Eric Lee / linux-smarc-t335x-v3.2

Commit 7e0a16f6118a297dd467c1e5a0908429fcdf56af

Authored by Mauro Carvalho Chehab 2009-03-10 16:31:34 +0800

Exists in master and in 4 other branches

V4L/DVB (10907): avoid loading the entire videodev.h header on V4L2 drivers

Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

Showing 16 changed files with 27 additions and 27 deletions Inline Diff

drivers/media/video/bt8xx/bttv.h
drivers/media/video/bt8xx/bttvp.h
drivers/media/video/cpia2/cpia2_v4l.c
drivers/media/video/cx23885/cx23885-video.c
drivers/media/video/cx88/cx88-video.c
drivers/media/video/msp3400-driver.c
drivers/media/video/ov7670.c
drivers/media/video/saa7134/saa7134-video.c
drivers/media/video/saa7146.h
drivers/media/video/v4l2-ioctl.c
drivers/media/video/vivi.c
drivers/media/video/w9966.c
drivers/media/video/w9968cf.c
drivers/media/video/zoran/zoran_driver.c
include/linux/videodev.h
include/media/v4l2-ioctl.h

drivers/media/video/bt8xx/bttv.h

Diff comments View file @ 7e0a16f

drivers/media/video/bt8xx/bttvp.h

Diff comments View file @ 7e0a16f

 /*
     bttv - Bt848 frame grabber driver
     bttv's *private* header file  --  nobody other than bttv itself
     should ever include this file.
     (c) 2000-2002 Gerd Knorr <kraxel@bytesex.org>
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 #ifndef _BTTVP_H_
 #define _BTTVP_H_
 #include <linux/version.h>
 #define BTTV_VERSION_CODE KERNEL_VERSION(0,9,17)
 #include <linux/types.h>
 #include <linux/wait.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
-#include <linux/videodev.h>
 #include <linux/pci.h>
 #include <linux/input.h>
 #include <linux/mutex.h>
 #include <linux/scatterlist.h>
 #include <asm/io.h>
 #include <media/v4l2-common.h>
 #include <linux/device.h>
 #include <media/videobuf-dma-sg.h>
 #include <media/tveeprom.h>
 #include <media/ir-common.h>
 #include "bt848.h"
 #include "bttv.h"
 #include "btcx-risc.h"
 #ifdef __KERNEL__
 #define FORMAT_FLAGS_DITHER       0x01
 #define FORMAT_FLAGS_PACKED       0x02
 #define FORMAT_FLAGS_PLANAR       0x04
 #define FORMAT_FLAGS_RAW          0x08
 #define FORMAT_FLAGS_CrCb         0x10
 #define RISC_SLOT_O_VBI        4
 #define RISC_SLOT_O_FIELD      6
 #define RISC_SLOT_E_VBI       10
 #define RISC_SLOT_E_FIELD     12
 #define RISC_SLOT_LOOP        14
 #define RESOURCE_OVERLAY       1
 #define RESOURCE_VIDEO_STREAM  2
 #define RESOURCE_VBI           4
 #define RESOURCE_VIDEO_READ    8
 #define RAW_LINES            640
 #define RAW_BPL             1024
 #define UNSET (-1U)
 /* Min. value in VDELAY register. */
 #define MIN_VDELAY 2
 /* Even to get Cb first, odd for Cr. */
 #define MAX_HDELAY (0x3FF & -2)
 /* Limits scaled width, which must be a multiple of 4. */
 #define MAX_HACTIVE (0x3FF & -4)
 #define BTTV_NORMS    (\
 		V4L2_STD_PAL    | V4L2_STD_PAL_N | \
 		V4L2_STD_PAL_Nc | V4L2_STD_SECAM | \
 		V4L2_STD_NTSC   | V4L2_STD_PAL_M | \
 		V4L2_STD_PAL_60)
 /* ---------------------------------------------------------- */
 struct bttv_tvnorm {
 	int   v4l2_id;
 	char  *name;
 	u32   Fsc;
 	u16   swidth, sheight; /* scaled standard width, height */
 	u16   totalwidth;
 	u8    adelay, bdelay, iform;
 	u32   scaledtwidth;
 	u16   hdelayx1, hactivex1;
 	u16   vdelay;
 	u8    vbipack;
 	u16   vtotal;
 	int   sram;
 	/* ITU-R frame line number of the first VBI line we can
 	   capture, of the first and second field. The last possible line
 	   is determined by cropcap.bounds. */
 	u16   vbistart[2];
 	/* Horizontally this counts fCLKx1 samples following the leading
 	   edge of the horizontal sync pulse, vertically ITU-R frame line
 	   numbers of the first field times two (2, 4, 6, ... 524 or 624). */
 	struct v4l2_cropcap cropcap;
 };
 extern const struct bttv_tvnorm bttv_tvnorms[];
 struct bttv_format {
 	char *name;
 	int  fourcc;          /* video4linux 2      */
 	int  btformat;        /* BT848_COLOR_FMT_*  */
 	int  btswap;          /* BT848_COLOR_CTL_*  */
 	int  depth;           /* bit/pixel          */
 	int  flags;
 	int  hshift,vshift;   /* for planar modes   */
 };
 /* ---------------------------------------------------------- */
 struct bttv_geometry {
 	u8  vtc,crop,comb;
 	u16 width,hscale,hdelay;
 	u16 sheight,vscale,vdelay,vtotal;
 };
 struct bttv_buffer {
 	/* common v4l buffer stuff -- must be first */
 	struct videobuf_buffer     vb;
 	/* bttv specific */
 	const struct bttv_format   *fmt;
 	unsigned int               tvnorm;
 	int                        btformat;
 	int                        btswap;
 	struct bttv_geometry       geo;
 	struct btcx_riscmem        top;
 	struct btcx_riscmem        bottom;
 	struct v4l2_rect           crop;
 	unsigned int               vbi_skip[2];
 	unsigned int               vbi_count[2];
 };
 struct bttv_buffer_set {
 	struct bttv_buffer     *top;       /* top field buffer    */
 	struct bttv_buffer     *bottom;    /* bottom field buffer */
 	unsigned int           top_irq;
 	unsigned int           frame_irq;
 };
 struct bttv_overlay {
 	unsigned int           tvnorm;
 	struct v4l2_rect       w;
 	enum v4l2_field        field;
 	struct v4l2_clip       *clips;
 	int                    nclips;
 	int                    setup_ok;
 };
 struct bttv_vbi_fmt {
 	struct v4l2_vbi_format fmt;
 	/* fmt.start[] and count[] refer to this video standard. */
 	const struct bttv_tvnorm *tvnorm;
 	/* Earliest possible start of video capturing with this
 	   v4l2_vbi_format, in struct bttv_crop.rect units. */
 	__s32                  end;
 };
 /* bttv-vbi.c */
 void bttv_vbi_fmt_reset(struct bttv_vbi_fmt *f, unsigned int norm);
 struct bttv_crop {
 	/* A cropping rectangle in struct bttv_tvnorm.cropcap units. */
 	struct v4l2_rect       rect;
 	/* Scaled image size limits with this crop rect. Divide
 	   max_height, but not min_height, by two when capturing
 	   single fields. See also bttv_crop_reset() and
 	   bttv_crop_adjust() in bttv-driver.c. */
 	__s32                  min_scaled_width;
 	__s32                  min_scaled_height;
 	__s32                  max_scaled_width;
 	__s32                  max_scaled_height;
 };
 struct bttv_fh {
 	struct bttv              *btv;
 	int resources;
 #ifdef VIDIOC_G_PRIORITY
 	enum v4l2_priority       prio;
 #endif
 	enum v4l2_buf_type       type;
 	/* video capture */
 	struct videobuf_queue    cap;
 	const struct bttv_format *fmt;
 	int                      width;
 	int                      height;
 	/* video overlay */
 	const struct bttv_format *ovfmt;
 	struct bttv_overlay      ov;
 	/* Application called VIDIOC_S_CROP. */
 	int                      do_crop;
 	/* vbi capture */
 	struct videobuf_queue    vbi;
 	/* Current VBI capture window as seen through this fh (cannot
 	   be global for compatibility with earlier drivers). Protected
 	   by struct bttv.lock and struct bttv_fh.vbi.lock. */
 	struct bttv_vbi_fmt      vbi_fmt;
 };
 /* ---------------------------------------------------------- */
 /* bttv-risc.c                                                */
 /* risc code generators - capture */
 int bttv_risc_packed(struct bttv *btv, struct btcx_riscmem *risc,
 		     struct scatterlist *sglist,
 		     unsigned int offset, unsigned int bpl,
 		     unsigned int pitch, unsigned int skip_lines,
 		     unsigned int store_lines);
 /* control dma register + risc main loop */
 void bttv_set_dma(struct bttv *btv, int override);
 int bttv_risc_init_main(struct bttv *btv);
 int bttv_risc_hook(struct bttv *btv, int slot, struct btcx_riscmem *risc,
 		   int irqflags);
 /* capture buffer handling */
 int bttv_buffer_risc(struct bttv *btv, struct bttv_buffer *buf);
 int bttv_buffer_activate_video(struct bttv *btv,
 			       struct bttv_buffer_set *set);
 int bttv_buffer_activate_vbi(struct bttv *btv,
 			     struct bttv_buffer *vbi);
 void bttv_dma_free(struct videobuf_queue *q, struct bttv *btv,
 		   struct bttv_buffer *buf);
 /* overlay handling */
 int bttv_overlay_risc(struct bttv *btv, struct bttv_overlay *ov,
 		      const struct bttv_format *fmt,
 		      struct bttv_buffer *buf);
 /* ---------------------------------------------------------- */
 /* bttv-vbi.c                                                 */
 int bttv_try_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f);
 int bttv_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f);
 int bttv_s_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f);
 extern struct videobuf_queue_ops bttv_vbi_qops;
 /* ---------------------------------------------------------- */
 /* bttv-gpio.c */
 extern struct bus_type bttv_sub_bus_type;
 int bttv_sub_add_device(struct bttv_core *core, char *name);
 int bttv_sub_del_devices(struct bttv_core *core);
 /* ---------------------------------------------------------- */
 /* bttv-cards.c                                               */
 extern int no_overlay;
 /* ---------------------------------------------------------- */
 /* bttv-driver.c                                              */
 /* insmod options */
 extern unsigned int bttv_verbose;
 extern unsigned int bttv_debug;
 extern unsigned int bttv_gpio;
 extern void bttv_gpio_tracking(struct bttv *btv, char *comment);
 extern int init_bttv_i2c(struct bttv *btv);
 extern int fini_bttv_i2c(struct bttv *btv);
 #define bttv_printk if (bttv_verbose) printk
 #define dprintk  if (bttv_debug >= 1) printk
 #define d2printk if (bttv_debug >= 2) printk
 #define BTTV_MAX_FBUF   0x208000
 #define BTTV_TIMEOUT    msecs_to_jiffies(500)    /* 0.5 seconds */
 #define BTTV_FREE_IDLE  msecs_to_jiffies(1000)   /* one second */
 struct bttv_pll_info {
 	unsigned int pll_ifreq;    /* PLL input frequency        */
 	unsigned int pll_ofreq;    /* PLL output frequency       */
 	unsigned int pll_crystal;  /* Crystal used for input     */
 	unsigned int pll_current;  /* Currently programmed ofreq */
 };
 /* for gpio-connected remote control */
 struct bttv_input {
 	struct input_dev      *dev;
 	struct ir_input_state ir;
 	char                  name[32];
 	char                  phys[32];
 	u32                   mask_keycode;
 	u32                   mask_keydown;
 };
 struct bttv_suspend_state {
 	u32  gpio_enable;
 	u32  gpio_data;
 	int  disabled;
 	int  loop_irq;
 	struct bttv_buffer_set video;
 	struct bttv_buffer     *vbi;
 };
 struct bttv {
 	struct bttv_core c;
 	/* pci device config */
 	unsigned short id;
 	unsigned char revision;
 	unsigned char __iomem *bt848_mmio;   /* pointer to mmio */
 	/* card configuration info */
 	unsigned int cardid;   /* pci subsystem id (bt878 based ones) */
 	unsigned int tuner_type;  /* tuner chip type */
 	unsigned int tda9887_conf;
 	unsigned int svhs, dig;
 	struct bttv_pll_info pll;
 	int triton1;
 	int gpioirq;
 	int (*custom_irq)(struct bttv *btv);
 	int use_i2c_hw;
 	/* old gpio interface */
 	wait_queue_head_t gpioq;
 	int shutdown;
 	void (*volume_gpio)(struct bttv *btv, __u16 volume);
 	void (*audio_mode_gpio)(struct bttv *btv, struct v4l2_tuner *tuner, int set);
 	/* new gpio interface */
 	spinlock_t gpio_lock;
 	/* i2c layer */
 	struct i2c_algo_bit_data   i2c_algo;
 	struct i2c_client          i2c_client;
 	int                        i2c_state, i2c_rc;
 	int                        i2c_done;
 	wait_queue_head_t          i2c_queue;
 	struct i2c_client 	  *i2c_msp34xx_client;
 	struct i2c_client 	  *i2c_tvaudio_client;
 	/* video4linux (1) */
 	struct video_device *video_dev;
 	struct video_device *radio_dev;
 	struct video_device *vbi_dev;
 	/* infrared remote */
 	int has_remote;
 	struct card_ir *remote;
 	/* locking */
 	spinlock_t s_lock;
 	struct mutex lock;
 	int resources;
 #ifdef VIDIOC_G_PRIORITY
 	struct v4l2_prio_state prio;
 #endif
 	/* video state */
 	unsigned int input;
 	unsigned int audio;
 	unsigned int mute;
 	unsigned long freq;
 	unsigned int tvnorm;
 	int hue, contrast, bright, saturation;
 	struct v4l2_framebuffer fbuf;
 	unsigned int field_count;
 	/* various options */
 	int opt_combfilter;
 	int opt_lumafilter;
 	int opt_automute;
 	int opt_chroma_agc;
 	int opt_adc_crush;
 	int opt_vcr_hack;
 	int opt_whitecrush_upper;
 	int opt_whitecrush_lower;
 	int opt_uv_ratio;
 	int opt_full_luma_range;
 	int opt_coring;
 	/* radio data/state */
 	int has_radio;
 	int radio_user;
 	/* miro/pinnacle + Aimslab VHX
 	   philips matchbox (tea5757 radio tuner) support */
 	int has_matchbox;
 	int mbox_we;
 	int mbox_data;
 	int mbox_clk;
 	int mbox_most;
 	int mbox_mask;
 	/* ISA stuff (Terratec Active Radio Upgrade) */
 	int mbox_ior;
 	int mbox_iow;
 	int mbox_csel;
 	/* risc memory management data
 	   - must acquire s_lock before changing these
 	   - only the irq handler is supported to touch top + bottom + vcurr */
 	struct btcx_riscmem     main;
 	struct bttv_buffer      *screen;    /* overlay             */
 	struct list_head        capture;    /* video capture queue */
 	struct list_head        vcapture;   /* vbi capture queue   */
 	struct bttv_buffer_set  curr;       /* active buffers      */
 	struct bttv_buffer      *cvbi;      /* active vbi buffer   */
 	int                     loop_irq;
 	int                     new_input;
 	unsigned long cap_ctl;
 	unsigned long dma_on;
 	struct timer_list timeout;
 	struct bttv_suspend_state state;
 	/* stats */
 	unsigned int errors;
 	unsigned int framedrop;
 	unsigned int irq_total;
 	unsigned int irq_me;
 	unsigned int users;
 	struct bttv_fh init;
 	/* used to make dvb-bt8xx autoloadable */
 	struct work_struct request_module_wk;
 	/* Default (0) and current (1) video capturing and overlay
 	   cropping parameters in bttv_tvnorm.cropcap units. Protected
 	   by bttv.lock. */
 	struct bttv_crop crop[2];
 	/* Earliest possible start of video capturing in
 	   bttv_tvnorm.cropcap line units. Set by check_alloc_btres()
 	   and free_btres(). Protected by bttv.lock. */
 	__s32			vbi_end;
 	/* Latest possible end of VBI capturing (= crop[x].rect.top when
 	   VIDEO_RESOURCES are locked). Set by check_alloc_btres()
 	   and free_btres(). Protected by bttv.lock. */
 	__s32			crop_start;
 };
 /* our devices */
 #define BTTV_MAX 32
 extern unsigned int bttv_num;
 extern struct bttv *bttvs[BTTV_MAX];
 static inline unsigned int bttv_muxsel(const struct bttv *btv,
 				       unsigned int input)
 {
 	return (bttv_tvcards[btv->c.type].muxsel >> (input * 2)) & 3;
 }
 #endif
 #define btwrite(dat,adr)    writel((dat), btv->bt848_mmio+(adr))
 #define btread(adr)         readl(btv->bt848_mmio+(adr))
 #define btand(dat,adr)      btwrite((dat) & btread(adr), adr)
 #define btor(dat,adr)       btwrite((dat) | btread(adr), adr)
 #define btaor(dat,mask,adr) btwrite((dat) | ((mask) & btread(adr)), adr)
 #endif /* _BTTVP_H_ */
 /*
  * Local variables:
  * c-basic-offset: 8
  * End:
  */

drivers/media/video/cpia2/cpia2_v4l.c

Diff comments View file @ 7e0a16f

 /****************************************************************************
  *
  *  Filename: cpia2_v4l.c
  *
  *  Copyright 2001, STMicrolectronics, Inc.
  *      Contact:  steve.miller@st.com
  *  Copyright 2001,2005, Scott J. Bertin <scottbertin@yahoo.com>
  *
  *  Description:
  *     This is a USB driver for CPia2 based video cameras.
  *     The infrastructure of this driver is based on the cpia usb driver by
  *     Jochen Scharrlach and Johannes Erdfeldt.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  *  Stripped of 2.4 stuff ready for main kernel submit by
  *		Alan Cox <alan@lxorguk.ukuu.org.uk>
  ****************************************************************************/
 #include <linux/version.h>
 #include <linux/module.h>
 #include <linux/time.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/init.h>
+#include <linux/videodev.h>
 #include <media/v4l2-ioctl.h>
 #include "cpia2.h"
 #include "cpia2dev.h"
 //#define _CPIA2_DEBUG_
 #define MAKE_STRING_1(x)	#x
 #define MAKE_STRING(x)	MAKE_STRING_1(x)
 static int video_nr = -1;
 module_param(video_nr, int, 0);
 MODULE_PARM_DESC(video_nr,"video device to register (0=/dev/video0, etc)");
 static int buffer_size = 68*1024;
 module_param(buffer_size, int, 0);
 MODULE_PARM_DESC(buffer_size, "Size for each frame buffer in bytes (default 68k)");
 static int num_buffers = 3;
 module_param(num_buffers, int, 0);
 MODULE_PARM_DESC(num_buffers, "Number of frame buffers (1-"
 		 MAKE_STRING(VIDEO_MAX_FRAME) ", default 3)");
 static int alternate = DEFAULT_ALT;
 module_param(alternate, int, 0);
 MODULE_PARM_DESC(alternate, "USB Alternate (" MAKE_STRING(USBIF_ISO_1) "-"
 		 MAKE_STRING(USBIF_ISO_6) ", default "
 		 MAKE_STRING(DEFAULT_ALT) ")");
 static int flicker_freq = 60;
 module_param(flicker_freq, int, 0);
 MODULE_PARM_DESC(flicker_freq, "Flicker frequency (" MAKE_STRING(50) "or"
 		 MAKE_STRING(60) ", default "
 		 MAKE_STRING(60) ")");
 static int flicker_mode = NEVER_FLICKER;
 module_param(flicker_mode, int, 0);
 MODULE_PARM_DESC(flicker_mode,
 		 "Flicker supression (" MAKE_STRING(NEVER_FLICKER) "or"
 		 MAKE_STRING(ANTI_FLICKER_ON) ", default "
 		 MAKE_STRING(NEVER_FLICKER) ")");
 MODULE_AUTHOR("Steve Miller (STMicroelectronics) <steve.miller@st.com>");
 MODULE_DESCRIPTION("V4L-driver for STMicroelectronics CPiA2 based cameras");
 MODULE_SUPPORTED_DEVICE("video");
 MODULE_LICENSE("GPL");
 #define ABOUT "V4L-Driver for Vision CPiA2 based cameras"
 struct control_menu_info {
 	int value;
 	char name[32];
 };
 static struct control_menu_info framerate_controls[] =
 {
 	{ CPIA2_VP_FRAMERATE_6_25, "6.25 fps" },
 	{ CPIA2_VP_FRAMERATE_7_5,  "7.5 fps"  },
 	{ CPIA2_VP_FRAMERATE_12_5, "12.5 fps" },
 	{ CPIA2_VP_FRAMERATE_15,   "15 fps"   },
 	{ CPIA2_VP_FRAMERATE_25,   "25 fps"   },
 	{ CPIA2_VP_FRAMERATE_30,   "30 fps"   },
 };
 #define NUM_FRAMERATE_CONTROLS (ARRAY_SIZE(framerate_controls))
 static struct control_menu_info flicker_controls[] =
 {
 	{ NEVER_FLICKER, "Off" },
 	{ FLICKER_50,    "50 Hz" },
 	{ FLICKER_60,    "60 Hz"  },
 };
 #define NUM_FLICKER_CONTROLS (ARRAY_SIZE(flicker_controls))
 static struct control_menu_info lights_controls[] =
 {
 	{ 0,   "Off" },
 	{ 64,  "Top" },
 	{ 128, "Bottom"  },
 	{ 192, "Both"  },
 };
 #define NUM_LIGHTS_CONTROLS (ARRAY_SIZE(lights_controls))
 #define GPIO_LIGHTS_MASK 192
 static struct v4l2_queryctrl controls[] = {
 	{
 		.id            = V4L2_CID_BRIGHTNESS,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "Brightness",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 1,
 		.default_value = DEFAULT_BRIGHTNESS,
 	},
 	{
 		.id            = V4L2_CID_CONTRAST,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "Contrast",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 1,
 		.default_value = DEFAULT_CONTRAST,
 	},
 	{
 		.id            = V4L2_CID_SATURATION,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "Saturation",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 1,
 		.default_value = DEFAULT_SATURATION,
 	},
 	{
 		.id            = V4L2_CID_HFLIP,
 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
 		.name          = "Mirror Horizontally",
 		.minimum       = 0,
 		.maximum       = 1,
 		.step          = 1,
 		.default_value = 0,
 	},
 	{
 		.id            = V4L2_CID_VFLIP,
 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
 		.name          = "Flip Vertically",
 		.minimum       = 0,
 		.maximum       = 1,
 		.step          = 1,
 		.default_value = 0,
 	},
 	{
 		.id            = CPIA2_CID_TARGET_KB,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "Target KB",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 1,
 		.default_value = DEFAULT_TARGET_KB,
 	},
 	{
 		.id            = CPIA2_CID_GPIO,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "GPIO",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 1,
 		.default_value = 0,
 	},
 	{
 		.id            = CPIA2_CID_FLICKER_MODE,
 		.type          = V4L2_CTRL_TYPE_MENU,
 		.name          = "Flicker Reduction",
 		.minimum       = 0,
 		.maximum       = NUM_FLICKER_CONTROLS-1,
 		.step          = 1,
 		.default_value = 0,
 	},
 	{
 		.id            = CPIA2_CID_FRAMERATE,
 		.type          = V4L2_CTRL_TYPE_MENU,
 		.name          = "Framerate",
 		.minimum       = 0,
 		.maximum       = NUM_FRAMERATE_CONTROLS-1,
 		.step          = 1,
 		.default_value = NUM_FRAMERATE_CONTROLS-1,
 	},
 	{
 		.id            = CPIA2_CID_USB_ALT,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "USB Alternate",
 		.minimum       = USBIF_ISO_1,
 		.maximum       = USBIF_ISO_6,
 		.step          = 1,
 		.default_value = DEFAULT_ALT,
 	},
 	{
 		.id            = CPIA2_CID_LIGHTS,
 		.type          = V4L2_CTRL_TYPE_MENU,
 		.name          = "Lights",
 		.minimum       = 0,
 		.maximum       = NUM_LIGHTS_CONTROLS-1,
 		.step          = 1,
 		.default_value = 0,
 	},
 	{
 		.id            = CPIA2_CID_RESET_CAMERA,
 		.type          = V4L2_CTRL_TYPE_BUTTON,
 		.name          = "Reset Camera",
 		.minimum       = 0,
 		.maximum       = 0,
 		.step          = 0,
 		.default_value = 0,
 	},
 };
 #define NUM_CONTROLS (ARRAY_SIZE(controls))
 /******************************************************************************
  *
  *  cpia2_open
  *
  *****************************************************************************/
 static int cpia2_open(struct file *file)
 {
 	struct camera_data *cam = video_drvdata(file);
 	int retval = 0;
 	if (!cam) {
 		ERR("Internal error, camera_data not found!\n");
 		return -ENODEV;
 	}
 	if(mutex_lock_interruptible(&cam->busy_lock))
 		return -ERESTARTSYS;
 	if(!cam->present) {
 		retval = -ENODEV;
 		goto err_return;
 	}
 	if (cam->open_count > 0) {
 		goto skip_init;
 	}
 	if (cpia2_allocate_buffers(cam)) {
 		retval = -ENOMEM;
 		goto err_return;
 	}
 	/* reset the camera */
 	if (cpia2_reset_camera(cam) < 0) {
 		retval = -EIO;
 		goto err_return;
 	}
 	cam->APP_len = 0;
 	cam->COM_len = 0;
 skip_init:
 	{
 		struct cpia2_fh *fh = kmalloc(sizeof(*fh),GFP_KERNEL);
 		if(!fh) {
 			retval = -ENOMEM;
 			goto err_return;
 		}
 		file->private_data = fh;
 		fh->prio = V4L2_PRIORITY_UNSET;
 		v4l2_prio_open(&cam->prio, &fh->prio);
 		fh->mmapped = 0;
 	}
 	++cam->open_count;
 	cpia2_dbg_dump_registers(cam);
 err_return:
 	mutex_unlock(&cam->busy_lock);
 	return retval;
 }
 /******************************************************************************
  *
  *  cpia2_close
  *
  *****************************************************************************/
 static int cpia2_close(struct file *file)
 {
 	struct video_device *dev = video_devdata(file);
 	struct camera_data *cam = video_get_drvdata(dev);
 	struct cpia2_fh *fh = file->private_data;
 	mutex_lock(&cam->busy_lock);
 	if (cam->present &&
 	    (cam->open_count == 1
 	     || fh->prio == V4L2_PRIORITY_RECORD
 	    )) {
 		cpia2_usb_stream_stop(cam);
 		if(cam->open_count == 1) {
 			/* save camera state for later open */
 			cpia2_save_camera_state(cam);
 			cpia2_set_low_power(cam);
 			cpia2_free_buffers(cam);
 		}
 	}
 	{
 		if(fh->mmapped)
 			cam->mmapped = 0;
 		v4l2_prio_close(&cam->prio,&fh->prio);
 		file->private_data = NULL;
 		kfree(fh);
 	}
 	if (--cam->open_count == 0) {
 		cpia2_free_buffers(cam);
 		if (!cam->present) {
 			video_unregister_device(dev);
 			mutex_unlock(&cam->busy_lock);
 			kfree(cam);
 			return 0;
 		}
 	}
 	mutex_unlock(&cam->busy_lock);
 	return 0;
 }
 /******************************************************************************
  *
  *  cpia2_v4l_read
  *
  *****************************************************************************/
 static ssize_t cpia2_v4l_read(struct file *file, char __user *buf, size_t count,
 			      loff_t *off)
 {
 	struct camera_data *cam = video_drvdata(file);
 	int noblock = file->f_flags&O_NONBLOCK;
 	struct cpia2_fh *fh = file->private_data;
 	if(!cam)
 		return -EINVAL;
 	/* Priority check */
 	if(fh->prio != V4L2_PRIORITY_RECORD) {
 		return -EBUSY;
 	}
 	return cpia2_read(cam, buf, count, noblock);
 }
 /******************************************************************************
  *
  *  cpia2_v4l_poll
  *
  *****************************************************************************/
 static unsigned int cpia2_v4l_poll(struct file *filp, struct poll_table_struct *wait)
 {
 	struct camera_data *cam = video_drvdata(filp);
 	struct cpia2_fh *fh = filp->private_data;
 	if(!cam)
 		return POLLERR;
 	/* Priority check */
 	if(fh->prio != V4L2_PRIORITY_RECORD) {
 		return POLLERR;
 	}
 	return cpia2_poll(cam, filp, wait);
 }
 /******************************************************************************
  *
  *  ioctl_cap_query
  *
  *****************************************************************************/
 static int ioctl_cap_query(void *arg, struct camera_data *cam)
 {
 	struct video_capability *vc;
 	int retval = 0;
 	vc = arg;
 	if (cam->params.pnp_id.product == 0x151)
 		strcpy(vc->name, "QX5 Microscope");
 	else
 		strcpy(vc->name, "CPiA2 Camera");
 	vc->type = VID_TYPE_CAPTURE | VID_TYPE_MJPEG_ENCODER;
 	vc->channels = 1;
 	vc->audios = 0;
 	vc->minwidth = 176;	/* VIDEOSIZE_QCIF */
 	vc->minheight = 144;
 	switch (cam->params.version.sensor_flags) {
 	case CPIA2_VP_SENSOR_FLAGS_500:
 		vc->maxwidth = STV_IMAGE_VGA_COLS;
 		vc->maxheight = STV_IMAGE_VGA_ROWS;
 		break;
 	case CPIA2_VP_SENSOR_FLAGS_410:
 		vc->maxwidth = STV_IMAGE_CIF_COLS;
 		vc->maxheight = STV_IMAGE_CIF_ROWS;
 		break;
 	default:
 		return -EINVAL;
 	}
 	return retval;
 }
 /******************************************************************************
  *
  *  ioctl_get_channel
  *
  *****************************************************************************/
 static int ioctl_get_channel(void *arg)
 {
 	int retval = 0;
 	struct video_channel *v;
 	v = arg;
 	if (v->channel != 0)
 		return -EINVAL;
 	v->channel = 0;
 	strcpy(v->name, "Camera");
 	v->tuners = 0;
 	v->flags = 0;
 	v->type = VIDEO_TYPE_CAMERA;
 	v->norm = 0;
 	return retval;
 }
 /******************************************************************************
  *
  *  ioctl_set_channel
  *
  *****************************************************************************/
 static int ioctl_set_channel(void *arg)
 {
 	struct video_channel *v;
 	int retval = 0;
 	v = arg;
 	if (retval == 0 && v->channel != 0)
 		retval = -EINVAL;
 	return retval;
 }
 /******************************************************************************
  *
  *  ioctl_set_image_prop
  *
  *****************************************************************************/
 static int ioctl_set_image_prop(void *arg, struct camera_data *cam)
 {
 	struct video_picture *vp;
 	int retval = 0;
 	vp = arg;
 	/* brightness, color, contrast need no check 0-65535 */
 	memcpy(&cam->vp, vp, sizeof(*vp));
 	/* update cam->params.colorParams */
 	cam->params.color_params.brightness = vp->brightness / 256;
 	cam->params.color_params.saturation = vp->colour / 256;
 	cam->params.color_params.contrast = vp->contrast / 256;
 	DBG("Requested params: bright 0x%X, sat 0x%X, contrast 0x%X\n",
 	    cam->params.color_params.brightness,
 	    cam->params.color_params.saturation,
 	    cam->params.color_params.contrast);
 	cpia2_set_color_params(cam);
 	return retval;
 }
 static int sync(struct camera_data *cam, int frame_nr)
 {
 	struct framebuf *frame = &cam->buffers[frame_nr];
 	while (1) {
 		if (frame->status == FRAME_READY)
 			return 0;
 		if (!cam->streaming) {
 			frame->status = FRAME_READY;
 			frame->length = 0;
 			return 0;
 		}
 		mutex_unlock(&cam->busy_lock);
 		wait_event_interruptible(cam->wq_stream,
 					 !cam->streaming ||
 					 frame->status == FRAME_READY);
 		mutex_lock(&cam->busy_lock);
 		if (signal_pending(current))
 			return -ERESTARTSYS;
 		if(!cam->present)
 			return -ENOTTY;
 	}
 }
 /******************************************************************************
  *
  *  ioctl_set_window_size
  *
  *****************************************************************************/
 static int ioctl_set_window_size(void *arg, struct camera_data *cam,
 				 struct cpia2_fh *fh)
 {
 	/* copy_from_user, check validity, copy to internal structure */
 	struct video_window *vw;
 	int frame, err;
 	vw = arg;
 	if (vw->clipcount != 0)	/* clipping not supported */
 		return -EINVAL;
 	if (vw->clips != NULL)	/* clipping not supported */
 		return -EINVAL;
 	/* Ensure that only this process can change the format. */
 	err = v4l2_prio_change(&cam->prio, &fh->prio, V4L2_PRIORITY_RECORD);
 	if(err != 0)
 		return err;
 	cam->pixelformat = V4L2_PIX_FMT_JPEG;
 	/* Be sure to supply the Huffman tables, this isn't MJPEG */
 	cam->params.compression.inhibit_htables = 0;
 	/* we set the video window to something smaller or equal to what
 	 * is requested by the user???
 	 */
 	DBG("Requested width = %d, height = %d\n", vw->width, vw->height);
 	if (vw->width != cam->vw.width || vw->height != cam->vw.height) {
 		cam->vw.width = vw->width;
 		cam->vw.height = vw->height;
 		cam->params.roi.width = vw->width;
 		cam->params.roi.height = vw->height;
 		cpia2_set_format(cam);
 	}
 	for (frame = 0; frame < cam->num_frames; ++frame) {
 		if (cam->buffers[frame].status == FRAME_READING)
 			if ((err = sync(cam, frame)) < 0)
 				return err;
 		cam->buffers[frame].status = FRAME_EMPTY;
 	}
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_get_mbuf
  *
  *****************************************************************************/
 static int ioctl_get_mbuf(void *arg, struct camera_data *cam)
 {
 	struct video_mbuf *vm;
 	int i;
 	vm = arg;
 	memset(vm, 0, sizeof(*vm));
 	vm->size = cam->frame_size*cam->num_frames;
 	vm->frames = cam->num_frames;
 	for (i = 0; i < cam->num_frames; i++)
 		vm->offsets[i] = cam->frame_size * i;
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_mcapture
  *
  *****************************************************************************/
 static int ioctl_mcapture(void *arg, struct camera_data *cam,
 			  struct cpia2_fh *fh)
 {
 	struct video_mmap *vm;
 	int video_size, err;
 	vm = arg;
 	if (vm->frame < 0 || vm->frame >= cam->num_frames)
 		return -EINVAL;
 	/* set video size */
 	video_size = cpia2_match_video_size(vm->width, vm->height);
 	if (cam->video_size < 0) {
 		return -EINVAL;
 	}
 	/* Ensure that only this process can change the format. */
 	err = v4l2_prio_change(&cam->prio, &fh->prio, V4L2_PRIORITY_RECORD);
 	if(err != 0)
 		return err;
 	if (video_size != cam->video_size) {
 		cam->video_size = video_size;
 		cam->params.roi.width = vm->width;
 		cam->params.roi.height = vm->height;
 		cpia2_set_format(cam);
 	}
 	if (cam->buffers[vm->frame].status == FRAME_READING)
 		if ((err=sync(cam, vm->frame)) < 0)
 			return err;
 	cam->buffers[vm->frame].status = FRAME_EMPTY;
 	return cpia2_usb_stream_start(cam,cam->params.camera_state.stream_mode);
 }
 /******************************************************************************
  *
  *  ioctl_sync
  *
  *****************************************************************************/
 static int ioctl_sync(void *arg, struct camera_data *cam)
 {
 	int frame;
 	frame = *(int*)arg;
 	if (frame < 0 || frame >= cam->num_frames)
 		return -EINVAL;
 	return sync(cam, frame);
 }
 /******************************************************************************
  *
  *  ioctl_set_gpio
  *
  *****************************************************************************/
 static int ioctl_set_gpio(void *arg, struct camera_data *cam)
 {
 	__u32 gpio_val;
 	gpio_val = *(__u32*) arg;
 	if (gpio_val &~ 0xFFU)
 		return -EINVAL;
 	return cpia2_set_gpio(cam, (unsigned char)gpio_val);
 }
 /******************************************************************************
  *
  *  ioctl_querycap
  *
  *  V4L2 device capabilities
  *
  *****************************************************************************/
 static int ioctl_querycap(void *arg, struct camera_data *cam)
 {
 	struct v4l2_capability *vc = arg;
 	memset(vc, 0, sizeof(*vc));
 	strcpy(vc->driver, "cpia2");
 	if (cam->params.pnp_id.product == 0x151)
 		strcpy(vc->card, "QX5 Microscope");
 	else
 		strcpy(vc->card, "CPiA2 Camera");
 	switch (cam->params.pnp_id.device_type) {
 	case DEVICE_STV_672:
 		strcat(vc->card, " (672/");
 		break;
 	case DEVICE_STV_676:
 		strcat(vc->card, " (676/");
 		break;
 	default:
 		strcat(vc->card, " (???/");
 		break;
 	}
 	switch (cam->params.version.sensor_flags) {
 	case CPIA2_VP_SENSOR_FLAGS_404:
 		strcat(vc->card, "404)");
 		break;
 	case CPIA2_VP_SENSOR_FLAGS_407:
 		strcat(vc->card, "407)");
 		break;
 	case CPIA2_VP_SENSOR_FLAGS_409:
 		strcat(vc->card, "409)");
 		break;
 	case CPIA2_VP_SENSOR_FLAGS_410:
 		strcat(vc->card, "410)");
 		break;
 	case CPIA2_VP_SENSOR_FLAGS_500:
 		strcat(vc->card, "500)");
 		break;
 	default:
 		strcat(vc->card, "???)");
 		break;
 	}
 	if (usb_make_path(cam->dev, vc->bus_info, sizeof(vc->bus_info)) <0)
 		memset(vc->bus_info,0, sizeof(vc->bus_info));
 	vc->version = KERNEL_VERSION(CPIA2_MAJ_VER, CPIA2_MIN_VER,
 				     CPIA2_PATCH_VER);
 	vc->capabilities = V4L2_CAP_VIDEO_CAPTURE |
 			   V4L2_CAP_READWRITE |
 			   V4L2_CAP_STREAMING;
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_input
  *
  *  V4L2 input get/set/enumerate
  *
  *****************************************************************************/
 static int ioctl_input(unsigned int ioclt_nr,void *arg,struct camera_data *cam)
 {
 	struct v4l2_input *i = arg;
 	if(ioclt_nr  != VIDIOC_G_INPUT) {
 		if (i->index != 0)
 		       return -EINVAL;
 	}
 	memset(i, 0, sizeof(*i));
 	strcpy(i->name, "Camera");
 	i->type = V4L2_INPUT_TYPE_CAMERA;
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_enum_fmt
  *
  *  V4L2 format enumerate
  *
  *****************************************************************************/
 static int ioctl_enum_fmt(void *arg,struct camera_data *cam)
 {
 	struct v4l2_fmtdesc *f = arg;
 	int index = f->index;
 	if (index < 0 || index > 1)
 	       return -EINVAL;
 	memset(f, 0, sizeof(*f));
 	f->index = index;
 	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 	f->flags = V4L2_FMT_FLAG_COMPRESSED;
 	switch(index) {
 	case 0:
 		strcpy(f->description, "MJPEG");
 		f->pixelformat = V4L2_PIX_FMT_MJPEG;
 		break;
 	case 1:
 		strcpy(f->description, "JPEG");
 		f->pixelformat = V4L2_PIX_FMT_JPEG;
 		break;
 	default:
 		return -EINVAL;
 	}
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_try_fmt
  *
  *  V4L2 format try
  *
  *****************************************************************************/
 static int ioctl_try_fmt(void *arg,struct camera_data *cam)
 {
 	struct v4l2_format *f = arg;
 	if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 	       return -EINVAL;
 	if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG &&
 	    f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
 	       return -EINVAL;
 	f->fmt.pix.field = V4L2_FIELD_NONE;
 	f->fmt.pix.bytesperline = 0;
 	f->fmt.pix.sizeimage = cam->frame_size;
 	f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
 	f->fmt.pix.priv = 0;
 	switch (cpia2_match_video_size(f->fmt.pix.width, f->fmt.pix.height)) {
 	case VIDEOSIZE_VGA:
 		f->fmt.pix.width = 640;
 		f->fmt.pix.height = 480;
 		break;
 	case VIDEOSIZE_CIF:
 		f->fmt.pix.width = 352;
 		f->fmt.pix.height = 288;
 		break;
 	case VIDEOSIZE_QVGA:
 		f->fmt.pix.width = 320;
 		f->fmt.pix.height = 240;
 		break;
 	case VIDEOSIZE_288_216:
 		f->fmt.pix.width = 288;
 		f->fmt.pix.height = 216;
 		break;
 	case VIDEOSIZE_256_192:
 		f->fmt.pix.width = 256;
 		f->fmt.pix.height = 192;
 		break;
 	case VIDEOSIZE_224_168:
 		f->fmt.pix.width = 224;
 		f->fmt.pix.height = 168;
 		break;
 	case VIDEOSIZE_192_144:
 		f->fmt.pix.width = 192;
 		f->fmt.pix.height = 144;
 		break;
 	case VIDEOSIZE_QCIF:
 	default:
 		f->fmt.pix.width = 176;
 		f->fmt.pix.height = 144;
 		break;
 	}
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_set_fmt
  *
  *  V4L2 format set
  *
  *****************************************************************************/
 static int ioctl_set_fmt(void *arg,struct camera_data *cam, struct cpia2_fh *fh)
 {
 	struct v4l2_format *f = arg;
 	int err, frame;
 	err = ioctl_try_fmt(arg, cam);
 	if(err != 0)
 		return err;
 	/* Ensure that only this process can change the format. */
 	err = v4l2_prio_change(&cam->prio, &fh->prio, V4L2_PRIORITY_RECORD);
 	if(err != 0) {
 		return err;
 	}
 	cam->pixelformat = f->fmt.pix.pixelformat;
 	/* NOTE: This should be set to 1 for MJPEG, but some apps don't handle
 	 * the missing Huffman table properly. */
 	cam->params.compression.inhibit_htables = 0;
 		/*f->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG;*/
 	/* we set the video window to something smaller or equal to what
 	 * is requested by the user???
 	 */
 	DBG("Requested width = %d, height = %d\n",
 	    f->fmt.pix.width, f->fmt.pix.height);
 	if (f->fmt.pix.width != cam->vw.width ||
 	    f->fmt.pix.height != cam->vw.height) {
 		cam->vw.width = f->fmt.pix.width;
 		cam->vw.height = f->fmt.pix.height;
 		cam->params.roi.width = f->fmt.pix.width;
 		cam->params.roi.height = f->fmt.pix.height;
 		cpia2_set_format(cam);
 	}
 	for (frame = 0; frame < cam->num_frames; ++frame) {
 		if (cam->buffers[frame].status == FRAME_READING)
 			if ((err = sync(cam, frame)) < 0)
 				return err;
 		cam->buffers[frame].status = FRAME_EMPTY;
 	}
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_get_fmt
  *
  *  V4L2 format get
  *
  *****************************************************************************/
 static int ioctl_get_fmt(void *arg,struct camera_data *cam)
 {
 	struct v4l2_format *f = arg;
 	if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 	       return -EINVAL;
 	f->fmt.pix.width = cam->vw.width;
 	f->fmt.pix.height = cam->vw.height;
 	f->fmt.pix.pixelformat = cam->pixelformat;
 	f->fmt.pix.field = V4L2_FIELD_NONE;
 	f->fmt.pix.bytesperline = 0;
 	f->fmt.pix.sizeimage = cam->frame_size;
 	f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
 	f->fmt.pix.priv = 0;
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_cropcap
  *
  *  V4L2 query cropping capabilities
  *  NOTE: cropping is currently disabled
  *
  *****************************************************************************/
 static int ioctl_cropcap(void *arg,struct camera_data *cam)
 {
 	struct v4l2_cropcap *c = arg;
 	if (c->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 	       return -EINVAL;
 	c->bounds.left = 0;
 	c->bounds.top = 0;
 	c->bounds.width = cam->vw.width;
 	c->bounds.height = cam->vw.height;
 	c->defrect.left = 0;
 	c->defrect.top = 0;
 	c->defrect.width = cam->vw.width;
 	c->defrect.height = cam->vw.height;
 	c->pixelaspect.numerator = 1;
 	c->pixelaspect.denominator = 1;
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_queryctrl
  *
  *  V4L2 query possible control variables
  *
  *****************************************************************************/
 static int ioctl_queryctrl(void *arg,struct camera_data *cam)
 {
 	struct v4l2_queryctrl *c = arg;
 	int i;
 	for(i=0; i<NUM_CONTROLS; ++i) {
 		if(c->id == controls[i].id) {
 			memcpy(c, controls+i, sizeof(*c));
 			break;
 		}
 	}
 	if(i == NUM_CONTROLS)
 		return -EINVAL;
 	/* Some devices have additional limitations */
 	switch(c->id) {
 	case V4L2_CID_BRIGHTNESS:
 		/***
 		 * Don't let the register be set to zero - bug in VP4
 		 * flash of full brightness
 		 ***/
 		if (cam->params.pnp_id.device_type == DEVICE_STV_672)
 			c->minimum = 1;
 		break;
 	case V4L2_CID_VFLIP:
 		// VP5 Only
 		if(cam->params.pnp_id.device_type == DEVICE_STV_672)
 			c->flags |= V4L2_CTRL_FLAG_DISABLED;
 		break;
 	case CPIA2_CID_FRAMERATE:
 		if(cam->params.pnp_id.device_type == DEVICE_STV_672 &&
 		   cam->params.version.sensor_flags==CPIA2_VP_SENSOR_FLAGS_500){
 			// Maximum 15fps
 			for(i=0; i<c->maximum; ++i) {
 				if(framerate_controls[i].value ==
 				   CPIA2_VP_FRAMERATE_15) {
 					c->maximum = i;
 					c->default_value = i;
 				}
 			}
 		}
 		break;
 	case CPIA2_CID_FLICKER_MODE:
 		// Flicker control only valid for 672.
 		if(cam->params.pnp_id.device_type != DEVICE_STV_672)
 			c->flags |= V4L2_CTRL_FLAG_DISABLED;
 		break;
 	case CPIA2_CID_LIGHTS:
 		// Light control only valid for the QX5 Microscope.
 		if(cam->params.pnp_id.product != 0x151)
 			c->flags |= V4L2_CTRL_FLAG_DISABLED;
 		break;
 	default:
 		break;
 	}
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_querymenu
  *
  *  V4L2 query possible control variables
  *
  *****************************************************************************/
 static int ioctl_querymenu(void *arg,struct camera_data *cam)
 {
 	struct v4l2_querymenu *m = arg;
 	memset(m->name, 0, sizeof(m->name));
 	m->reserved = 0;
 	switch(m->id) {
 	case CPIA2_CID_FLICKER_MODE:
 		if(m->index < 0 || m->index >= NUM_FLICKER_CONTROLS)
 			return -EINVAL;
 		strcpy(m->name, flicker_controls[m->index].name);
 		break;
 	case CPIA2_CID_FRAMERATE:
 	    {
 		int maximum = NUM_FRAMERATE_CONTROLS - 1;
 		if(cam->params.pnp_id.device_type == DEVICE_STV_672 &&
 		   cam->params.version.sensor_flags==CPIA2_VP_SENSOR_FLAGS_500){
 			// Maximum 15fps
 			int i;
 			for(i=0; i<maximum; ++i) {
 				if(framerate_controls[i].value ==
 				   CPIA2_VP_FRAMERATE_15)
 					maximum = i;
 			}
 		}
 		if(m->index < 0 || m->index > maximum)
 			return -EINVAL;
 		strcpy(m->name, framerate_controls[m->index].name);
 		break;
 	    }
 	case CPIA2_CID_LIGHTS:
 		if(m->index < 0 || m->index >= NUM_LIGHTS_CONTROLS)
 			return -EINVAL;
 		strcpy(m->name, lights_controls[m->index].name);
 		break;
 	default:
 		return -EINVAL;
 	}
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_g_ctrl
  *
  *  V4L2 get the value of a control variable
  *
  *****************************************************************************/
 static int ioctl_g_ctrl(void *arg,struct camera_data *cam)
 {
 	struct v4l2_control *c = arg;
 	switch(c->id) {
 	case V4L2_CID_BRIGHTNESS:
 		cpia2_do_command(cam, CPIA2_CMD_GET_VP_BRIGHTNESS,
 				 TRANSFER_READ, 0);
 		c->value = cam->params.color_params.brightness;
 		break;
 	case V4L2_CID_CONTRAST:
 		cpia2_do_command(cam, CPIA2_CMD_GET_CONTRAST,
 				 TRANSFER_READ, 0);
 		c->value = cam->params.color_params.contrast;
 		break;
 	case V4L2_CID_SATURATION:
 		cpia2_do_command(cam, CPIA2_CMD_GET_VP_SATURATION,
 				 TRANSFER_READ, 0);
 		c->value = cam->params.color_params.saturation;
 		break;
 	case V4L2_CID_HFLIP:
 		cpia2_do_command(cam, CPIA2_CMD_GET_USER_EFFECTS,
 				 TRANSFER_READ, 0);
 		c->value = (cam->params.vp_params.user_effects &
 			    CPIA2_VP_USER_EFFECTS_MIRROR) != 0;
 		break;
 	case V4L2_CID_VFLIP:
 		cpia2_do_command(cam, CPIA2_CMD_GET_USER_EFFECTS,
 				 TRANSFER_READ, 0);
 		c->value = (cam->params.vp_params.user_effects &
 			    CPIA2_VP_USER_EFFECTS_FLIP) != 0;
 		break;
 	case CPIA2_CID_TARGET_KB:
 		c->value = cam->params.vc_params.target_kb;
 		break;
 	case CPIA2_CID_GPIO:
 		cpia2_do_command(cam, CPIA2_CMD_GET_VP_GPIO_DATA,
 				 TRANSFER_READ, 0);
 		c->value = cam->params.vp_params.gpio_data;
 		break;
 	case CPIA2_CID_FLICKER_MODE:
 	{
 		int i, mode;
 		cpia2_do_command(cam, CPIA2_CMD_GET_FLICKER_MODES,
 				 TRANSFER_READ, 0);
 		if(cam->params.flicker_control.cam_register &
 		   CPIA2_VP_FLICKER_MODES_NEVER_FLICKER) {
 			mode = NEVER_FLICKER;
 		} else {
 		    if(cam->params.flicker_control.cam_register &
 		       CPIA2_VP_FLICKER_MODES_50HZ) {
 			mode = FLICKER_50;
 		    } else {
 			mode = FLICKER_60;
 		    }
 		}
 		for(i=0; i<NUM_FLICKER_CONTROLS; i++) {
 			if(flicker_controls[i].value == mode) {
 				c->value = i;
 				break;
 			}
 		}
 		if(i == NUM_FLICKER_CONTROLS)
 			return -EINVAL;
 		break;
 	}
 	case CPIA2_CID_FRAMERATE:
 	{
 		int maximum = NUM_FRAMERATE_CONTROLS - 1;
 		int i;
 		for(i=0; i<= maximum; i++) {
 			if(cam->params.vp_params.frame_rate ==
 			   framerate_controls[i].value)
 				break;
 		}
 		if(i > maximum)
 			return -EINVAL;
 		c->value = i;
 		break;
 	}
 	case CPIA2_CID_USB_ALT:
 		c->value = cam->params.camera_state.stream_mode;
 		break;
 	case CPIA2_CID_LIGHTS:
 	{
 		int i;
 		cpia2_do_command(cam, CPIA2_CMD_GET_VP_GPIO_DATA,
 				 TRANSFER_READ, 0);
 		for(i=0; i<NUM_LIGHTS_CONTROLS; i++) {
 			if((cam->params.vp_params.gpio_data&GPIO_LIGHTS_MASK) ==
 			   lights_controls[i].value) {
 				break;
 			}
 		}
 		if(i == NUM_LIGHTS_CONTROLS)
 			return -EINVAL;
 		c->value = i;
 		break;
 	}
 	case CPIA2_CID_RESET_CAMERA:
 		return -EINVAL;
 	default:
 		return -EINVAL;
 	}
 	DBG("Get control id:%d, value:%d\n", c->id, c->value);
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_s_ctrl
  *
  *  V4L2 set the value of a control variable
  *
  *****************************************************************************/
 static int ioctl_s_ctrl(void *arg,struct camera_data *cam)
 {
 	struct v4l2_control *c = arg;
 	int i;
 	int retval = 0;
 	DBG("Set control id:%d, value:%d\n", c->id, c->value);
 	/* Check that the value is in range */
 	for(i=0; i<NUM_CONTROLS; i++) {
 		if(c->id == controls[i].id) {
 			if(c->value < controls[i].minimum ||
 			   c->value > controls[i].maximum) {
 				return -EINVAL;
 			}
 			break;
 		}
 	}
 	if(i == NUM_CONTROLS)
 		return -EINVAL;
 	switch(c->id) {
 	case V4L2_CID_BRIGHTNESS:
 		cpia2_set_brightness(cam, c->value);
 		break;
 	case V4L2_CID_CONTRAST:
 		cpia2_set_contrast(cam, c->value);
 		break;
 	case V4L2_CID_SATURATION:
 		cpia2_set_saturation(cam, c->value);
 		break;
 	case V4L2_CID_HFLIP:
 		cpia2_set_property_mirror(cam, c->value);
 		break;
 	case V4L2_CID_VFLIP:
 		cpia2_set_property_flip(cam, c->value);
 		break;
 	case CPIA2_CID_TARGET_KB:
 		retval = cpia2_set_target_kb(cam, c->value);
 		break;
 	case CPIA2_CID_GPIO:
 		retval = cpia2_set_gpio(cam, c->value);
 		break;
 	case CPIA2_CID_FLICKER_MODE:
 		retval = cpia2_set_flicker_mode(cam,
 					      flicker_controls[c->value].value);
 		break;
 	case CPIA2_CID_FRAMERATE:
 		retval = cpia2_set_fps(cam, framerate_controls[c->value].value);
 		break;
 	case CPIA2_CID_USB_ALT:
 		retval = cpia2_usb_change_streaming_alternate(cam, c->value);
 		break;
 	case CPIA2_CID_LIGHTS:
 		retval = cpia2_set_gpio(cam, lights_controls[c->value].value);
 		break;
 	case CPIA2_CID_RESET_CAMERA:
 		cpia2_usb_stream_pause(cam);
 		cpia2_reset_camera(cam);
 		cpia2_usb_stream_resume(cam);
 		break;
 	default:
 		retval = -EINVAL;
 	}
 	return retval;
 }
 /******************************************************************************
  *
  *  ioctl_g_jpegcomp
  *
  *  V4L2 get the JPEG compression parameters
  *
  *****************************************************************************/
 static int ioctl_g_jpegcomp(void *arg,struct camera_data *cam)
 {
 	struct v4l2_jpegcompression *parms = arg;
 	memset(parms, 0, sizeof(*parms));
 	parms->quality = 80; // TODO: Can this be made meaningful?
 	parms->jpeg_markers = V4L2_JPEG_MARKER_DQT | V4L2_JPEG_MARKER_DRI;
 	if(!cam->params.compression.inhibit_htables) {
 		parms->jpeg_markers |= V4L2_JPEG_MARKER_DHT;
 	}
 	parms->APPn = cam->APPn;
 	parms->APP_len = cam->APP_len;
 	if(cam->APP_len > 0) {
 		memcpy(parms->APP_data, cam->APP_data, cam->APP_len);
 		parms->jpeg_markers |= V4L2_JPEG_MARKER_APP;
 	}
 	parms->COM_len = cam->COM_len;
 	if(cam->COM_len > 0) {
 		memcpy(parms->COM_data, cam->COM_data, cam->COM_len);
 		parms->jpeg_markers |= JPEG_MARKER_COM;
 	}
 	DBG("G_JPEGCOMP APP_len:%d COM_len:%d\n",
 	    parms->APP_len, parms->COM_len);
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_s_jpegcomp
  *
  *  V4L2 set the JPEG compression parameters
  *  NOTE: quality and some jpeg_markers are ignored.
  *
  *****************************************************************************/
 static int ioctl_s_jpegcomp(void *arg,struct camera_data *cam)
 {
 	struct v4l2_jpegcompression *parms = arg;
 	DBG("S_JPEGCOMP APP_len:%d COM_len:%d\n",
 	    parms->APP_len, parms->COM_len);
 	cam->params.compression.inhibit_htables =
 		!(parms->jpeg_markers & V4L2_JPEG_MARKER_DHT);
 	if(parms->APP_len != 0) {
 		if(parms->APP_len > 0 &&
 		   parms->APP_len <= sizeof(cam->APP_data) &&
 		   parms->APPn >= 0 && parms->APPn <= 15) {
 			cam->APPn = parms->APPn;
 			cam->APP_len = parms->APP_len;
 			memcpy(cam->APP_data, parms->APP_data, parms->APP_len);
 		} else {
 			LOG("Bad APPn Params n=%d len=%d\n",
 			    parms->APPn, parms->APP_len);
 			return -EINVAL;
 		}
 	} else {
 		cam->APP_len = 0;
 	}
 	if(parms->COM_len != 0) {
 		if(parms->COM_len > 0 &&
 		   parms->COM_len <= sizeof(cam->COM_data)) {
 			cam->COM_len = parms->COM_len;
 			memcpy(cam->COM_data, parms->COM_data, parms->COM_len);
 		} else {
 			LOG("Bad COM_len=%d\n", parms->COM_len);
 			return -EINVAL;
 		}
 	}
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_reqbufs
  *
  *  V4L2 Initiate memory mapping.
  *  NOTE: The user's request is ignored. For now the buffers are fixed.
  *
  *****************************************************************************/
 static int ioctl_reqbufs(void *arg,struct camera_data *cam)
 {
 	struct v4l2_requestbuffers *req = arg;
 	if(req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
 	   req->memory != V4L2_MEMORY_MMAP)
 		return -EINVAL;
 	DBG("REQBUFS requested:%d returning:%d\n", req->count, cam->num_frames);
 	req->count = cam->num_frames;
 	memset(&req->reserved, 0, sizeof(req->reserved));
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_querybuf
  *
  *  V4L2 Query memory buffer status.
  *
  *****************************************************************************/
 static int ioctl_querybuf(void *arg,struct camera_data *cam)
 {
 	struct v4l2_buffer *buf = arg;
 	if(buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
 	   buf->index > cam->num_frames)
 		return -EINVAL;
 	buf->m.offset = cam->buffers[buf->index].data - cam->frame_buffer;
 	buf->length = cam->frame_size;
 	buf->memory = V4L2_MEMORY_MMAP;
 	if(cam->mmapped)
 		buf->flags = V4L2_BUF_FLAG_MAPPED;
 	else
 		buf->flags = 0;
 	switch (cam->buffers[buf->index].status) {
 	case FRAME_EMPTY:
 	case FRAME_ERROR:
 	case FRAME_READING:
 		buf->bytesused = 0;
 		buf->flags = V4L2_BUF_FLAG_QUEUED;
 		break;
 	case FRAME_READY:
 		buf->bytesused = cam->buffers[buf->index].length;
 		buf->timestamp = cam->buffers[buf->index].timestamp;
 		buf->sequence = cam->buffers[buf->index].seq;
 		buf->flags = V4L2_BUF_FLAG_DONE;
 		break;
 	}
 	DBG("QUERYBUF index:%d offset:%d flags:%d seq:%d bytesused:%d\n",
 	     buf->index, buf->m.offset, buf->flags, buf->sequence,
 	     buf->bytesused);
 	return 0;
 }
 /******************************************************************************
  *
  *  ioctl_qbuf
  *
  *  V4L2 User is freeing buffer
  *
  *****************************************************************************/
 static int ioctl_qbuf(void *arg,struct camera_data *cam)
 {
 	struct v4l2_buffer *buf = arg;
 	if(buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
 	   buf->memory != V4L2_MEMORY_MMAP ||
 	   buf->index > cam->num_frames)
 		return -EINVAL;
 	DBG("QBUF #%d\n", buf->index);
 	if(cam->buffers[buf->index].status == FRAME_READY)
 		cam->buffers[buf->index].status = FRAME_EMPTY;
 	return 0;
 }
 /******************************************************************************
  *
  *  find_earliest_filled_buffer
  *
  *  Helper for ioctl_dqbuf. Find the next ready buffer.
  *
  *****************************************************************************/
 static int find_earliest_filled_buffer(struct camera_data *cam)
 {
 	int i;
 	int found = -1;
 	for (i=0; i<cam->num_frames; i++) {
 		if(cam->buffers[i].status == FRAME_READY) {
 			if(found < 0) {
 				found = i;
 			} else {
 				/* find which buffer is earlier */
 				struct timeval *tv1, *tv2;
 				tv1 = &cam->buffers[i].timestamp;
 				tv2 = &cam->buffers[found].timestamp;
 				if(tv1->tv_sec < tv2->tv_sec ||
 				   (tv1->tv_sec == tv2->tv_sec &&
 				    tv1->tv_usec < tv2->tv_usec))
 					found = i;
 			}
 		}
 	}
 	return found;
 }
 /******************************************************************************
  *
  *  ioctl_dqbuf
  *
  *  V4L2 User is asking for a filled buffer.
  *
  *****************************************************************************/
 static int ioctl_dqbuf(void *arg,struct camera_data *cam, struct file *file)
 {
 	struct v4l2_buffer *buf = arg;
 	int frame;
 	if(buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
 	   buf->memory != V4L2_MEMORY_MMAP)
 		return -EINVAL;
 	frame = find_earliest_filled_buffer(cam);
 	if(frame < 0 && file->f_flags&O_NONBLOCK)
 		return -EAGAIN;
 	if(frame < 0) {
 		/* Wait for a frame to become available */
 		struct framebuf *cb=cam->curbuff;
 		mutex_unlock(&cam->busy_lock);
 		wait_event_interruptible(cam->wq_stream,
 					 !cam->present ||
 					 (cb=cam->curbuff)->status == FRAME_READY);
 		mutex_lock(&cam->busy_lock);
 		if (signal_pending(current))
 			return -ERESTARTSYS;
 		if(!cam->present)
 			return -ENOTTY;
 		frame = cb->num;
 	}
 	buf->index = frame;
 	buf->bytesused = cam->buffers[buf->index].length;
 	buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_DONE;
 	buf->field = V4L2_FIELD_NONE;
 	buf->timestamp = cam->buffers[buf->index].timestamp;
 	buf->sequence = cam->buffers[buf->index].seq;
 	buf->m.offset = cam->buffers[buf->index].data - cam->frame_buffer;
 	buf->length = cam->frame_size;
 	buf->input = 0;
 	buf->reserved = 0;
 	memset(&buf->timecode, 0, sizeof(buf->timecode));
 	DBG("DQBUF #%d status:%d seq:%d length:%d\n", buf->index,
 	    cam->buffers[buf->index].status, buf->sequence, buf->bytesused);
 	return 0;
 }
 /******************************************************************************
  *
  *  cpia2_ioctl
  *
  *****************************************************************************/
 static long cpia2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 {
 	struct camera_data *cam = video_drvdata(file);
 	long retval = 0;
 	if (!cam)
 		return -ENOTTY;
 	/* make this _really_ smp-safe */
 	if (mutex_lock_interruptible(&cam->busy_lock))
 		return -ERESTARTSYS;
 	if (!cam->present) {
 		mutex_unlock(&cam->busy_lock);
 		return -ENODEV;
 	}
 	/* Priority check */
 	switch (cmd) {
 	case VIDIOCSWIN:
 	case VIDIOCMCAPTURE:
 	case VIDIOC_S_FMT:
 	{
 		struct cpia2_fh *fh = file->private_data;
 		retval = v4l2_prio_check(&cam->prio, &fh->prio);
 		if(retval) {
 			mutex_unlock(&cam->busy_lock);
 			return retval;
 		}
 		break;
 	}
 	case VIDIOCGMBUF:
 	case VIDIOCSYNC:
 	{
 		struct cpia2_fh *fh = file->private_data;
 		if(fh->prio != V4L2_PRIORITY_RECORD) {
 			mutex_unlock(&cam->busy_lock);
 			return -EBUSY;
 		}
 		break;
 	}
 	default:
 		break;
 	}
 	switch (cmd) {
 	case VIDIOCGCAP:	/* query capabilities */
 		retval = ioctl_cap_query(arg, cam);
 		break;
 	case VIDIOCGCHAN:	/* get video source - we are a camera, nothing else */
 		retval = ioctl_get_channel(arg);
 		break;
 	case VIDIOCSCHAN:	/* set video source - we are a camera, nothing else */
 		retval = ioctl_set_channel(arg);
 		break;
 	case VIDIOCGPICT:	/* image properties */
 		memcpy(arg, &cam->vp, sizeof(struct video_picture));
 		break;
 	case VIDIOCSPICT:
 		retval = ioctl_set_image_prop(arg, cam);
 		break;
 	case VIDIOCGWIN:	/* get/set capture window */
 		memcpy(arg, &cam->vw, sizeof(struct video_window));
 		break;
 	case VIDIOCSWIN:
 		retval = ioctl_set_window_size(arg, cam, file->private_data);
 		break;
 	case VIDIOCGMBUF:	/* mmap interface */
 		retval = ioctl_get_mbuf(arg, cam);
 		break;
 	case VIDIOCMCAPTURE:
 		retval = ioctl_mcapture(arg, cam, file->private_data);
 		break;
 	case VIDIOCSYNC:
 		retval = ioctl_sync(arg, cam);
 		break;
 		/* pointless to implement overlay with this camera */
 	case VIDIOCCAPTURE:
 	case VIDIOCGFBUF:
 	case VIDIOCSFBUF:
 	case VIDIOCKEY:
 		retval = -EINVAL;
 		break;
 		/* tuner interface - we have none */
 	case VIDIOCGTUNER:
 	case VIDIOCSTUNER:
 	case VIDIOCGFREQ:
 	case VIDIOCSFREQ:
 		retval = -EINVAL;
 		break;
 		/* audio interface - we have none */
 	case VIDIOCGAUDIO:
 	case VIDIOCSAUDIO:
 		retval = -EINVAL;
 		break;
 	/* CPIA2 extension to Video4Linux API */
 	case CPIA2_IOC_SET_GPIO:
 		retval = ioctl_set_gpio(arg, cam);
 		break;
 	case VIDIOC_QUERYCAP:
 		retval = ioctl_querycap(arg,cam);
 		break;
 	case VIDIOC_ENUMINPUT:
 	case VIDIOC_G_INPUT:
 	case VIDIOC_S_INPUT:
 		retval = ioctl_input(cmd, arg, cam);
 		break;
 	case VIDIOC_ENUM_FMT:
 		retval = ioctl_enum_fmt(arg,cam);
 		break;
 	case VIDIOC_TRY_FMT:
 		retval = ioctl_try_fmt(arg,cam);
 		break;
 	case VIDIOC_G_FMT:
 		retval = ioctl_get_fmt(arg,cam);
 		break;
 	case VIDIOC_S_FMT:
 		retval = ioctl_set_fmt(arg,cam,file->private_data);
 		break;
 	case VIDIOC_CROPCAP:
 		retval = ioctl_cropcap(arg,cam);
 		break;
 	case VIDIOC_G_CROP:
 	case VIDIOC_S_CROP:
 		// TODO: I think cropping can be implemented - SJB
 		retval = -EINVAL;
 		break;
 	case VIDIOC_QUERYCTRL:
 		retval = ioctl_queryctrl(arg,cam);
 		break;
 	case VIDIOC_QUERYMENU:
 		retval = ioctl_querymenu(arg,cam);
 		break;
 	case VIDIOC_G_CTRL:
 		retval = ioctl_g_ctrl(arg,cam);
 		break;
 	case VIDIOC_S_CTRL:
 		retval = ioctl_s_ctrl(arg,cam);
 		break;
 	case VIDIOC_G_JPEGCOMP:
 		retval = ioctl_g_jpegcomp(arg,cam);
 		break;
 	case VIDIOC_S_JPEGCOMP:
 		retval = ioctl_s_jpegcomp(arg,cam);
 		break;
 	case VIDIOC_G_PRIORITY:
 	{
 		struct cpia2_fh *fh = file->private_data;
 		*(enum v4l2_priority*)arg = fh->prio;
 		break;
 	}
 	case VIDIOC_S_PRIORITY:
 	{
 		struct cpia2_fh *fh = file->private_data;
 		enum v4l2_priority prio;
 		prio = *(enum v4l2_priority*)arg;
 		if(cam->streaming &&
 		   prio != fh->prio &&
 		   fh->prio == V4L2_PRIORITY_RECORD) {
 			/* Can't drop record priority while streaming */
 			retval = -EBUSY;
 		} else if(prio == V4L2_PRIORITY_RECORD &&
 		   prio != fh->prio &&
 		   v4l2_prio_max(&cam->prio) == V4L2_PRIORITY_RECORD) {
 			/* Only one program can record at a time */
 			retval = -EBUSY;
 		} else {
 			retval = v4l2_prio_change(&cam->prio, &fh->prio, prio);
 		}
 		break;
 	}
 	case VIDIOC_REQBUFS:
 		retval = ioctl_reqbufs(arg,cam);
 		break;
 	case VIDIOC_QUERYBUF:
 		retval = ioctl_querybuf(arg,cam);
 		break;
 	case VIDIOC_QBUF:
 		retval = ioctl_qbuf(arg,cam);
 		break;
 	case VIDIOC_DQBUF:
 		retval = ioctl_dqbuf(arg,cam,file);
 		break;
 	case VIDIOC_STREAMON:
 	{
 		int type;
 		DBG("VIDIOC_STREAMON, streaming=%d\n", cam->streaming);
 		type = *(int*)arg;
 		if(!cam->mmapped || type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 			retval = -EINVAL;
 		if(!cam->streaming) {
 			retval = cpia2_usb_stream_start(cam,
 					  cam->params.camera_state.stream_mode);
 		} else {
 			retval = -EINVAL;
 		}
 		break;
 	}
 	case VIDIOC_STREAMOFF:
 	{
 		int type;
 		DBG("VIDIOC_STREAMOFF, streaming=%d\n", cam->streaming);
 		type = *(int*)arg;
 		if(!cam->mmapped || type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 			retval = -EINVAL;
 		if(cam->streaming) {
 			retval = cpia2_usb_stream_stop(cam);
 		} else {
 			retval = -EINVAL;
 		}
 		break;
 	}
 	case VIDIOC_ENUMOUTPUT:
 	case VIDIOC_G_OUTPUT:
 	case VIDIOC_S_OUTPUT:
 	case VIDIOC_G_MODULATOR:
 	case VIDIOC_S_MODULATOR:
 	case VIDIOC_ENUMAUDIO:
 	case VIDIOC_G_AUDIO:
 	case VIDIOC_S_AUDIO:
 	case VIDIOC_ENUMAUDOUT:
 	case VIDIOC_G_AUDOUT:
 	case VIDIOC_S_AUDOUT:
 	case VIDIOC_ENUMSTD:
 	case VIDIOC_QUERYSTD:
 	case VIDIOC_G_STD:
 	case VIDIOC_S_STD:
 	case VIDIOC_G_TUNER:
 	case VIDIOC_S_TUNER:
 	case VIDIOC_G_FREQUENCY:
 	case VIDIOC_S_FREQUENCY:
 	case VIDIOC_OVERLAY:
 	case VIDIOC_G_FBUF:
 	case VIDIOC_S_FBUF:
 	case VIDIOC_G_PARM:
 	case VIDIOC_S_PARM:
 		retval = -EINVAL;
 		break;
 	default:
 		retval = -ENOIOCTLCMD;
 		break;
 	}
 	mutex_unlock(&cam->busy_lock);
 	return retval;
 }
 static long cpia2_ioctl(struct file *file,
 		       unsigned int cmd, unsigned long arg)
 {
 	return video_usercopy(file, cmd, arg, cpia2_do_ioctl);
 }
 /******************************************************************************
  *
  *  cpia2_mmap
  *
  *****************************************************************************/
 static int cpia2_mmap(struct file *file, struct vm_area_struct *area)
 {
 	struct camera_data *cam = video_drvdata(file);
 	int retval;
 	/* Priority check */
 	struct cpia2_fh *fh = file->private_data;
 	if(fh->prio != V4L2_PRIORITY_RECORD) {
 		return -EBUSY;
 	}
 	retval = cpia2_remap_buffer(cam, area);
 	if(!retval)
 		fh->mmapped = 1;
 	return retval;
 }
 /******************************************************************************
  *
  *  reset_camera_struct_v4l
  *
  *  Sets all values to the defaults
  *****************************************************************************/
 static void reset_camera_struct_v4l(struct camera_data *cam)
 {
 	/***
 	 * Fill in the v4l structures.  video_cap is filled in inside the VIDIOCCAP
 	 * Ioctl.  Here, just do the window and picture stucts.
 	 ***/
 	cam->vp.palette = (u16) VIDEO_PALETTE_RGB24;	/* Is this right? */
 	cam->vp.brightness = (u16) cam->params.color_params.brightness * 256;
 	cam->vp.colour = (u16) cam->params.color_params.saturation * 256;
 	cam->vp.contrast = (u16) cam->params.color_params.contrast * 256;
 	cam->vw.x = 0;
 	cam->vw.y = 0;
 	cam->vw.width = cam->params.roi.width;
 	cam->vw.height = cam->params.roi.height;
 	cam->vw.flags = 0;
 	cam->vw.clipcount = 0;
 	cam->frame_size = buffer_size;
 	cam->num_frames = num_buffers;
 	/* FlickerModes */
 	cam->params.flicker_control.flicker_mode_req = flicker_mode;
 	cam->params.flicker_control.mains_frequency = flicker_freq;
 	/* streamMode */
 	cam->params.camera_state.stream_mode = alternate;
 	cam->pixelformat = V4L2_PIX_FMT_JPEG;
 	v4l2_prio_init(&cam->prio);
 	return;
 }
 /***
  * The v4l video device structure initialized for this device
  ***/
 static const struct v4l2_file_operations fops_template = {
 	.owner		= THIS_MODULE,
 	.open		= cpia2_open,
 	.release	= cpia2_close,
 	.read		= cpia2_v4l_read,
 	.poll		= cpia2_v4l_poll,
 	.ioctl		= cpia2_ioctl,
 	.mmap		= cpia2_mmap,
 };
 static struct video_device cpia2_template = {
 	/* I could not find any place for the old .initialize initializer?? */
 	.name=		"CPiA2 Camera",
 	.minor=		-1,
 	.fops=		&fops_template,
 	.release=	video_device_release,
 };
 /******************************************************************************
  *
  *  cpia2_register_camera
  *
  *****************************************************************************/
 int cpia2_register_camera(struct camera_data *cam)
 {
 	cam->vdev = video_device_alloc();
 	if(!cam->vdev)
 		return -ENOMEM;
 	memcpy(cam->vdev, &cpia2_template, sizeof(cpia2_template));
 	video_set_drvdata(cam->vdev, cam);
 	reset_camera_struct_v4l(cam);
 	/* register v4l device */
 	if (video_register_device(cam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
 		ERR("video_register_device failed\n");
 		video_device_release(cam->vdev);
 		return -ENODEV;
 	}
 	return 0;
 }
 /******************************************************************************
  *
  *  cpia2_unregister_camera
  *
  *****************************************************************************/
 void cpia2_unregister_camera(struct camera_data *cam)
 {
 	if (!cam->open_count) {
 		video_unregister_device(cam->vdev);
 	} else {
 		LOG("/dev/video%d removed while open, "
 		    "deferring video_unregister_device\n",
 		    cam->vdev->num);
 	}
 }
 /******************************************************************************
  *
  *  check_parameters
  *
  *  Make sure that all user-supplied parameters are sensible
  *****************************************************************************/
 static void __init check_parameters(void)
 {
 	if(buffer_size < PAGE_SIZE) {
 		buffer_size = PAGE_SIZE;
 		LOG("buffer_size too small, setting to %d\n", buffer_size);
 	} else if(buffer_size > 1024*1024) {
 		/* arbitrary upper limiit */
 		buffer_size = 1024*1024;
 		LOG("buffer_size ridiculously large, setting to %d\n",
 		    buffer_size);
 	} else {
 		buffer_size += PAGE_SIZE-1;
 		buffer_size &= ~(PAGE_SIZE-1);
 	}
 	if(num_buffers < 1) {
 		num_buffers = 1;
 		LOG("num_buffers too small, setting to %d\n", num_buffers);
 	} else if(num_buffers > VIDEO_MAX_FRAME) {
 		num_buffers = VIDEO_MAX_FRAME;
 		LOG("num_buffers too large, setting to %d\n", num_buffers);
 	}
 	if(alternate < USBIF_ISO_1 || alternate > USBIF_ISO_6) {
 		alternate = DEFAULT_ALT;
 		LOG("alternate specified is invalid, using %d\n", alternate);
 	}
 	if (flicker_mode != NEVER_FLICKER && flicker_mode != ANTI_FLICKER_ON) {
 		flicker_mode = NEVER_FLICKER;
 		LOG("Flicker mode specified is invalid, using %d\n",
 		    flicker_mode);
 	}
 	if (flicker_freq != FLICKER_50 && flicker_freq != FLICKER_60) {
 		flicker_freq = FLICKER_60;
 		LOG("Flicker mode specified is invalid, using %d\n",
 		    flicker_freq);
 	}
 	if(video_nr < -1 || video_nr > 64) {
 		video_nr = -1;
 		LOG("invalid video_nr specified, must be -1 to 64\n");
 	}
 	DBG("Using %d buffers, each %d bytes, alternate=%d\n",
 	    num_buffers, buffer_size, alternate);
 }
 /************   Module Stuff ***************/
 /******************************************************************************
  *
  * cpia2_init/module_init
  *
  *****************************************************************************/
 static int __init cpia2_init(void)
 {
 	LOG("%s v%d.%d.%d\n",
 	    ABOUT, CPIA2_MAJ_VER, CPIA2_MIN_VER, CPIA2_PATCH_VER);
 	check_parameters();
 	cpia2_usb_init();
 	return 0;
 }
 /******************************************************************************
  *
  * cpia2_exit/module_exit
  *
  *****************************************************************************/
 static void __exit cpia2_exit(void)
 {
 	cpia2_usb_cleanup();
 	schedule_timeout(2 * HZ);
 }
 module_init(cpia2_init);
 module_exit(cpia2_exit);

drivers/media/video/cx23885/cx23885-video.c

Diff comments View file @ 7e0a16f

 /*
  *  Driver for the Conexant CX23885 PCIe bridge
  *
  *  Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/kmod.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
 #include <asm/div64.h>
 #include "cx23885.h"
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
-#ifdef CONFIG_VIDEO_V4L1_COMPAT
-/* Include V4L1 specific functions. Should be removed soon */
-#include <linux/videodev.h>
-#endif
 MODULE_DESCRIPTION("v4l2 driver module for cx23885 based TV cards");
 MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
 MODULE_LICENSE("GPL");
 /* ------------------------------------------------------------------ */
 static unsigned int video_nr[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
 static unsigned int vbi_nr[]   = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
 static unsigned int radio_nr[] = {[0 ... (CX23885_MAXBOARDS - 1)] = UNSET };
 module_param_array(video_nr, int, NULL, 0444);
 module_param_array(vbi_nr,   int, NULL, 0444);
 module_param_array(radio_nr, int, NULL, 0444);
 MODULE_PARM_DESC(video_nr, "video device numbers");
 MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
 MODULE_PARM_DESC(radio_nr, "radio device numbers");
 static unsigned int video_debug;
 module_param(video_debug, int, 0644);
 MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
 static unsigned int irq_debug;
 module_param(irq_debug, int, 0644);
 MODULE_PARM_DESC(irq_debug, "enable debug messages [IRQ handler]");
 static unsigned int vid_limit = 16;
 module_param(vid_limit, int, 0644);
 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
 #define dprintk(level, fmt, arg...)\
 	do { if (video_debug >= level)\
 		printk(KERN_DEBUG "%s/0: " fmt, dev->name, ## arg);\
 	} while (0)
 /* ------------------------------------------------------------------- */
 /* static data                                                         */
 #define FORMAT_FLAGS_PACKED       0x01
 static struct cx23885_fmt formats[] = {
 	{
 		.name     = "8 bpp, gray",
 		.fourcc   = V4L2_PIX_FMT_GREY,
 		.depth    = 8,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "15 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_RGB555,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "15 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB555X,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "16 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_RGB565,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "16 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB565X,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "24 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_BGR24,
 		.depth    = 24,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "32 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_BGR32,
 		.depth    = 32,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "32 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB32,
 		.depth    = 32,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "4:2:2, packed, YUYV",
 		.fourcc   = V4L2_PIX_FMT_YUYV,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	}, {
 		.name     = "4:2:2, packed, UYVY",
 		.fourcc   = V4L2_PIX_FMT_UYVY,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},
 };
 static struct cx23885_fmt *format_by_fourcc(unsigned int fourcc)
 {
 	unsigned int i;
 	for (i = 0; i < ARRAY_SIZE(formats); i++)
 		if (formats[i].fourcc == fourcc)
 			return formats+i;
 	printk(KERN_ERR "%s(0x%08x) NOT FOUND\n", __func__, fourcc);
 	return NULL;
 }
 /* ------------------------------------------------------------------- */
 static const struct v4l2_queryctrl no_ctl = {
 	.name  = "42",
 	.flags = V4L2_CTRL_FLAG_DISABLED,
 };
 static struct cx23885_ctrl cx23885_ctls[] = {
 	/* --- video --- */
 	{
 		.v = {
 			.id            = V4L2_CID_BRIGHTNESS,
 			.name          = "Brightness",
 			.minimum       = 0x00,
 			.maximum       = 0xff,
 			.step          = 1,
 			.default_value = 0x7f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.off                   = 128,
 		.reg                   = LUMA_CTRL,
 		.mask                  = 0x00ff,
 		.shift                 = 0,
 	}, {
 		.v = {
 			.id            = V4L2_CID_CONTRAST,
 			.name          = "Contrast",
 			.minimum       = 0,
 			.maximum       = 0xff,
 			.step          = 1,
 			.default_value = 0x3f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.off                   = 0,
 		.reg                   = LUMA_CTRL,
 		.mask                  = 0xff00,
 		.shift                 = 8,
 	}, {
 		.v = {
 			.id            = V4L2_CID_HUE,
 			.name          = "Hue",
 			.minimum       = 0,
 			.maximum       = 0xff,
 			.step          = 1,
 			.default_value = 0x7f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.off                   = 128,
 		.reg                   = CHROMA_CTRL,
 		.mask                  = 0xff0000,
 		.shift                 = 16,
 	}, {
 		/* strictly, this only describes only U saturation.
 		 * V saturation is handled specially through code.
 		 */
 		.v = {
 			.id            = V4L2_CID_SATURATION,
 			.name          = "Saturation",
 			.minimum       = 0,
 			.maximum       = 0xff,
 			.step          = 1,
 			.default_value = 0x7f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.off                   = 0,
 		.reg                   = CHROMA_CTRL,
 		.mask                  = 0x00ff,
 		.shift                 = 0,
 	}, {
 	/* --- audio --- */
 		.v = {
 			.id            = V4L2_CID_AUDIO_MUTE,
 			.name          = "Mute",
 			.minimum       = 0,
 			.maximum       = 1,
 			.default_value = 1,
 			.type          = V4L2_CTRL_TYPE_BOOLEAN,
 		},
 		.reg                   = PATH1_CTL1,
 		.mask                  = (0x1f << 24),
 		.shift                 = 24,
 	}, {
 		.v = {
 			.id            = V4L2_CID_AUDIO_VOLUME,
 			.name          = "Volume",
 			.minimum       = 0,
 			.maximum       = 0x3f,
 			.step          = 1,
 			.default_value = 0x3f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.reg                   = PATH1_VOL_CTL,
 		.mask                  = 0xff,
 		.shift                 = 0,
 	}
 };
 static const int CX23885_CTLS = ARRAY_SIZE(cx23885_ctls);
 /* Must be sorted from low to high control ID! */
 static const u32 cx23885_user_ctrls[] = {
 	V4L2_CID_USER_CLASS,
 	V4L2_CID_BRIGHTNESS,
 	V4L2_CID_CONTRAST,
 	V4L2_CID_SATURATION,
 	V4L2_CID_HUE,
 	V4L2_CID_AUDIO_VOLUME,
 	V4L2_CID_AUDIO_MUTE,
 	0
 };
 static const u32 *ctrl_classes[] = {
 	cx23885_user_ctrls,
 	NULL
 };
 static void cx23885_video_wakeup(struct cx23885_dev *dev,
 		 struct cx23885_dmaqueue *q, u32 count)
 {
 	struct cx23885_buffer *buf;
 	int bc;
 	for (bc = 0;; bc++) {
 		if (list_empty(&q->active))
 			break;
 		buf = list_entry(q->active.next,
 				 struct cx23885_buffer, vb.queue);
 		/* count comes from the hw and is is 16bit wide --
 		 * this trick handles wrap-arounds correctly for
 		 * up to 32767 buffers in flight... */
 		if ((s16) (count - buf->count) < 0)
 			break;
 		do_gettimeofday(&buf->vb.ts);
 		dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf, buf->vb.i,
 			count, buf->count);
 		buf->vb.state = VIDEOBUF_DONE;
 		list_del(&buf->vb.queue);
 		wake_up(&buf->vb.done);
 	}
 	if (list_empty(&q->active))
 		del_timer(&q->timeout);
 	else
 		mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 	if (bc != 1)
 		printk(KERN_ERR "%s: %d buffers handled (should be 1)\n",
 			__func__, bc);
 }
 static int cx23885_set_tvnorm(struct cx23885_dev *dev, v4l2_std_id norm)
 {
 	dprintk(1, "%s(norm = 0x%08x) name: [%s]\n",
 		__func__,
 		(unsigned int)norm,
 		v4l2_norm_to_name(norm));
 	dev->tvnorm = norm;
 	/* Tell the analog tuner/demods */
 	cx23885_call_i2c_clients(&dev->i2c_bus[1], VIDIOC_S_STD, &norm);
 	/* Tell the internal A/V decoder */
 	cx23885_call_i2c_clients(&dev->i2c_bus[2], VIDIOC_S_STD, &norm);
 	return 0;
 }
 static struct video_device *cx23885_vdev_init(struct cx23885_dev *dev,
 				    struct pci_dev *pci,
 				    struct video_device *template,
 				    char *type)
 {
 	struct video_device *vfd;
 	dprintk(1, "%s()\n", __func__);
 	vfd = video_device_alloc();
 	if (NULL == vfd)
 		return NULL;
 	*vfd = *template;
 	vfd->minor   = -1;
 	vfd->parent  = &pci->dev;
 	vfd->release = video_device_release;
 	snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
 		 dev->name, type, cx23885_boards[dev->board].name);
 	return vfd;
 }
 static int cx23885_ctrl_query(struct v4l2_queryctrl *qctrl)
 {
 	int i;
 	if (qctrl->id < V4L2_CID_BASE ||
 	    qctrl->id >= V4L2_CID_LASTP1)
 		return -EINVAL;
 	for (i = 0; i < CX23885_CTLS; i++)
 		if (cx23885_ctls[i].v.id == qctrl->id)
 			break;
 	if (i == CX23885_CTLS) {
 		*qctrl = no_ctl;
 		return 0;
 	}
 	*qctrl = cx23885_ctls[i].v;
 	return 0;
 }
 /* ------------------------------------------------------------------- */
 /* resource management                                                 */
 static int res_get(struct cx23885_dev *dev, struct cx23885_fh *fh,
 	unsigned int bit)
 {
 	dprintk(1, "%s()\n", __func__);
 	if (fh->resources & bit)
 		/* have it already allocated */
 		return 1;
 	/* is it free? */
 	mutex_lock(&dev->lock);
 	if (dev->resources & bit) {
 		/* no, someone else uses it */
 		mutex_unlock(&dev->lock);
 		return 0;
 	}
 	/* it's free, grab it */
 	fh->resources  |= bit;
 	dev->resources |= bit;
 	dprintk(1, "res: get %d\n", bit);
 	mutex_unlock(&dev->lock);
 	return 1;
 }
 static int res_check(struct cx23885_fh *fh, unsigned int bit)
 {
 	return fh->resources & bit;
 }
 static int res_locked(struct cx23885_dev *dev, unsigned int bit)
 {
 	return dev->resources & bit;
 }
 static void res_free(struct cx23885_dev *dev, struct cx23885_fh *fh,
 	unsigned int bits)
 {
 	BUG_ON((fh->resources & bits) != bits);
 	dprintk(1, "%s()\n", __func__);
 	mutex_lock(&dev->lock);
 	fh->resources  &= ~bits;
 	dev->resources &= ~bits;
 	dprintk(1, "res: put %d\n", bits);
 	mutex_unlock(&dev->lock);
 }
 static int cx23885_video_mux(struct cx23885_dev *dev, unsigned int input)
 {
 	struct v4l2_routing route;
 	memset(&route, 0, sizeof(route));
 	dprintk(1, "%s() video_mux: %d [vmux=%d, gpio=0x%x,0x%x,0x%x,0x%x]\n",
 		__func__,
 		input, INPUT(input)->vmux,
 		INPUT(input)->gpio0, INPUT(input)->gpio1,
 		INPUT(input)->gpio2, INPUT(input)->gpio3);
 	dev->input = input;
 	route.input = INPUT(input)->vmux;
 	/* Tell the internal A/V decoder */
 	cx23885_call_i2c_clients(&dev->i2c_bus[2],
 		VIDIOC_INT_S_VIDEO_ROUTING, &route);
 	return 0;
 }
 /* ------------------------------------------------------------------ */
 static int cx23885_set_scale(struct cx23885_dev *dev, unsigned int width,
 	unsigned int height, enum v4l2_field field)
 {
 	dprintk(1, "%s()\n", __func__);
 	return 0;
 }
 static int cx23885_start_video_dma(struct cx23885_dev *dev,
 			   struct cx23885_dmaqueue *q,
 			   struct cx23885_buffer *buf)
 {
 	dprintk(1, "%s()\n", __func__);
 	/* setup fifo + format */
 	cx23885_sram_channel_setup(dev, &dev->sram_channels[SRAM_CH01],
 				buf->bpl, buf->risc.dma);
 	cx23885_set_scale(dev, buf->vb.width, buf->vb.height, buf->vb.field);
 	/* reset counter */
 	cx_write(VID_A_GPCNT_CTL, 3);
 	q->count = 1;
 	/* enable irq */
 	cx_set(PCI_INT_MSK, cx_read(PCI_INT_MSK) | 0x01);
 	cx_set(VID_A_INT_MSK, 0x000011);
 	/* start dma */
 	cx_set(DEV_CNTRL2, (1<<5));
 	cx_set(VID_A_DMA_CTL, 0x11); /* FIFO and RISC enable */
 	return 0;
 }
 static int cx23885_restart_video_queue(struct cx23885_dev *dev,
 			       struct cx23885_dmaqueue *q)
 {
 	struct cx23885_buffer *buf, *prev;
 	struct list_head *item;
 	dprintk(1, "%s()\n", __func__);
 	if (!list_empty(&q->active)) {
 		buf = list_entry(q->active.next, struct cx23885_buffer,
 			vb.queue);
 		dprintk(2, "restart_queue [%p/%d]: restart dma\n",
 			buf, buf->vb.i);
 		cx23885_start_video_dma(dev, q, buf);
 		list_for_each(item, &q->active) {
 			buf = list_entry(item, struct cx23885_buffer,
 				vb.queue);
 			buf->count    = q->count++;
 		}
 		mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 		return 0;
 	}
 	prev = NULL;
 	for (;;) {
 		if (list_empty(&q->queued))
 			return 0;
 		buf = list_entry(q->queued.next, struct cx23885_buffer,
 			vb.queue);
 		if (NULL == prev) {
 			list_move_tail(&buf->vb.queue, &q->active);
 			cx23885_start_video_dma(dev, q, buf);
 			buf->vb.state = VIDEOBUF_ACTIVE;
 			buf->count    = q->count++;
 			mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 			dprintk(2, "[%p/%d] restart_queue - first active\n",
 				buf, buf->vb.i);
 		} else if (prev->vb.width  == buf->vb.width  &&
 			   prev->vb.height == buf->vb.height &&
 			   prev->fmt       == buf->fmt) {
 			list_move_tail(&buf->vb.queue, &q->active);
 			buf->vb.state = VIDEOBUF_ACTIVE;
 			buf->count    = q->count++;
 			prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 			prev->risc.jmp[2] = cpu_to_le32(0); /* Bits 63 - 32 */
 			dprintk(2, "[%p/%d] restart_queue - move to active\n",
 				buf, buf->vb.i);
 		} else {
 			return 0;
 		}
 		prev = buf;
 	}
 }
 static int buffer_setup(struct videobuf_queue *q, unsigned int *count,
 	unsigned int *size)
 {
 	struct cx23885_fh *fh = q->priv_data;
 	*size = fh->fmt->depth*fh->width*fh->height >> 3;
 	if (0 == *count)
 		*count = 32;
 	while (*size * *count > vid_limit * 1024 * 1024)
 		(*count)--;
 	return 0;
 }
 static int buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
 	       enum v4l2_field field)
 {
 	struct cx23885_fh *fh  = q->priv_data;
 	struct cx23885_dev *dev = fh->dev;
 	struct cx23885_buffer *buf =
 		container_of(vb, struct cx23885_buffer, vb);
 	int rc, init_buffer = 0;
 	u32 line0_offset, line1_offset;
 	struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
 	BUG_ON(NULL == fh->fmt);
 	if (fh->width  < 48 || fh->width  > norm_maxw(dev->tvnorm) ||
 	    fh->height < 32 || fh->height > norm_maxh(dev->tvnorm))
 		return -EINVAL;
 	buf->vb.size = (fh->width * fh->height * fh->fmt->depth) >> 3;
 	if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
 		return -EINVAL;
 	if (buf->fmt       != fh->fmt    ||
 	    buf->vb.width  != fh->width  ||
 	    buf->vb.height != fh->height ||
 	    buf->vb.field  != field) {
 		buf->fmt       = fh->fmt;
 		buf->vb.width  = fh->width;
 		buf->vb.height = fh->height;
 		buf->vb.field  = field;
 		init_buffer = 1;
 	}
 	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 		init_buffer = 1;
 		rc = videobuf_iolock(q, &buf->vb, NULL);
 		if (0 != rc)
 			goto fail;
 	}
 	if (init_buffer) {
 		buf->bpl = buf->vb.width * buf->fmt->depth >> 3;
 		switch (buf->vb.field) {
 		case V4L2_FIELD_TOP:
 			cx23885_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist, 0, UNSET,
 					 buf->bpl, 0, buf->vb.height);
 			break;
 		case V4L2_FIELD_BOTTOM:
 			cx23885_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist, UNSET, 0,
 					 buf->bpl, 0, buf->vb.height);
 			break;
 		case V4L2_FIELD_INTERLACED:
 			if (dev->tvnorm & V4L2_STD_NTSC) {
 				/* cx25840 transmits NTSC bottom field first */
 				dprintk(1, "%s() Creating NTSC risc\n",
 					__func__);
 				line0_offset = buf->bpl;
 				line1_offset = 0;
 			} else {
 				/* All other formats are top field first */
 				dprintk(1, "%s() Creating PAL/SECAM risc\n",
 					__func__);
 				line0_offset = 0;
 				line1_offset = buf->bpl;
 			}
 			cx23885_risc_buffer(dev->pci, &buf->risc,
 					dma->sglist, line0_offset,
 					line1_offset,
 					buf->bpl, buf->bpl,
 					buf->vb.height >> 1);
 			break;
 		case V4L2_FIELD_SEQ_TB:
 			cx23885_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist,
 					 0, buf->bpl * (buf->vb.height >> 1),
 					 buf->bpl, 0,
 					 buf->vb.height >> 1);
 			break;
 		case V4L2_FIELD_SEQ_BT:
 			cx23885_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist,
 					 buf->bpl * (buf->vb.height >> 1), 0,
 					 buf->bpl, 0,
 					 buf->vb.height >> 1);
 			break;
 		default:
 			BUG();
 		}
 	}
 	dprintk(2, "[%p/%d] buffer_prep - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
 		buf, buf->vb.i,
 		fh->width, fh->height, fh->fmt->depth, fh->fmt->name,
 		(unsigned long)buf->risc.dma);
 	buf->vb.state = VIDEOBUF_PREPARED;
 	return 0;
  fail:
 	cx23885_free_buffer(q, buf);
 	return rc;
 }
 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 {
 	struct cx23885_buffer   *buf = container_of(vb,
 		struct cx23885_buffer, vb);
 	struct cx23885_buffer   *prev;
 	struct cx23885_fh       *fh   = vq->priv_data;
 	struct cx23885_dev      *dev  = fh->dev;
 	struct cx23885_dmaqueue *q    = &dev->vidq;
 	/* add jump to stopper */
 	buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
 	buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma);
 	buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
 	if (!list_empty(&q->queued)) {
 		list_add_tail(&buf->vb.queue, &q->queued);
 		buf->vb.state = VIDEOBUF_QUEUED;
 		dprintk(2, "[%p/%d] buffer_queue - append to queued\n",
 			buf, buf->vb.i);
 	} else if (list_empty(&q->active)) {
 		list_add_tail(&buf->vb.queue, &q->active);
 		cx23885_start_video_dma(dev, q, buf);
 		buf->vb.state = VIDEOBUF_ACTIVE;
 		buf->count    = q->count++;
 		mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 		dprintk(2, "[%p/%d] buffer_queue - first active\n",
 			buf, buf->vb.i);
 	} else {
 		prev = list_entry(q->active.prev, struct cx23885_buffer,
 			vb.queue);
 		if (prev->vb.width  == buf->vb.width  &&
 		    prev->vb.height == buf->vb.height &&
 		    prev->fmt       == buf->fmt) {
 			list_add_tail(&buf->vb.queue, &q->active);
 			buf->vb.state = VIDEOBUF_ACTIVE;
 			buf->count    = q->count++;
 			prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 			/* 64 bit bits 63-32 */
 			prev->risc.jmp[2] = cpu_to_le32(0);
 			dprintk(2, "[%p/%d] buffer_queue - append to active\n",
 				buf, buf->vb.i);
 		} else {
 			list_add_tail(&buf->vb.queue, &q->queued);
 			buf->vb.state = VIDEOBUF_QUEUED;
 			dprintk(2, "[%p/%d] buffer_queue - first queued\n",
 				buf, buf->vb.i);
 		}
 	}
 }
 static void buffer_release(struct videobuf_queue *q,
 	struct videobuf_buffer *vb)
 {
 	struct cx23885_buffer *buf = container_of(vb,
 		struct cx23885_buffer, vb);
 	cx23885_free_buffer(q, buf);
 }
 static struct videobuf_queue_ops cx23885_video_qops = {
 	.buf_setup    = buffer_setup,
 	.buf_prepare  = buffer_prepare,
 	.buf_queue    = buffer_queue,
 	.buf_release  = buffer_release,
 };
 static struct videobuf_queue *get_queue(struct cx23885_fh *fh)
 {
 	switch (fh->type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		return &fh->vidq;
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		return &fh->vbiq;
 	default:
 		BUG();
 		return NULL;
 	}
 }
 static int get_resource(struct cx23885_fh *fh)
 {
 	switch (fh->type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		return RESOURCE_VIDEO;
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		return RESOURCE_VBI;
 	default:
 		BUG();
 		return 0;
 	}
 }
 static int video_open(struct file *file)
 {
 	int minor = video_devdata(file)->minor;
 	struct cx23885_dev *h, *dev = NULL;
 	struct cx23885_fh *fh;
 	struct list_head *list;
 	enum v4l2_buf_type type = 0;
 	int radio = 0;
 	lock_kernel();
 	list_for_each(list, &cx23885_devlist) {
 		h = list_entry(list, struct cx23885_dev, devlist);
 		if (h->video_dev &&
 		    h->video_dev->minor == minor) {
 			dev  = h;
 			type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 		}
 		if (h->vbi_dev &&
 		    h->vbi_dev->minor == minor) {
 			dev  = h;
 			type = V4L2_BUF_TYPE_VBI_CAPTURE;
 		}
 		if (h->radio_dev &&
 		    h->radio_dev->minor == minor) {
 			radio = 1;
 			dev   = h;
 		}
 	}
 	if (NULL == dev) {
 		unlock_kernel();
 		return -ENODEV;
 	}
 	dprintk(1, "open minor=%d radio=%d type=%s\n",
 		minor, radio, v4l2_type_names[type]);
 	/* allocate + initialize per filehandle data */
 	fh = kzalloc(sizeof(*fh), GFP_KERNEL);
 	if (NULL == fh) {
 		unlock_kernel();
 		return -ENOMEM;
 	}
 	file->private_data = fh;
 	fh->dev      = dev;
 	fh->radio    = radio;
 	fh->type     = type;
 	fh->width    = 320;
 	fh->height   = 240;
 	fh->fmt      = format_by_fourcc(V4L2_PIX_FMT_BGR24);
 	videobuf_queue_sg_init(&fh->vidq, &cx23885_video_qops,
 			    &dev->pci->dev, &dev->slock,
 			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
 			    V4L2_FIELD_INTERLACED,
 			    sizeof(struct cx23885_buffer),
 			    fh);
 	dprintk(1, "post videobuf_queue_init()\n");
 	unlock_kernel();
 	return 0;
 }
 static ssize_t video_read(struct file *file, char __user *data,
 	size_t count, loff_t *ppos)
 {
 	struct cx23885_fh *fh = file->private_data;
 	switch (fh->type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		if (res_locked(fh->dev, RESOURCE_VIDEO))
 			return -EBUSY;
 		return videobuf_read_one(&fh->vidq, data, count, ppos,
 					 file->f_flags & O_NONBLOCK);
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		if (!res_get(fh->dev, fh, RESOURCE_VBI))
 			return -EBUSY;
 		return videobuf_read_stream(&fh->vbiq, data, count, ppos, 1,
 					    file->f_flags & O_NONBLOCK);
 	default:
 		BUG();
 		return 0;
 	}
 }
 static unsigned int video_poll(struct file *file,
 	struct poll_table_struct *wait)
 {
 	struct cx23885_fh *fh = file->private_data;
 	struct cx23885_buffer *buf;
 	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
 		if (!res_get(fh->dev, fh, RESOURCE_VBI))
 			return POLLERR;
 		return videobuf_poll_stream(file, &fh->vbiq, wait);
 	}
 	if (res_check(fh, RESOURCE_VIDEO)) {
 		/* streaming capture */
 		if (list_empty(&fh->vidq.stream))
 			return POLLERR;
 		buf = list_entry(fh->vidq.stream.next,
 			struct cx23885_buffer, vb.stream);
 	} else {
 		/* read() capture */
 		buf = (struct cx23885_buffer *)fh->vidq.read_buf;
 		if (NULL == buf)
 			return POLLERR;
 	}
 	poll_wait(file, &buf->vb.done, wait);
 	if (buf->vb.state == VIDEOBUF_DONE ||
 	    buf->vb.state == VIDEOBUF_ERROR)
 		return POLLIN|POLLRDNORM;
 	return 0;
 }
 static int video_release(struct file *file)
 {
 	struct cx23885_fh *fh = file->private_data;
 	struct cx23885_dev *dev = fh->dev;
 	/* turn off overlay */
 	if (res_check(fh, RESOURCE_OVERLAY)) {
 		/* FIXME */
 		res_free(dev, fh, RESOURCE_OVERLAY);
 	}
 	/* stop video capture */
 	if (res_check(fh, RESOURCE_VIDEO)) {
 		videobuf_queue_cancel(&fh->vidq);
 		res_free(dev, fh, RESOURCE_VIDEO);
 	}
 	if (fh->vidq.read_buf) {
 		buffer_release(&fh->vidq, fh->vidq.read_buf);
 		kfree(fh->vidq.read_buf);
 	}
 	/* stop vbi capture */
 	if (res_check(fh, RESOURCE_VBI)) {
 		if (fh->vbiq.streaming)
 			videobuf_streamoff(&fh->vbiq);
 		if (fh->vbiq.reading)
 			videobuf_read_stop(&fh->vbiq);
 		res_free(dev, fh, RESOURCE_VBI);
 	}
 	videobuf_mmap_free(&fh->vidq);
 	file->private_data = NULL;
 	kfree(fh);
 	/* We are not putting the tuner to sleep here on exit, because
 	 * we want to use the mpeg encoder in another session to capture
 	 * tuner video. Closing this will result in no video to the encoder.
 	 */
 	return 0;
 }
 static int video_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct cx23885_fh *fh = file->private_data;
 	return videobuf_mmap_mapper(get_queue(fh), vma);
 }
 /* ------------------------------------------------------------------ */
 /* VIDEO CTRL IOCTLS                                                  */
 static int cx23885_get_control(struct cx23885_dev *dev,
 	struct v4l2_control *ctl)
 {
 	dprintk(1, "%s() calling cx25840(VIDIOC_G_CTRL)\n", __func__);
 	cx23885_call_i2c_clients(&dev->i2c_bus[2], VIDIOC_G_CTRL, ctl);
 	return 0;
 }
 static int cx23885_set_control(struct cx23885_dev *dev,
 	struct v4l2_control *ctl)
 {
 	dprintk(1, "%s() calling cx25840(VIDIOC_S_CTRL)"
 		" (disabled - no action)\n", __func__);
 	return 0;
 }
 static void init_controls(struct cx23885_dev *dev)
 {
 	struct v4l2_control ctrl;
 	int i;
 	for (i = 0; i < CX23885_CTLS; i++) {
 		ctrl.id = cx23885_ctls[i].v.id;
 		ctrl.value = cx23885_ctls[i].v.default_value;
 		cx23885_set_control(dev, &ctrl);
 	}
 }
 /* ------------------------------------------------------------------ */
 /* VIDEO IOCTLS                                                       */
 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 	struct v4l2_format *f)
 {
 	struct cx23885_fh *fh   = priv;
 	f->fmt.pix.width        = fh->width;
 	f->fmt.pix.height       = fh->height;
 	f->fmt.pix.field        = fh->vidq.field;
 	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
 	f->fmt.pix.bytesperline =
 		(f->fmt.pix.width * fh->fmt->depth) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	return 0;
 }
 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 	struct v4l2_format *f)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	struct cx23885_fmt *fmt;
 	enum v4l2_field   field;
 	unsigned int      maxw, maxh;
 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 	if (NULL == fmt)
 		return -EINVAL;
 	field = f->fmt.pix.field;
 	maxw  = norm_maxw(dev->tvnorm);
 	maxh  = norm_maxh(dev->tvnorm);
 	if (V4L2_FIELD_ANY == field) {
 		field = (f->fmt.pix.height > maxh/2)
 			? V4L2_FIELD_INTERLACED
 			: V4L2_FIELD_BOTTOM;
 	}
 	switch (field) {
 	case V4L2_FIELD_TOP:
 	case V4L2_FIELD_BOTTOM:
 		maxh = maxh / 2;
 		break;
 	case V4L2_FIELD_INTERLACED:
 		break;
 	default:
 		return -EINVAL;
 	}
 	f->fmt.pix.field = field;
 	if (f->fmt.pix.height < 32)
 		f->fmt.pix.height = 32;
 	if (f->fmt.pix.height > maxh)
 		f->fmt.pix.height = maxh;
 	if (f->fmt.pix.width < 48)
 		f->fmt.pix.width = 48;
 	if (f->fmt.pix.width > maxw)
 		f->fmt.pix.width = maxw;
 	f->fmt.pix.width &= ~0x03;
 	f->fmt.pix.bytesperline =
 		(f->fmt.pix.width * fmt->depth) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	return 0;
 }
 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 	struct v4l2_format *f)
 {
 	struct cx23885_fh *fh = priv;
 	struct cx23885_dev *dev  = ((struct cx23885_fh *)priv)->dev;
 	int err;
 	dprintk(2, "%s()\n", __func__);
 	err = vidioc_try_fmt_vid_cap(file, priv, f);
 	if (0 != err)
 		return err;
 	fh->fmt        = format_by_fourcc(f->fmt.pix.pixelformat);
 	fh->width      = f->fmt.pix.width;
 	fh->height     = f->fmt.pix.height;
 	fh->vidq.field = f->fmt.pix.field;
 	dprintk(2, "%s() width=%d height=%d field=%d\n", __func__,
 		fh->width, fh->height, fh->vidq.field);
 	cx23885_call_i2c_clients(&dev->i2c_bus[2], VIDIOC_S_FMT, f);
 	return 0;
 }
 static int vidioc_querycap(struct file *file, void  *priv,
 	struct v4l2_capability *cap)
 {
 	struct cx23885_dev *dev  = ((struct cx23885_fh *)priv)->dev;
 	strcpy(cap->driver, "cx23885");
 	strlcpy(cap->card, cx23885_boards[dev->board].name,
 		sizeof(cap->card));
 	sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
 	cap->version = CX23885_VERSION_CODE;
 	cap->capabilities =
 		V4L2_CAP_VIDEO_CAPTURE |
 		V4L2_CAP_READWRITE     |
 		V4L2_CAP_STREAMING     |
 		V4L2_CAP_VBI_CAPTURE;
 	if (UNSET != dev->tuner_type)
 		cap->capabilities |= V4L2_CAP_TUNER;
 	return 0;
 }
 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 	struct v4l2_fmtdesc *f)
 {
 	if (unlikely(f->index >= ARRAY_SIZE(formats)))
 		return -EINVAL;
 	strlcpy(f->description, formats[f->index].name,
 		sizeof(f->description));
 	f->pixelformat = formats[f->index].fourcc;
 	return 0;
 }
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 static int vidiocgmbuf(struct file *file, void *priv,
 	struct video_mbuf *mbuf)
 {
 	struct cx23885_fh *fh = priv;
 	struct videobuf_queue *q;
 	struct v4l2_requestbuffers req;
 	unsigned int i;
 	int err;
 	q = get_queue(fh);
 	memset(&req, 0, sizeof(req));
 	req.type   = q->type;
 	req.count  = 8;
 	req.memory = V4L2_MEMORY_MMAP;
 	err = videobuf_reqbufs(q, &req);
 	if (err < 0)
 		return err;
 	mbuf->frames = req.count;
 	mbuf->size   = 0;
 	for (i = 0; i < mbuf->frames; i++) {
 		mbuf->offsets[i]  = q->bufs[i]->boff;
 		mbuf->size       += q->bufs[i]->bsize;
 	}
 	return 0;
 }
 #endif
 static int vidioc_reqbufs(struct file *file, void *priv,
 	struct v4l2_requestbuffers *p)
 {
 	struct cx23885_fh *fh = priv;
 	return videobuf_reqbufs(get_queue(fh), p);
 }
 static int vidioc_querybuf(struct file *file, void *priv,
 	struct v4l2_buffer *p)
 {
 	struct cx23885_fh *fh = priv;
 	return videobuf_querybuf(get_queue(fh), p);
 }
 static int vidioc_qbuf(struct file *file, void *priv,
 	struct v4l2_buffer *p)
 {
 	struct cx23885_fh *fh = priv;
 	return videobuf_qbuf(get_queue(fh), p);
 }
 static int vidioc_dqbuf(struct file *file, void *priv,
 	struct v4l2_buffer *p)
 {
 	struct cx23885_fh *fh = priv;
 	return videobuf_dqbuf(get_queue(fh), p,
 				file->f_flags & O_NONBLOCK);
 }
 static int vidioc_streamon(struct file *file, void *priv,
 	enum v4l2_buf_type i)
 {
 	struct cx23885_fh *fh = priv;
 	struct cx23885_dev *dev = fh->dev;
 	dprintk(1, "%s()\n", __func__);
 	if (unlikely(fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE))
 		return -EINVAL;
 	if (unlikely(i != fh->type))
 		return -EINVAL;
 	if (unlikely(!res_get(dev, fh, get_resource(fh))))
 		return -EBUSY;
 	return videobuf_streamon(get_queue(fh));
 }
 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
 {
 	struct cx23885_fh *fh = priv;
 	struct cx23885_dev *dev = fh->dev;
 	int err, res;
 	dprintk(1, "%s()\n", __func__);
 	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 		return -EINVAL;
 	if (i != fh->type)
 		return -EINVAL;
 	res = get_resource(fh);
 	err = videobuf_streamoff(get_queue(fh));
 	if (err < 0)
 		return err;
 	res_free(dev, fh, res);
 	return 0;
 }
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *tvnorms)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	dprintk(1, "%s()\n", __func__);
 	mutex_lock(&dev->lock);
 	cx23885_set_tvnorm(dev, *tvnorms);
 	mutex_unlock(&dev->lock);
 	return 0;
 }
 static int cx23885_enum_input(struct cx23885_dev *dev, struct v4l2_input *i)
 {
 	static const char *iname[] = {
 		[CX23885_VMUX_COMPOSITE1] = "Composite1",
 		[CX23885_VMUX_COMPOSITE2] = "Composite2",
 		[CX23885_VMUX_COMPOSITE3] = "Composite3",
 		[CX23885_VMUX_COMPOSITE4] = "Composite4",
 		[CX23885_VMUX_SVIDEO]     = "S-Video",
 		[CX23885_VMUX_TELEVISION] = "Television",
 		[CX23885_VMUX_CABLE]      = "Cable TV",
 		[CX23885_VMUX_DVB]        = "DVB",
 		[CX23885_VMUX_DEBUG]      = "for debug only",
 	};
 	unsigned int n;
 	dprintk(1, "%s()\n", __func__);
 	n = i->index;
 	if (n >= 4)
 		return -EINVAL;
 	if (0 == INPUT(n)->type)
 		return -EINVAL;
 	memset(i, 0, sizeof(*i));
 	i->index = n;
 	i->type  = V4L2_INPUT_TYPE_CAMERA;
 	strcpy(i->name, iname[INPUT(n)->type]);
 	if ((CX23885_VMUX_TELEVISION == INPUT(n)->type) ||
 		(CX23885_VMUX_CABLE == INPUT(n)->type))
 		i->type = V4L2_INPUT_TYPE_TUNER;
 		i->std = CX23885_NORMS;
 	return 0;
 }
 static int vidioc_enum_input(struct file *file, void *priv,
 				struct v4l2_input *i)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	dprintk(1, "%s()\n", __func__);
 	return cx23885_enum_input(dev, i);
 }
 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	*i = dev->input;
 	dprintk(1, "%s() returns %d\n", __func__, *i);
 	return 0;
 }
 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	dprintk(1, "%s(%d)\n", __func__, i);
 	if (i >= 4) {
 		dprintk(1, "%s() -EINVAL\n", __func__);
 		return -EINVAL;
 	}
 	mutex_lock(&dev->lock);
 	cx23885_video_mux(dev, i);
 	mutex_unlock(&dev->lock);
 	return 0;
 }
 static int vidioc_queryctrl(struct file *file, void *priv,
 				struct v4l2_queryctrl *qctrl)
 {
 	qctrl->id = v4l2_ctrl_next(ctrl_classes, qctrl->id);
 	if (unlikely(qctrl->id == 0))
 		return -EINVAL;
 	return cx23885_ctrl_query(qctrl);
 }
 static int vidioc_g_ctrl(struct file *file, void *priv,
 				struct v4l2_control *ctl)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	return cx23885_get_control(dev, ctl);
 }
 static int vidioc_s_ctrl(struct file *file, void *priv,
 				struct v4l2_control *ctl)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	return cx23885_set_control(dev, ctl);
 }
 static int vidioc_g_tuner(struct file *file, void *priv,
 				struct v4l2_tuner *t)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	if (unlikely(UNSET == dev->tuner_type))
 		return -EINVAL;
 	if (0 != t->index)
 		return -EINVAL;
 	strcpy(t->name, "Television");
 	t->type       = V4L2_TUNER_ANALOG_TV;
 	t->capability = V4L2_TUNER_CAP_NORM;
 	t->rangehigh  = 0xffffffffUL;
 	t->signal = 0xffff ; /* LOCKED */
 	return 0;
 }
 static int vidioc_s_tuner(struct file *file, void *priv,
 				struct v4l2_tuner *t)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 	if (UNSET == dev->tuner_type)
 		return -EINVAL;
 	if (0 != t->index)
 		return -EINVAL;
 	return 0;
 }
 static int vidioc_g_frequency(struct file *file, void *priv,
 				struct v4l2_frequency *f)
 {
 	struct cx23885_fh *fh = priv;
 	struct cx23885_dev *dev = fh->dev;
 	if (unlikely(UNSET == dev->tuner_type))
 		return -EINVAL;
 	/* f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; */
 	f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
 	f->frequency = dev->freq;
 	cx23885_call_i2c_clients(&dev->i2c_bus[1], VIDIOC_G_FREQUENCY, f);
 	return 0;
 }
 static int cx23885_set_freq(struct cx23885_dev *dev, struct v4l2_frequency *f)
 {
 	if (unlikely(UNSET == dev->tuner_type))
 		return -EINVAL;
 	if (unlikely(f->tuner != 0))
 		return -EINVAL;
 	mutex_lock(&dev->lock);
 	dev->freq = f->frequency;
 	cx23885_call_i2c_clients(&dev->i2c_bus[1], VIDIOC_S_FREQUENCY, f);
 	/* When changing channels it is required to reset TVAUDIO */
 	msleep(10);
 	mutex_unlock(&dev->lock);
 	return 0;
 }
 static int vidioc_s_frequency(struct file *file, void *priv,
 				struct v4l2_frequency *f)
 {
 	struct cx23885_fh *fh = priv;
 	struct cx23885_dev *dev = fh->dev;
 	if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV))
 		return -EINVAL;
 	if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO))
 		return -EINVAL;
 	return
 		cx23885_set_freq(dev, f);
 }
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_register(struct file *file, void *fh,
 				struct v4l2_dbg_register *reg)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)fh)->dev;
 	if (!v4l2_chip_match_host(&reg->match))
 		return -EINVAL;
 	cx23885_call_i2c_clients(&dev->i2c_bus[2], VIDIOC_DBG_G_REGISTER, reg);
 	return 0;
 }
 static int vidioc_s_register(struct file *file, void *fh,
 				struct v4l2_dbg_register *reg)
 {
 	struct cx23885_dev *dev = ((struct cx23885_fh *)fh)->dev;
 	if (!v4l2_chip_match_host(&reg->match))
 		return -EINVAL;
 	cx23885_call_i2c_clients(&dev->i2c_bus[2], VIDIOC_DBG_S_REGISTER, reg);
 	return 0;
 }
 #endif
 /* ----------------------------------------------------------- */
 static void cx23885_vid_timeout(unsigned long data)
 {
 	struct cx23885_dev *dev = (struct cx23885_dev *)data;
 	struct cx23885_dmaqueue *q = &dev->vidq;
 	struct cx23885_buffer *buf;
 	unsigned long flags;
 	cx23885_sram_channel_dump(dev, &dev->sram_channels[SRAM_CH01]);
 	cx_clear(VID_A_DMA_CTL, 0x11);
 	spin_lock_irqsave(&dev->slock, flags);
 	while (!list_empty(&q->active)) {
 		buf = list_entry(q->active.next,
 			struct cx23885_buffer, vb.queue);
 		list_del(&buf->vb.queue);
 		buf->vb.state = VIDEOBUF_ERROR;
 		wake_up(&buf->vb.done);
 		printk(KERN_ERR "%s/0: [%p/%d] timeout - dma=0x%08lx\n",
 			dev->name, buf, buf->vb.i,
 			(unsigned long)buf->risc.dma);
 	}
 	cx23885_restart_video_queue(dev, q);
 	spin_unlock_irqrestore(&dev->slock, flags);
 }
 int cx23885_video_irq(struct cx23885_dev *dev, u32 status)
 {
 	u32 mask, count;
 	int handled = 0;
 	mask   = cx_read(VID_A_INT_MSK);
 	if (0 == (status & mask))
 		return handled;
 	cx_write(VID_A_INT_STAT, status);
 	dprintk(2, "%s() status = 0x%08x\n", __func__, status);
 	/* risc op code error */
 	if (status & (1 << 16)) {
 		printk(KERN_WARNING "%s/0: video risc op code error\n",
 			dev->name);
 		cx_clear(VID_A_DMA_CTL, 0x11);
 		cx23885_sram_channel_dump(dev, &dev->sram_channels[SRAM_CH01]);
 	}
 	/* risc1 y */
 	if (status & 0x01) {
 		spin_lock(&dev->slock);
 		count = cx_read(VID_A_GPCNT);
 		cx23885_video_wakeup(dev, &dev->vidq, count);
 		spin_unlock(&dev->slock);
 		handled++;
 	}
 	/* risc2 y */
 	if (status & 0x10) {
 		dprintk(2, "stopper video\n");
 		spin_lock(&dev->slock);
 		cx23885_restart_video_queue(dev, &dev->vidq);
 		spin_unlock(&dev->slock);
 		handled++;
 	}
 	return handled;
 }
 /* ----------------------------------------------------------- */
 /* exported stuff                                              */
 static const struct v4l2_file_operations video_fops = {
 	.owner	       = THIS_MODULE,
 	.open	       = video_open,
 	.release       = video_release,
 	.read	       = video_read,
 	.poll          = video_poll,
 	.mmap	       = video_mmap,
 	.ioctl	       = video_ioctl2,
 };
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
 	.vidioc_querycap      = vidioc_querycap,
 	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
 	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
 	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
 	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
 	.vidioc_g_fmt_vbi_cap     = cx23885_vbi_fmt,
 	.vidioc_try_fmt_vbi_cap   = cx23885_vbi_fmt,
 	.vidioc_s_fmt_vbi_cap     = cx23885_vbi_fmt,
 	.vidioc_reqbufs       = vidioc_reqbufs,
 	.vidioc_querybuf      = vidioc_querybuf,
 	.vidioc_qbuf          = vidioc_qbuf,
 	.vidioc_dqbuf         = vidioc_dqbuf,
 	.vidioc_s_std         = vidioc_s_std,
 	.vidioc_enum_input    = vidioc_enum_input,
 	.vidioc_g_input       = vidioc_g_input,
 	.vidioc_s_input       = vidioc_s_input,
 	.vidioc_queryctrl     = vidioc_queryctrl,
 	.vidioc_g_ctrl        = vidioc_g_ctrl,
 	.vidioc_s_ctrl        = vidioc_s_ctrl,
 	.vidioc_streamon      = vidioc_streamon,
 	.vidioc_streamoff     = vidioc_streamoff,
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 	.vidiocgmbuf          = vidiocgmbuf,
 #endif
 	.vidioc_g_tuner       = vidioc_g_tuner,
 	.vidioc_s_tuner       = vidioc_s_tuner,
 	.vidioc_g_frequency   = vidioc_g_frequency,
 	.vidioc_s_frequency   = vidioc_s_frequency,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	.vidioc_g_register    = vidioc_g_register,
 	.vidioc_s_register    = vidioc_s_register,
 #endif
 };
 static struct video_device cx23885_vbi_template;
 static struct video_device cx23885_video_template = {
 	.name                 = "cx23885-video",
 	.fops                 = &video_fops,
 	.minor                = -1,
 	.ioctl_ops 	      = &video_ioctl_ops,
 	.tvnorms              = CX23885_NORMS,
 	.current_norm         = V4L2_STD_NTSC_M,
 };
 static const struct v4l2_file_operations radio_fops = {
 	.owner         = THIS_MODULE,
 	.open          = video_open,
 	.release       = video_release,
 	.ioctl         = video_ioctl2,
 };
 void cx23885_video_unregister(struct cx23885_dev *dev)
 {
 	dprintk(1, "%s()\n", __func__);
 	cx_clear(PCI_INT_MSK, 1);
 	if (dev->video_dev) {
 		if (-1 != dev->video_dev->minor)
 			video_unregister_device(dev->video_dev);
 		else
 			video_device_release(dev->video_dev);
 		dev->video_dev = NULL;
 		btcx_riscmem_free(dev->pci, &dev->vidq.stopper);
 	}
 }
 int cx23885_video_register(struct cx23885_dev *dev)
 {
 	int err;
 	dprintk(1, "%s()\n", __func__);
 	spin_lock_init(&dev->slock);
 	/* Initialize VBI template */
 	memcpy(&cx23885_vbi_template, &cx23885_video_template,
 		sizeof(cx23885_vbi_template));
 	strcpy(cx23885_vbi_template.name, "cx23885-vbi");
 	dev->tvnorm = cx23885_video_template.current_norm;
 	/* init video dma queues */
 	INIT_LIST_HEAD(&dev->vidq.active);
 	INIT_LIST_HEAD(&dev->vidq.queued);
 	dev->vidq.timeout.function = cx23885_vid_timeout;
 	dev->vidq.timeout.data = (unsigned long)dev;
 	init_timer(&dev->vidq.timeout);
 	cx23885_risc_stopper(dev->pci, &dev->vidq.stopper,
 		VID_A_DMA_CTL, 0x11, 0x00);
 	/* Don't enable VBI yet */
 	cx_set(PCI_INT_MSK, 1);
 	/* register v4l devices */
 	dev->video_dev = cx23885_vdev_init(dev, dev->pci,
 		&cx23885_video_template, "video");
 	err = video_register_device(dev->video_dev, VFL_TYPE_GRABBER,
 				    video_nr[dev->nr]);
 	if (err < 0) {
 		printk(KERN_INFO "%s: can't register video device\n",
 			dev->name);
 		goto fail_unreg;
 	}
 	printk(KERN_INFO "%s/0: registered device video%d [v4l2]\n",
 	       dev->name, dev->video_dev->num);
 	/* initial device configuration */
 	mutex_lock(&dev->lock);
 	cx23885_set_tvnorm(dev, dev->tvnorm);
 	init_controls(dev);
 	cx23885_video_mux(dev, 0);
 	mutex_unlock(&dev->lock);
 	return 0;
 fail_unreg:
 	cx23885_video_unregister(dev);
 	return err;
 }

drivers/media/video/cx88/cx88-video.c

Diff comments View file @ 7e0a16f

 /*
  *
  * device driver for Conexant 2388x based TV cards
  * video4linux video interface
  *
  * (c) 2003-04 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
  *
  * (c) 2005-2006 Mauro Carvalho Chehab <mchehab@infradead.org>
  *	- Multituner support
  *	- video_ioctl2 conversion
  *	- PAL/M fixes
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/kmod.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/dma-mapping.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
 #include <asm/div64.h>
 #include "cx88.h"
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
-#ifdef CONFIG_VIDEO_V4L1_COMPAT
-/* Include V4L1 specific functions. Should be removed soon */
-#include <linux/videodev.h>
-#endif
 MODULE_DESCRIPTION("v4l2 driver module for cx2388x based TV cards");
 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
 MODULE_LICENSE("GPL");
 /* ------------------------------------------------------------------ */
 static unsigned int video_nr[] = {[0 ... (CX88_MAXBOARDS - 1)] = UNSET };
 static unsigned int vbi_nr[]   = {[0 ... (CX88_MAXBOARDS - 1)] = UNSET };
 static unsigned int radio_nr[] = {[0 ... (CX88_MAXBOARDS - 1)] = UNSET };
 module_param_array(video_nr, int, NULL, 0444);
 module_param_array(vbi_nr,   int, NULL, 0444);
 module_param_array(radio_nr, int, NULL, 0444);
 MODULE_PARM_DESC(video_nr,"video device numbers");
 MODULE_PARM_DESC(vbi_nr,"vbi device numbers");
 MODULE_PARM_DESC(radio_nr,"radio device numbers");
 static unsigned int video_debug;
 module_param(video_debug,int,0644);
 MODULE_PARM_DESC(video_debug,"enable debug messages [video]");
 static unsigned int irq_debug;
 module_param(irq_debug,int,0644);
 MODULE_PARM_DESC(irq_debug,"enable debug messages [IRQ handler]");
 static unsigned int vid_limit = 16;
 module_param(vid_limit,int,0644);
 MODULE_PARM_DESC(vid_limit,"capture memory limit in megabytes");
 #define dprintk(level,fmt, arg...)	if (video_debug >= level) \
 	printk(KERN_DEBUG "%s/0: " fmt, core->name , ## arg)
 /* ------------------------------------------------------------------ */
 static LIST_HEAD(cx8800_devlist);
 /* ------------------------------------------------------------------- */
 /* static data                                                         */
 static struct cx8800_fmt formats[] = {
 	{
 		.name     = "8 bpp, gray",
 		.fourcc   = V4L2_PIX_FMT_GREY,
 		.cxformat = ColorFormatY8,
 		.depth    = 8,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "15 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_RGB555,
 		.cxformat = ColorFormatRGB15,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "15 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB555X,
 		.cxformat = ColorFormatRGB15 | ColorFormatBSWAP,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "16 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_RGB565,
 		.cxformat = ColorFormatRGB16,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "16 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB565X,
 		.cxformat = ColorFormatRGB16 | ColorFormatBSWAP,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "24 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_BGR24,
 		.cxformat = ColorFormatRGB24,
 		.depth    = 24,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "32 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_BGR32,
 		.cxformat = ColorFormatRGB32,
 		.depth    = 32,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "32 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB32,
 		.cxformat = ColorFormatRGB32 | ColorFormatBSWAP | ColorFormatWSWAP,
 		.depth    = 32,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "4:2:2, packed, YUYV",
 		.fourcc   = V4L2_PIX_FMT_YUYV,
 		.cxformat = ColorFormatYUY2,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},{
 		.name     = "4:2:2, packed, UYVY",
 		.fourcc   = V4L2_PIX_FMT_UYVY,
 		.cxformat = ColorFormatYUY2 | ColorFormatBSWAP,
 		.depth    = 16,
 		.flags    = FORMAT_FLAGS_PACKED,
 	},
 };
 static struct cx8800_fmt* format_by_fourcc(unsigned int fourcc)
 {
 	unsigned int i;
 	for (i = 0; i < ARRAY_SIZE(formats); i++)
 		if (formats[i].fourcc == fourcc)
 			return formats+i;
 	return NULL;
 }
 /* ------------------------------------------------------------------- */
 static const struct v4l2_queryctrl no_ctl = {
 	.name  = "42",
 	.flags = V4L2_CTRL_FLAG_DISABLED,
 };
 static struct cx88_ctrl cx8800_ctls[] = {
 	/* --- video --- */
 	{
 		.v = {
 			.id            = V4L2_CID_BRIGHTNESS,
 			.name          = "Brightness",
 			.minimum       = 0x00,
 			.maximum       = 0xff,
 			.step          = 1,
 			.default_value = 0x7f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.off                   = 128,
 		.reg                   = MO_CONTR_BRIGHT,
 		.mask                  = 0x00ff,
 		.shift                 = 0,
 	},{
 		.v = {
 			.id            = V4L2_CID_CONTRAST,
 			.name          = "Contrast",
 			.minimum       = 0,
 			.maximum       = 0xff,
 			.step          = 1,
 			.default_value = 0x3f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.off                   = 0,
 		.reg                   = MO_CONTR_BRIGHT,
 		.mask                  = 0xff00,
 		.shift                 = 8,
 	},{
 		.v = {
 			.id            = V4L2_CID_HUE,
 			.name          = "Hue",
 			.minimum       = 0,
 			.maximum       = 0xff,
 			.step          = 1,
 			.default_value = 0x7f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.off                   = 128,
 		.reg                   = MO_HUE,
 		.mask                  = 0x00ff,
 		.shift                 = 0,
 	},{
 		/* strictly, this only describes only U saturation.
 		 * V saturation is handled specially through code.
 		 */
 		.v = {
 			.id            = V4L2_CID_SATURATION,
 			.name          = "Saturation",
 			.minimum       = 0,
 			.maximum       = 0xff,
 			.step          = 1,
 			.default_value = 0x7f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.off                   = 0,
 		.reg                   = MO_UV_SATURATION,
 		.mask                  = 0x00ff,
 		.shift                 = 0,
 	},{
 		.v = {
 			.id            = V4L2_CID_CHROMA_AGC,
 			.name          = "Chroma AGC",
 			.minimum       = 0,
 			.maximum       = 1,
 			.default_value = 0x1,
 			.type          = V4L2_CTRL_TYPE_BOOLEAN,
 		},
 		.reg                   = MO_INPUT_FORMAT,
 		.mask                  = 1 << 10,
 		.shift                 = 10,
 	}, {
 		.v = {
 			.id            = V4L2_CID_COLOR_KILLER,
 			.name          = "Color killer",
 			.minimum       = 0,
 			.maximum       = 1,
 			.default_value = 0x1,
 			.type          = V4L2_CTRL_TYPE_BOOLEAN,
 		},
 		.reg                   = MO_INPUT_FORMAT,
 		.mask                  = 1 << 9,
 		.shift                 = 9,
 	}, {
 	/* --- audio --- */
 		.v = {
 			.id            = V4L2_CID_AUDIO_MUTE,
 			.name          = "Mute",
 			.minimum       = 0,
 			.maximum       = 1,
 			.default_value = 1,
 			.type          = V4L2_CTRL_TYPE_BOOLEAN,
 		},
 		.reg                   = AUD_VOL_CTL,
 		.sreg                  = SHADOW_AUD_VOL_CTL,
 		.mask                  = (1 << 6),
 		.shift                 = 6,
 	},{
 		.v = {
 			.id            = V4L2_CID_AUDIO_VOLUME,
 			.name          = "Volume",
 			.minimum       = 0,
 			.maximum       = 0x3f,
 			.step          = 1,
 			.default_value = 0x3f,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.reg                   = AUD_VOL_CTL,
 		.sreg                  = SHADOW_AUD_VOL_CTL,
 		.mask                  = 0x3f,
 		.shift                 = 0,
 	},{
 		.v = {
 			.id            = V4L2_CID_AUDIO_BALANCE,
 			.name          = "Balance",
 			.minimum       = 0,
 			.maximum       = 0x7f,
 			.step          = 1,
 			.default_value = 0x40,
 			.type          = V4L2_CTRL_TYPE_INTEGER,
 		},
 		.reg                   = AUD_BAL_CTL,
 		.sreg                  = SHADOW_AUD_BAL_CTL,
 		.mask                  = 0x7f,
 		.shift                 = 0,
 	}
 };
 static const int CX8800_CTLS = ARRAY_SIZE(cx8800_ctls);
 /* Must be sorted from low to high control ID! */
 const u32 cx88_user_ctrls[] = {
 	V4L2_CID_USER_CLASS,
 	V4L2_CID_BRIGHTNESS,
 	V4L2_CID_CONTRAST,
 	V4L2_CID_SATURATION,
 	V4L2_CID_HUE,
 	V4L2_CID_AUDIO_VOLUME,
 	V4L2_CID_AUDIO_BALANCE,
 	V4L2_CID_AUDIO_MUTE,
 	V4L2_CID_CHROMA_AGC,
 	V4L2_CID_COLOR_KILLER,
 	0
 };
 EXPORT_SYMBOL(cx88_user_ctrls);
 static const u32 *ctrl_classes[] = {
 	cx88_user_ctrls,
 	NULL
 };
 int cx8800_ctrl_query(struct cx88_core *core, struct v4l2_queryctrl *qctrl)
 {
 	int i;
 	if (qctrl->id < V4L2_CID_BASE ||
 	    qctrl->id >= V4L2_CID_LASTP1)
 		return -EINVAL;
 	for (i = 0; i < CX8800_CTLS; i++)
 		if (cx8800_ctls[i].v.id == qctrl->id)
 			break;
 	if (i == CX8800_CTLS) {
 		*qctrl = no_ctl;
 		return 0;
 	}
 	*qctrl = cx8800_ctls[i].v;
 	/* Report chroma AGC as inactive when SECAM is selected */
 	if (cx8800_ctls[i].v.id == V4L2_CID_CHROMA_AGC &&
 	    core->tvnorm & V4L2_STD_SECAM)
 		qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
 	return 0;
 }
 EXPORT_SYMBOL(cx8800_ctrl_query);
 /* ------------------------------------------------------------------- */
 /* resource management                                                 */
 static int res_get(struct cx8800_dev *dev, struct cx8800_fh *fh, unsigned int bit)
 {
 	struct cx88_core *core = dev->core;
 	if (fh->resources & bit)
 		/* have it already allocated */
 		return 1;
 	/* is it free? */
 	mutex_lock(&core->lock);
 	if (dev->resources & bit) {
 		/* no, someone else uses it */
 		mutex_unlock(&core->lock);
 		return 0;
 	}
 	/* it's free, grab it */
 	fh->resources  |= bit;
 	dev->resources |= bit;
 	dprintk(1,"res: get %d\n",bit);
 	mutex_unlock(&core->lock);
 	return 1;
 }
 static
 int res_check(struct cx8800_fh *fh, unsigned int bit)
 {
 	return (fh->resources & bit);
 }
 static
 int res_locked(struct cx8800_dev *dev, unsigned int bit)
 {
 	return (dev->resources & bit);
 }
 static
 void res_free(struct cx8800_dev *dev, struct cx8800_fh *fh, unsigned int bits)
 {
 	struct cx88_core *core = dev->core;
 	BUG_ON((fh->resources & bits) != bits);
 	mutex_lock(&core->lock);
 	fh->resources  &= ~bits;
 	dev->resources &= ~bits;
 	dprintk(1,"res: put %d\n",bits);
 	mutex_unlock(&core->lock);
 }
 /* ------------------------------------------------------------------ */
 int cx88_video_mux(struct cx88_core *core, unsigned int input)
 {
 	/* struct cx88_core *core = dev->core; */
 	dprintk(1,"video_mux: %d [vmux=%d,gpio=0x%x,0x%x,0x%x,0x%x]\n",
 		input, INPUT(input).vmux,
 		INPUT(input).gpio0,INPUT(input).gpio1,
 		INPUT(input).gpio2,INPUT(input).gpio3);
 	core->input = input;
 	cx_andor(MO_INPUT_FORMAT, 0x03 << 14, INPUT(input).vmux << 14);
 	cx_write(MO_GP3_IO, INPUT(input).gpio3);
 	cx_write(MO_GP0_IO, INPUT(input).gpio0);
 	cx_write(MO_GP1_IO, INPUT(input).gpio1);
 	cx_write(MO_GP2_IO, INPUT(input).gpio2);
 	switch (INPUT(input).type) {
 	case CX88_VMUX_SVIDEO:
 		cx_set(MO_AFECFG_IO,    0x00000001);
 		cx_set(MO_INPUT_FORMAT, 0x00010010);
 		cx_set(MO_FILTER_EVEN,  0x00002020);
 		cx_set(MO_FILTER_ODD,   0x00002020);
 		break;
 	default:
 		cx_clear(MO_AFECFG_IO,    0x00000001);
 		cx_clear(MO_INPUT_FORMAT, 0x00010010);
 		cx_clear(MO_FILTER_EVEN,  0x00002020);
 		cx_clear(MO_FILTER_ODD,   0x00002020);
 		break;
 	}
 	/* if there are audioroutes defined, we have an external
 	   ADC to deal with audio */
 	if (INPUT(input).audioroute) {
 		/* The wm8775 module has the "2" route hardwired into
 		   the initialization. Some boards may use different
 		   routes for different inputs. HVR-1300 surely does */
 		if (core->board.audio_chip &&
 		    core->board.audio_chip == V4L2_IDENT_WM8775) {
 			struct v4l2_routing route;
 			route.input = INPUT(input).audioroute;
 			cx88_call_i2c_clients(core,
 				VIDIOC_INT_S_AUDIO_ROUTING, &route);
 		}
 		/* cx2388's C-ADC is connected to the tuner only.
 		   When used with S-Video, that ADC is busy dealing with
 		   chroma, so an external must be used for baseband audio */
 		if (INPUT(input).type != CX88_VMUX_TELEVISION ) {
 			/* "I2S ADC mode" */
 			core->tvaudio = WW_I2SADC;
 			cx88_set_tvaudio(core);
 		} else {
 			/* Normal mode */
 			cx_write(AUD_I2SCNTL, 0x0);
 			cx_clear(AUD_CTL, EN_I2SIN_ENABLE);
 		}
 	}
 	return 0;
 }
 EXPORT_SYMBOL(cx88_video_mux);
 /* ------------------------------------------------------------------ */
 static int start_video_dma(struct cx8800_dev    *dev,
 			   struct cx88_dmaqueue *q,
 			   struct cx88_buffer   *buf)
 {
 	struct cx88_core *core = dev->core;
 	/* setup fifo + format */
 	cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH21],
 				buf->bpl, buf->risc.dma);
 	cx88_set_scale(core, buf->vb.width, buf->vb.height, buf->vb.field);
 	cx_write(MO_COLOR_CTRL, buf->fmt->cxformat | ColorFormatGamma);
 	/* reset counter */
 	cx_write(MO_VIDY_GPCNTRL,GP_COUNT_CONTROL_RESET);
 	q->count = 1;
 	/* enable irqs */
 	cx_set(MO_PCI_INTMSK, core->pci_irqmask | PCI_INT_VIDINT);
 	/* Enables corresponding bits at PCI_INT_STAT:
 		bits 0 to 4: video, audio, transport stream, VIP, Host
 		bit 7: timer
 		bits 8 and 9: DMA complete for: SRC, DST
 		bits 10 and 11: BERR signal asserted for RISC: RD, WR
 		bits 12 to 15: BERR signal asserted for: BRDG, SRC, DST, IPB
 	 */
 	cx_set(MO_VID_INTMSK, 0x0f0011);
 	/* enable capture */
 	cx_set(VID_CAPTURE_CONTROL,0x06);
 	/* start dma */
 	cx_set(MO_DEV_CNTRL2, (1<<5));
 	cx_set(MO_VID_DMACNTRL, 0x11); /* Planar Y and packed FIFO and RISC enable */
 	return 0;
 }
 #ifdef CONFIG_PM
 static int stop_video_dma(struct cx8800_dev    *dev)
 {
 	struct cx88_core *core = dev->core;
 	/* stop dma */
 	cx_clear(MO_VID_DMACNTRL, 0x11);
 	/* disable capture */
 	cx_clear(VID_CAPTURE_CONTROL,0x06);
 	/* disable irqs */
 	cx_clear(MO_PCI_INTMSK, PCI_INT_VIDINT);
 	cx_clear(MO_VID_INTMSK, 0x0f0011);
 	return 0;
 }
 #endif
 static int restart_video_queue(struct cx8800_dev    *dev,
 			       struct cx88_dmaqueue *q)
 {
 	struct cx88_core *core = dev->core;
 	struct cx88_buffer *buf, *prev;
 	if (!list_empty(&q->active)) {
 		buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
 		dprintk(2,"restart_queue [%p/%d]: restart dma\n",
 			buf, buf->vb.i);
 		start_video_dma(dev, q, buf);
 		list_for_each_entry(buf, &q->active, vb.queue)
 			buf->count = q->count++;
 		mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 		return 0;
 	}
 	prev = NULL;
 	for (;;) {
 		if (list_empty(&q->queued))
 			return 0;
 		buf = list_entry(q->queued.next, struct cx88_buffer, vb.queue);
 		if (NULL == prev) {
 			list_move_tail(&buf->vb.queue, &q->active);
 			start_video_dma(dev, q, buf);
 			buf->vb.state = VIDEOBUF_ACTIVE;
 			buf->count    = q->count++;
 			mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 			dprintk(2,"[%p/%d] restart_queue - first active\n",
 				buf,buf->vb.i);
 		} else if (prev->vb.width  == buf->vb.width  &&
 			   prev->vb.height == buf->vb.height &&
 			   prev->fmt       == buf->fmt) {
 			list_move_tail(&buf->vb.queue, &q->active);
 			buf->vb.state = VIDEOBUF_ACTIVE;
 			buf->count    = q->count++;
 			prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 			dprintk(2,"[%p/%d] restart_queue - move to active\n",
 				buf,buf->vb.i);
 		} else {
 			return 0;
 		}
 		prev = buf;
 	}
 }
 /* ------------------------------------------------------------------ */
 static int
 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
 {
 	struct cx8800_fh *fh = q->priv_data;
 	*size = fh->fmt->depth*fh->width*fh->height >> 3;
 	if (0 == *count)
 		*count = 32;
 	while (*size * *count > vid_limit * 1024 * 1024)
 		(*count)--;
 	return 0;
 }
 static int
 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
 	       enum v4l2_field field)
 {
 	struct cx8800_fh   *fh  = q->priv_data;
 	struct cx8800_dev  *dev = fh->dev;
 	struct cx88_core *core = dev->core;
 	struct cx88_buffer *buf = container_of(vb,struct cx88_buffer,vb);
 	struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
 	int rc, init_buffer = 0;
 	BUG_ON(NULL == fh->fmt);
 	if (fh->width  < 48 || fh->width  > norm_maxw(core->tvnorm) ||
 	    fh->height < 32 || fh->height > norm_maxh(core->tvnorm))
 		return -EINVAL;
 	buf->vb.size = (fh->width * fh->height * fh->fmt->depth) >> 3;
 	if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
 		return -EINVAL;
 	if (buf->fmt       != fh->fmt    ||
 	    buf->vb.width  != fh->width  ||
 	    buf->vb.height != fh->height ||
 	    buf->vb.field  != field) {
 		buf->fmt       = fh->fmt;
 		buf->vb.width  = fh->width;
 		buf->vb.height = fh->height;
 		buf->vb.field  = field;
 		init_buffer = 1;
 	}
 	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 		init_buffer = 1;
 		if (0 != (rc = videobuf_iolock(q,&buf->vb,NULL)))
 			goto fail;
 	}
 	if (init_buffer) {
 		buf->bpl = buf->vb.width * buf->fmt->depth >> 3;
 		switch (buf->vb.field) {
 		case V4L2_FIELD_TOP:
 			cx88_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist, 0, UNSET,
 					 buf->bpl, 0, buf->vb.height);
 			break;
 		case V4L2_FIELD_BOTTOM:
 			cx88_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist, UNSET, 0,
 					 buf->bpl, 0, buf->vb.height);
 			break;
 		case V4L2_FIELD_INTERLACED:
 			cx88_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist, 0, buf->bpl,
 					 buf->bpl, buf->bpl,
 					 buf->vb.height >> 1);
 			break;
 		case V4L2_FIELD_SEQ_TB:
 			cx88_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist,
 					 0, buf->bpl * (buf->vb.height >> 1),
 					 buf->bpl, 0,
 					 buf->vb.height >> 1);
 			break;
 		case V4L2_FIELD_SEQ_BT:
 			cx88_risc_buffer(dev->pci, &buf->risc,
 					 dma->sglist,
 					 buf->bpl * (buf->vb.height >> 1), 0,
 					 buf->bpl, 0,
 					 buf->vb.height >> 1);
 			break;
 		default:
 			BUG();
 		}
 	}
 	dprintk(2,"[%p/%d] buffer_prepare - %dx%d %dbpp \"%s\" - dma=0x%08lx\n",
 		buf, buf->vb.i,
 		fh->width, fh->height, fh->fmt->depth, fh->fmt->name,
 		(unsigned long)buf->risc.dma);
 	buf->vb.state = VIDEOBUF_PREPARED;
 	return 0;
  fail:
 	cx88_free_buffer(q,buf);
 	return rc;
 }
 static void
 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 {
 	struct cx88_buffer    *buf = container_of(vb,struct cx88_buffer,vb);
 	struct cx88_buffer    *prev;
 	struct cx8800_fh      *fh   = vq->priv_data;
 	struct cx8800_dev     *dev  = fh->dev;
 	struct cx88_core      *core = dev->core;
 	struct cx88_dmaqueue  *q    = &dev->vidq;
 	/* add jump to stopper */
 	buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | RISC_CNT_INC);
 	buf->risc.jmp[1] = cpu_to_le32(q->stopper.dma);
 	if (!list_empty(&q->queued)) {
 		list_add_tail(&buf->vb.queue,&q->queued);
 		buf->vb.state = VIDEOBUF_QUEUED;
 		dprintk(2,"[%p/%d] buffer_queue - append to queued\n",
 			buf, buf->vb.i);
 	} else if (list_empty(&q->active)) {
 		list_add_tail(&buf->vb.queue,&q->active);
 		start_video_dma(dev, q, buf);
 		buf->vb.state = VIDEOBUF_ACTIVE;
 		buf->count    = q->count++;
 		mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
 		dprintk(2,"[%p/%d] buffer_queue - first active\n",
 			buf, buf->vb.i);
 	} else {
 		prev = list_entry(q->active.prev, struct cx88_buffer, vb.queue);
 		if (prev->vb.width  == buf->vb.width  &&
 		    prev->vb.height == buf->vb.height &&
 		    prev->fmt       == buf->fmt) {
 			list_add_tail(&buf->vb.queue,&q->active);
 			buf->vb.state = VIDEOBUF_ACTIVE;
 			buf->count    = q->count++;
 			prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
 			dprintk(2,"[%p/%d] buffer_queue - append to active\n",
 				buf, buf->vb.i);
 		} else {
 			list_add_tail(&buf->vb.queue,&q->queued);
 			buf->vb.state = VIDEOBUF_QUEUED;
 			dprintk(2,"[%p/%d] buffer_queue - first queued\n",
 				buf, buf->vb.i);
 		}
 	}
 }
 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
 {
 	struct cx88_buffer *buf = container_of(vb,struct cx88_buffer,vb);
 	cx88_free_buffer(q,buf);
 }
 static struct videobuf_queue_ops cx8800_video_qops = {
 	.buf_setup    = buffer_setup,
 	.buf_prepare  = buffer_prepare,
 	.buf_queue    = buffer_queue,
 	.buf_release  = buffer_release,
 };
 /* ------------------------------------------------------------------ */
 /* ------------------------------------------------------------------ */
 static struct videobuf_queue* get_queue(struct cx8800_fh *fh)
 {
 	switch (fh->type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		return &fh->vidq;
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		return &fh->vbiq;
 	default:
 		BUG();
 		return NULL;
 	}
 }
 static int get_ressource(struct cx8800_fh *fh)
 {
 	switch (fh->type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		return RESOURCE_VIDEO;
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		return RESOURCE_VBI;
 	default:
 		BUG();
 		return 0;
 	}
 }
 static int video_open(struct file *file)
 {
 	int minor = video_devdata(file)->minor;
 	struct cx8800_dev *h,*dev = NULL;
 	struct cx88_core *core;
 	struct cx8800_fh *fh;
 	enum v4l2_buf_type type = 0;
 	int radio = 0;
 	lock_kernel();
 	list_for_each_entry(h, &cx8800_devlist, devlist) {
 		if (h->video_dev->minor == minor) {
 			dev  = h;
 			type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 		}
 		if (h->vbi_dev->minor == minor) {
 			dev  = h;
 			type = V4L2_BUF_TYPE_VBI_CAPTURE;
 		}
 		if (h->radio_dev &&
 		    h->radio_dev->minor == minor) {
 			radio = 1;
 			dev   = h;
 		}
 	}
 	if (NULL == dev) {
 		unlock_kernel();
 		return -ENODEV;
 	}
 	core = dev->core;
 	dprintk(1,"open minor=%d radio=%d type=%s\n",
 		minor,radio,v4l2_type_names[type]);
 	/* allocate + initialize per filehandle data */
 	fh = kzalloc(sizeof(*fh),GFP_KERNEL);
 	if (NULL == fh) {
 		unlock_kernel();
 		return -ENOMEM;
 	}
 	file->private_data = fh;
 	fh->dev      = dev;
 	fh->radio    = radio;
 	fh->type     = type;
 	fh->width    = 320;
 	fh->height   = 240;
 	fh->fmt      = format_by_fourcc(V4L2_PIX_FMT_BGR24);
 	videobuf_queue_sg_init(&fh->vidq, &cx8800_video_qops,
 			    &dev->pci->dev, &dev->slock,
 			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
 			    V4L2_FIELD_INTERLACED,
 			    sizeof(struct cx88_buffer),
 			    fh);
 	videobuf_queue_sg_init(&fh->vbiq, &cx8800_vbi_qops,
 			    &dev->pci->dev, &dev->slock,
 			    V4L2_BUF_TYPE_VBI_CAPTURE,
 			    V4L2_FIELD_SEQ_TB,
 			    sizeof(struct cx88_buffer),
 			    fh);
 	if (fh->radio) {
 		dprintk(1,"video_open: setting radio device\n");
 		cx_write(MO_GP3_IO, core->board.radio.gpio3);
 		cx_write(MO_GP0_IO, core->board.radio.gpio0);
 		cx_write(MO_GP1_IO, core->board.radio.gpio1);
 		cx_write(MO_GP2_IO, core->board.radio.gpio2);
 		if (core->board.radio.audioroute) {
 			if(core->board.audio_chip &&
 				core->board.audio_chip == V4L2_IDENT_WM8775) {
 				struct v4l2_routing route;
 				route.input = core->board.radio.audioroute;
 				cx88_call_i2c_clients(core,
 					VIDIOC_INT_S_AUDIO_ROUTING, &route);
 			}
 			/* "I2S ADC mode" */
 			core->tvaudio = WW_I2SADC;
 			cx88_set_tvaudio(core);
 		} else {
 			/* FM Mode */
 			core->tvaudio = WW_FM;
 			cx88_set_tvaudio(core);
 			cx88_set_stereo(core,V4L2_TUNER_MODE_STEREO,1);
 		}
 		cx88_call_i2c_clients(core,AUDC_SET_RADIO,NULL);
 	}
 	unlock_kernel();
 	atomic_inc(&core->users);
 	return 0;
 }
 static ssize_t
 video_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
 {
 	struct cx8800_fh *fh = file->private_data;
 	switch (fh->type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		if (res_locked(fh->dev,RESOURCE_VIDEO))
 			return -EBUSY;
 		return videobuf_read_one(&fh->vidq, data, count, ppos,
 					 file->f_flags & O_NONBLOCK);
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		if (!res_get(fh->dev,fh,RESOURCE_VBI))
 			return -EBUSY;
 		return videobuf_read_stream(&fh->vbiq, data, count, ppos, 1,
 					    file->f_flags & O_NONBLOCK);
 	default:
 		BUG();
 		return 0;
 	}
 }
 static unsigned int
 video_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct cx8800_fh *fh = file->private_data;
 	struct cx88_buffer *buf;
 	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
 		if (!res_get(fh->dev,fh,RESOURCE_VBI))
 			return POLLERR;
 		return videobuf_poll_stream(file, &fh->vbiq, wait);
 	}
 	if (res_check(fh,RESOURCE_VIDEO)) {
 		/* streaming capture */
 		if (list_empty(&fh->vidq.stream))
 			return POLLERR;
 		buf = list_entry(fh->vidq.stream.next,struct cx88_buffer,vb.stream);
 	} else {
 		/* read() capture */
 		buf = (struct cx88_buffer*)fh->vidq.read_buf;
 		if (NULL == buf)
 			return POLLERR;
 	}
 	poll_wait(file, &buf->vb.done, wait);
 	if (buf->vb.state == VIDEOBUF_DONE ||
 	    buf->vb.state == VIDEOBUF_ERROR)
 		return POLLIN|POLLRDNORM;
 	return 0;
 }
 static int video_release(struct file *file)
 {
 	struct cx8800_fh  *fh  = file->private_data;
 	struct cx8800_dev *dev = fh->dev;
 	/* turn off overlay */
 	if (res_check(fh, RESOURCE_OVERLAY)) {
 		/* FIXME */
 		res_free(dev,fh,RESOURCE_OVERLAY);
 	}
 	/* stop video capture */
 	if (res_check(fh, RESOURCE_VIDEO)) {
 		videobuf_queue_cancel(&fh->vidq);
 		res_free(dev,fh,RESOURCE_VIDEO);
 	}
 	if (fh->vidq.read_buf) {
 		buffer_release(&fh->vidq,fh->vidq.read_buf);
 		kfree(fh->vidq.read_buf);
 	}
 	/* stop vbi capture */
 	if (res_check(fh, RESOURCE_VBI)) {
 		videobuf_stop(&fh->vbiq);
 		res_free(dev,fh,RESOURCE_VBI);
 	}
 	videobuf_mmap_free(&fh->vidq);
 	videobuf_mmap_free(&fh->vbiq);
 	file->private_data = NULL;
 	kfree(fh);
 	if(atomic_dec_and_test(&dev->core->users))
 		cx88_call_i2c_clients (dev->core, TUNER_SET_STANDBY, NULL);
 	return 0;
 }
 static int
 video_mmap(struct file *file, struct vm_area_struct * vma)
 {
 	struct cx8800_fh *fh = file->private_data;
 	return videobuf_mmap_mapper(get_queue(fh), vma);
 }
 /* ------------------------------------------------------------------ */
 /* VIDEO CTRL IOCTLS                                                  */
 int cx88_get_control (struct cx88_core  *core, struct v4l2_control *ctl)
 {
 	struct cx88_ctrl  *c    = NULL;
 	u32 value;
 	int i;
 	for (i = 0; i < CX8800_CTLS; i++)
 		if (cx8800_ctls[i].v.id == ctl->id)
 			c = &cx8800_ctls[i];
 	if (unlikely(NULL == c))
 		return -EINVAL;
 	value = c->sreg ? cx_sread(c->sreg) : cx_read(c->reg);
 	switch (ctl->id) {
 	case V4L2_CID_AUDIO_BALANCE:
 		ctl->value = ((value & 0x7f) < 0x40) ? ((value & 0x7f) + 0x40)
 					: (0x7f - (value & 0x7f));
 		break;
 	case V4L2_CID_AUDIO_VOLUME:
 		ctl->value = 0x3f - (value & 0x3f);
 		break;
 	default:
 		ctl->value = ((value + (c->off << c->shift)) & c->mask) >> c->shift;
 		break;
 	}
 	dprintk(1,"get_control id=0x%X(%s) ctrl=0x%02x, reg=0x%02x val=0x%02x (mask 0x%02x)%s\n",
 				ctl->id, c->v.name, ctl->value, c->reg,
 				value,c->mask, c->sreg ? " [shadowed]" : "");
 	return 0;
 }
 EXPORT_SYMBOL(cx88_get_control);
 int cx88_set_control(struct cx88_core *core, struct v4l2_control *ctl)
 {
 	struct cx88_ctrl *c = NULL;
 	u32 value,mask;
 	int i;
 	for (i = 0; i < CX8800_CTLS; i++) {
 		if (cx8800_ctls[i].v.id == ctl->id) {
 			c = &cx8800_ctls[i];
 		}
 	}
 	if (unlikely(NULL == c))
 		return -EINVAL;
 	if (ctl->value < c->v.minimum)
 		ctl->value = c->v.minimum;
 	if (ctl->value > c->v.maximum)
 		ctl->value = c->v.maximum;
 	mask=c->mask;
 	switch (ctl->id) {
 	case V4L2_CID_AUDIO_BALANCE:
 		value = (ctl->value < 0x40) ? (0x7f - ctl->value) : (ctl->value - 0x40);
 		break;
 	case V4L2_CID_AUDIO_VOLUME:
 		value = 0x3f - (ctl->value & 0x3f);
 		break;
 	case V4L2_CID_SATURATION:
 		/* special v_sat handling */
 		value = ((ctl->value - c->off) << c->shift) & c->mask;
 		if (core->tvnorm & V4L2_STD_SECAM) {
 			/* For SECAM, both U and V sat should be equal */
 			value=value<<8|value;
 		} else {
 			/* Keeps U Saturation proportional to V Sat */
 			value=(value*0x5a)/0x7f<<8|value;
 		}
 		mask=0xffff;
 		break;
 	case V4L2_CID_CHROMA_AGC:
 		/* Do not allow chroma AGC to be enabled for SECAM */
 		value = ((ctl->value - c->off) << c->shift) & c->mask;
 		if (core->tvnorm & V4L2_STD_SECAM && value)
 			return -EINVAL;
 		break;
 	default:
 		value = ((ctl->value - c->off) << c->shift) & c->mask;
 		break;
 	}
 	dprintk(1,"set_control id=0x%X(%s) ctrl=0x%02x, reg=0x%02x val=0x%02x (mask 0x%02x)%s\n",
 				ctl->id, c->v.name, ctl->value, c->reg, value,
 				mask, c->sreg ? " [shadowed]" : "");
 	if (c->sreg) {
 		cx_sandor(c->sreg, c->reg, mask, value);
 	} else {
 		cx_andor(c->reg, mask, value);
 	}
 	return 0;
 }
 EXPORT_SYMBOL(cx88_set_control);
 static void init_controls(struct cx88_core *core)
 {
 	struct v4l2_control ctrl;
 	int i;
 	for (i = 0; i < CX8800_CTLS; i++) {
 		ctrl.id=cx8800_ctls[i].v.id;
 		ctrl.value=cx8800_ctls[i].v.default_value;
 		cx88_set_control(core, &ctrl);
 	}
 }
 /* ------------------------------------------------------------------ */
 /* VIDEO IOCTLS                                                       */
 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 					struct v4l2_format *f)
 {
 	struct cx8800_fh  *fh   = priv;
 	f->fmt.pix.width        = fh->width;
 	f->fmt.pix.height       = fh->height;
 	f->fmt.pix.field        = fh->vidq.field;
 	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
 	f->fmt.pix.bytesperline =
 		(f->fmt.pix.width * fh->fmt->depth) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	return 0;
 }
 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 			struct v4l2_format *f)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	struct cx8800_fmt *fmt;
 	enum v4l2_field   field;
 	unsigned int      maxw, maxh;
 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 	if (NULL == fmt)
 		return -EINVAL;
 	field = f->fmt.pix.field;
 	maxw  = norm_maxw(core->tvnorm);
 	maxh  = norm_maxh(core->tvnorm);
 	if (V4L2_FIELD_ANY == field) {
 		field = (f->fmt.pix.height > maxh/2)
 			? V4L2_FIELD_INTERLACED
 			: V4L2_FIELD_BOTTOM;
 	}
 	switch (field) {
 	case V4L2_FIELD_TOP:
 	case V4L2_FIELD_BOTTOM:
 		maxh = maxh / 2;
 		break;
 	case V4L2_FIELD_INTERLACED:
 		break;
 	default:
 		return -EINVAL;
 	}
 	f->fmt.pix.field = field;
 	if (f->fmt.pix.height < 32)
 		f->fmt.pix.height = 32;
 	if (f->fmt.pix.height > maxh)
 		f->fmt.pix.height = maxh;
 	if (f->fmt.pix.width < 48)
 		f->fmt.pix.width = 48;
 	if (f->fmt.pix.width > maxw)
 		f->fmt.pix.width = maxw;
 	f->fmt.pix.width &= ~0x03;
 	f->fmt.pix.bytesperline =
 		(f->fmt.pix.width * fmt->depth) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	return 0;
 }
 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 					struct v4l2_format *f)
 {
 	struct cx8800_fh  *fh   = priv;
 	int err = vidioc_try_fmt_vid_cap (file,priv,f);
 	if (0 != err)
 		return err;
 	fh->fmt        = format_by_fourcc(f->fmt.pix.pixelformat);
 	fh->width      = f->fmt.pix.width;
 	fh->height     = f->fmt.pix.height;
 	fh->vidq.field = f->fmt.pix.field;
 	return 0;
 }
 static int vidioc_querycap (struct file *file, void  *priv,
 					struct v4l2_capability *cap)
 {
 	struct cx8800_dev *dev  = ((struct cx8800_fh *)priv)->dev;
 	struct cx88_core  *core = dev->core;
 	strcpy(cap->driver, "cx8800");
 	strlcpy(cap->card, core->board.name, sizeof(cap->card));
 	sprintf(cap->bus_info,"PCI:%s",pci_name(dev->pci));
 	cap->version = CX88_VERSION_CODE;
 	cap->capabilities =
 		V4L2_CAP_VIDEO_CAPTURE |
 		V4L2_CAP_READWRITE     |
 		V4L2_CAP_STREAMING     |
 		V4L2_CAP_VBI_CAPTURE;
 	if (UNSET != core->board.tuner_type)
 		cap->capabilities |= V4L2_CAP_TUNER;
 	return 0;
 }
 static int vidioc_enum_fmt_vid_cap (struct file *file, void  *priv,
 					struct v4l2_fmtdesc *f)
 {
 	if (unlikely(f->index >= ARRAY_SIZE(formats)))
 		return -EINVAL;
 	strlcpy(f->description,formats[f->index].name,sizeof(f->description));
 	f->pixelformat = formats[f->index].fourcc;
 	return 0;
 }
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 static int vidiocgmbuf (struct file *file, void *priv, struct video_mbuf *mbuf)
 {
 	struct cx8800_fh           *fh  = priv;
 	return videobuf_cgmbuf (get_queue(fh), mbuf, 8);
 }
 #endif
 static int vidioc_reqbufs (struct file *file, void *priv, struct v4l2_requestbuffers *p)
 {
 	struct cx8800_fh  *fh   = priv;
 	return (videobuf_reqbufs(get_queue(fh), p));
 }
 static int vidioc_querybuf (struct file *file, void *priv, struct v4l2_buffer *p)
 {
 	struct cx8800_fh  *fh   = priv;
 	return (videobuf_querybuf(get_queue(fh), p));
 }
 static int vidioc_qbuf (struct file *file, void *priv, struct v4l2_buffer *p)
 {
 	struct cx8800_fh  *fh   = priv;
 	return (videobuf_qbuf(get_queue(fh), p));
 }
 static int vidioc_dqbuf (struct file *file, void *priv, struct v4l2_buffer *p)
 {
 	struct cx8800_fh  *fh   = priv;
 	return (videobuf_dqbuf(get_queue(fh), p,
 				file->f_flags & O_NONBLOCK));
 }
 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
 {
 	struct cx8800_fh  *fh   = priv;
 	struct cx8800_dev *dev  = fh->dev;
 	/* We should remember that this driver also supports teletext,  */
 	/* so we have to test if the v4l2_buf_type is VBI capture data. */
 	if (unlikely((fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) &&
 		     (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)))
 		return -EINVAL;
 	if (unlikely(i != fh->type))
 		return -EINVAL;
 	if (unlikely(!res_get(dev,fh,get_ressource(fh))))
 		return -EBUSY;
 	return videobuf_streamon(get_queue(fh));
 }
 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
 {
 	struct cx8800_fh  *fh   = priv;
 	struct cx8800_dev *dev  = fh->dev;
 	int               err, res;
 	if ((fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) &&
 	    (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE))
 		return -EINVAL;
 	if (i != fh->type)
 		return -EINVAL;
 	res = get_ressource(fh);
 	err = videobuf_streamoff(get_queue(fh));
 	if (err < 0)
 		return err;
 	res_free(dev,fh,res);
 	return 0;
 }
 static int vidioc_s_std (struct file *file, void *priv, v4l2_std_id *tvnorms)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	mutex_lock(&core->lock);
 	cx88_set_tvnorm(core,*tvnorms);
 	mutex_unlock(&core->lock);
 	return 0;
 }
 /* only one input in this sample driver */
 int cx88_enum_input (struct cx88_core  *core,struct v4l2_input *i)
 {
 	static const char *iname[] = {
 		[ CX88_VMUX_COMPOSITE1 ] = "Composite1",
 		[ CX88_VMUX_COMPOSITE2 ] = "Composite2",
 		[ CX88_VMUX_COMPOSITE3 ] = "Composite3",
 		[ CX88_VMUX_COMPOSITE4 ] = "Composite4",
 		[ CX88_VMUX_SVIDEO     ] = "S-Video",
 		[ CX88_VMUX_TELEVISION ] = "Television",
 		[ CX88_VMUX_CABLE      ] = "Cable TV",
 		[ CX88_VMUX_DVB        ] = "DVB",
 		[ CX88_VMUX_DEBUG      ] = "for debug only",
 	};
 	unsigned int n = i->index;
 	if (n >= 4)
 		return -EINVAL;
 	if (0 == INPUT(n).type)
 		return -EINVAL;
 	i->type  = V4L2_INPUT_TYPE_CAMERA;
 	strcpy(i->name,iname[INPUT(n).type]);
 	if ((CX88_VMUX_TELEVISION == INPUT(n).type) ||
 	    (CX88_VMUX_CABLE      == INPUT(n).type))
 		i->type = V4L2_INPUT_TYPE_TUNER;
 		i->std = CX88_NORMS;
 	return 0;
 }
 EXPORT_SYMBOL(cx88_enum_input);
 static int vidioc_enum_input (struct file *file, void *priv,
 				struct v4l2_input *i)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	return cx88_enum_input (core,i);
 }
 static int vidioc_g_input (struct file *file, void *priv, unsigned int *i)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	*i = core->input;
 	return 0;
 }
 static int vidioc_s_input (struct file *file, void *priv, unsigned int i)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	if (i >= 4)
 		return -EINVAL;
 	mutex_lock(&core->lock);
 	cx88_newstation(core);
 	cx88_video_mux(core,i);
 	mutex_unlock(&core->lock);
 	return 0;
 }
 static int vidioc_queryctrl (struct file *file, void *priv,
 				struct v4l2_queryctrl *qctrl)
 {
 	struct cx88_core *core = ((struct cx8800_fh *)priv)->dev->core;
 	qctrl->id = v4l2_ctrl_next(ctrl_classes, qctrl->id);
 	if (unlikely(qctrl->id == 0))
 		return -EINVAL;
 	return cx8800_ctrl_query(core, qctrl);
 }
 static int vidioc_g_ctrl (struct file *file, void *priv,
 				struct v4l2_control *ctl)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	return
 		cx88_get_control(core,ctl);
 }
 static int vidioc_s_ctrl (struct file *file, void *priv,
 				struct v4l2_control *ctl)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	return
 		cx88_set_control(core,ctl);
 }
 static int vidioc_g_tuner (struct file *file, void *priv,
 				struct v4l2_tuner *t)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	u32 reg;
 	if (unlikely(UNSET == core->board.tuner_type))
 		return -EINVAL;
 	if (0 != t->index)
 		return -EINVAL;
 	strcpy(t->name, "Television");
 	t->type       = V4L2_TUNER_ANALOG_TV;
 	t->capability = V4L2_TUNER_CAP_NORM;
 	t->rangehigh  = 0xffffffffUL;
 	cx88_get_stereo(core ,t);
 	reg = cx_read(MO_DEVICE_STATUS);
 	t->signal = (reg & (1<<5)) ? 0xffff : 0x0000;
 	return 0;
 }
 static int vidioc_s_tuner (struct file *file, void *priv,
 				struct v4l2_tuner *t)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	if (UNSET == core->board.tuner_type)
 		return -EINVAL;
 	if (0 != t->index)
 		return -EINVAL;
 	cx88_set_stereo(core, t->audmode, 1);
 	return 0;
 }
 static int vidioc_g_frequency (struct file *file, void *priv,
 				struct v4l2_frequency *f)
 {
 	struct cx8800_fh  *fh   = priv;
 	struct cx88_core  *core = fh->dev->core;
 	if (unlikely(UNSET == core->board.tuner_type))
 		return -EINVAL;
 	/* f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; */
 	f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
 	f->frequency = core->freq;
 	cx88_call_i2c_clients(core,VIDIOC_G_FREQUENCY,f);
 	return 0;
 }
 int cx88_set_freq (struct cx88_core  *core,
 				struct v4l2_frequency *f)
 {
 	if (unlikely(UNSET == core->board.tuner_type))
 		return -EINVAL;
 	if (unlikely(f->tuner != 0))
 		return -EINVAL;
 	mutex_lock(&core->lock);
 	core->freq = f->frequency;
 	cx88_newstation(core);
 	cx88_call_i2c_clients(core,VIDIOC_S_FREQUENCY,f);
 	/* When changing channels it is required to reset TVAUDIO */
 	msleep (10);
 	cx88_set_tvaudio(core);
 	mutex_unlock(&core->lock);
 	return 0;
 }
 EXPORT_SYMBOL(cx88_set_freq);
 static int vidioc_s_frequency (struct file *file, void *priv,
 				struct v4l2_frequency *f)
 {
 	struct cx8800_fh  *fh   = priv;
 	struct cx88_core  *core = fh->dev->core;
 	if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV))
 		return -EINVAL;
 	if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO))
 		return -EINVAL;
 	return
 		cx88_set_freq (core,f);
 }
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_register (struct file *file, void *fh,
 				struct v4l2_dbg_register *reg)
 {
 	struct cx88_core *core = ((struct cx8800_fh*)fh)->dev->core;
 	if (!v4l2_chip_match_host(&reg->match))
 		return -EINVAL;
 	/* cx2388x has a 24-bit register space */
 	reg->val = cx_read(reg->reg & 0xffffff);
 	reg->size = 4;
 	return 0;
 }
 static int vidioc_s_register (struct file *file, void *fh,
 				struct v4l2_dbg_register *reg)
 {
 	struct cx88_core *core = ((struct cx8800_fh*)fh)->dev->core;
 	if (!v4l2_chip_match_host(&reg->match))
 		return -EINVAL;
 	cx_write(reg->reg & 0xffffff, reg->val);
 	return 0;
 }
 #endif
 /* ----------------------------------------------------------- */
 /* RADIO ESPECIFIC IOCTLS                                      */
 /* ----------------------------------------------------------- */
 static int radio_querycap (struct file *file, void  *priv,
 					struct v4l2_capability *cap)
 {
 	struct cx8800_dev *dev  = ((struct cx8800_fh *)priv)->dev;
 	struct cx88_core  *core = dev->core;
 	strcpy(cap->driver, "cx8800");
 	strlcpy(cap->card, core->board.name, sizeof(cap->card));
 	sprintf(cap->bus_info,"PCI:%s", pci_name(dev->pci));
 	cap->version = CX88_VERSION_CODE;
 	cap->capabilities = V4L2_CAP_TUNER;
 	return 0;
 }
 static int radio_g_tuner (struct file *file, void *priv,
 				struct v4l2_tuner *t)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	if (unlikely(t->index > 0))
 		return -EINVAL;
 	strcpy(t->name, "Radio");
 	t->type = V4L2_TUNER_RADIO;
 	cx88_call_i2c_clients(core,VIDIOC_G_TUNER,t);
 	return 0;
 }
 static int radio_enum_input (struct file *file, void *priv,
 				struct v4l2_input *i)
 {
 	if (i->index != 0)
 		return -EINVAL;
 	strcpy(i->name,"Radio");
 	i->type = V4L2_INPUT_TYPE_TUNER;
 	return 0;
 }
 static int radio_g_audio (struct file *file, void *priv, struct v4l2_audio *a)
 {
 	if (unlikely(a->index))
 		return -EINVAL;
 	strcpy(a->name,"Radio");
 	return 0;
 }
 /* FIXME: Should add a standard for radio */
 static int radio_s_tuner (struct file *file, void *priv,
 				struct v4l2_tuner *t)
 {
 	struct cx88_core  *core = ((struct cx8800_fh *)priv)->dev->core;
 	if (0 != t->index)
 		return -EINVAL;
 	cx88_call_i2c_clients(core,VIDIOC_S_TUNER,t);
 	return 0;
 }
 static int radio_s_audio (struct file *file, void *fh,
 			  struct v4l2_audio *a)
 {
 	return 0;
 }
 static int radio_s_input (struct file *file, void *fh, unsigned int i)
 {
 	return 0;
 }
 static int radio_queryctrl (struct file *file, void *priv,
 			    struct v4l2_queryctrl *c)
 {
 	int i;
 	if (c->id <  V4L2_CID_BASE ||
 		c->id >= V4L2_CID_LASTP1)
 		return -EINVAL;
 	if (c->id == V4L2_CID_AUDIO_MUTE) {
 		for (i = 0; i < CX8800_CTLS; i++)
 			if (cx8800_ctls[i].v.id == c->id)
 				break;
 		*c = cx8800_ctls[i].v;
 	} else
 		*c = no_ctl;
 	return 0;
 }
 /* ----------------------------------------------------------- */
 static void cx8800_vid_timeout(unsigned long data)
 {
 	struct cx8800_dev *dev = (struct cx8800_dev*)data;
 	struct cx88_core *core = dev->core;
 	struct cx88_dmaqueue *q = &dev->vidq;
 	struct cx88_buffer *buf;
 	unsigned long flags;
 	cx88_sram_channel_dump(core, &cx88_sram_channels[SRAM_CH21]);
 	cx_clear(MO_VID_DMACNTRL, 0x11);
 	cx_clear(VID_CAPTURE_CONTROL, 0x06);
 	spin_lock_irqsave(&dev->slock,flags);
 	while (!list_empty(&q->active)) {
 		buf = list_entry(q->active.next, struct cx88_buffer, vb.queue);
 		list_del(&buf->vb.queue);
 		buf->vb.state = VIDEOBUF_ERROR;
 		wake_up(&buf->vb.done);
 		printk("%s/0: [%p/%d] timeout - dma=0x%08lx\n", core->name,
 		       buf, buf->vb.i, (unsigned long)buf->risc.dma);
 	}
 	restart_video_queue(dev,q);
 	spin_unlock_irqrestore(&dev->slock,flags);
 }
 static char *cx88_vid_irqs[32] = {
 	"y_risci1", "u_risci1", "v_risci1", "vbi_risc1",
 	"y_risci2", "u_risci2", "v_risci2", "vbi_risc2",
 	"y_oflow",  "u_oflow",  "v_oflow",  "vbi_oflow",
 	"y_sync",   "u_sync",   "v_sync",   "vbi_sync",
 	"opc_err",  "par_err",  "rip_err",  "pci_abort",
 };
 static void cx8800_vid_irq(struct cx8800_dev *dev)
 {
 	struct cx88_core *core = dev->core;
 	u32 status, mask, count;
 	status = cx_read(MO_VID_INTSTAT);
 	mask   = cx_read(MO_VID_INTMSK);
 	if (0 == (status & mask))
 		return;
 	cx_write(MO_VID_INTSTAT, status);
 	if (irq_debug  ||  (status & mask & ~0xff))
 		cx88_print_irqbits(core->name, "irq vid",
 				   cx88_vid_irqs, ARRAY_SIZE(cx88_vid_irqs),
 				   status, mask);
 	/* risc op code error */
 	if (status & (1 << 16)) {
 		printk(KERN_WARNING "%s/0: video risc op code error\n",core->name);
 		cx_clear(MO_VID_DMACNTRL, 0x11);
 		cx_clear(VID_CAPTURE_CONTROL, 0x06);
 		cx88_sram_channel_dump(core, &cx88_sram_channels[SRAM_CH21]);
 	}
 	/* risc1 y */
 	if (status & 0x01) {
 		spin_lock(&dev->slock);
 		count = cx_read(MO_VIDY_GPCNT);
 		cx88_wakeup(core, &dev->vidq, count);
 		spin_unlock(&dev->slock);
 	}
 	/* risc1 vbi */
 	if (status & 0x08) {
 		spin_lock(&dev->slock);
 		count = cx_read(MO_VBI_GPCNT);
 		cx88_wakeup(core, &dev->vbiq, count);
 		spin_unlock(&dev->slock);
 	}
 	/* risc2 y */
 	if (status & 0x10) {
 		dprintk(2,"stopper video\n");
 		spin_lock(&dev->slock);
 		restart_video_queue(dev,&dev->vidq);
 		spin_unlock(&dev->slock);
 	}
 	/* risc2 vbi */
 	if (status & 0x80) {
 		dprintk(2,"stopper vbi\n");
 		spin_lock(&dev->slock);
 		cx8800_restart_vbi_queue(dev,&dev->vbiq);
 		spin_unlock(&dev->slock);
 	}
 }
 static irqreturn_t cx8800_irq(int irq, void *dev_id)
 {
 	struct cx8800_dev *dev = dev_id;
 	struct cx88_core *core = dev->core;
 	u32 status;
 	int loop, handled = 0;
 	for (loop = 0; loop < 10; loop++) {
 		status = cx_read(MO_PCI_INTSTAT) &
 			(core->pci_irqmask | PCI_INT_VIDINT);
 		if (0 == status)
 			goto out;
 		cx_write(MO_PCI_INTSTAT, status);
 		handled = 1;
 		if (status & core->pci_irqmask)
 			cx88_core_irq(core,status);
 		if (status & PCI_INT_VIDINT)
 			cx8800_vid_irq(dev);
 	};
 	if (10 == loop) {
 		printk(KERN_WARNING "%s/0: irq loop -- clearing mask\n",
 		       core->name);
 		cx_write(MO_PCI_INTMSK,0);
 	}
  out:
 	return IRQ_RETVAL(handled);
 }
 /* ----------------------------------------------------------- */
 /* exported stuff                                              */
 static const struct v4l2_file_operations video_fops =
 {
 	.owner	       = THIS_MODULE,
 	.open	       = video_open,
 	.release       = video_release,
 	.read	       = video_read,
 	.poll          = video_poll,
 	.mmap	       = video_mmap,
 	.ioctl	       = video_ioctl2,
 };
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
 	.vidioc_querycap      = vidioc_querycap,
 	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
 	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
 	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
 	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
 	.vidioc_g_fmt_vbi_cap     = cx8800_vbi_fmt,
 	.vidioc_try_fmt_vbi_cap   = cx8800_vbi_fmt,
 	.vidioc_s_fmt_vbi_cap     = cx8800_vbi_fmt,
 	.vidioc_reqbufs       = vidioc_reqbufs,
 	.vidioc_querybuf      = vidioc_querybuf,
 	.vidioc_qbuf          = vidioc_qbuf,
 	.vidioc_dqbuf         = vidioc_dqbuf,
 	.vidioc_s_std         = vidioc_s_std,
 	.vidioc_enum_input    = vidioc_enum_input,
 	.vidioc_g_input       = vidioc_g_input,
 	.vidioc_s_input       = vidioc_s_input,
 	.vidioc_queryctrl     = vidioc_queryctrl,
 	.vidioc_g_ctrl        = vidioc_g_ctrl,
 	.vidioc_s_ctrl        = vidioc_s_ctrl,
 	.vidioc_streamon      = vidioc_streamon,
 	.vidioc_streamoff     = vidioc_streamoff,
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 	.vidiocgmbuf          = vidiocgmbuf,
 #endif
 	.vidioc_g_tuner       = vidioc_g_tuner,
 	.vidioc_s_tuner       = vidioc_s_tuner,
 	.vidioc_g_frequency   = vidioc_g_frequency,
 	.vidioc_s_frequency   = vidioc_s_frequency,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	.vidioc_g_register    = vidioc_g_register,
 	.vidioc_s_register    = vidioc_s_register,
 #endif
 };
 static struct video_device cx8800_vbi_template;
 static struct video_device cx8800_video_template = {
 	.name                 = "cx8800-video",
 	.fops                 = &video_fops,
 	.minor                = -1,
 	.ioctl_ops 	      = &video_ioctl_ops,
 	.tvnorms              = CX88_NORMS,
 	.current_norm         = V4L2_STD_NTSC_M,
 };
 static const struct v4l2_file_operations radio_fops =
 {
 	.owner         = THIS_MODULE,
 	.open          = video_open,
 	.release       = video_release,
 	.ioctl         = video_ioctl2,
 };
 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
 	.vidioc_querycap      = radio_querycap,
 	.vidioc_g_tuner       = radio_g_tuner,
 	.vidioc_enum_input    = radio_enum_input,
 	.vidioc_g_audio       = radio_g_audio,
 	.vidioc_s_tuner       = radio_s_tuner,
 	.vidioc_s_audio       = radio_s_audio,
 	.vidioc_s_input       = radio_s_input,
 	.vidioc_queryctrl     = radio_queryctrl,
 	.vidioc_g_ctrl        = vidioc_g_ctrl,
 	.vidioc_s_ctrl        = vidioc_s_ctrl,
 	.vidioc_g_frequency   = vidioc_g_frequency,
 	.vidioc_s_frequency   = vidioc_s_frequency,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	.vidioc_g_register    = vidioc_g_register,
 	.vidioc_s_register    = vidioc_s_register,
 #endif
 };
 static struct video_device cx8800_radio_template = {
 	.name                 = "cx8800-radio",
 	.fops                 = &radio_fops,
 	.minor                = -1,
 	.ioctl_ops 	      = &radio_ioctl_ops,
 };
 /* ----------------------------------------------------------- */
 static void cx8800_unregister_video(struct cx8800_dev *dev)
 {
 	if (dev->radio_dev) {
 		if (-1 != dev->radio_dev->minor)
 			video_unregister_device(dev->radio_dev);
 		else
 			video_device_release(dev->radio_dev);
 		dev->radio_dev = NULL;
 	}
 	if (dev->vbi_dev) {
 		if (-1 != dev->vbi_dev->minor)
 			video_unregister_device(dev->vbi_dev);
 		else
 			video_device_release(dev->vbi_dev);
 		dev->vbi_dev = NULL;
 	}
 	if (dev->video_dev) {
 		if (-1 != dev->video_dev->minor)
 			video_unregister_device(dev->video_dev);
 		else
 			video_device_release(dev->video_dev);
 		dev->video_dev = NULL;
 	}
 }
 static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
 				    const struct pci_device_id *pci_id)
 {
 	struct cx8800_dev *dev;
 	struct cx88_core *core;
 	int err;
 	dev = kzalloc(sizeof(*dev),GFP_KERNEL);
 	if (NULL == dev)
 		return -ENOMEM;
 	/* pci init */
 	dev->pci = pci_dev;
 	if (pci_enable_device(pci_dev)) {
 		err = -EIO;
 		goto fail_free;
 	}
 	core = cx88_core_get(dev->pci);
 	if (NULL == core) {
 		err = -EINVAL;
 		goto fail_free;
 	}
 	dev->core = core;
 	/* print pci info */
 	pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &dev->pci_rev);
 	pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER,  &dev->pci_lat);
 	printk(KERN_INFO "%s/0: found at %s, rev: %d, irq: %d, "
 	       "latency: %d, mmio: 0x%llx\n", core->name,
 	       pci_name(pci_dev), dev->pci_rev, pci_dev->irq,
 	       dev->pci_lat,(unsigned long long)pci_resource_start(pci_dev,0));
 	pci_set_master(pci_dev);
 	if (!pci_dma_supported(pci_dev,DMA_32BIT_MASK)) {
 		printk("%s/0: Oops: no 32bit PCI DMA ???\n",core->name);
 		err = -EIO;
 		goto fail_core;
 	}
 	/* Initialize VBI template */
 	memcpy( &cx8800_vbi_template, &cx8800_video_template,
 		sizeof(cx8800_vbi_template) );
 	strcpy(cx8800_vbi_template.name,"cx8800-vbi");
 	/* initialize driver struct */
 	spin_lock_init(&dev->slock);
 	core->tvnorm = cx8800_video_template.current_norm;
 	/* init video dma queues */
 	INIT_LIST_HEAD(&dev->vidq.active);
 	INIT_LIST_HEAD(&dev->vidq.queued);
 	dev->vidq.timeout.function = cx8800_vid_timeout;
 	dev->vidq.timeout.data     = (unsigned long)dev;
 	init_timer(&dev->vidq.timeout);
 	cx88_risc_stopper(dev->pci,&dev->vidq.stopper,
 			  MO_VID_DMACNTRL,0x11,0x00);
 	/* init vbi dma queues */
 	INIT_LIST_HEAD(&dev->vbiq.active);
 	INIT_LIST_HEAD(&dev->vbiq.queued);
 	dev->vbiq.timeout.function = cx8800_vbi_timeout;
 	dev->vbiq.timeout.data     = (unsigned long)dev;
 	init_timer(&dev->vbiq.timeout);
 	cx88_risc_stopper(dev->pci,&dev->vbiq.stopper,
 			  MO_VID_DMACNTRL,0x88,0x00);
 	/* get irq */
 	err = request_irq(pci_dev->irq, cx8800_irq,
 			  IRQF_SHARED | IRQF_DISABLED, core->name, dev);
 	if (err < 0) {
 		printk(KERN_ERR "%s/0: can't get IRQ %d\n",
 		       core->name,pci_dev->irq);
 		goto fail_core;
 	}
 	cx_set(MO_PCI_INTMSK, core->pci_irqmask);
 	/* load and configure helper modules */
 	if (core->board.audio_chip == V4L2_IDENT_WM8775)
 		request_module("wm8775");
 	switch (core->boardnr) {
 	case CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD:
 	case CX88_BOARD_DVICO_FUSIONHDTV_7_GOLD:
 		request_module("rtc-isl1208");
 		/* break intentionally omitted */
 	case CX88_BOARD_DVICO_FUSIONHDTV_5_PCI_NANO:
 		request_module("ir-kbd-i2c");
 	}
 	/* register v4l devices */
 	dev->video_dev = cx88_vdev_init(core,dev->pci,
 					&cx8800_video_template,"video");
 	err = video_register_device(dev->video_dev,VFL_TYPE_GRABBER,
 				    video_nr[core->nr]);
 	if (err < 0) {
 		printk(KERN_ERR "%s/0: can't register video device\n",
 		       core->name);
 		goto fail_unreg;
 	}
 	printk(KERN_INFO "%s/0: registered device video%d [v4l2]\n",
 	       core->name, dev->video_dev->num);
 	dev->vbi_dev = cx88_vdev_init(core,dev->pci,&cx8800_vbi_template,"vbi");
 	err = video_register_device(dev->vbi_dev,VFL_TYPE_VBI,
 				    vbi_nr[core->nr]);
 	if (err < 0) {
 		printk(KERN_ERR "%s/0: can't register vbi device\n",
 		       core->name);
 		goto fail_unreg;
 	}
 	printk(KERN_INFO "%s/0: registered device vbi%d\n",
 	       core->name, dev->vbi_dev->num);
 	if (core->board.radio.type == CX88_RADIO) {
 		dev->radio_dev = cx88_vdev_init(core,dev->pci,
 						&cx8800_radio_template,"radio");
 		err = video_register_device(dev->radio_dev,VFL_TYPE_RADIO,
 					    radio_nr[core->nr]);
 		if (err < 0) {
 			printk(KERN_ERR "%s/0: can't register radio device\n",
 			       core->name);
 			goto fail_unreg;
 		}
 		printk(KERN_INFO "%s/0: registered device radio%d\n",
 		       core->name, dev->radio_dev->num);
 	}
 	/* everything worked */
 	list_add_tail(&dev->devlist,&cx8800_devlist);
 	pci_set_drvdata(pci_dev,dev);
 	/* initial device configuration */
 	mutex_lock(&core->lock);
 	cx88_set_tvnorm(core,core->tvnorm);
 	init_controls(core);
 	cx88_video_mux(core,0);
 	mutex_unlock(&core->lock);
 	/* start tvaudio thread */
 	if (core->board.tuner_type != TUNER_ABSENT) {
 		core->kthread = kthread_run(cx88_audio_thread, core, "cx88 tvaudio");
 		if (IS_ERR(core->kthread)) {
 			err = PTR_ERR(core->kthread);
 			printk(KERN_ERR "%s/0: failed to create cx88 audio thread, err=%d\n",
 			       core->name, err);
 		}
 	}
 	return 0;
 fail_unreg:
 	cx8800_unregister_video(dev);
 	free_irq(pci_dev->irq, dev);
 fail_core:
 	cx88_core_put(core,dev->pci);
 fail_free:
 	kfree(dev);
 	return err;
 }
 static void __devexit cx8800_finidev(struct pci_dev *pci_dev)
 {
 	struct cx8800_dev *dev = pci_get_drvdata(pci_dev);
 	struct cx88_core *core = dev->core;
 	/* stop thread */
 	if (core->kthread) {
 		kthread_stop(core->kthread);
 		core->kthread = NULL;
 	}
 	if (core->ir)
 		cx88_ir_stop(core, core->ir);
 	cx88_shutdown(core); /* FIXME */
 	pci_disable_device(pci_dev);
 	/* unregister stuff */
 	free_irq(pci_dev->irq, dev);
 	cx8800_unregister_video(dev);
 	pci_set_drvdata(pci_dev, NULL);
 	/* free memory */
 	btcx_riscmem_free(dev->pci,&dev->vidq.stopper);
 	list_del(&dev->devlist);
 	cx88_core_put(core,dev->pci);
 	kfree(dev);
 }
 #ifdef CONFIG_PM
 static int cx8800_suspend(struct pci_dev *pci_dev, pm_message_t state)
 {
 	struct cx8800_dev *dev = pci_get_drvdata(pci_dev);
 	struct cx88_core *core = dev->core;
 	/* stop video+vbi capture */
 	spin_lock(&dev->slock);
 	if (!list_empty(&dev->vidq.active)) {
 		printk("%s/0: suspend video\n", core->name);
 		stop_video_dma(dev);
 		del_timer(&dev->vidq.timeout);
 	}
 	if (!list_empty(&dev->vbiq.active)) {
 		printk("%s/0: suspend vbi\n", core->name);
 		cx8800_stop_vbi_dma(dev);
 		del_timer(&dev->vbiq.timeout);
 	}
 	spin_unlock(&dev->slock);
 	if (core->ir)
 		cx88_ir_stop(core, core->ir);
 	/* FIXME -- shutdown device */
 	cx88_shutdown(core);
 	pci_save_state(pci_dev);
 	if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
 		pci_disable_device(pci_dev);
 		dev->state.disabled = 1;
 	}
 	return 0;
 }
 static int cx8800_resume(struct pci_dev *pci_dev)
 {
 	struct cx8800_dev *dev = pci_get_drvdata(pci_dev);
 	struct cx88_core *core = dev->core;
 	int err;
 	if (dev->state.disabled) {
 		err=pci_enable_device(pci_dev);
 		if (err) {
 			printk(KERN_ERR "%s/0: can't enable device\n",
 			       core->name);
 			return err;
 		}
 		dev->state.disabled = 0;
 	}
 	err= pci_set_power_state(pci_dev, PCI_D0);
 	if (err) {
 		printk(KERN_ERR "%s/0: can't set power state\n", core->name);
 		pci_disable_device(pci_dev);
 		dev->state.disabled = 1;
 		return err;
 	}
 	pci_restore_state(pci_dev);
 	/* FIXME: re-initialize hardware */
 	cx88_reset(core);
 	if (core->ir)
 		cx88_ir_start(core, core->ir);
 	cx_set(MO_PCI_INTMSK, core->pci_irqmask);
 	/* restart video+vbi capture */
 	spin_lock(&dev->slock);
 	if (!list_empty(&dev->vidq.active)) {
 		printk("%s/0: resume video\n", core->name);
 		restart_video_queue(dev,&dev->vidq);
 	}
 	if (!list_empty(&dev->vbiq.active)) {
 		printk("%s/0: resume vbi\n", core->name);
 		cx8800_restart_vbi_queue(dev,&dev->vbiq);
 	}
 	spin_unlock(&dev->slock);
 	return 0;
 }
 #endif
 /* ----------------------------------------------------------- */
 static struct pci_device_id cx8800_pci_tbl[] = {
 	{
 		.vendor       = 0x14f1,
 		.device       = 0x8800,
 		.subvendor    = PCI_ANY_ID,
 		.subdevice    = PCI_ANY_ID,
 	},{
 		/* --- end of list --- */
 	}
 };
 MODULE_DEVICE_TABLE(pci, cx8800_pci_tbl);
 static struct pci_driver cx8800_pci_driver = {
 	.name     = "cx8800",
 	.id_table = cx8800_pci_tbl,
 	.probe    = cx8800_initdev,
 	.remove   = __devexit_p(cx8800_finidev),
 #ifdef CONFIG_PM
 	.suspend  = cx8800_suspend,
 	.resume   = cx8800_resume,
 #endif
 };
 static int cx8800_init(void)
 {
 	printk(KERN_INFO "cx88/0: cx2388x v4l2 driver version %d.%d.%d loaded\n",
 	       (CX88_VERSION_CODE >> 16) & 0xff,
 	       (CX88_VERSION_CODE >>  8) & 0xff,
 	       CX88_VERSION_CODE & 0xff);
 #ifdef SNAPSHOT
 	printk(KERN_INFO "cx2388x: snapshot date %04d-%02d-%02d\n",
 	       SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
 #endif
 	return pci_register_driver(&cx8800_pci_driver);
 }
 static void cx8800_fini(void)
 {
 	pci_unregister_driver(&cx8800_pci_driver);
 }
 module_init(cx8800_init);
 module_exit(cx8800_fini);
 /* ----------------------------------------------------------- */
 /*
  * Local variables:
  * c-basic-offset: 8
  * End:
  * kate: eol "unix"; indent-width 3; remove-trailing-space on; replace-trailing-space-save on; tab-width 8; replace-tabs off; space-indent off; mixed-indent off
  */

drivers/media/video/msp3400-driver.c

Diff comments View file @ 7e0a16f

1	/*	1	/*
2	* Programming the mspx4xx sound processor family	2	* Programming the mspx4xx sound processor family
3	*	3	*
4	* (c) 1997-2001 Gerd Knorr <kraxel@bytesex.org>	4	* (c) 1997-2001 Gerd Knorr <kraxel@bytesex.org>
5	*	5	*
6	* what works and what doesn't:	6	* what works and what doesn't:
7	*	7	*
8	* AM-Mono	8	* AM-Mono
9	* Support for Hauppauge cards added (decoding handled by tuner) added by	9	* Support for Hauppauge cards added (decoding handled by tuner) added by
10	* Frederic Crozat <fcrozat@mail.dotcom.fr>	10	* Frederic Crozat <fcrozat@mail.dotcom.fr>
11	*	11	*
12	* FM-Mono	12	* FM-Mono
13	* should work. The stereo modes are backward compatible to FM-mono,	13	* should work. The stereo modes are backward compatible to FM-mono,
14	* therefore FM-Mono should be allways available.	14	* therefore FM-Mono should be allways available.
15	*	15	*
16	* FM-Stereo (B/G, used in germany)	16	* FM-Stereo (B/G, used in germany)
17	* should work, with autodetect	17	* should work, with autodetect
18	*	18	*
19	* FM-Stereo (satellite)	19	* FM-Stereo (satellite)
20	* should work, no autodetect (i.e. default is mono, but you can	20	* should work, no autodetect (i.e. default is mono, but you can
21	* switch to stereo -- untested)	21	* switch to stereo -- untested)
22	*	22	*
23	* NICAM (B/G, L , used in UK, Scandinavia, Spain and France)	23	* NICAM (B/G, L , used in UK, Scandinavia, Spain and France)
24	* should work, with autodetect. Support for NICAM was added by	24	* should work, with autodetect. Support for NICAM was added by
25	* Pekka Pietikainen <pp@netppl.fi>	25	* Pekka Pietikainen <pp@netppl.fi>
26	*	26	*
27	* TODO:	27	* TODO:
28	* - better SAT support	28	* - better SAT support
29	*	29	*
30	* 980623 Thomas Sailer (sailer@ife.ee.ethz.ch)	30	* 980623 Thomas Sailer (sailer@ife.ee.ethz.ch)
31	* using soundcore instead of OSS	31	* using soundcore instead of OSS
32	*	32	*
33	* This program is free software; you can redistribute it and/or	33	* This program is free software; you can redistribute it and/or
34	* modify it under the terms of the GNU General Public License	34	* modify it under the terms of the GNU General Public License
35	* as published by the Free Software Foundation; either version 2	35	* as published by the Free Software Foundation; either version 2
36	* of the License, or (at your option) any later version.	36	* of the License, or (at your option) any later version.
37	*	37	*
38	* This program is distributed in the hope that it will be useful,	38	* This program is distributed in the hope that it will be useful,
39	* but WITHOUT ANY WARRANTY; without even the implied warranty of	39	* but WITHOUT ANY WARRANTY; without even the implied warranty of
40	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	40	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
41	* GNU General Public License for more details.	41	* GNU General Public License for more details.
42	*	42	*
43	* You should have received a copy of the GNU General Public License	43	* You should have received a copy of the GNU General Public License
44	* along with this program; if not, write to the Free Software	44	* along with this program; if not, write to the Free Software
45	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA	45	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
46	* 02110-1301, USA.	46	* 02110-1301, USA.
47	*/	47	*/
48		48
49		49
50	#include <linux/kernel.h>	50	#include <linux/kernel.h>
51	#include <linux/module.h>	51	#include <linux/module.h>
52	#include <linux/slab.h>	52	#include <linux/slab.h>
53	#include <linux/i2c.h>	53	#include <linux/i2c.h>
54	#include <linux/kthread.h>	54	#include <linux/kthread.h>
55	#include <linux/freezer.h>	55	#include <linux/freezer.h>
56	#include <linux/videodev2.h>	56	#include <linux/videodev.h>
57	#include <media/v4l2-device.h>	57	#include <media/v4l2-device.h>
58	#include <media/v4l2-ioctl.h>	58	#include <media/v4l2-ioctl.h>
59	#include <media/v4l2-i2c-drv-legacy.h>	59	#include <media/v4l2-i2c-drv-legacy.h>
60	#include <media/msp3400.h>	60	#include <media/msp3400.h>
61	#include <media/tvaudio.h>	61	#include <media/tvaudio.h>
62	#include "msp3400-driver.h"	62	#include "msp3400-driver.h"
63		63
64	/* ---------------------------------------------------------------------- */	64	/* ---------------------------------------------------------------------- */
65		65
66	MODULE_DESCRIPTION("device driver for msp34xx TV sound processor");	66	MODULE_DESCRIPTION("device driver for msp34xx TV sound processor");
67	MODULE_AUTHOR("Gerd Knorr");	67	MODULE_AUTHOR("Gerd Knorr");
68	MODULE_LICENSE("GPL");	68	MODULE_LICENSE("GPL");
69		69
70	/* module parameters */	70	/* module parameters */
71	static int opmode = OPMODE_AUTO;	71	static int opmode = OPMODE_AUTO;
72	int msp_debug; /* msp_debug output */	72	int msp_debug; /* msp_debug output */
73	int msp_once; /* no continous stereo monitoring */	73	int msp_once; /* no continous stereo monitoring */
74	int msp_amsound; /* hard-wire AM sound at 6.5 Hz (france),	74	int msp_amsound; /* hard-wire AM sound at 6.5 Hz (france),
75	the autoscan seems work well only with FM... */	75	the autoscan seems work well only with FM... */
76	int msp_standard = 1; /* Override auto detect of audio msp_standard,	76	int msp_standard = 1; /* Override auto detect of audio msp_standard,
77	if needed. */	77	if needed. */
78	int msp_dolby;	78	int msp_dolby;
79		79
80	int msp_stereo_thresh = 0x190; /* a2 threshold for stereo/bilingual	80	int msp_stereo_thresh = 0x190; /* a2 threshold for stereo/bilingual
81	(msp34xxg only) 0x00a0-0x03c0 */	81	(msp34xxg only) 0x00a0-0x03c0 */
82		82
83	/* read-only */	83	/* read-only */
84	module_param(opmode, int, 0444);	84	module_param(opmode, int, 0444);
85		85
86	/* read-write */	86	/* read-write */
87	module_param_named(once, msp_once, bool, 0644);	87	module_param_named(once, msp_once, bool, 0644);
88	module_param_named(debug, msp_debug, int, 0644);	88	module_param_named(debug, msp_debug, int, 0644);
89	module_param_named(stereo_threshold, msp_stereo_thresh, int, 0644);	89	module_param_named(stereo_threshold, msp_stereo_thresh, int, 0644);
90	module_param_named(standard, msp_standard, int, 0644);	90	module_param_named(standard, msp_standard, int, 0644);
91	module_param_named(amsound, msp_amsound, bool, 0644);	91	module_param_named(amsound, msp_amsound, bool, 0644);
92	module_param_named(dolby, msp_dolby, bool, 0644);	92	module_param_named(dolby, msp_dolby, bool, 0644);
93		93
94	MODULE_PARM_DESC(opmode, "Forces a MSP3400 opmode. 0=Manual, 1=Autodetect, 2=Autodetect and autoselect");	94	MODULE_PARM_DESC(opmode, "Forces a MSP3400 opmode. 0=Manual, 1=Autodetect, 2=Autodetect and autoselect");
95	MODULE_PARM_DESC(once, "No continuous stereo monitoring");	95	MODULE_PARM_DESC(once, "No continuous stereo monitoring");
96	MODULE_PARM_DESC(debug, "Enable debug messages [0-3]");	96	MODULE_PARM_DESC(debug, "Enable debug messages [0-3]");
97	MODULE_PARM_DESC(stereo_threshold, "Sets signal threshold to activate stereo");	97	MODULE_PARM_DESC(stereo_threshold, "Sets signal threshold to activate stereo");
98	MODULE_PARM_DESC(standard, "Specify audio standard: 32 = NTSC, 64 = radio, Default: Autodetect");	98	MODULE_PARM_DESC(standard, "Specify audio standard: 32 = NTSC, 64 = radio, Default: Autodetect");
99	MODULE_PARM_DESC(amsound, "Hardwire AM sound at 6.5Hz (France), FM can autoscan");	99	MODULE_PARM_DESC(amsound, "Hardwire AM sound at 6.5Hz (France), FM can autoscan");
100	MODULE_PARM_DESC(dolby, "Activates Dolby processsing");	100	MODULE_PARM_DESC(dolby, "Activates Dolby processsing");
101		101
102	/* ---------------------------------------------------------------------- */	102	/* ---------------------------------------------------------------------- */
103		103
104	/* control subaddress */	104	/* control subaddress */
105	#define I2C_MSP_CONTROL 0x00	105	#define I2C_MSP_CONTROL 0x00
106	/* demodulator unit subaddress */	106	/* demodulator unit subaddress */
107	#define I2C_MSP_DEM 0x10	107	#define I2C_MSP_DEM 0x10
108	/* DSP unit subaddress */	108	/* DSP unit subaddress */
109	#define I2C_MSP_DSP 0x12	109	#define I2C_MSP_DSP 0x12
110		110
111	/* Addresses to scan */	111	/* Addresses to scan */
112	static unsigned short normal_i2c[] = { 0x80 >> 1, 0x88 >> 1, I2C_CLIENT_END };	112	static unsigned short normal_i2c[] = { 0x80 >> 1, 0x88 >> 1, I2C_CLIENT_END };
113		113
114	I2C_CLIENT_INSMOD;	114	I2C_CLIENT_INSMOD;
115		115
116	/* ----------------------------------------------------------------------- */	116	/* ----------------------------------------------------------------------- */
117	/* functions for talking to the MSP3400C Sound processor */	117	/* functions for talking to the MSP3400C Sound processor */
118		118
119	int msp_reset(struct i2c_client *client)	119	int msp_reset(struct i2c_client *client)
120	{	120	{
121	/* reset and read revision code */	121	/* reset and read revision code */
122	static u8 reset_off[3] = { I2C_MSP_CONTROL, 0x80, 0x00 };	122	static u8 reset_off[3] = { I2C_MSP_CONTROL, 0x80, 0x00 };
123	static u8 reset_on[3] = { I2C_MSP_CONTROL, 0x00, 0x00 };	123	static u8 reset_on[3] = { I2C_MSP_CONTROL, 0x00, 0x00 };
124	static u8 write[3] = { I2C_MSP_DSP + 1, 0x00, 0x1e };	124	static u8 write[3] = { I2C_MSP_DSP + 1, 0x00, 0x1e };
125	u8 read[2];	125	u8 read[2];
126	struct i2c_msg reset[2] = {	126	struct i2c_msg reset[2] = {
127	{ client->addr, I2C_M_IGNORE_NAK, 3, reset_off },	127	{ client->addr, I2C_M_IGNORE_NAK, 3, reset_off },
128	{ client->addr, I2C_M_IGNORE_NAK, 3, reset_on },	128	{ client->addr, I2C_M_IGNORE_NAK, 3, reset_on },
129	};	129	};
130	struct i2c_msg test[2] = {	130	struct i2c_msg test[2] = {
131	{ client->addr, 0, 3, write },	131	{ client->addr, 0, 3, write },
132	{ client->addr, I2C_M_RD, 2, read },	132	{ client->addr, I2C_M_RD, 2, read },
133	};	133	};
134		134
135	v4l_dbg(3, msp_debug, client, "msp_reset\n");	135	v4l_dbg(3, msp_debug, client, "msp_reset\n");
136	if (i2c_transfer(client->adapter, &reset[0], 1) != 1 \|\|	136	if (i2c_transfer(client->adapter, &reset[0], 1) != 1 \|\|
137	i2c_transfer(client->adapter, &reset[1], 1) != 1 \|\|	137	i2c_transfer(client->adapter, &reset[1], 1) != 1 \|\|
138	i2c_transfer(client->adapter, test, 2) != 2) {	138	i2c_transfer(client->adapter, test, 2) != 2) {
139	v4l_err(client, "chip reset failed\n");	139	v4l_err(client, "chip reset failed\n");
140	return -1;	140	return -1;
141	}	141	}
142	return 0;	142	return 0;
143	}	143	}
144		144
145	static int msp_read(struct i2c_client *client, int dev, int addr)	145	static int msp_read(struct i2c_client *client, int dev, int addr)
146	{	146	{
147	int err, retval;	147	int err, retval;
148	u8 write[3];	148	u8 write[3];
149	u8 read[2];	149	u8 read[2];
150	struct i2c_msg msgs[2] = {	150	struct i2c_msg msgs[2] = {
151	{ client->addr, 0, 3, write },	151	{ client->addr, 0, 3, write },
152	{ client->addr, I2C_M_RD, 2, read }	152	{ client->addr, I2C_M_RD, 2, read }
153	};	153	};
154		154
155	write[0] = dev + 1;	155	write[0] = dev + 1;
156	write[1] = addr >> 8;	156	write[1] = addr >> 8;
157	write[2] = addr & 0xff;	157	write[2] = addr & 0xff;
158		158
159	for (err = 0; err < 3; err++) {	159	for (err = 0; err < 3; err++) {
160	if (i2c_transfer(client->adapter, msgs, 2) == 2)	160	if (i2c_transfer(client->adapter, msgs, 2) == 2)
161	break;	161	break;
162	v4l_warn(client, "I/O error #%d (read 0x%02x/0x%02x)\n", err,	162	v4l_warn(client, "I/O error #%d (read 0x%02x/0x%02x)\n", err,
163	dev, addr);	163	dev, addr);
164	schedule_timeout_interruptible(msecs_to_jiffies(10));	164	schedule_timeout_interruptible(msecs_to_jiffies(10));
165	}	165	}
166	if (err == 3) {	166	if (err == 3) {
167	v4l_warn(client, "resetting chip, sound will go off.\n");	167	v4l_warn(client, "resetting chip, sound will go off.\n");
168	msp_reset(client);	168	msp_reset(client);
169	return -1;	169	return -1;
170	}	170	}
171	retval = read[0] << 8 \| read[1];	171	retval = read[0] << 8 \| read[1];
172	v4l_dbg(3, msp_debug, client, "msp_read(0x%x, 0x%x): 0x%x\n",	172	v4l_dbg(3, msp_debug, client, "msp_read(0x%x, 0x%x): 0x%x\n",
173	dev, addr, retval);	173	dev, addr, retval);
174	return retval;	174	return retval;
175	}	175	}
176		176
177	int msp_read_dem(struct i2c_client *client, int addr)	177	int msp_read_dem(struct i2c_client *client, int addr)
178	{	178	{
179	return msp_read(client, I2C_MSP_DEM, addr);	179	return msp_read(client, I2C_MSP_DEM, addr);
180	}	180	}
181		181
182	int msp_read_dsp(struct i2c_client *client, int addr)	182	int msp_read_dsp(struct i2c_client *client, int addr)
183	{	183	{
184	return msp_read(client, I2C_MSP_DSP, addr);	184	return msp_read(client, I2C_MSP_DSP, addr);
185	}	185	}
186		186
187	static int msp_write(struct i2c_client *client, int dev, int addr, int val)	187	static int msp_write(struct i2c_client *client, int dev, int addr, int val)
188	{	188	{
189	int err;	189	int err;
190	u8 buffer[5];	190	u8 buffer[5];
191		191
192	buffer[0] = dev;	192	buffer[0] = dev;
193	buffer[1] = addr >> 8;	193	buffer[1] = addr >> 8;
194	buffer[2] = addr & 0xff;	194	buffer[2] = addr & 0xff;
195	buffer[3] = val >> 8;	195	buffer[3] = val >> 8;
196	buffer[4] = val & 0xff;	196	buffer[4] = val & 0xff;
197		197
198	v4l_dbg(3, msp_debug, client, "msp_write(0x%x, 0x%x, 0x%x)\n",	198	v4l_dbg(3, msp_debug, client, "msp_write(0x%x, 0x%x, 0x%x)\n",
199	dev, addr, val);	199	dev, addr, val);
200	for (err = 0; err < 3; err++) {	200	for (err = 0; err < 3; err++) {
201	if (i2c_master_send(client, buffer, 5) == 5)	201	if (i2c_master_send(client, buffer, 5) == 5)
202	break;	202	break;
203	v4l_warn(client, "I/O error #%d (write 0x%02x/0x%02x)\n", err,	203	v4l_warn(client, "I/O error #%d (write 0x%02x/0x%02x)\n", err,
204	dev, addr);	204	dev, addr);
205	schedule_timeout_interruptible(msecs_to_jiffies(10));	205	schedule_timeout_interruptible(msecs_to_jiffies(10));
206	}	206	}
207	if (err == 3) {	207	if (err == 3) {
208	v4l_warn(client, "resetting chip, sound will go off.\n");	208	v4l_warn(client, "resetting chip, sound will go off.\n");
209	msp_reset(client);	209	msp_reset(client);
210	return -1;	210	return -1;
211	}	211	}
212	return 0;	212	return 0;
213	}	213	}
214		214
215	int msp_write_dem(struct i2c_client *client, int addr, int val)	215	int msp_write_dem(struct i2c_client *client, int addr, int val)
216	{	216	{
217	return msp_write(client, I2C_MSP_DEM, addr, val);	217	return msp_write(client, I2C_MSP_DEM, addr, val);
218	}	218	}
219		219
220	int msp_write_dsp(struct i2c_client *client, int addr, int val)	220	int msp_write_dsp(struct i2c_client *client, int addr, int val)
221	{	221	{
222	return msp_write(client, I2C_MSP_DSP, addr, val);	222	return msp_write(client, I2C_MSP_DSP, addr, val);
223	}	223	}
224		224
225	/* ----------------------------------------------------------------------- *	225	/* ----------------------------------------------------------------------- *
226	* bits 9 8 5 - SCART DSP input Select:	226	* bits 9 8 5 - SCART DSP input Select:
227	* 0 0 0 - SCART 1 to DSP input (reset position)	227	* 0 0 0 - SCART 1 to DSP input (reset position)
228	* 0 1 0 - MONO to DSP input	228	* 0 1 0 - MONO to DSP input
229	* 1 0 0 - SCART 2 to DSP input	229	* 1 0 0 - SCART 2 to DSP input
230	* 1 1 1 - Mute DSP input	230	* 1 1 1 - Mute DSP input
231	*	231	*
232	* bits 11 10 6 - SCART 1 Output Select:	232	* bits 11 10 6 - SCART 1 Output Select:
233	* 0 0 0 - undefined (reset position)	233	* 0 0 0 - undefined (reset position)
234	* 0 1 0 - SCART 2 Input to SCART 1 Output (for devices with 2 SCARTS)	234	* 0 1 0 - SCART 2 Input to SCART 1 Output (for devices with 2 SCARTS)
235	* 1 0 0 - MONO input to SCART 1 Output	235	* 1 0 0 - MONO input to SCART 1 Output
236	* 1 1 0 - SCART 1 DA to SCART 1 Output	236	* 1 1 0 - SCART 1 DA to SCART 1 Output
237	* 0 0 1 - SCART 2 DA to SCART 1 Output	237	* 0 0 1 - SCART 2 DA to SCART 1 Output
238	* 0 1 1 - SCART 1 Input to SCART 1 Output	238	* 0 1 1 - SCART 1 Input to SCART 1 Output
239	* 1 1 1 - Mute SCART 1 Output	239	* 1 1 1 - Mute SCART 1 Output
240	*	240	*
241	* bits 13 12 7 - SCART 2 Output Select (for devices with 2 Output SCART):	241	* bits 13 12 7 - SCART 2 Output Select (for devices with 2 Output SCART):
242	* 0 0 0 - SCART 1 DA to SCART 2 Output (reset position)	242	* 0 0 0 - SCART 1 DA to SCART 2 Output (reset position)
243	* 0 1 0 - SCART 1 Input to SCART 2 Output	243	* 0 1 0 - SCART 1 Input to SCART 2 Output
244	* 1 0 0 - MONO input to SCART 2 Output	244	* 1 0 0 - MONO input to SCART 2 Output
245	* 0 0 1 - SCART 2 DA to SCART 2 Output	245	* 0 0 1 - SCART 2 DA to SCART 2 Output
246	* 0 1 1 - SCART 2 Input to SCART 2 Output	246	* 0 1 1 - SCART 2 Input to SCART 2 Output
247	* 1 1 0 - Mute SCART 2 Output	247	* 1 1 0 - Mute SCART 2 Output
248	*	248	*
249	* Bits 4 to 0 should be zero.	249	* Bits 4 to 0 should be zero.
250	* ----------------------------------------------------------------------- */	250	* ----------------------------------------------------------------------- */
251		251
252	static int scarts[3][9] = {	252	static int scarts[3][9] = {
253	/* MASK IN1 IN2 IN3 IN4 IN1_DA IN2_DA MONO MUTE */	253	/* MASK IN1 IN2 IN3 IN4 IN1_DA IN2_DA MONO MUTE */
254	/* SCART DSP Input select */	254	/* SCART DSP Input select */
255	{ 0x0320, 0x0000, 0x0200, 0x0300, 0x0020, -1, -1, 0x0100, 0x0320 },	255	{ 0x0320, 0x0000, 0x0200, 0x0300, 0x0020, -1, -1, 0x0100, 0x0320 },
256	/* SCART1 Output select */	256	/* SCART1 Output select */
257	{ 0x0c40, 0x0440, 0x0400, 0x0000, 0x0840, 0x0c00, 0x0040, 0x0800, 0x0c40 },	257	{ 0x0c40, 0x0440, 0x0400, 0x0000, 0x0840, 0x0c00, 0x0040, 0x0800, 0x0c40 },
258	/* SCART2 Output select */	258	/* SCART2 Output select */
259	{ 0x3080, 0x1000, 0x1080, 0x2080, 0x3080, 0x0000, 0x0080, 0x2000, 0x3000 },	259	{ 0x3080, 0x1000, 0x1080, 0x2080, 0x3080, 0x0000, 0x0080, 0x2000, 0x3000 },
260	};	260	};
261		261
262	static char *scart_names[] = {	262	static char *scart_names[] = {
263	"in1", "in2", "in3", "in4", "in1 da", "in2 da", "mono", "mute"	263	"in1", "in2", "in3", "in4", "in1 da", "in2 da", "mono", "mute"
264	};	264	};
265		265
266	void msp_set_scart(struct i2c_client *client, int in, int out)	266	void msp_set_scart(struct i2c_client *client, int in, int out)
267	{	267	{
268	struct msp_state *state = to_state(i2c_get_clientdata(client));	268	struct msp_state *state = to_state(i2c_get_clientdata(client));
269		269
270	state->in_scart = in;	270	state->in_scart = in;
271		271
272	if (in >= 0 && in <= 7 && out >= 0 && out <= 2) {	272	if (in >= 0 && in <= 7 && out >= 0 && out <= 2) {
273	if (-1 == scarts[out][in + 1])	273	if (-1 == scarts[out][in + 1])
274	return;	274	return;
275		275
276	state->acb &= ~scarts[out][0];	276	state->acb &= ~scarts[out][0];
277	state->acb \|= scarts[out][in + 1];	277	state->acb \|= scarts[out][in + 1];
278	} else	278	} else
279	state->acb = 0xf60; /* Mute Input and SCART 1 Output */	279	state->acb = 0xf60; /* Mute Input and SCART 1 Output */
280		280
281	v4l_dbg(1, msp_debug, client, "scart switch: %s => %d (ACB=0x%04x)\n",	281	v4l_dbg(1, msp_debug, client, "scart switch: %s => %d (ACB=0x%04x)\n",
282	scart_names[in], out, state->acb);	282	scart_names[in], out, state->acb);
283	msp_write_dsp(client, 0x13, state->acb);	283	msp_write_dsp(client, 0x13, state->acb);
284		284
285	/* Sets I2S speed 0 = 1.024 Mbps, 1 = 2.048 Mbps */	285	/* Sets I2S speed 0 = 1.024 Mbps, 1 = 2.048 Mbps */
286	if (state->has_i2s_conf)	286	if (state->has_i2s_conf)
287	msp_write_dem(client, 0x40, state->i2s_mode);	287	msp_write_dem(client, 0x40, state->i2s_mode);
288	}	288	}
289		289
290	void msp_set_audio(struct i2c_client *client)	290	void msp_set_audio(struct i2c_client *client)
291	{	291	{
292	struct msp_state *state = to_state(i2c_get_clientdata(client));	292	struct msp_state *state = to_state(i2c_get_clientdata(client));
293	int bal = 0, bass, treble, loudness;	293	int bal = 0, bass, treble, loudness;
294	int val = 0;	294	int val = 0;
295	int reallymuted = state->muted \| state->scan_in_progress;	295	int reallymuted = state->muted \| state->scan_in_progress;
296		296
297	if (!reallymuted)	297	if (!reallymuted)
298	val = (state->volume * 0x7f / 65535) << 8;	298	val = (state->volume * 0x7f / 65535) << 8;
299		299
300	v4l_dbg(1, msp_debug, client, "mute=%s scanning=%s volume=%d\n",	300	v4l_dbg(1, msp_debug, client, "mute=%s scanning=%s volume=%d\n",
301	state->muted ? "on" : "off",	301	state->muted ? "on" : "off",
302	state->scan_in_progress ? "yes" : "no",	302	state->scan_in_progress ? "yes" : "no",
303	state->volume);	303	state->volume);
304		304
305	msp_write_dsp(client, 0x0000, val);	305	msp_write_dsp(client, 0x0000, val);
306	msp_write_dsp(client, 0x0007, reallymuted ? 0x1 : (val \| 0x1));	306	msp_write_dsp(client, 0x0007, reallymuted ? 0x1 : (val \| 0x1));
307	if (state->has_scart2_out_volume)	307	if (state->has_scart2_out_volume)
308	msp_write_dsp(client, 0x0040, reallymuted ? 0x1 : (val \| 0x1));	308	msp_write_dsp(client, 0x0040, reallymuted ? 0x1 : (val \| 0x1));
309	if (state->has_headphones)	309	if (state->has_headphones)
310	msp_write_dsp(client, 0x0006, val);	310	msp_write_dsp(client, 0x0006, val);
311	if (!state->has_sound_processing)	311	if (!state->has_sound_processing)
312	return;	312	return;
313		313
314	if (val)	314	if (val)
315	bal = (u8)((state->balance / 256) - 128);	315	bal = (u8)((state->balance / 256) - 128);
316	bass = ((state->bass - 32768) * 0x60 / 65535) << 8;	316	bass = ((state->bass - 32768) * 0x60 / 65535) << 8;
317	treble = ((state->treble - 32768) * 0x60 / 65535) << 8;	317	treble = ((state->treble - 32768) * 0x60 / 65535) << 8;
318	loudness = state->loudness ? ((5 * 4) << 8) : 0;	318	loudness = state->loudness ? ((5 * 4) << 8) : 0;
319		319
320	v4l_dbg(1, msp_debug, client, "balance=%d bass=%d treble=%d loudness=%d\n",	320	v4l_dbg(1, msp_debug, client, "balance=%d bass=%d treble=%d loudness=%d\n",
321	state->balance, state->bass, state->treble, state->loudness);	321	state->balance, state->bass, state->treble, state->loudness);
322		322
323	msp_write_dsp(client, 0x0001, bal << 8);	323	msp_write_dsp(client, 0x0001, bal << 8);
324	msp_write_dsp(client, 0x0002, bass);	324	msp_write_dsp(client, 0x0002, bass);
325	msp_write_dsp(client, 0x0003, treble);	325	msp_write_dsp(client, 0x0003, treble);
326	msp_write_dsp(client, 0x0004, loudness);	326	msp_write_dsp(client, 0x0004, loudness);
327	if (!state->has_headphones)	327	if (!state->has_headphones)
328	return;	328	return;
329	msp_write_dsp(client, 0x0030, bal << 8);	329	msp_write_dsp(client, 0x0030, bal << 8);
330	msp_write_dsp(client, 0x0031, bass);	330	msp_write_dsp(client, 0x0031, bass);
331	msp_write_dsp(client, 0x0032, treble);	331	msp_write_dsp(client, 0x0032, treble);
332	msp_write_dsp(client, 0x0033, loudness);	332	msp_write_dsp(client, 0x0033, loudness);
333	}	333	}
334		334
335	/* ------------------------------------------------------------------------ */	335	/* ------------------------------------------------------------------------ */
336		336
337	static void msp_wake_thread(struct i2c_client *client)	337	static void msp_wake_thread(struct i2c_client *client)
338	{	338	{
339	struct msp_state *state = to_state(i2c_get_clientdata(client));	339	struct msp_state *state = to_state(i2c_get_clientdata(client));
340		340
341	if (NULL == state->kthread)	341	if (NULL == state->kthread)
342	return;	342	return;
343	state->watch_stereo = 0;	343	state->watch_stereo = 0;
344	state->restart = 1;	344	state->restart = 1;
345	wake_up_interruptible(&state->wq);	345	wake_up_interruptible(&state->wq);
346	}	346	}
347		347
348	int msp_sleep(struct msp_state *state, int timeout)	348	int msp_sleep(struct msp_state *state, int timeout)
349	{	349	{
350	DECLARE_WAITQUEUE(wait, current);	350	DECLARE_WAITQUEUE(wait, current);
351		351
352	add_wait_queue(&state->wq, &wait);	352	add_wait_queue(&state->wq, &wait);
353	if (!kthread_should_stop()) {	353	if (!kthread_should_stop()) {
354	if (timeout < 0) {	354	if (timeout < 0) {
355	set_current_state(TASK_INTERRUPTIBLE);	355	set_current_state(TASK_INTERRUPTIBLE);
356	schedule();	356	schedule();
357	} else {	357	} else {
358	schedule_timeout_interruptible	358	schedule_timeout_interruptible
359	(msecs_to_jiffies(timeout));	359	(msecs_to_jiffies(timeout));
360	}	360	}
361	}	361	}
362		362
363	remove_wait_queue(&state->wq, &wait);	363	remove_wait_queue(&state->wq, &wait);
364	try_to_freeze();	364	try_to_freeze();
365	return state->restart;	365	return state->restart;
366	}	366	}
367		367
368	/* ------------------------------------------------------------------------ */	368	/* ------------------------------------------------------------------------ */
369	#ifdef CONFIG_VIDEO_ALLOW_V4L1	369	#ifdef CONFIG_VIDEO_ALLOW_V4L1
370	static int msp_mode_v4l2_to_v4l1(int rxsubchans, int audmode)	370	static int msp_mode_v4l2_to_v4l1(int rxsubchans, int audmode)
371	{	371	{
372	if (rxsubchans == V4L2_TUNER_SUB_MONO)	372	if (rxsubchans == V4L2_TUNER_SUB_MONO)
373	return VIDEO_SOUND_MONO;	373	return VIDEO_SOUND_MONO;
374	if (rxsubchans == V4L2_TUNER_SUB_STEREO)	374	if (rxsubchans == V4L2_TUNER_SUB_STEREO)
375	return VIDEO_SOUND_STEREO;	375	return VIDEO_SOUND_STEREO;
376	if (audmode == V4L2_TUNER_MODE_LANG2)	376	if (audmode == V4L2_TUNER_MODE_LANG2)
377	return VIDEO_SOUND_LANG2;	377	return VIDEO_SOUND_LANG2;
378	return VIDEO_SOUND_LANG1;	378	return VIDEO_SOUND_LANG1;
379	}	379	}
380		380
381	static int msp_mode_v4l1_to_v4l2(int mode)	381	static int msp_mode_v4l1_to_v4l2(int mode)
382	{	382	{
383	if (mode & VIDEO_SOUND_STEREO)	383	if (mode & VIDEO_SOUND_STEREO)
384	return V4L2_TUNER_MODE_STEREO;	384	return V4L2_TUNER_MODE_STEREO;
385	if (mode & VIDEO_SOUND_LANG2)	385	if (mode & VIDEO_SOUND_LANG2)
386	return V4L2_TUNER_MODE_LANG2;	386	return V4L2_TUNER_MODE_LANG2;
387	if (mode & VIDEO_SOUND_LANG1)	387	if (mode & VIDEO_SOUND_LANG1)
388	return V4L2_TUNER_MODE_LANG1;	388	return V4L2_TUNER_MODE_LANG1;
389	return V4L2_TUNER_MODE_MONO;	389	return V4L2_TUNER_MODE_MONO;
390	}	390	}
391	#endif	391	#endif
392		392
393	static int msp_g_ctrl(struct v4l2_subdev sd, struct v4l2_control ctrl)	393	static int msp_g_ctrl(struct v4l2_subdev sd, struct v4l2_control ctrl)
394	{	394	{
395	struct msp_state *state = to_state(sd);	395	struct msp_state *state = to_state(sd);
396		396
397	switch (ctrl->id) {	397	switch (ctrl->id) {
398	case V4L2_CID_AUDIO_VOLUME:	398	case V4L2_CID_AUDIO_VOLUME:
399	ctrl->value = state->volume;	399	ctrl->value = state->volume;
400	break;	400	break;
401		401
402	case V4L2_CID_AUDIO_MUTE:	402	case V4L2_CID_AUDIO_MUTE:
403	ctrl->value = state->muted;	403	ctrl->value = state->muted;
404	break;	404	break;
405		405
406	case V4L2_CID_AUDIO_BALANCE:	406	case V4L2_CID_AUDIO_BALANCE:
407	if (!state->has_sound_processing)	407	if (!state->has_sound_processing)
408	return -EINVAL;	408	return -EINVAL;
409	ctrl->value = state->balance;	409	ctrl->value = state->balance;
410	break;	410	break;
411		411
412	case V4L2_CID_AUDIO_BASS:	412	case V4L2_CID_AUDIO_BASS:
413	if (!state->has_sound_processing)	413	if (!state->has_sound_processing)
414	return -EINVAL;	414	return -EINVAL;
415	ctrl->value = state->bass;	415	ctrl->value = state->bass;
416	break;	416	break;
417		417
418	case V4L2_CID_AUDIO_TREBLE:	418	case V4L2_CID_AUDIO_TREBLE:
419	if (!state->has_sound_processing)	419	if (!state->has_sound_processing)
420	return -EINVAL;	420	return -EINVAL;
421	ctrl->value = state->treble;	421	ctrl->value = state->treble;
422	break;	422	break;
423		423
424	case V4L2_CID_AUDIO_LOUDNESS:	424	case V4L2_CID_AUDIO_LOUDNESS:
425	if (!state->has_sound_processing)	425	if (!state->has_sound_processing)
426	return -EINVAL;	426	return -EINVAL;
427	ctrl->value = state->loudness;	427	ctrl->value = state->loudness;
428	break;	428	break;
429		429
430	default:	430	default:
431	return -EINVAL;	431	return -EINVAL;
432	}	432	}
433	return 0;	433	return 0;
434	}	434	}
435		435
436	static int msp_s_ctrl(struct v4l2_subdev sd, struct v4l2_control ctrl)	436	static int msp_s_ctrl(struct v4l2_subdev sd, struct v4l2_control ctrl)
437	{	437	{
438	struct msp_state *state = to_state(sd);	438	struct msp_state *state = to_state(sd);
439	struct i2c_client *client = v4l2_get_subdevdata(sd);	439	struct i2c_client *client = v4l2_get_subdevdata(sd);
440		440
441	switch (ctrl->id) {	441	switch (ctrl->id) {
442	case V4L2_CID_AUDIO_VOLUME:	442	case V4L2_CID_AUDIO_VOLUME:
443	state->volume = ctrl->value;	443	state->volume = ctrl->value;
444	if (state->volume == 0)	444	if (state->volume == 0)
445	state->balance = 32768;	445	state->balance = 32768;
446	break;	446	break;
447		447
448	case V4L2_CID_AUDIO_MUTE:	448	case V4L2_CID_AUDIO_MUTE:
449	if (ctrl->value < 0 \|\| ctrl->value >= 2)	449	if (ctrl->value < 0 \|\| ctrl->value >= 2)
450	return -ERANGE;	450	return -ERANGE;
451	state->muted = ctrl->value;	451	state->muted = ctrl->value;
452	break;	452	break;
453		453
454	case V4L2_CID_AUDIO_BASS:	454	case V4L2_CID_AUDIO_BASS:
455	if (!state->has_sound_processing)	455	if (!state->has_sound_processing)
456	return -EINVAL;	456	return -EINVAL;
457	state->bass = ctrl->value;	457	state->bass = ctrl->value;
458	break;	458	break;
459		459
460	case V4L2_CID_AUDIO_TREBLE:	460	case V4L2_CID_AUDIO_TREBLE:
461	if (!state->has_sound_processing)	461	if (!state->has_sound_processing)
462	return -EINVAL;	462	return -EINVAL;
463	state->treble = ctrl->value;	463	state->treble = ctrl->value;
464	break;	464	break;
465		465
466	case V4L2_CID_AUDIO_LOUDNESS:	466	case V4L2_CID_AUDIO_LOUDNESS:
467	if (!state->has_sound_processing)	467	if (!state->has_sound_processing)
468	return -EINVAL;	468	return -EINVAL;
469	state->loudness = ctrl->value;	469	state->loudness = ctrl->value;
470	break;	470	break;
471		471
472	case V4L2_CID_AUDIO_BALANCE:	472	case V4L2_CID_AUDIO_BALANCE:
473	if (!state->has_sound_processing)	473	if (!state->has_sound_processing)
474	return -EINVAL;	474	return -EINVAL;
475	state->balance = ctrl->value;	475	state->balance = ctrl->value;
476	break;	476	break;
477		477
478	default:	478	default:
479	return -EINVAL;	479	return -EINVAL;
480	}	480	}
481	msp_set_audio(client);	481	msp_set_audio(client);
482	return 0;	482	return 0;
483	}	483	}
484		484
485	#ifdef CONFIG_VIDEO_ALLOW_V4L1	485	#ifdef CONFIG_VIDEO_ALLOW_V4L1
486	static long msp_ioctl(struct v4l2_subdev sd, unsigned int cmd, void arg)	486	static long msp_ioctl(struct v4l2_subdev sd, unsigned int cmd, void arg)
487	{	487	{
488	struct msp_state *state = to_state(sd);	488	struct msp_state *state = to_state(sd);
489	struct i2c_client *client = v4l2_get_subdevdata(sd);	489	struct i2c_client *client = v4l2_get_subdevdata(sd);
490		490
491	switch (cmd) {	491	switch (cmd) {
492	/* --- v4l ioctls --- */	492	/* --- v4l ioctls --- */
493	/* take care: bttv does userspace copying, we'll get a	493	/* take care: bttv does userspace copying, we'll get a
494	kernel pointer here... */	494	kernel pointer here... */
495	case VIDIOCGAUDIO:	495	case VIDIOCGAUDIO:
496	{	496	{
497	struct video_audio *va = arg;	497	struct video_audio *va = arg;
498		498
499	va->flags \|= VIDEO_AUDIO_VOLUME \| VIDEO_AUDIO_MUTABLE;	499	va->flags \|= VIDEO_AUDIO_VOLUME \| VIDEO_AUDIO_MUTABLE;
500	if (state->has_sound_processing)	500	if (state->has_sound_processing)
501	va->flags \|= VIDEO_AUDIO_BALANCE \|	501	va->flags \|= VIDEO_AUDIO_BALANCE \|
502	VIDEO_AUDIO_BASS \|	502	VIDEO_AUDIO_BASS \|
503	VIDEO_AUDIO_TREBLE;	503	VIDEO_AUDIO_TREBLE;
504	if (state->muted)	504	if (state->muted)
505	va->flags \|= VIDEO_AUDIO_MUTE;	505	va->flags \|= VIDEO_AUDIO_MUTE;
506	va->volume = state->volume;	506	va->volume = state->volume;
507	va->balance = state->volume ? state->balance : 32768;	507	va->balance = state->volume ? state->balance : 32768;
508	va->bass = state->bass;	508	va->bass = state->bass;
509	va->treble = state->treble;	509	va->treble = state->treble;
510		510
511	if (state->radio)	511	if (state->radio)
512	break;	512	break;
513	if (state->opmode == OPMODE_AUTOSELECT)	513	if (state->opmode == OPMODE_AUTOSELECT)
514	msp_detect_stereo(client);	514	msp_detect_stereo(client);
515	va->mode = msp_mode_v4l2_to_v4l1(state->rxsubchans, state->audmode);	515	va->mode = msp_mode_v4l2_to_v4l1(state->rxsubchans, state->audmode);
516	break;	516	break;
517	}	517	}
518		518
519	case VIDIOCSAUDIO:	519	case VIDIOCSAUDIO:
520	{	520	{
521	struct video_audio *va = arg;	521	struct video_audio *va = arg;
522		522
523	state->muted = (va->flags & VIDEO_AUDIO_MUTE);	523	state->muted = (va->flags & VIDEO_AUDIO_MUTE);
524	state->volume = va->volume;	524	state->volume = va->volume;
525	state->balance = va->balance;	525	state->balance = va->balance;
526	state->bass = va->bass;	526	state->bass = va->bass;
527	state->treble = va->treble;	527	state->treble = va->treble;
528	msp_set_audio(client);	528	msp_set_audio(client);
529		529
530	if (va->mode != 0 && state->radio == 0 &&	530	if (va->mode != 0 && state->radio == 0 &&
531	state->audmode != msp_mode_v4l1_to_v4l2(va->mode)) {	531	state->audmode != msp_mode_v4l1_to_v4l2(va->mode)) {
532	state->audmode = msp_mode_v4l1_to_v4l2(va->mode);	532	state->audmode = msp_mode_v4l1_to_v4l2(va->mode);
533	msp_set_audmode(client);	533	msp_set_audmode(client);
534	}	534	}
535	break;	535	break;
536	}	536	}
537		537
538	case VIDIOCSCHAN:	538	case VIDIOCSCHAN:
539	{	539	{
540	struct video_channel *vc = arg;	540	struct video_channel *vc = arg;
541	int update = 0;	541	int update = 0;
542	v4l2_std_id std;	542	v4l2_std_id std;
543		543
544	if (state->radio)	544	if (state->radio)
545	update = 1;	545	update = 1;
546	state->radio = 0;	546	state->radio = 0;
547	if (vc->norm == VIDEO_MODE_PAL)	547	if (vc->norm == VIDEO_MODE_PAL)
548	std = V4L2_STD_PAL;	548	std = V4L2_STD_PAL;
549	else if (vc->norm == VIDEO_MODE_SECAM)	549	else if (vc->norm == VIDEO_MODE_SECAM)
550	std = V4L2_STD_SECAM;	550	std = V4L2_STD_SECAM;
551	else	551	else
552	std = V4L2_STD_NTSC;	552	std = V4L2_STD_NTSC;
553	if (std != state->v4l2_std) {	553	if (std != state->v4l2_std) {
554	state->v4l2_std = std;	554	state->v4l2_std = std;
555	update = 1;	555	update = 1;
556	}	556	}
557	if (update)	557	if (update)
558	msp_wake_thread(client);	558	msp_wake_thread(client);
559	break;	559	break;
560	}	560	}
561		561
562	case VIDIOCSFREQ:	562	case VIDIOCSFREQ:
563	{	563	{
564	/* new channel -- kick audio carrier scan */	564	/* new channel -- kick audio carrier scan */
565	msp_wake_thread(client);	565	msp_wake_thread(client);
566	break;	566	break;
567	}	567	}
568	default:	568	default:
569	return -ENOIOCTLCMD;	569	return -ENOIOCTLCMD;
570	}	570	}
571	return 0;	571	return 0;
572	}	572	}
573	#endif	573	#endif
574		574
575	/* --- v4l2 ioctls --- */	575	/* --- v4l2 ioctls --- */
576	static int msp_s_radio(struct v4l2_subdev *sd)	576	static int msp_s_radio(struct v4l2_subdev *sd)
577	{	577	{
578	struct msp_state *state = to_state(sd);	578	struct msp_state *state = to_state(sd);
579	struct i2c_client *client = v4l2_get_subdevdata(sd);	579	struct i2c_client *client = v4l2_get_subdevdata(sd);
580		580
581	if (state->radio)	581	if (state->radio)
582	return 0;	582	return 0;
583	state->radio = 1;	583	state->radio = 1;
584	v4l_dbg(1, msp_debug, client, "switching to radio mode\n");	584	v4l_dbg(1, msp_debug, client, "switching to radio mode\n");
585	state->watch_stereo = 0;	585	state->watch_stereo = 0;
586	switch (state->opmode) {	586	switch (state->opmode) {
587	case OPMODE_MANUAL:	587	case OPMODE_MANUAL:
588	/* set msp3400 to FM radio mode */	588	/* set msp3400 to FM radio mode */
589	msp3400c_set_mode(client, MSP_MODE_FM_RADIO);	589	msp3400c_set_mode(client, MSP_MODE_FM_RADIO);
590	msp3400c_set_carrier(client, MSP_CARRIER(10.7),	590	msp3400c_set_carrier(client, MSP_CARRIER(10.7),
591	MSP_CARRIER(10.7));	591	MSP_CARRIER(10.7));
592	msp_set_audio(client);	592	msp_set_audio(client);
593	break;	593	break;
594	case OPMODE_AUTODETECT:	594	case OPMODE_AUTODETECT:
595	case OPMODE_AUTOSELECT:	595	case OPMODE_AUTOSELECT:
596	/* the thread will do for us */	596	/* the thread will do for us */
597	msp_wake_thread(client);	597	msp_wake_thread(client);
598	break;	598	break;
599	}	599	}
600	return 0;	600	return 0;
601	}	601	}
602		602
603	static int msp_s_frequency(struct v4l2_subdev sd, struct v4l2_frequency freq)	603	static int msp_s_frequency(struct v4l2_subdev sd, struct v4l2_frequency freq)
604	{	604	{
605	struct i2c_client *client = v4l2_get_subdevdata(sd);	605	struct i2c_client *client = v4l2_get_subdevdata(sd);
606		606
607	/* new channel -- kick audio carrier scan */	607	/* new channel -- kick audio carrier scan */
608	msp_wake_thread(client);	608	msp_wake_thread(client);
609	return 0;	609	return 0;
610	}	610	}
611		611
612	static int msp_s_std(struct v4l2_subdev *sd, v4l2_std_id id)	612	static int msp_s_std(struct v4l2_subdev *sd, v4l2_std_id id)
613	{	613	{
614	struct msp_state *state = to_state(sd);	614	struct msp_state *state = to_state(sd);
615	struct i2c_client *client = v4l2_get_subdevdata(sd);	615	struct i2c_client *client = v4l2_get_subdevdata(sd);
616	int update = state->radio \|\| state->v4l2_std != id;	616	int update = state->radio \|\| state->v4l2_std != id;
617		617
618	state->v4l2_std = id;	618	state->v4l2_std = id;
619	state->radio = 0;	619	state->radio = 0;
620	if (update)	620	if (update)
621	msp_wake_thread(client);	621	msp_wake_thread(client);
622	return 0;	622	return 0;
623	}	623	}
624		624
625	static int msp_s_routing(struct v4l2_subdev sd, const struct v4l2_routing rt)	625	static int msp_s_routing(struct v4l2_subdev sd, const struct v4l2_routing rt)
626	{	626	{
627	struct msp_state *state = to_state(sd);	627	struct msp_state *state = to_state(sd);
628	struct i2c_client *client = v4l2_get_subdevdata(sd);	628	struct i2c_client *client = v4l2_get_subdevdata(sd);
629	int tuner = (rt->input >> 3) & 1;	629	int tuner = (rt->input >> 3) & 1;
630	int sc_in = rt->input & 0x7;	630	int sc_in = rt->input & 0x7;
631	int sc1_out = rt->output & 0xf;	631	int sc1_out = rt->output & 0xf;
632	int sc2_out = (rt->output >> 4) & 0xf;	632	int sc2_out = (rt->output >> 4) & 0xf;
633	u16 val, reg;	633	u16 val, reg;
634	int i;	634	int i;
635	int extern_input = 1;	635	int extern_input = 1;
636		636
637	if (state->routing.input == rt->input &&	637	if (state->routing.input == rt->input &&
638	state->routing.output == rt->output)	638	state->routing.output == rt->output)
639	return 0;	639	return 0;
640	state->routing = *rt;	640	state->routing = *rt;
641	/* check if the tuner input is used */	641	/* check if the tuner input is used */
642	for (i = 0; i < 5; i++) {	642	for (i = 0; i < 5; i++) {
643	if (((rt->input >> (4 + i * 4)) & 0xf) == 0)	643	if (((rt->input >> (4 + i * 4)) & 0xf) == 0)
644	extern_input = 0;	644	extern_input = 0;
645	}	645	}
646	state->mode = extern_input ? MSP_MODE_EXTERN : MSP_MODE_AM_DETECT;	646	state->mode = extern_input ? MSP_MODE_EXTERN : MSP_MODE_AM_DETECT;
647	state->rxsubchans = V4L2_TUNER_SUB_STEREO;	647	state->rxsubchans = V4L2_TUNER_SUB_STEREO;
648	msp_set_scart(client, sc_in, 0);	648	msp_set_scart(client, sc_in, 0);
649	msp_set_scart(client, sc1_out, 1);	649	msp_set_scart(client, sc1_out, 1);
650	msp_set_scart(client, sc2_out, 2);	650	msp_set_scart(client, sc2_out, 2);
651	msp_set_audmode(client);	651	msp_set_audmode(client);
652	reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb;	652	reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb;
653	val = msp_read_dem(client, reg);	653	val = msp_read_dem(client, reg);
654	msp_write_dem(client, reg, (val & ~0x100) \| (tuner << 8));	654	msp_write_dem(client, reg, (val & ~0x100) \| (tuner << 8));
655	/* wake thread when a new input is chosen */	655	/* wake thread when a new input is chosen */
656	msp_wake_thread(client);	656	msp_wake_thread(client);
657	return 0;	657	return 0;
658	}	658	}
659		659
660	static int msp_g_tuner(struct v4l2_subdev sd, struct v4l2_tuner vt)	660	static int msp_g_tuner(struct v4l2_subdev sd, struct v4l2_tuner vt)
661	{	661	{
662	struct msp_state *state = to_state(sd);	662	struct msp_state *state = to_state(sd);
663	struct i2c_client *client = v4l2_get_subdevdata(sd);	663	struct i2c_client *client = v4l2_get_subdevdata(sd);
664		664
665	if (state->radio)	665	if (state->radio)
666	return 0;	666	return 0;
667	if (state->opmode == OPMODE_AUTOSELECT)	667	if (state->opmode == OPMODE_AUTOSELECT)
668	msp_detect_stereo(client);	668	msp_detect_stereo(client);
669	vt->audmode = state->audmode;	669	vt->audmode = state->audmode;
670	vt->rxsubchans = state->rxsubchans;	670	vt->rxsubchans = state->rxsubchans;
671	vt->capability \|= V4L2_TUNER_CAP_STEREO \|	671	vt->capability \|= V4L2_TUNER_CAP_STEREO \|
672	V4L2_TUNER_CAP_LANG1 \| V4L2_TUNER_CAP_LANG2;	672	V4L2_TUNER_CAP_LANG1 \| V4L2_TUNER_CAP_LANG2;
673	return 0;	673	return 0;
674	}	674	}
675		675
676	static int msp_s_tuner(struct v4l2_subdev sd, struct v4l2_tuner vt)	676	static int msp_s_tuner(struct v4l2_subdev sd, struct v4l2_tuner vt)
677	{	677	{
678	struct msp_state *state = to_state(sd);	678	struct msp_state *state = to_state(sd);
679	struct i2c_client *client = v4l2_get_subdevdata(sd);	679	struct i2c_client *client = v4l2_get_subdevdata(sd);
680		680
681	if (state->radio) /* TODO: add mono/stereo support for radio */	681	if (state->radio) /* TODO: add mono/stereo support for radio */
682	return 0;	682	return 0;
683	if (state->audmode == vt->audmode)	683	if (state->audmode == vt->audmode)
684	return 0;	684	return 0;
685	state->audmode = vt->audmode;	685	state->audmode = vt->audmode;
686	/* only set audmode */	686	/* only set audmode */
687	msp_set_audmode(client);	687	msp_set_audmode(client);
688	return 0;	688	return 0;
689	}	689	}
690		690
691	static int msp_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)	691	static int msp_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)
692	{	692	{
693	struct msp_state *state = to_state(sd);	693	struct msp_state *state = to_state(sd);
694	struct i2c_client *client = v4l2_get_subdevdata(sd);	694	struct i2c_client *client = v4l2_get_subdevdata(sd);
695		695
696	v4l_dbg(1, msp_debug, client, "Setting I2S speed to %d\n", freq);	696	v4l_dbg(1, msp_debug, client, "Setting I2S speed to %d\n", freq);
697		697
698	switch (freq) {	698	switch (freq) {
699	case 1024000:	699	case 1024000:
700	state->i2s_mode = 0;	700	state->i2s_mode = 0;
701	break;	701	break;
702	case 2048000:	702	case 2048000:
703	state->i2s_mode = 1;	703	state->i2s_mode = 1;
704	break;	704	break;
705	default:	705	default:
706	return -EINVAL;	706	return -EINVAL;
707	}	707	}
708	return 0;	708	return 0;
709	}	709	}
710		710
711	static int msp_queryctrl(struct v4l2_subdev sd, struct v4l2_queryctrl qc)	711	static int msp_queryctrl(struct v4l2_subdev sd, struct v4l2_queryctrl qc)
712	{	712	{
713	struct msp_state *state = to_state(sd);	713	struct msp_state *state = to_state(sd);
714		714
715	switch (qc->id) {	715	switch (qc->id) {
716	case V4L2_CID_AUDIO_VOLUME:	716	case V4L2_CID_AUDIO_VOLUME:
717	return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 58880);	717	return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 58880);
718	case V4L2_CID_AUDIO_MUTE:	718	case V4L2_CID_AUDIO_MUTE:
719	return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);	719	return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
720	default:	720	default:
721	break;	721	break;
722	}	722	}
723	if (!state->has_sound_processing)	723	if (!state->has_sound_processing)
724	return -EINVAL;	724	return -EINVAL;
725	switch (qc->id) {	725	switch (qc->id) {
726	case V4L2_CID_AUDIO_LOUDNESS:	726	case V4L2_CID_AUDIO_LOUDNESS:
727	return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);	727	return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
728	case V4L2_CID_AUDIO_BALANCE:	728	case V4L2_CID_AUDIO_BALANCE:
729	case V4L2_CID_AUDIO_BASS:	729	case V4L2_CID_AUDIO_BASS:
730	case V4L2_CID_AUDIO_TREBLE:	730	case V4L2_CID_AUDIO_TREBLE:
731	return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 32768);	731	return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 32768);
732	default:	732	default:
733	return -EINVAL;	733	return -EINVAL;
734	}	734	}
735	return 0;	735	return 0;
736	}	736	}
737		737
738	static int msp_g_chip_ident(struct v4l2_subdev sd, struct v4l2_dbg_chip_ident chip)	738	static int msp_g_chip_ident(struct v4l2_subdev sd, struct v4l2_dbg_chip_ident chip)
739	{	739	{
740	struct msp_state *state = to_state(sd);	740	struct msp_state *state = to_state(sd);
741	struct i2c_client *client = v4l2_get_subdevdata(sd);	741	struct i2c_client *client = v4l2_get_subdevdata(sd);
742		742
743	return v4l2_chip_ident_i2c_client(client, chip, state->ident,	743	return v4l2_chip_ident_i2c_client(client, chip, state->ident,
744	(state->rev1 << 16) \| state->rev2);	744	(state->rev1 << 16) \| state->rev2);
745	}	745	}
746		746
747	static int msp_log_status(struct v4l2_subdev *sd)	747	static int msp_log_status(struct v4l2_subdev *sd)
748	{	748	{
749	struct msp_state *state = to_state(sd);	749	struct msp_state *state = to_state(sd);
750	struct i2c_client *client = v4l2_get_subdevdata(sd);	750	struct i2c_client *client = v4l2_get_subdevdata(sd);
751	const char *p;	751	const char *p;
752		752
753	if (state->opmode == OPMODE_AUTOSELECT)	753	if (state->opmode == OPMODE_AUTOSELECT)
754	msp_detect_stereo(client);	754	msp_detect_stereo(client);
755	v4l_info(client, "%s rev1 = 0x%04x rev2 = 0x%04x\n",	755	v4l_info(client, "%s rev1 = 0x%04x rev2 = 0x%04x\n",
756	client->name, state->rev1, state->rev2);	756	client->name, state->rev1, state->rev2);
757	v4l_info(client, "Audio: volume %d%s\n",	757	v4l_info(client, "Audio: volume %d%s\n",
758	state->volume, state->muted ? " (muted)" : "");	758	state->volume, state->muted ? " (muted)" : "");
759	if (state->has_sound_processing) {	759	if (state->has_sound_processing) {
760	v4l_info(client, "Audio: balance %d bass %d treble %d loudness %s\n",	760	v4l_info(client, "Audio: balance %d bass %d treble %d loudness %s\n",
761	state->balance, state->bass,	761	state->balance, state->bass,
762	state->treble,	762	state->treble,
763	state->loudness ? "on" : "off");	763	state->loudness ? "on" : "off");
764	}	764	}
765	switch (state->mode) {	765	switch (state->mode) {
766	case MSP_MODE_AM_DETECT: p = "AM (for carrier detect)"; break;	766	case MSP_MODE_AM_DETECT: p = "AM (for carrier detect)"; break;
767	case MSP_MODE_FM_RADIO: p = "FM Radio"; break;	767	case MSP_MODE_FM_RADIO: p = "FM Radio"; break;
768	case MSP_MODE_FM_TERRA: p = "Terrestial FM-mono/stereo"; break;	768	case MSP_MODE_FM_TERRA: p = "Terrestial FM-mono/stereo"; break;
769	case MSP_MODE_FM_SAT: p = "Satellite FM-mono"; break;	769	case MSP_MODE_FM_SAT: p = "Satellite FM-mono"; break;
770	case MSP_MODE_FM_NICAM1: p = "NICAM/FM (B/G, D/K)"; break;	770	case MSP_MODE_FM_NICAM1: p = "NICAM/FM (B/G, D/K)"; break;
771	case MSP_MODE_FM_NICAM2: p = "NICAM/FM (I)"; break;	771	case MSP_MODE_FM_NICAM2: p = "NICAM/FM (I)"; break;
772	case MSP_MODE_AM_NICAM: p = "NICAM/AM (L)"; break;	772	case MSP_MODE_AM_NICAM: p = "NICAM/AM (L)"; break;
773	case MSP_MODE_BTSC: p = "BTSC"; break;	773	case MSP_MODE_BTSC: p = "BTSC"; break;
774	case MSP_MODE_EXTERN: p = "External input"; break;	774	case MSP_MODE_EXTERN: p = "External input"; break;
775	default: p = "unknown"; break;	775	default: p = "unknown"; break;
776	}	776	}
777	if (state->mode == MSP_MODE_EXTERN) {	777	if (state->mode == MSP_MODE_EXTERN) {
778	v4l_info(client, "Mode: %s\n", p);	778	v4l_info(client, "Mode: %s\n", p);
779	} else if (state->opmode == OPMODE_MANUAL) {	779	} else if (state->opmode == OPMODE_MANUAL) {
780	v4l_info(client, "Mode: %s (%s%s)\n", p,	780	v4l_info(client, "Mode: %s (%s%s)\n", p,
781	(state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",	781	(state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
782	(state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");	782	(state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
783	} else {	783	} else {
784	if (state->opmode == OPMODE_AUTODETECT)	784	if (state->opmode == OPMODE_AUTODETECT)
785	v4l_info(client, "Mode: %s\n", p);	785	v4l_info(client, "Mode: %s\n", p);
786	v4l_info(client, "Standard: %s (%s%s)\n",	786	v4l_info(client, "Standard: %s (%s%s)\n",
787	msp_standard_std_name(state->std),	787	msp_standard_std_name(state->std),
788	(state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",	788	(state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
789	(state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");	789	(state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
790	}	790	}
791	v4l_info(client, "Audmode: 0x%04x\n", state->audmode);	791	v4l_info(client, "Audmode: 0x%04x\n", state->audmode);
792	v4l_info(client, "Routing: 0x%08x (input) 0x%08x (output)\n",	792	v4l_info(client, "Routing: 0x%08x (input) 0x%08x (output)\n",
793	state->routing.input, state->routing.output);	793	state->routing.input, state->routing.output);
794	v4l_info(client, "ACB: 0x%04x\n", state->acb);	794	v4l_info(client, "ACB: 0x%04x\n", state->acb);
795	return 0;	795	return 0;
796	}	796	}
797		797
798	static int msp_suspend(struct i2c_client *client, pm_message_t state)	798	static int msp_suspend(struct i2c_client *client, pm_message_t state)
799	{	799	{
800	v4l_dbg(1, msp_debug, client, "suspend\n");	800	v4l_dbg(1, msp_debug, client, "suspend\n");
801	msp_reset(client);	801	msp_reset(client);
802	return 0;	802	return 0;
803	}	803	}
804		804
805	static int msp_resume(struct i2c_client *client)	805	static int msp_resume(struct i2c_client *client)
806	{	806	{
807	v4l_dbg(1, msp_debug, client, "resume\n");	807	v4l_dbg(1, msp_debug, client, "resume\n");
808	msp_wake_thread(client);	808	msp_wake_thread(client);
809	return 0;	809	return 0;
810	}	810	}
811		811
812	static int msp_command(struct i2c_client client, unsigned cmd, void arg)	812	static int msp_command(struct i2c_client client, unsigned cmd, void arg)
813	{	813	{
814	return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);	814	return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
815	}	815	}
816		816
817	/* ----------------------------------------------------------------------- */	817	/* ----------------------------------------------------------------------- */
818		818
819	static const struct v4l2_subdev_core_ops msp_core_ops = {	819	static const struct v4l2_subdev_core_ops msp_core_ops = {
820	.log_status = msp_log_status,	820	.log_status = msp_log_status,
821	.g_chip_ident = msp_g_chip_ident,	821	.g_chip_ident = msp_g_chip_ident,
822	.g_ctrl = msp_g_ctrl,	822	.g_ctrl = msp_g_ctrl,
823	.s_ctrl = msp_s_ctrl,	823	.s_ctrl = msp_s_ctrl,
824	.queryctrl = msp_queryctrl,	824	.queryctrl = msp_queryctrl,
825	#ifdef CONFIG_VIDEO_ALLOW_V4L1	825	#ifdef CONFIG_VIDEO_ALLOW_V4L1
826	.ioctl = msp_ioctl,	826	.ioctl = msp_ioctl,
827	#endif	827	#endif
828	};	828	};
829		829
830	static const struct v4l2_subdev_tuner_ops msp_tuner_ops = {	830	static const struct v4l2_subdev_tuner_ops msp_tuner_ops = {
831	.s_frequency = msp_s_frequency,	831	.s_frequency = msp_s_frequency,
832	.g_tuner = msp_g_tuner,	832	.g_tuner = msp_g_tuner,
833	.s_tuner = msp_s_tuner,	833	.s_tuner = msp_s_tuner,
834	.s_radio = msp_s_radio,	834	.s_radio = msp_s_radio,
835	.s_std = msp_s_std,	835	.s_std = msp_s_std,
836	};	836	};
837		837
838	static const struct v4l2_subdev_audio_ops msp_audio_ops = {	838	static const struct v4l2_subdev_audio_ops msp_audio_ops = {
839	.s_routing = msp_s_routing,	839	.s_routing = msp_s_routing,
840	.s_i2s_clock_freq = msp_s_i2s_clock_freq,	840	.s_i2s_clock_freq = msp_s_i2s_clock_freq,
841	};	841	};
842		842
843	static const struct v4l2_subdev_ops msp_ops = {	843	static const struct v4l2_subdev_ops msp_ops = {
844	.core = &msp_core_ops,	844	.core = &msp_core_ops,
845	.tuner = &msp_tuner_ops,	845	.tuner = &msp_tuner_ops,
846	.audio = &msp_audio_ops,	846	.audio = &msp_audio_ops,
847	};	847	};
848		848
849	/* ----------------------------------------------------------------------- */	849	/* ----------------------------------------------------------------------- */
850		850
851	static int msp_probe(struct i2c_client client, const struct i2c_device_id id)	851	static int msp_probe(struct i2c_client client, const struct i2c_device_id id)
852	{	852	{
853	struct msp_state *state;	853	struct msp_state *state;
854	struct v4l2_subdev *sd;	854	struct v4l2_subdev *sd;
855	int (thread_func)(void data) = NULL;	855	int (thread_func)(void data) = NULL;
856	int msp_hard;	856	int msp_hard;
857	int msp_family;	857	int msp_family;
858	int msp_revision;	858	int msp_revision;
859	int msp_product, msp_prod_hi, msp_prod_lo;	859	int msp_product, msp_prod_hi, msp_prod_lo;
860	int msp_rom;	860	int msp_rom;
861		861
862	if (!id)	862	if (!id)
863	strlcpy(client->name, "msp3400", sizeof(client->name));	863	strlcpy(client->name, "msp3400", sizeof(client->name));
864		864
865	if (msp_reset(client) == -1) {	865	if (msp_reset(client) == -1) {
866	v4l_dbg(1, msp_debug, client, "msp3400 not found\n");	866	v4l_dbg(1, msp_debug, client, "msp3400 not found\n");
867	return -ENODEV;	867	return -ENODEV;
868	}	868	}
869		869
870	state = kzalloc(sizeof(*state), GFP_KERNEL);	870	state = kzalloc(sizeof(*state), GFP_KERNEL);
871	if (!state)	871	if (!state)
872	return -ENOMEM;	872	return -ENOMEM;
873		873
874	sd = &state->sd;	874	sd = &state->sd;
875	v4l2_i2c_subdev_init(sd, client, &msp_ops);	875	v4l2_i2c_subdev_init(sd, client, &msp_ops);
876		876
877	state->v4l2_std = V4L2_STD_NTSC;	877	state->v4l2_std = V4L2_STD_NTSC;
878	state->audmode = V4L2_TUNER_MODE_STEREO;	878	state->audmode = V4L2_TUNER_MODE_STEREO;
879	state->volume = 58880; /* 0db gain */	879	state->volume = 58880; /* 0db gain */
880	state->balance = 32768; /* 0db gain */	880	state->balance = 32768; /* 0db gain */
881	state->bass = 32768;	881	state->bass = 32768;
882	state->treble = 32768;	882	state->treble = 32768;
883	state->loudness = 0;	883	state->loudness = 0;
884	state->input = -1;	884	state->input = -1;
885	state->muted = 0;	885	state->muted = 0;
886	state->i2s_mode = 0;	886	state->i2s_mode = 0;
887	init_waitqueue_head(&state->wq);	887	init_waitqueue_head(&state->wq);
888	/* These are the reset input/output positions */	888	/* These are the reset input/output positions */
889	state->routing.input = MSP_INPUT_DEFAULT;	889	state->routing.input = MSP_INPUT_DEFAULT;
890	state->routing.output = MSP_OUTPUT_DEFAULT;	890	state->routing.output = MSP_OUTPUT_DEFAULT;
891		891
892	state->rev1 = msp_read_dsp(client, 0x1e);	892	state->rev1 = msp_read_dsp(client, 0x1e);
893	if (state->rev1 != -1)	893	if (state->rev1 != -1)
894	state->rev2 = msp_read_dsp(client, 0x1f);	894	state->rev2 = msp_read_dsp(client, 0x1f);
895	v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n",	895	v4l_dbg(1, msp_debug, client, "rev1=0x%04x, rev2=0x%04x\n",
896	state->rev1, state->rev2);	896	state->rev1, state->rev2);
897	if (state->rev1 == -1 \|\| (state->rev1 == 0 && state->rev2 == 0)) {	897	if (state->rev1 == -1 \|\| (state->rev1 == 0 && state->rev2 == 0)) {
898	v4l_dbg(1, msp_debug, client,	898	v4l_dbg(1, msp_debug, client,
899	"not an msp3400 (cannot read chip version)\n");	899	"not an msp3400 (cannot read chip version)\n");
900	kfree(state);	900	kfree(state);
901	return -ENODEV;	901	return -ENODEV;
902	}	902	}
903		903
904	msp_set_audio(client);	904	msp_set_audio(client);
905		905
906	msp_family = ((state->rev1 >> 4) & 0x0f) + 3;	906	msp_family = ((state->rev1 >> 4) & 0x0f) + 3;
907	msp_product = (state->rev2 >> 8) & 0xff;	907	msp_product = (state->rev2 >> 8) & 0xff;
908	msp_prod_hi = msp_product / 10;	908	msp_prod_hi = msp_product / 10;
909	msp_prod_lo = msp_product % 10;	909	msp_prod_lo = msp_product % 10;
910	msp_revision = (state->rev1 & 0x0f) + '@';	910	msp_revision = (state->rev1 & 0x0f) + '@';
911	msp_hard = ((state->rev1 >> 8) & 0xff) + '@';	911	msp_hard = ((state->rev1 >> 8) & 0xff) + '@';
912	msp_rom = state->rev2 & 0x1f;	912	msp_rom = state->rev2 & 0x1f;
913	/* Rev B=2, C=3, D=4, G=7 */	913	/* Rev B=2, C=3, D=4, G=7 */
914	state->ident = msp_family * 10000 + 4000 + msp_product * 10 +	914	state->ident = msp_family * 10000 + 4000 + msp_product * 10 +
915	msp_revision - '@';	915	msp_revision - '@';
916		916
917	/* Has NICAM support: all mspx41x and mspx45x products have NICAM */	917	/* Has NICAM support: all mspx41x and mspx45x products have NICAM */
918	state->has_nicam =	918	state->has_nicam =
919	msp_prod_hi == 1 \|\| msp_prod_hi == 5;	919	msp_prod_hi == 1 \|\| msp_prod_hi == 5;
920	/* Has radio support: was added with revision G */	920	/* Has radio support: was added with revision G */
921	state->has_radio =	921	state->has_radio =
922	msp_revision >= 'G';	922	msp_revision >= 'G';
923	/* Has headphones output: not for stripped down products */	923	/* Has headphones output: not for stripped down products */
924	state->has_headphones =	924	state->has_headphones =
925	msp_prod_lo < 5;	925	msp_prod_lo < 5;
926	/* Has scart2 input: not in stripped down products of the '3' family */	926	/* Has scart2 input: not in stripped down products of the '3' family */
927	state->has_scart2 =	927	state->has_scart2 =
928	msp_family >= 4 \|\| msp_prod_lo < 7;	928	msp_family >= 4 \|\| msp_prod_lo < 7;
929	/* Has scart3 input: not in stripped down products of the '3' family */	929	/* Has scart3 input: not in stripped down products of the '3' family */
930	state->has_scart3 =	930	state->has_scart3 =
931	msp_family >= 4 \|\| msp_prod_lo < 5;	931	msp_family >= 4 \|\| msp_prod_lo < 5;
932	/* Has scart4 input: not in pre D revisions, not in stripped D revs */	932	/* Has scart4 input: not in pre D revisions, not in stripped D revs */
933	state->has_scart4 =	933	state->has_scart4 =
934	msp_family >= 4 \|\| (msp_revision >= 'D' && msp_prod_lo < 5);	934	msp_family >= 4 \|\| (msp_revision >= 'D' && msp_prod_lo < 5);
935	/* Has scart2 output: not in stripped down products of	935	/* Has scart2 output: not in stripped down products of
936	* the '3' family */	936	* the '3' family */
937	state->has_scart2_out =	937	state->has_scart2_out =
938	msp_family >= 4 \|\| msp_prod_lo < 5;	938	msp_family >= 4 \|\| msp_prod_lo < 5;
939	/* Has scart2 a volume control? Not in pre-D revisions. */	939	/* Has scart2 a volume control? Not in pre-D revisions. */
940	state->has_scart2_out_volume =	940	state->has_scart2_out_volume =
941	msp_revision > 'C' && state->has_scart2_out;	941	msp_revision > 'C' && state->has_scart2_out;
942	/* Has a configurable i2s out? */	942	/* Has a configurable i2s out? */
943	state->has_i2s_conf =	943	state->has_i2s_conf =
944	msp_revision >= 'G' && msp_prod_lo < 7;	944	msp_revision >= 'G' && msp_prod_lo < 7;
945	/* Has subwoofer output: not in pre-D revs and not in stripped down	945	/* Has subwoofer output: not in pre-D revs and not in stripped down
946	* products */	946	* products */
947	state->has_subwoofer =	947	state->has_subwoofer =
948	msp_revision >= 'D' && msp_prod_lo < 5;	948	msp_revision >= 'D' && msp_prod_lo < 5;
949	/* Has soundprocessing (bass/treble/balance/loudness/equalizer):	949	/* Has soundprocessing (bass/treble/balance/loudness/equalizer):
950	* not in stripped down products */	950	* not in stripped down products */
951	state->has_sound_processing =	951	state->has_sound_processing =
952	msp_prod_lo < 7;	952	msp_prod_lo < 7;
953	/* Has Virtual Dolby Surround: only in msp34x1 */	953	/* Has Virtual Dolby Surround: only in msp34x1 */
954	state->has_virtual_dolby_surround =	954	state->has_virtual_dolby_surround =
955	msp_revision == 'G' && msp_prod_lo == 1;	955	msp_revision == 'G' && msp_prod_lo == 1;
956	/* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */	956	/* Has Virtual Dolby Surround & Dolby Pro Logic: only in msp34x2 */
957	state->has_dolby_pro_logic =	957	state->has_dolby_pro_logic =
958	msp_revision == 'G' && msp_prod_lo == 2;	958	msp_revision == 'G' && msp_prod_lo == 2;
959	/* The msp343xG supports BTSC only and cannot do Automatic Standard	959	/* The msp343xG supports BTSC only and cannot do Automatic Standard
960	* Detection. */	960	* Detection. */
961	state->force_btsc =	961	state->force_btsc =
962	msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3;	962	msp_family == 3 && msp_revision == 'G' && msp_prod_hi == 3;
963		963
964	state->opmode = opmode;	964	state->opmode = opmode;
965	if (state->opmode == OPMODE_AUTO) {	965	if (state->opmode == OPMODE_AUTO) {
966	/* MSP revision G and up have both autodetect and autoselect */	966	/* MSP revision G and up have both autodetect and autoselect */
967	if (msp_revision >= 'G')	967	if (msp_revision >= 'G')
968	state->opmode = OPMODE_AUTOSELECT;	968	state->opmode = OPMODE_AUTOSELECT;
969	/* MSP revision D and up have autodetect */	969	/* MSP revision D and up have autodetect */
970	else if (msp_revision >= 'D')	970	else if (msp_revision >= 'D')
971	state->opmode = OPMODE_AUTODETECT;	971	state->opmode = OPMODE_AUTODETECT;
972	else	972	else
973	state->opmode = OPMODE_MANUAL;	973	state->opmode = OPMODE_MANUAL;
974	}	974	}
975		975
976	/* hello world :-) */	976	/* hello world :-) */
977	v4l_info(client, "MSP%d4%02d%c-%c%d found @ 0x%x (%s)\n",	977	v4l_info(client, "MSP%d4%02d%c-%c%d found @ 0x%x (%s)\n",
978	msp_family, msp_product,	978	msp_family, msp_product,
979	msp_revision, msp_hard, msp_rom,	979	msp_revision, msp_hard, msp_rom,
980	client->addr << 1, client->adapter->name);	980	client->addr << 1, client->adapter->name);
981	v4l_info(client, "%s ", client->name);	981	v4l_info(client, "%s ", client->name);
982	if (state->has_nicam && state->has_radio)	982	if (state->has_nicam && state->has_radio)
983	printk(KERN_CONT "supports nicam and radio, ");	983	printk(KERN_CONT "supports nicam and radio, ");
984	else if (state->has_nicam)	984	else if (state->has_nicam)
985	printk(KERN_CONT "supports nicam, ");	985	printk(KERN_CONT "supports nicam, ");
986	else if (state->has_radio)	986	else if (state->has_radio)
987	printk(KERN_CONT "supports radio, ");	987	printk(KERN_CONT "supports radio, ");
988	printk(KERN_CONT "mode is ");	988	printk(KERN_CONT "mode is ");
989		989
990	/* version-specific initialization */	990	/* version-specific initialization */
991	switch (state->opmode) {	991	switch (state->opmode) {
992	case OPMODE_MANUAL:	992	case OPMODE_MANUAL:
993	printk(KERN_CONT "manual");	993	printk(KERN_CONT "manual");
994	thread_func = msp3400c_thread;	994	thread_func = msp3400c_thread;
995	break;	995	break;
996	case OPMODE_AUTODETECT:	996	case OPMODE_AUTODETECT:
997	printk(KERN_CONT "autodetect");	997	printk(KERN_CONT "autodetect");
998	thread_func = msp3410d_thread;	998	thread_func = msp3410d_thread;
999	break;	999	break;
1000	case OPMODE_AUTOSELECT:	1000	case OPMODE_AUTOSELECT:
1001	printk(KERN_CONT "autodetect and autoselect");	1001	printk(KERN_CONT "autodetect and autoselect");
1002	thread_func = msp34xxg_thread;	1002	thread_func = msp34xxg_thread;
1003	break;	1003	break;
1004	}	1004	}
1005	printk(KERN_CONT "\n");	1005	printk(KERN_CONT "\n");
1006		1006
1007	/* startup control thread if needed */	1007	/* startup control thread if needed */
1008	if (thread_func) {	1008	if (thread_func) {
1009	state->kthread = kthread_run(thread_func, client, "msp34xx");	1009	state->kthread = kthread_run(thread_func, client, "msp34xx");
1010		1010
1011	if (IS_ERR(state->kthread))	1011	if (IS_ERR(state->kthread))
1012	v4l_warn(client, "kernel_thread() failed\n");	1012	v4l_warn(client, "kernel_thread() failed\n");
1013	msp_wake_thread(client);	1013	msp_wake_thread(client);
1014	}	1014	}
1015	return 0;	1015	return 0;
1016	}	1016	}
1017		1017
1018	static int msp_remove(struct i2c_client *client)	1018	static int msp_remove(struct i2c_client *client)
1019	{	1019	{
1020	struct msp_state *state = to_state(i2c_get_clientdata(client));	1020	struct msp_state *state = to_state(i2c_get_clientdata(client));
1021		1021
1022	v4l2_device_unregister_subdev(&state->sd);	1022	v4l2_device_unregister_subdev(&state->sd);
1023	/* shutdown control thread */	1023	/* shutdown control thread */
1024	if (state->kthread) {	1024	if (state->kthread) {
1025	state->restart = 1;	1025	state->restart = 1;
1026	kthread_stop(state->kthread);	1026	kthread_stop(state->kthread);
1027	}	1027	}
1028	msp_reset(client);	1028	msp_reset(client);
1029		1029
1030	kfree(state);	1030	kfree(state);
1031	return 0;	1031	return 0;
1032	}	1032	}
1033		1033
1034	/* ----------------------------------------------------------------------- */	1034	/* ----------------------------------------------------------------------- */
1035		1035
1036	static const struct i2c_device_id msp_id[] = {	1036	static const struct i2c_device_id msp_id[] = {
1037	{ "msp3400", 0 },	1037	{ "msp3400", 0 },
1038	{ }	1038	{ }
1039	};	1039	};
1040	MODULE_DEVICE_TABLE(i2c, msp_id);	1040	MODULE_DEVICE_TABLE(i2c, msp_id);
1041		1041
1042	static struct v4l2_i2c_driver_data v4l2_i2c_data = {	1042	static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1043	.name = "msp3400",	1043	.name = "msp3400",
1044	.driverid = I2C_DRIVERID_MSP3400,	1044	.driverid = I2C_DRIVERID_MSP3400,
1045	.command = msp_command,	1045	.command = msp_command,
1046	.probe = msp_probe,	1046	.probe = msp_probe,
1047	.remove = msp_remove,	1047	.remove = msp_remove,
1048	.suspend = msp_suspend,	1048	.suspend = msp_suspend,
1049	.resume = msp_resume,	1049	.resume = msp_resume,
1050	.id_table = msp_id,	1050	.id_table = msp_id,
1051	};	1051	};
1052		1052
1053	/*	1053	/*
1054	* Overrides for Emacs so that we follow Linus's tabbing style.	1054	* Overrides for Emacs so that we follow Linus's tabbing style.
1055	* ---------------------------------------------------------------------------	1055	* ---------------------------------------------------------------------------
1056	* Local variables:	1056	* Local variables:
1057	* c-basic-offset: 8	1057	* c-basic-offset: 8
1058	* End:	1058	* End:
1059	*/	1059	*/
1060		1060

drivers/media/video/ov7670.c

Diff comments View file @ 7e0a16f

1	/*	1	/*
2	* A V4L2 driver for OmniVision OV7670 cameras.	2	* A V4L2 driver for OmniVision OV7670 cameras.
3	*	3	*
4	* Copyright 2006 One Laptop Per Child Association, Inc. Written	4	* Copyright 2006 One Laptop Per Child Association, Inc. Written
5	* by Jonathan Corbet with substantial inspiration from Mark	5	* by Jonathan Corbet with substantial inspiration from Mark
6	* McClelland's ovcamchip code.	6	* McClelland's ovcamchip code.
7	*	7	*
8	* Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>	8	* Copyright 2006-7 Jonathan Corbet <corbet@lwn.net>
9	*	9	*
10	* This file may be distributed under the terms of the GNU General	10	* This file may be distributed under the terms of the GNU General
11	* Public License, version 2.	11	* Public License, version 2.
12	*/	12	*/
13	#include <linux/init.h>	13	#include <linux/init.h>
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/slab.h>	15	#include <linux/slab.h>
16	#include <linux/delay.h>	16	#include <linux/delay.h>
17	#include <linux/videodev.h>	17	#include <linux/videodev2.h>
18	#include <media/v4l2-common.h>	18	#include <media/v4l2-common.h>
19	#include <media/v4l2-chip-ident.h>	19	#include <media/v4l2-chip-ident.h>
20	#include <linux/i2c.h>	20	#include <linux/i2c.h>
21		21
22		22
23	MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");	23	MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
24	MODULE_DESCRIPTION("A low-level driver for OmniVision ov7670 sensors");	24	MODULE_DESCRIPTION("A low-level driver for OmniVision ov7670 sensors");
25	MODULE_LICENSE("GPL");	25	MODULE_LICENSE("GPL");
26		26
27	/*	27	/*
28	* Basic window sizes. These probably belong somewhere more globally	28	* Basic window sizes. These probably belong somewhere more globally
29	* useful.	29	* useful.
30	*/	30	*/
31	#define VGA_WIDTH 640	31	#define VGA_WIDTH 640
32	#define VGA_HEIGHT 480	32	#define VGA_HEIGHT 480
33	#define QVGA_WIDTH 320	33	#define QVGA_WIDTH 320
34	#define QVGA_HEIGHT 240	34	#define QVGA_HEIGHT 240
35	#define CIF_WIDTH 352	35	#define CIF_WIDTH 352
36	#define CIF_HEIGHT 288	36	#define CIF_HEIGHT 288
37	#define QCIF_WIDTH 176	37	#define QCIF_WIDTH 176
38	#define QCIF_HEIGHT 144	38	#define QCIF_HEIGHT 144
39		39
40	/*	40	/*
41	* Our nominal (default) frame rate.	41	* Our nominal (default) frame rate.
42	*/	42	*/
43	#define OV7670_FRAME_RATE 30	43	#define OV7670_FRAME_RATE 30
44		44
45	/*	45	/*
46	* The 7670 sits on i2c with ID 0x42	46	* The 7670 sits on i2c with ID 0x42
47	*/	47	*/
48	#define OV7670_I2C_ADDR 0x42	48	#define OV7670_I2C_ADDR 0x42
49		49
50	/* Registers */	50	/* Registers */
51	#define REG_GAIN 0x00 /* Gain lower 8 bits (rest in vref) */	51	#define REG_GAIN 0x00 /* Gain lower 8 bits (rest in vref) */
52	#define REG_BLUE 0x01 /* blue gain */	52	#define REG_BLUE 0x01 /* blue gain */
53	#define REG_RED 0x02 /* red gain */	53	#define REG_RED 0x02 /* red gain */
54	#define REG_VREF 0x03 /* Pieces of GAIN, VSTART, VSTOP */	54	#define REG_VREF 0x03 /* Pieces of GAIN, VSTART, VSTOP */
55	#define REG_COM1 0x04 /* Control 1 */	55	#define REG_COM1 0x04 /* Control 1 */
56	#define COM1_CCIR656 0x40 /* CCIR656 enable */	56	#define COM1_CCIR656 0x40 /* CCIR656 enable */
57	#define REG_BAVE 0x05 /* U/B Average level */	57	#define REG_BAVE 0x05 /* U/B Average level */
58	#define REG_GbAVE 0x06 /* Y/Gb Average level */	58	#define REG_GbAVE 0x06 /* Y/Gb Average level */
59	#define REG_AECHH 0x07 /* AEC MS 5 bits */	59	#define REG_AECHH 0x07 /* AEC MS 5 bits */
60	#define REG_RAVE 0x08 /* V/R Average level */	60	#define REG_RAVE 0x08 /* V/R Average level */
61	#define REG_COM2 0x09 /* Control 2 */	61	#define REG_COM2 0x09 /* Control 2 */
62	#define COM2_SSLEEP 0x10 /* Soft sleep mode */	62	#define COM2_SSLEEP 0x10 /* Soft sleep mode */
63	#define REG_PID 0x0a /* Product ID MSB */	63	#define REG_PID 0x0a /* Product ID MSB */
64	#define REG_VER 0x0b /* Product ID LSB */	64	#define REG_VER 0x0b /* Product ID LSB */
65	#define REG_COM3 0x0c /* Control 3 */	65	#define REG_COM3 0x0c /* Control 3 */
66	#define COM3_SWAP 0x40 /* Byte swap */	66	#define COM3_SWAP 0x40 /* Byte swap */
67	#define COM3_SCALEEN 0x08 /* Enable scaling */	67	#define COM3_SCALEEN 0x08 /* Enable scaling */
68	#define COM3_DCWEN 0x04 /* Enable downsamp/crop/window */	68	#define COM3_DCWEN 0x04 /* Enable downsamp/crop/window */
69	#define REG_COM4 0x0d /* Control 4 */	69	#define REG_COM4 0x0d /* Control 4 */
70	#define REG_COM5 0x0e /* All "reserved" */	70	#define REG_COM5 0x0e /* All "reserved" */
71	#define REG_COM6 0x0f /* Control 6 */	71	#define REG_COM6 0x0f /* Control 6 */
72	#define REG_AECH 0x10 /* More bits of AEC value */	72	#define REG_AECH 0x10 /* More bits of AEC value */
73	#define REG_CLKRC 0x11 /* Clocl control */	73	#define REG_CLKRC 0x11 /* Clocl control */
74	#define CLK_EXT 0x40 /* Use external clock directly */	74	#define CLK_EXT 0x40 /* Use external clock directly */
75	#define CLK_SCALE 0x3f /* Mask for internal clock scale */	75	#define CLK_SCALE 0x3f /* Mask for internal clock scale */
76	#define REG_COM7 0x12 /* Control 7 */	76	#define REG_COM7 0x12 /* Control 7 */
77	#define COM7_RESET 0x80 /* Register reset */	77	#define COM7_RESET 0x80 /* Register reset */
78	#define COM7_FMT_MASK 0x38	78	#define COM7_FMT_MASK 0x38
79	#define COM7_FMT_VGA 0x00	79	#define COM7_FMT_VGA 0x00
80	#define COM7_FMT_CIF 0x20 /* CIF format */	80	#define COM7_FMT_CIF 0x20 /* CIF format */
81	#define COM7_FMT_QVGA 0x10 /* QVGA format */	81	#define COM7_FMT_QVGA 0x10 /* QVGA format */
82	#define COM7_FMT_QCIF 0x08 /* QCIF format */	82	#define COM7_FMT_QCIF 0x08 /* QCIF format */
83	#define COM7_RGB 0x04 /* bits 0 and 2 - RGB format */	83	#define COM7_RGB 0x04 /* bits 0 and 2 - RGB format */
84	#define COM7_YUV 0x00 /* YUV */	84	#define COM7_YUV 0x00 /* YUV */
85	#define COM7_BAYER 0x01 /* Bayer format */	85	#define COM7_BAYER 0x01 /* Bayer format */
86	#define COM7_PBAYER 0x05 /* "Processed bayer" */	86	#define COM7_PBAYER 0x05 /* "Processed bayer" */
87	#define REG_COM8 0x13 /* Control 8 */	87	#define REG_COM8 0x13 /* Control 8 */
88	#define COM8_FASTAEC 0x80 /* Enable fast AGC/AEC */	88	#define COM8_FASTAEC 0x80 /* Enable fast AGC/AEC */
89	#define COM8_AECSTEP 0x40 /* Unlimited AEC step size */	89	#define COM8_AECSTEP 0x40 /* Unlimited AEC step size */
90	#define COM8_BFILT 0x20 /* Band filter enable */	90	#define COM8_BFILT 0x20 /* Band filter enable */
91	#define COM8_AGC 0x04 /* Auto gain enable */	91	#define COM8_AGC 0x04 /* Auto gain enable */
92	#define COM8_AWB 0x02 /* White balance enable */	92	#define COM8_AWB 0x02 /* White balance enable */
93	#define COM8_AEC 0x01 /* Auto exposure enable */	93	#define COM8_AEC 0x01 /* Auto exposure enable */
94	#define REG_COM9 0x14 /* Control 9 - gain ceiling */	94	#define REG_COM9 0x14 /* Control 9 - gain ceiling */
95	#define REG_COM10 0x15 /* Control 10 */	95	#define REG_COM10 0x15 /* Control 10 */
96	#define COM10_HSYNC 0x40 /* HSYNC instead of HREF */	96	#define COM10_HSYNC 0x40 /* HSYNC instead of HREF */
97	#define COM10_PCLK_HB 0x20 /* Suppress PCLK on horiz blank */	97	#define COM10_PCLK_HB 0x20 /* Suppress PCLK on horiz blank */
98	#define COM10_HREF_REV 0x08 /* Reverse HREF */	98	#define COM10_HREF_REV 0x08 /* Reverse HREF */
99	#define COM10_VS_LEAD 0x04 /* VSYNC on clock leading edge */	99	#define COM10_VS_LEAD 0x04 /* VSYNC on clock leading edge */
100	#define COM10_VS_NEG 0x02 /* VSYNC negative */	100	#define COM10_VS_NEG 0x02 /* VSYNC negative */
101	#define COM10_HS_NEG 0x01 /* HSYNC negative */	101	#define COM10_HS_NEG 0x01 /* HSYNC negative */
102	#define REG_HSTART 0x17 /* Horiz start high bits */	102	#define REG_HSTART 0x17 /* Horiz start high bits */
103	#define REG_HSTOP 0x18 /* Horiz stop high bits */	103	#define REG_HSTOP 0x18 /* Horiz stop high bits */
104	#define REG_VSTART 0x19 /* Vert start high bits */	104	#define REG_VSTART 0x19 /* Vert start high bits */
105	#define REG_VSTOP 0x1a /* Vert stop high bits */	105	#define REG_VSTOP 0x1a /* Vert stop high bits */
106	#define REG_PSHFT 0x1b /* Pixel delay after HREF */	106	#define REG_PSHFT 0x1b /* Pixel delay after HREF */
107	#define REG_MIDH 0x1c /* Manuf. ID high */	107	#define REG_MIDH 0x1c /* Manuf. ID high */
108	#define REG_MIDL 0x1d /* Manuf. ID low */	108	#define REG_MIDL 0x1d /* Manuf. ID low */
109	#define REG_MVFP 0x1e /* Mirror / vflip */	109	#define REG_MVFP 0x1e /* Mirror / vflip */
110	#define MVFP_MIRROR 0x20 /* Mirror image */	110	#define MVFP_MIRROR 0x20 /* Mirror image */
111	#define MVFP_FLIP 0x10 /* Vertical flip */	111	#define MVFP_FLIP 0x10 /* Vertical flip */
112		112
113	#define REG_AEW 0x24 /* AGC upper limit */	113	#define REG_AEW 0x24 /* AGC upper limit */
114	#define REG_AEB 0x25 /* AGC lower limit */	114	#define REG_AEB 0x25 /* AGC lower limit */
115	#define REG_VPT 0x26 /* AGC/AEC fast mode op region */	115	#define REG_VPT 0x26 /* AGC/AEC fast mode op region */
116	#define REG_HSYST 0x30 /* HSYNC rising edge delay */	116	#define REG_HSYST 0x30 /* HSYNC rising edge delay */
117	#define REG_HSYEN 0x31 /* HSYNC falling edge delay */	117	#define REG_HSYEN 0x31 /* HSYNC falling edge delay */
118	#define REG_HREF 0x32 /* HREF pieces */	118	#define REG_HREF 0x32 /* HREF pieces */
119	#define REG_TSLB 0x3a /* lots of stuff */	119	#define REG_TSLB 0x3a /* lots of stuff */
120	#define TSLB_YLAST 0x04 /* UYVY or VYUY - see com13 */	120	#define TSLB_YLAST 0x04 /* UYVY or VYUY - see com13 */
121	#define REG_COM11 0x3b /* Control 11 */	121	#define REG_COM11 0x3b /* Control 11 */
122	#define COM11_NIGHT 0x80 /* NIght mode enable */	122	#define COM11_NIGHT 0x80 /* NIght mode enable */
123	#define COM11_NMFR 0x60 /* Two bit NM frame rate */	123	#define COM11_NMFR 0x60 /* Two bit NM frame rate */
124	#define COM11_HZAUTO 0x10 /* Auto detect 50/60 Hz */	124	#define COM11_HZAUTO 0x10 /* Auto detect 50/60 Hz */
125	#define COM11_50HZ 0x08 /* Manual 50Hz select */	125	#define COM11_50HZ 0x08 /* Manual 50Hz select */
126	#define COM11_EXP 0x02	126	#define COM11_EXP 0x02
127	#define REG_COM12 0x3c /* Control 12 */	127	#define REG_COM12 0x3c /* Control 12 */
128	#define COM12_HREF 0x80 /* HREF always */	128	#define COM12_HREF 0x80 /* HREF always */
129	#define REG_COM13 0x3d /* Control 13 */	129	#define REG_COM13 0x3d /* Control 13 */
130	#define COM13_GAMMA 0x80 /* Gamma enable */	130	#define COM13_GAMMA 0x80 /* Gamma enable */
131	#define COM13_UVSAT 0x40 /* UV saturation auto adjustment */	131	#define COM13_UVSAT 0x40 /* UV saturation auto adjustment */
132	#define COM13_UVSWAP 0x01 /* V before U - w/TSLB */	132	#define COM13_UVSWAP 0x01 /* V before U - w/TSLB */
133	#define REG_COM14 0x3e /* Control 14 */	133	#define REG_COM14 0x3e /* Control 14 */
134	#define COM14_DCWEN 0x10 /* DCW/PCLK-scale enable */	134	#define COM14_DCWEN 0x10 /* DCW/PCLK-scale enable */
135	#define REG_EDGE 0x3f /* Edge enhancement factor */	135	#define REG_EDGE 0x3f /* Edge enhancement factor */
136	#define REG_COM15 0x40 /* Control 15 */	136	#define REG_COM15 0x40 /* Control 15 */
137	#define COM15_R10F0 0x00 /* Data range 10 to F0 */	137	#define COM15_R10F0 0x00 /* Data range 10 to F0 */
138	#define COM15_R01FE 0x80 /* 01 to FE */	138	#define COM15_R01FE 0x80 /* 01 to FE */
139	#define COM15_R00FF 0xc0 /* 00 to FF */	139	#define COM15_R00FF 0xc0 /* 00 to FF */
140	#define COM15_RGB565 0x10 /* RGB565 output */	140	#define COM15_RGB565 0x10 /* RGB565 output */
141	#define COM15_RGB555 0x30 /* RGB555 output */	141	#define COM15_RGB555 0x30 /* RGB555 output */
142	#define REG_COM16 0x41 /* Control 16 */	142	#define REG_COM16 0x41 /* Control 16 */
143	#define COM16_AWBGAIN 0x08 /* AWB gain enable */	143	#define COM16_AWBGAIN 0x08 /* AWB gain enable */
144	#define REG_COM17 0x42 /* Control 17 */	144	#define REG_COM17 0x42 /* Control 17 */
145	#define COM17_AECWIN 0xc0 /* AEC window - must match COM4 */	145	#define COM17_AECWIN 0xc0 /* AEC window - must match COM4 */
146	#define COM17_CBAR 0x08 /* DSP Color bar */	146	#define COM17_CBAR 0x08 /* DSP Color bar */
147		147
148	/*	148	/*
149	* This matrix defines how the colors are generated, must be	149	* This matrix defines how the colors are generated, must be
150	* tweaked to adjust hue and saturation.	150	* tweaked to adjust hue and saturation.
151	*	151	*
152	* Order: v-red, v-green, v-blue, u-red, u-green, u-blue	152	* Order: v-red, v-green, v-blue, u-red, u-green, u-blue
153	*	153	*
154	* They are nine-bit signed quantities, with the sign bit	154	* They are nine-bit signed quantities, with the sign bit
155	* stored in 0x58. Sign for v-red is bit 0, and up from there.	155	* stored in 0x58. Sign for v-red is bit 0, and up from there.
156	*/	156	*/
157	#define REG_CMATRIX_BASE 0x4f	157	#define REG_CMATRIX_BASE 0x4f
158	#define CMATRIX_LEN 6	158	#define CMATRIX_LEN 6
159	#define REG_CMATRIX_SIGN 0x58	159	#define REG_CMATRIX_SIGN 0x58
160		160
161		161
162	#define REG_BRIGHT 0x55 /* Brightness */	162	#define REG_BRIGHT 0x55 /* Brightness */
163	#define REG_CONTRAS 0x56 /* Contrast control */	163	#define REG_CONTRAS 0x56 /* Contrast control */
164		164
165	#define REG_GFIX 0x69 /* Fix gain control */	165	#define REG_GFIX 0x69 /* Fix gain control */
166		166
167	#define REG_REG76 0x76 /* OV's name */	167	#define REG_REG76 0x76 /* OV's name */
168	#define R76_BLKPCOR 0x80 /* Black pixel correction enable */	168	#define R76_BLKPCOR 0x80 /* Black pixel correction enable */
169	#define R76_WHTPCOR 0x40 /* White pixel correction enable */	169	#define R76_WHTPCOR 0x40 /* White pixel correction enable */
170		170
171	#define REG_RGB444 0x8c /* RGB 444 control */	171	#define REG_RGB444 0x8c /* RGB 444 control */
172	#define R444_ENABLE 0x02 /* Turn on RGB444, overrides 5x5 */	172	#define R444_ENABLE 0x02 /* Turn on RGB444, overrides 5x5 */
173	#define R444_RGBX 0x01 /* Empty nibble at end */	173	#define R444_RGBX 0x01 /* Empty nibble at end */
174		174
175	#define REG_HAECC1 0x9f /* Hist AEC/AGC control 1 */	175	#define REG_HAECC1 0x9f /* Hist AEC/AGC control 1 */
176	#define REG_HAECC2 0xa0 /* Hist AEC/AGC control 2 */	176	#define REG_HAECC2 0xa0 /* Hist AEC/AGC control 2 */
177		177
178	#define REG_BD50MAX 0xa5 /* 50hz banding step limit */	178	#define REG_BD50MAX 0xa5 /* 50hz banding step limit */
179	#define REG_HAECC3 0xa6 /* Hist AEC/AGC control 3 */	179	#define REG_HAECC3 0xa6 /* Hist AEC/AGC control 3 */
180	#define REG_HAECC4 0xa7 /* Hist AEC/AGC control 4 */	180	#define REG_HAECC4 0xa7 /* Hist AEC/AGC control 4 */
181	#define REG_HAECC5 0xa8 /* Hist AEC/AGC control 5 */	181	#define REG_HAECC5 0xa8 /* Hist AEC/AGC control 5 */
182	#define REG_HAECC6 0xa9 /* Hist AEC/AGC control 6 */	182	#define REG_HAECC6 0xa9 /* Hist AEC/AGC control 6 */
183	#define REG_HAECC7 0xaa /* Hist AEC/AGC control 7 */	183	#define REG_HAECC7 0xaa /* Hist AEC/AGC control 7 */
184	#define REG_BD60MAX 0xab /* 60hz banding step limit */	184	#define REG_BD60MAX 0xab /* 60hz banding step limit */
185		185
186		186
187	/*	187	/*
188	* Information we maintain about a known sensor.	188	* Information we maintain about a known sensor.
189	*/	189	*/
190	struct ov7670_format_struct; /* coming later */	190	struct ov7670_format_struct; /* coming later */
191	struct ov7670_info {	191	struct ov7670_info {
192	struct ov7670_format_struct fmt; / Current format */	192	struct ov7670_format_struct fmt; / Current format */
193	unsigned char sat; /* Saturation value */	193	unsigned char sat; /* Saturation value */
194	int hue; /* Hue value */	194	int hue; /* Hue value */
195	};	195	};
196		196
197		197
198		198
199		199
200	/*	200	/*
201	* The default register settings, as obtained from OmniVision. There	201	* The default register settings, as obtained from OmniVision. There
202	* is really no making sense of most of these - lots of "reserved" values	202	* is really no making sense of most of these - lots of "reserved" values
203	* and such.	203	* and such.
204	*	204	*
205	* These settings give VGA YUYV.	205	* These settings give VGA YUYV.
206	*/	206	*/
207		207
208	struct regval_list {	208	struct regval_list {
209	unsigned char reg_num;	209	unsigned char reg_num;
210	unsigned char value;	210	unsigned char value;
211	};	211	};
212		212
213	static struct regval_list ov7670_default_regs[] = {	213	static struct regval_list ov7670_default_regs[] = {
214	{ REG_COM7, COM7_RESET },	214	{ REG_COM7, COM7_RESET },
215	/*	215	/*
216	* Clock scale: 3 = 15fps	216	* Clock scale: 3 = 15fps
217	* 2 = 20fps	217	* 2 = 20fps
218	* 1 = 30fps	218	* 1 = 30fps
219	*/	219	*/
220	{ REG_CLKRC, 0x1 }, /* OV: clock scale (30 fps) */	220	{ REG_CLKRC, 0x1 }, /* OV: clock scale (30 fps) */
221	{ REG_TSLB, 0x04 }, /* OV */	221	{ REG_TSLB, 0x04 }, /* OV */
222	{ REG_COM7, 0 }, /* VGA */	222	{ REG_COM7, 0 }, /* VGA */
223	/*	223	/*
224	* Set the hardware window. These values from OV don't entirely	224	* Set the hardware window. These values from OV don't entirely
225	* make sense - hstop is less than hstart. But they work...	225	* make sense - hstop is less than hstart. But they work...
226	*/	226	*/
227	{ REG_HSTART, 0x13 }, { REG_HSTOP, 0x01 },	227	{ REG_HSTART, 0x13 }, { REG_HSTOP, 0x01 },
228	{ REG_HREF, 0xb6 }, { REG_VSTART, 0x02 },	228	{ REG_HREF, 0xb6 }, { REG_VSTART, 0x02 },
229	{ REG_VSTOP, 0x7a }, { REG_VREF, 0x0a },	229	{ REG_VSTOP, 0x7a }, { REG_VREF, 0x0a },
230		230
231	{ REG_COM3, 0 }, { REG_COM14, 0 },	231	{ REG_COM3, 0 }, { REG_COM14, 0 },
232	/* Mystery scaling numbers */	232	/* Mystery scaling numbers */
233	{ 0x70, 0x3a }, { 0x71, 0x35 },	233	{ 0x70, 0x3a }, { 0x71, 0x35 },
234	{ 0x72, 0x11 }, { 0x73, 0xf0 },	234	{ 0x72, 0x11 }, { 0x73, 0xf0 },
235	{ 0xa2, 0x02 }, { REG_COM10, 0x0 },	235	{ 0xa2, 0x02 }, { REG_COM10, 0x0 },
236		236
237	/* Gamma curve values */	237	/* Gamma curve values */
238	{ 0x7a, 0x20 }, { 0x7b, 0x10 },	238	{ 0x7a, 0x20 }, { 0x7b, 0x10 },
239	{ 0x7c, 0x1e }, { 0x7d, 0x35 },	239	{ 0x7c, 0x1e }, { 0x7d, 0x35 },
240	{ 0x7e, 0x5a }, { 0x7f, 0x69 },	240	{ 0x7e, 0x5a }, { 0x7f, 0x69 },
241	{ 0x80, 0x76 }, { 0x81, 0x80 },	241	{ 0x80, 0x76 }, { 0x81, 0x80 },
242	{ 0x82, 0x88 }, { 0x83, 0x8f },	242	{ 0x82, 0x88 }, { 0x83, 0x8f },
243	{ 0x84, 0x96 }, { 0x85, 0xa3 },	243	{ 0x84, 0x96 }, { 0x85, 0xa3 },
244	{ 0x86, 0xaf }, { 0x87, 0xc4 },	244	{ 0x86, 0xaf }, { 0x87, 0xc4 },
245	{ 0x88, 0xd7 }, { 0x89, 0xe8 },	245	{ 0x88, 0xd7 }, { 0x89, 0xe8 },
246		246
247	/* AGC and AEC parameters. Note we start by disabling those features,	247	/* AGC and AEC parameters. Note we start by disabling those features,
248	then turn them only after tweaking the values. */	248	then turn them only after tweaking the values. */
249	{ REG_COM8, COM8_FASTAEC \| COM8_AECSTEP \| COM8_BFILT },	249	{ REG_COM8, COM8_FASTAEC \| COM8_AECSTEP \| COM8_BFILT },
250	{ REG_GAIN, 0 }, { REG_AECH, 0 },	250	{ REG_GAIN, 0 }, { REG_AECH, 0 },
251	{ REG_COM4, 0x40 }, /* magic reserved bit */	251	{ REG_COM4, 0x40 }, /* magic reserved bit */
252	{ REG_COM9, 0x18 }, /* 4x gain + magic rsvd bit */	252	{ REG_COM9, 0x18 }, /* 4x gain + magic rsvd bit */
253	{ REG_BD50MAX, 0x05 }, { REG_BD60MAX, 0x07 },	253	{ REG_BD50MAX, 0x05 }, { REG_BD60MAX, 0x07 },
254	{ REG_AEW, 0x95 }, { REG_AEB, 0x33 },	254	{ REG_AEW, 0x95 }, { REG_AEB, 0x33 },
255	{ REG_VPT, 0xe3 }, { REG_HAECC1, 0x78 },	255	{ REG_VPT, 0xe3 }, { REG_HAECC1, 0x78 },
256	{ REG_HAECC2, 0x68 }, { 0xa1, 0x03 }, /* magic */	256	{ REG_HAECC2, 0x68 }, { 0xa1, 0x03 }, /* magic */
257	{ REG_HAECC3, 0xd8 }, { REG_HAECC4, 0xd8 },	257	{ REG_HAECC3, 0xd8 }, { REG_HAECC4, 0xd8 },
258	{ REG_HAECC5, 0xf0 }, { REG_HAECC6, 0x90 },	258	{ REG_HAECC5, 0xf0 }, { REG_HAECC6, 0x90 },
259	{ REG_HAECC7, 0x94 },	259	{ REG_HAECC7, 0x94 },
260	{ REG_COM8, COM8_FASTAEC\|COM8_AECSTEP\|COM8_BFILT\|COM8_AGC\|COM8_AEC },	260	{ REG_COM8, COM8_FASTAEC\|COM8_AECSTEP\|COM8_BFILT\|COM8_AGC\|COM8_AEC },
261		261
262	/* Almost all of these are magic "reserved" values. */	262	/* Almost all of these are magic "reserved" values. */
263	{ REG_COM5, 0x61 }, { REG_COM6, 0x4b },	263	{ REG_COM5, 0x61 }, { REG_COM6, 0x4b },
264	{ 0x16, 0x02 }, { REG_MVFP, 0x07 },	264	{ 0x16, 0x02 }, { REG_MVFP, 0x07 },
265	{ 0x21, 0x02 }, { 0x22, 0x91 },	265	{ 0x21, 0x02 }, { 0x22, 0x91 },
266	{ 0x29, 0x07 }, { 0x33, 0x0b },	266	{ 0x29, 0x07 }, { 0x33, 0x0b },
267	{ 0x35, 0x0b }, { 0x37, 0x1d },	267	{ 0x35, 0x0b }, { 0x37, 0x1d },
268	{ 0x38, 0x71 }, { 0x39, 0x2a },	268	{ 0x38, 0x71 }, { 0x39, 0x2a },
269	{ REG_COM12, 0x78 }, { 0x4d, 0x40 },	269	{ REG_COM12, 0x78 }, { 0x4d, 0x40 },
270	{ 0x4e, 0x20 }, { REG_GFIX, 0 },	270	{ 0x4e, 0x20 }, { REG_GFIX, 0 },
271	{ 0x6b, 0x4a }, { 0x74, 0x10 },	271	{ 0x6b, 0x4a }, { 0x74, 0x10 },
272	{ 0x8d, 0x4f }, { 0x8e, 0 },	272	{ 0x8d, 0x4f }, { 0x8e, 0 },
273	{ 0x8f, 0 }, { 0x90, 0 },	273	{ 0x8f, 0 }, { 0x90, 0 },
274	{ 0x91, 0 }, { 0x96, 0 },	274	{ 0x91, 0 }, { 0x96, 0 },
275	{ 0x9a, 0 }, { 0xb0, 0x84 },	275	{ 0x9a, 0 }, { 0xb0, 0x84 },
276	{ 0xb1, 0x0c }, { 0xb2, 0x0e },	276	{ 0xb1, 0x0c }, { 0xb2, 0x0e },
277	{ 0xb3, 0x82 }, { 0xb8, 0x0a },	277	{ 0xb3, 0x82 }, { 0xb8, 0x0a },
278		278
279	/* More reserved magic, some of which tweaks white balance */	279	/* More reserved magic, some of which tweaks white balance */
280	{ 0x43, 0x0a }, { 0x44, 0xf0 },	280	{ 0x43, 0x0a }, { 0x44, 0xf0 },
281	{ 0x45, 0x34 }, { 0x46, 0x58 },	281	{ 0x45, 0x34 }, { 0x46, 0x58 },
282	{ 0x47, 0x28 }, { 0x48, 0x3a },	282	{ 0x47, 0x28 }, { 0x48, 0x3a },
283	{ 0x59, 0x88 }, { 0x5a, 0x88 },	283	{ 0x59, 0x88 }, { 0x5a, 0x88 },
284	{ 0x5b, 0x44 }, { 0x5c, 0x67 },	284	{ 0x5b, 0x44 }, { 0x5c, 0x67 },
285	{ 0x5d, 0x49 }, { 0x5e, 0x0e },	285	{ 0x5d, 0x49 }, { 0x5e, 0x0e },
286	{ 0x6c, 0x0a }, { 0x6d, 0x55 },	286	{ 0x6c, 0x0a }, { 0x6d, 0x55 },
287	{ 0x6e, 0x11 }, { 0x6f, 0x9f }, /* "9e for advance AWB" */	287	{ 0x6e, 0x11 }, { 0x6f, 0x9f }, /* "9e for advance AWB" */
288	{ 0x6a, 0x40 }, { REG_BLUE, 0x40 },	288	{ 0x6a, 0x40 }, { REG_BLUE, 0x40 },
289	{ REG_RED, 0x60 },	289	{ REG_RED, 0x60 },
290	{ REG_COM8, COM8_FASTAEC\|COM8_AECSTEP\|COM8_BFILT\|COM8_AGC\|COM8_AEC\|COM8_AWB },	290	{ REG_COM8, COM8_FASTAEC\|COM8_AECSTEP\|COM8_BFILT\|COM8_AGC\|COM8_AEC\|COM8_AWB },
291		291
292	/* Matrix coefficients */	292	/* Matrix coefficients */
293	{ 0x4f, 0x80 }, { 0x50, 0x80 },	293	{ 0x4f, 0x80 }, { 0x50, 0x80 },
294	{ 0x51, 0 }, { 0x52, 0x22 },	294	{ 0x51, 0 }, { 0x52, 0x22 },
295	{ 0x53, 0x5e }, { 0x54, 0x80 },	295	{ 0x53, 0x5e }, { 0x54, 0x80 },
296	{ 0x58, 0x9e },	296	{ 0x58, 0x9e },
297		297
298	{ REG_COM16, COM16_AWBGAIN }, { REG_EDGE, 0 },	298	{ REG_COM16, COM16_AWBGAIN }, { REG_EDGE, 0 },
299	{ 0x75, 0x05 }, { 0x76, 0xe1 },	299	{ 0x75, 0x05 }, { 0x76, 0xe1 },
300	{ 0x4c, 0 }, { 0x77, 0x01 },	300	{ 0x4c, 0 }, { 0x77, 0x01 },
301	{ REG_COM13, 0xc3 }, { 0x4b, 0x09 },	301	{ REG_COM13, 0xc3 }, { 0x4b, 0x09 },
302	{ 0xc9, 0x60 }, { REG_COM16, 0x38 },	302	{ 0xc9, 0x60 }, { REG_COM16, 0x38 },
303	{ 0x56, 0x40 },	303	{ 0x56, 0x40 },
304		304
305	{ 0x34, 0x11 }, { REG_COM11, COM11_EXP\|COM11_HZAUTO },	305	{ 0x34, 0x11 }, { REG_COM11, COM11_EXP\|COM11_HZAUTO },
306	{ 0xa4, 0x88 }, { 0x96, 0 },	306	{ 0xa4, 0x88 }, { 0x96, 0 },
307	{ 0x97, 0x30 }, { 0x98, 0x20 },	307	{ 0x97, 0x30 }, { 0x98, 0x20 },
308	{ 0x99, 0x30 }, { 0x9a, 0x84 },	308	{ 0x99, 0x30 }, { 0x9a, 0x84 },
309	{ 0x9b, 0x29 }, { 0x9c, 0x03 },	309	{ 0x9b, 0x29 }, { 0x9c, 0x03 },
310	{ 0x9d, 0x4c }, { 0x9e, 0x3f },	310	{ 0x9d, 0x4c }, { 0x9e, 0x3f },
311	{ 0x78, 0x04 },	311	{ 0x78, 0x04 },
312		312
313	/* Extra-weird stuff. Some sort of multiplexor register */	313	/* Extra-weird stuff. Some sort of multiplexor register */
314	{ 0x79, 0x01 }, { 0xc8, 0xf0 },	314	{ 0x79, 0x01 }, { 0xc8, 0xf0 },
315	{ 0x79, 0x0f }, { 0xc8, 0x00 },	315	{ 0x79, 0x0f }, { 0xc8, 0x00 },
316	{ 0x79, 0x10 }, { 0xc8, 0x7e },	316	{ 0x79, 0x10 }, { 0xc8, 0x7e },
317	{ 0x79, 0x0a }, { 0xc8, 0x80 },	317	{ 0x79, 0x0a }, { 0xc8, 0x80 },
318	{ 0x79, 0x0b }, { 0xc8, 0x01 },	318	{ 0x79, 0x0b }, { 0xc8, 0x01 },
319	{ 0x79, 0x0c }, { 0xc8, 0x0f },	319	{ 0x79, 0x0c }, { 0xc8, 0x0f },
320	{ 0x79, 0x0d }, { 0xc8, 0x20 },	320	{ 0x79, 0x0d }, { 0xc8, 0x20 },
321	{ 0x79, 0x09 }, { 0xc8, 0x80 },	321	{ 0x79, 0x09 }, { 0xc8, 0x80 },
322	{ 0x79, 0x02 }, { 0xc8, 0xc0 },	322	{ 0x79, 0x02 }, { 0xc8, 0xc0 },
323	{ 0x79, 0x03 }, { 0xc8, 0x40 },	323	{ 0x79, 0x03 }, { 0xc8, 0x40 },
324	{ 0x79, 0x05 }, { 0xc8, 0x30 },	324	{ 0x79, 0x05 }, { 0xc8, 0x30 },
325	{ 0x79, 0x26 },	325	{ 0x79, 0x26 },
326		326
327	{ 0xff, 0xff }, /* END MARKER */	327	{ 0xff, 0xff }, /* END MARKER */
328	};	328	};
329		329
330		330
331	/*	331	/*
332	* Here we'll try to encapsulate the changes for just the output	332	* Here we'll try to encapsulate the changes for just the output
333	* video format.	333	* video format.
334	*	334	*
335	* RGB656 and YUV422 come from OV; RGB444 is homebrewed.	335	* RGB656 and YUV422 come from OV; RGB444 is homebrewed.
336	*	336	*
337	* IMPORTANT RULE: the first entry must be for COM7, see ov7670_s_fmt for why.	337	* IMPORTANT RULE: the first entry must be for COM7, see ov7670_s_fmt for why.
338	*/	338	*/
339		339
340		340
341	static struct regval_list ov7670_fmt_yuv422[] = {	341	static struct regval_list ov7670_fmt_yuv422[] = {
342	{ REG_COM7, 0x0 }, /* Selects YUV mode */	342	{ REG_COM7, 0x0 }, /* Selects YUV mode */
343	{ REG_RGB444, 0 }, /* No RGB444 please */	343	{ REG_RGB444, 0 }, /* No RGB444 please */
344	{ REG_COM1, 0 },	344	{ REG_COM1, 0 },
345	{ REG_COM15, COM15_R00FF },	345	{ REG_COM15, COM15_R00FF },
346	{ REG_COM9, 0x18 }, /* 4x gain ceiling; 0x8 is reserved bit */	346	{ REG_COM9, 0x18 }, /* 4x gain ceiling; 0x8 is reserved bit */
347	{ 0x4f, 0x80 }, /* "matrix coefficient 1" */	347	{ 0x4f, 0x80 }, /* "matrix coefficient 1" */
348	{ 0x50, 0x80 }, /* "matrix coefficient 2" */	348	{ 0x50, 0x80 }, /* "matrix coefficient 2" */
349	{ 0x51, 0 }, /* vb */	349	{ 0x51, 0 }, /* vb */
350	{ 0x52, 0x22 }, /* "matrix coefficient 4" */	350	{ 0x52, 0x22 }, /* "matrix coefficient 4" */
351	{ 0x53, 0x5e }, /* "matrix coefficient 5" */	351	{ 0x53, 0x5e }, /* "matrix coefficient 5" */
352	{ 0x54, 0x80 }, /* "matrix coefficient 6" */	352	{ 0x54, 0x80 }, /* "matrix coefficient 6" */
353	{ REG_COM13, COM13_GAMMA\|COM13_UVSAT },	353	{ REG_COM13, COM13_GAMMA\|COM13_UVSAT },
354	{ 0xff, 0xff },	354	{ 0xff, 0xff },
355	};	355	};
356		356
357	static struct regval_list ov7670_fmt_rgb565[] = {	357	static struct regval_list ov7670_fmt_rgb565[] = {
358	{ REG_COM7, COM7_RGB }, /* Selects RGB mode */	358	{ REG_COM7, COM7_RGB }, /* Selects RGB mode */
359	{ REG_RGB444, 0 }, /* No RGB444 please */	359	{ REG_RGB444, 0 }, /* No RGB444 please */
360	{ REG_COM1, 0x0 },	360	{ REG_COM1, 0x0 },
361	{ REG_COM15, COM15_RGB565 },	361	{ REG_COM15, COM15_RGB565 },
362	{ REG_COM9, 0x38 }, /* 16x gain ceiling; 0x8 is reserved bit */	362	{ REG_COM9, 0x38 }, /* 16x gain ceiling; 0x8 is reserved bit */
363	{ 0x4f, 0xb3 }, /* "matrix coefficient 1" */	363	{ 0x4f, 0xb3 }, /* "matrix coefficient 1" */
364	{ 0x50, 0xb3 }, /* "matrix coefficient 2" */	364	{ 0x50, 0xb3 }, /* "matrix coefficient 2" */
365	{ 0x51, 0 }, /* vb */	365	{ 0x51, 0 }, /* vb */
366	{ 0x52, 0x3d }, /* "matrix coefficient 4" */	366	{ 0x52, 0x3d }, /* "matrix coefficient 4" */
367	{ 0x53, 0xa7 }, /* "matrix coefficient 5" */	367	{ 0x53, 0xa7 }, /* "matrix coefficient 5" */
368	{ 0x54, 0xe4 }, /* "matrix coefficient 6" */	368	{ 0x54, 0xe4 }, /* "matrix coefficient 6" */
369	{ REG_COM13, COM13_GAMMA\|COM13_UVSAT },	369	{ REG_COM13, COM13_GAMMA\|COM13_UVSAT },
370	{ 0xff, 0xff },	370	{ 0xff, 0xff },
371	};	371	};
372		372
373	static struct regval_list ov7670_fmt_rgb444[] = {	373	static struct regval_list ov7670_fmt_rgb444[] = {
374	{ REG_COM7, COM7_RGB }, /* Selects RGB mode */	374	{ REG_COM7, COM7_RGB }, /* Selects RGB mode */
375	{ REG_RGB444, R444_ENABLE }, /* Enable xxxxrrrr ggggbbbb */	375	{ REG_RGB444, R444_ENABLE }, /* Enable xxxxrrrr ggggbbbb */
376	{ REG_COM1, 0x40 }, /* Magic reserved bit */	376	{ REG_COM1, 0x40 }, /* Magic reserved bit */
377	{ REG_COM15, COM15_R01FE\|COM15_RGB565 }, /* Data range needed? */	377	{ REG_COM15, COM15_R01FE\|COM15_RGB565 }, /* Data range needed? */
378	{ REG_COM9, 0x38 }, /* 16x gain ceiling; 0x8 is reserved bit */	378	{ REG_COM9, 0x38 }, /* 16x gain ceiling; 0x8 is reserved bit */
379	{ 0x4f, 0xb3 }, /* "matrix coefficient 1" */	379	{ 0x4f, 0xb3 }, /* "matrix coefficient 1" */
380	{ 0x50, 0xb3 }, /* "matrix coefficient 2" */	380	{ 0x50, 0xb3 }, /* "matrix coefficient 2" */
381	{ 0x51, 0 }, /* vb */	381	{ 0x51, 0 }, /* vb */
382	{ 0x52, 0x3d }, /* "matrix coefficient 4" */	382	{ 0x52, 0x3d }, /* "matrix coefficient 4" */
383	{ 0x53, 0xa7 }, /* "matrix coefficient 5" */	383	{ 0x53, 0xa7 }, /* "matrix coefficient 5" */
384	{ 0x54, 0xe4 }, /* "matrix coefficient 6" */	384	{ 0x54, 0xe4 }, /* "matrix coefficient 6" */
385	{ REG_COM13, COM13_GAMMA\|COM13_UVSAT\|0x2 }, /* Magic rsvd bit */	385	{ REG_COM13, COM13_GAMMA\|COM13_UVSAT\|0x2 }, /* Magic rsvd bit */
386	{ 0xff, 0xff },	386	{ 0xff, 0xff },
387	};	387	};
388		388
389	static struct regval_list ov7670_fmt_raw[] = {	389	static struct regval_list ov7670_fmt_raw[] = {
390	{ REG_COM7, COM7_BAYER },	390	{ REG_COM7, COM7_BAYER },
391	{ REG_COM13, 0x08 }, /* No gamma, magic rsvd bit */	391	{ REG_COM13, 0x08 }, /* No gamma, magic rsvd bit */
392	{ REG_COM16, 0x3d }, /* Edge enhancement, denoise */	392	{ REG_COM16, 0x3d }, /* Edge enhancement, denoise */
393	{ REG_REG76, 0xe1 }, /* Pix correction, magic rsvd */	393	{ REG_REG76, 0xe1 }, /* Pix correction, magic rsvd */
394	{ 0xff, 0xff },	394	{ 0xff, 0xff },
395	};	395	};
396		396
397		397
398		398
399	/*	399	/*
400	* Low-level register I/O.	400	* Low-level register I/O.
401	*/	401	*/
402		402
403	static int ov7670_read(struct i2c_client *c, unsigned char reg,	403	static int ov7670_read(struct i2c_client *c, unsigned char reg,
404	unsigned char *value)	404	unsigned char *value)
405	{	405	{
406	int ret;	406	int ret;
407		407
408	ret = i2c_smbus_read_byte_data(c, reg);	408	ret = i2c_smbus_read_byte_data(c, reg);
409	if (ret >= 0) {	409	if (ret >= 0) {
410	*value = (unsigned char) ret;	410	*value = (unsigned char) ret;
411	ret = 0;	411	ret = 0;
412	}	412	}
413	return ret;	413	return ret;
414	}	414	}
415		415
416		416
417	static int ov7670_write(struct i2c_client *c, unsigned char reg,	417	static int ov7670_write(struct i2c_client *c, unsigned char reg,
418	unsigned char value)	418	unsigned char value)
419	{	419	{
420	int ret = i2c_smbus_write_byte_data(c, reg, value);	420	int ret = i2c_smbus_write_byte_data(c, reg, value);
421	if (reg == REG_COM7 && (value & COM7_RESET))	421	if (reg == REG_COM7 && (value & COM7_RESET))
422	msleep(2); /* Wait for reset to run */	422	msleep(2); /* Wait for reset to run */
423	return ret;	423	return ret;
424	}	424	}
425		425
426		426
427	/*	427	/*
428	* Write a list of register settings; ff/ff stops the process.	428	* Write a list of register settings; ff/ff stops the process.
429	*/	429	*/
430	static int ov7670_write_array(struct i2c_client c, struct regval_list vals)	430	static int ov7670_write_array(struct i2c_client c, struct regval_list vals)
431	{	431	{
432	while (vals->reg_num != 0xff \|\| vals->value != 0xff) {	432	while (vals->reg_num != 0xff \|\| vals->value != 0xff) {
433	int ret = ov7670_write(c, vals->reg_num, vals->value);	433	int ret = ov7670_write(c, vals->reg_num, vals->value);
434	if (ret < 0)	434	if (ret < 0)
435	return ret;	435	return ret;
436	vals++;	436	vals++;
437	}	437	}
438	return 0;	438	return 0;
439	}	439	}
440		440
441		441
442	/*	442	/*
443	* Stuff that knows about the sensor.	443	* Stuff that knows about the sensor.
444	*/	444	*/
445	static void ov7670_reset(struct i2c_client *client)	445	static void ov7670_reset(struct i2c_client *client)
446	{	446	{
447	ov7670_write(client, REG_COM7, COM7_RESET);	447	ov7670_write(client, REG_COM7, COM7_RESET);
448	msleep(1);	448	msleep(1);
449	}	449	}
450		450
451		451
452	static int ov7670_init(struct i2c_client *client)	452	static int ov7670_init(struct i2c_client *client)
453	{	453	{
454	return ov7670_write_array(client, ov7670_default_regs);	454	return ov7670_write_array(client, ov7670_default_regs);
455	}	455	}
456		456
457		457
458		458
459	static int ov7670_detect(struct i2c_client *client)	459	static int ov7670_detect(struct i2c_client *client)
460	{	460	{
461	unsigned char v;	461	unsigned char v;
462	int ret;	462	int ret;
463		463
464	ret = ov7670_init(client);	464	ret = ov7670_init(client);
465	if (ret < 0)	465	if (ret < 0)
466	return ret;	466	return ret;
467	ret = ov7670_read(client, REG_MIDH, &v);	467	ret = ov7670_read(client, REG_MIDH, &v);
468	if (ret < 0)	468	if (ret < 0)
469	return ret;	469	return ret;
470	if (v != 0x7f) /* OV manuf. id. */	470	if (v != 0x7f) /* OV manuf. id. */
471	return -ENODEV;	471	return -ENODEV;
472	ret = ov7670_read(client, REG_MIDL, &v);	472	ret = ov7670_read(client, REG_MIDL, &v);
473	if (ret < 0)	473	if (ret < 0)
474	return ret;	474	return ret;
475	if (v != 0xa2)	475	if (v != 0xa2)
476	return -ENODEV;	476	return -ENODEV;
477	/*	477	/*
478	* OK, we know we have an OmniVision chip...but which one?	478	* OK, we know we have an OmniVision chip...but which one?
479	*/	479	*/
480	ret = ov7670_read(client, REG_PID, &v);	480	ret = ov7670_read(client, REG_PID, &v);
481	if (ret < 0)	481	if (ret < 0)
482	return ret;	482	return ret;
483	if (v != 0x76) /* PID + VER = 0x76 / 0x73 */	483	if (v != 0x76) /* PID + VER = 0x76 / 0x73 */
484	return -ENODEV;	484	return -ENODEV;
485	ret = ov7670_read(client, REG_VER, &v);	485	ret = ov7670_read(client, REG_VER, &v);
486	if (ret < 0)	486	if (ret < 0)
487	return ret;	487	return ret;
488	if (v != 0x73) /* PID + VER = 0x76 / 0x73 */	488	if (v != 0x73) /* PID + VER = 0x76 / 0x73 */
489	return -ENODEV;	489	return -ENODEV;
490	return 0;	490	return 0;
491	}	491	}
492		492
493		493
494	/*	494	/*
495	* Store information about the video data format. The color matrix	495	* Store information about the video data format. The color matrix
496	* is deeply tied into the format, so keep the relevant values here.	496	* is deeply tied into the format, so keep the relevant values here.
497	* The magic matrix nubmers come from OmniVision.	497	* The magic matrix nubmers come from OmniVision.
498	*/	498	*/
499	static struct ov7670_format_struct {	499	static struct ov7670_format_struct {
500	__u8 *desc;	500	__u8 *desc;
501	__u32 pixelformat;	501	__u32 pixelformat;
502	struct regval_list *regs;	502	struct regval_list *regs;
503	int cmatrix[CMATRIX_LEN];	503	int cmatrix[CMATRIX_LEN];
504	int bpp; /* Bytes per pixel */	504	int bpp; /* Bytes per pixel */
505	} ov7670_formats[] = {	505	} ov7670_formats[] = {
506	{	506	{
507	.desc = "YUYV 4:2:2",	507	.desc = "YUYV 4:2:2",
508	.pixelformat = V4L2_PIX_FMT_YUYV,	508	.pixelformat = V4L2_PIX_FMT_YUYV,
509	.regs = ov7670_fmt_yuv422,	509	.regs = ov7670_fmt_yuv422,
510	.cmatrix = { 128, -128, 0, -34, -94, 128 },	510	.cmatrix = { 128, -128, 0, -34, -94, 128 },
511	.bpp = 2,	511	.bpp = 2,
512	},	512	},
513	{	513	{
514	.desc = "RGB 444",	514	.desc = "RGB 444",
515	.pixelformat = V4L2_PIX_FMT_RGB444,	515	.pixelformat = V4L2_PIX_FMT_RGB444,
516	.regs = ov7670_fmt_rgb444,	516	.regs = ov7670_fmt_rgb444,
517	.cmatrix = { 179, -179, 0, -61, -176, 228 },	517	.cmatrix = { 179, -179, 0, -61, -176, 228 },
518	.bpp = 2,	518	.bpp = 2,
519	},	519	},
520	{	520	{
521	.desc = "RGB 565",	521	.desc = "RGB 565",
522	.pixelformat = V4L2_PIX_FMT_RGB565,	522	.pixelformat = V4L2_PIX_FMT_RGB565,
523	.regs = ov7670_fmt_rgb565,	523	.regs = ov7670_fmt_rgb565,
524	.cmatrix = { 179, -179, 0, -61, -176, 228 },	524	.cmatrix = { 179, -179, 0, -61, -176, 228 },
525	.bpp = 2,	525	.bpp = 2,
526	},	526	},
527	{	527	{
528	.desc = "Raw RGB Bayer",	528	.desc = "Raw RGB Bayer",
529	.pixelformat = V4L2_PIX_FMT_SBGGR8,	529	.pixelformat = V4L2_PIX_FMT_SBGGR8,
530	.regs = ov7670_fmt_raw,	530	.regs = ov7670_fmt_raw,
531	.cmatrix = { 0, 0, 0, 0, 0, 0 },	531	.cmatrix = { 0, 0, 0, 0, 0, 0 },
532	.bpp = 1	532	.bpp = 1
533	},	533	},
534	};	534	};
535	#define N_OV7670_FMTS ARRAY_SIZE(ov7670_formats)	535	#define N_OV7670_FMTS ARRAY_SIZE(ov7670_formats)
536		536
537		537
538	/*	538	/*
539	* Then there is the issue of window sizes. Try to capture the info here.	539	* Then there is the issue of window sizes. Try to capture the info here.
540	*/	540	*/
541		541
542	/*	542	/*
543	* QCIF mode is done (by OV) in a very strange way - it actually looks like	543	* QCIF mode is done (by OV) in a very strange way - it actually looks like
544	* VGA with weird scaling options - they do not use the canned QCIF mode	544	* VGA with weird scaling options - they do not use the canned QCIF mode
545	* which is allegedly provided by the sensor. So here's the weird register	545	* which is allegedly provided by the sensor. So here's the weird register
546	* settings.	546	* settings.
547	*/	547	*/
548	static struct regval_list ov7670_qcif_regs[] = {	548	static struct regval_list ov7670_qcif_regs[] = {
549	{ REG_COM3, COM3_SCALEEN\|COM3_DCWEN },	549	{ REG_COM3, COM3_SCALEEN\|COM3_DCWEN },
550	{ REG_COM3, COM3_DCWEN },	550	{ REG_COM3, COM3_DCWEN },
551	{ REG_COM14, COM14_DCWEN \| 0x01},	551	{ REG_COM14, COM14_DCWEN \| 0x01},
552	{ 0x73, 0xf1 },	552	{ 0x73, 0xf1 },
553	{ 0xa2, 0x52 },	553	{ 0xa2, 0x52 },
554	{ 0x7b, 0x1c },	554	{ 0x7b, 0x1c },
555	{ 0x7c, 0x28 },	555	{ 0x7c, 0x28 },
556	{ 0x7d, 0x3c },	556	{ 0x7d, 0x3c },
557	{ 0x7f, 0x69 },	557	{ 0x7f, 0x69 },
558	{ REG_COM9, 0x38 },	558	{ REG_COM9, 0x38 },
559	{ 0xa1, 0x0b },	559	{ 0xa1, 0x0b },
560	{ 0x74, 0x19 },	560	{ 0x74, 0x19 },
561	{ 0x9a, 0x80 },	561	{ 0x9a, 0x80 },
562	{ 0x43, 0x14 },	562	{ 0x43, 0x14 },
563	{ REG_COM13, 0xc0 },	563	{ REG_COM13, 0xc0 },
564	{ 0xff, 0xff },	564	{ 0xff, 0xff },
565	};	565	};
566		566
567	static struct ov7670_win_size {	567	static struct ov7670_win_size {
568	int width;	568	int width;
569	int height;	569	int height;
570	unsigned char com7_bit;	570	unsigned char com7_bit;
571	int hstart; /* Start/stop values for the camera. Note */	571	int hstart; /* Start/stop values for the camera. Note */
572	int hstop; /* that they do not always make complete */	572	int hstop; /* that they do not always make complete */
573	int vstart; /* sense to humans, but evidently the sensor */	573	int vstart; /* sense to humans, but evidently the sensor */
574	int vstop; /* will do the right thing... */	574	int vstop; /* will do the right thing... */
575	struct regval_list regs; / Regs to tweak */	575	struct regval_list regs; / Regs to tweak */
576	/* h/vref stuff */	576	/* h/vref stuff */
577	} ov7670_win_sizes[] = {	577	} ov7670_win_sizes[] = {
578	/* VGA */	578	/* VGA */
579	{	579	{
580	.width = VGA_WIDTH,	580	.width = VGA_WIDTH,
581	.height = VGA_HEIGHT,	581	.height = VGA_HEIGHT,
582	.com7_bit = COM7_FMT_VGA,	582	.com7_bit = COM7_FMT_VGA,
583	.hstart = 158, /* These values from */	583	.hstart = 158, /* These values from */
584	.hstop = 14, /* Omnivision */	584	.hstop = 14, /* Omnivision */
585	.vstart = 10,	585	.vstart = 10,
586	.vstop = 490,	586	.vstop = 490,
587	.regs = NULL,	587	.regs = NULL,
588	},	588	},
589	/* CIF */	589	/* CIF */
590	{	590	{
591	.width = CIF_WIDTH,	591	.width = CIF_WIDTH,
592	.height = CIF_HEIGHT,	592	.height = CIF_HEIGHT,
593	.com7_bit = COM7_FMT_CIF,	593	.com7_bit = COM7_FMT_CIF,
594	.hstart = 170, /* Empirically determined */	594	.hstart = 170, /* Empirically determined */
595	.hstop = 90,	595	.hstop = 90,
596	.vstart = 14,	596	.vstart = 14,
597	.vstop = 494,	597	.vstop = 494,
598	.regs = NULL,	598	.regs = NULL,
599	},	599	},
600	/* QVGA */	600	/* QVGA */
601	{	601	{
602	.width = QVGA_WIDTH,	602	.width = QVGA_WIDTH,
603	.height = QVGA_HEIGHT,	603	.height = QVGA_HEIGHT,
604	.com7_bit = COM7_FMT_QVGA,	604	.com7_bit = COM7_FMT_QVGA,
605	.hstart = 164, /* Empirically determined */	605	.hstart = 164, /* Empirically determined */
606	.hstop = 20,	606	.hstop = 20,
607	.vstart = 14,	607	.vstart = 14,
608	.vstop = 494,	608	.vstop = 494,
609	.regs = NULL,	609	.regs = NULL,
610	},	610	},
611	/* QCIF */	611	/* QCIF */
612	{	612	{
613	.width = QCIF_WIDTH,	613	.width = QCIF_WIDTH,
614	.height = QCIF_HEIGHT,	614	.height = QCIF_HEIGHT,
615	.com7_bit = COM7_FMT_VGA, /* see comment above */	615	.com7_bit = COM7_FMT_VGA, /* see comment above */
616	.hstart = 456, /* Empirically determined */	616	.hstart = 456, /* Empirically determined */
617	.hstop = 24,	617	.hstop = 24,
618	.vstart = 14,	618	.vstart = 14,
619	.vstop = 494,	619	.vstop = 494,
620	.regs = ov7670_qcif_regs,	620	.regs = ov7670_qcif_regs,
621	},	621	},
622	};	622	};
623		623
624	#define N_WIN_SIZES (ARRAY_SIZE(ov7670_win_sizes))	624	#define N_WIN_SIZES (ARRAY_SIZE(ov7670_win_sizes))
625		625
626		626
627	/*	627	/*
628	* Store a set of start/stop values into the camera.	628	* Store a set of start/stop values into the camera.
629	*/	629	*/
630	static int ov7670_set_hw(struct i2c_client *client, int hstart, int hstop,	630	static int ov7670_set_hw(struct i2c_client *client, int hstart, int hstop,
631	int vstart, int vstop)	631	int vstart, int vstop)
632	{	632	{
633	int ret;	633	int ret;
634	unsigned char v;	634	unsigned char v;
635	/*	635	/*
636	* Horizontal: 11 bits, top 8 live in hstart and hstop. Bottom 3 of	636	* Horizontal: 11 bits, top 8 live in hstart and hstop. Bottom 3 of
637	* hstart are in href[2:0], bottom 3 of hstop in href[5:3]. There is	637	* hstart are in href[2:0], bottom 3 of hstop in href[5:3]. There is
638	* a mystery "edge offset" value in the top two bits of href.	638	* a mystery "edge offset" value in the top two bits of href.
639	*/	639	*/
640	ret = ov7670_write(client, REG_HSTART, (hstart >> 3) & 0xff);	640	ret = ov7670_write(client, REG_HSTART, (hstart >> 3) & 0xff);
641	ret += ov7670_write(client, REG_HSTOP, (hstop >> 3) & 0xff);	641	ret += ov7670_write(client, REG_HSTOP, (hstop >> 3) & 0xff);
642	ret += ov7670_read(client, REG_HREF, &v);	642	ret += ov7670_read(client, REG_HREF, &v);
643	v = (v & 0xc0) \| ((hstop & 0x7) << 3) \| (hstart & 0x7);	643	v = (v & 0xc0) \| ((hstop & 0x7) << 3) \| (hstart & 0x7);
644	msleep(10);	644	msleep(10);
645	ret += ov7670_write(client, REG_HREF, v);	645	ret += ov7670_write(client, REG_HREF, v);
646	/*	646	/*
647	* Vertical: similar arrangement, but only 10 bits.	647	* Vertical: similar arrangement, but only 10 bits.
648	*/	648	*/
649	ret += ov7670_write(client, REG_VSTART, (vstart >> 2) & 0xff);	649	ret += ov7670_write(client, REG_VSTART, (vstart >> 2) & 0xff);
650	ret += ov7670_write(client, REG_VSTOP, (vstop >> 2) & 0xff);	650	ret += ov7670_write(client, REG_VSTOP, (vstop >> 2) & 0xff);
651	ret += ov7670_read(client, REG_VREF, &v);	651	ret += ov7670_read(client, REG_VREF, &v);
652	v = (v & 0xf0) \| ((vstop & 0x3) << 2) \| (vstart & 0x3);	652	v = (v & 0xf0) \| ((vstop & 0x3) << 2) \| (vstart & 0x3);
653	msleep(10);	653	msleep(10);
654	ret += ov7670_write(client, REG_VREF, v);	654	ret += ov7670_write(client, REG_VREF, v);
655	return ret;	655	return ret;
656	}	656	}
657		657
658		658
659	static int ov7670_enum_fmt(struct i2c_client c, struct v4l2_fmtdesc fmt)	659	static int ov7670_enum_fmt(struct i2c_client c, struct v4l2_fmtdesc fmt)
660	{	660	{
661	struct ov7670_format_struct *ofmt;	661	struct ov7670_format_struct *ofmt;
662		662
663	if (fmt->index >= N_OV7670_FMTS)	663	if (fmt->index >= N_OV7670_FMTS)
664	return -EINVAL;	664	return -EINVAL;
665		665
666	ofmt = ov7670_formats + fmt->index;	666	ofmt = ov7670_formats + fmt->index;
667	fmt->flags = 0;	667	fmt->flags = 0;
668	strcpy(fmt->description, ofmt->desc);	668	strcpy(fmt->description, ofmt->desc);
669	fmt->pixelformat = ofmt->pixelformat;	669	fmt->pixelformat = ofmt->pixelformat;
670	return 0;	670	return 0;
671	}	671	}
672		672
673		673
674	static int ov7670_try_fmt(struct i2c_client c, struct v4l2_format fmt,	674	static int ov7670_try_fmt(struct i2c_client c, struct v4l2_format fmt,
675	struct ov7670_format_struct **ret_fmt,	675	struct ov7670_format_struct **ret_fmt,
676	struct ov7670_win_size **ret_wsize)	676	struct ov7670_win_size **ret_wsize)
677	{	677	{
678	int index;	678	int index;
679	struct ov7670_win_size *wsize;	679	struct ov7670_win_size *wsize;
680	struct v4l2_pix_format *pix = &fmt->fmt.pix;	680	struct v4l2_pix_format *pix = &fmt->fmt.pix;
681		681
682	for (index = 0; index < N_OV7670_FMTS; index++)	682	for (index = 0; index < N_OV7670_FMTS; index++)
683	if (ov7670_formats[index].pixelformat == pix->pixelformat)	683	if (ov7670_formats[index].pixelformat == pix->pixelformat)
684	break;	684	break;
685	if (index >= N_OV7670_FMTS) {	685	if (index >= N_OV7670_FMTS) {
686	/* default to first format */	686	/* default to first format */
687	index = 0;	687	index = 0;
688	pix->pixelformat = ov7670_formats[0].pixelformat;	688	pix->pixelformat = ov7670_formats[0].pixelformat;
689	}	689	}
690	if (ret_fmt != NULL)	690	if (ret_fmt != NULL)
691	*ret_fmt = ov7670_formats + index;	691	*ret_fmt = ov7670_formats + index;
692	/*	692	/*
693	* Fields: the OV devices claim to be progressive.	693	* Fields: the OV devices claim to be progressive.
694	*/	694	*/
695	pix->field = V4L2_FIELD_NONE;	695	pix->field = V4L2_FIELD_NONE;
696	/*	696	/*
697	* Round requested image size down to the nearest	697	* Round requested image size down to the nearest
698	* we support, but not below the smallest.	698	* we support, but not below the smallest.
699	*/	699	*/
700	for (wsize = ov7670_win_sizes; wsize < ov7670_win_sizes + N_WIN_SIZES;	700	for (wsize = ov7670_win_sizes; wsize < ov7670_win_sizes + N_WIN_SIZES;
701	wsize++)	701	wsize++)
702	if (pix->width >= wsize->width && pix->height >= wsize->height)	702	if (pix->width >= wsize->width && pix->height >= wsize->height)
703	break;	703	break;
704	if (wsize >= ov7670_win_sizes + N_WIN_SIZES)	704	if (wsize >= ov7670_win_sizes + N_WIN_SIZES)
705	wsize--; /* Take the smallest one */	705	wsize--; /* Take the smallest one */
706	if (ret_wsize != NULL)	706	if (ret_wsize != NULL)
707	*ret_wsize = wsize;	707	*ret_wsize = wsize;
708	/*	708	/*
709	* Note the size we'll actually handle.	709	* Note the size we'll actually handle.
710	*/	710	*/
711	pix->width = wsize->width;	711	pix->width = wsize->width;
712	pix->height = wsize->height;	712	pix->height = wsize->height;
713	pix->bytesperline = pix->width*ov7670_formats[index].bpp;	713	pix->bytesperline = pix->width*ov7670_formats[index].bpp;
714	pix->sizeimage = pix->height*pix->bytesperline;	714	pix->sizeimage = pix->height*pix->bytesperline;
715	return 0;	715	return 0;
716	}	716	}
717		717
718	/*	718	/*
719	* Set a format.	719	* Set a format.
720	*/	720	*/
721	static int ov7670_s_fmt(struct i2c_client c, struct v4l2_format fmt)	721	static int ov7670_s_fmt(struct i2c_client c, struct v4l2_format fmt)
722	{	722	{
723	int ret;	723	int ret;
724	struct ov7670_format_struct *ovfmt;	724	struct ov7670_format_struct *ovfmt;
725	struct ov7670_win_size *wsize;	725	struct ov7670_win_size *wsize;
726	struct ov7670_info *info = i2c_get_clientdata(c);	726	struct ov7670_info *info = i2c_get_clientdata(c);
727	unsigned char com7, clkrc;	727	unsigned char com7, clkrc;
728		728
729	ret = ov7670_try_fmt(c, fmt, &ovfmt, &wsize);	729	ret = ov7670_try_fmt(c, fmt, &ovfmt, &wsize);
730	if (ret)	730	if (ret)
731	return ret;	731	return ret;
732	/*	732	/*
733	* HACK: if we're running rgb565 we need to grab then rewrite	733	* HACK: if we're running rgb565 we need to grab then rewrite
734	* CLKRC. If we're not, however, then rewriting clkrc hoses	734	* CLKRC. If we're not, however, then rewriting clkrc hoses
735	* the colors.	735	* the colors.
736	*/	736	*/
737	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_RGB565) {	737	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_RGB565) {
738	ret = ov7670_read(c, REG_CLKRC, &clkrc);	738	ret = ov7670_read(c, REG_CLKRC, &clkrc);
739	if (ret)	739	if (ret)
740	return ret;	740	return ret;
741	}	741	}
742	/*	742	/*
743	* COM7 is a pain in the ass, it doesn't like to be read then	743	* COM7 is a pain in the ass, it doesn't like to be read then
744	* quickly written afterward. But we have everything we need	744	* quickly written afterward. But we have everything we need
745	* to set it absolutely here, as long as the format-specific	745	* to set it absolutely here, as long as the format-specific
746	* register sets list it first.	746	* register sets list it first.
747	*/	747	*/
748	com7 = ovfmt->regs[0].value;	748	com7 = ovfmt->regs[0].value;
749	com7 \|= wsize->com7_bit;	749	com7 \|= wsize->com7_bit;
750	ov7670_write(c, REG_COM7, com7);	750	ov7670_write(c, REG_COM7, com7);
751	/*	751	/*
752	* Now write the rest of the array. Also store start/stops	752	* Now write the rest of the array. Also store start/stops
753	*/	753	*/
754	ov7670_write_array(c, ovfmt->regs + 1);	754	ov7670_write_array(c, ovfmt->regs + 1);
755	ov7670_set_hw(c, wsize->hstart, wsize->hstop, wsize->vstart,	755	ov7670_set_hw(c, wsize->hstart, wsize->hstop, wsize->vstart,
756	wsize->vstop);	756	wsize->vstop);
757	ret = 0;	757	ret = 0;
758	if (wsize->regs)	758	if (wsize->regs)
759	ret = ov7670_write_array(c, wsize->regs);	759	ret = ov7670_write_array(c, wsize->regs);
760	info->fmt = ovfmt;	760	info->fmt = ovfmt;
761		761
762	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_RGB565 && ret == 0)	762	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_RGB565 && ret == 0)
763	ret = ov7670_write(c, REG_CLKRC, clkrc);	763	ret = ov7670_write(c, REG_CLKRC, clkrc);
764	return ret;	764	return ret;
765	}	765	}
766		766
767	/*	767	/*
768	* Implement G/S_PARM. There is a "high quality" mode we could try	768	* Implement G/S_PARM. There is a "high quality" mode we could try
769	* to do someday; for now, we just do the frame rate tweak.	769	* to do someday; for now, we just do the frame rate tweak.
770	*/	770	*/
771	static int ov7670_g_parm(struct i2c_client c, struct v4l2_streamparm parms)	771	static int ov7670_g_parm(struct i2c_client c, struct v4l2_streamparm parms)
772	{	772	{
773	struct v4l2_captureparm *cp = &parms->parm.capture;	773	struct v4l2_captureparm *cp = &parms->parm.capture;
774	unsigned char clkrc;	774	unsigned char clkrc;
775	int ret;	775	int ret;
776		776
777	if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)	777	if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
778	return -EINVAL;	778	return -EINVAL;
779	ret = ov7670_read(c, REG_CLKRC, &clkrc);	779	ret = ov7670_read(c, REG_CLKRC, &clkrc);
780	if (ret < 0)	780	if (ret < 0)
781	return ret;	781	return ret;
782	memset(cp, 0, sizeof(struct v4l2_captureparm));	782	memset(cp, 0, sizeof(struct v4l2_captureparm));
783	cp->capability = V4L2_CAP_TIMEPERFRAME;	783	cp->capability = V4L2_CAP_TIMEPERFRAME;
784	cp->timeperframe.numerator = 1;	784	cp->timeperframe.numerator = 1;
785	cp->timeperframe.denominator = OV7670_FRAME_RATE;	785	cp->timeperframe.denominator = OV7670_FRAME_RATE;
786	if ((clkrc & CLK_EXT) == 0 && (clkrc & CLK_SCALE) > 1)	786	if ((clkrc & CLK_EXT) == 0 && (clkrc & CLK_SCALE) > 1)
787	cp->timeperframe.denominator /= (clkrc & CLK_SCALE);	787	cp->timeperframe.denominator /= (clkrc & CLK_SCALE);
788	return 0;	788	return 0;
789	}	789	}
790		790
791	static int ov7670_s_parm(struct i2c_client c, struct v4l2_streamparm parms)	791	static int ov7670_s_parm(struct i2c_client c, struct v4l2_streamparm parms)
792	{	792	{
793	struct v4l2_captureparm *cp = &parms->parm.capture;	793	struct v4l2_captureparm *cp = &parms->parm.capture;
794	struct v4l2_fract *tpf = &cp->timeperframe;	794	struct v4l2_fract *tpf = &cp->timeperframe;
795	unsigned char clkrc;	795	unsigned char clkrc;
796	int ret, div;	796	int ret, div;
797		797
798	if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)	798	if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
799	return -EINVAL;	799	return -EINVAL;
800	if (cp->extendedmode != 0)	800	if (cp->extendedmode != 0)
801	return -EINVAL;	801	return -EINVAL;
802	/*	802	/*
803	* CLKRC has a reserved bit, so let's preserve it.	803	* CLKRC has a reserved bit, so let's preserve it.
804	*/	804	*/
805	ret = ov7670_read(c, REG_CLKRC, &clkrc);	805	ret = ov7670_read(c, REG_CLKRC, &clkrc);
806	if (ret < 0)	806	if (ret < 0)
807	return ret;	807	return ret;
808	if (tpf->numerator == 0 \|\| tpf->denominator == 0)	808	if (tpf->numerator == 0 \|\| tpf->denominator == 0)
809	div = 1; /* Reset to full rate */	809	div = 1; /* Reset to full rate */
810	else	810	else
811	div = (tpf->numerator*OV7670_FRAME_RATE)/tpf->denominator;	811	div = (tpf->numerator*OV7670_FRAME_RATE)/tpf->denominator;
812	if (div == 0)	812	if (div == 0)
813	div = 1;	813	div = 1;
814	else if (div > CLK_SCALE)	814	else if (div > CLK_SCALE)
815	div = CLK_SCALE;	815	div = CLK_SCALE;
816	clkrc = (clkrc & 0x80) \| div;	816	clkrc = (clkrc & 0x80) \| div;
817	tpf->numerator = 1;	817	tpf->numerator = 1;
818	tpf->denominator = OV7670_FRAME_RATE/div;	818	tpf->denominator = OV7670_FRAME_RATE/div;
819	return ov7670_write(c, REG_CLKRC, clkrc);	819	return ov7670_write(c, REG_CLKRC, clkrc);
820	}	820	}
821		821
822		822
823		823
824	/*	824	/*
825	* Code for dealing with controls.	825	* Code for dealing with controls.
826	*/	826	*/
827		827
828		828
829		829
830		830
831		831
832	static int ov7670_store_cmatrix(struct i2c_client *client,	832	static int ov7670_store_cmatrix(struct i2c_client *client,
833	int matrix[CMATRIX_LEN])	833	int matrix[CMATRIX_LEN])
834	{	834	{
835	int i, ret;	835	int i, ret;
836	unsigned char signbits = 0;	836	unsigned char signbits = 0;
837		837
838	/*	838	/*
839	* Weird crap seems to exist in the upper part of	839	* Weird crap seems to exist in the upper part of
840	* the sign bits register, so let's preserve it.	840	* the sign bits register, so let's preserve it.
841	*/	841	*/
842	ret = ov7670_read(client, REG_CMATRIX_SIGN, &signbits);	842	ret = ov7670_read(client, REG_CMATRIX_SIGN, &signbits);
843	signbits &= 0xc0;	843	signbits &= 0xc0;
844		844
845	for (i = 0; i < CMATRIX_LEN; i++) {	845	for (i = 0; i < CMATRIX_LEN; i++) {
846	unsigned char raw;	846	unsigned char raw;
847		847
848	if (matrix[i] < 0) {	848	if (matrix[i] < 0) {
849	signbits \|= (1 << i);	849	signbits \|= (1 << i);
850	if (matrix[i] < -255)	850	if (matrix[i] < -255)
851	raw = 0xff;	851	raw = 0xff;
852	else	852	else
853	raw = (-1 * matrix[i]) & 0xff;	853	raw = (-1 * matrix[i]) & 0xff;
854	}	854	}
855	else {	855	else {
856	if (matrix[i] > 255)	856	if (matrix[i] > 255)
857	raw = 0xff;	857	raw = 0xff;
858	else	858	else
859	raw = matrix[i] & 0xff;	859	raw = matrix[i] & 0xff;
860	}	860	}
861	ret += ov7670_write(client, REG_CMATRIX_BASE + i, raw);	861	ret += ov7670_write(client, REG_CMATRIX_BASE + i, raw);
862	}	862	}
863	ret += ov7670_write(client, REG_CMATRIX_SIGN, signbits);	863	ret += ov7670_write(client, REG_CMATRIX_SIGN, signbits);
864	return ret;	864	return ret;
865	}	865	}
866		866
867		867
868	/*	868	/*
869	* Hue also requires messing with the color matrix. It also requires	869	* Hue also requires messing with the color matrix. It also requires
870	* trig functions, which tend not to be well supported in the kernel.	870	* trig functions, which tend not to be well supported in the kernel.
871	* So here is a simple table of sine values, 0-90 degrees, in steps	871	* So here is a simple table of sine values, 0-90 degrees, in steps
872	* of five degrees. Values are multiplied by 1000.	872	* of five degrees. Values are multiplied by 1000.
873	*	873	*
874	* The following naive approximate trig functions require an argument	874	* The following naive approximate trig functions require an argument
875	* carefully limited to -180 <= theta <= 180.	875	* carefully limited to -180 <= theta <= 180.
876	*/	876	*/
877	#define SIN_STEP 5	877	#define SIN_STEP 5
878	static const int ov7670_sin_table[] = {	878	static const int ov7670_sin_table[] = {
879	0, 87, 173, 258, 342, 422,	879	0, 87, 173, 258, 342, 422,
880	499, 573, 642, 707, 766, 819,	880	499, 573, 642, 707, 766, 819,
881	866, 906, 939, 965, 984, 996,	881	866, 906, 939, 965, 984, 996,
882	1000	882	1000
883	};	883	};
884		884
885	static int ov7670_sine(int theta)	885	static int ov7670_sine(int theta)
886	{	886	{
887	int chs = 1;	887	int chs = 1;
888	int sine;	888	int sine;
889		889
890	if (theta < 0) {	890	if (theta < 0) {
891	theta = -theta;	891	theta = -theta;
892	chs = -1;	892	chs = -1;
893	}	893	}
894	if (theta <= 90)	894	if (theta <= 90)
895	sine = ov7670_sin_table[theta/SIN_STEP];	895	sine = ov7670_sin_table[theta/SIN_STEP];
896	else {	896	else {
897	theta -= 90;	897	theta -= 90;
898	sine = 1000 - ov7670_sin_table[theta/SIN_STEP];	898	sine = 1000 - ov7670_sin_table[theta/SIN_STEP];
899	}	899	}
900	return sine*chs;	900	return sine*chs;
901	}	901	}
902		902
903	static int ov7670_cosine(int theta)	903	static int ov7670_cosine(int theta)
904	{	904	{
905	theta = 90 - theta;	905	theta = 90 - theta;
906	if (theta > 180)	906	if (theta > 180)
907	theta -= 360;	907	theta -= 360;
908	else if (theta < -180)	908	else if (theta < -180)
909	theta += 360;	909	theta += 360;
910	return ov7670_sine(theta);	910	return ov7670_sine(theta);
911	}	911	}
912		912
913		913
914		914
915		915
916	static void ov7670_calc_cmatrix(struct ov7670_info *info,	916	static void ov7670_calc_cmatrix(struct ov7670_info *info,
917	int matrix[CMATRIX_LEN])	917	int matrix[CMATRIX_LEN])
918	{	918	{
919	int i;	919	int i;
920	/*	920	/*
921	* Apply the current saturation setting first.	921	* Apply the current saturation setting first.
922	*/	922	*/
923	for (i = 0; i < CMATRIX_LEN; i++)	923	for (i = 0; i < CMATRIX_LEN; i++)
924	matrix[i] = (info->fmt->cmatrix[i]*info->sat) >> 7;	924	matrix[i] = (info->fmt->cmatrix[i]*info->sat) >> 7;
925	/*	925	/*
926	* Then, if need be, rotate the hue value.	926	* Then, if need be, rotate the hue value.
927	*/	927	*/
928	if (info->hue != 0) {	928	if (info->hue != 0) {
929	int sinth, costh, tmpmatrix[CMATRIX_LEN];	929	int sinth, costh, tmpmatrix[CMATRIX_LEN];
930		930
931	memcpy(tmpmatrix, matrix, CMATRIX_LEN*sizeof(int));	931	memcpy(tmpmatrix, matrix, CMATRIX_LEN*sizeof(int));
932	sinth = ov7670_sine(info->hue);	932	sinth = ov7670_sine(info->hue);
933	costh = ov7670_cosine(info->hue);	933	costh = ov7670_cosine(info->hue);
934		934
935	matrix[0] = (matrix[3]sinth + matrix[0]costh)/1000;	935	matrix[0] = (matrix[3]sinth + matrix[0]costh)/1000;
936	matrix[1] = (matrix[4]sinth + matrix[1]costh)/1000;	936	matrix[1] = (matrix[4]sinth + matrix[1]costh)/1000;
937	matrix[2] = (matrix[5]sinth + matrix[2]costh)/1000;	937	matrix[2] = (matrix[5]sinth + matrix[2]costh)/1000;
938	matrix[3] = (matrix[3]costh - matrix[0]sinth)/1000;	938	matrix[3] = (matrix[3]costh - matrix[0]sinth)/1000;
939	matrix[4] = (matrix[4]costh - matrix[1]sinth)/1000;	939	matrix[4] = (matrix[4]costh - matrix[1]sinth)/1000;
940	matrix[5] = (matrix[5]costh - matrix[2]sinth)/1000;	940	matrix[5] = (matrix[5]costh - matrix[2]sinth)/1000;
941	}	941	}
942	}	942	}
943		943
944		944
945		945
946	static int ov7670_t_sat(struct i2c_client *client, int value)	946	static int ov7670_t_sat(struct i2c_client *client, int value)
947	{	947	{
948	struct ov7670_info *info = i2c_get_clientdata(client);	948	struct ov7670_info *info = i2c_get_clientdata(client);
949	int matrix[CMATRIX_LEN];	949	int matrix[CMATRIX_LEN];
950	int ret;	950	int ret;
951		951
952	info->sat = value;	952	info->sat = value;
953	ov7670_calc_cmatrix(info, matrix);	953	ov7670_calc_cmatrix(info, matrix);
954	ret = ov7670_store_cmatrix(client, matrix);	954	ret = ov7670_store_cmatrix(client, matrix);
955	return ret;	955	return ret;
956	}	956	}
957		957
958	static int ov7670_q_sat(struct i2c_client client, __s32 value)	958	static int ov7670_q_sat(struct i2c_client client, __s32 value)
959	{	959	{
960	struct ov7670_info *info = i2c_get_clientdata(client);	960	struct ov7670_info *info = i2c_get_clientdata(client);
961		961
962	*value = info->sat;	962	*value = info->sat;
963	return 0;	963	return 0;
964	}	964	}
965		965
966	static int ov7670_t_hue(struct i2c_client *client, int value)	966	static int ov7670_t_hue(struct i2c_client *client, int value)
967	{	967	{
968	struct ov7670_info *info = i2c_get_clientdata(client);	968	struct ov7670_info *info = i2c_get_clientdata(client);
969	int matrix[CMATRIX_LEN];	969	int matrix[CMATRIX_LEN];
970	int ret;	970	int ret;
971		971
972	if (value < -180 \|\| value > 180)	972	if (value < -180 \|\| value > 180)
973	return -EINVAL;	973	return -EINVAL;
974	info->hue = value;	974	info->hue = value;
975	ov7670_calc_cmatrix(info, matrix);	975	ov7670_calc_cmatrix(info, matrix);
976	ret = ov7670_store_cmatrix(client, matrix);	976	ret = ov7670_store_cmatrix(client, matrix);
977	return ret;	977	return ret;
978	}	978	}
979		979
980		980
981	static int ov7670_q_hue(struct i2c_client client, __s32 value)	981	static int ov7670_q_hue(struct i2c_client client, __s32 value)
982	{	982	{
983	struct ov7670_info *info = i2c_get_clientdata(client);	983	struct ov7670_info *info = i2c_get_clientdata(client);
984		984
985	*value = info->hue;	985	*value = info->hue;
986	return 0;	986	return 0;
987	}	987	}
988		988
989		989
990	/*	990	/*
991	* Some weird registers seem to store values in a sign/magnitude format!	991	* Some weird registers seem to store values in a sign/magnitude format!
992	*/	992	*/
993	static unsigned char ov7670_sm_to_abs(unsigned char v)	993	static unsigned char ov7670_sm_to_abs(unsigned char v)
994	{	994	{
995	if ((v & 0x80) == 0)	995	if ((v & 0x80) == 0)
996	return v + 128;	996	return v + 128;
997	else	997	else
998	return 128 - (v & 0x7f);	998	return 128 - (v & 0x7f);
999	}	999	}
1000		1000
1001		1001
1002	static unsigned char ov7670_abs_to_sm(unsigned char v)	1002	static unsigned char ov7670_abs_to_sm(unsigned char v)
1003	{	1003	{
1004	if (v > 127)	1004	if (v > 127)
1005	return v & 0x7f;	1005	return v & 0x7f;
1006	else	1006	else
1007	return (128 - v) \| 0x80;	1007	return (128 - v) \| 0x80;
1008	}	1008	}
1009		1009
1010	static int ov7670_t_brightness(struct i2c_client *client, int value)	1010	static int ov7670_t_brightness(struct i2c_client *client, int value)
1011	{	1011	{
1012	unsigned char com8 = 0, v;	1012	unsigned char com8 = 0, v;
1013	int ret;	1013	int ret;
1014		1014
1015	ov7670_read(client, REG_COM8, &com8);	1015	ov7670_read(client, REG_COM8, &com8);
1016	com8 &= ~COM8_AEC;	1016	com8 &= ~COM8_AEC;
1017	ov7670_write(client, REG_COM8, com8);	1017	ov7670_write(client, REG_COM8, com8);
1018	v = ov7670_abs_to_sm(value);	1018	v = ov7670_abs_to_sm(value);
1019	ret = ov7670_write(client, REG_BRIGHT, v);	1019	ret = ov7670_write(client, REG_BRIGHT, v);
1020	return ret;	1020	return ret;
1021	}	1021	}
1022		1022
1023	static int ov7670_q_brightness(struct i2c_client client, __s32 value)	1023	static int ov7670_q_brightness(struct i2c_client client, __s32 value)
1024	{	1024	{
1025	unsigned char v = 0;	1025	unsigned char v = 0;
1026	int ret = ov7670_read(client, REG_BRIGHT, &v);	1026	int ret = ov7670_read(client, REG_BRIGHT, &v);
1027		1027
1028	*value = ov7670_sm_to_abs(v);	1028	*value = ov7670_sm_to_abs(v);
1029	return ret;	1029	return ret;
1030	}	1030	}
1031		1031
1032	static int ov7670_t_contrast(struct i2c_client *client, int value)	1032	static int ov7670_t_contrast(struct i2c_client *client, int value)
1033	{	1033	{
1034	return ov7670_write(client, REG_CONTRAS, (unsigned char) value);	1034	return ov7670_write(client, REG_CONTRAS, (unsigned char) value);
1035	}	1035	}
1036		1036
1037	static int ov7670_q_contrast(struct i2c_client client, __s32 value)	1037	static int ov7670_q_contrast(struct i2c_client client, __s32 value)
1038	{	1038	{
1039	unsigned char v = 0;	1039	unsigned char v = 0;
1040	int ret = ov7670_read(client, REG_CONTRAS, &v);	1040	int ret = ov7670_read(client, REG_CONTRAS, &v);
1041		1041
1042	*value = v;	1042	*value = v;
1043	return ret;	1043	return ret;
1044	}	1044	}
1045		1045
1046	static int ov7670_q_hflip(struct i2c_client client, __s32 value)	1046	static int ov7670_q_hflip(struct i2c_client client, __s32 value)
1047	{	1047	{
1048	int ret;	1048	int ret;
1049	unsigned char v = 0;	1049	unsigned char v = 0;
1050		1050
1051	ret = ov7670_read(client, REG_MVFP, &v);	1051	ret = ov7670_read(client, REG_MVFP, &v);
1052	*value = (v & MVFP_MIRROR) == MVFP_MIRROR;	1052	*value = (v & MVFP_MIRROR) == MVFP_MIRROR;
1053	return ret;	1053	return ret;
1054	}	1054	}
1055		1055
1056		1056
1057	static int ov7670_t_hflip(struct i2c_client *client, int value)	1057	static int ov7670_t_hflip(struct i2c_client *client, int value)
1058	{	1058	{
1059	unsigned char v = 0;	1059	unsigned char v = 0;
1060	int ret;	1060	int ret;
1061		1061
1062	ret = ov7670_read(client, REG_MVFP, &v);	1062	ret = ov7670_read(client, REG_MVFP, &v);
1063	if (value)	1063	if (value)
1064	v \|= MVFP_MIRROR;	1064	v \|= MVFP_MIRROR;
1065	else	1065	else
1066	v &= ~MVFP_MIRROR;	1066	v &= ~MVFP_MIRROR;
1067	msleep(10); /* FIXME */	1067	msleep(10); /* FIXME */
1068	ret += ov7670_write(client, REG_MVFP, v);	1068	ret += ov7670_write(client, REG_MVFP, v);
1069	return ret;	1069	return ret;
1070	}	1070	}
1071		1071
1072		1072
1073		1073
1074	static int ov7670_q_vflip(struct i2c_client client, __s32 value)	1074	static int ov7670_q_vflip(struct i2c_client client, __s32 value)
1075	{	1075	{
1076	int ret;	1076	int ret;
1077	unsigned char v = 0;	1077	unsigned char v = 0;
1078		1078
1079	ret = ov7670_read(client, REG_MVFP, &v);	1079	ret = ov7670_read(client, REG_MVFP, &v);
1080	*value = (v & MVFP_FLIP) == MVFP_FLIP;	1080	*value = (v & MVFP_FLIP) == MVFP_FLIP;
1081	return ret;	1081	return ret;
1082	}	1082	}
1083		1083
1084		1084
1085	static int ov7670_t_vflip(struct i2c_client *client, int value)	1085	static int ov7670_t_vflip(struct i2c_client *client, int value)
1086	{	1086	{
1087	unsigned char v = 0;	1087	unsigned char v = 0;
1088	int ret;	1088	int ret;
1089		1089
1090	ret = ov7670_read(client, REG_MVFP, &v);	1090	ret = ov7670_read(client, REG_MVFP, &v);
1091	if (value)	1091	if (value)
1092	v \|= MVFP_FLIP;	1092	v \|= MVFP_FLIP;
1093	else	1093	else
1094	v &= ~MVFP_FLIP;	1094	v &= ~MVFP_FLIP;
1095	msleep(10); /* FIXME */	1095	msleep(10); /* FIXME */
1096	ret += ov7670_write(client, REG_MVFP, v);	1096	ret += ov7670_write(client, REG_MVFP, v);
1097	return ret;	1097	return ret;
1098	}	1098	}
1099		1099
1100		1100
1101	static struct ov7670_control {	1101	static struct ov7670_control {
1102	struct v4l2_queryctrl qc;	1102	struct v4l2_queryctrl qc;
1103	int (query)(struct i2c_client c, __s32 *value);	1103	int (query)(struct i2c_client c, __s32 *value);
1104	int (tweak)(struct i2c_client c, int value);	1104	int (tweak)(struct i2c_client c, int value);
1105	} ov7670_controls[] =	1105	} ov7670_controls[] =
1106	{	1106	{
1107	{	1107	{
1108	.qc = {	1108	.qc = {
1109	.id = V4L2_CID_BRIGHTNESS,	1109	.id = V4L2_CID_BRIGHTNESS,
1110	.type = V4L2_CTRL_TYPE_INTEGER,	1110	.type = V4L2_CTRL_TYPE_INTEGER,
1111	.name = "Brightness",	1111	.name = "Brightness",
1112	.minimum = 0,	1112	.minimum = 0,
1113	.maximum = 255,	1113	.maximum = 255,
1114	.step = 1,	1114	.step = 1,
1115	.default_value = 0x80,	1115	.default_value = 0x80,
1116	.flags = V4L2_CTRL_FLAG_SLIDER	1116	.flags = V4L2_CTRL_FLAG_SLIDER
1117	},	1117	},
1118	.tweak = ov7670_t_brightness,	1118	.tweak = ov7670_t_brightness,
1119	.query = ov7670_q_brightness,	1119	.query = ov7670_q_brightness,
1120	},	1120	},
1121	{	1121	{
1122	.qc = {	1122	.qc = {
1123	.id = V4L2_CID_CONTRAST,	1123	.id = V4L2_CID_CONTRAST,
1124	.type = V4L2_CTRL_TYPE_INTEGER,	1124	.type = V4L2_CTRL_TYPE_INTEGER,
1125	.name = "Contrast",	1125	.name = "Contrast",
1126	.minimum = 0,	1126	.minimum = 0,
1127	.maximum = 127,	1127	.maximum = 127,
1128	.step = 1,	1128	.step = 1,
1129	.default_value = 0x40, /* XXX ov7670 spec */	1129	.default_value = 0x40, /* XXX ov7670 spec */
1130	.flags = V4L2_CTRL_FLAG_SLIDER	1130	.flags = V4L2_CTRL_FLAG_SLIDER
1131	},	1131	},
1132	.tweak = ov7670_t_contrast,	1132	.tweak = ov7670_t_contrast,
1133	.query = ov7670_q_contrast,	1133	.query = ov7670_q_contrast,
1134	},	1134	},
1135	{	1135	{
1136	.qc = {	1136	.qc = {
1137	.id = V4L2_CID_SATURATION,	1137	.id = V4L2_CID_SATURATION,
1138	.type = V4L2_CTRL_TYPE_INTEGER,	1138	.type = V4L2_CTRL_TYPE_INTEGER,
1139	.name = "Saturation",	1139	.name = "Saturation",
1140	.minimum = 0,	1140	.minimum = 0,
1141	.maximum = 256,	1141	.maximum = 256,
1142	.step = 1,	1142	.step = 1,
1143	.default_value = 0x80,	1143	.default_value = 0x80,
1144	.flags = V4L2_CTRL_FLAG_SLIDER	1144	.flags = V4L2_CTRL_FLAG_SLIDER
1145	},	1145	},
1146	.tweak = ov7670_t_sat,	1146	.tweak = ov7670_t_sat,
1147	.query = ov7670_q_sat,	1147	.query = ov7670_q_sat,
1148	},	1148	},
1149	{	1149	{
1150	.qc = {	1150	.qc = {
1151	.id = V4L2_CID_HUE,	1151	.id = V4L2_CID_HUE,
1152	.type = V4L2_CTRL_TYPE_INTEGER,	1152	.type = V4L2_CTRL_TYPE_INTEGER,
1153	.name = "HUE",	1153	.name = "HUE",
1154	.minimum = -180,	1154	.minimum = -180,
1155	.maximum = 180,	1155	.maximum = 180,
1156	.step = 5,	1156	.step = 5,
1157	.default_value = 0,	1157	.default_value = 0,
1158	.flags = V4L2_CTRL_FLAG_SLIDER	1158	.flags = V4L2_CTRL_FLAG_SLIDER
1159	},	1159	},
1160	.tweak = ov7670_t_hue,	1160	.tweak = ov7670_t_hue,
1161	.query = ov7670_q_hue,	1161	.query = ov7670_q_hue,
1162	},	1162	},
1163	{	1163	{
1164	.qc = {	1164	.qc = {
1165	.id = V4L2_CID_VFLIP,	1165	.id = V4L2_CID_VFLIP,
1166	.type = V4L2_CTRL_TYPE_BOOLEAN,	1166	.type = V4L2_CTRL_TYPE_BOOLEAN,
1167	.name = "Vertical flip",	1167	.name = "Vertical flip",
1168	.minimum = 0,	1168	.minimum = 0,
1169	.maximum = 1,	1169	.maximum = 1,
1170	.step = 1,	1170	.step = 1,
1171	.default_value = 0,	1171	.default_value = 0,
1172	},	1172	},
1173	.tweak = ov7670_t_vflip,	1173	.tweak = ov7670_t_vflip,
1174	.query = ov7670_q_vflip,	1174	.query = ov7670_q_vflip,
1175	},	1175	},
1176	{	1176	{
1177	.qc = {	1177	.qc = {
1178	.id = V4L2_CID_HFLIP,	1178	.id = V4L2_CID_HFLIP,
1179	.type = V4L2_CTRL_TYPE_BOOLEAN,	1179	.type = V4L2_CTRL_TYPE_BOOLEAN,
1180	.name = "Horizontal mirror",	1180	.name = "Horizontal mirror",
1181	.minimum = 0,	1181	.minimum = 0,
1182	.maximum = 1,	1182	.maximum = 1,
1183	.step = 1,	1183	.step = 1,
1184	.default_value = 0,	1184	.default_value = 0,
1185	},	1185	},
1186	.tweak = ov7670_t_hflip,	1186	.tweak = ov7670_t_hflip,
1187	.query = ov7670_q_hflip,	1187	.query = ov7670_q_hflip,
1188	},	1188	},
1189	};	1189	};
1190	#define N_CONTROLS (ARRAY_SIZE(ov7670_controls))	1190	#define N_CONTROLS (ARRAY_SIZE(ov7670_controls))
1191		1191
1192	static struct ov7670_control *ov7670_find_control(__u32 id)	1192	static struct ov7670_control *ov7670_find_control(__u32 id)
1193	{	1193	{
1194	int i;	1194	int i;
1195		1195
1196	for (i = 0; i < N_CONTROLS; i++)	1196	for (i = 0; i < N_CONTROLS; i++)
1197	if (ov7670_controls[i].qc.id == id)	1197	if (ov7670_controls[i].qc.id == id)
1198	return ov7670_controls + i;	1198	return ov7670_controls + i;
1199	return NULL;	1199	return NULL;
1200	}	1200	}
1201		1201
1202		1202
1203	static int ov7670_queryctrl(struct i2c_client *client,	1203	static int ov7670_queryctrl(struct i2c_client *client,
1204	struct v4l2_queryctrl *qc)	1204	struct v4l2_queryctrl *qc)
1205	{	1205	{
1206	struct ov7670_control *ctrl = ov7670_find_control(qc->id);	1206	struct ov7670_control *ctrl = ov7670_find_control(qc->id);
1207		1207
1208	if (ctrl == NULL)	1208	if (ctrl == NULL)
1209	return -EINVAL;	1209	return -EINVAL;
1210	*qc = ctrl->qc;	1210	*qc = ctrl->qc;
1211	return 0;	1211	return 0;
1212	}	1212	}
1213		1213
1214	static int ov7670_g_ctrl(struct i2c_client client, struct v4l2_control ctrl)	1214	static int ov7670_g_ctrl(struct i2c_client client, struct v4l2_control ctrl)
1215	{	1215	{
1216	struct ov7670_control *octrl = ov7670_find_control(ctrl->id);	1216	struct ov7670_control *octrl = ov7670_find_control(ctrl->id);
1217	int ret;	1217	int ret;
1218		1218
1219	if (octrl == NULL)	1219	if (octrl == NULL)
1220	return -EINVAL;	1220	return -EINVAL;
1221	ret = octrl->query(client, &ctrl->value);	1221	ret = octrl->query(client, &ctrl->value);
1222	if (ret >= 0)	1222	if (ret >= 0)
1223	return 0;	1223	return 0;
1224	return ret;	1224	return ret;
1225	}	1225	}
1226		1226
1227	static int ov7670_s_ctrl(struct i2c_client client, struct v4l2_control ctrl)	1227	static int ov7670_s_ctrl(struct i2c_client client, struct v4l2_control ctrl)
1228	{	1228	{
1229	struct ov7670_control *octrl = ov7670_find_control(ctrl->id);	1229	struct ov7670_control *octrl = ov7670_find_control(ctrl->id);
1230	int ret;	1230	int ret;
1231		1231
1232	if (octrl == NULL)	1232	if (octrl == NULL)
1233	return -EINVAL;	1233	return -EINVAL;
1234	ret = octrl->tweak(client, ctrl->value);	1234	ret = octrl->tweak(client, ctrl->value);
1235	if (ret >= 0)	1235	if (ret >= 0)
1236	return 0;	1236	return 0;
1237	return ret;	1237	return ret;
1238	}	1238	}
1239		1239
1240		1240
1241		1241
1242		1242
1243		1243
1244		1244
1245	/*	1245	/*
1246	* Basic i2c stuff.	1246	* Basic i2c stuff.
1247	*/	1247	*/
1248	static struct i2c_driver ov7670_driver;	1248	static struct i2c_driver ov7670_driver;
1249		1249
1250	static int ov7670_attach(struct i2c_adapter *adapter)	1250	static int ov7670_attach(struct i2c_adapter *adapter)
1251	{	1251	{
1252	int ret;	1252	int ret;
1253	struct i2c_client *client;	1253	struct i2c_client *client;
1254	struct ov7670_info *info;	1254	struct ov7670_info *info;
1255		1255
1256	/*	1256	/*
1257	* For now: only deal with adapters we recognize.	1257	* For now: only deal with adapters we recognize.
1258	*/	1258	*/
1259	if (adapter->id != I2C_HW_SMBUS_CAFE)	1259	if (adapter->id != I2C_HW_SMBUS_CAFE)
1260	return -ENODEV;	1260	return -ENODEV;
1261		1261
1262	client = kzalloc(sizeof (struct i2c_client), GFP_KERNEL);	1262	client = kzalloc(sizeof (struct i2c_client), GFP_KERNEL);
1263	if (! client)	1263	if (! client)
1264	return -ENOMEM;	1264	return -ENOMEM;
1265	client->adapter = adapter;	1265	client->adapter = adapter;
1266	client->addr = OV7670_I2C_ADDR;	1266	client->addr = OV7670_I2C_ADDR;
1267	client->driver = &ov7670_driver,	1267	client->driver = &ov7670_driver,
1268	strcpy(client->name, "OV7670");	1268	strcpy(client->name, "OV7670");
1269	/*	1269	/*
1270	* Set up our info structure.	1270	* Set up our info structure.
1271	*/	1271	*/
1272	info = kzalloc(sizeof (struct ov7670_info), GFP_KERNEL);	1272	info = kzalloc(sizeof (struct ov7670_info), GFP_KERNEL);
1273	if (! info) {	1273	if (! info) {
1274	ret = -ENOMEM;	1274	ret = -ENOMEM;
1275	goto out_free;	1275	goto out_free;
1276	}	1276	}
1277	info->fmt = &ov7670_formats[0];	1277	info->fmt = &ov7670_formats[0];
1278	info->sat = 128; /* Review this */	1278	info->sat = 128; /* Review this */
1279	i2c_set_clientdata(client, info);	1279	i2c_set_clientdata(client, info);
1280		1280
1281	/*	1281	/*
1282	* Make sure it's an ov7670	1282	* Make sure it's an ov7670
1283	*/	1283	*/
1284	ret = ov7670_detect(client);	1284	ret = ov7670_detect(client);
1285	if (ret)	1285	if (ret)
1286	goto out_free_info;	1286	goto out_free_info;
1287	ret = i2c_attach_client(client);	1287	ret = i2c_attach_client(client);
1288	if (ret)	1288	if (ret)
1289	goto out_free_info;	1289	goto out_free_info;
1290	return 0;	1290	return 0;
1291		1291
1292	out_free_info:	1292	out_free_info:
1293	kfree(info);	1293	kfree(info);
1294	out_free:	1294	out_free:
1295	kfree(client);	1295	kfree(client);
1296	return ret;	1296	return ret;
1297	}	1297	}
1298		1298
1299		1299
1300	static int ov7670_detach(struct i2c_client *client)	1300	static int ov7670_detach(struct i2c_client *client)
1301	{	1301	{
1302	i2c_detach_client(client);	1302	i2c_detach_client(client);
1303	kfree(i2c_get_clientdata(client));	1303	kfree(i2c_get_clientdata(client));
1304	kfree(client);	1304	kfree(client);
1305	return 0;	1305	return 0;
1306	}	1306	}
1307		1307
1308		1308
1309	static int ov7670_command(struct i2c_client *client, unsigned int cmd,	1309	static int ov7670_command(struct i2c_client *client, unsigned int cmd,
1310	void *arg)	1310	void *arg)
1311	{	1311	{
1312	switch (cmd) {	1312	switch (cmd) {
1313	case VIDIOC_DBG_G_CHIP_IDENT:	1313	case VIDIOC_DBG_G_CHIP_IDENT:
1314	return v4l2_chip_ident_i2c_client(client, arg, V4L2_IDENT_OV7670, 0);	1314	return v4l2_chip_ident_i2c_client(client, arg, V4L2_IDENT_OV7670, 0);
1315		1315
1316	case VIDIOC_INT_RESET:	1316	case VIDIOC_INT_RESET:
1317	ov7670_reset(client);	1317	ov7670_reset(client);
1318	return 0;	1318	return 0;
1319		1319
1320	case VIDIOC_INT_INIT:	1320	case VIDIOC_INT_INIT:
1321	return ov7670_init(client);	1321	return ov7670_init(client);
1322		1322
1323	case VIDIOC_ENUM_FMT:	1323	case VIDIOC_ENUM_FMT:
1324	return ov7670_enum_fmt(client, (struct v4l2_fmtdesc *) arg);	1324	return ov7670_enum_fmt(client, (struct v4l2_fmtdesc *) arg);
1325	case VIDIOC_TRY_FMT:	1325	case VIDIOC_TRY_FMT:
1326	return ov7670_try_fmt(client, (struct v4l2_format *) arg, NULL, NULL);	1326	return ov7670_try_fmt(client, (struct v4l2_format *) arg, NULL, NULL);
1327	case VIDIOC_S_FMT:	1327	case VIDIOC_S_FMT:
1328	return ov7670_s_fmt(client, (struct v4l2_format *) arg);	1328	return ov7670_s_fmt(client, (struct v4l2_format *) arg);
1329	case VIDIOC_QUERYCTRL:	1329	case VIDIOC_QUERYCTRL:
1330	return ov7670_queryctrl(client, (struct v4l2_queryctrl *) arg);	1330	return ov7670_queryctrl(client, (struct v4l2_queryctrl *) arg);
1331	case VIDIOC_S_CTRL:	1331	case VIDIOC_S_CTRL:
1332	return ov7670_s_ctrl(client, (struct v4l2_control *) arg);	1332	return ov7670_s_ctrl(client, (struct v4l2_control *) arg);
1333	case VIDIOC_G_CTRL:	1333	case VIDIOC_G_CTRL:
1334	return ov7670_g_ctrl(client, (struct v4l2_control *) arg);	1334	return ov7670_g_ctrl(client, (struct v4l2_control *) arg);
1335	case VIDIOC_S_PARM:	1335	case VIDIOC_S_PARM:
1336	return ov7670_s_parm(client, (struct v4l2_streamparm *) arg);	1336	return ov7670_s_parm(client, (struct v4l2_streamparm *) arg);
1337	case VIDIOC_G_PARM:	1337	case VIDIOC_G_PARM:
1338	return ov7670_g_parm(client, (struct v4l2_streamparm *) arg);	1338	return ov7670_g_parm(client, (struct v4l2_streamparm *) arg);
1339	}	1339	}
1340	return -EINVAL;	1340	return -EINVAL;
1341	}	1341	}
1342		1342
1343		1343
1344		1344
1345	static struct i2c_driver ov7670_driver = {	1345	static struct i2c_driver ov7670_driver = {
1346	.driver = {	1346	.driver = {
1347	.name = "ov7670",	1347	.name = "ov7670",
1348	},	1348	},
1349	.id = I2C_DRIVERID_OV7670,	1349	.id = I2C_DRIVERID_OV7670,
1350	.attach_adapter = ov7670_attach,	1350	.attach_adapter = ov7670_attach,
1351	.detach_client = ov7670_detach,	1351	.detach_client = ov7670_detach,
1352	.command = ov7670_command,	1352	.command = ov7670_command,
1353	};	1353	};
1354		1354
1355		1355
1356	/*	1356	/*
1357	* Module initialization	1357	* Module initialization
1358	*/	1358	*/
1359	static int __init ov7670_mod_init(void)	1359	static int __init ov7670_mod_init(void)
1360	{	1360	{
1361	printk(KERN_NOTICE "OmniVision ov7670 sensor driver, at your service\n");	1361	printk(KERN_NOTICE "OmniVision ov7670 sensor driver, at your service\n");
1362	return i2c_add_driver(&ov7670_driver);	1362	return i2c_add_driver(&ov7670_driver);
1363	}	1363	}
1364		1364
1365	static void __exit ov7670_mod_exit(void)	1365	static void __exit ov7670_mod_exit(void)
1366	{	1366	{
1367	i2c_del_driver(&ov7670_driver);	1367	i2c_del_driver(&ov7670_driver);
1368	}	1368	}
1369		1369
1370	module_init(ov7670_mod_init);	1370	module_init(ov7670_mod_init);
1371	module_exit(ov7670_mod_exit);	1371	module_exit(ov7670_mod_exit);
1372		1372

drivers/media/video/saa7134/saa7134-video.c

Diff comments View file @ 7e0a16f

 /*
  *
  * device driver for philips saa7134 based TV cards
  * video4linux video interface
  *
  * (c) 2001-03 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/sort.h>
 #include "saa7134-reg.h"
 #include "saa7134.h"
 #include <media/v4l2-common.h>
-#ifdef CONFIG_VIDEO_V4L1_COMPAT
-/* Include V4L1 specific functions. Should be removed soon */
-#include <linux/videodev.h>
-#endif
 /* ------------------------------------------------------------------ */
 unsigned int video_debug;
 static unsigned int gbuffers      = 8;
 static unsigned int noninterlaced; /* 0 */
 static unsigned int gbufsize      = 720*576*4;
 static unsigned int gbufsize_max  = 720*576*4;
 static char secam[] = "--";
 module_param(video_debug, int, 0644);
 MODULE_PARM_DESC(video_debug,"enable debug messages [video]");
 module_param(gbuffers, int, 0444);
 MODULE_PARM_DESC(gbuffers,"number of capture buffers, range 2-32");
 module_param(noninterlaced, int, 0644);
 MODULE_PARM_DESC(noninterlaced,"capture non interlaced video");
 module_param_string(secam, secam, sizeof(secam), 0644);
 MODULE_PARM_DESC(secam, "force SECAM variant, either DK,L or Lc");
 #define dprintk(fmt, arg...)	if (video_debug&0x04) \
 	printk(KERN_DEBUG "%s/video: " fmt, dev->name , ## arg)
 /* ------------------------------------------------------------------ */
 /* Defines for Video Output Port Register at address 0x191            */
 /* Bit 0: VIP code T bit polarity */
 #define VP_T_CODE_P_NON_INVERTED	0x00
 #define VP_T_CODE_P_INVERTED		0x01
 /* ------------------------------------------------------------------ */
 /* Defines for Video Output Port Register at address 0x195            */
 /* Bit 2: Video output clock delay control */
 #define VP_CLK_CTRL2_NOT_DELAYED	0x00
 #define VP_CLK_CTRL2_DELAYED		0x04
 /* Bit 1: Video output clock invert control */
 #define VP_CLK_CTRL1_NON_INVERTED	0x00
 #define VP_CLK_CTRL1_INVERTED		0x02
 /* ------------------------------------------------------------------ */
 /* Defines for Video Output Port Register at address 0x196            */
 /* Bits 2 to 0: VSYNC pin video vertical sync type */
 #define VP_VS_TYPE_MASK			0x07
 #define VP_VS_TYPE_OFF			0x00
 #define VP_VS_TYPE_V123			0x01
 #define VP_VS_TYPE_V_ITU		0x02
 #define VP_VS_TYPE_VGATE_L		0x03
 #define VP_VS_TYPE_RESERVED1		0x04
 #define VP_VS_TYPE_RESERVED2		0x05
 #define VP_VS_TYPE_F_ITU		0x06
 #define VP_VS_TYPE_SC_FID		0x07
 /* ------------------------------------------------------------------ */
 /* data structs for video                                             */
 static int video_out[][9] = {
 	[CCIR656] = { 0x00, 0xb1, 0x00, 0xa1, 0x00, 0x04, 0x06, 0x00, 0x00 },
 };
 static struct saa7134_format formats[] = {
 	{
 		.name     = "8 bpp gray",
 		.fourcc   = V4L2_PIX_FMT_GREY,
 		.depth    = 8,
 		.pm       = 0x06,
 	},{
 		.name     = "15 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_RGB555,
 		.depth    = 16,
 		.pm       = 0x13 | 0x80,
 	},{
 		.name     = "15 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB555X,
 		.depth    = 16,
 		.pm       = 0x13 | 0x80,
 		.bswap    = 1,
 	},{
 		.name     = "16 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_RGB565,
 		.depth    = 16,
 		.pm       = 0x10 | 0x80,
 	},{
 		.name     = "16 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB565X,
 		.depth    = 16,
 		.pm       = 0x10 | 0x80,
 		.bswap    = 1,
 	},{
 		.name     = "24 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_BGR24,
 		.depth    = 24,
 		.pm       = 0x11,
 	},{
 		.name     = "24 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB24,
 		.depth    = 24,
 		.pm       = 0x11,
 		.bswap    = 1,
 	},{
 		.name     = "32 bpp RGB, le",
 		.fourcc   = V4L2_PIX_FMT_BGR32,
 		.depth    = 32,
 		.pm       = 0x12,
 	},{
 		.name     = "32 bpp RGB, be",
 		.fourcc   = V4L2_PIX_FMT_RGB32,
 		.depth    = 32,
 		.pm       = 0x12,
 		.bswap    = 1,
 		.wswap    = 1,
 	},{
 		.name     = "4:2:2 packed, YUYV",
 		.fourcc   = V4L2_PIX_FMT_YUYV,
 		.depth    = 16,
 		.pm       = 0x00,
 		.bswap    = 1,
 		.yuv      = 1,
 	},{
 		.name     = "4:2:2 packed, UYVY",
 		.fourcc   = V4L2_PIX_FMT_UYVY,
 		.depth    = 16,
 		.pm       = 0x00,
 		.yuv      = 1,
 	},{
 		.name     = "4:2:2 planar, Y-Cb-Cr",
 		.fourcc   = V4L2_PIX_FMT_YUV422P,
 		.depth    = 16,
 		.pm       = 0x09,
 		.yuv      = 1,
 		.planar   = 1,
 		.hshift   = 1,
 		.vshift   = 0,
 	},{
 		.name     = "4:2:0 planar, Y-Cb-Cr",
 		.fourcc   = V4L2_PIX_FMT_YUV420,
 		.depth    = 12,
 		.pm       = 0x0a,
 		.yuv      = 1,
 		.planar   = 1,
 		.hshift   = 1,
 		.vshift   = 1,
 	},{
 		.name     = "4:2:0 planar, Y-Cb-Cr",
 		.fourcc   = V4L2_PIX_FMT_YVU420,
 		.depth    = 12,
 		.pm       = 0x0a,
 		.yuv      = 1,
 		.planar   = 1,
 		.uvswap   = 1,
 		.hshift   = 1,
 		.vshift   = 1,
 	}
 };
 #define FORMATS ARRAY_SIZE(formats)
 #define NORM_625_50			\
 		.h_start       = 0,	\
 		.h_stop        = 719,	\
 		.video_v_start = 24,	\
 		.video_v_stop  = 311,	\
 		.vbi_v_start_0 = 7,	\
 		.vbi_v_stop_0  = 22,	\
 		.vbi_v_start_1 = 319,   \
 		.src_timing    = 4
 #define NORM_525_60			\
 		.h_start       = 0,	\
 		.h_stop        = 703,	\
 		.video_v_start = 23,	\
 		.video_v_stop  = 262,	\
 		.vbi_v_start_0 = 10,	\
 		.vbi_v_stop_0  = 21,	\
 		.vbi_v_start_1 = 273,	\
 		.src_timing    = 7
 static struct saa7134_tvnorm tvnorms[] = {
 	{
 		.name          = "PAL", /* autodetect */
 		.id            = V4L2_STD_PAL,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x40,
 		.chroma_ctrl1  = 0x81,
 		.chroma_gain   = 0x2a,
 		.chroma_ctrl2  = 0x06,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "PAL-BG",
 		.id            = V4L2_STD_PAL_BG,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x40,
 		.chroma_ctrl1  = 0x81,
 		.chroma_gain   = 0x2a,
 		.chroma_ctrl2  = 0x06,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "PAL-I",
 		.id            = V4L2_STD_PAL_I,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x40,
 		.chroma_ctrl1  = 0x81,
 		.chroma_gain   = 0x2a,
 		.chroma_ctrl2  = 0x06,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "PAL-DK",
 		.id            = V4L2_STD_PAL_DK,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x40,
 		.chroma_ctrl1  = 0x81,
 		.chroma_gain   = 0x2a,
 		.chroma_ctrl2  = 0x06,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "NTSC",
 		.id            = V4L2_STD_NTSC,
 		NORM_525_60,
 		.sync_control  = 0x59,
 		.luma_control  = 0x40,
 		.chroma_ctrl1  = 0x89,
 		.chroma_gain   = 0x2a,
 		.chroma_ctrl2  = 0x0e,
 		.vgate_misc    = 0x18,
 	},{
 		.name          = "SECAM",
 		.id            = V4L2_STD_SECAM,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x1b,
 		.chroma_ctrl1  = 0xd1,
 		.chroma_gain   = 0x80,
 		.chroma_ctrl2  = 0x00,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "SECAM-DK",
 		.id            = V4L2_STD_SECAM_DK,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x1b,
 		.chroma_ctrl1  = 0xd1,
 		.chroma_gain   = 0x80,
 		.chroma_ctrl2  = 0x00,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "SECAM-L",
 		.id            = V4L2_STD_SECAM_L,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x1b,
 		.chroma_ctrl1  = 0xd1,
 		.chroma_gain   = 0x80,
 		.chroma_ctrl2  = 0x00,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "SECAM-Lc",
 		.id            = V4L2_STD_SECAM_LC,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x1b,
 		.chroma_ctrl1  = 0xd1,
 		.chroma_gain   = 0x80,
 		.chroma_ctrl2  = 0x00,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "PAL-M",
 		.id            = V4L2_STD_PAL_M,
 		NORM_525_60,
 		.sync_control  = 0x59,
 		.luma_control  = 0x40,
 		.chroma_ctrl1  = 0xb9,
 		.chroma_gain   = 0x2a,
 		.chroma_ctrl2  = 0x0e,
 		.vgate_misc    = 0x18,
 	},{
 		.name          = "PAL-Nc",
 		.id            = V4L2_STD_PAL_Nc,
 		NORM_625_50,
 		.sync_control  = 0x18,
 		.luma_control  = 0x40,
 		.chroma_ctrl1  = 0xa1,
 		.chroma_gain   = 0x2a,
 		.chroma_ctrl2  = 0x06,
 		.vgate_misc    = 0x1c,
 	},{
 		.name          = "PAL-60",
 		.id            = V4L2_STD_PAL_60,
 		.h_start       = 0,
 		.h_stop        = 719,
 		.video_v_start = 23,
 		.video_v_stop  = 262,
 		.vbi_v_start_0 = 10,
 		.vbi_v_stop_0  = 21,
 		.vbi_v_start_1 = 273,
 		.src_timing    = 7,
 		.sync_control  = 0x18,
 		.luma_control  = 0x40,
 		.chroma_ctrl1  = 0x81,
 		.chroma_gain   = 0x2a,
 		.chroma_ctrl2  = 0x06,
 		.vgate_misc    = 0x1c,
 	}
 };
 #define TVNORMS ARRAY_SIZE(tvnorms)
 #define V4L2_CID_PRIVATE_INVERT      (V4L2_CID_PRIVATE_BASE + 0)
 #define V4L2_CID_PRIVATE_Y_ODD       (V4L2_CID_PRIVATE_BASE + 1)
 #define V4L2_CID_PRIVATE_Y_EVEN      (V4L2_CID_PRIVATE_BASE + 2)
 #define V4L2_CID_PRIVATE_AUTOMUTE    (V4L2_CID_PRIVATE_BASE + 3)
 #define V4L2_CID_PRIVATE_LASTP1      (V4L2_CID_PRIVATE_BASE + 4)
 static const struct v4l2_queryctrl no_ctrl = {
 	.name  = "42",
 	.flags = V4L2_CTRL_FLAG_DISABLED,
 };
 static const struct v4l2_queryctrl video_ctrls[] = {
 	/* --- video --- */
 	{
 		.id            = V4L2_CID_BRIGHTNESS,
 		.name          = "Brightness",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 1,
 		.default_value = 128,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 	},{
 		.id            = V4L2_CID_CONTRAST,
 		.name          = "Contrast",
 		.minimum       = 0,
 		.maximum       = 127,
 		.step          = 1,
 		.default_value = 68,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 	},{
 		.id            = V4L2_CID_SATURATION,
 		.name          = "Saturation",
 		.minimum       = 0,
 		.maximum       = 127,
 		.step          = 1,
 		.default_value = 64,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 	},{
 		.id            = V4L2_CID_HUE,
 		.name          = "Hue",
 		.minimum       = -128,
 		.maximum       = 127,
 		.step          = 1,
 		.default_value = 0,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 	},{
 		.id            = V4L2_CID_HFLIP,
 		.name          = "Mirror",
 		.minimum       = 0,
 		.maximum       = 1,
 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
 	},
 	/* --- audio --- */
 	{
 		.id            = V4L2_CID_AUDIO_MUTE,
 		.name          = "Mute",
 		.minimum       = 0,
 		.maximum       = 1,
 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
 	},{
 		.id            = V4L2_CID_AUDIO_VOLUME,
 		.name          = "Volume",
 		.minimum       = -15,
 		.maximum       = 15,
 		.step          = 1,
 		.default_value = 0,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 	},
 	/* --- private --- */
 	{
 		.id            = V4L2_CID_PRIVATE_INVERT,
 		.name          = "Invert",
 		.minimum       = 0,
 		.maximum       = 1,
 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
 	},{
 		.id            = V4L2_CID_PRIVATE_Y_ODD,
 		.name          = "y offset odd field",
 		.minimum       = 0,
 		.maximum       = 128,
 		.step          = 1,
 		.default_value = 0,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 	},{
 		.id            = V4L2_CID_PRIVATE_Y_EVEN,
 		.name          = "y offset even field",
 		.minimum       = 0,
 		.maximum       = 128,
 		.step          = 1,
 		.default_value = 0,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 	},{
 		.id            = V4L2_CID_PRIVATE_AUTOMUTE,
 		.name          = "automute",
 		.minimum       = 0,
 		.maximum       = 1,
 		.default_value = 1,
 		.type          = V4L2_CTRL_TYPE_BOOLEAN,
 	}
 };
 static const unsigned int CTRLS = ARRAY_SIZE(video_ctrls);
 static const struct v4l2_queryctrl* ctrl_by_id(unsigned int id)
 {
 	unsigned int i;
 	for (i = 0; i < CTRLS; i++)
 		if (video_ctrls[i].id == id)
 			return video_ctrls+i;
 	return NULL;
 }
 static struct saa7134_format* format_by_fourcc(unsigned int fourcc)
 {
 	unsigned int i;
 	for (i = 0; i < FORMATS; i++)
 		if (formats[i].fourcc == fourcc)
 			return formats+i;
 	return NULL;
 }
 /* ----------------------------------------------------------------------- */
 /* resource management                                                     */
 static int res_get(struct saa7134_dev *dev, struct saa7134_fh *fh, unsigned int bit)
 {
 	if (fh->resources & bit)
 		/* have it already allocated */
 		return 1;
 	/* is it free? */
 	mutex_lock(&dev->lock);
 	if (dev->resources & bit) {
 		/* no, someone else uses it */
 		mutex_unlock(&dev->lock);
 		return 0;
 	}
 	/* it's free, grab it */
 	fh->resources  |= bit;
 	dev->resources |= bit;
 	dprintk("res: get %d\n",bit);
 	mutex_unlock(&dev->lock);
 	return 1;
 }
 static int res_check(struct saa7134_fh *fh, unsigned int bit)
 {
 	return (fh->resources & bit);
 }
 static int res_locked(struct saa7134_dev *dev, unsigned int bit)
 {
 	return (dev->resources & bit);
 }
 static
 void res_free(struct saa7134_dev *dev, struct saa7134_fh *fh, unsigned int bits)
 {
 	BUG_ON((fh->resources & bits) != bits);
 	mutex_lock(&dev->lock);
 	fh->resources  &= ~bits;
 	dev->resources &= ~bits;
 	dprintk("res: put %d\n",bits);
 	mutex_unlock(&dev->lock);
 }
 /* ------------------------------------------------------------------ */
 static void set_tvnorm(struct saa7134_dev *dev, struct saa7134_tvnorm *norm)
 {
 	dprintk("set tv norm = %s\n",norm->name);
 	dev->tvnorm = norm;
 	/* setup cropping */
 	dev->crop_bounds.left    = norm->h_start;
 	dev->crop_defrect.left   = norm->h_start;
 	dev->crop_bounds.width   = norm->h_stop - norm->h_start +1;
 	dev->crop_defrect.width  = norm->h_stop - norm->h_start +1;
 	dev->crop_bounds.top     = (norm->vbi_v_stop_0+1)*2;
 	dev->crop_defrect.top    = norm->video_v_start*2;
 	dev->crop_bounds.height  = ((norm->id & V4L2_STD_525_60) ? 524 : 624)
 		- dev->crop_bounds.top;
 	dev->crop_defrect.height = (norm->video_v_stop - norm->video_v_start +1)*2;
 	dev->crop_current = dev->crop_defrect;
 	saa7134_set_tvnorm_hw(dev);
 }
 static void video_mux(struct saa7134_dev *dev, int input)
 {
 	dprintk("video input = %d [%s]\n", input, card_in(dev, input).name);
 	dev->ctl_input = input;
 	set_tvnorm(dev, dev->tvnorm);
 	saa7134_tvaudio_setinput(dev, &card_in(dev, input));
 }
 static void saa7134_set_decoder(struct saa7134_dev *dev)
 {
 	int luma_control, sync_control, mux;
 	struct saa7134_tvnorm *norm = dev->tvnorm;
 	mux = card_in(dev, dev->ctl_input).vmux;
 	luma_control = norm->luma_control;
 	sync_control = norm->sync_control;
 	if (mux > 5)
 		luma_control |= 0x80; /* svideo */
 	if (noninterlaced || dev->nosignal)
 		sync_control |= 0x20;
 	/* setup video decoder */
 	saa_writeb(SAA7134_INCR_DELAY,            0x08);
 	saa_writeb(SAA7134_ANALOG_IN_CTRL1,       0xc0 | mux);
 	saa_writeb(SAA7134_ANALOG_IN_CTRL2,       0x00);
 	saa_writeb(SAA7134_ANALOG_IN_CTRL3,       0x90);
 	saa_writeb(SAA7134_ANALOG_IN_CTRL4,       0x90);
 	saa_writeb(SAA7134_HSYNC_START,           0xeb);
 	saa_writeb(SAA7134_HSYNC_STOP,            0xe0);
 	saa_writeb(SAA7134_SOURCE_TIMING1,        norm->src_timing);
 	saa_writeb(SAA7134_SYNC_CTRL,             sync_control);
 	saa_writeb(SAA7134_LUMA_CTRL,             luma_control);
 	saa_writeb(SAA7134_DEC_LUMA_BRIGHT,       dev->ctl_bright);
 	saa_writeb(SAA7134_DEC_LUMA_CONTRAST,
 		dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast);
 	saa_writeb(SAA7134_DEC_CHROMA_SATURATION,
 		dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation);
 	saa_writeb(SAA7134_DEC_CHROMA_HUE,        dev->ctl_hue);
 	saa_writeb(SAA7134_CHROMA_CTRL1,          norm->chroma_ctrl1);
 	saa_writeb(SAA7134_CHROMA_GAIN,           norm->chroma_gain);
 	saa_writeb(SAA7134_CHROMA_CTRL2,          norm->chroma_ctrl2);
 	saa_writeb(SAA7134_MODE_DELAY_CTRL,       0x00);
 	saa_writeb(SAA7134_ANALOG_ADC,            0x01);
 	saa_writeb(SAA7134_VGATE_START,           0x11);
 	saa_writeb(SAA7134_VGATE_STOP,            0xfe);
 	saa_writeb(SAA7134_MISC_VGATE_MSB,        norm->vgate_misc);
 	saa_writeb(SAA7134_RAW_DATA_GAIN,         0x40);
 	saa_writeb(SAA7134_RAW_DATA_OFFSET,       0x80);
 }
 void saa7134_set_tvnorm_hw(struct saa7134_dev *dev)
 {
 	saa7134_set_decoder(dev);
 	if (card_in(dev, dev->ctl_input).tv)
 		saa_call_all(dev, tuner, s_std, dev->tvnorm->id);
 	/* Set the correct norm for the saa6752hs. This function
 	   does nothing if there is no saa6752hs. */
 	saa_call_empress(dev, tuner, s_std, dev->tvnorm->id);
 }
 static void set_h_prescale(struct saa7134_dev *dev, int task, int prescale)
 {
 	static const struct {
 		int xpsc;
 		int xacl;
 		int xc2_1;
 		int xdcg;
 		int vpfy;
 	} vals[] = {
 		/* XPSC XACL XC2_1 XDCG VPFY */
 		{    1,   0,    0,    0,   0 },
 		{    2,   2,    1,    2,   2 },
 		{    3,   4,    1,    3,   2 },
 		{    4,   8,    1,    4,   2 },
 		{    5,   8,    1,    4,   2 },
 		{    6,   8,    1,    4,   3 },
 		{    7,   8,    1,    4,   3 },
 		{    8,  15,    0,    4,   3 },
 		{    9,  15,    0,    4,   3 },
 		{   10,  16,    1,    5,   3 },
 	};
 	static const int count = ARRAY_SIZE(vals);
 	int i;
 	for (i = 0; i < count; i++)
 		if (vals[i].xpsc == prescale)
 			break;
 	if (i == count)
 		return;
 	saa_writeb(SAA7134_H_PRESCALE(task), vals[i].xpsc);
 	saa_writeb(SAA7134_ACC_LENGTH(task), vals[i].xacl);
 	saa_writeb(SAA7134_LEVEL_CTRL(task),
 		   (vals[i].xc2_1 << 3) | (vals[i].xdcg));
 	saa_andorb(SAA7134_FIR_PREFILTER_CTRL(task), 0x0f,
 		   (vals[i].vpfy << 2) | vals[i].vpfy);
 }
 static void set_v_scale(struct saa7134_dev *dev, int task, int yscale)
 {
 	int val,mirror;
 	saa_writeb(SAA7134_V_SCALE_RATIO1(task), yscale &  0xff);
 	saa_writeb(SAA7134_V_SCALE_RATIO2(task), yscale >> 8);
 	mirror = (dev->ctl_mirror) ? 0x02 : 0x00;
 	if (yscale < 2048) {
 		/* LPI */
 		dprintk("yscale LPI yscale=%d\n",yscale);
 		saa_writeb(SAA7134_V_FILTER(task), 0x00 | mirror);
 		saa_writeb(SAA7134_LUMA_CONTRAST(task), 0x40);
 		saa_writeb(SAA7134_CHROMA_SATURATION(task), 0x40);
 	} else {
 		/* ACM */
 		val = 0x40 * 1024 / yscale;
 		dprintk("yscale ACM yscale=%d val=0x%x\n",yscale,val);
 		saa_writeb(SAA7134_V_FILTER(task), 0x01 | mirror);
 		saa_writeb(SAA7134_LUMA_CONTRAST(task), val);
 		saa_writeb(SAA7134_CHROMA_SATURATION(task), val);
 	}
 	saa_writeb(SAA7134_LUMA_BRIGHT(task),       0x80);
 }
 static void set_size(struct saa7134_dev *dev, int task,
 		     int width, int height, int interlace)
 {
 	int prescale,xscale,yscale,y_even,y_odd;
 	int h_start, h_stop, v_start, v_stop;
 	int div = interlace ? 2 : 1;
 	/* setup video scaler */
 	h_start = dev->crop_current.left;
 	v_start = dev->crop_current.top/2;
 	h_stop  = (dev->crop_current.left + dev->crop_current.width -1);
 	v_stop  = (dev->crop_current.top + dev->crop_current.height -1)/2;
 	saa_writeb(SAA7134_VIDEO_H_START1(task), h_start &  0xff);
 	saa_writeb(SAA7134_VIDEO_H_START2(task), h_start >> 8);
 	saa_writeb(SAA7134_VIDEO_H_STOP1(task),  h_stop  &  0xff);
 	saa_writeb(SAA7134_VIDEO_H_STOP2(task),  h_stop  >> 8);
 	saa_writeb(SAA7134_VIDEO_V_START1(task), v_start &  0xff);
 	saa_writeb(SAA7134_VIDEO_V_START2(task), v_start >> 8);
 	saa_writeb(SAA7134_VIDEO_V_STOP1(task),  v_stop  &  0xff);
 	saa_writeb(SAA7134_VIDEO_V_STOP2(task),  v_stop  >> 8);
 	prescale = dev->crop_current.width / width;
 	if (0 == prescale)
 		prescale = 1;
 	xscale = 1024 * dev->crop_current.width / prescale / width;
 	yscale = 512 * div * dev->crop_current.height / height;
 	dprintk("prescale=%d xscale=%d yscale=%d\n",prescale,xscale,yscale);
 	set_h_prescale(dev,task,prescale);
 	saa_writeb(SAA7134_H_SCALE_INC1(task),      xscale &  0xff);
 	saa_writeb(SAA7134_H_SCALE_INC2(task),      xscale >> 8);
 	set_v_scale(dev,task,yscale);
 	saa_writeb(SAA7134_VIDEO_PIXELS1(task),     width  & 0xff);
 	saa_writeb(SAA7134_VIDEO_PIXELS2(task),     width  >> 8);
 	saa_writeb(SAA7134_VIDEO_LINES1(task),      height/div & 0xff);
 	saa_writeb(SAA7134_VIDEO_LINES2(task),      height/div >> 8);
 	/* deinterlace y offsets */
 	y_odd  = dev->ctl_y_odd;
 	y_even = dev->ctl_y_even;
 	saa_writeb(SAA7134_V_PHASE_OFFSET0(task), y_odd);
 	saa_writeb(SAA7134_V_PHASE_OFFSET1(task), y_even);
 	saa_writeb(SAA7134_V_PHASE_OFFSET2(task), y_odd);
 	saa_writeb(SAA7134_V_PHASE_OFFSET3(task), y_even);
 }
 /* ------------------------------------------------------------------ */
 struct cliplist {
 	__u16 position;
 	__u8  enable;
 	__u8  disable;
 };
 static void set_cliplist(struct saa7134_dev *dev, int reg,
 			struct cliplist *cl, int entries, char *name)
 {
 	__u8 winbits = 0;
 	int i;
 	for (i = 0; i < entries; i++) {
 		winbits |= cl[i].enable;
 		winbits &= ~cl[i].disable;
 		if (i < 15 && cl[i].position == cl[i+1].position)
 			continue;
 		saa_writeb(reg + 0, winbits);
 		saa_writeb(reg + 2, cl[i].position & 0xff);
 		saa_writeb(reg + 3, cl[i].position >> 8);
 		dprintk("clip: %s winbits=%02x pos=%d\n",
 			name,winbits,cl[i].position);
 		reg += 8;
 	}
 	for (; reg < 0x400; reg += 8) {
 		saa_writeb(reg+ 0, 0);
 		saa_writeb(reg + 1, 0);
 		saa_writeb(reg + 2, 0);
 		saa_writeb(reg + 3, 0);
 	}
 }
 static int clip_range(int val)
 {
 	if (val < 0)
 		val = 0;
 	return val;
 }
 /* Sort into smallest position first order */
 static int cliplist_cmp(const void *a, const void *b)
 {
 	const struct cliplist *cla = a;
 	const struct cliplist *clb = b;
 	if (cla->position < clb->position)
 		return -1;
 	if (cla->position > clb->position)
 		return 1;
 	return 0;
 }
 static int setup_clipping(struct saa7134_dev *dev, struct v4l2_clip *clips,
 			  int nclips, int interlace)
 {
 	struct cliplist col[16], row[16];
 	int cols = 0, rows = 0, i;
 	int div = interlace ? 2 : 1;
 	memset(col, 0, sizeof(col));
 	memset(row, 0, sizeof(row));
 	for (i = 0; i < nclips && i < 8; i++) {
 		col[cols].position = clip_range(clips[i].c.left);
 		col[cols].enable   = (1 << i);
 		cols++;
 		col[cols].position = clip_range(clips[i].c.left+clips[i].c.width);
 		col[cols].disable  = (1 << i);
 		cols++;
 		row[rows].position = clip_range(clips[i].c.top / div);
 		row[rows].enable   = (1 << i);
 		rows++;
 		row[rows].position = clip_range((clips[i].c.top + clips[i].c.height)
 						/ div);
 		row[rows].disable  = (1 << i);
 		rows++;
 	}
 	sort(col, cols, sizeof col[0], cliplist_cmp, NULL);
 	sort(row, rows, sizeof row[0], cliplist_cmp, NULL);
 	set_cliplist(dev,0x380,col,cols,"cols");
 	set_cliplist(dev,0x384,row,rows,"rows");
 	return 0;
 }
 static int verify_preview(struct saa7134_dev *dev, struct v4l2_window *win)
 {
 	enum v4l2_field field;
 	int maxw, maxh;
 	if (NULL == dev->ovbuf.base)
 		return -EINVAL;
 	if (NULL == dev->ovfmt)
 		return -EINVAL;
 	if (win->w.width < 48 || win->w.height <  32)
 		return -EINVAL;
 	if (win->clipcount > 2048)
 		return -EINVAL;
 	field = win->field;
 	maxw  = dev->crop_current.width;
 	maxh  = dev->crop_current.height;
 	if (V4L2_FIELD_ANY == field) {
 		field = (win->w.height > maxh/2)
 			? V4L2_FIELD_INTERLACED
 			: V4L2_FIELD_TOP;
 	}
 	switch (field) {
 	case V4L2_FIELD_TOP:
 	case V4L2_FIELD_BOTTOM:
 		maxh = maxh / 2;
 		break;
 	case V4L2_FIELD_INTERLACED:
 		break;
 	default:
 		return -EINVAL;
 	}
 	win->field = field;
 	if (win->w.width > maxw)
 		win->w.width = maxw;
 	if (win->w.height > maxh)
 		win->w.height = maxh;
 	return 0;
 }
 static int start_preview(struct saa7134_dev *dev, struct saa7134_fh *fh)
 {
 	unsigned long base,control,bpl;
 	int err;
 	err = verify_preview(dev,&fh->win);
 	if (0 != err)
 		return err;
 	dev->ovfield = fh->win.field;
 	dprintk("start_preview %dx%d+%d+%d %s field=%s\n",
 		fh->win.w.width,fh->win.w.height,
 		fh->win.w.left,fh->win.w.top,
 		dev->ovfmt->name,v4l2_field_names[dev->ovfield]);
 	/* setup window + clipping */
 	set_size(dev,TASK_B,fh->win.w.width,fh->win.w.height,
 		 V4L2_FIELD_HAS_BOTH(dev->ovfield));
 	setup_clipping(dev,fh->clips,fh->nclips,
 		       V4L2_FIELD_HAS_BOTH(dev->ovfield));
 	if (dev->ovfmt->yuv)
 		saa_andorb(SAA7134_DATA_PATH(TASK_B), 0x3f, 0x03);
 	else
 		saa_andorb(SAA7134_DATA_PATH(TASK_B), 0x3f, 0x01);
 	saa_writeb(SAA7134_OFMT_VIDEO_B, dev->ovfmt->pm | 0x20);
 	/* dma: setup channel 1 (= Video Task B) */
 	base  = (unsigned long)dev->ovbuf.base;
 	base += dev->ovbuf.fmt.bytesperline * fh->win.w.top;
 	base += dev->ovfmt->depth/8         * fh->win.w.left;
 	bpl   = dev->ovbuf.fmt.bytesperline;
 	control = SAA7134_RS_CONTROL_BURST_16;
 	if (dev->ovfmt->bswap)
 		control |= SAA7134_RS_CONTROL_BSWAP;
 	if (dev->ovfmt->wswap)
 		control |= SAA7134_RS_CONTROL_WSWAP;
 	if (V4L2_FIELD_HAS_BOTH(dev->ovfield)) {
 		saa_writel(SAA7134_RS_BA1(1),base);
 		saa_writel(SAA7134_RS_BA2(1),base+bpl);
 		saa_writel(SAA7134_RS_PITCH(1),bpl*2);
 		saa_writel(SAA7134_RS_CONTROL(1),control);
 	} else {
 		saa_writel(SAA7134_RS_BA1(1),base);
 		saa_writel(SAA7134_RS_BA2(1),base);
 		saa_writel(SAA7134_RS_PITCH(1),bpl);
 		saa_writel(SAA7134_RS_CONTROL(1),control);
 	}
 	/* start dma */
 	dev->ovenable = 1;
 	saa7134_set_dmabits(dev);
 	return 0;
 }
 static int stop_preview(struct saa7134_dev *dev, struct saa7134_fh *fh)
 {
 	dev->ovenable = 0;
 	saa7134_set_dmabits(dev);
 	return 0;
 }
 /* ------------------------------------------------------------------ */
 static int buffer_activate(struct saa7134_dev *dev,
 			   struct saa7134_buf *buf,
 			   struct saa7134_buf *next)
 {
 	unsigned long base,control,bpl;
 	unsigned long bpl_uv,lines_uv,base2,base3,tmp; /* planar */
 	dprintk("buffer_activate buf=%p\n",buf);
 	buf->vb.state = VIDEOBUF_ACTIVE;
 	buf->top_seen = 0;
 	set_size(dev,TASK_A,buf->vb.width,buf->vb.height,
 		 V4L2_FIELD_HAS_BOTH(buf->vb.field));
 	if (buf->fmt->yuv)
 		saa_andorb(SAA7134_DATA_PATH(TASK_A), 0x3f, 0x03);
 	else
 		saa_andorb(SAA7134_DATA_PATH(TASK_A), 0x3f, 0x01);
 	saa_writeb(SAA7134_OFMT_VIDEO_A, buf->fmt->pm);
 	/* DMA: setup channel 0 (= Video Task A0) */
 	base  = saa7134_buffer_base(buf);
 	if (buf->fmt->planar)
 		bpl = buf->vb.width;
 	else
 		bpl = (buf->vb.width * buf->fmt->depth) / 8;
 	control = SAA7134_RS_CONTROL_BURST_16 |
 		SAA7134_RS_CONTROL_ME |
 		(buf->pt->dma >> 12);
 	if (buf->fmt->bswap)
 		control |= SAA7134_RS_CONTROL_BSWAP;
 	if (buf->fmt->wswap)
 		control |= SAA7134_RS_CONTROL_WSWAP;
 	if (V4L2_FIELD_HAS_BOTH(buf->vb.field)) {
 		/* interlaced */
 		saa_writel(SAA7134_RS_BA1(0),base);
 		saa_writel(SAA7134_RS_BA2(0),base+bpl);
 		saa_writel(SAA7134_RS_PITCH(0),bpl*2);
 	} else {
 		/* non-interlaced */
 		saa_writel(SAA7134_RS_BA1(0),base);
 		saa_writel(SAA7134_RS_BA2(0),base);
 		saa_writel(SAA7134_RS_PITCH(0),bpl);
 	}
 	saa_writel(SAA7134_RS_CONTROL(0),control);
 	if (buf->fmt->planar) {
 		/* DMA: setup channel 4+5 (= planar task A) */
 		bpl_uv   = bpl >> buf->fmt->hshift;
 		lines_uv = buf->vb.height >> buf->fmt->vshift;
 		base2    = base + bpl * buf->vb.height;
 		base3    = base2 + bpl_uv * lines_uv;
 		if (buf->fmt->uvswap)
 			tmp = base2, base2 = base3, base3 = tmp;
 		dprintk("uv: bpl=%ld lines=%ld base2/3=%ld/%ld\n",
 			bpl_uv,lines_uv,base2,base3);
 		if (V4L2_FIELD_HAS_BOTH(buf->vb.field)) {
 			/* interlaced */
 			saa_writel(SAA7134_RS_BA1(4),base2);
 			saa_writel(SAA7134_RS_BA2(4),base2+bpl_uv);
 			saa_writel(SAA7134_RS_PITCH(4),bpl_uv*2);
 			saa_writel(SAA7134_RS_BA1(5),base3);
 			saa_writel(SAA7134_RS_BA2(5),base3+bpl_uv);
 			saa_writel(SAA7134_RS_PITCH(5),bpl_uv*2);
 		} else {
 			/* non-interlaced */
 			saa_writel(SAA7134_RS_BA1(4),base2);
 			saa_writel(SAA7134_RS_BA2(4),base2);
 			saa_writel(SAA7134_RS_PITCH(4),bpl_uv);
 			saa_writel(SAA7134_RS_BA1(5),base3);
 			saa_writel(SAA7134_RS_BA2(5),base3);
 			saa_writel(SAA7134_RS_PITCH(5),bpl_uv);
 		}
 		saa_writel(SAA7134_RS_CONTROL(4),control);
 		saa_writel(SAA7134_RS_CONTROL(5),control);
 	}
 	/* start DMA */
 	saa7134_set_dmabits(dev);
 	mod_timer(&dev->video_q.timeout, jiffies+BUFFER_TIMEOUT);
 	return 0;
 }
 static int buffer_prepare(struct videobuf_queue *q,
 			  struct videobuf_buffer *vb,
 			  enum v4l2_field field)
 {
 	struct saa7134_fh *fh = q->priv_data;
 	struct saa7134_dev *dev = fh->dev;
 	struct saa7134_buf *buf = container_of(vb,struct saa7134_buf,vb);
 	unsigned int size;
 	int err;
 	/* sanity checks */
 	if (NULL == fh->fmt)
 		return -EINVAL;
 	if (fh->width    < 48 ||
 	    fh->height   < 32 ||
 	    fh->width/4  > dev->crop_current.width  ||
 	    fh->height/4 > dev->crop_current.height ||
 	    fh->width    > dev->crop_bounds.width  ||
 	    fh->height   > dev->crop_bounds.height)
 		return -EINVAL;
 	size = (fh->width * fh->height * fh->fmt->depth) >> 3;
 	if (0 != buf->vb.baddr  &&  buf->vb.bsize < size)
 		return -EINVAL;
 	dprintk("buffer_prepare [%d,size=%dx%d,bytes=%d,fields=%s,%s]\n",
 		vb->i,fh->width,fh->height,size,v4l2_field_names[field],
 		fh->fmt->name);
 	if (buf->vb.width  != fh->width  ||
 	    buf->vb.height != fh->height ||
 	    buf->vb.size   != size       ||
 	    buf->vb.field  != field      ||
 	    buf->fmt       != fh->fmt) {
 		saa7134_dma_free(q,buf);
 	}
 	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 		struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
 		buf->vb.width  = fh->width;
 		buf->vb.height = fh->height;
 		buf->vb.size   = size;
 		buf->vb.field  = field;
 		buf->fmt       = fh->fmt;
 		buf->pt        = &fh->pt_cap;
 		err = videobuf_iolock(q,&buf->vb,&dev->ovbuf);
 		if (err)
 			goto oops;
 		err = saa7134_pgtable_build(dev->pci,buf->pt,
 					    dma->sglist,
 					    dma->sglen,
 					    saa7134_buffer_startpage(buf));
 		if (err)
 			goto oops;
 	}
 	buf->vb.state = VIDEOBUF_PREPARED;
 	buf->activate = buffer_activate;
 	return 0;
  oops:
 	saa7134_dma_free(q,buf);
 	return err;
 }
 static int
 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
 {
 	struct saa7134_fh *fh = q->priv_data;
 	*size = fh->fmt->depth * fh->width * fh->height >> 3;
 	if (0 == *count)
 		*count = gbuffers;
 	*count = saa7134_buffer_count(*size,*count);
 	return 0;
 }
 static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
 {
 	struct saa7134_fh *fh = q->priv_data;
 	struct saa7134_buf *buf = container_of(vb,struct saa7134_buf,vb);
 	saa7134_buffer_queue(fh->dev,&fh->dev->video_q,buf);
 }
 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
 {
 	struct saa7134_buf *buf = container_of(vb,struct saa7134_buf,vb);
 	saa7134_dma_free(q,buf);
 }
 static struct videobuf_queue_ops video_qops = {
 	.buf_setup    = buffer_setup,
 	.buf_prepare  = buffer_prepare,
 	.buf_queue    = buffer_queue,
 	.buf_release  = buffer_release,
 };
 /* ------------------------------------------------------------------ */
 int saa7134_g_ctrl_internal(struct saa7134_dev *dev, struct saa7134_fh *fh, struct v4l2_control *c)
 {
 	const struct v4l2_queryctrl* ctrl;
 	ctrl = ctrl_by_id(c->id);
 	if (NULL == ctrl)
 		return -EINVAL;
 	switch (c->id) {
 	case V4L2_CID_BRIGHTNESS:
 		c->value = dev->ctl_bright;
 		break;
 	case V4L2_CID_HUE:
 		c->value = dev->ctl_hue;
 		break;
 	case V4L2_CID_CONTRAST:
 		c->value = dev->ctl_contrast;
 		break;
 	case V4L2_CID_SATURATION:
 		c->value = dev->ctl_saturation;
 		break;
 	case V4L2_CID_AUDIO_MUTE:
 		c->value = dev->ctl_mute;
 		break;
 	case V4L2_CID_AUDIO_VOLUME:
 		c->value = dev->ctl_volume;
 		break;
 	case V4L2_CID_PRIVATE_INVERT:
 		c->value = dev->ctl_invert;
 		break;
 	case V4L2_CID_HFLIP:
 		c->value = dev->ctl_mirror;
 		break;
 	case V4L2_CID_PRIVATE_Y_EVEN:
 		c->value = dev->ctl_y_even;
 		break;
 	case V4L2_CID_PRIVATE_Y_ODD:
 		c->value = dev->ctl_y_odd;
 		break;
 	case V4L2_CID_PRIVATE_AUTOMUTE:
 		c->value = dev->ctl_automute;
 		break;
 	default:
 		return -EINVAL;
 	}
 	return 0;
 }
 EXPORT_SYMBOL_GPL(saa7134_g_ctrl_internal);
 static int saa7134_g_ctrl(struct file *file, void *priv, struct v4l2_control *c)
 {
 	struct saa7134_fh *fh = priv;
 	return saa7134_g_ctrl_internal(fh->dev, fh, c);
 }
 int saa7134_s_ctrl_internal(struct saa7134_dev *dev,  struct saa7134_fh *fh, struct v4l2_control *c)
 {
 	const struct v4l2_queryctrl* ctrl;
 	unsigned long flags;
 	int restart_overlay = 0;
 	int err;
 	/* When called from the empress code fh == NULL.
 	   That needs to be fixed somehow, but for now this is
 	   good enough. */
 	if (fh) {
 		err = v4l2_prio_check(&dev->prio, &fh->prio);
 		if (0 != err)
 			return err;
 	}
 	err = -EINVAL;
 	mutex_lock(&dev->lock);
 	ctrl = ctrl_by_id(c->id);
 	if (NULL == ctrl)
 		goto error;
 	dprintk("set_control name=%s val=%d\n",ctrl->name,c->value);
 	switch (ctrl->type) {
 	case V4L2_CTRL_TYPE_BOOLEAN:
 	case V4L2_CTRL_TYPE_MENU:
 	case V4L2_CTRL_TYPE_INTEGER:
 		if (c->value < ctrl->minimum)
 			c->value = ctrl->minimum;
 		if (c->value > ctrl->maximum)
 			c->value = ctrl->maximum;
 		break;
 	default:
 		/* nothing */;
 	};
 	switch (c->id) {
 	case V4L2_CID_BRIGHTNESS:
 		dev->ctl_bright = c->value;
 		saa_writeb(SAA7134_DEC_LUMA_BRIGHT, dev->ctl_bright);
 		break;
 	case V4L2_CID_HUE:
 		dev->ctl_hue = c->value;
 		saa_writeb(SAA7134_DEC_CHROMA_HUE, dev->ctl_hue);
 		break;
 	case V4L2_CID_CONTRAST:
 		dev->ctl_contrast = c->value;
 		saa_writeb(SAA7134_DEC_LUMA_CONTRAST,
 			   dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast);
 		break;
 	case V4L2_CID_SATURATION:
 		dev->ctl_saturation = c->value;
 		saa_writeb(SAA7134_DEC_CHROMA_SATURATION,
 			   dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation);
 		break;
 	case V4L2_CID_AUDIO_MUTE:
 		dev->ctl_mute = c->value;
 		saa7134_tvaudio_setmute(dev);
 		break;
 	case V4L2_CID_AUDIO_VOLUME:
 		dev->ctl_volume = c->value;
 		saa7134_tvaudio_setvolume(dev,dev->ctl_volume);
 		break;
 	case V4L2_CID_PRIVATE_INVERT:
 		dev->ctl_invert = c->value;
 		saa_writeb(SAA7134_DEC_LUMA_CONTRAST,
 			   dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast);
 		saa_writeb(SAA7134_DEC_CHROMA_SATURATION,
 			   dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation);
 		break;
 	case V4L2_CID_HFLIP:
 		dev->ctl_mirror = c->value;
 		restart_overlay = 1;
 		break;
 	case V4L2_CID_PRIVATE_Y_EVEN:
 		dev->ctl_y_even = c->value;
 		restart_overlay = 1;
 		break;
 	case V4L2_CID_PRIVATE_Y_ODD:
 		dev->ctl_y_odd = c->value;
 		restart_overlay = 1;
 		break;
 	case V4L2_CID_PRIVATE_AUTOMUTE:
 	{
 		struct v4l2_priv_tun_config tda9887_cfg;
 		tda9887_cfg.tuner = TUNER_TDA9887;
 		tda9887_cfg.priv = &dev->tda9887_conf;
 		dev->ctl_automute = c->value;
 		if (dev->tda9887_conf) {
 			if (dev->ctl_automute)
 				dev->tda9887_conf |= TDA9887_AUTOMUTE;
 			else
 				dev->tda9887_conf &= ~TDA9887_AUTOMUTE;
 			saa_call_all(dev, tuner, s_config, &tda9887_cfg);
 		}
 		break;
 	}
 	default:
 		goto error;
 	}
 	if (restart_overlay && fh && res_check(fh, RESOURCE_OVERLAY)) {
 		spin_lock_irqsave(&dev->slock,flags);
 		stop_preview(dev,fh);
 		start_preview(dev,fh);
 		spin_unlock_irqrestore(&dev->slock,flags);
 	}
 	err = 0;
 error:
 	mutex_unlock(&dev->lock);
 	return err;
 }
 EXPORT_SYMBOL_GPL(saa7134_s_ctrl_internal);
 static int saa7134_s_ctrl(struct file *file, void *f, struct v4l2_control *c)
 {
 	struct saa7134_fh *fh = f;
 	return saa7134_s_ctrl_internal(fh->dev, fh, c);
 }
 /* ------------------------------------------------------------------ */
 static struct videobuf_queue* saa7134_queue(struct saa7134_fh *fh)
 {
 	struct videobuf_queue* q = NULL;
 	switch (fh->type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		q = &fh->cap;
 		break;
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		q = &fh->vbi;
 		break;
 	default:
 		BUG();
 	}
 	return q;
 }
 static int saa7134_resource(struct saa7134_fh *fh)
 {
 	if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 		return RESOURCE_VIDEO;
 	if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
 		return RESOURCE_VBI;
 	BUG();
 	return 0;
 }
 static int video_open(struct file *file)
 {
 	int minor = video_devdata(file)->minor;
 	struct saa7134_dev *dev;
 	struct saa7134_fh *fh;
 	enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 	int radio = 0;
 	mutex_lock(&saa7134_devlist_lock);
 	list_for_each_entry(dev, &saa7134_devlist, devlist) {
 		if (dev->video_dev && (dev->video_dev->minor == minor))
 			goto found;
 		if (dev->radio_dev && (dev->radio_dev->minor == minor)) {
 			radio = 1;
 			goto found;
 		}
 		if (dev->vbi_dev && (dev->vbi_dev->minor == minor)) {
 			type = V4L2_BUF_TYPE_VBI_CAPTURE;
 			goto found;
 		}
 	}
 	mutex_unlock(&saa7134_devlist_lock);
 	return -ENODEV;
 found:
 	mutex_unlock(&saa7134_devlist_lock);
 	dprintk("open minor=%d radio=%d type=%s\n",minor,radio,
 		v4l2_type_names[type]);
 	/* allocate + initialize per filehandle data */
 	fh = kzalloc(sizeof(*fh),GFP_KERNEL);
 	if (NULL == fh)
 		return -ENOMEM;
 	file->private_data = fh;
 	fh->dev      = dev;
 	fh->radio    = radio;
 	fh->type     = type;
 	fh->fmt      = format_by_fourcc(V4L2_PIX_FMT_BGR24);
 	fh->width    = 720;
 	fh->height   = 576;
 	v4l2_prio_open(&dev->prio,&fh->prio);
 	videobuf_queue_sg_init(&fh->cap, &video_qops,
 			    &dev->pci->dev, &dev->slock,
 			    V4L2_BUF_TYPE_VIDEO_CAPTURE,
 			    V4L2_FIELD_INTERLACED,
 			    sizeof(struct saa7134_buf),
 			    fh);
 	videobuf_queue_sg_init(&fh->vbi, &saa7134_vbi_qops,
 			    &dev->pci->dev, &dev->slock,
 			    V4L2_BUF_TYPE_VBI_CAPTURE,
 			    V4L2_FIELD_SEQ_TB,
 			    sizeof(struct saa7134_buf),
 			    fh);
 	saa7134_pgtable_alloc(dev->pci,&fh->pt_cap);
 	saa7134_pgtable_alloc(dev->pci,&fh->pt_vbi);
 	if (fh->radio) {
 		/* switch to radio mode */
 		saa7134_tvaudio_setinput(dev,&card(dev).radio);
 		saa_call_all(dev, tuner, s_radio);
 	} else {
 		/* switch to video/vbi mode */
 		video_mux(dev,dev->ctl_input);
 	}
 	return 0;
 }
 static ssize_t
 video_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
 {
 	struct saa7134_fh *fh = file->private_data;
 	switch (fh->type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		if (res_locked(fh->dev,RESOURCE_VIDEO))
 			return -EBUSY;
 		return videobuf_read_one(saa7134_queue(fh),
 					 data, count, ppos,
 					 file->f_flags & O_NONBLOCK);
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		if (!res_get(fh->dev,fh,RESOURCE_VBI))
 			return -EBUSY;
 		return videobuf_read_stream(saa7134_queue(fh),
 					    data, count, ppos, 1,
 					    file->f_flags & O_NONBLOCK);
 		break;
 	default:
 		BUG();
 		return 0;
 	}
 }
 static unsigned int
 video_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct saa7134_fh *fh = file->private_data;
 	struct videobuf_buffer *buf = NULL;
 	if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)
 		return videobuf_poll_stream(file, &fh->vbi, wait);
 	if (res_check(fh,RESOURCE_VIDEO)) {
 		if (!list_empty(&fh->cap.stream))
 			buf = list_entry(fh->cap.stream.next, struct videobuf_buffer, stream);
 	} else {
 		mutex_lock(&fh->cap.vb_lock);
 		if (UNSET == fh->cap.read_off) {
 			/* need to capture a new frame */
 			if (res_locked(fh->dev,RESOURCE_VIDEO))
 				goto err;
 			if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,fh->cap.field))
 				goto err;
 			fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
 			fh->cap.read_off = 0;
 		}
 		mutex_unlock(&fh->cap.vb_lock);
 		buf = fh->cap.read_buf;
 	}
 	if (!buf)
 		return POLLERR;
 	poll_wait(file, &buf->done, wait);
 	if (buf->state == VIDEOBUF_DONE ||
 	    buf->state == VIDEOBUF_ERROR)
 		return POLLIN|POLLRDNORM;
 	return 0;
 err:
 	mutex_unlock(&fh->cap.vb_lock);
 	return POLLERR;
 }
 static int video_release(struct file *file)
 {
 	struct saa7134_fh  *fh  = file->private_data;
 	struct saa7134_dev *dev = fh->dev;
 	unsigned long flags;
 	/* turn off overlay */
 	if (res_check(fh, RESOURCE_OVERLAY)) {
 		spin_lock_irqsave(&dev->slock,flags);
 		stop_preview(dev,fh);
 		spin_unlock_irqrestore(&dev->slock,flags);
 		res_free(dev,fh,RESOURCE_OVERLAY);
 	}
 	/* stop video capture */
 	if (res_check(fh, RESOURCE_VIDEO)) {
 		videobuf_streamoff(&fh->cap);
 		res_free(dev,fh,RESOURCE_VIDEO);
 	}
 	if (fh->cap.read_buf) {
 		buffer_release(&fh->cap,fh->cap.read_buf);
 		kfree(fh->cap.read_buf);
 	}
 	/* stop vbi capture */
 	if (res_check(fh, RESOURCE_VBI)) {
 		videobuf_stop(&fh->vbi);
 		res_free(dev,fh,RESOURCE_VBI);
 	}
 	/* ts-capture will not work in planar mode, so turn it off Hac: 04.05*/
 	saa_andorb(SAA7134_OFMT_VIDEO_A, 0x1f, 0);
 	saa_andorb(SAA7134_OFMT_VIDEO_B, 0x1f, 0);
 	saa_andorb(SAA7134_OFMT_DATA_A, 0x1f, 0);
 	saa_andorb(SAA7134_OFMT_DATA_B, 0x1f, 0);
 	saa_call_all(dev, core, s_standby, 0);
 	/* free stuff */
 	videobuf_mmap_free(&fh->cap);
 	videobuf_mmap_free(&fh->vbi);
 	saa7134_pgtable_free(dev->pci,&fh->pt_cap);
 	saa7134_pgtable_free(dev->pci,&fh->pt_vbi);
 	v4l2_prio_close(&dev->prio,&fh->prio);
 	file->private_data = NULL;
 	kfree(fh);
 	return 0;
 }
 static int video_mmap(struct file *file, struct vm_area_struct * vma)
 {
 	struct saa7134_fh *fh = file->private_data;
 	return videobuf_mmap_mapper(saa7134_queue(fh), vma);
 }
 /* ------------------------------------------------------------------ */
 static int saa7134_try_get_set_fmt_vbi_cap(struct file *file, void *priv,
 						struct v4l2_format *f)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	struct saa7134_tvnorm *norm = dev->tvnorm;
 	f->fmt.vbi.sampling_rate = 6750000 * 4;
 	f->fmt.vbi.samples_per_line = 2048 /* VBI_LINE_LENGTH */;
 	f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
 	f->fmt.vbi.offset = 64 * 4;
 	f->fmt.vbi.start[0] = norm->vbi_v_start_0;
 	f->fmt.vbi.count[0] = norm->vbi_v_stop_0 - norm->vbi_v_start_0 +1;
 	f->fmt.vbi.start[1] = norm->vbi_v_start_1;
 	f->fmt.vbi.count[1] = f->fmt.vbi.count[0];
 	f->fmt.vbi.flags = 0; /* VBI_UNSYNC VBI_INTERLACED */
 	return 0;
 }
 static int saa7134_g_fmt_vid_cap(struct file *file, void *priv,
 				struct v4l2_format *f)
 {
 	struct saa7134_fh *fh = priv;
 	f->fmt.pix.width        = fh->width;
 	f->fmt.pix.height       = fh->height;
 	f->fmt.pix.field        = fh->cap.field;
 	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
 	f->fmt.pix.bytesperline =
 		(f->fmt.pix.width * fh->fmt->depth) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	return 0;
 }
 static int saa7134_g_fmt_vid_overlay(struct file *file, void *priv,
 				struct v4l2_format *f)
 {
 	struct saa7134_fh *fh = priv;
 	if (saa7134_no_overlay > 0) {
 		printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
 		return -EINVAL;
 	}
 	f->fmt.win = fh->win;
 	return 0;
 }
 static int saa7134_try_fmt_vid_cap(struct file *file, void *priv,
 						struct v4l2_format *f)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	struct saa7134_format *fmt;
 	enum v4l2_field field;
 	unsigned int maxw, maxh;
 	fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 	if (NULL == fmt)
 		return -EINVAL;
 	field = f->fmt.pix.field;
 	maxw  = min(dev->crop_current.width*4,  dev->crop_bounds.width);
 	maxh  = min(dev->crop_current.height*4, dev->crop_bounds.height);
 	if (V4L2_FIELD_ANY == field) {
 		field = (f->fmt.pix.height > maxh/2)
 			? V4L2_FIELD_INTERLACED
 			: V4L2_FIELD_BOTTOM;
 	}
 	switch (field) {
 	case V4L2_FIELD_TOP:
 	case V4L2_FIELD_BOTTOM:
 		maxh = maxh / 2;
 		break;
 	case V4L2_FIELD_INTERLACED:
 		break;
 	default:
 		return -EINVAL;
 	}
 	f->fmt.pix.field = field;
 	if (f->fmt.pix.width  < 48)
 		f->fmt.pix.width  = 48;
 	if (f->fmt.pix.height < 32)
 		f->fmt.pix.height = 32;
 	if (f->fmt.pix.width > maxw)
 		f->fmt.pix.width = maxw;
 	if (f->fmt.pix.height > maxh)
 		f->fmt.pix.height = maxh;
 	f->fmt.pix.width &= ~0x03;
 	f->fmt.pix.bytesperline =
 		(f->fmt.pix.width * fmt->depth) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	return 0;
 }
 static int saa7134_try_fmt_vid_overlay(struct file *file, void *priv,
 						struct v4l2_format *f)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	if (saa7134_no_overlay > 0) {
 		printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
 		return -EINVAL;
 	}
 	return verify_preview(dev, &f->fmt.win);
 }
 static int saa7134_s_fmt_vid_cap(struct file *file, void *priv,
 					struct v4l2_format *f)
 {
 	struct saa7134_fh *fh = priv;
 	int err;
 	err = saa7134_try_fmt_vid_cap(file, priv, f);
 	if (0 != err)
 		return err;
 	fh->fmt       = format_by_fourcc(f->fmt.pix.pixelformat);
 	fh->width     = f->fmt.pix.width;
 	fh->height    = f->fmt.pix.height;
 	fh->cap.field = f->fmt.pix.field;
 	return 0;
 }
 static int saa7134_s_fmt_vid_overlay(struct file *file, void *priv,
 					struct v4l2_format *f)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	int err;
 	unsigned long flags;
 	if (saa7134_no_overlay > 0) {
 		printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
 		return -EINVAL;
 	}
 	err = verify_preview(dev, &f->fmt.win);
 	if (0 != err)
 		return err;
 	mutex_lock(&dev->lock);
 	fh->win    = f->fmt.win;
 	fh->nclips = f->fmt.win.clipcount;
 	if (fh->nclips > 8)
 		fh->nclips = 8;
 	if (copy_from_user(fh->clips, f->fmt.win.clips,
 			   sizeof(struct v4l2_clip)*fh->nclips)) {
 		mutex_unlock(&dev->lock);
 		return -EFAULT;
 	}
 	if (res_check(fh, RESOURCE_OVERLAY)) {
 		spin_lock_irqsave(&dev->slock, flags);
 		stop_preview(dev, fh);
 		start_preview(dev, fh);
 		spin_unlock_irqrestore(&dev->slock, flags);
 	}
 	mutex_unlock(&dev->lock);
 	return 0;
 }
 int saa7134_queryctrl(struct file *file, void *priv, struct v4l2_queryctrl *c)
 {
 	const struct v4l2_queryctrl *ctrl;
 	if ((c->id <  V4L2_CID_BASE ||
 	     c->id >= V4L2_CID_LASTP1) &&
 	    (c->id <  V4L2_CID_PRIVATE_BASE ||
 	     c->id >= V4L2_CID_PRIVATE_LASTP1))
 		return -EINVAL;
 	ctrl = ctrl_by_id(c->id);
 	*c = (NULL != ctrl) ? *ctrl : no_ctrl;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(saa7134_queryctrl);
 static int saa7134_enum_input(struct file *file, void *priv,
 					struct v4l2_input *i)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	unsigned int n;
 	n = i->index;
 	if (n >= SAA7134_INPUT_MAX)
 		return -EINVAL;
 	if (NULL == card_in(dev, i->index).name)
 		return -EINVAL;
 	memset(i, 0, sizeof(*i));
 	i->index = n;
 	i->type  = V4L2_INPUT_TYPE_CAMERA;
 	strcpy(i->name, card_in(dev, n).name);
 	if (card_in(dev, n).tv)
 		i->type = V4L2_INPUT_TYPE_TUNER;
 	i->audioset = 1;
 	if (n == dev->ctl_input) {
 		int v1 = saa_readb(SAA7134_STATUS_VIDEO1);
 		int v2 = saa_readb(SAA7134_STATUS_VIDEO2);
 		if (0 != (v1 & 0x40))
 			i->status |= V4L2_IN_ST_NO_H_LOCK;
 		if (0 != (v2 & 0x40))
 			i->status |= V4L2_IN_ST_NO_SYNC;
 		if (0 != (v2 & 0x0e))
 			i->status |= V4L2_IN_ST_MACROVISION;
 	}
 	i->std = SAA7134_NORMS;
 	return 0;
 }
 static int saa7134_g_input(struct file *file, void *priv, unsigned int *i)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	*i = dev->ctl_input;
 	return 0;
 }
 static int saa7134_s_input(struct file *file, void *priv, unsigned int i)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	int err;
 	err = v4l2_prio_check(&dev->prio, &fh->prio);
 	if (0 != err)
 		return err;
 	if (i < 0  ||  i >= SAA7134_INPUT_MAX)
 		return -EINVAL;
 	if (NULL == card_in(dev, i).name)
 		return -EINVAL;
 	mutex_lock(&dev->lock);
 	video_mux(dev, i);
 	mutex_unlock(&dev->lock);
 	return 0;
 }
 static int saa7134_querycap(struct file *file, void  *priv,
 					struct v4l2_capability *cap)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	unsigned int tuner_type = dev->tuner_type;
 	strcpy(cap->driver, "saa7134");
 	strlcpy(cap->card, saa7134_boards[dev->board].name,
 		sizeof(cap->card));
 	sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
 	cap->version = SAA7134_VERSION_CODE;
 	cap->capabilities =
 		V4L2_CAP_VIDEO_CAPTURE |
 		V4L2_CAP_VBI_CAPTURE |
 		V4L2_CAP_READWRITE |
 		V4L2_CAP_STREAMING |
 		V4L2_CAP_TUNER;
 	if (saa7134_no_overlay <= 0)
 		cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
 	if ((tuner_type == TUNER_ABSENT) || (tuner_type == UNSET))
 		cap->capabilities &= ~V4L2_CAP_TUNER;
 		return 0;
 }
 int saa7134_s_std_internal(struct saa7134_dev *dev, struct saa7134_fh *fh, v4l2_std_id *id)
 {
 	unsigned long flags;
 	unsigned int i;
 	v4l2_std_id fixup;
 	int err;
 	/* When called from the empress code fh == NULL.
 	   That needs to be fixed somehow, but for now this is
 	   good enough. */
 	if (fh) {
 		err = v4l2_prio_check(&dev->prio, &fh->prio);
 		if (0 != err)
 			return err;
 	} else if (res_locked(dev, RESOURCE_OVERLAY)) {
 		/* Don't change the std from the mpeg device
 		   if overlay is active. */
 		return -EBUSY;
 	}
 	for (i = 0; i < TVNORMS; i++)
 		if (*id == tvnorms[i].id)
 			break;
 	if (i == TVNORMS)
 		for (i = 0; i < TVNORMS; i++)
 			if (*id & tvnorms[i].id)
 				break;
 	if (i == TVNORMS)
 		return -EINVAL;
 	if ((*id & V4L2_STD_SECAM) && (secam[0] != '-')) {
 		if (secam[0] == 'L' || secam[0] == 'l') {
 			if (secam[1] == 'C' || secam[1] == 'c')
 				fixup = V4L2_STD_SECAM_LC;
 			else
 				fixup = V4L2_STD_SECAM_L;
 		} else {
 			if (secam[0] == 'D' || secam[0] == 'd')
 				fixup = V4L2_STD_SECAM_DK;
 			else
 				fixup = V4L2_STD_SECAM;
 		}
 		for (i = 0; i < TVNORMS; i++)
 			if (fixup == tvnorms[i].id)
 				break;
 	}
 	*id = tvnorms[i].id;
 	mutex_lock(&dev->lock);
 	if (fh && res_check(fh, RESOURCE_OVERLAY)) {
 		spin_lock_irqsave(&dev->slock, flags);
 		stop_preview(dev, fh);
 		spin_unlock_irqrestore(&dev->slock, flags);
 		set_tvnorm(dev, &tvnorms[i]);
 		spin_lock_irqsave(&dev->slock, flags);
 		start_preview(dev, fh);
 		spin_unlock_irqrestore(&dev->slock, flags);
 	} else
 		set_tvnorm(dev, &tvnorms[i]);
 	saa7134_tvaudio_do_scan(dev);
 	mutex_unlock(&dev->lock);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(saa7134_s_std_internal);
 static int saa7134_s_std(struct file *file, void *priv, v4l2_std_id *id)
 {
 	struct saa7134_fh *fh = priv;
 	return saa7134_s_std_internal(fh->dev, fh, id);
 }
 static int saa7134_g_std(struct file *file, void *priv, v4l2_std_id *id)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	*id = dev->tvnorm->id;
 	return 0;
 }
 static int saa7134_cropcap(struct file *file, void *priv,
 					struct v4l2_cropcap *cap)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 	    cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
 		return -EINVAL;
 	cap->bounds  = dev->crop_bounds;
 	cap->defrect = dev->crop_defrect;
 	cap->pixelaspect.numerator   = 1;
 	cap->pixelaspect.denominator = 1;
 	if (dev->tvnorm->id & V4L2_STD_525_60) {
 		cap->pixelaspect.numerator   = 11;
 		cap->pixelaspect.denominator = 10;
 	}
 	if (dev->tvnorm->id & V4L2_STD_625_50) {
 		cap->pixelaspect.numerator   = 54;
 		cap->pixelaspect.denominator = 59;
 	}
 	return 0;
 }
 static int saa7134_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
 {
 	struct saa7134_fh *fh = f;
 	struct saa7134_dev *dev = fh->dev;
 	if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 	    crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
 		return -EINVAL;
 	crop->c = dev->crop_current;
 	return 0;
 }
 static int saa7134_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
 {
 	struct saa7134_fh *fh = f;
 	struct saa7134_dev *dev = fh->dev;
 	struct v4l2_rect *b = &dev->crop_bounds;
 	if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 	    crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
 		return -EINVAL;
 	if (crop->c.height < 0)
 		return -EINVAL;
 	if (crop->c.width < 0)
 		return -EINVAL;
 	if (res_locked(fh->dev, RESOURCE_OVERLAY))
 		return -EBUSY;
 	if (res_locked(fh->dev, RESOURCE_VIDEO))
 		return -EBUSY;
 	if (crop->c.top < b->top)
 		crop->c.top = b->top;
 	if (crop->c.top > b->top + b->height)
 		crop->c.top = b->top + b->height;
 	if (crop->c.height > b->top - crop->c.top + b->height)
 		crop->c.height = b->top - crop->c.top + b->height;
 	if (crop->c.left < b->left)
 		crop->c.left = b->left;
 	if (crop->c.left > b->left + b->width)
 		crop->c.left = b->left + b->width;
 	if (crop->c.width > b->left - crop->c.left + b->width)
 		crop->c.width = b->left - crop->c.left + b->width;
 	dev->crop_current = crop->c;
 	return 0;
 }
 static int saa7134_g_tuner(struct file *file, void *priv,
 					struct v4l2_tuner *t)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	int n;
 	if (0 != t->index)
 		return -EINVAL;
 	memset(t, 0, sizeof(*t));
 	for (n = 0; n < SAA7134_INPUT_MAX; n++)
 		if (card_in(dev, n).tv)
 			break;
 	if (NULL != card_in(dev, n).name) {
 		strcpy(t->name, "Television");
 		t->type = V4L2_TUNER_ANALOG_TV;
 		t->capability = V4L2_TUNER_CAP_NORM |
 			V4L2_TUNER_CAP_STEREO |
 			V4L2_TUNER_CAP_LANG1 |
 			V4L2_TUNER_CAP_LANG2;
 		t->rangehigh = 0xffffffffUL;
 		t->rxsubchans = saa7134_tvaudio_getstereo(dev);
 		t->audmode = saa7134_tvaudio_rx2mode(t->rxsubchans);
 	}
 	if (0 != (saa_readb(SAA7134_STATUS_VIDEO1) & 0x03))
 		t->signal = 0xffff;
 	return 0;
 }
 static int saa7134_s_tuner(struct file *file, void *priv,
 					struct v4l2_tuner *t)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	int rx, mode, err;
 	err = v4l2_prio_check(&dev->prio, &fh->prio);
 	if (0 != err)
 		return err;
 	mode = dev->thread.mode;
 	if (UNSET == mode) {
 		rx   = saa7134_tvaudio_getstereo(dev);
 		mode = saa7134_tvaudio_rx2mode(t->rxsubchans);
 	}
 	if (mode != t->audmode)
 		dev->thread.mode = t->audmode;
 	return 0;
 }
 static int saa7134_g_frequency(struct file *file, void *priv,
 					struct v4l2_frequency *f)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
 	f->frequency = dev->ctl_freq;
 	return 0;
 }
 static int saa7134_s_frequency(struct file *file, void *priv,
 					struct v4l2_frequency *f)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	int err;
 	err = v4l2_prio_check(&dev->prio, &fh->prio);
 	if (0 != err)
 		return err;
 	if (0 != f->tuner)
 		return -EINVAL;
 	if (0 == fh->radio && V4L2_TUNER_ANALOG_TV != f->type)
 		return -EINVAL;
 	if (1 == fh->radio && V4L2_TUNER_RADIO != f->type)
 		return -EINVAL;
 	mutex_lock(&dev->lock);
 	dev->ctl_freq = f->frequency;
 	saa_call_all(dev, tuner, s_frequency, f);
 	saa7134_tvaudio_do_scan(dev);
 	mutex_unlock(&dev->lock);
 	return 0;
 }
 static int saa7134_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
 {
 	strcpy(a->name, "audio");
 	return 0;
 }
 static int saa7134_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
 {
 	return 0;
 }
 static int saa7134_g_priority(struct file *file, void *f, enum v4l2_priority *p)
 {
 	struct saa7134_fh *fh = f;
 	struct saa7134_dev *dev = fh->dev;
 	*p = v4l2_prio_max(&dev->prio);
 	return 0;
 }
 static int saa7134_s_priority(struct file *file, void *f,
 					enum v4l2_priority prio)
 {
 	struct saa7134_fh *fh = f;
 	struct saa7134_dev *dev = fh->dev;
 	return v4l2_prio_change(&dev->prio, &fh->prio, prio);
 }
 static int saa7134_enum_fmt_vid_cap(struct file *file, void  *priv,
 					struct v4l2_fmtdesc *f)
 {
 	if (f->index >= FORMATS)
 		return -EINVAL;
 	strlcpy(f->description, formats[f->index].name,
 		sizeof(f->description));
 	f->pixelformat = formats[f->index].fourcc;
 	return 0;
 }
 static int saa7134_enum_fmt_vid_overlay(struct file *file, void  *priv,
 					struct v4l2_fmtdesc *f)
 {
 	if (saa7134_no_overlay > 0) {
 		printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
 		return -EINVAL;
 	}
 	if ((f->index >= FORMATS) || formats[f->index].planar)
 		return -EINVAL;
 	strlcpy(f->description, formats[f->index].name,
 		sizeof(f->description));
 	f->pixelformat = formats[f->index].fourcc;
 	return 0;
 }
 static int saa7134_g_fbuf(struct file *file, void *f,
 				struct v4l2_framebuffer *fb)
 {
 	struct saa7134_fh *fh = f;
 	struct saa7134_dev *dev = fh->dev;
 	*fb = dev->ovbuf;
 	fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
 	return 0;
 }
 static int saa7134_s_fbuf(struct file *file, void *f,
 					struct v4l2_framebuffer *fb)
 {
 	struct saa7134_fh *fh = f;
 	struct saa7134_dev *dev = fh->dev;
 	struct saa7134_format *fmt;
 	if (!capable(CAP_SYS_ADMIN) &&
 	   !capable(CAP_SYS_RAWIO))
 		return -EPERM;
 	/* check args */
 	fmt = format_by_fourcc(fb->fmt.pixelformat);
 	if (NULL == fmt)
 		return -EINVAL;
 	/* ok, accept it */
 	dev->ovbuf = *fb;
 	dev->ovfmt = fmt;
 	if (0 == dev->ovbuf.fmt.bytesperline)
 		dev->ovbuf.fmt.bytesperline =
 			dev->ovbuf.fmt.width*fmt->depth/8;
 	return 0;
 }
 static int saa7134_overlay(struct file *file, void *f, unsigned int on)
 {
 	struct saa7134_fh *fh = f;
 	struct saa7134_dev *dev = fh->dev;
 	unsigned long flags;
 	if (on) {
 		if (saa7134_no_overlay > 0) {
 			dprintk("no_overlay\n");
 			return -EINVAL;
 		}
 		if (!res_get(dev, fh, RESOURCE_OVERLAY))
 			return -EBUSY;
 		spin_lock_irqsave(&dev->slock, flags);
 		start_preview(dev, fh);
 		spin_unlock_irqrestore(&dev->slock, flags);
 	}
 	if (!on) {
 		if (!res_check(fh, RESOURCE_OVERLAY))
 			return -EINVAL;
 		spin_lock_irqsave(&dev->slock, flags);
 		stop_preview(dev, fh);
 		spin_unlock_irqrestore(&dev->slock, flags);
 		res_free(dev, fh, RESOURCE_OVERLAY);
 	}
 	return 0;
 }
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
 {
 	struct saa7134_fh *fh = file->private_data;
 	return videobuf_cgmbuf(saa7134_queue(fh), mbuf, 8);
 }
 #endif
 static int saa7134_reqbufs(struct file *file, void *priv,
 					struct v4l2_requestbuffers *p)
 {
 	struct saa7134_fh *fh = priv;
 	return videobuf_reqbufs(saa7134_queue(fh), p);
 }
 static int saa7134_querybuf(struct file *file, void *priv,
 					struct v4l2_buffer *b)
 {
 	struct saa7134_fh *fh = priv;
 	return videobuf_querybuf(saa7134_queue(fh), b);
 }
 static int saa7134_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 {
 	struct saa7134_fh *fh = priv;
 	return videobuf_qbuf(saa7134_queue(fh), b);
 }
 static int saa7134_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
 {
 	struct saa7134_fh *fh = priv;
 	return videobuf_dqbuf(saa7134_queue(fh), b,
 				file->f_flags & O_NONBLOCK);
 }
 static int saa7134_streamon(struct file *file, void *priv,
 					enum v4l2_buf_type type)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	int res = saa7134_resource(fh);
 	if (!res_get(dev, fh, res))
 		return -EBUSY;
 	return videobuf_streamon(saa7134_queue(fh));
 }
 static int saa7134_streamoff(struct file *file, void *priv,
 					enum v4l2_buf_type type)
 {
 	int err;
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	int res = saa7134_resource(fh);
 	err = videobuf_streamoff(saa7134_queue(fh));
 	if (err < 0)
 		return err;
 	res_free(dev, fh, res);
 	return 0;
 }
 static int saa7134_g_parm(struct file *file, void *fh,
 				struct v4l2_streamparm *parm)
 {
 	return 0;
 }
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 static int vidioc_g_register (struct file *file, void *priv,
 			      struct v4l2_dbg_register *reg)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	if (!v4l2_chip_match_host(&reg->match))
 		return -EINVAL;
 	reg->val = saa_readb(reg->reg);
 	reg->size = 1;
 	return 0;
 }
 static int vidioc_s_register (struct file *file, void *priv,
 				struct v4l2_dbg_register *reg)
 {
 	struct saa7134_fh *fh = priv;
 	struct saa7134_dev *dev = fh->dev;
 	if (!v4l2_chip_match_host(&reg->match))
 		return -EINVAL;
 	saa_writeb(reg->reg&0xffffff, reg->val);
 	return 0;
 }
 #endif
 static int radio_querycap(struct file *file, void *priv,
 					struct v4l2_capability *cap)
 {
 	struct saa7134_fh *fh = file->private_data;
 	struct saa7134_dev *dev = fh->dev;
 	strcpy(cap->driver, "saa7134");
 	strlcpy(cap->card, saa7134_boards[dev->board].name, sizeof(cap->card));
 	sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
 	cap->version = SAA7134_VERSION_CODE;
 	cap->capabilities = V4L2_CAP_TUNER;
 	return 0;
 }
 static int radio_g_tuner(struct file *file, void *priv,
 					struct v4l2_tuner *t)
 {
 	struct saa7134_fh *fh = file->private_data;
 	struct saa7134_dev *dev = fh->dev;
 	if (0 != t->index)
 		return -EINVAL;
 	memset(t, 0, sizeof(*t));
 	strcpy(t->name, "Radio");
 	t->type = V4L2_TUNER_RADIO;
 	saa_call_all(dev, tuner, g_tuner, t);
 	if (dev->input->amux == TV) {
 		t->signal = 0xf800 - ((saa_readb(0x581) & 0x1f) << 11);
 		t->rxsubchans = (saa_readb(0x529) & 0x08) ?
 				V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
 	}
 	return 0;
 }
 static int radio_s_tuner(struct file *file, void *priv,
 					struct v4l2_tuner *t)
 {
 	struct saa7134_fh *fh = file->private_data;
 	struct saa7134_dev *dev = fh->dev;
 	if (0 != t->index)
 		return -EINVAL;
 	saa_call_all(dev, tuner, s_tuner, t);
 	return 0;
 }
 static int radio_enum_input(struct file *file, void *priv,
 					struct v4l2_input *i)
 {
 	if (i->index != 0)
 		return -EINVAL;
 	strcpy(i->name, "Radio");
 	i->type = V4L2_INPUT_TYPE_TUNER;
 	return 0;
 }
 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
 {
 	*i = 0;
 	return 0;
 }
 static int radio_g_audio(struct file *file, void *priv,
 					struct v4l2_audio *a)
 {
 	memset(a, 0, sizeof(*a));
 	strcpy(a->name, "Radio");
 	return 0;
 }
 static int radio_s_audio(struct file *file, void *priv,
 					struct v4l2_audio *a)
 {
 	return 0;
 }
 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
 {
 	return 0;
 }
 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
 {
 	return 0;
 }
 static int radio_queryctrl(struct file *file, void *priv,
 					struct v4l2_queryctrl *c)
 {
 	const struct v4l2_queryctrl *ctrl;
 	if (c->id <  V4L2_CID_BASE ||
 	    c->id >= V4L2_CID_LASTP1)
 		return -EINVAL;
 	if (c->id == V4L2_CID_AUDIO_MUTE) {
 		ctrl = ctrl_by_id(c->id);
 		*c = *ctrl;
 	} else
 		*c = no_ctrl;
 	return 0;
 }
 static const struct v4l2_file_operations video_fops =
 {
 	.owner	  = THIS_MODULE,
 	.open	  = video_open,
 	.release  = video_release,
 	.read	  = video_read,
 	.poll     = video_poll,
 	.mmap	  = video_mmap,
 	.ioctl	  = video_ioctl2,
 };
 static const struct v4l2_ioctl_ops video_ioctl_ops = {
 	.vidioc_querycap		= saa7134_querycap,
 	.vidioc_enum_fmt_vid_cap	= saa7134_enum_fmt_vid_cap,
 	.vidioc_g_fmt_vid_cap		= saa7134_g_fmt_vid_cap,
 	.vidioc_try_fmt_vid_cap		= saa7134_try_fmt_vid_cap,
 	.vidioc_s_fmt_vid_cap		= saa7134_s_fmt_vid_cap,
 	.vidioc_enum_fmt_vid_overlay	= saa7134_enum_fmt_vid_overlay,
 	.vidioc_g_fmt_vid_overlay	= saa7134_g_fmt_vid_overlay,
 	.vidioc_try_fmt_vid_overlay	= saa7134_try_fmt_vid_overlay,
 	.vidioc_s_fmt_vid_overlay	= saa7134_s_fmt_vid_overlay,
 	.vidioc_g_fmt_vbi_cap		= saa7134_try_get_set_fmt_vbi_cap,
 	.vidioc_try_fmt_vbi_cap		= saa7134_try_get_set_fmt_vbi_cap,
 	.vidioc_s_fmt_vbi_cap		= saa7134_try_get_set_fmt_vbi_cap,
 	.vidioc_g_audio			= saa7134_g_audio,
 	.vidioc_s_audio			= saa7134_s_audio,
 	.vidioc_cropcap			= saa7134_cropcap,
 	.vidioc_reqbufs			= saa7134_reqbufs,
 	.vidioc_querybuf		= saa7134_querybuf,
 	.vidioc_qbuf			= saa7134_qbuf,
 	.vidioc_dqbuf			= saa7134_dqbuf,
 	.vidioc_s_std			= saa7134_s_std,
 	.vidioc_g_std			= saa7134_g_std,
 	.vidioc_enum_input		= saa7134_enum_input,
 	.vidioc_g_input			= saa7134_g_input,
 	.vidioc_s_input			= saa7134_s_input,
 	.vidioc_queryctrl		= saa7134_queryctrl,
 	.vidioc_g_ctrl			= saa7134_g_ctrl,
 	.vidioc_s_ctrl			= saa7134_s_ctrl,
 	.vidioc_streamon		= saa7134_streamon,
 	.vidioc_streamoff		= saa7134_streamoff,
 	.vidioc_g_tuner			= saa7134_g_tuner,
 	.vidioc_s_tuner			= saa7134_s_tuner,
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 	.vidiocgmbuf			= vidiocgmbuf,
 #endif
 	.vidioc_g_crop			= saa7134_g_crop,
 	.vidioc_s_crop			= saa7134_s_crop,
 	.vidioc_g_fbuf			= saa7134_g_fbuf,
 	.vidioc_s_fbuf			= saa7134_s_fbuf,
 	.vidioc_overlay			= saa7134_overlay,
 	.vidioc_g_priority		= saa7134_g_priority,
 	.vidioc_s_priority		= saa7134_s_priority,
 	.vidioc_g_parm			= saa7134_g_parm,
 	.vidioc_g_frequency		= saa7134_g_frequency,
 	.vidioc_s_frequency		= saa7134_s_frequency,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	.vidioc_g_register              = vidioc_g_register,
 	.vidioc_s_register              = vidioc_s_register,
 #endif
 };
 static const struct v4l2_file_operations radio_fops = {
 	.owner	  = THIS_MODULE,
 	.open	  = video_open,
 	.release  = video_release,
 	.ioctl	  = video_ioctl2,
 };
 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
 	.vidioc_querycap	= radio_querycap,
 	.vidioc_g_tuner		= radio_g_tuner,
 	.vidioc_enum_input	= radio_enum_input,
 	.vidioc_g_audio		= radio_g_audio,
 	.vidioc_s_tuner		= radio_s_tuner,
 	.vidioc_s_audio		= radio_s_audio,
 	.vidioc_s_input		= radio_s_input,
 	.vidioc_s_std		= radio_s_std,
 	.vidioc_queryctrl	= radio_queryctrl,
 	.vidioc_g_input		= radio_g_input,
 	.vidioc_g_ctrl		= saa7134_g_ctrl,
 	.vidioc_s_ctrl		= saa7134_s_ctrl,
 	.vidioc_g_frequency	= saa7134_g_frequency,
 	.vidioc_s_frequency	= saa7134_s_frequency,
 };
 /* ----------------------------------------------------------- */
 /* exported stuff                                              */
 struct video_device saa7134_video_template = {
 	.name				= "saa7134-video",
 	.fops				= &video_fops,
 	.ioctl_ops 			= &video_ioctl_ops,
 	.minor				= -1,
 	.tvnorms			= SAA7134_NORMS,
 	.current_norm			= V4L2_STD_PAL,
 };
 struct video_device saa7134_radio_template = {
 	.name			= "saa7134-radio",
 	.fops			= &radio_fops,
 	.ioctl_ops 		= &radio_ioctl_ops,
 	.minor			= -1,
 };
 int saa7134_video_init1(struct saa7134_dev *dev)
 {
 	/* sanitycheck insmod options */
 	if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
 		gbuffers = 2;
 	if (gbufsize < 0 || gbufsize > gbufsize_max)
 		gbufsize = gbufsize_max;
 	gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
 	/* put some sensible defaults into the data structures ... */
 	dev->ctl_bright     = ctrl_by_id(V4L2_CID_BRIGHTNESS)->default_value;
 	dev->ctl_contrast   = ctrl_by_id(V4L2_CID_CONTRAST)->default_value;
 	dev->ctl_hue        = ctrl_by_id(V4L2_CID_HUE)->default_value;
 	dev->ctl_saturation = ctrl_by_id(V4L2_CID_SATURATION)->default_value;
 	dev->ctl_volume     = ctrl_by_id(V4L2_CID_AUDIO_VOLUME)->default_value;
 	dev->ctl_mute       = 1; // ctrl_by_id(V4L2_CID_AUDIO_MUTE)->default_value;
 	dev->ctl_invert     = ctrl_by_id(V4L2_CID_PRIVATE_INVERT)->default_value;
 	dev->ctl_automute   = ctrl_by_id(V4L2_CID_PRIVATE_AUTOMUTE)->default_value;
 	if (dev->tda9887_conf && dev->ctl_automute)
 		dev->tda9887_conf |= TDA9887_AUTOMUTE;
 	dev->automute       = 0;
 	INIT_LIST_HEAD(&dev->video_q.queue);
 	init_timer(&dev->video_q.timeout);
 	dev->video_q.timeout.function = saa7134_buffer_timeout;
 	dev->video_q.timeout.data     = (unsigned long)(&dev->video_q);
 	dev->video_q.dev              = dev;
 	if (saa7134_boards[dev->board].video_out)
 		saa7134_videoport_init(dev);
 	return 0;
 }
 int saa7134_videoport_init(struct saa7134_dev *dev)
 {
 	/* enable video output */
 	int vo = saa7134_boards[dev->board].video_out;
 	int video_reg;
 	unsigned int vid_port_opts = saa7134_boards[dev->board].vid_port_opts;
 	/* Configure videoport */
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL0, video_out[vo][0]);
 	video_reg = video_out[vo][1];
 	if (vid_port_opts & SET_T_CODE_POLARITY_NON_INVERTED)
 		video_reg &= ~VP_T_CODE_P_INVERTED;
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL1, video_reg);
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL2, video_out[vo][2]);
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL4, video_out[vo][4]);
 	video_reg = video_out[vo][5];
 	if (vid_port_opts & SET_CLOCK_NOT_DELAYED)
 		video_reg &= ~VP_CLK_CTRL2_DELAYED;
 	if (vid_port_opts & SET_CLOCK_INVERTED)
 		video_reg |= VP_CLK_CTRL1_INVERTED;
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL5, video_reg);
 	video_reg = video_out[vo][6];
 	if (vid_port_opts & SET_VSYNC_OFF) {
 		video_reg &= ~VP_VS_TYPE_MASK;
 		video_reg |= VP_VS_TYPE_OFF;
 	}
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL6, video_reg);
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL7, video_out[vo][7]);
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL8, video_out[vo][8]);
 	/* Start videoport */
 	saa_writeb(SAA7134_VIDEO_PORT_CTRL3, video_out[vo][3]);
 	return 0;
 }
 int saa7134_video_init2(struct saa7134_dev *dev)
 {
 	/* init video hw */
 	set_tvnorm(dev,&tvnorms[0]);
 	video_mux(dev,0);
 	saa7134_tvaudio_setmute(dev);
 	saa7134_tvaudio_setvolume(dev,dev->ctl_volume);
 	return 0;
 }
 void saa7134_irq_video_signalchange(struct saa7134_dev *dev)
 {
 	static const char *st[] = {
 		"(no signal)", "NTSC", "PAL", "SECAM" };
 	u32 st1,st2;
 	st1 = saa_readb(SAA7134_STATUS_VIDEO1);
 	st2 = saa_readb(SAA7134_STATUS_VIDEO2);
 	dprintk("DCSDT: pll: %s, sync: %s, norm: %s\n",
 		(st1 & 0x40) ? "not locked" : "locked",
 		(st2 & 0x40) ? "no"         : "yes",
 		st[st1 & 0x03]);
 	dev->nosignal = (st1 & 0x40) || (st2 & 0x40)  || !(st2 & 0x1);
 	if (dev->nosignal) {
 		/* no video signal -> mute audio */
 		if (dev->ctl_automute)
 			dev->automute = 1;
 		saa7134_tvaudio_setmute(dev);
 	} else {
 		/* wake up tvaudio audio carrier scan thread */
 		saa7134_tvaudio_do_scan(dev);
 	}
 	if ((st2 & 0x80) && !noninterlaced && !dev->nosignal)
 		saa_clearb(SAA7134_SYNC_CTRL, 0x20);
 	else
 		saa_setb(SAA7134_SYNC_CTRL, 0x20);
 	if (dev->mops && dev->mops->signal_change)
 		dev->mops->signal_change(dev);
 }
 void saa7134_irq_video_done(struct saa7134_dev *dev, unsigned long status)
 {
 	enum v4l2_field field;
 	spin_lock(&dev->slock);
 	if (dev->video_q.curr) {
 		dev->video_fieldcount++;
 		field = dev->video_q.curr->vb.field;
 		if (V4L2_FIELD_HAS_BOTH(field)) {
 			/* make sure we have seen both fields */
 			if ((status & 0x10) == 0x00) {
 				dev->video_q.curr->top_seen = 1;
 				goto done;
 			}
 			if (!dev->video_q.curr->top_seen)
 				goto done;
 		} else if (field == V4L2_FIELD_TOP) {
 			if ((status & 0x10) != 0x10)
 				goto done;
 		} else if (field == V4L2_FIELD_BOTTOM) {
 			if ((status & 0x10) != 0x00)
 				goto done;
 		}
 		dev->video_q.curr->vb.field_count = dev->video_fieldcount;
 		saa7134_buffer_finish(dev,&dev->video_q,VIDEOBUF_DONE);
 	}
 	saa7134_buffer_next(dev,&dev->video_q);
  done:
 	spin_unlock(&dev->slock);
 }
 /* ----------------------------------------------------------- */
 /*
  * Local variables:
  * c-basic-offset: 8
  * End:
  */

drivers/media/video/saa7146.h

Diff comments View file @ 7e0a16f

 /*
     saa7146.h - definitions philips saa7146 based cards
     Copyright (C) 1999 Nathan Laredo (laredo@gnu.org)
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 #ifndef __SAA7146__
 #define __SAA7146__
 #define SAA7146_VERSION_CODE 0x000101
 #include <linux/types.h>
 #include <linux/wait.h>
-#include <linux/videodev.h>
 #ifndef O_NONCAP
 #define O_NONCAP	O_TRUNC
 #endif
 #define MAX_GBUFFERS	2
 #define FBUF_SIZE	0x190000
 #ifdef __KERNEL__
 struct saa7146_window
 {
 	int x, y;
 	ushort width, height;
 	ushort bpp, bpl;
 	ushort swidth, sheight;
 	short cropx, cropy;
 	ushort cropwidth, cropheight;
 	unsigned long vidadr;
 	int color_fmt;
 	ushort depth;
 };
 /*  Per-open data for handling multiple opens on one device */
 struct device_open
 {
 	int	     isopen;
 	int	     noncapturing;
 	struct saa7146  *dev;
 };
 #define MAX_OPENS 3
 struct saa7146
 {
 	struct video_device video_dev;
 	struct video_picture picture;
 	struct video_audio audio_dev;
 	struct video_info vidinfo;
 	int user;
 	int cap;
 	int capuser;
 	int irqstate;		/* irq routine is state driven */
 	int writemode;
 	int playmode;
 	unsigned int nr;
 	unsigned long irq;          /* IRQ used by SAA7146 card */
 	unsigned short id;
 	unsigned char revision;
 	unsigned char boardcfg[64];	/* 64 bytes of config from eeprom */
 	unsigned long saa7146_adr;   /* bus address of IO mem from PCI BIOS */
 	struct saa7146_window win;
 	unsigned char __iomem *saa7146_mem; /* pointer to mapped IO memory */
 	struct device_open open_data[MAX_OPENS];
 #define MAX_MARKS 16
 	/* for a/v sync */
 	int endmark[MAX_MARKS], endmarkhead, endmarktail;
 	u32 *dmaRPS1, *pageRPS1, *dmaRPS2, *pageRPS2, *dmavid1, *dmavid2,
 		*dmavid3, *dmaa1in, *dmaa1out, *dmaa2in, *dmaa2out,
 		*pagedebi, *pagevid1, *pagevid2, *pagevid3, *pagea1in,
 		*pagea1out, *pagea2in, *pagea2out;
 	wait_queue_head_t i2cq, debiq, audq, vidq;
 	u8  *vidbuf, *audbuf, *osdbuf, *dmadebi;
 	int audhead, vidhead, osdhead, audtail, vidtail, osdtail;
 	spinlock_t lock;	/* the device lock */
 };
 #endif
 #ifdef _ALPHA_SAA7146
 #define saawrite(dat,adr)    writel((dat), saa->saa7146_adr+(adr))
 #define saaread(adr)         readl(saa->saa7146_adr+(adr))
 #else
 #define saawrite(dat,adr)    writel((dat), saa->saa7146_mem+(adr))
 #define saaread(adr)         readl(saa->saa7146_mem+(adr))
 #endif
 #define saaand(dat,adr)      saawrite((dat) & saaread(adr), adr)
 #define saaor(dat,adr)       saawrite((dat) | saaread(adr), adr)
 #define saaaor(dat,mask,adr) saawrite((dat) | ((mask) & saaread(adr)), adr)
 /* bitmask of attached hardware found */
 #define SAA7146_UNKNOWN		0x00000000
 #define SAA7146_SAA7111		0x00000001
 #define SAA7146_SAA7121		0x00000002
 #define SAA7146_IBMMPEG		0x00000004
 #endif

drivers/media/video/v4l2-ioctl.c

Diff comments View file @ 7e0a16f

 /*
  * Video capture interface for Linux version 2
  *
  * A generic framework to process V4L2 ioctl commands.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version
  * 2 of the License, or (at your option) any later version.
  *
  * Authors:	Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
  *              Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
  */
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
 #define __OLD_VIDIOC_ /* To allow fixing old calls */
+#include <linux/videodev.h>
 #include <linux/videodev2.h>
 #ifdef CONFIG_VIDEO_V4L1
 #include <linux/videodev.h>
 #endif
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
 #include <media/v4l2-chip-ident.h>
 #define dbgarg(cmd, fmt, arg...) \
 		do {							\
 		    if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {		\
 			printk(KERN_DEBUG "%s: ",  vfd->name);		\
 			v4l_printk_ioctl(cmd);				\
 			printk(" " fmt,  ## arg);			\
 		    }							\
 		} while (0)
 #define dbgarg2(fmt, arg...) \
 		do {							\
 		    if (vfd->debug & V4L2_DEBUG_IOCTL_ARG)		\
 			printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);\
 		} while (0)
 struct std_descr {
 	v4l2_std_id std;
 	const char *descr;
 };
 static const struct std_descr standards[] = {
 	{ V4L2_STD_NTSC, 	"NTSC"      },
 	{ V4L2_STD_NTSC_M, 	"NTSC-M"    },
 	{ V4L2_STD_NTSC_M_JP, 	"NTSC-M-JP" },
 	{ V4L2_STD_NTSC_M_KR,	"NTSC-M-KR" },
 	{ V4L2_STD_NTSC_443, 	"NTSC-443"  },
 	{ V4L2_STD_PAL, 	"PAL"       },
 	{ V4L2_STD_PAL_BG, 	"PAL-BG"    },
 	{ V4L2_STD_PAL_B, 	"PAL-B"     },
 	{ V4L2_STD_PAL_B1, 	"PAL-B1"    },
 	{ V4L2_STD_PAL_G, 	"PAL-G"     },
 	{ V4L2_STD_PAL_H, 	"PAL-H"     },
 	{ V4L2_STD_PAL_I, 	"PAL-I"     },
 	{ V4L2_STD_PAL_DK, 	"PAL-DK"    },
 	{ V4L2_STD_PAL_D, 	"PAL-D"     },
 	{ V4L2_STD_PAL_D1, 	"PAL-D1"    },
 	{ V4L2_STD_PAL_K, 	"PAL-K"     },
 	{ V4L2_STD_PAL_M, 	"PAL-M"     },
 	{ V4L2_STD_PAL_N, 	"PAL-N"     },
 	{ V4L2_STD_PAL_Nc, 	"PAL-Nc"    },
 	{ V4L2_STD_PAL_60, 	"PAL-60"    },
 	{ V4L2_STD_SECAM, 	"SECAM"     },
 	{ V4L2_STD_SECAM_B, 	"SECAM-B"   },
 	{ V4L2_STD_SECAM_G, 	"SECAM-G"   },
 	{ V4L2_STD_SECAM_H, 	"SECAM-H"   },
 	{ V4L2_STD_SECAM_DK, 	"SECAM-DK"  },
 	{ V4L2_STD_SECAM_D, 	"SECAM-D"   },
 	{ V4L2_STD_SECAM_K, 	"SECAM-K"   },
 	{ V4L2_STD_SECAM_K1, 	"SECAM-K1"  },
 	{ V4L2_STD_SECAM_L, 	"SECAM-L"   },
 	{ V4L2_STD_SECAM_LC, 	"SECAM-Lc"  },
 	{ 0, 			"Unknown"   }
 };
 /* video4linux standard ID conversion to standard name
  */
 const char *v4l2_norm_to_name(v4l2_std_id id)
 {
 	u32 myid = id;
 	int i;
 	/* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
 	   64 bit comparations. So, on that architecture, with some gcc
 	   variants, compilation fails. Currently, the max value is 30bit wide.
 	 */
 	BUG_ON(myid != id);
 	for (i = 0; standards[i].std; i++)
 		if (myid == standards[i].std)
 			break;
 	return standards[i].descr;
 }
 EXPORT_SYMBOL(v4l2_norm_to_name);
 /* Returns frame period for the given standard */
 void v4l2_video_std_frame_period(int id, struct v4l2_fract *frameperiod)
 {
 	if (id & V4L2_STD_525_60) {
 		frameperiod->numerator = 1001;
 		frameperiod->denominator = 30000;
 	} else {
 		frameperiod->numerator = 1;
 		frameperiod->denominator = 25;
 	}
 }
 EXPORT_SYMBOL(v4l2_video_std_frame_period);
 /* Fill in the fields of a v4l2_standard structure according to the
    'id' and 'transmission' parameters.  Returns negative on error.  */
 int v4l2_video_std_construct(struct v4l2_standard *vs,
 			     int id, const char *name)
 {
 	vs->id = id;
 	v4l2_video_std_frame_period(id, &vs->frameperiod);
 	vs->framelines = (id & V4L2_STD_525_60) ? 525 : 625;
 	strlcpy(vs->name, name, sizeof(vs->name));
 	return 0;
 }
 EXPORT_SYMBOL(v4l2_video_std_construct);
 /* ----------------------------------------------------------------- */
 /* some arrays for pretty-printing debug messages of enum types      */
 const char *v4l2_field_names[] = {
 	[V4L2_FIELD_ANY]        = "any",
 	[V4L2_FIELD_NONE]       = "none",
 	[V4L2_FIELD_TOP]        = "top",
 	[V4L2_FIELD_BOTTOM]     = "bottom",
 	[V4L2_FIELD_INTERLACED] = "interlaced",
 	[V4L2_FIELD_SEQ_TB]     = "seq-tb",
 	[V4L2_FIELD_SEQ_BT]     = "seq-bt",
 	[V4L2_FIELD_ALTERNATE]  = "alternate",
 	[V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
 	[V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
 };
 EXPORT_SYMBOL(v4l2_field_names);
 const char *v4l2_type_names[] = {
 	[V4L2_BUF_TYPE_VIDEO_CAPTURE]      = "vid-cap",
 	[V4L2_BUF_TYPE_VIDEO_OVERLAY]      = "vid-overlay",
 	[V4L2_BUF_TYPE_VIDEO_OUTPUT]       = "vid-out",
 	[V4L2_BUF_TYPE_VBI_CAPTURE]        = "vbi-cap",
 	[V4L2_BUF_TYPE_VBI_OUTPUT]         = "vbi-out",
 	[V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
 	[V4L2_BUF_TYPE_SLICED_VBI_OUTPUT]  = "sliced-vbi-out",
 	[V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "vid-out-overlay",
 };
 EXPORT_SYMBOL(v4l2_type_names);
 static const char *v4l2_memory_names[] = {
 	[V4L2_MEMORY_MMAP]    = "mmap",
 	[V4L2_MEMORY_USERPTR] = "userptr",
 	[V4L2_MEMORY_OVERLAY] = "overlay",
 };
 #define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
 			   arr[a] : "unknown")
 /* ------------------------------------------------------------------ */
 /* debug help functions                                               */
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 static const char *v4l1_ioctls[] = {
 	[_IOC_NR(VIDIOCGCAP)]       = "VIDIOCGCAP",
 	[_IOC_NR(VIDIOCGCHAN)]      = "VIDIOCGCHAN",
 	[_IOC_NR(VIDIOCSCHAN)]      = "VIDIOCSCHAN",
 	[_IOC_NR(VIDIOCGTUNER)]     = "VIDIOCGTUNER",
 	[_IOC_NR(VIDIOCSTUNER)]     = "VIDIOCSTUNER",
 	[_IOC_NR(VIDIOCGPICT)]      = "VIDIOCGPICT",
 	[_IOC_NR(VIDIOCSPICT)]      = "VIDIOCSPICT",
 	[_IOC_NR(VIDIOCCAPTURE)]    = "VIDIOCCAPTURE",
 	[_IOC_NR(VIDIOCGWIN)]       = "VIDIOCGWIN",
 	[_IOC_NR(VIDIOCSWIN)]       = "VIDIOCSWIN",
 	[_IOC_NR(VIDIOCGFBUF)]      = "VIDIOCGFBUF",
 	[_IOC_NR(VIDIOCSFBUF)]      = "VIDIOCSFBUF",
 	[_IOC_NR(VIDIOCKEY)]        = "VIDIOCKEY",
 	[_IOC_NR(VIDIOCGFREQ)]      = "VIDIOCGFREQ",
 	[_IOC_NR(VIDIOCSFREQ)]      = "VIDIOCSFREQ",
 	[_IOC_NR(VIDIOCGAUDIO)]     = "VIDIOCGAUDIO",
 	[_IOC_NR(VIDIOCSAUDIO)]     = "VIDIOCSAUDIO",
 	[_IOC_NR(VIDIOCSYNC)]       = "VIDIOCSYNC",
 	[_IOC_NR(VIDIOCMCAPTURE)]   = "VIDIOCMCAPTURE",
 	[_IOC_NR(VIDIOCGMBUF)]      = "VIDIOCGMBUF",
 	[_IOC_NR(VIDIOCGUNIT)]      = "VIDIOCGUNIT",
 	[_IOC_NR(VIDIOCGCAPTURE)]   = "VIDIOCGCAPTURE",
 	[_IOC_NR(VIDIOCSCAPTURE)]   = "VIDIOCSCAPTURE",
 	[_IOC_NR(VIDIOCSPLAYMODE)]  = "VIDIOCSPLAYMODE",
 	[_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
 	[_IOC_NR(VIDIOCGPLAYINFO)]  = "VIDIOCGPLAYINFO",
 	[_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
 	[_IOC_NR(VIDIOCGVBIFMT)]    = "VIDIOCGVBIFMT",
 	[_IOC_NR(VIDIOCSVBIFMT)]    = "VIDIOCSVBIFMT"
 };
 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
 #endif
 static const char *v4l2_ioctls[] = {
 	[_IOC_NR(VIDIOC_QUERYCAP)]         = "VIDIOC_QUERYCAP",
 	[_IOC_NR(VIDIOC_RESERVED)]         = "VIDIOC_RESERVED",
 	[_IOC_NR(VIDIOC_ENUM_FMT)]         = "VIDIOC_ENUM_FMT",
 	[_IOC_NR(VIDIOC_G_FMT)]            = "VIDIOC_G_FMT",
 	[_IOC_NR(VIDIOC_S_FMT)]            = "VIDIOC_S_FMT",
 	[_IOC_NR(VIDIOC_REQBUFS)]          = "VIDIOC_REQBUFS",
 	[_IOC_NR(VIDIOC_QUERYBUF)]         = "VIDIOC_QUERYBUF",
 	[_IOC_NR(VIDIOC_G_FBUF)]           = "VIDIOC_G_FBUF",
 	[_IOC_NR(VIDIOC_S_FBUF)]           = "VIDIOC_S_FBUF",
 	[_IOC_NR(VIDIOC_OVERLAY)]          = "VIDIOC_OVERLAY",
 	[_IOC_NR(VIDIOC_QBUF)]             = "VIDIOC_QBUF",
 	[_IOC_NR(VIDIOC_DQBUF)]            = "VIDIOC_DQBUF",
 	[_IOC_NR(VIDIOC_STREAMON)]         = "VIDIOC_STREAMON",
 	[_IOC_NR(VIDIOC_STREAMOFF)]        = "VIDIOC_STREAMOFF",
 	[_IOC_NR(VIDIOC_G_PARM)]           = "VIDIOC_G_PARM",
 	[_IOC_NR(VIDIOC_S_PARM)]           = "VIDIOC_S_PARM",
 	[_IOC_NR(VIDIOC_G_STD)]            = "VIDIOC_G_STD",
 	[_IOC_NR(VIDIOC_S_STD)]            = "VIDIOC_S_STD",
 	[_IOC_NR(VIDIOC_ENUMSTD)]          = "VIDIOC_ENUMSTD",
 	[_IOC_NR(VIDIOC_ENUMINPUT)]        = "VIDIOC_ENUMINPUT",
 	[_IOC_NR(VIDIOC_G_CTRL)]           = "VIDIOC_G_CTRL",
 	[_IOC_NR(VIDIOC_S_CTRL)]           = "VIDIOC_S_CTRL",
 	[_IOC_NR(VIDIOC_G_TUNER)]          = "VIDIOC_G_TUNER",
 	[_IOC_NR(VIDIOC_S_TUNER)]          = "VIDIOC_S_TUNER",
 	[_IOC_NR(VIDIOC_G_AUDIO)]          = "VIDIOC_G_AUDIO",
 	[_IOC_NR(VIDIOC_S_AUDIO)]          = "VIDIOC_S_AUDIO",
 	[_IOC_NR(VIDIOC_QUERYCTRL)]        = "VIDIOC_QUERYCTRL",
 	[_IOC_NR(VIDIOC_QUERYMENU)]        = "VIDIOC_QUERYMENU",
 	[_IOC_NR(VIDIOC_G_INPUT)]          = "VIDIOC_G_INPUT",
 	[_IOC_NR(VIDIOC_S_INPUT)]          = "VIDIOC_S_INPUT",
 	[_IOC_NR(VIDIOC_G_OUTPUT)]         = "VIDIOC_G_OUTPUT",
 	[_IOC_NR(VIDIOC_S_OUTPUT)]         = "VIDIOC_S_OUTPUT",
 	[_IOC_NR(VIDIOC_ENUMOUTPUT)]       = "VIDIOC_ENUMOUTPUT",
 	[_IOC_NR(VIDIOC_G_AUDOUT)]         = "VIDIOC_G_AUDOUT",
 	[_IOC_NR(VIDIOC_S_AUDOUT)]         = "VIDIOC_S_AUDOUT",
 	[_IOC_NR(VIDIOC_G_MODULATOR)]      = "VIDIOC_G_MODULATOR",
 	[_IOC_NR(VIDIOC_S_MODULATOR)]      = "VIDIOC_S_MODULATOR",
 	[_IOC_NR(VIDIOC_G_FREQUENCY)]      = "VIDIOC_G_FREQUENCY",
 	[_IOC_NR(VIDIOC_S_FREQUENCY)]      = "VIDIOC_S_FREQUENCY",
 	[_IOC_NR(VIDIOC_CROPCAP)]          = "VIDIOC_CROPCAP",
 	[_IOC_NR(VIDIOC_G_CROP)]           = "VIDIOC_G_CROP",
 	[_IOC_NR(VIDIOC_S_CROP)]           = "VIDIOC_S_CROP",
 	[_IOC_NR(VIDIOC_G_JPEGCOMP)]       = "VIDIOC_G_JPEGCOMP",
 	[_IOC_NR(VIDIOC_S_JPEGCOMP)]       = "VIDIOC_S_JPEGCOMP",
 	[_IOC_NR(VIDIOC_QUERYSTD)]         = "VIDIOC_QUERYSTD",
 	[_IOC_NR(VIDIOC_TRY_FMT)]          = "VIDIOC_TRY_FMT",
 	[_IOC_NR(VIDIOC_ENUMAUDIO)]        = "VIDIOC_ENUMAUDIO",
 	[_IOC_NR(VIDIOC_ENUMAUDOUT)]       = "VIDIOC_ENUMAUDOUT",
 	[_IOC_NR(VIDIOC_G_PRIORITY)]       = "VIDIOC_G_PRIORITY",
 	[_IOC_NR(VIDIOC_S_PRIORITY)]       = "VIDIOC_S_PRIORITY",
 	[_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
 	[_IOC_NR(VIDIOC_LOG_STATUS)]       = "VIDIOC_LOG_STATUS",
 	[_IOC_NR(VIDIOC_G_EXT_CTRLS)]      = "VIDIOC_G_EXT_CTRLS",
 	[_IOC_NR(VIDIOC_S_EXT_CTRLS)]      = "VIDIOC_S_EXT_CTRLS",
 	[_IOC_NR(VIDIOC_TRY_EXT_CTRLS)]    = "VIDIOC_TRY_EXT_CTRLS",
 #if 1
 	[_IOC_NR(VIDIOC_ENUM_FRAMESIZES)]  = "VIDIOC_ENUM_FRAMESIZES",
 	[_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
 	[_IOC_NR(VIDIOC_G_ENC_INDEX)] 	   = "VIDIOC_G_ENC_INDEX",
 	[_IOC_NR(VIDIOC_ENCODER_CMD)] 	   = "VIDIOC_ENCODER_CMD",
 	[_IOC_NR(VIDIOC_TRY_ENCODER_CMD)]  = "VIDIOC_TRY_ENCODER_CMD",
 	[_IOC_NR(VIDIOC_DBG_S_REGISTER)]   = "VIDIOC_DBG_S_REGISTER",
 	[_IOC_NR(VIDIOC_DBG_G_REGISTER)]   = "VIDIOC_DBG_G_REGISTER",
 	[_IOC_NR(VIDIOC_DBG_G_CHIP_IDENT)] = "VIDIOC_DBG_G_CHIP_IDENT",
 	[_IOC_NR(VIDIOC_S_HW_FREQ_SEEK)]   = "VIDIOC_S_HW_FREQ_SEEK",
 #endif
 };
 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 static const char *v4l2_int_ioctls[] = {
 	[_IOC_NR(AUDC_SET_RADIO)]              = "AUDC_SET_RADIO",
 	[_IOC_NR(TUNER_SET_TYPE_ADDR)]         = "TUNER_SET_TYPE_ADDR",
 	[_IOC_NR(TUNER_SET_STANDBY)]           = "TUNER_SET_STANDBY",
 	[_IOC_NR(TUNER_SET_CONFIG)]            = "TUNER_SET_CONFIG",
 	[_IOC_NR(VIDIOC_INT_S_TUNER_MODE)]     = "VIDIOC_INT_S_TUNER_MODE",
 	[_IOC_NR(VIDIOC_INT_RESET)]            = "VIDIOC_INT_RESET",
 	[_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
 	[_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)]  = "VIDIOC_INT_DECODE_VBI_LINE",
 	[_IOC_NR(VIDIOC_INT_S_VBI_DATA)]       = "VIDIOC_INT_S_VBI_DATA",
 	[_IOC_NR(VIDIOC_INT_G_VBI_DATA)]       = "VIDIOC_INT_G_VBI_DATA",
 	[_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)]   = "VIDIOC_INT_I2S_CLOCK_FREQ",
 	[_IOC_NR(VIDIOC_INT_S_STANDBY)]        = "VIDIOC_INT_S_STANDBY",
 	[_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)]  = "VIDIOC_INT_S_AUDIO_ROUTING",
 	[_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)]  = "VIDIOC_INT_G_AUDIO_ROUTING",
 	[_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)]  = "VIDIOC_INT_S_VIDEO_ROUTING",
 	[_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)]  = "VIDIOC_INT_G_VIDEO_ROUTING",
 	[_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)]   = "VIDIOC_INT_S_CRYSTAL_FREQ",
 	[_IOC_NR(VIDIOC_INT_INIT)]   	       = "VIDIOC_INT_INIT",
 	[_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)]     = "VIDIOC_INT_G_STD_OUTPUT",
 	[_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)]     = "VIDIOC_INT_S_STD_OUTPUT",
 };
 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
 /* Common ioctl debug function. This function can be used by
    external ioctl messages as well as internal V4L ioctl */
 void v4l_printk_ioctl(unsigned int cmd)
 {
 	char *dir, *type;
 	switch (_IOC_TYPE(cmd)) {
 	case 'd':
 		if (_IOC_NR(cmd) >= V4L2_INT_IOCTLS) {
 			type = "v4l2_int";
 			break;
 		}
 		printk("%s", v4l2_int_ioctls[_IOC_NR(cmd)]);
 		return;
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 	case 'v':
 		if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
 			type = "v4l1";
 			break;
 		}
 		printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
 		return;
 #endif
 	case 'V':
 		if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
 			type = "v4l2";
 			break;
 		}
 		printk("%s", v4l2_ioctls[_IOC_NR(cmd)]);
 		return;
 	default:
 		type = "unknown";
 	}
 	switch (_IOC_DIR(cmd)) {
 	case _IOC_NONE:              dir = "--"; break;
 	case _IOC_READ:              dir = "r-"; break;
 	case _IOC_WRITE:             dir = "-w"; break;
 	case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
 	default:                     dir = "*ERR*"; break;
 	}
 	printk("%s ioctl '%c', dir=%s, #%d (0x%08x)",
 		type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
 }
 EXPORT_SYMBOL(v4l_printk_ioctl);
 /*
  * helper function -- handles userspace copying for ioctl arguments
  */
 #ifdef __OLD_VIDIOC_
 static unsigned int
 video_fix_command(unsigned int cmd)
 {
 	switch (cmd) {
 	case VIDIOC_OVERLAY_OLD:
 		cmd = VIDIOC_OVERLAY;
 		break;
 	case VIDIOC_S_PARM_OLD:
 		cmd = VIDIOC_S_PARM;
 		break;
 	case VIDIOC_S_CTRL_OLD:
 		cmd = VIDIOC_S_CTRL;
 		break;
 	case VIDIOC_G_AUDIO_OLD:
 		cmd = VIDIOC_G_AUDIO;
 		break;
 	case VIDIOC_G_AUDOUT_OLD:
 		cmd = VIDIOC_G_AUDOUT;
 		break;
 	case VIDIOC_CROPCAP_OLD:
 		cmd = VIDIOC_CROPCAP;
 		break;
 	}
 	return cmd;
 }
 #endif
 /*
  * Obsolete usercopy function - Should be removed soon
  */
 long
 video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,
 		v4l2_kioctl func)
 {
 	char	sbuf[128];
 	void    *mbuf = NULL;
 	void	*parg = NULL;
 	long	err  = -EINVAL;
 	int     is_ext_ctrl;
 	size_t  ctrls_size = 0;
 	void __user *user_ptr = NULL;
 #ifdef __OLD_VIDIOC_
 	cmd = video_fix_command(cmd);
 #endif
 	is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
 		       cmd == VIDIOC_TRY_EXT_CTRLS);
 	/*  Copy arguments into temp kernel buffer  */
 	switch (_IOC_DIR(cmd)) {
 	case _IOC_NONE:
 		parg = NULL;
 		break;
 	case _IOC_READ:
 	case _IOC_WRITE:
 	case (_IOC_WRITE | _IOC_READ):
 		if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
 			parg = sbuf;
 		} else {
 			/* too big to allocate from stack */
 			mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
 			if (NULL == mbuf)
 				return -ENOMEM;
 			parg = mbuf;
 		}
 		err = -EFAULT;
 		if (_IOC_DIR(cmd) & _IOC_WRITE)
 			if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
 				goto out;
 		break;
 	}
 	if (is_ext_ctrl) {
 		struct v4l2_ext_controls *p = parg;
 		/* In case of an error, tell the caller that it wasn't
 		   a specific control that caused it. */
 		p->error_idx = p->count;
 		user_ptr = (void __user *)p->controls;
 		if (p->count) {
 			ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
 			/* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
 			mbuf = kmalloc(ctrls_size, GFP_KERNEL);
 			err = -ENOMEM;
 			if (NULL == mbuf)
 				goto out_ext_ctrl;
 			err = -EFAULT;
 			if (copy_from_user(mbuf, user_ptr, ctrls_size))
 				goto out_ext_ctrl;
 			p->controls = mbuf;
 		}
 	}
 	/* call driver */
 	err = func(file, cmd, parg);
 	if (err == -ENOIOCTLCMD)
 		err = -EINVAL;
 	if (is_ext_ctrl) {
 		struct v4l2_ext_controls *p = parg;
 		p->controls = (void *)user_ptr;
 		if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
 			err = -EFAULT;
 		goto out_ext_ctrl;
 	}
 	if (err < 0)
 		goto out;
 out_ext_ctrl:
 	/*  Copy results into user buffer  */
 	switch (_IOC_DIR(cmd)) {
 	case _IOC_READ:
 	case (_IOC_WRITE | _IOC_READ):
 		if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
 			err = -EFAULT;
 		break;
 	}
 out:
 	kfree(mbuf);
 	return err;
 }
 EXPORT_SYMBOL(video_usercopy);
 static void dbgbuf(unsigned int cmd, struct video_device *vfd,
 					struct v4l2_buffer *p)
 {
 	struct v4l2_timecode *tc = &p->timecode;
 	dbgarg(cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
 		"bytesused=%d, flags=0x%08d, "
 		"field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx, length=%d\n",
 			p->timestamp.tv_sec / 3600,
 			(int)(p->timestamp.tv_sec / 60) % 60,
 			(int)(p->timestamp.tv_sec % 60),
 			(long)p->timestamp.tv_usec,
 			p->index,
 			prt_names(p->type, v4l2_type_names),
 			p->bytesused, p->flags,
 			p->field, p->sequence,
 			prt_names(p->memory, v4l2_memory_names),
 			p->m.userptr, p->length);
 	dbgarg2("timecode=%02d:%02d:%02d type=%d, "
 		"flags=0x%08d, frames=%d, userbits=0x%08x\n",
 			tc->hours, tc->minutes, tc->seconds,
 			tc->type, tc->flags, tc->frames, *(__u32 *)tc->userbits);
 }
 static inline void dbgrect(struct video_device *vfd, char *s,
 							struct v4l2_rect *r)
 {
 	dbgarg2("%sRect start at %dx%d, size=%dx%d\n", s, r->left, r->top,
 						r->width, r->height);
 };
 static inline void v4l_print_pix_fmt(struct video_device *vfd,
 						struct v4l2_pix_format *fmt)
 {
 	dbgarg2("width=%d, height=%d, format=%c%c%c%c, field=%s, "
 		"bytesperline=%d sizeimage=%d, colorspace=%d\n",
 		fmt->width, fmt->height,
 		(fmt->pixelformat & 0xff),
 		(fmt->pixelformat >>  8) & 0xff,
 		(fmt->pixelformat >> 16) & 0xff,
 		(fmt->pixelformat >> 24) & 0xff,
 		prt_names(fmt->field, v4l2_field_names),
 		fmt->bytesperline, fmt->sizeimage, fmt->colorspace);
 };
 static inline void v4l_print_ext_ctrls(unsigned int cmd,
 	struct video_device *vfd, struct v4l2_ext_controls *c, int show_vals)
 {
 	__u32 i;
 	if (!(vfd->debug & V4L2_DEBUG_IOCTL_ARG))
 		return;
 	dbgarg(cmd, "");
 	printk(KERN_CONT "class=0x%x", c->ctrl_class);
 	for (i = 0; i < c->count; i++) {
 		if (show_vals)
 			printk(KERN_CONT " id/val=0x%x/0x%x",
 				c->controls[i].id, c->controls[i].value);
 		else
 			printk(KERN_CONT " id=0x%x", c->controls[i].id);
 	}
 	printk(KERN_CONT "\n");
 };
 static inline int check_ext_ctrls(struct v4l2_ext_controls *c, int allow_priv)
 {
 	__u32 i;
 	/* zero the reserved fields */
 	c->reserved[0] = c->reserved[1] = 0;
 	for (i = 0; i < c->count; i++) {
 		c->controls[i].reserved2[0] = 0;
 		c->controls[i].reserved2[1] = 0;
 	}
 	/* V4L2_CID_PRIVATE_BASE cannot be used as control class
 	   when using extended controls.
 	   Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
 	   is it allowed for backwards compatibility.
 	 */
 	if (!allow_priv && c->ctrl_class == V4L2_CID_PRIVATE_BASE)
 		return 0;
 	/* Check that all controls are from the same control class. */
 	for (i = 0; i < c->count; i++) {
 		if (V4L2_CTRL_ID2CLASS(c->controls[i].id) != c->ctrl_class) {
 			c->error_idx = i;
 			return 0;
 		}
 	}
 	return 1;
 }
 static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type)
 {
 	if (ops == NULL)
 		return -EINVAL;
 	switch (type) {
 	case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 		if (ops->vidioc_try_fmt_vid_cap)
 			return 0;
 		break;
 	case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 		if (ops->vidioc_try_fmt_vid_overlay)
 			return 0;
 		break;
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 		if (ops->vidioc_try_fmt_vid_out)
 			return 0;
 		break;
 	case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 		if (ops->vidioc_try_fmt_vid_out_overlay)
 			return 0;
 		break;
 	case V4L2_BUF_TYPE_VBI_CAPTURE:
 		if (ops->vidioc_try_fmt_vbi_cap)
 			return 0;
 		break;
 	case V4L2_BUF_TYPE_VBI_OUTPUT:
 		if (ops->vidioc_try_fmt_vbi_out)
 			return 0;
 		break;
 	case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 		if (ops->vidioc_try_fmt_sliced_vbi_cap)
 			return 0;
 		break;
 	case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 		if (ops->vidioc_try_fmt_sliced_vbi_out)
 			return 0;
 		break;
 	case V4L2_BUF_TYPE_PRIVATE:
 		if (ops->vidioc_try_fmt_type_private)
 			return 0;
 		break;
 	}
 	return -EINVAL;
 }
 static long __video_do_ioctl(struct file *file,
 		unsigned int cmd, void *arg)
 {
 	struct video_device *vfd = video_devdata(file);
 	const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
 	void *fh = file->private_data;
 	long ret = -EINVAL;
 	if ((vfd->debug & V4L2_DEBUG_IOCTL) &&
 				!(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
 		v4l_print_ioctl(vfd->name, cmd);
 		printk(KERN_CONT "\n");
 	}
 	if (ops == NULL) {
 		printk(KERN_WARNING "videodev: \"%s\" has no ioctl_ops.\n",
 				vfd->name);
 		return -EINVAL;
 	}
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 	/***********************************************************
 	 Handles calls to the obsoleted V4L1 API
 	 Due to the nature of VIDIOCGMBUF, each driver that supports
 	 V4L1 should implement its own handler for this ioctl.
 	 ***********************************************************/
 	/* --- streaming capture ------------------------------------- */
 	if (cmd == VIDIOCGMBUF) {
 		struct video_mbuf *p = arg;
 		if (!ops->vidiocgmbuf)
 			return ret;
 		ret = ops->vidiocgmbuf(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
 						p->size, p->frames,
 						(unsigned long)p->offsets);
 		return ret;
 	}
 	/********************************************************
 	 All other V4L1 calls are handled by v4l1_compat module.
 	 Those calls will be translated into V4L2 calls, and
 	 __video_do_ioctl will be called again, with one or more
 	 V4L2 ioctls.
 	 ********************************************************/
 	if (_IOC_TYPE(cmd) == 'v' && _IOC_NR(cmd) < BASE_VIDIOCPRIVATE)
 		return v4l_compat_translate_ioctl(file, cmd, arg,
 						__video_do_ioctl);
 #endif
 	switch (cmd) {
 	/* --- capabilities ------------------------------------------ */
 	case VIDIOC_QUERYCAP:
 	{
 		struct v4l2_capability *cap = (struct v4l2_capability *)arg;
 		if (!ops->vidioc_querycap)
 			break;
 		ret = ops->vidioc_querycap(file, fh, cap);
 		if (!ret)
 			dbgarg(cmd, "driver=%s, card=%s, bus=%s, "
 					"version=0x%08x, "
 					"capabilities=0x%08x\n",
 					cap->driver, cap->card, cap->bus_info,
 					cap->version,
 					cap->capabilities);
 		break;
 	}
 	/* --- priority ------------------------------------------ */
 	case VIDIOC_G_PRIORITY:
 	{
 		enum v4l2_priority *p = arg;
 		if (!ops->vidioc_g_priority)
 			break;
 		ret = ops->vidioc_g_priority(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "priority is %d\n", *p);
 		break;
 	}
 	case VIDIOC_S_PRIORITY:
 	{
 		enum v4l2_priority *p = arg;
 		if (!ops->vidioc_s_priority)
 			break;
 		dbgarg(cmd, "setting priority to %d\n", *p);
 		ret = ops->vidioc_s_priority(file, fh, *p);
 		break;
 	}
 	/* --- capture ioctls ---------------------------------------- */
 	case VIDIOC_ENUM_FMT:
 	{
 		struct v4l2_fmtdesc *f = arg;
 		switch (f->type) {
 		case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 			if (ops->vidioc_enum_fmt_vid_cap)
 				ret = ops->vidioc_enum_fmt_vid_cap(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 			if (ops->vidioc_enum_fmt_vid_overlay)
 				ret = ops->vidioc_enum_fmt_vid_overlay(file,
 					fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 			if (ops->vidioc_enum_fmt_vid_out)
 				ret = ops->vidioc_enum_fmt_vid_out(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_PRIVATE:
 			if (ops->vidioc_enum_fmt_type_private)
 				ret = ops->vidioc_enum_fmt_type_private(file,
 								fh, f);
 			break;
 		default:
 			break;
 		}
 		if (!ret)
 			dbgarg(cmd, "index=%d, type=%d, flags=%d, "
 				"pixelformat=%c%c%c%c, description='%s'\n",
 				f->index, f->type, f->flags,
 				(f->pixelformat & 0xff),
 				(f->pixelformat >>  8) & 0xff,
 				(f->pixelformat >> 16) & 0xff,
 				(f->pixelformat >> 24) & 0xff,
 				f->description);
 		break;
 	}
 	case VIDIOC_G_FMT:
 	{
 		struct v4l2_format *f = (struct v4l2_format *)arg;
 		/* FIXME: Should be one dump per type */
 		dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
 		switch (f->type) {
 		case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 			if (ops->vidioc_g_fmt_vid_cap)
 				ret = ops->vidioc_g_fmt_vid_cap(file, fh, f);
 			if (!ret)
 				v4l_print_pix_fmt(vfd, &f->fmt.pix);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 			if (ops->vidioc_g_fmt_vid_overlay)
 				ret = ops->vidioc_g_fmt_vid_overlay(file,
 								    fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 			if (ops->vidioc_g_fmt_vid_out)
 				ret = ops->vidioc_g_fmt_vid_out(file, fh, f);
 			if (!ret)
 				v4l_print_pix_fmt(vfd, &f->fmt.pix);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 			if (ops->vidioc_g_fmt_vid_out_overlay)
 				ret = ops->vidioc_g_fmt_vid_out_overlay(file,
 				       fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_CAPTURE:
 			if (ops->vidioc_g_fmt_vbi_cap)
 				ret = ops->vidioc_g_fmt_vbi_cap(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_OUTPUT:
 			if (ops->vidioc_g_fmt_vbi_out)
 				ret = ops->vidioc_g_fmt_vbi_out(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 			if (ops->vidioc_g_fmt_sliced_vbi_cap)
 				ret = ops->vidioc_g_fmt_sliced_vbi_cap(file,
 									fh, f);
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 			if (ops->vidioc_g_fmt_sliced_vbi_out)
 				ret = ops->vidioc_g_fmt_sliced_vbi_out(file,
 									fh, f);
 			break;
 		case V4L2_BUF_TYPE_PRIVATE:
 			if (ops->vidioc_g_fmt_type_private)
 				ret = ops->vidioc_g_fmt_type_private(file,
 								fh, f);
 			break;
 		}
 		break;
 	}
 	case VIDIOC_S_FMT:
 	{
 		struct v4l2_format *f = (struct v4l2_format *)arg;
 		/* FIXME: Should be one dump per type */
 		dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
 		switch (f->type) {
 		case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 			v4l_print_pix_fmt(vfd, &f->fmt.pix);
 			if (ops->vidioc_s_fmt_vid_cap)
 				ret = ops->vidioc_s_fmt_vid_cap(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 			if (ops->vidioc_s_fmt_vid_overlay)
 				ret = ops->vidioc_s_fmt_vid_overlay(file,
 								    fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 			v4l_print_pix_fmt(vfd, &f->fmt.pix);
 			if (ops->vidioc_s_fmt_vid_out)
 				ret = ops->vidioc_s_fmt_vid_out(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 			if (ops->vidioc_s_fmt_vid_out_overlay)
 				ret = ops->vidioc_s_fmt_vid_out_overlay(file,
 					fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_CAPTURE:
 			if (ops->vidioc_s_fmt_vbi_cap)
 				ret = ops->vidioc_s_fmt_vbi_cap(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_OUTPUT:
 			if (ops->vidioc_s_fmt_vbi_out)
 				ret = ops->vidioc_s_fmt_vbi_out(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 			if (ops->vidioc_s_fmt_sliced_vbi_cap)
 				ret = ops->vidioc_s_fmt_sliced_vbi_cap(file,
 									fh, f);
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 			if (ops->vidioc_s_fmt_sliced_vbi_out)
 				ret = ops->vidioc_s_fmt_sliced_vbi_out(file,
 									fh, f);
 			break;
 		case V4L2_BUF_TYPE_PRIVATE:
 			if (ops->vidioc_s_fmt_type_private)
 				ret = ops->vidioc_s_fmt_type_private(file,
 								fh, f);
 			break;
 		}
 		break;
 	}
 	case VIDIOC_TRY_FMT:
 	{
 		struct v4l2_format *f = (struct v4l2_format *)arg;
 		/* FIXME: Should be one dump per type */
 		dbgarg(cmd, "type=%s\n", prt_names(f->type,
 						v4l2_type_names));
 		switch (f->type) {
 		case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 			if (ops->vidioc_try_fmt_vid_cap)
 				ret = ops->vidioc_try_fmt_vid_cap(file, fh, f);
 			if (!ret)
 				v4l_print_pix_fmt(vfd, &f->fmt.pix);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 			if (ops->vidioc_try_fmt_vid_overlay)
 				ret = ops->vidioc_try_fmt_vid_overlay(file,
 					fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 			if (ops->vidioc_try_fmt_vid_out)
 				ret = ops->vidioc_try_fmt_vid_out(file, fh, f);
 			if (!ret)
 				v4l_print_pix_fmt(vfd, &f->fmt.pix);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 			if (ops->vidioc_try_fmt_vid_out_overlay)
 				ret = ops->vidioc_try_fmt_vid_out_overlay(file,
 				       fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_CAPTURE:
 			if (ops->vidioc_try_fmt_vbi_cap)
 				ret = ops->vidioc_try_fmt_vbi_cap(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_OUTPUT:
 			if (ops->vidioc_try_fmt_vbi_out)
 				ret = ops->vidioc_try_fmt_vbi_out(file, fh, f);
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 			if (ops->vidioc_try_fmt_sliced_vbi_cap)
 				ret = ops->vidioc_try_fmt_sliced_vbi_cap(file,
 								fh, f);
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 			if (ops->vidioc_try_fmt_sliced_vbi_out)
 				ret = ops->vidioc_try_fmt_sliced_vbi_out(file,
 								fh, f);
 			break;
 		case V4L2_BUF_TYPE_PRIVATE:
 			if (ops->vidioc_try_fmt_type_private)
 				ret = ops->vidioc_try_fmt_type_private(file,
 								fh, f);
 			break;
 		}
 		break;
 	}
 	/* FIXME: Those buf reqs could be handled here,
 	   with some changes on videobuf to allow its header to be included at
 	   videodev2.h or being merged at videodev2.
 	 */
 	case VIDIOC_REQBUFS:
 	{
 		struct v4l2_requestbuffers *p = arg;
 		if (!ops->vidioc_reqbufs)
 			break;
 		ret = check_fmt(ops, p->type);
 		if (ret)
 			break;
 		ret = ops->vidioc_reqbufs(file, fh, p);
 		dbgarg(cmd, "count=%d, type=%s, memory=%s\n",
 				p->count,
 				prt_names(p->type, v4l2_type_names),
 				prt_names(p->memory, v4l2_memory_names));
 		break;
 	}
 	case VIDIOC_QUERYBUF:
 	{
 		struct v4l2_buffer *p = arg;
 		if (!ops->vidioc_querybuf)
 			break;
 		ret = check_fmt(ops, p->type);
 		if (ret)
 			break;
 		ret = ops->vidioc_querybuf(file, fh, p);
 		if (!ret)
 			dbgbuf(cmd, vfd, p);
 		break;
 	}
 	case VIDIOC_QBUF:
 	{
 		struct v4l2_buffer *p = arg;
 		if (!ops->vidioc_qbuf)
 			break;
 		ret = check_fmt(ops, p->type);
 		if (ret)
 			break;
 		ret = ops->vidioc_qbuf(file, fh, p);
 		if (!ret)
 			dbgbuf(cmd, vfd, p);
 		break;
 	}
 	case VIDIOC_DQBUF:
 	{
 		struct v4l2_buffer *p = arg;
 		if (!ops->vidioc_dqbuf)
 			break;
 		ret = check_fmt(ops, p->type);
 		if (ret)
 			break;
 		ret = ops->vidioc_dqbuf(file, fh, p);
 		if (!ret)
 			dbgbuf(cmd, vfd, p);
 		break;
 	}
 	case VIDIOC_OVERLAY:
 	{
 		int *i = arg;
 		if (!ops->vidioc_overlay)
 			break;
 		dbgarg(cmd, "value=%d\n", *i);
 		ret = ops->vidioc_overlay(file, fh, *i);
 		break;
 	}
 	case VIDIOC_G_FBUF:
 	{
 		struct v4l2_framebuffer *p = arg;
 		if (!ops->vidioc_g_fbuf)
 			break;
 		ret = ops->vidioc_g_fbuf(file, fh, arg);
 		if (!ret) {
 			dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
 					p->capability, p->flags,
 					(unsigned long)p->base);
 			v4l_print_pix_fmt(vfd, &p->fmt);
 		}
 		break;
 	}
 	case VIDIOC_S_FBUF:
 	{
 		struct v4l2_framebuffer *p = arg;
 		if (!ops->vidioc_s_fbuf)
 			break;
 		dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
 			p->capability, p->flags, (unsigned long)p->base);
 		v4l_print_pix_fmt(vfd, &p->fmt);
 		ret = ops->vidioc_s_fbuf(file, fh, arg);
 		break;
 	}
 	case VIDIOC_STREAMON:
 	{
 		enum v4l2_buf_type i = *(int *)arg;
 		if (!ops->vidioc_streamon)
 			break;
 		dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
 		ret = ops->vidioc_streamon(file, fh, i);
 		break;
 	}
 	case VIDIOC_STREAMOFF:
 	{
 		enum v4l2_buf_type i = *(int *)arg;
 		if (!ops->vidioc_streamoff)
 			break;
 		dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
 		ret = ops->vidioc_streamoff(file, fh, i);
 		break;
 	}
 	/* ---------- tv norms ---------- */
 	case VIDIOC_ENUMSTD:
 	{
 		struct v4l2_standard *p = arg;
 		v4l2_std_id id = vfd->tvnorms, curr_id = 0;
 		unsigned int index = p->index, i, j = 0;
 		const char *descr = "";
 		/* Return norm array in a canonical way */
 		for (i = 0; i <= index && id; i++) {
 			/* last std value in the standards array is 0, so this
 			   while always ends there since (id & 0) == 0. */
 			while ((id & standards[j].std) != standards[j].std)
 				j++;
 			curr_id = standards[j].std;
 			descr = standards[j].descr;
 			j++;
 			if (curr_id == 0)
 				break;
 			if (curr_id != V4L2_STD_PAL &&
 			    curr_id != V4L2_STD_SECAM &&
 			    curr_id != V4L2_STD_NTSC)
 				id &= ~curr_id;
 		}
 		if (i <= index)
 			return -EINVAL;
 		v4l2_video_std_construct(p, curr_id, descr);
 		dbgarg(cmd, "index=%d, id=0x%Lx, name=%s, fps=%d/%d, "
 				"framelines=%d\n", p->index,
 				(unsigned long long)p->id, p->name,
 				p->frameperiod.numerator,
 				p->frameperiod.denominator,
 				p->framelines);
 		ret = 0;
 		break;
 	}
 	case VIDIOC_G_STD:
 	{
 		v4l2_std_id *id = arg;
 		ret = 0;
 		/* Calls the specific handler */
 		if (ops->vidioc_g_std)
 			ret = ops->vidioc_g_std(file, fh, id);
 		else
 			*id = vfd->current_norm;
 		if (!ret)
 			dbgarg(cmd, "std=0x%08Lx\n", (long long unsigned)*id);
 		break;
 	}
 	case VIDIOC_S_STD:
 	{
 		v4l2_std_id *id = arg, norm;
 		dbgarg(cmd, "std=%08Lx\n", (long long unsigned)*id);
 		norm = (*id) & vfd->tvnorms;
 		if (vfd->tvnorms && !norm)	/* Check if std is supported */
 			break;
 		/* Calls the specific handler */
 		if (ops->vidioc_s_std)
 			ret = ops->vidioc_s_std(file, fh, &norm);
 		else
 			ret = -EINVAL;
 		/* Updates standard information */
 		if (ret >= 0)
 			vfd->current_norm = norm;
 		break;
 	}
 	case VIDIOC_QUERYSTD:
 	{
 		v4l2_std_id *p = arg;
 		if (!ops->vidioc_querystd)
 			break;
 		ret = ops->vidioc_querystd(file, fh, arg);
 		if (!ret)
 			dbgarg(cmd, "detected std=%08Lx\n",
 						(unsigned long long)*p);
 		break;
 	}
 	/* ------ input switching ---------- */
 	/* FIXME: Inputs can be handled inside videodev2 */
 	case VIDIOC_ENUMINPUT:
 	{
 		struct v4l2_input *p = arg;
 		if (!ops->vidioc_enum_input)
 			break;
 		ret = ops->vidioc_enum_input(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "index=%d, name=%s, type=%d, "
 				"audioset=%d, "
 				"tuner=%d, std=%08Lx, status=%d\n",
 				p->index, p->name, p->type, p->audioset,
 				p->tuner,
 				(unsigned long long)p->std,
 				p->status);
 		break;
 	}
 	case VIDIOC_G_INPUT:
 	{
 		unsigned int *i = arg;
 		if (!ops->vidioc_g_input)
 			break;
 		ret = ops->vidioc_g_input(file, fh, i);
 		if (!ret)
 			dbgarg(cmd, "value=%d\n", *i);
 		break;
 	}
 	case VIDIOC_S_INPUT:
 	{
 		unsigned int *i = arg;
 		if (!ops->vidioc_s_input)
 			break;
 		dbgarg(cmd, "value=%d\n", *i);
 		ret = ops->vidioc_s_input(file, fh, *i);
 		break;
 	}
 	/* ------ output switching ---------- */
 	case VIDIOC_ENUMOUTPUT:
 	{
 		struct v4l2_output *p = arg;
 		if (!ops->vidioc_enum_output)
 			break;
 		ret = ops->vidioc_enum_output(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "index=%d, name=%s, type=%d, "
 				"audioset=0x%x, "
 				"modulator=%d, std=0x%08Lx\n",
 				p->index, p->name, p->type, p->audioset,
 				p->modulator, (unsigned long long)p->std);
 		break;
 	}
 	case VIDIOC_G_OUTPUT:
 	{
 		unsigned int *i = arg;
 		if (!ops->vidioc_g_output)
 			break;
 		ret = ops->vidioc_g_output(file, fh, i);
 		if (!ret)
 			dbgarg(cmd, "value=%d\n", *i);
 		break;
 	}
 	case VIDIOC_S_OUTPUT:
 	{
 		unsigned int *i = arg;
 		if (!ops->vidioc_s_output)
 			break;
 		dbgarg(cmd, "value=%d\n", *i);
 		ret = ops->vidioc_s_output(file, fh, *i);
 		break;
 	}
 	/* --- controls ---------------------------------------------- */
 	case VIDIOC_QUERYCTRL:
 	{
 		struct v4l2_queryctrl *p = arg;
 		if (!ops->vidioc_queryctrl)
 			break;
 		ret = ops->vidioc_queryctrl(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "id=0x%x, type=%d, name=%s, min/max=%d/%d, "
 					"step=%d, default=%d, flags=0x%08x\n",
 					p->id, p->type, p->name,
 					p->minimum, p->maximum,
 					p->step, p->default_value, p->flags);
 		else
 			dbgarg(cmd, "id=0x%x\n", p->id);
 		break;
 	}
 	case VIDIOC_G_CTRL:
 	{
 		struct v4l2_control *p = arg;
 		if (ops->vidioc_g_ctrl)
 			ret = ops->vidioc_g_ctrl(file, fh, p);
 		else if (ops->vidioc_g_ext_ctrls) {
 			struct v4l2_ext_controls ctrls;
 			struct v4l2_ext_control ctrl;
 			ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
 			ctrls.count = 1;
 			ctrls.controls = &ctrl;
 			ctrl.id = p->id;
 			ctrl.value = p->value;
 			if (check_ext_ctrls(&ctrls, 1)) {
 				ret = ops->vidioc_g_ext_ctrls(file, fh, &ctrls);
 				if (ret == 0)
 					p->value = ctrl.value;
 			}
 		} else
 			break;
 		if (!ret)
 			dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
 		else
 			dbgarg(cmd, "id=0x%x\n", p->id);
 		break;
 	}
 	case VIDIOC_S_CTRL:
 	{
 		struct v4l2_control *p = arg;
 		struct v4l2_ext_controls ctrls;
 		struct v4l2_ext_control ctrl;
 		if (!ops->vidioc_s_ctrl && !ops->vidioc_s_ext_ctrls)
 			break;
 		dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
 		if (ops->vidioc_s_ctrl) {
 			ret = ops->vidioc_s_ctrl(file, fh, p);
 			break;
 		}
 		if (!ops->vidioc_s_ext_ctrls)
 			break;
 		ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
 		ctrls.count = 1;
 		ctrls.controls = &ctrl;
 		ctrl.id = p->id;
 		ctrl.value = p->value;
 		if (check_ext_ctrls(&ctrls, 1))
 			ret = ops->vidioc_s_ext_ctrls(file, fh, &ctrls);
 		break;
 	}
 	case VIDIOC_G_EXT_CTRLS:
 	{
 		struct v4l2_ext_controls *p = arg;
 		p->error_idx = p->count;
 		if (!ops->vidioc_g_ext_ctrls)
 			break;
 		if (check_ext_ctrls(p, 0))
 			ret = ops->vidioc_g_ext_ctrls(file, fh, p);
 		v4l_print_ext_ctrls(cmd, vfd, p, !ret);
 		break;
 	}
 	case VIDIOC_S_EXT_CTRLS:
 	{
 		struct v4l2_ext_controls *p = arg;
 		p->error_idx = p->count;
 		if (!ops->vidioc_s_ext_ctrls)
 			break;
 		v4l_print_ext_ctrls(cmd, vfd, p, 1);
 		if (check_ext_ctrls(p, 0))
 			ret = ops->vidioc_s_ext_ctrls(file, fh, p);
 		break;
 	}
 	case VIDIOC_TRY_EXT_CTRLS:
 	{
 		struct v4l2_ext_controls *p = arg;
 		p->error_idx = p->count;
 		if (!ops->vidioc_try_ext_ctrls)
 			break;
 		v4l_print_ext_ctrls(cmd, vfd, p, 1);
 		if (check_ext_ctrls(p, 0))
 			ret = ops->vidioc_try_ext_ctrls(file, fh, p);
 		break;
 	}
 	case VIDIOC_QUERYMENU:
 	{
 		struct v4l2_querymenu *p = arg;
 		if (!ops->vidioc_querymenu)
 			break;
 		ret = ops->vidioc_querymenu(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "id=0x%x, index=%d, name=%s\n",
 				p->id, p->index, p->name);
 		else
 			dbgarg(cmd, "id=0x%x, index=%d\n",
 				p->id, p->index);
 		break;
 	}
 	/* --- audio ---------------------------------------------- */
 	case VIDIOC_ENUMAUDIO:
 	{
 		struct v4l2_audio *p = arg;
 		if (!ops->vidioc_enumaudio)
 			break;
 		ret = ops->vidioc_enumaudio(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
 					"mode=0x%x\n", p->index, p->name,
 					p->capability, p->mode);
 		else
 			dbgarg(cmd, "index=%d\n", p->index);
 		break;
 	}
 	case VIDIOC_G_AUDIO:
 	{
 		struct v4l2_audio *p = arg;
 		if (!ops->vidioc_g_audio)
 			break;
 		ret = ops->vidioc_g_audio(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
 					"mode=0x%x\n", p->index,
 					p->name, p->capability, p->mode);
 		else
 			dbgarg(cmd, "index=%d\n", p->index);
 		break;
 	}
 	case VIDIOC_S_AUDIO:
 	{
 		struct v4l2_audio *p = arg;
 		if (!ops->vidioc_s_audio)
 			break;
 		dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
 					"mode=0x%x\n", p->index, p->name,
 					p->capability, p->mode);
 		ret = ops->vidioc_s_audio(file, fh, p);
 		break;
 	}
 	case VIDIOC_ENUMAUDOUT:
 	{
 		struct v4l2_audioout *p = arg;
 		if (!ops->vidioc_enumaudout)
 			break;
 		dbgarg(cmd, "Enum for index=%d\n", p->index);
 		ret = ops->vidioc_enumaudout(file, fh, p);
 		if (!ret)
 			dbgarg2("index=%d, name=%s, capability=%d, "
 					"mode=%d\n", p->index, p->name,
 					p->capability, p->mode);
 		break;
 	}
 	case VIDIOC_G_AUDOUT:
 	{
 		struct v4l2_audioout *p = arg;
 		if (!ops->vidioc_g_audout)
 			break;
 		ret = ops->vidioc_g_audout(file, fh, p);
 		if (!ret)
 			dbgarg2("index=%d, name=%s, capability=%d, "
 					"mode=%d\n", p->index, p->name,
 					p->capability, p->mode);
 		break;
 	}
 	case VIDIOC_S_AUDOUT:
 	{
 		struct v4l2_audioout *p = arg;
 		if (!ops->vidioc_s_audout)
 			break;
 		dbgarg(cmd, "index=%d, name=%s, capability=%d, "
 					"mode=%d\n", p->index, p->name,
 					p->capability, p->mode);
 		ret = ops->vidioc_s_audout(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_MODULATOR:
 	{
 		struct v4l2_modulator *p = arg;
 		if (!ops->vidioc_g_modulator)
 			break;
 		ret = ops->vidioc_g_modulator(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "index=%d, name=%s, "
 					"capability=%d, rangelow=%d,"
 					" rangehigh=%d, txsubchans=%d\n",
 					p->index, p->name, p->capability,
 					p->rangelow, p->rangehigh,
 					p->txsubchans);
 		break;
 	}
 	case VIDIOC_S_MODULATOR:
 	{
 		struct v4l2_modulator *p = arg;
 		if (!ops->vidioc_s_modulator)
 			break;
 		dbgarg(cmd, "index=%d, name=%s, capability=%d, "
 				"rangelow=%d, rangehigh=%d, txsubchans=%d\n",
 				p->index, p->name, p->capability, p->rangelow,
 				p->rangehigh, p->txsubchans);
 			ret = ops->vidioc_s_modulator(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_CROP:
 	{
 		struct v4l2_crop *p = arg;
 		if (!ops->vidioc_g_crop)
 			break;
 		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
 		ret = ops->vidioc_g_crop(file, fh, p);
 		if (!ret)
 			dbgrect(vfd, "", &p->c);
 		break;
 	}
 	case VIDIOC_S_CROP:
 	{
 		struct v4l2_crop *p = arg;
 		if (!ops->vidioc_s_crop)
 			break;
 		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
 		dbgrect(vfd, "", &p->c);
 		ret = ops->vidioc_s_crop(file, fh, p);
 		break;
 	}
 	case VIDIOC_CROPCAP:
 	{
 		struct v4l2_cropcap *p = arg;
 		/*FIXME: Should also show v4l2_fract pixelaspect */
 		if (!ops->vidioc_cropcap)
 			break;
 		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
 		ret = ops->vidioc_cropcap(file, fh, p);
 		if (!ret) {
 			dbgrect(vfd, "bounds ", &p->bounds);
 			dbgrect(vfd, "defrect ", &p->defrect);
 		}
 		break;
 	}
 	case VIDIOC_G_JPEGCOMP:
 	{
 		struct v4l2_jpegcompression *p = arg;
 		if (!ops->vidioc_g_jpegcomp)
 			break;
 		ret = ops->vidioc_g_jpegcomp(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "quality=%d, APPn=%d, "
 					"APP_len=%d, COM_len=%d, "
 					"jpeg_markers=%d\n",
 					p->quality, p->APPn, p->APP_len,
 					p->COM_len, p->jpeg_markers);
 		break;
 	}
 	case VIDIOC_S_JPEGCOMP:
 	{
 		struct v4l2_jpegcompression *p = arg;
 		if (!ops->vidioc_g_jpegcomp)
 			break;
 		dbgarg(cmd, "quality=%d, APPn=%d, APP_len=%d, "
 					"COM_len=%d, jpeg_markers=%d\n",
 					p->quality, p->APPn, p->APP_len,
 					p->COM_len, p->jpeg_markers);
 			ret = ops->vidioc_s_jpegcomp(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_ENC_INDEX:
 	{
 		struct v4l2_enc_idx *p = arg;
 		if (!ops->vidioc_g_enc_index)
 			break;
 		ret = ops->vidioc_g_enc_index(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "entries=%d, entries_cap=%d\n",
 					p->entries, p->entries_cap);
 		break;
 	}
 	case VIDIOC_ENCODER_CMD:
 	{
 		struct v4l2_encoder_cmd *p = arg;
 		if (!ops->vidioc_encoder_cmd)
 			break;
 		ret = ops->vidioc_encoder_cmd(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
 		break;
 	}
 	case VIDIOC_TRY_ENCODER_CMD:
 	{
 		struct v4l2_encoder_cmd *p = arg;
 		if (!ops->vidioc_try_encoder_cmd)
 			break;
 		ret = ops->vidioc_try_encoder_cmd(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
 		break;
 	}
 	case VIDIOC_G_PARM:
 	{
 		struct v4l2_streamparm *p = arg;
 		if (ops->vidioc_g_parm) {
 			ret = ops->vidioc_g_parm(file, fh, p);
 		} else {
 			if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 				return -EINVAL;
 			v4l2_video_std_frame_period(vfd->current_norm,
 						    &p->parm.capture.timeperframe);
 			ret = 0;
 		}
 		dbgarg(cmd, "type=%d\n", p->type);
 		break;
 	}
 	case VIDIOC_S_PARM:
 	{
 		struct v4l2_streamparm *p = arg;
 		if (!ops->vidioc_s_parm)
 			break;
 		dbgarg(cmd, "type=%d\n", p->type);
 		ret = ops->vidioc_s_parm(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_TUNER:
 	{
 		struct v4l2_tuner *p = arg;
 		if (!ops->vidioc_g_tuner)
 			break;
 		ret = ops->vidioc_g_tuner(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "index=%d, name=%s, type=%d, "
 					"capability=0x%x, rangelow=%d, "
 					"rangehigh=%d, signal=%d, afc=%d, "
 					"rxsubchans=0x%x, audmode=%d\n",
 					p->index, p->name, p->type,
 					p->capability, p->rangelow,
 					p->rangehigh, p->signal, p->afc,
 					p->rxsubchans, p->audmode);
 		break;
 	}
 	case VIDIOC_S_TUNER:
 	{
 		struct v4l2_tuner *p = arg;
 		if (!ops->vidioc_s_tuner)
 			break;
 		dbgarg(cmd, "index=%d, name=%s, type=%d, "
 				"capability=0x%x, rangelow=%d, "
 				"rangehigh=%d, signal=%d, afc=%d, "
 				"rxsubchans=0x%x, audmode=%d\n",
 				p->index, p->name, p->type,
 				p->capability, p->rangelow,
 				p->rangehigh, p->signal, p->afc,
 				p->rxsubchans, p->audmode);
 		ret = ops->vidioc_s_tuner(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_FREQUENCY:
 	{
 		struct v4l2_frequency *p = arg;
 		if (!ops->vidioc_g_frequency)
 			break;
 		ret = ops->vidioc_g_frequency(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
 					p->tuner, p->type, p->frequency);
 		break;
 	}
 	case VIDIOC_S_FREQUENCY:
 	{
 		struct v4l2_frequency *p = arg;
 		if (!ops->vidioc_s_frequency)
 			break;
 		dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
 				p->tuner, p->type, p->frequency);
 		ret = ops->vidioc_s_frequency(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_SLICED_VBI_CAP:
 	{
 		struct v4l2_sliced_vbi_cap *p = arg;
 		if (!ops->vidioc_g_sliced_vbi_cap)
 			break;
 		/* Clear up to type, everything after type is zerod already */
 		memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
 		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
 		ret = ops->vidioc_g_sliced_vbi_cap(file, fh, p);
 		if (!ret)
 			dbgarg2("service_set=%d\n", p->service_set);
 		break;
 	}
 	case VIDIOC_LOG_STATUS:
 	{
 		if (!ops->vidioc_log_status)
 			break;
 		ret = ops->vidioc_log_status(file, fh);
 		break;
 	}
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	case VIDIOC_DBG_G_REGISTER:
 	{
 		struct v4l2_dbg_register *p = arg;
 		if (!capable(CAP_SYS_ADMIN))
 			ret = -EPERM;
 		else if (ops->vidioc_g_register)
 			ret = ops->vidioc_g_register(file, fh, p);
 		break;
 	}
 	case VIDIOC_DBG_S_REGISTER:
 	{
 		struct v4l2_dbg_register *p = arg;
 		if (!capable(CAP_SYS_ADMIN))
 			ret = -EPERM;
 		else if (ops->vidioc_s_register)
 			ret = ops->vidioc_s_register(file, fh, p);
 		break;
 	}
 #endif
 	case VIDIOC_DBG_G_CHIP_IDENT:
 	{
 		struct v4l2_dbg_chip_ident *p = arg;
 		if (!ops->vidioc_g_chip_ident)
 			break;
 		p->ident = V4L2_IDENT_NONE;
 		p->revision = 0;
 		ret = ops->vidioc_g_chip_ident(file, fh, p);
 		if (!ret)
 			dbgarg(cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
 		break;
 	}
 	case VIDIOC_G_CHIP_IDENT_OLD:
 		printk(KERN_ERR "VIDIOC_G_CHIP_IDENT has been deprecated and will disappear in 2.6.30.\n");
 		printk(KERN_ERR "It is a debugging ioctl and must not be used in applications!\n");
 		return -EINVAL;
 	case VIDIOC_S_HW_FREQ_SEEK:
 	{
 		struct v4l2_hw_freq_seek *p = arg;
 		if (!ops->vidioc_s_hw_freq_seek)
 			break;
 		dbgarg(cmd,
 			"tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
 			p->tuner, p->type, p->seek_upward, p->wrap_around);
 		ret = ops->vidioc_s_hw_freq_seek(file, fh, p);
 		break;
 	}
 	case VIDIOC_ENUM_FRAMESIZES:
 	{
 		struct v4l2_frmsizeenum *p = arg;
 		if (!ops->vidioc_enum_framesizes)
 			break;
 		ret = ops->vidioc_enum_framesizes(file, fh, p);
 		dbgarg(cmd,
 			"index=%d, pixelformat=%d, type=%d ",
 			p->index, p->pixel_format, p->type);
 		switch (p->type) {
 		case V4L2_FRMSIZE_TYPE_DISCRETE:
 			dbgarg2("width = %d, height=%d\n",
 				p->discrete.width, p->discrete.height);
 			break;
 		case V4L2_FRMSIZE_TYPE_STEPWISE:
 			dbgarg2("min %dx%d, max %dx%d, step %dx%d\n",
 				p->stepwise.min_width,  p->stepwise.min_height,
 				p->stepwise.step_width, p->stepwise.step_height,
 				p->stepwise.max_width,  p->stepwise.max_height);
 			break;
 		case V4L2_FRMSIZE_TYPE_CONTINUOUS:
 			dbgarg2("continuous\n");
 			break;
 		default:
 			dbgarg2("- Unknown type!\n");
 		}
 		break;
 	}
 	case VIDIOC_ENUM_FRAMEINTERVALS:
 	{
 		struct v4l2_frmivalenum *p = arg;
 		if (!ops->vidioc_enum_frameintervals)
 			break;
 		ret = ops->vidioc_enum_frameintervals(file, fh, p);
 		dbgarg(cmd,
 			"index=%d, pixelformat=%d, width=%d, height=%d, type=%d ",
 			p->index, p->pixel_format,
 			p->width, p->height, p->type);
 		switch (p->type) {
 		case V4L2_FRMIVAL_TYPE_DISCRETE:
 			dbgarg2("fps=%d/%d\n",
 				p->discrete.numerator,
 				p->discrete.denominator);
 			break;
 		case V4L2_FRMIVAL_TYPE_STEPWISE:
 			dbgarg2("min=%d/%d, max=%d/%d, step=%d/%d\n",
 				p->stepwise.min.numerator,
 				p->stepwise.min.denominator,
 				p->stepwise.max.numerator,
 				p->stepwise.max.denominator,
 				p->stepwise.step.numerator,
 				p->stepwise.step.denominator);
 			break;
 		case V4L2_FRMIVAL_TYPE_CONTINUOUS:
 			dbgarg2("continuous\n");
 			break;
 		default:
 			dbgarg2("- Unknown type!\n");
 		}
 		break;
 	}
 	default:
 	{
 		if (!ops->vidioc_default)
 			break;
 		ret = ops->vidioc_default(file, fh, cmd, arg);
 		break;
 	}
 	} /* switch */
 	if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
 		if (ret < 0) {
 			v4l_print_ioctl(vfd->name, cmd);
 			printk(KERN_CONT " error %ld\n", ret);
 		}
 	}
 	return ret;
 }
 /* In some cases, only a few fields are used as input, i.e. when the app sets
  * "index" and then the driver fills in the rest of the structure for the thing
  * with that index.  We only need to copy up the first non-input field.  */
 static unsigned long cmd_input_size(unsigned int cmd)
 {
 	/* Size of structure up to and including 'field' */
 #define CMDINSIZE(cmd, type, field) case _IOC_NR(VIDIOC_##cmd): return \
 		offsetof(struct v4l2_##type, field) + \
 		sizeof(((struct v4l2_##type *)0)->field);
 	switch (_IOC_NR(cmd)) {
 		CMDINSIZE(ENUM_FMT,		fmtdesc,	type);
 		CMDINSIZE(G_FMT,		format,		type);
 		CMDINSIZE(QUERYBUF,		buffer,		type);
 		CMDINSIZE(G_PARM,		streamparm,	type);
 		CMDINSIZE(ENUMSTD,		standard,	index);
 		CMDINSIZE(ENUMINPUT,		input,		index);
 		CMDINSIZE(G_CTRL,		control,	id);
 		CMDINSIZE(G_TUNER,		tuner,		index);
 		CMDINSIZE(QUERYCTRL,		queryctrl,	id);
 		CMDINSIZE(QUERYMENU,		querymenu,	index);
 		CMDINSIZE(ENUMOUTPUT,		output,		index);
 		CMDINSIZE(G_MODULATOR,		modulator,	index);
 		CMDINSIZE(G_FREQUENCY,		frequency,	tuner);
 		CMDINSIZE(CROPCAP,		cropcap,	type);
 		CMDINSIZE(G_CROP,		crop,		type);
 		CMDINSIZE(ENUMAUDIO,		audio, 		index);
 		CMDINSIZE(ENUMAUDOUT,		audioout, 	index);
 		CMDINSIZE(ENCODER_CMD,		encoder_cmd,	flags);
 		CMDINSIZE(TRY_ENCODER_CMD,	encoder_cmd,	flags);
 		CMDINSIZE(G_SLICED_VBI_CAP,	sliced_vbi_cap,	type);
 		CMDINSIZE(ENUM_FRAMESIZES,	frmsizeenum,	pixel_format);
 		CMDINSIZE(ENUM_FRAMEINTERVALS,	frmivalenum,	height);
 	default:
 		return _IOC_SIZE(cmd);
 	}
 }
 long video_ioctl2(struct file *file,
 	       unsigned int cmd, unsigned long arg)
 {
 	char	sbuf[128];
 	void    *mbuf = NULL;
 	void	*parg = NULL;
 	long	err  = -EINVAL;
 	int     is_ext_ctrl;
 	size_t  ctrls_size = 0;
 	void __user *user_ptr = NULL;
 #ifdef __OLD_VIDIOC_
 	cmd = video_fix_command(cmd);
 #endif
 	is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
 		       cmd == VIDIOC_TRY_EXT_CTRLS);
 	/*  Copy arguments into temp kernel buffer  */
 	if (_IOC_DIR(cmd) != _IOC_NONE) {
 		if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
 			parg = sbuf;
 		} else {
 			/* too big to allocate from stack */
 			mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
 			if (NULL == mbuf)
 				return -ENOMEM;
 			parg = mbuf;
 		}
 		err = -EFAULT;
 		if (_IOC_DIR(cmd) & _IOC_WRITE) {
 			unsigned long n = cmd_input_size(cmd);
 			if (copy_from_user(parg, (void __user *)arg, n))
 				goto out;
 			/* zero out anything we don't copy from userspace */
 			if (n < _IOC_SIZE(cmd))
 				memset((u8 *)parg + n, 0, _IOC_SIZE(cmd) - n);
 		} else {
 			/* read-only ioctl */
 			memset(parg, 0, _IOC_SIZE(cmd));
 		}
 	}
 	if (is_ext_ctrl) {
 		struct v4l2_ext_controls *p = parg;
 		/* In case of an error, tell the caller that it wasn't
 		   a specific control that caused it. */
 		p->error_idx = p->count;
 		user_ptr = (void __user *)p->controls;
 		if (p->count) {
 			ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
 			/* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
 			mbuf = kmalloc(ctrls_size, GFP_KERNEL);
 			err = -ENOMEM;
 			if (NULL == mbuf)
 				goto out_ext_ctrl;
 			err = -EFAULT;
 			if (copy_from_user(mbuf, user_ptr, ctrls_size))
 				goto out_ext_ctrl;
 			p->controls = mbuf;
 		}
 	}
 	/* Handles IOCTL */
 	err = __video_do_ioctl(file, cmd, parg);
 	if (err == -ENOIOCTLCMD)
 		err = -EINVAL;
 	if (is_ext_ctrl) {
 		struct v4l2_ext_controls *p = parg;
 		p->controls = (void *)user_ptr;
 		if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
 			err = -EFAULT;
 		goto out_ext_ctrl;
 	}
 	if (err < 0)
 		goto out;
 out_ext_ctrl:
 	/*  Copy results into user buffer  */
 	switch (_IOC_DIR(cmd)) {
 	case _IOC_READ:
 	case (_IOC_WRITE | _IOC_READ):
 		if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
 			err = -EFAULT;
 		break;
 	}
 out:
 	kfree(mbuf);
 	return err;
 }
 EXPORT_SYMBOL(video_ioctl2);

drivers/media/video/vivi.c

Diff comments View file @ 7e0a16f

 /*
  * Virtual Video driver - This code emulates a real video device with v4l2 api
  *
  * Copyright (c) 2006 by:
  *      Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
  *      Ted Walther <ted--a.t--enumera.com>
  *      John Sokol <sokol--a.t--videotechnology.com>
  *      http://v4l.videotechnology.com/
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the BSD Licence, GNU General Public License
  * as published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version
  */
 #include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/pci.h>
 #include <linux/random.h>
 #include <linux/version.h>
 #include <linux/mutex.h>
 #include <linux/videodev2.h>
 #include <linux/dma-mapping.h>
-#ifdef CONFIG_VIDEO_V4L1_COMPAT
-/* Include V4L1 specific functions. Should be removed soon */
-#include <linux/videodev.h>
-#endif
 #include <linux/interrupt.h>
 #include <linux/kthread.h>
 #include <linux/highmem.h>
 #include <linux/freezer.h>
 #include <media/videobuf-vmalloc.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-ioctl.h>
 #include "font.h"
 #define VIVI_MODULE_NAME "vivi"
 /* Wake up at about 30 fps */
 #define WAKE_NUMERATOR 30
 #define WAKE_DENOMINATOR 1001
 #define BUFFER_TIMEOUT     msecs_to_jiffies(500)  /* 0.5 seconds */
 #define VIVI_MAJOR_VERSION 0
 #define VIVI_MINOR_VERSION 6
 #define VIVI_RELEASE 0
 #define VIVI_VERSION \
 	KERNEL_VERSION(VIVI_MAJOR_VERSION, VIVI_MINOR_VERSION, VIVI_RELEASE)
 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
 MODULE_LICENSE("Dual BSD/GPL");
 static unsigned video_nr = -1;
 module_param(video_nr, uint, 0644);
 MODULE_PARM_DESC(video_nr, "videoX start number, -1 is autodetect");
 static unsigned n_devs = 1;
 module_param(n_devs, uint, 0644);
 MODULE_PARM_DESC(n_devs, "number of video devices to create");
 static unsigned debug;
 module_param(debug, uint, 0644);
 MODULE_PARM_DESC(debug, "activates debug info");
 static unsigned int vid_limit = 16;
 module_param(vid_limit, uint, 0644);
 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
 /* supported controls */
 static struct v4l2_queryctrl vivi_qctrl[] = {
 	{
 		.id            = V4L2_CID_AUDIO_VOLUME,
 		.name          = "Volume",
 		.minimum       = 0,
 		.maximum       = 65535,
 		.step          = 65535/100,
 		.default_value = 65535,
 		.flags         = V4L2_CTRL_FLAG_SLIDER,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 	}, {
 		.id            = V4L2_CID_BRIGHTNESS,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "Brightness",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 1,
 		.default_value = 127,
 		.flags         = V4L2_CTRL_FLAG_SLIDER,
 	}, {
 		.id            = V4L2_CID_CONTRAST,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "Contrast",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 0x1,
 		.default_value = 0x10,
 		.flags         = V4L2_CTRL_FLAG_SLIDER,
 	}, {
 		.id            = V4L2_CID_SATURATION,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "Saturation",
 		.minimum       = 0,
 		.maximum       = 255,
 		.step          = 0x1,
 		.default_value = 127,
 		.flags         = V4L2_CTRL_FLAG_SLIDER,
 	}, {
 		.id            = V4L2_CID_HUE,
 		.type          = V4L2_CTRL_TYPE_INTEGER,
 		.name          = "Hue",
 		.minimum       = -128,
 		.maximum       = 127,
 		.step          = 0x1,
 		.default_value = 0,
 		.flags         = V4L2_CTRL_FLAG_SLIDER,
 	}
 };
 #define dprintk(dev, level, fmt, arg...) \
 	v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
 /* ------------------------------------------------------------------
 	Basic structures
    ------------------------------------------------------------------*/
 struct vivi_fmt {
 	char  *name;
 	u32   fourcc;          /* v4l2 format id */
 	int   depth;
 };
 static struct vivi_fmt formats[] = {
 	{
 		.name     = "4:2:2, packed, YUYV",
 		.fourcc   = V4L2_PIX_FMT_YUYV,
 		.depth    = 16,
 	},
 	{
 		.name     = "4:2:2, packed, UYVY",
 		.fourcc   = V4L2_PIX_FMT_UYVY,
 		.depth    = 16,
 	},
 	{
 		.name     = "RGB565 (LE)",
 		.fourcc   = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
 		.depth    = 16,
 	},
 	{
 		.name     = "RGB565 (BE)",
 		.fourcc   = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
 		.depth    = 16,
 	},
 	{
 		.name     = "RGB555 (LE)",
 		.fourcc   = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
 		.depth    = 16,
 	},
 	{
 		.name     = "RGB555 (BE)",
 		.fourcc   = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
 		.depth    = 16,
 	},
 };
 static struct vivi_fmt *get_format(struct v4l2_format *f)
 {
 	struct vivi_fmt *fmt;
 	unsigned int k;
 	for (k = 0; k < ARRAY_SIZE(formats); k++) {
 		fmt = &formats[k];
 		if (fmt->fourcc == f->fmt.pix.pixelformat)
 			break;
 	}
 	if (k == ARRAY_SIZE(formats))
 		return NULL;
 	return &formats[k];
 }
 struct sg_to_addr {
 	int pos;
 	struct scatterlist *sg;
 };
 /* buffer for one video frame */
 struct vivi_buffer {
 	/* common v4l buffer stuff -- must be first */
 	struct videobuf_buffer vb;
 	struct vivi_fmt        *fmt;
 };
 struct vivi_dmaqueue {
 	struct list_head       active;
 	/* thread for generating video stream*/
 	struct task_struct         *kthread;
 	wait_queue_head_t          wq;
 	/* Counters to control fps rate */
 	int                        frame;
 	int                        ini_jiffies;
 };
 static LIST_HEAD(vivi_devlist);
 struct vivi_dev {
 	struct list_head           vivi_devlist;
 	struct v4l2_device 	   v4l2_dev;
 	spinlock_t                 slock;
 	struct mutex		   mutex;
 	int                        users;
 	/* various device info */
 	struct video_device        *vfd;
 	struct vivi_dmaqueue       vidq;
 	/* Several counters */
 	int                        h, m, s, ms;
 	unsigned long              jiffies;
 	char                       timestr[13];
 	int			   mv_count;	/* Controls bars movement */
 	/* Input Number */
 	int			   input;
 	/* Control 'registers' */
 	int 			   qctl_regs[ARRAY_SIZE(vivi_qctrl)];
 };
 struct vivi_fh {
 	struct vivi_dev            *dev;
 	/* video capture */
 	struct vivi_fmt            *fmt;
 	unsigned int               width, height;
 	struct videobuf_queue      vb_vidq;
 	enum v4l2_buf_type         type;
 	unsigned char              bars[8][3];
 	int			   input; 	/* Input Number on bars */
 };
 /* ------------------------------------------------------------------
 	DMA and thread functions
    ------------------------------------------------------------------*/
 /* Bars and Colors should match positions */
 enum colors {
 	WHITE,
 	AMBAR,
 	CYAN,
 	GREEN,
 	MAGENTA,
 	RED,
 	BLUE,
 	BLACK,
 };
 	/* R   G   B */
 #define COLOR_WHITE	{204, 204, 204}
 #define COLOR_AMBAR	{208, 208,   0}
 #define COLOR_CIAN	{  0, 206, 206}
 #define	COLOR_GREEN	{  0, 239,   0}
 #define COLOR_MAGENTA	{239,   0, 239}
 #define COLOR_RED	{205,   0,   0}
 #define COLOR_BLUE	{  0,   0, 255}
 #define COLOR_BLACK	{  0,   0,   0}
 struct bar_std {
 	u8 bar[8][3];
 };
 /* Maximum number of bars are 10 - otherwise, the input print code
    should be modified */
 static struct bar_std bars[] = {
 	{	/* Standard ITU-R color bar sequence */
 		{
 			COLOR_WHITE,
 			COLOR_AMBAR,
 			COLOR_CIAN,
 			COLOR_GREEN,
 			COLOR_MAGENTA,
 			COLOR_RED,
 			COLOR_BLUE,
 			COLOR_BLACK,
 		}
 	}, {
 		{
 			COLOR_WHITE,
 			COLOR_AMBAR,
 			COLOR_BLACK,
 			COLOR_WHITE,
 			COLOR_AMBAR,
 			COLOR_BLACK,
 			COLOR_WHITE,
 			COLOR_AMBAR,
 		}
 	}, {
 		{
 			COLOR_WHITE,
 			COLOR_CIAN,
 			COLOR_BLACK,
 			COLOR_WHITE,
 			COLOR_CIAN,
 			COLOR_BLACK,
 			COLOR_WHITE,
 			COLOR_CIAN,
 		}
 	}, {
 		{
 			COLOR_WHITE,
 			COLOR_GREEN,
 			COLOR_BLACK,
 			COLOR_WHITE,
 			COLOR_GREEN,
 			COLOR_BLACK,
 			COLOR_WHITE,
 			COLOR_GREEN,
 		}
 	},
 };
 #define NUM_INPUTS ARRAY_SIZE(bars)
 #define TO_Y(r, g, b) \
 	(((16829 * r + 33039 * g + 6416 * b  + 32768) >> 16) + 16)
 /* RGB to  V(Cr) Color transform */
 #define TO_V(r, g, b) \
 	(((28784 * r - 24103 * g - 4681 * b  + 32768) >> 16) + 128)
 /* RGB to  U(Cb) Color transform */
 #define TO_U(r, g, b) \
 	(((-9714 * r - 19070 * g + 28784 * b + 32768) >> 16) + 128)
 #define TSTAMP_MIN_Y	24
 #define TSTAMP_MAX_Y	(TSTAMP_MIN_Y + 15)
 #define TSTAMP_INPUT_X	10
 #define TSTAMP_MIN_X	(54 + TSTAMP_INPUT_X)
 static void gen_twopix(struct vivi_fh *fh, unsigned char *buf, int colorpos)
 {
 	unsigned char r_y, g_u, b_v;
 	unsigned char *p;
 	int color;
 	r_y = fh->bars[colorpos][0]; /* R or precalculated Y */
 	g_u = fh->bars[colorpos][1]; /* G or precalculated U */
 	b_v = fh->bars[colorpos][2]; /* B or precalculated V */
 	for (color = 0; color < 4; color++) {
 		p = buf + color;
 		switch (fh->fmt->fourcc) {
 		case V4L2_PIX_FMT_YUYV:
 			switch (color) {
 			case 0:
 			case 2:
 				*p = r_y;
 				break;
 			case 1:
 				*p = g_u;
 				break;
 			case 3:
 				*p = b_v;
 				break;
 			}
 			break;
 		case V4L2_PIX_FMT_UYVY:
 			switch (color) {
 			case 1:
 			case 3:
 				*p = r_y;
 				break;
 			case 0:
 				*p = g_u;
 				break;
 			case 2:
 				*p = b_v;
 				break;
 			}
 			break;
 		case V4L2_PIX_FMT_RGB565:
 			switch (color) {
 			case 0:
 			case 2:
 				*p = (g_u << 5) | b_v;
 				break;
 			case 1:
 			case 3:
 				*p = (r_y << 3) | (g_u >> 3);
 				break;
 			}
 			break;
 		case V4L2_PIX_FMT_RGB565X:
 			switch (color) {
 			case 0:
 			case 2:
 				*p = (r_y << 3) | (g_u >> 3);
 				break;
 			case 1:
 			case 3:
 				*p = (g_u << 5) | b_v;
 				break;
 			}
 			break;
 		case V4L2_PIX_FMT_RGB555:
 			switch (color) {
 			case 0:
 			case 2:
 				*p = (g_u << 5) | b_v;
 				break;
 			case 1:
 			case 3:
 				*p = (r_y << 2) | (g_u >> 3);
 				break;
 			}
 			break;
 		case V4L2_PIX_FMT_RGB555X:
 			switch (color) {
 			case 0:
 			case 2:
 				*p = (r_y << 2) | (g_u >> 3);
 				break;
 			case 1:
 			case 3:
 				*p = (g_u << 5) | b_v;
 				break;
 			}
 			break;
 		}
 	}
 }
 static void gen_line(struct vivi_fh *fh, char *basep, int inipos, int wmax,
 		int hmax, int line, int count, char *timestr)
 {
 	int  w, i, j;
 	int pos = inipos;
 	char *s;
 	u8 chr;
 	/* We will just duplicate the second pixel at the packet */
 	wmax /= 2;
 	/* Generate a standard color bar pattern */
 	for (w = 0; w < wmax; w++) {
 		int colorpos = ((w + count) * 8/(wmax + 1)) % 8;
 		gen_twopix(fh, basep + pos, colorpos);
 		pos += 4; /* only 16 bpp supported for now */
 	}
 	/* Prints input entry number */
 	/* Checks if it is possible to input number */
 	if (TSTAMP_MAX_Y >= hmax)
 		goto end;
 	if (TSTAMP_INPUT_X + strlen(timestr) >= wmax)
 		goto end;
 	if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
 		chr = rom8x16_bits[fh->input * 16 + line - TSTAMP_MIN_Y];
 		pos = TSTAMP_INPUT_X;
 		for (i = 0; i < 7; i++) {
 			/* Draw white font on black background */
 			if (chr & 1 << (7 - i))
 				gen_twopix(fh, basep + pos, WHITE);
 			else
 				gen_twopix(fh, basep + pos, BLACK);
 			pos += 2;
 		}
 	}
 	/* Checks if it is possible to show timestamp */
 	if (TSTAMP_MIN_X + strlen(timestr) >= wmax)
 		goto end;
 	/* Print stream time */
 	if (line >= TSTAMP_MIN_Y && line <= TSTAMP_MAX_Y) {
 		j = TSTAMP_MIN_X;
 		for (s = timestr; *s; s++) {
 			chr = rom8x16_bits[(*s-0x30)*16+line-TSTAMP_MIN_Y];
 			for (i = 0; i < 7; i++) {
 				pos = inipos + j * 2;
 				/* Draw white font on black background */
 				if (chr & 1 << (7 - i))
 					gen_twopix(fh, basep + pos, WHITE);
 				else
 					gen_twopix(fh, basep + pos, BLACK);
 				j++;
 			}
 		}
 	}
 end:
 	return;
 }
 static void vivi_fillbuff(struct vivi_fh *fh, struct vivi_buffer *buf)
 {
 	struct vivi_dev *dev = fh->dev;
 	int h , pos = 0;
 	int hmax  = buf->vb.height;
 	int wmax  = buf->vb.width;
 	struct timeval ts;
 	char *tmpbuf;
 	void *vbuf = videobuf_to_vmalloc(&buf->vb);
 	if (!vbuf)
 		return;
 	tmpbuf = kmalloc(wmax * 2, GFP_ATOMIC);
 	if (!tmpbuf)
 		return;
 	for (h = 0; h < hmax; h++) {
 		gen_line(fh, tmpbuf, 0, wmax, hmax, h, dev->mv_count,
 			 dev->timestr);
 		memcpy(vbuf + pos, tmpbuf, wmax * 2);
 		pos += wmax*2;
 	}
 	dev->mv_count++;
 	kfree(tmpbuf);
 	/* Updates stream time */
 	dev->ms += jiffies_to_msecs(jiffies-dev->jiffies);
 	dev->jiffies = jiffies;
 	if (dev->ms >= 1000) {
 		dev->ms -= 1000;
 		dev->s++;
 		if (dev->s >= 60) {
 			dev->s -= 60;
 			dev->m++;
 			if (dev->m > 60) {
 				dev->m -= 60;
 				dev->h++;
 				if (dev->h > 24)
 					dev->h -= 24;
 			}
 		}
 	}
 	sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
 			dev->h, dev->m, dev->s, dev->ms);
 	dprintk(dev, 2, "vivifill at %s: Buffer 0x%08lx size= %d\n",
 			dev->timestr, (unsigned long)tmpbuf, pos);
 	/* Advice that buffer was filled */
 	buf->vb.field_count++;
 	do_gettimeofday(&ts);
 	buf->vb.ts = ts;
 	buf->vb.state = VIDEOBUF_DONE;
 }
 static void vivi_thread_tick(struct vivi_fh *fh)
 {
 	struct vivi_buffer *buf;
 	struct vivi_dev *dev = fh->dev;
 	struct vivi_dmaqueue *dma_q = &dev->vidq;
 	unsigned long flags = 0;
 	dprintk(dev, 1, "Thread tick\n");
 	spin_lock_irqsave(&dev->slock, flags);
 	if (list_empty(&dma_q->active)) {
 		dprintk(dev, 1, "No active queue to serve\n");
 		goto unlock;
 	}
 	buf = list_entry(dma_q->active.next,
 			 struct vivi_buffer, vb.queue);
 	/* Nobody is waiting on this buffer, return */
 	if (!waitqueue_active(&buf->vb.done))
 		goto unlock;
 	list_del(&buf->vb.queue);
 	do_gettimeofday(&buf->vb.ts);
 	/* Fill buffer */
 	vivi_fillbuff(fh, buf);
 	dprintk(dev, 1, "filled buffer %p\n", buf);
 	wake_up(&buf->vb.done);
 	dprintk(dev, 2, "[%p/%d] wakeup\n", buf, buf->vb. i);
 unlock:
 	spin_unlock_irqrestore(&dev->slock, flags);
 	return;
 }
 #define frames_to_ms(frames)					\
 	((frames * WAKE_NUMERATOR * 1000) / WAKE_DENOMINATOR)
 static void vivi_sleep(struct vivi_fh *fh)
 {
 	struct vivi_dev *dev = fh->dev;
 	struct vivi_dmaqueue *dma_q = &dev->vidq;
 	int timeout;
 	DECLARE_WAITQUEUE(wait, current);
 	dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
 		(unsigned long)dma_q);
 	add_wait_queue(&dma_q->wq, &wait);
 	if (kthread_should_stop())
 		goto stop_task;
 	/* Calculate time to wake up */
 	timeout = msecs_to_jiffies(frames_to_ms(1));
 	vivi_thread_tick(fh);
 	schedule_timeout_interruptible(timeout);
 stop_task:
 	remove_wait_queue(&dma_q->wq, &wait);
 	try_to_freeze();
 }
 static int vivi_thread(void *data)
 {
 	struct vivi_fh  *fh = data;
 	struct vivi_dev *dev = fh->dev;
 	dprintk(dev, 1, "thread started\n");
 	set_freezable();
 	for (;;) {
 		vivi_sleep(fh);
 		if (kthread_should_stop())
 			break;
 	}
 	dprintk(dev, 1, "thread: exit\n");
 	return 0;
 }
 static int vivi_start_thread(struct vivi_fh *fh)
 {
 	struct vivi_dev *dev = fh->dev;
 	struct vivi_dmaqueue *dma_q = &dev->vidq;
 	dma_q->frame = 0;
 	dma_q->ini_jiffies = jiffies;
 	dprintk(dev, 1, "%s\n", __func__);
 	dma_q->kthread = kthread_run(vivi_thread, fh, "vivi");
 	if (IS_ERR(dma_q->kthread)) {
 		v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
 		return PTR_ERR(dma_q->kthread);
 	}
 	/* Wakes thread */
 	wake_up_interruptible(&dma_q->wq);
 	dprintk(dev, 1, "returning from %s\n", __func__);
 	return 0;
 }
 static void vivi_stop_thread(struct vivi_dmaqueue  *dma_q)
 {
 	struct vivi_dev *dev = container_of(dma_q, struct vivi_dev, vidq);
 	dprintk(dev, 1, "%s\n", __func__);
 	/* shutdown control thread */
 	if (dma_q->kthread) {
 		kthread_stop(dma_q->kthread);
 		dma_q->kthread = NULL;
 	}
 }
 /* ------------------------------------------------------------------
 	Videobuf operations
    ------------------------------------------------------------------*/
 static int
 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
 {
 	struct vivi_fh  *fh = vq->priv_data;
 	struct vivi_dev *dev  = fh->dev;
 	*size = fh->width*fh->height*2;
 	if (0 == *count)
 		*count = 32;
 	while (*size * *count > vid_limit * 1024 * 1024)
 		(*count)--;
 	dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
 		*count, *size);
 	return 0;
 }
 static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
 {
 	struct vivi_fh  *fh = vq->priv_data;
 	struct vivi_dev *dev  = fh->dev;
 	dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
 	if (in_interrupt())
 		BUG();
 	videobuf_vmalloc_free(&buf->vb);
 	dprintk(dev, 1, "free_buffer: freed\n");
 	buf->vb.state = VIDEOBUF_NEEDS_INIT;
 }
 #define norm_maxw() 1024
 #define norm_maxh() 768
 static int
 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 						enum v4l2_field field)
 {
 	struct vivi_fh     *fh  = vq->priv_data;
 	struct vivi_dev    *dev = fh->dev;
 	struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
 	int rc;
 	dprintk(dev, 1, "%s, field=%d\n", __func__, field);
 	BUG_ON(NULL == fh->fmt);
 	if (fh->width  < 48 || fh->width  > norm_maxw() ||
 	    fh->height < 32 || fh->height > norm_maxh())
 		return -EINVAL;
 	buf->vb.size = fh->width*fh->height*2;
 	if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
 		return -EINVAL;
 	/* These properties only change when queue is idle, see s_fmt */
 	buf->fmt       = fh->fmt;
 	buf->vb.width  = fh->width;
 	buf->vb.height = fh->height;
 	buf->vb.field  = field;
 	if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 		rc = videobuf_iolock(vq, &buf->vb, NULL);
 		if (rc < 0)
 			goto fail;
 	}
 	buf->vb.state = VIDEOBUF_PREPARED;
 	return 0;
 fail:
 	free_buffer(vq, buf);
 	return rc;
 }
 static void
 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 {
 	struct vivi_buffer    *buf  = container_of(vb, struct vivi_buffer, vb);
 	struct vivi_fh        *fh   = vq->priv_data;
 	struct vivi_dev       *dev  = fh->dev;
 	struct vivi_dmaqueue *vidq = &dev->vidq;
 	dprintk(dev, 1, "%s\n", __func__);
 	buf->vb.state = VIDEOBUF_QUEUED;
 	list_add_tail(&buf->vb.queue, &vidq->active);
 }
 static void buffer_release(struct videobuf_queue *vq,
 			   struct videobuf_buffer *vb)
 {
 	struct vivi_buffer   *buf  = container_of(vb, struct vivi_buffer, vb);
 	struct vivi_fh       *fh   = vq->priv_data;
 	struct vivi_dev      *dev  = (struct vivi_dev *)fh->dev;
 	dprintk(dev, 1, "%s\n", __func__);
 	free_buffer(vq, buf);
 }
 static struct videobuf_queue_ops vivi_video_qops = {
 	.buf_setup      = buffer_setup,
 	.buf_prepare    = buffer_prepare,
 	.buf_queue      = buffer_queue,
 	.buf_release    = buffer_release,
 };
 /* ------------------------------------------------------------------
 	IOCTL vidioc handling
    ------------------------------------------------------------------*/
 static int vidioc_querycap(struct file *file, void  *priv,
 					struct v4l2_capability *cap)
 {
 	struct vivi_fh  *fh  = priv;
 	struct vivi_dev *dev = fh->dev;
 	strcpy(cap->driver, "vivi");
 	strcpy(cap->card, "vivi");
 	strlcpy(cap->bus_info, dev->v4l2_dev.name, sizeof(cap->bus_info));
 	cap->version = VIVI_VERSION;
 	cap->capabilities =	V4L2_CAP_VIDEO_CAPTURE |
 				V4L2_CAP_STREAMING     |
 				V4L2_CAP_READWRITE;
 	return 0;
 }
 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 					struct v4l2_fmtdesc *f)
 {
 	struct vivi_fmt *fmt;
 	if (f->index >= ARRAY_SIZE(formats))
 		return -EINVAL;
 	fmt = &formats[f->index];
 	strlcpy(f->description, fmt->name, sizeof(f->description));
 	f->pixelformat = fmt->fourcc;
 	return 0;
 }
 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 					struct v4l2_format *f)
 {
 	struct vivi_fh *fh = priv;
 	f->fmt.pix.width        = fh->width;
 	f->fmt.pix.height       = fh->height;
 	f->fmt.pix.field        = fh->vb_vidq.field;
 	f->fmt.pix.pixelformat  = fh->fmt->fourcc;
 	f->fmt.pix.bytesperline =
 		(f->fmt.pix.width * fh->fmt->depth) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	return (0);
 }
 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 			struct v4l2_format *f)
 {
 	struct vivi_fh  *fh  = priv;
 	struct vivi_dev *dev = fh->dev;
 	struct vivi_fmt *fmt;
 	enum v4l2_field field;
 	unsigned int maxw, maxh;
 	fmt = get_format(f);
 	if (!fmt) {
 		dprintk(dev, 1, "Fourcc format (0x%08x) invalid.\n",
 			f->fmt.pix.pixelformat);
 		return -EINVAL;
 	}
 	field = f->fmt.pix.field;
 	if (field == V4L2_FIELD_ANY) {
 		field = V4L2_FIELD_INTERLACED;
 	} else if (V4L2_FIELD_INTERLACED != field) {
 		dprintk(dev, 1, "Field type invalid.\n");
 		return -EINVAL;
 	}
 	maxw  = norm_maxw();
 	maxh  = norm_maxh();
 	f->fmt.pix.field = field;
 	if (f->fmt.pix.height < 32)
 		f->fmt.pix.height = 32;
 	if (f->fmt.pix.height > maxh)
 		f->fmt.pix.height = maxh;
 	if (f->fmt.pix.width < 48)
 		f->fmt.pix.width = 48;
 	if (f->fmt.pix.width > maxw)
 		f->fmt.pix.width = maxw;
 	f->fmt.pix.width &= ~0x03;
 	f->fmt.pix.bytesperline =
 		(f->fmt.pix.width * fmt->depth) >> 3;
 	f->fmt.pix.sizeimage =
 		f->fmt.pix.height * f->fmt.pix.bytesperline;
 	return 0;
 }
 /* precalculate color bar values to speed up rendering */
 static void precalculate_bars(struct vivi_fh *fh)
 {
 	struct vivi_dev *dev = fh->dev;
 	unsigned char r, g, b;
 	int k, is_yuv;
 	fh->input = dev->input;
 	for (k = 0; k < 8; k++) {
 		r = bars[fh->input].bar[k][0];
 		g = bars[fh->input].bar[k][1];
 		b = bars[fh->input].bar[k][2];
 		is_yuv = 0;
 		switch (fh->fmt->fourcc) {
 		case V4L2_PIX_FMT_YUYV:
 		case V4L2_PIX_FMT_UYVY:
 			is_yuv = 1;
 			break;
 		case V4L2_PIX_FMT_RGB565:
 		case V4L2_PIX_FMT_RGB565X:
 			r >>= 3;
 			g >>= 2;
 			b >>= 3;
 			break;
 		case V4L2_PIX_FMT_RGB555:
 		case V4L2_PIX_FMT_RGB555X:
 			r >>= 3;
 			g >>= 3;
 			b >>= 3;
 			break;
 		}
 		if (is_yuv) {
 			fh->bars[k][0] = TO_Y(r, g, b);	/* Luma */
 			fh->bars[k][1] = TO_U(r, g, b);	/* Cb */
 			fh->bars[k][2] = TO_V(r, g, b);	/* Cr */
 		} else {
 			fh->bars[k][0] = r;
 			fh->bars[k][1] = g;
 			fh->bars[k][2] = b;
 		}
 	}
 }
 /*FIXME: This seems to be generic enough to be at videodev2 */
 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 					struct v4l2_format *f)
 {
 	struct vivi_fh *fh = priv;
 	struct videobuf_queue *q = &fh->vb_vidq;
 	int ret = vidioc_try_fmt_vid_cap(file, fh, f);
 	if (ret < 0)
 		return ret;
 	mutex_lock(&q->vb_lock);
 	if (videobuf_queue_is_busy(&fh->vb_vidq)) {
 		dprintk(fh->dev, 1, "%s queue busy\n", __func__);
 		ret = -EBUSY;
 		goto out;
 	}
 	fh->fmt           = get_format(f);
 	fh->width         = f->fmt.pix.width;
 	fh->height        = f->fmt.pix.height;
 	fh->vb_vidq.field = f->fmt.pix.field;
 	fh->type          = f->type;
 	precalculate_bars(fh);
 	ret = 0;
 out:
 	mutex_unlock(&q->vb_lock);
 	return ret;
 }
 static int vidioc_reqbufs(struct file *file, void *priv,
 			  struct v4l2_requestbuffers *p)
 {
 	struct vivi_fh  *fh = priv;
 	return (videobuf_reqbufs(&fh->vb_vidq, p));
 }
 static int vidioc_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
 {
 	struct vivi_fh  *fh = priv;
 	return (videobuf_querybuf(&fh->vb_vidq, p));
 }
 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 {
 	struct vivi_fh *fh = priv;
 	return (videobuf_qbuf(&fh->vb_vidq, p));
 }
 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
 {
 	struct vivi_fh  *fh = priv;
 	return (videobuf_dqbuf(&fh->vb_vidq, p,
 				file->f_flags & O_NONBLOCK));
 }
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
 {
 	struct vivi_fh  *fh = priv;
 	return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
 }
 #endif
 static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
 {
 	struct vivi_fh  *fh = priv;
 	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 		return -EINVAL;
 	if (i != fh->type)
 		return -EINVAL;
 	return videobuf_streamon(&fh->vb_vidq);
 }
 static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
 {
 	struct vivi_fh  *fh = priv;
 	if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 		return -EINVAL;
 	if (i != fh->type)
 		return -EINVAL;
 	return videobuf_streamoff(&fh->vb_vidq);
 }
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *i)
 {
 	return 0;
 }
 /* only one input in this sample driver */
 static int vidioc_enum_input(struct file *file, void *priv,
 				struct v4l2_input *inp)
 {
 	if (inp->index >= NUM_INPUTS)
 		return -EINVAL;
 	inp->type = V4L2_INPUT_TYPE_CAMERA;
 	inp->std = V4L2_STD_525_60;
 	sprintf(inp->name, "Camera %u", inp->index);
 	return (0);
 }
 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 {
 	struct vivi_fh *fh = priv;
 	struct vivi_dev *dev = fh->dev;
 	*i = dev->input;
 	return (0);
 }
 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 {
 	struct vivi_fh *fh = priv;
 	struct vivi_dev *dev = fh->dev;
 	if (i >= NUM_INPUTS)
 		return -EINVAL;
 	dev->input = i;
 	precalculate_bars(fh);
 	return (0);
 }
 	/* --- controls ---------------------------------------------- */
 static int vidioc_queryctrl(struct file *file, void *priv,
 			    struct v4l2_queryctrl *qc)
 {
 	int i;
 	for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
 		if (qc->id && qc->id == vivi_qctrl[i].id) {
 			memcpy(qc, &(vivi_qctrl[i]),
 				sizeof(*qc));
 			return (0);
 		}
 	return -EINVAL;
 }
 static int vidioc_g_ctrl(struct file *file, void *priv,
 			 struct v4l2_control *ctrl)
 {
 	struct vivi_fh *fh = priv;
 	struct vivi_dev *dev = fh->dev;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
 		if (ctrl->id == vivi_qctrl[i].id) {
 			ctrl->value = dev->qctl_regs[i];
 			return 0;
 		}
 	return -EINVAL;
 }
 static int vidioc_s_ctrl(struct file *file, void *priv,
 				struct v4l2_control *ctrl)
 {
 	struct vivi_fh *fh = priv;
 	struct vivi_dev *dev = fh->dev;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
 		if (ctrl->id == vivi_qctrl[i].id) {
 			if (ctrl->value < vivi_qctrl[i].minimum ||
 			    ctrl->value > vivi_qctrl[i].maximum) {
 				return -ERANGE;
 			}
 			dev->qctl_regs[i] = ctrl->value;
 			return 0;
 		}
 	return -EINVAL;
 }
 /* ------------------------------------------------------------------
 	File operations for the device
    ------------------------------------------------------------------*/
 static int vivi_open(struct file *file)
 {
 	struct vivi_dev *dev = video_drvdata(file);
 	struct vivi_fh *fh = NULL;
 	int retval = 0;
 	mutex_lock(&dev->mutex);
 	dev->users++;
 	if (dev->users > 1) {
 		dev->users--;
 		mutex_unlock(&dev->mutex);
 		return -EBUSY;
 	}
 	dprintk(dev, 1, "open /dev/video%d type=%s users=%d\n", dev->vfd->num,
 		v4l2_type_names[V4L2_BUF_TYPE_VIDEO_CAPTURE], dev->users);
 	/* allocate + initialize per filehandle data */
 	fh = kzalloc(sizeof(*fh), GFP_KERNEL);
 	if (NULL == fh) {
 		dev->users--;
 		retval = -ENOMEM;
 	}
 	mutex_unlock(&dev->mutex);
 	if (retval)
 		return retval;
 	file->private_data = fh;
 	fh->dev      = dev;
 	fh->type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 	fh->fmt      = &formats[0];
 	fh->width    = 640;
 	fh->height   = 480;
 	/* Resets frame counters */
 	dev->h = 0;
 	dev->m = 0;
 	dev->s = 0;
 	dev->ms = 0;
 	dev->mv_count = 0;
 	dev->jiffies = jiffies;
 	sprintf(dev->timestr, "%02d:%02d:%02d:%03d",
 			dev->h, dev->m, dev->s, dev->ms);
 	videobuf_queue_vmalloc_init(&fh->vb_vidq, &vivi_video_qops,
 			NULL, &dev->slock, fh->type, V4L2_FIELD_INTERLACED,
 			sizeof(struct vivi_buffer), fh);
 	vivi_start_thread(fh);
 	return 0;
 }
 static ssize_t
 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
 {
 	struct vivi_fh *fh = file->private_data;
 	if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 		return videobuf_read_stream(&fh->vb_vidq, data, count, ppos, 0,
 					file->f_flags & O_NONBLOCK);
 	}
 	return 0;
 }
 static unsigned int
 vivi_poll(struct file *file, struct poll_table_struct *wait)
 {
 	struct vivi_fh        *fh = file->private_data;
 	struct vivi_dev       *dev = fh->dev;
 	struct videobuf_queue *q = &fh->vb_vidq;
 	dprintk(dev, 1, "%s\n", __func__);
 	if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
 		return POLLERR;
 	return videobuf_poll_stream(file, q, wait);
 }
 static int vivi_close(struct file *file)
 {
 	struct vivi_fh         *fh = file->private_data;
 	struct vivi_dev *dev       = fh->dev;
 	struct vivi_dmaqueue *vidq = &dev->vidq;
 	int minor = video_devdata(file)->minor;
 	vivi_stop_thread(vidq);
 	videobuf_stop(&fh->vb_vidq);
 	videobuf_mmap_free(&fh->vb_vidq);
 	kfree(fh);
 	mutex_lock(&dev->mutex);
 	dev->users--;
 	mutex_unlock(&dev->mutex);
 	dprintk(dev, 1, "close called (minor=%d, users=%d)\n",
 		minor, dev->users);
 	return 0;
 }
 static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct vivi_fh  *fh = file->private_data;
 	struct vivi_dev *dev = fh->dev;
 	int ret;
 	dprintk(dev, 1, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
 	ret = videobuf_mmap_mapper(&fh->vb_vidq, vma);
 	dprintk(dev, 1, "vma start=0x%08lx, size=%ld, ret=%d\n",
 		(unsigned long)vma->vm_start,
 		(unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
 		ret);
 	return ret;
 }
 static const struct v4l2_file_operations vivi_fops = {
 	.owner		= THIS_MODULE,
 	.open           = vivi_open,
 	.release        = vivi_close,
 	.read           = vivi_read,
 	.poll		= vivi_poll,
 	.ioctl          = video_ioctl2, /* V4L2 ioctl handler */
 	.mmap           = vivi_mmap,
 };
 static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
 	.vidioc_querycap      = vidioc_querycap,
 	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
 	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
 	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
 	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
 	.vidioc_reqbufs       = vidioc_reqbufs,
 	.vidioc_querybuf      = vidioc_querybuf,
 	.vidioc_qbuf          = vidioc_qbuf,
 	.vidioc_dqbuf         = vidioc_dqbuf,
 	.vidioc_s_std         = vidioc_s_std,
 	.vidioc_enum_input    = vidioc_enum_input,
 	.vidioc_g_input       = vidioc_g_input,
 	.vidioc_s_input       = vidioc_s_input,
 	.vidioc_queryctrl     = vidioc_queryctrl,
 	.vidioc_g_ctrl        = vidioc_g_ctrl,
 	.vidioc_s_ctrl        = vidioc_s_ctrl,
 	.vidioc_streamon      = vidioc_streamon,
 	.vidioc_streamoff     = vidioc_streamoff,
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 	.vidiocgmbuf          = vidiocgmbuf,
 #endif
 };
 static struct video_device vivi_template = {
 	.name		= "vivi",
 	.fops           = &vivi_fops,
 	.ioctl_ops 	= &vivi_ioctl_ops,
 	.minor		= -1,
 	.release	= video_device_release,
 	.tvnorms              = V4L2_STD_525_60,
 	.current_norm         = V4L2_STD_NTSC_M,
 };
 /* -----------------------------------------------------------------
 	Initialization and module stuff
    ------------------------------------------------------------------*/
 static int vivi_release(void)
 {
 	struct vivi_dev *dev;
 	struct list_head *list;
 	while (!list_empty(&vivi_devlist)) {
 		list = vivi_devlist.next;
 		list_del(list);
 		dev = list_entry(list, struct vivi_dev, vivi_devlist);
 		v4l2_info(&dev->v4l2_dev, "unregistering /dev/video%d\n",
 			dev->vfd->num);
 		video_unregister_device(dev->vfd);
 		v4l2_device_unregister(&dev->v4l2_dev);
 		kfree(dev);
 	}
 	return 0;
 }
 static int __init vivi_create_instance(int inst)
 {
 	struct vivi_dev *dev;
 	struct video_device *vfd;
 	int ret, i;
 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 	if (!dev)
 		return -ENOMEM;
 	snprintf(dev->v4l2_dev.name, sizeof(dev->v4l2_dev.name),
 			"%s-%03d", VIVI_MODULE_NAME, inst);
 	ret = v4l2_device_register(NULL, &dev->v4l2_dev);
 	if (ret)
 		goto free_dev;
 	/* init video dma queues */
 	INIT_LIST_HEAD(&dev->vidq.active);
 	init_waitqueue_head(&dev->vidq.wq);
 	/* initialize locks */
 	spin_lock_init(&dev->slock);
 	mutex_init(&dev->mutex);
 	ret = -ENOMEM;
 	vfd = video_device_alloc();
 	if (!vfd)
 		goto unreg_dev;
 	*vfd = vivi_template;
 	ret = video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
 	if (ret < 0)
 		goto rel_vdev;
 	video_set_drvdata(vfd, dev);
 	/* Set all controls to their default value. */
 	for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
 		dev->qctl_regs[i] = vivi_qctrl[i].default_value;
 	/* Now that everything is fine, let's add it to device list */
 	list_add_tail(&dev->vivi_devlist, &vivi_devlist);
 	snprintf(vfd->name, sizeof(vfd->name), "%s (%i)",
 			vivi_template.name, vfd->num);
 	if (video_nr >= 0)
 		video_nr++;
 	dev->vfd = vfd;
 	v4l2_info(&dev->v4l2_dev, "V4L2 device registered as /dev/video%d\n",
 			vfd->num);
 	return 0;
 rel_vdev:
 	video_device_release(vfd);
 unreg_dev:
 	v4l2_device_unregister(&dev->v4l2_dev);
 free_dev:
 	kfree(dev);
 	return ret;
 }
 /* This routine allocates from 1 to n_devs virtual drivers.
    The real maximum number of virtual drivers will depend on how many drivers
    will succeed. This is limited to the maximum number of devices that
    videodev supports, which is equal to VIDEO_NUM_DEVICES.
  */
 static int __init vivi_init(void)
 {
 	int ret, i;
 	if (n_devs <= 0)
 		n_devs = 1;
 	for (i = 0; i < n_devs; i++) {
 		ret = vivi_create_instance(i);
 		if (ret) {
 			/* If some instantiations succeeded, keep driver */
 			if (i)
 				ret = 0;
 			break;
 		}
 	}
 	if (ret < 0) {
 		printk(KERN_INFO "Error %d while loading vivi driver\n", ret);
 		return ret;
 	}
 	printk(KERN_INFO "Video Technology Magazine Virtual Video "
 			"Capture Board ver %u.%u.%u successfully loaded.\n",
 			(VIVI_VERSION >> 16) & 0xFF, (VIVI_VERSION >> 8) & 0xFF,
 			VIVI_VERSION & 0xFF);
 	/* n_devs will reflect the actual number of allocated devices */
 	n_devs = i;
 	return ret;
 }
 static void __exit vivi_exit(void)
 {
 	vivi_release();
 }
 module_init(vivi_init);
 module_exit(vivi_exit);

drivers/media/video/w9966.c

Diff comments View file @ 7e0a16f

1	/*	1	/*
2	Winbond w9966cf Webcam parport driver.	2	Winbond w9966cf Webcam parport driver.
3		3
4	Version 0.32	4	Version 0.32
5		5
6	Copyright (C) 2001 Jakob Kemi <jakob.kemi@post.utfors.se>	6	Copyright (C) 2001 Jakob Kemi <jakob.kemi@post.utfors.se>
7		7
8	This program is free software; you can redistribute it and/or modify	8	This program is free software; you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by	9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation; either version 2 of the License, or	10	the Free Software Foundation; either version 2 of the License, or
11	(at your option) any later version.	11	(at your option) any later version.
12		12
13	This program is distributed in the hope that it will be useful,	13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.	16	GNU General Public License for more details.
17		17
18	You should have received a copy of the GNU General Public License	18	You should have received a copy of the GNU General Public License
19	along with this program; if not, write to the Free Software	19	along with this program; if not, write to the Free Software
20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*/	21	*/
22	/*	22	/*
23	Supported devices:	23	Supported devices:
24	*Lifeview FlyCam Supra (using the Philips saa7111a chip)	24	*Lifeview FlyCam Supra (using the Philips saa7111a chip)
25		25
26	Does any other model using the w9966 interface chip exist ?	26	Does any other model using the w9966 interface chip exist ?
27		27
28	Todo:	28	Todo:
29		29
30	*Add a working EPP mode, since DMA ECP read isn't implemented	30	*Add a working EPP mode, since DMA ECP read isn't implemented
31	in the parport drivers. (That's why it's so sloow)	31	in the parport drivers. (That's why it's so sloow)
32		32
33	*Add support for other ccd-control chips than the saa7111	33	*Add support for other ccd-control chips than the saa7111
34	please send me feedback on what kind of chips you have.	34	please send me feedback on what kind of chips you have.
35		35
36	*Add proper probing. I don't know what's wrong with the IEEE1284	36	*Add proper probing. I don't know what's wrong with the IEEE1284
37	parport drivers but (IEEE1284_MODE_NIBBLE\|IEEE1284_DEVICE_ID)	37	parport drivers but (IEEE1284_MODE_NIBBLE\|IEEE1284_DEVICE_ID)
38	and nibble read seems to be broken for some peripherals.	38	and nibble read seems to be broken for some peripherals.
39		39
40	*Add probing for onboard SRAM, port directions etc. (if possible)	40	*Add probing for onboard SRAM, port directions etc. (if possible)
41		41
42	*Add support for the hardware compressed modes (maybe using v4l2)	42	*Add support for the hardware compressed modes (maybe using v4l2)
43		43
44	*Fix better support for the capture window (no skewed images, v4l	44	*Fix better support for the capture window (no skewed images, v4l
45	interface to capt. window)	45	interface to capt. window)
46		46
47	*Probably some bugs that I don't know of	47	*Probably some bugs that I don't know of
48		48
49	Please support me by sending feedback!	49	Please support me by sending feedback!
50		50
51	Changes:	51	Changes:
52		52
53	Alan Cox: Removed RGB mode for kernel merge, added THIS_MODULE	53	Alan Cox: Removed RGB mode for kernel merge, added THIS_MODULE
54	and owner support for newer module locks	54	and owner support for newer module locks
55	*/	55	*/
56		56
57	#include <linux/module.h>	57	#include <linux/module.h>
58	#include <linux/init.h>	58	#include <linux/init.h>
59	#include <linux/delay.h>	59	#include <linux/delay.h>
60	#include <linux/videodev2.h>	60	#include <linux/videodev.h>
61	#include <media/v4l2-common.h>	61	#include <media/v4l2-common.h>
62	#include <media/v4l2-ioctl.h>	62	#include <media/v4l2-ioctl.h>
63	#include <linux/parport.h>	63	#include <linux/parport.h>
64		64
65	/#define DEBUG/ /* Undef me for production */	65	/#define DEBUG/ /* Undef me for production */
66		66
67	#ifdef DEBUG	67	#ifdef DEBUG
68	#define DPRINTF(x, a...) printk(KERN_DEBUG "W9966: %s(): "x, __func__ , ##a)	68	#define DPRINTF(x, a...) printk(KERN_DEBUG "W9966: %s(): "x, __func__ , ##a)
69	#else	69	#else
70	#define DPRINTF(x...)	70	#define DPRINTF(x...)
71	#endif	71	#endif
72		72
73	/*	73	/*
74	* Defines, simple typedefs etc.	74	* Defines, simple typedefs etc.
75	*/	75	*/
76		76
77	#define W9966_DRIVERNAME "W9966CF Webcam"	77	#define W9966_DRIVERNAME "W9966CF Webcam"
78	#define W9966_MAXCAMS 4 // Maximum number of cameras	78	#define W9966_MAXCAMS 4 // Maximum number of cameras
79	#define W9966_RBUFFER 2048 // Read buffer (must be an even number)	79	#define W9966_RBUFFER 2048 // Read buffer (must be an even number)
80	#define W9966_SRAMSIZE 131072 // 128kb	80	#define W9966_SRAMSIZE 131072 // 128kb
81	#define W9966_SRAMID 0x02 // check w9966cf.pdf	81	#define W9966_SRAMID 0x02 // check w9966cf.pdf
82		82
83	// Empirically determined window limits	83	// Empirically determined window limits
84	#define W9966_WND_MIN_X 16	84	#define W9966_WND_MIN_X 16
85	#define W9966_WND_MIN_Y 14	85	#define W9966_WND_MIN_Y 14
86	#define W9966_WND_MAX_X 705	86	#define W9966_WND_MAX_X 705
87	#define W9966_WND_MAX_Y 253	87	#define W9966_WND_MAX_Y 253
88	#define W9966_WND_MAX_W (W9966_WND_MAX_X - W9966_WND_MIN_X)	88	#define W9966_WND_MAX_W (W9966_WND_MAX_X - W9966_WND_MIN_X)
89	#define W9966_WND_MAX_H (W9966_WND_MAX_Y - W9966_WND_MIN_Y)	89	#define W9966_WND_MAX_H (W9966_WND_MAX_Y - W9966_WND_MIN_Y)
90		90
91	// Keep track of our current state	91	// Keep track of our current state
92	#define W9966_STATE_PDEV 0x01	92	#define W9966_STATE_PDEV 0x01
93	#define W9966_STATE_CLAIMED 0x02	93	#define W9966_STATE_CLAIMED 0x02
94	#define W9966_STATE_VDEV 0x04	94	#define W9966_STATE_VDEV 0x04
95		95
96	#define W9966_I2C_W_ID 0x48	96	#define W9966_I2C_W_ID 0x48
97	#define W9966_I2C_R_ID 0x49	97	#define W9966_I2C_R_ID 0x49
98	#define W9966_I2C_R_DATA 0x08	98	#define W9966_I2C_R_DATA 0x08
99	#define W9966_I2C_R_CLOCK 0x04	99	#define W9966_I2C_R_CLOCK 0x04
100	#define W9966_I2C_W_DATA 0x02	100	#define W9966_I2C_W_DATA 0x02
101	#define W9966_I2C_W_CLOCK 0x01	101	#define W9966_I2C_W_CLOCK 0x01
102		102
103	struct w9966_dev {	103	struct w9966_dev {
104	unsigned char dev_state;	104	unsigned char dev_state;
105	unsigned char i2c_state;	105	unsigned char i2c_state;
106	unsigned short ppmode;	106	unsigned short ppmode;
107	struct parport* pport;	107	struct parport* pport;
108	struct pardevice* pdev;	108	struct pardevice* pdev;
109	struct video_device vdev;	109	struct video_device vdev;
110	unsigned short width;	110	unsigned short width;
111	unsigned short height;	111	unsigned short height;
112	unsigned char brightness;	112	unsigned char brightness;
113	signed char contrast;	113	signed char contrast;
114	signed char color;	114	signed char color;
115	signed char hue;	115	signed char hue;
116	unsigned long in_use;	116	unsigned long in_use;
117	};	117	};
118		118
119	/*	119	/*
120	* Module specific properties	120	* Module specific properties
121	*/	121	*/
122		122
123	MODULE_AUTHOR("Jakob Kemi <jakob.kemi@post.utfors.se>");	123	MODULE_AUTHOR("Jakob Kemi <jakob.kemi@post.utfors.se>");
124	MODULE_DESCRIPTION("Winbond w9966cf WebCam driver (0.32)");	124	MODULE_DESCRIPTION("Winbond w9966cf WebCam driver (0.32)");
125	MODULE_LICENSE("GPL");	125	MODULE_LICENSE("GPL");
126		126
127		127
128	#ifdef MODULE	128	#ifdef MODULE
129	static const char* pardev[] = {[0 ... W9966_MAXCAMS] = ""};	129	static const char* pardev[] = {[0 ... W9966_MAXCAMS] = ""};
130	#else	130	#else
131	static const char* pardev[] = {[0 ... W9966_MAXCAMS] = "aggressive"};	131	static const char* pardev[] = {[0 ... W9966_MAXCAMS] = "aggressive"};
132	#endif	132	#endif
133	module_param_array(pardev, charp, NULL, 0);	133	module_param_array(pardev, charp, NULL, 0);
134	MODULE_PARM_DESC(pardev, "pardev: where to search for\n\	134	MODULE_PARM_DESC(pardev, "pardev: where to search for\n\
135	\teach camera. 'aggressive' means brute-force search.\n\	135	\teach camera. 'aggressive' means brute-force search.\n\
136	\tEg: >pardev=parport3,aggressive,parport2,parport1< would assign\n\	136	\tEg: >pardev=parport3,aggressive,parport2,parport1< would assign\n\
137	\tcam 1 to parport3 and search every parport for cam 2 etc...");	137	\tcam 1 to parport3 and search every parport for cam 2 etc...");
138		138
139	static int parmode;	139	static int parmode;
140	module_param(parmode, int, 0);	140	module_param(parmode, int, 0);
141	MODULE_PARM_DESC(parmode, "parmode: transfer mode (0=auto, 1=ecp, 2=epp");	141	MODULE_PARM_DESC(parmode, "parmode: transfer mode (0=auto, 1=ecp, 2=epp");
142		142
143	static int video_nr = -1;	143	static int video_nr = -1;
144	module_param(video_nr, int, 0);	144	module_param(video_nr, int, 0);
145		145
146	/*	146	/*
147	* Private data	147	* Private data
148	*/	148	*/
149		149
150	static struct w9966_dev w9966_cams[W9966_MAXCAMS];	150	static struct w9966_dev w9966_cams[W9966_MAXCAMS];
151		151
152	/*	152	/*
153	* Private function declares	153	* Private function declares
154	*/	154	*/
155		155
156	static inline void w9966_setState(struct w9966_dev* cam, int mask, int val);	156	static inline void w9966_setState(struct w9966_dev* cam, int mask, int val);
157	static inline int w9966_getState(struct w9966_dev* cam, int mask, int val);	157	static inline int w9966_getState(struct w9966_dev* cam, int mask, int val);
158	static inline void w9966_pdev_claim(struct w9966_dev *vdev);	158	static inline void w9966_pdev_claim(struct w9966_dev *vdev);
159	static inline void w9966_pdev_release(struct w9966_dev *vdev);	159	static inline void w9966_pdev_release(struct w9966_dev *vdev);
160		160
161	static int w9966_rReg(struct w9966_dev* cam, int reg);	161	static int w9966_rReg(struct w9966_dev* cam, int reg);
162	static int w9966_wReg(struct w9966_dev* cam, int reg, int data);	162	static int w9966_wReg(struct w9966_dev* cam, int reg, int data);
163	#if 0	163	#if 0
164	static int w9966_rReg_i2c(struct w9966_dev* cam, int reg);	164	static int w9966_rReg_i2c(struct w9966_dev* cam, int reg);
165	#endif	165	#endif
166	static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data);	166	static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data);
167	static int w9966_findlen(int near, int size, int maxlen);	167	static int w9966_findlen(int near, int size, int maxlen);
168	static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor);	168	static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor);
169	static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h);	169	static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h);
170		170
171	static int w9966_init(struct w9966_dev* cam, struct parport* port);	171	static int w9966_init(struct w9966_dev* cam, struct parport* port);
172	static void w9966_term(struct w9966_dev* cam);	172	static void w9966_term(struct w9966_dev* cam);
173		173
174	static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state);	174	static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state);
175	static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state);	175	static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state);
176	static inline int w9966_i2c_getsda(struct w9966_dev* cam);	176	static inline int w9966_i2c_getsda(struct w9966_dev* cam);
177	static inline int w9966_i2c_getscl(struct w9966_dev* cam);	177	static inline int w9966_i2c_getscl(struct w9966_dev* cam);
178	static int w9966_i2c_wbyte(struct w9966_dev* cam, int data);	178	static int w9966_i2c_wbyte(struct w9966_dev* cam, int data);
179	#if 0	179	#if 0
180	static int w9966_i2c_rbyte(struct w9966_dev* cam);	180	static int w9966_i2c_rbyte(struct w9966_dev* cam);
181	#endif	181	#endif
182		182
183	static long w9966_v4l_ioctl(struct file *file,	183	static long w9966_v4l_ioctl(struct file *file,
184	unsigned int cmd, unsigned long arg);	184	unsigned int cmd, unsigned long arg);
185	static ssize_t w9966_v4l_read(struct file file, char __user buf,	185	static ssize_t w9966_v4l_read(struct file file, char __user buf,
186	size_t count, loff_t *ppos);	186	size_t count, loff_t *ppos);
187		187
188	static int w9966_exclusive_open(struct file *file)	188	static int w9966_exclusive_open(struct file *file)
189	{	189	{
190	struct w9966_dev *cam = video_drvdata(file);	190	struct w9966_dev *cam = video_drvdata(file);
191		191
192	return test_and_set_bit(0, &cam->in_use) ? -EBUSY : 0;	192	return test_and_set_bit(0, &cam->in_use) ? -EBUSY : 0;
193	}	193	}
194		194
195	static int w9966_exclusive_release(struct file *file)	195	static int w9966_exclusive_release(struct file *file)
196	{	196	{
197	struct w9966_dev *cam = video_drvdata(file);	197	struct w9966_dev *cam = video_drvdata(file);
198		198
199	clear_bit(0, &cam->in_use);	199	clear_bit(0, &cam->in_use);
200	return 0;	200	return 0;
201	}	201	}
202		202
203	static const struct v4l2_file_operations w9966_fops = {	203	static const struct v4l2_file_operations w9966_fops = {
204	.owner = THIS_MODULE,	204	.owner = THIS_MODULE,
205	.open = w9966_exclusive_open,	205	.open = w9966_exclusive_open,
206	.release = w9966_exclusive_release,	206	.release = w9966_exclusive_release,
207	.ioctl = w9966_v4l_ioctl,	207	.ioctl = w9966_v4l_ioctl,
208	.read = w9966_v4l_read,	208	.read = w9966_v4l_read,
209	};	209	};
210	static struct video_device w9966_template = {	210	static struct video_device w9966_template = {
211	.name = W9966_DRIVERNAME,	211	.name = W9966_DRIVERNAME,
212	.fops = &w9966_fops,	212	.fops = &w9966_fops,
213	.release = video_device_release_empty,	213	.release = video_device_release_empty,
214	};	214	};
215		215
216	/*	216	/*
217	* Private function defines	217	* Private function defines
218	*/	218	*/
219		219
220		220
221	// Set camera phase flags, so we know what to uninit when terminating	221	// Set camera phase flags, so we know what to uninit when terminating
222	static inline void w9966_setState(struct w9966_dev* cam, int mask, int val)	222	static inline void w9966_setState(struct w9966_dev* cam, int mask, int val)
223	{	223	{
224	cam->dev_state = (cam->dev_state & ~mask) ^ val;	224	cam->dev_state = (cam->dev_state & ~mask) ^ val;
225	}	225	}
226		226
227	// Get camera phase flags	227	// Get camera phase flags
228	static inline int w9966_getState(struct w9966_dev* cam, int mask, int val)	228	static inline int w9966_getState(struct w9966_dev* cam, int mask, int val)
229	{	229	{
230	return ((cam->dev_state & mask) == val);	230	return ((cam->dev_state & mask) == val);
231	}	231	}
232		232
233	// Claim parport for ourself	233	// Claim parport for ourself
234	static inline void w9966_pdev_claim(struct w9966_dev* cam)	234	static inline void w9966_pdev_claim(struct w9966_dev* cam)
235	{	235	{
236	if (w9966_getState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED))	236	if (w9966_getState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED))
237	return;	237	return;
238	parport_claim_or_block(cam->pdev);	238	parport_claim_or_block(cam->pdev);
239	w9966_setState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED);	239	w9966_setState(cam, W9966_STATE_CLAIMED, W9966_STATE_CLAIMED);
240	}	240	}
241		241
242	// Release parport for others to use	242	// Release parport for others to use
243	static inline void w9966_pdev_release(struct w9966_dev* cam)	243	static inline void w9966_pdev_release(struct w9966_dev* cam)
244	{	244	{
245	if (w9966_getState(cam, W9966_STATE_CLAIMED, 0))	245	if (w9966_getState(cam, W9966_STATE_CLAIMED, 0))
246	return;	246	return;
247	parport_release(cam->pdev);	247	parport_release(cam->pdev);
248	w9966_setState(cam, W9966_STATE_CLAIMED, 0);	248	w9966_setState(cam, W9966_STATE_CLAIMED, 0);
249	}	249	}
250		250
251	// Read register from W9966 interface-chip	251	// Read register from W9966 interface-chip
252	// Expects a claimed pdev	252	// Expects a claimed pdev
253	// -1 on error, else register data (byte)	253	// -1 on error, else register data (byte)
254	static int w9966_rReg(struct w9966_dev* cam, int reg)	254	static int w9966_rReg(struct w9966_dev* cam, int reg)
255	{	255	{
256	// ECP, read, regtransfer, REG, REG, REG, REG, REG	256	// ECP, read, regtransfer, REG, REG, REG, REG, REG
257	const unsigned char addr = 0x80 \| (reg & 0x1f);	257	const unsigned char addr = 0x80 \| (reg & 0x1f);
258	unsigned char val;	258	unsigned char val;
259		259
260	if (parport_negotiate(cam->pport, cam->ppmode \| IEEE1284_ADDR) != 0)	260	if (parport_negotiate(cam->pport, cam->ppmode \| IEEE1284_ADDR) != 0)
261	return -1;	261	return -1;
262	if (parport_write(cam->pport, &addr, 1) != 1)	262	if (parport_write(cam->pport, &addr, 1) != 1)
263	return -1;	263	return -1;
264	if (parport_negotiate(cam->pport, cam->ppmode \| IEEE1284_DATA) != 0)	264	if (parport_negotiate(cam->pport, cam->ppmode \| IEEE1284_DATA) != 0)
265	return -1;	265	return -1;
266	if (parport_read(cam->pport, &val, 1) != 1)	266	if (parport_read(cam->pport, &val, 1) != 1)
267	return -1;	267	return -1;
268		268
269	return val;	269	return val;
270	}	270	}
271		271
272	// Write register to W9966 interface-chip	272	// Write register to W9966 interface-chip
273	// Expects a claimed pdev	273	// Expects a claimed pdev
274	// -1 on error	274	// -1 on error
275	static int w9966_wReg(struct w9966_dev* cam, int reg, int data)	275	static int w9966_wReg(struct w9966_dev* cam, int reg, int data)
276	{	276	{
277	// ECP, write, regtransfer, REG, REG, REG, REG, REG	277	// ECP, write, regtransfer, REG, REG, REG, REG, REG
278	const unsigned char addr = 0xc0 \| (reg & 0x1f);	278	const unsigned char addr = 0xc0 \| (reg & 0x1f);
279	const unsigned char val = data;	279	const unsigned char val = data;
280		280
281	if (parport_negotiate(cam->pport, cam->ppmode \| IEEE1284_ADDR) != 0)	281	if (parport_negotiate(cam->pport, cam->ppmode \| IEEE1284_ADDR) != 0)
282	return -1;	282	return -1;
283	if (parport_write(cam->pport, &addr, 1) != 1)	283	if (parport_write(cam->pport, &addr, 1) != 1)
284	return -1;	284	return -1;
285	if (parport_negotiate(cam->pport, cam->ppmode \| IEEE1284_DATA) != 0)	285	if (parport_negotiate(cam->pport, cam->ppmode \| IEEE1284_DATA) != 0)
286	return -1;	286	return -1;
287	if (parport_write(cam->pport, &val, 1) != 1)	287	if (parport_write(cam->pport, &val, 1) != 1)
288	return -1;	288	return -1;
289		289
290	return 0;	290	return 0;
291	}	291	}
292		292
293	// Initialize camera device. Setup all internal flags, set a	293	// Initialize camera device. Setup all internal flags, set a
294	// default video mode, setup ccd-chip, register v4l device etc..	294	// default video mode, setup ccd-chip, register v4l device etc..
295	// Also used for 'probing' of hardware.	295	// Also used for 'probing' of hardware.
296	// -1 on error	296	// -1 on error
297	static int w9966_init(struct w9966_dev* cam, struct parport* port)	297	static int w9966_init(struct w9966_dev* cam, struct parport* port)
298	{	298	{
299	if (cam->dev_state != 0)	299	if (cam->dev_state != 0)
300	return -1;	300	return -1;
301		301
302	cam->pport = port;	302	cam->pport = port;
303	cam->brightness = 128;	303	cam->brightness = 128;
304	cam->contrast = 64;	304	cam->contrast = 64;
305	cam->color = 64;	305	cam->color = 64;
306	cam->hue = 0;	306	cam->hue = 0;
307		307
308	// Select requested transfer mode	308	// Select requested transfer mode
309	switch(parmode)	309	switch(parmode)
310	{	310	{
311	default: // Auto-detect (priority: hw-ecp, hw-epp, sw-ecp)	311	default: // Auto-detect (priority: hw-ecp, hw-epp, sw-ecp)
312	case 0:	312	case 0:
313	if (port->modes & PARPORT_MODE_ECP)	313	if (port->modes & PARPORT_MODE_ECP)
314	cam->ppmode = IEEE1284_MODE_ECP;	314	cam->ppmode = IEEE1284_MODE_ECP;
315	else if (port->modes & PARPORT_MODE_EPP)	315	else if (port->modes & PARPORT_MODE_EPP)
316	cam->ppmode = IEEE1284_MODE_EPP;	316	cam->ppmode = IEEE1284_MODE_EPP;
317	else	317	else
318	cam->ppmode = IEEE1284_MODE_ECP;	318	cam->ppmode = IEEE1284_MODE_ECP;
319	break;	319	break;
320	case 1: // hw- or sw-ecp	320	case 1: // hw- or sw-ecp
321	cam->ppmode = IEEE1284_MODE_ECP;	321	cam->ppmode = IEEE1284_MODE_ECP;
322	break;	322	break;
323	case 2: // hw- or sw-epp	323	case 2: // hw- or sw-epp
324	cam->ppmode = IEEE1284_MODE_EPP;	324	cam->ppmode = IEEE1284_MODE_EPP;
325	break;	325	break;
326	}	326	}
327		327
328	// Tell the parport driver that we exists	328	// Tell the parport driver that we exists
329	cam->pdev = parport_register_device(port, "w9966", NULL, NULL, NULL, 0, NULL);	329	cam->pdev = parport_register_device(port, "w9966", NULL, NULL, NULL, 0, NULL);
330	if (cam->pdev == NULL) {	330	if (cam->pdev == NULL) {
331	DPRINTF("parport_register_device() failed\n");	331	DPRINTF("parport_register_device() failed\n");
332	return -1;	332	return -1;
333	}	333	}
334	w9966_setState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV);	334	w9966_setState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV);
335		335
336	w9966_pdev_claim(cam);	336	w9966_pdev_claim(cam);
337		337
338	// Setup a default capture mode	338	// Setup a default capture mode
339	if (w9966_setup(cam, 0, 0, 1023, 1023, 200, 160) != 0) {	339	if (w9966_setup(cam, 0, 0, 1023, 1023, 200, 160) != 0) {
340	DPRINTF("w9966_setup() failed.\n");	340	DPRINTF("w9966_setup() failed.\n");
341	return -1;	341	return -1;
342	}	342	}
343		343
344	w9966_pdev_release(cam);	344	w9966_pdev_release(cam);
345		345
346	// Fill in the video_device struct and register us to v4l	346	// Fill in the video_device struct and register us to v4l
347	memcpy(&cam->vdev, &w9966_template, sizeof(struct video_device));	347	memcpy(&cam->vdev, &w9966_template, sizeof(struct video_device));
348	video_set_drvdata(&cam->vdev, cam);	348	video_set_drvdata(&cam->vdev, cam);
349		349
350	if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) < 0)	350	if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) < 0)
351	return -1;	351	return -1;
352		352
353	w9966_setState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV);	353	w9966_setState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV);
354		354
355	// All ok	355	// All ok
356	printk(	356	printk(
357	"w9966cf: Found and initialized a webcam on %s.\n",	357	"w9966cf: Found and initialized a webcam on %s.\n",
358	cam->pport->name	358	cam->pport->name
359	);	359	);
360	return 0;	360	return 0;
361	}	361	}
362		362
363		363
364	// Terminate everything gracefully	364	// Terminate everything gracefully
365	static void w9966_term(struct w9966_dev* cam)	365	static void w9966_term(struct w9966_dev* cam)
366	{	366	{
367	// Unregister from v4l	367	// Unregister from v4l
368	if (w9966_getState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV)) {	368	if (w9966_getState(cam, W9966_STATE_VDEV, W9966_STATE_VDEV)) {
369	video_unregister_device(&cam->vdev);	369	video_unregister_device(&cam->vdev);
370	w9966_setState(cam, W9966_STATE_VDEV, 0);	370	w9966_setState(cam, W9966_STATE_VDEV, 0);
371	}	371	}
372		372
373	// Terminate from IEEE1284 mode and release pdev block	373	// Terminate from IEEE1284 mode and release pdev block
374	if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {	374	if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {
375	w9966_pdev_claim(cam);	375	w9966_pdev_claim(cam);
376	parport_negotiate(cam->pport, IEEE1284_MODE_COMPAT);	376	parport_negotiate(cam->pport, IEEE1284_MODE_COMPAT);
377	w9966_pdev_release(cam);	377	w9966_pdev_release(cam);
378	}	378	}
379		379
380	// Unregister from parport	380	// Unregister from parport
381	if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {	381	if (w9966_getState(cam, W9966_STATE_PDEV, W9966_STATE_PDEV)) {
382	parport_unregister_device(cam->pdev);	382	parport_unregister_device(cam->pdev);
383	w9966_setState(cam, W9966_STATE_PDEV, 0);	383	w9966_setState(cam, W9966_STATE_PDEV, 0);
384	}	384	}
385	}	385	}
386		386
387		387
388	// Find a good length for capture window (used both for W and H)	388	// Find a good length for capture window (used both for W and H)
389	// A bit ugly but pretty functional. The capture length	389	// A bit ugly but pretty functional. The capture length
390	// have to match the downscale	390	// have to match the downscale
391	static int w9966_findlen(int near, int size, int maxlen)	391	static int w9966_findlen(int near, int size, int maxlen)
392	{	392	{
393	int bestlen = size;	393	int bestlen = size;
394	int besterr = abs(near - bestlen);	394	int besterr = abs(near - bestlen);
395	int len;	395	int len;
396		396
397	for(len = size+1;len < maxlen;len++)	397	for(len = size+1;len < maxlen;len++)
398	{	398	{
399	int err;	399	int err;
400	if ( ((64*size) %len) != 0)	400	if ( ((64*size) %len) != 0)
401	continue;	401	continue;
402		402
403	err = abs(near - len);	403	err = abs(near - len);
404		404
405	// Only continue as long as we keep getting better values	405	// Only continue as long as we keep getting better values
406	if (err > besterr)	406	if (err > besterr)
407	break;	407	break;
408		408
409	besterr = err;	409	besterr = err;
410	bestlen = len;	410	bestlen = len;
411	}	411	}
412		412
413	return bestlen;	413	return bestlen;
414	}	414	}
415		415
416	// Modify capture window (if necessary)	416	// Modify capture window (if necessary)
417	// and calculate downscaling	417	// and calculate downscaling
418	// Return -1 on error	418	// Return -1 on error
419	static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor)	419	static int w9966_calcscale(int size, int min, int max, int* beg, int* end, unsigned char* factor)
420	{	420	{
421	int maxlen = max - min;	421	int maxlen = max - min;
422	int len = end - beg + 1;	422	int len = end - beg + 1;
423	int newlen = w9966_findlen(len, size, maxlen);	423	int newlen = w9966_findlen(len, size, maxlen);
424	int err = newlen - len;	424	int err = newlen - len;
425		425
426	// Check for bad format	426	// Check for bad format
427	if (newlen > maxlen \|\| newlen < size)	427	if (newlen > maxlen \|\| newlen < size)
428	return -1;	428	return -1;
429		429
430	// Set factor (6 bit fixed)	430	// Set factor (6 bit fixed)
431	factor = (64size) / newlen;	431	factor = (64size) / newlen;
432	if (*factor == 64)	432	if (*factor == 64)
433	*factor = 0x00; // downscale is disabled	433	*factor = 0x00; // downscale is disabled
434	else	434	else
435	*factor \|= 0x80; // set downscale-enable bit	435	*factor \|= 0x80; // set downscale-enable bit
436		436
437	// Modify old beginning and end	437	// Modify old beginning and end
438	*beg -= err / 2;	438	*beg -= err / 2;
439	*end += err - (err / 2);	439	*end += err - (err / 2);
440		440
441	// Move window if outside borders	441	// Move window if outside borders
442	if (*beg < min) {	442	if (*beg < min) {
443	end += min - beg;	443	end += min - beg;
444	beg += min - beg;	444	beg += min - beg;
445	}	445	}
446	if (*end > max) {	446	if (*end > max) {
447	beg -= end - max;	447	beg -= end - max;
448	end -= end - max;	448	end -= end - max;
449	}	449	}
450		450
451	return 0;	451	return 0;
452	}	452	}
453		453
454	// Setup the cameras capture window etc.	454	// Setup the cameras capture window etc.
455	// Expects a claimed pdev	455	// Expects a claimed pdev
456	// return -1 on error	456	// return -1 on error
457	static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h)	457	static int w9966_setup(struct w9966_dev* cam, int x1, int y1, int x2, int y2, int w, int h)
458	{	458	{
459	unsigned int i;	459	unsigned int i;
460	unsigned int enh_s, enh_e;	460	unsigned int enh_s, enh_e;
461	unsigned char scale_x, scale_y;	461	unsigned char scale_x, scale_y;
462	unsigned char regs[0x1c];	462	unsigned char regs[0x1c];
463	unsigned char saa7111_regs[] = {	463	unsigned char saa7111_regs[] = {
464	0x21, 0x00, 0xd8, 0x23, 0x00, 0x80, 0x80, 0x00,	464	0x21, 0x00, 0xd8, 0x23, 0x00, 0x80, 0x80, 0x00,
465	0x88, 0x10, 0x80, 0x40, 0x40, 0x00, 0x01, 0x00,	465	0x88, 0x10, 0x80, 0x40, 0x40, 0x00, 0x01, 0x00,
466	0x48, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	466	0x48, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
467	0x00, 0x00, 0x00, 0x71, 0xe7, 0x00, 0x00, 0xc0	467	0x00, 0x00, 0x00, 0x71, 0xe7, 0x00, 0x00, 0xc0
468	};	468	};
469		469
470		470
471	if (wh2 > W9966_SRAMSIZE)	471	if (wh2 > W9966_SRAMSIZE)
472	{	472	{
473	DPRINTF("capture window exceeds SRAM size!.\n");	473	DPRINTF("capture window exceeds SRAM size!.\n");
474	w = 200; h = 160; // Pick default values	474	w = 200; h = 160; // Pick default values
475	}	475	}
476		476
477	w &= ~0x1;	477	w &= ~0x1;
478	if (w < 2) w = 2;	478	if (w < 2) w = 2;
479	if (h < 1) h = 1;	479	if (h < 1) h = 1;
480	if (w > W9966_WND_MAX_W) w = W9966_WND_MAX_W;	480	if (w > W9966_WND_MAX_W) w = W9966_WND_MAX_W;
481	if (h > W9966_WND_MAX_H) h = W9966_WND_MAX_H;	481	if (h > W9966_WND_MAX_H) h = W9966_WND_MAX_H;
482		482
483	cam->width = w;	483	cam->width = w;
484	cam->height = h;	484	cam->height = h;
485		485
486	enh_s = 0;	486	enh_s = 0;
487	enh_e = wh2;	487	enh_e = wh2;
488		488
489	// Modify capture window if necessary and calculate downscaling	489	// Modify capture window if necessary and calculate downscaling
490	if (	490	if (
491	w9966_calcscale(w, W9966_WND_MIN_X, W9966_WND_MAX_X, &x1, &x2, &scale_x) != 0 \|\|	491	w9966_calcscale(w, W9966_WND_MIN_X, W9966_WND_MAX_X, &x1, &x2, &scale_x) != 0 \|\|
492	w9966_calcscale(h, W9966_WND_MIN_Y, W9966_WND_MAX_Y, &y1, &y2, &scale_y) != 0	492	w9966_calcscale(h, W9966_WND_MIN_Y, W9966_WND_MAX_Y, &y1, &y2, &scale_y) != 0
493	) return -1;	493	) return -1;
494		494
495	DPRINTF(	495	DPRINTF(
496	"%dx%d, x: %d<->%d, y: %d<->%d, sx: %d/64, sy: %d/64.\n",	496	"%dx%d, x: %d<->%d, y: %d<->%d, sx: %d/64, sy: %d/64.\n",
497	w, h, x1, x2, y1, y2, scale_x&~0x80, scale_y&~0x80	497	w, h, x1, x2, y1, y2, scale_x&~0x80, scale_y&~0x80
498	);	498	);
499		499
500	// Setup registers	500	// Setup registers
501	regs[0x00] = 0x00; // Set normal operation	501	regs[0x00] = 0x00; // Set normal operation
502	regs[0x01] = 0x18; // Capture mode	502	regs[0x01] = 0x18; // Capture mode
503	regs[0x02] = scale_y; // V-scaling	503	regs[0x02] = scale_y; // V-scaling
504	regs[0x03] = scale_x; // H-scaling	504	regs[0x03] = scale_x; // H-scaling
505		505
506	// Capture window	506	// Capture window
507	regs[0x04] = (x1 & 0x0ff); // X-start (8 low bits)	507	regs[0x04] = (x1 & 0x0ff); // X-start (8 low bits)
508	regs[0x05] = (x1 & 0x300)>>8; // X-start (2 high bits)	508	regs[0x05] = (x1 & 0x300)>>8; // X-start (2 high bits)
509	regs[0x06] = (y1 & 0x0ff); // Y-start (8 low bits)	509	regs[0x06] = (y1 & 0x0ff); // Y-start (8 low bits)
510	regs[0x07] = (y1 & 0x300)>>8; // Y-start (2 high bits)	510	regs[0x07] = (y1 & 0x300)>>8; // Y-start (2 high bits)
511	regs[0x08] = (x2 & 0x0ff); // X-end (8 low bits)	511	regs[0x08] = (x2 & 0x0ff); // X-end (8 low bits)
512	regs[0x09] = (x2 & 0x300)>>8; // X-end (2 high bits)	512	regs[0x09] = (x2 & 0x300)>>8; // X-end (2 high bits)
513	regs[0x0a] = (y2 & 0x0ff); // Y-end (8 low bits)	513	regs[0x0a] = (y2 & 0x0ff); // Y-end (8 low bits)
514		514
515	regs[0x0c] = W9966_SRAMID; // SRAM-banks (1x 128kb)	515	regs[0x0c] = W9966_SRAMID; // SRAM-banks (1x 128kb)
516		516
517	// Enhancement layer	517	// Enhancement layer
518	regs[0x0d] = (enh_s& 0x000ff); // Enh. start (0-7)	518	regs[0x0d] = (enh_s& 0x000ff); // Enh. start (0-7)
519	regs[0x0e] = (enh_s& 0x0ff00)>>8; // Enh. start (8-15)	519	regs[0x0e] = (enh_s& 0x0ff00)>>8; // Enh. start (8-15)
520	regs[0x0f] = (enh_s& 0x70000)>>16; // Enh. start (16-17/18??)	520	regs[0x0f] = (enh_s& 0x70000)>>16; // Enh. start (16-17/18??)
521	regs[0x10] = (enh_e& 0x000ff); // Enh. end (0-7)	521	regs[0x10] = (enh_e& 0x000ff); // Enh. end (0-7)
522	regs[0x11] = (enh_e& 0x0ff00)>>8; // Enh. end (8-15)	522	regs[0x11] = (enh_e& 0x0ff00)>>8; // Enh. end (8-15)
523	regs[0x12] = (enh_e& 0x70000)>>16; // Enh. end (16-17/18??)	523	regs[0x12] = (enh_e& 0x70000)>>16; // Enh. end (16-17/18??)
524		524
525	// Misc	525	// Misc
526	regs[0x13] = 0x40; // VEE control (raw 4:2:2)	526	regs[0x13] = 0x40; // VEE control (raw 4:2:2)
527	regs[0x17] = 0x00; // ???	527	regs[0x17] = 0x00; // ???
528	regs[0x18] = cam->i2c_state = 0x00; // Serial bus	528	regs[0x18] = cam->i2c_state = 0x00; // Serial bus
529	regs[0x19] = 0xff; // I/O port direction control	529	regs[0x19] = 0xff; // I/O port direction control
530	regs[0x1a] = 0xff; // I/O port data register	530	regs[0x1a] = 0xff; // I/O port data register
531	regs[0x1b] = 0x10; // ???	531	regs[0x1b] = 0x10; // ???
532		532
533	// SAA7111 chip settings	533	// SAA7111 chip settings
534	saa7111_regs[0x0a] = cam->brightness;	534	saa7111_regs[0x0a] = cam->brightness;
535	saa7111_regs[0x0b] = cam->contrast;	535	saa7111_regs[0x0b] = cam->contrast;
536	saa7111_regs[0x0c] = cam->color;	536	saa7111_regs[0x0c] = cam->color;
537	saa7111_regs[0x0d] = cam->hue;	537	saa7111_regs[0x0d] = cam->hue;
538		538
539	// Reset (ECP-fifo & serial-bus)	539	// Reset (ECP-fifo & serial-bus)
540	if (w9966_wReg(cam, 0x00, 0x03) == -1)	540	if (w9966_wReg(cam, 0x00, 0x03) == -1)
541	return -1;	541	return -1;
542		542
543	// Write regs to w9966cf chip	543	// Write regs to w9966cf chip
544	for (i = 0; i < 0x1c; i++)	544	for (i = 0; i < 0x1c; i++)
545	if (w9966_wReg(cam, i, regs[i]) == -1)	545	if (w9966_wReg(cam, i, regs[i]) == -1)
546	return -1;	546	return -1;
547		547
548	// Write regs to saa7111 chip	548	// Write regs to saa7111 chip
549	for (i = 0; i < 0x20; i++)	549	for (i = 0; i < 0x20; i++)
550	if (w9966_wReg_i2c(cam, i, saa7111_regs[i]) == -1)	550	if (w9966_wReg_i2c(cam, i, saa7111_regs[i]) == -1)
551	return -1;	551	return -1;
552		552
553	return 0;	553	return 0;
554	}	554	}
555		555
556	/*	556	/*
557	* Ugly and primitive i2c protocol functions	557	* Ugly and primitive i2c protocol functions
558	*/	558	*/
559		559
560	// Sets the data line on the i2c bus.	560	// Sets the data line on the i2c bus.
561	// Expects a claimed pdev.	561	// Expects a claimed pdev.
562	static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state)	562	static inline void w9966_i2c_setsda(struct w9966_dev* cam, int state)
563	{	563	{
564	if (state)	564	if (state)
565	cam->i2c_state \|= W9966_I2C_W_DATA;	565	cam->i2c_state \|= W9966_I2C_W_DATA;
566	else	566	else
567	cam->i2c_state &= ~W9966_I2C_W_DATA;	567	cam->i2c_state &= ~W9966_I2C_W_DATA;
568		568
569	w9966_wReg(cam, 0x18, cam->i2c_state);	569	w9966_wReg(cam, 0x18, cam->i2c_state);
570	udelay(5);	570	udelay(5);
571	}	571	}
572		572
573	// Get peripheral clock line	573	// Get peripheral clock line
574	// Expects a claimed pdev.	574	// Expects a claimed pdev.
575	static inline int w9966_i2c_getscl(struct w9966_dev* cam)	575	static inline int w9966_i2c_getscl(struct w9966_dev* cam)
576	{	576	{
577	const unsigned char state = w9966_rReg(cam, 0x18);	577	const unsigned char state = w9966_rReg(cam, 0x18);
578	return ((state & W9966_I2C_R_CLOCK) > 0);	578	return ((state & W9966_I2C_R_CLOCK) > 0);
579	}	579	}
580		580
581	// Sets the clock line on the i2c bus.	581	// Sets the clock line on the i2c bus.
582	// Expects a claimed pdev. -1 on error	582	// Expects a claimed pdev. -1 on error
583	static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state)	583	static inline int w9966_i2c_setscl(struct w9966_dev* cam, int state)
584	{	584	{
585	unsigned long timeout;	585	unsigned long timeout;
586		586
587	if (state)	587	if (state)
588	cam->i2c_state \|= W9966_I2C_W_CLOCK;	588	cam->i2c_state \|= W9966_I2C_W_CLOCK;
589	else	589	else
590	cam->i2c_state &= ~W9966_I2C_W_CLOCK;	590	cam->i2c_state &= ~W9966_I2C_W_CLOCK;
591		591
592	w9966_wReg(cam, 0x18, cam->i2c_state);	592	w9966_wReg(cam, 0x18, cam->i2c_state);
593	udelay(5);	593	udelay(5);
594		594
595	// we go to high, we also expect the peripheral to ack.	595	// we go to high, we also expect the peripheral to ack.
596	if (state) {	596	if (state) {
597	timeout = jiffies + 100;	597	timeout = jiffies + 100;
598	while (!w9966_i2c_getscl(cam)) {	598	while (!w9966_i2c_getscl(cam)) {
599	if (time_after(jiffies, timeout))	599	if (time_after(jiffies, timeout))
600	return -1;	600	return -1;
601	}	601	}
602	}	602	}
603	return 0;	603	return 0;
604	}	604	}
605		605
606	// Get peripheral data line	606	// Get peripheral data line
607	// Expects a claimed pdev.	607	// Expects a claimed pdev.
608	static inline int w9966_i2c_getsda(struct w9966_dev* cam)	608	static inline int w9966_i2c_getsda(struct w9966_dev* cam)
609	{	609	{
610	const unsigned char state = w9966_rReg(cam, 0x18);	610	const unsigned char state = w9966_rReg(cam, 0x18);
611	return ((state & W9966_I2C_R_DATA) > 0);	611	return ((state & W9966_I2C_R_DATA) > 0);
612	}	612	}
613		613
614	// Write a byte with ack to the i2c bus.	614	// Write a byte with ack to the i2c bus.
615	// Expects a claimed pdev. -1 on error	615	// Expects a claimed pdev. -1 on error
616	static int w9966_i2c_wbyte(struct w9966_dev* cam, int data)	616	static int w9966_i2c_wbyte(struct w9966_dev* cam, int data)
617	{	617	{
618	int i;	618	int i;
619	for (i = 7; i >= 0; i--)	619	for (i = 7; i >= 0; i--)
620	{	620	{
621	w9966_i2c_setsda(cam, (data >> i) & 0x01);	621	w9966_i2c_setsda(cam, (data >> i) & 0x01);
622		622
623	if (w9966_i2c_setscl(cam, 1) == -1)	623	if (w9966_i2c_setscl(cam, 1) == -1)
624	return -1;	624	return -1;
625	w9966_i2c_setscl(cam, 0);	625	w9966_i2c_setscl(cam, 0);
626	}	626	}
627		627
628	w9966_i2c_setsda(cam, 1);	628	w9966_i2c_setsda(cam, 1);
629		629
630	if (w9966_i2c_setscl(cam, 1) == -1)	630	if (w9966_i2c_setscl(cam, 1) == -1)
631	return -1;	631	return -1;
632	w9966_i2c_setscl(cam, 0);	632	w9966_i2c_setscl(cam, 0);
633		633
634	return 0;	634	return 0;
635	}	635	}
636		636
637	// Read a data byte with ack from the i2c-bus	637	// Read a data byte with ack from the i2c-bus
638	// Expects a claimed pdev. -1 on error	638	// Expects a claimed pdev. -1 on error
639	#if 0	639	#if 0
640	static int w9966_i2c_rbyte(struct w9966_dev* cam)	640	static int w9966_i2c_rbyte(struct w9966_dev* cam)
641	{	641	{
642	unsigned char data = 0x00;	642	unsigned char data = 0x00;
643	int i;	643	int i;
644		644
645	w9966_i2c_setsda(cam, 1);	645	w9966_i2c_setsda(cam, 1);
646		646
647	for (i = 0; i < 8; i++)	647	for (i = 0; i < 8; i++)
648	{	648	{
649	if (w9966_i2c_setscl(cam, 1) == -1)	649	if (w9966_i2c_setscl(cam, 1) == -1)
650	return -1;	650	return -1;
651	data = data << 1;	651	data = data << 1;
652	if (w9966_i2c_getsda(cam))	652	if (w9966_i2c_getsda(cam))
653	data \|= 0x01;	653	data \|= 0x01;
654		654
655	w9966_i2c_setscl(cam, 0);	655	w9966_i2c_setscl(cam, 0);
656	}	656	}
657	return data;	657	return data;
658	}	658	}
659	#endif	659	#endif
660		660
661	// Read a register from the i2c device.	661	// Read a register from the i2c device.
662	// Expects claimed pdev. -1 on error	662	// Expects claimed pdev. -1 on error
663	#if 0	663	#if 0
664	static int w9966_rReg_i2c(struct w9966_dev* cam, int reg)	664	static int w9966_rReg_i2c(struct w9966_dev* cam, int reg)
665	{	665	{
666	int data;	666	int data;
667		667
668	w9966_i2c_setsda(cam, 0);	668	w9966_i2c_setsda(cam, 0);
669	w9966_i2c_setscl(cam, 0);	669	w9966_i2c_setscl(cam, 0);
670		670
671	if (	671	if (
672	w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 \|\|	672	w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 \|\|
673	w9966_i2c_wbyte(cam, reg) == -1	673	w9966_i2c_wbyte(cam, reg) == -1
674	)	674	)
675	return -1;	675	return -1;
676		676
677	w9966_i2c_setsda(cam, 1);	677	w9966_i2c_setsda(cam, 1);
678	if (w9966_i2c_setscl(cam, 1) == -1)	678	if (w9966_i2c_setscl(cam, 1) == -1)
679	return -1;	679	return -1;
680	w9966_i2c_setsda(cam, 0);	680	w9966_i2c_setsda(cam, 0);
681	w9966_i2c_setscl(cam, 0);	681	w9966_i2c_setscl(cam, 0);
682		682
683	if (	683	if (
684	w9966_i2c_wbyte(cam, W9966_I2C_R_ID) == -1 \|\|	684	w9966_i2c_wbyte(cam, W9966_I2C_R_ID) == -1 \|\|
685	(data = w9966_i2c_rbyte(cam)) == -1	685	(data = w9966_i2c_rbyte(cam)) == -1
686	)	686	)
687	return -1;	687	return -1;
688		688
689	w9966_i2c_setsda(cam, 0);	689	w9966_i2c_setsda(cam, 0);
690		690
691	if (w9966_i2c_setscl(cam, 1) == -1)	691	if (w9966_i2c_setscl(cam, 1) == -1)
692	return -1;	692	return -1;
693	w9966_i2c_setsda(cam, 1);	693	w9966_i2c_setsda(cam, 1);
694		694
695	return data;	695	return data;
696	}	696	}
697	#endif	697	#endif
698		698
699	// Write a register to the i2c device.	699	// Write a register to the i2c device.
700	// Expects claimed pdev. -1 on error	700	// Expects claimed pdev. -1 on error
701	static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data)	701	static int w9966_wReg_i2c(struct w9966_dev* cam, int reg, int data)
702	{	702	{
703	w9966_i2c_setsda(cam, 0);	703	w9966_i2c_setsda(cam, 0);
704	w9966_i2c_setscl(cam, 0);	704	w9966_i2c_setscl(cam, 0);
705		705
706	if (	706	if (
707	w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 \|\|	707	w9966_i2c_wbyte(cam, W9966_I2C_W_ID) == -1 \|\|
708	w9966_i2c_wbyte(cam, reg) == -1 \|\|	708	w9966_i2c_wbyte(cam, reg) == -1 \|\|
709	w9966_i2c_wbyte(cam, data) == -1	709	w9966_i2c_wbyte(cam, data) == -1
710	)	710	)
711	return -1;	711	return -1;
712		712
713	w9966_i2c_setsda(cam, 0);	713	w9966_i2c_setsda(cam, 0);
714	if (w9966_i2c_setscl(cam, 1) == -1)	714	if (w9966_i2c_setscl(cam, 1) == -1)
715	return -1;	715	return -1;
716		716
717	w9966_i2c_setsda(cam, 1);	717	w9966_i2c_setsda(cam, 1);
718		718
719	return 0;	719	return 0;
720	}	720	}
721		721
722	/*	722	/*
723	* Video4linux interfacing	723	* Video4linux interfacing
724	*/	724	*/
725		725
726	static long w9966_v4l_do_ioctl(struct file file, unsigned int cmd, void arg)	726	static long w9966_v4l_do_ioctl(struct file file, unsigned int cmd, void arg)
727	{	727	{
728	struct w9966_dev *cam = video_drvdata(file);	728	struct w9966_dev *cam = video_drvdata(file);
729		729
730	switch(cmd)	730	switch(cmd)
731	{	731	{
732	case VIDIOCGCAP:	732	case VIDIOCGCAP:
733	{	733	{
734	static struct video_capability vcap = {	734	static struct video_capability vcap = {
735	.name = W9966_DRIVERNAME,	735	.name = W9966_DRIVERNAME,
736	.type = VID_TYPE_CAPTURE \| VID_TYPE_SCALES,	736	.type = VID_TYPE_CAPTURE \| VID_TYPE_SCALES,
737	.channels = 1,	737	.channels = 1,
738	.maxwidth = W9966_WND_MAX_W,	738	.maxwidth = W9966_WND_MAX_W,
739	.maxheight = W9966_WND_MAX_H,	739	.maxheight = W9966_WND_MAX_H,
740	.minwidth = 2,	740	.minwidth = 2,
741	.minheight = 1,	741	.minheight = 1,
742	};	742	};
743	struct video_capability *cap = arg;	743	struct video_capability *cap = arg;
744	*cap = vcap;	744	*cap = vcap;
745	return 0;	745	return 0;
746	}	746	}
747	case VIDIOCGCHAN:	747	case VIDIOCGCHAN:
748	{	748	{
749	struct video_channel *vch = arg;	749	struct video_channel *vch = arg;
750	if(vch->channel != 0) // We only support one channel (#0)	750	if(vch->channel != 0) // We only support one channel (#0)
751	return -EINVAL;	751	return -EINVAL;
752	memset(vch,0,sizeof(*vch));	752	memset(vch,0,sizeof(*vch));
753	strcpy(vch->name, "CCD-input");	753	strcpy(vch->name, "CCD-input");
754	vch->type = VIDEO_TYPE_CAMERA;	754	vch->type = VIDEO_TYPE_CAMERA;
755	return 0;	755	return 0;
756	}	756	}
757	case VIDIOCSCHAN:	757	case VIDIOCSCHAN:
758	{	758	{
759	struct video_channel *vch = arg;	759	struct video_channel *vch = arg;
760	if(vch->channel != 0)	760	if(vch->channel != 0)
761	return -EINVAL;	761	return -EINVAL;
762	return 0;	762	return 0;
763	}	763	}
764	case VIDIOCGTUNER:	764	case VIDIOCGTUNER:
765	{	765	{
766	struct video_tuner *vtune = arg;	766	struct video_tuner *vtune = arg;
767	if(vtune->tuner != 0)	767	if(vtune->tuner != 0)
768	return -EINVAL;	768	return -EINVAL;
769	strcpy(vtune->name, "no tuner");	769	strcpy(vtune->name, "no tuner");
770	vtune->rangelow = 0;	770	vtune->rangelow = 0;
771	vtune->rangehigh = 0;	771	vtune->rangehigh = 0;
772	vtune->flags = VIDEO_TUNER_NORM;	772	vtune->flags = VIDEO_TUNER_NORM;
773	vtune->mode = VIDEO_MODE_AUTO;	773	vtune->mode = VIDEO_MODE_AUTO;
774	vtune->signal = 0xffff;	774	vtune->signal = 0xffff;
775	return 0;	775	return 0;
776	}	776	}
777	case VIDIOCSTUNER:	777	case VIDIOCSTUNER:
778	{	778	{
779	struct video_tuner *vtune = arg;	779	struct video_tuner *vtune = arg;
780	if (vtune->tuner != 0)	780	if (vtune->tuner != 0)
781	return -EINVAL;	781	return -EINVAL;
782	if (vtune->mode != VIDEO_MODE_AUTO)	782	if (vtune->mode != VIDEO_MODE_AUTO)
783	return -EINVAL;	783	return -EINVAL;
784	return 0;	784	return 0;
785	}	785	}
786	case VIDIOCGPICT:	786	case VIDIOCGPICT:
787	{	787	{
788	struct video_picture vpic = {	788	struct video_picture vpic = {
789	cam->brightness << 8, // brightness	789	cam->brightness << 8, // brightness
790	(cam->hue + 128) << 8, // hue	790	(cam->hue + 128) << 8, // hue
791	cam->color << 9, // color	791	cam->color << 9, // color
792	cam->contrast << 9, // contrast	792	cam->contrast << 9, // contrast
793	0x8000, // whiteness	793	0x8000, // whiteness
794	16, VIDEO_PALETTE_YUV422// bpp, palette format	794	16, VIDEO_PALETTE_YUV422// bpp, palette format
795	};	795	};
796	struct video_picture *pic = arg;	796	struct video_picture *pic = arg;
797	*pic = vpic;	797	*pic = vpic;
798	return 0;	798	return 0;
799	}	799	}
800	case VIDIOCSPICT:	800	case VIDIOCSPICT:
801	{	801	{
802	struct video_picture *vpic = arg;	802	struct video_picture *vpic = arg;
803	if (vpic->depth != 16 \|\| (vpic->palette != VIDEO_PALETTE_YUV422 && vpic->palette != VIDEO_PALETTE_YUYV))	803	if (vpic->depth != 16 \|\| (vpic->palette != VIDEO_PALETTE_YUV422 && vpic->palette != VIDEO_PALETTE_YUYV))
804	return -EINVAL;	804	return -EINVAL;
805		805
806	cam->brightness = vpic->brightness >> 8;	806	cam->brightness = vpic->brightness >> 8;
807	cam->hue = (vpic->hue >> 8) - 128;	807	cam->hue = (vpic->hue >> 8) - 128;
808	cam->color = vpic->colour >> 9;	808	cam->color = vpic->colour >> 9;
809	cam->contrast = vpic->contrast >> 9;	809	cam->contrast = vpic->contrast >> 9;
810		810
811	w9966_pdev_claim(cam);	811	w9966_pdev_claim(cam);
812		812
813	if (	813	if (
814	w9966_wReg_i2c(cam, 0x0a, cam->brightness) == -1 \|\|	814	w9966_wReg_i2c(cam, 0x0a, cam->brightness) == -1 \|\|
815	w9966_wReg_i2c(cam, 0x0b, cam->contrast) == -1 \|\|	815	w9966_wReg_i2c(cam, 0x0b, cam->contrast) == -1 \|\|
816	w9966_wReg_i2c(cam, 0x0c, cam->color) == -1 \|\|	816	w9966_wReg_i2c(cam, 0x0c, cam->color) == -1 \|\|
817	w9966_wReg_i2c(cam, 0x0d, cam->hue) == -1	817	w9966_wReg_i2c(cam, 0x0d, cam->hue) == -1
818	) {	818	) {
819	w9966_pdev_release(cam);	819	w9966_pdev_release(cam);
820	return -EIO;	820	return -EIO;
821	}	821	}
822		822
823	w9966_pdev_release(cam);	823	w9966_pdev_release(cam);
824	return 0;	824	return 0;
825	}	825	}
826	case VIDIOCSWIN:	826	case VIDIOCSWIN:
827	{	827	{
828	int ret;	828	int ret;
829	struct video_window *vwin = arg;	829	struct video_window *vwin = arg;
830		830
831	if (vwin->flags != 0)	831	if (vwin->flags != 0)
832	return -EINVAL;	832	return -EINVAL;
833	if (vwin->clipcount != 0)	833	if (vwin->clipcount != 0)
834	return -EINVAL;	834	return -EINVAL;
835	if (vwin->width < 2 \|\| vwin->width > W9966_WND_MAX_W)	835	if (vwin->width < 2 \|\| vwin->width > W9966_WND_MAX_W)
836	return -EINVAL;	836	return -EINVAL;
837	if (vwin->height < 1 \|\| vwin->height > W9966_WND_MAX_H)	837	if (vwin->height < 1 \|\| vwin->height > W9966_WND_MAX_H)
838	return -EINVAL;	838	return -EINVAL;
839		839
840	// Update camera regs	840	// Update camera regs
841	w9966_pdev_claim(cam);	841	w9966_pdev_claim(cam);
842	ret = w9966_setup(cam, 0, 0, 1023, 1023, vwin->width, vwin->height);	842	ret = w9966_setup(cam, 0, 0, 1023, 1023, vwin->width, vwin->height);
843	w9966_pdev_release(cam);	843	w9966_pdev_release(cam);
844		844
845	if (ret != 0) {	845	if (ret != 0) {
846	DPRINTF("VIDIOCSWIN: w9966_setup() failed.\n");	846	DPRINTF("VIDIOCSWIN: w9966_setup() failed.\n");
847	return -EIO;	847	return -EIO;
848	}	848	}
849		849
850	return 0;	850	return 0;
851	}	851	}
852	case VIDIOCGWIN:	852	case VIDIOCGWIN:
853	{	853	{
854	struct video_window *vwin = arg;	854	struct video_window *vwin = arg;
855	memset(vwin, 0, sizeof(*vwin));	855	memset(vwin, 0, sizeof(*vwin));
856	vwin->width = cam->width;	856	vwin->width = cam->width;
857	vwin->height = cam->height;	857	vwin->height = cam->height;
858	return 0;	858	return 0;
859	}	859	}
860	// Unimplemented	860	// Unimplemented
861	case VIDIOCCAPTURE:	861	case VIDIOCCAPTURE:
862	case VIDIOCGFBUF:	862	case VIDIOCGFBUF:
863	case VIDIOCSFBUF:	863	case VIDIOCSFBUF:
864	case VIDIOCKEY:	864	case VIDIOCKEY:
865	case VIDIOCGFREQ:	865	case VIDIOCGFREQ:
866	case VIDIOCSFREQ:	866	case VIDIOCSFREQ:
867	case VIDIOCGAUDIO:	867	case VIDIOCGAUDIO:
868	case VIDIOCSAUDIO:	868	case VIDIOCSAUDIO:
869	return -EINVAL;	869	return -EINVAL;
870	default:	870	default:
871	return -ENOIOCTLCMD;	871	return -ENOIOCTLCMD;
872	}	872	}
873	return 0;	873	return 0;
874	}	874	}
875		875
876	static long w9966_v4l_ioctl(struct file *file,	876	static long w9966_v4l_ioctl(struct file *file,
877	unsigned int cmd, unsigned long arg)	877	unsigned int cmd, unsigned long arg)
878	{	878	{
879	return video_usercopy(file, cmd, arg, w9966_v4l_do_ioctl);	879	return video_usercopy(file, cmd, arg, w9966_v4l_do_ioctl);
880	}	880	}
881		881
882	// Capture data	882	// Capture data
883	static ssize_t w9966_v4l_read(struct file file, char __user buf,	883	static ssize_t w9966_v4l_read(struct file file, char __user buf,
884	size_t count, loff_t *ppos)	884	size_t count, loff_t *ppos)
885	{	885	{
886	struct w9966_dev *cam = video_drvdata(file);	886	struct w9966_dev *cam = video_drvdata(file);
887	unsigned char addr = 0xa0; // ECP, read, CCD-transfer, 00000	887	unsigned char addr = 0xa0; // ECP, read, CCD-transfer, 00000
888	unsigned char __user dest = (unsigned char __user )buf;	888	unsigned char __user dest = (unsigned char __user )buf;
889	unsigned long dleft = count;	889	unsigned long dleft = count;
890	unsigned char *tbuf;	890	unsigned char *tbuf;
891		891
892	// Why would anyone want more than this??	892	// Why would anyone want more than this??
893	if (count > cam->width * cam->height * 2)	893	if (count > cam->width * cam->height * 2)
894	return -EINVAL;	894	return -EINVAL;
895		895
896	w9966_pdev_claim(cam);	896	w9966_pdev_claim(cam);
897	w9966_wReg(cam, 0x00, 0x02); // Reset ECP-FIFO buffer	897	w9966_wReg(cam, 0x00, 0x02); // Reset ECP-FIFO buffer
898	w9966_wReg(cam, 0x00, 0x00); // Return to normal operation	898	w9966_wReg(cam, 0x00, 0x00); // Return to normal operation
899	w9966_wReg(cam, 0x01, 0x98); // Enable capture	899	w9966_wReg(cam, 0x01, 0x98); // Enable capture
900		900
901	// write special capture-addr and negotiate into data transfer	901	// write special capture-addr and negotiate into data transfer
902	if (	902	if (
903	(parport_negotiate(cam->pport, cam->ppmode\|IEEE1284_ADDR) != 0 )\|\|	903	(parport_negotiate(cam->pport, cam->ppmode\|IEEE1284_ADDR) != 0 )\|\|
904	(parport_write(cam->pport, &addr, 1) != 1 )\|\|	904	(parport_write(cam->pport, &addr, 1) != 1 )\|\|
905	(parport_negotiate(cam->pport, cam->ppmode\|IEEE1284_DATA) != 0 )	905	(parport_negotiate(cam->pport, cam->ppmode\|IEEE1284_DATA) != 0 )
906	) {	906	) {
907	w9966_pdev_release(cam);	907	w9966_pdev_release(cam);
908	return -EFAULT;	908	return -EFAULT;
909	}	909	}
910		910
911	tbuf = kmalloc(W9966_RBUFFER, GFP_KERNEL);	911	tbuf = kmalloc(W9966_RBUFFER, GFP_KERNEL);
912	if (tbuf == NULL) {	912	if (tbuf == NULL) {
913	count = -ENOMEM;	913	count = -ENOMEM;
914	goto out;	914	goto out;
915	}	915	}
916		916
917	while(dleft > 0)	917	while(dleft > 0)
918	{	918	{
919	unsigned long tsize = (dleft > W9966_RBUFFER) ? W9966_RBUFFER : dleft;	919	unsigned long tsize = (dleft > W9966_RBUFFER) ? W9966_RBUFFER : dleft;
920		920
921	if (parport_read(cam->pport, tbuf, tsize) < tsize) {	921	if (parport_read(cam->pport, tbuf, tsize) < tsize) {
922	count = -EFAULT;	922	count = -EFAULT;
923	goto out;	923	goto out;
924	}	924	}
925	if (copy_to_user(dest, tbuf, tsize) != 0) {	925	if (copy_to_user(dest, tbuf, tsize) != 0) {
926	count = -EFAULT;	926	count = -EFAULT;
927	goto out;	927	goto out;
928	}	928	}
929	dest += tsize;	929	dest += tsize;
930	dleft -= tsize;	930	dleft -= tsize;
931	}	931	}
932		932
933	w9966_wReg(cam, 0x01, 0x18); // Disable capture	933	w9966_wReg(cam, 0x01, 0x18); // Disable capture
934		934
935	out:	935	out:
936	kfree(tbuf);	936	kfree(tbuf);
937	w9966_pdev_release(cam);	937	w9966_pdev_release(cam);
938		938
939	return count;	939	return count;
940	}	940	}
941		941
942		942
943	// Called once for every parport on init	943	// Called once for every parport on init
944	static void w9966_attach(struct parport *port)	944	static void w9966_attach(struct parport *port)
945	{	945	{
946	int i;	946	int i;
947		947
948	for (i = 0; i < W9966_MAXCAMS; i++)	948	for (i = 0; i < W9966_MAXCAMS; i++)
949	{	949	{
950	if (w9966_cams[i].dev_state != 0) // Cam is already assigned	950	if (w9966_cams[i].dev_state != 0) // Cam is already assigned
951	continue;	951	continue;
952	if (	952	if (
953	strcmp(pardev[i], "aggressive") == 0 \|\|	953	strcmp(pardev[i], "aggressive") == 0 \|\|
954	strcmp(pardev[i], port->name) == 0	954	strcmp(pardev[i], port->name) == 0
955	) {	955	) {
956	if (w9966_init(&w9966_cams[i], port) != 0)	956	if (w9966_init(&w9966_cams[i], port) != 0)
957	w9966_term(&w9966_cams[i]);	957	w9966_term(&w9966_cams[i]);
958	break; // return	958	break; // return
959	}	959	}
960	}	960	}
961	}	961	}
962		962
963	// Called once for every parport on termination	963	// Called once for every parport on termination
964	static void w9966_detach(struct parport *port)	964	static void w9966_detach(struct parport *port)
965	{	965	{
966	int i;	966	int i;
967	for (i = 0; i < W9966_MAXCAMS; i++)	967	for (i = 0; i < W9966_MAXCAMS; i++)
968	if (w9966_cams[i].dev_state != 0 && w9966_cams[i].pport == port)	968	if (w9966_cams[i].dev_state != 0 && w9966_cams[i].pport == port)
969	w9966_term(&w9966_cams[i]);	969	w9966_term(&w9966_cams[i]);
970	}	970	}
971		971
972		972
973	static struct parport_driver w9966_ppd = {	973	static struct parport_driver w9966_ppd = {
974	.name = W9966_DRIVERNAME,	974	.name = W9966_DRIVERNAME,
975	.attach = w9966_attach,	975	.attach = w9966_attach,
976	.detach = w9966_detach,	976	.detach = w9966_detach,
977	};	977	};
978		978
979	// Module entry point	979	// Module entry point
980	static int __init w9966_mod_init(void)	980	static int __init w9966_mod_init(void)
981	{	981	{
982	int i;	982	int i;
983	for (i = 0; i < W9966_MAXCAMS; i++)	983	for (i = 0; i < W9966_MAXCAMS; i++)
984	w9966_cams[i].dev_state = 0;	984	w9966_cams[i].dev_state = 0;
985		985
986	return parport_register_driver(&w9966_ppd);	986	return parport_register_driver(&w9966_ppd);
987	}	987	}
988		988
989	// Module cleanup	989	// Module cleanup
990	static void __exit w9966_mod_term(void)	990	static void __exit w9966_mod_term(void)
991	{	991	{
992	parport_unregister_driver(&w9966_ppd);	992	parport_unregister_driver(&w9966_ppd);
993	}	993	}
994		994
995	module_init(w9966_mod_init);	995	module_init(w9966_mod_init);
996	module_exit(w9966_mod_term);	996	module_exit(w9966_mod_term);
997		997

drivers/media/video/w9968cf.c

Diff comments View file @ 7e0a16f

 /***************************************************************************
  * Video4Linux driver for W996[87]CF JPEG USB Dual Mode Camera Chip.       *
  *                                                                         *
  * Copyright (C) 2002-2004 by Luca Risolia <luca.risolia@studio.unibo.it>  *
  *                                                                         *
  * - Memory management code from bttv driver by Ralph Metzler,             *
  *   Marcus Metzler and Gerd Knorr.                                        *
  * - I2C interface to kernel, high-level image sensor control routines and *
  *   some symbolic names from OV511 driver by Mark W. McClelland.          *
  * - Low-level I2C fast write function by Piotr Czerczak.                  *
  * - Low-level I2C read function by Frederic Jouault.                      *
  *                                                                         *
  * This program is free software; you can redistribute it and/or modify    *
  * it under the terms of the GNU General Public License as published by    *
  * the Free Software Foundation; either version 2 of the License, or       *
  * (at your option) any later version.                                     *
  *                                                                         *
  * This program is distributed in the hope that it will be useful,         *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  * GNU General Public License for more details.                            *
  *                                                                         *
  * You should have received a copy of the GNU General Public License       *
  * along with this program; if not, write to the Free Software             *
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.               *
  ***************************************************************************/
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/kmod.h>
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/ioctl.h>
 #include <linux/delay.h>
 #include <linux/stddef.h>
 #include <asm/page.h>
 #include <asm/uaccess.h>
 #include <linux/page-flags.h>
+#include <linux/videodev.h>
 #include <media/v4l2-ioctl.h>
 #include "w9968cf.h"
 #include "w9968cf_decoder.h"
 static struct w9968cf_vpp_t* w9968cf_vpp;
 static DECLARE_WAIT_QUEUE_HEAD(w9968cf_vppmod_wait);
 static LIST_HEAD(w9968cf_dev_list); /* head of V4L registered cameras list */
 static DEFINE_MUTEX(w9968cf_devlist_mutex); /* semaphore for list traversal */
 static DECLARE_RWSEM(w9968cf_disconnect); /* prevent races with open() */
 /****************************************************************************
  * Module macros and parameters                                             *
  ****************************************************************************/
 MODULE_DEVICE_TABLE(usb, winbond_id_table);
 MODULE_AUTHOR(W9968CF_MODULE_AUTHOR" "W9968CF_AUTHOR_EMAIL);
 MODULE_DESCRIPTION(W9968CF_MODULE_NAME);
 MODULE_VERSION(W9968CF_MODULE_VERSION);
 MODULE_LICENSE(W9968CF_MODULE_LICENSE);
 MODULE_SUPPORTED_DEVICE("Video");
 static unsigned short simcams = W9968CF_SIMCAMS;
 static short video_nr[]={[0 ... W9968CF_MAX_DEVICES-1] = -1}; /*-1=first free*/
 static unsigned int packet_size[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 				     W9968CF_PACKET_SIZE};
 static unsigned short max_buffers[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 				       W9968CF_BUFFERS};
 static int double_buffer[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 			      W9968CF_DOUBLE_BUFFER};
 static int clamping[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_CLAMPING};
 static unsigned short filter_type[]= {[0 ... W9968CF_MAX_DEVICES-1] =
 				      W9968CF_FILTER_TYPE};
 static int largeview[]= {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_LARGEVIEW};
 static unsigned short decompression[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 					 W9968CF_DECOMPRESSION};
 static int upscaling[]= {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_UPSCALING};
 static unsigned short force_palette[] = {[0 ... W9968CF_MAX_DEVICES-1] = 0};
 static int force_rgb[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_FORCE_RGB};
 static int autobright[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_AUTOBRIGHT};
 static int autoexp[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_AUTOEXP};
 static unsigned short lightfreq[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 				     W9968CF_LIGHTFREQ};
 static int bandingfilter[] = {[0 ... W9968CF_MAX_DEVICES-1]=
 			      W9968CF_BANDINGFILTER};
 static short clockdiv[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_CLOCKDIV};
 static int backlight[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_BACKLIGHT};
 static int mirror[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_MIRROR};
 static int monochrome[] = {[0 ... W9968CF_MAX_DEVICES-1]=W9968CF_MONOCHROME};
 static unsigned int brightness[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 				    W9968CF_BRIGHTNESS};
 static unsigned int hue[] = {[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_HUE};
 static unsigned int colour[]={[0 ... W9968CF_MAX_DEVICES-1] = W9968CF_COLOUR};
 static unsigned int contrast[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 				  W9968CF_CONTRAST};
 static unsigned int whiteness[] = {[0 ... W9968CF_MAX_DEVICES-1] =
 				   W9968CF_WHITENESS};
 #ifdef W9968CF_DEBUG
 static unsigned short debug = W9968CF_DEBUG_LEVEL;
 static int specific_debug = W9968CF_SPECIFIC_DEBUG;
 #endif
 static unsigned int param_nv[24]; /* number of values per parameter */
 module_param(simcams, ushort, 0644);
 module_param_array(video_nr, short, &param_nv[0], 0444);
 module_param_array(packet_size, uint, &param_nv[1], 0444);
 module_param_array(max_buffers, ushort, &param_nv[2], 0444);
 module_param_array(double_buffer, bool, &param_nv[3], 0444);
 module_param_array(clamping, bool, &param_nv[4], 0444);
 module_param_array(filter_type, ushort, &param_nv[5], 0444);
 module_param_array(largeview, bool, &param_nv[6], 0444);
 module_param_array(decompression, ushort, &param_nv[7], 0444);
 module_param_array(upscaling, bool, &param_nv[8], 0444);
 module_param_array(force_palette, ushort, &param_nv[9], 0444);
 module_param_array(force_rgb, ushort, &param_nv[10], 0444);
 module_param_array(autobright, bool, &param_nv[11], 0444);
 module_param_array(autoexp, bool, &param_nv[12], 0444);
 module_param_array(lightfreq, ushort, &param_nv[13], 0444);
 module_param_array(bandingfilter, bool, &param_nv[14], 0444);
 module_param_array(clockdiv, short, &param_nv[15], 0444);
 module_param_array(backlight, bool, &param_nv[16], 0444);
 module_param_array(mirror, bool, &param_nv[17], 0444);
 module_param_array(monochrome, bool, &param_nv[18], 0444);
 module_param_array(brightness, uint, &param_nv[19], 0444);
 module_param_array(hue, uint, &param_nv[20], 0444);
 module_param_array(colour, uint, &param_nv[21], 0444);
 module_param_array(contrast, uint, &param_nv[22], 0444);
 module_param_array(whiteness, uint, &param_nv[23], 0444);
 #ifdef W9968CF_DEBUG
 module_param(debug, ushort, 0644);
 module_param(specific_debug, bool, 0644);
 #endif
 MODULE_PARM_DESC(simcams,
 		 "\n<n> Number of cameras allowed to stream simultaneously."
 		 "\nn may vary from 0 to "
 		 __MODULE_STRING(W9968CF_MAX_DEVICES)"."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_SIMCAMS)"."
 		 "\n");
 MODULE_PARM_DESC(video_nr,
 		 "\n<-1|n[,...]> Specify V4L minor mode number."
 		 "\n -1 = use next available (default)"
 		 "\n  n = use minor number n (integer >= 0)"
 		 "\nYou can specify up to "__MODULE_STRING(W9968CF_MAX_DEVICES)
 		 " cameras this way."
 		 "\nFor example:"
 		 "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
 		 "\nthe second camera and use auto for the first"
 		 "\none and for every other camera."
 		 "\n");
 MODULE_PARM_DESC(packet_size,
 		 "\n<n[,...]> Specify the maximum data payload"
 		 "\nsize in bytes for alternate settings, for each device."
 		 "\nn is scaled between 63 and 1023 "
 		 "(default is "__MODULE_STRING(W9968CF_PACKET_SIZE)")."
 		 "\n");
 MODULE_PARM_DESC(max_buffers,
 		 "\n<n[,...]> For advanced users."
 		 "\nSpecify the maximum number of video frame buffers"
 		 "\nto allocate for each device, from 2 to "
 		 __MODULE_STRING(W9968CF_MAX_BUFFERS)
 		 ". (default is "__MODULE_STRING(W9968CF_BUFFERS)")."
 		 "\n");
 MODULE_PARM_DESC(double_buffer,
 		 "\n<0|1[,...]> "
 		 "Hardware double buffering: 0 disabled, 1 enabled."
 		 "\nIt should be enabled if you want smooth video output: if"
 		 "\nyou obtain out of sync. video, disable it, or try to"
 		 "\ndecrease the 'clockdiv' module parameter value."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_DOUBLE_BUFFER)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(clamping,
 		 "\n<0|1[,...]> Video data clamping: 0 disabled, 1 enabled."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_CLAMPING)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(filter_type,
 		 "\n<0|1|2[,...]> Video filter type."
 		 "\n0 none, 1 (1-2-1) 3-tap filter, "
 		 "2 (2-3-6-3-2) 5-tap filter."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_FILTER_TYPE)
 		 " for every device."
 		 "\nThe filter is used to reduce noise and aliasing artifacts"
 		 "\nproduced by the CCD or CMOS image sensor, and the scaling"
 		 " process."
 		 "\n");
 MODULE_PARM_DESC(largeview,
 		 "\n<0|1[,...]> Large view: 0 disabled, 1 enabled."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_LARGEVIEW)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(upscaling,
 		 "\n<0|1[,...]> Software scaling (for non-compressed video):"
 		 "\n0 disabled, 1 enabled."
 		 "\nDisable it if you have a slow CPU or you don't have"
 		 " enough memory."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_UPSCALING)
 		 " for every device."
 		 "\nIf 'w9968cf-vpp' is not present, this parameter is"
 		 " set to 0."
 		 "\n");
 MODULE_PARM_DESC(decompression,
 		 "\n<0|1|2[,...]> Software video decompression:"
 		 "\n- 0 disables decompression (doesn't allow formats needing"
 		 " decompression)"
 		 "\n- 1 forces decompression (allows formats needing"
 		 " decompression only);"
 		 "\n- 2 allows any permitted formats."
 		 "\nFormats supporting compressed video are YUV422P and"
 		 " YUV420P/YUV420 "
 		 "\nin any resolutions where both width and height are "
 		 "a multiple of 16."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_DECOMPRESSION)
 		 " for every device."
 		 "\nIf 'w9968cf-vpp' is not present, forcing decompression is "
 		 "\nnot allowed; in this case this parameter is set to 2."
 		 "\n");
 MODULE_PARM_DESC(force_palette,
 		 "\n<0"
 		 "|" __MODULE_STRING(VIDEO_PALETTE_UYVY)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_YUV420)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_YUV422P)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_YUV420P)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_YUYV)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_YUV422)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_GREY)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_RGB555)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_RGB565)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_RGB24)
 		 "|" __MODULE_STRING(VIDEO_PALETTE_RGB32)
 		 "[,...]>"
 		 " Force picture palette."
 		 "\nIn order:"
 		 "\n- 0 allows any of the following formats:"
 		 "\n- UYVY    16 bpp - Original video, compression disabled"
 		 "\n- YUV420  12 bpp - Original video, compression enabled"
 		 "\n- YUV422P 16 bpp - Original video, compression enabled"
 		 "\n- YUV420P 12 bpp - Original video, compression enabled"
 		 "\n- YUVY    16 bpp - Software conversion from UYVY"
 		 "\n- YUV422  16 bpp - Software conversion from UYVY"
 		 "\n- GREY     8 bpp - Software conversion from UYVY"
 		 "\n- RGB555  16 bpp - Software conversion from UYVY"
 		 "\n- RGB565  16 bpp - Software conversion from UYVY"
 		 "\n- RGB24   24 bpp - Software conversion from UYVY"
 		 "\n- RGB32   32 bpp - Software conversion from UYVY"
 		 "\nWhen not 0, this parameter will override 'decompression'."
 		 "\nDefault value is 0 for every device."
 		 "\nInitial palette is "
 		 __MODULE_STRING(W9968CF_PALETTE_DECOMP_ON)"."
 		 "\nIf 'w9968cf-vpp' is not present, this parameter is"
 		 " set to 9 (UYVY)."
 		 "\n");
 MODULE_PARM_DESC(force_rgb,
 		 "\n<0|1[,...]> Read RGB video data instead of BGR:"
 		 "\n 1 = use RGB component ordering."
 		 "\n 0 = use BGR component ordering."
 		 "\nThis parameter has effect when using RGBX palettes only."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_FORCE_RGB)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(autobright,
 		 "\n<0|1[,...]> Image sensor automatically changes brightness:"
 		 "\n 0 = no, 1 = yes"
 		 "\nDefault value is "__MODULE_STRING(W9968CF_AUTOBRIGHT)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(autoexp,
 		 "\n<0|1[,...]> Image sensor automatically changes exposure:"
 		 "\n 0 = no, 1 = yes"
 		 "\nDefault value is "__MODULE_STRING(W9968CF_AUTOEXP)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(lightfreq,
 		 "\n<50|60[,...]> Light frequency in Hz:"
 		 "\n 50 for European and Asian lighting,"
 		 " 60 for American lighting."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_LIGHTFREQ)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(bandingfilter,
 		 "\n<0|1[,...]> Banding filter to reduce effects of"
 		 " fluorescent lighting:"
 		 "\n 0 disabled, 1 enabled."
 		 "\nThis filter tries to reduce the pattern of horizontal"
 		 "\nlight/dark bands caused by some (usually fluorescent)"
 		 " lighting."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_BANDINGFILTER)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(clockdiv,
 		 "\n<-1|n[,...]> "
 		 "Force pixel clock divisor to a specific value (for experts):"
 		 "\n  n may vary from 0 to 127."
 		 "\n -1 for automatic value."
 		 "\nSee also the 'double_buffer' module parameter."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_CLOCKDIV)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(backlight,
 		 "\n<0|1[,...]> Objects are lit from behind:"
 		 "\n 0 = no, 1 = yes"
 		 "\nDefault value is "__MODULE_STRING(W9968CF_BACKLIGHT)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(mirror,
 		 "\n<0|1[,...]> Reverse image horizontally:"
 		 "\n 0 = no, 1 = yes"
 		 "\nDefault value is "__MODULE_STRING(W9968CF_MIRROR)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(monochrome,
 		 "\n<0|1[,...]> Use image sensor as monochrome sensor:"
 		 "\n 0 = no, 1 = yes"
 		 "\nNot all the sensors support monochrome color."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_MONOCHROME)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(brightness,
 		 "\n<n[,...]> Set picture brightness (0-65535)."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_BRIGHTNESS)
 		 " for every device."
 		 "\nThis parameter has no effect if 'autobright' is enabled."
 		 "\n");
 MODULE_PARM_DESC(hue,
 		 "\n<n[,...]> Set picture hue (0-65535)."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_HUE)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(colour,
 		 "\n<n[,...]> Set picture saturation (0-65535)."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_COLOUR)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(contrast,
 		 "\n<n[,...]> Set picture contrast (0-65535)."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_CONTRAST)
 		 " for every device."
 		 "\n");
 MODULE_PARM_DESC(whiteness,
 		 "\n<n[,...]> Set picture whiteness (0-65535)."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_WHITENESS)
 		 " for every device."
 		 "\n");
 #ifdef W9968CF_DEBUG
 MODULE_PARM_DESC(debug,
 		 "\n<n> Debugging information level, from 0 to 6:"
 		 "\n0 = none (use carefully)"
 		 "\n1 = critical errors"
 		 "\n2 = significant informations"
 		 "\n3 = configuration or general messages"
 		 "\n4 = warnings"
 		 "\n5 = called functions"
 		 "\n6 = function internals"
 		 "\nLevel 5 and 6 are useful for testing only, when only "
 		 "one device is used."
 		 "\nDefault value is "__MODULE_STRING(W9968CF_DEBUG_LEVEL)"."
 		 "\n");
 MODULE_PARM_DESC(specific_debug,
 		 "\n<0|1> Enable or disable specific debugging messages:"
 		 "\n0 = print messages concerning every level"
 		 " <= 'debug' level."
 		 "\n1 = print messages concerning the level"
 		 " indicated by 'debug'."
 		 "\nDefault value is "
 		 __MODULE_STRING(W9968CF_SPECIFIC_DEBUG)"."
 		 "\n");
 #endif /* W9968CF_DEBUG */
 /****************************************************************************
  * Some prototypes                                                          *
  ****************************************************************************/
 /* Video4linux interface */
 static const struct v4l2_file_operations w9968cf_fops;
 static int w9968cf_open(struct file *);
 static int w9968cf_release(struct file *);
 static int w9968cf_mmap(struct file *, struct vm_area_struct *);
 static long w9968cf_ioctl(struct file *, unsigned, unsigned long);
 static ssize_t w9968cf_read(struct file *, char __user *, size_t, loff_t *);
 static long w9968cf_v4l_ioctl(struct file *, unsigned int,
 			     void __user *);
 /* USB-specific */
 static int w9968cf_start_transfer(struct w9968cf_device*);
 static int w9968cf_stop_transfer(struct w9968cf_device*);
 static int w9968cf_write_reg(struct w9968cf_device*, u16 value, u16 index);
 static int w9968cf_read_reg(struct w9968cf_device*, u16 index);
 static int w9968cf_write_fsb(struct w9968cf_device*, u16* data);
 static int w9968cf_write_sb(struct w9968cf_device*, u16 value);
 static int w9968cf_read_sb(struct w9968cf_device*);
 static int w9968cf_upload_quantizationtables(struct w9968cf_device*);
 static void w9968cf_urb_complete(struct urb *urb);
 /* Low-level I2C (SMBus) I/O */
 static int w9968cf_smbus_start(struct w9968cf_device*);
 static int w9968cf_smbus_stop(struct w9968cf_device*);
 static int w9968cf_smbus_write_byte(struct w9968cf_device*, u8 v);
 static int w9968cf_smbus_read_byte(struct w9968cf_device*, u8* v);
 static int w9968cf_smbus_write_ack(struct w9968cf_device*);
 static int w9968cf_smbus_read_ack(struct w9968cf_device*);
 static int w9968cf_smbus_refresh_bus(struct w9968cf_device*);
 static int w9968cf_i2c_adap_read_byte(struct w9968cf_device* cam,
 				      u16 address, u8* value);
 static int w9968cf_i2c_adap_read_byte_data(struct w9968cf_device*, u16 address,
 					   u8 subaddress, u8* value);
 static int w9968cf_i2c_adap_write_byte(struct w9968cf_device*,
 				       u16 address, u8 subaddress);
 static int w9968cf_i2c_adap_fastwrite_byte_data(struct w9968cf_device*,
 						u16 address, u8 subaddress,
 						u8 value);
 /* I2C interface to kernel */
 static int w9968cf_i2c_init(struct w9968cf_device*);
 static int w9968cf_i2c_smbus_xfer(struct i2c_adapter*, u16 addr,
 				  unsigned short flags, char read_write,
 				  u8 command, int size, union i2c_smbus_data*);
 static u32 w9968cf_i2c_func(struct i2c_adapter*);
 /* Memory management */
 static void* rvmalloc(unsigned long size);
 static void rvfree(void *mem, unsigned long size);
 static void w9968cf_deallocate_memory(struct w9968cf_device*);
 static int  w9968cf_allocate_memory(struct w9968cf_device*);
 /* High-level image sensor control functions */
 static int w9968cf_sensor_set_control(struct w9968cf_device*,int cid,int val);
 static int w9968cf_sensor_get_control(struct w9968cf_device*,int cid,int *val);
 static int w9968cf_sensor_cmd(struct w9968cf_device*,
 			      unsigned int cmd, void *arg);
 static int w9968cf_sensor_init(struct w9968cf_device*);
 static int w9968cf_sensor_update_settings(struct w9968cf_device*);
 static int w9968cf_sensor_get_picture(struct w9968cf_device*);
 static int w9968cf_sensor_update_picture(struct w9968cf_device*,
 					 struct video_picture pict);
 /* Other helper functions */
 static void w9968cf_configure_camera(struct w9968cf_device*,struct usb_device*,
 				     enum w9968cf_model_id,
 				     const unsigned short dev_nr);
 static void w9968cf_adjust_configuration(struct w9968cf_device*);
 static int w9968cf_turn_on_led(struct w9968cf_device*);
 static int w9968cf_init_chip(struct w9968cf_device*);
 static inline u16 w9968cf_valid_palette(u16 palette);
 static inline u16 w9968cf_valid_depth(u16 palette);
 static inline u8 w9968cf_need_decompression(u16 palette);
 static int w9968cf_set_picture(struct w9968cf_device*, struct video_picture);
 static int w9968cf_set_window(struct w9968cf_device*, struct video_window);
 static int w9968cf_postprocess_frame(struct w9968cf_device*,
 				     struct w9968cf_frame_t*);
 static int w9968cf_adjust_window_size(struct w9968cf_device*, u16* w, u16* h);
 static void w9968cf_init_framelist(struct w9968cf_device*);
 static void w9968cf_push_frame(struct w9968cf_device*, u8 f_num);
 static void w9968cf_pop_frame(struct w9968cf_device*,struct w9968cf_frame_t**);
 static void w9968cf_release_resources(struct w9968cf_device*);
 /****************************************************************************
  * Symbolic names                                                           *
  ****************************************************************************/
 /* Used to represent a list of values and their respective symbolic names */
 struct w9968cf_symbolic_list {
 	const int num;
 	const char *name;
 };
 /*--------------------------------------------------------------------------
   Returns the name of the matching element in the symbolic_list array. The
   end of the list must be marked with an element that has a NULL name.
   --------------------------------------------------------------------------*/
 static inline const char *
 symbolic(struct w9968cf_symbolic_list list[], const int num)
 {
 	int i;
 	for (i = 0; list[i].name != NULL; i++)
 		if (list[i].num == num)
 			return (list[i].name);
 	return "Unknown";
 }
 static struct w9968cf_symbolic_list camlist[] = {
 	{ W9968CF_MOD_GENERIC, "W996[87]CF JPEG USB Dual Mode Camera" },
 	{ W9968CF_MOD_CLVBWGP, "Creative Labs Video Blaster WebCam Go Plus" },
 	/* Other cameras (having the same descriptors as Generic W996[87]CF) */
 	{ W9968CF_MOD_ADPVDMA, "Aroma Digi Pen VGA Dual Mode ADG-5000" },
 	{ W9986CF_MOD_AAU, "AVerMedia AVerTV USB" },
 	{ W9968CF_MOD_CLVBWG, "Creative Labs Video Blaster WebCam Go" },
 	{ W9968CF_MOD_LL, "Lebon LDC-035A" },
 	{ W9968CF_MOD_EEEMC, "Ezonics EZ-802 EZMega Cam" },
 	{ W9968CF_MOD_OOE, "OmniVision OV8610-EDE" },
 	{ W9968CF_MOD_ODPVDMPC, "OPCOM Digi Pen VGA Dual Mode Pen Camera" },
 	{ W9968CF_MOD_PDPII, "Pretec Digi Pen-II" },
 	{ W9968CF_MOD_PDP480, "Pretec DigiPen-480" },
 	{  -1, NULL }
 };
 static struct w9968cf_symbolic_list senlist[] = {
 	{ CC_OV76BE,   "OV76BE" },
 	{ CC_OV7610,   "OV7610" },
 	{ CC_OV7620,   "OV7620" },
 	{ CC_OV7620AE, "OV7620AE" },
 	{ CC_OV6620,   "OV6620" },
 	{ CC_OV6630,   "OV6630" },
 	{ CC_OV6630AE, "OV6630AE" },
 	{ CC_OV6630AF, "OV6630AF" },
 	{ -1, NULL }
 };
 /* Video4Linux1 palettes */
 static struct w9968cf_symbolic_list v4l1_plist[] = {
 	{ VIDEO_PALETTE_GREY,    "GREY" },
 	{ VIDEO_PALETTE_HI240,   "HI240" },
 	{ VIDEO_PALETTE_RGB565,  "RGB565" },
 	{ VIDEO_PALETTE_RGB24,   "RGB24" },
 	{ VIDEO_PALETTE_RGB32,   "RGB32" },
 	{ VIDEO_PALETTE_RGB555,  "RGB555" },
 	{ VIDEO_PALETTE_YUV422,  "YUV422" },
 	{ VIDEO_PALETTE_YUYV,    "YUYV" },
 	{ VIDEO_PALETTE_UYVY,    "UYVY" },
 	{ VIDEO_PALETTE_YUV420,  "YUV420" },
 	{ VIDEO_PALETTE_YUV411,  "YUV411" },
 	{ VIDEO_PALETTE_RAW,     "RAW" },
 	{ VIDEO_PALETTE_YUV422P, "YUV422P" },
 	{ VIDEO_PALETTE_YUV411P, "YUV411P" },
 	{ VIDEO_PALETTE_YUV420P, "YUV420P" },
 	{ VIDEO_PALETTE_YUV410P, "YUV410P" },
 	{ -1, NULL }
 };
 /* Decoder error codes: */
 static struct w9968cf_symbolic_list decoder_errlist[] = {
 	{ W9968CF_DEC_ERR_CORRUPTED_DATA, "Corrupted data" },
 	{ W9968CF_DEC_ERR_BUF_OVERFLOW,   "Buffer overflow" },
 	{ W9968CF_DEC_ERR_NO_SOI,         "SOI marker not found" },
 	{ W9968CF_DEC_ERR_NO_SOF0,        "SOF0 marker not found" },
 	{ W9968CF_DEC_ERR_NO_SOS,         "SOS marker not found" },
 	{ W9968CF_DEC_ERR_NO_EOI,         "EOI marker not found" },
 	{ -1, NULL }
 };
 /* URB error codes: */
 static struct w9968cf_symbolic_list urb_errlist[] = {
 	{ -ENOMEM,    "No memory for allocation of internal structures" },
 	{ -ENOSPC,    "The host controller's bandwidth is already consumed" },
 	{ -ENOENT,    "URB was canceled by unlink_urb" },
 	{ -EXDEV,     "ISO transfer only partially completed" },
 	{ -EAGAIN,    "Too match scheduled for the future" },
 	{ -ENXIO,     "URB already queued" },
 	{ -EFBIG,     "Too much ISO frames requested" },
 	{ -ENOSR,     "Buffer error (overrun)" },
 	{ -EPIPE,     "Specified endpoint is stalled (device not responding)"},
 	{ -EOVERFLOW, "Babble (too much data)" },
 	{ -EPROTO,    "Bit-stuff error (bad cable?)" },
 	{ -EILSEQ,    "CRC/Timeout" },
 	{ -ETIME,     "Device does not respond to token" },
 	{ -ETIMEDOUT, "Device does not respond to command" },
 	{ -1, NULL }
 };
 /****************************************************************************
  * Memory management functions                                              *
  ****************************************************************************/
 static void* rvmalloc(unsigned long size)
 {
 	void* mem;
 	unsigned long adr;
 	size = PAGE_ALIGN(size);
 	mem = vmalloc_32(size);
 	if (!mem)
 		return NULL;
 	memset(mem, 0, size); /* Clear the ram out, no junk to the user */
 	adr = (unsigned long) mem;
 	while (size > 0) {
 		SetPageReserved(vmalloc_to_page((void *)adr));
 		adr += PAGE_SIZE;
 		size -= PAGE_SIZE;
 	}
 	return mem;
 }
 static void rvfree(void* mem, unsigned long size)
 {
 	unsigned long adr;
 	if (!mem)
 		return;
 	adr = (unsigned long) mem;
 	while ((long) size > 0) {
 		ClearPageReserved(vmalloc_to_page((void *)adr));
 		adr += PAGE_SIZE;
 		size -= PAGE_SIZE;
 	}
 	vfree(mem);
 }
 /*--------------------------------------------------------------------------
   Deallocate previously allocated memory.
   --------------------------------------------------------------------------*/
 static void w9968cf_deallocate_memory(struct w9968cf_device* cam)
 {
 	u8 i;
 	/* Free the isochronous transfer buffers */
 	for (i = 0; i < W9968CF_URBS; i++) {
 		kfree(cam->transfer_buffer[i]);
 		cam->transfer_buffer[i] = NULL;
 	}
 	/* Free temporary frame buffer */
 	if (cam->frame_tmp.buffer) {
 		rvfree(cam->frame_tmp.buffer, cam->frame_tmp.size);
 		cam->frame_tmp.buffer = NULL;
 	}
 	/* Free helper buffer */
 	if (cam->frame_vpp.buffer) {
 		rvfree(cam->frame_vpp.buffer, cam->frame_vpp.size);
 		cam->frame_vpp.buffer = NULL;
 	}
 	/* Free video frame buffers */
 	if (cam->frame[0].buffer) {
 		rvfree(cam->frame[0].buffer, cam->nbuffers*cam->frame[0].size);
 		cam->frame[0].buffer = NULL;
 	}
 	cam->nbuffers = 0;
 	DBG(5, "Memory successfully deallocated")
 }
 /*--------------------------------------------------------------------------
   Allocate memory buffers for USB transfers and video frames.
   This function is called by open() only.
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_allocate_memory(struct w9968cf_device* cam)
 {
 	const u16 p_size = wMaxPacketSize[cam->altsetting-1];
 	void* buff = NULL;
 	unsigned long hw_bufsize, vpp_bufsize;
 	u8 i, bpp;
 	/* NOTE: Deallocation is done elsewhere in case of error */
 	/* Calculate the max amount of raw data per frame from the device */
 	hw_bufsize = cam->maxwidth*cam->maxheight*2;
 	/* Calculate the max buf. size needed for post-processing routines */
 	bpp = (w9968cf_vpp) ? 4 : 2;
 	if (cam->upscaling)
 		vpp_bufsize = max(W9968CF_MAX_WIDTH*W9968CF_MAX_HEIGHT*bpp,
 				  cam->maxwidth*cam->maxheight*bpp);
 	else
 		vpp_bufsize = cam->maxwidth*cam->maxheight*bpp;
 	/* Allocate memory for the isochronous transfer buffers */
 	for (i = 0; i < W9968CF_URBS; i++) {
 		if (!(cam->transfer_buffer[i] =
 		      kzalloc(W9968CF_ISO_PACKETS*p_size, GFP_KERNEL))) {
 			DBG(1, "Couldn't allocate memory for the isochronous "
 			       "transfer buffers (%u bytes)",
 			    p_size * W9968CF_ISO_PACKETS)
 			return -ENOMEM;
 		}
 	}
 	/* Allocate memory for the temporary frame buffer */
 	if (!(cam->frame_tmp.buffer = rvmalloc(hw_bufsize))) {
 		DBG(1, "Couldn't allocate memory for the temporary "
 		       "video frame buffer (%lu bytes)", hw_bufsize)
 		return -ENOMEM;
 	}
 	cam->frame_tmp.size = hw_bufsize;
 	cam->frame_tmp.number = -1;
 	/* Allocate memory for the helper buffer */
 	if (w9968cf_vpp) {
 		if (!(cam->frame_vpp.buffer = rvmalloc(vpp_bufsize))) {
 			DBG(1, "Couldn't allocate memory for the helper buffer"
 			       " (%lu bytes)", vpp_bufsize)
 			return -ENOMEM;
 		}
 		cam->frame_vpp.size = vpp_bufsize;
 	} else
 		cam->frame_vpp.buffer = NULL;
 	/* Allocate memory for video frame buffers */
 	cam->nbuffers = cam->max_buffers;
 	while (cam->nbuffers >= 2) {
 		if ((buff = rvmalloc(cam->nbuffers * vpp_bufsize)))
 			break;
 		else
 			cam->nbuffers--;
 	}
 	if (!buff) {
 		DBG(1, "Couldn't allocate memory for the video frame buffers")
 		cam->nbuffers = 0;
 		return -ENOMEM;
 	}
 	if (cam->nbuffers != cam->max_buffers)
 		DBG(2, "Couldn't allocate memory for %u video frame buffers. "
 		       "Only memory for %u buffers has been allocated",
 		    cam->max_buffers, cam->nbuffers)
 	for (i = 0; i < cam->nbuffers; i++) {
 		cam->frame[i].buffer = buff + i*vpp_bufsize;
 		cam->frame[i].size = vpp_bufsize;
 		cam->frame[i].number = i;
 		/* Circular list */
 		if (i != cam->nbuffers-1)
 			cam->frame[i].next = &cam->frame[i+1];
 		else
 			cam->frame[i].next = &cam->frame[0];
 		cam->frame[i].status = F_UNUSED;
 	}
 	DBG(5, "Memory successfully allocated")
 	return 0;
 }
 /****************************************************************************
  * USB-specific functions                                                   *
  ****************************************************************************/
 /*--------------------------------------------------------------------------
   This is an handler function which is called after the URBs are completed.
   It collects multiple data packets coming from the camera by putting them
   into frame buffers: one or more zero data length data packets are used to
   mark the end of a video frame; the first non-zero data packet is the start
   of the next video frame; if an error is encountered in a packet, the entire
   video frame is discarded and grabbed again.
   If there are no requested frames in the FIFO list, packets are collected into
   a temporary buffer.
   --------------------------------------------------------------------------*/
 static void w9968cf_urb_complete(struct urb *urb)
 {
 	struct w9968cf_device* cam = (struct w9968cf_device*)urb->context;
 	struct w9968cf_frame_t** f;
 	unsigned int len, status;
 	void* pos;
 	u8 i;
 	int err = 0;
 	if ((!cam->streaming) || cam->disconnected) {
 		DBG(4, "Got interrupt, but not streaming")
 		return;
 	}
 	/* "(*f)" will be used instead of "cam->frame_current" */
 	f = &cam->frame_current;
 	/* If a frame has been requested and we are grabbing into
 	   the temporary frame, we'll switch to that requested frame */
 	if ((*f) == &cam->frame_tmp && *cam->requested_frame) {
 		if (cam->frame_tmp.status == F_GRABBING) {
 			w9968cf_pop_frame(cam, &cam->frame_current);
 			(*f)->status = F_GRABBING;
 			(*f)->length = cam->frame_tmp.length;
 			memcpy((*f)->buffer, cam->frame_tmp.buffer,
 			       (*f)->length);
 			DBG(6, "Switched from temp. frame to frame #%d",
 			    (*f)->number)
 		}
 	}
 	for (i = 0; i < urb->number_of_packets; i++) {
 		len = urb->iso_frame_desc[i].actual_length;
 		status = urb->iso_frame_desc[i].status;
 		pos = urb->iso_frame_desc[i].offset + urb->transfer_buffer;
 		if (status && len != 0) {
 			DBG(4, "URB failed, error in data packet "
 			       "(error #%u, %s)",
 			    status, symbolic(urb_errlist, status))
 			(*f)->status = F_ERROR;
 			continue;
 		}
 		if (len) { /* start of frame */
 			if ((*f)->status == F_UNUSED) {
 				(*f)->status = F_GRABBING;
 				(*f)->length = 0;
 			}
 			/* Buffer overflows shouldn't happen, however...*/
 			if ((*f)->length + len > (*f)->size) {
 				DBG(4, "Buffer overflow: bad data packets")
 				(*f)->status = F_ERROR;
 			}
 			if ((*f)->status == F_GRABBING) {
 				memcpy((*f)->buffer + (*f)->length, pos, len);
 				(*f)->length += len;
 			}
 		} else if ((*f)->status == F_GRABBING) { /* end of frame */
 			DBG(6, "Frame #%d successfully grabbed", (*f)->number)
 			if (cam->vpp_flag & VPP_DECOMPRESSION) {
 				err = w9968cf_vpp->check_headers((*f)->buffer,
 								 (*f)->length);
 				if (err) {
 					DBG(4, "Skip corrupted frame: %s",
 					    symbolic(decoder_errlist, err))
 					(*f)->status = F_UNUSED;
 					continue; /* grab this frame again */
 				}
 			}
 			(*f)->status = F_READY;
 			(*f)->queued = 0;
 			/* Take a pointer to the new frame from the FIFO list.
 			   If the list is empty,we'll use the temporary frame*/
 			if (*cam->requested_frame)
 				w9968cf_pop_frame(cam, &cam->frame_current);
 			else {
 				cam->frame_current = &cam->frame_tmp;
 				(*f)->status = F_UNUSED;
 			}
 		} else if ((*f)->status == F_ERROR)
 			(*f)->status = F_UNUSED; /* grab it again */
 		PDBGG("Frame length %lu | pack.#%u | pack.len. %u | state %d",
 		      (unsigned long)(*f)->length, i, len, (*f)->status)
 	} /* end for */
 	/* Resubmit this URB */
 	urb->dev = cam->usbdev;
 	urb->status = 0;
 	spin_lock(&cam->urb_lock);
 	if (cam->streaming)
 		if ((err = usb_submit_urb(urb, GFP_ATOMIC))) {
 			cam->misconfigured = 1;
 			DBG(1, "Couldn't resubmit the URB: error %d, %s",
 			    err, symbolic(urb_errlist, err))
 		}
 	spin_unlock(&cam->urb_lock);
 	/* Wake up the user process */
 	wake_up_interruptible(&cam->wait_queue);
 }
 /*---------------------------------------------------------------------------
   Setup the URB structures for the isochronous transfer.
   Submit the URBs so that the data transfer begins.
   Return 0 on success, a negative number otherwise.
   ---------------------------------------------------------------------------*/
 static int w9968cf_start_transfer(struct w9968cf_device* cam)
 {
 	struct usb_device *udev = cam->usbdev;
 	struct urb* urb;
 	const u16 p_size = wMaxPacketSize[cam->altsetting-1];
 	u16 w, h, d;
 	int vidcapt;
 	u32 t_size;
 	int err = 0;
 	s8 i, j;
 	for (i = 0; i < W9968CF_URBS; i++) {
 		urb = usb_alloc_urb(W9968CF_ISO_PACKETS, GFP_KERNEL);
 		if (!urb) {
 			for (j = 0; j < i; j++)
 				usb_free_urb(cam->urb[j]);
 			DBG(1, "Couldn't allocate the URB structures")
 			return -ENOMEM;
 		}
 		cam->urb[i] = urb;
 		urb->dev = udev;
 		urb->context = (void*)cam;
 		urb->pipe = usb_rcvisocpipe(udev, 1);
 		urb->transfer_flags = URB_ISO_ASAP;
 		urb->number_of_packets = W9968CF_ISO_PACKETS;
 		urb->complete = w9968cf_urb_complete;
 		urb->transfer_buffer = cam->transfer_buffer[i];
 		urb->transfer_buffer_length = p_size*W9968CF_ISO_PACKETS;
 		urb->interval = 1;
 		for (j = 0; j < W9968CF_ISO_PACKETS; j++) {
 			urb->iso_frame_desc[j].offset = p_size*j;
 			urb->iso_frame_desc[j].length = p_size;
 		}
 	}
 	/* Transfer size per frame, in WORD ! */
 	d = cam->hw_depth;
 	w = cam->hw_width;
 	h = cam->hw_height;
 	t_size = (w*h*d)/16;
 	err = w9968cf_write_reg(cam, 0xbf17, 0x00); /* reset everything */
 	err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* normal operation */
 	/* Transfer size */
 	err += w9968cf_write_reg(cam, t_size & 0xffff, 0x3d); /* low bits */
 	err += w9968cf_write_reg(cam, t_size >> 16, 0x3e);    /* high bits */
 	if (cam->vpp_flag & VPP_DECOMPRESSION)
 		err += w9968cf_upload_quantizationtables(cam);
 	vidcapt = w9968cf_read_reg(cam, 0x16); /* read picture settings */
 	err += w9968cf_write_reg(cam, vidcapt|0x8000, 0x16); /* capt. enable */
 	err += usb_set_interface(udev, 0, cam->altsetting);
 	err += w9968cf_write_reg(cam, 0x8a05, 0x3c); /* USB FIFO enable */
 	if (err || (vidcapt < 0)) {
 		for (i = 0; i < W9968CF_URBS; i++)
 			usb_free_urb(cam->urb[i]);
 		DBG(1, "Couldn't tell the camera to start the data transfer")
 		return err;
 	}
 	w9968cf_init_framelist(cam);
 	/* Begin to grab into the temporary buffer */
 	cam->frame_tmp.status = F_UNUSED;
 	cam->frame_tmp.queued = 0;
 	cam->frame_current = &cam->frame_tmp;
 	if (!(cam->vpp_flag & VPP_DECOMPRESSION))
 		DBG(5, "Isochronous transfer size: %lu bytes/frame",
 		    (unsigned long)t_size*2)
 	DBG(5, "Starting the isochronous transfer...")
 	cam->streaming = 1;
 	/* Submit the URBs */
 	for (i = 0; i < W9968CF_URBS; i++) {
 		err = usb_submit_urb(cam->urb[i], GFP_KERNEL);
 		if (err) {
 			cam->streaming = 0;
 			for (j = i-1; j >= 0; j--) {
 				usb_kill_urb(cam->urb[j]);
 				usb_free_urb(cam->urb[j]);
 			}
 			DBG(1, "Couldn't send a transfer request to the "
 			       "USB core (error #%d, %s)", err,
 			    symbolic(urb_errlist, err))
 			return err;
 		}
 	}
 	return 0;
 }
 /*--------------------------------------------------------------------------
   Stop the isochronous transfer and set alternate setting to 0 (0Mb/s).
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_stop_transfer(struct w9968cf_device* cam)
 {
 	struct usb_device *udev = cam->usbdev;
 	unsigned long lock_flags;
 	int err = 0;
 	s8 i;
 	if (!cam->streaming)
 		return 0;
 	/* This avoids race conditions with usb_submit_urb()
 	   in the URB completition handler */
 	spin_lock_irqsave(&cam->urb_lock, lock_flags);
 	cam->streaming = 0;
 	spin_unlock_irqrestore(&cam->urb_lock, lock_flags);
 	for (i = W9968CF_URBS-1; i >= 0; i--)
 		if (cam->urb[i]) {
 			usb_kill_urb(cam->urb[i]);
 			usb_free_urb(cam->urb[i]);
 			cam->urb[i] = NULL;
 		}
 	if (cam->disconnected)
 		goto exit;
 	err = w9968cf_write_reg(cam, 0x0a05, 0x3c); /* stop USB transfer */
 	err += usb_set_interface(udev, 0, 0); /* 0 Mb/s */
 	err += w9968cf_write_reg(cam, 0x0000, 0x39); /* disable JPEG encoder */
 	err += w9968cf_write_reg(cam, 0x0000, 0x16); /* stop video capture */
 	if (err) {
 		DBG(2, "Failed to tell the camera to stop the isochronous "
 		       "transfer. However this is not a critical error.")
 		return -EIO;
 	}
 exit:
 	DBG(5, "Isochronous transfer stopped")
 	return 0;
 }
 /*--------------------------------------------------------------------------
   Write a W9968CF register.
   Return 0 on success, -1 otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_write_reg(struct w9968cf_device* cam, u16 value, u16 index)
 {
 	struct usb_device* udev = cam->usbdev;
 	int res;
 	res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0,
 			      USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
 			      value, index, NULL, 0, W9968CF_USB_CTRL_TIMEOUT);
 	if (res < 0)
 		DBG(4, "Failed to write a register "
 		       "(value 0x%04X, index 0x%02X, error #%d, %s)",
 		    value, index, res, symbolic(urb_errlist, res))
 	return (res >= 0) ? 0 : -1;
 }
 /*--------------------------------------------------------------------------
   Read a W9968CF register.
   Return the register value on success, -1 otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_read_reg(struct w9968cf_device* cam, u16 index)
 {
 	struct usb_device* udev = cam->usbdev;
 	u16* buff = cam->control_buffer;
 	int res;
 	res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 1,
 			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 			      0, index, buff, 2, W9968CF_USB_CTRL_TIMEOUT);
 	if (res < 0)
 		DBG(4, "Failed to read a register "
 		       "(index 0x%02X, error #%d, %s)",
 		    index, res, symbolic(urb_errlist, res))
 	return (res >= 0) ? (int)(*buff) : -1;
 }
 /*--------------------------------------------------------------------------
   Write 64-bit data to the fast serial bus registers.
   Return 0 on success, -1 otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_write_fsb(struct w9968cf_device* cam, u16* data)
 {
 	struct usb_device* udev = cam->usbdev;
 	u16 value;
 	int res;
 	value = *data++;
 	res = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0,
 			      USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
 			      value, 0x06, data, 6, W9968CF_USB_CTRL_TIMEOUT);
 	if (res < 0)
 		DBG(4, "Failed to write the FSB registers "
 		       "(error #%d, %s)", res, symbolic(urb_errlist, res))
 	return (res >= 0) ? 0 : -1;
 }
 /*--------------------------------------------------------------------------
   Write data to the serial bus control register.
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_write_sb(struct w9968cf_device* cam, u16 value)
 {
 	int err = 0;
 	err = w9968cf_write_reg(cam, value, 0x01);
 	udelay(W9968CF_I2C_BUS_DELAY);
 	return err;
 }
 /*--------------------------------------------------------------------------
   Read data from the serial bus control register.
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_read_sb(struct w9968cf_device* cam)
 {
 	int v = 0;
 	v = w9968cf_read_reg(cam, 0x01);
 	udelay(W9968CF_I2C_BUS_DELAY);
 	return v;
 }
 /*--------------------------------------------------------------------------
   Upload quantization tables for the JPEG compression.
   This function is called by w9968cf_start_transfer().
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_upload_quantizationtables(struct w9968cf_device* cam)
 {
 	u16 a, b;
 	int err = 0, i, j;
 	err += w9968cf_write_reg(cam, 0x0010, 0x39); /* JPEG clock enable */
 	for (i = 0, j = 0; i < 32; i++, j += 2) {
 		a = Y_QUANTABLE[j] | ((unsigned)(Y_QUANTABLE[j+1]) << 8);
 		b = UV_QUANTABLE[j] | ((unsigned)(UV_QUANTABLE[j+1]) << 8);
 		err += w9968cf_write_reg(cam, a, 0x40+i);
 		err += w9968cf_write_reg(cam, b, 0x60+i);
 	}
 	err += w9968cf_write_reg(cam, 0x0012, 0x39); /* JPEG encoder enable */
 	return err;
 }
 /****************************************************************************
  * Low-level I2C I/O functions.                                             *
  * The adapter supports the following I2C transfer functions:               *
  * i2c_adap_fastwrite_byte_data() (at 400 kHz bit frequency only)           *
  * i2c_adap_read_byte_data()                                                *
  * i2c_adap_read_byte()                                                     *
  ****************************************************************************/
 static int w9968cf_smbus_start(struct w9968cf_device* cam)
 {
 	int err = 0;
 	err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
 	err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
 	return err;
 }
 static int w9968cf_smbus_stop(struct w9968cf_device* cam)
 {
 	int err = 0;
 	err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
 	err += w9968cf_write_sb(cam, 0x0013); /* SDE=1, SDA=1, SCL=1 */
 	return err;
 }
 static int w9968cf_smbus_write_byte(struct w9968cf_device* cam, u8 v)
 {
 	u8 bit;
 	int err = 0, sda;
 	for (bit = 0 ; bit < 8 ; bit++) {
 		sda = (v & 0x80) ? 2 : 0;
 		v <<= 1;
 		/* SDE=1, SDA=sda, SCL=0 */
 		err += w9968cf_write_sb(cam, 0x10 | sda);
 		/* SDE=1, SDA=sda, SCL=1 */
 		err += w9968cf_write_sb(cam, 0x11 | sda);
 		/* SDE=1, SDA=sda, SCL=0 */
 		err += w9968cf_write_sb(cam, 0x10 | sda);
 	}
 	return err;
 }
 static int w9968cf_smbus_read_byte(struct w9968cf_device* cam, u8* v)
 {
 	u8 bit;
 	int err = 0;
 	*v = 0;
 	for (bit = 0 ; bit < 8 ; bit++) {
 		*v <<= 1;
 		err += w9968cf_write_sb(cam, 0x0013);
 		*v |= (w9968cf_read_sb(cam) & 0x0008) ? 1 : 0;
 		err += w9968cf_write_sb(cam, 0x0012);
 	}
 	return err;
 }
 static int w9968cf_smbus_write_ack(struct w9968cf_device* cam)
 {
 	int err = 0;
 	err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
 	err += w9968cf_write_sb(cam, 0x0011); /* SDE=1, SDA=0, SCL=1 */
 	err += w9968cf_write_sb(cam, 0x0010); /* SDE=1, SDA=0, SCL=0 */
 	return err;
 }
 static int w9968cf_smbus_read_ack(struct w9968cf_device* cam)
 {
 	int err = 0, sda;
 	err += w9968cf_write_sb(cam, 0x0013); /* SDE=1, SDA=1, SCL=1 */
 	sda = (w9968cf_read_sb(cam) & 0x08) ? 1 : 0; /* sda = SDA */
 	err += w9968cf_write_sb(cam, 0x0012); /* SDE=1, SDA=1, SCL=0 */
 	if (sda < 0)
 		err += sda;
 	if (sda == 1) {
 		DBG(6, "Couldn't receive the ACK")
 		err += -1;
 	}
 	return err;
 }
 /* This seems to refresh the communication through the serial bus */
 static int w9968cf_smbus_refresh_bus(struct w9968cf_device* cam)
 {
 	int err = 0, j;
 	for (j = 1; j <= 10; j++) {
 		err = w9968cf_write_reg(cam, 0x0020, 0x01);
 		err += w9968cf_write_reg(cam, 0x0000, 0x01);
 		if (err)
 			break;
 	}
 	return err;
 }
 /* SMBus protocol: S Addr Wr [A] Subaddr [A] Value [A] P */
 static int
 w9968cf_i2c_adap_fastwrite_byte_data(struct w9968cf_device* cam,
 				     u16 address, u8 subaddress,u8 value)
 {
 	u16* data = cam->data_buffer;
 	int err = 0;
 	err += w9968cf_smbus_refresh_bus(cam);
 	/* Enable SBUS outputs */
 	err += w9968cf_write_sb(cam, 0x0020);
 	data[0] = 0x082f | ((address & 0x80) ? 0x1500 : 0x0);
 	data[0] |= (address & 0x40) ? 0x4000 : 0x0;
 	data[1] = 0x2082 | ((address & 0x40) ? 0x0005 : 0x0);
 	data[1] |= (address & 0x20) ? 0x0150 : 0x0;
 	data[1] |= (address & 0x10) ? 0x5400 : 0x0;
 	data[2] = 0x8208 | ((address & 0x08) ? 0x0015 : 0x0);
 	data[2] |= (address & 0x04) ? 0x0540 : 0x0;
 	data[2] |= (address & 0x02) ? 0x5000 : 0x0;
 	data[3] = 0x1d20 | ((address & 0x02) ? 0x0001 : 0x0);
 	data[3] |= (address & 0x01) ? 0x0054 : 0x0;
 	err += w9968cf_write_fsb(cam, data);
 	data[0] = 0x8208 | ((subaddress & 0x80) ? 0x0015 : 0x0);
 	data[0] |= (subaddress & 0x40) ? 0x0540 : 0x0;
 	data[0] |= (subaddress & 0x20) ? 0x5000 : 0x0;
 	data[1] = 0x0820 | ((subaddress & 0x20) ? 0x0001 : 0x0);
 	data[1] |= (subaddress & 0x10) ? 0x0054 : 0x0;
 	data[1] |= (subaddress & 0x08) ? 0x1500 : 0x0;
 	data[1] |= (subaddress & 0x04) ? 0x4000 : 0x0;
 	data[2] = 0x2082 | ((subaddress & 0x04) ? 0x0005 : 0x0);
 	data[2] |= (subaddress & 0x02) ? 0x0150 : 0x0;
 	data[2] |= (subaddress & 0x01) ? 0x5400 : 0x0;
 	data[3] = 0x001d;
 	err += w9968cf_write_fsb(cam, data);
 	data[0] = 0x8208 | ((value & 0x80) ? 0x0015 : 0x0);
 	data[0] |= (value & 0x40) ? 0x0540 : 0x0;
 	data[0] |= (value & 0x20) ? 0x5000 : 0x0;
 	data[1] = 0x0820 | ((value & 0x20) ? 0x0001 : 0x0);
 	data[1] |= (value & 0x10) ? 0x0054 : 0x0;
 	data[1] |= (value & 0x08) ? 0x1500 : 0x0;
 	data[1] |= (value & 0x04) ? 0x4000 : 0x0;
 	data[2] = 0x2082 | ((value & 0x04) ? 0x0005 : 0x0);
 	data[2] |= (value & 0x02) ? 0x0150 : 0x0;
 	data[2] |= (value & 0x01) ? 0x5400 : 0x0;
 	data[3] = 0xfe1d;
 	err += w9968cf_write_fsb(cam, data);
 	/* Disable SBUS outputs */
 	err += w9968cf_write_sb(cam, 0x0000);
 	if (!err)
 		DBG(5, "I2C write byte data done, addr.0x%04X, subaddr.0x%02X "
 		       "value 0x%02X", address, subaddress, value)
 	else
 		DBG(5, "I2C write byte data failed, addr.0x%04X, "
 		       "subaddr.0x%02X, value 0x%02X",
 		    address, subaddress, value)
 	return err;
 }
 /* SMBus protocol: S Addr Wr [A] Subaddr [A] P S Addr+1 Rd [A] [Value] NA P */
 static int
 w9968cf_i2c_adap_read_byte_data(struct w9968cf_device* cam,
 				u16 address, u8 subaddress,
 				u8* value)
 {
 	int err = 0;
 	/* Serial data enable */
 	err += w9968cf_write_sb(cam, 0x0013); /* don't change ! */
 	err += w9968cf_smbus_start(cam);
 	err += w9968cf_smbus_write_byte(cam, address);
 	err += w9968cf_smbus_read_ack(cam);
 	err += w9968cf_smbus_write_byte(cam, subaddress);
 	err += w9968cf_smbus_read_ack(cam);
 	err += w9968cf_smbus_stop(cam);
 	err += w9968cf_smbus_start(cam);
 	err += w9968cf_smbus_write_byte(cam, address + 1);
 	err += w9968cf_smbus_read_ack(cam);
 	err += w9968cf_smbus_read_byte(cam, value);
 	err += w9968cf_smbus_write_ack(cam);
 	err += w9968cf_smbus_stop(cam);
 	/* Serial data disable */
 	err += w9968cf_write_sb(cam, 0x0000);
 	if (!err)
 		DBG(5, "I2C read byte data done, addr.0x%04X, "
 		       "subaddr.0x%02X, value 0x%02X",
 		    address, subaddress, *value)
 	else
 		DBG(5, "I2C read byte data failed, addr.0x%04X, "
 		       "subaddr.0x%02X, wrong value 0x%02X",
 		    address, subaddress, *value)
 	return err;
 }
 /* SMBus protocol: S Addr+1 Rd [A] [Value] NA P */
 static int
 w9968cf_i2c_adap_read_byte(struct w9968cf_device* cam,
 			   u16 address, u8* value)
 {
 	int err = 0;
 	/* Serial data enable */
 	err += w9968cf_write_sb(cam, 0x0013);
 	err += w9968cf_smbus_start(cam);
 	err += w9968cf_smbus_write_byte(cam, address + 1);
 	err += w9968cf_smbus_read_ack(cam);
 	err += w9968cf_smbus_read_byte(cam, value);
 	err += w9968cf_smbus_write_ack(cam);
 	err += w9968cf_smbus_stop(cam);
 	/* Serial data disable */
 	err += w9968cf_write_sb(cam, 0x0000);
 	if (!err)
 		DBG(5, "I2C read byte done, addr.0x%04X, "
 		       "value 0x%02X", address, *value)
 	else
 		DBG(5, "I2C read byte failed, addr.0x%04X, "
 		       "wrong value 0x%02X", address, *value)
 	return err;
 }
 /* SMBus protocol: S Addr Wr [A] Value [A] P */
 static int
 w9968cf_i2c_adap_write_byte(struct w9968cf_device* cam,
 			    u16 address, u8 value)
 {
 	DBG(4, "i2c_write_byte() is an unsupported transfer mode")
 	return -EINVAL;
 }
 /****************************************************************************
  * I2C interface to kernel                                                  *
  ****************************************************************************/
 static int
 w9968cf_i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 		       unsigned short flags, char read_write, u8 command,
 		       int size, union i2c_smbus_data *data)
 {
 	struct v4l2_device *v4l2_dev = i2c_get_adapdata(adapter);
 	struct w9968cf_device *cam = to_cam(v4l2_dev);
 	u8 i;
 	int err = 0;
 	if (size == I2C_SMBUS_BYTE) {
 		/* Why addr <<= 1? See OVXXX0_SID defines in ovcamchip.h */
 		addr <<= 1;
 		if (read_write == I2C_SMBUS_WRITE)
 			err = w9968cf_i2c_adap_write_byte(cam, addr, command);
 		else if (read_write == I2C_SMBUS_READ)
 			for (i = 1; i <= W9968CF_I2C_RW_RETRIES; i++) {
 				err = w9968cf_i2c_adap_read_byte(cam, addr,
 							 &data->byte);
 				if (err) {
 					if (w9968cf_smbus_refresh_bus(cam)) {
 						err = -EIO;
 						break;
 					}
 				} else
 					break;
 			}
 	} else if (size == I2C_SMBUS_BYTE_DATA) {
 		addr <<= 1;
 		if (read_write == I2C_SMBUS_WRITE)
 			err = w9968cf_i2c_adap_fastwrite_byte_data(cam, addr,
 							  command, data->byte);
 		else if (read_write == I2C_SMBUS_READ) {
 			for (i = 1; i <= W9968CF_I2C_RW_RETRIES; i++) {
 				err = w9968cf_i2c_adap_read_byte_data(cam,addr,
 							 command, &data->byte);
 				if (err) {
 					if (w9968cf_smbus_refresh_bus(cam)) {
 						err = -EIO;
 						break;
 					}
 				} else
 					break;
 			}
 		} else
 			return -EINVAL;
 	} else {
 		DBG(4, "Unsupported I2C transfer mode (%d)", size)
 		return -EINVAL;
 	}
 	return err;
 }
 static u32 w9968cf_i2c_func(struct i2c_adapter* adap)
 {
 	return I2C_FUNC_SMBUS_READ_BYTE |
 	       I2C_FUNC_SMBUS_READ_BYTE_DATA  |
 	       I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
 }
 static int w9968cf_i2c_init(struct w9968cf_device* cam)
 {
 	int err = 0;
 	static struct i2c_algorithm algo = {
 		.smbus_xfer =    w9968cf_i2c_smbus_xfer,
 		.functionality = w9968cf_i2c_func,
 	};
 	static struct i2c_adapter adap = {
 		.id =                I2C_HW_SMBUS_W9968CF,
 		.owner =             THIS_MODULE,
 		.algo =              &algo,
 	};
 	memcpy(&cam->i2c_adapter, &adap, sizeof(struct i2c_adapter));
 	strcpy(cam->i2c_adapter.name, "w9968cf");
 	cam->i2c_adapter.dev.parent = &cam->usbdev->dev;
 	i2c_set_adapdata(&cam->i2c_adapter, &cam->v4l2_dev);
 	DBG(6, "Registering I2C adapter with kernel...")
 	err = i2c_add_adapter(&cam->i2c_adapter);
 	if (err)
 		DBG(1, "Failed to register the I2C adapter")
 	else
 		DBG(5, "I2C adapter registered")
 	return err;
 }
 /****************************************************************************
  * Helper functions                                                         *
  ****************************************************************************/
 /*--------------------------------------------------------------------------
   Turn on the LED on some webcams. A beep should be heard too.
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_turn_on_led(struct w9968cf_device* cam)
 {
 	int err = 0;
 	err += w9968cf_write_reg(cam, 0xff00, 0x00); /* power-down */
 	err += w9968cf_write_reg(cam, 0xbf17, 0x00); /* reset everything */
 	err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* normal operation */
 	err += w9968cf_write_reg(cam, 0x0010, 0x01); /* serial bus, SDS high */
 	err += w9968cf_write_reg(cam, 0x0000, 0x01); /* serial bus, SDS low */
 	err += w9968cf_write_reg(cam, 0x0010, 0x01); /* ..high 'beep-beep' */
 	if (err)
 		DBG(2, "Couldn't turn on the LED")
 	DBG(5, "LED turned on")
 	return err;
 }
 /*--------------------------------------------------------------------------
   Write some registers for the device initialization.
   This function is called once on open().
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_init_chip(struct w9968cf_device* cam)
 {
 	unsigned long hw_bufsize = cam->maxwidth*cam->maxheight*2,
 		      y0 = 0x0000,
 		      u0 = y0 + hw_bufsize/2,
 		      v0 = u0 + hw_bufsize/4,
 		      y1 = v0 + hw_bufsize/4,
 		      u1 = y1 + hw_bufsize/2,
 		      v1 = u1 + hw_bufsize/4;
 	int err = 0;
 	err += w9968cf_write_reg(cam, 0xff00, 0x00); /* power off */
 	err += w9968cf_write_reg(cam, 0xbf10, 0x00); /* power on */
 	err += w9968cf_write_reg(cam, 0x405d, 0x03); /* DRAM timings */
 	err += w9968cf_write_reg(cam, 0x0030, 0x04); /* SDRAM timings */
 	err += w9968cf_write_reg(cam, y0 & 0xffff, 0x20); /* Y buf.0, low */
 	err += w9968cf_write_reg(cam, y0 >> 16, 0x21);    /* Y buf.0, high */
 	err += w9968cf_write_reg(cam, u0 & 0xffff, 0x24); /* U buf.0, low */
 	err += w9968cf_write_reg(cam, u0 >> 16, 0x25);    /* U buf.0, high */
 	err += w9968cf_write_reg(cam, v0 & 0xffff, 0x28); /* V buf.0, low */
 	err += w9968cf_write_reg(cam, v0 >> 16, 0x29);    /* V buf.0, high */
 	err += w9968cf_write_reg(cam, y1 & 0xffff, 0x22); /* Y buf.1, low */
 	err += w9968cf_write_reg(cam, y1 >> 16, 0x23);    /* Y buf.1, high */
 	err += w9968cf_write_reg(cam, u1 & 0xffff, 0x26); /* U buf.1, low */
 	err += w9968cf_write_reg(cam, u1 >> 16, 0x27);    /* U buf.1, high */
 	err += w9968cf_write_reg(cam, v1 & 0xffff, 0x2a); /* V buf.1, low */
 	err += w9968cf_write_reg(cam, v1 >> 16, 0x2b);    /* V buf.1, high */
 	err += w9968cf_write_reg(cam, y1 & 0xffff, 0x32); /* JPEG buf 0 low */
 	err += w9968cf_write_reg(cam, y1 >> 16, 0x33);    /* JPEG buf 0 high */
 	err += w9968cf_write_reg(cam, y1 & 0xffff, 0x34); /* JPEG buf 1 low */
 	err += w9968cf_write_reg(cam, y1 >> 16, 0x35);    /* JPEG bug 1 high */
 	err += w9968cf_write_reg(cam, 0x0000, 0x36);/* JPEG restart interval */
 	err += w9968cf_write_reg(cam, 0x0804, 0x37);/*JPEG VLE FIFO threshold*/
 	err += w9968cf_write_reg(cam, 0x0000, 0x38);/* disable hw up-scaling */
 	err += w9968cf_write_reg(cam, 0x0000, 0x3f); /* JPEG/MCTL test data */
 	err += w9968cf_set_picture(cam, cam->picture); /* this before */
 	err += w9968cf_set_window(cam, cam->window);
 	if (err)
 		DBG(1, "Chip initialization failed")
 	else
 		DBG(5, "Chip successfully initialized")
 	return err;
 }
 /*--------------------------------------------------------------------------
   Return non-zero if the palette is supported, 0 otherwise.
   --------------------------------------------------------------------------*/
 static inline u16 w9968cf_valid_palette(u16 palette)
 {
 	u8 i = 0;
 	while (w9968cf_formatlist[i].palette != 0) {
 		if (palette == w9968cf_formatlist[i].palette)
 			return palette;
 		i++;
 	}
 	return 0;
 }
 /*--------------------------------------------------------------------------
   Return the depth corresponding to the given palette.
   Palette _must_ be supported !
   --------------------------------------------------------------------------*/
 static inline u16 w9968cf_valid_depth(u16 palette)
 {
 	u8 i=0;
 	while (w9968cf_formatlist[i].palette != palette)
 		i++;
 	return w9968cf_formatlist[i].depth;
 }
 /*--------------------------------------------------------------------------
   Return non-zero if the format requires decompression, 0 otherwise.
   --------------------------------------------------------------------------*/
 static inline u8 w9968cf_need_decompression(u16 palette)
 {
 	u8 i = 0;
 	while (w9968cf_formatlist[i].palette != 0) {
 		if (palette == w9968cf_formatlist[i].palette)
 			return w9968cf_formatlist[i].compression;
 		i++;
 	}
 	return 0;
 }
 /*--------------------------------------------------------------------------
   Change the picture settings of the camera.
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int
 w9968cf_set_picture(struct w9968cf_device* cam, struct video_picture pict)
 {
 	u16 fmt, hw_depth, hw_palette, reg_v = 0x0000;
 	int err = 0;
 	/* Make sure we are using a valid depth */
 	pict.depth = w9968cf_valid_depth(pict.palette);
 	fmt = pict.palette;
 	hw_depth = pict.depth; /* depth used by the winbond chip */
 	hw_palette = pict.palette; /* palette used by the winbond chip */
 	/* VS & HS polarities */
 	reg_v = (cam->vs_polarity << 12) | (cam->hs_polarity << 11);
 	switch (fmt)
 	{
 		case VIDEO_PALETTE_UYVY:
 			reg_v |= 0x0000;
 			cam->vpp_flag = VPP_NONE;
 			break;
 		case VIDEO_PALETTE_YUV422P:
 			reg_v |= 0x0002;
 			cam->vpp_flag = VPP_DECOMPRESSION;
 			break;
 		case VIDEO_PALETTE_YUV420:
 		case VIDEO_PALETTE_YUV420P:
 			reg_v |= 0x0003;
 			cam->vpp_flag = VPP_DECOMPRESSION;
 			break;
 		case VIDEO_PALETTE_YUYV:
 		case VIDEO_PALETTE_YUV422:
 			reg_v |= 0x0000;
 			cam->vpp_flag = VPP_SWAP_YUV_BYTES;
 			hw_palette = VIDEO_PALETTE_UYVY;
 			break;
 		/* Original video is used instead of RGBX palettes.
 		   Software conversion later. */
 		case VIDEO_PALETTE_GREY:
 		case VIDEO_PALETTE_RGB555:
 		case VIDEO_PALETTE_RGB565:
 		case VIDEO_PALETTE_RGB24:
 		case VIDEO_PALETTE_RGB32:
 			reg_v |= 0x0000; /* UYVY 16 bit is used */
 			hw_depth = 16;
 			hw_palette = VIDEO_PALETTE_UYVY;
 			cam->vpp_flag = VPP_UYVY_TO_RGBX;
 			break;
 	}
 	/* NOTE: due to memory issues, it is better to disable the hardware
 		 double buffering during compression */
 	if (cam->double_buffer && !(cam->vpp_flag & VPP_DECOMPRESSION))
 		reg_v |= 0x0080;
 	if (cam->clamping)
 		reg_v |= 0x0020;
 	if (cam->filter_type == 1)
 		reg_v |= 0x0008;
 	else if (cam->filter_type == 2)
 		reg_v |= 0x000c;
 	if ((err = w9968cf_write_reg(cam, reg_v, 0x16)))
 		goto error;
 	if ((err = w9968cf_sensor_update_picture(cam, pict)))
 		goto error;
 	/* If all went well, update the device data structure */
 	memcpy(&cam->picture, &pict, sizeof(pict));
 	cam->hw_depth = hw_depth;
 	cam->hw_palette = hw_palette;
 	/* Settings changed, so we clear the frame buffers */
 	memset(cam->frame[0].buffer, 0, cam->nbuffers*cam->frame[0].size);
 	DBG(4, "Palette is %s, depth is %u bpp",
 	    symbolic(v4l1_plist, pict.palette), pict.depth)
 	return 0;
 error:
 	DBG(1, "Failed to change picture settings")
 	return err;
 }
 /*--------------------------------------------------------------------------
   Change the capture area size of the camera.
   This function _must_ be called _after_ w9968cf_set_picture().
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int
 w9968cf_set_window(struct w9968cf_device* cam, struct video_window win)
 {
 	u16 x, y, w, h, scx, scy, cw, ch, ax, ay;
 	unsigned long fw, fh;
 	struct ovcamchip_window s_win;
 	int err = 0;
 	/* Work around to avoid FP arithmetics */
 	#define SC(x) ((x) << 10)
 	#define UNSC(x) ((x) >> 10)
 	/* Make sure we are using a supported resolution */
 	if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
 					      (u16*)&win.height)))
 		goto error;
 	/* Scaling factors */
 	fw = SC(win.width) / cam->maxwidth;
 	fh = SC(win.height) / cam->maxheight;
 	/* Set up the width and height values used by the chip */
 	if ((win.width > cam->maxwidth) || (win.height > cam->maxheight)) {
 		cam->vpp_flag |= VPP_UPSCALE;
 		/* Calculate largest w,h mantaining the same w/h ratio */
 		w = (fw >= fh) ? cam->maxwidth : SC(win.width)/fh;
 		h = (fw >= fh) ? SC(win.height)/fw : cam->maxheight;
 		if (w < cam->minwidth) /* just in case */
 			w = cam->minwidth;
 		if (h < cam->minheight) /* just in case */
 			h = cam->minheight;
 	} else {
 		cam->vpp_flag &= ~VPP_UPSCALE;
 		w = win.width;
 		h = win.height;
 	}
 	/* x,y offsets of the cropped area */
 	scx = cam->start_cropx;
 	scy = cam->start_cropy;
 	/* Calculate cropped area manteining the right w/h ratio */
 	if (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE)) {
 		cw = (fw >= fh) ? cam->maxwidth : SC(win.width)/fh;
 		ch = (fw >= fh) ? SC(win.height)/fw : cam->maxheight;
 	} else {
 		cw = w;
 		ch = h;
 	}
 	/* Setup the window of the sensor */
 	s_win.format = VIDEO_PALETTE_UYVY;
 	s_win.width = cam->maxwidth;
 	s_win.height = cam->maxheight;
 	s_win.quarter = 0; /* full progressive video */
 	/* Center it */
 	s_win.x = (s_win.width - cw) / 2;
 	s_win.y = (s_win.height - ch) / 2;
 	/* Clock divisor */
 	if (cam->clockdiv >= 0)
 		s_win.clockdiv = cam->clockdiv; /* manual override */
 	else
 		switch (cam->sensor) {
 			case CC_OV6620:
 				s_win.clockdiv = 0;
 				break;
 			case CC_OV6630:
 				s_win.clockdiv = 0;
 				break;
 			case CC_OV76BE:
 			case CC_OV7610:
 			case CC_OV7620:
 				s_win.clockdiv = 0;
 				break;
 			default:
 				s_win.clockdiv = W9968CF_DEF_CLOCKDIVISOR;
 		}
 	/* We have to scale win.x and win.y offsets */
 	if ( (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE))
 	     || (cam->vpp_flag & VPP_UPSCALE) ) {
 		ax = SC(win.x)/fw;
 		ay = SC(win.y)/fh;
 	} else {
 		ax = win.x;
 		ay = win.y;
 	}
 	if ((ax + cw) > cam->maxwidth)
 		ax = cam->maxwidth - cw;
 	if ((ay + ch) > cam->maxheight)
 		ay = cam->maxheight - ch;
 	/* Adjust win.x, win.y */
 	if ( (cam->largeview && !(cam->vpp_flag & VPP_UPSCALE))
 	     || (cam->vpp_flag & VPP_UPSCALE) ) {
 		win.x = UNSC(ax*fw);
 		win.y = UNSC(ay*fh);
 	} else {
 		win.x = ax;
 		win.y = ay;
 	}
 	/* Offsets used by the chip */
 	x = ax + s_win.x;
 	y = ay + s_win.y;
 	/* Go ! */
 	if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_S_MODE, &s_win)))
 		goto error;
 	err += w9968cf_write_reg(cam, scx + x, 0x10);
 	err += w9968cf_write_reg(cam, scy + y, 0x11);
 	err += w9968cf_write_reg(cam, scx + x + cw, 0x12);
 	err += w9968cf_write_reg(cam, scy + y + ch, 0x13);
 	err += w9968cf_write_reg(cam, w, 0x14);
 	err += w9968cf_write_reg(cam, h, 0x15);
 	/* JPEG width & height */
 	err += w9968cf_write_reg(cam, w, 0x30);
 	err += w9968cf_write_reg(cam, h, 0x31);
 	/* Y & UV frame buffer strides (in WORD) */
 	if (cam->vpp_flag & VPP_DECOMPRESSION) {
 		err += w9968cf_write_reg(cam, w/2, 0x2c);
 		err += w9968cf_write_reg(cam, w/4, 0x2d);
 	} else
 		err += w9968cf_write_reg(cam, w, 0x2c);
 	if (err)
 		goto error;
 	/* If all went well, update the device data structure */
 	memcpy(&cam->window, &win, sizeof(win));
 	cam->hw_width = w;
 	cam->hw_height = h;
 	/* Settings changed, so we clear the frame buffers */
 	memset(cam->frame[0].buffer, 0, cam->nbuffers*cam->frame[0].size);
 	DBG(4, "The capture area is %dx%d, Offset (x,y)=(%u,%u)",
 	    win.width, win.height, win.x, win.y)
 	PDBGG("x=%u ,y=%u, w=%u, h=%u, ax=%u, ay=%u, s_win.x=%u, s_win.y=%u, "
 	      "cw=%u, ch=%u, win.x=%u, win.y=%u, win.width=%u, win.height=%u",
 	      x, y, w, h, ax, ay, s_win.x, s_win.y, cw, ch, win.x, win.y,
 	      win.width, win.height)
 	return 0;
 error:
 	DBG(1, "Failed to change the capture area size")
 	return err;
 }
 /*--------------------------------------------------------------------------
   Adjust the asked values for window width and height.
   Return 0 on success, -1 otherwise.
   --------------------------------------------------------------------------*/
 static int
 w9968cf_adjust_window_size(struct w9968cf_device* cam, u16* width, u16* height)
 {
 	u16 maxw, maxh;
 	if ((*width < cam->minwidth) || (*height < cam->minheight))
 		return -ERANGE;
 	maxw = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
 	       w9968cf_vpp ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
 			   : cam->maxwidth;
 	maxh = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
 	       w9968cf_vpp ? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
 			   : cam->maxheight;
 	if (*width > maxw)
 		*width = maxw;
 	if (*height > maxh)
 		*height = maxh;
 	if (cam->vpp_flag & VPP_DECOMPRESSION) {
 		*width  &= ~15L; /* multiple of 16 */
 		*height &= ~15L;
 	}
 	PDBGG("Window size adjusted w=%u, h=%u ", *width, *height)
 	return 0;
 }
 /*--------------------------------------------------------------------------
   Initialize the FIFO list of requested frames.
   --------------------------------------------------------------------------*/
 static void w9968cf_init_framelist(struct w9968cf_device* cam)
 {
 	u8 i;
 	for (i = 0; i < cam->nbuffers; i++) {
 		cam->requested_frame[i] = NULL;
 		cam->frame[i].queued = 0;
 		cam->frame[i].status = F_UNUSED;
 	}
 }
 /*--------------------------------------------------------------------------
   Add a frame in the FIFO list of requested frames.
   This function is called in process context.
   --------------------------------------------------------------------------*/
 static void w9968cf_push_frame(struct w9968cf_device* cam, u8 f_num)
 {
 	u8 f;
 	unsigned long lock_flags;
 	spin_lock_irqsave(&cam->flist_lock, lock_flags);
 	for (f=0; cam->requested_frame[f] != NULL; f++);
 	cam->requested_frame[f] = &cam->frame[f_num];
 	cam->frame[f_num].queued = 1;
 	cam->frame[f_num].status = F_UNUSED; /* clear the status */
 	spin_unlock_irqrestore(&cam->flist_lock, lock_flags);
 	DBG(6, "Frame #%u pushed into the FIFO list. Position %u", f_num, f)
 }
 /*--------------------------------------------------------------------------
   Read, store and remove the first pointer in the FIFO list of requested
   frames. This function is called in interrupt context.
   --------------------------------------------------------------------------*/
 static void
 w9968cf_pop_frame(struct w9968cf_device* cam, struct w9968cf_frame_t** framep)
 {
 	u8 i;
 	spin_lock(&cam->flist_lock);
 	*framep = cam->requested_frame[0];
 	/* Shift the list of pointers */
 	for (i = 0; i < cam->nbuffers-1; i++)
 		cam->requested_frame[i] = cam->requested_frame[i+1];
 	cam->requested_frame[i] = NULL;
 	spin_unlock(&cam->flist_lock);
 	DBG(6,"Popped frame #%d from the list", (*framep)->number)
 }
 /*--------------------------------------------------------------------------
   High-level video post-processing routine on grabbed frames.
   Return 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int
 w9968cf_postprocess_frame(struct w9968cf_device* cam,
 			  struct w9968cf_frame_t* fr)
 {
 	void *pIn = fr->buffer, *pOut = cam->frame_vpp.buffer, *tmp;
 	u16 w = cam->window.width,
 	    h = cam->window.height,
 	    d = cam->picture.depth,
 	    fmt = cam->picture.palette,
 	    rgb = cam->force_rgb,
 	    hw_w = cam->hw_width,
 	    hw_h = cam->hw_height,
 	    hw_d = cam->hw_depth;
 	int err = 0;
 	#define _PSWAP(pIn, pOut) {tmp = (pIn); (pIn) = (pOut); (pOut) = tmp;}
 	if (cam->vpp_flag & VPP_DECOMPRESSION) {
 		memcpy(pOut, pIn, fr->length);
 		_PSWAP(pIn, pOut)
 		err = w9968cf_vpp->decode(pIn, fr->length, hw_w, hw_h, pOut);
 		PDBGG("Compressed frame length: %lu",(unsigned long)fr->length)
 		fr->length = (hw_w*hw_h*hw_d)/8;
 		_PSWAP(pIn, pOut)
 		if (err) {
 			DBG(4, "An error occurred while decoding the frame: "
 			       "%s", symbolic(decoder_errlist, err))
 			return err;
 		} else
 			DBG(6, "Frame decoded")
 	}
 	if (cam->vpp_flag & VPP_SWAP_YUV_BYTES) {
 		w9968cf_vpp->swap_yuvbytes(pIn, fr->length);
 		DBG(6, "Original UYVY component ordering changed")
 	}
 	if (cam->vpp_flag & VPP_UPSCALE) {
 		w9968cf_vpp->scale_up(pIn, pOut, hw_w, hw_h, hw_d, w, h);
 		fr->length = (w*h*hw_d)/8;
 		_PSWAP(pIn, pOut)
 		DBG(6, "Vertical up-scaling done: %u,%u,%ubpp->%u,%u",
 		    hw_w, hw_h, hw_d, w, h)
 	}
 	if (cam->vpp_flag & VPP_UYVY_TO_RGBX) {
 		w9968cf_vpp->uyvy_to_rgbx(pIn, fr->length, pOut, fmt, rgb);
 		fr->length = (w*h*d)/8;
 		_PSWAP(pIn, pOut)
 		DBG(6, "UYVY-16bit to %s conversion done",
 		    symbolic(v4l1_plist, fmt))
 	}
 	if (pOut == fr->buffer)
 		memcpy(fr->buffer, cam->frame_vpp.buffer, fr->length);
 	return 0;
 }
 /****************************************************************************
  * Image sensor control routines                                            *
  ****************************************************************************/
 static int
 w9968cf_sensor_set_control(struct w9968cf_device* cam, int cid, int val)
 {
 	struct ovcamchip_control ctl;
 	int err;
 	ctl.id = cid;
 	ctl.value = val;
 	err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_S_CTRL, &ctl);
 	return err;
 }
 static int
 w9968cf_sensor_get_control(struct w9968cf_device* cam, int cid, int* val)
 {
 	struct ovcamchip_control ctl;
 	int err;
 	ctl.id = cid;
 	err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_G_CTRL, &ctl);
 	if (!err)
 		*val = ctl.value;
 	return err;
 }
 static int
 w9968cf_sensor_cmd(struct w9968cf_device* cam, unsigned int cmd, void* arg)
 {
 	int rc;
 	rc = v4l2_subdev_call(cam->sensor_sd, core, ioctl, cmd, arg);
 	/* The I2C driver returns -EPERM on non-supported controls */
 	return (rc < 0 && rc != -EPERM) ? rc : 0;
 }
 /*--------------------------------------------------------------------------
   Update some settings of the image sensor.
   Returns: 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_sensor_update_settings(struct w9968cf_device* cam)
 {
 	int err = 0;
 	/* Auto brightness */
 	err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_AUTOBRIGHT,
 					 cam->auto_brt);
 	if (err)
 		return err;
 	/* Auto exposure */
 	err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_AUTOEXP,
 					 cam->auto_exp);
 	if (err)
 		return err;
 	/* Banding filter */
 	err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BANDFILT,
 					 cam->bandfilt);
 	if (err)
 		return err;
 	/* Light frequency */
 	err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_FREQ,
 					 cam->lightfreq);
 	if (err)
 		return err;
 	/* Back light */
 	err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BACKLIGHT,
 					 cam->backlight);
 	if (err)
 		return err;
 	/* Mirror */
 	err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_MIRROR,
 					 cam->mirror);
 	if (err)
 		return err;
 	return 0;
 }
 /*--------------------------------------------------------------------------
   Get some current picture settings from the image sensor and update the
   internal 'picture' structure of the camera.
   Returns: 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_sensor_get_picture(struct w9968cf_device* cam)
 {
 	int err, v;
 	err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_CONT, &v);
 	if (err)
 		return err;
 	cam->picture.contrast = v;
 	err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_BRIGHT, &v);
 	if (err)
 		return err;
 	cam->picture.brightness = v;
 	err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_SAT, &v);
 	if (err)
 		return err;
 	cam->picture.colour = v;
 	err = w9968cf_sensor_get_control(cam, OVCAMCHIP_CID_HUE, &v);
 	if (err)
 		return err;
 	cam->picture.hue = v;
 	DBG(5, "Got picture settings from the image sensor")
 	PDBGG("Brightness, contrast, hue, colour, whiteness are "
 	      "%u,%u,%u,%u,%u", cam->picture.brightness,cam->picture.contrast,
 	      cam->picture.hue, cam->picture.colour, cam->picture.whiteness)
 	return 0;
 }
 /*--------------------------------------------------------------------------
   Update picture settings of the image sensor.
   Returns: 0 on success, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int
 w9968cf_sensor_update_picture(struct w9968cf_device* cam,
 			      struct video_picture pict)
 {
 	int err = 0;
 	if ((!cam->sensor_initialized)
 	    || pict.contrast != cam->picture.contrast) {
 		err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_CONT,
 						 pict.contrast);
 		if (err)
 			goto fail;
 		DBG(4, "Contrast changed from %u to %u",
 		    cam->picture.contrast, pict.contrast)
 		cam->picture.contrast = pict.contrast;
 	}
 	if (((!cam->sensor_initialized) ||
 	    pict.brightness != cam->picture.brightness) && (!cam->auto_brt)) {
 		err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_BRIGHT,
 						 pict.brightness);
 		if (err)
 			goto fail;
 		DBG(4, "Brightness changed from %u to %u",
 		    cam->picture.brightness, pict.brightness)
 		cam->picture.brightness = pict.brightness;
 	}
 	if ((!cam->sensor_initialized) || pict.colour != cam->picture.colour) {
 		err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_SAT,
 						 pict.colour);
 		if (err)
 			goto fail;
 		DBG(4, "Colour changed from %u to %u",
 		    cam->picture.colour, pict.colour)
 		cam->picture.colour = pict.colour;
 	}
 	if ((!cam->sensor_initialized) || pict.hue != cam->picture.hue) {
 		err = w9968cf_sensor_set_control(cam, OVCAMCHIP_CID_HUE,
 						 pict.hue);
 		if (err)
 			goto fail;
 		DBG(4, "Hue changed from %u to %u",
 		    cam->picture.hue, pict.hue)
 		cam->picture.hue = pict.hue;
 	}
 	return 0;
 fail:
 	DBG(4, "Failed to change sensor picture setting")
 	return err;
 }
 /****************************************************************************
  * Camera configuration                                                     *
  ****************************************************************************/
 /*--------------------------------------------------------------------------
   This function is called when a supported image sensor is detected.
   Return 0 if the initialization succeeds, a negative number otherwise.
   --------------------------------------------------------------------------*/
 static int w9968cf_sensor_init(struct w9968cf_device* cam)
 {
 	int err = 0;
 	if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_INITIALIZE,
 				      &cam->monochrome)))
 		goto error;
 	if ((err = w9968cf_sensor_cmd(cam, OVCAMCHIP_CMD_Q_SUBTYPE,
 				      &cam->sensor)))
 		goto error;
 	/* NOTE: Make sure width and height are a multiple of 16 */
 	switch (v4l2_i2c_subdev_addr(cam->sensor_sd)) {
 		case OV6xx0_SID:
 			cam->maxwidth = 352;
 			cam->maxheight = 288;
 			cam->minwidth = 64;
 			cam->minheight = 48;
 			break;
 		case OV7xx0_SID:
 			cam->maxwidth = 640;
 			cam->maxheight = 480;
 			cam->minwidth = 64;
 			cam->minheight = 48;
 			break;
 		default:
 			DBG(1, "Not supported image sensor detected for %s",
 			    symbolic(camlist, cam->id))
 			return -EINVAL;
 	}
 	/* These values depend on the ones in the ovxxx0.c sources */
 	switch (cam->sensor) {
 		case CC_OV7620:
 			cam->start_cropx = 287;
 			cam->start_cropy = 35;
 			/* Seems to work around a bug in the image sensor */
 			cam->vs_polarity = 1;
 			cam->hs_polarity = 1;
 			break;
 		default:
 			cam->start_cropx = 320;
 			cam->start_cropy = 35;
 			cam->vs_polarity = 1;
 			cam->hs_polarity = 0;
 	}
 	if ((err = w9968cf_sensor_update_settings(cam)))
 		goto error;
 	if ((err = w9968cf_sensor_update_picture(cam, cam->picture)))
 		goto error;
 	cam->sensor_initialized = 1;
 	DBG(2, "%s image sensor initialized", symbolic(senlist, cam->sensor))
 	return 0;
 error:
 	cam->sensor_initialized = 0;
 	cam->sensor = CC_UNKNOWN;
 	DBG(1, "Image sensor initialization failed for %s (/dev/video%d). "
 	       "Try to detach and attach this device again",
 	    symbolic(camlist, cam->id), cam->v4ldev->num)
 	return err;
 }
 /*--------------------------------------------------------------------------
   Fill some basic fields in the main device data structure.
   This function is called once on w9968cf_usb_probe() for each recognized
   camera.
   --------------------------------------------------------------------------*/
 static void
 w9968cf_configure_camera(struct w9968cf_device* cam,
 			 struct usb_device* udev,
 			 enum w9968cf_model_id mod_id,
 			 const unsigned short dev_nr)
 {
 	mutex_init(&cam->fileop_mutex);
 	init_waitqueue_head(&cam->open);
 	spin_lock_init(&cam->urb_lock);
 	spin_lock_init(&cam->flist_lock);
 	cam->users = 0;
 	cam->disconnected = 0;
 	cam->id = mod_id;
 	cam->sensor = CC_UNKNOWN;
 	cam->sensor_initialized = 0;
 	/* Calculate the alternate setting number (from 1 to 16)
 	   according to the 'packet_size' module parameter */
 	if (packet_size[dev_nr] < W9968CF_MIN_PACKET_SIZE)
 		packet_size[dev_nr] = W9968CF_MIN_PACKET_SIZE;
 	for (cam->altsetting = 1;
 	     packet_size[dev_nr] < wMaxPacketSize[cam->altsetting-1];
 	     cam->altsetting++);
 	cam->max_buffers = (max_buffers[dev_nr] < 2 ||
 			    max_buffers[dev_nr] > W9968CF_MAX_BUFFERS)
 			   ? W9968CF_BUFFERS : (u8)max_buffers[dev_nr];
 	cam->double_buffer = (double_buffer[dev_nr] == 0 ||
 			      double_buffer[dev_nr] == 1)
 			     ? (u8)double_buffer[dev_nr]:W9968CF_DOUBLE_BUFFER;
 	cam->clamping = (clamping[dev_nr] == 0 || clamping[dev_nr] == 1)
 			? (u8)clamping[dev_nr] : W9968CF_CLAMPING;
 	cam->filter_type = (filter_type[dev_nr] == 0 ||
 			    filter_type[dev_nr] == 1 ||
 			    filter_type[dev_nr] == 2)
 			   ? (u8)filter_type[dev_nr] : W9968CF_FILTER_TYPE;
 	cam->capture = 1;
 	cam->largeview = (largeview[dev_nr] == 0 || largeview[dev_nr] == 1)
 			 ? (u8)largeview[dev_nr] : W9968CF_LARGEVIEW;
 	cam->decompression = (decompression[dev_nr] == 0 ||
 			      decompression[dev_nr] == 1 ||
 			      decompression[dev_nr] == 2)
 			     ? (u8)decompression[dev_nr]:W9968CF_DECOMPRESSION;
 	cam->upscaling = (upscaling[dev_nr] == 0 ||
 			  upscaling[dev_nr] == 1)
 			 ? (u8)upscaling[dev_nr] : W9968CF_UPSCALING;
 	cam->auto_brt = (autobright[dev_nr] == 0 || autobright[dev_nr] == 1)
 			? (u8)autobright[dev_nr] : W9968CF_AUTOBRIGHT;
 	cam->auto_exp = (autoexp[dev_nr] == 0 || autoexp[dev_nr] == 1)
 			? (u8)autoexp[dev_nr] : W9968CF_AUTOEXP;
 	cam->lightfreq = (lightfreq[dev_nr] == 50 || lightfreq[dev_nr] == 60)
 			 ? (u8)lightfreq[dev_nr] : W9968CF_LIGHTFREQ;
 	cam->bandfilt = (bandingfilter[dev_nr] == 0 ||
 			 bandingfilter[dev_nr] == 1)
 			? (u8)bandingfilter[dev_nr] : W9968CF_BANDINGFILTER;
 	cam->backlight = (backlight[dev_nr] == 0 || backlight[dev_nr] == 1)
 			 ? (u8)backlight[dev_nr] : W9968CF_BACKLIGHT;
 	cam->clockdiv = (clockdiv[dev_nr] == -1 || clockdiv[dev_nr] >= 0)
 			? (s8)clockdiv[dev_nr] : W9968CF_CLOCKDIV;
 	cam->mirror = (mirror[dev_nr] == 0 || mirror[dev_nr] == 1)
 		      ? (u8)mirror[dev_nr] : W9968CF_MIRROR;
 	cam->monochrome = (monochrome[dev_nr] == 0 || monochrome[dev_nr] == 1)
 			  ? monochrome[dev_nr] : W9968CF_MONOCHROME;
 	cam->picture.brightness = (u16)brightness[dev_nr];
 	cam->picture.hue = (u16)hue[dev_nr];
 	cam->picture.colour = (u16)colour[dev_nr];
 	cam->picture.contrast = (u16)contrast[dev_nr];
 	cam->picture.whiteness = (u16)whiteness[dev_nr];
 	if (w9968cf_valid_palette((u16)force_palette[dev_nr])) {
 		cam->picture.palette = (u16)force_palette[dev_nr];
 		cam->force_palette = 1;
 	} else {
 		cam->force_palette = 0;
 		if (cam->decompression == 0)
 			cam->picture.palette = W9968CF_PALETTE_DECOMP_OFF;
 		else if (cam->decompression == 1)
 			cam->picture.palette = W9968CF_PALETTE_DECOMP_FORCE;
 		else
 			cam->picture.palette = W9968CF_PALETTE_DECOMP_ON;
 	}
 	cam->picture.depth = w9968cf_valid_depth(cam->picture.palette);
 	cam->force_rgb = (force_rgb[dev_nr] == 0 || force_rgb[dev_nr] == 1)
 			 ? (u8)force_rgb[dev_nr] : W9968CF_FORCE_RGB;
 	cam->window.x = 0;
 	cam->window.y = 0;
 	cam->window.width = W9968CF_WIDTH;
 	cam->window.height = W9968CF_HEIGHT;
 	cam->window.chromakey = 0;
 	cam->window.clipcount = 0;
 	cam->window.flags = 0;
 	DBG(3, "%s configured with settings #%u:",
 	    symbolic(camlist, cam->id), dev_nr)
 	DBG(3, "- Data packet size for USB isochrnous transfer: %u bytes",
 	    wMaxPacketSize[cam->altsetting-1])
 	DBG(3, "- Number of requested video frame buffers: %u",
 	    cam->max_buffers)
 	if (cam->double_buffer)
 		DBG(3, "- Hardware double buffering enabled")
 	else
 		DBG(3, "- Hardware double buffering disabled")
 	if (cam->filter_type == 0)
 		DBG(3, "- Video filtering disabled")
 	else if (cam->filter_type == 1)
 		DBG(3, "- Video filtering enabled: type 1-2-1")
 	else if (cam->filter_type == 2)
 		DBG(3, "- Video filtering enabled: type 2-3-6-3-2")
 	if (cam->clamping)
 		DBG(3, "- Video data clamping (CCIR-601 format) enabled")
 	else
 		DBG(3, "- Video data clamping (CCIR-601 format) disabled")
 	if (cam->largeview)
 		DBG(3, "- Large view enabled")
 	else
 		DBG(3, "- Large view disabled")
 	if ((cam->decompression) == 0 && (!cam->force_palette))
 		DBG(3, "- Decompression disabled")
 	else if ((cam->decompression) == 1 && (!cam->force_palette))
 		DBG(3, "- Decompression forced")
 	else if ((cam->decompression) == 2 && (!cam->force_palette))
 		DBG(3, "- Decompression allowed")
 	if (cam->upscaling)
 		DBG(3, "- Software image scaling enabled")
 	else
 		DBG(3, "- Software image scaling disabled")
 	if (cam->force_palette)
 		DBG(3, "- Image palette forced to %s",
 		    symbolic(v4l1_plist, cam->picture.palette))
 	if (cam->force_rgb)
 		DBG(3, "- RGB component ordering will be used instead of BGR")
 	if (cam->auto_brt)
 		DBG(3, "- Auto brightness enabled")
 	else
 		DBG(3, "- Auto brightness disabled")
 	if (cam->auto_exp)
 		DBG(3, "- Auto exposure enabled")
 	else
 		DBG(3, "- Auto exposure disabled")
 	if (cam->backlight)
 		DBG(3, "- Backlight exposure algorithm enabled")
 	else
 		DBG(3, "- Backlight exposure algorithm disabled")
 	if (cam->mirror)
 		DBG(3, "- Mirror enabled")
 	else
 		DBG(3, "- Mirror disabled")
 	if (cam->bandfilt)
 		DBG(3, "- Banding filter enabled")
 	else
 		DBG(3, "- Banding filter disabled")
 	DBG(3, "- Power lighting frequency: %u", cam->lightfreq)
 	if (cam->clockdiv == -1)
 		DBG(3, "- Automatic clock divisor enabled")
 	else
 		DBG(3, "- Clock divisor: %d", cam->clockdiv)
 	if (cam->monochrome)
 		DBG(3, "- Image sensor used as monochrome")
 	else
 		DBG(3, "- Image sensor not used as monochrome")
 }
 /*--------------------------------------------------------------------------
   If the video post-processing module is not loaded, some parameters
   must be overridden.
   --------------------------------------------------------------------------*/
 static void w9968cf_adjust_configuration(struct w9968cf_device* cam)
 {
 	if (!w9968cf_vpp) {
 		if (cam->decompression == 1) {
 			cam->decompression = 2;
 			DBG(2, "Video post-processing module not found: "
 			       "'decompression' parameter forced to 2")
 		}
 		if (cam->upscaling) {
 			cam->upscaling = 0;
 			DBG(2, "Video post-processing module not found: "
 			       "'upscaling' parameter forced to 0")
 		}
 		if (cam->picture.palette != VIDEO_PALETTE_UYVY) {
 			cam->force_palette = 0;
 			DBG(2, "Video post-processing module not found: "
 			       "'force_palette' parameter forced to 0")
 		}
 		cam->picture.palette = VIDEO_PALETTE_UYVY;
 		cam->picture.depth = w9968cf_valid_depth(cam->picture.palette);
 	}
 }
 /*--------------------------------------------------------------------------
   Release the resources used by the driver.
   This function is called on disconnect
   (or on close if deallocation has been deferred)
   --------------------------------------------------------------------------*/
 static void w9968cf_release_resources(struct w9968cf_device* cam)
 {
 	mutex_lock(&w9968cf_devlist_mutex);
 	DBG(2, "V4L device deregistered: /dev/video%d", cam->v4ldev->num)
 	video_unregister_device(cam->v4ldev);
 	list_del(&cam->v4llist);
 	i2c_del_adapter(&cam->i2c_adapter);
 	w9968cf_deallocate_memory(cam);
 	kfree(cam->control_buffer);
 	kfree(cam->data_buffer);
 	v4l2_device_unregister(&cam->v4l2_dev);
 	mutex_unlock(&w9968cf_devlist_mutex);
 }
 /****************************************************************************
  * Video4Linux interface                                                    *
  ****************************************************************************/
 static int w9968cf_open(struct file *filp)
 {
 	struct w9968cf_device* cam;
 	int err;
 	/* This the only safe way to prevent race conditions with disconnect */
 	if (!down_read_trylock(&w9968cf_disconnect))
 		return -EAGAIN;
 	cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
 	mutex_lock(&cam->dev_mutex);
 	if (cam->sensor == CC_UNKNOWN) {
 		DBG(2, "No supported image sensor has been detected by the "
 		       "'ovcamchip' module for the %s (/dev/video%d). Make "
 		       "sure it is loaded *before* (re)connecting the camera.",
 		    symbolic(camlist, cam->id), cam->v4ldev->num)
 		mutex_unlock(&cam->dev_mutex);
 		up_read(&w9968cf_disconnect);
 		return -ENODEV;
 	}
 	if (cam->users) {
 		DBG(2, "%s (/dev/video%d) has been already occupied by '%s'",
 		    symbolic(camlist, cam->id), cam->v4ldev->num, cam->command)
 		if ((filp->f_flags & O_NONBLOCK)||(filp->f_flags & O_NDELAY)) {
 			mutex_unlock(&cam->dev_mutex);
 			up_read(&w9968cf_disconnect);
 			return -EWOULDBLOCK;
 		}
 		mutex_unlock(&cam->dev_mutex);
 		err = wait_event_interruptible_exclusive(cam->open,
 							 cam->disconnected ||
 							 !cam->users);
 		if (err) {
 			up_read(&w9968cf_disconnect);
 			return err;
 		}
 		if (cam->disconnected) {
 			up_read(&w9968cf_disconnect);
 			return -ENODEV;
 		}
 		mutex_lock(&cam->dev_mutex);
 	}
 	DBG(5, "Opening '%s', /dev/video%d ...",
 	    symbolic(camlist, cam->id), cam->v4ldev->num)
 	cam->streaming = 0;
 	cam->misconfigured = 0;
 	w9968cf_adjust_configuration(cam);
 	if ((err = w9968cf_allocate_memory(cam)))
 		goto deallocate_memory;
 	if ((err = w9968cf_init_chip(cam)))
 		goto deallocate_memory;
 	if ((err = w9968cf_start_transfer(cam)))
 		goto deallocate_memory;
 	filp->private_data = cam;
 	cam->users++;
 	strcpy(cam->command, current->comm);
 	init_waitqueue_head(&cam->wait_queue);
 	DBG(5, "Video device is open")
 	mutex_unlock(&cam->dev_mutex);
 	up_read(&w9968cf_disconnect);
 	return 0;
 deallocate_memory:
 	w9968cf_deallocate_memory(cam);
 	DBG(2, "Failed to open the video device")
 	mutex_unlock(&cam->dev_mutex);
 	up_read(&w9968cf_disconnect);
 	return err;
 }
 static int w9968cf_release(struct file *filp)
 {
 	struct w9968cf_device* cam;
 	cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
 	mutex_lock(&cam->dev_mutex); /* prevent disconnect() to be called */
 	w9968cf_stop_transfer(cam);
 	if (cam->disconnected) {
 		w9968cf_release_resources(cam);
 		mutex_unlock(&cam->dev_mutex);
 		kfree(cam);
 		return 0;
 	}
 	cam->users--;
 	w9968cf_deallocate_memory(cam);
 	wake_up_interruptible_nr(&cam->open, 1);
 	DBG(5, "Video device closed")
 	mutex_unlock(&cam->dev_mutex);
 	return 0;
 }
 static ssize_t
 w9968cf_read(struct file* filp, char __user * buf, size_t count, loff_t* f_pos)
 {
 	struct w9968cf_device* cam;
 	struct w9968cf_frame_t* fr;
 	int err = 0;
 	cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
 	if (filp->f_flags & O_NONBLOCK)
 		return -EWOULDBLOCK;
 	if (mutex_lock_interruptible(&cam->fileop_mutex))
 		return -ERESTARTSYS;
 	if (cam->disconnected) {
 		DBG(2, "Device not present")
 		mutex_unlock(&cam->fileop_mutex);
 		return -ENODEV;
 	}
 	if (cam->misconfigured) {
 		DBG(2, "The camera is misconfigured. Close and open it again.")
 		mutex_unlock(&cam->fileop_mutex);
 		return -EIO;
 	}
 	if (!cam->frame[0].queued)
 		w9968cf_push_frame(cam, 0);
 	if (!cam->frame[1].queued)
 		w9968cf_push_frame(cam, 1);
 	err = wait_event_interruptible(cam->wait_queue,
 				       cam->frame[0].status == F_READY ||
 				       cam->frame[1].status == F_READY ||
 				       cam->disconnected);
 	if (err) {
 		mutex_unlock(&cam->fileop_mutex);
 		return err;
 	}
 	if (cam->disconnected) {
 		mutex_unlock(&cam->fileop_mutex);
 		return -ENODEV;
 	}
 	fr = (cam->frame[0].status == F_READY) ? &cam->frame[0]:&cam->frame[1];
 	if (w9968cf_vpp)
 		w9968cf_postprocess_frame(cam, fr);
 	if (count > fr->length)
 		count = fr->length;
 	if (copy_to_user(buf, fr->buffer, count)) {
 		fr->status = F_UNUSED;
 		mutex_unlock(&cam->fileop_mutex);
 		return -EFAULT;
 	}
 	*f_pos += count;
 	fr->status = F_UNUSED;
 	DBG(5, "%zu bytes read", count)
 	mutex_unlock(&cam->fileop_mutex);
 	return count;
 }
 static int w9968cf_mmap(struct file* filp, struct vm_area_struct *vma)
 {
 	struct w9968cf_device* cam = (struct w9968cf_device*)
 				     video_get_drvdata(video_devdata(filp));
 	unsigned long vsize = vma->vm_end - vma->vm_start,
 		      psize = cam->nbuffers * cam->frame[0].size,
 		      start = vma->vm_start,
 		      pos = (unsigned long)cam->frame[0].buffer,
 		      page;
 	if (cam->disconnected) {
 		DBG(2, "Device not present")
 		return -ENODEV;
 	}
 	if (cam->misconfigured) {
 		DBG(2, "The camera is misconfigured. Close and open it again")
 		return -EIO;
 	}
 	PDBGG("mmapping %lu bytes...", vsize)
 	if (vsize > psize - (vma->vm_pgoff << PAGE_SHIFT))
 		return -EINVAL;
 	while (vsize > 0) {
 		page = vmalloc_to_pfn((void *)pos);
 		if (remap_pfn_range(vma, start, page + vma->vm_pgoff,
 						PAGE_SIZE, vma->vm_page_prot))
 			return -EAGAIN;
 		start += PAGE_SIZE;
 		pos += PAGE_SIZE;
 		vsize -= PAGE_SIZE;
 	}
 	DBG(5, "mmap method successfully called")
 	return 0;
 }
 static long
 w9968cf_ioctl(struct file *filp,
 	      unsigned int cmd, unsigned long arg)
 {
 	struct w9968cf_device* cam;
 	long err;
 	cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
 	if (mutex_lock_interruptible(&cam->fileop_mutex))
 		return -ERESTARTSYS;
 	if (cam->disconnected) {
 		DBG(2, "Device not present")
 		mutex_unlock(&cam->fileop_mutex);
 		return -ENODEV;
 	}
 	if (cam->misconfigured) {
 		DBG(2, "The camera is misconfigured. Close and open it again.")
 		mutex_unlock(&cam->fileop_mutex);
 		return -EIO;
 	}
 	err = w9968cf_v4l_ioctl(filp, cmd, (void __user *)arg);
 	mutex_unlock(&cam->fileop_mutex);
 	return err;
 }
 static long w9968cf_v4l_ioctl(struct file *filp,
 			     unsigned int cmd, void __user *arg)
 {
 	struct w9968cf_device* cam;
 	const char* v4l1_ioctls[] = {
 		"?", "CGAP", "GCHAN", "SCHAN", "GTUNER", "STUNER",
 		"GPICT", "SPICT", "CCAPTURE", "GWIN", "SWIN", "GFBUF",
 		"SFBUF", "KEY", "GFREQ", "SFREQ", "GAUDIO", "SAUDIO",
 		"SYNC", "MCAPTURE", "GMBUF", "GUNIT", "GCAPTURE", "SCAPTURE",
 		"SPLAYMODE", "SWRITEMODE", "GPLAYINFO", "SMICROCODE",
 		"GVBIFMT", "SVBIFMT"
 	};
 	#define V4L1_IOCTL(cmd) \
 		((_IOC_NR((cmd)) < ARRAY_SIZE(v4l1_ioctls)) ? \
 		v4l1_ioctls[_IOC_NR((cmd))] : "?")
 	cam = (struct w9968cf_device*)video_get_drvdata(video_devdata(filp));
 	switch (cmd) {
 	case VIDIOCGCAP: /* get video capability */
 	{
 		struct video_capability cap = {
 			.type = VID_TYPE_CAPTURE | VID_TYPE_SCALES,
 			.channels = 1,
 			.audios = 0,
 			.minwidth = cam->minwidth,
 			.minheight = cam->minheight,
 		};
 		sprintf(cap.name, "W996[87]CF USB Camera #%d",
 			cam->v4ldev->num);
 		cap.maxwidth = (cam->upscaling && w9968cf_vpp)
 			       ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
 				 : cam->maxwidth;
 		cap.maxheight = (cam->upscaling && w9968cf_vpp)
 				? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
 				  : cam->maxheight;
 		if (copy_to_user(arg, &cap, sizeof(cap)))
 			return -EFAULT;
 		DBG(5, "VIDIOCGCAP successfully called")
 		return 0;
 	}
 	case VIDIOCGCHAN: /* get video channel informations */
 	{
 		struct video_channel chan;
 		if (copy_from_user(&chan, arg, sizeof(chan)))
 			return -EFAULT;
 		if (chan.channel != 0)
 			return -EINVAL;
 		strcpy(chan.name, "Camera");
 		chan.tuners = 0;
 		chan.flags = 0;
 		chan.type = VIDEO_TYPE_CAMERA;
 		chan.norm = VIDEO_MODE_AUTO;
 		if (copy_to_user(arg, &chan, sizeof(chan)))
 			return -EFAULT;
 		DBG(5, "VIDIOCGCHAN successfully called")
 		return 0;
 	}
 	case VIDIOCSCHAN: /* set active channel */
 	{
 		struct video_channel chan;
 		if (copy_from_user(&chan, arg, sizeof(chan)))
 			return -EFAULT;
 		if (chan.channel != 0)
 			return -EINVAL;
 		DBG(5, "VIDIOCSCHAN successfully called")
 		return 0;
 	}
 	case VIDIOCGPICT: /* get image properties of the picture */
 	{
 		if (w9968cf_sensor_get_picture(cam))
 			return -EIO;
 		if (copy_to_user(arg, &cam->picture, sizeof(cam->picture)))
 			return -EFAULT;
 		DBG(5, "VIDIOCGPICT successfully called")
 		return 0;
 	}
 	case VIDIOCSPICT: /* change picture settings */
 	{
 		struct video_picture pict;
 		int err = 0;
 		if (copy_from_user(&pict, arg, sizeof(pict)))
 			return -EFAULT;
 		if ( (cam->force_palette || !w9968cf_vpp)
 		     && pict.palette != cam->picture.palette ) {
 			DBG(4, "Palette %s rejected: only %s is allowed",
 			    symbolic(v4l1_plist, pict.palette),
 			    symbolic(v4l1_plist, cam->picture.palette))
 			return -EINVAL;
 		}
 		if (!w9968cf_valid_palette(pict.palette)) {
 			DBG(4, "Palette %s not supported. VIDIOCSPICT failed",
 			    symbolic(v4l1_plist, pict.palette))
 			return -EINVAL;
 		}
 		if (!cam->force_palette) {
 		   if (cam->decompression == 0) {
 		      if (w9968cf_need_decompression(pict.palette)) {
 			 DBG(4, "Decompression disabled: palette %s is not "
 				"allowed. VIDIOCSPICT failed",
 			     symbolic(v4l1_plist, pict.palette))
 			 return -EINVAL;
 		      }
 		   } else if (cam->decompression == 1) {
 		      if (!w9968cf_need_decompression(pict.palette)) {
 			 DBG(4, "Decompression forced: palette %s is not "
 				"allowed. VIDIOCSPICT failed",
 			     symbolic(v4l1_plist, pict.palette))
 			 return -EINVAL;
 		      }
 		   }
 		}
 		if (pict.depth != w9968cf_valid_depth(pict.palette)) {
 			DBG(4, "Requested depth %u bpp is not valid for %s "
 			       "palette: ignored and changed to %u bpp",
 			    pict.depth, symbolic(v4l1_plist, pict.palette),
 			    w9968cf_valid_depth(pict.palette))
 			pict.depth = w9968cf_valid_depth(pict.palette);
 		}
 		if (pict.palette != cam->picture.palette) {
 			if(*cam->requested_frame
 			   || cam->frame_current->queued) {
 				err = wait_event_interruptible
 				      ( cam->wait_queue,
 					cam->disconnected ||
 					(!*cam->requested_frame &&
 					 !cam->frame_current->queued) );
 				if (err)
 					return err;
 				if (cam->disconnected)
 					return -ENODEV;
 			}
 			if (w9968cf_stop_transfer(cam))
 				goto ioctl_fail;
 			if (w9968cf_set_picture(cam, pict))
 				goto ioctl_fail;
 			if (w9968cf_start_transfer(cam))
 				goto ioctl_fail;
 		} else if (w9968cf_sensor_update_picture(cam, pict))
 			return -EIO;
 		DBG(5, "VIDIOCSPICT successfully called")
 		return 0;
 	}
 	case VIDIOCSWIN: /* set capture area */
 	{
 		struct video_window win;
 		int err = 0;
 		if (copy_from_user(&win, arg, sizeof(win)))
 			return -EFAULT;
 		DBG(6, "VIDIOCSWIN called: clipcount=%d, flags=%u, "
 		       "x=%u, y=%u, %ux%u", win.clipcount, win.flags,
 		    win.x, win.y, win.width, win.height)
 		if (win.clipcount != 0 || win.flags != 0)
 			return -EINVAL;
 		if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
 						      (u16*)&win.height))) {
 			DBG(4, "Resolution not supported (%ux%u). "
 			       "VIDIOCSWIN failed", win.width, win.height)
 			return err;
 		}
 		if (win.x != cam->window.x ||
 		    win.y != cam->window.y ||
 		    win.width != cam->window.width ||
 		    win.height != cam->window.height) {
 			if(*cam->requested_frame
 			   || cam->frame_current->queued) {
 				err = wait_event_interruptible
 				      ( cam->wait_queue,
 					cam->disconnected ||
 					(!*cam->requested_frame &&
 					 !cam->frame_current->queued) );
 				if (err)
 					return err;
 				if (cam->disconnected)
 					return -ENODEV;
 			}
 			if (w9968cf_stop_transfer(cam))
 				goto ioctl_fail;
 			/* This _must_ be called before set_window() */
 			if (w9968cf_set_picture(cam, cam->picture))
 				goto ioctl_fail;
 			if (w9968cf_set_window(cam, win))
 				goto ioctl_fail;
 			if (w9968cf_start_transfer(cam))
 				goto ioctl_fail;
 		}
 		DBG(5, "VIDIOCSWIN successfully called. ")
 		return 0;
 	}
 	case VIDIOCGWIN: /* get current window properties */
 	{
 		if (copy_to_user(arg,&cam->window,sizeof(struct video_window)))
 			return -EFAULT;
 		DBG(5, "VIDIOCGWIN successfully called")
 		return 0;
 	}
 	case VIDIOCGMBUF: /* request for memory (mapped) buffer */
 	{
 		struct video_mbuf mbuf;
 		u8 i;
 		mbuf.size = cam->nbuffers * cam->frame[0].size;
 		mbuf.frames = cam->nbuffers;
 		for (i = 0; i < cam->nbuffers; i++)
 			mbuf.offsets[i] = (unsigned long)cam->frame[i].buffer -
 					  (unsigned long)cam->frame[0].buffer;
 		if (copy_to_user(arg, &mbuf, sizeof(mbuf)))
 			return -EFAULT;
 		DBG(5, "VIDIOCGMBUF successfully called")
 		return 0;
 	}
 	case VIDIOCMCAPTURE: /* start the capture to a frame */
 	{
 		struct video_mmap mmap;
 		struct w9968cf_frame_t* fr;
 		int err = 0;
 		if (copy_from_user(&mmap, arg, sizeof(mmap)))
 			return -EFAULT;
 		DBG(6, "VIDIOCMCAPTURE called: frame #%u, format=%s, %dx%d",
 		    mmap.frame, symbolic(v4l1_plist, mmap.format),
 		    mmap.width, mmap.height)
 		if (mmap.frame >= cam->nbuffers) {
 			DBG(4, "Invalid frame number (%u). "
 			       "VIDIOCMCAPTURE failed", mmap.frame)
 			return -EINVAL;
 		}
 		if (mmap.format!=cam->picture.palette &&
 		    (cam->force_palette || !w9968cf_vpp)) {
 			DBG(4, "Palette %s rejected: only %s is allowed",
 			    symbolic(v4l1_plist, mmap.format),
 			    symbolic(v4l1_plist, cam->picture.palette))
 			return -EINVAL;
 		}
 		if (!w9968cf_valid_palette(mmap.format)) {
 			DBG(4, "Palette %s not supported. "
 			       "VIDIOCMCAPTURE failed",
 			    symbolic(v4l1_plist, mmap.format))
 			return -EINVAL;
 		}
 		if (!cam->force_palette) {
 		   if (cam->decompression == 0) {
 		      if (w9968cf_need_decompression(mmap.format)) {
 			 DBG(4, "Decompression disabled: palette %s is not "
 				"allowed. VIDIOCSPICT failed",
 			     symbolic(v4l1_plist, mmap.format))
 			 return -EINVAL;
 		      }
 		   } else if (cam->decompression == 1) {
 		      if (!w9968cf_need_decompression(mmap.format)) {
 			 DBG(4, "Decompression forced: palette %s is not "
 				"allowed. VIDIOCSPICT failed",
 			     symbolic(v4l1_plist, mmap.format))
 			 return -EINVAL;
 		      }
 		   }
 		}
 		if ((err = w9968cf_adjust_window_size(cam, (u16*)&mmap.width,
 						      (u16*)&mmap.height))) {
 			DBG(4, "Resolution not supported (%dx%d). "
 			       "VIDIOCMCAPTURE failed",
 			    mmap.width, mmap.height)
 			return err;
 		}
 		fr = &cam->frame[mmap.frame];
 		if (mmap.width  != cam->window.width ||
 		    mmap.height != cam->window.height ||
 		    mmap.format != cam->picture.palette) {
 			struct video_window win;
 			struct video_picture pict;
 			if(*cam->requested_frame
 			   || cam->frame_current->queued) {
 				DBG(6, "VIDIOCMCAPTURE. Change settings for "
 				       "frame #%u: %dx%d, format %s. Wait...",
 				    mmap.frame, mmap.width, mmap.height,
 				    symbolic(v4l1_plist, mmap.format))
 				err = wait_event_interruptible
 				      ( cam->wait_queue,
 					cam->disconnected ||
 					(!*cam->requested_frame &&
 					 !cam->frame_current->queued) );
 				if (err)
 					return err;
 				if (cam->disconnected)
 					return -ENODEV;
 			}
 			memcpy(&win, &cam->window, sizeof(win));
 			memcpy(&pict, &cam->picture, sizeof(pict));
 			win.width = mmap.width;
 			win.height = mmap.height;
 			pict.palette = mmap.format;
 			if (w9968cf_stop_transfer(cam))
 				goto ioctl_fail;
 			/* This before set_window */
 			if (w9968cf_set_picture(cam, pict))
 				goto ioctl_fail;
 			if (w9968cf_set_window(cam, win))
 				goto ioctl_fail;
 			if (w9968cf_start_transfer(cam))
 				goto ioctl_fail;
 		} else 	if (fr->queued) {
 			DBG(6, "Wait until frame #%u is free", mmap.frame)
 			err = wait_event_interruptible(cam->wait_queue,
 						       cam->disconnected ||
 						       (!fr->queued));
 			if (err)
 				return err;
 			if (cam->disconnected)
 				return -ENODEV;
 		}
 		w9968cf_push_frame(cam, mmap.frame);
 		DBG(5, "VIDIOCMCAPTURE(%u): successfully called", mmap.frame)
 		return 0;
 	}
 	case VIDIOCSYNC: /* wait until the capture of a frame is finished */
 	{
 		unsigned int f_num;
 		struct w9968cf_frame_t* fr;
 		int err = 0;
 		if (copy_from_user(&f_num, arg, sizeof(f_num)))
 			return -EFAULT;
 		if (f_num >= cam->nbuffers) {
 			DBG(4, "Invalid frame number (%u). "
 			       "VIDIOCMCAPTURE failed", f_num)
 			return -EINVAL;
 		}
 		DBG(6, "VIDIOCSYNC called for frame #%u", f_num)
 		fr = &cam->frame[f_num];
 		switch (fr->status) {
 		case F_UNUSED:
 			if (!fr->queued) {
 				DBG(4, "VIDIOSYNC: Frame #%u not requested!",
 				    f_num)
 				return -EFAULT;
 			}
 		case F_ERROR:
 		case F_GRABBING:
 			err = wait_event_interruptible(cam->wait_queue,
 						       (fr->status == F_READY)
 						       || cam->disconnected);
 			if (err)
 				return err;
 			if (cam->disconnected)
 				return -ENODEV;
 			break;
 		case F_READY:
 			break;
 		}
 		if (w9968cf_vpp)
 			w9968cf_postprocess_frame(cam, fr);
 		fr->status = F_UNUSED;
 		DBG(5, "VIDIOCSYNC(%u) successfully called", f_num)
 		return 0;
 	}
 	case VIDIOCGUNIT:/* report the unit numbers of the associated devices*/
 	{
 		struct video_unit unit = {
 			.video = cam->v4ldev->minor,
 			.vbi = VIDEO_NO_UNIT,
 			.radio = VIDEO_NO_UNIT,
 			.audio = VIDEO_NO_UNIT,
 			.teletext = VIDEO_NO_UNIT,
 		};
 		if (copy_to_user(arg, &unit, sizeof(unit)))
 			return -EFAULT;
 		DBG(5, "VIDIOCGUNIT successfully called")
 		return 0;
 	}
 	case VIDIOCKEY:
 		return 0;
 	case VIDIOCGFBUF:
 	{
 		if (clear_user(arg, sizeof(struct video_buffer)))
 			return -EFAULT;
 		DBG(5, "VIDIOCGFBUF successfully called")
 		return 0;
 	}
 	case VIDIOCGTUNER:
 	{
 		struct video_tuner tuner;
 		if (copy_from_user(&tuner, arg, sizeof(tuner)))
 			return -EFAULT;
 		if (tuner.tuner != 0)
 			return -EINVAL;
 		strcpy(tuner.name, "no_tuner");
 		tuner.rangelow = 0;
 		tuner.rangehigh = 0;
 		tuner.flags = VIDEO_TUNER_NORM;
 		tuner.mode = VIDEO_MODE_AUTO;
 		tuner.signal = 0xffff;
 		if (copy_to_user(arg, &tuner, sizeof(tuner)))
 			return -EFAULT;
 		DBG(5, "VIDIOCGTUNER successfully called")
 		return 0;
 	}
 	case VIDIOCSTUNER:
 	{
 		struct video_tuner tuner;
 		if (copy_from_user(&tuner, arg, sizeof(tuner)))
 			return -EFAULT;
 		if (tuner.tuner != 0)
 			return -EINVAL;
 		if (tuner.mode != VIDEO_MODE_AUTO)
 			return -EINVAL;
 		DBG(5, "VIDIOCSTUNER successfully called")
 		return 0;
 	}
 	case VIDIOCSFBUF:
 	case VIDIOCCAPTURE:
 	case VIDIOCGFREQ:
 	case VIDIOCSFREQ:
 	case VIDIOCGAUDIO:
 	case VIDIOCSAUDIO:
 	case VIDIOCSPLAYMODE:
 	case VIDIOCSWRITEMODE:
 	case VIDIOCGPLAYINFO:
 	case VIDIOCSMICROCODE:
 	case VIDIOCGVBIFMT:
 	case VIDIOCSVBIFMT:
 		DBG(4, "Unsupported V4L1 IOCtl: VIDIOC%s "
 		       "(type 0x%01X, "
 		       "n. 0x%01X, "
 		       "dir. 0x%01X, "
 		       "size 0x%02X)",
 		    V4L1_IOCTL(cmd),
 		    _IOC_TYPE(cmd),_IOC_NR(cmd),_IOC_DIR(cmd),_IOC_SIZE(cmd))
 		return -EINVAL;
 	default:
 		DBG(4, "Invalid V4L1 IOCtl: VIDIOC%s "
 		       "type 0x%01X, "
 		       "n. 0x%01X, "
 		       "dir. 0x%01X, "
 		       "size 0x%02X",
 		    V4L1_IOCTL(cmd),
 		    _IOC_TYPE(cmd),_IOC_NR(cmd),_IOC_DIR(cmd),_IOC_SIZE(cmd))
 		return -ENOIOCTLCMD;
 	} /* end of switch */
 ioctl_fail:
 	cam->misconfigured = 1;
 	DBG(1, "VIDIOC%s failed because of hardware problems. "
 	       "To use the camera, close and open it again.", V4L1_IOCTL(cmd))
 	return -EFAULT;
 }
 static const struct v4l2_file_operations w9968cf_fops = {
 	.owner =   THIS_MODULE,
 	.open =    w9968cf_open,
 	.release = w9968cf_release,
 	.read =    w9968cf_read,
 	.ioctl =   w9968cf_ioctl,
 	.mmap =    w9968cf_mmap,
 };
 /****************************************************************************
  * USB probe and V4L registration, disconnect and id_table[] definition     *
  ****************************************************************************/
 static int
 w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
 {
 	struct usb_device *udev = interface_to_usbdev(intf);
 	struct w9968cf_device* cam;
 	int err = 0;
 	enum w9968cf_model_id mod_id;
 	struct list_head* ptr;
 	u8 sc = 0; /* number of simultaneous cameras */
 	static unsigned short dev_nr; /* 0 - we are handling device number n */
 	static unsigned short addrs[] = {
 		OV7xx0_SID,
 		OV6xx0_SID,
 		I2C_CLIENT_END
 	};
 	if (le16_to_cpu(udev->descriptor.idVendor)  == winbond_id_table[0].idVendor &&
 	    le16_to_cpu(udev->descriptor.idProduct) == winbond_id_table[0].idProduct)
 		mod_id = W9968CF_MOD_CLVBWGP; /* see camlist[] table */
 	else if (le16_to_cpu(udev->descriptor.idVendor)  == winbond_id_table[1].idVendor &&
 		 le16_to_cpu(udev->descriptor.idProduct) == winbond_id_table[1].idProduct)
 		mod_id = W9968CF_MOD_GENERIC; /* see camlist[] table */
 	else
 		return -ENODEV;
 	cam = (struct w9968cf_device*)
 		  kzalloc(sizeof(struct w9968cf_device), GFP_KERNEL);
 	if (!cam)
 		return -ENOMEM;
 	err = v4l2_device_register(&udev->dev, &cam->v4l2_dev);
 	if (err)
 		goto fail0;
 	mutex_init(&cam->dev_mutex);
 	mutex_lock(&cam->dev_mutex);
 	cam->usbdev = udev;
 	DBG(2, "%s detected", symbolic(camlist, mod_id))
 	if (simcams > W9968CF_MAX_DEVICES)
 		simcams = W9968CF_SIMCAMS;
 	/* How many cameras are connected ? */
 	mutex_lock(&w9968cf_devlist_mutex);
 	list_for_each(ptr, &w9968cf_dev_list)
 		sc++;
 	mutex_unlock(&w9968cf_devlist_mutex);
 	if (sc >= simcams) {
 		DBG(2, "Device rejected: too many connected cameras "
 		       "(max. %u)", simcams)
 		err = -EPERM;
 		goto fail;
 	}
 	/* Allocate 2 bytes of memory for camera control USB transfers */
 	if (!(cam->control_buffer = kzalloc(2, GFP_KERNEL))) {
 		DBG(1,"Couldn't allocate memory for camera control transfers")
 		err = -ENOMEM;
 		goto fail;
 	}
 	/* Allocate 8 bytes of memory for USB data transfers to the FSB */
 	if (!(cam->data_buffer = kzalloc(8, GFP_KERNEL))) {
 		DBG(1, "Couldn't allocate memory for data "
 		       "transfers to the FSB")
 		err = -ENOMEM;
 		goto fail;
 	}
 	/* Register the V4L device */
 	cam->v4ldev = video_device_alloc();
 	if (!cam->v4ldev) {
 		DBG(1, "Could not allocate memory for a V4L structure")
 		err = -ENOMEM;
 		goto fail;
 	}
 	strcpy(cam->v4ldev->name, symbolic(camlist, mod_id));
 	cam->v4ldev->fops = &w9968cf_fops;
 	cam->v4ldev->minor = video_nr[dev_nr];
 	cam->v4ldev->release = video_device_release;
 	video_set_drvdata(cam->v4ldev, cam);
 	cam->v4ldev->v4l2_dev = &cam->v4l2_dev;
 	err = video_register_device(cam->v4ldev, VFL_TYPE_GRABBER,
 				    video_nr[dev_nr]);
 	if (err) {
 		DBG(1, "V4L device registration failed")
 		if (err == -ENFILE && video_nr[dev_nr] == -1)
 			DBG(2, "Couldn't find a free /dev/videoX node")
 		video_nr[dev_nr] = -1;
 		dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
 		goto fail;
 	}
 	DBG(2, "V4L device registered as /dev/video%d", cam->v4ldev->num)
 	/* Set some basic constants */
 	w9968cf_configure_camera(cam, udev, mod_id, dev_nr);
 	/* Add a new entry into the list of V4L registered devices */
 	mutex_lock(&w9968cf_devlist_mutex);
 	list_add(&cam->v4llist, &w9968cf_dev_list);
 	mutex_unlock(&w9968cf_devlist_mutex);
 	dev_nr = (dev_nr < W9968CF_MAX_DEVICES-1) ? dev_nr+1 : 0;
 	w9968cf_turn_on_led(cam);
 	w9968cf_i2c_init(cam);
 	cam->sensor_sd = v4l2_i2c_new_probed_subdev(&cam->i2c_adapter,
 			"ovcamchip", "ovcamchip", addrs);
 	usb_set_intfdata(intf, cam);
 	mutex_unlock(&cam->dev_mutex);
 	err = w9968cf_sensor_init(cam);
 	return 0;
 fail: /* Free unused memory */
 	kfree(cam->control_buffer);
 	kfree(cam->data_buffer);
 	if (cam->v4ldev)
 		video_device_release(cam->v4ldev);
 	mutex_unlock(&cam->dev_mutex);
 	v4l2_device_unregister(&cam->v4l2_dev);
 fail0:
 	kfree(cam);
 	return err;
 }
 static void w9968cf_usb_disconnect(struct usb_interface* intf)
 {
 	struct w9968cf_device* cam =
 	   (struct w9968cf_device*)usb_get_intfdata(intf);
 	if (cam) {
 		down_write(&w9968cf_disconnect);
 		/* Prevent concurrent accesses to data */
 		mutex_lock(&cam->dev_mutex);
 		cam->disconnected = 1;
 		DBG(2, "Disconnecting %s...", symbolic(camlist, cam->id))
 		wake_up_interruptible_all(&cam->open);
 		if (cam->users) {
 			DBG(2, "The device is open (/dev/video%d)! "
 			       "Process name: %s. Deregistration and memory "
 			       "deallocation are deferred on close.",
 			    cam->v4ldev->num, cam->command)
 			cam->misconfigured = 1;
 			w9968cf_stop_transfer(cam);
 			wake_up_interruptible(&cam->wait_queue);
 		} else
 			w9968cf_release_resources(cam);
 		mutex_unlock(&cam->dev_mutex);
 		up_write(&w9968cf_disconnect);
 		if (!cam->users) {
 			kfree(cam);
 		}
 	}
 }
 static struct usb_driver w9968cf_usb_driver = {
 	.name =       "w9968cf",
 	.id_table =   winbond_id_table,
 	.probe =      w9968cf_usb_probe,
 	.disconnect = w9968cf_usb_disconnect,
 };
 /****************************************************************************
  * Module init, exit and intermodule communication                          *
  ****************************************************************************/
 static int __init w9968cf_module_init(void)
 {
 	int err;
 	KDBG(2, W9968CF_MODULE_NAME" "W9968CF_MODULE_VERSION)
 	KDBG(3, W9968CF_MODULE_AUTHOR)
 	if ((err = usb_register(&w9968cf_usb_driver)))
 		return err;
 	return 0;
 }
 static void __exit w9968cf_module_exit(void)
 {
 	/* w9968cf_usb_disconnect() will be called */
 	usb_deregister(&w9968cf_usb_driver);
 	KDBG(2, W9968CF_MODULE_NAME" deregistered")
 }
 module_init(w9968cf_module_init);
 module_exit(w9968cf_module_exit);

drivers/media/video/zoran/zoran_driver.c

Diff comments View file @ 7e0a16f

1	/*	1	/*
2	* Zoran zr36057/zr36067 PCI controller driver, for the	2	* Zoran zr36057/zr36067 PCI controller driver, for the
3	* Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux	3	* Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
4	* Media Labs LML33/LML33R10.	4	* Media Labs LML33/LML33R10.
5	*	5	*
6	* Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>	6	* Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
7	*	7	*
8	* Changes for BUZ by Wolfgang Scherr <scherr@net4you.net>	8	* Changes for BUZ by Wolfgang Scherr <scherr@net4you.net>
9	*	9	*
10	* Changes for DC10/DC30 by Laurent Pinchart <laurent.pinchart@skynet.be>	10	* Changes for DC10/DC30 by Laurent Pinchart <laurent.pinchart@skynet.be>
11	*	11	*
12	* Changes for LML33R10 by Maxim Yevtyushkin <max@linuxmedialabs.com>	12	* Changes for LML33R10 by Maxim Yevtyushkin <max@linuxmedialabs.com>
13	*	13	*
14	* Changes for videodev2/v4l2 by Ronald Bultje <rbultje@ronald.bitfreak.net>	14	* Changes for videodev2/v4l2 by Ronald Bultje <rbultje@ronald.bitfreak.net>
15	*	15	*
16	* Based on	16	* Based on
17	*	17	*
18	* Miro DC10 driver	18	* Miro DC10 driver
19	* Copyright (C) 1999 Wolfgang Scherr <scherr@net4you.net>	19	* Copyright (C) 1999 Wolfgang Scherr <scherr@net4you.net>
20	*	20	*
21	* Iomega Buz driver version 1.0	21	* Iomega Buz driver version 1.0
22	* Copyright (C) 1999 Rainer Johanni <Rainer@Johanni.de>	22	* Copyright (C) 1999 Rainer Johanni <Rainer@Johanni.de>
23	*	23	*
24	* buz.0.0.3	24	* buz.0.0.3
25	* Copyright (C) 1998 Dave Perks <dperks@ibm.net>	25	* Copyright (C) 1998 Dave Perks <dperks@ibm.net>
26	*	26	*
27	* bttv - Bt848 frame grabber driver	27	* bttv - Bt848 frame grabber driver
28	* Copyright (C) 1996,97,98 Ralph Metzler (rjkm@thp.uni-koeln.de)	28	* Copyright (C) 1996,97,98 Ralph Metzler (rjkm@thp.uni-koeln.de)
29	* & Marcus Metzler (mocm@thp.uni-koeln.de)	29	* & Marcus Metzler (mocm@thp.uni-koeln.de)
30	*	30	*
31	*	31	*
32	* This program is free software; you can redistribute it and/or modify	32	* This program is free software; you can redistribute it and/or modify
33	* it under the terms of the GNU General Public License as published by	33	* it under the terms of the GNU General Public License as published by
34	* the Free Software Foundation; either version 2 of the License, or	34	* the Free Software Foundation; either version 2 of the License, or
35	* (at your option) any later version.	35	* (at your option) any later version.
36	*	36	*
37	* This program is distributed in the hope that it will be useful,	37	* This program is distributed in the hope that it will be useful,
38	* but WITHOUT ANY WARRANTY; without even the implied warranty of	38	* but WITHOUT ANY WARRANTY; without even the implied warranty of
39	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	39	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
40	* GNU General Public License for more details.	40	* GNU General Public License for more details.
41	*	41	*
42	* You should have received a copy of the GNU General Public License	42	* You should have received a copy of the GNU General Public License
43	* along with this program; if not, write to the Free Software	43	* along with this program; if not, write to the Free Software
44	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	44	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
45	*/	45	*/
46		46
47	#include <linux/version.h>	47	#include <linux/version.h>
48	#include <linux/init.h>	48	#include <linux/init.h>
49	#include <linux/module.h>	49	#include <linux/module.h>
50	#include <linux/delay.h>	50	#include <linux/delay.h>
51	#include <linux/slab.h>	51	#include <linux/slab.h>
52	#include <linux/pci.h>	52	#include <linux/pci.h>
53	#include <linux/vmalloc.h>	53	#include <linux/vmalloc.h>
54	#include <linux/wait.h>	54	#include <linux/wait.h>
55		55
56	#include <linux/interrupt.h>	56	#include <linux/interrupt.h>
57	#include <linux/i2c.h>	57	#include <linux/i2c.h>
58	#include <linux/i2c-algo-bit.h>	58	#include <linux/i2c-algo-bit.h>
59		59
60	#include <linux/spinlock.h>	60	#include <linux/spinlock.h>
61		61
62	#include <linux/videodev2.h>	62	#include <linux/videodev.h>
63	#include <media/v4l2-common.h>	63	#include <media/v4l2-common.h>
64	#include <media/v4l2-ioctl.h>	64	#include <media/v4l2-ioctl.h>
65	#include "videocodec.h"	65	#include "videocodec.h"
66		66
67	#include <asm/byteorder.h>	67	#include <asm/byteorder.h>
68	#include <asm/io.h>	68	#include <asm/io.h>
69	#include <asm/uaccess.h>	69	#include <asm/uaccess.h>
70	#include <linux/proc_fs.h>	70	#include <linux/proc_fs.h>
71		71
72	#include <linux/mutex.h>	72	#include <linux/mutex.h>
73	#include "zoran.h"	73	#include "zoran.h"
74	#include "zoran_device.h"	74	#include "zoran_device.h"
75	#include "zoran_card.h"	75	#include "zoran_card.h"
76		76
77		77
78	const struct zoran_format zoran_formats[] = {	78	const struct zoran_format zoran_formats[] = {
79	{	79	{
80	.name = "15-bit RGB LE",	80	.name = "15-bit RGB LE",
81	.fourcc = V4L2_PIX_FMT_RGB555,	81	.fourcc = V4L2_PIX_FMT_RGB555,
82	.colorspace = V4L2_COLORSPACE_SRGB,	82	.colorspace = V4L2_COLORSPACE_SRGB,
83	.depth = 15,	83	.depth = 15,
84	.flags = ZORAN_FORMAT_CAPTURE \|	84	.flags = ZORAN_FORMAT_CAPTURE \|
85	ZORAN_FORMAT_OVERLAY,	85	ZORAN_FORMAT_OVERLAY,
86	.vfespfr = ZR36057_VFESPFR_RGB555\|ZR36057_VFESPFR_ErrDif\|	86	.vfespfr = ZR36057_VFESPFR_RGB555\|ZR36057_VFESPFR_ErrDif\|
87	ZR36057_VFESPFR_LittleEndian,	87	ZR36057_VFESPFR_LittleEndian,
88	}, {	88	}, {
89	.name = "15-bit RGB BE",	89	.name = "15-bit RGB BE",
90	.fourcc = V4L2_PIX_FMT_RGB555X,	90	.fourcc = V4L2_PIX_FMT_RGB555X,
91	.colorspace = V4L2_COLORSPACE_SRGB,	91	.colorspace = V4L2_COLORSPACE_SRGB,
92	.depth = 15,	92	.depth = 15,
93	.flags = ZORAN_FORMAT_CAPTURE \|	93	.flags = ZORAN_FORMAT_CAPTURE \|
94	ZORAN_FORMAT_OVERLAY,	94	ZORAN_FORMAT_OVERLAY,
95	.vfespfr = ZR36057_VFESPFR_RGB555\|ZR36057_VFESPFR_ErrDif,	95	.vfespfr = ZR36057_VFESPFR_RGB555\|ZR36057_VFESPFR_ErrDif,
96	}, {	96	}, {
97	.name = "16-bit RGB LE",	97	.name = "16-bit RGB LE",
98	.fourcc = V4L2_PIX_FMT_RGB565,	98	.fourcc = V4L2_PIX_FMT_RGB565,
99	.colorspace = V4L2_COLORSPACE_SRGB,	99	.colorspace = V4L2_COLORSPACE_SRGB,
100	.depth = 16,	100	.depth = 16,
101	.flags = ZORAN_FORMAT_CAPTURE \|	101	.flags = ZORAN_FORMAT_CAPTURE \|
102	ZORAN_FORMAT_OVERLAY,	102	ZORAN_FORMAT_OVERLAY,
103	.vfespfr = ZR36057_VFESPFR_RGB565\|ZR36057_VFESPFR_ErrDif\|	103	.vfespfr = ZR36057_VFESPFR_RGB565\|ZR36057_VFESPFR_ErrDif\|
104	ZR36057_VFESPFR_LittleEndian,	104	ZR36057_VFESPFR_LittleEndian,
105	}, {	105	}, {
106	.name = "16-bit RGB BE",	106	.name = "16-bit RGB BE",
107	.fourcc = V4L2_PIX_FMT_RGB565X,	107	.fourcc = V4L2_PIX_FMT_RGB565X,
108	.colorspace = V4L2_COLORSPACE_SRGB,	108	.colorspace = V4L2_COLORSPACE_SRGB,
109	.depth = 16,	109	.depth = 16,
110	.flags = ZORAN_FORMAT_CAPTURE \|	110	.flags = ZORAN_FORMAT_CAPTURE \|
111	ZORAN_FORMAT_OVERLAY,	111	ZORAN_FORMAT_OVERLAY,
112	.vfespfr = ZR36057_VFESPFR_RGB565\|ZR36057_VFESPFR_ErrDif,	112	.vfespfr = ZR36057_VFESPFR_RGB565\|ZR36057_VFESPFR_ErrDif,
113	}, {	113	}, {
114	.name = "24-bit RGB",	114	.name = "24-bit RGB",
115	.fourcc = V4L2_PIX_FMT_BGR24,	115	.fourcc = V4L2_PIX_FMT_BGR24,
116	.colorspace = V4L2_COLORSPACE_SRGB,	116	.colorspace = V4L2_COLORSPACE_SRGB,
117	.depth = 24,	117	.depth = 24,
118	.flags = ZORAN_FORMAT_CAPTURE \|	118	.flags = ZORAN_FORMAT_CAPTURE \|
119	ZORAN_FORMAT_OVERLAY,	119	ZORAN_FORMAT_OVERLAY,
120	.vfespfr = ZR36057_VFESPFR_RGB888\|ZR36057_VFESPFR_Pack24,	120	.vfespfr = ZR36057_VFESPFR_RGB888\|ZR36057_VFESPFR_Pack24,
121	}, {	121	}, {
122	.name = "32-bit RGB LE",	122	.name = "32-bit RGB LE",
123	.fourcc = V4L2_PIX_FMT_BGR32,	123	.fourcc = V4L2_PIX_FMT_BGR32,
124	.colorspace = V4L2_COLORSPACE_SRGB,	124	.colorspace = V4L2_COLORSPACE_SRGB,
125	.depth = 32,	125	.depth = 32,
126	.flags = ZORAN_FORMAT_CAPTURE \|	126	.flags = ZORAN_FORMAT_CAPTURE \|
127	ZORAN_FORMAT_OVERLAY,	127	ZORAN_FORMAT_OVERLAY,
128	.vfespfr = ZR36057_VFESPFR_RGB888\|ZR36057_VFESPFR_LittleEndian,	128	.vfespfr = ZR36057_VFESPFR_RGB888\|ZR36057_VFESPFR_LittleEndian,
129	}, {	129	}, {
130	.name = "32-bit RGB BE",	130	.name = "32-bit RGB BE",
131	.fourcc = V4L2_PIX_FMT_RGB32,	131	.fourcc = V4L2_PIX_FMT_RGB32,
132	.colorspace = V4L2_COLORSPACE_SRGB,	132	.colorspace = V4L2_COLORSPACE_SRGB,
133	.depth = 32,	133	.depth = 32,
134	.flags = ZORAN_FORMAT_CAPTURE \|	134	.flags = ZORAN_FORMAT_CAPTURE \|
135	ZORAN_FORMAT_OVERLAY,	135	ZORAN_FORMAT_OVERLAY,
136	.vfespfr = ZR36057_VFESPFR_RGB888,	136	.vfespfr = ZR36057_VFESPFR_RGB888,
137	}, {	137	}, {
138	.name = "4:2:2, packed, YUYV",	138	.name = "4:2:2, packed, YUYV",
139	.fourcc = V4L2_PIX_FMT_YUYV,	139	.fourcc = V4L2_PIX_FMT_YUYV,
140	.colorspace = V4L2_COLORSPACE_SMPTE170M,	140	.colorspace = V4L2_COLORSPACE_SMPTE170M,
141	.depth = 16,	141	.depth = 16,
142	.flags = ZORAN_FORMAT_CAPTURE \|	142	.flags = ZORAN_FORMAT_CAPTURE \|
143	ZORAN_FORMAT_OVERLAY,	143	ZORAN_FORMAT_OVERLAY,
144	.vfespfr = ZR36057_VFESPFR_YUV422,	144	.vfespfr = ZR36057_VFESPFR_YUV422,
145	}, {	145	}, {
146	.name = "4:2:2, packed, UYVY",	146	.name = "4:2:2, packed, UYVY",
147	.fourcc = V4L2_PIX_FMT_UYVY,	147	.fourcc = V4L2_PIX_FMT_UYVY,
148	.colorspace = V4L2_COLORSPACE_SMPTE170M,	148	.colorspace = V4L2_COLORSPACE_SMPTE170M,
149	.depth = 16,	149	.depth = 16,
150	.flags = ZORAN_FORMAT_CAPTURE \|	150	.flags = ZORAN_FORMAT_CAPTURE \|
151	ZORAN_FORMAT_OVERLAY,	151	ZORAN_FORMAT_OVERLAY,
152	.vfespfr = ZR36057_VFESPFR_YUV422\|ZR36057_VFESPFR_LittleEndian,	152	.vfespfr = ZR36057_VFESPFR_YUV422\|ZR36057_VFESPFR_LittleEndian,
153	}, {	153	}, {
154	.name = "Hardware-encoded Motion-JPEG",	154	.name = "Hardware-encoded Motion-JPEG",
155	.fourcc = V4L2_PIX_FMT_MJPEG,	155	.fourcc = V4L2_PIX_FMT_MJPEG,
156	.colorspace = V4L2_COLORSPACE_SMPTE170M,	156	.colorspace = V4L2_COLORSPACE_SMPTE170M,
157	.depth = 0,	157	.depth = 0,
158	.flags = ZORAN_FORMAT_CAPTURE \|	158	.flags = ZORAN_FORMAT_CAPTURE \|
159	ZORAN_FORMAT_PLAYBACK \|	159	ZORAN_FORMAT_PLAYBACK \|
160	ZORAN_FORMAT_COMPRESSED,	160	ZORAN_FORMAT_COMPRESSED,
161	}	161	}
162	};	162	};
163	#define NUM_FORMATS ARRAY_SIZE(zoran_formats)	163	#define NUM_FORMATS ARRAY_SIZE(zoran_formats)
164		164
165	static int lock_norm; /* 0 = default 1 = Don't change TV standard (norm) */	165	static int lock_norm; /* 0 = default 1 = Don't change TV standard (norm) */
166	module_param(lock_norm, int, 0644);	166	module_param(lock_norm, int, 0644);
167	MODULE_PARM_DESC(lock_norm, "Prevent norm changes (1 = ignore, >1 = fail)");	167	MODULE_PARM_DESC(lock_norm, "Prevent norm changes (1 = ignore, >1 = fail)");
168		168
169	/* small helper function for calculating buffersizes for v4l2	169	/* small helper function for calculating buffersizes for v4l2
170	* we calculate the nearest higher power-of-two, which	170	* we calculate the nearest higher power-of-two, which
171	* will be the recommended buffersize */	171	* will be the recommended buffersize */
172	static __u32	172	static __u32
173	zoran_v4l2_calc_bufsize (struct zoran_jpg_settings *settings)	173	zoran_v4l2_calc_bufsize (struct zoran_jpg_settings *settings)
174	{	174	{
175	__u8 div = settings->VerDcm * settings->HorDcm * settings->TmpDcm;	175	__u8 div = settings->VerDcm * settings->HorDcm * settings->TmpDcm;
176	__u32 num = (1024 * 512) / (div);	176	__u32 num = (1024 * 512) / (div);
177	__u32 result = 2;	177	__u32 result = 2;
178		178
179	num--;	179	num--;
180	while (num) {	180	while (num) {
181	num >>= 1;	181	num >>= 1;
182	result <<= 1;	182	result <<= 1;
183	}	183	}
184		184
185	if (result > jpg_bufsize)	185	if (result > jpg_bufsize)
186	return jpg_bufsize;	186	return jpg_bufsize;
187	if (result < 8192)	187	if (result < 8192)
188	return 8192;	188	return 8192;
189	return result;	189	return result;
190	}	190	}
191		191
192	/* forward references */	192	/* forward references */
193	static void v4l_fbuffer_free(struct file *file);	193	static void v4l_fbuffer_free(struct file *file);
194	static void jpg_fbuffer_free(struct file *file);	194	static void jpg_fbuffer_free(struct file *file);
195		195
196	/*	196	/*
197	* Allocate the V4L grab buffers	197	* Allocate the V4L grab buffers
198	*	198	*
199	* These have to be pysically contiguous.	199	* These have to be pysically contiguous.
200	*/	200	*/
201		201
202	static int	202	static int
203	v4l_fbuffer_alloc (struct file *file)	203	v4l_fbuffer_alloc (struct file *file)
204	{	204	{
205	struct zoran_fh *fh = file->private_data;	205	struct zoran_fh *fh = file->private_data;
206	struct zoran *zr = fh->zr;	206	struct zoran *zr = fh->zr;
207	int i, off;	207	int i, off;
208	unsigned char *mem;	208	unsigned char *mem;
209		209
210	for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {	210	for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {
211	if (fh->v4l_buffers.buffer[i].fbuffer)	211	if (fh->v4l_buffers.buffer[i].fbuffer)
212	dprintk(2,	212	dprintk(2,
213	KERN_WARNING	213	KERN_WARNING
214	"%s: v4l_fbuffer_alloc() - buffer %d already allocated!?\n",	214	"%s: v4l_fbuffer_alloc() - buffer %d already allocated!?\n",
215	ZR_DEVNAME(zr), i);	215	ZR_DEVNAME(zr), i);
216		216
217	//udelay(20);	217	//udelay(20);
218	mem = kmalloc(fh->v4l_buffers.buffer_size, GFP_KERNEL);	218	mem = kmalloc(fh->v4l_buffers.buffer_size, GFP_KERNEL);
219	if (!mem) {	219	if (!mem) {
220	dprintk(1,	220	dprintk(1,
221	KERN_ERR	221	KERN_ERR
222	"%s: v4l_fbuffer_alloc() - kmalloc for V4L buf %d failed\n",	222	"%s: v4l_fbuffer_alloc() - kmalloc for V4L buf %d failed\n",
223	ZR_DEVNAME(zr), i);	223	ZR_DEVNAME(zr), i);
224	v4l_fbuffer_free(file);	224	v4l_fbuffer_free(file);
225	return -ENOBUFS;	225	return -ENOBUFS;
226	}	226	}
227	fh->v4l_buffers.buffer[i].fbuffer = mem;	227	fh->v4l_buffers.buffer[i].fbuffer = mem;
228	fh->v4l_buffers.buffer[i].fbuffer_phys =	228	fh->v4l_buffers.buffer[i].fbuffer_phys =
229	virt_to_phys(mem);	229	virt_to_phys(mem);
230	fh->v4l_buffers.buffer[i].fbuffer_bus =	230	fh->v4l_buffers.buffer[i].fbuffer_bus =
231	virt_to_bus(mem);	231	virt_to_bus(mem);
232	for (off = 0; off < fh->v4l_buffers.buffer_size;	232	for (off = 0; off < fh->v4l_buffers.buffer_size;
233	off += PAGE_SIZE)	233	off += PAGE_SIZE)
234	SetPageReserved(virt_to_page(mem + off));	234	SetPageReserved(virt_to_page(mem + off));
235	dprintk(4,	235	dprintk(4,
236	KERN_INFO	236	KERN_INFO
237	"%s: v4l_fbuffer_alloc() - V4L frame %d mem 0x%lx (bus: 0x%lx)\n",	237	"%s: v4l_fbuffer_alloc() - V4L frame %d mem 0x%lx (bus: 0x%lx)\n",
238	ZR_DEVNAME(zr), i, (unsigned long) mem,	238	ZR_DEVNAME(zr), i, (unsigned long) mem,
239	virt_to_bus(mem));	239	virt_to_bus(mem));
240	}	240	}
241		241
242	fh->v4l_buffers.allocated = 1;	242	fh->v4l_buffers.allocated = 1;
243		243
244	return 0;	244	return 0;
245	}	245	}
246		246
247	/* free the V4L grab buffers */	247	/* free the V4L grab buffers */
248	static void	248	static void
249	v4l_fbuffer_free (struct file *file)	249	v4l_fbuffer_free (struct file *file)
250	{	250	{
251	struct zoran_fh *fh = file->private_data;	251	struct zoran_fh *fh = file->private_data;
252	struct zoran *zr = fh->zr;	252	struct zoran *zr = fh->zr;
253	int i, off;	253	int i, off;
254	unsigned char *mem;	254	unsigned char *mem;
255		255
256	dprintk(4, KERN_INFO "%s: v4l_fbuffer_free()\n", ZR_DEVNAME(zr));	256	dprintk(4, KERN_INFO "%s: v4l_fbuffer_free()\n", ZR_DEVNAME(zr));
257		257
258	for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {	258	for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {
259	if (!fh->v4l_buffers.buffer[i].fbuffer)	259	if (!fh->v4l_buffers.buffer[i].fbuffer)
260	continue;	260	continue;
261		261
262	mem = fh->v4l_buffers.buffer[i].fbuffer;	262	mem = fh->v4l_buffers.buffer[i].fbuffer;
263	for (off = 0; off < fh->v4l_buffers.buffer_size;	263	for (off = 0; off < fh->v4l_buffers.buffer_size;
264	off += PAGE_SIZE)	264	off += PAGE_SIZE)
265	ClearPageReserved(virt_to_page(mem + off));	265	ClearPageReserved(virt_to_page(mem + off));
266	kfree((void *) fh->v4l_buffers.buffer[i].fbuffer);	266	kfree((void *) fh->v4l_buffers.buffer[i].fbuffer);
267	fh->v4l_buffers.buffer[i].fbuffer = NULL;	267	fh->v4l_buffers.buffer[i].fbuffer = NULL;
268	}	268	}
269		269
270	fh->v4l_buffers.allocated = 0;	270	fh->v4l_buffers.allocated = 0;
271	}	271	}
272		272
273	/*	273	/*
274	* Allocate the MJPEG grab buffers.	274	* Allocate the MJPEG grab buffers.
275	*	275	*
276	* If a Natoma chipset is present and this is a revision 1 zr36057,	276	* If a Natoma chipset is present and this is a revision 1 zr36057,
277	* each MJPEG buffer needs to be physically contiguous.	277	* each MJPEG buffer needs to be physically contiguous.
278	* (RJ: This statement is from Dave Perks' original driver,	278	* (RJ: This statement is from Dave Perks' original driver,
279	* I could never check it because I have a zr36067)	279	* I could never check it because I have a zr36067)
280	*	280	*
281	* RJ: The contents grab buffers needs never be accessed in the driver.	281	* RJ: The contents grab buffers needs never be accessed in the driver.
282	* Therefore there is no need to allocate them with vmalloc in order	282	* Therefore there is no need to allocate them with vmalloc in order
283	* to get a contiguous virtual memory space.	283	* to get a contiguous virtual memory space.
284	* I don't understand why many other drivers first allocate them with	284	* I don't understand why many other drivers first allocate them with
285	* vmalloc (which uses internally also get_zeroed_page, but delivers you	285	* vmalloc (which uses internally also get_zeroed_page, but delivers you
286	* virtual addresses) and then again have to make a lot of efforts	286	* virtual addresses) and then again have to make a lot of efforts
287	* to get the physical address.	287	* to get the physical address.
288	*	288	*
289	* Ben Capper:	289	* Ben Capper:
290	* On big-endian architectures (such as ppc) some extra steps	290	* On big-endian architectures (such as ppc) some extra steps
291	* are needed. When reading and writing to the stat_com array	291	* are needed. When reading and writing to the stat_com array
292	* and fragment buffers, the device expects to see little-	292	* and fragment buffers, the device expects to see little-
293	* endian values. The use of cpu_to_le32() and le32_to_cpu()	293	* endian values. The use of cpu_to_le32() and le32_to_cpu()
294	* in this function (and one or two others in zoran_device.c)	294	* in this function (and one or two others in zoran_device.c)
295	* ensure that these values are always stored in little-endian	295	* ensure that these values are always stored in little-endian
296	* form, regardless of architecture. The zr36057 does Very Bad	296	* form, regardless of architecture. The zr36057 does Very Bad
297	* Things on big endian architectures if the stat_com array	297	* Things on big endian architectures if the stat_com array
298	* and fragment buffers are not little-endian.	298	* and fragment buffers are not little-endian.
299	*/	299	*/
300		300
301	static int	301	static int
302	jpg_fbuffer_alloc (struct file *file)	302	jpg_fbuffer_alloc (struct file *file)
303	{	303	{
304	struct zoran_fh *fh = file->private_data;	304	struct zoran_fh *fh = file->private_data;
305	struct zoran *zr = fh->zr;	305	struct zoran *zr = fh->zr;
306	int i, j, off;	306	int i, j, off;
307	unsigned long mem;	307	unsigned long mem;
308		308
309	for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {	309	for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {
310	if (fh->jpg_buffers.buffer[i].frag_tab)	310	if (fh->jpg_buffers.buffer[i].frag_tab)
311	dprintk(2,	311	dprintk(2,
312	KERN_WARNING	312	KERN_WARNING
313	"%s: jpg_fbuffer_alloc() - buffer %d already allocated!?\n",	313	"%s: jpg_fbuffer_alloc() - buffer %d already allocated!?\n",
314	ZR_DEVNAME(zr), i);	314	ZR_DEVNAME(zr), i);
315		315
316	/* Allocate fragment table for this buffer */	316	/* Allocate fragment table for this buffer */
317		317
318	mem = get_zeroed_page(GFP_KERNEL);	318	mem = get_zeroed_page(GFP_KERNEL);
319	if (mem == 0) {	319	if (mem == 0) {
320	dprintk(1,	320	dprintk(1,
321	KERN_ERR	321	KERN_ERR
322	"%s: jpg_fbuffer_alloc() - get_zeroed_page (frag_tab) failed for buffer %d\n",	322	"%s: jpg_fbuffer_alloc() - get_zeroed_page (frag_tab) failed for buffer %d\n",
323	ZR_DEVNAME(zr), i);	323	ZR_DEVNAME(zr), i);
324	jpg_fbuffer_free(file);	324	jpg_fbuffer_free(file);
325	return -ENOBUFS;	325	return -ENOBUFS;
326	}	326	}
327	fh->jpg_buffers.buffer[i].frag_tab = (__le32 *) mem;	327	fh->jpg_buffers.buffer[i].frag_tab = (__le32 *) mem;
328	fh->jpg_buffers.buffer[i].frag_tab_bus =	328	fh->jpg_buffers.buffer[i].frag_tab_bus =
329	virt_to_bus((void *) mem);	329	virt_to_bus((void *) mem);
330		330
331	//if (alloc_contig) {	331	//if (alloc_contig) {
332	if (fh->jpg_buffers.need_contiguous) {	332	if (fh->jpg_buffers.need_contiguous) {
333	mem =	333	mem =
334	(unsigned long) kmalloc(fh->jpg_buffers.	334	(unsigned long) kmalloc(fh->jpg_buffers.
335	buffer_size,	335	buffer_size,
336	GFP_KERNEL);	336	GFP_KERNEL);
337	if (mem == 0) {	337	if (mem == 0) {
338	dprintk(1,	338	dprintk(1,
339	KERN_ERR	339	KERN_ERR
340	"%s: jpg_fbuffer_alloc() - kmalloc failed for buffer %d\n",	340	"%s: jpg_fbuffer_alloc() - kmalloc failed for buffer %d\n",
341	ZR_DEVNAME(zr), i);	341	ZR_DEVNAME(zr), i);
342	jpg_fbuffer_free(file);	342	jpg_fbuffer_free(file);
343	return -ENOBUFS;	343	return -ENOBUFS;
344	}	344	}
345	fh->jpg_buffers.buffer[i].frag_tab[0] =	345	fh->jpg_buffers.buffer[i].frag_tab[0] =
346	cpu_to_le32(virt_to_bus((void *) mem));	346	cpu_to_le32(virt_to_bus((void *) mem));
347	fh->jpg_buffers.buffer[i].frag_tab[1] =	347	fh->jpg_buffers.buffer[i].frag_tab[1] =
348	cpu_to_le32(((fh->jpg_buffers.buffer_size / 4) << 1) \| 1);	348	cpu_to_le32(((fh->jpg_buffers.buffer_size / 4) << 1) \| 1);
349	for (off = 0; off < fh->jpg_buffers.buffer_size;	349	for (off = 0; off < fh->jpg_buffers.buffer_size;
350	off += PAGE_SIZE)	350	off += PAGE_SIZE)
351	SetPageReserved(virt_to_page(mem + off));	351	SetPageReserved(virt_to_page(mem + off));
352	} else {	352	} else {
353	/* jpg_bufsize is already page aligned */	353	/* jpg_bufsize is already page aligned */
354	for (j = 0;	354	for (j = 0;
355	j < fh->jpg_buffers.buffer_size / PAGE_SIZE;	355	j < fh->jpg_buffers.buffer_size / PAGE_SIZE;
356	j++) {	356	j++) {
357	mem = get_zeroed_page(GFP_KERNEL);	357	mem = get_zeroed_page(GFP_KERNEL);
358	if (mem == 0) {	358	if (mem == 0) {
359	dprintk(1,	359	dprintk(1,
360	KERN_ERR	360	KERN_ERR
361	"%s: jpg_fbuffer_alloc() - get_zeroed_page failed for buffer %d\n",	361	"%s: jpg_fbuffer_alloc() - get_zeroed_page failed for buffer %d\n",
362	ZR_DEVNAME(zr), i);	362	ZR_DEVNAME(zr), i);
363	jpg_fbuffer_free(file);	363	jpg_fbuffer_free(file);
364	return -ENOBUFS;	364	return -ENOBUFS;
365	}	365	}
366		366
367	fh->jpg_buffers.buffer[i].frag_tab[2 * j] =	367	fh->jpg_buffers.buffer[i].frag_tab[2 * j] =
368	cpu_to_le32(virt_to_bus((void *) mem));	368	cpu_to_le32(virt_to_bus((void *) mem));
369	fh->jpg_buffers.buffer[i].frag_tab[2 * j +	369	fh->jpg_buffers.buffer[i].frag_tab[2 * j +
370	1] =	370	1] =
371	cpu_to_le32((PAGE_SIZE / 4) << 1);	371	cpu_to_le32((PAGE_SIZE / 4) << 1);
372	SetPageReserved(virt_to_page(mem));	372	SetPageReserved(virt_to_page(mem));
373	}	373	}
374		374
375	fh->jpg_buffers.buffer[i].frag_tab[2 * j - 1] \|= cpu_to_le32(1);	375	fh->jpg_buffers.buffer[i].frag_tab[2 * j - 1] \|= cpu_to_le32(1);
376	}	376	}
377	}	377	}
378		378
379	dprintk(4,	379	dprintk(4,
380	KERN_DEBUG "%s: jpg_fbuffer_alloc() - %d KB allocated\n",	380	KERN_DEBUG "%s: jpg_fbuffer_alloc() - %d KB allocated\n",
381	ZR_DEVNAME(zr),	381	ZR_DEVNAME(zr),
382	(fh->jpg_buffers.num_buffers *	382	(fh->jpg_buffers.num_buffers *
383	fh->jpg_buffers.buffer_size) >> 10);	383	fh->jpg_buffers.buffer_size) >> 10);
384		384
385	fh->jpg_buffers.allocated = 1;	385	fh->jpg_buffers.allocated = 1;
386		386
387	return 0;	387	return 0;
388	}	388	}
389		389
390	/* free the MJPEG grab buffers */	390	/* free the MJPEG grab buffers */
391	static void	391	static void
392	jpg_fbuffer_free (struct file *file)	392	jpg_fbuffer_free (struct file *file)
393	{	393	{
394	struct zoran_fh *fh = file->private_data;	394	struct zoran_fh *fh = file->private_data;
395	struct zoran *zr = fh->zr;	395	struct zoran *zr = fh->zr;
396	int i, j, off;	396	int i, j, off;
397	unsigned char *mem;	397	unsigned char *mem;
398	__le32 frag_tab;	398	__le32 frag_tab;
399		399
400	dprintk(4, KERN_DEBUG "%s: jpg_fbuffer_free()\n", ZR_DEVNAME(zr));	400	dprintk(4, KERN_DEBUG "%s: jpg_fbuffer_free()\n", ZR_DEVNAME(zr));
401		401
402	for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {	402	for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {
403	if (!fh->jpg_buffers.buffer[i].frag_tab)	403	if (!fh->jpg_buffers.buffer[i].frag_tab)
404	continue;	404	continue;
405		405
406	if (fh->jpg_buffers.need_contiguous) {	406	if (fh->jpg_buffers.need_contiguous) {
407	frag_tab = fh->jpg_buffers.buffer[i].frag_tab[0];	407	frag_tab = fh->jpg_buffers.buffer[i].frag_tab[0];
408		408
409	if (frag_tab) {	409	if (frag_tab) {
410	mem = (unsigned char *)bus_to_virt(le32_to_cpu(frag_tab));	410	mem = (unsigned char *)bus_to_virt(le32_to_cpu(frag_tab));
411	for (off = 0; off < fh->jpg_buffers.buffer_size; off += PAGE_SIZE)	411	for (off = 0; off < fh->jpg_buffers.buffer_size; off += PAGE_SIZE)
412	ClearPageReserved(virt_to_page(mem + off));	412	ClearPageReserved(virt_to_page(mem + off));
413	kfree(mem);	413	kfree(mem);
414	fh->jpg_buffers.buffer[i].frag_tab[0] = 0;	414	fh->jpg_buffers.buffer[i].frag_tab[0] = 0;
415	fh->jpg_buffers.buffer[i].frag_tab[1] = 0;	415	fh->jpg_buffers.buffer[i].frag_tab[1] = 0;
416	}	416	}
417	} else {	417	} else {
418	for (j = 0; j < fh->jpg_buffers.buffer_size / PAGE_SIZE; j++) {	418	for (j = 0; j < fh->jpg_buffers.buffer_size / PAGE_SIZE; j++) {
419	frag_tab = fh->jpg_buffers.buffer[i].frag_tab[2 * j];	419	frag_tab = fh->jpg_buffers.buffer[i].frag_tab[2 * j];
420		420
421	if (!frag_tab)	421	if (!frag_tab)
422	break;	422	break;
423	ClearPageReserved(virt_to_page(bus_to_virt(le32_to_cpu(frag_tab))));	423	ClearPageReserved(virt_to_page(bus_to_virt(le32_to_cpu(frag_tab))));
424	free_page((unsigned long)bus_to_virt(le32_to_cpu(frag_tab)));	424	free_page((unsigned long)bus_to_virt(le32_to_cpu(frag_tab)));
425	fh->jpg_buffers.buffer[i].frag_tab[2 * j] = 0;	425	fh->jpg_buffers.buffer[i].frag_tab[2 * j] = 0;
426	fh->jpg_buffers.buffer[i].frag_tab[2 * j + 1] = 0;	426	fh->jpg_buffers.buffer[i].frag_tab[2 * j + 1] = 0;
427	}	427	}
428	}	428	}
429		429
430	free_page((unsigned long)fh->jpg_buffers.buffer[i].frag_tab);	430	free_page((unsigned long)fh->jpg_buffers.buffer[i].frag_tab);
431	fh->jpg_buffers.buffer[i].frag_tab = NULL;	431	fh->jpg_buffers.buffer[i].frag_tab = NULL;
432	}	432	}
433		433
434	fh->jpg_buffers.allocated = 0;	434	fh->jpg_buffers.allocated = 0;
435	}	435	}
436		436
437	/*	437	/*
438	* V4L Buffer grabbing	438	* V4L Buffer grabbing
439	*/	439	*/
440		440
441	static int	441	static int
442	zoran_v4l_set_format (struct file *file,	442	zoran_v4l_set_format (struct file *file,
443	int width,	443	int width,
444	int height,	444	int height,
445	const struct zoran_format *format)	445	const struct zoran_format *format)
446	{	446	{
447	struct zoran_fh *fh = file->private_data;	447	struct zoran_fh *fh = file->private_data;
448	struct zoran *zr = fh->zr;	448	struct zoran *zr = fh->zr;
449	int bpp;	449	int bpp;
450		450
451	/* Check size and format of the grab wanted */	451	/* Check size and format of the grab wanted */
452		452
453	if (height < BUZ_MIN_HEIGHT \|\| width < BUZ_MIN_WIDTH \|\|	453	if (height < BUZ_MIN_HEIGHT \|\| width < BUZ_MIN_WIDTH \|\|
454	height > BUZ_MAX_HEIGHT \|\| width > BUZ_MAX_WIDTH) {	454	height > BUZ_MAX_HEIGHT \|\| width > BUZ_MAX_WIDTH) {
455	dprintk(1,	455	dprintk(1,
456	KERN_ERR	456	KERN_ERR
457	"%s: v4l_set_format() - wrong frame size (%dx%d)\n",	457	"%s: v4l_set_format() - wrong frame size (%dx%d)\n",
458	ZR_DEVNAME(zr), width, height);	458	ZR_DEVNAME(zr), width, height);
459	return -EINVAL;	459	return -EINVAL;
460	}	460	}
461		461
462	bpp = (format->depth + 7) / 8;	462	bpp = (format->depth + 7) / 8;
463		463
464	/* Check against available buffer size */	464	/* Check against available buffer size */
465	if (height * width * bpp > fh->v4l_buffers.buffer_size) {	465	if (height * width * bpp > fh->v4l_buffers.buffer_size) {
466	dprintk(1,	466	dprintk(1,
467	KERN_ERR	467	KERN_ERR
468	"%s: v4l_set_format() - video buffer size (%d kB) is too small\n",	468	"%s: v4l_set_format() - video buffer size (%d kB) is too small\n",
469	ZR_DEVNAME(zr), fh->v4l_buffers.buffer_size >> 10);	469	ZR_DEVNAME(zr), fh->v4l_buffers.buffer_size >> 10);
470	return -EINVAL;	470	return -EINVAL;
471	}	471	}
472		472
473	/* The video front end needs 4-byte alinged line sizes */	473	/* The video front end needs 4-byte alinged line sizes */
474		474
475	if ((bpp == 2 && (width & 1)) \|\| (bpp == 3 && (width & 3))) {	475	if ((bpp == 2 && (width & 1)) \|\| (bpp == 3 && (width & 3))) {
476	dprintk(1,	476	dprintk(1,
477	KERN_ERR	477	KERN_ERR
478	"%s: v4l_set_format() - wrong frame alignment\n",	478	"%s: v4l_set_format() - wrong frame alignment\n",
479	ZR_DEVNAME(zr));	479	ZR_DEVNAME(zr));
480	return -EINVAL;	480	return -EINVAL;
481	}	481	}
482		482
483	fh->v4l_settings.width = width;	483	fh->v4l_settings.width = width;
484	fh->v4l_settings.height = height;	484	fh->v4l_settings.height = height;
485	fh->v4l_settings.format = format;	485	fh->v4l_settings.format = format;
486	fh->v4l_settings.bytesperline = bpp * fh->v4l_settings.width;	486	fh->v4l_settings.bytesperline = bpp * fh->v4l_settings.width;
487		487
488	return 0;	488	return 0;
489	}	489	}
490		490
491	static int	491	static int
492	zoran_v4l_queue_frame (struct file *file,	492	zoran_v4l_queue_frame (struct file *file,
493	int num)	493	int num)
494	{	494	{
495	struct zoran_fh *fh = file->private_data;	495	struct zoran_fh *fh = file->private_data;
496	struct zoran *zr = fh->zr;	496	struct zoran *zr = fh->zr;
497	unsigned long flags;	497	unsigned long flags;
498	int res = 0;	498	int res = 0;
499		499
500	if (!fh->v4l_buffers.allocated) {	500	if (!fh->v4l_buffers.allocated) {
501	dprintk(1,	501	dprintk(1,
502	KERN_ERR	502	KERN_ERR
503	"%s: v4l_queue_frame() - buffers not yet allocated\n",	503	"%s: v4l_queue_frame() - buffers not yet allocated\n",
504	ZR_DEVNAME(zr));	504	ZR_DEVNAME(zr));
505	res = -ENOMEM;	505	res = -ENOMEM;
506	}	506	}
507		507
508	/* No grabbing outside the buffer range! */	508	/* No grabbing outside the buffer range! */
509	if (num >= fh->v4l_buffers.num_buffers \|\| num < 0) {	509	if (num >= fh->v4l_buffers.num_buffers \|\| num < 0) {
510	dprintk(1,	510	dprintk(1,
511	KERN_ERR	511	KERN_ERR
512	"%s: v4l_queue_frame() - buffer %d is out of range\n",	512	"%s: v4l_queue_frame() - buffer %d is out of range\n",
513	ZR_DEVNAME(zr), num);	513	ZR_DEVNAME(zr), num);
514	res = -EINVAL;	514	res = -EINVAL;
515	}	515	}
516		516
517	spin_lock_irqsave(&zr->spinlock, flags);	517	spin_lock_irqsave(&zr->spinlock, flags);
518		518
519	if (fh->v4l_buffers.active == ZORAN_FREE) {	519	if (fh->v4l_buffers.active == ZORAN_FREE) {
520	if (zr->v4l_buffers.active == ZORAN_FREE) {	520	if (zr->v4l_buffers.active == ZORAN_FREE) {
521	zr->v4l_buffers = fh->v4l_buffers;	521	zr->v4l_buffers = fh->v4l_buffers;
522	fh->v4l_buffers.active = ZORAN_ACTIVE;	522	fh->v4l_buffers.active = ZORAN_ACTIVE;
523	} else {	523	} else {
524	dprintk(1,	524	dprintk(1,
525	KERN_ERR	525	KERN_ERR
526	"%s: v4l_queue_frame() - another session is already capturing\n",	526	"%s: v4l_queue_frame() - another session is already capturing\n",
527	ZR_DEVNAME(zr));	527	ZR_DEVNAME(zr));
528	res = -EBUSY;	528	res = -EBUSY;
529	}	529	}
530	}	530	}
531		531
532	/* make sure a grab isn't going on currently with this buffer */	532	/* make sure a grab isn't going on currently with this buffer */
533	if (!res) {	533	if (!res) {
534	switch (zr->v4l_buffers.buffer[num].state) {	534	switch (zr->v4l_buffers.buffer[num].state) {
535	default:	535	default:
536	case BUZ_STATE_PEND:	536	case BUZ_STATE_PEND:
537	if (zr->v4l_buffers.active == ZORAN_FREE) {	537	if (zr->v4l_buffers.active == ZORAN_FREE) {
538	fh->v4l_buffers.active = ZORAN_FREE;	538	fh->v4l_buffers.active = ZORAN_FREE;
539	zr->v4l_buffers.allocated = 0;	539	zr->v4l_buffers.allocated = 0;
540	}	540	}
541	res = -EBUSY; /* what are you doing? */	541	res = -EBUSY; /* what are you doing? */
542	break;	542	break;
543	case BUZ_STATE_DONE:	543	case BUZ_STATE_DONE:
544	dprintk(2,	544	dprintk(2,
545	KERN_WARNING	545	KERN_WARNING
546	"%s: v4l_queue_frame() - queueing buffer %d in state DONE!?\n",	546	"%s: v4l_queue_frame() - queueing buffer %d in state DONE!?\n",
547	ZR_DEVNAME(zr), num);	547	ZR_DEVNAME(zr), num);
548	case BUZ_STATE_USER:	548	case BUZ_STATE_USER:
549	/* since there is at least one unused buffer there's room for at least	549	/* since there is at least one unused buffer there's room for at least
550	* one more pend[] entry */	550	* one more pend[] entry */
551	zr->v4l_pend[zr->v4l_pend_head++ &	551	zr->v4l_pend[zr->v4l_pend_head++ &
552	V4L_MASK_FRAME] = num;	552	V4L_MASK_FRAME] = num;
553	zr->v4l_buffers.buffer[num].state = BUZ_STATE_PEND;	553	zr->v4l_buffers.buffer[num].state = BUZ_STATE_PEND;
554	zr->v4l_buffers.buffer[num].bs.length =	554	zr->v4l_buffers.buffer[num].bs.length =
555	fh->v4l_settings.bytesperline *	555	fh->v4l_settings.bytesperline *
556	zr->v4l_settings.height;	556	zr->v4l_settings.height;
557	fh->v4l_buffers.buffer[num] =	557	fh->v4l_buffers.buffer[num] =
558	zr->v4l_buffers.buffer[num];	558	zr->v4l_buffers.buffer[num];
559	break;	559	break;
560	}	560	}
561	}	561	}
562		562
563	spin_unlock_irqrestore(&zr->spinlock, flags);	563	spin_unlock_irqrestore(&zr->spinlock, flags);
564		564
565	if (!res && zr->v4l_buffers.active == ZORAN_FREE)	565	if (!res && zr->v4l_buffers.active == ZORAN_FREE)
566	zr->v4l_buffers.active = fh->v4l_buffers.active;	566	zr->v4l_buffers.active = fh->v4l_buffers.active;
567		567
568	return res;	568	return res;
569	}	569	}
570		570
571	/*	571	/*
572	* Sync on a V4L buffer	572	* Sync on a V4L buffer
573	*/	573	*/
574		574
575	static int	575	static int
576	v4l_sync (struct file *file,	576	v4l_sync (struct file *file,
577	int frame)	577	int frame)
578	{	578	{
579	struct zoran_fh *fh = file->private_data;	579	struct zoran_fh *fh = file->private_data;
580	struct zoran *zr = fh->zr;	580	struct zoran *zr = fh->zr;
581	unsigned long flags;	581	unsigned long flags;
582		582
583	if (fh->v4l_buffers.active == ZORAN_FREE) {	583	if (fh->v4l_buffers.active == ZORAN_FREE) {
584	dprintk(1,	584	dprintk(1,
585	KERN_ERR	585	KERN_ERR
586	"%s: v4l_sync() - no grab active for this session\n",	586	"%s: v4l_sync() - no grab active for this session\n",
587	ZR_DEVNAME(zr));	587	ZR_DEVNAME(zr));
588	return -EINVAL;	588	return -EINVAL;
589	}	589	}
590		590
591	/* check passed-in frame number */	591	/* check passed-in frame number */
592	if (frame >= fh->v4l_buffers.num_buffers \|\| frame < 0) {	592	if (frame >= fh->v4l_buffers.num_buffers \|\| frame < 0) {
593	dprintk(1,	593	dprintk(1,
594	KERN_ERR "%s: v4l_sync() - frame %d is invalid\n",	594	KERN_ERR "%s: v4l_sync() - frame %d is invalid\n",
595	ZR_DEVNAME(zr), frame);	595	ZR_DEVNAME(zr), frame);
596	return -EINVAL;	596	return -EINVAL;
597	}	597	}
598		598
599	/* Check if is buffer was queued at all */	599	/* Check if is buffer was queued at all */
600	if (zr->v4l_buffers.buffer[frame].state == BUZ_STATE_USER) {	600	if (zr->v4l_buffers.buffer[frame].state == BUZ_STATE_USER) {
601	dprintk(1,	601	dprintk(1,
602	KERN_ERR	602	KERN_ERR
603	"%s: v4l_sync() - attempt to sync on a buffer which was not queued?\n",	603	"%s: v4l_sync() - attempt to sync on a buffer which was not queued?\n",
604	ZR_DEVNAME(zr));	604	ZR_DEVNAME(zr));
605	return -EPROTO;	605	return -EPROTO;
606	}	606	}
607		607
608	/* wait on this buffer to get ready */	608	/* wait on this buffer to get ready */
609	if (!wait_event_interruptible_timeout(zr->v4l_capq,	609	if (!wait_event_interruptible_timeout(zr->v4l_capq,
610	(zr->v4l_buffers.buffer[frame].state != BUZ_STATE_PEND),	610	(zr->v4l_buffers.buffer[frame].state != BUZ_STATE_PEND),
611	10*HZ))	611	10*HZ))
612	return -ETIME;	612	return -ETIME;
613	if (signal_pending(current))	613	if (signal_pending(current))
614	return -ERESTARTSYS;	614	return -ERESTARTSYS;
615		615
616	/* buffer should now be in BUZ_STATE_DONE */	616	/* buffer should now be in BUZ_STATE_DONE */
617	if (zr->v4l_buffers.buffer[frame].state != BUZ_STATE_DONE)	617	if (zr->v4l_buffers.buffer[frame].state != BUZ_STATE_DONE)
618	dprintk(2,	618	dprintk(2,
619	KERN_ERR "%s: v4l_sync() - internal state error\n",	619	KERN_ERR "%s: v4l_sync() - internal state error\n",
620	ZR_DEVNAME(zr));	620	ZR_DEVNAME(zr));
621		621
622	zr->v4l_buffers.buffer[frame].state = BUZ_STATE_USER;	622	zr->v4l_buffers.buffer[frame].state = BUZ_STATE_USER;
623	fh->v4l_buffers.buffer[frame] = zr->v4l_buffers.buffer[frame];	623	fh->v4l_buffers.buffer[frame] = zr->v4l_buffers.buffer[frame];
624		624
625	spin_lock_irqsave(&zr->spinlock, flags);	625	spin_lock_irqsave(&zr->spinlock, flags);
626		626
627	/* Check if streaming capture has finished */	627	/* Check if streaming capture has finished */
628	if (zr->v4l_pend_tail == zr->v4l_pend_head) {	628	if (zr->v4l_pend_tail == zr->v4l_pend_head) {
629	zr36057_set_memgrab(zr, 0);	629	zr36057_set_memgrab(zr, 0);
630	if (zr->v4l_buffers.active == ZORAN_ACTIVE) {	630	if (zr->v4l_buffers.active == ZORAN_ACTIVE) {
631	fh->v4l_buffers.active = zr->v4l_buffers.active =	631	fh->v4l_buffers.active = zr->v4l_buffers.active =
632	ZORAN_FREE;	632	ZORAN_FREE;
633	zr->v4l_buffers.allocated = 0;	633	zr->v4l_buffers.allocated = 0;
634	}	634	}
635	}	635	}
636		636
637	spin_unlock_irqrestore(&zr->spinlock, flags);	637	spin_unlock_irqrestore(&zr->spinlock, flags);
638		638
639	return 0;	639	return 0;
640	}	640	}
641		641
642	/*	642	/*
643	* Queue a MJPEG buffer for capture/playback	643	* Queue a MJPEG buffer for capture/playback
644	*/	644	*/
645		645
646	static int	646	static int
647	zoran_jpg_queue_frame (struct file *file,	647	zoran_jpg_queue_frame (struct file *file,
648	int num,	648	int num,
649	enum zoran_codec_mode mode)	649	enum zoran_codec_mode mode)
650	{	650	{
651	struct zoran_fh *fh = file->private_data;	651	struct zoran_fh *fh = file->private_data;
652	struct zoran *zr = fh->zr;	652	struct zoran *zr = fh->zr;
653	unsigned long flags;	653	unsigned long flags;
654	int res = 0;	654	int res = 0;
655		655
656	/* Check if buffers are allocated */	656	/* Check if buffers are allocated */
657	if (!fh->jpg_buffers.allocated) {	657	if (!fh->jpg_buffers.allocated) {
658	dprintk(1,	658	dprintk(1,
659	KERN_ERR	659	KERN_ERR
660	"%s: jpg_queue_frame() - buffers not yet allocated\n",	660	"%s: jpg_queue_frame() - buffers not yet allocated\n",
661	ZR_DEVNAME(zr));	661	ZR_DEVNAME(zr));
662	return -ENOMEM;	662	return -ENOMEM;
663	}	663	}
664		664
665	/* No grabbing outside the buffer range! */	665	/* No grabbing outside the buffer range! */
666	if (num >= fh->jpg_buffers.num_buffers \|\| num < 0) {	666	if (num >= fh->jpg_buffers.num_buffers \|\| num < 0) {
667	dprintk(1,	667	dprintk(1,
668	KERN_ERR	668	KERN_ERR
669	"%s: jpg_queue_frame() - buffer %d out of range\n",	669	"%s: jpg_queue_frame() - buffer %d out of range\n",
670	ZR_DEVNAME(zr), num);	670	ZR_DEVNAME(zr), num);
671	return -EINVAL;	671	return -EINVAL;
672	}	672	}
673		673
674	/* what is the codec mode right now? */	674	/* what is the codec mode right now? */
675	if (zr->codec_mode == BUZ_MODE_IDLE) {	675	if (zr->codec_mode == BUZ_MODE_IDLE) {
676	zr->jpg_settings = fh->jpg_settings;	676	zr->jpg_settings = fh->jpg_settings;
677	} else if (zr->codec_mode != mode) {	677	} else if (zr->codec_mode != mode) {
678	/* wrong codec mode active - invalid */	678	/* wrong codec mode active - invalid */
679	dprintk(1,	679	dprintk(1,
680	KERN_ERR	680	KERN_ERR
681	"%s: jpg_queue_frame() - codec in wrong mode\n",	681	"%s: jpg_queue_frame() - codec in wrong mode\n",
682	ZR_DEVNAME(zr));	682	ZR_DEVNAME(zr));
683	return -EINVAL;	683	return -EINVAL;
684	}	684	}
685		685
686	if (fh->jpg_buffers.active == ZORAN_FREE) {	686	if (fh->jpg_buffers.active == ZORAN_FREE) {
687	if (zr->jpg_buffers.active == ZORAN_FREE) {	687	if (zr->jpg_buffers.active == ZORAN_FREE) {
688	zr->jpg_buffers = fh->jpg_buffers;	688	zr->jpg_buffers = fh->jpg_buffers;
689	fh->jpg_buffers.active = ZORAN_ACTIVE;	689	fh->jpg_buffers.active = ZORAN_ACTIVE;
690	} else {	690	} else {
691	dprintk(1,	691	dprintk(1,
692	KERN_ERR	692	KERN_ERR
693	"%s: jpg_queue_frame() - another session is already capturing\n",	693	"%s: jpg_queue_frame() - another session is already capturing\n",
694	ZR_DEVNAME(zr));	694	ZR_DEVNAME(zr));
695	res = -EBUSY;	695	res = -EBUSY;
696	}	696	}
697	}	697	}
698		698
699	if (!res && zr->codec_mode == BUZ_MODE_IDLE) {	699	if (!res && zr->codec_mode == BUZ_MODE_IDLE) {
700	/* Ok load up the jpeg codec */	700	/* Ok load up the jpeg codec */
701	zr36057_enable_jpg(zr, mode);	701	zr36057_enable_jpg(zr, mode);
702	}	702	}
703		703
704	spin_lock_irqsave(&zr->spinlock, flags);	704	spin_lock_irqsave(&zr->spinlock, flags);
705		705
706	if (!res) {	706	if (!res) {
707	switch (zr->jpg_buffers.buffer[num].state) {	707	switch (zr->jpg_buffers.buffer[num].state) {
708	case BUZ_STATE_DONE:	708	case BUZ_STATE_DONE:
709	dprintk(2,	709	dprintk(2,
710	KERN_WARNING	710	KERN_WARNING
711	"%s: jpg_queue_frame() - queing frame in BUZ_STATE_DONE state!?\n",	711	"%s: jpg_queue_frame() - queing frame in BUZ_STATE_DONE state!?\n",
712	ZR_DEVNAME(zr));	712	ZR_DEVNAME(zr));
713	case BUZ_STATE_USER:	713	case BUZ_STATE_USER:
714	/* since there is at least one unused buffer there's room for at	714	/* since there is at least one unused buffer there's room for at
715	least one more pend[] entry /	715	least one more pend[] entry /
716	zr->jpg_pend[zr->jpg_que_head++ & BUZ_MASK_FRAME] =	716	zr->jpg_pend[zr->jpg_que_head++ & BUZ_MASK_FRAME] =
717	num;	717	num;
718	zr->jpg_buffers.buffer[num].state = BUZ_STATE_PEND;	718	zr->jpg_buffers.buffer[num].state = BUZ_STATE_PEND;
719	fh->jpg_buffers.buffer[num] =	719	fh->jpg_buffers.buffer[num] =
720	zr->jpg_buffers.buffer[num];	720	zr->jpg_buffers.buffer[num];
721	zoran_feed_stat_com(zr);	721	zoran_feed_stat_com(zr);
722	break;	722	break;
723	default:	723	default:
724	case BUZ_STATE_DMA:	724	case BUZ_STATE_DMA:
725	case BUZ_STATE_PEND:	725	case BUZ_STATE_PEND:
726	if (zr->jpg_buffers.active == ZORAN_FREE) {	726	if (zr->jpg_buffers.active == ZORAN_FREE) {
727	fh->jpg_buffers.active = ZORAN_FREE;	727	fh->jpg_buffers.active = ZORAN_FREE;
728	zr->jpg_buffers.allocated = 0;	728	zr->jpg_buffers.allocated = 0;
729	}	729	}
730	res = -EBUSY; /* what are you doing? */	730	res = -EBUSY; /* what are you doing? */
731	break;	731	break;
732	}	732	}
733	}	733	}
734		734
735	spin_unlock_irqrestore(&zr->spinlock, flags);	735	spin_unlock_irqrestore(&zr->spinlock, flags);
736		736
737	if (!res && zr->jpg_buffers.active == ZORAN_FREE) {	737	if (!res && zr->jpg_buffers.active == ZORAN_FREE) {
738	zr->jpg_buffers.active = fh->jpg_buffers.active;	738	zr->jpg_buffers.active = fh->jpg_buffers.active;
739	}	739	}
740		740
741	return res;	741	return res;
742	}	742	}
743		743
744	static int	744	static int
745	jpg_qbuf (struct file *file,	745	jpg_qbuf (struct file *file,
746	int frame,	746	int frame,
747	enum zoran_codec_mode mode)	747	enum zoran_codec_mode mode)
748	{	748	{
749	struct zoran_fh *fh = file->private_data;	749	struct zoran_fh *fh = file->private_data;
750	struct zoran *zr = fh->zr;	750	struct zoran *zr = fh->zr;
751	int res = 0;	751	int res = 0;
752		752
753	/* Does the user want to stop streaming? */	753	/* Does the user want to stop streaming? */
754	if (frame < 0) {	754	if (frame < 0) {
755	if (zr->codec_mode == mode) {	755	if (zr->codec_mode == mode) {
756	if (fh->jpg_buffers.active == ZORAN_FREE) {	756	if (fh->jpg_buffers.active == ZORAN_FREE) {
757	dprintk(1,	757	dprintk(1,
758	KERN_ERR	758	KERN_ERR
759	"%s: jpg_qbuf(-1) - session not active\n",	759	"%s: jpg_qbuf(-1) - session not active\n",
760	ZR_DEVNAME(zr));	760	ZR_DEVNAME(zr));
761	return -EINVAL;	761	return -EINVAL;
762	}	762	}
763	fh->jpg_buffers.active = zr->jpg_buffers.active =	763	fh->jpg_buffers.active = zr->jpg_buffers.active =
764	ZORAN_FREE;	764	ZORAN_FREE;
765	zr->jpg_buffers.allocated = 0;	765	zr->jpg_buffers.allocated = 0;
766	zr36057_enable_jpg(zr, BUZ_MODE_IDLE);	766	zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
767	return 0;	767	return 0;
768	} else {	768	} else {
769	dprintk(1,	769	dprintk(1,
770	KERN_ERR	770	KERN_ERR
771	"%s: jpg_qbuf() - stop streaming but not in streaming mode\n",	771	"%s: jpg_qbuf() - stop streaming but not in streaming mode\n",
772	ZR_DEVNAME(zr));	772	ZR_DEVNAME(zr));
773	return -EINVAL;	773	return -EINVAL;
774	}	774	}
775	}	775	}
776		776
777	if ((res = zoran_jpg_queue_frame(file, frame, mode)))	777	if ((res = zoran_jpg_queue_frame(file, frame, mode)))
778	return res;	778	return res;
779		779
780	/* Start the jpeg codec when the first frame is queued */	780	/* Start the jpeg codec when the first frame is queued */
781	if (!res && zr->jpg_que_head == 1)	781	if (!res && zr->jpg_que_head == 1)
782	jpeg_start(zr);	782	jpeg_start(zr);
783		783
784	return res;	784	return res;
785	}	785	}
786		786
787	/*	787	/*
788	* Sync on a MJPEG buffer	788	* Sync on a MJPEG buffer
789	*/	789	*/
790		790
791	static int	791	static int
792	jpg_sync (struct file *file,	792	jpg_sync (struct file *file,
793	struct zoran_sync *bs)	793	struct zoran_sync *bs)
794	{	794	{
795	struct zoran_fh *fh = file->private_data;	795	struct zoran_fh *fh = file->private_data;
796	struct zoran *zr = fh->zr;	796	struct zoran *zr = fh->zr;
797	unsigned long flags;	797	unsigned long flags;
798	int frame;	798	int frame;
799		799
800	if (fh->jpg_buffers.active == ZORAN_FREE) {	800	if (fh->jpg_buffers.active == ZORAN_FREE) {
801	dprintk(1,	801	dprintk(1,
802	KERN_ERR	802	KERN_ERR
803	"%s: jpg_sync() - capture is not currently active\n",	803	"%s: jpg_sync() - capture is not currently active\n",
804	ZR_DEVNAME(zr));	804	ZR_DEVNAME(zr));
805	return -EINVAL;	805	return -EINVAL;
806	}	806	}
807	if (zr->codec_mode != BUZ_MODE_MOTION_DECOMPRESS &&	807	if (zr->codec_mode != BUZ_MODE_MOTION_DECOMPRESS &&
808	zr->codec_mode != BUZ_MODE_MOTION_COMPRESS) {	808	zr->codec_mode != BUZ_MODE_MOTION_COMPRESS) {
809	dprintk(1,	809	dprintk(1,
810	KERN_ERR	810	KERN_ERR
811	"%s: jpg_sync() - codec not in streaming mode\n",	811	"%s: jpg_sync() - codec not in streaming mode\n",
812	ZR_DEVNAME(zr));	812	ZR_DEVNAME(zr));
813	return -EINVAL;	813	return -EINVAL;
814	}	814	}
815	if (!wait_event_interruptible_timeout(zr->jpg_capq,	815	if (!wait_event_interruptible_timeout(zr->jpg_capq,
816	(zr->jpg_que_tail != zr->jpg_dma_tail \|\|	816	(zr->jpg_que_tail != zr->jpg_dma_tail \|\|
817	zr->jpg_dma_tail == zr->jpg_dma_head),	817	zr->jpg_dma_tail == zr->jpg_dma_head),
818	10*HZ)) {	818	10*HZ)) {
819	int isr;	819	int isr;
820		820
821	btand(~ZR36057_JMC_Go_en, ZR36057_JMC);	821	btand(~ZR36057_JMC_Go_en, ZR36057_JMC);
822	udelay(1);	822	udelay(1);
823	zr->codec->control(zr->codec, CODEC_G_STATUS,	823	zr->codec->control(zr->codec, CODEC_G_STATUS,
824	sizeof(isr), &isr);	824	sizeof(isr), &isr);
825	dprintk(1,	825	dprintk(1,
826	KERN_ERR	826	KERN_ERR
827	"%s: jpg_sync() - timeout: codec isr=0x%02x\n",	827	"%s: jpg_sync() - timeout: codec isr=0x%02x\n",
828	ZR_DEVNAME(zr), isr);	828	ZR_DEVNAME(zr), isr);
829		829
830	return -ETIME;	830	return -ETIME;
831		831
832	}	832	}
833	if (signal_pending(current))	833	if (signal_pending(current))
834	return -ERESTARTSYS;	834	return -ERESTARTSYS;
835		835
836	spin_lock_irqsave(&zr->spinlock, flags);	836	spin_lock_irqsave(&zr->spinlock, flags);
837		837
838	if (zr->jpg_dma_tail != zr->jpg_dma_head)	838	if (zr->jpg_dma_tail != zr->jpg_dma_head)
839	frame = zr->jpg_pend[zr->jpg_que_tail++ & BUZ_MASK_FRAME];	839	frame = zr->jpg_pend[zr->jpg_que_tail++ & BUZ_MASK_FRAME];
840	else	840	else
841	frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];	841	frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
842		842
843	/* buffer should now be in BUZ_STATE_DONE */	843	/* buffer should now be in BUZ_STATE_DONE */
844	if (zr->jpg_buffers.buffer[frame].state != BUZ_STATE_DONE)	844	if (zr->jpg_buffers.buffer[frame].state != BUZ_STATE_DONE)
845	dprintk(2,	845	dprintk(2,
846	KERN_ERR "%s: jpg_sync() - internal state error\n",	846	KERN_ERR "%s: jpg_sync() - internal state error\n",
847	ZR_DEVNAME(zr));	847	ZR_DEVNAME(zr));
848		848
849	*bs = zr->jpg_buffers.buffer[frame].bs;	849	*bs = zr->jpg_buffers.buffer[frame].bs;
850	bs->frame = frame;	850	bs->frame = frame;
851	zr->jpg_buffers.buffer[frame].state = BUZ_STATE_USER;	851	zr->jpg_buffers.buffer[frame].state = BUZ_STATE_USER;
852	fh->jpg_buffers.buffer[frame] = zr->jpg_buffers.buffer[frame];	852	fh->jpg_buffers.buffer[frame] = zr->jpg_buffers.buffer[frame];
853		853
854	spin_unlock_irqrestore(&zr->spinlock, flags);	854	spin_unlock_irqrestore(&zr->spinlock, flags);
855		855
856	return 0;	856	return 0;
857	}	857	}
858		858
859	static void	859	static void
860	zoran_open_init_session (struct file *file)	860	zoran_open_init_session (struct file *file)
861	{	861	{
862	int i;	862	int i;
863	struct zoran_fh *fh = file->private_data;	863	struct zoran_fh *fh = file->private_data;
864	struct zoran *zr = fh->zr;	864	struct zoran *zr = fh->zr;
865		865
866	/* Per default, map the V4L Buffers */	866	/* Per default, map the V4L Buffers */
867	fh->map_mode = ZORAN_MAP_MODE_RAW;	867	fh->map_mode = ZORAN_MAP_MODE_RAW;
868		868
869	/* take over the card's current settings */	869	/* take over the card's current settings */
870	fh->overlay_settings = zr->overlay_settings;	870	fh->overlay_settings = zr->overlay_settings;
871	fh->overlay_settings.is_set = 0;	871	fh->overlay_settings.is_set = 0;
872	fh->overlay_settings.format = zr->overlay_settings.format;	872	fh->overlay_settings.format = zr->overlay_settings.format;
873	fh->overlay_active = ZORAN_FREE;	873	fh->overlay_active = ZORAN_FREE;
874		874
875	/* v4l settings */	875	/* v4l settings */
876	fh->v4l_settings = zr->v4l_settings;	876	fh->v4l_settings = zr->v4l_settings;
877		877
878	/* v4l_buffers */	878	/* v4l_buffers */
879	memset(&fh->v4l_buffers, 0, sizeof(struct zoran_v4l_struct));	879	memset(&fh->v4l_buffers, 0, sizeof(struct zoran_v4l_struct));
880	for (i = 0; i < VIDEO_MAX_FRAME; i++) {	880	for (i = 0; i < VIDEO_MAX_FRAME; i++) {
881	fh->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */	881	fh->v4l_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
882	fh->v4l_buffers.buffer[i].bs.frame = i;	882	fh->v4l_buffers.buffer[i].bs.frame = i;
883	}	883	}
884	fh->v4l_buffers.allocated = 0;	884	fh->v4l_buffers.allocated = 0;
885	fh->v4l_buffers.active = ZORAN_FREE;	885	fh->v4l_buffers.active = ZORAN_FREE;
886	fh->v4l_buffers.buffer_size = v4l_bufsize;	886	fh->v4l_buffers.buffer_size = v4l_bufsize;
887	fh->v4l_buffers.num_buffers = v4l_nbufs;	887	fh->v4l_buffers.num_buffers = v4l_nbufs;
888		888
889	/* jpg settings */	889	/* jpg settings */
890	fh->jpg_settings = zr->jpg_settings;	890	fh->jpg_settings = zr->jpg_settings;
891		891
892	/* jpg_buffers */	892	/* jpg_buffers */
893	memset(&fh->jpg_buffers, 0, sizeof(struct zoran_jpg_struct));	893	memset(&fh->jpg_buffers, 0, sizeof(struct zoran_jpg_struct));
894	for (i = 0; i < BUZ_MAX_FRAME; i++) {	894	for (i = 0; i < BUZ_MAX_FRAME; i++) {
895	fh->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */	895	fh->jpg_buffers.buffer[i].state = BUZ_STATE_USER; /* nothing going on */
896	fh->jpg_buffers.buffer[i].bs.frame = i;	896	fh->jpg_buffers.buffer[i].bs.frame = i;
897	}	897	}
898	fh->jpg_buffers.need_contiguous = zr->jpg_buffers.need_contiguous;	898	fh->jpg_buffers.need_contiguous = zr->jpg_buffers.need_contiguous;
899	fh->jpg_buffers.allocated = 0;	899	fh->jpg_buffers.allocated = 0;
900	fh->jpg_buffers.active = ZORAN_FREE;	900	fh->jpg_buffers.active = ZORAN_FREE;
901	fh->jpg_buffers.buffer_size = jpg_bufsize;	901	fh->jpg_buffers.buffer_size = jpg_bufsize;
902	fh->jpg_buffers.num_buffers = jpg_nbufs;	902	fh->jpg_buffers.num_buffers = jpg_nbufs;
903	}	903	}
904		904
905	static void	905	static void
906	zoran_close_end_session (struct file *file)	906	zoran_close_end_session (struct file *file)
907	{	907	{
908	struct zoran_fh *fh = file->private_data;	908	struct zoran_fh *fh = file->private_data;
909	struct zoran *zr = fh->zr;	909	struct zoran *zr = fh->zr;
910		910
911	/* overlay */	911	/* overlay */
912	if (fh->overlay_active != ZORAN_FREE) {	912	if (fh->overlay_active != ZORAN_FREE) {
913	fh->overlay_active = zr->overlay_active = ZORAN_FREE;	913	fh->overlay_active = zr->overlay_active = ZORAN_FREE;
914	zr->v4l_overlay_active = 0;	914	zr->v4l_overlay_active = 0;
915	if (!zr->v4l_memgrab_active)	915	if (!zr->v4l_memgrab_active)
916	zr36057_overlay(zr, 0);	916	zr36057_overlay(zr, 0);
917	zr->overlay_mask = NULL;	917	zr->overlay_mask = NULL;
918	}	918	}
919		919
920	/* v4l capture */	920	/* v4l capture */
921	if (fh->v4l_buffers.active != ZORAN_FREE) {	921	if (fh->v4l_buffers.active != ZORAN_FREE) {
922	unsigned long flags;	922	unsigned long flags;
923		923
924	spin_lock_irqsave(&zr->spinlock, flags);	924	spin_lock_irqsave(&zr->spinlock, flags);
925	zr36057_set_memgrab(zr, 0);	925	zr36057_set_memgrab(zr, 0);
926	zr->v4l_buffers.allocated = 0;	926	zr->v4l_buffers.allocated = 0;
927	zr->v4l_buffers.active = fh->v4l_buffers.active =	927	zr->v4l_buffers.active = fh->v4l_buffers.active =
928	ZORAN_FREE;	928	ZORAN_FREE;
929	spin_unlock_irqrestore(&zr->spinlock, flags);	929	spin_unlock_irqrestore(&zr->spinlock, flags);
930	}	930	}
931		931
932	/* v4l buffers */	932	/* v4l buffers */
933	if (fh->v4l_buffers.allocated)	933	if (fh->v4l_buffers.allocated)
934	v4l_fbuffer_free(file);	934	v4l_fbuffer_free(file);
935		935
936	/* jpg capture */	936	/* jpg capture */
937	if (fh->jpg_buffers.active != ZORAN_FREE) {	937	if (fh->jpg_buffers.active != ZORAN_FREE) {
938	zr36057_enable_jpg(zr, BUZ_MODE_IDLE);	938	zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
939	zr->jpg_buffers.allocated = 0;	939	zr->jpg_buffers.allocated = 0;
940	zr->jpg_buffers.active = fh->jpg_buffers.active =	940	zr->jpg_buffers.active = fh->jpg_buffers.active =
941	ZORAN_FREE;	941	ZORAN_FREE;
942	}	942	}
943		943
944	/* jpg buffers */	944	/* jpg buffers */
945	if (fh->jpg_buffers.allocated)	945	if (fh->jpg_buffers.allocated)
946	jpg_fbuffer_free(file);	946	jpg_fbuffer_free(file);
947	}	947	}
948		948
949	/*	949	/*
950	* Open a zoran card. Right now the flags stuff is just playing	950	* Open a zoran card. Right now the flags stuff is just playing
951	*/	951	*/
952		952
953	static int zoran_open(struct file *file)	953	static int zoran_open(struct file *file)
954	{	954	{
955	struct zoran *zr = video_drvdata(file);	955	struct zoran *zr = video_drvdata(file);
956	struct zoran_fh *fh;	956	struct zoran_fh *fh;
957	int res, first_open = 0;	957	int res, first_open = 0;
958		958
959	dprintk(2, KERN_INFO "%s: zoran_open(%s, pid=[%d]), users(-)=%d\n",	959	dprintk(2, KERN_INFO "%s: zoran_open(%s, pid=[%d]), users(-)=%d\n",
960	ZR_DEVNAME(zr), current->comm, task_pid_nr(current), zr->user + 1);	960	ZR_DEVNAME(zr), current->comm, task_pid_nr(current), zr->user + 1);
961		961
962	lock_kernel();	962	lock_kernel();
963		963
964	if (zr->user >= 2048) {	964	if (zr->user >= 2048) {
965	dprintk(1, KERN_ERR "%s: too many users (%d) on device\n",	965	dprintk(1, KERN_ERR "%s: too many users (%d) on device\n",
966	ZR_DEVNAME(zr), zr->user);	966	ZR_DEVNAME(zr), zr->user);
967	res = -EBUSY;	967	res = -EBUSY;
968	goto fail_unlock;	968	goto fail_unlock;
969	}	969	}
970		970
971	/* now, create the open()-specific file_ops struct */	971	/* now, create the open()-specific file_ops struct */
972	fh = kzalloc(sizeof(struct zoran_fh), GFP_KERNEL);	972	fh = kzalloc(sizeof(struct zoran_fh), GFP_KERNEL);
973	if (!fh) {	973	if (!fh) {
974	dprintk(1,	974	dprintk(1,
975	KERN_ERR	975	KERN_ERR
976	"%s: zoran_open() - allocation of zoran_fh failed\n",	976	"%s: zoran_open() - allocation of zoran_fh failed\n",
977	ZR_DEVNAME(zr));	977	ZR_DEVNAME(zr));
978	res = -ENOMEM;	978	res = -ENOMEM;
979	goto fail_unlock;	979	goto fail_unlock;
980	}	980	}
981	/* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows	981	/* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows
982	* on norm-change! */	982	* on norm-change! */
983	fh->overlay_mask =	983	fh->overlay_mask =
984	kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL);	984	kmalloc(((768 + 31) / 32) * 576 * 4, GFP_KERNEL);
985	if (!fh->overlay_mask) {	985	if (!fh->overlay_mask) {
986	dprintk(1,	986	dprintk(1,
987	KERN_ERR	987	KERN_ERR
988	"%s: zoran_open() - allocation of overlay_mask failed\n",	988	"%s: zoran_open() - allocation of overlay_mask failed\n",
989	ZR_DEVNAME(zr));	989	ZR_DEVNAME(zr));
990	res = -ENOMEM;	990	res = -ENOMEM;
991	goto fail_fh;	991	goto fail_fh;
992	}	992	}
993		993
994	if (zr->user++ == 0)	994	if (zr->user++ == 0)
995	first_open = 1;	995	first_open = 1;
996		996
997	/mutex_unlock(&zr->resource_lock);/	997	/mutex_unlock(&zr->resource_lock);/
998		998
999	/* default setup - TODO: look at flags */	999	/* default setup - TODO: look at flags */
1000	if (first_open) { /* First device open */	1000	if (first_open) { /* First device open */
1001	zr36057_restart(zr);	1001	zr36057_restart(zr);
1002	zoran_open_init_params(zr);	1002	zoran_open_init_params(zr);
1003	zoran_init_hardware(zr);	1003	zoran_init_hardware(zr);
1004		1004
1005	btor(ZR36057_ICR_IntPinEn, ZR36057_ICR);	1005	btor(ZR36057_ICR_IntPinEn, ZR36057_ICR);
1006	}	1006	}
1007		1007
1008	/* set file_ops stuff */	1008	/* set file_ops stuff */
1009	file->private_data = fh;	1009	file->private_data = fh;
1010	fh->zr = zr;	1010	fh->zr = zr;
1011	zoran_open_init_session(file);	1011	zoran_open_init_session(file);
1012	unlock_kernel();	1012	unlock_kernel();
1013		1013
1014	return 0;	1014	return 0;
1015		1015
1016	fail_fh:	1016	fail_fh:
1017	kfree(fh);	1017	kfree(fh);
1018	fail_unlock:	1018	fail_unlock:
1019	unlock_kernel();	1019	unlock_kernel();
1020		1020
1021	dprintk(2, KERN_INFO "%s: open failed (%d), users(-)=%d\n",	1021	dprintk(2, KERN_INFO "%s: open failed (%d), users(-)=%d\n",
1022	ZR_DEVNAME(zr), res, zr->user);	1022	ZR_DEVNAME(zr), res, zr->user);
1023		1023
1024	return res;	1024	return res;
1025	}	1025	}
1026		1026
1027	static int	1027	static int
1028	zoran_close(struct file *file)	1028	zoran_close(struct file *file)
1029	{	1029	{
1030	struct zoran_fh *fh = file->private_data;	1030	struct zoran_fh *fh = file->private_data;
1031	struct zoran *zr = fh->zr;	1031	struct zoran *zr = fh->zr;
1032		1032
1033	dprintk(2, KERN_INFO "%s: zoran_close(%s, pid=[%d]), users(+)=%d\n",	1033	dprintk(2, KERN_INFO "%s: zoran_close(%s, pid=[%d]), users(+)=%d\n",
1034	ZR_DEVNAME(zr), current->comm, task_pid_nr(current), zr->user - 1);	1034	ZR_DEVNAME(zr), current->comm, task_pid_nr(current), zr->user - 1);
1035		1035
1036	/* kernel locks (fs/device.c), so don't do that ourselves	1036	/* kernel locks (fs/device.c), so don't do that ourselves
1037	* (prevents deadlocks) */	1037	* (prevents deadlocks) */
1038	/mutex_lock(&zr->resource_lock);/	1038	/mutex_lock(&zr->resource_lock);/
1039		1039
1040	zoran_close_end_session(file);	1040	zoran_close_end_session(file);
1041		1041
1042	if (zr->user-- == 1) { /* Last process */	1042	if (zr->user-- == 1) { /* Last process */
1043	/* Clean up JPEG process */	1043	/* Clean up JPEG process */
1044	wake_up_interruptible(&zr->jpg_capq);	1044	wake_up_interruptible(&zr->jpg_capq);
1045	zr36057_enable_jpg(zr, BUZ_MODE_IDLE);	1045	zr36057_enable_jpg(zr, BUZ_MODE_IDLE);
1046	zr->jpg_buffers.allocated = 0;	1046	zr->jpg_buffers.allocated = 0;
1047	zr->jpg_buffers.active = ZORAN_FREE;	1047	zr->jpg_buffers.active = ZORAN_FREE;
1048		1048
1049	/* disable interrupts */	1049	/* disable interrupts */
1050	btand(~ZR36057_ICR_IntPinEn, ZR36057_ICR);	1050	btand(~ZR36057_ICR_IntPinEn, ZR36057_ICR);
1051		1051
1052	if (zr36067_debug > 1)	1052	if (zr36067_debug > 1)
1053	print_interrupts(zr);	1053	print_interrupts(zr);
1054		1054
1055	/* Overlay off */	1055	/* Overlay off */
1056	zr->v4l_overlay_active = 0;	1056	zr->v4l_overlay_active = 0;
1057	zr36057_overlay(zr, 0);	1057	zr36057_overlay(zr, 0);
1058	zr->overlay_mask = NULL;	1058	zr->overlay_mask = NULL;
1059		1059
1060	/* capture off */	1060	/* capture off */
1061	wake_up_interruptible(&zr->v4l_capq);	1061	wake_up_interruptible(&zr->v4l_capq);
1062	zr36057_set_memgrab(zr, 0);	1062	zr36057_set_memgrab(zr, 0);
1063	zr->v4l_buffers.allocated = 0;	1063	zr->v4l_buffers.allocated = 0;
1064	zr->v4l_buffers.active = ZORAN_FREE;	1064	zr->v4l_buffers.active = ZORAN_FREE;
1065	zoran_set_pci_master(zr, 0);	1065	zoran_set_pci_master(zr, 0);
1066		1066
1067	if (!pass_through) { /* Switch to color bar */	1067	if (!pass_through) { /* Switch to color bar */
1068	struct v4l2_routing route = { 2, 0 };	1068	struct v4l2_routing route = { 2, 0 };
1069		1069
1070	decoder_call(zr, video, s_stream, 0);	1070	decoder_call(zr, video, s_stream, 0);
1071	encoder_call(zr, video, s_routing, &route);	1071	encoder_call(zr, video, s_routing, &route);
1072	}	1072	}
1073	}	1073	}
1074		1074
1075	file->private_data = NULL;	1075	file->private_data = NULL;
1076	kfree(fh->overlay_mask);	1076	kfree(fh->overlay_mask);
1077	kfree(fh);	1077	kfree(fh);
1078		1078
1079	dprintk(4, KERN_INFO "%s: zoran_close() done\n", ZR_DEVNAME(zr));	1079	dprintk(4, KERN_INFO "%s: zoran_close() done\n", ZR_DEVNAME(zr));
1080		1080
1081	return 0;	1081	return 0;
1082	}	1082	}
1083		1083
1084		1084
1085	static ssize_t	1085	static ssize_t
1086	zoran_read (struct file *file,	1086	zoran_read (struct file *file,
1087	char __user *data,	1087	char __user *data,
1088	size_t count,	1088	size_t count,
1089	loff_t *ppos)	1089	loff_t *ppos)
1090	{	1090	{
1091	/* we simply don't support read() (yet)... */	1091	/* we simply don't support read() (yet)... */
1092		1092
1093	return -EINVAL;	1093	return -EINVAL;
1094	}	1094	}
1095		1095
1096	static ssize_t	1096	static ssize_t
1097	zoran_write (struct file *file,	1097	zoran_write (struct file *file,
1098	const char __user *data,	1098	const char __user *data,
1099	size_t count,	1099	size_t count,
1100	loff_t *ppos)	1100	loff_t *ppos)
1101	{	1101	{
1102	/* ...and the same goes for write() */	1102	/* ...and the same goes for write() */
1103		1103
1104	return -EINVAL;	1104	return -EINVAL;
1105	}	1105	}
1106		1106
1107	static int	1107	static int
1108	setup_fbuffer (struct file *file,	1108	setup_fbuffer (struct file *file,
1109	void *base,	1109	void *base,
1110	const struct zoran_format *fmt,	1110	const struct zoran_format *fmt,
1111	int width,	1111	int width,
1112	int height,	1112	int height,
1113	int bytesperline)	1113	int bytesperline)
1114	{	1114	{
1115	struct zoran_fh *fh = file->private_data;	1115	struct zoran_fh *fh = file->private_data;
1116	struct zoran *zr = fh->zr;	1116	struct zoran *zr = fh->zr;
1117		1117
1118	/* (Ronald) v4l/v4l2 guidelines */	1118	/* (Ronald) v4l/v4l2 guidelines */
1119	if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))	1119	if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
1120	return -EPERM;	1120	return -EPERM;
1121		1121
1122	/* Don't allow frame buffer overlay if PCI or AGP is buggy, or on	1122	/* Don't allow frame buffer overlay if PCI or AGP is buggy, or on
1123	ALi Magik (that needs very low latency while the card needs a	1123	ALi Magik (that needs very low latency while the card needs a
1124	higher value always) */	1124	higher value always) */
1125		1125
1126	if (pci_pci_problems & (PCIPCI_FAIL \| PCIAGP_FAIL \| PCIPCI_ALIMAGIK))	1126	if (pci_pci_problems & (PCIPCI_FAIL \| PCIAGP_FAIL \| PCIPCI_ALIMAGIK))
1127	return -ENXIO;	1127	return -ENXIO;
1128		1128
1129	/* we need a bytesperline value, even if not given */	1129	/* we need a bytesperline value, even if not given */
1130	if (!bytesperline)	1130	if (!bytesperline)
1131	bytesperline = width * ((fmt->depth + 7) & ~7) / 8;	1131	bytesperline = width * ((fmt->depth + 7) & ~7) / 8;
1132		1132
1133	#if 0	1133	#if 0
1134	if (zr->overlay_active) {	1134	if (zr->overlay_active) {
1135	/* dzjee... stupid users... don't even bother to turn off	1135	/* dzjee... stupid users... don't even bother to turn off
1136	* overlay before changing the memory location...	1136	* overlay before changing the memory location...
1137	* normally, we would return errors here. However, one of	1137	* normally, we would return errors here. However, one of
1138	* the tools that does this is... xawtv! and since xawtv	1138	* the tools that does this is... xawtv! and since xawtv
1139	* is used by +/- 99% of the users, we'd rather be user-	1139	* is used by +/- 99% of the users, we'd rather be user-
1140	* friendly and silently do as if nothing went wrong */	1140	* friendly and silently do as if nothing went wrong */
1141	dprintk(3,	1141	dprintk(3,
1142	KERN_ERR	1142	KERN_ERR
1143	"%s: setup_fbuffer() - forced overlay turnoff because framebuffer changed\n",	1143	"%s: setup_fbuffer() - forced overlay turnoff because framebuffer changed\n",
1144	ZR_DEVNAME(zr));	1144	ZR_DEVNAME(zr));
1145	zr36057_overlay(zr, 0);	1145	zr36057_overlay(zr, 0);
1146	}	1146	}
1147	#endif	1147	#endif
1148		1148
1149	if (!(fmt->flags & ZORAN_FORMAT_OVERLAY)) {	1149	if (!(fmt->flags & ZORAN_FORMAT_OVERLAY)) {
1150	dprintk(1,	1150	dprintk(1,
1151	KERN_ERR	1151	KERN_ERR
1152	"%s: setup_fbuffer() - no valid overlay format given\n",	1152	"%s: setup_fbuffer() - no valid overlay format given\n",
1153	ZR_DEVNAME(zr));	1153	ZR_DEVNAME(zr));
1154	return -EINVAL;	1154	return -EINVAL;
1155	}	1155	}
1156	if (height <= 0 \|\| width <= 0 \|\| bytesperline <= 0) {	1156	if (height <= 0 \|\| width <= 0 \|\| bytesperline <= 0) {
1157	dprintk(1,	1157	dprintk(1,
1158	KERN_ERR	1158	KERN_ERR
1159	"%s: setup_fbuffer() - invalid height/width/bpl value (%d\|%d\|%d)\n",	1159	"%s: setup_fbuffer() - invalid height/width/bpl value (%d\|%d\|%d)\n",
1160	ZR_DEVNAME(zr), width, height, bytesperline);	1160	ZR_DEVNAME(zr), width, height, bytesperline);
1161	return -EINVAL;	1161	return -EINVAL;
1162	}	1162	}
1163	if (bytesperline & 3) {	1163	if (bytesperline & 3) {
1164	dprintk(1,	1164	dprintk(1,
1165	KERN_ERR	1165	KERN_ERR
1166	"%s: setup_fbuffer() - bytesperline (%d) must be 4-byte aligned\n",	1166	"%s: setup_fbuffer() - bytesperline (%d) must be 4-byte aligned\n",
1167	ZR_DEVNAME(zr), bytesperline);	1167	ZR_DEVNAME(zr), bytesperline);
1168	return -EINVAL;	1168	return -EINVAL;
1169	}	1169	}
1170		1170
1171	zr->vbuf_base = (void *) ((unsigned long) base & ~3);	1171	zr->vbuf_base = (void *) ((unsigned long) base & ~3);
1172	zr->vbuf_height = height;	1172	zr->vbuf_height = height;
1173	zr->vbuf_width = width;	1173	zr->vbuf_width = width;
1174	zr->vbuf_depth = fmt->depth;	1174	zr->vbuf_depth = fmt->depth;
1175	zr->overlay_settings.format = fmt;	1175	zr->overlay_settings.format = fmt;
1176	zr->vbuf_bytesperline = bytesperline;	1176	zr->vbuf_bytesperline = bytesperline;
1177		1177
1178	/* The user should set new window parameters */	1178	/* The user should set new window parameters */
1179	zr->overlay_settings.is_set = 0;	1179	zr->overlay_settings.is_set = 0;
1180		1180
1181	return 0;	1181	return 0;
1182	}	1182	}
1183		1183
1184		1184
1185	static int	1185	static int
1186	setup_window (struct file *file,	1186	setup_window (struct file *file,
1187	int x,	1187	int x,
1188	int y,	1188	int y,
1189	int width,	1189	int width,
1190	int height,	1190	int height,
1191	struct v4l2_clip __user *clips,	1191	struct v4l2_clip __user *clips,
1192	int clipcount,	1192	int clipcount,
1193	void __user *bitmap)	1193	void __user *bitmap)
1194	{	1194	{
1195	struct zoran_fh *fh = file->private_data;	1195	struct zoran_fh *fh = file->private_data;
1196	struct zoran *zr = fh->zr;	1196	struct zoran *zr = fh->zr;
1197	struct v4l2_clip *vcp = NULL;	1197	struct v4l2_clip *vcp = NULL;
1198	int on, end;	1198	int on, end;
1199		1199
1200		1200
1201	if (!zr->vbuf_base) {	1201	if (!zr->vbuf_base) {
1202	dprintk(1,	1202	dprintk(1,
1203	KERN_ERR	1203	KERN_ERR
1204	"%s: setup_window() - frame buffer has to be set first\n",	1204	"%s: setup_window() - frame buffer has to be set first\n",
1205	ZR_DEVNAME(zr));	1205	ZR_DEVNAME(zr));
1206	return -EINVAL;	1206	return -EINVAL;
1207	}	1207	}
1208		1208
1209	if (!fh->overlay_settings.format) {	1209	if (!fh->overlay_settings.format) {
1210	dprintk(1,	1210	dprintk(1,
1211	KERN_ERR	1211	KERN_ERR
1212	"%s: setup_window() - no overlay format set\n",	1212	"%s: setup_window() - no overlay format set\n",
1213	ZR_DEVNAME(zr));	1213	ZR_DEVNAME(zr));
1214	return -EINVAL;	1214	return -EINVAL;
1215	}	1215	}
1216		1216
1217	/*	1217	/*
1218	* The video front end needs 4-byte alinged line sizes, we correct that	1218	* The video front end needs 4-byte alinged line sizes, we correct that
1219	* silently here if necessary	1219	* silently here if necessary
1220	*/	1220	*/
1221	if (zr->vbuf_depth == 15 \|\| zr->vbuf_depth == 16) {	1221	if (zr->vbuf_depth == 15 \|\| zr->vbuf_depth == 16) {
1222	end = (x + width) & ~1; /* round down */	1222	end = (x + width) & ~1; /* round down */
1223	x = (x + 1) & ~1; /* round up */	1223	x = (x + 1) & ~1; /* round up */
1224	width = end - x;	1224	width = end - x;
1225	}	1225	}
1226		1226
1227	if (zr->vbuf_depth == 24) {	1227	if (zr->vbuf_depth == 24) {
1228	end = (x + width) & ~3; /* round down */	1228	end = (x + width) & ~3; /* round down */
1229	x = (x + 3) & ~3; /* round up */	1229	x = (x + 3) & ~3; /* round up */
1230	width = end - x;	1230	width = end - x;
1231	}	1231	}
1232		1232
1233	if (width > BUZ_MAX_WIDTH)	1233	if (width > BUZ_MAX_WIDTH)
1234	width = BUZ_MAX_WIDTH;	1234	width = BUZ_MAX_WIDTH;
1235	if (height > BUZ_MAX_HEIGHT)	1235	if (height > BUZ_MAX_HEIGHT)
1236	height = BUZ_MAX_HEIGHT;	1236	height = BUZ_MAX_HEIGHT;
1237		1237
1238	/* Check for vaild parameters */	1238	/* Check for vaild parameters */
1239	if (width < BUZ_MIN_WIDTH \|\| height < BUZ_MIN_HEIGHT \|\|	1239	if (width < BUZ_MIN_WIDTH \|\| height < BUZ_MIN_HEIGHT \|\|
1240	width > BUZ_MAX_WIDTH \|\| height > BUZ_MAX_HEIGHT) {	1240	width > BUZ_MAX_WIDTH \|\| height > BUZ_MAX_HEIGHT) {
1241	dprintk(1,	1241	dprintk(1,
1242	KERN_ERR	1242	KERN_ERR
1243	"%s: setup_window() - width = %d or height = %d invalid\n",	1243	"%s: setup_window() - width = %d or height = %d invalid\n",
1244	ZR_DEVNAME(zr), width, height);	1244	ZR_DEVNAME(zr), width, height);
1245	return -EINVAL;	1245	return -EINVAL;
1246	}	1246	}
1247		1247
1248	fh->overlay_settings.x = x;	1248	fh->overlay_settings.x = x;
1249	fh->overlay_settings.y = y;	1249	fh->overlay_settings.y = y;
1250	fh->overlay_settings.width = width;	1250	fh->overlay_settings.width = width;
1251	fh->overlay_settings.height = height;	1251	fh->overlay_settings.height = height;
1252	fh->overlay_settings.clipcount = clipcount;	1252	fh->overlay_settings.clipcount = clipcount;
1253		1253
1254	/*	1254	/*
1255	* If an overlay is running, we have to switch it off	1255	* If an overlay is running, we have to switch it off
1256	* and switch it on again in order to get the new settings in effect.	1256	* and switch it on again in order to get the new settings in effect.
1257	*	1257	*
1258	* We also want to avoid that the overlay mask is written	1258	* We also want to avoid that the overlay mask is written
1259	* when an overlay is running.	1259	* when an overlay is running.
1260	*/	1260	*/
1261		1261
1262	on = zr->v4l_overlay_active && !zr->v4l_memgrab_active &&	1262	on = zr->v4l_overlay_active && !zr->v4l_memgrab_active &&
1263	zr->overlay_active != ZORAN_FREE &&	1263	zr->overlay_active != ZORAN_FREE &&
1264	fh->overlay_active != ZORAN_FREE;	1264	fh->overlay_active != ZORAN_FREE;
1265	if (on)	1265	if (on)
1266	zr36057_overlay(zr, 0);	1266	zr36057_overlay(zr, 0);
1267		1267
1268	/*	1268	/*
1269	* Write the overlay mask if clips are wanted.	1269	* Write the overlay mask if clips are wanted.
1270	* We prefer a bitmap.	1270	* We prefer a bitmap.
1271	*/	1271	*/
1272	if (bitmap) {	1272	if (bitmap) {
1273	/* fake value - it just means we want clips */	1273	/* fake value - it just means we want clips */
1274	fh->overlay_settings.clipcount = 1;	1274	fh->overlay_settings.clipcount = 1;
1275		1275
1276	if (copy_from_user(fh->overlay_mask, bitmap,	1276	if (copy_from_user(fh->overlay_mask, bitmap,
1277	(width * height + 7) / 8)) {	1277	(width * height + 7) / 8)) {
1278	return -EFAULT;	1278	return -EFAULT;
1279	}	1279	}
1280	} else if (clipcount > 0) {	1280	} else if (clipcount > 0) {
1281	/* write our own bitmap from the clips */	1281	/* write our own bitmap from the clips */
1282	vcp = vmalloc(sizeof(struct v4l2_clip) * (clipcount + 4));	1282	vcp = vmalloc(sizeof(struct v4l2_clip) * (clipcount + 4));
1283	if (vcp == NULL) {	1283	if (vcp == NULL) {
1284	dprintk(1,	1284	dprintk(1,
1285	KERN_ERR	1285	KERN_ERR
1286	"%s: setup_window() - Alloc of clip mask failed\n",	1286	"%s: setup_window() - Alloc of clip mask failed\n",
1287	ZR_DEVNAME(zr));	1287	ZR_DEVNAME(zr));
1288	return -ENOMEM;	1288	return -ENOMEM;
1289	}	1289	}
1290	if (copy_from_user	1290	if (copy_from_user
1291	(vcp, clips, sizeof(struct v4l2_clip) * clipcount)) {	1291	(vcp, clips, sizeof(struct v4l2_clip) * clipcount)) {
1292	vfree(vcp);	1292	vfree(vcp);
1293	return -EFAULT;	1293	return -EFAULT;
1294	}	1294	}
1295	write_overlay_mask(file, vcp, clipcount);	1295	write_overlay_mask(file, vcp, clipcount);
1296	vfree(vcp);	1296	vfree(vcp);
1297	}	1297	}
1298		1298
1299	fh->overlay_settings.is_set = 1;	1299	fh->overlay_settings.is_set = 1;
1300	if (fh->overlay_active != ZORAN_FREE &&	1300	if (fh->overlay_active != ZORAN_FREE &&
1301	zr->overlay_active != ZORAN_FREE)	1301	zr->overlay_active != ZORAN_FREE)
1302	zr->overlay_settings = fh->overlay_settings;	1302	zr->overlay_settings = fh->overlay_settings;
1303		1303
1304	if (on)	1304	if (on)
1305	zr36057_overlay(zr, 1);	1305	zr36057_overlay(zr, 1);
1306		1306
1307	/* Make sure the changes come into effect */	1307	/* Make sure the changes come into effect */
1308	return wait_grab_pending(zr);	1308	return wait_grab_pending(zr);
1309	}	1309	}
1310		1310
1311	static int	1311	static int
1312	setup_overlay (struct file *file,	1312	setup_overlay (struct file *file,
1313	int on)	1313	int on)
1314	{	1314	{
1315	struct zoran_fh *fh = file->private_data;	1315	struct zoran_fh *fh = file->private_data;
1316	struct zoran *zr = fh->zr;	1316	struct zoran *zr = fh->zr;
1317		1317
1318	/* If there is nothing to do, return immediatly */	1318	/* If there is nothing to do, return immediatly */
1319	if ((on && fh->overlay_active != ZORAN_FREE) \|\|	1319	if ((on && fh->overlay_active != ZORAN_FREE) \|\|
1320	(!on && fh->overlay_active == ZORAN_FREE))	1320	(!on && fh->overlay_active == ZORAN_FREE))
1321	return 0;	1321	return 0;
1322		1322
1323	/* check whether we're touching someone else's overlay */	1323	/* check whether we're touching someone else's overlay */
1324	if (on && zr->overlay_active != ZORAN_FREE &&	1324	if (on && zr->overlay_active != ZORAN_FREE &&
1325	fh->overlay_active == ZORAN_FREE) {	1325	fh->overlay_active == ZORAN_FREE) {
1326	dprintk(1,	1326	dprintk(1,
1327	KERN_ERR	1327	KERN_ERR
1328	"%s: setup_overlay() - overlay is already active for another session\n",	1328	"%s: setup_overlay() - overlay is already active for another session\n",
1329	ZR_DEVNAME(zr));	1329	ZR_DEVNAME(zr));
1330	return -EBUSY;	1330	return -EBUSY;
1331	}	1331	}
1332	if (!on && zr->overlay_active != ZORAN_FREE &&	1332	if (!on && zr->overlay_active != ZORAN_FREE &&
1333	fh->overlay_active == ZORAN_FREE) {	1333	fh->overlay_active == ZORAN_FREE) {
1334	dprintk(1,	1334	dprintk(1,
1335	KERN_ERR	1335	KERN_ERR
1336	"%s: setup_overlay() - you cannot cancel someone else's session\n",	1336	"%s: setup_overlay() - you cannot cancel someone else's session\n",
1337	ZR_DEVNAME(zr));	1337	ZR_DEVNAME(zr));
1338	return -EPERM;	1338	return -EPERM;
1339	}	1339	}
1340		1340
1341	if (on == 0) {	1341	if (on == 0) {
1342	zr->overlay_active = fh->overlay_active = ZORAN_FREE;	1342	zr->overlay_active = fh->overlay_active = ZORAN_FREE;
1343	zr->v4l_overlay_active = 0;	1343	zr->v4l_overlay_active = 0;
1344	/* When a grab is running, the video simply	1344	/* When a grab is running, the video simply
1345	* won't be switched on any more */	1345	* won't be switched on any more */
1346	if (!zr->v4l_memgrab_active)	1346	if (!zr->v4l_memgrab_active)
1347	zr36057_overlay(zr, 0);	1347	zr36057_overlay(zr, 0);
1348	zr->overlay_mask = NULL;	1348	zr->overlay_mask = NULL;
1349	} else {	1349	} else {
1350	if (!zr->vbuf_base \|\| !fh->overlay_settings.is_set) {	1350	if (!zr->vbuf_base \|\| !fh->overlay_settings.is_set) {
1351	dprintk(1,	1351	dprintk(1,
1352	KERN_ERR	1352	KERN_ERR
1353	"%s: setup_overlay() - buffer or window not set\n",	1353	"%s: setup_overlay() - buffer or window not set\n",
1354	ZR_DEVNAME(zr));	1354	ZR_DEVNAME(zr));
1355	return -EINVAL;	1355	return -EINVAL;
1356	}	1356	}
1357	if (!fh->overlay_settings.format) {	1357	if (!fh->overlay_settings.format) {
1358	dprintk(1,	1358	dprintk(1,
1359	KERN_ERR	1359	KERN_ERR
1360	"%s: setup_overlay() - no overlay format set\n",	1360	"%s: setup_overlay() - no overlay format set\n",
1361	ZR_DEVNAME(zr));	1361	ZR_DEVNAME(zr));
1362	return -EINVAL;	1362	return -EINVAL;
1363	}	1363	}
1364	zr->overlay_active = fh->overlay_active = ZORAN_LOCKED;	1364	zr->overlay_active = fh->overlay_active = ZORAN_LOCKED;
1365	zr->v4l_overlay_active = 1;	1365	zr->v4l_overlay_active = 1;
1366	zr->overlay_mask = fh->overlay_mask;	1366	zr->overlay_mask = fh->overlay_mask;
1367	zr->overlay_settings = fh->overlay_settings;	1367	zr->overlay_settings = fh->overlay_settings;
1368	if (!zr->v4l_memgrab_active)	1368	if (!zr->v4l_memgrab_active)
1369	zr36057_overlay(zr, 1);	1369	zr36057_overlay(zr, 1);
1370	/* When a grab is running, the video will be	1370	/* When a grab is running, the video will be
1371	* switched on when grab is finished */	1371	* switched on when grab is finished */
1372	}	1372	}
1373		1373
1374	/* Make sure the changes come into effect */	1374	/* Make sure the changes come into effect */
1375	return wait_grab_pending(zr);	1375	return wait_grab_pending(zr);
1376	}	1376	}
1377		1377
1378	/* get the status of a buffer in the clients buffer queue */	1378	/* get the status of a buffer in the clients buffer queue */
1379	static int	1379	static int
1380	zoran_v4l2_buffer_status (struct zoran_fh *fh,	1380	zoran_v4l2_buffer_status (struct zoran_fh *fh,
1381	struct v4l2_buffer *buf,	1381	struct v4l2_buffer *buf,
1382	int num)	1382	int num)
1383	{	1383	{
1384	struct zoran *zr = fh->zr;	1384	struct zoran *zr = fh->zr;
1385		1385
1386	buf->flags = V4L2_BUF_FLAG_MAPPED;	1386	buf->flags = V4L2_BUF_FLAG_MAPPED;
1387		1387
1388	switch (fh->map_mode) {	1388	switch (fh->map_mode) {
1389	case ZORAN_MAP_MODE_RAW:	1389	case ZORAN_MAP_MODE_RAW:
1390		1390
1391	/* check range */	1391	/* check range */
1392	if (num < 0 \|\| num >= fh->v4l_buffers.num_buffers \|\|	1392	if (num < 0 \|\| num >= fh->v4l_buffers.num_buffers \|\|
1393	!fh->v4l_buffers.allocated) {	1393	!fh->v4l_buffers.allocated) {
1394	dprintk(1,	1394	dprintk(1,
1395	KERN_ERR	1395	KERN_ERR
1396	"%s: v4l2_buffer_status() - wrong number or buffers not allocated\n",	1396	"%s: v4l2_buffer_status() - wrong number or buffers not allocated\n",
1397	ZR_DEVNAME(zr));	1397	ZR_DEVNAME(zr));
1398	return -EINVAL;	1398	return -EINVAL;
1399	}	1399	}
1400		1400
1401	buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	1401	buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1402	buf->length = fh->v4l_buffers.buffer_size;	1402	buf->length = fh->v4l_buffers.buffer_size;
1403		1403
1404	/* get buffer */	1404	/* get buffer */
1405	buf->bytesused = fh->v4l_buffers.buffer[num].bs.length;	1405	buf->bytesused = fh->v4l_buffers.buffer[num].bs.length;
1406	if (fh->v4l_buffers.buffer[num].state == BUZ_STATE_DONE \|\|	1406	if (fh->v4l_buffers.buffer[num].state == BUZ_STATE_DONE \|\|
1407	fh->v4l_buffers.buffer[num].state == BUZ_STATE_USER) {	1407	fh->v4l_buffers.buffer[num].state == BUZ_STATE_USER) {
1408	buf->sequence = fh->v4l_buffers.buffer[num].bs.seq;	1408	buf->sequence = fh->v4l_buffers.buffer[num].bs.seq;
1409	buf->flags \|= V4L2_BUF_FLAG_DONE;	1409	buf->flags \|= V4L2_BUF_FLAG_DONE;
1410	buf->timestamp =	1410	buf->timestamp =
1411	fh->v4l_buffers.buffer[num].bs.timestamp;	1411	fh->v4l_buffers.buffer[num].bs.timestamp;
1412	} else {	1412	} else {
1413	buf->flags \|= V4L2_BUF_FLAG_QUEUED;	1413	buf->flags \|= V4L2_BUF_FLAG_QUEUED;
1414	}	1414	}
1415		1415
1416	if (fh->v4l_settings.height <= BUZ_MAX_HEIGHT / 2)	1416	if (fh->v4l_settings.height <= BUZ_MAX_HEIGHT / 2)
1417	buf->field = V4L2_FIELD_TOP;	1417	buf->field = V4L2_FIELD_TOP;
1418	else	1418	else
1419	buf->field = V4L2_FIELD_INTERLACED;	1419	buf->field = V4L2_FIELD_INTERLACED;
1420		1420
1421	break;	1421	break;
1422		1422
1423	case ZORAN_MAP_MODE_JPG_REC:	1423	case ZORAN_MAP_MODE_JPG_REC:
1424	case ZORAN_MAP_MODE_JPG_PLAY:	1424	case ZORAN_MAP_MODE_JPG_PLAY:
1425		1425
1426	/* check range */	1426	/* check range */
1427	if (num < 0 \|\| num >= fh->jpg_buffers.num_buffers \|\|	1427	if (num < 0 \|\| num >= fh->jpg_buffers.num_buffers \|\|
1428	!fh->jpg_buffers.allocated) {	1428	!fh->jpg_buffers.allocated) {
1429	dprintk(1,	1429	dprintk(1,
1430	KERN_ERR	1430	KERN_ERR
1431	"%s: v4l2_buffer_status() - wrong number or buffers not allocated\n",	1431	"%s: v4l2_buffer_status() - wrong number or buffers not allocated\n",
1432	ZR_DEVNAME(zr));	1432	ZR_DEVNAME(zr));
1433	return -EINVAL;	1433	return -EINVAL;
1434	}	1434	}
1435		1435
1436	buf->type = (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ?	1436	buf->type = (fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ?
1437	V4L2_BUF_TYPE_VIDEO_CAPTURE :	1437	V4L2_BUF_TYPE_VIDEO_CAPTURE :
1438	V4L2_BUF_TYPE_VIDEO_OUTPUT;	1438	V4L2_BUF_TYPE_VIDEO_OUTPUT;
1439	buf->length = fh->jpg_buffers.buffer_size;	1439	buf->length = fh->jpg_buffers.buffer_size;
1440		1440
1441	/* these variables are only written after frame has been captured */	1441	/* these variables are only written after frame has been captured */
1442	if (fh->jpg_buffers.buffer[num].state == BUZ_STATE_DONE \|\|	1442	if (fh->jpg_buffers.buffer[num].state == BUZ_STATE_DONE \|\|
1443	fh->jpg_buffers.buffer[num].state == BUZ_STATE_USER) {	1443	fh->jpg_buffers.buffer[num].state == BUZ_STATE_USER) {
1444	buf->sequence = fh->jpg_buffers.buffer[num].bs.seq;	1444	buf->sequence = fh->jpg_buffers.buffer[num].bs.seq;
1445	buf->timestamp =	1445	buf->timestamp =
1446	fh->jpg_buffers.buffer[num].bs.timestamp;	1446	fh->jpg_buffers.buffer[num].bs.timestamp;
1447	buf->bytesused =	1447	buf->bytesused =
1448	fh->jpg_buffers.buffer[num].bs.length;	1448	fh->jpg_buffers.buffer[num].bs.length;
1449	buf->flags \|= V4L2_BUF_FLAG_DONE;	1449	buf->flags \|= V4L2_BUF_FLAG_DONE;
1450	} else {	1450	} else {
1451	buf->flags \|= V4L2_BUF_FLAG_QUEUED;	1451	buf->flags \|= V4L2_BUF_FLAG_QUEUED;
1452	}	1452	}
1453		1453
1454	/* which fields are these? */	1454	/* which fields are these? */
1455	if (fh->jpg_settings.TmpDcm != 1)	1455	if (fh->jpg_settings.TmpDcm != 1)
1456	buf->field =	1456	buf->field =
1457	fh->jpg_settings.	1457	fh->jpg_settings.
1458	odd_even ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM;	1458	odd_even ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM;
1459	else	1459	else
1460	buf->field =	1460	buf->field =
1461	fh->jpg_settings.	1461	fh->jpg_settings.
1462	odd_even ? V4L2_FIELD_SEQ_TB :	1462	odd_even ? V4L2_FIELD_SEQ_TB :
1463	V4L2_FIELD_SEQ_BT;	1463	V4L2_FIELD_SEQ_BT;
1464		1464
1465	break;	1465	break;
1466		1466
1467	default:	1467	default:
1468		1468
1469	dprintk(5,	1469	dprintk(5,
1470	KERN_ERR	1470	KERN_ERR
1471	"%s: v4l2_buffer_status() - invalid buffer type\|map_mode (%d\|%d)\n",	1471	"%s: v4l2_buffer_status() - invalid buffer type\|map_mode (%d\|%d)\n",
1472	ZR_DEVNAME(zr), buf->type, fh->map_mode);	1472	ZR_DEVNAME(zr), buf->type, fh->map_mode);
1473	return -EINVAL;	1473	return -EINVAL;
1474	}	1474	}
1475		1475
1476	buf->memory = V4L2_MEMORY_MMAP;	1476	buf->memory = V4L2_MEMORY_MMAP;
1477	buf->index = num;	1477	buf->index = num;
1478	buf->m.offset = buf->length * num;	1478	buf->m.offset = buf->length * num;
1479		1479
1480	return 0;	1480	return 0;
1481	}	1481	}
1482		1482
1483	static int	1483	static int
1484	zoran_set_norm (struct zoran *zr,	1484	zoran_set_norm (struct zoran *zr,
1485	v4l2_std_id norm)	1485	v4l2_std_id norm)
1486	{	1486	{
1487	int on;	1487	int on;
1488		1488
1489	if (zr->v4l_buffers.active != ZORAN_FREE \|\|	1489	if (zr->v4l_buffers.active != ZORAN_FREE \|\|
1490	zr->jpg_buffers.active != ZORAN_FREE) {	1490	zr->jpg_buffers.active != ZORAN_FREE) {
1491	dprintk(1,	1491	dprintk(1,
1492	KERN_WARNING	1492	KERN_WARNING
1493	"%s: set_norm() called while in playback/capture mode\n",	1493	"%s: set_norm() called while in playback/capture mode\n",
1494	ZR_DEVNAME(zr));	1494	ZR_DEVNAME(zr));
1495	return -EBUSY;	1495	return -EBUSY;
1496	}	1496	}
1497		1497
1498	if (lock_norm && norm != zr->norm) {	1498	if (lock_norm && norm != zr->norm) {
1499	if (lock_norm > 1) {	1499	if (lock_norm > 1) {
1500	dprintk(1,	1500	dprintk(1,
1501	KERN_WARNING	1501	KERN_WARNING
1502	"%s: set_norm() - TV standard is locked, can not switch norm\n",	1502	"%s: set_norm() - TV standard is locked, can not switch norm\n",
1503	ZR_DEVNAME(zr));	1503	ZR_DEVNAME(zr));
1504	return -EPERM;	1504	return -EPERM;
1505	} else {	1505	} else {
1506	dprintk(1,	1506	dprintk(1,
1507	KERN_WARNING	1507	KERN_WARNING
1508	"%s: set_norm() - TV standard is locked, norm was not changed\n",	1508	"%s: set_norm() - TV standard is locked, norm was not changed\n",
1509	ZR_DEVNAME(zr));	1509	ZR_DEVNAME(zr));
1510	norm = zr->norm;	1510	norm = zr->norm;
1511	}	1511	}
1512	}	1512	}
1513		1513
1514	if (!(norm & zr->card.norms)) {	1514	if (!(norm & zr->card.norms)) {
1515	dprintk(1,	1515	dprintk(1,
1516	KERN_ERR "%s: set_norm() - unsupported norm %llx\n",	1516	KERN_ERR "%s: set_norm() - unsupported norm %llx\n",
1517	ZR_DEVNAME(zr), norm);	1517	ZR_DEVNAME(zr), norm);
1518	return -EINVAL;	1518	return -EINVAL;
1519	}	1519	}
1520		1520
1521	if (norm == V4L2_STD_ALL) {	1521	if (norm == V4L2_STD_ALL) {
1522	int status = 0;	1522	int status = 0;
1523	v4l2_std_id std = 0;	1523	v4l2_std_id std = 0;
1524		1524
1525	decoder_call(zr, video, querystd, &std);	1525	decoder_call(zr, video, querystd, &std);
1526	decoder_s_std(zr, std);	1526	decoder_s_std(zr, std);
1527		1527
1528	/* let changes come into effect */	1528	/* let changes come into effect */
1529	ssleep(2);	1529	ssleep(2);
1530		1530
1531	decoder_call(zr, video, g_input_status, &status);	1531	decoder_call(zr, video, g_input_status, &status);
1532	if (status & V4L2_IN_ST_NO_SIGNAL) {	1532	if (status & V4L2_IN_ST_NO_SIGNAL) {
1533	dprintk(1,	1533	dprintk(1,
1534	KERN_ERR	1534	KERN_ERR
1535	"%s: set_norm() - no norm detected\n",	1535	"%s: set_norm() - no norm detected\n",
1536	ZR_DEVNAME(zr));	1536	ZR_DEVNAME(zr));
1537	/* reset norm */	1537	/* reset norm */
1538	decoder_s_std(zr, zr->norm);	1538	decoder_s_std(zr, zr->norm);
1539	return -EIO;	1539	return -EIO;
1540	}	1540	}
1541		1541
1542	norm = std;	1542	norm = std;
1543	}	1543	}
1544	if (norm & V4L2_STD_SECAM)	1544	if (norm & V4L2_STD_SECAM)
1545	zr->timing = zr->card.tvn[2];	1545	zr->timing = zr->card.tvn[2];
1546	else if (norm & V4L2_STD_NTSC)	1546	else if (norm & V4L2_STD_NTSC)
1547	zr->timing = zr->card.tvn[1];	1547	zr->timing = zr->card.tvn[1];
1548	else	1548	else
1549	zr->timing = zr->card.tvn[0];	1549	zr->timing = zr->card.tvn[0];
1550		1550
1551	/* We switch overlay off and on since a change in the	1551	/* We switch overlay off and on since a change in the
1552	* norm needs different VFE settings */	1552	* norm needs different VFE settings */
1553	on = zr->overlay_active && !zr->v4l_memgrab_active;	1553	on = zr->overlay_active && !zr->v4l_memgrab_active;
1554	if (on)	1554	if (on)
1555	zr36057_overlay(zr, 0);	1555	zr36057_overlay(zr, 0);
1556		1556
1557	decoder_s_std(zr, norm);	1557	decoder_s_std(zr, norm);
1558	encoder_call(zr, video, s_std_output, norm);	1558	encoder_call(zr, video, s_std_output, norm);
1559		1559
1560	if (on)	1560	if (on)
1561	zr36057_overlay(zr, 1);	1561	zr36057_overlay(zr, 1);
1562		1562
1563	/* Make sure the changes come into effect */	1563	/* Make sure the changes come into effect */
1564	zr->norm = norm;	1564	zr->norm = norm;
1565		1565
1566	return 0;	1566	return 0;
1567	}	1567	}
1568		1568
1569	static int	1569	static int
1570	zoran_set_input (struct zoran *zr,	1570	zoran_set_input (struct zoran *zr,
1571	int input)	1571	int input)
1572	{	1572	{
1573	struct v4l2_routing route = { 0, 0 };	1573	struct v4l2_routing route = { 0, 0 };
1574		1574
1575	if (input == zr->input) {	1575	if (input == zr->input) {
1576	return 0;	1576	return 0;
1577	}	1577	}
1578		1578
1579	if (zr->v4l_buffers.active != ZORAN_FREE \|\|	1579	if (zr->v4l_buffers.active != ZORAN_FREE \|\|
1580	zr->jpg_buffers.active != ZORAN_FREE) {	1580	zr->jpg_buffers.active != ZORAN_FREE) {
1581	dprintk(1,	1581	dprintk(1,
1582	KERN_WARNING	1582	KERN_WARNING
1583	"%s: set_input() called while in playback/capture mode\n",	1583	"%s: set_input() called while in playback/capture mode\n",
1584	ZR_DEVNAME(zr));	1584	ZR_DEVNAME(zr));
1585	return -EBUSY;	1585	return -EBUSY;
1586	}	1586	}
1587		1587
1588	if (input < 0 \|\| input >= zr->card.inputs) {	1588	if (input < 0 \|\| input >= zr->card.inputs) {
1589	dprintk(1,	1589	dprintk(1,
1590	KERN_ERR	1590	KERN_ERR
1591	"%s: set_input() - unnsupported input %d\n",	1591	"%s: set_input() - unnsupported input %d\n",
1592	ZR_DEVNAME(zr), input);	1592	ZR_DEVNAME(zr), input);
1593	return -EINVAL;	1593	return -EINVAL;
1594	}	1594	}
1595		1595
1596	route.input = zr->card.input[input].muxsel;	1596	route.input = zr->card.input[input].muxsel;
1597	zr->input = input;	1597	zr->input = input;
1598		1598
1599	decoder_s_routing(zr, &route);	1599	decoder_s_routing(zr, &route);
1600		1600
1601	return 0;	1601	return 0;
1602	}	1602	}
1603		1603
1604	/*	1604	/*
1605	* ioctl routine	1605	* ioctl routine
1606	*/	1606	*/
1607		1607
1608	#ifdef CONFIG_VIDEO_V4L1_COMPAT	1608	#ifdef CONFIG_VIDEO_V4L1_COMPAT
1609	static long zoran_default(struct file file, void __fh, int cmd, void *arg)	1609	static long zoran_default(struct file file, void __fh, int cmd, void *arg)
1610	{	1610	{
1611	struct zoran_fh *fh = __fh;	1611	struct zoran_fh *fh = __fh;
1612	struct zoran *zr = fh->zr;	1612	struct zoran *zr = fh->zr;
1613	struct zoran_jpg_settings settings;	1613	struct zoran_jpg_settings settings;
1614		1614
1615	switch (cmd) {	1615	switch (cmd) {
1616	case BUZIOC_G_PARAMS:	1616	case BUZIOC_G_PARAMS:
1617	{	1617	{
1618	struct zoran_params *bparams = arg;	1618	struct zoran_params *bparams = arg;
1619		1619
1620	dprintk(3, KERN_DEBUG "%s: BUZIOC_G_PARAMS\n", ZR_DEVNAME(zr));	1620	dprintk(3, KERN_DEBUG "%s: BUZIOC_G_PARAMS\n", ZR_DEVNAME(zr));
1621		1621
1622	memset(bparams, 0, sizeof(struct zoran_params));	1622	memset(bparams, 0, sizeof(struct zoran_params));
1623	bparams->major_version = MAJOR_VERSION;	1623	bparams->major_version = MAJOR_VERSION;
1624	bparams->minor_version = MINOR_VERSION;	1624	bparams->minor_version = MINOR_VERSION;
1625		1625
1626	mutex_lock(&zr->resource_lock);	1626	mutex_lock(&zr->resource_lock);
1627		1627
1628	if (zr->norm & V4L2_STD_NTSC)	1628	if (zr->norm & V4L2_STD_NTSC)
1629	bparams->norm = VIDEO_MODE_NTSC;	1629	bparams->norm = VIDEO_MODE_NTSC;
1630	else if (zr->norm & V4L2_STD_PAL)	1630	else if (zr->norm & V4L2_STD_PAL)
1631	bparams->norm = VIDEO_MODE_PAL;	1631	bparams->norm = VIDEO_MODE_PAL;
1632	else	1632	else
1633	bparams->norm = VIDEO_MODE_SECAM;	1633	bparams->norm = VIDEO_MODE_SECAM;
1634		1634
1635	bparams->input = zr->input;	1635	bparams->input = zr->input;
1636		1636
1637	bparams->decimation = fh->jpg_settings.decimation;	1637	bparams->decimation = fh->jpg_settings.decimation;
1638	bparams->HorDcm = fh->jpg_settings.HorDcm;	1638	bparams->HorDcm = fh->jpg_settings.HorDcm;
1639	bparams->VerDcm = fh->jpg_settings.VerDcm;	1639	bparams->VerDcm = fh->jpg_settings.VerDcm;
1640	bparams->TmpDcm = fh->jpg_settings.TmpDcm;	1640	bparams->TmpDcm = fh->jpg_settings.TmpDcm;
1641	bparams->field_per_buff = fh->jpg_settings.field_per_buff;	1641	bparams->field_per_buff = fh->jpg_settings.field_per_buff;
1642	bparams->img_x = fh->jpg_settings.img_x;	1642	bparams->img_x = fh->jpg_settings.img_x;
1643	bparams->img_y = fh->jpg_settings.img_y;	1643	bparams->img_y = fh->jpg_settings.img_y;
1644	bparams->img_width = fh->jpg_settings.img_width;	1644	bparams->img_width = fh->jpg_settings.img_width;
1645	bparams->img_height = fh->jpg_settings.img_height;	1645	bparams->img_height = fh->jpg_settings.img_height;
1646	bparams->odd_even = fh->jpg_settings.odd_even;	1646	bparams->odd_even = fh->jpg_settings.odd_even;
1647		1647
1648	bparams->quality = fh->jpg_settings.jpg_comp.quality;	1648	bparams->quality = fh->jpg_settings.jpg_comp.quality;
1649	bparams->APPn = fh->jpg_settings.jpg_comp.APPn;	1649	bparams->APPn = fh->jpg_settings.jpg_comp.APPn;
1650	bparams->APP_len = fh->jpg_settings.jpg_comp.APP_len;	1650	bparams->APP_len = fh->jpg_settings.jpg_comp.APP_len;
1651	memcpy(bparams->APP_data,	1651	memcpy(bparams->APP_data,
1652	fh->jpg_settings.jpg_comp.APP_data,	1652	fh->jpg_settings.jpg_comp.APP_data,
1653	sizeof(bparams->APP_data));	1653	sizeof(bparams->APP_data));
1654	bparams->COM_len = zr->jpg_settings.jpg_comp.COM_len;	1654	bparams->COM_len = zr->jpg_settings.jpg_comp.COM_len;
1655	memcpy(bparams->COM_data,	1655	memcpy(bparams->COM_data,
1656	fh->jpg_settings.jpg_comp.COM_data,	1656	fh->jpg_settings.jpg_comp.COM_data,
1657	sizeof(bparams->COM_data));	1657	sizeof(bparams->COM_data));
1658	bparams->jpeg_markers =	1658	bparams->jpeg_markers =
1659	fh->jpg_settings.jpg_comp.jpeg_markers;	1659	fh->jpg_settings.jpg_comp.jpeg_markers;
1660		1660
1661	mutex_unlock(&zr->resource_lock);	1661	mutex_unlock(&zr->resource_lock);
1662		1662
1663	bparams->VFIFO_FB = 0;	1663	bparams->VFIFO_FB = 0;
1664		1664
1665	return 0;	1665	return 0;
1666	}	1666	}
1667		1667
1668	case BUZIOC_S_PARAMS:	1668	case BUZIOC_S_PARAMS:
1669	{	1669	{
1670	struct zoran_params *bparams = arg;	1670	struct zoran_params *bparams = arg;
1671	int res = 0;	1671	int res = 0;
1672		1672
1673	dprintk(3, KERN_DEBUG "%s: BUZIOC_S_PARAMS\n", ZR_DEVNAME(zr));	1673	dprintk(3, KERN_DEBUG "%s: BUZIOC_S_PARAMS\n", ZR_DEVNAME(zr));
1674		1674
1675	settings.decimation = bparams->decimation;	1675	settings.decimation = bparams->decimation;
1676	settings.HorDcm = bparams->HorDcm;	1676	settings.HorDcm = bparams->HorDcm;
1677	settings.VerDcm = bparams->VerDcm;	1677	settings.VerDcm = bparams->VerDcm;
1678	settings.TmpDcm = bparams->TmpDcm;	1678	settings.TmpDcm = bparams->TmpDcm;
1679	settings.field_per_buff = bparams->field_per_buff;	1679	settings.field_per_buff = bparams->field_per_buff;
1680	settings.img_x = bparams->img_x;	1680	settings.img_x = bparams->img_x;
1681	settings.img_y = bparams->img_y;	1681	settings.img_y = bparams->img_y;
1682	settings.img_width = bparams->img_width;	1682	settings.img_width = bparams->img_width;
1683	settings.img_height = bparams->img_height;	1683	settings.img_height = bparams->img_height;
1684	settings.odd_even = bparams->odd_even;	1684	settings.odd_even = bparams->odd_even;
1685		1685
1686	settings.jpg_comp.quality = bparams->quality;	1686	settings.jpg_comp.quality = bparams->quality;
1687	settings.jpg_comp.APPn = bparams->APPn;	1687	settings.jpg_comp.APPn = bparams->APPn;
1688	settings.jpg_comp.APP_len = bparams->APP_len;	1688	settings.jpg_comp.APP_len = bparams->APP_len;
1689	memcpy(settings.jpg_comp.APP_data, bparams->APP_data,	1689	memcpy(settings.jpg_comp.APP_data, bparams->APP_data,
1690	sizeof(bparams->APP_data));	1690	sizeof(bparams->APP_data));
1691	settings.jpg_comp.COM_len = bparams->COM_len;	1691	settings.jpg_comp.COM_len = bparams->COM_len;
1692	memcpy(settings.jpg_comp.COM_data, bparams->COM_data,	1692	memcpy(settings.jpg_comp.COM_data, bparams->COM_data,
1693	sizeof(bparams->COM_data));	1693	sizeof(bparams->COM_data));
1694	settings.jpg_comp.jpeg_markers = bparams->jpeg_markers;	1694	settings.jpg_comp.jpeg_markers = bparams->jpeg_markers;
1695		1695
1696	mutex_lock(&zr->resource_lock);	1696	mutex_lock(&zr->resource_lock);
1697		1697
1698	if (zr->codec_mode != BUZ_MODE_IDLE) {	1698	if (zr->codec_mode != BUZ_MODE_IDLE) {
1699	dprintk(1,	1699	dprintk(1,
1700	KERN_ERR	1700	KERN_ERR
1701	"%s: BUZIOC_S_PARAMS called, but Buz in capture/playback mode\n",	1701	"%s: BUZIOC_S_PARAMS called, but Buz in capture/playback mode\n",
1702	ZR_DEVNAME(zr));	1702	ZR_DEVNAME(zr));
1703	res = -EINVAL;	1703	res = -EINVAL;
1704	goto sparams_unlock_and_return;	1704	goto sparams_unlock_and_return;
1705	}	1705	}
1706		1706
1707	/* Check the params first before overwriting our	1707	/* Check the params first before overwriting our
1708	* nternal values */	1708	* nternal values */
1709	if (zoran_check_jpg_settings(zr, &settings, 0)) {	1709	if (zoran_check_jpg_settings(zr, &settings, 0)) {
1710	res = -EINVAL;	1710	res = -EINVAL;
1711	goto sparams_unlock_and_return;	1711	goto sparams_unlock_and_return;
1712	}	1712	}
1713		1713
1714	fh->jpg_settings = settings;	1714	fh->jpg_settings = settings;
1715	sparams_unlock_and_return:	1715	sparams_unlock_and_return:
1716	mutex_unlock(&zr->resource_lock);	1716	mutex_unlock(&zr->resource_lock);
1717		1717
1718	return res;	1718	return res;
1719	}	1719	}
1720		1720
1721	case BUZIOC_REQBUFS:	1721	case BUZIOC_REQBUFS:
1722	{	1722	{
1723	struct zoran_requestbuffers *breq = arg;	1723	struct zoran_requestbuffers *breq = arg;
1724	int res = 0;	1724	int res = 0;
1725		1725
1726	dprintk(3,	1726	dprintk(3,
1727	KERN_DEBUG	1727	KERN_DEBUG
1728	"%s: BUZIOC_REQBUFS - count=%lu, size=%lu\n",	1728	"%s: BUZIOC_REQBUFS - count=%lu, size=%lu\n",
1729	ZR_DEVNAME(zr), breq->count, breq->size);	1729	ZR_DEVNAME(zr), breq->count, breq->size);
1730		1730
1731	/* Enforce reasonable lower and upper limits */	1731	/* Enforce reasonable lower and upper limits */
1732	if (breq->count < 4)	1732	if (breq->count < 4)
1733	breq->count = 4; /* Could be choosen smaller */	1733	breq->count = 4; /* Could be choosen smaller */
1734	if (breq->count > jpg_nbufs)	1734	if (breq->count > jpg_nbufs)
1735	breq->count = jpg_nbufs;	1735	breq->count = jpg_nbufs;
1736	breq->size = PAGE_ALIGN(breq->size);	1736	breq->size = PAGE_ALIGN(breq->size);
1737	if (breq->size < 8192)	1737	if (breq->size < 8192)
1738	breq->size = 8192; /* Arbitrary */	1738	breq->size = 8192; /* Arbitrary */
1739	/* breq->size is limited by 1 page for the stat_com	1739	/* breq->size is limited by 1 page for the stat_com
1740	* tables to a Maximum of 2 MB */	1740	* tables to a Maximum of 2 MB */
1741	if (breq->size > jpg_bufsize)	1741	if (breq->size > jpg_bufsize)
1742	breq->size = jpg_bufsize;	1742	breq->size = jpg_bufsize;
1743		1743
1744	mutex_lock(&zr->resource_lock);	1744	mutex_lock(&zr->resource_lock);
1745		1745
1746	if (fh->jpg_buffers.allocated \|\| fh->v4l_buffers.allocated) {	1746	if (fh->jpg_buffers.allocated \|\| fh->v4l_buffers.allocated) {
1747	dprintk(1,	1747	dprintk(1,
1748	KERN_ERR	1748	KERN_ERR
1749	"%s: BUZIOC_REQBUFS - buffers already allocated\n",	1749	"%s: BUZIOC_REQBUFS - buffers already allocated\n",
1750	ZR_DEVNAME(zr));	1750	ZR_DEVNAME(zr));
1751	res = -EBUSY;	1751	res = -EBUSY;
1752	goto jpgreqbuf_unlock_and_return;	1752	goto jpgreqbuf_unlock_and_return;
1753	}	1753	}
1754		1754
1755	fh->jpg_buffers.num_buffers = breq->count;	1755	fh->jpg_buffers.num_buffers = breq->count;
1756	fh->jpg_buffers.buffer_size = breq->size;	1756	fh->jpg_buffers.buffer_size = breq->size;
1757		1757
1758	if (jpg_fbuffer_alloc(file)) {	1758	if (jpg_fbuffer_alloc(file)) {
1759	res = -ENOMEM;	1759	res = -ENOMEM;
1760	goto jpgreqbuf_unlock_and_return;	1760	goto jpgreqbuf_unlock_and_return;
1761	}	1761	}
1762		1762
1763	/* The next mmap will map the MJPEG buffers - could	1763	/* The next mmap will map the MJPEG buffers - could
1764	* also be _PLAY, but it doesn't matter here /	1764	* also be _PLAY, but it doesn't matter here /
1765	fh->map_mode = ZORAN_MAP_MODE_JPG_REC;	1765	fh->map_mode = ZORAN_MAP_MODE_JPG_REC;
1766	jpgreqbuf_unlock_and_return:	1766	jpgreqbuf_unlock_and_return:
1767	mutex_unlock(&zr->resource_lock);	1767	mutex_unlock(&zr->resource_lock);
1768		1768
1769	return res;	1769	return res;
1770	}	1770	}
1771		1771
1772	case BUZIOC_QBUF_CAPT:	1772	case BUZIOC_QBUF_CAPT:
1773	{	1773	{
1774	int *frame = arg, res;	1774	int *frame = arg, res;
1775		1775
1776	dprintk(3, KERN_DEBUG "%s: BUZIOC_QBUF_CAPT - frame=%d\n",	1776	dprintk(3, KERN_DEBUG "%s: BUZIOC_QBUF_CAPT - frame=%d\n",
1777	ZR_DEVNAME(zr), *frame);	1777	ZR_DEVNAME(zr), *frame);
1778		1778
1779	mutex_lock(&zr->resource_lock);	1779	mutex_lock(&zr->resource_lock);
1780	res = jpg_qbuf(file, *frame, BUZ_MODE_MOTION_COMPRESS);	1780	res = jpg_qbuf(file, *frame, BUZ_MODE_MOTION_COMPRESS);
1781	mutex_unlock(&zr->resource_lock);	1781	mutex_unlock(&zr->resource_lock);
1782		1782
1783	return res;	1783	return res;
1784	}	1784	}
1785		1785
1786	case BUZIOC_QBUF_PLAY:	1786	case BUZIOC_QBUF_PLAY:
1787	{	1787	{
1788	int *frame = arg, res;	1788	int *frame = arg, res;
1789		1789
1790	dprintk(3, KERN_DEBUG "%s: BUZIOC_QBUF_PLAY - frame=%d\n",	1790	dprintk(3, KERN_DEBUG "%s: BUZIOC_QBUF_PLAY - frame=%d\n",
1791	ZR_DEVNAME(zr), *frame);	1791	ZR_DEVNAME(zr), *frame);
1792		1792
1793	mutex_lock(&zr->resource_lock);	1793	mutex_lock(&zr->resource_lock);
1794	res = jpg_qbuf(file, *frame, BUZ_MODE_MOTION_DECOMPRESS);	1794	res = jpg_qbuf(file, *frame, BUZ_MODE_MOTION_DECOMPRESS);
1795	mutex_unlock(&zr->resource_lock);	1795	mutex_unlock(&zr->resource_lock);
1796		1796
1797	return res;	1797	return res;
1798	}	1798	}
1799		1799
1800	case BUZIOC_SYNC:	1800	case BUZIOC_SYNC:
1801	{	1801	{
1802	struct zoran_sync *bsync = arg;	1802	struct zoran_sync *bsync = arg;
1803	int res;	1803	int res;
1804		1804
1805	dprintk(3, KERN_DEBUG "%s: BUZIOC_SYNC\n", ZR_DEVNAME(zr));	1805	dprintk(3, KERN_DEBUG "%s: BUZIOC_SYNC\n", ZR_DEVNAME(zr));
1806		1806
1807	mutex_lock(&zr->resource_lock);	1807	mutex_lock(&zr->resource_lock);
1808	res = jpg_sync(file, bsync);	1808	res = jpg_sync(file, bsync);
1809	mutex_unlock(&zr->resource_lock);	1809	mutex_unlock(&zr->resource_lock);
1810		1810
1811	return res;	1811	return res;
1812	}	1812	}
1813		1813
1814	case BUZIOC_G_STATUS:	1814	case BUZIOC_G_STATUS:
1815	{	1815	{
1816	struct zoran_status *bstat = arg;	1816	struct zoran_status *bstat = arg;
1817	struct v4l2_routing route = { 0, 0 };	1817	struct v4l2_routing route = { 0, 0 };
1818	int status = 0, res = 0;	1818	int status = 0, res = 0;
1819	v4l2_std_id norm;	1819	v4l2_std_id norm;
1820		1820
1821	dprintk(3, KERN_DEBUG "%s: BUZIOC_G_STATUS\n", ZR_DEVNAME(zr));	1821	dprintk(3, KERN_DEBUG "%s: BUZIOC_G_STATUS\n", ZR_DEVNAME(zr));
1822		1822
1823	if (zr->codec_mode != BUZ_MODE_IDLE) {	1823	if (zr->codec_mode != BUZ_MODE_IDLE) {
1824	dprintk(1,	1824	dprintk(1,
1825	KERN_ERR	1825	KERN_ERR
1826	"%s: BUZIOC_G_STATUS called but Buz in capture/playback mode\n",	1826	"%s: BUZIOC_G_STATUS called but Buz in capture/playback mode\n",
1827	ZR_DEVNAME(zr));	1827	ZR_DEVNAME(zr));
1828	return -EINVAL;	1828	return -EINVAL;
1829	}	1829	}
1830		1830
1831	route.input = zr->card.input[bstat->input].muxsel;	1831	route.input = zr->card.input[bstat->input].muxsel;
1832		1832
1833	mutex_lock(&zr->resource_lock);	1833	mutex_lock(&zr->resource_lock);
1834		1834
1835	if (zr->codec_mode != BUZ_MODE_IDLE) {	1835	if (zr->codec_mode != BUZ_MODE_IDLE) {
1836	dprintk(1,	1836	dprintk(1,
1837	KERN_ERR	1837	KERN_ERR
1838	"%s: BUZIOC_G_STATUS called, but Buz in capture/playback mode\n",	1838	"%s: BUZIOC_G_STATUS called, but Buz in capture/playback mode\n",
1839	ZR_DEVNAME(zr));	1839	ZR_DEVNAME(zr));
1840	res = -EINVAL;	1840	res = -EINVAL;
1841	goto gstat_unlock_and_return;	1841	goto gstat_unlock_and_return;
1842	}	1842	}
1843		1843
1844	decoder_s_routing(zr, &route);	1844	decoder_s_routing(zr, &route);
1845		1845
1846	/* sleep 1 second */	1846	/* sleep 1 second */
1847	ssleep(1);	1847	ssleep(1);
1848		1848
1849	/* Get status of video decoder */	1849	/* Get status of video decoder */
1850	decoder_call(zr, video, querystd, &norm);	1850	decoder_call(zr, video, querystd, &norm);
1851	decoder_call(zr, video, g_input_status, &status);	1851	decoder_call(zr, video, g_input_status, &status);
1852		1852
1853	/* restore previous input and norm */	1853	/* restore previous input and norm */
1854	route.input = zr->card.input[zr->input].muxsel;	1854	route.input = zr->card.input[zr->input].muxsel;
1855	decoder_s_routing(zr, &route);	1855	decoder_s_routing(zr, &route);
1856	gstat_unlock_and_return:	1856	gstat_unlock_and_return:
1857	mutex_unlock(&zr->resource_lock);	1857	mutex_unlock(&zr->resource_lock);
1858		1858
1859	if (!res) {	1859	if (!res) {
1860	bstat->signal =	1860	bstat->signal =
1861	(status & V4L2_IN_ST_NO_SIGNAL) ? 0 : 1;	1861	(status & V4L2_IN_ST_NO_SIGNAL) ? 0 : 1;
1862	if (norm & V4L2_STD_NTSC)	1862	if (norm & V4L2_STD_NTSC)
1863	bstat->norm = VIDEO_MODE_NTSC;	1863	bstat->norm = VIDEO_MODE_NTSC;
1864	else if (norm & V4L2_STD_SECAM)	1864	else if (norm & V4L2_STD_SECAM)
1865	bstat->norm = VIDEO_MODE_SECAM;	1865	bstat->norm = VIDEO_MODE_SECAM;
1866	else	1866	else
1867	bstat->norm = VIDEO_MODE_PAL;	1867	bstat->norm = VIDEO_MODE_PAL;
1868		1868
1869	bstat->color =	1869	bstat->color =
1870	(status & V4L2_IN_ST_NO_COLOR) ? 0 : 1;	1870	(status & V4L2_IN_ST_NO_COLOR) ? 0 : 1;
1871	}	1871	}
1872		1872
1873	return res;	1873	return res;
1874	}	1874	}
1875		1875
1876	default:	1876	default:
1877	return -EINVAL;	1877	return -EINVAL;
1878	}	1878	}
1879	}	1879	}
1880		1880
1881	static int zoran_vidiocgmbuf(struct file file, void __fh, struct video_mbuf *vmbuf)	1881	static int zoran_vidiocgmbuf(struct file file, void __fh, struct video_mbuf *vmbuf)
1882	{	1882	{
1883	struct zoran_fh *fh = __fh;	1883	struct zoran_fh *fh = __fh;
1884	struct zoran *zr = fh->zr;	1884	struct zoran *zr = fh->zr;
1885	int i, res = 0;	1885	int i, res = 0;
1886		1886
1887	vmbuf->size =	1887	vmbuf->size =
1888	fh->v4l_buffers.num_buffers *	1888	fh->v4l_buffers.num_buffers *
1889	fh->v4l_buffers.buffer_size;	1889	fh->v4l_buffers.buffer_size;
1890	vmbuf->frames = fh->v4l_buffers.num_buffers;	1890	vmbuf->frames = fh->v4l_buffers.num_buffers;
1891	for (i = 0; i < vmbuf->frames; i++) {	1891	for (i = 0; i < vmbuf->frames; i++) {
1892	vmbuf->offsets[i] =	1892	vmbuf->offsets[i] =
1893	i * fh->v4l_buffers.buffer_size;	1893	i * fh->v4l_buffers.buffer_size;
1894	}	1894	}
1895		1895
1896	mutex_lock(&zr->resource_lock);	1896	mutex_lock(&zr->resource_lock);
1897		1897
1898	if (fh->jpg_buffers.allocated \|\| fh->v4l_buffers.allocated) {	1898	if (fh->jpg_buffers.allocated \|\| fh->v4l_buffers.allocated) {
1899	dprintk(1,	1899	dprintk(1,
1900	KERN_ERR	1900	KERN_ERR
1901	"%s: VIDIOCGMBUF - buffers already allocated\n",	1901	"%s: VIDIOCGMBUF - buffers already allocated\n",
1902	ZR_DEVNAME(zr));	1902	ZR_DEVNAME(zr));
1903	res = -EINVAL;	1903	res = -EINVAL;
1904	goto v4l1reqbuf_unlock_and_return;	1904	goto v4l1reqbuf_unlock_and_return;
1905	}	1905	}
1906		1906
1907	if (v4l_fbuffer_alloc(file)) {	1907	if (v4l_fbuffer_alloc(file)) {
1908	res = -ENOMEM;	1908	res = -ENOMEM;
1909	goto v4l1reqbuf_unlock_and_return;	1909	goto v4l1reqbuf_unlock_and_return;
1910	}	1910	}
1911		1911
1912	/* The next mmap will map the V4L buffers */	1912	/* The next mmap will map the V4L buffers */
1913	fh->map_mode = ZORAN_MAP_MODE_RAW;	1913	fh->map_mode = ZORAN_MAP_MODE_RAW;
1914	v4l1reqbuf_unlock_and_return:	1914	v4l1reqbuf_unlock_and_return:
1915	mutex_unlock(&zr->resource_lock);	1915	mutex_unlock(&zr->resource_lock);
1916		1916
1917	return res;	1917	return res;
1918	}	1918	}
1919	#endif	1919	#endif
1920		1920
1921	static int zoran_querycap(struct file file, void __fh, struct v4l2_capability *cap)	1921	static int zoran_querycap(struct file file, void __fh, struct v4l2_capability *cap)
1922	{	1922	{
1923	struct zoran_fh *fh = __fh;	1923	struct zoran_fh *fh = __fh;
1924	struct zoran *zr = fh->zr;	1924	struct zoran *zr = fh->zr;
1925		1925
1926	memset(cap, 0, sizeof(*cap));	1926	memset(cap, 0, sizeof(*cap));
1927	strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)-1);	1927	strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)-1);
1928	strncpy(cap->driver, "zoran", sizeof(cap->driver)-1);	1928	strncpy(cap->driver, "zoran", sizeof(cap->driver)-1);
1929	snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",	1929	snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",
1930	pci_name(zr->pci_dev));	1930	pci_name(zr->pci_dev));
1931	cap->version = KERNEL_VERSION(MAJOR_VERSION, MINOR_VERSION,	1931	cap->version = KERNEL_VERSION(MAJOR_VERSION, MINOR_VERSION,
1932	RELEASE_VERSION);	1932	RELEASE_VERSION);
1933	cap->capabilities = V4L2_CAP_STREAMING \| V4L2_CAP_VIDEO_CAPTURE \|	1933	cap->capabilities = V4L2_CAP_STREAMING \| V4L2_CAP_VIDEO_CAPTURE \|
1934	V4L2_CAP_VIDEO_OUTPUT \| V4L2_CAP_VIDEO_OVERLAY;	1934	V4L2_CAP_VIDEO_OUTPUT \| V4L2_CAP_VIDEO_OVERLAY;
1935	return 0;	1935	return 0;
1936	}	1936	}
1937		1937
1938	static int zoran_enum_fmt(struct zoran zr, struct v4l2_fmtdesc fmt, int flag)	1938	static int zoran_enum_fmt(struct zoran zr, struct v4l2_fmtdesc fmt, int flag)
1939	{	1939	{
1940	int num = -1, i;	1940	int num = -1, i;
1941		1941
1942	for (i = 0; i < NUM_FORMATS; i++) {	1942	for (i = 0; i < NUM_FORMATS; i++) {
1943	if (zoran_formats[i].flags & flag)	1943	if (zoran_formats[i].flags & flag)
1944	num++;	1944	num++;
1945	if (num == fmt->index)	1945	if (num == fmt->index)
1946	break;	1946	break;
1947	}	1947	}
1948	if (fmt->index < 0 /* late, but not too late */ \|\| i == NUM_FORMATS)	1948	if (fmt->index < 0 /* late, but not too late */ \|\| i == NUM_FORMATS)
1949	return -EINVAL;	1949	return -EINVAL;
1950		1950
1951	strncpy(fmt->description, zoran_formats[i].name, sizeof(fmt->description)-1);	1951	strncpy(fmt->description, zoran_formats[i].name, sizeof(fmt->description)-1);
1952	fmt->pixelformat = zoran_formats[i].fourcc;	1952	fmt->pixelformat = zoran_formats[i].fourcc;
1953	if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)	1953	if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
1954	fmt->flags \|= V4L2_FMT_FLAG_COMPRESSED;	1954	fmt->flags \|= V4L2_FMT_FLAG_COMPRESSED;
1955	return 0;	1955	return 0;
1956	}	1956	}
1957		1957
1958	static int zoran_enum_fmt_vid_cap(struct file file, void __fh,	1958	static int zoran_enum_fmt_vid_cap(struct file file, void __fh,
1959	struct v4l2_fmtdesc *f)	1959	struct v4l2_fmtdesc *f)
1960	{	1960	{
1961	struct zoran_fh *fh = __fh;	1961	struct zoran_fh *fh = __fh;
1962	struct zoran *zr = fh->zr;	1962	struct zoran *zr = fh->zr;
1963		1963
1964	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_CAPTURE);	1964	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_CAPTURE);
1965	}	1965	}
1966		1966
1967	static int zoran_enum_fmt_vid_out(struct file file, void __fh,	1967	static int zoran_enum_fmt_vid_out(struct file file, void __fh,
1968	struct v4l2_fmtdesc *f)	1968	struct v4l2_fmtdesc *f)
1969	{	1969	{
1970	struct zoran_fh *fh = __fh;	1970	struct zoran_fh *fh = __fh;
1971	struct zoran *zr = fh->zr;	1971	struct zoran *zr = fh->zr;
1972		1972
1973	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_PLAYBACK);	1973	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_PLAYBACK);
1974	}	1974	}
1975		1975
1976	static int zoran_enum_fmt_vid_overlay(struct file file, void __fh,	1976	static int zoran_enum_fmt_vid_overlay(struct file file, void __fh,
1977	struct v4l2_fmtdesc *f)	1977	struct v4l2_fmtdesc *f)
1978	{	1978	{
1979	struct zoran_fh *fh = __fh;	1979	struct zoran_fh *fh = __fh;
1980	struct zoran *zr = fh->zr;	1980	struct zoran *zr = fh->zr;
1981		1981
1982	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_OVERLAY);	1982	return zoran_enum_fmt(zr, f, ZORAN_FORMAT_OVERLAY);
1983	}	1983	}
1984		1984
1985	static int zoran_g_fmt_vid_out(struct file file, void __fh,	1985	static int zoran_g_fmt_vid_out(struct file file, void __fh,
1986	struct v4l2_format *fmt)	1986	struct v4l2_format *fmt)
1987	{	1987	{
1988	struct zoran_fh *fh = __fh;	1988	struct zoran_fh *fh = __fh;
1989	struct zoran *zr = fh->zr;	1989	struct zoran *zr = fh->zr;
1990		1990
1991	mutex_lock(&zr->resource_lock);	1991	mutex_lock(&zr->resource_lock);
1992		1992
1993	fmt->fmt.pix.width = fh->jpg_settings.img_width / fh->jpg_settings.HorDcm;	1993	fmt->fmt.pix.width = fh->jpg_settings.img_width / fh->jpg_settings.HorDcm;
1994	fmt->fmt.pix.height = fh->jpg_settings.img_height * 2 /	1994	fmt->fmt.pix.height = fh->jpg_settings.img_height * 2 /
1995	(fh->jpg_settings.VerDcm * fh->jpg_settings.TmpDcm);	1995	(fh->jpg_settings.VerDcm * fh->jpg_settings.TmpDcm);
1996	fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&fh->jpg_settings);	1996	fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&fh->jpg_settings);
1997	fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;	1997	fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
1998	if (fh->jpg_settings.TmpDcm == 1)	1998	if (fh->jpg_settings.TmpDcm == 1)
1999	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?	1999	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
2000	V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);	2000	V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
2001	else	2001	else
2002	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?	2002	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
2003	V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);	2003	V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
2004	fmt->fmt.pix.bytesperline = 0;	2004	fmt->fmt.pix.bytesperline = 0;
2005	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;	2005	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2006		2006
2007	mutex_unlock(&zr->resource_lock);	2007	mutex_unlock(&zr->resource_lock);
2008	return 0;	2008	return 0;
2009	}	2009	}
2010		2010
2011	static int zoran_g_fmt_vid_cap(struct file file, void __fh,	2011	static int zoran_g_fmt_vid_cap(struct file file, void __fh,
2012	struct v4l2_format *fmt)	2012	struct v4l2_format *fmt)
2013	{	2013	{
2014	struct zoran_fh *fh = __fh;	2014	struct zoran_fh *fh = __fh;
2015	struct zoran *zr = fh->zr;	2015	struct zoran *zr = fh->zr;
2016		2016
2017	if (fh->map_mode != ZORAN_MAP_MODE_RAW)	2017	if (fh->map_mode != ZORAN_MAP_MODE_RAW)
2018	return zoran_g_fmt_vid_out(file, fh, fmt);	2018	return zoran_g_fmt_vid_out(file, fh, fmt);
2019		2019
2020	mutex_lock(&zr->resource_lock);	2020	mutex_lock(&zr->resource_lock);
2021	fmt->fmt.pix.width = fh->v4l_settings.width;	2021	fmt->fmt.pix.width = fh->v4l_settings.width;
2022	fmt->fmt.pix.height = fh->v4l_settings.height;	2022	fmt->fmt.pix.height = fh->v4l_settings.height;
2023	fmt->fmt.pix.sizeimage = fh->v4l_settings.bytesperline *	2023	fmt->fmt.pix.sizeimage = fh->v4l_settings.bytesperline *
2024	fh->v4l_settings.height;	2024	fh->v4l_settings.height;
2025	fmt->fmt.pix.pixelformat = fh->v4l_settings.format->fourcc;	2025	fmt->fmt.pix.pixelformat = fh->v4l_settings.format->fourcc;
2026	fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace;	2026	fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace;
2027	fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline;	2027	fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline;
2028	if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2))	2028	if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2))
2029	fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;	2029	fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
2030	else	2030	else
2031	fmt->fmt.pix.field = V4L2_FIELD_TOP;	2031	fmt->fmt.pix.field = V4L2_FIELD_TOP;
2032	mutex_unlock(&zr->resource_lock);	2032	mutex_unlock(&zr->resource_lock);
2033	return 0;	2033	return 0;
2034	}	2034	}
2035		2035
2036	static int zoran_g_fmt_vid_overlay(struct file file, void __fh,	2036	static int zoran_g_fmt_vid_overlay(struct file file, void __fh,
2037	struct v4l2_format *fmt)	2037	struct v4l2_format *fmt)
2038	{	2038	{
2039	struct zoran_fh *fh = __fh;	2039	struct zoran_fh *fh = __fh;
2040	struct zoran *zr = fh->zr;	2040	struct zoran *zr = fh->zr;
2041		2041
2042	mutex_lock(&zr->resource_lock);	2042	mutex_lock(&zr->resource_lock);
2043		2043
2044	fmt->fmt.win.w.left = fh->overlay_settings.x;	2044	fmt->fmt.win.w.left = fh->overlay_settings.x;
2045	fmt->fmt.win.w.top = fh->overlay_settings.y;	2045	fmt->fmt.win.w.top = fh->overlay_settings.y;
2046	fmt->fmt.win.w.width = fh->overlay_settings.width;	2046	fmt->fmt.win.w.width = fh->overlay_settings.width;
2047	fmt->fmt.win.w.height = fh->overlay_settings.height;	2047	fmt->fmt.win.w.height = fh->overlay_settings.height;
2048	if (fh->overlay_settings.width * 2 > BUZ_MAX_HEIGHT)	2048	if (fh->overlay_settings.width * 2 > BUZ_MAX_HEIGHT)
2049	fmt->fmt.win.field = V4L2_FIELD_INTERLACED;	2049	fmt->fmt.win.field = V4L2_FIELD_INTERLACED;
2050	else	2050	else
2051	fmt->fmt.win.field = V4L2_FIELD_TOP;	2051	fmt->fmt.win.field = V4L2_FIELD_TOP;
2052		2052
2053	mutex_unlock(&zr->resource_lock);	2053	mutex_unlock(&zr->resource_lock);
2054	return 0;	2054	return 0;
2055	}	2055	}
2056		2056
2057	static int zoran_try_fmt_vid_overlay(struct file file, void __fh,	2057	static int zoran_try_fmt_vid_overlay(struct file file, void __fh,
2058	struct v4l2_format *fmt)	2058	struct v4l2_format *fmt)
2059	{	2059	{
2060	struct zoran_fh *fh = __fh;	2060	struct zoran_fh *fh = __fh;
2061	struct zoran *zr = fh->zr;	2061	struct zoran *zr = fh->zr;
2062		2062
2063	mutex_lock(&zr->resource_lock);	2063	mutex_lock(&zr->resource_lock);
2064		2064
2065	if (fmt->fmt.win.w.width > BUZ_MAX_WIDTH)	2065	if (fmt->fmt.win.w.width > BUZ_MAX_WIDTH)
2066	fmt->fmt.win.w.width = BUZ_MAX_WIDTH;	2066	fmt->fmt.win.w.width = BUZ_MAX_WIDTH;
2067	if (fmt->fmt.win.w.width < BUZ_MIN_WIDTH)	2067	if (fmt->fmt.win.w.width < BUZ_MIN_WIDTH)
2068	fmt->fmt.win.w.width = BUZ_MIN_WIDTH;	2068	fmt->fmt.win.w.width = BUZ_MIN_WIDTH;
2069	if (fmt->fmt.win.w.height > BUZ_MAX_HEIGHT)	2069	if (fmt->fmt.win.w.height > BUZ_MAX_HEIGHT)
2070	fmt->fmt.win.w.height = BUZ_MAX_HEIGHT;	2070	fmt->fmt.win.w.height = BUZ_MAX_HEIGHT;
2071	if (fmt->fmt.win.w.height < BUZ_MIN_HEIGHT)	2071	if (fmt->fmt.win.w.height < BUZ_MIN_HEIGHT)
2072	fmt->fmt.win.w.height = BUZ_MIN_HEIGHT;	2072	fmt->fmt.win.w.height = BUZ_MIN_HEIGHT;
2073		2073
2074	mutex_unlock(&zr->resource_lock);	2074	mutex_unlock(&zr->resource_lock);
2075	return 0;	2075	return 0;
2076	}	2076	}
2077		2077
2078	static int zoran_try_fmt_vid_out(struct file file, void __fh,	2078	static int zoran_try_fmt_vid_out(struct file file, void __fh,
2079	struct v4l2_format *fmt)	2079	struct v4l2_format *fmt)
2080	{	2080	{
2081	struct zoran_fh *fh = __fh;	2081	struct zoran_fh *fh = __fh;
2082	struct zoran *zr = fh->zr;	2082	struct zoran *zr = fh->zr;
2083	struct zoran_jpg_settings settings;	2083	struct zoran_jpg_settings settings;
2084	int res = 0;	2084	int res = 0;
2085		2085
2086	if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)	2086	if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
2087	return -EINVAL;	2087	return -EINVAL;
2088		2088
2089	mutex_lock(&zr->resource_lock);	2089	mutex_lock(&zr->resource_lock);
2090	settings = fh->jpg_settings;	2090	settings = fh->jpg_settings;
2091		2091
2092	/* we actually need to set 'real' parameters now */	2092	/* we actually need to set 'real' parameters now */
2093	if ((fmt->fmt.pix.height * 2) > BUZ_MAX_HEIGHT)	2093	if ((fmt->fmt.pix.height * 2) > BUZ_MAX_HEIGHT)
2094	settings.TmpDcm = 1;	2094	settings.TmpDcm = 1;
2095	else	2095	else
2096	settings.TmpDcm = 2;	2096	settings.TmpDcm = 2;
2097	settings.decimation = 0;	2097	settings.decimation = 0;
2098	if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2)	2098	if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2)
2099	settings.VerDcm = 2;	2099	settings.VerDcm = 2;
2100	else	2100	else
2101	settings.VerDcm = 1;	2101	settings.VerDcm = 1;
2102	if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4)	2102	if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4)
2103	settings.HorDcm = 4;	2103	settings.HorDcm = 4;
2104	else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2)	2104	else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2)
2105	settings.HorDcm = 2;	2105	settings.HorDcm = 2;
2106	else	2106	else
2107	settings.HorDcm = 1;	2107	settings.HorDcm = 1;
2108	if (settings.TmpDcm == 1)	2108	if (settings.TmpDcm == 1)
2109	settings.field_per_buff = 2;	2109	settings.field_per_buff = 2;
2110	else	2110	else
2111	settings.field_per_buff = 1;	2111	settings.field_per_buff = 1;
2112		2112
2113	if (settings.HorDcm > 1) {	2113	if (settings.HorDcm > 1) {
2114	settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;	2114	settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
2115	settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;	2115	settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
2116	} else {	2116	} else {
2117	settings.img_x = 0;	2117	settings.img_x = 0;
2118	settings.img_width = BUZ_MAX_WIDTH;	2118	settings.img_width = BUZ_MAX_WIDTH;
2119	}	2119	}
2120		2120
2121	/* check */	2121	/* check */
2122	res = zoran_check_jpg_settings(zr, &settings, 1);	2122	res = zoran_check_jpg_settings(zr, &settings, 1);
2123	if (res)	2123	if (res)
2124	goto tryfmt_unlock_and_return;	2124	goto tryfmt_unlock_and_return;
2125		2125
2126	/* tell the user what we actually did */	2126	/* tell the user what we actually did */
2127	fmt->fmt.pix.width = settings.img_width / settings.HorDcm;	2127	fmt->fmt.pix.width = settings.img_width / settings.HorDcm;
2128	fmt->fmt.pix.height = settings.img_height * 2 /	2128	fmt->fmt.pix.height = settings.img_height * 2 /
2129	(settings.TmpDcm * settings.VerDcm);	2129	(settings.TmpDcm * settings.VerDcm);
2130	if (settings.TmpDcm == 1)	2130	if (settings.TmpDcm == 1)
2131	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?	2131	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
2132	V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);	2132	V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
2133	else	2133	else
2134	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?	2134	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
2135	V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);	2135	V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
2136		2136
2137	fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&settings);	2137	fmt->fmt.pix.sizeimage = zoran_v4l2_calc_bufsize(&settings);
2138	fmt->fmt.pix.bytesperline = 0;	2138	fmt->fmt.pix.bytesperline = 0;
2139	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;	2139	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2140	tryfmt_unlock_and_return:	2140	tryfmt_unlock_and_return:
2141	mutex_unlock(&zr->resource_lock);	2141	mutex_unlock(&zr->resource_lock);
2142	return res;	2142	return res;
2143	}	2143	}
2144		2144
2145	static int zoran_try_fmt_vid_cap(struct file file, void __fh,	2145	static int zoran_try_fmt_vid_cap(struct file file, void __fh,
2146	struct v4l2_format *fmt)	2146	struct v4l2_format *fmt)
2147	{	2147	{
2148	struct zoran_fh *fh = __fh;	2148	struct zoran_fh *fh = __fh;
2149	struct zoran *zr = fh->zr;	2149	struct zoran *zr = fh->zr;
2150	int bpp;	2150	int bpp;
2151	int i;	2151	int i;
2152		2152
2153	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)	2153	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)
2154	return zoran_try_fmt_vid_out(file, fh, fmt);	2154	return zoran_try_fmt_vid_out(file, fh, fmt);
2155		2155
2156	mutex_lock(&zr->resource_lock);	2156	mutex_lock(&zr->resource_lock);
2157		2157
2158	for (i = 0; i < NUM_FORMATS; i++)	2158	for (i = 0; i < NUM_FORMATS; i++)
2159	if (zoran_formats[i].fourcc == fmt->fmt.pix.pixelformat)	2159	if (zoran_formats[i].fourcc == fmt->fmt.pix.pixelformat)
2160	break;	2160	break;
2161		2161
2162	if (i == NUM_FORMATS) {	2162	if (i == NUM_FORMATS) {
2163	mutex_unlock(&zr->resource_lock);	2163	mutex_unlock(&zr->resource_lock);
2164	return -EINVAL;	2164	return -EINVAL;
2165	}	2165	}
2166		2166
2167	bpp = (zoran_formats[i].depth + 7) / 8;	2167	bpp = (zoran_formats[i].depth + 7) / 8;
2168	fmt->fmt.pix.width &= ~((bpp == 2) ? 1 : 3);	2168	fmt->fmt.pix.width &= ~((bpp == 2) ? 1 : 3);
2169	if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)	2169	if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)
2170	fmt->fmt.pix.width = BUZ_MAX_WIDTH;	2170	fmt->fmt.pix.width = BUZ_MAX_WIDTH;
2171	if (fmt->fmt.pix.width < BUZ_MIN_WIDTH)	2171	if (fmt->fmt.pix.width < BUZ_MIN_WIDTH)
2172	fmt->fmt.pix.width = BUZ_MIN_WIDTH;	2172	fmt->fmt.pix.width = BUZ_MIN_WIDTH;
2173	if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)	2173	if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)
2174	fmt->fmt.pix.height = BUZ_MAX_HEIGHT;	2174	fmt->fmt.pix.height = BUZ_MAX_HEIGHT;
2175	if (fmt->fmt.pix.height < BUZ_MIN_HEIGHT)	2175	if (fmt->fmt.pix.height < BUZ_MIN_HEIGHT)
2176	fmt->fmt.pix.height = BUZ_MIN_HEIGHT;	2176	fmt->fmt.pix.height = BUZ_MIN_HEIGHT;
2177	mutex_unlock(&zr->resource_lock);	2177	mutex_unlock(&zr->resource_lock);
2178		2178
2179	return 0;	2179	return 0;
2180	}	2180	}
2181		2181
2182	static int zoran_s_fmt_vid_overlay(struct file file, void __fh,	2182	static int zoran_s_fmt_vid_overlay(struct file file, void __fh,
2183	struct v4l2_format *fmt)	2183	struct v4l2_format *fmt)
2184	{	2184	{
2185	struct zoran_fh *fh = __fh;	2185	struct zoran_fh *fh = __fh;
2186	struct zoran *zr = fh->zr;	2186	struct zoran *zr = fh->zr;
2187	int res;	2187	int res;
2188		2188
2189	dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n",	2189	dprintk(3, "x=%d, y=%d, w=%d, h=%d, cnt=%d, map=0x%p\n",
2190	fmt->fmt.win.w.left, fmt->fmt.win.w.top,	2190	fmt->fmt.win.w.left, fmt->fmt.win.w.top,
2191	fmt->fmt.win.w.width,	2191	fmt->fmt.win.w.width,
2192	fmt->fmt.win.w.height,	2192	fmt->fmt.win.w.height,
2193	fmt->fmt.win.clipcount,	2193	fmt->fmt.win.clipcount,
2194	fmt->fmt.win.bitmap);	2194	fmt->fmt.win.bitmap);
2195	mutex_lock(&zr->resource_lock);	2195	mutex_lock(&zr->resource_lock);
2196	res = setup_window(file, fmt->fmt.win.w.left,	2196	res = setup_window(file, fmt->fmt.win.w.left,
2197	fmt->fmt.win.w.top,	2197	fmt->fmt.win.w.top,
2198	fmt->fmt.win.w.width,	2198	fmt->fmt.win.w.width,
2199	fmt->fmt.win.w.height,	2199	fmt->fmt.win.w.height,
2200	(struct v4l2_clip __user *)	2200	(struct v4l2_clip __user *)
2201	fmt->fmt.win.clips,	2201	fmt->fmt.win.clips,
2202	fmt->fmt.win.clipcount,	2202	fmt->fmt.win.clipcount,
2203	fmt->fmt.win.bitmap);	2203	fmt->fmt.win.bitmap);
2204	mutex_unlock(&zr->resource_lock);	2204	mutex_unlock(&zr->resource_lock);
2205	return res;	2205	return res;
2206	}	2206	}
2207		2207
2208	static int zoran_s_fmt_vid_out(struct file file, void __fh,	2208	static int zoran_s_fmt_vid_out(struct file file, void __fh,
2209	struct v4l2_format *fmt)	2209	struct v4l2_format *fmt)
2210	{	2210	{
2211	struct zoran_fh *fh = __fh;	2211	struct zoran_fh *fh = __fh;
2212	struct zoran *zr = fh->zr;	2212	struct zoran *zr = fh->zr;
2213	__le32 printformat = __cpu_to_le32(fmt->fmt.pix.pixelformat);	2213	__le32 printformat = __cpu_to_le32(fmt->fmt.pix.pixelformat);
2214	struct zoran_jpg_settings settings;	2214	struct zoran_jpg_settings settings;
2215	int res = 0;	2215	int res = 0;
2216		2216
2217	dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n",	2217	dprintk(3, "size=%dx%d, fmt=0x%x (%4.4s)\n",
2218	fmt->fmt.pix.width, fmt->fmt.pix.height,	2218	fmt->fmt.pix.width, fmt->fmt.pix.height,
2219	fmt->fmt.pix.pixelformat,	2219	fmt->fmt.pix.pixelformat,
2220	(char *) &printformat);	2220	(char *) &printformat);
2221	if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)	2221	if (fmt->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG)
2222	return -EINVAL;	2222	return -EINVAL;
2223		2223
2224	mutex_lock(&zr->resource_lock);	2224	mutex_lock(&zr->resource_lock);
2225		2225
2226	settings = fh->jpg_settings;	2226	settings = fh->jpg_settings;
2227		2227
2228	if (fh->v4l_buffers.allocated \|\| fh->jpg_buffers.allocated) {	2228	if (fh->v4l_buffers.allocated \|\| fh->jpg_buffers.allocated) {
2229	dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n",	2229	dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n",
2230	ZR_DEVNAME(zr));	2230	ZR_DEVNAME(zr));
2231	res = -EBUSY;	2231	res = -EBUSY;
2232	goto sfmtjpg_unlock_and_return;	2232	goto sfmtjpg_unlock_and_return;
2233	}	2233	}
2234		2234
2235	/* we actually need to set 'real' parameters now */	2235	/* we actually need to set 'real' parameters now */
2236	if (fmt->fmt.pix.height * 2 > BUZ_MAX_HEIGHT)	2236	if (fmt->fmt.pix.height * 2 > BUZ_MAX_HEIGHT)
2237	settings.TmpDcm = 1;	2237	settings.TmpDcm = 1;
2238	else	2238	else
2239	settings.TmpDcm = 2;	2239	settings.TmpDcm = 2;
2240	settings.decimation = 0;	2240	settings.decimation = 0;
2241	if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2)	2241	if (fmt->fmt.pix.height <= fh->jpg_settings.img_height / 2)
2242	settings.VerDcm = 2;	2242	settings.VerDcm = 2;
2243	else	2243	else
2244	settings.VerDcm = 1;	2244	settings.VerDcm = 1;
2245	if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4)	2245	if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 4)
2246	settings.HorDcm = 4;	2246	settings.HorDcm = 4;
2247	else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2)	2247	else if (fmt->fmt.pix.width <= fh->jpg_settings.img_width / 2)
2248	settings.HorDcm = 2;	2248	settings.HorDcm = 2;
2249	else	2249	else
2250	settings.HorDcm = 1;	2250	settings.HorDcm = 1;
2251	if (settings.TmpDcm == 1)	2251	if (settings.TmpDcm == 1)
2252	settings.field_per_buff = 2;	2252	settings.field_per_buff = 2;
2253	else	2253	else
2254	settings.field_per_buff = 1;	2254	settings.field_per_buff = 1;
2255		2255
2256	if (settings.HorDcm > 1) {	2256	if (settings.HorDcm > 1) {
2257	settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;	2257	settings.img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
2258	settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;	2258	settings.img_width = (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
2259	} else {	2259	} else {
2260	settings.img_x = 0;	2260	settings.img_x = 0;
2261	settings.img_width = BUZ_MAX_WIDTH;	2261	settings.img_width = BUZ_MAX_WIDTH;
2262	}	2262	}
2263		2263
2264	/* check */	2264	/* check */
2265	res = zoran_check_jpg_settings(zr, &settings, 0);	2265	res = zoran_check_jpg_settings(zr, &settings, 0);
2266	if (res)	2266	if (res)
2267	goto sfmtjpg_unlock_and_return;	2267	goto sfmtjpg_unlock_and_return;
2268		2268
2269	/* it's ok, so set them */	2269	/* it's ok, so set them */
2270	fh->jpg_settings = settings;	2270	fh->jpg_settings = settings;
2271		2271
2272	/* tell the user what we actually did */	2272	/* tell the user what we actually did */
2273	fmt->fmt.pix.width = settings.img_width / settings.HorDcm;	2273	fmt->fmt.pix.width = settings.img_width / settings.HorDcm;
2274	fmt->fmt.pix.height = settings.img_height * 2 /	2274	fmt->fmt.pix.height = settings.img_height * 2 /
2275	(settings.TmpDcm * settings.VerDcm);	2275	(settings.TmpDcm * settings.VerDcm);
2276	if (settings.TmpDcm == 1)	2276	if (settings.TmpDcm == 1)
2277	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?	2277	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
2278	V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);	2278	V4L2_FIELD_SEQ_TB : V4L2_FIELD_SEQ_BT);
2279	else	2279	else
2280	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?	2280	fmt->fmt.pix.field = (fh->jpg_settings.odd_even ?
2281	V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);	2281	V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM);
2282	fh->jpg_buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings);	2282	fh->jpg_buffers.buffer_size = zoran_v4l2_calc_bufsize(&fh->jpg_settings);
2283	fmt->fmt.pix.bytesperline = 0;	2283	fmt->fmt.pix.bytesperline = 0;
2284	fmt->fmt.pix.sizeimage = fh->jpg_buffers.buffer_size;	2284	fmt->fmt.pix.sizeimage = fh->jpg_buffers.buffer_size;
2285	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;	2285	fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
2286		2286
2287	/* we hereby abuse this variable to show that	2287	/* we hereby abuse this variable to show that
2288	* we're gonna do mjpeg capture */	2288	* we're gonna do mjpeg capture */
2289	fh->map_mode = (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) ?	2289	fh->map_mode = (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) ?
2290	ZORAN_MAP_MODE_JPG_REC : ZORAN_MAP_MODE_JPG_PLAY;	2290	ZORAN_MAP_MODE_JPG_REC : ZORAN_MAP_MODE_JPG_PLAY;
2291	sfmtjpg_unlock_and_return:	2291	sfmtjpg_unlock_and_return:
2292	mutex_unlock(&zr->resource_lock);	2292	mutex_unlock(&zr->resource_lock);
2293	return res;	2293	return res;
2294	}	2294	}
2295		2295
2296	static int zoran_s_fmt_vid_cap(struct file file, void __fh,	2296	static int zoran_s_fmt_vid_cap(struct file file, void __fh,
2297	struct v4l2_format *fmt)	2297	struct v4l2_format *fmt)
2298	{	2298	{
2299	struct zoran_fh *fh = __fh;	2299	struct zoran_fh *fh = __fh;
2300	struct zoran *zr = fh->zr;	2300	struct zoran *zr = fh->zr;
2301	int i;	2301	int i;
2302	int res = 0;	2302	int res = 0;
2303		2303
2304	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)	2304	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)
2305	return zoran_s_fmt_vid_out(file, fh, fmt);	2305	return zoran_s_fmt_vid_out(file, fh, fmt);
2306		2306
2307	for (i = 0; i < NUM_FORMATS; i++)	2307	for (i = 0; i < NUM_FORMATS; i++)
2308	if (fmt->fmt.pix.pixelformat == zoran_formats[i].fourcc)	2308	if (fmt->fmt.pix.pixelformat == zoran_formats[i].fourcc)
2309	break;	2309	break;
2310	if (i == NUM_FORMATS) {	2310	if (i == NUM_FORMATS) {
2311	dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n",	2311	dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - unknown/unsupported format 0x%x\n",
2312	ZR_DEVNAME(zr), fmt->fmt.pix.pixelformat);	2312	ZR_DEVNAME(zr), fmt->fmt.pix.pixelformat);
2313	return -EINVAL;	2313	return -EINVAL;
2314	}	2314	}
2315	mutex_lock(&zr->resource_lock);	2315	mutex_lock(&zr->resource_lock);
2316	if (fh->jpg_buffers.allocated \|\|	2316	if (fh->jpg_buffers.allocated \|\|
2317	(fh->v4l_buffers.allocated && fh->v4l_buffers.active != ZORAN_FREE)) {	2317	(fh->v4l_buffers.allocated && fh->v4l_buffers.active != ZORAN_FREE)) {
2318	dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n",	2318	dprintk(1, KERN_ERR "%s: VIDIOC_S_FMT - cannot change capture mode\n",
2319	ZR_DEVNAME(zr));	2319	ZR_DEVNAME(zr));
2320	res = -EBUSY;	2320	res = -EBUSY;
2321	goto sfmtv4l_unlock_and_return;	2321	goto sfmtv4l_unlock_and_return;
2322	}	2322	}
2323	if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)	2323	if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)
2324	fmt->fmt.pix.height = BUZ_MAX_HEIGHT;	2324	fmt->fmt.pix.height = BUZ_MAX_HEIGHT;
2325	if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)	2325	if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)
2326	fmt->fmt.pix.width = BUZ_MAX_WIDTH;	2326	fmt->fmt.pix.width = BUZ_MAX_WIDTH;
2327		2327
2328	res = zoran_v4l_set_format(file, fmt->fmt.pix.width,	2328	res = zoran_v4l_set_format(file, fmt->fmt.pix.width,
2329	fmt->fmt.pix.height, &zoran_formats[i]);	2329	fmt->fmt.pix.height, &zoran_formats[i]);
2330	if (res)	2330	if (res)
2331	goto sfmtv4l_unlock_and_return;	2331	goto sfmtv4l_unlock_and_return;
2332		2332
2333	/* tell the user the	2333	/* tell the user the
2334	* results/missing stuff */	2334	* results/missing stuff */
2335	fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline;	2335	fmt->fmt.pix.bytesperline = fh->v4l_settings.bytesperline;
2336	fmt->fmt.pix.sizeimage = fh->v4l_settings.height * fh->v4l_settings.bytesperline;	2336	fmt->fmt.pix.sizeimage = fh->v4l_settings.height * fh->v4l_settings.bytesperline;
2337	fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace;	2337	fmt->fmt.pix.colorspace = fh->v4l_settings.format->colorspace;
2338	if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2))	2338	if (BUZ_MAX_HEIGHT < (fh->v4l_settings.height * 2))
2339	fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;	2339	fmt->fmt.pix.field = V4L2_FIELD_INTERLACED;
2340	else	2340	else
2341	fmt->fmt.pix.field = V4L2_FIELD_TOP;	2341	fmt->fmt.pix.field = V4L2_FIELD_TOP;
2342		2342
2343	fh->map_mode = ZORAN_MAP_MODE_RAW;	2343	fh->map_mode = ZORAN_MAP_MODE_RAW;
2344	sfmtv4l_unlock_and_return:	2344	sfmtv4l_unlock_and_return:
2345	mutex_unlock(&zr->resource_lock);	2345	mutex_unlock(&zr->resource_lock);
2346	return res;	2346	return res;
2347	}	2347	}
2348		2348
2349	static int zoran_g_fbuf(struct file file, void __fh,	2349	static int zoran_g_fbuf(struct file file, void __fh,
2350	struct v4l2_framebuffer *fb)	2350	struct v4l2_framebuffer *fb)
2351	{	2351	{
2352	struct zoran_fh *fh = __fh;	2352	struct zoran_fh *fh = __fh;
2353	struct zoran *zr = fh->zr;	2353	struct zoran *zr = fh->zr;
2354		2354
2355	memset(fb, 0, sizeof(*fb));	2355	memset(fb, 0, sizeof(*fb));
2356	mutex_lock(&zr->resource_lock);	2356	mutex_lock(&zr->resource_lock);
2357	fb->base = zr->vbuf_base;	2357	fb->base = zr->vbuf_base;
2358	fb->fmt.width = zr->vbuf_width;	2358	fb->fmt.width = zr->vbuf_width;
2359	fb->fmt.height = zr->vbuf_height;	2359	fb->fmt.height = zr->vbuf_height;
2360	if (zr->overlay_settings.format)	2360	if (zr->overlay_settings.format)
2361	fb->fmt.pixelformat = fh->overlay_settings.format->fourcc;	2361	fb->fmt.pixelformat = fh->overlay_settings.format->fourcc;
2362	fb->fmt.bytesperline = zr->vbuf_bytesperline;	2362	fb->fmt.bytesperline = zr->vbuf_bytesperline;
2363	mutex_unlock(&zr->resource_lock);	2363	mutex_unlock(&zr->resource_lock);
2364	fb->fmt.colorspace = V4L2_COLORSPACE_SRGB;	2364	fb->fmt.colorspace = V4L2_COLORSPACE_SRGB;
2365	fb->fmt.field = V4L2_FIELD_INTERLACED;	2365	fb->fmt.field = V4L2_FIELD_INTERLACED;
2366	fb->flags = V4L2_FBUF_FLAG_OVERLAY;	2366	fb->flags = V4L2_FBUF_FLAG_OVERLAY;
2367	fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;	2367	fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2368		2368
2369	return 0;	2369	return 0;
2370	}	2370	}
2371		2371
2372	static int zoran_s_fbuf(struct file file, void __fh,	2372	static int zoran_s_fbuf(struct file file, void __fh,
2373	struct v4l2_framebuffer *fb)	2373	struct v4l2_framebuffer *fb)
2374	{	2374	{
2375	struct zoran_fh *fh = __fh;	2375	struct zoran_fh *fh = __fh;
2376	struct zoran *zr = fh->zr;	2376	struct zoran *zr = fh->zr;
2377	int i, res = 0;	2377	int i, res = 0;
2378	__le32 printformat = __cpu_to_le32(fb->fmt.pixelformat);	2378	__le32 printformat = __cpu_to_le32(fb->fmt.pixelformat);
2379		2379
2380	for (i = 0; i < NUM_FORMATS; i++)	2380	for (i = 0; i < NUM_FORMATS; i++)
2381	if (zoran_formats[i].fourcc == fb->fmt.pixelformat)	2381	if (zoran_formats[i].fourcc == fb->fmt.pixelformat)
2382	break;	2382	break;
2383	if (i == NUM_FORMATS) {	2383	if (i == NUM_FORMATS) {
2384	dprintk(1, KERN_ERR "%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n",	2384	dprintk(1, KERN_ERR "%s: VIDIOC_S_FBUF - format=0x%x (%4.4s) not allowed\n",
2385	ZR_DEVNAME(zr), fb->fmt.pixelformat,	2385	ZR_DEVNAME(zr), fb->fmt.pixelformat,
2386	(char *)&printformat);	2386	(char *)&printformat);
2387	return -EINVAL;	2387	return -EINVAL;
2388	}	2388	}
2389		2389
2390	mutex_lock(&zr->resource_lock);	2390	mutex_lock(&zr->resource_lock);
2391	res = setup_fbuffer(file, fb->base, &zoran_formats[i],	2391	res = setup_fbuffer(file, fb->base, &zoran_formats[i],
2392	fb->fmt.width, fb->fmt.height,	2392	fb->fmt.width, fb->fmt.height,
2393	fb->fmt.bytesperline);	2393	fb->fmt.bytesperline);
2394	mutex_unlock(&zr->resource_lock);	2394	mutex_unlock(&zr->resource_lock);
2395		2395
2396	return res;	2396	return res;
2397	}	2397	}
2398		2398
2399	static int zoran_overlay(struct file file, void __fh, unsigned int on)	2399	static int zoran_overlay(struct file file, void __fh, unsigned int on)
2400	{	2400	{
2401	struct zoran_fh *fh = __fh;	2401	struct zoran_fh *fh = __fh;
2402	struct zoran *zr = fh->zr;	2402	struct zoran *zr = fh->zr;
2403	int res;	2403	int res;
2404		2404
2405	mutex_lock(&zr->resource_lock);	2405	mutex_lock(&zr->resource_lock);
2406	res = setup_overlay(file, on);	2406	res = setup_overlay(file, on);
2407	mutex_unlock(&zr->resource_lock);	2407	mutex_unlock(&zr->resource_lock);
2408		2408
2409	return res;	2409	return res;
2410	}	2410	}
2411		2411
2412	static int zoran_streamoff(struct file file, void __fh, enum v4l2_buf_type type);	2412	static int zoran_streamoff(struct file file, void __fh, enum v4l2_buf_type type);
2413		2413
2414	static int zoran_reqbufs(struct file file, void __fh, struct v4l2_requestbuffers *req)	2414	static int zoran_reqbufs(struct file file, void __fh, struct v4l2_requestbuffers *req)
2415	{	2415	{
2416	struct zoran_fh *fh = __fh;	2416	struct zoran_fh *fh = __fh;
2417	struct zoran *zr = fh->zr;	2417	struct zoran *zr = fh->zr;
2418	int res = 0;	2418	int res = 0;
2419		2419
2420	if (req->memory != V4L2_MEMORY_MMAP) {	2420	if (req->memory != V4L2_MEMORY_MMAP) {
2421	dprintk(2,	2421	dprintk(2,
2422	KERN_ERR	2422	KERN_ERR
2423	"%s: only MEMORY_MMAP capture is supported, not %d\n",	2423	"%s: only MEMORY_MMAP capture is supported, not %d\n",
2424	ZR_DEVNAME(zr), req->memory);	2424	ZR_DEVNAME(zr), req->memory);
2425	return -EINVAL;	2425	return -EINVAL;
2426	}	2426	}
2427		2427
2428	if (req->count == 0)	2428	if (req->count == 0)
2429	return zoran_streamoff(file, fh, req->type);	2429	return zoran_streamoff(file, fh, req->type);
2430		2430
2431	mutex_lock(&zr->resource_lock);	2431	mutex_lock(&zr->resource_lock);
2432	if (fh->v4l_buffers.allocated \|\| fh->jpg_buffers.allocated) {	2432	if (fh->v4l_buffers.allocated \|\| fh->jpg_buffers.allocated) {
2433	dprintk(2,	2433	dprintk(2,
2434	KERN_ERR	2434	KERN_ERR
2435	"%s: VIDIOC_REQBUFS - buffers already allocated\n",	2435	"%s: VIDIOC_REQBUFS - buffers already allocated\n",
2436	ZR_DEVNAME(zr));	2436	ZR_DEVNAME(zr));
2437	res = -EBUSY;	2437	res = -EBUSY;
2438	goto v4l2reqbuf_unlock_and_return;	2438	goto v4l2reqbuf_unlock_and_return;
2439	}	2439	}
2440		2440
2441	if (fh->map_mode == ZORAN_MAP_MODE_RAW &&	2441	if (fh->map_mode == ZORAN_MAP_MODE_RAW &&
2442	req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {	2442	req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2443		2443
2444	/* control user input */	2444	/* control user input */
2445	if (req->count < 2)	2445	if (req->count < 2)
2446	req->count = 2;	2446	req->count = 2;
2447	if (req->count > v4l_nbufs)	2447	if (req->count > v4l_nbufs)
2448	req->count = v4l_nbufs;	2448	req->count = v4l_nbufs;
2449	fh->v4l_buffers.num_buffers = req->count;	2449	fh->v4l_buffers.num_buffers = req->count;
2450		2450
2451	if (v4l_fbuffer_alloc(file)) {	2451	if (v4l_fbuffer_alloc(file)) {
2452	res = -ENOMEM;	2452	res = -ENOMEM;
2453	goto v4l2reqbuf_unlock_and_return;	2453	goto v4l2reqbuf_unlock_and_return;
2454	}	2454	}
2455		2455
2456	/* The next mmap will map the V4L buffers */	2456	/* The next mmap will map the V4L buffers */
2457	fh->map_mode = ZORAN_MAP_MODE_RAW;	2457	fh->map_mode = ZORAN_MAP_MODE_RAW;
2458		2458
2459	} else if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC \|\|	2459	} else if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC \|\|
2460	fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {	2460	fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {
2461		2461
2462	/* we need to calculate size ourselves now */	2462	/* we need to calculate size ourselves now */
2463	if (req->count < 4)	2463	if (req->count < 4)
2464	req->count = 4;	2464	req->count = 4;
2465	if (req->count > jpg_nbufs)	2465	if (req->count > jpg_nbufs)
2466	req->count = jpg_nbufs;	2466	req->count = jpg_nbufs;
2467	fh->jpg_buffers.num_buffers = req->count;	2467	fh->jpg_buffers.num_buffers = req->count;
2468	fh->jpg_buffers.buffer_size =	2468	fh->jpg_buffers.buffer_size =
2469	zoran_v4l2_calc_bufsize(&fh->jpg_settings);	2469	zoran_v4l2_calc_bufsize(&fh->jpg_settings);
2470		2470
2471	if (jpg_fbuffer_alloc(file)) {	2471	if (jpg_fbuffer_alloc(file)) {
2472	res = -ENOMEM;	2472	res = -ENOMEM;
2473	goto v4l2reqbuf_unlock_and_return;	2473	goto v4l2reqbuf_unlock_and_return;
2474	}	2474	}
2475		2475
2476	/* The next mmap will map the MJPEG buffers */	2476	/* The next mmap will map the MJPEG buffers */
2477	if (req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)	2477	if (req->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
2478	fh->map_mode = ZORAN_MAP_MODE_JPG_REC;	2478	fh->map_mode = ZORAN_MAP_MODE_JPG_REC;
2479	else	2479	else
2480	fh->map_mode = ZORAN_MAP_MODE_JPG_PLAY;	2480	fh->map_mode = ZORAN_MAP_MODE_JPG_PLAY;
2481		2481
2482	} else {	2482	} else {
2483	dprintk(1,	2483	dprintk(1,
2484	KERN_ERR	2484	KERN_ERR
2485	"%s: VIDIOC_REQBUFS - unknown type %d\n",	2485	"%s: VIDIOC_REQBUFS - unknown type %d\n",
2486	ZR_DEVNAME(zr), req->type);	2486	ZR_DEVNAME(zr), req->type);
2487	res = -EINVAL;	2487	res = -EINVAL;
2488	goto v4l2reqbuf_unlock_and_return;	2488	goto v4l2reqbuf_unlock_and_return;
2489	}	2489	}
2490	v4l2reqbuf_unlock_and_return:	2490	v4l2reqbuf_unlock_and_return:
2491	mutex_unlock(&zr->resource_lock);	2491	mutex_unlock(&zr->resource_lock);
2492		2492
2493	return res;	2493	return res;
2494	}	2494	}
2495		2495
2496	static int zoran_querybuf(struct file file, void __fh, struct v4l2_buffer *buf)	2496	static int zoran_querybuf(struct file file, void __fh, struct v4l2_buffer *buf)
2497	{	2497	{
2498	struct zoran_fh *fh = __fh;	2498	struct zoran_fh *fh = __fh;
2499	struct zoran *zr = fh->zr;	2499	struct zoran *zr = fh->zr;
2500	int res;	2500	int res;
2501		2501
2502	mutex_lock(&zr->resource_lock);	2502	mutex_lock(&zr->resource_lock);
2503	res = zoran_v4l2_buffer_status(fh, buf, buf->index);	2503	res = zoran_v4l2_buffer_status(fh, buf, buf->index);
2504	mutex_unlock(&zr->resource_lock);	2504	mutex_unlock(&zr->resource_lock);
2505		2505
2506	return res;	2506	return res;
2507	}	2507	}
2508		2508
2509	static int zoran_qbuf(struct file file, void __fh, struct v4l2_buffer *buf)	2509	static int zoran_qbuf(struct file file, void __fh, struct v4l2_buffer *buf)
2510	{	2510	{
2511	struct zoran_fh *fh = __fh;	2511	struct zoran_fh *fh = __fh;
2512	struct zoran *zr = fh->zr;	2512	struct zoran *zr = fh->zr;
2513	int res = 0, codec_mode, buf_type;	2513	int res = 0, codec_mode, buf_type;
2514		2514
2515	mutex_lock(&zr->resource_lock);	2515	mutex_lock(&zr->resource_lock);
2516		2516
2517	switch (fh->map_mode) {	2517	switch (fh->map_mode) {
2518	case ZORAN_MAP_MODE_RAW:	2518	case ZORAN_MAP_MODE_RAW:
2519	if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {	2519	if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2520	dprintk(1, KERN_ERR	2520	dprintk(1, KERN_ERR
2521	"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",	2521	"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2522	ZR_DEVNAME(zr), buf->type, fh->map_mode);	2522	ZR_DEVNAME(zr), buf->type, fh->map_mode);
2523	res = -EINVAL;	2523	res = -EINVAL;
2524	goto qbuf_unlock_and_return;	2524	goto qbuf_unlock_and_return;
2525	}	2525	}
2526		2526
2527	res = zoran_v4l_queue_frame(file, buf->index);	2527	res = zoran_v4l_queue_frame(file, buf->index);
2528	if (res)	2528	if (res)
2529	goto qbuf_unlock_and_return;	2529	goto qbuf_unlock_and_return;
2530	if (!zr->v4l_memgrab_active &&	2530	if (!zr->v4l_memgrab_active &&
2531	fh->v4l_buffers.active == ZORAN_LOCKED)	2531	fh->v4l_buffers.active == ZORAN_LOCKED)
2532	zr36057_set_memgrab(zr, 1);	2532	zr36057_set_memgrab(zr, 1);
2533	break;	2533	break;
2534		2534
2535	case ZORAN_MAP_MODE_JPG_REC:	2535	case ZORAN_MAP_MODE_JPG_REC:
2536	case ZORAN_MAP_MODE_JPG_PLAY:	2536	case ZORAN_MAP_MODE_JPG_PLAY:
2537	if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {	2537	if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY) {
2538	buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;	2538	buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2539	codec_mode = BUZ_MODE_MOTION_DECOMPRESS;	2539	codec_mode = BUZ_MODE_MOTION_DECOMPRESS;
2540	} else {	2540	} else {
2541	buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	2541	buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2542	codec_mode = BUZ_MODE_MOTION_COMPRESS;	2542	codec_mode = BUZ_MODE_MOTION_COMPRESS;
2543	}	2543	}
2544		2544
2545	if (buf->type != buf_type) {	2545	if (buf->type != buf_type) {
2546	dprintk(1, KERN_ERR	2546	dprintk(1, KERN_ERR
2547	"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",	2547	"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2548	ZR_DEVNAME(zr), buf->type, fh->map_mode);	2548	ZR_DEVNAME(zr), buf->type, fh->map_mode);
2549	res = -EINVAL;	2549	res = -EINVAL;
2550	goto qbuf_unlock_and_return;	2550	goto qbuf_unlock_and_return;
2551	}	2551	}
2552		2552
2553	res = zoran_jpg_queue_frame(file, buf->index,	2553	res = zoran_jpg_queue_frame(file, buf->index,
2554	codec_mode);	2554	codec_mode);
2555	if (res != 0)	2555	if (res != 0)
2556	goto qbuf_unlock_and_return;	2556	goto qbuf_unlock_and_return;
2557	if (zr->codec_mode == BUZ_MODE_IDLE &&	2557	if (zr->codec_mode == BUZ_MODE_IDLE &&
2558	fh->jpg_buffers.active == ZORAN_LOCKED) {	2558	fh->jpg_buffers.active == ZORAN_LOCKED) {
2559	zr36057_enable_jpg(zr, codec_mode);	2559	zr36057_enable_jpg(zr, codec_mode);
2560	}	2560	}
2561	break;	2561	break;
2562		2562
2563	default:	2563	default:
2564	dprintk(1, KERN_ERR	2564	dprintk(1, KERN_ERR
2565	"%s: VIDIOC_QBUF - unsupported type %d\n",	2565	"%s: VIDIOC_QBUF - unsupported type %d\n",
2566	ZR_DEVNAME(zr), buf->type);	2566	ZR_DEVNAME(zr), buf->type);
2567	res = -EINVAL;	2567	res = -EINVAL;
2568	break;	2568	break;
2569	}	2569	}
2570	qbuf_unlock_and_return:	2570	qbuf_unlock_and_return:
2571	mutex_unlock(&zr->resource_lock);	2571	mutex_unlock(&zr->resource_lock);
2572		2572
2573	return res;	2573	return res;
2574	}	2574	}
2575		2575
2576	static int zoran_dqbuf(struct file file, void __fh, struct v4l2_buffer *buf)	2576	static int zoran_dqbuf(struct file file, void __fh, struct v4l2_buffer *buf)
2577	{	2577	{
2578	struct zoran_fh *fh = __fh;	2578	struct zoran_fh *fh = __fh;
2579	struct zoran *zr = fh->zr;	2579	struct zoran *zr = fh->zr;
2580	int res = 0, buf_type, num = -1; /* compiler borks here (?) */	2580	int res = 0, buf_type, num = -1; /* compiler borks here (?) */
2581		2581
2582	mutex_lock(&zr->resource_lock);	2582	mutex_lock(&zr->resource_lock);
2583		2583
2584	switch (fh->map_mode) {	2584	switch (fh->map_mode) {
2585	case ZORAN_MAP_MODE_RAW:	2585	case ZORAN_MAP_MODE_RAW:
2586	if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {	2586	if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2587	dprintk(1, KERN_ERR	2587	dprintk(1, KERN_ERR
2588	"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",	2588	"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2589	ZR_DEVNAME(zr), buf->type, fh->map_mode);	2589	ZR_DEVNAME(zr), buf->type, fh->map_mode);
2590	res = -EINVAL;	2590	res = -EINVAL;
2591	goto dqbuf_unlock_and_return;	2591	goto dqbuf_unlock_and_return;
2592	}	2592	}
2593		2593
2594	num = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];	2594	num = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];
2595	if (file->f_flags & O_NONBLOCK &&	2595	if (file->f_flags & O_NONBLOCK &&
2596	zr->v4l_buffers.buffer[num].state != BUZ_STATE_DONE) {	2596	zr->v4l_buffers.buffer[num].state != BUZ_STATE_DONE) {
2597	res = -EAGAIN;	2597	res = -EAGAIN;
2598	goto dqbuf_unlock_and_return;	2598	goto dqbuf_unlock_and_return;
2599	}	2599	}
2600	res = v4l_sync(file, num);	2600	res = v4l_sync(file, num);
2601	if (res)	2601	if (res)
2602	goto dqbuf_unlock_and_return;	2602	goto dqbuf_unlock_and_return;
2603	zr->v4l_sync_tail++;	2603	zr->v4l_sync_tail++;
2604	res = zoran_v4l2_buffer_status(fh, buf, num);	2604	res = zoran_v4l2_buffer_status(fh, buf, num);
2605	break;	2605	break;
2606		2606
2607	case ZORAN_MAP_MODE_JPG_REC:	2607	case ZORAN_MAP_MODE_JPG_REC:
2608	case ZORAN_MAP_MODE_JPG_PLAY:	2608	case ZORAN_MAP_MODE_JPG_PLAY:
2609	{	2609	{
2610	struct zoran_sync bs;	2610	struct zoran_sync bs;
2611		2611
2612	if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY)	2612	if (fh->map_mode == ZORAN_MAP_MODE_JPG_PLAY)
2613	buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;	2613	buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2614	else	2614	else
2615	buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	2615	buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2616		2616
2617	if (buf->type != buf_type) {	2617	if (buf->type != buf_type) {
2618	dprintk(1, KERN_ERR	2618	dprintk(1, KERN_ERR
2619	"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",	2619	"%s: VIDIOC_QBUF - invalid buf->type=%d for map_mode=%d\n",
2620	ZR_DEVNAME(zr), buf->type, fh->map_mode);	2620	ZR_DEVNAME(zr), buf->type, fh->map_mode);
2621	res = -EINVAL;	2621	res = -EINVAL;
2622	goto dqbuf_unlock_and_return;	2622	goto dqbuf_unlock_and_return;
2623	}	2623	}
2624		2624
2625	num = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];	2625	num = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
2626		2626
2627	if (file->f_flags & O_NONBLOCK &&	2627	if (file->f_flags & O_NONBLOCK &&
2628	zr->jpg_buffers.buffer[num].state != BUZ_STATE_DONE) {	2628	zr->jpg_buffers.buffer[num].state != BUZ_STATE_DONE) {
2629	res = -EAGAIN;	2629	res = -EAGAIN;
2630	goto dqbuf_unlock_and_return;	2630	goto dqbuf_unlock_and_return;
2631	}	2631	}
2632	res = jpg_sync(file, &bs);	2632	res = jpg_sync(file, &bs);
2633	if (res)	2633	if (res)
2634	goto dqbuf_unlock_and_return;	2634	goto dqbuf_unlock_and_return;
2635	res = zoran_v4l2_buffer_status(fh, buf, bs.frame);	2635	res = zoran_v4l2_buffer_status(fh, buf, bs.frame);
2636	break;	2636	break;
2637	}	2637	}
2638		2638
2639	default:	2639	default:
2640	dprintk(1, KERN_ERR	2640	dprintk(1, KERN_ERR
2641	"%s: VIDIOC_DQBUF - unsupported type %d\n",	2641	"%s: VIDIOC_DQBUF - unsupported type %d\n",
2642	ZR_DEVNAME(zr), buf->type);	2642	ZR_DEVNAME(zr), buf->type);
2643	res = -EINVAL;	2643	res = -EINVAL;
2644	break;	2644	break;
2645	}	2645	}
2646	dqbuf_unlock_and_return:	2646	dqbuf_unlock_and_return:
2647	mutex_unlock(&zr->resource_lock);	2647	mutex_unlock(&zr->resource_lock);
2648		2648
2649	return res;	2649	return res;
2650	}	2650	}
2651		2651
2652	static int zoran_streamon(struct file file, void __fh, enum v4l2_buf_type type)	2652	static int zoran_streamon(struct file file, void __fh, enum v4l2_buf_type type)
2653	{	2653	{
2654	struct zoran_fh *fh = __fh;	2654	struct zoran_fh *fh = __fh;
2655	struct zoran *zr = fh->zr;	2655	struct zoran *zr = fh->zr;
2656	int res = 0;	2656	int res = 0;
2657		2657
2658	mutex_lock(&zr->resource_lock);	2658	mutex_lock(&zr->resource_lock);
2659		2659
2660	switch (fh->map_mode) {	2660	switch (fh->map_mode) {
2661	case ZORAN_MAP_MODE_RAW: /* raw capture */	2661	case ZORAN_MAP_MODE_RAW: /* raw capture */
2662	if (zr->v4l_buffers.active != ZORAN_ACTIVE \|\|	2662	if (zr->v4l_buffers.active != ZORAN_ACTIVE \|\|
2663	fh->v4l_buffers.active != ZORAN_ACTIVE) {	2663	fh->v4l_buffers.active != ZORAN_ACTIVE) {
2664	res = -EBUSY;	2664	res = -EBUSY;
2665	goto strmon_unlock_and_return;	2665	goto strmon_unlock_and_return;
2666	}	2666	}
2667		2667
2668	zr->v4l_buffers.active = fh->v4l_buffers.active = ZORAN_LOCKED;	2668	zr->v4l_buffers.active = fh->v4l_buffers.active = ZORAN_LOCKED;
2669	zr->v4l_settings = fh->v4l_settings;	2669	zr->v4l_settings = fh->v4l_settings;
2670		2670
2671	zr->v4l_sync_tail = zr->v4l_pend_tail;	2671	zr->v4l_sync_tail = zr->v4l_pend_tail;
2672	if (!zr->v4l_memgrab_active &&	2672	if (!zr->v4l_memgrab_active &&
2673	zr->v4l_pend_head != zr->v4l_pend_tail) {	2673	zr->v4l_pend_head != zr->v4l_pend_tail) {
2674	zr36057_set_memgrab(zr, 1);	2674	zr36057_set_memgrab(zr, 1);
2675	}	2675	}
2676	break;	2676	break;
2677		2677
2678	case ZORAN_MAP_MODE_JPG_REC:	2678	case ZORAN_MAP_MODE_JPG_REC:
2679	case ZORAN_MAP_MODE_JPG_PLAY:	2679	case ZORAN_MAP_MODE_JPG_PLAY:
2680	/* what is the codec mode right now? */	2680	/* what is the codec mode right now? */
2681	if (zr->jpg_buffers.active != ZORAN_ACTIVE \|\|	2681	if (zr->jpg_buffers.active != ZORAN_ACTIVE \|\|
2682	fh->jpg_buffers.active != ZORAN_ACTIVE) {	2682	fh->jpg_buffers.active != ZORAN_ACTIVE) {
2683	res = -EBUSY;	2683	res = -EBUSY;
2684	goto strmon_unlock_and_return;	2684	goto strmon_unlock_and_return;
2685	}	2685	}
2686		2686
2687	zr->jpg_buffers.active = fh->jpg_buffers.active = ZORAN_LOCKED;	2687	zr->jpg_buffers.active = fh->jpg_buffers.active = ZORAN_LOCKED;
2688		2688
2689	if (zr->jpg_que_head != zr->jpg_que_tail) {	2689	if (zr->jpg_que_head != zr->jpg_que_tail) {
2690	/* Start the jpeg codec when the first frame is queued */	2690	/* Start the jpeg codec when the first frame is queued */
2691	jpeg_start(zr);	2691	jpeg_start(zr);
2692	}	2692	}
2693	break;	2693	break;
2694		2694
2695	default:	2695	default:
2696	dprintk(1,	2696	dprintk(1,
2697	KERN_ERR	2697	KERN_ERR
2698	"%s: VIDIOC_STREAMON - invalid map mode %d\n",	2698	"%s: VIDIOC_STREAMON - invalid map mode %d\n",
2699	ZR_DEVNAME(zr), fh->map_mode);	2699	ZR_DEVNAME(zr), fh->map_mode);
2700	res = -EINVAL;	2700	res = -EINVAL;
2701	break;	2701	break;
2702	}	2702	}
2703	strmon_unlock_and_return:	2703	strmon_unlock_and_return:
2704	mutex_unlock(&zr->resource_lock);	2704	mutex_unlock(&zr->resource_lock);
2705		2705
2706	return res;	2706	return res;
2707	}	2707	}
2708		2708
2709	static int zoran_streamoff(struct file file, void __fh, enum v4l2_buf_type type)	2709	static int zoran_streamoff(struct file file, void __fh, enum v4l2_buf_type type)
2710	{	2710	{
2711	struct zoran_fh *fh = __fh;	2711	struct zoran_fh *fh = __fh;
2712	struct zoran *zr = fh->zr;	2712	struct zoran *zr = fh->zr;
2713	int i, res = 0;	2713	int i, res = 0;
2714		2714
2715	mutex_lock(&zr->resource_lock);	2715	mutex_lock(&zr->resource_lock);
2716		2716
2717	switch (fh->map_mode) {	2717	switch (fh->map_mode) {
2718	case ZORAN_MAP_MODE_RAW: /* raw capture */	2718	case ZORAN_MAP_MODE_RAW: /* raw capture */
2719	if (fh->v4l_buffers.active == ZORAN_FREE &&	2719	if (fh->v4l_buffers.active == ZORAN_FREE &&
2720	zr->v4l_buffers.active != ZORAN_FREE) {	2720	zr->v4l_buffers.active != ZORAN_FREE) {
2721	res = -EPERM; /* stay off other's settings! */	2721	res = -EPERM; /* stay off other's settings! */
2722	goto strmoff_unlock_and_return;	2722	goto strmoff_unlock_and_return;
2723	}	2723	}
2724	if (zr->v4l_buffers.active == ZORAN_FREE)	2724	if (zr->v4l_buffers.active == ZORAN_FREE)
2725	goto strmoff_unlock_and_return;	2725	goto strmoff_unlock_and_return;
2726		2726
2727	/* unload capture */	2727	/* unload capture */
2728	if (zr->v4l_memgrab_active) {	2728	if (zr->v4l_memgrab_active) {
2729	unsigned long flags;	2729	unsigned long flags;
2730		2730
2731	spin_lock_irqsave(&zr->spinlock, flags);	2731	spin_lock_irqsave(&zr->spinlock, flags);
2732	zr36057_set_memgrab(zr, 0);	2732	zr36057_set_memgrab(zr, 0);
2733	spin_unlock_irqrestore(&zr->spinlock, flags);	2733	spin_unlock_irqrestore(&zr->spinlock, flags);
2734	}	2734	}
2735		2735
2736	for (i = 0; i < fh->v4l_buffers.num_buffers; i++)	2736	for (i = 0; i < fh->v4l_buffers.num_buffers; i++)
2737	zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;	2737	zr->v4l_buffers.buffer[i].state = BUZ_STATE_USER;
2738	fh->v4l_buffers = zr->v4l_buffers;	2738	fh->v4l_buffers = zr->v4l_buffers;
2739		2739
2740	zr->v4l_buffers.active = fh->v4l_buffers.active = ZORAN_FREE;	2740	zr->v4l_buffers.active = fh->v4l_buffers.active = ZORAN_FREE;
2741		2741
2742	zr->v4l_grab_seq = 0;	2742	zr->v4l_grab_seq = 0;
2743	zr->v4l_pend_head = zr->v4l_pend_tail = 0;	2743	zr->v4l_pend_head = zr->v4l_pend_tail = 0;
2744	zr->v4l_sync_tail = 0;	2744	zr->v4l_sync_tail = 0;
2745		2745
2746	break;	2746	break;
2747		2747
2748	case ZORAN_MAP_MODE_JPG_REC:	2748	case ZORAN_MAP_MODE_JPG_REC:
2749	case ZORAN_MAP_MODE_JPG_PLAY:	2749	case ZORAN_MAP_MODE_JPG_PLAY:
2750	if (fh->jpg_buffers.active == ZORAN_FREE &&	2750	if (fh->jpg_buffers.active == ZORAN_FREE &&
2751	zr->jpg_buffers.active != ZORAN_FREE) {	2751	zr->jpg_buffers.active != ZORAN_FREE) {
2752	res = -EPERM; /* stay off other's settings! */	2752	res = -EPERM; /* stay off other's settings! */
2753	goto strmoff_unlock_and_return;	2753	goto strmoff_unlock_and_return;
2754	}	2754	}
2755	if (zr->jpg_buffers.active == ZORAN_FREE)	2755	if (zr->jpg_buffers.active == ZORAN_FREE)
2756	goto strmoff_unlock_and_return;	2756	goto strmoff_unlock_and_return;
2757		2757
2758	res = jpg_qbuf(file, -1,	2758	res = jpg_qbuf(file, -1,
2759	(fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ?	2759	(fh->map_mode == ZORAN_MAP_MODE_JPG_REC) ?
2760	BUZ_MODE_MOTION_COMPRESS :	2760	BUZ_MODE_MOTION_COMPRESS :
2761	BUZ_MODE_MOTION_DECOMPRESS);	2761	BUZ_MODE_MOTION_DECOMPRESS);
2762	if (res)	2762	if (res)
2763	goto strmoff_unlock_and_return;	2763	goto strmoff_unlock_and_return;
2764	break;	2764	break;
2765	default:	2765	default:
2766	dprintk(1, KERN_ERR	2766	dprintk(1, KERN_ERR
2767	"%s: VIDIOC_STREAMOFF - invalid map mode %d\n",	2767	"%s: VIDIOC_STREAMOFF - invalid map mode %d\n",
2768	ZR_DEVNAME(zr), fh->map_mode);	2768	ZR_DEVNAME(zr), fh->map_mode);
2769	res = -EINVAL;	2769	res = -EINVAL;
2770	break;	2770	break;
2771	}	2771	}
2772	strmoff_unlock_and_return:	2772	strmoff_unlock_and_return:
2773	mutex_unlock(&zr->resource_lock);	2773	mutex_unlock(&zr->resource_lock);
2774		2774
2775	return res;	2775	return res;
2776	}	2776	}
2777		2777
2778	static int zoran_queryctrl(struct file file, void __fh,	2778	static int zoran_queryctrl(struct file file, void __fh,
2779	struct v4l2_queryctrl *ctrl)	2779	struct v4l2_queryctrl *ctrl)
2780	{	2780	{
2781	struct zoran_fh *fh = __fh;	2781	struct zoran_fh *fh = __fh;
2782	struct zoran *zr = fh->zr;	2782	struct zoran *zr = fh->zr;
2783		2783
2784	/* we only support hue/saturation/contrast/brightness */	2784	/* we only support hue/saturation/contrast/brightness */
2785	if (ctrl->id < V4L2_CID_BRIGHTNESS \|\|	2785	if (ctrl->id < V4L2_CID_BRIGHTNESS \|\|
2786	ctrl->id > V4L2_CID_HUE)	2786	ctrl->id > V4L2_CID_HUE)
2787	return -EINVAL;	2787	return -EINVAL;
2788		2788
2789	decoder_call(zr, core, queryctrl, ctrl);	2789	decoder_call(zr, core, queryctrl, ctrl);
2790		2790
2791	return 0;	2791	return 0;
2792	}	2792	}
2793		2793
2794	static int zoran_g_ctrl(struct file file, void __fh, struct v4l2_control *ctrl)	2794	static int zoran_g_ctrl(struct file file, void __fh, struct v4l2_control *ctrl)
2795	{	2795	{
2796	struct zoran_fh *fh = __fh;	2796	struct zoran_fh *fh = __fh;
2797	struct zoran *zr = fh->zr;	2797	struct zoran *zr = fh->zr;
2798		2798
2799	/* we only support hue/saturation/contrast/brightness */	2799	/* we only support hue/saturation/contrast/brightness */
2800	if (ctrl->id < V4L2_CID_BRIGHTNESS \|\|	2800	if (ctrl->id < V4L2_CID_BRIGHTNESS \|\|
2801	ctrl->id > V4L2_CID_HUE)	2801	ctrl->id > V4L2_CID_HUE)
2802	return -EINVAL;	2802	return -EINVAL;
2803		2803
2804	mutex_lock(&zr->resource_lock);	2804	mutex_lock(&zr->resource_lock);
2805	decoder_call(zr, core, g_ctrl, ctrl);	2805	decoder_call(zr, core, g_ctrl, ctrl);
2806	mutex_unlock(&zr->resource_lock);	2806	mutex_unlock(&zr->resource_lock);
2807		2807
2808	return 0;	2808	return 0;
2809	}	2809	}
2810		2810
2811	static int zoran_s_ctrl(struct file file, void __fh, struct v4l2_control *ctrl)	2811	static int zoran_s_ctrl(struct file file, void __fh, struct v4l2_control *ctrl)
2812	{	2812	{
2813	struct zoran_fh *fh = __fh;	2813	struct zoran_fh *fh = __fh;
2814	struct zoran *zr = fh->zr;	2814	struct zoran *zr = fh->zr;
2815		2815
2816	/* we only support hue/saturation/contrast/brightness */	2816	/* we only support hue/saturation/contrast/brightness */
2817	if (ctrl->id < V4L2_CID_BRIGHTNESS \|\|	2817	if (ctrl->id < V4L2_CID_BRIGHTNESS \|\|
2818	ctrl->id > V4L2_CID_HUE)	2818	ctrl->id > V4L2_CID_HUE)
2819	return -EINVAL;	2819	return -EINVAL;
2820		2820
2821	mutex_lock(&zr->resource_lock);	2821	mutex_lock(&zr->resource_lock);
2822	decoder_call(zr, core, s_ctrl, ctrl);	2822	decoder_call(zr, core, s_ctrl, ctrl);
2823	mutex_unlock(&zr->resource_lock);	2823	mutex_unlock(&zr->resource_lock);
2824		2824
2825	return 0;	2825	return 0;
2826	}	2826	}
2827		2827
2828	static int zoran_g_std(struct file file, void __fh, v4l2_std_id *std)	2828	static int zoran_g_std(struct file file, void __fh, v4l2_std_id *std)
2829	{	2829	{
2830	struct zoran_fh *fh = __fh;	2830	struct zoran_fh *fh = __fh;
2831	struct zoran *zr = fh->zr;	2831	struct zoran *zr = fh->zr;
2832		2832
2833	mutex_lock(&zr->resource_lock);	2833	mutex_lock(&zr->resource_lock);
2834	*std = zr->norm;	2834	*std = zr->norm;
2835	mutex_unlock(&zr->resource_lock);	2835	mutex_unlock(&zr->resource_lock);
2836	return 0;	2836	return 0;
2837	}	2837	}
2838		2838
2839	static int zoran_s_std(struct file file, void __fh, v4l2_std_id *std)	2839	static int zoran_s_std(struct file file, void __fh, v4l2_std_id *std)
2840	{	2840	{
2841	struct zoran_fh *fh = __fh;	2841	struct zoran_fh *fh = __fh;
2842	struct zoran *zr = fh->zr;	2842	struct zoran *zr = fh->zr;
2843	int res = 0;	2843	int res = 0;
2844		2844
2845	mutex_lock(&zr->resource_lock);	2845	mutex_lock(&zr->resource_lock);
2846	res = zoran_set_norm(zr, *std);	2846	res = zoran_set_norm(zr, *std);
2847	if (res)	2847	if (res)
2848	goto sstd_unlock_and_return;	2848	goto sstd_unlock_and_return;
2849		2849
2850	res = wait_grab_pending(zr);	2850	res = wait_grab_pending(zr);
2851	sstd_unlock_and_return:	2851	sstd_unlock_and_return:
2852	mutex_unlock(&zr->resource_lock);	2852	mutex_unlock(&zr->resource_lock);
2853	return res;	2853	return res;
2854	}	2854	}
2855		2855
2856	static int zoran_enum_input(struct file file, void __fh,	2856	static int zoran_enum_input(struct file file, void __fh,
2857	struct v4l2_input *inp)	2857	struct v4l2_input *inp)
2858	{	2858	{
2859	struct zoran_fh *fh = __fh;	2859	struct zoran_fh *fh = __fh;
2860	struct zoran *zr = fh->zr;	2860	struct zoran *zr = fh->zr;
2861		2861
2862	if (inp->index < 0 \|\| inp->index >= zr->card.inputs)	2862	if (inp->index < 0 \|\| inp->index >= zr->card.inputs)
2863	return -EINVAL;	2863	return -EINVAL;
2864	else {	2864	else {
2865	int id = inp->index;	2865	int id = inp->index;
2866	memset(inp, 0, sizeof(*inp));	2866	memset(inp, 0, sizeof(*inp));
2867	inp->index = id;	2867	inp->index = id;
2868	}	2868	}
2869		2869
2870	strncpy(inp->name, zr->card.input[inp->index].name,	2870	strncpy(inp->name, zr->card.input[inp->index].name,
2871	sizeof(inp->name) - 1);	2871	sizeof(inp->name) - 1);
2872	inp->type = V4L2_INPUT_TYPE_CAMERA;	2872	inp->type = V4L2_INPUT_TYPE_CAMERA;
2873	inp->std = V4L2_STD_ALL;	2873	inp->std = V4L2_STD_ALL;
2874		2874
2875	/* Get status of video decoder */	2875	/* Get status of video decoder */
2876	mutex_lock(&zr->resource_lock);	2876	mutex_lock(&zr->resource_lock);
2877	decoder_call(zr, video, g_input_status, &inp->status);	2877	decoder_call(zr, video, g_input_status, &inp->status);
2878	mutex_unlock(&zr->resource_lock);	2878	mutex_unlock(&zr->resource_lock);
2879	return 0;	2879	return 0;
2880	}	2880	}
2881		2881
2882	static int zoran_g_input(struct file file, void __fh, unsigned int *input)	2882	static int zoran_g_input(struct file file, void __fh, unsigned int *input)
2883	{	2883	{
2884	struct zoran_fh *fh = __fh;	2884	struct zoran_fh *fh = __fh;
2885	struct zoran *zr = fh->zr;	2885	struct zoran *zr = fh->zr;
2886		2886
2887	mutex_lock(&zr->resource_lock);	2887	mutex_lock(&zr->resource_lock);
2888	*input = zr->input;	2888	*input = zr->input;
2889	mutex_unlock(&zr->resource_lock);	2889	mutex_unlock(&zr->resource_lock);
2890		2890
2891	return 0;	2891	return 0;
2892	}	2892	}
2893		2893
2894	static int zoran_s_input(struct file file, void __fh, unsigned int input)	2894	static int zoran_s_input(struct file file, void __fh, unsigned int input)
2895	{	2895	{
2896	struct zoran_fh *fh = __fh;	2896	struct zoran_fh *fh = __fh;
2897	struct zoran *zr = fh->zr;	2897	struct zoran *zr = fh->zr;
2898	int res;	2898	int res;
2899		2899
2900	mutex_lock(&zr->resource_lock);	2900	mutex_lock(&zr->resource_lock);
2901	res = zoran_set_input(zr, input);	2901	res = zoran_set_input(zr, input);
2902	if (res)	2902	if (res)
2903	goto sinput_unlock_and_return;	2903	goto sinput_unlock_and_return;
2904		2904
2905	/* Make sure the changes come into effect */	2905	/* Make sure the changes come into effect */
2906	res = wait_grab_pending(zr);	2906	res = wait_grab_pending(zr);
2907	sinput_unlock_and_return:	2907	sinput_unlock_and_return:
2908	mutex_unlock(&zr->resource_lock);	2908	mutex_unlock(&zr->resource_lock);
2909	return res;	2909	return res;
2910	}	2910	}
2911		2911
2912	static int zoran_enum_output(struct file file, void __fh,	2912	static int zoran_enum_output(struct file file, void __fh,
2913	struct v4l2_output *outp)	2913	struct v4l2_output *outp)
2914	{	2914	{
2915	if (outp->index != 0)	2915	if (outp->index != 0)
2916	return -EINVAL;	2916	return -EINVAL;
2917		2917
2918	memset(outp, 0, sizeof(*outp));	2918	memset(outp, 0, sizeof(*outp));
2919	outp->index = 0;	2919	outp->index = 0;
2920	outp->type = V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY;	2920	outp->type = V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY;
2921	strncpy(outp->name, "Autodetect", sizeof(outp->name)-1);	2921	strncpy(outp->name, "Autodetect", sizeof(outp->name)-1);
2922		2922
2923	return 0;	2923	return 0;
2924	}	2924	}
2925		2925
2926	static int zoran_g_output(struct file file, void __fh, unsigned int *output)	2926	static int zoran_g_output(struct file file, void __fh, unsigned int *output)
2927	{	2927	{
2928	*output = 0;	2928	*output = 0;
2929		2929
2930	return 0;	2930	return 0;
2931	}	2931	}
2932		2932
2933	static int zoran_s_output(struct file file, void __fh, unsigned int output)	2933	static int zoran_s_output(struct file file, void __fh, unsigned int output)
2934	{	2934	{
2935	if (output != 0)	2935	if (output != 0)
2936	return -EINVAL;	2936	return -EINVAL;
2937		2937
2938	return 0;	2938	return 0;
2939	}	2939	}
2940		2940
2941	/* cropping (sub-frame capture) */	2941	/* cropping (sub-frame capture) */
2942	static int zoran_cropcap(struct file file, void __fh,	2942	static int zoran_cropcap(struct file file, void __fh,
2943	struct v4l2_cropcap *cropcap)	2943	struct v4l2_cropcap *cropcap)
2944	{	2944	{
2945	struct zoran_fh *fh = __fh;	2945	struct zoran_fh *fh = __fh;
2946	struct zoran *zr = fh->zr;	2946	struct zoran *zr = fh->zr;
2947	int type = cropcap->type, res = 0;	2947	int type = cropcap->type, res = 0;
2948		2948
2949	memset(cropcap, 0, sizeof(*cropcap));	2949	memset(cropcap, 0, sizeof(*cropcap));
2950	cropcap->type = type;	2950	cropcap->type = type;
2951		2951
2952	mutex_lock(&zr->resource_lock);	2952	mutex_lock(&zr->resource_lock);
2953		2953
2954	if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&	2954	if (cropcap->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2955	(cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE \|\|	2955	(cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE \|\|
2956	fh->map_mode == ZORAN_MAP_MODE_RAW)) {	2956	fh->map_mode == ZORAN_MAP_MODE_RAW)) {
2957	dprintk(1, KERN_ERR	2957	dprintk(1, KERN_ERR
2958	"%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n",	2958	"%s: VIDIOC_CROPCAP - subcapture only supported for compressed capture\n",
2959	ZR_DEVNAME(zr));	2959	ZR_DEVNAME(zr));
2960	res = -EINVAL;	2960	res = -EINVAL;
2961	goto cropcap_unlock_and_return;	2961	goto cropcap_unlock_and_return;
2962	}	2962	}
2963		2963
2964	cropcap->bounds.top = cropcap->bounds.left = 0;	2964	cropcap->bounds.top = cropcap->bounds.left = 0;
2965	cropcap->bounds.width = BUZ_MAX_WIDTH;	2965	cropcap->bounds.width = BUZ_MAX_WIDTH;
2966	cropcap->bounds.height = BUZ_MAX_HEIGHT;	2966	cropcap->bounds.height = BUZ_MAX_HEIGHT;
2967	cropcap->defrect.top = cropcap->defrect.left = 0;	2967	cropcap->defrect.top = cropcap->defrect.left = 0;
2968	cropcap->defrect.width = BUZ_MIN_WIDTH;	2968	cropcap->defrect.width = BUZ_MIN_WIDTH;
2969	cropcap->defrect.height = BUZ_MIN_HEIGHT;	2969	cropcap->defrect.height = BUZ_MIN_HEIGHT;
2970	cropcap_unlock_and_return:	2970	cropcap_unlock_and_return:
2971	mutex_unlock(&zr->resource_lock);	2971	mutex_unlock(&zr->resource_lock);
2972	return res;	2972	return res;
2973	}	2973	}
2974		2974
2975	static int zoran_g_crop(struct file file, void __fh, struct v4l2_crop *crop)	2975	static int zoran_g_crop(struct file file, void __fh, struct v4l2_crop *crop)
2976	{	2976	{
2977	struct zoran_fh *fh = __fh;	2977	struct zoran_fh *fh = __fh;
2978	struct zoran *zr = fh->zr;	2978	struct zoran *zr = fh->zr;
2979	int type = crop->type, res = 0;	2979	int type = crop->type, res = 0;
2980		2980
2981	memset(crop, 0, sizeof(*crop));	2981	memset(crop, 0, sizeof(*crop));
2982	crop->type = type;	2982	crop->type = type;
2983		2983
2984	mutex_lock(&zr->resource_lock);	2984	mutex_lock(&zr->resource_lock);
2985		2985
2986	if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&	2986	if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
2987	(crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE \|\|	2987	(crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE \|\|
2988	fh->map_mode == ZORAN_MAP_MODE_RAW)) {	2988	fh->map_mode == ZORAN_MAP_MODE_RAW)) {
2989	dprintk(1,	2989	dprintk(1,
2990	KERN_ERR	2990	KERN_ERR
2991	"%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",	2991	"%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
2992	ZR_DEVNAME(zr));	2992	ZR_DEVNAME(zr));
2993	res = -EINVAL;	2993	res = -EINVAL;
2994	goto gcrop_unlock_and_return;	2994	goto gcrop_unlock_and_return;
2995	}	2995	}
2996		2996
2997	crop->c.top = fh->jpg_settings.img_y;	2997	crop->c.top = fh->jpg_settings.img_y;
2998	crop->c.left = fh->jpg_settings.img_x;	2998	crop->c.left = fh->jpg_settings.img_x;
2999	crop->c.width = fh->jpg_settings.img_width;	2999	crop->c.width = fh->jpg_settings.img_width;
3000	crop->c.height = fh->jpg_settings.img_height;	3000	crop->c.height = fh->jpg_settings.img_height;
3001		3001
3002	gcrop_unlock_and_return:	3002	gcrop_unlock_and_return:
3003	mutex_unlock(&zr->resource_lock);	3003	mutex_unlock(&zr->resource_lock);
3004		3004
3005	return res;	3005	return res;
3006	}	3006	}
3007		3007
3008	static int zoran_s_crop(struct file file, void __fh, struct v4l2_crop *crop)	3008	static int zoran_s_crop(struct file file, void __fh, struct v4l2_crop *crop)
3009	{	3009	{
3010	struct zoran_fh *fh = __fh;	3010	struct zoran_fh *fh = __fh;
3011	struct zoran *zr = fh->zr;	3011	struct zoran *zr = fh->zr;
3012	int res = 0;	3012	int res = 0;
3013	struct zoran_jpg_settings settings;	3013	struct zoran_jpg_settings settings;
3014		3014
3015	settings = fh->jpg_settings;	3015	settings = fh->jpg_settings;
3016		3016
3017	mutex_lock(&zr->resource_lock);	3017	mutex_lock(&zr->resource_lock);
3018		3018
3019	if (fh->jpg_buffers.allocated \|\| fh->v4l_buffers.allocated) {	3019	if (fh->jpg_buffers.allocated \|\| fh->v4l_buffers.allocated) {
3020	dprintk(1, KERN_ERR	3020	dprintk(1, KERN_ERR
3021	"%s: VIDIOC_S_CROP - cannot change settings while active\n",	3021	"%s: VIDIOC_S_CROP - cannot change settings while active\n",
3022	ZR_DEVNAME(zr));	3022	ZR_DEVNAME(zr));
3023	res = -EBUSY;	3023	res = -EBUSY;
3024	goto scrop_unlock_and_return;	3024	goto scrop_unlock_and_return;
3025	}	3025	}
3026		3026
3027	if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&	3027	if (crop->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
3028	(crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE \|\|	3028	(crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE \|\|
3029	fh->map_mode == ZORAN_MAP_MODE_RAW)) {	3029	fh->map_mode == ZORAN_MAP_MODE_RAW)) {
3030	dprintk(1, KERN_ERR	3030	dprintk(1, KERN_ERR
3031	"%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",	3031	"%s: VIDIOC_G_CROP - subcapture only supported for compressed capture\n",
3032	ZR_DEVNAME(zr));	3032	ZR_DEVNAME(zr));
3033	res = -EINVAL;	3033	res = -EINVAL;
3034	goto scrop_unlock_and_return;	3034	goto scrop_unlock_and_return;
3035	}	3035	}
3036		3036
3037	/* move into a form that we understand */	3037	/* move into a form that we understand */
3038	settings.img_x = crop->c.left;	3038	settings.img_x = crop->c.left;
3039	settings.img_y = crop->c.top;	3039	settings.img_y = crop->c.top;
3040	settings.img_width = crop->c.width;	3040	settings.img_width = crop->c.width;
3041	settings.img_height = crop->c.height;	3041	settings.img_height = crop->c.height;
3042		3042
3043	/* check validity */	3043	/* check validity */
3044	res = zoran_check_jpg_settings(zr, &settings, 0);	3044	res = zoran_check_jpg_settings(zr, &settings, 0);
3045	if (res)	3045	if (res)
3046	goto scrop_unlock_and_return;	3046	goto scrop_unlock_and_return;
3047		3047
3048	/* accept */	3048	/* accept */
3049	fh->jpg_settings = settings;	3049	fh->jpg_settings = settings;
3050		3050
3051	scrop_unlock_and_return:	3051	scrop_unlock_and_return:
3052	mutex_unlock(&zr->resource_lock);	3052	mutex_unlock(&zr->resource_lock);
3053	return res;	3053	return res;
3054	}	3054	}
3055		3055
3056	static int zoran_g_jpegcomp(struct file file, void __fh,	3056	static int zoran_g_jpegcomp(struct file file, void __fh,
3057	struct v4l2_jpegcompression *params)	3057	struct v4l2_jpegcompression *params)
3058	{	3058	{
3059	struct zoran_fh *fh = __fh;	3059	struct zoran_fh *fh = __fh;
3060	struct zoran *zr = fh->zr;	3060	struct zoran *zr = fh->zr;
3061	memset(params, 0, sizeof(*params));	3061	memset(params, 0, sizeof(*params));
3062		3062
3063	mutex_lock(&zr->resource_lock);	3063	mutex_lock(&zr->resource_lock);
3064		3064
3065	params->quality = fh->jpg_settings.jpg_comp.quality;	3065	params->quality = fh->jpg_settings.jpg_comp.quality;
3066	params->APPn = fh->jpg_settings.jpg_comp.APPn;	3066	params->APPn = fh->jpg_settings.jpg_comp.APPn;
3067	memcpy(params->APP_data,	3067	memcpy(params->APP_data,
3068	fh->jpg_settings.jpg_comp.APP_data,	3068	fh->jpg_settings.jpg_comp.APP_data,
3069	fh->jpg_settings.jpg_comp.APP_len);	3069	fh->jpg_settings.jpg_comp.APP_len);
3070	params->APP_len = fh->jpg_settings.jpg_comp.APP_len;	3070	params->APP_len = fh->jpg_settings.jpg_comp.APP_len;
3071	memcpy(params->COM_data,	3071	memcpy(params->COM_data,
3072	fh->jpg_settings.jpg_comp.COM_data,	3072	fh->jpg_settings.jpg_comp.COM_data,
3073	fh->jpg_settings.jpg_comp.COM_len);	3073	fh->jpg_settings.jpg_comp.COM_len);
3074	params->COM_len = fh->jpg_settings.jpg_comp.COM_len;	3074	params->COM_len = fh->jpg_settings.jpg_comp.COM_len;
3075	params->jpeg_markers =	3075	params->jpeg_markers =
3076	fh->jpg_settings.jpg_comp.jpeg_markers;	3076	fh->jpg_settings.jpg_comp.jpeg_markers;
3077		3077
3078	mutex_unlock(&zr->resource_lock);	3078	mutex_unlock(&zr->resource_lock);
3079		3079
3080	return 0;	3080	return 0;
3081	}	3081	}
3082		3082
3083	static int zoran_s_jpegcomp(struct file file, void __fh,	3083	static int zoran_s_jpegcomp(struct file file, void __fh,
3084	struct v4l2_jpegcompression *params)	3084	struct v4l2_jpegcompression *params)
3085	{	3085	{
3086	struct zoran_fh *fh = __fh;	3086	struct zoran_fh *fh = __fh;
3087	struct zoran *zr = fh->zr;	3087	struct zoran *zr = fh->zr;
3088	int res = 0;	3088	int res = 0;
3089	struct zoran_jpg_settings settings;	3089	struct zoran_jpg_settings settings;
3090		3090
3091	settings = fh->jpg_settings;	3091	settings = fh->jpg_settings;
3092		3092
3093	settings.jpg_comp = *params;	3093	settings.jpg_comp = *params;
3094		3094
3095	mutex_lock(&zr->resource_lock);	3095	mutex_lock(&zr->resource_lock);
3096		3096
3097	if (fh->v4l_buffers.active != ZORAN_FREE \|\|	3097	if (fh->v4l_buffers.active != ZORAN_FREE \|\|
3098	fh->jpg_buffers.active != ZORAN_FREE) {	3098	fh->jpg_buffers.active != ZORAN_FREE) {
3099	dprintk(1, KERN_WARNING	3099	dprintk(1, KERN_WARNING
3100	"%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n",	3100	"%s: VIDIOC_S_JPEGCOMP called while in playback/capture mode\n",
3101	ZR_DEVNAME(zr));	3101	ZR_DEVNAME(zr));
3102	res = -EBUSY;	3102	res = -EBUSY;
3103	goto sjpegc_unlock_and_return;	3103	goto sjpegc_unlock_and_return;
3104	}	3104	}
3105		3105
3106	res = zoran_check_jpg_settings(zr, &settings, 0);	3106	res = zoran_check_jpg_settings(zr, &settings, 0);
3107	if (res)	3107	if (res)
3108	goto sjpegc_unlock_and_return;	3108	goto sjpegc_unlock_and_return;
3109	if (!fh->jpg_buffers.allocated)	3109	if (!fh->jpg_buffers.allocated)
3110	fh->jpg_buffers.buffer_size =	3110	fh->jpg_buffers.buffer_size =
3111	zoran_v4l2_calc_bufsize(&fh->jpg_settings);	3111	zoran_v4l2_calc_bufsize(&fh->jpg_settings);
3112	fh->jpg_settings.jpg_comp = *params = settings.jpg_comp;	3112	fh->jpg_settings.jpg_comp = *params = settings.jpg_comp;
3113	sjpegc_unlock_and_return:	3113	sjpegc_unlock_and_return:
3114	mutex_unlock(&zr->resource_lock);	3114	mutex_unlock(&zr->resource_lock);
3115		3115
3116	return res;	3116	return res;
3117	}	3117	}
3118		3118
3119	static unsigned int	3119	static unsigned int
3120	zoran_poll (struct file *file,	3120	zoran_poll (struct file *file,
3121	poll_table *wait)	3121	poll_table *wait)
3122	{	3122	{
3123	struct zoran_fh *fh = file->private_data;	3123	struct zoran_fh *fh = file->private_data;
3124	struct zoran *zr = fh->zr;	3124	struct zoran *zr = fh->zr;
3125	int res = 0, frame;	3125	int res = 0, frame;
3126	unsigned long flags;	3126	unsigned long flags;
3127		3127
3128	/* we should check whether buffers are ready to be synced on	3128	/* we should check whether buffers are ready to be synced on
3129	* (w/o waits - O_NONBLOCK) here	3129	* (w/o waits - O_NONBLOCK) here
3130	* if ready for read (sync), return POLLIN\|POLLRDNORM,	3130	* if ready for read (sync), return POLLIN\|POLLRDNORM,
3131	* if ready for write (sync), return POLLOUT\|POLLWRNORM,	3131	* if ready for write (sync), return POLLOUT\|POLLWRNORM,
3132	* if error, return POLLERR,	3132	* if error, return POLLERR,
3133	* if no buffers queued or so, return POLLNVAL	3133	* if no buffers queued or so, return POLLNVAL
3134	*/	3134	*/
3135		3135
3136	mutex_lock(&zr->resource_lock);	3136	mutex_lock(&zr->resource_lock);
3137		3137
3138	switch (fh->map_mode) {	3138	switch (fh->map_mode) {
3139	case ZORAN_MAP_MODE_RAW:	3139	case ZORAN_MAP_MODE_RAW:
3140	poll_wait(file, &zr->v4l_capq, wait);	3140	poll_wait(file, &zr->v4l_capq, wait);
3141	frame = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];	3141	frame = zr->v4l_pend[zr->v4l_sync_tail & V4L_MASK_FRAME];
3142		3142
3143	spin_lock_irqsave(&zr->spinlock, flags);	3143	spin_lock_irqsave(&zr->spinlock, flags);
3144	dprintk(3,	3144	dprintk(3,
3145	KERN_DEBUG	3145	KERN_DEBUG
3146	"%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",	3146	"%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",
3147	ZR_DEVNAME(zr), __func__,	3147	ZR_DEVNAME(zr), __func__,
3148	"FAL"[fh->v4l_buffers.active], zr->v4l_sync_tail,	3148	"FAL"[fh->v4l_buffers.active], zr->v4l_sync_tail,
3149	"UPMD"[zr->v4l_buffers.buffer[frame].state],	3149	"UPMD"[zr->v4l_buffers.buffer[frame].state],
3150	zr->v4l_pend_tail, zr->v4l_pend_head);	3150	zr->v4l_pend_tail, zr->v4l_pend_head);
3151	/* Process is the one capturing? */	3151	/* Process is the one capturing? */
3152	if (fh->v4l_buffers.active != ZORAN_FREE &&	3152	if (fh->v4l_buffers.active != ZORAN_FREE &&
3153	/* Buffer ready to DQBUF? */	3153	/* Buffer ready to DQBUF? */
3154	zr->v4l_buffers.buffer[frame].state == BUZ_STATE_DONE)	3154	zr->v4l_buffers.buffer[frame].state == BUZ_STATE_DONE)
3155	res = POLLIN \| POLLRDNORM;	3155	res = POLLIN \| POLLRDNORM;
3156	spin_unlock_irqrestore(&zr->spinlock, flags);	3156	spin_unlock_irqrestore(&zr->spinlock, flags);
3157		3157
3158	break;	3158	break;
3159		3159
3160	case ZORAN_MAP_MODE_JPG_REC:	3160	case ZORAN_MAP_MODE_JPG_REC:
3161	case ZORAN_MAP_MODE_JPG_PLAY:	3161	case ZORAN_MAP_MODE_JPG_PLAY:
3162	poll_wait(file, &zr->jpg_capq, wait);	3162	poll_wait(file, &zr->jpg_capq, wait);
3163	frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];	3163	frame = zr->jpg_pend[zr->jpg_que_tail & BUZ_MASK_FRAME];
3164		3164
3165	spin_lock_irqsave(&zr->spinlock, flags);	3165	spin_lock_irqsave(&zr->spinlock, flags);
3166	dprintk(3,	3166	dprintk(3,
3167	KERN_DEBUG	3167	KERN_DEBUG
3168	"%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",	3168	"%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",
3169	ZR_DEVNAME(zr), __func__,	3169	ZR_DEVNAME(zr), __func__,
3170	"FAL"[fh->jpg_buffers.active], zr->jpg_que_tail,	3170	"FAL"[fh->jpg_buffers.active], zr->jpg_que_tail,
3171	"UPMD"[zr->jpg_buffers.buffer[frame].state],	3171	"UPMD"[zr->jpg_buffers.buffer[frame].state],
3172	zr->jpg_que_head, zr->jpg_dma_tail, zr->jpg_dma_head);	3172	zr->jpg_que_head, zr->jpg_dma_tail, zr->jpg_dma_head);
3173	if (fh->jpg_buffers.active != ZORAN_FREE &&	3173	if (fh->jpg_buffers.active != ZORAN_FREE &&
3174	zr->jpg_buffers.buffer[frame].state == BUZ_STATE_DONE) {	3174	zr->jpg_buffers.buffer[frame].state == BUZ_STATE_DONE) {
3175	if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC)	3175	if (fh->map_mode == ZORAN_MAP_MODE_JPG_REC)
3176	res = POLLIN \| POLLRDNORM;	3176	res = POLLIN \| POLLRDNORM;
3177	else	3177	else
3178	res = POLLOUT \| POLLWRNORM;	3178	res = POLLOUT \| POLLWRNORM;
3179	}	3179	}
3180	spin_unlock_irqrestore(&zr->spinlock, flags);	3180	spin_unlock_irqrestore(&zr->spinlock, flags);
3181		3181
3182	break;	3182	break;
3183		3183
3184	default:	3184	default:
3185	dprintk(1,	3185	dprintk(1,
3186	KERN_ERR	3186	KERN_ERR
3187	"%s: zoran_poll() - internal error, unknown map_mode=%d\n",	3187	"%s: zoran_poll() - internal error, unknown map_mode=%d\n",
3188	ZR_DEVNAME(zr), fh->map_mode);	3188	ZR_DEVNAME(zr), fh->map_mode);
3189	res = POLLNVAL;	3189	res = POLLNVAL;
3190	}	3190	}
3191		3191
3192	mutex_unlock(&zr->resource_lock);	3192	mutex_unlock(&zr->resource_lock);
3193		3193
3194	return res;	3194	return res;
3195	}	3195	}
3196		3196
3197		3197
3198	/*	3198	/*
3199	* This maps the buffers to user space.	3199	* This maps the buffers to user space.
3200	*	3200	*
3201	* Depending on the state of fh->map_mode	3201	* Depending on the state of fh->map_mode
3202	* the V4L or the MJPEG buffers are mapped	3202	* the V4L or the MJPEG buffers are mapped
3203	* per buffer or all together	3203	* per buffer or all together
3204	*	3204	*
3205	* Note that we need to connect to some	3205	* Note that we need to connect to some
3206	* unmap signal event to unmap the de-allocate	3206	* unmap signal event to unmap the de-allocate
3207	* the buffer accordingly (zoran_vm_close())	3207	* the buffer accordingly (zoran_vm_close())
3208	*/	3208	*/
3209		3209
3210	static void	3210	static void
3211	zoran_vm_open (struct vm_area_struct *vma)	3211	zoran_vm_open (struct vm_area_struct *vma)
3212	{	3212	{
3213	struct zoran_mapping *map = vma->vm_private_data;	3213	struct zoran_mapping *map = vma->vm_private_data;
3214		3214
3215	map->count++;	3215	map->count++;
3216	}	3216	}
3217		3217
3218	static void	3218	static void
3219	zoran_vm_close (struct vm_area_struct *vma)	3219	zoran_vm_close (struct vm_area_struct *vma)
3220	{	3220	{
3221	struct zoran_mapping *map = vma->vm_private_data;	3221	struct zoran_mapping *map = vma->vm_private_data;
3222	struct file *file = map->file;	3222	struct file *file = map->file;
3223	struct zoran_fh *fh = file->private_data;	3223	struct zoran_fh *fh = file->private_data;
3224	struct zoran *zr = fh->zr;	3224	struct zoran *zr = fh->zr;
3225	int i;	3225	int i;
3226		3226
3227	map->count--;	3227	map->count--;
3228	if (map->count == 0) {	3228	if (map->count == 0) {
3229	switch (fh->map_mode) {	3229	switch (fh->map_mode) {
3230	case ZORAN_MAP_MODE_JPG_REC:	3230	case ZORAN_MAP_MODE_JPG_REC:
3231	case ZORAN_MAP_MODE_JPG_PLAY:	3231	case ZORAN_MAP_MODE_JPG_PLAY:
3232		3232
3233	dprintk(3, KERN_INFO "%s: munmap(MJPEG)\n",	3233	dprintk(3, KERN_INFO "%s: munmap(MJPEG)\n",
3234	ZR_DEVNAME(zr));	3234	ZR_DEVNAME(zr));
3235		3235
3236	for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {	3236	for (i = 0; i < fh->jpg_buffers.num_buffers; i++) {
3237	if (fh->jpg_buffers.buffer[i].map == map) {	3237	if (fh->jpg_buffers.buffer[i].map == map) {
3238	fh->jpg_buffers.buffer[i].map =	3238	fh->jpg_buffers.buffer[i].map =
3239	NULL;	3239	NULL;
3240	}	3240	}
3241	}	3241	}
3242	kfree(map);	3242	kfree(map);
3243		3243
3244	for (i = 0; i < fh->jpg_buffers.num_buffers; i++)	3244	for (i = 0; i < fh->jpg_buffers.num_buffers; i++)
3245	if (fh->jpg_buffers.buffer[i].map)	3245	if (fh->jpg_buffers.buffer[i].map)
3246	break;	3246	break;
3247	if (i == fh->jpg_buffers.num_buffers) {	3247	if (i == fh->jpg_buffers.num_buffers) {
3248	mutex_lock(&zr->resource_lock);	3248	mutex_lock(&zr->resource_lock);
3249		3249
3250	if (fh->jpg_buffers.active != ZORAN_FREE) {	3250	if (fh->jpg_buffers.active != ZORAN_FREE) {
3251	jpg_qbuf(file, -1, zr->codec_mode);	3251	jpg_qbuf(file, -1, zr->codec_mode);
3252	zr->jpg_buffers.allocated = 0;	3252	zr->jpg_buffers.allocated = 0;
3253	zr->jpg_buffers.active =	3253	zr->jpg_buffers.active =
3254	fh->jpg_buffers.active =	3254	fh->jpg_buffers.active =
3255	ZORAN_FREE;	3255	ZORAN_FREE;
3256	}	3256	}
3257	jpg_fbuffer_free(file);	3257	jpg_fbuffer_free(file);
3258	mutex_unlock(&zr->resource_lock);	3258	mutex_unlock(&zr->resource_lock);
3259	}	3259	}
3260		3260
3261	break;	3261	break;
3262		3262
3263	case ZORAN_MAP_MODE_RAW:	3263	case ZORAN_MAP_MODE_RAW:
3264		3264
3265	dprintk(3, KERN_INFO "%s: munmap(V4L)\n",	3265	dprintk(3, KERN_INFO "%s: munmap(V4L)\n",
3266	ZR_DEVNAME(zr));	3266	ZR_DEVNAME(zr));
3267		3267
3268	for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {	3268	for (i = 0; i < fh->v4l_buffers.num_buffers; i++) {
3269	if (fh->v4l_buffers.buffer[i].map == map) {	3269	if (fh->v4l_buffers.buffer[i].map == map) {
3270	/* unqueue/unmap */	3270	/* unqueue/unmap */
3271	fh->v4l_buffers.buffer[i].map =	3271	fh->v4l_buffers.buffer[i].map =
3272	NULL;	3272	NULL;
3273	}	3273	}
3274	}	3274	}
3275	kfree(map);	3275	kfree(map);
3276		3276
3277	for (i = 0; i < fh->v4l_buffers.num_buffers; i++)	3277	for (i = 0; i < fh->v4l_buffers.num_buffers; i++)
3278	if (fh->v4l_buffers.buffer[i].map)	3278	if (fh->v4l_buffers.buffer[i].map)
3279	break;	3279	break;
3280	if (i == fh->v4l_buffers.num_buffers) {	3280	if (i == fh->v4l_buffers.num_buffers) {
3281	mutex_lock(&zr->resource_lock);	3281	mutex_lock(&zr->resource_lock);
3282		3282
3283	if (fh->v4l_buffers.active != ZORAN_FREE) {	3283	if (fh->v4l_buffers.active != ZORAN_FREE) {
3284	unsigned long flags;	3284	unsigned long flags;
3285		3285
3286	spin_lock_irqsave(&zr->spinlock, flags);	3286	spin_lock_irqsave(&zr->spinlock, flags);
3287	zr36057_set_memgrab(zr, 0);	3287	zr36057_set_memgrab(zr, 0);
3288	zr->v4l_buffers.allocated = 0;	3288	zr->v4l_buffers.allocated = 0;
3289	zr->v4l_buffers.active =	3289	zr->v4l_buffers.active =
3290	fh->v4l_buffers.active =	3290	fh->v4l_buffers.active =
3291	ZORAN_FREE;	3291	ZORAN_FREE;
3292	spin_unlock_irqrestore(&zr->spinlock, flags);	3292	spin_unlock_irqrestore(&zr->spinlock, flags);
3293	}	3293	}
3294	v4l_fbuffer_free(file);	3294	v4l_fbuffer_free(file);
3295	mutex_unlock(&zr->resource_lock);	3295	mutex_unlock(&zr->resource_lock);
3296	}	3296	}
3297		3297
3298	break;	3298	break;
3299		3299
3300	default:	3300	default:
3301	printk(KERN_ERR	3301	printk(KERN_ERR
3302	"%s: munmap() - internal error - unknown map mode %d\n",	3302	"%s: munmap() - internal error - unknown map mode %d\n",
3303	ZR_DEVNAME(zr), fh->map_mode);	3303	ZR_DEVNAME(zr), fh->map_mode);
3304	break;	3304	break;
3305		3305
3306	}	3306	}
3307	}	3307	}
3308	}	3308	}
3309		3309
3310	static struct vm_operations_struct zoran_vm_ops = {	3310	static struct vm_operations_struct zoran_vm_ops = {
3311	.open = zoran_vm_open,	3311	.open = zoran_vm_open,
3312	.close = zoran_vm_close,	3312	.close = zoran_vm_close,
3313	};	3313	};
3314		3314
3315	static int	3315	static int
3316	zoran_mmap (struct file *file,	3316	zoran_mmap (struct file *file,
3317	struct vm_area_struct *vma)	3317	struct vm_area_struct *vma)
3318	{	3318	{
3319	struct zoran_fh *fh = file->private_data;	3319	struct zoran_fh *fh = file->private_data;
3320	struct zoran *zr = fh->zr;	3320	struct zoran *zr = fh->zr;
3321	unsigned long size = (vma->vm_end - vma->vm_start);	3321	unsigned long size = (vma->vm_end - vma->vm_start);
3322	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;	3322	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
3323	int i, j;	3323	int i, j;
3324	unsigned long page, start = vma->vm_start, todo, pos, fraglen;	3324	unsigned long page, start = vma->vm_start, todo, pos, fraglen;
3325	int first, last;	3325	int first, last;
3326	struct zoran_mapping *map;	3326	struct zoran_mapping *map;
3327	int res = 0;	3327	int res = 0;
3328		3328
3329	dprintk(3,	3329	dprintk(3,
3330	KERN_INFO "%s: mmap(%s) of 0x%08lx-0x%08lx (size=%lu)\n",	3330	KERN_INFO "%s: mmap(%s) of 0x%08lx-0x%08lx (size=%lu)\n",
3331	ZR_DEVNAME(zr),	3331	ZR_DEVNAME(zr),
3332	fh->map_mode == ZORAN_MAP_MODE_RAW ? "V4L" : "MJPEG",	3332	fh->map_mode == ZORAN_MAP_MODE_RAW ? "V4L" : "MJPEG",
3333	vma->vm_start, vma->vm_end, size);	3333	vma->vm_start, vma->vm_end, size);
3334		3334
3335	if (!(vma->vm_flags & VM_SHARED) \|\| !(vma->vm_flags & VM_READ) \|\|	3335	if (!(vma->vm_flags & VM_SHARED) \|\| !(vma->vm_flags & VM_READ) \|\|
3336	!(vma->vm_flags & VM_WRITE)) {	3336	!(vma->vm_flags & VM_WRITE)) {
3337	dprintk(1,	3337	dprintk(1,
3338	KERN_ERR	3338	KERN_ERR
3339	"%s: mmap() - no MAP_SHARED/PROT_{READ,WRITE} given\n",	3339	"%s: mmap() - no MAP_SHARED/PROT_{READ,WRITE} given\n",
3340	ZR_DEVNAME(zr));	3340	ZR_DEVNAME(zr));
3341	return -EINVAL;	3341	return -EINVAL;
3342	}	3342	}
3343		3343
3344	switch (fh->map_mode) {	3344	switch (fh->map_mode) {
3345		3345
3346	case ZORAN_MAP_MODE_JPG_REC:	3346	case ZORAN_MAP_MODE_JPG_REC:
3347	case ZORAN_MAP_MODE_JPG_PLAY:	3347	case ZORAN_MAP_MODE_JPG_PLAY:
3348		3348
3349	/* lock */	3349	/* lock */
3350	mutex_lock(&zr->resource_lock);	3350	mutex_lock(&zr->resource_lock);
3351		3351
3352	/* Map the MJPEG buffers */	3352	/* Map the MJPEG buffers */
3353	if (!fh->jpg_buffers.allocated) {	3353	if (!fh->jpg_buffers.allocated) {
3354	dprintk(1,	3354	dprintk(1,
3355	KERN_ERR	3355	KERN_ERR
3356	"%s: zoran_mmap(MJPEG) - buffers not yet allocated\n",	3356	"%s: zoran_mmap(MJPEG) - buffers not yet allocated\n",
3357	ZR_DEVNAME(zr));	3357	ZR_DEVNAME(zr));
3358	res = -ENOMEM;	3358	res = -ENOMEM;
3359	goto jpg_mmap_unlock_and_return;	3359	goto jpg_mmap_unlock_and_return;
3360	}	3360	}
3361		3361
3362	first = offset / fh->jpg_buffers.buffer_size;	3362	first = offset / fh->jpg_buffers.buffer_size;
3363	last = first - 1 + size / fh->jpg_buffers.buffer_size;	3363	last = first - 1 + size / fh->jpg_buffers.buffer_size;
3364	if (offset % fh->jpg_buffers.buffer_size != 0 \|\|	3364	if (offset % fh->jpg_buffers.buffer_size != 0 \|\|
3365	size % fh->jpg_buffers.buffer_size != 0 \|\| first < 0 \|\|	3365	size % fh->jpg_buffers.buffer_size != 0 \|\| first < 0 \|\|
3366	last < 0 \|\| first >= fh->jpg_buffers.num_buffers \|\|	3366	last < 0 \|\| first >= fh->jpg_buffers.num_buffers \|\|
3367	last >= fh->jpg_buffers.num_buffers) {	3367	last >= fh->jpg_buffers.num_buffers) {
3368	dprintk(1,	3368	dprintk(1,
3369	KERN_ERR	3369	KERN_ERR
3370	"%s: mmap(MJPEG) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",	3370	"%s: mmap(MJPEG) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
3371	ZR_DEVNAME(zr), offset, size,	3371	ZR_DEVNAME(zr), offset, size,
3372	fh->jpg_buffers.buffer_size,	3372	fh->jpg_buffers.buffer_size,
3373	fh->jpg_buffers.num_buffers);	3373	fh->jpg_buffers.num_buffers);
3374	res = -EINVAL;	3374	res = -EINVAL;
3375	goto jpg_mmap_unlock_and_return;	3375	goto jpg_mmap_unlock_and_return;
3376	}	3376	}
3377	for (i = first; i <= last; i++) {	3377	for (i = first; i <= last; i++) {
3378	if (fh->jpg_buffers.buffer[i].map) {	3378	if (fh->jpg_buffers.buffer[i].map) {
3379	dprintk(1,	3379	dprintk(1,
3380	KERN_ERR	3380	KERN_ERR
3381	"%s: mmap(MJPEG) - buffer %d already mapped\n",	3381	"%s: mmap(MJPEG) - buffer %d already mapped\n",
3382	ZR_DEVNAME(zr), i);	3382	ZR_DEVNAME(zr), i);
3383	res = -EBUSY;	3383	res = -EBUSY;
3384	goto jpg_mmap_unlock_and_return;	3384	goto jpg_mmap_unlock_and_return;
3385	}	3385	}
3386	}	3386	}
3387		3387
3388	/* map these buffers (v4l_buffers[i]) */	3388	/* map these buffers (v4l_buffers[i]) */
3389	map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL);	3389	map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL);
3390	if (!map) {	3390	if (!map) {
3391	res = -ENOMEM;	3391	res = -ENOMEM;
3392	goto jpg_mmap_unlock_and_return;	3392	goto jpg_mmap_unlock_and_return;
3393	}	3393	}
3394	map->file = file;	3394	map->file = file;
3395	map->count = 1;	3395	map->count = 1;
3396		3396
3397	vma->vm_ops = &zoran_vm_ops;	3397	vma->vm_ops = &zoran_vm_ops;
3398	vma->vm_flags \|= VM_DONTEXPAND;	3398	vma->vm_flags \|= VM_DONTEXPAND;
3399	vma->vm_private_data = map;	3399	vma->vm_private_data = map;
3400		3400
3401	for (i = first; i <= last; i++) {	3401	for (i = first; i <= last; i++) {
3402	for (j = 0;	3402	for (j = 0;
3403	j < fh->jpg_buffers.buffer_size / PAGE_SIZE;	3403	j < fh->jpg_buffers.buffer_size / PAGE_SIZE;
3404	j++) {	3404	j++) {
3405	fraglen =	3405	fraglen =
3406	(le32_to_cpu(fh->jpg_buffers.buffer[i].	3406	(le32_to_cpu(fh->jpg_buffers.buffer[i].
3407	frag_tab[2 * j + 1]) & ~1) << 1;	3407	frag_tab[2 * j + 1]) & ~1) << 1;
3408	todo = size;	3408	todo = size;
3409	if (todo > fraglen)	3409	if (todo > fraglen)
3410	todo = fraglen;	3410	todo = fraglen;
3411	pos =	3411	pos =
3412	le32_to_cpu(fh->jpg_buffers.	3412	le32_to_cpu(fh->jpg_buffers.
3413	buffer[i].frag_tab[2 * j]);	3413	buffer[i].frag_tab[2 * j]);
3414	/* should just be pos on i386 */	3414	/* should just be pos on i386 */
3415	page = virt_to_phys(bus_to_virt(pos))	3415	page = virt_to_phys(bus_to_virt(pos))
3416	>> PAGE_SHIFT;	3416	>> PAGE_SHIFT;
3417	if (remap_pfn_range(vma, start, page,	3417	if (remap_pfn_range(vma, start, page,
3418	todo, PAGE_SHARED)) {	3418	todo, PAGE_SHARED)) {
3419	dprintk(1,	3419	dprintk(1,
3420	KERN_ERR	3420	KERN_ERR
3421	"%s: zoran_mmap(V4L) - remap_pfn_range failed\n",	3421	"%s: zoran_mmap(V4L) - remap_pfn_range failed\n",
3422	ZR_DEVNAME(zr));	3422	ZR_DEVNAME(zr));
3423	res = -EAGAIN;	3423	res = -EAGAIN;
3424	goto jpg_mmap_unlock_and_return;	3424	goto jpg_mmap_unlock_and_return;
3425	}	3425	}
3426	size -= todo;	3426	size -= todo;
3427	start += todo;	3427	start += todo;
3428	if (size == 0)	3428	if (size == 0)
3429	break;	3429	break;
3430	if (le32_to_cpu(fh->jpg_buffers.buffer[i].	3430	if (le32_to_cpu(fh->jpg_buffers.buffer[i].
3431	frag_tab[2 * j + 1]) & 1)	3431	frag_tab[2 * j + 1]) & 1)
3432	break; /* was last fragment */	3432	break; /* was last fragment */
3433	}	3433	}
3434	fh->jpg_buffers.buffer[i].map = map;	3434	fh->jpg_buffers.buffer[i].map = map;
3435	if (size == 0)	3435	if (size == 0)
3436	break;	3436	break;
3437		3437
3438	}	3438	}
3439	jpg_mmap_unlock_and_return:	3439	jpg_mmap_unlock_and_return:
3440	mutex_unlock(&zr->resource_lock);	3440	mutex_unlock(&zr->resource_lock);
3441		3441
3442	break;	3442	break;
3443		3443
3444	case ZORAN_MAP_MODE_RAW:	3444	case ZORAN_MAP_MODE_RAW:
3445		3445
3446	mutex_lock(&zr->resource_lock);	3446	mutex_lock(&zr->resource_lock);
3447		3447
3448	/* Map the V4L buffers */	3448	/* Map the V4L buffers */
3449	if (!fh->v4l_buffers.allocated) {	3449	if (!fh->v4l_buffers.allocated) {
3450	dprintk(1,	3450	dprintk(1,
3451	KERN_ERR	3451	KERN_ERR
3452	"%s: zoran_mmap(V4L) - buffers not yet allocated\n",	3452	"%s: zoran_mmap(V4L) - buffers not yet allocated\n",
3453	ZR_DEVNAME(zr));	3453	ZR_DEVNAME(zr));
3454	res = -ENOMEM;	3454	res = -ENOMEM;
3455	goto v4l_mmap_unlock_and_return;	3455	goto v4l_mmap_unlock_and_return;
3456	}	3456	}
3457		3457
3458	first = offset / fh->v4l_buffers.buffer_size;	3458	first = offset / fh->v4l_buffers.buffer_size;
3459	last = first - 1 + size / fh->v4l_buffers.buffer_size;	3459	last = first - 1 + size / fh->v4l_buffers.buffer_size;
3460	if (offset % fh->v4l_buffers.buffer_size != 0 \|\|	3460	if (offset % fh->v4l_buffers.buffer_size != 0 \|\|
3461	size % fh->v4l_buffers.buffer_size != 0 \|\| first < 0 \|\|	3461	size % fh->v4l_buffers.buffer_size != 0 \|\| first < 0 \|\|
3462	last < 0 \|\| first >= fh->v4l_buffers.num_buffers \|\|	3462	last < 0 \|\| first >= fh->v4l_buffers.num_buffers \|\|
3463	last >= fh->v4l_buffers.buffer_size) {	3463	last >= fh->v4l_buffers.buffer_size) {
3464	dprintk(1,	3464	dprintk(1,
3465	KERN_ERR	3465	KERN_ERR
3466	"%s: mmap(V4L) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",	3466	"%s: mmap(V4L) - offset=%lu or size=%lu invalid for bufsize=%d and numbufs=%d\n",
3467	ZR_DEVNAME(zr), offset, size,	3467	ZR_DEVNAME(zr), offset, size,
3468	fh->v4l_buffers.buffer_size,	3468	fh->v4l_buffers.buffer_size,
3469	fh->v4l_buffers.num_buffers);	3469	fh->v4l_buffers.num_buffers);
3470	res = -EINVAL;	3470	res = -EINVAL;
3471	goto v4l_mmap_unlock_and_return;	3471	goto v4l_mmap_unlock_and_return;
3472	}	3472	}
3473	for (i = first; i <= last; i++) {	3473	for (i = first; i <= last; i++) {
3474	if (fh->v4l_buffers.buffer[i].map) {	3474	if (fh->v4l_buffers.buffer[i].map) {
3475	dprintk(1,	3475	dprintk(1,
3476	KERN_ERR	3476	KERN_ERR
3477	"%s: mmap(V4L) - buffer %d already mapped\n",	3477	"%s: mmap(V4L) - buffer %d already mapped\n",
3478	ZR_DEVNAME(zr), i);	3478	ZR_DEVNAME(zr), i);
3479	res = -EBUSY;	3479	res = -EBUSY;
3480	goto v4l_mmap_unlock_and_return;	3480	goto v4l_mmap_unlock_and_return;
3481	}	3481	}
3482	}	3482	}
3483		3483
3484	/* map these buffers (v4l_buffers[i]) */	3484	/* map these buffers (v4l_buffers[i]) */
3485	map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL);	3485	map = kmalloc(sizeof(struct zoran_mapping), GFP_KERNEL);
3486	if (!map) {	3486	if (!map) {
3487	res = -ENOMEM;	3487	res = -ENOMEM;
3488	goto v4l_mmap_unlock_and_return;	3488	goto v4l_mmap_unlock_and_return;
3489	}	3489	}
3490	map->file = file;	3490	map->file = file;
3491	map->count = 1;	3491	map->count = 1;
3492		3492
3493	vma->vm_ops = &zoran_vm_ops;	3493	vma->vm_ops = &zoran_vm_ops;
3494	vma->vm_flags \|= VM_DONTEXPAND;	3494	vma->vm_flags \|= VM_DONTEXPAND;
3495	vma->vm_private_data = map;	3495	vma->vm_private_data = map;
3496		3496
3497	for (i = first; i <= last; i++) {	3497	for (i = first; i <= last; i++) {
3498	todo = size;	3498	todo = size;
3499	if (todo > fh->v4l_buffers.buffer_size)	3499	if (todo > fh->v4l_buffers.buffer_size)
3500	todo = fh->v4l_buffers.buffer_size;	3500	todo = fh->v4l_buffers.buffer_size;
3501	page = fh->v4l_buffers.buffer[i].fbuffer_phys;	3501	page = fh->v4l_buffers.buffer[i].fbuffer_phys;
3502	if (remap_pfn_range(vma, start, page >> PAGE_SHIFT,	3502	if (remap_pfn_range(vma, start, page >> PAGE_SHIFT,
3503	todo, PAGE_SHARED)) {	3503	todo, PAGE_SHARED)) {
3504	dprintk(1,	3504	dprintk(1,
3505	KERN_ERR	3505	KERN_ERR
3506	"%s: zoran_mmap(V4L)i - remap_pfn_range failed\n",	3506	"%s: zoran_mmap(V4L)i - remap_pfn_range failed\n",
3507	ZR_DEVNAME(zr));	3507	ZR_DEVNAME(zr));
3508	res = -EAGAIN;	3508	res = -EAGAIN;
3509	goto v4l_mmap_unlock_and_return;	3509	goto v4l_mmap_unlock_and_return;
3510	}	3510	}
3511	size -= todo;	3511	size -= todo;
3512	start += todo;	3512	start += todo;
3513	fh->v4l_buffers.buffer[i].map = map;	3513	fh->v4l_buffers.buffer[i].map = map;
3514	if (size == 0)	3514	if (size == 0)
3515	break;	3515	break;
3516	}	3516	}
3517	v4l_mmap_unlock_and_return:	3517	v4l_mmap_unlock_and_return:
3518	mutex_unlock(&zr->resource_lock);	3518	mutex_unlock(&zr->resource_lock);
3519		3519
3520	break;	3520	break;
3521		3521
3522	default:	3522	default:
3523	dprintk(1,	3523	dprintk(1,
3524	KERN_ERR	3524	KERN_ERR
3525	"%s: zoran_mmap() - internal error - unknown map mode %d\n",	3525	"%s: zoran_mmap() - internal error - unknown map mode %d\n",
3526	ZR_DEVNAME(zr), fh->map_mode);	3526	ZR_DEVNAME(zr), fh->map_mode);
3527	break;	3527	break;
3528	}	3528	}
3529		3529
3530	return 0;	3530	return 0;
3531	}	3531	}
3532		3532
3533	static const struct v4l2_ioctl_ops zoran_ioctl_ops = {	3533	static const struct v4l2_ioctl_ops zoran_ioctl_ops = {
3534	.vidioc_querycap = zoran_querycap,	3534	.vidioc_querycap = zoran_querycap,
3535	.vidioc_cropcap = zoran_cropcap,	3535	.vidioc_cropcap = zoran_cropcap,
3536	.vidioc_s_crop = zoran_s_crop,	3536	.vidioc_s_crop = zoran_s_crop,
3537	.vidioc_g_crop = zoran_g_crop,	3537	.vidioc_g_crop = zoran_g_crop,
3538	.vidioc_enum_input = zoran_enum_input,	3538	.vidioc_enum_input = zoran_enum_input,
3539	.vidioc_g_input = zoran_g_input,	3539	.vidioc_g_input = zoran_g_input,
3540	.vidioc_s_input = zoran_s_input,	3540	.vidioc_s_input = zoran_s_input,
3541	.vidioc_enum_output = zoran_enum_output,	3541	.vidioc_enum_output = zoran_enum_output,
3542	.vidioc_g_output = zoran_g_output,	3542	.vidioc_g_output = zoran_g_output,
3543	.vidioc_s_output = zoran_s_output,	3543	.vidioc_s_output = zoran_s_output,
3544	.vidioc_g_fbuf = zoran_g_fbuf,	3544	.vidioc_g_fbuf = zoran_g_fbuf,
3545	.vidioc_s_fbuf = zoran_s_fbuf,	3545	.vidioc_s_fbuf = zoran_s_fbuf,
3546	.vidioc_g_std = zoran_g_std,	3546	.vidioc_g_std = zoran_g_std,
3547	.vidioc_s_std = zoran_s_std,	3547	.vidioc_s_std = zoran_s_std,
3548	.vidioc_g_jpegcomp = zoran_g_jpegcomp,	3548	.vidioc_g_jpegcomp = zoran_g_jpegcomp,
3549	.vidioc_s_jpegcomp = zoran_s_jpegcomp,	3549	.vidioc_s_jpegcomp = zoran_s_jpegcomp,
3550	.vidioc_overlay = zoran_overlay,	3550	.vidioc_overlay = zoran_overlay,
3551	.vidioc_reqbufs = zoran_reqbufs,	3551	.vidioc_reqbufs = zoran_reqbufs,
3552	.vidioc_querybuf = zoran_querybuf,	3552	.vidioc_querybuf = zoran_querybuf,
3553	.vidioc_qbuf = zoran_qbuf,	3553	.vidioc_qbuf = zoran_qbuf,
3554	.vidioc_dqbuf = zoran_dqbuf,	3554	.vidioc_dqbuf = zoran_dqbuf,
3555	.vidioc_streamon = zoran_streamon,	3555	.vidioc_streamon = zoran_streamon,
3556	.vidioc_streamoff = zoran_streamoff,	3556	.vidioc_streamoff = zoran_streamoff,
3557	.vidioc_enum_fmt_vid_cap = zoran_enum_fmt_vid_cap,	3557	.vidioc_enum_fmt_vid_cap = zoran_enum_fmt_vid_cap,
3558	.vidioc_enum_fmt_vid_out = zoran_enum_fmt_vid_out,	3558	.vidioc_enum_fmt_vid_out = zoran_enum_fmt_vid_out,
3559	.vidioc_enum_fmt_vid_overlay = zoran_enum_fmt_vid_overlay,	3559	.vidioc_enum_fmt_vid_overlay = zoran_enum_fmt_vid_overlay,
3560	.vidioc_g_fmt_vid_cap = zoran_g_fmt_vid_cap,	3560	.vidioc_g_fmt_vid_cap = zoran_g_fmt_vid_cap,
3561	.vidioc_g_fmt_vid_out = zoran_g_fmt_vid_out,	3561	.vidioc_g_fmt_vid_out = zoran_g_fmt_vid_out,
3562	.vidioc_g_fmt_vid_overlay = zoran_g_fmt_vid_overlay,	3562	.vidioc_g_fmt_vid_overlay = zoran_g_fmt_vid_overlay,
3563	.vidioc_s_fmt_vid_cap = zoran_s_fmt_vid_cap,	3563	.vidioc_s_fmt_vid_cap = zoran_s_fmt_vid_cap,
3564	.vidioc_s_fmt_vid_out = zoran_s_fmt_vid_out,	3564	.vidioc_s_fmt_vid_out = zoran_s_fmt_vid_out,
3565	.vidioc_s_fmt_vid_overlay = zoran_s_fmt_vid_overlay,	3565	.vidioc_s_fmt_vid_overlay = zoran_s_fmt_vid_overlay,
3566	.vidioc_try_fmt_vid_cap = zoran_try_fmt_vid_cap,	3566	.vidioc_try_fmt_vid_cap = zoran_try_fmt_vid_cap,
3567	.vidioc_try_fmt_vid_out = zoran_try_fmt_vid_out,	3567	.vidioc_try_fmt_vid_out = zoran_try_fmt_vid_out,
3568	.vidioc_try_fmt_vid_overlay = zoran_try_fmt_vid_overlay,	3568	.vidioc_try_fmt_vid_overlay = zoran_try_fmt_vid_overlay,
3569	.vidioc_queryctrl = zoran_queryctrl,	3569	.vidioc_queryctrl = zoran_queryctrl,
3570	.vidioc_s_ctrl = zoran_s_ctrl,	3570	.vidioc_s_ctrl = zoran_s_ctrl,
3571	.vidioc_g_ctrl = zoran_g_ctrl,	3571	.vidioc_g_ctrl = zoran_g_ctrl,
3572	#ifdef CONFIG_VIDEO_V4L1_COMPAT	3572	#ifdef CONFIG_VIDEO_V4L1_COMPAT
3573	.vidioc_default = zoran_default,	3573	.vidioc_default = zoran_default,
3574	.vidiocgmbuf = zoran_vidiocgmbuf,	3574	.vidiocgmbuf = zoran_vidiocgmbuf,
3575	#endif	3575	#endif
3576	};	3576	};
3577		3577
3578	static const struct v4l2_file_operations zoran_fops = {	3578	static const struct v4l2_file_operations zoran_fops = {
3579	.owner = THIS_MODULE,	3579	.owner = THIS_MODULE,
3580	.open = zoran_open,	3580	.open = zoran_open,
3581	.release = zoran_close,	3581	.release = zoran_close,
3582	.ioctl = video_ioctl2,	3582	.ioctl = video_ioctl2,
3583	.read = zoran_read,	3583	.read = zoran_read,
3584	.write = zoran_write,	3584	.write = zoran_write,
3585	.mmap = zoran_mmap,	3585	.mmap = zoran_mmap,
3586	.poll = zoran_poll,	3586	.poll = zoran_poll,
3587	};	3587	};
3588		3588
3589	struct video_device zoran_template __devinitdata = {	3589	struct video_device zoran_template __devinitdata = {
3590	.name = ZORAN_NAME,	3590	.name = ZORAN_NAME,
3591	.fops = &zoran_fops,	3591	.fops = &zoran_fops,
3592	.ioctl_ops = &zoran_ioctl_ops,	3592	.ioctl_ops = &zoran_ioctl_ops,
3593	.release = &zoran_vdev_release,	3593	.release = &zoran_vdev_release,
3594	.tvnorms = V4L2_STD_NTSC \| V4L2_STD_PAL \| V4L2_STD_SECAM,	3594	.tvnorms = V4L2_STD_NTSC \| V4L2_STD_PAL \| V4L2_STD_SECAM,
3595	.minor = -1	3595	.minor = -1
3596	};	3596	};
3597		3597
3598		3598

include/linux/videodev.h

Diff comments View file @ 7e0a16f

 /*
  *	Video for Linux version 1 - OBSOLETE
  *
  *	Header file for v4l1 drivers and applications, for
  *	Linux kernels 2.2.x or 2.4.x.
  *
  *	Provides header for legacy drivers and applications
  *
  *	See http://linuxtv.org for more info
  *
  */
 #ifndef __LINUX_VIDEODEV_H
 #define __LINUX_VIDEODEV_H
 #include <linux/types.h>
 #include <linux/ioctl.h>
 #include <linux/videodev2.h>
+#if defined(__MIN_V4L1) && defined (__KERNEL__)
+/*
+ * Used by those V4L2 core functions that need a minimum V4L1 support,
+ * in order to allow V4L1 Compatibilty code compilation.
+ */
+struct video_mbuf
+{
+	int	size;		/* Total memory to map */
+	int	frames;		/* Frames */
+	int	offsets[VIDEO_MAX_FRAME];
+};
+#define VIDIOCGMBUF		_IOR('v',20, struct video_mbuf)		/* Memory map buffer info */
+#else
 #if defined(CONFIG_VIDEO_V4L1_COMPAT) || !defined (__KERNEL__)
 #define VID_TYPE_CAPTURE	1	/* Can capture */
 #define VID_TYPE_TUNER		2	/* Can tune */
 #define VID_TYPE_TELETEXT	4	/* Does teletext */
 #define VID_TYPE_OVERLAY	8	/* Overlay onto frame buffer */
 #define VID_TYPE_CHROMAKEY	16	/* Overlay by chromakey */
 #define VID_TYPE_CLIPPING	32	/* Can clip */
 #define VID_TYPE_FRAMERAM	64	/* Uses the frame buffer memory */
 #define VID_TYPE_SCALES		128	/* Scalable */
 #define VID_TYPE_MONOCHROME	256	/* Monochrome only */
 #define VID_TYPE_SUBCAPTURE	512	/* Can capture subareas of the image */
 #define VID_TYPE_MPEG_DECODER	1024	/* Can decode MPEG streams */
 #define VID_TYPE_MPEG_ENCODER	2048	/* Can encode MPEG streams */
 #define VID_TYPE_MJPEG_DECODER	4096	/* Can decode MJPEG streams */
 #define VID_TYPE_MJPEG_ENCODER	8192	/* Can encode MJPEG streams */
 struct video_capability
 {
 	char name[32];
 	int type;
 	int channels;	/* Num channels */
 	int audios;	/* Num audio devices */
 	int maxwidth;	/* Supported width */
 	int maxheight;	/* And height */
 	int minwidth;	/* Supported width */
 	int minheight;	/* And height */
 };
 struct video_channel
 {
 	int channel;
 	char name[32];
 	int tuners;
 	__u32  flags;
 #define VIDEO_VC_TUNER		1	/* Channel has a tuner */
 #define VIDEO_VC_AUDIO		2	/* Channel has audio */
 	__u16  type;
 #define VIDEO_TYPE_TV		1
 #define VIDEO_TYPE_CAMERA	2
 	__u16 norm;			/* Norm set by channel */
 };
 struct video_tuner
 {
 	int tuner;
 	char name[32];
 	unsigned long rangelow, rangehigh;	/* Tuner range */
 	__u32 flags;
 #define VIDEO_TUNER_PAL		1
 #define VIDEO_TUNER_NTSC	2
 #define VIDEO_TUNER_SECAM	4
 #define VIDEO_TUNER_LOW		8	/* Uses KHz not MHz */
 #define VIDEO_TUNER_NORM	16	/* Tuner can set norm */
 #define VIDEO_TUNER_STEREO_ON	128	/* Tuner is seeing stereo */
 #define VIDEO_TUNER_RDS_ON      256     /* Tuner is seeing an RDS datastream */
 #define VIDEO_TUNER_MBS_ON      512     /* Tuner is seeing an MBS datastream */
 	__u16 mode;			/* PAL/NTSC/SECAM/OTHER */
 #define VIDEO_MODE_PAL		0
 #define VIDEO_MODE_NTSC		1
 #define VIDEO_MODE_SECAM	2
 #define VIDEO_MODE_AUTO		3
 	__u16 signal;			/* Signal strength 16bit scale */
 };
 struct video_picture
 {
 	__u16	brightness;
 	__u16	hue;
 	__u16	colour;
 	__u16	contrast;
 	__u16	whiteness;	/* Black and white only */
 	__u16	depth;		/* Capture depth */
 	__u16   palette;	/* Palette in use */
 #define VIDEO_PALETTE_GREY	1	/* Linear greyscale */
 #define VIDEO_PALETTE_HI240	2	/* High 240 cube (BT848) */
 #define VIDEO_PALETTE_RGB565	3	/* 565 16 bit RGB */
 #define VIDEO_PALETTE_RGB24	4	/* 24bit RGB */
 #define VIDEO_PALETTE_RGB32	5	/* 32bit RGB */
 #define VIDEO_PALETTE_RGB555	6	/* 555 15bit RGB */
 #define VIDEO_PALETTE_YUV422	7	/* YUV422 capture */
 #define VIDEO_PALETTE_YUYV	8
 #define VIDEO_PALETTE_UYVY	9	/* The great thing about standards is ... */
 #define VIDEO_PALETTE_YUV420	10
 #define VIDEO_PALETTE_YUV411	11	/* YUV411 capture */
 #define VIDEO_PALETTE_RAW	12	/* RAW capture (BT848) */
 #define VIDEO_PALETTE_YUV422P	13	/* YUV 4:2:2 Planar */
 #define VIDEO_PALETTE_YUV411P	14	/* YUV 4:1:1 Planar */
 #define VIDEO_PALETTE_YUV420P	15	/* YUV 4:2:0 Planar */
 #define VIDEO_PALETTE_YUV410P	16	/* YUV 4:1:0 Planar */
 #define VIDEO_PALETTE_PLANAR	13	/* start of planar entries */
 #define VIDEO_PALETTE_COMPONENT 7	/* start of component entries */
 };
 struct video_audio
 {
 	int	audio;		/* Audio channel */
 	__u16	volume;		/* If settable */
 	__u16	bass, treble;
 	__u32	flags;
 #define VIDEO_AUDIO_MUTE	1
 #define VIDEO_AUDIO_MUTABLE	2
 #define VIDEO_AUDIO_VOLUME	4
 #define VIDEO_AUDIO_BASS	8
 #define VIDEO_AUDIO_TREBLE	16
 #define VIDEO_AUDIO_BALANCE	32
 	char    name[16];
 #define VIDEO_SOUND_MONO	1
 #define VIDEO_SOUND_STEREO	2
 #define VIDEO_SOUND_LANG1	4
 #define VIDEO_SOUND_LANG2	8
 	__u16   mode;
 	__u16	balance;	/* Stereo balance */
 	__u16	step;		/* Step actual volume uses */
 };
 struct video_clip
 {
 	__s32	x,y;
 	__s32	width, height;
 	struct	video_clip *next;	/* For user use/driver use only */
 };
 struct video_window
 {
 	__u32	x,y;			/* Position of window */
 	__u32	width,height;		/* Its size */
 	__u32	chromakey;
 	__u32	flags;
 	struct	video_clip __user *clips;	/* Set only */
 	int	clipcount;
 #define VIDEO_WINDOW_INTERLACE	1
 #define VIDEO_WINDOW_CHROMAKEY	16	/* Overlay by chromakey */
 #define VIDEO_CLIP_BITMAP	-1
 /* bitmap is 1024x625, a '1' bit represents a clipped pixel */
 #define VIDEO_CLIPMAP_SIZE	(128 * 625)
 };
 struct video_capture
 {
 	__u32 	x,y;			/* Offsets into image */
 	__u32	width, height;		/* Area to capture */
 	__u16	decimation;		/* Decimation divider */
 	__u16	flags;			/* Flags for capture */
 #define VIDEO_CAPTURE_ODD		0	/* Temporal */
 #define VIDEO_CAPTURE_EVEN		1
 };
 struct video_buffer
 {
 	void	*base;
 	int	height,width;
 	int	depth;
 	int	bytesperline;
 };
 struct video_mmap
 {
 	unsigned	int frame;		/* Frame (0 - n) for double buffer */
 	int		height,width;
 	unsigned	int format;		/* should be VIDEO_PALETTE_* */
 };
 struct video_key
 {
 	__u8	key[8];
 	__u32	flags;
 };
 struct video_mbuf
 {
 	int	size;		/* Total memory to map */
 	int	frames;		/* Frames */
 	int	offsets[VIDEO_MAX_FRAME];
 };
 #define 	VIDEO_NO_UNIT	(-1)
 struct video_unit
 {
 	int 	video;		/* Video minor */
 	int	vbi;		/* VBI minor */
 	int	radio;		/* Radio minor */
 	int	audio;		/* Audio minor */
 	int	teletext;	/* Teletext minor */
 };
 struct vbi_format {
 	__u32	sampling_rate;	/* in Hz */
 	__u32	samples_per_line;
 	__u32	sample_format;	/* VIDEO_PALETTE_RAW only (1 byte) */
 	__s32	start[2];	/* starting line for each frame */
 	__u32	count[2];	/* count of lines for each frame */
 	__u32	flags;
 #define	VBI_UNSYNC	1	/* can distingues between top/bottom field */
 #define	VBI_INTERLACED	2	/* lines are interlaced */
 };
 /* video_info is biased towards hardware mpeg encode/decode */
 /* but it could apply generically to any hardware compressor/decompressor */
 struct video_info
 {
 	__u32	frame_count;	/* frames output since decode/encode began */
 	__u32	h_size;		/* current unscaled horizontal size */
 	__u32	v_size;		/* current unscaled veritcal size */
 	__u32	smpte_timecode;	/* current SMPTE timecode (for current GOP) */
 	__u32	picture_type;	/* current picture type */
 	__u32	temporal_reference;	/* current temporal reference */
 	__u8	user_data[256];	/* user data last found in compressed stream */
 	/* user_data[0] contains user data flags, user_data[1] has count */
 };
 /* generic structure for setting playback modes */
 struct video_play_mode
 {
 	int	mode;
 	int	p1;
 	int	p2;
 };
 /* for loading microcode / fpga programming */
 struct video_code
 {
 	char	loadwhat[16];	/* name or tag of file being passed */
 	int	datasize;
 	__u8	*data;
 };
 #define VIDIOCGCAP		_IOR('v',1,struct video_capability)	/* Get capabilities */
 #define VIDIOCGCHAN		_IOWR('v',2,struct video_channel)	/* Get channel info (sources) */
 #define VIDIOCSCHAN		_IOW('v',3,struct video_channel)	/* Set channel 	*/
 #define VIDIOCGTUNER		_IOWR('v',4,struct video_tuner)		/* Get tuner abilities */
 #define VIDIOCSTUNER		_IOW('v',5,struct video_tuner)		/* Tune the tuner for the current channel */
 #define VIDIOCGPICT		_IOR('v',6,struct video_picture)	/* Get picture properties */
 #define VIDIOCSPICT		_IOW('v',7,struct video_picture)	/* Set picture properties */
 #define VIDIOCCAPTURE		_IOW('v',8,int)				/* Start, end capture */
 #define VIDIOCGWIN		_IOR('v',9, struct video_window)	/* Get the video overlay window */
 #define VIDIOCSWIN		_IOW('v',10, struct video_window)	/* Set the video overlay window - passes clip list for hardware smarts , chromakey etc */
 #define VIDIOCGFBUF		_IOR('v',11, struct video_buffer)	/* Get frame buffer */
 #define VIDIOCSFBUF		_IOW('v',12, struct video_buffer)	/* Set frame buffer - root only */
 #define VIDIOCKEY		_IOR('v',13, struct video_key)		/* Video key event - to dev 255 is to all - cuts capture on all DMA windows with this key (0xFFFFFFFF == all) */
 #define VIDIOCGFREQ		_IOR('v',14, unsigned long)		/* Set tuner */
 #define VIDIOCSFREQ		_IOW('v',15, unsigned long)		/* Set tuner */
 #define VIDIOCGAUDIO		_IOR('v',16, struct video_audio)	/* Get audio info */
 #define VIDIOCSAUDIO		_IOW('v',17, struct video_audio)	/* Audio source, mute etc */
 #define VIDIOCSYNC		_IOW('v',18, int)			/* Sync with mmap grabbing */
 #define VIDIOCMCAPTURE		_IOW('v',19, struct video_mmap)		/* Grab frames */
 #define VIDIOCGMBUF		_IOR('v',20, struct video_mbuf)		/* Memory map buffer info */
 #define VIDIOCGUNIT		_IOR('v',21, struct video_unit)		/* Get attached units */
 #define VIDIOCGCAPTURE		_IOR('v',22, struct video_capture)	/* Get subcapture */
 #define VIDIOCSCAPTURE		_IOW('v',23, struct video_capture)	/* Set subcapture */
 #define VIDIOCSPLAYMODE		_IOW('v',24, struct video_play_mode)	/* Set output video mode/feature */
 #define VIDIOCSWRITEMODE	_IOW('v',25, int)			/* Set write mode */
 #define VIDIOCGPLAYINFO		_IOR('v',26, struct video_info)		/* Get current playback info from hardware */
 #define VIDIOCSMICROCODE	_IOW('v',27, struct video_code)		/* Load microcode into hardware */
 #define	VIDIOCGVBIFMT		_IOR('v',28, struct vbi_format)		/* Get VBI information */
 #define	VIDIOCSVBIFMT		_IOW('v',29, struct vbi_format)		/* Set VBI information */
 #define BASE_VIDIOCPRIVATE	192		/* 192-255 are private */
 /* VIDIOCSWRITEMODE */
 #define VID_WRITE_MPEG_AUD		0
 #define VID_WRITE_MPEG_VID		1
 #define VID_WRITE_OSD			2
 #define VID_WRITE_TTX			3
 #define VID_WRITE_CC			4
 #define VID_WRITE_MJPEG			5
 /* VIDIOCSPLAYMODE */
 #define VID_PLAY_VID_OUT_MODE		0
 	/* p1: = VIDEO_MODE_PAL, VIDEO_MODE_NTSC, etc ... */
 #define VID_PLAY_GENLOCK		1
 	/* p1: 0 = OFF, 1 = ON */
 	/* p2: GENLOCK FINE DELAY value */
 #define VID_PLAY_NORMAL			2
 #define VID_PLAY_PAUSE			3
 #define VID_PLAY_SINGLE_FRAME		4
 #define VID_PLAY_FAST_FORWARD		5
 #define VID_PLAY_SLOW_MOTION		6
 #define VID_PLAY_IMMEDIATE_NORMAL	7
 #define VID_PLAY_SWITCH_CHANNELS	8
 #define VID_PLAY_FREEZE_FRAME		9
 #define VID_PLAY_STILL_MODE		10
 #define VID_PLAY_MASTER_MODE		11
 	/* p1: see below */
 #define		VID_PLAY_MASTER_NONE	1
 #define		VID_PLAY_MASTER_VIDEO	2
 #define		VID_PLAY_MASTER_AUDIO	3
 #define VID_PLAY_ACTIVE_SCANLINES	12
 	/* p1 = first active; p2 = last active */
 #define VID_PLAY_RESET			13
 #define VID_PLAY_END_MARK		14
 #endif /* CONFIG_VIDEO_V4L1_COMPAT */
+#endif /* __MIN_V4L1 */
 #endif /* __LINUX_VIDEODEV_H */
 /*
  * Local variables:
  * c-basic-offset: 8
  * End:
  */

include/media/v4l2-ioctl.h

Diff comments View file @ 7e0a16f

 /*
  *
  *	V 4 L 2   D R I V E R   H E L P E R   A P I
  *
  * Moved from videodev2.h
  *
  *	Some commonly needed functions for drivers (v4l2-common.o module)
  */
 #ifndef _V4L2_IOCTL_H
 #define _V4L2_IOCTL_H
 #include <linux/poll.h>
 #include <linux/fs.h>
 #include <linux/device.h>
 #include <linux/mutex.h>
 #include <linux/compiler.h> /* need __user */
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
+#define __MIN_V4L1
 #include <linux/videodev.h>
 #else
 #include <linux/videodev2.h>
 #endif
 struct v4l2_ioctl_ops {
 	/* ioctl callbacks */
 	/* VIDIOC_QUERYCAP handler */
 	int (*vidioc_querycap)(struct file *file, void *fh, struct v4l2_capability *cap);
 	/* Priority handling */
 	int (*vidioc_g_priority)   (struct file *file, void *fh,
 				    enum v4l2_priority *p);
 	int (*vidioc_s_priority)   (struct file *file, void *fh,
 				    enum v4l2_priority p);
 	/* VIDIOC_ENUM_FMT handlers */
 	int (*vidioc_enum_fmt_vid_cap)     (struct file *file, void *fh,
 					    struct v4l2_fmtdesc *f);
 	int (*vidioc_enum_fmt_vid_overlay) (struct file *file, void *fh,
 					    struct v4l2_fmtdesc *f);
 	int (*vidioc_enum_fmt_vid_out)     (struct file *file, void *fh,
 					    struct v4l2_fmtdesc *f);
 	int (*vidioc_enum_fmt_type_private)(struct file *file, void *fh,
 					    struct v4l2_fmtdesc *f);
 	/* VIDIOC_G_FMT handlers */
 	int (*vidioc_g_fmt_vid_cap)    (struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_g_fmt_vid_overlay)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_g_fmt_vid_out)    (struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_g_fmt_vid_out_overlay)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_g_fmt_vbi_cap)    (struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_g_fmt_vbi_out)    (struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_g_fmt_sliced_vbi_cap)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_g_fmt_sliced_vbi_out)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_g_fmt_type_private)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	/* VIDIOC_S_FMT handlers */
 	int (*vidioc_s_fmt_vid_cap)    (struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_s_fmt_vid_overlay)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_s_fmt_vid_out)    (struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_s_fmt_vid_out_overlay)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_s_fmt_vbi_cap)    (struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_s_fmt_vbi_out)    (struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_s_fmt_sliced_vbi_cap)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_s_fmt_sliced_vbi_out)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	int (*vidioc_s_fmt_type_private)(struct file *file, void *fh,
 					struct v4l2_format *f);
 	/* VIDIOC_TRY_FMT handlers */
 	int (*vidioc_try_fmt_vid_cap)    (struct file *file, void *fh,
 					  struct v4l2_format *f);
 	int (*vidioc_try_fmt_vid_overlay)(struct file *file, void *fh,
 					  struct v4l2_format *f);
 	int (*vidioc_try_fmt_vid_out)    (struct file *file, void *fh,
 					  struct v4l2_format *f);
 	int (*vidioc_try_fmt_vid_out_overlay)(struct file *file, void *fh,
 					  struct v4l2_format *f);
 	int (*vidioc_try_fmt_vbi_cap)    (struct file *file, void *fh,
 					  struct v4l2_format *f);
 	int (*vidioc_try_fmt_vbi_out)    (struct file *file, void *fh,
 					  struct v4l2_format *f);
 	int (*vidioc_try_fmt_sliced_vbi_cap)(struct file *file, void *fh,
 					  struct v4l2_format *f);
 	int (*vidioc_try_fmt_sliced_vbi_out)(struct file *file, void *fh,
 					  struct v4l2_format *f);
 	int (*vidioc_try_fmt_type_private)(struct file *file, void *fh,
 					  struct v4l2_format *f);
 	/* Buffer handlers */
 	int (*vidioc_reqbufs) (struct file *file, void *fh, struct v4l2_requestbuffers *b);
 	int (*vidioc_querybuf)(struct file *file, void *fh, struct v4l2_buffer *b);
 	int (*vidioc_qbuf)    (struct file *file, void *fh, struct v4l2_buffer *b);
 	int (*vidioc_dqbuf)   (struct file *file, void *fh, struct v4l2_buffer *b);
 	int (*vidioc_overlay) (struct file *file, void *fh, unsigned int i);
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 			/* buffer type is struct vidio_mbuf * */
 	int (*vidiocgmbuf)  (struct file *file, void *fh, struct video_mbuf *p);
 #endif
 	int (*vidioc_g_fbuf)   (struct file *file, void *fh,
 				struct v4l2_framebuffer *a);
 	int (*vidioc_s_fbuf)   (struct file *file, void *fh,
 				struct v4l2_framebuffer *a);
 		/* Stream on/off */
 	int (*vidioc_streamon) (struct file *file, void *fh, enum v4l2_buf_type i);
 	int (*vidioc_streamoff)(struct file *file, void *fh, enum v4l2_buf_type i);
 		/* Standard handling
 			ENUMSTD is handled by videodev.c
 		 */
 	int (*vidioc_g_std) (struct file *file, void *fh, v4l2_std_id *norm);
 	int (*vidioc_s_std) (struct file *file, void *fh, v4l2_std_id *norm);
 	int (*vidioc_querystd) (struct file *file, void *fh, v4l2_std_id *a);
 		/* Input handling */
 	int (*vidioc_enum_input)(struct file *file, void *fh,
 				 struct v4l2_input *inp);
 	int (*vidioc_g_input)   (struct file *file, void *fh, unsigned int *i);
 	int (*vidioc_s_input)   (struct file *file, void *fh, unsigned int i);
 		/* Output handling */
 	int (*vidioc_enum_output) (struct file *file, void *fh,
 				  struct v4l2_output *a);
 	int (*vidioc_g_output)   (struct file *file, void *fh, unsigned int *i);
 	int (*vidioc_s_output)   (struct file *file, void *fh, unsigned int i);
 		/* Control handling */
 	int (*vidioc_queryctrl)        (struct file *file, void *fh,
 					struct v4l2_queryctrl *a);
 	int (*vidioc_g_ctrl)           (struct file *file, void *fh,
 					struct v4l2_control *a);
 	int (*vidioc_s_ctrl)           (struct file *file, void *fh,
 					struct v4l2_control *a);
 	int (*vidioc_g_ext_ctrls)      (struct file *file, void *fh,
 					struct v4l2_ext_controls *a);
 	int (*vidioc_s_ext_ctrls)      (struct file *file, void *fh,
 					struct v4l2_ext_controls *a);
 	int (*vidioc_try_ext_ctrls)    (struct file *file, void *fh,
 					struct v4l2_ext_controls *a);
 	int (*vidioc_querymenu)        (struct file *file, void *fh,
 					struct v4l2_querymenu *a);
 	/* Audio ioctls */
 	int (*vidioc_enumaudio)        (struct file *file, void *fh,
 					struct v4l2_audio *a);
 	int (*vidioc_g_audio)          (struct file *file, void *fh,
 					struct v4l2_audio *a);
 	int (*vidioc_s_audio)          (struct file *file, void *fh,
 					struct v4l2_audio *a);
 	/* Audio out ioctls */
 	int (*vidioc_enumaudout)       (struct file *file, void *fh,
 					struct v4l2_audioout *a);
 	int (*vidioc_g_audout)         (struct file *file, void *fh,
 					struct v4l2_audioout *a);
 	int (*vidioc_s_audout)         (struct file *file, void *fh,
 					struct v4l2_audioout *a);
 	int (*vidioc_g_modulator)      (struct file *file, void *fh,
 					struct v4l2_modulator *a);
 	int (*vidioc_s_modulator)      (struct file *file, void *fh,
 					struct v4l2_modulator *a);
 	/* Crop ioctls */
 	int (*vidioc_cropcap)          (struct file *file, void *fh,
 					struct v4l2_cropcap *a);
 	int (*vidioc_g_crop)           (struct file *file, void *fh,
 					struct v4l2_crop *a);
 	int (*vidioc_s_crop)           (struct file *file, void *fh,
 					struct v4l2_crop *a);
 	/* Compression ioctls */
 	int (*vidioc_g_jpegcomp)       (struct file *file, void *fh,
 					struct v4l2_jpegcompression *a);
 	int (*vidioc_s_jpegcomp)       (struct file *file, void *fh,
 					struct v4l2_jpegcompression *a);
 	int (*vidioc_g_enc_index)      (struct file *file, void *fh,
 					struct v4l2_enc_idx *a);
 	int (*vidioc_encoder_cmd)      (struct file *file, void *fh,
 					struct v4l2_encoder_cmd *a);
 	int (*vidioc_try_encoder_cmd)  (struct file *file, void *fh,
 					struct v4l2_encoder_cmd *a);
 	/* Stream type-dependent parameter ioctls */
 	int (*vidioc_g_parm)           (struct file *file, void *fh,
 					struct v4l2_streamparm *a);
 	int (*vidioc_s_parm)           (struct file *file, void *fh,
 					struct v4l2_streamparm *a);
 	/* Tuner ioctls */
 	int (*vidioc_g_tuner)          (struct file *file, void *fh,
 					struct v4l2_tuner *a);
 	int (*vidioc_s_tuner)          (struct file *file, void *fh,
 					struct v4l2_tuner *a);
 	int (*vidioc_g_frequency)      (struct file *file, void *fh,
 					struct v4l2_frequency *a);
 	int (*vidioc_s_frequency)      (struct file *file, void *fh,
 					struct v4l2_frequency *a);
 	/* Sliced VBI cap */
 	int (*vidioc_g_sliced_vbi_cap) (struct file *file, void *fh,
 					struct v4l2_sliced_vbi_cap *a);
 	/* Log status ioctl */
 	int (*vidioc_log_status)       (struct file *file, void *fh);
 	int (*vidioc_s_hw_freq_seek)   (struct file *file, void *fh,
 					struct v4l2_hw_freq_seek *a);
 	/* Debugging ioctls */
 #ifdef CONFIG_VIDEO_ADV_DEBUG
 	int (*vidioc_g_register)       (struct file *file, void *fh,
 					struct v4l2_dbg_register *reg);
 	int (*vidioc_s_register)       (struct file *file, void *fh,
 					struct v4l2_dbg_register *reg);
 #endif
 	int (*vidioc_g_chip_ident)     (struct file *file, void *fh,
 					struct v4l2_dbg_chip_ident *chip);
 	int (*vidioc_enum_framesizes)   (struct file *file, void *fh,
 					 struct v4l2_frmsizeenum *fsize);
 	int (*vidioc_enum_frameintervals) (struct file *file, void *fh,
 					   struct v4l2_frmivalenum *fival);
 	/* For other private ioctls */
 	long (*vidioc_default)	       (struct file *file, void *fh,
 					int cmd, void *arg);
 };
 /* v4l debugging and diagnostics */
 /* Debug bitmask flags to be used on V4L2 */
 #define V4L2_DEBUG_IOCTL     0x01
 #define V4L2_DEBUG_IOCTL_ARG 0x02
 /* Use this macro for non-I2C drivers. Pass the driver name as the first arg. */
 #define v4l_print_ioctl(name, cmd)  		 \
 	do {  					 \
 		printk(KERN_DEBUG "%s: ", name); \
 		v4l_printk_ioctl(cmd);		 \
 	} while (0)
 /* Use this macro in I2C drivers where 'client' is the struct i2c_client
    pointer */
 #define v4l_i2c_print_ioctl(client, cmd) 		   \
 	do {      					   \
 		v4l_client_printk(KERN_DEBUG, client, ""); \
 		v4l_printk_ioctl(cmd);			   \
 	} while (0)
 /*  Video standard functions  */
 extern const char *v4l2_norm_to_name(v4l2_std_id id);
 extern void v4l2_video_std_frame_period(int id, struct v4l2_fract *frameperiod);
 extern int v4l2_video_std_construct(struct v4l2_standard *vs,
 				    int id, const char *name);
 /* Prints the ioctl in a human-readable format */
 extern void v4l_printk_ioctl(unsigned int cmd);
 /* names for fancy debug output */
 extern const char *v4l2_field_names[];
 extern const char *v4l2_type_names[];
 /*  Compatibility layer interface  --  v4l1-compat module */
 typedef long (*v4l2_kioctl)(struct file *file,
 			   unsigned int cmd, void *arg);
 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 long v4l_compat_translate_ioctl(struct file *file,
 			       int cmd, void *arg, v4l2_kioctl driver_ioctl);
 #else
 #define v4l_compat_translate_ioctl(file, cmd, arg, ioctl) (-EINVAL)
 #endif
 #ifdef CONFIG_COMPAT
 /* 32 Bits compatibility layer for 64 bits processors */
 extern long v4l2_compat_ioctl32(struct file *file, unsigned int cmd,
 				unsigned long arg);
 #endif
 /* Include support for obsoleted stuff */
 extern long video_usercopy(struct file *file, unsigned int cmd,
 				unsigned long arg, v4l2_kioctl func);
 /* Standard handlers for V4L ioctl's */
 extern long video_ioctl2(struct file *file,
 			unsigned int cmd, unsigned long arg);
 #endif /* _V4L2_IOCTL_H */