Merge master.kernel.org:/pub/scm/linux/kernel/git/mchehab/v4l-dvb

* master.kernel.org:/pub/scm/linux/kernel/git/mchehab/v4l-dvb: (244 commits)
  V4L/DVB (4210b): git-dvb: tea575x-tuner build fix
  V4L/DVB (4210a): git-dvb versus matroxfb
  V4L/DVB (4209): Added some BTTV PCI IDs for newer boards
  Fixes some sync issues between V4L/DVB development and GIT
  V4L/DVB (4206): Cx88-blackbird: always set encoder height based on tvnorm->id
  V4L/DVB (4205): Merge tda9887 module into tuner.
  V4L/DVB (4203): Explicitly set the enum values.
  V4L/DVB (4202): allow selecting CX2341x port mode
  V4L/DVB (4200): Disable bitrate_mode when encoding mpeg-1.
  V4L/DVB (4199): Add cx2341x-specific control array to cx2341x.c
  V4L/DVB (4198): Avoid newer usages of obsoleted experimental MPEGCOMP API
  V4L/DVB (4197): Port new MPEG API to saa7134-empress with saa6752hs
  V4L/DVB (4196): Port cx88-blackbird to the new MPEG API.
  V4L/DVB (4193): Update cx2341x fw encoding API doc.
  V4L/DVB (4192): Use control helpers for saa7115, cx25840, msp3400.
  V4L/DVB (4191): Add CX2341X MPEG encoder module.
  V4L/DVB (4190): Add helper functions for control processing to v4l2-common.
  V4L/DVB (4189): Add videodev support for VIDIOC_S/G/TRY_EXT_CTRLS.
  V4L/DVB (4188): Add new MPEG control/ioctl definitions to videodev2.h
  V4L/DVB (4186): Add support for the DNTV Live! mini DVB-T card.
  ...

120 files changed, 13206 insertions, 3739 deletions

diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 6b419701856..824a63c9262 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -224,6 +224,12 @@ config VIDEO_ZORAN_LML33R10
           support for the Linux Media Labs LML33R10 MJPEG capture/playback
           card.
 
+config VIDEO_ZORAN_AVS6EYES
+        tristate "AverMedia 6 Eyes support (EXPERIMENTAL)"
+        depends on VIDEO_ZORAN && EXPERIMENTAL && VIDEO_V4L1
+        help
+          Support for the AverMedia 6 Eyes video surveillance card.
+
 config VIDEO_ZR36120
         tristate "Zoran ZR36120/36125 Video For Linux"
         depends on PCI && I2C && VIDEO_V4L1 && BROKEN
@@ -306,17 +312,6 @@ config VIDEO_HEXIUM_GEMINI
 
 source "drivers/media/video/cx88/Kconfig"
 
-config VIDEO_OVCAMCHIP
-        tristate "OmniVision Camera Chip support"
-        depends on I2C && VIDEO_V4L1
-        ---help---
-          Support for the OmniVision OV6xxx and OV7xxx series of camera chips.
-          This driver is intended to be used with the ov511 and w9968cf USB
-          camera drivers.
-
-          To compile this driver as a module, choose M here: the
-          module will be called ovcamchip.
-
 config VIDEO_M32R_AR
         tristate "AR devices"
         depends on M32R && VIDEO_V4L1
@@ -357,6 +352,15 @@ config VIDEO_CS53L32A
           To compile this driver as a module, choose M here: the
           module will be called cs53l32a.
 
+config VIDEO_TLV320AIC23B
+        tristate "Texas Instruments TLV320AIC23B audio codec"
+        depends on VIDEO_DEV && I2C && EXPERIMENTAL
+        ---help---
+          Support for the Texas Instruments TLV320AIC23B audio codec.
+
+          To compile this driver as a module, choose M here: the
+          module will be called tlv320aic23b.
+
 config VIDEO_WM8775
         tristate "Wolfson Microelectronics WM8775 audio ADC with input mixer"
         depends on VIDEO_DEV && I2C && EXPERIMENTAL
@@ -380,10 +384,10 @@ config VIDEO_WM8739
 source "drivers/media/video/cx25840/Kconfig"
 
 config VIDEO_SAA711X
-        tristate "Philips SAA7113/4/5 video decoders (OBSOLETED)"
-        depends on VIDEO_V4L1 && I2C && EXPERIMENTAL
+        tristate "Philips SAA7113/4/5 video decoders"
+        depends on VIDEO_DEV && I2C && EXPERIMENTAL
         ---help---
-          Old support for the Philips SAA7113/4 video decoders.
+          Support for the Philips SAA7113/4/5 video decoders.
 
           To compile this driver as a module, choose M here: the
           module will be called saa7115.
@@ -447,6 +451,35 @@ source "drivers/media/video/usbvideo/Kconfig"
 
 source "drivers/media/video/et61x251/Kconfig"
 
+config VIDEO_OVCAMCHIP
+        tristate "OmniVision Camera Chip support"
+        depends on I2C && VIDEO_V4L1
+        ---help---
+          Support for the OmniVision OV6xxx and OV7xxx series of camera chips.
+          This driver is intended to be used with the ov511 and w9968cf USB
+          camera drivers.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ovcamchip.
+
+config USB_W9968CF
+        tristate "USB W996[87]CF JPEG Dual Mode Camera support"
+        depends on USB && VIDEO_V4L1 && I2C
+        select VIDEO_OVCAMCHIP
+        ---help---
+          Say Y here if you want support for cameras based on OV681 or
+          Winbond W9967CF/W9968CF JPEG USB Dual Mode Camera Chips.
+
+          This driver has an optional plugin, which is distributed as a
+          separate module only (released under GPL). It allows to use higher
+          resolutions and framerates, but cannot be included in the official
+          Linux kernel for performance purposes.
+
+          See <file:Documentation/video4linux/w9968cf.txt> for more info.
+
+          To compile this driver as a module, choose M here: the
+          module will be called w9968cf.
+
 config USB_OV511
         tristate "USB OV511 Camera support"
         depends on USB && VIDEO_V4L1
@@ -483,24 +516,6 @@ config USB_STV680
           To compile this driver as a module, choose M here: the
           module will be called stv680.
 
-config USB_W9968CF
-        tristate "USB W996[87]CF JPEG Dual Mode Camera support"
-        depends on USB && VIDEO_V4L1 && I2C
-        select VIDEO_OVCAMCHIP
-        ---help---
-          Say Y here if you want support for cameras based on OV681 or
-          Winbond W9967CF/W9968CF JPEG USB Dual Mode Camera Chips.
-
-          This driver has an optional plugin, which is distributed as a
-          separate module only (released under GPL). It allows to use higher
-          resolutions and framerates, but cannot be included in the official
-          Linux kernel for performance purposes.
-
-          See <file:Documentation/video4linux/w9968cf.txt> for more info.
-
-          To compile this driver as a module, choose M here: the
-          module will be called w9968cf.
-
 source "drivers/media/video/zc0301/Kconfig"
 
 source "drivers/media/video/pwc/Kconfig"
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index e5bf2687b76..6c401b46398 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -6,7 +6,7 @@ zoran-objs      :=	zr36120.o zr36120_i2c.o zr36120_mem.o
 zr36067-objs    :=      zoran_procfs.o zoran_device.o \
                         zoran_driver.o zoran_card.o
 tuner-objs      :=      tuner-core.o tuner-types.o tuner-simple.o \
-                        mt20xx.o tda8290.o tea5767.o
+                        mt20xx.o tda8290.o tea5767.o tda9887.o
 
 msp3400-objs    :=      msp3400-driver.o msp3400-kthreads.o
 
@@ -33,6 +33,7 @@ obj-$(CONFIG_VIDEO_ZORAN_DC30) += adv7175.o vpx3220.o zr36050.o \
         zr36016.o
 obj-$(CONFIG_VIDEO_ZORAN_LML33) += bt819.o bt856.o zr36060.o
 obj-$(CONFIG_VIDEO_ZORAN_LML33R10) += saa7114.o adv7170.o zr36060.o
+obj-$(CONFIG_VIDEO_ZORAN_AVS6EYES) += bt866.o ks0127.o zr36060.o
 obj-$(CONFIG_VIDEO_ZORAN) += zr36067.o videocodec.o
 obj-$(CONFIG_VIDEO_PMS) += pms.o
 obj-$(CONFIG_VIDEO_PLANB) += planb.o
@@ -48,6 +49,7 @@ obj-$(CONFIG_VIDEO_EM28XX) += em28xx/
 obj-$(CONFIG_VIDEO_EM28XX) += tvp5150.o
 obj-$(CONFIG_VIDEO_MSP3400) += msp3400.o
 obj-$(CONFIG_VIDEO_CS53L32A) += cs53l32a.o
+obj-$(CONFIG_VIDEO_TLV320AIC23B) += tlv320aic23b.o
 obj-$(CONFIG_VIDEO_WM8775) += wm8775.o
 obj-$(CONFIG_VIDEO_WM8739) += wm8739.o
 obj-$(CONFIG_VIDEO_OVCAMCHIP) += ovcamchip/
@@ -58,7 +60,7 @@ obj-$(CONFIG_VIDEO_HEXIUM_GEMINI) += hexium_gemini.o
 obj-$(CONFIG_VIDEO_DPC) += saa7111.o dpc7146.o
 obj-$(CONFIG_TUNER_3036) += tuner-3036.o
 
-obj-$(CONFIG_VIDEO_TUNER) += tuner.o tda9887.o
+obj-$(CONFIG_VIDEO_TUNER) += tuner.o
 obj-$(CONFIG_VIDEO_BUF)   += video-buf.o
 obj-$(CONFIG_VIDEO_BUF_DVB) += video-buf-dvb.o
 obj-$(CONFIG_VIDEO_BTCX)  += btcx-risc.o
@@ -71,6 +73,7 @@ obj-$(CONFIG_VIDEO_SAA711X) += saa7115.o
 obj-$(CONFIG_VIDEO_SAA7127) += saa7127.o
 obj-$(CONFIG_VIDEO_UPD64031A) += upd64031a.o
 obj-$(CONFIG_VIDEO_UPD64083) += upd64083.o
+obj-$(CONFIG_VIDEO_CX2341X) += cx2341x.o
 
 obj-$(CONFIG_USB_DABUSB)        += dabusb.o
 obj-$(CONFIG_USB_DSBR)          += dsbr100.o
diff --git a/drivers/media/video/arv.c b/drivers/media/video/arv.c
index dbe02517059..6e08e32346e 100644
--- a/drivers/media/video/arv.c
+++ b/drivers/media/video/arv.c
@@ -31,6 +31,7 @@
 #include <linux/mm.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/mutex.h>
 
 #include <asm/uaccess.h>
@@ -212,7 +213,7 @@ void init_iic(void)
         ar_outl(0x0300, PLDI2CMOD);     /* I2CMOD ACK/8b-data/7b-addr/auto */
         ar_outl(0x1, PLDI2CACK);        /* I2CACK ACK                      */
 
-        /* I2C CLK */
+        /* I2C CLK */
         /* 50MH-100k */
         if (freq == 75) {
                 ar_outl(369, PLDI2CFREQ);       /* BCLK = 75MHz */
diff --git a/drivers/media/video/bt866.c b/drivers/media/video/bt866.c
new file mode 100644
index 00000000000..05e42bbcfc3
--- /dev/null
+++ b/drivers/media/video/bt866.c
@@ -0,0 +1,377 @@
+/*
+    bt866 - BT866 Digital Video Encoder (Rockwell Part)
+
+    Copyright (C) 1999 Mike Bernson <mike@mlb.org>
+    Copyright (C) 1998 Dave Perks <dperks@ibm.net>
+
+    Modifications for LML33/DC10plus unified driver
+    Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
+
+    This code was modify/ported from the saa7111 driver written
+    by Dave Perks.
+
+    This code was adapted for the bt866 by Christer Weinigel and ported
+    to 2.6 by Martin Samuelsson.
+
+    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/init.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/major.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/pci.h>
+#include <linux/signal.h>
+#include <asm/io.h>
+#include <asm/pgtable.h>
+#include <asm/page.h>
+#include <linux/sched.h>
+#include <linux/types.h>
+#include <linux/i2c.h>
+
+#include <linux/videodev.h>
+#include <asm/uaccess.h>
+
+#include <linux/video_encoder.h>
+
+MODULE_LICENSE("GPL");
+
+#define BT866_DEVNAME   "bt866"
+#define I2C_BT866       0x88
+
+MODULE_LICENSE("GPL");
+
+#define DEBUG(x)                /* Debug driver */
+
+/* ----------------------------------------------------------------------- */
+
+struct bt866 {
+        struct i2c_client *i2c;
+        int addr;
+        unsigned char reg[128];
+
+        int norm;
+        int enable;
+        int bright;
+        int contrast;
+        int hue;
+        int sat;
+};
+
+static int bt866_write(struct bt866 *dev,
+                        unsigned char subaddr, unsigned char data);
+
+static int bt866_do_command(struct bt866 *encoder,
+                        unsigned int cmd, void *arg)
+{
+        switch (cmd) {
+        case ENCODER_GET_CAPABILITIES:
+        {
+                struct video_encoder_capability *cap = arg;
+
+                DEBUG(printk
+                      (KERN_INFO "%s: get capabilities\n",
+                       encoder->i2c->name));
+
+                cap->flags
+                        = VIDEO_ENCODER_PAL
+                        | VIDEO_ENCODER_NTSC
+                        | VIDEO_ENCODER_CCIR;
+                cap->inputs = 2;
+                cap->outputs = 1;
+        }
+        break;
+
+        case ENCODER_SET_NORM:
+        {
+                int *iarg = arg;
+
+                DEBUG(printk(KERN_INFO "%s: set norm %d\n",
+                             encoder->i2c->name, *iarg));
+
+                switch (*iarg) {
+
+                case VIDEO_MODE_NTSC:
+                        break;
+
+                case VIDEO_MODE_PAL:
+                        break;
+
+                default:
+                        return -EINVAL;
+
+                }
+                encoder->norm = *iarg;
+        }
+        break;
+
+        case ENCODER_SET_INPUT:
+        {
+                int *iarg = arg;
+                static const __u8 init[] = {
+                        0xc8, 0xcc, /* CRSCALE */
+                        0xca, 0x91, /* CBSCALE */
+                        0xcc, 0x24, /* YC16 | OSDNUM */
+                        0xda, 0x00, /*  */
+                        0xdc, 0x24, /* SETMODE | PAL */
+                        0xde, 0x02, /* EACTIVE */
+
+                        /* overlay colors */
+                        0x70, 0xEB, 0x90, 0x80, 0xB0, 0x80, /* white */
+                        0x72, 0xA2, 0x92, 0x8E, 0xB2, 0x2C, /* yellow */
+                        0x74, 0x83, 0x94, 0x2C, 0xB4, 0x9C, /* cyan */
+                        0x76, 0x70, 0x96, 0x3A, 0xB6, 0x48, /* green */
+                        0x78, 0x54, 0x98, 0xC6, 0xB8, 0xB8, /* magenta */
+                        0x7A, 0x41, 0x9A, 0xD4, 0xBA, 0x64, /* red */
+                        0x7C, 0x23, 0x9C, 0x72, 0xBC, 0xD4, /* blue */
+                        0x7E, 0x10, 0x9E, 0x80, 0xBE, 0x80, /* black */
+
+                        0x60, 0xEB, 0x80, 0x80, 0xc0, 0x80, /* white */
+                        0x62, 0xA2, 0x82, 0x8E, 0xc2, 0x2C, /* yellow */
+                        0x64, 0x83, 0x84, 0x2C, 0xc4, 0x9C, /* cyan */
+                        0x66, 0x70, 0x86, 0x3A, 0xc6, 0x48, /* green */
+                        0x68, 0x54, 0x88, 0xC6, 0xc8, 0xB8, /* magenta */
+                        0x6A, 0x41, 0x8A, 0xD4, 0xcA, 0x64, /* red */
+                        0x6C, 0x23, 0x8C, 0x72, 0xcC, 0xD4, /* blue */
+                        0x6E, 0x10, 0x8E, 0x80, 0xcE, 0x80, /* black */
+                };
+                int i;
+                u8 val;
+
+                for (i = 0; i < ARRAY_SIZE(init) / 2; i += 2)
+                        bt866_write(encoder, init[i], init[i+1]);
+
+                val = encoder->reg[0xdc];
+
+                if (*iarg == 0)
+                        val |= 0x40; /* CBSWAP */
+                else
+                        val &= ~0x40; /* !CBSWAP */
+
+                bt866_write(encoder, 0xdc, val);
+
+                val = encoder->reg[0xcc];
+                if (*iarg == 2)
+                        val |= 0x01; /* OSDBAR */
+                else
+                        val &= ~0x01; /* !OSDBAR */
+                bt866_write(encoder, 0xcc, val);
+
+                DEBUG(printk(KERN_INFO "%s: set input %d\n",
+                             encoder->i2c->name, *iarg));
+
+                switch (*iarg) {
+                case 0:
+                        break;
+                case 1:
+                        break;
+                default:
+                        return -EINVAL;
+
+                }
+        }
+        break;
+
+        case ENCODER_SET_OUTPUT:
+        {
+                int *iarg = arg;
+
+                DEBUG(printk(KERN_INFO "%s: set output %d\n",
+                             encoder->i2c->name, *iarg));
+
+                /* not much choice of outputs */
+                if (*iarg != 0)
+                        return -EINVAL;
+        }
+        break;
+
+        case ENCODER_ENABLE_OUTPUT:
+        {
+                int *iarg = arg;
+                encoder->enable = !!*iarg;
+
+                DEBUG(printk
+                      (KERN_INFO "%s: enable output %d\n",
+                       encoder->i2c->name, encoder->enable));
+        }
+        break;
+
+        case 4711:
+        {
+                int *iarg = arg;
+                __u8 val;
+
+                printk("bt866: square = %d\n", *iarg);
+
+                val = encoder->reg[0xdc];
+                if (*iarg)
+                        val |= 1; /* SQUARE */
+                else
+                        val &= ~1; /* !SQUARE */
+                bt866_write(encoder, 0xdc, val);
+                break;
+        }
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int bt866_write(struct bt866 *encoder,
+                        unsigned char subaddr, unsigned char data)
+{
+        unsigned char buffer[2];
+        int err;
+
+        buffer[0] = subaddr;
+        buffer[1] = data;
+
+        encoder->reg[subaddr] = data;
+
+        DEBUG(printk
+              ("%s: write 0x%02X = 0x%02X\n",
+               encoder->i2c->name, subaddr, data));
+
+        for (err = 0; err < 3;) {
+                if (i2c_master_send(encoder->i2c, buffer, 2) == 2)
+                        break;
+                err++;
+                printk(KERN_WARNING "%s: I/O error #%d "
+                       "(write 0x%02x/0x%02x)\n",
+                       encoder->i2c->name, err, encoder->addr, subaddr);
+                schedule_timeout_interruptible(HZ/10);
+        }
+        if (err == 3) {
+                printk(KERN_WARNING "%s: giving up\n",
+                       encoder->i2c->name);
+                return -1;
+        }
+
+        return 0;
+}
+
+static int bt866_attach(struct i2c_adapter *adapter);
+static int bt866_detach(struct i2c_client *client);
+static int bt866_command(struct i2c_client *client,
+                         unsigned int cmd, void *arg);
+
+
+/* Addresses to scan */
+static unsigned short normal_i2c[]      = {I2C_BT866>>1, I2C_CLIENT_END};
+static unsigned short probe[2]          = {I2C_CLIENT_END, I2C_CLIENT_END};
+static unsigned short ignore[2]         = {I2C_CLIENT_END, I2C_CLIENT_END};
+
+static struct i2c_client_address_data addr_data = {
+        normal_i2c,
+        probe,
+        ignore,
+};
+
+static struct i2c_driver i2c_driver_bt866 = {
+        .driver.name = BT866_DEVNAME,
+        .id = I2C_DRIVERID_BT866,
+        .attach_adapter = bt866_attach,
+        .detach_client = bt866_detach,
+        .command = bt866_command
+};
+
+
+static struct i2c_client bt866_client_tmpl =
+{
+        .name = "(nil)",
+        .addr = 0,
+        .adapter = NULL,
+        .driver = &i2c_driver_bt866,
+        .usage_count = 0
+};
+
+static int bt866_found_proc(struct i2c_adapter *adapter,
+                            int addr, int kind)
+{
+        struct bt866 *encoder;
+        struct i2c_client *client;
+
+        client = kzalloc(sizeof(*client), GFP_KERNEL);
+        if (client == NULL)
+                return -ENOMEM;
+        memcpy(client, &bt866_client_tmpl, sizeof(*client));
+
+        encoder = kzalloc(sizeof(*encoder), GFP_KERNEL);
+        if (encoder == NULL) {
+                kfree(client);
+                return -ENOMEM;
+        }
+
+        i2c_set_clientdata(client, encoder);
+        client->adapter = adapter;
+        client->addr = addr;
+        sprintf(client->name, "%s-%02x", BT866_DEVNAME, adapter->id);
+
+        encoder->i2c = client;
+        encoder->addr = addr;
+        //encoder->encoder_type = ENCODER_TYPE_UNKNOWN;
+
+        /* initialize */
+
+        i2c_attach_client(client);
+
+        return 0;
+}
+
+static int bt866_attach(struct i2c_adapter *adapter)
+{
+        if (adapter->id == I2C_HW_B_ZR36067)
+                return i2c_probe(adapter, &addr_data, bt866_found_proc);
+        return 0;
+}
+
+static int bt866_detach(struct i2c_client *client)
+{
+        struct bt866 *encoder = i2c_get_clientdata(client);
+
+        i2c_detach_client(client);
+        kfree(encoder);
+        kfree(client);
+
+        return 0;
+}
+
+static int bt866_command(struct i2c_client *client,
+                         unsigned int cmd, void *arg)
+{
+        struct bt866 *encoder = i2c_get_clientdata(client);
+        return bt866_do_command(encoder, cmd, arg);
+}
+
+static int __devinit bt866_init(void)
+{
+        i2c_add_driver(&i2c_driver_bt866);
+        return 0;
+}
+
+static void __devexit bt866_exit(void)
+{
+        i2c_del_driver(&i2c_driver_bt866);
+}
+
+module_init(bt866_init);
+module_exit(bt866_exit);
diff --git a/drivers/media/video/bt8xx/bttv-cards.c b/drivers/media/video/bt8xx/bttv-cards.c
index 2b64aa835b4..3116345c93b 100644
--- a/drivers/media/video/bt8xx/bttv-cards.c
+++ b/drivers/media/video/bt8xx/bttv-cards.c
@@ -269,7 +269,7 @@ static struct CARD {
         { 0x41a0a051, BTTV_BOARD_FLYVIDEO_98FM, "Lifeview FlyVideo 98 LR50 Rev Q" },
         { 0x18501f7f, BTTV_BOARD_FLYVIDEO_98,   "Lifeview Flyvideo 98" },
 
-        { 0x010115cb, BTTV_BOARD_GMV1,          "AG GMV1" },
+        { 0x010115cb, BTTV_BOARD_GMV1,          "AG GMV1" },
         { 0x010114c7, BTTV_BOARD_MODTEC_205,    "Modular Technology MM201/MM202/MM205/MM210/MM215 PCTV" },
 
         { 0x10b42636, BTTV_BOARD_HAUPPAUGE878,  "STB ???" },
@@ -309,6 +309,7 @@ static struct CARD {
         { 0x07611461, BTTV_BOARD_AVDVBT_761,    "AverMedia AverTV DVB-T 761" },
         { 0xdb1018ac, BTTV_BOARD_DVICO_DVBT_LITE,    "DViCO FusionHDTV DVB-T Lite" },
         { 0xd50018ac, BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE,    "DViCO FusionHDTV 5 Lite" },
+        { 0x00261822, BTTV_BOARD_TWINHAN_DST,   "DNTV Live! Mini "},
 
         { 0, -1, NULL }
 };
@@ -1903,7 +1904,7 @@ struct tvcard bttv_tvcards[] = {
                 .no_tda7432     = 1,
         },
         [BTTV_BOARD_OSPREY2x0] = {
-                .name           = "Osprey 210/220",   /* 0x1(A|B)-04C0-C1 */
+                .name           = "Osprey 210/220/230",   /* 0x1(A|B)-04C0-C1 */
                 .video_inputs   = 2,
                 .audio_inputs   = 1,
                 .tuner          = -1,
@@ -2745,7 +2746,7 @@ struct tvcard bttv_tvcards[] = {
                 /* Michael Krufky <mkrufky@m1k.net> */
                 .name           = "DViCO FusionHDTV 5 Lite",
                 .tuner          = 0,
-                .tuner_type     = TUNER_LG_TDVS_H062F,
+                .tuner_type     = TUNER_LG_TDVS_H06XF, /* TDVS-H064F */
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
                 .video_inputs   = 3,
@@ -2762,7 +2763,7 @@ struct tvcard bttv_tvcards[] = {
         },
                 /* ---- card 0x88---------------------------------- */
         [BTTV_BOARD_ACORP_Y878F] = {
-                /* Mauro Carvalho Chehab <mchehab@brturbo.com.br> */
+                /* Mauro Carvalho Chehab <mchehab@infradead.org> */
                 .name           = "Acorp Y878F",
                 .video_inputs   = 3,
                 .audio_inputs   = 1,
@@ -3790,6 +3791,7 @@ static void __devinit osprey_eeprom(struct bttv *btv)
                        break;
                case 0x0060:
                case 0x0070:
+               case 0x00A0:
                        btv->c.type = BTTV_BOARD_OSPREY2x0;
                        /* enable output on select control lines */
                        gpio_inout(0xffffff,0x000303);
diff --git a/drivers/media/video/bt8xx/bttv-gpio.c b/drivers/media/video/bt8xx/bttv-gpio.c
index c4d5e2b70c2..ba081f6f8c8 100644
--- a/drivers/media/video/bt8xx/bttv-gpio.c
+++ b/drivers/media/video/bt8xx/bttv-gpio.c
@@ -118,20 +118,6 @@ int bttv_sub_del_devices(struct bttv_core *core)
         return 0;
 }
 
-void bttv_gpio_irq(struct bttv_core *core)
-{
-        struct bttv_sub_driver *drv;
-        struct bttv_sub_device *dev;
-        struct list_head *item;
-
-        list_for_each(item,&core->subs) {
-                dev = list_entry(item,struct bttv_sub_device,list);
-                drv = to_bttv_sub_drv(dev->dev.driver);
-                if (drv && drv->gpio_irq)
-                        drv->gpio_irq(dev);
-        }
-}
-
 /* ----------------------------------------------------------------------- */
 /* external: sub-driver register/unregister                                */
 
diff --git a/drivers/media/video/bt8xx/bttv-input.c b/drivers/media/video/bt8xx/bttv-input.c
index 69efa0e5174..b41f81d2372 100644
--- a/drivers/media/video/bt8xx/bttv-input.c
+++ b/drivers/media/video/bt8xx/bttv-input.c
@@ -355,7 +355,7 @@ int bttv_input_init(struct bttv *btv)
 
         if (ir->rc5_gpio) {
                 u32 gpio;
-                /* enable remote irq */
+                /* enable remote irq */
                 bttv_gpio_inout(&btv->c, (1 << 4), 1 << 4);
                 gpio = bttv_gpio_read(&btv->c);
                 bttv_gpio_write(&btv->c, gpio & ~(1 << 4));
diff --git a/drivers/media/video/bt8xx/bttv.h b/drivers/media/video/bt8xx/bttv.h
index 3a23265c153..f9c9e3c4d11 100644
--- a/drivers/media/video/bt8xx/bttv.h
+++ b/drivers/media/video/bt8xx/bttv.h
@@ -350,7 +350,6 @@ struct bttv_sub_driver {
         char                   wanted[BUS_ID_SIZE];
         int                    (*probe)(struct bttv_sub_device *sub);
         void                   (*remove)(struct bttv_sub_device *sub);
-        void                   (*gpio_irq)(struct bttv_sub_device *sub);
 };
 #define to_bttv_sub_drv(x) container_of((x), struct bttv_sub_driver, drv)
 
diff --git a/drivers/media/video/bt8xx/bttvp.h b/drivers/media/video/bt8xx/bttvp.h
index ee989d2e15d..d2956010f76 100644
--- a/drivers/media/video/bt8xx/bttvp.h
+++ b/drivers/media/video/bt8xx/bttvp.h
@@ -33,6 +33,7 @@
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/pci.h>
 #include <linux/input.h>
 #include <linux/mutex.h>
@@ -214,7 +215,6 @@ extern struct videobuf_queue_ops bttv_vbi_qops;
 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);
-void bttv_gpio_irq(struct bttv_core *core);
 
 
 /* ---------------------------------------------------------- */
diff --git a/drivers/media/video/bw-qcam.c b/drivers/media/video/bw-qcam.c
index cf61c590f4a..7d0b6e59c6e 100644
--- a/drivers/media/video/bw-qcam.c
+++ b/drivers/media/video/bw-qcam.c
@@ -73,6 +73,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include <linux/parport.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/mutex.h>
 #include <asm/uaccess.h>
 
@@ -759,7 +760,7 @@ static int qcam_do_ioctl(struct inode *inode, struct file *file,
                 {
                         struct video_picture *p = arg;
                         if(p->palette!=VIDEO_PALETTE_GREY)
-                                return -EINVAL;
+                                return -EINVAL;
                         if(p->depth!=4 && p->depth!=6)
                                 return -EINVAL;
 
diff --git a/drivers/media/video/c-qcam.c b/drivers/media/video/c-qcam.c
index 22a7386bbea..a3989bd2f81 100644
--- a/drivers/media/video/c-qcam.c
+++ b/drivers/media/video/c-qcam.c
@@ -34,6 +34,7 @@
 #include <linux/parport.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/mutex.h>
 
 #include <asm/uaccess.h>
diff --git a/drivers/media/video/cpia.c b/drivers/media/video/cpia.c
index 85d84e89d8f..95c5aceecc5 100644
--- a/drivers/media/video/cpia.c
+++ b/drivers/media/video/cpia.c
@@ -47,13 +47,6 @@
 
 #include "cpia.h"
 
-#ifdef CONFIG_VIDEO_CPIA_PP
-extern int cpia_pp_init(void);
-#endif
-#ifdef CONFIG_VIDEO_CPIA_USB
-extern int cpia_usb_init(void);
-#endif
-
 static int video_nr = -1;
 
 #ifdef MODULE
@@ -67,10 +60,10 @@ MODULE_SUPPORTED_DEVICE("video");
 static unsigned short colorspace_conv;
 module_param(colorspace_conv, ushort, 0444);
 MODULE_PARM_DESC(colorspace_conv,
-                 " Colorspace conversion:"
-                 "\n  0 = disable, 1 = enable"
-                 "\n  Default value is 0"
-                 );
+                 " Colorspace conversion:"
+                 "\n  0 = disable, 1 = enable"
+                 "\n  Default value is 0"
+                 );
 
 #define ABOUT "V4L-Driver for Vision CPiA based cameras"
 
@@ -4047,13 +4040,6 @@ static int __init cpia_init(void)
         proc_cpia_create();
 #endif
 
-#ifdef CONFIG_VIDEO_CPIA_PP
-        cpia_pp_init();
-#endif
-#ifdef CONFIG_VIDEO_CPIA_USB
-        cpia_usb_init();
-#endif
-
         return 0;
 }
 
diff --git a/drivers/media/video/cpia.h b/drivers/media/video/cpia.h
index dde27a6a4a0..6eaa692021c 100644
--- a/drivers/media/video/cpia.h
+++ b/drivers/media/video/cpia.h
@@ -45,6 +45,7 @@
 
 #include <asm/uaccess.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/list.h>
 #include <linux/smp_lock.h>
 #include <linux/mutex.h>
@@ -247,7 +248,7 @@ enum v4l_camstates {
 struct cam_data {
         struct list_head cam_data_list;
 
-        struct mutex busy_lock;     /* guard against SMP multithreading */
+        struct mutex busy_lock;         /* guard against SMP multithreading */
         struct cpia_camera_ops *ops;    /* lowlevel driver operations */
         void *lowlevel_data;            /* private data for lowlevel driver */
         u8 *raw_image;                  /* buffer for raw image data */
diff --git a/drivers/media/video/cpia2/cpia2.h b/drivers/media/video/cpia2/cpia2.h
index 1764991b0ac..c5ecb2be5f9 100644
--- a/drivers/media/video/cpia2/cpia2.h
+++ b/drivers/media/video/cpia2/cpia2.h
@@ -33,6 +33,7 @@
 
 #include <linux/version.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/usb.h>
 #include <linux/poll.h>
 
diff --git a/drivers/media/video/cpia2/cpia2_v4l.c b/drivers/media/video/cpia2/cpia2_v4l.c
index 481e178ef56..d129db57fcd 100644
--- a/drivers/media/video/cpia2/cpia2_v4l.c
+++ b/drivers/media/video/cpia2/cpia2_v4l.c
@@ -343,7 +343,9 @@ static int cpia2_close(struct inode *inode, struct file *file)
                 cpia2_free_buffers(cam);
                 if (!cam->present) {
                         video_unregister_device(dev);
+                        mutex_unlock(&cam->busy_lock);
                         kfree(cam);
+                        return 0;
                 }
         }
 
@@ -1167,9 +1169,9 @@ static int ioctl_g_ctrl(void *arg,struct camera_data *cam)
                 } else {
                     if(cam->params.flicker_control.cam_register &
                        CPIA2_VP_FLICKER_MODES_50HZ) {
-                        mode = FLICKER_50;
+                        mode = FLICKER_50;
                     } else {
-                        mode = FLICKER_60;
+                        mode = FLICKER_60;
                     }
                 }
                 for(i=0; i<NUM_FLICKER_CONTROLS; i++) {
diff --git a/drivers/media/video/cpia_pp.c b/drivers/media/video/cpia_pp.c
index 0b00e6027df..4c89bd395d3 100644
--- a/drivers/media/video/cpia_pp.c
+++ b/drivers/media/video/cpia_pp.c
@@ -803,7 +803,7 @@ static struct parport_driver cpia_pp_driver = {
         .detach = cpia_pp_detach,
 };
 
-int cpia_pp_init(void)
+static int cpia_pp_init(void)
 {
         printk(KERN_INFO "%s v%d.%d.%d\n",ABOUT,
                CPIA_PP_MAJ_VER,CPIA_PP_MIN_VER,CPIA_PP_PATCH_VER);
@@ -860,6 +860,8 @@ void cleanup_module(void)
 
 static int __init cpia_pp_setup(char *str)
 {
+        int err;
+
         if (!strncmp(str, "parport", 7)) {
                 int n = simple_strtoul(str + 7, NULL, 10);
                 if (parport_ptr < PARPORT_MAX) {
@@ -873,6 +875,10 @@ static int __init cpia_pp_setup(char *str)
                 parport_nr[parport_ptr++] = PPCPIA_PARPORT_NONE;
         }
 
+        err=cpia_pp_init();
+        if (err)
+                return err;
+
         return 1;
 }
 
diff --git a/drivers/media/video/cpia_usb.c b/drivers/media/video/cpia_usb.c
index 9c49a4b0011..2ee34a3b928 100644
--- a/drivers/media/video/cpia_usb.c
+++ b/drivers/media/video/cpia_usb.c
@@ -474,12 +474,6 @@ static int cpia_usb_close(void *privdata)
         return 0;
 }
 
-int cpia_usb_init(void)
-{
-        /* return -ENODEV; */
-        return 0;
-}
-
 /* Probing and initializing */
 
 static int cpia_probe(struct usb_interface *intf,
diff --git a/drivers/media/video/cx2341x.c b/drivers/media/video/cx2341x.c
new file mode 100644
index 00000000000..554813e6f65
--- /dev/null
+++ b/drivers/media/video/cx2341x.c
@@ -0,0 +1,915 @@
+/*
+ * cx2341x - generic code for cx23415/6 based devices
+ *
+ * Copyright (C) 2006 Hans Verkuil <hverkuil@xs4all.nl>
+ *
+ * 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/moduleparam.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/videodev2.h>
+#include <linux/i2c.h>
+
+#include <media/tuner.h>
+#include <media/cx2341x.h>
+#include <media/v4l2-common.h>
+
+MODULE_DESCRIPTION("cx23415/6 driver");
+MODULE_AUTHOR("Hans Verkuil");
+MODULE_LICENSE("GPL");
+
+static int debug = 0;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Debug level (0-1)");
+
+const u32 cx2341x_mpeg_ctrls[] = {
+        V4L2_CID_MPEG_CLASS,
+        V4L2_CID_MPEG_STREAM_TYPE,
+        V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
+        V4L2_CID_MPEG_AUDIO_ENCODING,
+        V4L2_CID_MPEG_AUDIO_L2_BITRATE,
+        V4L2_CID_MPEG_AUDIO_MODE,
+        V4L2_CID_MPEG_AUDIO_MODE_EXTENSION,
+        V4L2_CID_MPEG_AUDIO_EMPHASIS,
+        V4L2_CID_MPEG_AUDIO_CRC,
+        V4L2_CID_MPEG_VIDEO_ENCODING,
+        V4L2_CID_MPEG_VIDEO_ASPECT,
+        V4L2_CID_MPEG_VIDEO_B_FRAMES,
+        V4L2_CID_MPEG_VIDEO_GOP_SIZE,
+        V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
+        V4L2_CID_MPEG_VIDEO_PULLDOWN,
+        V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
+        V4L2_CID_MPEG_VIDEO_BITRATE,
+        V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
+        V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION,
+        V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE,
+        V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER,
+        V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE,
+        V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE,
+        V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE,
+        V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER,
+        V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE,
+        V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM,
+        V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP,
+        V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM,
+        V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP,
+        0
+};
+
+
+/* Map the control ID to the correct field in the cx2341x_mpeg_params
+   struct. Return -EINVAL if the ID is unknown, else return 0. */
+static int cx2341x_get_ctrl(struct cx2341x_mpeg_params *params,
+                struct v4l2_ext_control *ctrl)
+{
+        switch (ctrl->id) {
+        case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
+                ctrl->value = params->audio_sampling_freq;
+                break;
+        case V4L2_CID_MPEG_AUDIO_ENCODING:
+                ctrl->value = params->audio_encoding;
+                break;
+        case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
+                ctrl->value = params->audio_l2_bitrate;
+                break;
+        case V4L2_CID_MPEG_AUDIO_MODE:
+                ctrl->value = params->audio_mode;
+                break;
+        case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
+                ctrl->value = params->audio_mode_extension;
+                break;
+        case V4L2_CID_MPEG_AUDIO_EMPHASIS:
+                ctrl->value = params->audio_emphasis;
+                break;
+        case V4L2_CID_MPEG_AUDIO_CRC:
+                ctrl->value = params->audio_crc;
+                break;
+        case V4L2_CID_MPEG_VIDEO_ENCODING:
+                ctrl->value = params->video_encoding;
+                break;
+        case V4L2_CID_MPEG_VIDEO_ASPECT:
+                ctrl->value = params->video_aspect;
+                break;
+        case V4L2_CID_MPEG_VIDEO_B_FRAMES:
+                ctrl->value = params->video_b_frames;
+                break;
+        case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
+                ctrl->value = params->video_gop_size;
+                break;
+        case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
+                ctrl->value = params->video_gop_closure;
+                break;
+        case V4L2_CID_MPEG_VIDEO_PULLDOWN:
+                ctrl->value = params->video_pulldown;
+                break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
+                ctrl->value = params->video_bitrate_mode;
+                break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE:
+                ctrl->value = params->video_bitrate;
+                break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
+                ctrl->value = params->video_bitrate_peak;
+                break;
+        case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
+                ctrl->value = params->video_temporal_decimation;
+                break;
+        case V4L2_CID_MPEG_STREAM_TYPE:
+                ctrl->value = params->stream_type;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
+                ctrl->value = params->video_spatial_filter_mode;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
+                ctrl->value = params->video_spatial_filter;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
+                ctrl->value = params->video_luma_spatial_filter_type;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
+                ctrl->value = params->video_chroma_spatial_filter_type;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
+                ctrl->value = params->video_temporal_filter_mode;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
+                ctrl->value = params->video_temporal_filter;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
+                ctrl->value = params->video_median_filter_type;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
+                ctrl->value = params->video_luma_median_filter_top;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
+                ctrl->value = params->video_luma_median_filter_bottom;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
+                ctrl->value = params->video_chroma_median_filter_top;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
+                ctrl->value = params->video_chroma_median_filter_bottom;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/* Map the control ID to the correct field in the cx2341x_mpeg_params
+   struct. Return -EINVAL if the ID is unknown, else return 0. */
+static int cx2341x_set_ctrl(struct cx2341x_mpeg_params *params,
+                struct v4l2_ext_control *ctrl)
+{
+        switch (ctrl->id) {
+        case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
+                params->audio_sampling_freq = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_AUDIO_ENCODING:
+                params->audio_encoding = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
+                params->audio_l2_bitrate = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_AUDIO_MODE:
+                params->audio_mode = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
+                params->audio_mode_extension = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_AUDIO_EMPHASIS:
+                params->audio_emphasis = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_AUDIO_CRC:
+                params->audio_crc = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_VIDEO_ASPECT:
+                params->video_aspect = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_VIDEO_B_FRAMES: {
+                int b = ctrl->value + 1;
+                int gop = params->video_gop_size;
+                params->video_b_frames = ctrl->value;
+                params->video_gop_size = b * ((gop + b - 1) / b);
+                /* Max GOP size = 34 */
+                while (params->video_gop_size > 34)
+                        params->video_gop_size -= b;
+                break;
+        }
+        case V4L2_CID_MPEG_VIDEO_GOP_SIZE: {
+                int b = params->video_b_frames + 1;
+                int gop = ctrl->value;
+                params->video_gop_size = b * ((gop + b - 1) / b);
+                /* Max GOP size = 34 */
+                while (params->video_gop_size > 34)
+                        params->video_gop_size -= b;
+                ctrl->value = params->video_gop_size;
+                break;
+        }
+        case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
+                params->video_gop_closure = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_VIDEO_PULLDOWN:
+                params->video_pulldown = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
+                /* MPEG-1 only allows CBR */
+                if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1 &&
+                    ctrl->value != V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
+                        return -EINVAL;
+                params->video_bitrate_mode = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE:
+                params->video_bitrate = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
+                params->video_bitrate_peak = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
+                params->video_temporal_decimation = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_STREAM_TYPE:
+                params->stream_type = ctrl->value;
+                params->video_encoding =
+                        (params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_SS ||
+                         params->stream_type == V4L2_MPEG_STREAM_TYPE_MPEG1_VCD) ?
+                        V4L2_MPEG_VIDEO_ENCODING_MPEG_1 : V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
+                if (params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) {
+                        /* MPEG-1 implies CBR */
+                        params->video_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
+                }
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
+                params->video_spatial_filter_mode = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
+                params->video_spatial_filter = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
+                params->video_luma_spatial_filter_type = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
+                params->video_chroma_spatial_filter_type = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
+                params->video_temporal_filter_mode = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
+                params->video_temporal_filter = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
+                params->video_median_filter_type = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
+                params->video_luma_median_filter_top = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
+                params->video_luma_median_filter_bottom = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
+                params->video_chroma_median_filter_top = ctrl->value;
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
+                params->video_chroma_median_filter_bottom = ctrl->value;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int cx2341x_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
+{
+        const char *name;
+
+        qctrl->flags = 0;
+        switch (qctrl->id) {
+        /* MPEG controls */
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
+                name = "Spatial Filter Mode";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
+                name = "Spatial Filter";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
+                name = "Spatial Luma Filter Type";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
+                name = "Spatial Chroma Filter Type";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
+                name = "Temporal Filter Mode";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
+                name = "Temporal Filter";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
+                name = "Median Filter Type";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
+                name = "Median Luma Filter Maximum";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
+                name = "Median Luma Filter Minimum";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
+                name = "Median Chroma Filter Maximum";
+                break;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
+                name = "Median Chroma Filter Minimum";
+                break;
+
+        default:
+                return v4l2_ctrl_query_fill(qctrl, min, max, step, def);
+        }
+        switch (qctrl->id) {
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
+        case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
+                qctrl->type = V4L2_CTRL_TYPE_MENU;
+                min = 0;
+                step = 1;
+                break;
+        default:
+                qctrl->type = V4L2_CTRL_TYPE_INTEGER;
+                break;
+        }
+        switch (qctrl->id) {
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
+        case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
+                qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
+                break;
+        }
+        qctrl->minimum = min;
+        qctrl->maximum = max;
+        qctrl->step = step;
+        qctrl->default_value = def;
+        qctrl->reserved[0] = qctrl->reserved[1] = 0;
+        snprintf(qctrl->name, sizeof(qctrl->name), name);
+        return 0;
+}
+
+int cx2341x_ctrl_query(struct cx2341x_mpeg_params *params, struct v4l2_queryctrl *qctrl)
+{
+        int err;
+
+        switch (qctrl->id) {
+        case V4L2_CID_MPEG_AUDIO_ENCODING:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
+                                V4L2_MPEG_AUDIO_ENCODING_LAYER_2, 1,
+                                V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
+
+        case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_L2_BITRATE_192K,
+                                V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
+                                V4L2_MPEG_AUDIO_L2_BITRATE_224K);
+
+        case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
+        case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
+                return -EINVAL;
+
+        case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
+                err = v4l2_ctrl_query_fill_std(qctrl);
+                if (err == 0 && params->audio_mode != V4L2_MPEG_AUDIO_MODE_JOINT_STEREO)
+                        qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return err;
+
+        case V4L2_CID_MPEG_VIDEO_ENCODING:
+                /* this setting is read-only for the cx2341x since the
+                   V4L2_CID_MPEG_STREAM_TYPE really determines the
+                   MPEG-1/2 setting */
+                err = v4l2_ctrl_query_fill_std(qctrl);
+                if (err == 0)
+                        qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
+                return err;
+
+        case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
+                err = v4l2_ctrl_query_fill_std(qctrl);
+                if (err == 0 && params->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1)
+                        qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return err;
+
+        case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
+                err = v4l2_ctrl_query_fill_std(qctrl);
+                if (err == 0 && params->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
+                        qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return err;
+
+        /* CX23415/6 specific */
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
+                return cx2341x_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
+                                V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO, 1,
+                                V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL);
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER:
+                cx2341x_ctrl_query_fill(qctrl, 0, 15, 1, 0);
+                qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
+                if (params->video_spatial_filter_mode == V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
+                       qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return 0;
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
+                cx2341x_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF,
+                                V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE, 1,
+                                V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF);
+                if (params->video_spatial_filter_mode == V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
+                       qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return 0;
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
+                cx2341x_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF,
+                                V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR, 1,
+                                V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF);
+                if (params->video_spatial_filter_mode == V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO)
+                       qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return 0;
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
+                return cx2341x_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
+                                V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO, 1,
+                                V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL);
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER:
+                cx2341x_ctrl_query_fill(qctrl, 0, 31, 1, 0);
+                qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
+                if (params->video_temporal_filter_mode == V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO)
+                       qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return 0;
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
+                return cx2341x_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
+                                V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG, 1,
+                                V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF);
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP:
+                cx2341x_ctrl_query_fill(qctrl, 0, 255, 1, 255);
+                qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
+                if (params->video_median_filter_type == V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
+                       qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return 0;
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM:
+                cx2341x_ctrl_query_fill(qctrl, 0, 255, 1, 0);
+                qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
+                if (params->video_median_filter_type == V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
+                       qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return 0;
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP:
+                cx2341x_ctrl_query_fill(qctrl, 0, 255, 1, 255);
+                qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
+                if (params->video_median_filter_type == V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
+                       qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return 0;
+
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM:
+                cx2341x_ctrl_query_fill(qctrl, 0, 255, 1, 0);
+                qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
+                if (params->video_median_filter_type == V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF)
+                       qctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
+                return 0;
+
+        default:
+                return v4l2_ctrl_query_fill_std(qctrl);
+
+        }
+}
+
+const char **cx2341x_ctrl_get_menu(u32 id)
+{
+        static const char *mpeg_stream_type[] = {
+                "MPEG-2 Program Stream",
+                "",
+                "MPEG-1 System Stream",
+                "MPEG-2 DVD-compatible Stream",
+                "MPEG-1 VCD-compatible Stream",
+                "MPEG-2 SVCD-compatible Stream",
+                NULL
+        };
+
+        static const char *cx2341x_video_spatial_filter_mode_menu[] = {
+                "Manual",
+                "Auto",
+                NULL
+        };
+
+        static const char *cx2341x_video_luma_spatial_filter_type_menu[] = {
+                "Off",
+                "1D Horizontal",
+                "1D Vertical",
+                "2D H/V Separable",
+                "2D Symmetric non-separable",
+                NULL
+        };
+
+        static const char *cx2341x_video_chroma_spatial_filter_type_menu[] = {
+                "Off",
+                "1D Horizontal",
+                NULL
+        };
+
+        static const char *cx2341x_video_temporal_filter_mode_menu[] = {
+                "Manual",
+                "Auto",
+                NULL
+        };
+
+        static const char *cx2341x_video_median_filter_type_menu[] = {
+                "Off",
+                "Horizontal",
+                "Vertical",
+                "Horizontal/Vertical",
+                "Diagonal",
+                NULL
+        };
+
+        switch (id) {
+        case V4L2_CID_MPEG_STREAM_TYPE:
+                return mpeg_stream_type;
+        case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
+        case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
+                return NULL;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE:
+                return cx2341x_video_spatial_filter_mode_menu;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE:
+                return cx2341x_video_luma_spatial_filter_type_menu;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE:
+                return cx2341x_video_chroma_spatial_filter_type_menu;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE:
+                return cx2341x_video_temporal_filter_mode_menu;
+        case V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE:
+                return cx2341x_video_median_filter_type_menu;
+        default:
+                return v4l2_ctrl_get_menu(id);
+        }
+}
+
+static void cx2341x_calc_audio_properties(struct cx2341x_mpeg_params *params)
+{
+        params->audio_properties = (params->audio_sampling_freq << 0) |
+                ((3 - params->audio_encoding) << 2) |
+                ((1 + params->audio_l2_bitrate) << 4) |
+                (params->audio_mode << 8) |
+                (params->audio_mode_extension << 10) |
+                (((params->audio_emphasis == V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17) ?
+                  3 :
+                  params->audio_emphasis) << 12) |
+                (params->audio_crc << 14);
+}
+
+int cx2341x_ext_ctrls(struct cx2341x_mpeg_params *params,
+                  struct v4l2_ext_controls *ctrls, int cmd)
+{
+        int err = 0;
+        int i;
+
+        if (cmd == VIDIOC_G_EXT_CTRLS) {
+                for (i = 0; i < ctrls->count; i++) {
+                        struct v4l2_ext_control *ctrl = ctrls->controls + i;
+
+                        err = cx2341x_get_ctrl(params, ctrl);
+                        if (err) {
+                                ctrls->error_idx = i;
+                                break;
+                        }
+                }
+                return err;
+        }
+        for (i = 0; i < ctrls->count; i++) {
+                struct v4l2_ext_control *ctrl = ctrls->controls + i;
+                struct v4l2_queryctrl qctrl;
+                const char **menu_items = NULL;
+
+                qctrl.id = ctrl->id;
+                err = cx2341x_ctrl_query(params, &qctrl);
+                if (err)
+                        break;
+                if (qctrl.type == V4L2_CTRL_TYPE_MENU)
+                        menu_items = cx2341x_ctrl_get_menu(qctrl.id);
+                err = v4l2_ctrl_check(ctrl, &qctrl, menu_items);
+                if (err)
+                        break;
+                err = cx2341x_set_ctrl(params, ctrl);
+                if (err)
+                        break;
+        }
+        if (err == 0 && params->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR &&
+                        params->video_bitrate_peak < params->video_bitrate) {
+                err = -ERANGE;
+                ctrls->error_idx = ctrls->count;
+        }
+        if (err) {
+                ctrls->error_idx = i;
+        }
+        else {
+                cx2341x_calc_audio_properties(params);
+        }
+        return err;
+}
+
+void cx2341x_fill_defaults(struct cx2341x_mpeg_params *p)
+{
+        static struct cx2341x_mpeg_params default_params = {
+        /* misc */
+        .port = CX2341X_PORT_MEMORY,
+        .width = 720,
+        .height = 480,
+        .is_50hz = 0,
+
+        /* stream */
+        .stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
+
+        /* audio */
+        .audio_sampling_freq = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000,
+        .audio_encoding = V4L2_MPEG_AUDIO_ENCODING_LAYER_2,
+        .audio_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_224K,
+        .audio_mode = V4L2_MPEG_AUDIO_MODE_STEREO,
+        .audio_mode_extension = V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
+        .audio_emphasis = V4L2_MPEG_AUDIO_EMPHASIS_NONE,
+        .audio_crc = V4L2_MPEG_AUDIO_CRC_NONE,
+
+        /* video */
+        .video_encoding = V4L2_MPEG_VIDEO_ENCODING_MPEG_2,
+        .video_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3,
+        .video_b_frames = 2,
+        .video_gop_size = 12,
+        .video_gop_closure = 1,
+        .video_pulldown = 0,
+        .video_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
+        .video_bitrate = 6000000,
+        .video_bitrate_peak = 8000000,
+        .video_temporal_decimation = 0,
+
+        /* encoding filters */
+        .video_spatial_filter_mode = V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL,
+        .video_spatial_filter = 0,
+        .video_luma_spatial_filter_type = V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR,
+        .video_chroma_spatial_filter_type = V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR,
+        .video_temporal_filter_mode = V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL,
+        .video_temporal_filter = 0,
+        .video_median_filter_type = V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF,
+        .video_luma_median_filter_top = 255,
+        .video_luma_median_filter_bottom = 0,
+        .video_chroma_median_filter_top = 255,
+        .video_chroma_median_filter_bottom = 0,
+        };
+
+        *p = default_params;
+        cx2341x_calc_audio_properties(p);
+}
+
+static int cx2341x_api(void *priv, cx2341x_mbox_func func, int cmd, int args, ...)
+{
+        u32 data[CX2341X_MBOX_MAX_DATA];
+        va_list vargs;
+        int i;
+
+        va_start(vargs, args);
+
+        for (i = 0; i < args; i++) {
+                data[i] = va_arg(vargs, int);
+        }
+        va_end(vargs);
+        return func(priv, cmd, args, 0, data);
+}
+
+int cx2341x_update(void *priv, cx2341x_mbox_func func,
+                const struct cx2341x_mpeg_params *old, const struct cx2341x_mpeg_params *new)
+{
+        static int mpeg_stream_type[] = {
+                0,      /* MPEG-2 PS */
+                1,      /* MPEG-2 TS */
+                2,      /* MPEG-1 SS */
+                14,     /* DVD */
+                11,     /* VCD */
+                12,     /* SVCD */
+        };
+
+        int err = 0;
+
+        cx2341x_api(priv, func, CX2341X_ENC_SET_OUTPUT_PORT, 2, new->port, 0);
+
+        if (old == NULL || old->is_50hz != new->is_50hz) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_RATE, 1, new->is_50hz);
+                if (err) return err;
+        }
+
+        if (old == NULL || old->width != new->width || old->height != new->height ||
+                        old->video_encoding != new->video_encoding) {
+                u16 w = new->width;
+                u16 h = new->height;
+
+                if (new->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1) {
+                        w /= 2;
+                        h /= 2;
+                }
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_SIZE, 2, h, w);
+                if (err) return err;
+        }
+
+        if (old == NULL || old->stream_type != new->stream_type) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_STREAM_TYPE, 1, mpeg_stream_type[new->stream_type]);
+                if (err) return err;
+        }
+        if (old == NULL || old->video_aspect != new->video_aspect) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_ASPECT_RATIO, 1, 1 + new->video_aspect);
+                if (err) return err;
+        }
+        if (old == NULL || old->video_b_frames != new->video_b_frames ||
+                old->video_gop_size != new->video_gop_size) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_PROPERTIES, 2,
+                                new->video_gop_size, new->video_b_frames + 1);
+                if (err) return err;
+        }
+        if (old == NULL || old->video_gop_closure != new->video_gop_closure) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_GOP_CLOSURE, 1, new->video_gop_closure);
+                if (err) return err;
+        }
+        if (old == NULL || old->video_pulldown != new->video_pulldown) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_3_2_PULLDOWN, 1, new->video_pulldown);
+                if (err) return err;
+        }
+        if (old == NULL || old->audio_properties != new->audio_properties) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_AUDIO_PROPERTIES, 1, new->audio_properties);
+                if (err) return err;
+        }
+        if (old == NULL || old->video_bitrate_mode != new->video_bitrate_mode ||
+                old->video_bitrate != new->video_bitrate ||
+                old->video_bitrate_peak != new->video_bitrate_peak) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_BIT_RATE, 5,
+                                new->video_bitrate_mode, new->video_bitrate,
+                                new->video_bitrate_peak / 400, 0, 0);
+                if (err) return err;
+        }
+        if (old == NULL || old->video_spatial_filter_mode != new->video_spatial_filter_mode ||
+                old->video_temporal_filter_mode != new->video_temporal_filter_mode ||
+                old->video_median_filter_type != new->video_median_filter_type) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_MODE, 2,
+                                new->video_spatial_filter_mode | (new->video_temporal_filter_mode << 1),
+                                new->video_median_filter_type);
+                if (err) return err;
+        }
+        if (old == NULL ||
+                old->video_luma_median_filter_bottom != new->video_luma_median_filter_bottom ||
+                old->video_luma_median_filter_top != new->video_luma_median_filter_top ||
+                old->video_chroma_median_filter_bottom != new->video_chroma_median_filter_bottom ||
+                old->video_chroma_median_filter_top != new->video_chroma_median_filter_top) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_CORING_LEVELS, 4,
+                                new->video_luma_median_filter_bottom,
+                                new->video_luma_median_filter_top,
+                                new->video_chroma_median_filter_bottom,
+                                new->video_chroma_median_filter_top);
+                if (err) return err;
+        }
+        if (old == NULL ||
+                old->video_luma_spatial_filter_type != new->video_luma_spatial_filter_type ||
+                old->video_chroma_spatial_filter_type != new->video_chroma_spatial_filter_type) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_SPATIAL_FILTER_TYPE, 2,
+                        new->video_luma_spatial_filter_type, new->video_chroma_spatial_filter_type);
+                if (err) return err;
+        }
+        if (old == NULL ||
+                old->video_spatial_filter != new->video_spatial_filter ||
+                old->video_temporal_filter != new->video_temporal_filter) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_DNR_FILTER_PROPS, 2,
+                        new->video_spatial_filter, new->video_temporal_filter);
+                if (err) return err;
+        }
+        if (old == NULL || old->video_temporal_decimation != new->video_temporal_decimation) {
+                err = cx2341x_api(priv, func, CX2341X_ENC_SET_FRAME_DROP_RATE, 1,
+                        new->video_temporal_decimation);
+                if (err) return err;
+        }
+        return 0;
+}
+
+static const char *cx2341x_menu_item(struct cx2341x_mpeg_params *p, u32 id)
+{
+        const char **menu = cx2341x_ctrl_get_menu(id);
+        struct v4l2_ext_control ctrl;
+
+        if (menu == NULL)
+                goto invalid;
+        ctrl.id = id;
+        if (cx2341x_get_ctrl(p, &ctrl))
+                goto invalid;
+        while (ctrl.value-- && *menu) menu++;
+        if (*menu == NULL)
+                goto invalid;
+        return *menu;
+
+invalid:
+        return "<invalid>";
+}
+
+void cx2341x_log_status(struct cx2341x_mpeg_params *p, int card_id)
+{
+        int is_mpeg1 = p->video_encoding == V4L2_MPEG_VIDEO_ENCODING_MPEG_1;
+
+        /* Stream */
+        printk(KERN_INFO "cx2341x-%d: Stream: %s\n",
+                card_id,
+                cx2341x_menu_item(p, V4L2_CID_MPEG_STREAM_TYPE));
+
+        /* Video */
+        printk(KERN_INFO "cx2341x-%d: Video:  %dx%d, %d fps\n",
+                card_id,
+                p->width / (is_mpeg1 ? 2 : 1), p->height / (is_mpeg1 ? 2 : 1),
+                p->is_50hz ? 25 : 30);
+        printk(KERN_INFO "cx2341x-%d: Video:  %s, %s, %s, %d",
+                card_id,
+                cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ENCODING),
+                cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_ASPECT),
+                cx2341x_menu_item(p, V4L2_CID_MPEG_VIDEO_BITRATE_MODE),
+                p->video_bitrate);
+        if (p->video_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) {
+                printk(", Peak %d", p->video_bitrate_peak);
+        }
+        printk("\n");
+        printk(KERN_INFO "cx2341x-%d: Video:  GOP Size %d, %d B-Frames, %sGOP Closure, %s3:2 Pulldown\n",
+                card_id,
+                p->video_gop_size, p->video_b_frames,
+                p->video_gop_closure ? "" : "No ",
+                p->video_pulldown ? "" : "No ");
+        if (p->video_temporal_decimation) {
+                printk(KERN_INFO "cx2341x-%d: Video: Temporal Decimation %d\n",
+                        card_id, p->video_temporal_decimation);
+        }
+
+        /* Audio */
+        printk(KERN_INFO "cx2341x-%d: Audio:  %s, %s, %s, %s",
+                card_id,
+                cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ),
+                cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_ENCODING),
+                cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_L2_BITRATE),
+                cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_MODE));
+        if (p->audio_mode == V4L2_MPEG_AUDIO_MODE_JOINT_STEREO) {
+                printk(", %s",
+                        cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_MODE_EXTENSION));
+        }
+        printk(", %s, %s\n",
+                cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_EMPHASIS),
+                cx2341x_menu_item(p, V4L2_CID_MPEG_AUDIO_CRC));
+
+        /* Encoding filters */
+        printk(KERN_INFO "cx2341x-%d: Spatial Filter:  %s, Luma %s, Chroma %s, %d\n",
+                card_id,
+                cx2341x_menu_item(p, V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE),
+                cx2341x_menu_item(p, V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE),
+                cx2341x_menu_item(p, V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE),
+                p->video_spatial_filter);
+        printk(KERN_INFO "cx2341x-%d: Temporal Filter: %s, %d\n",
+                card_id,
+                cx2341x_menu_item(p, V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE),
+                p->video_temporal_filter);
+        printk(KERN_INFO "cx2341x-%d: Median Filter:   %s, Luma [%d, %d], Chroma [%d, %d]\n",
+                card_id,
+                cx2341x_menu_item(p, V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE),
+                p->video_luma_median_filter_bottom,
+                p->video_luma_median_filter_top,
+                p->video_chroma_median_filter_bottom,
+                p->video_chroma_median_filter_top);
+}
+
+EXPORT_SYMBOL(cx2341x_fill_defaults);
+EXPORT_SYMBOL(cx2341x_ctrl_query);
+EXPORT_SYMBOL(cx2341x_ctrl_get_menu);
+EXPORT_SYMBOL(cx2341x_ext_ctrls);
+EXPORT_SYMBOL(cx2341x_update);
+EXPORT_SYMBOL(cx2341x_log_status);
+EXPORT_SYMBOL(cx2341x_mpeg_ctrls);
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
+
diff --git a/drivers/media/video/cx25840/cx25840-audio.c b/drivers/media/video/cx25840/cx25840-audio.c
index 9a4b813152e..f897c1ebd5f 100644
--- a/drivers/media/video/cx25840/cx25840-audio.c
+++ b/drivers/media/video/cx25840/cx25840-audio.c
@@ -30,9 +30,6 @@ static int set_audclk_freq(struct i2c_client *client, u32 freq)
         if (freq != 32000 && freq != 44100 && freq != 48000)
                 return -EINVAL;
 
-        /* assert soft reset */
-        cx25840_and_or(client, 0x810, ~0x1, 0x01);
-
         /* common for all inputs and rates */
         /* SA_MCLK_SEL=1, SA_MCLK_DIV=0x10 */
         cx25840_write(client, 0x127, 0x50);
@@ -46,6 +43,9 @@ static int set_audclk_freq(struct i2c_client *client, u32 freq)
                         /* AUX_PLL_FRAC */
                         cx25840_write4(client, 0x110, 0xee39bb01);
 
+                        if (state->is_cx25836)
+                                break;
+
                         /* src3/4/6_ctl = 0x0801f77f */
                         cx25840_write4(client, 0x900, 0x7ff70108);
                         cx25840_write4(client, 0x904, 0x7ff70108);
@@ -59,6 +59,9 @@ static int set_audclk_freq(struct i2c_client *client, u32 freq)
                         /* AUX_PLL_FRAC */
                         cx25840_write4(client, 0x110, 0xd66bec00);
 
+                        if (state->is_cx25836)
+                                break;
+
                         /* src3/4/6_ctl = 0x08016d59 */
                         cx25840_write4(client, 0x900, 0x596d0108);
                         cx25840_write4(client, 0x904, 0x596d0108);
@@ -72,6 +75,9 @@ static int set_audclk_freq(struct i2c_client *client, u32 freq)
                         /* AUX_PLL_FRAC */
                         cx25840_write4(client, 0x110, 0xe5d69800);
 
+                        if (state->is_cx25836)
+                                break;
+
                         /* src3/4/6_ctl = 0x08014faa */
                         cx25840_write4(client, 0x900, 0xaa4f0108);
                         cx25840_write4(client, 0x904, 0xaa4f0108);
@@ -87,6 +93,9 @@ static int set_audclk_freq(struct i2c_client *client, u32 freq)
                         /* AUX_PLL_FRAC */
                         cx25840_write4(client, 0x110, 0x69082a01);
 
+                        if (state->is_cx25836)
+                                break;
+
                         /* src1_ctl = 0x08010000 */
                         cx25840_write4(client, 0x8f8, 0x00000108);
 
@@ -106,6 +115,9 @@ static int set_audclk_freq(struct i2c_client *client, u32 freq)
                         /* AUX_PLL_FRAC */
                         cx25840_write4(client, 0x110, 0xd66bec00);
 
+                        if (state->is_cx25836)
+                                break;
+
                         /* src1_ctl = 0x08010000 */
                         cx25840_write4(client, 0x8f8, 0xcd600108);
 
@@ -122,6 +134,9 @@ static int set_audclk_freq(struct i2c_client *client, u32 freq)
                         /* AUX_PLL_FRAC */
                         cx25840_write4(client, 0x110, 0xe5d69800);
 
+                        if (state->is_cx25836)
+                                break;
+
                         /* src1_ctl = 0x08010000 */
                         cx25840_write4(client, 0x8f8, 0x00800108);
 
@@ -133,9 +148,6 @@ static int set_audclk_freq(struct i2c_client *client, u32 freq)
                 }
         }
 
-        /* deassert soft reset */
-        cx25840_and_or(client, 0x810, ~0x1, 0x00);
-
         state->audclk_freq = freq;
 
         return 0;
@@ -148,6 +160,10 @@ void cx25840_audio_set_path(struct i2c_client *client)
         /* stop microcontroller */
         cx25840_and_or(client, 0x803, ~0x10, 0);
 
+        /* assert soft reset */
+        if (!state->is_cx25836)
+                cx25840_and_or(client, 0x810, ~0x1, 0x01);
+
         /* Mute everything to prevent the PFFT! */
         cx25840_write(client, 0x8d3, 0x1f);
 
@@ -161,13 +177,19 @@ void cx25840_audio_set_path(struct i2c_client *client)
         } else {
                 /* Set Path1 to Analog Demod Main Channel */
                 cx25840_write4(client, 0x8d0, 0x7038061f);
+        }
 
+        set_audclk_freq(client, state->audclk_freq);
+
+        /* deassert soft reset */
+        if (!state->is_cx25836)
+                cx25840_and_or(client, 0x810, ~0x1, 0x00);
+
+        if (state->aud_input != CX25840_AUDIO_SERIAL) {
                 /* When the microcontroller detects the
                  * audio format, it will unmute the lines */
                 cx25840_and_or(client, 0x803, ~0x10, 0x10);
         }
-
-        set_audclk_freq(client, state->audclk_freq);
 }
 
 static int get_volume(struct i2c_client *client)
@@ -291,11 +313,25 @@ static void set_mute(struct i2c_client *client, int mute)
 
 int cx25840_audio(struct i2c_client *client, unsigned int cmd, void *arg)
 {
+        struct cx25840_state *state = i2c_get_clientdata(client);
         struct v4l2_control *ctrl = arg;
+        int retval;
 
         switch (cmd) {
         case VIDIOC_INT_AUDIO_CLOCK_FREQ:
-                return set_audclk_freq(client, *(u32 *)arg);
+                if (state->aud_input != CX25840_AUDIO_SERIAL) {
+                        cx25840_and_or(client, 0x803, ~0x10, 0);
+                        cx25840_write(client, 0x8d3, 0x1f);
+                }
+                if (!state->is_cx25836)
+                        cx25840_and_or(client, 0x810, ~0x1, 1);
+                retval = set_audclk_freq(client, *(u32 *)arg);
+                if (!state->is_cx25836)
+                        cx25840_and_or(client, 0x810, ~0x1, 0);
+                if (state->aud_input != CX25840_AUDIO_SERIAL) {
+                        cx25840_and_or(client, 0x803, ~0x10, 0x10);
+                }
+                return retval;
 
         case VIDIOC_G_CTRL:
                 switch (ctrl->id) {
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index a961bb2ab0f..5c2036b40ea 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -10,6 +10,9 @@
  *
  * VBI support by Hans Verkuil <hverkuil@xs4all.nl>.
  *
+ * NTSC sliced VBI support by Christopher Neufeld <television@cneufeld.ca>
+ * with additional fixes by Hans Verkuil <hverkuil@xs4all.nl>.
+ *
  * 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
@@ -43,7 +46,7 @@ MODULE_LICENSE("GPL");
 static unsigned short normal_i2c[] = { 0x88 >> 1, I2C_CLIENT_END };
 
 
-static int cx25840_debug;
+int cx25840_debug;
 
 module_param_named(debug,cx25840_debug, int, 0644);
 
@@ -105,7 +108,7 @@ u32 cx25840_read4(struct i2c_client * client, u16 addr)
             (buffer[2] << 8) | buffer[3];
 }
 
-int cx25840_and_or(struct i2c_client *client, u16 addr, u8 and_mask,
+int cx25840_and_or(struct i2c_client *client, u16 addr, unsigned and_mask,
                    u8 or_value)
 {
         return cx25840_write(client, addr,
@@ -117,7 +120,8 @@ int cx25840_and_or(struct i2c_client *client, u16 addr, u8 and_mask,
 
 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
                                                 enum cx25840_audio_input aud_input);
-static void log_status(struct i2c_client *client);
+static void log_audio_status(struct i2c_client *client);
+static void log_video_status(struct i2c_client *client);
 
 /* ----------------------------------------------------------------------- */
 
@@ -147,6 +151,33 @@ static void init_dll2(struct i2c_client *client)
         cx25840_write(client, 0x15d, 0xe1);
 }
 
+static void cx25836_initialize(struct i2c_client *client)
+{
+        /* reset configuration is described on page 3-77 of the CX25836 datasheet */
+        /* 2. */
+        cx25840_and_or(client, 0x000, ~0x01, 0x01);
+        cx25840_and_or(client, 0x000, ~0x01, 0x00);
+        /* 3a. */
+        cx25840_and_or(client, 0x15a, ~0x70, 0x00);
+        /* 3b. */
+        cx25840_and_or(client, 0x15b, ~0x1e, 0x06);
+        /* 3c. */
+        cx25840_and_or(client, 0x159, ~0x02, 0x02);
+        /* 3d. */
+        /* There should be a 10-us delay here, but since the
+           i2c bus already has a 10-us delay we don't need to do
+           anything */
+        /* 3e. */
+        cx25840_and_or(client, 0x159, ~0x02, 0x00);
+        /* 3f. */
+        cx25840_and_or(client, 0x159, ~0xc0, 0xc0);
+        /* 3g. */
+        cx25840_and_or(client, 0x159, ~0x01, 0x00);
+        cx25840_and_or(client, 0x159, ~0x01, 0x01);
+        /* 3h. */
+        cx25840_and_or(client, 0x15b, ~0x1e, 0x10);
+}
+
 static void cx25840_initialize(struct i2c_client *client, int loadfw)
 {
         struct cx25840_state *state = i2c_get_clientdata(client);
@@ -220,17 +251,7 @@ static void input_change(struct i2c_client *client)
         cx25840_and_or(client, 0x401, ~0x60, 0);
         cx25840_and_or(client, 0x401, ~0x60, 0x60);
 
-        /* Note: perhaps V4L2_STD_PAL_M should be handled as V4L2_STD_NTSC
-           instead of V4L2_STD_PAL. Someone needs to test this. */
-        if (std & V4L2_STD_PAL) {
-                /* Follow tuner change procedure for PAL */
-                cx25840_write(client, 0x808, 0xff);
-                cx25840_write(client, 0x80b, 0x10);
-        } else if (std & V4L2_STD_SECAM) {
-                /* Select autodetect for SECAM */
-                cx25840_write(client, 0x808, 0xff);
-                cx25840_write(client, 0x80b, 0x10);
-        } else if (std & V4L2_STD_NTSC) {
+        if (std & V4L2_STD_525_60) {
                 /* Certain Hauppauge PVR150 models have a hardware bug
                    that causes audio to drop out. For these models the
                    audio standard must be set explicitly.
@@ -249,6 +270,14 @@ static void input_change(struct i2c_client *client)
                         cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
                 }
                 cx25840_write(client, 0x80b, 0x00);
+        } else if (std & V4L2_STD_PAL) {
+                /* Follow tuner change procedure for PAL */
+                cx25840_write(client, 0x808, 0xff);
+                cx25840_write(client, 0x80b, 0x10);
+        } else if (std & V4L2_STD_SECAM) {
+                /* Select autodetect for SECAM */
+                cx25840_write(client, 0x808, 0xff);
+                cx25840_write(client, 0x80b, 0x10);
         }
 
         if (cx25840_read(client, 0x803) & 0x10) {
@@ -319,8 +348,10 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
 
         state->vid_input = vid_input;
         state->aud_input = aud_input;
-        cx25840_audio_set_path(client);
-        input_change(client);
+        if (!state->is_cx25836) {
+                cx25840_audio_set_path(client);
+                input_change(client);
+        }
         return 0;
 }
 
@@ -354,6 +385,8 @@ static int set_v4lstd(struct i2c_client *client, v4l2_std_id std)
                 }
         }
 
+        v4l_dbg(1, cx25840_debug, client, "changing video std to fmt %i\n",fmt);
+
         /* Follow step 9 of section 3.16 in the cx25840 datasheet.
            Without this PAL may display a vertical ghosting effect.
            This happens for example with the Yuan MPC622. */
@@ -370,6 +403,7 @@ static int set_v4lstd(struct i2c_client *client, v4l2_std_id std)
 
 v4l2_std_id cx25840_get_v4lstd(struct i2c_client * client)
 {
+        struct cx25840_state *state = i2c_get_clientdata(client);
         /* check VID_FMT_SEL first */
         u8 fmt = cx25840_read(client, 0x400) & 0xf;
 
@@ -383,7 +417,7 @@ v4l2_std_id cx25840_get_v4lstd(struct i2c_client * client)
         {
                 /* if the audio std is A2-M, then this is the South Korean
                    NTSC standard */
-                if (cx25840_read(client, 0x805) == 2)
+                if (!state->is_cx25836 && cx25840_read(client, 0x805) == 2)
                         return V4L2_STD_NTSC_M_KR;
                 return V4L2_STD_NTSC_M;
         }
@@ -456,6 +490,8 @@ static int set_v4lctrl(struct i2c_client *client, struct v4l2_control *ctrl)
         case V4L2_CID_AUDIO_TREBLE:
         case V4L2_CID_AUDIO_BALANCE:
         case V4L2_CID_AUDIO_MUTE:
+                if (state->is_cx25836)
+                        return -EINVAL;
                 return cx25840_audio(client, VIDIOC_S_CTRL, ctrl);
 
         default:
@@ -490,6 +526,8 @@ static int get_v4lctrl(struct i2c_client *client, struct v4l2_control *ctrl)
         case V4L2_CID_AUDIO_TREBLE:
         case V4L2_CID_AUDIO_BALANCE:
         case V4L2_CID_AUDIO_MUTE:
+                if (state->is_cx25836)
+                        return -EINVAL;
                 return cx25840_audio(client, VIDIOC_G_CTRL, ctrl);
         default:
                 return -EINVAL;
@@ -579,91 +617,6 @@ static int set_v4lfmt(struct i2c_client *client, struct v4l2_format *fmt)
 
 /* ----------------------------------------------------------------------- */
 
-static struct v4l2_queryctrl cx25840_qctrl[] = {
-        {
-                .id            = V4L2_CID_BRIGHTNESS,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Brightness",
-                .minimum       = 0,
-                .maximum       = 255,
-                .step          = 1,
-                .default_value = 128,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_CONTRAST,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Contrast",
-                .minimum       = 0,
-                .maximum       = 127,
-                .step          = 1,
-                .default_value = 64,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_SATURATION,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Saturation",
-                .minimum       = 0,
-                .maximum       = 127,
-                .step          = 1,
-                .default_value = 64,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_HUE,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Hue",
-                .minimum       = -128,
-                .maximum       = 127,
-                .step          = 1,
-                .default_value = 0,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_AUDIO_VOLUME,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Volume",
-                .minimum       = 0,
-                .maximum       = 65535,
-                .step          = 65535/100,
-                .default_value = 58880,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_AUDIO_BALANCE,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Balance",
-                .minimum       = 0,
-                .maximum       = 65535,
-                .step          = 65535/100,
-                .default_value = 32768,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_AUDIO_MUTE,
-                .type          = V4L2_CTRL_TYPE_BOOLEAN,
-                .name          = "Mute",
-                .minimum       = 0,
-                .maximum       = 1,
-                .step          = 1,
-                .default_value = 1,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_AUDIO_BASS,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Bass",
-                .minimum       = 0,
-                .maximum       = 65535,
-                .step          = 65535/100,
-                .default_value = 32768,
-        }, {
-                .id            = V4L2_CID_AUDIO_TREBLE,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Treble",
-                .minimum       = 0,
-                .maximum       = 65535,
-                .step          = 65535/100,
-                .default_value = 32768,
-        },
-};
-
-/* ----------------------------------------------------------------------- */
-
 static int cx25840_command(struct i2c_client *client, unsigned int cmd,
                            void *arg)
 {
@@ -706,8 +659,8 @@ static int cx25840_command(struct i2c_client *client, unsigned int cmd,
 
         case VIDIOC_STREAMON:
                 v4l_dbg(1, cx25840_debug, client, "enable output\n");
-                cx25840_write(client, 0x115, 0x8c);
-                cx25840_write(client, 0x116, 0x07);
+                cx25840_write(client, 0x115, state->is_cx25836 ? 0x0c : 0x8c);
+                cx25840_write(client, 0x116, state->is_cx25836 ? 0x04 : 0x07);
                 break;
 
         case VIDIOC_STREAMOFF:
@@ -717,7 +670,9 @@ static int cx25840_command(struct i2c_client *client, unsigned int cmd,
                 break;
 
         case VIDIOC_LOG_STATUS:
-                log_status(client);
+                log_video_status(client);
+                if (!state->is_cx25836)
+                        log_audio_status(client);
                 break;
 
         case VIDIOC_G_CTRL:
@@ -729,13 +684,29 @@ static int cx25840_command(struct i2c_client *client, unsigned int cmd,
         case VIDIOC_QUERYCTRL:
         {
                 struct v4l2_queryctrl *qc = arg;
-                int i;
 
-                for (i = 0; i < ARRAY_SIZE(cx25840_qctrl); i++)
-                        if (qc->id && qc->id == cx25840_qctrl[i].id) {
-                                memcpy(qc, &cx25840_qctrl[i], sizeof(*qc));
-                                return 0;
-                        }
+                switch (qc->id) {
+                        case V4L2_CID_BRIGHTNESS:
+                        case V4L2_CID_CONTRAST:
+                        case V4L2_CID_SATURATION:
+                        case V4L2_CID_HUE:
+                                return v4l2_ctrl_query_fill_std(qc);
+                        default:
+                                break;
+                }
+                if (state->is_cx25836)
+                        return -EINVAL;
+
+                switch (qc->id) {
+                        case V4L2_CID_AUDIO_VOLUME:
+                        case V4L2_CID_AUDIO_MUTE:
+                        case V4L2_CID_AUDIO_BALANCE:
+                        case V4L2_CID_AUDIO_BASS:
+                        case V4L2_CID_AUDIO_TREBLE:
+                                return v4l2_ctrl_query_fill_std(qc);
+                        default:
+                                return -EINVAL;
+                }
                 return -EINVAL;
         }
 
@@ -760,31 +731,41 @@ static int cx25840_command(struct i2c_client *client, unsigned int cmd,
                 return set_input(client, route->input, state->aud_input);
 
         case VIDIOC_INT_G_AUDIO_ROUTING:
+                if (state->is_cx25836)
+                        return -EINVAL;
                 route->input = state->aud_input;
                 route->output = 0;
                 break;
 
         case VIDIOC_INT_S_AUDIO_ROUTING:
+                if (state->is_cx25836)
+                        return -EINVAL;
                 return set_input(client, state->vid_input, route->input);
 
         case VIDIOC_S_FREQUENCY:
-                input_change(client);
+                if (!state->is_cx25836) {
+                        input_change(client);
+                }
                 break;
 
         case VIDIOC_G_TUNER:
         {
-                u8 mode = cx25840_read(client, 0x804);
-                u8 vpres = cx25840_read(client, 0x80a) & 0x10;
+                u8 vpres = cx25840_read(client, 0x40e) & 0x20;
+                u8 mode;
                 int val = 0;
 
                 if (state->radio)
                         break;
 
+                vt->signal = vpres ? 0xffff : 0x0;
+                if (state->is_cx25836)
+                        break;
+
                 vt->capability |=
                     V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
                     V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
 
-                vt->signal = vpres ? 0xffff : 0x0;
+                mode = cx25840_read(client, 0x804);
 
                 /* get rxsubchans and audmode */
                 if ((mode & 0xf) == 1)
@@ -804,7 +785,7 @@ static int cx25840_command(struct i2c_client *client, unsigned int cmd,
         }
 
         case VIDIOC_S_TUNER:
-                if (state->radio)
+                if (state->radio || state->is_cx25836)
                         break;
 
                 switch (vt->audmode) {
@@ -846,12 +827,14 @@ static int cx25840_command(struct i2c_client *client, unsigned int cmd,
                 return set_v4lfmt(client, (struct v4l2_format *)arg);
 
         case VIDIOC_INT_RESET:
-                cx25840_initialize(client, 0);
+                if (state->is_cx25836)
+                        cx25836_initialize(client);
+                else
+                        cx25840_initialize(client, 0);
                 break;
 
         case VIDIOC_INT_G_CHIP_IDENT:
-                *(enum v4l2_chip_ident *)arg =
-                        V4L2_IDENT_CX25840 + ((cx25840_read(client, 0x100) >> 4) & 0xf);
+                *(enum v4l2_chip_ident *)arg = state->id;
                 break;
 
         default:
@@ -870,6 +853,7 @@ static int cx25840_detect_client(struct i2c_adapter *adapter, int address,
 {
         struct i2c_client *client;
         struct cx25840_state *state;
+        enum v4l2_chip_ident id;
         u16 device_id;
 
         /* Check if the adapter supports the needed features
@@ -878,10 +862,11 @@ static int cx25840_detect_client(struct i2c_adapter *adapter, int address,
         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
                 return 0;
 
-        client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
-        if (client == 0)
+        state = kzalloc(sizeof(struct cx25840_state), GFP_KERNEL);
+        if (state == 0)
                 return -ENOMEM;
 
+        client = &state->c;
         client->addr = address;
         client->adapter = adapter;
         client->driver = &i2c_driver_cx25840;
@@ -893,10 +878,18 @@ static int cx25840_detect_client(struct i2c_adapter *adapter, int address,
         device_id |= cx25840_read(client, 0x100);
 
         /* The high byte of the device ID should be
-         * 0x84 if chip is present */
-        if ((device_id & 0xff00) != 0x8400) {
+         * 0x83 for the cx2583x and 0x84 for the cx2584x */
+        if ((device_id & 0xff00) == 0x8300) {
+                id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
+                state->is_cx25836 = 1;
+        }
+        else if ((device_id & 0xff00) == 0x8400) {
+                id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
+                state->is_cx25836 = 0;
+        }
+        else {
                 v4l_dbg(1, cx25840_debug, client, "cx25840 not found\n");
-                kfree(client);
+                kfree(state);
                 return 0;
         }
 
@@ -905,21 +898,19 @@ static int cx25840_detect_client(struct i2c_adapter *adapter, int address,
                     (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1 : 3,
                     address << 1, adapter->name);
 
-        state = kmalloc(sizeof(struct cx25840_state), GFP_KERNEL);
-        if (state == NULL) {
-                kfree(client);
-                return -ENOMEM;
-        }
-
         i2c_set_clientdata(client, state);
-        memset(state, 0, sizeof(struct cx25840_state));
         state->vid_input = CX25840_COMPOSITE7;
         state->aud_input = CX25840_AUDIO8;
         state->audclk_freq = 48000;
         state->pvr150_workaround = 0;
         state->audmode = V4L2_TUNER_MODE_LANG1;
+        state->vbi_line_offset = 8;
+        state->id = id;
 
-        cx25840_initialize(client, 1);
+        if (state->is_cx25836)
+                cx25836_initialize(client);
+        else
+                cx25840_initialize(client, 1);
 
         i2c_attach_client(client);
 
@@ -944,7 +935,6 @@ static int cx25840_detach_client(struct i2c_client *client)
         }
 
         kfree(state);
-        kfree(client);
 
         return 0;
 }
@@ -977,7 +967,7 @@ module_exit(m__exit);
 
 /* ----------------------------------------------------------------------- */
 
-static void log_status(struct i2c_client *client)
+static void log_video_status(struct i2c_client *client)
 {
         static const char *const fmt_strs[] = {
                 "0x0",
@@ -989,9 +979,36 @@ static void log_status(struct i2c_client *client)
         };
 
         struct cx25840_state *state = i2c_get_clientdata(client);
-        u8 microctrl_vidfmt = cx25840_read(client, 0x80a);
         u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
         u8 gen_stat1 = cx25840_read(client, 0x40d);
+        u8 gen_stat2 = cx25840_read(client, 0x40e);
+        int vid_input = state->vid_input;
+
+        v4l_info(client, "Video signal:              %spresent\n",
+                    (gen_stat2 & 0x20) ? "" : "not ");
+        v4l_info(client, "Detected format:           %s\n",
+                    fmt_strs[gen_stat1 & 0xf]);
+
+        v4l_info(client, "Specified standard:        %s\n",
+                    vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
+
+        if (vid_input >= CX25840_COMPOSITE1 &&
+            vid_input <= CX25840_COMPOSITE8) {
+                v4l_info(client, "Specified video input:     Composite %d\n",
+                        vid_input - CX25840_COMPOSITE1 + 1);
+        } else {
+                v4l_info(client, "Specified video input:     S-Video (Luma In%d, Chroma In%d)\n",
+                        (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
+        }
+
+        v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
+}
+
+/* ----------------------------------------------------------------------- */
+
+static void log_audio_status(struct i2c_client *client)
+{
+        struct cx25840_state *state = i2c_get_clientdata(client);
         u8 download_ctl = cx25840_read(client, 0x803);
         u8 mod_det_stat0 = cx25840_read(client, 0x804);
         u8 mod_det_stat1 = cx25840_read(client, 0x805);
@@ -999,15 +1016,9 @@ static void log_status(struct i2c_client *client)
         u8 pref_mode = cx25840_read(client, 0x809);
         u8 afc0 = cx25840_read(client, 0x80b);
         u8 mute_ctl = cx25840_read(client, 0x8d3);
-        int vid_input = state->vid_input;
         int aud_input = state->aud_input;
         char *p;
 
-        v4l_info(client, "Video signal:              %spresent\n",
-                    (microctrl_vidfmt & 0x10) ? "" : "not ");
-        v4l_info(client, "Detected format:           %s\n",
-                    fmt_strs[gen_stat1 & 0xf]);
-
         switch (mod_det_stat0) {
         case 0x00: p = "mono"; break;
         case 0x01: p = "stereo"; break;
@@ -1107,25 +1118,12 @@ static void log_status(struct i2c_client *client)
                 v4l_info(client, "Configured audio system:   %s\n", p);
         }
 
-        v4l_info(client, "Specified standard:        %s\n",
-                    vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
-
-        if (vid_input >= CX25840_COMPOSITE1 &&
-            vid_input <= CX25840_COMPOSITE8) {
-                v4l_info(client, "Specified video input:     Composite %d\n",
-                        vid_input - CX25840_COMPOSITE1 + 1);
-        } else {
-                v4l_info(client, "Specified video input:     S-Video (Luma In%d, Chroma In%d)\n",
-                        (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
-        }
         if (aud_input) {
                 v4l_info(client, "Specified audio input:     Tuner (In%d)\n", aud_input);
         } else {
                 v4l_info(client, "Specified audio input:     External\n");
         }
 
-        v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
-
         switch (pref_mode & 0xf) {
         case 0: p = "mono/language A"; break;
         case 1: p = "language B"; break;
diff --git a/drivers/media/video/cx25840/cx25840-core.h b/drivers/media/video/cx25840/cx25840-core.h
index 1736929fc20..28049064dd7 100644
--- a/drivers/media/video/cx25840/cx25840-core.h
+++ b/drivers/media/video/cx25840/cx25840-core.h
@@ -24,6 +24,8 @@
 #include <linux/videodev2.h>
 #include <linux/i2c.h>
 
+extern int cx25840_debug;
+
 /* ENABLE_PVR150_WORKAROUND activates a workaround for a hardware bug that is
    present in Hauppauge PVR-150 (and possibly PVR-500) cards that have
    certain NTSC tuners (tveeprom tuner model numbers 85, 99 and 112). The
@@ -33,12 +35,16 @@
 #define CX25840_CID_ENABLE_PVR150_WORKAROUND (V4L2_CID_PRIVATE_BASE+0)
 
 struct cx25840_state {
+        struct i2c_client c;
         int pvr150_workaround;
         int radio;
         enum cx25840_video_input vid_input;
         enum cx25840_audio_input aud_input;
         u32 audclk_freq;
         int audmode;
+        int vbi_line_offset;
+        enum v4l2_chip_ident id;
+        int is_cx25836;
 };
 
 /* ----------------------------------------------------------------------- */
@@ -47,7 +53,7 @@ int cx25840_write(struct i2c_client *client, u16 addr, u8 value);
 int cx25840_write4(struct i2c_client *client, u16 addr, u32 value);
 u8 cx25840_read(struct i2c_client *client, u16 addr);
 u32 cx25840_read4(struct i2c_client *client, u16 addr);
-int cx25840_and_or(struct i2c_client *client, u16 addr, u8 mask, u8 value);
+int cx25840_and_or(struct i2c_client *client, u16 addr, unsigned mask, u8 value);
 v4l2_std_id cx25840_get_v4lstd(struct i2c_client *client);
 
 /* ----------------------------------------------------------------------- */
diff --git a/drivers/media/video/cx25840/cx25840-vbi.c b/drivers/media/video/cx25840/cx25840-vbi.c
index 57feca288d2..6cc8bf215e8 100644
--- a/drivers/media/video/cx25840/cx25840-vbi.c
+++ b/drivers/media/video/cx25840/cx25840-vbi.c
@@ -84,67 +84,140 @@ static int decode_vps(u8 * dst, u8 * p)
 
 void cx25840_vbi_setup(struct i2c_client *client)
 {
+        struct cx25840_state *state = i2c_get_clientdata(client);
         v4l2_std_id std = cx25840_get_v4lstd(client);
+        int hblank,hactive,burst,vblank,vactive,sc,vblank656,src_decimation;
+        int luma_lpf,uv_lpf, comb;
+        u32 pll_int,pll_frac,pll_post;
 
+        /* datasheet startup, step 8d */
         if (std & ~V4L2_STD_NTSC) {
-                /* datasheet startup, step 8d */
                 cx25840_write(client, 0x49f, 0x11);
+        } else {
+                cx25840_write(client, 0x49f, 0x14);
+        }
 
-                cx25840_write(client, 0x470, 0x84);
-                cx25840_write(client, 0x471, 0x00);
-                cx25840_write(client, 0x472, 0x2d);
-                cx25840_write(client, 0x473, 0x5d);
-
-                cx25840_write(client, 0x474, 0x24);
-                cx25840_write(client, 0x475, 0x40);
-                cx25840_write(client, 0x476, 0x24);
-                cx25840_write(client, 0x477, 0x28);
-
-                cx25840_write(client, 0x478, 0x1f);
-                cx25840_write(client, 0x479, 0x02);
+        if (std & V4L2_STD_625_50) {
+                hblank=0x084;
+                hactive=0x2d0;
+                burst=0x5d;
+                vblank=0x024;
+                vactive=0x244;
+                vblank656=0x28;
+                src_decimation=0x21f;
 
+                luma_lpf=2;
                 if (std & V4L2_STD_SECAM) {
-                        cx25840_write(client, 0x47a, 0x80);
-                        cx25840_write(client, 0x47b, 0x00);
-                        cx25840_write(client, 0x47c, 0x5f);
-                        cx25840_write(client, 0x47d, 0x42);
+                        uv_lpf=0;
+                        comb=0;
+                        sc=0x0a425f;
                 } else {
-                        cx25840_write(client, 0x47a, 0x90);
-                        cx25840_write(client, 0x47b, 0x20);
-                        cx25840_write(client, 0x47c, 0x63);
-                        cx25840_write(client, 0x47d, 0x82);
+                        uv_lpf=1;
+                        comb=0x20;
+                        sc=0x0a8263;
                 }
-
-                cx25840_write(client, 0x47e, 0x0a);
-                cx25840_write(client, 0x47f, 0x01);
         } else {
-                /* datasheet startup, step 8d */
-                cx25840_write(client, 0x49f, 0x14);
+                hactive=720;
+                hblank=122;
+                vactive=487;
+                luma_lpf=1;
+                uv_lpf=1;
+
+                src_decimation=0x21f;
+                if (std == V4L2_STD_PAL_M) {
+                        vblank=20;
+                        vblank656=24;
+                        burst=0x61;
+                        comb=0x20;
+
+                        sc=555452;
+                } else {
+                        vblank=26;
+                        vblank656=26;
+                        burst=0x5b;
+                        comb=0x66;
+                        sc=556063;
+                }
+        }
+
+        /* DEBUG: Displays configured PLL frequency */
+        pll_int=cx25840_read(client, 0x108);
+        pll_frac=cx25840_read4(client, 0x10c)&0x1ffffff;
+        pll_post=cx25840_read(client, 0x109);
+        v4l_dbg(1, cx25840_debug, client,
+                                "PLL regs = int: %u, frac: %u, post: %u\n",
+                                pll_int,pll_frac,pll_post);
+
+        if (pll_post) {
+                int fin, fsc;
+                int pll= (28636363L*((((u64)pll_int)<<25L)+pll_frac)) >>25L;
+
+                pll/=pll_post;
+                v4l_dbg(1, cx25840_debug, client, "PLL = %d.%06d MHz\n",
+                                                pll/1000000, pll%1000000);
+                v4l_dbg(1, cx25840_debug, client, "PLL/8 = %d.%06d MHz\n",
+                                                pll/8000000, (pll/8)%1000000);
+
+                fin=((u64)src_decimation*pll)>>12;
+                v4l_dbg(1, cx25840_debug, client, "ADC Sampling freq = "
+                                                "%d.%06d MHz\n",
+                                                fin/1000000,fin%1000000);
+
+                fsc= (((u64)sc)*pll) >> 24L;
+                v4l_dbg(1, cx25840_debug, client, "Chroma sub-carrier freq = "
+                                                "%d.%06d MHz\n",
+                                                fsc/1000000,fsc%1000000);
+
+                v4l_dbg(1, cx25840_debug, client, "hblank %i, hactive %i, "
+                        "vblank %i , vactive %i, vblank656 %i, src_dec %i,"
+                        "burst 0x%02x, luma_lpf %i, uv_lpf %i, comb 0x%02x,"
+                        " sc 0x%06x\n",
+                        hblank, hactive, vblank, vactive, vblank656,
+                        src_decimation, burst, luma_lpf, uv_lpf, comb, sc);
+        }
+
+        /* Sets horizontal blanking delay and active lines */
+        cx25840_write(client, 0x470, hblank);
+        cx25840_write(client, 0x471, 0xff&(((hblank>>8)&0x3)|(hactive <<4)));
+        cx25840_write(client, 0x472, hactive>>4);
+
+        /* Sets burst gate delay */
+        cx25840_write(client, 0x473, burst);
 
-                cx25840_write(client, 0x470, 0x7a);
-                cx25840_write(client, 0x471, 0x00);
-                cx25840_write(client, 0x472, 0x2d);
-                cx25840_write(client, 0x473, 0x5b);
+        /* Sets vertical blanking delay and active duration */
+        cx25840_write(client, 0x474, vblank);
+        cx25840_write(client, 0x475, 0xff&(((vblank>>8)&0x3)|(vactive <<4)));
+        cx25840_write(client, 0x476, vactive>>4);
+        cx25840_write(client, 0x477, vblank656);
 
-                cx25840_write(client, 0x474, 0x1a);
-                cx25840_write(client, 0x475, 0x70);
-                cx25840_write(client, 0x476, 0x1e);
-                cx25840_write(client, 0x477, 0x1e);
+        /* Sets src decimation rate */
+        cx25840_write(client, 0x478, 0xff&src_decimation);
+        cx25840_write(client, 0x479, 0xff&(src_decimation>>8));
 
-                cx25840_write(client, 0x478, 0x1f);
-                cx25840_write(client, 0x479, 0x02);
-                cx25840_write(client, 0x47a, 0x50);
-                cx25840_write(client, 0x47b, 0x66);
+        /* Sets Luma and UV Low pass filters */
+        cx25840_write(client, 0x47a, luma_lpf<<6|((uv_lpf<<4)&0x30));
 
-                cx25840_write(client, 0x47c, 0x1f);
-                cx25840_write(client, 0x47d, 0x7c);
-                cx25840_write(client, 0x47e, 0x08);
+        /* Enables comb filters */
+        cx25840_write(client, 0x47b, comb);
+
+        /* Sets SC Step*/
+        cx25840_write(client, 0x47c, sc);
+        cx25840_write(client, 0x47d, 0xff&sc>>8);
+        cx25840_write(client, 0x47e, 0xff&sc>>16);
+
+        /* Sets VBI parameters */
+        if (std & V4L2_STD_625_50) {
+                cx25840_write(client, 0x47f, 0x01);
+                state->vbi_line_offset = 5;
+        } else {
                 cx25840_write(client, 0x47f, 0x00);
+                state->vbi_line_offset = 8;
         }
 }
 
 int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg)
 {
+        struct cx25840_state *state = i2c_get_clientdata(client);
         struct v4l2_format *fmt;
         struct v4l2_sliced_vbi_format *svbi;
 
@@ -182,7 +255,7 @@ int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg)
 
         case VIDIOC_S_FMT:
         {
-                int is_pal = !(cx25840_get_v4lstd(client) & V4L2_STD_NTSC);
+                int is_pal = !(cx25840_get_v4lstd(client) & V4L2_STD_525_60);
                 int vbi_offset = is_pal ? 1 : 0;
                 int i, x;
                 u8 lcr[24];
@@ -211,7 +284,7 @@ int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg)
                 cx25840_vbi_setup(client);
 
                 /* Sliced VBI */
-                cx25840_write(client, 0x404, 0x36);     /* Ancillery data */
+                cx25840_write(client, 0x404, 0x32);     /* Ancillary data */
                 cx25840_write(client, 0x406, 0x13);
                 cx25840_write(client, 0x47f, vbi_offset);
 
@@ -248,8 +321,18 @@ int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg)
                         }
                 }
 
-                for (x = 1, i = 0x424; i <= 0x434; i++, x++) {
-                        cx25840_write(client, i, lcr[6 + x]);
+                if (is_pal) {
+                        for (x = 1, i = 0x424; i <= 0x434; i++, x++) {
+                                cx25840_write(client, i, lcr[6 + x]);
+                        }
+                }
+                else {
+                        for (x = 1, i = 0x424; i <= 0x430; i++, x++) {
+                                cx25840_write(client, i, lcr[9 + x]);
+                        }
+                        for (i = 0x431; i <= 0x434; i++) {
+                                cx25840_write(client, i, 0);
+                        }
                 }
 
                 cx25840_write(client, 0x43c, 0x16);
@@ -257,7 +340,7 @@ int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg)
                 if (is_pal) {
                         cx25840_write(client, 0x474, 0x2a);
                 } else {
-                        cx25840_write(client, 0x474, 0x1a + 6);
+                        cx25840_write(client, 0x474, 0x22);
                 }
                 break;
         }
@@ -278,7 +361,7 @@ int cx25840_vbi(struct i2c_client *client, unsigned int cmd, void *arg)
                 id1 = p[-1];
                 id2 = p[0] & 0xf;
                 l = p[2] & 0x3f;
-                l += 5;
+                l += state->vbi_line_offset;
                 p += 4;
 
                 switch (id2) {
diff --git a/drivers/media/video/cx88/Kconfig b/drivers/media/video/cx88/Kconfig
index 630273992a4..91e1c481a16 100644
--- a/drivers/media/video/cx88/Kconfig
+++ b/drivers/media/video/cx88/Kconfig
@@ -11,6 +11,7 @@ config VIDEO_CX88
         select VIDEO_BUF
         select VIDEO_TUNER
         select VIDEO_TVEEPROM
+        select VIDEO_CX2341X
         select VIDEO_IR
         ---help---
           This is a video4linux driver for Conexant 2388x based
@@ -61,6 +62,7 @@ config VIDEO_CX88_DVB_ALL_FRONTENDS
         select DVB_LGDT330X
         select DVB_NXT200X
         select DVB_CX24123
+        select DVB_ISL6421
         ---help---
           This builds cx88-dvb with all currently supported frontend
           demodulators.  If you wish to tweak your configuration, and
@@ -139,6 +141,7 @@ config VIDEO_CX88_DVB_CX24123
         default y
         depends on VIDEO_CX88_DVB && !VIDEO_CX88_DVB_ALL_FRONTENDS
         select DVB_CX24123
+        select DVB_ISL6421
         ---help---
           This adds DVB-S support for cards based on the
           Connexant 2388x chip and the CX24123 demodulator.
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c
index 320b3d9384b..2194cbeca33 100644
--- a/drivers/media/video/cx88/cx88-alsa.c
+++ b/drivers/media/video/cx88/cx88-alsa.c
@@ -4,7 +4,7 @@
  *  PCI function #1 of the cx2388x.
  *
  *    (c) 2005,2006 Ricardo Cerqueira <v4l@cerqueira.org>
- *    (c) 2005 Mauro Carvalho Chehab <mchehab@brturbo.com.br>
+ *    (c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org>
  *    Based on a dummy cx88 module by Gerd Knorr <kraxel@bytesex.org>
  *    Based on dummy.c by Jaroslav Kysela <perex@suse.cz>
  *
@@ -111,7 +111,7 @@ MODULE_PARM_DESC(index, "Index value for cx88x capture interface(s).");
 
 MODULE_DESCRIPTION("ALSA driver module for cx2388x based TV cards");
 MODULE_AUTHOR("Ricardo Cerqueira");
-MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@brturbo.com.br>");
+MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("{{Conexant,23881},"
                         "{{Conexant,23882},"
@@ -696,7 +696,6 @@ static int __devinit snd_cx88_create(struct snd_card *card,
         chip->irq = -1;
         spin_lock_init(&chip->reg_lock);
 
-        cx88_reset(core);
         chip->core = core;
 
         /* get irq */
diff --git a/drivers/media/video/cx88/cx88-blackbird.c b/drivers/media/video/cx88/cx88-blackbird.c
index e100d8ef369..67fd3302e8f 100644
--- a/drivers/media/video/cx88/cx88-blackbird.c
+++ b/drivers/media/video/cx88/cx88-blackbird.c
@@ -30,9 +30,10 @@
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/firmware.h>
+#include <media/v4l2-common.h>
+#include <media/cx2341x.h>
 
 #include "cx88.h"
-#include <media/v4l2-common.h>
 
 MODULE_DESCRIPTION("driver for cx2388x/cx23416 based mpeg encoder cards");
 MODULE_AUTHOR("Jelle Foks <jelle@foks.8m.com>, Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
@@ -53,7 +54,6 @@ static LIST_HEAD(cx8802_devlist);
 
 /* ------------------------------------------------------------------ */
 
-#define BLACKBIRD_FIRM_ENC_FILENAME "blackbird-fw-enc.bin"
 #define BLACKBIRD_FIRM_IMAGE_SIZE 256*1024
 
 /* defines below are from ivtv-driver.h */
@@ -63,8 +63,6 @@ static LIST_HEAD(cx8802_devlist);
 /* Firmware API commands */
 #define IVTV_API_STD_TIMEOUT 500
 
-#define BLACKBIRD_API_PING               0x80
-#define BLACKBIRD_API_BEGIN_CAPTURE      0x81
 enum blackbird_capture_type {
         BLACKBIRD_MPEG_CAPTURE,
         BLACKBIRD_RAW_CAPTURE,
@@ -78,205 +76,29 @@ enum blackbird_capture_bits {
         BLACKBIRD_RAW_BITS_PASSTHRU_CAPTURE = 0x08,
         BLACKBIRD_RAW_BITS_TO_HOST_CAPTURE  = 0x10
 };
-#define BLACKBIRD_API_END_CAPTURE        0x82
 enum blackbird_capture_end {
         BLACKBIRD_END_AT_GOP, /* stop at the end of gop, generate irq */
         BLACKBIRD_END_NOW, /* stop immediately, no irq */
 };
-#define BLACKBIRD_API_SET_AUDIO_ID       0x89
-#define BLACKBIRD_API_SET_VIDEO_ID       0x8B
-#define BLACKBIRD_API_SET_PCR_ID         0x8D
-#define BLACKBIRD_API_SET_FRAMERATE      0x8F
 enum blackbird_framerate {
         BLACKBIRD_FRAMERATE_NTSC_30, /* NTSC: 30fps */
         BLACKBIRD_FRAMERATE_PAL_25   /* PAL: 25fps */
 };
-#define BLACKBIRD_API_SET_RESOLUTION     0x91
-#define BLACKBIRD_API_SET_VIDEO_BITRATE  0x95
-enum blackbird_video_bitrate_type {
-        BLACKBIRD_VIDEO_VBR,
-        BLACKBIRD_VIDEO_CBR
-};
-#define BLACKBIRD_PEAK_RATE_DIVISOR 400
-enum blackbird_mux_rate {
-        BLACKBIRD_MUX_RATE_DEFAULT,
-         /* dvd mux rate: multiply by 400 to get the actual rate */
-        BLACKBIRD_MUX_RATE_DVD = 25200
-};
-#define BLACKBIRD_API_SET_GOP_STRUCTURE  0x97
-#define BLACKBIRD_API_SET_ASPECT_RATIO   0x99
-enum blackbird_aspect_ratio {
-        BLACKBIRD_ASPECT_RATIO_FORBIDDEN,
-        BLACKBIRD_ASPECT_RATIO_1_1_SQUARE,
-        BLACKBIRD_ASPECT_RATIO_4_3,
-        BLACKBIRD_ASPECT_RATIO_16_9,
-        BLACKBIRD_ASPECT_RATIO_221_100,
-        BLACKBIRD_ASPECT_RATIO_RESERVED
-};
-#define BLACKBIRD_API_SET_DNR_MODE       0x9B
-enum blackbird_dnr_bits {
-        BLACKBIRD_DNR_BITS_MANUAL,
-        BLACKBIRD_DNR_BITS_AUTO_SPATIAL,
-        BLACKBIRD_DNR_BITS_AUTO_TEMPORAL,
-        BLACKBIRD_DNR_BITS_AUTO
-};
-enum blackbird_median_filter {
-        BLACKBIRD_MEDIAN_FILTER_DISABLED,
-        BLACKBIRD_MEDIAN_FILTER_HORIZONTAL,
-        BLACKBIRD_MEDIAN_FILTER_VERTICAL,
-        BLACKBIRD_MEDIAN_FILTER_HV,
-        BLACKBIRD_MEDIAN_FILTER_DIAGONAL
-};
-#define BLACKBIRD_API_SET_MANUAL_DNR     0x9D
-#define BLACKBIRD_API_SET_DNR_MEDIAN     0x9F
-#define BLACKBIRD_API_SET_SPATIAL_FILTER 0xA1
-enum blackbird_spatial_filter_luma {
-        BLACKBIRD_SPATIAL_FILTER_LUMA_DISABLED,
-        BLACKBIRD_SPATIAL_FILTER_LUMA_1D_HORIZ,
-        BLACKBIRD_SPATIAL_FILTER_LUMA_1D_VERT,
-        BLACKBIRD_SPATIAL_FILTER_LUMA_2D_HV, /* separable, default */
-        BLACKBIRD_SPATIAL_FILTER_LUMA_2D_SYMM /* symmetric non-separable */
-};
-enum blackbird_spatial_filter_chroma {
-        BLACKBIRD_SPATIAL_FILTER_CHROMA_DISABLED,
-        BLACKBIRD_SPATIAL_FILTER_CHROMA_1D_HORIZ /* default */
-};
-#define BLACKBIRD_API_SET_3_2_PULLDOWN   0xB1
-enum blackbird_pulldown {
-        BLACKBIRD_3_2_PULLDOWN_DISABLED,
-        BLACKBIRD_3_2_PULLDOWN_ENABLED
-};
-#define BLACKBIRD_API_SET_VBI_LINE_NO    0xB7
-enum blackbird_vbi_line_bits {
-        BLACKBIRD_VBI_LINE_BITS_TOP_FIELD,
-        BLACKBIRD_VBI_LINE_BITS_BOT_FIELD = (1 << 31),
-        BLACKBIRD_VBI_LINE_BITS_ALL_LINES = 0xFFFFFFFF
-};
-enum blackbird_vbi_line {
-        BLACKBIRD_VBI_LINE_DISABLED,
-        BLACKBIRD_VBI_LINE_ENABLED
-};
-enum blackbird_vbi_slicing {
-        BLACKBIRD_VBI_SLICING_NONE,
-        BLACKBIRD_VBI_SLICING_CLOSED_CAPTION
-};
-#define BLACKBIRD_API_SET_STREAM_TYPE    0xB9
-enum blackbird_stream_type {
-        BLACKBIRD_STREAM_PROGRAM,
-        BLACKBIRD_STREAM_TRANSPORT,
-        BLACKBIRD_STREAM_MPEG1,
-        BLACKBIRD_STREAM_PES_AV,
-        BLACKBIRD_STREAM_UNKNOWN4,
-        BLACKBIRD_STREAM_PES_VIDEO,
-        BLACKBIRD_STREAM_UNKNOWN6,
-        BLACKBIRD_STREAM_PES_AUDIO,
-        BLACKBIRD_STREAM_UNKNOWN8,
-        BLACKBIRD_STREAM_UNKNOWN9, /* audio/pcm ? */
-        BLACKBIRD_STREAM_DVD,
-        BLACKBIRD_STREAM_VCD,
-        BLACKBIRD_STREAM_UNKNOWN12 /* svcd/xvcd ? */
-};
-#define BLACKBIRD_API_SET_OUTPUT_PORT    0xBB
 enum blackbird_stream_port {
         BLACKBIRD_OUTPUT_PORT_MEMORY,
         BLACKBIRD_OUTPUT_PORT_STREAMING,
         BLACKBIRD_OUTPUT_PORT_SERIAL
 };
-#define BLACKBIRD_API_SET_AUDIO_PARAMS   0xBD
-enum blackbird_audio_bits_sample_rate {
-        BLACKBIRD_AUDIO_BITS_44100HZ,
-        BLACKBIRD_AUDIO_BITS_48000HZ,
-        BLACKBIRD_AUDIO_BITS_32000HZ,
-        BLACKBIRD_AUDIO_BITS_RESERVED_HZ,
-};
-enum blackbird_audio_bits_encoding {
-        BLACKBIRD_AUDIO_BITS_LAYER_1 = 0x1 << 2,
-        BLACKBIRD_AUDIO_BITS_LAYER_2 = 0x2 << 2,
-};
-enum blackbird_audio_bits_bitrate_layer_1 {
-        BLACKBIRD_AUDIO_BITS_LAYER_1_FREE_FORMAT,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_32  = 0x01 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_64  = 0x02 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_96  = 0x03 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_128 = 0x04 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_160 = 0x05 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_192 = 0x06 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_224 = 0x07 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_256 = 0x08 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_288 = 0x09 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_320 = 0x0A << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_352 = 0x0B << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_384 = 0x0C << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_416 = 0x0D << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_1_448 = 0x0E << 4,
-};
-enum blackbird_audio_bits_bitrate_layer_2 {
-        BLACKBIRD_AUDIO_BITS_LAYER_2_FREE_FORMAT,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_32  = 0x01 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_48  = 0x02 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_56  = 0x03 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_64  = 0x04 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_80  = 0x05 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_96  = 0x06 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_112 = 0x07 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_128 = 0x08 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_160 = 0x09 << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_192 = 0x0A << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_224 = 0x0B << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_256 = 0x0C << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_320 = 0x0D << 4,
-        BLACKBIRD_AUDIO_BITS_LAYER_2_384 = 0x0E << 4,
-};
-enum blackbird_audio_bits_mode {
-        BLACKBIRD_AUDIO_BITS_STEREO,
-        BLACKBIRD_AUDIO_BITS_JOINT_STEREO = 0x1 << 8,
-        BLACKBIRD_AUDIO_BITS_DUAL         = 0x2 << 8,
-        BLACKBIRD_AUDIO_BITS_MONO         = 0x3 << 8,
-};
-enum blackbird_audio_bits_mode_extension {
-        BLACKBIRD_AUDIO_BITS_BOUND_4,
-        BLACKBIRD_AUDIO_BITS_BOUND_8  = 0x1 << 10,
-        BLACKBIRD_AUDIO_BITS_BOUND_12 = 0x2 << 10,
-        BLACKBIRD_AUDIO_BITS_BOUND_16 = 0x3 << 10,
-};
-enum blackbird_audio_bits_emphasis {
-        BLACKBIRD_AUDIO_BITS_EMPHASIS_NONE,
-        BLACKBIRD_AUDIO_BITS_EMPHASIS_50_15     = 0x1 << 12,
-        BLACKBIRD_AUDIO_BITS_EMPHASIS_RESERVED  = 0x2 << 12,
-        BLACKBIRD_AUDIO_BITS_EMPHASIS_CCITT_J17 = 0x3 << 12,
-};
-enum blackbird_audio_bits_crc {
-        BLACKBIRD_AUDIO_BITS_CRC_OFF,
-        BLACKBIRD_AUDIO_BITS_CRC_ON = 0x1 << 14,
-};
-enum blackbird_audio_bits_copyright {
-        BLACKBIRD_AUDIO_BITS_COPYRIGHT_OFF,
-        BLACKBIRD_AUDIO_BITS_COPYRIGHT_ON = 0x1 << 15,
-};
-enum blackbird_audio_bits_original {
-        BLACKBIRD_AUDIO_BITS_COPY,
-        BLACKBIRD_AUDIO_BITS_ORIGINAL = 0x1 << 16,
-};
-#define BLACKBIRD_API_HALT               0xC3
-#define BLACKBIRD_API_GET_VERSION        0xC4
-#define BLACKBIRD_API_SET_GOP_CLOSURE    0xC5
-enum blackbird_gop_closure {
-        BLACKBIRD_GOP_CLOSURE_OFF,
-        BLACKBIRD_GOP_CLOSURE_ON,
-};
-#define BLACKBIRD_API_DATA_XFER_STATUS   0xC6
 enum blackbird_data_xfer_status {
         BLACKBIRD_MORE_BUFFERS_FOLLOW,
         BLACKBIRD_LAST_BUFFER,
 };
-#define BLACKBIRD_API_PROGRAM_INDEX_INFO 0xC7
 enum blackbird_picture_mask {
         BLACKBIRD_PICTURE_MASK_NONE,
         BLACKBIRD_PICTURE_MASK_I_FRAMES,
         BLACKBIRD_PICTURE_MASK_I_P_FRAMES = 0x3,
         BLACKBIRD_PICTURE_MASK_ALL_FRAMES = 0x7,
 };
-#define BLACKBIRD_API_SET_VBI_PARAMS     0xC8
 enum blackbird_vbi_mode_bits {
         BLACKBIRD_VBI_BITS_SLICED,
         BLACKBIRD_VBI_BITS_RAW,
@@ -288,33 +110,23 @@ enum blackbird_vbi_insertion_bits {
         BLACKBIRD_VBI_BITS_SEPARATE_STREAM_USR_DATA = 0x4 << 1,
         BLACKBIRD_VBI_BITS_SEPARATE_STREAM_PRV_DATA = 0x5 << 1,
 };
-#define BLACKBIRD_API_SET_DMA_BLOCK_SIZE 0xC9
 enum blackbird_dma_unit {
         BLACKBIRD_DMA_BYTES,
         BLACKBIRD_DMA_FRAMES,
 };
-#define BLACKBIRD_API_DMA_TRANSFER_INFO  0xCA
-#define BLACKBIRD_API_DMA_TRANSFER_STAT  0xCB
 enum blackbird_dma_transfer_status_bits {
         BLACKBIRD_DMA_TRANSFER_BITS_DONE = 0x01,
         BLACKBIRD_DMA_TRANSFER_BITS_ERROR = 0x04,
         BLACKBIRD_DMA_TRANSFER_BITS_LL_ERROR = 0x10,
 };
-#define BLACKBIRD_API_SET_DMA2HOST_ADDR  0xCC
-#define BLACKBIRD_API_INIT_VIDEO_INPUT   0xCD
-#define BLACKBIRD_API_SET_FRAMESKIP      0xD0
-#define BLACKBIRD_API_PAUSE              0xD2
 enum blackbird_pause {
         BLACKBIRD_PAUSE_ENCODING,
         BLACKBIRD_RESUME_ENCODING,
 };
-#define BLACKBIRD_API_REFRESH_INPUT      0xD3
-#define BLACKBIRD_API_SET_COPYRIGHT      0xD4
 enum blackbird_copyright {
         BLACKBIRD_COPYRIGHT_OFF,
         BLACKBIRD_COPYRIGHT_ON,
 };
-#define BLACKBIRD_API_SET_NOTIFICATION   0xD5
 enum blackbird_notification_type {
         BLACKBIRD_NOTIFICATION_REFRESH,
 };
@@ -325,7 +137,6 @@ enum blackbird_notification_status {
 enum blackbird_notification_mailbox {
         BLACKBIRD_NOTIFICATION_NO_MAILBOX = -1,
 };
-#define BLACKBIRD_API_SET_CAPTURE_LINES  0xD6
 enum blackbird_field1_lines {
         BLACKBIRD_FIELD1_SAA7114 = 0x00EF, /* 239 */
         BLACKBIRD_FIELD1_SAA7115 = 0x00F0, /* 240 */
@@ -336,12 +147,10 @@ enum blackbird_field2_lines {
         BLACKBIRD_FIELD2_SAA7115 = 0x00F0, /* 240 */
         BLACKBIRD_FIELD2_MICRONAS = 0x0106, /* 262 */
 };
-#define BLACKBIRD_API_SET_CUSTOM_DATA    0xD7
 enum blackbird_custom_data_type {
         BLACKBIRD_CUSTOM_EXTENSION_USR_DATA,
         BLACKBIRD_CUSTOM_PRIVATE_PACKET,
 };
-#define BLACKBIRD_API_MUTE_VIDEO         0xD9
 enum blackbird_mute {
         BLACKBIRD_UNMUTE,
         BLACKBIRD_MUTE,
@@ -356,7 +165,6 @@ enum blackbird_mute_video_shift {
         BLACKBIRD_MUTE_VIDEO_U_SHIFT = 16,
         BLACKBIRD_MUTE_VIDEO_Y_SHIFT = 24,
 };
-#define BLACKBIRD_API_MUTE_AUDIO         0xDA
 
 /* Registers */
 #define IVTV_REG_ENC_SDRAM_REFRESH (0x07F8 /*| IVTV_REG_OFFSET*/)
@@ -498,15 +306,12 @@ static int register_read(struct cx88_core *core, u32 address, u32 *value)
 
 /* ------------------------------------------------------------------ */
 
-/* We don't need to call the API often, so using just one mailbox will probably suffice */
-static int blackbird_api_cmd(struct cx8802_dev *dev, u32 command,
-                             u32 inputcnt, u32 outputcnt, ...)
+static int blackbird_mbox_func(void *priv, int command, int in, int out, u32 data[CX2341X_MBOX_MAX_DATA])
 {
+        struct cx8802_dev *dev = priv;
         unsigned long timeout;
         u32 value, flag, retval;
         int i;
-        va_list args;
-        va_start(args, outputcnt);
 
         dprintk(1,"%s: 0x%X\n", __FUNCTION__, command);
 
@@ -530,12 +335,11 @@ static int blackbird_api_cmd(struct cx8802_dev *dev, u32 command,
         /* write command + args + fill remaining with zeros */
         memory_write(dev->core, dev->mailbox + 1, command); /* command code */
         memory_write(dev->core, dev->mailbox + 3, IVTV_API_STD_TIMEOUT); /* timeout */
-        for (i = 0; i < inputcnt ; i++) {
-                value = va_arg(args, int);
-                memory_write(dev->core, dev->mailbox + 4 + i, value);
-                dprintk(1, "API Input %d = %d\n", i, value);
+        for (i = 0; i < in; i++) {
+                memory_write(dev->core, dev->mailbox + 4 + i, data[i]);
+                dprintk(1, "API Input %d = %d\n", i, data[i]);
         }
-        for (; i < 16 ; i++)
+        for (; i < CX2341X_MBOX_MAX_DATA; i++)
                 memory_write(dev->core, dev->mailbox + 4 + i, 0);
 
         flag |= 3; /* tell 'em we're done writing */
@@ -555,12 +359,10 @@ static int blackbird_api_cmd(struct cx8802_dev *dev, u32 command,
         }
 
         /* read output values */
-        for (i = 0; i < outputcnt ; i++) {
-                int *vptr = va_arg(args, int *);
-                memory_read(dev->core, dev->mailbox + 4 + i, vptr);
-                dprintk(1, "API Output %d = %d\n", i, *vptr);
+        for (i = 0; i < out; i++) {
+                memory_read(dev->core, dev->mailbox + 4 + i, data + i);
+                dprintk(1, "API Output %d = %d\n", i, data[i]);
         }
-        va_end(args);
 
         memory_read(dev->core, dev->mailbox + 2, &retval);
         dprintk(1, "API result = %d\n",retval);
@@ -569,7 +371,29 @@ static int blackbird_api_cmd(struct cx8802_dev *dev, u32 command,
         memory_write(dev->core, dev->mailbox, flag);
         return retval;
 }
+/* ------------------------------------------------------------------ */
 
+/* We don't need to call the API often, so using just one mailbox will probably suffice */
+static int blackbird_api_cmd(struct cx8802_dev *dev, u32 command,
+                             u32 inputcnt, u32 outputcnt, ...)
+{
+        u32 data[CX2341X_MBOX_MAX_DATA];
+        va_list vargs;
+        int i, err;
+
+        va_start(vargs, outputcnt);
+
+        for (i = 0; i < inputcnt; i++) {
+                data[i] = va_arg(vargs, int);
+        }
+        err = blackbird_mbox_func(dev, command, inputcnt, outputcnt, data);
+        for (i = 0; i < outputcnt; i++) {
+                int *vptr = va_arg(vargs, int *);
+                *vptr = data[i];
+        }
+        va_end(vargs);
+        return err;
+}
 
 static int blackbird_find_mailbox(struct cx8802_dev *dev)
 {
@@ -614,13 +438,13 @@ static int blackbird_load_firmware(struct cx8802_dev *dev)
         if (retval < 0)
                 dprintk(0, "Error with register_write\n");
 
-        retval = request_firmware(&firmware, BLACKBIRD_FIRM_ENC_FILENAME,
+        retval = request_firmware(&firmware, CX2341X_FIRM_ENC_FILENAME,
                                   &dev->pci->dev);
 
 
         if (retval != 0) {
                 dprintk(0, "ERROR: Hotplug firmware request failed (%s).\n",
-                        BLACKBIRD_FIRM_ENC_FILENAME);
+                        CX2341X_FIRM_ENC_FILENAME);
                 dprintk(0, "Please fix your hotplug setup, the board will "
                         "not work without firmware loaded!\n");
                 return -1;
@@ -686,12 +510,19 @@ DB* DVD | MPEG2 | 720x576PAL | CBR     | 600 :Good    | 6000 Kbps  | 25fps   | M
 *DB: "DirectBurn"
 */
 
-static struct blackbird_dnr default_dnr_params = {
-        .mode     = BLACKBIRD_DNR_BITS_MANUAL,
-        .type     = BLACKBIRD_MEDIAN_FILTER_DISABLED,
-        .spatial  = 0,
-        .temporal = 0
-};
+static void blackbird_codec_settings(struct cx8802_dev *dev)
+{
+        /* assign frame size */
+        blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
+                                dev->height, dev->width);
+
+        dev->params.width = dev->width;
+        dev->params.height = dev->height;
+        dev->params.is_50hz = (dev->core->tvnorm->id & V4L2_STD_625_50) != 0;
+
+        cx2341x_update(dev, blackbird_mbox_func, NULL, &dev->params);
+}
+
 static struct v4l2_mpeg_compression default_mpeg_params = {
         .st_type          = V4L2_MPEG_PS_2,
         .st_bitrate       = {
@@ -712,7 +543,7 @@ static struct v4l2_mpeg_compression default_mpeg_params = {
                 .target   = 224,
                 .max      = 224
         },
-        .au_sample_rate    = 44100,
+        .au_sample_rate    = 48000,
         .au_pesid          = 0,
         .vi_type           = V4L2_MPEG_VI_2,
         .vi_aspect_ratio   = V4L2_MPEG_ASPECT_4_3,
@@ -723,524 +554,13 @@ static struct v4l2_mpeg_compression default_mpeg_params = {
                 .max       = 6000
         },
         .vi_frame_rate     = 25,
-        .vi_frames_per_gop = 15,
+        .vi_frames_per_gop = 12,
         .vi_bframes_count  = 2,
         .vi_pesid          = 0,
-        .closed_gops       = 0,
+        .closed_gops       = 1,
         .pulldown          = 0
 };
 
-static enum blackbird_stream_type mpeg_stream_types[] = {
-        [V4L2_MPEG_SS_1]   = BLACKBIRD_STREAM_MPEG1,
-        [V4L2_MPEG_PS_2]   = BLACKBIRD_STREAM_PROGRAM,
-        [V4L2_MPEG_TS_2]   = BLACKBIRD_STREAM_TRANSPORT,
-        [V4L2_MPEG_PS_DVD] = BLACKBIRD_STREAM_DVD,
-};
-static enum blackbird_aspect_ratio mpeg_stream_ratios[] = {
-        [V4L2_MPEG_ASPECT_SQUARE] = BLACKBIRD_ASPECT_RATIO_1_1_SQUARE,
-        [V4L2_MPEG_ASPECT_4_3]    = BLACKBIRD_ASPECT_RATIO_4_3,
-        [V4L2_MPEG_ASPECT_16_9]   = BLACKBIRD_ASPECT_RATIO_16_9,
-        [V4L2_MPEG_ASPECT_1_221]  = BLACKBIRD_ASPECT_RATIO_221_100,
-};
-static enum blackbird_video_bitrate_type mpeg_video_bitrates[] = {
-        [V4L2_BITRATE_NONE] = BLACKBIRD_VIDEO_CBR,
-        [V4L2_BITRATE_CBR]  = BLACKBIRD_VIDEO_CBR,
-        [V4L2_BITRATE_VBR]  = BLACKBIRD_VIDEO_VBR,
-};
-/* find the best layer I/II bitrate to fit a given numeric value */
-struct bitrate_bits {
-        u32 bits; /* layer bits for the best fit */
-        u32 rate; /* actual numeric value for the layer best fit */
-};
-struct bitrate_approximation {
-        u32                 target;   /* numeric value of the rate we want */
-        struct bitrate_bits layer[2];
-};
-static struct bitrate_approximation mpeg_audio_bitrates[] = {
-        /* target  layer[0].bits           layer[0].rate       layer[1].bits           layer[1].rate */
-        {   0, { {                                0,   0, }, {                                0,   0, }, }, },
-        {  32, { { BLACKBIRD_AUDIO_BITS_LAYER_1_32 ,  32, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_32 ,  32, }, }, },
-        {  48, { { BLACKBIRD_AUDIO_BITS_LAYER_1_64 ,  64, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_48 ,  48, }, }, },
-        {  56, { { BLACKBIRD_AUDIO_BITS_LAYER_1_64 ,  64, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_56 ,  56, }, }, },
-        {  64, { { BLACKBIRD_AUDIO_BITS_LAYER_1_64 ,  64, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_64 ,  64, }, }, },
-        {  80, { { BLACKBIRD_AUDIO_BITS_LAYER_1_96 ,  96, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_80 ,  80, }, }, },
-        {  96, { { BLACKBIRD_AUDIO_BITS_LAYER_1_96 ,  96, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_96 ,  96, }, }, },
-        { 112, { { BLACKBIRD_AUDIO_BITS_LAYER_1_128, 128, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_112, 112, }, }, },
-        { 128, { { BLACKBIRD_AUDIO_BITS_LAYER_1_128, 128, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_128, 128, }, }, },
-        { 160, { { BLACKBIRD_AUDIO_BITS_LAYER_1_160, 160, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_160, 160, }, }, },
-        { 192, { { BLACKBIRD_AUDIO_BITS_LAYER_1_192, 192, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_192, 192, }, }, },
-        { 224, { { BLACKBIRD_AUDIO_BITS_LAYER_1_224, 224, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_224, 224, }, }, },
-        { 256, { { BLACKBIRD_AUDIO_BITS_LAYER_1_256, 256, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_256, 256, }, }, },
-        { 288, { { BLACKBIRD_AUDIO_BITS_LAYER_1_288, 288, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_320, 320, }, }, },
-        { 320, { { BLACKBIRD_AUDIO_BITS_LAYER_1_320, 320, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_320, 320, }, }, },
-        { 352, { { BLACKBIRD_AUDIO_BITS_LAYER_1_352, 352, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_384, 384, }, }, },
-        { 384, { { BLACKBIRD_AUDIO_BITS_LAYER_1_384, 384, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_384, 384, }, }, },
-        { 416, { { BLACKBIRD_AUDIO_BITS_LAYER_1_416, 416, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_384, 384, }, }, },
-        { 448, { { BLACKBIRD_AUDIO_BITS_LAYER_1_448, 448, }, { BLACKBIRD_AUDIO_BITS_LAYER_2_384, 384, }, }, },
-};
-static const int BITRATES_SIZE = ARRAY_SIZE(mpeg_audio_bitrates);
-
-static void blackbird_set_default_params(struct cx8802_dev *dev)
-{
-        struct v4l2_mpeg_compression *params = &dev->params;
-        u32 au_params;
-
-        /* assign stream type */
-        if( params->st_type >= ARRAY_SIZE(mpeg_stream_types) )
-                params->st_type = V4L2_MPEG_PS_2;
-        if( params->st_type == V4L2_MPEG_SS_1 )
-                params->vi_type = V4L2_MPEG_VI_1;
-        else
-                params->vi_type = V4L2_MPEG_VI_2;
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_STREAM_TYPE, 1, 0, mpeg_stream_types[params->st_type]);
-
-        /* assign framerate */
-        if( params->vi_frame_rate <= 25 )
-        {
-                params->vi_frame_rate = 25;
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_PAL_25);
-        }
-        else
-        {
-                params->vi_frame_rate = 30;
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_NTSC_30);
-        }
-
-        /* assign aspect ratio */
-        if( params->vi_aspect_ratio >= ARRAY_SIZE(mpeg_stream_ratios) )
-                params->vi_aspect_ratio = V4L2_MPEG_ASPECT_4_3;
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_ASPECT_RATIO, 1, 0, mpeg_stream_ratios[params->vi_aspect_ratio]);
-
-        /* assign gop properties */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_STRUCTURE, 2, 0, params->vi_frames_per_gop, params->vi_bframes_count+1);
-
-        /* assign gop closure */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_CLOSURE, 1, 0, params->closed_gops);
-
-        /* assign 3 2 pulldown */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_3_2_PULLDOWN, 1, 0, params->pulldown);
-
-        /* make sure the params are within bounds */
-        if( params->st_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
-                params->vi_bitrate.mode = V4L2_BITRATE_NONE;
-        if( params->vi_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
-                params->vi_bitrate.mode = V4L2_BITRATE_NONE;
-        if( params->au_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
-                params->au_bitrate.mode = V4L2_BITRATE_NONE;
-
-        /* assign audio properties */
-        /* note: it's not necessary to set the samplerate, the mpeg encoder seems to autodetect/adjust */
-        au_params = BLACKBIRD_AUDIO_BITS_STEREO |
-                        /* BLACKBIRD_AUDIO_BITS_BOUND_4 | */
-                        BLACKBIRD_AUDIO_BITS_EMPHASIS_NONE |
-                        BLACKBIRD_AUDIO_BITS_CRC_OFF |
-                        BLACKBIRD_AUDIO_BITS_COPYRIGHT_OFF |
-                        BLACKBIRD_AUDIO_BITS_COPY |
-                        0;
-        if( params->au_sample_rate <= 32000 )
-        {
-                params->au_sample_rate = 32000;
-                au_params |= BLACKBIRD_AUDIO_BITS_32000HZ;
-        }
-        else if( params->au_sample_rate <= 44100 )
-        {
-                params->au_sample_rate = 44100;
-                au_params |= BLACKBIRD_AUDIO_BITS_44100HZ;
-        }
-        else
-        {
-                params->au_sample_rate = 48000;
-                au_params |= BLACKBIRD_AUDIO_BITS_48000HZ;
-        }
-        if( params->au_type == V4L2_MPEG_AU_2_I )
-        {
-                au_params |= BLACKBIRD_AUDIO_BITS_LAYER_1;
-        }
-        else
-        {
-                /* TODO: try to handle the other formats more gracefully */
-                params->au_type = V4L2_MPEG_AU_2_II;
-                au_params |= BLACKBIRD_AUDIO_BITS_LAYER_2;
-        }
-        if( params->au_bitrate.mode )
-        {
-                int layer;
-
-                if( params->au_bitrate.mode == V4L2_BITRATE_CBR )
-                        params->au_bitrate.max = params->vi_bitrate.target;
-                else
-                        params->au_bitrate.target = params->vi_bitrate.max;
-
-                layer = params->au_type;
-                if( params->au_bitrate.target == 0 )
-                {
-                        /* TODO: use the minimum possible bitrate instead of 0 ? */
-                        au_params |= 0;
-                }
-                else if( params->au_bitrate.target >=
-                         mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].rate )
-                {
-                        /* clamp the bitrate to the max supported by the standard */
-                        params->au_bitrate.target = mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].rate;
-                        params->au_bitrate.max = params->au_bitrate.target;
-                        au_params |= mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].bits;
-                }
-                else
-                {
-                        /* round up to the nearest supported bitrate */
-                        int i;
-                        for(i = 1; i < BITRATES_SIZE; i++)
-                        {
-                                if( params->au_bitrate.target > mpeg_audio_bitrates[i-1].layer[layer].rate &&
-                                    params->au_bitrate.target <= mpeg_audio_bitrates[i].layer[layer].rate )
-                                {
-                                        params->au_bitrate.target = mpeg_audio_bitrates[i].layer[layer].rate;
-                                        params->au_bitrate.max = params->au_bitrate.target;
-                                        au_params |= mpeg_audio_bitrates[i].layer[layer].bits;
-                                        break;
-                                }
-                        }
-                }
-        }
-        else
-        {
-                /* TODO: ??? */
-                params->au_bitrate.target = params->au_bitrate.max = 0;
-                au_params |= 0;
-        }
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_AUDIO_PARAMS, 1, 0, au_params );
-
-        /* assign bitrates */
-        if( params->vi_bitrate.mode )
-        {
-                /* bitrate is set, let's figure out the cbr/vbr mess */
-                if( params->vi_bitrate.max < params->vi_bitrate.target )
-                {
-                        if( params->vi_bitrate.mode == V4L2_BITRATE_CBR )
-                                params->vi_bitrate.max = params->vi_bitrate.target;
-                        else
-                                params->vi_bitrate.target = params->vi_bitrate.max;
-                }
-        }
-        else
-        {
-                if( params->st_bitrate.max < params->st_bitrate.target )
-                {
-                        if( params->st_bitrate.mode == V4L2_BITRATE_VBR )
-                                params->st_bitrate.target = params->st_bitrate.max;
-                        else
-                                params->st_bitrate.max = params->st_bitrate.target;
-                }
-                /* calculate vi_bitrate = st_bitrate - au_bitrate */
-                params->vi_bitrate.max = params->st_bitrate.max - params->au_bitrate.max;
-                params->vi_bitrate.target = params->st_bitrate.target - params->au_bitrate.target;
-        }
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_VIDEO_BITRATE, 4, 0,
-                                mpeg_video_bitrates[params->vi_bitrate.mode],
-                                params->vi_bitrate.target * 1000, /* kbps -> bps */
-                                params->vi_bitrate.max * 1000 / BLACKBIRD_PEAK_RATE_DIVISOR, /* peak/400 */
-                                BLACKBIRD_MUX_RATE_DEFAULT /*, 0x70*/); /* encoding buffer, ckennedy */
-
-        /* TODO: implement the stream ID stuff:
-                ts_pid_pmt, ts_pid_audio, ts_pid_video, ts_pid_pcr,
-                ps_size, au_pesid, vi_pesid
-        */
-}
-#define CHECK_PARAM( name ) ( dev->params.name != params->name )
-#define IF_PARAM( name ) if( CHECK_PARAM( name ) )
-#define UPDATE_PARAM( name ) dev->params.name = params->name
-void blackbird_set_params(struct cx8802_dev *dev, struct v4l2_mpeg_compression *params)
-{
-        u32 au_params;
-
-        /* assign stream type */
-        if( params->st_type >= ARRAY_SIZE(mpeg_stream_types) )
-                params->st_type = V4L2_MPEG_PS_2;
-        if( params->st_type == V4L2_MPEG_SS_1 )
-                params->vi_type = V4L2_MPEG_VI_1;
-        else
-                params->vi_type = V4L2_MPEG_VI_2;
-        if( CHECK_PARAM( st_type ) || CHECK_PARAM( vi_type ) )
-        {
-                UPDATE_PARAM( st_type );
-                UPDATE_PARAM( vi_type );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_STREAM_TYPE, 1, 0, mpeg_stream_types[params->st_type]);
-        }
-
-        /* assign framerate */
-        if( params->vi_frame_rate <= 25 )
-                params->vi_frame_rate = 25;
-        else
-                params->vi_frame_rate = 30;
-        IF_PARAM( vi_frame_rate )
-        {
-                UPDATE_PARAM( vi_frame_rate );
-                if( params->vi_frame_rate == 25 )
-                        blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_PAL_25);
-                else
-                        blackbird_api_cmd(dev, BLACKBIRD_API_SET_FRAMERATE, 1, 0, BLACKBIRD_FRAMERATE_NTSC_30);
-        }
-
-        /* assign aspect ratio */
-        if( params->vi_aspect_ratio >= ARRAY_SIZE(mpeg_stream_ratios) )
-                params->vi_aspect_ratio = V4L2_MPEG_ASPECT_4_3;
-        IF_PARAM( vi_aspect_ratio )
-        {
-                UPDATE_PARAM( vi_aspect_ratio );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_ASPECT_RATIO, 1, 0, mpeg_stream_ratios[params->vi_aspect_ratio]);
-        }
-
-        /* assign gop properties */
-        if( CHECK_PARAM( vi_frames_per_gop ) || CHECK_PARAM( vi_bframes_count ) )
-        {
-                UPDATE_PARAM( vi_frames_per_gop );
-                UPDATE_PARAM( vi_bframes_count );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_STRUCTURE, 2, 0, params->vi_frames_per_gop, params->vi_bframes_count+1);
-        }
-
-        /* assign gop closure */
-        IF_PARAM( closed_gops )
-        {
-                UPDATE_PARAM( closed_gops );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_GOP_CLOSURE, 1, 0, params->closed_gops);
-        }
-
-        /* assign 3 2 pulldown */
-        IF_PARAM( pulldown )
-        {
-                UPDATE_PARAM( pulldown );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_3_2_PULLDOWN, 1, 0, params->pulldown);
-        }
-
-        /* make sure the params are within bounds */
-        if( params->st_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
-                params->vi_bitrate.mode = V4L2_BITRATE_NONE;
-        if( params->vi_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
-                params->vi_bitrate.mode = V4L2_BITRATE_NONE;
-        if( params->au_bitrate.mode >= ARRAY_SIZE(mpeg_video_bitrates) )
-                params->au_bitrate.mode = V4L2_BITRATE_NONE;
-
-        /* assign audio properties */
-        /* note: it's not necessary to set the samplerate, the mpeg encoder seems to autodetect/adjust */
-        au_params = BLACKBIRD_AUDIO_BITS_STEREO |
-                        /* BLACKBIRD_AUDIO_BITS_BOUND_4 | */
-        BLACKBIRD_AUDIO_BITS_EMPHASIS_NONE |
-                BLACKBIRD_AUDIO_BITS_CRC_OFF |
-                BLACKBIRD_AUDIO_BITS_COPYRIGHT_OFF |
-                BLACKBIRD_AUDIO_BITS_COPY |
-                0;
-        if( params->au_sample_rate < 32000 )
-        {
-                params->au_sample_rate = 32000;
-                au_params |= BLACKBIRD_AUDIO_BITS_32000HZ;
-        }
-        else if( params->au_sample_rate < 44100 )
-        {
-                params->au_sample_rate = 44100;
-                au_params |= BLACKBIRD_AUDIO_BITS_44100HZ;
-        }
-        else
-        {
-                params->au_sample_rate = 48000;
-                au_params |= BLACKBIRD_AUDIO_BITS_48000HZ;
-        }
-        if( params->au_type == V4L2_MPEG_AU_2_I )
-        {
-                au_params |= BLACKBIRD_AUDIO_BITS_LAYER_1;
-        }
-        else
-        {
-                /* TODO: try to handle the other formats more gracefully */
-                params->au_type = V4L2_MPEG_AU_2_II;
-                au_params |= BLACKBIRD_AUDIO_BITS_LAYER_2;
-        }
-        if( params->au_bitrate.mode )
-        {
-                int layer;
-
-                if( params->au_bitrate.mode == V4L2_BITRATE_CBR )
-                        params->au_bitrate.max = params->vi_bitrate.target;
-                else
-                        params->au_bitrate.target = params->vi_bitrate.max;
-
-                layer = params->au_type;
-                if( params->au_bitrate.target == 0 )
-                {
-                        /* TODO: use the minimum possible bitrate instead of 0 ? */
-                        au_params |= 0;
-                }
-                else if( params->au_bitrate.target >=
-                         mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].rate )
-                {
-                        /* clamp the bitrate to the max supported by the standard */
-                        params->au_bitrate.target = mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].rate;
-                        params->au_bitrate.max = params->au_bitrate.target;
-                        au_params |= mpeg_audio_bitrates[BITRATES_SIZE-1].layer[layer].bits;
-                }
-                else
-                {
-                        /* round up to the nearest supported bitrate */
-                        int i;
-                        for(i = 1; i < BITRATES_SIZE; i++)
-                        {
-                                if( params->au_bitrate.target > mpeg_audio_bitrates[i-1].layer[layer].rate &&
-                                    params->au_bitrate.target <= mpeg_audio_bitrates[i].layer[layer].rate )
-                                {
-                                        params->au_bitrate.target = mpeg_audio_bitrates[i].layer[layer].rate;
-                                        params->au_bitrate.max = params->au_bitrate.target;
-                                        au_params |= mpeg_audio_bitrates[i].layer[layer].bits;
-                                        break;
-                                }
-                        }
-                }
-        }
-        else
-        {
-                /* TODO: ??? */
-                params->au_bitrate.target = params->au_bitrate.max = 0;
-                au_params |= 0;
-        }
-        if( CHECK_PARAM( au_type ) || CHECK_PARAM( au_sample_rate )
-                || CHECK_PARAM( au_bitrate.mode ) || CHECK_PARAM( au_bitrate.max )
-                || CHECK_PARAM( au_bitrate.target )
-        )
-        {
-                UPDATE_PARAM( au_type );
-                UPDATE_PARAM( au_sample_rate );
-                UPDATE_PARAM( au_bitrate );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_AUDIO_PARAMS, 1, 0, au_params );
-        }
-
-        /* assign bitrates */
-        if( params->vi_bitrate.mode )
-        {
-                /* bitrate is set, let's figure out the cbr/vbr mess */
-                if( params->vi_bitrate.max < params->vi_bitrate.target )
-                {
-                        if( params->vi_bitrate.mode == V4L2_BITRATE_CBR )
-                                params->vi_bitrate.max = params->vi_bitrate.target;
-                        else
-                                params->vi_bitrate.target = params->vi_bitrate.max;
-                }
-        }
-        else
-        {
-                if( params->st_bitrate.max < params->st_bitrate.target )
-                {
-                        if( params->st_bitrate.mode == V4L2_BITRATE_VBR )
-                                params->st_bitrate.target = params->st_bitrate.max;
-                        else
-                                params->st_bitrate.max = params->st_bitrate.target;
-                }
-                /* calculate vi_bitrate = st_bitrate - au_bitrate */
-                params->vi_bitrate.max = params->st_bitrate.max - params->au_bitrate.max;
-                params->vi_bitrate.target = params->st_bitrate.target - params->au_bitrate.target;
-        }
-        UPDATE_PARAM( st_bitrate );
-        if( CHECK_PARAM( vi_bitrate.mode ) || CHECK_PARAM( vi_bitrate.max )
-                || CHECK_PARAM( vi_bitrate.target )
-        )
-        {
-                UPDATE_PARAM( vi_bitrate );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_VIDEO_BITRATE, 4, 0,
-                                mpeg_video_bitrates[params->vi_bitrate.mode],
-                                params->vi_bitrate.target * 1000, /* kbps -> bps */
-                                params->vi_bitrate.max * 1000 / BLACKBIRD_PEAK_RATE_DIVISOR, /* peak/400 */
-                                BLACKBIRD_MUX_RATE_DEFAULT /*, 0x70*/); /* encoding buffer, ckennedy */
-        }
-
-        /* TODO: implement the stream ID stuff:
-                ts_pid_pmt, ts_pid_audio, ts_pid_video, ts_pid_pcr,
-                ps_size, au_pesid, vi_pesid
-        */
-        UPDATE_PARAM( ts_pid_pmt );
-        UPDATE_PARAM( ts_pid_audio );
-        UPDATE_PARAM( ts_pid_video );
-        UPDATE_PARAM( ts_pid_pcr );
-        UPDATE_PARAM( ps_size );
-        UPDATE_PARAM( au_pesid );
-        UPDATE_PARAM( vi_pesid );
-}
-
-static void blackbird_set_default_dnr_params(struct cx8802_dev *dev)
-{
-        /* assign dnr filter mode */
-        if( dev->dnr_params.mode > BLACKBIRD_DNR_BITS_AUTO )
-                dev->dnr_params.mode = BLACKBIRD_DNR_BITS_MANUAL;
-        if( dev->dnr_params.type > BLACKBIRD_MEDIAN_FILTER_DIAGONAL )
-                dev->dnr_params.type = BLACKBIRD_MEDIAN_FILTER_DISABLED;
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_DNR_MODE, 2, 0,
-                                dev->dnr_params.mode,
-                                dev->dnr_params.type
-                        );
-
-        /* assign dnr filter props*/
-        if( dev->dnr_params.spatial > 15 )
-                dev->dnr_params.spatial = 15;
-        if( dev->dnr_params.temporal > 31 )
-                dev->dnr_params.temporal = 31;
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_MANUAL_DNR, 2, 0,
-                                dev->dnr_params.spatial,
-                                dev->dnr_params.temporal
-                        );
-}
-#define CHECK_DNR_PARAM( name ) ( dev->dnr_params.name != dnr_params->name )
-#define UPDATE_DNR_PARAM( name ) dev->dnr_params.name = dnr_params->name
-void blackbird_set_dnr_params(struct cx8802_dev *dev, struct blackbird_dnr* dnr_params)
-{
-        /* assign dnr filter mode */
-        /* clamp values */
-        if( dnr_params->mode > BLACKBIRD_DNR_BITS_AUTO )
-                dnr_params->mode = BLACKBIRD_DNR_BITS_MANUAL;
-        if( dnr_params->type > BLACKBIRD_MEDIAN_FILTER_DIAGONAL )
-                dnr_params->type = BLACKBIRD_MEDIAN_FILTER_DISABLED;
-        /* check if the params actually changed */
-        if( CHECK_DNR_PARAM( mode ) || CHECK_DNR_PARAM( type ) )
-        {
-                UPDATE_DNR_PARAM( mode );
-                UPDATE_DNR_PARAM( type );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_DNR_MODE, 2, 0, dnr_params->mode, dnr_params->type);
-        }
-
-        /* assign dnr filter props*/
-        if( dnr_params->spatial > 15 )
-                dnr_params->spatial = 15;
-        if( dnr_params->temporal > 31 )
-                dnr_params->temporal = 31;
-        if( CHECK_DNR_PARAM( spatial ) || CHECK_DNR_PARAM( temporal ) )
-        {
-                UPDATE_DNR_PARAM( spatial );
-                UPDATE_DNR_PARAM( temporal );
-                blackbird_api_cmd(dev, BLACKBIRD_API_SET_MANUAL_DNR, 2, 0, dnr_params->spatial, dnr_params->temporal);
-        }
-}
-
-static void blackbird_codec_settings(struct cx8802_dev *dev)
-{
-
-        /* assign output port */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_OUTPUT_PORT, 1, 0, BLACKBIRD_OUTPUT_PORT_STREAMING); /* Host */
-
-        /* assign frame size */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_RESOLUTION, 2, 0,
-                                dev->height, dev->width);
-
-        /* assign coring levels (luma_h, luma_l, chroma_h, chroma_l) */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_DNR_MEDIAN, 4, 0, 0, 255, 0, 255);
-
-        /* assign spatial filter type: luma_t: horiz_only, chroma_t: horiz_only */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_SPATIAL_FILTER, 2, 0,
-                                BLACKBIRD_SPATIAL_FILTER_LUMA_1D_HORIZ,
-                                BLACKBIRD_SPATIAL_FILTER_CHROMA_1D_HORIZ
-                        );
-
-        /* assign frame drop rate */
-        /* blackbird_api_cmd(dev, IVTV_API_ASSIGN_FRAME_DROP_RATE, 1, 0, 0); */
-
-        blackbird_set_default_params(dev);
-        blackbird_set_default_dnr_params(dev);
-}
-
 static int blackbird_initialize_codec(struct cx8802_dev *dev)
 {
         struct cx88_core *core = dev->core;
@@ -1248,7 +568,7 @@ static int blackbird_initialize_codec(struct cx8802_dev *dev)
         int retval;
 
         dprintk(1,"Initialize codec\n");
-        retval = blackbird_api_cmd(dev, BLACKBIRD_API_PING, 0, 0); /* ping */
+        retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
         if (retval < 0) {
                 /* ping was not successful, reset and upload firmware */
                 cx_write(MO_SRST_IO, 0); /* SYS_RSTO=0 */
@@ -1263,13 +583,13 @@ static int blackbird_initialize_codec(struct cx8802_dev *dev)
                 if (dev->mailbox < 0)
                         return -1;
 
-                retval = blackbird_api_cmd(dev, BLACKBIRD_API_PING, 0, 0); /* ping */
+                retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
                 if (retval < 0) {
                         dprintk(0, "ERROR: Firmware ping failed!\n");
                         return -1;
                 }
 
-                retval = blackbird_api_cmd(dev, BLACKBIRD_API_GET_VERSION, 0, 1, &version);
+                retval = blackbird_api_cmd(dev, CX2341X_ENC_GET_VERSION, 0, 1, &version);
                 if (retval < 0) {
                         dprintk(0, "ERROR: Firmware get encoder version failed!\n");
                         return -1;
@@ -1289,35 +609,35 @@ static int blackbird_initialize_codec(struct cx8802_dev *dev)
         /* blackbird_api_cmd(dev, IVTV_API_ASSIGN_NUM_VSYNC_LINES, 4, 0, 0xef, 0xef);
            blackbird_api_cmd(dev, IVTV_API_ASSIGN_NUM_VSYNC_LINES, 4, 0, 0xf0, 0xf0);
            blackbird_api_cmd(dev, IVTV_API_ASSIGN_NUM_VSYNC_LINES, 4, 0, 0x180, 0x180); */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_CAPTURE_LINES, 2, 0,
+        blackbird_api_cmd(dev, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, 0,
                         BLACKBIRD_FIELD1_SAA7115,
-                        BLACKBIRD_FIELD1_SAA7115
+                        BLACKBIRD_FIELD2_SAA7115
                 );
 
         /* blackbird_api_cmd(dev, IVTV_API_ASSIGN_PLACEHOLDER, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); */
-        blackbird_api_cmd(dev, BLACKBIRD_API_SET_CUSTOM_DATA, 12, 0,
+        blackbird_api_cmd(dev, CX2341X_ENC_SET_PLACEHOLDER, 12, 0,
                         BLACKBIRD_CUSTOM_EXTENSION_USR_DATA,
                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 
         /* initialize the video input */
-        blackbird_api_cmd(dev, BLACKBIRD_API_INIT_VIDEO_INPUT, 0, 0);
+        blackbird_api_cmd(dev, CX2341X_ENC_INITIALIZE_INPUT, 0, 0);
 
         msleep(1);
 
-        blackbird_api_cmd(dev, BLACKBIRD_API_MUTE_VIDEO, 1, 0, BLACKBIRD_UNMUTE);
+        blackbird_api_cmd(dev, CX2341X_ENC_MUTE_VIDEO, 1, 0, BLACKBIRD_UNMUTE);
         msleep(1);
-        blackbird_api_cmd(dev, BLACKBIRD_API_MUTE_AUDIO, 1, 0, BLACKBIRD_UNMUTE);
+        blackbird_api_cmd(dev, CX2341X_ENC_MUTE_AUDIO, 1, 0, BLACKBIRD_UNMUTE);
         msleep(1);
 
         /* start capturing to the host interface */
-        /* blackbird_api_cmd(dev, BLACKBIRD_API_BEGIN_CAPTURE, 2, 0, 0, 0x13); */
-        blackbird_api_cmd(dev, BLACKBIRD_API_BEGIN_CAPTURE, 2, 0,
+        /* blackbird_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0, 0, 0x13); */
+        blackbird_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0,
                         BLACKBIRD_MPEG_CAPTURE,
                         BLACKBIRD_RAW_BITS_NONE
                 );
         msleep(10);
 
-        blackbird_api_cmd(dev, BLACKBIRD_API_REFRESH_INPUT, 0,0);
+        blackbird_api_cmd(dev, CX2341X_ENC_REFRESH_INPUT, 0,0);
         return 0;
 }
 
@@ -1485,14 +805,52 @@ static int mpeg_do_ioctl(struct inode *inode, struct file *file,
         {
                 struct v4l2_mpeg_compression *f = arg;
 
-                memcpy(f,&dev->params,sizeof(*f));
+                printk(KERN_WARNING "VIDIOC_G_MPEGCOMP is obsolete. "
+                                    "Replace with VIDIOC_G_EXT_CTRLS!");
+                memcpy(f,&default_mpeg_params,sizeof(*f));
                 return 0;
         }
         case VIDIOC_S_MPEGCOMP:
+                printk(KERN_WARNING "VIDIOC_S_MPEGCOMP is obsolete. "
+                                    "Replace with VIDIOC_S_EXT_CTRLS!");
+                return 0;
+        case VIDIOC_G_EXT_CTRLS:
         {
-                struct v4l2_mpeg_compression *f = arg;
+                struct v4l2_ext_controls *f = arg;
 
-                blackbird_set_params(dev, f);
+                if (f->ctrl_class != V4L2_CTRL_CLASS_MPEG)
+                        return -EINVAL;
+                return cx2341x_ext_ctrls(&dev->params, f, cmd);
+        }
+        case VIDIOC_S_EXT_CTRLS:
+        case VIDIOC_TRY_EXT_CTRLS:
+        {
+                struct v4l2_ext_controls *f = arg;
+                struct cx2341x_mpeg_params p;
+                int err;
+
+                if (f->ctrl_class != V4L2_CTRL_CLASS_MPEG)
+                        return -EINVAL;
+                p = dev->params;
+                err = cx2341x_ext_ctrls(&p, f, cmd);
+                if (err == 0 && cmd == VIDIOC_S_EXT_CTRLS) {
+                        err = cx2341x_update(dev, blackbird_mbox_func, &dev->params, &p);
+                        dev->params = p;
+                }
+                return err;
+        }
+        case VIDIOC_S_FREQUENCY:
+        {
+                blackbird_api_cmd(fh->dev, CX2341X_ENC_STOP_CAPTURE, 3, 0,
+                                  BLACKBIRD_END_NOW,
+                                  BLACKBIRD_MPEG_CAPTURE,
+                                  BLACKBIRD_RAW_BITS_NONE);
+
+                cx88_do_ioctl( inode, file, 0, dev->core, cmd, arg, cx88_ioctl_hook );
+
+                blackbird_initialize_codec(dev);
+                cx88_set_scale(dev->core, dev->width, dev->height,
+                               fh->mpegq.field);
                 return 0;
         }
 
@@ -1562,13 +920,14 @@ static int mpeg_release(struct inode *inode, struct file *file)
 {
         struct cx8802_fh  *fh  = file->private_data;
 
-        /* blackbird_api_cmd(fh->dev, BLACKBIRD_API_END_CAPTURE, 3, 0, BLACKBIRD_END_NOW, 0, 0x13); */
-        blackbird_api_cmd(fh->dev, BLACKBIRD_API_END_CAPTURE, 3, 0,
+        /* blackbird_api_cmd(fh->dev, CX2341X_ENC_STOP_CAPTURE, 3, 0, BLACKBIRD_END_NOW, 0, 0x13); */
+        blackbird_api_cmd(fh->dev, CX2341X_ENC_STOP_CAPTURE, 3, 0,
                         BLACKBIRD_END_NOW,
                         BLACKBIRD_MPEG_CAPTURE,
                         BLACKBIRD_RAW_BITS_NONE
                 );
 
+        cx8802_cancel_buffers(fh->dev);
         /* stop mpeg capture */
         if (fh->mpegq.streaming)
                 videobuf_streamoff(&fh->mpegq);
@@ -1683,19 +1042,13 @@ static int __devinit blackbird_probe(struct pci_dev *pci_dev,
         dev->core = core;
         dev->width = 720;
         dev->height = 576;
-        memcpy(&dev->params,&default_mpeg_params,sizeof(default_mpeg_params));
-        memcpy(&dev->dnr_params,&default_dnr_params,sizeof(default_dnr_params));
-
-        if (core->board == CX88_BOARD_HAUPPAUGE_ROSLYN) {
-
-                if (core->tuner_formats & V4L2_STD_525_60) {
-                        dev->height = 480;
-                        dev->params.vi_frame_rate = 30;
-                } else {
-                        dev->height = 576;
-                        dev->params.vi_frame_rate = 25;
-                }
+        cx2341x_fill_defaults(&dev->params);
+        dev->params.port = CX2341X_PORT_STREAMING;
 
+        if (core->tvnorm->id & V4L2_STD_525_60) {
+                dev->height = 480;
+        } else {
+                dev->height = 576;
         }
 
         err = cx8802_init_common(dev);
@@ -1781,8 +1134,6 @@ module_exit(blackbird_fini);
 
 EXPORT_SYMBOL(cx88_ioctl_hook);
 EXPORT_SYMBOL(cx88_ioctl_translator);
-EXPORT_SYMBOL(blackbird_set_params);
-EXPORT_SYMBOL(blackbird_set_dnr_params);
 
 /* ----------------------------------------------------------- */
 /*
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index f80154b87d2..67cdd827086 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -114,7 +114,7 @@ struct cx88_board cx88_boards[] = {
                 .radio = {
                          .type  = CX88_RADIO,
                          .gpio0 = 0xff10,
-                 },
+                },
         },
         [CX88_BOARD_ATI_WONDER_PRO] = {
                 .name           = "ATI TV Wonder Pro",
@@ -267,7 +267,7 @@ struct cx88_board cx88_boards[] = {
                         .gpio1  = 0x00007004,
                         .gpio2  = 0x0035d700,
                         .gpio3  = 0x02000000,
-                 },
+                },
         },
         [CX88_BOARD_LEADTEK_PVR2000] = {
                 // gpio values for PAL version from regspy by DScaler
@@ -413,7 +413,7 @@ struct cx88_board cx88_boards[] = {
                         .type   = CX88_VMUX_COMPOSITE1,
                         .vmux   = 1,
                         .gpio0  = 0x000027df,
-                 },{
+                },{
                         .type   = CX88_VMUX_SVIDEO,
                         .vmux   = 2,
                         .gpio0  = 0x000027df,
@@ -536,7 +536,7 @@ struct cx88_board cx88_boards[] = {
                         .type   = CX88_VMUX_COMPOSITE1,
                         .vmux   = 1,
                         .gpio0  = 0x000027df,
-                 },{
+                },{
                         .type   = CX88_VMUX_SVIDEO,
                         .vmux   = 2,
                         .gpio0  = 0x000027df,
@@ -759,7 +759,7 @@ struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD] = {
                 .name           = "DViCO FusionHDTV 5 Gold",
-                .tuner_type     = TUNER_LG_TDVS_H062F,
+                .tuner_type     = TUNER_LG_TDVS_H06XF, /* TDVS-H062F */
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -1050,11 +1050,7 @@ struct cx88_board cx88_boards[] = {
                 .dvb            = 1,
         },
         [CX88_BOARD_KWORLD_HARDWARE_MPEG_TV_XPERT] = {
-                /* FIXME: Standard video using the cx88 broadcast decoder is
-                 * working, but blackbird isn't working yet, audio is only
-                 * working correctly for television mode. S-Video and Composite
-                 * are working for video-only, so I have them disabled for now.
-                 */
+                /* FIXME: Audio not working for s-video / composite inputs. */
                 .name           = "KWorld HardwareMpegTV XPert",
                 .tuner_type     = TUNER_PHILIPS_TDA8290,
                 .radio_type     = UNSET,
@@ -1065,12 +1061,21 @@ struct cx88_board cx88_boards[] = {
                         .vmux   = 0,
                         .gpio0  = 0x3de2,
                         .gpio2  = 0x00ff,
+                },{
+                        .type   = CX88_VMUX_COMPOSITE1,
+                        .vmux   = 1,
+                        .gpio0  = 0x3de6,
+                },{
+                        .type   = CX88_VMUX_SVIDEO,
+                        .vmux   = 2,
+                        .gpio0  = 0x3de6,
                 }},
                 .radio = {
                         .type   = CX88_RADIO,
                         .gpio0  = 0x3de6,
                         .gpio2  = 0x00ff,
                 },
+                .blackbird      = 1,
         },
         [CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_HYBRID] = {
                 .name           = "DViCO FusionHDTV DVB-T Hybrid",
@@ -1093,7 +1098,102 @@ struct cx88_board cx88_boards[] = {
                 }},
                 .dvb            = 1,
         },
-
+        [CX88_BOARD_PCHDTV_HD5500] = {
+                .name           = "pcHDTV HD5500 HDTV",
+                .tuner_type     = TUNER_LG_TDVS_H06XF, /* TDVS-H064F */
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .tda9887_conf   = TDA9887_PRESENT,
+                .input          = {{
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x87fd,
+                },{
+                        .type   = CX88_VMUX_COMPOSITE1,
+                        .vmux   = 1,
+                        .gpio0  = 0x87f9,
+                },{
+                        .type   = CX88_VMUX_SVIDEO,
+                        .vmux   = 2,
+                        .gpio0  = 0x87f9,
+                }},
+                .dvb            = 1,
+        },
+        [CX88_BOARD_KWORLD_MCE200_DELUXE] = {
+                /* FIXME: tested TV input only, disabled composite,
+                   svideo and radio until they can be tested also. */
+                .name           = "Kworld MCE 200 Deluxe",
+                .tuner_type     = TUNER_TENA_9533_DI,
+                .radio_type     = UNSET,
+                .tda9887_conf   = TDA9887_PRESENT,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .input          = {{
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x0000BDE6
+                }},
+                .blackbird = 1,
+        },
+        [CX88_BOARD_PIXELVIEW_PLAYTV_P7000] = {
+                /* FIXME: SVideo, Composite and FM inputs are untested */
+                .name           = "PixelView PlayTV P7000",
+                .tuner_type     = TUNER_PHILIPS_FM1216ME_MK3,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .tda9887_conf   = TDA9887_PRESENT | TDA9887_PORT1_ACTIVE |
+                                  TDA9887_PORT2_ACTIVE,
+                .input          = {{
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x5da6,
+                }},
+                .blackbird = 1,
+        },
+        [CX88_BOARD_NPGTECH_REALTV_TOP10FM] = {
+                .name           = "NPG Tech Real TV FM Top 10",
+                .tuner_type     = TUNER_TNF_5335MF, /* Actually a TNF9535 */
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .input          = {{
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x0788,
+                },{
+                        .type   = CX88_VMUX_COMPOSITE1,
+                        .vmux   = 1,
+                        .gpio0  = 0x078b,
+                },{
+                        .type   = CX88_VMUX_SVIDEO,
+                        .vmux   = 2,
+                        .gpio0  = 0x078b,
+                }},
+                .radio = {
+                         .type  = CX88_RADIO,
+                         .gpio0 = 0x074a,
+                },
+        },
+        [CX88_BOARD_WINFAST_DTV2000H] = {
+                /* video inputs and radio still in testing */
+                .name           = "WinFast DTV2000 H",
+                .tuner_type     = TUNER_PHILIPS_FMD1216ME_MK3,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .tda9887_conf   = TDA9887_PRESENT,
+                .input          = {{
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x00017304,
+                        .gpio1  = 0x00008203,
+                        .gpio2  = 0x00017304,
+                        .gpio3  = 0x02000000,
+                }},
+                .dvb            = 1,
+        },
 };
 const unsigned int cx88_bcount = ARRAY_SIZE(cx88_boards);
 
@@ -1311,6 +1411,34 @@ struct cx88_subid cx88_subids[] = {
                 .subvendor = 0x18ac,
                 .subdevice = 0xdb44,
                 .card      = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_HYBRID,
+        },{
+                .subvendor = 0x7063,
+                .subdevice = 0x5500,
+                .card      = CX88_BOARD_PCHDTV_HD5500,
+        },{
+                .subvendor = 0x17de,
+                .subdevice = 0x0841,
+                .card      = CX88_BOARD_KWORLD_MCE200_DELUXE,
+        },{
+                .subvendor = 0x1822,
+                .subdevice = 0x0019,
+                .card      = CX88_BOARD_DNTV_LIVE_DVB_T_PRO,
+        },{
+                .subvendor = 0x1554,
+                .subdevice = 0x4813,
+                .card      = CX88_BOARD_PIXELVIEW_PLAYTV_P7000,
+        },{
+                .subvendor = 0x14f1,
+                .subdevice = 0x0842,
+                .card      = CX88_BOARD_NPGTECH_REALTV_TOP10FM,
+        },{
+                .subvendor = 0x107d,
+                .subdevice = 0x665e,
+                .card      = CX88_BOARD_WINFAST_DTV2000H,
+        },{
+                .subvendor = 0x18ac,
+                .subdevice = 0xd800, /* FusionHDTV 3 Gold (original revision) */
+                .card      = CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_Q,
         },
 };
 const unsigned int cx88_idcount = ARRAY_SIZE(cx88_subids);
diff --git a/drivers/media/video/cx88/cx88-core.c b/drivers/media/video/cx88/cx88-core.c
index e1092d5d462..c56292d8d93 100644
--- a/drivers/media/video/cx88/cx88-core.c
+++ b/drivers/media/video/cx88/cx88-core.c
@@ -677,7 +677,7 @@ static unsigned int inline norm_htotal(struct cx88_tvnorm *norm)
 
 static unsigned int inline norm_vbipack(struct cx88_tvnorm *norm)
 {
-        return (norm->id & V4L2_STD_625_50) ? 511 : 288;
+        return (norm->id & V4L2_STD_625_50) ? 511 : 400;
 }
 
 int cx88_set_scale(struct cx88_core *core, unsigned int width, unsigned int height,
@@ -932,9 +932,9 @@ int cx88_set_tvnorm(struct cx88_core *core, struct cx88_tvnorm *norm)
                 htotal, cx_read(MO_HTOTAL), (u32)tmp64);
         cx_write(MO_HTOTAL, htotal);
 
-        // vbi stuff
-        cx_write(MO_VBI_PACKET, ((1 << 11) | /* (norm_vdelay(norm)   << 11) | */
-                                 norm_vbipack(norm)));
+        // vbi stuff, set vbi offset to 10 (for 20 Clk*2 pixels), this makes
+        // the effective vbi offset ~244 samples, the same as the Bt8x8
+        cx_write(MO_VBI_PACKET, (10<<11) | norm_vbipack(norm));
 
         // this is needed as well to set all tvnorm parameter
         cx88_set_scale(core, 320, 240, V4L2_FIELD_INTERLACED);
diff --git a/drivers/media/video/cx88/cx88-dvb.c b/drivers/media/video/cx88/cx88-dvb.c
index 3619a449aef..dce1feddd55 100644
--- a/drivers/media/video/cx88/cx88-dvb.c
+++ b/drivers/media/video/cx88/cx88-dvb.c
@@ -51,6 +51,7 @@
 #endif
 #ifdef HAVE_LGDT330X
 # include "lgdt330x.h"
+# include "lg_h06xf.h"
 #endif
 #ifdef HAVE_NXT200X
 # include "nxt200x.h"
@@ -58,6 +59,7 @@
 #ifdef HAVE_CX24123
 # include "cx24123.h"
 #endif
+#include "isl6421.h"
 
 MODULE_DESCRIPTION("driver for cx2388x based DVB cards");
 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
@@ -113,21 +115,6 @@ static struct videobuf_queue_ops dvb_qops = {
 
 /* ------------------------------------------------------------------ */
 
-#if defined(HAVE_MT352) || defined(HAVE_ZL10353)
-static int zarlink_pll_set(struct dvb_frontend *fe,
-                              struct dvb_frontend_parameters *params,
-                              u8 *pllbuf)
-{
-        struct cx8802_dev *dev = fe->dvb->priv;
-
-        pllbuf[0] = dev->core->pll_addr << 1;
-        dvb_pll_configure(dev->core->pll_desc, pllbuf + 1,
-                          params->frequency,
-                          params->u.ofdm.bandwidth);
-        return 0;
-}
-#endif
-
 #ifdef HAVE_MT352
 static int dvico_fusionhdtv_demod_init(struct dvb_frontend* fe)
 {
@@ -196,19 +183,16 @@ static int dntv_live_dvbt_demod_init(struct dvb_frontend* fe)
 static struct mt352_config dvico_fusionhdtv = {
         .demod_address = 0x0F,
         .demod_init    = dvico_fusionhdtv_demod_init,
-        .pll_set       = zarlink_pll_set,
 };
 
 static struct mt352_config dntv_live_dvbt_config = {
         .demod_address = 0x0f,
         .demod_init    = dntv_live_dvbt_demod_init,
-        .pll_set       = zarlink_pll_set,
 };
 
 static struct mt352_config dvico_fusionhdtv_dual = {
         .demod_address = 0x0F,
         .demod_init    = dvico_dual_demod_init,
-        .pll_set       = zarlink_pll_set,
 };
 
 #ifdef HAVE_VP3054_I2C
@@ -246,6 +230,8 @@ static int philips_fmd1216_pll_init(struct dvb_frontend *fe)
                   .buf = fmd1216_init, .len = sizeof(fmd1216_init) };
         int err;
 
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if ((err = i2c_transfer(&dev->core->i2c_adap, &msg, 1)) != 1) {
                 if (err < 0)
                         return err;
@@ -256,14 +242,14 @@ static int philips_fmd1216_pll_init(struct dvb_frontend *fe)
         return 0;
 }
 
-static int dntv_live_dvbt_pro_pll_set(struct dvb_frontend* fe,
-                                      struct dvb_frontend_parameters* params,
-                                      u8* pllbuf)
+static int dntv_live_dvbt_pro_tuner_set_params(struct dvb_frontend* fe,
+                                               struct dvb_frontend_parameters* params)
 {
         struct cx8802_dev *dev= fe->dvb->priv;
+        u8 buf[4];
         struct i2c_msg msg =
                 { .addr = dev->core->pll_addr, .flags = 0,
-                  .buf = pllbuf+1, .len = 4 };
+                  .buf = buf, .len = 4 };
         int err;
 
         /* Switch PLL to DVB mode */
@@ -272,14 +258,16 @@ static int dntv_live_dvbt_pro_pll_set(struct dvb_frontend* fe,
                 return err;
 
         /* Tune PLL */
-        pllbuf[0] = dev->core->pll_addr << 1;
-        dvb_pll_configure(dev->core->pll_desc, pllbuf+1,
+        dvb_pll_configure(dev->core->pll_desc, buf,
                           params->frequency,
                           params->u.ofdm.bandwidth);
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if ((err = i2c_transfer(&dev->core->i2c_adap, &msg, 1)) != 1) {
+
                 printk(KERN_WARNING "cx88-dvb: %s error "
                            "(addr %02x <- %02x, err = %i)\n",
-                           __FUNCTION__, pllbuf[0], pllbuf[1], err);
+                           __FUNCTION__, dev->core->pll_addr, buf[0], err);
                 if (err < 0)
                         return err;
                 else
@@ -293,27 +281,27 @@ static struct mt352_config dntv_live_dvbt_pro_config = {
         .demod_address = 0x0f,
         .no_tuner      = 1,
         .demod_init    = dntv_live_dvbt_pro_demod_init,
-        .pll_set       = dntv_live_dvbt_pro_pll_set,
 };
 #endif
 #endif
 
 #ifdef HAVE_ZL10353
-static int dvico_hybrid_tune_pll(struct dvb_frontend *fe,
-                                 struct dvb_frontend_parameters *params,
-                                 u8 *pllbuf)
+static int dvico_hybrid_tuner_set_params(struct dvb_frontend *fe,
+                                         struct dvb_frontend_parameters *params)
 {
+        u8 pllbuf[4];
         struct cx8802_dev *dev= fe->dvb->priv;
         struct i2c_msg msg =
                 { .addr = dev->core->pll_addr, .flags = 0,
-                  .buf = pllbuf + 1, .len = 4 };
+                  .buf = pllbuf, .len = 4 };
         int err;
 
-        pllbuf[0] = dev->core->pll_addr << 1;
-        dvb_pll_configure(dev->core->pll_desc, pllbuf + 1,
+        dvb_pll_configure(dev->core->pll_desc, pllbuf,
                           params->frequency,
                           params->u.ofdm.bandwidth);
 
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if ((err = i2c_transfer(&dev->core->i2c_adap, &msg, 1)) != 1) {
                 printk(KERN_WARNING "cx88-dvb: %s error "
                            "(addr %02x <- %02x, err = %i)\n",
@@ -329,12 +317,11 @@ static int dvico_hybrid_tune_pll(struct dvb_frontend *fe,
 
 static struct zl10353_config dvico_fusionhdtv_hybrid = {
         .demod_address = 0x0F,
-        .pll_set       = dvico_hybrid_tune_pll,
+        .no_tuner      = 1,
 };
 
 static struct zl10353_config dvico_fusionhdtv_plus_v1_1 = {
         .demod_address = 0x0F,
-        .pll_set       = zarlink_pll_set,
 };
 #endif
 
@@ -342,21 +329,15 @@ static struct zl10353_config dvico_fusionhdtv_plus_v1_1 = {
 static struct cx22702_config connexant_refboard_config = {
         .demod_address = 0x43,
         .output_mode   = CX22702_SERIAL_OUTPUT,
-        .pll_address   = 0x60,
-        .pll_desc      = &dvb_pll_thomson_dtt7579,
 };
 
 static struct cx22702_config hauppauge_novat_config = {
         .demod_address = 0x43,
         .output_mode   = CX22702_SERIAL_OUTPUT,
-        .pll_address   = 0x61,
-        .pll_desc      = &dvb_pll_thomson_dtt759x,
 };
 static struct cx22702_config hauppauge_hvr1100_config = {
         .demod_address = 0x63,
         .output_mode   = CX22702_SERIAL_OUTPUT,
-        .pll_address   = 0x61,
-        .pll_desc      = &dvb_pll_fmd1216me,
 };
 #endif
 
@@ -371,15 +352,13 @@ static int or51132_set_ts_param(struct dvb_frontend* fe,
 
 static struct or51132_config pchdtv_hd3000 = {
         .demod_address    = 0x15,
-        .pll_address      = 0x61,
-        .pll_desc         = &dvb_pll_thomson_dtt761x,
         .set_ts_params    = or51132_set_ts_param,
 };
 #endif
 
 #ifdef HAVE_LGDT330X
-static int lgdt330x_pll_set(struct dvb_frontend* fe,
-                            struct dvb_frontend_parameters* params)
+static int lgdt3302_tuner_set_params(struct dvb_frontend* fe,
+                                     struct dvb_frontend_parameters* params)
 {
         /* FIXME make this routine use the tuner-simple code.
          * It could probably be shared with a number of ATSC
@@ -392,12 +371,12 @@ static int lgdt330x_pll_set(struct dvb_frontend* fe,
                 { .addr = dev->core->pll_addr, .flags = 0, .buf = buf, .len = 4 };
         int err;
 
-        /* Put the analog decoder in standby to keep it quiet */
-        cx88_call_i2c_clients (dev->core, TUNER_SET_STANDBY, NULL);
-
         dvb_pll_configure(core->pll_desc, buf, params->frequency, 0);
         dprintk(1, "%s: tuner at 0x%02x bytes: 0x%02x 0x%02x 0x%02x 0x%02x\n",
                         __FUNCTION__, msg.addr, buf[0],buf[1],buf[2],buf[3]);
+
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if ((err = i2c_transfer(&core->i2c_adap, &msg, 1)) != 1) {
                 printk(KERN_WARNING "cx88-dvb: %s error "
                            "(addr %02x <- %02x, err = %i)\n",
@@ -407,16 +386,21 @@ static int lgdt330x_pll_set(struct dvb_frontend* fe,
                 else
                         return -EREMOTEIO;
         }
-        if (core->tuner_type == TUNER_LG_TDVS_H062F) {
-                /* Set the Auxiliary Byte. */
-                buf[2] &= ~0x20;
-                buf[2] |= 0x18;
-                buf[3] = 0x50;
-                i2c_transfer(&core->i2c_adap, &msg, 1);
-        }
         return 0;
 }
 
+static int lgdt3303_tuner_set_params(struct dvb_frontend* fe,
+                                     struct dvb_frontend_parameters* params)
+{
+        struct cx8802_dev *dev= fe->dvb->priv;
+        struct cx88_core *core = dev->core;
+
+        /* Put the analog decoder in standby to keep it quiet */
+        cx88_call_i2c_clients (dev->core, TUNER_SET_STANDBY, NULL);
+
+        return lg_h06xf_pll_set(fe, &core->i2c_adap, params);
+}
+
 static int lgdt330x_pll_rf_set(struct dvb_frontend* fe, int index)
 {
         struct cx8802_dev *dev= fe->dvb->priv;
@@ -444,7 +428,6 @@ static struct lgdt330x_config fusionhdtv_3_gold = {
         .demod_address    = 0x0e,
         .demod_chip       = LGDT3302,
         .serial_mpeg      = 0x04, /* TPSERIAL for 3302 in TOP_CONTROL */
-        .pll_set          = lgdt330x_pll_set,
         .set_ts_params    = lgdt330x_set_ts_param,
 };
 
@@ -452,7 +435,13 @@ static struct lgdt330x_config fusionhdtv_5_gold = {
         .demod_address    = 0x0e,
         .demod_chip       = LGDT3303,
         .serial_mpeg      = 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
-        .pll_set          = lgdt330x_pll_set,
+        .set_ts_params    = lgdt330x_set_ts_param,
+};
+
+static struct lgdt330x_config pchdtv_hd5500 = {
+        .demod_address    = 0x59,
+        .demod_chip       = LGDT3303,
+        .serial_mpeg      = 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
         .set_ts_params    = lgdt330x_set_ts_param,
 };
 #endif
@@ -477,8 +466,6 @@ static int nxt200x_set_pll_input(u8* buf, int input)
 
 static struct nxt200x_config ati_hdtvwonder = {
         .demod_address    = 0x0a,
-        .pll_address      = 0x61,
-        .pll_desc         = &dvb_pll_tuv1236d,
         .set_pll_input    = nxt200x_set_pll_input,
         .set_ts_params    = nxt200x_set_ts_param,
 };
@@ -493,28 +480,30 @@ static int cx24123_set_ts_param(struct dvb_frontend* fe,
         return 0;
 }
 
-static void cx24123_enable_lnb_voltage(struct dvb_frontend* fe, int on)
+static int kworld_dvbs_100_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 {
         struct cx8802_dev *dev= fe->dvb->priv;
         struct cx88_core *core = dev->core;
 
-        if (on)
-                cx_write(MO_GP0_IO, 0x000006f9);
-        else
+        if (voltage == SEC_VOLTAGE_OFF) {
                 cx_write(MO_GP0_IO, 0x000006fB);
+        } else {
+                cx_write(MO_GP0_IO, 0x000006f9);
+        }
+
+        if (core->prev_set_voltage)
+                return core->prev_set_voltage(fe, voltage);
+        return 0;
 }
 
 static struct cx24123_config hauppauge_novas_config = {
         .demod_address          = 0x55,
-        .use_isl6421            = 1,
         .set_ts_params          = cx24123_set_ts_param,
 };
 
 static struct cx24123_config kworld_dvbs_100_config = {
         .demod_address          = 0x15,
-        .use_isl6421            = 0,
         .set_ts_params          = cx24123_set_ts_param,
-        .enable_lnb_voltage     = cx24123_enable_lnb_voltage,
 };
 #endif
 
@@ -530,6 +519,11 @@ static int dvb_register(struct cx8802_dev *dev)
         case CX88_BOARD_HAUPPAUGE_DVB_T1:
                 dev->dvb.frontend = cx22702_attach(&hauppauge_novat_config,
                                                    &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_thomson_dtt759x);
+                }
                 break;
         case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1:
         case CX88_BOARD_CONEXANT_DVB_T1:
@@ -537,44 +531,92 @@ static int dvb_register(struct cx8802_dev *dev)
         case CX88_BOARD_WINFAST_DTV1000:
                 dev->dvb.frontend = cx22702_attach(&connexant_refboard_config,
                                                    &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x60,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_thomson_dtt7579);
+                }
                 break;
+        case CX88_BOARD_WINFAST_DTV2000H:
         case CX88_BOARD_HAUPPAUGE_HVR1100:
         case CX88_BOARD_HAUPPAUGE_HVR1100LP:
                 dev->dvb.frontend = cx22702_attach(&hauppauge_hvr1100_config,
                                                    &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_fmd1216me);
+                }
                 break;
 #endif
 #if defined(HAVE_MT352) || defined(HAVE_ZL10353)
         case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS:
-                dev->core->pll_addr = 0x60;
-                dev->core->pll_desc = &dvb_pll_thomson_dtt7579;
 #ifdef HAVE_MT352
                 dev->dvb.frontend = mt352_attach(&dvico_fusionhdtv,
                                                  &dev->core->i2c_adap);
-                if (dev->dvb.frontend != NULL)
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x60,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_thomson_dtt7579);
                         break;
+                }
 #endif
 #ifdef HAVE_ZL10353
                 /* ZL10353 replaces MT352 on later cards */
                 dev->dvb.frontend = zl10353_attach(&dvico_fusionhdtv_plus_v1_1,
                                                    &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x60,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_thomson_dtt7579);
+                }
+#endif
+                break;
+        case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL:
+#ifdef HAVE_MT352
+                /* The tin box says DEE1601, but it seems to be DTT7579
+                 * compatible, with a slightly different MT352 AGC gain. */
+                dev->dvb.frontend = mt352_attach(&dvico_fusionhdtv_dual,
+                                                 &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_thomson_dtt7579);
+                        break;
+                }
+#endif
+#ifdef HAVE_ZL10353
+                /* ZL10353 replaces MT352 on later cards */
+                dev->dvb.frontend = zl10353_attach(&dvico_fusionhdtv_plus_v1_1,
+                                                   &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_thomson_dtt7579);
+                }
 #endif
                 break;
 #endif /* HAVE_MT352 || HAVE_ZL10353 */
 #ifdef HAVE_MT352
         case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1:
-                dev->core->pll_addr = 0x61;
-                dev->core->pll_desc = &dvb_pll_lg_z201;
                 dev->dvb.frontend = mt352_attach(&dvico_fusionhdtv,
                                                  &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_lg_z201);
+                }
                 break;
         case CX88_BOARD_KWORLD_DVB_T:
         case CX88_BOARD_DNTV_LIVE_DVB_T:
         case CX88_BOARD_ADSTECH_DVB_T_PCI:
-                dev->core->pll_addr = 0x61;
-                dev->core->pll_desc = &dvb_pll_unknown_1;
                 dev->dvb.frontend = mt352_attach(&dntv_live_dvbt_config,
                                                  &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_unknown_1);
+                }
                 break;
         case CX88_BOARD_DNTV_LIVE_DVB_T_PRO:
 #ifdef HAVE_VP3054_I2C
@@ -582,18 +624,13 @@ static int dvb_register(struct cx8802_dev *dev)
                 dev->core->pll_desc = &dvb_pll_fmd1216me;
                 dev->dvb.frontend = mt352_attach(&dntv_live_dvbt_pro_config,
                         &((struct vp3054_i2c_state *)dev->card_priv)->adap);
+                if (dev->dvb.frontend != NULL) {
+                        dev->dvb.frontend->ops.tuner_ops.set_params = dntv_live_dvbt_pro_tuner_set_params;
+                }
 #else
                 printk("%s: built without vp3054 support\n", dev->core->name);
 #endif
                 break;
-        case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL:
-                /* The tin box says DEE1601, but it seems to be DTT7579
-                 * compatible, with a slightly different MT352 AGC gain. */
-                dev->core->pll_addr = 0x61;
-                dev->core->pll_desc = &dvb_pll_thomson_dtt7579;
-                dev->dvb.frontend = mt352_attach(&dvico_fusionhdtv_dual,
-                                                 &dev->core->i2c_adap);
-                break;
 #endif
 #ifdef HAVE_ZL10353
         case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_HYBRID:
@@ -601,12 +638,20 @@ static int dvb_register(struct cx8802_dev *dev)
                 dev->core->pll_desc = &dvb_pll_thomson_fe6600;
                 dev->dvb.frontend = zl10353_attach(&dvico_fusionhdtv_hybrid,
                                                    &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dev->dvb.frontend->ops.tuner_ops.set_params = dvico_hybrid_tuner_set_params;
+                }
                 break;
 #endif
 #ifdef HAVE_OR51132
         case CX88_BOARD_PCHDTV_HD3000:
                 dev->dvb.frontend = or51132_attach(&pchdtv_hd3000,
                                                  &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_thomson_dtt761x);
+                }
                 break;
 #endif
 #ifdef HAVE_LGDT330X
@@ -627,6 +672,9 @@ static int dvb_register(struct cx8802_dev *dev)
                 dev->core->pll_desc = &dvb_pll_microtune_4042;
                 dev->dvb.frontend = lgdt330x_attach(&fusionhdtv_3_gold,
                                                     &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dev->dvb.frontend->ops.tuner_ops.set_params = lgdt3302_tuner_set_params;
+                }
                 }
                 break;
         case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_T:
@@ -643,6 +691,9 @@ static int dvb_register(struct cx8802_dev *dev)
                 dev->core->pll_desc = &dvb_pll_thomson_dtt761x;
                 dev->dvb.frontend = lgdt330x_attach(&fusionhdtv_3_gold,
                                                     &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dev->dvb.frontend->ops.tuner_ops.set_params = lgdt3302_tuner_set_params;
+                }
                 }
                 break;
         case CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD:
@@ -655,10 +706,28 @@ static int dvb_register(struct cx8802_dev *dev)
                 mdelay(100);
                 cx_set(MO_GP0_IO, 1);
                 mdelay(200);
-                dev->core->pll_addr = 0x61;
-                dev->core->pll_desc = &dvb_pll_tdvs_tua6034;
                 dev->dvb.frontend = lgdt330x_attach(&fusionhdtv_5_gold,
                                                     &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dev->dvb.frontend->ops.tuner_ops.set_params = lgdt3303_tuner_set_params;
+                }
+                }
+                break;
+        case CX88_BOARD_PCHDTV_HD5500:
+                dev->ts_gen_cntrl = 0x08;
+                {
+                /* Do a hardware reset of chip before using it. */
+                struct cx88_core *core = dev->core;
+
+                cx_clear(MO_GP0_IO, 1);
+                mdelay(100);
+                cx_set(MO_GP0_IO, 1);
+                mdelay(200);
+                dev->dvb.frontend = lgdt330x_attach(&pchdtv_hd5500,
+                                                    &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dev->dvb.frontend->ops.tuner_ops.set_params = lgdt3303_tuner_set_params;
+                }
                 }
                 break;
 #endif
@@ -666,6 +735,11 @@ static int dvb_register(struct cx8802_dev *dev)
         case CX88_BOARD_ATI_HDTVWONDER:
                 dev->dvb.frontend = nxt200x_attach(&ati_hdtvwonder,
                                                  &dev->core->i2c_adap);
+                if (dev->dvb.frontend != NULL) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61,
+                                       &dev->core->i2c_adap,
+                                       &dvb_pll_tuv1236d);
+                }
                 break;
 #endif
 #ifdef HAVE_CX24123
@@ -673,10 +747,18 @@ static int dvb_register(struct cx8802_dev *dev)
         case CX88_BOARD_HAUPPAUGE_NOVASE2_S1:
                 dev->dvb.frontend = cx24123_attach(&hauppauge_novas_config,
                         &dev->core->i2c_adap);
+                if (dev->dvb.frontend) {
+                        isl6421_attach(dev->dvb.frontend, &dev->core->i2c_adap,
+                                       0x08, 0x00, 0x00);
+                }
                 break;
         case CX88_BOARD_KWORLD_DVBS_100:
                 dev->dvb.frontend = cx24123_attach(&kworld_dvbs_100_config,
                         &dev->core->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->core->prev_set_voltage = dev->dvb.frontend->ops.set_voltage;
+                        dev->dvb.frontend->ops.set_voltage = kworld_dvbs_100_set_voltage;
+                }
                 break;
 #endif
         default:
@@ -690,15 +772,15 @@ static int dvb_register(struct cx8802_dev *dev)
         }
 
         if (dev->core->pll_desc) {
-                dev->dvb.frontend->ops->info.frequency_min = dev->core->pll_desc->min;
-                dev->dvb.frontend->ops->info.frequency_max = dev->core->pll_desc->max;
+                dev->dvb.frontend->ops.info.frequency_min = dev->core->pll_desc->min;
+                dev->dvb.frontend->ops.info.frequency_max = dev->core->pll_desc->max;
         }
 
         /* Put the analog decoder in standby to keep it quiet */
         cx88_call_i2c_clients (dev->core, TUNER_SET_STANDBY, NULL);
 
         /* register everything */
-        return videobuf_dvb_register(&dev->dvb, THIS_MODULE, dev);
+        return videobuf_dvb_register(&dev->dvb, THIS_MODULE, dev, &dev->pci->dev);
 }
 
 /* ----------------------------------------------------------- */
diff --git a/drivers/media/video/cx88/cx88-i2c.c b/drivers/media/video/cx88/cx88-i2c.c
index f720901e963..7efa6def0bd 100644
--- a/drivers/media/video/cx88/cx88-i2c.c
+++ b/drivers/media/video/cx88/cx88-i2c.c
@@ -138,13 +138,13 @@ void cx88_call_i2c_clients(struct cx88_core *core, unsigned int cmd, void *arg)
                 return;
 
         if (core->dvbdev) {
-                if (core->dvbdev->dvb.frontend->ops->i2c_gate_ctrl)
-                        core->dvbdev->dvb.frontend->ops->i2c_gate_ctrl(core->dvbdev->dvb.frontend, 1);
+                if (core->dvbdev->dvb.frontend->ops.i2c_gate_ctrl)
+                        core->dvbdev->dvb.frontend->ops.i2c_gate_ctrl(core->dvbdev->dvb.frontend, 1);
 
                 i2c_clients_command(&core->i2c_adap, cmd, arg);
 
-                if (core->dvbdev->dvb.frontend->ops->i2c_gate_ctrl)
-                        core->dvbdev->dvb.frontend->ops->i2c_gate_ctrl(core->dvbdev->dvb.frontend, 0);
+                if (core->dvbdev->dvb.frontend->ops.i2c_gate_ctrl)
+                        core->dvbdev->dvb.frontend->ops.i2c_gate_ctrl(core->dvbdev->dvb.frontend, 0);
         } else
                 i2c_clients_command(&core->i2c_adap, cmd, arg);
 }
diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c
index 78a63b7dd38..72b630a91f4 100644
--- a/drivers/media/video/cx88/cx88-input.c
+++ b/drivers/media/video/cx88/cx88-input.c
@@ -70,14 +70,33 @@ MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
 static void cx88_ir_handle_key(struct cx88_IR *ir)
 {
         struct cx88_core *core = ir->core;
-        u32 gpio, data;
+        u32 gpio, data, auxgpio;
 
         /* read gpio value */
         gpio = cx_read(ir->gpio_addr);
+        if (core->board == CX88_BOARD_NPGTECH_REALTV_TOP10FM) {
+                /* This board apparently uses a combination of 2 GPIO
+                   to represent the keys. Additionally, the second GPIO
+                   can be used for parity.
+
+                   Example:
+
+                   for key "5"
+                        gpio = 0x758, auxgpio = 0xe5 or 0xf5
+                   for key "Power"
+                        gpio = 0x758, auxgpio = 0xed or 0xfd
+                 */
+
+                auxgpio = cx_read(MO_GP1_IO);
+                /* Take out the parity part */
+                gpio+=(gpio & 0x7fd) + (auxgpio & 0xef);
+        } else
+                auxgpio = gpio;
+
         if (ir->polling) {
-                if (ir->last_gpio == gpio)
+                if (ir->last_gpio == auxgpio)
                         return;
-                ir->last_gpio = gpio;
+                ir->last_gpio = auxgpio;
         }
 
         /* extract data */
@@ -172,12 +191,13 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
                 ir_type = IR_TYPE_RC5;
                 ir->sampling = 1;
                 break;
+        case CX88_BOARD_WINFAST_DTV2000H:
         case CX88_BOARD_WINFAST2000XP_EXPERT:
                 ir_codes = ir_codes_winfast;
                 ir->gpio_addr = MO_GP0_IO;
                 ir->mask_keycode = 0x8f8;
                 ir->mask_keyup = 0x100;
-                ir->polling = 1; /* ms */
+                ir->polling = 50; /* ms */
                 break;
         case CX88_BOARD_IODATA_GVBCTV7E:
                 ir_codes = ir_codes_iodata_bctv7e;
@@ -228,6 +248,12 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
                 ir_type = IR_TYPE_PD;
                 ir->sampling = 0xff00; /* address */
                 break;
+        case CX88_BOARD_NPGTECH_REALTV_TOP10FM:
+                ir_codes = ir_codes_npgtech;
+                ir->gpio_addr = MO_GP0_IO;
+                ir->mask_keycode = 0xfa;
+                ir->polling = 50; /* ms */
+                break;
         }
 
         if (NULL == ir_codes) {
diff --git a/drivers/media/video/cx88/cx88-mpeg.c b/drivers/media/video/cx88/cx88-mpeg.c
index 7d16888b4a8..a9d7795a8e1 100644
--- a/drivers/media/video/cx88/cx88-mpeg.c
+++ b/drivers/media/video/cx88/cx88-mpeg.c
@@ -54,7 +54,7 @@ static int cx8802_start_dma(struct cx8802_dev    *dev,
 {
         struct cx88_core *core = dev->core;
 
-        dprintk(0, "cx8802_start_dma w: %d, h: %d, f: %d\n", dev->width, dev->height, buf->vb.field);
+        dprintk(1, "cx8802_start_dma w: %d, h: %d, f: %d\n", dev->width, dev->height, buf->vb.field);
 
         /* setup fifo + format */
         cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH28],
@@ -76,6 +76,7 @@ static int cx8802_start_dma(struct cx8802_dev    *dev,
                 case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_Q:
                 case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_T:
                 case CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD:
+                case CX88_BOARD_PCHDTV_HD5500:
                         cx_write(TS_SOP_STAT, 1<<13);
                         break;
                 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1:
@@ -109,7 +110,7 @@ static int cx8802_start_dma(struct cx8802_dev    *dev,
         q->count = 1;
 
         /* enable irqs */
-        dprintk( 0, "setting the interrupt mask\n" );
+        dprintk( 1, "setting the interrupt mask\n" );
         cx_set(MO_PCI_INTMSK, core->pci_irqmask | 0x04);
         cx_set(MO_TS_INTMSK,  0x1f0011);
 
@@ -122,7 +123,7 @@ static int cx8802_start_dma(struct cx8802_dev    *dev,
 static int cx8802_stop_dma(struct cx8802_dev *dev)
 {
         struct cx88_core *core = dev->core;
-        dprintk( 0, "cx8802_stop_dma\n" );
+        dprintk( 1, "cx8802_stop_dma\n" );
 
         /* stop dma */
         cx_clear(MO_TS_DMACNTRL, 0x11);
@@ -142,10 +143,43 @@ static int cx8802_restart_queue(struct cx8802_dev    *dev,
         struct cx88_buffer *buf;
         struct list_head *item;
 
-        dprintk( 0, "cx8802_restart_queue\n" );
+       dprintk( 1, "cx8802_restart_queue\n" );
         if (list_empty(&q->active))
         {
-                dprintk( 0, "cx8802_restart_queue: queue is empty\n" );
+               struct cx88_buffer *prev;
+               prev = NULL;
+
+               dprintk(1, "cx8802_restart_queue: queue is empty\n" );
+
+               for (;;) {
+                       if (list_empty(&q->queued))
+                               return 0;
+                       buf = list_entry(q->queued.next, struct cx88_buffer, vb.queue);
+                       if (NULL == prev) {
+                               list_del(&buf->vb.queue);
+                               list_add_tail(&buf->vb.queue,&q->active);
+                               cx8802_start_dma(dev, q, buf);
+                               buf->vb.state = STATE_ACTIVE;
+                               buf->count    = q->count++;
+                               mod_timer(&q->timeout, jiffies+BUFFER_TIMEOUT);
+                               dprintk(1,"[%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_del(&buf->vb.queue);
+                               list_add_tail(&buf->vb.queue,&q->active);
+                               buf->vb.state = STATE_ACTIVE;
+                               buf->count    = q->count++;
+                               prev->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
+                               dprintk(1,"[%p/%d] restart_queue - move to active\n",
+                                       buf,buf->vb.i);
+                       } else {
+                               return 0;
+                       }
+                       prev = buf;
+               }
                 return 0;
         }
 
@@ -204,13 +238,13 @@ void cx8802_buf_queue(struct cx8802_dev *dev, struct cx88_buffer *buf)
         buf->risc.jmp[1] = cpu_to_le32(cx88q->stopper.dma);
 
         if (list_empty(&cx88q->active)) {
-                dprintk( 0, "queue is empty - first active\n" );
+                dprintk( 1, "queue is empty - first active\n" );
                 list_add_tail(&buf->vb.queue,&cx88q->active);
                 cx8802_start_dma(dev, cx88q, buf);
                 buf->vb.state = STATE_ACTIVE;
                 buf->count    = cx88q->count++;
                 mod_timer(&cx88q->timeout, jiffies+BUFFER_TIMEOUT);
-                dprintk(0,"[%p/%d] %s - first active\n",
+                dprintk(1,"[%p/%d] %s - first active\n",
                         buf, buf->vb.i, __FUNCTION__);
 
         } else {
@@ -244,7 +278,7 @@ static void do_cancel_buffers(struct cx8802_dev *dev, char *reason, int restart)
         }
         if (restart)
         {
-                dprintk(0, "restarting queue\n" );
+                dprintk(1, "restarting queue\n" );
                 cx8802_restart_queue(dev,q);
         }
         spin_unlock_irqrestore(&dev->slock,flags);
diff --git a/drivers/media/video/cx88/cx88-tvaudio.c b/drivers/media/video/cx88/cx88-tvaudio.c
index 641a0c5a649..1e4278b588d 100644
--- a/drivers/media/video/cx88/cx88-tvaudio.c
+++ b/drivers/media/video/cx88/cx88-tvaudio.c
@@ -52,6 +52,7 @@
 #include <linux/init.h>
 #include <linux/smp_lock.h>
 #include <linux/delay.h>
+#include <linux/config.h>
 #include <linux/kthread.h>
 
 #include "cx88.h"
@@ -137,21 +138,28 @@ static void set_audio_finish(struct cx88_core *core, u32 ctl)
 {
         u32 volume;
 
-#ifndef USING_CX88_ALSA
+#ifndef CONFIG_VIDEO_CX88_ALSA
         /* restart dma; This avoids buzz in NICAM and is good in others  */
         cx88_stop_audio_dma(core);
 #endif
         cx_write(AUD_RATE_THRES_DMD, 0x000000C0);
-#ifndef USING_CX88_ALSA
+#ifndef CONFIG_VIDEO_CX88_ALSA
         cx88_start_audio_dma(core);
 #endif
 
         if (cx88_boards[core->board].blackbird) {
                 /* sets sound input from external adc */
-                if (core->board == CX88_BOARD_HAUPPAUGE_ROSLYN)
+                switch (core->board) {
+                case CX88_BOARD_HAUPPAUGE_ROSLYN:
+                case CX88_BOARD_KWORLD_MCE200_DELUXE:
+                case CX88_BOARD_KWORLD_HARDWARE_MPEG_TV_XPERT:
+                case CX88_BOARD_PIXELVIEW_PLAYTV_P7000:
+                case CX88_BOARD_ASUS_PVR_416:
                         cx_clear(AUD_CTL, EN_I2SIN_ENABLE);
-                else
+                        break;
+                default:
                         cx_set(AUD_CTL, EN_I2SIN_ENABLE);
+                }
 
                 cx_write(AUD_I2SINPUTCNTL, 4);
                 cx_write(AUD_BAUDRATE, 1);
diff --git a/drivers/media/video/cx88/cx88-vbi.c b/drivers/media/video/cx88/cx88-vbi.c
index 846faadc9f1..aa2a6977009 100644
--- a/drivers/media/video/cx88/cx88-vbi.c
+++ b/drivers/media/video/cx88/cx88-vbi.c
@@ -34,8 +34,8 @@ void cx8800_vbi_fmt(struct cx8800_dev *dev, struct v4l2_format *f)
         if (dev->core->tvnorm->id & V4L2_STD_525_60) {
                 /* ntsc */
                 f->fmt.vbi.sampling_rate = 28636363;
-                f->fmt.vbi.start[0] = 10 -1;
-                f->fmt.vbi.start[1] = 273 -1;
+                f->fmt.vbi.start[0] = 10;
+                f->fmt.vbi.start[1] = 273;
 
         } else if (dev->core->tvnorm->id & V4L2_STD_625_50) {
                 /* pal */
diff --git a/drivers/media/video/cx88/cx88.h b/drivers/media/video/cx88/cx88.h
index 326a25f147f..dc7bc35f18f 100644
--- a/drivers/media/video/cx88/cx88.h
+++ b/drivers/media/video/cx88/cx88.h
@@ -25,9 +25,11 @@
 #include <linux/videodev2.h>
 #include <linux/kdev_t.h>
 
+#include <media/v4l2-common.h>
 #include <media/tuner.h>
 #include <media/tveeprom.h>
 #include <media/video-buf.h>
+#include <media/cx2341x.h>
 #include <media/video-buf-dvb.h>
 
 #include "btcx-risc.h"
@@ -35,7 +37,7 @@
 
 #include <linux/version.h>
 #include <linux/mutex.h>
-#define CX88_VERSION_CODE KERNEL_VERSION(0,0,5)
+#define CX88_VERSION_CODE KERNEL_VERSION(0,0,6)
 
 #ifndef TRUE
 # define TRUE (1==1)
@@ -189,6 +191,11 @@ extern struct sram_channel cx88_sram_channels[];
 #define CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL 44
 #define CX88_BOARD_KWORLD_HARDWARE_MPEG_TV_XPERT 45
 #define CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_HYBRID 46
+#define CX88_BOARD_PCHDTV_HD5500           47
+#define CX88_BOARD_KWORLD_MCE200_DELUXE    48
+#define CX88_BOARD_PIXELVIEW_PLAYTV_P7000  49
+#define CX88_BOARD_NPGTECH_REALTV_TOP10FM  50
+#define CX88_BOARD_WINFAST_DTV2000H        51
 
 enum cx88_itype {
         CX88_VMUX_COMPOSITE1 = 1,
@@ -296,6 +303,7 @@ struct cx88_core {
         /* config info -- dvb */
         struct dvb_pll_desc        *pll_desc;
         unsigned int               pll_addr;
+        int                        (*prev_set_voltage)(struct dvb_frontend* fe, fe_sec_voltage_t voltage);
 
         /* state info */
         struct task_struct         *kthread;
@@ -391,14 +399,6 @@ struct cx8802_suspend_state {
         int                        disabled;
 };
 
-/* TODO: move this to struct v4l2_mpeg_compression ? */
-struct blackbird_dnr {
-        u32                       mode;
-        u32                       type;
-        u32                       spatial;
-        u32                       temporal;
-};
-
 struct cx8802_dev {
         struct cx88_core           *core;
         spinlock_t                 slock;
@@ -432,8 +432,7 @@ struct cx8802_dev {
         unsigned char              ts_gen_cntrl;
 
         /* mpeg params */
-        struct v4l2_mpeg_compression params;
-        struct blackbird_dnr       dnr_params;
+        struct cx2341x_mpeg_params params;
 };
 
 /* ----------------------------------------------------------- */
@@ -598,10 +597,6 @@ extern int cx88_do_ioctl(struct inode *inode, struct file *file, int radio,
 extern int (*cx88_ioctl_hook)(struct inode *inode, struct file *file,
                                 unsigned int cmd, void *arg);
 extern unsigned int (*cx88_ioctl_translator)(unsigned int cmd);
-void blackbird_set_params(struct cx8802_dev *dev,
-                                struct v4l2_mpeg_compression *params);
-void blackbird_set_dnr_params(struct cx8802_dev *dev,
-                                struct blackbird_dnr* dnr_params);
 
 /*
  * Local variables:
diff --git a/drivers/media/video/dsbr100.c b/drivers/media/video/dsbr100.c
index 3b4e9985c3d..f7e33f9ee8e 100644
--- a/drivers/media/video/dsbr100.c
+++ b/drivers/media/video/dsbr100.c
@@ -72,6 +72,7 @@
 #include <linux/slab.h>
 #include <linux/input.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/usb.h>
 #include <linux/smp_lock.h>
 
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 3ba3439db58..ed882ebc7b9 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -3,7 +3,7 @@
 
    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
                       Markus Rechberger <mrechberger@gmail.com>
-                      Mauro Carvalho Chehab <mchehab@brturbo.com.br>
+                      Mauro Carvalho Chehab <mchehab@infradead.org>
                       Sascha Sommer <saschasommer@freenet.de>
 
    This program is free software; you can redistribute it and/or modify
@@ -29,6 +29,8 @@
 #include <linux/usb.h>
 #include <media/tuner.h>
 #include <media/msp3400.h>
+#include <media/saa7115.h>
+#include <media/tvp5150.h>
 #include <media/tveeprom.h>
 #include <media/audiochip.h>
 #include <media/v4l2-common.h>
@@ -46,11 +48,11 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input           = {{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -64,11 +66,11 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input           = {{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -82,11 +84,11 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input           = {{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -100,15 +102,15 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input          = {{
                         .type     = EM28XX_VMUX_TELEVISION,
-                        .vmux     = 2,
+                        .vmux     = SAA7115_COMPOSITE2,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -122,15 +124,15 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input          = {{
                         .type     = EM28XX_VMUX_TELEVISION,
-                        .vmux     = 2,
+                        .vmux     = SAA7115_COMPOSITE2,
                         .amux     = 0,
                 },{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -146,11 +148,11 @@ struct em28xx_board em28xx_boards[] = {
                 /*FIXME: S-Video not tested */
                 .input          = {{
                         .type     = EM28XX_VMUX_TELEVISION,
-                        .vmux     = 0,
+                        .vmux     = TVP5150_COMPOSITE0,
                         .amux     = MSP_INPUT_DEFAULT,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 2,
+                        .vmux     = TVP5150_SVIDEO,
                         .amux     = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
                                         MSP_DSP_IN_SCART, MSP_DSP_IN_SCART),
                 }},
@@ -165,15 +167,15 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder        = EM28XX_SAA7114,
                 .input          = {{
                         .type     = EM28XX_VMUX_TELEVISION,
-                        .vmux     = 4,
+                        .vmux     = SAA7115_COMPOSITE4,
                         .amux     = 0,
                 },{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -188,15 +190,15 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input          = {{
                         .type     = EM28XX_VMUX_TELEVISION,
-                        .vmux     = 2,
+                        .vmux     = SAA7115_COMPOSITE2,
                         .amux     = 0,
                 },{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -211,15 +213,15 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input          = {{
                         .type     = EM28XX_VMUX_TELEVISION,
-                        .vmux     = 2,
+                        .vmux     = SAA7115_COMPOSITE2,
                         .amux     = 0,
                 },{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -234,15 +236,15 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input          = {{
                         .type     = EM28XX_VMUX_TELEVISION,
-                        .vmux     = 2,
+                        .vmux     = SAA7115_COMPOSITE2,
                         .amux     = 0,
                 },{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -254,11 +256,11 @@ struct em28xx_board em28xx_boards[] = {
                 .decoder      = EM28XX_SAA7113,
                 .input          = {{
                         .type     = EM28XX_VMUX_COMPOSITE1,
-                        .vmux     = 0,
+                        .vmux     = SAA7115_COMPOSITE0,
                         .amux     = 1,
                 },{
                         .type     = EM28XX_VMUX_SVIDEO,
-                        .vmux     = 9,
+                        .vmux     = SAA7115_SVIDEO3,
                         .amux     = 1,
                 }},
         },
@@ -324,8 +326,4 @@ void em28xx_card_setup(struct em28xx *dev)
         }
 }
 
-EXPORT_SYMBOL(em28xx_boards);
-EXPORT_SYMBOL(em28xx_bcount);
-EXPORT_SYMBOL(em28xx_id_table);
-
 MODULE_DEVICE_TABLE (usb, em28xx_id_table);
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index e5ee8bceb21..4350cc75b02 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -3,7 +3,7 @@
 
    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
                       Markus Rechberger <mrechberger@gmail.com>
-                      Mauro Carvalho Chehab <mchehab@brturbo.com.br>
+                      Mauro Carvalho Chehab <mchehab@infradead.org>
                       Sascha Sommer <saschasommer@freenet.de>
 
    This program is free software; you can redistribute it and/or modify
@@ -317,8 +317,8 @@ int em28xx_outfmt_set_yuv422(struct em28xx *dev)
         return em28xx_write_regs(dev, VINCTRL_REG, "\x11", 1);
 }
 
-int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax, u8 ymin,
-                                  u8 ymax)
+static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
+                                  u8 ymin, u8 ymax)
 {
         em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n", xmin, ymin, xmax, ymax);
 
@@ -328,7 +328,7 @@ int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax, u8 ymin,
         return em28xx_write_regs(dev, YMAX_REG, &ymax, 1);
 }
 
-int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
+static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
                                    u16 width, u16 height)
 {
         u8 cwidth = width;
@@ -345,7 +345,7 @@ int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
         return em28xx_write_regs(dev, OFLOW_REG, &overflow, 1);
 }
 
-int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
+static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
 {
         u8 mode;
         /* the em2800 scaler only supports scaling down to 50% */
@@ -534,7 +534,7 @@ static inline void em28xx_isoc_video_copy(struct em28xx *dev,
  * em28xx_isoIrq()
  * handles the incoming isoc urbs and fills the frames from our inqueue
  */
-void em28xx_isocIrq(struct urb *urb, struct pt_regs *regs)
+static void em28xx_isocIrq(struct urb *urb, struct pt_regs *regs)
 {
         struct em28xx *dev = urb->context;
         int i, status;
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
index 5b6cece37ae..d829d8f8c1f 100644
--- a/drivers/media/video/em28xx/em28xx-i2c.c
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -3,7 +3,7 @@
 
    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
                       Markus Rechberger <mrechberger@gmail.com>
-                      Mauro Carvalho Chehab <mchehab@brturbo.com.br>
+                      Mauro Carvalho Chehab <mchehab@infradead.org>
                       Sascha Sommer <saschasommer@freenet.de>
 
    This program is free software; you can redistribute it and/or modify
@@ -399,17 +399,6 @@ static u32 functionality(struct i2c_adapter *adap)
         return I2C_FUNC_SMBUS_EMUL;
 }
 
-#ifndef I2C_PEC
-static void inc_use(struct i2c_adapter *adap)
-{
-        MOD_INC_USE_COUNT;
-}
-
-static void dec_use(struct i2c_adapter *adap)
-{
-        MOD_DEC_USE_COUNT;
-}
-#endif
 
 static int em28xx_set_tuner(int check_eeprom, struct i2c_client *client)
 {
@@ -436,9 +425,19 @@ static int attach_inform(struct i2c_client *client)
         struct em28xx *dev = client->adapter->algo_data;
 
         switch (client->addr << 1) {
-                case 0x86:
+                case 0x43:
+                case 0x4b:
+                {
+                        struct tuner_setup tun_setup;
+
+                        tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
+                        tun_setup.type = TUNER_TDA9887;
+                        tun_setup.addr = client->addr;
+
+                        em28xx_i2c_call_clients(dev, TUNER_SET_TYPE_ADDR, &tun_setup);
                         em28xx_i2c_call_clients(dev, TDA9887_SET_CONFIG, &dev->tda9887_conf);
                         break;
+                }
                 case 0x42:
                         dprintk1(1,"attach_inform: saa7114 detected.\n");
                         break;
@@ -464,6 +463,7 @@ static int attach_inform(struct i2c_client *client)
                 case 0xba:
                         dprintk1(1,"attach_inform: tvp5150 detected.\n");
                         break;
+
                 default:
                         dprintk1(1,"attach inform: detected I2C address %x\n", client->addr << 1);
                         dev->tuner_addr = client->addr;
@@ -480,12 +480,7 @@ static struct i2c_algorithm em28xx_algo = {
 };
 
 static struct i2c_adapter em28xx_adap_template = {
-#ifdef I2C_PEC
         .owner = THIS_MODULE,
-#else
-        .inc_use = inc_use,
-        .dec_use = dec_use,
-#endif
         .class = I2C_CLASS_TV_ANALOG,
         .name = "em28xx",
         .id = I2C_HW_B_EM28XX,
diff --git a/drivers/media/video/em28xx/em28xx-input.c b/drivers/media/video/em28xx/em28xx-input.c
index 31e89e4f18b..3ffb5684f12 100644
--- a/drivers/media/video/em28xx/em28xx-input.c
+++ b/drivers/media/video/em28xx/em28xx-input.c
@@ -3,7 +3,7 @@
 
    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
                       Markus Rechberger <mrechberger@gmail.com>
-                      Mauro Carvalho Chehab <mchehab@brturbo.com.br>
+                      Mauro Carvalho Chehab <mchehab@infradead.org>
                       Sascha Sommer <saschasommer@freenet.de>
 
   This program is free software; you can redistribute it and/or modify
@@ -105,7 +105,7 @@ static int get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
         return 1;
 }
 
-static int get_key_pinnacle_usb(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+static int get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 {
         unsigned char buf[3];
 
@@ -148,8 +148,8 @@ void em28xx_set_ir(struct em28xx * dev,struct IR_i2c *ir)
                 snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (EM28XX Terratec)");
                 break;
         case (EM2820_BOARD_PINNACLE_USB_2):
-                ir->ir_codes = ir_codes_em_pinnacle_usb;
-                ir->get_key = get_key_pinnacle_usb;
+                ir->ir_codes = ir_codes_pinnacle_grey;
+                ir->get_key = get_key_pinnacle_usb_grey;
                 snprintf(ir->c.name, sizeof(ir->c.name), "i2c IR (EM28XX Pinnacle PCTV)");
                 break;
         case (EM2820_BOARD_HAUPPAUGE_WINTV_USB_2):
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index cf7cdf9ef61..9286090817c 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -3,7 +3,7 @@
 
    Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
                       Markus Rechberger <mrechberger@gmail.com>
-                      Mauro Carvalho Chehab <mchehab@brturbo.com.br>
+                      Mauro Carvalho Chehab <mchehab@infradead.org>
                       Sascha Sommer <saschasommer@freenet.de>
 
         Some parts based on SN9C10x PC Camera Controllers GPL driver made
@@ -42,7 +42,7 @@
 
 #define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
                       "Markus Rechberger <mrechberger@gmail.com>, " \
-                      "Mauro Carvalho Chehab <mchehab@brturbo.com.br>, " \
+                      "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
                       "Sascha Sommer <saschasommer@freenet.de>"
 
 #define DRIVER_NAME         "em28xx"
@@ -170,8 +170,12 @@ static int em28xx_config(struct em28xx *dev)
 static void em28xx_config_i2c(struct em28xx *dev)
 {
         struct v4l2_frequency f;
+        struct v4l2_routing route;
+
+        route.input = INPUT(dev->ctl_input)->vmux;
+        route.output = 0;
         em28xx_i2c_call_clients(dev, VIDIOC_INT_RESET, NULL);
-        em28xx_i2c_call_clients(dev, VIDIOC_S_INPUT, &dev->ctl_input);
+        em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
         em28xx_i2c_call_clients(dev, VIDIOC_STREAMON, NULL);
 
         /* configure tuner */
@@ -206,19 +210,19 @@ static void em28xx_empty_framequeues(struct em28xx *dev)
 
 static void video_mux(struct em28xx *dev, int index)
 {
-        int input, ainput;
+        int ainput;
+        struct v4l2_routing route;
 
-        input = INPUT(index)->vmux;
+        route.input = INPUT(index)->vmux;
+        route.output = 0;
         dev->ctl_input = index;
         dev->ctl_ainput = INPUT(index)->amux;
 
-        em28xx_i2c_call_clients(dev, VIDIOC_S_INPUT, &input);
+        em28xx_i2c_call_clients(dev, VIDIOC_INT_S_VIDEO_ROUTING, &route);
 
-        em28xx_videodbg("Setting input index=%d, vmux=%d, amux=%d\n",index,input,dev->ctl_ainput);
+        em28xx_videodbg("Setting input index=%d, vmux=%d, amux=%d\n",index,route.input,dev->ctl_ainput);
 
         if (dev->has_msp34xx) {
-                struct v4l2_routing route;
-
                 if (dev->i2s_speed)
                         em28xx_i2c_call_clients(dev, VIDIOC_INT_I2S_CLOCK_FREQ, &dev->i2s_speed);
                 route.input = dev->ctl_ainput;
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
index e1ddc2f27a2..d8fcc9e17ac 100644
--- a/drivers/media/video/em28xx/em28xx.h
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -3,7 +3,7 @@
 
    Copyright (C) 2005 Markus Rechberger <mrechberger@gmail.com>
                       Ludovico Cavedon <cavedon@sssup.it>
-                      Mauro Carvalho Chehab <mchehab@brturbo.com.br>
+                      Mauro Carvalho Chehab <mchehab@infradead.org>
 
    Based on the em2800 driver from Sascha Sommer <saschasommer@freenet.de>
 
@@ -319,13 +319,7 @@ int em28xx_audio_analog_set(struct em28xx *dev);
 int em28xx_colorlevels_set_default(struct em28xx *dev);
 int em28xx_capture_start(struct em28xx *dev, int start);
 int em28xx_outfmt_set_yuv422(struct em28xx *dev);
-int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax, u8 ymin,
-                           u8 ymax);
-int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
-                            u16 width, u16 height);
-int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v);
 int em28xx_resolution_set(struct em28xx *dev);
-void em28xx_isocIrq(struct urb *urb, struct pt_regs *regs);
 int em28xx_init_isoc(struct em28xx *dev);
 void em28xx_uninit_isoc(struct em28xx *dev);
 int em28xx_set_alternate(struct em28xx *dev);
diff --git a/drivers/media/video/et61x251/et61x251_core.c b/drivers/media/video/et61x251/et61x251_core.c
index dfc9dd732c9..8992b6e62b9 100644
--- a/drivers/media/video/et61x251/et61x251_core.c
+++ b/drivers/media/video/et61x251/et61x251_core.c
@@ -2341,11 +2341,9 @@ static int et61x251_ioctl_v4l2(struct inode* inode, struct file* filp,
         case VIDIOC_G_CTRL:
                 return et61x251_vidioc_g_ctrl(cam, arg);
 
-        case VIDIOC_S_CTRL_OLD:
         case VIDIOC_S_CTRL:
                 return et61x251_vidioc_s_ctrl(cam, arg);
 
-        case VIDIOC_CROPCAP_OLD:
         case VIDIOC_CROPCAP:
                 return et61x251_vidioc_cropcap(cam, arg);
 
@@ -2392,7 +2390,6 @@ static int et61x251_ioctl_v4l2(struct inode* inode, struct file* filp,
         case VIDIOC_G_PARM:
                 return et61x251_vidioc_g_parm(cam, arg);
 
-        case VIDIOC_S_PARM_OLD:
         case VIDIOC_S_PARM:
                 return et61x251_vidioc_s_parm(cam, arg);
 
diff --git a/drivers/media/video/ir-kbd-i2c.c b/drivers/media/video/ir-kbd-i2c.c
index 7e66d83fe0c..fba30a40e9c 100644
--- a/drivers/media/video/ir-kbd-i2c.c
+++ b/drivers/media/video/ir-kbd-i2c.c
@@ -150,12 +150,11 @@ static int get_key_knc1(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
         return 1;
 }
 
-/* The new pinnacle PCTV remote (with the colored buttons)
+/* Common (grey or coloured) pinnacle PCTV remote handling
  *
- * Ricardo Cerqueira <v4l@cerqueira.org>
  */
-
-int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+static int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw,
+                            int parity_offset, int marker, int code_modulo)
 {
         unsigned char b[4];
         unsigned int start = 0,parity = 0,code = 0;
@@ -167,9 +166,9 @@ int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
         }
 
         for (start = 0; start<4; start++) {
-                if (b[start] == 0x80) {
-                        code=b[(start+3)%4];
-                        parity=b[(start+2)%4];
+                if (b[start] == marker) {
+                        code=b[(start+parity_offset+1)%4];
+                        parity=b[(start+parity_offset)%4];
                 }
         }
 
@@ -181,16 +180,14 @@ int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
         if (ir->old == parity)
                 return 0;
 
-
         ir->old = parity;
 
-        /* Reduce code value to fit inside IR_KEYTAB_SIZE
-         *
-         * this is the only value that results in 42 unique
-         * codes < 128
-         */
+        /* drop special codes when a key is held down a long time for the grey controller
+           In this case, the second bit of the code is asserted */
+        if (marker == 0xfe && (code & 0x40))
+                return 0;
 
-        code %= 0x88;
+        code %= code_modulo;
 
         *ir_raw = code;
         *ir_key = code;
@@ -200,7 +197,40 @@ int get_key_pinnacle(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
         return 1;
 }
 
-EXPORT_SYMBOL_GPL(get_key_pinnacle);
+/* The grey pinnacle PCTV remote
+ *
+ *  There are one issue with this remote:
+ *   - I2c packet does not change when the same key is pressed quickly. The workaround
+ *     is to hold down each key for about half a second, so that another code is generated
+ *     in the i2c packet, and the function can distinguish key presses.
+ *
+ * Sylvain Pasche <sylvain.pasche@gmail.com>
+ */
+int get_key_pinnacle_grey(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+{
+
+        return get_key_pinnacle(ir, ir_key, ir_raw, 1, 0xfe, 0xff);
+}
+
+EXPORT_SYMBOL_GPL(get_key_pinnacle_grey);
+
+
+/* The new pinnacle PCTV remote (with the colored buttons)
+ *
+ * Ricardo Cerqueira <v4l@cerqueira.org>
+ */
+int get_key_pinnacle_color(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+{
+        /* code_modulo parameter (0x88) is used to reduce code value to fit inside IR_KEYTAB_SIZE
+         *
+         * this is the only value that results in 42 unique
+         * codes < 128
+         */
+
+        return get_key_pinnacle(ir, ir_key, ir_raw, 2, 0x80, 0x88);
+}
+
+EXPORT_SYMBOL_GPL(get_key_pinnacle_color);
 
 /* ----------------------------------------------------------------------- */
 
diff --git a/drivers/media/video/ks0127.c b/drivers/media/video/ks0127.c
new file mode 100644
index 00000000000..3bf7ac4f528
--- /dev/null
+++ b/drivers/media/video/ks0127.c
@@ -0,0 +1,846 @@
+/*
+ * Video Capture Driver (Video for Linux 1/2)
+ * for the Matrox Marvel G200,G400 and Rainbow Runner-G series
+ *
+ * This module is an interface to the KS0127 video decoder chip.
+ *
+ * Copyright (C) 1999  Ryan Drake <stiletto@mediaone.net>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ *****************************************************************************
+ *
+ * Modified and extended by
+ *      Mike Bernson <mike@mlb.org>
+ *      Gerard v.d. Horst
+ *      Leon van Stuivenberg <l.vanstuivenberg@chello.nl>
+ *      Gernot Ziegler <gz@lysator.liu.se>
+ *
+ * Version History:
+ * V1.0 Ryan Drake         Initial version by Ryan Drake
+ * V1.1 Gerard v.d. Horst  Added some debugoutput, reset the video-standard
+ */
+
+#ifndef __KERNEL__
+#define __KERNEL__
+#endif
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/proc_fs.h>
+#include "ks0127.h"
+
+#include <linux/i2c.h>
+#include <linux/video_decoder.h>
+
+#define dprintk     if (debug) printk
+
+/* i2c identification */
+#define I2C_KS0127_ADDON   0xD8
+#define I2C_KS0127_ONBOARD 0xDA
+
+#define KS_TYPE_UNKNOWN 0
+#define KS_TYPE_0122S   1
+#define KS_TYPE_0127    2
+#define KS_TYPE_0127B   3
+
+/* ks0127 control registers */
+#define KS_STAT     0x00
+#define KS_CMDA     0x01
+#define KS_CMDB     0x02
+#define KS_CMDC     0x03
+#define KS_CMDD     0x04
+#define KS_HAVB     0x05
+#define KS_HAVE     0x06
+#define KS_HS1B     0x07
+#define KS_HS1E     0x08
+#define KS_HS2B     0x09
+#define KS_HS2E     0x0a
+#define KS_AGC      0x0b
+#define KS_HXTRA    0x0c
+#define KS_CDEM     0x0d
+#define KS_PORTAB   0x0e
+#define KS_LUMA     0x0f
+#define KS_CON      0x10
+#define KS_BRT      0x11
+#define KS_CHROMA   0x12
+#define KS_CHROMB   0x13
+#define KS_DEMOD    0x14
+#define KS_SAT      0x15
+#define KS_HUE      0x16
+#define KS_VERTIA   0x17
+#define KS_VERTIB   0x18
+#define KS_VERTIC   0x19
+#define KS_HSCLL    0x1a
+#define KS_HSCLH    0x1b
+#define KS_VSCLL    0x1c
+#define KS_VSCLH    0x1d
+#define KS_OFMTA    0x1e
+#define KS_OFMTB    0x1f
+#define KS_VBICTL   0x20
+#define KS_CCDAT2   0x21
+#define KS_CCDAT1   0x22
+#define KS_VBIL30   0x23
+#define KS_VBIL74   0x24
+#define KS_VBIL118  0x25
+#define KS_VBIL1512 0x26
+#define KS_TTFRAM   0x27
+#define KS_TESTA    0x28
+#define KS_UVOFFH   0x29
+#define KS_UVOFFL   0x2a
+#define KS_UGAIN    0x2b
+#define KS_VGAIN    0x2c
+#define KS_VAVB     0x2d
+#define KS_VAVE     0x2e
+#define KS_CTRACK   0x2f
+#define KS_POLCTL   0x30
+#define KS_REFCOD   0x31
+#define KS_INVALY   0x32
+#define KS_INVALU   0x33
+#define KS_INVALV   0x34
+#define KS_UNUSEY   0x35
+#define KS_UNUSEU   0x36
+#define KS_UNUSEV   0x37
+#define KS_USRSAV   0x38
+#define KS_USREAV   0x39
+#define KS_SHS1A    0x3a
+#define KS_SHS1B    0x3b
+#define KS_SHS1C    0x3c
+#define KS_CMDE     0x3d
+#define KS_VSDEL    0x3e
+#define KS_CMDF     0x3f
+#define KS_GAMMA0   0x40
+#define KS_GAMMA1   0x41
+#define KS_GAMMA2   0x42
+#define KS_GAMMA3   0x43
+#define KS_GAMMA4   0x44
+#define KS_GAMMA5   0x45
+#define KS_GAMMA6   0x46
+#define KS_GAMMA7   0x47
+#define KS_GAMMA8   0x48
+#define KS_GAMMA9   0x49
+#define KS_GAMMA10  0x4a
+#define KS_GAMMA11  0x4b
+#define KS_GAMMA12  0x4c
+#define KS_GAMMA13  0x4d
+#define KS_GAMMA14  0x4e
+#define KS_GAMMA15  0x4f
+#define KS_GAMMA16  0x50
+#define KS_GAMMA17  0x51
+#define KS_GAMMA18  0x52
+#define KS_GAMMA19  0x53
+#define KS_GAMMA20  0x54
+#define KS_GAMMA21  0x55
+#define KS_GAMMA22  0x56
+#define KS_GAMMA23  0x57
+#define KS_GAMMA24  0x58
+#define KS_GAMMA25  0x59
+#define KS_GAMMA26  0x5a
+#define KS_GAMMA27  0x5b
+#define KS_GAMMA28  0x5c
+#define KS_GAMMA29  0x5d
+#define KS_GAMMA30  0x5e
+#define KS_GAMMA31  0x5f
+#define KS_GAMMAD0  0x60
+#define KS_GAMMAD1  0x61
+#define KS_GAMMAD2  0x62
+#define KS_GAMMAD3  0x63
+#define KS_GAMMAD4  0x64
+#define KS_GAMMAD5  0x65
+#define KS_GAMMAD6  0x66
+#define KS_GAMMAD7  0x67
+#define KS_GAMMAD8  0x68
+#define KS_GAMMAD9  0x69
+#define KS_GAMMAD10 0x6a
+#define KS_GAMMAD11 0x6b
+#define KS_GAMMAD12 0x6c
+#define KS_GAMMAD13 0x6d
+#define KS_GAMMAD14 0x6e
+#define KS_GAMMAD15 0x6f
+#define KS_GAMMAD16 0x70
+#define KS_GAMMAD17 0x71
+#define KS_GAMMAD18 0x72
+#define KS_GAMMAD19 0x73
+#define KS_GAMMAD20 0x74
+#define KS_GAMMAD21 0x75
+#define KS_GAMMAD22 0x76
+#define KS_GAMMAD23 0x77
+#define KS_GAMMAD24 0x78
+#define KS_GAMMAD25 0x79
+#define KS_GAMMAD26 0x7a
+#define KS_GAMMAD27 0x7b
+#define KS_GAMMAD28 0x7c
+#define KS_GAMMAD29 0x7d
+#define KS_GAMMAD30 0x7e
+#define KS_GAMMAD31 0x7f
+
+
+/****************************************************************************
+* mga_dev : represents one ks0127 chip.
+****************************************************************************/
+
+struct adjust {
+        int     contrast;
+        int     bright;
+        int     hue;
+        int     ugain;
+        int     vgain;
+};
+
+struct ks0127 {
+        struct i2c_client *client;
+        unsigned char   addr;
+        int             format_width;
+        int             format_height;
+        int             cap_width;
+        int             cap_height;
+        int             norm;
+        int             ks_type;
+        u8              regs[256];
+};
+
+
+static int debug; /* insmod parameter */
+
+module_param(debug, int, 0);
+MODULE_PARM_DESC(debug, "Debug output");
+MODULE_LICENSE("GPL");
+
+static u8 reg_defaults[64];
+
+
+
+static void init_reg_defaults(void)
+{
+        u8 *table = reg_defaults;
+
+        table[KS_CMDA]     = 0x2c;  /* VSE=0, CCIR 601, autodetect standard */
+        table[KS_CMDB]     = 0x12;  /* VALIGN=0, AGC control and input */
+        table[KS_CMDC]     = 0x00;  /* Test options */
+        /* clock & input select, write 1 to PORTA */
+        table[KS_CMDD]     = 0x01;
+        table[KS_HAVB]     = 0x00;  /* HAV Start Control */
+        table[KS_HAVE]     = 0x00;  /* HAV End Control */
+        table[KS_HS1B]     = 0x10;  /* HS1 Start Control */
+        table[KS_HS1E]     = 0x00;  /* HS1 End Control */
+        table[KS_HS2B]     = 0x00;  /* HS2 Start Control */
+        table[KS_HS2E]     = 0x00;  /* HS2 End Control */
+        table[KS_AGC]      = 0x53;  /* Manual setting for AGC */
+        table[KS_HXTRA]    = 0x00;  /* Extra Bits for HAV and HS1/2 */
+        table[KS_CDEM]     = 0x00;  /* Chroma Demodulation Control */
+        table[KS_PORTAB]   = 0x0f;  /* port B is input, port A output GPPORT */
+        table[KS_LUMA]     = 0x01;  /* Luma control */
+        table[KS_CON]      = 0x00;  /* Contrast Control */
+        table[KS_BRT]      = 0x00;  /* Brightness Control */
+        table[KS_CHROMA]   = 0x2a;  /* Chroma control A */
+        table[KS_CHROMB]   = 0x90;  /* Chroma control B */
+        table[KS_DEMOD]    = 0x00;  /* Chroma Demodulation Control & Status */
+        table[KS_SAT]      = 0x00;  /* Color Saturation Control*/
+        table[KS_HUE]      = 0x00;  /* Hue Control */
+        table[KS_VERTIA]   = 0x00;  /* Vertical Processing Control A */
+        /* Vertical Processing Control B, luma 1 line delayed */
+        table[KS_VERTIB]   = 0x12;
+        table[KS_VERTIC]   = 0x0b;  /* Vertical Processing Control C */
+        table[KS_HSCLL]    = 0x00;  /* Horizontal Scaling Ratio Low */
+        table[KS_HSCLH]    = 0x00;  /* Horizontal Scaling Ratio High */
+        table[KS_VSCLL]    = 0x00;  /* Vertical Scaling Ratio Low */
+        table[KS_VSCLH]    = 0x00;  /* Vertical Scaling Ratio High */
+        /* 16 bit YCbCr 4:2:2 output; I can't make the bt866 like 8 bit /Sam */
+        table[KS_OFMTA]    = 0x30;
+        table[KS_OFMTB]    = 0x00;  /* Output Control B */
+        /* VBI Decoder Control; 4bit fmt: avoid Y overflow */
+        table[KS_VBICTL]   = 0x5d;
+        table[KS_CCDAT2]   = 0x00;  /* Read Only register */
+        table[KS_CCDAT1]   = 0x00;  /* Read Only register */
+        table[KS_VBIL30]   = 0xa8;  /* VBI data decoding options */
+        table[KS_VBIL74]   = 0xaa;  /* VBI data decoding options */
+        table[KS_VBIL118]  = 0x2a;  /* VBI data decoding options */
+        table[KS_VBIL1512] = 0x00;  /* VBI data decoding options */
+        table[KS_TTFRAM]   = 0x00;  /* Teletext frame alignment pattern */
+        table[KS_TESTA]    = 0x00;  /* test register, shouldn't be written */
+        table[KS_UVOFFH]   = 0x00;  /* UV Offset Adjustment High */
+        table[KS_UVOFFL]   = 0x00;  /* UV Offset Adjustment Low */
+        table[KS_UGAIN]    = 0x00;  /* U Component Gain Adjustment */
+        table[KS_VGAIN]    = 0x00;  /* V Component Gain Adjustment */
+        table[KS_VAVB]     = 0x07;  /* VAV Begin */
+        table[KS_VAVE]     = 0x00;  /* VAV End */
+        table[KS_CTRACK]   = 0x00;  /* Chroma Tracking Control */
+        table[KS_POLCTL]   = 0x41;  /* Timing Signal Polarity Control */
+        table[KS_REFCOD]   = 0x80;  /* Reference Code Insertion Control */
+        table[KS_INVALY]   = 0x10;  /* Invalid Y Code */
+        table[KS_INVALU]   = 0x80;  /* Invalid U Code */
+        table[KS_INVALV]   = 0x80;  /* Invalid V Code */
+        table[KS_UNUSEY]   = 0x10;  /* Unused Y Code */
+        table[KS_UNUSEU]   = 0x80;  /* Unused U Code */
+        table[KS_UNUSEV]   = 0x80;  /* Unused V Code */
+        table[KS_USRSAV]   = 0x00;  /* reserved */
+        table[KS_USREAV]   = 0x00;  /* reserved */
+        table[KS_SHS1A]    = 0x00;  /* User Defined SHS1 A */
+        /* User Defined SHS1 B, ALT656=1 on 0127B */
+        table[KS_SHS1B]    = 0x80;
+        table[KS_SHS1C]    = 0x00;  /* User Defined SHS1 C */
+        table[KS_CMDE]     = 0x00;  /* Command Register E */
+        table[KS_VSDEL]    = 0x00;  /* VS Delay Control */
+        /* Command Register F, update -immediately- */
+        /* (there might come no vsync)*/
+        table[KS_CMDF]     = 0x02;
+}
+
+
+/* We need to manually read because of a bug in the KS0127 chip.
+ *
+ * An explanation from kayork@mail.utexas.edu:
+ *
+ * During I2C reads, the KS0127 only samples for a stop condition
+ * during the place where the acknoledge bit should be. Any standard
+ * I2C implementation (correctly) throws in another clock transition
+ * at the 9th bit, and the KS0127 will not recognize the stop condition
+ * and will continue to clock out data.
+ *
+ * So we have to do the read ourself.  Big deal.
+           workaround in i2c-algo-bit
+ */
+
+
+static u8 ks0127_read(struct ks0127 *ks, u8 reg)
+{
+        struct i2c_client *c = ks->client;
+        char val = 0;
+        struct i2c_msg msgs[] = {
+                {c->addr, 0, sizeof(reg), &reg},
+                {c->addr, I2C_M_RD | I2C_M_NO_RD_ACK, sizeof(val), &val}};
+        int ret;
+
+        ret = i2c_transfer(c->adapter, msgs, ARRAY_SIZE(msgs));
+        if (ret != ARRAY_SIZE(msgs))
+                dprintk("ks0127_write error\n");
+
+        return val;
+}
+
+
+static void ks0127_write(struct ks0127 *ks, u8 reg, u8 val)
+{
+        char msg[] = {reg, val};
+
+        if (i2c_master_send(ks->client, msg, sizeof(msg)) != sizeof(msg))
+                dprintk("ks0127_write error\n");
+
+        ks->regs[reg] = val;
+}
+
+
+/* generic bit-twiddling */
+static void ks0127_and_or(struct ks0127 *ks, u8 reg, u8 and_v, u8 or_v)
+{
+        u8 val = ks->regs[reg];
+        val = (val & and_v) | or_v;
+        ks0127_write(ks, reg, val);
+}
+
+
+
+/****************************************************************************
+* ks0127 private api
+****************************************************************************/
+static void ks0127_reset(struct ks0127* ks)
+{
+        int i;
+        u8 *table = reg_defaults;
+
+        ks->ks_type = KS_TYPE_UNKNOWN;
+
+        dprintk("ks0127: reset\n");
+        msleep(1);
+
+        /* initialize all registers to known values */
+        /* (except STAT, 0x21, 0x22, TEST and 0x38,0x39) */
+
+        for(i = 1; i < 33; i++)
+                ks0127_write(ks, i, table[i]);
+
+        for(i = 35; i < 40; i++)
+                ks0127_write(ks, i, table[i]);
+
+        for(i = 41; i < 56; i++)
+                ks0127_write(ks, i, table[i]);
+
+        for(i = 58; i < 64; i++)
+                ks0127_write(ks, i, table[i]);
+
+
+        if ((ks0127_read(ks, KS_STAT) & 0x80) == 0) {
+                ks->ks_type = KS_TYPE_0122S;
+                dprintk("ks0127: ks0122s Found\n");
+                return;
+        }
+
+        switch(ks0127_read(ks, KS_CMDE) & 0x0f) {
+
+        case 0:
+                ks->ks_type = KS_TYPE_0127;
+                dprintk("ks0127: ks0127 found\n");
+                break;
+
+        case 9:
+                ks->ks_type = KS_TYPE_0127B;
+                dprintk("ks0127: ks0127B Revision A found\n");
+                break;
+
+        default:
+                dprintk("ks0127: unknown revision\n");
+                break;
+        }
+}
+
+static int ks0127_command(struct i2c_client *client,
+                          unsigned int cmd, void *arg)
+{
+        struct ks0127 *ks = i2c_get_clientdata(client);
+
+        int             *iarg = (int*)arg;
+
+        int             status;
+
+        if (!ks)
+                return -ENODEV;
+
+        switch (cmd) {
+
+        case DECODER_INIT:
+                dprintk("ks0127: command DECODER_INIT\n");
+                ks0127_reset(ks);
+                break;
+
+        case DECODER_SET_INPUT:
+                switch(*iarg) {
+                case KS_INPUT_COMPOSITE_1:
+                case KS_INPUT_COMPOSITE_2:
+                case KS_INPUT_COMPOSITE_3:
+                case KS_INPUT_COMPOSITE_4:
+                case KS_INPUT_COMPOSITE_5:
+                case KS_INPUT_COMPOSITE_6:
+                        dprintk("ks0127: command DECODER_SET_INPUT %d: "
+                                "Composite\n", *iarg);
+                        /* autodetect 50/60 Hz */
+                        ks0127_and_or(ks, KS_CMDA,   0xfc, 0x00);
+                        /* VSE=0 */
+                        ks0127_and_or(ks, KS_CMDA,   ~0x40, 0x00);
+                        /* set input line */
+                        ks0127_and_or(ks, KS_CMDB,   0xb0, *iarg);
+                        /* non-freerunning mode */
+                        ks0127_and_or(ks, KS_CMDC,   0x70, 0x0a);
+                        /* analog input */
+                        ks0127_and_or(ks, KS_CMDD,   0x03, 0x00);
+                        /* enable chroma demodulation */
+                        ks0127_and_or(ks, KS_CTRACK, 0xcf, 0x00);
+                        /* chroma trap, HYBWR=1 */
+                        ks0127_and_or(ks, KS_LUMA,   0x00,
+                                       (reg_defaults[KS_LUMA])|0x0c);
+                        /* scaler fullbw, luma comb off */
+                        ks0127_and_or(ks, KS_VERTIA, 0x08, 0x81);
+                        /* manual chroma comb .25 .5 .25 */
+                        ks0127_and_or(ks, KS_VERTIC, 0x0f, 0x90);
+
+                        /* chroma path delay */
+                        ks0127_and_or(ks, KS_CHROMB, 0x0f, 0x90);
+
+                        ks0127_write(ks, KS_UGAIN, reg_defaults[KS_UGAIN]);
+                        ks0127_write(ks, KS_VGAIN, reg_defaults[KS_VGAIN]);
+                        ks0127_write(ks, KS_UVOFFH, reg_defaults[KS_UVOFFH]);
+                        ks0127_write(ks, KS_UVOFFL, reg_defaults[KS_UVOFFL]);
+                        break;
+
+                case KS_INPUT_SVIDEO_1:
+                case KS_INPUT_SVIDEO_2:
+                case KS_INPUT_SVIDEO_3:
+                        dprintk("ks0127: command DECODER_SET_INPUT %d: "
+                                "S-Video\n", *iarg);
+                        /* autodetect 50/60 Hz */
+                        ks0127_and_or(ks, KS_CMDA,   0xfc, 0x00);
+                        /* VSE=0 */
+                        ks0127_and_or(ks, KS_CMDA,   ~0x40, 0x00);
+                        /* set input line */
+                        ks0127_and_or(ks, KS_CMDB,   0xb0, *iarg);
+                        /* non-freerunning mode */
+                        ks0127_and_or(ks, KS_CMDC,   0x70, 0x0a);
+                        /* analog input */
+                        ks0127_and_or(ks, KS_CMDD,   0x03, 0x00);
+                        /* enable chroma demodulation */
+                        ks0127_and_or(ks, KS_CTRACK, 0xcf, 0x00);
+                        ks0127_and_or(ks, KS_LUMA, 0x00,
+                                       reg_defaults[KS_LUMA]);
+                        /* disable luma comb */
+                        ks0127_and_or(ks, KS_VERTIA, 0x08,
+                                       (reg_defaults[KS_VERTIA]&0xf0)|0x01);
+                        ks0127_and_or(ks, KS_VERTIC, 0x0f,
+                                       reg_defaults[KS_VERTIC]&0xf0);
+
+                        ks0127_and_or(ks, KS_CHROMB, 0x0f,
+                                       reg_defaults[KS_CHROMB]&0xf0);
+
+                        ks0127_write(ks, KS_UGAIN, reg_defaults[KS_UGAIN]);
+                        ks0127_write(ks, KS_VGAIN, reg_defaults[KS_VGAIN]);
+                        ks0127_write(ks, KS_UVOFFH, reg_defaults[KS_UVOFFH]);
+                        ks0127_write(ks, KS_UVOFFL, reg_defaults[KS_UVOFFL]);
+                        break;
+
+                case KS_INPUT_YUV656:
+                        dprintk("ks0127: command DECODER_SET_INPUT 15: "
+                                "YUV656\n");
+                        if (ks->norm == VIDEO_MODE_NTSC ||
+                            ks->norm == KS_STD_PAL_M)
+                                /* force 60 Hz */
+                                ks0127_and_or(ks, KS_CMDA,   0xfc, 0x03);
+                        else
+                                /* force 50 Hz */
+                                ks0127_and_or(ks, KS_CMDA,   0xfc, 0x02);
+
+                        ks0127_and_or(ks, KS_CMDA,   0xff, 0x40); /* VSE=1 */
+                        /* set input line and VALIGN */
+                        ks0127_and_or(ks, KS_CMDB,   0xb0, (*iarg | 0x40));
+                        /* freerunning mode, */
+                        /* TSTGEN = 1 TSTGFR=11 TSTGPH=0 TSTGPK=0  VMEM=1*/
+                        ks0127_and_or(ks, KS_CMDC,   0x70, 0x87);
+                        /* digital input, SYNDIR = 0 INPSL=01 CLKDIR=0 EAV=0 */
+                        ks0127_and_or(ks, KS_CMDD,   0x03, 0x08);
+                        /* disable chroma demodulation */
+                        ks0127_and_or(ks, KS_CTRACK, 0xcf, 0x30);
+                        /* HYPK =01 CTRAP = 0 HYBWR=0 PED=1 RGBH=1 UNIT=1 */
+                        ks0127_and_or(ks, KS_LUMA,   0x00, 0x71);
+                        ks0127_and_or(ks, KS_VERTIC, 0x0f,
+                                       reg_defaults[KS_VERTIC]&0xf0);
+
+                        /* scaler fullbw, luma comb off */
+                        ks0127_and_or(ks, KS_VERTIA, 0x08, 0x81);
+
+                        ks0127_and_or(ks, KS_CHROMB, 0x0f,
+                                       reg_defaults[KS_CHROMB]&0xf0);
+
+                        ks0127_and_or(ks, KS_CON, 0x00, 0x00);
+                        ks0127_and_or(ks, KS_BRT, 0x00, 32);    /* spec: 34 */
+                                /* spec: 229 (e5) */
+                        ks0127_and_or(ks, KS_SAT, 0x00, 0xe8);
+                        ks0127_and_or(ks, KS_HUE, 0x00, 0);
+
+                        ks0127_and_or(ks, KS_UGAIN, 0x00, 238);
+                        ks0127_and_or(ks, KS_VGAIN, 0x00, 0x00);
+
+                        /*UOFF:0x30, VOFF:0x30, TSTCGN=1 */
+                        ks0127_and_or(ks, KS_UVOFFH, 0x00, 0x4f);
+                        ks0127_and_or(ks, KS_UVOFFL, 0x00, 0x00);
+                        break;
+
+                default:
+                        dprintk("ks0127: command DECODER_SET_INPUT: "
+                                "Unknown input %d\n", *iarg);
+                        break;
+                }
+
+                /* hack: CDMLPF sometimes spontaneously switches on; */
+                /* force back off */
+                ks0127_write(ks, KS_DEMOD, reg_defaults[KS_DEMOD]);
+                break;
+
+        case DECODER_SET_OUTPUT:
+                switch(*iarg) {
+                case KS_OUTPUT_YUV656E:
+                        dprintk("ks0127: command DECODER_SET_OUTPUT: "
+                                "OUTPUT_YUV656E (Missing)\n");
+                        return -EINVAL;
+                        break;
+
+                case KS_OUTPUT_EXV:
+                        dprintk("ks0127: command DECODER_SET_OUTPUT: "
+                                "OUTPUT_EXV\n");
+                        ks0127_and_or(ks, KS_OFMTA, 0xf0, 0x09);
+                        break;
+                }
+                break;
+
+        case DECODER_SET_NORM: //sam This block mixes old and new norm names...
+                /* Set to automatic SECAM/Fsc mode */
+                ks0127_and_or(ks, KS_DEMOD, 0xf0, 0x00);
+
+                ks->norm = *iarg;
+                switch(*iarg)
+                {
+                /* this is untested !! */
+                /* It just detects PAL_N/NTSC_M (no special frequencies) */
+                /* And you have to set the standard a second time afterwards */
+                case VIDEO_MODE_AUTO:
+                        dprintk("ks0127: command DECODER_SET_NORM: AUTO\n");
+
+                        /* The chip determines the format */
+                        /* based on the current field rate */
+                        ks0127_and_or(ks, KS_CMDA,   0xfc, 0x00);
+                        ks0127_and_or(ks, KS_CHROMA, 0x9f, 0x20);
+                        /* This is wrong for PAL ! As I said, */
+                        /* you need to set the standard once again !! */
+                        ks->format_height = 240;
+                        ks->format_width = 704;
+                        break;
+
+                case VIDEO_MODE_NTSC:
+                        dprintk("ks0127: command DECODER_SET_NORM: NTSC_M\n");
+                        ks0127_and_or(ks, KS_CHROMA, 0x9f, 0x20);
+                        ks->format_height = 240;
+                        ks->format_width = 704;
+                        break;
+
+                case KS_STD_NTSC_N:
+                        dprintk("ks0127: command KS0127_SET_STANDARD: "
+                                "NTSC_N (fixme)\n");
+                        ks0127_and_or(ks, KS_CHROMA, 0x9f, 0x40);
+                        ks->format_height = 240;
+                        ks->format_width = 704;
+                        break;
+
+                case VIDEO_MODE_PAL:
+                        dprintk("ks0127: command DECODER_SET_NORM: PAL_N\n");
+                        ks0127_and_or(ks, KS_CHROMA, 0x9f, 0x20);
+                        ks->format_height = 290;
+                        ks->format_width = 704;
+                        break;
+
+                case KS_STD_PAL_M:
+                        dprintk("ks0127: command KS0127_SET_STANDARD: "
+                                "PAL_M (fixme)\n");
+                        ks0127_and_or(ks, KS_CHROMA, 0x9f, 0x40);
+                        ks->format_height = 290;
+                        ks->format_width = 704;
+                        break;
+
+                case VIDEO_MODE_SECAM:
+                        dprintk("ks0127: command KS0127_SET_STANDARD: "
+                                "SECAM\n");
+                        ks->format_height = 290;
+                        ks->format_width = 704;
+
+                        /* set to secam autodetection */
+                        ks0127_and_or(ks, KS_CHROMA, 0xdf, 0x20);
+                        ks0127_and_or(ks, KS_DEMOD, 0xf0, 0x00);
+                        schedule_timeout_interruptible(HZ/10+1);
+
+                        /* did it autodetect? */
+                        if (ks0127_read(ks, KS_DEMOD) & 0x40)
+                                break;
+
+                        /* force to secam mode */
+                        ks0127_and_or(ks, KS_DEMOD, 0xf0, 0x0f);
+                        break;
+
+                default:
+                        dprintk("ks0127: command DECODER_SET_NORM: "
+                                "Unknown norm %d\n", *iarg);
+                        break;
+                }
+                break;
+
+        case DECODER_SET_PICTURE:
+                dprintk("ks0127: command DECODER_SET_PICTURE "
+                        "not yet supported (fixme)\n");
+                return -EINVAL;
+
+        //sam todo: KS0127_SET_BRIGHTNESS: Merge into DECODER_SET_PICTURE
+        //sam todo: KS0127_SET_CONTRAST: Merge into DECODER_SET_PICTURE
+        //sam todo: KS0127_SET_HUE: Merge into DECODER_SET_PICTURE?
+        //sam todo: KS0127_SET_SATURATION: Merge into DECODER_SET_PICTURE
+        //sam todo: KS0127_SET_AGC_MODE:
+        //sam todo: KS0127_SET_AGC:
+        //sam todo: KS0127_SET_CHROMA_MODE:
+        //sam todo: KS0127_SET_PIXCLK_MODE:
+        //sam todo: KS0127_SET_GAMMA_MODE:
+        //sam todo: KS0127_SET_UGAIN:
+        //sam todo: KS0127_SET_VGAIN:
+        //sam todo: KS0127_SET_INVALY:
+        //sam todo: KS0127_SET_INVALU:
+        //sam todo: KS0127_SET_INVALV:
+        //sam todo: KS0127_SET_UNUSEY:
+        //sam todo: KS0127_SET_UNUSEU:
+        //sam todo: KS0127_SET_UNUSEV:
+        //sam todo: KS0127_SET_VSALIGN_MODE:
+
+        case DECODER_ENABLE_OUTPUT:
+        {
+
+                int *iarg = arg;
+                int enable = (*iarg != 0);
+                        if (enable) {
+                                dprintk("ks0127: command "
+                                        "DECODER_ENABLE_OUTPUT on "
+                                        "(%d)\n", enable);
+                                /* All output pins on */
+                                ks0127_and_or(ks, KS_OFMTA, 0xcf, 0x30);
+                                /* Obey the OEN pin */
+                                ks0127_and_or(ks, KS_CDEM, 0x7f, 0x00);
+                        } else {
+                                dprintk("ks0127: command "
+                                        "DECODER_ENABLE_OUTPUT off "
+                                        "(%d)\n", enable);
+                                /* Video output pins off */
+                                ks0127_and_or(ks, KS_OFMTA, 0xcf, 0x00);
+                                /* Ignore the OEN pin */
+                                ks0127_and_or(ks, KS_CDEM, 0x7f, 0x80);
+                        }
+        }
+                break;
+
+        //sam todo: KS0127_SET_OUTPUT_MODE:
+        //sam todo: KS0127_SET_WIDTH:
+        //sam todo: KS0127_SET_HEIGHT:
+        //sam todo: KS0127_SET_HSCALE:
+
+        case DECODER_GET_STATUS:
+                dprintk("ks0127: command DECODER_GET_STATUS\n");
+                *iarg = 0;
+                status = ks0127_read(ks, KS_STAT);
+                if (!(status & 0x20))            /* NOVID not set */
+                        *iarg = (*iarg & DECODER_STATUS_GOOD);
+                if ((status & 0x01))                  /* CLOCK set */
+                        *iarg = (*iarg & DECODER_STATUS_COLOR);
+                if ((status & 0x08))               /* PALDET set */
+                        *iarg = (*iarg & DECODER_STATUS_PAL);
+                else
+                        *iarg = (*iarg & DECODER_STATUS_NTSC);
+                break;
+
+        //Catch any unknown command
+        default:
+                dprintk("ks0127: command unknown: %04X\n", cmd);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+
+
+
+static int ks0127_probe(struct i2c_adapter *adapter);
+static int ks0127_detach(struct i2c_client *client);
+static int ks0127_command(struct i2c_client *client,
+                          unsigned int cmd, void *arg);
+
+
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = {I2C_KS0127_ADDON>>1,
+                                       I2C_KS0127_ONBOARD>>1, I2C_CLIENT_END};
+static unsigned short probe[2] =        {I2C_CLIENT_END, I2C_CLIENT_END};
+static unsigned short ignore[2] =       {I2C_CLIENT_END, I2C_CLIENT_END};
+static struct i2c_client_address_data addr_data = {
+        normal_i2c,
+        probe,
+        ignore,
+};
+
+static struct i2c_driver i2c_driver_ks0127 = {
+        .driver.name = "ks0127",
+        .id             = I2C_DRIVERID_KS0127,
+        .attach_adapter = ks0127_probe,
+        .detach_client  = ks0127_detach,
+        .command        = ks0127_command
+};
+
+static struct i2c_client ks0127_client_tmpl =
+{
+        .name = "(ks0127 unset)",
+        .addr = 0,
+        .adapter = NULL,
+        .driver = &i2c_driver_ks0127,
+        .usage_count = 0
+};
+
+static int ks0127_found_proc(struct i2c_adapter *adapter, int addr, int kind)
+{
+        struct ks0127 *ks;
+        struct i2c_client *client;
+
+        client = kzalloc(sizeof(*client), GFP_KERNEL);
+        if (client == NULL)
+                return -ENOMEM;
+        memcpy(client, &ks0127_client_tmpl, sizeof(*client));
+
+        ks = kzalloc(sizeof(*ks), GFP_KERNEL);
+        if (ks == NULL) {
+                kfree(client);
+                return -ENOMEM;
+        }
+
+        i2c_set_clientdata(client, ks);
+        client->adapter = adapter;
+        client->addr = addr;
+        sprintf(client->name, "ks0127-%02x", adapter->id);
+
+        ks->client = client;
+        ks->addr = addr;
+        ks->ks_type = KS_TYPE_UNKNOWN;
+
+        /* power up */
+        ks0127_write(ks, KS_CMDA, 0x2c);
+        mdelay(10);
+
+        /* reset the device */
+        ks0127_reset(ks);
+        printk(KERN_INFO "ks0127: attach: %s video decoder\n",
+               ks->addr==(I2C_KS0127_ADDON>>1) ? "addon" : "on-board");
+
+        i2c_attach_client(client);
+        return 0;
+}
+
+
+static int ks0127_probe(struct i2c_adapter *adapter)
+{
+        if (adapter->id == I2C_HW_B_ZR36067)
+                return i2c_probe(adapter, &addr_data, ks0127_found_proc);
+        return 0;
+}
+
+static int ks0127_detach(struct i2c_client *client)
+{
+        struct ks0127 *ks = i2c_get_clientdata(client);
+
+        ks0127_write(ks, KS_OFMTA, 0x20); /*tristate*/
+        ks0127_write(ks, KS_CMDA, 0x2c | 0x80); /* power down */
+
+        i2c_detach_client(client);
+        kfree(ks);
+        kfree(client);
+
+        dprintk("ks0127: detach\n");
+        return 0;
+}
+
+
+static int __devinit ks0127_init_module(void)
+{
+        init_reg_defaults();
+        i2c_add_driver(&i2c_driver_ks0127);
+        return 0;
+}
+
+static void __devexit ks0127_cleanup_module(void)
+{
+        i2c_del_driver(&i2c_driver_ks0127);
+}
+
+
+module_init(ks0127_init_module);
+module_exit(ks0127_cleanup_module);
diff --git a/drivers/media/video/ks0127.h b/drivers/media/video/ks0127.h
new file mode 100644
index 00000000000..1ec578833ae
--- /dev/null
+++ b/drivers/media/video/ks0127.h
@@ -0,0 +1,53 @@
+/*
+ * Video Capture Driver ( Video for Linux 1/2 )
+ * for the Matrox Marvel G200,G400 and Rainbow Runner-G series
+ *
+ * This module is an interface to the KS0127 video decoder chip.
+ *
+ * Copyright (C) 1999  Ryan Drake <stiletto@mediaone.net>
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifndef KS0127_H
+#define KS0127_H
+
+#include <linux/videodev.h>
+
+/* input channels */
+#define KS_INPUT_COMPOSITE_1    0
+#define KS_INPUT_COMPOSITE_2    1
+#define KS_INPUT_COMPOSITE_3    2
+#define KS_INPUT_COMPOSITE_4    4
+#define KS_INPUT_COMPOSITE_5    5
+#define KS_INPUT_COMPOSITE_6    6
+
+#define KS_INPUT_SVIDEO_1       8
+#define KS_INPUT_SVIDEO_2       9
+#define KS_INPUT_SVIDEO_3       10
+
+#define KS_INPUT_YUV656         15
+#define KS_INPUT_COUNT          10
+
+/* output channels */
+#define KS_OUTPUT_YUV656E       0
+#define KS_OUTPUT_EXV           1
+
+/* video standards */
+#define KS_STD_NTSC_N           112       /* 50 Hz NTSC */
+#define KS_STD_PAL_M            113       /* 60 Hz PAL  */
+
+#endif /* KS0127_H */
+
diff --git a/drivers/media/video/meye.c b/drivers/media/video/meye.c
index 850bee97090..f68ca7d9f53 100644
--- a/drivers/media/video/meye.c
+++ b/drivers/media/video/meye.c
@@ -32,6 +32,7 @@
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <linux/delay.h>
@@ -1682,13 +1683,13 @@ static unsigned int meye_poll(struct file *file, poll_table *wait)
 
 static void meye_vm_open(struct vm_area_struct *vma)
 {
-        int idx = (int)vma->vm_private_data;
+        long idx = (long)vma->vm_private_data;
         meye.vma_use_count[idx]++;
 }
 
 static void meye_vm_close(struct vm_area_struct *vma)
 {
-        int idx = (int)vma->vm_private_data;
+        long idx = (long)vma->vm_private_data;
         meye.vma_use_count[idx]--;
 }
 
diff --git a/drivers/media/video/msp3400-driver.c b/drivers/media/video/msp3400-driver.c
index b806999d6e0..dbb75a7db19 100644
--- a/drivers/media/video/msp3400-driver.c
+++ b/drivers/media/video/msp3400-driver.c
@@ -385,67 +385,6 @@ static int msp_mode_v4l1_to_v4l2(int mode)
         return V4L2_TUNER_MODE_MONO;
 }
 
-static struct v4l2_queryctrl msp_qctrl_std[] = {
-        {
-                .id            = V4L2_CID_AUDIO_VOLUME,
-                .name          = "Volume",
-                .minimum       = 0,
-                .maximum       = 65535,
-                .step          = 65535/100,
-                .default_value = 58880,
-                .flags         = 0,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-        },{
-                .id            = V4L2_CID_AUDIO_MUTE,
-                .name          = "Mute",
-                .minimum       = 0,
-                .maximum       = 1,
-                .step          = 1,
-                .default_value = 1,
-                .flags         = 0,
-                .type          = V4L2_CTRL_TYPE_BOOLEAN,
-        },
-};
-
-static struct v4l2_queryctrl msp_qctrl_sound_processing[] = {
-        {
-                .id            = V4L2_CID_AUDIO_BALANCE,
-                .name          = "Balance",
-                .minimum       = 0,
-                .maximum       = 65535,
-                .step          = 65535/100,
-                .default_value = 32768,
-                .flags         = 0,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-        },{
-                .id            = V4L2_CID_AUDIO_BASS,
-                .name          = "Bass",
-                .minimum       = 0,
-                .maximum       = 65535,
-                .step          = 65535/100,
-                .default_value = 32768,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-        },{
-                .id            = V4L2_CID_AUDIO_TREBLE,
-                .name          = "Treble",
-                .minimum       = 0,
-                .maximum       = 65535,
-                .step          = 65535/100,
-                .default_value = 32768,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-        },{
-                .id            = V4L2_CID_AUDIO_LOUDNESS,
-                .name          = "Loudness",
-                .minimum       = 0,
-                .maximum       = 1,
-                .step          = 1,
-                .default_value = 1,
-                .flags         = 0,
-                .type          = V4L2_CTRL_TYPE_BOOLEAN,
-        },
-};
-
-
 static int msp_get_ctrl(struct i2c_client *client, struct v4l2_control *ctrl)
 {
         struct msp_state *state = i2c_get_clientdata(client);
@@ -674,22 +613,31 @@ static int msp_command(struct i2c_client *client, unsigned int cmd, void *arg)
                 int sc1_out = rt->output & 0xf;
                 int sc2_out = (rt->output >> 4) & 0xf;
                 u16 val, reg;
+                int i;
+                int extern_input = 1;
 
                 if (state->routing.input == rt->input &&
                     state->routing.output == rt->output)
                         break;
                 state->routing = *rt;
+                /* check if the tuner input is used */
+                for (i = 0; i < 5; i++) {
+                        if (((rt->input >> (4 + i * 4)) & 0xf) == 0)
+                                extern_input = 0;
+                }
+                if (extern_input)
+                        state->mode = MSP_MODE_EXTERN;
+                else
+                        state->mode = MSP_MODE_AM_DETECT;
                 msp_set_scart(client, sc_in, 0);
                 msp_set_scart(client, sc1_out, 1);
                 msp_set_scart(client, sc2_out, 2);
                 msp_set_audmode(client);
                 reg = (state->opmode == OPMODE_AUTOSELECT) ? 0x30 : 0xbb;
                 val = msp_read_dem(client, reg);
-                if (tuner != ((val >> 8) & 1)) {
-                        msp_write_dem(client, reg, (val & ~0x100) | (tuner << 8));
-                        /* wake thread when a new tuner input is chosen */
-                        msp_wake_thread(client);
-                }
+                msp_write_dem(client, reg, (val & ~0x100) | (tuner << 8));
+                /* wake thread when a new input is chosen */
+                msp_wake_thread(client);
                 break;
         }
 
@@ -744,21 +692,25 @@ static int msp_command(struct i2c_client *client, unsigned int cmd, void *arg)
         case VIDIOC_QUERYCTRL:
         {
                 struct v4l2_queryctrl *qc = arg;
-                int i;
 
-                for (i = 0; i < ARRAY_SIZE(msp_qctrl_std); i++)
-                        if (qc->id && qc->id == msp_qctrl_std[i].id) {
-                                memcpy(qc, &msp_qctrl_std[i], sizeof(*qc));
-                                return 0;
-                        }
+                switch (qc->id) {
+                        case V4L2_CID_AUDIO_VOLUME:
+                        case V4L2_CID_AUDIO_MUTE:
+                                return v4l2_ctrl_query_fill_std(qc);
+                        default:
+                                break;
+                }
                 if (!state->has_sound_processing)
                         return -EINVAL;
-                for (i = 0; i < ARRAY_SIZE(msp_qctrl_sound_processing); i++)
-                        if (qc->id && qc->id == msp_qctrl_sound_processing[i].id) {
-                                memcpy(qc, &msp_qctrl_sound_processing[i], sizeof(*qc));
-                                return 0;
-                        }
-                return -EINVAL;
+                switch (qc->id) {
+                        case V4L2_CID_AUDIO_LOUDNESS:
+                        case V4L2_CID_AUDIO_BALANCE:
+                        case V4L2_CID_AUDIO_BASS:
+                        case V4L2_CID_AUDIO_TREBLE:
+                                return v4l2_ctrl_query_fill_std(qc);
+                        default:
+                                return -EINVAL;
+                }
         }
 
         case VIDIOC_G_CTRL:
@@ -794,7 +746,9 @@ static int msp_command(struct i2c_client *client, unsigned int cmd, void *arg)
                 case MSP_MODE_EXTERN: p = "External input"; break;
                 default: p = "unknown"; break;
                 }
-                if (state->opmode == OPMODE_MANUAL) {
+                if (state->mode == MSP_MODE_EXTERN) {
+                        v4l_info(client, "Mode:     %s\n", p);
+                } else if (state->opmode == OPMODE_MANUAL) {
                         v4l_info(client, "Mode:     %s (%s%s)\n", p,
                                 (state->rxsubchans & V4L2_TUNER_SUB_STEREO) ? "stereo" : "mono",
                                 (state->rxsubchans & V4L2_TUNER_SUB_LANG2) ? ", dual" : "");
diff --git a/drivers/media/video/msp3400-kthreads.c b/drivers/media/video/msp3400-kthreads.c
index 633a1021378..f2fd9195b3a 100644
--- a/drivers/media/video/msp3400-kthreads.c
+++ b/drivers/media/video/msp3400-kthreads.c
@@ -244,19 +244,21 @@ static void msp3400c_set_audmode(struct i2c_client *client)
            the hardware does not support SAP. So the rxsubchans combination
            of STEREO | LANG2 does not occur. */
 
-        /* switch to mono if only mono is available */
-        if (state->rxsubchans == V4L2_TUNER_SUB_MONO)
-                audmode = V4L2_TUNER_MODE_MONO;
-        /* if bilingual */
-        else if (state->rxsubchans & V4L2_TUNER_SUB_LANG2) {
-                /* and mono or stereo, then fallback to lang1 */
-                if (audmode == V4L2_TUNER_MODE_MONO ||
-                    audmode == V4L2_TUNER_MODE_STEREO)
-                        audmode = V4L2_TUNER_MODE_LANG1;
+        if (state->mode != MSP_MODE_EXTERN) {
+                /* switch to mono if only mono is available */
+                if (state->rxsubchans == V4L2_TUNER_SUB_MONO)
+                        audmode = V4L2_TUNER_MODE_MONO;
+                /* if bilingual */
+                else if (state->rxsubchans & V4L2_TUNER_SUB_LANG2) {
+                        /* and mono or stereo, then fallback to lang1 */
+                        if (audmode == V4L2_TUNER_MODE_MONO ||
+                            audmode == V4L2_TUNER_MODE_STEREO)
+                                audmode = V4L2_TUNER_MODE_LANG1;
+                }
+                /* if stereo, and audmode is not mono, then switch to stereo */
+                else if (audmode != V4L2_TUNER_MODE_MONO)
+                        audmode = V4L2_TUNER_MODE_STEREO;
         }
-        /* if stereo, and audmode is not mono, then switch to stereo */
-        else if (audmode != V4L2_TUNER_MODE_MONO)
-                audmode = V4L2_TUNER_MODE_STEREO;
 
         /* switch demodulator */
         switch (state->mode) {
@@ -481,6 +483,7 @@ int msp3400c_thread(void *data)
                         /* no carrier scan, just unmute */
                         v4l_dbg(1, msp_debug, client, "thread: no carrier scan\n");
                         state->scan_in_progress = 0;
+                        state->rxsubchans = V4L2_TUNER_SUB_STEREO;
                         msp_set_audio(client);
                         continue;
                 }
@@ -947,6 +950,14 @@ int msp34xxg_thread(void *data)
                 if (kthread_should_stop())
                         break;
 
+                if (state->mode == MSP_MODE_EXTERN) {
+                        /* no carrier scan needed, just unmute */
+                        v4l_dbg(1, msp_debug, client, "thread: no carrier scan\n");
+                        state->scan_in_progress = 0;
+                        msp_set_audio(client);
+                        continue;
+                }
+
                 /* setup the chip*/
                 msp34xxg_reset(client);
                 state->std = state->radio ? 0x40 : msp_standard;
@@ -978,6 +989,11 @@ int msp34xxg_thread(void *data)
                 v4l_dbg(1, msp_debug, client, "detected standard: %s (0x%04x)\n",
                         msp_standard_std_name(state->std), state->std);
 
+                if (state->std == 9) {
+                        /* AM NICAM mode */
+                        msp_write_dsp(client, 0x0e, 0x7c00);
+                }
+
                 /* unmute: dispatch sound to scart output, set scart volume */
                 msp_set_audio(client);
 
diff --git a/drivers/media/video/ov511.c b/drivers/media/video/ov511.c
index fdc8e3f1393..a988df226aa 100644
--- a/drivers/media/video/ov511.c
+++ b/drivers/media/video/ov511.c
@@ -3239,7 +3239,7 @@ ov511_move_data(struct usb_ov511 *ov, unsigned char *in, int n)
                 RESTRICT_TO_RANGE(frame->bytes_recvd, 8, max_raw);
 
                 if (frame->scanstate == STATE_LINES) {
-                        int nextf;
+                        int nextf;
 
                         frame->grabstate = FRAME_DONE;
                         wake_up_interruptible(&frame->wq);
@@ -3405,7 +3405,7 @@ eof:
         RESTRICT_TO_RANGE(frame->bytes_recvd, 8, max_raw);
 
         if (frame->scanstate == STATE_LINES) {
-                int nextf;
+                int nextf;
 
                 frame->grabstate = FRAME_DONE;
                 wake_up_interruptible(&frame->wq);
diff --git a/drivers/media/video/ov511.h b/drivers/media/video/ov511.h
index 12b3d51e1c3..68b082bcee1 100644
--- a/drivers/media/video/ov511.h
+++ b/drivers/media/video/ov511.h
@@ -3,6 +3,7 @@
 
 #include <asm/uaccess.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/smp_lock.h>
 #include <linux/usb.h>
 #include <linux/mutex.h>
diff --git a/drivers/media/video/planb.c b/drivers/media/video/planb.c
index d9e3cada52f..3484e36b680 100644
--- a/drivers/media/video/planb.c
+++ b/drivers/media/video/planb.c
@@ -40,6 +40,7 @@
 #include <linux/mm.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/wait.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
diff --git a/drivers/media/video/pms.c b/drivers/media/video/pms.c
index 09835ca098b..5d681fa8bcb 100644
--- a/drivers/media/video/pms.c
+++ b/drivers/media/video/pms.c
@@ -30,6 +30,7 @@
 #include <asm/io.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/mutex.h>
 
 #include <asm/uaccess.h>
@@ -804,7 +805,7 @@ static int pms_do_ioctl(struct inode *inode, struct file *file,
                         struct video_picture *p = arg;
                         if(!((p->palette==VIDEO_PALETTE_RGB565 && p->depth==16)
                             ||(p->palette==VIDEO_PALETTE_RGB555 && p->depth==15)))
-                                return -EINVAL;
+                                return -EINVAL;
                         pd->picture= *p;
 
                         /*
diff --git a/drivers/media/video/pwc/Kconfig b/drivers/media/video/pwc/Kconfig
index 53cbc950f95..697145e0bf1 100644
--- a/drivers/media/video/pwc/Kconfig
+++ b/drivers/media/video/pwc/Kconfig
@@ -7,6 +7,7 @@ config USB_PWC
            * Philips PCA645, PCA646
            * Philips PCVC675, PCVC680, PCVC690
            * Philips PCVC720/40, PCVC730, PCVC740, PCVC750
+           * Philips SPC900NC
            * Askey VC010
            * Logitech QuickCam Pro 3000, 4000, 'Zoom', 'Notebook Pro'
              and 'Orbit'/'Sphere'
@@ -19,10 +20,18 @@ config USB_PWC
           and never will be, but the 665 and 720/20 are supported by other
           drivers.
 
-          See <file:Documentation/usb/philips.txt> for more information and
-          installation instructions.
+          Some newer logitech webcams are not handled by this driver but by the
+          Usb Video Class driver (linux-uvc).
 
           The built-in microphone is enabled by selecting USB Audio support.
 
           To compile this driver as a module, choose M here: the
           module will be called pwc.
+
+config USB_PWC_DEBUG
+        bool "USB Philips Cameras verbose debug"
+        depends USB_PWC
+        help
+          Say Y here in order to have the pwc driver generate verbose debugging
+          messages.
+          A special module options 'trace' is used to control the verbosity.
diff --git a/drivers/media/video/pwc/Makefile b/drivers/media/video/pwc/Makefile
index 33d60126c02..9db2260d10c 100644
--- a/drivers/media/video/pwc/Makefile
+++ b/drivers/media/video/pwc/Makefile
@@ -1,3 +1,12 @@
-pwc-objs        := pwc-if.o pwc-misc.o pwc-ctrl.o pwc-uncompress.o pwc-timon.o pwc-kiara.o
+pwc-objs        := pwc-if.o pwc-misc.o pwc-ctrl.o pwc-v4l.o pwc-uncompress.o
+pwc-objs        += pwc-dec1.o pwc-dec23.o pwc-kiara.o pwc-timon.o
 
 obj-$(CONFIG_USB_PWC) += pwc.o
+
+ifeq ($(CONFIG_USB_PWC_DEBUG),y)
+EXTRA_CFLAGS += -DCONFIG_PWC_DEBUG=1
+else
+EXTRA_CFLAGS += -DCONFIG_PWC_DEBUG=0
+endif
+
+
diff --git a/drivers/media/video/pwc/pwc-ctrl.c b/drivers/media/video/pwc/pwc-ctrl.c
index 4ba549bfa0e..0bd115588f3 100644
--- a/drivers/media/video/pwc/pwc-ctrl.c
+++ b/drivers/media/video/pwc/pwc-ctrl.c
@@ -2,7 +2,7 @@
    Functions that send various control messages to the webcam, including
    video modes.
    (C) 1999-2003 Nemosoft Unv.
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -41,12 +41,14 @@
 #include <asm/uaccess.h>
 #endif
 #include <asm/errno.h>
+#include <linux/version.h>
 
 #include "pwc.h"
-#include "pwc-ioctl.h"
 #include "pwc-uncompress.h"
 #include "pwc-kiara.h"
 #include "pwc-timon.h"
+#include "pwc-dec1.h"
+#include "pwc-dec23.h"
 
 /* Request types: video */
 #define SET_LUM_CTL                     0x01
@@ -57,6 +59,10 @@
 #define GET_STATUS_CTL                  0x06
 #define SET_EP_STREAM_CTL               0x07
 #define GET_EP_STREAM_CTL               0x08
+#define GET_XX_CTL                      0x09
+#define SET_XX_CTL                      0x0A
+#define GET_XY_CTL                      0x0B
+#define SET_XY_CTL                      0x0C
 #define SET_MPT_CTL                     0x0D
 #define GET_MPT_CTL                     0x0E
 
@@ -93,12 +99,20 @@
 #define READ_SHUTTER_FORMATTER                  0x0600
 #define READ_RED_GAIN_FORMATTER                 0x0700
 #define READ_BLUE_GAIN_FORMATTER                0x0800
+#define GET_STATUS_B00                          0x0B00
 #define SENSOR_TYPE_FORMATTER1                  0x0C00
+#define GET_STATUS_3000                         0x3000
 #define READ_RAW_Y_MEAN_FORMATTER               0x3100
 #define SET_POWER_SAVE_MODE_FORMATTER           0x3200
 #define MIRROR_IMAGE_FORMATTER                  0x3300
 #define LED_FORMATTER                           0x3400
+#define LOWLIGHT                                0x3500
+#define GET_STATUS_3600                         0x3600
 #define SENSOR_TYPE_FORMATTER2                  0x3700
+#define GET_STATUS_3800                         0x3800
+#define GET_STATUS_4000                         0x4000
+#define GET_STATUS_4100                         0x4100  /* Get */
+#define CTL_STATUS_4200                         0x4200  /* [GS] 1 */
 
 /* Formatters for the Video Endpoint controls [GS]ET_EP_STREAM_CTL */
 #define VIDEO_OUTPUT_CONTROL_FORMATTER          0x0100
@@ -138,6 +152,7 @@ static struct Nala_table_entry Nala_table[PSZ_MAX][8] =
 #include "pwc-nala.h"
 };
 
+static void pwc_set_image_buffer_size(struct pwc_device *pdev);
 
 /****************************************************************************/
 
@@ -159,31 +174,7 @@ static struct Nala_table_entry Nala_table[PSZ_MAX][8] =
                 &buf, buflen, 500)
 
 
-#if PWC_DEBUG
-void pwc_hexdump(void *p, int len)
-{
-        int i;
-        unsigned char *s;
-        char buf[100], *d;
-
-        s = (unsigned char *)p;
-        d = buf;
-        *d = '\0';
-        Debug("Doing hexdump @ %p, %d bytes.\n", p, len);
-        for (i = 0; i < len; i++) {
-                d += sprintf(d, "%02X ", *s++);
-                if ((i & 0xF) == 0xF) {
-                        Debug("%s\n", buf);
-                        d = buf;
-                        *d = '\0';
-                }
-        }
-        if ((i & 0xF) != 0)
-                Debug("%s\n", buf);
-}
-#endif
-
-static inline int send_video_command(struct usb_device *udev, int index, void *buf, int buflen)
+static int send_video_command(struct usb_device *udev, int index, void *buf, int buflen)
 {
         return usb_control_msg(udev,
                 usb_sndctrlpipe(udev, 0),
@@ -196,7 +187,7 @@ static inline int send_video_command(struct usb_device *udev, int index, void *b
 
 
 
-static inline int set_video_mode_Nala(struct pwc_device *pdev, int size, int frames)
+static int set_video_mode_Nala(struct pwc_device *pdev, int size, int frames)
 {
         unsigned char buf[3];
         int ret, fps;
@@ -229,34 +220,14 @@ static inline int set_video_mode_Nala(struct pwc_device *pdev, int size, int fra
         if (pEntry->alternate == 0)
                 return -EINVAL;
 
-        if (pEntry->compressed)
-                return -ENOENT; /* Not supported. */
-
         memcpy(buf, pEntry->mode, 3);
         ret = send_video_command(pdev->udev, pdev->vendpoint, buf, 3);
         if (ret < 0) {
-                Debug("Failed to send video command... %d\n", ret);
+                PWC_DEBUG_MODULE("Failed to send video command... %d\n", ret);
                 return ret;
         }
         if (pEntry->compressed && pdev->vpalette != VIDEO_PALETTE_RAW)
-         {
-           switch(pdev->type) {
-             case 645:
-             case 646:
-/*             pwc_dec1_init(pdev->type, pdev->release, buf, pdev->decompress_data); */
-               break;
-
-             case 675:
-             case 680:
-             case 690:
-             case 720:
-             case 730:
-             case 740:
-             case 750:
-/*             pwc_dec23_init(pdev->type, pdev->release, buf, pdev->decompress_data); */
-               break;
-           }
-        }
+                pwc_dec1_init(pdev->type, pdev->release, buf, pdev->decompress_data);
 
         pdev->cmd_len = 3;
         memcpy(pdev->cmd_buf, buf, 3);
@@ -283,7 +254,7 @@ static inline int set_video_mode_Nala(struct pwc_device *pdev, int size, int fra
 }
 
 
-static inline int set_video_mode_Timon(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
+static int set_video_mode_Timon(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
 {
         unsigned char buf[13];
         const struct Timon_table_entry *pChoose;
@@ -315,8 +286,8 @@ static inline int set_video_mode_Timon(struct pwc_device *pdev, int size, int fr
         if (ret < 0)
                 return ret;
 
-/*      if (pChoose->bandlength > 0 && pdev->vpalette != VIDEO_PALETTE_RAW)
-           pwc_dec23_init(pdev->type, pdev->release, buf, pdev->decompress_data); */
+        if (pChoose->bandlength > 0 && pdev->vpalette != VIDEO_PALETTE_RAW)
+                pwc_dec23_init(pdev, pdev->type, buf);
 
         pdev->cmd_len = 13;
         memcpy(pdev->cmd_buf, buf, 13);
@@ -336,7 +307,7 @@ static inline int set_video_mode_Timon(struct pwc_device *pdev, int size, int fr
 }
 
 
-static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
+static int set_video_mode_Kiara(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
 {
         const struct Kiara_table_entry *pChoose = NULL;
         int fps, ret;
@@ -350,21 +321,14 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
         fps = (frames / 5) - 1;
 
         /* special case: VGA @ 5 fps and snapshot is raw bayer mode */
-        if (size == PSZ_VGA && frames == 5 && snapshot)
+        if (size == PSZ_VGA && frames == 5 && snapshot && pdev->vpalette == VIDEO_PALETTE_RAW)
         {
                 /* Only available in case the raw palette is selected or
                    we have the decompressor available. This mode is
                    only available in compressed form
                 */
-                if (pdev->vpalette == VIDEO_PALETTE_RAW)
-                {
-                        Info("Choosing VGA/5 BAYER mode (%d).\n", pdev->vpalette);
-                        pChoose = &RawEntry;
-                }
-                else
-                {
-                        Info("VGA/5 BAYER mode _must_ have a decompressor available, or use RAW palette.\n");
-                }
+                PWC_DEBUG_SIZE("Choosing VGA/5 BAYER mode.\n");
+                pChoose = &RawEntry;
         }
         else
         {
@@ -372,6 +336,7 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
                    if the preferred ratio is not available.
                    Skip this step when using RAW modes.
                 */
+                snapshot = 0;
                 while (compression <= 3) {
                         pChoose = &Kiara_table[size][fps][compression];
                         if (pChoose->alternate != 0)
@@ -382,7 +347,7 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
         if (pChoose == NULL || pChoose->alternate == 0)
                 return -ENOENT; /* Not supported. */
 
-        Debug("Using alternate setting %d.\n", pChoose->alternate);
+        PWC_TRACE("Using alternate setting %d.\n", pChoose->alternate);
 
         /* usb_control_msg won't take staticly allocated arrays as argument?? */
         memcpy(buf, pChoose->mode, 12);
@@ -394,8 +359,8 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
         if (ret < 0)
                 return ret;
 
-/*      if (pChoose->bandlength > 0 && pdev->vpalette != VIDEO_PALETTE_RAW)
-          pwc_dec23_init(pdev->type, pdev->release, buf, pdev->decompress_data); */
+        if (pChoose->bandlength > 0 && pdev->vpalette != VIDEO_PALETTE_RAW)
+                pwc_dec23_init(pdev, pdev->type, buf);
 
         pdev->cmd_len = 12;
         memcpy(pdev->cmd_buf, buf, 12);
@@ -410,49 +375,13 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
                 pdev->frame_size = (pdev->vbandlength * pdev->image.y) / 4;
         else
                 pdev->frame_size = (pdev->image.x * pdev->image.y * 12) / 8;
+        PWC_TRACE("frame_size=%d, vframes=%d, vsize=%d, vsnapshot=%d, vbandlength=%d\n",
+            pdev->frame_size,pdev->vframes,pdev->vsize,pdev->vsnapshot,pdev->vbandlength);
         return 0;
 }
 
 
 
-static void pwc_set_image_buffer_size(struct pwc_device *pdev)
-{
-        int i, factor = 0, filler = 0;
-
-        /* for PALETTE_YUV420P */
-        switch(pdev->vpalette)
-        {
-        case VIDEO_PALETTE_YUV420P:
-                factor = 6;
-                filler = 128;
-                break;
-        case VIDEO_PALETTE_RAW:
-                factor = 6; /* can be uncompressed YUV420P */
-                filler = 0;
-                break;
-        }
-
-        /* Set sizes in bytes */
-        pdev->image.size = pdev->image.x * pdev->image.y * factor / 4;
-        pdev->view.size  = pdev->view.x  * pdev->view.y  * factor / 4;
-
-        /* Align offset, or you'll get some very weird results in
-           YUV420 mode... x must be multiple of 4 (to get the Y's in
-           place), and y even (or you'll mixup U & V). This is less of a
-           problem for YUV420P.
-         */
-        pdev->offset.x = ((pdev->view.x - pdev->image.x) / 2) & 0xFFFC;
-        pdev->offset.y = ((pdev->view.y - pdev->image.y) / 2) & 0xFFFE;
-
-        /* Fill buffers with gray or black */
-        for (i = 0; i < MAX_IMAGES; i++) {
-                if (pdev->image_ptr[i] != NULL)
-                        memset(pdev->image_ptr[i], filler, pdev->view.size);
-        }
-}
-
-
-
 /**
    @pdev: device structure
    @width: viewport width
@@ -465,50 +394,78 @@ int pwc_set_video_mode(struct pwc_device *pdev, int width, int height, int frame
 {
         int ret, size;
 
-        Trace(TRACE_FLOW, "set_video_mode(%dx%d @ %d, palette %d).\n", width, height, frames, pdev->vpalette);
+        PWC_DEBUG_FLOW("set_video_mode(%dx%d @ %d, palette %d).\n", width, height, frames, pdev->vpalette);
         size = pwc_decode_size(pdev, width, height);
         if (size < 0) {
-                Debug("Could not find suitable size.\n");
+                PWC_DEBUG_MODULE("Could not find suitable size.\n");
                 return -ERANGE;
         }
-        Debug("decode_size = %d.\n", size);
+        PWC_TRACE("decode_size = %d.\n", size);
 
-        ret = -EINVAL;
-        switch(pdev->type) {
-        case 645:
-        case 646:
+        if (DEVICE_USE_CODEC1(pdev->type)) {
                 ret = set_video_mode_Nala(pdev, size, frames);
-                break;
 
-        case 675:
-        case 680:
-        case 690:
-                ret = set_video_mode_Timon(pdev, size, frames, compression, snapshot);
-                break;
-
-        case 720:
-        case 730:
-        case 740:
-        case 750:
+        } else if (DEVICE_USE_CODEC3(pdev->type)) {
                 ret = set_video_mode_Kiara(pdev, size, frames, compression, snapshot);
-                break;
+
+        } else {
+                ret = set_video_mode_Timon(pdev, size, frames, compression, snapshot);
         }
         if (ret < 0) {
-                if (ret == -ENOENT)
-                        Info("Video mode %s@%d fps is only supported with the decompressor module (pwcx).\n", size2name[size], frames);
-                else {
-                        Err("Failed to set video mode %s@%d fps; return code = %d\n", size2name[size], frames, ret);
-                }
+                PWC_ERROR("Failed to set video mode %s@%d fps; return code = %d\n", size2name[size], frames, ret);
                 return ret;
         }
         pdev->view.x = width;
         pdev->view.y = height;
         pdev->frame_total_size = pdev->frame_size + pdev->frame_header_size + pdev->frame_trailer_size;
         pwc_set_image_buffer_size(pdev);
-        Trace(TRACE_SIZE, "Set viewport to %dx%d, image size is %dx%d.\n", width, height, pwc_image_sizes[size].x, pwc_image_sizes[size].y);
+        PWC_DEBUG_SIZE("Set viewport to %dx%d, image size is %dx%d.\n", width, height, pwc_image_sizes[size].x, pwc_image_sizes[size].y);
         return 0;
 }
 
+#define BLACK_Y 0
+#define BLACK_U 128
+#define BLACK_V 128
+
+static void pwc_set_image_buffer_size(struct pwc_device *pdev)
+{
+        int i, factor = 0;
+
+        /* for PALETTE_YUV420P */
+        switch(pdev->vpalette)
+        {
+        case VIDEO_PALETTE_YUV420P:
+                factor = 6;
+                break;
+        case VIDEO_PALETTE_RAW:
+                factor = 6; /* can be uncompressed YUV420P */
+                break;
+        }
+
+        /* Set sizes in bytes */
+        pdev->image.size = pdev->image.x * pdev->image.y * factor / 4;
+        pdev->view.size  = pdev->view.x  * pdev->view.y  * factor / 4;
+
+        /* Align offset, or you'll get some very weird results in
+           YUV420 mode... x must be multiple of 4 (to get the Y's in
+           place), and y even (or you'll mixup U & V). This is less of a
+           problem for YUV420P.
+         */
+        pdev->offset.x = ((pdev->view.x - pdev->image.x) / 2) & 0xFFFC;
+        pdev->offset.y = ((pdev->view.y - pdev->image.y) / 2) & 0xFFFE;
+
+        /* Fill buffers with black colors */
+        for (i = 0; i < pwc_mbufs; i++) {
+                unsigned char *p = pdev->image_data + pdev->images[i].offset;
+                memset(p, BLACK_Y, pdev->view.x * pdev->view.y);
+                p += pdev->view.x * pdev->view.y;
+                memset(p, BLACK_U, pdev->view.x * pdev->view.y/4);
+                p += pdev->view.x * pdev->view.y/4;
+                memset(p, BLACK_V, pdev->view.x * pdev->view.y/4);
+        }
+}
+
+
 
 /* BRIGHTNESS */
 
@@ -520,7 +477,7 @@ int pwc_get_brightness(struct pwc_device *pdev)
         ret = RecvControlMsg(GET_LUM_CTL, BRIGHTNESS_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        return buf << 9;
+        return buf;
 }
 
 int pwc_set_brightness(struct pwc_device *pdev, int value)
@@ -545,7 +502,7 @@ int pwc_get_contrast(struct pwc_device *pdev)
         ret = RecvControlMsg(GET_LUM_CTL, CONTRAST_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        return buf << 10;
+        return buf;
 }
 
 int pwc_set_contrast(struct pwc_device *pdev, int value)
@@ -570,7 +527,7 @@ int pwc_get_gamma(struct pwc_device *pdev)
         ret = RecvControlMsg(GET_LUM_CTL, GAMMA_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        return buf << 11;
+        return buf;
 }
 
 int pwc_set_gamma(struct pwc_device *pdev, int value)
@@ -588,37 +545,47 @@ int pwc_set_gamma(struct pwc_device *pdev, int value)
 
 /* SATURATION */
 
-int pwc_get_saturation(struct pwc_device *pdev)
+/* return a value between [-100 , 100] */
+int pwc_get_saturation(struct pwc_device *pdev, int *value)
 {
         char buf;
-        int ret;
+        int ret, saturation_register;
 
         if (pdev->type < 675)
-                return -1;
-        ret = RecvControlMsg(GET_CHROM_CTL, pdev->type < 730 ? SATURATION_MODE_FORMATTER2 : SATURATION_MODE_FORMATTER1, 1);
+                return -EINVAL;
+        if (pdev->type < 730)
+                saturation_register = SATURATION_MODE_FORMATTER2;
+        else
+                saturation_register = SATURATION_MODE_FORMATTER1;
+        ret = RecvControlMsg(GET_CHROM_CTL, saturation_register, 1);
         if (ret < 0)
                 return ret;
-        return 32768 + buf * 327;
+        *value = (signed)buf;
+        return 0;
 }
 
+/* @param value saturation color between [-100 , 100] */
 int pwc_set_saturation(struct pwc_device *pdev, int value)
 {
         char buf;
+        int saturation_register;
 
         if (pdev->type < 675)
                 return -EINVAL;
-        if (value < 0)
-                value = 0;
-        if (value > 0xffff)
-                value = 0xffff;
-        /* saturation ranges from -100 to +100 */
-        buf = (value - 32768) / 327;
-        return SendControlMsg(SET_CHROM_CTL, pdev->type < 730 ? SATURATION_MODE_FORMATTER2 : SATURATION_MODE_FORMATTER1, 1);
+        if (value < -100)
+                value = -100;
+        if (value > 100)
+                value = 100;
+        if (pdev->type < 730)
+                saturation_register = SATURATION_MODE_FORMATTER2;
+        else
+                saturation_register = SATURATION_MODE_FORMATTER1;
+        return SendControlMsg(SET_CHROM_CTL, saturation_register, 1);
 }
 
 /* AGC */
 
-static inline int pwc_set_agc(struct pwc_device *pdev, int mode, int value)
+int pwc_set_agc(struct pwc_device *pdev, int mode, int value)
 {
         char buf;
         int ret;
@@ -643,7 +610,7 @@ static inline int pwc_set_agc(struct pwc_device *pdev, int mode, int value)
         return 0;
 }
 
-static inline int pwc_get_agc(struct pwc_device *pdev, int *value)
+int pwc_get_agc(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -673,7 +640,7 @@ static inline int pwc_get_agc(struct pwc_device *pdev, int *value)
         return 0;
 }
 
-static inline int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int value)
+int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int value)
 {
         char buf[2];
         int speed, ret;
@@ -691,23 +658,16 @@ static inline int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int v
                         value = 0;
                 if (value > 0xffff)
                         value = 0xffff;
-                switch(pdev->type) {
-                case 675:
-                case 680:
-                case 690:
+
+                if (DEVICE_USE_CODEC2(pdev->type)) {
                         /* speed ranges from 0x0 to 0x290 (656) */
                         speed = (value / 100);
                         buf[1] = speed >> 8;
                         buf[0] = speed & 0xff;
-                        break;
-                case 720:
-                case 730:
-                case 740:
-                case 750:
+                } else if (DEVICE_USE_CODEC3(pdev->type)) {
                         /* speed seems to range from 0x0 to 0xff */
                         buf[1] = 0;
                         buf[0] = value >> 8;
-                        break;
                 }
 
                 ret = SendControlMsg(SET_LUM_CTL, PRESET_SHUTTER_FORMATTER, 2);
@@ -715,6 +675,25 @@ static inline int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int v
         return ret;
 }
 
+/* This function is not exported to v4l1, so output values between 0 -> 256 */
+int pwc_get_shutter_speed(struct pwc_device *pdev, int *value)
+{
+        unsigned char buf[2];
+        int ret;
+
+        ret = RecvControlMsg(GET_STATUS_CTL, READ_SHUTTER_FORMATTER, 2);
+        if (ret < 0)
+                return ret;
+        *value = buf[0] + (buf[1] << 8);
+        if (DEVICE_USE_CODEC2(pdev->type)) {
+                /* speed ranges from 0x0 to 0x290 (656) */
+                *value *= 256/656;
+        } else if (DEVICE_USE_CODEC3(pdev->type)) {
+                /* speed seems to range from 0x0 to 0xff */
+        }
+        return 0;
+}
+
 
 /* POWER */
 
@@ -736,19 +715,19 @@ int pwc_camera_power(struct pwc_device *pdev, int power)
 
 /* private calls */
 
-static inline int pwc_restore_user(struct pwc_device *pdev)
+int pwc_restore_user(struct pwc_device *pdev)
 {
         char buf; /* dummy */
         return SendControlMsg(SET_STATUS_CTL, RESTORE_USER_DEFAULTS_FORMATTER, 0);
 }
 
-static inline int pwc_save_user(struct pwc_device *pdev)
+int pwc_save_user(struct pwc_device *pdev)
 {
         char buf; /* dummy */
         return SendControlMsg(SET_STATUS_CTL, SAVE_USER_DEFAULTS_FORMATTER, 0);
 }
 
-static inline int pwc_restore_factory(struct pwc_device *pdev)
+int pwc_restore_factory(struct pwc_device *pdev)
 {
         char buf; /* dummy */
         return SendControlMsg(SET_STATUS_CTL, RESTORE_FACTORY_DEFAULTS_FORMATTER, 0);
@@ -766,7 +745,7 @@ static inline int pwc_restore_factory(struct pwc_device *pdev)
   * 03: manual
   * 04: auto
   */
-static inline int pwc_set_awb(struct pwc_device *pdev, int mode)
+int pwc_set_awb(struct pwc_device *pdev, int mode)
 {
         char buf;
         int ret;
@@ -786,7 +765,7 @@ static inline int pwc_set_awb(struct pwc_device *pdev, int mode)
         return 0;
 }
 
-static inline int pwc_get_awb(struct pwc_device *pdev)
+int pwc_get_awb(struct pwc_device *pdev)
 {
         unsigned char buf;
         int ret;
@@ -798,7 +777,7 @@ static inline int pwc_get_awb(struct pwc_device *pdev)
         return buf;
 }
 
-static inline int pwc_set_red_gain(struct pwc_device *pdev, int value)
+int pwc_set_red_gain(struct pwc_device *pdev, int value)
 {
         unsigned char buf;
 
@@ -811,7 +790,7 @@ static inline int pwc_set_red_gain(struct pwc_device *pdev, int value)
         return SendControlMsg(SET_CHROM_CTL, PRESET_MANUAL_RED_GAIN_FORMATTER, 1);
 }
 
-static inline int pwc_get_red_gain(struct pwc_device *pdev, int *value)
+int pwc_get_red_gain(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -824,7 +803,7 @@ static inline int pwc_get_red_gain(struct pwc_device *pdev, int *value)
 }
 
 
-static inline int pwc_set_blue_gain(struct pwc_device *pdev, int value)
+int pwc_set_blue_gain(struct pwc_device *pdev, int value)
 {
         unsigned char buf;
 
@@ -837,7 +816,7 @@ static inline int pwc_set_blue_gain(struct pwc_device *pdev, int value)
         return SendControlMsg(SET_CHROM_CTL, PRESET_MANUAL_BLUE_GAIN_FORMATTER, 1);
 }
 
-static inline int pwc_get_blue_gain(struct pwc_device *pdev, int *value)
+int pwc_get_blue_gain(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -854,7 +833,7 @@ static inline int pwc_get_blue_gain(struct pwc_device *pdev, int *value)
    internal red/blue gains, which may be different from the manual
    gains set or read above.
  */
-static inline int pwc_read_red_gain(struct pwc_device *pdev, int *value)
+static int pwc_read_red_gain(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -866,7 +845,7 @@ static inline int pwc_read_red_gain(struct pwc_device *pdev, int *value)
         return 0;
 }
 
-static inline int pwc_read_blue_gain(struct pwc_device *pdev, int *value)
+static int pwc_read_blue_gain(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -879,7 +858,7 @@ static inline int pwc_read_blue_gain(struct pwc_device *pdev, int *value)
 }
 
 
-static inline int pwc_set_wb_speed(struct pwc_device *pdev, int speed)
+static int pwc_set_wb_speed(struct pwc_device *pdev, int speed)
 {
         unsigned char buf;
 
@@ -888,7 +867,7 @@ static inline int pwc_set_wb_speed(struct pwc_device *pdev, int speed)
         return SendControlMsg(SET_CHROM_CTL, AWB_CONTROL_SPEED_FORMATTER, 1);
 }
 
-static inline int pwc_get_wb_speed(struct pwc_device *pdev, int *value)
+static int pwc_get_wb_speed(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -901,7 +880,7 @@ static inline int pwc_get_wb_speed(struct pwc_device *pdev, int *value)
 }
 
 
-static inline int pwc_set_wb_delay(struct pwc_device *pdev, int delay)
+static int pwc_set_wb_delay(struct pwc_device *pdev, int delay)
 {
         unsigned char buf;
 
@@ -910,7 +889,7 @@ static inline int pwc_set_wb_delay(struct pwc_device *pdev, int delay)
         return SendControlMsg(SET_CHROM_CTL, AWB_CONTROL_DELAY_FORMATTER, 1);
 }
 
-static inline int pwc_get_wb_delay(struct pwc_device *pdev, int *value)
+static int pwc_get_wb_delay(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -965,7 +944,7 @@ static int pwc_get_leds(struct pwc_device *pdev, int *on_value, int *off_value)
         return 0;
 }
 
-static inline int pwc_set_contour(struct pwc_device *pdev, int contour)
+int pwc_set_contour(struct pwc_device *pdev, int contour)
 {
         unsigned char buf;
         int ret;
@@ -990,7 +969,7 @@ static inline int pwc_set_contour(struct pwc_device *pdev, int contour)
         return 0;
 }
 
-static inline int pwc_get_contour(struct pwc_device *pdev, int *contour)
+int pwc_get_contour(struct pwc_device *pdev, int *contour)
 {
         unsigned char buf;
         int ret;
@@ -1012,7 +991,7 @@ static inline int pwc_get_contour(struct pwc_device *pdev, int *contour)
 }
 
 
-static inline int pwc_set_backlight(struct pwc_device *pdev, int backlight)
+int pwc_set_backlight(struct pwc_device *pdev, int backlight)
 {
         unsigned char buf;
 
@@ -1023,7 +1002,7 @@ static inline int pwc_set_backlight(struct pwc_device *pdev, int backlight)
         return SendControlMsg(SET_LUM_CTL, BACK_LIGHT_COMPENSATION_FORMATTER, 1);
 }
 
-static inline int pwc_get_backlight(struct pwc_device *pdev, int *backlight)
+int pwc_get_backlight(struct pwc_device *pdev, int *backlight)
 {
         int ret;
         unsigned char buf;
@@ -1031,12 +1010,35 @@ static inline int pwc_get_backlight(struct pwc_device *pdev, int *backlight)
         ret = RecvControlMsg(GET_LUM_CTL, BACK_LIGHT_COMPENSATION_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        *backlight = buf;
+        *backlight = !!buf;
         return 0;
 }
 
+int pwc_set_colour_mode(struct pwc_device *pdev, int colour)
+{
+        unsigned char buf;
 
-static inline int pwc_set_flicker(struct pwc_device *pdev, int flicker)
+        if (colour)
+                buf = 0xff;
+        else
+                buf = 0x0;
+        return SendControlMsg(SET_CHROM_CTL, COLOUR_MODE_FORMATTER, 1);
+}
+
+int pwc_get_colour_mode(struct pwc_device *pdev, int *colour)
+{
+        int ret;
+        unsigned char buf;
+
+        ret = RecvControlMsg(GET_CHROM_CTL, COLOUR_MODE_FORMATTER, 1);
+        if (ret < 0)
+                return ret;
+        *colour = !!buf;
+        return 0;
+}
+
+
+int pwc_set_flicker(struct pwc_device *pdev, int flicker)
 {
         unsigned char buf;
 
@@ -1047,7 +1049,7 @@ static inline int pwc_set_flicker(struct pwc_device *pdev, int flicker)
         return SendControlMsg(SET_LUM_CTL, FLICKERLESS_MODE_FORMATTER, 1);
 }
 
-static inline int pwc_get_flicker(struct pwc_device *pdev, int *flicker)
+int pwc_get_flicker(struct pwc_device *pdev, int *flicker)
 {
         int ret;
         unsigned char buf;
@@ -1055,12 +1057,11 @@ static inline int pwc_get_flicker(struct pwc_device *pdev, int *flicker)
         ret = RecvControlMsg(GET_LUM_CTL, FLICKERLESS_MODE_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        *flicker = buf;
+        *flicker = !!buf;
         return 0;
 }
 
-
-static inline int pwc_set_dynamic_noise(struct pwc_device *pdev, int noise)
+int pwc_set_dynamic_noise(struct pwc_device *pdev, int noise)
 {
         unsigned char buf;
 
@@ -1072,7 +1073,7 @@ static inline int pwc_set_dynamic_noise(struct pwc_device *pdev, int noise)
         return SendControlMsg(SET_LUM_CTL, DYNAMIC_NOISE_CONTROL_FORMATTER, 1);
 }
 
-static inline int pwc_get_dynamic_noise(struct pwc_device *pdev, int *noise)
+int pwc_get_dynamic_noise(struct pwc_device *pdev, int *noise)
 {
         int ret;
         unsigned char buf;
@@ -1084,7 +1085,7 @@ static inline int pwc_get_dynamic_noise(struct pwc_device *pdev, int *noise)
         return 0;
 }
 
-static int pwc_mpt_reset(struct pwc_device *pdev, int flags)
+static int _pwc_mpt_reset(struct pwc_device *pdev, int flags)
 {
         unsigned char buf;
 
@@ -1092,7 +1093,18 @@ static int pwc_mpt_reset(struct pwc_device *pdev, int flags)
         return SendControlMsg(SET_MPT_CTL, PT_RESET_CONTROL_FORMATTER, 1);
 }
 
-static inline int pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt)
+int pwc_mpt_reset(struct pwc_device *pdev, int flags)
+{
+        int ret;
+        ret = _pwc_mpt_reset(pdev, flags);
+        if (ret >= 0) {
+                pdev->pan_angle = 0;
+                pdev->tilt_angle = 0;
+        }
+        return ret;
+}
+
+static int _pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt)
 {
         unsigned char buf[4];
 
@@ -1110,7 +1122,35 @@ static inline int pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt)
         return SendControlMsg(SET_MPT_CTL, PT_RELATIVE_CONTROL_FORMATTER, 4);
 }
 
-static inline int pwc_mpt_get_status(struct pwc_device *pdev, struct pwc_mpt_status *status)
+int pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt)
+{
+        int ret;
+
+        /* check absolute ranges */
+        if (pan  < pdev->angle_range.pan_min  ||
+            pan  > pdev->angle_range.pan_max  ||
+            tilt < pdev->angle_range.tilt_min ||
+            tilt > pdev->angle_range.tilt_max)
+                return -ERANGE;
+
+        /* go to relative range, check again */
+        pan  -= pdev->pan_angle;
+        tilt -= pdev->tilt_angle;
+        /* angles are specified in degrees * 100, thus the limit = 36000 */
+        if (pan < -36000 || pan > 36000 || tilt < -36000 || tilt > 36000)
+                return -ERANGE;
+
+        ret = _pwc_mpt_set_angle(pdev, pan, tilt);
+        if (ret >= 0) {
+                pdev->pan_angle  += pan;
+                pdev->tilt_angle += tilt;
+        }
+        if (ret == -EPIPE) /* stall -> out of range */
+                ret = -ERANGE;
+        return ret;
+}
+
+static int pwc_mpt_get_status(struct pwc_device *pdev, struct pwc_mpt_status *status)
 {
         int ret;
         unsigned char buf[5];
@@ -1151,6 +1191,26 @@ int pwc_get_cmos_sensor(struct pwc_device *pdev, int *sensor)
  /* End of Add-Ons                                    */
  /* ************************************************* */
 
+/* Linux 2.5.something and 2.6 pass direct pointers to arguments of
+   ioctl() calls. With 2.4, you have to do tedious copy_from_user()
+   and copy_to_user() calls. With these macros we circumvent this,
+   and let me maintain only one source file. The functionality is
+   exactly the same otherwise.
+ */
+
+
+/* define local variable for arg */
+#define ARG_DEF(ARG_type, ARG_name)\
+        ARG_type *ARG_name = arg;
+/* copy arg to local variable */
+#define ARG_IN(ARG_name) /* nothing */
+/* argument itself (referenced) */
+#define ARGR(ARG_name) (*ARG_name)
+/* argument address */
+#define ARGA(ARG_name) ARG_name
+/* copy local variable to arg */
+#define ARG_OUT(ARG_name) /* nothing */
+
 
 int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 {
@@ -1180,206 +1240,243 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 
         case VIDIOCPWCSCQUAL:
         {
-                int *qual = arg;
+                ARG_DEF(int, qual)
 
-                if (*qual < 0 || *qual > 3)
+                ARG_IN(qual)
+                if (ARGR(qual) < 0 || ARGR(qual) > 3)
                         ret = -EINVAL;
                 else
-                        ret = pwc_try_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, *qual, pdev->vsnapshot);
+                        ret = pwc_try_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, ARGR(qual), pdev->vsnapshot);
                 if (ret >= 0)
-                        pdev->vcompression = *qual;
+                        pdev->vcompression = ARGR(qual);
                 break;
         }
 
         case VIDIOCPWCGCQUAL:
         {
-                int *qual = arg;
-                *qual = pdev->vcompression;
+                ARG_DEF(int, qual)
+
+                ARGR(qual) = pdev->vcompression;
+                ARG_OUT(qual)
                 break;
         }
 
         case VIDIOCPWCPROBE:
         {
-                struct pwc_probe *probe = arg;
-                strcpy(probe->name, pdev->vdev->name);
-                probe->type = pdev->type;
+                ARG_DEF(struct pwc_probe, probe)
+
+                strcpy(ARGR(probe).name, pdev->vdev->name);
+                ARGR(probe).type = pdev->type;
+                ARG_OUT(probe)
                 break;
         }
 
         case VIDIOCPWCGSERIAL:
         {
-                struct pwc_serial *serial = arg;
-                strcpy(serial->serial, pdev->serial);
+                ARG_DEF(struct pwc_serial, serial)
+
+                strcpy(ARGR(serial).serial, pdev->serial);
+                ARG_OUT(serial)
                 break;
         }
 
         case VIDIOCPWCSAGC:
         {
-                int *agc = arg;
-                if (pwc_set_agc(pdev, *agc < 0 ? 1 : 0, *agc))
+                ARG_DEF(int, agc)
+
+                ARG_IN(agc)
+                if (pwc_set_agc(pdev, ARGR(agc) < 0 ? 1 : 0, ARGR(agc)))
                         ret = -EINVAL;
                 break;
         }
 
         case VIDIOCPWCGAGC:
         {
-                int *agc = arg;
+                ARG_DEF(int, agc)
 
-                if (pwc_get_agc(pdev, agc))
+                if (pwc_get_agc(pdev, ARGA(agc)))
                         ret = -EINVAL;
+                ARG_OUT(agc)
                 break;
         }
 
         case VIDIOCPWCSSHUTTER:
         {
-                int *shutter_speed = arg;
-                ret = pwc_set_shutter_speed(pdev, *shutter_speed < 0 ? 1 : 0, *shutter_speed);
+                ARG_DEF(int, shutter_speed)
+
+                ARG_IN(shutter_speed)
+                ret = pwc_set_shutter_speed(pdev, ARGR(shutter_speed) < 0 ? 1 : 0, ARGR(shutter_speed));
                 break;
         }
 
         case VIDIOCPWCSAWB:
         {
-                struct pwc_whitebalance *wb = arg;
+                ARG_DEF(struct pwc_whitebalance, wb)
 
-                ret = pwc_set_awb(pdev, wb->mode);
-                if (ret >= 0 && wb->mode == PWC_WB_MANUAL) {
-                        pwc_set_red_gain(pdev, wb->manual_red);
-                        pwc_set_blue_gain(pdev, wb->manual_blue);
+                ARG_IN(wb)
+                ret = pwc_set_awb(pdev, ARGR(wb).mode);
+                if (ret >= 0 && ARGR(wb).mode == PWC_WB_MANUAL) {
+                        pwc_set_red_gain(pdev, ARGR(wb).manual_red);
+                        pwc_set_blue_gain(pdev, ARGR(wb).manual_blue);
                 }
                 break;
         }
 
         case VIDIOCPWCGAWB:
         {
-                struct pwc_whitebalance *wb = arg;
+                ARG_DEF(struct pwc_whitebalance, wb)
 
-                memset(wb, 0, sizeof(struct pwc_whitebalance));
-                wb->mode = pwc_get_awb(pdev);
-                if (wb->mode < 0)
+                memset(ARGA(wb), 0, sizeof(struct pwc_whitebalance));
+                ARGR(wb).mode = pwc_get_awb(pdev);
+                if (ARGR(wb).mode < 0)
                         ret = -EINVAL;
                 else {
-                        if (wb->mode == PWC_WB_MANUAL) {
-                                ret = pwc_get_red_gain(pdev, &wb->manual_red);
+                        if (ARGR(wb).mode == PWC_WB_MANUAL) {
+                                ret = pwc_get_red_gain(pdev, &ARGR(wb).manual_red);
                                 if (ret < 0)
                                         break;
-                                ret = pwc_get_blue_gain(pdev, &wb->manual_blue);
+                                ret = pwc_get_blue_gain(pdev, &ARGR(wb).manual_blue);
                                 if (ret < 0)
                                         break;
                         }
-                        if (wb->mode == PWC_WB_AUTO) {
-                                ret = pwc_read_red_gain(pdev, &wb->read_red);
+                        if (ARGR(wb).mode == PWC_WB_AUTO) {
+                                ret = pwc_read_red_gain(pdev, &ARGR(wb).read_red);
                                 if (ret < 0)
                                         break;
-                                ret = pwc_read_blue_gain(pdev, &wb->read_blue);
+                                ret =pwc_read_blue_gain(pdev, &ARGR(wb).read_blue);
                                 if (ret < 0)
                                         break;
                         }
                 }
+                ARG_OUT(wb)
                 break;
         }
 
         case VIDIOCPWCSAWBSPEED:
         {
-                struct pwc_wb_speed *wbs = arg;
+                ARG_DEF(struct pwc_wb_speed, wbs)
 
-                if (wbs->control_speed > 0) {
-                        ret = pwc_set_wb_speed(pdev, wbs->control_speed);
+                if (ARGR(wbs).control_speed > 0) {
+                        ret = pwc_set_wb_speed(pdev, ARGR(wbs).control_speed);
                 }
-                if (wbs->control_delay > 0) {
-                        ret = pwc_set_wb_delay(pdev, wbs->control_delay);
+                if (ARGR(wbs).control_delay > 0) {
+                        ret = pwc_set_wb_delay(pdev, ARGR(wbs).control_delay);
                 }
                 break;
         }
 
         case VIDIOCPWCGAWBSPEED:
         {
-                struct pwc_wb_speed *wbs = arg;
+                ARG_DEF(struct pwc_wb_speed, wbs)
 
-                ret = pwc_get_wb_speed(pdev, &wbs->control_speed);
+                ret = pwc_get_wb_speed(pdev, &ARGR(wbs).control_speed);
                 if (ret < 0)
                         break;
-                ret = pwc_get_wb_delay(pdev, &wbs->control_delay);
+                ret = pwc_get_wb_delay(pdev, &ARGR(wbs).control_delay);
                 if (ret < 0)
                         break;
+                ARG_OUT(wbs)
                 break;
         }
 
         case VIDIOCPWCSLED:
         {
-                struct pwc_leds *leds = arg;
-                ret = pwc_set_leds(pdev, leds->led_on, leds->led_off);
-                break;
+                ARG_DEF(struct pwc_leds, leds)
+
+                ARG_IN(leds)
+                ret = pwc_set_leds(pdev, ARGR(leds).led_on, ARGR(leds).led_off);
+                break;
         }
 
 
         case VIDIOCPWCGLED:
         {
-                struct pwc_leds *leds = arg;
-                ret = pwc_get_leds(pdev, &leds->led_on, &leds->led_off);
+                ARG_DEF(struct pwc_leds, leds)
+
+                ret = pwc_get_leds(pdev, &ARGR(leds).led_on, &ARGR(leds).led_off);
+                ARG_OUT(leds)
                 break;
         }
 
         case VIDIOCPWCSCONTOUR:
         {
-                int *contour = arg;
-                ret = pwc_set_contour(pdev, *contour);
+                ARG_DEF(int, contour)
+
+                ARG_IN(contour)
+                ret = pwc_set_contour(pdev, ARGR(contour));
                 break;
         }
 
         case VIDIOCPWCGCONTOUR:
         {
-                int *contour = arg;
-                ret = pwc_get_contour(pdev, contour);
+                ARG_DEF(int, contour)
+
+                ret = pwc_get_contour(pdev, ARGA(contour));
+                ARG_OUT(contour)
                 break;
         }
 
         case VIDIOCPWCSBACKLIGHT:
         {
-                int *backlight = arg;
-                ret = pwc_set_backlight(pdev, *backlight);
+                ARG_DEF(int, backlight)
+
+                ARG_IN(backlight)
+                ret = pwc_set_backlight(pdev, ARGR(backlight));
                 break;
         }
 
         case VIDIOCPWCGBACKLIGHT:
         {
-                int *backlight = arg;
-                ret = pwc_get_backlight(pdev, backlight);
+                ARG_DEF(int, backlight)
+
+                ret = pwc_get_backlight(pdev, ARGA(backlight));
+                ARG_OUT(backlight)
                 break;
         }
 
         case VIDIOCPWCSFLICKER:
         {
-                int *flicker = arg;
-                ret = pwc_set_flicker(pdev, *flicker);
+                ARG_DEF(int, flicker)
+
+                ARG_IN(flicker)
+                ret = pwc_set_flicker(pdev, ARGR(flicker));
                 break;
         }
 
         case VIDIOCPWCGFLICKER:
         {
-                int *flicker = arg;
-                ret = pwc_get_flicker(pdev, flicker);
+                ARG_DEF(int, flicker)
+
+                ret = pwc_get_flicker(pdev, ARGA(flicker));
+                ARG_OUT(flicker)
                 break;
         }
 
         case VIDIOCPWCSDYNNOISE:
         {
-                int *dynnoise = arg;
-                ret = pwc_set_dynamic_noise(pdev, *dynnoise);
+                ARG_DEF(int, dynnoise)
+
+                ARG_IN(dynnoise)
+                ret = pwc_set_dynamic_noise(pdev, ARGR(dynnoise));
                 break;
         }
 
         case VIDIOCPWCGDYNNOISE:
         {
-                int *dynnoise = arg;
-                ret = pwc_get_dynamic_noise(pdev, dynnoise);
+                ARG_DEF(int, dynnoise)
+
+                ret = pwc_get_dynamic_noise(pdev, ARGA(dynnoise));
+                ARG_OUT(dynnoise);
                 break;
         }
 
         case VIDIOCPWCGREALSIZE:
         {
-                struct pwc_imagesize *size = arg;
-                size->width = pdev->image.x;
-                size->height = pdev->image.y;
+                ARG_DEF(struct pwc_imagesize, size)
+
+                ARGR(size).width = pdev->image.x;
+                ARGR(size).height = pdev->image.y;
+                ARG_OUT(size)
                 break;
         }
 
@@ -1387,14 +1484,10 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
         {
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        int *flags = arg;
+                        ARG_DEF(int, flags)
 
-                        ret = pwc_mpt_reset(pdev, *flags);
-                        if (ret >= 0)
-                        {
-                                pdev->pan_angle = 0;
-                                pdev->tilt_angle = 0;
-                        }
+                        ARG_IN(flags)
+                        ret = pwc_mpt_reset(pdev, ARGR(flags));
                 }
                 else
                 {
@@ -1407,8 +1500,10 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
         {
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        struct pwc_mpt_range *range = arg;
-                        *range = pdev->angle_range;
+                        ARG_DEF(struct pwc_mpt_range, range)
+
+                        ARGR(range) = pdev->angle_range;
+                        ARG_OUT(range)
                 }
                 else
                 {
@@ -1423,48 +1518,23 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        struct pwc_mpt_angles *angles = arg;
+                        ARG_DEF(struct pwc_mpt_angles, angles)
+
+                        ARG_IN(angles)
                         /* The camera can only set relative angles, so
                            do some calculations when getting an absolute angle .
                          */
-                        if (angles->absolute)
+                        if (ARGR(angles).absolute)
                         {
-                                new_pan  = angles->pan;
-                                new_tilt = angles->tilt;
+                                new_pan  = ARGR(angles).pan;
+                                new_tilt = ARGR(angles).tilt;
                         }
                         else
                         {
-                                new_pan  = pdev->pan_angle  + angles->pan;
-                                new_tilt = pdev->tilt_angle + angles->tilt;
-                        }
-                        /* check absolute ranges */
-                        if (new_pan  < pdev->angle_range.pan_min  ||
-                            new_pan  > pdev->angle_range.pan_max  ||
-                            new_tilt < pdev->angle_range.tilt_min ||
-                            new_tilt > pdev->angle_range.tilt_max)
-                        {
-                                ret = -ERANGE;
-                        }
-                        else
-                        {
-                                /* go to relative range, check again */
-                                new_pan  -= pdev->pan_angle;
-                                new_tilt -= pdev->tilt_angle;
-                                /* angles are specified in degrees * 100, thus the limit = 36000 */
-                                if (new_pan < -36000 || new_pan > 36000 || new_tilt < -36000 || new_tilt > 36000)
-                                        ret = -ERANGE;
-                        }
-                        if (ret == 0) /* no errors so far */
-                        {
-                                ret = pwc_mpt_set_angle(pdev, new_pan, new_tilt);
-                                if (ret >= 0)
-                                {
-                                        pdev->pan_angle  += new_pan;
-                                        pdev->tilt_angle += new_tilt;
-                                }
-                                if (ret == -EPIPE) /* stall -> out of range */
-                                        ret = -ERANGE;
+                                new_pan  = pdev->pan_angle  + ARGR(angles).pan;
+                                new_tilt = pdev->tilt_angle + ARGR(angles).tilt;
                         }
+                        ret = pwc_mpt_set_angle(pdev, new_pan, new_tilt);
                 }
                 else
                 {
@@ -1478,11 +1548,12 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        struct pwc_mpt_angles *angles = arg;
+                        ARG_DEF(struct pwc_mpt_angles, angles)
 
-                        angles->absolute = 1;
-                        angles->pan  = pdev->pan_angle;
-                        angles->tilt = pdev->tilt_angle;
+                        ARGR(angles).absolute = 1;
+                        ARGR(angles).pan  = pdev->pan_angle;
+                        ARGR(angles).tilt = pdev->tilt_angle;
+                        ARG_OUT(angles)
                 }
                 else
                 {
@@ -1495,8 +1566,10 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
         {
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        struct pwc_mpt_status *status = arg;
-                        ret = pwc_mpt_get_status(pdev, status);
+                        ARG_DEF(struct pwc_mpt_status, status)
+
+                        ret = pwc_mpt_get_status(pdev, ARGA(status));
+                        ARG_OUT(status)
                 }
                 else
                 {
@@ -1507,22 +1580,24 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 
         case VIDIOCPWCGVIDCMD:
         {
-                struct pwc_video_command *cmd = arg;
-
-                cmd->type = pdev->type;
-                cmd->release = pdev->release;
-                cmd->command_len = pdev->cmd_len;
-                memcpy(&cmd->command_buf, pdev->cmd_buf, pdev->cmd_len);
-                cmd->bandlength = pdev->vbandlength;
-                cmd->frame_size = pdev->frame_size;
+                ARG_DEF(struct pwc_video_command, cmd);
+
+                ARGR(cmd).type = pdev->type;
+                ARGR(cmd).release = pdev->release;
+                ARGR(cmd).command_len = pdev->cmd_len;
+                memcpy(&ARGR(cmd).command_buf, pdev->cmd_buf, pdev->cmd_len);
+                ARGR(cmd).bandlength = pdev->vbandlength;
+                ARGR(cmd).frame_size = pdev->frame_size;
+                ARG_OUT(cmd)
                 break;
         }
        /*
         case VIDIOCPWCGVIDTABLE:
         {
-                struct pwc_table_init_buffer *table = arg;
-                table->len = pdev->cmd_len;
-                memcpy(&table->buffer, pdev->decompress_data, pdev->decompressor->table_size);
+                ARG_DEF(struct pwc_table_init_buffer, table);
+                ARGR(table).len = pdev->cmd_len;
+                memcpy(&ARGR(table).buffer, pdev->decompress_data, pdev->decompressor->table_size);
+                ARG_OUT(table)
                 break;
         }
         */
@@ -1538,4 +1613,4 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 }
 
 
-
+/* vim: set cinoptions= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
diff --git a/drivers/media/video/pwc/pwc-dec1.c b/drivers/media/video/pwc/pwc-dec1.c
new file mode 100644
index 00000000000..c29593f589e
--- /dev/null
+++ b/drivers/media/video/pwc/pwc-dec1.c
@@ -0,0 +1,50 @@
+/* Linux driver for Philips webcam
+   Decompression for chipset version 1
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
+
+   NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
+   driver and thus may have bugs that are not present in the original version.
+   Please send bug reports and support requests to <luc@saillard.org>.
+   The decompression routines have been implemented by reverse-engineering the
+   Nemosoft binary pwcx module. Caveat emptor.
+
+   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+
+
+#include "pwc-dec1.h"
+
+
+void pwc_dec1_init(int type, int release, void *buffer, void *table)
+{
+
+}
+
+void pwc_dec1_exit(void)
+{
+
+
+
+}
+
+int pwc_dec1_alloc(struct pwc_device *pwc)
+{
+        pwc->decompress_data = kmalloc(sizeof(struct pwc_dec1_private), GFP_KERNEL);
+        if (pwc->decompress_data == NULL)
+                return -ENOMEM;
+        return 0;
+}
+
diff --git a/drivers/media/video/pwc/pwc-dec1.h b/drivers/media/video/pwc/pwc-dec1.h
new file mode 100644
index 00000000000..8b62ddcc5c7
--- /dev/null
+++ b/drivers/media/video/pwc/pwc-dec1.h
@@ -0,0 +1,43 @@
+/* Linux driver for Philips webcam
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
+
+   NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
+   driver and thus may have bugs that are not present in the original version.
+   Please send bug reports and support requests to <luc@saillard.org>.
+   The decompression routines have been implemented by reverse-engineering the
+   Nemosoft binary pwcx module. Caveat emptor.
+
+   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+
+
+#ifndef PWC_DEC1_H
+#define PWC_DEC1_H
+
+#include "pwc.h"
+
+struct pwc_dec1_private
+{
+        int version;
+
+};
+
+int  pwc_dec1_alloc(struct pwc_device *pwc);
+void pwc_dec1_init(int type, int release, void *buffer, void *private_data);
+void pwc_dec1_exit(void);
+
+#endif
+
diff --git a/drivers/media/video/pwc/pwc-dec23.c b/drivers/media/video/pwc/pwc-dec23.c
new file mode 100644
index 00000000000..9e2d91f26bf
--- /dev/null
+++ b/drivers/media/video/pwc/pwc-dec23.c
@@ -0,0 +1,941 @@
+/* Linux driver for Philips webcam
+   Decompression for chipset version 2 et 3
+   (C) 2004-2006  Luc Saillard (luc@saillard.org)
+
+   NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
+   driver and thus may have bugs that are not present in the original version.
+   Please send bug reports and support requests to <luc@saillard.org>.
+   The decompression routines have been implemented by reverse-engineering the
+   Nemosoft binary pwcx module. Caveat emptor.
+
+   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include "pwc-timon.h"
+#include "pwc-kiara.h"
+#include "pwc-dec23.h"
+#include <media/pwc-ioctl.h>
+
+#include <linux/string.h>
+
+/*
+ * USE_LOOKUP_TABLE_TO_CLAMP
+ *   0: use a C version of this tests:  {  a<0?0:(a>255?255:a) }
+ *   1: use a faster lookup table for cpu with a big cache (intel)
+ */
+#define USE_LOOKUP_TABLE_TO_CLAMP       1
+/*
+ * UNROLL_LOOP_FOR_COPYING_BLOCK
+ *   0: use a loop for a smaller code (but little slower)
+ *   1: when unrolling the loop, gcc produces some faster code (perhaps only
+ *   valid for intel processor class). Activating this option, automaticaly
+ *   activate USE_LOOKUP_TABLE_TO_CLAMP
+ */
+#define UNROLL_LOOP_FOR_COPY            1
+#if UNROLL_LOOP_FOR_COPY
+# undef USE_LOOKUP_TABLE_TO_CLAMP
+# define USE_LOOKUP_TABLE_TO_CLAMP 1
+#endif
+
+/*
+ * ENABLE_BAYER_DECODER
+ *   0: bayer decoder is not build (save some space)
+ *   1: bayer decoder is build and can be used
+ */
+#define ENABLE_BAYER_DECODER 0
+
+static void build_subblock_pattern(struct pwc_dec23_private *pdec)
+{
+        static const unsigned int initial_values[12] = {
+                -0x526500, -0x221200, 0x221200, 0x526500,
+                           -0x3de200, 0x3de200,
+                -0x6db480, -0x2d5d00, 0x2d5d00, 0x6db480,
+                           -0x12c200, 0x12c200
+
+        };
+        static const unsigned int values_derivated[12] = {
+                0xa4ca, 0x4424, -0x4424, -0xa4ca,
+                        0x7bc4, -0x7bc4,
+                0xdb69, 0x5aba, -0x5aba, -0xdb69,
+                        0x2584, -0x2584
+        };
+        unsigned int temp_values[12];
+        int i, j;
+
+        memcpy(temp_values, initial_values, sizeof(initial_values));
+        for (i = 0; i < 256; i++) {
+                for (j = 0; j < 12; j++) {
+                        pdec->table_subblock[i][j] = temp_values[j];
+                        temp_values[j] += values_derivated[j];
+                }
+        }
+}
+
+static void build_bit_powermask_table(struct pwc_dec23_private *pdec)
+{
+        unsigned char *p;
+        unsigned int bit, byte, mask, val;
+        unsigned int bitpower = 1;
+
+        for (bit = 0; bit < 8; bit++) {
+                mask = bitpower - 1;
+                p = pdec->table_bitpowermask[bit];
+                for (byte = 0; byte < 256; byte++) {
+                        val = (byte & mask);
+                        if (byte & bitpower)
+                                val = -val;
+                        *p++ = val;
+                }
+                bitpower<<=1;
+        }
+}
+
+
+static void build_table_color(const unsigned int romtable[16][8],
+                              unsigned char p0004[16][1024],
+                              unsigned char p8004[16][256])
+{
+        int compression_mode, j, k, bit, pw;
+        unsigned char *p0, *p8;
+        const unsigned int *r;
+
+        /* We have 16 compressions tables */
+        for (compression_mode = 0; compression_mode < 16; compression_mode++) {
+                p0 = p0004[compression_mode];
+                p8 = p8004[compression_mode];
+                r  = romtable[compression_mode];
+
+                for (j = 0; j < 8; j++, r++, p0 += 128) {
+
+                        for (k = 0; k < 16; k++) {
+                                if (k == 0)
+                                        bit = 1;
+                                else if (k >= 1 && k < 3)
+                                        bit = (r[0] >> 15) & 7;
+                                else if (k >= 3 && k < 6)
+                                        bit = (r[0] >> 12) & 7;
+                                else if (k >= 6 && k < 10)
+                                        bit = (r[0] >> 9) & 7;
+                                else if (k >= 10 && k < 13)
+                                        bit = (r[0] >> 6) & 7;
+                                else if (k >= 13 && k < 15)
+                                        bit = (r[0] >> 3) & 7;
+                                else
+                                        bit = (r[0]) & 7;
+                                if (k == 0)
+                                        *p8++ = 8;
+                                else
+                                        *p8++ = j - bit;
+                                *p8++ = bit;
+
+                                pw = 1 << bit;
+                                p0[k + 0x00] = (1 * pw) + 0x80;
+                                p0[k + 0x10] = (2 * pw) + 0x80;
+                                p0[k + 0x20] = (3 * pw) + 0x80;
+                                p0[k + 0x30] = (4 * pw) + 0x80;
+                                p0[k + 0x40] = (-1 * pw) + 0x80;
+                                p0[k + 0x50] = (-2 * pw) + 0x80;
+                                p0[k + 0x60] = (-3 * pw) + 0x80;
+                                p0[k + 0x70] = (-4 * pw) + 0x80;
+                        }       /* end of for (k=0; k<16; k++, p8++) */
+                }       /* end of for (j=0; j<8; j++ , table++) */
+        } /* end of foreach compression_mode */
+}
+
+/*
+ *
+ */
+static void fill_table_dc00_d800(struct pwc_dec23_private *pdec)
+{
+#define SCALEBITS 15
+#define ONE_HALF  (1UL << (SCALEBITS - 1))
+        int i;
+        unsigned int offset1 = ONE_HALF;
+        unsigned int offset2 = 0x0000;
+
+        for (i=0; i<256; i++) {
+                pdec->table_dc00[i] = offset1 & ~(ONE_HALF);
+                pdec->table_d800[i] = offset2;
+
+                offset1 += 0x7bc4;
+                offset2 += 0x7bc4;
+        }
+}
+
+/*
+ * To decode the stream:
+ *   if look_bits(2) == 0:      # op == 2 in the lookup table
+ *      skip_bits(2)
+ *      end of the stream
+ *   elif look_bits(3) == 7:    # op == 1 in the lookup table
+ *      skip_bits(3)
+ *      yyyy = get_bits(4)
+ *      xxxx = get_bits(8)
+ *   else:                      # op == 0 in the lookup table
+ *      skip_bits(x)
+ *
+ * For speedup processing, we build a lookup table and we takes the first 6 bits.
+ *
+ * struct {
+ *   unsigned char op;      // operation to execute
+ *   unsigned char bits;    // bits use to perform operation
+ *   unsigned char offset1; // offset to add to access in the table_0004 % 16
+ *   unsigned char offset2; // offset to add to access in the table_0004
+ * }
+ *
+ * How to build this table ?
+ *   op == 2 when (i%4)==0
+ *   op == 1 when (i%8)==7
+ *   op == 0 otherwise
+ *
+ */
+static const unsigned char hash_table_ops[64*4] = {
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x00,
+        0x00, 0x04, 0x01, 0x10,
+        0x00, 0x06, 0x01, 0x30,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x40,
+        0x00, 0x05, 0x01, 0x20,
+        0x01, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x00,
+        0x00, 0x04, 0x01, 0x50,
+        0x00, 0x05, 0x02, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x40,
+        0x00, 0x05, 0x03, 0x00,
+        0x01, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x00,
+        0x00, 0x04, 0x01, 0x10,
+        0x00, 0x06, 0x02, 0x10,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x40,
+        0x00, 0x05, 0x01, 0x60,
+        0x01, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x00,
+        0x00, 0x04, 0x01, 0x50,
+        0x00, 0x05, 0x02, 0x40,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x40,
+        0x00, 0x05, 0x03, 0x40,
+        0x01, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x00,
+        0x00, 0x04, 0x01, 0x10,
+        0x00, 0x06, 0x01, 0x70,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x40,
+        0x00, 0x05, 0x01, 0x20,
+        0x01, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x00,
+        0x00, 0x04, 0x01, 0x50,
+        0x00, 0x05, 0x02, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x40,
+        0x00, 0x05, 0x03, 0x00,
+        0x01, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x00,
+        0x00, 0x04, 0x01, 0x10,
+        0x00, 0x06, 0x02, 0x50,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x40,
+        0x00, 0x05, 0x01, 0x60,
+        0x01, 0x00, 0x00, 0x00,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x00,
+        0x00, 0x04, 0x01, 0x50,
+        0x00, 0x05, 0x02, 0x40,
+        0x02, 0x00, 0x00, 0x00,
+        0x00, 0x03, 0x01, 0x40,
+        0x00, 0x05, 0x03, 0x40,
+        0x01, 0x00, 0x00, 0x00
+};
+
+/*
+ *
+ */
+static const unsigned int MulIdx[16][16] = {
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
+        {0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,},
+        {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,},
+        {4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4,},
+        {6, 7, 8, 9, 7, 10, 11, 8, 8, 11, 10, 7, 9, 8, 7, 6,},
+        {4, 5, 5, 4, 4, 5, 5, 4, 4, 5, 5, 4, 4, 5, 5, 4,},
+        {1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2, 1, 3, 0, 2,},
+        {0, 3, 3, 0, 1, 2, 2, 1, 2, 1, 1, 2, 3, 0, 0, 3,},
+        {0, 1, 2, 3, 3, 2, 1, 0, 3, 2, 1, 0, 0, 1, 2, 3,},
+        {1, 1, 1, 1, 3, 3, 3, 3, 0, 0, 0, 0, 2, 2, 2, 2,},
+        {7, 10, 11, 8, 9, 8, 7, 6, 6, 7, 8, 9, 8, 11, 10, 7,},
+        {4, 5, 5, 4, 5, 4, 4, 5, 5, 4, 4, 5, 4, 5, 5, 4,},
+        {7, 9, 6, 8, 10, 8, 7, 11, 11, 7, 8, 10, 8, 6, 9, 7,},
+        {1, 3, 0, 2, 2, 0, 3, 1, 2, 0, 3, 1, 1, 3, 0, 2,},
+        {1, 2, 2, 1, 3, 0, 0, 3, 0, 3, 3, 0, 2, 1, 1, 2,},
+        {10, 8, 7, 11, 8, 6, 9, 7, 7, 9, 6, 8, 11, 7, 8, 10}
+};
+
+#if USE_LOOKUP_TABLE_TO_CLAMP
+#define MAX_OUTER_CROP_VALUE    (512)
+static unsigned char pwc_crop_table[256 + 2*MAX_OUTER_CROP_VALUE];
+#define CLAMP(x) (pwc_crop_table[MAX_OUTER_CROP_VALUE+(x)])
+#else
+#define CLAMP(x) ((x)>255?255:((x)<0?0:x))
+#endif
+
+
+/* If the type or the command change, we rebuild the lookup table */
+int pwc_dec23_init(struct pwc_device *pwc, int type, unsigned char *cmd)
+{
+        int flags, version, shift, i;
+        struct pwc_dec23_private *pdec;
+
+        if (pwc->decompress_data == NULL) {
+                pdec = kmalloc(sizeof(struct pwc_dec23_private), GFP_KERNEL);
+                if (pdec == NULL)
+                        return -ENOMEM;
+                pwc->decompress_data = pdec;
+        }
+        pdec = pwc->decompress_data;
+
+        if (DEVICE_USE_CODEC3(type)) {
+                flags = cmd[2] & 0x18;
+                if (flags == 8)
+                        pdec->nbits = 7;        /* More bits, mean more bits to encode the stream, but better quality */
+                else if (flags == 0x10)
+                        pdec->nbits = 8;
+                else
+                        pdec->nbits = 6;
+
+                version = cmd[2] >> 5;
+                build_table_color(KiaraRomTable[version][0], pdec->table_0004_pass1, pdec->table_8004_pass1);
+                build_table_color(KiaraRomTable[version][1], pdec->table_0004_pass2, pdec->table_8004_pass2);
+
+        } else {
+
+                flags = cmd[2] & 6;
+                if (flags == 2)
+                        pdec->nbits = 7;
+                else if (flags == 4)
+                        pdec->nbits = 8;
+                else
+                        pdec->nbits = 6;
+
+                version = cmd[2] >> 3;
+                build_table_color(TimonRomTable[version][0], pdec->table_0004_pass1, pdec->table_8004_pass1);
+                build_table_color(TimonRomTable[version][1], pdec->table_0004_pass2, pdec->table_8004_pass2);
+        }
+
+        /* Informations can be coded on a variable number of bits but never less than 8 */
+        shift = 8 - pdec->nbits;
+        pdec->scalebits = SCALEBITS - shift;
+        pdec->nbitsmask = 0xFF >> shift;
+
+        fill_table_dc00_d800(pdec);
+        build_subblock_pattern(pdec);
+        build_bit_powermask_table(pdec);
+
+#if USE_LOOKUP_TABLE_TO_CLAMP
+        /* Build the static table to clamp value [0-255] */
+        for (i=0;i<MAX_OUTER_CROP_VALUE;i++)
+                pwc_crop_table[i] = 0;
+        for (i=0; i<256; i++)
+                pwc_crop_table[MAX_OUTER_CROP_VALUE+i] = i;
+        for (i=0; i<MAX_OUTER_CROP_VALUE; i++)
+                pwc_crop_table[MAX_OUTER_CROP_VALUE+256+i] = 255;
+#endif
+
+        return 0;
+}
+
+/*
+ * Copy the 4x4 image block to Y plane buffer
+ */
+static void copy_image_block_Y(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
+{
+#if UNROLL_LOOP_FOR_COPY
+        const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
+        const int *c = src;
+        unsigned char *d = dst;
+
+        *d++ = cm[c[0] >> scalebits];
+        *d++ = cm[c[1] >> scalebits];
+        *d++ = cm[c[2] >> scalebits];
+        *d++ = cm[c[3] >> scalebits];
+
+        d = dst + bytes_per_line;
+        *d++ = cm[c[4] >> scalebits];
+        *d++ = cm[c[5] >> scalebits];
+        *d++ = cm[c[6] >> scalebits];
+        *d++ = cm[c[7] >> scalebits];
+
+        d = dst + bytes_per_line*2;
+        *d++ = cm[c[8] >> scalebits];
+        *d++ = cm[c[9] >> scalebits];
+        *d++ = cm[c[10] >> scalebits];
+        *d++ = cm[c[11] >> scalebits];
+
+        d = dst + bytes_per_line*3;
+        *d++ = cm[c[12] >> scalebits];
+        *d++ = cm[c[13] >> scalebits];
+        *d++ = cm[c[14] >> scalebits];
+        *d++ = cm[c[15] >> scalebits];
+#else
+        int i;
+        const int *c = src;
+        unsigned char *d = dst;
+        for (i = 0; i < 4; i++, c++)
+                *d++ = CLAMP((*c) >> scalebits);
+
+        d = dst + bytes_per_line;
+        for (i = 0; i < 4; i++, c++)
+                *d++ = CLAMP((*c) >> scalebits);
+
+        d = dst + bytes_per_line*2;
+        for (i = 0; i < 4; i++, c++)
+                *d++ = CLAMP((*c) >> scalebits);
+
+        d = dst + bytes_per_line*3;
+        for (i = 0; i < 4; i++, c++)
+                *d++ = CLAMP((*c) >> scalebits);
+#endif
+}
+
+/*
+ * Copy the 4x4 image block to a CrCb plane buffer
+ *
+ */
+static void copy_image_block_CrCb(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
+{
+#if UNROLL_LOOP_FOR_COPY
+        /* Unroll all loops */
+        const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
+        const int *c = src;
+        unsigned char *d = dst;
+
+        *d++ = cm[c[0] >> scalebits];
+        *d++ = cm[c[4] >> scalebits];
+        *d++ = cm[c[1] >> scalebits];
+        *d++ = cm[c[5] >> scalebits];
+        *d++ = cm[c[2] >> scalebits];
+        *d++ = cm[c[6] >> scalebits];
+        *d++ = cm[c[3] >> scalebits];
+        *d++ = cm[c[7] >> scalebits];
+
+        d = dst + bytes_per_line;
+        *d++ = cm[c[12] >> scalebits];
+        *d++ = cm[c[8] >> scalebits];
+        *d++ = cm[c[13] >> scalebits];
+        *d++ = cm[c[9] >> scalebits];
+        *d++ = cm[c[14] >> scalebits];
+        *d++ = cm[c[10] >> scalebits];
+        *d++ = cm[c[15] >> scalebits];
+        *d++ = cm[c[11] >> scalebits];
+#else
+        int i;
+        const int *c1 = src;
+        const int *c2 = src + 4;
+        unsigned char *d = dst;
+
+        for (i = 0; i < 4; i++, c1++, c2++) {
+                *d++ = CLAMP((*c1) >> scalebits);
+                *d++ = CLAMP((*c2) >> scalebits);
+        }
+        c1 = src + 12;
+        d = dst + bytes_per_line;
+        for (i = 0; i < 4; i++, c1++, c2++) {
+                *d++ = CLAMP((*c1) >> scalebits);
+                *d++ = CLAMP((*c2) >> scalebits);
+        }
+#endif
+}
+
+#if ENABLE_BAYER_DECODER
+/*
+ * Format: 8x2 pixels
+ *   . G . G . G . G . G . G . G
+ *   . . . . . . . . . . . . . .
+ *   . G . G . G . G . G . G . G
+ *   . . . . . . . . . . . . . .
+ *   or
+ *   . . . . . . . . . . . . . .
+ *   G . G . G . G . G . G . G .
+ *   . . . . . . . . . . . . . .
+ *   G . G . G . G . G . G . G .
+*/
+static void copy_image_block_Green(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
+{
+#if UNROLL_LOOP_FOR_COPY
+        /* Unroll all loops */
+        const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
+        unsigned char *d = dst;
+        const int *c = src;
+
+        d[0] = cm[c[0] >> scalebits];
+        d[2] = cm[c[1] >> scalebits];
+        d[4] = cm[c[2] >> scalebits];
+        d[6] = cm[c[3] >> scalebits];
+        d[8] = cm[c[4] >> scalebits];
+        d[10] = cm[c[5] >> scalebits];
+        d[12] = cm[c[6] >> scalebits];
+        d[14] = cm[c[7] >> scalebits];
+
+        d = dst + bytes_per_line;
+        d[0] = cm[c[8] >> scalebits];
+        d[2] = cm[c[9] >> scalebits];
+        d[4] = cm[c[10] >> scalebits];
+        d[6] = cm[c[11] >> scalebits];
+        d[8] = cm[c[12] >> scalebits];
+        d[10] = cm[c[13] >> scalebits];
+        d[12] = cm[c[14] >> scalebits];
+        d[14] = cm[c[15] >> scalebits];
+#else
+        int i;
+        unsigned char *d;
+        const int *c = src;
+
+        d = dst;
+        for (i = 0; i < 8; i++, c++)
+                d[i*2] = CLAMP((*c) >> scalebits);
+
+        d = dst + bytes_per_line;
+        for (i = 0; i < 8; i++, c++)
+                d[i*2] = CLAMP((*c) >> scalebits);
+#endif
+}
+#endif
+
+#if ENABLE_BAYER_DECODER
+/*
+ * Format: 4x4 pixels
+ *   R . R . R . R
+ *   . B . B . B .
+ *   R . R . R . R
+ *   . B . B . B .
+ */
+static void copy_image_block_RedBlue(const int *src, unsigned char *dst, unsigned int bytes_per_line, unsigned int scalebits)
+{
+#if UNROLL_LOOP_FOR_COPY
+        /* Unroll all loops */
+        const unsigned char *cm = pwc_crop_table+MAX_OUTER_CROP_VALUE;
+        unsigned char *d = dst;
+        const int *c = src;
+
+        d[0] = cm[c[0] >> scalebits];
+        d[2] = cm[c[1] >> scalebits];
+        d[4] = cm[c[2] >> scalebits];
+        d[6] = cm[c[3] >> scalebits];
+
+        d = dst + bytes_per_line;
+        d[1] = cm[c[4] >> scalebits];
+        d[3] = cm[c[5] >> scalebits];
+        d[5] = cm[c[6] >> scalebits];
+        d[7] = cm[c[7] >> scalebits];
+
+        d = dst + bytes_per_line*2;
+        d[0] = cm[c[8] >> scalebits];
+        d[2] = cm[c[9] >> scalebits];
+        d[4] = cm[c[10] >> scalebits];
+        d[6] = cm[c[11] >> scalebits];
+
+        d = dst + bytes_per_line*3;
+        d[1] = cm[c[12] >> scalebits];
+        d[3] = cm[c[13] >> scalebits];
+        d[5] = cm[c[14] >> scalebits];
+        d[7] = cm[c[15] >> scalebits];
+#else
+        int i;
+        unsigned char *d;
+        const int *c = src;
+
+        d = dst;
+        for (i = 0; i < 4; i++, c++)
+                d[i*2] = CLAMP((*c) >> scalebits);
+
+        d = dst + bytes_per_line;
+        for (i = 0; i < 4; i++, c++)
+                d[i*2+1] = CLAMP((*c) >> scalebits);
+
+        d = dst + bytes_per_line*2;
+        for (i = 0; i < 4; i++, c++)
+                d[i*2] = CLAMP((*c) >> scalebits);
+
+        d = dst + bytes_per_line*3;
+        for (i = 0; i < 4; i++, c++)
+                d[i*2+1] = CLAMP((*c) >> scalebits);
+#endif
+}
+#endif
+
+/*
+ * To manage the stream, we keep bits in a 32 bits register.
+ * fill_nbits(n): fill the reservoir with at least n bits
+ * skip_bits(n): discard n bits from the reservoir
+ * get_bits(n): fill the reservoir, returns the first n bits and discard the
+ *              bits from the reservoir.
+ * __get_nbits(n): faster version of get_bits(n), but asumes that the reservoir
+ *                 contains at least n bits. bits returned is discarded.
+ */
+#define fill_nbits(pdec, nbits_wanted) do { \
+   while (pdec->nbits_in_reservoir<(nbits_wanted)) \
+    { \
+      pdec->reservoir |= (*(pdec->stream)++) << (pdec->nbits_in_reservoir); \
+      pdec->nbits_in_reservoir += 8; \
+    } \
+}  while(0);
+
+#define skip_nbits(pdec, nbits_to_skip) do { \
+   pdec->reservoir >>= (nbits_to_skip); \
+   pdec->nbits_in_reservoir -= (nbits_to_skip); \
+}  while(0);
+
+#define get_nbits(pdec, nbits_wanted, result) do { \
+   fill_nbits(pdec, nbits_wanted); \
+   result = (pdec->reservoir) & ((1U<<(nbits_wanted))-1); \
+   skip_nbits(pdec, nbits_wanted); \
+}  while(0);
+
+#define __get_nbits(pdec, nbits_wanted, result) do { \
+   result = (pdec->reservoir) & ((1U<<(nbits_wanted))-1); \
+   skip_nbits(pdec, nbits_wanted); \
+}  while(0);
+
+#define look_nbits(pdec, nbits_wanted) \
+   ((pdec->reservoir) & ((1U<<(nbits_wanted))-1))
+
+/*
+ * Decode a 4x4 pixel block
+ */
+static void decode_block(struct pwc_dec23_private *pdec,
+                         const unsigned char *ptable0004,
+                         const unsigned char *ptable8004)
+{
+        unsigned int primary_color;
+        unsigned int channel_v, offset1, op;
+        int i;
+
+        fill_nbits(pdec, 16);
+        __get_nbits(pdec, pdec->nbits, primary_color);
+
+        if (look_nbits(pdec,2) == 0) {
+                skip_nbits(pdec, 2);
+                /* Very simple, the color is the same for all pixels of the square */
+                for (i = 0; i < 16; i++)
+                        pdec->temp_colors[i] = pdec->table_dc00[primary_color];
+
+                return;
+        }
+
+        /* This block is encoded with small pattern */
+        for (i = 0; i < 16; i++)
+                pdec->temp_colors[i] = pdec->table_d800[primary_color];
+
+        __get_nbits(pdec, 3, channel_v);
+        channel_v = ((channel_v & 1) << 2) | (channel_v & 2) | ((channel_v & 4) >> 2);
+
+        ptable0004 += (channel_v * 128);
+        ptable8004 += (channel_v * 32);
+
+        offset1 = 0;
+        do
+        {
+                unsigned int htable_idx, rows = 0;
+                const unsigned int *block;
+
+                /* [  zzzz y x x ]
+                 *     xx == 00 :=> end of the block def, remove the two bits from the stream
+                 *    yxx == 111
+                 *    yxx == any other value
+                 *
+                 */
+                fill_nbits(pdec, 16);
+                htable_idx = look_nbits(pdec, 6);
+                op = hash_table_ops[htable_idx * 4];
+
+                if (op == 2) {
+                        skip_nbits(pdec, 2);
+
+                } else if (op == 1) {
+                        /* 15bits [ xxxx xxxx yyyy 111 ]
+                         * yyy => offset in the table8004
+                         * xxx => offset in the tabled004 (tree)
+                         */
+                        unsigned int mask, shift;
+                        unsigned int nbits, col1;
+                        unsigned int yyyy;
+
+                        skip_nbits(pdec, 3);
+                        /* offset1 += yyyy */
+                        __get_nbits(pdec, 4, yyyy);
+                        offset1 += 1 + yyyy;
+                        offset1 &= 0x0F;
+                        nbits = ptable8004[offset1 * 2];
+
+                        /* col1 = xxxx xxxx */
+                        __get_nbits(pdec, nbits+1, col1);
+
+                        /* Bit mask table */
+                        mask = pdec->table_bitpowermask[nbits][col1];
+                        shift = ptable8004[offset1 * 2 + 1];
+                        rows = ((mask << shift) + 0x80) & 0xFF;
+
+                        block = pdec->table_subblock[rows];
+                        for (i = 0; i < 16; i++)
+                                pdec->temp_colors[i] += block[MulIdx[offset1][i]];
+
+                } else {
+                        /* op == 0
+                         * offset1 is coded on 3 bits
+                         */
+                        unsigned int shift;
+
+                        offset1 += hash_table_ops [htable_idx * 4 + 2];
+                        offset1 &= 0x0F;
+
+                        rows = ptable0004[offset1 + hash_table_ops [htable_idx * 4 + 3]];
+                        block = pdec->table_subblock[rows];
+                        for (i = 0; i < 16; i++)
+                                pdec->temp_colors[i] += block[MulIdx[offset1][i]];
+
+                        shift = hash_table_ops[htable_idx * 4 + 1];
+                        skip_nbits(pdec, shift);
+                }
+
+        } while (op != 2);
+
+}
+
+static void DecompressBand23(struct pwc_dec23_private *pdec,
+                             const unsigned char *rawyuv,
+                             unsigned char *planar_y,
+                             unsigned char *planar_u,
+                             unsigned char *planar_v,
+                             unsigned int   compressed_image_width,
+                             unsigned int   real_image_width)
+{
+        int compression_index, nblocks;
+        const unsigned char *ptable0004;
+        const unsigned char *ptable8004;
+
+        pdec->reservoir = 0;
+        pdec->nbits_in_reservoir = 0;
+        pdec->stream = rawyuv + 1;      /* The first byte of the stream is skipped */
+
+        get_nbits(pdec, 4, compression_index);
+
+        /* pass 1: uncompress Y component */
+        nblocks = compressed_image_width / 4;
+
+        ptable0004 = pdec->table_0004_pass1[compression_index];
+        ptable8004 = pdec->table_8004_pass1[compression_index];
+
+        /* Each block decode a square of 4x4 */
+        while (nblocks) {
+                decode_block(pdec, ptable0004, ptable8004);
+                copy_image_block_Y(pdec->temp_colors, planar_y, real_image_width, pdec->scalebits);
+                planar_y += 4;
+                nblocks--;
+        }
+
+        /* pass 2: uncompress UV component */
+        nblocks = compressed_image_width / 8;
+
+        ptable0004 = pdec->table_0004_pass2[compression_index];
+        ptable8004 = pdec->table_8004_pass2[compression_index];
+
+        /* Each block decode a square of 4x4 */
+        while (nblocks) {
+                decode_block(pdec, ptable0004, ptable8004);
+                copy_image_block_CrCb(pdec->temp_colors, planar_u, real_image_width/2, pdec->scalebits);
+
+                decode_block(pdec, ptable0004, ptable8004);
+                copy_image_block_CrCb(pdec->temp_colors, planar_v, real_image_width/2, pdec->scalebits);
+
+                planar_v += 8;
+                planar_u += 8;
+                nblocks -= 2;
+        }
+
+}
+
+#if ENABLE_BAYER_DECODER
+/*
+ * Size need to be a multiple of 8 in width
+ *
+ * Return a block of four line encoded like this:
+ *
+ *   G R G R G R G R G R G R G R G R
+ *   B G B G B G B G B G B G B G B G
+ *   G R G R G R G R G R G R G R G R
+ *   B G B G B G B G B G B G B G B G
+ *
+ */
+static void DecompressBandBayer(struct pwc_dec23_private *pdec,
+                                const unsigned char *rawyuv,
+                                unsigned char *rgbbayer,
+                                unsigned int   compressed_image_width,
+                                unsigned int   real_image_width)
+{
+        int compression_index, nblocks;
+        const unsigned char *ptable0004;
+        const unsigned char *ptable8004;
+        unsigned char *dest;
+
+        pdec->reservoir = 0;
+        pdec->nbits_in_reservoir = 0;
+        pdec->stream = rawyuv + 1;      /* The first byte of the stream is skipped */
+
+        get_nbits(pdec, 4, compression_index);
+
+        /* pass 1: uncompress RB component */
+        nblocks = compressed_image_width / 4;
+
+        ptable0004 = pdec->table_0004_pass1[compression_index];
+        ptable8004 = pdec->table_8004_pass1[compression_index];
+        dest = rgbbayer;
+
+        /* Each block decode a square of 4x4 */
+        while (nblocks) {
+                decode_block(pdec, ptable0004, ptable8004);
+                copy_image_block_RedBlue(pdec->temp_colors, rgbbayer, real_image_width, pdec->scalebits);
+                dest += 8;
+                nblocks--;
+        }
+
+        /* pass 2: uncompress G component */
+        nblocks = compressed_image_width / 8;
+
+        ptable0004 = pdec->table_0004_pass2[compression_index];
+        ptable8004 = pdec->table_8004_pass2[compression_index];
+
+        /* Each block decode a square of 4x4 */
+        while (nblocks) {
+                decode_block(pdec, ptable0004, ptable8004);
+                copy_image_block_Green(pdec->temp_colors, rgbbayer+1, real_image_width, pdec->scalebits);
+
+                decode_block(pdec, ptable0004, ptable8004);
+                copy_image_block_Green(pdec->temp_colors, rgbbayer+real_image_width, real_image_width, pdec->scalebits);
+
+                rgbbayer += 16;
+                nblocks -= 2;
+        }
+}
+#endif
+
+
+/**
+ *
+ * Uncompress a pwc23 buffer.
+ *
+ * pwc.view: size of the image wanted
+ * pwc.image: size of the image returned by the camera
+ * pwc.offset: (x,y) to displayer image in the view
+ *
+ * src: raw data
+ * dst: image output
+ * flags: PWCX_FLAG_PLANAR or PWCX_FLAG_BAYER
+ */
+void pwc_dec23_decompress(const struct pwc_device *pwc,
+                          const void *src,
+                          void *dst,
+                          int flags)
+{
+        int bandlines_left, stride, bytes_per_block;
+
+        bandlines_left = pwc->image.y / 4;
+        bytes_per_block = pwc->view.x * 4;
+
+        if (flags & PWCX_FLAG_BAYER) {
+#if ENABLE_BAYER_DECODER
+                /* RGB Bayer format */
+                unsigned char *rgbout;
+
+                stride = pwc->view.x * pwc->offset.y;
+                rgbout = dst + stride + pwc->offset.x;
+
+
+                while (bandlines_left--) {
+
+                        DecompressBandBayer(pwc->decompress_data,
+                                            src,
+                                            rgbout,
+                                            pwc->image.x, pwc->view.x);
+
+                        src += pwc->vbandlength;
+                        rgbout += bytes_per_block;
+
+                }
+#else
+                memset(dst, 0, pwc->view.x * pwc->view.y);
+#endif
+
+        } else {
+                /* YUV420P image format */
+                unsigned char *pout_planar_y;
+                unsigned char *pout_planar_u;
+                unsigned char *pout_planar_v;
+                unsigned int   plane_size;
+
+                plane_size = pwc->view.x * pwc->view.y;
+
+                /* offset in Y plane */
+                stride = pwc->view.x * pwc->offset.y;
+                pout_planar_y = dst + stride + pwc->offset.x;
+
+                /* offsets in U/V planes */
+                stride = (pwc->view.x * pwc->offset.y) / 4 + pwc->offset.x / 2;
+                pout_planar_u = dst + plane_size + stride;
+                pout_planar_v = dst + plane_size + plane_size / 4 + stride;
+
+                while (bandlines_left--) {
+
+                        DecompressBand23(pwc->decompress_data,
+                                         src,
+                                         pout_planar_y, pout_planar_u, pout_planar_v,
+                                         pwc->image.x, pwc->view.x);
+                        src += pwc->vbandlength;
+                        pout_planar_y += bytes_per_block;
+                        pout_planar_u += pwc->view.x;
+                        pout_planar_v += pwc->view.x;
+
+                }
+
+        }
+
+}
+
+void pwc_dec23_exit(void)
+{
+        /* Do nothing */
+
+}
+
+/**
+ * Allocate a private structure used by lookup table.
+ * You must call kfree() to free the memory allocated.
+ */
+int pwc_dec23_alloc(struct pwc_device *pwc)
+{
+        pwc->decompress_data = kmalloc(sizeof(struct pwc_dec23_private), GFP_KERNEL);
+        if (pwc->decompress_data == NULL)
+                return -ENOMEM;
+        return 0;
+}
+
+/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
diff --git a/drivers/media/video/pwc/pwc-dec23.h b/drivers/media/video/pwc/pwc-dec23.h
new file mode 100644
index 00000000000..1c55298ad15
--- /dev/null
+++ b/drivers/media/video/pwc/pwc-dec23.h
@@ -0,0 +1,67 @@
+/* Linux driver for Philips webcam
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
+
+   NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
+   driver and thus may have bugs that are not present in the original version.
+   Please send bug reports and support requests to <luc@saillard.org>.
+   The decompression routines have been implemented by reverse-engineering the
+   Nemosoft binary pwcx module. Caveat emptor.
+
+   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef PWC_DEC23_H
+#define PWC_DEC23_H
+
+#include "pwc.h"
+
+struct pwc_dec23_private
+{
+  unsigned int scalebits;
+  unsigned int nbitsmask, nbits; /* Number of bits of a color in the compressed stream */
+
+  unsigned int reservoir;
+  unsigned int nbits_in_reservoir;
+  const unsigned char *stream;
+  int temp_colors[16];
+
+  unsigned char table_0004_pass1[16][1024];
+  unsigned char table_0004_pass2[16][1024];
+  unsigned char table_8004_pass1[16][256];
+  unsigned char table_8004_pass2[16][256];
+  unsigned int  table_subblock[256][12];
+
+  unsigned char table_bitpowermask[8][256];
+  unsigned int  table_d800[256];
+  unsigned int  table_dc00[256];
+
+};
+
+
+int pwc_dec23_alloc(struct pwc_device *pwc);
+int pwc_dec23_init(struct pwc_device *pwc, int type, unsigned char *cmd);
+void pwc_dec23_exit(void);
+void pwc_dec23_decompress(const struct pwc_device *pwc,
+                          const void *src,
+                          void *dst,
+                          int flags);
+
+
+
+#endif
+
+
+/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
+
diff --git a/drivers/media/video/pwc/pwc-if.c b/drivers/media/video/pwc/pwc-if.c
index 41418294a32..47d0d83a026 100644
--- a/drivers/media/video/pwc/pwc-if.c
+++ b/drivers/media/video/pwc/pwc-if.c
@@ -1,7 +1,7 @@
 /* Linux driver for Philips webcam
    USB and Video4Linux interface part.
    (C) 1999-2004 Nemosoft Unv.
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -62,18 +62,21 @@
 #include <linux/poll.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
+#include <linux/version.h>
 #include <asm/io.h>
+#include <linux/moduleparam.h>
 
 #include "pwc.h"
-#include "pwc-ioctl.h"
 #include "pwc-kiara.h"
 #include "pwc-timon.h"
+#include "pwc-dec23.h"
+#include "pwc-dec1.h"
 #include "pwc-uncompress.h"
 
 /* Function prototypes and driver templates */
 
 /* hotplug device table support */
-static struct usb_device_id pwc_device_table [] = {
+static const struct usb_device_id pwc_device_table [] = {
         { USB_DEVICE(0x0471, 0x0302) }, /* Philips models */
         { USB_DEVICE(0x0471, 0x0303) },
         { USB_DEVICE(0x0471, 0x0304) },
@@ -81,9 +84,10 @@ static struct usb_device_id pwc_device_table [] = {
         { USB_DEVICE(0x0471, 0x0308) },
         { USB_DEVICE(0x0471, 0x030C) },
         { USB_DEVICE(0x0471, 0x0310) },
-        { USB_DEVICE(0x0471, 0x0311) },
+        { USB_DEVICE(0x0471, 0x0311) }, /* Philips ToUcam PRO II */
         { USB_DEVICE(0x0471, 0x0312) },
         { USB_DEVICE(0x0471, 0x0313) }, /* the 'new' 720K */
+        { USB_DEVICE(0x0471, 0x0329) }, /* Philips SPC 900NC PC Camera */
         { USB_DEVICE(0x069A, 0x0001) }, /* Askey */
         { USB_DEVICE(0x046D, 0x08B0) }, /* Logitech QuickCam Pro 3000 */
         { USB_DEVICE(0x046D, 0x08B1) }, /* Logitech QuickCam Notebook Pro */
@@ -94,8 +98,9 @@ static struct usb_device_id pwc_device_table [] = {
         { USB_DEVICE(0x046D, 0x08B6) }, /* Logitech (reserved) */
         { USB_DEVICE(0x046D, 0x08B7) }, /* Logitech (reserved) */
         { USB_DEVICE(0x046D, 0x08B8) }, /* Logitech (reserved) */
-        { USB_DEVICE(0x055D, 0x9000) }, /* Samsung */
-        { USB_DEVICE(0x055D, 0x9001) },
+        { USB_DEVICE(0x055D, 0x9000) }, /* Samsung MPC-C10 */
+        { USB_DEVICE(0x055D, 0x9001) }, /* Samsung MPC-C30 */
+        { USB_DEVICE(0x055D, 0x9002) }, /* Samsung SNC-35E (Ver3.0) */
         { USB_DEVICE(0x041E, 0x400C) }, /* Creative Webcam 5 */
         { USB_DEVICE(0x041E, 0x4011) }, /* Creative Webcam Pro Ex */
         { USB_DEVICE(0x04CC, 0x8116) }, /* Afina Eye */
@@ -122,11 +127,13 @@ static struct usb_driver pwc_driver = {
 static int default_size = PSZ_QCIF;
 static int default_fps = 10;
 static int default_fbufs = 3;   /* Default number of frame buffers */
-static int default_mbufs = 2;   /* Default number of mmap() buffers */
-       int pwc_trace = TRACE_MODULE | TRACE_FLOW | TRACE_PWCX;
+       int pwc_mbufs = 2;       /* Default number of mmap() buffers */
+#if CONFIG_PWC_DEBUG
+       int pwc_trace = PWC_DEBUG_LEVEL;
+#endif
 static int power_save = 0;
 static int led_on = 100, led_off = 0; /* defaults to LED that is on while in use */
-static int pwc_preferred_compression = 2; /* 0..3 = uncompressed..high */
+static int pwc_preferred_compression = 1; /* 0..3 = uncompressed..high */
 static struct {
         int type;
         char serial_number[30];
@@ -138,7 +145,7 @@ static struct {
 
 static int pwc_video_open(struct inode *inode, struct file *file);
 static int pwc_video_close(struct inode *inode, struct file *file);
-static ssize_t pwc_video_read(struct file *file, char __user * buf,
+static ssize_t pwc_video_read(struct file *file, char __user *buf,
                           size_t count, loff_t *ppos);
 static unsigned int pwc_video_poll(struct file *file, poll_table *wait);
 static int  pwc_video_ioctl(struct inode *inode, struct file *file,
@@ -153,7 +160,6 @@ static struct file_operations pwc_fops = {
         .poll =         pwc_video_poll,
         .mmap =         pwc_video_mmap,
         .ioctl =        pwc_video_ioctl,
-        .compat_ioctl = v4l_compat_ioctl32,
         .llseek =       no_llseek,
 };
 static struct video_device pwc_template = {
@@ -203,52 +209,44 @@ static struct video_device pwc_template = {
 /* Here we want the physical address of the memory.
  * This is used when initializing the contents of the area.
  */
-static inline unsigned long kvirt_to_pa(unsigned long adr)
-{
-        unsigned long kva, ret;
 
-        kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));
-        kva |= adr & (PAGE_SIZE-1); /* restore the offset */
-        ret = __pa(kva);
-        return ret;
-}
 
-static void * rvmalloc(unsigned long size)
+
+static void *pwc_rvmalloc(unsigned long size)
 {
         void * mem;
         unsigned long adr;
 
-        size=PAGE_ALIGN(size);
         mem=vmalloc_32(size);
-        if (mem)
-        {
-                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;
-                }
-        }
+        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)
+static void pwc_rvfree(void * mem, unsigned long size)
 {
         unsigned long adr;
 
-        if (mem)
-        {
-                adr=(unsigned long) mem;
-                while ((long) size > 0)
-                {
-                        ClearPageReserved(vmalloc_to_page((void *)adr));
-                        adr+=PAGE_SIZE;
-                        size-=PAGE_SIZE;
-                }
-                vfree(mem);
-        }
+        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);
 }
 
 
@@ -256,100 +254,83 @@ static void rvfree(void * mem, unsigned long size)
 
 static int pwc_allocate_buffers(struct pwc_device *pdev)
 {
-        int i;
+        int i, err;
         void *kbuf;
 
-        Trace(TRACE_MEMORY, ">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);
+        PWC_DEBUG_MEMORY(">> pwc_allocate_buffers(pdev = 0x%p)\n", pdev);
 
         if (pdev == NULL)
                 return -ENXIO;
 
-#ifdef PWC_MAGIC
-        if (pdev->magic != PWC_MAGIC) {
-                Err("allocate_buffers(): magic failed.\n");
-                return -ENXIO;
-        }
-#endif
-        /* Allocate Isochronous pipe buffers */
+        /* Allocate Isochronuous pipe buffers */
         for (i = 0; i < MAX_ISO_BUFS; i++) {
                 if (pdev->sbuf[i].data == NULL) {
-                        kbuf = kmalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
+                        kbuf = kzalloc(ISO_BUFFER_SIZE, GFP_KERNEL);
                         if (kbuf == NULL) {
-                                Err("Failed to allocate iso buffer %d.\n", i);
+                                PWC_ERROR("Failed to allocate iso buffer %d.\n", i);
                                 return -ENOMEM;
                         }
-                        Trace(TRACE_MEMORY, "Allocated iso buffer at %p.\n", kbuf);
+                        PWC_DEBUG_MEMORY("Allocated iso buffer at %p.\n", kbuf);
                         pdev->sbuf[i].data = kbuf;
-                        memset(kbuf, 0, ISO_BUFFER_SIZE);
                 }
         }
 
         /* Allocate frame buffer structure */
         if (pdev->fbuf == NULL) {
-                kbuf = kmalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
+                kbuf = kzalloc(default_fbufs * sizeof(struct pwc_frame_buf), GFP_KERNEL);
                 if (kbuf == NULL) {
-                        Err("Failed to allocate frame buffer structure.\n");
+                        PWC_ERROR("Failed to allocate frame buffer structure.\n");
                         return -ENOMEM;
                 }
-                Trace(TRACE_MEMORY, "Allocated frame buffer structure at %p.\n", kbuf);
+                PWC_DEBUG_MEMORY("Allocated frame buffer structure at %p.\n", kbuf);
                 pdev->fbuf = kbuf;
-                memset(kbuf, 0, default_fbufs * sizeof(struct pwc_frame_buf));
         }
+
         /* create frame buffers, and make circular ring */
         for (i = 0; i < default_fbufs; i++) {
                 if (pdev->fbuf[i].data == NULL) {
                         kbuf = vmalloc(PWC_FRAME_SIZE); /* need vmalloc since frame buffer > 128K */
                         if (kbuf == NULL) {
-                                Err("Failed to allocate frame buffer %d.\n", i);
+                                PWC_ERROR("Failed to allocate frame buffer %d.\n", i);
                                 return -ENOMEM;
                         }
-                        Trace(TRACE_MEMORY, "Allocated frame buffer %d at %p.\n", i, kbuf);
+                        PWC_DEBUG_MEMORY("Allocated frame buffer %d at %p.\n", i, kbuf);
                         pdev->fbuf[i].data = kbuf;
-                        memset(kbuf, 128, PWC_FRAME_SIZE);
+                        memset(kbuf, 0, PWC_FRAME_SIZE);
                 }
         }
 
         /* Allocate decompressor table space */
-        kbuf = NULL;
-        switch (pdev->type)
-         {
-          case 675:
-          case 680:
-          case 690:
-          case 720:
-          case 730:
-          case 740:
-          case 750:
-#if 0
-            Trace(TRACE_MEMORY,"private_data(%zu)\n",sizeof(struct pwc_dec23_private));
-            kbuf = kmalloc(sizeof(struct pwc_dec23_private), GFP_KERNEL);       /* Timon & Kiara */
-            break;
-          case 645:
-          case 646:
-            /* TODO & FIXME */
-            kbuf = kmalloc(sizeof(struct pwc_dec23_private), GFP_KERNEL);
-            break;
-#endif
-        ;
-         }
-        pdev->decompress_data = kbuf;
+        if (DEVICE_USE_CODEC1(pdev->type))
+                err = pwc_dec1_alloc(pdev);
+        else
+                err = pwc_dec23_alloc(pdev);
+
+        if (err) {
+                PWC_ERROR("Failed to allocate decompress table.\n");
+                return err;
+        }
 
         /* Allocate image buffer; double buffer for mmap() */
-        kbuf = rvmalloc(default_mbufs * pdev->len_per_image);
+        kbuf = pwc_rvmalloc(pwc_mbufs * pdev->len_per_image);
         if (kbuf == NULL) {
-                Err("Failed to allocate image buffer(s). needed (%d)\n",default_mbufs * pdev->len_per_image);
+                PWC_ERROR("Failed to allocate image buffer(s). needed (%d)\n",
+                                pwc_mbufs * pdev->len_per_image);
                 return -ENOMEM;
         }
-        Trace(TRACE_MEMORY, "Allocated image buffer at %p.\n", kbuf);
+        PWC_DEBUG_MEMORY("Allocated image buffer at %p.\n", kbuf);
         pdev->image_data = kbuf;
-        for (i = 0; i < default_mbufs; i++)
-                pdev->image_ptr[i] = kbuf + i * pdev->len_per_image;
-        for (; i < MAX_IMAGES; i++)
-                pdev->image_ptr[i] = NULL;
+        for (i = 0; i < pwc_mbufs; i++) {
+                pdev->images[i].offset = i * pdev->len_per_image;
+                pdev->images[i].vma_use_count = 0;
+        }
+        for (; i < MAX_IMAGES; i++) {
+                pdev->images[i].offset = 0;
+        }
 
         kbuf = NULL;
 
-        Trace(TRACE_MEMORY, "<< pwc_allocate_buffers()\n");
+        PWC_DEBUG_MEMORY("<< pwc_allocate_buffers()\n");
         return 0;
 }
 
@@ -357,21 +338,14 @@ static void pwc_free_buffers(struct pwc_device *pdev)
 {
         int i;
 
-        Trace(TRACE_MEMORY, "Entering free_buffers(%p).\n", pdev);
+        PWC_DEBUG_MEMORY("Entering free_buffers(%p).\n", pdev);
 
         if (pdev == NULL)
                 return;
-#ifdef PWC_MAGIC
-        if (pdev->magic != PWC_MAGIC) {
-                Err("free_buffers(): magic failed.\n");
-                return;
-        }
-#endif
-
         /* Release Iso-pipe buffers */
         for (i = 0; i < MAX_ISO_BUFS; i++)
                 if (pdev->sbuf[i].data != NULL) {
-                        Trace(TRACE_MEMORY, "Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
+                        PWC_DEBUG_MEMORY("Freeing ISO buffer at %p.\n", pdev->sbuf[i].data);
                         kfree(pdev->sbuf[i].data);
                         pdev->sbuf[i].data = NULL;
                 }
@@ -380,7 +354,7 @@ static void pwc_free_buffers(struct pwc_device *pdev)
         if (pdev->fbuf != NULL) {
                 for (i = 0; i < default_fbufs; i++) {
                         if (pdev->fbuf[i].data != NULL) {
-                                Trace(TRACE_MEMORY, "Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
+                                PWC_DEBUG_MEMORY("Freeing frame buffer %d at %p.\n", i, pdev->fbuf[i].data);
                                 vfree(pdev->fbuf[i].data);
                                 pdev->fbuf[i].data = NULL;
                         }
@@ -391,20 +365,19 @@ static void pwc_free_buffers(struct pwc_device *pdev)
 
         /* Intermediate decompression buffer & tables */
         if (pdev->decompress_data != NULL) {
-                Trace(TRACE_MEMORY, "Freeing decompression buffer at %p.\n", pdev->decompress_data);
+                PWC_DEBUG_MEMORY("Freeing decompression buffer at %p.\n", pdev->decompress_data);
                 kfree(pdev->decompress_data);
                 pdev->decompress_data = NULL;
         }
-        pdev->decompressor = NULL;
 
         /* Release image buffers */
         if (pdev->image_data != NULL) {
-                Trace(TRACE_MEMORY, "Freeing image buffer at %p.\n", pdev->image_data);
-                rvfree(pdev->image_data, default_mbufs * pdev->len_per_image);
+                PWC_DEBUG_MEMORY("Freeing image buffer at %p.\n", pdev->image_data);
+                pwc_rvfree(pdev->image_data, pwc_mbufs * pdev->len_per_image);
         }
         pdev->image_data = NULL;
 
-        Trace(TRACE_MEMORY, "Leaving free_buffers().\n");
+        PWC_DEBUG_MEMORY("Leaving free_buffers().\n");
 }
 
 /* The frame & image buffer mess.
@@ -464,7 +437,7 @@ static void pwc_free_buffers(struct pwc_device *pdev)
 /**
   \brief Find next frame buffer to fill. Take from empty or full list, whichever comes first.
  */
-static inline int pwc_next_fill_frame(struct pwc_device *pdev)
+static int pwc_next_fill_frame(struct pwc_device *pdev)
 {
         int ret;
         unsigned long flags;
@@ -489,23 +462,17 @@ static inline int pwc_next_fill_frame(struct pwc_device *pdev)
         }
         else {
                 /* Hmm. Take it from the full list */
-#if PWC_DEBUG
                 /* sanity check */
                 if (pdev->full_frames == NULL) {
-                        Err("Neither empty or full frames available!\n");
+                        PWC_ERROR("Neither empty or full frames available!\n");
                         spin_unlock_irqrestore(&pdev->ptrlock, flags);
                         return -EINVAL;
                 }
-#endif
                 pdev->fill_frame = pdev->full_frames;
                 pdev->full_frames = pdev->full_frames->next;
                 ret = 1;
         }
         pdev->fill_frame->next = NULL;
-#if PWC_DEBUG
-        Trace(TRACE_SEQUENCE, "Assigning sequence number %d.\n", pdev->sequence);
-        pdev->fill_frame->sequence = pdev->sequence++;
-#endif
         spin_unlock_irqrestore(&pdev->ptrlock, flags);
         return ret;
 }
@@ -521,6 +488,8 @@ static void pwc_reset_buffers(struct pwc_device *pdev)
         int i;
         unsigned long flags;
 
+        PWC_DEBUG_MEMORY(">> %s __enter__\n", __FUNCTION__);
+
         spin_lock_irqsave(&pdev->ptrlock, flags);
         pdev->full_frames = NULL;
         pdev->full_frames_tail = NULL;
@@ -540,13 +509,15 @@ static void pwc_reset_buffers(struct pwc_device *pdev)
         pdev->image_read_pos = 0;
         pdev->fill_image = 0;
         spin_unlock_irqrestore(&pdev->ptrlock, flags);
+
+        PWC_DEBUG_MEMORY("<< %s __leaving__\n", __FUNCTION__);
 }
 
 
 /**
   \brief Do all the handling for getting one frame: get pointer, decompress, advance pointers.
  */
-static int pwc_handle_frame(struct pwc_device *pdev)
+int pwc_handle_frame(struct pwc_device *pdev)
 {
         int ret = 0;
         unsigned long flags;
@@ -556,41 +527,40 @@ static int pwc_handle_frame(struct pwc_device *pdev)
            we can release the lock after this without problems */
         if (pdev->read_frame != NULL) {
                 /* This can't theoretically happen */
-                Err("Huh? Read frame still in use?\n");
+                PWC_ERROR("Huh? Read frame still in use?\n");
+                spin_unlock_irqrestore(&pdev->ptrlock, flags);
+                return ret;
+        }
+
+
+        if (pdev->full_frames == NULL) {
+                PWC_ERROR("Woops. No frames ready.\n");
         }
         else {
-                if (pdev->full_frames == NULL) {
-                        Err("Woops. No frames ready.\n");
+                pdev->read_frame = pdev->full_frames;
+                pdev->full_frames = pdev->full_frames->next;
+                pdev->read_frame->next = NULL;
+        }
+
+        if (pdev->read_frame != NULL) {
+                /* Decompression is a lenghty process, so it's outside of the lock.
+                   This gives the isoc_handler the opportunity to fill more frames
+                   in the mean time.
+                */
+                spin_unlock_irqrestore(&pdev->ptrlock, flags);
+                ret = pwc_decompress(pdev);
+                spin_lock_irqsave(&pdev->ptrlock, flags);
+
+                /* We're done with read_buffer, tack it to the end of the empty buffer list */
+                if (pdev->empty_frames == NULL) {
+                        pdev->empty_frames = pdev->read_frame;
+                        pdev->empty_frames_tail = pdev->empty_frames;
                 }
                 else {
-                        pdev->read_frame = pdev->full_frames;
-                        pdev->full_frames = pdev->full_frames->next;
-                        pdev->read_frame->next = NULL;
-                }
-
-                if (pdev->read_frame != NULL) {
-#if PWC_DEBUG
-                        Trace(TRACE_SEQUENCE, "Decompressing frame %d\n", pdev->read_frame->sequence);
-#endif
-                        /* Decompression is a lenghty process, so it's outside of the lock.
-                           This gives the isoc_handler the opportunity to fill more frames
-                           in the mean time.
-                        */
-                        spin_unlock_irqrestore(&pdev->ptrlock, flags);
-                        ret = pwc_decompress(pdev);
-                        spin_lock_irqsave(&pdev->ptrlock, flags);
-
-                        /* We're done with read_buffer, tack it to the end of the empty buffer list */
-                        if (pdev->empty_frames == NULL) {
-                                pdev->empty_frames = pdev->read_frame;
-                                pdev->empty_frames_tail = pdev->empty_frames;
-                        }
-                        else {
-                                pdev->empty_frames_tail->next = pdev->read_frame;
-                                pdev->empty_frames_tail = pdev->read_frame;
-                        }
-                        pdev->read_frame = NULL;
+                        pdev->empty_frames_tail->next = pdev->read_frame;
+                        pdev->empty_frames_tail = pdev->read_frame;
                 }
+                pdev->read_frame = NULL;
         }
         spin_unlock_irqrestore(&pdev->ptrlock, flags);
         return ret;
@@ -599,12 +569,114 @@ static int pwc_handle_frame(struct pwc_device *pdev)
 /**
   \brief Advance pointers of image buffer (after each user request)
 */
-static inline void pwc_next_image(struct pwc_device *pdev)
+void pwc_next_image(struct pwc_device *pdev)
 {
         pdev->image_used[pdev->fill_image] = 0;
-        pdev->fill_image = (pdev->fill_image + 1) % default_mbufs;
+        pdev->fill_image = (pdev->fill_image + 1) % pwc_mbufs;
 }
 
+/**
+ * Print debug information when a frame is discarded because all of our buffer
+ * is full
+ */
+static void pwc_frame_dumped(struct pwc_device *pdev)
+{
+        pdev->vframes_dumped++;
+        if (pdev->vframe_count < FRAME_LOWMARK)
+                return;
+
+        if (pdev->vframes_dumped < 20)
+                PWC_DEBUG_FLOW("Dumping frame %d\n", pdev->vframe_count);
+        else if (pdev->vframes_dumped == 20)
+                PWC_DEBUG_FLOW("Dumping frame %d (last message)\n",
+                                pdev->vframe_count);
+}
+
+static int pwc_rcv_short_packet(struct pwc_device *pdev, const struct pwc_frame_buf *fbuf)
+{
+        int awake = 0;
+
+        /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
+           frames on the USB wire after an exposure change. This conditition is
+           however detected  in the cam and a bit is set in the header.
+           */
+        if (pdev->type == 730) {
+                unsigned char *ptr = (unsigned char *)fbuf->data;
+
+                if (ptr[1] == 1 && ptr[0] & 0x10) {
+                        PWC_TRACE("Hyundai CMOS sensor bug. Dropping frame.\n");
+                        pdev->drop_frames += 2;
+                        pdev->vframes_error++;
+                }
+                if ((ptr[0] ^ pdev->vmirror) & 0x01) {
+                        if (ptr[0] & 0x01) {
+                                pdev->snapshot_button_status = 1;
+                                PWC_TRACE("Snapshot button pressed.\n");
+                        }
+                        else {
+                                PWC_TRACE("Snapshot button released.\n");
+                        }
+                }
+                if ((ptr[0] ^ pdev->vmirror) & 0x02) {
+                        if (ptr[0] & 0x02)
+                                PWC_TRACE("Image is mirrored.\n");
+                        else
+                                PWC_TRACE("Image is normal.\n");
+                }
+                pdev->vmirror = ptr[0] & 0x03;
+                /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
+                   after a short frame; this condition is filtered out specifically. A 4 byte
+                   frame doesn't make sense anyway.
+                   So we get either this sequence:
+                   drop_bit set -> 4 byte frame -> short frame -> good frame
+                   Or this one:
+                   drop_bit set -> short frame -> good frame
+                   So we drop either 3 or 2 frames in all!
+                   */
+                if (fbuf->filled == 4)
+                        pdev->drop_frames++;
+        }
+        else if (pdev->type == 740 || pdev->type == 720) {
+                unsigned char *ptr = (unsigned char *)fbuf->data;
+                if ((ptr[0] ^ pdev->vmirror) & 0x01) {
+                        if (ptr[0] & 0x01) {
+                                pdev->snapshot_button_status = 1;
+                                PWC_TRACE("Snapshot button pressed.\n");
+                        }
+                        else
+                                PWC_TRACE("Snapshot button released.\n");
+                }
+                pdev->vmirror = ptr[0] & 0x03;
+        }
+
+        /* In case we were instructed to drop the frame, do so silently.
+           The buffer pointers are not updated either (but the counters are reset below).
+           */
+        if (pdev->drop_frames > 0)
+                pdev->drop_frames--;
+        else {
+                /* Check for underflow first */
+                if (fbuf->filled < pdev->frame_total_size) {
+                        PWC_DEBUG_FLOW("Frame buffer underflow (%d bytes);"
+                                       " discarded.\n", fbuf->filled);
+                        pdev->vframes_error++;
+                }
+                else {
+                        /* Send only once per EOF */
+                        awake = 1; /* delay wake_ups */
+
+                        /* Find our next frame to fill. This will always succeed, since we
+                         * nick a frame from either empty or full list, but if we had to
+                         * take it from the full list, it means a frame got dropped.
+                         */
+                        if (pwc_next_fill_frame(pdev))
+                                pwc_frame_dumped(pdev);
+
+                }
+        } /* !drop_frames */
+        pdev->vframe_count++;
+        return awake;
+}
 
 /* This gets called for the Isochronous pipe (video). This is done in
  * interrupt time, so it has to be fast, not crash, and not stall. Neat.
@@ -620,17 +692,12 @@ static void pwc_isoc_handler(struct urb *urb, struct pt_regs *regs)
         awake = 0;
         pdev = (struct pwc_device *)urb->context;
         if (pdev == NULL) {
-                Err("isoc_handler() called with NULL device?!\n");
-                return;
-        }
-#ifdef PWC_MAGIC
-        if (pdev->magic != PWC_MAGIC) {
-                Err("isoc_handler() called with bad magic!\n");
+                PWC_ERROR("isoc_handler() called with NULL device?!\n");
                 return;
         }
-#endif
+
         if (urb->status == -ENOENT || urb->status == -ECONNRESET) {
-                Trace(TRACE_OPEN, "pwc_isoc_handler(): URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
+                PWC_DEBUG_OPEN("URB (%p) unlinked %ssynchronuously.\n", urb, urb->status == -ENOENT ? "" : "a");
                 return;
         }
         if (urb->status != -EINPROGRESS && urb->status != 0) {
@@ -645,13 +712,13 @@ static void pwc_isoc_handler(struct urb *urb, struct pt_regs *regs)
                         case -EILSEQ:           errmsg = "CRC/Timeout (could be anything)"; break;
                         case -ETIMEDOUT:        errmsg = "NAK (device does not respond)"; break;
                 }
-                Trace(TRACE_FLOW, "pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
+                PWC_DEBUG_FLOW("pwc_isoc_handler() called with status %d [%s].\n", urb->status, errmsg);
                 /* Give up after a number of contiguous errors on the USB bus.
                    Appearantly something is wrong so we simulate an unplug event.
                  */
                 if (++pdev->visoc_errors > MAX_ISOC_ERRORS)
                 {
-                        Info("Too many ISOC errors, bailing out.\n");
+                        PWC_INFO("Too many ISOC errors, bailing out.\n");
                         pdev->error_status = EIO;
                         awake = 1;
                         wake_up_interruptible(&pdev->frameq);
@@ -661,7 +728,7 @@ static void pwc_isoc_handler(struct urb *urb, struct pt_regs *regs)
 
         fbuf = pdev->fill_frame;
         if (fbuf == NULL) {
-                Err("pwc_isoc_handler without valid fill frame.\n");
+                PWC_ERROR("pwc_isoc_handler without valid fill frame.\n");
                 awake = 1;
                 goto handler_end;
         }
@@ -688,7 +755,7 @@ static void pwc_isoc_handler(struct urb *urb, struct pt_regs *regs)
 
                                         /* ...copy data to frame buffer, if possible */
                                         if (flen + fbuf->filled > pdev->frame_total_size) {
-                                                Trace(TRACE_FLOW, "Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);
+                                                PWC_DEBUG_FLOW("Frame buffer overflow (flen = %d, frame_total_size = %d).\n", flen, pdev->frame_total_size);
                                                 pdev->vsync = 0; /* Hmm, let's wait for an EOF (end-of-frame) */
                                                 pdev->vframes_error++;
                                         }
@@ -704,96 +771,28 @@ static void pwc_isoc_handler(struct urb *urb, struct pt_regs *regs)
                                 /* Shorter packet... We probably have the end of an image-frame;
                                    wake up read() process and let select()/poll() do something.
                                    Decompression is done in user time over there.
-                                 */
+                                   */
                                 if (pdev->vsync == 2) {
-                                        /* The ToUCam Fun CMOS sensor causes the firmware to send 2 or 3 bogus
-                                           frames on the USB wire after an exposure change. This conditition is
-                                           however detected  in the cam and a bit is set in the header.
-                                         */
-                                        if (pdev->type == 730) {
-                                                unsigned char *ptr = (unsigned char *)fbuf->data;
-
-                                                if (ptr[1] == 1 && ptr[0] & 0x10) {
-#if PWC_DEBUG
-                                                        Debug("Hyundai CMOS sensor bug. Dropping frame %d.\n", fbuf->sequence);
-#endif
-                                                        pdev->drop_frames += 2;
-                                                        pdev->vframes_error++;
-                                                }
-                                                if ((ptr[0] ^ pdev->vmirror) & 0x01) {
-                                                        if (ptr[0] & 0x01)
-                                                                Info("Snapshot button pressed.\n");
-                                                        else
-                                                                Info("Snapshot button released.\n");
-                                                }
-                                                if ((ptr[0] ^ pdev->vmirror) & 0x02) {
-                                                        if (ptr[0] & 0x02)
-                                                                Info("Image is mirrored.\n");
-                                                        else
-                                                                Info("Image is normal.\n");
-                                                }
-                                                pdev->vmirror = ptr[0] & 0x03;
-                                                /* Sometimes the trailer of the 730 is still sent as a 4 byte packet
-                                                   after a short frame; this condition is filtered out specifically. A 4 byte
-                                                   frame doesn't make sense anyway.
-                                                   So we get either this sequence:
-                                                        drop_bit set -> 4 byte frame -> short frame -> good frame
-                                                   Or this one:
-                                                        drop_bit set -> short frame -> good frame
-                                                   So we drop either 3 or 2 frames in all!
-                                                 */
-                                                if (fbuf->filled == 4)
-                                                        pdev->drop_frames++;
+                                        if (pwc_rcv_short_packet(pdev, fbuf)) {
+                                                awake = 1;
+                                                fbuf = pdev->fill_frame;
                                         }
-
-                                        /* In case we were instructed to drop the frame, do so silently.
-                                           The buffer pointers are not updated either (but the counters are reset below).
-                                         */
-                                        if (pdev->drop_frames > 0)
-                                                pdev->drop_frames--;
-                                        else {
-                                                /* Check for underflow first */
-                                                if (fbuf->filled < pdev->frame_total_size) {
-                                                        Trace(TRACE_FLOW, "Frame buffer underflow (%d bytes); discarded.\n", fbuf->filled);
-                                                        pdev->vframes_error++;
-                                                }
-                                                else {
-                                                        /* Send only once per EOF */
-                                                        awake = 1; /* delay wake_ups */
-
-                                                        /* Find our next frame to fill. This will always succeed, since we
-                                                         * nick a frame from either empty or full list, but if we had to
-                                                         * take it from the full list, it means a frame got dropped.
-                                                         */
-                                                        if (pwc_next_fill_frame(pdev)) {
-                                                                pdev->vframes_dumped++;
-                                                                if ((pdev->vframe_count > FRAME_LOWMARK) && (pwc_trace & TRACE_FLOW)) {
-                                                                        if (pdev->vframes_dumped < 20)
-                                                                                Trace(TRACE_FLOW, "Dumping frame %d.\n", pdev->vframe_count);
-                                                                        if (pdev->vframes_dumped == 20)
-                                                                                Trace(TRACE_FLOW, "Dumping frame %d (last message).\n", pdev->vframe_count);
-                                                                }
-                                                        }
-                                                        fbuf = pdev->fill_frame;
-                                                }
-                                        } /* !drop_frames */
-                                        pdev->vframe_count++;
                                 }
                                 fbuf->filled = 0;
                                 fillptr = fbuf->data;
                                 pdev->vsync = 1;
-                        } /* .. flen < last_packet_size */
+                        }
+
                         pdev->vlast_packet_size = flen;
                 } /* ..status == 0 */
-#if PWC_DEBUG
-                /* This is normally not interesting to the user, unless you are really debugging something */
                 else {
+                        /* This is normally not interesting to the user, unless
+                         * you are really debugging something */
                         static int iso_error = 0;
                         iso_error++;
                         if (iso_error < 20)
-                                Trace(TRACE_FLOW, "Iso frame %d of USB has error %d\n", i, fst);
+                                PWC_DEBUG_FLOW("Iso frame %d of USB has error %d\n", i, fst);
                 }
-#endif
         }
 
 handler_end:
@@ -803,11 +802,11 @@ handler_end:
         urb->dev = pdev->udev;
         i = usb_submit_urb(urb, GFP_ATOMIC);
         if (i != 0)
-                Err("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
+                PWC_ERROR("Error (%d) re-submitting urb in pwc_isoc_handler.\n", i);
 }
 
 
-static int pwc_isoc_init(struct pwc_device *pdev)
+int pwc_isoc_init(struct pwc_device *pdev)
 {
         struct usb_device *udev;
         struct urb *urb;
@@ -826,7 +825,6 @@ static int pwc_isoc_init(struct pwc_device *pdev)
         /* Get the current alternate interface, adjust packet size */
         if (!udev->actconfig)
                 return -EFAULT;
-
         intf = usb_ifnum_to_if(udev, 0);
         if (intf)
                 idesc = usb_altnum_to_altsetting(intf, pdev->valternate);
@@ -836,20 +834,21 @@ static int pwc_isoc_init(struct pwc_device *pdev)
 
         /* Search video endpoint */
         pdev->vmax_packet_size = -1;
-        for (i = 0; i < idesc->desc.bNumEndpoints; i++)
+        for (i = 0; i < idesc->desc.bNumEndpoints; i++) {
                 if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {
                         pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);
                         break;
                 }
+        }
 
         if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {
-                Err("Failed to find packet size for video endpoint in current alternate setting.\n");
+                PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting.\n");
                 return -ENFILE; /* Odd error, that should be noticeable */
         }
 
         /* Set alternate interface */
         ret = 0;
-        Trace(TRACE_OPEN, "Setting alternate interface %d\n", pdev->valternate);
+        PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
         ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
         if (ret < 0)
                 return ret;
@@ -857,12 +856,12 @@ static int pwc_isoc_init(struct pwc_device *pdev)
         for (i = 0; i < MAX_ISO_BUFS; i++) {
                 urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);
                 if (urb == NULL) {
-                        Err("Failed to allocate urb %d\n", i);
+                        PWC_ERROR("Failed to allocate urb %d\n", i);
                         ret = -ENOMEM;
                         break;
                 }
                 pdev->sbuf[i].urb = urb;
-                Trace(TRACE_MEMORY, "Allocated URB at 0x%p\n", urb);
+                PWC_DEBUG_MEMORY("Allocated URB at 0x%p\n", urb);
         }
         if (ret) {
                 /* De-allocate in reverse order */
@@ -899,24 +898,26 @@ static int pwc_isoc_init(struct pwc_device *pdev)
         for (i = 0; i < MAX_ISO_BUFS; i++) {
                 ret = usb_submit_urb(pdev->sbuf[i].urb, GFP_KERNEL);
                 if (ret)
-                        Err("isoc_init() submit_urb %d failed with error %d\n", i, ret);
+                        PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
                 else
-                        Trace(TRACE_MEMORY, "URB 0x%p submitted.\n", pdev->sbuf[i].urb);
+                        PWC_DEBUG_MEMORY("URB 0x%p submitted.\n", pdev->sbuf[i].urb);
         }
 
         /* All is done... */
         pdev->iso_init = 1;
-        Trace(TRACE_OPEN, "<< pwc_isoc_init()\n");
+        PWC_DEBUG_OPEN("<< pwc_isoc_init()\n");
         return 0;
 }
 
-static void pwc_isoc_cleanup(struct pwc_device *pdev)
+void pwc_isoc_cleanup(struct pwc_device *pdev)
 {
         int i;
 
-        Trace(TRACE_OPEN, ">> pwc_isoc_cleanup()\n");
+        PWC_DEBUG_OPEN(">> pwc_isoc_cleanup()\n");
         if (pdev == NULL)
                 return;
+        if (pdev->iso_init == 0)
+                return;
 
         /* Unlinking ISOC buffers one by one */
         for (i = 0; i < MAX_ISO_BUFS; i++) {
@@ -925,10 +926,10 @@ static void pwc_isoc_cleanup(struct pwc_device *pdev)
                 urb = pdev->sbuf[i].urb;
                 if (urb != 0) {
                         if (pdev->iso_init) {
-                                Trace(TRACE_MEMORY, "Unlinking URB %p\n", urb);
+                                PWC_DEBUG_MEMORY("Unlinking URB %p\n", urb);
                                 usb_kill_urb(urb);
                         }
-                        Trace(TRACE_MEMORY, "Freeing URB\n");
+                        PWC_DEBUG_MEMORY("Freeing URB\n");
                         usb_free_urb(urb);
                         pdev->sbuf[i].urb = NULL;
                 }
@@ -938,12 +939,12 @@ static void pwc_isoc_cleanup(struct pwc_device *pdev)
            is signalled by EPIPE)
          */
         if (pdev->error_status && pdev->error_status != EPIPE) {
-                Trace(TRACE_OPEN, "Setting alternate interface 0.\n");
+                PWC_DEBUG_OPEN("Setting alternate interface 0.\n");
                 usb_set_interface(pdev->udev, 0, 0);
         }
 
         pdev->iso_init = 0;
-        Trace(TRACE_OPEN, "<< pwc_isoc_cleanup()\n");
+        PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
 }
 
 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot)
@@ -957,18 +958,18 @@ int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_f
         /* Try to set video mode... */
         start = ret = pwc_set_video_mode(pdev, width, height, new_fps, new_compression, new_snapshot);
         if (ret) {
-                Trace(TRACE_FLOW, "pwc_set_video_mode attempt 1 failed.\n");
+                PWC_DEBUG_FLOW("pwc_set_video_mode attempt 1 failed.\n");
                 /* That failed... restore old mode (we know that worked) */
                 start = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
                 if (start) {
-                        Trace(TRACE_FLOW, "pwc_set_video_mode attempt 2 failed.\n");
+                        PWC_DEBUG_FLOW("pwc_set_video_mode attempt 2 failed.\n");
                 }
         }
         if (start == 0)
         {
                 if (pwc_isoc_init(pdev) < 0)
                 {
-                        Info("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
+                        PWC_WARNING("Failed to restart ISOC transfers in pwc_try_video_mode.\n");
                         ret = -EAGAIN; /* let's try again, who knows if it works a second time */
                 }
         }
@@ -976,54 +977,129 @@ int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_f
         return ret; /* Return original error code */
 }
 
+/*********
+ * sysfs
+ *********/
+static struct pwc_device *cd_to_pwc(struct class_device *cd)
+{
+        struct video_device *vdev = to_video_device(cd);
+        return video_get_drvdata(vdev);
+}
+
+static ssize_t show_pan_tilt(struct class_device *class_dev, char *buf)
+{
+        struct pwc_device *pdev = cd_to_pwc(class_dev);
+        return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
+}
+
+static ssize_t store_pan_tilt(struct class_device *class_dev, const char *buf,
+                         size_t count)
+{
+        struct pwc_device *pdev = cd_to_pwc(class_dev);
+        int pan, tilt;
+        int ret = -EINVAL;
+
+        if (strncmp(buf, "reset", 5) == 0)
+                ret = pwc_mpt_reset(pdev, 0x3);
+
+        else if (sscanf(buf, "%d %d", &pan, &tilt) > 0)
+                ret = pwc_mpt_set_angle(pdev, pan, tilt);
+
+        if (ret < 0)
+                return ret;
+        return strlen(buf);
+}
+static CLASS_DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
+                         store_pan_tilt);
+
+static ssize_t show_snapshot_button_status(struct class_device *class_dev, char *buf)
+{
+        struct pwc_device *pdev = cd_to_pwc(class_dev);
+        int status = pdev->snapshot_button_status;
+        pdev->snapshot_button_status = 0;
+        return sprintf(buf, "%d\n", status);
+}
+
+static CLASS_DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
+                         NULL);
+
+static void pwc_create_sysfs_files(struct video_device *vdev)
+{
+        struct pwc_device *pdev = video_get_drvdata(vdev);
+        if (pdev->features & FEATURE_MOTOR_PANTILT)
+                video_device_create_file(vdev, &class_device_attr_pan_tilt);
+        video_device_create_file(vdev, &class_device_attr_button);
+}
+
+static void pwc_remove_sysfs_files(struct video_device *vdev)
+{
+        struct pwc_device *pdev = video_get_drvdata(vdev);
+        if (pdev->features & FEATURE_MOTOR_PANTILT)
+                video_device_remove_file(vdev, &class_device_attr_pan_tilt);
+        video_device_remove_file(vdev, &class_device_attr_button);
+}
+
+#if CONFIG_PWC_DEBUG
+static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
+{
+        switch(sensor_type) {
+                case 0x00:
+                        return "Hyundai CMOS sensor";
+                case 0x20:
+                        return "Sony CCD sensor + TDA8787";
+                case 0x2E:
+                        return "Sony CCD sensor + Exas 98L59";
+                case 0x2F:
+                        return "Sony CCD sensor + ADI 9804";
+                case 0x30:
+                        return "Sharp CCD sensor + TDA8787";
+                case 0x3E:
+                        return "Sharp CCD sensor + Exas 98L59";
+                case 0x3F:
+                        return "Sharp CCD sensor + ADI 9804";
+                case 0x40:
+                        return "UPA 1021 sensor";
+                case 0x100:
+                        return "VGA sensor";
+                case 0x101:
+                        return "PAL MR sensor";
+                default:
+                        return "unknown type of sensor";
+        }
+}
+#endif
 
 /***************************************************************************/
 /* Video4Linux functions */
 
 static int pwc_video_open(struct inode *inode, struct file *file)
 {
-        int i;
+        int i, ret;
         struct video_device *vdev = video_devdata(file);
         struct pwc_device *pdev;
 
-        Trace(TRACE_OPEN, ">> video_open called(vdev = 0x%p).\n", vdev);
+        PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
 
         pdev = (struct pwc_device *)vdev->priv;
         if (pdev == NULL)
                 BUG();
-        if (pdev->vopen)
+        if (pdev->vopen) {
+                PWC_DEBUG_OPEN("I'm busy, someone is using the device.\n");
                 return -EBUSY;
+        }
 
         down(&pdev->modlock);
         if (!pdev->usb_init) {
-                Trace(TRACE_OPEN, "Doing first time initialization.\n");
+                PWC_DEBUG_OPEN("Doing first time initialization.\n");
                 pdev->usb_init = 1;
 
-                if (pwc_trace & TRACE_OPEN)
+                /* Query sensor type */
+                ret = pwc_get_cmos_sensor(pdev, &i);
+                if (ret >= 0)
                 {
-                        /* Query sensor type */
-                        const char *sensor_type = NULL;
-                        int ret;
-
-                        ret = pwc_get_cmos_sensor(pdev, &i);
-                        if (ret >= 0)
-                        {
-                                switch(i) {
-                                case 0x00:  sensor_type = "Hyundai CMOS sensor"; break;
-                                case 0x20:  sensor_type = "Sony CCD sensor + TDA8787"; break;
-                                case 0x2E:  sensor_type = "Sony CCD sensor + Exas 98L59"; break;
-                                case 0x2F:  sensor_type = "Sony CCD sensor + ADI 9804"; break;
-                                case 0x30:  sensor_type = "Sharp CCD sensor + TDA8787"; break;
-                                case 0x3E:  sensor_type = "Sharp CCD sensor + Exas 98L59"; break;
-                                case 0x3F:  sensor_type = "Sharp CCD sensor + ADI 9804"; break;
-                                case 0x40:  sensor_type = "UPA 1021 sensor"; break;
-                                case 0x100: sensor_type = "VGA sensor"; break;
-                                case 0x101: sensor_type = "PAL MR sensor"; break;
-                                default:    sensor_type = "unknown type of sensor"; break;
-                                }
-                        }
-                        if (sensor_type != NULL)
-                                Info("This %s camera is equipped with a %s (%d).\n", pdev->vdev->name, sensor_type, i);
+                        PWC_DEBUG_OPEN("This %s camera is equipped with a %s (%d).\n",
+                                        pdev->vdev->name,
+                                        pwc_sensor_type_to_string(i), i);
                 }
         }
 
@@ -1031,34 +1107,32 @@ static int pwc_video_open(struct inode *inode, struct file *file)
         if (power_save) {
                 i = pwc_camera_power(pdev, 1);
                 if (i < 0)
-                        Info("Failed to restore power to the camera! (%d)\n", i);
+                        PWC_DEBUG_OPEN("Failed to restore power to the camera! (%d)\n", i);
         }
         /* Set LED on/off time */
         if (pwc_set_leds(pdev, led_on, led_off) < 0)
-                Info("Failed to set LED on/off time.\n");
+                PWC_DEBUG_OPEN("Failed to set LED on/off time.\n");
 
         pwc_construct(pdev); /* set min/max sizes correct */
 
         /* So far, so good. Allocate memory. */
         i = pwc_allocate_buffers(pdev);
         if (i < 0) {
-                Trace(TRACE_OPEN, "Failed to allocate buffer memory.\n");
+                PWC_DEBUG_OPEN("Failed to allocate buffers memory.\n");
+                pwc_free_buffers(pdev);
                 up(&pdev->modlock);
                 return i;
         }
 
         /* Reset buffers & parameters */
         pwc_reset_buffers(pdev);
-        for (i = 0; i < default_mbufs; i++)
+        for (i = 0; i < pwc_mbufs; i++)
                 pdev->image_used[i] = 0;
         pdev->vframe_count = 0;
         pdev->vframes_dumped = 0;
         pdev->vframes_error = 0;
         pdev->visoc_errors = 0;
         pdev->error_status = 0;
-#if PWC_DEBUG
-        pdev->sequence = 0;
-#endif
         pwc_construct(pdev); /* set min/max sizes correct */
 
         /* Set some defaults */
@@ -1070,29 +1144,44 @@ static int pwc_video_open(struct inode *inode, struct file *file)
          */
         i = pwc_set_video_mode(pdev, pwc_image_sizes[pdev->vsize].x, pwc_image_sizes[pdev->vsize].y, pdev->vframes, pdev->vcompression, 0);
         if (i)  {
-                Trace(TRACE_OPEN, "First attempt at set_video_mode failed.\n");
-                if (pdev->type == 730 || pdev->type == 740 || pdev->type == 750)
-                        i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QSIF].x, pwc_image_sizes[PSZ_QSIF].y, 10, pdev->vcompression, 0);
+                unsigned int default_resolution;
+                PWC_DEBUG_OPEN("First attempt at set_video_mode failed.\n");
+                if (pdev->type>= 730)
+                        default_resolution = PSZ_QSIF;
                 else
-                        i = pwc_set_video_mode(pdev, pwc_image_sizes[PSZ_QCIF].x, pwc_image_sizes[PSZ_QCIF].y, 10, pdev->vcompression, 0);
+                        default_resolution = PSZ_QCIF;
+
+                i = pwc_set_video_mode(pdev,
+                                       pwc_image_sizes[default_resolution].x,
+                                       pwc_image_sizes[default_resolution].y,
+                                       10,
+                                       pdev->vcompression,
+                                       0);
         }
         if (i) {
-                Trace(TRACE_OPEN, "Second attempt at set_video_mode failed.\n");
+                PWC_DEBUG_OPEN("Second attempt at set_video_mode failed.\n");
+                pwc_free_buffers(pdev);
                 up(&pdev->modlock);
                 return i;
         }
 
         i = pwc_isoc_init(pdev);
         if (i) {
-                Trace(TRACE_OPEN, "Failed to init ISOC stuff = %d.\n", i);
+                PWC_DEBUG_OPEN("Failed to init ISOC stuff = %d.\n", i);
+                pwc_isoc_cleanup(pdev);
+                pwc_free_buffers(pdev);
                 up(&pdev->modlock);
                 return i;
         }
 
+        /* Initialize the webcam to sane value */
+        pwc_set_brightness(pdev, 0x7fff);
+        pwc_set_agc(pdev, 1, 0);
+
         pdev->vopen++;
         file->private_data = vdev;
         up(&pdev->modlock);
-        Trace(TRACE_OPEN, "<< video_open() returns 0.\n");
+        PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
         return 0;
 }
 
@@ -1103,35 +1192,23 @@ static int pwc_video_close(struct inode *inode, struct file *file)
         struct pwc_device *pdev;
         int i;
 
-        Trace(TRACE_OPEN, ">> video_close called(vdev = 0x%p).\n", vdev);
+        PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
 
         pdev = (struct pwc_device *)vdev->priv;
         if (pdev->vopen == 0)
-                Info("video_close() called on closed device?\n");
+                PWC_DEBUG_MODULE("video_close() called on closed device?\n");
 
         /* Dump statistics, but only if a reasonable amount of frames were
            processed (to prevent endless log-entries in case of snap-shot
            programs)
          */
         if (pdev->vframe_count > 20)
-                Info("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error);
+                PWC_DEBUG_MODULE("Closing video device: %d frames received, dumped %d frames, %d frames with errors.\n", pdev->vframe_count, pdev->vframes_dumped, pdev->vframes_error);
 
-        switch (pdev->type)
-         {
-          case 675:
-          case 680:
-          case 690:
-          case 720:
-          case 730:
-          case 740:
-          case 750:
-/*          pwc_dec23_exit();   *//* Timon & Kiara */
-            break;
-          case 645:
-          case 646:
-/*          pwc_dec1_exit(); */
-            break;
-         }
+        if (DEVICE_USE_CODEC1(pdev->type))
+            pwc_dec1_exit();
+        else
+            pwc_dec23_exit();
 
         pwc_isoc_cleanup(pdev);
         pwc_free_buffers(pdev);
@@ -1140,15 +1217,15 @@ static int pwc_video_close(struct inode *inode, struct file *file)
         if (pdev->error_status != EPIPE) {
                 /* Turn LEDs off */
                 if (pwc_set_leds(pdev, 0, 0) < 0)
-                        Info("Failed to set LED on/off time.\n");
+                        PWC_DEBUG_MODULE("Failed to set LED on/off time.\n");
                 if (power_save) {
                         i = pwc_camera_power(pdev, 0);
                         if (i < 0)
-                                Err("Failed to power down camera (%d)\n", i);
+                                PWC_ERROR("Failed to power down camera (%d)\n", i);
                 }
         }
-        pdev->vopen = 0;
-        Trace(TRACE_OPEN, "<< video_close()\n");
+        pdev->vopen--;
+        PWC_DEBUG_OPEN("<< video_close() vopen=%d\n", pdev->vopen);
         return 0;
 }
 
@@ -1164,7 +1241,7 @@ static int pwc_video_close(struct inode *inode, struct file *file)
                 device is tricky anyhow.
  */
 
-static ssize_t pwc_video_read(struct file *file, char __user * buf,
+static ssize_t pwc_video_read(struct file *file, char __user *buf,
                           size_t count, loff_t *ppos)
 {
         struct video_device *vdev = file->private_data;
@@ -1172,8 +1249,10 @@ static ssize_t pwc_video_read(struct file *file, char __user * buf,
         int noblock = file->f_flags & O_NONBLOCK;
         DECLARE_WAITQUEUE(wait, current);
         int bytes_to_read;
+        void *image_buffer_addr;
 
-        Trace(TRACE_READ, "video_read(0x%p, %p, %zu) called.\n", vdev, buf, count);
+        PWC_DEBUG_READ("pwc_video_read(vdev=0x%p, buf=%p, count=%zd) called.\n",
+                        vdev, buf, count);
         if (vdev == NULL)
                 return -EFAULT;
         pdev = vdev->priv;
@@ -1214,16 +1293,19 @@ static ssize_t pwc_video_read(struct file *file, char __user * buf,
                         return -EFAULT;
         }
 
-        Trace(TRACE_READ, "Copying data to user space.\n");
+        PWC_DEBUG_READ("Copying data to user space.\n");
         if (pdev->vpalette == VIDEO_PALETTE_RAW)
-                bytes_to_read = pdev->frame_size;
+                bytes_to_read = pdev->frame_size + sizeof(struct pwc_raw_frame);
         else
                 bytes_to_read = pdev->view.size;
 
         /* copy bytes to user space; we allow for partial reads */
         if (count + pdev->image_read_pos > bytes_to_read)
                 count = bytes_to_read - pdev->image_read_pos;
-        if (copy_to_user(buf, pdev->image_ptr[pdev->fill_image] + pdev->image_read_pos, count))
+        image_buffer_addr = pdev->image_data;
+        image_buffer_addr += pdev->images[pdev->fill_image].offset;
+        image_buffer_addr += pdev->image_read_pos;
+        if (copy_to_user(buf, image_buffer_addr, count))
                 return -EFAULT;
         pdev->image_read_pos += count;
         if (pdev->image_read_pos >= bytes_to_read) { /* All data has been read */
@@ -1253,370 +1335,56 @@ static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
         return 0;
 }
 
-static int pwc_video_do_ioctl(struct inode *inode, struct file *file,
-                              unsigned int cmd, void *arg)
-{
-        struct video_device *vdev = file->private_data;
-        struct pwc_device *pdev;
-        DECLARE_WAITQUEUE(wait, current);
-
-        if (vdev == NULL)
-                return -EFAULT;
-        pdev = vdev->priv;
-        if (pdev == NULL)
-                return -EFAULT;
-
-        switch (cmd) {
-                /* Query cabapilities */
-                case VIDIOCGCAP:
-                {
-                        struct video_capability *caps = arg;
-
-                        strcpy(caps->name, vdev->name);
-                        caps->type = VID_TYPE_CAPTURE;
-                        caps->channels = 1;
-                        caps->audios = 1;
-                        caps->minwidth  = pdev->view_min.x;
-                        caps->minheight = pdev->view_min.y;
-                        caps->maxwidth  = pdev->view_max.x;
-                        caps->maxheight = pdev->view_max.y;
-                        break;
-                }
-
-                /* Channel functions (simulate 1 channel) */
-                case VIDIOCGCHAN:
-                {
-                        struct video_channel *v = arg;
-
-                        if (v->channel != 0)
-                                return -EINVAL;
-                        v->flags = 0;
-                        v->tuners = 0;
-                        v->type = VIDEO_TYPE_CAMERA;
-                        strcpy(v->name, "Webcam");
-                        return 0;
-                }
-
-                case VIDIOCSCHAN:
-                {
-                        /* The spec says the argument is an integer, but
-                           the bttv driver uses a video_channel arg, which
-                           makes sense becasue it also has the norm flag.
-                         */
-                        struct video_channel *v = arg;
-                        if (v->channel != 0)
-                                return -EINVAL;
-                        return 0;
-                }
-
-
-                /* Picture functions; contrast etc. */
-                case VIDIOCGPICT:
-                {
-                        struct video_picture *p = arg;
-                        int val;
-
-                        val = pwc_get_brightness(pdev);
-                        if (val >= 0)
-                                p->brightness = val;
-                        else
-                                p->brightness = 0xffff;
-                        val = pwc_get_contrast(pdev);
-                        if (val >= 0)
-                                p->contrast = val;
-                        else
-                                p->contrast = 0xffff;
-                        /* Gamma, Whiteness, what's the difference? :) */
-                        val = pwc_get_gamma(pdev);
-                        if (val >= 0)
-                                p->whiteness = val;
-                        else
-                                p->whiteness = 0xffff;
-                        val = pwc_get_saturation(pdev);
-                        if (val >= 0)
-                                p->colour = val;
-                        else
-                                p->colour = 0xffff;
-                        p->depth = 24;
-                        p->palette = pdev->vpalette;
-                        p->hue = 0xFFFF; /* N/A */
-                        break;
-                }
-
-                case VIDIOCSPICT:
-                {
-                        struct video_picture *p = arg;
-                        /*
-                         *      FIXME:  Suppose we are mid read
-                                ANSWER: No problem: the firmware of the camera
-                                        can handle brightness/contrast/etc
-                                        changes at _any_ time, and the palette
-                                        is used exactly once in the uncompress
-                                        routine.
-                         */
-                        pwc_set_brightness(pdev, p->brightness);
-                        pwc_set_contrast(pdev, p->contrast);
-                        pwc_set_gamma(pdev, p->whiteness);
-                        pwc_set_saturation(pdev, p->colour);
-                        if (p->palette && p->palette != pdev->vpalette) {
-                                switch (p->palette) {
-                                        case VIDEO_PALETTE_YUV420P:
-                                        case VIDEO_PALETTE_RAW:
-                                                pdev->vpalette = p->palette;
-                                                return pwc_try_video_mode(pdev, pdev->image.x, pdev->image.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
-                                                break;
-                                        default:
-                                                return -EINVAL;
-                                                break;
-                                }
-                        }
-                        break;
-                }
-
-                /* Window/size parameters */
-                case VIDIOCGWIN:
-                {
-                        struct video_window *vw = arg;
-
-                        vw->x = 0;
-                        vw->y = 0;
-                        vw->width = pdev->view.x;
-                        vw->height = pdev->view.y;
-                        vw->chromakey = 0;
-                        vw->flags = (pdev->vframes << PWC_FPS_SHIFT) |
-                                   (pdev->vsnapshot ? PWC_FPS_SNAPSHOT : 0);
-                        break;
-                }
-
-                case VIDIOCSWIN:
-                {
-                        struct video_window *vw = arg;
-                        int fps, snapshot, ret;
-
-                        fps = (vw->flags & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
-                        snapshot = vw->flags & PWC_FPS_SNAPSHOT;
-                        if (fps == 0)
-                                fps = pdev->vframes;
-                        if (pdev->view.x == vw->width && pdev->view.y && fps == pdev->vframes && snapshot == pdev->vsnapshot)
-                                return 0;
-                        ret = pwc_try_video_mode(pdev, vw->width, vw->height, fps, pdev->vcompression, snapshot);
-                        if (ret)
-                                return ret;
-                        break;
-                }
-
-                /* We don't have overlay support (yet) */
-                case VIDIOCGFBUF:
-                {
-                        struct video_buffer *vb = arg;
-
-                        memset(vb,0,sizeof(*vb));
-                        break;
-                }
-
-                /* mmap() functions */
-                case VIDIOCGMBUF:
-                {
-                        /* Tell the user program how much memory is needed for a mmap() */
-                        struct video_mbuf *vm = arg;
-                        int i;
-
-                        memset(vm, 0, sizeof(*vm));
-                        vm->size = default_mbufs * pdev->len_per_image;
-                        vm->frames = default_mbufs; /* double buffering should be enough for most applications */
-                        for (i = 0; i < default_mbufs; i++)
-                                vm->offsets[i] = i * pdev->len_per_image;
-                        break;
-                }
-
-                case VIDIOCMCAPTURE:
-                {
-                        /* Start capture into a given image buffer (called 'frame' in video_mmap structure) */
-                        struct video_mmap *vm = arg;
-
-                        Trace(TRACE_READ, "VIDIOCMCAPTURE: %dx%d, frame %d, format %d\n", vm->width, vm->height, vm->frame, vm->format);
-                        if (vm->frame < 0 || vm->frame >= default_mbufs)
-                                return -EINVAL;
-
-                        /* xawtv is nasty. It probes the available palettes
-                           by setting a very small image size and trying
-                           various palettes... The driver doesn't support
-                           such small images, so I'm working around it.
-                         */
-                        if (vm->format)
-                        {
-                                switch (vm->format)
-                                {
-                                        case VIDEO_PALETTE_YUV420P:
-                                        case VIDEO_PALETTE_RAW:
-                                                break;
-                                        default:
-                                                return -EINVAL;
-                                                break;
-                                }
-                        }
-
-                        if ((vm->width != pdev->view.x || vm->height != pdev->view.y) &&
-                            (vm->width >= pdev->view_min.x && vm->height >= pdev->view_min.y)) {
-                                int ret;
-
-                                Trace(TRACE_OPEN, "VIDIOCMCAPTURE: changing size to please xawtv :-(.\n");
-                                ret = pwc_try_video_mode(pdev, vm->width, vm->height, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
-                                if (ret)
-                                        return ret;
-                        } /* ... size mismatch */
-
-                        /* FIXME: should we lock here? */
-                        if (pdev->image_used[vm->frame])
-                                return -EBUSY;  /* buffer wasn't available. Bummer */
-                        pdev->image_used[vm->frame] = 1;
-
-                        /* Okay, we're done here. In the SYNC call we wait until a
-                           frame comes available, then expand image into the given
-                           buffer.
-                           In contrast to the CPiA cam the Philips cams deliver a
-                           constant stream, almost like a grabber card. Also,
-                           we have separate buffers for the rawdata and the image,
-                           meaning we can nearly always expand into the requested buffer.
-                         */
-                        Trace(TRACE_READ, "VIDIOCMCAPTURE done.\n");
-                        break;
-                }
-
-                case VIDIOCSYNC:
-                {
-                        /* The doc says: "Whenever a buffer is used it should
-                           call VIDIOCSYNC to free this frame up and continue."
-
-                           The only odd thing about this whole procedure is
-                           that MCAPTURE flags the buffer as "in use", and
-                           SYNC immediately unmarks it, while it isn't
-                           after SYNC that you know that the buffer actually
-                           got filled! So you better not start a CAPTURE in
-                           the same frame immediately (use double buffering).
-                           This is not a problem for this cam, since it has
-                           extra intermediate buffers, but a hardware
-                           grabber card will then overwrite the buffer
-                           you're working on.
-                         */
-                        int *mbuf = arg;
-                        int ret;
-
-                        Trace(TRACE_READ, "VIDIOCSYNC called (%d).\n", *mbuf);
-
-                        /* bounds check */
-                        if (*mbuf < 0 || *mbuf >= default_mbufs)
-                                return -EINVAL;
-                        /* check if this buffer was requested anyway */
-                        if (pdev->image_used[*mbuf] == 0)
-                                return -EINVAL;
-
-                        /* Add ourselves to the frame wait-queue.
-
-                           FIXME: needs auditing for safety.
-                           QUESTION: In what respect? I think that using the
-                                     frameq is safe now.
-                         */
-                        add_wait_queue(&pdev->frameq, &wait);
-                        while (pdev->full_frames == NULL) {
-                                if (pdev->error_status) {
-                                        remove_wait_queue(&pdev->frameq, &wait);
-                                        set_current_state(TASK_RUNNING);
-                                        return -pdev->error_status;
-                                }
-
-                                if (signal_pending(current)) {
-                                        remove_wait_queue(&pdev->frameq, &wait);
-                                        set_current_state(TASK_RUNNING);
-                                        return -ERESTARTSYS;
-                                }
-                                schedule();
-                                set_current_state(TASK_INTERRUPTIBLE);
-                        }
-                        remove_wait_queue(&pdev->frameq, &wait);
-                        set_current_state(TASK_RUNNING);
-
-                        /* The frame is ready. Expand in the image buffer
-                           requested by the user. I don't care if you
-                           mmap() 5 buffers and request data in this order:
-                           buffer 4 2 3 0 1 2 3 0 4 3 1 . . .
-                           Grabber hardware may not be so forgiving.
-                         */
-                        Trace(TRACE_READ, "VIDIOCSYNC: frame ready.\n");
-                        pdev->fill_image = *mbuf; /* tell in which buffer we want the image to be expanded */
-                        /* Decompress, etc */
-                        ret = pwc_handle_frame(pdev);
-                        pdev->image_used[*mbuf] = 0;
-                        if (ret)
-                                return -EFAULT;
-                        break;
-                }
-
-                case VIDIOCGAUDIO:
-                {
-                        struct video_audio *v = arg;
-
-                        strcpy(v->name, "Microphone");
-                        v->audio = -1; /* unknown audio minor */
-                        v->flags = 0;
-                        v->mode = VIDEO_SOUND_MONO;
-                        v->volume = 0;
-                        v->bass = 0;
-                        v->treble = 0;
-                        v->balance = 0x8000;
-                        v->step = 1;
-                        break;
-                }
-
-                case VIDIOCSAUDIO:
-                {
-                        /* Dummy: nothing can be set */
-                        break;
-                }
-
-                case VIDIOCGUNIT:
-                {
-                        struct video_unit *vu = arg;
-
-                        vu->video = pdev->vdev->minor & 0x3F;
-                        vu->audio = -1; /* not known yet */
-                        vu->vbi = -1;
-                        vu->radio = -1;
-                        vu->teletext = -1;
-                        break;
-                }
-                default:
-                        return pwc_ioctl(pdev, cmd, arg);
-        } /* ..switch */
-        return 0;
-}
-
 static int pwc_video_ioctl(struct inode *inode, struct file *file,
                            unsigned int cmd, unsigned long arg)
 {
         return video_usercopy(inode, file, cmd, arg, pwc_video_do_ioctl);
 }
 
-
 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct video_device *vdev = file->private_data;
         struct pwc_device *pdev;
-        unsigned long start = vma->vm_start;
-        unsigned long size  = vma->vm_end-vma->vm_start;
-        unsigned long page, pos;
+        unsigned long start;
+        unsigned long size;
+        unsigned long page, pos = 0;
+        int index;
 
-        Trace(TRACE_MEMORY, "mmap(0x%p, 0x%lx, %lu) called.\n", vdev, start, size);
+        PWC_DEBUG_MEMORY(">> %s\n", __FUNCTION__);
         pdev = vdev->priv;
+        size = vma->vm_end - vma->vm_start;
+        start = vma->vm_start;
 
-        vma->vm_flags |= VM_IO;
+        /* Find the idx buffer for this mapping */
+        for (index = 0; index < pwc_mbufs; index++) {
+                pos = pdev->images[index].offset;
+                if ((pos>>PAGE_SHIFT) == vma->vm_pgoff)
+                        break;
+        }
+        if (index == MAX_IMAGES)
+                return -EINVAL;
+        if (index == 0) {
+                /*
+                 * Special case for v4l1. In v4l1, we map only one big buffer,
+                 * but in v4l2 each buffer is mapped
+                 */
+                unsigned long total_size;
+                total_size = pwc_mbufs * pdev->len_per_image;
+                if (size != pdev->len_per_image && size != total_size) {
+                        PWC_ERROR("Wrong size (%lu) needed to be len_per_image=%d or total_size=%lu\n",
+                                   size, pdev->len_per_image, total_size);
+                        return -EINVAL;
+                }
+        } else if (size > pdev->len_per_image)
+                return -EINVAL;
 
-        pos = (unsigned long)pdev->image_data;
+        vma->vm_flags |= VM_IO; /* from 2.6.9-acX */
+
+        pos += (unsigned long)pdev->image_data;
         while (size > 0) {
                 page = vmalloc_to_pfn((void *)pos);
                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED))
                         return -EAGAIN;
-
                 start += PAGE_SIZE;
                 pos += PAGE_SIZE;
                 if (size > PAGE_SIZE)
@@ -1624,7 +1392,6 @@ static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
                 else
                         size = 0;
         }
-
         return 0;
 }
 
@@ -1645,10 +1412,12 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         int video_nr = -1; /* default: use next available device */
         char serial_number[30], *name;
 
+        vendor_id = le16_to_cpu(udev->descriptor.idVendor);
+        product_id = le16_to_cpu(udev->descriptor.idProduct);
+
         /* Check if we can handle this device */
-        Trace(TRACE_PROBE, "probe() called [%04X %04X], if %d\n",
-                le16_to_cpu(udev->descriptor.idVendor),
-                le16_to_cpu(udev->descriptor.idProduct),
+        PWC_DEBUG_PROBE("probe() called [%04X %04X], if %d\n",
+                vendor_id, product_id,
                 intf->altsetting->desc.bInterfaceNumber);
 
         /* the interfaces are probed one by one. We are only interested in the
@@ -1658,61 +1427,63 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         if (intf->altsetting->desc.bInterfaceNumber > 0)
                 return -ENODEV;
 
-        vendor_id = le16_to_cpu(udev->descriptor.idVendor);
-        product_id = le16_to_cpu(udev->descriptor.idProduct);
-
         if (vendor_id == 0x0471) {
                 switch (product_id) {
                 case 0x0302:
-                        Info("Philips PCA645VC USB webcam detected.\n");
+                        PWC_INFO("Philips PCA645VC USB webcam detected.\n");
                         name = "Philips 645 webcam";
                         type_id = 645;
                         break;
                 case 0x0303:
-                        Info("Philips PCA646VC USB webcam detected.\n");
+                        PWC_INFO("Philips PCA646VC USB webcam detected.\n");
                         name = "Philips 646 webcam";
                         type_id = 646;
                         break;
                 case 0x0304:
-                        Info("Askey VC010 type 2 USB webcam detected.\n");
+                        PWC_INFO("Askey VC010 type 2 USB webcam detected.\n");
                         name = "Askey VC010 webcam";
                         type_id = 646;
                         break;
                 case 0x0307:
-                        Info("Philips PCVC675K (Vesta) USB webcam detected.\n");
+                        PWC_INFO("Philips PCVC675K (Vesta) USB webcam detected.\n");
                         name = "Philips 675 webcam";
                         type_id = 675;
                         break;
                 case 0x0308:
-                        Info("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
+                        PWC_INFO("Philips PCVC680K (Vesta Pro) USB webcam detected.\n");
                         name = "Philips 680 webcam";
                         type_id = 680;
                         break;
                 case 0x030C:
-                        Info("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
+                        PWC_INFO("Philips PCVC690K (Vesta Pro Scan) USB webcam detected.\n");
                         name = "Philips 690 webcam";
                         type_id = 690;
                         break;
                 case 0x0310:
-                        Info("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
+                        PWC_INFO("Philips PCVC730K (ToUCam Fun)/PCVC830 (ToUCam II) USB webcam detected.\n");
                         name = "Philips 730 webcam";
                         type_id = 730;
                         break;
                 case 0x0311:
-                        Info("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
+                        PWC_INFO("Philips PCVC740K (ToUCam Pro)/PCVC840 (ToUCam II) USB webcam detected.\n");
                         name = "Philips 740 webcam";
                         type_id = 740;
                         break;
                 case 0x0312:
-                        Info("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
+                        PWC_INFO("Philips PCVC750K (ToUCam Pro Scan) USB webcam detected.\n");
                         name = "Philips 750 webcam";
                         type_id = 750;
                         break;
                 case 0x0313:
-                        Info("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
+                        PWC_INFO("Philips PCVC720K/40 (ToUCam XS) USB webcam detected.\n");
                         name = "Philips 720K/40 webcam";
                         type_id = 720;
                         break;
+                case 0x0329:
+                        PWC_INFO("Philips SPC 900NC USB webcam detected.\n");
+                        name = "Philips SPC 900NC webcam";
+                        type_id = 720;
+                        break;
                 default:
                         return -ENODEV;
                         break;
@@ -1721,7 +1492,7 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         else if (vendor_id == 0x069A) {
                 switch(product_id) {
                 case 0x0001:
-                        Info("Askey VC010 type 1 USB webcam detected.\n");
+                        PWC_INFO("Askey VC010 type 1 USB webcam detected.\n");
                         name = "Askey VC010 webcam";
                         type_id = 645;
                         break;
@@ -1733,32 +1504,33 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         else if (vendor_id == 0x046d) {
                 switch(product_id) {
                 case 0x08b0:
-                        Info("Logitech QuickCam Pro 3000 USB webcam detected.\n");
+                        PWC_INFO("Logitech QuickCam Pro 3000 USB webcam detected.\n");
                         name = "Logitech QuickCam Pro 3000";
                         type_id = 740; /* CCD sensor */
                         break;
                 case 0x08b1:
-                        Info("Logitech QuickCam Notebook Pro USB webcam detected.\n");
+                        PWC_INFO("Logitech QuickCam Notebook Pro USB webcam detected.\n");
                         name = "Logitech QuickCam Notebook Pro";
                         type_id = 740; /* CCD sensor */
                         break;
                 case 0x08b2:
-                        Info("Logitech QuickCam 4000 Pro USB webcam detected.\n");
+                        PWC_INFO("Logitech QuickCam 4000 Pro USB webcam detected.\n");
                         name = "Logitech QuickCam Pro 4000";
                         type_id = 740; /* CCD sensor */
                         break;
                 case 0x08b3:
-                        Info("Logitech QuickCam Zoom USB webcam detected.\n");
+                        PWC_INFO("Logitech QuickCam Zoom USB webcam detected.\n");
                         name = "Logitech QuickCam Zoom";
                         type_id = 740; /* CCD sensor */
                         break;
                 case 0x08B4:
-                        Info("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
+                        PWC_INFO("Logitech QuickCam Zoom (new model) USB webcam detected.\n");
                         name = "Logitech QuickCam Zoom";
                         type_id = 740; /* CCD sensor */
+                        power_save = 1;
                         break;
                 case 0x08b5:
-                        Info("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
+                        PWC_INFO("Logitech QuickCam Orbit/Sphere USB webcam detected.\n");
                         name = "Logitech QuickCam Orbit";
                         type_id = 740; /* CCD sensor */
                         features |= FEATURE_MOTOR_PANTILT;
@@ -1766,7 +1538,7 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
                 case 0x08b6:
                 case 0x08b7:
                 case 0x08b8:
-                        Info("Logitech QuickCam detected (reserved ID).\n");
+                        PWC_INFO("Logitech QuickCam detected (reserved ID).\n");
                         name = "Logitech QuickCam (res.)";
                         type_id = 730; /* Assuming CMOS */
                         break;
@@ -1782,15 +1554,20 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
                  */
                 switch(product_id) {
                 case 0x9000:
-                        Info("Samsung MPC-C10 USB webcam detected.\n");
+                        PWC_INFO("Samsung MPC-C10 USB webcam detected.\n");
                         name = "Samsung MPC-C10";
                         type_id = 675;
                         break;
                 case 0x9001:
-                        Info("Samsung MPC-C30 USB webcam detected.\n");
+                        PWC_INFO("Samsung MPC-C30 USB webcam detected.\n");
                         name = "Samsung MPC-C30";
                         type_id = 675;
                         break;
+                case 0x9002:
+                        PWC_INFO("Samsung SNC-35E (v3.0) USB webcam detected.\n");
+                        name = "Samsung MPC-C30";
+                        type_id = 740;
+                        break;
                 default:
                         return -ENODEV;
                         break;
@@ -1799,12 +1576,12 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         else if (vendor_id == 0x041e) {
                 switch(product_id) {
                 case 0x400c:
-                        Info("Creative Labs Webcam 5 detected.\n");
+                        PWC_INFO("Creative Labs Webcam 5 detected.\n");
                         name = "Creative Labs Webcam 5";
                         type_id = 730;
                         break;
                 case 0x4011:
-                        Info("Creative Labs Webcam Pro Ex detected.\n");
+                        PWC_INFO("Creative Labs Webcam Pro Ex detected.\n");
                         name = "Creative Labs Webcam Pro Ex";
                         type_id = 740;
                         break;
@@ -1816,7 +1593,7 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         else if (vendor_id == 0x04cc) {
                 switch(product_id) {
                 case 0x8116:
-                        Info("Sotec Afina Eye USB webcam detected.\n");
+                        PWC_INFO("Sotec Afina Eye USB webcam detected.\n");
                         name = "Sotec Afina Eye";
                         type_id = 730;
                         break;
@@ -1829,7 +1606,7 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
                 switch(product_id) {
                 case 0x8116:
                         /* This is essentially the same cam as the Sotec Afina Eye */
-                        Info("AME Co. Afina Eye USB webcam detected.\n");
+                        PWC_INFO("AME Co. Afina Eye USB webcam detected.\n");
                         name = "AME Co. Afina Eye";
                         type_id = 750;
                         break;
@@ -1842,12 +1619,12 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         else if (vendor_id == 0x0d81) {
                 switch(product_id) {
                 case 0x1900:
-                        Info("Visionite VCS-UC300 USB webcam detected.\n");
+                        PWC_INFO("Visionite VCS-UC300 USB webcam detected.\n");
                         name = "Visionite VCS-UC300";
                         type_id = 740; /* CCD sensor */
                         break;
                 case 0x1910:
-                        Info("Visionite VCS-UM100 USB webcam detected.\n");
+                        PWC_INFO("Visionite VCS-UM100 USB webcam detected.\n");
                         name = "Visionite VCS-UM100";
                         type_id = 730; /* CMOS sensor */
                         break;
@@ -1861,15 +1638,15 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
 
         memset(serial_number, 0, 30);
         usb_string(udev, udev->descriptor.iSerialNumber, serial_number, 29);
-        Trace(TRACE_PROBE, "Device serial number is %s\n", serial_number);
+        PWC_DEBUG_PROBE("Device serial number is %s\n", serial_number);
 
         if (udev->descriptor.bNumConfigurations > 1)
-                Info("Warning: more than 1 configuration available.\n");
+                PWC_WARNING("Warning: more than 1 configuration available.\n");
 
         /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
         pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
         if (pdev == NULL) {
-                Err("Oops, could not allocate memory for pwc_device.\n");
+                PWC_ERROR("Oops, could not allocate memory for pwc_device.\n");
                 return -ENOMEM;
         }
         pdev->type = type_id;
@@ -1900,17 +1677,18 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         pdev->vdev = video_device_alloc();
         if (pdev->vdev == 0)
         {
-                Err("Err, cannot allocate video_device struture. Failing probe.");
+                PWC_ERROR("Err, cannot allocate video_device struture. Failing probe.");
                 kfree(pdev);
                 return -ENOMEM;
         }
         memcpy(pdev->vdev, &pwc_template, sizeof(pwc_template));
+        pdev->vdev->dev = &(udev->dev);
         strcpy(pdev->vdev->name, name);
         pdev->vdev->owner = THIS_MODULE;
         video_set_drvdata(pdev->vdev, pdev);
 
         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
-        Trace(TRACE_PROBE, "Release: %04x\n", pdev->release);
+        PWC_DEBUG_PROBE("Release: %04x\n", pdev->release);
 
         /* Now search device_hint[] table for a match, so we can hint a node number. */
         for (hint = 0; hint < MAX_DEV_HINTS; hint++) {
@@ -1918,10 +1696,10 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
                      (device_hint[hint].pdev == NULL)) {
                         /* so far, so good... try serial number */
                         if ((device_hint[hint].serial_number[0] == '*') || !strcmp(device_hint[hint].serial_number, serial_number)) {
-                                /* match! */
-                                video_nr = device_hint[hint].device_node;
-                                Trace(TRACE_PROBE, "Found hint, will try to register as /dev/video%d\n", video_nr);
-                                break;
+                                /* match! */
+                                video_nr = device_hint[hint].device_node;
+                                PWC_DEBUG_PROBE("Found hint, will try to register as /dev/video%d\n", video_nr);
+                                break;
                         }
                 }
         }
@@ -1929,21 +1707,27 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         pdev->vdev->release = video_device_release;
         i = video_register_device(pdev->vdev, VFL_TYPE_GRABBER, video_nr);
         if (i < 0) {
-                Err("Failed to register as video device (%d).\n", i);
+                PWC_ERROR("Failed to register as video device (%d).\n", i);
                 video_device_release(pdev->vdev); /* Drip... drip... drip... */
                 kfree(pdev); /* Oops, no memory leaks please */
                 return -EIO;
         }
         else {
-                Info("Registered as /dev/video%d.\n", pdev->vdev->minor & 0x3F);
+                PWC_INFO("Registered as /dev/video%d.\n", pdev->vdev->minor & 0x3F);
         }
 
         /* occupy slot */
         if (hint < MAX_DEV_HINTS)
                 device_hint[hint].pdev = pdev;
 
-        Trace(TRACE_PROBE, "probe() function returning struct at 0x%p.\n", pdev);
+        PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
         usb_set_intfdata (intf, pdev);
+        pwc_create_sysfs_files(pdev->vdev);
+
+        /* Set the leds off */
+        pwc_set_leds(pdev, 0, 0);
+        pwc_camera_power(pdev, 0);
+
         return 0;
 }
 
@@ -1957,27 +1741,21 @@ static void usb_pwc_disconnect(struct usb_interface *intf)
         pdev = usb_get_intfdata (intf);
         usb_set_intfdata (intf, NULL);
         if (pdev == NULL) {
-                Err("pwc_disconnect() Called without private pointer.\n");
+                PWC_ERROR("pwc_disconnect() Called without private pointer.\n");
                 goto disconnect_out;
         }
         if (pdev->udev == NULL) {
-                Err("pwc_disconnect() already called for %p\n", pdev);
+                PWC_ERROR("pwc_disconnect() already called for %p\n", pdev);
                 goto disconnect_out;
         }
         if (pdev->udev != interface_to_usbdev(intf)) {
-                Err("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
-                goto disconnect_out;
-        }
-#ifdef PWC_MAGIC
-        if (pdev->magic != PWC_MAGIC) {
-                Err("pwc_disconnect() Magic number failed. Consult your scrolls and try again.\n");
+                PWC_ERROR("pwc_disconnect() Woops: pointer mismatch udev/pdev.\n");
                 goto disconnect_out;
         }
-#endif
 
         /* We got unplugged; this is signalled by an EPIPE error code */
         if (pdev->vopen) {
-                Info("Disconnected while webcam is in use!\n");
+                PWC_INFO("Disconnected while webcam is in use!\n");
                 pdev->error_status = EPIPE;
         }
 
@@ -1987,7 +1765,8 @@ static void usb_pwc_disconnect(struct usb_interface *intf)
         while (pdev->vopen)
                 schedule();
         /* Device is now closed, so we can safely unregister it */
-        Trace(TRACE_PROBE, "Unregistering video device in disconnect().\n");
+        PWC_DEBUG_PROBE("Unregistering video device in disconnect().\n");
+        pwc_remove_sysfs_files(pdev->vdev);
         video_unregister_device(pdev->vdev);
 
         /* Free memory (don't set pdev to 0 just yet) */
@@ -2021,58 +1800,64 @@ static int pwc_atoi(const char *s)
  * Initialization code & module stuff
  */
 
-static char size[10];
-static int fps = 0;
-static int fbufs = 0;
-static int mbufs = 0;
-static int trace = -1;
+static char *size;
+static int fps;
+static int fbufs;
+static int mbufs;
 static int compression = -1;
 static int leds[2] = { -1, -1 };
-static char *dev_hint[MAX_DEV_HINTS] = { };
+static int leds_nargs;
+static char *dev_hint[MAX_DEV_HINTS];
+static int dev_hint_nargs;
+
+module_param(size, charp, 0444);
+module_param(fps, int, 0444);
+module_param(fbufs, int, 0444);
+module_param(mbufs, int, 0444);
+#if CONFIG_PWC_DEBUG
+module_param_named(trace, pwc_trace, int, 0644);
+#endif
+module_param(power_save, int, 0444);
+module_param(compression, int, 0444);
+module_param_array(leds, int, &leds_nargs, 0444);
+module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
 
-module_param_string(size, size, sizeof(size), 0);
 MODULE_PARM_DESC(size, "Initial image size. One of sqcif, qsif, qcif, sif, cif, vga");
-module_param(fps, int, 0000);
 MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful range 5-30");
-module_param(fbufs, int, 0000);
 MODULE_PARM_DESC(fbufs, "Number of internal frame buffers to reserve");
-module_param(mbufs, int, 0000);
 MODULE_PARM_DESC(mbufs, "Number of external (mmap()ed) image buffers");
-module_param(trace, int, 0000);
 MODULE_PARM_DESC(trace, "For debugging purposes");
-module_param(power_save, bool, 0000);
 MODULE_PARM_DESC(power_save, "Turn power save feature in camera on or off");
-module_param(compression, int, 0000);
 MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
-module_param_array(leds, int, NULL, 0000);
 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
-module_param_array(dev_hint, charp, NULL, 0000);
 MODULE_PARM_DESC(dev_hint, "Device node hints");
 
 MODULE_DESCRIPTION("Philips & OEM USB webcam driver");
 MODULE_AUTHOR("Luc Saillard <luc@saillard.org>");
 MODULE_LICENSE("GPL");
+MODULE_ALIAS("pwcx");
+MODULE_VERSION( PWC_VERSION );
 
 static int __init usb_pwc_init(void)
 {
         int i, sz;
         char *sizenames[PSZ_MAX] = { "sqcif", "qsif", "qcif", "sif", "cif", "vga" };
 
-        Info("Philips webcam module version " PWC_VERSION " loaded.\n");
-        Info("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
-        Info("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
-        Info("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
+        PWC_INFO("Philips webcam module version " PWC_VERSION " loaded.\n");
+        PWC_INFO("Supports Philips PCA645/646, PCVC675/680/690, PCVC720[40]/730/740/750 & PCVC830/840.\n");
+        PWC_INFO("Also supports the Askey VC010, various Logitech Quickcams, Samsung MPC-C10 and MPC-C30,\n");
+        PWC_INFO("the Creative WebCam 5 & Pro Ex, SOTEC Afina Eye and Visionite VCS-UC300 and VCS-UM100.\n");
 
         if (fps) {
                 if (fps < 4 || fps > 30) {
-                        Err("Framerate out of bounds (4-30).\n");
+                        PWC_ERROR("Framerate out of bounds (4-30).\n");
                         return -EINVAL;
                 }
                 default_fps = fps;
-                Info("Default framerate set to %d.\n", default_fps);
+                PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
         }
 
-        if (size[0]) {
+        if (size) {
                 /* string; try matching with array */
                 for (sz = 0; sz < PSZ_MAX; sz++) {
                         if (!strcmp(sizenames[sz], size)) { /* Found! */
@@ -2081,41 +1866,42 @@ static int __init usb_pwc_init(void)
                         }
                 }
                 if (sz == PSZ_MAX) {
-                        Err("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
+                        PWC_ERROR("Size not recognized; try size=[sqcif | qsif | qcif | sif | cif | vga].\n");
                         return -EINVAL;
                 }
-                Info("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
+                PWC_DEBUG_MODULE("Default image size set to %s [%dx%d].\n", sizenames[default_size], pwc_image_sizes[default_size].x, pwc_image_sizes[default_size].y);
         }
         if (mbufs) {
                 if (mbufs < 1 || mbufs > MAX_IMAGES) {
-                        Err("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
+                        PWC_ERROR("Illegal number of mmap() buffers; use a number between 1 and %d.\n", MAX_IMAGES);
                         return -EINVAL;
                 }
-                default_mbufs = mbufs;
-                Info("Number of image buffers set to %d.\n", default_mbufs);
+                pwc_mbufs = mbufs;
+                PWC_DEBUG_MODULE("Number of image buffers set to %d.\n", pwc_mbufs);
         }
         if (fbufs) {
                 if (fbufs < 2 || fbufs > MAX_FRAMES) {
-                        Err("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
+                        PWC_ERROR("Illegal number of frame buffers; use a number between 2 and %d.\n", MAX_FRAMES);
                         return -EINVAL;
                 }
                 default_fbufs = fbufs;
-                Info("Number of frame buffers set to %d.\n", default_fbufs);
+                PWC_DEBUG_MODULE("Number of frame buffers set to %d.\n", default_fbufs);
         }
-        if (trace >= 0) {
-                Info("Trace options: 0x%04x\n", trace);
-                pwc_trace = trace;
+#if CONFIG_PWC_DEBUG
+        if (pwc_trace >= 0) {
+                PWC_DEBUG_MODULE("Trace options: 0x%04x\n", pwc_trace);
         }
+#endif
         if (compression >= 0) {
                 if (compression > 3) {
-                        Err("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
+                        PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
                         return -EINVAL;
                 }
                 pwc_preferred_compression = compression;
-                Info("Preferred compression set to %d.\n", pwc_preferred_compression);
+                PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
         }
         if (power_save)
-                Info("Enabling power save on open/close.\n");
+                PWC_DEBUG_MODULE("Enabling power save on open/close.\n");
         if (leds[0] >= 0)
                 led_on = leds[0];
         if (leds[1] >= 0)
@@ -2146,14 +1932,14 @@ static int __init usb_pwc_init(void)
                                 dot++;
                         /* Few sanity checks */
                         if (*dot != '\0' && dot > colon) {
-                                Err("Malformed camera hint: the colon must be after the dot.\n");
+                                PWC_ERROR("Malformed camera hint: the colon must be after the dot.\n");
                                 return -EINVAL;
                         }
 
                         if (*colon == '\0') {
                                 /* No colon */
                                 if (*dot != '\0') {
-                                        Err("Malformed camera hint: no colon + device node given.\n");
+                                        PWC_ERROR("Malformed camera hint: no colon + device node given.\n");
                                         return -EINVAL;
                                 }
                                 else {
@@ -2178,28 +1964,27 @@ static int __init usb_pwc_init(void)
                                         device_hint[i].serial_number[k] = '\0';
                                 }
                         }
-#if PWC_DEBUG
-                        Debug("device_hint[%d]:\n", i);
-                        Debug("  type    : %d\n", device_hint[i].type);
-                        Debug("  serial# : %s\n", device_hint[i].serial_number);
-                        Debug("  node    : %d\n", device_hint[i].device_node);
-#endif
+                        PWC_TRACE("device_hint[%d]:\n", i);
+                        PWC_TRACE("  type    : %d\n", device_hint[i].type);
+                        PWC_TRACE("  serial# : %s\n", device_hint[i].serial_number);
+                        PWC_TRACE("  node    : %d\n", device_hint[i].device_node);
                 }
                 else
                         device_hint[i].type = 0; /* not filled */
         } /* ..for MAX_DEV_HINTS */
 
-        Trace(TRACE_PROBE, "Registering driver at address 0x%p.\n", &pwc_driver);
+        PWC_DEBUG_PROBE("Registering driver at address 0x%p.\n", &pwc_driver);
         return usb_register(&pwc_driver);
 }
 
 static void __exit usb_pwc_exit(void)
 {
-        Trace(TRACE_MODULE, "Deregistering driver.\n");
+        PWC_DEBUG_MODULE("Deregistering driver.\n");
         usb_deregister(&pwc_driver);
-        Info("Philips webcam module removed.\n");
+        PWC_INFO("Philips webcam module removed.\n");
 }
 
 module_init(usb_pwc_init);
 module_exit(usb_pwc_exit);
 
+/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
diff --git a/drivers/media/video/pwc/pwc-kiara.c b/drivers/media/video/pwc/pwc-kiara.c
index 4c96037f7be..fec39cc5a9f 100644
--- a/drivers/media/video/pwc/pwc-kiara.c
+++ b/drivers/media/video/pwc/pwc-kiara.c
@@ -1,5 +1,5 @@
 /* Linux driver for Philips webcam
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -316,3 +316,576 @@ const struct Kiara_table_entry Kiara_table[PSZ_MAX][6][4] =
    },
 };
 
+
+/*
+ * Rom table for kiara chips
+ *
+ * 32 roms tables (one for each resolution ?)
+ *  2 tables per roms (one for each passes) (Y, and U&V)
+ * 128 bytes per passes
+ */
+
+const unsigned int KiaraRomTable [8][2][16][8] =
+{
+ { /* version 0 */
+  { /* version 0, passes 0 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000001,0x00000001},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000009,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000249,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000249,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x00000249,0x0000124a,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x0000124a,0x00009252,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00009252,0x00009292,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009292,0x00009292,0x00009493,0x000124db},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009492,0x0000a49b,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x0000a493,0x000124db,0x000124db,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x000124db,0x000126dc,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000124db,0x000136e4,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b925,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 0, passes 1 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000001,0x00000009,
+    0x00000009,0x00000009,0x00000009,0x00000001},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000249,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00001252},
+   {0x00000000,0x00000000,0x00000049,0x00001249,
+    0x0000124a,0x0000124a,0x00001252,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009252,0x00009292,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009292,0x00009292,0x00009292,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x00009292,
+    0x00009492,0x00009493,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00009252,0x00009493,
+    0x000126dc,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000136e4,0x000136e4,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 1 */
+  { /* version 1, passes 0 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000001},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00001252},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009252,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009252,0x00009493,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009292,0x00009493,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x00009252,
+    0x00009492,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x000124db,0x000124db,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000126dc,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 1, passes 1 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000049,0x00000009,
+    0x00000049,0x00000009,0x00000001,0x00000000},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000000},
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000249,0x00000049,0x0000024a,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x0000024a,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x0000024a,0x00000009},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00009252,0x00001252,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00009292,0x00001252,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00009292,0x00001252,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009292,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x0000924a,0x0000924a,
+    0x00009492,0x00009493,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 2 */
+  { /* version 2, passes 0 */
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x00009252,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009493,0x00009493,0x0000a49b},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009292,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009292,0x00009493,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x000124db,0x000124db,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0001249b,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x00009252,0x000124db,
+    0x000126dc,0x0001b724,0x0001b725,0x0001b925},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 2, passes 1 */
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00000249,
+    0x0000124a,0x0000124a,0x00001252,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00009292,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x0000a49b,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x0000a49b,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x00009252,0x0000a49b,
+    0x0001249b,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 3 */
+  { /* version 3, passes 0 */
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x0000a49b,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0001249b,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000136e4,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x0001b725,0x0001b925},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x000136e4,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b92d,0x0001c92d},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000126dc,0x0001b724,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x000136e4,0x0001b925,0x00025bb6,0x00024b77},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 3, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00000249,
+    0x0000124a,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x00009493,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x000126dc,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000136e4,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001b724,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 4 */
+  { /* version 4, passes 0 */
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000249,0x00000249,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x00009252,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009292,0x00009493,0x00009493,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0001249b,0x000126dc,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00009252,0x00009493,
+    0x000124db,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009252,0x0000a49b,
+    0x000124db,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x000136e4,0x0001b925,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 4, passes 1 */
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000009,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000049,0x00000049,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00000249,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x0000124a,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009252,0x0000124a,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x00009252,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x00009292,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x00009292,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x00009493,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000124db,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009252,0x000124db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 5 */
+  { /* version 5, passes 0 */
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000126dc,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b725,0x000136e4},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b925,0x0001c96e,0x0001b925},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x0001b724,0x0001b925,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001c924,0x0002496d,0x00025bb6,0x00024b77},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 5, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009252,0x00009252,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000124db,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000124db,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000126dc,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009292,0x000124db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 6 */
+  { /* version 6, passes 0 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000126dc,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b725,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b92d,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b925,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x0001b724,0x0001b925,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001c92d,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001c92d,0x00024b76,0x0002496e},
+   {0x00000000,0x00000000,0x00012492,0x000126db,
+    0x0001c924,0x00024b6d,0x0002ddb6,0x00025bbf},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 6, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x00009252,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x00009292,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000124db,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000126dc,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x0001b724,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 7 */
+  { /* version 7, passes 0 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x0000a49b,
+    0x0001249b,0x000126dc,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x0001b725,0x000124db},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b725,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x000124db,
+    0x000136e4,0x0001b724,0x0001b725,0x000126dc},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b724,0x0001c96e,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001c92d,0x0001c96e,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x000136e4,0x0001c92d,0x0001c96e,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001c92d,0x0001c96e,0x0001b925},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b724,0x0001c92d,0x00024b76,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b924,0x0001c92d,0x00024b76,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b924,0x0001c92d,0x00024b76,0x0002496e},
+   {0x00000000,0x00000000,0x00012492,0x000136db,
+    0x00024924,0x00024b6d,0x0002ddb6,0x00025bbf},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 7, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x00009492,0x00009292,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000124db,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000136db,
+    0x0001b724,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000136db,
+    0x0001b724,0x000126dc,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00009292,0x000136db,
+    0x0001b724,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000136db,
+    0x0001b724,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00012492,0x0001b6db,
+    0x0001c924,0x0001b724,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ }
+};
+
diff --git a/drivers/media/video/pwc/pwc-kiara.h b/drivers/media/video/pwc/pwc-kiara.h
index 12929abbb1f..0bdb22547d8 100644
--- a/drivers/media/video/pwc/pwc-kiara.h
+++ b/drivers/media/video/pwc/pwc-kiara.h
@@ -1,5 +1,5 @@
 /* Linux driver for Philips webcam
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -27,7 +27,7 @@
 #ifndef PWC_KIARA_H
 #define PWC_KIARA_H
 
-#include "pwc-ioctl.h"
+#include <media/pwc-ioctl.h>
 
 struct Kiara_table_entry
 {
@@ -37,8 +37,8 @@ struct Kiara_table_entry
         unsigned char mode[12];         /* precomputed mode settings for cam */
 };
 
-const extern struct Kiara_table_entry Kiara_table[PSZ_MAX][6][4];
-const extern unsigned int KiaraRomTable[8][2][16][8];
+extern const struct Kiara_table_entry Kiara_table[PSZ_MAX][6][4];
+extern const unsigned int KiaraRomTable[8][2][16][8];
 
 #endif
 
diff --git a/drivers/media/video/pwc/pwc-misc.c b/drivers/media/video/pwc/pwc-misc.c
index 58fe7974799..589c687439d 100644
--- a/drivers/media/video/pwc/pwc-misc.c
+++ b/drivers/media/video/pwc/pwc-misc.c
@@ -1,7 +1,7 @@
 /* Linux driver for Philips webcam
    Various miscellaneous functions and tables.
    (C) 1999-2003 Nemosoft Unv.
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -24,18 +24,17 @@
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
-#include <linux/slab.h>
 
 #include "pwc.h"
 
-struct pwc_coord pwc_image_sizes[PSZ_MAX] =
+const struct pwc_coord pwc_image_sizes[PSZ_MAX] =
 {
-        { 128,  96, 0 },
-        { 160, 120, 0 },
-        { 176, 144, 0 },
-        { 320, 240, 0 },
-        { 352, 288, 0 },
-        { 640, 480, 0 },
+        { 128,  96, 0 }, /* sqcif */
+        { 160, 120, 0 }, /* qsif */
+        { 176, 144, 0 }, /* qcif */
+        { 320, 240, 0 }, /* sif */
+        { 352, 288, 0 }, /* cif */
+        { 640, 480, 0 }, /* vga */
 };
 
 /* x,y -> PSZ_ */
@@ -52,7 +51,7 @@ int pwc_decode_size(struct pwc_device *pdev, int width, int height)
         {
                 if (width > pdev->abs_max.x || height > pdev->abs_max.y)
                 {
-                        Debug("VIDEO_PALETTE_RAW: going beyond abs_max.\n");
+                        PWC_DEBUG_SIZE("VIDEO_PALETTE_RAW: going beyond abs_max.\n");
                         return -1;
                 }
         }
@@ -60,7 +59,7 @@ int pwc_decode_size(struct pwc_device *pdev, int width, int height)
         {
                 if (width > pdev->view_max.x || height > pdev->view_max.y)
                 {
-                        Debug("VIDEO_PALETTE_ not RAW: going beyond view_max.\n");
+                        PWC_DEBUG_SIZE("VIDEO_PALETTE_not RAW: going beyond view_max.\n");
                         return -1;
                 }
         }
@@ -81,9 +80,8 @@ int pwc_decode_size(struct pwc_device *pdev, int width, int height)
 /* initialize variables depending on type and decompressor*/
 void pwc_construct(struct pwc_device *pdev)
 {
-        switch(pdev->type) {
-        case 645:
-        case 646:
+        if (DEVICE_USE_CODEC1(pdev->type)) {
+
                 pdev->view_min.x = 128;
                 pdev->view_min.y =  96;
                 pdev->view_max.x = 352;
@@ -95,10 +93,23 @@ void pwc_construct(struct pwc_device *pdev)
                 pdev->vendpoint = 4;
                 pdev->frame_header_size = 0;
                 pdev->frame_trailer_size = 0;
-                break;
-        case 675:
-        case 680:
-        case 690:
+
+        } else if (DEVICE_USE_CODEC3(pdev->type)) {
+
+                pdev->view_min.x = 160;
+                pdev->view_min.y = 120;
+                pdev->view_max.x = 640;
+                pdev->view_max.y = 480;
+                pdev->image_mask = 1 << PSZ_QSIF | 1 << PSZ_SIF | 1 << PSZ_VGA;
+                pdev->abs_max.x = 640;
+                pdev->abs_max.y = 480;
+                pdev->vcinterface = 3;
+                pdev->vendpoint = 5;
+                pdev->frame_header_size = TOUCAM_HEADER_SIZE;
+                pdev->frame_trailer_size = TOUCAM_TRAILER_SIZE;
+
+        } else /* if (DEVICE_USE_CODEC2(pdev->type)) */ {
+
                 pdev->view_min.x = 128;
                 pdev->view_min.y =  96;
                 /* Anthill bug #38: PWC always reports max size, even without PWCX */
@@ -111,30 +122,12 @@ void pwc_construct(struct pwc_device *pdev)
                 pdev->vendpoint = 4;
                 pdev->frame_header_size = 0;
                 pdev->frame_trailer_size = 0;
-                break;
-        case 720:
-        case 730:
-        case 740:
-        case 750:
-                pdev->view_min.x = 160;
-                pdev->view_min.y = 120;
-                pdev->view_max.x = 640;
-                pdev->view_max.y = 480;
-                pdev->image_mask = 1 << PSZ_QSIF | 1 << PSZ_SIF | 1 << PSZ_VGA;
-                pdev->abs_max.x = 640;
-                pdev->abs_max.y = 480;
-                pdev->vcinterface = 3;
-                pdev->vendpoint = 5;
-                pdev->frame_header_size = TOUCAM_HEADER_SIZE;
-                pdev->frame_trailer_size = TOUCAM_TRAILER_SIZE;
-                break;
         }
-        Debug("type = %d\n",pdev->type);
         pdev->vpalette = VIDEO_PALETTE_YUV420P; /* default */
         pdev->view_min.size = pdev->view_min.x * pdev->view_min.y;
         pdev->view_max.size = pdev->view_max.x * pdev->view_max.y;
         /* length of image, in YUV format; always allocate enough memory. */
-        pdev->len_per_image = (pdev->abs_max.x * pdev->abs_max.y * 3) / 2;
+        pdev->len_per_image = PAGE_ALIGN((pdev->abs_max.x * pdev->abs_max.y * 3) / 2);
 }
 
 
diff --git a/drivers/media/video/pwc/pwc-timon.c b/drivers/media/video/pwc/pwc-timon.c
index 175250d089c..be65bdcd195 100644
--- a/drivers/media/video/pwc/pwc-timon.c
+++ b/drivers/media/video/pwc/pwc-timon.c
@@ -1,5 +1,5 @@
 /* Linux driver for Philips webcam
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -314,3 +314,1133 @@ const struct Timon_table_entry Timon_table[PSZ_MAX][6][4] =
    },
 };
 
+/*
+ * 16 versions:
+ *   2 tables  (one for Y, and one for U&V)
+ *   16 levels of details per tables
+ *   8 blocs
+ */
+
+const unsigned int TimonRomTable [16][2][16][8] =
+{
+ { /* version 0 */
+  { /* version 0, passes 0 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000001},
+   {0x00000000,0x00000000,0x00000001,0x00000001,
+    0x00000001,0x00000001,0x00000001,0x00000001},
+   {0x00000000,0x00000000,0x00000001,0x00000001,
+    0x00000001,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000009,0x00000001,
+    0x00000009,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000009,0x00000049,0x00000009},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000009,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000249,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000249,0x00000249,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000249,0x0000124a,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009252,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 0, passes 1 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000001,0x00000001,
+    0x00000001,0x00000001,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000009,0x00000001,
+    0x00000001,0x00000009,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000009,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000009,0x00000001,0x00000000},
+   {0x00000000,0x00000000,0x00000049,0x00000009,
+    0x00000009,0x00000049,0x00000001,0x00000001},
+   {0x00000000,0x00000000,0x00000049,0x00000009,
+    0x00000009,0x00000049,0x00000001,0x00000001},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000009,0x00000001},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000009,0x00000001},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000009,0x00000001},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000249,0x00000049,0x00000009},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000249,0x00000049,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000249,0x00000249,0x00000049,0x00000009},
+   {0x00000000,0x00000000,0x00001249,0x00000249,
+    0x0000124a,0x0000124a,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 1 */
+  { /* version 1, passes 0 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000001},
+   {0x00000000,0x00000000,0x00000001,0x00000001,
+    0x00000001,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000009,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000249,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00001252},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x0000124a,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009252,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009252,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009292,0x00009493,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 1, passes 1 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000001,0x00000001,0x00000000},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000009,0x00000001,0x00000000},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000009,0x00000001,0x00000000},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000001,0x00000001},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000009,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000049,0x00000249,0x00000009,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000249,0x00000249,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x00000049,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00000049,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00000049,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009252,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 2 */
+  { /* version 2, passes 0 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000001},
+   {0x00000000,0x00000000,0x00000009,0x00000009,
+    0x00000009,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00001252},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009252,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009252,0x00009493,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009292,0x00009493,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x00009252,
+    0x00009492,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x000124db,0x000124db,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000126dc,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 2, passes 1 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000049,0x00000009,
+    0x00000049,0x00000009,0x00000001,0x00000000},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000000},
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000249,0x00000049,0x0000024a,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x0000024a,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x0000024a,0x00000009},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00009252,0x00001252,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00009292,0x00001252,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00009292,0x00001252,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009292,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x0000924a,0x0000924a,
+    0x00009492,0x00009493,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 3 */
+  { /* version 3, passes 0 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000001},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000049,0x00000249,
+    0x00000249,0x00000249,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x00009252,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009292,0x00009292,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009292,0x00009493,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x00009252,
+    0x00009292,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009292,0x0000a49b,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x000124db,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x0000a49b,0x000124db,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0001249b,0x000126dc,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x0001b725,0x000136e4},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 3, passes 1 */
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000},
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000001,0x00000000},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x00000049,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x00000001},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x00001252,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009252,0x00009292,0x00000009},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00009252,0x00009292,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009252,0x00009292,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009493,0x00009292,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009493,0x00009292,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009493,0x00009493,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009292,0x00009493,0x00009493,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x00009493,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x00009292,
+    0x0000a493,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 4 */
+  { /* version 4, passes 0 */
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x00009252,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009493,0x00009493,0x0000a49b},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009292,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009292,0x00009493,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x000124db,0x000124db,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0001249b,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x00009252,0x000124db,
+    0x000126dc,0x0001b724,0x0001b725,0x0001b925},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 4, passes 1 */
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00000249,
+    0x0000124a,0x0000124a,0x00001252,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00009292,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x0000a49b,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x0000a49b,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x00009252,0x0000a49b,
+    0x0001249b,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 5 */
+  { /* version 5, passes 0 */
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x0000124a,0x00001252,0x00009292},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x0000124a,0x00009292,0x00009292,0x00009493},
+   {0x00000000,0x00000000,0x00000249,0x0000924a,
+    0x00009292,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009292,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x0000a49b,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x000124db,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x000124db,0x000124db,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0001249b,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0001249b,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0001249b,0x000126dc,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000126dc,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x000136e4,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b724,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 5, passes 1 */
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x00009493,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x00009493,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x00009493,0x000124db,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x00009493,0x000124db,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x000124db,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x000124db,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009252,0x000124db,
+    0x000126dc,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 6 */
+  { /* version 6, passes 0 */
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x0000124a,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x0000a49b,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0001249b,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000136e4,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x0001b725,0x0001b925},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x000136e4,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b92d,0x0001c92d},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000126dc,0x0001b724,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x000136e4,0x0001b925,0x00025bb6,0x00024b77},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 6, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00000249,
+    0x0000124a,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x00009493,0x0000a49b,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x000126dc,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000136e4,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001b724,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 7 */
+  { /* version 7, passes 0 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x0000a49b,0x000124db,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0001249b,0x000126dc,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x0001b725,0x0001b925},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x00009292,0x000124db,
+    0x000126dc,0x0001b724,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b724,0x0001c96e,0x0002496e},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x000136e4,0x0001b925,0x0001c96e,0x0002496e},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x0002496d,0x00025bb6,0x00025bbf},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 7, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x00009493,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x000136e4,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x000136e4,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000124db,0x000136e4,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x000136e4,0x0001b724,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00012492,0x000126db,
+    0x0001b724,0x0001b925,0x0001b725,0x000136e4},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 8 */
+  { /* version 8, passes 0 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009292,0x00009493,0x0000a49b,0x000124db},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x000124db,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x000136e4},
+   {0x00000000,0x00000000,0x00001249,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000136e4,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x0001b725,0x0001b925},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b92d,0x0001c92d},
+   {0x00000000,0x00000000,0x00009252,0x000124db,
+    0x000126dc,0x0001b724,0x0001b92d,0x0001c92d},
+   {0x00000000,0x00000000,0x00009292,0x000124db,
+    0x000126dc,0x0001b925,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b925,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b925,0x00024b76,0x00024b77},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x000136e4,0x0001b925,0x00024b76,0x00025bbf},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x000136e4,0x0001c92d,0x00024b76,0x00025bbf},
+   {0x00000000,0x00000000,0x00012492,0x000136db,
+    0x0001b724,0x00024b6d,0x0002ddb6,0x0002efff},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 8, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009493,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000126dc,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000136e4,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00009292,0x000124db,
+    0x000136e4,0x0001b724,0x0001b725,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x000136e4,0x0001b925,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x000136e4,0x0001b925,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x0002496d,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 9 */
+  { /* version 9, passes 0 */
+   {0x00000000,0x00000000,0x00000049,0x00000049,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000249,0x00000249,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x0000124a,0x00009252,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009292,0x00009493,0x00009493,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0001249b,0x000126dc,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00009252,0x00009493,
+    0x000124db,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009252,0x0000a49b,
+    0x000124db,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x000136e4,0x0001b925,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 9, passes 1 */
+   {0x00000000,0x00000000,0x00000249,0x00000049,
+    0x00000009,0x00000009,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000049,0x00000049,0x00000009,0x00000009},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00000249,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x0000124a,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009252,0x0000124a,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x00009252,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x00009292,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x00009292,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x00009493,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000124db,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009252,0x000124db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 10 */
+  { /* version 10, passes 0 */
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00000249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x00009493,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x000124db,0x000124db,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0001249b,0x000126dc,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000126dc,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009252,0x0000a49b,
+    0x000124db,0x000136e4,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000126dc,0x0001b925,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x000136e4,0x0002496d,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 10, passes 1 */
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000049,0x00000049,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00000249,0x00000049,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x00009252,0x0000024a,0x00000049},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009493,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00009252,
+    0x00009492,0x00009493,0x00001252,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x00009493,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x00009492,0x00009493,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x00009493,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009252,0x000126db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 11 */
+  { /* version 11, passes 0 */
+   {0x00000000,0x00000000,0x00000249,0x00000249,
+    0x00000249,0x00000249,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009492,0x0000a49b,0x0000a49b,0x00009292},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x000124db,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000126dc,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b725,0x000136e4},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b925,0x0001c96e,0x0001b925},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x0001b724,0x0001b925,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001c924,0x0002496d,0x00025bb6,0x00024b77},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 11, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00000249,
+    0x00000249,0x00000249,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009252,0x00009252,0x0000024a,0x0000024a},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x0000a49b,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x0000a49b,0x00009292,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000124db,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000124db,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000126dc,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009292,0x000124db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 12 */
+  { /* version 12, passes 0 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x0000a493,0x0000a49b,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x000126dc,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b725,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b92d,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b724,0x0001b92d,0x0001b724},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b925,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x0001b724,0x0001b925,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001c92d,0x0001c96e,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001c92d,0x00024b76,0x0002496e},
+   {0x00000000,0x00000000,0x00012492,0x000126db,
+    0x0001c924,0x00024b6d,0x0002ddb6,0x00025bbf},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 12, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x00001249,0x00009292,
+    0x00009492,0x00009252,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x00009292,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000124db,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000124db,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000126dc,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x000136e4,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00009492,0x000126db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x0001b724,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 13 */
+  { /* version 13, passes 0 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x00009252,0x00009292,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x000124db,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x0000a49b,
+    0x0001249b,0x000126dc,0x000126dc,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x000136e4,0x0001b725,0x000124db},
+   {0x00000000,0x00000000,0x00009292,0x0000a49b,
+    0x000136e4,0x0001b724,0x0001b725,0x000126dc},
+   {0x00000000,0x00000000,0x00009292,0x000124db,
+    0x000136e4,0x0001b724,0x0001b725,0x000126dc},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b724,0x0001c96e,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001c92d,0x0001c96e,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x000136e4,0x0001c92d,0x0001c96e,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001c92d,0x0001c96e,0x0001b925},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b724,0x0001c92d,0x00024b76,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b924,0x0001c92d,0x00024b76,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b924,0x0001c92d,0x00024b76,0x0002496e},
+   {0x00000000,0x00000000,0x00012492,0x000136db,
+    0x00024924,0x00024b6d,0x0002ddb6,0x00025bbf},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 13, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x00009492,0x00009292,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x0000a49b,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000124db,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000136db,
+    0x0001b724,0x000124db,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000136db,
+    0x0001b724,0x000126dc,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00009292,0x000136db,
+    0x0001b724,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000136db,
+    0x0001b724,0x000126dc,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00012492,0x0001b6db,
+    0x0001c924,0x0001b724,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 14 */
+  { /* version 14, passes 0 */
+   {0x00000000,0x00000000,0x00001249,0x0000924a,
+    0x00009292,0x00009493,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00001249,0x0000a49b,
+    0x0000a493,0x000124db,0x000126dc,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x0000a49b},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x000136e4,0x0001b725,0x000124db},
+   {0x00000000,0x00000000,0x00009292,0x000124db,
+    0x000126dc,0x0001b724,0x0001b92d,0x000126dc},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b724,0x0001b92d,0x000126dc},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001c92d,0x0001c96e,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x0001b724,0x0001c92d,0x0001c96e,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001c92d,0x00024b76,0x0001b925},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b724,0x0001c92d,0x00024b76,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b724,0x0001c92d,0x00024b76,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x0001c92d,0x00024b76,0x0002496e},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b924,0x0002496d,0x00024b76,0x00024b77},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b924,0x00024b6d,0x0002ddb6,0x00025bbf},
+   {0x00000000,0x00000000,0x00012492,0x0001b6db,
+    0x00024924,0x0002db6d,0x00036db6,0x0002efff},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 14, passes 1 */
+   {0x00000000,0x00000000,0x00001249,0x00001249,
+    0x0000124a,0x0000124a,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x00009493,
+    0x0000a493,0x00009292,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x0000a49b,0x00001252,0x00001252},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000136e4,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000136e4,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x000136e4,0x00009493,0x00009292},
+   {0x00000000,0x00000000,0x00009492,0x000136db,
+    0x0001b724,0x000136e4,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x00009492,0x000136db,
+    0x0001b724,0x000136e4,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x00009492,0x000136db,
+    0x0001b724,0x000136e4,0x0000a49b,0x00009493},
+   {0x00000000,0x00000000,0x00009492,0x000136db,
+    0x0001b724,0x000136e4,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x000136e4,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x000136e4,0x000124db,0x0000a49b},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b724,0x000136e4,0x000126dc,0x000124db},
+   {0x00000000,0x00000000,0x00012492,0x0001b6db,
+    0x0001c924,0x0001b724,0x000136e4,0x000126dc},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ },
+ { /* version 15 */
+  { /* version 15, passes 0 */
+   {0x00000000,0x00000000,0x00001249,0x00009493,
+    0x0000a493,0x0000a49b,0x000124db,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0001249b,0x000126dc,0x000136e4,0x000124db},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x000126dc,0x0001b724,0x0001b725,0x000126dc},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x0001b724,0x0001b92d,0x000126dc},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x000136e4,0x0001b925,0x0001c96e,0x000136e4},
+   {0x00000000,0x00000000,0x00009492,0x000124db,
+    0x0001b724,0x0001c92d,0x0001c96e,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000124db,
+    0x0001b724,0x0001c92d,0x0001c96e,0x0001b724},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b724,0x0001c92d,0x0001c96e,0x0001b925},
+   {0x00000000,0x00000000,0x0000a492,0x000126db,
+    0x0001b924,0x0001c92d,0x00024b76,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b924,0x0001c92d,0x00024b76,0x0001c92d},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001b924,0x0002496d,0x00024b76,0x0002496e},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x0002496d,0x00025bb6,0x00024b77},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x00024b6d,0x00025bb6,0x00024b77},
+   {0x00000000,0x00000000,0x00012492,0x000136db,
+    0x0001c924,0x00024b6d,0x0002ddb6,0x00025bbf},
+   {0x00000000,0x00000000,0x00012492,0x0001b6db,
+    0x00024924,0x0002db6d,0x00036db6,0x0002efff},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  },
+  { /* version 15, passes 1 */
+   {0x00000000,0x00000000,0x0000924a,0x0000924a,
+    0x00009292,0x00009292,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x0000a49b,
+    0x0000a493,0x000124db,0x00009292,0x00009292},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000124db,0x0001b724,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000126dc,0x0001b724,0x00009493,0x00009493},
+   {0x00000000,0x00000000,0x0000924a,0x000124db,
+    0x000136e4,0x0001b724,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00009292,0x000136db,
+    0x0001b724,0x0001b724,0x0000a49b,0x0000a49b},
+   {0x00000000,0x00000000,0x00009492,0x000136db,
+    0x0001c924,0x0001b724,0x000124db,0x000124db},
+   {0x00000000,0x00000000,0x00009492,0x000136db,
+    0x0001c924,0x0001b724,0x000124db,0x000124db},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x0001b724,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x0001b925,0x000126dc,0x000126dc},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x0001b925,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x0001b925,0x000136e4,0x000136e4},
+   {0x00000000,0x00000000,0x0000a492,0x000136db,
+    0x0001c924,0x0001b925,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x00012492,0x000136db,
+    0x0001c924,0x0001b925,0x0001b725,0x0001b724},
+   {0x00000000,0x00000000,0x00012492,0x0001b6db,
+    0x00024924,0x0002496d,0x0001b92d,0x0001b925},
+   {0x00000000,0x00000000,0x00000000,0x00000000,
+    0x00000000,0x00000000,0x00000000,0x00000000}
+  }
+ }
+};
diff --git a/drivers/media/video/pwc/pwc-timon.h b/drivers/media/video/pwc/pwc-timon.h
index a86b3782a08..eef9e2cd432 100644
--- a/drivers/media/video/pwc/pwc-timon.h
+++ b/drivers/media/video/pwc/pwc-timon.h
@@ -1,5 +1,5 @@
 /* Linux driver for Philips webcam
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -42,7 +42,7 @@
 #ifndef PWC_TIMON_H
 #define PWC_TIMON_H
 
-#include "pwc-ioctl.h"
+#include <media/pwc-ioctl.h>
 
 struct Timon_table_entry
 {
@@ -52,8 +52,8 @@ struct Timon_table_entry
         unsigned char mode[13];         /* precomputed mode settings for cam */
 };
 
-const extern struct Timon_table_entry Timon_table[PSZ_MAX][6][4];
-const extern unsigned int TimonRomTable [16][2][16][8];
+extern const struct Timon_table_entry Timon_table[PSZ_MAX][6][4];
+extern const unsigned int TimonRomTable [16][2][16][8];
 
 
 #endif
diff --git a/drivers/media/video/pwc/pwc-uncompress.c b/drivers/media/video/pwc/pwc-uncompress.c
index b37a89a163f..5d82028ef94 100644
--- a/drivers/media/video/pwc/pwc-uncompress.c
+++ b/drivers/media/video/pwc/pwc-uncompress.c
@@ -1,7 +1,7 @@
 /* Linux driver for Philips webcam
    Decompression frontend.
    (C) 1999-2003 Nemosoft Unv.
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -22,6 +22,8 @@
    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+   vim: set ts=8:
 */
 
 #include <asm/current.h>
@@ -29,6 +31,8 @@
 
 #include "pwc.h"
 #include "pwc-uncompress.h"
+#include "pwc-dec1.h"
+#include "pwc-dec23.h"
 
 int pwc_decompress(struct pwc_device *pdev)
 {
@@ -40,107 +44,95 @@ int pwc_decompress(struct pwc_device *pdev)
 
         if (pdev == NULL)
                 return -EFAULT;
-#if defined(__KERNEL__) && defined(PWC_MAGIC)
-        if (pdev->magic != PWC_MAGIC) {
-                Err("pwc_decompress(): magic failed.\n");
-                return -EFAULT;
-        }
-#endif
 
         fbuf = pdev->read_frame;
         if (fbuf == NULL)
                 return -EFAULT;
-        image = pdev->image_ptr[pdev->fill_image];
-        if (!image)
-                return -EFAULT;
+        image  = pdev->image_data;
+        image += pdev->images[pdev->fill_image].offset;
 
         yuv = fbuf->data + pdev->frame_header_size;  /* Skip header */
 
         /* Raw format; that's easy... */
         if (pdev->vpalette == VIDEO_PALETTE_RAW)
         {
-                memcpy(image, yuv, pdev->frame_size);
+                struct pwc_raw_frame *raw_frame = image;
+                raw_frame->type = cpu_to_le16(pdev->type);
+                raw_frame->vbandlength = cpu_to_le16(pdev->vbandlength);
+                        /* cmd_buf is always 4 bytes, but sometimes, only the
+                         * first 3 bytes is filled (Nala case). We can
+                         * determine this using the type of the webcam */
+                memcpy(raw_frame->cmd, pdev->cmd_buf, 4);
+                memcpy(raw_frame+1, yuv, pdev->frame_size);
                 return 0;
         }
 
         if (pdev->vbandlength == 0) {
-                /* Uncompressed mode. We copy the data into the output buffer,
-                   using the viewport size (which may be larger than the image
-                   size). Unfortunately we have to do a bit of byte stuffing
-                   to get the desired output format/size.
+                /* Uncompressed mode.
+                 * We copy the data into the output buffer, using the viewport
+                 * size (which may be larger than the image size).
+                 * Unfortunately we have to do a bit of byte stuffing to get
+                 * the desired output format/size.
+                 *
+                 * We do some byte shuffling here to go from the
+                 * native format to YUV420P.
                  */
-                        /*
-                         * We do some byte shuffling here to go from the
-                         * native format to YUV420P.
-                         */
-                        src = (u16 *)yuv;
-                        n = pdev->view.x * pdev->view.y;
-
-                        /* offset in Y plane */
-                        stride = pdev->view.x * pdev->offset.y + pdev->offset.x;
-                        dsty = (u16 *)(image + stride);
-
-                        /* offsets in U/V planes */
-                        stride = pdev->view.x * pdev->offset.y / 4 + pdev->offset.x / 2;
-                        dstu = (u16 *)(image + n +         stride);
-                        dstv = (u16 *)(image + n + n / 4 + stride);
-
-                        /* increment after each line */
-                        stride = (pdev->view.x - pdev->image.x) / 2; /* u16 is 2 bytes */
-
-                        for (line = 0; line < pdev->image.y; line++) {
-                                for (col = 0; col < pdev->image.x; col += 4) {
-                                        *dsty++ = *src++;
-                                        *dsty++ = *src++;
-                                        if (line & 1)
-                                                *dstv++ = *src++;
-                                        else
-                                                *dstu++ = *src++;
-                                }
-                                dsty += stride;
+                src = (u16 *)yuv;
+                n = pdev->view.x * pdev->view.y;
+
+                /* offset in Y plane */
+                stride = pdev->view.x * pdev->offset.y + pdev->offset.x;
+                dsty = (u16 *)(image + stride);
+
+                /* offsets in U/V planes */
+                stride = pdev->view.x * pdev->offset.y / 4 + pdev->offset.x / 2;
+                dstu = (u16 *)(image + n +         stride);
+                dstv = (u16 *)(image + n + n / 4 + stride);
+
+                /* increment after each line */
+                stride = (pdev->view.x - pdev->image.x) / 2; /* u16 is 2 bytes */
+
+                for (line = 0; line < pdev->image.y; line++) {
+                        for (col = 0; col < pdev->image.x; col += 4) {
+                                *dsty++ = *src++;
+                                *dsty++ = *src++;
                                 if (line & 1)
-                                        dstv += (stride >> 1);
+                                        *dstv++ = *src++;
                                 else
-                                        dstu += (stride >> 1);
+                                        *dstu++ = *src++;
                         }
+                        dsty += stride;
+                        if (line & 1)
+                                dstv += (stride >> 1);
+                        else
+                                dstu += (stride >> 1);
+                }
+
+                return 0;
         }
-        else {
-                /* Compressed; the decompressor routines will write the data
-                   in planar format immediately.
-                 */
-                int flags;
-
-                flags = PWCX_FLAG_PLANAR;
-                if (pdev->vsize == PSZ_VGA && pdev->vframes == 5 && pdev->vsnapshot)
-                 {
-                   printk(KERN_ERR "pwc: Mode Bayer is not supported for now\n");
-                   flags |= PWCX_FLAG_BAYER;
-                   return -ENXIO; /* No such device or address: missing decompressor */
-                 }
-
-#if 0
-                switch (pdev->type)
-                 {
-                  case 675:
-                  case 680:
-                  case 690:
-                  case 720:
-                  case 730:
-                  case 740:
-                  case 750:
-                    pwc_dec23_decompress(&pdev->image, &pdev->view,
-                                &pdev->offset, yuv, image, flags,
-                                pdev->decompress_data, pdev->vbandlength);
-                    break;
-                  case 645:
-                  case 646:
-                    /* TODO & FIXME */
-                    return -ENXIO; /* Missing decompressor */
-                    break;
-                 }
-#endif
+
+        /*
+         * Compressed;
+         * the decompressor routines will write the data in planar format
+         * immediately.
+         */
+        if (pdev->vsize == PSZ_VGA && pdev->vframes == 5 && pdev->vsnapshot) {
+                PWC_ERROR("Mode Bayer is not supported for now\n");
+                /* flags |= PWCX_FLAG_BAYER; */
+                return -ENXIO; /* No such device or address: missing decompressor */
+        }
+
+        if (DEVICE_USE_CODEC1(pdev->type)) {
+
+                /* TODO & FIXME */
+                PWC_ERROR("This chipset is not supported for now\n");
+                return -ENXIO; /* No such device or address: missing decompressor */
+
+        } else {
+                pwc_dec23_decompress(pdev, yuv, image, PWCX_FLAG_PLANAR);
         }
         return 0;
 }
 
 
+/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
diff --git a/drivers/media/video/pwc/pwc-uncompress.h b/drivers/media/video/pwc/pwc-uncompress.h
index f75e1b6cbe1..041227f6524 100644
--- a/drivers/media/video/pwc/pwc-uncompress.h
+++ b/drivers/media/video/pwc/pwc-uncompress.h
@@ -1,5 +1,5 @@
 /* (C) 1999-2003 Nemosoft Unv.
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -32,7 +32,7 @@
 
 #include <linux/config.h>
 
-#include "pwc-ioctl.h"
+#include <media/pwc-ioctl.h>
 
 /* from pwc-dec.h */
 #define PWCX_FLAG_PLANAR        0x0001
diff --git a/drivers/media/video/pwc/pwc-v4l.c b/drivers/media/video/pwc/pwc-v4l.c
new file mode 100644
index 00000000000..b7eb3ce3b96
--- /dev/null
+++ b/drivers/media/video/pwc/pwc-v4l.c
@@ -0,0 +1,1202 @@
+/* Linux driver for Philips webcam
+   USB and Video4Linux interface part.
+   (C) 1999-2004 Nemosoft Unv.
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
+
+   NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
+   driver and thus may have bugs that are not present in the original version.
+   Please send bug reports and support requests to <luc@saillard.org>.
+   The decompression routines have been implemented by reverse-engineering the
+   Nemosoft binary pwcx module. Caveat emptor.
+
+   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+*/
+
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/poll.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <asm/io.h>
+
+#include "pwc.h"
+
+static struct v4l2_queryctrl pwc_controls[] = {
+        {
+            .id      = V4L2_CID_BRIGHTNESS,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Brightness",
+            .minimum = 0,
+            .maximum = 128,
+            .step    = 1,
+            .default_value = 64,
+        },
+        {
+            .id      = V4L2_CID_CONTRAST,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Contrast",
+            .minimum = 0,
+            .maximum = 64,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_SATURATION,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Saturation",
+            .minimum = -100,
+            .maximum = 100,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_GAMMA,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Gamma",
+            .minimum = 0,
+            .maximum = 32,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_RED_BALANCE,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Red Gain",
+            .minimum = 0,
+            .maximum = 256,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_BLUE_BALANCE,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Blue Gain",
+            .minimum = 0,
+            .maximum = 256,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_AUTO_WHITE_BALANCE,
+            .type    = V4L2_CTRL_TYPE_BOOLEAN,
+            .name    = "Auto White Balance",
+            .minimum = 0,
+            .maximum = 1,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_EXPOSURE,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Shutter Speed (Exposure)",
+            .minimum = 0,
+            .maximum = 256,
+            .step    = 1,
+            .default_value = 200,
+        },
+        {
+            .id      = V4L2_CID_AUTOGAIN,
+            .type    = V4L2_CTRL_TYPE_BOOLEAN,
+            .name    = "Auto Gain Enabled",
+            .minimum = 0,
+            .maximum = 1,
+            .step    = 1,
+            .default_value = 1,
+        },
+        {
+            .id      = V4L2_CID_GAIN,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Gain Level",
+            .minimum = 0,
+            .maximum = 256,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_PRIVATE_SAVE_USER,
+            .type    = V4L2_CTRL_TYPE_BUTTON,
+            .name    = "Save User Settings",
+            .minimum = 0,
+            .maximum = 0,
+            .step    = 0,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_PRIVATE_RESTORE_USER,
+            .type    = V4L2_CTRL_TYPE_BUTTON,
+            .name    = "Restore User Settings",
+            .minimum = 0,
+            .maximum = 0,
+            .step    = 0,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_PRIVATE_RESTORE_FACTORY,
+            .type    = V4L2_CTRL_TYPE_BUTTON,
+            .name    = "Restore Factory Settings",
+            .minimum = 0,
+            .maximum = 0,
+            .step    = 0,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_PRIVATE_COLOUR_MODE,
+            .type    = V4L2_CTRL_TYPE_BOOLEAN,
+            .name    = "Colour mode",
+            .minimum = 0,
+            .maximum = 1,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_PRIVATE_AUTOCONTOUR,
+            .type    = V4L2_CTRL_TYPE_BOOLEAN,
+            .name    = "Auto contour",
+            .minimum = 0,
+            .maximum = 1,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_PRIVATE_CONTOUR,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Contour",
+            .minimum = 0,
+            .maximum = 63,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_PRIVATE_BACKLIGHT,
+            .type    = V4L2_CTRL_TYPE_BOOLEAN,
+            .name    = "Backlight compensation",
+            .minimum = 0,
+            .maximum = 1,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+          .id      = V4L2_CID_PRIVATE_FLICKERLESS,
+            .type    = V4L2_CTRL_TYPE_BOOLEAN,
+            .name    = "Flickerless",
+            .minimum = 0,
+            .maximum = 1,
+            .step    = 1,
+            .default_value = 0,
+        },
+        {
+            .id      = V4L2_CID_PRIVATE_NOISE_REDUCTION,
+            .type    = V4L2_CTRL_TYPE_INTEGER,
+            .name    = "Noise reduction",
+            .minimum = 0,
+            .maximum = 3,
+            .step    = 1,
+            .default_value = 0,
+        },
+};
+
+
+static void pwc_vidioc_fill_fmt(const struct pwc_device *pdev, struct v4l2_format *f)
+{
+        memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
+        f->fmt.pix.width        = pdev->view.x;
+        f->fmt.pix.height       = pdev->view.y;
+        f->fmt.pix.field        = V4L2_FIELD_NONE;
+        if (pdev->vpalette == VIDEO_PALETTE_YUV420P) {
+                f->fmt.pix.pixelformat  = V4L2_PIX_FMT_YUV420;
+                f->fmt.pix.bytesperline = (f->fmt.pix.width * 3)/2;
+                f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
+        } else {
+                /* vbandlength contains 4 lines ...  */
+                f->fmt.pix.bytesperline = pdev->vbandlength/4;
+                f->fmt.pix.sizeimage = pdev->frame_size + sizeof(struct pwc_raw_frame);
+                if (DEVICE_USE_CODEC1(pdev->type))
+                        f->fmt.pix.pixelformat  = V4L2_PIX_FMT_PWC1;
+                else
+                        f->fmt.pix.pixelformat  = V4L2_PIX_FMT_PWC2;
+        }
+        PWC_DEBUG_IOCTL("pwc_vidioc_fill_fmt() "
+                        "width=%d, height=%d, bytesperline=%d, sizeimage=%d, pixelformat=%c%c%c%c\n",
+                        f->fmt.pix.width,
+                        f->fmt.pix.height,
+                        f->fmt.pix.bytesperline,
+                        f->fmt.pix.sizeimage,
+                        (f->fmt.pix.pixelformat)&255,
+                        (f->fmt.pix.pixelformat>>8)&255,
+                        (f->fmt.pix.pixelformat>>16)&255,
+                        (f->fmt.pix.pixelformat>>24)&255);
+}
+
+/* ioctl(VIDIOC_TRY_FMT) */
+static int pwc_vidioc_try_fmt(struct pwc_device *pdev, struct v4l2_format *f)
+{
+        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                PWC_DEBUG_IOCTL("Bad video type must be V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
+                return -EINVAL;
+        }
+
+        switch (f->fmt.pix.pixelformat) {
+                case V4L2_PIX_FMT_YUV420:
+                        break;
+                case V4L2_PIX_FMT_PWC1:
+                        if (DEVICE_USE_CODEC23(pdev->type)) {
+                                PWC_DEBUG_IOCTL("codec1 is only supported for old pwc webcam\n");
+                                return -EINVAL;
+                        }
+                        break;
+                case V4L2_PIX_FMT_PWC2:
+                        if (DEVICE_USE_CODEC1(pdev->type)) {
+                                PWC_DEBUG_IOCTL("codec23 is only supported for new pwc webcam\n");
+                                return -EINVAL;
+                        }
+                        break;
+                default:
+                        PWC_DEBUG_IOCTL("Unsupported pixel format\n");
+                        return -EINVAL;
+
+        }
+
+        if (f->fmt.pix.width > pdev->view_max.x)
+                f->fmt.pix.width = pdev->view_max.x;
+        else if (f->fmt.pix.width < pdev->view_min.x)
+                f->fmt.pix.width = pdev->view_min.x;
+
+        if (f->fmt.pix.height > pdev->view_max.y)
+                f->fmt.pix.height = pdev->view_max.y;
+        else if (f->fmt.pix.height < pdev->view_min.y)
+                f->fmt.pix.height = pdev->view_min.y;
+
+        return 0;
+}
+
+/* ioctl(VIDIOC_SET_FMT) */
+static int pwc_vidioc_set_fmt(struct pwc_device *pdev, struct v4l2_format *f)
+{
+        int ret, fps, snapshot, compression, pixelformat;
+
+        ret = pwc_vidioc_try_fmt(pdev, f);
+        if (ret<0)
+                return ret;
+
+        pixelformat = f->fmt.pix.pixelformat;
+        compression = pdev->vcompression;
+        snapshot = 0;
+        fps = pdev->vframes;
+        if (f->fmt.pix.priv) {
+                compression = (f->fmt.pix.priv & PWC_QLT_MASK) >> PWC_QLT_SHIFT;
+                snapshot = !!(f->fmt.pix.priv & PWC_FPS_SNAPSHOT);
+                fps = (f->fmt.pix.priv & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
+                if (fps == 0)
+                        fps = pdev->vframes;
+        }
+
+        if (pixelformat == V4L2_PIX_FMT_YUV420)
+                pdev->vpalette = VIDEO_PALETTE_YUV420P;
+        else
+                pdev->vpalette = VIDEO_PALETTE_RAW;
+
+        PWC_DEBUG_IOCTL("Try to change format to: width=%d height=%d fps=%d "
+                        "compression=%d snapshot=%d format=%c%c%c%c\n",
+                        f->fmt.pix.width, f->fmt.pix.height, fps,
+                        compression, snapshot,
+                        (pixelformat)&255,
+                        (pixelformat>>8)&255,
+                        (pixelformat>>16)&255,
+                        (pixelformat>>24)&255);
+
+        ret = pwc_try_video_mode(pdev,
+                                 f->fmt.pix.width,
+                                 f->fmt.pix.height,
+                                 fps,
+                                 compression,
+                                 snapshot);
+
+        PWC_DEBUG_IOCTL("pwc_try_video_mode(), return=%d\n", ret);
+
+        if (ret)
+                return ret;
+
+        pwc_vidioc_fill_fmt(pdev, f);
+
+        return 0;
+
+}
+
+int pwc_video_do_ioctl(struct inode *inode, struct file *file,
+                       unsigned int cmd, void *arg)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct pwc_device *pdev;
+        DECLARE_WAITQUEUE(wait, current);
+
+        if (vdev == NULL)
+                return -EFAULT;
+        pdev = vdev->priv;
+        if (pdev == NULL)
+                return -EFAULT;
+
+#if CONFIG_PWC_DEBUG
+        if (PWC_DEBUG_LEVEL_IOCTL & pwc_trace)
+                v4l_printk_ioctl(cmd);
+#endif
+
+
+        switch (cmd) {
+                /* Query cabapilities */
+                case VIDIOCGCAP:
+                {
+                        struct video_capability *caps = arg;
+
+                        strcpy(caps->name, vdev->name);
+                        caps->type = VID_TYPE_CAPTURE;
+                        caps->channels = 1;
+                        caps->audios = 1;
+                        caps->minwidth  = pdev->view_min.x;
+                        caps->minheight = pdev->view_min.y;
+                        caps->maxwidth  = pdev->view_max.x;
+                        caps->maxheight = pdev->view_max.y;
+                        break;
+                }
+
+                /* Channel functions (simulate 1 channel) */
+                case VIDIOCGCHAN:
+                {
+                        struct video_channel *v = arg;
+
+                        if (v->channel != 0)
+                                return -EINVAL;
+                        v->flags = 0;
+                        v->tuners = 0;
+                        v->type = VIDEO_TYPE_CAMERA;
+                        strcpy(v->name, "Webcam");
+                        return 0;
+                }
+
+                case VIDIOCSCHAN:
+                {
+                        /* The spec says the argument is an integer, but
+                           the bttv driver uses a video_channel arg, which
+                           makes sense becasue it also has the norm flag.
+                         */
+                        struct video_channel *v = arg;
+                        if (v->channel != 0)
+                                return -EINVAL;
+                        return 0;
+                }
+
+
+                /* Picture functions; contrast etc. */
+                case VIDIOCGPICT:
+                {
+                        struct video_picture *p = arg;
+                        int val;
+
+                        val = pwc_get_brightness(pdev);
+                        if (val >= 0)
+                                p->brightness = (val<<9);
+                        else
+                                p->brightness = 0xffff;
+                        val = pwc_get_contrast(pdev);
+                        if (val >= 0)
+                                p->contrast = (val<<10);
+                        else
+                                p->contrast = 0xffff;
+                        /* Gamma, Whiteness, what's the difference? :) */
+                        val = pwc_get_gamma(pdev);
+                        if (val >= 0)
+                                p->whiteness = (val<<11);
+                        else
+                                p->whiteness = 0xffff;
+                        if (pwc_get_saturation(pdev, &val)<0)
+                                p->colour = 0xffff;
+                        else
+                                p->colour = 32768 + val * 327;
+                        p->depth = 24;
+                        p->palette = pdev->vpalette;
+                        p->hue = 0xFFFF; /* N/A */
+                        break;
+                }
+
+                case VIDIOCSPICT:
+                {
+                        struct video_picture *p = arg;
+                        /*
+                         *      FIXME:  Suppose we are mid read
+                                ANSWER: No problem: the firmware of the camera
+                                        can handle brightness/contrast/etc
+                                        changes at _any_ time, and the palette
+                                        is used exactly once in the uncompress
+                                        routine.
+                         */
+                        pwc_set_brightness(pdev, p->brightness);
+                        pwc_set_contrast(pdev, p->contrast);
+                        pwc_set_gamma(pdev, p->whiteness);
+                        pwc_set_saturation(pdev, (p->colour-32768)/327);
+                        if (p->palette && p->palette != pdev->vpalette) {
+                                switch (p->palette) {
+                                        case VIDEO_PALETTE_YUV420P:
+                                        case VIDEO_PALETTE_RAW:
+                                                pdev->vpalette = p->palette;
+                                                return pwc_try_video_mode(pdev, pdev->image.x, pdev->image.y, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
+                                                break;
+                                        default:
+                                                return -EINVAL;
+                                                break;
+                                }
+                        }
+                        break;
+                }
+
+                /* Window/size parameters */
+                case VIDIOCGWIN:
+                {
+                        struct video_window *vw = arg;
+
+                        vw->x = 0;
+                        vw->y = 0;
+                        vw->width = pdev->view.x;
+                        vw->height = pdev->view.y;
+                        vw->chromakey = 0;
+                        vw->flags = (pdev->vframes << PWC_FPS_SHIFT) |
+                                   (pdev->vsnapshot ? PWC_FPS_SNAPSHOT : 0);
+                        break;
+                }
+
+                case VIDIOCSWIN:
+                {
+                        struct video_window *vw = arg;
+                        int fps, snapshot, ret;
+
+                        fps = (vw->flags & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
+                        snapshot = vw->flags & PWC_FPS_SNAPSHOT;
+                        if (fps == 0)
+                                fps = pdev->vframes;
+                        if (pdev->view.x == vw->width && pdev->view.y && fps == pdev->vframes && snapshot == pdev->vsnapshot)
+                                return 0;
+                        ret = pwc_try_video_mode(pdev, vw->width, vw->height, fps, pdev->vcompression, snapshot);
+                        if (ret)
+                                return ret;
+                        break;
+                }
+
+                /* We don't have overlay support (yet) */
+                case VIDIOCGFBUF:
+                {
+                        struct video_buffer *vb = arg;
+
+                        memset(vb,0,sizeof(*vb));
+                        break;
+                }
+
+                /* mmap() functions */
+                case VIDIOCGMBUF:
+                {
+                        /* Tell the user program how much memory is needed for a mmap() */
+                        struct video_mbuf *vm = arg;
+                        int i;
+
+                        memset(vm, 0, sizeof(*vm));
+                        vm->size = pwc_mbufs * pdev->len_per_image;
+                        vm->frames = pwc_mbufs; /* double buffering should be enough for most applications */
+                        for (i = 0; i < pwc_mbufs; i++)
+                                vm->offsets[i] = i * pdev->len_per_image;
+                        break;
+                }
+
+                case VIDIOCMCAPTURE:
+                {
+                        /* Start capture into a given image buffer (called 'frame' in video_mmap structure) */
+                        struct video_mmap *vm = arg;
+
+                        PWC_DEBUG_READ("VIDIOCMCAPTURE: %dx%d, frame %d, format %d\n", vm->width, vm->height, vm->frame, vm->format);
+                        if (vm->frame < 0 || vm->frame >= pwc_mbufs)
+                                return -EINVAL;
+
+                        /* xawtv is nasty. It probes the available palettes
+                           by setting a very small image size and trying
+                           various palettes... The driver doesn't support
+                           such small images, so I'm working around it.
+                         */
+                        if (vm->format)
+                        {
+                                switch (vm->format)
+                                {
+                                        case VIDEO_PALETTE_YUV420P:
+                                        case VIDEO_PALETTE_RAW:
+                                                break;
+                                        default:
+                                                return -EINVAL;
+                                                break;
+                                }
+                        }
+
+                        if ((vm->width != pdev->view.x || vm->height != pdev->view.y) &&
+                            (vm->width >= pdev->view_min.x && vm->height >= pdev->view_min.y)) {
+                                int ret;
+
+                                PWC_DEBUG_OPEN("VIDIOCMCAPTURE: changing size to please xawtv :-(.\n");
+                                ret = pwc_try_video_mode(pdev, vm->width, vm->height, pdev->vframes, pdev->vcompression, pdev->vsnapshot);
+                                if (ret)
+                                        return ret;
+                        } /* ... size mismatch */
+
+                        /* FIXME: should we lock here? */
+                        if (pdev->image_used[vm->frame])
+                                return -EBUSY;  /* buffer wasn't available. Bummer */
+                        pdev->image_used[vm->frame] = 1;
+
+                        /* Okay, we're done here. In the SYNC call we wait until a
+                           frame comes available, then expand image into the given
+                           buffer.
+                           In contrast to the CPiA cam the Philips cams deliver a
+                           constant stream, almost like a grabber card. Also,
+                           we have separate buffers for the rawdata and the image,
+                           meaning we can nearly always expand into the requested buffer.
+                         */
+                        PWC_DEBUG_READ("VIDIOCMCAPTURE done.\n");
+                        break;
+                }
+
+                case VIDIOCSYNC:
+                {
+                        /* The doc says: "Whenever a buffer is used it should
+                           call VIDIOCSYNC to free this frame up and continue."
+
+                           The only odd thing about this whole procedure is
+                           that MCAPTURE flags the buffer as "in use", and
+                           SYNC immediately unmarks it, while it isn't
+                           after SYNC that you know that the buffer actually
+                           got filled! So you better not start a CAPTURE in
+                           the same frame immediately (use double buffering).
+                           This is not a problem for this cam, since it has
+                           extra intermediate buffers, but a hardware
+                           grabber card will then overwrite the buffer
+                           you're working on.
+                         */
+                        int *mbuf = arg;
+                        int ret;
+
+                        PWC_DEBUG_READ("VIDIOCSYNC called (%d).\n", *mbuf);
+
+                        /* bounds check */
+                        if (*mbuf < 0 || *mbuf >= pwc_mbufs)
+                                return -EINVAL;
+                        /* check if this buffer was requested anyway */
+                        if (pdev->image_used[*mbuf] == 0)
+                                return -EINVAL;
+
+                        /* Add ourselves to the frame wait-queue.
+
+                           FIXME: needs auditing for safety.
+                           QUESTION: In what respect? I think that using the
+                                     frameq is safe now.
+                         */
+                        add_wait_queue(&pdev->frameq, &wait);
+                        while (pdev->full_frames == NULL) {
+                                /* Check for unplugged/etc. here */
+                                if (pdev->error_status) {
+                                        remove_wait_queue(&pdev->frameq, &wait);
+                                        set_current_state(TASK_RUNNING);
+                                        return -pdev->error_status;
+                                }
+
+                                if (signal_pending(current)) {
+                                        remove_wait_queue(&pdev->frameq, &wait);
+                                        set_current_state(TASK_RUNNING);
+                                        return -ERESTARTSYS;
+                                }
+                                schedule();
+                                set_current_state(TASK_INTERRUPTIBLE);
+                        }
+                        remove_wait_queue(&pdev->frameq, &wait);
+                        set_current_state(TASK_RUNNING);
+
+                        /* The frame is ready. Expand in the image buffer
+                           requested by the user. I don't care if you
+                           mmap() 5 buffers and request data in this order:
+                           buffer 4 2 3 0 1 2 3 0 4 3 1 . . .
+                           Grabber hardware may not be so forgiving.
+                         */
+                        PWC_DEBUG_READ("VIDIOCSYNC: frame ready.\n");
+                        pdev->fill_image = *mbuf; /* tell in which buffer we want the image to be expanded */
+                        /* Decompress, etc */
+                        ret = pwc_handle_frame(pdev);
+                        pdev->image_used[*mbuf] = 0;
+                        if (ret)
+                                return -EFAULT;
+                        break;
+                }
+
+                case VIDIOCGAUDIO:
+                {
+                        struct video_audio *v = arg;
+
+                        strcpy(v->name, "Microphone");
+                        v->audio = -1; /* unknown audio minor */
+                        v->flags = 0;
+                        v->mode = VIDEO_SOUND_MONO;
+                        v->volume = 0;
+                        v->bass = 0;
+                        v->treble = 0;
+                        v->balance = 0x8000;
+                        v->step = 1;
+                        break;
+                }
+
+                case VIDIOCSAUDIO:
+                {
+                        /* Dummy: nothing can be set */
+                        break;
+                }
+
+                case VIDIOCGUNIT:
+                {
+                        struct video_unit *vu = arg;
+
+                        vu->video = pdev->vdev->minor & 0x3F;
+                        vu->audio = -1; /* not known yet */
+                        vu->vbi = -1;
+                        vu->radio = -1;
+                        vu->teletext = -1;
+                        break;
+                }
+
+                /* V4L2 Layer */
+                case VIDIOC_QUERYCAP:
+                {
+                    struct v4l2_capability *cap = arg;
+
+                    PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCAP) This application "\
+                                       "try to use the v4l2 layer\n");
+                    strcpy(cap->driver,PWC_NAME);
+                    strlcpy(cap->card, vdev->name, sizeof(cap->card));
+                    usb_make_path(pdev->udev,cap->bus_info,sizeof(cap->bus_info));
+                    cap->version = PWC_VERSION_CODE;
+                    cap->capabilities =
+                        V4L2_CAP_VIDEO_CAPTURE  |
+                        V4L2_CAP_STREAMING      |
+                        V4L2_CAP_READWRITE;
+                    return 0;
+                }
+
+                case VIDIOC_ENUMINPUT:
+                {
+                    struct v4l2_input *i = arg;
+
+                    if ( i->index )     /* Only one INPUT is supported */
+                          return -EINVAL;
+
+                    memset(i, 0, sizeof(struct v4l2_input));
+                    strcpy(i->name, "usb");
+                    return 0;
+                }
+
+                case VIDIOC_G_INPUT:
+                {
+                    int *i = arg;
+                    *i = 0;     /* Only one INPUT is supported */
+                    return 0;
+                }
+                case VIDIOC_S_INPUT:
+                {
+                        int *i = arg;
+
+                        if ( *i ) {     /* Only one INPUT is supported */
+                                PWC_DEBUG_IOCTL("Only one input source is"\
+                                        " supported with this webcam.\n");
+                                return -EINVAL;
+                        }
+                        return 0;
+                }
+
+                /* TODO: */
+                case VIDIOC_QUERYCTRL:
+                {
+                        struct v4l2_queryctrl *c = arg;
+                        int i;
+
+                        PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) query id=%d\n", c->id);
+                        for (i=0; i<sizeof(pwc_controls)/sizeof(struct v4l2_queryctrl); i++) {
+                                if (pwc_controls[i].id == c->id) {
+                                        PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) found\n");
+                                        memcpy(c,&pwc_controls[i],sizeof(struct v4l2_queryctrl));
+                                        return 0;
+                                }
+                        }
+                        PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) not found\n");
+
+                        return -EINVAL;
+                }
+                case VIDIOC_G_CTRL:
+                {
+                        struct v4l2_control *c = arg;
+                        int ret;
+
+                        switch (c->id)
+                        {
+                                case V4L2_CID_BRIGHTNESS:
+                                        c->value = pwc_get_brightness(pdev);
+                                        if (c->value<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_CONTRAST:
+                                        c->value = pwc_get_contrast(pdev);
+                                        if (c->value<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_SATURATION:
+                                        ret = pwc_get_saturation(pdev, &c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_GAMMA:
+                                        c->value = pwc_get_gamma(pdev);
+                                        if (c->value<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_RED_BALANCE:
+                                        ret = pwc_get_red_gain(pdev, &c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        c->value >>= 8;
+                                        return 0;
+                                case V4L2_CID_BLUE_BALANCE:
+                                        ret = pwc_get_blue_gain(pdev, &c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        c->value >>= 8;
+                                        return 0;
+                                case V4L2_CID_AUTO_WHITE_BALANCE:
+                                        ret = pwc_get_awb(pdev);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        c->value = (ret == PWC_WB_MANUAL)?0:1;
+                                        return 0;
+                                case V4L2_CID_GAIN:
+                                        ret = pwc_get_agc(pdev, &c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        c->value >>= 8;
+                                        return 0;
+                                case V4L2_CID_AUTOGAIN:
+                                        ret = pwc_get_agc(pdev, &c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        c->value = (c->value < 0)?1:0;
+                                        return 0;
+                                case V4L2_CID_EXPOSURE:
+                                        ret = pwc_get_shutter_speed(pdev, &c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_COLOUR_MODE:
+                                        ret = pwc_get_colour_mode(pdev, &c->value);
+                                        if (ret < 0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_AUTOCONTOUR:
+                                        ret = pwc_get_contour(pdev, &c->value);
+                                        if (ret < 0)
+                                                return -EINVAL;
+                                        c->value=(c->value == -1?1:0);
+                                        return 0;
+                                case V4L2_CID_PRIVATE_CONTOUR:
+                                        ret = pwc_get_contour(pdev, &c->value);
+                                        if (ret < 0)
+                                                return -EINVAL;
+                                        c->value >>= 10;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_BACKLIGHT:
+                                        ret = pwc_get_backlight(pdev, &c->value);
+                                        if (ret < 0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_FLICKERLESS:
+                                        ret = pwc_get_flicker(pdev, &c->value);
+                                        if (ret < 0)
+                                                return -EINVAL;
+                                        c->value=(c->value?1:0);
+                                        return 0;
+                                case V4L2_CID_PRIVATE_NOISE_REDUCTION:
+                                        ret = pwc_get_dynamic_noise(pdev, &c->value);
+                                        if (ret < 0)
+                                                return -EINVAL;
+                                        return 0;
+
+                                case V4L2_CID_PRIVATE_SAVE_USER:
+                                case V4L2_CID_PRIVATE_RESTORE_USER:
+                                case V4L2_CID_PRIVATE_RESTORE_FACTORY:
+                                        return -EINVAL;
+                        }
+                        return -EINVAL;
+                }
+                case VIDIOC_S_CTRL:
+                {
+                        struct v4l2_control *c = arg;
+                        int ret;
+
+                        switch (c->id)
+                        {
+                                case V4L2_CID_BRIGHTNESS:
+                                        c->value <<= 9;
+                                        ret = pwc_set_brightness(pdev, c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_CONTRAST:
+                                        c->value <<= 10;
+                                        ret = pwc_set_contrast(pdev, c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_SATURATION:
+                                        ret = pwc_set_saturation(pdev, c->value);
+                                        if (ret<0)
+                                          return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_GAMMA:
+                                        c->value <<= 11;
+                                        ret = pwc_set_gamma(pdev, c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_RED_BALANCE:
+                                        c->value <<= 8;
+                                        ret = pwc_set_red_gain(pdev, c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_BLUE_BALANCE:
+                                        c->value <<= 8;
+                                        ret = pwc_set_blue_gain(pdev, c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_AUTO_WHITE_BALANCE:
+                                        c->value = (c->value == 0)?PWC_WB_MANUAL:PWC_WB_AUTO;
+                                        ret = pwc_set_awb(pdev, c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_EXPOSURE:
+                                        c->value <<= 8;
+                                        ret = pwc_set_shutter_speed(pdev, c->value?0:1, c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_AUTOGAIN:
+                                        /* autogain off means nothing without a gain */
+                                        if (c->value == 0)
+                                                return 0;
+                                        ret = pwc_set_agc(pdev, c->value, 0);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_GAIN:
+                                        c->value <<= 8;
+                                        ret = pwc_set_agc(pdev, 0, c->value);
+                                        if (ret<0)
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_SAVE_USER:
+                                        if (pwc_save_user(pdev))
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_RESTORE_USER:
+                                        if (pwc_restore_user(pdev))
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_RESTORE_FACTORY:
+                                        if (pwc_restore_factory(pdev))
+                                                return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_COLOUR_MODE:
+                                        ret = pwc_set_colour_mode(pdev, c->value);
+                                        if (ret < 0)
+                                          return -EINVAL;
+                                        return 0;
+                                case V4L2_CID_PRIVATE_AUTOCONTOUR:
+                                  c->value=(c->value == 1)?-1:0;
+                                  ret = pwc_set_contour(pdev, c->value);
+                                  if (ret < 0)
+                                    return -EINVAL;
+                                  return 0;
+                                case V4L2_CID_PRIVATE_CONTOUR:
+                                  c->value <<= 10;
+                                  ret = pwc_set_contour(pdev, c->value);
+                                  if (ret < 0)
+                                    return -EINVAL;
+                                  return 0;
+                                case V4L2_CID_PRIVATE_BACKLIGHT:
+                                  ret = pwc_set_backlight(pdev, c->value);
+                                  if (ret < 0)
+                                    return -EINVAL;
+                                  return 0;
+                                case V4L2_CID_PRIVATE_FLICKERLESS:
+                                  ret = pwc_set_flicker(pdev, c->value);
+                                  if (ret < 0)
+                                    return -EINVAL;
+                                case V4L2_CID_PRIVATE_NOISE_REDUCTION:
+                                  ret = pwc_set_dynamic_noise(pdev, c->value);
+                                  if (ret < 0)
+                                    return -EINVAL;
+                                  return 0;
+
+                        }
+                        return -EINVAL;
+                }
+
+                case VIDIOC_ENUM_FMT:
+                {
+                        struct v4l2_fmtdesc *f = arg;
+                        int index;
+
+                        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                              return -EINVAL;
+
+                        /* We only support two format: the raw format, and YUV */
+                        index = f->index;
+                        memset(f,0,sizeof(struct v4l2_fmtdesc));
+                        f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                        f->index = index;
+                        switch(index)
+                        {
+                                case 0:
+                                        /* RAW format */
+                                        f->pixelformat = pdev->type<=646?V4L2_PIX_FMT_PWC1:V4L2_PIX_FMT_PWC2;
+                                        f->flags = V4L2_FMT_FLAG_COMPRESSED;
+                                        strlcpy(f->description,"Raw Philips Webcam",sizeof(f->description));
+                                        break;
+                                case 1:
+                                        f->pixelformat = V4L2_PIX_FMT_YUV420;
+                                        strlcpy(f->description,"4:2:0, planar, Y-Cb-Cr",sizeof(f->description));
+                                        break;
+                                default:
+                                        return -EINVAL;
+                        }
+                        return 0;
+                }
+
+                case VIDIOC_G_FMT:
+                {
+                        struct v4l2_format *f = arg;
+
+                        PWC_DEBUG_IOCTL("ioctl(VIDIOC_G_FMT) return size %dx%d\n",pdev->image.x,pdev->image.y);
+                        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                              return -EINVAL;
+
+                        pwc_vidioc_fill_fmt(pdev, f);
+
+                        return 0;
+                }
+
+                case VIDIOC_TRY_FMT:
+                        return pwc_vidioc_try_fmt(pdev, arg);
+
+                case VIDIOC_S_FMT:
+                        return pwc_vidioc_set_fmt(pdev, arg);
+
+                case VIDIOC_G_STD:
+                {
+                        v4l2_std_id *std = arg;
+                        *std = V4L2_STD_UNKNOWN;
+                        return 0;
+                }
+
+                case VIDIOC_S_STD:
+                {
+                        v4l2_std_id *std = arg;
+                        if (*std != V4L2_STD_UNKNOWN)
+                                return -EINVAL;
+                        return 0;
+                }
+
+                case VIDIOC_ENUMSTD:
+                {
+                        struct v4l2_standard *std = arg;
+                        if (std->index != 0)
+                                return -EINVAL;
+                        std->id = V4L2_STD_UNKNOWN;
+                        strncpy(std->name, "webcam", sizeof(std->name));
+                        return 0;
+                }
+
+                case VIDIOC_REQBUFS:
+                {
+                        struct v4l2_requestbuffers *rb = arg;
+                        int nbuffers;
+
+                        PWC_DEBUG_IOCTL("ioctl(VIDIOC_REQBUFS) count=%d\n",rb->count);
+                        if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                                return -EINVAL;
+                        if (rb->memory != V4L2_MEMORY_MMAP)
+                                return -EINVAL;
+
+                        nbuffers = rb->count;
+                        if (nbuffers < 2)
+                                nbuffers = 2;
+                        else if (nbuffers > pwc_mbufs)
+                                nbuffers = pwc_mbufs;
+                        /* Force to use our # of buffers */
+                        rb->count = pwc_mbufs;
+                        return 0;
+                }
+
+                case VIDIOC_QUERYBUF:
+                {
+                        struct v4l2_buffer *buf = arg;
+                        int index;
+
+                        PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) index=%d\n",buf->index);
+                        if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+                                PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad type\n");
+                                return -EINVAL;
+                        }
+                        if (buf->memory != V4L2_MEMORY_MMAP) {
+                                PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad memory type\n");
+                                return -EINVAL;
+                        }
+                        index = buf->index;
+                        if (index < 0 || index >= pwc_mbufs) {
+                                PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad index %d\n", buf->index);
+                                return -EINVAL;
+                        }
+
+                        memset(buf, 0, sizeof(struct v4l2_buffer));
+                        buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                        buf->index = index;
+                        buf->m.offset = index * pdev->len_per_image;
+                        if (pdev->vpalette == VIDEO_PALETTE_RAW)
+                                buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
+                        else
+                                buf->bytesused = pdev->view.size;
+                        buf->field = V4L2_FIELD_NONE;
+                        buf->memory = V4L2_MEMORY_MMAP;
+                        //buf->flags = V4L2_BUF_FLAG_MAPPED;
+                        buf->length = pdev->len_per_image;
+
+                        PWC_DEBUG_READ("VIDIOC_QUERYBUF: index=%d\n",buf->index);
+                        PWC_DEBUG_READ("VIDIOC_QUERYBUF: m.offset=%d\n",buf->m.offset);
+                        PWC_DEBUG_READ("VIDIOC_QUERYBUF: bytesused=%d\n",buf->bytesused);
+
+                        return 0;
+                }
+
+                case VIDIOC_QBUF:
+                {
+                        struct v4l2_buffer *buf = arg;
+
+                        PWC_DEBUG_IOCTL("ioctl(VIDIOC_QBUF) index=%d\n",buf->index);
+                        if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                                return -EINVAL;
+                        if (buf->memory != V4L2_MEMORY_MMAP)
+                                return -EINVAL;
+                        if (buf->index < 0 || buf->index >= pwc_mbufs)
+                                return -EINVAL;
+
+                        buf->flags |= V4L2_BUF_FLAG_QUEUED;
+                        buf->flags &= ~V4L2_BUF_FLAG_DONE;
+
+                        return 0;
+                }
+
+                case VIDIOC_DQBUF:
+                {
+                        struct v4l2_buffer *buf = arg;
+                        int ret;
+
+                        PWC_DEBUG_IOCTL("ioctl(VIDIOC_DQBUF)\n");
+
+                        if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                                return -EINVAL;
+
+                        /* Add ourselves to the frame wait-queue.
+
+                           FIXME: needs auditing for safety.
+                           QUESTION: In what respect? I think that using the
+                                     frameq is safe now.
+                         */
+                        add_wait_queue(&pdev->frameq, &wait);
+                        while (pdev->full_frames == NULL) {
+                                if (pdev->error_status) {
+                                        remove_wait_queue(&pdev->frameq, &wait);
+                                        set_current_state(TASK_RUNNING);
+                                        return -pdev->error_status;
+                                }
+
+                                if (signal_pending(current)) {
+                                        remove_wait_queue(&pdev->frameq, &wait);
+                                        set_current_state(TASK_RUNNING);
+                                        return -ERESTARTSYS;
+                                }
+                                schedule();
+                                set_current_state(TASK_INTERRUPTIBLE);
+                        }
+                        remove_wait_queue(&pdev->frameq, &wait);
+                        set_current_state(TASK_RUNNING);
+
+                        PWC_DEBUG_IOCTL("VIDIOC_DQBUF: frame ready.\n");
+                        /* Decompress data in pdev->images[pdev->fill_image] */
+                        ret = pwc_handle_frame(pdev);
+                        if (ret)
+                                return -EFAULT;
+                        PWC_DEBUG_IOCTL("VIDIOC_DQBUF: after pwc_handle_frame\n");
+
+                        buf->index = pdev->fill_image;
+                        if (pdev->vpalette == VIDEO_PALETTE_RAW)
+                                buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
+                        else
+                                buf->bytesused = pdev->view.size;
+                        buf->flags = V4L2_BUF_FLAG_MAPPED;
+                        buf->field = V4L2_FIELD_NONE;
+                        do_gettimeofday(&buf->timestamp);
+                        buf->sequence = 0;
+                        buf->memory = V4L2_MEMORY_MMAP;
+                        buf->m.offset = pdev->fill_image * pdev->len_per_image;
+                        buf->length = buf->bytesused;
+                        pwc_next_image(pdev);
+
+                        PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->index=%d\n",buf->index);
+                        PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->length=%d\n",buf->length);
+                        PWC_DEBUG_IOCTL("VIDIOC_DQBUF: m.offset=%d\n",buf->m.offset);
+                        PWC_DEBUG_IOCTL("VIDIOC_DQBUF: bytesused=%d\n",buf->bytesused);
+                        PWC_DEBUG_IOCTL("VIDIOC_DQBUF: leaving\n");
+                        return 0;
+
+                }
+
+                case VIDIOC_STREAMON:
+                {
+                        /* WARNING: pwc_try_video_mode() called pwc_isoc_init */
+                        pwc_isoc_init(pdev);
+                        return 0;
+                }
+
+                case VIDIOC_STREAMOFF:
+                {
+                        pwc_isoc_cleanup(pdev);
+                        return 0;
+                }
+
+                default:
+                        return pwc_ioctl(pdev, cmd, arg);
+        } /* ..switch */
+        return 0;
+}
+
+/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
diff --git a/drivers/media/video/pwc/pwc.h b/drivers/media/video/pwc/pwc.h
index 1b0ee0ced0e..629f79e44fb 100644
--- a/drivers/media/video/pwc/pwc.h
+++ b/drivers/media/video/pwc/pwc.h
@@ -1,5 +1,5 @@
 /* (C) 1999-2003 Nemosoft Unv.
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -29,51 +29,87 @@
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/spinlock.h>
-#include <linux/videodev.h>
 #include <linux/wait.h>
 #include <linux/smp_lock.h>
+#include <linux/version.h>
 #include <asm/semaphore.h>
 #include <asm/errno.h>
+#include <linux/videodev.h>
+#include <media/v4l2-common.h>
 
 #include "pwc-uncompress.h"
-#include "pwc-ioctl.h"
-
-/* Defines and structures for the Philips webcam */
-/* Used for checking memory corruption/pointer validation */
-#define PWC_MAGIC 0x89DC10ABUL
-#undef PWC_MAGIC
+#include <media/pwc-ioctl.h>
 
 /* Turn some debugging options on/off */
-#define PWC_DEBUG 0
+#ifndef CONFIG_PWC_DEBUG
+#define CONFIG_PWC_DEBUG 1
+#endif
+
+/* Version block */
+#define PWC_MAJOR       10
+#define PWC_MINOR       0
+#define PWC_EXTRAMINOR  12
+#define PWC_VERSION_CODE KERNEL_VERSION(PWC_MAJOR,PWC_MINOR,PWC_EXTRAMINOR)
+#define PWC_VERSION     "10.0.12"
+#define PWC_NAME        "pwc"
+#define PFX             PWC_NAME ": "
+
 
 /* Trace certain actions in the driver */
-#define TRACE_MODULE    0x0001
-#define TRACE_PROBE     0x0002
-#define TRACE_OPEN      0x0004
-#define TRACE_READ      0x0008
-#define TRACE_MEMORY    0x0010
-#define TRACE_FLOW      0x0020
-#define TRACE_SIZE      0x0040
-#define TRACE_PWCX      0x0080
-#define TRACE_SEQUENCE  0x1000
-
-#define Trace(R, A...) if (pwc_trace & R) printk(KERN_DEBUG PWC_NAME " " A)
-#define Debug(A...) printk(KERN_DEBUG PWC_NAME " " A)
-#define Info(A...)  printk(KERN_INFO  PWC_NAME " " A)
-#define Err(A...)   printk(KERN_ERR   PWC_NAME " " A)
+#define PWC_DEBUG_LEVEL_MODULE  (1<<0)
+#define PWC_DEBUG_LEVEL_PROBE   (1<<1)
+#define PWC_DEBUG_LEVEL_OPEN    (1<<2)
+#define PWC_DEBUG_LEVEL_READ    (1<<3)
+#define PWC_DEBUG_LEVEL_MEMORY  (1<<4)
+#define PWC_DEBUG_LEVEL_FLOW    (1<<5)
+#define PWC_DEBUG_LEVEL_SIZE    (1<<6)
+#define PWC_DEBUG_LEVEL_IOCTL   (1<<7)
+#define PWC_DEBUG_LEVEL_TRACE   (1<<8)
+
+#define PWC_DEBUG_MODULE(fmt, args...) PWC_DEBUG(MODULE, fmt, ##args)
+#define PWC_DEBUG_PROBE(fmt, args...) PWC_DEBUG(PROBE, fmt, ##args)
+#define PWC_DEBUG_OPEN(fmt, args...) PWC_DEBUG(OPEN, fmt, ##args)
+#define PWC_DEBUG_READ(fmt, args...) PWC_DEBUG(READ, fmt, ##args)
+#define PWC_DEBUG_MEMORY(fmt, args...) PWC_DEBUG(MEMORY, fmt, ##args)
+#define PWC_DEBUG_FLOW(fmt, args...) PWC_DEBUG(FLOW, fmt, ##args)
+#define PWC_DEBUG_SIZE(fmt, args...) PWC_DEBUG(SIZE, fmt, ##args)
+#define PWC_DEBUG_IOCTL(fmt, args...) PWC_DEBUG(IOCTL, fmt, ##args)
+#define PWC_DEBUG_TRACE(fmt, args...) PWC_DEBUG(TRACE, fmt, ##args)
+
+
+#if CONFIG_PWC_DEBUG
+
+#define PWC_DEBUG_LEVEL (PWC_DEBUG_LEVEL_MODULE)
+
+#define PWC_DEBUG(level, fmt, args...) do {\
+          if ((PWC_DEBUG_LEVEL_ ##level) & pwc_trace) \
+             printk(KERN_DEBUG PFX fmt, ##args); \
+          } while(0)
+
+#define PWC_ERROR(fmt, args...) printk(KERN_ERR PFX fmt, ##args)
+#define PWC_WARNING(fmt, args...) printk(KERN_WARNING PFX fmt, ##args)
+#define PWC_INFO(fmt, args...) printk(KERN_INFO PFX fmt, ##args)
+#define PWC_TRACE(fmt, args...) PWC_DEBUG(TRACE, fmt, ##args)
+
+#else /* if ! CONFIG_PWC_DEBUG */
+
+#define PWC_ERROR(fmt, args...) printk(KERN_ERR PFX fmt, ##args)
+#define PWC_WARNING(fmt, args...) printk(KERN_WARNING PFX fmt, ##args)
+#define PWC_INFO(fmt, args...) printk(KERN_INFO PFX fmt, ##args)
+#define PWC_TRACE(fmt, args...) do { } while(0)
+#define PWC_DEBUG(level, fmt, args...) do { } while(0)
+
+#define pwc_trace 0
 
+#endif
 
 /* Defines for ToUCam cameras */
 #define TOUCAM_HEADER_SIZE              8
 #define TOUCAM_TRAILER_SIZE             4
 
 #define FEATURE_MOTOR_PANTILT           0x0001
-
-/* Version block */
-#define PWC_MAJOR       9
-#define PWC_MINOR       0
-#define PWC_VERSION     "9.0.2-unofficial"
-#define PWC_NAME        "pwc"
+#define FEATURE_CODEC1                  0x0002
+#define FEATURE_CODEC2                  0x0004
 
 /* Turn certain features on/off */
 #define PWC_INT_PIPE 0
@@ -95,6 +131,18 @@
 /* Absolute maximum number of buffers available for mmap() */
 #define MAX_IMAGES              10
 
+/* Some macros to quickly find the type of a webcam */
+#define DEVICE_USE_CODEC1(x) ((x)<675)
+#define DEVICE_USE_CODEC2(x) ((x)>=675 && (x)<700)
+#define DEVICE_USE_CODEC3(x) ((x)>=700)
+#define DEVICE_USE_CODEC23(x) ((x)>=675)
+
+
+#ifndef V4L2_PIX_FMT_PWC1
+#define V4L2_PIX_FMT_PWC1       v4l2_fourcc('P','W','C','1')
+#define V4L2_PIX_FMT_PWC2       v4l2_fourcc('P','W','C','2')
+#endif
+
 /* The following structures were based on cpia.h. Why reinvent the wheel? :-) */
 struct pwc_iso_buf
 {
@@ -110,17 +158,19 @@ struct pwc_frame_buf
    void *data;
    volatile int filled;         /* number of bytes filled */
    struct pwc_frame_buf *next;  /* list */
-#if PWC_DEBUG
-   int sequence;                /* Sequence number */
-#endif
+};
+
+/* additionnal informations used when dealing image between kernel and userland */
+struct pwc_imgbuf
+{
+        unsigned long offset;   /* offset of this buffer in the big array of image_data */
+        int   vma_use_count;    /* count the number of time this memory is mapped */
 };
 
 struct pwc_device
 {
    struct video_device *vdev;
-#ifdef PWC_MAGIC
-   int magic;
-#endif
+
    /* Pointer to our usb_device */
    struct usb_device *udev;
 
@@ -177,12 +227,8 @@ struct pwc_device
    int frame_size;
    int frame_total_size; /* including header & trailer */
    int drop_frames;
-#if PWC_DEBUG
-   int sequence;                        /* Debugging aid */
-#endif
 
    /* 3: decompression */
-   struct pwc_decompressor *decompressor;       /* function block with decompression routines */
    void *decompress_data;               /* private data for decompression engine */
 
    /* 4: image */
@@ -198,7 +244,7 @@ struct pwc_device
    struct pwc_coord offset;             /* offset within the viewport */
 
    void *image_data;                    /* total buffer, which is subdivided into ... */
-   void *image_ptr[MAX_IMAGES];         /* ...several images... */
+   struct pwc_imgbuf images[MAX_IMAGES];/* ...several images... */
    int fill_image;                      /* ...which are rotated. */
    int len_per_image;                   /* length per image */
    int image_read_pos;                  /* In case we read data in pieces, keep track of were we are in the imagebuffer */
@@ -211,6 +257,7 @@ struct pwc_device
    struct pwc_mpt_range angle_range;
    int pan_angle;                       /* in degrees * 100 */
    int tilt_angle;                      /* absolute angle; 0,0 is home position */
+   int snapshot_button_status;          /* set to 1 when the user push the button, reset to 0 when this value is read */
 
    /*** Misc. data ***/
    wait_queue_head_t frameq;            /* When waiting for a frame to finish... */
@@ -219,20 +266,26 @@ struct pwc_device
 #endif
 };
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/* Global variable */
+/* Global variables */
+#if CONFIG_PWC_DEBUG
 extern int pwc_trace;
+#endif
+extern int pwc_mbufs;
 
 /** functions in pwc-if.c */
 int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_fps, int new_compression, int new_snapshot);
+int pwc_handle_frame(struct pwc_device *pdev);
+void pwc_next_image(struct pwc_device *pdev);
+int pwc_isoc_init(struct pwc_device *pdev);
+void pwc_isoc_cleanup(struct pwc_device *pdev);
 
 /** Functions in pwc-misc.c */
 /* sizes in pixels */
-extern struct pwc_coord pwc_image_sizes[PSZ_MAX];
+extern const struct pwc_coord pwc_image_sizes[PSZ_MAX];
 
 int pwc_decode_size(struct pwc_device *pdev, int width, int height);
 void pwc_construct(struct pwc_device *pdev);
@@ -240,6 +293,9 @@ void pwc_construct(struct pwc_device *pdev);
 /** Functions in pwc-ctrl.c */
 /* Request a certain video mode. Returns < 0 if not possible */
 extern int pwc_set_video_mode(struct pwc_device *pdev, int width, int height, int frames, int compression, int snapshot);
+/* Calculate the number of bytes per image (not frame) */
+extern int pwc_mpt_reset(struct pwc_device *pdev, int flags);
+extern int pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt);
 
 /* Various controls; should be obvious. Value 0..65535, or < 0 on error */
 extern int pwc_get_brightness(struct pwc_device *pdev);
@@ -248,10 +304,36 @@ extern int pwc_get_contrast(struct pwc_device *pdev);
 extern int pwc_set_contrast(struct pwc_device *pdev, int value);
 extern int pwc_get_gamma(struct pwc_device *pdev);
 extern int pwc_set_gamma(struct pwc_device *pdev, int value);
-extern int pwc_get_saturation(struct pwc_device *pdev);
+extern int pwc_get_saturation(struct pwc_device *pdev, int *value);
 extern int pwc_set_saturation(struct pwc_device *pdev, int value);
 extern int pwc_set_leds(struct pwc_device *pdev, int on_value, int off_value);
 extern int pwc_get_cmos_sensor(struct pwc_device *pdev, int *sensor);
+extern int pwc_restore_user(struct pwc_device *pdev);
+extern int pwc_save_user(struct pwc_device *pdev);
+extern int pwc_restore_factory(struct pwc_device *pdev);
+
+/* exported for use by v4l2 controls */
+extern int pwc_get_red_gain(struct pwc_device *pdev, int *value);
+extern int pwc_set_red_gain(struct pwc_device *pdev, int value);
+extern int pwc_get_blue_gain(struct pwc_device *pdev, int *value);
+extern int pwc_set_blue_gain(struct pwc_device *pdev, int value);
+extern int pwc_get_awb(struct pwc_device *pdev);
+extern int pwc_set_awb(struct pwc_device *pdev, int mode);
+extern int pwc_set_agc(struct pwc_device *pdev, int mode, int value);
+extern int pwc_get_agc(struct pwc_device *pdev, int *value);
+extern int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int value);
+extern int pwc_get_shutter_speed(struct pwc_device *pdev, int *value);
+
+extern int pwc_set_colour_mode(struct pwc_device *pdev, int colour);
+extern int pwc_get_colour_mode(struct pwc_device *pdev, int *colour);
+extern int pwc_set_contour(struct pwc_device *pdev, int contour);
+extern int pwc_get_contour(struct pwc_device *pdev, int *contour);
+extern int pwc_set_backlight(struct pwc_device *pdev, int backlight);
+extern int pwc_get_backlight(struct pwc_device *pdev, int *backlight);
+extern int pwc_set_flicker(struct pwc_device *pdev, int flicker);
+extern int pwc_get_flicker(struct pwc_device *pdev, int *flicker);
+extern int pwc_set_dynamic_noise(struct pwc_device *pdev, int noise);
+extern int pwc_get_dynamic_noise(struct pwc_device *pdev, int *noise);
 
 /* Power down or up the camera; not supported by all models */
 extern int pwc_camera_power(struct pwc_device *pdev, int power);
@@ -259,6 +341,9 @@ extern int pwc_camera_power(struct pwc_device *pdev, int power);
 /* Private ioctl()s; see pwc-ioctl.h */
 extern int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg);
 
+/** Functions in pwc-v4l.c */
+extern int pwc_video_do_ioctl(struct inode *inode, struct file *file,
+                              unsigned int cmd, void *arg);
 
 /** pwc-uncompress.c */
 /* Expand frame to image, possibly including decompression. Uses read_frame and fill_image */
@@ -270,3 +355,4 @@ extern int pwc_decompress(struct pwc_device *pdev);
 
 
 #endif
+/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
diff --git a/drivers/media/video/saa5246a.c b/drivers/media/video/saa5246a.c
index dd830e0e5e9..59a187272c8 100644
--- a/drivers/media/video/saa5246a.c
+++ b/drivers/media/video/saa5246a.c
@@ -46,6 +46,7 @@
 #include <linux/i2c.h>
 #include <linux/videotext.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/mutex.h>
 
 #include "saa5246a.h"
diff --git a/drivers/media/video/saa5249.c b/drivers/media/video/saa5249.c
index 531e9461cb6..19a8d65699f 100644
--- a/drivers/media/video/saa5249.c
+++ b/drivers/media/video/saa5249.c
@@ -56,6 +56,7 @@
 #include <linux/i2c.h>
 #include <linux/videotext.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/mutex.h>
 
 
diff --git a/drivers/media/video/saa7110.c b/drivers/media/video/saa7110.c
index 41d951db6ec..676b9970eb2 100644
--- a/drivers/media/video/saa7110.c
+++ b/drivers/media/video/saa7110.c
@@ -43,6 +43,7 @@ MODULE_LICENSE("GPL");
 #define I2C_NAME(s) (s)->name
 
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/video_decoder.h>
 
 static int debug = 0;
diff --git a/drivers/media/video/saa7115.c b/drivers/media/video/saa7115.c
index dceebc0b125..b59c1171727 100644
--- a/drivers/media/video/saa7115.c
+++ b/drivers/media/video/saa7115.c
@@ -72,6 +72,10 @@ struct saa7115_state {
         int sat;
         enum v4l2_chip_ident ident;
         u32 audclk_freq;
+        u32 crystal_freq;
+        u8 ucgc;
+        u8 cgcdiv;
+        u8 apll;
 };
 
 /* ----------------------------------------------------------------------- */
@@ -375,10 +379,6 @@ static const unsigned char saa7113_init_auto_input[] = {
 };
 
 static const unsigned char saa7115_init_misc[] = {
-        0x38, 0x03,             /* audio stuff */
-        0x39, 0x10,
-        0x3a, 0x08,
-
         0x81, 0x01,             /* reg 0x15,0x16 define blanking window */
         0x82, 0x00,
         0x83, 0x01,             /* I port settings */
@@ -584,6 +584,7 @@ static int saa7115_set_audio_clock_freq(struct i2c_client *client, u32 freq)
         u32 acni;
         u32 hz;
         u64 f;
+        u8 acc = 0;     /* reg 0x3a, audio clock control */
 
         v4l_dbg(1, debug, client, "set audio clock freq: %d\n", freq);
 
@@ -591,18 +592,34 @@ static int saa7115_set_audio_clock_freq(struct i2c_client *client, u32 freq)
         if (freq < 32000 || freq > 48000)
                 return -EINVAL;
 
+        /* The saa7113 has no audio clock */
+        if (state->ident == V4L2_IDENT_SAA7113)
+                return 0;
+
         /* hz is the refresh rate times 100 */
         hz = (state->std & V4L2_STD_525_60) ? 5994 : 5000;
         /* acpf = (256 * freq) / field_frequency == (256 * 100 * freq) / hz */
         acpf = (25600 * freq) / hz;
         /* acni = (256 * freq * 2^23) / crystal_frequency =
                   (freq * 2^(8+23)) / crystal_frequency =
-                  (freq << 31) / 32.11 MHz */
+                  (freq << 31) / crystal_frequency */
         f = freq;
         f = f << 31;
-        do_div(f, 32110000);
+        do_div(f, state->crystal_freq);
         acni = f;
+        if (state->ucgc) {
+                acpf = acpf * state->cgcdiv / 16;
+                acni = acni * state->cgcdiv / 16;
+                acc = 0x80;
+                if (state->cgcdiv == 3)
+                        acc |= 0x40;
+        }
+        if (state->apll)
+                acc |= 0x08;
 
+        saa7115_write(client, 0x38, 0x03);
+        saa7115_write(client, 0x39, 0x10);
+        saa7115_write(client, 0x3a, acc);
         saa7115_write(client, 0x30, acpf & 0xff);
         saa7115_write(client, 0x31, (acpf >> 8) & 0xff);
         saa7115_write(client, 0x32, (acpf >> 16) & 0x03);
@@ -1073,48 +1090,6 @@ static void saa7115_decode_vbi_line(struct i2c_client *client,
 
 /* ============ SAA7115 AUDIO settings (end) ============= */
 
-static struct v4l2_queryctrl saa7115_qctrl[] = {
-        {
-                .id            = V4L2_CID_BRIGHTNESS,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Brightness",
-                .minimum       = 0,
-                .maximum       = 255,
-                .step          = 1,
-                .default_value = 128,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_CONTRAST,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Contrast",
-                .minimum       = 0,
-                .maximum       = 127,
-                .step          = 1,
-                .default_value = 64,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_SATURATION,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Saturation",
-                .minimum       = 0,
-                .maximum       = 127,
-                .step          = 1,
-                .default_value = 64,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_HUE,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Hue",
-                .minimum       = -128,
-                .maximum       = 127,
-                .step          = 1,
-                .default_value = 0,
-                .flags         = 0,
-        },
-};
-
-/* ----------------------------------------------------------------------- */
-
 static int saa7115_command(struct i2c_client *client, unsigned int cmd, void *arg)
 {
         struct saa7115_state *state = i2c_get_clientdata(client);
@@ -1158,14 +1133,16 @@ static int saa7115_command(struct i2c_client *client, unsigned int cmd, void *ar
         case VIDIOC_QUERYCTRL:
         {
                 struct v4l2_queryctrl *qc = arg;
-                int i;
 
-                for (i = 0; i < ARRAY_SIZE(saa7115_qctrl); i++)
-                        if (qc->id && qc->id == saa7115_qctrl[i].id) {
-                                memcpy(qc, &saa7115_qctrl[i], sizeof(*qc));
-                                return 0;
-                        }
-                return -EINVAL;
+                switch (qc->id) {
+                        case V4L2_CID_BRIGHTNESS:
+                        case V4L2_CID_CONTRAST:
+                        case V4L2_CID_SATURATION:
+                        case V4L2_CID_HUE:
+                                return v4l2_ctrl_query_fill_std(qc);
+                        default:
+                                return -EINVAL;
+                }
         }
 
         case VIDIOC_G_STD:
@@ -1221,34 +1198,6 @@ static int saa7115_command(struct i2c_client *client, unsigned int cmd, void *ar
                 break;
         }
 
-        case VIDIOC_G_INPUT:
-                *(int *)arg = state->input;
-                break;
-
-        case VIDIOC_S_INPUT:
-                v4l_dbg(1, debug, client, "decoder set input %d\n", *iarg);
-                /* inputs from 0-9 are available */
-                if (*iarg < 0 || *iarg > 9) {
-                        return -EINVAL;
-                }
-
-                if (state->input == *iarg)
-                        break;
-                v4l_dbg(1, debug, client, "now setting %s input\n",
-                        *iarg >= 6 ? "S-Video" : "Composite");
-                state->input = *iarg;
-
-                /* select mode */
-                saa7115_write(client, 0x02,
-                              (saa7115_read(client, 0x02) & 0xf0) |
-                               state->input);
-
-                /* bypass chrominance trap for modes 6..9 */
-                saa7115_write(client, 0x09,
-                              (saa7115_read(client, 0x09) & 0x7f) |
-                               (state->input < 6 ? 0x0 : 0x80));
-                break;
-
         case VIDIOC_STREAMON:
         case VIDIOC_STREAMOFF:
                 v4l_dbg(1, debug, client, "%s output\n",
@@ -1260,6 +1209,21 @@ static int saa7115_command(struct i2c_client *client, unsigned int cmd, void *ar
                 }
                 break;
 
+        case VIDIOC_INT_S_CRYSTAL_FREQ:
+        {
+                struct v4l2_crystal_freq *freq = arg;
+
+                if (freq->freq != SAA7115_FREQ_32_11_MHZ &&
+                    freq->freq != SAA7115_FREQ_24_576_MHZ)
+                        return -EINVAL;
+                state->crystal_freq = freq->freq;
+                state->cgcdiv = (freq->flags & SAA7115_FREQ_FL_CGCDIV) ? 3 : 4;
+                state->ucgc = (freq->flags & SAA7115_FREQ_FL_UCGC) ? 1 : 0;
+                state->apll = (freq->flags & SAA7115_FREQ_FL_APLL) ? 1 : 0;
+                saa7115_set_audio_clock_freq(client, state->audclk_freq);
+                break;
+        }
+
         case VIDIOC_INT_DECODE_VBI_LINE:
                 saa7115_decode_vbi_line(client, arg);
                 break;
@@ -1401,10 +1365,13 @@ static int saa7115_attach(struct i2c_adapter *adapter, int address, int kind)
         v4l_dbg(1, debug, client, "writing init values\n");
 
         /* init to 60hz/48khz */
-        if (state->ident == V4L2_IDENT_SAA7113)
+        if (state->ident == V4L2_IDENT_SAA7113) {
+                state->crystal_freq = SAA7115_FREQ_24_576_MHZ;
                 saa7115_writeregs(client, saa7113_init_auto_input);
-        else
+        } else {
+                state->crystal_freq = SAA7115_FREQ_32_11_MHZ;
                 saa7115_writeregs(client, saa7115_init_auto_input);
+        }
         saa7115_writeregs(client, saa7115_init_misc);
         saa7115_writeregs(client, saa7115_cfg_60hz_fullres_x);
         saa7115_writeregs(client, saa7115_cfg_60hz_fullres_y);
diff --git a/drivers/media/video/saa7127.c b/drivers/media/video/saa7127.c
index c271e2e1410..ad401bdefea 100644
--- a/drivers/media/video/saa7127.c
+++ b/drivers/media/video/saa7127.c
@@ -270,7 +270,7 @@ static const char * const wss_strs[] = {
         "letterbox 16:9 top",
         "invalid",
         "invalid",
-        "16:9 full format anamorphic"
+        "16:9 full format anamorphic",
         "4:3 full format",
         "invalid",
         "invalid",
diff --git a/drivers/media/video/saa7134/saa6752hs.c b/drivers/media/video/saa7134/saa6752hs.c
index 0e0ba50946e..de7b9e6e932 100644
--- a/drivers/media/video/saa7134/saa6752hs.c
+++ b/drivers/media/video/saa7134/saa6752hs.c
@@ -39,6 +39,23 @@ enum saa6752hs_videoformat {
         SAA6752HS_VF_UNKNOWN,
 };
 
+struct saa6752hs_mpeg_params {
+        /* transport streams */
+        __u16                           ts_pid_pmt;
+        __u16                           ts_pid_audio;
+        __u16                           ts_pid_video;
+        __u16                           ts_pid_pcr;
+
+        /* audio */
+        enum v4l2_mpeg_audio_l2_bitrate au_l2_bitrate;
+
+        /* video */
+        enum v4l2_mpeg_video_aspect     vi_aspect;
+        enum v4l2_mpeg_video_bitrate_mode vi_bitrate_mode;
+        __u32                           vi_bitrate;
+        __u32                           vi_bitrate_peak;
+};
+
 static const struct v4l2_format v4l2_format_table[] =
 {
         [SAA6752HS_VF_D1] =
@@ -55,18 +72,19 @@ static const struct v4l2_format v4l2_format_table[] =
 
 struct saa6752hs_state {
         struct i2c_client             client;
-        struct v4l2_mpeg_compression  params;
+        struct v4l2_mpeg_compression  old_params;
+        struct saa6752hs_mpeg_params  params;
         enum saa6752hs_videoformat    video_format;
         v4l2_std_id                   standard;
 };
 
 enum saa6752hs_command {
         SAA6752HS_COMMAND_RESET = 0,
-        SAA6752HS_COMMAND_STOP = 1,
-        SAA6752HS_COMMAND_START = 2,
-        SAA6752HS_COMMAND_PAUSE = 3,
-        SAA6752HS_COMMAND_RECONFIGURE = 4,
-        SAA6752HS_COMMAND_SLEEP = 5,
+        SAA6752HS_COMMAND_STOP = 1,
+        SAA6752HS_COMMAND_START = 2,
+        SAA6752HS_COMMAND_PAUSE = 3,
+        SAA6752HS_COMMAND_RECONFIGURE = 4,
+        SAA6752HS_COMMAND_SLEEP = 5,
         SAA6752HS_COMMAND_RECONFIGURE_FORCE = 6,
 
         SAA6752HS_COMMAND_MAX
@@ -129,7 +147,22 @@ static u8 PMT[] = {
         0x00, 0x00, 0x00, 0x00 /* CRC32 */
 };
 
-static struct v4l2_mpeg_compression param_defaults =
+static struct saa6752hs_mpeg_params param_defaults =
+{
+        .ts_pid_pmt      = 16,
+        .ts_pid_video    = 260,
+        .ts_pid_audio    = 256,
+        .ts_pid_pcr      = 259,
+
+        .vi_aspect       = V4L2_MPEG_VIDEO_ASPECT_4x3,
+        .vi_bitrate      = 4000,
+        .vi_bitrate_peak = 6000,
+        .vi_bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
+
+        .au_l2_bitrate   = V4L2_MPEG_AUDIO_L2_BITRATE_256K,
+};
+
+static struct v4l2_mpeg_compression old_param_defaults =
 {
         .st_type         = V4L2_MPEG_TS_2,
         .st_bitrate      = {
@@ -228,45 +261,57 @@ static int saa6752hs_chip_command(struct i2c_client* client,
 
 
 static int saa6752hs_set_bitrate(struct i2c_client* client,
-                                 struct v4l2_mpeg_compression* params)
+                                 struct saa6752hs_mpeg_params* params)
 {
         u8 buf[3];
+        int tot_bitrate;
 
         /* set the bitrate mode */
         buf[0] = 0x71;
-        buf[1] = (params->vi_bitrate.mode == V4L2_BITRATE_VBR) ? 0 : 1;
+        buf[1] = (params->vi_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) ? 0 : 1;
         i2c_master_send(client, buf, 2);
 
         /* set the video bitrate */
-        if (params->vi_bitrate.mode == V4L2_BITRATE_VBR) {
+        if (params->vi_bitrate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) {
                 /* set the target bitrate */
                 buf[0] = 0x80;
-                buf[1] = params->vi_bitrate.target >> 8;
-                buf[2] = params->vi_bitrate.target & 0xff;
+                buf[1] = params->vi_bitrate >> 8;
+                buf[2] = params->vi_bitrate & 0xff;
                 i2c_master_send(client, buf, 3);
 
                 /* set the max bitrate */
                 buf[0] = 0x81;
-                buf[1] = params->vi_bitrate.max >> 8;
-                buf[2] = params->vi_bitrate.max & 0xff;
+                buf[1] = params->vi_bitrate_peak >> 8;
+                buf[2] = params->vi_bitrate_peak & 0xff;
                 i2c_master_send(client, buf, 3);
+                tot_bitrate = params->vi_bitrate_peak;
         } else {
                 /* set the target bitrate (no max bitrate for CBR) */
                 buf[0] = 0x81;
-                buf[1] = params->vi_bitrate.target >> 8;
-                buf[2] = params->vi_bitrate.target & 0xff;
+                buf[1] = params->vi_bitrate >> 8;
+                buf[2] = params->vi_bitrate & 0xff;
                 i2c_master_send(client, buf, 3);
+                tot_bitrate = params->vi_bitrate;
         }
 
         /* set the audio bitrate */
         buf[0] = 0x94;
-        buf[1] = (256 == params->au_bitrate.target) ? 0 : 1;
+        buf[1] = (V4L2_MPEG_AUDIO_L2_BITRATE_256K == params->au_l2_bitrate) ? 0 : 1;
         i2c_master_send(client, buf, 2);
+        tot_bitrate += (V4L2_MPEG_AUDIO_L2_BITRATE_256K == params->au_l2_bitrate) ? 256 : 384;
+
+        /* Note: the total max bitrate is determined by adding the video and audio
+           bitrates together and also adding an extra 768kbit/s to stay on the
+           safe side. If more control should be required, then an extra MPEG control
+           should be added. */
+        tot_bitrate += 768;
+        if (tot_bitrate > MPEG_TOTAL_TARGET_BITRATE_MAX)
+                tot_bitrate = MPEG_TOTAL_TARGET_BITRATE_MAX;
 
         /* set the total bitrate */
         buf[0] = 0xb1;
-        buf[1] = params->st_bitrate.target >> 8;
-        buf[2] = params->st_bitrate.target & 0xff;
+        buf[1] = tot_bitrate >> 8;
+        buf[2] = tot_bitrate & 0xff;
         i2c_master_send(client, buf, 3);
 
         return 0;
@@ -318,50 +363,188 @@ static void saa6752hs_set_subsampling(struct i2c_client* client,
 }
 
 
-static void saa6752hs_set_params(struct i2c_client* client,
+static void saa6752hs_old_set_params(struct i2c_client* client,
                                  struct v4l2_mpeg_compression* params)
 {
         struct saa6752hs_state *h = i2c_get_clientdata(client);
 
         /* check PIDs */
-        if (params->ts_pid_pmt <= MPEG_PID_MAX)
+        if (params->ts_pid_pmt <= MPEG_PID_MAX) {
+                h->old_params.ts_pid_pmt = params->ts_pid_pmt;
                 h->params.ts_pid_pmt = params->ts_pid_pmt;
-        if (params->ts_pid_pcr <= MPEG_PID_MAX)
+        }
+        if (params->ts_pid_pcr <= MPEG_PID_MAX) {
+                h->old_params.ts_pid_pcr = params->ts_pid_pcr;
                 h->params.ts_pid_pcr = params->ts_pid_pcr;
-        if (params->ts_pid_video <= MPEG_PID_MAX)
+        }
+        if (params->ts_pid_video <= MPEG_PID_MAX) {
+                h->old_params.ts_pid_video = params->ts_pid_video;
                 h->params.ts_pid_video = params->ts_pid_video;
-        if (params->ts_pid_audio <= MPEG_PID_MAX)
+        }
+        if (params->ts_pid_audio <= MPEG_PID_MAX) {
+                h->old_params.ts_pid_audio = params->ts_pid_audio;
                 h->params.ts_pid_audio = params->ts_pid_audio;
+        }
 
         /* check bitrate parameters */
         if ((params->vi_bitrate.mode == V4L2_BITRATE_CBR) ||
-            (params->vi_bitrate.mode == V4L2_BITRATE_VBR))
-                h->params.vi_bitrate.mode = params->vi_bitrate.mode;
+            (params->vi_bitrate.mode == V4L2_BITRATE_VBR)) {
+                h->old_params.vi_bitrate.mode = params->vi_bitrate.mode;
+                h->params.vi_bitrate_mode = (params->vi_bitrate.mode == V4L2_BITRATE_VBR) ?
+                       V4L2_MPEG_VIDEO_BITRATE_MODE_VBR : V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
+        }
         if (params->vi_bitrate.mode != V4L2_BITRATE_NONE)
-                h->params.st_bitrate.target = params->st_bitrate.target;
+                h->old_params.st_bitrate.target = params->st_bitrate.target;
         if (params->vi_bitrate.mode != V4L2_BITRATE_NONE)
-                h->params.vi_bitrate.target = params->vi_bitrate.target;
+                h->old_params.vi_bitrate.target = params->vi_bitrate.target;
         if (params->vi_bitrate.mode == V4L2_BITRATE_VBR)
-                h->params.vi_bitrate.max = params->vi_bitrate.max;
+                h->old_params.vi_bitrate.max = params->vi_bitrate.max;
         if (params->au_bitrate.mode != V4L2_BITRATE_NONE)
-                h->params.au_bitrate.target = params->au_bitrate.target;
+                h->old_params.au_bitrate.target = params->au_bitrate.target;
 
         /* aspect ratio */
         if (params->vi_aspect_ratio == V4L2_MPEG_ASPECT_4_3 ||
-            params->vi_aspect_ratio == V4L2_MPEG_ASPECT_16_9)
-                h->params.vi_aspect_ratio = params->vi_aspect_ratio;
+            params->vi_aspect_ratio == V4L2_MPEG_ASPECT_16_9) {
+                h->old_params.vi_aspect_ratio = params->vi_aspect_ratio;
+                if (params->vi_aspect_ratio == V4L2_MPEG_ASPECT_4_3)
+                        h->params.vi_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3;
+                else
+                        h->params.vi_aspect = V4L2_MPEG_VIDEO_ASPECT_16x9;
+        }
 
         /* range checks */
-        if (h->params.st_bitrate.target > MPEG_TOTAL_TARGET_BITRATE_MAX)
-                h->params.st_bitrate.target = MPEG_TOTAL_TARGET_BITRATE_MAX;
-        if (h->params.vi_bitrate.target > MPEG_VIDEO_TARGET_BITRATE_MAX)
-                h->params.vi_bitrate.target = MPEG_VIDEO_TARGET_BITRATE_MAX;
-        if (h->params.vi_bitrate.max > MPEG_VIDEO_MAX_BITRATE_MAX)
-                h->params.vi_bitrate.max = MPEG_VIDEO_MAX_BITRATE_MAX;
-        if (h->params.au_bitrate.target <= 256)
-                h->params.au_bitrate.target = 256;
+        if (h->old_params.st_bitrate.target > MPEG_TOTAL_TARGET_BITRATE_MAX)
+                h->old_params.st_bitrate.target = MPEG_TOTAL_TARGET_BITRATE_MAX;
+        if (h->old_params.vi_bitrate.target > MPEG_VIDEO_TARGET_BITRATE_MAX)
+                h->old_params.vi_bitrate.target = MPEG_VIDEO_TARGET_BITRATE_MAX;
+        if (h->old_params.vi_bitrate.max > MPEG_VIDEO_MAX_BITRATE_MAX)
+                h->old_params.vi_bitrate.max = MPEG_VIDEO_MAX_BITRATE_MAX;
+        h->params.vi_bitrate = params->vi_bitrate.target;
+        h->params.vi_bitrate_peak = params->vi_bitrate.max;
+        if (h->old_params.au_bitrate.target <= 256) {
+                h->old_params.au_bitrate.target = 256;
+                h->params.au_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_256K;
+        }
+        else {
+                h->old_params.au_bitrate.target = 384;
+                h->params.au_l2_bitrate = V4L2_MPEG_AUDIO_L2_BITRATE_384K;
+        }
+}
+
+static int handle_ctrl(struct saa6752hs_mpeg_params *params,
+                struct v4l2_ext_control *ctrl, int cmd)
+{
+        int old = 0, new;
+        int set = cmd == VIDIOC_S_EXT_CTRLS;
+
+        new = ctrl->value;
+        switch (ctrl->id) {
+                case V4L2_CID_MPEG_STREAM_TYPE:
+                        old = V4L2_MPEG_STREAM_TYPE_MPEG2_TS;
+                        if (set && new != old)
+                                return -ERANGE;
+                        new = old;
+                        break;
+                case V4L2_CID_MPEG_STREAM_PID_PMT:
+                        old = params->ts_pid_pmt;
+                        if (set && new > MPEG_PID_MAX)
+                                return -ERANGE;
+                        if (new > MPEG_PID_MAX)
+                                new = MPEG_PID_MAX;
+                        params->ts_pid_pmt = new;
+                        break;
+                case V4L2_CID_MPEG_STREAM_PID_AUDIO:
+                        old = params->ts_pid_audio;
+                        if (set && new > MPEG_PID_MAX)
+                                return -ERANGE;
+                        if (new > MPEG_PID_MAX)
+                                new = MPEG_PID_MAX;
+                        params->ts_pid_audio = new;
+                        break;
+                case V4L2_CID_MPEG_STREAM_PID_VIDEO:
+                        old = params->ts_pid_video;
+                        if (set && new > MPEG_PID_MAX)
+                                return -ERANGE;
+                        if (new > MPEG_PID_MAX)
+                                new = MPEG_PID_MAX;
+                        params->ts_pid_video = new;
+                        break;
+                case V4L2_CID_MPEG_STREAM_PID_PCR:
+                        old = params->ts_pid_pcr;
+                        if (set && new > MPEG_PID_MAX)
+                                return -ERANGE;
+                        if (new > MPEG_PID_MAX)
+                                new = MPEG_PID_MAX;
+                        params->ts_pid_pcr = new;
+                        break;
+                case V4L2_CID_MPEG_AUDIO_ENCODING:
+                        old = V4L2_MPEG_AUDIO_ENCODING_LAYER_2;
+                        if (set && new != old)
+                                return -ERANGE;
+                        new = old;
+                        break;
+                case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
+                        old = params->au_l2_bitrate;
+                        if (set && new != V4L2_MPEG_AUDIO_L2_BITRATE_256K &&
+                                   new != V4L2_MPEG_AUDIO_L2_BITRATE_384K)
+                                return -ERANGE;
+                        if (new <= V4L2_MPEG_AUDIO_L2_BITRATE_256K)
+                                new = V4L2_MPEG_AUDIO_L2_BITRATE_256K;
+                        else
+                                new = V4L2_MPEG_AUDIO_L2_BITRATE_384K;
+                        params->au_l2_bitrate = new;
+                        break;
+                case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
+                        old = V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000;
+                        if (set && new != old)
+                                return -ERANGE;
+                        new = old;
+                        break;
+                case V4L2_CID_MPEG_VIDEO_ENCODING:
+                        old = V4L2_MPEG_VIDEO_ENCODING_MPEG_2;
+                        if (set && new != old)
+                                return -ERANGE;
+                        new = old;
+                        break;
+                case V4L2_CID_MPEG_VIDEO_ASPECT:
+                        old = params->vi_aspect;
+                        if (set && new != V4L2_MPEG_VIDEO_ASPECT_16x9 &&
+                                   new != V4L2_MPEG_VIDEO_ASPECT_4x3)
+                                return -ERANGE;
+                        if (new != V4L2_MPEG_VIDEO_ASPECT_16x9)
+                                new = V4L2_MPEG_VIDEO_ASPECT_4x3;
+                        params->vi_aspect = new;
+                        break;
+                case V4L2_CID_MPEG_VIDEO_BITRATE:
+                        old = params->vi_bitrate * 1000;
+                        new = 1000 * (new / 1000);
+                        if (set && new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
+                                return -ERANGE;
+                        if (new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
+                                new = MPEG_VIDEO_TARGET_BITRATE_MAX * 1000;
+                        params->vi_bitrate = new / 1000;
+                        break;
+                case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
+                        old = params->vi_bitrate_peak * 1000;
+                        new = 1000 * (new / 1000);
+                        if (set && new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
+                                return -ERANGE;
+                        if (new > MPEG_VIDEO_TARGET_BITRATE_MAX * 1000)
+                                new = MPEG_VIDEO_TARGET_BITRATE_MAX * 1000;
+                        params->vi_bitrate_peak = new / 1000;
+                        break;
+                case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
+                        old = params->vi_bitrate_mode;
+                        params->vi_bitrate_mode = new;
+                        break;
+                default:
+                        return -EINVAL;
+        }
+        if (cmd == VIDIOC_G_EXT_CTRLS)
+                ctrl->value = old;
         else
-                h->params.au_bitrate.target = 384;
+                ctrl->value = new;
+        return 0;
 }
 
 static int saa6752hs_init(struct i2c_client* client)
@@ -395,22 +578,22 @@ static int saa6752hs_init(struct i2c_client* client)
         buf[2] = 0x0D;
         i2c_master_send(client,buf,3);
 
-        /* Set minimum Q-scale {4} */
+        /* Set minimum Q-scale {4} */
         buf[0] = 0x82;
         buf[1] = 0x04;
         i2c_master_send(client,buf,2);
 
-        /* Set maximum Q-scale {12} */
+        /* Set maximum Q-scale {12} */
         buf[0] = 0x83;
         buf[1] = 0x0C;
         i2c_master_send(client,buf,2);
 
-        /* Set Output Protocol */
+        /* Set Output Protocol */
         buf[0] = 0xD0;
         buf[1] = 0x81;
         i2c_master_send(client,buf,2);
 
-        /* Set video output stream format {TS} */
+        /* Set video output stream format {TS} */
         buf[0] = 0xB0;
         buf[1] = 0x05;
         i2c_master_send(client,buf,2);
@@ -441,7 +624,7 @@ static int saa6752hs_init(struct i2c_client* client)
         localPMT[sizeof(PMT) - 2] = (crc >> 8) & 0xFF;
         localPMT[sizeof(PMT) - 1] = crc & 0xFF;
 
-        /* Set Audio PID */
+        /* Set Audio PID */
         buf[0] = 0xC1;
         buf[1] = (h->params.ts_pid_audio >> 8) & 0xFF;
         buf[2] = h->params.ts_pid_audio & 0xFF;
@@ -489,11 +672,11 @@ static int saa6752hs_init(struct i2c_client* client)
         buf[3] = 0x82;
         buf[4] = 0xB0;
         buf[5] = buf2[0];
-        switch(h->params.vi_aspect_ratio) {
-        case V4L2_MPEG_ASPECT_16_9:
+        switch(h->params.vi_aspect) {
+        case V4L2_MPEG_VIDEO_ASPECT_16x9:
                 buf[6] = buf2[1] | 0x40;
                 break;
-        case V4L2_MPEG_ASPECT_4_3:
+        case V4L2_MPEG_VIDEO_ASPECT_4x3:
         default:
                 buf[6] = buf2[1] & 0xBF;
                 break;
@@ -515,6 +698,7 @@ static int saa6752hs_attach(struct i2c_adapter *adap, int addr, int kind)
                 return -ENOMEM;
         h->client = client_template;
         h->params = param_defaults;
+        h->old_params = old_param_defaults;
         h->client.adapter = adap;
         h->client.addr = addr;
 
@@ -550,20 +734,45 @@ static int
 saa6752hs_command(struct i2c_client *client, unsigned int cmd, void *arg)
 {
         struct saa6752hs_state *h = i2c_get_clientdata(client);
-        struct v4l2_mpeg_compression *params = arg;
+        struct v4l2_ext_controls *ctrls = arg;
+        struct v4l2_mpeg_compression *old_params = arg;
+        struct saa6752hs_mpeg_params params;
         int err = 0;
+        int i;
 
         switch (cmd) {
         case VIDIOC_S_MPEGCOMP:
-                if (NULL == params) {
+                if (NULL == old_params) {
                         /* apply settings and start encoder */
                         saa6752hs_init(client);
                         break;
                 }
-                saa6752hs_set_params(client, params);
+                saa6752hs_old_set_params(client, old_params);
                 /* fall through */
         case VIDIOC_G_MPEGCOMP:
-                *params = h->params;
+                *old_params = h->old_params;
+                break;
+        case VIDIOC_S_EXT_CTRLS:
+                if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
+                        return -EINVAL;
+                if (ctrls->count == 0) {
+                        /* apply settings and start encoder */
+                        saa6752hs_init(client);
+                        break;
+                }
+                /* fall through */
+        case VIDIOC_TRY_EXT_CTRLS:
+        case VIDIOC_G_EXT_CTRLS:
+                if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
+                        return -EINVAL;
+                params = h->params;
+                for (i = 0; i < ctrls->count; i++) {
+                        if ((err = handle_ctrl(&params, ctrls->controls + i, cmd))) {
+                                ctrls->error_idx = i;
+                                return err;
+                        }
+                }
+                h->params = params;
                 break;
         case VIDIOC_G_FMT:
         {
diff --git a/drivers/media/video/saa7134/saa7134-alsa.c b/drivers/media/video/saa7134/saa7134-alsa.c
index bb3e0ba946d..d77e6a8d943 100644
--- a/drivers/media/video/saa7134/saa7134-alsa.c
+++ b/drivers/media/video/saa7134/saa7134-alsa.c
@@ -818,7 +818,7 @@ static int snd_saa7134_capsrc_put(struct snd_kcontrol * kcontrol,
                                 break;
                 }
 
-                /* output xbar always main channel */
+                /* output xbar always main channel */
                 saa_dsp_writel(dev, SAA7133_DIGITAL_OUTPUT_SEL1, 0xbbbb10);
 
                 if (left || right) { // We've got data, turn the input on
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index 86eae352833..927413aded1 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -2160,7 +2160,7 @@ struct saa7134_board saa7134_boards[] = {
                 .radio = {
                           .name = name_radio,
                           .amux = LINE2,
-                },
+                },
         },
         [SAA7134_BOARD_GOTVIEW_7135] = {
                 /* Mike Baikov <mike@baikov.com> */
@@ -2842,6 +2842,55 @@ struct saa7134_board saa7134_boards[] = {
                         .gpio = 0x000000,       /* GPIO21=Low for FM radio antenna */
                 },
         },
+        [SAA7134_BOARD_FLYVIDEO3000_NTSC] = {
+                /* "Zac Bowling" <zac@zacbowling.com> */
+                .name           = "LifeView FlyVIDEO3000 (NTSC)",
+                .audio_clock    = 0x00200000,
+                .tuner_type     = TUNER_PHILIPS_NTSC,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+
+                .gpiomask       = 0xe000,
+                .inputs         = {{
+                        .name = name_tv,
+                        .vmux = 1,
+                        .amux = TV,
+                        .gpio = 0x8000,
+                        .tv   = 1,
+                },{
+                        .name = name_tv_mono,
+                        .vmux = 1,
+                        .amux = LINE2,
+                        .gpio = 0x0000,
+                        .tv   = 1,
+                },{
+                        .name = name_comp1,
+                        .vmux = 0,
+                        .amux = LINE2,
+                        .gpio = 0x4000,
+                },{
+                        .name = name_comp2,
+                        .vmux = 3,
+                        .amux = LINE2,
+                        .gpio = 0x4000,
+                },{
+                        .name = name_svideo,
+                        .vmux = 8,
+                        .amux = LINE2,
+                        .gpio = 0x4000,
+                }},
+                .radio = {
+                        .name = name_radio,
+                        .amux = LINE2,
+                        .gpio = 0x2000,
+                },
+                        .mute = {
+                        .name = name_mute,
+                        .amux = TV,
+                        .gpio = 0x8000,
+                },
+        },
 };
 
 const unsigned int saa7134_bcount = ARRAY_SIZE(saa7134_boards);
@@ -2901,6 +2950,12 @@ struct pci_device_id saa7134_pci_tbl[] = {
         },{
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
+                .subvendor    = 0x5169,
+                .subdevice    = 0x0138,
+                .driver_data  = SAA7134_BOARD_FLYVIDEO3000_NTSC,
+        },{
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
                 .subvendor    = 0x5168,
                 .subdevice    = 0x0138,
                 .driver_data  = SAA7134_BOARD_FLYVIDEO3000,
@@ -3459,6 +3514,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
         switch (dev->board) {
         case SAA7134_BOARD_FLYVIDEO2000:
         case SAA7134_BOARD_FLYVIDEO3000:
+        case SAA7134_BOARD_FLYVIDEO3000_NTSC:
                 dev->has_remote = SAA7134_REMOTE_GPIO;
                 board_flyvideo(dev);
                 break;
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c
index 222a36c3891..279828b8f29 100644
--- a/drivers/media/video/saa7134/saa7134-dvb.c
+++ b/drivers/media/video/saa7134/saa7134-dvb.c
@@ -132,9 +132,8 @@ static int mt352_aver777_init(struct dvb_frontend* fe)
         return 0;
 }
 
-static int mt352_pinnacle_pll_set(struct dvb_frontend* fe,
-                                  struct dvb_frontend_parameters* params,
-                                  u8* pllbuf)
+static int mt352_pinnacle_tuner_set_params(struct dvb_frontend* fe,
+                                           struct dvb_frontend_parameters* params)
 {
         u8 off[] = { 0x00, 0xf1};
         u8 on[]  = { 0x00, 0x71};
@@ -147,30 +146,31 @@ static int mt352_pinnacle_pll_set(struct dvb_frontend* fe,
         f.tuner     = 0;
         f.type      = V4L2_TUNER_DIGITAL_TV;
         f.frequency = params->frequency / 1000 * 16 / 1000;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &msg, 1);
         saa7134_i2c_call_clients(dev,VIDIOC_S_FREQUENCY,&f);
         msg.buf = on;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &msg, 1);
 
         pinnacle_antenna_pwr(dev, antenna_pwr);
 
         /* mt352 setup */
-        mt352_pinnacle_init(fe);
-        pllbuf[0] = 0xc2;
-        pllbuf[1] = 0x00;
-        pllbuf[2] = 0x00;
-        pllbuf[3] = 0x80;
-        pllbuf[4] = 0x00;
-        return 0;
+        return mt352_pinnacle_init(fe);
 }
 
-static int mt352_aver777_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params, u8* pllbuf)
+static int mt352_aver777_tuner_calc_regs(struct dvb_frontend *fe, struct dvb_frontend_parameters *params, u8* pllbuf, int buf_len)
 {
-        pllbuf[0] = 0xc2;
+        if (buf_len < 5)
+                return -EINVAL;
+
+        pllbuf[0] = 0x61;
         dvb_pll_configure(&dvb_pll_philips_td1316, pllbuf+1,
                           params->frequency,
                           params->u.ofdm.bandwidth);
-        return 0;
+        return 5;
 }
 
 static struct mt352_config pinnacle_300i = {
@@ -179,13 +179,11 @@ static struct mt352_config pinnacle_300i = {
         .if2           = 36150,
         .no_tuner      = 1,
         .demod_init    = mt352_pinnacle_init,
-        .pll_set       = mt352_pinnacle_pll_set,
 };
 
 static struct mt352_config avermedia_777 = {
         .demod_address = 0xf,
         .demod_init    = mt352_aver777_init,
-        .pll_set       = mt352_aver777_pll_set,
 };
 #endif
 
@@ -268,6 +266,8 @@ static int philips_tda6651_pll_set(u8 addr, struct dvb_frontend *fe, struct dvb_
         tuner_buf[2] = 0xca;
         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
 
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&dev->i2c_adap, &tuner_msg, 1) != 1)
                 return -EIO;
         msleep(1);
@@ -281,6 +281,8 @@ static int philips_tda6651_pll_init(u8 addr, struct dvb_frontend *fe)
         struct i2c_msg tuner_msg = {.addr = addr,.flags = 0,.buf = tu1216_init,.len = sizeof(tu1216_init) };
 
         /* setup PLL configuration */
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&dev->i2c_adap, &tuner_msg, 1) != 1)
                 return -EIO;
         msleep(1);
@@ -290,12 +292,12 @@ static int philips_tda6651_pll_init(u8 addr, struct dvb_frontend *fe)
 
 /* ------------------------------------------------------------------ */
 
-static int philips_tu1216_pll_60_init(struct dvb_frontend *fe)
+static int philips_tu1216_tuner_60_init(struct dvb_frontend *fe)
 {
         return philips_tda6651_pll_init(0x60, fe);
 }
 
-static int philips_tu1216_pll_60_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int philips_tu1216_tuner_60_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         return philips_tda6651_pll_set(0x60, fe, params);
 }
@@ -315,20 +317,17 @@ static struct tda1004x_config philips_tu1216_60_config = {
         .xtal_freq     = TDA10046_XTAL_4M,
         .agc_config    = TDA10046_AGC_DEFAULT,
         .if_freq       = TDA10046_FREQ_3617,
-        .pll_init      = philips_tu1216_pll_60_init,
-        .pll_set       = philips_tu1216_pll_60_set,
-        .pll_sleep     = NULL,
         .request_firmware = philips_tu1216_request_firmware,
 };
 
 /* ------------------------------------------------------------------ */
 
-static int philips_tu1216_pll_61_init(struct dvb_frontend *fe)
+static int philips_tu1216_tuner_61_init(struct dvb_frontend *fe)
 {
         return philips_tda6651_pll_init(0x61, fe);
 }
 
-static int philips_tu1216_pll_61_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int philips_tu1216_tuner_61_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         return philips_tda6651_pll_set(0x61, fe, params);
 }
@@ -341,21 +340,20 @@ static struct tda1004x_config philips_tu1216_61_config = {
         .xtal_freq     = TDA10046_XTAL_4M,
         .agc_config    = TDA10046_AGC_DEFAULT,
         .if_freq       = TDA10046_FREQ_3617,
-        .pll_init      = philips_tu1216_pll_61_init,
-        .pll_set       = philips_tu1216_pll_61_set,
-        .pll_sleep     = NULL,
         .request_firmware = philips_tu1216_request_firmware,
 };
 
 /* ------------------------------------------------------------------ */
 
-static int philips_europa_pll_init(struct dvb_frontend *fe)
+static int philips_europa_tuner_init(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         static u8 msg[] = { 0x0b, 0xf5, 0x86, 0xab };
         struct i2c_msg init_msg = {.addr = 0x61,.flags = 0,.buf = msg,.len = sizeof(msg) };
 
         /* setup PLL configuration */
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&dev->i2c_adap, &init_msg, 1) != 1)
                 return -EIO;
         msleep(1);
@@ -365,18 +363,20 @@ static int philips_europa_pll_init(struct dvb_frontend *fe)
         init_msg.len  = 0x02;
         msg[0] = 0x00;
         msg[1] = 0x40;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&dev->i2c_adap, &init_msg, 1) != 1)
                 return -EIO;
 
         return 0;
 }
 
-static int philips_td1316_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int philips_td1316_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         return philips_tda6651_pll_set(0x61, fe, params);
 }
 
-static void philips_europa_analog(struct dvb_frontend *fe)
+static int philips_europa_tuner_sleep(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         /* this message actually turns the tuner back to analog mode */
@@ -391,7 +391,20 @@ static void philips_europa_analog(struct dvb_frontend *fe)
         analog_msg.len  = 0x02;
         msg[0] = 0x00;
         msg[1] = 0x14;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &analog_msg, 1);
+        return 0;
+}
+
+static int philips_europa_demod_sleep(struct dvb_frontend *fe)
+{
+        struct saa7134_dev *dev = fe->dvb->priv;
+
+        if (dev->original_demod_sleep)
+                dev->original_demod_sleep(fe);
+        fe->ops.i2c_gate_ctrl(fe, 1);
+        return 0;
 }
 
 static struct tda1004x_config philips_europa_config = {
@@ -402,21 +415,20 @@ static struct tda1004x_config philips_europa_config = {
         .xtal_freq     = TDA10046_XTAL_4M,
         .agc_config    = TDA10046_AGC_IFO_AUTO_POS,
         .if_freq       = TDA10046_FREQ_052,
-        .pll_init      = philips_europa_pll_init,
-        .pll_set       = philips_td1316_pll_set,
-        .pll_sleep     = philips_europa_analog,
         .request_firmware = NULL,
 };
 
 /* ------------------------------------------------------------------ */
 
-static int philips_fmd1216_pll_init(struct dvb_frontend *fe)
+static int philips_fmd1216_tuner_init(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         /* this message is to set up ATC and ALC */
         static u8 fmd1216_init[] = { 0x0b, 0xdc, 0x9c, 0xa0 };
         struct i2c_msg tuner_msg = {.addr = 0x61,.flags = 0,.buf = fmd1216_init,.len = sizeof(fmd1216_init) };
 
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&dev->i2c_adap, &tuner_msg, 1) != 1)
                 return -EIO;
         msleep(1);
@@ -424,22 +436,27 @@ static int philips_fmd1216_pll_init(struct dvb_frontend *fe)
         return 0;
 }
 
-static void philips_fmd1216_analog(struct dvb_frontend *fe)
+static int philips_fmd1216_tuner_sleep(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         /* this message actually turns the tuner back to analog mode */
         static u8 fmd1216_init[] = { 0x0b, 0xdc, 0x9c, 0x60 };
         struct i2c_msg tuner_msg = {.addr = 0x61,.flags = 0,.buf = fmd1216_init,.len = sizeof(fmd1216_init) };
 
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &tuner_msg, 1);
         msleep(1);
         fmd1216_init[2] = 0x86;
         fmd1216_init[3] = 0x54;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &tuner_msg, 1);
         msleep(1);
+        return 0;
 }
 
-static int philips_fmd1216_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int philips_fmd1216_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         u8 tuner_buf[4];
@@ -516,6 +533,8 @@ static int philips_fmd1216_pll_set(struct dvb_frontend *fe, struct dvb_frontend_
         tuner_buf[2] = 0x80 | (cp << 6) | (mode  << 3) | 4;
         tuner_buf[3] = 0x40 | band;
 
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&dev->i2c_adap, &tuner_msg, 1) != 1)
                 return -EIO;
         return 0;
@@ -528,9 +547,6 @@ static struct tda1004x_config medion_cardbus = {
         .xtal_freq     = TDA10046_XTAL_16M,
         .agc_config    = TDA10046_AGC_IFO_AUTO_NEG,
         .if_freq       = TDA10046_FREQ_3613,
-        .pll_init      = philips_fmd1216_pll_init,
-        .pll_set       = philips_fmd1216_pll_set,
-        .pll_sleep         = philips_fmd1216_analog,
         .request_firmware = NULL,
 };
 
@@ -578,12 +594,12 @@ static struct tda827x_data tda827x_dvbt[] = {
         { .lomax =         0, .spd = 0, .bs = 0, .bp = 0, .cp = 0, .gc3 = 0, .div1p5 = 0}
 };
 
-static int philips_tda827x_pll_init(struct dvb_frontend *fe)
+static int philips_tda827x_tuner_init(struct dvb_frontend *fe)
 {
         return 0;
 }
 
-static int philips_tda827x_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int philips_tda827x_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         u8 tuner_buf[14];
@@ -630,6 +646,8 @@ static int philips_tda827x_pll_set(struct dvb_frontend *fe, struct dvb_frontend_
         tuner_buf[13] = 0x40;
 
         tuner_msg.len = 14;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&dev->i2c_adap, &tuner_msg, 1) != 1)
                 return -EIO;
 
@@ -638,18 +656,23 @@ static int philips_tda827x_pll_set(struct dvb_frontend *fe, struct dvb_frontend_
         tuner_buf[0] = 0x30;
         tuner_buf[1] = 0x50 + tda827x_dvbt[i].cp;
         tuner_msg.len = 2;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &tuner_msg, 1);
 
         return 0;
 }
 
-static void philips_tda827x_pll_sleep(struct dvb_frontend *fe)
+static int philips_tda827x_tuner_sleep(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         static u8 tda827x_sleep[] = { 0x30, 0xd0};
         struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tda827x_sleep,
                                     .len = sizeof(tda827x_sleep) };
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &tuner_msg, 1);
+        return 0;
 }
 
 static struct tda1004x_config tda827x_lifeview_config = {
@@ -659,9 +682,6 @@ static struct tda1004x_config tda827x_lifeview_config = {
         .xtal_freq     = TDA10046_XTAL_16M,
         .agc_config    = TDA10046_AGC_TDA827X,
         .if_freq       = TDA10046_FREQ_045,
-        .pll_init      = philips_tda827x_pll_init,
-        .pll_set       = philips_tda827x_pll_set,
-        .pll_sleep         = philips_tda827x_pll_sleep,
         .request_firmware = NULL,
 };
 
@@ -753,6 +773,8 @@ static int philips_tda827xa_pll_set(u8 addr, struct dvb_frontend *fe, struct dvb
         tuner_buf[12] = 0x00;
         tuner_buf[13] = 0x39;  // lpsel
         msg.len = 14;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         if (i2c_transfer(&dev->i2c_adap, &msg, 1) != 1)
                 return -EIO;
 
@@ -760,10 +782,14 @@ static int philips_tda827xa_pll_set(u8 addr, struct dvb_frontend *fe, struct dvb
         msg.len = 2;
         reg2[0] = 0x60;
         reg2[1] = 0x3c;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &msg, 1);
 
         reg2[0] = 0xa0;
         reg2[1] = 0x40;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &msg, 1);
 
         msleep(2);
@@ -771,36 +797,43 @@ static int philips_tda827xa_pll_set(u8 addr, struct dvb_frontend *fe, struct dvb
         reg2[0] = 0x30;
         reg2[1] = 0x10 + tda827xa_dvbt[i].scr;
         msg.len = 2;
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &msg, 1);
 
         msleep(550);
         reg2[0] = 0x50;
         reg2[1] = 0x4f + (tda827xa_dvbt[i].gc3 << 4);
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &msg, 1);
 
         return 0;
 
 }
 
-static void philips_tda827xa_pll_sleep(u8 addr, struct dvb_frontend *fe)
+static int philips_tda827xa_tuner_sleep(u8 addr, struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         static u8 tda827xa_sleep[] = { 0x30, 0x90};
         struct i2c_msg tuner_msg = {.addr = addr,.flags = 0,.buf = tda827xa_sleep,
                                     .len = sizeof(tda827xa_sleep) };
+        if (fe->ops.i2c_gate_ctrl)
+                fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &tuner_msg, 1);
-
+        return 0;
 }
 
 /* ------------------------------------------------------------------ */
 
-static int philips_tiger_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int philips_tiger_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         int ret;
         struct saa7134_dev *dev = fe->dvb->priv;
         static u8 tda8290_close[] = { 0x21, 0xc0};
         static u8 tda8290_open[]  = { 0x21, 0x80};
         struct i2c_msg tda8290_msg = {.addr = 0x4b,.flags = 0, .len = 2};
+
         /* close tda8290 i2c bridge */
         tda8290_msg.buf = tda8290_close;
         ret = i2c_transfer(&dev->i2c_adap, &tda8290_msg, 1);
@@ -816,7 +849,7 @@ static int philips_tiger_pll_set(struct dvb_frontend *fe, struct dvb_frontend_pa
         return ret;
 }
 
-static int philips_tiger_dvb_mode(struct dvb_frontend *fe)
+static int philips_tiger_tuner_init(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         static u8 data[] = { 0x3c, 0x33, 0x6a};
@@ -827,14 +860,15 @@ static int philips_tiger_dvb_mode(struct dvb_frontend *fe)
         return 0;
 }
 
-static void philips_tiger_analog_mode(struct dvb_frontend *fe)
+static int philips_tiger_tuner_sleep(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         static u8 data[] = { 0x3c, 0x33, 0x68};
         struct i2c_msg msg = {.addr=0x08, .flags=0, .buf=data, .len = sizeof(data)};
 
         i2c_transfer(&dev->i2c_adap, &msg, 1);
-        philips_tda827xa_pll_sleep( 0x61, fe);
+        philips_tda827xa_tuner_sleep( 0x61, fe);
+        return 0;
 }
 
 static struct tda1004x_config philips_tiger_config = {
@@ -844,15 +878,12 @@ static struct tda1004x_config philips_tiger_config = {
         .xtal_freq     = TDA10046_XTAL_16M,
         .agc_config    = TDA10046_AGC_TDA827X,
         .if_freq       = TDA10046_FREQ_045,
-        .pll_init      = philips_tiger_dvb_mode,
-        .pll_set       = philips_tiger_pll_set,
-        .pll_sleep     = philips_tiger_analog_mode,
         .request_firmware = NULL,
 };
 
 /* ------------------------------------------------------------------ */
 
-static int lifeview_trio_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int lifeview_trio_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         int ret;
 
@@ -860,16 +891,12 @@ static int lifeview_trio_pll_set(struct dvb_frontend *fe, struct dvb_frontend_pa
         return ret;
 }
 
-static int lifeview_trio_dvb_mode(struct dvb_frontend *fe)
+static int lifeview_trio_tuner_sleep(struct dvb_frontend *fe)
 {
+        philips_tda827xa_tuner_sleep(0x60, fe);
         return 0;
 }
 
-static void lifeview_trio_analog_mode(struct dvb_frontend *fe)
-{
-        philips_tda827xa_pll_sleep(0x60, fe);
-}
-
 static struct tda1004x_config lifeview_trio_config = {
         .demod_address = 0x09,
         .invert        = 1,
@@ -877,15 +904,12 @@ static struct tda1004x_config lifeview_trio_config = {
         .xtal_freq     = TDA10046_XTAL_16M,
         .agc_config    = TDA10046_AGC_TDA827X_GPL,
         .if_freq       = TDA10046_FREQ_045,
-        .pll_init      = lifeview_trio_dvb_mode,
-        .pll_set       = lifeview_trio_pll_set,
-        .pll_sleep     = lifeview_trio_analog_mode,
         .request_firmware = NULL,
 };
 
 /* ------------------------------------------------------------------ */
 
-static int ads_duo_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int ads_duo_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         int ret;
 
@@ -893,7 +917,7 @@ static int ads_duo_pll_set(struct dvb_frontend *fe, struct dvb_frontend_paramete
         return ret;
 }
 
-static int ads_duo_dvb_mode(struct dvb_frontend *fe)
+static int ads_duo_tuner_init(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         /* route TDA8275a AGC input to the channel decoder */
@@ -901,12 +925,13 @@ static int ads_duo_dvb_mode(struct dvb_frontend *fe)
         return 0;
 }
 
-static void ads_duo_analog_mode(struct dvb_frontend *fe)
+static int ads_duo_tuner_sleep(struct dvb_frontend *fe)
 {
         struct saa7134_dev *dev = fe->dvb->priv;
         /* route TDA8275a AGC input to the analog IF chip*/
         saa_writeb(SAA7134_GPIO_GPSTATUS2, 0x20);
-        philips_tda827xa_pll_sleep( 0x61, fe);
+        philips_tda827xa_tuner_sleep( 0x61, fe);
+        return 0;
 }
 
 static struct tda1004x_config ads_tech_duo_config = {
@@ -916,31 +941,24 @@ static struct tda1004x_config ads_tech_duo_config = {
         .xtal_freq     = TDA10046_XTAL_16M,
         .agc_config    = TDA10046_AGC_TDA827X_GPL,
         .if_freq       = TDA10046_FREQ_045,
-        .pll_init      = ads_duo_dvb_mode,
-        .pll_set       = ads_duo_pll_set,
-        .pll_sleep     = ads_duo_analog_mode,
         .request_firmware = NULL,
 };
 
 /* ------------------------------------------------------------------ */
 
-static int tevion_dvb220rf_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int tevion_dvb220rf_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
 {
         int ret;
         ret = philips_tda827xa_pll_set(0x60, fe, params);
         return ret;
 }
 
-static int tevion_dvb220rf_pll_init(struct dvb_frontend *fe)
+static int tevion_dvb220rf_tuner_sleep(struct dvb_frontend *fe)
 {
+        philips_tda827xa_tuner_sleep( 0x61, fe);
         return 0;
 }
 
-static void tevion_dvb220rf_pll_sleep(struct dvb_frontend *fe)
-{
-        philips_tda827xa_pll_sleep( 0x61, fe);
-}
-
 static struct tda1004x_config tevion_dvbt220rf_config = {
         .demod_address = 0x08,
         .invert        = 1,
@@ -948,9 +966,6 @@ static struct tda1004x_config tevion_dvbt220rf_config = {
         .xtal_freq     = TDA10046_XTAL_16M,
         .agc_config    = TDA10046_AGC_TDA827X,
         .if_freq       = TDA10046_FREQ_045,
-        .pll_init      = tevion_dvb220rf_pll_init,
-        .pll_set       = tevion_dvb220rf_pll_set,
-        .pll_sleep     = tevion_dvb220rf_pll_sleep,
         .request_firmware = NULL,
 };
 
@@ -961,8 +976,6 @@ static struct tda1004x_config tevion_dvbt220rf_config = {
 #ifdef HAVE_NXT200X
 static struct nxt200x_config avertvhda180 = {
         .demod_address    = 0x0a,
-        .pll_address      = 0x61,
-        .pll_desc         = &dvb_pll_tdhu2,
 };
 
 static int nxt200x_set_pll_input(u8 *buf, int input)
@@ -976,8 +989,6 @@ static int nxt200x_set_pll_input(u8 *buf, int input)
 
 static struct nxt200x_config kworldatsc110 = {
         .demod_address    = 0x0a,
-        .pll_address      = 0x61,
-        .pll_desc         = &dvb_pll_tuv1236d,
         .set_pll_input    = nxt200x_set_pll_input,
 };
 #endif
@@ -1003,78 +1014,158 @@ static int dvb_init(struct saa7134_dev *dev)
                 printk("%s: pinnacle 300i dvb setup\n",dev->name);
                 dev->dvb.frontend = mt352_attach(&pinnacle_300i,
                                                  &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.set_params = mt352_pinnacle_tuner_set_params;
+                }
                 break;
 
         case SAA7134_BOARD_AVERMEDIA_777:
                 printk("%s: avertv 777 dvb setup\n",dev->name);
                 dev->dvb.frontend = mt352_attach(&avermedia_777,
                                                  &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.calc_regs = mt352_aver777_tuner_calc_regs;
+                }
                 break;
 #endif
 #ifdef HAVE_TDA1004X
         case SAA7134_BOARD_MD7134:
                 dev->dvb.frontend = tda10046_attach(&medion_cardbus,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_fmd1216_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = philips_fmd1216_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_fmd1216_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_PHILIPS_TOUGH:
                 dev->dvb.frontend = tda10046_attach(&philips_tu1216_60_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_tu1216_tuner_60_init;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_tu1216_tuner_60_set_params;
+                }
                 break;
         case SAA7134_BOARD_FLYDVBTDUO:
                 dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_tda827x_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = philips_tda827x_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_tda827x_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_FLYDVBT_DUO_CARDBUS:
                 dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_tda827x_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = philips_tda827x_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_tda827x_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_PHILIPS_EUROPA:
                 dev->dvb.frontend = tda10046_attach(&philips_europa_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->original_demod_sleep = dev->dvb.frontend->ops.sleep;
+                        dev->dvb.frontend->ops.sleep = philips_europa_demod_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_europa_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = philips_europa_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_td1316_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_VIDEOMATE_DVBT_300:
                 dev->dvb.frontend = tda10046_attach(&philips_europa_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_europa_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = philips_europa_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_td1316_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_VIDEOMATE_DVBT_200:
                 dev->dvb.frontend = tda10046_attach(&philips_tu1216_61_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_tu1216_tuner_61_init;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_tu1216_tuner_61_set_params;
+                }
                 break;
         case SAA7134_BOARD_PHILIPS_TIGER:
                 dev->dvb.frontend = tda10046_attach(&philips_tiger_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_tiger_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = philips_tiger_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_tiger_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_ASUSTeK_P7131_DUAL:
                 dev->dvb.frontend = tda10046_attach(&philips_tiger_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_tiger_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = philips_tiger_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_tiger_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_FLYDVBT_LR301:
                 dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = philips_tda827x_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = philips_tda827x_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = philips_tda827x_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_FLYDVB_TRIO:
                 dev->dvb.frontend = tda10046_attach(&lifeview_trio_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.sleep = lifeview_trio_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = lifeview_trio_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_ADS_DUO_CARDBUS_PTV331:
                 dev->dvb.frontend = tda10046_attach(&ads_tech_duo_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = ads_duo_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = ads_duo_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = ads_duo_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_TEVION_DVBT_220RF:
                 dev->dvb.frontend = tda10046_attach(&tevion_dvbt220rf_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.sleep = tevion_dvb220rf_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = tevion_dvb220rf_tuner_set_params;
+                }
                 break;
         case SAA7134_BOARD_FLYDVBT_HYBRID_CARDBUS:
                 dev->dvb.frontend = tda10046_attach(&ads_tech_duo_config,
                                                     &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dev->dvb.frontend->ops.tuner_ops.init = ads_duo_tuner_init;
+                        dev->dvb.frontend->ops.tuner_ops.sleep = ads_duo_tuner_sleep;
+                        dev->dvb.frontend->ops.tuner_ops.set_params = ads_duo_tuner_set_params;
+                }
                 break;
 #endif
 #ifdef HAVE_NXT200X
         case SAA7134_BOARD_AVERMEDIA_AVERTVHD_A180:
                 dev->dvb.frontend = nxt200x_attach(&avertvhda180, &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61, &dev->i2c_adap, &dvb_pll_tdhu2);
+                }
                 break;
         case SAA7134_BOARD_KWORLD_ATSC110:
                 dev->dvb.frontend = nxt200x_attach(&kworldatsc110, &dev->i2c_adap);
+                if (dev->dvb.frontend) {
+                        dvb_pll_attach(dev->dvb.frontend, 0x61, &dev->i2c_adap, &dvb_pll_tuv1236d);
+                }
                 break;
 #endif
         default:
@@ -1088,7 +1179,7 @@ static int dvb_init(struct saa7134_dev *dev)
         }
 
         /* register everything else */
-        return videobuf_dvb_register(&dev->dvb, THIS_MODULE, dev);
+        return videobuf_dvb_register(&dev->dvb, THIS_MODULE, dev, &dev->pci->dev);
 }
 
 static int dvb_fini(struct saa7134_dev *dev)
diff --git a/drivers/media/video/saa7134/saa7134-empress.c b/drivers/media/video/saa7134/saa7134-empress.c
index 1d972edb3be..65d044086ce 100644
--- a/drivers/media/video/saa7134/saa7134-empress.c
+++ b/drivers/media/video/saa7134/saa7134-empress.c
@@ -64,8 +64,10 @@ static void ts_reset_encoder(struct saa7134_dev* dev)
 
 static int ts_init_encoder(struct saa7134_dev* dev)
 {
+        struct v4l2_ext_controls ctrls = { V4L2_CTRL_CLASS_MPEG, 0 };
+
         ts_reset_encoder(dev);
-        saa7134_i2c_call_clients(dev, VIDIOC_S_MPEGCOMP, NULL);
+        saa7134_i2c_call_clients(dev, VIDIOC_S_EXT_CTRLS, &ctrls);
         dev->empress_started = 1;
         return 0;
 }
@@ -162,6 +164,7 @@ static int ts_do_ioctl(struct inode *inode, struct file *file,
                        unsigned int cmd, void *arg)
 {
         struct saa7134_dev *dev = file->private_data;
+        struct v4l2_ext_controls *ctrls = arg;
 
         if (debug > 1)
                 v4l_print_ioctl(dev->name,cmd);
@@ -278,12 +281,31 @@ static int ts_do_ioctl(struct inode *inode, struct file *file,
                 return saa7134_common_ioctl(dev, cmd, arg);
 
         case VIDIOC_S_MPEGCOMP:
+                printk(KERN_WARNING "VIDIOC_S_MPEGCOMP is obsolete. "
+                                    "Replace with VIDIOC_S_EXT_CTRLS!");
                 saa7134_i2c_call_clients(dev, VIDIOC_S_MPEGCOMP, arg);
                 ts_init_encoder(dev);
                 return 0;
         case VIDIOC_G_MPEGCOMP:
+                printk(KERN_WARNING "VIDIOC_G_MPEGCOMP is obsolete. "
+                                    "Replace with VIDIOC_G_EXT_CTRLS!");
                 saa7134_i2c_call_clients(dev, VIDIOC_G_MPEGCOMP, arg);
                 return 0;
+        case VIDIOC_S_EXT_CTRLS:
+                /* count == 0 is abused in saa6752hs.c, so that special
+                   case is handled here explicitly. */
+                if (ctrls->count == 0)
+                        return 0;
+                if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
+                        return -EINVAL;
+                saa7134_i2c_call_clients(dev, VIDIOC_S_EXT_CTRLS, arg);
+                ts_init_encoder(dev);
+                return 0;
+        case VIDIOC_G_EXT_CTRLS:
+                if (ctrls->ctrl_class != V4L2_CTRL_CLASS_MPEG)
+                        return -EINVAL;
+                saa7134_i2c_call_clients(dev, VIDIOC_G_EXT_CTRLS, arg);
+                return 0;
 
         default:
                 return -ENOIOCTLCMD;
diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c
index 1426e4c8602..7c595492c56 100644
--- a/drivers/media/video/saa7134/saa7134-input.c
+++ b/drivers/media/video/saa7134/saa7134-input.c
@@ -37,6 +37,10 @@ static unsigned int ir_debug = 0;
 module_param(ir_debug, int, 0644);
 MODULE_PARM_DESC(ir_debug,"enable debug messages [IR]");
 
+static int pinnacle_remote = 0;
+module_param(pinnacle_remote, int, 0644);    /* Choose Pinnacle PCTV remote */
+MODULE_PARM_DESC(pinnacle_remote, "Specify Pinnacle PCTV remote: 0=coloured, 1=grey (defaults to 0)");
+
 #define dprintk(fmt, arg...)    if (ir_debug) \
         printk(KERN_DEBUG "%s/ir: " fmt, dev->name , ## arg)
 #define i2cdprintk(fmt, arg...)    if (ir_debug) \
@@ -316,8 +320,13 @@ void saa7134_set_i2c_ir(struct saa7134_dev *dev, struct IR_i2c *ir)
         switch (dev->board) {
         case SAA7134_BOARD_PINNACLE_PCTV_110i:
                 snprintf(ir->c.name, sizeof(ir->c.name), "Pinnacle PCTV");
-                ir->get_key   = get_key_pinnacle;
-                ir->ir_codes  = ir_codes_pinnacle;
+                if (pinnacle_remote == 0) {
+                        ir->get_key   = get_key_pinnacle_color;
+                        ir->ir_codes = ir_codes_pinnacle_color;
+                } else {
+                        ir->get_key   = get_key_pinnacle_grey;
+                        ir->ir_codes = ir_codes_pinnacle_grey;
+                }
                 break;
         case SAA7134_BOARD_UPMOST_PURPLE_TV:
                 snprintf(ir->c.name, sizeof(ir->c.name), "Purple TV");
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index 353af3a8b76..d5ee99c574c 100644
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -33,6 +33,7 @@
 
 #include <asm/io.h>
 
+#include <media/v4l2-common.h>
 #include <media/tuner.h>
 #include <media/ir-common.h>
 #include <media/ir-kbd-i2c.h>
@@ -221,6 +222,7 @@ struct saa7134_format {
 #define SAA7134_BOARD_AVERMEDIA_A169_B1 92
 #define SAA7134_BOARD_MD7134_BRIDGE_2     93
 #define SAA7134_BOARD_FLYDVBT_HYBRID_CARDBUS 94
+#define SAA7134_BOARD_FLYVIDEO3000_NTSC 95
 
 #define SAA7134_MAXBOARDS 8
 #define SAA7134_INPUT_MAX 8
@@ -531,6 +533,7 @@ struct saa7134_dev {
 
         /* SAA7134_MPEG_DVB only */
         struct videobuf_dvb        dvb;
+        int (*original_demod_sleep)(struct dvb_frontend* fe);
 };
 
 /* ----------------------------------------------------------- */
diff --git a/drivers/media/video/se401.h b/drivers/media/video/se401.h
index a7a216bd441..c0891b3e001 100644
--- a/drivers/media/video/se401.h
+++ b/drivers/media/video/se401.h
@@ -4,6 +4,7 @@
 
 #include <asm/uaccess.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/smp_lock.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/media/video/sn9c102/sn9c102_core.c b/drivers/media/video/sn9c102/sn9c102_core.c
index ea4394dc941..48d138a7c72 100644
--- a/drivers/media/video/sn9c102/sn9c102_core.c
+++ b/drivers/media/video/sn9c102/sn9c102_core.c
@@ -2608,11 +2608,9 @@ static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp,
         case VIDIOC_G_CTRL:
                 return sn9c102_vidioc_g_ctrl(cam, arg);
 
-        case VIDIOC_S_CTRL_OLD:
         case VIDIOC_S_CTRL:
                 return sn9c102_vidioc_s_ctrl(cam, arg);
 
-        case VIDIOC_CROPCAP_OLD:
         case VIDIOC_CROPCAP:
                 return sn9c102_vidioc_cropcap(cam, arg);
 
@@ -2659,7 +2657,6 @@ static int sn9c102_ioctl_v4l2(struct inode* inode, struct file* filp,
         case VIDIOC_G_PARM:
                 return sn9c102_vidioc_g_parm(cam, arg);
 
-        case VIDIOC_S_PARM_OLD:
         case VIDIOC_S_PARM:
                 return sn9c102_vidioc_s_parm(cam, arg);
 
diff --git a/drivers/media/video/stradis.c b/drivers/media/video/stradis.c
index 07476c71174..6be9c1131e1 100644
--- a/drivers/media/video/stradis.c
+++ b/drivers/media/video/stradis.c
@@ -42,6 +42,7 @@
 #include <asm/uaccess.h>
 #include <linux/vmalloc.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 
 #include "saa7146.h"
 #include "saa7146reg.h"
diff --git a/drivers/media/video/stv680.c b/drivers/media/video/stv680.c
index b38bda83a7c..351b182d921 100644
--- a/drivers/media/video/stv680.c
+++ b/drivers/media/video/stv680.c
@@ -66,6 +66,7 @@
 #include <linux/pagemap.h>
 #include <linux/errno.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/usb.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/media/video/tda9875.c b/drivers/media/video/tda9875.c
index 103ccb91929..827633b3bb4 100644
--- a/drivers/media/video/tda9875.c
+++ b/drivers/media/video/tda9875.c
@@ -26,6 +26,7 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
 #include <linux/init.h>
@@ -163,7 +164,7 @@ static void do_tda9875_init(struct i2c_client *client)
         struct tda9875 *t = i2c_get_clientdata(client);
         dprintk("In tda9875_init\n");
         tda9875_write(client, TDA9875_CFG, 0xd0 ); /*reg de config 0 (reset)*/
-        tda9875_write(client, TDA9875_MSR, 0x03 );    /* Monitor 0b00000XXX*/
+        tda9875_write(client, TDA9875_MSR, 0x03 );    /* Monitor 0b00000XXX*/
         tda9875_write(client, TDA9875_C1MSB, 0x00 );  /*Car1(FM) MSB XMHz*/
         tda9875_write(client, TDA9875_C1MIB, 0x00 );  /*Car1(FM) MIB XMHz*/
         tda9875_write(client, TDA9875_C1LSB, 0x00 );  /*Car1(FM) LSB XMHz*/
diff --git a/drivers/media/video/tda9887.c b/drivers/media/video/tda9887.c
index 0d54f6c1982..b6ae969563b 100644
--- a/drivers/media/video/tda9887.c
+++ b/drivers/media/video/tda9887.c
@@ -18,49 +18,21 @@
    TDA9886 (PAL, SECAM, NTSC)
    TDA9887 (PAL, SECAM, NTSC, FM Radio)
 
-   found on:
-   - Pinnacle PCTV (Jul.2002 Version with MT2032, bttv)
-      TDA9887 (world), TDA9885 (USA)
-      Note: OP2 of tda988x must be set to 1, else MT2032 is disabled!
-   - KNC One TV-Station RDS (saa7134)
-   - Hauppauge PVR-150/500 (possibly more)
+   Used as part of several tuners
 */
 
+#define tda9887_info(fmt, arg...) do {\
+        printk(KERN_INFO "%s %d-%04x (tda9887): " fmt, t->i2c.name, \
+                        i2c_adapter_id(t->i2c.adapter), t->i2c.addr , ##arg); } while (0)
+#define tda9887_dbg(fmt, arg...) do {\
+        if (tuner_debug) \
+                printk(KERN_INFO "%s %d-%04x (tda9887): " fmt, t->i2c.name, \
+                        i2c_adapter_id(t->i2c.adapter), t->i2c.addr , ##arg); } while (0)
 
-/* Addresses to scan */
-static unsigned short normal_i2c[] = {
-        0x84 >>1,
-        0x86 >>1,
-        0x96 >>1,
-        I2C_CLIENT_END,
-};
-I2C_CLIENT_INSMOD;
-
-/* insmod options */
-static unsigned int debug = 0;
-module_param(debug, int, 0644);
-MODULE_LICENSE("GPL");
 
 /* ---------------------------------------------------------------------- */
 
 #define UNSET       (-1U)
-#define tda9887_info(fmt, arg...) do {\
-        printk(KERN_INFO "%s %d-%04x: " fmt, t->client.name, \
-                        i2c_adapter_id(t->client.adapter), t->client.addr , ##arg); } while (0)
-#define tda9887_dbg(fmt, arg...) do {\
-        if (debug) \
-                printk(KERN_INFO "%s %d-%04x: " fmt, t->client.name, \
-                        i2c_adapter_id(t->client.adapter), t->client.addr , ##arg); } while (0)
-
-struct tda9887 {
-        struct i2c_client  client;
-        v4l2_std_id        std;
-        enum tuner_mode    mode;
-        unsigned int       config;
-        unsigned int       using_v4l2;
-        unsigned int       radio_mode;
-        unsigned char      data[4];
-};
 
 struct tvnorm {
         v4l2_std_id       std;
@@ -70,9 +42,6 @@ struct tvnorm {
         unsigned char     e;
 };
 
-static struct i2c_driver driver;
-static struct i2c_client client_template;
-
 /* ---------------------------------------------------------------------- */
 
 //
@@ -281,7 +250,7 @@ static struct tvnorm radio_mono = {
 
 /* ---------------------------------------------------------------------- */
 
-static void dump_read_message(struct tda9887 *t, unsigned char *buf)
+static void dump_read_message(struct tuner *t, unsigned char *buf)
 {
         static char *afc[16] = {
                 "- 12.5 kHz",
@@ -309,7 +278,7 @@ static void dump_read_message(struct tda9887 *t, unsigned char *buf)
         tda9887_info("  vfi level      : %s\n", (buf[0] & 0x80) ? "high" : "low");
 }
 
-static void dump_write_message(struct tda9887 *t, unsigned char *buf)
+static void dump_write_message(struct tuner *t, unsigned char *buf)
 {
         static char *sound[4] = {
                 "AM/TV",
@@ -405,13 +374,13 @@ static void dump_write_message(struct tda9887 *t, unsigned char *buf)
 
 /* ---------------------------------------------------------------------- */
 
-static int tda9887_set_tvnorm(struct tda9887 *t, char *buf)
+static int tda9887_set_tvnorm(struct tuner *t, char *buf)
 {
         struct tvnorm *norm = NULL;
         int i;
 
-        if (t->mode == T_RADIO) {
-                if (t->radio_mode == V4L2_TUNER_MODE_MONO)
+        if (t->mode == V4L2_TUNER_RADIO) {
+                if (t->audmode == V4L2_TUNER_MODE_MONO)
                         norm = &radio_mono;
                 else
                         norm = &radio_stereo;
@@ -445,7 +414,7 @@ module_param(port2, int, 0644);
 module_param(qss, int, 0644);
 module_param(adjust, int, 0644);
 
-static int tda9887_set_insmod(struct tda9887 *t, char *buf)
+static int tda9887_set_insmod(struct tuner *t, char *buf)
 {
         if (UNSET != port1) {
                 if (port1)
@@ -474,27 +443,27 @@ static int tda9887_set_insmod(struct tda9887 *t, char *buf)
         return 0;
 }
 
-static int tda9887_set_config(struct tda9887 *t, char *buf)
+static int tda9887_set_config(struct tuner *t, char *buf)
 {
-        if (t->config & TDA9887_PORT1_ACTIVE)
+        if (t->tda9887_config & TDA9887_PORT1_ACTIVE)
                 buf[1] &= ~cOutputPort1Inactive;
-        if (t->config & TDA9887_PORT1_INACTIVE)
+        if (t->tda9887_config & TDA9887_PORT1_INACTIVE)
                 buf[1] |= cOutputPort1Inactive;
-        if (t->config & TDA9887_PORT2_ACTIVE)
+        if (t->tda9887_config & TDA9887_PORT2_ACTIVE)
                 buf[1] &= ~cOutputPort2Inactive;
-        if (t->config & TDA9887_PORT2_INACTIVE)
+        if (t->tda9887_config & TDA9887_PORT2_INACTIVE)
                 buf[1] |= cOutputPort2Inactive;
 
-        if (t->config & TDA9887_QSS)
+        if (t->tda9887_config & TDA9887_QSS)
                 buf[1] |= cQSS;
-        if (t->config & TDA9887_INTERCARRIER)
+        if (t->tda9887_config & TDA9887_INTERCARRIER)
                 buf[1] &= ~cQSS;
 
-        if (t->config & TDA9887_AUTOMUTE)
+        if (t->tda9887_config & TDA9887_AUTOMUTE)
                 buf[1] |= cAutoMuteFmActive;
-        if (t->config & TDA9887_DEEMPHASIS_MASK) {
+        if (t->tda9887_config & TDA9887_DEEMPHASIS_MASK) {
                 buf[2] &= ~0x60;
-                switch (t->config & TDA9887_DEEMPHASIS_MASK) {
+                switch (t->tda9887_config & TDA9887_DEEMPHASIS_MASK) {
                 case TDA9887_DEEMPHASIS_NONE:
                         buf[2] |= cDeemphasisOFF;
                         break;
@@ -506,153 +475,36 @@ static int tda9887_set_config(struct tda9887 *t, char *buf)
                         break;
                 }
         }
-        if (t->config & TDA9887_TOP_SET) {
+        if (t->tda9887_config & TDA9887_TOP_SET) {
                 buf[2] &= ~cTopMask;
-                buf[2] |= (t->config >> 8) & cTopMask;
+                buf[2] |= (t->tda9887_config >> 8) & cTopMask;
         }
-        if ((t->config & TDA9887_INTERCARRIER_NTSC) && (t->std & V4L2_STD_NTSC))
+        if ((t->tda9887_config & TDA9887_INTERCARRIER_NTSC) && (t->std & V4L2_STD_NTSC))
                 buf[1] &= ~cQSS;
         return 0;
 }
 
 /* ---------------------------------------------------------------------- */
 
-static char pal[] = "--";
-static char secam[] = "--";
-static char ntsc[] = "-";
-
-module_param_string(pal, pal, sizeof(pal), 0644);
-module_param_string(secam, secam, sizeof(secam), 0644);
-module_param_string(ntsc, ntsc, sizeof(ntsc), 0644);
-
-static int tda9887_fixup_std(struct tda9887 *t)
-{
-        /* get more precise norm info from insmod option */
-        if ((t->std & V4L2_STD_PAL) == V4L2_STD_PAL) {
-                switch (pal[0]) {
-                case 'b':
-                case 'B':
-                case 'g':
-                case 'G':
-                case 'h':
-                case 'H':
-                case 'n':
-                case 'N':
-                        if (pal[1] == 'c' || pal[1] == 'C') {
-                                tda9887_dbg("insmod fixup: PAL => PAL-Nc\n");
-                                t->std = V4L2_STD_PAL_Nc;
-                        } else {
-                                tda9887_dbg("insmod fixup: PAL => PAL-BGHN\n");
-                                t->std = V4L2_STD_PAL_BG | V4L2_STD_PAL_H | V4L2_STD_PAL_N;
-                        }
-                        break;
-                case 'i':
-                case 'I':
-                        tda9887_dbg("insmod fixup: PAL => PAL-I\n");
-                        t->std = V4L2_STD_PAL_I;
-                        break;
-                case 'd':
-                case 'D':
-                case 'k':
-                case 'K':
-                        tda9887_dbg("insmod fixup: PAL => PAL-DK\n");
-                        t->std = V4L2_STD_PAL_DK;
-                        break;
-                case 'm':
-                case 'M':
-                        tda9887_dbg("insmod fixup: PAL => PAL-M\n");
-                        t->std = V4L2_STD_PAL_M;
-                        break;
-                case '-':
-                        /* default parameter, do nothing */
-                        break;
-                default:
-                        tda9887_info("pal= argument not recognised\n");
-                        break;
-                }
-        }
-        if ((t->std & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
-                switch (secam[0]) {
-                case 'b':
-                case 'B':
-                case 'g':
-                case 'G':
-                case 'h':
-                case 'H':
-                        tda9887_dbg("insmod fixup: SECAM => SECAM-BGH\n");
-                        t->std = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H;
-                        break;
-                case 'd':
-                case 'D':
-                case 'k':
-                case 'K':
-                        tda9887_dbg("insmod fixup: SECAM => SECAM-DK\n");
-                        t->std = V4L2_STD_SECAM_DK;
-                        break;
-                case 'l':
-                case 'L':
-                        if (secam[1] == 'c' || secam[1] == 'C') {
-                                tda9887_dbg("insmod fixup: SECAM => SECAM-L'\n");
-                                t->std = V4L2_STD_SECAM_LC;
-                        } else {
-                                tda9887_dbg("insmod fixup: SECAM => SECAM-L\n");
-                                t->std = V4L2_STD_SECAM_L;
-                        }
-                        break;
-                case '-':
-                        /* default parameter, do nothing */
-                        break;
-                default:
-                        tda9887_info("secam= argument not recognised\n");
-                        break;
-                }
-        }
-        if ((t->std & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
-                switch (ntsc[0]) {
-                case 'm':
-                case 'M':
-                        tda9887_dbg("insmod fixup: NTSC => NTSC-M\n");
-                        t->std = V4L2_STD_NTSC_M;
-                        break;
-                case 'j':
-                case 'J':
-                        tda9887_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
-                        t->std = V4L2_STD_NTSC_M_JP;
-                        break;
-                case 'k':
-                case 'K':
-                        tda9887_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
-                        t->std = V4L2_STD_NTSC_M_KR;
-                        break;
-                case '-':
-                        /* default parameter, do nothing */
-                        break;
-                default:
-                        tda9887_info("ntsc= argument not recognised\n");
-                        break;
-                }
-        }
-        return 0;
-}
-
-static int tda9887_status(struct tda9887 *t)
+static int tda9887_status(struct tuner *t)
 {
         unsigned char buf[1];
         int rc;
 
         memset(buf,0,sizeof(buf));
-        if (1 != (rc = i2c_master_recv(&t->client,buf,1)))
+        if (1 != (rc = i2c_master_recv(&t->i2c,buf,1)))
                 tda9887_info("i2c i/o error: rc == %d (should be 1)\n",rc);
         dump_read_message(t, buf);
         return 0;
 }
 
-static int tda9887_configure(struct tda9887 *t)
+static void tda9887_configure(struct i2c_client *client)
 {
+        struct tuner *t = i2c_get_clientdata(client);
         int rc;
 
-        memset(t->data,0,sizeof(t->data));
-        tda9887_set_tvnorm(t,t->data);
+        memset(t->tda9887_data,0,sizeof(t->tda9887_data));
+        tda9887_set_tvnorm(t,t->tda9887_data);
 
         /* A note on the port settings:
            These settings tend to depend on the specifics of the board.
@@ -667,249 +519,84 @@ static int tda9887_configure(struct tda9887 *t)
            the ports should be set to active (0), but, again, that may
            differ depending on the precise hardware configuration.
          */
-        t->data[1] |= cOutputPort1Inactive;
-        t->data[1] |= cOutputPort2Inactive;
+        t->tda9887_data[1] |= cOutputPort1Inactive;
+        t->tda9887_data[1] |= cOutputPort2Inactive;
 
-        tda9887_set_config(t,t->data);
-        tda9887_set_insmod(t,t->data);
+        tda9887_set_config(t,t->tda9887_data);
+        tda9887_set_insmod(t,t->tda9887_data);
 
         if (t->mode == T_STANDBY) {
-                t->data[1] |= cForcedMuteAudioON;
+                t->tda9887_data[1] |= cForcedMuteAudioON;
         }
 
         tda9887_dbg("writing: b=0x%02x c=0x%02x e=0x%02x\n",
-                t->data[1],t->data[2],t->data[3]);
-        if (debug > 1)
-                dump_write_message(t, t->data);
+                t->tda9887_data[1],t->tda9887_data[2],t->tda9887_data[3]);
+        if (tuner_debug > 1)
+                dump_write_message(t, t->tda9887_data);
 
-        if (4 != (rc = i2c_master_send(&t->client,t->data,4)))
+        if (4 != (rc = i2c_master_send(&t->i2c,t->tda9887_data,4)))
                 tda9887_info("i2c i/o error: rc == %d (should be 4)\n",rc);
 
-        if (debug > 2) {
+        if (tuner_debug > 2) {
                 msleep_interruptible(1000);
                 tda9887_status(t);
         }
-        return 0;
 }
 
 /* ---------------------------------------------------------------------- */
 
-static int tda9887_attach(struct i2c_adapter *adap, int addr, int kind)
+static void tda9887_tuner_status(struct i2c_client *client)
 {
-        struct tda9887 *t;
-
-        client_template.adapter = adap;
-        client_template.addr    = addr;
-
-        if (NULL == (t = kzalloc(sizeof(*t), GFP_KERNEL)))
-                return -ENOMEM;
-
-        t->client      = client_template;
-        t->std         = 0;
-        t->radio_mode = V4L2_TUNER_MODE_STEREO;
-
-        tda9887_info("chip found @ 0x%x (%s)\n", addr<<1, adap->name);
-
-        i2c_set_clientdata(&t->client, t);
-        i2c_attach_client(&t->client);
-
-        return 0;
+        struct tuner *t = i2c_get_clientdata(client);
+        tda9887_info("Data bytes: b=0x%02x c=0x%02x e=0x%02x\n", t->tda9887_data[1], t->tda9887_data[2], t->tda9887_data[3]);
 }
 
-static int tda9887_probe(struct i2c_adapter *adap)
+static int tda9887_get_afc(struct i2c_client *client)
 {
-        if (adap->class & I2C_CLASS_TV_ANALOG)
-                return i2c_probe(adap, &addr_data, tda9887_attach);
-        return 0;
-}
+        struct tuner *t = i2c_get_clientdata(client);
+        static int AFC_BITS_2_kHz[] = {
+                -12500,  -37500,  -62500,  -97500,
+                -112500, -137500, -162500, -187500,
+                187500,  162500,  137500,  112500,
+                97500 ,  62500,   37500 ,  12500
+        };
+        int afc=0;
+        __u8 reg = 0;
 
-static int tda9887_detach(struct i2c_client *client)
-{
-        struct tda9887 *t = i2c_get_clientdata(client);
+        if (1 == i2c_master_recv(&t->i2c,&reg,1))
+                afc = AFC_BITS_2_kHz[(reg>>1)&0x0f];
 
-        i2c_detach_client(client);
-        kfree(t);
-        return 0;
+        return afc;
 }
 
-#define SWITCH_V4L2     if (!t->using_v4l2 && debug) \
-                          tda9887_info("switching to v4l2\n"); \
-                          t->using_v4l2 = 1;
-#define CHECK_V4L2      if (t->using_v4l2) { if (debug) \
-                          tda9887_info("ignore v4l1 call\n"); \
-                          return 0; }
-
-static int
-tda9887_command(struct i2c_client *client, unsigned int cmd, void *arg)
+static void tda9887_standby(struct i2c_client *client)
 {
-        struct tda9887 *t = i2c_get_clientdata(client);
-
-        switch (cmd) {
-
-        /* --- configuration --- */
-        case AUDC_SET_RADIO:
-        {
-                t->mode = T_RADIO;
-                tda9887_configure(t);
-                break;
-        }
-        case TUNER_SET_STANDBY:
-        {
-                t->mode = T_STANDBY;
-                tda9887_configure(t);
-                break;
-        }
-        case TDA9887_SET_CONFIG:
-        {
-                int *i = arg;
-
-                t->config = *i;
-                tda9887_configure(t);
-                break;
-        }
-        /* --- v4l ioctls --- */
-        /* take care: bttv does userspace copying, we'll get a
-           kernel pointer here... */
-        case VIDIOCSCHAN:
-        {
-                static const v4l2_std_id map[] = {
-                        [ VIDEO_MODE_PAL   ] = V4L2_STD_PAL,
-                        [ VIDEO_MODE_NTSC  ] = V4L2_STD_NTSC_M,
-                        [ VIDEO_MODE_SECAM ] = V4L2_STD_SECAM,
-                        [ 4 /* bttv */     ] = V4L2_STD_PAL_M,
-                        [ 5 /* bttv */     ] = V4L2_STD_PAL_N,
-                        [ 6 /* bttv */     ] = V4L2_STD_NTSC_M_JP,
-                };
-                struct video_channel *vc = arg;
-
-                CHECK_V4L2;
-                t->mode = T_ANALOG_TV;
-                if (vc->norm < ARRAY_SIZE(map))
-                        t->std = map[vc->norm];
-                tda9887_fixup_std(t);
-                tda9887_configure(t);
-                break;
-        }
-        case VIDIOC_S_STD:
-        {
-                v4l2_std_id *id = arg;
-
-                SWITCH_V4L2;
-                t->mode = T_ANALOG_TV;
-                t->std   = *id;
-                tda9887_fixup_std(t);
-                tda9887_configure(t);
-                break;
-        }
-        case VIDIOC_S_FREQUENCY:
-        {
-                struct v4l2_frequency *f = arg;
-
-                SWITCH_V4L2;
-                if (V4L2_TUNER_ANALOG_TV == f->type) {
-                        if (t->mode == T_ANALOG_TV)
-                                return 0;
-                        t->mode = T_ANALOG_TV;
-                }
-                if (V4L2_TUNER_RADIO == f->type) {
-                        if (t->mode == T_RADIO)
-                                return 0;
-                        t->mode = T_RADIO;
-                }
-                tda9887_configure(t);
-                break;
-        }
-        case VIDIOC_G_TUNER:
-        {
-                static int AFC_BITS_2_kHz[] = {
-                        -12500,  -37500,  -62500,  -97500,
-                        -112500, -137500, -162500, -187500,
-                        187500,  162500,  137500,  112500,
-                        97500 ,  62500,   37500 ,  12500
-                };
-                struct v4l2_tuner* tuner = arg;
-
-                if (t->mode == T_RADIO) {
-                        __u8 reg = 0;
-                        tuner->afc=0;
-                        if (1 == i2c_master_recv(&t->client,&reg,1))
-                                tuner->afc = AFC_BITS_2_kHz[(reg>>1)&0x0f];
-                }
-                break;
-        }
-        case VIDIOC_S_TUNER:
-        {
-                struct v4l2_tuner* tuner = arg;
-
-                if (t->mode == T_RADIO) {
-                        t->radio_mode = tuner->audmode;
-                        tda9887_configure (t);
-                }
-                break;
-        }
-        case VIDIOC_LOG_STATUS:
-        {
-                tda9887_info("Data bytes: b=0x%02x c=0x%02x e=0x%02x\n", t->data[1], t->data[2], t->data[3]);
-                break;
-        }
-        default:
-                /* nothing */
-                break;
-        }
-        return 0;
+        tda9887_configure(client);
 }
 
-static int tda9887_suspend(struct device * dev, pm_message_t state)
+static void tda9887_set_freq(struct i2c_client *client, unsigned int freq)
 {
-        struct i2c_client *c = container_of(dev, struct i2c_client, dev);
-        struct tda9887 *t = i2c_get_clientdata(c);
-
-        tda9887_dbg("suspend\n");
-        return 0;
+        tda9887_configure(client);
 }
 
-static int tda9887_resume(struct device * dev)
+int tda9887_tuner_init(struct i2c_client *c)
 {
-        struct i2c_client *c = container_of(dev, struct i2c_client, dev);
-        struct tda9887 *t = i2c_get_clientdata(c);
+        struct tuner *t = i2c_get_clientdata(c);
 
-        tda9887_dbg("resume\n");
-        tda9887_configure(t);
-        return 0;
-}
+        strlcpy(c->name, "tda9887", sizeof(c->name));
 
-/* ----------------------------------------------------------------------- */
-
-static struct i2c_driver driver = {
-        .id             = I2C_DRIVERID_TDA9887,
-        .attach_adapter = tda9887_probe,
-        .detach_client  = tda9887_detach,
-        .command        = tda9887_command,
-        .driver = {
-                .name    = "tda9887",
-                .suspend = tda9887_suspend,
-                .resume  = tda9887_resume,
-        },
-};
-static struct i2c_client client_template =
-{
-        .name      = "tda9887",
-        .driver    = &driver,
-};
+        tda9887_info("tda988[5/6/7] found @ 0x%x (%s)\n", t->i2c.addr,
+                                                t->i2c.driver->driver.name);
 
-static int __init tda9887_init_module(void)
-{
-        return i2c_add_driver(&driver);
-}
+        t->set_tv_freq = tda9887_set_freq;
+        t->set_radio_freq = tda9887_set_freq;
+        t->standby = tda9887_standby;
+        t->tuner_status=tda9887_tuner_status;
+        t->get_afc=tda9887_get_afc;
 
-static void __exit tda9887_cleanup_module(void)
-{
-        i2c_del_driver(&driver);
+        return 0;
 }
 
-module_init(tda9887_init_module);
-module_exit(tda9887_cleanup_module);
-
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * ---------------------------------------------------------------------------
diff --git a/drivers/media/video/tea5767.c b/drivers/media/video/tea5767.c
index c2b98f81c19..d1c41781ccc 100644
--- a/drivers/media/video/tea5767.c
+++ b/drivers/media/video/tea5767.c
@@ -3,7 +3,7 @@
  * I2C address is allways 0xC0.
  *
  *
- * Copyright (c) 2005 Mauro Carvalho Chehab (mchehab@brturbo.com.br)
+ * Copyright (c) 2005 Mauro Carvalho Chehab (mchehab@infradead.org)
  * This code is placed under the terms of the GNU General Public License
  *
  * tea5767 autodetection thanks to Torsten Seeboth and Atsushi Nakagawa
diff --git a/drivers/media/video/tlv320aic23b.c b/drivers/media/video/tlv320aic23b.c
new file mode 100644
index 00000000000..76b2e96429d
--- /dev/null
+++ b/drivers/media/video/tlv320aic23b.c
@@ -0,0 +1,217 @@
+/*
+ * tlv320aic23b - driver version 0.0.1
+ *
+ * Copyright (C) 2006 Scott Alfter <salfter@ssai.us>
+ *
+ * Based on wm8775 driver
+ *
+ * Copyright (C) 2004 Ulf Eklund <ivtv at eklund.to>
+ * Copyright (C) 2005 Hans Verkuil <hverkuil@xs4all.nl>
+ *
+ * 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/types.h>
+#include <linux/ioctl.h>
+#include <asm/uaccess.h>
+#include <linux/i2c.h>
+#include <linux/i2c-id.h>
+#include <linux/videodev.h>
+#include <media/v4l2-common.h>
+
+MODULE_DESCRIPTION("tlv320aic23b driver");
+MODULE_AUTHOR("Scott Alfter, Ulf Eklund, Hans Verkuil");
+MODULE_LICENSE("GPL");
+
+static unsigned short normal_i2c[] = { 0x34 >> 1, I2C_CLIENT_END };
+
+
+I2C_CLIENT_INSMOD;
+
+/* ----------------------------------------------------------------------- */
+
+struct tlv320aic23b_state {
+        u8 muted;
+};
+
+static int tlv320aic23b_write(struct i2c_client *client, int reg, u16 val)
+{
+        int i;
+
+        if ((reg < 0 || reg > 9) && (reg != 15)) {
+                v4l_err(client, "Invalid register R%d\n", reg);
+                return -1;
+        }
+
+        for (i = 0; i < 3; i++) {
+                if (i2c_smbus_write_byte_data(client, (reg << 1) |
+                                        (val >> 8), val & 0xff) == 0) {
+                        return 0;
+                }
+        }
+        v4l_err(client, "I2C: cannot write %03x to register R%d\n", val, reg);
+        return -1;
+}
+
+static int tlv320aic23b_command(struct i2c_client *client, unsigned int cmd,
+                          void *arg)
+{
+        struct tlv320aic23b_state *state = i2c_get_clientdata(client);
+        struct v4l2_control *ctrl = arg;
+        u32* freq = arg;
+
+        switch (cmd) {
+        case VIDIOC_INT_AUDIO_CLOCK_FREQ:
+                switch (*freq) {
+                        case 32000: /* set sample rate to 32 kHz */
+                                tlv320aic23b_write(client, 8, 0x018);
+                                break;
+                        case 44100: /* set sample rate to 44.1 kHz */
+                                tlv320aic23b_write(client, 8, 0x022);
+                                break;
+                        case 48000: /* set sample rate to 48 kHz */
+                                tlv320aic23b_write(client, 8, 0x000);
+                                break;
+                        default:
+                                return -EINVAL;
+                }
+                break;
+
+        case VIDIOC_G_CTRL:
+                if (ctrl->id != V4L2_CID_AUDIO_MUTE)
+                        return -EINVAL;
+                ctrl->value = state->muted;
+                break;
+
+        case VIDIOC_S_CTRL:
+                if (ctrl->id != V4L2_CID_AUDIO_MUTE)
+                        return -EINVAL;
+                state->muted = ctrl->value;
+                tlv320aic23b_write(client, 0, 0x180); /* mute both channels */
+                /* set gain on both channels to +3.0 dB */
+                if (!state->muted)
+                        tlv320aic23b_write(client, 0, 0x119);
+                break;
+
+        case VIDIOC_LOG_STATUS:
+                v4l_info(client, "Input: %s\n",
+                            state->muted ? "muted" : "active");
+                break;
+
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+
+/* i2c implementation */
+
+/*
+ * Generic i2c probe
+ * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
+ */
+
+static struct i2c_driver i2c_driver;
+
+static int tlv320aic23b_attach(struct i2c_adapter *adapter, int address, int kind)
+{
+        struct i2c_client *client;
+        struct tlv320aic23b_state *state;
+
+        /* Check if the adapter supports the needed features */
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return 0;
+
+        client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
+        if (client == 0)
+                return -ENOMEM;
+
+        client->addr = address;
+        client->adapter = adapter;
+        client->driver = &i2c_driver;
+        snprintf(client->name, sizeof(client->name) - 1, "tlv320aic23b");
+
+        v4l_info(client, "chip found @ 0x%x (%s)\n", address << 1, adapter->name);
+
+        state = kmalloc(sizeof(struct tlv320aic23b_state), GFP_KERNEL);
+        if (state == NULL) {
+                kfree(client);
+                return -ENOMEM;
+        }
+        state->muted = 0;
+        i2c_set_clientdata(client, state);
+
+        /* initialize tlv320aic23b */
+        tlv320aic23b_write(client, 15, 0x000);  /* RESET */
+        tlv320aic23b_write(client, 6, 0x00A);   /* turn off DAC & mic input */
+        tlv320aic23b_write(client, 7, 0x049);   /* left-justified, 24-bit, master mode */
+        tlv320aic23b_write(client, 0, 0x119);   /* set gain on both channels to +3.0 dB */
+        tlv320aic23b_write(client, 8, 0x000);   /* set sample rate to 48 kHz */
+        tlv320aic23b_write(client, 9, 0x001);   /* activate digital interface */
+
+        i2c_attach_client(client);
+
+        return 0;
+}
+
+static int tlv320aic23b_probe(struct i2c_adapter *adapter)
+{
+        if (adapter->class & I2C_CLASS_TV_ANALOG)
+                return i2c_probe(adapter, &addr_data, tlv320aic23b_attach);
+        return 0;
+}
+
+static int tlv320aic23b_detach(struct i2c_client *client)
+{
+        int err;
+
+        err = i2c_detach_client(client);
+        if (err) {
+                return err;
+        }
+        kfree(client);
+
+        return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+
+/* i2c implementation */
+static struct i2c_driver i2c_driver = {
+        .driver = {
+                .name = "tlv320aic23b",
+        },
+        .id             = I2C_DRIVERID_TLV320AIC23B,
+        .attach_adapter = tlv320aic23b_probe,
+        .detach_client  = tlv320aic23b_detach,
+        .command        = tlv320aic23b_command,
+};
+
+
+static int __init tlv320aic23b_init_module(void)
+{
+        return i2c_add_driver(&i2c_driver);
+}
+
+static void __exit tlv320aic23b_cleanup_module(void)
+{
+        i2c_del_driver(&i2c_driver);
+}
+
+module_init(tlv320aic23b_init_module);
+module_exit(tlv320aic23b_cleanup_module);
diff --git a/drivers/media/video/tuner-3036.c b/drivers/media/video/tuner-3036.c
index 74ab48c09c6..bdf506e6ae2 100644
--- a/drivers/media/video/tuner-3036.c
+++ b/drivers/media/video/tuner-3036.c
@@ -25,6 +25,7 @@
 
 #include <linux/i2c.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 
 #include <media/tuner.h>
 
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 1013b4de89a..e95792fd70f 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -199,7 +199,7 @@ static void set_type(struct i2c_client *c, unsigned int type,
                 i2c_master_send(c, buffer, 4);
                 default_tuner_init(c);
                 break;
-        case TUNER_LG_TDVS_H062F:
+        case TUNER_LG_TDVS_H06XF:
                 /* Set the Auxiliary Byte. */
                 buffer[2] &= ~0x20;
                 buffer[2] |= 0x18;
@@ -215,6 +215,9 @@ static void set_type(struct i2c_client *c, unsigned int type,
                 i2c_master_send(c,buffer,4);
                 default_tuner_init(c);
                 break;
+        case TUNER_TDA9887:
+                tda9887_tuner_init(c);
+                break;
         default:
                 default_tuner_init(c);
                 break;
@@ -241,6 +244,8 @@ static void set_addr(struct i2c_client *c, struct tuner_setup *tun_setup)
 {
         struct tuner *t = i2c_get_clientdata(c);
 
+        tuner_dbg("set addr for type %i\n", t->type);
+
         if ( t->type == UNSET && ((tun_setup->addr == ADDR_UNSET &&
                 (t->mode_mask & tun_setup->mode_mask)) ||
                 tun_setup->addr == c->addr)) {
@@ -436,6 +441,7 @@ static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
         t->radio_if2 = 10700 * 1000;    /* 10.7MHz - FM radio */
         t->audmode = V4L2_TUNER_MODE_STEREO;
         t->mode_mask = T_UNINITIALIZED;
+        t->tuner_status = tuner_status;
         if (tuner_debug_old) {
                 tuner_debug = tuner_debug_old;
                 printk(KERN_ERR "tuner: tuner_debug is deprecated and will be removed in 2.6.17.\n");
@@ -462,10 +468,14 @@ static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
                 case 0x4b:
                         /* If chip is not tda8290, don't register.
                            since it can be tda9887*/
-                        if (tda8290_probe(&t->i2c) != 0) {
-                                tuner_dbg("chip at addr %x is not a tda8290\n", addr);
-                                kfree(t);
-                                return 0;
+                        if (tda8290_probe(&t->i2c) == 0) {
+                                tuner_dbg("chip at addr %x is a tda8290\n", addr);
+                        } else {
+                                /* Default is being tda9887 */
+                                t->type = TUNER_TDA9887;
+                                t->mode_mask = T_RADIO | T_ANALOG_TV | T_DIGITAL_TV;
+                                t->mode = T_STANDBY;
+                                goto register_client;
                         }
                         break;
                 case 0x60:
@@ -592,6 +602,7 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
         case TUNER_SET_STANDBY:
                 if (check_mode(t, "TUNER_SET_STANDBY") == EINVAL)
                         return 0;
+                t->mode = T_STANDBY;
                 if (t->standby)
                         t->standby (client);
                 break;
@@ -604,6 +615,14 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                 /* Should be implemented, since bttv calls it */
                 tuner_dbg("VIDIOCSAUDIO not implemented.\n");
                 break;
+        case TDA9887_SET_CONFIG:
+        {
+                int *i = arg;
+
+                t->tda9887_config = *i;
+                set_freq(client, t->tv_freq);
+                break;
+        }
         /* --- v4l ioctls --- */
         /* take care: bttv does userspace copying, we'll get a
            kernel pointer here... */
@@ -744,6 +763,8 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                         switch_v4l2();
 
                         tuner->type = t->mode;
+                        if (t->get_afc)
+                                tuner->afc=t->get_afc(client);
                         if (t->mode == V4L2_TUNER_ANALOG_TV)
                                 tuner->capability |= V4L2_TUNER_CAP_NORM;
                         if (t->mode != V4L2_TUNER_RADIO) {
@@ -787,7 +808,8 @@ static int tuner_command(struct i2c_client *client, unsigned int cmd, void *arg)
                         break;
                 }
         case VIDIOC_LOG_STATUS:
-                tuner_status(client);
+                if (t->tuner_status)
+                        t->tuner_status(client);
                 break;
         }
 
diff --git a/drivers/media/video/tuner-simple.c b/drivers/media/video/tuner-simple.c
index 5d7abed7167..6da6f82b8c8 100644
--- a/drivers/media/video/tuner-simple.c
+++ b/drivers/media/video/tuner-simple.c
@@ -105,7 +105,7 @@ static int tuner_stereo(struct i2c_client *c)
 
         switch (t->type) {
                 case TUNER_PHILIPS_FM1216ME_MK3:
-                case TUNER_PHILIPS_FM1236_MK3:
+                case TUNER_PHILIPS_FM1236_MK3:
                 case TUNER_PHILIPS_FM1256_IH3:
                         stereo = ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3);
                         break;
diff --git a/drivers/media/video/tuner-types.c b/drivers/media/video/tuner-types.c
index a1ae036b44e..9d9226cb639 100644
--- a/drivers/media/video/tuner-types.c
+++ b/drivers/media/video/tuner-types.c
@@ -874,7 +874,7 @@ static struct tuner_params tuner_philips_fmd1216me_mk3_params[] = {
 };
 
 
-/* ------------ TUNER_LG_TDVS_H062F - INFINEON ATSC ------------ */
+/* ------ TUNER_LG_TDVS_H06XF - LG INNOTEK / INFINEON ATSC ----- */
 
 static struct tuner_range tuner_tua6034_ntsc_ranges[] = {
         { 16 * 165.00 /*MHz*/, 0x8e, 0x01 },
@@ -883,7 +883,7 @@ static struct tuner_range tuner_tua6034_ntsc_ranges[] = {
 };
 
 
-static struct tuner_params tuner_tua6034_params[] = {
+static struct tuner_params tuner_lg_tdvs_h06xf_params[] = {
         {
                 .type   = TUNER_PARAM_TYPE_NTSC,
                 .ranges = tuner_tua6034_ntsc_ranges,
@@ -1024,6 +1024,22 @@ static struct tuner_params tuner_thomson_fe6600_params[] = {
         },
 };
 
+/* ------------ TUNER_SAMSUNG_TCPG_6121P30A - Samsung PAL ------------ */
+
+static struct tuner_range tuner_samsung_tcpg_6121p30a_pal_ranges[] = {
+        { 16 * 146.25 /*MHz*/, 0xce, 0x01, },
+        { 16 * 428.50 /*MHz*/, 0xce, 0x02, },
+        { 16 * 999.99        , 0xce, 0x08, },
+};
+
+static struct tuner_params tuner_samsung_tcpg_6121p30a_params[] = {
+        {
+                .type   = TUNER_PARAM_TYPE_PAL,
+                .ranges = tuner_samsung_tcpg_6121p30a_pal_ranges,
+                .count  = ARRAY_SIZE(tuner_samsung_tcpg_6121p30a_pal_ranges),
+        },
+};
+
 /* --------------------------------------------------------------------- */
 
 struct tunertype tuners[] = {
@@ -1354,10 +1370,10 @@ struct tunertype tuners[] = {
                 .params = tuner_philips_fmd1216me_mk3_params,
                 .count  = ARRAY_SIZE(tuner_philips_fmd1216me_mk3_params),
         },
-        [TUNER_LG_TDVS_H062F] = { /* LGINNOTEK ATSC */
-                .name   = "LG TDVS-H062F/TUA6034",
-                .params = tuner_tua6034_params,
-                .count  = ARRAY_SIZE(tuner_tua6034_params),
+        [TUNER_LG_TDVS_H06XF] = { /* LGINNOTEK ATSC */
+                .name   = "LG TDVS-H06xF", /* H061F, H062F & H064F */
+                .params = tuner_lg_tdvs_h06xf_params,
+                .count  = ARRAY_SIZE(tuner_lg_tdvs_h06xf_params),
         },
         [TUNER_YMEC_TVF66T5_B_DFF] = { /* Philips PAL */
                 .name   = "Ymec TVF66T5-B/DFF",
@@ -1400,6 +1416,16 @@ struct tunertype tuners[] = {
                 .params = tuner_thomson_fe6600_params,
                 .count  = ARRAY_SIZE(tuner_thomson_fe6600_params),
         },
+        [TUNER_SAMSUNG_TCPG_6121P30A] = { /* Samsung PAL */
+                .name   = "Samsung TCPG 6121P30A",
+                .params = tuner_samsung_tcpg_6121p30a_params,
+                .count  = ARRAY_SIZE(tuner_samsung_tcpg_6121p30a_params),
+        },
+        [TUNER_TDA9887] = { /* Philips TDA 9887 IF PLL Demodulator.
+                                This chip is part of some modern tuners */
+                .name   = "Philips TDA988[5,6,7] IF PLL Demodulator",
+                /* see tda9887.c for details */
+        },
 };
 
 unsigned const int tuner_count = ARRAY_SIZE(tuners);
diff --git a/drivers/media/video/tveeprom.c b/drivers/media/video/tveeprom.c
index b463e996961..30f8d80ddca 100644
--- a/drivers/media/video/tveeprom.c
+++ b/drivers/media/video/tveeprom.c
@@ -200,7 +200,7 @@ hauppauge_tuner[] =
         { TUNER_ABSENT,        "Philips FQ1286A MK4"},
         { TUNER_ABSENT,        "Philips FQ1216ME MK5"},
         { TUNER_ABSENT,        "Philips FQ1236 MK5"},
-        { TUNER_ABSENT,        "Samsung TCPG_6121P30A"},
+        { TUNER_SAMSUNG_TCPG_6121P30A, "Samsung TCPG 6121P30A"},
         { TUNER_TCL_2002MB,    "TCL 2002MB_3H"},
         { TUNER_ABSENT,        "TCL 2002MI_3H"},
         { TUNER_TCL_2002N,     "TCL 2002N 5H"},
diff --git a/drivers/media/video/tvmixer.c b/drivers/media/video/tvmixer.c
index 9e86caeb96a..1654576de10 100644
--- a/drivers/media/video/tvmixer.c
+++ b/drivers/media/video/tvmixer.c
@@ -198,10 +198,6 @@ static int tvmixer_open(struct inode *inode, struct file *file)
 
         /* lock bttv in memory while the mixer is in use  */
         file->private_data = mix;
-#ifndef I2C_PEC
-        if (client->adapter->inc_use)
-                client->adapter->inc_use(client->adapter);
-#endif
         if (client->adapter->owner)
                 try_module_get(client->adapter->owner);
         return 0;
@@ -217,10 +213,6 @@ static int tvmixer_release(struct inode *inode, struct file *file)
                 return -ENODEV;
         }
 
-#ifndef I2C_PEC
-        if (client->adapter->dec_use)
-                client->adapter->dec_use(client->adapter);
-#endif
         if (client->adapter->owner)
                 module_put(client->adapter->owner);
         return 0;
diff --git a/drivers/media/video/tvp5150.c b/drivers/media/video/tvp5150.c
index dab4973bcf8..b167ffab252 100644
--- a/drivers/media/video/tvp5150.c
+++ b/drivers/media/video/tvp5150.c
@@ -10,6 +10,7 @@
 #include <linux/delay.h>
 #include <linux/video_decoder.h>
 #include <media/v4l2-common.h>
+#include <media/tvp5150.h>
 
 #include "tvp5150_reg.h"
 
@@ -89,7 +90,7 @@ struct tvp5150 {
         struct i2c_client *client;
 
         v4l2_std_id norm;       /* Current set standard */
-        int input;
+        struct v4l2_routing route;
         int enable;
         int bright;
         int contrast;
@@ -283,29 +284,26 @@ static void dump_reg(struct i2c_client *c)
 /****************************************************************************
                         Basic functions
  ****************************************************************************/
-enum tvp5150_input {
-        TVP5150_ANALOG_CH0 = 0,
-        TVP5150_SVIDEO = 1,
-        TVP5150_ANALOG_CH1 = 2,
-        TVP5150_BLACK_SCREEN = 8
-};
 
-static inline void tvp5150_selmux(struct i2c_client *c,
-                                  enum tvp5150_input input)
+static inline void tvp5150_selmux(struct i2c_client *c)
 {
         int opmode=0;
-
         struct tvp5150 *decoder = i2c_get_clientdata(c);
+        int input = 0;
 
-        if (!decoder->enable)
-                input |= TVP5150_BLACK_SCREEN;
+        if ((decoder->route.output & TVP5150_BLACK_SCREEN) || !decoder->enable)
+                input = 8;
 
         switch (input) {
-        case TVP5150_ANALOG_CH0:
-        case TVP5150_ANALOG_CH1:
+        case TVP5150_COMPOSITE1:
+                input |= 2;
+                /* fall through */
+        case TVP5150_COMPOSITE0:
                 opmode=0x30;            /* TV Mode */
                 break;
+        case TVP5150_SVIDEO:
         default:
+                input |= 1;
                 opmode=0;               /* Auto Mode */
                 break;
         }
@@ -790,7 +788,7 @@ static inline void tvp5150_reset(struct i2c_client *c)
         tvp5150_vdp_init(c, vbi_ram_default);
 
         /* Selects decoder input */
-        tvp5150_selmux(c, decoder->input);
+        tvp5150_selmux(c);
 
         /* Initializes TVP5150 to stream enabled values */
         tvp5150_write_inittab(c, tvp5150_init_enable);
@@ -860,6 +858,21 @@ static int tvp5150_command(struct i2c_client *c,
         case VIDIOC_INT_RESET:
                 tvp5150_reset(c);
                 break;
+        case VIDIOC_INT_G_VIDEO_ROUTING:
+        {
+                struct v4l2_routing *route = arg;
+
+                *route = decoder->route;
+                break;
+        }
+        case VIDIOC_INT_S_VIDEO_ROUTING:
+        {
+                struct v4l2_routing *route = arg;
+
+                decoder->route = *route;
+                tvp5150_selmux(c);
+                break;
+        }
         case VIDIOC_S_STD:
                 if (decoder->norm == *(v4l2_std_id *)arg)
                         break;
@@ -1063,7 +1076,7 @@ static int tvp5150_detect_client(struct i2c_adapter *adapter,
         rv = i2c_attach_client(c);
 
         core->norm = V4L2_STD_ALL;      /* Default is autodetect */
-        core->input = 2;
+        core->route.input = TVP5150_COMPOSITE1;
         core->enable = 1;
         core->bright = 32768;
         core->contrast = 32768;
diff --git a/drivers/media/video/usbvideo/Kconfig b/drivers/media/video/usbvideo/Kconfig
index 39269a2c563..59fb899f31f 100644
--- a/drivers/media/video/usbvideo/Kconfig
+++ b/drivers/media/video/usbvideo/Kconfig
@@ -36,3 +36,15 @@ config USB_KONICAWC
 
           To compile this driver as a module, choose M here: the
           module will be called konicawc.
+
+config USB_QUICKCAM_MESSENGER
+        tristate "USB Logitech Quickcam Messenger"
+        depends on USB && VIDEO_DEV
+        select VIDEO_USBVIDEO
+        ---help---
+          Say Y or M here to enable support for the USB Logitech Quickcam
+          Messenger webcam.
+
+          To compile this driver as a module, choose M here: the
+          module will be called quickcam_messenger.
+
diff --git a/drivers/media/video/usbvideo/Makefile b/drivers/media/video/usbvideo/Makefile
index bb52eb8dc2f..4a1b144bee4 100644
--- a/drivers/media/video/usbvideo/Makefile
+++ b/drivers/media/video/usbvideo/Makefile
@@ -2,3 +2,4 @@ obj-$(CONFIG_VIDEO_USBVIDEO)    += usbvideo.o
 obj-$(CONFIG_USB_IBMCAM)        += ibmcam.o ultracam.o
 obj-$(CONFIG_USB_KONICAWC)      += konicawc.o
 obj-$(CONFIG_USB_VICAM)         += vicam.o
+obj-$(CONFIG_USB_QUICKCAM_MESSENGER)    += quickcam_messenger.o
diff --git a/drivers/media/video/usbvideo/quickcam_messenger.c b/drivers/media/video/usbvideo/quickcam_messenger.c
new file mode 100644
index 00000000000..3f3182a24da
--- /dev/null
+++ b/drivers/media/video/usbvideo/quickcam_messenger.c
@@ -0,0 +1,1120 @@
+/*
+ * Driver for Logitech Quickcam Messenger usb video camera
+ * Copyright (C) Jaya Kumar
+ *
+ * This work was sponsored by CIS(M) Sdn Bhd.
+ * History:
+ * 05/08/2006 - Jaya Kumar
+ * I wrote this based on the konicawc by Simon Evans.
+ * -
+ * Full credit for reverse engineering and creating an initial
+ * working linux driver for the VV6422 goes to the qce-ga project by
+ * Tuukka Toivonen, Jochen Hoenicke, Peter McConnell,
+ * Cristiano De Michele, Georg Acher, Jean-Frederic Clere as well as
+ * others.
+ * ---
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/usb_input.h>
+
+#include "usbvideo.h"
+#include "quickcam_messenger.h"
+
+/*
+ * Version Information
+ */
+
+#ifdef CONFIG_USB_DEBUG
+static int debug;
+#define DEBUG(n, format, arg...) \
+        if (n <= debug) {        \
+                printk(KERN_DEBUG __FILE__ ":%s(): " format "\n", __FUNCTION__ , ## arg); \
+        }
+#else
+#define DEBUG(n, arg...)
+static const int debug = 0;
+#endif
+
+#define DRIVER_VERSION "v0.01"
+#define DRIVER_DESC "Logitech Quickcam Messenger USB"
+
+#define USB_LOGITECH_VENDOR_ID  0x046D
+#define USB_QCM_PRODUCT_ID      0x08F0
+
+#define MAX_CAMERAS     1
+
+#define MAX_COLOUR      32768
+#define MAX_HUE         32768
+#define MAX_BRIGHTNESS  32768
+#define MAX_CONTRAST    32768
+#define MAX_WHITENESS   32768
+
+static int size = SIZE_320X240;
+static int colour = MAX_COLOUR;
+static int hue = MAX_HUE;
+static int brightness = MAX_BRIGHTNESS;
+static int contrast =   MAX_CONTRAST;
+static int whiteness =  MAX_WHITENESS;
+
+static struct usbvideo *cams;
+
+static struct usb_device_id qcm_table [] = {
+        { USB_DEVICE(USB_LOGITECH_VENDOR_ID, USB_QCM_PRODUCT_ID) },
+        { }
+};
+MODULE_DEVICE_TABLE(usb, qcm_table);
+
+#ifdef CONFIG_INPUT
+static void qcm_register_input(struct qcm *cam, struct usb_device *dev)
+{
+        struct input_dev *input_dev;
+
+        usb_make_path(dev, cam->input_physname, sizeof(cam->input_physname));
+        strncat(cam->input_physname, "/input0", sizeof(cam->input_physname));
+
+        cam->input = input_dev = input_allocate_device();
+        if (!input_dev) {
+                warn("insufficient mem for cam input device");
+                return;
+        }
+
+        input_dev->name = "QCM button";
+        input_dev->phys = cam->input_physname;
+        usb_to_input_id(dev, &input_dev->id);
+        input_dev->cdev.dev = &dev->dev;
+
+        input_dev->evbit[0] = BIT(EV_KEY);
+        input_dev->keybit[LONG(BTN_0)] = BIT(BTN_0);
+
+        input_dev->private = cam;
+
+        input_register_device(cam->input);
+}
+
+static void qcm_unregister_input(struct qcm *cam)
+{
+        if (cam->input) {
+                input_unregister_device(cam->input);
+                cam->input = NULL;
+        }
+}
+
+static void qcm_report_buttonstat(struct qcm *cam)
+{
+        if (cam->input) {
+                input_report_key(cam->input, BTN_0, cam->button_sts);
+                input_sync(cam->input);
+        }
+}
+
+static void qcm_int_irq(struct urb *urb, struct pt_regs *regs)
+{
+        int ret;
+        struct uvd *uvd = urb->context;
+        struct qcm *cam;
+
+        if (!CAMERA_IS_OPERATIONAL(uvd))
+                return;
+
+        if (!uvd->streaming)
+                return;
+
+        uvd->stats.urb_count++;
+
+        if (urb->status < 0)
+                uvd->stats.iso_err_count++;
+        else {
+                if (urb->actual_length > 0 ) {
+                        cam = (struct qcm *) uvd->user_data;
+                        if (cam->button_sts_buf == 0x88)
+                                cam->button_sts = 0x0;
+                        else if (cam->button_sts_buf == 0x80)
+                                cam->button_sts = 0x1;
+                        qcm_report_buttonstat(cam);
+                }
+        }
+
+        ret = usb_submit_urb(urb, GFP_ATOMIC);
+        if (ret < 0)
+                err("usb_submit_urb error (%d)", ret);
+}
+
+static int qcm_setup_input_int(struct qcm *cam, struct uvd *uvd)
+{
+        int errflag;
+        usb_fill_int_urb(cam->button_urb, uvd->dev,
+                        usb_rcvintpipe(uvd->dev, uvd->video_endp + 1),
+                        &cam->button_sts_buf,
+                        1,
+                        qcm_int_irq,
+                        uvd, 16);
+
+        errflag = usb_submit_urb(cam->button_urb, GFP_KERNEL);
+        if (errflag)
+                err ("usb_submit_int ret %d", errflag);
+        return errflag;
+}
+
+static void qcm_stop_int_data(struct qcm *cam)
+{
+        usb_kill_urb(cam->button_urb);
+}
+
+static int qcm_alloc_int_urb(struct qcm *cam)
+{
+        cam->button_urb = usb_alloc_urb(0, GFP_KERNEL);
+
+        if (!cam->button_urb)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void qcm_free_int(struct qcm *cam)
+{
+        if (cam->button_urb)
+                usb_free_urb(cam->button_urb);
+}
+#endif /* CONFIG_INPUT */
+
+static int qcm_stv_setb(struct usb_device *dev, u16 reg, u8 val)
+{
+        int ret;
+
+        /* we'll wait up to 3 slices but no more */
+        ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+                0x04, USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
+                reg, 0, &val, 1, 3*HZ);
+        return ret;
+}
+
+static int qcm_stv_setw(struct usb_device *dev, u16 reg, u16 val)
+{
+        int ret;
+
+        /* we'll wait up to 3 slices but no more */
+        ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+                0x04, USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
+                reg, 0, &val, 2, 3*HZ);
+        return ret;
+}
+
+static int qcm_stv_getw(struct usb_device *dev, unsigned short reg,
+                                                        __le16 *val)
+{
+        int ret;
+
+        /* we'll wait up to 3 slices but no more */
+        ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                0x04, USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
+                reg, 0, val, 2, 3*HZ);
+        return ret;
+}
+
+static int qcm_camera_on(struct uvd *uvd)
+{
+        int ret;
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x01));
+        return 0;
+}
+
+static int qcm_camera_off(struct uvd *uvd)
+{
+        int ret;
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x00));
+        return 0;
+}
+
+static void qcm_hsv2rgb(u16 hue, u16 sat, u16 val, u16 *r, u16 *g, u16 *b)
+{
+        unsigned int segment, valsat;
+        signed int   h = (signed int) hue;
+        unsigned int s = (sat - 32768) * 2;     /* rescale */
+        unsigned int v = val;
+        unsigned int p;
+
+        /*
+        the registers controling gain are 8 bit of which
+        we affect only the last 4 bits with our gain.
+        we know that if saturation is 0, (unsaturated) then
+        we're grayscale (center axis of the colour cone) so
+        we set rgb=value. we use a formula obtained from
+        wikipedia to map the cone to the RGB plane. it's
+        as follows for the human value case of h=0..360,
+        s=0..1, v=0..1
+        h_i = h/60 % 6 , f = h/60 - h_i , p = v(1-s)
+        q = v(1 - f*s) , t = v(1 - (1-f)s)
+        h_i==0 => r=v , g=t, b=p
+        h_i==1 => r=q , g=v, b=p
+        h_i==2 => r=p , g=v, b=t
+        h_i==3 => r=p , g=q, b=v
+        h_i==4 => r=t , g=p, b=v
+        h_i==5 => r=v , g=p, b=q
+        the bottom side (the point) and the stuff just up
+        of that is black so we simplify those two cases.
+        */
+        if (sat < 32768) {
+                /* anything less than this is unsaturated */
+                *r = val;
+                *g = val;
+                *b = val;
+                return;
+        }
+        if (val <= (0xFFFF/8)) {
+                /* anything less than this is black */
+                *r = 0;
+                *g = 0;
+                *b = 0;
+                return;
+        }
+
+        /* the rest of this code is copying tukkat's
+        implementation of the hsv2rgb conversion as taken
+        from qc-usb-messenger code. the 10923 is 0xFFFF/6
+        to divide the cone into 6 sectors.  */
+
+        segment = (h + 10923) & 0xFFFF;
+        segment = segment*3 >> 16;              /* 0..2: 0=R, 1=G, 2=B */
+        hue -= segment * 21845;                 /* -10923..10923 */
+        h = hue;
+        h *= 3;
+        valsat = v*s >> 16;                     /* 0..65534 */
+        p = v - valsat;
+        if (h >= 0) {
+                unsigned int t = v - (valsat * (32769 - h) >> 15);
+                switch (segment) {
+                case 0: /* R-> */
+                        *r = v;
+                        *g = t;
+                        *b = p;
+                        break;
+                case 1: /* G-> */
+                        *r = p;
+                        *g = v;
+                        *b = t;
+                        break;
+                case 2: /* B-> */
+                        *r = t;
+                        *g = p;
+                        *b = v;
+                        break;
+                }
+        } else {
+                unsigned int q = v - (valsat * (32769 + h) >> 15);
+                switch (segment) {
+                case 0: /* ->R */
+                        *r = v;
+                        *g = p;
+                        *b = q;
+                        break;
+                case 1: /* ->G */
+                        *r = q;
+                        *g = v;
+                        *b = p;
+                        break;
+                case 2: /* ->B */
+                        *r = p;
+                        *g = q;
+                        *b = v;
+                        break;
+                }
+        }
+}
+
+static int qcm_sensor_set_gains(struct uvd *uvd, u16 hue,
+        u16 saturation, u16 value)
+{
+        int ret;
+        u16 r=0,g=0,b=0;
+
+        /* this code is based on qc-usb-messenger */
+        qcm_hsv2rgb(hue, saturation, value, &r, &g, &b);
+
+        r >>= 12;
+        g >>= 12;
+        b >>= 12;
+
+        /* min val is 8 */
+        r = max((u16) 8, r);
+        g = max((u16) 8, g);
+        b = max((u16) 8, b);
+
+        r |= 0x30;
+        g |= 0x30;
+        b |= 0x30;
+
+        /* set the r,g,b gain registers */
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x0509, r));
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050A, g));
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050B, b));
+
+        /* doing as qc-usb did */
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050C, 0x2A));
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050D, 0x01));
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01));
+
+        return 0;
+}
+
+static int qcm_sensor_set_exposure(struct uvd *uvd, int exposure)
+{
+        int ret;
+        int formedval;
+
+        /* calculation was from qc-usb-messenger driver */
+        formedval = ( exposure >> 12 );
+
+        /* max value for formedval is 14 */
+        formedval = min(formedval, 14);
+
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev,
+                        0x143A, 0xF0 | formedval));
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01));
+        return 0;
+}
+
+static int qcm_sensor_setlevels(struct uvd *uvd, int brightness, int contrast,
+                                        int hue, int colour)
+{
+        int ret;
+        /* brightness is exposure, contrast is gain, colour is saturation */
+        CHECK_RET(ret,
+                qcm_sensor_set_exposure(uvd, brightness));
+        CHECK_RET(ret, qcm_sensor_set_gains(uvd, hue, colour, contrast));
+
+        return 0;
+}
+
+static int qcm_sensor_setsize(struct uvd *uvd, u8 size)
+{
+        int ret;
+
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x1505, size));
+        return 0;
+}
+
+static int qcm_sensor_set_shutter(struct uvd *uvd, int whiteness)
+{
+        int ret;
+        /* some rescaling as done by the qc-usb-messenger code */
+        if (whiteness > 0xC000)
+                whiteness = 0xC000 + (whiteness & 0x3FFF)*8;
+
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143D,
+                                (whiteness >> 8) & 0xFF));
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143E,
+                                (whiteness >> 16) & 0x03));
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01));
+
+        return 0;
+}
+
+static int qcm_sensor_init(struct uvd *uvd)
+{
+        struct qcm *cam = (struct qcm *) uvd->user_data;
+        int ret;
+        int i;
+
+        for (i=0; i < sizeof(regval_table)/sizeof(regval_table[0]) ; i++) {
+                CHECK_RET(ret, qcm_stv_setb(uvd->dev,
+                                        regval_table[i].reg,
+                                        regval_table[i].val));
+        }
+
+        CHECK_RET(ret, qcm_stv_setw(uvd->dev, 0x15c1,
+                                cpu_to_le16(ISOC_PACKET_SIZE)));
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x15c3, 0x08));
+        CHECK_RET(ret, ret = qcm_stv_setb(uvd->dev, 0x143f, 0x01));
+
+        CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x00));
+
+        CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd));
+
+        CHECK_RET(ret, qcm_sensor_setlevels(uvd, uvd->vpic.brightness,
+                        uvd->vpic.contrast, uvd->vpic.hue, uvd->vpic.colour));
+
+        CHECK_RET(ret, qcm_sensor_set_shutter(uvd, uvd->vpic.whiteness));
+        CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd));
+
+        return 0;
+}
+
+static int qcm_set_camera_size(struct uvd *uvd)
+{
+        int ret;
+        struct qcm *cam = (struct qcm *) uvd->user_data;
+
+        CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd));
+        cam->width = camera_sizes[cam->size].width;
+        cam->height = camera_sizes[cam->size].height;
+        uvd->videosize = VIDEOSIZE(cam->width, cam->height);
+
+        return 0;
+}
+
+static int qcm_setup_on_open(struct uvd *uvd)
+{
+        int ret;
+
+        CHECK_RET(ret, qcm_sensor_set_gains(uvd, uvd->vpic.hue,
+                                uvd->vpic.colour, uvd->vpic.contrast));
+        CHECK_RET(ret, qcm_sensor_set_exposure(uvd, uvd->vpic.brightness));
+        CHECK_RET(ret, qcm_sensor_set_shutter(uvd, uvd->vpic.whiteness));
+        CHECK_RET(ret, qcm_set_camera_size(uvd));
+        CHECK_RET(ret, qcm_camera_on(uvd));
+        return 0;
+}
+
+static void qcm_adjust_picture(struct uvd *uvd)
+{
+        int ret;
+        struct qcm *cam = (struct qcm *) uvd->user_data;
+
+        ret = qcm_camera_off(uvd);
+        if (ret) {
+                err("can't turn camera off. abandoning pic adjustment");
+                return;
+        }
+
+        /* if there's been a change in contrast, hue, or
+        colour then we need to recalculate hsv in order
+        to update gains */
+        if ((cam->contrast != uvd->vpic.contrast) ||
+                (cam->hue != uvd->vpic.hue) ||
+                (cam->colour != uvd->vpic.colour)) {
+                cam->contrast = uvd->vpic.contrast;
+                cam->hue = uvd->vpic.hue;
+                cam->colour = uvd->vpic.colour;
+                ret = qcm_sensor_set_gains(uvd, cam->hue, cam->colour,
+                                                cam->contrast);
+                if (ret) {
+                        err("can't set gains. abandoning pic adjustment");
+                        return;
+                }
+        }
+
+        if (cam->brightness != uvd->vpic.brightness) {
+                cam->brightness = uvd->vpic.brightness;
+                ret = qcm_sensor_set_exposure(uvd, cam->brightness);
+                if (ret) {
+                        err("can't set exposure. abandoning pic adjustment");
+                        return;
+                }
+        }
+
+        if (cam->whiteness != uvd->vpic.whiteness) {
+                cam->whiteness = uvd->vpic.whiteness;
+                qcm_sensor_set_shutter(uvd, cam->whiteness);
+                if (ret) {
+                        err("can't set shutter. abandoning pic adjustment");
+                        return;
+                }
+        }
+
+        ret = qcm_camera_on(uvd);
+        if (ret) {
+                err("can't reenable camera. pic adjustment failed");
+                return;
+        }
+}
+
+static int qcm_process_frame(struct uvd *uvd, u8 *cdata, int framelen)
+{
+        int datalen;
+        int totaldata;
+        struct framehdr {
+                __be16 id;
+                __be16 len;
+        };
+        struct framehdr *fhdr;
+
+        totaldata = 0;
+        while (framelen) {
+                fhdr = (struct framehdr *) cdata;
+                datalen = be16_to_cpu(fhdr->len);
+                framelen -= 4;
+                cdata += 4;
+
+                if ((fhdr->id) == cpu_to_be16(0x8001)) {
+                        RingQueue_Enqueue(&uvd->dp, marker, 4);
+                        totaldata += 4;
+                        continue;
+                }
+                if ((fhdr->id & cpu_to_be16(0xFF00)) == cpu_to_be16(0x0200)) {
+                        RingQueue_Enqueue(&uvd->dp, cdata, datalen);
+                        totaldata += datalen;
+                }
+                framelen -= datalen;
+                cdata += datalen;
+        }
+        return totaldata;
+}
+
+static int qcm_compress_iso(struct uvd *uvd, struct urb *dataurb)
+{
+        int totlen;
+        int i;
+        unsigned char *cdata;
+
+        totlen=0;
+        for (i = 0; i < dataurb->number_of_packets; i++) {
+                int n = dataurb->iso_frame_desc[i].actual_length;
+                int st = dataurb->iso_frame_desc[i].status;
+
+                cdata = dataurb->transfer_buffer +
+                        dataurb->iso_frame_desc[i].offset;
+
+                if (st < 0) {
+                        warn("Data error: packet=%d. len=%d. status=%d.",
+                              i, n, st);
+                        uvd->stats.iso_err_count++;
+                        continue;
+                }
+                if (!n)
+                        continue;
+
+                totlen += qcm_process_frame(uvd, cdata, n);
+        }
+        return totlen;
+}
+
+static void resubmit_urb(struct uvd *uvd, struct urb *urb)
+{
+        int ret;
+
+        urb->dev = uvd->dev;
+        ret = usb_submit_urb(urb, GFP_ATOMIC);
+        if (ret)
+                err("usb_submit_urb error (%d)", ret);
+}
+
+static void qcm_isoc_irq(struct urb *urb, struct pt_regs *regs)
+{
+        int len;
+        struct uvd *uvd = urb->context;
+
+        if (!CAMERA_IS_OPERATIONAL(uvd))
+                return;
+
+        if (!uvd->streaming)
+                return;
+
+        uvd->stats.urb_count++;
+
+        if (!urb->actual_length) {
+                resubmit_urb(uvd, urb);
+                return;
+        }
+
+        len = qcm_compress_iso(uvd, urb);
+        resubmit_urb(uvd, urb);
+        uvd->stats.urb_length = len;
+        uvd->stats.data_count += len;
+        if (len)
+                RingQueue_WakeUpInterruptible(&uvd->dp);
+}
+
+static int qcm_start_data(struct uvd *uvd)
+{
+        struct qcm *cam = (struct qcm *) uvd->user_data;
+        int i;
+        int errflag;
+        int pktsz;
+        int err;
+
+        pktsz = uvd->iso_packet_len;
+        if (!CAMERA_IS_OPERATIONAL(uvd)) {
+                err("Camera is not operational");
+                return -EFAULT;
+        }
+
+        err = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltActive);
+        if (err < 0) {
+                err("usb_set_interface error");
+                uvd->last_error = err;
+                return -EBUSY;
+        }
+
+        for (i=0; i < USBVIDEO_NUMSBUF; i++) {
+                int j, k;
+                struct urb *urb = uvd->sbuf[i].urb;
+                urb->dev = uvd->dev;
+                urb->context = uvd;
+                urb->pipe = usb_rcvisocpipe(uvd->dev, uvd->video_endp);
+                urb->interval = 1;
+                urb->transfer_flags = URB_ISO_ASAP;
+                urb->transfer_buffer = uvd->sbuf[i].data;
+                urb->complete = qcm_isoc_irq;
+                urb->number_of_packets = FRAMES_PER_DESC;
+                urb->transfer_buffer_length = pktsz * FRAMES_PER_DESC;
+                for (j=k=0; j < FRAMES_PER_DESC; j++, k += pktsz) {
+                        urb->iso_frame_desc[j].offset = k;
+                        urb->iso_frame_desc[j].length = pktsz;
+                }
+        }
+
+        uvd->streaming = 1;
+        uvd->curframe = -1;
+        for (i=0; i < USBVIDEO_NUMSBUF; i++) {
+                errflag = usb_submit_urb(uvd->sbuf[i].urb, GFP_KERNEL);
+                if (errflag)
+                        err ("usb_submit_isoc(%d) ret %d", i, errflag);
+        }
+
+        CHECK_RET(err, qcm_setup_input_int(cam, uvd));
+        CHECK_RET(err, qcm_camera_on(uvd));
+        return 0;
+}
+
+static void qcm_stop_data(struct uvd *uvd)
+{
+        struct qcm *cam = (struct qcm *) uvd->user_data;
+        int i, j;
+        int ret;
+
+        if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL))
+                return;
+
+        ret = qcm_camera_off(uvd);
+        if (ret)
+                warn("couldn't turn the cam off.");
+
+        uvd->streaming = 0;
+
+        /* Unschedule all of the iso td's */
+        for (i=0; i < USBVIDEO_NUMSBUF; i++)
+                usb_kill_urb(uvd->sbuf[i].urb);
+
+        qcm_stop_int_data(cam);
+
+        if (!uvd->remove_pending) {
+                /* Set packet size to 0 */
+                j = usb_set_interface(uvd->dev, uvd->iface,
+                                        uvd->ifaceAltInactive);
+                if (j < 0) {
+                        err("usb_set_interface() error %d.", j);
+                        uvd->last_error = j;
+                }
+        }
+}
+
+static void qcm_process_isoc(struct uvd *uvd, struct usbvideo_frame *frame)
+{
+        struct qcm *cam = (struct qcm *) uvd->user_data;
+        int x;
+        struct rgb *rgbL0;
+        struct rgb *rgbL1;
+        struct bayL0 *bayL0;
+        struct bayL1 *bayL1;
+        int hor,ver,hordel,verdel;
+        assert(frame != NULL);
+
+        switch (cam->size) {
+        case SIZE_160X120:
+                hor = 162; ver = 124; hordel = 1; verdel = 2;
+                break;
+        case SIZE_320X240:
+        default:
+                hor = 324; ver = 248; hordel = 2; verdel = 4;
+                break;
+        }
+
+        if (frame->scanstate == ScanState_Scanning) {
+                while (RingQueue_GetLength(&uvd->dp) >=
+                         4 + (hor*verdel + hordel)) {
+                        if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) &&
+                            (RING_QUEUE_PEEK(&uvd->dp, 1) == 0xff) &&
+                            (RING_QUEUE_PEEK(&uvd->dp, 2) == 0x00) &&
+                            (RING_QUEUE_PEEK(&uvd->dp, 3) == 0xff)) {
+                                frame->curline = 0;
+                                frame->scanstate = ScanState_Lines;
+                                frame->frameState = FrameState_Grabbing;
+                                RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 4);
+                        /*
+                        * if we're starting, we need to discard the first
+                        * 4 lines of y bayer data
+                        * and the first 2 gr elements of x bayer data
+                        */
+                                RING_QUEUE_DEQUEUE_BYTES(&uvd->dp,
+                                                        (hor*verdel + hordel));
+                                break;
+                        }
+                        RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1);
+                }
+        }
+
+        if (frame->scanstate == ScanState_Scanning)
+                return;
+
+        /* now we can start processing bayer data so long as we have at least
+        * 2 lines worth of data. this is the simplest demosaicing method that
+        * I could think of. I use each 2x2 bayer element without interpolation
+        * to generate 4 rgb pixels.
+        */
+        while ( frame->curline < cam->height &&
+                (RingQueue_GetLength(&uvd->dp) >= hor*2)) {
+                /* get 2 lines of bayer for demosaicing
+                 * into 2 lines of RGB */
+                RingQueue_Dequeue(&uvd->dp, cam->scratch, hor*2);
+                bayL0 = (struct bayL0 *) cam->scratch;
+                bayL1 = (struct bayL1 *) (cam->scratch + hor);
+                /* frame->curline is the rgb y line */
+                rgbL0 = (struct rgb *)
+                                ( frame->data + (cam->width*3*frame->curline));
+                /* w/2 because we're already doing 2 pixels */
+                rgbL1 = rgbL0 + (cam->width/2);
+
+                for (x=0; x < cam->width; x+=2) {
+                        rgbL0->r = bayL0->r;
+                        rgbL0->g = bayL0->g;
+                        rgbL0->b = bayL1->b;
+
+                        rgbL0->r2 = bayL0->r;
+                        rgbL0->g2 = bayL1->g;
+                        rgbL0->b2 = bayL1->b;
+
+                        rgbL1->r = bayL0->r;
+                        rgbL1->g = bayL1->g;
+                        rgbL1->b = bayL1->b;
+
+                        rgbL1->r2 = bayL0->r;
+                        rgbL1->g2 = bayL1->g;
+                        rgbL1->b2 = bayL1->b;
+
+                        rgbL0++;
+                        rgbL1++;
+
+                        bayL0++;
+                        bayL1++;
+                }
+
+                frame->seqRead_Length += cam->width*3*2;
+                frame->curline += 2;
+        }
+        /* See if we filled the frame */
+        if (frame->curline == cam->height) {
+                frame->frameState = FrameState_Done_Hold;
+                frame->curline = 0;
+                uvd->curframe = -1;
+                uvd->stats.frame_num++;
+        }
+}
+
+/* taken from konicawc */
+static int qcm_set_video_mode(struct uvd *uvd, struct video_window *vw)
+{
+        int ret;
+        int newsize;
+        int oldsize;
+        int x = vw->width;
+        int y = vw->height;
+        struct qcm *cam = (struct qcm *) uvd->user_data;
+
+        if (x > 0 && y > 0) {
+                DEBUG(2, "trying to find size %d,%d", x, y);
+                for (newsize = 0; newsize <= MAX_FRAME_SIZE; newsize++) {
+                        if ((camera_sizes[newsize].width == x) &&
+                                (camera_sizes[newsize].height == y))
+                                break;
+                }
+        } else
+                newsize = cam->size;
+
+        if (newsize > MAX_FRAME_SIZE) {
+                DEBUG(1, "couldn't find size %d,%d", x, y);
+                return -EINVAL;
+        }
+
+        if (newsize == cam->size) {
+                DEBUG(1, "Nothing to do");
+                return 0;
+        }
+
+        qcm_stop_data(uvd);
+
+        if (cam->size != newsize) {
+                oldsize = cam->size;
+                cam->size = newsize;
+                ret = qcm_set_camera_size(uvd);
+                if (ret) {
+                        err("Couldn't set camera size, err=%d",ret);
+                        /* restore the original size */
+                        cam->size = oldsize;
+                        return ret;
+                }
+        }
+
+        /* Flush the input queue and clear any current frame in progress */
+
+        RingQueue_Flush(&uvd->dp);
+        if (uvd->curframe != -1) {
+                uvd->frame[uvd->curframe].curline = 0;
+                uvd->frame[uvd->curframe].seqRead_Length = 0;
+                uvd->frame[uvd->curframe].seqRead_Index = 0;
+        }
+
+        CHECK_RET(ret, qcm_start_data(uvd));
+        return 0;
+}
+
+static int qcm_configure_video(struct uvd *uvd)
+{
+        int ret;
+        memset(&uvd->vpic, 0, sizeof(uvd->vpic));
+        memset(&uvd->vpic_old, 0x55, sizeof(uvd->vpic_old));
+
+        uvd->vpic.colour = colour;
+        uvd->vpic.hue = hue;
+        uvd->vpic.brightness = brightness;
+        uvd->vpic.contrast = contrast;
+        uvd->vpic.whiteness = whiteness;
+        uvd->vpic.depth = 24;
+        uvd->vpic.palette = VIDEO_PALETTE_RGB24;
+
+        memset(&uvd->vcap, 0, sizeof(uvd->vcap));
+        strcpy(uvd->vcap.name, "QCM USB Camera");
+        uvd->vcap.type = VID_TYPE_CAPTURE;
+        uvd->vcap.channels = 1;
+        uvd->vcap.audios = 0;
+
+        uvd->vcap.minwidth = camera_sizes[SIZE_160X120].width;
+        uvd->vcap.minheight = camera_sizes[SIZE_160X120].height;
+        uvd->vcap.maxwidth = camera_sizes[SIZE_320X240].width;
+        uvd->vcap.maxheight = camera_sizes[SIZE_320X240].height;
+
+        memset(&uvd->vchan, 0, sizeof(uvd->vchan));
+        uvd->vchan.flags = 0 ;
+        uvd->vchan.tuners = 0;
+        uvd->vchan.channel = 0;
+        uvd->vchan.type = VIDEO_TYPE_CAMERA;
+        strcpy(uvd->vchan.name, "Camera");
+
+        CHECK_RET(ret, qcm_sensor_init(uvd));
+        return 0;
+}
+
+static int qcm_probe(struct usb_interface *intf,
+                        const struct usb_device_id *devid)
+{
+        int err;
+        struct uvd *uvd;
+        struct usb_device *dev = interface_to_usbdev(intf);
+        struct qcm *cam;
+        size_t buffer_size;
+        unsigned char video_ep;
+        struct usb_host_interface *interface;
+        struct usb_endpoint_descriptor *endpoint;
+        int i,j;
+        unsigned int ifacenum, ifacenum_inact=0;
+        __le16 sensor_id;
+
+        /* we don't support multiconfig cams */
+        if (dev->descriptor.bNumConfigurations != 1)
+                return -ENODEV;
+
+        /* first check for the video interface and not
+        * the audio interface */
+        interface = &intf->cur_altsetting[0];
+        if ((interface->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC)
+                || (interface->desc.bInterfaceSubClass !=
+                        USB_CLASS_VENDOR_SPEC))
+                return -ENODEV;
+
+        /*
+        walk through each endpoint in each setting in the interface
+        stop when we find the one that's an isochronous IN endpoint.
+        */
+        for (i=0; i < intf->num_altsetting; i++) {
+                interface = &intf->cur_altsetting[i];
+                ifacenum = interface->desc.bAlternateSetting;
+                /* walk the end points */
+                for (j=0; j < interface->desc.bNumEndpoints; j++) {
+                        endpoint = &interface->endpoint[j].desc;
+
+                        if ((endpoint->bEndpointAddress &
+                                USB_ENDPOINT_DIR_MASK) != USB_DIR_IN)
+                                continue; /* not input then not good */
+
+                        buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
+                        if (!buffer_size) {
+                                ifacenum_inact = ifacenum;
+                                continue; /* 0 pkt size is not what we want */
+                        }
+
+                        if ((endpoint->bmAttributes &
+                                USB_ENDPOINT_XFERTYPE_MASK) ==
+                                USB_ENDPOINT_XFER_ISOC) {
+                                video_ep = endpoint->bEndpointAddress;
+                                /* break out of the search */
+                                goto good_videoep;
+                        }
+                }
+        }
+        /* failed out since nothing useful was found */
+        err("No suitable endpoint was found\n");
+        return -ENODEV;
+
+good_videoep:
+        /* disable isochronous stream before doing anything else */
+        err = qcm_stv_setb(dev, STV_ISO_ENABLE, 0);
+        if (err < 0) {
+                err("Failed to disable sensor stream");
+                return -EIO;
+        }
+
+        /*
+        Check that this is the same unknown sensor that is known to work. This
+        sensor is suspected to be the ST VV6422C001. I'll check the same value
+        that the qc-usb driver checks. This value is probably not even the
+        sensor ID since it matches the USB dev ID. Oh well. If it doesn't
+        match, it's probably a diff sensor so exit and apologize.
+        */
+        err = qcm_stv_getw(dev, CMOS_SENSOR_IDREV, &sensor_id);
+        if (err < 0) {
+                err("Couldn't read sensor values. Err %d\n",err);
+                return err;
+        }
+        if (sensor_id != cpu_to_le16(0x08F0)) {
+                err("Sensor ID %x != %x. Unsupported. Sorry\n",
+                        le16_to_cpu(sensor_id), (0x08F0));
+                return -ENODEV;
+        }
+
+        uvd = usbvideo_AllocateDevice(cams);
+        if (!uvd)
+                return -ENOMEM;
+
+        cam = (struct qcm *) uvd->user_data;
+
+        /* buf for doing demosaicing */
+        cam->scratch = kmalloc(324*2, GFP_KERNEL);
+        if (!cam->scratch) /* uvd freed in dereg */
+                return -ENOMEM;
+
+        /* yes, if we fail after here, cam->scratch gets freed
+        by qcm_free_uvd */
+
+        err = qcm_alloc_int_urb(cam);
+        if (err < 0)
+                return err;
+
+        /* yes, if we fail after here, int urb gets freed
+        by qcm_free_uvd */
+
+        RESTRICT_TO_RANGE(size, SIZE_160X120, SIZE_320X240);
+        cam->width = camera_sizes[size].width;
+        cam->height = camera_sizes[size].height;
+        cam->size = size;
+
+        uvd->debug = debug;
+        uvd->flags = 0;
+        uvd->dev = dev;
+        uvd->iface = intf->altsetting->desc.bInterfaceNumber;
+        uvd->ifaceAltActive = ifacenum;
+        uvd->ifaceAltInactive = ifacenum_inact;
+        uvd->video_endp = video_ep;
+        uvd->iso_packet_len = buffer_size;
+        uvd->paletteBits = 1L << VIDEO_PALETTE_RGB24;
+        uvd->defaultPalette = VIDEO_PALETTE_RGB24;
+        uvd->canvas = VIDEOSIZE(320, 240);
+        uvd->videosize = VIDEOSIZE(cam->width, cam->height);
+        err = qcm_configure_video(uvd);
+        if (err) {
+                err("failed to configure video settings");
+                return err;
+        }
+
+        err = usbvideo_RegisterVideoDevice(uvd);
+        if (err) { /* the uvd gets freed in Deregister */
+                err("usbvideo_RegisterVideoDevice() failed.");
+                return err;
+        }
+
+        uvd->max_frame_size = (320 * 240 * 3);
+        qcm_register_input(cam, dev);
+        usb_set_intfdata(intf, uvd);
+        return 0;
+}
+
+static void qcm_free_uvd(struct uvd *uvd)
+{
+        struct qcm *cam = (struct qcm *) uvd->user_data;
+
+        kfree(cam->scratch);
+        qcm_unregister_input(cam);
+        qcm_free_int(cam);
+}
+
+static struct usbvideo_cb qcm_driver = {
+        .probe =                qcm_probe,
+        .setupOnOpen =          qcm_setup_on_open,
+        .processData =          qcm_process_isoc,
+        .setVideoMode =         qcm_set_video_mode,
+        .startDataPump =        qcm_start_data,
+        .stopDataPump =         qcm_stop_data,
+        .adjustPicture =        qcm_adjust_picture,
+        .userFree =             qcm_free_uvd
+};
+
+static int __init qcm_init(void)
+{
+        info(DRIVER_DESC " " DRIVER_VERSION);
+
+        return usbvideo_register(
+                &cams,
+                MAX_CAMERAS,
+                sizeof(struct qcm),
+                "QCM",
+                &qcm_driver,
+                THIS_MODULE,
+                qcm_table);
+}
+
+static void __exit qcm_exit(void)
+{
+        usbvideo_Deregister(&cams);
+}
+
+module_param(size, int, 0);
+MODULE_PARM_DESC(size, "Initial Size 0: 160x120 1: 320x240");
+module_param(colour, int, 0);
+MODULE_PARM_DESC(colour, "Initial colour");
+module_param(hue, int, 0);
+MODULE_PARM_DESC(hue, "Initial hue");
+module_param(brightness, int, 0);
+MODULE_PARM_DESC(brightness, "Initial brightness");
+module_param(contrast, int, 0);
+MODULE_PARM_DESC(contrast, "Initial contrast");
+module_param(whiteness, int, 0);
+MODULE_PARM_DESC(whiteness, "Initial whiteness");
+
+#ifdef CONFIG_USB_DEBUG
+module_param(debug, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug level: 0-9 (default=0)");
+#endif
+
+module_init(qcm_init);
+module_exit(qcm_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jaya Kumar");
+MODULE_DESCRIPTION("QCM USB Camera");
+MODULE_SUPPORTED_DEVICE("QCM USB Camera");
diff --git a/drivers/media/video/usbvideo/quickcam_messenger.h b/drivers/media/video/usbvideo/quickcam_messenger.h
new file mode 100644
index 00000000000..baab9c081b5
--- /dev/null
+++ b/drivers/media/video/usbvideo/quickcam_messenger.h
@@ -0,0 +1,126 @@
+#ifndef quickcam_messenger_h
+#define quickcam_messenger_h
+
+#ifndef CONFIG_INPUT
+/* if we're not using input we dummy out these functions */
+#define qcm_register_input(...)
+#define qcm_unregister_input(...)
+#define qcm_report_buttonstat(...)
+#define qcm_setup_input_int(...) 0
+#define qcm_stop_int_data(...)
+#define qcm_alloc_int_urb(...) 0
+#define qcm_free_int(...)
+#endif
+
+
+#define CHECK_RET(ret, expr) \
+        if ((ret = expr) < 0) return ret
+
+/* Control Registers for the STVV6422 ASIC
+ * - this define is taken from the qc-usb-messenger code
+ */
+#define STV_ISO_ENABLE          0x1440
+#define ISOC_PACKET_SIZE        1023
+
+/* Chip identification number including revision indicator */
+#define CMOS_SENSOR_IDREV       0xE00A
+
+struct rgb {
+        u8 b;
+        u8 g;
+        u8 r;
+        u8 b2;
+        u8 g2;
+        u8 r2;
+};
+
+struct bayL0 {
+#ifdef __BIG_ENDIAN
+        u8 r;
+        u8 g;
+#elif __LITTLE_ENDIAN
+        u8 g;
+        u8 r;
+#else
+#error not byte order defined
+#endif
+};
+
+struct bayL1 {
+#ifdef __BIG_ENDIAN
+        u8 g;
+        u8 b;
+#elif __LITTLE_ENDIAN
+        u8 b;
+        u8 g;
+#else
+#error not byte order defined
+#endif
+};
+
+struct cam_size {
+        u16     width;
+        u16     height;
+        u8      cmd;
+};
+
+static const struct cam_size camera_sizes[] = {
+        { 160, 120, 0xf },
+        { 320, 240, 0x2 },
+};
+
+enum frame_sizes {
+        SIZE_160X120    = 0,
+        SIZE_320X240    = 1,
+};
+
+#define MAX_FRAME_SIZE SIZE_320X240
+
+struct qcm {
+        u16 colour;
+        u16 hue;
+        u16 brightness;
+        u16 contrast;
+        u16 whiteness;
+
+        u8 size;
+        int height;
+        int width;
+        u8 *scratch;
+        struct urb *button_urb;
+        u8 button_sts;
+        u8 button_sts_buf;
+
+#ifdef CONFIG_INPUT
+        struct input_dev *input;
+        char input_physname[64];
+#endif
+};
+
+struct regval {
+        u16 reg;
+        u8 val;
+};
+/* this table is derived from the
+qc-usb-messenger code */
+static const struct regval regval_table[] = {
+        { STV_ISO_ENABLE, 0x00 },
+        { 0x1436, 0x00 }, { 0x1432, 0x03 },
+        { 0x143a, 0xF9 }, { 0x0509, 0x38 },
+        { 0x050a, 0x38 }, { 0x050b, 0x38 },
+        { 0x050c, 0x2A }, { 0x050d, 0x01 },
+        { 0x1431, 0x00 }, { 0x1433, 0x34 },
+        { 0x1438, 0x18 }, { 0x1439, 0x00 },
+        { 0x143b, 0x05 }, { 0x143c, 0x00 },
+        { 0x143e, 0x01 }, { 0x143d, 0x00 },
+        { 0x1442, 0xe2 }, { 0x1500, 0xd0 },
+        { 0x1500, 0xd0 }, { 0x1500, 0x50 },
+        { 0x1501, 0xaf }, { 0x1502, 0xc2 },
+        { 0x1503, 0x45 }, { 0x1505, 0x02 },
+        { 0x150e, 0x8e }, { 0x150f, 0x37 },
+        { 0x15c0, 0x00 },
+};
+
+static const unsigned char marker[] = { 0x00, 0xff, 0x00, 0xFF };
+
+#endif /* quickcam_messenger_h */
diff --git a/drivers/media/video/usbvideo/usbvideo.h b/drivers/media/video/usbvideo/usbvideo.h
index 3cbf4fc499a..49dbee5f562 100644
--- a/drivers/media/video/usbvideo/usbvideo.h
+++ b/drivers/media/video/usbvideo/usbvideo.h
@@ -18,6 +18,7 @@
 
 #include <linux/config.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/usb.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/media/video/v4l1-compat.c b/drivers/media/video/v4l1-compat.c
index 474a29bc176..19d3c20dc7e 100644
--- a/drivers/media/video/v4l1-compat.c
+++ b/drivers/media/video/v4l1-compat.c
@@ -32,6 +32,7 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
diff --git a/drivers/media/video/v4l2-common.c b/drivers/media/video/v4l2-common.c
index d330fa985bc..14e52347135 100644
--- a/drivers/media/video/v4l2-common.c
+++ b/drivers/media/video/v4l2-common.c
@@ -59,6 +59,7 @@
 #include <asm/io.h>
 #include <asm/div64.h>
 #include <linux/video_decoder.h>
+#define __OLD_VIDIOC_ /* To allow fixing old calls*/
 #include <media/v4l2-common.h>
 
 #ifdef CONFIG_KMOD
@@ -293,7 +294,10 @@ static const char *v4l2_ioctls[] = {
 #if 1
         [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
 #endif
-        [_IOC_NR(VIDIOC_LOG_STATUS)]       = "VIDIOC_LOG_STATUS"
+        [_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"
 };
 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
 
@@ -331,7 +335,8 @@ static const char *v4l2_int_ioctls[] = {
         [_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_G_VIDEO_ROUTING)]  = "VIDIOC_INT_G_VIDEO_ROUTING",
+        [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)]   = "VIDIOC_INT_S_CRYSTAL_FREQ"
 };
 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
 
@@ -423,7 +428,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
         case TUNER_SET_TYPE_ADDR:
         case TUNER_SET_STANDBY:
         case TDA9887_SET_CONFIG:
+#ifdef __OLD_VIDIOC_
         case VIDIOC_OVERLAY_OLD:
+#endif
         case VIDIOC_STREAMOFF:
         case VIDIOC_G_OUTPUT:
         case VIDIOC_S_OUTPUT:
@@ -439,7 +446,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
         case VIDIOC_G_AUDIO:
         case VIDIOC_S_AUDIO:
         case VIDIOC_ENUMAUDIO:
+#ifdef __OLD_VIDIOC_
         case VIDIOC_G_AUDIO_OLD:
+#endif
         {
                 struct v4l2_audio *p=arg;
 
@@ -450,7 +459,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
         case VIDIOC_G_AUDOUT:
         case VIDIOC_S_AUDOUT:
         case VIDIOC_ENUMAUDOUT:
+#ifdef __OLD_VIDIOC_
         case VIDIOC_G_AUDOUT_OLD:
+#endif
         {
                 struct v4l2_audioout *p=arg;
                 printk ("%s: index=%d, name=%s, capability=%d, mode=%d\n", s,
@@ -478,9 +489,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
                                 prt_names(p->memory,v4l2_memory_names),
                                 p->m.userptr);
                 printk ("%s: timecode= %02d:%02d:%02d type=%d, "
-                        "flags=0x%08x, frames=%d, userbits=0x%p\n",
+                        "flags=0x%08x, frames=%d, userbits=0x%08x\n",
                                 s,tc->hours,tc->minutes,tc->seconds,
-                                tc->type, tc->flags, tc->frames, tc->userbits);
+                                tc->type, tc->flags, tc->frames, *(__u32 *) tc->userbits);
                 break;
         }
         case VIDIOC_QUERYCAP:
@@ -495,12 +506,31 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
         }
         case VIDIOC_G_CTRL:
         case VIDIOC_S_CTRL:
+#ifdef __OLD_VIDIOC_
         case VIDIOC_S_CTRL_OLD:
+#endif
         {
                 struct v4l2_control *p=arg;
                 printk ("%s: id=%d, value=%d\n", s, p->id, p->value);
                 break;
         }
+        case VIDIOC_G_EXT_CTRLS:
+        case VIDIOC_S_EXT_CTRLS:
+        case VIDIOC_TRY_EXT_CTRLS:
+        {
+                struct v4l2_ext_controls *p = arg;
+                int i;
+
+                printk("%s: ctrl_class=%d, count=%d\n", s, p->ctrl_class, p->count);
+                for (i = 0; i < p->count; i++) {
+                        struct v4l2_ext_control *c = &p->controls[i];
+                        if (cmd == VIDIOC_G_EXT_CTRLS)
+                                printk("%s: id=%d\n", s, c->id);
+                        else
+                                printk("%s: id=%d, value=%d\n", s, c->id, c->value);
+                }
+                break;
+        }
         case VIDIOC_G_CROP:
         case VIDIOC_S_CROP:
         {
@@ -510,7 +540,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
                 break;
         }
         case VIDIOC_CROPCAP:
+#ifdef __OLD_VIDIOC_
         case VIDIOC_CROPCAP_OLD:
+#endif
         {
                 struct v4l2_cropcap *p=arg;
                 /*FIXME: Should also show rect structs */
@@ -667,6 +699,12 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
                 printk ("%s: input=0x%x, output=0x%x\n", s, p->input, p->output);
                 break;
         }
+        case VIDIOC_INT_S_CRYSTAL_FREQ:
+        {
+                struct v4l2_crystal_freq *p=arg;
+                printk ("%s: freq=%u, flags=0x%x\n", s, p->freq, p->flags);
+                break;
+        }
         case VIDIOC_G_SLICED_VBI_CAP:
         {
                 struct v4l2_sliced_vbi_cap *p=arg;
@@ -696,7 +734,9 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
         }
         case VIDIOC_G_PARM:
         case VIDIOC_S_PARM:
+#ifdef __OLD_VIDIOC_
         case VIDIOC_S_PARM_OLD:
+#endif
         {
                 struct v4l2_streamparm *p=arg;
                 printk ("%s: type=%d\n", s, p->type);
@@ -915,6 +955,484 @@ void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
 
 /* ----------------------------------------------------------------- */
 
+/* Helper functions for control handling                             */
+
+/* Check for correctness of the ctrl's value based on the data from
+   struct v4l2_queryctrl and the available menu items. Note that
+   menu_items may be NULL, in that case it is ignored. */
+int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
+                const char **menu_items)
+{
+        if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
+                return -EINVAL;
+        if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
+                return -EBUSY;
+        if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
+            qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
+            qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
+                return 0;
+        if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
+                return -ERANGE;
+        if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
+                if (menu_items[ctrl->value] == NULL ||
+                    menu_items[ctrl->value][0] == '\0')
+                        return -EINVAL;
+        }
+        return 0;
+}
+
+/* Returns NULL or a character pointer array containing the menu for
+   the given control ID. The pointer array ends with a NULL pointer.
+   An empty string signifies a menu entry that is invalid. This allows
+   drivers to disable certain options if it is not supported. */
+const char **v4l2_ctrl_get_menu(u32 id)
+{
+        static const char *mpeg_audio_sampling_freq[] = {
+                "44.1 kHz",
+                "48 kHz",
+                "32 kHz",
+                NULL
+        };
+        static const char *mpeg_audio_encoding[] = {
+                "Layer I",
+                "Layer II",
+                "Layer III",
+                NULL
+        };
+        static const char *mpeg_audio_l1_bitrate[] = {
+                "32 kbps",
+                "64 kbps",
+                "96 kbps",
+                "128 kbps",
+                "160 kbps",
+                "192 kbps",
+                "224 kbps",
+                "256 kbps",
+                "288 kbps",
+                "320 kbps",
+                "352 kbps",
+                "384 kbps",
+                "416 kbps",
+                "448 kbps",
+                NULL
+        };
+        static const char *mpeg_audio_l2_bitrate[] = {
+                "32 kbps",
+                "48 kbps",
+                "56 kbps",
+                "64 kbps",
+                "80 kbps",
+                "96 kbps",
+                "112 kbps",
+                "128 kbps",
+                "160 kbps",
+                "192 kbps",
+                "224 kbps",
+                "256 kbps",
+                "320 kbps",
+                "384 kbps",
+                NULL
+        };
+        static const char *mpeg_audio_l3_bitrate[] = {
+                "32 kbps",
+                "40 kbps",
+                "48 kbps",
+                "56 kbps",
+                "64 kbps",
+                "80 kbps",
+                "96 kbps",
+                "112 kbps",
+                "128 kbps",
+                "160 kbps",
+                "192 kbps",
+                "224 kbps",
+                "256 kbps",
+                "320 kbps",
+                NULL
+        };
+        static const char *mpeg_audio_mode[] = {
+                "Stereo",
+                "Joint Stereo",
+                "Dual",
+                "Mono",
+                NULL
+        };
+        static const char *mpeg_audio_mode_extension[] = {
+                "Bound 4",
+                "Bound 8",
+                "Bound 12",
+                "Bound 16",
+                NULL
+        };
+        static const char *mpeg_audio_emphasis[] = {
+                "No Emphasis",
+                "50/15 us",
+                "CCITT J17",
+                NULL
+        };
+        static const char *mpeg_audio_crc[] = {
+                "No CRC",
+                "16-bit CRC",
+                NULL
+        };
+        static const char *mpeg_video_encoding[] = {
+                "MPEG-1",
+                "MPEG-2",
+                NULL
+        };
+        static const char *mpeg_video_aspect[] = {
+                "1x1",
+                "4x3",
+                "16x9",
+                "2.21x1",
+                NULL
+        };
+        static const char *mpeg_video_bitrate_mode[] = {
+                "Variable Bitrate",
+                "Constant Bitrate",
+                NULL
+        };
+        static const char *mpeg_stream_type[] = {
+                "MPEG-2 Program Stream",
+                "MPEG-2 Transport Stream",
+                "MPEG-1 System Stream",
+                "MPEG-2 DVD-compatible Stream",
+                "MPEG-1 VCD-compatible Stream",
+                "MPEG-2 SVCD-compatible Stream",
+                NULL
+        };
+
+        switch (id) {
+                case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
+                        return mpeg_audio_sampling_freq;
+                case V4L2_CID_MPEG_AUDIO_ENCODING:
+                        return mpeg_audio_encoding;
+                case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
+                        return mpeg_audio_l1_bitrate;
+                case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
+                        return mpeg_audio_l2_bitrate;
+                case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
+                        return mpeg_audio_l3_bitrate;
+                case V4L2_CID_MPEG_AUDIO_MODE:
+                        return mpeg_audio_mode;
+                case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
+                        return mpeg_audio_mode_extension;
+                case V4L2_CID_MPEG_AUDIO_EMPHASIS:
+                        return mpeg_audio_emphasis;
+                case V4L2_CID_MPEG_AUDIO_CRC:
+                        return mpeg_audio_crc;
+                case V4L2_CID_MPEG_VIDEO_ENCODING:
+                        return mpeg_video_encoding;
+                case V4L2_CID_MPEG_VIDEO_ASPECT:
+                        return mpeg_video_aspect;
+                case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
+                        return mpeg_video_bitrate_mode;
+                case V4L2_CID_MPEG_STREAM_TYPE:
+                        return mpeg_stream_type;
+                default:
+                        return NULL;
+        }
+}
+
+/* Fill in a struct v4l2_queryctrl */
+int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
+{
+        const char *name;
+
+        qctrl->flags = 0;
+        switch (qctrl->id) {
+        /* USER controls */
+        case V4L2_CID_USER_CLASS:       name = "User Controls"; break;
+        case V4L2_CID_AUDIO_VOLUME:     name = "Volume"; break;
+        case V4L2_CID_AUDIO_MUTE:       name = "Mute"; break;
+        case V4L2_CID_AUDIO_BALANCE:    name = "Balance"; break;
+        case V4L2_CID_AUDIO_BASS:       name = "Bass"; break;
+        case V4L2_CID_AUDIO_TREBLE:     name = "Treble"; break;
+        case V4L2_CID_AUDIO_LOUDNESS:   name = "Loudness"; break;
+        case V4L2_CID_BRIGHTNESS:       name = "Brightness"; break;
+        case V4L2_CID_CONTRAST:         name = "Contrast"; break;
+        case V4L2_CID_SATURATION:       name = "Saturation"; break;
+        case V4L2_CID_HUE:              name = "Hue"; break;
+
+        /* MPEG controls */
+        case V4L2_CID_MPEG_CLASS:               name = "MPEG Encoder Controls"; break;
+        case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
+        case V4L2_CID_MPEG_AUDIO_ENCODING:      name = "Audio Encoding Layer"; break;
+        case V4L2_CID_MPEG_AUDIO_L1_BITRATE:    name = "Audio Layer I Bitrate"; break;
+        case V4L2_CID_MPEG_AUDIO_L2_BITRATE:    name = "Audio Layer II Bitrate"; break;
+        case V4L2_CID_MPEG_AUDIO_L3_BITRATE:    name = "Audio Layer III Bitrate"; break;
+        case V4L2_CID_MPEG_AUDIO_MODE:          name = "Audio Stereo Mode"; break;
+        case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
+        case V4L2_CID_MPEG_AUDIO_EMPHASIS:      name = "Audio Emphasis"; break;
+        case V4L2_CID_MPEG_AUDIO_CRC:           name = "Audio CRC"; break;
+        case V4L2_CID_MPEG_VIDEO_ENCODING:      name = "Video Encoding"; break;
+        case V4L2_CID_MPEG_VIDEO_ASPECT:        name = "Video Aspect"; break;
+        case V4L2_CID_MPEG_VIDEO_B_FRAMES:      name = "Video B Frames"; break;
+        case V4L2_CID_MPEG_VIDEO_GOP_SIZE:      name = "Video GOP Size"; break;
+        case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:   name = "Video GOP Closure"; break;
+        case V4L2_CID_MPEG_VIDEO_PULLDOWN:      name = "Video Pulldown"; break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:  name = "Video Bitrate Mode"; break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE:       name = "Video Bitrate"; break;
+        case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:  name = "Video Peak Bitrate"; break;
+        case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
+        case V4L2_CID_MPEG_STREAM_TYPE:         name = "Stream Type"; break;
+        case V4L2_CID_MPEG_STREAM_PID_PMT:      name = "Stream PMT Program ID"; break;
+        case V4L2_CID_MPEG_STREAM_PID_AUDIO:    name = "Stream Audio Program ID"; break;
+        case V4L2_CID_MPEG_STREAM_PID_VIDEO:    name = "Stream Video Program ID"; break;
+        case V4L2_CID_MPEG_STREAM_PID_PCR:      name = "Stream PCR Program ID"; break;
+        case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
+        case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
+
+        default:
+                return -EINVAL;
+        }
+        switch (qctrl->id) {
+        case V4L2_CID_AUDIO_MUTE:
+        case V4L2_CID_AUDIO_LOUDNESS:
+        case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
+        case V4L2_CID_MPEG_VIDEO_PULLDOWN:
+                qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
+                min = 0;
+                max = step = 1;
+                break;
+        case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
+        case V4L2_CID_MPEG_AUDIO_ENCODING:
+        case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
+        case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
+        case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
+        case V4L2_CID_MPEG_AUDIO_MODE:
+        case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
+        case V4L2_CID_MPEG_AUDIO_EMPHASIS:
+        case V4L2_CID_MPEG_AUDIO_CRC:
+        case V4L2_CID_MPEG_VIDEO_ENCODING:
+        case V4L2_CID_MPEG_VIDEO_ASPECT:
+        case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
+        case V4L2_CID_MPEG_STREAM_TYPE:
+                qctrl->type = V4L2_CTRL_TYPE_MENU;
+                step = 1;
+                break;
+        case V4L2_CID_USER_CLASS:
+        case V4L2_CID_MPEG_CLASS:
+                qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
+                qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
+                min = max = step = def = 0;
+                break;
+        default:
+                qctrl->type = V4L2_CTRL_TYPE_INTEGER;
+                break;
+        }
+        switch (qctrl->id) {
+        case V4L2_CID_MPEG_AUDIO_ENCODING:
+        case V4L2_CID_MPEG_AUDIO_MODE:
+        case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
+        case V4L2_CID_MPEG_VIDEO_B_FRAMES:
+        case V4L2_CID_MPEG_STREAM_TYPE:
+                qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
+                break;
+        case V4L2_CID_AUDIO_VOLUME:
+        case V4L2_CID_AUDIO_BALANCE:
+        case V4L2_CID_AUDIO_BASS:
+        case V4L2_CID_AUDIO_TREBLE:
+        case V4L2_CID_BRIGHTNESS:
+        case V4L2_CID_CONTRAST:
+        case V4L2_CID_SATURATION:
+        case V4L2_CID_HUE:
+                qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
+                break;
+        }
+        qctrl->minimum = min;
+        qctrl->maximum = max;
+        qctrl->step = step;
+        qctrl->default_value = def;
+        qctrl->reserved[0] = qctrl->reserved[1] = 0;
+        snprintf(qctrl->name, sizeof(qctrl->name), name);
+        return 0;
+}
+
+/* Fill in a struct v4l2_queryctrl with standard values based on
+   the control ID. */
+int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
+{
+        switch (qctrl->id) {
+        /* USER controls */
+        case V4L2_CID_USER_CLASS:
+        case V4L2_CID_MPEG_CLASS:
+                return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
+        case V4L2_CID_AUDIO_VOLUME:
+                return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
+        case V4L2_CID_AUDIO_MUTE:
+        case V4L2_CID_AUDIO_LOUDNESS:
+                return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
+        case V4L2_CID_AUDIO_BALANCE:
+        case V4L2_CID_AUDIO_BASS:
+        case V4L2_CID_AUDIO_TREBLE:
+                return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
+        case V4L2_CID_BRIGHTNESS:
+                return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
+        case V4L2_CID_CONTRAST:
+        case V4L2_CID_SATURATION:
+                return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
+        case V4L2_CID_HUE:
+                return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
+
+        /* MPEG controls */
+        case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
+                                V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
+                                V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
+        case V4L2_CID_MPEG_AUDIO_ENCODING:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
+                                V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
+                                V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
+        case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_L1_BITRATE_32K,
+                                V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
+                                V4L2_MPEG_AUDIO_L1_BITRATE_256K);
+        case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_L2_BITRATE_32K,
+                                V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
+                                V4L2_MPEG_AUDIO_L2_BITRATE_224K);
+        case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_L3_BITRATE_32K,
+                                V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
+                                V4L2_MPEG_AUDIO_L3_BITRATE_192K);
+        case V4L2_CID_MPEG_AUDIO_MODE:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_MODE_STEREO,
+                                V4L2_MPEG_AUDIO_MODE_MONO, 1,
+                                V4L2_MPEG_AUDIO_MODE_STEREO);
+        case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
+                                V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
+                                V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
+        case V4L2_CID_MPEG_AUDIO_EMPHASIS:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_EMPHASIS_NONE,
+                                V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
+                                V4L2_MPEG_AUDIO_EMPHASIS_NONE);
+        case V4L2_CID_MPEG_AUDIO_CRC:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_AUDIO_CRC_NONE,
+                                V4L2_MPEG_AUDIO_CRC_CRC16, 1,
+                                V4L2_MPEG_AUDIO_CRC_NONE);
+        case V4L2_CID_MPEG_VIDEO_ENCODING:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
+                                V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
+                                V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
+        case V4L2_CID_MPEG_VIDEO_ASPECT:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_VIDEO_ASPECT_1x1,
+                                V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
+                                V4L2_MPEG_VIDEO_ASPECT_4x3);
+        case V4L2_CID_MPEG_VIDEO_B_FRAMES:
+                return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
+        case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
+                return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
+        case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
+                return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
+        case V4L2_CID_MPEG_VIDEO_PULLDOWN:
+                return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
+        case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
+                                V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
+                                V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
+        case V4L2_CID_MPEG_VIDEO_BITRATE:
+                return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
+        case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
+                return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
+        case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
+                return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
+        case V4L2_CID_MPEG_STREAM_TYPE:
+                return v4l2_ctrl_query_fill(qctrl,
+                                V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
+                                V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
+                                V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
+        case V4L2_CID_MPEG_STREAM_PID_PMT:
+                return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
+        case V4L2_CID_MPEG_STREAM_PID_AUDIO:
+                return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
+        case V4L2_CID_MPEG_STREAM_PID_VIDEO:
+                return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
+        case V4L2_CID_MPEG_STREAM_PID_PCR:
+                return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
+        case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
+                return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
+        case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
+                return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
+        default:
+                return -EINVAL;
+        }
+}
+
+/* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
+   the menu. The qctrl pointer may be NULL, in which case it is ignored. */
+int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
+               const char **menu_items)
+{
+        int i;
+
+        if (menu_items == NULL ||
+            (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
+                return -EINVAL;
+        for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
+        if (menu_items[i] == NULL || menu_items[i][0] == '\0')
+                return -EINVAL;
+        snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
+        qmenu->reserved = 0;
+        return 0;
+}
+
+/* ctrl_classes points to an array of u32 pointers, the last element is
+   a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
+   Each array must be sorted low to high and belong to the same control
+   class. The array of u32 pointer must also be sorted, from low class IDs
+   to high class IDs.
+
+   This function returns the first ID that follows after the given ID.
+   When no more controls are available 0 is returned. */
+u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
+{
+        u32 ctrl_class;
+        const u32 *pctrl;
+
+        /* if no query is desired, then just return the control ID */
+        if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0)
+                return id;
+        if (ctrl_classes == NULL)
+                return 0;
+        id &= V4L2_CTRL_ID_MASK;
+        ctrl_class = V4L2_CTRL_ID2CLASS(id);
+        id++;   /* select next control */
+        /* find first class that matches (or is greater than) the class of
+           the ID */
+        while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
+                ctrl_classes++;
+        /* no more classes */
+        if (*ctrl_classes == NULL)
+                return 0;
+        pctrl = *ctrl_classes;
+        /* find first ctrl within the class that is >= ID */
+        while (*pctrl && *pctrl < id) pctrl++;
+        if (*pctrl)
+                return *pctrl;
+        /* we are at the end of the controls of the current class. */
+        /* continue with next class if available */
+        ctrl_classes++;
+        if (*ctrl_classes == NULL)
+                return 0;
+        return **ctrl_classes;
+}
+
+/* ----------------------------------------------------------------- */
+
 EXPORT_SYMBOL(v4l2_video_std_construct);
 
 EXPORT_SYMBOL(v4l2_prio_init);
@@ -929,6 +1447,13 @@ EXPORT_SYMBOL(v4l2_type_names);
 EXPORT_SYMBOL(v4l_printk_ioctl);
 EXPORT_SYMBOL(v4l_printk_ioctl_arg);
 
+EXPORT_SYMBOL(v4l2_ctrl_next);
+EXPORT_SYMBOL(v4l2_ctrl_check);
+EXPORT_SYMBOL(v4l2_ctrl_get_menu);
+EXPORT_SYMBOL(v4l2_ctrl_query_menu);
+EXPORT_SYMBOL(v4l2_ctrl_query_fill);
+EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
+
 /*
  * Local variables:
  * c-basic-offset: 8
diff --git a/drivers/media/video/video-buf-dvb.c b/drivers/media/video/video-buf-dvb.c
index caf3e7e2f21..7ee8a53cd33 100644
--- a/drivers/media/video/video-buf-dvb.c
+++ b/drivers/media/video/video-buf-dvb.c
@@ -135,14 +135,15 @@ static int videobuf_dvb_stop_feed(struct dvb_demux_feed *feed)
 
 int videobuf_dvb_register(struct videobuf_dvb *dvb,
                           struct module *module,
-                          void *adapter_priv)
+                          void *adapter_priv,
+                          struct device *device)
 {
         int result;
 
         mutex_init(&dvb->lock);
 
         /* register adapter */
-        result = dvb_register_adapter(&dvb->adapter, dvb->name, module);
+        result = dvb_register_adapter(&dvb->adapter, dvb->name, module, device);
         if (result < 0) {
                 printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n",
                        dvb->name, result);
diff --git a/drivers/media/video/videodev.c b/drivers/media/video/videodev.c
index 5f87dd5f1d0..2dfa7f23d0c 100644
--- a/drivers/media/video/videodev.c
+++ b/drivers/media/video/videodev.c
@@ -1,20 +1,31 @@
 /*
- * Video capture interface for Linux
+ * Video capture interface for Linux version 2
  *
- *              A generic video device interface for the LINUX operating system
- *              using a set of device structures/vectors for low level operations.
+ *      A generic video device interface for the LINUX operating system
+ *      using a set of device structures/vectors for low level operations.
  *
- *              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 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.
  *
- * Author:      Alan Cox, <alan@redhat.com>
+ * Authors:     Alan Cox, <alan@redhat.com> (version 1)
+ *              Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
  *
  * Fixes:       20000516  Claudio Matsuoka <claudio@conectiva.com>
  *              - Added procfs support
  */
 
+#define dbgarg(cmd, fmt, arg...) \
+                if (vfd->debug & V4L2_DEBUG_IOCTL_ARG)                  \
+                        printk (KERN_DEBUG "%s: ",  vfd->name);         \
+                        v4l_printk_ioctl(cmd);                          \
+                        printk (KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
+
+#define dbgarg2(fmt, arg...) \
+                if (vfd->debug & V4L2_DEBUG_IOCTL_ARG)                  \
+                        printk (KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
+
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
@@ -30,7 +41,13 @@
 #include <asm/uaccess.h>
 #include <asm/system.h>
 
+#define __OLD_VIDIOC_ /* To allow fixing old calls*/
+#include <linux/videodev2.h>
+
+#ifdef CONFIG_VIDEO_V4L1
 #include <linux/videodev.h>
+#endif
+#include <media/v4l2-common.h>
 
 #define VIDEO_NUM_DEVICES       256
 #define VIDEO_NAME              "video4linux"
@@ -41,7 +58,8 @@
 
 static ssize_t show_name(struct class_device *cd, char *buf)
 {
-        struct video_device *vfd = container_of(cd, struct video_device, class_dev);
+        struct video_device *vfd = container_of(cd, struct video_device,
+                                                                class_dev);
         return sprintf(buf,"%.*s\n",(int)sizeof(vfd->name),vfd->name);
 }
 
@@ -62,7 +80,8 @@ void video_device_release(struct video_device *vfd)
 
 static void video_release(struct class_device *cd)
 {
-        struct video_device *vfd = container_of(cd, struct video_device, class_dev);
+        struct video_device *vfd = container_of(cd, struct video_device,
+                                                                class_dev);
 
 #if 1
         /* needed until all drivers are fixed */
@@ -90,7 +109,7 @@ struct video_device* video_devdata(struct file *file)
 }
 
 /*
- *      Open a video device.
+ *      Open a video device - FIXME: Obsoleted
  */
 static int video_open(struct inode *inode, struct file *file)
 {
@@ -130,6 +149,7 @@ static int video_open(struct inode *inode, struct file *file)
  * helper function -- handles userspace copying for ioctl arguments
  */
 
+#ifdef __OLD_VIDIOC_
 static unsigned int
 video_fix_command(unsigned int cmd)
 {
@@ -155,7 +175,11 @@ video_fix_command(unsigned int cmd)
         }
         return cmd;
 }
+#endif
 
+/*
+ * Obsolete usercopy function - Should be removed soon
+ */
 int
 video_usercopy(struct inode *inode, struct file *file,
                unsigned int cmd, unsigned long arg,
@@ -166,8 +190,15 @@ video_usercopy(struct inode *inode, struct file *file,
         void    *mbuf = NULL;
         void    *parg = NULL;
         int     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)) {
@@ -193,14 +224,43 @@ video_usercopy(struct inode *inode, struct file *file,
                                 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(inode, 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))
         {
@@ -218,6 +278,7 @@ out:
 
 /*
  * open/release helper functions -- handle exclusive opens
+ * Should be removed soon
  */
 int video_exclusive_open(struct inode *inode, struct file *file)
 {
@@ -242,6 +303,1184 @@ int video_exclusive_release(struct inode *inode, struct file *file)
         return 0;
 }
 
+static char *v4l2_memory_names[] = {
+        [V4L2_MEMORY_MMAP]    = "mmap",
+        [V4L2_MEMORY_USERPTR] = "userptr",
+        [V4L2_MEMORY_OVERLAY] = "overlay",
+};
+
+
+/* FIXME: Those stuff are replicated also on v4l2-common.c */
+static char *v4l2_type_names_FIXME[] = {
+        [V4L2_BUF_TYPE_VIDEO_CAPTURE]      = "video-cap",
+        [V4L2_BUF_TYPE_VIDEO_OVERLAY]      = "video-over",
+        [V4L2_BUF_TYPE_VIDEO_OUTPUT]       = "video-out",
+        [V4L2_BUF_TYPE_VBI_CAPTURE]        = "vbi-cap",
+        [V4L2_BUF_TYPE_VBI_OUTPUT]         = "vbi-out",
+        [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT]  = "sliced-vbi-out",
+        [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-capture",
+        [V4L2_BUF_TYPE_PRIVATE]            = "private",
+};
+
+static char *v4l2_field_names_FIXME[] = {
+        [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",
+};
+
+#define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown"
+
+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\n",
+                        (p->timestamp.tv_sec/3600),
+                        (int)(p->timestamp.tv_sec/60)%60,
+                        (int)(p->timestamp.tv_sec%60),
+                        p->timestamp.tv_usec,
+                        p->index,
+                        prt_names(p->type,v4l2_type_names_FIXME),
+                        p->bytesused,p->flags,
+                        p->field,p->sequence,
+                        prt_names(p->memory,v4l2_memory_names),
+                        p->m.userptr);
+        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=0x%08x, field=%s, "
+                "bytesperline=%d sizeimage=%d, colorspace=%d\n",
+                fmt->width,fmt->height,fmt->pixelformat,
+                prt_names(fmt->field,v4l2_field_names_FIXME),
+                fmt->bytesperline,fmt->sizeimage,fmt->colorspace);
+};
+
+
+static int check_fmt (struct video_device *vfd, enum v4l2_buf_type type)
+{
+        switch (type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                if (vfd->vidioc_try_fmt_cap)
+                        return (0);
+                break;
+        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                if (vfd->vidioc_try_fmt_overlay)
+                        return (0);
+                break;
+        case V4L2_BUF_TYPE_VBI_CAPTURE:
+                if (vfd->vidioc_try_fmt_vbi)
+                        return (0);
+                break;
+        case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                if (vfd->vidioc_try_fmt_vbi_output)
+                        return (0);
+                break;
+        case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                if (vfd->vidioc_try_fmt_vbi_capture)
+                        return (0);
+                break;
+        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                if (vfd->vidioc_try_fmt_video_output)
+                        return (0);
+                break;
+        case V4L2_BUF_TYPE_VBI_OUTPUT:
+                if (vfd->vidioc_try_fmt_vbi_output)
+                        return (0);
+                break;
+        case V4L2_BUF_TYPE_PRIVATE:
+                if (vfd->vidioc_try_fmt_type_private)
+                        return (0);
+                break;
+        }
+        return (-EINVAL);
+}
+
+static int __video_do_ioctl(struct inode *inode, struct file *file,
+                unsigned int cmd, void *arg)
+{
+        struct video_device *vfd = video_devdata(file);
+        void                 *fh = file->private_data;
+        int                  ret = -EINVAL;
+
+        if ( (vfd->debug & V4L2_DEBUG_IOCTL) &&
+                                !(vfd->debug | V4L2_DEBUG_IOCTL_ARG)) {
+                v4l_print_ioctl(vfd->name, cmd);
+        }
+
+        switch(cmd) {
+        /* --- capabilities ------------------------------------------ */
+        case VIDIOC_QUERYCAP:
+        {
+                struct v4l2_capability *cap = (struct v4l2_capability*)arg;
+                memset(cap, 0, sizeof(*cap));
+
+                if (!vfd->vidioc_querycap)
+                        break;
+
+                ret=vfd->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 (!vfd->vidioc_g_priority)
+                        break;
+                ret=vfd->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 (!vfd->vidioc_s_priority)
+                        break;
+                dbgarg(cmd, "setting priority to %d\n", *p);
+                ret=vfd->vidioc_s_priority(file, fh, *p);
+                break;
+        }
+
+        /* --- capture ioctls ---------------------------------------- */
+        case VIDIOC_ENUM_FMT:
+        {
+                struct v4l2_fmtdesc *f = arg;
+                enum v4l2_buf_type type;
+                unsigned int index;
+
+                index = f->index;
+                type  = f->type;
+                memset(f,0,sizeof(*f));
+                f->index = index;
+                f->type  = type;
+
+                switch (type) {
+                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                        if (vfd->vidioc_enum_fmt_cap)
+                                ret=vfd->vidioc_enum_fmt_cap(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                        if (vfd->vidioc_enum_fmt_overlay)
+                                ret=vfd->vidioc_enum_fmt_overlay(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VBI_CAPTURE:
+                        if (vfd->vidioc_enum_fmt_vbi)
+                                ret=vfd->vidioc_enum_fmt_vbi(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                        if (vfd->vidioc_enum_fmt_vbi_output)
+                                ret=vfd->vidioc_enum_fmt_vbi_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                        if (vfd->vidioc_enum_fmt_vbi_capture)
+                                ret=vfd->vidioc_enum_fmt_vbi_capture(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                        if (vfd->vidioc_enum_fmt_video_output)
+                                ret=vfd->vidioc_enum_fmt_video_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VBI_OUTPUT:
+                        if (vfd->vidioc_enum_fmt_vbi_output)
+                                ret=vfd->vidioc_enum_fmt_vbi_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_PRIVATE:
+                        if (vfd->vidioc_enum_fmt_type_private)
+                                ret=vfd->vidioc_enum_fmt_type_private(file,
+                                                                fh, f);
+                        break;
+                }
+                if (!ret)
+                        dbgarg (cmd, "index=%d, type=%d, flags=%d, "
+                                        "description=%s,"
+                                        " pixelformat=0x%8x\n",
+                                        f->index, f->type, f->flags,
+                                        f->description,
+                                        f->pixelformat);
+
+                break;
+        }
+        case VIDIOC_G_FMT:
+        {
+                struct v4l2_format *f = (struct v4l2_format *)arg;
+                enum v4l2_buf_type type=f->type;
+
+                memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
+                f->type=type;
+
+                /* FIXME: Should be one dump per type */
+                dbgarg (cmd, "type=%s\n", prt_names(type,
+                                        v4l2_type_names_FIXME));
+
+                switch (type) {
+                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                        if (vfd->vidioc_g_fmt_cap)
+                                ret=vfd->vidioc_g_fmt_cap(file, fh, f);
+                        if (!ret)
+                                v4l_print_pix_fmt(vfd,&f->fmt.pix);
+                        break;
+                case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                        if (vfd->vidioc_g_fmt_overlay)
+                                ret=vfd->vidioc_g_fmt_overlay(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VBI_CAPTURE:
+                        if (vfd->vidioc_g_fmt_vbi)
+                                ret=vfd->vidioc_g_fmt_vbi(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                        if (vfd->vidioc_g_fmt_vbi_output)
+                                ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                        if (vfd->vidioc_g_fmt_vbi_capture)
+                                ret=vfd->vidioc_g_fmt_vbi_capture(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                        if (vfd->vidioc_g_fmt_video_output)
+                                ret=vfd->vidioc_g_fmt_video_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VBI_OUTPUT:
+                        if (vfd->vidioc_g_fmt_vbi_output)
+                                ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_PRIVATE:
+                        if (vfd->vidioc_g_fmt_type_private)
+                                ret=vfd->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_FIXME));
+
+                switch (f->type) {
+                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                        v4l_print_pix_fmt(vfd,&f->fmt.pix);
+                        if (vfd->vidioc_s_fmt_cap)
+                                ret=vfd->vidioc_s_fmt_cap(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                        if (vfd->vidioc_s_fmt_overlay)
+                                ret=vfd->vidioc_s_fmt_overlay(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VBI_CAPTURE:
+                        if (vfd->vidioc_s_fmt_vbi)
+                                ret=vfd->vidioc_s_fmt_vbi(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                        if (vfd->vidioc_s_fmt_vbi_output)
+                                ret=vfd->vidioc_s_fmt_vbi_output(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                        if (vfd->vidioc_s_fmt_vbi_capture)
+                                ret=vfd->vidioc_s_fmt_vbi_capture(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                        if (vfd->vidioc_s_fmt_video_output)
+                                ret=vfd->vidioc_s_fmt_video_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VBI_OUTPUT:
+                        if (vfd->vidioc_s_fmt_vbi_output)
+                                ret=vfd->vidioc_s_fmt_vbi_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_PRIVATE:
+                        if (vfd->vidioc_s_fmt_type_private)
+                                ret=vfd->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_FIXME));
+                switch (f->type) {
+                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                        if (vfd->vidioc_try_fmt_cap)
+                                ret=vfd->vidioc_try_fmt_cap(file, fh, f);
+                        if (!ret)
+                                v4l_print_pix_fmt(vfd,&f->fmt.pix);
+                        break;
+                case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                        if (vfd->vidioc_try_fmt_overlay)
+                                ret=vfd->vidioc_try_fmt_overlay(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VBI_CAPTURE:
+                        if (vfd->vidioc_try_fmt_vbi)
+                                ret=vfd->vidioc_try_fmt_vbi(file, fh, f);
+                        break;
+                case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                        if (vfd->vidioc_try_fmt_vbi_output)
+                                ret=vfd->vidioc_try_fmt_vbi_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                        if (vfd->vidioc_try_fmt_vbi_capture)
+                                ret=vfd->vidioc_try_fmt_vbi_capture(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                        if (vfd->vidioc_try_fmt_video_output)
+                                ret=vfd->vidioc_try_fmt_video_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_VBI_OUTPUT:
+                        if (vfd->vidioc_try_fmt_vbi_output)
+                                ret=vfd->vidioc_try_fmt_vbi_output(file,
+                                                                fh, f);
+                        break;
+                case V4L2_BUF_TYPE_PRIVATE:
+                        if (vfd->vidioc_try_fmt_type_private)
+                                ret=vfd->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 (!vfd->vidioc_reqbufs)
+                        break;
+                ret = check_fmt (vfd, p->type);
+                if (ret)
+                        break;
+
+                ret=vfd->vidioc_reqbufs(file, fh, p);
+                dbgarg (cmd, "count=%d, type=%s, memory=%s\n",
+                                p->count,
+                                prt_names(p->type,v4l2_type_names_FIXME),
+                                prt_names(p->memory,v4l2_memory_names));
+                break;
+        }
+        case VIDIOC_QUERYBUF:
+        {
+                struct v4l2_buffer *p=arg;
+
+                if (!vfd->vidioc_querybuf)
+                        break;
+                ret = check_fmt (vfd, p->type);
+                if (ret)
+                        break;
+
+                ret=vfd->vidioc_querybuf(file, fh, p);
+                if (!ret)
+                        dbgbuf(cmd,vfd,p);
+                break;
+        }
+        case VIDIOC_QBUF:
+        {
+                struct v4l2_buffer *p=arg;
+
+                if (!vfd->vidioc_qbuf)
+                        break;
+                ret = check_fmt (vfd, p->type);
+                if (ret)
+                        break;
+
+                ret=vfd->vidioc_qbuf(file, fh, p);
+                if (!ret)
+                        dbgbuf(cmd,vfd,p);
+                break;
+        }
+        case VIDIOC_DQBUF:
+        {
+                struct v4l2_buffer *p=arg;
+                if (!vfd->vidioc_qbuf)
+                        break;
+                ret = check_fmt (vfd, p->type);
+                if (ret)
+                        break;
+
+                ret=vfd->vidioc_qbuf(file, fh, p);
+                if (!ret)
+                        dbgbuf(cmd,vfd,p);
+                break;
+        }
+        case VIDIOC_OVERLAY:
+        {
+                int *i = arg;
+
+                if (!vfd->vidioc_overlay)
+                        break;
+                dbgarg (cmd, "value=%d\n",*i);
+                ret=vfd->vidioc_overlay(file, fh, *i);
+                break;
+        }
+#ifdef HAVE_V4L1
+        /* --- streaming capture ------------------------------------- */
+        case VIDIOCGMBUF:
+        {
+                struct video_mbuf *p=arg;
+
+                memset(p,0,sizeof(p));
+
+                if (!vfd->vidiocgmbuf)
+                        break;
+                ret=vfd->vidiocgmbuf(file, fh, p);
+                if (!ret)
+                        dbgarg (cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
+                                                p->size, p->frames,
+                                                (unsigned long)p->offsets);
+                break;
+        }
+#endif
+        case VIDIOC_G_FBUF:
+        {
+                struct v4l2_framebuffer *p=arg;
+                if (!vfd->vidioc_g_fbuf)
+                        break;
+                ret=vfd->vidioc_g_fbuf(file, fh, arg);
+                if (!ret) {
+                        dbgarg (cmd, "capability=%d, 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 (!vfd->vidioc_s_fbuf)
+                        break;
+
+                dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
+                                p->capability,p->flags,(unsigned long)p->base);
+                v4l_print_pix_fmt (vfd, &p->fmt);
+                ret=vfd->vidioc_s_fbuf(file, fh, arg);
+
+                break;
+        }
+        case VIDIOC_STREAMON:
+        {
+                enum v4l2_buf_type i = *(int *)arg;
+                if (!vfd->vidioc_streamon)
+                        break;
+                dbgarg (cmd, "type=%s\n", prt_names(i,v4l2_type_names_FIXME));
+                ret=vfd->vidioc_streamon(file, fh,i);
+                break;
+        }
+        case VIDIOC_STREAMOFF:
+        {
+                enum v4l2_buf_type i = *(int *)arg;
+
+                if (!vfd->vidioc_streamoff)
+                        break;
+                dbgarg (cmd, "type=%s\n", prt_names(i,v4l2_type_names_FIXME));
+                ret=vfd->vidioc_streamoff(file, fh, i);
+                break;
+        }
+        /* ---------- tv norms ---------- */
+        case VIDIOC_ENUMSTD:
+        {
+                struct v4l2_standard *p = arg;
+                unsigned int index = p->index;
+
+                if (!vfd->tvnormsize) {
+                        printk (KERN_WARNING "%s: no TV norms defined!\n",
+                                                vfd->name);
+                        break;
+                }
+
+                if (index<=0 || index >= vfd->tvnormsize) {
+                        ret=-EINVAL;
+                        break;
+                }
+                v4l2_video_std_construct(p, vfd->tvnorms[p->index].id,
+                                         vfd->tvnorms[p->index].name);
+                p->index = index;
+
+                dbgarg (cmd, "index=%d, id=%Ld, 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;
+
+                *id = vfd->current_norm;
+
+                dbgarg (cmd, "value=%Lu\n", (long long unsigned) *id);
+
+                ret=0;
+                break;
+        }
+        case VIDIOC_S_STD:
+        {
+                v4l2_std_id *id = arg;
+                unsigned int i;
+
+                if (!vfd->tvnormsize) {
+                        printk (KERN_WARNING "%s: no TV norms defined!\n",
+                                                vfd->name);
+                        break;
+                }
+
+                dbgarg (cmd, "value=%Lu\n", (long long unsigned) *id);
+
+                /* First search for exact match */
+                for (i = 0; i < vfd->tvnormsize; i++)
+                        if (*id == vfd->tvnorms[i].id)
+                                break;
+                /* Then for a generic video std that contains desired std */
+                if (i == vfd->tvnormsize)
+                        for (i = 0; i < vfd->tvnormsize; i++)
+                                if (*id & vfd->tvnorms[i].id)
+                                        break;
+                if (i == vfd->tvnormsize) {
+                        break;
+                }
+
+                /* Calls the specific handler */
+                if (vfd->vidioc_s_std)
+                        ret=vfd->vidioc_s_std(file, fh, i);
+                else
+                        ret=-EINVAL;
+
+                /* Updates standard information */
+                if (!ret)
+                        vfd->current_norm=*id;
+
+                break;
+        }
+        case VIDIOC_QUERYSTD:
+        {
+                v4l2_std_id *p=arg;
+
+                if (!vfd->vidioc_querystd)
+                        break;
+                ret=vfd->vidioc_querystd(file, fh, arg);
+                if (!ret)
+                        dbgarg (cmd, "detected std=%Lu\n",
+                                                (unsigned long long)*p);
+                break;
+        }
+        /* ------ input switching ---------- */
+        /* FIXME: Inputs can be handled inside videodev2 */
+        case VIDIOC_ENUMINPUT:
+        {
+                struct v4l2_input *p=arg;
+                int i=p->index;
+
+                if (!vfd->vidioc_enum_input)
+                        break;
+                memset(p, 0, sizeof(*p));
+                p->index=i;
+
+                ret=vfd->vidioc_enum_input(file, fh, p);
+                if (!ret)
+                        dbgarg (cmd, "index=%d, name=%s, type=%d, "
+                                        "audioset=%d, "
+                                        "tuner=%d, std=%Ld, 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 (!vfd->vidioc_g_input)
+                        break;
+                ret=vfd->vidioc_g_input(file, fh, i);
+                if (!ret)
+                        dbgarg (cmd, "value=%d\n",*i);
+                break;
+        }
+        case VIDIOC_S_INPUT:
+        {
+                unsigned int *i = arg;
+
+                if (!vfd->vidioc_s_input)
+                        break;
+                dbgarg (cmd, "value=%d\n",*i);
+                ret=vfd->vidioc_s_input(file, fh, *i);
+                break;
+        }
+
+        /* ------ output switching ---------- */
+        case VIDIOC_G_OUTPUT:
+        {
+                unsigned int *i = arg;
+
+                if (!vfd->vidioc_g_output)
+                        break;
+                ret=vfd->vidioc_g_output(file, fh, i);
+                if (!ret)
+                        dbgarg (cmd, "value=%d\n",*i);
+                break;
+        }
+        case VIDIOC_S_OUTPUT:
+        {
+                unsigned int *i = arg;
+
+                if (!vfd->vidioc_s_output)
+                        break;
+                dbgarg (cmd, "value=%d\n",*i);
+                ret=vfd->vidioc_s_output(file, fh, *i);
+                break;
+        }
+
+        /* --- controls ---------------------------------------------- */
+        case VIDIOC_QUERYCTRL:
+        {
+                struct v4l2_queryctrl *p=arg;
+
+                if (!vfd->vidioc_queryctrl)
+                        break;
+                ret=vfd->vidioc_queryctrl(file, fh, p);
+
+                if (!ret)
+                        dbgarg (cmd, "id=%d, 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);
+                break;
+        }
+        case VIDIOC_G_CTRL:
+        {
+                struct v4l2_control *p = arg;
+
+                if (!vfd->vidioc_g_ctrl)
+                        break;
+                dbgarg(cmd, "Enum for index=%d\n", p->id);
+
+                ret=vfd->vidioc_g_ctrl(file, fh, p);
+                if (!ret)
+                        dbgarg2 ( "id=%d, value=%d\n", p->id, p->value);
+                break;
+        }
+        case VIDIOC_S_CTRL:
+        {
+                struct v4l2_control *p = arg;
+
+                if (!vfd->vidioc_s_ctrl)
+                        break;
+                dbgarg (cmd, "id=%d, value=%d\n", p->id, p->value);
+
+                ret=vfd->vidioc_s_ctrl(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_EXT_CTRLS:
+        {
+                struct v4l2_ext_controls *p = arg;
+
+                if (vfd->vidioc_g_ext_ctrls) {
+                        dbgarg(cmd, "count=%d\n", p->count);
+
+                        ret=vfd->vidioc_g_ext_ctrls(file, fh, p);
+                }
+                break;
+        }
+        case VIDIOC_S_EXT_CTRLS:
+        {
+                struct v4l2_ext_controls *p = arg;
+
+                if (vfd->vidioc_s_ext_ctrls) {
+                        dbgarg(cmd, "count=%d\n", p->count);
+
+                        ret=vfd->vidioc_s_ext_ctrls(file, fh, p);
+                }
+                break;
+        }
+        case VIDIOC_TRY_EXT_CTRLS:
+        {
+                struct v4l2_ext_controls *p = arg;
+
+                if (vfd->vidioc_try_ext_ctrls) {
+                        dbgarg(cmd, "count=%d\n", p->count);
+
+                        ret=vfd->vidioc_try_ext_ctrls(file, fh, p);
+                }
+                break;
+        }
+        case VIDIOC_QUERYMENU:
+        {
+                struct v4l2_querymenu *p=arg;
+                if (!vfd->vidioc_querymenu)
+                        break;
+                ret=vfd->vidioc_querymenu(file, fh, p);
+                if (!ret)
+                        dbgarg (cmd, "id=%d, index=%d, name=%s\n",
+                                                p->id,p->index,p->name);
+                break;
+        }
+        /* --- audio ---------------------------------------------- */
+        case VIDIOC_ENUMAUDIO:
+        {
+                struct v4l2_audio *p=arg;
+
+                if (!vfd->vidioc_enumaudio)
+                        break;
+                dbgarg(cmd, "Enum for index=%d\n", p->index);
+                ret=vfd->vidioc_enumaudio(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_AUDIO:
+        {
+                struct v4l2_audio *p=arg;
+
+                if (!vfd->vidioc_g_audio)
+                        break;
+                dbgarg(cmd, "Get for index=%d\n", p->index);
+                ret=vfd->vidioc_g_audio(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_AUDIO:
+        {
+                struct v4l2_audio *p=arg;
+
+                if (!vfd->vidioc_s_audio)
+                        break;
+                dbgarg(cmd, "index=%d, name=%s, capability=%d, "
+                                        "mode=%d\n", p->index, p->name,
+                                        p->capability, p->mode);
+                ret=vfd->vidioc_s_audio(file, fh, p);
+                break;
+        }
+        case VIDIOC_ENUMAUDOUT:
+        {
+                struct v4l2_audioout *p=arg;
+
+                if (!vfd->vidioc_enumaudout)
+                        break;
+                dbgarg(cmd, "Enum for index=%d\n", p->index);
+                ret=vfd->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 (!vfd->vidioc_g_audout)
+                        break;
+                dbgarg(cmd, "Enum for index=%d\n", p->index);
+                ret=vfd->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 (!vfd->vidioc_s_audout)
+                        break;
+                dbgarg(cmd, "index=%d, name=%s, capability=%d, "
+                                        "mode=%d\n", p->index, p->name,
+                                        p->capability,p->mode);
+
+                ret=vfd->vidioc_s_audout(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_MODULATOR:
+        {
+                struct v4l2_modulator *p=arg;
+                if (!vfd->vidioc_g_modulator)
+                        break;
+                ret=vfd->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 (!vfd->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=vfd->vidioc_s_modulator(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_CROP:
+        {
+                struct v4l2_crop *p=arg;
+                if (!vfd->vidioc_g_crop)
+                        break;
+                ret=vfd->vidioc_g_crop(file, fh, p);
+                if (!ret) {
+                        dbgarg(cmd, "type=%d\n", p->type);
+                        dbgrect(vfd, "", &p->c);
+                }
+                break;
+        }
+        case VIDIOC_S_CROP:
+        {
+                struct v4l2_crop *p=arg;
+                if (!vfd->vidioc_s_crop)
+                        break;
+                dbgarg(cmd, "type=%d\n", p->type);
+                dbgrect(vfd, "", &p->c);
+                ret=vfd->vidioc_s_crop(file, fh, p);
+                break;
+        }
+        case VIDIOC_CROPCAP:
+        {
+                struct v4l2_cropcap *p=arg;
+                /*FIXME: Should also show v4l2_fract pixelaspect */
+                if (!vfd->vidioc_cropcap)
+                        break;
+                dbgarg(cmd, "type=%d\n", p->type);
+                dbgrect(vfd, "bounds ", &p->bounds);
+                dbgrect(vfd, "defrect ", &p->defrect);
+                ret=vfd->vidioc_cropcap(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_MPEGCOMP:
+        {
+                struct v4l2_mpeg_compression *p=arg;
+
+                /*FIXME: Several fields not shown */
+                if (!vfd->vidioc_g_mpegcomp)
+                        break;
+                ret=vfd->vidioc_g_mpegcomp(file, fh, p);
+                if (!ret)
+                        dbgarg (cmd, "ts_pid_pmt=%d, ts_pid_audio=%d,"
+                                        " ts_pid_video=%d, ts_pid_pcr=%d, "
+                                        "ps_size=%d, au_sample_rate=%d, "
+                                        "au_pesid=%c, vi_frame_rate=%d, "
+                                        "vi_frames_per_gop=%d, "
+                                        "vi_bframes_count=%d, vi_pesid=%c\n",
+                                        p->ts_pid_pmt,p->ts_pid_audio,
+                                        p->ts_pid_video,p->ts_pid_pcr,
+                                        p->ps_size, p->au_sample_rate,
+                                        p->au_pesid, p->vi_frame_rate,
+                                        p->vi_frames_per_gop,
+                                        p->vi_bframes_count, p->vi_pesid);
+                break;
+        }
+        case VIDIOC_S_MPEGCOMP:
+        {
+                struct v4l2_mpeg_compression *p=arg;
+                /*FIXME: Several fields not shown */
+                if (!vfd->vidioc_s_mpegcomp)
+                        break;
+                dbgarg (cmd, "ts_pid_pmt=%d, ts_pid_audio=%d, "
+                                "ts_pid_video=%d, ts_pid_pcr=%d, ps_size=%d, "
+                                "au_sample_rate=%d, au_pesid=%c, "
+                                "vi_frame_rate=%d, vi_frames_per_gop=%d, "
+                                "vi_bframes_count=%d, vi_pesid=%c\n",
+                                p->ts_pid_pmt,p->ts_pid_audio, p->ts_pid_video,
+                                p->ts_pid_pcr, p->ps_size, p->au_sample_rate,
+                                p->au_pesid, p->vi_frame_rate,
+                                p->vi_frames_per_gop, p->vi_bframes_count,
+                                p->vi_pesid);
+                ret=vfd->vidioc_s_mpegcomp(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_JPEGCOMP:
+        {
+                struct v4l2_jpegcompression *p=arg;
+                if (!vfd->vidioc_g_jpegcomp)
+                        break;
+                ret=vfd->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 (!vfd->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=vfd->vidioc_s_jpegcomp(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_PARM:
+        {
+                struct v4l2_streamparm *p=arg;
+                if (!vfd->vidioc_g_parm)
+                        break;
+                ret=vfd->vidioc_g_parm(file, fh, p);
+                dbgarg (cmd, "type=%d\n", p->type);
+                break;
+        }
+        case VIDIOC_S_PARM:
+        {
+                struct v4l2_streamparm *p=arg;
+                if (!vfd->vidioc_s_parm)
+                        break;
+                dbgarg (cmd, "type=%d\n", p->type);
+                ret=vfd->vidioc_s_parm(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_TUNER:
+        {
+                struct v4l2_tuner *p=arg;
+                if (!vfd->vidioc_g_tuner)
+                        break;
+                ret=vfd->vidioc_g_tuner(file, fh, p);
+                if (!ret)
+                        dbgarg (cmd, "index=%d, name=%s, type=%d, "
+                                        "capability=%d, rangelow=%d, "
+                                        "rangehigh=%d, signal=%d, afc=%d, "
+                                        "rxsubchans=%d, audmode=%d\n",
+                                        p->index, p->name, p->type,
+                                        p->capability, p->rangelow,
+                                        p->rangehigh, p->rxsubchans,
+                                        p->audmode, p->signal, p->afc);
+                break;
+        }
+        case VIDIOC_S_TUNER:
+        {
+                struct v4l2_tuner *p=arg;
+                if (!vfd->vidioc_s_tuner)
+                        break;
+                dbgarg (cmd, "index=%d, name=%s, type=%d, "
+                                "capability=%d, rangelow=%d, rangehigh=%d, "
+                                "signal=%d, afc=%d, rxsubchans=%d, "
+                                "audmode=%d\n",p->index, p->name, p->type,
+                                p->capability, p->rangelow,p->rangehigh,
+                                p->rxsubchans, p->audmode, p->signal,
+                                p->afc);
+                ret=vfd->vidioc_s_tuner(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_FREQUENCY:
+        {
+                struct v4l2_frequency *p=arg;
+                if (!vfd->vidioc_g_frequency)
+                        break;
+                ret=vfd->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 (!vfd->vidioc_s_frequency)
+                        break;
+                dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
+                                p->tuner,p->type,p->frequency);
+                ret=vfd->vidioc_s_frequency(file, fh, p);
+                break;
+        }
+        case VIDIOC_G_SLICED_VBI_CAP:
+        {
+                struct v4l2_sliced_vbi_cap *p=arg;
+                if (!vfd->vidioc_g_sliced_vbi_cap)
+                        break;
+                ret=vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
+                if (!ret)
+                        dbgarg (cmd, "service_set=%d\n", p->service_set);
+                break;
+        }
+        case VIDIOC_LOG_STATUS:
+        {
+                if (!vfd->vidioc_log_status)
+                        break;
+                ret=vfd->vidioc_log_status(file, fh);
+                break;
+        }
+
+        /* --- Others --------------------------------------------- */
+
+        default:
+                ret=v4l_compat_translate_ioctl(inode,file,cmd,arg,__video_do_ioctl);
+        }
+
+        if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
+                if (ret<0) {
+                        printk ("%s: err:\n", vfd->name);
+                        v4l_print_ioctl(vfd->name, cmd);
+                }
+        }
+
+        return ret;
+}
+
+int video_ioctl2 (struct inode *inode, struct file *file,
+               unsigned int cmd, unsigned long arg)
+{
+        char    sbuf[128];
+        void    *mbuf = NULL;
+        void    *parg = NULL;
+        int     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;
+                }
+        }
+
+        /* Handles IOCTL */
+        err = __video_do_ioctl(inode, 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;
+}
+
+
 static struct file_operations video_fops;
 
 /**
@@ -371,7 +1610,9 @@ void video_unregister_device(struct video_device *vfd)
         mutex_unlock(&videodev_lock);
 }
 
-
+/*
+ * Video fs operations
+ */
 static struct file_operations video_fops=
 {
         .owner          = THIS_MODULE,
@@ -387,7 +1628,7 @@ static int __init videodev_init(void)
 {
         int ret;
 
-        printk(KERN_INFO "Linux video capture interface: v1.00\n");
+        printk(KERN_INFO "Linux video capture interface: v2.00\n");
         if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
                 printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
                 return -EIO;
@@ -418,11 +1659,12 @@ EXPORT_SYMBOL(video_devdata);
 EXPORT_SYMBOL(video_usercopy);
 EXPORT_SYMBOL(video_exclusive_open);
 EXPORT_SYMBOL(video_exclusive_release);
+EXPORT_SYMBOL(video_ioctl2);
 EXPORT_SYMBOL(video_device_alloc);
 EXPORT_SYMBOL(video_device_release);
 
-MODULE_AUTHOR("Alan Cox");
-MODULE_DESCRIPTION("Device registrar for Video4Linux drivers");
+MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
+MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
 MODULE_LICENSE("GPL");
 
 
diff --git a/drivers/media/video/vino.c b/drivers/media/video/vino.c
index a8c101494cf..268e69fdefc 100644
--- a/drivers/media/video/vino.c
+++ b/drivers/media/video/vino.c
@@ -40,7 +40,7 @@
 #include <linux/i2c-algo-sgi.h>
 
 #include <linux/videodev.h>
-#include <linux/videodev2.h>
+#include <media/v4l2-common.h>
 #include <linux/video_decoder.h>
 #include <linux/mutex.h>
 
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index 779db26771c..41d23c8acbd 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -48,34 +48,15 @@
 
 #include "font.h"
 
-#ifndef kzalloc
-#define kzalloc(size, flags)                            \
-({                                                      \
-        void *__ret = kmalloc(size, flags);             \
-        if (__ret)                                      \
-                memset(__ret, 0, size);                 \
-        __ret;                                          \
-})
-#endif
-
-MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
-MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
-MODULE_LICENSE("Dual BSD/GPL");
-
 #define VIVI_MAJOR_VERSION 0
 #define VIVI_MINOR_VERSION 4
 #define VIVI_RELEASE 0
 #define VIVI_VERSION KERNEL_VERSION(VIVI_MAJOR_VERSION, VIVI_MINOR_VERSION, VIVI_RELEASE)
 
-static int video_nr = -1;        /* /dev/videoN, -1 for autodetect */
-module_param(video_nr, int, 0);
-
-static int debug = 0;
-module_param(debug, int, 0);
-
-static unsigned int vid_limit = 16;
-module_param(vid_limit,int,0644);
-MODULE_PARM_DESC(vid_limit,"capture memory limit in megabytes");
+/* Declare static vars that will be used as parameters */
+static unsigned int vid_limit = 16;     /* Video memory limit, in Mb */
+static struct video_device vivi;        /* Video device */
+static int video_nr = -1;               /* /dev/videoN, -1 for autodetect */
 
 /* supported controls */
 static struct v4l2_queryctrl vivi_qctrl[] = {
@@ -129,10 +110,10 @@ static struct v4l2_queryctrl vivi_qctrl[] = {
 
 static int qctl_regs[ARRAY_SIZE(vivi_qctrl)];
 
-#define dprintk(level,fmt, arg...)                           \
-        do {                                                 \
-                if (debug >= (level))                        \
-                        printk(KERN_DEBUG "vivi: " fmt , ## arg);    \
+#define dprintk(level,fmt, arg...)                                      \
+        do {                                                            \
+                if (vivi.debug >= (level))                              \
+                        printk(KERN_DEBUG "vivi: " fmt , ## arg);       \
         } while (0)
 
 /* ------------------------------------------------------------------
@@ -190,7 +171,7 @@ struct vivi_dev {
 
         /* various device info */
         unsigned int               resources;
-        struct video_device        video_dev;
+        struct video_device        vfd;
 
         struct vivi_dmaqueue       vidq;
 
@@ -248,7 +229,8 @@ static u8 bars[8][3] = {
 #define TSTAMP_MAX_Y TSTAMP_MIN_Y+15
 #define TSTAMP_MIN_X 64
 
-void prep_to_addr(struct sg_to_addr to_addr[],struct videobuf_buffer *vb)
+static void prep_to_addr(struct sg_to_addr to_addr[],
+                         struct videobuf_buffer *vb)
 {
         int i, pos=0;
 
@@ -259,7 +241,7 @@ void prep_to_addr(struct sg_to_addr to_addr[],struct videobuf_buffer *vb)
         }
 }
 
-inline int get_addr_pos(int pos, int pages, struct sg_to_addr to_addr[])
+static int get_addr_pos(int pos, int pages, struct sg_to_addr to_addr[])
 {
         int p1=0,p2=pages-1,p3=pages/2;
 
@@ -280,8 +262,8 @@ inline int get_addr_pos(int pos, int pages, struct sg_to_addr to_addr[])
         return (p1);
 }
 
-void gen_line(struct sg_to_addr to_addr[],int inipos,int pages,int wmax,
-                                        int hmax, int line, char *timestr)
+static void gen_line(struct sg_to_addr to_addr[],int inipos,int pages,int wmax,
+                     int hmax, int line, char *timestr)
 {
         int  w,i,j,pos=inipos,pgpos,oldpg,y;
         char *p,*s,*basep;
@@ -491,7 +473,7 @@ static void vivi_thread_tick(struct vivi_dmaqueue  *dma_q)
                 dprintk(1,"%s: %d buffers handled (should be 1)\n",__FUNCTION__,bc);
 }
 
-void vivi_sleep(struct vivi_dmaqueue  *dma_q)
+static void vivi_sleep(struct vivi_dmaqueue  *dma_q)
 {
         int timeout;
         DECLARE_WAITQUEUE(wait, current);
@@ -526,7 +508,7 @@ void vivi_sleep(struct vivi_dmaqueue  *dma_q)
         try_to_freeze();
 }
 
-int vivi_thread(void *data)
+static int vivi_thread(void *data)
 {
         struct vivi_dmaqueue  *dma_q=data;
 
@@ -542,7 +524,7 @@ int vivi_thread(void *data)
         return 0;
 }
 
-int vivi_start_thread(struct vivi_dmaqueue  *dma_q)
+static int vivi_start_thread(struct vivi_dmaqueue  *dma_q)
 {
         dma_q->frame=0;
         dma_q->ini_jiffies=jiffies;
@@ -560,7 +542,7 @@ int vivi_start_thread(struct vivi_dmaqueue  *dma_q)
         return 0;
 }
 
-void vivi_stop_thread(struct vivi_dmaqueue  *dma_q)
+static void vivi_stop_thread(struct vivi_dmaqueue  *dma_q)
 {
         dprintk(1,"%s\n",__FUNCTION__);
         /* shutdown control thread */
@@ -666,8 +648,7 @@ buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
         return 0;
 }
 
-void
-free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
+static void free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
 {
         dprintk(1,"%s\n",__FUNCTION__);
 
@@ -791,8 +772,8 @@ static void buffer_release(struct videobuf_queue *vq, struct videobuf_buffer *vb
         free_buffer(vq,buf);
 }
 
-int vivi_map_sg (void *dev, struct scatterlist *sg, int nents,
-           int direction)
+static int vivi_map_sg(void *dev, struct scatterlist *sg, int nents,
+                       int direction)
 {
         int i;
 
@@ -808,15 +789,15 @@ int vivi_map_sg (void *dev, struct scatterlist *sg, int nents,
         return nents;
 }
 
-int vivi_unmap_sg(void *dev,struct scatterlist *sglist,int nr_pages,
-                                        int direction)
+static int vivi_unmap_sg(void *dev,struct scatterlist *sglist,int nr_pages,
+                         int direction)
 {
         dprintk(1,"%s\n",__FUNCTION__);
         return 0;
 }
 
-int vivi_dma_sync_sg(void *dev,struct scatterlist *sglist,int nr_pages,
-                                        int direction)
+static int vivi_dma_sync_sg(void *dev,struct scatterlist *sglist, int nr_pages,
+                            int direction)
 {
 //      dprintk(1,"%s\n",__FUNCTION__);
 
@@ -840,7 +821,80 @@ static struct videobuf_queue_ops vivi_video_qops = {
         IOCTL handling
    ------------------------------------------------------------------*/
 
-static int vivi_try_fmt(struct vivi_dev *dev, struct vivi_fh *fh,
+
+static int res_get(struct vivi_dev *dev, struct vivi_fh *fh)
+{
+        /* is it free? */
+        down(&dev->lock);
+        if (dev->resources) {
+                /* no, someone else uses it */
+                up(&dev->lock);
+                return 0;
+        }
+        /* it's free, grab it */
+        dev->resources =1;
+        dprintk(1,"res: get\n");
+        up(&dev->lock);
+        return 1;
+}
+
+static int res_locked(struct vivi_dev *dev)
+{
+        return (dev->resources);
+}
+
+static void res_free(struct vivi_dev *dev, struct vivi_fh *fh)
+{
+        down(&dev->lock);
+        dev->resources = 0;
+        dprintk(1,"res: put\n");
+        up(&dev->lock);
+}
+
+/* ------------------------------------------------------------------
+        IOCTL vidioc handling
+   ------------------------------------------------------------------*/
+static int vidioc_querycap (struct file *file, void  *priv,
+                                        struct v4l2_capability *cap)
+{
+        strcpy(cap->driver, "vivi");
+        strcpy(cap->card, "vivi");
+        cap->version = VIVI_VERSION;
+        cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
+                                V4L2_CAP_STREAMING     |
+                                V4L2_CAP_READWRITE;
+        return 0;
+}
+
+static int vidioc_enum_fmt_cap (struct file *file, void  *priv,
+                                        struct v4l2_fmtdesc *f)
+{
+        if (f->index > 0)
+                return -EINVAL;
+
+        strlcpy(f->description,format.name,sizeof(f->description));
+        f->pixelformat = format.fourcc;
+        return 0;
+}
+
+static int vidioc_g_fmt_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_cap (struct file *file, void *priv,
                         struct v4l2_format *f)
 {
         struct vivi_fmt *fmt;
@@ -848,7 +902,8 @@ static int vivi_try_fmt(struct vivi_dev *dev, struct vivi_fh *fh,
         unsigned int maxw, maxh;
 
         if (format.fourcc != f->fmt.pix.pixelformat) {
-                dprintk(1,"Fourcc format invalid.\n");
+                dprintk(1,"Fourcc format (0x%08x) invalid. Driver accepts "
+                        "only 0x%08x\n",f->fmt.pix.pixelformat,format.fourcc);
                 return -EINVAL;
         }
         fmt=&format;
@@ -884,356 +939,196 @@ static int vivi_try_fmt(struct vivi_dev *dev, struct vivi_fh *fh,
         return 0;
 }
 
-static int res_get(struct vivi_dev *dev, struct vivi_fh *fh)
+/*FIXME: This seems to be generic enough to be at videodev2 */
+static int vidioc_s_fmt_cap (struct file *file, void *priv,
+                                        struct v4l2_format *f)
 {
-        /* is it free? */
-        down(&dev->lock);
-        if (dev->resources) {
-                /* no, someone else uses it */
-                up(&dev->lock);
-                return 0;
-        }
-        /* it's free, grab it */
-        dev->resources =1;
-        dprintk(1,"res: get\n");
-        up(&dev->lock);
-        return 1;
+        struct vivi_fh  *fh=priv;
+        int ret = vidioc_try_fmt_cap(file,fh,f);
+        if (ret < 0)
+                return (ret);
+
+        fh->fmt           = &format;
+        fh->width         = f->fmt.pix.width;
+        fh->height        = f->fmt.pix.height;
+        fh->vb_vidq.field = f->fmt.pix.field;
+        fh->type          = f->type;
+
+        return (0);
 }
 
-static inline int res_locked(struct vivi_dev *dev)
+static int vidioc_reqbufs (struct file *file, void *priv, struct v4l2_requestbuffers *p)
 {
-        return (dev->resources);
-}
+        struct vivi_fh  *fh=priv;
 
-static void res_free(struct vivi_dev *dev, struct vivi_fh *fh)
-{
-        down(&dev->lock);
-        dev->resources = 0;
-        dprintk(1,"res: put\n");
-        up(&dev->lock);
+        return (videobuf_reqbufs(&fh->vb_vidq, p));
 }
 
-static int vivi_do_ioctl(struct inode *inode, struct file *file, unsigned int cmd, void *arg)
+static int vidioc_querybuf (struct file *file, void *priv, struct v4l2_buffer *p)
 {
-        struct vivi_fh  *fh     = file->private_data;
-        struct vivi_dev *dev    = fh->dev;
-        int ret=0;
+        struct vivi_fh  *fh=priv;
 
-        if (debug) {
-                if (_IOC_DIR(cmd) & _IOC_WRITE)
-                        v4l_printk_ioctl_arg("vivi(w)",cmd, arg);
-                else if (!_IOC_DIR(cmd) & _IOC_READ) {
-                        v4l_print_ioctl("vivi", cmd);
-                }
-        }
+        return (videobuf_querybuf(&fh->vb_vidq, p));
+}
 
-        switch(cmd) {
-        /* --- capabilities ------------------------------------------ */
-        case VIDIOC_QUERYCAP:
-        {
-                struct v4l2_capability *cap = (struct v4l2_capability*)arg;
-
-                memset(cap, 0, sizeof(*cap));
-
-                strcpy(cap->driver, "vivi");
-                strcpy(cap->card, "vivi");
-                cap->version = VIVI_VERSION;
-                cap->capabilities =
-                                        V4L2_CAP_VIDEO_CAPTURE |
-                                        V4L2_CAP_STREAMING     |
-                                        V4L2_CAP_READWRITE;
-                break;
-        }
-        /* --- capture ioctls ---------------------------------------- */
-        case VIDIOC_ENUM_FMT:
-        {
-                struct v4l2_fmtdesc *f = arg;
-                enum v4l2_buf_type type;
-                unsigned int index;
+static int vidioc_qbuf (struct file *file, void *priv, struct v4l2_buffer *p)
+{
+        struct vivi_fh  *fh=priv;
 
-                index = f->index;
-                type  = f->type;
+        return (videobuf_qbuf(&fh->vb_vidq, p));
+}
 
-                if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        ret=-EINVAL;
-                        break;
-                }
+static int vidioc_dqbuf (struct file *file, void *priv, struct v4l2_buffer *p)
+{
+        struct vivi_fh  *fh=priv;
 
-                switch (type) {
-                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-                        if (index > 0){
-                                ret=-EINVAL;
-                                break;
-                        }
-                        memset(f,0,sizeof(*f));
+        return (videobuf_dqbuf(&fh->vb_vidq, p,
+                                file->f_flags & O_NONBLOCK));
+}
 
-                        f->index = index;
-                        f->type  = type;
-                        strlcpy(f->description,format.name,sizeof(f->description));
-                        f->pixelformat = format.fourcc;
-                        break;
-                default:
-                        ret=-EINVAL;
-                }
-                break;
+#ifdef HAVE_V4L1
+static int vidiocgmbuf (struct file *file, void *priv, struct video_mbuf *mbuf)
+{
+        struct vivi_fh  *fh=priv;
+        struct videobuf_queue *q=&fh->vb_vidq;
+        struct v4l2_requestbuffers req;
+        unsigned int i, ret;
+
+        req.type   = q->type;
+        req.count  = 8;
+        req.memory = V4L2_MEMORY_MMAP;
+        ret = videobuf_reqbufs(q,&req);
+        if (ret < 0)
+                return (ret);
+
+        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;
         }
-        case VIDIOC_G_FMT:
-        {
-                struct v4l2_format *f = (struct v4l2_format *)arg;
+        return (0);
+}
+#endif
 
-                if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        ret=-EINVAL;
-                        break;
-                }
+static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
+{
+        struct vivi_fh  *fh=priv;
+        struct vivi_dev *dev    = fh->dev;
 
-                memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
-                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;
-                break;
-        }
-        case VIDIOC_S_FMT:
-        {
-                struct v4l2_format *f = arg;
+        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+        if (i != fh->type)
+                return -EINVAL;
 
-                if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        dprintk(1,"Only capture supported.\n");
-                        ret=-EINVAL;
-                        break;
-                }
+        if (!res_get(dev,fh))
+                return -EBUSY;
+        return (videobuf_streamon(&fh->vb_vidq));
+}
 
-                ret = vivi_try_fmt(dev,fh,f);
-                if (ret < 0)
-                        break;
+static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
+{
+        struct vivi_fh  *fh=priv;
+        struct vivi_dev *dev    = fh->dev;
 
-                fh->fmt           = &format;
-                fh->width         = f->fmt.pix.width;
-                fh->height        = f->fmt.pix.height;
-                fh->vb_vidq.field = f->fmt.pix.field;
-                fh->type          = f->type;
+        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+        if (i != fh->type)
+                return -EINVAL;
 
-                break;
-        }
-        case VIDIOC_TRY_FMT:
-        {
-                struct v4l2_format *f = arg;
-                if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        ret=-EINVAL;
-                        break;
-                }
+        videobuf_streamoff(&fh->vb_vidq);
+        res_free(dev,fh);
 
-                ret=vivi_try_fmt(dev,fh,f);
-                break;
-        }
-        case VIDIOC_REQBUFS:
-                if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        ret=-EINVAL;
-                        break;
-                }
-                ret=videobuf_reqbufs(&fh->vb_vidq, arg);
-                break;
-        case VIDIOC_QUERYBUF:
-                if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        ret=-EINVAL;
-                        break;
-                }
-                ret=videobuf_querybuf(&fh->vb_vidq, arg);
-                break;
-        case VIDIOC_QBUF:
-                if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        ret=-EINVAL;
-                        break;
-                }
-                ret=videobuf_qbuf(&fh->vb_vidq, arg);
-                break;
-        case VIDIOC_DQBUF:
-                if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        ret=-EINVAL;
-                        break;
-                }
-                ret=videobuf_dqbuf(&fh->vb_vidq, arg,
-                                        file->f_flags & O_NONBLOCK);
-                break;
-#ifdef HAVE_V4L1
-        /* --- streaming capture ------------------------------------- */
-        case VIDIOCGMBUF:
-        {
-                struct video_mbuf *mbuf = arg;
-                struct videobuf_queue *q=&fh->vb_vidq;
-                struct v4l2_requestbuffers req;
-                unsigned int i;
-
-                memset(&req,0,sizeof(req));
-                req.type   = q->type;
-                req.count  = 8;
-                req.memory = V4L2_MEMORY_MMAP;
-                ret = videobuf_reqbufs(q,&req);
-                if (ret < 0)
-                        break;
-                memset(mbuf,0,sizeof(*mbuf));
-                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;
-                }
-                break;
-        }
-#endif
-        case VIDIOC_STREAMON:
-        {
-                if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                        return -EINVAL;
-                if (!res_get(dev,fh))
-                        return -EBUSY;
-                ret=videobuf_streamon(&fh->vb_vidq);
-                break;
-        }
-        case VIDIOC_STREAMOFF:
+        return (0);
+}
+
+static struct v4l2_tvnorm tvnorms[] = {
         {
-                if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                        ret=-EINVAL;
-                        break;
-                }
-                ret = videobuf_streamoff(&fh->vb_vidq);
-                if (ret < 0)
-                        break;
-                res_free(dev,fh);
-                break;
+                .name      = "NTSC-M",
+                .id        = V4L2_STD_NTSC_M,
         }
-        /* ---------- tv norms ---------- */
-        case VIDIOC_ENUMSTD:
-        {
-                struct v4l2_standard *e = arg;
+};
 
-                if (e->index>0) {
-                        ret=-EINVAL;
-                        break;
-                }
-                ret = v4l2_video_std_construct(e, V4L2_STD_NTSC_M, "NTSC-M");
+static int vidioc_s_std (struct file *file, void *priv, v4l2_std_id a)
+{
 
-                /* Allows vivi to use different fps from video std */
-                e->frameperiod.numerator = WAKE_NUMERATOR;
-                e->frameperiod.denominator = WAKE_DENOMINATOR;
+        return 0;
+}
 
-                break;
-        }
-        case VIDIOC_G_STD:
-        {
-                v4l2_std_id *id = arg;
+/* only one input in this sample driver */
+static int vidioc_enum_input (struct file *file, void *priv,
+                                struct v4l2_input *inp)
+{
+        if (inp->index != 0)
+                return -EINVAL;
 
-                *id = V4L2_STD_NTSC_M;
-                break;
-        }
-        case VIDIOC_S_STD:
-        {
-                break;
-        }
-        /* ------ input switching ---------- */
-        case VIDIOC_ENUMINPUT:
-        { /* only one input in this sample driver */
-                struct v4l2_input *inp = arg;
+        inp->type = V4L2_INPUT_TYPE_CAMERA;
+        inp->std = V4L2_STD_NTSC_M;
+        strcpy(inp->name,"Camera");
 
-                if (inp->index != 0) {
-                        ret=-EINVAL;
-                        break;
-                }
-                memset(inp, 0, sizeof(*inp));
+        return (0);
+}
 
-                inp->index = 0;
-                inp->type = V4L2_INPUT_TYPE_CAMERA;
-                inp->std = V4L2_STD_NTSC_M;
-                strcpy(inp->name,"Camera");
-                break;
-        }
-        case VIDIOC_G_INPUT:
-        {
-                unsigned int *i = arg;
+static int vidioc_g_input (struct file *file, void *priv, unsigned int *i)
+{
+        *i = 0;
 
-                *i = 0;
-                break;
-        }
-        case VIDIOC_S_INPUT:
-        {
-                unsigned int *i = arg;
+        return (0);
+}
+static int vidioc_s_input (struct file *file, void *priv, unsigned int i)
+{
+        if (i > 0)
+                return -EINVAL;
 
-                if (*i > 0)
-                        ret=-EINVAL;
-                break;
-        }
+        return (0);
+}
 
         /* --- controls ---------------------------------------------- */
-        case VIDIOC_QUERYCTRL:
-        {
-                struct v4l2_queryctrl *qc = arg;
-                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));
-                                break;
-                        }
+static int vidioc_queryctrl (struct file *file, void *priv,
+                                struct v4l2_queryctrl *qc)
+{
+        int i;
 
-                ret=-EINVAL;
-                break;
-        }
-        case VIDIOC_G_CTRL:
-        {
-                struct v4l2_control *ctrl = arg;
-                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);
+                }
 
-                for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
-                        if (ctrl->id == vivi_qctrl[i].id) {
-                                ctrl->value=qctl_regs[i];
-                                break;
-                        }
+        return -EINVAL;
+}
 
-                ret=-EINVAL;
-                break;
-        }
-        case VIDIOC_S_CTRL:
-        {
-                struct v4l2_control *ctrl = arg;
-                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) {
-                                                ret=-ERANGE;
-                                                break;
-                                        }
-                                qctl_regs[i]=ctrl->value;
-                                break;
-                        }
-                ret=-EINVAL;
-                break;
-        }
-        default:
-                ret=v4l_compat_translate_ioctl(inode,file,cmd,arg,vivi_do_ioctl);
-        }
+static int vidioc_g_ctrl (struct file *file, void *priv,
+                                struct v4l2_control *ctrl)
+{
+        int i;
 
-        if (debug) {
-                if (ret<0) {
-                        v4l_print_ioctl("vivi(err)", cmd);
-                        dprintk(1,"errcode=%d\n",ret);
-                } else if (_IOC_DIR(cmd) & _IOC_READ)
-                        v4l_printk_ioctl_arg("vivi(r)",cmd, arg);
-        }
+        for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
+                if (ctrl->id == vivi_qctrl[i].id) {
+                        ctrl->value=qctl_regs[i];
+                        return (0);
+                }
 
-        return ret;
+        return -EINVAL;
 }
-
-static int vivi_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static int vidioc_s_ctrl (struct file *file, void *priv,
+                                struct v4l2_control *ctrl)
 {
-        return video_usercopy(inode, file, cmd, arg, vivi_do_ioctl);
+        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);
+                                }
+                        qctl_regs[i]=ctrl->value;
+                        return (0);
+                }
+        return -EINVAL;
 }
 
 /* ------------------------------------------------------------------
@@ -1255,7 +1150,7 @@ static int vivi_open(struct inode *inode, struct file *file)
 
         list_for_each(list,&vivi_devlist) {
                 h = list_entry(list, struct vivi_dev, vivi_devlist);
-                if (h->video_dev.minor == minor) {
+                if (h->vfd.minor == minor) {
                         dev  = h;
                         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                 }
@@ -1264,6 +1159,7 @@ static int vivi_open(struct inode *inode, struct file *file)
                 return -ENODEV;
 
 
+
         /* If more than one user, mutex should be added */
         dev->users++;
 
@@ -1279,6 +1175,7 @@ static int vivi_open(struct inode *inode, struct file *file)
 
         file->private_data = fh;
         fh->dev      = dev;
+
         fh->type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         fh->fmt      = &format;
         fh->width    = 640;
@@ -1314,7 +1211,7 @@ static int vivi_open(struct inode *inode, struct file *file)
 static ssize_t
 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
 {
-        struct vivi_fh *fh = file->private_data;
+        struct vivi_fh        *fh = file->private_data;
 
         if (fh->type==V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                 if (res_locked(fh->dev))
@@ -1328,8 +1225,8 @@ vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
 static unsigned int
 vivi_poll(struct file *file, struct poll_table_struct *wait)
 {
-        struct vivi_fh *fh = file->private_data;
-        struct vivi_buffer *buf;
+        struct vivi_fh        *fh = file->private_data;
+        struct vivi_buffer    *buf;
 
         dprintk(1,"%s\n",__FUNCTION__);
 
@@ -1358,8 +1255,8 @@ vivi_poll(struct file *file, struct poll_table_struct *wait)
 
 static int vivi_release(struct inode *inode, struct file *file)
 {
-        struct vivi_fh  *fh     = file->private_data;
-        struct vivi_dev *dev    = fh->dev;
+        struct vivi_fh         *fh = file->private_data;
+        struct vivi_dev *dev       = fh->dev;
         struct vivi_dmaqueue *vidq = &dev->vidq;
 
         int minor = iminor(inode);
@@ -1379,7 +1276,7 @@ static int vivi_release(struct inode *inode, struct file *file)
 static int
 vivi_mmap(struct file *file, struct vm_area_struct * vma)
 {
-        struct vivi_fh *fh = file->private_data;
+        struct vivi_fh        *fh = file->private_data;
         int ret;
 
         dprintk (1,"mmap called, vma=0x%08lx\n",(unsigned long)vma);
@@ -1400,20 +1297,44 @@ static struct file_operations vivi_fops = {
         .release        = vivi_release,
         .read           = vivi_read,
         .poll           = vivi_poll,
-        .ioctl          = vivi_ioctl,
+        .ioctl          = video_ioctl2, /* V4L2 ioctl handler */
         .mmap           = vivi_mmap,
         .llseek         = no_llseek,
 };
 
 static struct video_device vivi = {
-        .name           = "VTM Virtual Video Capture Board",
+        .name           = "vivi",
         .type           = VID_TYPE_CAPTURE,
         .hardware       = 0,
         .fops           = &vivi_fops,
         .minor          = -1,
 //      .release        = video_device_release,
+
+        .vidioc_querycap      = vidioc_querycap,
+        .vidioc_enum_fmt_cap  = vidioc_enum_fmt_cap,
+        .vidioc_g_fmt_cap     = vidioc_g_fmt_cap,
+        .vidioc_try_fmt_cap   = vidioc_try_fmt_cap,
+        .vidioc_s_fmt_cap     = vidioc_s_fmt_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 HAVE_V4L1
+        .vidiocgmbuf          = vidiocgmbuf,
+#endif
+        .tvnorms              = tvnorms,
+        .tvnormsize           = ARRAY_SIZE(tvnorms),
 };
-/* ------------------------------------------------------------------
+/* -----------------------------------------------------------------
         Initialization and module stuff
    ------------------------------------------------------------------*/
 
@@ -1457,3 +1378,16 @@ static void __exit vivi_exit(void)
 
 module_init(vivi_init);
 module_exit(vivi_exit);
+
+MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
+MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
+MODULE_LICENSE("Dual BSD/GPL");
+
+module_param(video_nr, int, 0);
+
+module_param_named(debug,vivi.debug, int, 0644);
+MODULE_PARM_DESC(debug,"activates debug info");
+
+module_param(vid_limit,int,0644);
+MODULE_PARM_DESC(vid_limit,"capture memory limit in megabytes");
+
diff --git a/drivers/media/video/vpx3220.c b/drivers/media/video/vpx3220.c
index 40b205b9148..1eca7e65d23 100644
--- a/drivers/media/video/vpx3220.c
+++ b/drivers/media/video/vpx3220.c
@@ -34,6 +34,7 @@
 #define I2C_NAME(x) (x)->name
 
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/video_decoder.h>
 
 #define I2C_VPX3220        0x86
diff --git a/drivers/media/video/w9966.c b/drivers/media/video/w9966.c
index 80ef8a1b8f6..4bdc886abc4 100644
--- a/drivers/media/video/w9966.c
+++ b/drivers/media/video/w9966.c
@@ -58,6 +58,7 @@
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/parport.h>
 
 //#define DEBUG                         // Undef me for production
diff --git a/drivers/media/video/zc0301/Kconfig b/drivers/media/video/zc0301/Kconfig
index 115833e4f4d..a859a692018 100644
--- a/drivers/media/video/zc0301/Kconfig
+++ b/drivers/media/video/zc0301/Kconfig
@@ -1,9 +1,9 @@
 config USB_ZC0301
-        tristate "USB ZC0301 Image Processor and Control Chip support"
+        tristate "USB ZC0301[P] Image Processor and Control Chip support"
         depends on USB && VIDEO_V4L1
         ---help---
-          Say Y here if you want support for cameras based on the ZC0301
-          Image Processor and Control Chip.
+          Say Y here if you want support for cameras based on the ZC0301 or
+          ZC0301P Image Processors and Control Chips.
 
           See <file:Documentation/video4linux/zc0301.txt> for more info.
 
diff --git a/drivers/media/video/zc0301/Makefile b/drivers/media/video/zc0301/Makefile
index d749199d8f0..d9e6d97fade 100644
--- a/drivers/media/video/zc0301/Makefile
+++ b/drivers/media/video/zc0301/Makefile
@@ -1,3 +1,3 @@
-zc0301-objs     := zc0301_core.o zc0301_pas202bcb.o
+zc0301-objs     := zc0301_core.o zc0301_pb0330.o zc0301_pas202bcb.o
 
 obj-$(CONFIG_USB_ZC0301)        += zc0301.o
diff --git a/drivers/media/video/zc0301/zc0301_core.c b/drivers/media/video/zc0301/zc0301_core.c
index 0fad39754f7..1b2be2d2a3e 100644
--- a/drivers/media/video/zc0301/zc0301_core.c
+++ b/drivers/media/video/zc0301/zc0301_core.c
@@ -1,5 +1,5 @@
 /***************************************************************************
- * Video4Linux2 driver for ZC0301 Image Processor and Control Chip         *
+ * Video4Linux2 driver for ZC0301[P] Image Processor and Control Chip      *
  *                                                                         *
  * Copyright (C) 2006 by Luca Risolia <luca.risolia@studio.unibo.it>       *
  *                                                                         *
@@ -47,13 +47,13 @@
 
 /*****************************************************************************/
 
-#define ZC0301_MODULE_NAME    "V4L2 driver for ZC0301 "                       \
+#define ZC0301_MODULE_NAME    "V4L2 driver for ZC0301[P] "                    \
                               "Image Processor and Control Chip"
 #define ZC0301_MODULE_AUTHOR  "(C) 2006 Luca Risolia"
 #define ZC0301_AUTHOR_EMAIL   "<luca.risolia@studio.unibo.it>"
 #define ZC0301_MODULE_LICENSE "GPL"
-#define ZC0301_MODULE_VERSION "1:1.03"
-#define ZC0301_MODULE_VERSION_CODE  KERNEL_VERSION(1, 0, 3)
+#define ZC0301_MODULE_VERSION "1:1.05"
+#define ZC0301_MODULE_VERSION_CODE  KERNEL_VERSION(1, 0, 5)
 
 /*****************************************************************************/
 
@@ -427,10 +427,11 @@ resubmit_urb:
 static int zc0301_start_transfer(struct zc0301_device* cam)
 {
         struct usb_device *udev = cam->usbdev;
+        struct usb_host_interface* altsetting = usb_altnum_to_altsetting(
+                                                     usb_ifnum_to_if(udev, 0),
+                                                     ZC0301_ALTERNATE_SETTING);
+        const unsigned int psz = altsetting->endpoint[0].desc.wMaxPacketSize;
         struct urb* urb;
-        const unsigned int wMaxPacketSize[] = {0, 128, 192, 256, 384,
-                                               512, 768, 1023};
-        const unsigned int psz = wMaxPacketSize[ZC0301_ALTERNATE_SETTING];
         s8 i, j;
         int err = 0;
 
@@ -1772,11 +1773,9 @@ static int zc0301_ioctl_v4l2(struct inode* inode, struct file* filp,
         case VIDIOC_G_CTRL:
                 return zc0301_vidioc_g_ctrl(cam, arg);
 
-        case VIDIOC_S_CTRL_OLD:
         case VIDIOC_S_CTRL:
                 return zc0301_vidioc_s_ctrl(cam, arg);
 
-        case VIDIOC_CROPCAP_OLD:
         case VIDIOC_CROPCAP:
                 return zc0301_vidioc_cropcap(cam, arg);
 
@@ -1823,7 +1822,6 @@ static int zc0301_ioctl_v4l2(struct inode* inode, struct file* filp,
         case VIDIOC_G_PARM:
                 return zc0301_vidioc_g_parm(cam, arg);
 
-        case VIDIOC_S_PARM_OLD:
         case VIDIOC_S_PARM:
                 return zc0301_vidioc_s_parm(cam, arg);
 
@@ -1914,7 +1912,7 @@ zc0301_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
 
         mutex_init(&cam->dev_mutex);
 
-        DBG(2, "ZC0301 Image Processor and Control Chip detected "
+        DBG(2, "ZC0301[P] Image Processor and Control Chip detected "
                "(vid/pid 0x%04X/0x%04X)",id->idVendor, id->idProduct);
 
         for  (i = 0; zc0301_sensor_table[i]; i++) {
@@ -1936,7 +1934,7 @@ zc0301_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
                 cam->state |= DEV_MISCONFIGURED;
         }
 
-        strcpy(cam->v4ldev->name, "ZC0301 PC Camera");
+        strcpy(cam->v4ldev->name, "ZC0301[P] PC Camera");
         cam->v4ldev->owner = THIS_MODULE;
         cam->v4ldev->type = VID_TYPE_CAPTURE | VID_TYPE_SCALES;
         cam->v4ldev->hardware = 0;
diff --git a/drivers/media/video/zc0301/zc0301_pas202bcb.c b/drivers/media/video/zc0301/zc0301_pas202bcb.c
index eaadf025204..ecfd39a56df 100644
--- a/drivers/media/video/zc0301/zc0301_pas202bcb.c
+++ b/drivers/media/video/zc0301/zc0301_pas202bcb.c
@@ -1,10 +1,10 @@
 /***************************************************************************
- * Plug-in for PAS202BCB image sensor connected to the ZC030! Image        *
+ * Plug-in for PAS202BCB image sensor connected to the ZC0301[P] Image     *
  * Processor and Control Chip                                              *
  *                                                                         *
  * Copyright (C) 2006 by Luca Risolia <luca.risolia@studio.unibo.it>       *
  *                                                                         *
- * Initialization values of the ZC0301 have been taken from the SPCA5XX    *
+ * Initialization values of the ZC0301[P] have been taken from the SPCA5XX *
  * driver maintained by Michel Xhaard <mxhaard@magic.fr>                   *
  *                                                                         *
  * This program is free software; you can redistribute it and/or modify    *
diff --git a/drivers/media/video/zc0301/zc0301_pb0330.c b/drivers/media/video/zc0301/zc0301_pb0330.c
new file mode 100644
index 00000000000..ed8542e6c50
--- /dev/null
+++ b/drivers/media/video/zc0301/zc0301_pb0330.c
@@ -0,0 +1,187 @@
+/***************************************************************************
+ * Plug-in for PB-0330 image sensor connected to the ZC0301[P] Image       *
+ * Processor and Control Chip                                              *
+ *                                                                         *
+ * Copyright (C) 2006 by Luca Risolia <luca.risolia@studio.unibo.it>       *
+ *                                                                         *
+ * Initialization values of the ZC0301[P] have been taken from the SPCA5XX *
+ * driver maintained by Michel Xhaard <mxhaard@magic.fr>                   *
+ *                                                                         *
+ * 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/delay.h>
+#include "zc0301_sensor.h"
+
+
+static struct zc0301_sensor pb0330;
+
+
+static int pb0330_init(struct zc0301_device* cam)
+{
+        int err = 0;
+
+        err += zc0301_write_reg(cam, 0x0000, 0x01);
+        err += zc0301_write_reg(cam, 0x0008, 0x03);
+        err += zc0301_write_reg(cam, 0x0010, 0x0A);
+        err += zc0301_write_reg(cam, 0x0002, 0x00);
+        err += zc0301_write_reg(cam, 0x0003, 0x02);
+        err += zc0301_write_reg(cam, 0x0004, 0x80);
+        err += zc0301_write_reg(cam, 0x0005, 0x01);
+        err += zc0301_write_reg(cam, 0x0006, 0xE0);
+        err += zc0301_write_reg(cam, 0x0001, 0x01);
+        err += zc0301_write_reg(cam, 0x0012, 0x05);
+        err += zc0301_write_reg(cam, 0x0012, 0x07);
+        err += zc0301_write_reg(cam, 0x0098, 0x00);
+        err += zc0301_write_reg(cam, 0x009A, 0x00);
+        err += zc0301_write_reg(cam, 0x011A, 0x00);
+        err += zc0301_write_reg(cam, 0x011C, 0x00);
+        err += zc0301_write_reg(cam, 0x0012, 0x05);
+
+        err += zc0301_i2c_write(cam, 0x01, 0x0006);
+        err += zc0301_i2c_write(cam, 0x02, 0x0011);
+        err += zc0301_i2c_write(cam, 0x03, 0x01E7);
+        err += zc0301_i2c_write(cam, 0x04, 0x0287);
+        err += zc0301_i2c_write(cam, 0x06, 0x0003);
+        err += zc0301_i2c_write(cam, 0x07, 0x3002);
+        err += zc0301_i2c_write(cam, 0x20, 0x1100);
+        err += zc0301_i2c_write(cam, 0x2F, 0xF7B0);
+        err += zc0301_i2c_write(cam, 0x30, 0x0005);
+        err += zc0301_i2c_write(cam, 0x31, 0x0000);
+        err += zc0301_i2c_write(cam, 0x34, 0x0100);
+        err += zc0301_i2c_write(cam, 0x35, 0x0060);
+        err += zc0301_i2c_write(cam, 0x3D, 0x068F);
+        err += zc0301_i2c_write(cam, 0x40, 0x01E0);
+        err += zc0301_i2c_write(cam, 0x58, 0x0078);
+        err += zc0301_i2c_write(cam, 0x62, 0x0411);
+
+        err += zc0301_write_reg(cam, 0x0087, 0x10);
+        err += zc0301_write_reg(cam, 0x0101, 0x37);
+        err += zc0301_write_reg(cam, 0x0012, 0x05);
+        err += zc0301_write_reg(cam, 0x0100, 0x0D);
+        err += zc0301_write_reg(cam, 0x0189, 0x06);
+        err += zc0301_write_reg(cam, 0x01AD, 0x00);
+        err += zc0301_write_reg(cam, 0x01C5, 0x03);
+        err += zc0301_write_reg(cam, 0x01CB, 0x13);
+        err += zc0301_write_reg(cam, 0x0250, 0x08);
+        err += zc0301_write_reg(cam, 0x0301, 0x08);
+        err += zc0301_write_reg(cam, 0x01A8, 0x60);
+        err += zc0301_write_reg(cam, 0x018D, 0x6C);
+        err += zc0301_write_reg(cam, 0x01AD, 0x09);
+        err += zc0301_write_reg(cam, 0x01AE, 0x15);
+        err += zc0301_write_reg(cam, 0x010A, 0x50);
+        err += zc0301_write_reg(cam, 0x010B, 0xF8);
+        err += zc0301_write_reg(cam, 0x010C, 0xF8);
+        err += zc0301_write_reg(cam, 0x010D, 0xF8);
+        err += zc0301_write_reg(cam, 0x010E, 0x50);
+        err += zc0301_write_reg(cam, 0x010F, 0xF8);
+        err += zc0301_write_reg(cam, 0x0110, 0xF8);
+        err += zc0301_write_reg(cam, 0x0111, 0xF8);
+        err += zc0301_write_reg(cam, 0x0112, 0x50);
+        err += zc0301_write_reg(cam, 0x0008, 0x03);
+        err += zc0301_write_reg(cam, 0x01C6, 0x08);
+        err += zc0301_write_reg(cam, 0x01CB, 0x0F);
+        err += zc0301_write_reg(cam, 0x010A, 0x50);
+        err += zc0301_write_reg(cam, 0x010B, 0xF8);
+        err += zc0301_write_reg(cam, 0x010C, 0xF8);
+        err += zc0301_write_reg(cam, 0x010D, 0xF8);
+        err += zc0301_write_reg(cam, 0x010E, 0x50);
+        err += zc0301_write_reg(cam, 0x010F, 0xF8);
+        err += zc0301_write_reg(cam, 0x0110, 0xF8);
+        err += zc0301_write_reg(cam, 0x0111, 0xF8);
+        err += zc0301_write_reg(cam, 0x0112, 0x50);
+        err += zc0301_write_reg(cam, 0x0180, 0x00);
+        err += zc0301_write_reg(cam, 0x0019, 0x00);
+
+        err += zc0301_i2c_write(cam, 0x05, 0x0066);
+        err += zc0301_i2c_write(cam, 0x09, 0x02B2);
+        err += zc0301_i2c_write(cam, 0x10, 0x0002);
+
+        err += zc0301_write_reg(cam, 0x011D, 0x60);
+        err += zc0301_write_reg(cam, 0x0190, 0x00);
+        err += zc0301_write_reg(cam, 0x0191, 0x07);
+        err += zc0301_write_reg(cam, 0x0192, 0x8C);
+        err += zc0301_write_reg(cam, 0x0195, 0x00);
+        err += zc0301_write_reg(cam, 0x0196, 0x00);
+        err += zc0301_write_reg(cam, 0x0197, 0x8A);
+        err += zc0301_write_reg(cam, 0x018C, 0x10);
+        err += zc0301_write_reg(cam, 0x018F, 0x20);
+        err += zc0301_write_reg(cam, 0x01A9, 0x14);
+        err += zc0301_write_reg(cam, 0x01AA, 0x24);
+        err += zc0301_write_reg(cam, 0x001D, 0xD7);
+        err += zc0301_write_reg(cam, 0x001E, 0xF0);
+        err += zc0301_write_reg(cam, 0x001F, 0xF8);
+        err += zc0301_write_reg(cam, 0x0020, 0xFF);
+        err += zc0301_write_reg(cam, 0x01AD, 0x09);
+        err += zc0301_write_reg(cam, 0x01AE, 0x15);
+        err += zc0301_write_reg(cam, 0x0180, 0x40);
+        err += zc0301_write_reg(cam, 0x0180, 0x42);
+
+        msleep(100);
+
+        return err;
+}
+
+
+static struct zc0301_sensor pb0330 = {
+        .name = "PB-0330",
+        .init = &pb0330_init,
+        .cropcap = {
+                .bounds = {
+                        .left = 0,
+                        .top = 0,
+                        .width = 640,
+                        .height = 480,
+                },
+                .defrect = {
+                        .left = 0,
+                        .top = 0,
+                        .width = 640,
+                        .height = 480,
+                },
+        },
+        .pix_format = {
+                .width = 640,
+                .height = 480,
+                .pixelformat = V4L2_PIX_FMT_JPEG,
+                .priv = 8,
+        },
+};
+
+
+int zc0301_probe_pb0330(struct zc0301_device* cam)
+{
+        int r0, err = 0;
+
+        err += zc0301_write_reg(cam, 0x0000, 0x01);
+        err += zc0301_write_reg(cam, 0x0010, 0x0a);
+        err += zc0301_write_reg(cam, 0x0001, 0x01);
+        err += zc0301_write_reg(cam, 0x0012, 0x03);
+        err += zc0301_write_reg(cam, 0x0012, 0x01);
+
+        msleep(10);
+
+        r0 = zc0301_i2c_read(cam, 0x00, 2);
+
+        if (r0 < 0 || err)
+                return -EIO;
+
+        if (r0 != 0x8243)
+                return -ENODEV;
+
+        zc0301_attach_sensor(cam, &pb0330);
+
+        return 0;
+}
diff --git a/drivers/media/video/zc0301/zc0301_sensor.h b/drivers/media/video/zc0301/zc0301_sensor.h
index 1f95c28b101..4363a915b1f 100644
--- a/drivers/media/video/zc0301/zc0301_sensor.h
+++ b/drivers/media/video/zc0301/zc0301_sensor.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- * API for image sensors connected to the ZC030! Image Processor and       *
+ * API for image sensors connected to the ZC0301 Image Processor and       *
  * Control Chip                                                            *
  *                                                                         *
  * Copyright (C) 2006 by Luca Risolia <luca.risolia@studio.unibo.it>       *
@@ -35,11 +35,13 @@ struct zc0301_sensor;
 /*****************************************************************************/
 
 extern int zc0301_probe_pas202bcb(struct zc0301_device* cam);
+extern int zc0301_probe_pb0330(struct zc0301_device* cam);
 
 #define ZC0301_SENSOR_TABLE                                                   \
 /* Weak detections must go at the end of the list */                          \
 static int (*zc0301_sensor_table[])(struct zc0301_device*) = {                \
         &zc0301_probe_pas202bcb,                                              \
+        &zc0301_probe_pb0330,                                                 \
         NULL,                                                                 \
 };
 
@@ -58,14 +60,28 @@ zc0301_attach_sensor(struct zc0301_device* cam, struct zc0301_sensor* sensor);
 
 #define ZC0301_ID_TABLE                                                       \
 static const struct usb_device_id zc0301_id_table[] =  {                      \
-        { ZC0301_USB_DEVICE(0x041e, 0x4017, 0xff), },                         \
+        { ZC0301_USB_DEVICE(0x041e, 0x4017, 0xff), }, /* ICM105 */            \
         { ZC0301_USB_DEVICE(0x041e, 0x401c, 0xff), }, /* PAS106 */            \
-        { ZC0301_USB_DEVICE(0x041e, 0x401e, 0xff), }, /* HV7131B */           \
+        { ZC0301_USB_DEVICE(0x041e, 0x401e, 0xff), }, /* HV7131 */            \
+        { ZC0301_USB_DEVICE(0x041e, 0x401f, 0xff), }, /* TAS5130 */           \
+        { ZC0301_USB_DEVICE(0x041e, 0x4022, 0xff), },                         \
         { ZC0301_USB_DEVICE(0x041e, 0x4034, 0xff), }, /* PAS106 */            \
         { ZC0301_USB_DEVICE(0x041e, 0x4035, 0xff), }, /* PAS106 */            \
-        { ZC0301_USB_DEVICE(0x046d, 0x08ae, 0xff), }, /* PAS202BCB */         \
+        { ZC0301_USB_DEVICE(0x041e, 0x4036, 0xff), }, /* HV7131 */            \
+        { ZC0301_USB_DEVICE(0x041e, 0x403a, 0xff), }, /* HV7131 */            \
+        { ZC0301_USB_DEVICE(0x0458, 0x7007, 0xff), }, /* TAS5130 */           \
+        { ZC0301_USB_DEVICE(0x0458, 0x700C, 0xff), }, /* TAS5130 */           \
+        { ZC0301_USB_DEVICE(0x0458, 0x700f, 0xff), }, /* TAS5130 */           \
+        { ZC0301_USB_DEVICE(0x046d, 0x08ae, 0xff), }, /* PAS202 */            \
+        { ZC0301_USB_DEVICE(0x055f, 0xd003, 0xff), }, /* TAS5130 */           \
+        { ZC0301_USB_DEVICE(0x055f, 0xd004, 0xff), }, /* TAS5130 */           \
+        { ZC0301_USB_DEVICE(0x046d, 0x08ae, 0xff), }, /* PAS202 */            \
         { ZC0301_USB_DEVICE(0x0ac8, 0x0301, 0xff), },                         \
-        { ZC0301_USB_DEVICE(0x10fd, 0x8050, 0xff), }, /* TAS5130D */          \
+        { ZC0301_USB_DEVICE(0x0ac8, 0x301b, 0xff), }, /* PB-0330/HV7131 */    \
+        { ZC0301_USB_DEVICE(0x0ac8, 0x303b, 0xff), }, /* PB-0330 */           \
+        { ZC0301_USB_DEVICE(0x10fd, 0x0128, 0xff), }, /* TAS5130 */           \
+        { ZC0301_USB_DEVICE(0x10fd, 0x8050, 0xff), }, /* TAS5130 */           \
+        { ZC0301_USB_DEVICE(0x10fd, 0x804e, 0xff), }, /* TAS5130 */           \
         { }                                                                   \
 };
 
diff --git a/drivers/media/video/zoran.h b/drivers/media/video/zoran.h
index 0166f555a5c..ffcda95ed9d 100644
--- a/drivers/media/video/zoran.h
+++ b/drivers/media/video/zoran.h
@@ -159,7 +159,7 @@ Private IOCTL to set up for displaying MJPEG
 #define BUZ_MAX_FRAME     256   /* Must be a power of 2 */
 #define BUZ_MASK_FRAME    255   /* Must be BUZ_MAX_FRAME-1 */
 
-#define BUZ_MAX_INPUT       8
+#define BUZ_MAX_INPUT       16
 
 #if VIDEO_MAX_FRAME <= 32
 #   define   V4L_MAX_FRAME   32
@@ -191,6 +191,9 @@ enum card_type {
         /* Iomega */
         BUZ,
 
+        /* AverMedia */
+        AVS6EYES,
+
         /* total number of cards */
         NUM_CARDS
 };
@@ -379,6 +382,9 @@ struct card_info {
         /* is the /GWS line conected? */
         u8 gws_not_connected;
 
+        /* avs6eyes mux setting */
+        u8 input_mux;
+
         void (*init) (struct zoran * zr);
 };
 
diff --git a/drivers/media/video/zoran_card.c b/drivers/media/video/zoran_card.c
index 0a85c9e7fb4..958c1e6fc85 100644
--- a/drivers/media/video/zoran_card.c
+++ b/drivers/media/video/zoran_card.c
@@ -27,6 +27,8 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/delay.h>
+
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
@@ -38,6 +40,7 @@
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include <linux/spinlock.h>
 #include <linux/sem.h>
 #include <linux/kmod.h>
@@ -93,6 +96,11 @@ module_param(default_input, int, 0);
 MODULE_PARM_DESC(default_input,
                  "Default input (0=Composite, 1=S-Video, 2=Internal)");
 
+static int default_mux = 1;     /* 6 Eyes input selection */
+module_param(default_mux, int, 0);
+MODULE_PARM_DESC(default_mux,
+                 "Default 6 Eyes mux setting (Input selection)");
+
 static int default_norm = 0;    /* 0=PAL, 1=NTSC 2=SECAM */
 module_param(default_norm, int, 0);
 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
@@ -301,6 +309,30 @@ lml33_init (struct zoran *zr)
         GPIO(zr, 2, 1);         // Set Composite input/output
 }
 
+static void
+avs6eyes_init (struct zoran *zr)
+{
+        // AverMedia 6-Eyes original driver by Christer Weinigel
+
+        // Lifted straight from Christer's old driver and
+        // modified slightly by Martin Samuelsson.
+
+        int mux = default_mux; /* 1 = BT866, 7 = VID1 */
+
+        GPIO(zr, 4, 1); /* Bt866 SLEEP on */
+        udelay(2);
+
+        GPIO(zr, 0, 1); /* ZR36060 /RESET on */
+        GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
+        GPIO(zr, 2, mux & 1);   /* MUX S0 */
+        GPIO(zr, 3, 0); /* /FRAME on */
+        GPIO(zr, 4, 0); /* Bt866 SLEEP off */
+        GPIO(zr, 5, mux & 2);   /* MUX S1 */
+        GPIO(zr, 6, 0); /* ? */
+        GPIO(zr, 7, mux & 4);   /* MUX S2 */
+
+}
+
 static char *
 i2cid_to_modulename (u16 i2c_id)
 {
@@ -391,6 +423,14 @@ static struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
 static struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74+54, 804, 625, 576, 18 };
 static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 };
 
+/* FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I
+ * copy Maxim's left shift hack for the 6 Eyes.
+ *
+ * Christer's driver used the unshifted norms, though...
+ * /Sam  */
+static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
+static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
+
 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         {
                 .type = DC10_old,
@@ -419,6 +459,7 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .gpcs = { -1, 0 },
                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
                 .gws_not_connected = 0,
+                .input_mux = 0,
                 .init = &dc10_init,
         }, {
                 .type = DC10_new,
@@ -445,6 +486,7 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .gpcs = { -1, 1},
                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
                 .gws_not_connected = 0,
+                .input_mux = 0,
                 .init = &dc10plus_init,
         }, {
                 .type = DC10plus,
@@ -474,6 +516,7 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .gpcs = { -1, 1 },
                 .vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
                 .gws_not_connected = 0,
+                .input_mux = 0,
                 .init = &dc10plus_init,
         }, {
                 .type = DC30,
@@ -502,6 +545,7 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .gpcs = { -1, 0 },
                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
                 .gws_not_connected = 0,
+                .input_mux = 0,
                 .init = &dc10_init,
         }, {
                 .type = DC30plus,
@@ -532,6 +576,7 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .gpcs = { -1, 0 },
                 .vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
                 .gws_not_connected = 0,
+                .input_mux = 0,
                 .init = &dc10_init,
         }, {
                 .type = LML33,
@@ -558,6 +603,7 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .gpcs = { 3, 1 },
                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
                 .gws_not_connected = 1,
+                .input_mux = 0,
                 .init = &lml33_init,
         }, {
                 .type = LML33R10,
@@ -586,6 +632,7 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .gpcs = { 3, 1 },
                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
                 .gws_not_connected = 1,
+                .input_mux = 0,
                 .init = &lml33_init,
         }, {
                 .type = BUZ,
@@ -614,8 +661,49 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .gpcs = { 3, 1 },
                 .vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
                 .gws_not_connected = 1,
+                .input_mux = 0,
                 .init = &buz_init,
+        }, {
+                .type = AVS6EYES,
+                .name = "6-Eyes",
+                /* AverMedia chose not to brand the 6-Eyes. Thus it
+                   can't be autodetected, and requires card=x. */
+                .vendor_id = -1,
+                .device_id = -1,
+                .i2c_decoder = I2C_DRIVERID_KS0127,
+                .i2c_encoder = I2C_DRIVERID_BT866,
+                .video_codec = CODEC_TYPE_ZR36060,
+
+                .inputs = 10,
+                .input = {
+                        { 0, "Composite 1" },
+                        { 1, "Composite 2" },
+                        { 2, "Composite 3" },
+                        { 4, "Composite 4" },
+                        { 5, "Composite 5" },
+                        { 6, "Composite 6" },
+                        { 8, "S-Video 1" },
+                        { 9, "S-Video 2" },
+                        {10, "S-Video 3" },
+                        {15, "YCbCr" }
+                },
+                .norms = 2,
+                .tvn = {
+                        &f50ccir601_avs6eyes,
+                        &f60ccir601_avs6eyes,
+                        NULL
+                },
+                .jpeg_int = ZR36057_ISR_GIRQ1,
+                .vsync_int = ZR36057_ISR_GIRQ0,
+                .gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
+                .gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
+                .gpcs = { 3, 1 },                       // Validity unknown /Sam
+                .vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 },  // Validity unknown /Sam
+                .gws_not_connected = 1,
+                .input_mux = 1,
+                .init = &avs6eyes_init,
         }
+
 };
 
 /*
diff --git a/drivers/media/video/zoran_device.c b/drivers/media/video/zoran_device.c
index c690b2ee880..02168d9c218 100644
--- a/drivers/media/video/zoran_device.c
+++ b/drivers/media/video/zoran_device.c
@@ -536,7 +536,7 @@ zr36057_overlay (struct zoran *zr,
                  * All error messages are internal driver checking only! */
 
                 /* video display top and bottom registers */
-                reg = (u32) zr->buffer.base +
+                reg = (long) zr->buffer.base +
                     zr->overlay_settings.x *
                     ((zr->overlay_settings.format->depth + 7) / 8) +
                     zr->overlay_settings.y *
diff --git a/drivers/media/video/zoran_driver.c b/drivers/media/video/zoran_driver.c
index b5a576a37fd..9711f6248ef 100644
--- a/drivers/media/video/zoran_driver.c
+++ b/drivers/media/video/zoran_driver.c
@@ -73,6 +73,7 @@
                              )
 
 #include <linux/videodev.h>
+#include <media/v4l2-common.h>
 #include "videocodec.h"
 
 #include <asm/io.h>
@@ -2047,7 +2048,7 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOCGCAP\n", ZR_DEVNAME(zr));
 
                 memset(vcap, 0, sizeof(struct video_capability));
-                strncpy(vcap->name, ZR_DEVNAME(zr), sizeof(vcap->name));
+                strncpy(vcap->name, ZR_DEVNAME(zr), sizeof(vcap->name)-1);
                 vcap->type = ZORAN_VID_TYPE;
 
                 vcap->channels = zr->card.inputs;
@@ -2689,8 +2690,8 @@ zoran_do_ioctl (struct inode *inode,
                 dprintk(3, KERN_DEBUG "%s: VIDIOC_QUERYCAP\n", ZR_DEVNAME(zr));
 
                 memset(cap, 0, sizeof(*cap));
-                strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card));
-                strncpy(cap->driver, "zoran", sizeof(cap->driver));
+                strncpy(cap->card, ZR_DEVNAME(zr), sizeof(cap->card)-1);
+                strncpy(cap->driver, "zoran", sizeof(cap->driver)-1);
                 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",
                          pci_name(zr->pci_dev));
                 cap->version =
@@ -2742,7 +2743,7 @@ zoran_do_ioctl (struct inode *inode,
                 memset(fmt, 0, sizeof(*fmt));
                 fmt->index = index;
                 fmt->type = type;
-                strncpy(fmt->description, zoran_formats[i].name, 31);
+                strncpy(fmt->description, zoran_formats[i].name, sizeof(fmt->description)-1);
                 fmt->pixelformat = zoran_formats[i].fourcc;
                 if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
                         fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
@@ -3566,16 +3567,16 @@ zoran_do_ioctl (struct inode *inode,
 
                 switch (ctrl->id) {
                 case V4L2_CID_BRIGHTNESS:
-                        strncpy(ctrl->name, "Brightness", 31);
+                        strncpy(ctrl->name, "Brightness", sizeof(ctrl->name)-1);
                         break;
                 case V4L2_CID_CONTRAST:
-                        strncpy(ctrl->name, "Contrast", 31);
+                        strncpy(ctrl->name, "Contrast", sizeof(ctrl->name)-1);
                         break;
                 case V4L2_CID_SATURATION:
-                        strncpy(ctrl->name, "Saturation", 31);
+                        strncpy(ctrl->name, "Saturation", sizeof(ctrl->name)-1);
                         break;
                 case V4L2_CID_HUE:
-                        strncpy(ctrl->name, "Hue", 31);
+                        strncpy(ctrl->name, "Hue", sizeof(ctrl->name)-1);
                         break;
                 }
 
@@ -3693,7 +3694,7 @@ zoran_do_ioctl (struct inode *inode,
                                         &caps);
                         if (caps.flags & VIDEO_DECODER_AUTO) {
                                 std->id = V4L2_STD_ALL;
-                                strncpy(std->name, "Autodetect", 31);
+                                strncpy(std->name, "Autodetect", sizeof(std->name)-1);
                                 return 0;
                         } else
                                 return -EINVAL;
@@ -3701,21 +3702,21 @@ zoran_do_ioctl (struct inode *inode,
                 switch (std->index) {
                 case 0:
                         std->id = V4L2_STD_PAL;
-                        strncpy(std->name, "PAL", 31);
+                        strncpy(std->name, "PAL", sizeof(std->name)-1);
                         std->frameperiod.numerator = 1;
                         std->frameperiod.denominator = 25;
                         std->framelines = zr->card.tvn[0]->Ht;
                         break;
                 case 1:
                         std->id = V4L2_STD_NTSC;
-                        strncpy(std->name, "NTSC", 31);
+                        strncpy(std->name, "NTSC", sizeof(std->name)-1);
                         std->frameperiod.numerator = 1001;
                         std->frameperiod.denominator = 30000;
                         std->framelines = zr->card.tvn[1]->Ht;
                         break;
                 case 2:
                         std->id = V4L2_STD_SECAM;
-                        strncpy(std->name, "SECAM", 31);
+                        strncpy(std->name, "SECAM", sizeof(std->name)-1);
                         std->frameperiod.numerator = 1;
                         std->frameperiod.denominator = 25;
                         std->framelines = zr->card.tvn[2]->Ht;
@@ -3871,7 +3872,7 @@ zoran_do_ioctl (struct inode *inode,
                 memset(outp, 0, sizeof(*outp));
                 outp->index = 0;
                 outp->type = V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY;
-                strncpy(outp->name, "Autodetect", 31);
+                strncpy(outp->name, "Autodetect", sizeof(outp->name)-1);
 
                 return 0;
         }
diff --git a/drivers/media/video/zoran_procfs.c b/drivers/media/video/zoran_procfs.c
index a00fae90229..f4ffe79bdc5 100644
--- a/drivers/media/video/zoran_procfs.c
+++ b/drivers/media/video/zoran_procfs.c
@@ -43,6 +43,7 @@
 #include <linux/seq_file.h>
 
 #include <linux/ctype.h>
+#include <linux/poll.h>
 #include <asm/io.h>
 
 #include "videocodec.h"