Merge branch 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

* 'v4l_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (655 commits)
  [media] revert patch: HDIC HD29L2 DMB-TH USB2.0 reference design driver
  mb86a20s: Add a few more register settings at the init seq
  mb86a20s: Group registers into the same line
  [media] [PATCH] don't reset the delivery system on DTV_CLEAR
  [media] [BUG] it913x-fe fix typo error making SNR levels unstable
  [media] cx23885: Query the CX25840 during enum_input for status
  [media] cx25840: Add support for g_input_status
  [media] rc-videomate-m1f.c Rename to match remote controler name
  [media] drivers: media: au0828: Fix dependency for VIDEO_AU0828
  [media] convert drivers/media/* to use module_platform_driver()
  [media] drivers: video: cx231xx: Fix dependency for VIDEO_CX231XX_DVB
  [media] Exynos4 JPEG codec v4l2 driver
  [media] doc: v4l: selection: choose pixels as units for selection rectangles
  [media] v4l: s5p-tv: mixer: fix setup of VP scaling
  [media] v4l: s5p-tv: mixer: add support for selection API
  [media] v4l: emulate old crop API using extended crop/compose API
  [media] doc: v4l: add documentation for selection API
  [media] doc: v4l: add binary images for selection API
  [media] v4l: add support for selection api
  [media] hd29l2: fix review findings
  ...

218 files changed, 15158 insertions, 5613 deletions

diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index b303a3f8a9f8..9adada0d7447 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -533,6 +533,13 @@ config VIDEO_ADP1653
           This is a driver for the ADP1653 flash controller. It is used for
           example in Nokia N900.
 
+config VIDEO_AS3645A
+        tristate "AS3645A flash driver support"
+        depends on I2C && VIDEO_V4L2 && MEDIA_CONTROLLER
+        ---help---
+          This is a driver for the AS3645A and LM3555 flash controllers. It has
+          build in control for flash, torch and indicator LEDs.
+
 comment "Video improvement chips"
 
 config VIDEO_UPD64031A
@@ -580,25 +587,6 @@ config VIDEO_M52790
 
 endmenu # encoder / decoder chips
 
-config VIDEO_SH_VOU
-        tristate "SuperH VOU video output driver"
-        depends on VIDEO_DEV && ARCH_SHMOBILE
-        select VIDEOBUF_DMA_CONTIG
-        help
-          Support for the Video Output Unit (VOU) on SuperH SoCs.
-
-config VIDEO_VIU
-        tristate "Freescale VIU Video Driver"
-        depends on VIDEO_V4L2 && PPC_MPC512x
-        select VIDEOBUF_DMA_CONTIG
-        default y
-        ---help---
-          Support for Freescale VIU video driver. This device captures
-          video data, or overlays video on DIU frame buffer.
-
-          Say Y here if you want to enable VIU device on MPC5121e Rev2+.
-          In doubt, say N.
-
 config VIDEO_VIVI
         tristate "Virtual Video Driver"
         depends on VIDEO_DEV && VIDEO_V4L2 && !SPARC32 && !SPARC64
@@ -613,66 +601,130 @@ config VIDEO_VIVI
           Say Y here if you want to test video apps or debug V4L devices.
           In doubt, say N.
 
-source "drivers/media/video/davinci/Kconfig"
+#
+# USB Multimedia device configuration
+#
 
-source "drivers/media/video/omap/Kconfig"
+menuconfig V4L_USB_DRIVERS
+        bool "V4L USB devices"
+        depends on USB
+        default y
 
-source "drivers/media/video/bt8xx/Kconfig"
+if V4L_USB_DRIVERS
 
-config VIDEO_PMS
-        tristate "Mediavision Pro Movie Studio Video For Linux"
-        depends on ISA && VIDEO_V4L2
-        help
-          Say Y if you have such a thing.
+source "drivers/media/video/uvc/Kconfig"
+
+source "drivers/media/video/gspca/Kconfig"
+
+source "drivers/media/video/pvrusb2/Kconfig"
+
+source "drivers/media/video/hdpvr/Kconfig"
+
+source "drivers/media/video/em28xx/Kconfig"
+
+source "drivers/media/video/tlg2300/Kconfig"
+
+source "drivers/media/video/cx231xx/Kconfig"
+
+source "drivers/media/video/tm6000/Kconfig"
+
+source "drivers/media/video/usbvision/Kconfig"
+
+source "drivers/media/video/et61x251/Kconfig"
+
+source "drivers/media/video/sn9c102/Kconfig"
+
+source "drivers/media/video/pwc/Kconfig"
+
+source "drivers/media/video/cpia2/Kconfig"
+
+config USB_ZR364XX
+        tristate "USB ZR364XX Camera support"
+        depends on VIDEO_V4L2
+        select VIDEOBUF_GEN
+        select VIDEOBUF_VMALLOC
+        ---help---
+          Say Y here if you want to connect this type of camera to your
+          computer's USB port.
+          See <file:Documentation/video4linux/zr364xx.txt> for more info
+          and list of supported cameras.
 
           To compile this driver as a module, choose M here: the
-          module will be called pms.
+          module will be called zr364xx.
 
-config VIDEO_BWQCAM
-        tristate "Quickcam BW Video For Linux"
-        depends on PARPORT && VIDEO_V4L2
-        help
-          Say Y have if you the black and white version of the QuickCam
-          camera. See the next option for the color version.
+config USB_STKWEBCAM
+        tristate "USB Syntek DC1125 Camera support"
+        depends on VIDEO_V4L2 && EXPERIMENTAL
+        ---help---
+          Say Y here if you want to use this type of camera.
+          Supported devices are typically found in some Asus laptops,
+          with USB id 174f:a311 and 05e1:0501. Other Syntek cameras
+          may be supported by the stk11xx driver, from which this is
+          derived, see <http://sourceforge.net/projects/syntekdriver/>
 
           To compile this driver as a module, choose M here: the
-          module will be called bw-qcam.
+          module will be called stkwebcam.
 
-config VIDEO_CQCAM
-        tristate "QuickCam Colour Video For Linux (EXPERIMENTAL)"
-        depends on EXPERIMENTAL && PARPORT && VIDEO_V4L2
+config USB_S2255
+        tristate "USB Sensoray 2255 video capture device"
+        depends on VIDEO_V4L2
+        select VIDEOBUF_VMALLOC
+        default n
         help
-          This is the video4linux driver for the colour version of the
-          Connectix QuickCam.  If you have one of these cameras, say Y here,
-          otherwise say N.  This driver does not work with the original
-          monochrome QuickCam, QuickCam VC or QuickClip.  It is also available
-          as a module (c-qcam).
-          Read <file:Documentation/video4linux/CQcam.txt> for more information.
+          Say Y here if you want support for the Sensoray 2255 USB device.
+          This driver can be compiled as a module, called s2255drv.
 
-config VIDEO_W9966
-        tristate "W9966CF Webcam (FlyCam Supra and others) Video For Linux"
-        depends on PARPORT_1284 && PARPORT && VIDEO_V4L2
-        help
-          Video4linux driver for Winbond's w9966 based Webcams.
-          Currently tested with the LifeView FlyCam Supra.
-          If you have one of these cameras, say Y here
-          otherwise say N.
-          This driver is also available as a module (w9966).
+endif # V4L_USB_DRIVERS
 
-          Check out <file:Documentation/video4linux/w9966.txt> for more
-          information.
+#
+# PCI drivers configuration
+#
 
-source "drivers/media/video/cpia2/Kconfig"
+menuconfig V4L_PCI_DRIVERS
+        bool "V4L PCI(e) devices"
+        depends on PCI
+        default y
+        ---help---
+          Say Y here to enable support for these PCI(e) drivers.
 
-config VIDEO_VINO
-        tristate "SGI Vino Video For Linux (EXPERIMENTAL)"
-        depends on I2C && SGI_IP22 && EXPERIMENTAL && VIDEO_V4L2
-        select VIDEO_SAA7191 if VIDEO_HELPER_CHIPS_AUTO
-        help
-          Say Y here to build in support for the Vino video input system found
-          on SGI Indy machines.
+if V4L_PCI_DRIVERS
 
-source "drivers/media/video/zoran/Kconfig"
+source "drivers/media/video/au0828/Kconfig"
+
+source "drivers/media/video/bt8xx/Kconfig"
+
+source "drivers/media/video/cx18/Kconfig"
+
+source "drivers/media/video/cx23885/Kconfig"
+
+source "drivers/media/video/cx25821/Kconfig"
+
+source "drivers/media/video/cx88/Kconfig"
+
+config VIDEO_HEXIUM_GEMINI
+        tristate "Hexium Gemini frame grabber"
+        depends on PCI && VIDEO_V4L2 && I2C
+        select VIDEO_SAA7146_VV
+        ---help---
+          This is a video4linux driver for the Hexium Gemini frame
+          grabber card by Hexium. Please note that the Gemini Dual
+          card is *not* fully supported.
+
+          To compile this driver as a module, choose M here: the
+          module will be called hexium_gemini.
+
+config VIDEO_HEXIUM_ORION
+        tristate "Hexium HV-PCI6 and Orion frame grabber"
+        depends on PCI && VIDEO_V4L2 && I2C
+        select VIDEO_SAA7146_VV
+        ---help---
+          This is a video4linux driver for the Hexium HV-PCI6 and
+          Orion frame grabber cards by Hexium.
+
+          To compile this driver as a module, choose M here: the
+          module will be called hexium_orion.
+
+source "drivers/media/video/ivtv/Kconfig"
 
 config VIDEO_MEYE
         tristate "Sony Vaio Picturebook Motion Eye Video For Linux"
@@ -688,8 +740,6 @@ config VIDEO_MEYE
           To compile this driver as a module, choose M here: the
           module will be called meye.
 
-source "drivers/media/video/saa7134/Kconfig"
-
 config VIDEO_MXB
         tristate "Siemens-Nixdorf 'Multimedia eXtension Board'"
         depends on PCI && VIDEO_V4L2 && I2C
@@ -706,28 +756,119 @@ config VIDEO_MXB
           To compile this driver as a module, choose M here: the
           module will be called mxb.
 
-config VIDEO_HEXIUM_ORION
-        tristate "Hexium HV-PCI6 and Orion frame grabber"
-        depends on PCI && VIDEO_V4L2 && I2C
-        select VIDEO_SAA7146_VV
+source "drivers/media/video/saa7134/Kconfig"
+
+source "drivers/media/video/saa7164/Kconfig"
+
+source "drivers/media/video/zoran/Kconfig"
+
+endif # V4L_PCI_DRIVERS
+
+#
+# ISA & parallel port drivers configuration
+#
+
+menuconfig V4L_ISA_PARPORT_DRIVERS
+        bool "V4L ISA and parallel port devices"
+        depends on ISA || PARPORT
+        default n
         ---help---
-          This is a video4linux driver for the Hexium HV-PCI6 and
-          Orion frame grabber cards by Hexium.
+          Say Y here to enable support for these ISA and parallel port drivers.
+
+if V4L_ISA_PARPORT_DRIVERS
+
+config VIDEO_BWQCAM
+        tristate "Quickcam BW Video For Linux"
+        depends on PARPORT && VIDEO_V4L2
+        help
+          Say Y have if you the black and white version of the QuickCam
+          camera. See the next option for the color version.
 
           To compile this driver as a module, choose M here: the
-          module will be called hexium_orion.
+          module will be called bw-qcam.
 
-config VIDEO_HEXIUM_GEMINI
-        tristate "Hexium Gemini frame grabber"
-        depends on PCI && VIDEO_V4L2 && I2C
-        select VIDEO_SAA7146_VV
-        ---help---
-          This is a video4linux driver for the Hexium Gemini frame
-          grabber card by Hexium. Please note that the Gemini Dual
-          card is *not* fully supported.
+config VIDEO_CQCAM
+        tristate "QuickCam Colour Video For Linux"
+        depends on PARPORT && VIDEO_V4L2
+        help
+          This is the video4linux driver for the colour version of the
+          Connectix QuickCam.  If you have one of these cameras, say Y here,
+          otherwise say N.  This driver does not work with the original
+          monochrome QuickCam, QuickCam VC or QuickClip.  It is also available
+          as a module (c-qcam).
+          Read <file:Documentation/video4linux/CQcam.txt> for more information.
+
+config VIDEO_PMS
+        tristate "Mediavision Pro Movie Studio Video For Linux"
+        depends on ISA && VIDEO_V4L2
+        help
+          Say Y if you have the ISA Mediavision Pro Movie Studio
+          capture card.
 
           To compile this driver as a module, choose M here: the
-          module will be called hexium_gemini.
+          module will be called pms.
+
+config VIDEO_W9966
+        tristate "W9966CF Webcam (FlyCam Supra and others) Video For Linux"
+        depends on PARPORT_1284 && PARPORT && VIDEO_V4L2
+        help
+          Video4linux driver for Winbond's w9966 based Webcams.
+          Currently tested with the LifeView FlyCam Supra.
+          If you have one of these cameras, say Y here
+          otherwise say N.
+          This driver is also available as a module (w9966).
+
+          Check out <file:Documentation/video4linux/w9966.txt> for more
+          information.
+
+endif # V4L_ISA_PARPORT_DRIVERS
+
+menuconfig V4L_PLATFORM_DRIVERS
+        bool "V4L platform devices"
+        default n
+        ---help---
+          Say Y here to enable support for platform-specific V4L drivers.
+
+if V4L_PLATFORM_DRIVERS
+
+source "drivers/media/video/marvell-ccic/Kconfig"
+
+config VIDEO_VIA_CAMERA
+        tristate "VIAFB camera controller support"
+        depends on FB_VIA
+        select VIDEOBUF_DMA_SG
+        select VIDEO_OV7670
+        help
+           Driver support for the integrated camera controller in VIA
+           Chrome9 chipsets.  Currently only tested on OLPC xo-1.5 systems
+           with ov7670 sensors.
+
+#
+# Platform multimedia device configuration
+#
+
+source "drivers/media/video/davinci/Kconfig"
+
+source "drivers/media/video/omap/Kconfig"
+
+config VIDEO_SH_VOU
+        tristate "SuperH VOU video output driver"
+        depends on VIDEO_DEV && ARCH_SHMOBILE
+        select VIDEOBUF_DMA_CONTIG
+        help
+          Support for the Video Output Unit (VOU) on SuperH SoCs.
+
+config VIDEO_VIU
+        tristate "Freescale VIU Video Driver"
+        depends on VIDEO_V4L2 && PPC_MPC512x
+        select VIDEOBUF_DMA_CONTIG
+        default y
+        ---help---
+          Support for Freescale VIU video driver. This device captures
+          video data, or overlays video on DIU frame buffer.
+
+          Say Y here if you want to enable VIU device on MPC5121e Rev2+.
+          In doubt, say N.
 
 config VIDEO_TIMBERDALE
         tristate "Support for timberdale Video In/LogiWIN"
@@ -739,21 +880,13 @@ config VIDEO_TIMBERDALE
         ---help---
           Add support for the Video In peripherial of the timberdale FPGA.
 
-source "drivers/media/video/cx88/Kconfig"
-
-source "drivers/media/video/cx23885/Kconfig"
-
-source "drivers/media/video/cx25821/Kconfig"
-
-source "drivers/media/video/au0828/Kconfig"
-
-source "drivers/media/video/ivtv/Kconfig"
-
-source "drivers/media/video/cx18/Kconfig"
-
-source "drivers/media/video/saa7164/Kconfig"
-
-source "drivers/media/video/marvell-ccic/Kconfig"
+config VIDEO_VINO
+        tristate "SGI Vino Video For Linux"
+        depends on I2C && SGI_IP22 && VIDEO_V4L2
+        select VIDEO_SAA7191 if VIDEO_HELPER_CHIPS_AUTO
+        help
+          Say Y here to build in support for the Vino video input system found
+          on SGI Indy machines.
 
 config VIDEO_M32R_AR
         tristate "AR devices"
@@ -774,16 +907,6 @@ config VIDEO_M32R_AR_M64278
           To compile this driver as a module, choose M here: the
           module will be called arv.
 
-config VIDEO_VIA_CAMERA
-        tristate "VIAFB camera controller support"
-        depends on FB_VIA
-        select VIDEOBUF_DMA_SG
-        select VIDEO_OV7670
-        help
-           Driver support for the integrated camera controller in VIA
-           Chrome9 chipsets.  Currently only tested on OLPC xo-1.5 systems
-           with ov7670 sensors.
-
 config VIDEO_OMAP3
         tristate "OMAP 3 Camera support (EXPERIMENTAL)"
         depends on OMAP_IOVMM && VIDEO_V4L2 && I2C && VIDEO_V4L2_SUBDEV_API && ARCH_OMAP3 && EXPERIMENTAL
@@ -1002,78 +1125,7 @@ config VIDEO_S5P_MIPI_CSIS
 
 source "drivers/media/video/s5p-tv/Kconfig"
 
-#
-# USB Multimedia device configuration
-#
-
-menuconfig V4L_USB_DRIVERS
-        bool "V4L USB devices"
-        depends on USB
-        default y
-
-if V4L_USB_DRIVERS && USB
-
-source "drivers/media/video/uvc/Kconfig"
-
-source "drivers/media/video/gspca/Kconfig"
-
-source "drivers/media/video/pvrusb2/Kconfig"
-
-source "drivers/media/video/hdpvr/Kconfig"
-
-source "drivers/media/video/em28xx/Kconfig"
-
-source "drivers/media/video/tlg2300/Kconfig"
-
-source "drivers/media/video/cx231xx/Kconfig"
-
-source "drivers/media/video/tm6000/Kconfig"
-
-source "drivers/media/video/usbvision/Kconfig"
-
-source "drivers/media/video/et61x251/Kconfig"
-
-source "drivers/media/video/sn9c102/Kconfig"
-
-source "drivers/media/video/pwc/Kconfig"
-
-config USB_ZR364XX
-        tristate "USB ZR364XX Camera support"
-        depends on VIDEO_V4L2
-        select VIDEOBUF_GEN
-        select VIDEOBUF_VMALLOC
-        ---help---
-          Say Y here if you want to connect this type of camera to your
-          computer's USB port.
-          See <file:Documentation/video4linux/zr364xx.txt> for more info
-          and list of supported cameras.
-
-          To compile this driver as a module, choose M here: the
-          module will be called zr364xx.
-
-config USB_STKWEBCAM
-        tristate "USB Syntek DC1125 Camera support"
-        depends on VIDEO_V4L2 && EXPERIMENTAL
-        ---help---
-          Say Y here if you want to use this type of camera.
-          Supported devices are typically found in some Asus laptops,
-          with USB id 174f:a311 and 05e1:0501. Other Syntek cameras
-          may be supported by the stk11xx driver, from which this is
-          derived, see <http://sourceforge.net/projects/syntekdriver/>
-
-          To compile this driver as a module, choose M here: the
-          module will be called stkwebcam.
-
-config USB_S2255
-        tristate "USB Sensoray 2255 video capture device"
-        depends on VIDEO_V4L2
-        select VIDEOBUF_VMALLOC
-        default n
-        help
-          Say Y here if you want support for the Sensoray 2255 USB device.
-          This driver can be compiled as a module, called s2255drv.
-
-endif # V4L_USB_DRIVERS
+endif # V4L_PLATFORM_DRIVERS
 endif # VIDEO_CAPTURE_DRIVERS
 
 menuconfig V4L_MEM2MEM_DRIVERS
@@ -1098,6 +1150,23 @@ config VIDEO_MEM2MEM_TESTDEV
           This is a virtual test device for the memory-to-memory driver
           framework.
 
+config VIDEO_SAMSUNG_S5P_G2D
+        tristate "Samsung S5P and EXYNOS4 G2D 2d graphics accelerator driver"
+        depends on VIDEO_DEV && VIDEO_V4L2 && PLAT_S5P
+        select VIDEOBUF2_DMA_CONTIG
+        select V4L2_MEM2MEM_DEV
+        default n
+        ---help---
+          This is a v4l2 driver for Samsung S5P and EXYNOS4 G2D
+          2d graphics accelerator.
+
+config VIDEO_SAMSUNG_S5P_JPEG
+        tristate "Samsung S5P/Exynos4 JPEG codec driver (EXPERIMENTAL)"
+        depends on VIDEO_DEV && VIDEO_V4L2 && PLAT_S5P && EXPERIMENTAL
+        select VIDEOBUF2_DMA_CONTIG
+        select V4L2_MEM2MEM_DEV
+        ---help---
+          This is a v4l2 driver for Samsung S5P and EXYNOS4 JPEG codec
 
 config VIDEO_SAMSUNG_S5P_MFC
         tristate "Samsung S5P MFC 5.1 Video Codec"
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 117f9c4b4cb9..354138804cda 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -74,6 +74,7 @@ obj-$(CONFIG_VIDEO_NOON010PC30)	+= noon010pc30.o
 obj-$(CONFIG_VIDEO_M5MOLS)      += m5mols/
 obj-$(CONFIG_VIDEO_S5K6AA)      += s5k6aa.o
 obj-$(CONFIG_VIDEO_ADP1653)     += adp1653.o
+obj-$(CONFIG_VIDEO_AS3645A)     += as3645a.o
 
 obj-$(CONFIG_SOC_CAMERA_IMX074)         += imx074.o
 obj-$(CONFIG_SOC_CAMERA_MT9M001)        += mt9m001.o
@@ -177,9 +178,12 @@ obj-$(CONFIG_VIDEO_OMAP1)		+= omap1_camera.o
 obj-$(CONFIG_VIDEO_ATMEL_ISI)           += atmel-isi.o
 
 obj-$(CONFIG_VIDEO_SAMSUNG_S5P_FIMC)    += s5p-fimc/
+obj-$(CONFIG_VIDEO_SAMSUNG_S5P_JPEG)    += s5p-jpeg/
 obj-$(CONFIG_VIDEO_SAMSUNG_S5P_MFC)     += s5p-mfc/
 obj-$(CONFIG_VIDEO_SAMSUNG_S5P_TV)      += s5p-tv/
 
+obj-$(CONFIG_VIDEO_SAMSUNG_S5P_G2D)     += s5p-g2d/
+
 obj-$(CONFIG_ARCH_DAVINCI)              += davinci/
 
 obj-$(CONFIG_VIDEO_SH_VOU)              += sh_vou.o
diff --git a/drivers/media/video/adv7170.c b/drivers/media/video/adv7170.c
index 23ba5c37c3e4..879f1d839760 100644
--- a/drivers/media/video/adv7170.c
+++ b/drivers/media/video/adv7170.c
@@ -64,6 +64,11 @@ static inline struct adv7170 *to_adv7170(struct v4l2_subdev *sd)
 
 static char *inputs[] = { "pass_through", "play_back" };
 
+static enum v4l2_mbus_pixelcode adv7170_codes[] = {
+        V4L2_MBUS_FMT_UYVY8_2X8,
+        V4L2_MBUS_FMT_UYVY8_1X16,
+};
+
 /* ----------------------------------------------------------------------- */
 
 static inline int adv7170_write(struct v4l2_subdev *sd, u8 reg, u8 value)
@@ -258,6 +263,60 @@ static int adv7170_s_routing(struct v4l2_subdev *sd,
         return 0;
 }
 
+static int adv7170_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
+                                enum v4l2_mbus_pixelcode *code)
+{
+        if (index >= ARRAY_SIZE(adv7170_codes))
+                return -EINVAL;
+
+        *code = adv7170_codes[index];
+        return 0;
+}
+
+static int adv7170_g_fmt(struct v4l2_subdev *sd,
+                                struct v4l2_mbus_framefmt *mf)
+{
+        u8 val = adv7170_read(sd, 0x7);
+
+        if ((val & 0x40) == (1 << 6))
+                mf->code = V4L2_MBUS_FMT_UYVY8_1X16;
+        else
+                mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
+
+        mf->colorspace  = V4L2_COLORSPACE_SMPTE170M;
+        mf->width       = 0;
+        mf->height      = 0;
+        mf->field       = V4L2_FIELD_ANY;
+
+        return 0;
+}
+
+static int adv7170_s_fmt(struct v4l2_subdev *sd,
+                                struct v4l2_mbus_framefmt *mf)
+{
+        u8 val = adv7170_read(sd, 0x7);
+        int ret;
+
+        switch (mf->code) {
+        case V4L2_MBUS_FMT_UYVY8_2X8:
+                val &= ~0x40;
+                break;
+
+        case V4L2_MBUS_FMT_UYVY8_1X16:
+                val |= 0x40;
+                break;
+
+        default:
+                v4l2_dbg(1, debug, sd,
+                        "illegal v4l2_mbus_framefmt code: %d\n", mf->code);
+                return -EINVAL;
+        }
+
+        ret = adv7170_write(sd, 0x7, val);
+
+        return ret;
+}
+
 static int adv7170_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
@@ -274,6 +333,9 @@ static const struct v4l2_subdev_core_ops adv7170_core_ops = {
 static const struct v4l2_subdev_video_ops adv7170_video_ops = {
         .s_std_output = adv7170_s_std_output,
         .s_routing = adv7170_s_routing,
+        .s_mbus_fmt = adv7170_s_fmt,
+        .g_mbus_fmt = adv7170_g_fmt,
+        .enum_mbus_fmt  = adv7170_enum_fmt,
 };
 
 static const struct v4l2_subdev_ops adv7170_ops = {
diff --git a/drivers/media/video/as3645a.c b/drivers/media/video/as3645a.c
new file mode 100644
index 000000000000..ec859a580651
--- /dev/null
+++ b/drivers/media/video/as3645a.c
@@ -0,0 +1,904 @@
+/*
+ * drivers/media/video/as3645a.c - AS3645A and LM3555 flash controllers driver
+ *
+ * Copyright (C) 2008-2011 Nokia Corporation
+ * Copyright (c) 2011, Intel Corporation.
+ *
+ * Contact: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ * TODO:
+ * - Check hardware FSTROBE control when sensor driver add support for this
+ *
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+
+#include <media/as3645a.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-device.h>
+
+#define AS_TIMER_MS_TO_CODE(t)                  (((t) - 100) / 50)
+#define AS_TIMER_CODE_TO_MS(c)                  (50 * (c) + 100)
+
+/* Register definitions */
+
+/* Read-only Design info register: Reset state: xxxx 0001 */
+#define AS_DESIGN_INFO_REG                      0x00
+#define AS_DESIGN_INFO_FACTORY(x)               (((x) >> 4))
+#define AS_DESIGN_INFO_MODEL(x)                 ((x) & 0x0f)
+
+/* Read-only Version control register: Reset state: 0000 0000
+ * for first engineering samples
+ */
+#define AS_VERSION_CONTROL_REG                  0x01
+#define AS_VERSION_CONTROL_RFU(x)               (((x) >> 4))
+#define AS_VERSION_CONTROL_VERSION(x)           ((x) & 0x0f)
+
+/* Read / Write (Indicator and timer register): Reset state: 0000 1111 */
+#define AS_INDICATOR_AND_TIMER_REG              0x02
+#define AS_INDICATOR_AND_TIMER_TIMEOUT_SHIFT    0
+#define AS_INDICATOR_AND_TIMER_VREF_SHIFT       4
+#define AS_INDICATOR_AND_TIMER_INDICATOR_SHIFT  6
+
+/* Read / Write (Current set register): Reset state: 0110 1001 */
+#define AS_CURRENT_SET_REG                      0x03
+#define AS_CURRENT_ASSIST_LIGHT_SHIFT           0
+#define AS_CURRENT_LED_DET_ON                   (1 << 3)
+#define AS_CURRENT_FLASH_CURRENT_SHIFT          4
+
+/* Read / Write (Control register): Reset state: 1011 0100 */
+#define AS_CONTROL_REG                          0x04
+#define AS_CONTROL_MODE_SETTING_SHIFT           0
+#define AS_CONTROL_STROBE_ON                    (1 << 2)
+#define AS_CONTROL_OUT_ON                       (1 << 3)
+#define AS_CONTROL_EXT_TORCH_ON                 (1 << 4)
+#define AS_CONTROL_STROBE_TYPE_EDGE             (0 << 5)
+#define AS_CONTROL_STROBE_TYPE_LEVEL            (1 << 5)
+#define AS_CONTROL_COIL_PEAK_SHIFT              6
+
+/* Read only (D3 is read / write) (Fault and info): Reset state: 0000 x000 */
+#define AS_FAULT_INFO_REG                       0x05
+#define AS_FAULT_INFO_INDUCTOR_PEAK_LIMIT       (1 << 1)
+#define AS_FAULT_INFO_INDICATOR_LED             (1 << 2)
+#define AS_FAULT_INFO_LED_AMOUNT                (1 << 3)
+#define AS_FAULT_INFO_TIMEOUT                   (1 << 4)
+#define AS_FAULT_INFO_OVER_TEMPERATURE          (1 << 5)
+#define AS_FAULT_INFO_SHORT_CIRCUIT             (1 << 6)
+#define AS_FAULT_INFO_OVER_VOLTAGE              (1 << 7)
+
+/* Boost register */
+#define AS_BOOST_REG                            0x0d
+#define AS_BOOST_CURRENT_DISABLE                (0 << 0)
+#define AS_BOOST_CURRENT_ENABLE                 (1 << 0)
+
+/* Password register is used to unlock boost register writing */
+#define AS_PASSWORD_REG                         0x0f
+#define AS_PASSWORD_UNLOCK_VALUE                0x55
+
+enum as_mode {
+        AS_MODE_EXT_TORCH = 0 << AS_CONTROL_MODE_SETTING_SHIFT,
+        AS_MODE_INDICATOR = 1 << AS_CONTROL_MODE_SETTING_SHIFT,
+        AS_MODE_ASSIST = 2 << AS_CONTROL_MODE_SETTING_SHIFT,
+        AS_MODE_FLASH = 3 << AS_CONTROL_MODE_SETTING_SHIFT,
+};
+
+/*
+ * struct as3645a
+ *
+ * @subdev:             V4L2 subdev
+ * @pdata:              Flash platform data
+ * @power_lock:         Protects power_count
+ * @power_count:        Power reference count
+ * @led_mode:           V4L2 flash LED mode
+ * @timeout:            Flash timeout in microseconds
+ * @flash_current:      Flash current (0=200mA ... 15=500mA). Maximum
+ *                      values are 400mA for two LEDs and 500mA for one LED.
+ * @assist_current:     Torch/Assist light current (0=20mA, 1=40mA ... 7=160mA)
+ * @indicator_current:  Indicator LED current (0=0mA, 1=2.5mA ... 4=10mA)
+ * @strobe_source:      Flash strobe source (software or external)
+ */
+struct as3645a {
+        struct v4l2_subdev subdev;
+        const struct as3645a_platform_data *pdata;
+
+        struct mutex power_lock;
+        int power_count;
+
+        /* Controls */
+        struct v4l2_ctrl_handler ctrls;
+
+        enum v4l2_flash_led_mode led_mode;
+        unsigned int timeout;
+        u8 flash_current;
+        u8 assist_current;
+        u8 indicator_current;
+        enum v4l2_flash_strobe_source strobe_source;
+};
+
+#define to_as3645a(sd) container_of(sd, struct as3645a, subdev)
+
+/* Return negative errno else zero on success */
+static int as3645a_write(struct as3645a *flash, u8 addr, u8 val)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
+        int rval;
+
+        rval = i2c_smbus_write_byte_data(client, addr, val);
+
+        dev_dbg(&client->dev, "Write Addr:%02X Val:%02X %s\n", addr, val,
+                rval < 0 ? "fail" : "ok");
+
+        return rval;
+}
+
+/* Return negative errno else a data byte received from the device. */
+static int as3645a_read(struct as3645a *flash, u8 addr)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
+        int rval;
+
+        rval = i2c_smbus_read_byte_data(client, addr);
+
+        dev_dbg(&client->dev, "Read Addr:%02X Val:%02X %s\n", addr, rval,
+                rval < 0 ? "fail" : "ok");
+
+        return rval;
+}
+
+/* -----------------------------------------------------------------------------
+ * Hardware configuration and trigger
+ */
+
+/*
+ * as3645a_set_config - Set flash configuration registers
+ * @flash: The flash
+ *
+ * Configure the hardware with flash, assist and indicator currents, as well as
+ * flash timeout.
+ *
+ * Return 0 on success, or a negative error code if an I2C communication error
+ * occurred.
+ */
+static int as3645a_set_config(struct as3645a *flash)
+{
+        int ret;
+        u8 val;
+
+        val = (flash->flash_current << AS_CURRENT_FLASH_CURRENT_SHIFT)
+            | (flash->assist_current << AS_CURRENT_ASSIST_LIGHT_SHIFT)
+            | AS_CURRENT_LED_DET_ON;
+
+        ret = as3645a_write(flash, AS_CURRENT_SET_REG, val);
+        if (ret < 0)
+                return ret;
+
+        val = AS_TIMER_MS_TO_CODE(flash->timeout / 1000)
+                    << AS_INDICATOR_AND_TIMER_TIMEOUT_SHIFT;
+
+        val |= (flash->pdata->vref << AS_INDICATOR_AND_TIMER_VREF_SHIFT)
+            |  ((flash->indicator_current ? flash->indicator_current - 1 : 0)
+                 << AS_INDICATOR_AND_TIMER_INDICATOR_SHIFT);
+
+        return as3645a_write(flash, AS_INDICATOR_AND_TIMER_REG, val);
+}
+
+/*
+ * as3645a_set_control - Set flash control register
+ * @flash: The flash
+ * @mode: Desired output mode
+ * @on: Desired output state
+ *
+ * Configure the hardware with output mode and state.
+ *
+ * Return 0 on success, or a negative error code if an I2C communication error
+ * occurred.
+ */
+static int
+as3645a_set_control(struct as3645a *flash, enum as_mode mode, bool on)
+{
+        u8 reg;
+
+        /* Configure output parameters and operation mode. */
+        reg = (flash->pdata->peak << AS_CONTROL_COIL_PEAK_SHIFT)
+            | (on ? AS_CONTROL_OUT_ON : 0)
+            | mode;
+
+        if (flash->led_mode == V4L2_FLASH_LED_MODE_FLASH &&
+            flash->strobe_source == V4L2_FLASH_STROBE_SOURCE_EXTERNAL) {
+                reg |= AS_CONTROL_STROBE_TYPE_LEVEL
+                    |  AS_CONTROL_STROBE_ON;
+        }
+
+        return as3645a_write(flash, AS_CONTROL_REG, reg);
+}
+
+/*
+ * as3645a_set_output - Configure output and operation mode
+ * @flash: Flash controller
+ * @strobe: Strobe the flash (only valid in flash mode)
+ *
+ * Turn the LEDs output on/off and set the operation mode based on the current
+ * parameters.
+ *
+ * The AS3645A can't control the indicator LED independently of the flash/torch
+ * LED. If the flash controller is in V4L2_FLASH_LED_MODE_NONE mode, set the
+ * chip to indicator mode. Otherwise set it to assist light (torch) or flash
+ * mode.
+ *
+ * In indicator and assist modes, turn the output on/off based on the indicator
+ * and torch currents. In software strobe flash mode, turn the output on/off
+ * based on the strobe parameter.
+ */
+static int as3645a_set_output(struct as3645a *flash, bool strobe)
+{
+        enum as_mode mode;
+        bool on;
+
+        switch (flash->led_mode) {
+        case V4L2_FLASH_LED_MODE_NONE:
+                on = flash->indicator_current != 0;
+                mode = AS_MODE_INDICATOR;
+                break;
+        case V4L2_FLASH_LED_MODE_TORCH:
+                on = true;
+                mode = AS_MODE_ASSIST;
+                break;
+        case V4L2_FLASH_LED_MODE_FLASH:
+                on = strobe;
+                mode = AS_MODE_FLASH;
+                break;
+        default:
+                BUG();
+        }
+
+        /* Configure output parameters and operation mode. */
+        return as3645a_set_control(flash, mode, on);
+}
+
+/* -----------------------------------------------------------------------------
+ * V4L2 controls
+ */
+
+static int as3645a_is_active(struct as3645a *flash)
+{
+        int ret;
+
+        ret = as3645a_read(flash, AS_CONTROL_REG);
+        return ret < 0 ? ret : !!(ret & AS_CONTROL_OUT_ON);
+}
+
+static int as3645a_read_fault(struct as3645a *flash)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
+        int rval;
+
+        /* NOTE: reading register clear fault status */
+        rval = as3645a_read(flash, AS_FAULT_INFO_REG);
+        if (rval < 0)
+                return rval;
+
+        if (rval & AS_FAULT_INFO_INDUCTOR_PEAK_LIMIT)
+                dev_dbg(&client->dev, "Inductor Peak limit fault\n");
+
+        if (rval & AS_FAULT_INFO_INDICATOR_LED)
+                dev_dbg(&client->dev, "Indicator LED fault: "
+                        "Short circuit or open loop\n");
+
+        dev_dbg(&client->dev, "%u connected LEDs\n",
+                rval & AS_FAULT_INFO_LED_AMOUNT ? 2 : 1);
+
+        if (rval & AS_FAULT_INFO_TIMEOUT)
+                dev_dbg(&client->dev, "Timeout fault\n");
+
+        if (rval & AS_FAULT_INFO_OVER_TEMPERATURE)
+                dev_dbg(&client->dev, "Over temperature fault\n");
+
+        if (rval & AS_FAULT_INFO_SHORT_CIRCUIT)
+                dev_dbg(&client->dev, "Short circuit fault\n");
+
+        if (rval & AS_FAULT_INFO_OVER_VOLTAGE)
+                dev_dbg(&client->dev, "Over voltage fault: "
+                        "Indicates missing capacitor or open connection\n");
+
+        return rval;
+}
+
+static int as3645a_get_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct as3645a *flash =
+                container_of(ctrl->handler, struct as3645a, ctrls);
+        struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
+        int value;
+
+        switch (ctrl->id) {
+        case V4L2_CID_FLASH_FAULT:
+                value = as3645a_read_fault(flash);
+                if (value < 0)
+                        return value;
+
+                ctrl->cur.val = 0;
+                if (value & AS_FAULT_INFO_SHORT_CIRCUIT)
+                        ctrl->cur.val |= V4L2_FLASH_FAULT_SHORT_CIRCUIT;
+                if (value & AS_FAULT_INFO_OVER_TEMPERATURE)
+                        ctrl->cur.val |= V4L2_FLASH_FAULT_OVER_TEMPERATURE;
+                if (value & AS_FAULT_INFO_TIMEOUT)
+                        ctrl->cur.val |= V4L2_FLASH_FAULT_TIMEOUT;
+                if (value & AS_FAULT_INFO_OVER_VOLTAGE)
+                        ctrl->cur.val |= V4L2_FLASH_FAULT_OVER_VOLTAGE;
+                if (value & AS_FAULT_INFO_INDUCTOR_PEAK_LIMIT)
+                        ctrl->cur.val |= V4L2_FLASH_FAULT_OVER_CURRENT;
+                if (value & AS_FAULT_INFO_INDICATOR_LED)
+                        ctrl->cur.val |= V4L2_FLASH_FAULT_INDICATOR;
+                break;
+
+        case V4L2_CID_FLASH_STROBE_STATUS:
+                if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH) {
+                        ctrl->cur.val = 0;
+                        break;
+                }
+
+                value = as3645a_is_active(flash);
+                if (value < 0)
+                        return value;
+
+                ctrl->cur.val = value;
+                break;
+        }
+
+        dev_dbg(&client->dev, "G_CTRL %08x:%d\n", ctrl->id, ctrl->cur.val);
+
+        return 0;
+}
+
+static int as3645a_set_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct as3645a *flash =
+                container_of(ctrl->handler, struct as3645a, ctrls);
+        struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
+        int ret;
+
+        dev_dbg(&client->dev, "S_CTRL %08x:%d\n", ctrl->id, ctrl->val);
+
+        /* If a control that doesn't apply to the current mode is modified,
+         * we store the value and return immediately. The setting will be
+         * applied when the LED mode is changed. Otherwise we apply the setting
+         * immediately.
+         */
+
+        switch (ctrl->id) {
+        case V4L2_CID_FLASH_LED_MODE:
+                if (flash->indicator_current)
+                        return -EBUSY;
+
+                ret = as3645a_set_config(flash);
+                if (ret < 0)
+                        return ret;
+
+                flash->led_mode = ctrl->val;
+                return as3645a_set_output(flash, false);
+
+        case V4L2_CID_FLASH_STROBE_SOURCE:
+                flash->strobe_source = ctrl->val;
+
+                /* Applies to flash mode only. */
+                if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH)
+                        break;
+
+                return as3645a_set_output(flash, false);
+
+        case V4L2_CID_FLASH_STROBE:
+                if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH)
+                        return -EBUSY;
+
+                return as3645a_set_output(flash, true);
+
+        case V4L2_CID_FLASH_STROBE_STOP:
+                if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH)
+                        return -EBUSY;
+
+                return as3645a_set_output(flash, false);
+
+        case V4L2_CID_FLASH_TIMEOUT:
+                flash->timeout = ctrl->val;
+
+                /* Applies to flash mode only. */
+                if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH)
+                        break;
+
+                return as3645a_set_config(flash);
+
+        case V4L2_CID_FLASH_INTENSITY:
+                flash->flash_current = (ctrl->val - AS3645A_FLASH_INTENSITY_MIN)
+                                     / AS3645A_FLASH_INTENSITY_STEP;
+
+                /* Applies to flash mode only. */
+                if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH)
+                        break;
+
+                return as3645a_set_config(flash);
+
+        case V4L2_CID_FLASH_TORCH_INTENSITY:
+                flash->assist_current =
+                        (ctrl->val - AS3645A_TORCH_INTENSITY_MIN)
+                        / AS3645A_TORCH_INTENSITY_STEP;
+
+                /* Applies to torch mode only. */
+                if (flash->led_mode != V4L2_FLASH_LED_MODE_TORCH)
+                        break;
+
+                return as3645a_set_config(flash);
+
+        case V4L2_CID_FLASH_INDICATOR_INTENSITY:
+                if (flash->led_mode != V4L2_FLASH_LED_MODE_NONE)
+                        return -EBUSY;
+
+                flash->indicator_current =
+                        (ctrl->val - AS3645A_INDICATOR_INTENSITY_MIN)
+                        / AS3645A_INDICATOR_INTENSITY_STEP;
+
+                ret = as3645a_set_config(flash);
+                if (ret < 0)
+                        return ret;
+
+                if ((ctrl->val == 0) == (ctrl->cur.val == 0))
+                        break;
+
+                return as3645a_set_output(flash, false);
+        }
+
+        return 0;
+}
+
+static const struct v4l2_ctrl_ops as3645a_ctrl_ops = {
+        .g_volatile_ctrl = as3645a_get_ctrl,
+        .s_ctrl = as3645a_set_ctrl,
+};
+
+/* -----------------------------------------------------------------------------
+ * V4L2 subdev core operations
+ */
+
+/* Put device into know state. */
+static int as3645a_setup(struct as3645a *flash)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
+        int ret;
+
+        /* clear errors */
+        ret = as3645a_read(flash, AS_FAULT_INFO_REG);
+        if (ret < 0)
+                return ret;
+
+        dev_dbg(&client->dev, "Fault info: %02x\n", ret);
+
+        ret = as3645a_set_config(flash);
+        if (ret < 0)
+                return ret;
+
+        ret = as3645a_set_output(flash, false);
+        if (ret < 0)
+                return ret;
+
+        /* read status */
+        ret = as3645a_read_fault(flash);
+        if (ret < 0)
+                return ret;
+
+        dev_dbg(&client->dev, "AS_INDICATOR_AND_TIMER_REG: %02x\n",
+                as3645a_read(flash, AS_INDICATOR_AND_TIMER_REG));
+        dev_dbg(&client->dev, "AS_CURRENT_SET_REG: %02x\n",
+                as3645a_read(flash, AS_CURRENT_SET_REG));
+        dev_dbg(&client->dev, "AS_CONTROL_REG: %02x\n",
+                as3645a_read(flash, AS_CONTROL_REG));
+
+        return ret & ~AS_FAULT_INFO_LED_AMOUNT ? -EIO : 0;
+}
+
+static int __as3645a_set_power(struct as3645a *flash, int on)
+{
+        int ret;
+
+        if (!on)
+                as3645a_set_control(flash, AS_MODE_EXT_TORCH, false);
+
+        if (flash->pdata->set_power) {
+                ret = flash->pdata->set_power(&flash->subdev, on);
+                if (ret < 0)
+                        return ret;
+        }
+
+        if (!on)
+                return 0;
+
+        ret = as3645a_setup(flash);
+        if (ret < 0) {
+                if (flash->pdata->set_power)
+                        flash->pdata->set_power(&flash->subdev, 0);
+        }
+
+        return ret;
+}
+
+static int as3645a_set_power(struct v4l2_subdev *sd, int on)
+{
+        struct as3645a *flash = to_as3645a(sd);
+        int ret = 0;
+
+        mutex_lock(&flash->power_lock);
+
+        if (flash->power_count == !on) {
+                ret = __as3645a_set_power(flash, !!on);
+                if (ret < 0)
+                        goto done;
+        }
+
+        flash->power_count += on ? 1 : -1;
+        WARN_ON(flash->power_count < 0);
+
+done:
+        mutex_unlock(&flash->power_lock);
+        return ret;
+}
+
+static int as3645a_registered(struct v4l2_subdev *sd)
+{
+        struct as3645a *flash = to_as3645a(sd);
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+        int rval, man, model, rfu, version;
+        const char *vendor;
+
+        /* Power up the flash driver and read manufacturer ID, model ID, RFU
+         * and version.
+         */
+        rval = as3645a_set_power(&flash->subdev, 1);
+        if (rval < 0)
+                return rval;
+
+        rval = as3645a_read(flash, AS_DESIGN_INFO_REG);
+        if (rval < 0)
+                goto power_off;
+
+        man = AS_DESIGN_INFO_FACTORY(rval);
+        model = AS_DESIGN_INFO_MODEL(rval);
+
+        rval = as3645a_read(flash, AS_VERSION_CONTROL_REG);
+        if (rval < 0)
+                goto power_off;
+
+        rfu = AS_VERSION_CONTROL_RFU(rval);
+        version = AS_VERSION_CONTROL_VERSION(rval);
+
+        /* Verify the chip model and version. */
+        if (model != 0x01 || rfu != 0x00) {
+                dev_err(&client->dev, "AS3645A not detected "
+                        "(model %d rfu %d)\n", model, rfu);
+                rval = -ENODEV;
+                goto power_off;
+        }
+
+        switch (man) {
+        case 1:
+                vendor = "AMS, Austria Micro Systems";
+                break;
+        case 2:
+                vendor = "ADI, Analog Devices Inc.";
+                break;
+        case 3:
+                vendor = "NSC, National Semiconductor";
+                break;
+        case 4:
+                vendor = "NXP";
+                break;
+        case 5:
+                vendor = "TI, Texas Instrument";
+                break;
+        default:
+                vendor = "Unknown";
+        }
+
+        dev_info(&client->dev, "Chip vendor: %s (%d) Version: %d\n", vendor,
+                 man, version);
+
+        rval = as3645a_write(flash, AS_PASSWORD_REG, AS_PASSWORD_UNLOCK_VALUE);
+        if (rval < 0)
+                goto power_off;
+
+        rval = as3645a_write(flash, AS_BOOST_REG, AS_BOOST_CURRENT_DISABLE);
+        if (rval < 0)
+                goto power_off;
+
+        /* Setup default values. This makes sure that the chip is in a known
+         * state, in case the power rail can't be controlled.
+         */
+        rval = as3645a_setup(flash);
+
+power_off:
+        as3645a_set_power(&flash->subdev, 0);
+
+        return rval;
+}
+
+static int as3645a_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
+{
+        return as3645a_set_power(sd, 1);
+}
+
+static int as3645a_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
+{
+        return as3645a_set_power(sd, 0);
+}
+
+static const struct v4l2_subdev_core_ops as3645a_core_ops = {
+        .s_power                = as3645a_set_power,
+};
+
+static const struct v4l2_subdev_ops as3645a_ops = {
+        .core = &as3645a_core_ops,
+};
+
+static const struct v4l2_subdev_internal_ops as3645a_internal_ops = {
+        .registered = as3645a_registered,
+        .open = as3645a_open,
+        .close = as3645a_close,
+};
+
+/* -----------------------------------------------------------------------------
+ *  I2C driver
+ */
+#ifdef CONFIG_PM
+
+static int as3645a_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct v4l2_subdev *subdev = i2c_get_clientdata(client);
+        struct as3645a *flash = to_as3645a(subdev);
+        int rval;
+
+        if (flash->power_count == 0)
+                return 0;
+
+        rval = __as3645a_set_power(flash, 0);
+
+        dev_dbg(&client->dev, "Suspend %s\n", rval < 0 ? "failed" : "ok");
+
+        return rval;
+}
+
+static int as3645a_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct v4l2_subdev *subdev = i2c_get_clientdata(client);
+        struct as3645a *flash = to_as3645a(subdev);
+        int rval;
+
+        if (flash->power_count == 0)
+                return 0;
+
+        rval = __as3645a_set_power(flash, 1);
+
+        dev_dbg(&client->dev, "Resume %s\n", rval < 0 ? "fail" : "ok");
+
+        return rval;
+}
+
+#else
+
+#define as3645a_suspend NULL
+#define as3645a_resume  NULL
+
+#endif /* CONFIG_PM */
+
+/*
+ * as3645a_init_controls - Create controls
+ * @flash: The flash
+ *
+ * The number of LEDs reported in platform data is used to compute default
+ * limits. Parameters passed through platform data can override those limits.
+ */
+static int as3645a_init_controls(struct as3645a *flash)
+{
+        const struct as3645a_platform_data *pdata = flash->pdata;
+        struct v4l2_ctrl *ctrl;
+        int maximum;
+
+        v4l2_ctrl_handler_init(&flash->ctrls, 10);
+
+        /* V4L2_CID_FLASH_LED_MODE */
+        v4l2_ctrl_new_std_menu(&flash->ctrls, &as3645a_ctrl_ops,
+                               V4L2_CID_FLASH_LED_MODE, 2, ~7,
+                               V4L2_FLASH_LED_MODE_NONE);
+
+        /* V4L2_CID_FLASH_STROBE_SOURCE */
+        v4l2_ctrl_new_std_menu(&flash->ctrls, &as3645a_ctrl_ops,
+                               V4L2_CID_FLASH_STROBE_SOURCE,
+                               pdata->ext_strobe ? 1 : 0,
+                               pdata->ext_strobe ? ~3 : ~1,
+                               V4L2_FLASH_STROBE_SOURCE_SOFTWARE);
+
+        flash->strobe_source = V4L2_FLASH_STROBE_SOURCE_SOFTWARE;
+
+        /* V4L2_CID_FLASH_STROBE */
+        v4l2_ctrl_new_std(&flash->ctrls, &as3645a_ctrl_ops,
+                          V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);
+
+        /* V4L2_CID_FLASH_STROBE_STOP */
+        v4l2_ctrl_new_std(&flash->ctrls, &as3645a_ctrl_ops,
+                          V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);
+
+        /* V4L2_CID_FLASH_STROBE_STATUS */
+        ctrl = v4l2_ctrl_new_std(&flash->ctrls, &as3645a_ctrl_ops,
+                                 V4L2_CID_FLASH_STROBE_STATUS, 0, 1, 1, 1);
+        if (ctrl != NULL)
+                ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
+
+        /* V4L2_CID_FLASH_TIMEOUT */
+        maximum = pdata->timeout_max;
+
+        v4l2_ctrl_new_std(&flash->ctrls, &as3645a_ctrl_ops,
+                          V4L2_CID_FLASH_TIMEOUT, AS3645A_FLASH_TIMEOUT_MIN,
+                          maximum, AS3645A_FLASH_TIMEOUT_STEP, maximum);
+
+        flash->timeout = maximum;
+
+        /* V4L2_CID_FLASH_INTENSITY */
+        maximum = pdata->flash_max_current;
+
+        v4l2_ctrl_new_std(&flash->ctrls, &as3645a_ctrl_ops,
+                          V4L2_CID_FLASH_INTENSITY, AS3645A_FLASH_INTENSITY_MIN,
+                          maximum, AS3645A_FLASH_INTENSITY_STEP, maximum);
+
+        flash->flash_current = (maximum - AS3645A_FLASH_INTENSITY_MIN)
+                             / AS3645A_FLASH_INTENSITY_STEP;
+
+        /* V4L2_CID_FLASH_TORCH_INTENSITY */
+        maximum = pdata->torch_max_current;
+
+        v4l2_ctrl_new_std(&flash->ctrls, &as3645a_ctrl_ops,
+                          V4L2_CID_FLASH_TORCH_INTENSITY,
+                          AS3645A_TORCH_INTENSITY_MIN, maximum,
+                          AS3645A_TORCH_INTENSITY_STEP,
+                          AS3645A_TORCH_INTENSITY_MIN);
+
+        flash->assist_current = 0;
+
+        /* V4L2_CID_FLASH_INDICATOR_INTENSITY */
+        v4l2_ctrl_new_std(&flash->ctrls, &as3645a_ctrl_ops,
+                          V4L2_CID_FLASH_INDICATOR_INTENSITY,
+                          AS3645A_INDICATOR_INTENSITY_MIN,
+                          AS3645A_INDICATOR_INTENSITY_MAX,
+                          AS3645A_INDICATOR_INTENSITY_STEP,
+                          AS3645A_INDICATOR_INTENSITY_MIN);
+
+        flash->indicator_current = 0;
+
+        /* V4L2_CID_FLASH_FAULT */
+        ctrl = v4l2_ctrl_new_std(&flash->ctrls, &as3645a_ctrl_ops,
+                                 V4L2_CID_FLASH_FAULT, 0,
+                                 V4L2_FLASH_FAULT_OVER_VOLTAGE |
+                                 V4L2_FLASH_FAULT_TIMEOUT |
+                                 V4L2_FLASH_FAULT_OVER_TEMPERATURE |
+                                 V4L2_FLASH_FAULT_SHORT_CIRCUIT, 0, 0);
+        if (ctrl != NULL)
+                ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
+
+        flash->subdev.ctrl_handler = &flash->ctrls;
+
+        return flash->ctrls.error;
+}
+
+static int as3645a_probe(struct i2c_client *client,
+                         const struct i2c_device_id *devid)
+{
+        struct as3645a *flash;
+        int ret;
+
+        if (client->dev.platform_data == NULL)
+                return -ENODEV;
+
+        flash = kzalloc(sizeof(*flash), GFP_KERNEL);
+        if (flash == NULL)
+                return -ENOMEM;
+
+        flash->pdata = client->dev.platform_data;
+
+        v4l2_i2c_subdev_init(&flash->subdev, client, &as3645a_ops);
+        flash->subdev.internal_ops = &as3645a_internal_ops;
+        flash->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
+
+        ret = as3645a_init_controls(flash);
+        if (ret < 0)
+                goto done;
+
+        ret = media_entity_init(&flash->subdev.entity, 0, NULL, 0);
+        if (ret < 0)
+                goto done;
+
+        flash->subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV_FLASH;
+
+        mutex_init(&flash->power_lock);
+
+        flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
+
+done:
+        if (ret < 0) {
+                v4l2_ctrl_handler_free(&flash->ctrls);
+                kfree(flash);
+        }
+
+        return ret;
+}
+
+static int __exit as3645a_remove(struct i2c_client *client)
+{
+        struct v4l2_subdev *subdev = i2c_get_clientdata(client);
+        struct as3645a *flash = to_as3645a(subdev);
+
+        v4l2_device_unregister_subdev(subdev);
+        v4l2_ctrl_handler_free(&flash->ctrls);
+        media_entity_cleanup(&flash->subdev.entity);
+        mutex_destroy(&flash->power_lock);
+        kfree(flash);
+
+        return 0;
+}
+
+static const struct i2c_device_id as3645a_id_table[] = {
+        { AS3645A_NAME, 0 },
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, as3645a_id_table);
+
+static const struct dev_pm_ops as3645a_pm_ops = {
+        .suspend = as3645a_suspend,
+        .resume = as3645a_resume,
+};
+
+static struct i2c_driver as3645a_i2c_driver = {
+        .driver = {
+                .name = AS3645A_NAME,
+                .pm   = &as3645a_pm_ops,
+        },
+        .probe  = as3645a_probe,
+        .remove = __exit_p(as3645a_remove),
+        .id_table = as3645a_id_table,
+};
+
+static int __init as3645a_init(void)
+{
+        int rval;
+
+        rval = i2c_add_driver(&as3645a_i2c_driver);
+        if (rval)
+                pr_err("%s: Failed to register the driver\n", AS3645A_NAME);
+
+        return rval;
+}
+
+static void __exit as3645a_exit(void)
+{
+        i2c_del_driver(&as3645a_i2c_driver);
+}
+
+module_init(as3645a_init);
+module_exit(as3645a_exit);
+
+MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
+MODULE_DESCRIPTION("LED flash driver for AS3645A, LM3555 and their clones");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/atmel-isi.c b/drivers/media/video/atmel-isi.c
index 8c775c59e120..9fe4519176a4 100644
--- a/drivers/media/video/atmel-isi.c
+++ b/drivers/media/video/atmel-isi.c
@@ -90,7 +90,10 @@ struct atmel_isi {
         struct isi_dma_desc             dma_desc[MAX_BUFFER_NUM];
 
         struct completion               complete;
+        /* ISI peripherial clock */
         struct clk                      *pclk;
+        /* ISI_MCK, feed to camera sensor to generate pixel clock */
+        struct clk                      *mck;
         unsigned int                    irq;
 
         struct isi_platform_data        *pdata;
@@ -766,6 +769,12 @@ static int isi_camera_add_device(struct soc_camera_device *icd)
         if (ret)
                 return ret;
 
+        ret = clk_enable(isi->mck);
+        if (ret) {
+                clk_disable(isi->pclk);
+                return ret;
+        }
+
         isi->icd = icd;
         dev_dbg(icd->parent, "Atmel ISI Camera driver attached to camera %d\n",
                  icd->devnum);
@@ -779,6 +788,7 @@ static void isi_camera_remove_device(struct soc_camera_device *icd)
 
         BUG_ON(icd != isi->icd);
 
+        clk_disable(isi->mck);
         clk_disable(isi->pclk);
         isi->icd = NULL;
 
@@ -803,7 +813,7 @@ static int isi_camera_querycap(struct soc_camera_host *ici,
         return 0;
 }
 
-static int isi_camera_set_bus_param(struct soc_camera_device *icd, u32 pixfmt)
+static int isi_camera_set_bus_param(struct soc_camera_device *icd)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
@@ -874,7 +884,7 @@ static int isi_camera_set_bus_param(struct soc_camera_device *icd, u32 pixfmt)
 
         if (isi->pdata->has_emb_sync)
                 cfg1 |= ISI_CFG1_EMB_SYNC;
-        if (isi->pdata->isi_full_mode)
+        if (isi->pdata->full_mode)
                 cfg1 |= ISI_CFG1_FULL_MODE;
 
         isi_writel(isi, ISI_CTRL, ISI_CTRL_DIS);
@@ -912,6 +922,7 @@ static int __devexit atmel_isi_remove(struct platform_device *pdev)
                         isi->fb_descriptors_phys);
 
         iounmap(isi->regs);
+        clk_put(isi->mck);
         clk_put(isi->pclk);
         kfree(isi);
 
@@ -930,7 +941,7 @@ static int __devinit atmel_isi_probe(struct platform_device *pdev)
         struct isi_platform_data *pdata;
 
         pdata = dev->platform_data;
-        if (!pdata || !pdata->data_width_flags) {
+        if (!pdata || !pdata->data_width_flags || !pdata->mck_hz) {
                 dev_err(&pdev->dev,
                         "No config available for Atmel ISI\n");
                 return -EINVAL;
@@ -959,6 +970,19 @@ static int __devinit atmel_isi_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&isi->video_buffer_list);
         INIT_LIST_HEAD(&isi->dma_desc_head);
 
+        /* Get ISI_MCK, provided by programmable clock or external clock */
+        isi->mck = clk_get(dev, "isi_mck");
+        if (IS_ERR(isi->mck)) {
+                dev_err(dev, "Failed to get isi_mck\n");
+                ret = PTR_ERR(isi->mck);
+                goto err_clk_get;
+        }
+
+        /* Set ISI_MCK's frequency, it should be faster than pixel clock */
+        ret = clk_set_rate(isi->mck, pdata->mck_hz);
+        if (ret < 0)
+                goto err_set_mck_rate;
+
         isi->p_fb_descriptors = dma_alloc_coherent(&pdev->dev,
                                 sizeof(struct fbd) * MAX_BUFFER_NUM,
                                 &isi->fb_descriptors_phys,
@@ -1034,9 +1058,12 @@ err_alloc_ctx:
                         isi->p_fb_descriptors,
                         isi->fb_descriptors_phys);
 err_alloc_descriptors:
+err_set_mck_rate:
+        clk_put(isi->mck);
+err_clk_get:
         kfree(isi);
 err_alloc_isi:
-        clk_put(isi->pclk);
+        clk_put(pclk);
 
         return ret;
 }
diff --git a/drivers/media/video/au0828/Kconfig b/drivers/media/video/au0828/Kconfig
index 0c3a5ba0e857..81ba9d9d1b52 100644
--- a/drivers/media/video/au0828/Kconfig
+++ b/drivers/media/video/au0828/Kconfig
@@ -2,6 +2,7 @@
 config VIDEO_AU0828
         tristate "Auvitek AU0828 support"
         depends on I2C && INPUT && DVB_CORE && USB && VIDEO_V4L2
+        depends on DVB_CAPTURE_DRIVERS
         select I2C_ALGOBIT
         select VIDEO_TVEEPROM
         select VIDEOBUF_VMALLOC
diff --git a/drivers/media/video/au0828/au0828-i2c.c b/drivers/media/video/au0828/au0828-i2c.c
index cbdb65c34f21..05c299fa5d79 100644
--- a/drivers/media/video/au0828/au0828-i2c.c
+++ b/drivers/media/video/au0828/au0828-i2c.c
@@ -348,7 +348,7 @@ static void do_i2c_scan(char *name, struct i2c_client *c)
         }
 }
 
-/* init + register i2c algo-bit adapter */
+/* init + register i2c adapter */
 int au0828_i2c_register(struct au0828_dev *dev)
 {
         dprintk(1, "%s()\n", __func__);
diff --git a/drivers/media/video/bt8xx/bt848.h b/drivers/media/video/bt8xx/bt848.h
index 0bcd95303bb0..c37e6acffded 100644
--- a/drivers/media/video/bt8xx/bt848.h
+++ b/drivers/media/video/bt8xx/bt848.h
@@ -30,6 +30,10 @@
 #ifndef PCI_DEVICE_ID_BT849
 #define PCI_DEVICE_ID_BT849     0x351
 #endif
+#ifndef PCI_DEVICE_ID_FUSION879
+#define PCI_DEVICE_ID_FUSION879 0x36c
+#endif
+
 #ifndef PCI_DEVICE_ID_BT878
 #define PCI_DEVICE_ID_BT878     0x36e
 #endif
@@ -37,7 +41,6 @@
 #define PCI_DEVICE_ID_BT879     0x36f
 #endif
 
-
 /* Brooktree 848 registers */
 
 #define BT848_DSTATUS          0x000
diff --git a/drivers/media/video/bt8xx/bttv-cards.c b/drivers/media/video/bt8xx/bttv-cards.c
index 5939021d8eba..ff2933ab705f 100644
--- a/drivers/media/video/bt8xx/bttv-cards.c
+++ b/drivers/media/video/bt8xx/bttv-cards.c
@@ -80,6 +80,8 @@ static void phytec_muxsel(struct bttv *btv, unsigned int input);
 static void gv800s_muxsel(struct bttv *btv, unsigned int input);
 static void gv800s_init(struct bttv *btv);
 
+static void td3116_muxsel(struct bttv *btv, unsigned int input);
+
 static int terratec_active_radio_upgrade(struct bttv *btv);
 static int tea5757_read(struct bttv *btv);
 static int tea5757_write(struct bttv *btv, int value);
@@ -284,7 +286,8 @@ static struct CARD {
         { 0x10b42636, BTTV_BOARD_HAUPPAUGE878,  "STB ???" },
         { 0x217d6606, BTTV_BOARD_WINFAST2000,   "Leadtek WinFast TV 2000" },
         { 0xfff6f6ff, BTTV_BOARD_WINFAST2000,   "Leadtek WinFast TV 2000" },
-        { 0x03116000, BTTV_BOARD_SENSORAY311,   "Sensoray 311" },
+        { 0x03116000, BTTV_BOARD_SENSORAY311_611, "Sensoray 311" },
+        { 0x06116000, BTTV_BOARD_SENSORAY311_611, "Sensoray 611" },
         { 0x00790e11, BTTV_BOARD_WINDVR,        "Canopus WinDVR PCI" },
         { 0xa0fca1a0, BTTV_BOARD_ZOLTRIX,       "Face to Face Tvmax" },
         { 0x82b2aa6a, BTTV_BOARD_SIMUS_GVC1100, "SIMUS GVC1100" },
@@ -341,6 +344,7 @@ static struct CARD {
         { 0x15401835, BTTV_BOARD_PV183,         "Provideo PV183-6" },
         { 0x15401836, BTTV_BOARD_PV183,         "Provideo PV183-7" },
         { 0x15401837, BTTV_BOARD_PV183,         "Provideo PV183-8" },
+        { 0x3116f200, BTTV_BOARD_TVT_TD3116,    "Tongwei Video Technology TD-3116" },
 
         { 0, -1, NULL }
 };
@@ -1526,10 +1530,10 @@ struct tvcard bttv_tvcards[] = {
                         GPIO20,22,23: R30,R29,R28
                 */
         },
-        [BTTV_BOARD_SENSORAY311] = {
+        [BTTV_BOARD_SENSORAY311_611] = {
                 /* Clay Kunz <ckunz@mail.arc.nasa.gov> */
-                /* you must jumper JP5 for the card to work */
-                .name           = "Sensoray 311",
+                /* you must jumper JP5 for the 311 card (PC/104+) to work */
+                .name           = "Sensoray 311/611",
                 .video_inputs   = 5,
                 /* .audio_inputs= 0, */
                 .svhs           = 4,
@@ -2879,6 +2883,16 @@ struct tvcard bttv_tvcards[] = {
                 .tuner_type     = TUNER_ABSENT,
                 .tuner_addr     = ADDR_UNSET,
         },
+        [BTTV_BOARD_TVT_TD3116] = {
+                .name           = "Tongwei Video Technology TD-3116",
+                .video_inputs   = 16,
+                .gpiomask       = 0xc00ff,
+                .muxsel         = MUXSEL(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2),
+                .muxsel_hook    = td3116_muxsel,
+                .svhs           = NO_SVHS,
+                .pll            = PLL_28,
+                .tuner_type     = TUNER_ABSENT,
+        },
 };
 
 static const unsigned int bttv_num_tvcards = ARRAY_SIZE(bttv_tvcards);
@@ -3228,6 +3242,42 @@ static void geovision_muxsel(struct bttv *btv, unsigned int input)
         gpio_bits(0xf, inmux);
 }
 
+/*
+ * The TD3116 has 2 74HC4051 muxes wired to the MUX0 input of a bt878.
+ * The first 74HC4051 has the lower 8 inputs, the second one the higher 8.
+ * The muxes are controlled via a 74HC373 latch which is connected to
+ * GPIOs 0-7. GPIO 18 is connected to the LE signal of the latch.
+ * Q0 of the latch is connected to the Enable (~E) input of the first
+ * 74HC4051. Q1 - Q3 are connected to S0 - S2 of the same 74HC4051.
+ * Q4 - Q7 are connected to the second 74HC4051 in the same way.
+ */
+
+static void td3116_latch_value(struct bttv *btv, u32 value)
+{
+        gpio_bits((1<<18) | 0xff, value);
+        gpio_bits((1<<18) | 0xff, (1<<18) | value);
+        udelay(1);
+        gpio_bits((1<<18) | 0xff, value);
+}
+
+static void td3116_muxsel(struct bttv *btv, unsigned int input)
+{
+        u32 value;
+        u32 highbit;
+
+        highbit = (input & 0x8) >> 3 ;
+
+        /* Disable outputs and set value in the mux */
+        value = 0x11; /* Disable outputs */
+        value |= ((input & 0x7) << 1)  << (4 * highbit);
+        td3116_latch_value(btv, value);
+
+        /* Enable the correct output */
+        value &= ~0x11;
+        value |= ((highbit ^ 0x1) << 4) | highbit;
+        td3116_latch_value(btv, value);
+}
+
 /* ----------------------------------------------------------------------- */
 
 static void bttv_reset_audio(struct bttv *btv)
diff --git a/drivers/media/video/bt8xx/bttv-driver.c b/drivers/media/video/bt8xx/bttv-driver.c
index 3dd06607aec2..76c301f05095 100644
--- a/drivers/media/video/bt8xx/bttv-driver.c
+++ b/drivers/media/video/bt8xx/bttv-driver.c
@@ -4572,6 +4572,7 @@ static struct pci_device_id bttv_pci_tbl[] = {
         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
         {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
+        {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0},
         {0,}
 };
 
diff --git a/drivers/media/video/bt8xx/bttv-i2c.c b/drivers/media/video/bt8xx/bttv-i2c.c
index e3952af7e56e..580c8e682392 100644
--- a/drivers/media/video/bt8xx/bttv-i2c.c
+++ b/drivers/media/video/bt8xx/bttv-i2c.c
@@ -346,7 +346,7 @@ static void do_i2c_scan(char *name, struct i2c_client *c)
         }
 }
 
-/* init + register i2c algo-bit adapter */
+/* init + register i2c adapter */
 int __devinit init_bttv_i2c(struct bttv *btv)
 {
         strlcpy(btv->i2c_client.name, "bttv internal", I2C_NAME_SIZE);
diff --git a/drivers/media/video/bt8xx/bttv.h b/drivers/media/video/bt8xx/bttv.h
index c6333595c6b9..c5171619ac79 100644
--- a/drivers/media/video/bt8xx/bttv.h
+++ b/drivers/media/video/bt8xx/bttv.h
@@ -96,7 +96,7 @@
 #define BTTV_BOARD_PV_BT878P_PLUS          0x46
 #define BTTV_BOARD_FLYVIDEO98EZ            0x47
 #define BTTV_BOARD_PV_BT878P_9B            0x48
-#define BTTV_BOARD_SENSORAY311             0x49
+#define BTTV_BOARD_SENSORAY311_611         0x49
 #define BTTV_BOARD_RV605                   0x4a
 #define BTTV_BOARD_POWERCLR_MTV878         0x4b
 #define BTTV_BOARD_WINDVR                  0x4c
@@ -183,6 +183,7 @@
 #define BTTV_BOARD_GEOVISION_GV800S        0x9d
 #define BTTV_BOARD_GEOVISION_GV800S_SL     0x9e
 #define BTTV_BOARD_PV183                   0x9f
+#define BTTV_BOARD_TVT_TD3116              0xa0
 
 
 /* more card-specific defines */
diff --git a/drivers/media/video/cx18/cx18-i2c.c b/drivers/media/video/cx18/cx18-i2c.c
index 040aaa87579d..51609d5c88ce 100644
--- a/drivers/media/video/cx18/cx18-i2c.c
+++ b/drivers/media/video/cx18/cx18-i2c.c
@@ -232,7 +232,7 @@ static struct i2c_algo_bit_data cx18_i2c_algo_template = {
         .timeout        = CX18_ALGO_BIT_TIMEOUT*HZ /* jiffies */
 };
 
-/* init + register i2c algo-bit adapter */
+/* init + register i2c adapter */
 int init_cx18_i2c(struct cx18 *cx)
 {
         int i, err;
diff --git a/drivers/media/video/cx18/cx18-i2c.h b/drivers/media/video/cx18/cx18-i2c.h
index bdfd1921e300..1180fdc8d983 100644
--- a/drivers/media/video/cx18/cx18-i2c.h
+++ b/drivers/media/video/cx18/cx18-i2c.h
@@ -24,6 +24,6 @@
 int cx18_i2c_register(struct cx18 *cx, unsigned idx);
 struct v4l2_subdev *cx18_find_hw(struct cx18 *cx, u32 hw);
 
-/* init + register i2c algo-bit adapter */
+/* init + register i2c adapter */
 int init_cx18_i2c(struct cx18 *cx);
 void exit_cx18_i2c(struct cx18 *cx);
diff --git a/drivers/media/video/cx231xx/Kconfig b/drivers/media/video/cx231xx/Kconfig
index ae85a7a7bd73..446f692aabb7 100644
--- a/drivers/media/video/cx231xx/Kconfig
+++ b/drivers/media/video/cx231xx/Kconfig
@@ -40,10 +40,10 @@ config VIDEO_CX231XX_ALSA
 
 config VIDEO_CX231XX_DVB
         tristate "DVB/ATSC Support for Cx231xx based TV cards"
-        depends on VIDEO_CX231XX && DVB_CORE
+        depends on VIDEO_CX231XX && DVB_CORE && DVB_CAPTURE_DRIVERS
         select VIDEOBUF_DVB
-        select MEDIA_TUNER_XC5000 if !DVB_FE_CUSTOMISE
-        select MEDIA_TUNER_NXP18271 if !DVB_FE_CUSTOMISE
+        select MEDIA_TUNER_XC5000 if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_TDA18271 if !MEDIA_TUNER_CUSTOMISE
         select DVB_MB86A20S if !DVB_FE_CUSTOMISE
 
         ---help---
diff --git a/drivers/media/video/cx231xx/cx231xx-audio.c b/drivers/media/video/cx231xx/cx231xx-audio.c
index 30d13c15739a..a2c2b7d343ec 100644
--- a/drivers/media/video/cx231xx/cx231xx-audio.c
+++ b/drivers/media/video/cx231xx/cx231xx-audio.c
@@ -111,6 +111,9 @@ static void cx231xx_audio_isocirq(struct urb *urb)
         struct snd_pcm_substream *substream;
         struct snd_pcm_runtime *runtime;
 
+        if (dev->state & DEV_DISCONNECTED)
+                return;
+
         switch (urb->status) {
         case 0:         /* success */
         case -ETIMEDOUT:        /* NAK */
@@ -196,6 +199,9 @@ static void cx231xx_audio_bulkirq(struct urb *urb)
         struct snd_pcm_substream *substream;
         struct snd_pcm_runtime *runtime;
 
+        if (dev->state & DEV_DISCONNECTED)
+                return;
+
         switch (urb->status) {
         case 0:         /* success */
         case -ETIMEDOUT:        /* NAK */
@@ -273,6 +279,9 @@ static int cx231xx_init_audio_isoc(struct cx231xx *dev)
 
         cx231xx_info("%s: Starting ISO AUDIO transfers\n", __func__);
 
+        if (dev->state & DEV_DISCONNECTED)
+                return -ENODEV;
+
         sb_size = CX231XX_ISO_NUM_AUDIO_PACKETS * dev->adev.max_pkt_size;
 
         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
@@ -298,7 +307,7 @@ static int cx231xx_init_audio_isoc(struct cx231xx *dev)
                 urb->context = dev;
                 urb->pipe = usb_rcvisocpipe(dev->udev,
                                                 dev->adev.end_point_addr);
-                urb->transfer_flags = URB_ISO_ASAP;
+                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
                 urb->interval = 1;
                 urb->complete = cx231xx_audio_isocirq;
@@ -331,6 +340,9 @@ static int cx231xx_init_audio_bulk(struct cx231xx *dev)
 
         cx231xx_info("%s: Starting BULK AUDIO transfers\n", __func__);
 
+        if (dev->state & DEV_DISCONNECTED)
+                return -ENODEV;
+
         sb_size = CX231XX_NUM_AUDIO_PACKETS * dev->adev.max_pkt_size;
 
         for (i = 0; i < CX231XX_AUDIO_BUFS; i++) {
@@ -356,7 +368,7 @@ static int cx231xx_init_audio_bulk(struct cx231xx *dev)
                 urb->context = dev;
                 urb->pipe = usb_rcvbulkpipe(dev->udev,
                                                 dev->adev.end_point_addr);
-                urb->transfer_flags = 0;
+                urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
                 urb->complete = cx231xx_audio_bulkirq;
                 urb->transfer_buffer_length = sb_size;
@@ -432,6 +444,11 @@ static int snd_cx231xx_capture_open(struct snd_pcm_substream *substream)
                 return -ENODEV;
         }
 
+        if (dev->state & DEV_DISCONNECTED) {
+                cx231xx_errdev("Can't open. the device was removed.\n");
+                return -ENODEV;
+        }
+
         /* Sets volume, mute, etc */
         dev->mute = 0;
 
@@ -571,6 +588,9 @@ static int snd_cx231xx_capture_trigger(struct snd_pcm_substream *substream,
         struct cx231xx *dev = snd_pcm_substream_chip(substream);
         int retval;
 
+        if (dev->state & DEV_DISCONNECTED)
+                return -ENODEV;
+
         spin_lock(&dev->adev.slock);
         switch (cmd) {
         case SNDRV_PCM_TRIGGER_START:
diff --git a/drivers/media/video/cx231xx/cx231xx-cards.c b/drivers/media/video/cx231xx/cx231xx-cards.c
index 60b021e79864..919ed77b32f2 100644
--- a/drivers/media/video/cx231xx/cx231xx-cards.c
+++ b/drivers/media/video/cx231xx/cx231xx-cards.c
@@ -843,25 +843,34 @@ void cx231xx_release_resources(struct cx231xx *dev)
 
         cx231xx_remove_from_devlist(dev);
 
+        cx231xx_ir_exit(dev);
+
         /* Release I2C buses */
         cx231xx_dev_uninit(dev);
 
-        cx231xx_ir_exit(dev);
+        /* delete v4l2 device */
+        v4l2_device_unregister(&dev->v4l2_dev);
 
         usb_put_dev(dev->udev);
 
         /* Mark device as unused */
-        cx231xx_devused &= ~(1 << dev->devno);
+        clear_bit(dev->devno, &cx231xx_devused);
+
+        kfree(dev->video_mode.alt_max_pkt_size);
+        kfree(dev->vbi_mode.alt_max_pkt_size);
+        kfree(dev->sliced_cc_mode.alt_max_pkt_size);
+        kfree(dev->ts1_mode.alt_max_pkt_size);
+        kfree(dev);
+        dev = NULL;
 }
 
 /*
  * cx231xx_init_dev()
  * allocates and inits the device structs, registers i2c bus and v4l device
  */
-static int cx231xx_init_dev(struct cx231xx **devhandle, struct usb_device *udev,
+static int cx231xx_init_dev(struct cx231xx *dev, struct usb_device *udev,
                             int minor)
 {
-        struct cx231xx *dev = *devhandle;
         int retval = -ENOMEM;
         int errCode;
         unsigned int maxh, maxw;
@@ -1016,7 +1025,6 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         int i, isoc_pipe = 0;
         char *speed;
         char descr[255] = "";
-        struct usb_interface *lif = NULL;
         struct usb_interface_assoc_descriptor *assoc_desc;
 
         udev = usb_get_dev(interface_to_usbdev(interface));
@@ -1030,21 +1038,21 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
                 return -ENODEV;
 
         /* Check to see next free device and mark as used */
-        nr = find_first_zero_bit(&cx231xx_devused, CX231XX_MAXBOARDS);
-        cx231xx_devused |= 1 << nr;
-
-        if (nr >= CX231XX_MAXBOARDS) {
-                cx231xx_err(DRIVER_NAME
-                 ": Supports only %i cx231xx boards.\n", CX231XX_MAXBOARDS);
-                cx231xx_devused &= ~(1 << nr);
-                return -ENOMEM;
-        }
+        do {
+                nr = find_first_zero_bit(&cx231xx_devused, CX231XX_MAXBOARDS);
+                if (nr >= CX231XX_MAXBOARDS) {
+                        /* No free device slots */
+                        cx231xx_err(DRIVER_NAME ": Supports only %i devices.\n",
+                                        CX231XX_MAXBOARDS);
+                        return -ENOMEM;
+                }
+        } while (test_and_set_bit(nr, &cx231xx_devused));
 
         /* allocate memory for our device state and initialize it */
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (dev == NULL) {
                 cx231xx_err(DRIVER_NAME ": out of memory!\n");
-                cx231xx_devused &= ~(1 << nr);
+                clear_bit(dev->devno, &cx231xx_devused);
                 return -ENOMEM;
         }
 
@@ -1071,9 +1079,6 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
 
         /* init CIR module TBD */
 
-        /* store the current interface */
-        lif = interface;
-
         /*mode_tv: digital=1 or analog=0*/
         dev->mode_tv = 0;
 
@@ -1113,9 +1118,6 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
              le16_to_cpu(udev->descriptor.idProduct),
              dev->max_iad_interface_count);
 
-        /* store the interface 0 back */
-        lif = udev->actconfig->interface[0];
-
         /* increment interface count */
         dev->interface_count++;
 
@@ -1126,7 +1128,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         if (assoc_desc->bFirstInterface != ifnum) {
                 cx231xx_err(DRIVER_NAME ": Not found "
                             "matching IAD interface\n");
-                cx231xx_devused &= ~(1 << nr);
+                clear_bit(dev->devno, &cx231xx_devused);
                 kfree(dev);
                 dev = NULL;
                 return -ENODEV;
@@ -1135,7 +1137,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         cx231xx_info("registering interface %d\n", ifnum);
 
         /* save our data pointer in this interface device */
-        usb_set_intfdata(lif, dev);
+        usb_set_intfdata(interface, dev);
 
         /*
          * AV device initialization - only done at the last interface
@@ -1145,19 +1147,19 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
         retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
         if (retval) {
                 cx231xx_errdev("v4l2_device_register failed\n");
-                cx231xx_devused &= ~(1 << nr);
+                clear_bit(dev->devno, &cx231xx_devused);
                 kfree(dev);
                 dev = NULL;
                 return -EIO;
         }
         /* allocate device struct */
-        retval = cx231xx_init_dev(&dev, udev, nr);
+        retval = cx231xx_init_dev(dev, udev, nr);
         if (retval) {
-                cx231xx_devused &= ~(1 << dev->devno);
+                clear_bit(dev->devno, &cx231xx_devused);
                 v4l2_device_unregister(&dev->v4l2_dev);
                 kfree(dev);
                 dev = NULL;
-                usb_set_intfdata(lif, NULL);
+                usb_set_intfdata(interface, NULL);
 
                 return retval;
         }
@@ -1178,7 +1180,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
 
         if (dev->video_mode.alt_max_pkt_size == NULL) {
                 cx231xx_errdev("out of memory!\n");
-                cx231xx_devused &= ~(1 << nr);
+                clear_bit(dev->devno, &cx231xx_devused);
                 v4l2_device_unregister(&dev->v4l2_dev);
                 kfree(dev);
                 dev = NULL;
@@ -1212,7 +1214,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
 
         if (dev->vbi_mode.alt_max_pkt_size == NULL) {
                 cx231xx_errdev("out of memory!\n");
-                cx231xx_devused &= ~(1 << nr);
+                clear_bit(dev->devno, &cx231xx_devused);
                 v4l2_device_unregister(&dev->v4l2_dev);
                 kfree(dev);
                 dev = NULL;
@@ -1247,7 +1249,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
 
         if (dev->sliced_cc_mode.alt_max_pkt_size == NULL) {
                 cx231xx_errdev("out of memory!\n");
-                cx231xx_devused &= ~(1 << nr);
+                clear_bit(dev->devno, &cx231xx_devused);
                 v4l2_device_unregister(&dev->v4l2_dev);
                 kfree(dev);
                 dev = NULL;
@@ -1283,7 +1285,7 @@ static int cx231xx_usb_probe(struct usb_interface *interface,
 
                 if (dev->ts1_mode.alt_max_pkt_size == NULL) {
                         cx231xx_errdev("out of memory!\n");
-                        cx231xx_devused &= ~(1 << nr);
+                        clear_bit(dev->devno, &cx231xx_devused);
                         v4l2_device_unregister(&dev->v4l2_dev);
                         kfree(dev);
                         dev = NULL;
@@ -1334,10 +1336,9 @@ static void cx231xx_usb_disconnect(struct usb_interface *interface)
         if (!dev->udev)
                 return;
 
-        flush_request_modules(dev);
+        dev->state |= DEV_DISCONNECTED;
 
-        /* delete v4l2 device */
-        v4l2_device_unregister(&dev->v4l2_dev);
+        flush_request_modules(dev);
 
         /* wait until all current v4l2 io is finished then deallocate
            resources */
@@ -1351,31 +1352,24 @@ static void cx231xx_usb_disconnect(struct usb_interface *interface)
                      "deallocation are deferred on close.\n",
                      video_device_node_name(dev->vdev));
 
-                dev->state |= DEV_MISCONFIGURED;
+                /* Even having users, it is safe to remove the RC i2c driver */
+                cx231xx_ir_exit(dev);
+
                 if (dev->USE_ISO)
                         cx231xx_uninit_isoc(dev);
                 else
                         cx231xx_uninit_bulk(dev);
-                dev->state |= DEV_DISCONNECTED;
                 wake_up_interruptible(&dev->wait_frame);
                 wake_up_interruptible(&dev->wait_stream);
         } else {
-                dev->state |= DEV_DISCONNECTED;
-                cx231xx_release_resources(dev);
         }
 
         cx231xx_close_extension(dev);
 
         mutex_unlock(&dev->lock);
 
-        if (!dev->users) {
-                kfree(dev->video_mode.alt_max_pkt_size);
-                kfree(dev->vbi_mode.alt_max_pkt_size);
-                kfree(dev->sliced_cc_mode.alt_max_pkt_size);
-                kfree(dev->ts1_mode.alt_max_pkt_size);
-                kfree(dev);
-                dev = NULL;
-        }
+        if (!dev->users)
+                cx231xx_release_resources(dev);
 }
 
 static struct usb_driver cx231xx_usb_driver = {
diff --git a/drivers/media/video/cx231xx/cx231xx-core.c b/drivers/media/video/cx231xx/cx231xx-core.c
index d4457f9488ee..08dd930f882a 100644
--- a/drivers/media/video/cx231xx/cx231xx-core.c
+++ b/drivers/media/video/cx231xx/cx231xx-core.c
@@ -166,6 +166,9 @@ int cx231xx_send_usb_command(struct cx231xx_i2c *i2c_bus,
         u8 _i2c_nostop = 0;
         u8 _i2c_reserve = 0;
 
+        if (dev->state & DEV_DISCONNECTED)
+                return -ENODEV;
+
         /* Get the I2C period, nostop and reserve parameters */
         _i2c_period = i2c_bus->i2c_period;
         _i2c_nostop = i2c_bus->i2c_nostop;
@@ -1071,7 +1074,7 @@ int cx231xx_init_isoc(struct cx231xx *dev, int max_packets,
                                  sb_size, cx231xx_isoc_irq_callback, dma_q, 1);
 
                 urb->number_of_packets = max_packets;
-                urb->transfer_flags = URB_ISO_ASAP;
+                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 
                 k = 0;
                 for (j = 0; j < max_packets; j++) {
@@ -1182,7 +1185,7 @@ int cx231xx_init_bulk(struct cx231xx *dev, int max_packets,
                         return -ENOMEM;
                 }
                 dev->video_mode.bulk_ctl.urb[i] = urb;
-                urb->transfer_flags = 0;
+                urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 
                 dev->video_mode.bulk_ctl.transfer_buffer[i] =
                     usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL,
diff --git a/drivers/media/video/cx231xx/cx231xx-dvb.c b/drivers/media/video/cx231xx/cx231xx-dvb.c
index da9a4a0aab79..7c4e360ba9bc 100644
--- a/drivers/media/video/cx231xx/cx231xx-dvb.c
+++ b/drivers/media/video/cx231xx/cx231xx-dvb.c
@@ -196,7 +196,7 @@ static inline int dvb_isoc_copy(struct cx231xx *dev, struct urb *urb)
         if (!dev)
                 return 0;
 
-        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+        if (dev->state & DEV_DISCONNECTED)
                 return 0;
 
         if (urb->status < 0) {
@@ -228,7 +228,7 @@ static inline int dvb_bulk_copy(struct cx231xx *dev, struct urb *urb)
         if (!dev)
                 return 0;
 
-        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+        if (dev->state & DEV_DISCONNECTED)
                 return 0;
 
         if (urb->status < 0) {
diff --git a/drivers/media/video/cx231xx/cx231xx-input.c b/drivers/media/video/cx231xx/cx231xx-input.c
index 45e14cac4622..96176e9db5a2 100644
--- a/drivers/media/video/cx231xx/cx231xx-input.c
+++ b/drivers/media/video/cx231xx/cx231xx-input.c
@@ -27,12 +27,16 @@
 static int get_key_isdbt(struct IR_i2c *ir, u32 *ir_key,
                          u32 *ir_raw)
 {
+        int     rc;
         u8      cmd, scancode;
 
         dev_dbg(&ir->rc->input_dev->dev, "%s\n", __func__);
 
                 /* poll IR chip */
-        if (1 != i2c_master_recv(ir->c, &cmd, 1))
+        rc = i2c_master_recv(ir->c, &cmd, 1);
+        if (rc < 0)
+                return rc;
+        if (rc != 1)
                 return -EIO;
 
         /* it seems that 0xFE indicates that a button is still hold
@@ -102,11 +106,14 @@ int cx231xx_ir_init(struct cx231xx *dev)
         ir_i2c_bus = cx231xx_boards[dev->model].ir_i2c_master;
         dev_dbg(&dev->udev->dev, "Trying to bind ir at bus %d, addr 0x%02x\n",
                 ir_i2c_bus, info.addr);
-        i2c_new_device(&dev->i2c_bus[ir_i2c_bus].i2c_adap, &info);
+        dev->ir_i2c_client = i2c_new_device(&dev->i2c_bus[ir_i2c_bus].i2c_adap, &info);
 
         return 0;
 }
 
 void cx231xx_ir_exit(struct cx231xx *dev)
 {
+        if (dev->ir_i2c_client)
+                i2c_unregister_device(dev->ir_i2c_client);
+        dev->ir_i2c_client = NULL;
 }
diff --git a/drivers/media/video/cx231xx/cx231xx-vbi.c b/drivers/media/video/cx231xx/cx231xx-vbi.c
index 1c7a4daafecf..8cdee5f78f13 100644
--- a/drivers/media/video/cx231xx/cx231xx-vbi.c
+++ b/drivers/media/video/cx231xx/cx231xx-vbi.c
@@ -93,7 +93,7 @@ static inline int cx231xx_isoc_vbi_copy(struct cx231xx *dev, struct urb *urb)
         if (!dev)
                 return 0;
 
-        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+        if (dev->state & DEV_DISCONNECTED)
                 return 0;
 
         if (urb->status < 0) {
@@ -452,7 +452,7 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
                         return -ENOMEM;
                 }
                 dev->vbi_mode.bulk_ctl.urb[i] = urb;
-                urb->transfer_flags = 0;
+                urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 
                 dev->vbi_mode.bulk_ctl.transfer_buffer[i] =
                     kzalloc(sb_size, GFP_KERNEL);
diff --git a/drivers/media/video/cx231xx/cx231xx-video.c b/drivers/media/video/cx231xx/cx231xx-video.c
index 6e81f970dc7d..829a41b0c9ef 100644
--- a/drivers/media/video/cx231xx/cx231xx-video.c
+++ b/drivers/media/video/cx231xx/cx231xx-video.c
@@ -337,7 +337,7 @@ static inline int cx231xx_isoc_copy(struct cx231xx *dev, struct urb *urb)
         if (!dev)
                 return 0;
 
-        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+        if (dev->state & DEV_DISCONNECTED)
                 return 0;
 
         if (urb->status < 0) {
@@ -440,7 +440,7 @@ static inline int cx231xx_bulk_copy(struct cx231xx *dev, struct urb *urb)
         if (!dev)
                 return 0;
 
-        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+        if (dev->state & DEV_DISCONNECTED)
                 return 0;
 
         if (urb->status < 0) {
@@ -1000,12 +1000,6 @@ static int check_dev(struct cx231xx *dev)
                 cx231xx_errdev("v4l2 ioctl: device not present\n");
                 return -ENODEV;
         }
-
-        if (dev->state & DEV_MISCONFIGURED) {
-                cx231xx_errdev("v4l2 ioctl: device is misconfigured; "
-                               "close and open it again\n");
-                return -EIO;
-        }
         return 0;
 }
 
@@ -2347,7 +2341,8 @@ static int cx231xx_v4l2_close(struct file *filp)
                         return 0;
                 }
 
-        if (dev->users == 1) {
+        dev->users--;
+        if (!dev->users) {
                 videobuf_stop(&fh->vb_vidq);
                 videobuf_mmap_free(&fh->vb_vidq);
 
@@ -2374,7 +2369,6 @@ static int cx231xx_v4l2_close(struct file *filp)
                 cx231xx_set_alt_setting(dev, INDEX_VIDEO, 0);
         }
         kfree(fh);
-        dev->users--;
         wake_up_interruptible_nr(&dev->open, 1);
         return 0;
 }
diff --git a/drivers/media/video/cx231xx/cx231xx.h b/drivers/media/video/cx231xx/cx231xx.h
index 2000bc64c497..e17447554a0d 100644
--- a/drivers/media/video/cx231xx/cx231xx.h
+++ b/drivers/media/video/cx231xx/cx231xx.h
@@ -377,7 +377,6 @@ struct cx231xx_board {
 enum cx231xx_dev_state {
         DEV_INITIALIZED = 0x01,
         DEV_DISCONNECTED = 0x02,
-        DEV_MISCONFIGURED = 0x04,
 };
 
 enum AFE_MODE {
@@ -621,6 +620,7 @@ struct cx231xx {
 
         /* For I2C IR support */
         struct IR_i2c_init_data    init_data;
+        struct i2c_client          *ir_i2c_client;
 
         unsigned int stream_on:1;       /* Locks streams */
         unsigned int vbi_stream_on:1;   /* Locks streams for VBI */
diff --git a/drivers/media/video/cx23885/cx23885-417.c b/drivers/media/video/cx23885/cx23885-417.c
index 67c4a59bd882..f5c79e53e5a1 100644
--- a/drivers/media/video/cx23885/cx23885-417.c
+++ b/drivers/media/video/cx23885/cx23885-417.c
@@ -900,6 +900,7 @@ static int cx23885_load_firmware(struct cx23885_dev *dev)
         int i, retval = 0;
         u32 value = 0;
         u32 gpio_output = 0;
+        u32 gpio_value;
         u32 checksum = 0;
         u32 *dataptr;
 
@@ -907,7 +908,7 @@ static int cx23885_load_firmware(struct cx23885_dev *dev)
 
         /* Save GPIO settings before reset of APU */
         retval |= mc417_memory_read(dev, 0x9020, &gpio_output);
-        retval |= mc417_memory_read(dev, 0x900C, &value);
+        retval |= mc417_memory_read(dev, 0x900C, &gpio_value);
 
         retval  = mc417_register_write(dev,
                 IVTV_REG_VPU, 0xFFFFFFED);
@@ -991,11 +992,18 @@ static int cx23885_load_firmware(struct cx23885_dev *dev)
 
         /* F/W power up disturbs the GPIOs, restore state */
         retval |= mc417_register_write(dev, 0x9020, gpio_output);
-        retval |= mc417_register_write(dev, 0x900C, value);
+        retval |= mc417_register_write(dev, 0x900C, gpio_value);
 
         retval |= mc417_register_read(dev, IVTV_REG_VPU, &value);
         retval |= mc417_register_write(dev, IVTV_REG_VPU, value & 0xFFFFFFE8);
 
+        /* Hardcoded GPIO's here */
+        retval |= mc417_register_write(dev, 0x9020, 0x4000);
+        retval |= mc417_register_write(dev, 0x900C, 0x4000);
+
+        mc417_register_read(dev, 0x9020, &gpio_output);
+        mc417_register_read(dev, 0x900C, &gpio_value);
+
         if (retval < 0)
                 printk(KERN_ERR "%s: Error with mc417_register_write\n",
                         __func__);
@@ -1015,6 +1023,12 @@ static void cx23885_codec_settings(struct cx23885_dev *dev)
 {
         dprintk(1, "%s()\n", __func__);
 
+        /* Dynamically change the height based on video standard */
+        if (dev->encodernorm.id & V4L2_STD_525_60)
+                dev->ts1.height = 480;
+        else
+                dev->ts1.height = 576;
+
         /* assign frame size */
         cx23885_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
                                 dev->ts1.height, dev->ts1.width);
@@ -1030,7 +1044,7 @@ static void cx23885_codec_settings(struct cx23885_dev *dev)
         cx23885_api_cmd(dev, CX2341X_ENC_MISC, 2, 0, 4, 1);
 }
 
-static int cx23885_initialize_codec(struct cx23885_dev *dev)
+static int cx23885_initialize_codec(struct cx23885_dev *dev, int startencoder)
 {
         int version;
         int retval;
@@ -1112,9 +1126,11 @@ static int cx23885_initialize_codec(struct cx23885_dev *dev)
         mc417_memory_write(dev, 2120, 0x00000080);
 
         /* start capturing to the host interface */
-        cx23885_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0,
-                CX23885_MPEG_CAPTURE, CX23885_RAW_BITS_NONE);
-        msleep(10);
+        if (startencoder) {
+                cx23885_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0,
+                        CX23885_MPEG_CAPTURE, CX23885_RAW_BITS_NONE);
+                msleep(10);
+        }
 
         return 0;
 }
@@ -1196,6 +1212,16 @@ static int cx23885_querymenu(struct cx23885_dev *dev,
                 cx2341x_ctrl_get_menu(&dev->mpeg_params, qmenu->id));
 }
 
+static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
+{
+        struct cx23885_fh  *fh  = file->private_data;
+        struct cx23885_dev *dev = fh->dev;
+
+        call_all(dev, core, g_std, id);
+
+        return 0;
+}
+
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *id)
 {
         struct cx23885_fh  *fh  = file->private_data;
@@ -1208,55 +1234,31 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *id)
         if (i == ARRAY_SIZE(cx23885_tvnorms))
                 return -EINVAL;
         dev->encodernorm = cx23885_tvnorms[i];
+
+        /* Have the drier core notify the subdevices */
+        mutex_lock(&dev->lock);
+        cx23885_set_tvnorm(dev, *id);
+        mutex_unlock(&dev->lock);
+
         return 0;
 }
 
 static int vidioc_enum_input(struct file *file, void *priv,
-                                struct v4l2_input *i)
+        struct v4l2_input *i)
 {
-        struct cx23885_fh  *fh  = file->private_data;
-        struct cx23885_dev *dev = fh->dev;
-        struct cx23885_input *input;
-        int n;
-
-        if (i->index >= 4)
-                return -EINVAL;
-
-        input = &cx23885_boards[dev->board].input[i->index];
-
-        if (input->type == 0)
-                return -EINVAL;
-
-        /* FIXME
-         * strcpy(i->name, input->name); */
-        strcpy(i->name, "unset");
-
-        if (input->type == CX23885_VMUX_TELEVISION ||
-            input->type == CX23885_VMUX_CABLE)
-                i->type = V4L2_INPUT_TYPE_TUNER;
-        else
-                i->type  = V4L2_INPUT_TYPE_CAMERA;
-
-        for (n = 0; n < ARRAY_SIZE(cx23885_tvnorms); n++)
-                i->std |= cx23885_tvnorms[n].id;
-        return 0;
+        struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
+        dprintk(1, "%s()\n", __func__);
+        return cx23885_enum_input(dev, i);
 }
 
 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 {
-        struct cx23885_fh  *fh  = file->private_data;
-        struct cx23885_dev *dev = fh->dev;
-
-        *i = dev->input;
-        return 0;
+        return cx23885_get_input(file, priv, i);
 }
 
 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 {
-        if (i >= 4)
-                return -EINVAL;
-
-        return 0;
+        return cx23885_set_input(file, priv, i);
 }
 
 static int vidioc_g_tuner(struct file *file, void *priv,
@@ -1309,43 +1311,25 @@ static int vidioc_g_frequency(struct file *file, void *priv,
 }
 
 static int vidioc_s_frequency(struct file *file, void *priv,
-                                struct v4l2_frequency *f)
+        struct v4l2_frequency *f)
 {
-        struct cx23885_fh  *fh  = file->private_data;
-        struct cx23885_dev *dev = fh->dev;
-
-        cx23885_api_cmd(fh->dev, CX2341X_ENC_STOP_CAPTURE, 3, 0,
-                CX23885_END_NOW, CX23885_MPEG_CAPTURE,
-                CX23885_RAW_BITS_NONE);
-
-        dprintk(1, "VIDIOC_S_FREQUENCY: dev type %d, f\n",
-                dev->tuner_type);
-        dprintk(1, "VIDIOC_S_FREQUENCY: f tuner %d, f type %d\n",
-                f->tuner, f->type);
-        if (UNSET == dev->tuner_type)
-                return -EINVAL;
-        if (f->tuner != 0)
-                return -EINVAL;
-        if (f->type != V4L2_TUNER_ANALOG_TV)
-                return -EINVAL;
-        dev->freq = f->frequency;
-
-        call_all(dev, tuner, s_frequency, f);
+        return cx23885_set_frequency(file, priv, f);
+}
 
-        cx23885_initialize_codec(dev);
+static int vidioc_g_ctrl(struct file *file, void *priv,
+        struct v4l2_control *ctl)
+{
+        struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 
-        return 0;
+        return cx23885_get_control(dev, ctl);
 }
 
 static int vidioc_s_ctrl(struct file *file, void *priv,
-                                struct v4l2_control *ctl)
+        struct v4l2_control *ctl)
 {
-        struct cx23885_fh  *fh  = file->private_data;
-        struct cx23885_dev *dev = fh->dev;
+        struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 
-        /* Update the A/V core */
-        call_all(dev, core, s_ctrl, ctl);
-        return 0;
+        return cx23885_set_control(dev, ctl);
 }
 
 static int vidioc_querycap(struct file *file, void  *priv,
@@ -1636,7 +1620,7 @@ static ssize_t mpeg_read(struct file *file, char __user *data,
         /* Start mpeg encoder on first read. */
         if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
                 if (atomic_inc_return(&dev->v4l_reader_count) == 1) {
-                        if (cx23885_initialize_codec(dev) < 0)
+                        if (cx23885_initialize_codec(dev, 1) < 0)
                                 return -EINVAL;
                 }
         }
@@ -1677,6 +1661,8 @@ static struct v4l2_file_operations mpeg_fops = {
 };
 
 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
+        .vidioc_querystd         = vidioc_g_std,
+        .vidioc_g_std            = vidioc_g_std,
         .vidioc_s_std            = vidioc_s_std,
         .vidioc_enum_input       = vidioc_enum_input,
         .vidioc_g_input          = vidioc_g_input,
@@ -1686,6 +1672,7 @@ static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
         .vidioc_g_frequency      = vidioc_g_frequency,
         .vidioc_s_frequency      = vidioc_s_frequency,
         .vidioc_s_ctrl           = vidioc_s_ctrl,
+        .vidioc_g_ctrl           = vidioc_g_ctrl,
         .vidioc_querycap         = vidioc_querycap,
         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
         .vidioc_g_fmt_vid_cap    = vidioc_g_fmt_vid_cap,
@@ -1746,8 +1733,8 @@ static struct video_device *cx23885_video_dev_alloc(
         if (NULL == vfd)
                 return NULL;
         *vfd = *template;
-        snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
-                type, cx23885_boards[tsport->dev->board].name);
+        snprintf(vfd->name, sizeof(vfd->name), "%s (%s)",
+                cx23885_boards[tsport->dev->board].name, type);
         vfd->parent  = &pci->dev;
         vfd->release = video_device_release;
         return vfd;
@@ -1791,5 +1778,11 @@ int cx23885_417_register(struct cx23885_dev *dev)
         printk(KERN_INFO "%s: registered device %s [mpeg]\n",
                dev->name, video_device_node_name(dev->v4l_device));
 
+        /* ST: Configure the encoder paramaters, but don't begin
+         * encoding, this resolves an issue where the first time the
+         * encoder is started video can be choppy.
+         */
+        cx23885_initialize_codec(dev, 0);
+
         return 0;
 }
diff --git a/drivers/media/video/cx23885/cx23885-cards.c b/drivers/media/video/cx23885/cx23885-cards.c
index c3cf08945e4c..3c01be999e35 100644
--- a/drivers/media/video/cx23885/cx23885-cards.c
+++ b/drivers/media/video/cx23885/cx23885-cards.c
@@ -335,8 +335,33 @@ struct cx23885_board cx23885_boards[] = {
         },
         [CX23885_BOARD_HAUPPAUGE_HVR1850] = {
                 .name           = "Hauppauge WinTV-HVR1850",
+                .porta          = CX23885_ANALOG_VIDEO,
                 .portb          = CX23885_MPEG_ENCODER,
                 .portc          = CX23885_MPEG_DVB,
+                .tuner_type     = TUNER_ABSENT,
+                .tuner_addr     = 0x42, /* 0x84 >> 1 */
+                .force_bff      = 1,
+                .input          = {{
+                        .type   = CX23885_VMUX_TELEVISION,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN5_CH2 |
+                                        CX25840_VIN2_CH1 |
+                                        CX25840_DIF_ON,
+                        .amux   = CX25840_AUDIO8,
+                }, {
+                        .type   = CX23885_VMUX_COMPOSITE1,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN6_CH1,
+                        .amux   = CX25840_AUDIO7,
+                }, {
+                        .type   = CX23885_VMUX_SVIDEO,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN8_CH1 |
+                                        CX25840_SVIDEO_ON,
+                        .amux   = CX25840_AUDIO7,
+                } },
         },
         [CX23885_BOARD_COMPRO_VIDEOMATE_E800] = {
                 .name           = "Compro VideoMate E800",
@@ -438,6 +463,41 @@ struct cx23885_board cx23885_boards[] = {
                         .gpio0  = 0,
                 } },
         },
+        [CX23885_BOARD_MYGICA_X8507] = {
+                .name           = "Mygica X8507",
+                .tuner_type = TUNER_XC5000,
+                .tuner_addr = 0x61,
+                .tuner_bus      = 1,
+                .porta          = CX23885_ANALOG_VIDEO,
+                .input          = {
+                        {
+                                .type   = CX23885_VMUX_TELEVISION,
+                                .vmux   = CX25840_COMPOSITE2,
+                                .amux   = CX25840_AUDIO8,
+                        },
+                        {
+                                .type   = CX23885_VMUX_COMPOSITE1,
+                                .vmux   = CX25840_COMPOSITE8,
+                        },
+                        {
+                                .type   = CX23885_VMUX_SVIDEO,
+                                .vmux   = CX25840_SVIDEO_LUMA3 |
+                                                CX25840_SVIDEO_CHROMA4,
+                        },
+                        {
+                                .type   = CX23885_VMUX_COMPONENT,
+                                .vmux   = CX25840_COMPONENT_ON |
+                                        CX25840_VIN1_CH1 |
+                                        CX25840_VIN6_CH2 |
+                                        CX25840_VIN7_CH3,
+                        },
+                },
+        },
+        [CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL] = {
+                .name           = "TerraTec Cinergy T PCIe Dual",
+                .portb          = CX23885_MPEG_DVB,
+                .portc          = CX23885_MPEG_DVB,
+        }
 };
 const unsigned int cx23885_bcount = ARRAY_SIZE(cx23885_boards);
 
@@ -637,6 +697,14 @@ struct cx23885_subid cx23885_subids[] = {
                 .subvendor = 0x1b55,
                 .subdevice = 0xe2e4,
                 .card      = CX23885_BOARD_NETUP_DUAL_DVB_T_C_CI_RF,
+        }, {
+                .subvendor = 0x14f1,
+                .subdevice = 0x8502,
+                .card      = CX23885_BOARD_MYGICA_X8507,
+        }, {
+                .subvendor = 0x153b,
+                .subdevice = 0x117e,
+                .card      = CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL,
         },
 };
 const unsigned int cx23885_idcount = ARRAY_SIZE(cx23885_subids);
@@ -1068,6 +1136,7 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
                 break;
         case CX23885_BOARD_MYGICA_X8506:
         case CX23885_BOARD_MAGICPRO_PROHDTVE2:
+        case CX23885_BOARD_MYGICA_X8507:
                 /* GPIO-0 (0)Analog / (1)Digital TV */
                 /* GPIO-1 reset XC5000 */
                 /* GPIO-2 reset LGS8GL5 / LGS8G75 */
@@ -1367,6 +1436,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
                 ts1->ts_clk_en_val = 0x1; /* Enable TS_CLK */
                 ts1->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
                 break;
+        case CX23885_BOARD_HAUPPAUGE_HVR1850:
         case CX23885_BOARD_HAUPPAUGE_HVR1800:
                 /* Defaults for VID B - Analog encoder */
                 /* DREQ_POL, SMODE, PUNC_CLK, MCLK_POL Serial bus + punc clk */
@@ -1377,6 +1447,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
                 /* APB_TSVALERR_POL (active low)*/
                 ts1->vld_misc_val    = 0x2000;
                 ts1->hw_sop_ctrl_val = (0x47 << 16 | 188 << 4 | 0xc);
+                cx_write(0x130184, 0xc);
 
                 /* Defaults for VID C */
                 ts2->gen_ctrl_val  = 0xc; /* Serial bus + punctured clock */
@@ -1396,6 +1467,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
                 break;
         case CX23885_BOARD_NETUP_DUAL_DVBS2_CI:
         case CX23885_BOARD_NETUP_DUAL_DVB_T_C_CI_RF:
+        case CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL:
                 ts1->gen_ctrl_val  = 0xc; /* Serial bus + punctured clock */
                 ts1->ts_clk_en_val = 0x1; /* Enable TS_CLK */
                 ts1->src_sel_val   = CX23885_SRC_SEL_PARALLEL_MPEG_VIDEO;
@@ -1431,7 +1503,6 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
-        case CX23885_BOARD_HAUPPAUGE_HVR1850:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
         case CX23885_BOARD_HAUPPAUGE_HVR1290:
         case CX23885_BOARD_GOTVIEW_X5_3D_HYBRID:
@@ -1468,6 +1539,8 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_GOTVIEW_X5_3D_HYBRID:
         case CX23885_BOARD_HAUPPAUGE_HVR1500:
         case CX23885_BOARD_MPX885:
+        case CX23885_BOARD_MYGICA_X8507:
+        case CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL:
                 dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
                                 &dev->i2c_bus[2].i2c_adap,
                                 "cx25840", 0x88 >> 1, NULL);
diff --git a/drivers/media/video/cx23885/cx23885-core.c b/drivers/media/video/cx23885/cx23885-core.c
index 40e68b22015e..6ad227029a0f 100644
--- a/drivers/media/video/cx23885/cx23885-core.c
+++ b/drivers/media/video/cx23885/cx23885-core.c
@@ -206,12 +206,12 @@ static struct sram_channel cx23887_sram_channels[] = {
                 .cnt2_reg       = DMA1_CNT2,
         },
         [SRAM_CH02] = {
-                .name           = "ch2",
-                .cmds_start     = 0x0,
-                .ctrl_start     = 0x0,
-                .cdt            = 0x0,
-                .fifo_start     = 0x0,
-                .fifo_size      = 0x0,
+                .name           = "VID A (VBI)",
+                .cmds_start     = 0x10050,
+                .ctrl_start     = 0x105F0,
+                .cdt            = 0x10810,
+                .fifo_start     = 0x3000,
+                .fifo_size      = 0x1000,
                 .ptr1_reg       = DMA2_PTR1,
                 .ptr2_reg       = DMA2_PTR2,
                 .cnt1_reg       = DMA2_CNT1,
@@ -266,12 +266,12 @@ static struct sram_channel cx23887_sram_channels[] = {
                 .cnt2_reg       = DMA5_CNT2,
         },
         [SRAM_CH07] = {
-                .name           = "ch7",
-                .cmds_start     = 0x0,
-                .ctrl_start     = 0x0,
-                .cdt            = 0x0,
-                .fifo_start     = 0x0,
-                .fifo_size      = 0x0,
+                .name           = "TV Audio",
+                .cmds_start     = 0x10190,
+                .ctrl_start     = 0x106B0,
+                .cdt            = 0x10930,
+                .fifo_start     = 0x7000,
+                .fifo_size      = 0x1000,
                 .ptr1_reg       = DMA6_PTR1,
                 .ptr2_reg       = DMA6_PTR2,
                 .cnt1_reg       = DMA6_CNT1,
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index bcb45be44bb2..af8a225763d3 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -61,6 +61,8 @@
 #include "cx23885-f300.h"
 #include "altera-ci.h"
 #include "stv0367.h"
+#include "drxk.h"
+#include "mt2063.h"
 
 static unsigned int debug;
 
@@ -111,6 +113,8 @@ static void dvb_buf_release(struct videobuf_queue *q,
         cx23885_free_buffer(q, (struct cx23885_buffer *)vb);
 }
 
+static int cx23885_dvb_set_frontend(struct dvb_frontend *fe);
+
 static void cx23885_dvb_gate_ctrl(struct cx23885_tsport  *port, int open)
 {
         struct videobuf_dvb_frontends *f;
@@ -125,6 +129,12 @@ static void cx23885_dvb_gate_ctrl(struct cx23885_tsport  *port, int open)
 
         if (fe && fe->dvb.frontend && fe->dvb.frontend->ops.i2c_gate_ctrl)
                 fe->dvb.frontend->ops.i2c_gate_ctrl(fe->dvb.frontend, open);
+
+        /*
+         * FIXME: Improve this path to avoid calling the
+         * cx23885_dvb_set_frontend() every time it passes here.
+         */
+        cx23885_dvb_set_frontend(fe->dvb.frontend);
 }
 
 static struct videobuf_queue_ops dvb_qops = {
@@ -479,15 +489,15 @@ static struct xc5000_config mygica_x8506_xc5000_config = {
         .if_khz = 5380,
 };
 
-static int cx23885_dvb_set_frontend(struct dvb_frontend *fe,
-                                    struct dvb_frontend_parameters *param)
+static int cx23885_dvb_set_frontend(struct dvb_frontend *fe)
 {
+        struct dtv_frontend_properties *p = &fe->dtv_property_cache;
         struct cx23885_tsport *port = fe->dvb->priv;
         struct cx23885_dev *dev = port->dev;
 
         switch (dev->board) {
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
-                switch (param->u.vsb.modulation) {
+                switch (p->modulation) {
                 case VSB_8:
                         cx23885_gpio_clear(dev, GPIO_5);
                         break;
@@ -507,31 +517,6 @@ static int cx23885_dvb_set_frontend(struct dvb_frontend *fe,
         return 0;
 }
 
-static int cx23885_dvb_fe_ioctl_override(struct dvb_frontend *fe,
-                                         unsigned int cmd, void *parg,
-                                         unsigned int stage)
-{
-        int err = 0;
-
-        switch (stage) {
-        case DVB_FE_IOCTL_PRE:
-
-                switch (cmd) {
-                case FE_SET_FRONTEND:
-                        err = cx23885_dvb_set_frontend(fe,
-                                (struct dvb_frontend_parameters *) parg);
-                        break;
-                }
-                break;
-
-        case DVB_FE_IOCTL_POST:
-                /* no post-ioctl handling required */
-                break;
-        }
-        return err;
-};
-
-
 static struct lgs8gxx_config magicpro_prohdtve2_lgs8g75_config = {
         .prod = LGS8GXX_PROD_LGS8G75,
         .demod_address = 0x19,
@@ -617,6 +602,24 @@ static struct xc5000_config netup_xc5000_config[] = {
         },
 };
 
+static struct drxk_config terratec_drxk_config[] = {
+        {
+                .adr = 0x29,
+                .no_i2c_bridge = 1,
+        }, {
+                .adr = 0x2a,
+                .no_i2c_bridge = 1,
+        },
+};
+
+static struct mt2063_config terratec_mt2063_config[] = {
+        {
+                .tuner_address = 0x60,
+        }, {
+                .tuner_address = 0x67,
+        },
+};
+
 int netup_altera_fpga_rw(void *device, int flag, int data, int read)
 {
         struct cx23885_dev *dev = (struct cx23885_dev *)device;
@@ -1043,6 +1046,20 @@ static int dvb_register(struct cx23885_tsport *port)
                 }
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
+                i2c_bus = &dev->i2c_bus[0];
+                fe0->dvb.frontend = dvb_attach(s5h1411_attach,
+                        &hcw_s5h1411_config,
+                        &i2c_bus->i2c_adap);
+                if (fe0->dvb.frontend != NULL)
+                        dvb_attach(tda18271_attach, fe0->dvb.frontend,
+                                0x60, &dev->i2c_bus[0].i2c_adap,
+                                &hauppauge_tda18271_config);
+
+                tda18271_attach(&dev->ts1.analog_fe,
+                        0x60, &dev->i2c_bus[1].i2c_adap,
+                        &hauppauge_tda18271_config);
+
+                break;
         case CX23885_BOARD_HAUPPAUGE_HVR1290:
                 i2c_bus = &dev->i2c_bus[0];
                 fe0->dvb.frontend = dvb_attach(s5h1411_attach,
@@ -1118,6 +1135,39 @@ static int dvb_register(struct cx23885_tsport *port)
                                 goto frontend_detach;
                 }
                 break;
+        case CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL:
+                i2c_bus = &dev->i2c_bus[0];
+                i2c_bus2 = &dev->i2c_bus[1];
+
+                switch (port->nr) {
+                /* port b */
+                case 1:
+                        fe0->dvb.frontend = dvb_attach(drxk_attach,
+                                        &terratec_drxk_config[0],
+                                        &i2c_bus->i2c_adap);
+                        if (fe0->dvb.frontend != NULL) {
+                                if (!dvb_attach(mt2063_attach,
+                                                fe0->dvb.frontend,
+                                                &terratec_mt2063_config[0],
+                                                &i2c_bus2->i2c_adap))
+                                        goto frontend_detach;
+                        }
+                        break;
+                /* port c */
+                case 2:
+                        fe0->dvb.frontend = dvb_attach(drxk_attach,
+                                        &terratec_drxk_config[1],
+                                        &i2c_bus->i2c_adap);
+                        if (fe0->dvb.frontend != NULL) {
+                                if (!dvb_attach(mt2063_attach,
+                                                fe0->dvb.frontend,
+                                                &terratec_mt2063_config[1],
+                                                &i2c_bus2->i2c_adap))
+                                        goto frontend_detach;
+                        }
+                        break;
+                }
+                break;
         default:
                 printk(KERN_INFO "%s: The frontend of your DVB/ATSC card "
                         " isn't supported yet\n",
@@ -1151,7 +1201,7 @@ static int dvb_register(struct cx23885_tsport *port)
         /* register everything */
         ret = videobuf_dvb_register_bus(&port->frontends, THIS_MODULE, port,
                                         &dev->pci->dev, adapter_nr, mfe_shared,
-                                        cx23885_dvb_fe_ioctl_override);
+                                        NULL);
         if (ret)
                 goto frontend_detach;
 
diff --git a/drivers/media/video/cx23885/cx23885-i2c.c b/drivers/media/video/cx23885/cx23885-i2c.c
index 0ff7a9e98f3e..be1e21d8295c 100644
--- a/drivers/media/video/cx23885/cx23885-i2c.c
+++ b/drivers/media/video/cx23885/cx23885-i2c.c
@@ -309,7 +309,7 @@ static void do_i2c_scan(char *name, struct i2c_client *c)
         }
 }
 
-/* init + register i2c algo-bit adapter */
+/* init + register i2c adapter */
 int cx23885_i2c_register(struct cx23885_i2c *bus)
 {
         struct cx23885_dev *dev = bus->dev;
diff --git a/drivers/media/video/cx23885/cx23885-video.c b/drivers/media/video/cx23885/cx23885-video.c
index e730b9263016..4bbf9bb97bde 100644
--- a/drivers/media/video/cx23885/cx23885-video.c
+++ b/drivers/media/video/cx23885/cx23885-video.c
@@ -253,9 +253,9 @@ static struct cx23885_ctrl cx23885_ctls[] = {
                         .id            = V4L2_CID_AUDIO_VOLUME,
                         .name          = "Volume",
                         .minimum       = 0,
-                        .maximum       = 0x3f,
-                        .step          = 1,
-                        .default_value = 0x3f,
+                        .maximum       = 65535,
+                        .step          = 65535 / 100,
+                        .default_value = 65535,
                         .type          = V4L2_CTRL_TYPE_INTEGER,
                 },
                 .reg                   = PATH1_VOL_CTL,
@@ -316,7 +316,7 @@ void cx23885_video_wakeup(struct cx23885_dev *dev,
                         __func__, bc);
 }
 
-static int cx23885_set_tvnorm(struct cx23885_dev *dev, v4l2_std_id norm)
+int cx23885_set_tvnorm(struct cx23885_dev *dev, v4l2_std_id norm)
 {
         dprintk(1, "%s(norm = 0x%08x) name: [%s]\n",
                 __func__,
@@ -344,8 +344,8 @@ static struct video_device *cx23885_vdev_init(struct cx23885_dev *dev,
         *vfd = *template;
         vfd->v4l2_dev = &dev->v4l2_dev;
         vfd->release = video_device_release;
-        snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)",
-                 dev->name, type, cx23885_boards[dev->board].name);
+        snprintf(vfd->name, sizeof(vfd->name), "%s (%s)",
+                 cx23885_boards[dev->board].name, type);
         video_set_drvdata(vfd, dev);
         return vfd;
 }
@@ -492,7 +492,8 @@ static int cx23885_video_mux(struct cx23885_dev *dev, unsigned int input)
         dev->input = input;
 
         if (dev->board == CX23885_BOARD_MYGICA_X8506 ||
-                dev->board == CX23885_BOARD_MAGICPRO_PROHDTVE2) {
+                dev->board == CX23885_BOARD_MAGICPRO_PROHDTVE2 ||
+                dev->board == CX23885_BOARD_MYGICA_X8507) {
                 /* Select Analog TV */
                 if (INPUT(input)->type == CX23885_VMUX_TELEVISION)
                         cx23885_gpio_clear(dev, GPIO_0);
@@ -503,7 +504,8 @@ static int cx23885_video_mux(struct cx23885_dev *dev, unsigned int input)
                         INPUT(input)->vmux, 0, 0);
 
         if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1800) ||
-                (dev->board == CX23885_BOARD_MPX885)) {
+                (dev->board == CX23885_BOARD_MPX885) ||
+                (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850)) {
                 /* Configure audio routing */
                 v4l2_subdev_call(dev->sd_cx25840, audio, s_routing,
                         INPUT(input)->amux, 0, 0);
@@ -649,6 +651,7 @@ static int buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
         int rc, init_buffer = 0;
         u32 line0_offset, line1_offset;
         struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
+        int field_tff;
 
         BUG_ON(NULL == fh->fmt);
         if (fh->width  < 48 || fh->width  > norm_maxw(dev->tvnorm) ||
@@ -690,15 +693,25 @@ static int buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
                                          buf->bpl, 0, buf->vb.height);
                         break;
                 case V4L2_FIELD_INTERLACED:
-                        if (dev->tvnorm & V4L2_STD_NTSC) {
+                        if (dev->tvnorm & V4L2_STD_NTSC)
+                                /* NTSC or  */
+                                field_tff = 1;
+                        else
+                                field_tff = 0;
+
+                        if (cx23885_boards[dev->board].force_bff)
+                                /* PAL / SECAM OR 888 in NTSC MODE */
+                                field_tff = 0;
+
+                        if (field_tff) {
                                 /* cx25840 transmits NTSC bottom field first */
-                                dprintk(1, "%s() Creating NTSC risc\n",
+                                dprintk(1, "%s() Creating TFF/NTSC risc\n",
                                         __func__);
                                 line0_offset = buf->bpl;
                                 line1_offset = 0;
                         } else {
                                 /* All other formats are top field first */
-                                dprintk(1, "%s() Creating PAL/SECAM risc\n",
+                                dprintk(1, "%s() Creating BFF/PAL/SECAM risc\n",
                                         __func__);
                                 line0_offset = 0;
                                 line1_offset = buf->bpl;
@@ -981,6 +994,8 @@ static int video_release(struct file *file)
         }
 
         videobuf_mmap_free(&fh->vidq);
+        videobuf_mmap_free(&fh->vbiq);
+
         file->private_data = NULL;
         kfree(fh);
 
@@ -1002,7 +1017,7 @@ static int video_mmap(struct file *file, struct vm_area_struct *vma)
 /* ------------------------------------------------------------------ */
 /* VIDEO CTRL IOCTLS                                                  */
 
-static int cx23885_get_control(struct cx23885_dev *dev,
+int cx23885_get_control(struct cx23885_dev *dev,
         struct v4l2_control *ctl)
 {
         dprintk(1, "%s() calling cx25840(VIDIOC_G_CTRL)\n", __func__);
@@ -1010,7 +1025,7 @@ static int cx23885_get_control(struct cx23885_dev *dev,
         return 0;
 }
 
-static int cx23885_set_control(struct cx23885_dev *dev,
+int cx23885_set_control(struct cx23885_dev *dev,
         struct v4l2_control *ctl)
 {
         dprintk(1, "%s() calling cx25840(VIDIOC_S_CTRL)\n", __func__);
@@ -1229,6 +1244,16 @@ static int vidioc_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
         return 0;
 }
 
+static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
+{
+        struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
+        dprintk(1, "%s()\n", __func__);
+
+        call_all(dev, core, g_std, id);
+
+        return 0;
+}
+
 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *tvnorms)
 {
         struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
@@ -1241,7 +1266,7 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *tvnorms)
         return 0;
 }
 
-static int cx23885_enum_input(struct cx23885_dev *dev, struct v4l2_input *i)
+int cx23885_enum_input(struct cx23885_dev *dev, struct v4l2_input *i)
 {
         static const char *iname[] = {
                 [CX23885_VMUX_COMPOSITE1] = "Composite1",
@@ -1278,6 +1303,15 @@ static int cx23885_enum_input(struct cx23885_dev *dev, struct v4l2_input *i)
         if (INPUT(n)->type != CX23885_VMUX_TELEVISION)
                 i->audioset = 0x3;
 
+        if (dev->input == n) {
+                /* enum'd input matches our configured input.
+                 * Ask the video decoder to process the call
+                 * and give it an oppertunity to update the
+                 * status field.
+                 */
+                call_all(dev, video, g_input_status, &i->status);
+        }
+
         return 0;
 }
 
@@ -1289,7 +1323,7 @@ static int vidioc_enum_input(struct file *file, void *priv,
         return cx23885_enum_input(dev, i);
 }
 
-static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
+int cx23885_get_input(struct file *file, void *priv, unsigned int *i)
 {
         struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 
@@ -1298,7 +1332,12 @@ static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
         return 0;
 }
 
-static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
+static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
+{
+        return cx23885_get_input(file, priv, i);
+}
+
+int cx23885_set_input(struct file *file, void *priv, unsigned int i)
 {
         struct cx23885_dev *dev = ((struct cx23885_fh *)priv)->dev;
 
@@ -1322,6 +1361,11 @@ static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
         return 0;
 }
 
+static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
+{
+        return cx23885_set_input(file, priv, i);
+}
+
 static int vidioc_log_status(struct file *file, void *priv)
 {
         struct cx23885_fh  *fh  = priv;
@@ -1329,11 +1373,11 @@ static int vidioc_log_status(struct file *file, void *priv)
 
         printk(KERN_INFO
                 "%s/0: ============  START LOG STATUS  ============\n",
-               dev->name);
+                dev->name);
         call_all(dev, core, log_status);
         printk(KERN_INFO
                 "%s/0: =============  END LOG STATUS  =============\n",
-               dev->name);
+                dev->name);
         return 0;
 }
 
@@ -1471,6 +1515,8 @@ static int vidioc_g_frequency(struct file *file, void *priv,
 
 static int cx23885_set_freq(struct cx23885_dev *dev, struct v4l2_frequency *f)
 {
+        struct v4l2_control ctrl;
+
         if (unlikely(UNSET == dev->tuner_type))
                 return -EINVAL;
         if (unlikely(f->tuner != 0))
@@ -1479,29 +1525,102 @@ static int cx23885_set_freq(struct cx23885_dev *dev, struct v4l2_frequency *f)
         mutex_lock(&dev->lock);
         dev->freq = f->frequency;
 
+        /* I need to mute audio here */
+        ctrl.id = V4L2_CID_AUDIO_MUTE;
+        ctrl.value = 1;
+        cx23885_set_control(dev, &ctrl);
+
         call_all(dev, tuner, s_frequency, f);
 
         /* When changing channels it is required to reset TVAUDIO */
-        msleep(10);
+        msleep(100);
+
+        /* I need to unmute audio here */
+        ctrl.value = 0;
+        cx23885_set_control(dev, &ctrl);
 
         mutex_unlock(&dev->lock);
 
         return 0;
 }
 
-static int vidioc_s_frequency(struct file *file, void *priv,
-                                struct v4l2_frequency *f)
+static int cx23885_set_freq_via_ops(struct cx23885_dev *dev,
+        struct v4l2_frequency *f)
+{
+        struct v4l2_control ctrl;
+        struct videobuf_dvb_frontend *vfe;
+        struct dvb_frontend *fe;
+        int err = 0;
+
+        struct analog_parameters params = {
+                .mode      = V4L2_TUNER_ANALOG_TV,
+                .audmode   = V4L2_TUNER_MODE_STEREO,
+                .std       = dev->tvnorm,
+                .frequency = f->frequency
+        };
+
+        mutex_lock(&dev->lock);
+        dev->freq = f->frequency;
+
+        /* I need to mute audio here */
+        ctrl.id = V4L2_CID_AUDIO_MUTE;
+        ctrl.value = 1;
+        cx23885_set_control(dev, &ctrl);
+
+        /* If HVR1850 */
+        dprintk(1, "%s() frequency=%d tuner=%d std=0x%llx\n", __func__,
+                params.frequency, f->tuner, params.std);
+
+        vfe = videobuf_dvb_get_frontend(&dev->ts2.frontends, 1);
+        if (!vfe)
+                err = -EINVAL;
+
+        fe = vfe->dvb.frontend;
+
+        if (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850)
+                fe = &dev->ts1.analog_fe;
+
+        if (fe && fe->ops.tuner_ops.set_analog_params) {
+                call_all(dev, core, s_std, dev->tvnorm);
+                fe->ops.tuner_ops.set_analog_params(fe, &params);
+        }
+        else
+                printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
+
+        /* When changing channels it is required to reset TVAUDIO */
+        msleep(100);
+
+        /* I need to unmute audio here */
+        ctrl.value = 0;
+        cx23885_set_control(dev, &ctrl);
+
+        mutex_unlock(&dev->lock);
+
+        return 0;
+}
+
+int cx23885_set_frequency(struct file *file, void *priv,
+        struct v4l2_frequency *f)
 {
         struct cx23885_fh *fh = priv;
         struct cx23885_dev *dev = fh->dev;
+        int ret;
 
-        if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV))
-                return -EINVAL;
-        if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO))
-                return -EINVAL;
+        switch (dev->board) {
+        case CX23885_BOARD_HAUPPAUGE_HVR1850:
+                ret = cx23885_set_freq_via_ops(dev, f);
+                break;
+        default:
+                ret = cx23885_set_freq(dev, f);
+        }
 
-        return
-                cx23885_set_freq(dev, f);
+        return ret;
+}
+
+static int vidioc_s_frequency(struct file *file, void *priv,
+        struct v4l2_frequency *f)
+{
+        return cx23885_set_frequency(file, priv, f);
 }
 
 /* ----------------------------------------------------------- */
@@ -1613,6 +1732,8 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
         .vidioc_qbuf          = vidioc_qbuf,
         .vidioc_dqbuf         = vidioc_dqbuf,
         .vidioc_s_std         = vidioc_s_std,
+        .vidioc_g_std         = vidioc_g_std,
+        .vidioc_querystd      = vidioc_g_std,
         .vidioc_enum_input    = vidioc_enum_input,
         .vidioc_g_input       = vidioc_g_input,
         .vidioc_s_input       = vidioc_s_input,
diff --git a/drivers/media/video/cx23885/cx23885.h b/drivers/media/video/cx23885/cx23885.h
index b49036fe3ffd..f020f0568df4 100644
--- a/drivers/media/video/cx23885/cx23885.h
+++ b/drivers/media/video/cx23885/cx23885.h
@@ -87,6 +87,8 @@
 #define CX23885_BOARD_NETUP_DUAL_DVB_T_C_CI_RF 30
 #define CX23885_BOARD_LEADTEK_WINFAST_PXDVR3200_H_XC4000 31
 #define CX23885_BOARD_MPX885                   32
+#define CX23885_BOARD_MYGICA_X8507             33
+#define CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL 34
 
 #define GPIO_0 0x00000001
 #define GPIO_1 0x00000002
@@ -226,6 +228,8 @@ struct cx23885_board {
         u32                     clk_freq;
         struct cx23885_input    input[MAX_CX23885_INPUT];
         int                     ci_type; /* for NetUP */
+        /* Force bottom field first during DMA (888 workaround) */
+        u32                     force_bff;
 };
 
 struct cx23885_subid {
@@ -310,6 +314,9 @@ struct cx23885_tsport {
         u32                        num_frontends;
         void                (*gate_ctrl)(struct cx23885_tsport *port, int open);
         void                       *port_priv;
+
+        /* Workaround for a temp dvb_frontend that the tuner can attached to */
+        struct dvb_frontend analog_fe;
 };
 
 struct cx23885_kernel_ir {
@@ -574,6 +581,13 @@ extern void cx23885_video_unregister(struct cx23885_dev *dev);
 extern int cx23885_video_irq(struct cx23885_dev *dev, u32 status);
 extern void cx23885_video_wakeup(struct cx23885_dev *dev,
         struct cx23885_dmaqueue *q, u32 count);
+int cx23885_enum_input(struct cx23885_dev *dev, struct v4l2_input *i);
+int cx23885_set_input(struct file *file, void *priv, unsigned int i);
+int cx23885_get_input(struct file *file, void *priv, unsigned int *i);
+int cx23885_set_frequency(struct file *file, void *priv, struct v4l2_frequency *f);
+int cx23885_set_control(struct cx23885_dev *dev, struct v4l2_control *ctl);
+int cx23885_get_control(struct cx23885_dev *dev, struct v4l2_control *ctl);
+int cx23885_set_tvnorm(struct cx23885_dev *dev, v4l2_std_id norm);
 
 /* ----------------------------------------------------------- */
 /* cx23885-vbi.c                                               */
diff --git a/drivers/media/video/cx25821/cx25821-alsa.c b/drivers/media/video/cx25821/cx25821-alsa.c
index 58be4f3bb3cb..03cfac476b03 100644
--- a/drivers/media/video/cx25821/cx25821-alsa.c
+++ b/drivers/media/video/cx25821/cx25821-alsa.c
@@ -176,8 +176,7 @@ static int _cx25821_start_audio_dma(struct cx25821_audio_dev *chip)
 
         /* Set the input mode to 16-bit */
         tmp = cx_read(AUD_A_CFG);
-        cx_write(AUD_A_CFG,
-                 tmp | FLD_AUD_DST_PK_MODE | FLD_AUD_DST_ENABLE |
+        cx_write(AUD_A_CFG, tmp | FLD_AUD_DST_PK_MODE | FLD_AUD_DST_ENABLE |
                  FLD_AUD_CLK_ENABLE);
 
         /*
@@ -188,9 +187,8 @@ static int _cx25821_start_audio_dma(struct cx25821_audio_dev *chip)
         */
 
         /* Enables corresponding bits at AUD_INT_STAT */
-        cx_write(AUD_A_INT_MSK,
-                 FLD_AUD_DST_RISCI1 | FLD_AUD_DST_OF | FLD_AUD_DST_SYNC |
-                 FLD_AUD_DST_OPC_ERR);
+        cx_write(AUD_A_INT_MSK, FLD_AUD_DST_RISCI1 | FLD_AUD_DST_OF |
+                 FLD_AUD_DST_SYNC | FLD_AUD_DST_OPC_ERR);
 
         /* Clean any pending interrupt bits already set */
         cx_write(AUD_A_INT_STAT, ~0);
@@ -200,8 +198,8 @@ static int _cx25821_start_audio_dma(struct cx25821_audio_dev *chip)
 
         /* Turn on audio downstream fifo and risc enable 0x101 */
         tmp = cx_read(AUD_INT_DMA_CTL);
-        cx_set(AUD_INT_DMA_CTL,
-               tmp | (FLD_AUD_DST_A_RISC_EN | FLD_AUD_DST_A_FIFO_EN));
+        cx_set(AUD_INT_DMA_CTL, tmp |
+               (FLD_AUD_DST_A_RISC_EN | FLD_AUD_DST_A_FIFO_EN));
 
         mdelay(100);
         return 0;
@@ -220,9 +218,8 @@ static int _cx25821_stop_audio_dma(struct cx25821_audio_dev *chip)
 
         /* disable irqs */
         cx_clear(PCI_INT_MSK, PCI_MSK_AUD_INT);
-        cx_clear(AUD_A_INT_MSK,
-                 AUD_INT_OPC_ERR | AUD_INT_DN_SYNC | AUD_INT_DN_RISCI2 |
-                 AUD_INT_DN_RISCI1);
+        cx_clear(AUD_A_INT_MSK, AUD_INT_OPC_ERR | AUD_INT_DN_SYNC |
+                 AUD_INT_DN_RISCI2 | AUD_INT_DN_RISCI1);
 
         return 0;
 }
@@ -234,15 +231,15 @@ static int _cx25821_stop_audio_dma(struct cx25821_audio_dev *chip)
  */
 static char *cx25821_aud_irqs[32] = {
         "dn_risci1", "up_risci1", "rds_dn_risc1",       /* 0-2 */
-        NULL,                   /* reserved */
+        NULL,                                           /* reserved */
         "dn_risci2", "up_risci2", "rds_dn_risc2",       /* 4-6 */
-        NULL,                   /* reserved */
-        "dnf_of", "upf_uf", "rds_dnf_uf",       /* 8-10 */
-        NULL,                   /* reserved */
-        "dn_sync", "up_sync", "rds_dn_sync",    /* 12-14 */
-        NULL,                   /* reserved */
-        "opc_err", "par_err", "rip_err",        /* 16-18 */
-        "pci_abort", "ber_irq", "mchg_irq"      /* 19-21 */
+        NULL,                                           /* reserved */
+        "dnf_of", "upf_uf", "rds_dnf_uf",               /* 8-10 */
+        NULL,                                           /* reserved */
+        "dn_sync", "up_sync", "rds_dn_sync",            /* 12-14 */
+        NULL,                                           /* reserved */
+        "opc_err", "par_err", "rip_err",                /* 16-18 */
+        "pci_abort", "ber_irq", "mchg_irq"              /* 19-21 */
 };
 
 /*
@@ -258,10 +255,8 @@ static void cx25821_aud_irq(struct cx25821_audio_dev *chip, u32 status,
 
         cx_write(AUD_A_INT_STAT, status);
         if (debug > 1 || (status & mask & ~0xff))
-                cx25821_print_irqbits(dev->name, "irq aud",
-                                      cx25821_aud_irqs,
-                                      ARRAY_SIZE(cx25821_aud_irqs), status,
-                                      mask);
+                cx25821_print_irqbits(dev->name, "irq aud", cx25821_aud_irqs,
+                                ARRAY_SIZE(cx25821_aud_irqs), status, mask);
 
         /* risc op code error */
         if (status & AUD_INT_OPC_ERR) {
@@ -270,8 +265,7 @@ static void cx25821_aud_irq(struct cx25821_audio_dev *chip, u32 status,
                 cx_clear(AUD_INT_DMA_CTL,
                          FLD_AUD_DST_A_RISC_EN | FLD_AUD_DST_A_FIFO_EN);
                 cx25821_sram_channel_dump_audio(dev,
-                                                &cx25821_sram_channels
-                                                [AUDIO_SRAM_CHANNEL]);
+                                &cx25821_sram_channels[AUDIO_SRAM_CHANNEL]);
         }
         if (status & AUD_INT_DN_SYNC) {
                 pr_warn("WARNING %s: Downstream sync error!\n", dev->name);
@@ -317,8 +311,9 @@ static irqreturn_t cx25821_irq(int irq, void *dev_id)
                                 cx25821_aud_irq(chip, audint_status,
                                                 audint_mask);
                                 break;
-                        } else
+                        } else {
                                 goto out;
+                        }
                 }
 
                 handled = 1;
@@ -361,9 +356,8 @@ static int dsp_buffer_free(struct cx25821_audio_dev *chip)
  */
 #define DEFAULT_FIFO_SIZE       384
 static struct snd_pcm_hardware snd_cx25821_digital_hw = {
-        .info = SNDRV_PCM_INFO_MMAP |
-            SNDRV_PCM_INFO_INTERLEAVED |
-            SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID,
+        .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID,
         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 
         .rates = SNDRV_PCM_RATE_48000,
@@ -396,8 +390,8 @@ static int snd_cx25821_pcm_open(struct snd_pcm_substream *substream)
                 return -ENODEV;
         }
 
-        err =
-            snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS);
+        err = snd_pcm_hw_constraint_pow2(runtime, 0,
+                                         SNDRV_PCM_HW_PARAM_PERIODS);
         if (err < 0)
                 goto _error;
 
@@ -468,8 +462,7 @@ static int snd_cx25821_hw_params(struct snd_pcm_substream *substream,
         dma = &buf->dma;
         videobuf_dma_init(dma);
         ret = videobuf_dma_init_kernel(dma, PCI_DMA_FROMDEVICE,
-                                       (PAGE_ALIGN(chip->dma_size) >>
-                                        PAGE_SHIFT));
+                        (PAGE_ALIGN(chip->dma_size) >> PAGE_SHIFT));
         if (ret < 0)
                 goto error;
 
@@ -477,10 +470,8 @@ static int snd_cx25821_hw_params(struct snd_pcm_substream *substream,
         if (ret < 0)
                 goto error;
 
-        ret =
-            cx25821_risc_databuffer_audio(chip->pci, &buf->risc, dma->sglist,
-                                          chip->period_size, chip->num_periods,
-                                          1);
+        ret = cx25821_risc_databuffer_audio(chip->pci, &buf->risc, dma->sglist,
+                        chip->period_size, chip->num_periods, 1);
         if (ret < 0) {
                 pr_info("DEBUG: ERROR after cx25821_risc_databuffer_audio()\n");
                 goto error;
@@ -686,7 +677,7 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev)
         }
 
         err = snd_card_create(index[devno], id[devno], THIS_MODULE,
-                         sizeof(struct cx25821_audio_dev), &card);
+                        sizeof(struct cx25821_audio_dev), &card);
         if (err < 0) {
                 pr_info("DEBUG ERROR: cannot create snd_card_new in %s\n",
                         __func__);
@@ -711,8 +702,8 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev)
                           IRQF_SHARED, chip->dev->name, chip);
 
         if (err < 0) {
-                pr_err("ERROR %s: can't get IRQ %d for ALSA\n",
-                       chip->dev->name, dev->pci->irq);
+                pr_err("ERROR %s: can't get IRQ %d for ALSA\n", chip->dev->name,
+                        dev->pci->irq);
                 goto error;
         }
 
@@ -730,8 +721,8 @@ static int cx25821_audio_initdev(struct cx25821_dev *dev)
                 chip->iobase, chip->irq);
         strcpy(card->mixername, "CX25821");
 
-        pr_info("%s/%i: ALSA support for cx25821 boards\n",
-                card->driver, devno);
+        pr_info("%s/%i: ALSA support for cx25821 boards\n", card->driver,
+                devno);
 
         err = snd_card_register(card);
         if (err < 0) {
diff --git a/drivers/media/video/cx25821/cx25821-audio-upstream.c b/drivers/media/video/cx25821/cx25821-audio-upstream.c
index c20d6dece154..20c7ca3351a8 100644
--- a/drivers/media/video/cx25821/cx25821-audio-upstream.c
+++ b/drivers/media/video/cx25821/cx25821-audio-upstream.c
@@ -107,7 +107,7 @@ static __le32 *cx25821_risc_field_upstream_audio(struct cx25821_dev *dev,
 {
         unsigned int line;
         struct sram_channel *sram_ch =
-           dev->channels[dev->_audio_upstream_channel].sram_channels;
+                dev->channels[dev->_audio_upstream_channel].sram_channels;
         int offset = 0;
 
         /* scan lines */
@@ -175,10 +175,8 @@ int cx25821_risc_buffer_upstream_audio(struct cx25821_dev *dev,
                 }
 
                 rp = cx25821_risc_field_upstream_audio(dev, rp,
-                                                       dev->
-                                                       _audiodata_buf_phys_addr
-                                                       + databuf_offset, bpl,
-                                                       fifo_enable);
+                                dev->_audiodata_buf_phys_addr + databuf_offset,
+                                bpl, fifo_enable);
 
                 if (USE_RISC_NOOP_AUDIO) {
                         for (i = 0; i < NUM_NO_OPS; i++)
@@ -193,7 +191,7 @@ int cx25821_risc_buffer_upstream_audio(struct cx25821_dev *dev,
 
                 /* Recalculate virtual address based on frame index */
                 rp = dev->_risc_virt_addr + RISC_SYNC_INSTRUCTION_SIZE / 4 +
-                    (AUDIO_RISC_DMA_BUF_SIZE * (frame + 1) / 4);
+                        (AUDIO_RISC_DMA_BUF_SIZE * (frame + 1) / 4);
         }
 
         return 0;
@@ -218,7 +216,7 @@ void cx25821_free_memory_audio(struct cx25821_dev *dev)
 void cx25821_stop_upstream_audio(struct cx25821_dev *dev)
 {
         struct sram_channel *sram_ch =
-           dev->channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B].sram_channels;
+                dev->channels[AUDIO_UPSTREAM_SRAM_CHANNEL_B].sram_channels;
         u32 tmp = 0;
 
         if (!dev->_audio_is_running) {
@@ -286,14 +284,14 @@ int cx25821_get_audio_data(struct cx25821_dev *dev,
         } else {
                 if (!(myfile->f_op)) {
                         pr_err("%s(): File has no file operations registered!\n",
-                               __func__);
+                                __func__);
                         filp_close(myfile, NULL);
                         return -EIO;
                 }
 
                 if (!myfile->f_op->read) {
                         pr_err("%s(): File has no READ operations registered!\n",
-                               __func__);
+                                __func__);
                         filp_close(myfile, NULL);
                         return -EIO;
                 }
@@ -305,14 +303,14 @@ int cx25821_get_audio_data(struct cx25821_dev *dev,
                 for (i = 0; i < dev->_audio_lines_count; i++) {
                         pos = file_offset;
 
-                        vfs_read_retval =
-                            vfs_read(myfile, mybuf, line_size, &pos);
+                        vfs_read_retval = vfs_read(myfile, mybuf, line_size,
+                                                                        &pos);
 
                         if (vfs_read_retval > 0 && vfs_read_retval == line_size
                             && dev->_audiodata_buf_virt_addr != NULL) {
                                 memcpy((void *)(dev->_audiodata_buf_virt_addr +
                                                 frame_offset / 4), mybuf,
-                                       vfs_read_retval);
+                                        vfs_read_retval);
                         }
 
                         file_offset += vfs_read_retval;
@@ -328,8 +326,8 @@ int cx25821_get_audio_data(struct cx25821_dev *dev,
                 if (i > 0)
                         dev->_audioframe_count++;
 
-                dev->_audiofile_status =
-                    (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
+                dev->_audiofile_status = (vfs_read_retval == line_size) ?
+                                                IN_PROGRESS : END_OF_FILE;
 
                 set_fs(old_fs);
                 filp_close(myfile, NULL);
@@ -340,12 +338,12 @@ int cx25821_get_audio_data(struct cx25821_dev *dev,
 
 static void cx25821_audioups_handler(struct work_struct *work)
 {
-        struct cx25821_dev *dev =
-            container_of(work, struct cx25821_dev, _audio_work_entry);
+        struct cx25821_dev *dev = container_of(work, struct cx25821_dev,
+                        _audio_work_entry);
 
         if (!dev) {
                 pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n",
-                       __func__);
+                        __func__);
                 return;
         }
 
@@ -370,19 +368,19 @@ int cx25821_openfile_audio(struct cx25821_dev *dev,
         if (IS_ERR(myfile)) {
                 const int open_errno = -PTR_ERR(myfile);
                 pr_err("%s(): ERROR opening file(%s) with errno = %d!\n",
-                       __func__, dev->_audiofilename, open_errno);
+                        __func__, dev->_audiofilename, open_errno);
                 return PTR_ERR(myfile);
         } else {
                 if (!(myfile->f_op)) {
                         pr_err("%s(): File has no file operations registered!\n",
-                               __func__);
+                                __func__);
                         filp_close(myfile, NULL);
                         return -EIO;
                 }
 
                 if (!myfile->f_op->read) {
                         pr_err("%s(): File has no READ operations registered!\n",
-                               __func__);
+                                __func__);
                         filp_close(myfile, NULL);
                         return -EIO;
                 }
@@ -395,12 +393,12 @@ int cx25821_openfile_audio(struct cx25821_dev *dev,
                         for (i = 0; i < dev->_audio_lines_count; i++) {
                                 pos = offset;
 
-                                vfs_read_retval =
-                                    vfs_read(myfile, mybuf, line_size, &pos);
+                                vfs_read_retval = vfs_read(myfile, mybuf,
+                                                line_size, &pos);
 
-                                if (vfs_read_retval > 0
-                                    && vfs_read_retval == line_size
-                                    && dev->_audiodata_buf_virt_addr != NULL) {
+                                if (vfs_read_retval > 0 &&
+                                    vfs_read_retval == line_size &&
+                                    dev->_audiodata_buf_virt_addr != NULL) {
                                         memcpy((void *)(dev->
                                                         _audiodata_buf_virt_addr
                                                         + offset / 4), mybuf,
@@ -423,8 +421,8 @@ int cx25821_openfile_audio(struct cx25821_dev *dev,
                                 break;
                 }
 
-                dev->_audiofile_status =
-                    (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
+                dev->_audiofile_status = (vfs_read_retval == line_size) ?
+                                                IN_PROGRESS : END_OF_FILE;
 
                 set_fs(old_fs);
                 myfile->f_pos = 0;
@@ -444,9 +442,8 @@ static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
 
         cx25821_free_memory_audio(dev);
 
-        dev->_risc_virt_addr =
-            pci_alloc_consistent(dev->pci, dev->audio_upstream_riscbuf_size,
-                                 &dma_addr);
+        dev->_risc_virt_addr = pci_alloc_consistent(dev->pci,
+                        dev->audio_upstream_riscbuf_size, &dma_addr);
         dev->_risc_virt_start_addr = dev->_risc_virt_addr;
         dev->_risc_phys_start_addr = dma_addr;
         dev->_risc_phys_addr = dma_addr;
@@ -454,22 +451,21 @@ static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
 
         if (!dev->_risc_virt_addr) {
                 printk(KERN_DEBUG
-                       pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning\n"));
+                        pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for RISC program! Returning\n"));
                 return -ENOMEM;
         }
         /* Clear out memory at address */
         memset(dev->_risc_virt_addr, 0, dev->_audiorisc_size);
 
         /* For Audio Data buffer allocation */
-        dev->_audiodata_buf_virt_addr =
-            pci_alloc_consistent(dev->pci, dev->audio_upstream_databuf_size,
-                                 &data_dma_addr);
+        dev->_audiodata_buf_virt_addr = pci_alloc_consistent(dev->pci,
+                        dev->audio_upstream_databuf_size, &data_dma_addr);
         dev->_audiodata_buf_phys_addr = data_dma_addr;
         dev->_audiodata_buf_size = dev->audio_upstream_databuf_size;
 
         if (!dev->_audiodata_buf_virt_addr) {
                 printk(KERN_DEBUG
-                       pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning\n"));
+                        pr_fmt("ERROR: pci_alloc_consistent() FAILED to allocate memory for data buffer! Returning\n"));
                 return -ENOMEM;
         }
         /* Clear out memory at address */
@@ -480,12 +476,11 @@ static int cx25821_audio_upstream_buffer_prepare(struct cx25821_dev *dev,
                 return ret;
 
         /* Creating RISC programs */
-        ret =
-            cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl,
-                                               dev->_audio_lines_count);
+        ret = cx25821_risc_buffer_upstream_audio(dev, dev->pci, bpl,
+                                                dev->_audio_lines_count);
         if (ret < 0) {
                 printk(KERN_DEBUG
-                       pr_fmt("ERROR creating audio upstream RISC programs!\n"));
+                        pr_fmt("ERROR creating audio upstream RISC programs!\n"));
                 goto error;
         }
 
@@ -533,9 +528,9 @@ int cx25821_audio_upstream_irq(struct cx25821_dev *dev, int chan_num,
 
                         if (dev->_risc_virt_start_addr != NULL) {
                                 risc_phys_jump_addr =
-                                    dev->_risc_phys_start_addr +
-                                    RISC_SYNC_INSTRUCTION_SIZE +
-                                    AUDIO_RISC_DMA_BUF_SIZE;
+                                        dev->_risc_phys_start_addr +
+                                        RISC_SYNC_INSTRUCTION_SIZE +
+                                        AUDIO_RISC_DMA_BUF_SIZE;
 
                                 rp = cx25821_risc_field_upstream_audio(dev,
                                                 dev->_risc_virt_start_addr + 1,
@@ -632,7 +627,7 @@ static void cx25821_wait_fifo_enable(struct cx25821_dev *dev,
                 /* 10 millisecond timeout */
                 if (count++ > 1000) {
                         pr_err("ERROR: %s() fifo is NOT turned on. Timeout!\n",
-                               __func__);
+                                __func__);
                         return;
                 }
 
@@ -661,9 +656,9 @@ int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev,
 
         /* Set the input mode to 16-bit */
         tmp = cx_read(sram_ch->aud_cfg);
-        tmp |=
-            FLD_AUD_SRC_ENABLE | FLD_AUD_DST_PK_MODE | FLD_AUD_CLK_ENABLE |
-            FLD_AUD_MASTER_MODE | FLD_AUD_CLK_SELECT_PLL_D | FLD_AUD_SONY_MODE;
+        tmp |= FLD_AUD_SRC_ENABLE | FLD_AUD_DST_PK_MODE | FLD_AUD_CLK_ENABLE |
+                FLD_AUD_MASTER_MODE | FLD_AUD_CLK_SELECT_PLL_D |
+                FLD_AUD_SONY_MODE;
         cx_write(sram_ch->aud_cfg, tmp);
 
         /* Read and write back the interrupt status register to clear it */
@@ -678,12 +673,11 @@ int cx25821_start_audio_dma_upstream(struct cx25821_dev *dev,
         tmp = cx_read(sram_ch->int_msk);
         cx_write(sram_ch->int_msk, tmp |= _intr_msk);
 
-        err =
-            request_irq(dev->pci->irq, cx25821_upstream_irq_audio,
+        err = request_irq(dev->pci->irq, cx25821_upstream_irq_audio,
                         IRQF_SHARED, dev->name, dev);
         if (err < 0) {
-                pr_err("%s: can't get upstream IRQ %d\n",
-                       dev->name, dev->pci->irq);
+                pr_err("%s: can't get upstream IRQ %d\n", dev->name,
+                                dev->pci->irq);
                 goto fail_irq;
         }
 
@@ -726,7 +720,7 @@ int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
 
         if (!dev->_irq_audio_queues) {
                 printk(KERN_DEBUG
-                       pr_fmt("ERROR: create_singlethread_workqueue() for Audio FAILED!\n"));
+                        pr_fmt("ERROR: create_singlethread_workqueue() for Audio FAILED!\n"));
                 return -ENOMEM;
         }
 
@@ -739,33 +733,30 @@ int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
 
         if (dev->input_audiofilename) {
                 str_length = strlen(dev->input_audiofilename);
-                dev->_audiofilename = kmalloc(str_length + 1, GFP_KERNEL);
+                dev->_audiofilename = kmemdup(dev->input_audiofilename,
+                                              str_length + 1, GFP_KERNEL);
 
                 if (!dev->_audiofilename)
                         goto error;
 
-                memcpy(dev->_audiofilename, dev->input_audiofilename,
-                       str_length + 1);
-
                 /* Default if filename is empty string */
                 if (strcmp(dev->input_audiofilename, "") == 0)
                         dev->_audiofilename = "/root/audioGOOD.wav";
         } else {
                 str_length = strlen(_defaultAudioName);
-                dev->_audiofilename = kmalloc(str_length + 1, GFP_KERNEL);
+                dev->_audiofilename = kmemdup(_defaultAudioName,
+                                              str_length + 1, GFP_KERNEL);
 
                 if (!dev->_audiofilename)
                         goto error;
-
-                memcpy(dev->_audiofilename, _defaultAudioName, str_length + 1);
         }
 
         retval = cx25821_sram_channel_setup_upstream_audio(dev, sram_ch,
                                                         _line_size, 0);
 
         dev->audio_upstream_riscbuf_size =
-            AUDIO_RISC_DMA_BUF_SIZE * NUM_AUDIO_PROGS +
-            RISC_SYNC_INSTRUCTION_SIZE;
+                AUDIO_RISC_DMA_BUF_SIZE * NUM_AUDIO_PROGS +
+                RISC_SYNC_INSTRUCTION_SIZE;
         dev->audio_upstream_databuf_size = AUDIO_DATA_BUF_SZ * NUM_AUDIO_PROGS;
 
         /* Allocating buffers and prepare RISC program */
@@ -773,7 +764,7 @@ int cx25821_audio_upstream_init(struct cx25821_dev *dev, int channel_select)
                                                         _line_size);
         if (retval < 0) {
                 pr_err("%s: Failed to set up Audio upstream buffers!\n",
-                       dev->name);
+                        dev->name);
                 goto error;
         }
         /* Start RISC engine */
diff --git a/drivers/media/video/cx25821/cx25821-audio.h b/drivers/media/video/cx25821/cx25821-audio.h
index 8eb55b7b88cb..1fc2d24f5110 100644
--- a/drivers/media/video/cx25821/cx25821-audio.h
+++ b/drivers/media/video/cx25821/cx25821-audio.h
@@ -23,39 +23,40 @@
 #ifndef __CX25821_AUDIO_H__
 #define __CX25821_AUDIO_H__
 
-#define USE_RISC_NOOP               1
-#define LINES_PER_BUFFER            15
-#define AUDIO_LINE_SIZE             128
+#define USE_RISC_NOOP           1
+#define LINES_PER_BUFFER        15
+#define AUDIO_LINE_SIZE         128
 
 /* Number of buffer programs to use at once. */
-#define NUMBER_OF_PROGRAMS  8
+#define NUMBER_OF_PROGRAMS      8
 
 /*
  * Max size of the RISC program for a buffer. - worst case is 2 writes per line
  * Space is also added for the 4 no-op instructions added on the end.
  */
 #ifndef USE_RISC_NOOP
-#define MAX_BUFFER_PROGRAM_SIZE     \
-        (2 * LINES_PER_BUFFER * RISC_WRITE_INSTRUCTION_SIZE + \
-        RISC_WRITECR_INSTRUCTION_SIZE * 4)
+#define MAX_BUFFER_PROGRAM_SIZE                                         \
+        (2 * LINES_PER_BUFFER * RISC_WRITE_INSTRUCTION_SIZE +           \
+         RISC_WRITECR_INSTRUCTION_SIZE * 4)
 #endif
 
 /* MAE 12 July 2005 Try to use NOOP RISC instruction instead */
 #ifdef USE_RISC_NOOP
-#define MAX_BUFFER_PROGRAM_SIZE     \
-        (2 * LINES_PER_BUFFER * RISC_WRITE_INSTRUCTION_SIZE + \
-        RISC_NOOP_INSTRUCTION_SIZE * 4)
+#define MAX_BUFFER_PROGRAM_SIZE                                         \
+        (2 * LINES_PER_BUFFER * RISC_WRITE_INSTRUCTION_SIZE +           \
+         RISC_NOOP_INSTRUCTION_SIZE * 4)
 #endif
 
 /* Sizes of various instructions in bytes.  Used when adding instructions. */
-#define RISC_WRITE_INSTRUCTION_SIZE 12
-#define RISC_JUMP_INSTRUCTION_SIZE  12
-#define RISC_SKIP_INSTRUCTION_SIZE  4
-#define RISC_SYNC_INSTRUCTION_SIZE  4
-#define RISC_WRITECR_INSTRUCTION_SIZE  16
-#define RISC_NOOP_INSTRUCTION_SIZE 4
-
-#define MAX_AUDIO_DMA_BUFFER_SIZE       \
-(MAX_BUFFER_PROGRAM_SIZE * NUMBER_OF_PROGRAMS + RISC_SYNC_INSTRUCTION_SIZE)
+#define RISC_WRITE_INSTRUCTION_SIZE     12
+#define RISC_JUMP_INSTRUCTION_SIZE      12
+#define RISC_SKIP_INSTRUCTION_SIZE      4
+#define RISC_SYNC_INSTRUCTION_SIZE      4
+#define RISC_WRITECR_INSTRUCTION_SIZE   16
+#define RISC_NOOP_INSTRUCTION_SIZE      4
+
+#define MAX_AUDIO_DMA_BUFFER_SIZE                                       \
+        (MAX_BUFFER_PROGRAM_SIZE * NUMBER_OF_PROGRAMS +                 \
+         RISC_SYNC_INSTRUCTION_SIZE)
 
 #endif
diff --git a/drivers/media/video/cx25821/cx25821-cards.c b/drivers/media/video/cx25821/cx25821-cards.c
index 6ace60313b49..99988c988095 100644
--- a/drivers/media/video/cx25821/cx25821-cards.c
+++ b/drivers/media/video/cx25821/cx25821-cards.c
@@ -67,6 +67,6 @@ void cx25821_card_setup(struct cx25821_dev *dev)
         if (dev->i2c_bus[0].i2c_rc == 0) {
                 dev->i2c_bus[0].i2c_client.addr = 0xa0 >> 1;
                 tveeprom_read(&dev->i2c_bus[0].i2c_client, eeprom,
-                              sizeof(eeprom));
+                                sizeof(eeprom));
         }
 }
diff --git a/drivers/media/video/cx25821/cx25821-core.c b/drivers/media/video/cx25821/cx25821-core.c
index a7fa38f9594e..f617474f9073 100644
--- a/drivers/media/video/cx25821/cx25821-core.c
+++ b/drivers/media/video/cx25821/cx25821-core.c
@@ -804,8 +804,8 @@ void cx25821_set_pixel_format(struct cx25821_dev *dev, int channel_select,
                               u32 format)
 {
         if (channel_select <= 7 && channel_select >= 0) {
-                cx_write(dev->channels[channel_select].
-                        sram_channels->pix_frmt, format);
+                cx_write(dev->channels[channel_select].sram_channels->pix_frmt,
+                                format);
                 dev->channels[channel_select].pixel_formats = format;
         }
 }
@@ -855,21 +855,19 @@ static void cx25821_initialize(struct cx25821_dev *dev)
         }
 
         cx25821_sram_channel_setup_audio(dev,
-                                dev->channels[SRAM_CH08].sram_channels,
-                                128, 0);
+                        dev->channels[SRAM_CH08].sram_channels, 128, 0);
 
         cx25821_gpio_init(dev);
 }
 
 static int cx25821_get_resources(struct cx25821_dev *dev)
 {
-        if (request_mem_region
-            (pci_resource_start(dev->pci, 0), pci_resource_len(dev->pci, 0),
-             dev->name))
+        if (request_mem_region(pci_resource_start(dev->pci, 0),
+                                pci_resource_len(dev->pci, 0), dev->name))
                 return 0;
 
         pr_err("%s: can't get MMIO memory @ 0x%llx\n",
-               dev->name, (unsigned long long)pci_resource_start(dev->pci, 0));
+                dev->name, (unsigned long long)pci_resource_start(dev->pci, 0));
 
         return -EBUSY;
 }
@@ -972,8 +970,7 @@ static int cx25821_dev_setup(struct cx25821_dev *dev)
         dev->lmmio = ioremap(dev->base_io_addr, pci_resource_len(dev->pci, 0));
 
         if (!dev->lmmio) {
-                CX25821_ERR
-                    ("ioremap failed, maybe increasing __VMALLOC_RESERVE in page.h\n");
+                CX25821_ERR("ioremap failed, maybe increasing __VMALLOC_RESERVE in page.h\n");
                 cx25821_iounmap(dev);
                 return -ENOMEM;
         }
@@ -994,7 +991,7 @@ static int cx25821_dev_setup(struct cx25821_dev *dev)
  *  cx25821_i2c_register(&dev->i2c_bus[2]); */
 
         CX25821_INFO("i2c register! bus->i2c_rc = %d\n",
-                     dev->i2c_bus[0].i2c_rc);
+                        dev->i2c_bus[0].i2c_rc);
 
         cx25821_card_setup(dev);
 
@@ -1004,9 +1001,8 @@ static int cx25821_dev_setup(struct cx25821_dev *dev)
         cx25821_video_register(dev);
 
         /* register IOCTL device */
-        dev->ioctl_dev =
-           cx25821_vdev_init(dev, dev->pci, &cx25821_videoioctl_template,
-                              "video");
+        dev->ioctl_dev = cx25821_vdev_init(dev, dev->pci,
+                        &cx25821_videoioctl_template, "video");
 
         if (video_register_device
             (dev->ioctl_dev, VFL_TYPE_GRABBER, VIDEO_IOCTL_CH) < 0) {
@@ -1103,16 +1099,15 @@ static __le32 *cx25821_risc_field(__le32 * rp, struct scatterlist *sglist,
                 }
                 if (bpl <= sg_dma_len(sg) - offset) {
                         /* fits into current chunk */
-                        *(rp++) =
-                            cpu_to_le32(RISC_WRITE | RISC_SOL | RISC_EOL | bpl);
+                        *(rp++) = cpu_to_le32(RISC_WRITE | RISC_SOL | RISC_EOL |
+                                        bpl);
                         *(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
                         *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                         offset += bpl;
                 } else {
                         /* scanline needs to be split */
                         todo = bpl;
-                        *(rp++) =
-                            cpu_to_le32(RISC_WRITE | RISC_SOL |
+                        *(rp++) = cpu_to_le32(RISC_WRITE | RISC_SOL |
                                         (sg_dma_len(sg) - offset));
                         *(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
                         *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
@@ -1120,8 +1115,8 @@ static __le32 *cx25821_risc_field(__le32 * rp, struct scatterlist *sglist,
                         offset = 0;
                         sg++;
                         while (todo > sg_dma_len(sg)) {
-                                *(rp++) =
-                                    cpu_to_le32(RISC_WRITE | sg_dma_len(sg));
+                                *(rp++) = cpu_to_le32(RISC_WRITE |
+                                                sg_dma_len(sg));
                                 *(rp++) = cpu_to_le32(sg_dma_address(sg));
                                 *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                                 todo -= sg_dma_len(sg);
@@ -1160,8 +1155,8 @@ int cx25821_risc_buffer(struct pci_dev *pci, struct btcx_riscmem *risc,
            can cause next bpl to start close to a page border.  First DMA
            region may be smaller than PAGE_SIZE */
         /* write and jump need and extra dword */
-        instructions =
-            fields * (1 + ((bpl + padding) * lines) / PAGE_SIZE + lines);
+        instructions = fields * (1 + ((bpl + padding) * lines) / PAGE_SIZE +
+                        lines);
         instructions += 2;
         rc = btcx_riscmem_alloc(pci, risc, instructions * 12);
 
@@ -1215,8 +1210,8 @@ static __le32 *cx25821_risc_field_audio(__le32 * rp, struct scatterlist *sglist,
 
                 if (bpl <= sg_dma_len(sg) - offset) {
                         /* fits into current chunk */
-                        *(rp++) =
-                            cpu_to_le32(RISC_WRITE | sol | RISC_EOL | bpl);
+                        *(rp++) = cpu_to_le32(RISC_WRITE | sol | RISC_EOL |
+                                        bpl);
                         *(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
                         *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                         offset += bpl;
@@ -1224,7 +1219,7 @@ static __le32 *cx25821_risc_field_audio(__le32 * rp, struct scatterlist *sglist,
                         /* scanline needs to be split */
                         todo = bpl;
                         *(rp++) = cpu_to_le32(RISC_WRITE | sol |
-                                              (sg_dma_len(sg) - offset));
+                                        (sg_dma_len(sg) - offset));
                         *(rp++) = cpu_to_le32(sg_dma_address(sg) + offset);
                         *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                         todo -= (sg_dma_len(sg) - offset);
@@ -1232,7 +1227,7 @@ static __le32 *cx25821_risc_field_audio(__le32 * rp, struct scatterlist *sglist,
                         sg++;
                         while (todo > sg_dma_len(sg)) {
                                 *(rp++) = cpu_to_le32(RISC_WRITE |
-                                                      sg_dma_len(sg));
+                                                sg_dma_len(sg));
                                 *(rp++) = cpu_to_le32(sg_dma_address(sg));
                                 *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
                                 todo -= sg_dma_len(sg);
@@ -1339,8 +1334,8 @@ static irqreturn_t cx25821_irq(int irq, void *dev_id)
                                 sram_channels->int_stat);
 
                         if (vid_status)
-                                handled +=
-                                cx25821_video_irq(dev, i, vid_status);
+                                handled += cx25821_video_irq(dev, i,
+                                                vid_status);
 
                         cx_write(PCI_INT_STAT, mask[i]);
                 }
@@ -1427,9 +1422,8 @@ static int __devinit cx25821_initdev(struct pci_dev *pci_dev,
                 goto fail_irq;
         }
 
-        err =
-            request_irq(pci_dev->irq, cx25821_irq, IRQF_SHARED,
-                        dev->name, dev);
+        err = request_irq(pci_dev->irq, cx25821_irq,
+                        IRQF_SHARED, dev->name, dev);
 
         if (err < 0) {
                 pr_err("%s: can't get IRQ %d\n", dev->name, pci_dev->irq);
@@ -1512,6 +1506,5 @@ static void __exit cx25821_fini(void)
         pci_unregister_driver(&cx25821_pci_driver);
 }
 
-
 module_init(cx25821_init);
 module_exit(cx25821_fini);
diff --git a/drivers/media/video/cx25821/cx25821-i2c.c b/drivers/media/video/cx25821/cx25821-i2c.c
index 4d3d0ce40785..12d7300fa1e9 100644
--- a/drivers/media/video/cx25821/cx25821-i2c.c
+++ b/drivers/media/video/cx25821/cx25821-i2c.c
@@ -252,8 +252,8 @@ static int i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
                 } else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
                            msgs[i].addr == msgs[i + 1].addr) {
                         /* write then read from same address */
-                        retval =
-                            i2c_sendbytes(i2c_adap, &msgs[i], msgs[i + 1].len);
+                        retval = i2c_sendbytes(i2c_adap, &msgs[i],
+                                        msgs[i + 1].len);
 
                         if (retval < 0)
                                 goto err;
@@ -276,10 +276,8 @@ err:
 
 static u32 cx25821_functionality(struct i2c_adapter *adap)
 {
-        return I2C_FUNC_SMBUS_EMUL |
-            I2C_FUNC_I2C |
-            I2C_FUNC_SMBUS_WORD_DATA |
-            I2C_FUNC_SMBUS_READ_WORD_DATA | I2C_FUNC_SMBUS_WRITE_WORD_DATA;
+        return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C | I2C_FUNC_SMBUS_WORD_DATA |
+                I2C_FUNC_SMBUS_READ_WORD_DATA | I2C_FUNC_SMBUS_WRITE_WORD_DATA;
 }
 
 static struct i2c_algorithm cx25821_i2c_algo_template = {
@@ -300,7 +298,7 @@ static struct i2c_client cx25821_i2c_client_template = {
         .name = "cx25821 internal",
 };
 
-/* init + register i2c algo-bit adapter */
+/* init + register i2c adapter */
 int cx25821_i2c_register(struct cx25821_i2c *bus)
 {
         struct cx25821_dev *dev = bus->dev;
diff --git a/drivers/media/video/cx25821/cx25821-medusa-defines.h b/drivers/media/video/cx25821/cx25821-medusa-defines.h
index 60d197f57556..7a9e6470ba22 100644
--- a/drivers/media/video/cx25821/cx25821-medusa-defines.h
+++ b/drivers/media/video/cx25821/cx25821-medusa-defines.h
@@ -23,7 +23,7 @@
 #ifndef _MEDUSA_DEF_H_
 #define _MEDUSA_DEF_H_
 
-/* Video deocder that we supported */
+/* Video decoder that we supported */
 #define VDEC_A          0
 #define VDEC_B          1
 #define VDEC_C          2
@@ -34,9 +34,9 @@
 #define VDEC_H          7
 
 /* end of display sequence */
-#define END_OF_SEQ                                      0xF;
+#define END_OF_SEQ      0xF;
 
 /* registry string size */
-#define MAX_REGISTRY_SZ                                 40;
+#define MAX_REGISTRY_SZ 40;
 
 #endif
diff --git a/drivers/media/video/cx25821/cx25821-medusa-reg.h b/drivers/media/video/cx25821/cx25821-medusa-reg.h
index 1c1c228352d1..c98ac946b277 100644
--- a/drivers/media/video/cx25821/cx25821-medusa-reg.h
+++ b/drivers/media/video/cx25821/cx25821-medusa-reg.h
@@ -28,22 +28,22 @@
 #define HOST_REGISTER2                          0x0001
 
 /* Chip Configuration Registers */
-#define CHIP_CTRL                                       0x0100
-#define AFE_AB_CTRL                                     0x0104
-#define AFE_CD_CTRL                                     0x0108
-#define AFE_EF_CTRL                                     0x010C
-#define AFE_GH_CTRL                                     0x0110
+#define CHIP_CTRL                               0x0100
+#define AFE_AB_CTRL                             0x0104
+#define AFE_CD_CTRL                             0x0108
+#define AFE_EF_CTRL                             0x010C
+#define AFE_GH_CTRL                             0x0110
 #define DENC_AB_CTRL                            0x0114
-#define BYP_AB_CTRL                                     0x0118
-#define MON_A_CTRL                                      0x011C
-#define DISP_SEQ_A                                      0x0120
-#define DISP_SEQ_B                                      0x0124
-#define DISP_AB_CNT                                     0x0128
-#define DISP_CD_CNT                                     0x012C
-#define DISP_EF_CNT                                     0x0130
-#define DISP_GH_CNT                                     0x0134
-#define DISP_IJ_CNT                                     0x0138
-#define PIN_OE_CTRL                                     0x013C
+#define BYP_AB_CTRL                             0x0118
+#define MON_A_CTRL                              0x011C
+#define DISP_SEQ_A                              0x0120
+#define DISP_SEQ_B                              0x0124
+#define DISP_AB_CNT                             0x0128
+#define DISP_CD_CNT                             0x012C
+#define DISP_EF_CNT                             0x0130
+#define DISP_GH_CNT                             0x0134
+#define DISP_IJ_CNT                             0x0138
+#define PIN_OE_CTRL                             0x013C
 #define PIN_SPD_CTRL                            0x0140
 #define PIN_SPD_CTRL2                           0x0144
 #define IRQ_STAT_CTRL                           0x0148
@@ -51,8 +51,8 @@
 #define POWER_CTRL_CD                           0x0150
 #define POWER_CTRL_EF                           0x0154
 #define POWER_CTRL_GH                           0x0158
-#define TUNE_CTRL                                       0x015C
-#define BIAS_CTRL                                       0x0160
+#define TUNE_CTRL                               0x015C
+#define BIAS_CTRL                               0x0160
 #define AFE_AB_DIAG_CTRL                        0x0164
 #define AFE_CD_DIAG_CTRL                        0x0168
 #define AFE_EF_DIAG_CTRL                        0x016C
@@ -61,17 +61,17 @@
 #define PLL_CD_DIAG_CTRL                        0x0178
 #define PLL_EF_DIAG_CTRL                        0x017C
 #define PLL_GH_DIAG_CTRL                        0x0180
-#define TEST_CTRL                                       0x0184
-#define BIST_STAT                                       0x0188
-#define BIST_STAT2                                      0x018C
-#define BIST_VID_PLL_AB_STAT            0x0190
-#define BIST_VID_PLL_CD_STAT            0x0194
-#define BIST_VID_PLL_EF_STAT            0x0198
-#define BIST_VID_PLL_GH_STAT            0x019C
+#define TEST_CTRL                               0x0184
+#define BIST_STAT                               0x0188
+#define BIST_STAT2                              0x018C
+#define BIST_VID_PLL_AB_STAT                    0x0190
+#define BIST_VID_PLL_CD_STAT                    0x0194
+#define BIST_VID_PLL_EF_STAT                    0x0198
+#define BIST_VID_PLL_GH_STAT                    0x019C
 #define DLL_DIAG_CTRL                           0x01A0
 #define DEV_CH_ID_CTRL                          0x01A4
 #define ABIST_CTRL_STATUS                       0x01A8
-#define ABIST_FREQ                                      0x01AC
+#define ABIST_FREQ                              0x01AC
 #define ABIST_GOERT_SHIFT                       0x01B0
 #define ABIST_COEF12                            0x01B4
 #define ABIST_COEF34                            0x01B8
@@ -92,357 +92,357 @@
 #define ABIST_CLAMP_E                           0x01F4
 #define ABIST_CLAMP_F                           0x01F8
 
-/*              Digital Video Encoder A Registers */
-#define DENC_A_REG_1                                    0x0200
-#define DENC_A_REG_2                                    0x0204
-#define DENC_A_REG_3                                    0x0208
-#define DENC_A_REG_4                                    0x020C
-#define DENC_A_REG_5                                    0x0210
-#define DENC_A_REG_6                                    0x0214
-#define DENC_A_REG_7                                    0x0218
-#define DENC_A_REG_8                                    0x021C
+/* Digital Video Encoder A Registers */
+#define DENC_A_REG_1                            0x0200
+#define DENC_A_REG_2                            0x0204
+#define DENC_A_REG_3                            0x0208
+#define DENC_A_REG_4                            0x020C
+#define DENC_A_REG_5                            0x0210
+#define DENC_A_REG_6                            0x0214
+#define DENC_A_REG_7                            0x0218
+#define DENC_A_REG_8                            0x021C
 
-/*      Digital Video Encoder B Registers */
-#define DENC_B_REG_1                                    0x0300
-#define DENC_B_REG_2                                    0x0304
-#define DENC_B_REG_3                                    0x0308
-#define DENC_B_REG_4                                    0x030C
-#define DENC_B_REG_5                                    0x0310
-#define DENC_B_REG_6                                    0x0314
-#define DENC_B_REG_7                                    0x0318
-#define DENC_B_REG_8                                    0x031C
+/* Digital Video Encoder B Registers */
+#define DENC_B_REG_1                            0x0300
+#define DENC_B_REG_2                            0x0304
+#define DENC_B_REG_3                            0x0308
+#define DENC_B_REG_4                            0x030C
+#define DENC_B_REG_5                            0x0310
+#define DENC_B_REG_6                            0x0314
+#define DENC_B_REG_7                            0x0318
+#define DENC_B_REG_8                            0x031C
 
-/*              Video Decoder A Registers */
-#define MODE_CTRL                                               0x1000
-#define OUT_CTRL1                                               0x1004
-#define OUT_CTRL_NS                                             0x1008
-#define GEN_STAT                                                0x100C
-#define INT_STAT_MASK                                   0x1010
-#define LUMA_CTRL                                               0x1014
-#define CHROMA_CTRL                                             0x1018
-#define CRUSH_CTRL                                              0x101C
-#define HORIZ_TIM_CTRL                                  0x1020
-#define VERT_TIM_CTRL                                   0x1024
-#define MISC_TIM_CTRL                                   0x1028
-#define FIELD_COUNT                                             0x102C
-#define HSCALE_CTRL                                             0x1030
-#define VSCALE_CTRL                                             0x1034
-#define MAN_VGA_CTRL                                    0x1038
-#define MAN_AGC_CTRL                                    0x103C
-#define DFE_CTRL1                                               0x1040
-#define DFE_CTRL2                                               0x1044
-#define DFE_CTRL3                                               0x1048
-#define PLL_CTRL                                                0x104C
-#define PLL_CTRL_FAST                                   0x1050
-#define HTL_CTRL                                                0x1054
-#define SRC_CFG                                                 0x1058
-#define SC_STEP_SIZE                                    0x105C
-#define SC_CONVERGE_CTRL                                0x1060
-#define SC_LOOP_CTRL                                    0x1064
-#define COMB_2D_HFS_CFG                                 0x1068
-#define COMB_2D_HFD_CFG                                 0x106C
-#define COMB_2D_LF_CFG                                  0x1070
-#define COMB_2D_BLEND                                   0x1074
-#define COMB_MISC_CTRL                                  0x1078
+/* Video Decoder A Registers */
+#define MODE_CTRL                               0x1000
+#define OUT_CTRL1                               0x1004
+#define OUT_CTRL_NS                             0x1008
+#define GEN_STAT                                0x100C
+#define INT_STAT_MASK                           0x1010
+#define LUMA_CTRL                               0x1014
+#define CHROMA_CTRL                             0x1018
+#define CRUSH_CTRL                              0x101C
+#define HORIZ_TIM_CTRL                          0x1020
+#define VERT_TIM_CTRL                           0x1024
+#define MISC_TIM_CTRL                           0x1028
+#define FIELD_COUNT                             0x102C
+#define HSCALE_CTRL                             0x1030
+#define VSCALE_CTRL                             0x1034
+#define MAN_VGA_CTRL                            0x1038
+#define MAN_AGC_CTRL                            0x103C
+#define DFE_CTRL1                               0x1040
+#define DFE_CTRL2                               0x1044
+#define DFE_CTRL3                               0x1048
+#define PLL_CTRL                                0x104C
+#define PLL_CTRL_FAST                           0x1050
+#define HTL_CTRL                                0x1054
+#define SRC_CFG                                 0x1058
+#define SC_STEP_SIZE                            0x105C
+#define SC_CONVERGE_CTRL                        0x1060
+#define SC_LOOP_CTRL                            0x1064
+#define COMB_2D_HFS_CFG                         0x1068
+#define COMB_2D_HFD_CFG                         0x106C
+#define COMB_2D_LF_CFG                          0x1070
+#define COMB_2D_BLEND                           0x1074
+#define COMB_MISC_CTRL                          0x1078
 #define COMB_FLAT_THRESH_CTRL                   0x107C
-#define COMB_TEST                                               0x1080
-#define BP_MISC_CTRL                                    0x1084
-#define VCR_DET_CTRL                                    0x1088
-#define NOISE_DET_CTRL                                  0x108C
+#define COMB_TEST                               0x1080
+#define BP_MISC_CTRL                            0x1084
+#define VCR_DET_CTRL                            0x1088
+#define NOISE_DET_CTRL                          0x108C
 #define COMB_FLAT_NOISE_CTRL                    0x1090
-#define VERSION                                                 0x11F8
-#define SOFT_RST_CTRL                                   0x11FC
+#define VERSION                                 0x11F8
+#define SOFT_RST_CTRL                           0x11FC
 
-/*      Video Decoder B Registers */
-#define VDEC_B_MODE_CTRL                                0x1200
-#define VDEC_B_OUT_CTRL1                                0x1204
-#define VDEC_B_OUT_CTRL_NS                              0x1208
-#define VDEC_B_GEN_STAT                                 0x120C
+/* Video Decoder B Registers */
+#define VDEC_B_MODE_CTRL                        0x1200
+#define VDEC_B_OUT_CTRL1                        0x1204
+#define VDEC_B_OUT_CTRL_NS                      0x1208
+#define VDEC_B_GEN_STAT                         0x120C
 #define VDEC_B_INT_STAT_MASK                    0x1210
-#define VDEC_B_LUMA_CTRL                                0x1214
-#define VDEC_B_CHROMA_CTRL                              0x1218
-#define VDEC_B_CRUSH_CTRL                               0x121C
+#define VDEC_B_LUMA_CTRL                        0x1214
+#define VDEC_B_CHROMA_CTRL                      0x1218
+#define VDEC_B_CRUSH_CTRL                       0x121C
 #define VDEC_B_HORIZ_TIM_CTRL                   0x1220
 #define VDEC_B_VERT_TIM_CTRL                    0x1224
 #define VDEC_B_MISC_TIM_CTRL                    0x1228
-#define VDEC_B_FIELD_COUNT                              0x122C
-#define VDEC_B_HSCALE_CTRL                              0x1230
-#define VDEC_B_VSCALE_CTRL                              0x1234
-#define VDEC_B_MAN_VGA_CTRL                             0x1238
-#define VDEC_B_MAN_AGC_CTRL                             0x123C
-#define VDEC_B_DFE_CTRL1                                0x1240
-#define VDEC_B_DFE_CTRL2                                0x1244
-#define VDEC_B_DFE_CTRL3                                0x1248
-#define VDEC_B_PLL_CTRL                                 0x124C
+#define VDEC_B_FIELD_COUNT                      0x122C
+#define VDEC_B_HSCALE_CTRL                      0x1230
+#define VDEC_B_VSCALE_CTRL                      0x1234
+#define VDEC_B_MAN_VGA_CTRL                     0x1238
+#define VDEC_B_MAN_AGC_CTRL                     0x123C
+#define VDEC_B_DFE_CTRL1                        0x1240
+#define VDEC_B_DFE_CTRL2                        0x1244
+#define VDEC_B_DFE_CTRL3                        0x1248
+#define VDEC_B_PLL_CTRL                         0x124C
 #define VDEC_B_PLL_CTRL_FAST                    0x1250
-#define VDEC_B_HTL_CTRL                                 0x1254
-#define VDEC_B_SRC_CFG                                  0x1258
-#define VDEC_B_SC_STEP_SIZE                             0x125C
+#define VDEC_B_HTL_CTRL                         0x1254
+#define VDEC_B_SRC_CFG                          0x1258
+#define VDEC_B_SC_STEP_SIZE                     0x125C
 #define VDEC_B_SC_CONVERGE_CTRL                 0x1260
-#define VDEC_B_SC_LOOP_CTRL                             0x1264
+#define VDEC_B_SC_LOOP_CTRL                     0x1264
 #define VDEC_B_COMB_2D_HFS_CFG                  0x1268
 #define VDEC_B_COMB_2D_HFD_CFG                  0x126C
 #define VDEC_B_COMB_2D_LF_CFG                   0x1270
 #define VDEC_B_COMB_2D_BLEND                    0x1274
 #define VDEC_B_COMB_MISC_CTRL                   0x1278
-#define VDEC_B_COMB_FLAT_THRESH_CTRL    0x127C
-#define VDEC_B_COMB_TEST                                0x1280
-#define VDEC_B_BP_MISC_CTRL                             0x1284
-#define VDEC_B_VCR_DET_CTRL                             0x1288
+#define VDEC_B_COMB_FLAT_THRESH_CTRL            0x127C
+#define VDEC_B_COMB_TEST                        0x1280
+#define VDEC_B_BP_MISC_CTRL                     0x1284
+#define VDEC_B_VCR_DET_CTRL                     0x1288
 #define VDEC_B_NOISE_DET_CTRL                   0x128C
 #define VDEC_B_COMB_FLAT_NOISE_CTRL             0x1290
-#define VDEC_B_VERSION                                  0x13F8
+#define VDEC_B_VERSION                          0x13F8
 #define VDEC_B_SOFT_RST_CTRL                    0x13FC
 
 /* Video Decoder C Registers */
-#define VDEC_C_MODE_CTRL                                0x1400
-#define VDEC_C_OUT_CTRL1                                0x1404
-#define VDEC_C_OUT_CTRL_NS                              0x1408
-#define VDEC_C_GEN_STAT                                 0x140C
+#define VDEC_C_MODE_CTRL                        0x1400
+#define VDEC_C_OUT_CTRL1                        0x1404
+#define VDEC_C_OUT_CTRL_NS                      0x1408
+#define VDEC_C_GEN_STAT                         0x140C
 #define VDEC_C_INT_STAT_MASK                    0x1410
-#define VDEC_C_LUMA_CTRL                                0x1414
-#define VDEC_C_CHROMA_CTRL                              0x1418
-#define VDEC_C_CRUSH_CTRL                               0x141C
+#define VDEC_C_LUMA_CTRL                        0x1414
+#define VDEC_C_CHROMA_CTRL                      0x1418
+#define VDEC_C_CRUSH_CTRL                       0x141C
 #define VDEC_C_HORIZ_TIM_CTRL                   0x1420
 #define VDEC_C_VERT_TIM_CTRL                    0x1424
 #define VDEC_C_MISC_TIM_CTRL                    0x1428
-#define VDEC_C_FIELD_COUNT                              0x142C
-#define VDEC_C_HSCALE_CTRL                              0x1430
-#define VDEC_C_VSCALE_CTRL                              0x1434
-#define VDEC_C_MAN_VGA_CTRL                             0x1438
-#define VDEC_C_MAN_AGC_CTRL                             0x143C
-#define VDEC_C_DFE_CTRL1                                0x1440
-#define VDEC_C_DFE_CTRL2                                0x1444
-#define VDEC_C_DFE_CTRL3                                0x1448
-#define VDEC_C_PLL_CTRL                                 0x144C
+#define VDEC_C_FIELD_COUNT                      0x142C
+#define VDEC_C_HSCALE_CTRL                      0x1430
+#define VDEC_C_VSCALE_CTRL                      0x1434
+#define VDEC_C_MAN_VGA_CTRL                     0x1438
+#define VDEC_C_MAN_AGC_CTRL                     0x143C
+#define VDEC_C_DFE_CTRL1                        0x1440
+#define VDEC_C_DFE_CTRL2                        0x1444
+#define VDEC_C_DFE_CTRL3                        0x1448
+#define VDEC_C_PLL_CTRL                         0x144C
 #define VDEC_C_PLL_CTRL_FAST                    0x1450
-#define VDEC_C_HTL_CTRL                                 0x1454
-#define VDEC_C_SRC_CFG                                  0x1458
-#define VDEC_C_SC_STEP_SIZE                             0x145C
+#define VDEC_C_HTL_CTRL                         0x1454
+#define VDEC_C_SRC_CFG                          0x1458
+#define VDEC_C_SC_STEP_SIZE                     0x145C
 #define VDEC_C_SC_CONVERGE_CTRL                 0x1460
-#define VDEC_C_SC_LOOP_CTRL                             0x1464
+#define VDEC_C_SC_LOOP_CTRL                     0x1464
 #define VDEC_C_COMB_2D_HFS_CFG                  0x1468
 #define VDEC_C_COMB_2D_HFD_CFG                  0x146C
 #define VDEC_C_COMB_2D_LF_CFG                   0x1470
 #define VDEC_C_COMB_2D_BLEND                    0x1474
 #define VDEC_C_COMB_MISC_CTRL                   0x1478
-#define VDEC_C_COMB_FLAT_THRESH_CTRL    0x147C
-#define VDEC_C_COMB_TEST                                0x1480
-#define VDEC_C_BP_MISC_CTRL                             0x1484
-#define VDEC_C_VCR_DET_CTRL                             0x1488
+#define VDEC_C_COMB_FLAT_THRESH_CTRL            0x147C
+#define VDEC_C_COMB_TEST                        0x1480
+#define VDEC_C_BP_MISC_CTRL                     0x1484
+#define VDEC_C_VCR_DET_CTRL                     0x1488
 #define VDEC_C_NOISE_DET_CTRL                   0x148C
 #define VDEC_C_COMB_FLAT_NOISE_CTRL             0x1490
-#define VDEC_C_VERSION                                  0x15F8
+#define VDEC_C_VERSION                          0x15F8
 #define VDEC_C_SOFT_RST_CTRL                    0x15FC
 
 /* Video Decoder D Registers */
-#define VDEC_D_MODE_CTRL                                0x1600
-#define VDEC_D_OUT_CTRL1                                0x1604
-#define VDEC_D_OUT_CTRL_NS                              0x1608
-#define VDEC_D_GEN_STAT                                 0x160C
+#define VDEC_D_MODE_CTRL                        0x1600
+#define VDEC_D_OUT_CTRL1                        0x1604
+#define VDEC_D_OUT_CTRL_NS                      0x1608
+#define VDEC_D_GEN_STAT                         0x160C
 #define VDEC_D_INT_STAT_MASK                    0x1610
-#define VDEC_D_LUMA_CTRL                                0x1614
-#define VDEC_D_CHROMA_CTRL                              0x1618
-#define VDEC_D_CRUSH_CTRL                               0x161C
+#define VDEC_D_LUMA_CTRL                        0x1614
+#define VDEC_D_CHROMA_CTRL                      0x1618
+#define VDEC_D_CRUSH_CTRL                       0x161C
 #define VDEC_D_HORIZ_TIM_CTRL                   0x1620
 #define VDEC_D_VERT_TIM_CTRL                    0x1624
 #define VDEC_D_MISC_TIM_CTRL                    0x1628
-#define VDEC_D_FIELD_COUNT                              0x162C
-#define VDEC_D_HSCALE_CTRL                              0x1630
-#define VDEC_D_VSCALE_CTRL                              0x1634
-#define VDEC_D_MAN_VGA_CTRL                             0x1638
-#define VDEC_D_MAN_AGC_CTRL                             0x163C
-#define VDEC_D_DFE_CTRL1                                0x1640
-#define VDEC_D_DFE_CTRL2                                0x1644
-#define VDEC_D_DFE_CTRL3                                0x1648
-#define VDEC_D_PLL_CTRL                                 0x164C
+#define VDEC_D_FIELD_COUNT                      0x162C
+#define VDEC_D_HSCALE_CTRL                      0x1630
+#define VDEC_D_VSCALE_CTRL                      0x1634
+#define VDEC_D_MAN_VGA_CTRL                     0x1638
+#define VDEC_D_MAN_AGC_CTRL                     0x163C
+#define VDEC_D_DFE_CTRL1                        0x1640
+#define VDEC_D_DFE_CTRL2                        0x1644
+#define VDEC_D_DFE_CTRL3                        0x1648
+#define VDEC_D_PLL_CTRL                         0x164C
 #define VDEC_D_PLL_CTRL_FAST                    0x1650
-#define VDEC_D_HTL_CTRL                                 0x1654
-#define VDEC_D_SRC_CFG                                  0x1658
-#define VDEC_D_SC_STEP_SIZE                             0x165C
+#define VDEC_D_HTL_CTRL                         0x1654
+#define VDEC_D_SRC_CFG                          0x1658
+#define VDEC_D_SC_STEP_SIZE                     0x165C
 #define VDEC_D_SC_CONVERGE_CTRL                 0x1660
-#define VDEC_D_SC_LOOP_CTRL                             0x1664
+#define VDEC_D_SC_LOOP_CTRL                     0x1664
 #define VDEC_D_COMB_2D_HFS_CFG                  0x1668
 #define VDEC_D_COMB_2D_HFD_CFG                  0x166C
 #define VDEC_D_COMB_2D_LF_CFG                   0x1670
 #define VDEC_D_COMB_2D_BLEND                    0x1674
 #define VDEC_D_COMB_MISC_CTRL                   0x1678
-#define VDEC_D_COMB_FLAT_THRESH_CTRL    0x167C
-#define VDEC_D_COMB_TEST                                0x1680
-#define VDEC_D_BP_MISC_CTRL                             0x1684
-#define VDEC_D_VCR_DET_CTRL                             0x1688
+#define VDEC_D_COMB_FLAT_THRESH_CTRL            0x167C
+#define VDEC_D_COMB_TEST                        0x1680
+#define VDEC_D_BP_MISC_CTRL                     0x1684
+#define VDEC_D_VCR_DET_CTRL                     0x1688
 #define VDEC_D_NOISE_DET_CTRL                   0x168C
 #define VDEC_D_COMB_FLAT_NOISE_CTRL             0x1690
-#define VDEC_D_VERSION                                  0x17F8
+#define VDEC_D_VERSION                          0x17F8
 #define VDEC_D_SOFT_RST_CTRL                    0x17FC
 
 /* Video Decoder E Registers */
-#define VDEC_E_MODE_CTRL                                0x1800
-#define VDEC_E_OUT_CTRL1                                0x1804
-#define VDEC_E_OUT_CTRL_NS                              0x1808
-#define VDEC_E_GEN_STAT                                 0x180C
+#define VDEC_E_MODE_CTRL                        0x1800
+#define VDEC_E_OUT_CTRL1                        0x1804
+#define VDEC_E_OUT_CTRL_NS                      0x1808
+#define VDEC_E_GEN_STAT                         0x180C
 #define VDEC_E_INT_STAT_MASK                    0x1810
-#define VDEC_E_LUMA_CTRL                                0x1814
-#define VDEC_E_CHROMA_CTRL                              0x1818
-#define VDEC_E_CRUSH_CTRL                               0x181C
+#define VDEC_E_LUMA_CTRL                        0x1814
+#define VDEC_E_CHROMA_CTRL                      0x1818
+#define VDEC_E_CRUSH_CTRL                       0x181C
 #define VDEC_E_HORIZ_TIM_CTRL                   0x1820
 #define VDEC_E_VERT_TIM_CTRL                    0x1824
 #define VDEC_E_MISC_TIM_CTRL                    0x1828
-#define VDEC_E_FIELD_COUNT                              0x182C
-#define VDEC_E_HSCALE_CTRL                              0x1830
-#define VDEC_E_VSCALE_CTRL                              0x1834
-#define VDEC_E_MAN_VGA_CTRL                             0x1838
-#define VDEC_E_MAN_AGC_CTRL                             0x183C
-#define VDEC_E_DFE_CTRL1                                0x1840
-#define VDEC_E_DFE_CTRL2                                0x1844
-#define VDEC_E_DFE_CTRL3                                0x1848
-#define VDEC_E_PLL_CTRL                                 0x184C
+#define VDEC_E_FIELD_COUNT                      0x182C
+#define VDEC_E_HSCALE_CTRL                      0x1830
+#define VDEC_E_VSCALE_CTRL                      0x1834
+#define VDEC_E_MAN_VGA_CTRL                     0x1838
+#define VDEC_E_MAN_AGC_CTRL                     0x183C
+#define VDEC_E_DFE_CTRL1                        0x1840
+#define VDEC_E_DFE_CTRL2                        0x1844
+#define VDEC_E_DFE_CTRL3                        0x1848
+#define VDEC_E_PLL_CTRL                         0x184C
 #define VDEC_E_PLL_CTRL_FAST                    0x1850
-#define VDEC_E_HTL_CTRL                                 0x1854
-#define VDEC_E_SRC_CFG                                  0x1858
-#define VDEC_E_SC_STEP_SIZE                             0x185C
+#define VDEC_E_HTL_CTRL                         0x1854
+#define VDEC_E_SRC_CFG                          0x1858
+#define VDEC_E_SC_STEP_SIZE                     0x185C
 #define VDEC_E_SC_CONVERGE_CTRL                 0x1860
-#define VDEC_E_SC_LOOP_CTRL                             0x1864
+#define VDEC_E_SC_LOOP_CTRL                     0x1864
 #define VDEC_E_COMB_2D_HFS_CFG                  0x1868
 #define VDEC_E_COMB_2D_HFD_CFG                  0x186C
 #define VDEC_E_COMB_2D_LF_CFG                   0x1870
 #define VDEC_E_COMB_2D_BLEND                    0x1874
 #define VDEC_E_COMB_MISC_CTRL                   0x1878
-#define VDEC_E_COMB_FLAT_THRESH_CTRL    0x187C
-#define VDEC_E_COMB_TEST                                0x1880
-#define VDEC_E_BP_MISC_CTRL                             0x1884
-#define VDEC_E_VCR_DET_CTRL                             0x1888
+#define VDEC_E_COMB_FLAT_THRESH_CTRL            0x187C
+#define VDEC_E_COMB_TEST                        0x1880
+#define VDEC_E_BP_MISC_CTRL                     0x1884
+#define VDEC_E_VCR_DET_CTRL                     0x1888
 #define VDEC_E_NOISE_DET_CTRL                   0x188C
 #define VDEC_E_COMB_FLAT_NOISE_CTRL             0x1890
-#define VDEC_E_VERSION                                  0x19F8
+#define VDEC_E_VERSION                          0x19F8
 #define VDEC_E_SOFT_RST_CTRL                    0x19FC
 
 /* Video Decoder F Registers */
-#define VDEC_F_MODE_CTRL                                0x1A00
-#define VDEC_F_OUT_CTRL1                                0x1A04
-#define VDEC_F_OUT_CTRL_NS                              0x1A08
-#define VDEC_F_GEN_STAT                                 0x1A0C
+#define VDEC_F_MODE_CTRL                        0x1A00
+#define VDEC_F_OUT_CTRL1                        0x1A04
+#define VDEC_F_OUT_CTRL_NS                      0x1A08
+#define VDEC_F_GEN_STAT                         0x1A0C
 #define VDEC_F_INT_STAT_MASK                    0x1A10
-#define VDEC_F_LUMA_CTRL                                0x1A14
-#define VDEC_F_CHROMA_CTRL                              0x1A18
-#define VDEC_F_CRUSH_CTRL                               0x1A1C
+#define VDEC_F_LUMA_CTRL                        0x1A14
+#define VDEC_F_CHROMA_CTRL                      0x1A18
+#define VDEC_F_CRUSH_CTRL                       0x1A1C
 #define VDEC_F_HORIZ_TIM_CTRL                   0x1A20
 #define VDEC_F_VERT_TIM_CTRL                    0x1A24
 #define VDEC_F_MISC_TIM_CTRL                    0x1A28
-#define VDEC_F_FIELD_COUNT                              0x1A2C
-#define VDEC_F_HSCALE_CTRL                              0x1A30
-#define VDEC_F_VSCALE_CTRL                              0x1A34
-#define VDEC_F_MAN_VGA_CTRL                             0x1A38
-#define VDEC_F_MAN_AGC_CTRL                             0x1A3C
-#define VDEC_F_DFE_CTRL1                                0x1A40
-#define VDEC_F_DFE_CTRL2                                0x1A44
-#define VDEC_F_DFE_CTRL3                                0x1A48
-#define VDEC_F_PLL_CTRL                                 0x1A4C
+#define VDEC_F_FIELD_COUNT                      0x1A2C
+#define VDEC_F_HSCALE_CTRL                      0x1A30
+#define VDEC_F_VSCALE_CTRL                      0x1A34
+#define VDEC_F_MAN_VGA_CTRL                     0x1A38
+#define VDEC_F_MAN_AGC_CTRL                     0x1A3C
+#define VDEC_F_DFE_CTRL1                        0x1A40
+#define VDEC_F_DFE_CTRL2                        0x1A44
+#define VDEC_F_DFE_CTRL3                        0x1A48
+#define VDEC_F_PLL_CTRL                         0x1A4C
 #define VDEC_F_PLL_CTRL_FAST                    0x1A50
-#define VDEC_F_HTL_CTRL                                 0x1A54
-#define VDEC_F_SRC_CFG                                  0x1A58
-#define VDEC_F_SC_STEP_SIZE                             0x1A5C
+#define VDEC_F_HTL_CTRL                         0x1A54
+#define VDEC_F_SRC_CFG                          0x1A58
+#define VDEC_F_SC_STEP_SIZE                     0x1A5C
 #define VDEC_F_SC_CONVERGE_CTRL                 0x1A60
-#define VDEC_F_SC_LOOP_CTRL                             0x1A64
+#define VDEC_F_SC_LOOP_CTRL                     0x1A64
 #define VDEC_F_COMB_2D_HFS_CFG                  0x1A68
 #define VDEC_F_COMB_2D_HFD_CFG                  0x1A6C
 #define VDEC_F_COMB_2D_LF_CFG                   0x1A70
 #define VDEC_F_COMB_2D_BLEND                    0x1A74
 #define VDEC_F_COMB_MISC_CTRL                   0x1A78
-#define VDEC_F_COMB_FLAT_THRESH_CTRL    0x1A7C
-#define VDEC_F_COMB_TEST                                0x1A80
-#define VDEC_F_BP_MISC_CTRL                             0x1A84
-#define VDEC_F_VCR_DET_CTRL                             0x1A88
+#define VDEC_F_COMB_FLAT_THRESH_CTRL            0x1A7C
+#define VDEC_F_COMB_TEST                        0x1A80
+#define VDEC_F_BP_MISC_CTRL                     0x1A84
+#define VDEC_F_VCR_DET_CTRL                     0x1A88
 #define VDEC_F_NOISE_DET_CTRL                   0x1A8C
 #define VDEC_F_COMB_FLAT_NOISE_CTRL             0x1A90
-#define VDEC_F_VERSION                                  0x1BF8
+#define VDEC_F_VERSION                          0x1BF8
 #define VDEC_F_SOFT_RST_CTRL                    0x1BFC
 
 /* Video Decoder G Registers */
-#define VDEC_G_MODE_CTRL                                0x1C00
-#define VDEC_G_OUT_CTRL1                                0x1C04
-#define VDEC_G_OUT_CTRL_NS                              0x1C08
-#define VDEC_G_GEN_STAT                                 0x1C0C
+#define VDEC_G_MODE_CTRL                        0x1C00
+#define VDEC_G_OUT_CTRL1                        0x1C04
+#define VDEC_G_OUT_CTRL_NS                      0x1C08
+#define VDEC_G_GEN_STAT                         0x1C0C
 #define VDEC_G_INT_STAT_MASK                    0x1C10
-#define VDEC_G_LUMA_CTRL                                0x1C14
-#define VDEC_G_CHROMA_CTRL                              0x1C18
-#define VDEC_G_CRUSH_CTRL                               0x1C1C
+#define VDEC_G_LUMA_CTRL                        0x1C14
+#define VDEC_G_CHROMA_CTRL                      0x1C18
+#define VDEC_G_CRUSH_CTRL                       0x1C1C
 #define VDEC_G_HORIZ_TIM_CTRL                   0x1C20
 #define VDEC_G_VERT_TIM_CTRL                    0x1C24
 #define VDEC_G_MISC_TIM_CTRL                    0x1C28
-#define VDEC_G_FIELD_COUNT                              0x1C2C
-#define VDEC_G_HSCALE_CTRL                              0x1C30
-#define VDEC_G_VSCALE_CTRL                              0x1C34
-#define VDEC_G_MAN_VGA_CTRL                             0x1C38
-#define VDEC_G_MAN_AGC_CTRL                             0x1C3C
-#define VDEC_G_DFE_CTRL1                                0x1C40
-#define VDEC_G_DFE_CTRL2                                0x1C44
-#define VDEC_G_DFE_CTRL3                                0x1C48
-#define VDEC_G_PLL_CTRL                                 0x1C4C
+#define VDEC_G_FIELD_COUNT                      0x1C2C
+#define VDEC_G_HSCALE_CTRL                      0x1C30
+#define VDEC_G_VSCALE_CTRL                      0x1C34
+#define VDEC_G_MAN_VGA_CTRL                     0x1C38
+#define VDEC_G_MAN_AGC_CTRL                     0x1C3C
+#define VDEC_G_DFE_CTRL1                        0x1C40
+#define VDEC_G_DFE_CTRL2                        0x1C44
+#define VDEC_G_DFE_CTRL3                        0x1C48
+#define VDEC_G_PLL_CTRL                         0x1C4C
 #define VDEC_G_PLL_CTRL_FAST                    0x1C50
-#define VDEC_G_HTL_CTRL                                 0x1C54
-#define VDEC_G_SRC_CFG                                  0x1C58
-#define VDEC_G_SC_STEP_SIZE                             0x1C5C
+#define VDEC_G_HTL_CTRL                         0x1C54
+#define VDEC_G_SRC_CFG                          0x1C58
+#define VDEC_G_SC_STEP_SIZE                     0x1C5C
 #define VDEC_G_SC_CONVERGE_CTRL                 0x1C60
-#define VDEC_G_SC_LOOP_CTRL                             0x1C64
+#define VDEC_G_SC_LOOP_CTRL                     0x1C64
 #define VDEC_G_COMB_2D_HFS_CFG                  0x1C68
 #define VDEC_G_COMB_2D_HFD_CFG                  0x1C6C
 #define VDEC_G_COMB_2D_LF_CFG                   0x1C70
 #define VDEC_G_COMB_2D_BLEND                    0x1C74
 #define VDEC_G_COMB_MISC_CTRL                   0x1C78
-#define VDEC_G_COMB_FLAT_THRESH_CTRL    0x1C7C
-#define VDEC_G_COMB_TEST                                0x1C80
-#define VDEC_G_BP_MISC_CTRL                             0x1C84
-#define VDEC_G_VCR_DET_CTRL                             0x1C88
+#define VDEC_G_COMB_FLAT_THRESH_CTRL            0x1C7C
+#define VDEC_G_COMB_TEST                        0x1C80
+#define VDEC_G_BP_MISC_CTRL                     0x1C84
+#define VDEC_G_VCR_DET_CTRL                     0x1C88
 #define VDEC_G_NOISE_DET_CTRL                   0x1C8C
 #define VDEC_G_COMB_FLAT_NOISE_CTRL             0x1C90
-#define VDEC_G_VERSION                                  0x1DF8
+#define VDEC_G_VERSION                          0x1DF8
 #define VDEC_G_SOFT_RST_CTRL                    0x1DFC
 
-/*              Video Decoder H Registers  */
-#define VDEC_H_MODE_CTRL                                0x1E00
-#define VDEC_H_OUT_CTRL1                                0x1E04
-#define VDEC_H_OUT_CTRL_NS                              0x1E08
-#define VDEC_H_GEN_STAT                                 0x1E0C
+/* Video Decoder H Registers  */
+#define VDEC_H_MODE_CTRL                        0x1E00
+#define VDEC_H_OUT_CTRL1                        0x1E04
+#define VDEC_H_OUT_CTRL_NS                      0x1E08
+#define VDEC_H_GEN_STAT                         0x1E0C
 #define VDEC_H_INT_STAT_MASK                    0x1E1E
-#define VDEC_H_LUMA_CTRL                                0x1E14
-#define VDEC_H_CHROMA_CTRL                              0x1E18
-#define VDEC_H_CRUSH_CTRL                               0x1E1C
+#define VDEC_H_LUMA_CTRL                        0x1E14
+#define VDEC_H_CHROMA_CTRL                      0x1E18
+#define VDEC_H_CRUSH_CTRL                       0x1E1C
 #define VDEC_H_HORIZ_TIM_CTRL                   0x1E20
 #define VDEC_H_VERT_TIM_CTRL                    0x1E24
 #define VDEC_H_MISC_TIM_CTRL                    0x1E28
-#define VDEC_H_FIELD_COUNT                              0x1E2C
-#define VDEC_H_HSCALE_CTRL                              0x1E30
-#define VDEC_H_VSCALE_CTRL                              0x1E34
-#define VDEC_H_MAN_VGA_CTRL                             0x1E38
-#define VDEC_H_MAN_AGC_CTRL                             0x1E3C
-#define VDEC_H_DFE_CTRL1                                0x1E40
-#define VDEC_H_DFE_CTRL2                                0x1E44
-#define VDEC_H_DFE_CTRL3                                0x1E48
-#define VDEC_H_PLL_CTRL                                 0x1E4C
+#define VDEC_H_FIELD_COUNT                      0x1E2C
+#define VDEC_H_HSCALE_CTRL                      0x1E30
+#define VDEC_H_VSCALE_CTRL                      0x1E34
+#define VDEC_H_MAN_VGA_CTRL                     0x1E38
+#define VDEC_H_MAN_AGC_CTRL                     0x1E3C
+#define VDEC_H_DFE_CTRL1                        0x1E40
+#define VDEC_H_DFE_CTRL2                        0x1E44
+#define VDEC_H_DFE_CTRL3                        0x1E48
+#define VDEC_H_PLL_CTRL                         0x1E4C
 #define VDEC_H_PLL_CTRL_FAST                    0x1E50
-#define VDEC_H_HTL_CTRL                                 0x1E54
-#define VDEC_H_SRC_CFG                                  0x1E58
-#define VDEC_H_SC_STEP_SIZE                             0x1E5C
+#define VDEC_H_HTL_CTRL                         0x1E54
+#define VDEC_H_SRC_CFG                          0x1E58
+#define VDEC_H_SC_STEP_SIZE                     0x1E5C
 #define VDEC_H_SC_CONVERGE_CTRL                 0x1E60
-#define VDEC_H_SC_LOOP_CTRL                             0x1E64
+#define VDEC_H_SC_LOOP_CTRL                     0x1E64
 #define VDEC_H_COMB_2D_HFS_CFG                  0x1E68
 #define VDEC_H_COMB_2D_HFD_CFG                  0x1E6C
 #define VDEC_H_COMB_2D_LF_CFG                   0x1E70
 #define VDEC_H_COMB_2D_BLEND                    0x1E74
 #define VDEC_H_COMB_MISC_CTRL                   0x1E78
-#define VDEC_H_COMB_FLAT_THRESH_CTRL    0x1E7C
-#define VDEC_H_COMB_TEST                                0x1E80
-#define VDEC_H_BP_MISC_CTRL                             0x1E84
-#define VDEC_H_VCR_DET_CTRL                             0x1E88
+#define VDEC_H_COMB_FLAT_THRESH_CTRL            0x1E7C
+#define VDEC_H_COMB_TEST                        0x1E80
+#define VDEC_H_BP_MISC_CTRL                     0x1E84
+#define VDEC_H_VCR_DET_CTRL                     0x1E88
 #define VDEC_H_NOISE_DET_CTRL                   0x1E8C
 #define VDEC_H_COMB_FLAT_NOISE_CTRL             0x1E90
-#define VDEC_H_VERSION                                  0x1FF8
+#define VDEC_H_VERSION                          0x1FF8
 #define VDEC_H_SOFT_RST_CTRL                    0x1FFC
 
 /*****************************************************************************/
 /* LUMA_CTRL register fields */
-#define VDEC_A_BRITE_CTRL                               0x1014
+#define VDEC_A_BRITE_CTRL                       0x1014
 #define VDEC_A_CNTRST_CTRL                      0x1015
 #define VDEC_A_PEAK_SEL                         0x1016
 
diff --git a/drivers/media/video/cx25821/cx25821-medusa-video.c b/drivers/media/video/cx25821/cx25821-medusa-video.c
index fc780d0908dc..298a68d98c2f 100644
--- a/drivers/media/video/cx25821/cx25821-medusa-video.c
+++ b/drivers/media/video/cx25821/cx25821-medusa-video.c
@@ -99,82 +99,67 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev)
 
         for (i = 0; i < MAX_DECODERS; i++) {
                 /* set video format NTSC-M */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0], MODE_CTRL + (0x200 * i),
-                                     &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                MODE_CTRL + (0x200 * i), &tmp);
                 value &= 0xFFFFFFF0;
                 /* enable the fast locking mode bit[16] */
                 value |= 0x10001;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0], MODE_CTRL + (0x200 * i),
-                                      value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                MODE_CTRL + (0x200 * i), value);
 
                 /* resolution NTSC 720x480 */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     HORIZ_TIM_CTRL + (0x200 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                HORIZ_TIM_CTRL + (0x200 * i), &tmp);
                 value &= 0x00C00C00;
                 value |= 0x612D0074;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      HORIZ_TIM_CTRL + (0x200 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                HORIZ_TIM_CTRL + (0x200 * i), value);
 
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     VERT_TIM_CTRL + (0x200 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                VERT_TIM_CTRL + (0x200 * i), &tmp);
                 value &= 0x00C00C00;
                 value |= 0x1C1E001A;    /* vblank_cnt + 2 to get camera ID */
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      VERT_TIM_CTRL + (0x200 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                VERT_TIM_CTRL + (0x200 * i), value);
 
                 /* chroma subcarrier step size */
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      SC_STEP_SIZE + (0x200 * i), 0x43E00000);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                SC_STEP_SIZE + (0x200 * i), 0x43E00000);
 
                 /* enable VIP optional active */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     OUT_CTRL_NS + (0x200 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                OUT_CTRL_NS + (0x200 * i), &tmp);
                 value &= 0xFFFBFFFF;
                 value |= 0x00040000;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      OUT_CTRL_NS + (0x200 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                OUT_CTRL_NS + (0x200 * i), value);
 
                 /* enable VIP optional active (VIP_OPT_AL) for direct output. */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL1 + (0x200 * i),
-                                     &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                OUT_CTRL1 + (0x200 * i), &tmp);
                 value &= 0xFFFBFFFF;
                 value |= 0x00040000;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL1 + (0x200 * i),
-                                      value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                OUT_CTRL1 + (0x200 * i), value);
 
                 /*
                  * clear VPRES_VERT_EN bit, fixes the chroma run away problem
                  * when the input switching rate < 16 fields
                 */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     MISC_TIM_CTRL + (0x200 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                MISC_TIM_CTRL + (0x200 * i), &tmp);
                 /* disable special play detection */
                 value = setBitAtPos(value, 14);
                 value = clearBitAtPos(value, 15);
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      MISC_TIM_CTRL + (0x200 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                MISC_TIM_CTRL + (0x200 * i), value);
 
                 /* set vbi_gate_en to 0 */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0], DFE_CTRL1 + (0x200 * i),
-                                     &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DFE_CTRL1 + (0x200 * i), &tmp);
                 value = clearBitAtPos(value, 29);
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0], DFE_CTRL1 + (0x200 * i),
-                                      value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DFE_CTRL1 + (0x200 * i), value);
 
                 /* Enable the generation of blue field output if no video */
                 medusa_enable_bluefield_output(dev, i, 1);
@@ -182,61 +167,49 @@ static int medusa_initialize_ntsc(struct cx25821_dev *dev)
 
         for (i = 0; i < MAX_ENCODERS; i++) {
                 /* NTSC hclock */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_1 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_1 + (0x100 * i), &tmp);
                 value &= 0xF000FC00;
                 value |= 0x06B402D0;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_1 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_1 + (0x100 * i), value);
 
                 /* burst begin and burst end */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_2 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_2 + (0x100 * i), &tmp);
                 value &= 0xFF000000;
                 value |= 0x007E9054;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_2 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_2 + (0x100 * i), value);
 
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_3 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_3 + (0x100 * i), &tmp);
                 value &= 0xFC00FE00;
                 value |= 0x00EC00F0;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_3 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_3 + (0x100 * i), value);
 
                 /* set NTSC vblank, no phase alternation, 7.5 IRE pedestal */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_4 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_4 + (0x100 * i), &tmp);
                 value &= 0x00FCFFFF;
                 value |= 0x13020000;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_4 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_4 + (0x100 * i), value);
 
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_5 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_5 + (0x100 * i), &tmp);
                 value &= 0xFFFF0000;
                 value |= 0x0000E575;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_5 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_5 + (0x100 * i), value);
 
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_6 + (0x100 * i), 0x009A89C1);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_6 + (0x100 * i), 0x009A89C1);
 
                 /* Subcarrier Increment */
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_7 + (0x100 * i), 0x21F07C1F);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_7 + (0x100 * i), 0x21F07C1F);
         }
 
         /* set picture resolutions */
@@ -261,34 +234,27 @@ static int medusa_PALCombInit(struct cx25821_dev *dev, int dec)
         u32 value = 0, tmp = 0;
 
         /* Setup for 2D threshold */
-        ret_val =
-            cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_HFS_CFG + (0x200 * dec),
-                              0x20002861);
-        ret_val =
-            cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_HFD_CFG + (0x200 * dec),
-                              0x20002861);
-        ret_val =
-            cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_LF_CFG + (0x200 * dec),
-                              0x200A1023);
+        ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                        COMB_2D_HFS_CFG + (0x200 * dec), 0x20002861);
+        ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                        COMB_2D_HFD_CFG + (0x200 * dec), 0x20002861);
+        ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                        COMB_2D_LF_CFG + (0x200 * dec), 0x200A1023);
 
         /* Setup flat chroma and luma thresholds */
-        value =
-            cx25821_i2c_read(&dev->i2c_bus[0],
-                             COMB_FLAT_THRESH_CTRL + (0x200 * dec), &tmp);
+        value = cx25821_i2c_read(&dev->i2c_bus[0],
+                        COMB_FLAT_THRESH_CTRL + (0x200 * dec), &tmp);
         value &= 0x06230000;
-        ret_val =
-            cx25821_i2c_write(&dev->i2c_bus[0],
-                              COMB_FLAT_THRESH_CTRL + (0x200 * dec), value);
+        ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                        COMB_FLAT_THRESH_CTRL + (0x200 * dec), value);
 
         /* set comb 2D blend */
-        ret_val =
-            cx25821_i2c_write(&dev->i2c_bus[0], COMB_2D_BLEND + (0x200 * dec),
-                              0x210F0F0F);
+        ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                        COMB_2D_BLEND + (0x200 * dec), 0x210F0F0F);
 
         /* COMB MISC CONTROL */
-        ret_val =
-            cx25821_i2c_write(&dev->i2c_bus[0], COMB_MISC_CTRL + (0x200 * dec),
-                              0x41120A7F);
+        ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                        COMB_MISC_CTRL + (0x200 * dec), 0x41120A7F);
 
         return ret_val;
 }
@@ -304,83 +270,68 @@ static int medusa_initialize_pal(struct cx25821_dev *dev)
 
         for (i = 0; i < MAX_DECODERS; i++) {
                 /* set video format PAL-BDGHI */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0], MODE_CTRL + (0x200 * i),
-                                     &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                MODE_CTRL + (0x200 * i), &tmp);
                 value &= 0xFFFFFFF0;
                 /* enable the fast locking mode bit[16] */
                 value |= 0x10004;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0], MODE_CTRL + (0x200 * i),
-                                      value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                MODE_CTRL + (0x200 * i), value);
 
                 /* resolution PAL 720x576 */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     HORIZ_TIM_CTRL + (0x200 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                HORIZ_TIM_CTRL + (0x200 * i), &tmp);
                 value &= 0x00C00C00;
                 value |= 0x632D007D;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      HORIZ_TIM_CTRL + (0x200 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                HORIZ_TIM_CTRL + (0x200 * i), value);
 
                 /* vblank656_cnt=x26, vactive_cnt=240h, vblank_cnt=x24 */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     VERT_TIM_CTRL + (0x200 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                VERT_TIM_CTRL + (0x200 * i), &tmp);
                 value &= 0x00C00C00;
                 value |= 0x28240026;    /* vblank_cnt + 2 to get camera ID */
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      VERT_TIM_CTRL + (0x200 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                VERT_TIM_CTRL + (0x200 * i), value);
 
                 /* chroma subcarrier step size */
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      SC_STEP_SIZE + (0x200 * i), 0x5411E2D0);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                SC_STEP_SIZE + (0x200 * i), 0x5411E2D0);
 
                 /* enable VIP optional active */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     OUT_CTRL_NS + (0x200 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                OUT_CTRL_NS + (0x200 * i), &tmp);
                 value &= 0xFFFBFFFF;
                 value |= 0x00040000;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      OUT_CTRL_NS + (0x200 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                OUT_CTRL_NS + (0x200 * i), value);
 
                 /* enable VIP optional active (VIP_OPT_AL) for direct output. */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0], OUT_CTRL1 + (0x200 * i),
-                                     &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                OUT_CTRL1 + (0x200 * i), &tmp);
                 value &= 0xFFFBFFFF;
                 value |= 0x00040000;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0], OUT_CTRL1 + (0x200 * i),
-                                      value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                OUT_CTRL1 + (0x200 * i), value);
 
                 /*
                  * clear VPRES_VERT_EN bit, fixes the chroma run away problem
                  * when the input switching rate < 16 fields
                  */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     MISC_TIM_CTRL + (0x200 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                MISC_TIM_CTRL + (0x200 * i), &tmp);
                 /* disable special play detection */
                 value = setBitAtPos(value, 14);
                 value = clearBitAtPos(value, 15);
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      MISC_TIM_CTRL + (0x200 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                MISC_TIM_CTRL + (0x200 * i), value);
 
                 /* set vbi_gate_en to 0 */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0], DFE_CTRL1 + (0x200 * i),
-                                     &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DFE_CTRL1 + (0x200 * i), &tmp);
                 value = clearBitAtPos(value, 29);
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0], DFE_CTRL1 + (0x200 * i),
-                                      value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DFE_CTRL1 + (0x200 * i), value);
 
                 medusa_PALCombInit(dev, i);
 
@@ -390,62 +341,50 @@ static int medusa_initialize_pal(struct cx25821_dev *dev)
 
         for (i = 0; i < MAX_ENCODERS; i++) {
                 /* PAL hclock */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_1 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_1 + (0x100 * i), &tmp);
                 value &= 0xF000FC00;
                 value |= 0x06C002D0;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_1 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_1 + (0x100 * i), value);
 
                 /* burst begin and burst end */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_2 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_2 + (0x100 * i), &tmp);
                 value &= 0xFF000000;
                 value |= 0x007E9754;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_2 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_2 + (0x100 * i), value);
 
                 /* hblank and vactive */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_3 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_3 + (0x100 * i), &tmp);
                 value &= 0xFC00FE00;
                 value |= 0x00FC0120;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_3 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_3 + (0x100 * i), value);
 
                 /* set PAL vblank, phase alternation, 0 IRE pedestal */
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_4 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_4 + (0x100 * i), &tmp);
                 value &= 0x00FCFFFF;
                 value |= 0x14010000;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_4 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_4 + (0x100 * i), value);
 
-                value =
-                    cx25821_i2c_read(&dev->i2c_bus[0],
-                                     DENC_A_REG_5 + (0x100 * i), &tmp);
+                value = cx25821_i2c_read(&dev->i2c_bus[0],
+                                DENC_A_REG_5 + (0x100 * i), &tmp);
                 value &= 0xFFFF0000;
                 value |= 0x0000F078;
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_5 + (0x100 * i), value);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_5 + (0x100 * i), value);
 
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_6 + (0x100 * i), 0x00A493CF);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_6 + (0x100 * i), 0x00A493CF);
 
                 /* Subcarrier Increment */
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      DENC_A_REG_7 + (0x100 * i), 0x2A098ACB);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                DENC_A_REG_7 + (0x100 * i), 0x2A098ACB);
         }
 
         /* set picture resolutions */
@@ -499,7 +438,7 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width,
 
         mutex_lock(&dev->lock);
 
-        /* validate the width - cannot be negative */
+        /* validate the width */
         if (width > MAX_WIDTH) {
                 pr_info("%s(): width %d > MAX_WIDTH %d ! resetting to MAX_WIDTH\n",
                         __func__, width, MAX_WIDTH);
@@ -543,12 +482,10 @@ void medusa_set_resolution(struct cx25821_dev *dev, int width,
 
         for (; decoder < decoder_count; decoder++) {
                 /* write scaling values for each decoder */
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      HSCALE_CTRL + (0x200 * decoder), hscale);
-                ret_val =
-                    cx25821_i2c_write(&dev->i2c_bus[0],
-                                      VSCALE_CTRL + (0x200 * decoder), vscale);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                HSCALE_CTRL + (0x200 * decoder), hscale);
+                ret_val = cx25821_i2c_write(&dev->i2c_bus[0],
+                                VSCALE_CTRL + (0x200 * decoder), vscale);
         }
 
         mutex_unlock(&dev->lock);
@@ -606,8 +543,8 @@ static void medusa_set_decoderduration(struct cx25821_dev *dev, int decoder,
 }
 
 /* Map to Medusa register setting */
-static int mapM(int srcMin,
-                int srcMax, int srcVal, int dstMin, int dstMax, int *dstVal)
+static int mapM(int srcMin, int srcMax, int srcVal, int dstMin, int dstMax,
+                int *dstVal)
 {
         int numerator;
         int denominator;
@@ -654,23 +591,19 @@ int medusa_set_brightness(struct cx25821_dev *dev, int brightness, int decoder)
         u32 val = 0, tmp = 0;
 
         mutex_lock(&dev->lock);
-        if ((brightness > VIDEO_PROCAMP_MAX)
-            || (brightness < VIDEO_PROCAMP_MIN)) {
+        if ((brightness > VIDEO_PROCAMP_MAX) ||
+            (brightness < VIDEO_PROCAMP_MIN)) {
                 mutex_unlock(&dev->lock);
                 return -1;
         }
-        ret_val =
-            mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, brightness,
-                 SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value);
+        ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, brightness,
+                        SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value);
         value = convert_to_twos(value, 8);
-        val =
-            cx25821_i2c_read(&dev->i2c_bus[0],
-                             VDEC_A_BRITE_CTRL + (0x200 * decoder), &tmp);
+        val = cx25821_i2c_read(&dev->i2c_bus[0],
+                        VDEC_A_BRITE_CTRL + (0x200 * decoder), &tmp);
         val &= 0xFFFFFF00;
-        ret_val |=
-            cx25821_i2c_write(&dev->i2c_bus[0],
-                              VDEC_A_BRITE_CTRL + (0x200 * decoder),
-                              val | value);
+        ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                        VDEC_A_BRITE_CTRL + (0x200 * decoder), val | value);
         mutex_unlock(&dev->lock);
         return ret_val;
 }
@@ -688,17 +621,13 @@ int medusa_set_contrast(struct cx25821_dev *dev, int contrast, int decoder)
                 return -1;
         }
 
-        ret_val =
-            mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, contrast,
-                 UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
-        val =
-            cx25821_i2c_read(&dev->i2c_bus[0],
-                             VDEC_A_CNTRST_CTRL + (0x200 * decoder), &tmp);
+        ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, contrast,
+                        UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
+        val = cx25821_i2c_read(&dev->i2c_bus[0],
+                        VDEC_A_CNTRST_CTRL + (0x200 * decoder), &tmp);
         val &= 0xFFFFFF00;
-        ret_val |=
-            cx25821_i2c_write(&dev->i2c_bus[0],
-                              VDEC_A_CNTRST_CTRL + (0x200 * decoder),
-                              val | value);
+        ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                        VDEC_A_CNTRST_CTRL + (0x200 * decoder), val | value);
 
         mutex_unlock(&dev->lock);
         return ret_val;
@@ -717,19 +646,16 @@ int medusa_set_hue(struct cx25821_dev *dev, int hue, int decoder)
                 return -1;
         }
 
-        ret_val =
-            mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, hue, SIGNED_BYTE_MIN,
-                 SIGNED_BYTE_MAX, &value);
+        ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, hue,
+                        SIGNED_BYTE_MIN, SIGNED_BYTE_MAX, &value);
 
         value = convert_to_twos(value, 8);
-        val =
-            cx25821_i2c_read(&dev->i2c_bus[0],
-                             VDEC_A_HUE_CTRL + (0x200 * decoder), &tmp);
+        val = cx25821_i2c_read(&dev->i2c_bus[0],
+                        VDEC_A_HUE_CTRL + (0x200 * decoder), &tmp);
         val &= 0xFFFFFF00;
 
-        ret_val |=
-            cx25821_i2c_write(&dev->i2c_bus[0],
-                              VDEC_A_HUE_CTRL + (0x200 * decoder), val | value);
+        ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                        VDEC_A_HUE_CTRL + (0x200 * decoder), val | value);
 
         mutex_unlock(&dev->lock);
         return ret_val;
@@ -743,33 +669,26 @@ int medusa_set_saturation(struct cx25821_dev *dev, int saturation, int decoder)
 
         mutex_lock(&dev->lock);
 
-        if ((saturation > VIDEO_PROCAMP_MAX)
-            || (saturation < VIDEO_PROCAMP_MIN)) {
+        if ((saturation > VIDEO_PROCAMP_MAX) ||
+            (saturation < VIDEO_PROCAMP_MIN)) {
                 mutex_unlock(&dev->lock);
                 return -1;
         }
 
-        ret_val =
-            mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, saturation,
-                 UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
+        ret_val = mapM(VIDEO_PROCAMP_MIN, VIDEO_PROCAMP_MAX, saturation,
+                        UNSIGNED_BYTE_MIN, UNSIGNED_BYTE_MAX, &value);
 
-        val =
-            cx25821_i2c_read(&dev->i2c_bus[0],
-                             VDEC_A_USAT_CTRL + (0x200 * decoder), &tmp);
+        val = cx25821_i2c_read(&dev->i2c_bus[0],
+                        VDEC_A_USAT_CTRL + (0x200 * decoder), &tmp);
         val &= 0xFFFFFF00;
-        ret_val |=
-            cx25821_i2c_write(&dev->i2c_bus[0],
-                              VDEC_A_USAT_CTRL + (0x200 * decoder),
-                              val | value);
-
-        val =
-            cx25821_i2c_read(&dev->i2c_bus[0],
-                             VDEC_A_VSAT_CTRL + (0x200 * decoder), &tmp);
+        ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                        VDEC_A_USAT_CTRL + (0x200 * decoder), val | value);
+
+        val = cx25821_i2c_read(&dev->i2c_bus[0],
+                        VDEC_A_VSAT_CTRL + (0x200 * decoder), &tmp);
         val &= 0xFFFFFF00;
-        ret_val |=
-            cx25821_i2c_write(&dev->i2c_bus[0],
-                              VDEC_A_VSAT_CTRL + (0x200 * decoder),
-                              val | value);
+        ret_val |= cx25821_i2c_write(&dev->i2c_bus[0],
+                        VDEC_A_VSAT_CTRL + (0x200 * decoder), val | value);
 
         mutex_unlock(&dev->lock);
         return ret_val;
@@ -830,9 +749,8 @@ int medusa_video_init(struct cx25821_dev *dev)
         /* select AFE clock to output mode */
         value = cx25821_i2c_read(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL, &tmp);
         value &= 0x83FFFFFF;
-        ret_val =
-           cx25821_i2c_write(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL,
-                             value | 0x10000000);
+        ret_val = cx25821_i2c_write(&dev->i2c_bus[0], AFE_AB_DIAG_CTRL,
+                        value | 0x10000000);
 
         if (ret_val < 0)
                 goto error;
diff --git a/drivers/media/video/cx25821/cx25821-video-upstream-ch2.c b/drivers/media/video/cx25821/cx25821-video-upstream-ch2.c
index 2a724ddfa53f..5a157cf4a95e 100644
--- a/drivers/media/video/cx25821/cx25821-video-upstream-ch2.c
+++ b/drivers/media/video/cx25821/cx25821-video-upstream-ch2.c
@@ -65,9 +65,8 @@ static __le32 *cx25821_update_riscprogram_ch2(struct cx25821_dev *dev,
                 *(rp++) = cpu_to_le32(dev->_data_buf_phys_addr_ch2 + offset);
                 *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
 
-                if ((lines <= NTSC_FIELD_HEIGHT)
-                    || (line < (NTSC_FIELD_HEIGHT - 1))
-                    || !(dev->_isNTSC_ch2)) {
+                if ((lines <= NTSC_FIELD_HEIGHT) ||
+                    (line < (NTSC_FIELD_HEIGHT - 1)) || !(dev->_isNTSC_ch2)) {
                         offset += dist_betwn_starts;
                 }
         }
@@ -85,7 +84,7 @@ static __le32 *cx25821_risc_field_upstream_ch2(struct cx25821_dev *dev,
 {
         unsigned int line, i;
         struct sram_channel *sram_ch =
-           dev->channels[dev->_channel2_upstream_select].sram_channels;
+                dev->channels[dev->_channel2_upstream_select].sram_channels;
         int dist_betwn_starts = bpl * 2;
 
         /* sync instruction */
@@ -103,9 +102,8 @@ static __le32 *cx25821_risc_field_upstream_ch2(struct cx25821_dev *dev,
                 *(rp++) = cpu_to_le32(databuf_phys_addr + offset);
                 *(rp++) = cpu_to_le32(0);       /* bits 63-32 */
 
-                if ((lines <= NTSC_FIELD_HEIGHT)
-                    || (line < (NTSC_FIELD_HEIGHT - 1))
-                    || !(dev->_isNTSC_ch2)) {
+                if ((lines <= NTSC_FIELD_HEIGHT) ||
+                    (line < (NTSC_FIELD_HEIGHT - 1)) || !(dev->_isNTSC_ch2)) {
                         offset += dist_betwn_starts;
                 }
 
@@ -173,7 +171,7 @@ int cx25821_risc_buffer_upstream_ch2(struct cx25821_dev *dev,
 
                 fifo_enable = FIFO_DISABLE;
 
-               /* Even field */
+                /* Even field */
                 rp = cx25821_risc_field_upstream_ch2(dev, rp,
                                 dev->_data_buf_phys_addr_ch2 + databuf_offset,
                                 bottom_offset, 0x200, bpl, singlefield_lines,
@@ -189,9 +187,9 @@ int cx25821_risc_buffer_upstream_ch2(struct cx25821_dev *dev,
                 }
 
                /*
-                  Loop to 2ndFrameRISC or to Start of
-                  Risc program & generate IRQ
-               */
+                * Loop to 2ndFrameRISC or to Start of
+                * Risc program & generate IRQ
+                */
                 *(rp++) = cpu_to_le32(RISC_JUMP | RISC_IRQ1 | risc_flag);
                 *(rp++) = cpu_to_le32(risc_phys_jump_addr);
                 *(rp++) = cpu_to_le32(0);
@@ -203,7 +201,7 @@ int cx25821_risc_buffer_upstream_ch2(struct cx25821_dev *dev,
 void cx25821_stop_upstream_video_ch2(struct cx25821_dev *dev)
 {
         struct sram_channel *sram_ch =
-           dev->channels[VID_UPSTREAM_SRAM_CHANNEL_J].sram_channels;
+                dev->channels[VID_UPSTREAM_SRAM_CHANNEL_J].sram_channels;
         u32 tmp = 0;
 
         if (!dev->_is_running_ch2) {
@@ -262,9 +260,8 @@ int cx25821_get_frame_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
         struct file *myfile;
         int frame_index_temp = dev->_frame_index_ch2;
         int i = 0;
-        int line_size =
-            (dev->_pixel_format_ch2 ==
-             PIXEL_FRMT_411) ? Y411_LINE_SZ : Y422_LINE_SZ;
+        int line_size = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ?
+                Y411_LINE_SZ : Y422_LINE_SZ;
         int frame_size = 0;
         int frame_offset = 0;
         ssize_t vfs_read_retval = 0;
@@ -277,14 +274,11 @@ int cx25821_get_frame_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                 return 0;
 
         if (dev->_isNTSC_ch2) {
-                frame_size =
-                    (line_size ==
-                     Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 :
-                    FRAME_SIZE_NTSC_Y422;
+                frame_size = (line_size == Y411_LINE_SZ) ?
+                        FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
         } else {
-                frame_size =
-                    (line_size ==
-                     Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
+                frame_size = (line_size == Y411_LINE_SZ) ?
+                        FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
         }
 
         frame_offset = (frame_index_temp > 0) ? frame_size : 0;
@@ -318,14 +312,14 @@ int cx25821_get_frame_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                 for (i = 0; i < dev->_lines_count_ch2; i++) {
                         pos = file_offset;
 
-                        vfs_read_retval =
-                            vfs_read(myfile, mybuf, line_size, &pos);
+                        vfs_read_retval = vfs_read(myfile, mybuf, line_size,
+                                        &pos);
 
                         if (vfs_read_retval > 0 && vfs_read_retval == line_size
                             && dev->_data_buf_virt_addr_ch2 != NULL) {
                                 memcpy((void *)(dev->_data_buf_virt_addr_ch2 +
                                                 frame_offset / 4), mybuf,
-                                       vfs_read_retval);
+                                                vfs_read_retval);
                         }
 
                         file_offset += vfs_read_retval;
@@ -341,8 +335,8 @@ int cx25821_get_frame_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                 if (i > 0)
                         dev->_frame_count_ch2++;
 
-                dev->_file_status_ch2 =
-                    (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
+                dev->_file_status_ch2 = (vfs_read_retval == line_size) ?
+                        IN_PROGRESS : END_OF_FILE;
 
                 set_fs(old_fs);
                 filp_close(myfile, NULL);
@@ -353,8 +347,8 @@ int cx25821_get_frame_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
 
 static void cx25821_vidups_handler_ch2(struct work_struct *work)
 {
-        struct cx25821_dev *dev =
-            container_of(work, struct cx25821_dev, _irq_work_entry_ch2);
+        struct cx25821_dev *dev = container_of(work, struct cx25821_dev,
+                        _irq_work_entry_ch2);
 
         if (!dev) {
                 pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n",
@@ -362,18 +356,16 @@ static void cx25821_vidups_handler_ch2(struct work_struct *work)
                 return;
         }
 
-        cx25821_get_frame_ch2(dev,
-                             dev->channels[dev->
-                               _channel2_upstream_select].sram_channels);
+        cx25821_get_frame_ch2(dev, dev->channels[dev->
+                        _channel2_upstream_select].sram_channels);
 }
 
 int cx25821_openfile_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
 {
         struct file *myfile;
         int i = 0, j = 0;
-        int line_size =
-            (dev->_pixel_format_ch2 ==
-             PIXEL_FRMT_411) ? Y411_LINE_SZ : Y422_LINE_SZ;
+        int line_size = (dev->_pixel_format_ch2 == PIXEL_FRMT_411) ?
+                Y411_LINE_SZ : Y422_LINE_SZ;
         ssize_t vfs_read_retval = 0;
         char mybuf[line_size];
         loff_t pos;
@@ -410,16 +402,16 @@ int cx25821_openfile_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                         for (i = 0; i < dev->_lines_count_ch2; i++) {
                                 pos = offset;
 
-                                vfs_read_retval =
-                                    vfs_read(myfile, mybuf, line_size, &pos);
+                                vfs_read_retval = vfs_read(myfile, mybuf,
+                                                line_size, &pos);
 
-                                if (vfs_read_retval > 0
-                                    && vfs_read_retval == line_size
-                                    && dev->_data_buf_virt_addr_ch2 != NULL) {
+                                if (vfs_read_retval > 0 &&
+                                    vfs_read_retval == line_size &&
+                                    dev->_data_buf_virt_addr_ch2 != NULL) {
                                         memcpy((void *)(dev->
                                                         _data_buf_virt_addr_ch2
                                                         + offset / 4), mybuf,
-                                               vfs_read_retval);
+                                                        vfs_read_retval);
                                 }
 
                                 offset += vfs_read_retval;
@@ -438,8 +430,8 @@ int cx25821_openfile_ch2(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                                 break;
                 }
 
-                dev->_file_status_ch2 =
-                    (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
+                dev->_file_status_ch2 = (vfs_read_retval == line_size) ?
+                        IN_PROGRESS : END_OF_FILE;
 
                 set_fs(old_fs);
                 myfile->f_pos = 0;
@@ -463,9 +455,8 @@ static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev,
                                     dev->_dma_phys_addr_ch2);
         }
 
-        dev->_dma_virt_addr_ch2 =
-            pci_alloc_consistent(dev->pci, dev->upstream_riscbuf_size_ch2,
-                                 &dma_addr);
+        dev->_dma_virt_addr_ch2 = pci_alloc_consistent(dev->pci,
+                        dev->upstream_riscbuf_size_ch2, &dma_addr);
         dev->_dma_virt_start_addr_ch2 = dev->_dma_virt_addr_ch2;
         dev->_dma_phys_start_addr_ch2 = dma_addr;
         dev->_dma_phys_addr_ch2 = dma_addr;
@@ -485,9 +476,8 @@ static int cx25821_upstream_buffer_prepare_ch2(struct cx25821_dev *dev,
                                     dev->_data_buf_phys_addr_ch2);
         }
         /* For Video Data buffer allocation */
-        dev->_data_buf_virt_addr_ch2 =
-            pci_alloc_consistent(dev->pci, dev->upstream_databuf_size_ch2,
-                                 &data_dma_addr);
+        dev->_data_buf_virt_addr_ch2 = pci_alloc_consistent(dev->pci,
+                        dev->upstream_databuf_size_ch2, &data_dma_addr);
         dev->_data_buf_phys_addr_ch2 = data_dma_addr;
         dev->_data_buf_size_ch2 = dev->upstream_databuf_size_ch2;
 
@@ -563,8 +553,8 @@ int cx25821_video_upstream_irq_ch2(struct cx25821_dev *dev, int chan_num,
                                 else
                                         line_size_in_bytes = Y422_LINE_SZ;
                                 risc_phys_jump_addr =
-                                    dev->_dma_phys_start_addr_ch2 +
-                                    odd_risc_prog_size;
+                                        dev->_dma_phys_start_addr_ch2 +
+                                        odd_risc_prog_size;
 
                                 rp = cx25821_update_riscprogram_ch2(dev,
                                                 dev->_dma_virt_start_addr_ch2,
@@ -612,11 +602,9 @@ static irqreturn_t cx25821_upstream_irq_ch2(int irq, void *dev_id)
         vid_status = cx_read(sram_ch->int_stat);
 
         /* Only deal with our interrupt */
-        if (vid_status) {
-                handled =
-                    cx25821_video_upstream_irq_ch2(dev, channel_num,
-                                                   vid_status);
-        }
+        if (vid_status)
+                handled = cx25821_video_upstream_irq_ch2(dev, channel_num,
+                                vid_status);
 
         if (handled < 0)
                 cx25821_stop_upstream_video_ch2(dev);
@@ -691,8 +679,7 @@ int cx25821_start_video_dma_upstream_ch2(struct cx25821_dev *dev,
         tmp = cx_read(sram_ch->int_msk);
         cx_write(sram_ch->int_msk, tmp |= _intr_msk);
 
-        err =
-            request_irq(dev->pci->irq, cx25821_upstream_irq_ch2,
+        err = request_irq(dev->pci->irq, cx25821_upstream_irq_ch2,
                         IRQF_SHARED, dev->name, dev);
         if (err < 0) {
                 pr_err("%s: can't get upstream IRQ %d\n",
@@ -752,45 +739,38 @@ int cx25821_vidupstream_init_ch2(struct cx25821_dev *dev, int channel_select,
         dev->_file_status_ch2 = RESET_STATUS;
         dev->_lines_count_ch2 = dev->_isNTSC_ch2 ? 480 : 576;
         dev->_pixel_format_ch2 = pixel_format;
-        dev->_line_size_ch2 =
-            (dev->_pixel_format_ch2 ==
-             PIXEL_FRMT_422) ? (WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
+        dev->_line_size_ch2 = (dev->_pixel_format_ch2 == PIXEL_FRMT_422) ?
+                (WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
         data_frame_size = dev->_isNTSC_ch2 ? NTSC_DATA_BUF_SZ : PAL_DATA_BUF_SZ;
-        risc_buffer_size =
-            dev->_isNTSC_ch2 ? NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE;
+        risc_buffer_size = dev->_isNTSC_ch2 ?
+                NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE;
 
         if (dev->input_filename_ch2) {
                 str_length = strlen(dev->input_filename_ch2);
-                dev->_filename_ch2 = kmalloc(str_length + 1, GFP_KERNEL);
+                dev->_filename_ch2 = kmemdup(dev->input_filename_ch2,
+                                             str_length + 1, GFP_KERNEL);
 
                 if (!dev->_filename_ch2)
                         goto error;
-
-                memcpy(dev->_filename_ch2, dev->input_filename_ch2,
-                       str_length + 1);
         } else {
                 str_length = strlen(dev->_defaultname_ch2);
-                dev->_filename_ch2 = kmalloc(str_length + 1, GFP_KERNEL);
+                dev->_filename_ch2 = kmemdup(dev->_defaultname_ch2,
+                                             str_length + 1, GFP_KERNEL);
 
                 if (!dev->_filename_ch2)
                         goto error;
-
-                memcpy(dev->_filename_ch2, dev->_defaultname_ch2,
-                       str_length + 1);
         }
 
         /* Default if filename is empty string */
         if (strcmp(dev->input_filename_ch2, "") == 0) {
                 if (dev->_isNTSC_ch2) {
-                        dev->_filename_ch2 =
-                            (dev->_pixel_format_ch2 ==
-                             PIXEL_FRMT_411) ? "/root/vid411.yuv" :
-                            "/root/vidtest.yuv";
+                        dev->_filename_ch2 = (dev->_pixel_format_ch2 ==
+                                PIXEL_FRMT_411) ? "/root/vid411.yuv" :
+                                "/root/vidtest.yuv";
                 } else {
-                        dev->_filename_ch2 =
-                            (dev->_pixel_format_ch2 ==
-                             PIXEL_FRMT_411) ? "/root/pal411.yuv" :
-                            "/root/pal422.yuv";
+                        dev->_filename_ch2 = (dev->_pixel_format_ch2 ==
+                                PIXEL_FRMT_411) ? "/root/pal411.yuv" :
+                                "/root/pal422.yuv";
                 }
         }
 
diff --git a/drivers/media/video/cx25821/cx25821-video-upstream.c b/drivers/media/video/cx25821/cx25821-video-upstream.c
index c0b80068f468..21e7d657f049 100644
--- a/drivers/media/video/cx25821/cx25821-video-upstream.c
+++ b/drivers/media/video/cx25821/cx25821-video-upstream.c
@@ -136,7 +136,7 @@ static __le32 *cx25821_risc_field_upstream(struct cx25821_dev *dev, __le32 * rp,
 {
         unsigned int line, i;
         struct sram_channel *sram_ch =
-           dev->channels[dev->_channel_upstream_select].sram_channels;
+                dev->channels[dev->_channel_upstream_select].sram_channels;
         int dist_betwn_starts = bpl * 2;
 
         /* sync instruction */
@@ -194,15 +194,12 @@ int cx25821_risc_buffer_upstream(struct cx25821_dev *dev,
         if (dev->_isNTSC) {
                 odd_num_lines = singlefield_lines + 1;
                 risc_program_size = FRAME1_VID_PROG_SIZE;
-                frame_size =
-                    (bpl ==
-                     Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 :
-                    FRAME_SIZE_NTSC_Y422;
+                frame_size = (bpl == Y411_LINE_SZ) ?
+                        FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
         } else {
                 risc_program_size = PAL_VID_PROG_SIZE;
-                frame_size =
-                    (bpl ==
-                     Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
+                frame_size = (bpl == Y411_LINE_SZ) ?
+                        FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
         }
 
         /* Virtual address of Risc buffer program */
@@ -214,13 +211,9 @@ int cx25821_risc_buffer_upstream(struct cx25821_dev *dev,
                 if (UNSET != top_offset) {
                         fifo_enable = (frame == 0) ? FIFO_ENABLE : FIFO_DISABLE;
                         rp = cx25821_risc_field_upstream(dev, rp,
-                                                         dev->
-                                                         _data_buf_phys_addr +
-                                                         databuf_offset,
-                                                         top_offset, 0, bpl,
-                                                         odd_num_lines,
-                                                         fifo_enable,
-                                                         ODD_FIELD);
+                                        dev->_data_buf_phys_addr +
+                                        databuf_offset, top_offset, 0, bpl,
+                                        odd_num_lines, fifo_enable, ODD_FIELD);
                 }
 
                 fifo_enable = FIFO_DISABLE;
@@ -234,8 +227,8 @@ int cx25821_risc_buffer_upstream(struct cx25821_dev *dev,
 
                 if (frame == 0) {
                         risc_flag = RISC_CNT_RESET;
-                        risc_phys_jump_addr =
-                            dev->_dma_phys_start_addr + risc_program_size;
+                        risc_phys_jump_addr = dev->_dma_phys_start_addr +
+                                risc_program_size;
                 } else {
                         risc_phys_jump_addr = dev->_dma_phys_start_addr;
                         risc_flag = RISC_CNT_INC;
@@ -255,7 +248,7 @@ int cx25821_risc_buffer_upstream(struct cx25821_dev *dev,
 void cx25821_stop_upstream_video_ch1(struct cx25821_dev *dev)
 {
         struct sram_channel *sram_ch =
-           dev->channels[VID_UPSTREAM_SRAM_CHANNEL_I].sram_channels;
+                dev->channels[VID_UPSTREAM_SRAM_CHANNEL_I].sram_channels;
         u32 tmp = 0;
 
         if (!dev->_is_running) {
@@ -312,9 +305,8 @@ int cx25821_get_frame(struct cx25821_dev *dev, struct sram_channel *sram_ch)
         struct file *myfile;
         int frame_index_temp = dev->_frame_index;
         int i = 0;
-        int line_size =
-            (dev->_pixel_format ==
-             PIXEL_FRMT_411) ? Y411_LINE_SZ : Y422_LINE_SZ;
+        int line_size = (dev->_pixel_format == PIXEL_FRMT_411) ?
+                Y411_LINE_SZ : Y422_LINE_SZ;
         int frame_size = 0;
         int frame_offset = 0;
         ssize_t vfs_read_retval = 0;
@@ -326,16 +318,12 @@ int cx25821_get_frame(struct cx25821_dev *dev, struct sram_channel *sram_ch)
         if (dev->_file_status == END_OF_FILE)
                 return 0;
 
-        if (dev->_isNTSC) {
-                frame_size =
-                    (line_size ==
-                     Y411_LINE_SZ) ? FRAME_SIZE_NTSC_Y411 :
-                    FRAME_SIZE_NTSC_Y422;
-        } else {
-                frame_size =
-                    (line_size ==
-                     Y411_LINE_SZ) ? FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
-        }
+        if (dev->_isNTSC)
+                frame_size = (line_size == Y411_LINE_SZ) ?
+                        FRAME_SIZE_NTSC_Y411 : FRAME_SIZE_NTSC_Y422;
+        else
+                frame_size = (line_size == Y411_LINE_SZ) ?
+                        FRAME_SIZE_PAL_Y411 : FRAME_SIZE_PAL_Y422;
 
         frame_offset = (frame_index_temp > 0) ? frame_size : 0;
         file_offset = dev->_frame_count * frame_size;
@@ -369,8 +357,8 @@ int cx25821_get_frame(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                 for (i = 0; i < dev->_lines_count; i++) {
                         pos = file_offset;
 
-                        vfs_read_retval =
-                            vfs_read(myfile, mybuf, line_size, &pos);
+                        vfs_read_retval = vfs_read(myfile, mybuf, line_size,
+                                        &pos);
 
                         if (vfs_read_retval > 0 && vfs_read_retval == line_size
                             && dev->_data_buf_virt_addr != NULL) {
@@ -392,8 +380,8 @@ int cx25821_get_frame(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                 if (i > 0)
                         dev->_frame_count++;
 
-                dev->_file_status =
-                    (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
+                dev->_file_status = (vfs_read_retval == line_size) ?
+                        IN_PROGRESS : END_OF_FILE;
 
                 set_fs(old_fs);
                 filp_close(myfile, NULL);
@@ -404,8 +392,8 @@ int cx25821_get_frame(struct cx25821_dev *dev, struct sram_channel *sram_ch)
 
 static void cx25821_vidups_handler(struct work_struct *work)
 {
-        struct cx25821_dev *dev =
-            container_of(work, struct cx25821_dev, _irq_work_entry);
+        struct cx25821_dev *dev = container_of(work, struct cx25821_dev,
+                        _irq_work_entry);
 
         if (!dev) {
                 pr_err("ERROR %s(): since container_of(work_struct) FAILED!\n",
@@ -413,18 +401,16 @@ static void cx25821_vidups_handler(struct work_struct *work)
                 return;
         }
 
-        cx25821_get_frame(dev,
-                         dev->channels[dev->_channel_upstream_select].
-                                               sram_channels);
+        cx25821_get_frame(dev, dev->channels[dev->_channel_upstream_select].
+                        sram_channels);
 }
 
 int cx25821_openfile(struct cx25821_dev *dev, struct sram_channel *sram_ch)
 {
         struct file *myfile;
         int i = 0, j = 0;
-        int line_size =
-            (dev->_pixel_format ==
-             PIXEL_FRMT_411) ? Y411_LINE_SZ : Y422_LINE_SZ;
+        int line_size = (dev->_pixel_format == PIXEL_FRMT_411) ?
+                Y411_LINE_SZ : Y422_LINE_SZ;
         ssize_t vfs_read_retval = 0;
         char mybuf[line_size];
         loff_t pos;
@@ -461,8 +447,8 @@ int cx25821_openfile(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                         for (i = 0; i < dev->_lines_count; i++) {
                                 pos = offset;
 
-                                vfs_read_retval =
-                                    vfs_read(myfile, mybuf, line_size, &pos);
+                                vfs_read_retval = vfs_read(myfile, mybuf,
+                                                line_size, &pos);
 
                                 if (vfs_read_retval > 0
                                     && vfs_read_retval == line_size
@@ -489,8 +475,8 @@ int cx25821_openfile(struct cx25821_dev *dev, struct sram_channel *sram_ch)
                                 break;
                 }
 
-                dev->_file_status =
-                    (vfs_read_retval == line_size) ? IN_PROGRESS : END_OF_FILE;
+                dev->_file_status = (vfs_read_retval == line_size) ?
+                        IN_PROGRESS : END_OF_FILE;
 
                 set_fs(old_fs);
                 myfile->f_pos = 0;
@@ -507,14 +493,12 @@ int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
         dma_addr_t dma_addr;
         dma_addr_t data_dma_addr;
 
-        if (dev->_dma_virt_addr != NULL) {
+        if (dev->_dma_virt_addr != NULL)
                 pci_free_consistent(dev->pci, dev->upstream_riscbuf_size,
-                                    dev->_dma_virt_addr, dev->_dma_phys_addr);
-        }
+                                dev->_dma_virt_addr, dev->_dma_phys_addr);
 
-        dev->_dma_virt_addr =
-            pci_alloc_consistent(dev->pci, dev->upstream_riscbuf_size,
-                                 &dma_addr);
+        dev->_dma_virt_addr = pci_alloc_consistent(dev->pci,
+                        dev->upstream_riscbuf_size, &dma_addr);
         dev->_dma_virt_start_addr = dev->_dma_virt_addr;
         dev->_dma_phys_start_addr = dma_addr;
         dev->_dma_phys_addr = dma_addr;
@@ -528,15 +512,13 @@ int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
         /* Clear memory at address */
         memset(dev->_dma_virt_addr, 0, dev->_risc_size);
 
-        if (dev->_data_buf_virt_addr != NULL) {
+        if (dev->_data_buf_virt_addr != NULL)
                 pci_free_consistent(dev->pci, dev->upstream_databuf_size,
-                                    dev->_data_buf_virt_addr,
-                                    dev->_data_buf_phys_addr);
-        }
+                                dev->_data_buf_virt_addr,
+                                dev->_data_buf_phys_addr);
         /* For Video Data buffer allocation */
-        dev->_data_buf_virt_addr =
-            pci_alloc_consistent(dev->pci, dev->upstream_databuf_size,
-                                 &data_dma_addr);
+        dev->_data_buf_virt_addr = pci_alloc_consistent(dev->pci,
+                        dev->upstream_databuf_size, &data_dma_addr);
         dev->_data_buf_phys_addr = data_dma_addr;
         dev->_data_buf_size = dev->upstream_databuf_size;
 
@@ -553,9 +535,8 @@ int cx25821_upstream_buffer_prepare(struct cx25821_dev *dev,
                 return ret;
 
         /* Create RISC programs */
-        ret =
-            cx25821_risc_buffer_upstream(dev, dev->pci, 0, bpl,
-                                         dev->_lines_count);
+        ret = cx25821_risc_buffer_upstream(dev, dev->pci, 0, bpl,
+                        dev->_lines_count);
         if (ret < 0) {
                 pr_info("Failed creating Video Upstream Risc programs!\n");
                 goto error;
@@ -672,10 +653,9 @@ static irqreturn_t cx25821_upstream_irq(int irq, void *dev_id)
         vid_status = cx_read(sram_ch->int_stat);
 
         /* Only deal with our interrupt */
-        if (vid_status) {
-                handled =
-                    cx25821_video_upstream_irq(dev, channel_num, vid_status);
-        }
+        if (vid_status)
+                handled = cx25821_video_upstream_irq(dev, channel_num,
+                                vid_status);
 
         if (handled < 0)
                 cx25821_stop_upstream_video_ch1(dev);
@@ -747,8 +727,7 @@ int cx25821_start_video_dma_upstream(struct cx25821_dev *dev,
         tmp = cx_read(sram_ch->int_msk);
         cx_write(sram_ch->int_msk, tmp |= _intr_msk);
 
-        err =
-            request_irq(dev->pci->irq, cx25821_upstream_irq,
+        err = request_irq(dev->pci->irq, cx25821_upstream_irq,
                         IRQF_SHARED, dev->name, dev);
         if (err < 0) {
                 pr_err("%s: can't get upstream IRQ %d\n",
@@ -807,43 +786,38 @@ int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select,
         dev->_file_status = RESET_STATUS;
         dev->_lines_count = dev->_isNTSC ? 480 : 576;
         dev->_pixel_format = pixel_format;
-        dev->_line_size =
-            (dev->_pixel_format ==
-             PIXEL_FRMT_422) ? (WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
+        dev->_line_size = (dev->_pixel_format == PIXEL_FRMT_422) ?
+                (WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
         data_frame_size = dev->_isNTSC ? NTSC_DATA_BUF_SZ : PAL_DATA_BUF_SZ;
-        risc_buffer_size =
-            dev->_isNTSC ? NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE;
+        risc_buffer_size = dev->_isNTSC ?
+                NTSC_RISC_BUF_SIZE : PAL_RISC_BUF_SIZE;
 
         if (dev->input_filename) {
                 str_length = strlen(dev->input_filename);
-                dev->_filename = kmalloc(str_length + 1, GFP_KERNEL);
+                dev->_filename = kmemdup(dev->input_filename, str_length + 1,
+                                         GFP_KERNEL);
 
                 if (!dev->_filename)
                         goto error;
-
-                memcpy(dev->_filename, dev->input_filename, str_length + 1);
         } else {
                 str_length = strlen(dev->_defaultname);
-                dev->_filename = kmalloc(str_length + 1, GFP_KERNEL);
+                dev->_filename = kmemdup(dev->_defaultname, str_length + 1,
+                                         GFP_KERNEL);
 
                 if (!dev->_filename)
                         goto error;
-
-                memcpy(dev->_filename, dev->_defaultname, str_length + 1);
         }
 
         /* Default if filename is empty string */
         if (strcmp(dev->input_filename, "") == 0) {
                 if (dev->_isNTSC) {
                         dev->_filename =
-                            (dev->_pixel_format ==
-                             PIXEL_FRMT_411) ? "/root/vid411.yuv" :
-                            "/root/vidtest.yuv";
+                                (dev->_pixel_format == PIXEL_FRMT_411) ?
+                                "/root/vid411.yuv" : "/root/vidtest.yuv";
                 } else {
                         dev->_filename =
-                            (dev->_pixel_format ==
-                             PIXEL_FRMT_411) ? "/root/pal411.yuv" :
-                            "/root/pal422.yuv";
+                                (dev->_pixel_format == PIXEL_FRMT_411) ?
+                                "/root/pal411.yuv" : "/root/pal422.yuv";
                 }
         }
 
@@ -852,13 +826,11 @@ int cx25821_vidupstream_init_ch1(struct cx25821_dev *dev, int channel_select,
         dev->_file_status = RESET_STATUS;
         dev->_lines_count = dev->_isNTSC ? 480 : 576;
         dev->_pixel_format = pixel_format;
-        dev->_line_size =
-            (dev->_pixel_format ==
-             PIXEL_FRMT_422) ? (WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
+        dev->_line_size = (dev->_pixel_format == PIXEL_FRMT_422) ?
+                (WIDTH_D1 * 2) : (WIDTH_D1 * 3) / 2;
 
-        retval =
-            cx25821_sram_channel_setup_upstream(dev, sram_ch, dev->_line_size,
-                                                0);
+        retval = cx25821_sram_channel_setup_upstream(dev, sram_ch,
+                        dev->_line_size, 0);
 
         /* setup fifo + format */
         cx25821_set_pixelengine(dev, sram_ch, dev->_pixel_format);
diff --git a/drivers/media/video/cx25821/cx25821-video.c b/drivers/media/video/cx25821/cx25821-video.c
index 4d6907cda75b..ffd8bc79c02e 100644
--- a/drivers/media/video/cx25821/cx25821-video.c
+++ b/drivers/media/video/cx25821/cx25821-video.c
@@ -118,12 +118,12 @@ void cx25821_dump_video_queue(struct cx25821_dev *dev,
 
         if (!list_empty(&q->active)) {
                 list_for_each(item, &q->active)
-                    buf = list_entry(item, struct cx25821_buffer, vb.queue);
+                        buf = list_entry(item, struct cx25821_buffer, vb.queue);
         }
 
         if (!list_empty(&q->queued)) {
                 list_for_each(item, &q->queued)
-                    buf = list_entry(item, struct cx25821_buffer, vb.queue);
+                        buf = list_entry(item, struct cx25821_buffer, vb.queue);
         }
 
 }
@@ -140,8 +140,8 @@ void cx25821_video_wakeup(struct cx25821_dev *dev, struct cx25821_dmaqueue *q,
                         break;
                 }
 
-                buf =
-                    list_entry(q->active.next, struct cx25821_buffer, vb.queue);
+                buf = list_entry(q->active.next, struct cx25821_buffer,
+                                vb.queue);
 
                 /* count comes from the hw and it is 16bit wide --
                  * this trick handles wrap-arounds correctly for
@@ -318,8 +318,8 @@ int cx25821_restart_video_queue(struct cx25821_dev *dev,
         struct list_head *item;
 
         if (!list_empty(&q->active)) {
-                buf =
-                    list_entry(q->active.next, struct cx25821_buffer, vb.queue);
+                buf = list_entry(q->active.next, struct cx25821_buffer,
+                                vb.queue);
 
                 cx25821_start_video_dma(dev, q, buf, channel);
 
@@ -337,8 +337,8 @@ int cx25821_restart_video_queue(struct cx25821_dev *dev,
                 if (list_empty(&q->queued))
                         return 0;
 
-                buf =
-                    list_entry(q->queued.next, struct cx25821_buffer, vb.queue);
+                buf = list_entry(q->queued.next, struct cx25821_buffer,
+                                vb.queue);
 
                 if (NULL == prev) {
                         list_move_tail(&buf->vb.queue, &q->active);
@@ -375,8 +375,8 @@ void cx25821_vid_timeout(unsigned long data)
 
         spin_lock_irqsave(&dev->slock, flags);
         while (!list_empty(&q->active)) {
-                buf =
-                    list_entry(q->active.next, struct cx25821_buffer, vb.queue);
+                buf = list_entry(q->active.next, struct cx25821_buffer,
+                                vb.queue);
                 list_del(&buf->vb.queue);
 
                 buf->vb.state = VIDEOBUF_ERROR;
@@ -484,8 +484,7 @@ int cx25821_video_register(struct cx25821_dev *dev)
                 cx25821_init_controls(dev, i);
 
                 cx25821_risc_stopper(dev->pci, &dev->channels[i].vidq.stopper,
-                                dev->channels[i].sram_channels->dma_ctl,
-                                0x11, 0);
+                        dev->channels[i].sram_channels->dma_ctl, 0x11, 0);
 
                 dev->channels[i].sram_channels = &cx25821_sram_channels[i];
                 dev->channels[i].video_dev = NULL;
@@ -499,15 +498,14 @@ int cx25821_video_register(struct cx25821_dev *dev)
                 dev->channels[i].timeout_data.dev = dev;
                 dev->channels[i].timeout_data.channel =
                         &cx25821_sram_channels[i];
-                dev->channels[i].vidq.timeout.function =
-                        cx25821_vid_timeout;
+                dev->channels[i].vidq.timeout.function = cx25821_vid_timeout;
                 dev->channels[i].vidq.timeout.data =
                         (unsigned long)&dev->channels[i].timeout_data;
                 init_timer(&dev->channels[i].vidq.timeout);
 
                 /* register v4l devices */
-                dev->channels[i].video_dev = cx25821_vdev_init(dev,
-                                dev->pci, &cx25821_video_device, "video");
+                dev->channels[i].video_dev = cx25821_vdev_init(dev, dev->pci,
+                                &cx25821_video_device, "video");
 
                 err = video_register_device(dev->channels[i].video_dev,
                                 VFL_TYPE_GRABBER, video_nr[dev->nr]);
@@ -528,7 +526,6 @@ int cx25821_video_register(struct cx25821_dev *dev)
 #endif
         mutex_unlock(&dev->lock);
 
-
         return 0;
 
 fail_unreg:
@@ -558,7 +555,7 @@ int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
         struct cx25821_fh *fh = q->priv_data;
         struct cx25821_dev *dev = fh->dev;
         struct cx25821_buffer *buf =
-            container_of(vb, struct cx25821_buffer, vb);
+                container_of(vb, struct cx25821_buffer, vb);
         int rc, init_buffer = 0;
         u32 line0_offset, line1_offset;
         struct videobuf_dmabuf *dma = videobuf_to_dma(&buf->vb);
@@ -617,14 +614,13 @@ int cx25821_buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
                         if (channel_opened >= 0 && channel_opened <= 7) {
                                 if (dev->channels[channel_opened]
                                                 .use_cif_resolution) {
-                                        if (dev->tvnorm & V4L2_STD_PAL_BG
-                                            || dev->tvnorm & V4L2_STD_PAL_DK)
+                                        if (dev->tvnorm & V4L2_STD_PAL_BG ||
+                                            dev->tvnorm & V4L2_STD_PAL_DK)
                                                 bpl_local = 352 << 1;
                                         else
-                                                bpl_local =
-                                                 dev->channels[channel_opened].
-                                                 cif_width <<
-                                                 1;
+                                                bpl_local = dev->channels[
+                                                        channel_opened].
+                                                        cif_width << 1;
                                 }
                         }
                 }
@@ -685,7 +681,7 @@ void cx25821_buffer_release(struct videobuf_queue *q,
                             struct videobuf_buffer *vb)
 {
         struct cx25821_buffer *buf =
-            container_of(vb, struct cx25821_buffer, vb);
+                container_of(vb, struct cx25821_buffer, vb);
 
         cx25821_free_buffer(q, buf);
 }
@@ -723,7 +719,7 @@ int cx25821_video_mmap(struct file *file, struct vm_area_struct *vma)
 static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 {
         struct cx25821_buffer *buf =
-           container_of(vb, struct cx25821_buffer, vb);
+                container_of(vb, struct cx25821_buffer, vb);
         struct cx25821_buffer *prev;
         struct cx25821_fh *fh = vq->priv_data;
         struct cx25821_dev *dev = fh->dev;
@@ -814,7 +810,7 @@ static int video_open(struct file *file)
 
                 for (i = 0; i < MAX_VID_CHANNEL_NUM; i++) {
                         if (h->channels[i].video_dev &&
-                           h->channels[i].video_dev->minor == minor) {
+                            h->channels[i].video_dev->minor == minor) {
                                 dev = h;
                                 ch_id = i;
                                 type  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
@@ -848,11 +844,10 @@ static int video_open(struct file *file)
 
         v4l2_prio_open(&dev->channels[ch_id].prio, &fh->prio);
 
-        videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops,
-                              &dev->pci->dev, &dev->slock,
-                              V4L2_BUF_TYPE_VIDEO_CAPTURE,
-                              V4L2_FIELD_INTERLACED,
-                              sizeof(struct cx25821_buffer), fh, NULL);
+        videobuf_queue_sg_init(&fh->vidq, &cx25821_video_qops, &dev->pci->dev,
+                        &dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
+                        V4L2_FIELD_INTERLACED, sizeof(struct cx25821_buffer),
+                        fh, NULL);
 
         dprintk(1, "post videobuf_queue_init()\n");
         mutex_unlock(&cx25821_devlist_mutex);
@@ -1168,8 +1163,8 @@ int cx25821_vidioc_querycap(struct file *file, void *priv,
         strlcpy(cap->card, cx25821_boards[dev->board].name, sizeof(cap->card));
         sprintf(cap->bus_info, "PCIe:%s", pci_name(dev->pci));
         cap->version = CX25821_VERSION_CODE;
-        cap->capabilities =
-            V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
+        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
+                V4L2_CAP_STREAMING;
         if (UNSET != dev->tuner_type)
                 cap->capabilities |= V4L2_CAP_TUNER;
         return 0;
@@ -1454,38 +1449,38 @@ static const struct v4l2_queryctrl no_ctl = {
 static struct v4l2_queryctrl cx25821_ctls[] = {
         /* --- video --- */
         {
-         .id = V4L2_CID_BRIGHTNESS,
-         .name = "Brightness",
-         .minimum = 0,
-         .maximum = 10000,
-         .step = 1,
-         .default_value = 6200,
-         .type = V4L2_CTRL_TYPE_INTEGER,
-         }, {
-             .id = V4L2_CID_CONTRAST,
-             .name = "Contrast",
-             .minimum = 0,
-             .maximum = 10000,
-             .step = 1,
-             .default_value = 5000,
-             .type = V4L2_CTRL_TYPE_INTEGER,
-             }, {
-                 .id = V4L2_CID_SATURATION,
-                 .name = "Saturation",
-                 .minimum = 0,
-                 .maximum = 10000,
-                 .step = 1,
-                 .default_value = 5000,
-                 .type = V4L2_CTRL_TYPE_INTEGER,
-                 }, {
-                     .id = V4L2_CID_HUE,
-                     .name = "Hue",
-                     .minimum = 0,
-                     .maximum = 10000,
-                     .step = 1,
-                     .default_value = 5000,
-                     .type = V4L2_CTRL_TYPE_INTEGER,
-                     }
+                .id = V4L2_CID_BRIGHTNESS,
+                .name = "Brightness",
+                .minimum = 0,
+                .maximum = 10000,
+                .step = 1,
+                .default_value = 6200,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+        }, {
+                .id = V4L2_CID_CONTRAST,
+                .name = "Contrast",
+                .minimum = 0,
+                .maximum = 10000,
+                .step = 1,
+                .default_value = 5000,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+        }, {
+                .id = V4L2_CID_SATURATION,
+                .name = "Saturation",
+                .minimum = 0,
+                .maximum = 10000,
+                .step = 1,
+                .default_value = 5000,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+        }, {
+                .id = V4L2_CID_HUE,
+                .name = "Hue",
+                .minimum = 0,
+                .maximum = 10000,
+                .step = 1,
+                .default_value = 5000,
+                .type = V4L2_CTRL_TYPE_INTEGER,
+        }
 };
 static const int CX25821_CTLS = ARRAY_SIZE(cx25821_ctls);
 
@@ -1623,7 +1618,8 @@ int cx25821_vidioc_cropcap(struct file *file, void *priv,
 
         if (cropcap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
-        cropcap->bounds.top = cropcap->bounds.left = 0;
+        cropcap->bounds.top = 0;
+        cropcap->bounds.left = 0;
         cropcap->bounds.width = 720;
         cropcap->bounds.height = dev->tvnorm == V4L2_STD_PAL_BG ? 576 : 480;
         cropcap->pixelaspect.numerator =
@@ -1829,8 +1825,11 @@ static long video_ioctl_set(struct file *file, unsigned int cmd,
         struct downstream_user_struct *data_from_user;
         int command;
         int width = 720;
-        int selected_channel = 0, pix_format = 0, i = 0;
-        int cif_enable = 0, cif_width = 0;
+        int selected_channel = 0;
+        int pix_format = 0;
+        int i = 0;
+        int cif_enable = 0;
+        int cif_width = 0;
         u32 value = 0;
 
         data_from_user = (struct downstream_user_struct *)arg;
@@ -1895,8 +1894,8 @@ static long video_ioctl_set(struct file *file, unsigned int cmd,
                 }
 
                 if (selected_channel <= 7 && selected_channel >= 0) {
-                        dev->channels[selected_channel].
-                                use_cif_resolution = cif_enable;
+                        dev->channels[selected_channel].use_cif_resolution =
+                                cif_enable;
                         dev->channels[selected_channel].cif_width = width;
                 } else {
                         for (i = 0; i < VID_CHANNEL_NUM; i++) {
@@ -1932,9 +1931,9 @@ static long video_ioctl_set(struct file *file, unsigned int cmd,
 static long cx25821_video_ioctl(struct file *file,
                                 unsigned int cmd, unsigned long arg)
 {
-        int  ret = 0;
+        int ret = 0;
 
-        struct cx25821_fh  *fh  = file->private_data;
+        struct cx25821_fh *fh = file->private_data;
 
         /* check to see if it's the video upstream */
         if (fh->channel_id == SRAM_CH09) {
diff --git a/drivers/media/video/cx25821/cx25821.h b/drivers/media/video/cx25821/cx25821.h
index 2d2d00932823..b9aa801b00a7 100644
--- a/drivers/media/video/cx25821/cx25821.h
+++ b/drivers/media/video/cx25821/cx25821.h
@@ -67,7 +67,7 @@
 #define MAX_CAMERAS             16
 
 /* Max number of inputs by card */
-#define MAX_CX25821_INPUT 8
+#define MAX_CX25821_INPUT     8
 #define INPUT(nr) (&cx25821_boards[dev->board].input[nr])
 #define RESOURCE_VIDEO0       1
 #define RESOURCE_VIDEO1       2
@@ -85,7 +85,7 @@
 
 #define BUFFER_TIMEOUT     (HZ) /* 0.5 seconds */
 
-#define UNKNOWN_BOARD       0
+#define UNKNOWN_BOARD        0
 #define CX25821_BOARD        1
 
 /* Currently supported by the driver */
diff --git a/drivers/media/video/cx25840/cx25840-audio.c b/drivers/media/video/cx25840/cx25840-audio.c
index 005f11093642..34b96c7cfd62 100644
--- a/drivers/media/video/cx25840/cx25840-audio.c
+++ b/drivers/media/video/cx25840/cx25840-audio.c
@@ -480,7 +480,6 @@ void cx25840_audio_set_path(struct i2c_client *client)
 
 static void set_volume(struct i2c_client *client, int volume)
 {
-        struct cx25840_state *state = to_state(i2c_get_clientdata(client));
         int vol;
 
         /* Convert the volume to msp3400 values (0-127) */
@@ -496,14 +495,7 @@ static void set_volume(struct i2c_client *client, int volume)
         }
 
         /* PATH1_VOLUME */
-        if (is_cx2388x(state)) {
-                /* for cx23885 volume doesn't work,
-                 * the calculation always results in
-                 * e4 regardless.
-                 */
-                cx25840_write(client, 0x8d4, volume);
-        } else
-                cx25840_write(client, 0x8d4, 228 - (vol * 2));
+        cx25840_write(client, 0x8d4, 228 - (vol * 2));
 }
 
 static void set_balance(struct i2c_client *client, int balance)
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index cd9976408ab3..05247d4c340a 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -18,6 +18,9 @@
  * CX2388[578] IRQ handling, IO Pin mux configuration and other small fixes are
  * Copyright (C) 2010 Andy Walls <awalls@md.metrocast.net>
  *
+ * CX23888 DIF support for the HVR1850
+ * Copyright (C) 2011 Steven Toth <stoth@kernellabs.com>
+ *
  * 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
@@ -40,6 +43,7 @@
 #include <linux/videodev2.h>
 #include <linux/i2c.h>
 #include <linux/delay.h>
+#include <linux/math64.h>
 #include <media/v4l2-common.h>
 #include <media/v4l2-chip-ident.h>
 #include <media/cx25840.h>
@@ -80,6 +84,7 @@ MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
 
 
 /* ----------------------------------------------------------------------- */
+static void cx23885_std_setup(struct i2c_client *client);
 
 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
 {
@@ -498,8 +503,13 @@ static void cx23885_initialize(struct i2c_client *client)
                  * 50.0 MHz * (0xb + 0xe8ba26/0x2000000)/4 = 5 * 28.636363 MHz
                  * 572.73 MHz before post divide
                  */
-                cx25840_write4(client, 0x11c, 0x00e8ba26);
-                cx25840_write4(client, 0x118, 0x0000040b);
+                /* HVR1850 or 50MHz xtal */
+                cx25840_write(client, 0x2, 0x71);
+                cx25840_write4(client, 0x11c, 0x01d1744c);
+                cx25840_write4(client, 0x118, 0x00000416);
+                cx25840_write4(client, 0x404, 0x0010253e);
+                cx25840_write4(client, 0x42c, 0x42600000);
+                cx25840_write4(client, 0x44c, 0x161f1000);
                 break;
         case V4L2_IDENT_CX23887_AV:
                 /*
@@ -533,8 +543,18 @@ static void cx23885_initialize(struct i2c_client *client)
          * 28.636363 MHz * (0xf + 0x02be2c9/0x2000000)/4 = 8 * 13.5 MHz
          * 432.0 MHz before post divide
          */
-        cx25840_write4(client, 0x10c, 0x002be2c9);
-        cx25840_write4(client, 0x108, 0x0000040f);
+
+        /* HVR1850 */
+        switch (state->id) {
+        case V4L2_IDENT_CX23888_AV:
+                /* 888/HVR1250 specific */
+                cx25840_write4(client, 0x10c, 0x13333333);
+                cx25840_write4(client, 0x108, 0x00000515);
+                break;
+        default:
+                cx25840_write4(client, 0x10c, 0x002be2c9);
+                cx25840_write4(client, 0x108, 0x0000040f);
+        }
 
         /* Luma */
         cx25840_write4(client, 0x414, 0x00107d12);
@@ -556,8 +576,9 @@ static void cx23885_initialize(struct i2c_client *client)
                  * 368.64 MHz before post divide
                  * 122.88 MHz / 0xa = 12.288 MHz
                  */
-                cx25840_write4(client, 0x114, 0x00bedfa4);
-                cx25840_write4(client, 0x110, 0x000a0307);
+                /* HVR1850  or 50MHz xtal */
+                cx25840_write4(client, 0x114, 0x017dbf48);
+                cx25840_write4(client, 0x110, 0x000a030e);
                 break;
         case V4L2_IDENT_CX23887_AV:
                 /*
@@ -617,7 +638,10 @@ static void cx23885_initialize(struct i2c_client *client)
         finish_wait(&state->fw_wait, &wait);
         destroy_workqueue(q);
 
-        cx25840_std_setup(client);
+        /* Call the cx23885 specific std setup func, we no longer rely on
+         * the generic cx24840 func.
+         */
+        cx23885_std_setup(client);
 
         /* (re)set input */
         set_input(client, state->vid_input, state->aud_input);
@@ -631,6 +655,37 @@ static void cx23885_initialize(struct i2c_client *client)
         /* Disable and clear audio interrupts - we don't use them */
         cx25840_write(client, CX25840_AUD_INT_CTRL_REG, 0xff);
         cx25840_write(client, CX25840_AUD_INT_STAT_REG, 0xff);
+
+        /* CC raw enable */
+        /*  - VIP 1.1 control codes - 10bit, blue field enable.
+         *  - enable raw data during vertical blanking.
+         *  - enable ancillary Data insertion for 656 or VIP.
+         */
+        cx25840_write4(client, 0x404, 0x0010253e);
+
+        /* CC on  - Undocumented Register */
+        cx25840_write(client, 0x42f, 0x66);
+
+        /* HVR-1250 / HVR1850 DIF related */
+        /* Power everything up */
+        cx25840_write4(client, 0x130, 0x0);
+
+        /* Undocumented */
+        cx25840_write4(client, 0x478, 0x6628021F);
+
+        /* AFE_CLK_OUT_CTRL - Select the clock output source as output */
+        cx25840_write4(client, 0x144, 0x5);
+
+        /* I2C_OUT_CTL - I2S output configuration as
+         * Master, Sony, Left justified, left sample on WS=1
+         */
+        cx25840_write4(client, 0x918, 0x1a0);
+
+        /* AFE_DIAG_CTRL1 */
+        cx25840_write4(client, 0x134, 0x000a1800);
+
+        /* AFE_DIAG_CTRL3 - Inverted Polarity for Audio and Video */
+        cx25840_write4(client, 0x13c, 0x00310000);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -945,9 +1000,14 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
                            vid_input <= CX25840_COMPOSITE8);
         u8 is_component = (vid_input & CX25840_COMPONENT_ON) ==
                         CX25840_COMPONENT_ON;
+        u8 is_dif = (vid_input & CX25840_DIF_ON) ==
+                        CX25840_DIF_ON;
+        u8 is_svideo = (vid_input & CX25840_SVIDEO_ON) ==
+                        CX25840_SVIDEO_ON;
         int luma = vid_input & 0xf0;
         int chroma = vid_input & 0xf00;
         u8 reg;
+        u32 val;
 
         v4l_dbg(1, cx25840_debug, client,
                 "decoder set video input %d, audio input %d\n",
@@ -1012,6 +1072,66 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
         else
                 cx25840_and_or(client, 0x401, ~0x6, is_composite ? 0 : 0x02);
 
+        if (is_cx2388x(state)) {
+
+                /* Enable or disable the DIF for tuner use */
+                if (is_dif) {
+                        cx25840_and_or(client, 0x102, ~0x80, 0x80);
+
+                        /* Set of defaults for NTSC and PAL */
+                        cx25840_write4(client, 0x31c, 0xc2262600);
+                        cx25840_write4(client, 0x320, 0xc2262600);
+
+                        /* 18271 IF - Nobody else yet uses a different
+                         * tuner with the DIF, so these are reasonable
+                         * assumptions (HVR1250 and HVR1850 specific).
+                         */
+                        cx25840_write4(client, 0x318, 0xda262600);
+                        cx25840_write4(client, 0x33c, 0x2a24c800);
+                        cx25840_write4(client, 0x104, 0x0704dd00);
+                } else {
+                        cx25840_write4(client, 0x300, 0x015c28f5);
+
+                        cx25840_and_or(client, 0x102, ~0x80, 0);
+                        cx25840_write4(client, 0x340, 0xdf7df83);
+                        cx25840_write4(client, 0x104, 0x0704dd80);
+                        cx25840_write4(client, 0x314, 0x22400600);
+                        cx25840_write4(client, 0x318, 0x40002600);
+                        cx25840_write4(client, 0x324, 0x40002600);
+                        cx25840_write4(client, 0x32c, 0x0250e620);
+                        cx25840_write4(client, 0x39c, 0x01FF0B00);
+
+                        cx25840_write4(client, 0x410, 0xffff0dbf);
+                        cx25840_write4(client, 0x414, 0x00137d03);
+                        cx25840_write4(client, 0x418, 0x01008080);
+                        cx25840_write4(client, 0x41c, 0x00000000);
+                        cx25840_write4(client, 0x420, 0x001c3e0f);
+                        cx25840_write4(client, 0x42c, 0x42600000);
+                        cx25840_write4(client, 0x430, 0x0000039b);
+                        cx25840_write4(client, 0x438, 0x00000000);
+
+                        cx25840_write4(client, 0x440, 0xF8E3E824);
+                        cx25840_write4(client, 0x444, 0x401040dc);
+                        cx25840_write4(client, 0x448, 0xcd3f02a0);
+                        cx25840_write4(client, 0x44c, 0x161f1000);
+                        cx25840_write4(client, 0x450, 0x00000802);
+
+                        cx25840_write4(client, 0x91c, 0x01000000);
+                        cx25840_write4(client, 0x8e0, 0x03063870);
+                        cx25840_write4(client, 0x8d4, 0x7FFF0024);
+                        cx25840_write4(client, 0x8d0, 0x00063073);
+
+                        cx25840_write4(client, 0x8c8, 0x00010000);
+                        cx25840_write4(client, 0x8cc, 0x00080023);
+
+                        /* DIF BYPASS */
+                        cx25840_write4(client, 0x33c, 0x2a04c800);
+                }
+
+                /* Reset the DIF */
+                cx25840_write4(client, 0x398, 0);
+        }
+
         if (!is_cx2388x(state) && !is_cx231xx(state)) {
                 /* Set CH_SEL_ADC2 to 1 if input comes from CH3 */
                 cx25840_and_or(client, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
@@ -1036,6 +1156,33 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
                                 cx25840_and_or(client, 0x102, ~0x2, 0);
                         }
                 }
+
+                /* cx23885 / SVIDEO */
+                if (is_cx2388x(state) && is_svideo) {
+#define AFE_CTRL  (0x104)
+#define MODE_CTRL (0x400)
+                        cx25840_and_or(client, 0x102, ~0x2, 0x2);
+
+                        val = cx25840_read4(client, MODE_CTRL);
+                        val &= 0xFFFFF9FF;
+
+                        /* YC */
+                        val |= 0x00000200;
+                        val &= ~0x2000;
+                        cx25840_write4(client, MODE_CTRL, val);
+
+                        val = cx25840_read4(client, AFE_CTRL);
+
+                        /* Chroma in select */
+                        val |= 0x00001000;
+                        val &= 0xfffffe7f;
+                        /* Clear VGA_SEL_CH2 and VGA_SEL_CH3 (bits 7 and 8).
+                         * This sets them to use video rather than audio.
+                         * Only one of the two will be in use.
+                         */
+                        cx25840_write4(client, AFE_CTRL, val);
+                } else
+                        cx25840_and_or(client, 0x102, ~0x2, 0);
         }
 
         state->vid_input = vid_input;
@@ -1086,6 +1233,23 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
                 cx25840_write4(client, 0x8d0, 0x1f063870);
         }
 
+        if (is_cx2388x(state)) {
+                /* HVR1850 */
+                /* AUD_IO_CTRL - I2S Input, Parallel1*/
+                /*  - Channel 1 src - Parallel1 (Merlin out) */
+                /*  - Channel 2 src - Parallel2 (Merlin out) */
+                /*  - Channel 3 src - Parallel3 (Merlin AC97 out) */
+                /*  - I2S source and dir - Merlin, output */
+                cx25840_write4(client, 0x124, 0x100);
+
+                if (!is_dif) {
+                        /* Stop microcontroller if we don't need it
+                         * to avoid audio popping on svideo/composite use.
+                         */
+                        cx25840_and_or(client, 0x803, ~0x10, 0x00);
+                }
+        }
+
         return 0;
 }
 
@@ -1134,7 +1298,10 @@ static int set_v4lstd(struct i2c_client *client)
         }
         cx25840_and_or(client, 0x400, ~0xf, fmt);
         cx25840_and_or(client, 0x403, ~0x3, pal_m);
-        cx25840_std_setup(client);
+        if (is_cx2388x(state))
+                cx23885_std_setup(client);
+        else
+                cx25840_std_setup(client);
         if (!is_cx2583x(state))
                 input_change(client);
         return 0;
@@ -1539,6 +1706,56 @@ static int cx25840_s_stream(struct v4l2_subdev *sd, int enable)
         return 0;
 }
 
+/* Query the current detected video format */
+static int cx25840_g_std(struct v4l2_subdev *sd, v4l2_std_id *std)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        v4l2_std_id stds[] = {
+                /* 0000 */ V4L2_STD_UNKNOWN,
+
+                /* 0001 */ V4L2_STD_NTSC_M,
+                /* 0010 */ V4L2_STD_NTSC_M_JP,
+                /* 0011 */ V4L2_STD_NTSC_443,
+                /* 0100 */ V4L2_STD_PAL,
+                /* 0101 */ V4L2_STD_PAL_M,
+                /* 0110 */ V4L2_STD_PAL_N,
+                /* 0111 */ V4L2_STD_PAL_Nc,
+                /* 1000 */ V4L2_STD_PAL_60,
+
+                /* 1001 */ V4L2_STD_UNKNOWN,
+                /* 1010 */ V4L2_STD_UNKNOWN,
+                /* 1001 */ V4L2_STD_UNKNOWN,
+                /* 1010 */ V4L2_STD_UNKNOWN,
+                /* 1011 */ V4L2_STD_UNKNOWN,
+                /* 1110 */ V4L2_STD_UNKNOWN,
+                /* 1111 */ V4L2_STD_UNKNOWN
+        };
+
+        u32 fmt = (cx25840_read4(client, 0x40c) >> 8) & 0xf;
+        *std = stds[ fmt ];
+
+        v4l_dbg(1, cx25840_debug, client, "g_std fmt = %x, v4l2_std_id = 0x%x\n",
+                fmt, (unsigned int)stds[ fmt ]);
+
+        return 0;
+}
+
+static int cx25840_g_input_status(struct v4l2_subdev *sd, u32 *status)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+        /* A limited function that checks for signal status and returns
+         * the state.
+         */
+
+        /* Check for status of Horizontal lock (SRC lock isn't reliable) */
+        if ((cx25840_read4(client, 0x40c) & 0x00010000) == 0)
+                *status |= V4L2_IN_ST_NO_SIGNAL;
+
+        return 0;
+}
+
 static int cx25840_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
 {
         struct cx25840_state *state = to_state(sd);
@@ -1565,6 +1782,9 @@ static int cx25840_s_video_routing(struct v4l2_subdev *sd,
         struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
+        if (is_cx2388x(state))
+                cx23885_std_setup(client);
+
         return set_input(client, input, state->aud_input);
 }
 
@@ -1574,6 +1794,8 @@ static int cx25840_s_audio_routing(struct v4l2_subdev *sd,
         struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
+        if (is_cx2388x(state))
+                cx23885_std_setup(client);
         return set_input(client, state->vid_input, input);
 }
 
@@ -1786,6 +2008,3007 @@ static int cx25840_irq_handler(struct v4l2_subdev *sd, u32 status,
 
 /* ----------------------------------------------------------------------- */
 
+#define DIF_PLL_FREQ_WORD       (0x300)
+#define DIF_BPF_COEFF01         (0x348)
+#define DIF_BPF_COEFF23         (0x34c)
+#define DIF_BPF_COEFF45         (0x350)
+#define DIF_BPF_COEFF67         (0x354)
+#define DIF_BPF_COEFF89         (0x358)
+#define DIF_BPF_COEFF1011       (0x35c)
+#define DIF_BPF_COEFF1213       (0x360)
+#define DIF_BPF_COEFF1415       (0x364)
+#define DIF_BPF_COEFF1617       (0x368)
+#define DIF_BPF_COEFF1819       (0x36c)
+#define DIF_BPF_COEFF2021       (0x370)
+#define DIF_BPF_COEFF2223       (0x374)
+#define DIF_BPF_COEFF2425       (0x378)
+#define DIF_BPF_COEFF2627       (0x37c)
+#define DIF_BPF_COEFF2829       (0x380)
+#define DIF_BPF_COEFF3031       (0x384)
+#define DIF_BPF_COEFF3233       (0x388)
+#define DIF_BPF_COEFF3435       (0x38c)
+#define DIF_BPF_COEFF36         (0x390)
+
+void cx23885_dif_setup(struct i2c_client *client, u32 ifHz)
+{
+        u64 pll_freq;
+        u32 pll_freq_word;
+
+        v4l_dbg(1, cx25840_debug, client, "%s(%d)\n", __func__, ifHz);
+
+        /* Assuming TV */
+        /* Calculate the PLL frequency word based on the adjusted ifHz */
+        pll_freq = div_u64((u64)ifHz * 268435456, 50000000);
+        pll_freq_word = (u32)pll_freq;
+
+        cx25840_write4(client, DIF_PLL_FREQ_WORD,  pll_freq_word);
+
+        /* Round down to the nearest 100KHz */
+        ifHz = (ifHz / 100000) * 100000;
+
+        if (ifHz < 3000000)
+                ifHz = 3000000;
+
+        if (ifHz > 16000000)
+                ifHz = 16000000;
+
+        v4l_dbg(1, cx25840_debug, client, "%s(%d) again\n", __func__, ifHz);
+
+        switch (ifHz) {
+        case 3000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00080012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001e0024);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x001bfff8);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffb4ff50);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed8fe68);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe24fe34);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfebaffc7);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d031f);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x04f0065d);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x07010688);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x04c901d6);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe00f9d3);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600f342);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf235f337);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf64efb22);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0105070f);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x0c460fce);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00070012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00220032);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00370026);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xfff0ff91);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff0efe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe01fdcc);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe0afedb);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x00440224);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0434060c);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0738074e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x06090361);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xff99fb39);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fef3b6);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf21af2a5);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf573fa33);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0034067d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x0bfb0fb9);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0004000e);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00200038);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x004c004f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x002fffdf);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff5cfeb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe0dfd92);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd7ffe03);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36010a);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x03410575);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x072607d2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x071804d5);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0134fcb7);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81ff451);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf223f22e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf4a7f94b);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xff6405e8);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x0bae0fa4);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00000008);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001a0036);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0056006d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00670030);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffbdff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe46fd8d);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd25fd4f);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35ffe0);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0224049f);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06c9080e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x07ef0627);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x02c9fe45);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf961f513);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf250f1d2);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf3ecf869);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfe930552);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x0b5f0f8f);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffd0001);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000f002c);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0054007d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0093007c);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0024ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfea6fdbb);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd03fcca);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51feb9);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x00eb0392);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06270802);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08880750);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x044dffdb);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabdf5f8);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2a0f193);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf342f78f);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfdc404b9);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x0b0e0f78);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffafff9);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0002001b);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0046007d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00ad00ba);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00870000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff26fe1a);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd1bfc7e);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fda4);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xffa5025c);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x054507ad);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08dd0847);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x05b80172);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2ef6ff);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf313f170);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf2abf6bd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfcf6041f);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x0abc0f61);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff3);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff50006);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x002f006c);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00b200e3);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00dc007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xffb9fea0);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd6bfc71);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fcb1);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe65010b);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x042d0713);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08ec0906);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x07020302);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaff823);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3a7f16a);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf228f5f5);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfc2a0384);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x0a670f4a);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff7ffef);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe9fff1);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0010004d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00a100f2);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x011a00f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0053ff44);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdedfca2);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fbef);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd39ffae);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x02ea0638);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08b50987);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x08230483);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xff39f960);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf45bf180);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf1b8f537);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfb6102e7);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x0a110f32);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9ffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe1ffdd);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfff00024);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x007c00e5);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013a014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00e6fff8);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe98fd0f);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fb67);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc32fe54);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x01880525);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x083909c7);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x091505ee);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c7fab3);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf52df1b4);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf15df484);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfa9b0249);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x09ba0f19);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 3900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffbfff0);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffcf);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffd1fff6);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x004800be);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x01390184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x016300ac);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff5efdb1);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fb23);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb5cfd0d);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x001703e4);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x077b09c4);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x09d2073c);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0251fc18);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf61cf203);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf118f3dc);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf9d801aa);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x09600eff);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffefff4);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe1ffc8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffbaffca);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x000b0082);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x01170198);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01c10152);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0030fe7b);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fb24);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfac3fbe9);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfea5027f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x0683097f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a560867);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d2fd89);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf723f26f);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0e8f341);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf919010a);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x09060ee5);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0002fffb);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe8ffca);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffacffa4);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffcd0036);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00d70184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01f601dc);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x00ffff60);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fb6d);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa6efaf5);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfd410103);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x055708f9);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a9e0969);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0543ff02);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf842f2f5);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0cef2b2);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf85e006b);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x08aa0ecb);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00050003);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff3ffd3);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffaaff8b);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff95ffe5);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0080014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01fe023f);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01ba0050);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fbf8);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa62fa3b);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfbf9ff7e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x04010836);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0aa90a3d);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x069f007f);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf975f395);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0cbf231);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf7a9ffcb);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x084c0eaf);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0008000a);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0000ffe4);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffb4ff81);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff6aff96);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x001c00f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01d70271);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0254013b);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fcbd);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa9ff9c5);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfadbfdfe);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x028c073b);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a750adf);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e101fa);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfab8f44e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0ddf1be);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf6f9ff2b);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x07ed0e94);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0009000f);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000efff8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9ff87);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff52ff54);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffb5007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01860270);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02c00210);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fdb2);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb22f997);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9f2fc90);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x0102060f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a050b4c);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0902036e);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfc0af51e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf106f15a);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf64efe8b);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x078d0e77);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00080012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0019000e);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5ff9e);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff4fff25);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff560000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0112023b);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f702c0);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfec8);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfbe5f9b3);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf947fb41);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xff7004b9);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x095a0b81);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a0004d8);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfd65f603);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf144f104);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf5aafdec);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x072b0e5a);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00060012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00200022);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0005ffc1);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff61ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff09ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x008601d7);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f50340);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fff0);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfcddfa19);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8e2fa1e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfde30343);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x08790b7f);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad50631);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfec7f6fc);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf198f0bd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf50dfd4e);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x06c90e3d);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0003000f);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00220030);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0025ffed);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff87ff15);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed6ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xffed014c);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02b90386);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03110119);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfdfefac4);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8c6f92f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfc6701b7);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x07670b44);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7e0776);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x002df807);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf200f086);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf477fcb1);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x06650e1e);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xffff0009);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001e0038);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x003f001b);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffbcff36);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec2feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff5600a5);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0248038d);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b00232);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xff39fbab);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8f4f87f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb060020);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x062a0ad2);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf908a3);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0192f922);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf27df05e);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf3e8fc14);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x06000e00);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 4900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffc0002);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00160037);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00510046);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xfff9ff6d);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed0fe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfecefff0);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01aa0356);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413032b);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x007ffcc5);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf96cf812);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf9cefe87);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x04c90a2c);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c4309b4);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x02f3fa4a);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf30ef046);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf361fb7a);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x059b0de0);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fffa);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000a002d);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00570067);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0037ffb5);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfefffe68);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe62ff3d);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x00ec02e3);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x043503f6);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x01befe05);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa27f7ee);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf8c6fcf8);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x034c0954);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c5c0aa4);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x044cfb7e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf3b1f03f);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf2e2fae1);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x05340dc0);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff4);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfffd001e);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0051007b);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x006e0006);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff48fe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe1bfe9a);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x001d023e);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x04130488);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x02e6ff5b);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfb1ef812);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7f7fb7f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x01bc084e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c430b72);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x059afcba);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf467f046);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf26cfa4a);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x04cd0da0);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8ffef);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff00009);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x003f007f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00980056);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffa5feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe00fe15);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff4b0170);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b004d7);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x03e800b9);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfc48f87f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf768fa23);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0022071f);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf90c1b);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x06dafdfd);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf52df05e);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf1fef9b5);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x04640d7f);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9ffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe6fff3);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00250072);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00af009c);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x000cff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe13fdb8);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe870089);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x031104e1);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x04b8020f);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfd98f92f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf71df8f0);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe8805ce);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7e0c9c);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0808ff44);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf603f086);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf19af922);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x03fb0d5e);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffcffef);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe0ffe0);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00050056);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00b000d1);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0071ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe53fd8c);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfddfff99);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x024104a3);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x054a034d);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xff01fa1e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf717f7ed);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfcf50461);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad50cf4);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0921008d);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf6e7f0bd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf13ff891);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x03920d3b);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffffff3);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffd1);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5002f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x009c00ed);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00cb0000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfebafd94);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd61feb0);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d0422);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x05970464);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0074fb41);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf759f721);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfb7502de);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a000d21);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0a2201d4);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf7d9f104);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf0edf804);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x03280d19);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0003fffa);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe3ffc9);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc90002);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x007500ef);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x010e007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff3dfdcf);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd16fddd);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x00440365);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x059b0548);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x01e3fc90);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7dff691);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfa0f014d);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x09020d23);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0b0a0318);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf8d7f15a);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf0a5f779);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x02bd0cf6);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00060001);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffecffc9);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffb4ffd4);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x004000d5);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013600f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xffd3fe39);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd04fd31);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff360277);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x055605ef);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x033efdfe);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf8a5f642);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf8cbffb6);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e10cfb);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0bd50456);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf9dff1be);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf067f6f2);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x02520cd2);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00080009);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff8ffd2);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffaaffac);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x000200a3);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013c014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x006dfec9);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd2bfcb7);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe350165);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x04cb0651);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0477ff7e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf9a5f635);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf7b1fe20);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x069f0ca8);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0c81058b);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfaf0f231);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf033f66d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x01e60cae);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 5900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0009000e);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0005ffe1);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffacff90);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffc5005f);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x01210184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00fcff72);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd8afc77);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51003f);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x04020669);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x05830103);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfad7f66b);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf6c8fc93);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x05430c2b);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d0d06b5);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfc08f2b2);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf00af5ec);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x017b0c89);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00070012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0012fff5);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffbaff82);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff8e000f);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00e80198);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01750028);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe18fc75);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99ff15);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x03050636);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0656027f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfc32f6e2);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf614fb17);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d20b87);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d7707d2);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfd26f341);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xefeaf56f);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x010f0c64);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00050012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001c000b);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffd1ff84);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff66ffbe);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00960184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01cd00da);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfeccfcb2);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fdf9);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x01e005bc);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06e703e4);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfdabf798);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf599f9b3);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x02510abd);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0dbf08df);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfe48f3dc);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xefd5f4f6);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x00a20c3e);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0002000f);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0021001f);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfff0ff97);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff50ff74);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0034014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01fa0179);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff97fd2a);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fcfa);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x00a304fe);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x07310525);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xff37f886);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf55cf86e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c709d0);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0de209db);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xff6df484);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xefcbf481);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0x00360c18);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffe000a);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0021002f);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0010ffb8);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff50ff3b);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffcc00f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01fa01fa);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0069fdd4);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fc26);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xff5d0407);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x07310638);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x00c9f9a8);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf55cf74e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xff3908c3);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0de20ac3);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0093f537);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xefcbf410);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xffca0bf2);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffb0003);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001c0037);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x002fffe2);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff66ff17);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff6a007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01cd0251);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0134fea5);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fb8b);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe2002e0);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06e70713);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x0255faf5);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf599f658);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaf0799);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0dbf0b96);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x01b8f5f5);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xefd5f3a3);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xff5e0bca);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fffb);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00120037);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00460010);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff8eff0f);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff180000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01750276);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01e8ff8d);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fb31);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfcfb0198);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x065607ad);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x03cefc64);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf614f592);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2e0656);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d770c52);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x02daf6bd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xefeaf33b);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfef10ba3);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff7fff5);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0005002f);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0054003c);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffc5ff22);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfedfff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00fc0267);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0276007e);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fb1c);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfbfe003e);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x05830802);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x0529fdec);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf6c8f4fe);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabd04ff);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d0d0cf6);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x03f8f78f);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf00af2d7);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfe850b7b);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff0);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff80020);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00560060);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0002ff4e);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec4ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x006d0225);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02d50166);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fb4e);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb35fee1);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0477080e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x065bff82);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf7b1f4a0);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf9610397);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0c810d80);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0510f869);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf033f278);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfe1a0b52);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffaffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffec000c);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x004c0078);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0040ff8e);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfecafeb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xffd301b6);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02fc0235);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fbc5);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfaaafd90);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x033e07d2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x075b011b);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf8cbf47a);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81f0224);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0bd50def);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0621f94b);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf067f21e);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfdae0b29);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 6900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffdffef);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe3fff6);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0037007f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0075ffdc);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfef2fe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff3d0122);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02ea02dd);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fc79);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa65fc5d);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x01e3074e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x082102ad);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfa0ff48c);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fe00a9);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0b0a0e43);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0729fa33);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf0a5f1c9);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfd430b00);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0001fff3);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffe2);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x001b0076);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x009c002d);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff35fe68);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfeba0076);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x029f0352);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfd60);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa69fb53);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x00740688);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08a7042d);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfb75f4d6);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600ff2d);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0a220e7a);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0827fb22);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf0edf17a);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfcd80ad6);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0004fff9);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe0ffd2);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfffb005e);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00b0007a);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff8ffe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe53ffc1);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0221038c);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fe6e);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfab6fa80);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xff010587);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08e90590);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfcf5f556);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf52bfdb3);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x09210e95);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0919fc15);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf13ff12f);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfc6e0aab);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00070000);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe6ffc9);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffdb0039);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00af00b8);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfff4feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe13ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01790388);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0311ff92);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb48f9ed);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfd980453);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08e306cd);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe88f60a);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf482fc40);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x08080e93);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x09fdfd0c);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf19af0ea);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfc050a81);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00080008);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff0ffc9);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc1000d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x009800e2);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x005bff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe00fe74);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x00b50345);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b000bc);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc18f9a1);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfc4802f9);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x089807dc);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0022f6f0);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf407fada);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x06da0e74);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0ad3fe06);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf1fef0ab);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfb9c0a55);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0008000e);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfffdffd0);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffafffdf);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x006e00f2);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00b8ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe1bfdf8);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xffe302c8);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x041301dc);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd1af99e);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfb1e0183);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x080908b5);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x01bcf801);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3bdf985);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x059a0e38);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0b99ff03);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf26cf071);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfb330a2a);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00070011);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000affdf);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffa9ffb5);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x003700e6);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x01010000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe62fda8);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff140219);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x043502e1);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe42f9e6);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa270000);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x073a0953);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x034cf939);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3a4f845);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x044c0de1);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0c4f0000);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf2e2f03c);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfacc09fe);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00040012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0016fff3);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffafff95);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xfff900c0);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0130007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfecefd89);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe560146);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x041303bc);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xff81fa76);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf96cfe7d);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x063209b1);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x04c9fa93);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3bdf71e);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x02f30d6e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0cf200fd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf361f00e);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfa6509d1);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00010010);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001e0008);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc1ff84);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffbc0084);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013e00f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff56fd9f);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdb8005c);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b00460);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x00c7fb45);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8f4fd07);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x04fa09ce);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x062afc07);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf407f614);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x01920ce0);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0d8301fa);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf3e8efe5);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xfa0009a4);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffd000b);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0022001d);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffdbff82);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff870039);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x012a014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xffedfde7);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd47ff6b);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x031104c6);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0202fc4c);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8c6fbad);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x039909a7);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0767fd8e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf482f52b);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x002d0c39);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0e0002f4);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf477efc2);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf99b0977);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 7900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffa0004);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0020002d);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfffbff91);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff61ffe8);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00f70184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0086fe5c);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd0bfe85);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x024104e5);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0323fd7d);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8e2fa79);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x021d093f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0879ff22);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf52bf465);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfec70b79);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0e6803eb);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf50defa5);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf937094a);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fffd);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00190036);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x001bffaf);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff4fff99);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00aa0198);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0112fef3);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd09fdb9);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d04be);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x041bfecc);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf947f978);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x00900897);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x095a00b9);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600f3c5);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfd650aa3);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0ebc04de);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf5aaef8e);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf8d5091c);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff7fff6);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000e0038);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0037ffd7);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff52ff56);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x004b0184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0186ffa1);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd40fd16);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x00440452);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x04de0029);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9f2f8b2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfefe07b5);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a05024d);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fef34d);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfc0a09b8);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0efa05cd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf64eef7d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf87308ed);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff0);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00000031);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x004c0005);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff6aff27);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffe4014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01d70057);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdacfca6);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff3603a7);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x05610184);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfadbf82e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfd74069f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a7503d6);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81ff2ff);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfab808b9);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0f2306b5);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf6f9ef72);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf81308bf);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffbffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff30022);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00560032);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff95ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff8000f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01fe0106);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe46fc71);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe3502c7);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x059e02ce);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfbf9f7f2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfbff055b);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0aa9054c);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf961f2db);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf97507aa);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0f350797);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf7a9ef6d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf7b40890);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffeffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe8000f);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00540058);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffcdff14);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff29007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01f6019e);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff01fc7c);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd5101bf);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x059203f6);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfd41f7fe);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfaa903f3);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a9e06a9);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabdf2e2);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf842068b);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0f320871);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf85eef6e);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf7560860);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0002fff2);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe1fff9);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00460073);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x000bff34);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfee90000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01c10215);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xffd0fcc5);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99009d);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x053d04f1);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfea5f853);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf97d0270);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a5607e4);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2ef314);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf723055f);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0f180943);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf919ef75);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf6fa0830);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0005fff8);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffe4);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x002f007f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0048ff6b);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec7ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0163025f);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x00a2fd47);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17ff73);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x04a405b2);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0017f8ed);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf88500dc);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x09d208f9);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaff370);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf61c0429);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0ee80a0b);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xf9d8ef82);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf6a00800);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0007ffff);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe1ffd4);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0010007a);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x007cffb2);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec6ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00e60277);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0168fdf9);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fe50);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x03ce0631);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0188f9c8);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7c7ff43);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x091509e3);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xff39f3f6);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf52d02ea);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0ea30ac9);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfa9bef95);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf64607d0);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00090007);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe9ffca);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfff00065);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00a10003);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfee6feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0053025b);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0213fed0);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3fd46);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x02c70668);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x02eafadb);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf74bfdae);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x08230a9c);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c7f4a3);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf45b01a6);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0e480b7c);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfb61efae);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf5ef079f);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 8900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0008000d);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff5ffc8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffd10043);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00b20053);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff24fe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xffb9020c);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0295ffbb);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fc64);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x019b0654);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x042dfc1c);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf714fc2a);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x07020b21);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0251f575);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3a7005e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0dd80c24);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfc2aefcd);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf599076e);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00060011);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0002ffcf);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffba0018);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00ad009a);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff79fe68);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff260192);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02e500ab);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fbb6);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x005b05f7);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0545fd81);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf723fabf);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x05b80b70);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d2f669);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf313ff15);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0d550cbf);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfcf6eff2);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf544073d);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00030012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000fffdd);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffacffea);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x009300cf);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffdcfe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfea600f7);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02fd0190);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fb46);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xff150554);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0627fefd);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf778f978);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x044d0b87);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0543f77d);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2a0fdcf);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0cbe0d4e);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfdc4f01d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4f2070b);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00000010);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001afff0);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffaaffbf);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x006700ed);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0043feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe460047);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02db0258);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fb1b);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfddc0473);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06c90082);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf811f85e);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x02c90b66);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x069ff8ad);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf250fc8d);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0c140dcf);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfe93f04d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4a106d9);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffc000c);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00200006);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffb4ff9c);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x002f00ef);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00a4ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe0dff92);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x028102f7);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fb37);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfcbf035e);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x07260202);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf8e8f778);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x01340b0d);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e1f9f4);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf223fb51);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0b590e42);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xff64f083);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf45206a7);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff90005);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0022001a);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9ff86);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xfff000d7);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00f2ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe01fee5);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01f60362);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fb99);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfbcc0222);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x07380370);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf9f7f6cc);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xff990a7e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0902fb50);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf21afa1f);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0a8d0ea6);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0034f0bf);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4050675);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fffe);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001e002b);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5ff81);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffb400a5);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x01280000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe24fe50);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01460390);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfc3a);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb1000ce);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x070104bf);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb37f65f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe0009bc);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a00fcbb);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf235f8f8);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x09b20efc);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0105f101);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf3ba0642);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0001ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff7);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00150036);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0005ff8c);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff810061);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013d007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe71fddf);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x007c0380);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fd13);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa94ff70);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x068005e2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfc9bf633);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfc7308ca);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad5fe30);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf274f7e0);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x08c90f43);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x01d4f147);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf371060f);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fff1);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00090038);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0025ffa7);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff5e0012);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013200f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfee3fd9b);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xffaa0331);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0311fe15);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa60fe18);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x05bd06d1);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfe1bf64a);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfafa07ae);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7effab);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2d5f6d7);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x07d30f7a);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x02a3f194);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf32905dc);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffcffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfffb0032);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x003fffcd);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff4effc1);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0106014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff6efd8a);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfedd02aa);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b0ff34);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa74fcd7);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x04bf0781);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xffaaf6a3);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf99e066b);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf90128);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf359f5e1);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x06d20fa2);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0370f1e5);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2e405a8);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 9900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xffffffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffef0024);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0051fffa);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff54ff77);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00be0184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0006fdad);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe2701f3);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413005e);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfad1fbba);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x039007ee);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x013bf73d);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf868050a);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c4302a1);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3fdf4fe);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x05c70fba);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x043bf23c);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2a10575);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0003fff1);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe50011);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00570027);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff70ff3c);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00620198);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x009efe01);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd95011a);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x04350183);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb71fad0);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x023c0812);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x02c3f811);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf75e0390);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c5c0411);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf4c1f432);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x04b30fc1);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0503f297);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2610541);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0006fff7);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdffffc);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00510050);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff9dff18);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfffc0184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0128fe80);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd32002e);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x04130292);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc4dfa21);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x00d107ee);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x0435f91c);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf6850205);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c430573);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf5a1f37d);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x03990fba);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x05c7f2f8);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf222050d);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0008fffe);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdfffe7);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x003f006e);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffd6ff0f);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff96014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0197ff1f);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd05ff3e);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b0037c);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd59f9b7);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xff5d0781);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x0585fa56);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf5e4006f);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf906c4);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf69df2e0);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x02790fa2);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0688f35d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf1e604d8);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00090005);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe4ffd6);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0025007e);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0014ff20);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff3c00f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01e1ffd0);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd12fe5c);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03110433);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe88f996);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfdf106d1);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x06aafbb7);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf57efed8);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7e07ff);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf7b0f25e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x01560f7a);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0745f3c7);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf1ac04a4);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0008000c);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffedffcb);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0005007d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0050ff4c);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfef6007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01ff0086);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd58fd97);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x024104ad);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xffcaf9c0);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfc9905e2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x079afd35);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf555fd46);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad50920);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf8d9f1f6);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x00310f43);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x07fdf435);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf174046f);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xfffffffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00050011);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfffaffc8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5006b);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0082ff8c);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfecc0000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01f00130);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdd2fcfc);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d04e3);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x010efa32);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfb6404bf);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x084efec5);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf569fbc2);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a000a23);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfa15f1ab);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xff0b0efc);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x08b0f4a7);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf13f043a);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00020012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0007ffcd);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9004c);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00a4ffd9);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec3ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01b401c1);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe76fc97);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x004404d2);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0245fae8);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa5f0370);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08c1005f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf5bcfa52);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x09020b04);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfb60f17b);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfde70ea6);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x095df51e);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf10c0405);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xffff0011);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0014ffdb);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffb40023);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00b2002a);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfedbff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0150022d);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff38fc6f);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36047b);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x035efbda);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9940202);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08ee01f5);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf649f8fe);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e10bc2);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfcb6f169);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfcc60e42);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0a04f599);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0db03d0);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffb000d);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001dffed);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffaafff5);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00aa0077);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff13feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00ce026b);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x000afc85);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe3503e3);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x044cfcfb);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf90c0082);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08d5037f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf710f7cc);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x069f0c59);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfe16f173);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfbaa0dcf);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0aa5f617);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0ad039b);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 10900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff90006);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00210003);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffacffc8);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x008e00b6);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff63fe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x003a0275);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x00dafcda);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd510313);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0501fe40);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8cbfefd);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x087604f0);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf80af6c2);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x05430cc8);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xff7af19a);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfa940d4e);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0b3ff699);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0810365);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0001ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8ffff);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00210018);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffbaffa3);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x006000e1);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffc4fe68);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xffa0024b);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x019afd66);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc990216);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0575ff99);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8d4fd81);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x07d40640);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf932f5e6);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d20d0d);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x00dff1de);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf9860cbf);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0bd1f71e);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf058032f);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff8);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001b0029);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffd1ff8a);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x002600f2);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x002cfe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff0f01f0);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x023bfe20);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc1700fa);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x05a200f7);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf927fc1c);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x06f40765);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfa82f53b);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x02510d27);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0243f23d);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf8810c24);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0c5cf7a7);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf03102fa);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffafff2);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00110035);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfff0ff81);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffe700e7);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x008ffeb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe94016d);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02b0fefb);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3ffd1);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x05850249);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9c1fadb);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x05de0858);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfbf2f4c4);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c70d17);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x03a0f2b8);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf7870b7c);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0cdff833);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf00d02c4);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffdffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00040038);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0010ff88);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffac00c2);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00e2ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe3900cb);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f1ffe9);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3feaa);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x05210381);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa9cf9c8);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x04990912);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfd7af484);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xff390cdb);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x04f4f34d);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf69a0ac9);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0d5af8c1);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xefec028e);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0000ffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff60033);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x002fff9f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff7b0087);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x011eff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe080018);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f900d8);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17fd96);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x04790490);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfbadf8ed);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x032f098e);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xff10f47d);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaf0c75);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x063cf3fc);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf5ba0a0b);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0dccf952);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xefcd0258);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0004fff1);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffea0026);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0046ffc3);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff5a003c);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013b0000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe04ff63);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02c801b8);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fca6);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0397056a);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfcecf853);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x01ad09c9);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x00acf4ad);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2e0be7);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0773f4c2);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf4e90943);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0e35f9e6);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xefb10221);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0007fff6);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe20014);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0054ffee);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff4effeb);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0137007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe2efebb);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0260027a);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fbe6);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x02870605);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfe4af7fe);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x001d09c1);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0243f515);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabd0b32);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0897f59e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf4280871);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0e95fa7c);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef9701eb);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0008fffd);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdeffff);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0056001d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff57ff9c);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x011300f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe82fe2e);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01ca0310);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fb62);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0155065a);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xffbaf7f2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfe8c0977);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x03cef5b2);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf9610a58);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x09a5f68f);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf3790797);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0eebfb14);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef8001b5);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00080004);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe0ffe9);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x004c0047);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff75ff58);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00d1014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfef9fdc8);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0111036f);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fb21);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x00120665);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x012df82e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfd0708ec);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0542f682);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81f095c);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0a9af792);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf2db06b5);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0f38fbad);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef6c017e);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 11900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0007000b);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe7ffd8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00370068);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffa4ff28);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00790184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff87fd91);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x00430392);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fb26);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfece0626);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0294f8b2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb990825);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0698f77f);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fe0842);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0b73f8a7);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf25105cd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0f7bfc48);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef5a0148);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00050010);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff2ffcc);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x001b007b);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffdfff10);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00140198);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0020fd8e);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff710375);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfb73);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd9a059f);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x03e0f978);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfa4e0726);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x07c8f8a7);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600070c);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0c2ff9c9);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf1db04de);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0fb4fce5);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef4b0111);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00010012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffffffc8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfffb007e);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x001dff14);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffad0184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00b7fdbe);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfea9031b);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fc01);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc8504d6);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0504fa79);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf93005f6);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x08caf9f2);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf52b05c0);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0ccbfaf9);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf17903eb);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0fe3fd83);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef3f00db);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffe0011);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000cffcc);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffdb0071);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0058ff32);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff4f014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x013cfe1f);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdfb028a);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0311fcc9);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb9d03d6);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x05f4fbad);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf848049d);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0999fb5b);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf4820461);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d46fc32);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf12d02f4);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x1007fe21);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef3600a4);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffa000e);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0017ffd9);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc10055);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0088ff68);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff0400f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01a6fea7);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd7501cc);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b0fdc0);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfaef02a8);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06a7fd07);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf79d0326);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a31fcda);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf40702f3);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d9ffd72);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0f601fa);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x1021fec0);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef2f006d);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0001ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80007);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001fffeb);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffaf002d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00a8ffb0);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed3007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01e9ff4c);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd2000ee);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413fed8);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa82015c);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0715fe7d);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7340198);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a8dfe69);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3bd017c);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0dd5feb8);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0d500fd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x1031ff60);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef2b0037);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff70000);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00220000);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffa90000);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00b30000);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec20000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x02000000);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd030000);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x04350000);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa5e0000);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x073b0000);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7110000);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0aac0000);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3a40000);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0de70000);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0c90000);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x10360000);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef290000);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff8fff9);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001f0015);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffafffd3);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00a80050);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfed3ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01e900b4);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd20ff12);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x04130128);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa82fea4);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x07150183);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf734fe68);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a8d0197);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf3bdfe84);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0dd50148);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0d5ff03);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x103100a0);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef2bffc9);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffafff2);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00170027);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc1ffab);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00880098);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff04ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01a60159);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd75fe34);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b00240);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfaeffd58);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06a702f9);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf79dfcda);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0a310326);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf407fd0d);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d9f028e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf0f6fe06);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x10210140);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef2fff93);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffeffef);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000c0034);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffdbff8f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x005800ce);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff4ffeb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x013c01e1);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdfbfd76);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03110337);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb9dfc2a);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x05f40453);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf848fb63);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x099904a5);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf482fb9f);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0d4603ce);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf12dfd0c);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x100701df);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef36ff5c);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 12900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0001ffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffff0038);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfffbff82);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x001d00ec);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffadfe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00b70242);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfea9fce5);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x024103ff);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc85fb2a);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x05040587);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf930fa0a);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x08ca060e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf52bfa40);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0ccb0507);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf179fc15);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0fe3027d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef3fff25);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0005fff0);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff20034);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x001bff85);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffdf00f0);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0014fe68);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00200272);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff71fc8b);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d048d);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd9afa61);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x03e00688);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfa4ef8da);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x07c80759);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf600f8f4);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0c2f0637);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf1dbfb22);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0fb4031b);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef4bfeef);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0007fff5);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe70028);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0037ff98);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffa400d8);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0079fe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff87026f);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0043fc6e);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x004404da);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfecef9da);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0294074e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb99f7db);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x06980881);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf6fef7be);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0b730759);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf251fa33);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0f7b03b8);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef5afeb8);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0008fffc);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe00017);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x004cffb9);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff7500a8);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00d1feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfef90238);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0111fc91);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff3604df);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0012f99b);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x012d07d2);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfd07f714);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0542097e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf81ff6a4);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x0a9a086e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf2dbf94b);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0f380453);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef6cfe82);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00080003);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffde0001);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0056ffe3);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff570064);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0113ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe8201d2);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01cafcf0);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35049e);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0155f9a6);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xffba080e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfe8cf689);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x03ce0a4e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xf961f5a8);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x09a50971);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf379f869);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0eeb04ec);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef80fe4b);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0007000a);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe2ffec);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00540012);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff4e0015);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0137ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe2e0145);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0260fd86);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51041a);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0287f9fb);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfe4a0802);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x001df63f);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x02430aeb);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfabdf4ce);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x08970a62);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf428f78f);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0e950584);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xef97fe15);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0004000f);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffeaffda);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0046003d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff5affc4);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013b0000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe04009d);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02c8fe48);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99035a);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0397fa96);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfcec07ad);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x01adf637);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x00ac0b53);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfc2ef419);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x07730b3e);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf4e9f6bd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0e35061a);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xefb1fddf);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00000012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfff6ffcd);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x002f0061);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff7bff79);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x011e007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe08ffe8);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f9ff28);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17026a);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0479fb70);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfbad0713);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x032ff672);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xff100b83);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xfdaff38b);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x063c0c04);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf5baf5f5);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0dcc06ae);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xefcdfda8);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffd0012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0004ffc8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00100078);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffacff3e);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00e200f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe39ff35);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02f10017);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd30156);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0521fc7f);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa9c0638);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x0499f6ee);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfd7a0b7c);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0xff39f325);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x04f40cb3);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf69af537);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0d5a073f);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xefecfd72);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0001fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffa000e);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0011ffcb);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xfff0007f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffe7ff19);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x008f014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe94fe93);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02b00105);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfbd3002f);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x0585fdb7);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf9c10525);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x05def7a8);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfbf20b3c);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x00c7f2e9);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x03a00d48);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf787f484);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0cdf07cd);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf00dfd3c);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 13900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010000);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80008);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001bffd7);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffd10076);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0026ff0e);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x002c0184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff0ffe10);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x023b01e0);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc17ff06);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x05a2ff09);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf92703e4);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x06f4f89b);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfa820ac5);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0251f2d9);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x02430dc3);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf881f3dc);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0c5c0859);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf031fd06);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80001);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0021ffe8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffba005d);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0060ff1f);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffc40198);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xffa0fdb5);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x019a029a);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99fdea);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x05750067);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8d4027f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x07d4f9c0);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf9320a1a);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d2f2f3);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0x00df0e22);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xf986f341);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0bd108e2);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf058fcd1);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fffa);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0021fffd);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffac0038);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x008eff4a);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff630184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x003afd8b);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x00da0326);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd51fced);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x050101c0);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf8cb0103);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x0876fb10);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf80a093e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0543f338);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xff7a0e66);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfa94f2b2);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0b3f0967);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf081fc9b);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffbfff3);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001d0013);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffaa000b);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00aaff89);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff13014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00cefd95);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x000a037b);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe35fc1d);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x044c0305);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf90cff7e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08d5fc81);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf7100834);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x069ff3a7);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfe160e8d);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfbaaf231);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0aa509e9);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0adfc65);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xffffffef);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00140025);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffb4ffdd);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00b2ffd6);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfedb00f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x0150fdd3);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xff380391);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff36fb85);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x035e0426);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xf994fdfe);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08eefe0b);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf6490702);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e1f43e);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfcb60e97);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfcc6f1be);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x0a040a67);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf0dbfc30);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0002ffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00070033);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9ffb4);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00a40027);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfec3007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01b4fe3f);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe760369);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0044fb2e);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x02450518);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfa5ffc90);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x08c1ffa1);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf5bc05ae);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0902f4fc);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfb600e85);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xfde7f15a);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x095d0ae2);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf10cfbfb);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0005ffef);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfffa0038);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5ff95);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00820074);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfecc0000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01f0fed0);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfdd20304);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014dfb1d);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x010e05ce);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfb64fb41);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x084e013b);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf569043e);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a00f5dd);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xfa150e55);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0xff0bf104);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x08b00b59);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf13ffbc6);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0008fff4);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffed0035);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0005ff83);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x005000b4);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfef6ff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01ffff7a);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd580269);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0241fb53);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xffca0640);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfc99fa1e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x079a02cb);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf55502ba);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad5f6e0);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf8d90e0a);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0031f0bd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x07fd0bcb);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf174fb91);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffffffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0009fffb);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe4002a);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0025ff82);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x001400e0);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff3cff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01e10030);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd1201a4);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0311fbcd);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfe88066a);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xfdf1f92f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x06aa0449);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf57e0128);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7ef801);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf7b00da2);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0156f086);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x07450c39);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf1acfb5c);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00080002);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdf0019);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x003fff92);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffd600f1);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff96feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x019700e1);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd0500c2);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b0fc84);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfd590649);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0xff5df87f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x058505aa);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf5e4ff91);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf9f93c);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf69d0d20);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0279f05e);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x06880ca3);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf1e6fb28);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 14900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x00060009);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffdf0004);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0051ffb0);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff9d00e8);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xfffcfe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x01280180);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd32ffd2);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413fd6e);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfc4d05df);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x00d1f812);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x043506e4);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf685fdfb);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c43fa8d);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf5a10c83);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0399f046);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x05c70d08);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf222faf3);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0003000f);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffe5ffef);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x0057ffd9);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff7000c4);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0062fe68);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x009e01ff);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfd95fee6);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0435fe7d);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb710530);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x023cf7ee);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x02c307ef);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf75efc70);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c5cfbef);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf4c10bce);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x04b3f03f);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x05030d69);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf261fabf);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15100000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0000fffd);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xffff0012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xffefffdc);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00510006);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff540089);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00befe7c);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0x00060253);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfe27fe0d);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x0413ffa2);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfad10446);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0390f812);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0x013b08c3);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf868faf6);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0c43fd5f);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3fd0b02);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x05c7f046);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x043b0dc4);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2a1fa8b);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15200000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0001fffe);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffc0012);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0xfffbffce);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x003f0033);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff4e003f);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0106feb6);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff6e0276);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xfeddfd56);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x03b000cc);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa740329);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x04bff87f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xffaa095d);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xf99ef995);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0bf9fed8);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf3590a1f);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x06d2f05e);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x03700e1b);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf2e4fa58);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15300000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x0001ffff);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9000f);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0009ffc8);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00250059);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff5effee);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0132ff10);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfee30265);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0xffaafccf);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x031101eb);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa6001e8);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x05bdf92f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfe1b09b6);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfafaf852);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0b7e0055);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2d50929);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x07d3f086);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x02a30e6c);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf329fa24);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15400000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00010001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80009);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0015ffca);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0x00050074);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xff81ff9f);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x013dff82);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe710221);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x007cfc80);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x024102ed);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfa940090);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0680fa1e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfc9b09cd);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfc73f736);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0ad501d0);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2740820);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x08c9f0bd);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x01d40eb9);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf371f9f1);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15500000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff80002);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001effd5);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffe5007f);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xffb4ff5b);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x01280000);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe2401b0);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0146fc70);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x014d03c6);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfb10ff32);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0701fb41);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xfb3709a1);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xfe00f644);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x0a000345);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2350708);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x09b2f104);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x01050eff);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf3baf9be);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15600000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfff9fffb);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0022ffe6);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffc9007a);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0xfff0ff29);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00f2007e);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe01011b);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x01f6fc9e);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0x00440467);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfbccfdde);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0738fc90);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf9f70934);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0xff99f582);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x090204b0);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf21a05e1);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0a8df15a);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0x00340f41);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf405f98b);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15700000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0xfffcfff4);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x0020fffa);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffb40064);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x002fff11);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x00a400f0);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe0d006e);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x0281fd09);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xff3604c9);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfcbffca2);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0726fdfe);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf8e80888);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x0134f4f3);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x07e1060c);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf22304af);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0b59f1be);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xff640f7d);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf452f959);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15800000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0x00000003);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0000fff0);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x001a0010);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffaa0041);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0067ff13);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0x0043014a);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfe46ffb9);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02dbfda8);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfe3504e5);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xfddcfb8d);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06c9ff7e);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf81107a2);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x02c9f49a);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x069f0753);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2500373);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0c14f231);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfe930fb3);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4a1f927);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 15900000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0002);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0003ffee);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x000f0023);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffac0016);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x0093ff31);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xffdc0184);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xfea6ff09);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02fdfe70);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfd5104ba);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0xff15faac);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x06270103);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7780688);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x044df479);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x05430883);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf2a00231);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0cbef2b2);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfdc40fe3);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf4f2f8f5);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+
+        case 16000000:
+                cx25840_write4(client, DIF_BPF_COEFF01, 0xffff0001);
+                cx25840_write4(client, DIF_BPF_COEFF23, 0x0006ffef);
+                cx25840_write4(client, DIF_BPF_COEFF45, 0x00020031);
+                cx25840_write4(client, DIF_BPF_COEFF67, 0xffbaffe8);
+                cx25840_write4(client, DIF_BPF_COEFF89, 0x00adff66);
+                cx25840_write4(client, DIF_BPF_COEFF1011, 0xff790198);
+                cx25840_write4(client, DIF_BPF_COEFF1213, 0xff26fe6e);
+                cx25840_write4(client, DIF_BPF_COEFF1415, 0x02e5ff55);
+                cx25840_write4(client, DIF_BPF_COEFF1617, 0xfc99044a);
+                cx25840_write4(client, DIF_BPF_COEFF1819, 0x005bfa09);
+                cx25840_write4(client, DIF_BPF_COEFF2021, 0x0545027f);
+                cx25840_write4(client, DIF_BPF_COEFF2223, 0xf7230541);
+                cx25840_write4(client, DIF_BPF_COEFF2425, 0x05b8f490);
+                cx25840_write4(client, DIF_BPF_COEFF2627, 0x03d20997);
+                cx25840_write4(client, DIF_BPF_COEFF2829, 0xf31300eb);
+                cx25840_write4(client, DIF_BPF_COEFF3031, 0x0d55f341);
+                cx25840_write4(client, DIF_BPF_COEFF3233, 0xfcf6100e);
+                cx25840_write4(client, DIF_BPF_COEFF3435, 0xf544f8c3);
+                cx25840_write4(client, DIF_BPF_COEFF36, 0x110d0000);
+                break;
+        }
+}
+
+static void cx23885_std_setup(struct i2c_client *client)
+{
+        struct cx25840_state *state = to_state(i2c_get_clientdata(client));
+        v4l2_std_id std = state->std;
+        u32 ifHz;
+
+        cx25840_write4(client, 0x478, 0x6628021F);
+        cx25840_write4(client, 0x400, 0x0);
+        cx25840_write4(client, 0x4b4, 0x20524030);
+        cx25840_write4(client, 0x47c, 0x010a8263);
+
+        if (std & V4L2_STD_NTSC) {
+                v4l_dbg(1, cx25840_debug, client, "%s() Selecting NTSC",
+                        __func__);
+
+                /* Horiz / vert timing */
+                cx25840_write4(client, 0x428, 0x1e1e601a);
+                cx25840_write4(client, 0x424, 0x5b2d007a);
+
+                /* DIF NTSC */
+                cx25840_write4(client, 0x304, 0x6503bc0c);
+                cx25840_write4(client, 0x308, 0xbd038c85);
+                cx25840_write4(client, 0x30c, 0x1db4640a);
+                cx25840_write4(client, 0x310, 0x00008800);
+                cx25840_write4(client, 0x314, 0x44400400);
+                cx25840_write4(client, 0x32c, 0x0c800800);
+                cx25840_write4(client, 0x330, 0x27000100);
+                cx25840_write4(client, 0x334, 0x1f296e1f);
+                cx25840_write4(client, 0x338, 0x009f50c1);
+                cx25840_write4(client, 0x340, 0x1befbf06);
+                cx25840_write4(client, 0x344, 0x000035e8);
+
+                /* DIF I/F */
+                ifHz = 5400000;
+
+        } else {
+                v4l_dbg(1, cx25840_debug, client, "%s() Selecting PAL-BG",
+                        __func__);
+
+                /* Horiz / vert timing */
+                cx25840_write4(client, 0x428, 0x28244024);
+                cx25840_write4(client, 0x424, 0x5d2d0084);
+
+                /* DIF */
+                cx25840_write4(client, 0x304, 0x6503bc0c);
+                cx25840_write4(client, 0x308, 0xbd038c85);
+                cx25840_write4(client, 0x30c, 0x1db4640a);
+                cx25840_write4(client, 0x310, 0x00008800);
+                cx25840_write4(client, 0x314, 0x44400600);
+                cx25840_write4(client, 0x32c, 0x0c800800);
+                cx25840_write4(client, 0x330, 0x27000100);
+                cx25840_write4(client, 0x334, 0x213530ec);
+                cx25840_write4(client, 0x338, 0x00a65ba8);
+                cx25840_write4(client, 0x340, 0x1befbf06);
+                cx25840_write4(client, 0x344, 0x000035e8);
+
+                /* DIF I/F */
+                ifHz = 6000000;
+        }
+
+        cx23885_dif_setup(client, ifHz);
+
+        /* Explicitly ensure the inputs are reconfigured after
+         * a standard change.
+         */
+        set_input(client, state->vid_input, state->aud_input);
+}
+
+/* ----------------------------------------------------------------------- */
+
 static const struct v4l2_ctrl_ops cx25840_ctrl_ops = {
         .s_ctrl = cx25840_s_ctrl,
 };
@@ -1801,6 +5024,7 @@ static const struct v4l2_subdev_core_ops cx25840_core_ops = {
         .queryctrl = v4l2_subdev_queryctrl,
         .querymenu = v4l2_subdev_querymenu,
         .s_std = cx25840_s_std,
+        .g_std = cx25840_g_std,
         .reset = cx25840_reset,
         .load_fw = cx25840_load_fw,
         .s_io_pin_config = common_s_io_pin_config,
@@ -1828,6 +5052,7 @@ static const struct v4l2_subdev_video_ops cx25840_video_ops = {
         .s_routing = cx25840_s_video_routing,
         .s_mbus_fmt = cx25840_s_mbus_fmt,
         .s_stream = cx25840_s_stream,
+        .g_input_status = cx25840_g_input_status,
 };
 
 static const struct v4l2_subdev_vbi_ops cx25840_vbi_ops = {
diff --git a/drivers/media/video/cx88/Kconfig b/drivers/media/video/cx88/Kconfig
index 5c42abdf422f..3598dc087b08 100644
--- a/drivers/media/video/cx88/Kconfig
+++ b/drivers/media/video/cx88/Kconfig
@@ -70,11 +70,6 @@ config VIDEO_CX88_DVB
           To compile this driver as a module, choose M here: the
           module will be called cx88-dvb.
 
-config VIDEO_CX88_MPEG
-        tristate
-        depends on VIDEO_CX88_DVB || VIDEO_CX88_BLACKBIRD
-        default y
-
 config VIDEO_CX88_VP3054
         tristate "VP-3054 Secondary I2C Bus Support"
         default m
@@ -84,3 +79,8 @@ config VIDEO_CX88_VP3054
           Conexant 2388x chip and the MT352 demodulator,
           which also require support for the VP-3054
           Secondary I2C bus, such at DNTV Live! DVB-T Pro.
+
+config VIDEO_CX88_MPEG
+        tristate
+        depends on VIDEO_CX88_DVB || VIDEO_CX88_BLACKBIRD
+        default y
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index 0d719faafd8a..62c7ad050f9b 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -1306,7 +1306,7 @@ static const struct cx88_board cx88_boards[] = {
         },
         [CX88_BOARD_WINFAST_DTV2000H_J] = {
                 .name           = "WinFast DTV2000 H rev. J",
-                .tuner_type     = TUNER_PHILIPS_FMD1216ME_MK3,
+                .tuner_type     = TUNER_PHILIPS_FMD1216MEX_MK3,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
@@ -1643,6 +1643,78 @@ static const struct cx88_board cx88_boards[] = {
                         .gpio3  = 0x0000,
                 },
         },
+        [CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36] = {
+                .name           = "Leadtek TV2000 XP Global (SC4100)",
+                .tuner_type     = TUNER_XC4000,
+                .tuner_addr     = 0x61,
+                .radio_type     = UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .input          = { {
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
+                        .gpio1  = 0x0000,
+                        .gpio2  = 0x0C04,       /* pin 18 = 1, pin 19 = 0 */
+                        .gpio3  = 0x0000,
+                }, {
+                        .type   = CX88_VMUX_COMPOSITE1,
+                        .vmux   = 1,
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
+                        .gpio1  = 0x0000,
+                        .gpio2  = 0x0C0C,       /* pin 18 = 1, pin 19 = 1 */
+                        .gpio3  = 0x0000,
+                }, {
+                        .type   = CX88_VMUX_SVIDEO,
+                        .vmux   = 2,
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
+                        .gpio1  = 0x0000,
+                        .gpio2  = 0x0C0C,       /* pin 18 = 1, pin 19 = 1 */
+                        .gpio3  = 0x0000,
+                } },
+                .radio = {
+                        .type   = CX88_RADIO,
+                        .gpio0  = 0x0400,        /* pin 2 = 0 */
+                        .gpio1  = 0x0000,
+                        .gpio2  = 0x0C00,       /* pin 18 = 0, pin 19 = 0 */
+                        .gpio3  = 0x0000,
+                },
+        },
+        [CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43] = {
+                .name           = "Leadtek TV2000 XP Global (XC4100)",
+                .tuner_type     = TUNER_XC4000,
+                .tuner_addr     = 0x61,
+                .radio_type     = UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .input          = { {
+                        .type   = CX88_VMUX_TELEVISION,
+                        .vmux   = 0,
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
+                        .gpio1  = 0x6040,       /* pin 14 = 1, pin 13 = 0 */
+                        .gpio2  = 0x0000,
+                        .gpio3  = 0x0000,
+                }, {
+                        .type   = CX88_VMUX_COMPOSITE1,
+                        .vmux   = 1,
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
+                        .gpio1  = 0x6060,       /* pin 14 = 1, pin 13 = 1 */
+                        .gpio2  = 0x0000,
+                        .gpio3  = 0x0000,
+                }, {
+                        .type   = CX88_VMUX_SVIDEO,
+                        .vmux   = 2,
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
+                        .gpio1  = 0x6060,       /* pin 14 = 1, pin 13 = 1 */
+                        .gpio2  = 0x0000,
+                        .gpio3  = 0x0000,
+                } },
+                .radio = {
+                        .type   = CX88_RADIO,
+                        .gpio0  = 0x0400,        /* pin 2 = 0 */
+                        .gpio1  = 0x6000,        /* pin 14 = 1, pin 13 = 0 */
+                        .gpio2  = 0x0000,
+                        .gpio3  = 0x0000,
+                },
+        },
         [CX88_BOARD_POWERCOLOR_REAL_ANGEL] = {
                 .name           = "PowerColor RA330",   /* Long names may confuse LIRC. */
                 .tuner_type     = TUNER_XC2028,
@@ -2719,6 +2791,21 @@ static const struct cx88_subid cx88_subids[] = {
                 .subdevice = 0x6618,
                 .card      = CX88_BOARD_WINFAST_TV2000_XP_GLOBAL,
         }, {
+                /* TV2000 XP Global [107d:6618] */
+                .subvendor = 0x107d,
+                .subdevice = 0x6619,
+                .card      = CX88_BOARD_WINFAST_TV2000_XP_GLOBAL,
+        }, {
+                /* WinFast TV2000 XP Global with XC4000 tuner */
+                .subvendor = 0x107d,
+                .subdevice = 0x6f36,
+                .card      = CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36,
+        }, {
+                /* WinFast TV2000 XP Global with XC4000 tuner and different GPIOs */
+                .subvendor = 0x107d,
+                .subdevice = 0x6f43,
+                .card      = CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43,
+        }, {
                 .subvendor = 0xb034,
                 .subdevice = 0x3034,
                 .card      = CX88_BOARD_PROF_7301,
@@ -3075,6 +3162,8 @@ static int cx88_xc4000_tuner_callback(struct cx88_core *core,
         switch (core->boardnr) {
         case CX88_BOARD_WINFAST_DTV1800H_XC4000:
         case CX88_BOARD_WINFAST_DTV2000H_PLUS:
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36:
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43:
                 return cx88_xc4000_winfast2000h_plus_callback(core,
                                                               command, arg);
         }
@@ -3232,6 +3321,7 @@ static void cx88_card_setup_pre_i2c(struct cx88_core *core)
                 cx_set(MO_GP0_IO, 0x00001010);
                 break;
 
+        case CX88_BOARD_WINFAST_DTV2000H_J:
         case CX88_BOARD_HAUPPAUGE_HVR3000:
         case CX88_BOARD_HAUPPAUGE_HVR4000:
                 /* Init GPIO */
@@ -3250,6 +3340,8 @@ static void cx88_card_setup_pre_i2c(struct cx88_core *core)
 
         case CX88_BOARD_WINFAST_DTV1800H_XC4000:
         case CX88_BOARD_WINFAST_DTV2000H_PLUS:
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36:
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43:
                 cx88_xc4000_winfast2000h_plus_callback(core,
                                                        XC4000_TUNER_RESET, 0);
                 break;
diff --git a/drivers/media/video/cx88/cx88-dvb.c b/drivers/media/video/cx88/cx88-dvb.c
index cf3d33ab541b..003937cd72f5 100644
--- a/drivers/media/video/cx88/cx88-dvb.c
+++ b/drivers/media/video/cx88/cx88-dvb.c
@@ -815,9 +815,9 @@ static const u8 samsung_smt_7020_inittab[] = {
 };
 
 
-static int samsung_smt_7020_tuner_set_params(struct dvb_frontend *fe,
-        struct dvb_frontend_parameters *params)
+static int samsung_smt_7020_tuner_set_params(struct dvb_frontend *fe)
 {
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
         struct cx8802_dev *dev = fe->dvb->priv;
         u8 buf[4];
         u32 div;
@@ -827,14 +827,14 @@ static int samsung_smt_7020_tuner_set_params(struct dvb_frontend *fe,
                 .buf = buf,
                 .len = sizeof(buf) };
 
-        div = params->frequency / 125;
+        div = c->frequency / 125;
 
         buf[0] = (div >> 8) & 0x7f;
         buf[1] = div & 0xff;
         buf[2] = 0x84;  /* 0xC4 */
         buf[3] = 0x00;
 
-        if (params->frequency < 1500000)
+        if (c->frequency < 1500000)
                 buf[3] |= 0x10;
 
         if (fe->ops.i2c_gate_ctrl)
@@ -954,6 +954,7 @@ static int dvb_register(struct cx8802_dev *dev)
         struct cx88_core *core = dev->core;
         struct videobuf_dvb_frontend *fe0, *fe1 = NULL;
         int mfe_shared = 0; /* bus not shared by default */
+        int res = -EINVAL;
 
         if (0 != core->i2c_rc) {
                 printk(KERN_ERR "%s/2: no i2c-bus available, cannot attach dvb drivers\n", core->name);
@@ -999,7 +1000,6 @@ static int dvb_register(struct cx8802_dev *dev)
                 }
                 break;
         case CX88_BOARD_WINFAST_DTV2000H:
-        case CX88_BOARD_WINFAST_DTV2000H_J:
         case CX88_BOARD_HAUPPAUGE_HVR1100:
         case CX88_BOARD_HAUPPAUGE_HVR1100LP:
         case CX88_BOARD_HAUPPAUGE_HVR1300:
@@ -1013,6 +1013,17 @@ static int dvb_register(struct cx8802_dev *dev)
                                 goto frontend_detach;
                 }
                 break;
+        case CX88_BOARD_WINFAST_DTV2000H_J:
+                fe0->dvb.frontend = dvb_attach(cx22702_attach,
+                                               &hauppauge_hvr_config,
+                                               &core->i2c_adap);
+                if (fe0->dvb.frontend != NULL) {
+                        if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
+                                   &core->i2c_adap, 0x61,
+                                   TUNER_PHILIPS_FMD1216MEX_MK3))
+                                goto frontend_detach;
+                }
+                break;
         case CX88_BOARD_HAUPPAUGE_HVR3000:
                 /* MFE frontend 1 */
                 mfe_shared = 1;
@@ -1566,13 +1577,16 @@ static int dvb_register(struct cx8802_dev *dev)
         call_all(core, core, s_power, 0);
 
         /* register everything */
-        return videobuf_dvb_register_bus(&dev->frontends, THIS_MODULE, dev,
-                                         &dev->pci->dev, adapter_nr, mfe_shared, NULL);
+        res = videobuf_dvb_register_bus(&dev->frontends, THIS_MODULE, dev,
+                &dev->pci->dev, adapter_nr, mfe_shared, NULL);
+        if (res)
+                goto frontend_detach;
+        return res;
 
 frontend_detach:
         core->gate_ctrl = NULL;
         videobuf_dvb_dealloc_frontends(&dev->frontends);
-        return -EINVAL;
+        return res;
 }
 
 /* ----------------------------------------------------------- */
diff --git a/drivers/media/video/cx88/cx88-i2c.c b/drivers/media/video/cx88/cx88-i2c.c
index a1fe0abb6e43..de0f1af74e41 100644
--- a/drivers/media/video/cx88/cx88-i2c.c
+++ b/drivers/media/video/cx88/cx88-i2c.c
@@ -132,7 +132,7 @@ static void do_i2c_scan(const char *name, struct i2c_client *c)
         }
 }
 
-/* init + register i2c algo-bit adapter */
+/* init + register i2c adapter */
 int cx88_i2c_init(struct cx88_core *core, struct pci_dev *pci)
 {
         /* Prevents usage of invalid delay values */
diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c
index e614201b5ed3..ebf448c48ca3 100644
--- a/drivers/media/video/cx88/cx88-input.c
+++ b/drivers/media/video/cx88/cx88-input.c
@@ -103,6 +103,8 @@ static void cx88_ir_handle_key(struct cx88_IR *ir)
         case CX88_BOARD_WINFAST_DTV1800H_XC4000:
         case CX88_BOARD_WINFAST_DTV2000H_PLUS:
         case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36:
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43:
                 gpio = (gpio & 0x6ff) | ((cx_read(MO_GP1_IO) << 8) & 0x900);
                 auxgpio = gpio;
                 break;
@@ -302,6 +304,8 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
         case CX88_BOARD_WINFAST2000XP_EXPERT:
         case CX88_BOARD_WINFAST_DTV1000:
         case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36:
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43:
                 ir_codes = RC_MAP_WINFAST;
                 ir->gpio_addr = MO_GP0_IO;
                 ir->mask_keycode = 0x8f8;
diff --git a/drivers/media/video/cx88/cx88.h b/drivers/media/video/cx88/cx88.h
index fa8d307e1a3d..c9659def2a78 100644
--- a/drivers/media/video/cx88/cx88.h
+++ b/drivers/media/video/cx88/cx88.h
@@ -244,6 +244,8 @@ extern const struct sram_channel const cx88_sram_channels[];
 #define CX88_BOARD_TEVII_S464              86
 #define CX88_BOARD_WINFAST_DTV2000H_PLUS   87
 #define CX88_BOARD_WINFAST_DTV1800H_XC4000 88
+#define CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F36 89
+#define CX88_BOARD_WINFAST_TV2000_XP_GLOBAL_6F43 90
 
 enum cx88_itype {
         CX88_VMUX_COMPOSITE1 = 1,
diff --git a/drivers/media/video/davinci/dm355_ccdc.c b/drivers/media/video/davinci/dm355_ccdc.c
index bd443ee76fff..f83baf3a52b0 100644
--- a/drivers/media/video/davinci/dm355_ccdc.c
+++ b/drivers/media/video/davinci/dm355_ccdc.c
@@ -1069,15 +1069,4 @@ static struct platform_driver dm355_ccdc_driver = {
         .probe = dm355_ccdc_probe,
 };
 
-static int __init dm355_ccdc_init(void)
-{
-        return platform_driver_register(&dm355_ccdc_driver);
-}
-
-static void __exit dm355_ccdc_exit(void)
-{
-        platform_driver_unregister(&dm355_ccdc_driver);
-}
-
-module_init(dm355_ccdc_init);
-module_exit(dm355_ccdc_exit);
+module_platform_driver(dm355_ccdc_driver);
diff --git a/drivers/media/video/davinci/dm644x_ccdc.c b/drivers/media/video/davinci/dm644x_ccdc.c
index 8051c2956478..9303fe553b07 100644
--- a/drivers/media/video/davinci/dm644x_ccdc.c
+++ b/drivers/media/video/davinci/dm644x_ccdc.c
@@ -1078,15 +1078,4 @@ static struct platform_driver dm644x_ccdc_driver = {
         .probe = dm644x_ccdc_probe,
 };
 
-static int __init dm644x_ccdc_init(void)
-{
-        return platform_driver_register(&dm644x_ccdc_driver);
-}
-
-static void __exit dm644x_ccdc_exit(void)
-{
-        platform_driver_unregister(&dm644x_ccdc_driver);
-}
-
-module_init(dm644x_ccdc_init);
-module_exit(dm644x_ccdc_exit);
+module_platform_driver(dm644x_ccdc_driver);
diff --git a/drivers/media/video/davinci/isif.c b/drivers/media/video/davinci/isif.c
index 29c29c668596..1e63852374be 100644
--- a/drivers/media/video/davinci/isif.c
+++ b/drivers/media/video/davinci/isif.c
@@ -1156,17 +1156,6 @@ static struct platform_driver isif_driver = {
         .probe = isif_probe,
 };
 
-static int __init isif_init(void)
-{
-        return platform_driver_register(&isif_driver);
-}
-
-static void isif_exit(void)
-{
-        platform_driver_unregister(&isif_driver);
-}
-
-module_init(isif_init);
-module_exit(isif_exit);
+module_platform_driver(isif_driver);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/davinci/vpbe.c b/drivers/media/video/davinci/vpbe.c
index d773d30de221..c4a82a1a8a97 100644
--- a/drivers/media/video/davinci/vpbe.c
+++ b/drivers/media/video/davinci/vpbe.c
@@ -141,11 +141,12 @@ static int vpbe_enum_outputs(struct vpbe_device *vpbe_dev,
         return 0;
 }
 
-static int vpbe_get_mode_info(struct vpbe_device *vpbe_dev, char *mode)
+static int vpbe_get_mode_info(struct vpbe_device *vpbe_dev, char *mode,
+                              int output_index)
 {
         struct vpbe_config *cfg = vpbe_dev->cfg;
         struct vpbe_enc_mode_info var;
-        int curr_output = vpbe_dev->current_out_index;
+        int curr_output = output_index;
         int i;
 
         if (NULL == mode)
@@ -245,6 +246,8 @@ static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index)
         struct encoder_config_info *curr_enc_info =
                         vpbe_current_encoder_info(vpbe_dev);
         struct vpbe_config *cfg = vpbe_dev->cfg;
+        struct venc_platform_data *venc_device = vpbe_dev->venc_device;
+        enum v4l2_mbus_pixelcode if_params;
         int enc_out_index;
         int sd_index;
         int ret = 0;
@@ -274,6 +277,8 @@ static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index)
                         goto out;
                 }
 
+                if_params = cfg->outputs[index].if_params;
+                venc_device->setup_if_config(if_params);
                 if (ret)
                         goto out;
         }
@@ -293,7 +298,7 @@ static int vpbe_set_output(struct vpbe_device *vpbe_dev, int index)
          * encoder.
          */
         ret = vpbe_get_mode_info(vpbe_dev,
-                                 cfg->outputs[index].default_mode);
+                                 cfg->outputs[index].default_mode, index);
         if (!ret) {
                 struct osd_state *osd_device = vpbe_dev->osd_device;
 
@@ -367,6 +372,11 @@ static int vpbe_s_dv_preset(struct vpbe_device *vpbe_dev,
 
         ret = v4l2_subdev_call(vpbe_dev->encoders[sd_index], video,
                                         s_dv_preset, dv_preset);
+        if (!ret && (vpbe_dev->amp != NULL)) {
+                /* Call amplifier subdevice */
+                ret = v4l2_subdev_call(vpbe_dev->amp, video,
+                                s_dv_preset, dv_preset);
+        }
         /* set the lcd controller output for the given mode */
         if (!ret) {
                 struct osd_state *osd_device = vpbe_dev->osd_device;
@@ -566,6 +576,8 @@ static int platform_device_get(struct device *dev, void *data)
 
         if (strcmp("vpbe-osd", pdev->name) == 0)
                 vpbe_dev->osd_device = platform_get_drvdata(pdev);
+        if (strcmp("vpbe-venc", pdev->name) == 0)
+                vpbe_dev->venc_device = dev_get_platdata(&pdev->dev);
 
         return 0;
 }
@@ -584,6 +596,7 @@ static int platform_device_get(struct device *dev, void *data)
 static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
 {
         struct encoder_config_info *enc_info;
+        struct amp_config_info *amp_info;
         struct v4l2_subdev **enc_subdev;
         struct osd_state *osd_device;
         struct i2c_adapter *i2c_adap;
@@ -704,6 +717,32 @@ static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
                         v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c encoders"
                                  " currently not supported");
         }
+        /* Add amplifier subdevice for dm365 */
+        if ((strcmp(vpbe_dev->cfg->module_name, "dm365-vpbe-display") == 0) &&
+                        vpbe_dev->cfg->amp != NULL) {
+                amp_info = vpbe_dev->cfg->amp;
+                if (amp_info->is_i2c) {
+                        vpbe_dev->amp = v4l2_i2c_new_subdev_board(
+                        &vpbe_dev->v4l2_dev, i2c_adap,
+                        &amp_info->board_info, NULL);
+                        if (!vpbe_dev->amp) {
+                                v4l2_err(&vpbe_dev->v4l2_dev,
+                                         "amplifier %s failed to register",
+                                         amp_info->module_name);
+                                ret = -ENODEV;
+                                goto vpbe_fail_amp_register;
+                        }
+                        v4l2_info(&vpbe_dev->v4l2_dev,
+                                          "v4l2 sub device %s registered\n",
+                                          amp_info->module_name);
+                } else {
+                            vpbe_dev->amp = NULL;
+                            v4l2_warn(&vpbe_dev->v4l2_dev, "non-i2c amplifiers"
+                            " currently not supported");
+                }
+        } else {
+            vpbe_dev->amp = NULL;
+        }
 
         /* set the current encoder and output to that of venc by default */
         vpbe_dev->current_sd_index = 0;
@@ -731,6 +770,8 @@ static int vpbe_initialize(struct device *dev, struct vpbe_device *vpbe_dev)
         /* TBD handling of bootargs for default output and mode */
         return 0;
 
+vpbe_fail_amp_register:
+        kfree(vpbe_dev->amp);
 vpbe_fail_sd_register:
         kfree(vpbe_dev->encoders);
 vpbe_fail_v4l2_device:
@@ -757,6 +798,7 @@ static void vpbe_deinitialize(struct device *dev, struct vpbe_device *vpbe_dev)
         if (strcmp(vpbe_dev->cfg->module_name, "dm644x-vpbe-display") != 0)
                 clk_put(vpbe_dev->dac_clk);
 
+        kfree(vpbe_dev->amp);
         kfree(vpbe_dev->encoders);
         vpbe_dev->initialized = 0;
         /* disable vpss clocks */
@@ -811,8 +853,10 @@ static __devinit int vpbe_probe(struct platform_device *pdev)
 
         if (cfg->outputs->num_modes > 0)
                 vpbe_dev->current_timings = vpbe_dev->cfg->outputs[0].modes[0];
-        else
+        else {
+                kfree(vpbe_dev);
                 return -ENODEV;
+        }
 
         /* set the driver data in platform device */
         platform_set_drvdata(pdev, vpbe_dev);
@@ -839,26 +883,4 @@ static struct platform_driver vpbe_driver = {
         .remove = vpbe_remove,
 };
 
-/**
- * vpbe_init: initialize the vpbe driver
- *
- * This function registers device and driver to the kernel
- */
-static __init int vpbe_init(void)
-{
-        return platform_driver_register(&vpbe_driver);
-}
-
-/**
- * vpbe_cleanup : cleanup function for vpbe driver
- *
- * This will un-registers the device and driver to the kernel
- */
-static void vpbe_cleanup(void)
-{
-        platform_driver_unregister(&vpbe_driver);
-}
-
-/* Function for module initialization and cleanup */
-module_init(vpbe_init);
-module_exit(vpbe_cleanup);
+module_platform_driver(vpbe_driver);
diff --git a/drivers/media/video/davinci/vpbe_display.c b/drivers/media/video/davinci/vpbe_display.c
index 8588a86d9b45..1f3b1c729252 100644
--- a/drivers/media/video/davinci/vpbe_display.c
+++ b/drivers/media/video/davinci/vpbe_display.c
@@ -1746,15 +1746,16 @@ static __devinit int vpbe_display_probe(struct platform_device *pdev)
         for (i = 0; i < VPBE_DISPLAY_MAX_DEVICES; i++) {
                 if (register_device(disp_dev->dev[i], disp_dev, pdev)) {
                         err = -ENODEV;
-                        goto probe_out;
+                        goto probe_out_irq;
                 }
         }
 
         printk(KERN_DEBUG "Successfully completed the probing of vpbe v4l2 device\n");
         return 0;
 
-probe_out:
+probe_out_irq:
         free_irq(res->start, disp_dev);
+probe_out:
         for (k = 0; k < VPBE_DISPLAY_MAX_DEVICES; k++) {
                 /* Get the pointer to the layer object */
                 vpbe_display_layer = disp_dev->dev[k];
@@ -1816,43 +1817,7 @@ static struct platform_driver vpbe_display_driver = {
         .remove = __devexit_p(vpbe_display_remove),
 };
 
-/*
- * vpbe_display_init()
- * This function registers device and driver to the kernel, requests irq
- * handler and allocates memory for layer objects
- */
-static __devinit int vpbe_display_init(void)
-{
-        int err;
-
-        printk(KERN_DEBUG "vpbe_display_init\n");
-
-        /* Register driver to the kernel */
-        err = platform_driver_register(&vpbe_display_driver);
-        if (0 != err)
-                return err;
-
-        printk(KERN_DEBUG "vpbe_display_init:"
-                        "VPBE V4L2 Display Driver V1.0 loaded\n");
-        return 0;
-}
-
-/*
- * vpbe_display_cleanup()
- * This function un-registers device and driver to the kernel, frees requested
- * irq handler and de-allocates memory allocated for layer objects.
- */
-static void vpbe_display_cleanup(void)
-{
-        printk(KERN_DEBUG "vpbe_display_cleanup\n");
-
-        /* platform driver unregister */
-        platform_driver_unregister(&vpbe_display_driver);
-}
-
-/* Function for module initialization and cleanup */
-module_init(vpbe_display_init);
-module_exit(vpbe_display_cleanup);
+module_platform_driver(vpbe_display_driver);
 
 MODULE_DESCRIPTION("TI DM644x/DM355/DM365 VPBE Display controller");
 MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/davinci/vpbe_osd.c b/drivers/media/video/davinci/vpbe_osd.c
index ceccf4302518..d6488b79ae3b 100644
--- a/drivers/media/video/davinci/vpbe_osd.c
+++ b/drivers/media/video/davinci/vpbe_osd.c
@@ -248,11 +248,29 @@ static void _osd_set_rec601_attenuation(struct osd_state *sd,
                 osd_modify(sd, OSD_OSDWIN0MD_ATN0E,
                           enable ? OSD_OSDWIN0MD_ATN0E : 0,
                           OSD_OSDWIN0MD);
+                if (sd->vpbe_type == VPBE_VERSION_1)
+                        osd_modify(sd, OSD_OSDWIN0MD_ATN0E,
+                                  enable ? OSD_OSDWIN0MD_ATN0E : 0,
+                                  OSD_OSDWIN0MD);
+                else if ((sd->vpbe_type == VPBE_VERSION_3) ||
+                           (sd->vpbe_type == VPBE_VERSION_2))
+                        osd_modify(sd, OSD_EXTMODE_ATNOSD0EN,
+                                  enable ? OSD_EXTMODE_ATNOSD0EN : 0,
+                                  OSD_EXTMODE);
                 break;
         case OSDWIN_OSD1:
                 osd_modify(sd, OSD_OSDWIN1MD_ATN1E,
                           enable ? OSD_OSDWIN1MD_ATN1E : 0,
                           OSD_OSDWIN1MD);
+                if (sd->vpbe_type == VPBE_VERSION_1)
+                        osd_modify(sd, OSD_OSDWIN1MD_ATN1E,
+                                  enable ? OSD_OSDWIN1MD_ATN1E : 0,
+                                  OSD_OSDWIN1MD);
+                else if ((sd->vpbe_type == VPBE_VERSION_3) ||
+                           (sd->vpbe_type == VPBE_VERSION_2))
+                        osd_modify(sd, OSD_EXTMODE_ATNOSD1EN,
+                                  enable ? OSD_EXTMODE_ATNOSD1EN : 0,
+                                  OSD_EXTMODE);
                 break;
         }
 }
@@ -273,15 +291,71 @@ static void _osd_set_blending_factor(struct osd_state *sd,
         }
 }
 
+static void _osd_enable_rgb888_pixblend(struct osd_state *sd,
+                                        enum osd_win_layer osdwin)
+{
+
+        osd_modify(sd, OSD_MISCCTL_BLDSEL, 0, OSD_MISCCTL);
+        switch (osdwin) {
+        case OSDWIN_OSD0:
+                osd_modify(sd, OSD_EXTMODE_OSD0BLDCHR,
+                          OSD_EXTMODE_OSD0BLDCHR, OSD_EXTMODE);
+                break;
+        case OSDWIN_OSD1:
+                osd_modify(sd, OSD_EXTMODE_OSD1BLDCHR,
+                          OSD_EXTMODE_OSD1BLDCHR, OSD_EXTMODE);
+                break;
+        }
+}
+
 static void _osd_enable_color_key(struct osd_state *sd,
                                   enum osd_win_layer osdwin,
                                   unsigned colorkey,
                                   enum osd_pix_format pixfmt)
 {
         switch (pixfmt) {
+        case PIXFMT_1BPP:
+        case PIXFMT_2BPP:
+        case PIXFMT_4BPP:
+        case PIXFMT_8BPP:
+                if (sd->vpbe_type == VPBE_VERSION_3) {
+                        switch (osdwin) {
+                        case OSDWIN_OSD0:
+                                osd_modify(sd, OSD_TRANSPBMPIDX_BMP0,
+                                          colorkey <<
+                                          OSD_TRANSPBMPIDX_BMP0_SHIFT,
+                                          OSD_TRANSPBMPIDX);
+                                break;
+                        case OSDWIN_OSD1:
+                                osd_modify(sd, OSD_TRANSPBMPIDX_BMP1,
+                                          colorkey <<
+                                          OSD_TRANSPBMPIDX_BMP1_SHIFT,
+                                          OSD_TRANSPBMPIDX);
+                                break;
+                        }
+                }
+                break;
         case PIXFMT_RGB565:
-                osd_write(sd, colorkey & OSD_TRANSPVAL_RGBTRANS,
-                          OSD_TRANSPVAL);
+                if (sd->vpbe_type == VPBE_VERSION_1)
+                        osd_write(sd, colorkey & OSD_TRANSPVAL_RGBTRANS,
+                                  OSD_TRANSPVAL);
+                else if (sd->vpbe_type == VPBE_VERSION_3)
+                        osd_write(sd, colorkey & OSD_TRANSPVALL_RGBL,
+                                  OSD_TRANSPVALL);
+                break;
+        case PIXFMT_YCbCrI:
+        case PIXFMT_YCrCbI:
+                if (sd->vpbe_type == VPBE_VERSION_3)
+                        osd_modify(sd, OSD_TRANSPVALU_Y, colorkey,
+                                   OSD_TRANSPVALU);
+                break;
+        case PIXFMT_RGB888:
+                if (sd->vpbe_type == VPBE_VERSION_3) {
+                        osd_write(sd, colorkey & OSD_TRANSPVALL_RGBL,
+                                  OSD_TRANSPVALL);
+                        osd_modify(sd, OSD_TRANSPVALU_RGBU, colorkey >> 16,
+                                  OSD_TRANSPVALU);
+                }
                 break;
         default:
                 break;
@@ -470,23 +544,188 @@ static int osd_enable_layer(struct osd_state *sd, enum osd_layer layer,
         return 0;
 }
 
+#define OSD_SRC_ADDR_HIGH4      0x7800000
+#define OSD_SRC_ADDR_HIGH7      0x7F0000
+#define OSD_SRCADD_OFSET_SFT    23
+#define OSD_SRCADD_ADD_SFT      16
+#define OSD_WINADL_MASK         0xFFFF
+#define OSD_WINOFST_MASK        0x1000
+#define VPBE_REG_BASE           0x80000000
+
 static void _osd_start_layer(struct osd_state *sd, enum osd_layer layer,
                              unsigned long fb_base_phys,
                              unsigned long cbcr_ofst)
 {
-        switch (layer) {
-        case WIN_OSD0:
-                osd_write(sd, fb_base_phys & ~0x1F, OSD_OSDWIN0ADR);
-                break;
-        case WIN_VID0:
-                osd_write(sd, fb_base_phys & ~0x1F, OSD_VIDWIN0ADR);
-                break;
-        case WIN_OSD1:
-                osd_write(sd, fb_base_phys & ~0x1F, OSD_OSDWIN1ADR);
-                break;
-        case WIN_VID1:
-                osd_write(sd, fb_base_phys & ~0x1F, OSD_VIDWIN1ADR);
-                break;
+
+        if (sd->vpbe_type == VPBE_VERSION_1) {
+                switch (layer) {
+                case WIN_OSD0:
+                        osd_write(sd, fb_base_phys & ~0x1F, OSD_OSDWIN0ADR);
+                        break;
+                case WIN_VID0:
+                        osd_write(sd, fb_base_phys & ~0x1F, OSD_VIDWIN0ADR);
+                        break;
+                case WIN_OSD1:
+                        osd_write(sd, fb_base_phys & ~0x1F, OSD_OSDWIN1ADR);
+                        break;
+                case WIN_VID1:
+                        osd_write(sd, fb_base_phys & ~0x1F, OSD_VIDWIN1ADR);
+                        break;
+              }
+        } else if (sd->vpbe_type == VPBE_VERSION_3) {
+                unsigned long fb_offset_32 =
+                    (fb_base_phys - VPBE_REG_BASE) >> 5;
+
+                switch (layer) {
+                case WIN_OSD0:
+                        osd_modify(sd, OSD_OSDWINADH_O0AH,
+                                  fb_offset_32 >> (OSD_SRCADD_ADD_SFT -
+                                                   OSD_OSDWINADH_O0AH_SHIFT),
+                                  OSD_OSDWINADH);
+                        osd_write(sd, fb_offset_32 & OSD_OSDWIN0ADL_O0AL,
+                                  OSD_OSDWIN0ADL);
+                        break;
+                case WIN_VID0:
+                        osd_modify(sd, OSD_VIDWINADH_V0AH,
+                                  fb_offset_32 >> (OSD_SRCADD_ADD_SFT -
+                                                   OSD_VIDWINADH_V0AH_SHIFT),
+                                  OSD_VIDWINADH);
+                        osd_write(sd, fb_offset_32 & OSD_VIDWIN0ADL_V0AL,
+                                  OSD_VIDWIN0ADL);
+                        break;
+                case WIN_OSD1:
+                        osd_modify(sd, OSD_OSDWINADH_O1AH,
+                                  fb_offset_32 >> (OSD_SRCADD_ADD_SFT -
+                                                   OSD_OSDWINADH_O1AH_SHIFT),
+                                  OSD_OSDWINADH);
+                        osd_write(sd, fb_offset_32 & OSD_OSDWIN1ADL_O1AL,
+                                  OSD_OSDWIN1ADL);
+                        break;
+                case WIN_VID1:
+                        osd_modify(sd, OSD_VIDWINADH_V1AH,
+                                  fb_offset_32 >> (OSD_SRCADD_ADD_SFT -
+                                                   OSD_VIDWINADH_V1AH_SHIFT),
+                                  OSD_VIDWINADH);
+                        osd_write(sd, fb_offset_32 & OSD_VIDWIN1ADL_V1AL,
+                                  OSD_VIDWIN1ADL);
+                        break;
+                }
+        } else if (sd->vpbe_type == VPBE_VERSION_2) {
+                struct osd_window_state *win = &sd->win[layer];
+                unsigned long fb_offset_32, cbcr_offset_32;
+
+                fb_offset_32 = fb_base_phys - VPBE_REG_BASE;
+                if (cbcr_ofst)
+                        cbcr_offset_32 = cbcr_ofst;
+                else
+                        cbcr_offset_32 = win->lconfig.line_length *
+                                         win->lconfig.ysize;
+                cbcr_offset_32 += fb_offset_32;
+                fb_offset_32 = fb_offset_32 >> 5;
+                cbcr_offset_32 = cbcr_offset_32 >> 5;
+                /*
+                 * DM365: start address is 27-bit long address b26 - b23 are
+                 * in offset register b12 - b9, and * bit 26 has to be '1'
+                 */
+                if (win->lconfig.pixfmt == PIXFMT_NV12) {
+                        switch (layer) {
+                        case WIN_VID0:
+                        case WIN_VID1:
+                                /* Y is in VID0 */
+                                osd_modify(sd, OSD_VIDWIN0OFST_V0AH,
+                                         ((fb_offset_32 & OSD_SRC_ADDR_HIGH4) >>
+                                         (OSD_SRCADD_OFSET_SFT -
+                                         OSD_WINOFST_AH_SHIFT)) |
+                                         OSD_WINOFST_MASK, OSD_VIDWIN0OFST);
+                                osd_modify(sd, OSD_VIDWINADH_V0AH,
+                                          (fb_offset_32 & OSD_SRC_ADDR_HIGH7) >>
+                                          (OSD_SRCADD_ADD_SFT -
+                                          OSD_VIDWINADH_V0AH_SHIFT),
+                                           OSD_VIDWINADH);
+                                osd_write(sd, fb_offset_32 & OSD_WINADL_MASK,
+                                          OSD_VIDWIN0ADL);
+                                /* CbCr is in VID1 */
+                                osd_modify(sd, OSD_VIDWIN1OFST_V1AH,
+                                         ((cbcr_offset_32 &
+                                         OSD_SRC_ADDR_HIGH4) >>
+                                         (OSD_SRCADD_OFSET_SFT -
+                                         OSD_WINOFST_AH_SHIFT)) |
+                                         OSD_WINOFST_MASK, OSD_VIDWIN1OFST);
+                                osd_modify(sd, OSD_VIDWINADH_V1AH,
+                                          (cbcr_offset_32 &
+                                          OSD_SRC_ADDR_HIGH7) >>
+                                          (OSD_SRCADD_ADD_SFT -
+                                          OSD_VIDWINADH_V1AH_SHIFT),
+                                          OSD_VIDWINADH);
+                                osd_write(sd, cbcr_offset_32 & OSD_WINADL_MASK,
+                                          OSD_VIDWIN1ADL);
+                                break;
+                        default:
+                                break;
+                        }
+                }
+
+                switch (layer) {
+                case WIN_OSD0:
+                        osd_modify(sd, OSD_OSDWIN0OFST_O0AH,
+                                 ((fb_offset_32 & OSD_SRC_ADDR_HIGH4) >>
+                                 (OSD_SRCADD_OFSET_SFT -
+                                 OSD_WINOFST_AH_SHIFT)) | OSD_WINOFST_MASK,
+                                  OSD_OSDWIN0OFST);
+                        osd_modify(sd, OSD_OSDWINADH_O0AH,
+                                 (fb_offset_32 & OSD_SRC_ADDR_HIGH7) >>
+                                 (OSD_SRCADD_ADD_SFT -
+                                 OSD_OSDWINADH_O0AH_SHIFT), OSD_OSDWINADH);
+                        osd_write(sd, fb_offset_32 & OSD_WINADL_MASK,
+                                        OSD_OSDWIN0ADL);
+                        break;
+                case WIN_VID0:
+                        if (win->lconfig.pixfmt != PIXFMT_NV12) {
+                                osd_modify(sd, OSD_VIDWIN0OFST_V0AH,
+                                         ((fb_offset_32 & OSD_SRC_ADDR_HIGH4) >>
+                                         (OSD_SRCADD_OFSET_SFT -
+                                         OSD_WINOFST_AH_SHIFT)) |
+                                         OSD_WINOFST_MASK, OSD_VIDWIN0OFST);
+                                osd_modify(sd, OSD_VIDWINADH_V0AH,
+                                          (fb_offset_32 & OSD_SRC_ADDR_HIGH7) >>
+                                          (OSD_SRCADD_ADD_SFT -
+                                          OSD_VIDWINADH_V0AH_SHIFT),
+                                          OSD_VIDWINADH);
+                                osd_write(sd, fb_offset_32 & OSD_WINADL_MASK,
+                                          OSD_VIDWIN0ADL);
+                        }
+                        break;
+                case WIN_OSD1:
+                        osd_modify(sd, OSD_OSDWIN1OFST_O1AH,
+                                 ((fb_offset_32 & OSD_SRC_ADDR_HIGH4) >>
+                                 (OSD_SRCADD_OFSET_SFT -
+                                 OSD_WINOFST_AH_SHIFT)) | OSD_WINOFST_MASK,
+                                  OSD_OSDWIN1OFST);
+                        osd_modify(sd, OSD_OSDWINADH_O1AH,
+                                  (fb_offset_32 & OSD_SRC_ADDR_HIGH7) >>
+                                  (OSD_SRCADD_ADD_SFT -
+                                  OSD_OSDWINADH_O1AH_SHIFT),
+                                  OSD_OSDWINADH);
+                        osd_write(sd, fb_offset_32 & OSD_WINADL_MASK,
+                                        OSD_OSDWIN1ADL);
+                        break;
+                case WIN_VID1:
+                        if (win->lconfig.pixfmt != PIXFMT_NV12) {
+                                osd_modify(sd, OSD_VIDWIN1OFST_V1AH,
+                                         ((fb_offset_32 & OSD_SRC_ADDR_HIGH4) >>
+                                         (OSD_SRCADD_OFSET_SFT -
+                                         OSD_WINOFST_AH_SHIFT)) |
+                                         OSD_WINOFST_MASK, OSD_VIDWIN1OFST);
+                                osd_modify(sd, OSD_VIDWINADH_V1AH,
+                                          (fb_offset_32 & OSD_SRC_ADDR_HIGH7) >>
+                                          (OSD_SRCADD_ADD_SFT -
+                                          OSD_VIDWINADH_V1AH_SHIFT),
+                                          OSD_VIDWINADH);
+                                osd_write(sd, fb_offset_32 & OSD_WINADL_MASK,
+                                          OSD_VIDWIN1ADL);
+                        }
+                        break;
+                }
         }
 }
 
@@ -545,7 +784,7 @@ static int try_layer_config(struct osd_state *sd, enum osd_layer layer,
 {
         struct osd_state *osd = sd;
         struct osd_window_state *win = &osd->win[layer];
-        int bad_config;
+        int bad_config = 0;
 
         /* verify that the pixel format is compatible with the layer */
         switch (lconfig->pixfmt) {
@@ -554,17 +793,25 @@ static int try_layer_config(struct osd_state *sd, enum osd_layer layer,
         case PIXFMT_4BPP:
         case PIXFMT_8BPP:
         case PIXFMT_RGB565:
-                bad_config = !is_osd_win(layer);
+                if (osd->vpbe_type == VPBE_VERSION_1)
+                        bad_config = !is_vid_win(layer);
                 break;
         case PIXFMT_YCbCrI:
         case PIXFMT_YCrCbI:
                 bad_config = !is_vid_win(layer);
                 break;
         case PIXFMT_RGB888:
-                bad_config = !is_vid_win(layer);
+                if (osd->vpbe_type == VPBE_VERSION_1)
+                        bad_config = !is_vid_win(layer);
+                else if ((osd->vpbe_type == VPBE_VERSION_3) ||
+                         (osd->vpbe_type == VPBE_VERSION_2))
+                        bad_config = !is_osd_win(layer);
                 break;
         case PIXFMT_NV12:
-                bad_config = 1;
+                if (osd->vpbe_type != VPBE_VERSION_2)
+                        bad_config = 1;
+                else
+                        bad_config = is_osd_win(layer);
                 break;
         case PIXFMT_OSD_ATTR:
                 bad_config = (layer != WIN_OSD1);
@@ -584,7 +831,8 @@ static int try_layer_config(struct osd_state *sd, enum osd_layer layer,
 
         /* DM6446: */
         /* only one OSD window at a time can use RGB pixel formats */
-        if (is_osd_win(layer) && is_rgb_pixfmt(lconfig->pixfmt)) {
+          if ((osd->vpbe_type == VPBE_VERSION_1) &&
+                  is_osd_win(layer) && is_rgb_pixfmt(lconfig->pixfmt)) {
                 enum osd_pix_format pixfmt;
                 if (layer == WIN_OSD0)
                         pixfmt = osd->win[WIN_OSD1].lconfig.pixfmt;
@@ -602,7 +850,8 @@ static int try_layer_config(struct osd_state *sd, enum osd_layer layer,
         }
 
         /* DM6446: only one video window at a time can use RGB888 */
-        if (is_vid_win(layer) && lconfig->pixfmt == PIXFMT_RGB888) {
+        if ((osd->vpbe_type == VPBE_VERSION_1) && is_vid_win(layer) &&
+                lconfig->pixfmt == PIXFMT_RGB888) {
                 enum osd_pix_format pixfmt;
 
                 if (layer == WIN_VID0)
@@ -652,7 +901,8 @@ static void _osd_disable_vid_rgb888(struct osd_state *sd)
          * The caller must ensure that neither video window is currently
          * configured for RGB888 pixel format.
          */
-        osd_clear(sd, OSD_MISCCTL_RGBEN, OSD_MISCCTL);
+        if (sd->vpbe_type == VPBE_VERSION_1)
+                osd_clear(sd, OSD_MISCCTL_RGBEN, OSD_MISCCTL);
 }
 
 static void _osd_enable_vid_rgb888(struct osd_state *sd,
@@ -665,13 +915,14 @@ static void _osd_enable_vid_rgb888(struct osd_state *sd,
          * currently configured for RGB888 pixel format, as this routine will
          * disable RGB888 pixel format for the other window.
          */
-        if (layer == WIN_VID0) {
-                osd_modify(sd, OSD_MISCCTL_RGBEN | OSD_MISCCTL_RGBWIN,
-                          OSD_MISCCTL_RGBEN, OSD_MISCCTL);
-        } else if (layer == WIN_VID1) {
-                osd_modify(sd, OSD_MISCCTL_RGBEN | OSD_MISCCTL_RGBWIN,
-                          OSD_MISCCTL_RGBEN | OSD_MISCCTL_RGBWIN,
-                          OSD_MISCCTL);
+        if (sd->vpbe_type == VPBE_VERSION_1) {
+                if (layer == WIN_VID0)
+                        osd_modify(sd, OSD_MISCCTL_RGBEN | OSD_MISCCTL_RGBWIN,
+                                  OSD_MISCCTL_RGBEN, OSD_MISCCTL);
+                else if (layer == WIN_VID1)
+                        osd_modify(sd, OSD_MISCCTL_RGBEN | OSD_MISCCTL_RGBWIN,
+                                  OSD_MISCCTL_RGBEN | OSD_MISCCTL_RGBWIN,
+                                  OSD_MISCCTL);
         }
 }
 
@@ -697,9 +948,30 @@ static void _osd_set_layer_config(struct osd_state *sd, enum osd_layer layer,
 
         switch (layer) {
         case WIN_OSD0:
-                winmd_mask |= OSD_OSDWIN0MD_RGB0E;
-                if (lconfig->pixfmt == PIXFMT_RGB565)
-                        winmd |= OSD_OSDWIN0MD_RGB0E;
+                if (sd->vpbe_type == VPBE_VERSION_1) {
+                        winmd_mask |= OSD_OSDWIN0MD_RGB0E;
+                        if (lconfig->pixfmt == PIXFMT_RGB565)
+                                winmd |= OSD_OSDWIN0MD_RGB0E;
+                } else if ((sd->vpbe_type == VPBE_VERSION_3) ||
+                  (sd->vpbe_type == VPBE_VERSION_2)) {
+                        winmd_mask |= OSD_OSDWIN0MD_BMP0MD;
+                        switch (lconfig->pixfmt) {
+                        case PIXFMT_RGB565:
+                                        winmd |= (1 <<
+                                        OSD_OSDWIN0MD_BMP0MD_SHIFT);
+                                        break;
+                        case PIXFMT_RGB888:
+                                winmd |= (2 << OSD_OSDWIN0MD_BMP0MD_SHIFT);
+                                _osd_enable_rgb888_pixblend(sd, OSDWIN_OSD0);
+                                break;
+                        case PIXFMT_YCbCrI:
+                        case PIXFMT_YCrCbI:
+                                winmd |= (3 << OSD_OSDWIN0MD_BMP0MD_SHIFT);
+                                break;
+                        default:
+                                break;
+                        }
+                }
 
                 winmd_mask |= OSD_OSDWIN0MD_BMW0 | OSD_OSDWIN0MD_OFF0;
 
@@ -749,12 +1021,59 @@ static void _osd_set_layer_config(struct osd_state *sd, enum osd_layer layer,
                  * For YUV420P format the register contents are
                  * duplicated in both VID registers
                  */
+                if ((sd->vpbe_type == VPBE_VERSION_2) &&
+                                (lconfig->pixfmt == PIXFMT_NV12)) {
+                        /* other window also */
+                        if (lconfig->interlaced) {
+                                winmd_mask |= OSD_VIDWINMD_VFF1;
+                                winmd |= OSD_VIDWINMD_VFF1;
+                                osd_modify(sd, winmd_mask, winmd,
+                                          OSD_VIDWINMD);
+                        }
+
+                        osd_modify(sd, OSD_MISCCTL_S420D,
+                                    OSD_MISCCTL_S420D, OSD_MISCCTL);
+                        osd_write(sd, lconfig->line_length >> 5,
+                                  OSD_VIDWIN1OFST);
+                        osd_write(sd, lconfig->xpos, OSD_VIDWIN1XP);
+                        osd_write(sd, lconfig->xsize, OSD_VIDWIN1XL);
+                        /*
+                          * if NV21 pixfmt and line length not 32B
+                          * aligned (e.g. NTSC), Need to set window
+                          * X pixel size to be 32B aligned as well
+                          */
+                        if (lconfig->xsize % 32) {
+                                osd_write(sd,
+                                          ((lconfig->xsize + 31) & ~31),
+                                          OSD_VIDWIN1XL);
+                                osd_write(sd,
+                                          ((lconfig->xsize + 31) & ~31),
+                                          OSD_VIDWIN0XL);
+                        }
+                } else if ((sd->vpbe_type == VPBE_VERSION_2) &&
+                                (lconfig->pixfmt != PIXFMT_NV12)) {
+                        osd_modify(sd, OSD_MISCCTL_S420D, ~OSD_MISCCTL_S420D,
+                                                OSD_MISCCTL);
+                }
+
                 if (lconfig->interlaced) {
                         osd_write(sd, lconfig->ypos >> 1, OSD_VIDWIN0YP);
                         osd_write(sd, lconfig->ysize >> 1, OSD_VIDWIN0YL);
+                        if ((sd->vpbe_type == VPBE_VERSION_2) &&
+                                lconfig->pixfmt == PIXFMT_NV12) {
+                                osd_write(sd, lconfig->ypos >> 1,
+                                          OSD_VIDWIN1YP);
+                                osd_write(sd, lconfig->ysize >> 1,
+                                          OSD_VIDWIN1YL);
+                        }
                 } else {
                         osd_write(sd, lconfig->ypos, OSD_VIDWIN0YP);
                         osd_write(sd, lconfig->ysize, OSD_VIDWIN0YL);
+                        if ((sd->vpbe_type == VPBE_VERSION_2) &&
+                                lconfig->pixfmt == PIXFMT_NV12) {
+                                osd_write(sd, lconfig->ypos, OSD_VIDWIN1YP);
+                                osd_write(sd, lconfig->ysize, OSD_VIDWIN1YL);
+                        }
                 }
                 break;
         case WIN_OSD1:
@@ -764,14 +1083,43 @@ static void _osd_set_layer_config(struct osd_state *sd, enum osd_layer layer,
                  * attribute mode to a normal mode.
                  */
                 if (lconfig->pixfmt == PIXFMT_OSD_ATTR) {
-                        winmd_mask |=
-                            OSD_OSDWIN1MD_ATN1E | OSD_OSDWIN1MD_RGB1E |
-                            OSD_OSDWIN1MD_CLUTS1 |
-                            OSD_OSDWIN1MD_BLND1 | OSD_OSDWIN1MD_TE1;
+                        if (sd->vpbe_type == VPBE_VERSION_1) {
+                                winmd_mask |= OSD_OSDWIN1MD_ATN1E |
+                                OSD_OSDWIN1MD_RGB1E | OSD_OSDWIN1MD_CLUTS1 |
+                                OSD_OSDWIN1MD_BLND1 | OSD_OSDWIN1MD_TE1;
+                        } else {
+                                winmd_mask |= OSD_OSDWIN1MD_BMP1MD |
+                                OSD_OSDWIN1MD_CLUTS1 | OSD_OSDWIN1MD_BLND1 |
+                                OSD_OSDWIN1MD_TE1;
+                        }
                 } else {
-                        winmd_mask |= OSD_OSDWIN1MD_RGB1E;
-                        if (lconfig->pixfmt == PIXFMT_RGB565)
-                                winmd |= OSD_OSDWIN1MD_RGB1E;
+                        if (sd->vpbe_type == VPBE_VERSION_1) {
+                                winmd_mask |= OSD_OSDWIN1MD_RGB1E;
+                                if (lconfig->pixfmt == PIXFMT_RGB565)
+                                        winmd |= OSD_OSDWIN1MD_RGB1E;
+                        } else if ((sd->vpbe_type == VPBE_VERSION_3)
+                                   || (sd->vpbe_type == VPBE_VERSION_2)) {
+                                winmd_mask |= OSD_OSDWIN1MD_BMP1MD;
+                                switch (lconfig->pixfmt) {
+                                case PIXFMT_RGB565:
+                                        winmd |=
+                                            (1 << OSD_OSDWIN1MD_BMP1MD_SHIFT);
+                                        break;
+                                case PIXFMT_RGB888:
+                                        winmd |=
+                                            (2 << OSD_OSDWIN1MD_BMP1MD_SHIFT);
+                                        _osd_enable_rgb888_pixblend(sd,
+                                                        OSDWIN_OSD1);
+                                        break;
+                                case PIXFMT_YCbCrI:
+                                case PIXFMT_YCrCbI:
+                                        winmd |=
+                                            (3 << OSD_OSDWIN1MD_BMP1MD_SHIFT);
+                                        break;
+                                default:
+                                        break;
+                                }
+                        }
 
                         winmd_mask |= OSD_OSDWIN1MD_BMW1;
                         switch (lconfig->pixfmt) {
@@ -822,15 +1170,45 @@ static void _osd_set_layer_config(struct osd_state *sd, enum osd_layer layer,
                  * For YUV420P format the register contents are
                  * duplicated in both VID registers
                  */
-                osd_modify(sd, OSD_MISCCTL_S420D, ~OSD_MISCCTL_S420D,
-                           OSD_MISCCTL);
+                if (sd->vpbe_type == VPBE_VERSION_2) {
+                        if (lconfig->pixfmt == PIXFMT_NV12) {
+                                /* other window also */
+                                if (lconfig->interlaced) {
+                                        winmd_mask |= OSD_VIDWINMD_VFF0;
+                                        winmd |= OSD_VIDWINMD_VFF0;
+                                        osd_modify(sd, winmd_mask, winmd,
+                                                  OSD_VIDWINMD);
+                                }
+                                osd_modify(sd, OSD_MISCCTL_S420D,
+                                           OSD_MISCCTL_S420D, OSD_MISCCTL);
+                                osd_write(sd, lconfig->line_length >> 5,
+                                          OSD_VIDWIN0OFST);
+                                osd_write(sd, lconfig->xpos, OSD_VIDWIN0XP);
+                                osd_write(sd, lconfig->xsize, OSD_VIDWIN0XL);
+                        } else {
+                                osd_modify(sd, OSD_MISCCTL_S420D,
+                                           ~OSD_MISCCTL_S420D, OSD_MISCCTL);
+                        }
+                }
 
                 if (lconfig->interlaced) {
                         osd_write(sd, lconfig->ypos >> 1, OSD_VIDWIN1YP);
                         osd_write(sd, lconfig->ysize >> 1, OSD_VIDWIN1YL);
+                        if ((sd->vpbe_type == VPBE_VERSION_2) &&
+                                lconfig->pixfmt == PIXFMT_NV12) {
+                                osd_write(sd, lconfig->ypos >> 1,
+                                          OSD_VIDWIN0YP);
+                                osd_write(sd, lconfig->ysize >> 1,
+                                          OSD_VIDWIN0YL);
+                        }
                 } else {
                         osd_write(sd, lconfig->ypos, OSD_VIDWIN1YP);
                         osd_write(sd, lconfig->ysize, OSD_VIDWIN1YL);
+                        if ((sd->vpbe_type == VPBE_VERSION_2) &&
+                                lconfig->pixfmt == PIXFMT_NV12) {
+                                osd_write(sd, lconfig->ypos, OSD_VIDWIN0YP);
+                                osd_write(sd, lconfig->ysize, OSD_VIDWIN0YL);
+                        }
                 }
                 break;
         }
@@ -1089,6 +1467,11 @@ static void _osd_init(struct osd_state *sd)
         osd_write(sd, 0, OSD_OSDWIN1MD);
         osd_write(sd, 0, OSD_RECTCUR);
         osd_write(sd, 0, OSD_MISCCTL);
+        if (sd->vpbe_type == VPBE_VERSION_3) {
+                osd_write(sd, 0, OSD_VBNDRY);
+                osd_write(sd, 0, OSD_EXTMODE);
+                osd_write(sd, OSD_MISCCTL_DMANG, OSD_MISCCTL);
+        }
 }
 
 static void osd_set_left_margin(struct osd_state *sd, u32 val)
@@ -1110,6 +1493,14 @@ static int osd_initialize(struct osd_state *osd)
         /* set default Cb/Cr order */
         osd->yc_pixfmt = PIXFMT_YCbCrI;
 
+        if (osd->vpbe_type == VPBE_VERSION_3) {
+                /*
+                 * ROM CLUT1 on the DM355 is similar (identical?) to ROM CLUT0
+                 * on the DM6446, so make ROM_CLUT1 the default on the DM355.
+                 */
+                osd->rom_clut = ROM_CLUT1;
+        }
+
         _osd_set_field_inversion(osd, osd->field_inversion);
         _osd_set_rom_clut(osd, osd->rom_clut);
 
@@ -1208,23 +1599,7 @@ static struct platform_driver osd_driver = {
         },
 };
 
-static int osd_init(void)
-{
-        if (platform_driver_register(&osd_driver)) {
-                printk(KERN_ERR "Unable to register davinci osd driver\n");
-                return -ENODEV;
-        }
-
-        return 0;
-}
-
-static void osd_exit(void)
-{
-        platform_driver_unregister(&osd_driver);
-}
-
-module_init(osd_init);
-module_exit(osd_exit);
+module_platform_driver(osd_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("DaVinci OSD Manager Driver");
diff --git a/drivers/media/video/davinci/vpbe_venc.c b/drivers/media/video/davinci/vpbe_venc.c
index 03a3e5c65ee7..00e80f59d5d5 100644
--- a/drivers/media/video/davinci/vpbe_venc.c
+++ b/drivers/media/video/davinci/vpbe_venc.c
@@ -99,6 +99,8 @@ static inline u32 vdaccfg_write(struct v4l2_subdev *sd, u32 val)
         return val;
 }
 
+#define VDAC_COMPONENT  0x543
+#define VDAC_S_VIDEO    0x210
 /* This function sets the dac of the VPBE for various outputs
  */
 static int venc_set_dac(struct v4l2_subdev *sd, u32 out_index)
@@ -109,11 +111,12 @@ static int venc_set_dac(struct v4l2_subdev *sd, u32 out_index)
                 venc_write(sd, VENC_DACSEL, 0);
                 break;
         case 1:
-                v4l2_dbg(debug, 1, sd, "Setting output to S-Video\n");
-                venc_write(sd, VENC_DACSEL, 0x210);
+                v4l2_dbg(debug, 1, sd, "Setting output to Component\n");
+                venc_write(sd, VENC_DACSEL, VDAC_COMPONENT);
                 break;
-        case  2:
-                venc_write(sd, VENC_DACSEL, 0x543);
+        case 2:
+                v4l2_dbg(debug, 1, sd, "Setting output to S-video\n");
+                venc_write(sd, VENC_DACSEL, VDAC_S_VIDEO);
                 break;
         default:
                 return -EINVAL;
@@ -124,6 +127,8 @@ static int venc_set_dac(struct v4l2_subdev *sd, u32 out_index)
 
 static void venc_enabledigitaloutput(struct v4l2_subdev *sd, int benable)
 {
+        struct venc_state *venc = to_state(sd);
+        struct venc_platform_data *pdata = venc->pdata;
         v4l2_dbg(debug, 2, sd, "venc_enabledigitaloutput\n");
 
         if (benable) {
@@ -155,7 +160,8 @@ static void venc_enabledigitaloutput(struct v4l2_subdev *sd, int benable)
 
                 /* Disable LCD output control (accepting default polarity) */
                 venc_write(sd, VENC_LCDOUT, 0);
-                venc_write(sd, VENC_CMPNT, 0x100);
+                if (pdata->venc_type != VPBE_VERSION_3)
+                        venc_write(sd, VENC_CMPNT, 0x100);
                 venc_write(sd, VENC_HSPLS, 0);
                 venc_write(sd, VENC_HINT, 0);
                 venc_write(sd, VENC_HSTART, 0);
@@ -178,11 +184,14 @@ static void venc_enabledigitaloutput(struct v4l2_subdev *sd, int benable)
         }
 }
 
+#define VDAC_CONFIG_SD_V3       0x0E21A6B6
+#define VDAC_CONFIG_SD_V2       0x081141CF
 /*
  * setting NTSC mode
  */
 static int venc_set_ntsc(struct v4l2_subdev *sd)
 {
+        u32 val;
         struct venc_state *venc = to_state(sd);
         struct venc_platform_data *pdata = venc->pdata;
 
@@ -195,12 +204,22 @@ static int venc_set_ntsc(struct v4l2_subdev *sd)
 
         venc_enabledigitaloutput(sd, 0);
 
-        /* to set VENC CLK DIV to 1 - final clock is 54 MHz */
-        venc_modify(sd, VENC_VIDCTL, 0, 1 << 1);
-        /* Set REC656 Mode */
-        venc_write(sd, VENC_YCCCTL, 0x1);
-        venc_modify(sd, VENC_VDPRO, 0, VENC_VDPRO_DAFRQ);
-        venc_modify(sd, VENC_VDPRO, 0, VENC_VDPRO_DAUPS);
+        if (pdata->venc_type == VPBE_VERSION_3) {
+                venc_write(sd, VENC_CLKCTL, 0x01);
+                venc_write(sd, VENC_VIDCTL, 0);
+                val = vdaccfg_write(sd, VDAC_CONFIG_SD_V3);
+        } else if (pdata->venc_type == VPBE_VERSION_2) {
+                venc_write(sd, VENC_CLKCTL, 0x01);
+                venc_write(sd, VENC_VIDCTL, 0);
+                vdaccfg_write(sd, VDAC_CONFIG_SD_V2);
+        } else {
+                /* to set VENC CLK DIV to 1 - final clock is 54 MHz */
+                venc_modify(sd, VENC_VIDCTL, 0, 1 << 1);
+                /* Set REC656 Mode */
+                venc_write(sd, VENC_YCCCTL, 0x1);
+                venc_modify(sd, VENC_VDPRO, 0, VENC_VDPRO_DAFRQ);
+                venc_modify(sd, VENC_VDPRO, 0, VENC_VDPRO_DAUPS);
+        }
 
         venc_write(sd, VENC_VMOD, 0);
         venc_modify(sd, VENC_VMOD, (1 << VENC_VMOD_VIE_SHIFT),
@@ -220,6 +239,7 @@ static int venc_set_ntsc(struct v4l2_subdev *sd)
 static int venc_set_pal(struct v4l2_subdev *sd)
 {
         struct venc_state *venc = to_state(sd);
+        struct venc_platform_data *pdata = venc->pdata;
 
         v4l2_dbg(debug, 2, sd, "venc_set_pal\n");
 
@@ -230,10 +250,20 @@ static int venc_set_pal(struct v4l2_subdev *sd)
 
         venc_enabledigitaloutput(sd, 0);
 
-        /* to set VENC CLK DIV to 1 - final clock is 54 MHz */
-        venc_modify(sd, VENC_VIDCTL, 0, 1 << 1);
-        /* Set REC656 Mode */
-        venc_write(sd, VENC_YCCCTL, 0x1);
+        if (pdata->venc_type == VPBE_VERSION_3) {
+                venc_write(sd, VENC_CLKCTL, 0x1);
+                venc_write(sd, VENC_VIDCTL, 0);
+                vdaccfg_write(sd, VDAC_CONFIG_SD_V3);
+        } else if (pdata->venc_type == VPBE_VERSION_2) {
+                venc_write(sd, VENC_CLKCTL, 0x1);
+                venc_write(sd, VENC_VIDCTL, 0);
+                vdaccfg_write(sd, VDAC_CONFIG_SD_V2);
+        } else {
+                /* to set VENC CLK DIV to 1 - final clock is 54 MHz */
+                venc_modify(sd, VENC_VIDCTL, 0, 1 << 1);
+                /* Set REC656 Mode */
+                venc_write(sd, VENC_YCCCTL, 0x1);
+        }
 
         venc_modify(sd, VENC_SYNCCTL, 1 << VENC_SYNCCTL_OVD_SHIFT,
                         VENC_SYNCCTL_OVD);
@@ -252,6 +282,7 @@ static int venc_set_pal(struct v4l2_subdev *sd)
         return 0;
 }
 
+#define VDAC_CONFIG_HD_V2       0x081141EF
 /*
  * venc_set_480p59_94
  *
@@ -263,6 +294,9 @@ static int venc_set_480p59_94(struct v4l2_subdev *sd)
         struct venc_platform_data *pdata = venc->pdata;
 
         v4l2_dbg(debug, 2, sd, "venc_set_480p59_94\n");
+        if ((pdata->venc_type != VPBE_VERSION_1) &&
+            (pdata->venc_type != VPBE_VERSION_2))
+                return -EINVAL;
 
         /* Setup clock at VPSS & VENC for SD */
         if (pdata->setup_clock(VPBE_ENC_DV_PRESET, V4L2_DV_480P59_94) < 0)
@@ -270,12 +304,18 @@ static int venc_set_480p59_94(struct v4l2_subdev *sd)
 
         venc_enabledigitaloutput(sd, 0);
 
+        if (pdata->venc_type == VPBE_VERSION_2)
+                vdaccfg_write(sd, VDAC_CONFIG_HD_V2);
         venc_write(sd, VENC_OSDCLK0, 0);
         venc_write(sd, VENC_OSDCLK1, 1);
-        venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAFRQ,
-                    VENC_VDPRO_DAFRQ);
-        venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAUPS,
-                    VENC_VDPRO_DAUPS);
+
+        if (pdata->venc_type == VPBE_VERSION_1) {
+                venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAFRQ,
+                            VENC_VDPRO_DAFRQ);
+                venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAUPS,
+                            VENC_VDPRO_DAUPS);
+        }
+
         venc_write(sd, VENC_VMOD, 0);
         venc_modify(sd, VENC_VMOD, (1 << VENC_VMOD_VIE_SHIFT),
                     VENC_VMOD_VIE);
@@ -302,19 +342,27 @@ static int venc_set_576p50(struct v4l2_subdev *sd)
 
         v4l2_dbg(debug, 2, sd, "venc_set_576p50\n");
 
+        if ((pdata->venc_type != VPBE_VERSION_1) &&
+          (pdata->venc_type != VPBE_VERSION_2))
+                return -EINVAL;
         /* Setup clock at VPSS & VENC for SD */
         if (pdata->setup_clock(VPBE_ENC_DV_PRESET, V4L2_DV_576P50) < 0)
                 return -EINVAL;
 
         venc_enabledigitaloutput(sd, 0);
 
+        if (pdata->venc_type == VPBE_VERSION_2)
+                vdaccfg_write(sd, VDAC_CONFIG_HD_V2);
+
         venc_write(sd, VENC_OSDCLK0, 0);
         venc_write(sd, VENC_OSDCLK1, 1);
 
-        venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAFRQ,
-                    VENC_VDPRO_DAFRQ);
-        venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAUPS,
-                    VENC_VDPRO_DAUPS);
+        if (pdata->venc_type == VPBE_VERSION_1) {
+                venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAFRQ,
+                            VENC_VDPRO_DAFRQ);
+                venc_modify(sd, VENC_VDPRO, VENC_VDPRO_DAUPS,
+                            VENC_VDPRO_DAUPS);
+        }
 
         venc_write(sd, VENC_VMOD, 0);
         venc_modify(sd, VENC_VMOD, (1 << VENC_VMOD_VIE_SHIFT),
@@ -330,6 +378,63 @@ static int venc_set_576p50(struct v4l2_subdev *sd)
         return 0;
 }
 
+/*
+ * venc_set_720p60_internal - Setup 720p60 in venc for dm365 only
+ */
+static int venc_set_720p60_internal(struct v4l2_subdev *sd)
+{
+        struct venc_state *venc = to_state(sd);
+        struct venc_platform_data *pdata = venc->pdata;
+
+        if (pdata->setup_clock(VPBE_ENC_DV_PRESET, V4L2_DV_720P60) < 0)
+                return -EINVAL;
+
+        venc_enabledigitaloutput(sd, 0);
+
+        venc_write(sd, VENC_OSDCLK0, 0);
+        venc_write(sd, VENC_OSDCLK1, 1);
+
+        venc_write(sd, VENC_VMOD, 0);
+        /* DM365 component HD mode */
+        venc_modify(sd, VENC_VMOD, (1 << VENC_VMOD_VIE_SHIFT),
+            VENC_VMOD_VIE);
+        venc_modify(sd, VENC_VMOD, VENC_VMOD_HDMD, VENC_VMOD_HDMD);
+        venc_modify(sd, VENC_VMOD, (HDTV_720P << VENC_VMOD_TVTYP_SHIFT),
+                    VENC_VMOD_TVTYP);
+        venc_modify(sd, VENC_VMOD, VENC_VMOD_VENC, VENC_VMOD_VENC);
+        venc_write(sd, VENC_XHINTVL, 0);
+        return 0;
+}
+
+/*
+ * venc_set_1080i30_internal - Setup 1080i30 in venc for dm365 only
+ */
+static int venc_set_1080i30_internal(struct v4l2_subdev *sd)
+{
+        struct venc_state *venc = to_state(sd);
+        struct venc_platform_data *pdata = venc->pdata;
+
+        if (pdata->setup_clock(VPBE_ENC_DV_PRESET, V4L2_DV_1080P30) < 0)
+                return -EINVAL;
+
+        venc_enabledigitaloutput(sd, 0);
+
+        venc_write(sd, VENC_OSDCLK0, 0);
+        venc_write(sd, VENC_OSDCLK1, 1);
+
+
+        venc_write(sd, VENC_VMOD, 0);
+        /* DM365 component HD mode */
+        venc_modify(sd, VENC_VMOD, (1 << VENC_VMOD_VIE_SHIFT),
+                    VENC_VMOD_VIE);
+        venc_modify(sd, VENC_VMOD, VENC_VMOD_HDMD, VENC_VMOD_HDMD);
+        venc_modify(sd, VENC_VMOD, (HDTV_1080I << VENC_VMOD_TVTYP_SHIFT),
+                    VENC_VMOD_TVTYP);
+        venc_modify(sd, VENC_VMOD, VENC_VMOD_VENC, VENC_VMOD_VENC);
+        venc_write(sd, VENC_XHINTVL, 0);
+        return 0;
+}
+
 static int venc_s_std_output(struct v4l2_subdev *sd, v4l2_std_id norm)
 {
         v4l2_dbg(debug, 1, sd, "venc_s_std_output\n");
@@ -345,13 +450,30 @@ static int venc_s_std_output(struct v4l2_subdev *sd, v4l2_std_id norm)
 static int venc_s_dv_preset(struct v4l2_subdev *sd,
                             struct v4l2_dv_preset *dv_preset)
 {
+        struct venc_state *venc = to_state(sd);
+        int ret;
+
         v4l2_dbg(debug, 1, sd, "venc_s_dv_preset\n");
 
         if (dv_preset->preset == V4L2_DV_576P50)
                 return venc_set_576p50(sd);
         else if (dv_preset->preset == V4L2_DV_480P59_94)
                 return venc_set_480p59_94(sd);
-
+        else if ((dv_preset->preset == V4L2_DV_720P60) &&
+                        (venc->pdata->venc_type == VPBE_VERSION_2)) {
+                /* TBD setup internal 720p mode here */
+                ret = venc_set_720p60_internal(sd);
+                /* for DM365 VPBE, there is DAC inside */
+                vdaccfg_write(sd, VDAC_CONFIG_HD_V2);
+                return ret;
+        } else if ((dv_preset->preset == V4L2_DV_1080I30) &&
+                (venc->pdata->venc_type == VPBE_VERSION_2)) {
+                /* TBD setup internal 1080i mode here */
+                ret = venc_set_1080i30_internal(sd);
+                /* for DM365 VPBE, there is DAC inside */
+                vdaccfg_write(sd, VDAC_CONFIG_HD_V2);
+                return ret;
+        }
         return -EINVAL;
 }
 
@@ -508,11 +630,41 @@ static int venc_probe(struct platform_device *pdev)
                 goto release_venc_mem_region;
         }
 
+        if (venc->pdata->venc_type != VPBE_VERSION_1) {
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+                if (!res) {
+                        dev_err(venc->pdev,
+                                "Unable to get VDAC_CONFIG address map\n");
+                        ret = -ENODEV;
+                        goto unmap_venc_io;
+                }
+
+                if (!request_mem_region(res->start,
+                                        resource_size(res), "venc")) {
+                        dev_err(venc->pdev,
+                                "Unable to reserve VDAC_CONFIG  MMIO region\n");
+                        ret = -ENODEV;
+                        goto unmap_venc_io;
+                }
+
+                venc->vdaccfg_reg = ioremap_nocache(res->start,
+                                                    resource_size(res));
+                if (!venc->vdaccfg_reg) {
+                        dev_err(venc->pdev,
+                                "Unable to map VDAC_CONFIG IO space\n");
+                        ret = -ENODEV;
+                        goto release_vdaccfg_mem_region;
+                }
+        }
         spin_lock_init(&venc->lock);
         platform_set_drvdata(pdev, venc);
         dev_notice(venc->pdev, "VENC sub device probe success\n");
         return 0;
 
+release_vdaccfg_mem_region:
+        release_mem_region(res->start, resource_size(res));
+unmap_venc_io:
+        iounmap(venc->venc_base);
 release_venc_mem_region:
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         release_mem_region(res->start, resource_size(res));
@@ -529,6 +681,11 @@ static int venc_remove(struct platform_device *pdev)
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         iounmap((void *)venc->venc_base);
         release_mem_region(res->start, resource_size(res));
+        if (venc->pdata->venc_type != VPBE_VERSION_1) {
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+                iounmap((void *)venc->vdaccfg_reg);
+                release_mem_region(res->start, resource_size(res));
+        }
         kfree(venc);
 
         return 0;
@@ -543,23 +700,7 @@ static struct platform_driver venc_driver = {
         },
 };
 
-static int venc_init(void)
-{
-        if (platform_driver_register(&venc_driver)) {
-                printk(KERN_ERR "Unable to register venc driver\n");
-                return -ENODEV;
-        }
-        return 0;
-}
-
-static void venc_exit(void)
-{
-        platform_driver_unregister(&venc_driver);
-        return;
-}
-
-module_init(venc_init);
-module_exit(venc_exit);
+module_platform_driver(venc_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("VPBE VENC Driver");
diff --git a/drivers/media/video/davinci/vpfe_capture.c b/drivers/media/video/davinci/vpfe_capture.c
index 5b38fc93ff28..20cf271a774b 100644
--- a/drivers/media/video/davinci/vpfe_capture.c
+++ b/drivers/media/video/davinci/vpfe_capture.c
@@ -2076,20 +2076,4 @@ static struct platform_driver vpfe_driver = {
         .remove = __devexit_p(vpfe_remove),
 };
 
-static __init int vpfe_init(void)
-{
-        printk(KERN_NOTICE "vpfe_init\n");
-        /* Register driver to the kernel */
-        return platform_driver_register(&vpfe_driver);
-}
-
-/*
- * vpfe_cleanup : This function un-registers device driver
- */
-static void vpfe_cleanup(void)
-{
-        platform_driver_unregister(&vpfe_driver);
-}
-
-module_init(vpfe_init);
-module_exit(vpfe_cleanup);
+module_platform_driver(vpfe_driver);
diff --git a/drivers/media/video/davinci/vpif_capture.c b/drivers/media/video/davinci/vpif_capture.c
index 49e4deb50043..6504e40a31dd 100644
--- a/drivers/media/video/davinci/vpif_capture.c
+++ b/drivers/media/video/davinci/vpif_capture.c
@@ -2177,6 +2177,12 @@ static __init int vpif_probe(struct platform_device *pdev)
                 return err;
         }
 
+        err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev);
+        if (err) {
+                v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n");
+                return err;
+        }
+
         k = 0;
         while ((res = platform_get_resource(pdev, IORESOURCE_IRQ, k))) {
                 for (i = res->start; i <= res->end; i++) {
@@ -2246,12 +2252,6 @@ static __init int vpif_probe(struct platform_device *pdev)
                 goto probe_out;
         }
 
-        err = v4l2_device_register(vpif_dev, &vpif_obj.v4l2_dev);
-        if (err) {
-                v4l2_err(vpif_dev->driver, "Error registering v4l2 device\n");
-                goto probe_subdev_out;
-        }
-
         for (i = 0; i < subdev_count; i++) {
                 subdevdata = &config->subdev_info[i];
                 vpif_obj.sd[i] =
@@ -2281,7 +2281,6 @@ probe_subdev_out:
 
         j = VPIF_CAPTURE_MAX_DEVICES;
 probe_out:
-        v4l2_device_unregister(&vpif_obj.v4l2_dev);
         for (k = 0; k < j; k++) {
                 /* Get the pointer to the channel object */
                 ch = vpif_obj.dev[k];
@@ -2303,6 +2302,7 @@ vpif_int_err:
                 if (res)
                         i = res->end;
         }
+        v4l2_device_unregister(&vpif_obj.v4l2_dev);
         return err;
 }
 
diff --git a/drivers/media/video/em28xx/em28xx-audio.c b/drivers/media/video/em28xx/em28xx-audio.c
index cff0768afbf5..e2a7b77c39c7 100644
--- a/drivers/media/video/em28xx/em28xx-audio.c
+++ b/drivers/media/video/em28xx/em28xx-audio.c
@@ -193,7 +193,7 @@ static int em28xx_init_audio_isoc(struct em28xx *dev)
 
                 urb->dev = dev->udev;
                 urb->context = dev;
-                urb->pipe = usb_rcvisocpipe(dev->udev, 0x83);
+                urb->pipe = usb_rcvisocpipe(dev->udev, EM28XX_EP_AUDIO);
                 urb->transfer_flags = URB_ISO_ASAP;
                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
                 urb->interval = 1;
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 93807dcf944e..4561cd89938d 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -336,6 +336,23 @@ static struct em28xx_reg_seq pctv_460e[] = {
         {             -1,   -1,   -1,  -1},
 };
 
+#if 0
+static struct em28xx_reg_seq hauppauge_930c_gpio[] = {
+        {EM2874_R80_GPIO,       0x6f,   0xff,   10},
+        {EM2874_R80_GPIO,       0x4f,   0xff,   10}, /* xc5000 reset */
+        {EM2874_R80_GPIO,       0x6f,   0xff,   10},
+        {EM2874_R80_GPIO,       0x4f,   0xff,   10},
+        { -1,                   -1,     -1,     -1},
+};
+
+static struct em28xx_reg_seq hauppauge_930c_digital[] = {
+        {EM2874_R80_GPIO,       0xf6,   0xff,   10},
+        {EM2874_R80_GPIO,       0xe6,   0xff,   100},
+        {EM2874_R80_GPIO,       0xa6,   0xff,   10},
+        { -1,                   -1,     -1,     -1},
+};
+#endif
+
 /*
  *  Board definitions
  */
@@ -839,6 +856,10 @@ struct em28xx_board em28xx_boards[] = {
         [EM2870_BOARD_KWORLD_355U] = {
                 .name         = "Kworld 355 U DVB-T",
                 .valid        = EM28XX_BOARD_NOT_VALIDATED,
+                .tuner_type   = TUNER_ABSENT,
+                .tuner_gpio   = default_tuner_gpio,
+                .has_dvb      = 1,
+                .dvb_gpio     = default_digital,
         },
         [EM2870_BOARD_PINNACLE_PCTV_DVB] = {
                 .name         = "Pinnacle PCTV DVB-T",
@@ -887,6 +908,37 @@ struct em28xx_board em28xx_boards[] = {
                 .tuner_addr   = 0x41,
                 .dvb_gpio     = terratec_h5_digital, /* FIXME: probably wrong */
                 .tuner_gpio   = terratec_h5_gpio,
+#else
+                .tuner_type   = TUNER_ABSENT,
+#endif
+                .i2c_speed    = EM2874_I2C_SECONDARY_BUS_SELECT |
+                                EM28XX_I2C_CLK_WAIT_ENABLE |
+                                EM28XX_I2C_FREQ_400_KHZ,
+        },
+        [EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C] = {
+                .name         = "Hauppauge WinTV HVR 930C",
+                .has_dvb      = 1,
+#if 0 /* FIXME: Add analog support */
+                .tuner_type   = TUNER_XC5000,
+                .tuner_addr   = 0x41,
+                .dvb_gpio     = hauppauge_930c_digital,
+                .tuner_gpio   = hauppauge_930c_gpio,
+#else
+                .tuner_type   = TUNER_ABSENT,
+#endif
+                .ir_codes     = RC_MAP_HAUPPAUGE,
+                .i2c_speed    = EM2874_I2C_SECONDARY_BUS_SELECT |
+                                EM28XX_I2C_CLK_WAIT_ENABLE |
+                                EM28XX_I2C_FREQ_400_KHZ,
+        },
+        [EM2884_BOARD_CINERGY_HTC_STICK] = {
+                .name         = "Terratec Cinergy HTC Stick",
+                .has_dvb      = 1,
+#if 0
+                .tuner_type   = TUNER_PHILIPS_TDA8290,
+                .tuner_addr   = 0x41,
+                .dvb_gpio     = terratec_h5_digital, /* FIXME: probably wrong */
+                .tuner_gpio   = terratec_h5_gpio,
 #endif
                 .i2c_speed    = EM2874_I2C_SECONDARY_BUS_SELECT |
                                 EM28XX_I2C_CLK_WAIT_ENABLE |
@@ -1127,7 +1179,7 @@ struct em28xx_board em28xx_boards[] = {
                 .name         = "Terratec Cinergy 200 USB",
                 .is_em2800    = 1,
                 .has_ir_i2c   = 1,
-                .tuner_type   = TUNER_LG_PAL_NEW_TAPC,
+                .tuner_type   = TUNER_LG_TALN,
                 .tda9887_conf = TDA9887_PRESENT,
                 .decoder      = EM28XX_SAA711X,
                 .input        = { {
@@ -1218,7 +1270,7 @@ struct em28xx_board em28xx_boards[] = {
         },
         [EM2820_BOARD_PINNACLE_DVC_90] = {
                 .name         = "Pinnacle Dazzle DVC 90/100/101/107 / Kaiser Baas Video to DVD maker "
-                                "/ Kworld DVD Maker 2",
+                               "/ Kworld DVD Maker 2 / Plextor ConvertX PX-AV100U",
                 .tuner_type   = TUNER_ABSENT, /* capture only board */
                 .decoder      = EM28XX_SAA711X,
                 .input        = { {
@@ -1840,6 +1892,22 @@ struct em28xx_board em28xx_boards[] = {
                 .has_dvb       = 1,
                 .ir_codes      = RC_MAP_PINNACLE_PCTV_HD,
         },
+        /* eb1a:5006 Honestech VIDBOX NW03
+         * Empia EM2860, Philips SAA7113, Empia EMP202, No Tuner */
+        [EM2860_BOARD_HT_VIDBOX_NW03] = {
+                .name                = "Honestech Vidbox NW03",
+                .tuner_type          = TUNER_ABSENT,
+                .decoder             = EM28XX_SAA711X,
+                .input               = { {
+                        .type     = EM28XX_VMUX_COMPOSITE1,
+                        .vmux     = SAA7115_COMPOSITE0,
+                        .amux     = EM28XX_AMUX_LINE_IN,
+                }, {
+                        .type     = EM28XX_VMUX_SVIDEO,
+                        .vmux     = SAA7115_SVIDEO3,  /* S-VIDEO needs confirming */
+                        .amux     = EM28XX_AMUX_LINE_IN,
+                } },
+        },
 };
 const unsigned int em28xx_bcount = ARRAY_SIZE(em28xx_boards);
 
@@ -1899,6 +1967,8 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM2800_BOARD_GRABBEEX_USB2800 },
         { USB_DEVICE(0xeb1a, 0xe357),
                         .driver_info = EM2870_BOARD_KWORLD_355U },
+        { USB_DEVICE(0xeb1a, 0xe359),
+                        .driver_info = EM2870_BOARD_KWORLD_355U },
         { USB_DEVICE(0x1b80, 0xe302),
                         .driver_info = EM2820_BOARD_PINNACLE_DVC_90 }, /* Kaiser Baas Video to DVD maker */
         { USB_DEVICE(0x1b80, 0xe304),
@@ -1914,17 +1984,23 @@ struct usb_device_id em28xx_id_table[] = {
         { USB_DEVICE(0x0ccd, 0x0042),
                         .driver_info = EM2882_BOARD_TERRATEC_HYBRID_XS },
         { USB_DEVICE(0x0ccd, 0x0043),
+                        .driver_info = EM2870_BOARD_TERRATEC_XS },
+        { USB_DEVICE(0x0ccd, 0x008e),   /* Cinergy HTC USB XS Rev. 1 */
+                        .driver_info = EM2884_BOARD_TERRATEC_H5 },
+        { USB_DEVICE(0x0ccd, 0x00ac),   /* Cinergy HTC USB XS Rev. 2 */
+                        .driver_info = EM2884_BOARD_TERRATEC_H5 },
+        { USB_DEVICE(0x0ccd, 0x10a2),   /* H5 Rev. 1 */
                         .driver_info = EM2884_BOARD_TERRATEC_H5 },
-        { USB_DEVICE(0x0ccd, 0x10a2),   /* Rev. 1 */
+        { USB_DEVICE(0x0ccd, 0x10ad),   /* H5 Rev. 2 */
                         .driver_info = EM2884_BOARD_TERRATEC_H5 },
-        { USB_DEVICE(0x0ccd, 0x10ad),   /* Rev. 2 */
-                        .driver_info = EM2880_BOARD_TERRATEC_PRODIGY_XS },
         { USB_DEVICE(0x0ccd, 0x0084),
                         .driver_info = EM2860_BOARD_TERRATEC_AV350 },
         { USB_DEVICE(0x0ccd, 0x0096),
                         .driver_info = EM2860_BOARD_TERRATEC_GRABBY },
         { USB_DEVICE(0x0ccd, 0x10AF),
                         .driver_info = EM2860_BOARD_TERRATEC_GRABBY },
+        { USB_DEVICE(0x0ccd, 0x00b2),
+                        .driver_info = EM2884_BOARD_CINERGY_HTC_STICK },
         { USB_DEVICE(0x0fd9, 0x0033),
                         .driver_info = EM2860_BOARD_ELGATO_VIDEO_CAPTURE},
         { USB_DEVICE(0x185b, 0x2870),
@@ -1963,6 +2039,8 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM2880_BOARD_PINNACLE_PCTV_HD_PRO },
         { USB_DEVICE(0x0413, 0x6023),
                         .driver_info = EM2800_BOARD_LEADTEK_WINFAST_USBII },
+        { USB_DEVICE(0x093b, 0xa003),
+                       .driver_info = EM2820_BOARD_PINNACLE_DVC_90 },
         { USB_DEVICE(0x093b, 0xa005),
                         .driver_info = EM2861_BOARD_PLEXTOR_PX_TV100U },
         { USB_DEVICE(0x04bb, 0x0515),
@@ -1975,6 +2053,12 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM28174_BOARD_PCTV_290E },
         { USB_DEVICE(0x2013, 0x024c),
                         .driver_info = EM28174_BOARD_PCTV_460E },
+        { USB_DEVICE(0x2040, 0x1605),
+                        .driver_info = EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C },
+        { USB_DEVICE(0xeb1a, 0x5006),
+                        .driver_info = EM2860_BOARD_HT_VIDBOX_NW03 },
+        { USB_DEVICE(0x1b80, 0xe309), /* Sveon STV40 */
+                        .driver_info = EM2860_BOARD_EASYCAP },
         { },
 };
 MODULE_DEVICE_TABLE(usb, em28xx_id_table);
@@ -2028,10 +2112,10 @@ int em28xx_tuner_callback(void *ptr, int component, int command, int arg)
         int rc = 0;
         struct em28xx *dev = ptr;
 
-        if (dev->tuner_type != TUNER_XC2028)
+        if (dev->tuner_type != TUNER_XC2028 && dev->tuner_type != TUNER_XC5000)
                 return 0;
 
-        if (command != XC2028_TUNER_RESET)
+        if (command != XC2028_TUNER_RESET && command != XC5000_TUNER_RESET)
                 return 0;
 
         rc = em28xx_gpio_set(dev, dev->board.tuner_gpio);
@@ -2203,7 +2287,8 @@ void em28xx_pre_card_setup(struct em28xx *dev)
         /* Set the initial XCLK and I2C clock values based on the board
            definition */
         em28xx_write_reg(dev, EM28XX_R0F_XCLK, dev->board.xclk & 0x7f);
-        em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, dev->board.i2c_speed);
+        if (!dev->board.is_em2800)
+                em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, dev->board.i2c_speed);
         msleep(50);
 
         /* request some modules */
@@ -2832,11 +2917,10 @@ void em28xx_release_resources(struct em28xx *dev)
  * em28xx_init_dev()
  * allocates and inits the device structs, registers i2c bus and v4l device
  */
-static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
+static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
                            struct usb_interface *interface,
                            int minor)
 {
-        struct em28xx *dev = *devhandle;
         int retval;
 
         dev->udev = udev;
@@ -2931,7 +3015,7 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
 
         if (!dev->board.is_em2800) {
                 /* Resets I2C speed */
-                em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, dev->board.i2c_speed);
+                retval = em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, dev->board.i2c_speed);
                 if (retval < 0) {
                         em28xx_errdev("%s: em28xx_write_reg failed!"
                                       " retval [%d]\n",
@@ -3031,12 +3115,11 @@ unregister_dev:
 static int em28xx_usb_probe(struct usb_interface *interface,
                             const struct usb_device_id *id)
 {
-        const struct usb_endpoint_descriptor *endpoint;
         struct usb_device *udev;
         struct em28xx *dev = NULL;
         int retval;
-        bool is_audio_only = false, has_audio = false;
-        int i, nr, isoc_pipe;
+        bool has_audio = false, has_video = false, has_dvb = false;
+        int i, nr;
         const int ifnum = interface->altsetting[0].desc.bInterfaceNumber;
         char *speed;
         char descr[255] = "";
@@ -3068,54 +3151,65 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 goto err;
         }
 
+        /* allocate memory for our device state and initialize it */
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (dev == NULL) {
+                em28xx_err(DRIVER_NAME ": out of memory!\n");
+                retval = -ENOMEM;
+                goto err;
+        }
+
+        /* compute alternate max packet sizes */
+        dev->alt_max_pkt_size = kmalloc(sizeof(dev->alt_max_pkt_size[0]) *
+                                        interface->num_altsetting, GFP_KERNEL);
+        if (dev->alt_max_pkt_size == NULL) {
+                em28xx_errdev("out of memory!\n");
+                kfree(dev);
+                retval = -ENOMEM;
+                goto err;
+        }
+
         /* Get endpoints */
         for (i = 0; i < interface->num_altsetting; i++) {
                 int ep;
 
                 for (ep = 0; ep < interface->altsetting[i].desc.bNumEndpoints; ep++) {
-                        struct usb_host_endpoint        *e;
-                        e = &interface->altsetting[i].endpoint[ep];
-
-                        if (e->desc.bEndpointAddress == 0x83)
-                                has_audio = true;
+                        const struct usb_endpoint_descriptor *e;
+                        int sizedescr, size;
+
+                        e = &interface->altsetting[i].endpoint[ep].desc;
+
+                        sizedescr = le16_to_cpu(e->wMaxPacketSize);
+                        size = sizedescr & 0x7ff;
+
+                        if (udev->speed == USB_SPEED_HIGH)
+                                size = size * hb_mult(sizedescr);
+
+                        if (usb_endpoint_xfer_isoc(e) &&
+                            usb_endpoint_dir_in(e)) {
+                                switch (e->bEndpointAddress) {
+                                case EM28XX_EP_AUDIO:
+                                        has_audio = true;
+                                        break;
+                                case EM28XX_EP_ANALOG:
+                                        has_video = true;
+                                        dev->alt_max_pkt_size[i] = size;
+                                        break;
+                                case EM28XX_EP_DIGITAL:
+                                        has_dvb = true;
+                                        if (size > dev->dvb_max_pkt_size) {
+                                                dev->dvb_max_pkt_size = size;
+                                                dev->dvb_alt = i;
+                                        }
+                                        break;
+                                }
+                        }
                 }
         }
 
-        endpoint = &interface->cur_altsetting->endpoint[0].desc;
-
-        /* check if the device has the iso in endpoint at the correct place */
-        if (usb_endpoint_xfer_isoc(endpoint)
-            &&
-            (interface->altsetting[1].endpoint[0].desc.wMaxPacketSize == 940)) {
-                /* It's a newer em2874/em2875 device */
-                isoc_pipe = 0;
-        } else {
-                int check_interface = 1;
-                isoc_pipe = 1;
-                endpoint = &interface->cur_altsetting->endpoint[1].desc;
-                if (!usb_endpoint_xfer_isoc(endpoint))
-                        check_interface = 0;
-
-                if (usb_endpoint_dir_out(endpoint))
-                        check_interface = 0;
-
-                if (!check_interface) {
-                        if (has_audio) {
-                                is_audio_only = true;
-                        } else {
-                                em28xx_err(DRIVER_NAME " video device (%04x:%04x): "
-                                        "interface %i, class %i found.\n",
-                                        le16_to_cpu(udev->descriptor.idVendor),
-                                        le16_to_cpu(udev->descriptor.idProduct),
-                                        ifnum,
-                                        interface->altsetting[0].desc.bInterfaceClass);
-                                em28xx_err(DRIVER_NAME " This is an anciliary "
-                                        "interface not used by the driver\n");
-
-                                retval = -ENODEV;
-                                goto err;
-                        }
-                }
+        if (!(has_audio || has_video || has_dvb)) {
+                retval = -ENODEV;
+                goto err_free;
         }
 
         switch (udev->speed) {
@@ -3141,6 +3235,7 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                         strlcat(descr, " ", sizeof(descr));
                 strlcat(descr, udev->product, sizeof(descr));
         }
+
         if (*descr)
                 strlcat(descr, " ", sizeof(descr));
 
@@ -3157,6 +3252,14 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 printk(KERN_INFO DRIVER_NAME
                        ": Audio Vendor Class interface %i found\n",
                        ifnum);
+        if (has_video)
+                printk(KERN_INFO DRIVER_NAME
+                       ": Video interface %i found\n",
+                       ifnum);
+        if (has_dvb)
+                printk(KERN_INFO DRIVER_NAME
+                       ": DVB interface %i found\n",
+                       ifnum);
 
         /*
          * Make sure we have 480 Mbps of bandwidth, otherwise things like
@@ -3168,22 +3271,14 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 printk(DRIVER_NAME ": Device must be connected to a high-speed"
                        " USB 2.0 port.\n");
                 retval = -ENODEV;
-                goto err;
-        }
-
-        /* allocate memory for our device state and initialize it */
-        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-        if (dev == NULL) {
-                em28xx_err(DRIVER_NAME ": out of memory!\n");
-                retval = -ENOMEM;
-                goto err;
+                goto err_free;
         }
 
         snprintf(dev->name, sizeof(dev->name), "em28xx #%d", nr);
         dev->devno = nr;
         dev->model = id->driver_info;
         dev->alt   = -1;
-        dev->is_audio_only = is_audio_only;
+        dev->is_audio_only = has_audio && !(has_video || has_dvb);
         dev->has_alsa_audio = has_audio;
         dev->audio_ifnum = ifnum;
 
@@ -3196,26 +3291,7 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 }
         }
 
-        /* compute alternate max packet sizes */
         dev->num_alt = interface->num_altsetting;
-        dev->alt_max_pkt_size = kmalloc(32 * dev->num_alt, GFP_KERNEL);
-
-        if (dev->alt_max_pkt_size == NULL) {
-                em28xx_errdev("out of memory!\n");
-                kfree(dev);
-                retval = -ENOMEM;
-                goto err;
-        }
-
-        for (i = 0; i < dev->num_alt ; i++) {
-                u16 tmp = le16_to_cpu(interface->altsetting[i].endpoint[isoc_pipe].desc.wMaxPacketSize);
-                unsigned int size = tmp & 0x7ff;
-
-                if (udev->speed == USB_SPEED_HIGH)
-                        size = size * hb_mult(tmp);
-
-                dev->alt_max_pkt_size[i] = size;
-        }
 
         if ((card[nr] >= 0) && (card[nr] < em28xx_bcount))
                 dev->model = card[nr];
@@ -3226,12 +3302,9 @@ static int em28xx_usb_probe(struct usb_interface *interface,
         /* allocate device struct */
         mutex_init(&dev->lock);
         mutex_lock(&dev->lock);
-        retval = em28xx_init_dev(&dev, udev, interface, nr);
+        retval = em28xx_init_dev(dev, udev, interface, nr);
         if (retval) {
-                mutex_unlock(&dev->lock);
-                kfree(dev->alt_max_pkt_size);
-                kfree(dev);
-                goto err;
+                goto unlock_and_free;
         }
 
         request_modules(dev);
@@ -3250,6 +3323,13 @@ static int em28xx_usb_probe(struct usb_interface *interface,
 
         return 0;
 
+unlock_and_free:
+        mutex_unlock(&dev->lock);
+
+err_free:
+        kfree(dev->alt_max_pkt_size);
+        kfree(dev);
+
 err:
         clear_bit(nr, &em28xx_devused);
 
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index 804a4ab47ac6..0aacc96f9a23 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -568,7 +568,7 @@ int em28xx_audio_setup(struct em28xx *dev)
         em28xx_warn("AC97 features = 0x%04x\n", feat);
 
         /* Try to identify what audio processor we have */
-        if ((vid == 0xffffffff) && (feat == 0x6a90))
+        if (((vid == 0xffffffff) || (vid == 0x83847650)) && (feat == 0x6a90))
                 dev->audio_mode.ac97 = EM28XX_AC97_EM202;
         else if ((vid >> 8) == 0x838476)
                 dev->audio_mode.ac97 = EM28XX_AC97_SIGMATEL;
@@ -1070,7 +1070,8 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
                         should also be using 'desc.bInterval'
                  */
                 pipe = usb_rcvisocpipe(dev->udev,
-                        dev->mode == EM28XX_ANALOG_MODE ? 0x82 : 0x84);
+                                       dev->mode == EM28XX_ANALOG_MODE ?
+                                       EM28XX_EP_ANALOG : EM28XX_EP_DIGITAL);
 
                 usb_fill_int_urb(urb, dev->udev, pipe,
                                  dev->isoc_ctl.transfer_buffer[i], sb_size,
@@ -1108,62 +1109,6 @@ int em28xx_init_isoc(struct em28xx *dev, int max_packets,
 }
 EXPORT_SYMBOL_GPL(em28xx_init_isoc);
 
-/* Determine the packet size for the DVB stream for the given device
-   (underlying value programmed into the eeprom) */
-int em28xx_isoc_dvb_max_packetsize(struct em28xx *dev)
-{
-        unsigned int chip_cfg2;
-        unsigned int packet_size;
-
-        switch (dev->chip_id) {
-        case CHIP_ID_EM2710:
-        case CHIP_ID_EM2750:
-        case CHIP_ID_EM2800:
-        case CHIP_ID_EM2820:
-        case CHIP_ID_EM2840:
-        case CHIP_ID_EM2860:
-                /* No DVB support */
-                return -EINVAL;
-        case CHIP_ID_EM2870:
-        case CHIP_ID_EM2883:
-                /* TS max packet size stored in bits 1-0 of R01 */
-                chip_cfg2 = em28xx_read_reg(dev, EM28XX_R01_CHIPCFG2);
-                switch (chip_cfg2 & EM28XX_CHIPCFG2_TS_PACKETSIZE_MASK) {
-                case EM28XX_CHIPCFG2_TS_PACKETSIZE_188:
-                        packet_size = 188;
-                        break;
-                case EM28XX_CHIPCFG2_TS_PACKETSIZE_376:
-                        packet_size = 376;
-                        break;
-                case EM28XX_CHIPCFG2_TS_PACKETSIZE_564:
-                        packet_size = 564;
-                        break;
-                case EM28XX_CHIPCFG2_TS_PACKETSIZE_752:
-                        packet_size = 752;
-                        break;
-                }
-                break;
-        case CHIP_ID_EM2874:
-                /*
-                 * FIXME: for now assumes 564 like it was before, but the
-                 * em2874 code should be added to return the proper value
-                 */
-                packet_size = 564;
-                break;
-        case CHIP_ID_EM2884:
-        case CHIP_ID_EM28174:
-        default:
-                /*
-                 * FIXME: same as em2874. 564 was enough for 22 Mbit DVB-T
-                 * but not enough for 44 Mbit DVB-C.
-                 */
-                packet_size = 752;
-        }
-
-        return packet_size;
-}
-EXPORT_SYMBOL_GPL(em28xx_isoc_dvb_max_packetsize);
-
 /*
  * em28xx_wake_i2c()
  * configure i2c attached devices
diff --git a/drivers/media/video/em28xx/em28xx-dvb.c b/drivers/media/video/em28xx/em28xx-dvb.c
index cef7a2d409cb..9449423098e0 100644
--- a/drivers/media/video/em28xx/em28xx-dvb.c
+++ b/drivers/media/video/em28xx/em28xx-dvb.c
@@ -44,6 +44,7 @@
 #include "drxk.h"
 #include "tda10071.h"
 #include "a8293.h"
+#include "qt1010.h"
 
 MODULE_DESCRIPTION("driver for em28xx based DVB cards");
 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
@@ -163,12 +164,12 @@ static int em28xx_start_streaming(struct em28xx_dvb *dvb)
         struct em28xx *dev = dvb->adapter.priv;
         int max_dvb_packet_size;
 
-        usb_set_interface(dev->udev, 0, 1);
+        usb_set_interface(dev->udev, 0, dev->dvb_alt);
         rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
         if (rc < 0)
                 return rc;
 
-        max_dvb_packet_size = em28xx_isoc_dvb_max_packetsize(dev);
+        max_dvb_packet_size = dev->dvb_max_pkt_size;
         if (max_dvb_packet_size < 0)
                 return max_dvb_packet_size;
         dprintk(1, "Using %d buffers each with %d bytes\n",
@@ -302,10 +303,12 @@ static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = {
 };
 
 static struct drxd_config em28xx_drxd = {
-        .index = 0, .demod_address = 0x70, .demod_revision = 0xa2,
-        .demoda_address = 0x00, .pll_address = 0x00,
-        .pll_type = DRXD_PLL_NONE, .clock = 12000, .insert_rs_byte = 1,
-        .pll_set = NULL, .osc_deviation = NULL, .IF = 42800000,
+        .demod_address = 0x70,
+        .demod_revision = 0xa2,
+        .pll_type = DRXD_PLL_NONE,
+        .clock = 12000,
+        .insert_rs_byte = 1,
+        .IF = 42800000,
         .disable_i2c_gate_ctrl = 1,
 };
 
@@ -316,6 +319,14 @@ struct drxk_config terratec_h5_drxk = {
         .microcode_name = "dvb-usb-terratec-h5-drxk.fw",
 };
 
+struct drxk_config hauppauge_930c_drxk = {
+        .adr = 0x29,
+        .single_master = 1,
+        .no_i2c_bridge = 1,
+        .microcode_name = "dvb-usb-hauppauge-hvr930c-drxk.fw",
+        .chunk_size = 56,
+};
+
 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
 {
         struct em28xx_dvb *dvb = fe->sec_priv;
@@ -334,6 +345,73 @@ static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
         return status;
 }
 
+static void hauppauge_hvr930c_init(struct em28xx *dev)
+{
+        int i;
+
+        struct em28xx_reg_seq hauppauge_hvr930c_init[] = {
+                {EM2874_R80_GPIO,       0xff,   0xff,   0x65},
+                {EM2874_R80_GPIO,       0xfb,   0xff,   0x32},
+                {EM2874_R80_GPIO,       0xff,   0xff,   0xb8},
+                { -1,                   -1,     -1,     -1},
+        };
+        struct em28xx_reg_seq hauppauge_hvr930c_end[] = {
+                {EM2874_R80_GPIO,       0xef,   0xff,   0x01},
+                {EM2874_R80_GPIO,       0xaf,   0xff,   0x65},
+                {EM2874_R80_GPIO,       0xef,   0xff,   0x76},
+                {EM2874_R80_GPIO,       0xef,   0xff,   0x01},
+                {EM2874_R80_GPIO,       0xcf,   0xff,   0x0b},
+                {EM2874_R80_GPIO,       0xef,   0xff,   0x40},
+
+                {EM2874_R80_GPIO,       0xcf,   0xff,   0x65},
+                {EM2874_R80_GPIO,       0xef,   0xff,   0x65},
+                {EM2874_R80_GPIO,       0xcf,   0xff,   0x0b},
+                {EM2874_R80_GPIO,       0xef,   0xff,   0x65},
+
+                { -1,                   -1,     -1,     -1},
+        };
+
+        struct {
+                unsigned char r[4];
+                int len;
+        } regs[] = {
+                {{ 0x06, 0x02, 0x00, 0x31 }, 4},
+                {{ 0x01, 0x02 }, 2},
+                {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
+                {{ 0x01, 0x00 }, 2},
+                {{ 0x01, 0x00, 0xff, 0xaf }, 4},
+                {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
+                {{ 0x01, 0x00 }, 2},
+                {{ 0x01, 0x00, 0x73, 0xaf }, 4},
+                {{ 0x04, 0x00 }, 2},
+                {{ 0x00, 0x04 }, 2},
+                {{ 0x00, 0x04, 0x00, 0x0a }, 4},
+                {{ 0x04, 0x14 }, 2},
+                {{ 0x04, 0x14, 0x00, 0x00 }, 4},
+        };
+
+        em28xx_gpio_set(dev, hauppauge_hvr930c_init);
+        em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
+        msleep(10);
+        em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
+        msleep(10);
+
+        dev->i2c_client.addr = 0x82 >> 1;
+
+        for (i = 0; i < ARRAY_SIZE(regs); i++)
+                i2c_master_send(&dev->i2c_client, regs[i].r, regs[i].len);
+        em28xx_gpio_set(dev, hauppauge_hvr930c_end);
+
+        msleep(100);
+
+        em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
+        msleep(30);
+
+        em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
+        msleep(10);
+
+}
+
 static void terratec_h5_init(struct em28xx *dev)
 {
         int i;
@@ -425,13 +503,6 @@ static struct tda10023_config em28xx_tda10023_config = {
 static struct cxd2820r_config em28xx_cxd2820r_config = {
         .i2c_address = (0xd8 >> 1),
         .ts_mode = CXD2820R_TS_SERIAL,
-        .if_dvbt_6  = 3300,
-        .if_dvbt_7  = 3500,
-        .if_dvbt_8  = 4000,
-        .if_dvbt2_6 = 3300,
-        .if_dvbt2_7 = 3500,
-        .if_dvbt2_8 = 4000,
-        .if_dvbc    = 5000,
 
         /* enable LNA for DVB-T2 and DVB-C */
         .gpio_dvbt2[0] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | CXD2820R_GPIO_L,
@@ -456,6 +527,17 @@ static const struct a8293_config em28xx_a8293_config = {
         .i2c_addr = 0x08, /* (0x10 >> 1) */
 };
 
+static struct zl10353_config em28xx_zl10353_no_i2c_gate_dev = {
+        .demod_address = (0x1e >> 1),
+        .disable_i2c_gate_ctrl = 1,
+        .no_tuner = 1,
+        .parallel_ts = 1,
+};
+static struct qt1010_config em28xx_qt1010_config = {
+        .i2c_address = 0x62
+
+};
+
 /* ------------------------------------------------------------------ */
 
 static int em28xx_attach_xc3028(u8 addr, struct em28xx *dev)
@@ -708,6 +790,14 @@ static int em28xx_dvb_init(struct em28xx *dev)
                         goto out_free;
                 }
                 break;
+        case EM2870_BOARD_KWORLD_355U:
+                dvb->fe[0] = dvb_attach(zl10353_attach,
+                                           &em28xx_zl10353_no_i2c_gate_dev,
+                                           &dev->i2c_adap);
+                if (dvb->fe[0] != NULL)
+                        dvb_attach(qt1010_attach, dvb->fe[0],
+                                   &dev->i2c_adap, &em28xx_qt1010_config);
+                break;
         case EM2883_BOARD_KWORLD_HYBRID_330U:
         case EM2882_BOARD_EVGA_INDTUBE:
                 dvb->fe[0] = dvb_attach(s5h1409_attach,
@@ -761,50 +851,72 @@ static int em28xx_dvb_init(struct em28xx *dev)
                                    &dev->i2c_adap, &kworld_a340_config);
                 break;
         case EM28174_BOARD_PCTV_290E:
-                /* MFE
-                 * FE 0 = DVB-T/T2 + FE 1 = DVB-C, both sharing same tuner. */
-                /* FE 0 */
                 dvb->fe[0] = dvb_attach(cxd2820r_attach,
-                        &em28xx_cxd2820r_config, &dev->i2c_adap, NULL);
+                                        &em28xx_cxd2820r_config,
+                                        &dev->i2c_adap,
+                                        NULL);
                 if (dvb->fe[0]) {
                         /* FE 0 attach tuner */
-                        if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
-                                &dev->i2c_adap, &em28xx_cxd2820r_tda18271_config)) {
+                        if (!dvb_attach(tda18271_attach,
+                                        dvb->fe[0],
+                                        0x60,
+                                        &dev->i2c_adap,
+                                        &em28xx_cxd2820r_tda18271_config)) {
+
                                 dvb_frontend_detach(dvb->fe[0]);
                                 result = -EINVAL;
                                 goto out_free;
                         }
-                        /* FE 1. This dvb_attach() cannot fail. */
-                        dvb->fe[1] = dvb_attach(cxd2820r_attach, NULL, NULL,
-                                dvb->fe[0]);
-                        dvb->fe[1]->id = 1;
-                        /* FE 1 attach tuner */
-                        if (!dvb_attach(tda18271_attach, dvb->fe[1], 0x60,
-                                &dev->i2c_adap, &em28xx_cxd2820r_tda18271_config)) {
-                                dvb_frontend_detach(dvb->fe[1]);
-                                /* leave FE 0 still active */
-                        }
+                }
+                break;
+        case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C:
+        {
+                struct xc5000_config cfg;
+                hauppauge_hvr930c_init(dev);
+
+                dvb->fe[0] = dvb_attach(drxk_attach,
+                                        &hauppauge_930c_drxk, &dev->i2c_adap);
+                if (!dvb->fe[0]) {
+                        result = -EINVAL;
+                        goto out_free;
+                }
+                /* FIXME: do we need a pll semaphore? */
+                dvb->fe[0]->sec_priv = dvb;
+                sema_init(&dvb->pll_mutex, 1);
+                dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
+                dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
 
-                        mfe_shared = 1;
+                /* Attach xc5000 */
+                memset(&cfg, 0, sizeof(cfg));
+                cfg.i2c_address  = 0x61;
+                cfg.if_khz = 4000;
+
+                if (dvb->fe[0]->ops.i2c_gate_ctrl)
+                        dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
+                if (!dvb_attach(xc5000_attach, dvb->fe[0], &dev->i2c_adap,
+                                &cfg)) {
+                        result = -EINVAL;
+                        goto out_free;
                 }
+                if (dvb->fe[0]->ops.i2c_gate_ctrl)
+                        dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
+
                 break;
+        }
         case EM2884_BOARD_TERRATEC_H5:
+        case EM2884_BOARD_CINERGY_HTC_STICK:
                 terratec_h5_init(dev);
 
-                dvb->dont_attach_fe1 = 1;
-
-                dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk, &dev->i2c_adap, &dvb->fe[1]);
+                dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk, &dev->i2c_adap);
                 if (!dvb->fe[0]) {
                         result = -EINVAL;
                         goto out_free;
                 }
-
                 /* FIXME: do we need a pll semaphore? */
                 dvb->fe[0]->sec_priv = dvb;
                 sema_init(&dvb->pll_mutex, 1);
                 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
                 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
-                dvb->fe[1]->id = 1;
 
                 /* Attach tda18271 to DVB-C frontend */
                 if (dvb->fe[0]->ops.i2c_gate_ctrl)
@@ -816,12 +928,6 @@ static int em28xx_dvb_init(struct em28xx *dev)
                 if (dvb->fe[0]->ops.i2c_gate_ctrl)
                         dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
 
-                /* Hack - needed by drxk/tda18271c2dd */
-                dvb->fe[1]->tuner_priv = dvb->fe[0]->tuner_priv;
-                memcpy(&dvb->fe[1]->ops.tuner_ops,
-                       &dvb->fe[0]->ops.tuner_ops,
-                       sizeof(dvb->fe[0]->ops.tuner_ops));
-
                 break;
         case EM28174_BOARD_PCTV_460E:
                 /* attach demod */
@@ -845,6 +951,8 @@ static int em28xx_dvb_init(struct em28xx *dev)
         }
         /* define general-purpose callback pointer */
         dvb->fe[0]->callback = em28xx_tuner_callback;
+        if (dvb->fe[1])
+                dvb->fe[1]->callback = em28xx_tuner_callback;
 
         /* register everything */
         result = em28xx_register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
diff --git a/drivers/media/video/em28xx/em28xx-input.c b/drivers/media/video/em28xx/em28xx-input.c
index 679da4804281..2630b265b0e8 100644
--- a/drivers/media/video/em28xx/em28xx-input.c
+++ b/drivers/media/video/em28xx/em28xx-input.c
@@ -306,7 +306,8 @@ static void em28xx_ir_handle_key(struct em28xx_IR *ir)
                                    poll_result.rc_data[0],
                                    poll_result.toggle_bit);
 
-                if (ir->dev->chip_id == CHIP_ID_EM2874)
+                if (ir->dev->chip_id == CHIP_ID_EM2874 ||
+                    ir->dev->chip_id == CHIP_ID_EM2884)
                         /* The em2874 clears the readcount field every time the
                            register is read.  The em2860/2880 datasheet says that it
                            is supposed to clear the readcount, but it doesn't.  So with
@@ -371,13 +372,15 @@ int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 rc_type)
         case CHIP_ID_EM2883:
                 ir->get_key = default_polling_getkey;
                 break;
+        case CHIP_ID_EM2884:
         case CHIP_ID_EM2874:
         case CHIP_ID_EM28174:
                 ir->get_key = em2874_polling_getkey;
                 em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1);
                 break;
         default:
-                printk("Unrecognized em28xx chip id: IR not supported\n");
+                printk("Unrecognized em28xx chip id 0x%02x: IR not supported\n",
+                        dev->chip_id);
                 rc = -EINVAL;
         }
 
diff --git a/drivers/media/video/em28xx/em28xx-reg.h b/drivers/media/video/em28xx/em28xx-reg.h
index 66f792361b97..2f6268505726 100644
--- a/drivers/media/video/em28xx/em28xx-reg.h
+++ b/drivers/media/video/em28xx/em28xx-reg.h
@@ -12,6 +12,11 @@
 #define EM_GPO_2   (1 << 2)
 #define EM_GPO_3   (1 << 3)
 
+/* em28xx endpoints */
+#define EM28XX_EP_ANALOG        0x82
+#define EM28XX_EP_AUDIO         0x83
+#define EM28XX_EP_DIGITAL       0x84
+
 /* em2800 registers */
 #define EM2800_R08_AUDIOSRC 0x08
 
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index 9b4557a2f6d0..613300b51a9e 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -1070,6 +1070,10 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                 /* the em2800 can only scale down to 50% */
                 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
                 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
+                /* MaxPacketSize for em2800 is too small to capture at full resolution
+                 * use half of maxw as the scaler can only scale to 50% */
+                if (width == maxw && height == maxh)
+                        width /= 2;
         } else {
                 /* width must even because of the YUYV format
                    height must be even because of interlacing */
@@ -2503,6 +2507,7 @@ int em28xx_register_analog_devices(struct em28xx *dev)
 {
       u8 val;
         int ret;
+        unsigned int maxw;
 
         printk(KERN_INFO "%s: v4l2 driver version %s\n",
                 dev->name, EM28XX_VERSION);
@@ -2515,8 +2520,15 @@ int em28xx_register_analog_devices(struct em28xx *dev)
 
         /* Analog specific initialization */
         dev->format = &format[0];
+
+        maxw = norm_maxw(dev);
+        /* MaxPacketSize for em2800 is too small to capture at full resolution
+         * use half of maxw as the scaler can only scale to 50% */
+        if (dev->board.is_em2800)
+            maxw /= 2;
+
         em28xx_set_video_format(dev, format[0].fourcc,
-                                norm_maxw(dev), norm_maxh(dev));
+                                maxw, norm_maxh(dev));
 
         video_mux(dev, dev->ctl_input);
 
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
index 2a2cb7ed0014..22e252bcc41e 100644
--- a/drivers/media/video/em28xx/em28xx.h
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -38,6 +38,7 @@
 #include <media/videobuf-dvb.h>
 #endif
 #include "tuner-xc2028.h"
+#include "xc5000.h"
 #include "em28xx-reg.h"
 
 /* Boards supported by driver */
@@ -121,6 +122,9 @@
 #define EM28174_BOARD_PCTV_290E                   78
 #define EM2884_BOARD_TERRATEC_H5                  79
 #define EM28174_BOARD_PCTV_460E                   80
+#define EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C     81
+#define EM2884_BOARD_CINERGY_HTC_STICK            82
+#define EM2860_BOARD_HT_VIDBOX_NW03               83
 
 /* Limits minimum and default number of buffers */
 #define EM28XX_MIN_BUF 4
@@ -594,6 +598,8 @@ struct em28xx {
         int max_pkt_size;       /* max packet size of isoc transaction */
         int num_alt;            /* Number of alternative settings */
         unsigned int *alt_max_pkt_size; /* array of wMaxPacketSize */
+        int dvb_alt;                            /* alternate for DVB */
+        unsigned int dvb_max_pkt_size;          /* wMaxPacketSize for DVB */
         struct urb *urb[EM28XX_NUM_BUFS];       /* urb for isoc transfers */
         char *transfer_buffer[EM28XX_NUM_BUFS]; /* transfer buffers for isoc
                                                    transfer */
@@ -825,7 +831,7 @@ static inline unsigned int norm_maxw(struct em28xx *dev)
         if (dev->board.is_webcam)
                 return dev->sensor_xres;
 
-        if (dev->board.max_range_640_480 || dev->board.is_em2800)
+        if (dev->board.max_range_640_480)
                 return 640;
 
         return 720;
diff --git a/drivers/media/video/fsl-viu.c b/drivers/media/video/fsl-viu.c
index 27cb197d0bd6..27e3e0c0b219 100644
--- a/drivers/media/video/fsl-viu.c
+++ b/drivers/media/video/fsl-viu.c
@@ -1661,18 +1661,7 @@ static struct platform_driver viu_of_platform_driver = {
         },
 };
 
-static int __init viu_init(void)
-{
-        return platform_driver_register(&viu_of_platform_driver);
-}
-
-static void __exit viu_exit(void)
-{
-        platform_driver_unregister(&viu_of_platform_driver);
-}
-
-module_init(viu_init);
-module_exit(viu_exit);
+module_platform_driver(viu_of_platform_driver);
 
 MODULE_DESCRIPTION("Freescale Video-In(VIU)");
 MODULE_AUTHOR("Hongjun Chen");
diff --git a/drivers/media/video/gspca/Kconfig b/drivers/media/video/gspca/Kconfig
index 103af3fe5aa0..dfe268bfa4f8 100644
--- a/drivers/media/video/gspca/Kconfig
+++ b/drivers/media/video/gspca/Kconfig
@@ -77,6 +77,16 @@ config USB_GSPCA_JEILINJ
           To compile this driver as a module, choose M here: the
           module will be called gspca_jeilinj.
 
+config USB_GSPCA_JL2005BCD
+        tristate "JL2005B/C/D USB V4L2 driver"
+        depends on VIDEO_V4L2 && USB_GSPCA
+        help
+          Say Y here if you want support for cameras based the
+          JL2005B, JL2005C, or JL2005D chip.
+
+          To compile this driver as a module, choose M here: the
+          module will be called gspca_jl2005bcd.
+
 config USB_GSPCA_KINECT
         tristate "Kinect sensor device USB Camera Driver"
         depends on VIDEO_V4L2 && USB_GSPCA
diff --git a/drivers/media/video/gspca/Makefile b/drivers/media/video/gspca/Makefile
index f345f494d0f3..79ebe46e1ad7 100644
--- a/drivers/media/video/gspca/Makefile
+++ b/drivers/media/video/gspca/Makefile
@@ -5,6 +5,7 @@ obj-$(CONFIG_USB_GSPCA_CPIA1)    += gspca_cpia1.o
 obj-$(CONFIG_USB_GSPCA_ETOMS)    += gspca_etoms.o
 obj-$(CONFIG_USB_GSPCA_FINEPIX)  += gspca_finepix.o
 obj-$(CONFIG_USB_GSPCA_JEILINJ)  += gspca_jeilinj.o
+obj-$(CONFIG_USB_GSPCA_JL2005BCD) += gspca_jl2005bcd.o
 obj-$(CONFIG_USB_GSPCA_KINECT)   += gspca_kinect.o
 obj-$(CONFIG_USB_GSPCA_KONICA)   += gspca_konica.o
 obj-$(CONFIG_USB_GSPCA_MARS)     += gspca_mars.o
@@ -49,6 +50,7 @@ gspca_cpia1-objs    := cpia1.o
 gspca_etoms-objs    := etoms.o
 gspca_finepix-objs  := finepix.o
 gspca_jeilinj-objs  := jeilinj.o
+gspca_jl2005bcd-objs  := jl2005bcd.o
 gspca_kinect-objs   := kinect.o
 gspca_konica-objs   := konica.o
 gspca_mars-objs     := mars.o
diff --git a/drivers/media/video/gspca/benq.c b/drivers/media/video/gspca/benq.c
index 636627b57dc9..9769f17915c0 100644
--- a/drivers/media/video/gspca/benq.c
+++ b/drivers/media/video/gspca/benq.c
@@ -76,7 +76,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
         gspca_dev->cam.cam_mode = vga_mode;
         gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
         gspca_dev->cam.no_urb_create = 1;
-        gspca_dev->cam.reverse_alts = 1;
         return 0;
 }
 
@@ -135,13 +134,17 @@ static int sd_start(struct gspca_dev *gspca_dev)
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
+        struct usb_interface *intf;
+
         reg_w(gspca_dev, 0x003c, 0x0003);
         reg_w(gspca_dev, 0x003c, 0x0004);
         reg_w(gspca_dev, 0x003c, 0x0005);
         reg_w(gspca_dev, 0x003c, 0x0006);
         reg_w(gspca_dev, 0x003c, 0x0007);
+
+        intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
         usb_set_interface(gspca_dev->dev, gspca_dev->iface,
-                                        gspca_dev->nbalt - 1);
+                                        intf->num_altsetting - 1);
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
diff --git a/drivers/media/video/gspca/gl860/gl860.c b/drivers/media/video/gspca/gl860/gl860.c
index a8f54c20e585..c84e26006fc3 100644
--- a/drivers/media/video/gspca/gl860/gl860.c
+++ b/drivers/media/video/gspca/gl860/gl860.c
@@ -337,7 +337,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 return -1;
 
         cam = &gspca_dev->cam;
-        gspca_dev->nbalt = 4;
 
         switch (sd->sensor) {
         case ID_MI1320:
diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c
index 2ca10dfec91f..ca5a2b139d0b 100644
--- a/drivers/media/video/gspca/gspca.c
+++ b/drivers/media/video/gspca/gspca.c
@@ -633,23 +633,32 @@ static u32 which_bandwidth(struct gspca_dev *gspca_dev)
         u32 bandwidth;
         int i;
 
+        /* get the (max) image size */
         i = gspca_dev->curr_mode;
         bandwidth = gspca_dev->cam.cam_mode[i].sizeimage;
 
-        /* if the image is compressed, estimate the mean image size */
-        if (bandwidth < gspca_dev->cam.cam_mode[i].width *
+        /* if the image is compressed, estimate its mean size */
+        if (!gspca_dev->cam.needs_full_bandwidth &&
+            bandwidth < gspca_dev->cam.cam_mode[i].width *
                                 gspca_dev->cam.cam_mode[i].height)
-                bandwidth /= 3;
+                bandwidth = bandwidth * 3 / 8;  /* 0.375 */
 
         /* estimate the frame rate */
         if (gspca_dev->sd_desc->get_streamparm) {
                 struct v4l2_streamparm parm;
 
-                parm.parm.capture.timeperframe.denominator = 15;
                 gspca_dev->sd_desc->get_streamparm(gspca_dev, &parm);
                 bandwidth *= parm.parm.capture.timeperframe.denominator;
+                bandwidth /= parm.parm.capture.timeperframe.numerator;
         } else {
-                bandwidth *= 15;                /* 15 fps */
+
+                /* don't hope more than 15 fps with USB 1.1 and
+                 * image resolution >= 640x480 */
+                if (gspca_dev->width >= 640
+                 && gspca_dev->dev->speed == USB_SPEED_FULL)
+                        bandwidth *= 15;                /* 15 fps */
+                else
+                        bandwidth *= 30;                /* 30 fps */
         }
 
         PDEBUG(D_STREAM, "min bandwidth: %d", bandwidth);
@@ -667,9 +676,8 @@ struct ep_tb_s {
  * build the table of the endpoints
  * and compute the minimum bandwidth for the image transfer
  */
-static int build_ep_tb(struct gspca_dev *gspca_dev,
+static int build_isoc_ep_tb(struct gspca_dev *gspca_dev,
                         struct usb_interface *intf,
-                        int xfer,
                         struct ep_tb_s *ep_tb)
 {
         struct usb_host_endpoint *ep;
@@ -687,17 +695,21 @@ static int build_ep_tb(struct gspca_dev *gspca_dev,
                 ep_tb->bandwidth = 2000 * 2000 * 120;
                 found = 0;
                 for (j = 0; j < nbalt; j++) {
-                        ep = alt_xfer(&intf->altsetting[j], xfer);
+                        ep = alt_xfer(&intf->altsetting[j],
+                                      USB_ENDPOINT_XFER_ISOC);
                         if (ep == NULL)
                                 continue;
+                        if (ep->desc.bInterval == 0) {
+                                pr_err("alt %d iso endp with 0 interval\n", j);
+                                continue;
+                        }
                         psize = le16_to_cpu(ep->desc.wMaxPacketSize);
-                        if (!gspca_dev->cam.bulk)               /* isoc */
-                                psize = (psize & 0x07ff) *
-                                                (1 + ((psize >> 11) & 3));
-                        bandwidth = psize * ep->desc.bInterval * 1000;
+                        psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
+                        bandwidth = psize * 1000;
                         if (gspca_dev->dev->speed == USB_SPEED_HIGH
                          || gspca_dev->dev->speed == USB_SPEED_SUPER)
                                 bandwidth *= 8;
+                        bandwidth /= 1 << (ep->desc.bInterval - 1);
                         if (bandwidth <= last_bw)
                                 continue;
                         if (bandwidth < ep_tb->bandwidth) {
@@ -715,6 +727,23 @@ static int build_ep_tb(struct gspca_dev *gspca_dev,
                 ep_tb++;
         }
 
+        /*
+         * If the camera:
+         * has a usb audio class interface (a built in usb mic); and
+         * is a usb 1 full speed device; and
+         * uses the max full speed iso bandwidth; and
+         * and has more than 1 alt setting
+         * then skip the highest alt setting to spare bandwidth for the mic
+         */
+        if (gspca_dev->audio &&
+                        gspca_dev->dev->speed == USB_SPEED_FULL &&
+                        last_bw >= 1000000 &&
+                        i > 1) {
+                PDEBUG(D_STREAM, "dev has usb audio, skipping highest alt");
+                i--;
+                ep_tb--;
+        }
+
         /* get the requested bandwidth and start at the highest atlsetting */
         bandwidth = which_bandwidth(gspca_dev);
         ep_tb--;
@@ -790,10 +819,7 @@ static int create_urbs(struct gspca_dev *gspca_dev,
                                                     ep->desc.bEndpointAddress);
                         urb->transfer_flags = URB_ISO_ASAP
                                         | URB_NO_TRANSFER_DMA_MAP;
-                        if (gspca_dev->dev->speed == USB_SPEED_LOW)
-                                urb->interval = ep->desc.bInterval;
-                        else
-                                urb->interval = 1 << (ep->desc.bInterval - 1);
+                        urb->interval = 1 << (ep->desc.bInterval - 1);
                         urb->complete = isoc_irq;
                         urb->number_of_packets = npkt;
                         for (i = 0; i < npkt; i++) {
@@ -848,7 +874,7 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
         xfer = gspca_dev->cam.bulk ? USB_ENDPOINT_XFER_BULK
                                    : USB_ENDPOINT_XFER_ISOC;
 
-        /* if the subdriver forced an altsetting, get the endpoint */
+        /* if bulk or the subdriver forced an altsetting, get the endpoint */
         if (gspca_dev->alt != 0) {
                 gspca_dev->alt--;       /* (previous version compatibility) */
                 ep = alt_xfer(&intf->altsetting[gspca_dev->alt], xfer);
@@ -863,7 +889,7 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
 
         /* else, compute the minimum bandwidth
          * and build the endpoint table */
-                alt_idx = build_ep_tb(gspca_dev, intf, xfer, ep_tb);
+                alt_idx = build_isoc_ep_tb(gspca_dev, intf, ep_tb);
                 if (alt_idx <= 0) {
                         pr_err("no transfer endpoint found\n");
                         ret = -EIO;
@@ -880,7 +906,7 @@ static int gspca_init_transfer(struct gspca_dev *gspca_dev)
         for (;;) {
                 if (alt != gspca_dev->alt) {
                         alt = gspca_dev->alt;
-                        if (gspca_dev->nbalt > 1) {
+                        if (intf->num_altsetting > 1) {
                                 ret = usb_set_interface(gspca_dev->dev,
                                                         gspca_dev->iface,
                                                         alt);
@@ -2300,15 +2326,14 @@ int gspca_dev_probe2(struct usb_interface *intf,
         }
         gspca_dev->dev = dev;
         gspca_dev->iface = intf->cur_altsetting->desc.bInterfaceNumber;
-        gspca_dev->nbalt = intf->num_altsetting;
 
         /* check if any audio device */
-        if (dev->config->desc.bNumInterfaces != 1) {
+        if (dev->actconfig->desc.bNumInterfaces != 1) {
                 int i;
                 struct usb_interface *intf2;
 
-                for (i = 0; i < dev->config->desc.bNumInterfaces; i++) {
-                        intf2 = dev->config->interface[i];
+                for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
+                        intf2 = dev->actconfig->interface[i];
                         if (intf2 != NULL
                          && intf2->altsetting != NULL
                          && intf2->altsetting->desc.bInterfaceClass ==
@@ -2389,7 +2414,7 @@ int gspca_dev_probe(struct usb_interface *intf,
         }
 
         /* the USB video interface must be the first one */
-        if (dev->config->desc.bNumInterfaces != 1
+        if (dev->actconfig->desc.bNumInterfaces != 1
          && intf->cur_altsetting->desc.bInterfaceNumber != 0)
                 return -ENODEV;
 
diff --git a/drivers/media/video/gspca/gspca.h b/drivers/media/video/gspca/gspca.h
index e444f16e1497..589009f4496f 100644
--- a/drivers/media/video/gspca/gspca.h
+++ b/drivers/media/video/gspca/gspca.h
@@ -69,7 +69,9 @@ struct cam {
         u8 bulk;                /* image transfer by 0:isoc / 1:bulk */
         u8 npkt;                /* number of packets in an ISOC message
                                  * 0 is the default value: 32 packets */
-        u8 reverse_alts;        /* Alt settings are in high to low order */
+        u8 needs_full_bandwidth;/* Set this flag to notify the bandwidth calc.
+                                 * code that the cam fills all image buffers to
+                                 * the max, even when using compression. */
 };
 
 struct gspca_dev;
@@ -208,7 +210,6 @@ struct gspca_dev {
         char memory;                    /* memory type (V4L2_MEMORY_xxx) */
         __u8 iface;                     /* USB interface number */
         __u8 alt;                       /* USB alternate setting */
-        __u8 nbalt;                     /* number of USB alternate settings */
         u8 audio;                       /* presence of audio device */
 };
 
diff --git a/drivers/media/video/gspca/jl2005bcd.c b/drivers/media/video/gspca/jl2005bcd.c
new file mode 100644
index 000000000000..53f58ef367cf
--- /dev/null
+++ b/drivers/media/video/gspca/jl2005bcd.c
@@ -0,0 +1,554 @@
+/*
+ * Jeilin JL2005B/C/D library
+ *
+ * Copyright (C) 2011 Theodore Kilgore <kilgota@auburn.edu>
+ *
+ * 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
+ * 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
+ */
+
+#define MODULE_NAME "jl2005bcd"
+
+#include <linux/workqueue.h>
+#include <linux/slab.h>
+#include "gspca.h"
+
+
+MODULE_AUTHOR("Theodore Kilgore <kilgota@auburn.edu>");
+MODULE_DESCRIPTION("JL2005B/C/D USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+/* Default timeouts, in ms */
+#define JL2005C_CMD_TIMEOUT 500
+#define JL2005C_DATA_TIMEOUT 1000
+
+/* Maximum transfer size to use. */
+#define JL2005C_MAX_TRANSFER 0x200
+#define FRAME_HEADER_LEN 16
+
+
+/* specific webcam descriptor */
+struct sd {
+        struct gspca_dev gspca_dev;  /* !! must be the first item */
+        unsigned char firmware_id[6];
+        const struct v4l2_pix_format *cap_mode;
+        /* Driver stuff */
+        struct work_struct work_struct;
+        struct workqueue_struct *work_thread;
+        u8 frame_brightness;
+        int block_size; /* block size of camera */
+        int vga;        /* 1 if vga cam, 0 if cif cam */
+};
+
+
+/* Camera has two resolution settings. What they are depends on model. */
+static const struct v4l2_pix_format cif_mode[] = {
+        {176, 144, V4L2_PIX_FMT_JL2005BCD, V4L2_FIELD_NONE,
+                .bytesperline = 176,
+                .sizeimage = 176 * 144,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0},
+        {352, 288, V4L2_PIX_FMT_JL2005BCD, V4L2_FIELD_NONE,
+                .bytesperline = 352,
+                .sizeimage = 352 * 288,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0},
+};
+
+static const struct v4l2_pix_format vga_mode[] = {
+        {320, 240, V4L2_PIX_FMT_JL2005BCD, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0},
+        {640, 480, V4L2_PIX_FMT_JL2005BCD, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0},
+};
+
+/*
+ * cam uses endpoint 0x03 to send commands, 0x84 for read commands,
+ * and 0x82 for bulk data transfer.
+ */
+
+/* All commands are two bytes only */
+static int jl2005c_write2(struct gspca_dev *gspca_dev, unsigned char *command)
+{
+        int retval;
+
+        memcpy(gspca_dev->usb_buf, command, 2);
+        retval = usb_bulk_msg(gspca_dev->dev,
+                        usb_sndbulkpipe(gspca_dev->dev, 3),
+                        gspca_dev->usb_buf, 2, NULL, 500);
+        if (retval < 0)
+                pr_err("command write [%02x] error %d\n",
+                       gspca_dev->usb_buf[0], retval);
+        return retval;
+}
+
+/* Response to a command is one byte in usb_buf[0], only if requested. */
+static int jl2005c_read1(struct gspca_dev *gspca_dev)
+{
+        int retval;
+
+        retval = usb_bulk_msg(gspca_dev->dev,
+                                usb_rcvbulkpipe(gspca_dev->dev, 0x84),
+                                gspca_dev->usb_buf, 1, NULL, 500);
+        if (retval < 0)
+                pr_err("read command [0x%02x] error %d\n",
+                       gspca_dev->usb_buf[0], retval);
+        return retval;
+}
+
+/* Response appears in gspca_dev->usb_buf[0] */
+static int jl2005c_read_reg(struct gspca_dev *gspca_dev, unsigned char reg)
+{
+        int retval;
+
+        static u8 instruction[2] = {0x95, 0x00};
+        /* put register to read in byte 1 */
+        instruction[1] = reg;
+        /* Send the read request */
+        retval = jl2005c_write2(gspca_dev, instruction);
+        if (retval < 0)
+                return retval;
+        retval = jl2005c_read1(gspca_dev);
+
+        return retval;
+}
+
+static int jl2005c_start_new_frame(struct gspca_dev *gspca_dev)
+{
+        int i;
+        int retval;
+        int frame_brightness = 0;
+
+        static u8 instruction[2] = {0x7f, 0x01};
+
+        retval = jl2005c_write2(gspca_dev, instruction);
+        if (retval < 0)
+                return retval;
+
+        i = 0;
+        while (i < 20 && !frame_brightness) {
+                /* If we tried 20 times, give up. */
+                retval = jl2005c_read_reg(gspca_dev, 0x7e);
+                if (retval < 0)
+                        return retval;
+                frame_brightness = gspca_dev->usb_buf[0];
+                retval = jl2005c_read_reg(gspca_dev, 0x7d);
+                if (retval < 0)
+                        return retval;
+                i++;
+        }
+        PDEBUG(D_FRAM, "frame_brightness is 0x%02x", gspca_dev->usb_buf[0]);
+        return retval;
+}
+
+static int jl2005c_write_reg(struct gspca_dev *gspca_dev, unsigned char reg,
+                                                    unsigned char value)
+{
+        int retval;
+        u8 instruction[2];
+
+        instruction[0] = reg;
+        instruction[1] = value;
+
+        retval = jl2005c_write2(gspca_dev, instruction);
+        if (retval < 0)
+                        return retval;
+
+        return retval;
+}
+
+static int jl2005c_get_firmware_id(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *)gspca_dev;
+        int i = 0;
+        int retval = -1;
+        unsigned char regs_to_read[] = {0x57, 0x02, 0x03, 0x5d, 0x5e, 0x5f};
+
+        PDEBUG(D_PROBE, "Running jl2005c_get_firmware_id");
+        /* Read the first ID byte once for warmup */
+        retval = jl2005c_read_reg(gspca_dev, regs_to_read[0]);
+        PDEBUG(D_PROBE, "response is %02x", gspca_dev->usb_buf[0]);
+        if (retval < 0)
+                return retval;
+        /* Now actually get the ID string */
+        for (i = 0; i < 6; i++) {
+                retval = jl2005c_read_reg(gspca_dev, regs_to_read[i]);
+                if (retval < 0)
+                        return retval;
+                sd->firmware_id[i] = gspca_dev->usb_buf[0];
+        }
+        PDEBUG(D_PROBE, "firmware ID is %02x%02x%02x%02x%02x%02x",
+                                                sd->firmware_id[0],
+                                                sd->firmware_id[1],
+                                                sd->firmware_id[2],
+                                                sd->firmware_id[3],
+                                                sd->firmware_id[4],
+                                                sd->firmware_id[5]);
+        return 0;
+}
+
+static int jl2005c_stream_start_vga_lg
+                    (struct gspca_dev *gspca_dev)
+{
+        int i;
+        int retval = -1;
+        static u8 instruction[][2] = {
+                {0x05, 0x00},
+                {0x7c, 0x00},
+                {0x7d, 0x18},
+                {0x02, 0x00},
+                {0x01, 0x00},
+                {0x04, 0x52},
+        };
+
+        for (i = 0; i < ARRAY_SIZE(instruction); i++) {
+                msleep(60);
+                retval = jl2005c_write2(gspca_dev, instruction[i]);
+                if (retval < 0)
+                        return retval;
+        }
+        msleep(60);
+        return retval;
+}
+
+static int jl2005c_stream_start_vga_small(struct gspca_dev *gspca_dev)
+{
+        int i;
+        int retval = -1;
+        static u8 instruction[][2] = {
+                {0x06, 0x00},
+                {0x7c, 0x00},
+                {0x7d, 0x1a},
+                {0x02, 0x00},
+                {0x01, 0x00},
+                {0x04, 0x52},
+        };
+
+        for (i = 0; i < ARRAY_SIZE(instruction); i++) {
+                msleep(60);
+                retval = jl2005c_write2(gspca_dev, instruction[i]);
+                if (retval < 0)
+                        return retval;
+        }
+        msleep(60);
+        return retval;
+}
+
+static int jl2005c_stream_start_cif_lg(struct gspca_dev *gspca_dev)
+{
+        int i;
+        int retval = -1;
+        static u8 instruction[][2] = {
+                {0x05, 0x00},
+                {0x7c, 0x00},
+                {0x7d, 0x30},
+                {0x02, 0x00},
+                {0x01, 0x00},
+                {0x04, 0x42},
+        };
+
+        for (i = 0; i < ARRAY_SIZE(instruction); i++) {
+                msleep(60);
+                retval = jl2005c_write2(gspca_dev, instruction[i]);
+                if (retval < 0)
+                        return retval;
+        }
+        msleep(60);
+        return retval;
+}
+
+static int jl2005c_stream_start_cif_small(struct gspca_dev *gspca_dev)
+{
+        int i;
+        int retval = -1;
+        static u8 instruction[][2] = {
+                {0x06, 0x00},
+                {0x7c, 0x00},
+                {0x7d, 0x32},
+                {0x02, 0x00},
+                {0x01, 0x00},
+                {0x04, 0x42},
+        };
+
+        for (i = 0; i < ARRAY_SIZE(instruction); i++) {
+                msleep(60);
+                retval = jl2005c_write2(gspca_dev, instruction[i]);
+                if (retval < 0)
+                        return retval;
+        }
+        msleep(60);
+        return retval;
+}
+
+
+static int jl2005c_stop(struct gspca_dev *gspca_dev)
+{
+        int retval;
+
+        retval = jl2005c_write_reg(gspca_dev, 0x07, 0x00);
+        return retval;
+}
+
+/* This function is called as a workqueue function and runs whenever the camera
+ * is streaming data. Because it is a workqueue function it is allowed to sleep
+ * so we can use synchronous USB calls. To avoid possible collisions with other
+ * threads attempting to use the camera's USB interface the gspca usb_lock is
+ * used when performing the one USB control operation inside the workqueue,
+ * which tells the camera to close the stream. In practice the only thing
+ * which needs to be protected against is the usb_set_interface call that
+ * gspca makes during stream_off. Otherwise the camera doesn't provide any
+ * controls that the user could try to change.
+ */
+static void jl2005c_dostream(struct work_struct *work)
+{
+        struct sd *dev = container_of(work, struct sd, work_struct);
+        struct gspca_dev *gspca_dev = &dev->gspca_dev;
+        int bytes_left = 0; /* bytes remaining in current frame. */
+        int data_len;   /* size to use for the next read. */
+        int header_read = 0;
+        unsigned char header_sig[2] = {0x4a, 0x4c};
+        int act_len;
+        int packet_type;
+        int ret;
+        u8 *buffer;
+
+        buffer = kmalloc(JL2005C_MAX_TRANSFER, GFP_KERNEL | GFP_DMA);
+        if (!buffer) {
+                pr_err("Couldn't allocate USB buffer\n");
+                goto quit_stream;
+        }
+
+        while (gspca_dev->present && gspca_dev->streaming) {
+                /* Check if this is a new frame. If so, start the frame first */
+                if (!header_read) {
+                        mutex_lock(&gspca_dev->usb_lock);
+                        ret = jl2005c_start_new_frame(gspca_dev);
+                        mutex_unlock(&gspca_dev->usb_lock);
+                        if (ret < 0)
+                                goto quit_stream;
+                        ret = usb_bulk_msg(gspca_dev->dev,
+                                usb_rcvbulkpipe(gspca_dev->dev, 0x82),
+                                buffer, JL2005C_MAX_TRANSFER, &act_len,
+                                JL2005C_DATA_TIMEOUT);
+                        PDEBUG(D_PACK,
+                                "Got %d bytes out of %d for header",
+                                        act_len, JL2005C_MAX_TRANSFER);
+                        if (ret < 0 || act_len < JL2005C_MAX_TRANSFER)
+                                goto quit_stream;
+                        /* Check whether we actually got the first blodk */
+                        if (memcmp(header_sig, buffer, 2) != 0) {
+                                pr_err("First block is not the first block\n");
+                                goto quit_stream;
+                        }
+                        /* total size to fetch is byte 7, times blocksize
+                         * of which we already got act_len */
+                        bytes_left = buffer[0x07] * dev->block_size - act_len;
+                        PDEBUG(D_PACK, "bytes_left = 0x%x", bytes_left);
+                        /* We keep the header. It has other information, too.*/
+                        packet_type = FIRST_PACKET;
+                        gspca_frame_add(gspca_dev, packet_type,
+                                        buffer, act_len);
+                        header_read = 1;
+                }
+                while (bytes_left > 0 && gspca_dev->present) {
+                        data_len = bytes_left > JL2005C_MAX_TRANSFER ?
+                                JL2005C_MAX_TRANSFER : bytes_left;
+                        ret = usb_bulk_msg(gspca_dev->dev,
+                                usb_rcvbulkpipe(gspca_dev->dev, 0x82),
+                                buffer, data_len, &act_len,
+                                JL2005C_DATA_TIMEOUT);
+                        if (ret < 0 || act_len < data_len)
+                                goto quit_stream;
+                        PDEBUG(D_PACK,
+                                "Got %d bytes out of %d for frame",
+                                                data_len, bytes_left);
+                        bytes_left -= data_len;
+                        if (bytes_left == 0) {
+                                packet_type = LAST_PACKET;
+                                header_read = 0;
+                        } else
+                                packet_type = INTER_PACKET;
+                        gspca_frame_add(gspca_dev, packet_type,
+                                        buffer, data_len);
+                }
+        }
+quit_stream:
+        if (gspca_dev->present) {
+                mutex_lock(&gspca_dev->usb_lock);
+                jl2005c_stop(gspca_dev);
+                mutex_unlock(&gspca_dev->usb_lock);
+        }
+        kfree(buffer);
+}
+
+
+
+
+/* This function is called at probe time */
+static int sd_config(struct gspca_dev *gspca_dev,
+                        const struct usb_device_id *id)
+{
+        struct cam *cam;
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        cam = &gspca_dev->cam;
+        /* We don't use the buffer gspca allocates so make it small. */
+        cam->bulk_size = 64;
+        cam->bulk = 1;
+        /* For the rest, the camera needs to be detected */
+        jl2005c_get_firmware_id(gspca_dev);
+        /* Here are some known firmware IDs
+         * First some JL2005B cameras
+         * {0x41, 0x07, 0x04, 0x2c, 0xe8, 0xf2} Sakar KidzCam
+         * {0x45, 0x02, 0x08, 0xb9, 0x00, 0xd2} No-name JL2005B
+         * JL2005C cameras
+         * {0x01, 0x0c, 0x16, 0x10, 0xf8, 0xc8} Argus DC-1512
+         * {0x12, 0x04, 0x03, 0xc0, 0x00, 0xd8} ICarly
+         * {0x86, 0x08, 0x05, 0x02, 0x00, 0xd4} Jazz
+         *
+         * Based upon this scanty evidence, we can detect a CIF camera by
+         * testing byte 0 for 0x4x.
+         */
+        if ((sd->firmware_id[0] & 0xf0) == 0x40) {
+                cam->cam_mode   = cif_mode;
+                cam->nmodes     = ARRAY_SIZE(cif_mode);
+                sd->block_size  = 0x80;
+        } else {
+                cam->cam_mode   = vga_mode;
+                cam->nmodes     = ARRAY_SIZE(vga_mode);
+                sd->block_size  = 0x200;
+        }
+
+        INIT_WORK(&sd->work_struct, jl2005c_dostream);
+
+        return 0;
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+        return 0;
+}
+
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+
+        struct sd *sd = (struct sd *) gspca_dev;
+        sd->cap_mode = gspca_dev->cam.cam_mode;
+
+        switch (gspca_dev->width) {
+        case 640:
+                PDEBUG(D_STREAM, "Start streaming at vga resolution");
+                jl2005c_stream_start_vga_lg(gspca_dev);
+                break;
+        case 320:
+                PDEBUG(D_STREAM, "Start streaming at qvga resolution");
+                jl2005c_stream_start_vga_small(gspca_dev);
+                break;
+        case 352:
+                PDEBUG(D_STREAM, "Start streaming at cif resolution");
+                jl2005c_stream_start_cif_lg(gspca_dev);
+                break;
+        case 176:
+                PDEBUG(D_STREAM, "Start streaming at qcif resolution");
+                jl2005c_stream_start_cif_small(gspca_dev);
+                break;
+        default:
+                pr_err("Unknown resolution specified\n");
+                return -1;
+        }
+
+        /* Start the workqueue function to do the streaming */
+        sd->work_thread = create_singlethread_workqueue(MODULE_NAME);
+        queue_work(sd->work_thread, &sd->work_struct);
+
+        return 0;
+}
+
+/* called on streamoff with alt==0 and on disconnect */
+/* the usb_lock is held at entry - restore on exit */
+static void sd_stop0(struct gspca_dev *gspca_dev)
+{
+        struct sd *dev = (struct sd *) gspca_dev;
+
+        /* wait for the work queue to terminate */
+        mutex_unlock(&gspca_dev->usb_lock);
+        /* This waits for sq905c_dostream to finish */
+        destroy_workqueue(dev->work_thread);
+        dev->work_thread = NULL;
+        mutex_lock(&gspca_dev->usb_lock);
+}
+
+
+
+/* sub-driver description */
+static const struct sd_desc sd_desc = {
+        .name = MODULE_NAME,
+        /* .ctrls = none have been detected */
+        /* .nctrls = ARRAY_SIZE(sd_ctrls),  */
+        .config = sd_config,
+        .init = sd_init,
+        .start = sd_start,
+        .stop0 = sd_stop0,
+};
+
+/* -- module initialisation -- */
+static const __devinitdata struct usb_device_id device_table[] = {
+        {USB_DEVICE(0x0979, 0x0227)},
+        {}
+};
+MODULE_DEVICE_TABLE(usb, device_table);
+
+/* -- device connect -- */
+static int sd_probe(struct usb_interface *intf,
+                                const struct usb_device_id *id)
+{
+        return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
+                                THIS_MODULE);
+}
+
+static struct usb_driver sd_driver = {
+        .name = MODULE_NAME,
+        .id_table = device_table,
+        .probe = sd_probe,
+        .disconnect = gspca_disconnect,
+#ifdef CONFIG_PM
+        .suspend = gspca_suspend,
+        .resume = gspca_resume,
+#endif
+};
+
+/* -- module insert / remove -- */
+static int __init sd_mod_init(void)
+{
+        int ret;
+
+        ret = usb_register(&sd_driver);
+        if (ret < 0)
+                return ret;
+        return 0;
+}
+static void __exit sd_mod_exit(void)
+{
+        usb_deregister(&sd_driver);
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);
diff --git a/drivers/media/video/gspca/konica.c b/drivers/media/video/gspca/konica.c
index b1da7f4096c8..f0c0d74dfe92 100644
--- a/drivers/media/video/gspca/konica.c
+++ b/drivers/media/video/gspca/konica.c
@@ -247,9 +247,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
         gspca_dev->cam.cam_mode = vga_mode;
         gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
         gspca_dev->cam.no_urb_create = 1;
-        /* The highest alt setting has an isoc packetsize of 0, so we
-           don't want to use it */
-        gspca_dev->nbalt--;
 
         sd->brightness  = BRIGHTNESS_DEFAULT;
         sd->contrast    = CONTRAST_DEFAULT;
diff --git a/drivers/media/video/gspca/mars.c b/drivers/media/video/gspca/mars.c
index 5c2ea05c46b4..b0231465afae 100644
--- a/drivers/media/video/gspca/mars.c
+++ b/drivers/media/video/gspca/mars.c
@@ -263,7 +263,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
         cam->nmodes = ARRAY_SIZE(vga_mode);
         cam->ctrls = sd->ctrls;
         sd->quality = QUALITY_DEF;
-        gspca_dev->nbalt = 9;           /* use the altsetting 08 */
         return 0;
 }
 
diff --git a/drivers/media/video/gspca/nw80x.c b/drivers/media/video/gspca/nw80x.c
index d4bec9321771..7167cac7359c 100644
--- a/drivers/media/video/gspca/nw80x.c
+++ b/drivers/media/video/gspca/nw80x.c
@@ -1763,8 +1763,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
         if ((unsigned) webcam >= NWEBCAMS)
                 webcam = 0;
         sd->webcam = webcam;
-        gspca_dev->cam.reverse_alts = 1;
         gspca_dev->cam.ctrls = sd->ctrls;
+        gspca_dev->cam.needs_full_bandwidth = 1;
         sd->ag_cnt = -1;
 
         /*
diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c
index 08b8ce1dee18..739e8a2a2d30 100644
--- a/drivers/media/video/gspca/ov519.c
+++ b/drivers/media/video/gspca/ov519.c
@@ -3348,7 +3348,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
         case BRIDGE_W9968CF:
                 cam->cam_mode = w9968cf_vga_mode;
                 cam->nmodes = ARRAY_SIZE(w9968cf_vga_mode);
-                cam->reverse_alts = 1;
                 break;
         }
 
@@ -3684,8 +3683,8 @@ static void ov511_mode_init_regs(struct sd *sd)
         /* Check if we have enough bandwidth to disable compression */
         fps = (interlaced ? 60 : 30) / (sd->clockdiv + 1) + 1;
         needed = fps * sd->gspca_dev.width * sd->gspca_dev.height * 3 / 2;
-        /* 1400 is a conservative estimate of the max nr of isoc packets/sec */
-        if (needed > 1400 * packet_size) {
+        /* 1000 isoc packets/sec */
+        if (needed > 1000 * packet_size) {
                 /* Enable Y and UV quantization and compression */
                 reg_w(sd, R511_COMP_EN, 0x07);
                 reg_w(sd, R511_COMP_LUT_EN, 0x03);
diff --git a/drivers/media/video/gspca/ov534_9.c b/drivers/media/video/gspca/ov534_9.c
index f30060d50633..fbfa02affa13 100644
--- a/drivers/media/video/gspca/ov534_9.c
+++ b/drivers/media/video/gspca/ov534_9.c
@@ -71,6 +71,7 @@ struct sd {
 enum sensors {
         SENSOR_OV965x,          /* ov9657 */
         SENSOR_OV971x,          /* ov9712 */
+        SENSOR_OV562x,          /* ov5621 */
         NSENSORS
 };
 
@@ -207,6 +208,14 @@ static const struct v4l2_pix_format ov971x_mode[] = {
         }
 };
 
+static const struct v4l2_pix_format ov562x_mode[] = {
+        {2592, 1680, V4L2_PIX_FMT_SBGGR8, V4L2_FIELD_NONE,
+                .bytesperline = 2592,
+                .sizeimage = 2592 * 1680,
+                .colorspace = V4L2_COLORSPACE_SRGB
+        }
+};
+
 static const u8 bridge_init[][2] = {
         {0x88, 0xf8},
         {0x89, 0xff},
@@ -830,6 +839,124 @@ static const u8 ov965x_start_2_sxga[][2] = {
         {0xa3, 0x41},   /* bd60 */
 };
 
+static const u8 ov562x_init[][2] = {
+        {0x88, 0x20},
+        {0x89, 0x0a},
+        {0x8a, 0x90},
+        {0x8b, 0x06},
+        {0x8c, 0x01},
+        {0x8d, 0x10},
+        {0x1c, 0x00},
+        {0x1d, 0x48},
+        {0x1d, 0x00},
+        {0x1d, 0xff},
+        {0x1c, 0x0a},
+        {0x1d, 0x2e},
+        {0x1d, 0x1e},
+};
+
+static const u8 ov562x_init_2[][2] = {
+        {0x12, 0x80},
+        {0x11, 0x41},
+        {0x13, 0x00},
+        {0x10, 0x1e},
+        {0x3b, 0x07},
+        {0x5b, 0x40},
+        {0x39, 0x07},
+        {0x53, 0x02},
+        {0x54, 0x60},
+        {0x04, 0x20},
+        {0x27, 0x04},
+        {0x3d, 0x40},
+        {0x36, 0x00},
+        {0xc5, 0x04},
+        {0x4e, 0x00},
+        {0x4f, 0x93},
+        {0x50, 0x7b},
+        {0xca, 0x0c},
+        {0xcb, 0x0f},
+        {0x39, 0x07},
+        {0x4a, 0x10},
+        {0x3e, 0x0a},
+        {0x3d, 0x00},
+        {0x0c, 0x38},
+        {0x38, 0x90},
+        {0x46, 0x30},
+        {0x4f, 0x93},
+        {0x50, 0x7b},
+        {0xab, 0x00},
+        {0xca, 0x0c},
+        {0xcb, 0x0f},
+        {0x37, 0x02},
+        {0x44, 0x48},
+        {0x8d, 0x44},
+        {0x2a, 0x00},
+        {0x2b, 0x00},
+        {0x32, 0x00},
+        {0x38, 0x90},
+        {0x53, 0x02},
+        {0x54, 0x60},
+        {0x12, 0x00},
+        {0x17, 0x12},
+        {0x18, 0xb4},
+        {0x19, 0x0c},
+        {0x1a, 0xf4},
+        {0x03, 0x4a},
+        {0x89, 0x20},
+        {0x83, 0x80},
+        {0xb7, 0x9d},
+        {0xb6, 0x11},
+        {0xb5, 0x55},
+        {0xb4, 0x00},
+        {0xa9, 0xf0},
+        {0xa8, 0x0a},
+        {0xb8, 0xf0},
+        {0xb9, 0xf0},
+        {0xba, 0xf0},
+        {0x81, 0x07},
+        {0x63, 0x44},
+        {0x13, 0xc7},
+        {0x14, 0x60},
+        {0x33, 0x75},
+        {0x2c, 0x00},
+        {0x09, 0x00},
+        {0x35, 0x30},
+        {0x27, 0x04},
+        {0x3c, 0x07},
+        {0x3a, 0x0a},
+        {0x3b, 0x07},
+        {0x01, 0x40},
+        {0x02, 0x40},
+        {0x16, 0x40},
+        {0x52, 0xb0},
+        {0x51, 0x83},
+        {0x21, 0xbb},
+        {0x22, 0x10},
+        {0x23, 0x03},
+        {0x35, 0x38},
+        {0x20, 0x90},
+        {0x28, 0x30},
+        {0x73, 0xe1},
+        {0x6c, 0x00},
+        {0x6d, 0x80},
+        {0x6e, 0x00},
+        {0x70, 0x04},
+        {0x71, 0x00},
+        {0x8d, 0x04},
+        {0x64, 0x00},
+        {0x65, 0x00},
+        {0x66, 0x00},
+        {0x67, 0x00},
+        {0x68, 0x00},
+        {0x69, 0x00},
+        {0x6a, 0x00},
+        {0x6b, 0x00},
+        {0x71, 0x94},
+        {0x74, 0x20},
+        {0x80, 0x09},
+        {0x85, 0xc0},
+};
+
 static void reg_w_i(struct gspca_dev *gspca_dev, u16 reg, u8 val)
 {
         struct usb_device *udev = gspca_dev->dev;
@@ -1210,6 +1337,17 @@ static int sd_init(struct gspca_dev *gspca_dev)
                         reg_w(gspca_dev, 0x56, 0x1f);
                 else
                         reg_w(gspca_dev, 0x56, 0x17);
+        } else if ((sensor_id & 0xfff0) == 0x5620) {
+                sd->sensor = SENSOR_OV562x;
+
+                gspca_dev->cam.cam_mode = ov562x_mode;
+                gspca_dev->cam.nmodes = ARRAY_SIZE(ov562x_mode);
+
+                reg_w_array(gspca_dev, ov562x_init,
+                                ARRAY_SIZE(ov562x_init));
+                sccb_w_array(gspca_dev, ov562x_init_2,
+                                ARRAY_SIZE(ov562x_init_2));
+                reg_w(gspca_dev, 0xe0, 0x00);
         } else {
                 err("Unknown sensor %04x", sensor_id);
                 return -EINVAL;
@@ -1222,7 +1360,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
-        if (sd->sensor == SENSOR_OV971x)
+        if (sd->sensor == SENSOR_OV971x || sd->sensor == SENSOR_OV562x)
                 return gspca_dev->usb_err;
         switch (gspca_dev->curr_mode) {
         case QVGA_MODE:                 /* 320x240 */
@@ -1409,6 +1547,7 @@ static const struct sd_desc sd_desc = {
 static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x05a9, 0x8065)},
         {USB_DEVICE(0x06f8, 0x3003)},
+        {USB_DEVICE(0x05a9, 0x1550)},
         {}
 };
 
diff --git a/drivers/media/video/gspca/pac207.c b/drivers/media/video/gspca/pac207.c
index ece8b1e82a13..3844c49f269c 100644
--- a/drivers/media/video/gspca/pac207.c
+++ b/drivers/media/video/gspca/pac207.c
@@ -41,14 +41,14 @@ MODULE_LICENSE("GPL");
 #define PAC207_BRIGHTNESS_DEFAULT       46
 
 #define PAC207_EXPOSURE_MIN             3
-#define PAC207_EXPOSURE_MAX             26
+#define PAC207_EXPOSURE_MAX             90 /* 1 sec expo time / 1 fps */
 #define PAC207_EXPOSURE_DEFAULT         5 /* power on default: 3 */
-#define PAC207_EXPOSURE_KNEE            8 /* 4 = 30 fps, 11 = 8, 15 = 6 */
+#define PAC207_EXPOSURE_KNEE            9 /* fps: 90 / exposure -> 9: 10 fps */
 
 #define PAC207_GAIN_MIN                 0
 #define PAC207_GAIN_MAX                 31
-#define PAC207_GAIN_DEFAULT             9 /* power on default: 9 */
-#define PAC207_GAIN_KNEE                31
+#define PAC207_GAIN_DEFAULT             7 /* power on default: 9 */
+#define PAC207_GAIN_KNEE                15
 
 #define PAC207_AUTOGAIN_DEADZONE        30
 
@@ -332,7 +332,7 @@ static void pac207_do_auto_gain(struct gspca_dev *gspca_dev)
         if (sd->autogain_ignore_frames > 0)
                 sd->autogain_ignore_frames--;
         else if (gspca_auto_gain_n_exposure(gspca_dev, avg_lum,
-                        100, PAC207_AUTOGAIN_DEADZONE,
+                        90, PAC207_AUTOGAIN_DEADZONE,
                         PAC207_GAIN_KNEE, PAC207_EXPOSURE_KNEE))
                 sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
 }
diff --git a/drivers/media/video/gspca/pac7302.c b/drivers/media/video/gspca/pac7302.c
index 2811195258c4..9db2b34d172c 100644
--- a/drivers/media/video/gspca/pac7302.c
+++ b/drivers/media/video/gspca/pac7302.c
@@ -1197,6 +1197,7 @@ static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x093a, 0x2629), .driver_info = FL_VFLIP},
         {USB_DEVICE(0x093a, 0x262a)},
         {USB_DEVICE(0x093a, 0x262c)},
+        {USB_DEVICE(0x145f, 0x013c)},
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
diff --git a/drivers/media/video/gspca/se401.c b/drivers/media/video/gspca/se401.c
index 1494e1829d36..bb70092c2229 100644
--- a/drivers/media/video/gspca/se401.c
+++ b/drivers/media/video/gspca/se401.c
@@ -376,7 +376,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
         cam->bulk_size = BULK_SIZE;
         cam->bulk_nurbs = 4;
         cam->ctrls = sd->ctrls;
-        gspca_dev->nbalt = 1;  /* Ignore the bogus isoc alt settings */
         sd->resetlevel = 0x2d; /* Set initial resetlevel */
 
         /* See if the camera supports brightness */
@@ -395,6 +394,14 @@ static int sd_init(struct gspca_dev *gspca_dev)
         return 0;
 }
 
+/* function called at start time before URB creation */
+static int sd_isoc_init(struct gspca_dev *gspca_dev)
+{
+        gspca_dev->alt = 1;     /* Ignore the bogus isoc alt settings */
+
+        return gspca_dev->usb_err;
+}
+
 /* -- start the camera -- */
 static int sd_start(struct gspca_dev *gspca_dev)
 {
@@ -714,6 +721,7 @@ static const struct sd_desc sd_desc = {
         .nctrls = ARRAY_SIZE(sd_ctrls),
         .config = sd_config,
         .init = sd_init,
+        .isoc_init = sd_isoc_init,
         .start = sd_start,
         .stopN = sd_stopN,
         .dq_callback = sd_dq_callback,
diff --git a/drivers/media/video/gspca/sn9c20x.c b/drivers/media/video/gspca/sn9c20x.c
index 33cabc342dcf..9e198b45c3c8 100644
--- a/drivers/media/video/gspca/sn9c20x.c
+++ b/drivers/media/video/gspca/sn9c20x.c
@@ -2048,6 +2048,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct cam *cam;
 
         cam = &gspca_dev->cam;
+        cam->needs_full_bandwidth = 1;
 
         sd->sensor = (id->driver_info >> 8) & 0xff;
         sd->i2c_addr = id->driver_info & 0xff;
@@ -2233,6 +2234,42 @@ static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode)
         }
 }
 
+static int sd_isoc_init(struct gspca_dev *gspca_dev)
+{
+        struct usb_interface *intf;
+        u32 flags = gspca_dev->cam.cam_mode[(int)gspca_dev->curr_mode].priv;
+
+        /*
+         * When using the SN9C20X_I420 fmt the sn9c20x needs more bandwidth
+         * than our regular bandwidth calculations reserve, so we force the
+         * use of a specific altsetting when using the SN9C20X_I420 fmt.
+         */
+        if (!(flags & (MODE_RAW | MODE_JPEG))) {
+                intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
+
+                if (intf->num_altsetting != 9) {
+                        pr_warn("sn9c20x camera with unknown number of alt "
+                                "settings (%d), please report!\n",
+                                intf->num_altsetting);
+                        gspca_dev->alt = intf->num_altsetting;
+                        return 0;
+                }
+
+                switch (gspca_dev->width) {
+                case 160: /* 160x120 */
+                        gspca_dev->alt = 2;
+                        break;
+                case 320: /* 320x240 */
+                        gspca_dev->alt = 6;
+                        break;
+                default:  /* >= 640x480 */
+                        gspca_dev->alt = 9;
+                }
+        }
+
+        return 0;
+}
+
 #define HW_WIN(mode, hstart, vstart) \
 ((const u8 []){hstart, 0, vstart, 0, \
 (mode & MODE_SXGA ? 1280 >> 4 : 640 >> 4), \
@@ -2473,6 +2510,7 @@ static const struct sd_desc sd_desc = {
         .nctrls = ARRAY_SIZE(sd_ctrls),
         .config = sd_config,
         .init = sd_init,
+        .isoc_init = sd_isoc_init,
         .start = sd_start,
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
diff --git a/drivers/media/video/gspca/sonixb.c b/drivers/media/video/gspca/sonixb.c
index ddb392dc4f2d..6a1148d7fe92 100644
--- a/drivers/media/video/gspca/sonixb.c
+++ b/drivers/media/video/gspca/sonixb.c
@@ -1079,20 +1079,23 @@ static int sd_config(struct gspca_dev *gspca_dev,
         }
         cam->npkt = 36;                 /* 36 packets per ISOC message */
 
-        if (sensor_data[sd->sensor].flags & F_COARSE_EXPO) {
-                sd->ctrls[EXPOSURE].min = COARSE_EXPOSURE_MIN;
-                sd->ctrls[EXPOSURE].max = COARSE_EXPOSURE_MAX;
-                sd->ctrls[EXPOSURE].def = COARSE_EXPOSURE_DEF;
-        }
-
         return 0;
 }
 
 /* this function is called at probe and resume time */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
+        struct sd *sd = (struct sd *) gspca_dev;
         const __u8 stop = 0x09; /* Disable stream turn of LED */
 
+        if (sensor_data[sd->sensor].flags & F_COARSE_EXPO) {
+                sd->ctrls[EXPOSURE].min = COARSE_EXPOSURE_MIN;
+                sd->ctrls[EXPOSURE].max = COARSE_EXPOSURE_MAX;
+                sd->ctrls[EXPOSURE].def = COARSE_EXPOSURE_DEF;
+                if (sd->ctrls[EXPOSURE].val > COARSE_EXPOSURE_MAX)
+                        sd->ctrls[EXPOSURE].val = COARSE_EXPOSURE_DEF;
+        }
+
         reg_w(gspca_dev, 0x01, &stop, 1);
 
         return 0;
diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index afa3186b8038..0c9e6ddabd2c 100644
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -1235,7 +1235,7 @@ static const u8 po2030n_sensor_param1[][8] = {
         {DELAY, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /* delay 8ms */
         {0xa1, 0x6e, 0x1b, 0xf4, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x6e, 0x15, 0x04, 0x00, 0x00, 0x00, 0x10},
-        {0xd1, 0x6e, 0x16, 0x50, 0x40, 0x49, 0x40, 0x10},
+        {0xd1, 0x6e, 0x16, 0x40, 0x40, 0x40, 0x40, 0x10}, /* RGBG gains */
 /*param2*/
         {0xa1, 0x6e, 0x1d, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xa1, 0x6e, 0x04, 0x03, 0x00, 0x00, 0x00, 0x10},
@@ -1779,10 +1779,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->ag_cnt = -1;
         sd->quality = QUALITY_DEF;
 
-        /* if USB 1.1, let some bandwidth for the audio device */
-        if (gspca_dev->audio && gspca_dev->dev->speed < USB_SPEED_HIGH)
-                gspca_dev->nbalt--;
-
         INIT_WORK(&sd->work, qual_upd);
 
         return 0;
@@ -2063,6 +2059,16 @@ static void setredblue(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
 
+        if (sd->sensor == SENSOR_PO2030N) {
+                u8 rg1b[] =             /* red  green1 blue (no g2) */
+                        {0xc1, 0x6e, 0x16, 0x00, 0x40, 0x00, 0x00, 0x10};
+
+                /* 0x40 = normal value = gain x 1 */
+                rg1b[3] = sd->ctrls[RED].val * 2;
+                rg1b[5] = sd->ctrls[BLUE].val * 2;
+                i2c_w8(gspca_dev, rg1b);
+                return;
+        }
         reg_w1(gspca_dev, 0x05, sd->ctrls[RED].val);
 /*      reg_w1(gspca_dev, 0x07, 32); */
         reg_w1(gspca_dev, 0x06, sd->ctrls[BLUE].val);
@@ -2397,7 +2403,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         reg_w1(gspca_dev, 0x17, reg17);
         reg01 &= ~S_PWR_DN;             /* sensor power on */
         reg_w1(gspca_dev, 0x01, reg01);
-        reg01 &= ~SYS_SEL_48M;
+        reg01 &= ~SCL_SEL_OD;           /* remove open-drain mode */
         reg_w1(gspca_dev, 0x01, reg01);
 
         switch (sd->sensor) {
diff --git a/drivers/media/video/gspca/spca561.c b/drivers/media/video/gspca/spca561.c
index 259a0c73c664..4a5f209ce719 100644
--- a/drivers/media/video/gspca/spca561.c
+++ b/drivers/media/video/gspca/spca561.c
@@ -451,7 +451,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
         }
 
         cam = &gspca_dev->cam;
-        gspca_dev->nbalt = 7 + 1;       /* choose alternate 7 first */
+        cam->needs_full_bandwidth = 1;
 
         sd->chip_revision = id->driver_info;
         if (sd->chip_revision == Rev012A) {
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.c b/drivers/media/video/gspca/stv06xx/stv06xx.c
index 6f878f6c6e99..91d99b4cc57b 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.c
@@ -304,7 +304,7 @@ static int stv06xx_isoc_init(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         /* Start isoc bandwidth "negotiation" at max isoc bandwidth */
-        alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
+        alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1];
         alt->endpoint[0].desc.wMaxPacketSize =
                 cpu_to_le16(sd->sensor->max_packet_size[gspca_dev->curr_mode]);
 
@@ -317,7 +317,7 @@ static int stv06xx_isoc_nego(struct gspca_dev *gspca_dev)
         struct usb_host_interface *alt;
         struct sd *sd = (struct sd *) gspca_dev;
 
-        alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
+        alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1];
         packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
         min_packet_size = sd->sensor->min_packet_size[gspca_dev->curr_mode];
         if (packet_size <= min_packet_size)
diff --git a/drivers/media/video/gspca/t613.c b/drivers/media/video/gspca/t613.c
index ea44deb66af4..9b9f85a8e60e 100644
--- a/drivers/media/video/gspca/t613.c
+++ b/drivers/media/video/gspca/t613.c
@@ -30,6 +30,7 @@
 
 #define MODULE_NAME "t613"
 
+#include <linux/input.h>
 #include <linux/slab.h>
 #include "gspca.h"
 
@@ -57,6 +58,7 @@ struct sd {
         u8 effect;
 
         u8 sensor;
+        u8 button_pressed;
 };
 enum sensors {
         SENSOR_OM6802,
@@ -1095,15 +1097,35 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
                 msleep(20);
                 reg_w(gspca_dev, 0x0309);
         }
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        /* If the last button state is pressed, release it now! */
+        if (sd->button_pressed) {
+                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
+                input_sync(gspca_dev->input_dev);
+                sd->button_pressed = 0;
+        }
+#endif
 }
 
 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,                       /* isoc packet */
                         int len)                        /* iso packet length */
 {
+        struct sd *sd = (struct sd *) gspca_dev;
         int pkt_type;
 
         if (data[0] == 0x5a) {
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+                if (len > 20) {
+                        u8 state = (data[20] & 0x80) ? 1 : 0;
+                        if (sd->button_pressed != state) {
+                                input_report_key(gspca_dev->input_dev,
+                                                 KEY_CAMERA, state);
+                                input_sync(gspca_dev->input_dev);
+                                sd->button_pressed = state;
+                        }
+                }
+#endif
                 /* Control Packet, after this came the header again,
                  * but extra bytes came in the packet before this,
                  * sometimes an EOF arrives, sometimes not... */
@@ -1410,6 +1432,9 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
         .querymenu = sd_querymenu,
+#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+        .other_input = 1,
+#endif
 };
 
 /* -- module initialisation -- */
diff --git a/drivers/media/video/gspca/topro.c b/drivers/media/video/gspca/topro.c
index b2695b1dc603..444d3c5b9079 100644
--- a/drivers/media/video/gspca/topro.c
+++ b/drivers/media/video/gspca/topro.c
@@ -3946,7 +3946,7 @@ static int get_fr_idx(struct gspca_dev *gspca_dev)
                 /* 640x480 * 30 fps does not work */
                 if (i == 6                      /* if 30 fps */
                  && gspca_dev->width == 640)
-                        i = 0x86;               /* 15 fps */
+                        i = 0x05;               /* 15 fps */
         } else {
                 for (i = 0; i < ARRAY_SIZE(rates_6810) - 1; i++) {
                         if (sd->framerate >= rates_6810[i])
diff --git a/drivers/media/video/gspca/vicam.c b/drivers/media/video/gspca/vicam.c
index d12ea1518ace..911152e169d6 100644
--- a/drivers/media/video/gspca/vicam.c
+++ b/drivers/media/video/gspca/vicam.c
@@ -324,7 +324,8 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
         dev->work_thread = NULL;
         mutex_lock(&gspca_dev->usb_lock);
 
-        vicam_set_camera_power(gspca_dev, 0);
+        if (gspca_dev->present)
+                vicam_set_camera_power(gspca_dev, 0);
 }
 
 /* Table of supported USB devices */
diff --git a/drivers/media/video/gspca/xirlink_cit.c b/drivers/media/video/gspca/xirlink_cit.c
index fbb6ed25ec31..ecada178bceb 100644
--- a/drivers/media/video/gspca/xirlink_cit.c
+++ b/drivers/media/video/gspca/xirlink_cit.c
@@ -995,14 +995,12 @@ static int sd_config(struct gspca_dev *gspca_dev,
         case CIT_MODEL0:
                 cam->cam_mode = model0_mode;
                 cam->nmodes = ARRAY_SIZE(model0_mode);
-                cam->reverse_alts = 1;
                 gspca_dev->ctrl_dis = ~((1 << SD_CONTRAST) | (1 << SD_HFLIP));
                 sd->sof_len = 4;
                 break;
         case CIT_MODEL1:
                 cam->cam_mode = cif_yuv_mode;
                 cam->nmodes = ARRAY_SIZE(cif_yuv_mode);
-                cam->reverse_alts = 1;
                 gspca_dev->ctrl_dis = (1 << SD_HUE) | (1 << SD_HFLIP);
                 sd->sof_len = 4;
                 break;
@@ -2791,7 +2789,7 @@ static int sd_isoc_init(struct gspca_dev *gspca_dev)
         }
 
         /* Start isoc bandwidth "negotiation" at max isoc bandwidth */
-        alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
+        alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1];
         alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
 
         return 0;
@@ -2814,7 +2812,7 @@ static int sd_isoc_nego(struct gspca_dev *gspca_dev)
                 break;
         }
 
-        alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
+        alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1];
         packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
         if (packet_size <= min_packet_size)
                 return -EIO;
diff --git a/drivers/media/video/gspca/zc3xx.c b/drivers/media/video/gspca/zc3xx.c
index 0202fead6b97..b9e15bb0328b 100644
--- a/drivers/media/video/gspca/zc3xx.c
+++ b/drivers/media/video/gspca/zc3xx.c
@@ -5381,12 +5381,12 @@ static const struct usb_action tas5130c_NoFlikerScale[] = {
         {}
 };
 
-static const struct usb_action gc0303_InitialScale[] = {
+/* from usbvm305.inf 0ac8:305b 07/06/15 (3 - tas5130c) */
+static const struct usb_action gc0303_Initial[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},         /* 00,00,01,cc, */
         {0xa0, 0x02, ZC3XX_R008_CLOCKSETTING},          /* 00,08,02,cc, */
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT},      /* 00,10,01,cc, */
-        {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT},           /* 00,02,00,cc,
-                                                         * 0<->10 */
+        {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x02, ZC3XX_R003_FRAMEWIDTHHIGH},        /* 00,03,02,cc, */
         {0xa0, 0x80, ZC3XX_R004_FRAMEWIDTHLOW},         /* 00,04,80,cc, */
         {0xa0, 0x01, ZC3XX_R005_FRAMEHEIGHTHIGH},       /* 00,05,01,cc, */
@@ -5405,29 +5405,22 @@ static const struct usb_action gc0303_InitialScale[] = {
                                                          * 6<->8 */
         {0xa0, 0x10, ZC3XX_R087_EXPTIMEMID},            /* 00,87,10,cc, */
         {0xa0, 0x98, ZC3XX_R08B_I2CDEVICEADDR},         /* 00,8b,98,cc, */
-        {0xaa, 0x1b, 0x0024},           /* 00,1b,24,aa, */
-        {0xdd, 0x00, 0x0080},           /* 00,00,80,dd, */
-        {0xaa, 0x1b, 0x0000},           /* 00,1b,00,aa, */
-        {0xaa, 0x13, 0x0002},           /* 00,13,02,aa, */
-        {0xaa, 0x15, 0x0004},           /* 00,15,04,aa */
-/*??    {0xaa, 0x01, 0x0000}, */
         {0xaa, 0x01, 0x0000},
         {0xaa, 0x1a, 0x0000},           /* 00,1a,00,aa, */
         {0xaa, 0x1c, 0x0017},           /* 00,1c,17,aa, */
+        {0xaa, 0x1b, 0x0000},
         {0xa0, 0x82, ZC3XX_R086_EXPTIMEHIGH},           /* 00,86,82,cc, */
         {0xa0, 0x83, ZC3XX_R087_EXPTIMEMID},            /* 00,87,83,cc, */
         {0xa0, 0x84, ZC3XX_R088_EXPTIMELOW},            /* 00,88,84,cc, */
         {0xaa, 0x05, 0x0010},           /* 00,05,10,aa, */
-        {0xaa, 0x0a, 0x0000},           /* 00,0a,00,aa, */
-        {0xaa, 0x0b, 0x00a0},           /* 00,0b,a0,aa, */
-        {0xaa, 0x0c, 0x0000},           /* 00,0c,00,aa, */
-        {0xaa, 0x0d, 0x00a0},           /* 00,0d,a0,aa, */
-        {0xaa, 0x0e, 0x0000},           /* 00,0e,00,aa, */
-        {0xaa, 0x0f, 0x00a0},           /* 00,0f,a0,aa, */
-        {0xaa, 0x10, 0x0000},           /* 00,10,00,aa, */
-        {0xaa, 0x11, 0x00a0},           /* 00,11,a0,aa, */
-/*??    {0xa0, 0x00, 0x0039},
-        {0xa1, 0x01, 0x0037}, */
+        {0xaa, 0x0a, 0x0002},
+        {0xaa, 0x0b, 0x0000},
+        {0xaa, 0x0c, 0x0002},
+        {0xaa, 0x0d, 0x0000},
+        {0xaa, 0x0e, 0x0002},
+        {0xaa, 0x0f, 0x0000},
+        {0xaa, 0x10, 0x0002},
+        {0xaa, 0x11, 0x0000},
         {0xaa, 0x16, 0x0001},           /* 00,16,01,aa, */
         {0xaa, 0x17, 0x00e8},           /* 00,17,e6,aa, (e6 -> e8) */
         {0xaa, 0x18, 0x0002},           /* 00,18,02,aa, */
@@ -5442,17 +5435,18 @@ static const struct usb_action gc0303_InitialScale[] = {
         {0xa0, 0x13, ZC3XX_R1CB_SHARPNESS05},           /* 01,cb,13,cc, */
         {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE},        /* 02,50,08,cc, */
         {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},          /* 03,01,08,cc, */
-        {0xa0, 0x60, ZC3XX_R1A8_DIGITALGAIN},           /* 01,a8,60,cc, */
+        {0xa0, 0x58, ZC3XX_R1A8_DIGITALGAIN},
         {0xa0, 0x61, ZC3XX_R116_RGAIN},                 /* 01,16,61,cc, */
         {0xa0, 0x65, ZC3XX_R118_BGAIN},                 /* 01,18,65,cc */
+        {0xaa, 0x1b, 0x0000},
         {}
 };
 
-static const struct usb_action gc0303_Initial[] = {
+static const struct usb_action gc0303_InitialScale[] = {
         {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},         /* 00,00,01,cc, */
         {0xa0, 0x02, ZC3XX_R008_CLOCKSETTING},          /* 00,08,02,cc, */
         {0xa0, 0x01, ZC3XX_R010_CMOSSENSORSELECT},      /* 00,10,01,cc, */
-        {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},           /* 00,02,10,cc, */
+        {0xa0, 0x10, ZC3XX_R002_CLOCKSELECT},
         {0xa0, 0x02, ZC3XX_R003_FRAMEWIDTHHIGH},        /* 00,03,02,cc, */
         {0xa0, 0x80, ZC3XX_R004_FRAMEWIDTHLOW},         /* 00,04,80,cc, */
         {0xa0, 0x01, ZC3XX_R005_FRAMEHEIGHTHIGH},       /* 00,05,01,cc, */
@@ -5471,34 +5465,26 @@ static const struct usb_action gc0303_Initial[] = {
                                                          * 8<->6 */
         {0xa0, 0x10, ZC3XX_R087_EXPTIMEMID},            /* 00,87,10,cc, */
         {0xa0, 0x98, ZC3XX_R08B_I2CDEVICEADDR},         /* 00,8b,98,cc, */
-        {0xaa, 0x1b, 0x0024},           /* 00,1b,24,aa, */
-        {0xdd, 0x00, 0x0080},           /* 00,00,80,dd, */
-        {0xaa, 0x1b, 0x0000},           /* 00,1b,00,aa, */
-        {0xaa, 0x13, 0x0002},           /* 00,13,02,aa, */
-        {0xaa, 0x15, 0x0004},           /* 00,15,04,aa */
-/*??    {0xaa, 0x01, 0x0000}, */
         {0xaa, 0x01, 0x0000},
         {0xaa, 0x1a, 0x0000},           /* 00,1a,00,aa, */
         {0xaa, 0x1c, 0x0017},           /* 00,1c,17,aa, */
+        {0xaa, 0x1b, 0x0000},
         {0xa0, 0x82, ZC3XX_R086_EXPTIMEHIGH},   /* 00,86,82,cc, */
         {0xa0, 0x83, ZC3XX_R087_EXPTIMEMID},    /* 00,87,83,cc, */
         {0xa0, 0x84, ZC3XX_R088_EXPTIMELOW},    /* 00,88,84,cc, */
         {0xaa, 0x05, 0x0010},           /* 00,05,10,aa, */
-        {0xaa, 0x0a, 0x0000},           /* 00,0a,00,aa, */
-        {0xaa, 0x0b, 0x00a0},           /* 00,0b,a0,aa, */
-        {0xaa, 0x0c, 0x0000},           /* 00,0c,00,aa, */
-        {0xaa, 0x0d, 0x00a0},           /* 00,0d,a0,aa, */
-        {0xaa, 0x0e, 0x0000},           /* 00,0e,00,aa, */
-        {0xaa, 0x0f, 0x00a0},           /* 00,0f,a0,aa, */
-        {0xaa, 0x10, 0x0000},           /* 00,10,00,aa, */
-        {0xaa, 0x11, 0x00a0},           /* 00,11,a0,aa, */
-/*??    {0xa0, 0x00, 0x0039},
-        {0xa1, 0x01, 0x0037}, */
+        {0xaa, 0x0a, 0x0001},
+        {0xaa, 0x0b, 0x0000},
+        {0xaa, 0x0c, 0x0001},
+        {0xaa, 0x0d, 0x0000},
+        {0xaa, 0x0e, 0x0001},
+        {0xaa, 0x0f, 0x0000},
+        {0xaa, 0x10, 0x0001},
+        {0xaa, 0x11, 0x0000},
         {0xaa, 0x16, 0x0001},           /* 00,16,01,aa, */
         {0xaa, 0x17, 0x00e8},           /* 00,17,e6,aa (e6 -> e8) */
         {0xaa, 0x18, 0x0002},           /* 00,18,02,aa, */
         {0xaa, 0x19, 0x0088},           /* 00,19,88,aa, */
-        {0xaa, 0x20, 0x0020},           /* 00,20,20,aa, */
         {0xa0, 0xb7, ZC3XX_R101_SENSORCORRECTION},      /* 01,01,b7,cc, */
         {0xa0, 0x05, ZC3XX_R012_VIDEOCONTROLFUNC},      /* 00,12,05,cc, */
         {0xa0, 0x0d, ZC3XX_R100_OPERATIONMODE},         /* 01,00,0d,cc, */
@@ -5508,36 +5494,37 @@ static const struct usb_action gc0303_Initial[] = {
         {0xa0, 0x13, ZC3XX_R1CB_SHARPNESS05},           /* 01,cb,13,cc, */
         {0xa0, 0x08, ZC3XX_R250_DEADPIXELSMODE},        /* 02,50,08,cc, */
         {0xa0, 0x08, ZC3XX_R301_EEPROMACCESS},          /* 03,01,08,cc, */
-        {0xa0, 0x60, ZC3XX_R1A8_DIGITALGAIN},           /* 01,a8,60,cc, */
+        {0xa0, 0x58, ZC3XX_R1A8_DIGITALGAIN},
         {0xa0, 0x61, ZC3XX_R116_RGAIN},         /* 01,16,61,cc, */
         {0xa0, 0x65, ZC3XX_R118_BGAIN},         /* 01,18,65,cc */
+        {0xaa, 0x1b, 0x0000},
         {}
 };
-static const struct usb_action gc0303_50HZScale[] = {
+static const struct usb_action gc0303_50HZ[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0001},           /* 00,83,01,aa */
-        {0xaa, 0x84, 0x00aa},           /* 00,84,aa,aa */
+        {0xaa, 0x84, 0x0063},
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc, */
         {0xa0, 0x06, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,0d,cc, */
         {0xa0, 0xa8, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,50,cc, */
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc, */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc, */
-        {0xa0, 0x8e, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,47,cc, */
+        {0xa0, 0x47, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,47,cc, */
         {0xa0, 0x0e, ZC3XX_R18C_AEFREEZE},              /* 01,8c,0e,cc, */
         {0xa0, 0x15, ZC3XX_R18F_AEUNFREEZE},            /* 01,8f,15,cc, */
         {0xa0, 0x10, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* 01,a9,10,cc, */
-        {0xa0, 0x24, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,24,cc, */
+        {0xa0, 0x48, ZC3XX_R1AA_DIGITALGAINSTEP},
         {0xa0, 0x62, ZC3XX_R01D_HSYNC_0},               /* 00,1d,62,cc, */
         {0xa0, 0x90, ZC3XX_R01E_HSYNC_1},               /* 00,1e,90,cc, */
         {0xa0, 0xc8, ZC3XX_R01F_HSYNC_2},               /* 00,1f,c8,cc, */
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},               /* 00,20,ff,cc, */
         {0xa0, 0x58, ZC3XX_R11D_GLOBALGAIN},            /* 01,1d,58,cc, */
         {0xa0, 0x42, ZC3XX_R180_AUTOCORRECTENABLE},     /* 01,80,42,cc, */
-        {0xa0, 0x78, ZC3XX_R18D_YTARGET},               /* 01,8d,78,cc */
+        {0xa0, 0x7f, ZC3XX_R18D_YTARGET},
         {}
 };
 
-static const struct usb_action gc0303_50HZ[] = {
+static const struct usb_action gc0303_50HZScale[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0003},           /* 00,83,03,aa */
         {0xaa, 0x84, 0x0054},           /* 00,84,54,aa */
@@ -5550,21 +5537,21 @@ static const struct usb_action gc0303_50HZ[] = {
         {0xa0, 0x0e, ZC3XX_R18C_AEFREEZE},              /* 01,8c,0e,cc, */
         {0xa0, 0x15, ZC3XX_R18F_AEUNFREEZE},            /* 01,8f,15,cc, */
         {0xa0, 0x10, ZC3XX_R1A9_DIGITALLIMITDIFF},      /* 01,a9,10,cc, */
-        {0xa0, 0x24, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,24,cc, */
+        {0xa0, 0x48, ZC3XX_R1AA_DIGITALGAINSTEP},       /* 01,aa,24,cc, */
         {0xa0, 0x62, ZC3XX_R01D_HSYNC_0},               /* 00,1d,62,cc, */
         {0xa0, 0x90, ZC3XX_R01E_HSYNC_1},               /* 00,1e,90,cc, */
         {0xa0, 0xc8, ZC3XX_R01F_HSYNC_2},               /* 00,1f,c8,cc, */
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},               /* 00,20,ff,cc, */
         {0xa0, 0x58, ZC3XX_R11D_GLOBALGAIN},            /* 01,1d,58,cc, */
         {0xa0, 0x42, ZC3XX_R180_AUTOCORRECTENABLE},     /* 01,80,42,cc, */
-        {0xa0, 0x78, ZC3XX_R18D_YTARGET},               /* 01,8d,78,cc */
+        {0xa0, 0x7f, ZC3XX_R18D_YTARGET},
         {}
 };
 
-static const struct usb_action gc0303_60HZScale[] = {
+static const struct usb_action gc0303_60HZ[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
-        {0xaa, 0x83, 0x0001},           /* 00,83,01,aa */
-        {0xaa, 0x84, 0x0062},           /* 00,84,62,aa */
+        {0xaa, 0x83, 0x0000},
+        {0xaa, 0x84, 0x003b},
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc, */
         {0xa0, 0x05, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,05,cc, */
         {0xa0, 0x88, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,88,cc, */
@@ -5581,14 +5568,14 @@ static const struct usb_action gc0303_60HZScale[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},               /* 00,20,ff,cc, */
         {0xa0, 0x58, ZC3XX_R11D_GLOBALGAIN},            /* 01,1d,58,cc, */
         {0xa0, 0x42, ZC3XX_R180_AUTOCORRECTENABLE},     /* 01,80,42,cc, */
-        {0xa0, 0x78, ZC3XX_R18D_YTARGET},               /* 01,8d,78,cc */
+        {0xa0, 0x80, ZC3XX_R18D_YTARGET},
         {}
 };
 
-static const struct usb_action gc0303_60HZ[] = {
+static const struct usb_action gc0303_60HZScale[] = {
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
-        {0xaa, 0x83, 0x0002},           /* 00,83,02,aa */
-        {0xaa, 0x84, 0x00c4},           /* 00,84,c4,aa */
+        {0xaa, 0x83, 0x0000},
+        {0xaa, 0x84, 0x0076},
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc, */
         {0xa0, 0x0b, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,1,0b,cc, */
         {0xa0, 0x10, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,2,10,cc, */
@@ -5605,18 +5592,18 @@ static const struct usb_action gc0303_60HZ[] = {
         {0xa0, 0xff, ZC3XX_R020_HSYNC_3},               /* 00,0,ff,cc, */
         {0xa0, 0x58, ZC3XX_R11D_GLOBALGAIN},            /* 01,d,58,cc, */
         {0xa0, 0x42, ZC3XX_R180_AUTOCORRECTENABLE},     /* 01,80,42,cc, */
-        {0xa0, 0x78, ZC3XX_R18D_YTARGET},               /* 01,d,78,cc */
+        {0xa0, 0x80, ZC3XX_R18D_YTARGET},
         {}
 };
 
-static const struct usb_action gc0303_NoFlikerScale[] = {
+static const struct usb_action gc0303_NoFliker[] = {
         {0xa0, 0x0c, ZC3XX_R100_OPERATIONMODE},         /* 01,00,0c,cc, */
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0000},           /* 00,83,00,aa */
         {0xaa, 0x84, 0x0020},           /* 00,84,20,aa */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,0,00,cc, */
-        {0xa0, 0x05, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,05,cc, */
-        {0xa0, 0x88, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,88,cc, */
+        {0xa0, 0x00, ZC3XX_R191_EXPOSURELIMITMID},
+        {0xa0, 0x48, ZC3XX_R192_EXPOSURELIMITLOW},
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc, */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc, */
         {0xa0, 0x10, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,10,cc, */
@@ -5631,14 +5618,14 @@ static const struct usb_action gc0303_NoFlikerScale[] = {
         {}
 };
 
-static const struct usb_action gc0303_NoFliker[] = {
+static const struct usb_action gc0303_NoFlikerScale[] = {
         {0xa0, 0x0c, ZC3XX_R100_OPERATIONMODE},         /* 01,00,0c,cc, */
         {0xaa, 0x82, 0x0000},           /* 00,82,00,aa */
         {0xaa, 0x83, 0x0000},           /* 00,83,00,aa */
         {0xaa, 0x84, 0x0020},           /* 00,84,20,aa */
         {0xa0, 0x00, ZC3XX_R190_EXPOSURELIMITHIGH},     /* 01,90,00,cc, */
-        {0xa0, 0x0b, ZC3XX_R191_EXPOSURELIMITMID},      /* 01,91,0b,cc, */
-        {0xa0, 0x10, ZC3XX_R192_EXPOSURELIMITLOW},      /* 01,92,10,cc, */
+        {0xa0, 0x00, ZC3XX_R191_EXPOSURELIMITMID},
+        {0xa0, 0x48, ZC3XX_R192_EXPOSURELIMITLOW},
         {0xa0, 0x00, ZC3XX_R195_ANTIFLICKERHIGH},       /* 01,95,00,cc, */
         {0xa0, 0x00, ZC3XX_R196_ANTIFLICKERMID},        /* 01,96,00,cc, */
         {0xa0, 0x10, ZC3XX_R197_ANTIFLICKERLOW},        /* 01,97,10,cc, */
@@ -5809,7 +5796,7 @@ static void setmatrix(struct gspca_dev *gspca_dev)
         static const u8 tas5130c_matrix[9] =
                 {0x68, 0xec, 0xec, 0xec, 0x68, 0xec, 0xec, 0xec, 0x68};
         static const u8 gc0303_matrix[9] =
-                {0x7b, 0xea, 0xea, 0xea, 0x7b, 0xea, 0xea, 0xea, 0x7b};
+                {0x6c, 0xea, 0xea, 0xea, 0x6c, 0xea, 0xea, 0xea, 0x6c};
         static const u8 *matrix_tb[SENSOR_MAX] = {
                 [SENSOR_ADCM2700] =     adcm2700_matrix,
                 [SENSOR_CS2102] =       ov7620_matrix,
@@ -6426,10 +6413,6 @@ static int sd_config(struct gspca_dev *gspca_dev,
         gspca_dev->cam.ctrls = sd->ctrls;
         sd->quality = QUALITY_DEF;
 
-        /* if USB 1.1, let some bandwidth for the audio device */
-        if (gspca_dev->audio && gspca_dev->dev->speed < USB_SPEED_HIGH)
-                gspca_dev->nbalt--;
-
         return 0;
 }
 
diff --git a/drivers/media/video/ir-kbd-i2c.c b/drivers/media/video/ir-kbd-i2c.c
index 3ab875d036e1..a7c41d32f414 100644
--- a/drivers/media/video/ir-kbd-i2c.c
+++ b/drivers/media/video/ir-kbd-i2c.c
@@ -244,7 +244,7 @@ static int get_key_avermedia_cardbus(struct IR_i2c *ir,
 
 /* ----------------------------------------------------------------------- */
 
-static void ir_key_poll(struct IR_i2c *ir)
+static int ir_key_poll(struct IR_i2c *ir)
 {
         static u32 ir_key, ir_raw;
         int rc;
@@ -253,20 +253,28 @@ static void ir_key_poll(struct IR_i2c *ir)
         rc = ir->get_key(ir, &ir_key, &ir_raw);
         if (rc < 0) {
                 dprintk(2,"error\n");
-                return;
+                return rc;
         }
 
         if (rc) {
                 dprintk(1, "%s: keycode = 0x%04x\n", __func__, ir_key);
                 rc_keydown(ir->rc, ir_key, 0);
         }
+        return 0;
 }
 
 static void ir_work(struct work_struct *work)
 {
+        int rc;
         struct IR_i2c *ir = container_of(work, struct IR_i2c, work.work);
 
-        ir_key_poll(ir);
+        rc = ir_key_poll(ir);
+        if (rc == -ENODEV) {
+                rc_unregister_device(ir->rc);
+                ir->rc = NULL;
+                return;
+        }
+
         schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling_interval));
 }
 
@@ -446,7 +454,8 @@ static int ir_remove(struct i2c_client *client)
         cancel_delayed_work_sync(&ir->work);
 
         /* unregister device */
-        rc_unregister_device(ir->rc);
+        if (ir->rc)
+                rc_unregister_device(ir->rc);
 
         /* free memory */
         kfree(ir);
@@ -489,11 +498,3 @@ static void __exit ir_fini(void)
 
 module_init(ir_init);
 module_exit(ir_fini);
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/video/ivtv/ivtv-i2c.h b/drivers/media/video/ivtv/ivtv-i2c.h
index 9332920ca4ff..7b9ec1cfeb80 100644
--- a/drivers/media/video/ivtv/ivtv-i2c.h
+++ b/drivers/media/video/ivtv/ivtv-i2c.h
@@ -25,7 +25,7 @@ struct i2c_client *ivtv_i2c_new_ir_legacy(struct ivtv *itv);
 int ivtv_i2c_register(struct ivtv *itv, unsigned idx);
 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw);
 
-/* init + register i2c algo-bit adapter */
+/* init + register i2c adapter */
 int init_ivtv_i2c(struct ivtv *itv);
 void exit_ivtv_i2c(struct ivtv *itv);
 
diff --git a/drivers/media/video/m5mols/m5mols.h b/drivers/media/video/m5mols/m5mols.h
index 82c8817bd32d..4b021e1ee5f2 100644
--- a/drivers/media/video/m5mols/m5mols.h
+++ b/drivers/media/video/m5mols/m5mols.h
@@ -163,7 +163,6 @@ struct m5mols_version {
  * @ffmt: current fmt according to resolution type
  * @res_type: current resolution type
  * @irq_waitq: waitqueue for the capture
- * @work_irq: workqueue for the IRQ
  * @flags: state variable for the interrupt handler
  * @handle: control handler
  * @autoexposure: Auto Exposure control
@@ -175,14 +174,12 @@ struct m5mols_version {
  * @ver: information of the version
  * @cap: the capture mode attributes
  * @power: current sensor's power status
- * @ctrl_sync: true means all controls of the sensor are initialized
- * @int_capture: true means the capture interrupt is issued once
+ * @isp_ready: 1 when the ISP controller has completed booting
+ * @ctrl_sync: 1 when the control handler state is restored in H/W
  * @lock_ae: true means the Auto Exposure is locked
  * @lock_awb: true means the Aut WhiteBalance is locked
  * @resolution: register value for current resolution
- * @interrupt: register value for current interrupt status
  * @mode: register value for current operation mode
- * @mode_save: register value for current operation mode for saving
  * @set_power: optional power callback to the board code
  */
 struct m5mols_info {
@@ -191,16 +188,16 @@ struct m5mols_info {
         struct media_pad pad;
         struct v4l2_mbus_framefmt ffmt[M5MOLS_RESTYPE_MAX];
         int res_type;
+
         wait_queue_head_t irq_waitq;
-        struct work_struct work_irq;
-        unsigned long flags;
+        atomic_t irq_done;
 
         struct v4l2_ctrl_handler handle;
+
         /* Autoexposure/exposure control cluster */
-        struct {
-                struct v4l2_ctrl *autoexposure;
-                struct v4l2_ctrl *exposure;
-        };
+        struct v4l2_ctrl *autoexposure;
+        struct v4l2_ctrl *exposure;
+
         struct v4l2_ctrl *autowb;
         struct v4l2_ctrl *colorfx;
         struct v4l2_ctrl *saturation;
@@ -208,21 +205,19 @@ struct m5mols_info {
 
         struct m5mols_version ver;
         struct m5mols_capture cap;
-        bool power;
-        bool ctrl_sync;
+
+        unsigned int isp_ready:1;
+        unsigned int power:1;
+        unsigned int ctrl_sync:1;
+
         bool lock_ae;
         bool lock_awb;
         u8 resolution;
-        u8 interrupt;
         u8 mode;
-        u8 mode_save;
+
         int (*set_power)(struct device *dev, int on);
 };
 
-#define ST_CAPT_IRQ 0
-
-#define is_powered(__info) (__info->power)
-#define is_ctrl_synced(__info) (__info->ctrl_sync)
 #define is_available_af(__info) (__info->ver.af)
 #define is_code(__code, __type) (__code == m5mols_default_ffmt[__type].code)
 #define is_manufacturer(__info, __manufacturer) \
@@ -257,7 +252,15 @@ int m5mols_read_u8(struct v4l2_subdev *sd, u32 reg_comb, u8 *val);
 int m5mols_read_u16(struct v4l2_subdev *sd, u32 reg_comb, u16 *val);
 int m5mols_read_u32(struct v4l2_subdev *sd, u32 reg_comb, u32 *val);
 int m5mols_write(struct v4l2_subdev *sd, u32 reg_comb, u32 val);
-int m5mols_busy(struct v4l2_subdev *sd, u8 category, u8 cmd, u8 value);
+
+int m5mols_busy_wait(struct v4l2_subdev *sd, u32 reg, u32 value, u32 mask,
+                     int timeout);
+
+/* Mask value for busy waiting until M-5MOLS I2C interface is initialized */
+#define M5MOLS_I2C_RDY_WAIT_FL          (1 << 16)
+/* ISP state transition timeout, in ms */
+#define M5MOLS_MODE_CHANGE_TIMEOUT      200
+#define M5MOLS_BUSY_WAIT_DEF_TIMEOUT    250
 
 /*
  * Mode operation of the M-5MOLS
@@ -282,7 +285,8 @@ int m5mols_busy(struct v4l2_subdev *sd, u8 category, u8 cmd, u8 value);
 int m5mols_mode(struct m5mols_info *info, u8 mode);
 
 int m5mols_enable_interrupt(struct v4l2_subdev *sd, u8 reg);
-int m5mols_sync_controls(struct m5mols_info *info);
+int m5mols_wait_interrupt(struct v4l2_subdev *sd, u8 condition, u32 timeout);
+int m5mols_restore_controls(struct m5mols_info *info);
 int m5mols_start_capture(struct m5mols_info *info);
 int m5mols_do_scenemode(struct m5mols_info *info, u8 mode);
 int m5mols_lock_3a(struct m5mols_info *info, bool lock);
diff --git a/drivers/media/video/m5mols/m5mols_capture.c b/drivers/media/video/m5mols/m5mols_capture.c
index 3248ac805711..ba25e8e2ba4c 100644
--- a/drivers/media/video/m5mols/m5mols_capture.c
+++ b/drivers/media/video/m5mols/m5mols_capture.c
@@ -1,3 +1,4 @@
+
 /*
  * The Capture code for Fujitsu M-5MOLS ISP
  *
@@ -25,26 +26,11 @@
 #include <media/v4l2-device.h>
 #include <media/v4l2-subdev.h>
 #include <media/m5mols.h>
+#include <media/s5p_fimc.h>
 
 #include "m5mols.h"
 #include "m5mols_reg.h"
 
-static int m5mols_capture_error_handler(struct m5mols_info *info,
-                                        int timeout)
-{
-        int ret;
-
-        /* Disable all interrupts and clear relevant interrupt staus bits */
-        ret = m5mols_write(&info->sd, SYSTEM_INT_ENABLE,
-                           info->interrupt & ~(REG_INT_CAPTURE));
-        if (ret)
-                return ret;
-
-        if (timeout == 0)
-                return -ETIMEDOUT;
-
-        return 0;
-}
 /**
  * m5mols_read_rational - I2C read of a rational number
  *
@@ -121,69 +107,54 @@ int m5mols_start_capture(struct m5mols_info *info)
 {
         struct v4l2_subdev *sd = &info->sd;
         u8 resolution = info->resolution;
-        int timeout;
         int ret;
 
         /*
-         * Preparing capture. Setting control & interrupt before entering
-         * capture mode
-         *
-         * 1) change to MONITOR mode for operating control & interrupt
-         * 2) set controls (considering v4l2_control value & lock 3A)
-         * 3) set interrupt
-         * 4) change to CAPTURE mode
+         * Synchronize the controls, set the capture frame resolution and color
+         * format. The frame capture is initiated during switching from Monitor
+         * to Capture mode.
          */
         ret = m5mols_mode(info, REG_MONITOR);
         if (!ret)
-                ret = m5mols_sync_controls(info);
+                ret = m5mols_restore_controls(info);
         if (!ret)
-                ret = m5mols_lock_3a(info, true);
+                ret = m5mols_write(sd, CAPP_YUVOUT_MAIN, REG_JPEG);
+        if (!ret)
+                ret = m5mols_write(sd, CAPP_MAIN_IMAGE_SIZE, resolution);
         if (!ret)
-                ret = m5mols_enable_interrupt(sd, REG_INT_CAPTURE);
+                ret = m5mols_lock_3a(info, true);
         if (!ret)
                 ret = m5mols_mode(info, REG_CAPTURE);
-        if (!ret) {
-                /* Wait for capture interrupt, after changing capture mode */
-                timeout = wait_event_interruptible_timeout(info->irq_waitq,
-                                           test_bit(ST_CAPT_IRQ, &info->flags),
-                                           msecs_to_jiffies(2000));
-                if (test_and_clear_bit(ST_CAPT_IRQ, &info->flags))
-                        ret = m5mols_capture_error_handler(info, timeout);
-        }
+        if (!ret)
+                /* Wait until a frame is captured to ISP internal memory */
+                ret = m5mols_wait_interrupt(sd, REG_INT_CAPTURE, 2000);
         if (!ret)
                 ret = m5mols_lock_3a(info, false);
         if (ret)
                 return ret;
+
         /*
-         * Starting capture. Setting capture frame count and resolution and
-         * the format(available format: JPEG, Bayer RAW, YUV).
-         *
-         * 1) select single or multi(enable to 25), format, size
-         * 2) set interrupt
-         * 3) start capture(for main image, now)
-         * 4) get information
-         * 5) notify file size to v4l2 device(e.g, to s5p-fimc v4l2 device)
+         * Initiate the captured data transfer to a MIPI-CSI receiver.
          */
         ret = m5mols_write(sd, CAPC_SEL_FRAME, 1);
         if (!ret)
-                ret = m5mols_write(sd, CAPP_YUVOUT_MAIN, REG_JPEG);
-        if (!ret)
-                ret = m5mols_write(sd, CAPP_MAIN_IMAGE_SIZE, resolution);
-        if (!ret)
-                ret = m5mols_enable_interrupt(sd, REG_INT_CAPTURE);
-        if (!ret)
                 ret = m5mols_write(sd, CAPC_START, REG_CAP_START_MAIN);
         if (!ret) {
+                bool captured = false;
+                unsigned int size;
+
                 /* Wait for the capture completion interrupt */
-                timeout = wait_event_interruptible_timeout(info->irq_waitq,
-                                           test_bit(ST_CAPT_IRQ, &info->flags),
-                                           msecs_to_jiffies(2000));
-                if (test_and_clear_bit(ST_CAPT_IRQ, &info->flags)) {
+                ret = m5mols_wait_interrupt(sd, REG_INT_CAPTURE, 2000);
+                if (!ret) {
+                        captured = true;
                         ret = m5mols_capture_info(info);
-                        if (!ret)
-                                v4l2_subdev_notify(sd, 0, &info->cap.total);
                 }
+                size = captured ? info->cap.main : 0;
+                v4l2_dbg(1, m5mols_debug, sd, "%s: size: %d, thumb.: %d B\n",
+                         __func__, size, info->cap.thumb);
+
+                v4l2_subdev_notify(sd, S5P_FIMC_TX_END_NOTIFY, &size);
         }
 
-        return m5mols_capture_error_handler(info, timeout);
+        return ret;
 }
diff --git a/drivers/media/video/m5mols/m5mols_core.c b/drivers/media/video/m5mols/m5mols_core.c
index e0f09e531800..93d768db9f33 100644
--- a/drivers/media/video/m5mols/m5mols_core.c
+++ b/drivers/media/video/m5mols/m5mols_core.c
@@ -135,10 +135,13 @@ static u32 m5mols_swap_byte(u8 *data, u8 length)
  * @reg: combination of size, category and command for the I2C packet
  * @size: desired size of I2C packet
  * @val: read value
+ *
+ * Returns 0 on success, or else negative errno.
  */
 static int m5mols_read(struct v4l2_subdev *sd, u32 size, u32 reg, u32 *val)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
+        struct m5mols_info *info = to_m5mols(sd);
         u8 rbuf[M5MOLS_I2C_MAX_SIZE + 1];
         u8 category = I2C_CATEGORY(reg);
         u8 cmd = I2C_COMMAND(reg);
@@ -168,15 +171,17 @@ static int m5mols_read(struct v4l2_subdev *sd, u32 size, u32 reg, u32 *val)
         usleep_range(200, 200);
 
         ret = i2c_transfer(client->adapter, msg, 2);
-        if (ret < 0) {
-                v4l2_err(sd, "read failed: size:%d cat:%02x cmd:%02x. %d\n",
-                         size, category, cmd, ret);
-                return ret;
+
+        if (ret == 2) {
+                *val = m5mols_swap_byte(&rbuf[1], size);
+                return 0;
         }
 
-        *val = m5mols_swap_byte(&rbuf[1], size);
+        if (info->isp_ready)
+                v4l2_err(sd, "read failed: size:%d cat:%02x cmd:%02x. %d\n",
+                         size, category, cmd, ret);
 
-        return 0;
+        return ret < 0 ? ret : -EIO;
 }
 
 int m5mols_read_u8(struct v4l2_subdev *sd, u32 reg, u8 *val)
@@ -229,10 +234,13 @@ int m5mols_read_u32(struct v4l2_subdev *sd, u32 reg, u32 *val)
  * m5mols_write - I2C command write function
  * @reg: combination of size, category and command for the I2C packet
  * @val: value to write
+ *
+ * Returns 0 on success, or else negative errno.
  */
 int m5mols_write(struct v4l2_subdev *sd, u32 reg, u32 val)
 {
         struct i2c_client *client = v4l2_get_subdevdata(sd);
+        struct m5mols_info *info = to_m5mols(sd);
         u8 wbuf[M5MOLS_I2C_MAX_SIZE + 4];
         u8 category = I2C_CATEGORY(reg);
         u8 cmd = I2C_COMMAND(reg);
@@ -263,28 +271,45 @@ int m5mols_write(struct v4l2_subdev *sd, u32 reg, u32 val)
         usleep_range(200, 200);
 
         ret = i2c_transfer(client->adapter, msg, 1);
-        if (ret < 0) {
-                v4l2_err(sd, "write failed: size:%d cat:%02x cmd:%02x. %d\n",
-                        size, category, cmd, ret);
-                return ret;
-        }
+        if (ret == 1)
+                return 0;
 
-        return 0;
+        if (info->isp_ready)
+                v4l2_err(sd, "write failed: cat:%02x cmd:%02x ret:%d\n",
+                         category, cmd, ret);
+
+        return ret < 0 ? ret : -EIO;
 }
 
-int m5mols_busy(struct v4l2_subdev *sd, u8 category, u8 cmd, u8 mask)
+/**
+ * m5mols_busy_wait - Busy waiting with I2C register polling
+ * @reg: the I2C_REG() address of an 8-bit status register to check
+ * @value: expected status register value
+ * @mask: bit mask for the read status register value
+ * @timeout: timeout in miliseconds, or -1 for default timeout
+ *
+ * The @reg register value is ORed with @mask before comparing with @value.
+ *
+ * Return: 0 if the requested condition became true within less than
+ *         @timeout ms, or else negative errno.
+ */
+int m5mols_busy_wait(struct v4l2_subdev *sd, u32 reg, u32 value, u32 mask,
+                     int timeout)
 {
-        u8 busy;
-        int i;
-        int ret;
+        int ms = timeout < 0 ? M5MOLS_BUSY_WAIT_DEF_TIMEOUT : timeout;
+        unsigned long end = jiffies + msecs_to_jiffies(ms);
+        u8 status;
 
-        for (i = 0; i < M5MOLS_I2C_CHECK_RETRY; i++) {
-                ret = m5mols_read_u8(sd, I2C_REG(category, cmd, 1), &busy);
-                if (ret < 0)
+        do {
+                int ret = m5mols_read_u8(sd, reg, &status);
+
+                if (ret < 0 && !(mask & M5MOLS_I2C_RDY_WAIT_FL))
                         return ret;
-                if ((busy & mask) == mask)
+                if (!ret && (status & mask & 0xff) == (value & 0xff))
                         return 0;
-        }
+                usleep_range(100, 250);
+        } while (ms > 0 && time_is_after_jiffies(end));
+
         return -EBUSY;
 }
 
@@ -307,6 +332,20 @@ int m5mols_enable_interrupt(struct v4l2_subdev *sd, u8 reg)
         return ret;
 }
 
+int m5mols_wait_interrupt(struct v4l2_subdev *sd, u8 irq_mask, u32 timeout)
+{
+        struct m5mols_info *info = to_m5mols(sd);
+
+        int ret = wait_event_interruptible_timeout(info->irq_waitq,
+                                atomic_add_unless(&info->irq_done, -1, 0),
+                                msecs_to_jiffies(timeout));
+        if (ret <= 0)
+                return ret ? ret : -ETIMEDOUT;
+
+        return m5mols_busy_wait(sd, SYSTEM_INT_FACTOR, irq_mask,
+                                M5MOLS_I2C_RDY_WAIT_FL | irq_mask, -1);
+}
+
 /**
  * m5mols_reg_mode - Write the mode and check busy status
  *
@@ -316,8 +355,10 @@ int m5mols_enable_interrupt(struct v4l2_subdev *sd, u8 reg)
 static int m5mols_reg_mode(struct v4l2_subdev *sd, u8 mode)
 {
         int ret = m5mols_write(sd, SYSTEM_SYSMODE, mode);
-
-        return ret ? ret : m5mols_busy(sd, CAT_SYSTEM, CAT0_SYSMODE, mode);
+        if (ret < 0)
+                return ret;
+        return m5mols_busy_wait(sd, SYSTEM_SYSMODE, mode, 0xff,
+                                M5MOLS_MODE_CHANGE_TIMEOUT);
 }
 
 /**
@@ -338,13 +379,13 @@ int m5mols_mode(struct m5mols_info *info, u8 mode)
                 return ret;
 
         ret = m5mols_read_u8(sd, SYSTEM_SYSMODE, &reg);
-        if ((!ret && reg == mode) || ret)
+        if (ret || reg == mode)
                 return ret;
 
         switch (reg) {
         case REG_PARAMETER:
                 ret = m5mols_reg_mode(sd, REG_MONITOR);
-                if (!ret && mode == REG_MONITOR)
+                if (mode == REG_MONITOR)
                         break;
                 if (!ret)
                         ret = m5mols_reg_mode(sd, REG_CAPTURE);
@@ -361,7 +402,7 @@ int m5mols_mode(struct m5mols_info *info, u8 mode)
 
         case REG_CAPTURE:
                 ret = m5mols_reg_mode(sd, REG_MONITOR);
-                if (!ret && mode == REG_MONITOR)
+                if (mode == REG_MONITOR)
                         break;
                 if (!ret)
                         ret = m5mols_reg_mode(sd, REG_PARAMETER);
@@ -570,26 +611,25 @@ static struct v4l2_subdev_pad_ops m5mols_pad_ops = {
 };
 
 /**
- * m5mols_sync_controls - Apply default scene mode and the current controls
+ * m5mols_restore_controls - Apply current control values to the registers
  *
- * This is used only streaming for syncing between v4l2_ctrl framework and
- * m5mols's controls. First, do the scenemode to the sensor, then call
- * v4l2_ctrl_handler_setup. It can be same between some commands and
- * the scenemode's in the default v4l2_ctrls. But, such commands of control
- * should be prior to the scenemode's one.
+ * m5mols_do_scenemode() handles all parameters for which there is yet no
+ * individual control. It should be replaced at some point by setting each
+ * control individually, in required register set up order.
  */
-int m5mols_sync_controls(struct m5mols_info *info)
+int m5mols_restore_controls(struct m5mols_info *info)
 {
-        int ret = -EINVAL;
+        int ret;
 
-        if (!is_ctrl_synced(info)) {
-                ret = m5mols_do_scenemode(info, REG_SCENE_NORMAL);
-                if (ret)
-                        return ret;
+        if (info->ctrl_sync)
+                return 0;
 
-                v4l2_ctrl_handler_setup(&info->handle);
-                info->ctrl_sync = true;
-        }
+        ret = m5mols_do_scenemode(info, REG_SCENE_NORMAL);
+        if (ret)
+                return ret;
+
+        ret = v4l2_ctrl_handler_setup(&info->handle);
+        info->ctrl_sync = !ret;
 
         return ret;
 }
@@ -613,7 +653,7 @@ static int m5mols_start_monitor(struct m5mols_info *info)
         if (!ret)
                 ret = m5mols_mode(info, REG_MONITOR);
         if (!ret)
-                ret = m5mols_sync_controls(info);
+                ret = m5mols_restore_controls(info);
 
         return ret;
 }
@@ -645,17 +685,25 @@ static int m5mols_s_ctrl(struct v4l2_ctrl *ctrl)
 {
         struct v4l2_subdev *sd = to_sd(ctrl);
         struct m5mols_info *info = to_m5mols(sd);
+        int ispstate = info->mode;
         int ret;
 
-        info->mode_save = info->mode;
+        /*
+         * If needed, defer restoring the controls until
+         * the device is fully initialized.
+         */
+        if (!info->isp_ready) {
+                info->ctrl_sync = 0;
+                return 0;
+        }
 
         ret = m5mols_mode(info, REG_PARAMETER);
-        if (!ret)
-                ret = m5mols_set_ctrl(ctrl);
-        if (!ret)
-                ret = m5mols_mode(info, info->mode_save);
-
-        return ret;
+        if (ret < 0)
+                return ret;
+        ret = m5mols_set_ctrl(ctrl);
+        if (ret < 0)
+                return ret;
+        return m5mols_mode(info, ispstate);
 }
 
 static const struct v4l2_ctrl_ops m5mols_ctrl_ops = {
@@ -669,10 +717,10 @@ static int m5mols_sensor_power(struct m5mols_info *info, bool enable)
         const struct m5mols_platform_data *pdata = info->pdata;
         int ret;
 
-        if (enable) {
-                if (is_powered(info))
-                        return 0;
+        if (info->power == enable)
+                return 0;
 
+        if (enable) {
                 if (info->set_power) {
                         ret = info->set_power(&client->dev, 1);
                         if (ret)
@@ -686,15 +734,11 @@ static int m5mols_sensor_power(struct m5mols_info *info, bool enable)
                 }
 
                 gpio_set_value(pdata->gpio_reset, !pdata->reset_polarity);
-                usleep_range(1000, 1000);
-                info->power = true;
+                info->power = 1;
 
                 return ret;
         }
 
-        if (!is_powered(info))
-                return 0;
-
         ret = regulator_bulk_disable(ARRAY_SIZE(supplies), supplies);
         if (ret)
                 return ret;
@@ -703,8 +747,9 @@ static int m5mols_sensor_power(struct m5mols_info *info, bool enable)
                 info->set_power(&client->dev, 0);
 
         gpio_set_value(pdata->gpio_reset, pdata->reset_polarity);
-        usleep_range(1000, 1000);
-        info->power = false;
+
+        info->isp_ready = 0;
+        info->power = 0;
 
         return ret;
 }
@@ -717,21 +762,29 @@ int __attribute__ ((weak)) m5mols_update_fw(struct v4l2_subdev *sd,
 }
 
 /**
- * m5mols_sensor_armboot - Booting M-5MOLS internal ARM core.
+ * m5mols_fw_start - M-5MOLS internal ARM controller initialization
  *
- * Booting internal ARM core makes the M-5MOLS is ready for getting commands
- * with I2C. It's the first thing to be done after it powered up. It must wait
- * at least 520ms recommended by M-5MOLS datasheet, after executing arm booting.
+ * Execute the M-5MOLS internal ARM controller initialization sequence.
+ * This function should be called after the supply voltage has been
+ * applied and before any requests to the device are made.
  */
-static int m5mols_sensor_armboot(struct v4l2_subdev *sd)
+static int m5mols_fw_start(struct v4l2_subdev *sd)
 {
+        struct m5mols_info *info = to_m5mols(sd);
         int ret;
 
-        ret = m5mols_write(sd, FLASH_CAM_START, REG_START_ARM_BOOT);
+        atomic_set(&info->irq_done, 0);
+        /* Wait until I2C slave is initialized in Flash Writer mode */
+        ret = m5mols_busy_wait(sd, FLASH_CAM_START, REG_IN_FLASH_MODE,
+                               M5MOLS_I2C_RDY_WAIT_FL | 0xff, -1);
+        if (!ret)
+                ret = m5mols_write(sd, FLASH_CAM_START, REG_START_ARM_BOOT);
+        if (!ret)
+                ret = m5mols_wait_interrupt(sd, REG_INT_MODE, 2000);
         if (ret < 0)
                 return ret;
 
-        msleep(520);
+        info->isp_ready = 1;
 
         ret = m5mols_get_version(sd);
         if (!ret)
@@ -743,7 +796,8 @@ static int m5mols_sensor_armboot(struct v4l2_subdev *sd)
 
         ret = m5mols_write(sd, PARM_INTERFACE, REG_INTERFACE_MIPI);
         if (!ret)
-                ret = m5mols_enable_interrupt(sd, REG_INT_AF);
+                ret = m5mols_enable_interrupt(sd,
+                                REG_INT_AF | REG_INT_CAPTURE);
 
         return ret;
 }
@@ -780,7 +834,7 @@ static int m5mols_init_controls(struct m5mols_info *info)
                         4, (1 << V4L2_COLORFX_BW), V4L2_COLORFX_NONE);
         info->autoexposure = v4l2_ctrl_new_std_menu(&info->handle,
                         &m5mols_ctrl_ops, V4L2_CID_EXPOSURE_AUTO,
-                        1, 0, V4L2_EXPOSURE_MANUAL);
+                        1, 0, V4L2_EXPOSURE_AUTO);
 
         sd->ctrl_handler = &info->handle;
         if (info->handle.error) {
@@ -809,16 +863,7 @@ static int m5mols_s_power(struct v4l2_subdev *sd, int on)
         if (on) {
                 ret = m5mols_sensor_power(info, true);
                 if (!ret)
-                        ret = m5mols_sensor_armboot(sd);
-                if (!ret)
-                        ret = m5mols_init_controls(info);
-                if (ret)
-                        return ret;
-
-                info->ffmt[M5MOLS_RESTYPE_MONITOR] =
-                        m5mols_default_ffmt[M5MOLS_RESTYPE_MONITOR];
-                info->ffmt[M5MOLS_RESTYPE_CAPTURE] =
-                        m5mols_default_ffmt[M5MOLS_RESTYPE_CAPTURE];
+                        ret = m5mols_fw_start(sd);
                 return ret;
         }
 
@@ -829,17 +874,14 @@ static int m5mols_s_power(struct v4l2_subdev *sd, int on)
                 if (!ret)
                         ret = m5mols_write(sd, AF_MODE, REG_AF_POWEROFF);
                 if (!ret)
-                        ret = m5mols_busy(sd, CAT_SYSTEM, CAT0_STATUS,
-                                        REG_AF_IDLE);
-                if (!ret)
-                        v4l2_info(sd, "Success soft-landing lens\n");
+                        ret = m5mols_busy_wait(sd, SYSTEM_STATUS, REG_AF_IDLE,
+                                               0xff, -1);
+                if (ret < 0)
+                        v4l2_warn(sd, "Soft landing lens failed\n");
         }
 
         ret = m5mols_sensor_power(info, false);
-        if (!ret) {
-                v4l2_ctrl_handler_free(&info->handle);
-                info->ctrl_sync = false;
-        }
+        info->ctrl_sync = 0;
 
         return ret;
 }
@@ -865,52 +907,33 @@ static const struct v4l2_subdev_core_ops m5mols_core_ops = {
         .log_status     = m5mols_log_status,
 };
 
+/*
+ * V4L2 subdev internal operations
+ */
+static int m5mols_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
+{
+        struct v4l2_mbus_framefmt *format = v4l2_subdev_get_try_format(fh, 0);
+
+        *format = m5mols_default_ffmt[0];
+        return 0;
+}
+
+static const struct v4l2_subdev_internal_ops m5mols_subdev_internal_ops = {
+        .open           = m5mols_open,
+};
+
 static const struct v4l2_subdev_ops m5mols_ops = {
         .core           = &m5mols_core_ops,
         .pad            = &m5mols_pad_ops,
         .video          = &m5mols_video_ops,
 };
 
-static void m5mols_irq_work(struct work_struct *work)
-{
-        struct m5mols_info *info =
-                container_of(work, struct m5mols_info, work_irq);
-        struct v4l2_subdev *sd = &info->sd;
-        u8 reg;
-        int ret;
-
-        if (!is_powered(info) ||
-                        m5mols_read_u8(sd, SYSTEM_INT_FACTOR, &info->interrupt))
-                return;
-
-        switch (info->interrupt & REG_INT_MASK) {
-        case REG_INT_AF:
-                if (!is_available_af(info))
-                        break;
-                ret = m5mols_read_u8(sd, AF_STATUS, &reg);
-                v4l2_dbg(2, m5mols_debug, sd, "AF %s\n",
-                         reg == REG_AF_FAIL ? "Failed" :
-                         reg == REG_AF_SUCCESS ? "Success" :
-                         reg == REG_AF_IDLE ? "Idle" : "Busy");
-                break;
-        case REG_INT_CAPTURE:
-                if (!test_and_set_bit(ST_CAPT_IRQ, &info->flags))
-                        wake_up_interruptible(&info->irq_waitq);
-
-                v4l2_dbg(2, m5mols_debug, sd, "CAPTURE\n");
-                break;
-        default:
-                v4l2_dbg(2, m5mols_debug, sd, "Undefined: %02x\n", reg);
-                break;
-        };
-}
-
 static irqreturn_t m5mols_irq_handler(int irq, void *data)
 {
-        struct v4l2_subdev *sd = data;
-        struct m5mols_info *info = to_m5mols(sd);
+        struct m5mols_info *info = to_m5mols(data);
 
-        schedule_work(&info->work_irq);
+        atomic_set(&info->irq_done, 1);
+        wake_up_interruptible(&info->irq_waitq);
 
         return IRQ_HANDLED;
 }
@@ -961,7 +984,9 @@ static int __devinit m5mols_probe(struct i2c_client *client,
         sd = &info->sd;
         strlcpy(sd->name, MODULE_NAME, sizeof(sd->name));
         v4l2_i2c_subdev_init(sd, client, &m5mols_ops);
+        sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
 
+        sd->internal_ops = &m5mols_subdev_internal_ops;
         info->pad.flags = MEDIA_PAD_FL_SOURCE;
         ret = media_entity_init(&sd->entity, 1, &info->pad, 0);
         if (ret < 0)
@@ -969,7 +994,6 @@ static int __devinit m5mols_probe(struct i2c_client *client,
         sd->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
 
         init_waitqueue_head(&info->irq_waitq);
-        INIT_WORK(&info->work_irq, m5mols_irq_work);
         ret = request_irq(client->irq, m5mols_irq_handler,
                           IRQF_TRIGGER_RISING, MODULE_NAME, sd);
         if (ret) {
@@ -977,7 +1001,20 @@ static int __devinit m5mols_probe(struct i2c_client *client,
                 goto out_me;
         }
         info->res_type = M5MOLS_RESTYPE_MONITOR;
-        return 0;
+        info->ffmt[0] = m5mols_default_ffmt[0];
+        info->ffmt[1] = m5mols_default_ffmt[1];
+
+        ret = m5mols_sensor_power(info, true);
+        if (ret)
+                goto out_me;
+
+        ret = m5mols_fw_start(sd);
+        if (!ret)
+                ret = m5mols_init_controls(info);
+
+        m5mols_sensor_power(info, false);
+        if (!ret)
+                return 0;
 out_me:
         media_entity_cleanup(&sd->entity);
 out_reg:
@@ -995,6 +1032,7 @@ static int __devexit m5mols_remove(struct i2c_client *client)
         struct m5mols_info *info = to_m5mols(sd);
 
         v4l2_device_unregister_subdev(sd);
+        v4l2_ctrl_handler_free(sd->ctrl_handler);
         free_irq(client->irq, sd);
 
         regulator_bulk_free(ARRAY_SIZE(supplies), supplies);
diff --git a/drivers/media/video/m5mols/m5mols_reg.h b/drivers/media/video/m5mols/m5mols_reg.h
index c755bd6edfe9..ae4aced0f9b2 100644
--- a/drivers/media/video/m5mols/m5mols_reg.h
+++ b/drivers/media/video/m5mols/m5mols_reg.h
@@ -55,39 +55,31 @@
  * There is many registers between customer version address and awb one. For
  * more specific contents, see definition if file m5mols.h.
  */
-#define CAT0_VER_CUSTOMER       0x00    /* customer version */
-#define CAT0_VER_PROJECT        0x01    /* project version */
-#define CAT0_VER_FIRMWARE       0x02    /* Firmware version */
-#define CAT0_VER_HARDWARE       0x04    /* Hardware version */
-#define CAT0_VER_PARAMETER      0x06    /* Parameter version */
-#define CAT0_VER_AWB            0x08    /* Auto WB version */
-#define CAT0_VER_STRING         0x0a    /* string including M-5MOLS */
-#define CAT0_SYSMODE            0x0b    /* SYSTEM mode register */
-#define CAT0_STATUS             0x0c    /* SYSTEM mode status register */
-#define CAT0_INT_FACTOR         0x10    /* interrupt pending register */
-#define CAT0_INT_ENABLE         0x11    /* interrupt enable register */
-
-#define SYSTEM_VER_CUSTOMER     I2C_REG(CAT_SYSTEM, CAT0_VER_CUSTOMER, 1)
-#define SYSTEM_VER_PROJECT      I2C_REG(CAT_SYSTEM, CAT0_VER_PROJECT, 1)
-#define SYSTEM_VER_FIRMWARE     I2C_REG(CAT_SYSTEM, CAT0_VER_FIRMWARE, 2)
-#define SYSTEM_VER_HARDWARE     I2C_REG(CAT_SYSTEM, CAT0_VER_HARDWARE, 2)
-#define SYSTEM_VER_PARAMETER    I2C_REG(CAT_SYSTEM, CAT0_VER_PARAMETER, 2)
-#define SYSTEM_VER_AWB          I2C_REG(CAT_SYSTEM, CAT0_VER_AWB, 2)
-
-#define SYSTEM_SYSMODE          I2C_REG(CAT_SYSTEM, CAT0_SYSMODE, 1)
+#define SYSTEM_VER_CUSTOMER     I2C_REG(CAT_SYSTEM, 0x00, 1)
+#define SYSTEM_VER_PROJECT      I2C_REG(CAT_SYSTEM, 0x01, 1)
+#define SYSTEM_VER_FIRMWARE     I2C_REG(CAT_SYSTEM, 0x02, 2)
+#define SYSTEM_VER_HARDWARE     I2C_REG(CAT_SYSTEM, 0x04, 2)
+#define SYSTEM_VER_PARAMETER    I2C_REG(CAT_SYSTEM, 0x06, 2)
+#define SYSTEM_VER_AWB          I2C_REG(CAT_SYSTEM, 0x08, 2)
+
+#define SYSTEM_SYSMODE          I2C_REG(CAT_SYSTEM, 0x0b, 1)
 #define REG_SYSINIT             0x00    /* SYSTEM mode */
 #define REG_PARAMETER           0x01    /* PARAMETER mode */
 #define REG_MONITOR             0x02    /* MONITOR mode */
 #define REG_CAPTURE             0x03    /* CAPTURE mode */
 
 #define SYSTEM_CMD(__cmd)       I2C_REG(CAT_SYSTEM, cmd, 1)
-#define SYSTEM_VER_STRING       I2C_REG(CAT_SYSTEM, CAT0_VER_STRING, 1)
+#define SYSTEM_VER_STRING       I2C_REG(CAT_SYSTEM, 0x0a, 1)
 #define REG_SAMSUNG_ELECTRO     "SE"    /* Samsung Electro-Mechanics */
 #define REG_SAMSUNG_OPTICS      "OP"    /* Samsung Fiber-Optics */
 #define REG_SAMSUNG_TECHWIN     "TB"    /* Samsung Techwin */
+/* SYSTEM mode status */
+#define SYSTEM_STATUS   I2C_REG(CAT_SYSTEM, 0x0c, 1)
 
-#define SYSTEM_INT_FACTOR       I2C_REG(CAT_SYSTEM, CAT0_INT_FACTOR, 1)
-#define SYSTEM_INT_ENABLE       I2C_REG(CAT_SYSTEM, CAT0_INT_ENABLE, 1)
+/* Interrupt pending register */
+#define SYSTEM_INT_FACTOR       I2C_REG(CAT_SYSTEM, 0x10, 1)
+/* interrupt enable register */
+#define SYSTEM_INT_ENABLE       I2C_REG(CAT_SYSTEM, 0x11, 1)
 #define REG_INT_MODE            (1 << 0)
 #define REG_INT_AF              (1 << 1)
 #define REG_INT_ZOOM            (1 << 2)
@@ -105,20 +97,20 @@
  * can handle with preview(MONITOR) resolution size/frame per second/interface
  * between the sensor and the Application Processor/even the image effect.
  */
-#define CAT1_DATA_INTERFACE     0x00    /* interface between sensor and AP */
-#define CAT1_MONITOR_SIZE       0x01    /* resolution at the MONITOR mode */
-#define CAT1_MONITOR_FPS        0x02    /* frame per second at this mode */
-#define CAT1_EFFECT             0x0b    /* image effects */
 
-#define PARM_MON_SIZE           I2C_REG(CAT_PARAM, CAT1_MONITOR_SIZE, 1)
+/* Resolution in the MONITOR mode */
+#define PARM_MON_SIZE           I2C_REG(CAT_PARAM, 0x01, 1)
 
-#define PARM_MON_FPS            I2C_REG(CAT_PARAM, CAT1_MONITOR_FPS, 1)
+/* Frame rate */
+#define PARM_MON_FPS            I2C_REG(CAT_PARAM, 0x02, 1)
 #define REG_FPS_30              0x02
 
-#define PARM_INTERFACE          I2C_REG(CAT_PARAM, CAT1_DATA_INTERFACE, 1)
+/* Video bus between the sensor and a host processor */
+#define PARM_INTERFACE          I2C_REG(CAT_PARAM, 0x00, 1)
 #define REG_INTERFACE_MIPI      0x02
 
-#define PARM_EFFECT             I2C_REG(CAT_PARAM, CAT1_EFFECT, 1)
+/* Image effects */
+#define PARM_EFFECT             I2C_REG(CAT_PARAM, 0x0b, 1)
 #define REG_EFFECT_OFF          0x00
 #define REG_EFFECT_NEGA         0x01
 #define REG_EFFECT_EMBOSS       0x06
@@ -135,39 +127,37 @@
  * another options like zoom/color effect(different with effect in PARAMETER
  * mode)/anti hand shaking algorithm.
  */
-#define CAT2_ZOOM               0x01    /* set the zoom position & execute */
-#define CAT2_ZOOM_STEP          0x03    /* set the zoom step */
-#define CAT2_CFIXB              0x09    /* CB value for color effect */
-#define CAT2_CFIXR              0x0a    /* CR value for color effect */
-#define CAT2_COLOR_EFFECT       0x0b    /* set on/off of color effect */
-#define CAT2_CHROMA_LVL         0x0f    /* set chroma level */
-#define CAT2_CHROMA_EN          0x10    /* set on/off of choroma */
-#define CAT2_EDGE_LVL           0x11    /* set sharpness level */
-#define CAT2_EDGE_EN            0x12    /* set on/off sharpness */
-#define CAT2_TONE_CTL           0x25    /* set tone color(contrast) */
-
-#define MON_ZOOM                I2C_REG(CAT_MONITOR, CAT2_ZOOM, 1)
-
-#define MON_CFIXR               I2C_REG(CAT_MONITOR, CAT2_CFIXR, 1)
-#define MON_CFIXB               I2C_REG(CAT_MONITOR, CAT2_CFIXB, 1)
+
+/* Target digital zoom position */
+#define MON_ZOOM                I2C_REG(CAT_MONITOR, 0x01, 1)
+
+/* CR value for color effect */
+#define MON_CFIXR               I2C_REG(CAT_MONITOR, 0x0a, 1)
+/* CB value for color effect */
+#define MON_CFIXB               I2C_REG(CAT_MONITOR, 0x09, 1)
 #define REG_CFIXB_SEPIA         0xd8
 #define REG_CFIXR_SEPIA         0x18
 
-#define MON_EFFECT              I2C_REG(CAT_MONITOR, CAT2_COLOR_EFFECT, 1)
+#define MON_EFFECT              I2C_REG(CAT_MONITOR, 0x0b, 1)
 #define REG_COLOR_EFFECT_OFF    0x00
 #define REG_COLOR_EFFECT_ON     0x01
 
-#define MON_CHROMA_EN           I2C_REG(CAT_MONITOR, CAT2_CHROMA_EN, 1)
-#define MON_CHROMA_LVL          I2C_REG(CAT_MONITOR, CAT2_CHROMA_LVL, 1)
+/* Chroma enable */
+#define MON_CHROMA_EN           I2C_REG(CAT_MONITOR, 0x10, 1)
+/* Chroma level */
+#define MON_CHROMA_LVL          I2C_REG(CAT_MONITOR, 0x0f, 1)
 #define REG_CHROMA_OFF          0x00
 #define REG_CHROMA_ON           0x01
 
-#define MON_EDGE_EN             I2C_REG(CAT_MONITOR, CAT2_EDGE_EN, 1)
-#define MON_EDGE_LVL            I2C_REG(CAT_MONITOR, CAT2_EDGE_LVL, 1)
+/* Sharpness on/off */
+#define MON_EDGE_EN             I2C_REG(CAT_MONITOR, 0x12, 1)
+/* Sharpness level */
+#define MON_EDGE_LVL            I2C_REG(CAT_MONITOR, 0x11, 1)
 #define REG_EDGE_OFF            0x00
 #define REG_EDGE_ON             0x01
 
-#define MON_TONE_CTL            I2C_REG(CAT_MONITOR, CAT2_TONE_CTL, 1)
+/* Set color tone (contrast) */
+#define MON_TONE_CTL            I2C_REG(CAT_MONITOR, 0x25, 1)
 
 /*
  * Category 3 - Auto Exposure
@@ -179,27 +169,20 @@
  * different. So, this category also provide getting the max/min values. And,
  * each MONITOR and CAPTURE mode has each gain/shutter/max exposure values.
  */
-#define CAT3_AE_LOCK            0x00    /* locking Auto exposure */
-#define CAT3_AE_MODE            0x01    /* set AE mode, mode means range */
-#define CAT3_ISO                0x05    /* set ISO */
-#define CAT3_EV_PRESET_MONITOR  0x0a    /* EV(scenemode) preset for MONITOR */
-#define CAT3_EV_PRESET_CAPTURE  0x0b    /* EV(scenemode) preset for CAPTURE */
-#define CAT3_MANUAL_GAIN_MON    0x12    /* meteoring value for the MONITOR */
-#define CAT3_MAX_GAIN_MON       0x1a    /* max gain value for the MONITOR */
-#define CAT3_MANUAL_GAIN_CAP    0x26    /* meteoring value for the CAPTURE */
-#define CAT3_AE_INDEX           0x38    /* AE index */
-
-#define AE_LOCK                 I2C_REG(CAT_AE, CAT3_AE_LOCK, 1)
+
+/* Auto Exposure locking */
+#define AE_LOCK                 I2C_REG(CAT_AE, 0x00, 1)
 #define REG_AE_UNLOCK           0x00
 #define REG_AE_LOCK             0x01
 
-#define AE_MODE                 I2C_REG(CAT_AE, CAT3_AE_MODE, 1)
+/* Auto Exposure algorithm mode */
+#define AE_MODE                 I2C_REG(CAT_AE, 0x01, 1)
 #define REG_AE_OFF              0x00    /* AE off */
 #define REG_AE_ALL              0x01    /* calc AE in all block integral */
 #define REG_AE_CENTER           0x03    /* calc AE in center weighted */
 #define REG_AE_SPOT             0x06    /* calc AE in specific spot */
 
-#define AE_ISO                  I2C_REG(CAT_AE, CAT3_ISO, 1)
+#define AE_ISO                  I2C_REG(CAT_AE, 0x05, 1)
 #define REG_ISO_AUTO            0x00
 #define REG_ISO_50              0x01
 #define REG_ISO_100             0x02
@@ -207,8 +190,10 @@
 #define REG_ISO_400             0x04
 #define REG_ISO_800             0x05
 
-#define AE_EV_PRESET_MONITOR    I2C_REG(CAT_AE, CAT3_EV_PRESET_MONITOR, 1)
-#define AE_EV_PRESET_CAPTURE    I2C_REG(CAT_AE, CAT3_EV_PRESET_CAPTURE, 1)
+/* EV (scenemode) preset for MONITOR */
+#define AE_EV_PRESET_MONITOR    I2C_REG(CAT_AE, 0x0a, 1)
+/* EV (scenemode) preset for CAPTURE */
+#define AE_EV_PRESET_CAPTURE    I2C_REG(CAT_AE, 0x0b, 1)
 #define REG_SCENE_NORMAL        0x00
 #define REG_SCENE_PORTRAIT      0x01
 #define REG_SCENE_LANDSCAPE     0x02
@@ -224,11 +209,14 @@
 #define REG_SCENE_TEXT          0x0c
 #define REG_SCENE_CANDLE        0x0d
 
-#define AE_MAN_GAIN_MON         I2C_REG(CAT_AE, CAT3_MANUAL_GAIN_MON, 2)
-#define AE_MAX_GAIN_MON         I2C_REG(CAT_AE, CAT3_MAX_GAIN_MON, 2)
-#define AE_MAN_GAIN_CAP         I2C_REG(CAT_AE, CAT3_MANUAL_GAIN_CAP, 2)
+/* Manual gain in MONITOR mode */
+#define AE_MAN_GAIN_MON         I2C_REG(CAT_AE, 0x12, 2)
+/* Maximum gain in MONITOR mode */
+#define AE_MAX_GAIN_MON         I2C_REG(CAT_AE, 0x1a, 2)
+/* Manual gain in CAPTURE mode */
+#define AE_MAN_GAIN_CAP         I2C_REG(CAT_AE, 0x26, 2)
 
-#define AE_INDEX                I2C_REG(CAT_AE, CAT3_AE_INDEX, 1)
+#define AE_INDEX                I2C_REG(CAT_AE, 0x38, 1)
 #define REG_AE_INDEX_20_NEG     0x00
 #define REG_AE_INDEX_15_NEG     0x01
 #define REG_AE_INDEX_10_NEG     0x02
@@ -241,22 +229,19 @@
 
 /*
  * Category 6 - White Balance
- *
- * This category provide AWB locking/mode/preset/speed/gain bias, etc.
  */
-#define CAT6_AWB_LOCK           0x00    /* locking Auto Whitebalance */
-#define CAT6_AWB_MODE           0x02    /* set Auto or Manual */
-#define CAT6_AWB_MANUAL         0x03    /* set Manual(preset) value */
 
-#define AWB_LOCK                I2C_REG(CAT_WB, CAT6_AWB_LOCK, 1)
+/* Auto Whitebalance locking */
+#define AWB_LOCK                I2C_REG(CAT_WB, 0x00, 1)
 #define REG_AWB_UNLOCK          0x00
 #define REG_AWB_LOCK            0x01
 
-#define AWB_MODE                I2C_REG(CAT_WB, CAT6_AWB_MODE, 1)
+#define AWB_MODE                I2C_REG(CAT_WB, 0x02, 1)
 #define REG_AWB_AUTO            0x01    /* AWB off */
 #define REG_AWB_PRESET          0x02    /* AWB preset */
 
-#define AWB_MANUAL              I2C_REG(CAT_WB, CAT6_AWB_MANUAL, 1)
+/* Manual WB (preset) */
+#define AWB_MANUAL              I2C_REG(CAT_WB, 0x03, 1)
 #define REG_AWB_INCANDESCENT    0x01
 #define REG_AWB_FLUORESCENT_1   0x02
 #define REG_AWB_FLUORESCENT_2   0x03
@@ -269,42 +254,25 @@
 /*
  * Category 7 - EXIF information
  */
-#define CAT7_INFO_EXPTIME_NU    0x00
-#define CAT7_INFO_EXPTIME_DE    0x04
-#define CAT7_INFO_TV_NU         0x08
-#define CAT7_INFO_TV_DE         0x0c
-#define CAT7_INFO_AV_NU         0x10
-#define CAT7_INFO_AV_DE         0x14
-#define CAT7_INFO_BV_NU         0x18
-#define CAT7_INFO_BV_DE         0x1c
-#define CAT7_INFO_EBV_NU        0x20
-#define CAT7_INFO_EBV_DE        0x24
-#define CAT7_INFO_ISO           0x28
-#define CAT7_INFO_FLASH         0x2a
-#define CAT7_INFO_SDR           0x2c
-#define CAT7_INFO_QVAL          0x2e
-
-#define EXIF_INFO_EXPTIME_NU    I2C_REG(CAT_EXIF, CAT7_INFO_EXPTIME_NU, 4)
-#define EXIF_INFO_EXPTIME_DE    I2C_REG(CAT_EXIF, CAT7_INFO_EXPTIME_DE, 4)
-#define EXIF_INFO_TV_NU         I2C_REG(CAT_EXIF, CAT7_INFO_TV_NU, 4)
-#define EXIF_INFO_TV_DE         I2C_REG(CAT_EXIF, CAT7_INFO_TV_DE, 4)
-#define EXIF_INFO_AV_NU         I2C_REG(CAT_EXIF, CAT7_INFO_AV_NU, 4)
-#define EXIF_INFO_AV_DE         I2C_REG(CAT_EXIF, CAT7_INFO_AV_DE, 4)
-#define EXIF_INFO_BV_NU         I2C_REG(CAT_EXIF, CAT7_INFO_BV_NU, 4)
-#define EXIF_INFO_BV_DE         I2C_REG(CAT_EXIF, CAT7_INFO_BV_DE, 4)
-#define EXIF_INFO_EBV_NU        I2C_REG(CAT_EXIF, CAT7_INFO_EBV_NU, 4)
-#define EXIF_INFO_EBV_DE        I2C_REG(CAT_EXIF, CAT7_INFO_EBV_DE, 4)
-#define EXIF_INFO_ISO           I2C_REG(CAT_EXIF, CAT7_INFO_ISO, 2)
-#define EXIF_INFO_FLASH         I2C_REG(CAT_EXIF, CAT7_INFO_FLASH, 2)
-#define EXIF_INFO_SDR           I2C_REG(CAT_EXIF, CAT7_INFO_SDR, 2)
-#define EXIF_INFO_QVAL          I2C_REG(CAT_EXIF, CAT7_INFO_QVAL, 2)
+#define EXIF_INFO_EXPTIME_NU    I2C_REG(CAT_EXIF, 0x00, 4)
+#define EXIF_INFO_EXPTIME_DE    I2C_REG(CAT_EXIF, 0x04, 4)
+#define EXIF_INFO_TV_NU         I2C_REG(CAT_EXIF, 0x08, 4)
+#define EXIF_INFO_TV_DE         I2C_REG(CAT_EXIF, 0x0c, 4)
+#define EXIF_INFO_AV_NU         I2C_REG(CAT_EXIF, 0x10, 4)
+#define EXIF_INFO_AV_DE         I2C_REG(CAT_EXIF, 0x14, 4)
+#define EXIF_INFO_BV_NU         I2C_REG(CAT_EXIF, 0x18, 4)
+#define EXIF_INFO_BV_DE         I2C_REG(CAT_EXIF, 0x1c, 4)
+#define EXIF_INFO_EBV_NU        I2C_REG(CAT_EXIF, 0x20, 4)
+#define EXIF_INFO_EBV_DE        I2C_REG(CAT_EXIF, 0x24, 4)
+#define EXIF_INFO_ISO           I2C_REG(CAT_EXIF, 0x28, 2)
+#define EXIF_INFO_FLASH         I2C_REG(CAT_EXIF, 0x2a, 2)
+#define EXIF_INFO_SDR           I2C_REG(CAT_EXIF, 0x2c, 2)
+#define EXIF_INFO_QVAL          I2C_REG(CAT_EXIF, 0x2e, 2)
 
 /*
  * Category 9 - Face Detection
  */
-#define CAT9_FD_CTL             0x00
-
-#define FD_CTL                  I2C_REG(CAT_FD, CAT9_FD_CTL, 1)
+#define FD_CTL                  I2C_REG(CAT_FD, 0x00, 1)
 #define BIT_FD_EN               0
 #define BIT_FD_DRAW_FACE_FRAME  4
 #define BIT_FD_DRAW_SMILE_LVL   6
@@ -314,62 +282,50 @@
 /*
  * Category A - Lens Parameter
  */
-#define CATA_AF_MODE            0x01
-#define CATA_AF_EXECUTE         0x02
-#define CATA_AF_STATUS          0x03
-#define CATA_AF_VERSION         0x0a
-
-#define AF_MODE                 I2C_REG(CAT_LENS, CATA_AF_MODE, 1)
+#define AF_MODE                 I2C_REG(CAT_LENS, 0x01, 1)
 #define REG_AF_NORMAL           0x00    /* Normal AF, one time */
 #define REG_AF_MACRO            0x01    /* Macro AF, one time */
 #define REG_AF_POWEROFF         0x07
 
-#define AF_EXECUTE              I2C_REG(CAT_LENS, CATA_AF_EXECUTE, 1)
+#define AF_EXECUTE              I2C_REG(CAT_LENS, 0x02, 1)
 #define REG_AF_STOP             0x00
 #define REG_AF_EXE_AUTO         0x01
 #define REG_AF_EXE_CAF          0x02
 
-#define AF_STATUS               I2C_REG(CAT_LENS, CATA_AF_STATUS, 1)
+#define AF_STATUS               I2C_REG(CAT_LENS, 0x03, 1)
 #define REG_AF_FAIL             0x00
 #define REG_AF_SUCCESS          0x02
 #define REG_AF_IDLE             0x04
 #define REG_AF_BUSY             0x05
 
-#define AF_VERSION              I2C_REG(CAT_LENS, CATA_AF_VERSION, 1)
+#define AF_VERSION              I2C_REG(CAT_LENS, 0x0a, 1)
 
 /*
  * Category B - CAPTURE Parameter
  */
-#define CATB_YUVOUT_MAIN        0x00
-#define CATB_MAIN_IMAGE_SIZE    0x01
-#define CATB_MCC_MODE           0x1d
-#define CATB_WDR_EN             0x2c
-#define CATB_LIGHT_CTRL         0x40
-#define CATB_FLASH_CTRL         0x41
-
-#define CAPP_YUVOUT_MAIN        I2C_REG(CAT_CAPT_PARM, CATB_YUVOUT_MAIN, 1)
+#define CAPP_YUVOUT_MAIN        I2C_REG(CAT_CAPT_PARM, 0x00, 1)
 #define REG_YUV422              0x00
 #define REG_BAYER10             0x05
 #define REG_BAYER8              0x06
 #define REG_JPEG                0x10
 
-#define CAPP_MAIN_IMAGE_SIZE    I2C_REG(CAT_CAPT_PARM, CATB_MAIN_IMAGE_SIZE, 1)
+#define CAPP_MAIN_IMAGE_SIZE    I2C_REG(CAT_CAPT_PARM, 0x01, 1)
 
-#define CAPP_MCC_MODE           I2C_REG(CAT_CAPT_PARM, CATB_MCC_MODE, 1)
+#define CAPP_MCC_MODE           I2C_REG(CAT_CAPT_PARM, 0x1d, 1)
 #define REG_MCC_OFF             0x00
 #define REG_MCC_NORMAL          0x01
 
-#define CAPP_WDR_EN             I2C_REG(CAT_CAPT_PARM, CATB_WDR_EN, 1)
+#define CAPP_WDR_EN             I2C_REG(CAT_CAPT_PARM, 0x2c, 1)
 #define REG_WDR_OFF             0x00
 #define REG_WDR_ON              0x01
 #define REG_WDR_AUTO            0x02
 
-#define CAPP_LIGHT_CTRL         I2C_REG(CAT_CAPT_PARM, CATB_LIGHT_CTRL, 1)
+#define CAPP_LIGHT_CTRL         I2C_REG(CAT_CAPT_PARM, 0x40, 1)
 #define REG_LIGHT_OFF           0x00
 #define REG_LIGHT_ON            0x01
 #define REG_LIGHT_AUTO          0x02
 
-#define CAPP_FLASH_CTRL         I2C_REG(CAT_CAPT_PARM, CATB_FLASH_CTRL, 1)
+#define CAPP_FLASH_CTRL         I2C_REG(CAT_CAPT_PARM, 0x41, 1)
 #define REG_FLASH_OFF           0x00
 #define REG_FLASH_ON            0x01
 #define REG_FLASH_AUTO          0x02
@@ -377,34 +333,29 @@
 /*
  * Category C - CAPTURE Control
  */
-#define CATC_CAP_MODE           0x00
-#define CATC_CAP_SEL_FRAME      0x06    /* It determines Single or Multi */
-#define CATC_CAP_START          0x09
-#define CATC_CAP_IMAGE_SIZE     0x0d
-#define CATC_CAP_THUMB_SIZE     0x11
-
-#define CAPC_MODE               I2C_REG(CAT_CAPT_CTRL, CATC_CAP_MODE, 1)
+#define CAPC_MODE               I2C_REG(CAT_CAPT_CTRL, 0x00, 1)
 #define REG_CAP_NONE            0x00
 #define REG_CAP_ANTI_SHAKE      0x02
 
-#define CAPC_SEL_FRAME          I2C_REG(CAT_CAPT_CTRL, CATC_CAP_SEL_FRAME, 1)
+/* Select single- or multi-shot capture */
+#define CAPC_SEL_FRAME          I2C_REG(CAT_CAPT_CTRL, 0x06, 1)
 
-#define CAPC_START              I2C_REG(CAT_CAPT_CTRL, CATC_CAP_START, 1)
+#define CAPC_START              I2C_REG(CAT_CAPT_CTRL, 0x09, 1)
 #define REG_CAP_START_MAIN      0x01
 #define REG_CAP_START_THUMB     0x03
 
-#define CAPC_IMAGE_SIZE         I2C_REG(CAT_CAPT_CTRL, CATC_CAP_IMAGE_SIZE, 4)
-#define CAPC_THUMB_SIZE         I2C_REG(CAT_CAPT_CTRL, CATC_CAP_THUMB_SIZE, 4)
+#define CAPC_IMAGE_SIZE         I2C_REG(CAT_CAPT_CTRL, 0x0d, 4)
+#define CAPC_THUMB_SIZE         I2C_REG(CAT_CAPT_CTRL, 0x11, 4)
 
 /*
  * Category F - Flash
  *
  * This mode provides functions about internal flash stuff and system startup.
  */
-#define CATF_CAM_START          0x12    /* It starts internal ARM core booting
-                                         * after power-up */
 
-#define FLASH_CAM_START         I2C_REG(CAT_FLASH, CATF_CAM_START, 1)
-#define REG_START_ARM_BOOT      0x01
+/* Starts internal ARM core booting after power-up */
+#define FLASH_CAM_START         I2C_REG(CAT_FLASH, 0x12, 1)
+#define REG_START_ARM_BOOT      0x01    /* write value */
+#define REG_IN_FLASH_MODE       0x00    /* read value */
 
 #endif  /* M5MOLS_REG_H */
diff --git a/drivers/media/video/marvell-ccic/mcam-core.c b/drivers/media/video/marvell-ccic/mcam-core.c
index 2c8fc0f6d690..37d20e73908a 100644
--- a/drivers/media/video/marvell-ccic/mcam-core.c
+++ b/drivers/media/video/marvell-ccic/mcam-core.c
@@ -522,6 +522,15 @@ static void mcam_sg_next_buffer(struct mcam_camera *cam)
  */
 static void mcam_ctlr_dma_sg(struct mcam_camera *cam)
 {
+        /*
+         * The list-empty condition can hit us at resume time
+         * if the buffer list was empty when the system was suspended.
+         */
+        if (list_empty(&cam->buffers)) {
+                set_bit(CF_SG_RESTART, &cam->flags);
+                return;
+        }
+
         mcam_reg_clear_bit(cam, REG_CTRL1, C1_DESC_3WORD);
         mcam_sg_next_buffer(cam);
         mcam_reg_set_bit(cam, REG_CTRL1, C1_DESC_ENA);
@@ -566,6 +575,7 @@ static void mcam_dma_sg_done(struct mcam_camera *cam, int frame)
         } else {
                 set_bit(CF_SG_RESTART, &cam->flags);
                 singles++;
+                cam->vb_bufs[0] = NULL;
         }
         /*
          * Now we can give the completed frame back to user space.
@@ -661,10 +671,10 @@ static int mcam_ctlr_configure(struct mcam_camera *cam)
         unsigned long flags;
 
         spin_lock_irqsave(&cam->dev_lock, flags);
+        clear_bit(CF_SG_RESTART, &cam->flags);
         cam->dma_setup(cam);
         mcam_ctlr_image(cam);
         mcam_set_config_needed(cam, 0);
-        clear_bit(CF_SG_RESTART, &cam->flags);
         spin_unlock_irqrestore(&cam->dev_lock, flags);
         return 0;
 }
@@ -873,7 +883,8 @@ static int mcam_read_setup(struct mcam_camera *cam)
         mcam_reset_buffers(cam);
         mcam_ctlr_irq_enable(cam);
         cam->state = S_STREAMING;
-        mcam_ctlr_start(cam);
+        if (!test_bit(CF_SG_RESTART, &cam->flags))
+                mcam_ctlr_start(cam);
         spin_unlock_irqrestore(&cam->dev_lock, flags);
         return 0;
 }
@@ -1818,11 +1829,15 @@ void mccic_shutdown(struct mcam_camera *cam)
 
 void mccic_suspend(struct mcam_camera *cam)
 {
-        enum mcam_state cstate = cam->state;
+        mutex_lock(&cam->s_mutex);
+        if (cam->users > 0) {
+                enum mcam_state cstate = cam->state;
 
-        mcam_ctlr_stop_dma(cam);
-        mcam_ctlr_power_down(cam);
-        cam->state = cstate;
+                mcam_ctlr_stop_dma(cam);
+                mcam_ctlr_power_down(cam);
+                cam->state = cstate;
+        }
+        mutex_unlock(&cam->s_mutex);
 }
 
 int mccic_resume(struct mcam_camera *cam)
@@ -1839,8 +1854,15 @@ int mccic_resume(struct mcam_camera *cam)
         mutex_unlock(&cam->s_mutex);
 
         set_bit(CF_CONFIG_NEEDED, &cam->flags);
-        if (cam->state == S_STREAMING)
+        if (cam->state == S_STREAMING) {
+                /*
+                 * If there was a buffer in the DMA engine at suspend
+                 * time, put it back on the queue or we'll forget about it.
+                 */
+                if (cam->buffer_mode == B_DMA_sg && cam->vb_bufs[0])
+                        list_add(&cam->vb_bufs[0]->queue, &cam->buffers);
                 ret = mcam_read_setup(cam);
+        }
         return ret;
 }
 #endif /* CONFIG_PM */
diff --git a/drivers/media/video/marvell-ccic/mmp-driver.c b/drivers/media/video/marvell-ccic/mmp-driver.c
index fb0b124b35f3..0d64e2d7474a 100644
--- a/drivers/media/video/marvell-ccic/mmp-driver.c
+++ b/drivers/media/video/marvell-ccic/mmp-driver.c
@@ -26,6 +26,7 @@
 #include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/list.h>
+#include <linux/pm.h>
 
 #include "mcam-core.h"
 
@@ -310,10 +311,44 @@ static int mmpcam_platform_remove(struct platform_device *pdev)
         return mmpcam_remove(cam);
 }
 
+/*
+ * Suspend/resume support.
+ */
+#ifdef CONFIG_PM
+
+static int mmpcam_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct mmp_camera *cam = mmpcam_find_device(pdev);
+
+        if (state.event != PM_EVENT_SUSPEND)
+                return 0;
+        mccic_suspend(&cam->mcam);
+        return 0;
+}
+
+static int mmpcam_resume(struct platform_device *pdev)
+{
+        struct mmp_camera *cam = mmpcam_find_device(pdev);
+
+        /*
+         * Power up unconditionally just in case the core tries to
+         * touch a register even if nothing was active before; trust
+         * me, it's better this way.
+         */
+        mmpcam_power_up(&cam->mcam);
+        return mccic_resume(&cam->mcam);
+}
+
+#endif
+
 
 static struct platform_driver mmpcam_driver = {
         .probe          = mmpcam_probe,
         .remove         = mmpcam_platform_remove,
+#ifdef CONFIG_PM
+        .suspend        = mmpcam_suspend,
+        .resume         = mmpcam_resume,
+#endif
         .driver = {
                 .name   = "mmp-camera",
                 .owner  = THIS_MODULE
diff --git a/drivers/media/video/mt9m001.c b/drivers/media/video/mt9m001.c
index e2b1029b16cd..097c9d3d04a8 100644
--- a/drivers/media/video/mt9m001.c
+++ b/drivers/media/video/mt9m001.c
@@ -109,14 +109,13 @@ static struct mt9m001 *to_mt9m001(const struct i2c_client *client)
 
 static int reg_read(struct i2c_client *client, const u8 reg)
 {
-        s32 data = i2c_smbus_read_word_data(client, reg);
-        return data < 0 ? data : swab16(data);
+        return i2c_smbus_read_word_swapped(client, reg);
 }
 
 static int reg_write(struct i2c_client *client, const u8 reg,
                      const u16 data)
 {
-        return i2c_smbus_write_word_data(client, reg, swab16(data));
+        return i2c_smbus_write_word_swapped(client, reg, data);
 }
 
 static int reg_set(struct i2c_client *client, const u8 reg,
diff --git a/drivers/media/video/mt9m111.c b/drivers/media/video/mt9m111.c
index 398f96ffd35e..bee65bff46e8 100644
--- a/drivers/media/video/mt9m111.c
+++ b/drivers/media/video/mt9m111.c
@@ -139,25 +139,52 @@
 #define MT9M111_MAX_HEIGHT      1024
 #define MT9M111_MAX_WIDTH       1280
 
+struct mt9m111_context {
+        u16 read_mode;
+        u16 blanking_h;
+        u16 blanking_v;
+        u16 reducer_xzoom;
+        u16 reducer_yzoom;
+        u16 reducer_xsize;
+        u16 reducer_ysize;
+        u16 output_fmt_ctrl2;
+        u16 control;
+};
+
+static struct mt9m111_context context_a = {
+        .read_mode              = MT9M111_READ_MODE_A,
+        .blanking_h             = MT9M111_HORIZONTAL_BLANKING_A,
+        .blanking_v             = MT9M111_VERTICAL_BLANKING_A,
+        .reducer_xzoom          = MT9M111_REDUCER_XZOOM_A,
+        .reducer_yzoom          = MT9M111_REDUCER_YZOOM_A,
+        .reducer_xsize          = MT9M111_REDUCER_XSIZE_A,
+        .reducer_ysize          = MT9M111_REDUCER_YSIZE_A,
+        .output_fmt_ctrl2       = MT9M111_OUTPUT_FORMAT_CTRL2_A,
+        .control                = MT9M111_CTXT_CTRL_RESTART,
+};
+
+static struct mt9m111_context context_b = {
+        .read_mode              = MT9M111_READ_MODE_B,
+        .blanking_h             = MT9M111_HORIZONTAL_BLANKING_B,
+        .blanking_v             = MT9M111_VERTICAL_BLANKING_B,
+        .reducer_xzoom          = MT9M111_REDUCER_XZOOM_B,
+        .reducer_yzoom          = MT9M111_REDUCER_YZOOM_B,
+        .reducer_xsize          = MT9M111_REDUCER_XSIZE_B,
+        .reducer_ysize          = MT9M111_REDUCER_YSIZE_B,
+        .output_fmt_ctrl2       = MT9M111_OUTPUT_FORMAT_CTRL2_B,
+        .control                = MT9M111_CTXT_CTRL_RESTART |
+                MT9M111_CTXT_CTRL_DEFECTCOR_B | MT9M111_CTXT_CTRL_RESIZE_B |
+                MT9M111_CTXT_CTRL_CTRL2_B | MT9M111_CTXT_CTRL_GAMMA_B |
+                MT9M111_CTXT_CTRL_READ_MODE_B | MT9M111_CTXT_CTRL_VBLANK_SEL_B |
+                MT9M111_CTXT_CTRL_HBLANK_SEL_B,
+};
+
 /* MT9M111 has only one fixed colorspace per pixelcode */
 struct mt9m111_datafmt {
         enum v4l2_mbus_pixelcode        code;
         enum v4l2_colorspace            colorspace;
 };
 
-/* Find a data format by a pixel code in an array */
-static const struct mt9m111_datafmt *mt9m111_find_datafmt(
-        enum v4l2_mbus_pixelcode code, const struct mt9m111_datafmt *fmt,
-        int n)
-{
-        int i;
-        for (i = 0; i < n; i++)
-                if (fmt[i].code == code)
-                        return fmt + i;
-
-        return NULL;
-}
-
 static const struct mt9m111_datafmt mt9m111_colour_fmts[] = {
         {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},
         {V4L2_MBUS_FMT_YVYU8_2X8, V4L2_COLORSPACE_JPEG},
@@ -173,27 +200,35 @@ static const struct mt9m111_datafmt mt9m111_colour_fmts[] = {
         {V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE, V4L2_COLORSPACE_SRGB},
 };
 
-enum mt9m111_context {
-        HIGHPOWER = 0,
-        LOWPOWER,
-};
-
 struct mt9m111 {
         struct v4l2_subdev subdev;
         struct v4l2_ctrl_handler hdl;
         struct v4l2_ctrl *gain;
         int model;      /* V4L2_IDENT_MT9M111 or V4L2_IDENT_MT9M112 code
                          * from v4l2-chip-ident.h */
-        enum mt9m111_context context;
-        struct v4l2_rect rect;
+        struct mt9m111_context *ctx;
+        struct v4l2_rect rect;  /* cropping rectangle */
+        int width;              /* output */
+        int height;             /* sizes */
         struct mutex power_lock; /* lock to protect power_count */
         int power_count;
         const struct mt9m111_datafmt *fmt;
         int lastpage;   /* PageMap cache value */
         unsigned char datawidth;
-        unsigned int powered:1;
 };
 
+/* Find a data format by a pixel code */
+static const struct mt9m111_datafmt *mt9m111_find_datafmt(struct mt9m111 *mt9m111,
+                                                enum v4l2_mbus_pixelcode code)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(mt9m111_colour_fmts); i++)
+                if (mt9m111_colour_fmts[i].code == code)
+                        return mt9m111_colour_fmts + i;
+
+        return mt9m111->fmt;
+}
+
 static struct mt9m111 *to_mt9m111(const struct i2c_client *client)
 {
         return container_of(i2c_get_clientdata(client), struct mt9m111, subdev);
@@ -211,7 +246,7 @@ static int reg_page_map_set(struct i2c_client *client, const u16 reg)
         if (page > 2)
                 return -EINVAL;
 
-        ret = i2c_smbus_write_word_data(client, MT9M111_PAGE_MAP, swab16(page));
+        ret = i2c_smbus_write_word_swapped(client, MT9M111_PAGE_MAP, page);
         if (!ret)
                 mt9m111->lastpage = page;
         return ret;
@@ -223,7 +258,7 @@ static int mt9m111_reg_read(struct i2c_client *client, const u16 reg)
 
         ret = reg_page_map_set(client, reg);
         if (!ret)
-                ret = swab16(i2c_smbus_read_word_data(client, reg & 0xff));
+                ret = i2c_smbus_read_word_swapped(client, reg & 0xff);
 
         dev_dbg(&client->dev, "read  reg.%03x -> %04x\n", reg, ret);
         return ret;
@@ -236,8 +271,7 @@ static int mt9m111_reg_write(struct i2c_client *client, const u16 reg,
 
         ret = reg_page_map_set(client, reg);
         if (!ret)
-                ret = i2c_smbus_write_word_data(client, reg & 0xff,
-                                                swab16(data));
+                ret = i2c_smbus_write_word_swapped(client, reg & 0xff, data);
         dev_dbg(&client->dev, "write reg.%03x = %04x -> %d\n", reg, data, ret);
         return ret;
 }
@@ -276,76 +310,63 @@ static int mt9m111_reg_mask(struct i2c_client *client, const u16 reg,
 }
 
 static int mt9m111_set_context(struct mt9m111 *mt9m111,
-                               enum mt9m111_context ctxt)
+                               struct mt9m111_context *ctx)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-        int valB = MT9M111_CTXT_CTRL_RESTART | MT9M111_CTXT_CTRL_DEFECTCOR_B
-                | MT9M111_CTXT_CTRL_RESIZE_B | MT9M111_CTXT_CTRL_CTRL2_B
-                | MT9M111_CTXT_CTRL_GAMMA_B | MT9M111_CTXT_CTRL_READ_MODE_B
-                | MT9M111_CTXT_CTRL_VBLANK_SEL_B
-                | MT9M111_CTXT_CTRL_HBLANK_SEL_B;
-        int valA = MT9M111_CTXT_CTRL_RESTART;
-
-        if (ctxt == HIGHPOWER)
-                return reg_write(CONTEXT_CONTROL, valB);
-        else
-                return reg_write(CONTEXT_CONTROL, valA);
+        return reg_write(CONTEXT_CONTROL, ctx->control);
 }
 
-static int mt9m111_setup_rect(struct mt9m111 *mt9m111,
-                              struct v4l2_rect *rect)
+static int mt9m111_setup_rect_ctx(struct mt9m111 *mt9m111,
+                        struct mt9m111_context *ctx, struct v4l2_rect *rect,
+                        unsigned int width, unsigned int height)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-        int ret, is_raw_format;
-        int width = rect->width;
-        int height = rect->height;
+        int ret = mt9m111_reg_write(client, ctx->reducer_xzoom, rect->width);
+        if (!ret)
+                ret = mt9m111_reg_write(client, ctx->reducer_yzoom, rect->height);
+        if (!ret)
+                ret = mt9m111_reg_write(client, ctx->reducer_xsize, width);
+        if (!ret)
+                ret = mt9m111_reg_write(client, ctx->reducer_ysize, height);
+        return ret;
+}
 
-        if (mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
-            mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE)
-                is_raw_format = 1;
-        else
-                is_raw_format = 0;
+static int mt9m111_setup_geometry(struct mt9m111 *mt9m111, struct v4l2_rect *rect,
+                        int width, int height, enum v4l2_mbus_pixelcode code)
+{
+        struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+        int ret;
 
         ret = reg_write(COLUMN_START, rect->left);
         if (!ret)
                 ret = reg_write(ROW_START, rect->top);
 
-        if (is_raw_format) {
-                if (!ret)
-                        ret = reg_write(WINDOW_WIDTH, width);
-                if (!ret)
-                        ret = reg_write(WINDOW_HEIGHT, height);
-        } else {
-                if (!ret)
-                        ret = reg_write(REDUCER_XZOOM_B, MT9M111_MAX_WIDTH);
-                if (!ret)
-                        ret = reg_write(REDUCER_YZOOM_B, MT9M111_MAX_HEIGHT);
-                if (!ret)
-                        ret = reg_write(REDUCER_XSIZE_B, width);
-                if (!ret)
-                        ret = reg_write(REDUCER_YSIZE_B, height);
-                if (!ret)
-                        ret = reg_write(REDUCER_XZOOM_A, MT9M111_MAX_WIDTH);
-                if (!ret)
-                        ret = reg_write(REDUCER_YZOOM_A, MT9M111_MAX_HEIGHT);
+        if (!ret)
+                ret = reg_write(WINDOW_WIDTH, rect->width);
+        if (!ret)
+                ret = reg_write(WINDOW_HEIGHT, rect->height);
+
+        if (code != V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
+                /* IFP in use, down-scaling possible */
                 if (!ret)
-                        ret = reg_write(REDUCER_XSIZE_A, width);
+                        ret = mt9m111_setup_rect_ctx(mt9m111, &context_b,
+                                                     rect, width, height);
                 if (!ret)
-                        ret = reg_write(REDUCER_YSIZE_A, height);
+                        ret = mt9m111_setup_rect_ctx(mt9m111, &context_a,
+                                                     rect, width, height);
         }
 
+        dev_dbg(&client->dev, "%s(%x): %ux%u@%u:%u -> %ux%u = %d\n",
+                __func__, code, rect->width, rect->height, rect->left, rect->top,
+                width, height, ret);
+
         return ret;
 }
 
 static int mt9m111_enable(struct mt9m111 *mt9m111)
 {
         struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
-        int ret;
-
-        ret = reg_set(RESET, MT9M111_RESET_CHIP_ENABLE);
-        if (!ret)
-                mt9m111->powered = 1;
-        return ret;
+        return reg_write(RESET, MT9M111_RESET_CHIP_ENABLE);
 }
 
 static int mt9m111_reset(struct mt9m111 *mt9m111)
@@ -363,43 +384,41 @@ static int mt9m111_reset(struct mt9m111 *mt9m111)
         return ret;
 }
 
-static int mt9m111_make_rect(struct mt9m111 *mt9m111,
-                             struct v4l2_rect *rect)
+static int mt9m111_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
 {
+        struct v4l2_rect rect = a->c;
+        struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+        int width, height;
+        int ret;
+
+        if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
         if (mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
             mt9m111->fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
                 /* Bayer format - even size lengths */
-                rect->width     = ALIGN(rect->width, 2);
-                rect->height    = ALIGN(rect->height, 2);
+                rect.width      = ALIGN(rect.width, 2);
+                rect.height     = ALIGN(rect.height, 2);
                 /* Let the user play with the starting pixel */
         }
 
         /* FIXME: the datasheet doesn't specify minimum sizes */
-        soc_camera_limit_side(&rect->left, &rect->width,
+        soc_camera_limit_side(&rect.left, &rect.width,
                      MT9M111_MIN_DARK_COLS, 2, MT9M111_MAX_WIDTH);
 
-        soc_camera_limit_side(&rect->top, &rect->height,
+        soc_camera_limit_side(&rect.top, &rect.height,
                      MT9M111_MIN_DARK_ROWS, 2, MT9M111_MAX_HEIGHT);
 
-        return mt9m111_setup_rect(mt9m111, rect);
-}
-
-static int mt9m111_s_crop(struct v4l2_subdev *sd, struct v4l2_crop *a)
-{
-        struct v4l2_rect rect = a->c;
-        struct i2c_client *client = v4l2_get_subdevdata(sd);
-        struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-        int ret;
-
-        dev_dbg(&client->dev, "%s left=%d, top=%d, width=%d, height=%d\n",
-                __func__, rect.left, rect.top, rect.width, rect.height);
+        width = min(mt9m111->width, rect.width);
+        height = min(mt9m111->height, rect.height);
 
-        if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return -EINVAL;
-
-        ret = mt9m111_make_rect(mt9m111, &rect);
-        if (!ret)
+        ret = mt9m111_setup_geometry(mt9m111, &rect, width, height, mt9m111->fmt->code);
+        if (!ret) {
                 mt9m111->rect = rect;
+                mt9m111->width = width;
+                mt9m111->height = height;
+        }
+
         return ret;
 }
 
@@ -434,8 +453,8 @@ static int mt9m111_g_fmt(struct v4l2_subdev *sd,
 {
         struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
 
-        mf->width       = mt9m111->rect.width;
-        mf->height      = mt9m111->rect.height;
+        mf->width       = mt9m111->width;
+        mf->height      = mt9m111->height;
         mf->code        = mt9m111->fmt->code;
         mf->colorspace  = mt9m111->fmt->colorspace;
         mf->field       = V4L2_FIELD_NONE;
@@ -504,46 +523,11 @@ static int mt9m111_set_pixfmt(struct mt9m111 *mt9m111,
                 return -EINVAL;
         }
 
-        ret = reg_mask(OUTPUT_FORMAT_CTRL2_A, data_outfmt2,
-                       mask_outfmt2);
+        ret = mt9m111_reg_mask(client, context_a.output_fmt_ctrl2,
+                               data_outfmt2, mask_outfmt2);
         if (!ret)
-                ret = reg_mask(OUTPUT_FORMAT_CTRL2_B, data_outfmt2,
-                               mask_outfmt2);
-
-        return ret;
-}
-
-static int mt9m111_s_fmt(struct v4l2_subdev *sd,
-                         struct v4l2_mbus_framefmt *mf)
-{
-        struct i2c_client *client = v4l2_get_subdevdata(sd);
-        const struct mt9m111_datafmt *fmt;
-        struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
-        struct v4l2_rect rect = {
-                .left   = mt9m111->rect.left,
-                .top    = mt9m111->rect.top,
-                .width  = mf->width,
-                .height = mf->height,
-        };
-        int ret;
-
-        fmt = mt9m111_find_datafmt(mf->code, mt9m111_colour_fmts,
-                                   ARRAY_SIZE(mt9m111_colour_fmts));
-        if (!fmt)
-                return -EINVAL;
-
-        dev_dbg(&client->dev,
-                "%s code=%x left=%d, top=%d, width=%d, height=%d\n", __func__,
-                mf->code, rect.left, rect.top, rect.width, rect.height);
-
-        ret = mt9m111_make_rect(mt9m111, &rect);
-        if (!ret)
-                ret = mt9m111_set_pixfmt(mt9m111, mf->code);
-        if (!ret) {
-                mt9m111->rect   = rect;
-                mt9m111->fmt    = fmt;
-                mf->colorspace  = fmt->colorspace;
-        }
+                ret = mt9m111_reg_mask(client, context_b.output_fmt_ctrl2,
+                                       data_outfmt2, mask_outfmt2);
 
         return ret;
 }
@@ -551,42 +535,71 @@ static int mt9m111_s_fmt(struct v4l2_subdev *sd,
 static int mt9m111_try_fmt(struct v4l2_subdev *sd,
                            struct v4l2_mbus_framefmt *mf)
 {
+        struct i2c_client *client = v4l2_get_subdevdata(sd);
         struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
         const struct mt9m111_datafmt *fmt;
-        bool bayer = mf->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
-                mf->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE;
-
-        fmt = mt9m111_find_datafmt(mf->code, mt9m111_colour_fmts,
-                                   ARRAY_SIZE(mt9m111_colour_fmts));
-        if (!fmt) {
-                fmt = mt9m111->fmt;
-                mf->code = fmt->code;
-        }
+        struct v4l2_rect *rect = &mt9m111->rect;
+        bool bayer;
+
+        fmt = mt9m111_find_datafmt(mt9m111, mf->code);
+
+        bayer = fmt->code == V4L2_MBUS_FMT_SBGGR8_1X8 ||
+                fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE;
 
         /*
          * With Bayer format enforce even side lengths, but let the user play
          * with the starting pixel
          */
+        if (bayer) {
+                rect->width = ALIGN(rect->width, 2);
+                rect->height = ALIGN(rect->height, 2);
+        }
 
-        if (mf->height > MT9M111_MAX_HEIGHT)
-                mf->height = MT9M111_MAX_HEIGHT;
-        else if (mf->height < 2)
-                mf->height = 2;
-        else if (bayer)
-                mf->height = ALIGN(mf->height, 2);
+        if (fmt->code == V4L2_MBUS_FMT_SBGGR10_2X8_PADHI_LE) {
+                /* IFP bypass mode, no scaling */
+                mf->width = rect->width;
+                mf->height = rect->height;
+        } else {
+                /* No upscaling */
+                if (mf->width > rect->width)
+                        mf->width = rect->width;
+                if (mf->height > rect->height)
+                        mf->height = rect->height;
+        }
 
-        if (mf->width > MT9M111_MAX_WIDTH)
-                mf->width = MT9M111_MAX_WIDTH;
-        else if (mf->width < 2)
-                mf->width = 2;
-        else if (bayer)
-                mf->width = ALIGN(mf->width, 2);
+        dev_dbg(&client->dev, "%s(): %ux%u, code=%x\n", __func__,
+                mf->width, mf->height, fmt->code);
 
+        mf->code = fmt->code;
         mf->colorspace = fmt->colorspace;
 
         return 0;
 }
 
+static int mt9m111_s_fmt(struct v4l2_subdev *sd,
+                         struct v4l2_mbus_framefmt *mf)
+{
+        const struct mt9m111_datafmt *fmt;
+        struct mt9m111 *mt9m111 = container_of(sd, struct mt9m111, subdev);
+        struct v4l2_rect *rect = &mt9m111->rect;
+        int ret;
+
+        mt9m111_try_fmt(sd, mf);
+        fmt = mt9m111_find_datafmt(mt9m111, mf->code);
+        /* try_fmt() guarantees fmt != NULL && fmt->code == mf->code */
+
+        ret = mt9m111_setup_geometry(mt9m111, rect, mf->width, mf->height, mf->code);
+        if (!ret)
+                ret = mt9m111_set_pixfmt(mt9m111, mf->code);
+        if (!ret) {
+                mt9m111->width  = mf->width;
+                mt9m111->height = mf->height;
+                mt9m111->fmt    = fmt;
+        }
+
+        return ret;
+}
+
 static int mt9m111_g_chip_ident(struct v4l2_subdev *sd,
                                 struct v4l2_dbg_chip_ident *id)
 {
@@ -650,17 +663,10 @@ static int mt9m111_set_flip(struct mt9m111 *mt9m111, int flip, int mask)
         struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
         int ret;
 
-        if (mt9m111->context == HIGHPOWER) {
-                if (flip)
-                        ret = reg_set(READ_MODE_B, mask);
-                else
-                        ret = reg_clear(READ_MODE_B, mask);
-        } else {
-                if (flip)
-                        ret = reg_set(READ_MODE_A, mask);
-                else
-                        ret = reg_clear(READ_MODE_A, mask);
-        }
+        if (flip)
+                ret = mt9m111_reg_set(client, mt9m111->ctx->read_mode, mask);
+        else
+                ret = mt9m111_reg_clear(client, mt9m111->ctx->read_mode, mask);
 
         return ret;
 }
@@ -738,30 +744,39 @@ static int mt9m111_s_ctrl(struct v4l2_ctrl *ctrl)
 
 static int mt9m111_suspend(struct mt9m111 *mt9m111)
 {
+        struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
+        int ret;
+
         v4l2_ctrl_s_ctrl(mt9m111->gain, mt9m111_get_global_gain(mt9m111));
 
-        return 0;
+        ret = reg_set(RESET, MT9M111_RESET_RESET_MODE);
+        if (!ret)
+                ret = reg_set(RESET, MT9M111_RESET_RESET_SOC |
+                              MT9M111_RESET_OUTPUT_DISABLE |
+                              MT9M111_RESET_ANALOG_STANDBY);
+        if (!ret)
+                ret = reg_clear(RESET, MT9M111_RESET_CHIP_ENABLE);
+
+        return ret;
 }
 
 static void mt9m111_restore_state(struct mt9m111 *mt9m111)
 {
-        mt9m111_set_context(mt9m111, mt9m111->context);
+        mt9m111_set_context(mt9m111, mt9m111->ctx);
         mt9m111_set_pixfmt(mt9m111, mt9m111->fmt->code);
-        mt9m111_setup_rect(mt9m111, &mt9m111->rect);
+        mt9m111_setup_geometry(mt9m111, &mt9m111->rect,
+                        mt9m111->width, mt9m111->height, mt9m111->fmt->code);
         v4l2_ctrl_handler_setup(&mt9m111->hdl);
 }
 
 static int mt9m111_resume(struct mt9m111 *mt9m111)
 {
-        int ret = 0;
+        int ret = mt9m111_enable(mt9m111);
+        if (!ret)
+                ret = mt9m111_reset(mt9m111);
+        if (!ret)
+                mt9m111_restore_state(mt9m111);
 
-        if (mt9m111->powered) {
-                ret = mt9m111_enable(mt9m111);
-                if (!ret)
-                        ret = mt9m111_reset(mt9m111);
-                if (!ret)
-                        mt9m111_restore_state(mt9m111);
-        }
         return ret;
 }
 
@@ -770,12 +785,13 @@ static int mt9m111_init(struct mt9m111 *mt9m111)
         struct i2c_client *client = v4l2_get_subdevdata(&mt9m111->subdev);
         int ret;
 
-        mt9m111->context = HIGHPOWER;
+        /* Default HIGHPOWER context */
+        mt9m111->ctx = &context_b;
         ret = mt9m111_enable(mt9m111);
         if (!ret)
                 ret = mt9m111_reset(mt9m111);
         if (!ret)
-                ret = mt9m111_set_context(mt9m111, mt9m111->context);
+                ret = mt9m111_set_context(mt9m111, mt9m111->ctx);
         if (ret)
                 dev_err(&client->dev, "mt9m111 init failed: %d\n", ret);
         return ret;
diff --git a/drivers/media/video/mt9p031.c b/drivers/media/video/mt9p031.c
index 73c068993f05..93c3ec7426e8 100644
--- a/drivers/media/video/mt9p031.c
+++ b/drivers/media/video/mt9p031.c
@@ -132,13 +132,12 @@ static struct mt9p031 *to_mt9p031(struct v4l2_subdev *sd)
 
 static int mt9p031_read(struct i2c_client *client, u8 reg)
 {
-        s32 data = i2c_smbus_read_word_data(client, reg);
-        return data < 0 ? data : be16_to_cpu(data);
+        return i2c_smbus_read_word_swapped(client, reg);
 }
 
 static int mt9p031_write(struct i2c_client *client, u8 reg, u16 data)
 {
-        return i2c_smbus_write_word_data(client, reg, cpu_to_be16(data));
+        return i2c_smbus_write_word_swapped(client, reg, data);
 }
 
 static int mt9p031_set_output_control(struct mt9p031 *mt9p031, u16 clear,
diff --git a/drivers/media/video/mt9t001.c b/drivers/media/video/mt9t001.c
index 08074b8a2736..cd81d04a529e 100644
--- a/drivers/media/video/mt9t001.c
+++ b/drivers/media/video/mt9t001.c
@@ -133,13 +133,12 @@ static inline struct mt9t001 *to_mt9t001(struct v4l2_subdev *sd)
 
 static int mt9t001_read(struct i2c_client *client, u8 reg)
 {
-        s32 data = i2c_smbus_read_word_data(client, reg);
-        return data < 0 ? data : be16_to_cpu(data);
+        return i2c_smbus_read_word_swapped(client, reg);
 }
 
 static int mt9t001_write(struct i2c_client *client, u8 reg, u16 data)
 {
-        return i2c_smbus_write_word_data(client, reg, cpu_to_be16(data));
+        return i2c_smbus_write_word_swapped(client, reg, data);
 }
 
 static int mt9t001_set_output_control(struct mt9t001 *mt9t001, u16 clear,
diff --git a/drivers/media/video/mt9t031.c b/drivers/media/video/mt9t031.c
index 0e78477452ff..84add1aef139 100644
--- a/drivers/media/video/mt9t031.c
+++ b/drivers/media/video/mt9t031.c
@@ -90,14 +90,13 @@ static struct mt9t031 *to_mt9t031(const struct i2c_client *client)
 
 static int reg_read(struct i2c_client *client, const u8 reg)
 {
-        s32 data = i2c_smbus_read_word_data(client, reg);
-        return data < 0 ? data : swab16(data);
+        return i2c_smbus_read_word_swapped(client, reg);
 }
 
 static int reg_write(struct i2c_client *client, const u8 reg,
                      const u16 data)
 {
-        return i2c_smbus_write_word_data(client, reg, swab16(data));
+        return i2c_smbus_write_word_swapped(client, reg, data);
 }
 
 static int reg_set(struct i2c_client *client, const u8 reg,
diff --git a/drivers/media/video/mt9v022.c b/drivers/media/video/mt9v022.c
index 690ee0d42eeb..944940758fa3 100644
--- a/drivers/media/video/mt9v022.c
+++ b/drivers/media/video/mt9v022.c
@@ -130,14 +130,13 @@ static struct mt9v022 *to_mt9v022(const struct i2c_client *client)
 
 static int reg_read(struct i2c_client *client, const u8 reg)
 {
-        s32 data = i2c_smbus_read_word_data(client, reg);
-        return data < 0 ? data : swab16(data);
+        return i2c_smbus_read_word_swapped(client, reg);
 }
 
 static int reg_write(struct i2c_client *client, const u8 reg,
                      const u16 data)
 {
-        return i2c_smbus_write_word_data(client, reg, swab16(data));
+        return i2c_smbus_write_word_swapped(client, reg, data);
 }
 
 static int reg_set(struct i2c_client *client, const u8 reg,
diff --git a/drivers/media/video/mt9v032.c b/drivers/media/video/mt9v032.c
index f080c162123f..d90b982cc218 100644
--- a/drivers/media/video/mt9v032.c
+++ b/drivers/media/video/mt9v032.c
@@ -139,10 +139,10 @@ static struct mt9v032 *to_mt9v032(struct v4l2_subdev *sd)
 
 static int mt9v032_read(struct i2c_client *client, const u8 reg)
 {
-        s32 data = i2c_smbus_read_word_data(client, reg);
+        s32 data = i2c_smbus_read_word_swapped(client, reg);
         dev_dbg(&client->dev, "%s: read 0x%04x from 0x%02x\n", __func__,
-                swab16(data), reg);
-        return data < 0 ? data : swab16(data);
+                data, reg);
+        return data;
 }
 
 static int mt9v032_write(struct i2c_client *client, const u8 reg,
@@ -150,7 +150,7 @@ static int mt9v032_write(struct i2c_client *client, const u8 reg,
 {
         dev_dbg(&client->dev, "%s: writing 0x%04x to 0x%02x\n", __func__,
                 data, reg);
-        return i2c_smbus_write_word_data(client, reg, swab16(data));
+        return i2c_smbus_write_word_swapped(client, reg, data);
 }
 
 static int mt9v032_set_chip_control(struct mt9v032 *mt9v032, u16 clear, u16 set)
diff --git a/drivers/media/video/mx1_camera.c b/drivers/media/video/mx1_camera.c
index 18e94c7d2be8..055d11ddb038 100644
--- a/drivers/media/video/mx1_camera.c
+++ b/drivers/media/video/mx1_camera.c
@@ -487,7 +487,7 @@ static int mx1_camera_set_crop(struct soc_camera_device *icd,
         return v4l2_subdev_call(sd, video, s_crop, a);
 }
 
-static int mx1_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
+static int mx1_camera_set_bus_param(struct soc_camera_device *icd)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
diff --git a/drivers/media/video/mx2_camera.c b/drivers/media/video/mx2_camera.c
index a803d9ea8fd6..04aab0c538aa 100644
--- a/drivers/media/video/mx2_camera.c
+++ b/drivers/media/video/mx2_camera.c
@@ -210,6 +210,22 @@
 
 #define MAX_VIDEO_MEM   16
 
+struct mx2_prp_cfg {
+        int channel;
+        u32 in_fmt;
+        u32 out_fmt;
+        u32 src_pixel;
+        u32 ch1_pixel;
+        u32 irq_flags;
+};
+
+/* prp configuration for a client-host fmt pair */
+struct mx2_fmt_cfg {
+        enum v4l2_mbus_pixelcode        in_fmt;
+        u32                             out_fmt;
+        struct mx2_prp_cfg              cfg;
+};
+
 struct mx2_camera_dev {
         struct device           *dev;
         struct soc_camera_host  soc_host;
@@ -241,6 +257,8 @@ struct mx2_camera_dev {
         void                    *discard_buffer;
         dma_addr_t              discard_buffer_dma;
         size_t                  discard_size;
+        struct mx2_fmt_cfg      *emma_prp;
+        u32                     frame_count;
 };
 
 /* buffer for one video frame */
@@ -253,6 +271,59 @@ struct mx2_buffer {
         int bufnum;
 };
 
+static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
+        /*
+         * This is a generic configuration which is valid for most
+         * prp input-output format combinations.
+         * We set the incomming and outgoing pixelformat to a
+         * 16 Bit wide format and adjust the bytesperline
+         * accordingly. With this configuration the inputdata
+         * will not be changed by the emma and could be any type
+         * of 16 Bit Pixelformat.
+         */
+        {
+                .in_fmt         = 0,
+                .out_fmt        = 0,
+                .cfg            = {
+                        .channel        = 1,
+                        .in_fmt         = PRP_CNTL_DATA_IN_RGB16,
+                        .out_fmt        = PRP_CNTL_CH1_OUT_RGB16,
+                        .src_pixel      = 0x2ca00565, /* RGB565 */
+                        .ch1_pixel      = 0x2ca00565, /* RGB565 */
+                        .irq_flags      = PRP_INTR_RDERR | PRP_INTR_CH1WERR |
+                                                PRP_INTR_CH1FC | PRP_INTR_LBOVF,
+                }
+        },
+        {
+                .in_fmt         = V4L2_MBUS_FMT_YUYV8_2X8,
+                .out_fmt        = V4L2_PIX_FMT_YUV420,
+                .cfg            = {
+                        .channel        = 2,
+                        .in_fmt         = PRP_CNTL_DATA_IN_YUV422,
+                        .out_fmt        = PRP_CNTL_CH2_OUT_YUV420,
+                        .src_pixel      = 0x22000888, /* YUV422 (YUYV) */
+                        .irq_flags      = PRP_INTR_RDERR | PRP_INTR_CH2WERR |
+                                        PRP_INTR_CH2FC | PRP_INTR_LBOVF |
+                                        PRP_INTR_CH2OVF,
+                }
+        },
+};
+
+static struct mx2_fmt_cfg *mx27_emma_prp_get_format(
+                                        enum v4l2_mbus_pixelcode in_fmt,
+                                        u32 out_fmt)
+{
+        int i;
+
+        for (i = 1; i < ARRAY_SIZE(mx27_emma_prp_table); i++)
+                if ((mx27_emma_prp_table[i].in_fmt == in_fmt) &&
+                                (mx27_emma_prp_table[i].out_fmt == out_fmt)) {
+                        return &mx27_emma_prp_table[i];
+                }
+        /* If no match return the most generic configuration */
+        return &mx27_emma_prp_table[0];
+};
+
 static void mx2_camera_deactivate(struct mx2_camera_dev *pcdev)
 {
         unsigned long flags;
@@ -301,6 +372,7 @@ static int mx2_camera_add_device(struct soc_camera_device *icd)
         writel(pcdev->csicr1, pcdev->base_csi + CSICR1);
 
         pcdev->icd = icd;
+        pcdev->frame_count = 0;
 
         dev_info(icd->parent, "Camera driver attached to camera %d\n",
                  icd->devnum);
@@ -719,55 +791,77 @@ static void mx27_camera_emma_buf_init(struct soc_camera_device *icd,
         struct soc_camera_host *ici =
                 to_soc_camera_host(icd->parent);
         struct mx2_camera_dev *pcdev = ici->priv;
+        struct mx2_fmt_cfg *prp = pcdev->emma_prp;
+        u32 imgsize = pcdev->icd->user_height * pcdev->icd->user_width;
+
+        if (prp->cfg.channel == 1) {
+                writel(pcdev->discard_buffer_dma,
+                                pcdev->base_emma + PRP_DEST_RGB1_PTR);
+                writel(pcdev->discard_buffer_dma,
+                                pcdev->base_emma + PRP_DEST_RGB2_PTR);
+
+                writel(PRP_CNTL_CH1EN |
+                                PRP_CNTL_CSIEN |
+                                prp->cfg.in_fmt |
+                                prp->cfg.out_fmt |
+                                PRP_CNTL_CH1_LEN |
+                                PRP_CNTL_CH1BYP |
+                                PRP_CNTL_CH1_TSKIP(0) |
+                                PRP_CNTL_IN_TSKIP(0),
+                                pcdev->base_emma + PRP_CNTL);
+
+                writel((icd->user_width << 16) | icd->user_height,
+                        pcdev->base_emma + PRP_SRC_FRAME_SIZE);
+                writel((icd->user_width << 16) | icd->user_height,
+                        pcdev->base_emma + PRP_CH1_OUT_IMAGE_SIZE);
+                writel(bytesperline,
+                        pcdev->base_emma + PRP_DEST_CH1_LINE_STRIDE);
+                writel(prp->cfg.src_pixel,
+                        pcdev->base_emma + PRP_SRC_PIXEL_FORMAT_CNTL);
+                writel(prp->cfg.ch1_pixel,
+                        pcdev->base_emma + PRP_CH1_PIXEL_FORMAT_CNTL);
+        } else { /* channel 2 */
+                writel(pcdev->discard_buffer_dma,
+                        pcdev->base_emma + PRP_DEST_Y_PTR);
+                writel(pcdev->discard_buffer_dma,
+                        pcdev->base_emma + PRP_SOURCE_Y_PTR);
+
+                if (prp->cfg.out_fmt == PRP_CNTL_CH2_OUT_YUV420) {
+                        writel(pcdev->discard_buffer_dma + imgsize,
+                                pcdev->base_emma + PRP_DEST_CB_PTR);
+                        writel(pcdev->discard_buffer_dma + ((5 * imgsize) / 4),
+                                pcdev->base_emma + PRP_DEST_CR_PTR);
+                        writel(pcdev->discard_buffer_dma + imgsize,
+                                pcdev->base_emma + PRP_SOURCE_CB_PTR);
+                        writel(pcdev->discard_buffer_dma + ((5 * imgsize) / 4),
+                                pcdev->base_emma + PRP_SOURCE_CR_PTR);
+                }
 
-        writel(pcdev->discard_buffer_dma,
-                        pcdev->base_emma + PRP_DEST_RGB1_PTR);
-        writel(pcdev->discard_buffer_dma,
-                        pcdev->base_emma + PRP_DEST_RGB2_PTR);
-
-        /*
-         * We only use the EMMA engine to get rid of the broken
-         * DMA Engine. No color space consversion at the moment.
-         * We set the incomming and outgoing pixelformat to an
-         * 16 Bit wide format and adjust the bytesperline
-         * accordingly. With this configuration the inputdata
-         * will not be changed by the emma and could be any type
-         * of 16 Bit Pixelformat.
-         */
-        writel(PRP_CNTL_CH1EN |
+                writel(PRP_CNTL_CH2EN |
                         PRP_CNTL_CSIEN |
-                        PRP_CNTL_DATA_IN_RGB16 |
-                        PRP_CNTL_CH1_OUT_RGB16 |
-                        PRP_CNTL_CH1_LEN |
-                        PRP_CNTL_CH1BYP |
-                        PRP_CNTL_CH1_TSKIP(0) |
+                        prp->cfg.in_fmt |
+                        prp->cfg.out_fmt |
+                        PRP_CNTL_CH2_LEN |
+                        PRP_CNTL_CH2_TSKIP(0) |
                         PRP_CNTL_IN_TSKIP(0),
                         pcdev->base_emma + PRP_CNTL);
 
-        writel(((bytesperline >> 1) << 16) | icd->user_height,
+                writel((icd->user_width << 16) | icd->user_height,
                         pcdev->base_emma + PRP_SRC_FRAME_SIZE);
-        writel(((bytesperline >> 1) << 16) | icd->user_height,
-                        pcdev->base_emma + PRP_CH1_OUT_IMAGE_SIZE);
-        writel(bytesperline,
-                        pcdev->base_emma + PRP_DEST_CH1_LINE_STRIDE);
-        writel(0x2ca00565, /* RGB565 */
+
+                writel((icd->user_width << 16) | icd->user_height,
+                        pcdev->base_emma + PRP_CH2_OUT_IMAGE_SIZE);
+
+                writel(prp->cfg.src_pixel,
                         pcdev->base_emma + PRP_SRC_PIXEL_FORMAT_CNTL);
-        writel(0x2ca00565, /* RGB565 */
-                        pcdev->base_emma + PRP_CH1_PIXEL_FORMAT_CNTL);
+
+        }
 
         /* Enable interrupts */
-        writel(PRP_INTR_RDERR |
-                        PRP_INTR_CH1WERR |
-                        PRP_INTR_CH2WERR |
-                        PRP_INTR_CH1FC |
-                        PRP_INTR_CH2FC |
-                        PRP_INTR_LBOVF |
-                        PRP_INTR_CH2OVF,
-                        pcdev->base_emma + PRP_INTR_CNTL);
+        writel(prp->cfg.irq_flags, pcdev->base_emma + PRP_INTR_CNTL);
 }
 
-static int mx2_camera_set_bus_param(struct soc_camera_device *icd,
-                __u32 pixfmt)
+static int mx2_camera_set_bus_param(struct soc_camera_device *icd)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
@@ -911,9 +1005,58 @@ static int mx2_camera_set_crop(struct soc_camera_device *icd,
         return ret;
 }
 
+static int mx2_camera_get_formats(struct soc_camera_device *icd,
+                                  unsigned int idx,
+                                  struct soc_camera_format_xlate *xlate)
+{
+        struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
+        const struct soc_mbus_pixelfmt *fmt;
+        struct device *dev = icd->parent;
+        enum v4l2_mbus_pixelcode code;
+        int ret, formats = 0;
+
+        ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
+        if (ret < 0)
+                /* no more formats */
+                return 0;
+
+        fmt = soc_mbus_get_fmtdesc(code);
+        if (!fmt) {
+                dev_err(dev, "Invalid format code #%u: %d\n", idx, code);
+                return 0;
+        }
+
+        if (code == V4L2_MBUS_FMT_YUYV8_2X8) {
+                formats++;
+                if (xlate) {
+                        /*
+                         * CH2 can output YUV420 which is a standard format in
+                         * soc_mediabus.c
+                         */
+                        xlate->host_fmt =
+                                soc_mbus_get_fmtdesc(V4L2_MBUS_FMT_YUYV8_1_5X8);
+                        xlate->code     = code;
+                        dev_dbg(dev, "Providing host format %s for sensor code %d\n",
+                               xlate->host_fmt->name, code);
+                        xlate++;
+                }
+        }
+
+        /* Generic pass-trough */
+        formats++;
+        if (xlate) {
+                xlate->host_fmt = fmt;
+                xlate->code     = code;
+                xlate++;
+        }
+        return formats;
+}
+
 static int mx2_camera_set_fmt(struct soc_camera_device *icd,
                                struct v4l2_format *f)
 {
+        struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
+        struct mx2_camera_dev *pcdev = ici->priv;
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         const struct soc_camera_format_xlate *xlate;
         struct v4l2_pix_format *pix = &f->fmt.pix;
@@ -946,6 +1089,10 @@ static int mx2_camera_set_fmt(struct soc_camera_device *icd,
         pix->colorspace         = mf.colorspace;
         icd->current_fmt        = xlate;
 
+        if (mx27_camera_emma(pcdev))
+                pcdev->emma_prp = mx27_emma_prp_get_format(xlate->code,
+                                                xlate->host_fmt->fourcc);
+
         return 0;
 }
 
@@ -1011,7 +1158,12 @@ static int mx2_camera_try_fmt(struct soc_camera_device *icd,
 
         if (mf.field == V4L2_FIELD_ANY)
                 mf.field = V4L2_FIELD_NONE;
-        if (mf.field != V4L2_FIELD_NONE) {
+        /*
+         * Driver supports interlaced images provided they have
+         * both fields so that they can be processed as if they
+         * were progressive.
+         */
+        if (mf.field != V4L2_FIELD_NONE && !V4L2_FIELD_HAS_BOTH(mf.field)) {
                 dev_err(icd->parent, "Field type %d unsupported.\n",
                                 mf.field);
                 return -EINVAL;
@@ -1173,6 +1325,7 @@ static struct soc_camera_host_ops mx2_soc_camera_host_ops = {
         .remove         = mx2_camera_remove_device,
         .set_fmt        = mx2_camera_set_fmt,
         .set_crop       = mx2_camera_set_crop,
+        .get_formats    = mx2_camera_get_formats,
         .try_fmt        = mx2_camera_try_fmt,
         .init_videobuf  = mx2_camera_init_videobuf,
         .reqbufs        = mx2_camera_reqbufs,
@@ -1184,6 +1337,8 @@ static struct soc_camera_host_ops mx2_soc_camera_host_ops = {
 static void mx27_camera_frame_done_emma(struct mx2_camera_dev *pcdev,
                 int bufnum, int state)
 {
+        u32 imgsize = pcdev->icd->user_height * pcdev->icd->user_width;
+        struct mx2_fmt_cfg *prp = pcdev->emma_prp;
         struct mx2_buffer *buf;
         struct videobuf_buffer *vb;
         unsigned long phys;
@@ -1197,12 +1352,22 @@ static void mx27_camera_frame_done_emma(struct mx2_camera_dev *pcdev,
                 vb = &buf->vb;
 #ifdef DEBUG
                 phys = videobuf_to_dma_contig(vb);
-                if (readl(pcdev->base_emma + PRP_DEST_RGB1_PTR + 4 * bufnum)
-                                != phys) {
-                        dev_err(pcdev->dev, "%p != %p\n", phys,
-                                        readl(pcdev->base_emma +
-                                                PRP_DEST_RGB1_PTR +
-                                                4 * bufnum));
+                if (prp->cfg.channel == 1) {
+                        if (readl(pcdev->base_emma + PRP_DEST_RGB1_PTR +
+                                4 * bufnum) != phys) {
+                                dev_err(pcdev->dev, "%p != %p\n", phys,
+                                                readl(pcdev->base_emma +
+                                                        PRP_DEST_RGB1_PTR +
+                                                        4 * bufnum));
+                        }
+                } else {
+                        if (readl(pcdev->base_emma + PRP_DEST_Y_PTR -
+                                0x14 * bufnum) != phys) {
+                                dev_err(pcdev->dev, "%p != %p\n", phys,
+                                                readl(pcdev->base_emma +
+                                                        PRP_DEST_Y_PTR -
+                                                        0x14 * bufnum));
+                        }
                 }
 #endif
                 dev_dbg(pcdev->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__, vb,
@@ -1211,14 +1376,29 @@ static void mx27_camera_frame_done_emma(struct mx2_camera_dev *pcdev,
                 list_del(&vb->queue);
                 vb->state = state;
                 do_gettimeofday(&vb->ts);
-                vb->field_count++;
+                vb->field_count = pcdev->frame_count * 2;
+                pcdev->frame_count++;
 
                 wake_up(&vb->done);
         }
 
         if (list_empty(&pcdev->capture)) {
-                writel(pcdev->discard_buffer_dma, pcdev->base_emma +
-                                PRP_DEST_RGB1_PTR + 4 * bufnum);
+                if (prp->cfg.channel == 1) {
+                        writel(pcdev->discard_buffer_dma, pcdev->base_emma +
+                                        PRP_DEST_RGB1_PTR + 4 * bufnum);
+                } else {
+                        writel(pcdev->discard_buffer_dma, pcdev->base_emma +
+                                                PRP_DEST_Y_PTR -
+                                                0x14 * bufnum);
+                        if (prp->out_fmt == V4L2_PIX_FMT_YUV420) {
+                                writel(pcdev->discard_buffer_dma + imgsize,
+                                       pcdev->base_emma + PRP_DEST_CB_PTR -
+                                       0x14 * bufnum);
+                                writel(pcdev->discard_buffer_dma +
+                                       ((5 * imgsize) / 4), pcdev->base_emma +
+                                       PRP_DEST_CR_PTR - 0x14 * bufnum);
+                        }
+                }
                 return;
         }
 
@@ -1233,7 +1413,18 @@ static void mx27_camera_frame_done_emma(struct mx2_camera_dev *pcdev,
         vb->state = VIDEOBUF_ACTIVE;
 
         phys = videobuf_to_dma_contig(vb);
-        writel(phys, pcdev->base_emma + PRP_DEST_RGB1_PTR + 4 * bufnum);
+        if (prp->cfg.channel == 1) {
+                writel(phys, pcdev->base_emma + PRP_DEST_RGB1_PTR + 4 * bufnum);
+        } else {
+                writel(phys, pcdev->base_emma +
+                                PRP_DEST_Y_PTR - 0x14 * bufnum);
+                if (prp->cfg.out_fmt == PRP_CNTL_CH2_OUT_YUV420) {
+                        writel(phys + imgsize, pcdev->base_emma +
+                                        PRP_DEST_CB_PTR - 0x14 * bufnum);
+                        writel(phys + ((5 * imgsize) / 4), pcdev->base_emma +
+                                        PRP_DEST_CR_PTR - 0x14 * bufnum);
+                }
+        }
 }
 
 static irqreturn_t mx27_camera_emma_irq(int irq_emma, void *data)
@@ -1253,10 +1444,12 @@ static irqreturn_t mx27_camera_emma_irq(int irq_emma, void *data)
                  * the next one.
                  */
                 cntl = readl(pcdev->base_emma + PRP_CNTL);
-                writel(cntl & ~PRP_CNTL_CH1EN, pcdev->base_emma + PRP_CNTL);
+                writel(cntl & ~(PRP_CNTL_CH1EN | PRP_CNTL_CH2EN),
+                       pcdev->base_emma + PRP_CNTL);
                 writel(cntl, pcdev->base_emma + PRP_CNTL);
         }
-        if ((status & (3 << 5)) == (3 << 5)
+        if ((((status & (3 << 5)) == (3 << 5)) ||
+                ((status & (3 << 3)) == (3 << 3)))
                         && !list_empty(&pcdev->active_bufs)) {
                 /*
                  * Both buffers have triggered, process the one we're expecting
@@ -1267,9 +1460,9 @@ static irqreturn_t mx27_camera_emma_irq(int irq_emma, void *data)
                 mx27_camera_frame_done_emma(pcdev, buf->bufnum, VIDEOBUF_DONE);
                 status &= ~(1 << (6 - buf->bufnum)); /* mark processed */
         }
-        if (status & (1 << 6))
+        if ((status & (1 << 6)) || (status & (1 << 4)))
                 mx27_camera_frame_done_emma(pcdev, 0, VIDEOBUF_DONE);
-        if (status & (1 << 5))
+        if ((status & (1 << 5)) || (status & (1 << 3)))
                 mx27_camera_frame_done_emma(pcdev, 1, VIDEOBUF_DONE);
 
         writel(status, pcdev->base_emma + PRP_INTRSTATUS);
diff --git a/drivers/media/video/mx3_camera.c b/drivers/media/video/mx3_camera.c
index f96f92f00f92..0cb461dd396a 100644
--- a/drivers/media/video/mx3_camera.c
+++ b/drivers/media/video/mx3_camera.c
@@ -982,12 +982,13 @@ static int mx3_camera_querycap(struct soc_camera_host *ici,
         return 0;
 }
 
-static int mx3_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
+static int mx3_camera_set_bus_param(struct soc_camera_device *icd)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
         struct mx3_camera_dev *mx3_cam = ici->priv;
         struct v4l2_mbus_config cfg = {.type = V4L2_MBUS_PARALLEL,};
+        u32 pixfmt = icd->current_fmt->host_fmt->fourcc;
         unsigned long bus_flags, common_flags;
         u32 dw, sens_conf;
         const struct soc_mbus_pixelfmt *fmt;
@@ -1285,19 +1286,7 @@ static struct platform_driver mx3_camera_driver = {
         .remove         = __devexit_p(mx3_camera_remove),
 };
 
-
-static int __init mx3_camera_init(void)
-{
-        return platform_driver_register(&mx3_camera_driver);
-}
-
-static void __exit mx3_camera_exit(void)
-{
-        platform_driver_unregister(&mx3_camera_driver);
-}
-
-module_init(mx3_camera_init);
-module_exit(mx3_camera_exit);
+module_platform_driver(mx3_camera_driver);
 
 MODULE_DESCRIPTION("i.MX3x SoC Camera Host driver");
 MODULE_AUTHOR("Guennadi Liakhovetski <lg@denx.de>");
diff --git a/drivers/media/video/omap/omap_vout.c b/drivers/media/video/omap/omap_vout.c
index a378c2ce1273..a277f95091ef 100644
--- a/drivers/media/video/omap/omap_vout.c
+++ b/drivers/media/video/omap/omap_vout.c
@@ -524,10 +524,50 @@ static int omapvid_apply_changes(struct omap_vout_device *vout)
         return 0;
 }
 
+static int omapvid_handle_interlace_display(struct omap_vout_device *vout,
+                unsigned int irqstatus, struct timeval timevalue)
+{
+        u32 fid;
+
+        if (vout->first_int) {
+                vout->first_int = 0;
+                goto err;
+        }
+
+        if (irqstatus & DISPC_IRQ_EVSYNC_ODD)
+                fid = 1;
+        else if (irqstatus & DISPC_IRQ_EVSYNC_EVEN)
+                fid = 0;
+        else
+                goto err;
+
+        vout->field_id ^= 1;
+        if (fid != vout->field_id) {
+                if (fid == 0)
+                        vout->field_id = fid;
+        } else if (0 == fid) {
+                if (vout->cur_frm == vout->next_frm)
+                        goto err;
+
+                vout->cur_frm->ts = timevalue;
+                vout->cur_frm->state = VIDEOBUF_DONE;
+                wake_up_interruptible(&vout->cur_frm->done);
+                vout->cur_frm = vout->next_frm;
+        } else {
+                if (list_empty(&vout->dma_queue) ||
+                                (vout->cur_frm != vout->next_frm))
+                        goto err;
+        }
+
+        return vout->field_id;
+err:
+        return 0;
+}
+
 static void omap_vout_isr(void *arg, unsigned int irqstatus)
 {
-        int ret;
-        u32 addr, fid;
+        int ret, fid, mgr_id;
+        u32 addr, irq;
         struct omap_overlay *ovl;
         struct timeval timevalue;
         struct omapvideo_info *ovid;
@@ -543,112 +583,73 @@ static void omap_vout_isr(void *arg, unsigned int irqstatus)
         if (!ovl->manager || !ovl->manager->device)
                 return;
 
+        mgr_id = ovl->manager->id;
         cur_display = ovl->manager->device;
 
         spin_lock(&vout->vbq_lock);
         do_gettimeofday(&timevalue);
 
-        if (cur_display->type != OMAP_DISPLAY_TYPE_VENC) {
-                switch (cur_display->type) {
-                case OMAP_DISPLAY_TYPE_DPI:
-                        if (!(irqstatus & (DISPC_IRQ_VSYNC | DISPC_IRQ_VSYNC2)))
-                                goto vout_isr_err;
-                        break;
-                case OMAP_DISPLAY_TYPE_HDMI:
-                        if (!(irqstatus & DISPC_IRQ_EVSYNC_EVEN))
-                                goto vout_isr_err;
-                        break;
-                default:
-                        goto vout_isr_err;
-                }
-                if (!vout->first_int && (vout->cur_frm != vout->next_frm)) {
-                        vout->cur_frm->ts = timevalue;
-                        vout->cur_frm->state = VIDEOBUF_DONE;
-                        wake_up_interruptible(&vout->cur_frm->done);
-                        vout->cur_frm = vout->next_frm;
-                }
-                vout->first_int = 0;
-                if (list_empty(&vout->dma_queue))
+        switch (cur_display->type) {
+        case OMAP_DISPLAY_TYPE_DSI:
+        case OMAP_DISPLAY_TYPE_DPI:
+                if (mgr_id == OMAP_DSS_CHANNEL_LCD)
+                        irq = DISPC_IRQ_VSYNC;
+                else if (mgr_id == OMAP_DSS_CHANNEL_LCD2)
+                        irq = DISPC_IRQ_VSYNC2;
+                else
                         goto vout_isr_err;
 
-                vout->next_frm = list_entry(vout->dma_queue.next,
-                                struct videobuf_buffer, queue);
-                list_del(&vout->next_frm->queue);
-
-                vout->next_frm->state = VIDEOBUF_ACTIVE;
+                if (!(irqstatus & irq))
+                        goto vout_isr_err;
+                break;
+        case OMAP_DISPLAY_TYPE_VENC:
+                fid = omapvid_handle_interlace_display(vout, irqstatus,
+                                timevalue);
+                if (!fid)
+                        goto vout_isr_err;
+                break;
+        case OMAP_DISPLAY_TYPE_HDMI:
+                if (!(irqstatus & DISPC_IRQ_EVSYNC_EVEN))
+                        goto vout_isr_err;
+                break;
+        default:
+                goto vout_isr_err;
+        }
 
-                addr = (unsigned long) vout->queued_buf_addr[vout->next_frm->i]
-                        + vout->cropped_offset;
+        if (!vout->first_int && (vout->cur_frm != vout->next_frm)) {
+                vout->cur_frm->ts = timevalue;
+                vout->cur_frm->state = VIDEOBUF_DONE;
+                wake_up_interruptible(&vout->cur_frm->done);
+                vout->cur_frm = vout->next_frm;
+        }
 
-                /* First save the configuration in ovelray structure */
-                ret = omapvid_init(vout, addr);
-                if (ret)
-                        printk(KERN_ERR VOUT_NAME
-                                "failed to set overlay info\n");
-                /* Enable the pipeline and set the Go bit */
-                ret = omapvid_apply_changes(vout);
-                if (ret)
-                        printk(KERN_ERR VOUT_NAME "failed to change mode\n");
-        } else {
+        vout->first_int = 0;
+        if (list_empty(&vout->dma_queue))
+                goto vout_isr_err;
 
-                if (vout->first_int) {
-                        vout->first_int = 0;
-                        goto vout_isr_err;
-                }
-                if (irqstatus & DISPC_IRQ_EVSYNC_ODD)
-                        fid = 1;
-                else if (irqstatus & DISPC_IRQ_EVSYNC_EVEN)
-                        fid = 0;
-                else
-                        goto vout_isr_err;
+        vout->next_frm = list_entry(vout->dma_queue.next,
+                        struct videobuf_buffer, queue);
+        list_del(&vout->next_frm->queue);
 
-                vout->field_id ^= 1;
-                if (fid != vout->field_id) {
-                        if (0 == fid)
-                                vout->field_id = fid;
+        vout->next_frm->state = VIDEOBUF_ACTIVE;
 
-                        goto vout_isr_err;
-                }
-                if (0 == fid) {
-                        if (vout->cur_frm == vout->next_frm)
-                                goto vout_isr_err;
-
-                        vout->cur_frm->ts = timevalue;
-                        vout->cur_frm->state = VIDEOBUF_DONE;
-                        wake_up_interruptible(&vout->cur_frm->done);
-                        vout->cur_frm = vout->next_frm;
-                } else if (1 == fid) {
-                        if (list_empty(&vout->dma_queue) ||
-                                        (vout->cur_frm != vout->next_frm))
-                                goto vout_isr_err;
-
-                        vout->next_frm = list_entry(vout->dma_queue.next,
-                                        struct videobuf_buffer, queue);
-                        list_del(&vout->next_frm->queue);
-
-                        vout->next_frm->state = VIDEOBUF_ACTIVE;
-                        addr = (unsigned long)
-                                vout->queued_buf_addr[vout->next_frm->i] +
-                                vout->cropped_offset;
-                        /* First save the configuration in ovelray structure */
-                        ret = omapvid_init(vout, addr);
-                        if (ret)
-                                printk(KERN_ERR VOUT_NAME
-                                                "failed to set overlay info\n");
-                        /* Enable the pipeline and set the Go bit */
-                        ret = omapvid_apply_changes(vout);
-                        if (ret)
-                                printk(KERN_ERR VOUT_NAME
-                                                "failed to change mode\n");
-                }
+        addr = (unsigned long) vout->queued_buf_addr[vout->next_frm->i]
+                + vout->cropped_offset;
 
-        }
+        /* First save the configuration in ovelray structure */
+        ret = omapvid_init(vout, addr);
+        if (ret)
+                printk(KERN_ERR VOUT_NAME
+                        "failed to set overlay info\n");
+        /* Enable the pipeline and set the Go bit */
+        ret = omapvid_apply_changes(vout);
+        if (ret)
+                printk(KERN_ERR VOUT_NAME "failed to change mode\n");
 
 vout_isr_err:
         spin_unlock(&vout->vbq_lock);
 }
 
-
 /* Video buffer call backs */
 
 /*
@@ -664,10 +665,14 @@ static int omap_vout_buffer_setup(struct videobuf_queue *q, unsigned int *count,
         u32 phy_addr = 0, virt_addr = 0;
         struct omap_vout_device *vout = q->priv_data;
         struct omapvideo_info *ovid = &vout->vid_info;
+        int vid_max_buf_size;
 
         if (!vout)
                 return -EINVAL;
 
+        vid_max_buf_size = vout->vid == OMAP_VIDEO1 ? video1_bufsize :
+                video2_bufsize;
+
         if (V4L2_BUF_TYPE_VIDEO_OUTPUT != q->type)
                 return -EINVAL;
 
@@ -690,7 +695,7 @@ static int omap_vout_buffer_setup(struct videobuf_queue *q, unsigned int *count,
                 video1_numbuffers : video2_numbuffers;
 
         /* Check the size of the buffer */
-        if (*size > vout->buffer_size) {
+        if (*size > vid_max_buf_size) {
                 v4l2_err(&vout->vid_dev->v4l2_dev,
                                 "buffer allocation mismatch [%u] [%u]\n",
                                 *size, vout->buffer_size);
diff --git a/drivers/media/video/omap/omap_voutdef.h b/drivers/media/video/omap/omap_voutdef.h
index d793501cafcc..27a95d23b913 100644
--- a/drivers/media/video/omap/omap_voutdef.h
+++ b/drivers/media/video/omap/omap_voutdef.h
@@ -25,7 +25,7 @@
 #define MAC_VRFB_CTXS   4
 #define MAX_VOUT_DEV    2
 #define MAX_OVLS        3
-#define MAX_DISPLAYS    3
+#define MAX_DISPLAYS    10
 #define MAX_MANAGERS    3
 
 #define QQVGA_WIDTH             160
diff --git a/drivers/media/video/omap1_camera.c b/drivers/media/video/omap1_camera.c
index 6a6cf388bae4..c20f5ecd6790 100644
--- a/drivers/media/video/omap1_camera.c
+++ b/drivers/media/video/omap1_camera.c
@@ -1436,13 +1436,13 @@ static int omap1_cam_querycap(struct soc_camera_host *ici,
         return 0;
 }
 
-static int omap1_cam_set_bus_param(struct soc_camera_device *icd,
-                __u32 pixfmt)
+static int omap1_cam_set_bus_param(struct soc_camera_device *icd)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct device *dev = icd->parent;
         struct soc_camera_host *ici = to_soc_camera_host(dev);
         struct omap1_cam_dev *pcdev = ici->priv;
+        u32 pixfmt = icd->current_fmt->host_fmt->fourcc;
         const struct soc_camera_format_xlate *xlate;
         const struct soc_mbus_pixelfmt *fmt;
         struct v4l2_mbus_config cfg = {.type = V4L2_MBUS_PARALLEL,};
@@ -1713,17 +1713,7 @@ static struct platform_driver omap1_cam_driver = {
         .remove         = __exit_p(omap1_cam_remove),
 };
 
-static int __init omap1_cam_init(void)
-{
-        return platform_driver_register(&omap1_cam_driver);
-}
-module_init(omap1_cam_init);
-
-static void __exit omap1_cam_exit(void)
-{
-        platform_driver_unregister(&omap1_cam_driver);
-}
-module_exit(omap1_cam_exit);
+module_platform_driver(omap1_cam_driver);
 
 module_param(sg_mode, bool, 0644);
 MODULE_PARM_DESC(sg_mode, "videobuf mode, 0: dma-contig (default), 1: dma-sg");
diff --git a/drivers/media/video/omap24xxcam.c b/drivers/media/video/omap24xxcam.c
index 45522e603185..7d3864144368 100644
--- a/drivers/media/video/omap24xxcam.c
+++ b/drivers/media/video/omap24xxcam.c
@@ -1868,21 +1868,7 @@ static struct platform_driver omap24xxcam_driver = {
         },
 };
 
-/*
- *
- * Module initialisation and deinitialisation
- *
- */
-
-static int __init omap24xxcam_init(void)
-{
-        return platform_driver_register(&omap24xxcam_driver);
-}
-
-static void __exit omap24xxcam_cleanup(void)
-{
-        platform_driver_unregister(&omap24xxcam_driver);
-}
+module_platform_driver(omap24xxcam_driver);
 
 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
 MODULE_DESCRIPTION("OMAP24xx Video for Linux camera driver");
@@ -1894,6 +1880,3 @@ MODULE_PARM_DESC(video_nr,
 module_param(capture_mem, int, 0);
 MODULE_PARM_DESC(capture_mem, "Maximum amount of memory for capture "
                  "buffers (default 4800kiB)");
-
-module_init(omap24xxcam_init);
-module_exit(omap24xxcam_cleanup);
diff --git a/drivers/media/video/omap3isp/isp.c b/drivers/media/video/omap3isp/isp.c
index d4c48ef227fb..12d5f923e1d0 100644
--- a/drivers/media/video/omap3isp/isp.c
+++ b/drivers/media/video/omap3isp/isp.c
@@ -403,6 +403,7 @@ static inline void isp_isr_dbg(struct isp_device *isp, u32 irqstatus)
 static void isp_isr_sbl(struct isp_device *isp)
 {
         struct device *dev = isp->dev;
+        struct isp_pipeline *pipe;
         u32 sbl_pcr;
 
         /*
@@ -416,27 +417,38 @@ static void isp_isr_sbl(struct isp_device *isp)
         if (sbl_pcr)
                 dev_dbg(dev, "SBL overflow (PCR = 0x%08x)\n", sbl_pcr);
 
-        if (sbl_pcr & (ISPSBL_PCR_CCDC_WBL_OVF | ISPSBL_PCR_CSIA_WBL_OVF
-                     | ISPSBL_PCR_CSIB_WBL_OVF)) {
-                isp->isp_ccdc.error = 1;
-                if (isp->isp_ccdc.output & CCDC_OUTPUT_PREVIEW)
-                        isp->isp_prev.error = 1;
-                if (isp->isp_ccdc.output & CCDC_OUTPUT_RESIZER)
-                        isp->isp_res.error = 1;
+        if (sbl_pcr & ISPSBL_PCR_CSIB_WBL_OVF) {
+                pipe = to_isp_pipeline(&isp->isp_ccp2.subdev.entity);
+                if (pipe != NULL)
+                        pipe->error = true;
+        }
+
+        if (sbl_pcr & ISPSBL_PCR_CSIA_WBL_OVF) {
+                pipe = to_isp_pipeline(&isp->isp_csi2a.subdev.entity);
+                if (pipe != NULL)
+                        pipe->error = true;
+        }
+
+        if (sbl_pcr & ISPSBL_PCR_CCDC_WBL_OVF) {
+                pipe = to_isp_pipeline(&isp->isp_ccdc.subdev.entity);
+                if (pipe != NULL)
+                        pipe->error = true;
         }
 
         if (sbl_pcr & ISPSBL_PCR_PRV_WBL_OVF) {
-                isp->isp_prev.error = 1;
-                if (isp->isp_res.input == RESIZER_INPUT_VP &&
-                    !(isp->isp_ccdc.output & CCDC_OUTPUT_RESIZER))
-                        isp->isp_res.error = 1;
+                pipe = to_isp_pipeline(&isp->isp_prev.subdev.entity);
+                if (pipe != NULL)
+                        pipe->error = true;
         }
 
         if (sbl_pcr & (ISPSBL_PCR_RSZ1_WBL_OVF
                        | ISPSBL_PCR_RSZ2_WBL_OVF
                        | ISPSBL_PCR_RSZ3_WBL_OVF
-                       | ISPSBL_PCR_RSZ4_WBL_OVF))
-                isp->isp_res.error = 1;
+                       | ISPSBL_PCR_RSZ4_WBL_OVF)) {
+                pipe = to_isp_pipeline(&isp->isp_res.subdev.entity);
+                if (pipe != NULL)
+                        pipe->error = true;
+        }
 
         if (sbl_pcr & ISPSBL_PCR_H3A_AF_WBL_OVF)
                 omap3isp_stat_sbl_overflow(&isp->isp_af);
@@ -464,24 +476,17 @@ static irqreturn_t isp_isr(int irq, void *_isp)
                                        IRQ0STATUS_HS_VS_IRQ;
         struct isp_device *isp = _isp;
         u32 irqstatus;
-        int ret;
 
         irqstatus = isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS);
         isp_reg_writel(isp, irqstatus, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0STATUS);
 
         isp_isr_sbl(isp);
 
-        if (irqstatus & IRQ0STATUS_CSIA_IRQ) {
-                ret = omap3isp_csi2_isr(&isp->isp_csi2a);
-                if (ret)
-                        isp->isp_ccdc.error = 1;
-        }
+        if (irqstatus & IRQ0STATUS_CSIA_IRQ)
+                omap3isp_csi2_isr(&isp->isp_csi2a);
 
-        if (irqstatus & IRQ0STATUS_CSIB_IRQ) {
-                ret = omap3isp_ccp2_isr(&isp->isp_ccp2);
-                if (ret)
-                        isp->isp_ccdc.error = 1;
-        }
+        if (irqstatus & IRQ0STATUS_CSIB_IRQ)
+                omap3isp_ccp2_isr(&isp->isp_ccp2);
 
         if (irqstatus & IRQ0STATUS_CCDC_VD0_IRQ) {
                 if (isp->isp_ccdc.output & CCDC_OUTPUT_PREVIEW)
@@ -2222,24 +2227,7 @@ static struct platform_driver omap3isp_driver = {
         },
 };
 
-/*
- * isp_init - ISP module initialization.
- */
-static int __init isp_init(void)
-{
-        return platform_driver_register(&omap3isp_driver);
-}
-
-/*
- * isp_cleanup - ISP module cleanup.
- */
-static void __exit isp_cleanup(void)
-{
-        platform_driver_unregister(&omap3isp_driver);
-}
-
-module_init(isp_init);
-module_exit(isp_cleanup);
+module_platform_driver(omap3isp_driver);
 
 MODULE_AUTHOR("Nokia Corporation");
 MODULE_DESCRIPTION("TI OMAP3 ISP driver");
diff --git a/drivers/media/video/omap3isp/ispccdc.c b/drivers/media/video/omap3isp/ispccdc.c
index d341ba12593f..a74a79701d34 100644
--- a/drivers/media/video/omap3isp/ispccdc.c
+++ b/drivers/media/video/omap3isp/ispccdc.c
@@ -1406,9 +1406,8 @@ static int __ccdc_handle_stopping(struct isp_ccdc_device *ccdc, u32 event)
 
 static void ccdc_hs_vs_isr(struct isp_ccdc_device *ccdc)
 {
-        struct isp_pipeline *pipe =
-                to_isp_pipeline(&ccdc->video_out.video.entity);
-        struct video_device *vdev = ccdc->subdev.devnode;
+        struct isp_pipeline *pipe = to_isp_pipeline(&ccdc->subdev.entity);
+        struct video_device *vdev = &ccdc->subdev.devnode;
         struct v4l2_event event;
 
         memset(&event, 0, sizeof(event));
@@ -1428,8 +1427,11 @@ static void ccdc_lsc_isr(struct isp_ccdc_device *ccdc, u32 events)
         unsigned long flags;
 
         if (events & IRQ0STATUS_CCDC_LSC_PREF_ERR_IRQ) {
+                struct isp_pipeline *pipe =
+                        to_isp_pipeline(&ccdc->subdev.entity);
+
                 ccdc_lsc_error_handler(ccdc);
-                ccdc->error = 1;
+                pipe->error = true;
                 dev_dbg(to_device(ccdc), "lsc prefetch error\n");
         }
 
@@ -1504,7 +1506,7 @@ static int ccdc_isr_buffer(struct isp_ccdc_device *ccdc)
                 goto done;
         }
 
-        buffer = omap3isp_video_buffer_next(&ccdc->video_out, ccdc->error);
+        buffer = omap3isp_video_buffer_next(&ccdc->video_out);
         if (buffer != NULL) {
                 ccdc_set_outaddr(ccdc, buffer->isp_addr);
                 restart = 1;
@@ -1518,7 +1520,6 @@ static int ccdc_isr_buffer(struct isp_ccdc_device *ccdc)
                                         ISP_PIPELINE_STREAM_SINGLESHOT);
 
 done:
-        ccdc->error = 0;
         return restart;
 }
 
@@ -1744,7 +1745,6 @@ static int ccdc_set_stream(struct v4l2_subdev *sd, int enable)
                  */
                 ccdc_config_vp(ccdc);
                 ccdc_enable_vp(ccdc, 1);
-                ccdc->error = 0;
                 ccdc_print_status(ccdc);
         }
 
diff --git a/drivers/media/video/omap3isp/ispccdc.h b/drivers/media/video/omap3isp/ispccdc.h
index 483a19cac1ad..6d0264bab75b 100644
--- a/drivers/media/video/omap3isp/ispccdc.h
+++ b/drivers/media/video/omap3isp/ispccdc.h
@@ -150,7 +150,6 @@ struct ispccdc_lsc {
  * @input: Active input
  * @output: Active outputs
  * @video_out: Output video node
- * @error: A hardware error occurred during capture
  * @alaw: A-law compression enabled (1) or disabled (0)
  * @lpf: Low pass filter enabled (1) or disabled (0)
  * @obclamp: Optical-black clamp enabled (1) or disabled (0)
@@ -178,7 +177,6 @@ struct isp_ccdc_device {
         enum ccdc_input_entity input;
         unsigned int output;
         struct isp_video video_out;
-        unsigned int error;
 
         unsigned int alaw:1,
                      lpf:1,
diff --git a/drivers/media/video/omap3isp/ispccp2.c b/drivers/media/video/omap3isp/ispccp2.c
index 904ca8c8b17f..70ddbf35b223 100644
--- a/drivers/media/video/omap3isp/ispccp2.c
+++ b/drivers/media/video/omap3isp/ispccp2.c
@@ -556,7 +556,7 @@ static void ccp2_isr_buffer(struct isp_ccp2_device *ccp2)
         struct isp_pipeline *pipe = to_isp_pipeline(&ccp2->subdev.entity);
         struct isp_buffer *buffer;
 
-        buffer = omap3isp_video_buffer_next(&ccp2->video_in, ccp2->error);
+        buffer = omap3isp_video_buffer_next(&ccp2->video_in);
         if (buffer != NULL)
                 ccp2_set_inaddr(ccp2, buffer->isp_addr);
 
@@ -567,8 +567,6 @@ static void ccp2_isr_buffer(struct isp_ccp2_device *ccp2)
                         omap3isp_pipeline_set_stream(pipe,
                                                 ISP_PIPELINE_STREAM_SINGLESHOT);
         }
-
-        ccp2->error = 0;
 }
 
 /*
@@ -576,13 +574,11 @@ static void ccp2_isr_buffer(struct isp_ccp2_device *ccp2)
  * @ccp2: Pointer to ISP CCP2 device
  *
  * This will handle the CCP2 interrupts
- *
- * Returns -EIO in case of error, or 0 on success.
  */
-int omap3isp_ccp2_isr(struct isp_ccp2_device *ccp2)
+void omap3isp_ccp2_isr(struct isp_ccp2_device *ccp2)
 {
+        struct isp_pipeline *pipe = to_isp_pipeline(&ccp2->subdev.entity);
         struct isp_device *isp = to_isp_device(ccp2);
-        int ret = 0;
         static const u32 ISPCCP2_LC01_ERROR =
                 ISPCCP2_LC01_IRQSTATUS_LC0_FIFO_OVF_IRQ |
                 ISPCCP2_LC01_IRQSTATUS_LC0_CRC_IRQ |
@@ -604,19 +600,18 @@ int omap3isp_ccp2_isr(struct isp_ccp2_device *ccp2)
                        ISPCCP2_LCM_IRQSTATUS);
         /* Errors */
         if (lcx_irqstatus & ISPCCP2_LC01_ERROR) {
-                ccp2->error = 1;
+                pipe->error = true;
                 dev_dbg(isp->dev, "CCP2 err:%x\n", lcx_irqstatus);
-                return -EIO;
+                return;
         }
 
         if (lcm_irqstatus & ISPCCP2_LCM_IRQSTATUS_OCPERROR_IRQ) {
-                ccp2->error = 1;
+                pipe->error = true;
                 dev_dbg(isp->dev, "CCP2 OCP err:%x\n", lcm_irqstatus);
-                ret = -EIO;
         }
 
         if (omap3isp_module_sync_is_stopping(&ccp2->wait, &ccp2->stopping))
-                return 0;
+                return;
 
         /* Frame number propagation */
         if (lcx_irqstatus & ISPCCP2_LC01_IRQSTATUS_LC0_FS_IRQ) {
@@ -629,8 +624,6 @@ int omap3isp_ccp2_isr(struct isp_ccp2_device *ccp2)
         /* Handle queued buffers on frame end interrupts */
         if (lcm_irqstatus & ISPCCP2_LCM_IRQSTATUS_EOF_IRQ)
                 ccp2_isr_buffer(ccp2);
-
-        return ret;
 }
 
 /* -----------------------------------------------------------------------------
@@ -867,7 +860,6 @@ static int ccp2_s_stream(struct v4l2_subdev *sd, int enable)
                 if (enable == ISP_PIPELINE_STREAM_STOPPED)
                         return 0;
                 atomic_set(&ccp2->stopping, 0);
-                ccp2->error = 0;
         }
 
         switch (enable) {
diff --git a/drivers/media/video/omap3isp/ispccp2.h b/drivers/media/video/omap3isp/ispccp2.h
index 6674e9de2cd7..76d65f4576ef 100644
--- a/drivers/media/video/omap3isp/ispccp2.h
+++ b/drivers/media/video/omap3isp/ispccp2.h
@@ -82,7 +82,6 @@ struct isp_ccp2_device {
         struct isp_video video_in;
         struct isp_csiphy *phy;
         struct regulator *vdds_csib;
-        unsigned int error;
         enum isp_pipeline_stream_state state;
         wait_queue_head_t wait;
         atomic_t stopping;
@@ -94,6 +93,6 @@ void omap3isp_ccp2_cleanup(struct isp_device *isp);
 int omap3isp_ccp2_register_entities(struct isp_ccp2_device *ccp2,
                         struct v4l2_device *vdev);
 void omap3isp_ccp2_unregister_entities(struct isp_ccp2_device *ccp2);
-int omap3isp_ccp2_isr(struct isp_ccp2_device *ccp2);
+void omap3isp_ccp2_isr(struct isp_ccp2_device *ccp2);
 
 #endif  /* OMAP3_ISP_CCP2_H */
diff --git a/drivers/media/video/omap3isp/ispcsi2.c b/drivers/media/video/omap3isp/ispcsi2.c
index 0c5f1cb9d99d..fcb5168996a7 100644
--- a/drivers/media/video/omap3isp/ispcsi2.c
+++ b/drivers/media/video/omap3isp/ispcsi2.c
@@ -667,7 +667,7 @@ static void csi2_isr_buffer(struct isp_csi2_device *csi2)
 
         csi2_ctx_enable(isp, csi2, 0, 0);
 
-        buffer = omap3isp_video_buffer_next(&csi2->video_out, 0);
+        buffer = omap3isp_video_buffer_next(&csi2->video_out);
 
         /*
          * Let video queue operation restart engine if there is an underrun
@@ -727,17 +727,15 @@ static void csi2_isr_ctx(struct isp_csi2_device *csi2,
 
 /*
  * omap3isp_csi2_isr - CSI2 interrupt handling.
- *
- * Return -EIO on Transmission error
  */
-int omap3isp_csi2_isr(struct isp_csi2_device *csi2)
+void omap3isp_csi2_isr(struct isp_csi2_device *csi2)
 {
+        struct isp_pipeline *pipe = to_isp_pipeline(&csi2->subdev.entity);
         u32 csi2_irqstatus, cpxio1_irqstatus;
         struct isp_device *isp = csi2->isp;
-        int retval = 0;
 
         if (!csi2->available)
-                return -ENODEV;
+                return;
 
         csi2_irqstatus = isp_reg_readl(isp, csi2->regs1, ISPCSI2_IRQSTATUS);
         isp_reg_writel(isp, csi2_irqstatus, csi2->regs1, ISPCSI2_IRQSTATUS);
@@ -750,7 +748,7 @@ int omap3isp_csi2_isr(struct isp_csi2_device *csi2)
                                csi2->regs1, ISPCSI2_PHY_IRQSTATUS);
                 dev_dbg(isp->dev, "CSI2: ComplexIO Error IRQ "
                         "%x\n", cpxio1_irqstatus);
-                retval = -EIO;
+                pipe->error = true;
         }
 
         if (csi2_irqstatus & (ISPCSI2_IRQSTATUS_OCP_ERR_IRQ |
@@ -775,11 +773,11 @@ int omap3isp_csi2_isr(struct isp_csi2_device *csi2)
                          ISPCSI2_IRQSTATUS_COMPLEXIO2_ERR_IRQ) ? 1 : 0,
                         (csi2_irqstatus &
                          ISPCSI2_IRQSTATUS_FIFO_OVF_IRQ) ? 1 : 0);
-                retval = -EIO;
+                pipe->error = true;
         }
 
         if (omap3isp_module_sync_is_stopping(&csi2->wait, &csi2->stopping))
-                return 0;
+                return;
 
         /* Successful cases */
         if (csi2_irqstatus & ISPCSI2_IRQSTATUS_CONTEXT(0))
@@ -787,8 +785,6 @@ int omap3isp_csi2_isr(struct isp_csi2_device *csi2)
 
         if (csi2_irqstatus & ISPCSI2_IRQSTATUS_ECC_CORRECTION_IRQ)
                 dev_dbg(isp->dev, "CSI2: ECC correction done\n");
-
-        return retval;
 }
 
 /* -----------------------------------------------------------------------------
diff --git a/drivers/media/video/omap3isp/ispcsi2.h b/drivers/media/video/omap3isp/ispcsi2.h
index 456fb7fb8a0f..885ad79a7678 100644
--- a/drivers/media/video/omap3isp/ispcsi2.h
+++ b/drivers/media/video/omap3isp/ispcsi2.h
@@ -156,7 +156,7 @@ struct isp_csi2_device {
         atomic_t stopping;
 };
 
-int omap3isp_csi2_isr(struct isp_csi2_device *csi2);
+void omap3isp_csi2_isr(struct isp_csi2_device *csi2);
 int omap3isp_csi2_reset(struct isp_csi2_device *csi2);
 int omap3isp_csi2_init(struct isp_device *isp);
 void omap3isp_csi2_cleanup(struct isp_device *isp);
diff --git a/drivers/media/video/omap3isp/isppreview.c b/drivers/media/video/omap3isp/isppreview.c
index ccb876fe023f..6d0fb2c8c26d 100644
--- a/drivers/media/video/omap3isp/isppreview.c
+++ b/drivers/media/video/omap3isp/isppreview.c
@@ -116,11 +116,11 @@ static struct omap3isp_prev_csc flr_prev_csc = {
 #define PREV_MIN_IN_HEIGHT      8
 #define PREV_MAX_IN_HEIGHT      16384
 
-#define PREV_MIN_OUT_WIDTH      0
-#define PREV_MIN_OUT_HEIGHT     0
-#define PREV_MAX_OUT_WIDTH      1280
-#define PREV_MAX_OUT_WIDTH_ES2  3300
-#define PREV_MAX_OUT_WIDTH_3630 4096
+#define PREV_MIN_OUT_WIDTH              0
+#define PREV_MIN_OUT_HEIGHT             0
+#define PREV_MAX_OUT_WIDTH_REV_1        1280
+#define PREV_MAX_OUT_WIDTH_REV_2        3300
+#define PREV_MAX_OUT_WIDTH_REV_15       4096
 
 /*
  * Coeficient Tables for the submodules in Preview.
@@ -1306,14 +1306,14 @@ static unsigned int preview_max_out_width(struct isp_prev_device *prev)
 
         switch (isp->revision) {
         case ISP_REVISION_1_0:
-                return PREV_MAX_OUT_WIDTH;
+                return PREV_MAX_OUT_WIDTH_REV_1;
 
         case ISP_REVISION_2_0:
         default:
-                return PREV_MAX_OUT_WIDTH_ES2;
+                return PREV_MAX_OUT_WIDTH_REV_2;
 
         case ISP_REVISION_15_0:
-                return PREV_MAX_OUT_WIDTH_3630;
+                return PREV_MAX_OUT_WIDTH_REV_15;
         }
 }
 
@@ -1404,16 +1404,14 @@ static void preview_isr_buffer(struct isp_prev_device *prev)
         int restart = 0;
 
         if (prev->input == PREVIEW_INPUT_MEMORY) {
-                buffer = omap3isp_video_buffer_next(&prev->video_in,
-                                                    prev->error);
+                buffer = omap3isp_video_buffer_next(&prev->video_in);
                 if (buffer != NULL)
                         preview_set_inaddr(prev, buffer->isp_addr);
                 pipe->state |= ISP_PIPELINE_IDLE_INPUT;
         }
 
         if (prev->output & PREVIEW_OUTPUT_MEMORY) {
-                buffer = omap3isp_video_buffer_next(&prev->video_out,
-                                                    prev->error);
+                buffer = omap3isp_video_buffer_next(&prev->video_out);
                 if (buffer != NULL) {
                         preview_set_outaddr(prev, buffer->isp_addr);
                         restart = 1;
@@ -1440,8 +1438,6 @@ static void preview_isr_buffer(struct isp_prev_device *prev)
         default:
                 return;
         }
-
-        prev->error = 0;
 }
 
 /*
@@ -1565,7 +1561,6 @@ static int preview_set_stream(struct v4l2_subdev *sd, int enable)
                 omap3isp_subclk_enable(isp, OMAP3_ISP_SUBCLK_PREVIEW);
                 preview_configure(prev);
                 atomic_set(&prev->stopping, 0);
-                prev->error = 0;
                 preview_print_status(prev);
         }
 
diff --git a/drivers/media/video/omap3isp/isppreview.h b/drivers/media/video/omap3isp/isppreview.h
index f54e775c2df4..09686607973c 100644
--- a/drivers/media/video/omap3isp/isppreview.h
+++ b/drivers/media/video/omap3isp/isppreview.h
@@ -157,7 +157,6 @@ struct isptables_update {
  * @output: Bitmask of the active output
  * @video_in: Input video entity
  * @video_out: Output video entity
- * @error: A hardware error occurred during capture
  * @params: Module configuration data
  * @shadow_update: If set, update the hardware configured in the next interrupt
  * @underrun: Whether the preview entity has queued buffers on the output
@@ -179,7 +178,6 @@ struct isp_prev_device {
         unsigned int output;
         struct isp_video video_in;
         struct isp_video video_out;
-        unsigned int error;
 
         struct prev_params params;
         unsigned int shadow_update:1;
diff --git a/drivers/media/video/omap3isp/ispresizer.c b/drivers/media/video/omap3isp/ispresizer.c
index 50e593bfcfaf..6958a9e3dc22 100644
--- a/drivers/media/video/omap3isp/ispresizer.c
+++ b/drivers/media/video/omap3isp/ispresizer.c
@@ -1038,7 +1038,7 @@ static void resizer_isr_buffer(struct isp_res_device *res)
         /* Complete the output buffer and, if reading from memory, the input
          * buffer.
          */
-        buffer = omap3isp_video_buffer_next(&res->video_out, res->error);
+        buffer = omap3isp_video_buffer_next(&res->video_out);
         if (buffer != NULL) {
                 resizer_set_outaddr(res, buffer->isp_addr);
                 restart = 1;
@@ -1047,7 +1047,7 @@ static void resizer_isr_buffer(struct isp_res_device *res)
         pipe->state |= ISP_PIPELINE_IDLE_OUTPUT;
 
         if (res->input == RESIZER_INPUT_MEMORY) {
-                buffer = omap3isp_video_buffer_next(&res->video_in, 0);
+                buffer = omap3isp_video_buffer_next(&res->video_in);
                 if (buffer != NULL)
                         resizer_set_inaddr(res, buffer->isp_addr);
                 pipe->state |= ISP_PIPELINE_IDLE_INPUT;
@@ -1064,8 +1064,6 @@ static void resizer_isr_buffer(struct isp_res_device *res)
                 if (restart)
                         resizer_enable_oneshot(res);
         }
-
-        res->error = 0;
 }
 
 /*
@@ -1154,7 +1152,6 @@ static int resizer_set_stream(struct v4l2_subdev *sd, int enable)
 
                 omap3isp_subclk_enable(isp, OMAP3_ISP_SUBCLK_RESIZER);
                 resizer_configure(res);
-                res->error = 0;
                 resizer_print_status(res);
         }
 
diff --git a/drivers/media/video/omap3isp/ispresizer.h b/drivers/media/video/omap3isp/ispresizer.h
index 76abc2e42126..70c1c0e1bbdf 100644
--- a/drivers/media/video/omap3isp/ispresizer.h
+++ b/drivers/media/video/omap3isp/ispresizer.h
@@ -107,7 +107,6 @@ struct isp_res_device {
         enum resizer_input_entity input;
         struct isp_video video_in;
         struct isp_video video_out;
-        unsigned int error;
 
         u32 addr_base;   /* stored source buffer address in memory mode */
         u32 crop_offset; /* additional offset for crop in memory mode */
diff --git a/drivers/media/video/omap3isp/ispvideo.c b/drivers/media/video/omap3isp/ispvideo.c
index bd3aebafafa0..b02070057724 100644
--- a/drivers/media/video/omap3isp/ispvideo.c
+++ b/drivers/media/video/omap3isp/ispvideo.c
@@ -211,14 +211,14 @@ static void isp_video_pix_to_mbus(const struct v4l2_pix_format *pix,
         mbus->width = pix->width;
         mbus->height = pix->height;
 
-        for (i = 0; i < ARRAY_SIZE(formats); ++i) {
+        /* Skip the last format in the loop so that it will be selected if no
+         * match is found.
+         */
+        for (i = 0; i < ARRAY_SIZE(formats) - 1; ++i) {
                 if (formats[i].pixelformat == pix->pixelformat)
                         break;
         }
 
-        if (WARN_ON(i == ARRAY_SIZE(formats)))
-                return;
-
         mbus->code = formats[i].code;
         mbus->colorspace = pix->colorspace;
         mbus->field = pix->field;
@@ -581,21 +581,20 @@ static const struct isp_video_queue_operations isp_video_queue_ops = {
 /*
  * omap3isp_video_buffer_next - Complete the current buffer and return the next
  * @video: ISP video object
- * @error: Whether an error occurred during capture
  *
  * Remove the current video buffer from the DMA queue and fill its timestamp,
  * field count and state fields before waking up its completion handler.
  *
- * The buffer state is set to VIDEOBUF_DONE if no error occurred (@error is 0)
- * or VIDEOBUF_ERROR otherwise (@error is non-zero).
+ * For capture video nodes the buffer state is set to ISP_BUF_STATE_DONE if no
+ * error has been flagged in the pipeline, or to ISP_BUF_STATE_ERROR otherwise.
+ * For video output nodes the buffer state is always set to ISP_BUF_STATE_DONE.
  *
  * The DMA queue is expected to contain at least one buffer.
  *
  * Return a pointer to the next buffer in the DMA queue, or NULL if the queue is
  * empty.
  */
-struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video,
-                                              unsigned int error)
+struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video)
 {
         struct isp_pipeline *pipe = to_isp_pipeline(&video->video.entity);
         struct isp_video_queue *queue = video->queue;
@@ -630,7 +629,13 @@ struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video,
         else
                 buf->vbuf.sequence = atomic_read(&pipe->frame_number);
 
-        buf->state = error ? ISP_BUF_STATE_ERROR : ISP_BUF_STATE_DONE;
+        /* Report pipeline errors to userspace on the capture device side. */
+        if (queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && pipe->error) {
+                buf->state = ISP_BUF_STATE_ERROR;
+                pipe->error = false;
+        } else {
+                buf->state = ISP_BUF_STATE_DONE;
+        }
 
         wake_up(&buf->wait);
 
@@ -1016,6 +1021,8 @@ isp_video_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
         if (ret < 0)
                 goto error;
 
+        pipe->error = false;
+
         spin_lock_irqsave(&pipe->lock, flags);
         pipe->state &= ~ISP_PIPELINE_STREAM;
         pipe->state |= state;
diff --git a/drivers/media/video/omap3isp/ispvideo.h b/drivers/media/video/omap3isp/ispvideo.h
index 08cbfa144e6e..d91bdb919be0 100644
--- a/drivers/media/video/omap3isp/ispvideo.h
+++ b/drivers/media/video/omap3isp/ispvideo.h
@@ -85,6 +85,10 @@ enum isp_pipeline_state {
         ISP_PIPELINE_STREAM = 64,
 };
 
+/*
+ * struct isp_pipeline - An ISP hardware pipeline
+ * @error: A hardware error occurred during capture
+ */
 struct isp_pipeline {
         struct media_pipeline pipe;
         spinlock_t lock;                /* Pipeline state and queue flags */
@@ -96,6 +100,7 @@ struct isp_pipeline {
         unsigned int max_rate;
         atomic_t frame_number;
         bool do_propagation; /* of frame number */
+        bool error;
         struct v4l2_fract max_timeperframe;
 };
 
@@ -194,8 +199,7 @@ void omap3isp_video_cleanup(struct isp_video *video);
 int omap3isp_video_register(struct isp_video *video,
                             struct v4l2_device *vdev);
 void omap3isp_video_unregister(struct isp_video *video);
-struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video,
-                                              unsigned int error);
+struct isp_buffer *omap3isp_video_buffer_next(struct isp_video *video);
 void omap3isp_video_resume(struct isp_video *video, int continuous);
 struct media_pad *omap3isp_video_remote_pad(struct isp_video *video);
 
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
index 122b45760f0d..ebc2c7e39233 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
@@ -2546,8 +2546,9 @@ struct pvr2_hdw *pvr2_hdw_create(struct usb_interface *intf,
         }
 
         /* Define and configure additional controls from cx2341x module. */
-        hdw->mpeg_ctrl_info = kzalloc(
-                sizeof(*(hdw->mpeg_ctrl_info)) * MPEGDEF_COUNT, GFP_KERNEL);
+        hdw->mpeg_ctrl_info = kcalloc(MPEGDEF_COUNT,
+                                      sizeof(*(hdw->mpeg_ctrl_info)),
+                                      GFP_KERNEL);
         if (!hdw->mpeg_ctrl_info) goto fail;
         for (idx = 0; idx < MPEGDEF_COUNT; idx++) {
                 cptr = hdw->controls + idx + CTRLDEF_COUNT;
diff --git a/drivers/media/video/pwc/pwc-ctrl.c b/drivers/media/video/pwc/pwc-ctrl.c
index 3977addf3ba8..905d41d90c6a 100644
--- a/drivers/media/video/pwc/pwc-ctrl.c
+++ b/drivers/media/video/pwc/pwc-ctrl.c
@@ -102,8 +102,6 @@ static struct Nala_table_entry Nala_table[PSZ_MAX][PWC_FPS_MAX_NALA] =
 #include "pwc-nala.h"
 };
 
-static void pwc_set_image_buffer_size(struct pwc_device *pdev);
-
 /****************************************************************************/
 
 static int _send_control_msg(struct pwc_device *pdev,
@@ -113,10 +111,9 @@ static int _send_control_msg(struct pwc_device *pdev,
         void *kbuf = NULL;
 
         if (buflen) {
-                kbuf = kmalloc(buflen, GFP_KERNEL); /* not allowed on stack */
+                kbuf = kmemdup(buf, buflen, GFP_KERNEL); /* not allowed on stack */
                 if (kbuf == NULL)
                         return -ENOMEM;
-                memcpy(kbuf, buf, buflen);
         }
 
         rc = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
@@ -171,7 +168,8 @@ int send_control_msg(struct pwc_device *pdev,
                 request, value, pdev->vcinterface, buf, buflen);
 }
 
-static 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,
+                               int *compression)
 {
         unsigned char buf[3];
         int ret, fps;
@@ -221,10 +219,10 @@ static int set_video_mode_Nala(struct pwc_device *pdev, int size, int frames)
 
         /* Set various parameters */
         pdev->vframes = frames;
-        pdev->vsize = size;
         pdev->valternate = pEntry->alternate;
-        pdev->image = pwc_image_sizes[size];
-        pdev->frame_size = (pdev->image.x * pdev->image.y * 3) / 2;
+        pdev->width  = pwc_image_sizes[size][0];
+        pdev->height = pwc_image_sizes[size][1];
+        pdev->frame_size = (pdev->width * pdev->height * 3) / 2;
         if (pEntry->compressed) {
                 if (pdev->release < 5) { /* 4 fold compression */
                         pdev->vbandlength = 528;
@@ -237,38 +235,40 @@ static int set_video_mode_Nala(struct pwc_device *pdev, int size, int frames)
         }
         else
                 pdev->vbandlength = 0;
+
+        /* Let pwc-if.c:isoc_init know we don't support higher compression */
+        *compression = 3;
+
         return 0;
 }
 
 
-static 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)
 {
         unsigned char buf[13];
         const struct Timon_table_entry *pChoose;
         int ret, fps;
 
-        if (size >= PSZ_MAX || frames < 5 || frames > 30 || compression < 0 || compression > 3)
+        if (size >= PSZ_MAX || frames < 5 || frames > 30 ||
+            *compression < 0 || *compression > 3)
                 return -EINVAL;
         if (size == PSZ_VGA && frames > 15)
                 return -EINVAL;
         fps = (frames / 5) - 1;
 
-        /* Find a supported framerate with progressively higher compression ratios
-           if the preferred ratio is not available.
-        */
+        /* Find a supported framerate with progressively higher compression */
         pChoose = NULL;
-        while (compression <= 3) {
-           pChoose = &Timon_table[size][fps][compression];
-           if (pChoose->alternate != 0)
-             break;
-           compression++;
+        while (*compression <= 3) {
+                pChoose = &Timon_table[size][fps][*compression];
+                if (pChoose->alternate != 0)
+                        break;
+                (*compression)++;
         }
         if (pChoose == NULL || pChoose->alternate == 0)
                 return -ENOENT; /* Not supported. */
 
         memcpy(buf, pChoose->mode, 13);
-        if (snapshot)
-                buf[0] |= 0x80;
         ret = send_video_command(pdev, pdev->vendpoint, buf, 13);
         if (ret < 0)
                 return ret;
@@ -284,55 +284,38 @@ static int set_video_mode_Timon(struct pwc_device *pdev, int size, int frames, i
 
         /* Set various parameters */
         pdev->vframes = frames;
-        pdev->vsize = size;
-        pdev->vsnapshot = snapshot;
         pdev->valternate = pChoose->alternate;
-        pdev->image = pwc_image_sizes[size];
+        pdev->width  = pwc_image_sizes[size][0];
+        pdev->height = pwc_image_sizes[size][1];
         pdev->vbandlength = pChoose->bandlength;
         if (pChoose->bandlength > 0)
-                pdev->frame_size = (pChoose->bandlength * pdev->image.y) / 4;
+                pdev->frame_size = (pChoose->bandlength * pdev->height) / 4;
         else
-                pdev->frame_size = (pdev->image.x * pdev->image.y * 12) / 8;
+                pdev->frame_size = (pdev->width * pdev->height * 12) / 8;
         return 0;
 }
 
 
-static 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)
 {
         const struct Kiara_table_entry *pChoose = NULL;
         int fps, ret;
         unsigned char buf[12];
-        struct Kiara_table_entry RawEntry = {6, 773, 1272, {0xAD, 0xF4, 0x10, 0x27, 0xB6, 0x24, 0x96, 0x02, 0x30, 0x05, 0x03, 0x80}};
 
-        if (size >= PSZ_MAX || frames < 5 || frames > 30 || compression < 0 || compression > 3)
+        if (size >= PSZ_MAX || frames < 5 || frames > 30 ||
+            *compression < 0 || *compression > 3)
                 return -EINVAL;
         if (size == PSZ_VGA && frames > 15)
                 return -EINVAL;
         fps = (frames / 5) - 1;
 
-        /* special case: VGA @ 5 fps and snapshot is raw bayer mode */
-        if (size == PSZ_VGA && frames == 5 && snapshot && pdev->pixfmt != V4L2_PIX_FMT_YUV420)
-        {
-                /* Only available in case the raw palette is selected or
-                   we have the decompressor available. This mode is
-                   only available in compressed form
-                */
-                PWC_DEBUG_SIZE("Choosing VGA/5 BAYER mode.\n");
-                pChoose = &RawEntry;
-        }
-        else
-        {
-                /* Find a supported framerate with progressively higher compression ratios
-                   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)
-                                break;
-                        compression++;
-                }
+        /* Find a supported framerate with progressively higher compression */
+        while (*compression <= 3) {
+                pChoose = &Kiara_table[size][fps][*compression];
+                if (pChoose->alternate != 0)
+                        break;
+                (*compression)++;
         }
         if (pChoose == NULL || pChoose->alternate == 0)
                 return -ENOENT; /* Not supported. */
@@ -341,8 +324,6 @@ static int set_video_mode_Kiara(struct pwc_device *pdev, int size, int frames, i
 
         /* usb_control_msg won't take staticly allocated arrays as argument?? */
         memcpy(buf, pChoose->mode, 12);
-        if (snapshot)
-                buf[0] |= 0x80;
 
         /* Firmware bug: video endpoint is 5, but commands are sent to endpoint 4 */
         ret = send_video_command(pdev, 4 /* pdev->vendpoint */, buf, 12);
@@ -359,61 +340,43 @@ static int set_video_mode_Kiara(struct pwc_device *pdev, int size, int frames, i
         memcpy(pdev->cmd_buf, buf, 12);
         /* All set and go */
         pdev->vframes = frames;
-        pdev->vsize = size;
-        pdev->vsnapshot = snapshot;
         pdev->valternate = pChoose->alternate;
-        pdev->image = pwc_image_sizes[size];
+        pdev->width  = pwc_image_sizes[size][0];
+        pdev->height = pwc_image_sizes[size][1];
         pdev->vbandlength = pChoose->bandlength;
         if (pdev->vbandlength > 0)
-                pdev->frame_size = (pdev->vbandlength * pdev->image.y) / 4;
+                pdev->frame_size = (pdev->vbandlength * pdev->height) / 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);
+                pdev->frame_size = (pdev->width * pdev->height * 12) / 8;
+        PWC_TRACE("frame_size=%d, vframes=%d, vsize=%d, vbandlength=%d\n",
+            pdev->frame_size, pdev->vframes, size, pdev->vbandlength);
         return 0;
 }
 
-
-
-/**
-   @pdev: device structure
-   @width: viewport width
-   @height: viewport height
-   @frame: framerate, in fps
-   @compression: preferred compression ratio
-   @snapshot: snapshot mode or streaming
- */
-int pwc_set_video_mode(struct pwc_device *pdev, int width, int height, int frames, int compression, int snapshot)
+int pwc_set_video_mode(struct pwc_device *pdev, int width, int height,
+        int frames, int *compression)
 {
         int ret, size;
 
         PWC_DEBUG_FLOW("set_video_mode(%dx%d @ %d, pixfmt %08x).\n", width, height, frames, pdev->pixfmt);
-        size = pwc_decode_size(pdev, width, height);
-        if (size < 0) {
-                PWC_DEBUG_MODULE("Could not find suitable size.\n");
-                return -ERANGE;
-        }
+        size = pwc_get_size(pdev, width, height);
         PWC_TRACE("decode_size = %d.\n", size);
 
         if (DEVICE_USE_CODEC1(pdev->type)) {
-                ret = set_video_mode_Nala(pdev, size, frames);
+                ret = set_video_mode_Nala(pdev, size, frames, compression);
 
         } else if (DEVICE_USE_CODEC3(pdev->type)) {
-                ret = set_video_mode_Kiara(pdev, size, frames, compression, snapshot);
+                ret = set_video_mode_Kiara(pdev, size, frames, compression);
 
         } else {
-                ret = set_video_mode_Timon(pdev, size, frames, compression, snapshot);
+                ret = set_video_mode_Timon(pdev, size, frames, compression);
         }
         if (ret < 0) {
                 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->vcompression = compression;
         pdev->frame_total_size = pdev->frame_size + pdev->frame_header_size + pdev->frame_trailer_size;
-        pwc_set_image_buffer_size(pdev);
-        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);
+        PWC_DEBUG_SIZE("Set resolution to %dx%d\n", pdev->width, pdev->height);
         return 0;
 }
 
@@ -470,34 +433,6 @@ unsigned int pwc_get_fps(struct pwc_device *pdev, unsigned int index, unsigned i
         return ret;
 }
 
-static void pwc_set_image_buffer_size(struct pwc_device *pdev)
-{
-        int factor = 0;
-
-        /* for V4L2_PIX_FMT_YUV420 */
-        switch (pdev->pixfmt) {
-        case V4L2_PIX_FMT_YUV420:
-                factor = 6;
-                break;
-        case V4L2_PIX_FMT_PWC1:
-        case V4L2_PIX_FMT_PWC2:
-                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;
-}
-
 int pwc_get_u8_ctrl(struct pwc_device *pdev, u8 request, u16 value, int *data)
 {
         int ret;
@@ -598,54 +533,6 @@ void pwc_camera_power(struct pwc_device *pdev, int power)
                           power ? "on" : "off", r);
 }
 
-static int pwc_set_wb_speed(struct pwc_device *pdev, int speed)
-{
-        unsigned char buf;
-
-        /* useful range is 0x01..0x20 */
-        buf = speed / 0x7f0;
-        return send_control_msg(pdev,
-                SET_CHROM_CTL, AWB_CONTROL_SPEED_FORMATTER, &buf, sizeof(buf));
-}
-
-static int pwc_get_wb_speed(struct pwc_device *pdev, int *value)
-{
-        unsigned char buf;
-        int ret;
-
-        ret = recv_control_msg(pdev,
-                GET_CHROM_CTL, AWB_CONTROL_SPEED_FORMATTER, &buf, sizeof(buf));
-        if (ret < 0)
-                return ret;
-        *value = buf * 0x7f0;
-        return 0;
-}
-
-
-static int pwc_set_wb_delay(struct pwc_device *pdev, int delay)
-{
-        unsigned char buf;
-
-        /* useful range is 0x01..0x3F */
-        buf = (delay >> 10);
-        return send_control_msg(pdev,
-                SET_CHROM_CTL, AWB_CONTROL_DELAY_FORMATTER, &buf, sizeof(buf));
-}
-
-static int pwc_get_wb_delay(struct pwc_device *pdev, int *value)
-{
-        unsigned char buf;
-        int ret;
-
-        ret = recv_control_msg(pdev,
-                GET_CHROM_CTL, AWB_CONTROL_DELAY_FORMATTER, &buf, sizeof(buf));
-        if (ret < 0)
-                return ret;
-        *value = buf << 10;
-        return 0;
-}
-
-
 int pwc_set_leds(struct pwc_device *pdev, int on_value, int off_value)
 {
         unsigned char buf[2];
@@ -675,108 +562,6 @@ int pwc_set_leds(struct pwc_device *pdev, int on_value, int off_value)
         return r;
 }
 
-static int pwc_get_leds(struct pwc_device *pdev, int *on_value, int *off_value)
-{
-        unsigned char buf[2];
-        int ret;
-
-        if (pdev->type < 730) {
-                *on_value = -1;
-                *off_value = -1;
-                return 0;
-        }
-
-        ret = recv_control_msg(pdev,
-                GET_STATUS_CTL, LED_FORMATTER, &buf, sizeof(buf));
-        if (ret < 0)
-                return ret;
-        *on_value = buf[0] * 100;
-        *off_value = buf[1] * 100;
-        return 0;
-}
-
-static int _pwc_mpt_reset(struct pwc_device *pdev, int flags)
-{
-        unsigned char buf;
-
-        buf = flags & 0x03; // only lower two bits are currently used
-        return send_control_msg(pdev,
-                SET_MPT_CTL, PT_RESET_CONTROL_FORMATTER, &buf, sizeof(buf));
-}
-
-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];
-
-        /* set new relative angle; angles are expressed in degrees * 100,
-           but cam as .5 degree resolution, hence divide by 200. Also
-           the angle must be multiplied by 64 before it's send to
-           the cam (??)
-         */
-        pan  =  64 * pan  / 100;
-        tilt = -64 * tilt / 100; /* positive tilt is down, which is not what the user would expect */
-        buf[0] = pan & 0xFF;
-        buf[1] = (pan >> 8) & 0xFF;
-        buf[2] = tilt & 0xFF;
-        buf[3] = (tilt >> 8) & 0xFF;
-        return send_control_msg(pdev,
-                SET_MPT_CTL, PT_RELATIVE_CONTROL_FORMATTER, &buf, sizeof(buf));
-}
-
-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];
-
-        ret = recv_control_msg(pdev,
-                GET_MPT_CTL, PT_STATUS_FORMATTER, &buf, sizeof(buf));
-        if (ret < 0)
-                return ret;
-        status->status = buf[0] & 0x7; // 3 bits are used for reporting
-        status->time_pan = (buf[1] << 8) + buf[2];
-        status->time_tilt = (buf[3] << 8) + buf[4];
-        return 0;
-}
-
 #ifdef CONFIG_USB_PWC_DEBUG
 int pwc_get_cmos_sensor(struct pwc_device *pdev, int *sensor)
 {
@@ -801,420 +586,3 @@ int pwc_get_cmos_sensor(struct pwc_device *pdev, int *sensor)
         return 0;
 }
 #endif
-
- /* 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 */
-
-/*
- * Our ctrls use native values, but the old custom pwc ioctl interface expects
- * values from 0 - 65535, define 2 helper functions to scale things. */
-static int pwc_ioctl_g_ctrl(struct v4l2_ctrl *ctrl)
-{
-        return v4l2_ctrl_g_ctrl(ctrl) * 65535 / ctrl->maximum;
-}
-
-static int pwc_ioctl_s_ctrl(struct v4l2_ctrl *ctrl, int val)
-{
-        return v4l2_ctrl_s_ctrl(ctrl, val * ctrl->maximum / 65535);
-}
-
-long pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
-{
-        long ret = 0;
-
-        switch(cmd) {
-        case VIDIOCPWCRUSER:
-                ret = pwc_button_ctrl(pdev, RESTORE_USER_DEFAULTS_FORMATTER);
-                break;
-
-        case VIDIOCPWCSUSER:
-                ret = pwc_button_ctrl(pdev, SAVE_USER_DEFAULTS_FORMATTER);
-                break;
-
-        case VIDIOCPWCFACTORY:
-                ret = pwc_button_ctrl(pdev, RESTORE_FACTORY_DEFAULTS_FORMATTER);
-                break;
-
-        case VIDIOCPWCSCQUAL:
-        {
-                ARG_DEF(int, qual)
-
-                if (vb2_is_streaming(&pdev->vb_queue)) {
-                        ret = -EBUSY;
-                        break;
-                }
-
-                ARG_IN(qual)
-                if (ARGR(qual) < 0 || ARGR(qual) > 3)
-                        ret = -EINVAL;
-                else
-                        ret = pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, ARGR(qual), pdev->vsnapshot);
-                break;
-        }
-
-        case VIDIOCPWCGCQUAL:
-        {
-                ARG_DEF(int, qual)
-
-                ARGR(qual) = pdev->vcompression;
-                ARG_OUT(qual)
-                break;
-        }
-
-        case VIDIOCPWCPROBE:
-        {
-                ARG_DEF(struct pwc_probe, probe)
-
-                strcpy(ARGR(probe).name, pdev->vdev.name);
-                ARGR(probe).type = pdev->type;
-                ARG_OUT(probe)
-                break;
-        }
-
-        case VIDIOCPWCGSERIAL:
-        {
-                ARG_DEF(struct pwc_serial, serial)
-
-                strcpy(ARGR(serial).serial, pdev->serial);
-                ARG_OUT(serial)
-                break;
-        }
-
-        case VIDIOCPWCSAGC:
-        {
-                ARG_DEF(int, agc)
-                ARG_IN(agc)
-                ret = v4l2_ctrl_s_ctrl(pdev->autogain, ARGR(agc) < 0);
-                if (ret == 0 && ARGR(agc) >= 0)
-                        ret = pwc_ioctl_s_ctrl(pdev->gain, ARGR(agc));
-                break;
-        }
-
-        case VIDIOCPWCGAGC:
-        {
-                ARG_DEF(int, agc)
-                if (v4l2_ctrl_g_ctrl(pdev->autogain))
-                        ARGR(agc) = -1;
-                else
-                        ARGR(agc) = pwc_ioctl_g_ctrl(pdev->gain);
-                ARG_OUT(agc)
-                break;
-        }
-
-        case VIDIOCPWCSSHUTTER:
-        {
-                ARG_DEF(int, shutter)
-                ARG_IN(shutter)
-                ret = v4l2_ctrl_s_ctrl(pdev->exposure_auto,
-                                       /* Menu idx 0 = auto, idx 1 = manual */
-                                       ARGR(shutter) >= 0);
-                if (ret == 0 && ARGR(shutter) >= 0)
-                        ret = pwc_ioctl_s_ctrl(pdev->exposure, ARGR(shutter));
-                break;
-        }
-
-        case VIDIOCPWCSAWB:
-        {
-                ARG_DEF(struct pwc_whitebalance, wb)
-                ARG_IN(wb)
-                ret = v4l2_ctrl_s_ctrl(pdev->auto_white_balance,
-                                       ARGR(wb).mode);
-                if (ret == 0 && ARGR(wb).mode == PWC_WB_MANUAL)
-                        ret = pwc_ioctl_s_ctrl(pdev->red_balance,
-                                               ARGR(wb).manual_red);
-                if (ret == 0 && ARGR(wb).mode == PWC_WB_MANUAL)
-                        ret = pwc_ioctl_s_ctrl(pdev->blue_balance,
-                                               ARGR(wb).manual_blue);
-                break;
-        }
-
-        case VIDIOCPWCGAWB:
-        {
-                ARG_DEF(struct pwc_whitebalance, wb)
-                ARGR(wb).mode = v4l2_ctrl_g_ctrl(pdev->auto_white_balance);
-                ARGR(wb).manual_red = ARGR(wb).read_red =
-                        pwc_ioctl_g_ctrl(pdev->red_balance);
-                ARGR(wb).manual_blue = ARGR(wb).read_blue =
-                        pwc_ioctl_g_ctrl(pdev->blue_balance);
-                ARG_OUT(wb)
-                break;
-        }
-
-        case VIDIOCPWCSAWBSPEED:
-        {
-                ARG_DEF(struct pwc_wb_speed, wbs)
-
-                if (ARGR(wbs).control_speed > 0) {
-                        ret = pwc_set_wb_speed(pdev, ARGR(wbs).control_speed);
-                }
-                if (ARGR(wbs).control_delay > 0) {
-                        ret = pwc_set_wb_delay(pdev, ARGR(wbs).control_delay);
-                }
-                break;
-        }
-
-        case VIDIOCPWCGAWBSPEED:
-        {
-                ARG_DEF(struct pwc_wb_speed, wbs)
-
-                ret = pwc_get_wb_speed(pdev, &ARGR(wbs).control_speed);
-                if (ret < 0)
-                        break;
-                ret = pwc_get_wb_delay(pdev, &ARGR(wbs).control_delay);
-                if (ret < 0)
-                        break;
-                ARG_OUT(wbs)
-                break;
-        }
-
-        case VIDIOCPWCSLED:
-        {
-                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:
-        {
-                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:
-        {
-                ARG_DEF(int, contour)
-                ARG_IN(contour)
-                ret = v4l2_ctrl_s_ctrl(pdev->autocontour, ARGR(contour) < 0);
-                if (ret == 0 && ARGR(contour) >= 0)
-                        ret = pwc_ioctl_s_ctrl(pdev->contour, ARGR(contour));
-                break;
-        }
-
-        case VIDIOCPWCGCONTOUR:
-        {
-                ARG_DEF(int, contour)
-                if (v4l2_ctrl_g_ctrl(pdev->autocontour))
-                        ARGR(contour) = -1;
-                else
-                        ARGR(contour) = pwc_ioctl_g_ctrl(pdev->contour);
-                ARG_OUT(contour)
-                break;
-        }
-
-        case VIDIOCPWCSBACKLIGHT:
-        {
-                ARG_DEF(int, backlight)
-                ARG_IN(backlight)
-                ret = v4l2_ctrl_s_ctrl(pdev->backlight, ARGR(backlight));
-                break;
-        }
-
-        case VIDIOCPWCGBACKLIGHT:
-        {
-                ARG_DEF(int, backlight)
-                ARGR(backlight) = v4l2_ctrl_g_ctrl(pdev->backlight);
-                ARG_OUT(backlight)
-                break;
-        }
-
-        case VIDIOCPWCSFLICKER:
-        {
-                ARG_DEF(int, flicker)
-                ARG_IN(flicker)
-                ret = v4l2_ctrl_s_ctrl(pdev->flicker, ARGR(flicker));
-                break;
-        }
-
-        case VIDIOCPWCGFLICKER:
-        {
-                ARG_DEF(int, flicker)
-                ARGR(flicker) = v4l2_ctrl_g_ctrl(pdev->flicker);
-                ARG_OUT(flicker)
-                break;
-        }
-
-        case VIDIOCPWCSDYNNOISE:
-        {
-                ARG_DEF(int, dynnoise)
-                ARG_IN(dynnoise)
-                ret = v4l2_ctrl_s_ctrl(pdev->noise_reduction, ARGR(dynnoise));
-                break;
-        }
-
-        case VIDIOCPWCGDYNNOISE:
-        {
-                ARG_DEF(int, dynnoise)
-                ARGR(dynnoise) = v4l2_ctrl_g_ctrl(pdev->noise_reduction);
-                ARG_OUT(dynnoise);
-                break;
-        }
-
-        case VIDIOCPWCGREALSIZE:
-        {
-                ARG_DEF(struct pwc_imagesize, size)
-
-                ARGR(size).width = pdev->image.x;
-                ARGR(size).height = pdev->image.y;
-                ARG_OUT(size)
-                break;
-        }
-
-        case VIDIOCPWCMPTRESET:
-        {
-                if (pdev->features & FEATURE_MOTOR_PANTILT)
-                {
-                        ARG_DEF(int, flags)
-
-                        ARG_IN(flags)
-                        ret = pwc_mpt_reset(pdev, ARGR(flags));
-                }
-                else
-                {
-                        ret = -ENXIO;
-                }
-                break;
-        }
-
-        case VIDIOCPWCMPTGRANGE:
-        {
-                if (pdev->features & FEATURE_MOTOR_PANTILT)
-                {
-                        ARG_DEF(struct pwc_mpt_range, range)
-
-                        ARGR(range) = pdev->angle_range;
-                        ARG_OUT(range)
-                }
-                else
-                {
-                        ret = -ENXIO;
-                }
-                break;
-        }
-
-        case VIDIOCPWCMPTSANGLE:
-        {
-                int new_pan, new_tilt;
-
-                if (pdev->features & FEATURE_MOTOR_PANTILT)
-                {
-                        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 (ARGR(angles).absolute)
-                        {
-                                new_pan  = ARGR(angles).pan;
-                                new_tilt = ARGR(angles).tilt;
-                        }
-                        else
-                        {
-                                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
-                {
-                        ret = -ENXIO;
-                }
-                break;
-        }
-
-        case VIDIOCPWCMPTGANGLE:
-        {
-
-                if (pdev->features & FEATURE_MOTOR_PANTILT)
-                {
-                        ARG_DEF(struct pwc_mpt_angles, angles)
-
-                        ARGR(angles).absolute = 1;
-                        ARGR(angles).pan  = pdev->pan_angle;
-                        ARGR(angles).tilt = pdev->tilt_angle;
-                        ARG_OUT(angles)
-                }
-                else
-                {
-                        ret = -ENXIO;
-                }
-                break;
-        }
-
-        case VIDIOCPWCMPTSTATUS:
-        {
-                if (pdev->features & FEATURE_MOTOR_PANTILT)
-                {
-                        ARG_DEF(struct pwc_mpt_status, status)
-
-                        ret = pwc_mpt_get_status(pdev, ARGA(status));
-                        ARG_OUT(status)
-                }
-                else
-                {
-                        ret = -ENXIO;
-                }
-                break;
-        }
-
-        case VIDIOCPWCGVIDCMD:
-        {
-                ARG_DEF(struct pwc_video_command, vcmd);
-
-                ARGR(vcmd).type = pdev->type;
-                ARGR(vcmd).release = pdev->release;
-                ARGR(vcmd).command_len = pdev->cmd_len;
-                memcpy(&ARGR(vcmd).command_buf, pdev->cmd_buf, pdev->cmd_len);
-                ARGR(vcmd).bandlength = pdev->vbandlength;
-                ARGR(vcmd).frame_size = pdev->frame_size;
-                ARG_OUT(vcmd)
-                break;
-        }
-        /*
-        case VIDIOCPWCGVIDTABLE:
-        {
-                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;
-        }
-        */
-
-        default:
-                ret = -ENOIOCTLCMD;
-                break;
-        }
-
-        if (ret > 0)
-                return 0;
-        return ret;
-}
-
-
-/* vim: set cinoptions= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
diff --git a/drivers/media/video/pwc/pwc-dec23.c b/drivers/media/video/pwc/pwc-dec23.c
index 06a4e877ba40..2c6709112b2f 100644
--- a/drivers/media/video/pwc/pwc-dec23.c
+++ b/drivers/media/video/pwc/pwc-dec23.c
@@ -27,7 +27,6 @@
 #include "pwc-timon.h"
 #include "pwc-kiara.h"
 #include "pwc-dec23.h"
-#include <media/pwc-ioctl.h>
 
 #include <linux/string.h>
 #include <linux/slab.h>
@@ -51,13 +50,6 @@
 # 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] = {
@@ -315,6 +307,8 @@ int pwc_dec23_init(struct pwc_device *pwc, int type, unsigned char *cmd)
         }
         pdec = pwc->decompress_data;
 
+        mutex_init(&pdec->lock);
+
         if (DEVICE_USE_CODEC3(type)) {
                 flags = cmd[2] & 0x18;
                 if (flags == 8)
@@ -467,123 +461,6 @@ static void copy_image_block_CrCb(const int *src, unsigned char *dst, unsigned i
 #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
@@ -775,146 +652,45 @@ static void DecompressBand23(struct pwc_dec23_private *pdec,
 
 }
 
-#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)
+                          void *dst)
 {
-        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;
-
-                }
+        int bandlines_left, bytes_per_block;
+        struct pwc_dec23_private *pdec = pwc->decompress_data;
+
+        /* YUV420P image format */
+        unsigned char *pout_planar_y;
+        unsigned char *pout_planar_u;
+        unsigned char *pout_planar_v;
+        unsigned int   plane_size;
+
+        mutex_lock(&pdec->lock);
+
+        bandlines_left = pwc->height / 4;
+        bytes_per_block = pwc->width * 4;
+        plane_size = pwc->height * pwc->width;
+
+        pout_planar_y = dst;
+        pout_planar_u = dst + plane_size;
+        pout_planar_v = dst + plane_size + plane_size / 4;
+
+        while (bandlines_left--) {
+                DecompressBand23(pwc->decompress_data,
+                                 src,
+                                 pout_planar_y, pout_planar_u, pout_planar_v,
+                                 pwc->width, pwc->width);
+                src += pwc->vbandlength;
+                pout_planar_y += bytes_per_block;
+                pout_planar_u += pwc->width;
+                pout_planar_v += pwc->width;
         }
+        mutex_unlock(&pdec->lock);
 }
diff --git a/drivers/media/video/pwc/pwc-dec23.h b/drivers/media/video/pwc/pwc-dec23.h
index a0ac4f3dff81..d64a3c281af6 100644
--- a/drivers/media/video/pwc/pwc-dec23.h
+++ b/drivers/media/video/pwc/pwc-dec23.h
@@ -29,6 +29,8 @@
 
 struct pwc_dec23_private
 {
+        struct mutex lock;
+
   unsigned int scalebits;
   unsigned int nbitsmask, nbits; /* Number of bits of a color in the compressed stream */
 
@@ -52,6 +54,5 @@ struct pwc_dec23_private
 int pwc_dec23_init(struct pwc_device *pwc, int type, unsigned char *cmd);
 void pwc_dec23_decompress(const struct pwc_device *pwc,
                           const void *src,
-                          void *dst,
-                          int flags);
+                          void *dst);
 #endif
diff --git a/drivers/media/video/pwc/pwc-if.c b/drivers/media/video/pwc/pwc-if.c
index 01ff643e682d..943d37ad0d33 100644
--- a/drivers/media/video/pwc/pwc-if.c
+++ b/drivers/media/video/pwc/pwc-if.c
@@ -134,7 +134,6 @@ static int default_fps = 10;
 #endif
 static int power_save = -1;
 static int led_on = 100, led_off; /* defaults to LED that is on while in use */
-static int pwc_preferred_compression = 1; /* 0..3 = uncompressed..high */
 static struct {
         int type;
         char serial_number[30];
@@ -144,17 +143,15 @@ static struct {
 
 /***/
 
-static int pwc_video_open(struct file *file);
 static int pwc_video_close(struct file *file);
 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_mmap(struct file *file, struct vm_area_struct *vma);
-static void pwc_video_release(struct video_device *vfd);
 
 static const struct v4l2_file_operations pwc_fops = {
         .owner =        THIS_MODULE,
-        .open =         pwc_video_open,
+        .open =         v4l2_fh_open,
         .release =      pwc_video_close,
         .read =         pwc_video_read,
         .poll =         pwc_video_poll,
@@ -163,7 +160,7 @@ static const struct v4l2_file_operations pwc_fops = {
 };
 static struct video_device pwc_template = {
         .name =         "Philips Webcam",       /* Filled in later */
-        .release =      pwc_video_release,
+        .release =      video_device_release_empty,
         .fops =         &pwc_fops,
         .ioctl_ops =    &pwc_ioctl_ops,
 };
@@ -191,7 +188,6 @@ static void pwc_snapshot_button(struct pwc_device *pdev, int down)
 {
         if (down) {
                 PWC_TRACE("Snapshot button pressed.\n");
-                pdev->snapshot_button_status = 1;
         } else {
                 PWC_TRACE("Snapshot button released.\n");
         }
@@ -375,6 +371,7 @@ static int pwc_isoc_init(struct pwc_device *pdev)
         int i, j, ret;
         struct usb_interface *intf;
         struct usb_host_interface *idesc = NULL;
+        int compression = 0; /* 0..3 = uncompressed..high */
 
         if (pdev->iso_init)
                 return 0;
@@ -386,6 +383,12 @@ static int pwc_isoc_init(struct pwc_device *pdev)
         pdev->visoc_errors = 0;
         udev = pdev->udev;
 
+retry:
+        /* We first try with low compression and then retry with a higher
+           compression setting if there is not enough bandwidth. */
+        ret = pwc_set_video_mode(pdev, pdev->width, pdev->height,
+                                 pdev->vframes, &compression);
+
         /* Get the current alternate interface, adjust packet size */
         intf = usb_ifnum_to_if(udev, 0);
         if (intf)
@@ -408,9 +411,12 @@ static int pwc_isoc_init(struct pwc_device *pdev)
         }
 
         /* Set alternate interface */
-        ret = 0;
         PWC_DEBUG_OPEN("Setting alternate interface %d\n", pdev->valternate);
         ret = usb_set_interface(pdev->udev, 0, pdev->valternate);
+        if (ret == -ENOSPC && compression < 3) {
+                compression++;
+                goto retry;
+        }
         if (ret < 0)
                 return ret;
 
@@ -454,6 +460,12 @@ static int pwc_isoc_init(struct pwc_device *pdev)
         /* link */
         for (i = 0; i < MAX_ISO_BUFS; i++) {
                 ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);
+                if (ret == -ENOSPC && compression < 3) {
+                        compression++;
+                        pdev->iso_init = 1;
+                        pwc_isoc_cleanup(pdev);
+                        goto retry;
+                }
                 if (ret) {
                         PWC_ERROR("isoc_init() submit_urb %d failed with error %d\n", i, ret);
                         pdev->iso_init = 1;
@@ -517,12 +529,11 @@ static void pwc_isoc_cleanup(struct pwc_device *pdev)
         PWC_DEBUG_OPEN("<< pwc_isoc_cleanup()\n");
 }
 
-/*
- * Release all queued buffers, no need to take queued_bufs_lock, since all
- * iso urbs have been killed when we're called so pwc_isoc_handler won't run.
- */
 static void pwc_cleanup_queued_bufs(struct pwc_device *pdev)
 {
+        unsigned long flags = 0;
+
+        spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
         while (!list_empty(&pdev->queued_bufs)) {
                 struct pwc_frame_buf *buf;
 
@@ -531,84 +542,7 @@ static void pwc_cleanup_queued_bufs(struct pwc_device *pdev)
                 list_del(&buf->list);
                 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
         }
-}
-
-/*********
- * sysfs
- *********/
-static struct pwc_device *cd_to_pwc(struct device *cd)
-{
-        struct video_device *vdev = to_video_device(cd);
-        return video_get_drvdata(vdev);
-}
-
-static ssize_t show_pan_tilt(struct device *class_dev,
-                             struct device_attribute *attr, 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 device *class_dev,
-                              struct device_attribute *attr,
-                              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 DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
-                   store_pan_tilt);
-
-static ssize_t show_snapshot_button_status(struct device *class_dev,
-                                           struct device_attribute *attr, 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 DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
-                   NULL);
-
-static int pwc_create_sysfs_files(struct pwc_device *pdev)
-{
-        int rc;
-
-        rc = device_create_file(&pdev->vdev.dev, &dev_attr_button);
-        if (rc)
-                goto err;
-        if (pdev->features & FEATURE_MOTOR_PANTILT) {
-                rc = device_create_file(&pdev->vdev.dev, &dev_attr_pan_tilt);
-                if (rc)
-                        goto err_button;
-        }
-
-        return 0;
-
-err_button:
-        device_remove_file(&pdev->vdev.dev, &dev_attr_button);
-err:
-        PWC_ERROR("Could not create sysfs files.\n");
-        return rc;
-}
-
-static void pwc_remove_sysfs_files(struct pwc_device *pdev)
-{
-        if (pdev->features & FEATURE_MOTOR_PANTILT)
-                device_remove_file(&pdev->vdev.dev, &dev_attr_pan_tilt);
-        device_remove_file(&pdev->vdev.dev, &dev_attr_button);
+        spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
 }
 
 #ifdef CONFIG_USB_PWC_DEBUG
@@ -644,25 +578,25 @@ static const char *pwc_sensor_type_to_string(unsigned int sensor_type)
 /***************************************************************************/
 /* Video4Linux functions */
 
-static int pwc_video_open(struct file *file)
+int pwc_test_n_set_capt_file(struct pwc_device *pdev, struct file *file)
 {
-        struct video_device *vdev = video_devdata(file);
-        struct pwc_device *pdev;
-
-        PWC_DEBUG_OPEN(">> video_open called(vdev = 0x%p).\n", vdev);
+        int r = 0;
 
-        pdev = video_get_drvdata(vdev);
-        if (!pdev->udev)
-                return -ENODEV;
-
-        file->private_data = vdev;
-        PWC_DEBUG_OPEN("<< video_open() returns 0.\n");
-        return 0;
+        mutex_lock(&pdev->capt_file_lock);
+        if (pdev->capt_file != NULL &&
+            pdev->capt_file != file) {
+                r = -EBUSY;
+                goto leave;
+        }
+        pdev->capt_file = file;
+leave:
+        mutex_unlock(&pdev->capt_file_lock);
+        return r;
 }
 
-static void pwc_video_release(struct video_device *vfd)
+static void pwc_video_release(struct v4l2_device *v)
 {
-        struct pwc_device *pdev = container_of(vfd, struct pwc_device, vdev);
+        struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
         int hint;
 
         /* search device_hint[] table if we occupy a slot, by any chance */
@@ -685,44 +619,33 @@ static void pwc_video_release(struct video_device *vfd)
 
 static int pwc_video_close(struct file *file)
 {
-        struct video_device *vdev = file->private_data;
-        struct pwc_device *pdev;
-
-        PWC_DEBUG_OPEN(">> video_close called(vdev = 0x%p).\n", vdev);
+        struct pwc_device *pdev = video_drvdata(file);
 
-        pdev = video_get_drvdata(vdev);
         if (pdev->capt_file == file) {
                 vb2_queue_release(&pdev->vb_queue);
                 pdev->capt_file = NULL;
         }
-
-        PWC_DEBUG_OPEN("<< video_close()\n");
-        return 0;
+        return v4l2_fh_release(file);
 }
 
 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;
-        struct pwc_device *pdev = video_get_drvdata(vdev);
+        struct pwc_device *pdev = video_drvdata(file);
 
         if (!pdev->udev)
                 return -ENODEV;
 
-        if (pdev->capt_file != NULL &&
-            pdev->capt_file != file)
+        if (pwc_test_n_set_capt_file(pdev, file))
                 return -EBUSY;
 
-        pdev->capt_file = file;
-
         return vb2_read(&pdev->vb_queue, buf, count, ppos,
                         file->f_flags & O_NONBLOCK);
 }
 
 static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
 {
-        struct video_device *vdev = file->private_data;
-        struct pwc_device *pdev = video_get_drvdata(vdev);
+        struct pwc_device *pdev = video_drvdata(file);
 
         if (!pdev->udev)
                 return POLL_ERR;
@@ -732,8 +655,7 @@ static unsigned int pwc_video_poll(struct file *file, poll_table *wait)
 
 static int pwc_video_mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct video_device *vdev = file->private_data;
-        struct pwc_device *pdev = video_get_drvdata(vdev);
+        struct pwc_device *pdev = video_drvdata(file);
 
         if (pdev->capt_file != file)
                 return -EBUSY;
@@ -749,6 +671,7 @@ static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
                                 unsigned int sizes[], void *alloc_ctxs[])
 {
         struct pwc_device *pdev = vb2_get_drv_priv(vq);
+        int size;
 
         if (*nbuffers < MIN_FRAMES)
                 *nbuffers = MIN_FRAMES;
@@ -757,7 +680,9 @@ static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
 
         *nplanes = 1;
 
-        sizes[0] = PAGE_ALIGN((pdev->abs_max.x * pdev->abs_max.y * 3) / 2);
+        size = pwc_get_size(pdev, MAX_WIDTH, MAX_HEIGHT);
+        sizes[0] = PAGE_ALIGN(pwc_image_sizes[size][0] *
+                              pwc_image_sizes[size][1] * 3 / 2);
 
         return 0;
 }
@@ -812,56 +737,59 @@ static void buffer_queue(struct vb2_buffer *vb)
         unsigned long flags = 0;
 
         spin_lock_irqsave(&pdev->queued_bufs_lock, flags);
-        list_add_tail(&buf->list, &pdev->queued_bufs);
+        /* Check the device has not disconnected between prep and queuing */
+        if (pdev->udev)
+                list_add_tail(&buf->list, &pdev->queued_bufs);
+        else
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
         spin_unlock_irqrestore(&pdev->queued_bufs_lock, flags);
 }
 
 static int start_streaming(struct vb2_queue *vq, unsigned int count)
 {
         struct pwc_device *pdev = vb2_get_drv_priv(vq);
+        int r;
 
-        if (!pdev->udev)
-                return -ENODEV;
+        mutex_lock(&pdev->udevlock);
+        if (!pdev->udev) {
+                r = -ENODEV;
+                goto leave;
+        }
 
         /* Turn on camera and set LEDS on */
         pwc_camera_power(pdev, 1);
-        if (pdev->power_save) {
-                /* Restore video mode */
-                pwc_set_video_mode(pdev, pdev->view.x, pdev->view.y,
-                                   pdev->vframes, pdev->vcompression,
-                                   pdev->vsnapshot);
-        }
         pwc_set_leds(pdev, led_on, led_off);
 
-        return pwc_isoc_init(pdev);
+        r = pwc_isoc_init(pdev);
+        if (r) {
+                /* If we failed turn camera and LEDS back off */
+                pwc_set_leds(pdev, 0, 0);
+                pwc_camera_power(pdev, 0);
+                /* And cleanup any queued bufs!! */
+                pwc_cleanup_queued_bufs(pdev);
+        }
+leave:
+        mutex_unlock(&pdev->udevlock);
+        return r;
 }
 
 static int stop_streaming(struct vb2_queue *vq)
 {
         struct pwc_device *pdev = vb2_get_drv_priv(vq);
 
+        mutex_lock(&pdev->udevlock);
         if (pdev->udev) {
                 pwc_set_leds(pdev, 0, 0);
                 pwc_camera_power(pdev, 0);
                 pwc_isoc_cleanup(pdev);
         }
+        mutex_unlock(&pdev->udevlock);
+
         pwc_cleanup_queued_bufs(pdev);
 
         return 0;
 }
 
-static void pwc_lock(struct vb2_queue *vq)
-{
-        struct pwc_device *pdev = vb2_get_drv_priv(vq);
-        mutex_lock(&pdev->modlock);
-}
-
-static void pwc_unlock(struct vb2_queue *vq)
-{
-        struct pwc_device *pdev = vb2_get_drv_priv(vq);
-        mutex_unlock(&pdev->modlock);
-}
-
 static struct vb2_ops pwc_vb_queue_ops = {
         .queue_setup            = queue_setup,
         .buf_init               = buffer_init,
@@ -871,8 +799,6 @@ static struct vb2_ops pwc_vb_queue_ops = {
         .buf_queue              = buffer_queue,
         .start_streaming        = start_streaming,
         .stop_streaming         = stop_streaming,
-        .wait_prepare           = pwc_unlock,
-        .wait_finish            = pwc_lock,
 };
 
 /***************************************************************************/
@@ -889,6 +815,7 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         int vendor_id, product_id, type_id;
         int hint, rc;
         int features = 0;
+        int compression = 0;
         int video_nr = -1; /* default: use next available device */
         int my_power_save = power_save;
         char serial_number[30], *name;
@@ -1150,27 +1077,15 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         }
         pdev->type = type_id;
         pdev->vframes = default_fps;
-        strcpy(pdev->serial, serial_number);
         pdev->features = features;
-        if (vendor_id == 0x046D && product_id == 0x08B5) {
-                /* Logitech QuickCam Orbit
-                   The ranges have been determined experimentally; they may differ from cam to cam.
-                   Also, the exact ranges left-right and up-down are different for my cam
-                  */
-                pdev->angle_range.pan_min  = -7000;
-                pdev->angle_range.pan_max  =  7000;
-                pdev->angle_range.tilt_min = -3000;
-                pdev->angle_range.tilt_max =  2500;
-        }
         pwc_construct(pdev); /* set min/max sizes correct */
 
-        mutex_init(&pdev->modlock);
+        mutex_init(&pdev->capt_file_lock);
         mutex_init(&pdev->udevlock);
         spin_lock_init(&pdev->queued_bufs_lock);
         INIT_LIST_HEAD(&pdev->queued_bufs);
 
         pdev->udev = udev;
-        pdev->vcompression = pwc_preferred_compression;
         pdev->power_save = my_power_save;
 
         /* Init videobuf2 queue structure */
@@ -1185,9 +1100,8 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
 
         /* Init video_device structure */
         memcpy(&pdev->vdev, &pwc_template, sizeof(pwc_template));
-        pdev->vdev.parent = &intf->dev;
-        pdev->vdev.lock = &pdev->modlock;
         strcpy(pdev->vdev.name, name);
+        set_bit(V4L2_FL_USE_FH_PRIO, &pdev->vdev.flags);
         video_set_drvdata(&pdev->vdev, pdev);
 
         pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
@@ -1211,9 +1125,6 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         if (hint < MAX_DEV_HINTS)
                 device_hint[hint].pdev = pdev;
 
-        PWC_DEBUG_PROBE("probe() function returning struct at 0x%p.\n", pdev);
-        usb_set_intfdata(intf, pdev);
-
 #ifdef CONFIG_USB_PWC_DEBUG
         /* Query sensor type */
         if (pwc_get_cmos_sensor(pdev, &rc) >= 0) {
@@ -1227,8 +1138,8 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         pwc_set_leds(pdev, 0, 0);
 
         /* Setup intial videomode */
-        rc = pwc_set_video_mode(pdev, pdev->view_max.x, pdev->view_max.y,
-                                pdev->vframes, pdev->vcompression, 0);
+        rc = pwc_set_video_mode(pdev, MAX_WIDTH, MAX_HEIGHT, pdev->vframes,
+                                &compression);
         if (rc)
                 goto err_free_mem;
 
@@ -1239,20 +1150,25 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
                 goto err_free_mem;
         }
 
-        pdev->vdev.ctrl_handler = &pdev->ctrl_handler;
-
         /* And powerdown the camera until streaming starts */
         pwc_camera_power(pdev, 0);
 
+        /* Register the v4l2_device structure */
+        pdev->v4l2_dev.release = pwc_video_release;
+        rc = v4l2_device_register(&intf->dev, &pdev->v4l2_dev);
+        if (rc) {
+                PWC_ERROR("Failed to register v4l2-device (%d).\n", rc);
+                goto err_free_controls;
+        }
+
+        pdev->v4l2_dev.ctrl_handler = &pdev->ctrl_handler;
+        pdev->vdev.v4l2_dev = &pdev->v4l2_dev;
+
         rc = video_register_device(&pdev->vdev, VFL_TYPE_GRABBER, video_nr);
         if (rc < 0) {
                 PWC_ERROR("Failed to register as video device (%d).\n", rc);
-                goto err_free_controls;
+                goto err_unregister_v4l2_dev;
         }
-        rc = pwc_create_sysfs_files(pdev);
-        if (rc)
-                goto err_video_unreg;
-
         PWC_INFO("Registered as %s.\n", video_device_node_name(&pdev->vdev));
 
 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
@@ -1261,7 +1177,6 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         if (!pdev->button_dev) {
                 PWC_ERROR("Err, insufficient memory for webcam snapshot button device.");
                 rc = -ENOMEM;
-                pwc_remove_sysfs_files(pdev);
                 goto err_video_unreg;
         }
 
@@ -1279,7 +1194,6 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         if (rc) {
                 input_free_device(pdev->button_dev);
                 pdev->button_dev = NULL;
-                pwc_remove_sysfs_files(pdev);
                 goto err_video_unreg;
         }
 #endif
@@ -1287,13 +1201,14 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
         return 0;
 
 err_video_unreg:
-        if (hint < MAX_DEV_HINTS)
-                device_hint[hint].pdev = NULL;
         video_unregister_device(&pdev->vdev);
+err_unregister_v4l2_dev:
+        v4l2_device_unregister(&pdev->v4l2_dev);
 err_free_controls:
         v4l2_ctrl_handler_free(&pdev->ctrl_handler);
 err_free_mem:
-        usb_set_intfdata(intf, NULL);
+        if (hint < MAX_DEV_HINTS)
+                device_hint[hint].pdev = NULL;
         kfree(pdev);
         return rc;
 }
@@ -1301,27 +1216,26 @@ err_free_mem:
 /* The user yanked out the cable... */
 static void usb_pwc_disconnect(struct usb_interface *intf)
 {
-        struct pwc_device *pdev  = usb_get_intfdata(intf);
+        struct v4l2_device *v = usb_get_intfdata(intf);
+        struct pwc_device *pdev = container_of(v, struct pwc_device, v4l2_dev);
 
         mutex_lock(&pdev->udevlock);
-        mutex_lock(&pdev->modlock);
-
-        usb_set_intfdata(intf, NULL);
         /* No need to keep the urbs around after disconnection */
         pwc_isoc_cleanup(pdev);
-        pwc_cleanup_queued_bufs(pdev);
         pdev->udev = NULL;
-
-        mutex_unlock(&pdev->modlock);
         mutex_unlock(&pdev->udevlock);
 
-        pwc_remove_sysfs_files(pdev);
+        pwc_cleanup_queued_bufs(pdev);
+
         video_unregister_device(&pdev->vdev);
+        v4l2_device_unregister(&pdev->v4l2_dev);
 
 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
         if (pdev->button_dev)
                 input_unregister_device(pdev->button_dev);
 #endif
+
+        v4l2_device_put(&pdev->v4l2_dev);
 }
 
 
@@ -1330,7 +1244,6 @@ static void usb_pwc_disconnect(struct usb_interface *intf)
  */
 
 static int fps;
-static int compression = -1;
 static int leds[2] = { -1, -1 };
 static unsigned int leds_nargs;
 static char *dev_hint[MAX_DEV_HINTS];
@@ -1341,7 +1254,6 @@ module_param(fps, int, 0444);
 module_param_named(trace, pwc_trace, int, 0644);
 #endif
 module_param(power_save, int, 0644);
-module_param(compression, int, 0444);
 module_param_array(leds, int, &leds_nargs, 0444);
 module_param_array(dev_hint, charp, &dev_hint_nargs, 0444);
 
@@ -1350,7 +1262,6 @@ MODULE_PARM_DESC(fps, "Initial frames per second. Varies with model, useful rang
 MODULE_PARM_DESC(trace, "For debugging purposes");
 #endif
 MODULE_PARM_DESC(power_save, "Turn power saving for new cameras on or off");
-MODULE_PARM_DESC(compression, "Preferred compression quality. Range 0 (uncompressed) to 3 (high compression)");
 MODULE_PARM_DESC(leds, "LED on,off time in milliseconds");
 MODULE_PARM_DESC(dev_hint, "Device node hints");
 
@@ -1384,14 +1295,6 @@ static int __init usb_pwc_init(void)
                 PWC_DEBUG_MODULE("Default framerate set to %d.\n", default_fps);
         }
 
-        if (compression >= 0) {
-                if (compression > 3) {
-                        PWC_ERROR("Invalid compression setting; use a number between 0 (uncompressed) and 3 (high).\n");
-                        return -EINVAL;
-                }
-                pwc_preferred_compression = compression;
-                PWC_DEBUG_MODULE("Preferred compression set to %d.\n", pwc_preferred_compression);
-        }
         if (leds[0] >= 0)
                 led_on = leds[0];
         if (leds[1] >= 0)
diff --git a/drivers/media/video/pwc/pwc-kiara.h b/drivers/media/video/pwc/pwc-kiara.h
index 047dad8c15f7..8e02b7ac2139 100644
--- a/drivers/media/video/pwc/pwc-kiara.h
+++ b/drivers/media/video/pwc/pwc-kiara.h
@@ -27,7 +27,7 @@
 #ifndef PWC_KIARA_H
 #define PWC_KIARA_H
 
-#include <media/pwc-ioctl.h>
+#include "pwc.h"
 
 #define PWC_FPS_MAX_KIARA 6
 
diff --git a/drivers/media/video/pwc/pwc-misc.c b/drivers/media/video/pwc/pwc-misc.c
index 0b031336eab8..23a55b5814fc 100644
--- a/drivers/media/video/pwc/pwc-misc.c
+++ b/drivers/media/video/pwc/pwc-misc.c
@@ -27,67 +27,47 @@
 
 #include "pwc.h"
 
-const struct pwc_coord pwc_image_sizes[PSZ_MAX] =
+const int pwc_image_sizes[PSZ_MAX][2] =
 {
-        { 128,  96, 0 }, /* sqcif */
-        { 160, 120, 0 }, /* qsif */
-        { 176, 144, 0 }, /* qcif */
-        { 320, 240, 0 }, /* sif */
-        { 352, 288, 0 }, /* cif */
-        { 640, 480, 0 }, /* vga */
+        { 128,  96 }, /* sqcif */
+        { 160, 120 }, /* qsif */
+        { 176, 144 }, /* qcif */
+        { 320, 240 }, /* sif */
+        { 352, 288 }, /* cif */
+        { 640, 480 }, /* vga */
 };
 
 /* x,y -> PSZ_ */
-int pwc_decode_size(struct pwc_device *pdev, int width, int height)
+int pwc_get_size(struct pwc_device *pdev, int width, int height)
 {
-        int i, find;
-
-        /* Make sure we don't go beyond our max size.
-           NB: we have different limits for RAW and normal modes. In case
-           you don't have the decompressor loaded or use RAW mode,
-           the maximum viewable size is smaller.
-        */
-        if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
-        {
-                if (width > pdev->abs_max.x || height > pdev->abs_max.y)
-                {
-                        PWC_DEBUG_SIZE("VIDEO_PALETTE_RAW: going beyond abs_max.\n");
-                        return -1;
-                }
-        }
-        else
-        {
-                if (width > pdev->view_max.x || height > pdev->view_max.y)
-                {
-                        PWC_DEBUG_SIZE("VIDEO_PALETTE_not RAW: going beyond view_max.\n");
-                        return -1;
-                }
-        }
+        int i;
 
         /* Find the largest size supported by the camera that fits into the
-           requested size.
-         */
-        find = -1;
+           requested size. */
+        for (i = PSZ_MAX - 1; i >= 0; i--) {
+                if (!(pdev->image_mask & (1 << i)))
+                        continue;
+
+                if (pwc_image_sizes[i][0] <= width &&
+                    pwc_image_sizes[i][1] <= height)
+                        return i;
+        }
+
+        /* No mode found, return the smallest mode we have */
         for (i = 0; i < PSZ_MAX; i++) {
-                if (pdev->image_mask & (1 << i)) {
-                        if (pwc_image_sizes[i].x <= width && pwc_image_sizes[i].y <= height)
-                                find = i;
-                }
+                if (pdev->image_mask & (1 << i))
+                        return i;
         }
-        return find;
+
+        /* Never reached there always is atleast one supported mode */
+        return 0;
 }
 
-/* initialize variables depending on type and decompressor*/
+/* initialize variables depending on type and decompressor */
 void pwc_construct(struct pwc_device *pdev)
 {
         if (DEVICE_USE_CODEC1(pdev->type)) {
 
-                pdev->view_min.x = 128;
-                pdev->view_min.y =  96;
-                pdev->view_max.x = 352;
-                pdev->view_max.y = 288;
-                pdev->abs_max.x  = 352;
-                pdev->abs_max.y  = 288;
                 pdev->image_mask = 1 << PSZ_SQCIF | 1 << PSZ_QCIF | 1 << PSZ_CIF;
                 pdev->vcinterface = 2;
                 pdev->vendpoint = 4;
@@ -96,13 +76,7 @@ void pwc_construct(struct pwc_device *pdev)
 
         } 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;
@@ -110,20 +84,11 @@ void pwc_construct(struct pwc_device *pdev)
 
         } 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 */
-                pdev->view_max.x = 640;
-                pdev->view_max.y = 480;
                 pdev->image_mask = 1 << PSZ_SQCIF | 1 << PSZ_QSIF | 1 << PSZ_QCIF | 1 << PSZ_SIF | 1 << PSZ_CIF | 1 << PSZ_VGA;
-                pdev->abs_max.x = 640;
-                pdev->abs_max.y = 480;
                 pdev->vcinterface = 3;
                 pdev->vendpoint = 4;
                 pdev->frame_header_size = 0;
                 pdev->frame_trailer_size = 0;
         }
         pdev->pixfmt = V4L2_PIX_FMT_YUV420; /* 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;
 }
diff --git a/drivers/media/video/pwc/pwc-timon.h b/drivers/media/video/pwc/pwc-timon.h
index a6e22224c95f..270c5b9010f6 100644
--- a/drivers/media/video/pwc/pwc-timon.h
+++ b/drivers/media/video/pwc/pwc-timon.h
@@ -42,7 +42,7 @@
 #ifndef PWC_TIMON_H
 #define PWC_TIMON_H
 
-#include <media/pwc-ioctl.h>
+#include "pwc.h"
 
 #define PWC_FPS_MAX_TIMON 6
 
diff --git a/drivers/media/video/pwc/pwc-uncompress.c b/drivers/media/video/pwc/pwc-uncompress.c
index 51265092bd31..b65903fbcf0d 100644
--- a/drivers/media/video/pwc/pwc-uncompress.c
+++ b/drivers/media/video/pwc/pwc-uncompress.c
@@ -35,7 +35,7 @@
 
 int pwc_decompress(struct pwc_device *pdev, struct pwc_frame_buf *fbuf)
 {
-        int n, line, col, stride;
+        int n, line, col;
         void *yuv, *image;
         u16 *src;
         u16 *dsty, *dstu, *dstv;
@@ -60,35 +60,23 @@ int pwc_decompress(struct pwc_device *pdev, struct pwc_frame_buf *fbuf)
                 return 0;
         }
 
-        vb2_set_plane_payload(&fbuf->vb, 0, pdev->view.size);
+        vb2_set_plane_payload(&fbuf->vb, 0,
+                              pdev->width * pdev->height * 3 / 2);
 
         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.
                  *
                  * We do some byte shuffling here to go from the
                  * native format to YUV420P.
                  */
                 src = (u16 *)yuv;
-                n = pdev->view.x * pdev->view.y;
+                n = pdev->width * pdev->height;
+                dsty = (u16 *)(image);
+                dstu = (u16 *)(image + n);
+                dstv = (u16 *)(image + n + n / 4);
 
-                /* 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) {
+                for (line = 0; line < pdev->height; line++) {
+                        for (col = 0; col < pdev->width; col += 4) {
                                 *dsty++ = *src++;
                                 *dsty++ = *src++;
                                 if (line & 1)
@@ -96,11 +84,6 @@ int pwc_decompress(struct pwc_device *pdev, struct pwc_frame_buf *fbuf)
                                 else
                                         *dstu++ = *src++;
                         }
-                        dsty += stride;
-                        if (line & 1)
-                                dstv += (stride >> 1);
-                        else
-                                dstu += (stride >> 1);
                 }
 
                 return 0;
@@ -111,12 +94,6 @@ int pwc_decompress(struct pwc_device *pdev, struct pwc_frame_buf *fbuf)
          * 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 */
@@ -124,10 +101,7 @@ int pwc_decompress(struct pwc_device *pdev, struct pwc_frame_buf *fbuf)
                 return -ENXIO; /* No such device or address: missing decompressor */
 
         } else {
-                pwc_dec23_decompress(pdev, yuv, image, PWCX_FLAG_PLANAR);
+                pwc_dec23_decompress(pdev, yuv, image);
         }
         return 0;
 }
-
-
-/* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */
diff --git a/drivers/media/video/pwc/pwc-v4l.c b/drivers/media/video/pwc/pwc-v4l.c
index a10ff6b64acf..80e25842e84a 100644
--- a/drivers/media/video/pwc/pwc-v4l.c
+++ b/drivers/media/video/pwc/pwc-v4l.c
@@ -49,6 +49,7 @@ static const struct v4l2_ctrl_ops pwc_ctrl_ops = {
 
 enum { awb_indoor, awb_outdoor, awb_fl, awb_manual, awb_auto };
 enum { custom_autocontour, custom_contour, custom_noise_reduction,
+        custom_awb_speed, custom_awb_delay,
         custom_save_user, custom_restore_user, custom_restore_factory };
 
 const char * const pwc_auto_whitebal_qmenu[] = {
@@ -138,6 +139,26 @@ static const struct v4l2_ctrl_config pwc_restore_factory_cfg = {
         .name    = "Restore Factory Settings",
 };
 
+static const struct v4l2_ctrl_config pwc_awb_speed_cfg = {
+        .ops    = &pwc_ctrl_ops,
+        .id     = PWC_CID_CUSTOM(awb_speed),
+        .type   = V4L2_CTRL_TYPE_INTEGER,
+        .name   = "Auto White Balance Speed",
+        .min    = 1,
+        .max    = 32,
+        .step   = 1,
+};
+
+static const struct v4l2_ctrl_config pwc_awb_delay_cfg = {
+        .ops    = &pwc_ctrl_ops,
+        .id     = PWC_CID_CUSTOM(awb_delay),
+        .type   = V4L2_CTRL_TYPE_INTEGER,
+        .name   = "Auto White Balance Delay",
+        .min    = 0,
+        .max    = 63,
+        .step   = 1,
+};
+
 int pwc_init_controls(struct pwc_device *pdev)
 {
         struct v4l2_ctrl_handler *hdl;
@@ -338,6 +359,23 @@ int pwc_init_controls(struct pwc_device *pdev)
         if (pdev->restore_factory)
                 pdev->restore_factory->flags |= V4L2_CTRL_FLAG_UPDATE;
 
+        /* Auto White Balance speed & delay */
+        r = pwc_get_u8_ctrl(pdev, GET_CHROM_CTL,
+                            AWB_CONTROL_SPEED_FORMATTER, &def);
+        if (r || def < 1 || def > 32)
+                def = 1;
+        cfg = pwc_awb_speed_cfg;
+        cfg.def = def;
+        pdev->awb_speed = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
+
+        r = pwc_get_u8_ctrl(pdev, GET_CHROM_CTL,
+                            AWB_CONTROL_DELAY_FORMATTER, &def);
+        if (r || def > 63)
+                def = 0;
+        cfg = pwc_awb_delay_cfg;
+        cfg.def = def;
+        pdev->awb_delay = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
+
         if (!(pdev->features & FEATURE_MOTOR_PANTILT))
                 return hdl->error;
 
@@ -357,25 +395,16 @@ int pwc_init_controls(struct pwc_device *pdev)
         return hdl->error;
 }
 
-static void pwc_vidioc_fill_fmt(const struct pwc_device *pdev, struct v4l2_format *f)
+static void pwc_vidioc_fill_fmt(struct v4l2_format *f,
+        int width, int height, u32 pixfmt)
 {
         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.width        = width;
+        f->fmt.pix.height       = height;
         f->fmt.pix.field        = V4L2_FIELD_NONE;
-        if (pdev->pixfmt == V4L2_PIX_FMT_YUV420) {
-                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;
-        }
+        f->fmt.pix.pixelformat  = pixfmt;
+        f->fmt.pix.bytesperline = f->fmt.pix.width;
+        f->fmt.pix.sizeimage    = f->fmt.pix.height * f->fmt.pix.width * 3 / 2;
         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,
@@ -391,6 +420,8 @@ static void pwc_vidioc_fill_fmt(const struct pwc_device *pdev, struct v4l2_forma
 /* ioctl(VIDIOC_TRY_FMT) */
 static int pwc_vidioc_try_fmt(struct pwc_device *pdev, struct v4l2_format *f)
 {
+        int size;
+
         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                 PWC_DEBUG_IOCTL("Bad video type must be V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
                 return -EINVAL;
@@ -417,15 +448,11 @@ static int pwc_vidioc_try_fmt(struct pwc_device *pdev, struct v4l2_format *f)
 
         }
 
-        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;
+        size = pwc_get_size(pdev, f->fmt.pix.width, f->fmt.pix.height);
+        pwc_vidioc_fill_fmt(f,
+                            pwc_image_sizes[size][0],
+                            pwc_image_sizes[size][1],
+                            f->fmt.pix.pixelformat);
 
         return 0;
 }
@@ -435,68 +462,50 @@ static int pwc_vidioc_try_fmt(struct pwc_device *pdev, struct v4l2_format *f)
 static int pwc_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f)
 {
         struct pwc_device *pdev = video_drvdata(file);
-        int ret, fps, snapshot, compression, pixelformat;
-
-        if (!pdev->udev)
-                return -ENODEV;
+        int ret, pixelformat, compression = 0;
 
-        if (pdev->capt_file != NULL &&
-            pdev->capt_file != file)
+        if (pwc_test_n_set_capt_file(pdev, file))
                 return -EBUSY;
 
-        pdev->capt_file = file;
-
         ret = pwc_vidioc_try_fmt(pdev, f);
-        if (ret<0)
+        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 &&
-            pixelformat != V4L2_PIX_FMT_PWC1 &&
-            pixelformat != V4L2_PIX_FMT_PWC2)
-                return -EINVAL;
+        mutex_lock(&pdev->udevlock);
+        if (!pdev->udev) {
+                ret = -ENODEV;
+                goto leave;
+        }
 
-        if (vb2_is_streaming(&pdev->vb_queue))
-                return -EBUSY;
+        if (pdev->iso_init) {
+                ret = -EBUSY;
+                goto leave;
+        }
 
         PWC_DEBUG_IOCTL("Trying to set 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,
+                        "format=%c%c%c%c\n",
+                        f->fmt.pix.width, f->fmt.pix.height, pdev->vframes,
                         (pixelformat)&255,
                         (pixelformat>>8)&255,
                         (pixelformat>>16)&255,
                         (pixelformat>>24)&255);
 
-        ret = pwc_set_video_mode(pdev,
-                                 f->fmt.pix.width,
-                                 f->fmt.pix.height,
-                                 fps,
-                                 compression,
-                                 snapshot);
+        ret = pwc_set_video_mode(pdev, f->fmt.pix.width, f->fmt.pix.height,
+                                 pdev->vframes, &compression);
 
         PWC_DEBUG_IOCTL("pwc_set_video_mode(), return=%d\n", ret);
 
-        if (ret)
-                return ret;
-
-        pdev->pixfmt = pixelformat;
-
-        pwc_vidioc_fill_fmt(pdev, f);
-
-        return 0;
+        if (ret == 0) {
+                pdev->pixfmt = pixelformat;
+                pwc_vidioc_fill_fmt(f, pdev->width, pdev->height,
+                                    pdev->pixfmt);
+        }
 
+leave:
+        mutex_unlock(&pdev->udevlock);
+        return ret;
 }
 
 static int pwc_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
@@ -536,30 +545,14 @@ static int pwc_s_input(struct file *file, void *fh, unsigned int i)
         return i ? -EINVAL : 0;
 }
 
-static int pwc_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
+static int pwc_g_volatile_ctrl_unlocked(struct v4l2_ctrl *ctrl)
 {
         struct pwc_device *pdev =
                 container_of(ctrl->handler, struct pwc_device, ctrl_handler);
         int ret = 0;
 
-        /*
-         * Sometimes it can take quite long for the pwc to complete usb control
-         * transfers, so release the modlock to give streaming by another
-         * process / thread the chance to continue with a dqbuf.
-         */
-        mutex_unlock(&pdev->modlock);
-
-        /*
-         * Take the udev-lock to protect against the disconnect handler
-         * completing and setting dev->udev to NULL underneath us. Other code
-         * does not need to do this since it is protected by the modlock.
-         */
-        mutex_lock(&pdev->udevlock);
-
-        if (!pdev->udev) {
-                ret = -ENODEV;
-                goto leave;
-        }
+        if (!pdev->udev)
+                return -ENODEV;
 
         switch (ctrl->id) {
         case V4L2_CID_AUTO_WHITE_BALANCE:
@@ -624,9 +617,18 @@ static int pwc_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
         if (ret)
                 PWC_ERROR("g_ctrl %s error %d\n", ctrl->name, ret);
 
-leave:
+        return ret;
+}
+
+static int pwc_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct pwc_device *pdev =
+                container_of(ctrl->handler, struct pwc_device, ctrl_handler);
+        int ret;
+
+        mutex_lock(&pdev->udevlock);
+        ret = pwc_g_volatile_ctrl_unlocked(ctrl);
         mutex_unlock(&pdev->udevlock);
-        mutex_lock(&pdev->modlock);
         return ret;
 }
 
@@ -643,6 +645,15 @@ static int pwc_set_awb(struct pwc_device *pdev)
 
                 if (pdev->auto_white_balance->val != awb_manual)
                         pdev->color_bal_valid = false; /* Force cache update */
+
+                /*
+                 * If this is a preset, update our red / blue balance values
+                 * so that events get generated for the new preset values
+                 */
+                if (pdev->auto_white_balance->val == awb_indoor ||
+                    pdev->auto_white_balance->val == awb_outdoor ||
+                    pdev->auto_white_balance->val == awb_fl)
+                        pwc_g_volatile_ctrl_unlocked(pdev->auto_white_balance);
         }
         if (pdev->auto_white_balance->val != awb_manual)
                 return 0;
@@ -806,8 +817,6 @@ static int pwc_s_ctrl(struct v4l2_ctrl *ctrl)
                 container_of(ctrl->handler, struct pwc_device, ctrl_handler);
         int ret = 0;
 
-        /* See the comments on locking in pwc_g_volatile_ctrl */
-        mutex_unlock(&pdev->modlock);
         mutex_lock(&pdev->udevlock);
 
         if (!pdev->udev) {
@@ -891,6 +900,16 @@ static int pwc_s_ctrl(struct v4l2_ctrl *ctrl)
                 ret = pwc_button_ctrl(pdev,
                                       RESTORE_FACTORY_DEFAULTS_FORMATTER);
                 break;
+        case PWC_CID_CUSTOM(awb_speed):
+                ret = pwc_set_u8_ctrl(pdev, SET_CHROM_CTL,
+                                      AWB_CONTROL_SPEED_FORMATTER,
+                                      ctrl->val);
+                break;
+        case PWC_CID_CUSTOM(awb_delay):
+                ret = pwc_set_u8_ctrl(pdev, SET_CHROM_CTL,
+                                      AWB_CONTROL_DELAY_FORMATTER,
+                                      ctrl->val);
+                break;
         case V4L2_CID_PAN_RELATIVE:
                 ret = pwc_set_motor(pdev);
                 break;
@@ -903,7 +922,6 @@ static int pwc_s_ctrl(struct v4l2_ctrl *ctrl)
 
 leave:
         mutex_unlock(&pdev->udevlock);
-        mutex_lock(&pdev->modlock);
         return ret;
 }
 
@@ -933,9 +951,14 @@ static int pwc_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f)
 {
         struct pwc_device *pdev = video_drvdata(file);
 
+        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        mutex_lock(&pdev->udevlock); /* To avoid race with s_fmt */
         PWC_DEBUG_IOCTL("ioctl(VIDIOC_G_FMT) return size %dx%d\n",
-                        pdev->image.x, pdev->image.y);
-        pwc_vidioc_fill_fmt(pdev, f);
+                        pdev->width, pdev->height);
+        pwc_vidioc_fill_fmt(f, pdev->width, pdev->height, pdev->pixfmt);
+        mutex_unlock(&pdev->udevlock);
         return 0;
 }
 
@@ -951,12 +974,9 @@ static int pwc_reqbufs(struct file *file, void *fh,
 {
         struct pwc_device *pdev = video_drvdata(file);
 
-        if (pdev->capt_file != NULL &&
-            pdev->capt_file != file)
+        if (pwc_test_n_set_capt_file(pdev, file))
                 return -EBUSY;
 
-        pdev->capt_file = file;
-
         return vb2_reqbufs(&pdev->vb_queue, rb);
 }
 
@@ -1025,25 +1045,21 @@ static int pwc_enum_framesizes(struct file *file, void *fh,
         struct pwc_device *pdev = video_drvdata(file);
         unsigned int i = 0, index = fsize->index;
 
-        if (fsize->pixel_format == V4L2_PIX_FMT_YUV420) {
+        if (fsize->pixel_format == V4L2_PIX_FMT_YUV420 ||
+            (fsize->pixel_format == V4L2_PIX_FMT_PWC1 &&
+                        DEVICE_USE_CODEC1(pdev->type)) ||
+            (fsize->pixel_format == V4L2_PIX_FMT_PWC2 &&
+                        DEVICE_USE_CODEC23(pdev->type))) {
                 for (i = 0; i < PSZ_MAX; i++) {
-                        if (pdev->image_mask & (1UL << i)) {
-                                if (!index--) {
-                                        fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
-                                        fsize->discrete.width = pwc_image_sizes[i].x;
-                                        fsize->discrete.height = pwc_image_sizes[i].y;
-                                        return 0;
-                                }
+                        if (!(pdev->image_mask & (1UL << i)))
+                                continue;
+                        if (!index--) {
+                                fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+                                fsize->discrete.width = pwc_image_sizes[i][0];
+                                fsize->discrete.height = pwc_image_sizes[i][1];
+                                return 0;
                         }
                 }
-        } else if (fsize->index == 0 &&
-                        ((fsize->pixel_format == V4L2_PIX_FMT_PWC1 && DEVICE_USE_CODEC1(pdev->type)) ||
-                         (fsize->pixel_format == V4L2_PIX_FMT_PWC2 && DEVICE_USE_CODEC23(pdev->type)))) {
-
-                fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
-                fsize->discrete.width = pdev->abs_max.x;
-                fsize->discrete.height = pdev->abs_max.y;
-                return 0;
         }
         return -EINVAL;
 }
@@ -1056,8 +1072,8 @@ static int pwc_enum_frameintervals(struct file *file, void *fh,
         unsigned int i;
 
         for (i = 0; i < PSZ_MAX; i++) {
-                if (pwc_image_sizes[i].x == fival->width &&
-                                pwc_image_sizes[i].y == fival->height) {
+                if (pwc_image_sizes[i][0] == fival->width &&
+                                pwc_image_sizes[i][1] == fival->height) {
                         size = i;
                         break;
                 }
@@ -1086,14 +1102,6 @@ static int pwc_log_status(struct file *file, void *priv)
         return 0;
 }
 
-static long pwc_default(struct file *file, void *fh, bool valid_prio,
-                        int cmd, void *arg)
-{
-        struct pwc_device *pdev = video_drvdata(file);
-
-        return pwc_ioctl(pdev, cmd, arg);
-}
-
 const struct v4l2_ioctl_ops pwc_ioctl_ops = {
         .vidioc_querycap                    = pwc_querycap,
         .vidioc_enum_input                  = pwc_enum_input,
@@ -1112,8 +1120,4 @@ const struct v4l2_ioctl_ops pwc_ioctl_ops = {
         .vidioc_log_status                  = pwc_log_status,
         .vidioc_enum_framesizes             = pwc_enum_framesizes,
         .vidioc_enum_frameintervals         = pwc_enum_frameintervals,
-        .vidioc_default             = pwc_default,
 };
-
-
-/* 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 0e4e2d7b7872..47c518fef179 100644
--- a/drivers/media/video/pwc/pwc.h
+++ b/drivers/media/video/pwc/pwc.h
@@ -35,15 +35,16 @@
 #include <asm/errno.h>
 #include <linux/videodev2.h>
 #include <media/v4l2-common.h>
+#include <media/v4l2-device.h>
 #include <media/v4l2-ioctl.h>
 #include <media/v4l2-ctrls.h>
+#include <media/v4l2-fh.h>
+#include <media/v4l2-event.h>
 #include <media/videobuf2-vmalloc.h>
 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
 #include <linux/input.h>
 #endif
 
-#include <media/pwc-ioctl.h>
-
 /* Version block */
 #define PWC_VERSION     "10.0.15"
 #define PWC_NAME        "pwc"
@@ -106,6 +107,9 @@
 #define FEATURE_CODEC1                  0x0002
 #define FEATURE_CODEC2                  0x0004
 
+#define MAX_WIDTH               640
+#define MAX_HEIGHT              480
+
 /* Ignore errors in the first N frames, to allow for startup delays */
 #define FRAME_LOWMARK 5
 
@@ -186,6 +190,24 @@
 #define PT_RESET_CONTROL_FORMATTER              0x02
 #define PT_STATUS_FORMATTER                     0x03
 
+/* Enumeration of image sizes */
+#define PSZ_SQCIF       0x00
+#define PSZ_QSIF        0x01
+#define PSZ_QCIF        0x02
+#define PSZ_SIF         0x03
+#define PSZ_CIF         0x04
+#define PSZ_VGA         0x05
+#define PSZ_MAX         6
+
+struct pwc_raw_frame {
+        __le16 type;            /* type of the webcam */
+        __le16 vbandlength;     /* Size of 4 lines compressed (used by the
+                                   decompressor) */
+        __u8   cmd[4];          /* the four byte of the command (in case of
+                                   nala, only the first 3 bytes is filled) */
+        __u8   rawframe[0];     /* frame_size = H / 4 * vbandlength */
+} __packed;
+
 /* intermediate buffers with raw data from the USB cam */
 struct pwc_frame_buf
 {
@@ -198,33 +220,30 @@ struct pwc_frame_buf
 struct pwc_device
 {
         struct video_device vdev;
-        struct mutex modlock;
+        struct v4l2_device v4l2_dev;
 
         /* Pointer to our usb_device, may be NULL after unplug */
         struct usb_device *udev;
-        /* Protects the setting of udev to NULL by our disconnect handler */
         struct mutex udevlock;
 
         /* type of cam (645, 646, 675, 680, 690, 720, 730, 740, 750) */
         int type;
         int release;            /* release number */
         int features;           /* feature bits */
-        char serial[30];        /* serial number (string) */
 
         /*** Video data ***/
         struct file *capt_file; /* file doing video capture */
+        struct mutex capt_file_lock;
         int vendpoint;          /* video isoc endpoint */
         int vcinterface;        /* video control interface */
         int valternate;         /* alternate interface needed */
-        int vframes, vsize;     /* frames-per-second & size (see PSZ_*) */
+        int vframes;            /* frames-per-second */
         int pixfmt;             /* pixelformat: V4L2_PIX_FMT_YUV420 or _PWCX */
         int vframe_count;       /* received frames */
         int vmax_packet_size;   /* USB maxpacket size */
         int vlast_packet_size;  /* for frame synchronisation */
         int visoc_errors;       /* number of contiguous ISOC errors */
-        int vcompression;       /* desired compression factor */
         int vbandlength;        /* compressed band length; 0 is uncompressed */
-        char vsnapshot;         /* snapshot mode */
         char vsync;             /* used by isoc handler */
         char vmirror;           /* for ToUCaM series */
         char power_save;        /* Do powersaving for this cam */
@@ -262,21 +281,8 @@ struct pwc_device
          * a gray or black border. view_min <= image <= view <= view_max;
          */
         int image_mask;                         /* supported sizes */
-        struct pwc_coord view_min, view_max;    /* minimum and maximum view */
-        struct pwc_coord abs_max;               /* maximum supported size */
-        struct pwc_coord image, view;           /* image and viewport size */
-        struct pwc_coord offset;                /* offset of the viewport */
-
-        /*** motorized pan/tilt feature */
-        struct pwc_mpt_range angle_range;
-        int pan_angle;                  /* in degrees * 100 */
-        int tilt_angle;                 /* absolute angle; 0,0 is home */
+        int width, height;                      /* current resolution */
 
-        /*
-         * Set to 1 when the user push the button, reset to 0
-         * when this value is read from sysfs.
-         */
-        int snapshot_button_status;
 #ifdef CONFIG_USB_PWC_INPUT_EVDEV
         struct input_dev *button_dev;   /* webcam snapshot button input */
         char button_phys[64];
@@ -328,6 +334,8 @@ struct pwc_device
         struct v4l2_ctrl                *save_user;
         struct v4l2_ctrl                *restore_user;
         struct v4l2_ctrl                *restore_factory;
+        struct v4l2_ctrl                *awb_speed;
+        struct v4l2_ctrl                *awb_delay;
         struct {
                 /* motor control cluster */
                 struct v4l2_ctrl        *motor_pan;
@@ -344,19 +352,20 @@ struct pwc_device
 extern int pwc_trace;
 #endif
 
+int pwc_test_n_set_capt_file(struct pwc_device *pdev, struct file *file);
+
 /** Functions in pwc-misc.c */
 /* sizes in pixels */
-extern const struct pwc_coord pwc_image_sizes[PSZ_MAX];
+extern const int pwc_image_sizes[PSZ_MAX][2];
 
-int pwc_decode_size(struct pwc_device *pdev, int width, int height);
+int pwc_get_size(struct pwc_device *pdev, int width, int height);
 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);
+extern int pwc_set_video_mode(struct pwc_device *pdev, int width, int height,
+                              int frames, int *compression);
 extern unsigned int pwc_get_fps(struct pwc_device *pdev, unsigned int index, unsigned int size);
-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);
 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 send_control_msg(struct pwc_device *pdev,
@@ -375,9 +384,6 @@ int pwc_init_controls(struct pwc_device *pdev);
 /* Power down or up the camera; not supported by all models */
 extern void pwc_camera_power(struct pwc_device *pdev, int power);
 
-/* Private ioctl()s; see pwc-ioctl.h */
-extern long pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg);
-
 extern const struct v4l2_ioctl_ops pwc_ioctl_ops;
 
 /** pwc-uncompress.c */
diff --git a/drivers/media/video/pxa_camera.c b/drivers/media/video/pxa_camera.c
index 79fb22c89ae9..0bd7da26d018 100644
--- a/drivers/media/video/pxa_camera.c
+++ b/drivers/media/video/pxa_camera.c
@@ -1133,12 +1133,13 @@ static void pxa_camera_setup_cicr(struct soc_camera_device *icd,
         __raw_writel(cicr0, pcdev->base + CICR0);
 }
 
-static int pxa_camera_set_bus_param(struct soc_camera_device *icd, __u32 pixfmt)
+static int pxa_camera_set_bus_param(struct soc_camera_device *icd)
 {
         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
         struct pxa_camera_dev *pcdev = ici->priv;
         struct v4l2_mbus_config cfg = {.type = V4L2_MBUS_PARALLEL,};
+        u32 pixfmt = icd->current_fmt->host_fmt->fourcc;
         unsigned long bus_flags, common_flags;
         int ret;
         struct pxa_cam *cam = icd->host_priv;
@@ -1851,19 +1852,7 @@ static struct platform_driver pxa_camera_driver = {
         .remove         = __devexit_p(pxa_camera_remove),
 };
 
-
-static int __init pxa_camera_init(void)
-{
-        return platform_driver_register(&pxa_camera_driver);
-}
-
-static void __exit pxa_camera_exit(void)
-{
-        platform_driver_unregister(&pxa_camera_driver);
-}
-
-module_init(pxa_camera_init);
-module_exit(pxa_camera_exit);
+module_platform_driver(pxa_camera_driver);
 
 MODULE_DESCRIPTION("PXA27x SoC Camera Host driver");
 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
diff --git a/drivers/media/video/s5p-fimc/fimc-capture.c b/drivers/media/video/s5p-fimc/fimc-capture.c
index 2cc3b9166724..510cfab477ff 100644
--- a/drivers/media/video/s5p-fimc/fimc-capture.c
+++ b/drivers/media/video/s5p-fimc/fimc-capture.c
@@ -63,6 +63,8 @@ static int fimc_init_capture(struct fimc_dev *fimc)
                 fimc_hw_set_effect(ctx, false);
                 fimc_hw_set_output_path(ctx);
                 fimc_hw_set_out_dma(ctx);
+                if (fimc->variant->has_alpha)
+                        fimc_hw_set_rgb_alpha(ctx);
                 clear_bit(ST_CAPT_APPLY_CFG, &fimc->state);
         }
         spin_unlock_irqrestore(&fimc->slock, flags);
@@ -154,6 +156,8 @@ int fimc_capture_config_update(struct fimc_ctx *ctx)
                 fimc_hw_set_rotation(ctx);
                 fimc_prepare_dma_offset(ctx, &ctx->d_frame);
                 fimc_hw_set_out_dma(ctx);
+                if (fimc->variant->has_alpha)
+                        fimc_hw_set_rgb_alpha(ctx);
                 clear_bit(ST_CAPT_APPLY_CFG, &fimc->state);
         }
         spin_unlock(&ctx->slock);
@@ -812,6 +816,10 @@ static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
                                           FIMC_SD_PAD_SOURCE);
         if (!ff->fmt)
                 return -EINVAL;
+
+        /* Update RGB Alpha control state and value range */
+        fimc_alpha_ctrl_update(ctx);
+
         /* Try to match format at the host and the sensor */
         if (!fimc->vid_cap.user_subdev_api) {
                 mf->code   = ff->fmt->mbus_code;
@@ -1235,6 +1243,9 @@ static int fimc_subdev_set_fmt(struct v4l2_subdev *sd,
                 *mf = fmt->format;
                 return 0;
         }
+        /* Update RGB Alpha control state and value range */
+        fimc_alpha_ctrl_update(ctx);
+
         fimc_capture_mark_jpeg_xfer(ctx, fimc_fmt_is_jpeg(ffmt->color));
 
         ff = fmt->pad == FIMC_SD_PAD_SINK ?
diff --git a/drivers/media/video/s5p-fimc/fimc-core.c b/drivers/media/video/s5p-fimc/fimc-core.c
index 07c6254faee3..f5cbb8a4c540 100644
--- a/drivers/media/video/s5p-fimc/fimc-core.c
+++ b/drivers/media/video/s5p-fimc/fimc-core.c
@@ -52,13 +52,29 @@ static struct fimc_fmt fimc_formats[] = {
                 .colplanes      = 1,
                 .flags          = FMT_FLAGS_M2M,
         }, {
-                .name           = "XRGB-8-8-8-8, 32 bpp",
+                .name           = "ARGB8888, 32 bpp",
                 .fourcc         = V4L2_PIX_FMT_RGB32,
                 .depth          = { 32 },
                 .color          = S5P_FIMC_RGB888,
                 .memplanes      = 1,
                 .colplanes      = 1,
-                .flags          = FMT_FLAGS_M2M,
+                .flags          = FMT_FLAGS_M2M | FMT_HAS_ALPHA,
+        }, {
+                .name           = "ARGB1555",
+                .fourcc         = V4L2_PIX_FMT_RGB555,
+                .depth          = { 16 },
+                .color          = S5P_FIMC_RGB555,
+                .memplanes      = 1,
+                .colplanes      = 1,
+                .flags          = FMT_FLAGS_M2M_OUT | FMT_HAS_ALPHA,
+        }, {
+                .name           = "ARGB4444",
+                .fourcc         = V4L2_PIX_FMT_RGB444,
+                .depth          = { 16 },
+                .color          = S5P_FIMC_RGB444,
+                .memplanes      = 1,
+                .colplanes      = 1,
+                .flags          = FMT_FLAGS_M2M_OUT | FMT_HAS_ALPHA,
         }, {
                 .name           = "YUV 4:2:2 packed, YCbYCr",
                 .fourcc         = V4L2_PIX_FMT_YUYV,
@@ -171,6 +187,14 @@ static struct fimc_fmt fimc_formats[] = {
         },
 };
 
+static unsigned int get_m2m_fmt_flags(unsigned int stream_type)
+{
+        if (stream_type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+                return FMT_FLAGS_M2M_IN;
+        else
+                return FMT_FLAGS_M2M_OUT;
+}
+
 int fimc_check_scaler_ratio(struct fimc_ctx *ctx, int sw, int sh,
                             int dw, int dh, int rotation)
 {
@@ -652,8 +676,11 @@ static void fimc_dma_run(void *priv)
         if (ctx->state & (FIMC_DST_ADDR | FIMC_PARAMS))
                 fimc_hw_set_output_addr(fimc, &ctx->d_frame.paddr, -1);
 
-        if (ctx->state & FIMC_PARAMS)
+        if (ctx->state & FIMC_PARAMS) {
                 fimc_hw_set_out_dma(ctx);
+                if (fimc->variant->has_alpha)
+                        fimc_hw_set_rgb_alpha(ctx);
+        }
 
         fimc_activate_capture(ctx);
 
@@ -750,12 +777,11 @@ static struct vb2_ops fimc_qops = {
 #define ctrl_to_ctx(__ctrl) \
         container_of((__ctrl)->handler, struct fimc_ctx, ctrl_handler)
 
-static int fimc_s_ctrl(struct v4l2_ctrl *ctrl)
+static int __fimc_s_ctrl(struct fimc_ctx *ctx, struct v4l2_ctrl *ctrl)
 {
-        struct fimc_ctx *ctx = ctrl_to_ctx(ctrl);
         struct fimc_dev *fimc = ctx->fimc_dev;
         struct samsung_fimc_variant *variant = fimc->variant;
-        unsigned long flags;
+        unsigned int flags = FIMC_DST_FMT | FIMC_SRC_FMT;
         int ret = 0;
 
         if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
@@ -763,52 +789,63 @@ static int fimc_s_ctrl(struct v4l2_ctrl *ctrl)
 
         switch (ctrl->id) {
         case V4L2_CID_HFLIP:
-                spin_lock_irqsave(&ctx->slock, flags);
                 ctx->hflip = ctrl->val;
                 break;
 
         case V4L2_CID_VFLIP:
-                spin_lock_irqsave(&ctx->slock, flags);
                 ctx->vflip = ctrl->val;
                 break;
 
         case V4L2_CID_ROTATE:
                 if (fimc_capture_pending(fimc) ||
-                    fimc_ctx_state_is_set(FIMC_DST_FMT | FIMC_SRC_FMT, ctx)) {
+                    (ctx->state & flags) == flags) {
                         ret = fimc_check_scaler_ratio(ctx, ctx->s_frame.width,
                                         ctx->s_frame.height, ctx->d_frame.width,
                                         ctx->d_frame.height, ctrl->val);
-                }
-                if (ret) {
-                        v4l2_err(fimc->m2m.vfd, "Out of scaler range\n");
-                        return -EINVAL;
+                        if (ret)
+                                return -EINVAL;
                 }
                 if ((ctrl->val == 90 || ctrl->val == 270) &&
                     !variant->has_out_rot)
                         return -EINVAL;
-                spin_lock_irqsave(&ctx->slock, flags);
+
                 ctx->rotation = ctrl->val;
                 break;
 
-        default:
-                v4l2_err(fimc->v4l2_dev, "Invalid control: 0x%X\n", ctrl->id);
-                return -EINVAL;
+        case V4L2_CID_ALPHA_COMPONENT:
+                ctx->d_frame.alpha = ctrl->val;
+                break;
         }
         ctx->state |= FIMC_PARAMS;
         set_bit(ST_CAPT_APPLY_CFG, &fimc->state);
-        spin_unlock_irqrestore(&ctx->slock, flags);
         return 0;
 }
 
+static int fimc_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct fimc_ctx *ctx = ctrl_to_ctx(ctrl);
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&ctx->slock, flags);
+        ret = __fimc_s_ctrl(ctx, ctrl);
+        spin_unlock_irqrestore(&ctx->slock, flags);
+
+        return ret;
+}
+
 static const struct v4l2_ctrl_ops fimc_ctrl_ops = {
         .s_ctrl = fimc_s_ctrl,
 };
 
 int fimc_ctrls_create(struct fimc_ctx *ctx)
 {
+        struct samsung_fimc_variant *variant = ctx->fimc_dev->variant;
+        unsigned int max_alpha = fimc_get_alpha_mask(ctx->d_frame.fmt);
+
         if (ctx->ctrls_rdy)
                 return 0;
-        v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3);
+        v4l2_ctrl_handler_init(&ctx->ctrl_handler, 4);
 
         ctx->ctrl_rotate = v4l2_ctrl_new_std(&ctx->ctrl_handler, &fimc_ctrl_ops,
                                      V4L2_CID_HFLIP, 0, 1, 1, 0);
@@ -816,6 +853,13 @@ int fimc_ctrls_create(struct fimc_ctx *ctx)
                                     V4L2_CID_VFLIP, 0, 1, 1, 0);
         ctx->ctrl_vflip = v4l2_ctrl_new_std(&ctx->ctrl_handler, &fimc_ctrl_ops,
                                     V4L2_CID_ROTATE, 0, 270, 90, 0);
+        if (variant->has_alpha)
+                ctx->ctrl_alpha = v4l2_ctrl_new_std(&ctx->ctrl_handler,
+                                    &fimc_ctrl_ops, V4L2_CID_ALPHA_COMPONENT,
+                                    0, max_alpha, 1, 0);
+        else
+                ctx->ctrl_alpha = NULL;
+
         ctx->ctrls_rdy = ctx->ctrl_handler.error == 0;
 
         return ctx->ctrl_handler.error;
@@ -826,11 +870,14 @@ void fimc_ctrls_delete(struct fimc_ctx *ctx)
         if (ctx->ctrls_rdy) {
                 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
                 ctx->ctrls_rdy = false;
+                ctx->ctrl_alpha = NULL;
         }
 }
 
 void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active)
 {
+        unsigned int has_alpha = ctx->d_frame.fmt->flags & FMT_HAS_ALPHA;
+
         if (!ctx->ctrls_rdy)
                 return;
 
@@ -838,6 +885,8 @@ void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active)
         v4l2_ctrl_activate(ctx->ctrl_rotate, active);
         v4l2_ctrl_activate(ctx->ctrl_hflip, active);
         v4l2_ctrl_activate(ctx->ctrl_vflip, active);
+        if (ctx->ctrl_alpha)
+                v4l2_ctrl_activate(ctx->ctrl_alpha, active && has_alpha);
 
         if (active) {
                 ctx->rotation = ctx->ctrl_rotate->val;
@@ -851,6 +900,24 @@ void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active)
         mutex_unlock(&ctx->ctrl_handler.lock);
 }
 
+/* Update maximum value of the alpha color control */
+void fimc_alpha_ctrl_update(struct fimc_ctx *ctx)
+{
+        struct fimc_dev *fimc = ctx->fimc_dev;
+        struct v4l2_ctrl *ctrl = ctx->ctrl_alpha;
+
+        if (ctrl == NULL || !fimc->variant->has_alpha)
+                return;
+
+        v4l2_ctrl_lock(ctrl);
+        ctrl->maximum = fimc_get_alpha_mask(ctx->d_frame.fmt);
+
+        if (ctrl->cur.val > ctrl->maximum)
+                ctrl->cur.val = ctrl->maximum;
+
+        v4l2_ctrl_unlock(ctrl);
+}
+
 /*
  * V4L2 ioctl handlers
  */
@@ -874,7 +941,8 @@ static int fimc_m2m_enum_fmt_mplane(struct file *file, void *priv,
 {
         struct fimc_fmt *fmt;
 
-        fmt = fimc_find_format(NULL, NULL, FMT_FLAGS_M2M, f->index);
+        fmt = fimc_find_format(NULL, NULL, get_m2m_fmt_flags(f->type),
+                               f->index);
         if (!fmt)
                 return -EINVAL;
 
@@ -938,6 +1006,7 @@ void fimc_adjust_mplane_format(struct fimc_fmt *fmt, u32 width, u32 height,
         pix->colorspace = V4L2_COLORSPACE_JPEG;
         pix->field = V4L2_FIELD_NONE;
         pix->num_planes = fmt->memplanes;
+        pix->pixelformat = fmt->fourcc;
         pix->height = height;
         pix->width = width;
 
@@ -1017,7 +1086,8 @@ static int fimc_try_fmt_mplane(struct fimc_ctx *ctx, struct v4l2_format *f)
 
         dbg("w: %d, h: %d", pix->width, pix->height);
 
-        fmt = fimc_find_format(&pix->pixelformat, NULL, FMT_FLAGS_M2M, 0);
+        fmt = fimc_find_format(&pix->pixelformat, NULL,
+                               get_m2m_fmt_flags(f->type), 0);
         if (WARN(fmt == NULL, "Pixel format lookup failed"))
                 return -EINVAL;
 
@@ -1087,10 +1157,13 @@ static int fimc_m2m_s_fmt_mplane(struct file *file, void *fh,
 
         pix = &f->fmt.pix_mp;
         frame->fmt = fimc_find_format(&pix->pixelformat, NULL,
-                                      FMT_FLAGS_M2M, 0);
+                                      get_m2m_fmt_flags(f->type), 0);
         if (!frame->fmt)
                 return -EINVAL;
 
+        /* Update RGB Alpha control state and value range */
+        fimc_alpha_ctrl_update(ctx);
+
         for (i = 0; i < frame->fmt->colplanes; i++) {
                 frame->payload[i] =
                         (pix->width * pix->height * frame->fmt->depth[i]) / 8;
@@ -1374,6 +1447,12 @@ static int fimc_m2m_open(struct file *file)
         if (!ctx)
                 return -ENOMEM;
         v4l2_fh_init(&ctx->fh, fimc->m2m.vfd);
+        ctx->fimc_dev = fimc;
+
+        /* Default color format */
+        ctx->s_frame.fmt = &fimc_formats[0];
+        ctx->d_frame.fmt = &fimc_formats[0];
+
         ret = fimc_ctrls_create(ctx);
         if (ret)
                 goto error_fh;
@@ -1383,10 +1462,6 @@ static int fimc_m2m_open(struct file *file)
         file->private_data = &ctx->fh;
         v4l2_fh_add(&ctx->fh);
 
-        ctx->fimc_dev = fimc;
-        /* Default color format */
-        ctx->s_frame.fmt = &fimc_formats[0];
-        ctx->d_frame.fmt = &fimc_formats[0];
         /* Setup the device context for memory-to-memory mode */
         ctx->state = FIMC_CTX_M2M;
         ctx->flags = 0;
@@ -1709,9 +1784,8 @@ static int fimc_runtime_resume(struct device *dev)
         /* Resume the capture or mem-to-mem device */
         if (fimc_capture_busy(fimc))
                 return fimc_capture_resume(fimc);
-        else if (fimc_m2m_pending(fimc))
-                return fimc_m2m_resume(fimc);
-        return 0;
+
+        return fimc_m2m_resume(fimc);
 }
 
 static int fimc_runtime_suspend(struct device *dev)
@@ -1893,6 +1967,7 @@ static struct samsung_fimc_variant fimc0_variant_exynos4 = {
         .has_cam_if      = 1,
         .has_cistatus2   = 1,
         .has_mainscaler_ext = 1,
+        .has_alpha       = 1,
         .min_inp_pixsize = 16,
         .min_out_pixsize = 16,
         .hor_offs_align  = 2,
@@ -1906,6 +1981,7 @@ static struct samsung_fimc_variant fimc3_variant_exynos4 = {
         .has_cam_if      = 1,
         .has_cistatus2   = 1,
         .has_mainscaler_ext = 1,
+        .has_alpha       = 1,
         .min_inp_pixsize = 16,
         .min_out_pixsize = 16,
         .hor_offs_align  = 2,
diff --git a/drivers/media/video/s5p-fimc/fimc-core.h b/drivers/media/video/s5p-fimc/fimc-core.h
index c7f01c47b20f..4e20560c73d4 100644
--- a/drivers/media/video/s5p-fimc/fimc-core.h
+++ b/drivers/media/video/s5p-fimc/fimc-core.h
@@ -85,7 +85,9 @@ enum fimc_datapath {
 };
 
 enum fimc_color_fmt {
-        S5P_FIMC_RGB565 = 0x10,
+        S5P_FIMC_RGB444 = 0x10,
+        S5P_FIMC_RGB555,
+        S5P_FIMC_RGB565,
         S5P_FIMC_RGB666,
         S5P_FIMC_RGB888,
         S5P_FIMC_RGB30_LOCAL,
@@ -160,8 +162,11 @@ struct fimc_fmt {
         u16     colplanes;
         u8      depth[VIDEO_MAX_PLANES];
         u16     flags;
-#define FMT_FLAGS_CAM   (1 << 0)
-#define FMT_FLAGS_M2M   (1 << 1)
+#define FMT_FLAGS_CAM           (1 << 0)
+#define FMT_FLAGS_M2M_IN        (1 << 1)
+#define FMT_FLAGS_M2M_OUT       (1 << 2)
+#define FMT_FLAGS_M2M           (1 << 1 | 1 << 2)
+#define FMT_HAS_ALPHA           (1 << 3)
 };
 
 /**
@@ -283,6 +288,7 @@ struct fimc_frame {
         struct fimc_addr        paddr;
         struct fimc_dma_offset  dma_offset;
         struct fimc_fmt         *fmt;
+        u8                      alpha;
 };
 
 /**
@@ -387,6 +393,7 @@ struct samsung_fimc_variant {
         unsigned int    has_cistatus2:1;
         unsigned int    has_mainscaler_ext:1;
         unsigned int    has_cam_if:1;
+        unsigned int    has_alpha:1;
         struct fimc_pix_limit *pix_limit;
         u16             min_inp_pixsize;
         u16             min_out_pixsize;
@@ -482,7 +489,8 @@ struct fimc_dev {
  * @ctrl_handler:       v4l2 controls handler
  * @ctrl_rotate         image rotation control
  * @ctrl_hflip          horizontal flip control
- * @ctrl_vflip          vartical flip control
+ * @ctrl_vflip          vertical flip control
+ * @ctrl_alpha          RGB alpha control
  * @ctrls_rdy:          true if the control handler is initialized
  */
 struct fimc_ctx {
@@ -509,6 +517,7 @@ struct fimc_ctx {
         struct v4l2_ctrl        *ctrl_rotate;
         struct v4l2_ctrl        *ctrl_hflip;
         struct v4l2_ctrl        *ctrl_vflip;
+        struct v4l2_ctrl        *ctrl_alpha;
         bool                    ctrls_rdy;
 };
 
@@ -578,6 +587,17 @@ static inline int tiled_fmt(struct fimc_fmt *fmt)
         return fmt->fourcc == V4L2_PIX_FMT_NV12MT;
 }
 
+/* Return the alpha component bit mask */
+static inline int fimc_get_alpha_mask(struct fimc_fmt *fmt)
+{
+        switch (fmt->color) {
+        case S5P_FIMC_RGB444:   return 0x0f;
+        case S5P_FIMC_RGB555:   return 0x01;
+        case S5P_FIMC_RGB888:   return 0xff;
+        default:                return 0;
+        };
+}
+
 static inline void fimc_hw_clear_irq(struct fimc_dev *dev)
 {
         u32 cfg = readl(dev->regs + S5P_CIGCTRL);
@@ -674,6 +694,7 @@ void fimc_hw_set_prescaler(struct fimc_ctx *ctx);
 void fimc_hw_set_mainscaler(struct fimc_ctx *ctx);
 void fimc_hw_en_capture(struct fimc_ctx *ctx);
 void fimc_hw_set_effect(struct fimc_ctx *ctx, bool active);
+void fimc_hw_set_rgb_alpha(struct fimc_ctx *ctx);
 void fimc_hw_set_in_dma(struct fimc_ctx *ctx);
 void fimc_hw_set_input_path(struct fimc_ctx *ctx);
 void fimc_hw_set_output_path(struct fimc_ctx *ctx);
@@ -695,6 +716,7 @@ int fimc_vidioc_enum_fmt_mplane(struct file *file, void *priv,
 int fimc_ctrls_create(struct fimc_ctx *ctx);
 void fimc_ctrls_delete(struct fimc_ctx *ctx);
 void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active);
+void fimc_alpha_ctrl_update(struct fimc_ctx *ctx);
 int fimc_fill_format(struct fimc_frame *frame, struct v4l2_format *f);
 void fimc_adjust_mplane_format(struct fimc_fmt *fmt, u32 width, u32 height,
                                struct v4l2_pix_format_mplane *pix);
diff --git a/drivers/media/video/s5p-fimc/fimc-reg.c b/drivers/media/video/s5p-fimc/fimc-reg.c
index 44f5c2d1920b..15466d0529c1 100644
--- a/drivers/media/video/s5p-fimc/fimc-reg.c
+++ b/drivers/media/video/s5p-fimc/fimc-reg.c
@@ -117,7 +117,7 @@ void fimc_hw_set_target_format(struct fimc_ctx *ctx)
                   S5P_CITRGFMT_VSIZE_MASK);
 
         switch (frame->fmt->color) {
-        case S5P_FIMC_RGB565...S5P_FIMC_RGB888:
+        case S5P_FIMC_RGB444...S5P_FIMC_RGB888:
                 cfg |= S5P_CITRGFMT_RGB;
                 break;
         case S5P_FIMC_YCBCR420:
@@ -175,6 +175,7 @@ void fimc_hw_set_out_dma(struct fimc_ctx *ctx)
         struct fimc_dev *dev = ctx->fimc_dev;
         struct fimc_frame *frame = &ctx->d_frame;
         struct fimc_dma_offset *offset = &frame->dma_offset;
+        struct fimc_fmt *fmt = frame->fmt;
 
         /* Set the input dma offsets. */
         cfg = 0;
@@ -198,15 +199,22 @@ void fimc_hw_set_out_dma(struct fimc_ctx *ctx)
         cfg = readl(dev->regs + S5P_CIOCTRL);
 
         cfg &= ~(S5P_CIOCTRL_ORDER2P_MASK | S5P_CIOCTRL_ORDER422_MASK |
-                 S5P_CIOCTRL_YCBCR_PLANE_MASK);
+                 S5P_CIOCTRL_YCBCR_PLANE_MASK | S5P_CIOCTRL_RGB16FMT_MASK);
 
-        if (frame->fmt->colplanes == 1)
+        if (fmt->colplanes == 1)
                 cfg |= ctx->out_order_1p;
-        else if (frame->fmt->colplanes == 2)
+        else if (fmt->colplanes == 2)
                 cfg |= ctx->out_order_2p | S5P_CIOCTRL_YCBCR_2PLANE;
-        else if (frame->fmt->colplanes == 3)
+        else if (fmt->colplanes == 3)
                 cfg |= S5P_CIOCTRL_YCBCR_3PLANE;
 
+        if (fmt->color == S5P_FIMC_RGB565)
+                cfg |= S5P_CIOCTRL_RGB565;
+        else if (fmt->color == S5P_FIMC_RGB555)
+                cfg |= S5P_CIOCTRL_ARGB1555;
+        else if (fmt->color == S5P_FIMC_RGB444)
+                cfg |= S5P_CIOCTRL_ARGB4444;
+
         writel(cfg, dev->regs + S5P_CIOCTRL);
 }
 
@@ -278,22 +286,28 @@ static void fimc_hw_set_scaler(struct fimc_ctx *ctx)
         if (sc->copy_mode)
                 cfg |= S5P_CISCCTRL_ONE2ONE;
 
-
         if (ctx->in_path == FIMC_DMA) {
-                if (src_frame->fmt->color == S5P_FIMC_RGB565)
+                switch (src_frame->fmt->color) {
+                case S5P_FIMC_RGB565:
                         cfg |= S5P_CISCCTRL_INRGB_FMT_RGB565;
-                else if (src_frame->fmt->color == S5P_FIMC_RGB666)
+                        break;
+                case S5P_FIMC_RGB666:
                         cfg |= S5P_CISCCTRL_INRGB_FMT_RGB666;
-                else if (src_frame->fmt->color == S5P_FIMC_RGB888)
+                        break;
+                case S5P_FIMC_RGB888:
                         cfg |= S5P_CISCCTRL_INRGB_FMT_RGB888;
+                        break;
+                }
         }
 
         if (ctx->out_path == FIMC_DMA) {
-                if (dst_frame->fmt->color == S5P_FIMC_RGB565)
+                u32 color = dst_frame->fmt->color;
+
+                if (color >= S5P_FIMC_RGB444 && color <= S5P_FIMC_RGB565)
                         cfg |= S5P_CISCCTRL_OUTRGB_FMT_RGB565;
-                else if (dst_frame->fmt->color == S5P_FIMC_RGB666)
+                else if (color == S5P_FIMC_RGB666)
                         cfg |= S5P_CISCCTRL_OUTRGB_FMT_RGB666;
-                else if (dst_frame->fmt->color == S5P_FIMC_RGB888)
+                else if (color == S5P_FIMC_RGB888)
                         cfg |= S5P_CISCCTRL_OUTRGB_FMT_RGB888;
         } else {
                 cfg |= S5P_CISCCTRL_OUTRGB_FMT_RGB888;
@@ -379,6 +393,21 @@ void fimc_hw_set_effect(struct fimc_ctx *ctx, bool active)
         writel(cfg, dev->regs + S5P_CIIMGEFF);
 }
 
+void fimc_hw_set_rgb_alpha(struct fimc_ctx *ctx)
+{
+        struct fimc_dev *dev = ctx->fimc_dev;
+        struct fimc_frame *frame = &ctx->d_frame;
+        u32 cfg;
+
+        if (!(frame->fmt->flags & FMT_HAS_ALPHA))
+                return;
+
+        cfg = readl(dev->regs + S5P_CIOCTRL);
+        cfg &= ~S5P_CIOCTRL_ALPHA_OUT_MASK;
+        cfg |= (frame->alpha << 4);
+        writel(cfg, dev->regs + S5P_CIOCTRL);
+}
+
 static void fimc_hw_set_in_dma_size(struct fimc_ctx *ctx)
 {
         struct fimc_dev *dev = ctx->fimc_dev;
diff --git a/drivers/media/video/s5p-fimc/mipi-csis.c b/drivers/media/video/s5p-fimc/mipi-csis.c
index 59d79bc2f58a..130335cf62fd 100644
--- a/drivers/media/video/s5p-fimc/mipi-csis.c
+++ b/drivers/media/video/s5p-fimc/mipi-csis.c
@@ -427,6 +427,23 @@ static int s5pcsis_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh,
         return 0;
 }
 
+static int s5pcsis_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
+{
+        struct v4l2_mbus_framefmt *format = v4l2_subdev_get_try_format(fh, 0);
+
+        format->colorspace = V4L2_COLORSPACE_JPEG;
+        format->code = s5pcsis_formats[0].code;
+        format->width = S5PCSIS_DEF_PIX_WIDTH;
+        format->height = S5PCSIS_DEF_PIX_HEIGHT;
+        format->field = V4L2_FIELD_NONE;
+
+        return 0;
+}
+
+static const struct v4l2_subdev_internal_ops s5pcsis_sd_internal_ops = {
+        .open = s5pcsis_open,
+};
+
 static struct v4l2_subdev_core_ops s5pcsis_core_ops = {
         .s_power = s5pcsis_s_power,
 };
@@ -544,8 +561,13 @@ static int __devinit s5pcsis_probe(struct platform_device *pdev)
         v4l2_subdev_init(&state->sd, &s5pcsis_subdev_ops);
         state->sd.owner = THIS_MODULE;
         strlcpy(state->sd.name, dev_name(&pdev->dev), sizeof(state->sd.name));
+        state->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
         state->csis_fmt = &s5pcsis_formats[0];
 
+        state->format.code = s5pcsis_formats[0].code;
+        state->format.width = S5PCSIS_DEF_PIX_WIDTH;
+        state->format.height = S5PCSIS_DEF_PIX_HEIGHT;
+
         state->pads[CSIS_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
         state->pads[CSIS_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
         ret = media_entity_init(&state->sd.entity,
diff --git a/drivers/media/video/s5p-fimc/mipi-csis.h b/drivers/media/video/s5p-fimc/mipi-csis.h
index f5691336dd5c..2709286396e1 100644
--- a/drivers/media/video/s5p-fimc/mipi-csis.h
+++ b/drivers/media/video/s5p-fimc/mipi-csis.h
@@ -19,4 +19,7 @@
 #define CSIS_PAD_SOURCE         1
 #define CSIS_PADS_NUM           2
 
+#define S5PCSIS_DEF_PIX_WIDTH   640
+#define S5PCSIS_DEF_PIX_HEIGHT  480
+
 #endif
diff --git a/drivers/media/video/s5p-fimc/regs-fimc.h b/drivers/media/video/s5p-fimc/regs-fimc.h
index c8e3b94bd91d..c7a5bc51d571 100644
--- a/drivers/media/video/s5p-fimc/regs-fimc.h
+++ b/drivers/media/video/s5p-fimc/regs-fimc.h
@@ -107,6 +107,11 @@
 #define S5P_CIOCTRL_YCBCR_3PLANE        (0 << 3)
 #define S5P_CIOCTRL_YCBCR_2PLANE        (1 << 3)
 #define S5P_CIOCTRL_YCBCR_PLANE_MASK    (1 << 3)
+#define S5P_CIOCTRL_ALPHA_OUT_MASK      (0xff << 4)
+#define S5P_CIOCTRL_RGB16FMT_MASK       (3 << 16)
+#define S5P_CIOCTRL_RGB565              (0 << 16)
+#define S5P_CIOCTRL_ARGB1555            (1 << 16)
+#define S5P_CIOCTRL_ARGB4444            (2 << 16)
 #define S5P_CIOCTRL_ORDER2P_SHIFT       (24)
 #define S5P_CIOCTRL_ORDER2P_MASK        (3 << 24)
 #define S5P_CIOCTRL_ORDER422_2P_LSB_CRCB (0 << 24)
diff --git a/drivers/media/video/s5p-g2d/Makefile b/drivers/media/video/s5p-g2d/Makefile
new file mode 100644
index 000000000000..2c48c416a804
--- /dev/null
+++ b/drivers/media/video/s5p-g2d/Makefile
@@ -0,0 +1,3 @@
+s5p-g2d-objs := g2d.o g2d-hw.o
+
+obj-$(CONFIG_VIDEO_SAMSUNG_S5P_G2D)     += s5p-g2d.o
diff --git a/drivers/media/video/s5p-g2d/g2d-hw.c b/drivers/media/video/s5p-g2d/g2d-hw.c
new file mode 100644
index 000000000000..39937cf03c88
--- /dev/null
+++ b/drivers/media/video/s5p-g2d/g2d-hw.c
@@ -0,0 +1,104 @@
+/*
+ * Samsung S5P G2D - 2D Graphics Accelerator Driver
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ * Kamil Debski, <k.debski@samsung.com>
+ *
+ * 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
+ */
+
+#include <linux/io.h>
+
+#include "g2d.h"
+#include "g2d-regs.h"
+
+#define w(x, a) writel((x), d->regs + (a))
+#define r(a)    readl(d->regs + (a))
+
+/* g2d_reset clears all g2d registers */
+void g2d_reset(struct g2d_dev *d)
+{
+        w(1, SOFT_RESET_REG);
+}
+
+void g2d_set_src_size(struct g2d_dev *d, struct g2d_frame *f)
+{
+        u32 n;
+
+        w(f->stride & 0xFFFF, SRC_STRIDE_REG);
+
+        n = f->o_height & 0xFFF;
+        n <<= 16;
+        n |= f->o_width & 0xFFF;
+        w(n, SRC_LEFT_TOP_REG);
+
+        n = f->bottom & 0xFFF;
+        n <<= 16;
+        n |= f->right & 0xFFF;
+        w(n, SRC_RIGHT_BOTTOM_REG);
+
+        w(f->fmt->hw, SRC_COLOR_MODE_REG);
+}
+
+void g2d_set_src_addr(struct g2d_dev *d, dma_addr_t a)
+{
+        w(a, SRC_BASE_ADDR_REG);
+}
+
+void g2d_set_dst_size(struct g2d_dev *d, struct g2d_frame *f)
+{
+        u32 n;
+
+        w(f->stride & 0xFFFF, DST_STRIDE_REG);
+
+        n = f->o_height & 0xFFF;
+        n <<= 16;
+        n |= f->o_width & 0xFFF;
+        w(n, DST_LEFT_TOP_REG);
+
+        n = f->bottom & 0xFFF;
+        n <<= 16;
+        n |= f->right & 0xFFF;
+        w(n, DST_RIGHT_BOTTOM_REG);
+
+        w(f->fmt->hw, DST_COLOR_MODE_REG);
+}
+
+void g2d_set_dst_addr(struct g2d_dev *d, dma_addr_t a)
+{
+        w(a, DST_BASE_ADDR_REG);
+}
+
+void g2d_set_rop4(struct g2d_dev *d, u32 r)
+{
+        w(r, ROP4_REG);
+}
+
+u32 g2d_cmd_stretch(u32 e)
+{
+        e &= 1;
+        return e << 4;
+}
+
+void g2d_set_cmd(struct g2d_dev *d, u32 c)
+{
+        w(c, BITBLT_COMMAND_REG);
+}
+
+void g2d_start(struct g2d_dev *d)
+{
+        /* Clear cache */
+        w(0x7, CACHECTL_REG);
+        /* Enable interrupt */
+        w(1, INTEN_REG);
+        /* Start G2D engine */
+        w(1, BITBLT_START_REG);
+}
+
+void g2d_clear_int(struct g2d_dev *d)
+{
+        w(1, INTC_PEND_REG);
+}
diff --git a/drivers/media/video/s5p-g2d/g2d-regs.h b/drivers/media/video/s5p-g2d/g2d-regs.h
new file mode 100644
index 000000000000..02e1cf50da4e
--- /dev/null
+++ b/drivers/media/video/s5p-g2d/g2d-regs.h
@@ -0,0 +1,115 @@
+/*
+ * Samsung S5P G2D - 2D Graphics Accelerator Driver
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ * Kamil Debski, <k.debski@samsung.com>
+ *
+ * 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
+ */
+
+/* General Registers */
+#define SOFT_RESET_REG          0x0000  /* Software reset reg */
+#define INTEN_REG               0x0004  /* Interrupt Enable reg */
+#define INTC_PEND_REG           0x000C  /* Interrupt Control Pending reg */
+#define FIFO_STAT_REG           0x0010  /* Command FIFO Status reg */
+#define AXI_ID_MODE_REG         0x0014  /* AXI Read ID Mode reg */
+#define CACHECTL_REG            0x0018  /* Cache & Buffer clear reg */
+#define AXI_MODE_REG            0x001C  /* AXI Mode reg */
+
+/* Command Registers */
+#define BITBLT_START_REG        0x0100  /* BitBLT Start reg */
+#define BITBLT_COMMAND_REG      0x0104  /* Command reg for BitBLT */
+
+/* Parameter Setting Registers (Rotate & Direction) */
+#define ROTATE_REG              0x0200  /* Rotation reg */
+#define SRC_MSK_DIRECT_REG      0x0204  /* Src and Mask Direction reg */
+#define DST_PAT_DIRECT_REG      0x0208  /* Dest and Pattern Direction reg */
+
+/* Parameter Setting Registers (Src) */
+#define SRC_SELECT_REG          0x0300  /* Src Image Selection reg */
+#define SRC_BASE_ADDR_REG       0x0304  /* Src Image Base Address reg */
+#define SRC_STRIDE_REG          0x0308  /* Src Stride reg */
+#define SRC_COLOR_MODE_REG      0x030C  /* Src Image Color Mode reg */
+#define SRC_LEFT_TOP_REG        0x0310  /* Src Left Top Coordinate reg */
+#define SRC_RIGHT_BOTTOM_REG    0x0314  /* Src Right Bottom Coordinate reg */
+
+/* Parameter Setting Registers (Dest) */
+#define DST_SELECT_REG          0x0400  /* Dest Image Selection reg */
+#define DST_BASE_ADDR_REG       0x0404  /* Dest Image Base Address reg */
+#define DST_STRIDE_REG          0x0408  /* Dest Stride reg */
+#define DST_COLOR_MODE_REG      0x040C  /* Dest Image Color Mode reg */
+#define DST_LEFT_TOP_REG        0x0410  /* Dest Left Top Coordinate reg */
+#define DST_RIGHT_BOTTOM_REG    0x0414  /* Dest Right Bottom Coordinate reg */
+
+/* Parameter Setting Registers (Pattern) */
+#define PAT_BASE_ADDR_REG       0x0500  /* Pattern Image Base Address reg */
+#define PAT_SIZE_REG            0x0504  /* Pattern Image Size reg */
+#define PAT_COLOR_MODE_REG      0x0508  /* Pattern Image Color Mode reg */
+#define PAT_OFFSET_REG          0x050C  /* Pattern Left Top Coordinate reg */
+#define PAT_STRIDE_REG          0x0510  /* Pattern Stride reg */
+
+/* Parameter Setting Registers (Mask) */
+#define MASK_BASE_ADDR_REG      0x0520  /* Mask Base Address reg */
+#define MASK_STRIDE_REG         0x0524  /* Mask Stride reg */
+
+/* Parameter Setting Registers (Clipping Window) */
+#define CW_LT_REG               0x0600  /* LeftTop coordinates of Clip Window */
+#define CW_RB_REG               0x0604  /* RightBottom coordinates of Clip
+                                                                Window */
+
+/* Parameter Setting Registers (ROP & Alpha Setting) */
+#define THIRD_OPERAND_REG       0x0610  /* Third Operand Selection reg */
+#define ROP4_REG                0x0614  /* Raster Operation reg */
+#define ALPHA_REG               0x0618  /* Alpha value, Fading offset value */
+
+/* Parameter Setting Registers (Color) */
+#define FG_COLOR_REG            0x0700  /* Foreground Color reg */
+#define BG_COLOR_REG            0x0704  /* Background Color reg */
+#define BS_COLOR_REG            0x0708  /* Blue Screen Color reg */
+
+/* Parameter Setting Registers (Color Key) */
+#define SRC_COLORKEY_CTRL_REG   0x0710  /* Src Colorkey control reg */
+#define SRC_COLORKEY_DR_MIN_REG 0x0714  /* Src Colorkey Decision Reference
+                                                                Min reg */
+#define SRC_COLORKEY_DR_MAX_REG 0x0718  /* Src Colorkey Decision Reference
+                                                                Max reg */
+#define DST_COLORKEY_CTRL_REG   0x071C  /* Dest Colorkey control reg */
+#define DST_COLORKEY_DR_MIN_REG 0x0720  /* Dest Colorkey Decision Reference
+                                                                Min reg */
+#define DST_COLORKEY_DR_MAX_REG 0x0724  /* Dest Colorkey Decision Reference
+                                                                Max reg */
+
+/* Color mode values */
+
+#define ORDER_XRGB              0
+#define ORDER_RGBX              1
+#define ORDER_XBGR              2
+#define ORDER_BGRX              3
+
+#define MODE_XRGB_8888          0
+#define MODE_ARGB_8888          1
+#define MODE_RGB_565            2
+#define MODE_XRGB_1555          3
+#define MODE_ARGB_1555          4
+#define MODE_XRGB_4444          5
+#define MODE_ARGB_4444          6
+#define MODE_PACKED_RGB_888     7
+
+#define COLOR_MODE(o, m)        (((o) << 4) | (m))
+
+/* ROP4 operation values */
+#define ROP4_COPY               0xCCCC
+#define ROP4_INVERT             0x3333
+
+/* Hardware limits */
+#define MAX_WIDTH               8000
+#define MAX_HEIGHT              8000
+
+#define G2D_TIMEOUT             500
+
+#define DEFAULT_WIDTH           100
+#define DEFAULT_HEIGHT          100
+
diff --git a/drivers/media/video/s5p-g2d/g2d.c b/drivers/media/video/s5p-g2d/g2d.c
new file mode 100644
index 000000000000..c40b0dde1883
--- /dev/null
+++ b/drivers/media/video/s5p-g2d/g2d.c
@@ -0,0 +1,810 @@
+/*
+ * Samsung S5P G2D - 2D Graphics Accelerator Driver
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ * Kamil Debski, <k.debski@samsung.com>
+ *
+ * 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
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/version.h>
+#include <linux/timer.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/clk.h>
+#include <linux/interrupt.h>
+
+#include <linux/platform_device.h>
+#include <media/v4l2-mem2mem.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-ioctl.h>
+#include <media/videobuf2-core.h>
+#include <media/videobuf2-dma-contig.h>
+
+#include "g2d.h"
+#include "g2d-regs.h"
+
+#define fh2ctx(__fh) container_of(__fh, struct g2d_ctx, fh)
+
+static struct g2d_fmt formats[] = {
+        {
+                .name   = "XRGB_8888",
+                .fourcc = V4L2_PIX_FMT_RGB32,
+                .depth  = 32,
+                .hw     = COLOR_MODE(ORDER_XRGB, MODE_XRGB_8888),
+        },
+        {
+                .name   = "RGB_565",
+                .fourcc = V4L2_PIX_FMT_RGB565X,
+                .depth  = 16,
+                .hw     = COLOR_MODE(ORDER_XRGB, MODE_RGB_565),
+        },
+        {
+                .name   = "XRGB_1555",
+                .fourcc = V4L2_PIX_FMT_RGB555X,
+                .depth  = 16,
+                .hw     = COLOR_MODE(ORDER_XRGB, MODE_XRGB_1555),
+        },
+        {
+                .name   = "XRGB_4444",
+                .fourcc = V4L2_PIX_FMT_RGB444,
+                .depth  = 16,
+                .hw     = COLOR_MODE(ORDER_XRGB, MODE_XRGB_4444),
+        },
+        {
+                .name   = "PACKED_RGB_888",
+                .fourcc = V4L2_PIX_FMT_RGB24,
+                .depth  = 24,
+                .hw     = COLOR_MODE(ORDER_XRGB, MODE_PACKED_RGB_888),
+        },
+};
+#define NUM_FORMATS ARRAY_SIZE(formats)
+
+struct g2d_frame def_frame = {
+        .width          = DEFAULT_WIDTH,
+        .height         = DEFAULT_HEIGHT,
+        .c_width        = DEFAULT_WIDTH,
+        .c_height       = DEFAULT_HEIGHT,
+        .o_width        = 0,
+        .o_height       = 0,
+        .fmt            = &formats[0],
+        .right          = DEFAULT_WIDTH,
+        .bottom         = DEFAULT_HEIGHT,
+};
+
+struct g2d_fmt *find_fmt(struct v4l2_format *f)
+{
+        unsigned int i;
+        for (i = 0; i < NUM_FORMATS; i++) {
+                if (formats[i].fourcc == f->fmt.pix.pixelformat)
+                        return &formats[i];
+        }
+        return NULL;
+}
+
+
+static struct g2d_frame *get_frame(struct g2d_ctx *ctx,
+                                                        enum v4l2_buf_type type)
+{
+        switch (type) {
+        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                return &ctx->in;
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                return &ctx->out;
+        default:
+                return ERR_PTR(-EINVAL);
+        }
+}
+
+static int g2d_queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
+                           unsigned int *nbuffers, unsigned int *nplanes,
+                           unsigned int sizes[], void *alloc_ctxs[])
+{
+        struct g2d_ctx *ctx = vb2_get_drv_priv(vq);
+        struct g2d_frame *f = get_frame(ctx, vq->type);
+
+        if (IS_ERR(f))
+                return PTR_ERR(f);
+
+        sizes[0] = f->size;
+        *nplanes = 1;
+        alloc_ctxs[0] = ctx->dev->alloc_ctx;
+
+        if (*nbuffers == 0)
+                *nbuffers = 1;
+
+        return 0;
+}
+
+static int g2d_buf_prepare(struct vb2_buffer *vb)
+{
+        struct g2d_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
+        struct g2d_frame *f = get_frame(ctx, vb->vb2_queue->type);
+
+        if (IS_ERR(f))
+                return PTR_ERR(f);
+        vb2_set_plane_payload(vb, 0, f->size);
+        return 0;
+}
+
+static void g2d_buf_queue(struct vb2_buffer *vb)
+{
+        struct g2d_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
+        v4l2_m2m_buf_queue(ctx->m2m_ctx, vb);
+}
+
+
+static struct vb2_ops g2d_qops = {
+        .queue_setup    = g2d_queue_setup,
+        .buf_prepare    = g2d_buf_prepare,
+        .buf_queue      = g2d_buf_queue,
+};
+
+static int queue_init(void *priv, struct vb2_queue *src_vq,
+                                                struct vb2_queue *dst_vq)
+{
+        struct g2d_ctx *ctx = priv;
+        int ret;
+
+        memset(src_vq, 0, sizeof(*src_vq));
+        src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+        src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+        src_vq->drv_priv = ctx;
+        src_vq->ops = &g2d_qops;
+        src_vq->mem_ops = &vb2_dma_contig_memops;
+        src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
+
+        ret = vb2_queue_init(src_vq);
+        if (ret)
+                return ret;
+
+        memset(dst_vq, 0, sizeof(*dst_vq));
+        dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+        dst_vq->drv_priv = ctx;
+        dst_vq->ops = &g2d_qops;
+        dst_vq->mem_ops = &vb2_dma_contig_memops;
+        dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
+
+        return vb2_queue_init(dst_vq);
+}
+
+static int g2d_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+        struct g2d_ctx *ctx = container_of(ctrl->handler, struct g2d_ctx,
+                                                                ctrl_handler);
+        switch (ctrl->id) {
+        case V4L2_CID_COLORFX:
+                if (ctrl->val == V4L2_COLORFX_NEGATIVE)
+                        ctx->rop = ROP4_INVERT;
+                else
+                        ctx->rop = ROP4_COPY;
+        default:
+                v4l2_err(&ctx->dev->v4l2_dev, "unknown control\n");
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static const struct v4l2_ctrl_ops g2d_ctrl_ops = {
+        .s_ctrl         = g2d_s_ctrl,
+};
+
+int g2d_setup_ctrls(struct g2d_ctx *ctx)
+{
+        struct g2d_dev *dev = ctx->dev;
+
+        v4l2_ctrl_handler_init(&ctx->ctrl_handler, 1);
+        if (ctx->ctrl_handler.error) {
+                v4l2_err(&dev->v4l2_dev, "v4l2_ctrl_handler_init failed\n");
+                return ctx->ctrl_handler.error;
+        }
+
+        v4l2_ctrl_new_std_menu(
+                &ctx->ctrl_handler,
+                &g2d_ctrl_ops,
+                V4L2_CID_COLORFX,
+                V4L2_COLORFX_NEGATIVE,
+                ~((1 << V4L2_COLORFX_NONE) | (1 << V4L2_COLORFX_NEGATIVE)),
+                V4L2_COLORFX_NONE);
+
+        if (ctx->ctrl_handler.error) {
+                v4l2_err(&dev->v4l2_dev, "v4l2_ctrl_handler_init failed\n");
+                return ctx->ctrl_handler.error;
+        }
+
+        return 0;
+}
+
+static int g2d_open(struct file *file)
+{
+        struct g2d_dev *dev = video_drvdata(file);
+        struct g2d_ctx *ctx = NULL;
+        int ret = 0;
+
+        ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
+        if (!ctx)
+                return -ENOMEM;
+        ctx->dev = dev;
+        /* Set default formats */
+        ctx->in         = def_frame;
+        ctx->out        = def_frame;
+
+        ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx, &queue_init);
+        if (IS_ERR(ctx->m2m_ctx)) {
+                ret = PTR_ERR(ctx->m2m_ctx);
+                kfree(ctx);
+                return ret;
+        }
+        v4l2_fh_init(&ctx->fh, video_devdata(file));
+        file->private_data = &ctx->fh;
+        v4l2_fh_add(&ctx->fh);
+
+        g2d_setup_ctrls(ctx);
+
+        /* Write the default values to the ctx struct */
+        v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
+
+        ctx->fh.ctrl_handler = &ctx->ctrl_handler;
+
+        v4l2_info(&dev->v4l2_dev, "instance opened\n");
+        return 0;
+}
+
+static int g2d_release(struct file *file)
+{
+        struct g2d_dev *dev = video_drvdata(file);
+        struct g2d_ctx *ctx = fh2ctx(file->private_data);
+
+        v4l2_ctrl_handler_free(&ctx->ctrl_handler);
+        v4l2_fh_del(&ctx->fh);
+        v4l2_fh_exit(&ctx->fh);
+        kfree(ctx);
+        v4l2_info(&dev->v4l2_dev, "instance closed\n");
+        return 0;
+}
+
+
+static int vidioc_querycap(struct file *file, void *priv,
+                                struct v4l2_capability *cap)
+{
+        strncpy(cap->driver, G2D_NAME, sizeof(cap->driver) - 1);
+        strncpy(cap->card, G2D_NAME, sizeof(cap->card) - 1);
+        cap->bus_info[0] = 0;
+        cap->version = KERNEL_VERSION(1, 0, 0);
+        cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT
+                                                        | V4L2_CAP_STREAMING;
+        return 0;
+}
+
+static int vidioc_enum_fmt(struct file *file, void *prv, struct v4l2_fmtdesc *f)
+{
+        struct g2d_fmt *fmt;
+        if (f->index >= NUM_FORMATS)
+                return -EINVAL;
+        fmt = &formats[f->index];
+        f->pixelformat = fmt->fourcc;
+        strncpy(f->description, fmt->name, sizeof(f->description) - 1);
+        return 0;
+}
+
+static int vidioc_g_fmt(struct file *file, void *prv, struct v4l2_format *f)
+{
+        struct g2d_ctx *ctx = prv;
+        struct vb2_queue *vq;
+        struct g2d_frame *frm;
+
+        vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
+        if (!vq)
+                return -EINVAL;
+        frm = get_frame(ctx, f->type);
+        if (IS_ERR(frm))
+                return PTR_ERR(frm);
+
+        f->fmt.pix.width                = frm->width;
+        f->fmt.pix.height               = frm->height;
+        f->fmt.pix.field                = V4L2_FIELD_NONE;
+        f->fmt.pix.pixelformat          = frm->fmt->fourcc;
+        f->fmt.pix.bytesperline         = (frm->width * frm->fmt->depth) >> 3;
+        f->fmt.pix.sizeimage            = frm->size;
+        return 0;
+}
+
+static int vidioc_try_fmt(struct file *file, void *prv, struct v4l2_format *f)
+{
+        struct g2d_fmt *fmt;
+        enum v4l2_field *field;
+
+        fmt = find_fmt(f);
+        if (!fmt)
+                return -EINVAL;
+
+        field = &f->fmt.pix.field;
+        if (*field == V4L2_FIELD_ANY)
+                *field = V4L2_FIELD_NONE;
+        else if (*field != V4L2_FIELD_NONE)
+                return -EINVAL;
+
+        if (f->fmt.pix.width > MAX_WIDTH)
+                f->fmt.pix.width = MAX_WIDTH;
+        if (f->fmt.pix.height > MAX_HEIGHT)
+                f->fmt.pix.height = MAX_HEIGHT;
+
+        if (f->fmt.pix.width < 1)
+                f->fmt.pix.width = 1;
+        if (f->fmt.pix.height < 1)
+                f->fmt.pix.height = 1;
+
+        f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
+        f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
+        return 0;
+}
+
+static int vidioc_s_fmt(struct file *file, void *prv, struct v4l2_format *f)
+{
+        struct g2d_ctx *ctx = prv;
+        struct g2d_dev *dev = ctx->dev;
+        struct vb2_queue *vq;
+        struct g2d_frame *frm;
+        struct g2d_fmt *fmt;
+        int ret = 0;
+
+        /* Adjust all values accordingly to the hardware capabilities
+         * and chosen format. */
+        ret = vidioc_try_fmt(file, prv, f);
+        if (ret)
+                return ret;
+        vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
+        if (vb2_is_busy(vq)) {
+                v4l2_err(&dev->v4l2_dev, "queue (%d) bust\n", f->type);
+                return -EBUSY;
+        }
+        frm = get_frame(ctx, f->type);
+        if (IS_ERR(frm))
+                return PTR_ERR(frm);
+        fmt = find_fmt(f);
+        if (!fmt)
+                return -EINVAL;
+        frm->width      = f->fmt.pix.width;
+        frm->height     = f->fmt.pix.height;
+        frm->size       = f->fmt.pix.sizeimage;
+        /* Reset crop settings */
+        frm->o_width    = 0;
+        frm->o_height   = 0;
+        frm->c_width    = frm->width;
+        frm->c_height   = frm->height;
+        frm->right      = frm->width;
+        frm->bottom     = frm->height;
+        frm->fmt        = fmt;
+        frm->stride     = f->fmt.pix.bytesperline;
+        return 0;
+}
+
+static unsigned int g2d_poll(struct file *file, struct poll_table_struct *wait)
+{
+        struct g2d_ctx *ctx = fh2ctx(file->private_data);
+        return v4l2_m2m_poll(file, ctx->m2m_ctx, wait);
+}
+
+static int g2d_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        struct g2d_ctx *ctx = fh2ctx(file->private_data);
+        return v4l2_m2m_mmap(file, ctx->m2m_ctx, vma);
+}
+
+static int vidioc_reqbufs(struct file *file, void *priv,
+                        struct v4l2_requestbuffers *reqbufs)
+{
+        struct g2d_ctx *ctx = priv;
+        return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
+}
+
+static int vidioc_querybuf(struct file *file, void *priv,
+                        struct v4l2_buffer *buf)
+{
+        struct g2d_ctx *ctx = priv;
+        return v4l2_m2m_querybuf(file, ctx->m2m_ctx, buf);
+}
+
+static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
+{
+        struct g2d_ctx *ctx = priv;
+        return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
+}
+
+static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
+{
+        struct g2d_ctx *ctx = priv;
+        return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
+}
+
+
+static int vidioc_streamon(struct file *file, void *priv,
+                                        enum v4l2_buf_type type)
+{
+        struct g2d_ctx *ctx = priv;
+        return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
+}
+
+static int vidioc_streamoff(struct file *file, void *priv,
+                                        enum v4l2_buf_type type)
+{
+        struct g2d_ctx *ctx = priv;
+        return v4l2_m2m_streamoff(file, ctx->m2m_ctx, type);
+}
+
+static int vidioc_cropcap(struct file *file, void *priv,
+                                        struct v4l2_cropcap *cr)
+{
+        struct g2d_ctx *ctx = priv;
+        struct g2d_frame *f;
+
+        f = get_frame(ctx, cr->type);
+        if (IS_ERR(f))
+                return PTR_ERR(f);
+
+        cr->bounds.left         = 0;
+        cr->bounds.top          = 0;
+        cr->bounds.width        = f->width;
+        cr->bounds.height       = f->height;
+        cr->defrect             = cr->bounds;
+        return 0;
+}
+
+static int vidioc_g_crop(struct file *file, void *prv, struct v4l2_crop *cr)
+{
+        struct g2d_ctx *ctx = prv;
+        struct g2d_frame *f;
+
+        f = get_frame(ctx, cr->type);
+        if (IS_ERR(f))
+                return PTR_ERR(f);
+
+        cr->c.left      = f->o_height;
+        cr->c.top       = f->o_width;
+        cr->c.width     = f->c_width;
+        cr->c.height    = f->c_height;
+        return 0;
+}
+
+static int vidioc_try_crop(struct file *file, void *prv, struct v4l2_crop *cr)
+{
+        struct g2d_ctx *ctx = prv;
+        struct g2d_dev *dev = ctx->dev;
+        struct g2d_frame *f;
+
+        f = get_frame(ctx, cr->type);
+        if (IS_ERR(f))
+                return PTR_ERR(f);
+
+        if (cr->c.top < 0 || cr->c.left < 0) {
+                v4l2_err(&dev->v4l2_dev,
+                        "doesn't support negative values for top & left\n");
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int vidioc_s_crop(struct file *file, void *prv, struct v4l2_crop *cr)
+{
+        struct g2d_ctx *ctx = prv;
+        struct g2d_frame *f;
+        int ret;
+
+        ret = vidioc_try_crop(file, prv, cr);
+        if (ret)
+                return ret;
+        f = get_frame(ctx, cr->type);
+        if (IS_ERR(f))
+                return PTR_ERR(f);
+
+        f->c_width      = cr->c.width;
+        f->c_height     = cr->c.height;
+        f->o_width      = cr->c.left;
+        f->o_height     = cr->c.top;
+        f->bottom       = f->o_height + f->c_height;
+        f->right        = f->o_width + f->c_width;
+        return 0;
+}
+
+static void g2d_lock(void *prv)
+{
+        struct g2d_ctx *ctx = prv;
+        struct g2d_dev *dev = ctx->dev;
+        mutex_lock(&dev->mutex);
+}
+
+static void g2d_unlock(void *prv)
+{
+        struct g2d_ctx *ctx = prv;
+        struct g2d_dev *dev = ctx->dev;
+        mutex_unlock(&dev->mutex);
+}
+
+static void job_abort(void *prv)
+{
+        struct g2d_ctx *ctx = prv;
+        struct g2d_dev *dev = ctx->dev;
+        int ret;
+
+        if (dev->curr == 0) /* No job currently running */
+                return;
+
+        ret = wait_event_timeout(dev->irq_queue,
+                dev->curr == 0,
+                msecs_to_jiffies(G2D_TIMEOUT));
+}
+
+static void device_run(void *prv)
+{
+        struct g2d_ctx *ctx = prv;
+        struct g2d_dev *dev = ctx->dev;
+        struct vb2_buffer *src, *dst;
+        u32 cmd = 0;
+
+        dev->curr = ctx;
+
+        src = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
+        dst = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
+
+        clk_enable(dev->gate);
+        g2d_reset(dev);
+
+        g2d_set_src_size(dev, &ctx->in);
+        g2d_set_src_addr(dev, vb2_dma_contig_plane_dma_addr(src, 0));
+
+        g2d_set_dst_size(dev, &ctx->out);
+        g2d_set_dst_addr(dev, vb2_dma_contig_plane_dma_addr(dst, 0));
+
+        g2d_set_rop4(dev, ctx->rop);
+        if (ctx->in.c_width != ctx->out.c_width ||
+                ctx->in.c_height != ctx->out.c_height)
+                cmd |= g2d_cmd_stretch(1);
+        g2d_set_cmd(dev, cmd);
+        g2d_start(dev);
+}
+
+static irqreturn_t g2d_isr(int irq, void *prv)
+{
+        struct g2d_dev *dev = prv;
+        struct g2d_ctx *ctx = dev->curr;
+        struct vb2_buffer *src, *dst;
+
+        g2d_clear_int(dev);
+        clk_disable(dev->gate);
+
+        BUG_ON(ctx == 0);
+
+        src = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
+        dst = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
+
+        BUG_ON(src == 0);
+        BUG_ON(dst == 0);
+
+        v4l2_m2m_buf_done(src, VB2_BUF_STATE_DONE);
+        v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);
+        v4l2_m2m_job_finish(dev->m2m_dev, ctx->m2m_ctx);
+
+        dev->curr = 0;
+        wake_up(&dev->irq_queue);
+        return IRQ_HANDLED;
+}
+
+static const struct v4l2_file_operations g2d_fops = {
+        .owner          = THIS_MODULE,
+        .open           = g2d_open,
+        .release        = g2d_release,
+        .poll           = g2d_poll,
+        .unlocked_ioctl = video_ioctl2,
+        .mmap           = g2d_mmap,
+};
+
+static const struct v4l2_ioctl_ops g2d_ioctl_ops = {
+        .vidioc_querycap        = vidioc_querycap,
+
+        .vidioc_enum_fmt_vid_cap        = vidioc_enum_fmt,
+        .vidioc_g_fmt_vid_cap           = vidioc_g_fmt,
+        .vidioc_try_fmt_vid_cap         = vidioc_try_fmt,
+        .vidioc_s_fmt_vid_cap           = vidioc_s_fmt,
+
+        .vidioc_enum_fmt_vid_out        = vidioc_enum_fmt,
+        .vidioc_g_fmt_vid_out           = vidioc_g_fmt,
+        .vidioc_try_fmt_vid_out         = vidioc_try_fmt,
+        .vidioc_s_fmt_vid_out           = vidioc_s_fmt,
+
+        .vidioc_reqbufs                 = vidioc_reqbufs,
+        .vidioc_querybuf                = vidioc_querybuf,
+
+        .vidioc_qbuf                    = vidioc_qbuf,
+        .vidioc_dqbuf                   = vidioc_dqbuf,
+
+        .vidioc_streamon                = vidioc_streamon,
+        .vidioc_streamoff               = vidioc_streamoff,
+
+        .vidioc_g_crop                  = vidioc_g_crop,
+        .vidioc_s_crop                  = vidioc_s_crop,
+        .vidioc_cropcap                 = vidioc_cropcap,
+};
+
+static struct video_device g2d_videodev = {
+        .name           = G2D_NAME,
+        .fops           = &g2d_fops,
+        .ioctl_ops      = &g2d_ioctl_ops,
+        .minor          = -1,
+        .release        = video_device_release,
+};
+
+static struct v4l2_m2m_ops g2d_m2m_ops = {
+        .device_run     = device_run,
+        .job_abort      = job_abort,
+        .lock           = g2d_lock,
+        .unlock         = g2d_unlock,
+};
+
+static int g2d_probe(struct platform_device *pdev)
+{
+        struct g2d_dev *dev;
+        struct video_device *vfd;
+        struct resource *res;
+        int ret = 0;
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (!dev)
+                return -ENOMEM;
+        spin_lock_init(&dev->irqlock);
+        mutex_init(&dev->mutex);
+        atomic_set(&dev->num_inst, 0);
+        init_waitqueue_head(&dev->irq_queue);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to find registers\n");
+                ret = -ENOENT;
+                goto free_dev;
+        }
+
+        dev->res_regs = request_mem_region(res->start, resource_size(res),
+                                                dev_name(&pdev->dev));
+
+        if (!dev->res_regs) {
+                dev_err(&pdev->dev, "failed to obtain register region\n");
+                ret = -ENOENT;
+                goto free_dev;
+        }
+
+        dev->regs = ioremap(res->start, resource_size(res));
+        if (!dev->regs) {
+                dev_err(&pdev->dev, "failed to map registers\n");
+                ret = -ENOENT;
+                goto rel_res_regs;
+        }
+
+        dev->clk = clk_get(&pdev->dev, "sclk_fimg2d");
+        if (IS_ERR_OR_NULL(dev->clk)) {
+                dev_err(&pdev->dev, "failed to get g2d clock\n");
+                ret = -ENXIO;
+                goto unmap_regs;
+        }
+
+        dev->gate = clk_get(&pdev->dev, "fimg2d");
+        if (IS_ERR_OR_NULL(dev->gate)) {
+                dev_err(&pdev->dev, "failed to get g2d clock gate\n");
+                ret = -ENXIO;
+                goto put_clk;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "failed to find IRQ\n");
+                ret = -ENXIO;
+                goto put_clk_gate;
+        }
+
+        dev->irq = res->start;
+
+        ret = request_irq(dev->irq, g2d_isr, 0, pdev->name, dev);
+        if (ret) {
+                dev_err(&pdev->dev, "failed to install IRQ\n");
+                goto put_clk_gate;
+        }
+
+        dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
+        if (IS_ERR(dev->alloc_ctx)) {
+                ret = PTR_ERR(dev->alloc_ctx);
+                goto rel_irq;
+        }
+
+        ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
+        if (ret)
+                goto alloc_ctx_cleanup;
+        vfd = video_device_alloc();
+        if (!vfd) {
+                v4l2_err(&dev->v4l2_dev, "Failed to allocate video device\n");
+                ret = -ENOMEM;
+                goto unreg_v4l2_dev;
+        }
+        *vfd = g2d_videodev;
+        vfd->lock = &dev->mutex;
+        ret = video_register_device(vfd, VFL_TYPE_GRABBER, 0);
+        if (ret) {
+                v4l2_err(&dev->v4l2_dev, "Failed to register video device\n");
+                goto rel_vdev;
+        }
+        video_set_drvdata(vfd, dev);
+        snprintf(vfd->name, sizeof(vfd->name), "%s", g2d_videodev.name);
+        dev->vfd = vfd;
+        v4l2_info(&dev->v4l2_dev, "device registered as /dev/video%d\n",
+                                                                vfd->num);
+        platform_set_drvdata(pdev, dev);
+        dev->m2m_dev = v4l2_m2m_init(&g2d_m2m_ops);
+        if (IS_ERR(dev->m2m_dev)) {
+                v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem device\n");
+                ret = PTR_ERR(dev->m2m_dev);
+                goto unreg_video_dev;
+        }
+
+        def_frame.stride = (def_frame.width * def_frame.fmt->depth) >> 3;
+
+        return 0;
+
+unreg_video_dev:
+        video_unregister_device(dev->vfd);
+rel_vdev:
+        video_device_release(vfd);
+unreg_v4l2_dev:
+        v4l2_device_unregister(&dev->v4l2_dev);
+alloc_ctx_cleanup:
+        vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
+rel_irq:
+        free_irq(dev->irq, dev);
+put_clk_gate:
+        clk_put(dev->gate);
+put_clk:
+        clk_put(dev->clk);
+unmap_regs:
+        iounmap(dev->regs);
+rel_res_regs:
+        release_resource(dev->res_regs);
+free_dev:
+        kfree(dev);
+        return ret;
+}
+
+static int g2d_remove(struct platform_device *pdev)
+{
+        struct g2d_dev *dev = (struct g2d_dev *)platform_get_drvdata(pdev);
+
+        v4l2_info(&dev->v4l2_dev, "Removing " G2D_NAME);
+        v4l2_m2m_release(dev->m2m_dev);
+        video_unregister_device(dev->vfd);
+        v4l2_device_unregister(&dev->v4l2_dev);
+        vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
+        free_irq(dev->irq, dev);
+        clk_put(dev->gate);
+        clk_put(dev->clk);
+        iounmap(dev->regs);
+        release_resource(dev->res_regs);
+        kfree(dev);
+        return 0;
+}
+
+static struct platform_driver g2d_pdrv = {
+        .probe          = g2d_probe,
+        .remove         = g2d_remove,
+        .driver         = {
+                .name = G2D_NAME,
+                .owner = THIS_MODULE,
+        },
+};
+
+module_platform_driver(g2d_pdrv);
+
+MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
+MODULE_DESCRIPTION("S5P G2D 2d graphics accelerator driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/s5p-g2d/g2d.h b/drivers/media/video/s5p-g2d/g2d.h
new file mode 100644
index 000000000000..5eae90107bf8
--- /dev/null
+++ b/drivers/media/video/s5p-g2d/g2d.h
@@ -0,0 +1,83 @@
+/*
+ * Samsung S5P G2D - 2D Graphics Accelerator Driver
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ * Kamil Debski, <k.debski@samsung.com>
+ *
+ * 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
+ */
+
+#include <media/v4l2-device.h>
+#include <media/v4l2-ctrls.h>
+
+#define G2D_NAME "s5p-g2d"
+
+struct g2d_dev {
+        struct v4l2_device      v4l2_dev;
+        struct v4l2_m2m_dev     *m2m_dev;
+        struct video_device     *vfd;
+        struct mutex            mutex;
+        spinlock_t              irqlock;
+        atomic_t                num_inst;
+        struct vb2_alloc_ctx    *alloc_ctx;
+        struct resource         *res_regs;
+        void __iomem            *regs;
+        struct clk              *clk;
+        struct clk              *gate;
+        struct g2d_ctx          *curr;
+        int irq;
+        wait_queue_head_t       irq_queue;
+};
+
+struct g2d_frame {
+        /* Original dimensions */
+        u32     width;
+        u32     height;
+        /* Crop size */
+        u32     c_width;
+        u32     c_height;
+        /* Offset */
+        u32     o_width;
+        u32     o_height;
+        /* Image format */
+        struct g2d_fmt *fmt;
+        /* Variables that can calculated once and reused */
+        u32     stride;
+        u32     bottom;
+        u32     right;
+        u32     size;
+};
+
+struct g2d_ctx {
+        struct v4l2_fh fh;
+        struct g2d_dev          *dev;
+        struct v4l2_m2m_ctx     *m2m_ctx;
+        struct g2d_frame        in;
+        struct g2d_frame        out;
+        struct v4l2_ctrl_handler ctrl_handler;
+        u32 rop;
+};
+
+struct g2d_fmt {
+        char    *name;
+        u32     fourcc;
+        int     depth;
+        u32     hw;
+};
+
+
+void g2d_reset(struct g2d_dev *d);
+void g2d_set_src_size(struct g2d_dev *d, struct g2d_frame *f);
+void g2d_set_src_addr(struct g2d_dev *d, dma_addr_t a);
+void g2d_set_dst_size(struct g2d_dev *d, struct g2d_frame *f);
+void g2d_set_dst_addr(struct g2d_dev *d, dma_addr_t a);
+void g2d_start(struct g2d_dev *d);
+void g2d_clear_int(struct g2d_dev *d);
+void g2d_set_rop4(struct g2d_dev *d, u32 r);
+u32 g2d_cmd_stretch(u32 e);
+void g2d_set_cmd(struct g2d_dev *d, u32 c);
+
+
diff --git a/drivers/media/video/s5p-jpeg/Makefile b/drivers/media/video/s5p-jpeg/Makefile
new file mode 100644
index 000000000000..ddc2900d88a2
--- /dev/null
+++ b/drivers/media/video/s5p-jpeg/Makefile
@@ -0,0 +1,2 @@
+s5p-jpeg-objs := jpeg-core.o
+obj-$(CONFIG_VIDEO_SAMSUNG_S5P_JPEG) := s5p-jpeg.o
diff --git a/drivers/media/video/s5p-jpeg/jpeg-core.c b/drivers/media/video/s5p-jpeg/jpeg-core.c
new file mode 100644
index 000000000000..f841a3e9845c
--- /dev/null
+++ b/drivers/media/video/s5p-jpeg/jpeg-core.c
@@ -0,0 +1,1481 @@
+/* linux/drivers/media/video/s5p-jpeg/jpeg-core.c
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/gfp.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/string.h>
+#include <media/v4l2-mem2mem.h>
+#include <media/v4l2-ioctl.h>
+#include <media/videobuf2-core.h>
+#include <media/videobuf2-dma-contig.h>
+
+#include "jpeg-core.h"
+#include "jpeg-hw.h"
+
+static struct s5p_jpeg_fmt formats_enc[] = {
+        {
+                .name           = "YUV 4:2:0 planar, YCbCr",
+                .fourcc         = V4L2_PIX_FMT_YUV420,
+                .depth          = 12,
+                .colplanes      = 3,
+                .types          = MEM2MEM_CAPTURE,
+        },
+        {
+                .name           = "YUV 4:2:2 packed, YCbYCr",
+                .fourcc         = V4L2_PIX_FMT_YUYV,
+                .depth          = 16,
+                .colplanes      = 1,
+                .types          = MEM2MEM_CAPTURE | MEM2MEM_OUTPUT,
+        },
+        {
+                .name           = "RGB565",
+                .fourcc         = V4L2_PIX_FMT_RGB565,
+                .depth          = 16,
+                .colplanes      = 1,
+                .types          = MEM2MEM_OUTPUT,
+        },
+};
+#define NUM_FORMATS_ENC ARRAY_SIZE(formats_enc)
+
+static struct s5p_jpeg_fmt formats_dec[] = {
+        {
+                .name           = "YUV 4:2:0 planar, YCbCr",
+                .fourcc         = V4L2_PIX_FMT_YUV420,
+                .depth          = 12,
+                .colplanes      = 3,
+                .h_align        = 4,
+                .v_align        = 4,
+                .types          = MEM2MEM_CAPTURE,
+        },
+        {
+                .name           = "YUV 4:2:2 packed, YCbYCr",
+                .fourcc         = V4L2_PIX_FMT_YUYV,
+                .depth          = 16,
+                .colplanes      = 1,
+                .h_align        = 4,
+                .v_align        = 3,
+                .types          = MEM2MEM_CAPTURE,
+        },
+        {
+                .name           = "JPEG JFIF",
+                .fourcc         = V4L2_PIX_FMT_JPEG,
+                .colplanes      = 1,
+                .types          = MEM2MEM_OUTPUT,
+        },
+};
+#define NUM_FORMATS_DEC ARRAY_SIZE(formats_dec)
+
+static const unsigned char qtbl_luminance[4][64] = {
+        {/* level 1 - high quality */
+                 8,  6,  6,  8, 12, 14, 16, 17,
+                 6,  6,  6,  8, 10, 13, 12, 15,
+                 6,  6,  7,  8, 13, 14, 18, 24,
+                 8,  8,  8, 14, 13, 19, 24, 35,
+                12, 10, 13, 13, 20, 26, 34, 39,
+                14, 13, 14, 19, 26, 34, 39, 39,
+                16, 12, 18, 24, 34, 39, 39, 39,
+                17, 15, 24, 35, 39, 39, 39, 39
+        },
+        {/* level 2 */
+                12,  8,  8, 12, 17, 21, 24, 23,
+                 8,  9,  9, 11, 15, 19, 18, 23,
+                 8,  9, 10, 12, 19, 20, 27, 36,
+                12, 11, 12, 21, 20, 28, 36, 53,
+                17, 15, 19, 20, 30, 39, 51, 59,
+                21, 19, 20, 28, 39, 51, 59, 59,
+                24, 18, 27, 36, 51, 59, 59, 59,
+                23, 23, 36, 53, 59, 59, 59, 59
+        },
+        {/* level 3 */
+                16, 11, 11, 16, 23, 27, 31, 30,
+                11, 12, 12, 15, 20, 23, 23, 30,
+                11, 12, 13, 16, 23, 26, 35, 47,
+                16, 15, 16, 23, 26, 37, 47, 64,
+                23, 20, 23, 26, 39, 51, 64, 64,
+                27, 23, 26, 37, 51, 64, 64, 64,
+                31, 23, 35, 47, 64, 64, 64, 64,
+                30, 30, 47, 64, 64, 64, 64, 64
+        },
+        {/*level 4 - low quality */
+                20, 16, 25, 39, 50, 46, 62, 68,
+                16, 18, 23, 38, 38, 53, 65, 68,
+                25, 23, 31, 38, 53, 65, 68, 68,
+                39, 38, 38, 53, 65, 68, 68, 68,
+                50, 38, 53, 65, 68, 68, 68, 68,
+                46, 53, 65, 68, 68, 68, 68, 68,
+                62, 65, 68, 68, 68, 68, 68, 68,
+                68, 68, 68, 68, 68, 68, 68, 68
+        }
+};
+
+static const unsigned char qtbl_chrominance[4][64] = {
+        {/* level 1 - high quality */
+                 9,  8,  9, 11, 14, 17, 19, 24,
+                 8, 10,  9, 11, 14, 13, 17, 22,
+                 9,  9, 13, 14, 13, 15, 23, 26,
+                11, 11, 14, 14, 15, 20, 26, 33,
+                14, 14, 13, 15, 20, 24, 33, 39,
+                17, 13, 15, 20, 24, 32, 39, 39,
+                19, 17, 23, 26, 33, 39, 39, 39,
+                24, 22, 26, 33, 39, 39, 39, 39
+        },
+        {/* level 2 */
+                13, 11, 13, 16, 20, 20, 29, 37,
+                11, 14, 14, 14, 16, 20, 26, 32,
+                13, 14, 15, 17, 20, 23, 35, 40,
+                16, 14, 17, 21, 23, 30, 40, 50,
+                20, 16, 20, 23, 30, 37, 50, 59,
+                20, 20, 23, 30, 37, 48, 59, 59,
+                29, 26, 35, 40, 50, 59, 59, 59,
+                37, 32, 40, 50, 59, 59, 59, 59
+        },
+        {/* level 3 */
+                17, 15, 17, 21, 20, 26, 38, 48,
+                15, 19, 18, 17, 20, 26, 35, 43,
+                17, 18, 20, 22, 26, 30, 46, 53,
+                21, 17, 22, 28, 30, 39, 53, 64,
+                20, 20, 26, 30, 39, 48, 64, 64,
+                26, 26, 30, 39, 48, 63, 64, 64,
+                38, 35, 46, 53, 64, 64, 64, 64,
+                48, 43, 53, 64, 64, 64, 64, 64
+        },
+        {/*level 4 - low quality */
+                21, 25, 32, 38, 54, 68, 68, 68,
+                25, 28, 24, 38, 54, 68, 68, 68,
+                32, 24, 32, 43, 66, 68, 68, 68,
+                38, 38, 43, 53, 68, 68, 68, 68,
+                54, 54, 66, 68, 68, 68, 68, 68,
+                68, 68, 68, 68, 68, 68, 68, 68,
+                68, 68, 68, 68, 68, 68, 68, 68,
+                68, 68, 68, 68, 68, 68, 68, 68
+        }
+};
+
+static const unsigned char hdctbl0[16] = {
+        0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
+};
+
+static const unsigned char hdctblg0[12] = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb
+};
+static const unsigned char hactbl0[16] = {
+        0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
+};
+static const unsigned char hactblg0[162] = {
+        0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+        0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+        0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+        0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+        0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+        0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+        0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+        0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+        0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+        0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+        0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+        0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+        0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+        0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+        0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+        0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+        0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+        0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+        0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+        0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+        0xf9, 0xfa
+};
+
+static inline void jpeg_set_qtbl(void __iomem *regs, const unsigned char *qtbl,
+                   unsigned long tab, int len)
+{
+        int i;
+
+        for (i = 0; i < len; i++)
+                writel((unsigned int)qtbl[i], regs + tab + (i * 0x04));
+}
+
+static inline void jpeg_set_qtbl_lum(void __iomem *regs, int quality)
+{
+        /* this driver fills quantisation table 0 with data for luma */
+        jpeg_set_qtbl(regs, qtbl_luminance[quality], S5P_JPG_QTBL_CONTENT(0),
+                      ARRAY_SIZE(qtbl_luminance[quality]));
+}
+
+static inline void jpeg_set_qtbl_chr(void __iomem *regs, int quality)
+{
+        /* this driver fills quantisation table 1 with data for chroma */
+        jpeg_set_qtbl(regs, qtbl_chrominance[quality], S5P_JPG_QTBL_CONTENT(1),
+                      ARRAY_SIZE(qtbl_chrominance[quality]));
+}
+
+static inline void jpeg_set_htbl(void __iomem *regs, const unsigned char *htbl,
+                   unsigned long tab, int len)
+{
+        int i;
+
+        for (i = 0; i < len; i++)
+                writel((unsigned int)htbl[i], regs + tab + (i * 0x04));
+}
+
+static inline void jpeg_set_hdctbl(void __iomem *regs)
+{
+        /* this driver fills table 0 for this component */
+        jpeg_set_htbl(regs, hdctbl0, S5P_JPG_HDCTBL(0), ARRAY_SIZE(hdctbl0));
+}
+
+static inline void jpeg_set_hdctblg(void __iomem *regs)
+{
+        /* this driver fills table 0 for this component */
+        jpeg_set_htbl(regs, hdctblg0, S5P_JPG_HDCTBLG(0), ARRAY_SIZE(hdctblg0));
+}
+
+static inline void jpeg_set_hactbl(void __iomem *regs)
+{
+        /* this driver fills table 0 for this component */
+        jpeg_set_htbl(regs, hactbl0, S5P_JPG_HACTBL(0), ARRAY_SIZE(hactbl0));
+}
+
+static inline void jpeg_set_hactblg(void __iomem *regs)
+{
+        /* this driver fills table 0 for this component */
+        jpeg_set_htbl(regs, hactblg0, S5P_JPG_HACTBLG(0), ARRAY_SIZE(hactblg0));
+}
+
+/*
+ * ============================================================================
+ * Device file operations
+ * ============================================================================
+ */
+
+static int queue_init(void *priv, struct vb2_queue *src_vq,
+                      struct vb2_queue *dst_vq);
+static struct s5p_jpeg_fmt *s5p_jpeg_find_format(unsigned int mode,
+                                                 __u32 pixelformat);
+
+static int s5p_jpeg_open(struct file *file)
+{
+        struct s5p_jpeg *jpeg = video_drvdata(file);
+        struct video_device *vfd = video_devdata(file);
+        struct s5p_jpeg_ctx *ctx;
+        struct s5p_jpeg_fmt *out_fmt;
+
+        ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
+        if (!ctx)
+                return -ENOMEM;
+
+        file->private_data = ctx;
+        ctx->jpeg = jpeg;
+        if (vfd == jpeg->vfd_encoder) {
+                ctx->mode = S5P_JPEG_ENCODE;
+                out_fmt = s5p_jpeg_find_format(ctx->mode, V4L2_PIX_FMT_RGB565);
+        } else {
+                ctx->mode = S5P_JPEG_DECODE;
+                out_fmt = s5p_jpeg_find_format(ctx->mode, V4L2_PIX_FMT_JPEG);
+        }
+
+        ctx->m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, queue_init);
+        if (IS_ERR(ctx->m2m_ctx)) {
+                int err = PTR_ERR(ctx->m2m_ctx);
+                kfree(ctx);
+                return err;
+        }
+
+        ctx->out_q.fmt = out_fmt;
+        ctx->cap_q.fmt = s5p_jpeg_find_format(ctx->mode, V4L2_PIX_FMT_YUYV);
+
+        return 0;
+}
+
+static int s5p_jpeg_release(struct file *file)
+{
+        struct s5p_jpeg_ctx *ctx = file->private_data;
+
+        v4l2_m2m_ctx_release(ctx->m2m_ctx);
+        kfree(ctx);
+
+        return 0;
+}
+
+static unsigned int s5p_jpeg_poll(struct file *file,
+                                 struct poll_table_struct *wait)
+{
+        struct s5p_jpeg_ctx *ctx = file->private_data;
+
+        return v4l2_m2m_poll(file, ctx->m2m_ctx, wait);
+}
+
+static int s5p_jpeg_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        struct s5p_jpeg_ctx *ctx = file->private_data;
+
+        return v4l2_m2m_mmap(file, ctx->m2m_ctx, vma);
+}
+
+static const struct v4l2_file_operations s5p_jpeg_fops = {
+        .owner          = THIS_MODULE,
+        .open           = s5p_jpeg_open,
+        .release        = s5p_jpeg_release,
+        .poll           = s5p_jpeg_poll,
+        .unlocked_ioctl = video_ioctl2,
+        .mmap           = s5p_jpeg_mmap,
+};
+
+/*
+ * ============================================================================
+ * video ioctl operations
+ * ============================================================================
+ */
+
+static int get_byte(struct s5p_jpeg_buffer *buf)
+{
+        if (buf->curr >= buf->size)
+                return -1;
+
+        return ((unsigned char *)buf->data)[buf->curr++];
+}
+
+static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word)
+{
+        unsigned int temp;
+        int byte;
+
+        byte = get_byte(buf);
+        if (byte == -1)
+                return -1;
+        temp = byte << 8;
+        byte = get_byte(buf);
+        if (byte == -1)
+                return -1;
+        *word = (unsigned int)byte | temp;
+        return 0;
+}
+
+static void skip(struct s5p_jpeg_buffer *buf, long len)
+{
+        if (len <= 0)
+                return;
+
+        while (len--)
+                get_byte(buf);
+}
+
+static bool s5p_jpeg_parse_hdr(struct s5p_jpeg_q_data *result,
+                               unsigned long buffer, unsigned long size)
+{
+        int c, components, notfound;
+        unsigned int height, width, word;
+        long length;
+        struct s5p_jpeg_buffer jpeg_buffer;
+
+        jpeg_buffer.size = size;
+        jpeg_buffer.data = buffer;
+        jpeg_buffer.curr = 0;
+
+        notfound = 1;
+        while (notfound) {
+                c = get_byte(&jpeg_buffer);
+                if (c == -1)
+                        break;
+                if (c != 0xff)
+                        continue;
+                do
+                        c = get_byte(&jpeg_buffer);
+                while (c == 0xff);
+                if (c == -1)
+                        break;
+                if (c == 0)
+                        continue;
+                length = 0;
+                switch (c) {
+                /* SOF0: baseline JPEG */
+                case SOF0:
+                        if (get_word_be(&jpeg_buffer, &word))
+                                break;
+                        if (get_byte(&jpeg_buffer) == -1)
+                                break;
+                        if (get_word_be(&jpeg_buffer, &height))
+                                break;
+                        if (get_word_be(&jpeg_buffer, &width))
+                                break;
+                        components = get_byte(&jpeg_buffer);
+                        if (components == -1)
+                                break;
+                        notfound = 0;
+
+                        skip(&jpeg_buffer, components * 3);
+                        break;
+
+                /* skip payload-less markers */
+                case RST ... RST + 7:
+                case SOI:
+                case EOI:
+                case TEM:
+                        break;
+
+                /* skip uninteresting payload markers */
+                default:
+                        if (get_word_be(&jpeg_buffer, &word))
+                                break;
+                        length = (long)word - 2;
+                        skip(&jpeg_buffer, length);
+                        break;
+                }
+        }
+        result->w = width;
+        result->h = height;
+        result->size = components;
+        return !notfound;
+}
+
+static int s5p_jpeg_querycap(struct file *file, void *priv,
+                           struct v4l2_capability *cap)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        if (ctx->mode == S5P_JPEG_ENCODE) {
+                strlcpy(cap->driver, S5P_JPEG_M2M_NAME " encoder",
+                        sizeof(cap->driver));
+                strlcpy(cap->card, S5P_JPEG_M2M_NAME " encoder",
+                        sizeof(cap->card));
+        } else {
+                strlcpy(cap->driver, S5P_JPEG_M2M_NAME " decoder",
+                        sizeof(cap->driver));
+                strlcpy(cap->card, S5P_JPEG_M2M_NAME " decoder",
+                        sizeof(cap->card));
+        }
+        cap->bus_info[0] = 0;
+        cap->capabilities = V4L2_CAP_STREAMING |
+                            V4L2_CAP_VIDEO_CAPTURE |
+                            V4L2_CAP_VIDEO_OUTPUT;
+        return 0;
+}
+
+static int enum_fmt(struct s5p_jpeg_fmt *formats, int n,
+                    struct v4l2_fmtdesc *f, u32 type)
+{
+        int i, num = 0;
+
+        for (i = 0; i < n; ++i) {
+                if (formats[i].types & type) {
+                        /* index-th format of type type found ? */
+                        if (num == f->index)
+                                break;
+                        /* Correct type but haven't reached our index yet,
+                         * just increment per-type index */
+                        ++num;
+                }
+        }
+
+        /* Format not found */
+        if (i >= n)
+                return -EINVAL;
+
+        strlcpy(f->description, formats[i].name, sizeof(f->description));
+        f->pixelformat = formats[i].fourcc;
+
+        return 0;
+}
+
+static int s5p_jpeg_enum_fmt_vid_cap(struct file *file, void *priv,
+                                   struct v4l2_fmtdesc *f)
+{
+        struct s5p_jpeg_ctx *ctx;
+
+        ctx = priv;
+
+        if (ctx->mode == S5P_JPEG_ENCODE)
+                return enum_fmt(formats_enc, NUM_FORMATS_ENC, f,
+                                MEM2MEM_CAPTURE);
+
+        return enum_fmt(formats_dec, NUM_FORMATS_DEC, f, MEM2MEM_CAPTURE);
+}
+
+static int s5p_jpeg_enum_fmt_vid_out(struct file *file, void *priv,
+                                   struct v4l2_fmtdesc *f)
+{
+        struct s5p_jpeg_ctx *ctx;
+
+        ctx = priv;
+
+        if (ctx->mode == S5P_JPEG_ENCODE)
+                return enum_fmt(formats_enc, NUM_FORMATS_ENC, f,
+                                MEM2MEM_OUTPUT);
+
+        return enum_fmt(formats_dec, NUM_FORMATS_DEC, f, MEM2MEM_OUTPUT);
+}
+
+static struct s5p_jpeg_q_data *get_q_data(struct s5p_jpeg_ctx *ctx,
+                                          enum v4l2_buf_type type)
+{
+        if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
+                return &ctx->out_q;
+        if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return &ctx->cap_q;
+
+        return NULL;
+}
+
+static int s5p_jpeg_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
+{
+        struct vb2_queue *vq;
+        struct s5p_jpeg_q_data *q_data = NULL;
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+        struct s5p_jpeg_ctx *ct = priv;
+
+        vq = v4l2_m2m_get_vq(ct->m2m_ctx, f->type);
+        if (!vq)
+                return -EINVAL;
+
+        if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
+            ct->mode == S5P_JPEG_DECODE && !ct->hdr_parsed)
+                return -EINVAL;
+        q_data = get_q_data(ct, f->type);
+        BUG_ON(q_data == NULL);
+
+        pix->width = q_data->w;
+        pix->height = q_data->h;
+        pix->field = V4L2_FIELD_NONE;
+        pix->pixelformat = q_data->fmt->fourcc;
+        pix->bytesperline = 0;
+        if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {
+                u32 bpl = q_data->w;
+                if (q_data->fmt->colplanes == 1)
+                        bpl = (bpl * q_data->fmt->depth) >> 3;
+                pix->bytesperline = bpl;
+        }
+        pix->sizeimage = q_data->size;
+
+        return 0;
+}
+
+static struct s5p_jpeg_fmt *s5p_jpeg_find_format(unsigned int mode,
+                                                 u32 pixelformat)
+{
+        unsigned int k;
+        struct s5p_jpeg_fmt *formats;
+        int n;
+
+        if (mode == S5P_JPEG_ENCODE) {
+                formats = formats_enc;
+                n = NUM_FORMATS_ENC;
+        } else {
+                formats = formats_dec;
+                n = NUM_FORMATS_DEC;
+        }
+
+        for (k = 0; k < n; k++) {
+                struct s5p_jpeg_fmt *fmt = &formats[k];
+                if (fmt->fourcc == pixelformat)
+                        return fmt;
+        }
+
+        return NULL;
+
+}
+
+static void jpeg_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
+                                   unsigned int walign,
+                                   u32 *h, unsigned int hmin, unsigned int hmax,
+                                   unsigned int halign)
+{
+        int width, height, w_step, h_step;
+
+        width = *w;
+        height = *h;
+
+        w_step = 1 << walign;
+        h_step = 1 << halign;
+        v4l_bound_align_image(w, wmin, wmax, walign, h, hmin, hmax, halign, 0);
+
+        if (*w < width && (*w + w_step) < wmax)
+                *w += w_step;
+        if (*h < height && (*h + h_step) < hmax)
+                *h += h_step;
+
+}
+
+static int vidioc_try_fmt(struct v4l2_format *f, struct s5p_jpeg_fmt *fmt,
+                          struct s5p_jpeg_ctx *ctx, int q_type)
+{
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+
+        if (pix->field == V4L2_FIELD_ANY)
+                pix->field = V4L2_FIELD_NONE;
+        else if (pix->field != V4L2_FIELD_NONE)
+                return -EINVAL;
+
+        /* V4L2 specification suggests the driver corrects the format struct
+         * if any of the dimensions is unsupported */
+        if (q_type == MEM2MEM_OUTPUT)
+                jpeg_bound_align_image(&pix->width, S5P_JPEG_MIN_WIDTH,
+                                       S5P_JPEG_MAX_WIDTH, 0,
+                                       &pix->height, S5P_JPEG_MIN_HEIGHT,
+                                       S5P_JPEG_MAX_HEIGHT, 0);
+        else
+                jpeg_bound_align_image(&pix->width, S5P_JPEG_MIN_WIDTH,
+                                       S5P_JPEG_MAX_WIDTH, fmt->h_align,
+                                       &pix->height, S5P_JPEG_MIN_HEIGHT,
+                                       S5P_JPEG_MAX_HEIGHT, fmt->v_align);
+
+        if (fmt->fourcc == V4L2_PIX_FMT_JPEG) {
+                if (pix->sizeimage <= 0)
+                        pix->sizeimage = PAGE_SIZE;
+                pix->bytesperline = 0;
+        } else {
+                u32 bpl = pix->bytesperline;
+
+                if (fmt->colplanes > 1 && bpl < pix->width)
+                        bpl = pix->width; /* planar */
+
+                if (fmt->colplanes == 1 && /* packed */
+                    (bpl << 3) * fmt->depth < pix->width)
+                        bpl = (pix->width * fmt->depth) >> 3;
+
+                pix->bytesperline = bpl;
+                pix->sizeimage = (pix->width * pix->height * fmt->depth) >> 3;
+        }
+
+        return 0;
+}
+
+static int s5p_jpeg_try_fmt_vid_cap(struct file *file, void *priv,
+                                  struct v4l2_format *f)
+{
+        struct s5p_jpeg_fmt *fmt;
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        fmt = s5p_jpeg_find_format(ctx->mode, f->fmt.pix.pixelformat);
+        if (!fmt || !(fmt->types & MEM2MEM_CAPTURE)) {
+                v4l2_err(&ctx->jpeg->v4l2_dev,
+                         "Fourcc format (0x%08x) invalid.\n",
+                         f->fmt.pix.pixelformat);
+                return -EINVAL;
+        }
+
+        return vidioc_try_fmt(f, fmt, ctx, MEM2MEM_CAPTURE);
+}
+
+static int s5p_jpeg_try_fmt_vid_out(struct file *file, void *priv,
+                                  struct v4l2_format *f)
+{
+        struct s5p_jpeg_fmt *fmt;
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        fmt = s5p_jpeg_find_format(ctx->mode, f->fmt.pix.pixelformat);
+        if (!fmt || !(fmt->types & MEM2MEM_OUTPUT)) {
+                v4l2_err(&ctx->jpeg->v4l2_dev,
+                         "Fourcc format (0x%08x) invalid.\n",
+                         f->fmt.pix.pixelformat);
+                return -EINVAL;
+        }
+
+        return vidioc_try_fmt(f, fmt, ctx, MEM2MEM_OUTPUT);
+}
+
+static int s5p_jpeg_s_fmt(struct s5p_jpeg_ctx *ct, struct v4l2_format *f)
+{
+        struct vb2_queue *vq;
+        struct s5p_jpeg_q_data *q_data = NULL;
+        struct v4l2_pix_format *pix = &f->fmt.pix;
+
+        vq = v4l2_m2m_get_vq(ct->m2m_ctx, f->type);
+        if (!vq)
+                return -EINVAL;
+
+        q_data = get_q_data(ct, f->type);
+        BUG_ON(q_data == NULL);
+
+        if (vb2_is_busy(vq)) {
+                v4l2_err(&ct->jpeg->v4l2_dev, "%s queue busy\n", __func__);
+                return -EBUSY;
+        }
+
+        q_data->fmt = s5p_jpeg_find_format(ct->mode, pix->pixelformat);
+        q_data->w = pix->width;
+        q_data->h = pix->height;
+        if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG)
+                q_data->size = q_data->w * q_data->h * q_data->fmt->depth >> 3;
+        else
+                q_data->size = pix->sizeimage;
+
+        return 0;
+}
+
+static int s5p_jpeg_s_fmt_vid_cap(struct file *file, void *priv,
+                                struct v4l2_format *f)
+{
+        int ret;
+
+        ret = s5p_jpeg_try_fmt_vid_cap(file, priv, f);
+        if (ret)
+                return ret;
+
+        return s5p_jpeg_s_fmt(priv, f);
+}
+
+static int s5p_jpeg_s_fmt_vid_out(struct file *file, void *priv,
+                                struct v4l2_format *f)
+{
+        int ret;
+
+        ret = s5p_jpeg_try_fmt_vid_out(file, priv, f);
+        if (ret)
+                return ret;
+
+        return s5p_jpeg_s_fmt(priv, f);
+}
+
+static int s5p_jpeg_reqbufs(struct file *file, void *priv,
+                          struct v4l2_requestbuffers *reqbufs)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
+}
+
+static int s5p_jpeg_querybuf(struct file *file, void *priv,
+                           struct v4l2_buffer *buf)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        return v4l2_m2m_querybuf(file, ctx->m2m_ctx, buf);
+}
+
+static int s5p_jpeg_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
+}
+
+static int s5p_jpeg_dqbuf(struct file *file, void *priv,
+                          struct v4l2_buffer *buf)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
+}
+
+static int s5p_jpeg_streamon(struct file *file, void *priv,
+                           enum v4l2_buf_type type)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
+}
+
+static int s5p_jpeg_streamoff(struct file *file, void *priv,
+                            enum v4l2_buf_type type)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        return v4l2_m2m_streamoff(file, ctx->m2m_ctx, type);
+}
+
+int s5p_jpeg_g_selection(struct file *file, void *priv,
+                         struct v4l2_selection *s)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
+            s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                return -EINVAL;
+
+        /* For JPEG blob active == default == bounds */
+        switch (s->target) {
+        case V4L2_SEL_TGT_CROP_ACTIVE:
+        case V4L2_SEL_TGT_CROP_BOUNDS:
+        case V4L2_SEL_TGT_CROP_DEFAULT:
+        case V4L2_SEL_TGT_COMPOSE_ACTIVE:
+        case V4L2_SEL_TGT_COMPOSE_DEFAULT:
+                s->r.width = ctx->out_q.w;
+                s->r.height = ctx->out_q.h;
+                break;
+        case V4L2_SEL_TGT_COMPOSE_BOUNDS:
+        case V4L2_SEL_TGT_COMPOSE_PADDED:
+                s->r.width = ctx->cap_q.w;
+                s->r.height = ctx->cap_q.h;
+                break;
+        default:
+                return -EINVAL;
+        }
+        s->r.left = 0;
+        s->r.top = 0;
+        return 0;
+}
+
+static int s5p_jpeg_g_jpegcomp(struct file *file, void *priv,
+                               struct v4l2_jpegcompression *compr)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        if (ctx->mode == S5P_JPEG_DECODE)
+                return -ENOTTY;
+
+        memset(compr, 0, sizeof(*compr));
+        compr->quality = ctx->compr_quality;
+
+        return 0;
+}
+
+static int s5p_jpeg_s_jpegcomp(struct file *file, void *priv,
+                               struct v4l2_jpegcompression *compr)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        if (ctx->mode == S5P_JPEG_DECODE)
+                return -ENOTTY;
+
+        compr->quality = clamp(compr->quality, S5P_JPEG_COMPR_QUAL_BEST,
+                               S5P_JPEG_COMPR_QUAL_WORST);
+
+        ctx->compr_quality = S5P_JPEG_COMPR_QUAL_WORST - compr->quality;
+
+        return 0;
+}
+
+static const struct v4l2_ioctl_ops s5p_jpeg_ioctl_ops = {
+        .vidioc_querycap                = s5p_jpeg_querycap,
+
+        .vidioc_enum_fmt_vid_cap        = s5p_jpeg_enum_fmt_vid_cap,
+        .vidioc_enum_fmt_vid_out        = s5p_jpeg_enum_fmt_vid_out,
+
+        .vidioc_g_fmt_vid_cap           = s5p_jpeg_g_fmt,
+        .vidioc_g_fmt_vid_out           = s5p_jpeg_g_fmt,
+
+        .vidioc_try_fmt_vid_cap         = s5p_jpeg_try_fmt_vid_cap,
+        .vidioc_try_fmt_vid_out         = s5p_jpeg_try_fmt_vid_out,
+
+        .vidioc_s_fmt_vid_cap           = s5p_jpeg_s_fmt_vid_cap,
+        .vidioc_s_fmt_vid_out           = s5p_jpeg_s_fmt_vid_out,
+
+        .vidioc_reqbufs                 = s5p_jpeg_reqbufs,
+        .vidioc_querybuf                = s5p_jpeg_querybuf,
+
+        .vidioc_qbuf                    = s5p_jpeg_qbuf,
+        .vidioc_dqbuf                   = s5p_jpeg_dqbuf,
+
+        .vidioc_streamon                = s5p_jpeg_streamon,
+        .vidioc_streamoff               = s5p_jpeg_streamoff,
+
+        .vidioc_g_selection             = s5p_jpeg_g_selection,
+
+        .vidioc_g_jpegcomp              = s5p_jpeg_g_jpegcomp,
+        .vidioc_s_jpegcomp              = s5p_jpeg_s_jpegcomp,
+};
+
+/*
+ * ============================================================================
+ * mem2mem callbacks
+ * ============================================================================
+ */
+
+static void s5p_jpeg_device_run(void *priv)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+        struct s5p_jpeg *jpeg = ctx->jpeg;
+        struct vb2_buffer *src_buf, *dst_buf;
+        unsigned long src_addr, dst_addr;
+
+        src_buf = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
+        dst_buf = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
+        src_addr = vb2_dma_contig_plane_dma_addr(src_buf, 0);
+        dst_addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0);
+
+        jpeg_reset(jpeg->regs);
+        jpeg_poweron(jpeg->regs);
+        jpeg_proc_mode(jpeg->regs, ctx->mode);
+        if (ctx->mode == S5P_JPEG_ENCODE) {
+                if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565)
+                        jpeg_input_raw_mode(jpeg->regs, S5P_JPEG_RAW_IN_565);
+                else
+                        jpeg_input_raw_mode(jpeg->regs, S5P_JPEG_RAW_IN_422);
+                if (ctx->cap_q.fmt->fourcc == V4L2_PIX_FMT_YUYV)
+                        jpeg_subsampling_mode(jpeg->regs,
+                                              S5P_JPEG_SUBSAMPLING_422);
+                else
+                        jpeg_subsampling_mode(jpeg->regs,
+                                              S5P_JPEG_SUBSAMPLING_420);
+                jpeg_dri(jpeg->regs, 0);
+                jpeg_x(jpeg->regs, ctx->out_q.w);
+                jpeg_y(jpeg->regs, ctx->out_q.h);
+                jpeg_imgadr(jpeg->regs, src_addr);
+                jpeg_jpgadr(jpeg->regs, dst_addr);
+
+                /* ultimately comes from sizeimage from userspace */
+                jpeg_enc_stream_int(jpeg->regs, ctx->cap_q.size);
+
+                /* JPEG RGB to YCbCr conversion matrix */
+                jpeg_coef(jpeg->regs, 1, 1, S5P_JPEG_COEF11);
+                jpeg_coef(jpeg->regs, 1, 2, S5P_JPEG_COEF12);
+                jpeg_coef(jpeg->regs, 1, 3, S5P_JPEG_COEF13);
+                jpeg_coef(jpeg->regs, 2, 1, S5P_JPEG_COEF21);
+                jpeg_coef(jpeg->regs, 2, 2, S5P_JPEG_COEF22);
+                jpeg_coef(jpeg->regs, 2, 3, S5P_JPEG_COEF23);
+                jpeg_coef(jpeg->regs, 3, 1, S5P_JPEG_COEF31);
+                jpeg_coef(jpeg->regs, 3, 2, S5P_JPEG_COEF32);
+                jpeg_coef(jpeg->regs, 3, 3, S5P_JPEG_COEF33);
+
+                /*
+                 * JPEG IP allows storing 4 quantization tables
+                 * We fill table 0 for luma and table 1 for chroma
+                 */
+                jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
+                jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
+                /* use table 0 for Y */
+                jpeg_qtbl(jpeg->regs, 1, 0);
+                /* use table 1 for Cb and Cr*/
+                jpeg_qtbl(jpeg->regs, 2, 1);
+                jpeg_qtbl(jpeg->regs, 3, 1);
+
+                /* Y, Cb, Cr use Huffman table 0 */
+                jpeg_htbl_ac(jpeg->regs, 1);
+                jpeg_htbl_dc(jpeg->regs, 1);
+                jpeg_htbl_ac(jpeg->regs, 2);
+                jpeg_htbl_dc(jpeg->regs, 2);
+                jpeg_htbl_ac(jpeg->regs, 3);
+                jpeg_htbl_dc(jpeg->regs, 3);
+        } else {
+                jpeg_rst_int_enable(jpeg->regs, true);
+                jpeg_data_num_int_enable(jpeg->regs, true);
+                jpeg_final_mcu_num_int_enable(jpeg->regs, true);
+                jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_422);
+                jpeg_jpgadr(jpeg->regs, src_addr);
+                jpeg_imgadr(jpeg->regs, dst_addr);
+        }
+        jpeg_start(jpeg->regs);
+}
+
+static int s5p_jpeg_job_ready(void *priv)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+
+        if (ctx->mode == S5P_JPEG_DECODE)
+                return ctx->hdr_parsed;
+        return 1;
+}
+
+static void s5p_jpeg_job_abort(void *priv)
+{
+}
+
+static struct v4l2_m2m_ops s5p_jpeg_m2m_ops = {
+        .device_run     = s5p_jpeg_device_run,
+        .job_ready      = s5p_jpeg_job_ready,
+        .job_abort      = s5p_jpeg_job_abort,
+};
+
+/*
+ * ============================================================================
+ * Queue operations
+ * ============================================================================
+ */
+
+static int s5p_jpeg_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers,
+                                unsigned int *nplanes, unsigned int sizes[],
+                                void *alloc_ctxs[])
+{
+        struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq);
+        struct s5p_jpeg_q_data *q_data = NULL;
+        unsigned int size, count = *nbuffers;
+
+        q_data = get_q_data(ctx, vq->type);
+        BUG_ON(q_data == NULL);
+
+        size = q_data->size;
+
+        /*
+         * header is parsed during decoding and parsed information stored
+         * in the context so we do not allow another buffer to overwrite it
+         */
+        if (ctx->mode == S5P_JPEG_DECODE)
+                count = 1;
+
+        *nbuffers = count;
+        *nplanes = 1;
+        sizes[0] = size;
+        alloc_ctxs[0] = ctx->jpeg->alloc_ctx;
+
+        return 0;
+}
+
+static int s5p_jpeg_buf_prepare(struct vb2_buffer *vb)
+{
+        struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
+        struct s5p_jpeg_q_data *q_data = NULL;
+
+        q_data = get_q_data(ctx, vb->vb2_queue->type);
+        BUG_ON(q_data == NULL);
+
+        if (vb2_plane_size(vb, 0) < q_data->size) {
+                pr_err("%s data will not fit into plane (%lu < %lu)\n",
+                                __func__, vb2_plane_size(vb, 0),
+                                (long)q_data->size);
+                return -EINVAL;
+        }
+
+        vb2_set_plane_payload(vb, 0, q_data->size);
+
+        return 0;
+}
+
+static void s5p_jpeg_buf_queue(struct vb2_buffer *vb)
+{
+        struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
+
+        if (ctx->mode == S5P_JPEG_DECODE &&
+            vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
+                struct s5p_jpeg_q_data tmp, *q_data;
+                ctx->hdr_parsed = s5p_jpeg_parse_hdr(&tmp,
+                     (unsigned long)vb2_plane_vaddr(vb, 0),
+                     min((unsigned long)ctx->out_q.size,
+                         vb2_get_plane_payload(vb, 0)));
+                if (!ctx->hdr_parsed) {
+                        vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
+                        return;
+                }
+
+                q_data = &ctx->out_q;
+                q_data->w = tmp.w;
+                q_data->h = tmp.h;
+
+                q_data = &ctx->cap_q;
+                q_data->w = tmp.w;
+                q_data->h = tmp.h;
+
+                jpeg_bound_align_image(&q_data->w, S5P_JPEG_MIN_WIDTH,
+                                       S5P_JPEG_MAX_WIDTH, q_data->fmt->h_align,
+                                       &q_data->h, S5P_JPEG_MIN_HEIGHT,
+                                       S5P_JPEG_MAX_HEIGHT, q_data->fmt->v_align
+                                      );
+                q_data->size = q_data->w * q_data->h * q_data->fmt->depth >> 3;
+        }
+        if (ctx->m2m_ctx)
+                v4l2_m2m_buf_queue(ctx->m2m_ctx, vb);
+}
+
+static void s5p_jpeg_wait_prepare(struct vb2_queue *vq)
+{
+        struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq);
+
+        mutex_unlock(&ctx->jpeg->lock);
+}
+
+static void s5p_jpeg_wait_finish(struct vb2_queue *vq)
+{
+        struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq);
+
+        mutex_lock(&ctx->jpeg->lock);
+}
+
+static int s5p_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
+{
+        struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
+        int ret;
+
+        ret = pm_runtime_get_sync(ctx->jpeg->dev);
+
+        return ret > 0 ? 0 : ret;
+}
+
+static int s5p_jpeg_stop_streaming(struct vb2_queue *q)
+{
+        struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
+
+        pm_runtime_put(ctx->jpeg->dev);
+
+        return 0;
+}
+
+static struct vb2_ops s5p_jpeg_qops = {
+        .queue_setup            = s5p_jpeg_queue_setup,
+        .buf_prepare            = s5p_jpeg_buf_prepare,
+        .buf_queue              = s5p_jpeg_buf_queue,
+        .wait_prepare           = s5p_jpeg_wait_prepare,
+        .wait_finish            = s5p_jpeg_wait_finish,
+        .start_streaming        = s5p_jpeg_start_streaming,
+        .stop_streaming         = s5p_jpeg_stop_streaming,
+};
+
+static int queue_init(void *priv, struct vb2_queue *src_vq,
+                      struct vb2_queue *dst_vq)
+{
+        struct s5p_jpeg_ctx *ctx = priv;
+        int ret;
+
+        memset(src_vq, 0, sizeof(*src_vq));
+        src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+        src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+        src_vq->drv_priv = ctx;
+        src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
+        src_vq->ops = &s5p_jpeg_qops;
+        src_vq->mem_ops = &vb2_dma_contig_memops;
+
+        ret = vb2_queue_init(src_vq);
+        if (ret)
+                return ret;
+
+        memset(dst_vq, 0, sizeof(*dst_vq));
+        dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
+        dst_vq->drv_priv = ctx;
+        dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
+        dst_vq->ops = &s5p_jpeg_qops;
+        dst_vq->mem_ops = &vb2_dma_contig_memops;
+
+        return vb2_queue_init(dst_vq);
+}
+
+/*
+ * ============================================================================
+ * ISR
+ * ============================================================================
+ */
+
+static irqreturn_t s5p_jpeg_irq(int irq, void *dev_id)
+{
+        struct s5p_jpeg *jpeg = dev_id;
+        struct s5p_jpeg_ctx *curr_ctx;
+        struct vb2_buffer *src_buf, *dst_buf;
+        unsigned long payload_size = 0;
+        enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
+        bool enc_jpeg_too_large = false;
+        bool timer_elapsed = false;
+        bool op_completed = false;
+
+        curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
+
+        src_buf = v4l2_m2m_src_buf_remove(curr_ctx->m2m_ctx);
+        dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->m2m_ctx);
+
+        if (curr_ctx->mode == S5P_JPEG_ENCODE)
+                enc_jpeg_too_large = jpeg_enc_stream_stat(jpeg->regs);
+        timer_elapsed = jpeg_timer_stat(jpeg->regs);
+        op_completed = jpeg_result_stat_ok(jpeg->regs);
+        if (curr_ctx->mode == S5P_JPEG_DECODE)
+                op_completed = op_completed && jpeg_stream_stat_ok(jpeg->regs);
+
+        if (enc_jpeg_too_large) {
+                state = VB2_BUF_STATE_ERROR;
+                jpeg_clear_enc_stream_stat(jpeg->regs);
+        } else if (timer_elapsed) {
+                state = VB2_BUF_STATE_ERROR;
+                jpeg_clear_timer_stat(jpeg->regs);
+        } else if (!op_completed) {
+                state = VB2_BUF_STATE_ERROR;
+        } else {
+                payload_size = jpeg_compressed_size(jpeg->regs);
+        }
+
+        v4l2_m2m_buf_done(src_buf, state);
+        if (curr_ctx->mode == S5P_JPEG_ENCODE)
+                vb2_set_plane_payload(dst_buf, 0, payload_size);
+        v4l2_m2m_buf_done(dst_buf, state);
+        v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->m2m_ctx);
+
+        jpeg_clear_int(jpeg->regs);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * ============================================================================
+ * Driver basic infrastructure
+ * ============================================================================
+ */
+
+static int s5p_jpeg_probe(struct platform_device *pdev)
+{
+        struct s5p_jpeg *jpeg;
+        struct resource *res;
+        int ret;
+
+        /* JPEG IP abstraction struct */
+        jpeg = kzalloc(sizeof(struct s5p_jpeg), GFP_KERNEL);
+        if (!jpeg)
+                return -ENOMEM;
+
+        mutex_init(&jpeg->lock);
+        jpeg->dev = &pdev->dev;
+
+        /* memory-mapped registers */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "cannot find IO resource\n");
+                ret = -ENOENT;
+                goto jpeg_alloc_rollback;
+        }
+
+        jpeg->ioarea = request_mem_region(res->start, resource_size(res),
+                                          pdev->name);
+        if (!jpeg->ioarea) {
+                dev_err(&pdev->dev, "cannot request IO\n");
+                ret = -ENXIO;
+                goto jpeg_alloc_rollback;
+        }
+
+        jpeg->regs = ioremap(res->start, resource_size(res));
+        if (!jpeg->regs) {
+                dev_err(&pdev->dev, "cannot map IO\n");
+                ret = -ENXIO;
+                goto mem_region_rollback;
+        }
+
+        dev_dbg(&pdev->dev, "registers %p (%p, %p)\n",
+                jpeg->regs, jpeg->ioarea, res);
+
+        /* interrupt service routine registration */
+        jpeg->irq = ret = platform_get_irq(pdev, 0);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "cannot find IRQ\n");
+                goto ioremap_rollback;
+        }
+
+        ret = request_irq(jpeg->irq, s5p_jpeg_irq, 0,
+                          dev_name(&pdev->dev), jpeg);
+
+        if (ret) {
+                dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpeg->irq);
+                goto ioremap_rollback;
+        }
+
+        /* clocks */
+        jpeg->clk = clk_get(&pdev->dev, "jpeg");
+        if (IS_ERR(jpeg->clk)) {
+                dev_err(&pdev->dev, "cannot get clock\n");
+                ret = PTR_ERR(jpeg->clk);
+                goto request_irq_rollback;
+        }
+        dev_dbg(&pdev->dev, "clock source %p\n", jpeg->clk);
+        clk_enable(jpeg->clk);
+
+        /* v4l2 device */
+        ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to register v4l2 device\n");
+                goto clk_get_rollback;
+        }
+
+        /* mem2mem device */
+        jpeg->m2m_dev = v4l2_m2m_init(&s5p_jpeg_m2m_ops);
+        if (IS_ERR(jpeg->m2m_dev)) {
+                v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n");
+                ret = PTR_ERR(jpeg->m2m_dev);
+                goto device_register_rollback;
+        }
+
+        jpeg->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
+        if (IS_ERR(jpeg->alloc_ctx)) {
+                v4l2_err(&jpeg->v4l2_dev, "Failed to init memory allocator\n");
+                ret = PTR_ERR(jpeg->alloc_ctx);
+                goto m2m_init_rollback;
+        }
+
+        /* JPEG encoder /dev/videoX node */
+        jpeg->vfd_encoder = video_device_alloc();
+        if (!jpeg->vfd_encoder) {
+                v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
+                ret = -ENOMEM;
+                goto vb2_allocator_rollback;
+        }
+        strlcpy(jpeg->vfd_encoder->name, S5P_JPEG_M2M_NAME,
+                sizeof(jpeg->vfd_encoder->name));
+        jpeg->vfd_encoder->fops         = &s5p_jpeg_fops;
+        jpeg->vfd_encoder->ioctl_ops    = &s5p_jpeg_ioctl_ops;
+        jpeg->vfd_encoder->minor        = -1;
+        jpeg->vfd_encoder->release      = video_device_release;
+        jpeg->vfd_encoder->lock         = &jpeg->lock;
+        jpeg->vfd_encoder->v4l2_dev     = &jpeg->v4l2_dev;
+
+        ret = video_register_device(jpeg->vfd_encoder, VFL_TYPE_GRABBER, -1);
+        if (ret) {
+                v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
+                goto enc_vdev_alloc_rollback;
+        }
+
+        video_set_drvdata(jpeg->vfd_encoder, jpeg);
+        v4l2_info(&jpeg->v4l2_dev,
+                  "encoder device registered as /dev/video%d\n",
+                  jpeg->vfd_encoder->num);
+
+        /* JPEG decoder /dev/videoX node */
+        jpeg->vfd_decoder = video_device_alloc();
+        if (!jpeg->vfd_decoder) {
+                v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
+                ret = -ENOMEM;
+                goto enc_vdev_register_rollback;
+        }
+        strlcpy(jpeg->vfd_decoder->name, S5P_JPEG_M2M_NAME,
+                sizeof(jpeg->vfd_decoder->name));
+        jpeg->vfd_decoder->fops         = &s5p_jpeg_fops;
+        jpeg->vfd_decoder->ioctl_ops    = &s5p_jpeg_ioctl_ops;
+        jpeg->vfd_decoder->minor        = -1;
+        jpeg->vfd_decoder->release      = video_device_release;
+        jpeg->vfd_decoder->lock         = &jpeg->lock;
+        jpeg->vfd_decoder->v4l2_dev     = &jpeg->v4l2_dev;
+
+        ret = video_register_device(jpeg->vfd_decoder, VFL_TYPE_GRABBER, -1);
+        if (ret) {
+                v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
+                goto dec_vdev_alloc_rollback;
+        }
+
+        video_set_drvdata(jpeg->vfd_decoder, jpeg);
+        v4l2_info(&jpeg->v4l2_dev,
+                  "decoder device registered as /dev/video%d\n",
+                  jpeg->vfd_decoder->num);
+
+        /* final statements & power management */
+        platform_set_drvdata(pdev, jpeg);
+
+        pm_runtime_enable(&pdev->dev);
+
+        v4l2_info(&jpeg->v4l2_dev, "Samsung S5P JPEG codec\n");
+
+        return 0;
+
+dec_vdev_alloc_rollback:
+        video_device_release(jpeg->vfd_decoder);
+
+enc_vdev_register_rollback:
+        video_unregister_device(jpeg->vfd_encoder);
+
+enc_vdev_alloc_rollback:
+        video_device_release(jpeg->vfd_encoder);
+
+vb2_allocator_rollback:
+        vb2_dma_contig_cleanup_ctx(jpeg->alloc_ctx);
+
+m2m_init_rollback:
+        v4l2_m2m_release(jpeg->m2m_dev);
+
+device_register_rollback:
+        v4l2_device_unregister(&jpeg->v4l2_dev);
+
+clk_get_rollback:
+        clk_disable(jpeg->clk);
+        clk_put(jpeg->clk);
+
+request_irq_rollback:
+        free_irq(jpeg->irq, jpeg);
+
+ioremap_rollback:
+        iounmap(jpeg->regs);
+
+mem_region_rollback:
+        release_resource(jpeg->ioarea);
+        release_mem_region(jpeg->ioarea->start, resource_size(jpeg->ioarea));
+
+jpeg_alloc_rollback:
+        kfree(jpeg);
+        return ret;
+}
+
+static int s5p_jpeg_remove(struct platform_device *pdev)
+{
+        struct s5p_jpeg *jpeg = platform_get_drvdata(pdev);
+
+        pm_runtime_disable(jpeg->dev);
+
+        video_unregister_device(jpeg->vfd_decoder);
+        video_device_release(jpeg->vfd_decoder);
+        video_unregister_device(jpeg->vfd_encoder);
+        video_device_release(jpeg->vfd_encoder);
+        vb2_dma_contig_cleanup_ctx(jpeg->alloc_ctx);
+        v4l2_m2m_release(jpeg->m2m_dev);
+        v4l2_device_unregister(&jpeg->v4l2_dev);
+
+        clk_disable(jpeg->clk);
+        clk_put(jpeg->clk);
+
+        free_irq(jpeg->irq, jpeg);
+
+        iounmap(jpeg->regs);
+
+        release_resource(jpeg->ioarea);
+        release_mem_region(jpeg->ioarea->start, resource_size(jpeg->ioarea));
+        kfree(jpeg);
+
+        return 0;
+}
+
+static int s5p_jpeg_runtime_suspend(struct device *dev)
+{
+        return 0;
+}
+
+static int s5p_jpeg_runtime_resume(struct device *dev)
+{
+        struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
+        /*
+         * JPEG IP allows storing two Huffman tables for each component
+         * We fill table 0 for each component
+         */
+        jpeg_set_hdctbl(jpeg->regs);
+        jpeg_set_hdctblg(jpeg->regs);
+        jpeg_set_hactbl(jpeg->regs);
+        jpeg_set_hactblg(jpeg->regs);
+        return 0;
+}
+
+static const struct dev_pm_ops s5p_jpeg_pm_ops = {
+        .runtime_suspend = s5p_jpeg_runtime_suspend,
+        .runtime_resume  = s5p_jpeg_runtime_resume,
+};
+
+static struct platform_driver s5p_jpeg_driver = {
+        .probe = s5p_jpeg_probe,
+        .remove = s5p_jpeg_remove,
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = S5P_JPEG_M2M_NAME,
+                .pm = &s5p_jpeg_pm_ops,
+        },
+};
+
+static int __init
+s5p_jpeg_register(void)
+{
+        int ret;
+
+        pr_info("S5P JPEG V4L2 Driver, (c) 2011 Samsung Electronics\n");
+
+        ret = platform_driver_register(&s5p_jpeg_driver);
+
+        if (ret)
+                pr_err("%s: failed to register jpeg driver\n", __func__);
+
+        return ret;
+}
+
+static void __exit
+s5p_jpeg_unregister(void)
+{
+        platform_driver_unregister(&s5p_jpeg_driver);
+}
+
+module_init(s5p_jpeg_register);
+module_exit(s5p_jpeg_unregister);
+
+MODULE_AUTHOR("Andrzej Pietrasiewicz <andrzej.p@samsung.com>");
+MODULE_DESCRIPTION("Samsung JPEG codec driver");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/media/video/s5p-jpeg/jpeg-core.h b/drivers/media/video/s5p-jpeg/jpeg-core.h
new file mode 100644
index 000000000000..facad6114f5e
--- /dev/null
+++ b/drivers/media/video/s5p-jpeg/jpeg-core.h
@@ -0,0 +1,143 @@
+/* linux/drivers/media/video/s5p-jpeg/jpeg-core.h
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef JPEG_CORE_H_
+#define JPEG_CORE_H_
+
+#include <media/v4l2-device.h>
+
+#define S5P_JPEG_M2M_NAME               "s5p-jpeg"
+
+/* JPEG compression quality setting */
+#define S5P_JPEG_COMPR_QUAL_BEST        0
+#define S5P_JPEG_COMPR_QUAL_WORST       3
+
+/* JPEG RGB to YCbCr conversion matrix coefficients */
+#define S5P_JPEG_COEF11                 0x4d
+#define S5P_JPEG_COEF12                 0x97
+#define S5P_JPEG_COEF13                 0x1e
+#define S5P_JPEG_COEF21                 0x2c
+#define S5P_JPEG_COEF22                 0x57
+#define S5P_JPEG_COEF23                 0x83
+#define S5P_JPEG_COEF31                 0x83
+#define S5P_JPEG_COEF32                 0x6e
+#define S5P_JPEG_COEF33                 0x13
+
+/* a selection of JPEG markers */
+#define TEM                             0x01
+#define SOF0                            0xc0
+#define RST                             0xd0
+#define SOI                             0xd8
+#define EOI                             0xd9
+#define DHP                             0xde
+
+/* Flags that indicate a format can be used for capture/output */
+#define MEM2MEM_CAPTURE                 (1 << 0)
+#define MEM2MEM_OUTPUT                  (1 << 1)
+
+/**
+ * struct s5p_jpeg - JPEG IP abstraction
+ * @lock:               the mutex protecting this structure
+ * @v4l2_dev:           v4l2 device for mem2mem mode
+ * @vfd_encoder:        video device node for encoder mem2mem mode
+ * @vfd_decoder:        video device node for decoder mem2mem mode
+ * @m2m_dev:            v4l2 mem2mem device data
+ * @ioarea:             JPEG IP memory region
+ * @regs:               JPEG IP registers mapping
+ * @irq:                JPEG IP irq
+ * @clk:                JPEG IP clock
+ * @dev:                JPEG IP struct device
+ * @alloc_ctx:          videobuf2 memory allocator's context
+ */
+struct s5p_jpeg {
+        struct mutex            lock;
+
+        struct v4l2_device      v4l2_dev;
+        struct video_device     *vfd_encoder;
+        struct video_device     *vfd_decoder;
+        struct v4l2_m2m_dev     *m2m_dev;
+
+        struct resource         *ioarea;
+        void __iomem            *regs;
+        unsigned int            irq;
+        struct clk              *clk;
+        struct device           *dev;
+        void                    *alloc_ctx;
+};
+
+/**
+ * struct jpeg_fmt - driver's internal color format data
+ * @name:       format descritpion
+ * @fourcc:     the fourcc code, 0 if not applicable
+ * @depth:      number of bits per pixel
+ * @colplanes:  number of color planes (1 for packed formats)
+ * @h_align:    horizontal alignment order (align to 2^h_align)
+ * @v_align:    vertical alignment order (align to 2^v_align)
+ * @types:      types of queue this format is applicable to
+ */
+struct s5p_jpeg_fmt {
+        char    *name;
+        u32     fourcc;
+        int     depth;
+        int     colplanes;
+        int     h_align;
+        int     v_align;
+        u32     types;
+};
+
+/**
+ * s5p_jpeg_q_data - parameters of one queue
+ * @fmt:        driver-specific format of this queue
+ * @w:          image width
+ * @h:          image height
+ * @size:       image buffer size in bytes
+ */
+struct s5p_jpeg_q_data {
+        struct s5p_jpeg_fmt     *fmt;
+        u32                     w;
+        u32                     h;
+        u32                     size;
+};
+
+/**
+ * s5p_jpeg_ctx - the device context data
+ * @jpeg:               JPEG IP device for this context
+ * @mode:               compression (encode) operation or decompression (decode)
+ * @compr_quality:      destination image quality in compression (encode) mode
+ * @m2m_ctx:            mem2mem device context
+ * @out_q:              source (output) queue information
+ * @cap_fmt:            destination (capture) queue queue information
+ * @hdr_parsed:         set if header has been parsed during decompression
+ */
+struct s5p_jpeg_ctx {
+        struct s5p_jpeg         *jpeg;
+        unsigned int            mode;
+        unsigned int            compr_quality;
+        struct v4l2_m2m_ctx     *m2m_ctx;
+        struct s5p_jpeg_q_data  out_q;
+        struct s5p_jpeg_q_data  cap_q;
+        bool                    hdr_parsed;
+};
+
+/**
+ * s5p_jpeg_buffer - description of memory containing input JPEG data
+ * @size:       buffer size
+ * @curr:       current position in the buffer
+ * @data:       pointer to the data
+ */
+struct s5p_jpeg_buffer {
+        unsigned long size;
+        unsigned long curr;
+        unsigned long data;
+};
+
+#endif /* JPEG_CORE_H */
diff --git a/drivers/media/video/s5p-jpeg/jpeg-hw.h b/drivers/media/video/s5p-jpeg/jpeg-hw.h
new file mode 100644
index 000000000000..e10c744e9f23
--- /dev/null
+++ b/drivers/media/video/s5p-jpeg/jpeg-hw.h
@@ -0,0 +1,353 @@
+/* linux/drivers/media/video/s5p-jpeg/jpeg-hw.h
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef JPEG_HW_H_
+#define JPEG_HW_H_
+
+#include <linux/io.h>
+
+#include "jpeg-hw.h"
+#include "jpeg-regs.h"
+
+#define S5P_JPEG_MIN_WIDTH              32
+#define S5P_JPEG_MIN_HEIGHT             32
+#define S5P_JPEG_MAX_WIDTH              8192
+#define S5P_JPEG_MAX_HEIGHT             8192
+#define S5P_JPEG_ENCODE                 0
+#define S5P_JPEG_DECODE                 1
+#define S5P_JPEG_RAW_IN_565             0
+#define S5P_JPEG_RAW_IN_422             1
+#define S5P_JPEG_SUBSAMPLING_422        0
+#define S5P_JPEG_SUBSAMPLING_420        1
+#define S5P_JPEG_RAW_OUT_422            0
+#define S5P_JPEG_RAW_OUT_420            1
+
+static inline void jpeg_reset(void __iomem *regs)
+{
+        unsigned long reg;
+
+        writel(1, regs + S5P_JPG_SW_RESET);
+        reg = readl(regs + S5P_JPG_SW_RESET);
+        /* no other way but polling for when JPEG IP becomes operational */
+        while (reg != 0) {
+                cpu_relax();
+                reg = readl(regs + S5P_JPG_SW_RESET);
+        }
+}
+
+static inline void jpeg_poweron(void __iomem *regs)
+{
+        writel(S5P_POWER_ON, regs + S5P_JPGCLKCON);
+}
+
+static inline void jpeg_input_raw_mode(void __iomem *regs, unsigned long mode)
+{
+        unsigned long reg, m;
+
+        m = S5P_MOD_SEL_565;
+        if (mode == S5P_JPEG_RAW_IN_565)
+                m = S5P_MOD_SEL_565;
+        else if (mode == S5P_JPEG_RAW_IN_422)
+                m = S5P_MOD_SEL_422;
+
+        reg = readl(regs + S5P_JPGCMOD);
+        reg &= ~S5P_MOD_SEL_MASK;
+        reg |= m;
+        writel(reg, regs + S5P_JPGCMOD);
+}
+
+static inline void jpeg_input_raw_y16(void __iomem *regs, bool y16)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPGCMOD);
+        if (y16)
+                reg |= S5P_MODE_Y16;
+        else
+                reg &= ~S5P_MODE_Y16_MASK;
+        writel(reg, regs + S5P_JPGCMOD);
+}
+
+static inline void jpeg_proc_mode(void __iomem *regs, unsigned long mode)
+{
+        unsigned long reg, m;
+
+        m = S5P_PROC_MODE_DECOMPR;
+        if (mode == S5P_JPEG_ENCODE)
+                m = S5P_PROC_MODE_COMPR;
+        else
+                m = S5P_PROC_MODE_DECOMPR;
+        reg = readl(regs + S5P_JPGMOD);
+        reg &= ~S5P_PROC_MODE_MASK;
+        reg |= m;
+        writel(reg, regs + S5P_JPGMOD);
+}
+
+static inline void jpeg_subsampling_mode(void __iomem *regs, unsigned long mode)
+{
+        unsigned long reg, m;
+
+        m = S5P_SUBSAMPLING_MODE_422;
+        if (mode == S5P_JPEG_SUBSAMPLING_422)
+                m = S5P_SUBSAMPLING_MODE_422;
+        else if (mode == S5P_JPEG_SUBSAMPLING_420)
+                m = S5P_SUBSAMPLING_MODE_420;
+        reg = readl(regs + S5P_JPGMOD);
+        reg &= ~S5P_SUBSAMPLING_MODE_MASK;
+        reg |= m;
+        writel(reg, regs + S5P_JPGMOD);
+}
+
+static inline void jpeg_dri(void __iomem *regs, unsigned int dri)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPGDRI_U);
+        reg &= ~0xff;
+        reg |= (dri >> 8) & 0xff;
+        writel(reg, regs + S5P_JPGDRI_U);
+
+        reg = readl(regs + S5P_JPGDRI_L);
+        reg &= ~0xff;
+        reg |= dri & 0xff;
+        writel(reg, regs + S5P_JPGDRI_L);
+}
+
+static inline void jpeg_qtbl(void __iomem *regs, unsigned int t, unsigned int n)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_QTBL);
+        reg &= ~S5P_QT_NUMt_MASK(t);
+        reg |= (n << S5P_QT_NUMt_SHIFT(t)) & S5P_QT_NUMt_MASK(t);
+        writel(reg, regs + S5P_JPG_QTBL);
+}
+
+static inline void jpeg_htbl_ac(void __iomem *regs, unsigned int t)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_HTBL);
+        reg &= ~S5P_HT_NUMt_AC_MASK(t);
+        /* this driver uses table 0 for all color components */
+        reg |= (0 << S5P_HT_NUMt_AC_SHIFT(t)) & S5P_HT_NUMt_AC_MASK(t);
+        writel(reg, regs + S5P_JPG_HTBL);
+}
+
+static inline void jpeg_htbl_dc(void __iomem *regs, unsigned int t)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_HTBL);
+        reg &= ~S5P_HT_NUMt_DC_MASK(t);
+        /* this driver uses table 0 for all color components */
+        reg |= (0 << S5P_HT_NUMt_DC_SHIFT(t)) & S5P_HT_NUMt_DC_MASK(t);
+        writel(reg, regs + S5P_JPG_HTBL);
+}
+
+static inline void jpeg_y(void __iomem *regs, unsigned int y)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPGY_U);
+        reg &= ~0xff;
+        reg |= (y >> 8) & 0xff;
+        writel(reg, regs + S5P_JPGY_U);
+
+        reg = readl(regs + S5P_JPGY_L);
+        reg &= ~0xff;
+        reg |= y & 0xff;
+        writel(reg, regs + S5P_JPGY_L);
+}
+
+static inline void jpeg_x(void __iomem *regs, unsigned int x)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPGX_U);
+        reg &= ~0xff;
+        reg |= (x >> 8) & 0xff;
+        writel(reg, regs + S5P_JPGX_U);
+
+        reg = readl(regs + S5P_JPGX_L);
+        reg &= ~0xff;
+        reg |= x & 0xff;
+        writel(reg, regs + S5P_JPGX_L);
+}
+
+static inline void jpeg_rst_int_enable(void __iomem *regs, bool enable)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPGINTSE);
+        reg &= ~S5P_RSTm_INT_EN_MASK;
+        if (enable)
+                reg |= S5P_RSTm_INT_EN;
+        writel(reg, regs + S5P_JPGINTSE);
+}
+
+static inline void jpeg_data_num_int_enable(void __iomem *regs, bool enable)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPGINTSE);
+        reg &= ~S5P_DATA_NUM_INT_EN_MASK;
+        if (enable)
+                reg |= S5P_DATA_NUM_INT_EN;
+        writel(reg, regs + S5P_JPGINTSE);
+}
+
+static inline void jpeg_final_mcu_num_int_enable(void __iomem *regs, bool enbl)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPGINTSE);
+        reg &= ~S5P_FINAL_MCU_NUM_INT_EN_MASK;
+        if (enbl)
+                reg |= S5P_FINAL_MCU_NUM_INT_EN;
+        writel(reg, regs + S5P_JPGINTSE);
+}
+
+static inline void jpeg_timer_enable(void __iomem *regs, unsigned long val)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_TIMER_SE);
+        reg |= S5P_TIMER_INT_EN;
+        reg &= ~S5P_TIMER_INIT_MASK;
+        reg |= val & S5P_TIMER_INIT_MASK;
+        writel(reg, regs + S5P_JPG_TIMER_SE);
+}
+
+static inline void jpeg_timer_disable(void __iomem *regs)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_TIMER_SE);
+        reg &= ~S5P_TIMER_INT_EN_MASK;
+        writel(reg, regs + S5P_JPG_TIMER_SE);
+}
+
+static inline int jpeg_timer_stat(void __iomem *regs)
+{
+        return (int)((readl(regs + S5P_JPG_TIMER_ST) & S5P_TIMER_INT_STAT_MASK)
+                     >> S5P_TIMER_INT_STAT_SHIFT);
+}
+
+static inline void jpeg_clear_timer_stat(void __iomem *regs)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_TIMER_SE);
+        reg &= ~S5P_TIMER_INT_STAT_MASK;
+        writel(reg, regs + S5P_JPG_TIMER_SE);
+}
+
+static inline void jpeg_enc_stream_int(void __iomem *regs, unsigned long size)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_ENC_STREAM_INTSE);
+        reg &= ~S5P_ENC_STREAM_BOUND_MASK;
+        reg |= S5P_ENC_STREAM_INT_EN;
+        reg |= size & S5P_ENC_STREAM_BOUND_MASK;
+        writel(reg, regs + S5P_JPG_ENC_STREAM_INTSE);
+}
+
+static inline int jpeg_enc_stream_stat(void __iomem *regs)
+{
+        return (int)(readl(regs + S5P_JPG_ENC_STREAM_INTST) &
+                     S5P_ENC_STREAM_INT_STAT_MASK);
+}
+
+static inline void jpeg_clear_enc_stream_stat(void __iomem *regs)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_ENC_STREAM_INTSE);
+        reg &= ~S5P_ENC_STREAM_INT_MASK;
+        writel(reg, regs + S5P_JPG_ENC_STREAM_INTSE);
+}
+
+static inline void jpeg_outform_raw(void __iomem *regs, unsigned long format)
+{
+        unsigned long reg, f;
+
+        f = S5P_DEC_OUT_FORMAT_422;
+        if (format == S5P_JPEG_RAW_OUT_422)
+                f = S5P_DEC_OUT_FORMAT_422;
+        else if (format == S5P_JPEG_RAW_OUT_420)
+                f = S5P_DEC_OUT_FORMAT_420;
+        reg = readl(regs + S5P_JPG_OUTFORM);
+        reg &= ~S5P_DEC_OUT_FORMAT_MASK;
+        reg |= f;
+        writel(reg, regs + S5P_JPG_OUTFORM);
+}
+
+static inline void jpeg_jpgadr(void __iomem *regs, unsigned long addr)
+{
+        writel(addr, regs + S5P_JPG_JPGADR);
+}
+
+static inline void jpeg_imgadr(void __iomem *regs, unsigned long addr)
+{
+        writel(addr, regs + S5P_JPG_IMGADR);
+}
+
+static inline void jpeg_coef(void __iomem *regs, unsigned int i,
+                             unsigned int j, unsigned int coef)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPG_COEF(i));
+        reg &= ~S5P_COEFn_MASK(j);
+        reg |= (coef << S5P_COEFn_SHIFT(j)) & S5P_COEFn_MASK(j);
+        writel(reg, regs + S5P_JPG_COEF(i));
+}
+
+static inline void jpeg_start(void __iomem *regs)
+{
+        writel(1, regs + S5P_JSTART);
+}
+
+static inline int jpeg_result_stat_ok(void __iomem *regs)
+{
+        return (int)((readl(regs + S5P_JPGINTST) & S5P_RESULT_STAT_MASK)
+                     >> S5P_RESULT_STAT_SHIFT);
+}
+
+static inline int jpeg_stream_stat_ok(void __iomem *regs)
+{
+        return !(int)((readl(regs + S5P_JPGINTST) & S5P_STREAM_STAT_MASK)
+                      >> S5P_STREAM_STAT_SHIFT);
+}
+
+static inline void jpeg_clear_int(void __iomem *regs)
+{
+        unsigned long reg;
+
+        reg = readl(regs + S5P_JPGINTST);
+        writel(S5P_INT_RELEASE, regs + S5P_JPGCOM);
+        reg = readl(regs + S5P_JPGOPR);
+}
+
+static inline unsigned int jpeg_compressed_size(void __iomem *regs)
+{
+        unsigned long jpeg_size = 0;
+
+        jpeg_size |= (readl(regs + S5P_JPGCNT_U) & 0xff) << 16;
+        jpeg_size |= (readl(regs + S5P_JPGCNT_M) & 0xff) << 8;
+        jpeg_size |= (readl(regs + S5P_JPGCNT_L) & 0xff);
+
+        return (unsigned int)jpeg_size;
+}
+
+#endif /* JPEG_HW_H_ */
diff --git a/drivers/media/video/s5p-jpeg/jpeg-regs.h b/drivers/media/video/s5p-jpeg/jpeg-regs.h
new file mode 100644
index 000000000000..91f4dd5f86dd
--- /dev/null
+++ b/drivers/media/video/s5p-jpeg/jpeg-regs.h
@@ -0,0 +1,170 @@
+/* linux/drivers/media/video/s5p-jpeg/jpeg-regs.h
+ *
+ * Register definition file for Samsung JPEG codec driver
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef JPEG_REGS_H_
+#define JPEG_REGS_H_
+
+/* JPEG mode register */
+#define S5P_JPGMOD                      0x00
+#define S5P_PROC_MODE_MASK              (0x1 << 3)
+#define S5P_PROC_MODE_DECOMPR           (0x1 << 3)
+#define S5P_PROC_MODE_COMPR             (0x0 << 3)
+#define S5P_SUBSAMPLING_MODE_MASK       0x7
+#define S5P_SUBSAMPLING_MODE_444        (0x0 << 0)
+#define S5P_SUBSAMPLING_MODE_422        (0x1 << 0)
+#define S5P_SUBSAMPLING_MODE_420        (0x2 << 0)
+#define S5P_SUBSAMPLING_MODE_GRAY       (0x3 << 0)
+
+/* JPEG operation status register */
+#define S5P_JPGOPR                      0x04
+
+/* Quantization tables*/
+#define S5P_JPG_QTBL                    0x08
+#define S5P_QT_NUMt_SHIFT(t)            (((t) - 1) << 1)
+#define S5P_QT_NUMt_MASK(t)             (0x3 << S5P_QT_NUMt_SHIFT(t))
+
+/* Huffman tables */
+#define S5P_JPG_HTBL                    0x0c
+#define S5P_HT_NUMt_AC_SHIFT(t)         (((t) << 1) - 1)
+#define S5P_HT_NUMt_AC_MASK(t)          (0x1 << S5P_HT_NUMt_AC_SHIFT(t))
+
+#define S5P_HT_NUMt_DC_SHIFT(t)         (((t) - 1) << 1)
+#define S5P_HT_NUMt_DC_MASK(t)          (0x1 << S5P_HT_NUMt_DC_SHIFT(t))
+
+/* JPEG restart interval register upper byte */
+#define S5P_JPGDRI_U                    0x10
+
+/* JPEG restart interval register lower byte */
+#define S5P_JPGDRI_L                    0x14
+
+/* JPEG vertical resolution register upper byte */
+#define S5P_JPGY_U                      0x18
+
+/* JPEG vertical resolution register lower byte */
+#define S5P_JPGY_L                      0x1c
+
+/* JPEG horizontal resolution register upper byte */
+#define S5P_JPGX_U                      0x20
+
+/* JPEG horizontal resolution register lower byte */
+#define S5P_JPGX_L                      0x24
+
+/* JPEG byte count register upper byte */
+#define S5P_JPGCNT_U                    0x28
+
+/* JPEG byte count register middle byte */
+#define S5P_JPGCNT_M                    0x2c
+
+/* JPEG byte count register lower byte */
+#define S5P_JPGCNT_L                    0x30
+
+/* JPEG interrupt setting register */
+#define S5P_JPGINTSE                    0x34
+#define S5P_RSTm_INT_EN_MASK            (0x1 << 7)
+#define S5P_RSTm_INT_EN                 (0x1 << 7)
+#define S5P_DATA_NUM_INT_EN_MASK        (0x1 << 6)
+#define S5P_DATA_NUM_INT_EN             (0x1 << 6)
+#define S5P_FINAL_MCU_NUM_INT_EN_MASK   (0x1 << 5)
+#define S5P_FINAL_MCU_NUM_INT_EN        (0x1 << 5)
+
+/* JPEG interrupt status register */
+#define S5P_JPGINTST                    0x38
+#define S5P_RESULT_STAT_SHIFT           6
+#define S5P_RESULT_STAT_MASK            (0x1 << S5P_RESULT_STAT_SHIFT)
+#define S5P_STREAM_STAT_SHIFT           5
+#define S5P_STREAM_STAT_MASK            (0x1 << S5P_STREAM_STAT_SHIFT)
+
+/* JPEG command register */
+#define S5P_JPGCOM                      0x4c
+#define S5P_INT_RELEASE                 (0x1 << 2)
+
+/* Raw image data r/w address register */
+#define S5P_JPG_IMGADR                  0x50
+
+/* JPEG file r/w address register */
+#define S5P_JPG_JPGADR                  0x58
+
+/* Coefficient for RGB-to-YCbCr converter register */
+#define S5P_JPG_COEF(n)                 (0x5c + (((n) - 1) << 2))
+#define S5P_COEFn_SHIFT(j)              ((3 - (j)) << 3)
+#define S5P_COEFn_MASK(j)               (0xff << S5P_COEFn_SHIFT(j))
+
+/* JPEG color mode register */
+#define S5P_JPGCMOD                     0x68
+#define S5P_MOD_SEL_MASK                (0x7 << 5)
+#define S5P_MOD_SEL_422                 (0x1 << 5)
+#define S5P_MOD_SEL_565                 (0x2 << 5)
+#define S5P_MODE_Y16_MASK               (0x1 << 1)
+#define S5P_MODE_Y16                    (0x1 << 1)
+
+/* JPEG clock control register */
+#define S5P_JPGCLKCON                   0x6c
+#define S5P_CLK_DOWN_READY              (0x1 << 1)
+#define S5P_POWER_ON                    (0x1 << 0)
+
+/* JPEG start register */
+#define S5P_JSTART                      0x70
+
+/* JPEG SW reset register */
+#define S5P_JPG_SW_RESET                0x78
+
+/* JPEG timer setting register */
+#define S5P_JPG_TIMER_SE                0x7c
+#define S5P_TIMER_INT_EN_MASK           (0x1 << 31)
+#define S5P_TIMER_INT_EN                (0x1 << 31)
+#define S5P_TIMER_INIT_MASK             0x7fffffff
+
+/* JPEG timer status register */
+#define S5P_JPG_TIMER_ST                0x80
+#define S5P_TIMER_INT_STAT_SHIFT        31
+#define S5P_TIMER_INT_STAT_MASK         (0x1 << S5P_TIMER_INT_STAT_SHIFT)
+#define S5P_TIMER_CNT_SHIFT             0
+#define S5P_TIMER_CNT_MASK              0x7fffffff
+
+/* JPEG decompression output format register */
+#define S5P_JPG_OUTFORM                 0x88
+#define S5P_DEC_OUT_FORMAT_MASK         (0x1 << 0)
+#define S5P_DEC_OUT_FORMAT_422          (0x0 << 0)
+#define S5P_DEC_OUT_FORMAT_420          (0x1 << 0)
+
+/* JPEG version register */
+#define S5P_JPG_VERSION                 0x8c
+
+/* JPEG compressed stream size interrupt setting register */
+#define S5P_JPG_ENC_STREAM_INTSE        0x98
+#define S5P_ENC_STREAM_INT_MASK         (0x1 << 24)
+#define S5P_ENC_STREAM_INT_EN           (0x1 << 24)
+#define S5P_ENC_STREAM_BOUND_MASK       0xffffff
+
+/* JPEG compressed stream size interrupt status register */
+#define S5P_JPG_ENC_STREAM_INTST        0x9c
+#define S5P_ENC_STREAM_INT_STAT_MASK    0x1
+
+/* JPEG quantizer table register */
+#define S5P_JPG_QTBL_CONTENT(n)         (0x400 + (n) * 0x100)
+
+/* JPEG DC Huffman table register */
+#define S5P_JPG_HDCTBL(n)               (0x800 + (n) * 0x400)
+
+/* JPEG DC Huffman table register */
+#define S5P_JPG_HDCTBLG(n)              (0x840 + (n) * 0x400)
+
+/* JPEG AC Huffman table register */
+#define S5P_JPG_HACTBL(n)               (0x880 + (n) * 0x400)
+
+/* JPEG AC Huffman table register */
+#define S5P_JPG_HACTBLG(n)              (0x8c0 + (n) * 0x400)
+
+#endif /* JPEG_REGS_H_ */
+
diff --git a/drivers/media/video/s5p-mfc/s5p_mfc.c b/drivers/media/video/s5p-mfc/s5p_mfc.c
index 8be8b54eb749..e43e128baf5f 100644
--- a/drivers/media/video/s5p-mfc/s5p_mfc.c
+++ b/drivers/media/video/s5p-mfc/s5p_mfc.c
@@ -1245,27 +1245,7 @@ static struct platform_driver s5p_mfc_driver = {
         },
 };
 
-static char banner[] __initdata =
-                        "S5P MFC V4L2 Driver, (C) 2011 Samsung Electronics\n";
-
-static int __init s5p_mfc_init(void)
-{
-        int ret;
-
-        pr_info("%s", banner);
-        ret = platform_driver_register(&s5p_mfc_driver);
-        if (ret)
-                pr_err("Platform device registration failed.\n");
-        return ret;
-}
-
-static void __exit s5p_mfc_exit(void)
-{
-        platform_driver_unregister(&s5p_mfc_driver);
-}
-
-module_init(s5p_mfc_init);
-module_exit(s5p_mfc_exit);
+module_platform_driver(s5p_mfc_driver);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
diff --git a/drivers/media/video/s5p-tv/hdmi_drv.c b/drivers/media/video/s5p-tv/hdmi_drv.c
index 0279e6e89feb..8b41a0410ab1 100644
--- a/drivers/media/video/s5p-tv/hdmi_drv.c
+++ b/drivers/media/video/s5p-tv/hdmi_drv.c
@@ -838,8 +838,8 @@ static int hdmi_resources_init(struct hdmi_device *hdev)
                 dev_err(dev, "failed to get clock 'hdmiphy'\n");
                 goto fail;
         }
-        res->regul_bulk = kzalloc(ARRAY_SIZE(supply) *
-                sizeof res->regul_bulk[0], GFP_KERNEL);
+        res->regul_bulk = kcalloc(ARRAY_SIZE(supply),
+                                  sizeof(res->regul_bulk[0]), GFP_KERNEL);
         if (!res->regul_bulk) {
                 dev_err(dev, "failed to get memory for regulators\n");
                 goto fail;
@@ -1016,28 +1016,4 @@ static struct platform_driver hdmi_driver __refdata = {
         }
 };
 
-/* D R I V E R   I N I T I A L I Z A T I O N */
-
-static int __init hdmi_init(void)
-{
-        int ret;
-        static const char banner[] __initdata = KERN_INFO \
-                "Samsung HDMI output driver, "
-                "(c) 2010-2011 Samsung Electronics Co., Ltd.\n";
-        printk(banner);
-
-        ret = platform_driver_register(&hdmi_driver);
-        if (ret)
-                printk(KERN_ERR "HDMI platform driver register failed\n");
-
-        return ret;
-}
-module_init(hdmi_init);
-
-static void __exit hdmi_exit(void)
-{
-        platform_driver_unregister(&hdmi_driver);
-}
-module_exit(hdmi_exit);
-
-
+module_platform_driver(hdmi_driver);
diff --git a/drivers/media/video/s5p-tv/mixer.h b/drivers/media/video/s5p-tv/mixer.h
index 51ad59b30358..1597078c4a50 100644
--- a/drivers/media/video/s5p-tv/mixer.h
+++ b/drivers/media/video/s5p-tv/mixer.h
@@ -86,6 +86,17 @@ struct mxr_crop {
         unsigned int field;
 };
 
+/** stages of geometry operations */
+enum mxr_geometry_stage {
+        MXR_GEOMETRY_SINK,
+        MXR_GEOMETRY_COMPOSE,
+        MXR_GEOMETRY_CROP,
+        MXR_GEOMETRY_SOURCE,
+};
+
+/* flag indicating that offset should be 0 */
+#define MXR_NO_OFFSET   0x80000000
+
 /** description of transformation from source to destination image */
 struct mxr_geometry {
         /** cropping for source image */
@@ -133,7 +144,8 @@ struct mxr_layer_ops {
         /** streaming stop/start */
         void (*stream_set)(struct mxr_layer *, int);
         /** adjusting geometry */
-        void (*fix_geometry)(struct mxr_layer *);
+        void (*fix_geometry)(struct mxr_layer *,
+                enum mxr_geometry_stage, unsigned long);
 };
 
 /** layer instance, a single window and content displayed on output */
diff --git a/drivers/media/video/s5p-tv/mixer_grp_layer.c b/drivers/media/video/s5p-tv/mixer_grp_layer.c
index de8270c2b6e7..b93a21f5aa13 100644
--- a/drivers/media/video/s5p-tv/mixer_grp_layer.c
+++ b/drivers/media/video/s5p-tv/mixer_grp_layer.c
@@ -101,47 +101,132 @@ static void mxr_graph_format_set(struct mxr_layer *layer)
                 layer->fmt, &layer->geo);
 }
 
-static void mxr_graph_fix_geometry(struct mxr_layer *layer)
+static inline unsigned int closest(unsigned int x, unsigned int a,
+        unsigned int b, unsigned long flags)
+{
+        unsigned int mid = (a + b) / 2;
+
+        /* choosing closest value with constraints according to table:
+         * -------------+-----+-----+-----+-------+
+         * flags        |  0  |  LE |  GE | LE|GE |
+         * -------------+-----+-----+-----+-------+
+         * x <= a       |  a  |  a  |  a  |   a   |
+         * a < x <= mid |  a  |  a  |  b  |   a   |
+         * mid < x < b  |  b  |  a  |  b  |   b   |
+         * b <= x       |  b  |  b  |  b  |   b   |
+         * -------------+-----+-----+-----+-------+
+         */
+
+        /* remove all non-constraint flags */
+        flags &= V4L2_SEL_FLAG_LE | V4L2_SEL_FLAG_GE;
+
+        if (x <= a)
+                return  a;
+        if (x >= b)
+                return b;
+        if (flags == V4L2_SEL_FLAG_LE)
+                return a;
+        if (flags == V4L2_SEL_FLAG_GE)
+                return b;
+        if (x <= mid)
+                return a;
+        return b;
+}
+
+static inline unsigned int do_center(unsigned int center,
+        unsigned int size, unsigned int upper, unsigned int flags)
+{
+        unsigned int lower;
+
+        if (flags & MXR_NO_OFFSET)
+                return 0;
+
+        lower = center - min(center, size / 2);
+        return min(lower, upper - size);
+}
+
+static void mxr_graph_fix_geometry(struct mxr_layer *layer,
+        enum mxr_geometry_stage stage, unsigned long flags)
 {
         struct mxr_geometry *geo = &layer->geo;
+        struct mxr_crop *src = &geo->src;
+        struct mxr_crop *dst = &geo->dst;
+        unsigned int x_center, y_center;
 
-        /* limit to boundary size */
-        geo->src.full_width = clamp_val(geo->src.full_width, 1, 32767);
-        geo->src.full_height = clamp_val(geo->src.full_height, 1, 2047);
-        geo->src.width = clamp_val(geo->src.width, 1, geo->src.full_width);
-        geo->src.width = min(geo->src.width, 2047U);
-        /* not possible to crop of Y axis */
-        geo->src.y_offset = min(geo->src.y_offset, geo->src.full_height - 1);
-        geo->src.height = geo->src.full_height - geo->src.y_offset;
-        /* limitting offset */
-        geo->src.x_offset = min(geo->src.x_offset,
-                geo->src.full_width - geo->src.width);
-
-        /* setting position in output */
-        geo->dst.width = min(geo->dst.width, geo->dst.full_width);
-        geo->dst.height = min(geo->dst.height, geo->dst.full_height);
-
-        /* Mixer supports only 1x and 2x scaling */
-        if (geo->dst.width >= 2 * geo->src.width) {
-                geo->x_ratio = 1;
-                geo->dst.width = 2 * geo->src.width;
-        } else {
-                geo->x_ratio = 0;
-                geo->dst.width = geo->src.width;
-        }
+        switch (stage) {
 
-        if (geo->dst.height >= 2 * geo->src.height) {
-                geo->y_ratio = 1;
-                geo->dst.height = 2 * geo->src.height;
-        } else {
-                geo->y_ratio = 0;
-                geo->dst.height = geo->src.height;
-        }
+        case MXR_GEOMETRY_SINK: /* nothing to be fixed here */
+                flags = 0;
+                /* fall through */
+
+        case MXR_GEOMETRY_COMPOSE:
+                /* remember center of the area */
+                x_center = dst->x_offset + dst->width / 2;
+                y_center = dst->y_offset + dst->height / 2;
+                /* round up/down to 2 multiple depending on flags */
+                if (flags & V4L2_SEL_FLAG_LE) {
+                        dst->width = round_down(dst->width, 2);
+                        dst->height = round_down(dst->height, 2);
+                } else {
+                        dst->width = round_up(dst->width, 2);
+                        dst->height = round_up(dst->height, 2);
+                }
+                /* assure that compose rect is inside display area */
+                dst->width = min(dst->width, dst->full_width);
+                dst->height = min(dst->height, dst->full_height);
+
+                /* ensure that compose is reachable using 2x scaling */
+                dst->width = min(dst->width, 2 * src->full_width);
+                dst->height = min(dst->height, 2 * src->full_height);
+
+                /* setup offsets */
+                dst->x_offset = do_center(x_center, dst->width,
+                        dst->full_width, flags);
+                dst->y_offset = do_center(y_center, dst->height,
+                        dst->full_height, flags);
+                flags = 0;
+                /* fall through */
 
-        geo->dst.x_offset = min(geo->dst.x_offset,
-                geo->dst.full_width - geo->dst.width);
-        geo->dst.y_offset = min(geo->dst.y_offset,
-                geo->dst.full_height - geo->dst.height);
+        case MXR_GEOMETRY_CROP:
+                /* remember center of the area */
+                x_center = src->x_offset + src->width / 2;
+                y_center = src->y_offset + src->height / 2;
+                /* ensure that cropping area lies inside the buffer */
+                if (src->full_width < dst->width)
+                        src->width = dst->width / 2;
+                else
+                        src->width = closest(src->width, dst->width / 2,
+                                dst->width, flags);
+
+                if (src->width == dst->width)
+                        geo->x_ratio = 0;
+                else
+                        geo->x_ratio = 1;
+
+                if (src->full_height < dst->height)
+                        src->height = dst->height / 2;
+                else
+                        src->height = closest(src->height, dst->height / 2,
+                                dst->height, flags);
+
+                if (src->height == dst->height)
+                        geo->y_ratio = 0;
+                else
+                        geo->y_ratio = 1;
+
+                /* setup offsets */
+                src->x_offset = do_center(x_center, src->width,
+                        src->full_width, flags);
+                src->y_offset = do_center(y_center, src->height,
+                        src->full_height, flags);
+                flags = 0;
+                /* fall through */
+        case MXR_GEOMETRY_SOURCE:
+                src->full_width = clamp_val(src->full_width,
+                        src->width + src->x_offset, 32767);
+                src->full_height = clamp_val(src->full_height,
+                        src->height + src->y_offset, 2047);
+        };
 }
 
 /* PUBLIC API */
diff --git a/drivers/media/video/s5p-tv/mixer_video.c b/drivers/media/video/s5p-tv/mixer_video.c
index b47d0c06ecf5..7884baeff76a 100644
--- a/drivers/media/video/s5p-tv/mixer_video.c
+++ b/drivers/media/video/s5p-tv/mixer_video.c
@@ -170,18 +170,22 @@ static int mxr_querycap(struct file *file, void *priv,
         return 0;
 }
 
-/* Geometry handling */
-static void mxr_layer_geo_fix(struct mxr_layer *layer)
+static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo)
 {
-        struct mxr_device *mdev = layer->mdev;
-        struct v4l2_mbus_framefmt mbus_fmt;
-
-        /* TODO: add some dirty flag to avoid unnecessary adjustments */
-        mxr_get_mbus_fmt(mdev, &mbus_fmt);
-        layer->geo.dst.full_width = mbus_fmt.width;
-        layer->geo.dst.full_height = mbus_fmt.height;
-        layer->geo.dst.field = mbus_fmt.field;
-        layer->ops.fix_geometry(layer);
+        mxr_dbg(mdev, "src.full_size = (%u, %u)\n",
+                geo->src.full_width, geo->src.full_height);
+        mxr_dbg(mdev, "src.size = (%u, %u)\n",
+                geo->src.width, geo->src.height);
+        mxr_dbg(mdev, "src.offset = (%u, %u)\n",
+                geo->src.x_offset, geo->src.y_offset);
+        mxr_dbg(mdev, "dst.full_size = (%u, %u)\n",
+                geo->dst.full_width, geo->dst.full_height);
+        mxr_dbg(mdev, "dst.size = (%u, %u)\n",
+                geo->dst.width, geo->dst.height);
+        mxr_dbg(mdev, "dst.offset = (%u, %u)\n",
+                geo->dst.x_offset, geo->dst.y_offset);
+        mxr_dbg(mdev, "ratio = (%u, %u)\n",
+                geo->x_ratio, geo->y_ratio);
 }
 
 static void mxr_layer_default_geo(struct mxr_layer *layer)
@@ -204,27 +208,29 @@ static void mxr_layer_default_geo(struct mxr_layer *layer)
         layer->geo.src.width = layer->geo.src.full_width;
         layer->geo.src.height = layer->geo.src.full_height;
 
-        layer->ops.fix_geometry(layer);
+        mxr_geometry_dump(mdev, &layer->geo);
+        layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
+        mxr_geometry_dump(mdev, &layer->geo);
 }
 
-static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo)
+static void mxr_layer_update_output(struct mxr_layer *layer)
 {
-        mxr_dbg(mdev, "src.full_size = (%u, %u)\n",
-                geo->src.full_width, geo->src.full_height);
-        mxr_dbg(mdev, "src.size = (%u, %u)\n",
-                geo->src.width, geo->src.height);
-        mxr_dbg(mdev, "src.offset = (%u, %u)\n",
-                geo->src.x_offset, geo->src.y_offset);
-        mxr_dbg(mdev, "dst.full_size = (%u, %u)\n",
-                geo->dst.full_width, geo->dst.full_height);
-        mxr_dbg(mdev, "dst.size = (%u, %u)\n",
-                geo->dst.width, geo->dst.height);
-        mxr_dbg(mdev, "dst.offset = (%u, %u)\n",
-                geo->dst.x_offset, geo->dst.y_offset);
-        mxr_dbg(mdev, "ratio = (%u, %u)\n",
-                geo->x_ratio, geo->y_ratio);
-}
+        struct mxr_device *mdev = layer->mdev;
+        struct v4l2_mbus_framefmt mbus_fmt;
+
+        mxr_get_mbus_fmt(mdev, &mbus_fmt);
+        /* checking if update is needed */
+        if (layer->geo.dst.full_width == mbus_fmt.width &&
+                layer->geo.dst.full_height == mbus_fmt.width)
+                return;
 
+        layer->geo.dst.full_width = mbus_fmt.width;
+        layer->geo.dst.full_height = mbus_fmt.height;
+        layer->geo.dst.field = mbus_fmt.field;
+        layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
+
+        mxr_geometry_dump(mdev, &layer->geo);
+}
 
 static const struct mxr_format *find_format_by_fourcc(
         struct mxr_layer *layer, unsigned long fourcc);
@@ -249,37 +255,6 @@ static int mxr_enum_fmt(struct file *file, void  *priv,
         return 0;
 }
 
-static int mxr_s_fmt(struct file *file, void *priv,
-        struct v4l2_format *f)
-{
-        struct mxr_layer *layer = video_drvdata(file);
-        const struct mxr_format *fmt;
-        struct v4l2_pix_format_mplane *pix;
-        struct mxr_device *mdev = layer->mdev;
-        struct mxr_geometry *geo = &layer->geo;
-
-        mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
-
-        pix = &f->fmt.pix_mp;
-        fmt = find_format_by_fourcc(layer, pix->pixelformat);
-        if (fmt == NULL) {
-                mxr_warn(mdev, "not recognized fourcc: %08x\n",
-                        pix->pixelformat);
-                return -EINVAL;
-        }
-        layer->fmt = fmt;
-        geo->src.full_width = pix->width;
-        geo->src.width = pix->width;
-        geo->src.full_height = pix->height;
-        geo->src.height = pix->height;
-        /* assure consistency of geometry */
-        mxr_layer_geo_fix(layer);
-        mxr_dbg(mdev, "width=%u height=%u span=%u\n",
-                geo->src.width, geo->src.height, geo->src.full_width);
-
-        return 0;
-}
-
 static unsigned int divup(unsigned int divident, unsigned int divisor)
 {
         return (divident + divisor - 1) / divisor;
@@ -299,6 +274,10 @@ static void mxr_mplane_fill(struct v4l2_plane_pix_format *planes,
 {
         int i;
 
+        /* checking if nothing to fill */
+        if (!planes)
+                return;
+
         memset(planes, 0, sizeof(*planes) * fmt->num_subframes);
         for (i = 0; i < fmt->num_planes; ++i) {
                 struct v4l2_plane_pix_format *plane = planes
@@ -332,73 +311,194 @@ static int mxr_g_fmt(struct file *file, void *priv,
         return 0;
 }
 
-static inline struct mxr_crop *choose_crop_by_type(struct mxr_geometry *geo,
-        enum v4l2_buf_type type)
-{
-        switch (type) {
-        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
-        case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
-                return &geo->dst;
-        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
-                return &geo->src;
-        default:
-                return NULL;
-        }
-}
-
-static int mxr_g_crop(struct file *file, void *fh, struct v4l2_crop *a)
+static int mxr_s_fmt(struct file *file, void *priv,
+        struct v4l2_format *f)
 {
         struct mxr_layer *layer = video_drvdata(file);
-        struct mxr_crop *crop;
+        const struct mxr_format *fmt;
+        struct v4l2_pix_format_mplane *pix;
+        struct mxr_device *mdev = layer->mdev;
+        struct mxr_geometry *geo = &layer->geo;
 
-        mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
-        crop = choose_crop_by_type(&layer->geo, a->type);
-        if (crop == NULL)
+        mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
+
+        pix = &f->fmt.pix_mp;
+        fmt = find_format_by_fourcc(layer, pix->pixelformat);
+        if (fmt == NULL) {
+                mxr_warn(mdev, "not recognized fourcc: %08x\n",
+                        pix->pixelformat);
                 return -EINVAL;
-        mxr_layer_geo_fix(layer);
-        a->c.left = crop->x_offset;
-        a->c.top = crop->y_offset;
-        a->c.width = crop->width;
-        a->c.height = crop->height;
+        }
+        layer->fmt = fmt;
+        /* set source size to highest accepted value */
+        geo->src.full_width = max(geo->dst.full_width, pix->width);
+        geo->src.full_height = max(geo->dst.full_height, pix->height);
+        layer->ops.fix_geometry(layer, MXR_GEOMETRY_SOURCE, 0);
+        mxr_geometry_dump(mdev, &layer->geo);
+        /* set cropping to total visible screen */
+        geo->src.width = pix->width;
+        geo->src.height = pix->height;
+        geo->src.x_offset = 0;
+        geo->src.y_offset = 0;
+        /* assure consistency of geometry */
+        layer->ops.fix_geometry(layer, MXR_GEOMETRY_CROP, MXR_NO_OFFSET);
+        mxr_geometry_dump(mdev, &layer->geo);
+        /* set full size to lowest possible value */
+        geo->src.full_width = 0;
+        geo->src.full_height = 0;
+        layer->ops.fix_geometry(layer, MXR_GEOMETRY_SOURCE, 0);
+        mxr_geometry_dump(mdev, &layer->geo);
+
+        /* returning results */
+        mxr_g_fmt(file, priv, f);
+
         return 0;
 }
 
-static int mxr_s_crop(struct file *file, void *fh, struct v4l2_crop *a)
+static int mxr_g_selection(struct file *file, void *fh,
+        struct v4l2_selection *s)
 {
         struct mxr_layer *layer = video_drvdata(file);
-        struct mxr_crop *crop;
+        struct mxr_geometry *geo = &layer->geo;
 
         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
-        crop = choose_crop_by_type(&layer->geo, a->type);
-        if (crop == NULL)
+
+        if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
+                s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
+                return -EINVAL;
+
+        switch (s->target) {
+        case V4L2_SEL_TGT_CROP_ACTIVE:
+                s->r.left = geo->src.x_offset;
+                s->r.top = geo->src.y_offset;
+                s->r.width = geo->src.width;
+                s->r.height = geo->src.height;
+                break;
+        case V4L2_SEL_TGT_CROP_DEFAULT:
+        case V4L2_SEL_TGT_CROP_BOUNDS:
+                s->r.left = 0;
+                s->r.top = 0;
+                s->r.width = geo->src.full_width;
+                s->r.height = geo->src.full_height;
+                break;
+        case V4L2_SEL_TGT_COMPOSE_ACTIVE:
+        case V4L2_SEL_TGT_COMPOSE_PADDED:
+                s->r.left = geo->dst.x_offset;
+                s->r.top = geo->dst.y_offset;
+                s->r.width = geo->dst.width;
+                s->r.height = geo->dst.height;
+                break;
+        case V4L2_SEL_TGT_COMPOSE_DEFAULT:
+        case V4L2_SEL_TGT_COMPOSE_BOUNDS:
+                s->r.left = 0;
+                s->r.top = 0;
+                s->r.width = geo->dst.full_width;
+                s->r.height = geo->dst.full_height;
+                break;
+        default:
                 return -EINVAL;
-        crop->x_offset = a->c.left;
-        crop->y_offset = a->c.top;
-        crop->width = a->c.width;
-        crop->height = a->c.height;
-        mxr_layer_geo_fix(layer);
+        }
+
         return 0;
 }
 
-static int mxr_cropcap(struct file *file, void *fh, struct v4l2_cropcap *a)
+/* returns 1 if rectangle 'a' is inside 'b' */
+static int mxr_is_rect_inside(struct v4l2_rect *a, struct v4l2_rect *b)
+{
+        if (a->left < b->left)
+                return 0;
+        if (a->top < b->top)
+                return 0;
+        if (a->left + a->width > b->left + b->width)
+                return 0;
+        if (a->top + a->height > b->top + b->height)
+                return 0;
+        return 1;
+}
+
+static int mxr_s_selection(struct file *file, void *fh,
+        struct v4l2_selection *s)
 {
         struct mxr_layer *layer = video_drvdata(file);
-        struct mxr_crop *crop;
+        struct mxr_geometry *geo = &layer->geo;
+        struct mxr_crop *target = NULL;
+        enum mxr_geometry_stage stage;
+        struct mxr_geometry tmp;
+        struct v4l2_rect res;
 
-        mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
-        crop = choose_crop_by_type(&layer->geo, a->type);
-        if (crop == NULL)
+        memset(&res, 0, sizeof res);
+
+        mxr_dbg(layer->mdev, "%s: rect: %dx%d@%d,%d\n", __func__,
+                s->r.width, s->r.height, s->r.left, s->r.top);
+
+        if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
+                s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
                 return -EINVAL;
-        mxr_layer_geo_fix(layer);
-        a->bounds.left = 0;
-        a->bounds.top = 0;
-        a->bounds.width = crop->full_width;
-        a->bounds.top = crop->full_height;
-        a->defrect = a->bounds;
-        /* setting pixel aspect to 1/1 */
-        a->pixelaspect.numerator = 1;
-        a->pixelaspect.denominator = 1;
+
+        switch (s->target) {
+        /* ignore read-only targets */
+        case V4L2_SEL_TGT_CROP_DEFAULT:
+        case V4L2_SEL_TGT_CROP_BOUNDS:
+                res.width = geo->src.full_width;
+                res.height = geo->src.full_height;
+                break;
+
+        /* ignore read-only targets */
+        case V4L2_SEL_TGT_COMPOSE_DEFAULT:
+        case V4L2_SEL_TGT_COMPOSE_BOUNDS:
+                res.width = geo->dst.full_width;
+                res.height = geo->dst.full_height;
+                break;
+
+        case V4L2_SEL_TGT_CROP_ACTIVE:
+                target = &geo->src;
+                stage = MXR_GEOMETRY_CROP;
+                break;
+        case V4L2_SEL_TGT_COMPOSE_ACTIVE:
+        case V4L2_SEL_TGT_COMPOSE_PADDED:
+                target = &geo->dst;
+                stage = MXR_GEOMETRY_COMPOSE;
+                break;
+        default:
+                return -EINVAL;
+        }
+        /* apply change and update geometry if needed */
+        if (target) {
+                /* backup current geometry if setup fails */
+                memcpy(&tmp, geo, sizeof tmp);
+
+                /* apply requested selection */
+                target->x_offset = s->r.left;
+                target->y_offset = s->r.top;
+                target->width = s->r.width;
+                target->height = s->r.height;
+
+                layer->ops.fix_geometry(layer, stage, s->flags);
+
+                /* retrieve update selection rectangle */
+                res.left = target->x_offset;
+                res.top = target->y_offset;
+                res.width = target->width;
+                res.height = target->height;
+
+                mxr_geometry_dump(layer->mdev, &layer->geo);
+        }
+
+        /* checking if the rectangle satisfies constraints */
+        if ((s->flags & V4L2_SEL_FLAG_LE) && !mxr_is_rect_inside(&res, &s->r))
+                goto fail;
+        if ((s->flags & V4L2_SEL_FLAG_GE) && !mxr_is_rect_inside(&s->r, &res))
+                goto fail;
+
+        /* return result rectangle */
+        s->r = res;
+
         return 0;
+fail:
+        /* restore old geometry, which is not touched if target is NULL */
+        if (target)
+                memcpy(geo, &tmp, sizeof tmp);
+        return -ERANGE;
 }
 
 static int mxr_enum_dv_presets(struct file *file, void *fh,
@@ -438,6 +538,8 @@ static int mxr_s_dv_preset(struct file *file, void *fh,
 
         mutex_unlock(&mdev->mutex);
 
+        mxr_layer_update_output(layer);
+
         /* any failure should return EINVAL according to V4L2 doc */
         return ret ? -EINVAL : 0;
 }
@@ -478,6 +580,8 @@ static int mxr_s_std(struct file *file, void *fh, v4l2_std_id *norm)
 
         mutex_unlock(&mdev->mutex);
 
+        mxr_layer_update_output(layer);
+
         return ret ? -EINVAL : 0;
 }
 
@@ -526,25 +630,27 @@ static int mxr_s_output(struct file *file, void *fh, unsigned int i)
         struct video_device *vfd = video_devdata(file);
         struct mxr_layer *layer = video_drvdata(file);
         struct mxr_device *mdev = layer->mdev;
-        int ret = 0;
 
         if (i >= mdev->output_cnt || mdev->output[i] == NULL)
                 return -EINVAL;
 
         mutex_lock(&mdev->mutex);
         if (mdev->n_output > 0) {
-                ret = -EBUSY;
-                goto done;
+                mutex_unlock(&mdev->mutex);
+                return -EBUSY;
         }
         mdev->current_output = i;
         vfd->tvnorms = 0;
         v4l2_subdev_call(to_outsd(mdev), video, g_tvnorms_output,
                 &vfd->tvnorms);
+        mutex_unlock(&mdev->mutex);
+
+        /* update layers geometry */
+        mxr_layer_update_output(layer);
+
         mxr_dbg(mdev, "tvnorms = %08llx\n", vfd->tvnorms);
 
-done:
-        mutex_unlock(&mdev->mutex);
-        return ret;
+        return 0;
 }
 
 static int mxr_g_output(struct file *file, void *fh, unsigned int *p)
@@ -633,10 +739,9 @@ static const struct v4l2_ioctl_ops mxr_ioctl_ops = {
         .vidioc_enum_output = mxr_enum_output,
         .vidioc_s_output = mxr_s_output,
         .vidioc_g_output = mxr_g_output,
-        /* Crop ioctls */
-        .vidioc_g_crop = mxr_g_crop,
-        .vidioc_s_crop = mxr_s_crop,
-        .vidioc_cropcap = mxr_cropcap,
+        /* selection ioctls */
+        .vidioc_g_selection = mxr_g_selection,
+        .vidioc_s_selection = mxr_s_selection,
 };
 
 static int mxr_video_open(struct file *file)
@@ -805,10 +910,7 @@ static int start_streaming(struct vb2_queue *vq, unsigned int count)
         /* block any changes in output configuration */
         mxr_output_get(mdev);
 
-        /* update layers geometry */
-        mxr_layer_geo_fix(layer);
-        mxr_geometry_dump(mdev, &layer->geo);
-
+        mxr_layer_update_output(layer);
         layer->ops.format_set(layer);
         /* enabling layer in hardware */
         spin_lock_irqsave(&layer->enq_slock, flags);
diff --git a/drivers/media/video/s5p-tv/mixer_vp_layer.c b/drivers/media/video/s5p-tv/mixer_vp_layer.c
index f3bb2e34cb51..3d13a636877b 100644
--- a/drivers/media/video/s5p-tv/mixer_vp_layer.c
+++ b/drivers/media/video/s5p-tv/mixer_vp_layer.c
@@ -127,47 +127,77 @@ static void mxr_vp_format_set(struct mxr_layer *layer)
         mxr_reg_vp_format(layer->mdev, layer->fmt, &layer->geo);
 }
 
-static void mxr_vp_fix_geometry(struct mxr_layer *layer)
+static inline unsigned int do_center(unsigned int center,
+        unsigned int size, unsigned int upper, unsigned int flags)
 {
-        struct mxr_geometry *geo = &layer->geo;
+        unsigned int lower;
+
+        if (flags & MXR_NO_OFFSET)
+                return 0;
+
+        lower = center - min(center, size / 2);
+        return min(lower, upper - size);
+}
 
-        /* align horizontal size to 8 pixels */
-        geo->src.full_width = ALIGN(geo->src.full_width, 8);
-        /* limit to boundary size */
-        geo->src.full_width = clamp_val(geo->src.full_width, 8, 8192);
-        geo->src.full_height = clamp_val(geo->src.full_height, 1, 8192);
-        geo->src.width = clamp_val(geo->src.width, 32, geo->src.full_width);
-        geo->src.width = min(geo->src.width, 2047U);
-        geo->src.height = clamp_val(geo->src.height, 4, geo->src.full_height);
-        geo->src.height = min(geo->src.height, 2047U);
-
-        /* setting size of output window */
-        geo->dst.width = clamp_val(geo->dst.width, 8, geo->dst.full_width);
-        geo->dst.height = clamp_val(geo->dst.height, 1, geo->dst.full_height);
-
-        /* ensure that scaling is in range 1/4x to 16x */
-        if (geo->src.width >= 4 * geo->dst.width)
-                geo->src.width = 4 * geo->dst.width;
-        if (geo->dst.width >= 16 * geo->src.width)
-                geo->dst.width = 16 * geo->src.width;
-        if (geo->src.height >= 4 * geo->dst.height)
-                geo->src.height = 4 * geo->dst.height;
-        if (geo->dst.height >= 16 * geo->src.height)
-                geo->dst.height = 16 * geo->src.height;
-
-        /* setting scaling ratio */
-        geo->x_ratio = (geo->src.width << 16) / geo->dst.width;
-        geo->y_ratio = (geo->src.height << 16) / geo->dst.height;
-
-        /* adjust offsets */
-        geo->src.x_offset = min(geo->src.x_offset,
-                geo->src.full_width - geo->src.width);
-        geo->src.y_offset = min(geo->src.y_offset,
-                geo->src.full_height - geo->src.height);
-        geo->dst.x_offset = min(geo->dst.x_offset,
-                geo->dst.full_width - geo->dst.width);
-        geo->dst.y_offset = min(geo->dst.y_offset,
-                geo->dst.full_height - geo->dst.height);
+static void mxr_vp_fix_geometry(struct mxr_layer *layer,
+        enum mxr_geometry_stage stage, unsigned long flags)
+{
+        struct mxr_geometry *geo = &layer->geo;
+        struct mxr_crop *src = &geo->src;
+        struct mxr_crop *dst = &geo->dst;
+        unsigned long x_center, y_center;
+
+        switch (stage) {
+
+        case MXR_GEOMETRY_SINK: /* nothing to be fixed here */
+        case MXR_GEOMETRY_COMPOSE:
+                /* remember center of the area */
+                x_center = dst->x_offset + dst->width / 2;
+                y_center = dst->y_offset + dst->height / 2;
+
+                /* ensure that compose is reachable using 16x scaling */
+                dst->width = clamp(dst->width, 8U, 16 * src->full_width);
+                dst->height = clamp(dst->height, 1U, 16 * src->full_height);
+
+                /* setup offsets */
+                dst->x_offset = do_center(x_center, dst->width,
+                        dst->full_width, flags);
+                dst->y_offset = do_center(y_center, dst->height,
+                        dst->full_height, flags);
+                flags = 0; /* remove possible MXR_NO_OFFSET flag */
+                /* fall through */
+        case MXR_GEOMETRY_CROP:
+                /* remember center of the area */
+                x_center = src->x_offset + src->width / 2;
+                y_center = src->y_offset + src->height / 2;
+
+                /* ensure scaling is between 0.25x .. 16x */
+                src->width = clamp(src->width, round_up(dst->width / 16, 4),
+                        dst->width * 4);
+                src->height = clamp(src->height, round_up(dst->height / 16, 4),
+                        dst->height * 4);
+
+                /* hardware limits */
+                src->width = clamp(src->width, 32U, 2047U);
+                src->height = clamp(src->height, 4U, 2047U);
+
+                /* setup offsets */
+                src->x_offset = do_center(x_center, src->width,
+                        src->full_width, flags);
+                src->y_offset = do_center(y_center, src->height,
+                        src->full_height, flags);
+
+                /* setting scaling ratio */
+                geo->x_ratio = (src->width << 16) / dst->width;
+                geo->y_ratio = (src->height << 16) / dst->height;
+                /* fall through */
+
+        case MXR_GEOMETRY_SOURCE:
+                src->full_width = clamp(src->full_width,
+                        ALIGN(src->width + src->x_offset, 8), 8192U);
+                src->full_height = clamp(src->full_height,
+                        src->height + src->y_offset, 8192U);
+        };
 }
 
 /* PUBLIC API */
diff --git a/drivers/media/video/s5p-tv/sdo_drv.c b/drivers/media/video/s5p-tv/sdo_drv.c
index 8cec67ef48c9..059e7749ce95 100644
--- a/drivers/media/video/s5p-tv/sdo_drv.c
+++ b/drivers/media/video/s5p-tv/sdo_drv.c
@@ -457,24 +457,4 @@ static struct platform_driver sdo_driver __refdata = {
         }
 };
 
-static int __init sdo_init(void)
-{
-        int ret;
-        static const char banner[] __initdata = KERN_INFO \
-                "Samsung Standard Definition Output (SDO) driver, "
-                "(c) 2010-2011 Samsung Electronics Co., Ltd.\n";
-        printk(banner);
-
-        ret = platform_driver_register(&sdo_driver);
-        if (ret)
-                printk(KERN_ERR "SDO platform driver register failed\n");
-
-        return ret;
-}
-module_init(sdo_init);
-
-static void __exit sdo_exit(void)
-{
-        platform_driver_unregister(&sdo_driver);
-}
-module_exit(sdo_exit);
+module_platform_driver(sdo_driver);
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index 0f9fb99adeb4..065d0f6be4a0 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -5691,6 +5691,27 @@ struct saa7134_board saa7134_boards[] = {
                         .amux = LINE1,
                 },
         },
+        [SAA7134_BOARD_SENSORAY811_911] = {
+                .name           = "Sensoray 811/911",
+                .audio_clock    = 0x00200000,
+                .tuner_type     = TUNER_ABSENT,
+                .radio_type     = UNSET,
+                .tuner_addr     = ADDR_UNSET,
+                .radio_addr     = ADDR_UNSET,
+                .inputs         = {{
+                        .name   = name_comp1,
+                        .vmux   = 0,
+                        .amux   = LINE1,
+                }, {
+                        .name   = name_comp3,
+                        .vmux   = 2,
+                        .amux   = LINE1,
+                }, {
+                        .name   = name_svideo,
+                        .vmux   = 8,
+                        .amux   = LINE1,
+                } },
+        },
 
 };
 
@@ -6914,6 +6935,18 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .subdevice    = 0xd136,
                 .driver_data  = SAA7134_BOARD_MAGICPRO_PROHDTV_PRO2,
         }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
+                .subvendor    = 0x6000,
+                .subdevice    = 0x0811,
+                .driver_data  = SAA7134_BOARD_SENSORAY811_911,
+        }, {
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
+                .subvendor    = 0x6000,
+                .subdevice    = 0x0911,
+                .driver_data  = SAA7134_BOARD_SENSORAY811_911,
+        }, {
                 /* --- boards without eeprom + subsystem ID --- */
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7134,
diff --git a/drivers/media/video/saa7134/saa7134-core.c b/drivers/media/video/saa7134/saa7134-core.c
index ca65cda3e101..5fbb4e49495c 100644
--- a/drivers/media/video/saa7134/saa7134-core.c
+++ b/drivers/media/video/saa7134/saa7134-core.c
@@ -1263,7 +1263,6 @@ static int saa7134_resume(struct pci_dev *pci_dev)
         saa7134_tvaudio_setmute(dev);
         saa7134_tvaudio_setvolume(dev, dev->ctl_volume);
         saa7134_tvaudio_init(dev);
-        saa7134_tvaudio_do_scan(dev);
         saa7134_enable_i2s(dev);
         saa7134_hw_enable2(dev);
 
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c
index 1e4ef1669887..089fa0fb5c94 100644
--- a/drivers/media/video/saa7134/saa7134-dvb.c
+++ b/drivers/media/video/saa7134/saa7134-dvb.c
@@ -183,9 +183,9 @@ static int mt352_avermedia_xc3028_init(struct dvb_frontend *fe)
         return 0;
 }
 
-static int mt352_pinnacle_tuner_set_params(struct dvb_frontend* fe,
-                                           struct dvb_frontend_parameters* params)
+static int mt352_pinnacle_tuner_set_params(struct dvb_frontend *fe)
 {
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
         u8 off[] = { 0x00, 0xf1};
         u8 on[]  = { 0x00, 0x71};
         struct i2c_msg msg = {.addr=0x43, .flags=0, .buf=off, .len = sizeof(off)};
@@ -196,7 +196,7 @@ static int mt352_pinnacle_tuner_set_params(struct dvb_frontend* fe,
         /* set frequency (mt2050) */
         f.tuner     = 0;
         f.type      = V4L2_TUNER_DIGITAL_TV;
-        f.frequency = params->frequency / 1000 * 16 / 1000;
+        f.frequency = c->frequency / 1000 * 16 / 1000;
         if (fe->ops.i2c_gate_ctrl)
                 fe->ops.i2c_gate_ctrl(fe, 1);
         i2c_transfer(&dev->i2c_adap, &msg, 1);
@@ -287,8 +287,9 @@ static int philips_tda1004x_request_firmware(struct dvb_frontend *fe,
  * these tuners are tu1216, td1316(a)
  */
 
-static int philips_tda6651_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int philips_tda6651_pll_set(struct dvb_frontend *fe)
 {
+        struct dtv_frontend_properties *c = &fe->dtv_property_cache;
         struct saa7134_dev *dev = fe->dvb->priv;
         struct tda1004x_state *state = fe->demodulator_priv;
         u8 addr = state->config->tuner_address;
@@ -299,7 +300,7 @@ static int philips_tda6651_pll_set(struct dvb_frontend *fe, struct dvb_frontend_
         u8 band, cp, filter;
 
         /* determine charge pump */
-        tuner_frequency = params->frequency + 36166000;
+        tuner_frequency = c->frequency + 36166000;
         if (tuner_frequency < 87000000)
                 return -EINVAL;
         else if (tuner_frequency < 130000000)
@@ -324,28 +325,28 @@ static int philips_tda6651_pll_set(struct dvb_frontend *fe, struct dvb_frontend_
                 return -EINVAL;
 
         /* determine band */
-        if (params->frequency < 49000000)
+        if (c->frequency < 49000000)
                 return -EINVAL;
-        else if (params->frequency < 161000000)
+        else if (c->frequency < 161000000)
                 band = 1;
-        else if (params->frequency < 444000000)
+        else if (c->frequency < 444000000)
                 band = 2;
-        else if (params->frequency < 861000000)
+        else if (c->frequency < 861000000)
                 band = 4;
         else
                 return -EINVAL;
 
         /* setup PLL filter */
-        switch (params->u.ofdm.bandwidth) {
-        case BANDWIDTH_6_MHZ:
+        switch (c->bandwidth_hz) {
+        case 6000000:
                 filter = 0;
                 break;
 
-        case BANDWIDTH_7_MHZ:
+        case 7000000:
                 filter = 0;
                 break;
 
-        case BANDWIDTH_8_MHZ:
+        case 8000000:
                 filter = 1;
                 break;
 
@@ -356,7 +357,7 @@ static int philips_tda6651_pll_set(struct dvb_frontend *fe, struct dvb_frontend_
         /* calculate divisor
          * ((36166000+((1000000/6)/2)) + Finput)/(1000000/6)
          */
-        tuner_frequency = (((params->frequency / 1000) * 6) + 217496) / 1000;
+        tuner_frequency = (((c->frequency / 1000) * 6) + 217496) / 1000;
 
         /* setup tuner buffer */
         tuner_buf[0] = (tuner_frequency >> 8) & 0x7f;
@@ -436,9 +437,9 @@ static int philips_td1316_tuner_init(struct dvb_frontend *fe)
         return 0;
 }
 
-static int philips_td1316_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
+static int philips_td1316_tuner_set_params(struct dvb_frontend *fe)
 {
-        return philips_tda6651_pll_set(fe, params);
+        return philips_tda6651_pll_set(fe);
 }
 
 static int philips_td1316_tuner_sleep(struct dvb_frontend *fe)
diff --git a/drivers/media/video/saa7134/saa7134-input.c b/drivers/media/video/saa7134/saa7134-input.c
index d4ee24bf6928..22ecd7297d2d 100644
--- a/drivers/media/video/saa7134/saa7134-input.c
+++ b/drivers/media/video/saa7134/saa7134-input.c
@@ -235,22 +235,25 @@ static int get_key_purpletv(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 
 static int get_key_hvr1110(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
 {
-        unsigned char buf[5], cod4, code3, code4;
+        unsigned char buf[5];
 
         /* poll IR chip */
         if (5 != i2c_master_recv(ir->c, buf, 5))
                 return -EIO;
 
-        cod4    = buf[4];
-        code4   = (cod4 >> 2);
-        code3   = buf[3];
-        if (code3 == 0)
-                /* no key pressed */
+        /* Check if some key were pressed */
+        if (!(buf[0] & 0x80))
                 return 0;
 
-        /* return key */
-        *ir_key = code4;
-        *ir_raw = code4;
+        /*
+         * buf[3] & 0x80 is always high.
+         * buf[3] & 0x40 is a parity bit. A repeat event is marked
+         * by preserving it into two separate readings
+         * buf[4] bits 0 and 1, and buf[1] and buf[2] are always
+         * zero.
+         */
+        *ir_key = 0x1fff & ((buf[3] << 8) | (buf[4] >> 2));
+        *ir_raw = *ir_key;
         return 1;
 }
 
@@ -752,7 +755,7 @@ int saa7134_input_init1(struct saa7134_dev *dev)
                 polling      = 50; /* ms */
                 break;
         case SAA7134_BOARD_VIDEOMATE_M1F:
-                ir_codes     = RC_MAP_VIDEOMATE_M1F;
+                ir_codes     = RC_MAP_VIDEOMATE_K100;
                 mask_keycode = 0x0ff00;
                 mask_keyup   = 0x040000;
                 break;
diff --git a/drivers/media/video/saa7134/saa7134-tvaudio.c b/drivers/media/video/saa7134/saa7134-tvaudio.c
index 57e646bb48b3..b7a99bee2f98 100644
--- a/drivers/media/video/saa7134/saa7134-tvaudio.c
+++ b/drivers/media/video/saa7134/saa7134-tvaudio.c
@@ -332,6 +332,13 @@ static int tvaudio_checkcarrier(struct saa7134_dev *dev, struct mainscan *scan)
 {
         __s32 left,right,value;
 
+        if (!(dev->tvnorm->id & scan->std)) {
+                value = 0;
+                dprintk("skipping %d.%03d MHz [%4s]\n",
+                        scan->carr / 1000, scan->carr % 1000, scan->name);
+                return 0;
+        }
+
         if (audio_debug > 1) {
                 int i;
                 dprintk("debug %d:",scan->carr);
@@ -348,30 +355,25 @@ static int tvaudio_checkcarrier(struct saa7134_dev *dev, struct mainscan *scan)
                 }
                 printk("\n");
         }
-        if (dev->tvnorm->id & scan->std) {
-                tvaudio_setcarrier(dev,scan->carr-90,scan->carr-90);
-                saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
-                if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
-                        return -1;
-                left = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
-
-                tvaudio_setcarrier(dev,scan->carr+90,scan->carr+90);
-                saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
-                if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
-                        return -1;
-                right = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
-
-                left >>= 16;
-                right >>= 16;
-                value = left > right ? left - right : right - left;
-                dprintk("scanning %d.%03d MHz [%4s] =>  dc is %5d [%d/%d]\n",
-                        scan->carr / 1000, scan->carr % 1000,
-                        scan->name, value, left, right);
-        } else {
-                value = 0;
-                dprintk("skipping %d.%03d MHz [%4s]\n",
-                        scan->carr / 1000, scan->carr % 1000, scan->name);
-        }
+
+        tvaudio_setcarrier(dev,scan->carr-90,scan->carr-90);
+        saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
+        if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
+                return -1;
+        left = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
+
+        tvaudio_setcarrier(dev,scan->carr+90,scan->carr+90);
+        saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
+        if (tvaudio_sleep(dev,SCAN_SAMPLE_DELAY))
+                return -1;
+        right = saa_readl(SAA7134_LEVEL_READOUT1 >> 2);
+
+        left >>= 16;
+        right >>= 16;
+        value = left > right ? left - right : right - left;
+        dprintk("scanning %d.%03d MHz [%4s] =>  dc is %5d [%d/%d]\n",
+                scan->carr / 1000, scan->carr % 1000,
+                scan->name, value, left, right);
         return value;
 }
 
@@ -546,6 +548,7 @@ static int tvaudio_thread(void *data)
                                 dev->tvnorm->name, carrier/1000, carrier%1000,
                                 max1, max2);
                         dev->last_carrier = carrier;
+                        dev->automute = 0;
 
                 } else if (0 != dev->last_carrier) {
                         /* no carrier -- try last detected one as fallback */
@@ -553,6 +556,7 @@ static int tvaudio_thread(void *data)
                         dprintk("audio carrier scan failed, "
                                 "using %d.%03d MHz [last detected]\n",
                                 carrier/1000, carrier%1000);
+                        dev->automute = 1;
 
                 } else {
                         /* no carrier + no fallback -- use default */
@@ -560,9 +564,9 @@ static int tvaudio_thread(void *data)
                         dprintk("audio carrier scan failed, "
                                 "using %d.%03d MHz [default]\n",
                                 carrier/1000, carrier%1000);
+                        dev->automute = 1;
                 }
                 tvaudio_setcarrier(dev,carrier,carrier);
-                dev->automute = 0;
                 saa_andorb(SAA7134_STEREO_DAC_OUTPUT_SELECT, 0x30, 0x00);
                 saa7134_tvaudio_setmute(dev);
                 /* find the exact tv audio norm */
@@ -601,7 +605,7 @@ static int tvaudio_thread(void *data)
                         if (kthread_should_stop())
                                 break;
                         if (UNSET == dev->thread.mode) {
-                                rx = tvaudio_getstereo(dev,&tvaudio[i]);
+                                rx = tvaudio_getstereo(dev, &tvaudio[audio]);
                                 mode = saa7134_tvaudio_rx2mode(rx);
                         } else {
                                 mode = dev->thread.mode;
@@ -1020,6 +1024,7 @@ int saa7134_tvaudio_init2(struct saa7134_dev *dev)
         }
 
         dev->thread.thread = NULL;
+        dev->thread.scan1 = dev->thread.scan2 = 0;
         if (my_thread) {
                 saa7134_tvaudio_init(dev);
                 /* start tvaudio thread */
@@ -1029,13 +1034,19 @@ int saa7134_tvaudio_init2(struct saa7134_dev *dev)
                                dev->name);
                         /* XXX: missing error handling here */
                 }
-                saa7134_tvaudio_do_scan(dev);
         }
 
         saa7134_enable_i2s(dev);
         return 0;
 }
 
+int saa7134_tvaudio_close(struct saa7134_dev *dev)
+{
+        dev->automute = 1;
+        /* anything else to undo? */
+        return 0;
+}
+
 int saa7134_tvaudio_fini(struct saa7134_dev *dev)
 {
         /* shutdown tvaudio thread */
diff --git a/drivers/media/video/saa7134/saa7134-video.c b/drivers/media/video/saa7134/saa7134-video.c
index 9cf7914f6f90..417034eb6ad2 100644
--- a/drivers/media/video/saa7134/saa7134-video.c
+++ b/drivers/media/video/saa7134/saa7134-video.c
@@ -1462,6 +1462,8 @@ static int video_release(struct file *file)
         struct saa6588_command cmd;
         unsigned long flags;
 
+        saa7134_tvaudio_close(dev);
+
         /* turn off overlay */
         if (res_check(fh, RESOURCE_OVERLAY)) {
                 spin_lock_irqsave(&dev->slock,flags);
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index 9b550687213a..42fba4f93c72 100644
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -330,6 +330,7 @@ struct saa7134_card_ir {
 #define SAA7134_BOARD_MAGICPRO_PROHDTV_PRO2 185
 #define SAA7134_BOARD_BEHOLD_501            186
 #define SAA7134_BOARD_BEHOLD_503FM          187
+#define SAA7134_BOARD_SENSORAY811_911       188
 
 #define SAA7134_MAXBOARDS 32
 #define SAA7134_INPUT_MAX 8
@@ -817,6 +818,7 @@ void saa7134_tvaudio_init(struct saa7134_dev *dev);
 int saa7134_tvaudio_init2(struct saa7134_dev *dev);
 int saa7134_tvaudio_fini(struct saa7134_dev *dev);
 int saa7134_tvaudio_do_scan(struct saa7134_dev *dev);
+int saa7134_tvaudio_close(struct saa7134_dev *dev);
 
 int saa_dsp_writel(struct saa7134_dev *dev, int reg, u32 value);
 
diff --git a/drivers/media/video/saa7164/saa7164-bus.c b/drivers/media/video/saa7164/saa7164-bus.c
index 466e1b02f91f..a7f58a998752 100644
--- a/drivers/media/video/saa7164/saa7164-bus.c
+++ b/drivers/media/video/saa7164/saa7164-bus.c
@@ -149,7 +149,7 @@ int saa7164_bus_set(struct saa7164_dev *dev, struct tmComResInfo* msg,
         saa7164_bus_verify(dev);
 
         msg->size = cpu_to_le16(msg->size);
-        msg->command = cpu_to_le16(msg->command);
+        msg->command = cpu_to_le32(msg->command);
         msg->controlselector = cpu_to_le16(msg->controlselector);
 
         if (msg->size > dev->bus.m_wMaxReqSize) {
@@ -464,7 +464,7 @@ int saa7164_bus_get(struct saa7164_dev *dev, struct tmComResInfo* msg,
 
 peekout:
         msg->size = le16_to_cpu(msg->size);
-        msg->command = le16_to_cpu(msg->command);
+        msg->command = le32_to_cpu(msg->command);
         msg->controlselector = le16_to_cpu(msg->controlselector);
         ret = SAA_OK;
 out:
diff --git a/drivers/media/video/sh_mobile_ceu_camera.c b/drivers/media/video/sh_mobile_ceu_camera.c
index c51decfcae19..f854d85a387c 100644
--- a/drivers/media/video/sh_mobile_ceu_camera.c
+++ b/drivers/media/video/sh_mobile_ceu_camera.c
@@ -786,8 +786,7 @@ static struct v4l2_subdev *find_bus_subdev(struct sh_mobile_ceu_dev *pcdev,
                 V4L2_MBUS_DATA_ACTIVE_HIGH)
 
 /* Capture is not running, no interrupts, no locking needed */
-static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
-                                       __u32 pixfmt)
+static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd)
 {
         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
         struct sh_mobile_ceu_dev *pcdev = ici->priv;
@@ -925,11 +924,6 @@ static int sh_mobile_ceu_set_bus_param(struct soc_camera_device *icd,
         ceu_write(pcdev, CDOCR, value);
         ceu_write(pcdev, CFWCR, 0); /* keep "datafetch firewall" disabled */
 
-        dev_dbg(icd->parent, "S_FMT successful for %c%c%c%c %ux%u\n",
-                pixfmt & 0xff, (pixfmt >> 8) & 0xff,
-                (pixfmt >> 16) & 0xff, (pixfmt >> 24) & 0xff,
-                icd->user_width, icd->user_height);
-
         capture_restore(pcdev, capsr);
 
         /* not in bundle mode: skip CBDSR, CDAYR2, CDACR2, CDBYR2, CDBCR2 */
@@ -1966,8 +1960,7 @@ static int sh_mobile_ceu_set_livecrop(struct soc_camera_device *icd,
                 if (!ret) {
                         icd->user_width         = out_width & ~3;
                         icd->user_height        = out_height & ~3;
-                        ret = sh_mobile_ceu_set_bus_param(icd,
-                                        icd->current_fmt->host_fmt->fourcc);
+                        ret = sh_mobile_ceu_set_bus_param(icd);
                 }
         }
 
diff --git a/drivers/media/video/sh_mobile_csi2.c b/drivers/media/video/sh_mobile_csi2.c
index 8a652b53ff7e..05286500b4d4 100644
--- a/drivers/media/video/sh_mobile_csi2.c
+++ b/drivers/media/video/sh_mobile_csi2.c
@@ -390,18 +390,7 @@ static struct platform_driver __refdata sh_csi2_pdrv = {
         },
 };
 
-static int __init sh_csi2_init(void)
-{
-        return platform_driver_register(&sh_csi2_pdrv);
-}
-
-static void __exit sh_csi2_exit(void)
-{
-        platform_driver_unregister(&sh_csi2_pdrv);
-}
-
-module_init(sh_csi2_init);
-module_exit(sh_csi2_exit);
+module_platform_driver(sh_csi2_pdrv);
 
 MODULE_DESCRIPTION("SH-Mobile MIPI CSI-2 driver");
 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index 62e4312515cb..b82710745ba8 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -487,7 +487,7 @@ static int soc_camera_set_fmt(struct soc_camera_device *icd,
                 icd->user_width, icd->user_height);
 
         /* set physical bus parameters */
-        return ici->ops->set_bus_param(icd, pix->pixelformat);
+        return ici->ops->set_bus_param(icd);
 }
 
 static int soc_camera_open(struct file *file)
@@ -600,9 +600,9 @@ static int soc_camera_close(struct file *file)
                 pm_runtime_suspend(&icd->vdev->dev);
                 pm_runtime_disable(&icd->vdev->dev);
 
-                ici->ops->remove(icd);
                 if (ici->ops->init_videobuf2)
                         vb2_queue_release(&icd->vb2_vidq);
+                ici->ops->remove(icd);
 
                 soc_camera_power_off(icd, icl);
         }
diff --git a/drivers/media/video/soc_camera_platform.c b/drivers/media/video/soc_camera_platform.c
index 4402a8a74f7a..f59ccade07c8 100644
--- a/drivers/media/video/soc_camera_platform.c
+++ b/drivers/media/video/soc_camera_platform.c
@@ -189,18 +189,7 @@ static struct platform_driver soc_camera_platform_driver = {
         .remove         = soc_camera_platform_remove,
 };
 
-static int __init soc_camera_platform_module_init(void)
-{
-        return platform_driver_register(&soc_camera_platform_driver);
-}
-
-static void __exit soc_camera_platform_module_exit(void)
-{
-        platform_driver_unregister(&soc_camera_platform_driver);
-}
-
-module_init(soc_camera_platform_module_init);
-module_exit(soc_camera_platform_module_exit);
+module_platform_driver(soc_camera_platform_driver);
 
 MODULE_DESCRIPTION("SoC Camera Platform driver");
 MODULE_AUTHOR("Magnus Damm");
diff --git a/drivers/media/video/stk-webcam.c b/drivers/media/video/stk-webcam.c
index 3c61aec517ac..d427f8436c70 100644
--- a/drivers/media/video/stk-webcam.c
+++ b/drivers/media/video/stk-webcam.c
@@ -377,8 +377,8 @@ static int stk_prepare_iso(struct stk_camera *dev)
         if (dev->isobufs)
                 STK_ERROR("isobufs already allocated. Bad\n");
         else
-                dev->isobufs = kzalloc(MAX_ISO_BUFS * sizeof(*dev->isobufs),
-                                        GFP_KERNEL);
+                dev->isobufs = kcalloc(MAX_ISO_BUFS, sizeof(*dev->isobufs),
+                                       GFP_KERNEL);
         if (dev->isobufs == NULL) {
                 STK_ERROR("Unable to allocate iso buffers\n");
                 return -ENOMEM;
diff --git a/drivers/media/video/timblogiw.c b/drivers/media/video/timblogiw.c
index a0895bf07487..0a2d75f04066 100644
--- a/drivers/media/video/timblogiw.c
+++ b/drivers/media/video/timblogiw.c
@@ -872,20 +872,7 @@ static struct platform_driver timblogiw_platform_driver = {
         .remove         = __devexit_p(timblogiw_remove),
 };
 
-/* Module functions */
-
-static int __init timblogiw_init(void)
-{
-        return platform_driver_register(&timblogiw_platform_driver);
-}
-
-static void __exit timblogiw_exit(void)
-{
-        platform_driver_unregister(&timblogiw_platform_driver);
-}
-
-module_init(timblogiw_init);
-module_exit(timblogiw_exit);
+module_platform_driver(timblogiw_platform_driver);
 
 MODULE_DESCRIPTION(TIMBLOGIWIN_NAME);
 MODULE_AUTHOR("Pelagicore AB <info@pelagicore.com>");
diff --git a/drivers/media/video/tlg2300/pd-common.h b/drivers/media/video/tlg2300/pd-common.h
index 56564e6aaac2..5dd73b7857d1 100644
--- a/drivers/media/video/tlg2300/pd-common.h
+++ b/drivers/media/video/tlg2300/pd-common.h
@@ -140,7 +140,7 @@ struct pd_dvb_adapter {
         u8                      reserved[3];
 
         /* data for power resume*/
-        struct dvb_frontend_parameters fe_param;
+        struct dtv_frontend_properties fe_param;
 
         /* for channel scanning */
         int             prev_freq;
diff --git a/drivers/media/video/tlg2300/pd-dvb.c b/drivers/media/video/tlg2300/pd-dvb.c
index d0da11ae19df..30fcb117e898 100644
--- a/drivers/media/video/tlg2300/pd-dvb.c
+++ b/drivers/media/video/tlg2300/pd-dvb.c
@@ -12,9 +12,9 @@
 static void dvb_urb_cleanup(struct pd_dvb_adapter *pd_dvb);
 
 static int dvb_bandwidth[][2] = {
-        { TLG_BW_8, BANDWIDTH_8_MHZ },
-        { TLG_BW_7, BANDWIDTH_7_MHZ },
-        { TLG_BW_6, BANDWIDTH_6_MHZ }
+        { TLG_BW_8, 8000000 },
+        { TLG_BW_7, 7000000 },
+        { TLG_BW_6, 6000000 }
 };
 static int dvb_bandwidth_length = ARRAY_SIZE(dvb_bandwidth);
 
@@ -146,9 +146,9 @@ static int fw_delay_overflow(struct pd_dvb_adapter *adapter)
         return msec > 800 ? true : false;
 }
 
-static int poseidon_set_fe(struct dvb_frontend *fe,
-                        struct dvb_frontend_parameters *fep)
+static int poseidon_set_fe(struct dvb_frontend *fe)
 {
+        struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
         s32 ret = 0, cmd_status = 0;
         s32 i, bandwidth = -1;
         struct poseidon *pd = fe->demodulator_priv;
@@ -159,7 +159,7 @@ static int poseidon_set_fe(struct dvb_frontend *fe,
 
         mutex_lock(&pd->lock);
         for (i = 0; i < dvb_bandwidth_length; i++)
-                if (fep->u.ofdm.bandwidth == dvb_bandwidth[i][1])
+                if (fep->bandwidth_hz == dvb_bandwidth[i][1])
                         bandwidth = dvb_bandwidth[i][0];
 
         if (check_scan_ok(fep->frequency, bandwidth, pd_dvb)) {
@@ -210,7 +210,7 @@ static int pm_dvb_resume(struct poseidon *pd)
 
         poseidon_check_mode_dvbt(pd);
         msleep(300);
-        poseidon_set_fe(&pd_dvb->dvb_fe, &pd_dvb->fe_param);
+        poseidon_set_fe(&pd_dvb->dvb_fe);
 
         dvb_start_streaming(pd_dvb);
         return 0;
@@ -227,13 +227,13 @@ static s32 poseidon_fe_init(struct dvb_frontend *fe)
         pd->pm_resume  = pm_dvb_resume;
 #endif
         memset(&pd_dvb->fe_param, 0,
-                        sizeof(struct dvb_frontend_parameters));
+                        sizeof(struct dtv_frontend_properties));
         return 0;
 }
 
-static int poseidon_get_fe(struct dvb_frontend *fe,
-                        struct dvb_frontend_parameters *fep)
+static int poseidon_get_fe(struct dvb_frontend *fe)
 {
+        struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
         struct poseidon *pd = fe->demodulator_priv;
         struct pd_dvb_adapter *pd_dvb = &pd->dvb_data;
 
@@ -332,9 +332,9 @@ static int poseidon_read_unc_blocks(struct dvb_frontend *fe, u32 *unc)
 }
 
 static struct dvb_frontend_ops poseidon_frontend_ops = {
+        .delsys = { SYS_DVBT },
         .info = {
                 .name           = "Poseidon DVB-T",
-                .type           = FE_OFDM,
                 .frequency_min  = 174000000,
                 .frequency_max  = 862000000,
                 .frequency_stepsize       = 62500,/* FIXME */
diff --git a/drivers/media/video/tm6000/Kconfig b/drivers/media/video/tm6000/Kconfig
index 114eec8a630a..a43b77abd931 100644
--- a/drivers/media/video/tm6000/Kconfig
+++ b/drivers/media/video/tm6000/Kconfig
@@ -1,6 +1,6 @@
 config VIDEO_TM6000
         tristate "TV Master TM5600/6000/6010 driver"
-        depends on VIDEO_DEV && I2C && INPUT && RC_CORE && USB && EXPERIMENTAL
+        depends on VIDEO_DEV && I2C && INPUT && RC_CORE && USB
         select VIDEO_TUNER
         select MEDIA_TUNER_XC2028
         select MEDIA_TUNER_XC5000
@@ -16,7 +16,7 @@ config VIDEO_TM6000
 
 config VIDEO_TM6000_ALSA
         tristate "TV Master TM5600/6000/6010 audio support"
-        depends on VIDEO_TM6000 && SND && EXPERIMENTAL
+        depends on VIDEO_TM6000 && SND
         select SND_PCM
         ---help---
           This is a video4linux driver for direct (DMA) audio for
@@ -27,7 +27,7 @@ config VIDEO_TM6000_ALSA
 
 config VIDEO_TM6000_DVB
         tristate "DVB Support for tm6000 based TV cards"
-        depends on VIDEO_TM6000 && DVB_CORE && USB && EXPERIMENTAL
+        depends on VIDEO_TM6000 && DVB_CORE && USB
         select DVB_ZL10353
         ---help---
           This adds support for DVB cards based on the tm5600/tm6000 chip.
diff --git a/drivers/media/video/tm6000/tm6000-alsa.c b/drivers/media/video/tm6000/tm6000-alsa.c
index bb2047c10358..bd07ec707956 100644
--- a/drivers/media/video/tm6000/tm6000-alsa.c
+++ b/drivers/media/video/tm6000/tm6000-alsa.c
@@ -146,20 +146,21 @@ static int dsp_buffer_alloc(struct snd_pcm_substream *substream, int size)
 #define DEFAULT_FIFO_SIZE       4096
 
 static struct snd_pcm_hardware snd_tm6000_digital_hw = {
-        .info = SNDRV_PCM_INFO_MMAP |
+        .info = SNDRV_PCM_INFO_BATCH |
+                SNDRV_PCM_INFO_MMAP |
                 SNDRV_PCM_INFO_INTERLEAVED |
                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
                 SNDRV_PCM_INFO_MMAP_VALID,
         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 
-        .rates = SNDRV_PCM_RATE_CONTINUOUS,
+        .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_KNOT,
         .rate_min = 48000,
         .rate_max = 48000,
         .channels_min = 2,
         .channels_max = 2,
         .period_bytes_min = 64,
         .period_bytes_max = 12544,
-        .periods_min = 1,
+        .periods_min = 2,
         .periods_max = 98,
         .buffer_bytes_max = 62720 * 8,
 };
@@ -181,6 +182,7 @@ static int snd_tm6000_pcm_open(struct snd_pcm_substream *substream)
         chip->substream = substream;
 
         runtime->hw = snd_tm6000_digital_hw;
+        snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 
         return 0;
 _error:
@@ -347,9 +349,13 @@ static int snd_tm6000_card_trigger(struct snd_pcm_substream *substream, int cmd)
         int err = 0;
 
         switch (cmd) {
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
+        case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
         case SNDRV_PCM_TRIGGER_START:
                 atomic_set(&core->stream_started, 1);
                 break;
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
+        case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
         case SNDRV_PCM_TRIGGER_STOP:
                 atomic_set(&core->stream_started, 0);
                 break;
@@ -371,6 +377,14 @@ static snd_pcm_uframes_t snd_tm6000_pointer(struct snd_pcm_substream *substream)
         return chip->buf_pos;
 }
 
+static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
+                                             unsigned long offset)
+{
+        void *pageptr = subs->runtime->dma_area + offset;
+
+        return vmalloc_to_page(pageptr);
+}
+
 /*
  * operators
  */
@@ -383,6 +397,7 @@ static struct snd_pcm_ops snd_tm6000_pcm_ops = {
         .prepare = snd_tm6000_prepare,
         .trigger = snd_tm6000_card_trigger,
         .pointer = snd_tm6000_pointer,
+        .page = snd_pcm_get_vmalloc_page,
 };
 
 /*
diff --git a/drivers/media/video/tm6000/tm6000-cards.c b/drivers/media/video/tm6000/tm6000-cards.c
index ff939bc0e0b9..034659b13174 100644
--- a/drivers/media/video/tm6000/tm6000-cards.c
+++ b/drivers/media/video/tm6000/tm6000-cards.c
@@ -351,6 +351,7 @@ static struct tm6000_board tm6000_boards[] = {
                 .tuner_addr   = 0xc2 >> 1,
                 .demod_addr   = 0x1e >> 1,
                 .type         = TM6010,
+                .ir_codes = RC_MAP_HAUPPAUGE,
                 .caps = {
                         .has_tuner    = 1,
                         .has_dvb      = 1,
@@ -639,6 +640,7 @@ static struct usb_device_id tm6000_id_table[] = {
         { USB_DEVICE(0x6000, 0xdec3), .driver_info = TM6010_BOARD_BEHOLD_VOYAGER_LITE },
         { }
 };
+MODULE_DEVICE_TABLE(usb, tm6000_id_table);
 
 /* Control power led for show some activity */
 void tm6000_flash_led(struct tm6000_core *dev, u8 state)
@@ -941,6 +943,7 @@ static void tm6000_config_tuner(struct tm6000_core *dev)
                 case TM6010_BOARD_HAUPPAUGE_900H:
                 case TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE:
                 case TM6010_BOARD_TWINHAN_TU501:
+                        ctl.max_len = 80;
                         ctl.fname = "xc3028L-v36.fw";
                         break;
                 default:
@@ -1002,6 +1005,7 @@ static int fill_board_specific_data(struct tm6000_core *dev)
         /* setup per-model quirks */
         switch (dev->model) {
         case TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE:
+        case TM6010_BOARD_HAUPPAUGE_900H:
                 dev->quirks |= TM6000_QUIRK_NO_USB_DELAY;
                 break;
 
@@ -1050,6 +1054,33 @@ static void use_alternative_detection_method(struct tm6000_core *dev)
                tm6000_boards[model].name, model);
 }
 
+#if defined(CONFIG_MODULES) && defined(MODULE)
+static void request_module_async(struct work_struct *work)
+{
+        struct tm6000_core *dev = container_of(work, struct tm6000_core,
+                                               request_module_wk);
+
+        request_module("tm6000-alsa");
+
+        if (dev->caps.has_dvb)
+                request_module("tm6000-dvb");
+}
+
+static void request_modules(struct tm6000_core *dev)
+{
+        INIT_WORK(&dev->request_module_wk, request_module_async);
+        schedule_work(&dev->request_module_wk);
+}
+
+static void flush_request_modules(struct tm6000_core *dev)
+{
+        flush_work_sync(&dev->request_module_wk);
+}
+#else
+#define request_modules(dev)
+#define flush_request_modules(dev)
+#endif /* CONFIG_MODULES */
+
 static int tm6000_init_dev(struct tm6000_core *dev)
 {
         struct v4l2_frequency f;
@@ -1112,6 +1143,8 @@ static int tm6000_init_dev(struct tm6000_core *dev)
 
         tm6000_ir_init(dev);
 
+        request_modules(dev);
+
         mutex_unlock(&dev->lock);
         return 0;
 
@@ -1324,6 +1357,8 @@ static void tm6000_usb_disconnect(struct usb_interface *interface)
 
         printk(KERN_INFO "tm6000: disconnecting %s\n", dev->name);
 
+        flush_request_modules(dev);
+
         tm6000_ir_fini(dev);
 
         if (dev->gpio.power_led) {
diff --git a/drivers/media/video/tm6000/tm6000-core.c b/drivers/media/video/tm6000/tm6000-core.c
index 9783616a0da2..22cc0116deb6 100644
--- a/drivers/media/video/tm6000/tm6000-core.c
+++ b/drivers/media/video/tm6000/tm6000-core.c
@@ -38,6 +38,7 @@ int tm6000_read_write_usb(struct tm6000_core *dev, u8 req_type, u8 req,
         int          ret, i;
         unsigned int pipe;
         u8           *data = NULL;
+        int delay = 5000;
 
         mutex_lock(&dev->usb_lock);
 
@@ -88,7 +89,20 @@ int tm6000_read_write_usb(struct tm6000_core *dev, u8 req_type, u8 req,
         }
 
         kfree(data);
-        msleep(5);
+
+        if (dev->quirks & TM6000_QUIRK_NO_USB_DELAY)
+                delay = 0;
+
+        if (req == REQ_16_SET_GET_I2C_WR1_RDN && !(req_type & USB_DIR_IN)) {
+                unsigned int tsleep;
+                /* Calculate delay time, 14000us for 64 bytes */
+                tsleep = (len * 200) + 200;
+                if (tsleep < delay)
+                        tsleep = delay;
+                usleep_range(tsleep, tsleep + 1000);
+        }
+        else if (delay)
+                usleep_range(delay, delay + 1000);
 
         mutex_unlock(&dev->usb_lock);
         return ret;
@@ -125,14 +139,14 @@ int tm6000_set_reg_mask(struct tm6000_core *dev, u8 req, u16 value,
         u8 new_index;
 
         rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR, req,
-                                        value, index, buf, 1);
+                                        value, 0, buf, 1);
 
         if (rc < 0)
                 return rc;
 
         new_index = (buf[0] & ~mask) | (index & mask);
 
-        if (new_index == index)
+        if (new_index == buf[0])
                 return 0;
 
         return tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR,
@@ -536,16 +550,16 @@ static struct reg_init tm6010_init_tab[] = {
 
         { TM6010_REQ05_R18_IMASK7, 0x00 },
 
-        { TM6010_REQ07_RD8_IR_LEADER1, 0xaa },
-        { TM6010_REQ07_RD8_IR_LEADER0, 0x30 },
-        { TM6010_REQ07_RD8_IR_PULSE_CNT1, 0x20 },
-        { TM6010_REQ07_RD8_IR_PULSE_CNT0, 0xd0 },
+        { TM6010_REQ07_RDC_IR_LEADER1, 0xaa },
+        { TM6010_REQ07_RDD_IR_LEADER0, 0x30 },
+        { TM6010_REQ07_RDE_IR_PULSE_CNT1, 0x20 },
+        { TM6010_REQ07_RDF_IR_PULSE_CNT0, 0xd0 },
         { REQ_04_EN_DISABLE_MCU_INT, 0x02, 0x00 },
-        { TM6010_REQ07_RD8_IR, 0x2f },
+        { TM6010_REQ07_RD8_IR, 0x0f },
 
         /* set remote wakeup key:any key wakeup */
         { TM6010_REQ07_RE5_REMOTE_WAKEUP,  0xfe },
-        { TM6010_REQ07_RD8_IR_WAKEUP_SEL,  0xff },
+        { TM6010_REQ07_RDA_IR_WAKEUP_SEL,  0xff },
 };
 
 int tm6000_init(struct tm6000_core *dev)
@@ -599,55 +613,6 @@ int tm6000_init(struct tm6000_core *dev)
         return rc;
 }
 
-int tm6000_reset(struct tm6000_core *dev)
-{
-        int pipe;
-        int err;
-
-        msleep(500);
-
-        err = usb_set_interface(dev->udev, dev->isoc_in.bInterfaceNumber, 0);
-        if (err < 0) {
-                tm6000_err("failed to select interface %d, alt. setting 0\n",
-                                dev->isoc_in.bInterfaceNumber);
-                return err;
-        }
-
-        err = usb_reset_configuration(dev->udev);
-        if (err < 0) {
-                tm6000_err("failed to reset configuration\n");
-                return err;
-        }
-
-        if ((dev->quirks & TM6000_QUIRK_NO_USB_DELAY) == 0)
-                msleep(5);
-
-        /*
-         * Not all devices have int_in defined
-         */
-        if (!dev->int_in.endp)
-                return 0;
-
-        err = usb_set_interface(dev->udev, dev->isoc_in.bInterfaceNumber, 2);
-        if (err < 0) {
-                tm6000_err("failed to select interface %d, alt. setting 2\n",
-                                dev->isoc_in.bInterfaceNumber);
-                return err;
-        }
-
-        msleep(5);
-
-        pipe = usb_rcvintpipe(dev->udev,
-                        dev->int_in.endp->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
-
-        err = usb_clear_halt(dev->udev, pipe);
-        if (err < 0) {
-                tm6000_err("usb_clear_halt failed: %d\n", err);
-                return err;
-        }
-
-        return 0;
-}
 
 int tm6000_set_audio_bitrate(struct tm6000_core *dev, int bitrate)
 {
@@ -696,11 +661,13 @@ int tm6000_set_audio_rinput(struct tm6000_core *dev)
         if (dev->dev_type == TM6010) {
                 /* Audio crossbar setting, default SIF1 */
                 u8 areg_f0;
+                u8 areg_07 = 0x10;
 
                 switch (dev->rinput.amux) {
                 case TM6000_AMUX_SIF1:
                 case TM6000_AMUX_SIF2:
                         areg_f0 = 0x03;
+                        areg_07 = 0x30;
                         break;
                 case TM6000_AMUX_ADC1:
                         areg_f0 = 0x00;
@@ -720,6 +687,9 @@ int tm6000_set_audio_rinput(struct tm6000_core *dev)
                 /* Set audio input crossbar */
                 tm6000_set_reg_mask(dev, TM6010_REQ08_RF0_DAUDIO_INPUT_CONFIG,
                                                         areg_f0, 0x0f);
+                /* Mux overflow workaround */
+                tm6000_set_reg_mask(dev, TM6010_REQ07_R07_OUTPUT_CONTROL,
+                        areg_07, 0xf0);
         } else {
                 u8 areg_eb;
                 /* Audio setting, default LINE1 */
diff --git a/drivers/media/video/tm6000/tm6000-dvb.c b/drivers/media/video/tm6000/tm6000-dvb.c
index 5e6c129a4beb..e1f3f66e1e63 100644
--- a/drivers/media/video/tm6000/tm6000-dvb.c
+++ b/drivers/media/video/tm6000/tm6000-dvb.c
@@ -89,9 +89,19 @@ static void tm6000_urb_received(struct urb *urb)
         int ret;
         struct tm6000_core *dev = urb->context;
 
-        if (urb->status != 0)
+        switch (urb->status) {
+        case 0:
+        case -ETIMEDOUT:
+                break;
+        case -ENOENT:
+        case -ECONNRESET:
+        case -ESHUTDOWN:
+                return;
+        default:
                 print_err_status(dev, 0, urb->status);
-        else if (urb->actual_length > 0)
+        }
+
+        if (urb->actual_length > 0)
                 dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer,
                                                    urb->actual_length);
 
@@ -151,7 +161,7 @@ static int tm6000_start_stream(struct tm6000_core *dev)
                 printk(KERN_ERR "tm6000: pipe resetted\n");
 
 /*      mutex_lock(&tm6000_driver.open_close_mutex); */
-        ret = usb_submit_urb(dvb->bulk_urb, GFP_KERNEL);
+        ret = usb_submit_urb(dvb->bulk_urb, GFP_ATOMIC);
 
 /*      mutex_unlock(&tm6000_driver.open_close_mutex); */
         if (ret) {
@@ -396,6 +406,11 @@ static int dvb_init(struct tm6000_core *dev)
         if (!dev->caps.has_dvb)
                 return 0;
 
+        if (dev->udev->speed == USB_SPEED_FULL) {
+                printk(KERN_INFO "This USB2.0 device cannot be run on a USB1.1 port. (it lacks a hardware PID filter)\n");
+                return 0;
+        }
+
         dvb = kzalloc(sizeof(struct tm6000_dvb), GFP_KERNEL);
         if (!dvb) {
                 printk(KERN_INFO "Cannot allocate memory\n");
diff --git a/drivers/media/video/tm6000/tm6000-i2c.c b/drivers/media/video/tm6000/tm6000-i2c.c
index 0290bbf00c3e..c7e23e3dd75e 100644
--- a/drivers/media/video/tm6000/tm6000-i2c.c
+++ b/drivers/media/video/tm6000/tm6000-i2c.c
@@ -46,11 +46,10 @@ static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
                                 __u8 reg, char *buf, int len)
 {
         int rc;
-        unsigned int tsleep;
         unsigned int i2c_packet_limit = 16;
 
         if (dev->dev_type == TM6010)
-                i2c_packet_limit = 64;
+                i2c_packet_limit = 80;
 
         if (!buf)
                 return -1;
@@ -71,10 +70,6 @@ static int tm6000_i2c_send_regs(struct tm6000_core *dev, unsigned char addr,
                 return rc;
         }
 
-        /* Calculate delay time, 14000us for 64 bytes */
-        tsleep = ((len * 200) + 200 + 1000) / 1000;
-        msleep(tsleep);
-
         /* release mutex */
         return rc;
 }
@@ -145,7 +140,6 @@ static int tm6000_i2c_recv_regs16(struct tm6000_core *dev, unsigned char addr,
                         return rc;
                 }
 
-                msleep(1400 / 1000);
                 rc = tm6000_read_write_usb(dev, USB_DIR_IN | USB_TYPE_VENDOR |
                         USB_RECIP_DEVICE, REQ_35_AFTEK_TUNER_READ,
                         reg, 0, buf, len);
diff --git a/drivers/media/video/tm6000/tm6000-input.c b/drivers/media/video/tm6000/tm6000-input.c
index 405d12729d05..7844607dd45a 100644
--- a/drivers/media/video/tm6000/tm6000-input.c
+++ b/drivers/media/video/tm6000/tm6000-input.c
@@ -31,22 +31,25 @@
 
 static unsigned int ir_debug;
 module_param(ir_debug, int, 0644);
-MODULE_PARM_DESC(ir_debug, "enable debug message [IR]");
+MODULE_PARM_DESC(ir_debug, "debug message level");
 
 static unsigned int enable_ir = 1;
 module_param(enable_ir, int, 0644);
 MODULE_PARM_DESC(enable_ir, "enable ir (default is enable)");
 
-/* number of 50ms for ON-OFF-ON power led */
-/* show IR activity */
-#define PWLED_OFF 2
+static unsigned int ir_clock_mhz = 12;
+module_param(ir_clock_mhz, int, 0644);
+MODULE_PARM_DESC(enable_ir, "ir clock, in MHz");
+
+#define URB_SUBMIT_DELAY        100     /* ms - Delay to submit an URB request on retrial and init */
+#define URB_INT_LED_DELAY       100     /* ms - Delay to turn led on again on int mode */
 
 #undef dprintk
 
-#define dprintk(fmt, arg...) \
-        if (ir_debug) { \
+#define dprintk(level, fmt, arg...) do {\
+        if (ir_debug >= level) \
                 printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
-        }
+        } while (0)
 
 struct tm6000_ir_poll_result {
         u16 rc_data;
@@ -62,20 +65,15 @@ struct tm6000_IR {
         int                     polling;
         struct delayed_work     work;
         u8                      wait:1;
-        u8                      key:1;
-        u8                      pwled:1;
-        u8                      pwledcnt;
+        u8                      pwled:2;
+        u8                      submit_urb:1;
         u16                     key_addr;
         struct urb              *int_urb;
-        u8                      *urb_data;
-
-        int (*get_key) (struct tm6000_IR *, struct tm6000_ir_poll_result *);
 
         /* IR device properties */
         u64                     rc_type;
 };
 
-
 void tm6000_ir_wait(struct tm6000_core *dev, u8 state)
 {
         struct tm6000_IR *ir = dev->ir;
@@ -83,62 +81,84 @@ void tm6000_ir_wait(struct tm6000_core *dev, u8 state)
         if (!dev->ir)
                 return;
 
+        dprintk(2, "%s: %i\n",__func__, ir->wait);
+
         if (state)
                 ir->wait = 1;
         else
                 ir->wait = 0;
 }
 
-
 static int tm6000_ir_config(struct tm6000_IR *ir)
 {
         struct tm6000_core *dev = ir->dev;
-        u8 buf[10];
-        int rc;
+        u32 pulse = 0, leader = 0;
+
+        dprintk(2, "%s\n",__func__);
+
+        /*
+         * The IR decoder supports RC-5 or NEC, with a configurable timing.
+         * The timing configuration there is not that accurate, as it uses
+         * approximate values. The NEC spec mentions a 562.5 unit period,
+         * and RC-5 uses a 888.8 period.
+         * Currently, driver assumes a clock provided by a 12 MHz XTAL, but
+         * a modprobe parameter can adjust it.
+         * Adjustments are required for other timings.
+         * It seems that the 900ms timing for NEC is used to detect a RC-5
+         * IR, in order to discard such decoding
+         */
 
         switch (ir->rc_type) {
         case RC_TYPE_NEC:
-                /* Setup IR decoder for NEC standard 12MHz system clock */
-                /* IR_LEADER_CNT = 0.9ms             */
-                tm6000_set_reg(dev, TM6010_REQ07_RD8_IR_LEADER1, 0xaa);
-                tm6000_set_reg(dev, TM6010_REQ07_RD8_IR_LEADER0, 0x30);
-                /* IR_PULSE_CNT = 0.7ms              */
-                tm6000_set_reg(dev, TM6010_REQ07_RD8_IR_PULSE_CNT1, 0x20);
-                tm6000_set_reg(dev, TM6010_REQ07_RD8_IR_PULSE_CNT0, 0xd0);
-                /* Remote WAKEUP = enable */
-                tm6000_set_reg(dev, TM6010_REQ07_RE5_REMOTE_WAKEUP, 0xfe);
-                /* IR_WKUP_SEL = Low byte in decoded IR data */
-                tm6000_set_reg(dev, TM6010_REQ07_RD8_IR_WAKEUP_SEL, 0xff);
-                /* IR_WKU_ADD code */
-                tm6000_set_reg(dev, TM6010_REQ07_RD8_IR_WAKEUP_ADD, 0xff);
-                tm6000_flash_led(dev, 0);
-                msleep(100);
-                tm6000_flash_led(dev, 1);
+                leader = 900;   /* ms */
+                pulse  = 700;   /* ms - the actual value would be 562 */
                 break;
         default:
-                /* hack */
-                buf[0] = 0xff;
-                buf[1] = 0xff;
-                buf[2] = 0xf2;
-                buf[3] = 0x2b;
-                buf[4] = 0x20;
-                buf[5] = 0x35;
-                buf[6] = 0x60;
-                buf[7] = 0x04;
-                buf[8] = 0xc0;
-                buf[9] = 0x08;
-
-                rc = tm6000_read_write_usb(dev, USB_DIR_OUT | USB_TYPE_VENDOR |
-                        USB_RECIP_DEVICE, REQ_00_SET_IR_VALUE, 0, 0, buf, 0x0a);
-                msleep(100);
-
-                if (rc < 0) {
-                        printk(KERN_INFO "IR configuration failed");
-                        return rc;
-                }
+        case RC_TYPE_RC5:
+                leader = 900;   /* ms - from the NEC decoding */
+                pulse  = 1780;  /* ms - The actual value would be 1776 */
                 break;
         }
 
+        pulse = ir_clock_mhz * pulse;
+        leader = ir_clock_mhz * leader;
+        if (ir->rc_type == RC_TYPE_NEC)
+                leader = leader | 0x8000;
+
+        dprintk(2, "%s: %s, %d MHz, leader = 0x%04x, pulse = 0x%06x \n",
+                __func__,
+                (ir->rc_type == RC_TYPE_NEC) ? "NEC" : "RC-5",
+                ir_clock_mhz, leader, pulse);
+
+        /* Remote WAKEUP = enable, normal mode, from IR decoder output */
+        tm6000_set_reg(dev, TM6010_REQ07_RE5_REMOTE_WAKEUP, 0xfe);
+
+        /* Enable IR reception on non-busrt mode */
+        tm6000_set_reg(dev, TM6010_REQ07_RD8_IR, 0x2f);
+
+        /* IR_WKUP_SEL = Low byte in decoded IR data */
+        tm6000_set_reg(dev, TM6010_REQ07_RDA_IR_WAKEUP_SEL, 0xff);
+        /* IR_WKU_ADD code */
+        tm6000_set_reg(dev, TM6010_REQ07_RDB_IR_WAKEUP_ADD, 0xff);
+
+        tm6000_set_reg(dev, TM6010_REQ07_RDC_IR_LEADER1, leader >> 8);
+        tm6000_set_reg(dev, TM6010_REQ07_RDD_IR_LEADER0, leader);
+
+        tm6000_set_reg(dev, TM6010_REQ07_RDE_IR_PULSE_CNT1, pulse >> 8);
+        tm6000_set_reg(dev, TM6010_REQ07_RDF_IR_PULSE_CNT0, pulse);
+
+        if (!ir->polling)
+                tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 0);
+        else
+                tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 1);
+        msleep(10);
+
+        /* Shows that IR is working via the LED */
+        tm6000_flash_led(dev, 0);
+        msleep(100);
+        tm6000_flash_led(dev, 1);
+        ir->pwled = 1;
+
         return 0;
 }
 
@@ -146,132 +166,124 @@ static void tm6000_ir_urb_received(struct urb *urb)
 {
         struct tm6000_core *dev = urb->context;
         struct tm6000_IR *ir = dev->ir;
+        struct tm6000_ir_poll_result poll_result;
+        char *buf;
         int rc;
 
-        if (urb->status != 0)
-                printk(KERN_INFO "not ready\n");
-        else if (urb->actual_length > 0) {
-                memcpy(ir->urb_data, urb->transfer_buffer, urb->actual_length);
+        dprintk(2, "%s\n",__func__);
+        if (urb->status < 0 || urb->actual_length <= 0) {
+                printk(KERN_INFO "tm6000: IR URB failure: status: %i, length %i\n",
+                       urb->status, urb->actual_length);
+                ir->submit_urb = 1;
+                schedule_delayed_work(&ir->work, msecs_to_jiffies(URB_SUBMIT_DELAY));
+                return;
+        }
+        buf = urb->transfer_buffer;
 
-                dprintk("data %02x %02x %02x %02x\n", ir->urb_data[0],
-                        ir->urb_data[1], ir->urb_data[2], ir->urb_data[3]);
+        if (ir_debug)
+                print_hex_dump(KERN_DEBUG, "tm6000: IR data: ",
+                               DUMP_PREFIX_OFFSET,16, 1,
+                               buf, urb->actual_length, false);
 
-                ir->key = 1;
-        }
+        poll_result.rc_data = buf[0];
+        if (urb->actual_length > 1)
+                poll_result.rc_data |= buf[1] << 8;
+
+        dprintk(1, "%s, scancode: 0x%04x\n",__func__, poll_result.rc_data);
+        rc_keydown(ir->rc, poll_result.rc_data, 0);
 
         rc = usb_submit_urb(urb, GFP_ATOMIC);
+        /*
+         * Flash the led. We can't do it here, as it is running on IRQ context.
+         * So, use the scheduler to do it, in a few ms.
+         */
+        ir->pwled = 2;
+        schedule_delayed_work(&ir->work, msecs_to_jiffies(10));
 }
 
-static int default_polling_getkey(struct tm6000_IR *ir,
-                                struct tm6000_ir_poll_result *poll_result)
+static void tm6000_ir_handle_key(struct work_struct *work)
 {
+        struct tm6000_IR *ir = container_of(work, struct tm6000_IR, work.work);
         struct tm6000_core *dev = ir->dev;
+        struct tm6000_ir_poll_result poll_result;
         int rc;
         u8 buf[2];
 
-        if (ir->wait && !&dev->int_in)
-                return 0;
-
-        if (&dev->int_in) {
-                switch (ir->rc_type) {
-                case RC_TYPE_RC5:
-                        poll_result->rc_data = ir->urb_data[0];
-                        break;
-                case RC_TYPE_NEC:
-                        if (ir->urb_data[1] == ((ir->key_addr >> 8) & 0xff)) {
-                                poll_result->rc_data = ir->urb_data[0]
-                                                        | ir->urb_data[1] << 8;
-                        }
-                        break;
-                default:
-                        poll_result->rc_data = ir->urb_data[0]
-                                        | ir->urb_data[1] << 8;
-                        break;
-                }
-        } else {
-                tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 0);
-                msleep(10);
-                tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 1);
-                msleep(10);
-
-                if (ir->rc_type == RC_TYPE_RC5) {
-                        rc = tm6000_read_write_usb(dev, USB_DIR_IN |
-                                USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                                REQ_02_GET_IR_CODE, 0, 0, buf, 1);
-
-                        msleep(10);
-
-                        dprintk("read data=%02x\n", buf[0]);
-                        if (rc < 0)
-                                return rc;
+        if (ir->wait)
+                return;
 
-                        poll_result->rc_data = buf[0];
-                } else {
-                        rc = tm6000_read_write_usb(dev, USB_DIR_IN |
-                                USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                                REQ_02_GET_IR_CODE, 0, 0, buf, 2);
+        dprintk(3, "%s\n",__func__);
 
-                        msleep(10);
+        rc = tm6000_read_write_usb(dev, USB_DIR_IN |
+                USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                REQ_02_GET_IR_CODE, 0, 0, buf, 2);
+        if (rc < 0)
+                return;
 
-                        dprintk("read data=%04x\n", buf[0] | buf[1] << 8);
-                        if (rc < 0)
-                                return rc;
+        if (rc > 1)
+                poll_result.rc_data = buf[0] | buf[1] << 8;
+        else
+                poll_result.rc_data = buf[0];
 
-                        poll_result->rc_data = buf[0] | buf[1] << 8;
+        /* Check if something was read */
+        if ((poll_result.rc_data & 0xff) == 0xff) {
+                if (!ir->pwled) {
+                        tm6000_flash_led(dev, 1);
+                        ir->pwled = 1;
                 }
-                if ((poll_result->rc_data & 0x00ff) != 0xff)
-                        ir->key = 1;
+                return;
         }
-        return 0;
+
+        dprintk(1, "%s, scancode: 0x%04x\n",__func__, poll_result.rc_data);
+        rc_keydown(ir->rc, poll_result.rc_data, 0);
+        tm6000_flash_led(dev, 0);
+        ir->pwled = 0;
+
+        /* Re-schedule polling */
+        schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
 }
 
-static void tm6000_ir_handle_key(struct tm6000_IR *ir)
+static void tm6000_ir_int_work(struct work_struct *work)
 {
+        struct tm6000_IR *ir = container_of(work, struct tm6000_IR, work.work);
         struct tm6000_core *dev = ir->dev;
-        int result;
-        struct tm6000_ir_poll_result poll_result;
+        int rc;
 
-        /* read the registers containing the IR status */
-        result = ir->get_key(ir, &poll_result);
-        if (result < 0) {
-                printk(KERN_INFO "ir->get_key() failed %d\n", result);
-                return;
-        }
+        dprintk(3, "%s, submit_urb = %d, pwled = %d\n",__func__, ir->submit_urb,
+                ir->pwled);
 
-        dprintk("ir->get_key result data=%04x\n", poll_result.rc_data);
+        if (ir->submit_urb) {
+                dprintk(3, "Resubmit urb\n");
+                tm6000_set_reg(dev, REQ_04_EN_DISABLE_MCU_INT, 2, 0);
 
-        if (ir->pwled) {
-                if (ir->pwledcnt >= PWLED_OFF) {
-                        ir->pwled = 0;
-                        ir->pwledcnt = 0;
-                        tm6000_flash_led(dev, 1);
-                } else
-                        ir->pwledcnt += 1;
+                rc = usb_submit_urb(ir->int_urb, GFP_ATOMIC);
+                if (rc < 0) {
+                        printk(KERN_ERR "tm6000: Can't submit an IR interrupt. Error %i\n",
+                               rc);
+                        /* Retry in 100 ms */
+                        schedule_delayed_work(&ir->work, msecs_to_jiffies(URB_SUBMIT_DELAY));
+                        return;
+                }
+                ir->submit_urb = 0;
         }
 
-        if (ir->key) {
-                rc_keydown(ir->rc, poll_result.rc_data, 0);
-                ir->key = 0;
-                ir->pwled = 1;
-                ir->pwledcnt = 0;
+        /* Led is enabled only if USB submit doesn't fail */
+        if (ir->pwled == 2) {
                 tm6000_flash_led(dev, 0);
+                ir->pwled = 0;
+                schedule_delayed_work(&ir->work, msecs_to_jiffies(URB_INT_LED_DELAY));
+        } else if (!ir->pwled) {
+                tm6000_flash_led(dev, 1);
+                ir->pwled = 1;
         }
-        return;
-}
-
-static void tm6000_ir_work(struct work_struct *work)
-{
-        struct tm6000_IR *ir = container_of(work, struct tm6000_IR, work.work);
-
-        tm6000_ir_handle_key(ir);
-        schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
 }
 
 static int tm6000_ir_start(struct rc_dev *rc)
 {
         struct tm6000_IR *ir = rc->priv;
 
-        INIT_DELAYED_WORK(&ir->work, tm6000_ir_work);
+        dprintk(2, "%s\n",__func__);
+
         schedule_delayed_work(&ir->work, 0);
 
         return 0;
@@ -281,6 +293,8 @@ static void tm6000_ir_stop(struct rc_dev *rc)
 {
         struct tm6000_IR *ir = rc->priv;
 
+        dprintk(2, "%s\n",__func__);
+
         cancel_delayed_work_sync(&ir->work);
 }
 
@@ -291,10 +305,11 @@ static int tm6000_ir_change_protocol(struct rc_dev *rc, u64 rc_type)
         if (!ir)
                 return 0;
 
+        dprintk(2, "%s\n",__func__);
+
         if ((rc->rc_map.scan) && (rc_type == RC_TYPE_NEC))
                 ir->key_addr = ((rc->rc_map.scan[0].scancode >> 8) & 0xffff);
 
-        ir->get_key = default_polling_getkey;
         ir->rc_type = rc_type;
 
         tm6000_ir_config(ir);
@@ -302,17 +317,19 @@ static int tm6000_ir_change_protocol(struct rc_dev *rc, u64 rc_type)
         return 0;
 }
 
-int tm6000_ir_int_start(struct tm6000_core *dev)
+static int __tm6000_ir_int_start(struct rc_dev *rc)
 {
-        struct tm6000_IR *ir = dev->ir;
+        struct tm6000_IR *ir = rc->priv;
+        struct tm6000_core *dev = ir->dev;
         int pipe, size;
         int err = -ENOMEM;
 
-
         if (!ir)
                 return -ENODEV;
 
-        ir->int_urb = usb_alloc_urb(0, GFP_KERNEL);
+        dprintk(2, "%s\n",__func__);
+
+        ir->int_urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!ir->int_urb)
                 return -ENOMEM;
 
@@ -321,42 +338,59 @@ int tm6000_ir_int_start(struct tm6000_core *dev)
                 & USB_ENDPOINT_NUMBER_MASK);
 
         size = usb_maxpacket(dev->udev, pipe, usb_pipeout(pipe));
-        dprintk("IR max size: %d\n", size);
+        dprintk(1, "IR max size: %d\n", size);
 
-        ir->int_urb->transfer_buffer = kzalloc(size, GFP_KERNEL);
+        ir->int_urb->transfer_buffer = kzalloc(size, GFP_ATOMIC);
         if (ir->int_urb->transfer_buffer == NULL) {
                 usb_free_urb(ir->int_urb);
                 return err;
         }
-        dprintk("int interval: %d\n", dev->int_in.endp->desc.bInterval);
+        dprintk(1, "int interval: %d\n", dev->int_in.endp->desc.bInterval);
+
         usb_fill_int_urb(ir->int_urb, dev->udev, pipe,
                 ir->int_urb->transfer_buffer, size,
                 tm6000_ir_urb_received, dev,
                 dev->int_in.endp->desc.bInterval);
-        err = usb_submit_urb(ir->int_urb, GFP_KERNEL);
-        if (err) {
-                kfree(ir->int_urb->transfer_buffer);
-                usb_free_urb(ir->int_urb);
-                return err;
-        }
-        ir->urb_data = kzalloc(size, GFP_KERNEL);
+
+        ir->submit_urb = 1;
+        schedule_delayed_work(&ir->work, msecs_to_jiffies(URB_SUBMIT_DELAY));
 
         return 0;
 }
 
-void tm6000_ir_int_stop(struct tm6000_core *dev)
+static void __tm6000_ir_int_stop(struct rc_dev *rc)
 {
-        struct tm6000_IR *ir = dev->ir;
+        struct tm6000_IR *ir = rc->priv;
 
-        if (!ir)
+        if (!ir || !ir->int_urb)
                 return;
 
+        dprintk(2, "%s\n",__func__);
+
         usb_kill_urb(ir->int_urb);
         kfree(ir->int_urb->transfer_buffer);
         usb_free_urb(ir->int_urb);
         ir->int_urb = NULL;
-        kfree(ir->urb_data);
-        ir->urb_data = NULL;
+}
+
+int tm6000_ir_int_start(struct tm6000_core *dev)
+{
+        struct tm6000_IR *ir = dev->ir;
+
+        if (!ir)
+                return 0;
+
+        return __tm6000_ir_int_start(ir->rc);
+}
+
+void tm6000_ir_int_stop(struct tm6000_core *dev)
+{
+        struct tm6000_IR *ir = dev->ir;
+
+        if (!ir || !ir->rc)
+                return;
+
+        __tm6000_ir_int_stop(ir->rc);
 }
 
 int tm6000_ir_init(struct tm6000_core *dev)
@@ -374,29 +408,36 @@ int tm6000_ir_init(struct tm6000_core *dev)
         if (!dev->ir_codes)
                 return 0;
 
-        ir = kzalloc(sizeof(*ir), GFP_KERNEL);
+        ir = kzalloc(sizeof(*ir), GFP_ATOMIC);
         rc = rc_allocate_device();
         if (!ir || !rc)
                 goto out;
 
+        dprintk(2, "%s\n", __func__);
+
         /* record handles to ourself */
         ir->dev = dev;
         dev->ir = ir;
         ir->rc = rc;
 
-        /* input einrichten */
+        /* input setup */
         rc->allowed_protos = RC_TYPE_RC5 | RC_TYPE_NEC;
+        /* Neded, in order to support NEC remotes with 24 or 32 bits */
+        rc->scanmask = 0xffff;
         rc->priv = ir;
         rc->change_protocol = tm6000_ir_change_protocol;
-        rc->open = tm6000_ir_start;
-        rc->close = tm6000_ir_stop;
+        if (dev->int_in.endp) {
+                rc->open    = __tm6000_ir_int_start;
+                rc->close   = __tm6000_ir_int_stop;
+                INIT_DELAYED_WORK(&ir->work, tm6000_ir_int_work);
+        } else {
+                rc->open  = tm6000_ir_start;
+                rc->close = tm6000_ir_stop;
+                ir->polling = 50;
+                INIT_DELAYED_WORK(&ir->work, tm6000_ir_handle_key);
+        }
         rc->driver_type = RC_DRIVER_SCANCODE;
 
-        ir->polling = 50;
-        ir->pwled = 0;
-        ir->pwledcnt = 0;
-
-
         snprintf(ir->name, sizeof(ir->name), "tm5600/60x0 IR (%s)",
                                                 dev->name);
 
@@ -415,15 +456,6 @@ int tm6000_ir_init(struct tm6000_core *dev)
         rc->driver_name = "tm6000";
         rc->dev.parent = &dev->udev->dev;
 
-        if (&dev->int_in) {
-                dprintk("IR over int\n");
-
-                err = tm6000_ir_int_start(dev);
-
-                if (err)
-                        goto out;
-        }
-
         /* ir register */
         err = rc_register_device(rc);
         if (err)
@@ -447,10 +479,19 @@ int tm6000_ir_fini(struct tm6000_core *dev)
         if (!ir)
                 return 0;
 
+        dprintk(2, "%s\n",__func__);
+
         rc_unregister_device(ir->rc);
 
-        if (ir->int_urb)
-                tm6000_ir_int_stop(dev);
+        if (!ir->polling)
+                __tm6000_ir_int_stop(ir->rc);
+
+        tm6000_ir_stop(ir->rc);
+
+        /* Turn off the led */
+        tm6000_flash_led(dev, 0);
+        ir->pwled = 0;
+
 
         kfree(ir);
         dev->ir = NULL;
diff --git a/drivers/media/video/tm6000/tm6000-regs.h b/drivers/media/video/tm6000/tm6000-regs.h
index 7f491b6de933..a38c251ed57b 100644
--- a/drivers/media/video/tm6000/tm6000-regs.h
+++ b/drivers/media/video/tm6000/tm6000-regs.h
@@ -284,19 +284,19 @@ enum {
 /* ONLY for TM6010 */
 #define TM6010_REQ07_RD8_IR                             0x07, 0xd8
 /* ONLY for TM6010 */
-#define TM6010_REQ07_RD8_IR_BSIZE                       0x07, 0xd9
+#define TM6010_REQ07_RD9_IR_BSIZE                       0x07, 0xd9
 /* ONLY for TM6010 */
-#define TM6010_REQ07_RD8_IR_WAKEUP_SEL                  0x07, 0xda
+#define TM6010_REQ07_RDA_IR_WAKEUP_SEL                  0x07, 0xda
 /* ONLY for TM6010 */
-#define TM6010_REQ07_RD8_IR_WAKEUP_ADD                  0x07, 0xdb
+#define TM6010_REQ07_RDB_IR_WAKEUP_ADD                  0x07, 0xdb
 /* ONLY for TM6010 */
-#define TM6010_REQ07_RD8_IR_LEADER1                     0x07, 0xdc
+#define TM6010_REQ07_RDC_IR_LEADER1                     0x07, 0xdc
 /* ONLY for TM6010 */
-#define TM6010_REQ07_RD8_IR_LEADER0                     0x07, 0xdd
+#define TM6010_REQ07_RDD_IR_LEADER0                     0x07, 0xdd
 /* ONLY for TM6010 */
-#define TM6010_REQ07_RD8_IR_PULSE_CNT1                  0x07, 0xde
+#define TM6010_REQ07_RDE_IR_PULSE_CNT1                  0x07, 0xde
 /* ONLY for TM6010 */
-#define TM6010_REQ07_RD8_IR_PULSE_CNT0                  0x07, 0xdf
+#define TM6010_REQ07_RDF_IR_PULSE_CNT0                  0x07, 0xdf
 /* ONLY for TM6010 */
 #define TM6010_REQ07_RE0_DVIDEO_SOURCE                  0x07, 0xe0
 /* ONLY for TM6010 */
diff --git a/drivers/media/video/tm6000/tm6000-stds.c b/drivers/media/video/tm6000/tm6000-stds.c
index 9a4145dc3d87..9dc0831d813f 100644
--- a/drivers/media/video/tm6000/tm6000-stds.c
+++ b/drivers/media/video/tm6000/tm6000-stds.c
@@ -361,82 +361,51 @@ static int tm6000_set_audio_std(struct tm6000_core *dev)
                 return 0;
         }
 
-        switch (tm6010_a_mode) {
+        /*
+         * STD/MN shouldn't be affected by tm6010_a_mode, as there's just one
+         * audio standard for each V4L2_STD type.
+         */
+        if ((dev->norm & V4L2_STD_NTSC) == V4L2_STD_NTSC_M_KR) {
+                areg_05 |= 0x04;
+        } else if ((dev->norm & V4L2_STD_NTSC) == V4L2_STD_NTSC_M_JP) {
+                areg_05 |= 0x43;
+        } else if (dev->norm & V4L2_STD_MN) {
+                areg_05 |= 0x22;
+        } else switch (tm6010_a_mode) {
         /* auto */
         case 0:
-                switch (dev->norm) {
-                case V4L2_STD_NTSC_M_KR:
+                if ((dev->norm & V4L2_STD_SECAM) == V4L2_STD_SECAM_L)
                         areg_05 |= 0x00;
-                        break;
-                case V4L2_STD_NTSC_M_JP:
-                        areg_05 |= 0x40;
-                        break;
-                case V4L2_STD_NTSC_M:
-                case V4L2_STD_PAL_M:
-                case V4L2_STD_PAL_N:
-                        areg_05 |= 0x20;
-                        break;
-                case V4L2_STD_PAL_Nc:
-                        areg_05 |= 0x60;
-                        break;
-                case V4L2_STD_SECAM_L:
-                        areg_05 |= 0x00;
-                        break;
-                case V4L2_STD_DK:
+                else    /* Other PAL/SECAM standards */
                         areg_05 |= 0x10;
-                        break;
-                }
                 break;
         /* A2 */
         case 1:
-                switch (dev->norm) {
-                case V4L2_STD_B:
-                case V4L2_STD_GH:
-                        areg_05 = 0x05;
-                        break;
-                case V4L2_STD_DK:
+                if (dev->norm & V4L2_STD_DK)
                         areg_05 = 0x09;
-                        break;
-                }
+                else
+                        areg_05 = 0x05;
                 break;
         /* NICAM */
         case 2:
-                switch (dev->norm) {
-                case V4L2_STD_B:
-                case V4L2_STD_GH:
-                        areg_05 = 0x07;
-                        break;
-                case V4L2_STD_DK:
+                if (dev->norm & V4L2_STD_DK) {
                         areg_05 = 0x06;
-                        break;
-                case V4L2_STD_PAL_I:
+                } else if (dev->norm & V4L2_STD_PAL_I) {
                         areg_05 = 0x08;
-                        break;
-                case V4L2_STD_SECAM_L:
+                } else if (dev->norm & V4L2_STD_SECAM_L) {
                         areg_05 = 0x0a;
                         areg_02 = 0x02;
-                        break;
+                } else {
+                        areg_05 = 0x07;
                 }
                 nicam_flag = 1;
                 break;
         /* other */
         case 3:
-                switch (dev->norm) {
-                /* DK3_A2 */
-                case V4L2_STD_DK:
+                if (dev->norm & V4L2_STD_DK) {
                         areg_05 = 0x0b;
-                        break;
-                /* Korea */
-                case V4L2_STD_NTSC_M_KR:
-                        areg_05 = 0x04;
-                        break;
-                /* EIAJ */
-                case V4L2_STD_NTSC_M_JP:
-                        areg_05 = 0x03;
-                        break;
-                default:
+                } else {
                         areg_05 = 0x02;
-                        break;
                 }
                 break;
         }
@@ -557,10 +526,16 @@ int tm6000_set_standard(struct tm6000_core *dev)
                 case TM6000_AMUX_ADC1:
                         tm6000_set_reg_mask(dev, TM6010_REQ08_RF0_DAUDIO_INPUT_CONFIG,
                                 0x00, 0x0f);
+                        /* Mux overflow workaround */
+                        tm6000_set_reg_mask(dev, TM6010_REQ07_R07_OUTPUT_CONTROL,
+                                0x10, 0xf0);
                         break;
                 case TM6000_AMUX_ADC2:
                         tm6000_set_reg_mask(dev, TM6010_REQ08_RF0_DAUDIO_INPUT_CONFIG,
                                 0x08, 0x0f);
+                        /* Mux overflow workaround */
+                        tm6000_set_reg_mask(dev, TM6010_REQ07_R07_OUTPUT_CONTROL,
+                                0x10, 0xf0);
                         break;
                 case TM6000_AMUX_SIF1:
                         reg_08_e2 |= 0x02;
@@ -570,6 +545,9 @@ int tm6000_set_standard(struct tm6000_core *dev)
                         tm6000_set_reg(dev, TM6010_REQ08_RE4_ADC_IN2_SEL, 0xf3);
                         tm6000_set_reg_mask(dev, TM6010_REQ08_RF0_DAUDIO_INPUT_CONFIG,
                                 0x02, 0x0f);
+                        /* Mux overflow workaround */
+                        tm6000_set_reg_mask(dev, TM6010_REQ07_R07_OUTPUT_CONTROL,
+                                0x30, 0xf0);
                         break;
                 case TM6000_AMUX_SIF2:
                         reg_08_e2 |= 0x02;
@@ -579,6 +557,9 @@ int tm6000_set_standard(struct tm6000_core *dev)
                         tm6000_set_reg(dev, TM6010_REQ08_RE4_ADC_IN2_SEL, 0xf7);
                         tm6000_set_reg_mask(dev, TM6010_REQ08_RF0_DAUDIO_INPUT_CONFIG,
                                 0x02, 0x0f);
+                        /* Mux overflow workaround */
+                        tm6000_set_reg_mask(dev, TM6010_REQ07_R07_OUTPUT_CONTROL,
+                                0x30, 0xf0);
                         break;
                 default:
                         break;
diff --git a/drivers/media/video/tm6000/tm6000-video.c b/drivers/media/video/tm6000/tm6000-video.c
index 1e5ace0b5d10..bc13db736e24 100644
--- a/drivers/media/video/tm6000/tm6000-video.c
+++ b/drivers/media/video/tm6000/tm6000-video.c
@@ -1605,16 +1605,25 @@ static int tm6000_release(struct file *file)
         res_free(dev, fh);
 
         if (!dev->users) {
-                int err;
-
                 tm6000_uninit_isoc(dev);
 
+                /* Stop interrupt USB pipe */
+                tm6000_ir_int_stop(dev);
+
+                usb_reset_configuration(dev->udev);
+
+                if (dev->int_in.endp)
+                        usb_set_interface(dev->udev,
+                                        dev->isoc_in.bInterfaceNumber, 2);
+                else
+                        usb_set_interface(dev->udev,
+                                        dev->isoc_in.bInterfaceNumber, 0);
+
+                /* Start interrupt USB pipe */
+                tm6000_ir_int_start(dev);
+
                 if (!fh->radio)
                         videobuf_mmap_free(&fh->vb_vidq);
-
-                err = tm6000_reset(dev);
-                if (err < 0)
-                        dev_err(&vdev->dev, "reset failed: %d\n", err);
         }
 
         kfree(fh);
diff --git a/drivers/media/video/tm6000/tm6000.h b/drivers/media/video/tm6000/tm6000.h
index 2777e514eff2..27ba659cfa85 100644
--- a/drivers/media/video/tm6000/tm6000.h
+++ b/drivers/media/video/tm6000/tm6000.h
@@ -188,6 +188,9 @@ struct tm6000_core {
         /* Device Capabilities*/
         struct tm6000_capabilities      caps;
 
+        /* Used to load alsa/dvb */
+        struct work_struct              request_module_wk;
+
         /* Tuner configuration */
         int                             tuner_type;             /* type of the tuner */
         int                             tuner_addr;             /* tuner address */
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 11cc980b0cd5..4059ea178c2d 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -326,6 +326,7 @@ static void set_type(struct i2c_client *c, unsigned int type,
                 t->mode_mask = T_RADIO;
                 break;
         case TUNER_PHILIPS_FMD1216ME_MK3:
+        case TUNER_PHILIPS_FMD1216MEX_MK3:
                 buffer[0] = 0x0b;
                 buffer[1] = 0xdc;
                 buffer[2] = 0x9c;
diff --git a/drivers/media/video/tvp5150.c b/drivers/media/video/tvp5150.c
index 6abaa16ae136..6be9910a6e24 100644
--- a/drivers/media/video/tvp5150.c
+++ b/drivers/media/video/tvp5150.c
@@ -703,21 +703,21 @@ static int tvp5150_set_std(struct v4l2_subdev *sd, v4l2_std_id std)
         /* First tests should be against specific std */
 
         if (std == V4L2_STD_ALL) {
-                fmt = 0;        /* Autodetect mode */
+                fmt = VIDEO_STD_AUTO_SWITCH_BIT;        /* Autodetect mode */
         } else if (std & V4L2_STD_NTSC_443) {
-                fmt = 0xa;
+                fmt = VIDEO_STD_NTSC_4_43_BIT;
         } else if (std & V4L2_STD_PAL_M) {
-                fmt = 0x6;
+                fmt = VIDEO_STD_PAL_M_BIT;
         } else if (std & (V4L2_STD_PAL_N | V4L2_STD_PAL_Nc)) {
-                fmt = 0x8;
+                fmt = VIDEO_STD_PAL_COMBINATION_N_BIT;
         } else {
                 /* Then, test against generic ones */
                 if (std & V4L2_STD_NTSC)
-                        fmt = 0x2;
+                        fmt = VIDEO_STD_NTSC_MJ_BIT;
                 else if (std & V4L2_STD_PAL)
-                        fmt = 0x4;
+                        fmt = VIDEO_STD_PAL_BDGHIN_BIT;
                 else if (std & V4L2_STD_SECAM)
-                        fmt = 0xc;
+                        fmt = VIDEO_STD_SECAM_BIT;
         }
 
         v4l2_dbg(1, debug, sd, "Set video std register to %d.\n", fmt);
@@ -779,6 +779,70 @@ static int tvp5150_s_ctrl(struct v4l2_ctrl *ctrl)
         return -EINVAL;
 }
 
+static v4l2_std_id tvp5150_read_std(struct v4l2_subdev *sd)
+{
+        int val = tvp5150_read(sd, TVP5150_STATUS_REG_5);
+
+        switch (val & 0x0F) {
+        case 0x01:
+                return V4L2_STD_NTSC;
+        case 0x03:
+                return V4L2_STD_PAL;
+        case 0x05:
+                return V4L2_STD_PAL_M;
+        case 0x07:
+                return V4L2_STD_PAL_N | V4L2_STD_PAL_Nc;
+        case 0x09:
+                return V4L2_STD_NTSC_443;
+        case 0xb:
+                return V4L2_STD_SECAM;
+        default:
+                return V4L2_STD_UNKNOWN;
+        }
+}
+
+static int tvp5150_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned index,
+                                                enum v4l2_mbus_pixelcode *code)
+{
+        if (index)
+                return -EINVAL;
+
+        *code = V4L2_MBUS_FMT_YUYV8_2X8;
+        return 0;
+}
+
+static int tvp5150_mbus_fmt(struct v4l2_subdev *sd,
+                            struct v4l2_mbus_framefmt *f)
+{
+        struct tvp5150 *decoder = to_tvp5150(sd);
+        v4l2_std_id std;
+
+        if (f == NULL)
+                return -EINVAL;
+
+        tvp5150_reset(sd, 0);
+
+        /* Calculate height and width based on current standard */
+        if (decoder->norm == V4L2_STD_ALL)
+                std = tvp5150_read_std(sd);
+        else
+                std = decoder->norm;
+
+        f->width = 720;
+        if (std & V4L2_STD_525_60)
+                f->height = 480;
+        else
+                f->height = 576;
+
+        f->code = V4L2_MBUS_FMT_YUYV8_2X8;
+        f->field = V4L2_FIELD_SEQ_TB;
+        f->colorspace = V4L2_COLORSPACE_SMPTE170M;
+
+        v4l2_dbg(1, debug, sd, "width = %d, height = %d\n", f->width,
+                        f->height);
+        return 0;
+}
+
 /****************************************************************************
                         I2C Command
  ****************************************************************************/
@@ -931,6 +995,9 @@ static const struct v4l2_subdev_tuner_ops tvp5150_tuner_ops = {
 
 static const struct v4l2_subdev_video_ops tvp5150_video_ops = {
         .s_routing = tvp5150_s_routing,
+        .enum_mbus_fmt = tvp5150_enum_mbus_fmt,
+        .s_mbus_fmt = tvp5150_mbus_fmt,
+        .try_mbus_fmt = tvp5150_mbus_fmt,
 };
 
 static const struct v4l2_subdev_vbi_ops tvp5150_vbi_ops = {
diff --git a/drivers/media/video/usbvision/usbvision-i2c.c b/drivers/media/video/usbvision/usbvision-i2c.c
index d7f97513b289..89fec029e924 100644
--- a/drivers/media/video/usbvision/usbvision-i2c.c
+++ b/drivers/media/video/usbvision/usbvision-i2c.c
@@ -110,42 +110,20 @@ static inline int usb_find_address(struct i2c_adapter *i2c_adap,
 
         unsigned char addr;
         int ret;
-        if ((flags & I2C_M_TEN)) {
-                /* a ten bit address */
-                addr = 0xf0 | ((msg->addr >> 7) & 0x03);
-                /* try extended address code... */
-                ret = try_write_address(i2c_adap, addr, retries);
-                if (ret != 1) {
-                        dev_err(&i2c_adap->dev,
-                                "died at extended address code, while writing\n");
-                        return -EREMOTEIO;
-                }
-                add[0] = addr;
-                if (flags & I2C_M_RD) {
-                        /* okay, now switch into reading mode */
-                        addr |= 0x01;
-                        ret = try_read_address(i2c_adap, addr, retries);
-                        if (ret != 1) {
-                                dev_err(&i2c_adap->dev,
-                                        "died at extended address code, while reading\n");
-                                return -EREMOTEIO;
-                        }
-                }
 
-        } else {                /* normal 7bit address  */
-                addr = (msg->addr << 1);
-                if (flags & I2C_M_RD)
-                        addr |= 1;
+        addr = (msg->addr << 1);
+        if (flags & I2C_M_RD)
+                addr |= 1;
 
-                add[0] = addr;
-                if (flags & I2C_M_RD)
-                        ret = try_read_address(i2c_adap, addr, retries);
-                else
-                        ret = try_write_address(i2c_adap, addr, retries);
+        add[0] = addr;
+        if (flags & I2C_M_RD)
+                ret = try_read_address(i2c_adap, addr, retries);
+        else
+                ret = try_write_address(i2c_adap, addr, retries);
+
+        if (ret != 1)
+                return -EREMOTEIO;
 
-                if (ret != 1)
-                        return -EREMOTEIO;
-        }
         return 0;
 }
 
@@ -184,7 +162,7 @@ usbvision_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
 
 static u32 functionality(struct i2c_adapter *adap)
 {
-        return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR;
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 }
 
 /* -----exported algorithm data: -------------------------------------  */
diff --git a/drivers/media/video/uvc/Kconfig b/drivers/media/video/uvc/Kconfig
index 2956a7637219..6c197da531b2 100644
--- a/drivers/media/video/uvc/Kconfig
+++ b/drivers/media/video/uvc/Kconfig
@@ -1,5 +1,6 @@
 config USB_VIDEO_CLASS
         tristate "USB Video Class (UVC)"
+        select VIDEOBUF2_VMALLOC
         ---help---
           Support for the USB Video Class (UVC).  Currently only video
           input devices, such as webcams, are supported.
diff --git a/drivers/media/video/uvc/Makefile b/drivers/media/video/uvc/Makefile
index 2071ca8a2f03..c26d12fdb8f4 100644
--- a/drivers/media/video/uvc/Makefile
+++ b/drivers/media/video/uvc/Makefile
@@ -1,5 +1,5 @@
 uvcvideo-objs  := uvc_driver.o uvc_queue.o uvc_v4l2.o uvc_video.o uvc_ctrl.o \
-                  uvc_status.o uvc_isight.o
+                  uvc_status.o uvc_isight.o uvc_debugfs.o
 ifeq ($(CONFIG_MEDIA_CONTROLLER),y)
 uvcvideo-objs  += uvc_entity.o
 endif
diff --git a/drivers/media/video/uvc/uvc_ctrl.c b/drivers/media/video/uvc/uvc_ctrl.c
index 254d32688843..0efd3b10b353 100644
--- a/drivers/media/video/uvc/uvc_ctrl.c
+++ b/drivers/media/video/uvc/uvc_ctrl.c
@@ -878,8 +878,21 @@ static int uvc_ctrl_populate_cache(struct uvc_video_chain *chain,
                                      chain->dev->intfnum, ctrl->info.selector,
                                      uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES),
                                      ctrl->info.size);
-                if (ret < 0)
-                        return ret;
+                if (ret < 0) {
+                        if (UVC_ENTITY_TYPE(ctrl->entity) !=
+                            UVC_VC_EXTENSION_UNIT)
+                                return ret;
+
+                        /* GET_RES is mandatory for XU controls, but some
+                         * cameras still choke on it. Ignore errors and set the
+                         * resolution value to zero.
+                         */
+                        uvc_warn_once(chain->dev, UVC_WARN_XU_GET_RES,
+                                      "UVC non compliance - GET_RES failed on "
+                                      "an XU control. Enabling workaround.\n");
+                        memset(uvc_ctrl_data(ctrl, UVC_CTRL_DATA_RES), 0,
+                               ctrl->info.size);
+                }
         }
 
         ctrl->cached = 1;
@@ -1861,7 +1874,7 @@ int uvc_ctrl_init_device(struct uvc_device *dev)
                 if (ncontrols == 0)
                         continue;
 
-                entity->controls = kzalloc(ncontrols * sizeof(*ctrl),
+                entity->controls = kcalloc(ncontrols, sizeof(*ctrl),
                                            GFP_KERNEL);
                 if (entity->controls == NULL)
                         return -ENOMEM;
diff --git a/drivers/media/video/uvc/uvc_debugfs.c b/drivers/media/video/uvc/uvc_debugfs.c
new file mode 100644
index 000000000000..14561a5abb79
--- /dev/null
+++ b/drivers/media/video/uvc/uvc_debugfs.c
@@ -0,0 +1,136 @@
+/*
+ *      uvc_debugfs.c --  USB Video Class driver - Debugging support
+ *
+ *      Copyright (C) 2011
+ *          Laurent Pinchart (laurent.pinchart@ideasonboard.com)
+ *
+ *      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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/debugfs.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+
+#include "uvcvideo.h"
+
+/* -----------------------------------------------------------------------------
+ * Statistics
+ */
+
+#define UVC_DEBUGFS_BUF_SIZE    1024
+
+struct uvc_debugfs_buffer {
+        size_t count;
+        char data[UVC_DEBUGFS_BUF_SIZE];
+};
+
+static int uvc_debugfs_stats_open(struct inode *inode, struct file *file)
+{
+        struct uvc_streaming *stream = inode->i_private;
+        struct uvc_debugfs_buffer *buf;
+
+        buf = kmalloc(sizeof(*buf), GFP_KERNEL);
+        if (buf == NULL)
+                return -ENOMEM;
+
+        buf->count = uvc_video_stats_dump(stream, buf->data, sizeof(buf->data));
+
+        file->private_data = buf;
+        return 0;
+}
+
+static ssize_t uvc_debugfs_stats_read(struct file *file, char __user *user_buf,
+                                      size_t nbytes, loff_t *ppos)
+{
+        struct uvc_debugfs_buffer *buf = file->private_data;
+
+        return simple_read_from_buffer(user_buf, nbytes, ppos, buf->data,
+                                       buf->count);
+}
+
+static int uvc_debugfs_stats_release(struct inode *inode, struct file *file)
+{
+        kfree(file->private_data);
+        file->private_data = NULL;
+
+        return 0;
+}
+
+static const struct file_operations uvc_debugfs_stats_fops = {
+        .owner = THIS_MODULE,
+        .open = uvc_debugfs_stats_open,
+        .llseek = no_llseek,
+        .read = uvc_debugfs_stats_read,
+        .release = uvc_debugfs_stats_release,
+};
+
+/* -----------------------------------------------------------------------------
+ * Global and stream initialization/cleanup
+ */
+
+static struct dentry *uvc_debugfs_root_dir;
+
+int uvc_debugfs_init_stream(struct uvc_streaming *stream)
+{
+        struct usb_device *udev = stream->dev->udev;
+        struct dentry *dent;
+        char dir_name[32];
+
+        if (uvc_debugfs_root_dir == NULL)
+                return -ENODEV;
+
+        sprintf(dir_name, "%u-%u", udev->bus->busnum, udev->devnum);
+
+        dent = debugfs_create_dir(dir_name, uvc_debugfs_root_dir);
+        if (IS_ERR_OR_NULL(dent)) {
+                uvc_printk(KERN_INFO, "Unable to create debugfs %s "
+                           "directory.\n", dir_name);
+                return -ENODEV;
+        }
+
+        stream->debugfs_dir = dent;
+
+        dent = debugfs_create_file("stats", 0444, stream->debugfs_dir,
+                                   stream, &uvc_debugfs_stats_fops);
+        if (IS_ERR_OR_NULL(dent)) {
+                uvc_printk(KERN_INFO, "Unable to create debugfs stats file.\n");
+                uvc_debugfs_cleanup_stream(stream);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+void uvc_debugfs_cleanup_stream(struct uvc_streaming *stream)
+{
+        if (stream->debugfs_dir == NULL)
+                return;
+
+        debugfs_remove_recursive(stream->debugfs_dir);
+        stream->debugfs_dir = NULL;
+}
+
+int uvc_debugfs_init(void)
+{
+        struct dentry *dir;
+
+        dir = debugfs_create_dir("uvcvideo", usb_debug_root);
+        if (IS_ERR_OR_NULL(dir)) {
+                uvc_printk(KERN_INFO, "Unable to create debugfs directory\n");
+                return -ENODATA;
+        }
+
+        uvc_debugfs_root_dir = dir;
+        return 0;
+}
+
+void uvc_debugfs_cleanup(void)
+{
+        if (uvc_debugfs_root_dir != NULL)
+                debugfs_remove_recursive(uvc_debugfs_root_dir);
+}
diff --git a/drivers/media/video/uvc/uvc_driver.c b/drivers/media/video/uvc/uvc_driver.c
index 656d4c9e3b9f..a240d43d15d1 100644
--- a/drivers/media/video/uvc/uvc_driver.c
+++ b/drivers/media/video/uvc/uvc_driver.c
@@ -1675,6 +1675,8 @@ static void uvc_unregister_video(struct uvc_device *dev)
 
                 video_unregister_device(stream->vdev);
                 stream->vdev = NULL;
+
+                uvc_debugfs_cleanup_stream(stream);
         }
 
         /* Decrement the stream count and call uvc_delete explicitly if there
@@ -1700,6 +1702,8 @@ static int uvc_register_video(struct uvc_device *dev,
                 return ret;
         }
 
+        uvc_debugfs_init_stream(stream);
+
         /* Register the device with V4L. */
         vdev = video_device_alloc();
         if (vdev == NULL) {
@@ -2033,6 +2037,15 @@ MODULE_PARM_DESC(timeout, "Streaming control requests timeout");
  * though they are compliant.
  */
 static struct usb_device_id uvc_ids[] = {
+        /* LogiLink Wireless Webcam */
+        { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
+                                | USB_DEVICE_ID_MATCH_INT_INFO,
+          .idVendor             = 0x0416,
+          .idProduct            = 0xa91a,
+          .bInterfaceClass      = USB_CLASS_VIDEO,
+          .bInterfaceSubClass   = 1,
+          .bInterfaceProtocol   = 0,
+          .driver_info          = UVC_QUIRK_PROBE_MINMAX },
         /* Genius eFace 2025 */
         { .match_flags          = USB_DEVICE_ID_MATCH_DEVICE
                                 | USB_DEVICE_ID_MATCH_INT_INFO,
@@ -2396,17 +2409,24 @@ struct uvc_driver uvc_driver = {
 
 static int __init uvc_init(void)
 {
-        int result;
+        int ret;
+
+        uvc_debugfs_init();
 
-        result = usb_register(&uvc_driver.driver);
-        if (result == 0)
-                printk(KERN_INFO DRIVER_DESC " (" DRIVER_VERSION ")\n");
-        return result;
+        ret = usb_register(&uvc_driver.driver);
+        if (ret < 0) {
+                uvc_debugfs_cleanup();
+                return ret;
+        }
+
+        printk(KERN_INFO DRIVER_DESC " (" DRIVER_VERSION ")\n");
+        return 0;
 }
 
 static void __exit uvc_cleanup(void)
 {
         usb_deregister(&uvc_driver.driver);
+        uvc_debugfs_cleanup();
 }
 
 module_init(uvc_init);
diff --git a/drivers/media/video/uvc/uvc_isight.c b/drivers/media/video/uvc/uvc_isight.c
index 74bbe8f18f3e..8510e7259e76 100644
--- a/drivers/media/video/uvc/uvc_isight.c
+++ b/drivers/media/video/uvc/uvc_isight.c
@@ -74,7 +74,7 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
          * Empty buffers (bytesused == 0) don't trigger end of frame detection
          * as it doesn't make sense to return an empty buffer.
          */
-        if (is_header && buf->buf.bytesused != 0) {
+        if (is_header && buf->bytesused != 0) {
                 buf->state = UVC_BUF_STATE_DONE;
                 return -EAGAIN;
         }
@@ -83,13 +83,13 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf,
          * contain no data.
          */
         if (!is_header) {
-                maxlen = buf->buf.length - buf->buf.bytesused;
-                mem = queue->mem + buf->buf.m.offset + buf->buf.bytesused;
+                maxlen = buf->length - buf->bytesused;
+                mem = buf->mem + buf->bytesused;
                 nbytes = min(len, maxlen);
                 memcpy(mem, data, nbytes);
-                buf->buf.bytesused += nbytes;
+                buf->bytesused += nbytes;
 
-                if (len > maxlen || buf->buf.bytesused == buf->buf.length) {
+                if (len > maxlen || buf->bytesused == buf->length) {
                         uvc_trace(UVC_TRACE_FRAME, "Frame complete "
                                   "(overflow).\n");
                         buf->state = UVC_BUF_STATE_DONE;
diff --git a/drivers/media/video/uvc/uvc_queue.c b/drivers/media/video/uvc/uvc_queue.c
index 677691c44500..518f77d3a4d8 100644
--- a/drivers/media/video/uvc/uvc_queue.c
+++ b/drivers/media/video/uvc/uvc_queue.c
@@ -11,6 +11,7 @@
  *
  */
 
+#include <linux/atomic.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/list.h>
@@ -19,7 +20,7 @@
 #include <linux/videodev2.h>
 #include <linux/vmalloc.h>
 #include <linux/wait.h>
-#include <linux/atomic.h>
+#include <media/videobuf2-vmalloc.h>
 
 #include "uvcvideo.h"
 
@@ -29,467 +30,211 @@
  * Video queues is initialized by uvc_queue_init(). The function performs
  * basic initialization of the uvc_video_queue struct and never fails.
  *
- * Video buffer allocation and freeing are performed by uvc_alloc_buffers and
- * uvc_free_buffers respectively. The former acquires the video queue lock,
- * while the later must be called with the lock held (so that allocation can
- * free previously allocated buffers). Trying to free buffers that are mapped
- * to user space will return -EBUSY.
- *
- * Video buffers are managed using two queues. However, unlike most USB video
- * drivers that use an in queue and an out queue, we use a main queue to hold
- * all queued buffers (both 'empty' and 'done' buffers), and an irq queue to
- * hold empty buffers. This design (copied from video-buf) minimizes locking
- * in interrupt, as only one queue is shared between interrupt and user
- * contexts.
- *
- * Use cases
- * ---------
- *
- * Unless stated otherwise, all operations that modify the irq buffers queue
- * are protected by the irq spinlock.
- *
- * 1. The user queues the buffers, starts streaming and dequeues a buffer.
- *
- *    The buffers are added to the main and irq queues. Both operations are
- *    protected by the queue lock, and the later is protected by the irq
- *    spinlock as well.
- *
- *    The completion handler fetches a buffer from the irq queue and fills it
- *    with video data. If no buffer is available (irq queue empty), the handler
- *    returns immediately.
- *
- *    When the buffer is full, the completion handler removes it from the irq
- *    queue, marks it as done (UVC_BUF_STATE_DONE) and wakes its wait queue.
- *    At that point, any process waiting on the buffer will be woken up. If a
- *    process tries to dequeue a buffer after it has been marked done, the
- *    dequeing will succeed immediately.
- *
- * 2. Buffers are queued, user is waiting on a buffer and the device gets
- *    disconnected.
- *
- *    When the device is disconnected, the kernel calls the completion handler
- *    with an appropriate status code. The handler marks all buffers in the
- *    irq queue as being erroneous (UVC_BUF_STATE_ERROR) and wakes them up so
- *    that any process waiting on a buffer gets woken up.
- *
- *    Waking up up the first buffer on the irq list is not enough, as the
- *    process waiting on the buffer might restart the dequeue operation
- *    immediately.
- *
+ * Video buffers are managed by videobuf2. The driver uses a mutex to protect
+ * the videobuf2 queue operations by serializing calls to videobuf2 and a
+ * spinlock to protect the IRQ queue that holds the buffers to be processed by
+ * the driver.
  */
 
-void uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
-                    int drop_corrupted)
-{
-        mutex_init(&queue->mutex);
-        spin_lock_init(&queue->irqlock);
-        INIT_LIST_HEAD(&queue->mainqueue);
-        INIT_LIST_HEAD(&queue->irqqueue);
-        queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;
-        queue->type = type;
-}
-
-/*
- * Free the video buffers.
- *
- * This function must be called with the queue lock held.
+/* -----------------------------------------------------------------------------
+ * videobuf2 queue operations
  */
-static int __uvc_free_buffers(struct uvc_video_queue *queue)
+
+static int uvc_queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
+                           unsigned int *nbuffers, unsigned int *nplanes,
+                           unsigned int sizes[], void *alloc_ctxs[])
 {
-        unsigned int i;
+        struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
+        struct uvc_streaming *stream =
+                        container_of(queue, struct uvc_streaming, queue);
 
-        for (i = 0; i < queue->count; ++i) {
-                if (queue->buffer[i].vma_use_count != 0)
-                        return -EBUSY;
-        }
+        if (*nbuffers > UVC_MAX_VIDEO_BUFFERS)
+                *nbuffers = UVC_MAX_VIDEO_BUFFERS;
 
-        if (queue->count) {
-                uvc_queue_cancel(queue, 0);
-                INIT_LIST_HEAD(&queue->mainqueue);
-                vfree(queue->mem);
-                queue->count = 0;
-        }
+        *nplanes = 1;
+
+        sizes[0] = stream->ctrl.dwMaxVideoFrameSize;
 
         return 0;
 }
 
-int uvc_free_buffers(struct uvc_video_queue *queue)
+static int uvc_buffer_prepare(struct vb2_buffer *vb)
 {
-        int ret;
+        struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
+        struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
 
-        mutex_lock(&queue->mutex);
-        ret = __uvc_free_buffers(queue);
-        mutex_unlock(&queue->mutex);
+        if (vb->v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
+            vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
+                uvc_trace(UVC_TRACE_CAPTURE, "[E] Bytes used out of bounds.\n");
+                return -EINVAL;
+        }
 
-        return ret;
-}
+        if (unlikely(queue->flags & UVC_QUEUE_DISCONNECTED))
+                return -ENODEV;
 
-/*
- * Allocate the video buffers.
- *
- * Pages are reserved to make sure they will not be swapped, as they will be
- * filled in the URB completion handler.
- *
- * Buffers will be individually mapped, so they must all be page aligned.
- */
-int uvc_alloc_buffers(struct uvc_video_queue *queue, unsigned int nbuffers,
-                unsigned int buflength)
-{
-        unsigned int bufsize = PAGE_ALIGN(buflength);
-        unsigned int i;
-        void *mem = NULL;
-        int ret;
+        buf->state = UVC_BUF_STATE_QUEUED;
+        buf->error = 0;
+        buf->mem = vb2_plane_vaddr(vb, 0);
+        buf->length = vb2_plane_size(vb, 0);
+        if (vb->v4l2_buf.type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
+                buf->bytesused = 0;
+        else
+                buf->bytesused = vb2_get_plane_payload(vb, 0);
 
-        if (nbuffers > UVC_MAX_VIDEO_BUFFERS)
-                nbuffers = UVC_MAX_VIDEO_BUFFERS;
+        return 0;
+}
 
-        mutex_lock(&queue->mutex);
+static void uvc_buffer_queue(struct vb2_buffer *vb)
+{
+        struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
+        struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
+        unsigned long flags;
 
-        if ((ret = __uvc_free_buffers(queue)) < 0)
-                goto done;
+        spin_lock_irqsave(&queue->irqlock, flags);
+        if (likely(!(queue->flags & UVC_QUEUE_DISCONNECTED))) {
+                list_add_tail(&buf->queue, &queue->irqqueue);
+        } else {
+                /* If the device is disconnected return the buffer to userspace
+                 * directly. The next QBUF call will fail with -ENODEV.
+                 */
+                buf->state = UVC_BUF_STATE_ERROR;
+                vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
+        }
 
-        /* Bail out if no buffers should be allocated. */
-        if (nbuffers == 0)
-                goto done;
+        spin_unlock_irqrestore(&queue->irqlock, flags);
+}
 
-        /* Decrement the number of buffers until allocation succeeds. */
-        for (; nbuffers > 0; --nbuffers) {
-                mem = vmalloc_32(nbuffers * bufsize);
-                if (mem != NULL)
-                        break;
-        }
+static int uvc_buffer_finish(struct vb2_buffer *vb)
+{
+        struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
+        struct uvc_streaming *stream =
+                        container_of(queue, struct uvc_streaming, queue);
+        struct uvc_buffer *buf = container_of(vb, struct uvc_buffer, buf);
 
-        if (mem == NULL) {
-                ret = -ENOMEM;
-                goto done;
-        }
+        uvc_video_clock_update(stream, &vb->v4l2_buf, buf);
+        return 0;
+}
 
-        for (i = 0; i < nbuffers; ++i) {
-                memset(&queue->buffer[i], 0, sizeof queue->buffer[i]);
-                queue->buffer[i].buf.index = i;
-                queue->buffer[i].buf.m.offset = i * bufsize;
-                queue->buffer[i].buf.length = buflength;
-                queue->buffer[i].buf.type = queue->type;
-                queue->buffer[i].buf.field = V4L2_FIELD_NONE;
-                queue->buffer[i].buf.memory = V4L2_MEMORY_MMAP;
-                queue->buffer[i].buf.flags = 0;
-                init_waitqueue_head(&queue->buffer[i].wait);
-        }
+static struct vb2_ops uvc_queue_qops = {
+        .queue_setup = uvc_queue_setup,
+        .buf_prepare = uvc_buffer_prepare,
+        .buf_queue = uvc_buffer_queue,
+        .buf_finish = uvc_buffer_finish,
+};
 
-        queue->mem = mem;
-        queue->count = nbuffers;
-        queue->buf_size = bufsize;
-        ret = nbuffers;
+void uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
+                    int drop_corrupted)
+{
+        queue->queue.type = type;
+        queue->queue.io_modes = VB2_MMAP;
+        queue->queue.drv_priv = queue;
+        queue->queue.buf_struct_size = sizeof(struct uvc_buffer);
+        queue->queue.ops = &uvc_queue_qops;
+        queue->queue.mem_ops = &vb2_vmalloc_memops;
+        vb2_queue_init(&queue->queue);
 
-done:
-        mutex_unlock(&queue->mutex);
-        return ret;
+        mutex_init(&queue->mutex);
+        spin_lock_init(&queue->irqlock);
+        INIT_LIST_HEAD(&queue->irqqueue);
+        queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;
 }
 
-/*
- * Check if buffers have been allocated.
+/* -----------------------------------------------------------------------------
+ * V4L2 queue operations
  */
-int uvc_queue_allocated(struct uvc_video_queue *queue)
+
+int uvc_alloc_buffers(struct uvc_video_queue *queue,
+                      struct v4l2_requestbuffers *rb)
 {
-        int allocated;
+        int ret;
 
         mutex_lock(&queue->mutex);
-        allocated = queue->count != 0;
+        ret = vb2_reqbufs(&queue->queue, rb);
         mutex_unlock(&queue->mutex);
 
-        return allocated;
+        return ret ? ret : rb->count;
 }
 
-static void __uvc_query_buffer(struct uvc_buffer *buf,
-                struct v4l2_buffer *v4l2_buf)
+void uvc_free_buffers(struct uvc_video_queue *queue)
 {
-        memcpy(v4l2_buf, &buf->buf, sizeof *v4l2_buf);
-
-        if (buf->vma_use_count)
-                v4l2_buf->flags |= V4L2_BUF_FLAG_MAPPED;
-
-        switch (buf->state) {
-        case UVC_BUF_STATE_ERROR:
-        case UVC_BUF_STATE_DONE:
-                v4l2_buf->flags |= V4L2_BUF_FLAG_DONE;
-                break;
-        case UVC_BUF_STATE_QUEUED:
-        case UVC_BUF_STATE_ACTIVE:
-        case UVC_BUF_STATE_READY:
-                v4l2_buf->flags |= V4L2_BUF_FLAG_QUEUED;
-                break;
-        case UVC_BUF_STATE_IDLE:
-        default:
-                break;
-        }
+        mutex_lock(&queue->mutex);
+        vb2_queue_release(&queue->queue);
+        mutex_unlock(&queue->mutex);
 }
 
-int uvc_query_buffer(struct uvc_video_queue *queue,
-                struct v4l2_buffer *v4l2_buf)
+int uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
 {
-        int ret = 0;
+        int ret;
 
         mutex_lock(&queue->mutex);
-        if (v4l2_buf->index >= queue->count) {
-                ret = -EINVAL;
-                goto done;
-        }
-
-        __uvc_query_buffer(&queue->buffer[v4l2_buf->index], v4l2_buf);
-
-done:
+        ret = vb2_querybuf(&queue->queue, buf);
         mutex_unlock(&queue->mutex);
+
         return ret;
 }
 
-/*
- * Queue a video buffer. Attempting to queue a buffer that has already been
- * queued will return -EINVAL.
- */
-int uvc_queue_buffer(struct uvc_video_queue *queue,
-        struct v4l2_buffer *v4l2_buf)
+int uvc_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
 {
-        struct uvc_buffer *buf;
-        unsigned long flags;
-        int ret = 0;
-
-        uvc_trace(UVC_TRACE_CAPTURE, "Queuing buffer %u.\n", v4l2_buf->index);
-
-        if (v4l2_buf->type != queue->type ||
-            v4l2_buf->memory != V4L2_MEMORY_MMAP) {
-                uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer type (%u) "
-                        "and/or memory (%u).\n", v4l2_buf->type,
-                        v4l2_buf->memory);
-                return -EINVAL;
-        }
+        int ret;
 
         mutex_lock(&queue->mutex);
-        if (v4l2_buf->index >= queue->count) {
-                uvc_trace(UVC_TRACE_CAPTURE, "[E] Out of range index.\n");
-                ret = -EINVAL;
-                goto done;
-        }
-
-        buf = &queue->buffer[v4l2_buf->index];
-        if (buf->state != UVC_BUF_STATE_IDLE) {
-                uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer state "
-                        "(%u).\n", buf->state);
-                ret = -EINVAL;
-                goto done;
-        }
-
-        if (v4l2_buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
-            v4l2_buf->bytesused > buf->buf.length) {
-                uvc_trace(UVC_TRACE_CAPTURE, "[E] Bytes used out of bounds.\n");
-                ret = -EINVAL;
-                goto done;
-        }
-
-        spin_lock_irqsave(&queue->irqlock, flags);
-        if (queue->flags & UVC_QUEUE_DISCONNECTED) {
-                spin_unlock_irqrestore(&queue->irqlock, flags);
-                ret = -ENODEV;
-                goto done;
-        }
-        buf->state = UVC_BUF_STATE_QUEUED;
-        if (v4l2_buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                buf->buf.bytesused = 0;
-        else
-                buf->buf.bytesused = v4l2_buf->bytesused;
-
-        list_add_tail(&buf->stream, &queue->mainqueue);
-        list_add_tail(&buf->queue, &queue->irqqueue);
-        spin_unlock_irqrestore(&queue->irqlock, flags);
-
-done:
+        ret = vb2_qbuf(&queue->queue, buf);
         mutex_unlock(&queue->mutex);
-        return ret;
-}
 
-static int uvc_queue_waiton(struct uvc_buffer *buf, int nonblocking)
-{
-        if (nonblocking) {
-                return (buf->state != UVC_BUF_STATE_QUEUED &&
-                        buf->state != UVC_BUF_STATE_ACTIVE &&
-                        buf->state != UVC_BUF_STATE_READY)
-                        ? 0 : -EAGAIN;
-        }
-
-        return wait_event_interruptible(buf->wait,
-                buf->state != UVC_BUF_STATE_QUEUED &&
-                buf->state != UVC_BUF_STATE_ACTIVE &&
-                buf->state != UVC_BUF_STATE_READY);
+        return ret;
 }
 
-/*
- * Dequeue a video buffer. If nonblocking is false, block until a buffer is
- * available.
- */
-int uvc_dequeue_buffer(struct uvc_video_queue *queue,
-                struct v4l2_buffer *v4l2_buf, int nonblocking)
+int uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
+                       int nonblocking)
 {
-        struct uvc_buffer *buf;
-        int ret = 0;
-
-        if (v4l2_buf->type != queue->type ||
-            v4l2_buf->memory != V4L2_MEMORY_MMAP) {
-                uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer type (%u) "
-                        "and/or memory (%u).\n", v4l2_buf->type,
-                        v4l2_buf->memory);
-                return -EINVAL;
-        }
+        int ret;
 
         mutex_lock(&queue->mutex);
-        if (list_empty(&queue->mainqueue)) {
-                uvc_trace(UVC_TRACE_CAPTURE, "[E] Empty buffer queue.\n");
-                ret = -EINVAL;
-                goto done;
-        }
-
-        buf = list_first_entry(&queue->mainqueue, struct uvc_buffer, stream);
-        if ((ret = uvc_queue_waiton(buf, nonblocking)) < 0)
-                goto done;
-
-        uvc_trace(UVC_TRACE_CAPTURE, "Dequeuing buffer %u (%u, %u bytes).\n",
-                buf->buf.index, buf->state, buf->buf.bytesused);
-
-        switch (buf->state) {
-        case UVC_BUF_STATE_ERROR:
-                uvc_trace(UVC_TRACE_CAPTURE, "[W] Corrupted data "
-                        "(transmission error).\n");
-                ret = -EIO;
-        case UVC_BUF_STATE_DONE:
-                buf->state = UVC_BUF_STATE_IDLE;
-                break;
-
-        case UVC_BUF_STATE_IDLE:
-        case UVC_BUF_STATE_QUEUED:
-        case UVC_BUF_STATE_ACTIVE:
-        case UVC_BUF_STATE_READY:
-        default:
-                uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer state %u "
-                        "(driver bug?).\n", buf->state);
-                ret = -EINVAL;
-                goto done;
-        }
-
-        list_del(&buf->stream);
-        __uvc_query_buffer(buf, v4l2_buf);
-
-done:
+        ret = vb2_dqbuf(&queue->queue, buf, nonblocking);
         mutex_unlock(&queue->mutex);
-        return ret;
-}
 
-/*
- * VMA operations.
- */
-static void uvc_vm_open(struct vm_area_struct *vma)
-{
-        struct uvc_buffer *buffer = vma->vm_private_data;
-        buffer->vma_use_count++;
-}
-
-static void uvc_vm_close(struct vm_area_struct *vma)
-{
-        struct uvc_buffer *buffer = vma->vm_private_data;
-        buffer->vma_use_count--;
+        return ret;
 }
 
-static const struct vm_operations_struct uvc_vm_ops = {
-        .open           = uvc_vm_open,
-        .close          = uvc_vm_close,
-};
-
-/*
- * Memory-map a video buffer.
- *
- * This function implements video buffers memory mapping and is intended to be
- * used by the device mmap handler.
- */
 int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
 {
-        struct uvc_buffer *uninitialized_var(buffer);
-        struct page *page;
-        unsigned long addr, start, size;
-        unsigned int i;
-        int ret = 0;
-
-        start = vma->vm_start;
-        size = vma->vm_end - vma->vm_start;
+        int ret;
 
         mutex_lock(&queue->mutex);
+        ret = vb2_mmap(&queue->queue, vma);
+        mutex_unlock(&queue->mutex);
 
-        for (i = 0; i < queue->count; ++i) {
-                buffer = &queue->buffer[i];
-                if ((buffer->buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
-                        break;
-        }
-
-        if (i == queue->count || PAGE_ALIGN(size) != queue->buf_size) {
-                ret = -EINVAL;
-                goto done;
-        }
-
-        /*
-         * VM_IO marks the area as being an mmaped region for I/O to a
-         * device. It also prevents the region from being core dumped.
-         */
-        vma->vm_flags |= VM_IO;
-
-        addr = (unsigned long)queue->mem + buffer->buf.m.offset;
-#ifdef CONFIG_MMU
-        while (size > 0) {
-                page = vmalloc_to_page((void *)addr);
-                if ((ret = vm_insert_page(vma, start, page)) < 0)
-                        goto done;
-
-                start += PAGE_SIZE;
-                addr += PAGE_SIZE;
-                size -= PAGE_SIZE;
-        }
-#endif
+        return ret;
+}
 
-        vma->vm_ops = &uvc_vm_ops;
-        vma->vm_private_data = buffer;
-        uvc_vm_open(vma);
+unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
+                            poll_table *wait)
+{
+        unsigned int ret;
 
-done:
+        mutex_lock(&queue->mutex);
+        ret = vb2_poll(&queue->queue, file, wait);
         mutex_unlock(&queue->mutex);
+
         return ret;
 }
 
-/*
- * Poll the video queue.
+/* -----------------------------------------------------------------------------
  *
- * This function implements video queue polling and is intended to be used by
- * the device poll handler.
  */
-unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
-                poll_table *wait)
+
+/*
+ * Check if buffers have been allocated.
+ */
+int uvc_queue_allocated(struct uvc_video_queue *queue)
 {
-        struct uvc_buffer *buf;
-        unsigned int mask = 0;
+        int allocated;
 
         mutex_lock(&queue->mutex);
-        if (list_empty(&queue->mainqueue)) {
-                mask |= POLLERR;
-                goto done;
-        }
-        buf = list_first_entry(&queue->mainqueue, struct uvc_buffer, stream);
-
-        poll_wait(file, &buf->wait, wait);
-        if (buf->state == UVC_BUF_STATE_DONE ||
-            buf->state == UVC_BUF_STATE_ERROR) {
-                if (queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                        mask |= POLLIN | POLLRDNORM;
-                else
-                        mask |= POLLOUT | POLLWRNORM;
-        }
-
-done:
+        allocated = vb2_is_busy(&queue->queue);
         mutex_unlock(&queue->mutex);
-        return mask;
+
+        return allocated;
 }
 
 #ifndef CONFIG_MMU
@@ -515,7 +260,7 @@ unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
                 ret = -EINVAL;
                 goto done;
         }
-        ret = (unsigned long)queue->mem + buffer->buf.m.offset;
+        ret = (unsigned long)buf->mem;
 done:
         mutex_unlock(&queue->mutex);
         return ret;
@@ -540,27 +285,24 @@ done:
  */
 int uvc_queue_enable(struct uvc_video_queue *queue, int enable)
 {
-        unsigned int i;
-        int ret = 0;
+        unsigned long flags;
+        int ret;
 
         mutex_lock(&queue->mutex);
         if (enable) {
-                if (uvc_queue_streaming(queue)) {
-                        ret = -EBUSY;
+                ret = vb2_streamon(&queue->queue, queue->queue.type);
+                if (ret < 0)
                         goto done;
-                }
-                queue->flags |= UVC_QUEUE_STREAMING;
+
                 queue->buf_used = 0;
         } else {
-                uvc_queue_cancel(queue, 0);
-                INIT_LIST_HEAD(&queue->mainqueue);
-
-                for (i = 0; i < queue->count; ++i) {
-                        queue->buffer[i].error = 0;
-                        queue->buffer[i].state = UVC_BUF_STATE_IDLE;
-                }
+                ret = vb2_streamoff(&queue->queue, queue->queue.type);
+                if (ret < 0)
+                        goto done;
 
-                queue->flags &= ~UVC_QUEUE_STREAMING;
+                spin_lock_irqsave(&queue->irqlock, flags);
+                INIT_LIST_HEAD(&queue->irqqueue);
+                spin_unlock_irqrestore(&queue->irqlock, flags);
         }
 
 done:
@@ -591,12 +333,12 @@ void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
                                        queue);
                 list_del(&buf->queue);
                 buf->state = UVC_BUF_STATE_ERROR;
-                wake_up(&buf->wait);
+                vb2_buffer_done(&buf->buf, VB2_BUF_STATE_ERROR);
         }
         /* This must be protected by the irqlock spinlock to avoid race
-         * conditions between uvc_queue_buffer and the disconnection event that
+         * conditions between uvc_buffer_queue and the disconnection event that
          * could result in an interruptible wait in uvc_dequeue_buffer. Do not
-         * blindly replace this logic by checking for the UVC_DEV_DISCONNECTED
+         * blindly replace this logic by checking for the UVC_QUEUE_DISCONNECTED
          * state outside the queue code.
          */
         if (disconnect)
@@ -613,14 +355,12 @@ struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
         if ((queue->flags & UVC_QUEUE_DROP_CORRUPTED) && buf->error) {
                 buf->error = 0;
                 buf->state = UVC_BUF_STATE_QUEUED;
-                buf->buf.bytesused = 0;
+                vb2_set_plane_payload(&buf->buf, 0, 0);
                 return buf;
         }
 
         spin_lock_irqsave(&queue->irqlock, flags);
         list_del(&buf->queue);
-        buf->error = 0;
-        buf->state = UVC_BUF_STATE_DONE;
         if (!list_empty(&queue->irqqueue))
                 nextbuf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
                                            queue);
@@ -628,7 +368,9 @@ struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
                 nextbuf = NULL;
         spin_unlock_irqrestore(&queue->irqlock, flags);
 
-        wake_up(&buf->wait);
+        buf->state = buf->error ? VB2_BUF_STATE_ERROR : UVC_BUF_STATE_DONE;
+        vb2_set_plane_payload(&buf->buf, 0, buf->bytesused);
+        vb2_buffer_done(&buf->buf, VB2_BUF_STATE_DONE);
+
         return nextbuf;
 }
-
diff --git a/drivers/media/video/uvc/uvc_v4l2.c b/drivers/media/video/uvc/uvc_v4l2.c
index dadf11f704dc..2ae4f880ea05 100644
--- a/drivers/media/video/uvc/uvc_v4l2.c
+++ b/drivers/media/video/uvc/uvc_v4l2.c
@@ -58,6 +58,15 @@ static int uvc_ioctl_ctrl_map(struct uvc_video_chain *chain,
                 break;
 
         case V4L2_CTRL_TYPE_MENU:
+                /* Prevent excessive memory consumption, as well as integer
+                 * overflows.
+                 */
+                if (xmap->menu_count == 0 ||
+                    xmap->menu_count > UVC_MAX_CONTROL_MENU_ENTRIES) {
+                        ret = -EINVAL;
+                        goto done;
+                }
+
                 size = xmap->menu_count * sizeof(*map->menu_info);
                 map->menu_info = kmalloc(size, GFP_KERNEL);
                 if (map->menu_info == NULL) {
@@ -513,10 +522,7 @@ static int uvc_v4l2_release(struct file *file)
         /* Only free resources if this is a privileged handle. */
         if (uvc_has_privileges(handle)) {
                 uvc_video_enable(stream, 0);
-
-                if (uvc_free_buffers(&stream->queue) < 0)
-                        uvc_printk(KERN_ERR, "uvc_v4l2_release: Unable to "
-                                        "free buffers.\n");
+                uvc_free_buffers(&stream->queue);
         }
 
         /* Release the file handle. */
@@ -914,19 +920,11 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
 
         /* Buffers & streaming */
         case VIDIOC_REQBUFS:
-        {
-                struct v4l2_requestbuffers *rb = arg;
-
-                if (rb->type != stream->type ||
-                    rb->memory != V4L2_MEMORY_MMAP)
-                        return -EINVAL;
-
                 if ((ret = uvc_acquire_privileges(handle)) < 0)
                         return ret;
 
                 mutex_lock(&stream->mutex);
-                ret = uvc_alloc_buffers(&stream->queue, rb->count,
-                                        stream->ctrl.dwMaxVideoFrameSize);
+                ret = uvc_alloc_buffers(&stream->queue, arg);
                 mutex_unlock(&stream->mutex);
                 if (ret < 0)
                         return ret;
@@ -934,18 +932,13 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 if (ret == 0)
                         uvc_dismiss_privileges(handle);
 
-                rb->count = ret;
                 ret = 0;
                 break;
-        }
 
         case VIDIOC_QUERYBUF:
         {
                 struct v4l2_buffer *buf = arg;
 
-                if (buf->type != stream->type)
-                        return -EINVAL;
-
                 if (!uvc_has_privileges(handle))
                         return -EBUSY;
 
diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
index b015e8e5e8b0..c7e69b8f81c9 100644
--- a/drivers/media/video/uvc/uvc_video.c
+++ b/drivers/media/video/uvc/uvc_video.c
@@ -351,25 +351,553 @@ done:
         return ret;
 }
 
-int uvc_commit_video(struct uvc_streaming *stream,
-        struct uvc_streaming_control *probe)
+static int uvc_commit_video(struct uvc_streaming *stream,
+                            struct uvc_streaming_control *probe)
 {
         return uvc_set_video_ctrl(stream, probe, 0);
 }
 
+/* -----------------------------------------------------------------------------
+ * Clocks and timestamps
+ */
+
+static void
+uvc_video_clock_decode(struct uvc_streaming *stream, struct uvc_buffer *buf,
+                       const __u8 *data, int len)
+{
+        struct uvc_clock_sample *sample;
+        unsigned int header_size;
+        bool has_pts = false;
+        bool has_scr = false;
+        unsigned long flags;
+        struct timespec ts;
+        u16 host_sof;
+        u16 dev_sof;
+
+        switch (data[1] & (UVC_STREAM_PTS | UVC_STREAM_SCR)) {
+        case UVC_STREAM_PTS | UVC_STREAM_SCR:
+                header_size = 12;
+                has_pts = true;
+                has_scr = true;
+                break;
+        case UVC_STREAM_PTS:
+                header_size = 6;
+                has_pts = true;
+                break;
+        case UVC_STREAM_SCR:
+                header_size = 8;
+                has_scr = true;
+                break;
+        default:
+                header_size = 2;
+                break;
+        }
+
+        /* Check for invalid headers. */
+        if (len < header_size)
+                return;
+
+        /* Extract the timestamps:
+         *
+         * - store the frame PTS in the buffer structure
+         * - if the SCR field is present, retrieve the host SOF counter and
+         *   kernel timestamps and store them with the SCR STC and SOF fields
+         *   in the ring buffer
+         */
+        if (has_pts && buf != NULL)
+                buf->pts = get_unaligned_le32(&data[2]);
+
+        if (!has_scr)
+                return;
+
+        /* To limit the amount of data, drop SCRs with an SOF identical to the
+         * previous one.
+         */
+        dev_sof = get_unaligned_le16(&data[header_size - 2]);
+        if (dev_sof == stream->clock.last_sof)
+                return;
+
+        stream->clock.last_sof = dev_sof;
+
+        host_sof = usb_get_current_frame_number(stream->dev->udev);
+        ktime_get_ts(&ts);
+
+        /* The UVC specification allows device implementations that can't obtain
+         * the USB frame number to keep their own frame counters as long as they
+         * match the size and frequency of the frame number associated with USB
+         * SOF tokens. The SOF values sent by such devices differ from the USB
+         * SOF tokens by a fixed offset that needs to be estimated and accounted
+         * for to make timestamp recovery as accurate as possible.
+         *
+         * The offset is estimated the first time a device SOF value is received
+         * as the difference between the host and device SOF values. As the two
+         * SOF values can differ slightly due to transmission delays, consider
+         * that the offset is null if the difference is not higher than 10 ms
+         * (negative differences can not happen and are thus considered as an
+         * offset). The video commit control wDelay field should be used to
+         * compute a dynamic threshold instead of using a fixed 10 ms value, but
+         * devices don't report reliable wDelay values.
+         *
+         * See uvc_video_clock_host_sof() for an explanation regarding why only
+         * the 8 LSBs of the delta are kept.
+         */
+        if (stream->clock.sof_offset == (u16)-1) {
+                u16 delta_sof = (host_sof - dev_sof) & 255;
+                if (delta_sof >= 10)
+                        stream->clock.sof_offset = delta_sof;
+                else
+                        stream->clock.sof_offset = 0;
+        }
+
+        dev_sof = (dev_sof + stream->clock.sof_offset) & 2047;
+
+        spin_lock_irqsave(&stream->clock.lock, flags);
+
+        sample = &stream->clock.samples[stream->clock.head];
+        sample->dev_stc = get_unaligned_le32(&data[header_size - 6]);
+        sample->dev_sof = dev_sof;
+        sample->host_sof = host_sof;
+        sample->host_ts = ts;
+
+        /* Update the sliding window head and count. */
+        stream->clock.head = (stream->clock.head + 1) % stream->clock.size;
+
+        if (stream->clock.count < stream->clock.size)
+                stream->clock.count++;
+
+        spin_unlock_irqrestore(&stream->clock.lock, flags);
+}
+
+static int uvc_video_clock_init(struct uvc_streaming *stream)
+{
+        struct uvc_clock *clock = &stream->clock;
+
+        spin_lock_init(&clock->lock);
+        clock->head = 0;
+        clock->count = 0;
+        clock->size = 32;
+        clock->last_sof = -1;
+        clock->sof_offset = -1;
+
+        clock->samples = kmalloc(clock->size * sizeof(*clock->samples),
+                                 GFP_KERNEL);
+        if (clock->samples == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+static void uvc_video_clock_cleanup(struct uvc_streaming *stream)
+{
+        kfree(stream->clock.samples);
+        stream->clock.samples = NULL;
+}
+
+/*
+ * uvc_video_clock_host_sof - Return the host SOF value for a clock sample
+ *
+ * Host SOF counters reported by usb_get_current_frame_number() usually don't
+ * cover the whole 11-bits SOF range (0-2047) but are limited to the HCI frame
+ * schedule window. They can be limited to 8, 9 or 10 bits depending on the host
+ * controller and its configuration.
+ *
+ * We thus need to recover the SOF value corresponding to the host frame number.
+ * As the device and host frame numbers are sampled in a short interval, the
+ * difference between their values should be equal to a small delta plus an
+ * integer multiple of 256 caused by the host frame number limited precision.
+ *
+ * To obtain the recovered host SOF value, compute the small delta by masking
+ * the high bits of the host frame counter and device SOF difference and add it
+ * to the device SOF value.
+ */
+static u16 uvc_video_clock_host_sof(const struct uvc_clock_sample *sample)
+{
+        /* The delta value can be negative. */
+        s8 delta_sof;
+
+        delta_sof = (sample->host_sof - sample->dev_sof) & 255;
+
+        return (sample->dev_sof + delta_sof) & 2047;
+}
+
+/*
+ * uvc_video_clock_update - Update the buffer timestamp
+ *
+ * This function converts the buffer PTS timestamp to the host clock domain by
+ * going through the USB SOF clock domain and stores the result in the V4L2
+ * buffer timestamp field.
+ *
+ * The relationship between the device clock and the host clock isn't known.
+ * However, the device and the host share the common USB SOF clock which can be
+ * used to recover that relationship.
+ *
+ * The relationship between the device clock and the USB SOF clock is considered
+ * to be linear over the clock samples sliding window and is given by
+ *
+ * SOF = m * PTS + p
+ *
+ * Several methods to compute the slope (m) and intercept (p) can be used. As
+ * the clock drift should be small compared to the sliding window size, we
+ * assume that the line that goes through the points at both ends of the window
+ * is a good approximation. Naming those points P1 and P2, we get
+ *
+ * SOF = (SOF2 - SOF1) / (STC2 - STC1) * PTS
+ *     + (SOF1 * STC2 - SOF2 * STC1) / (STC2 - STC1)
+ *
+ * or
+ *
+ * SOF = ((SOF2 - SOF1) * PTS + SOF1 * STC2 - SOF2 * STC1) / (STC2 - STC1)   (1)
+ *
+ * to avoid loosing precision in the division. Similarly, the host timestamp is
+ * computed with
+ *
+ * TS = ((TS2 - TS1) * PTS + TS1 * SOF2 - TS2 * SOF1) / (SOF2 - SOF1)        (2)
+ *
+ * SOF values are coded on 11 bits by USB. We extend their precision with 16
+ * decimal bits, leading to a 11.16 coding.
+ *
+ * TODO: To avoid surprises with device clock values, PTS/STC timestamps should
+ * be normalized using the nominal device clock frequency reported through the
+ * UVC descriptors.
+ *
+ * Both the PTS/STC and SOF counters roll over, after a fixed but device
+ * specific amount of time for PTS/STC and after 2048ms for SOF. As long as the
+ * sliding window size is smaller than the rollover period, differences computed
+ * on unsigned integers will produce the correct result. However, the p term in
+ * the linear relations will be miscomputed.
+ *
+ * To fix the issue, we subtract a constant from the PTS and STC values to bring
+ * PTS to half the 32 bit STC range. The sliding window STC values then fit into
+ * the 32 bit range without any rollover.
+ *
+ * Similarly, we add 2048 to the device SOF values to make sure that the SOF
+ * computed by (1) will never be smaller than 0. This offset is then compensated
+ * by adding 2048 to the SOF values used in (2). However, this doesn't prevent
+ * rollovers between (1) and (2): the SOF value computed by (1) can be slightly
+ * lower than 4096, and the host SOF counters can have rolled over to 2048. This
+ * case is handled by subtracting 2048 from the SOF value if it exceeds the host
+ * SOF value at the end of the sliding window.
+ *
+ * Finally we subtract a constant from the host timestamps to bring the first
+ * timestamp of the sliding window to 1s.
+ */
+void uvc_video_clock_update(struct uvc_streaming *stream,
+                            struct v4l2_buffer *v4l2_buf,
+                            struct uvc_buffer *buf)
+{
+        struct uvc_clock *clock = &stream->clock;
+        struct uvc_clock_sample *first;
+        struct uvc_clock_sample *last;
+        unsigned long flags;
+        struct timespec ts;
+        u32 delta_stc;
+        u32 y1, y2;
+        u32 x1, x2;
+        u32 mean;
+        u32 sof;
+        u32 div;
+        u32 rem;
+        u64 y;
+
+        spin_lock_irqsave(&clock->lock, flags);
+
+        if (clock->count < clock->size)
+                goto done;
+
+        first = &clock->samples[clock->head];
+        last = &clock->samples[(clock->head - 1) % clock->size];
+
+        /* First step, PTS to SOF conversion. */
+        delta_stc = buf->pts - (1UL << 31);
+        x1 = first->dev_stc - delta_stc;
+        x2 = last->dev_stc - delta_stc;
+        y1 = (first->dev_sof + 2048) << 16;
+        y2 = (last->dev_sof + 2048) << 16;
+
+        if (y2 < y1)
+                y2 += 2048 << 16;
+
+        y = (u64)(y2 - y1) * (1ULL << 31) + (u64)y1 * (u64)x2
+          - (u64)y2 * (u64)x1;
+        y = div_u64(y, x2 - x1);
+
+        sof = y;
+
+        uvc_trace(UVC_TRACE_CLOCK, "%s: PTS %u y %llu.%06llu SOF %u.%06llu "
+                  "(x1 %u x2 %u y1 %u y2 %u SOF offset %u)\n",
+                  stream->dev->name, buf->pts,
+                  y >> 16, div_u64((y & 0xffff) * 1000000, 65536),
+                  sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
+                  x1, x2, y1, y2, clock->sof_offset);
+
+        /* Second step, SOF to host clock conversion. */
+        ts = timespec_sub(last->host_ts, first->host_ts);
+        x1 = (uvc_video_clock_host_sof(first) + 2048) << 16;
+        x2 = (uvc_video_clock_host_sof(last) + 2048) << 16;
+        y1 = NSEC_PER_SEC;
+        y2 = (ts.tv_sec + 1) * NSEC_PER_SEC + ts.tv_nsec;
+
+        if (x2 < x1)
+                x2 += 2048 << 16;
+
+        /* Interpolated and host SOF timestamps can wrap around at slightly
+         * different times. Handle this by adding or removing 2048 to or from
+         * the computed SOF value to keep it close to the SOF samples mean
+         * value.
+         */
+        mean = (x1 + x2) / 2;
+        if (mean - (1024 << 16) > sof)
+                sof += 2048 << 16;
+        else if (sof > mean + (1024 << 16))
+                sof -= 2048 << 16;
+
+        y = (u64)(y2 - y1) * (u64)sof + (u64)y1 * (u64)x2
+          - (u64)y2 * (u64)x1;
+        y = div_u64(y, x2 - x1);
+
+        div = div_u64_rem(y, NSEC_PER_SEC, &rem);
+        ts.tv_sec = first->host_ts.tv_sec - 1 + div;
+        ts.tv_nsec = first->host_ts.tv_nsec + rem;
+        if (ts.tv_nsec >= NSEC_PER_SEC) {
+                ts.tv_sec++;
+                ts.tv_nsec -= NSEC_PER_SEC;
+        }
+
+        uvc_trace(UVC_TRACE_CLOCK, "%s: SOF %u.%06llu y %llu ts %lu.%06lu "
+                  "buf ts %lu.%06lu (x1 %u/%u/%u x2 %u/%u/%u y1 %u y2 %u)\n",
+                  stream->dev->name,
+                  sof >> 16, div_u64(((u64)sof & 0xffff) * 1000000LLU, 65536),
+                  y, ts.tv_sec, ts.tv_nsec / NSEC_PER_USEC,
+                  v4l2_buf->timestamp.tv_sec, v4l2_buf->timestamp.tv_usec,
+                  x1, first->host_sof, first->dev_sof,
+                  x2, last->host_sof, last->dev_sof, y1, y2);
+
+        /* Update the V4L2 buffer. */
+        v4l2_buf->timestamp.tv_sec = ts.tv_sec;
+        v4l2_buf->timestamp.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
+
+done:
+        spin_unlock_irqrestore(&stream->clock.lock, flags);
+}
+
 /* ------------------------------------------------------------------------
- * Video codecs
+ * Stream statistics
  */
 
-/* Values for bmHeaderInfo (Video and Still Image Payload Headers, 2.4.3.3) */
-#define UVC_STREAM_EOH  (1 << 7)
-#define UVC_STREAM_ERR  (1 << 6)
-#define UVC_STREAM_STI  (1 << 5)
-#define UVC_STREAM_RES  (1 << 4)
-#define UVC_STREAM_SCR  (1 << 3)
-#define UVC_STREAM_PTS  (1 << 2)
-#define UVC_STREAM_EOF  (1 << 1)
-#define UVC_STREAM_FID  (1 << 0)
+static void uvc_video_stats_decode(struct uvc_streaming *stream,
+                const __u8 *data, int len)
+{
+        unsigned int header_size;
+        bool has_pts = false;
+        bool has_scr = false;
+        u16 uninitialized_var(scr_sof);
+        u32 uninitialized_var(scr_stc);
+        u32 uninitialized_var(pts);
+
+        if (stream->stats.stream.nb_frames == 0 &&
+            stream->stats.frame.nb_packets == 0)
+                ktime_get_ts(&stream->stats.stream.start_ts);
+
+        switch (data[1] & (UVC_STREAM_PTS | UVC_STREAM_SCR)) {
+        case UVC_STREAM_PTS | UVC_STREAM_SCR:
+                header_size = 12;
+                has_pts = true;
+                has_scr = true;
+                break;
+        case UVC_STREAM_PTS:
+                header_size = 6;
+                has_pts = true;
+                break;
+        case UVC_STREAM_SCR:
+                header_size = 8;
+                has_scr = true;
+                break;
+        default:
+                header_size = 2;
+                break;
+        }
+
+        /* Check for invalid headers. */
+        if (len < header_size || data[0] < header_size) {
+                stream->stats.frame.nb_invalid++;
+                return;
+        }
+
+        /* Extract the timestamps. */
+        if (has_pts)
+                pts = get_unaligned_le32(&data[2]);
+
+        if (has_scr) {
+                scr_stc = get_unaligned_le32(&data[header_size - 6]);
+                scr_sof = get_unaligned_le16(&data[header_size - 2]);
+        }
+
+        /* Is PTS constant through the whole frame ? */
+        if (has_pts && stream->stats.frame.nb_pts) {
+                if (stream->stats.frame.pts != pts) {
+                        stream->stats.frame.nb_pts_diffs++;
+                        stream->stats.frame.last_pts_diff =
+                                stream->stats.frame.nb_packets;
+                }
+        }
+
+        if (has_pts) {
+                stream->stats.frame.nb_pts++;
+                stream->stats.frame.pts = pts;
+        }
+
+        /* Do all frames have a PTS in their first non-empty packet, or before
+         * their first empty packet ?
+         */
+        if (stream->stats.frame.size == 0) {
+                if (len > header_size)
+                        stream->stats.frame.has_initial_pts = has_pts;
+                if (len == header_size && has_pts)
+                        stream->stats.frame.has_early_pts = true;
+        }
+
+        /* Do the SCR.STC and SCR.SOF fields vary through the frame ? */
+        if (has_scr && stream->stats.frame.nb_scr) {
+                if (stream->stats.frame.scr_stc != scr_stc)
+                        stream->stats.frame.nb_scr_diffs++;
+        }
+
+        if (has_scr) {
+                /* Expand the SOF counter to 32 bits and store its value. */
+                if (stream->stats.stream.nb_frames > 0 ||
+                    stream->stats.frame.nb_scr > 0)
+                        stream->stats.stream.scr_sof_count +=
+                                (scr_sof - stream->stats.stream.scr_sof) % 2048;
+                stream->stats.stream.scr_sof = scr_sof;
+
+                stream->stats.frame.nb_scr++;
+                stream->stats.frame.scr_stc = scr_stc;
+                stream->stats.frame.scr_sof = scr_sof;
+
+                if (scr_sof < stream->stats.stream.min_sof)
+                        stream->stats.stream.min_sof = scr_sof;
+                if (scr_sof > stream->stats.stream.max_sof)
+                        stream->stats.stream.max_sof = scr_sof;
+        }
+
+        /* Record the first non-empty packet number. */
+        if (stream->stats.frame.size == 0 && len > header_size)
+                stream->stats.frame.first_data = stream->stats.frame.nb_packets;
+
+        /* Update the frame size. */
+        stream->stats.frame.size += len - header_size;
+
+        /* Update the packets counters. */
+        stream->stats.frame.nb_packets++;
+        if (len > header_size)
+                stream->stats.frame.nb_empty++;
+
+        if (data[1] & UVC_STREAM_ERR)
+                stream->stats.frame.nb_errors++;
+}
+
+static void uvc_video_stats_update(struct uvc_streaming *stream)
+{
+        struct uvc_stats_frame *frame = &stream->stats.frame;
+
+        uvc_trace(UVC_TRACE_STATS, "frame %u stats: %u/%u/%u packets, "
+                  "%u/%u/%u pts (%searly %sinitial), %u/%u scr, "
+                  "last pts/stc/sof %u/%u/%u\n",
+                  stream->sequence, frame->first_data,
+                  frame->nb_packets - frame->nb_empty, frame->nb_packets,
+                  frame->nb_pts_diffs, frame->last_pts_diff, frame->nb_pts,
+                  frame->has_early_pts ? "" : "!",
+                  frame->has_initial_pts ? "" : "!",
+                  frame->nb_scr_diffs, frame->nb_scr,
+                  frame->pts, frame->scr_stc, frame->scr_sof);
+
+        stream->stats.stream.nb_frames++;
+        stream->stats.stream.nb_packets += stream->stats.frame.nb_packets;
+        stream->stats.stream.nb_empty += stream->stats.frame.nb_empty;
+        stream->stats.stream.nb_errors += stream->stats.frame.nb_errors;
+        stream->stats.stream.nb_invalid += stream->stats.frame.nb_invalid;
+
+        if (frame->has_early_pts)
+                stream->stats.stream.nb_pts_early++;
+        if (frame->has_initial_pts)
+                stream->stats.stream.nb_pts_initial++;
+        if (frame->last_pts_diff <= frame->first_data)
+                stream->stats.stream.nb_pts_constant++;
+        if (frame->nb_scr >= frame->nb_packets - frame->nb_empty)
+                stream->stats.stream.nb_scr_count_ok++;
+        if (frame->nb_scr_diffs + 1 == frame->nb_scr)
+                stream->stats.stream.nb_scr_diffs_ok++;
+
+        memset(&stream->stats.frame, 0, sizeof(stream->stats.frame));
+}
+
+size_t uvc_video_stats_dump(struct uvc_streaming *stream, char *buf,
+                            size_t size)
+{
+        unsigned int scr_sof_freq;
+        unsigned int duration;
+        struct timespec ts;
+        size_t count = 0;
+
+        ts.tv_sec = stream->stats.stream.stop_ts.tv_sec
+                  - stream->stats.stream.start_ts.tv_sec;
+        ts.tv_nsec = stream->stats.stream.stop_ts.tv_nsec
+                   - stream->stats.stream.start_ts.tv_nsec;
+        if (ts.tv_nsec < 0) {
+                ts.tv_sec--;
+                ts.tv_nsec += 1000000000;
+        }
+
+        /* Compute the SCR.SOF frequency estimate. At the nominal 1kHz SOF
+         * frequency this will not overflow before more than 1h.
+         */
+        duration = ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
+        if (duration != 0)
+                scr_sof_freq = stream->stats.stream.scr_sof_count * 1000
+                             / duration;
+        else
+                scr_sof_freq = 0;
+
+        count += scnprintf(buf + count, size - count,
+                           "frames:  %u\npackets: %u\nempty:   %u\n"
+                           "errors:  %u\ninvalid: %u\n",
+                           stream->stats.stream.nb_frames,
+                           stream->stats.stream.nb_packets,
+                           stream->stats.stream.nb_empty,
+                           stream->stats.stream.nb_errors,
+                           stream->stats.stream.nb_invalid);
+        count += scnprintf(buf + count, size - count,
+                           "pts: %u early, %u initial, %u ok\n",
+                           stream->stats.stream.nb_pts_early,
+                           stream->stats.stream.nb_pts_initial,
+                           stream->stats.stream.nb_pts_constant);
+        count += scnprintf(buf + count, size - count,
+                           "scr: %u count ok, %u diff ok\n",
+                           stream->stats.stream.nb_scr_count_ok,
+                           stream->stats.stream.nb_scr_diffs_ok);
+        count += scnprintf(buf + count, size - count,
+                           "sof: %u <= sof <= %u, freq %u.%03u kHz\n",
+                           stream->stats.stream.min_sof,
+                           stream->stats.stream.max_sof,
+                           scr_sof_freq / 1000, scr_sof_freq % 1000);
+
+        return count;
+}
+
+static void uvc_video_stats_start(struct uvc_streaming *stream)
+{
+        memset(&stream->stats, 0, sizeof(stream->stats));
+        stream->stats.stream.min_sof = 2048;
+}
+
+static void uvc_video_stats_stop(struct uvc_streaming *stream)
+{
+        ktime_get_ts(&stream->stats.stream.stop_ts);
+}
+
+/* ------------------------------------------------------------------------
+ * Video codecs
+ */
 
 /* Video payload decoding is handled by uvc_video_decode_start(),
  * uvc_video_decode_data() and uvc_video_decode_end().
@@ -416,14 +944,9 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
          * - bHeaderLength value must be at least 2 bytes (see above)
          * - bHeaderLength value can't be larger than the packet size.
          */
-        if (len < 2 || data[0] < 2 || data[0] > len)
+        if (len < 2 || data[0] < 2 || data[0] > len) {
+                stream->stats.frame.nb_invalid++;
                 return -EINVAL;
-
-        /* Skip payloads marked with the error bit ("error frames"). */
-        if (data[1] & UVC_STREAM_ERR) {
-                uvc_trace(UVC_TRACE_FRAME, "Dropping payload (error bit "
-                          "set).\n");
-                return -ENODATA;
         }
 
         fid = data[1] & UVC_STREAM_FID;
@@ -431,8 +954,14 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
         /* Increase the sequence number regardless of any buffer states, so
          * that discontinuous sequence numbers always indicate lost frames.
          */
-        if (stream->last_fid != fid)
+        if (stream->last_fid != fid) {
                 stream->sequence++;
+                if (stream->sequence)
+                        uvc_video_stats_update(stream);
+        }
+
+        uvc_video_clock_decode(stream, buf, data, len);
+        uvc_video_stats_decode(stream, data, len);
 
         /* Store the payload FID bit and return immediately when the buffer is
          * NULL.
@@ -442,6 +971,13 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
                 return -ENODATA;
         }
 
+        /* Mark the buffer as bad if the error bit is set. */
+        if (data[1] & UVC_STREAM_ERR) {
+                uvc_trace(UVC_TRACE_FRAME, "Marking buffer as bad (error bit "
+                          "set).\n");
+                buf->error = 1;
+        }
+
         /* Synchronize to the input stream by waiting for the FID bit to be
          * toggled when the the buffer state is not UVC_BUF_STATE_ACTIVE.
          * stream->last_fid is initialized to -1, so the first isochronous
@@ -467,9 +1003,10 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
                 else
                         ktime_get_real_ts(&ts);
 
-                buf->buf.sequence = stream->sequence;
-                buf->buf.timestamp.tv_sec = ts.tv_sec;
-                buf->buf.timestamp.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
+                buf->buf.v4l2_buf.sequence = stream->sequence;
+                buf->buf.v4l2_buf.timestamp.tv_sec = ts.tv_sec;
+                buf->buf.v4l2_buf.timestamp.tv_usec =
+                        ts.tv_nsec / NSEC_PER_USEC;
 
                 /* TODO: Handle PTS and SCR. */
                 buf->state = UVC_BUF_STATE_ACTIVE;
@@ -490,7 +1027,7 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
          * avoids detecting end of frame conditions at FID toggling if the
          * previous payload had the EOF bit set.
          */
-        if (fid != stream->last_fid && buf->buf.bytesused != 0) {
+        if (fid != stream->last_fid && buf->bytesused != 0) {
                 uvc_trace(UVC_TRACE_FRAME, "Frame complete (FID bit "
                                 "toggled).\n");
                 buf->state = UVC_BUF_STATE_READY;
@@ -505,7 +1042,6 @@ static int uvc_video_decode_start(struct uvc_streaming *stream,
 static void uvc_video_decode_data(struct uvc_streaming *stream,
                 struct uvc_buffer *buf, const __u8 *data, int len)
 {
-        struct uvc_video_queue *queue = &stream->queue;
         unsigned int maxlen, nbytes;
         void *mem;
 
@@ -513,11 +1049,11 @@ static void uvc_video_decode_data(struct uvc_streaming *stream,
                 return;
 
         /* Copy the video data to the buffer. */
-        maxlen = buf->buf.length - buf->buf.bytesused;
-        mem = queue->mem + buf->buf.m.offset + buf->buf.bytesused;
+        maxlen = buf->length - buf->bytesused;
+        mem = buf->mem + buf->bytesused;
         nbytes = min((unsigned int)len, maxlen);
         memcpy(mem, data, nbytes);
-        buf->buf.bytesused += nbytes;
+        buf->bytesused += nbytes;
 
         /* Complete the current frame if the buffer size was exceeded. */
         if (len > maxlen) {
@@ -530,7 +1066,7 @@ static void uvc_video_decode_end(struct uvc_streaming *stream,
                 struct uvc_buffer *buf, const __u8 *data, int len)
 {
         /* Mark the buffer as done if the EOF marker is set. */
-        if (data[1] & UVC_STREAM_EOF && buf->buf.bytesused != 0) {
+        if (data[1] & UVC_STREAM_EOF && buf->bytesused != 0) {
                 uvc_trace(UVC_TRACE_FRAME, "Frame complete (EOF found).\n");
                 if (data[0] == len)
                         uvc_trace(UVC_TRACE_FRAME, "EOF in empty payload.\n");
@@ -568,8 +1104,8 @@ static int uvc_video_encode_data(struct uvc_streaming *stream,
         void *mem;
 
         /* Copy video data to the URB buffer. */
-        mem = queue->mem + buf->buf.m.offset + queue->buf_used;
-        nbytes = min((unsigned int)len, buf->buf.bytesused - queue->buf_used);
+        mem = buf->mem + queue->buf_used;
+        nbytes = min((unsigned int)len, buf->bytesused - queue->buf_used);
         nbytes = min(stream->bulk.max_payload_size - stream->bulk.payload_size,
                         nbytes);
         memcpy(data, mem, nbytes);
@@ -624,7 +1160,7 @@ static void uvc_video_decode_isoc(struct urb *urb, struct uvc_streaming *stream,
                         urb->iso_frame_desc[i].actual_length);
 
                 if (buf->state == UVC_BUF_STATE_READY) {
-                        if (buf->buf.length != buf->buf.bytesused &&
+                        if (buf->length != buf->bytesused &&
                             !(stream->cur_format->flags &
                               UVC_FMT_FLAG_COMPRESSED))
                                 buf->error = 1;
@@ -724,12 +1260,12 @@ static void uvc_video_encode_bulk(struct urb *urb, struct uvc_streaming *stream,
         stream->bulk.payload_size += ret;
         len -= ret;
 
-        if (buf->buf.bytesused == stream->queue.buf_used ||
+        if (buf->bytesused == stream->queue.buf_used ||
             stream->bulk.payload_size == stream->bulk.max_payload_size) {
-                if (buf->buf.bytesused == stream->queue.buf_used) {
+                if (buf->bytesused == stream->queue.buf_used) {
                         stream->queue.buf_used = 0;
                         buf->state = UVC_BUF_STATE_READY;
-                        buf->buf.sequence = ++stream->sequence;
+                        buf->buf.v4l2_buf.sequence = ++stream->sequence;
                         uvc_queue_next_buffer(&stream->queue, buf);
                         stream->last_fid ^= UVC_STREAM_FID;
                 }
@@ -870,6 +1406,8 @@ static void uvc_uninit_video(struct uvc_streaming *stream, int free_buffers)
         struct urb *urb;
         unsigned int i;
 
+        uvc_video_stats_stop(stream);
+
         for (i = 0; i < UVC_URBS; ++i) {
                 urb = stream->urb[i];
                 if (urb == NULL)
@@ -882,6 +1420,8 @@ static void uvc_uninit_video(struct uvc_streaming *stream, int free_buffers)
 
         if (free_buffers)
                 uvc_free_urb_buffers(stream);
+
+        uvc_video_clock_cleanup(stream);
 }
 
 /*
@@ -1009,6 +1549,12 @@ static int uvc_init_video(struct uvc_streaming *stream, gfp_t gfp_flags)
         stream->bulk.skip_payload = 0;
         stream->bulk.payload_size = 0;
 
+        uvc_video_stats_start(stream);
+
+        ret = uvc_video_clock_init(stream);
+        if (ret < 0)
+                return ret;
+
         if (intf->num_altsetting > 1) {
                 struct usb_host_endpoint *best_ep = NULL;
                 unsigned int best_psize = 3 * 1024;
@@ -1283,6 +1829,11 @@ int uvc_video_enable(struct uvc_streaming *stream, int enable)
                 return ret;
         }
 
-        return uvc_init_video(stream, GFP_KERNEL);
-}
+        ret = uvc_init_video(stream, GFP_KERNEL);
+        if (ret < 0) {
+                usb_set_interface(stream->dev->udev, stream->intfnum, 0);
+                uvc_queue_enable(&stream->queue, 0);
+        }
 
+        return ret;
+}
diff --git a/drivers/media/video/uvc/uvcvideo.h b/drivers/media/video/uvc/uvcvideo.h
index 4c1392ebcd4b..67f88d85bb16 100644
--- a/drivers/media/video/uvc/uvcvideo.h
+++ b/drivers/media/video/uvc/uvcvideo.h
@@ -13,6 +13,7 @@
 #include <linux/videodev2.h>
 #include <media/media-device.h>
 #include <media/v4l2-device.h>
+#include <media/videobuf2-core.h>
 
 /* --------------------------------------------------------------------------
  * UVC constants
@@ -113,6 +114,7 @@
 
 /* Maximum allowed number of control mappings per device */
 #define UVC_MAX_CONTROL_MAPPINGS        1024
+#define UVC_MAX_CONTROL_MENU_ENTRIES    32
 
 /* Devices quirks */
 #define UVC_QUIRK_STATUS_INTERVAL       0x00000001
@@ -319,35 +321,30 @@ enum uvc_buffer_state {
 };
 
 struct uvc_buffer {
-        unsigned long vma_use_count;
-        struct list_head stream;
-
-        /* Touched by interrupt handler. */
-        struct v4l2_buffer buf;
+        struct vb2_buffer buf;
         struct list_head queue;
-        wait_queue_head_t wait;
+
         enum uvc_buffer_state state;
         unsigned int error;
+
+        void *mem;
+        unsigned int length;
+        unsigned int bytesused;
+
+        u32 pts;
 };
 
-#define UVC_QUEUE_STREAMING             (1 << 0)
-#define UVC_QUEUE_DISCONNECTED          (1 << 1)
-#define UVC_QUEUE_DROP_CORRUPTED        (1 << 2)
+#define UVC_QUEUE_DISCONNECTED          (1 << 0)
+#define UVC_QUEUE_DROP_CORRUPTED        (1 << 1)
 
 struct uvc_video_queue {
-        enum v4l2_buf_type type;
+        struct vb2_queue queue;
+        struct mutex mutex;                     /* Protects queue */
 
-        void *mem;
         unsigned int flags;
-
-        unsigned int count;
-        unsigned int buf_size;
         unsigned int buf_used;
-        struct uvc_buffer buffer[UVC_MAX_VIDEO_BUFFERS];
-        struct mutex mutex;     /* protects buffers and mainqueue */
-        spinlock_t irqlock;     /* protects irqqueue */
 
-        struct list_head mainqueue;
+        spinlock_t irqlock;                     /* Protects irqqueue */
         struct list_head irqqueue;
 };
 
@@ -362,6 +359,51 @@ struct uvc_video_chain {
         struct mutex ctrl_mutex;                /* Protects ctrl.info */
 };
 
+struct uvc_stats_frame {
+        unsigned int size;              /* Number of bytes captured */
+        unsigned int first_data;        /* Index of the first non-empty packet */
+
+        unsigned int nb_packets;        /* Number of packets */
+        unsigned int nb_empty;          /* Number of empty packets */
+        unsigned int nb_invalid;        /* Number of packets with an invalid header */
+        unsigned int nb_errors;         /* Number of packets with the error bit set */
+
+        unsigned int nb_pts;            /* Number of packets with a PTS timestamp */
+        unsigned int nb_pts_diffs;      /* Number of PTS differences inside a frame */
+        unsigned int last_pts_diff;     /* Index of the last PTS difference */
+        bool has_initial_pts;           /* Whether the first non-empty packet has a PTS */
+        bool has_early_pts;             /* Whether a PTS is present before the first non-empty packet */
+        u32 pts;                        /* PTS of the last packet */
+
+        unsigned int nb_scr;            /* Number of packets with a SCR timestamp */
+        unsigned int nb_scr_diffs;      /* Number of SCR.STC differences inside a frame */
+        u16 scr_sof;                    /* SCR.SOF of the last packet */
+        u32 scr_stc;                    /* SCR.STC of the last packet */
+};
+
+struct uvc_stats_stream {
+        struct timespec start_ts;       /* Stream start timestamp */
+        struct timespec stop_ts;        /* Stream stop timestamp */
+
+        unsigned int nb_frames;         /* Number of frames */
+
+        unsigned int nb_packets;        /* Number of packets */
+        unsigned int nb_empty;          /* Number of empty packets */
+        unsigned int nb_invalid;        /* Number of packets with an invalid header */
+        unsigned int nb_errors;         /* Number of packets with the error bit set */
+
+        unsigned int nb_pts_constant;   /* Number of frames with constant PTS */
+        unsigned int nb_pts_early;      /* Number of frames with early PTS */
+        unsigned int nb_pts_initial;    /* Number of frames with initial PTS */
+
+        unsigned int nb_scr_count_ok;   /* Number of frames with at least one SCR per non empty packet */
+        unsigned int nb_scr_diffs_ok;   /* Number of frames with varying SCR.STC */
+        unsigned int scr_sof_count;     /* STC.SOF counter accumulated since stream start */
+        unsigned int scr_sof;           /* STC.SOF of the last packet */
+        unsigned int min_sof;           /* Minimum STC.SOF value */
+        unsigned int max_sof;           /* Maximum STC.SOF value */
+};
+
 struct uvc_streaming {
         struct list_head list;
         struct uvc_device *dev;
@@ -387,6 +429,7 @@ struct uvc_streaming {
          */
         struct mutex mutex;
 
+        /* Buffers queue. */
         unsigned int frozen : 1;
         struct uvc_video_queue queue;
         void (*decode) (struct urb *urb, struct uvc_streaming *video,
@@ -408,6 +451,32 @@ struct uvc_streaming {
 
         __u32 sequence;
         __u8 last_fid;
+
+        /* debugfs */
+        struct dentry *debugfs_dir;
+        struct {
+                struct uvc_stats_frame frame;
+                struct uvc_stats_stream stream;
+        } stats;
+
+        /* Timestamps support. */
+        struct uvc_clock {
+                struct uvc_clock_sample {
+                        u32 dev_stc;
+                        u16 dev_sof;
+                        struct timespec host_ts;
+                        u16 host_sof;
+                } *samples;
+
+                unsigned int head;
+                unsigned int count;
+                unsigned int size;
+
+                u16 last_sof;
+                u16 sof_offset;
+
+                spinlock_t lock;
+        } clock;
 };
 
 enum uvc_device_state {
@@ -479,9 +548,12 @@ struct uvc_driver {
 #define UVC_TRACE_SUSPEND       (1 << 8)
 #define UVC_TRACE_STATUS        (1 << 9)
 #define UVC_TRACE_VIDEO         (1 << 10)
+#define UVC_TRACE_STATS         (1 << 11)
+#define UVC_TRACE_CLOCK         (1 << 12)
 
 #define UVC_WARN_MINMAX         0
 #define UVC_WARN_PROBE_DEF      1
+#define UVC_WARN_XU_GET_RES     2
 
 extern unsigned int uvc_clock_param;
 extern unsigned int uvc_no_drop_param;
@@ -516,8 +588,8 @@ extern struct uvc_entity *uvc_entity_by_id(struct uvc_device *dev, int id);
 extern void uvc_queue_init(struct uvc_video_queue *queue,
                 enum v4l2_buf_type type, int drop_corrupted);
 extern int uvc_alloc_buffers(struct uvc_video_queue *queue,
-                unsigned int nbuffers, unsigned int buflength);
-extern int uvc_free_buffers(struct uvc_video_queue *queue);
+                struct v4l2_requestbuffers *rb);
+extern void uvc_free_buffers(struct uvc_video_queue *queue);
 extern int uvc_query_buffer(struct uvc_video_queue *queue,
                 struct v4l2_buffer *v4l2_buf);
 extern int uvc_queue_buffer(struct uvc_video_queue *queue,
@@ -539,7 +611,7 @@ extern unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
 extern int uvc_queue_allocated(struct uvc_video_queue *queue);
 static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
 {
-        return queue->flags & UVC_QUEUE_STREAMING;
+        return vb2_is_streaming(&queue->queue);
 }
 
 /* V4L2 interface */
@@ -556,10 +628,11 @@ extern int uvc_video_resume(struct uvc_streaming *stream, int reset);
 extern int uvc_video_enable(struct uvc_streaming *stream, int enable);
 extern int uvc_probe_video(struct uvc_streaming *stream,
                 struct uvc_streaming_control *probe);
-extern int uvc_commit_video(struct uvc_streaming *stream,
-                struct uvc_streaming_control *ctrl);
 extern int uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
                 __u8 intfnum, __u8 cs, void *data, __u16 size);
+void uvc_video_clock_update(struct uvc_streaming *stream,
+                            struct v4l2_buffer *v4l2_buf,
+                            struct uvc_buffer *buf);
 
 /* Status */
 extern int uvc_status_init(struct uvc_device *dev);
@@ -612,4 +685,13 @@ extern struct usb_host_endpoint *uvc_find_endpoint(
 void uvc_video_decode_isight(struct urb *urb, struct uvc_streaming *stream,
                 struct uvc_buffer *buf);
 
+/* debugfs and statistics */
+int uvc_debugfs_init(void);
+void uvc_debugfs_cleanup(void);
+int uvc_debugfs_init_stream(struct uvc_streaming *stream);
+void uvc_debugfs_cleanup_stream(struct uvc_streaming *stream);
+
+size_t uvc_video_stats_dump(struct uvc_streaming *stream, char *buf,
+                            size_t size);
+
 #endif
diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c
index c68531b88279..af4419e6c658 100644
--- a/drivers/media/video/v4l2-compat-ioctl32.c
+++ b/drivers/media/video/v4l2-compat-ioctl32.c
@@ -985,6 +985,8 @@ long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
         case VIDIOC_CROPCAP:
         case VIDIOC_G_CROP:
         case VIDIOC_S_CROP:
+        case VIDIOC_G_SELECTION:
+        case VIDIOC_S_SELECTION:
         case VIDIOC_G_JPEGCOMP:
         case VIDIOC_S_JPEGCOMP:
         case VIDIOC_QUERYSTD:
diff --git a/drivers/media/video/v4l2-ctrls.c b/drivers/media/video/v4l2-ctrls.c
index 0f415dade05a..da1f4c2d2d4b 100644
--- a/drivers/media/video/v4l2-ctrls.c
+++ b/drivers/media/video/v4l2-ctrls.c
@@ -467,6 +467,7 @@ const char *v4l2_ctrl_get_name(u32 id)
         case V4L2_CID_ILLUMINATORS_2:           return "Illuminator 2";
         case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:  return "Minimum Number of Capture Buffers";
         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:   return "Minimum Number of Output Buffers";
+        case V4L2_CID_ALPHA_COMPONENT:          return "Alpha Component";
 
         /* MPEG controls */
         /* Keep the order of the 'case's the same as in videodev2.h! */
@@ -1108,8 +1109,8 @@ int v4l2_ctrl_handler_init(struct v4l2_ctrl_handler *hdl,
         INIT_LIST_HEAD(&hdl->ctrls);
         INIT_LIST_HEAD(&hdl->ctrl_refs);
         hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;
-        hdl->buckets = kzalloc(sizeof(hdl->buckets[0]) * hdl->nr_of_buckets,
-                                                                GFP_KERNEL);
+        hdl->buckets = kcalloc(hdl->nr_of_buckets, sizeof(hdl->buckets[0]),
+                               GFP_KERNEL);
         hdl->error = hdl->buckets ? 0 : -ENOMEM;
         return hdl->error;
 }
diff --git a/drivers/media/video/v4l2-dev.c b/drivers/media/video/v4l2-dev.c
index a5c9ed128b97..96e9615663e9 100644
--- a/drivers/media/video/v4l2-dev.c
+++ b/drivers/media/video/v4l2-dev.c
@@ -146,10 +146,9 @@ static void v4l2_device_release(struct device *cd)
         struct v4l2_device *v4l2_dev = vdev->v4l2_dev;
 
         mutex_lock(&videodev_lock);
-        if (video_device[vdev->minor] != vdev) {
-                mutex_unlock(&videodev_lock);
+        if (WARN_ON(video_device[vdev->minor] != vdev)) {
                 /* should not happen */
-                WARN_ON(1);
+                mutex_unlock(&videodev_lock);
                 return;
         }
 
@@ -168,7 +167,7 @@ static void v4l2_device_release(struct device *cd)
         mutex_unlock(&videodev_lock);
 
 #if defined(CONFIG_MEDIA_CONTROLLER)
-        if (vdev->v4l2_dev && vdev->v4l2_dev->mdev &&
+        if (v4l2_dev && v4l2_dev->mdev &&
             vdev->vfl_type != VFL_TYPE_SUBDEV)
                 media_device_unregister_entity(&vdev->entity);
 #endif
@@ -556,8 +555,7 @@ int __video_register_device(struct video_device *vdev, int type, int nr,
         vdev->minor = -1;
 
         /* the release callback MUST be present */
-        WARN_ON(!vdev->release);
-        if (!vdev->release)
+        if (WARN_ON(!vdev->release))
                 return -EINVAL;
 
         /* v4l2_fh support */
@@ -703,8 +701,8 @@ int __video_register_device(struct video_device *vdev, int type, int nr,
             vdev->vfl_type != VFL_TYPE_SUBDEV) {
                 vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
                 vdev->entity.name = vdev->name;
-                vdev->entity.v4l.major = VIDEO_MAJOR;
-                vdev->entity.v4l.minor = vdev->minor;
+                vdev->entity.info.v4l.major = VIDEO_MAJOR;
+                vdev->entity.info.v4l.minor = vdev->minor;
                 ret = media_device_register_entity(vdev->v4l2_dev->mdev,
                         &vdev->entity);
                 if (ret < 0)
diff --git a/drivers/media/video/v4l2-device.c b/drivers/media/video/v4l2-device.c
index 0edd618b9ddf..1f203b85a637 100644
--- a/drivers/media/video/v4l2-device.c
+++ b/drivers/media/video/v4l2-device.c
@@ -234,8 +234,8 @@ int v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev)
                         goto clean_up;
                 }
 #if defined(CONFIG_MEDIA_CONTROLLER)
-                sd->entity.v4l.major = VIDEO_MAJOR;
-                sd->entity.v4l.minor = vdev->minor;
+                sd->entity.info.v4l.major = VIDEO_MAJOR;
+                sd->entity.info.v4l.minor = vdev->minor;
 #endif
                 sd->devnode = vdev;
         }
diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index e1da8fc9dd2f..77feeb67e2db 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -238,6 +238,8 @@ static const char *v4l2_ioctls[] = {
         [_IOC_NR(VIDIOC_CROPCAP)]          = "VIDIOC_CROPCAP",
         [_IOC_NR(VIDIOC_G_CROP)]           = "VIDIOC_G_CROP",
         [_IOC_NR(VIDIOC_S_CROP)]           = "VIDIOC_S_CROP",
+        [_IOC_NR(VIDIOC_G_SELECTION)]      = "VIDIOC_G_SELECTION",
+        [_IOC_NR(VIDIOC_S_SELECTION)]      = "VIDIOC_S_SELECTION",
         [_IOC_NR(VIDIOC_G_JPEGCOMP)]       = "VIDIOC_G_JPEGCOMP",
         [_IOC_NR(VIDIOC_S_JPEGCOMP)]       = "VIDIOC_S_JPEGCOMP",
         [_IOC_NR(VIDIOC_QUERYSTD)]         = "VIDIOC_QUERYSTD",
@@ -1547,11 +1549,32 @@ static long __video_do_ioctl(struct file *file,
         {
                 struct v4l2_crop *p = arg;
 
-                if (!ops->vidioc_g_crop)
+                if (!ops->vidioc_g_crop && !ops->vidioc_g_selection)
                         break;
 
                 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
-                ret = ops->vidioc_g_crop(file, fh, p);
+
+                if (ops->vidioc_g_crop) {
+                        ret = ops->vidioc_g_crop(file, fh, p);
+                } else {
+                        /* simulate capture crop using selection api */
+                        struct v4l2_selection s = {
+                                .type = p->type,
+                        };
+
+                        /* crop means compose for output devices */
+                        if (V4L2_TYPE_IS_OUTPUT(p->type))
+                                s.target = V4L2_SEL_TGT_COMPOSE_ACTIVE;
+                        else
+                                s.target = V4L2_SEL_TGT_CROP_ACTIVE;
+
+                        ret = ops->vidioc_g_selection(file, fh, &s);
+
+                        /* copying results to old structure on success */
+                        if (!ret)
+                                p->c = s.r;
+                }
+
                 if (!ret)
                         dbgrect(vfd, "", &p->c);
                 break;
@@ -1560,15 +1583,65 @@ static long __video_do_ioctl(struct file *file,
         {
                 struct v4l2_crop *p = arg;
 
-                if (!ops->vidioc_s_crop)
+                if (!ops->vidioc_s_crop && !ops->vidioc_s_selection)
                         break;
+
                 if (ret_prio) {
                         ret = ret_prio;
                         break;
                 }
                 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
                 dbgrect(vfd, "", &p->c);
-                ret = ops->vidioc_s_crop(file, fh, p);
+
+                if (ops->vidioc_s_crop) {
+                        ret = ops->vidioc_s_crop(file, fh, p);
+                } else {
+                        /* simulate capture crop using selection api */
+                        struct v4l2_selection s = {
+                                .type = p->type,
+                                .r = p->c,
+                        };
+
+                        /* crop means compose for output devices */
+                        if (V4L2_TYPE_IS_OUTPUT(p->type))
+                                s.target = V4L2_SEL_TGT_COMPOSE_ACTIVE;
+                        else
+                                s.target = V4L2_SEL_TGT_CROP_ACTIVE;
+
+                        ret = ops->vidioc_s_selection(file, fh, &s);
+                }
+                break;
+        }
+        case VIDIOC_G_SELECTION:
+        {
+                struct v4l2_selection *p = arg;
+
+                if (!ops->vidioc_g_selection)
+                        break;
+
+                dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
+
+                ret = ops->vidioc_g_selection(file, fh, p);
+                if (!ret)
+                        dbgrect(vfd, "", &p->r);
+                break;
+        }
+        case VIDIOC_S_SELECTION:
+        {
+                struct v4l2_selection *p = arg;
+
+                if (!ops->vidioc_s_selection)
+                        break;
+
+                if (ret_prio) {
+                        ret = ret_prio;
+                        break;
+                }
+
+                dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
+                dbgrect(vfd, "", &p->r);
+
+                ret = ops->vidioc_s_selection(file, fh, p);
                 break;
         }
         case VIDIOC_CROPCAP:
@@ -1576,11 +1649,42 @@ static long __video_do_ioctl(struct file *file,
                 struct v4l2_cropcap *p = arg;
 
                 /*FIXME: Should also show v4l2_fract pixelaspect */
-                if (!ops->vidioc_cropcap)
+                if (!ops->vidioc_cropcap && !ops->vidioc_g_selection)
                         break;
 
                 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
-                ret = ops->vidioc_cropcap(file, fh, p);
+                if (ops->vidioc_cropcap) {
+                        ret = ops->vidioc_cropcap(file, fh, p);
+                } else {
+                        struct v4l2_selection s = { .type = p->type };
+
+                        /* obtaining bounds */
+                        if (V4L2_TYPE_IS_OUTPUT(p->type))
+                                s.target = V4L2_SEL_TGT_COMPOSE_BOUNDS;
+                        else
+                                s.target = V4L2_SEL_TGT_CROP_BOUNDS;
+
+                        ret = ops->vidioc_g_selection(file, fh, &s);
+                        if (ret)
+                                break;
+                        p->bounds = s.r;
+
+                        /* obtaining defrect */
+                        if (V4L2_TYPE_IS_OUTPUT(p->type))
+                                s.target = V4L2_SEL_TGT_COMPOSE_DEFAULT;
+                        else
+                                s.target = V4L2_SEL_TGT_CROP_DEFAULT;
+
+                        ret = ops->vidioc_g_selection(file, fh, &s);
+                        if (ret)
+                                break;
+                        p->defrect = s.r;
+
+                        /* setting trivial pixelaspect */
+                        p->pixelaspect.numerator = 1;
+                        p->pixelaspect.denominator = 1;
+                }
+
                 if (!ret) {
                         dbgrect(vfd, "bounds ", &p->bounds);
                         dbgrect(vfd, "defrect ", &p->defrect);
@@ -2226,6 +2330,10 @@ static int check_array_args(unsigned int cmd, void *parg, size_t *array_size,
                 struct v4l2_ext_controls *ctrls = parg;
 
                 if (ctrls->count != 0) {
+                        if (ctrls->count > V4L2_CID_MAX_CTRLS) {
+                                ret = -EINVAL;
+                                break;
+                        }
                         *user_ptr = (void __user *)ctrls->controls;
                         *kernel_ptr = (void *)&ctrls->controls;
                         *array_size = sizeof(struct v4l2_ext_control)
diff --git a/drivers/media/video/v4l2-subdev.c b/drivers/media/video/v4l2-subdev.c
index 65ade5f03c2e..41d118ee2de6 100644
--- a/drivers/media/video/v4l2-subdev.c
+++ b/drivers/media/video/v4l2-subdev.c
@@ -193,6 +193,10 @@ static long subdev_do_ioctl(struct file *file, unsigned int cmd, void *arg)
                 return v4l2_subdev_call(sd, core, s_register, p);
         }
 #endif
+
+        case VIDIOC_LOG_STATUS:
+                return v4l2_subdev_call(sd, core, log_status);
+
 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
         case VIDIOC_SUBDEV_G_FMT: {
                 struct v4l2_subdev_format *format = arg;
diff --git a/drivers/media/video/via-camera.c b/drivers/media/video/via-camera.c
index bfae41ba53c3..20f7237b8242 100644
--- a/drivers/media/video/via-camera.c
+++ b/drivers/media/video/via-camera.c
@@ -156,14 +156,10 @@ static struct via_format {
                 .mbus_code      = V4L2_MBUS_FMT_YUYV8_2X8,
                 .bpp            = 2,
         },
-        {
-                .desc           = "RGB 565",
-                .pixelformat    = V4L2_PIX_FMT_RGB565,
-                .mbus_code      = V4L2_MBUS_FMT_RGB565_2X8_LE,
-                .bpp            = 2,
-        },
         /* RGB444 and Bayer should be doable, but have never been
-           tested with this driver. */
+           tested with this driver. RGB565 seems to work at the default
+           resolution, but results in color corruption when being scaled by
+           viacam_set_scaled(), and is disabled as a result. */
 };
 #define N_VIA_FMTS ARRAY_SIZE(via_formats)
 
@@ -1504,14 +1500,4 @@ static struct platform_driver viacam_driver = {
         .remove = viacam_remove,
 };
 
-static int viacam_init(void)
-{
-        return platform_driver_register(&viacam_driver);
-}
-module_init(viacam_init);
-
-static void viacam_exit(void)
-{
-        platform_driver_unregister(&viacam_driver);
-}
-module_exit(viacam_exit);
+module_platform_driver(viacam_driver);
diff --git a/drivers/media/video/videobuf-dvb.c b/drivers/media/video/videobuf-dvb.c
index 3de7c7e4402d..59cb54aa2946 100644
--- a/drivers/media/video/videobuf-dvb.c
+++ b/drivers/media/video/videobuf-dvb.c
@@ -226,9 +226,10 @@ static int videobuf_dvb_register_frontend(struct dvb_adapter *adapter,
         }
 
         /* register network adapter */
-        dvb_net_init(adapter, &dvb->net, &dvb->demux.dmx);
-        if (dvb->net.dvbdev == NULL) {
-                result = -ENOMEM;
+        result = dvb_net_init(adapter, &dvb->net, &dvb->demux.dmx);
+        if (result < 0) {
+                printk(KERN_WARNING "%s: dvb_net_init failed (errno = %d)\n",
+                       dvb->name, result);
                 goto fail_fe_conn;
         }
         return 0;
diff --git a/drivers/media/video/videobuf2-core.c b/drivers/media/video/videobuf2-core.c
index 95a3f5e82aef..2e8f1df775b6 100644
--- a/drivers/media/video/videobuf2-core.c
+++ b/drivers/media/video/videobuf2-core.c
@@ -30,7 +30,7 @@ module_param(debug, int, 0644);
                         printk(KERN_DEBUG "vb2: " fmt, ## arg);         \
         } while (0)
 
-#define call_memop(q, plane, op, args...)                               \
+#define call_memop(q, op, args...)                                      \
         (((q)->mem_ops->op) ?                                           \
                 ((q)->mem_ops->op(args)) : 0)
 
@@ -52,7 +52,7 @@ static int __vb2_buf_mem_alloc(struct vb2_buffer *vb)
 
         /* Allocate memory for all planes in this buffer */
         for (plane = 0; plane < vb->num_planes; ++plane) {
-                mem_priv = call_memop(q, plane, alloc, q->alloc_ctx[plane],
+                mem_priv = call_memop(q, alloc, q->alloc_ctx[plane],
                                       q->plane_sizes[plane]);
                 if (IS_ERR_OR_NULL(mem_priv))
                         goto free;
@@ -65,8 +65,10 @@ static int __vb2_buf_mem_alloc(struct vb2_buffer *vb)
         return 0;
 free:
         /* Free already allocated memory if one of the allocations failed */
-        for (; plane > 0; --plane)
-                call_memop(q, plane, put, vb->planes[plane - 1].mem_priv);
+        for (; plane > 0; --plane) {
+                call_memop(q, put, vb->planes[plane - 1].mem_priv);
+                vb->planes[plane - 1].mem_priv = NULL;
+        }
 
         return -ENOMEM;
 }
@@ -80,10 +82,10 @@ static void __vb2_buf_mem_free(struct vb2_buffer *vb)
         unsigned int plane;
 
         for (plane = 0; plane < vb->num_planes; ++plane) {
-                call_memop(q, plane, put, vb->planes[plane].mem_priv);
+                call_memop(q, put, vb->planes[plane].mem_priv);
                 vb->planes[plane].mem_priv = NULL;
-                dprintk(3, "Freed plane %d of buffer %d\n",
-                                plane, vb->v4l2_buf.index);
+                dprintk(3, "Freed plane %d of buffer %d\n", plane,
+                        vb->v4l2_buf.index);
         }
 }
 
@@ -97,12 +99,9 @@ static void __vb2_buf_userptr_put(struct vb2_buffer *vb)
         unsigned int plane;
 
         for (plane = 0; plane < vb->num_planes; ++plane) {
-                void *mem_priv = vb->planes[plane].mem_priv;
-
-                if (mem_priv) {
-                        call_memop(q, plane, put_userptr, mem_priv);
-                        vb->planes[plane].mem_priv = NULL;
-                }
+                if (vb->planes[plane].mem_priv)
+                        call_memop(q, put_userptr, vb->planes[plane].mem_priv);
+                vb->planes[plane].mem_priv = NULL;
         }
 }
 
@@ -305,7 +304,7 @@ static bool __buffer_in_use(struct vb2_queue *q, struct vb2_buffer *vb)
                  * case anyway. If num_users() returns more than 1,
                  * we are not the only user of the plane's memory.
                  */
-                if (mem_priv && call_memop(q, plane, num_users, mem_priv) > 1)
+                if (mem_priv && call_memop(q, num_users, mem_priv) > 1)
                         return true;
         }
         return false;
@@ -731,10 +730,10 @@ void *vb2_plane_vaddr(struct vb2_buffer *vb, unsigned int plane_no)
 {
         struct vb2_queue *q = vb->vb2_queue;
 
-        if (plane_no > vb->num_planes)
+        if (plane_no > vb->num_planes || !vb->planes[plane_no].mem_priv)
                 return NULL;
 
-        return call_memop(q, plane_no, vaddr, vb->planes[plane_no].mem_priv);
+        return call_memop(q, vaddr, vb->planes[plane_no].mem_priv);
 
 }
 EXPORT_SYMBOL_GPL(vb2_plane_vaddr);
@@ -754,10 +753,10 @@ void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no)
 {
         struct vb2_queue *q = vb->vb2_queue;
 
-        if (plane_no > vb->num_planes)
+        if (plane_no > vb->num_planes || !vb->planes[plane_no].mem_priv)
                 return NULL;
 
-        return call_memop(q, plane_no, cookie, vb->planes[plane_no].mem_priv);
+        return call_memop(q, cookie, vb->planes[plane_no].mem_priv);
 }
 EXPORT_SYMBOL_GPL(vb2_plane_cookie);
 
@@ -883,7 +882,8 @@ static int __qbuf_userptr(struct vb2_buffer *vb, const struct v4l2_buffer *b)
 
         for (plane = 0; plane < vb->num_planes; ++plane) {
                 /* Skip the plane if already verified */
-                if (vb->v4l2_planes[plane].m.userptr == planes[plane].m.userptr
+                if (vb->v4l2_planes[plane].m.userptr &&
+                    vb->v4l2_planes[plane].m.userptr == planes[plane].m.userptr
                     && vb->v4l2_planes[plane].length == planes[plane].length)
                         continue;
 
@@ -898,27 +898,23 @@ static int __qbuf_userptr(struct vb2_buffer *vb, const struct v4l2_buffer *b)
 
                 /* Release previously acquired memory if present */
                 if (vb->planes[plane].mem_priv)
-                        call_memop(q, plane, put_userptr,
-                                        vb->planes[plane].mem_priv);
+                        call_memop(q, put_userptr, vb->planes[plane].mem_priv);
 
                 vb->planes[plane].mem_priv = NULL;
                 vb->v4l2_planes[plane].m.userptr = 0;
                 vb->v4l2_planes[plane].length = 0;
 
                 /* Acquire each plane's memory */
-                if (q->mem_ops->get_userptr) {
-                        mem_priv = q->mem_ops->get_userptr(q->alloc_ctx[plane],
-                                                        planes[plane].m.userptr,
-                                                        planes[plane].length,
-                                                        write);
-                        if (IS_ERR(mem_priv)) {
-                                dprintk(1, "qbuf: failed acquiring userspace "
+                mem_priv = call_memop(q, get_userptr, q->alloc_ctx[plane],
+                                      planes[plane].m.userptr,
+                                      planes[plane].length, write);
+                if (IS_ERR_OR_NULL(mem_priv)) {
+                        dprintk(1, "qbuf: failed acquiring userspace "
                                                 "memory for plane %d\n", plane);
-                                ret = PTR_ERR(mem_priv);
-                                goto err;
-                        }
-                        vb->planes[plane].mem_priv = mem_priv;
+                        ret = mem_priv ? PTR_ERR(mem_priv) : -EINVAL;
+                        goto err;
                 }
+                vb->planes[plane].mem_priv = mem_priv;
         }
 
         /*
@@ -943,8 +939,7 @@ err:
         /* In case of errors, release planes that were already acquired */
         for (plane = 0; plane < vb->num_planes; ++plane) {
                 if (vb->planes[plane].mem_priv)
-                        call_memop(q, plane, put_userptr,
-                                   vb->planes[plane].mem_priv);
+                        call_memop(q, put_userptr, vb->planes[plane].mem_priv);
                 vb->planes[plane].mem_priv = NULL;
                 vb->v4l2_planes[plane].m.userptr = 0;
                 vb->v4l2_planes[plane].length = 0;
@@ -1081,46 +1076,76 @@ EXPORT_SYMBOL_GPL(vb2_prepare_buf);
  */
 int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
 {
+        struct rw_semaphore *mmap_sem = NULL;
         struct vb2_buffer *vb;
-        int ret;
+        int ret = 0;
+
+        /*
+         * In case of user pointer buffers vb2 allocator needs to get direct
+         * access to userspace pages. This requires getting read access on
+         * mmap semaphore in the current process structure. The same
+         * semaphore is taken before calling mmap operation, while both mmap
+         * and qbuf are called by the driver or v4l2 core with driver's lock
+         * held. To avoid a AB-BA deadlock (mmap_sem then driver's lock in
+         * mmap and driver's lock then mmap_sem in qbuf) the videobuf2 core
+         * release driver's lock, takes mmap_sem and then takes again driver's
+         * lock.
+         *
+         * To avoid race with other vb2 calls, which might be called after
+         * releasing driver's lock, this operation is performed at the
+         * beggining of qbuf processing. This way the queue status is
+         * consistent after getting driver's lock back.
+         */
+        if (q->memory == V4L2_MEMORY_USERPTR) {
+                mmap_sem = &current->mm->mmap_sem;
+                call_qop(q, wait_prepare, q);
+                down_read(mmap_sem);
+                call_qop(q, wait_finish, q);
+        }
 
         if (q->fileio) {
                 dprintk(1, "qbuf: file io in progress\n");
-                return -EBUSY;
+                ret = -EBUSY;
+                goto unlock;
         }
 
         if (b->type != q->type) {
                 dprintk(1, "qbuf: invalid buffer type\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto unlock;
         }
 
         if (b->index >= q->num_buffers) {
                 dprintk(1, "qbuf: buffer index out of range\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto unlock;
         }
 
         vb = q->bufs[b->index];
         if (NULL == vb) {
                 /* Should never happen */
                 dprintk(1, "qbuf: buffer is NULL\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto unlock;
         }
 
         if (b->memory != q->memory) {
                 dprintk(1, "qbuf: invalid memory type\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto unlock;
         }
 
         switch (vb->state) {
         case VB2_BUF_STATE_DEQUEUED:
                 ret = __buf_prepare(vb, b);
                 if (ret)
-                        return ret;
+                        goto unlock;
         case VB2_BUF_STATE_PREPARED:
                 break;
         default:
                 dprintk(1, "qbuf: buffer already in use\n");
-                return -EINVAL;
+                ret = -EINVAL;
+                goto unlock;
         }
 
         /*
@@ -1141,7 +1166,10 @@ int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
         __fill_v4l2_buffer(vb, b);
 
         dprintk(1, "qbuf of buffer %d succeeded\n", vb->v4l2_buf.index);
-        return 0;
+unlock:
+        if (mmap_sem)
+                up_read(mmap_sem);
+        return ret;
 }
 EXPORT_SYMBOL_GPL(vb2_qbuf);
 
@@ -1521,7 +1549,6 @@ static int __find_plane_by_offset(struct vb2_queue *q, unsigned long off,
 int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
 {
         unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
-        struct vb2_plane *vb_plane;
         struct vb2_buffer *vb;
         unsigned int buffer, plane;
         int ret;
@@ -1558,9 +1585,8 @@ int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma)
                 return ret;
 
         vb = q->bufs[buffer];
-        vb_plane = &vb->planes[plane];
 
-        ret = q->mem_ops->mmap(vb_plane->mem_priv, vma);
+        ret = call_memop(q, mmap, vb->planes[plane].mem_priv, vma);
         if (ret)
                 return ret;
 
diff --git a/drivers/media/video/videobuf2-dma-sg.c b/drivers/media/video/videobuf2-dma-sg.c
index 3bad8b105fea..25c3b360e1ad 100644
--- a/drivers/media/video/videobuf2-dma-sg.c
+++ b/drivers/media/video/videobuf2-dma-sg.c
@@ -140,7 +140,6 @@ static void *vb2_dma_sg_get_userptr(void *alloc_ctx, unsigned long vaddr,
         if (!buf->pages)
                 goto userptr_fail_pages_array_alloc;
 
-        down_read(&current->mm->mmap_sem);
         num_pages_from_user = get_user_pages(current, current->mm,
                                              vaddr & PAGE_MASK,
                                              buf->sg_desc.num_pages,
@@ -148,7 +147,7 @@ static void *vb2_dma_sg_get_userptr(void *alloc_ctx, unsigned long vaddr,
                                              1, /* force */
                                              buf->pages,
                                              NULL);
-        up_read(&current->mm->mmap_sem);
+
         if (num_pages_from_user != buf->sg_desc.num_pages)
                 goto userptr_fail_get_user_pages;
 
diff --git a/drivers/media/video/videobuf2-memops.c b/drivers/media/video/videobuf2-memops.c
index 71a7a78c3fc0..c41cb60245d6 100644
--- a/drivers/media/video/videobuf2-memops.c
+++ b/drivers/media/video/videobuf2-memops.c
@@ -100,29 +100,26 @@ int vb2_get_contig_userptr(unsigned long vaddr, unsigned long size,
         unsigned long offset, start, end;
         unsigned long this_pfn, prev_pfn;
         dma_addr_t pa = 0;
-        int ret = -EFAULT;
 
         start = vaddr;
         offset = start & ~PAGE_MASK;
         end = start + size;
 
-        down_read(&mm->mmap_sem);
         vma = find_vma(mm, start);
 
         if (vma == NULL || vma->vm_end < end)
-                goto done;
+                return -EFAULT;
 
         for (prev_pfn = 0; start < end; start += PAGE_SIZE) {
-                ret = follow_pfn(vma, start, &this_pfn);
+                int ret = follow_pfn(vma, start, &this_pfn);
                 if (ret)
-                        goto done;
+                        return ret;
 
                 if (prev_pfn == 0)
                         pa = this_pfn << PAGE_SHIFT;
-                else if (this_pfn != prev_pfn + 1) {
-                        ret = -EFAULT;
-                        goto done;
-                }
+                else if (this_pfn != prev_pfn + 1)
+                        return -EFAULT;
+
                 prev_pfn = this_pfn;
         }
 
@@ -130,16 +127,11 @@ int vb2_get_contig_userptr(unsigned long vaddr, unsigned long size,
          * Memory is contigous, lock vma and return to the caller
          */
         *res_vma = vb2_get_vma(vma);
-        if (*res_vma == NULL) {
-                ret = -ENOMEM;
-                goto done;
-        }
-        *res_pa = pa + offset;
-        ret = 0;
+        if (*res_vma == NULL)
+                return -ENOMEM;
 
-done:
-        up_read(&mm->mmap_sem);
-        return ret;
+        *res_pa = pa + offset;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(vb2_get_contig_userptr);
 
diff --git a/drivers/media/video/videobuf2-vmalloc.c b/drivers/media/video/videobuf2-vmalloc.c
index a3a884234059..4e789a178f8a 100644
--- a/drivers/media/video/videobuf2-vmalloc.c
+++ b/drivers/media/video/videobuf2-vmalloc.c
@@ -12,6 +12,7 @@
 
 #include <linux/module.h>
 #include <linux/mm.h>
+#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 
@@ -20,7 +21,10 @@
 
 struct vb2_vmalloc_buf {
         void                            *vaddr;
+        struct page                     **pages;
+        int                             write;
         unsigned long                   size;
+        unsigned int                    n_pages;
         atomic_t                        refcount;
         struct vb2_vmarea_handler       handler;
 };
@@ -31,7 +35,7 @@ static void *vb2_vmalloc_alloc(void *alloc_ctx, unsigned long size)
 {
         struct vb2_vmalloc_buf *buf;
 
-        buf = kzalloc(sizeof *buf, GFP_KERNEL);
+        buf = kzalloc(sizeof(*buf), GFP_KERNEL);
         if (!buf)
                 return NULL;
 
@@ -42,15 +46,12 @@ static void *vb2_vmalloc_alloc(void *alloc_ctx, unsigned long size)
         buf->handler.arg = buf;
 
         if (!buf->vaddr) {
-                printk(KERN_ERR "vmalloc of size %ld failed\n", buf->size);
+                pr_debug("vmalloc of size %ld failed\n", buf->size);
                 kfree(buf);
                 return NULL;
         }
 
         atomic_inc(&buf->refcount);
-        printk(KERN_DEBUG "Allocated vmalloc buffer of size %ld at vaddr=%p\n",
-                        buf->size, buf->vaddr);
-
         return buf;
 }
 
@@ -59,21 +60,84 @@ static void vb2_vmalloc_put(void *buf_priv)
         struct vb2_vmalloc_buf *buf = buf_priv;
 
         if (atomic_dec_and_test(&buf->refcount)) {
-                printk(KERN_DEBUG "%s: Freeing vmalloc mem at vaddr=%p\n",
-                        __func__, buf->vaddr);
                 vfree(buf->vaddr);
                 kfree(buf);
         }
 }
 
-static void *vb2_vmalloc_vaddr(void *buf_priv)
+static void *vb2_vmalloc_get_userptr(void *alloc_ctx, unsigned long vaddr,
+                                     unsigned long size, int write)
+{
+        struct vb2_vmalloc_buf *buf;
+        unsigned long first, last;
+        int n_pages, offset;
+
+        buf = kzalloc(sizeof(*buf), GFP_KERNEL);
+        if (!buf)
+                return NULL;
+
+        buf->write = write;
+        offset = vaddr & ~PAGE_MASK;
+        buf->size = size;
+
+        first = vaddr >> PAGE_SHIFT;
+        last  = (vaddr + size - 1) >> PAGE_SHIFT;
+        buf->n_pages = last - first + 1;
+        buf->pages = kzalloc(buf->n_pages * sizeof(struct page *), GFP_KERNEL);
+        if (!buf->pages)
+                goto fail_pages_array_alloc;
+
+        /* current->mm->mmap_sem is taken by videobuf2 core */
+        n_pages = get_user_pages(current, current->mm, vaddr & PAGE_MASK,
+                                 buf->n_pages, write, 1, /* force */
+                                 buf->pages, NULL);
+        if (n_pages != buf->n_pages)
+                goto fail_get_user_pages;
+
+        buf->vaddr = vm_map_ram(buf->pages, buf->n_pages, -1, PAGE_KERNEL);
+        if (!buf->vaddr)
+                goto fail_get_user_pages;
+
+        buf->vaddr += offset;
+        return buf;
+
+fail_get_user_pages:
+        pr_debug("get_user_pages requested/got: %d/%d]\n", n_pages,
+                 buf->n_pages);
+        while (--n_pages >= 0)
+                put_page(buf->pages[n_pages]);
+        kfree(buf->pages);
+
+fail_pages_array_alloc:
+        kfree(buf);
+
+        return NULL;
+}
+
+static void vb2_vmalloc_put_userptr(void *buf_priv)
 {
         struct vb2_vmalloc_buf *buf = buf_priv;
+        unsigned long vaddr = (unsigned long)buf->vaddr & PAGE_MASK;
+        unsigned int i;
+
+        if (vaddr)
+                vm_unmap_ram((void *)vaddr, buf->n_pages);
+        for (i = 0; i < buf->n_pages; ++i) {
+                if (buf->write)
+                        set_page_dirty_lock(buf->pages[i]);
+                put_page(buf->pages[i]);
+        }
+        kfree(buf->pages);
+        kfree(buf);
+}
 
-        BUG_ON(!buf);
+static void *vb2_vmalloc_vaddr(void *buf_priv)
+{
+        struct vb2_vmalloc_buf *buf = buf_priv;
 
         if (!buf->vaddr) {
-                printk(KERN_ERR "Address of an unallocated plane requested\n");
+                pr_err("Address of an unallocated plane requested "
+                       "or cannot map user pointer\n");
                 return NULL;
         }
 
@@ -92,13 +156,13 @@ static int vb2_vmalloc_mmap(void *buf_priv, struct vm_area_struct *vma)
         int ret;
 
         if (!buf) {
-                printk(KERN_ERR "No memory to map\n");
+                pr_err("No memory to map\n");
                 return -EINVAL;
         }
 
         ret = remap_vmalloc_range(vma, buf->vaddr, 0);
         if (ret) {
-                printk(KERN_ERR "Remapping vmalloc memory, error: %d\n", ret);
+                pr_err("Remapping vmalloc memory, error: %d\n", ret);
                 return ret;
         }
 
@@ -121,6 +185,8 @@ static int vb2_vmalloc_mmap(void *buf_priv, struct vm_area_struct *vma)
 const struct vb2_mem_ops vb2_vmalloc_memops = {
         .alloc          = vb2_vmalloc_alloc,
         .put            = vb2_vmalloc_put,
+        .get_userptr    = vb2_vmalloc_get_userptr,
+        .put_userptr    = vb2_vmalloc_put_userptr,
         .vaddr          = vb2_vmalloc_vaddr,
         .mmap           = vb2_vmalloc_mmap,
         .num_users      = vb2_vmalloc_num_users,
diff --git a/drivers/media/video/vino.c b/drivers/media/video/vino.c
index 52a0a3736c82..4d7391ec8001 100644
--- a/drivers/media/video/vino.c
+++ b/drivers/media/video/vino.c
@@ -708,7 +708,7 @@ static int vino_allocate_buffer(struct vino_framebuffer *fb,
                 size, count);
 
         /* allocate memory for table with virtual (page) addresses */
-        fb->desc_table.virtual = (unsigned long *)
+        fb->desc_table.virtual =
                 kmalloc(count * sizeof(unsigned long), GFP_KERNEL);
         if (!fb->desc_table.virtual)
                 return -ENOMEM;