86 files changed, 2820 insertions, 2499 deletions

diff --git a/drivers/media/usb/Kconfig b/drivers/media/usb/Kconfig
index 6746994d03fe..0a7d520636a9 100644
--- a/drivers/media/usb/Kconfig
+++ b/drivers/media/usb/Kconfig
@@ -21,7 +21,6 @@ endif
 
 if MEDIA_ANALOG_TV_SUPPORT
         comment "Analog TV USB devices"
-source "drivers/media/usb/au0828/Kconfig"
 source "drivers/media/usb/pvrusb2/Kconfig"
 source "drivers/media/usb/hdpvr/Kconfig"
 source "drivers/media/usb/tlg2300/Kconfig"
@@ -31,6 +30,7 @@ endif
 
 if (MEDIA_ANALOG_TV_SUPPORT || MEDIA_DIGITAL_TV_SUPPORT)
         comment "Analog/digital TV USB devices"
+source "drivers/media/usb/au0828/Kconfig"
 source "drivers/media/usb/cx231xx/Kconfig"
 source "drivers/media/usb/tm6000/Kconfig"
 endif
diff --git a/drivers/media/usb/au0828/Kconfig b/drivers/media/usb/au0828/Kconfig
index 1766c0ce93be..953a37c613b1 100644
--- a/drivers/media/usb/au0828/Kconfig
+++ b/drivers/media/usb/au0828/Kconfig
@@ -1,17 +1,28 @@
 
 config VIDEO_AU0828
         tristate "Auvitek AU0828 support"
-        depends on I2C && INPUT && DVB_CORE && USB && VIDEO_V4L2
+        depends on I2C && INPUT && DVB_CORE && USB
         select I2C_ALGOBIT
         select VIDEO_TVEEPROM
         select VIDEOBUF_VMALLOC
         select DVB_AU8522_DTV if MEDIA_SUBDRV_AUTOSELECT
-        select DVB_AU8522_V4L if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_XC5000 if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_MXL5007T if MEDIA_SUBDRV_AUTOSELECT
         select MEDIA_TUNER_TDA18271 if MEDIA_SUBDRV_AUTOSELECT
         ---help---
-          This is a video4linux driver for Auvitek's USB device.
+          This is a hybrid analog/digital tv capture driver for
+          Auvitek's AU0828 USB device.
 
           To compile this driver as a module, choose M here: the
           module will be called au0828
+
+config VIDEO_AU0828_V4L2
+        bool "Auvitek AU0828 v4l2 analog video support"
+        depends on VIDEO_AU0828 && VIDEO_V4L2
+        select DVB_AU8522_V4L if MEDIA_SUBDRV_AUTOSELECT
+        default y
+        ---help---
+          This is a video4linux driver for Auvitek's USB device.
+
+          Choose Y here to include support for v4l2 analog video
+          capture within the au0828 driver.
diff --git a/drivers/media/usb/au0828/Makefile b/drivers/media/usb/au0828/Makefile
index 98cc20cc0ffb..be3bdf698022 100644
--- a/drivers/media/usb/au0828/Makefile
+++ b/drivers/media/usb/au0828/Makefile
@@ -1,4 +1,8 @@
-au0828-objs     := au0828-core.o au0828-i2c.o au0828-cards.o au0828-dvb.o au0828-video.o au0828-vbi.o
+au0828-objs     := au0828-core.o au0828-i2c.o au0828-cards.o au0828-dvb.o
+
+ifeq ($(CONFIG_VIDEO_AU0828_V4L2),y)
+  au0828-objs   += au0828-video.o au0828-vbi.o
+endif
 
 obj-$(CONFIG_VIDEO_AU0828) += au0828.o
 
diff --git a/drivers/media/usb/au0828/au0828-cards.c b/drivers/media/usb/au0828/au0828-cards.c
index 0cb7c28dcb17..dd32decb237d 100644
--- a/drivers/media/usb/au0828/au0828-cards.c
+++ b/drivers/media/usb/au0828/au0828-cards.c
@@ -169,7 +169,9 @@ static void hauppauge_eeprom(struct au0828_dev *dev, u8 *eeprom_data)
         case 72231: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
         case 72241: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM and analog video */
         case 72251: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
-        case 72261: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
+        case 72261: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM and analog video */
+        case 72271: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM and analog video */
+        case 72281: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM and analog video */
         case 72301: /* WinTV-HVR850 (Retail, IR, ATSC and analog video */
         case 72500: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM */
                 break;
@@ -183,16 +185,15 @@ static void hauppauge_eeprom(struct au0828_dev *dev, u8 *eeprom_data)
                __func__, tv.model);
 }
 
+void au0828_card_analog_fe_setup(struct au0828_dev *dev);
+
 void au0828_card_setup(struct au0828_dev *dev)
 {
         static u8 eeprom[256];
-        struct tuner_setup tun_setup;
-        struct v4l2_subdev *sd;
-        unsigned int mode_mask = T_ANALOG_TV;
 
         dprintk(1, "%s()\n", __func__);
 
-        memcpy(&dev->board, &au0828_boards[dev->boardnr], sizeof(dev->board));
+        dev->board = au0828_boards[dev->boardnr];
 
         if (dev->i2c_rc == 0) {
                 dev->i2c_client.addr = 0xa0 >> 1;
@@ -209,6 +210,16 @@ void au0828_card_setup(struct au0828_dev *dev)
                 break;
         }
 
+        au0828_card_analog_fe_setup(dev);
+}
+
+void au0828_card_analog_fe_setup(struct au0828_dev *dev)
+{
+#ifdef CONFIG_VIDEO_AU0828_V4L2
+        struct tuner_setup tun_setup;
+        struct v4l2_subdev *sd;
+        unsigned int mode_mask = T_ANALOG_TV;
+
         if (AUVI_INPUT(0).type != AU0828_VMUX_UNDEFINED) {
                 /* Load the analog demodulator driver (note this would need to
                    be abstracted out if we ever need to support a different
@@ -234,6 +245,7 @@ void au0828_card_setup(struct au0828_dev *dev)
                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr,
                                      &tun_setup);
         }
+#endif
 }
 
 /*
@@ -333,6 +345,8 @@ struct usb_device_id au0828_usb_id_table[] = {
                 .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
         { USB_DEVICE(0x2040, 0x7213),
                 .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
+        { USB_DEVICE(0x2040, 0x7270),
+                .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
         { },
 };
 
diff --git a/drivers/media/usb/au0828/au0828-core.c b/drivers/media/usb/au0828/au0828-core.c
index 745a80a798c8..1e6f40ef1c6b 100644
--- a/drivers/media/usb/au0828/au0828-core.c
+++ b/drivers/media/usb/au0828/au0828-core.c
@@ -134,13 +134,17 @@ static void au0828_usb_disconnect(struct usb_interface *interface)
         /* Digital TV */
         au0828_dvb_unregister(dev);
 
+#ifdef CONFIG_VIDEO_AU0828_V4L2
         if (AUVI_INPUT(0).type != AU0828_VMUX_UNDEFINED)
                 au0828_analog_unregister(dev);
+#endif
 
         /* I2C */
         au0828_i2c_unregister(dev);
 
+#ifdef CONFIG_VIDEO_AU0828_V4L2
         v4l2_device_unregister(&dev->v4l2_dev);
+#endif
 
         usb_set_intfdata(interface, NULL);
 
@@ -155,7 +159,10 @@ static void au0828_usb_disconnect(struct usb_interface *interface)
 static int au0828_usb_probe(struct usb_interface *interface,
         const struct usb_device_id *id)
 {
-        int ifnum, retval;
+        int ifnum;
+#ifdef CONFIG_VIDEO_AU0828_V4L2
+        int retval;
+#endif
         struct au0828_dev *dev;
         struct usb_device *usbdev = interface_to_usbdev(interface);
 
@@ -194,6 +201,7 @@ static int au0828_usb_probe(struct usb_interface *interface,
         dev->usbdev = usbdev;
         dev->boardnr = id->driver_info;
 
+#ifdef CONFIG_VIDEO_AU0828_V4L2
         /* Create the v4l2_device */
         retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
         if (retval) {
@@ -203,6 +211,7 @@ static int au0828_usb_probe(struct usb_interface *interface,
                 kfree(dev);
                 return -EIO;
         }
+#endif
 
         /* Power Up the bridge */
         au0828_write(dev, REG_600, 1 << 4);
@@ -216,9 +225,11 @@ static int au0828_usb_probe(struct usb_interface *interface,
         /* Setup */
         au0828_card_setup(dev);
 
+#ifdef CONFIG_VIDEO_AU0828_V4L2
         /* Analog TV */
         if (AUVI_INPUT(0).type != AU0828_VMUX_UNDEFINED)
                 au0828_analog_register(dev, interface);
+#endif
 
         /* Digital TV */
         au0828_dvb_register(dev);
diff --git a/drivers/media/usb/au0828/au0828-i2c.c b/drivers/media/usb/au0828/au0828-i2c.c
index 4ded17fe1957..17ec3651b10e 100644
--- a/drivers/media/usb/au0828/au0828-i2c.c
+++ b/drivers/media/usb/au0828/au0828-i2c.c
@@ -364,12 +364,9 @@ int au0828_i2c_register(struct au0828_dev *dev)
 {
         dprintk(1, "%s()\n", __func__);
 
-        memcpy(&dev->i2c_adap, &au0828_i2c_adap_template,
-               sizeof(dev->i2c_adap));
-        memcpy(&dev->i2c_algo, &au0828_i2c_algo_template,
-               sizeof(dev->i2c_algo));
-        memcpy(&dev->i2c_client, &au0828_i2c_client_template,
-               sizeof(dev->i2c_client));
+        dev->i2c_adap = au0828_i2c_adap_template;
+        dev->i2c_algo = au0828_i2c_algo_template;
+        dev->i2c_client = au0828_i2c_client_template;
 
         dev->i2c_adap.dev.parent = &dev->usbdev->dev;
 
@@ -378,7 +375,11 @@ int au0828_i2c_register(struct au0828_dev *dev)
 
         dev->i2c_adap.algo = &dev->i2c_algo;
         dev->i2c_adap.algo_data = dev;
+#ifdef CONFIG_VIDEO_AU0828_V4L2
         i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
+#else
+        i2c_set_adapdata(&dev->i2c_adap, dev);
+#endif
         i2c_add_adapter(&dev->i2c_adap);
 
         dev->i2c_client.adapter = &dev->i2c_adap;
diff --git a/drivers/media/usb/au0828/au0828-video.c b/drivers/media/usb/au0828/au0828-video.c
index 45387aab10c7..8b9e8268e911 100644
--- a/drivers/media/usb/au0828/au0828-video.c
+++ b/drivers/media/usb/au0828/au0828-video.c
@@ -304,7 +304,7 @@ static inline void buffer_filled(struct au0828_dev *dev,
 
         buf->vb.state = VIDEOBUF_DONE;
         buf->vb.field_count++;
-        do_gettimeofday(&buf->vb.ts);
+        v4l2_get_timestamp(&buf->vb.ts);
 
         dev->isoc_ctl.buf = NULL;
 
@@ -321,7 +321,7 @@ static inline void vbi_buffer_filled(struct au0828_dev *dev,
 
         buf->vb.state = VIDEOBUF_DONE;
         buf->vb.field_count++;
-        do_gettimeofday(&buf->vb.ts);
+        v4l2_get_timestamp(&buf->vb.ts);
 
         dev->isoc_ctl.vbi_buf = NULL;
 
diff --git a/drivers/media/usb/au0828/au0828.h b/drivers/media/usb/au0828/au0828.h
index 66a56ef7bbe4..e579ff69ca4a 100644
--- a/drivers/media/usb/au0828/au0828.h
+++ b/drivers/media/usb/au0828/au0828.h
@@ -199,8 +199,10 @@ struct au0828_dev {
         struct au0828_dvb               dvb;
         struct work_struct              restart_streaming;
 
+#ifdef CONFIG_VIDEO_AU0828_V4L2
         /* Analog */
         struct v4l2_device v4l2_dev;
+#endif
         int users;
         unsigned int resources; /* resources in use */
         struct video_device *vdev;
diff --git a/drivers/media/usb/cpia2/cpia2_usb.c b/drivers/media/usb/cpia2/cpia2_usb.c
index 95b5d6e7cdc4..be1719283609 100644
--- a/drivers/media/usb/cpia2/cpia2_usb.c
+++ b/drivers/media/usb/cpia2/cpia2_usb.c
@@ -328,7 +328,7 @@ static void cpia2_usb_complete(struct urb *urb)
                                 continue;
                         }
                         DBG("Start of frame pattern found\n");
-                        do_gettimeofday(&cam->workbuff->timestamp);
+                        v4l2_get_timestamp(&cam->workbuff->timestamp);
                         cam->workbuff->seq = cam->frame_count++;
                         cam->workbuff->data[0] = 0xFF;
                         cam->workbuff->data[1] = 0xD8;
diff --git a/drivers/media/usb/cpia2/cpia2_v4l.c b/drivers/media/usb/cpia2/cpia2_v4l.c
index aeb9d2275725..d5d42b6e94be 100644
--- a/drivers/media/usb/cpia2/cpia2_v4l.c
+++ b/drivers/media/usb/cpia2/cpia2_v4l.c
@@ -825,6 +825,8 @@ static int cpia2_querybuf(struct file *file, void *fh, struct v4l2_buffer *buf)
         else
                 buf->flags = 0;
 
+        buf->flags |= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
+
         switch (cam->buffers[buf->index].status) {
         case FRAME_EMPTY:
         case FRAME_ERROR:
@@ -943,7 +945,8 @@ static int cpia2_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
 
         buf->index = frame;
         buf->bytesused = cam->buffers[buf->index].length;
-        buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_DONE;
+        buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_DONE
+                | V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
         buf->field = V4L2_FIELD_NONE;
         buf->timestamp = cam->buffers[buf->index].timestamp;
         buf->sequence = cam->buffers[buf->index].seq;
diff --git a/drivers/media/usb/cx231xx/cx231xx-417.c b/drivers/media/usb/cx231xx/cx231xx-417.c
index b024e5197a75..28688dbcb609 100644
--- a/drivers/media/usb/cx231xx/cx231xx-417.c
+++ b/drivers/media/usb/cx231xx/cx231xx-417.c
@@ -1291,7 +1291,7 @@ static void buffer_copy(struct cx231xx *dev, char *data, int len, struct urb *ur
 
                         buf->vb.state = VIDEOBUF_DONE;
                         buf->vb.field_count++;
-                        do_gettimeofday(&buf->vb.ts);
+                        v4l2_get_timestamp(&buf->vb.ts);
                         list_del(&buf->vb.queue);
                         wake_up(&buf->vb.done);
                         dma_q->mpeg_buffer_completed = 0;
@@ -1327,7 +1327,7 @@ static void buffer_filled(char *data, int len, struct urb *urb,
                 memcpy(vbuf, data, len);
                 buf->vb.state = VIDEOBUF_DONE;
                 buf->vb.field_count++;
-                do_gettimeofday(&buf->vb.ts);
+                v4l2_get_timestamp(&buf->vb.ts);
                 list_del(&buf->vb.queue);
                 wake_up(&buf->vb.done);
 
diff --git a/drivers/media/usb/cx231xx/cx231xx-cards.c b/drivers/media/usb/cx231xx/cx231xx-cards.c
index bbed1e40eeda..8d529565f163 100644
--- a/drivers/media/usb/cx231xx/cx231xx-cards.c
+++ b/drivers/media/usb/cx231xx/cx231xx-cards.c
@@ -603,6 +603,33 @@ struct cx231xx_board cx231xx_boards[] = {
                         .gpio = NULL,
                 } },
         },
+        [CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2] = {
+                .name = "Elgato Video Capture V2",
+                .tuner_type = TUNER_ABSENT,
+                .decoder = CX231XX_AVDECODER,
+                .output_mode = OUT_MODE_VIP11,
+                .demod_xfer_mode = 0,
+                .ctl_pin_status_mask = 0xFFFFFFC4,
+                .agc_analog_digital_select_gpio = 0x0c,
+                .gpio_pin_status_mask = 0x4001000,
+                .norm = V4L2_STD_NTSC,
+                .no_alt_vanc = 1,
+                .external_av = 1,
+                .dont_use_port_3 = 1,
+                .input = {{
+                        .type = CX231XX_VMUX_COMPOSITE1,
+                        .vmux = CX231XX_VIN_2_1,
+                        .amux = CX231XX_AMUX_LINE_IN,
+                        .gpio = NULL,
+                }, {
+                        .type = CX231XX_VMUX_SVIDEO,
+                        .vmux = CX231XX_VIN_1_1 |
+                                (CX231XX_VIN_1_2 << 8) |
+                                CX25840_SVIDEO_ON,
+                        .amux = CX231XX_AMUX_LINE_IN,
+                        .gpio = NULL,
+                } },
+        },
 };
 const unsigned int cx231xx_bcount = ARRAY_SIZE(cx231xx_boards);
 
@@ -642,6 +669,8 @@ struct usb_device_id cx231xx_id_table[] = {
          .driver_info = CX231XX_BOARD_KWORLD_UB430_USB_HYBRID},
         {USB_DEVICE(0x1f4d, 0x0237),
          .driver_info = CX231XX_BOARD_ICONBIT_U100},
+        {USB_DEVICE(0x0fd9, 0x0037),
+         .driver_info = CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2},
         {},
 };
 
@@ -707,7 +736,7 @@ static void cx231xx_sleep_s5h1432(struct cx231xx *dev)
 
 static inline void cx231xx_set_model(struct cx231xx *dev)
 {
-        memcpy(&dev->board, &cx231xx_boards[dev->model], sizeof(dev->board));
+        dev->board = cx231xx_boards[dev->model];
 }
 
 /* Since cx231xx_pre_card_setup() requires a proper dev->model,
diff --git a/drivers/media/usb/cx231xx/cx231xx-vbi.c b/drivers/media/usb/cx231xx/cx231xx-vbi.c
index ac7db52f404f..46e3892557c2 100644
--- a/drivers/media/usb/cx231xx/cx231xx-vbi.c
+++ b/drivers/media/usb/cx231xx/cx231xx-vbi.c
@@ -530,7 +530,7 @@ static inline void vbi_buffer_filled(struct cx231xx *dev,
 
         buf->vb.state = VIDEOBUF_DONE;
         buf->vb.field_count++;
-        do_gettimeofday(&buf->vb.ts);
+        v4l2_get_timestamp(&buf->vb.ts);
 
         dev->vbi_mode.bulk_ctl.buf = NULL;
 
diff --git a/drivers/media/usb/cx231xx/cx231xx-video.c b/drivers/media/usb/cx231xx/cx231xx-video.c
index fedf7852a355..06376d904c9f 100644
--- a/drivers/media/usb/cx231xx/cx231xx-video.c
+++ b/drivers/media/usb/cx231xx/cx231xx-video.c
@@ -235,7 +235,7 @@ static inline void buffer_filled(struct cx231xx *dev,
         cx231xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
         buf->vb.state = VIDEOBUF_DONE;
         buf->vb.field_count++;
-        do_gettimeofday(&buf->vb.ts);
+        v4l2_get_timestamp(&buf->vb.ts);
 
         if (dev->USE_ISO)
                 dev->video_mode.isoc_ctl.buf = NULL;
@@ -1751,6 +1751,7 @@ static int vidioc_s_register(struct file *file, void *priv,
                                                         0x02,
                                                         (u16)reg->reg, 1,
                                                         value, 1, 2);
+                                        break;
                         case 0x322:
                                         ret =
                                                 cx231xx_write_i2c_master(dev,
@@ -2627,8 +2628,7 @@ int cx231xx_register_analog_devices(struct cx231xx *dev)
                      dev->name, video_device_node_name(dev->vdev));
 
         /* Initialize VBI template */
-        memcpy(&cx231xx_vbi_template, &cx231xx_video_template,
-               sizeof(cx231xx_vbi_template));
+        cx231xx_vbi_template = cx231xx_video_template;
         strcpy(cx231xx_vbi_template.name, "cx231xx-vbi");
 
         /* Allocate and fill vbi video_device struct */
diff --git a/drivers/media/usb/cx231xx/cx231xx.h b/drivers/media/usb/cx231xx/cx231xx.h
index a89d020de948..3e11462be0d0 100644
--- a/drivers/media/usb/cx231xx/cx231xx.h
+++ b/drivers/media/usb/cx231xx/cx231xx.h
@@ -68,6 +68,7 @@
 #define CX231XX_BOARD_ICONBIT_U100 13
 #define CX231XX_BOARD_HAUPPAUGE_USB2_FM_PAL 14
 #define CX231XX_BOARD_HAUPPAUGE_USB2_FM_NTSC 15
+#define CX231XX_BOARD_ELGATO_VIDEO_CAPTURE_V2 16
 
 /* Limits minimum and default number of buffers */
 #define CX231XX_MIN_BUF                 4
diff --git a/drivers/media/usb/dvb-usb-v2/Kconfig b/drivers/media/usb/dvb-usb-v2/Kconfig
index 7a622dbe9b6d..692224d97d06 100644
--- a/drivers/media/usb/dvb-usb-v2/Kconfig
+++ b/drivers/media/usb/dvb-usb-v2/Kconfig
@@ -1,6 +1,6 @@
 config DVB_USB_V2
         tristate "Support for various USB DVB devices v2"
-        depends on DVB_CORE && USB && I2C && RC_CORE
+        depends on DVB_CORE && USB && I2C
         help
           By enabling this you will be able to choose the various supported
           USB1.1 and USB2.0 DVB devices.
@@ -113,6 +113,7 @@ config DVB_USB_IT913X
 config DVB_USB_LME2510
         tristate "LME DM04/QQBOX DVB-S USB2.0 support"
         depends on DVB_USB_V2
+        depends on RC_CORE
         select DVB_TDA10086 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_TDA826X if MEDIA_SUBDRV_AUTOSELECT
         select DVB_STV0288 if MEDIA_SUBDRV_AUTOSELECT
@@ -120,6 +121,7 @@ config DVB_USB_LME2510
         select DVB_STV0299 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_PLL if MEDIA_SUBDRV_AUTOSELECT
         select DVB_M88RS2000 if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_TS2020 if MEDIA_SUBDRV_AUTOSELECT
         help
           Say Y here to support the LME DM04/QQBOX DVB-S USB2.0
 
diff --git a/drivers/media/usb/dvb-usb-v2/af9015.c b/drivers/media/usb/dvb-usb-v2/af9015.c
index 943d93423705..b86d0f27a398 100644
--- a/drivers/media/usb/dvb-usb-v2/af9015.c
+++ b/drivers/media/usb/dvb-usb-v2/af9015.c
@@ -1156,6 +1156,7 @@ error:
         return ret;
 }
 
+#if IS_ENABLED(CONFIG_RC_CORE)
 struct af9015_rc_setup {
         unsigned int id;
         char *rc_codes;
@@ -1312,6 +1313,9 @@ static int af9015_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
 
         return 0;
 }
+#else
+        #define af9015_get_rc_config NULL
+#endif
 
 /* interface 0 is used by DVB-T receiver and
    interface 1 is for remote controller (HID) */
diff --git a/drivers/media/usb/dvb-usb-v2/af9035.c b/drivers/media/usb/dvb-usb-v2/af9035.c
index 61ae7f9d0b27..f11cc42454f0 100644
--- a/drivers/media/usb/dvb-usb-v2/af9035.c
+++ b/drivers/media/usb/dvb-usb-v2/af9035.c
@@ -209,10 +209,15 @@ static int af9035_i2c_master_xfer(struct i2c_adapter *adap,
                 if (msg[0].len > 40 || msg[1].len > 40) {
                         /* TODO: correct limits > 40 */
                         ret = -EOPNOTSUPP;
-                } else if (msg[0].addr == state->af9033_config[0].i2c_addr) {
-                        /* integrated demod */
+                } else if ((msg[0].addr == state->af9033_config[0].i2c_addr) ||
+                           (msg[0].addr == state->af9033_config[1].i2c_addr)) {
+                        /* demod access via firmware interface */
                         u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 |
                                         msg[0].buf[2];
+
+                        if (msg[0].addr == state->af9033_config[1].i2c_addr)
+                                reg |= 0x100000;
+
                         ret = af9035_rd_regs(d, reg, &msg[1].buf[0],
                                         msg[1].len);
                 } else {
@@ -220,6 +225,7 @@ static int af9035_i2c_master_xfer(struct i2c_adapter *adap,
                         u8 buf[5 + msg[0].len];
                         struct usb_req req = { CMD_I2C_RD, 0, sizeof(buf),
                                         buf, msg[1].len, msg[1].buf };
+                        req.mbox |= ((msg[0].addr & 0x80)  >>  3);
                         buf[0] = msg[1].len;
                         buf[1] = msg[0].addr << 1;
                         buf[2] = 0x00; /* reg addr len */
@@ -232,10 +238,15 @@ static int af9035_i2c_master_xfer(struct i2c_adapter *adap,
                 if (msg[0].len > 40) {
                         /* TODO: correct limits > 40 */
                         ret = -EOPNOTSUPP;
-                } else if (msg[0].addr == state->af9033_config[0].i2c_addr) {
-                        /* integrated demod */
+                } else if ((msg[0].addr == state->af9033_config[0].i2c_addr) ||
+                           (msg[0].addr == state->af9033_config[1].i2c_addr)) {
+                        /* demod access via firmware interface */
                         u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 |
                                         msg[0].buf[2];
+
+                        if (msg[0].addr == state->af9033_config[1].i2c_addr)
+                                reg |= 0x100000;
+
                         ret = af9035_wr_regs(d, reg, &msg[0].buf[3],
                                         msg[0].len - 3);
                 } else {
@@ -243,6 +254,7 @@ static int af9035_i2c_master_xfer(struct i2c_adapter *adap,
                         u8 buf[5 + msg[0].len];
                         struct usb_req req = { CMD_I2C_WR, 0, sizeof(buf), buf,
                                         0, NULL };
+                        req.mbox |= ((msg[0].addr & 0x80)  >>  3);
                         buf[0] = msg[0].len;
                         buf[1] = msg[0].addr << 1;
                         buf[2] = 0x00; /* reg addr len */
@@ -313,12 +325,57 @@ static int af9035_download_firmware(struct dvb_usb_device *d,
         struct usb_req req = { 0, 0, 0, NULL, 0, NULL };
         struct usb_req req_fw_dl = { CMD_FW_DL, 0, 0, wbuf, 0, NULL };
         struct usb_req req_fw_ver = { CMD_FW_QUERYINFO, 0, 1, wbuf, 4, rbuf } ;
-        u8 hdr_core;
+        u8 hdr_core, tmp;
         u16 hdr_addr, hdr_data_len, hdr_checksum;
         #define MAX_DATA 58
         #define HDR_SIZE 7
 
         /*
+         * In case of dual tuner configuration we need to do some extra
+         * initialization in order to download firmware to slave demod too,
+         * which is done by master demod.
+         * Master feeds also clock and controls power via GPIO.
+         */
+        ret = af9035_rd_reg(d, EEPROM_DUAL_MODE, &tmp);
+        if (ret < 0)
+                goto err;
+
+        if (tmp) {
+                /* configure gpioh1, reset & power slave demod */
+                ret = af9035_wr_reg_mask(d, 0x00d8b0, 0x01, 0x01);
+                if (ret < 0)
+                        goto err;
+
+                ret = af9035_wr_reg_mask(d, 0x00d8b1, 0x01, 0x01);
+                if (ret < 0)
+                        goto err;
+
+                ret = af9035_wr_reg_mask(d, 0x00d8af, 0x00, 0x01);
+                if (ret < 0)
+                        goto err;
+
+                usleep_range(10000, 50000);
+
+                ret = af9035_wr_reg_mask(d, 0x00d8af, 0x01, 0x01);
+                if (ret < 0)
+                        goto err;
+
+                /* tell the slave I2C address */
+                ret = af9035_rd_reg(d, EEPROM_2ND_DEMOD_ADDR, &tmp);
+                if (ret < 0)
+                        goto err;
+
+                ret = af9035_wr_reg(d, 0x00417f, tmp);
+                if (ret < 0)
+                        goto err;
+
+                /* enable clock out */
+                ret = af9035_wr_reg_mask(d, 0x00d81a, 0x01, 0x01);
+                if (ret < 0)
+                        goto err;
+        }
+
+        /*
          * Thanks to Daniel Glöckner <daniel-gl@gmx.net> about that info!
          *
          * byte 0: MCS 51 core
@@ -380,6 +437,10 @@ static int af9035_download_firmware(struct dvb_usb_device *d,
                                 __func__, fw->size - i);
         }
 
+        /* print warn if firmware is bad, continue and see what happens */
+        if (i)
+                dev_warn(&d->udev->dev, "%s: bad firmware\n", KBUILD_MODNAME);
+
         /* firmware loaded, request boot */
         req.cmd = CMD_FW_BOOT;
         ret = af9035_ctrl_msg(d, &req);
@@ -489,14 +550,28 @@ static int af9035_read_config(struct dvb_usb_device *d)
         u8 tmp;
         u16 tmp16;
 
+        /* demod I2C "address" */
+        state->af9033_config[0].i2c_addr = 0x38;
+
         /* check if there is dual tuners */
         ret = af9035_rd_reg(d, EEPROM_DUAL_MODE, &tmp);
         if (ret < 0)
                 goto err;
 
         state->dual_mode = tmp;
-        dev_dbg(&d->udev->dev, "%s: dual mode=%d\n",
-                        __func__, state->dual_mode);
+        dev_dbg(&d->udev->dev, "%s: dual mode=%d\n", __func__,
+                        state->dual_mode);
+
+        if (state->dual_mode) {
+                /* read 2nd demodulator I2C address */
+                ret = af9035_rd_reg(d, EEPROM_2ND_DEMOD_ADDR, &tmp);
+                if (ret < 0)
+                        goto err;
+
+                state->af9033_config[1].i2c_addr = tmp;
+                dev_dbg(&d->udev->dev, "%s: 2nd demod I2C addr=%02x\n",
+                                __func__, tmp);
+        }
 
         for (i = 0; i < state->dual_mode + 1; i++) {
                 /* tuner */
@@ -514,6 +589,7 @@ static int af9035_read_config(struct dvb_usb_device *d)
                 case AF9033_TUNER_MXL5007T:
                 case AF9033_TUNER_TDA18218:
                 case AF9033_TUNER_FC2580:
+                case AF9033_TUNER_FC0012:
                         state->af9033_config[i].spec_inv = 1;
                         break;
                 default:
@@ -522,6 +598,18 @@ static int af9035_read_config(struct dvb_usb_device *d)
                                         KBUILD_MODNAME, tmp);
                 }
 
+                /* disable dual mode if driver does not support it */
+                if (i == 1)
+                        switch (tmp) {
+                        case AF9033_TUNER_FC0012:
+                                break;
+                        default:
+                                state->dual_mode = false;
+                                dev_info(&d->udev->dev, "%s: driver does not " \
+                                                "support 2nd tuner and will " \
+                                                "disable it", KBUILD_MODNAME);
+                }
+
                 /* tuner IF frequency */
                 ret = af9035_rd_reg(d, EEPROM_1_IFFREQ_L + eeprom_shift, &tmp);
                 if (ret < 0)
@@ -730,6 +818,12 @@ static int af9035_frontend_callback(void *adapter_priv, int component,
         return 0;
 }
 
+static int af9035_get_adapter_count(struct dvb_usb_device *d)
+{
+        struct state *state = d_to_priv(d);
+        return state->dual_mode + 1;
+}
+
 static int af9035_frontend_attach(struct dvb_usb_adapter *adap)
 {
         struct state *state = adap_to_priv(adap);
@@ -751,15 +845,14 @@ static int af9035_frontend_attach(struct dvb_usb_adapter *adap)
                 if (ret < 0)
                         goto err;
 
-                ret = af9035_wr_reg(d, 0x00d81a,
-                                state->dual_mode);
+                ret = af9035_wr_reg(d, 0x00d81a, state->dual_mode);
                 if (ret < 0)
                         goto err;
         }
 
         /* attach demodulator */
-        adap->fe[0] = dvb_attach(af9033_attach,
-                        &state->af9033_config[adap->id], &d->i2c_adap);
+        adap->fe[0] = dvb_attach(af9033_attach, &state->af9033_config[adap->id],
+                        &d->i2c_adap);
         if (adap->fe[0] == NULL) {
                 ret = -ENODEV;
                 goto err;
@@ -785,13 +878,22 @@ static const struct fc0011_config af9035_fc0011_config = {
         .i2c_address = 0x60,
 };
 
-static struct mxl5007t_config af9035_mxl5007t_config = {
-        .xtal_freq_hz = MxL_XTAL_24_MHZ,
-        .if_freq_hz = MxL_IF_4_57_MHZ,
-        .invert_if = 0,
-        .loop_thru_enable = 0,
-        .clk_out_enable = 0,
-        .clk_out_amp = MxL_CLKOUT_AMP_0_94V,
+static struct mxl5007t_config af9035_mxl5007t_config[] = {
+        {
+                .xtal_freq_hz = MxL_XTAL_24_MHZ,
+                .if_freq_hz = MxL_IF_4_57_MHZ,
+                .invert_if = 0,
+                .loop_thru_enable = 0,
+                .clk_out_enable = 0,
+                .clk_out_amp = MxL_CLKOUT_AMP_0_94V,
+        }, {
+                .xtal_freq_hz = MxL_XTAL_24_MHZ,
+                .if_freq_hz = MxL_IF_4_57_MHZ,
+                .invert_if = 0,
+                .loop_thru_enable = 1,
+                .clk_out_enable = 1,
+                .clk_out_amp = MxL_CLKOUT_AMP_0_94V,
+        }
 };
 
 static struct tda18218_config af9035_tda18218_config = {
@@ -804,12 +906,32 @@ static const struct fc2580_config af9035_fc2580_config = {
         .clock = 16384000,
 };
 
+static const struct fc0012_config af9035_fc0012_config[] = {
+        {
+                .i2c_address = 0x63,
+                .xtal_freq = FC_XTAL_36_MHZ,
+                .dual_master = true,
+                .loop_through = true,
+                .clock_out = true,
+        }, {
+                .i2c_address = 0x63 | 0x80, /* I2C bus select hack */
+                .xtal_freq = FC_XTAL_36_MHZ,
+                .dual_master = true,
+        }
+};
+
 static int af9035_tuner_attach(struct dvb_usb_adapter *adap)
 {
         struct state *state = adap_to_priv(adap);
         struct dvb_usb_device *d = adap_to_d(adap);
         int ret;
         struct dvb_frontend *fe;
+        struct i2c_msg msg[1];
+        u8 tuner_addr;
+        /*
+         * XXX: Hack used in that function: we abuse unused I2C address bit [7]
+         * to carry info about used I2C bus for dual tuner configuration.
+         */
 
         switch (state->af9033_config[adap->id].tuner) {
         case AF9033_TUNER_TUA9001:
@@ -842,46 +964,59 @@ static int af9035_tuner_attach(struct dvb_usb_adapter *adap)
                                 &d->i2c_adap, &af9035_fc0011_config);
                 break;
         case AF9033_TUNER_MXL5007T:
-                ret = af9035_wr_reg(d, 0x00d8e0, 1);
-                if (ret < 0)
-                        goto err;
-                ret = af9035_wr_reg(d, 0x00d8e1, 1);
-                if (ret < 0)
-                        goto err;
-                ret = af9035_wr_reg(d, 0x00d8df, 0);
-                if (ret < 0)
-                        goto err;
+                if (adap->id == 0) {
+                        ret = af9035_wr_reg(d, 0x00d8e0, 1);
+                        if (ret < 0)
+                                goto err;
 
-                msleep(30);
+                        ret = af9035_wr_reg(d, 0x00d8e1, 1);
+                        if (ret < 0)
+                                goto err;
 
-                ret = af9035_wr_reg(d, 0x00d8df, 1);
-                if (ret < 0)
-                        goto err;
+                        ret = af9035_wr_reg(d, 0x00d8df, 0);
+                        if (ret < 0)
+                                goto err;
 
-                msleep(300);
+                        msleep(30);
 
-                ret = af9035_wr_reg(d, 0x00d8c0, 1);
-                if (ret < 0)
-                        goto err;
-                ret = af9035_wr_reg(d, 0x00d8c1, 1);
-                if (ret < 0)
-                        goto err;
-                ret = af9035_wr_reg(d, 0x00d8bf, 0);
-                if (ret < 0)
-                        goto err;
-                ret = af9035_wr_reg(d, 0x00d8b4, 1);
-                if (ret < 0)
-                        goto err;
-                ret = af9035_wr_reg(d, 0x00d8b5, 1);
-                if (ret < 0)
-                        goto err;
-                ret = af9035_wr_reg(d, 0x00d8b3, 1);
-                if (ret < 0)
-                        goto err;
+                        ret = af9035_wr_reg(d, 0x00d8df, 1);
+                        if (ret < 0)
+                                goto err;
+
+                        msleep(300);
+
+                        ret = af9035_wr_reg(d, 0x00d8c0, 1);
+                        if (ret < 0)
+                                goto err;
+
+                        ret = af9035_wr_reg(d, 0x00d8c1, 1);
+                        if (ret < 0)
+                                goto err;
+
+                        ret = af9035_wr_reg(d, 0x00d8bf, 0);
+                        if (ret < 0)
+                                goto err;
+
+                        ret = af9035_wr_reg(d, 0x00d8b4, 1);
+                        if (ret < 0)
+                                goto err;
+
+                        ret = af9035_wr_reg(d, 0x00d8b5, 1);
+                        if (ret < 0)
+                                goto err;
+
+                        ret = af9035_wr_reg(d, 0x00d8b3, 1);
+                        if (ret < 0)
+                                goto err;
+
+                        tuner_addr = 0x60;
+                } else {
+                        tuner_addr = 0x60 | 0x80; /* I2C bus hack */
+                }
 
                 /* attach tuner */
-                fe = dvb_attach(mxl5007t_attach, adap->fe[0],
-                                &d->i2c_adap, 0x60, &af9035_mxl5007t_config);
+                fe = dvb_attach(mxl5007t_attach, adap->fe[0], &d->i2c_adap,
+                                tuner_addr, &af9035_mxl5007t_config[adap->id]);
                 break;
         case AF9033_TUNER_TDA18218:
                 /* attach tuner */
@@ -907,6 +1042,46 @@ static int af9035_tuner_attach(struct dvb_usb_adapter *adap)
                 fe = dvb_attach(fc2580_attach, adap->fe[0],
                                 &d->i2c_adap, &af9035_fc2580_config);
                 break;
+        case AF9033_TUNER_FC0012:
+                /*
+                 * AF9035 gpiot2 = FC0012 enable
+                 * XXX: there seems to be something on gpioh8 too, but on my
+                 * my test I didn't find any difference.
+                 */
+
+                if (adap->id == 0) {
+                        /* configure gpiot2 as output and high */
+                        ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01);
+                        if (ret < 0)
+                                goto err;
+
+                        ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01);
+                        if (ret < 0)
+                                goto err;
+
+                        ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01);
+                        if (ret < 0)
+                                goto err;
+                } else {
+                        /*
+                         * FIXME: That belongs for the FC0012 driver.
+                         * Write 02 to FC0012 master tuner register 0d directly
+                         * in order to make slave tuner working.
+                         */
+                        msg[0].addr = 0x63;
+                        msg[0].flags = 0;
+                        msg[0].len = 2;
+                        msg[0].buf = "\x0d\x02";
+                        ret = i2c_transfer(&d->i2c_adap, msg, 1);
+                        if (ret < 0)
+                                goto err;
+                }
+
+                usleep_range(10000, 50000);
+
+                fe = dvb_attach(fc0012_attach, adap->fe[0], &d->i2c_adap,
+                                &af9035_fc0012_config[adap->id]);
+                break;
         default:
                 fe = NULL;
         }
@@ -945,8 +1120,8 @@ static int af9035_init(struct dvb_usb_device *d)
                 { 0x00dd8a, (frame_size >> 0) & 0xff, 0xff},
                 { 0x00dd8b, (frame_size >> 8) & 0xff, 0xff},
                 { 0x00dd0d, packet_size, 0xff },
-                { 0x80f9a3, 0x00, 0x01 },
-                { 0x80f9cd, 0x00, 0x01 },
+                { 0x80f9a3, state->dual_mode, 0x01 },
+                { 0x80f9cd, state->dual_mode, 0x01 },
                 { 0x80f99d, 0x00, 0x01 },
                 { 0x80f9a4, 0x00, 0x01 },
         };
@@ -971,6 +1146,7 @@ err:
         return ret;
 }
 
+#if IS_ENABLED(CONFIG_RC_CORE)
 static int af9035_rc_query(struct dvb_usb_device *d)
 {
         unsigned int key;
@@ -1045,6 +1221,9 @@ err:
 
         return ret;
 }
+#else
+        #define af9035_get_rc_config NULL
+#endif
 
 /* interface 0 is used by DVB-T receiver and
    interface 1 is for remote controller (HID) */
@@ -1068,7 +1247,7 @@ static const struct dvb_usb_device_properties af9035_props = {
         .init = af9035_init,
         .get_rc_config = af9035_get_rc_config,
 
-        .num_adapters = 1,
+        .get_adapter_count = af9035_get_adapter_count,
         .adapter = {
                 {
                         .stream = DVB_USB_STREAM_BULK(0x84, 6, 87 * 188),
diff --git a/drivers/media/usb/dvb-usb-v2/af9035.h b/drivers/media/usb/dvb-usb-v2/af9035.h
index 75ef1ec13fbf..29f3eec22c2c 100644
--- a/drivers/media/usb/dvb-usb-v2/af9035.h
+++ b/drivers/media/usb/dvb-usb-v2/af9035.h
@@ -26,6 +26,7 @@
 #include "af9033.h"
 #include "tua9001.h"
 #include "fc0011.h"
+#include "fc0012.h"
 #include "mxl5007t.h"
 #include "tda18218.h"
 #include "fc2580.h"
@@ -53,7 +54,6 @@ struct usb_req {
 struct state {
         u8 seq; /* packet sequence number */
         bool dual_mode;
-
         struct af9033_config af9033_config[2];
 };
 
@@ -91,6 +91,7 @@ u32 clock_lut_it9135[] = {
 /* EEPROM locations */
 #define EEPROM_IR_MODE            0x430d
 #define EEPROM_DUAL_MODE          0x4326
+#define EEPROM_2ND_DEMOD_ADDR     0x4327
 #define EEPROM_IR_TYPE            0x4329
 #define EEPROM_1_IFFREQ_L         0x432d
 #define EEPROM_1_IFFREQ_H         0x432e
diff --git a/drivers/media/usb/dvb-usb-v2/anysee.c b/drivers/media/usb/dvb-usb-v2/anysee.c
index d05c5b563dac..a20d691d0b63 100644
--- a/drivers/media/usb/dvb-usb-v2/anysee.c
+++ b/drivers/media/usb/dvb-usb-v2/anysee.c
@@ -1019,6 +1019,7 @@ static int anysee_tuner_attach(struct dvb_usb_adapter *adap)
         return ret;
 }
 
+#if IS_ENABLED(CONFIG_RC_CORE)
 static int anysee_rc_query(struct dvb_usb_device *d)
 {
         u8 buf[] = {CMD_GET_IR_CODE};
@@ -1054,6 +1055,9 @@ static int anysee_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
 
         return 0;
 }
+#else
+        #define anysee_get_rc_config NULL
+#endif
 
 static int anysee_ci_read_attribute_mem(struct dvb_ca_en50221 *ci, int slot,
         int addr)
diff --git a/drivers/media/usb/dvb-usb-v2/az6007.c b/drivers/media/usb/dvb-usb-v2/az6007.c
index d75dbf27e99e..70ec80d8be71 100644
--- a/drivers/media/usb/dvb-usb-v2/az6007.c
+++ b/drivers/media/usb/dvb-usb-v2/az6007.c
@@ -189,6 +189,7 @@ static int az6007_streaming_ctrl(struct dvb_frontend *fe, int onoff)
         return az6007_write(d, 0xbc, onoff, 0, NULL, 0);
 }
 
+#if IS_ENABLED(CONFIG_RC_CORE)
 /* remote control stuff (does not work with my box) */
 static int az6007_rc_query(struct dvb_usb_device *d)
 {
@@ -215,6 +216,20 @@ static int az6007_rc_query(struct dvb_usb_device *d)
         return 0;
 }
 
+static int az6007_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
+{
+        pr_debug("Getting az6007 Remote Control properties\n");
+
+        rc->allowed_protos = RC_BIT_NEC;
+        rc->query          = az6007_rc_query;
+        rc->interval       = 400;
+
+        return 0;
+}
+#else
+        #define az6007_get_rc_config NULL
+#endif
+
 static int az6007_ci_read_attribute_mem(struct dvb_ca_en50221 *ca,
                                         int slot,
                                         int address)
@@ -822,17 +837,6 @@ static void az6007_usb_disconnect(struct usb_interface *intf)
         dvb_usbv2_disconnect(intf);
 }
 
-static int az6007_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
-{
-        pr_debug("Getting az6007 Remote Control properties\n");
-
-        rc->allowed_protos = RC_BIT_NEC;
-        rc->query          = az6007_rc_query;
-        rc->interval       = 400;
-
-        return 0;
-}
-
 static int az6007_download_firmware(struct dvb_usb_device *d,
         const struct firmware *fw)
 {
diff --git a/drivers/media/usb/dvb-usb-v2/dvb_usb.h b/drivers/media/usb/dvb-usb-v2/dvb_usb.h
index 059291b892b8..3cac8bd0b116 100644
--- a/drivers/media/usb/dvb-usb-v2/dvb_usb.h
+++ b/drivers/media/usb/dvb-usb-v2/dvb_usb.h
@@ -347,6 +347,7 @@ struct dvb_usb_adapter {
  * @props: device properties
  * @name: device name
  * @rc_map: name of rc codes table
+ * @rc_polling_active: set when RC polling is active
  * @udev: pointer to the device's struct usb_device
  * @intf: pointer to the device's usb interface
  * @rc: remote controller configuration
@@ -364,7 +365,7 @@ struct dvb_usb_device {
         const struct dvb_usb_device_properties *props;
         const char *name;
         const char *rc_map;
-
+        bool rc_polling_active;
         struct usb_device *udev;
         struct usb_interface *intf;
         struct dvb_usb_rc rc;
diff --git a/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c b/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
index 671b4fa232b4..086792055912 100644
--- a/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
+++ b/drivers/media/usb/dvb-usb-v2/dvb_usb_core.c
@@ -102,6 +102,7 @@ static int dvb_usbv2_i2c_exit(struct dvb_usb_device *d)
         return 0;
 }
 
+#if IS_ENABLED(CONFIG_RC_CORE)
 static void dvb_usb_read_remote_control(struct work_struct *work)
 {
         struct dvb_usb_device *d = container_of(work,
@@ -112,13 +113,16 @@ static void dvb_usb_read_remote_control(struct work_struct *work)
          * When the parameter has been set to 1 via sysfs while the
          * driver was running, or when bulk mode is enabled after IR init.
          */
-        if (dvb_usbv2_disable_rc_polling || d->rc.bulk_mode)
+        if (dvb_usbv2_disable_rc_polling || d->rc.bulk_mode) {
+                d->rc_polling_active = false;
                 return;
+        }
 
         ret = d->rc.query(d);
         if (ret < 0) {
                 dev_err(&d->udev->dev, "%s: rc.query() failed=%d\n",
                                 KBUILD_MODNAME, ret);
+                d->rc_polling_active = false;
                 return; /* stop polling */
         }
 
@@ -182,6 +186,7 @@ static int dvb_usbv2_remote_init(struct dvb_usb_device *d)
                                 d->rc.interval);
                 schedule_delayed_work(&d->rc_query_work,
                                 msecs_to_jiffies(d->rc.interval));
+                d->rc_polling_active = true;
         }
 
         return 0;
@@ -202,6 +207,10 @@ static int dvb_usbv2_remote_exit(struct dvb_usb_device *d)
 
         return 0;
 }
+#else
+        #define dvb_usbv2_remote_init(args...) 0
+        #define dvb_usbv2_remote_exit(args...)
+#endif
 
 static void dvb_usb_data_complete(struct usb_data_stream *stream, u8 *buf,
                 size_t len)
@@ -959,7 +968,7 @@ int dvb_usbv2_suspend(struct usb_interface *intf, pm_message_t msg)
         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 
         /* stop remote controller poll */
-        if (d->rc.query && !d->rc.bulk_mode)
+        if (d->rc_polling_active)
                 cancel_delayed_work_sync(&d->rc_query_work);
 
         for (i = MAX_NO_OF_ADAPTER_PER_DEVICE - 1; i >= 0; i--) {
@@ -1006,7 +1015,7 @@ static int dvb_usbv2_resume_common(struct dvb_usb_device *d)
         }
 
         /* start remote controller poll */
-        if (d->rc.query && !d->rc.bulk_mode)
+        if (d->rc_polling_active)
                 schedule_delayed_work(&d->rc_query_work,
                                 msecs_to_jiffies(d->rc.interval));
 
diff --git a/drivers/media/usb/dvb-usb-v2/it913x.c b/drivers/media/usb/dvb-usb-v2/it913x.c
index 47204280b8b3..833847995c65 100644
--- a/drivers/media/usb/dvb-usb-v2/it913x.c
+++ b/drivers/media/usb/dvb-usb-v2/it913x.c
@@ -308,7 +308,7 @@ static struct i2c_algorithm it913x_i2c_algo = {
 };
 
 /* Callbacks for DVB USB */
-#define IT913X_POLL 250
+#if IS_ENABLED(CONFIG_RC_CORE)
 static int it913x_rc_query(struct dvb_usb_device *d)
 {
         u8 ibuf[4];
@@ -334,6 +334,25 @@ static int it913x_rc_query(struct dvb_usb_device *d)
         return ret;
 }
 
+static int it913x_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
+{
+        struct it913x_state *st = d->priv;
+
+        if (st->proprietary_ir == false) {
+                rc->map_name = NULL;
+                return 0;
+        }
+
+        rc->allowed_protos = RC_BIT_NEC;
+        rc->query = it913x_rc_query;
+        rc->interval = 250;
+
+        return 0;
+}
+#else
+        #define it913x_get_rc_config NULL
+#endif
+
 /* Firmware sets raw */
 static const char fw_it9135_v1[] = FW_IT9135_V1;
 static const char fw_it9135_v2[] = FW_IT9135_V2;
@@ -643,7 +662,8 @@ static int it913x_frontend_attach(struct dvb_usb_adapter *adap)
         struct it913x_state *st = d->priv;
         int ret = 0;
         u8 adap_addr = I2C_BASE_ADDR + (adap->id << 5);
-        u16 ep_size = adap->stream.buf_size / 4;
+        u16 ep_size = (adap->pid_filtering) ? TS_BUFFER_SIZE_PID / 4 :
+                TS_BUFFER_SIZE_MAX / 4;
         u8 pkt_size = 0x80;
 
         if (d->udev->speed != USB_SPEED_HIGH)
@@ -695,22 +715,6 @@ static int it913x_frontend_attach(struct dvb_usb_adapter *adap)
 }
 
 /* DVB USB Driver */
-static int it913x_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
-{
-        struct it913x_state *st = d->priv;
-
-        if (st->proprietary_ir == false) {
-                rc->map_name = NULL;
-                return 0;
-        }
-
-        rc->allowed_protos = RC_BIT_NEC;
-        rc->query = it913x_rc_query;
-        rc->interval = 250;
-
-        return 0;
-}
-
 static int it913x_get_adapter_count(struct dvb_usb_device *d)
 {
         struct it913x_state *st = d->priv;
@@ -779,6 +783,18 @@ static const struct usb_device_id it913x_id_table[] = {
         { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9006,
                 &it913x_properties, "ITE 9135(9006) Generic",
                         RC_MAP_IT913X_V1) },
+        { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_1835,
+                &it913x_properties, "Avermedia A835B(1835)",
+                        RC_MAP_IT913X_V2) },
+        { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_2835,
+                &it913x_properties, "Avermedia A835B(2835)",
+                        RC_MAP_IT913X_V2) },
+        { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_3835,
+                &it913x_properties, "Avermedia A835B(3835)",
+                        RC_MAP_IT913X_V2) },
+        { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_4835,
+                &it913x_properties, "Avermedia A835B(4835)",
+                        RC_MAP_IT913X_V2) },
         {}              /* Terminating entry */
 };
 
@@ -797,7 +813,7 @@ module_usb_driver(it913x_driver);
 
 MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
 MODULE_DESCRIPTION("it913x USB 2 Driver");
-MODULE_VERSION("1.32");
+MODULE_VERSION("1.33");
 MODULE_LICENSE("GPL");
 MODULE_FIRMWARE(FW_IT9135_V1);
 MODULE_FIRMWARE(FW_IT9135_V2);
diff --git a/drivers/media/usb/dvb-usb-v2/lmedm04.c b/drivers/media/usb/dvb-usb-v2/lmedm04.c
index 6427ac359f21..f30c58cecbba 100644
--- a/drivers/media/usb/dvb-usb-v2/lmedm04.c
+++ b/drivers/media/usb/dvb-usb-v2/lmedm04.c
@@ -81,6 +81,7 @@
 #include "dvb-pll.h"
 #include "z0194a.h"
 #include "m88rs2000.h"
+#include "ts2020.h"
 
 
 #define LME2510_C_S7395 "dvb-usb-lme2510c-s7395.fw";
@@ -626,8 +627,8 @@ static int lme2510_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
                 gate = 5;
 
         for (i = 0; i < num; i++) {
-                read_o = 1 & (msg[i].flags & I2C_M_RD);
-                read = i+1 < num && (msg[i+1].flags & I2C_M_RD);
+                read_o = msg[i].flags & I2C_M_RD;
+                read = i + 1 < num && msg[i + 1].flags & I2C_M_RD;
                 read |= read_o;
                 gate = (msg[i].addr == st->i2c_tuner_addr)
                         ? (read)        ? st->i2c_tuner_gate_r
@@ -640,7 +641,8 @@ static int lme2510_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
                 else
                         obuf[1] = msg[i].len + read + 1;
 
-                obuf[2] = msg[i].addr;
+                obuf[2] = msg[i].addr << 1;
+
                 if (read) {
                         if (read_o)
                                 len = 3;
@@ -894,27 +896,27 @@ static int lme2510_kill_urb(struct usb_data_stream *stream)
 }
 
 static struct tda10086_config tda10086_config = {
-        .demod_address = 0x1c,
+        .demod_address = 0x0e,
         .invert = 0,
         .diseqc_tone = 1,
         .xtal_freq = TDA10086_XTAL_16M,
 };
 
 static struct stv0288_config lme_config = {
-        .demod_address = 0xd0,
+        .demod_address = 0x68,
         .min_delay_ms = 15,
         .inittab = s7395_inittab,
 };
 
 static struct ix2505v_config lme_tuner = {
-        .tuner_address = 0xc0,
+        .tuner_address = 0x60,
         .min_delay_ms = 100,
         .tuner_gain = 0x0,
         .tuner_chargepump = 0x3,
 };
 
 static struct stv0299_config sharp_z0194_config = {
-        .demod_address = 0xd0,
+        .demod_address = 0x68,
         .inittab = sharp_z0194a_inittab,
         .mclk = 88000000UL,
         .invert = 0,
@@ -943,11 +945,15 @@ static int dm04_rs2000_set_ts_param(struct dvb_frontend *fe,
 }
 
 static struct m88rs2000_config m88rs2000_config = {
-        .demod_addr = 0xd0,
-        .tuner_addr = 0xc0,
+        .demod_addr = 0x68,
         .set_ts_params = dm04_rs2000_set_ts_param,
 };
 
+static struct ts2020_config ts2020_config = {
+        .tuner_address = 0x60,
+        .clk_out_div = 7,
+};
+
 static int dm04_lme2510_set_voltage(struct dvb_frontend *fe,
                                         fe_sec_voltage_t voltage)
 {
@@ -1049,7 +1055,7 @@ static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter *adap)
                         info("TUN Found Frontend TDA10086");
                         st->i2c_tuner_gate_w = 4;
                         st->i2c_tuner_gate_r = 4;
-                        st->i2c_tuner_addr = 0xc0;
+                        st->i2c_tuner_addr = 0x60;
                         st->tuner_config = TUNER_LG;
                         if (st->dvb_usb_lme2510_firmware != TUNER_LG) {
                                 st->dvb_usb_lme2510_firmware = TUNER_LG;
@@ -1065,7 +1071,7 @@ static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter *adap)
                         info("FE Found Stv0299");
                         st->i2c_tuner_gate_w = 4;
                         st->i2c_tuner_gate_r = 5;
-                        st->i2c_tuner_addr = 0xc0;
+                        st->i2c_tuner_addr = 0x60;
                         st->tuner_config = TUNER_S0194;
                         if (st->dvb_usb_lme2510_firmware != TUNER_S0194) {
                                 st->dvb_usb_lme2510_firmware = TUNER_S0194;
@@ -1082,7 +1088,7 @@ static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter *adap)
                         info("FE Found Stv0288");
                         st->i2c_tuner_gate_w = 4;
                         st->i2c_tuner_gate_r = 5;
-                        st->i2c_tuner_addr = 0xc0;
+                        st->i2c_tuner_addr = 0x60;
                         st->tuner_config = TUNER_S7395;
                         if (st->dvb_usb_lme2510_firmware != TUNER_S7395) {
                                 st->dvb_usb_lme2510_firmware = TUNER_S7395;
@@ -1097,9 +1103,11 @@ static int dm04_lme2510_frontend_attach(struct dvb_usb_adapter *adap)
 
                 if (adap->fe[0]) {
                         info("FE Found M88RS2000");
+                        dvb_attach(ts2020_attach, adap->fe[0], &ts2020_config,
+                                        &d->i2c_adap);
                         st->i2c_tuner_gate_w = 5;
                         st->i2c_tuner_gate_r = 5;
-                        st->i2c_tuner_addr = 0xc0;
+                        st->i2c_tuner_addr = 0x60;
                         st->tuner_config = TUNER_RS2000;
                         st->fe_set_voltage =
                                 adap->fe[0]->ops.set_voltage;
@@ -1144,7 +1152,7 @@ static int dm04_lme2510_tuner(struct dvb_usb_adapter *adap)
 
         switch (st->tuner_config) {
         case TUNER_LG:
-                if (dvb_attach(tda826x_attach, adap->fe[0], 0xc0,
+                if (dvb_attach(tda826x_attach, adap->fe[0], 0x60,
                         &d->i2c_adap, 1))
                         ret = st->tuner_config;
                 break;
@@ -1154,7 +1162,7 @@ static int dm04_lme2510_tuner(struct dvb_usb_adapter *adap)
                         ret = st->tuner_config;
                 break;
         case TUNER_S0194:
-                if (dvb_attach(dvb_pll_attach , adap->fe[0], 0xc0,
+                if (dvb_attach(dvb_pll_attach , adap->fe[0], 0x60,
                         &d->i2c_adap, DVB_PLL_OPERA1))
                         ret = st->tuner_config;
                 break;
diff --git a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
index a4c302d0aa37..d98387a3c95e 100644
--- a/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
+++ b/drivers/media/usb/dvb-usb-v2/rtl28xxu.c
@@ -835,6 +835,11 @@ static struct tua9001_config rtl2832u_tua9001_config = {
         .i2c_addr = 0x60,
 };
 
+static const struct fc0012_config rtl2832u_fc0012_config = {
+        .i2c_address = 0x63, /* 0xc6 >> 1 */
+        .xtal_freq = FC_XTAL_28_8_MHZ,
+};
+
 static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap)
 {
         int ret;
@@ -847,7 +852,7 @@ static int rtl2832u_tuner_attach(struct dvb_usb_adapter *adap)
         switch (priv->tuner) {
         case TUNER_RTL2832_FC0012:
                 fe = dvb_attach(fc0012_attach, adap->fe[0],
-                        &d->i2c_adap, 0xc6>>1, 0, FC_XTAL_28_8_MHZ);
+                        &d->i2c_adap, &rtl2832u_fc0012_config);
 
                 /* since fc0012 includs reading the signal strength delegate
                  * that to the tuner driver */
@@ -1120,7 +1125,7 @@ err:
         return ret;
 }
 
-
+#if IS_ENABLED(CONFIG_RC_CORE)
 static int rtl2831u_rc_query(struct dvb_usb_device *d)
 {
         int ret, i;
@@ -1203,7 +1208,11 @@ static int rtl2831u_get_rc_config(struct dvb_usb_device *d,
 
         return 0;
 }
+#else
+        #define rtl2831u_get_rc_config NULL
+#endif
 
+#if IS_ENABLED(CONFIG_RC_CORE)
 static int rtl2832u_rc_query(struct dvb_usb_device *d)
 {
         int ret, i;
@@ -1275,6 +1284,9 @@ static int rtl2832u_get_rc_config(struct dvb_usb_device *d,
 
         return 0;
 }
+#else
+        #define rtl2832u_get_rc_config NULL
+#endif
 
 static const struct dvb_usb_device_properties rtl2831u_props = {
         .driver_name = KBUILD_MODNAME,
@@ -1333,13 +1345,13 @@ static const struct usb_device_id rtl28xxu_id_table[] = {
         { DVB_USB_DEVICE(USB_VID_REALTEK, 0x2838,
                 &rtl2832u_props, "Realtek RTL2832U reference design", NULL) },
         { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_BLACK_REV1,
-                &rtl2832u_props, "Terratec Cinergy T Stick Black", NULL) },
+                &rtl2832u_props, "TerraTec Cinergy T Stick Black", NULL) },
         { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_DELOCK_USB2_DVBT,
                 &rtl2832u_props, "G-Tek Electronics Group Lifeview LV5TDLX DVB-T", NULL) },
         { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_NOXON_DAB_STICK,
-                &rtl2832u_props, "NOXON DAB/DAB+ USB dongle", NULL) },
+                &rtl2832u_props, "TerraTec NOXON DAB Stick", NULL) },
         { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_NOXON_DAB_STICK_REV2,
-                &rtl2832u_props, "NOXON DAB/DAB+ USB dongle (rev 2)", NULL) },
+                &rtl2832u_props, "TerraTec NOXON DAB Stick (rev 2)", NULL) },
         { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_TREKSTOR_TERRES_2_0,
                 &rtl2832u_props, "Trekstor DVB-T Stick Terres 2.0", NULL) },
         { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x1101,
@@ -1352,6 +1364,14 @@ static const struct usb_device_id rtl28xxu_id_table[] = {
                 &rtl2832u_props, "Dexatek DK mini DVB-T Dongle", NULL) },
         { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00d7,
                 &rtl2832u_props, "TerraTec Cinergy T Stick+", NULL) },
+        { DVB_USB_DEVICE(USB_VID_KWORLD_2, 0xd3a8,
+                &rtl2832u_props, "ASUS My Cinema-U3100Mini Plus V2", NULL) },
+        { DVB_USB_DEVICE(USB_VID_KWORLD_2, 0xd393,
+                &rtl2832u_props, "GIGABYTE U7300", NULL) },
+        { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x1104,
+                &rtl2832u_props, "Digivox Micro Hd", NULL) },
+        { DVB_USB_DEVICE(USB_VID_COMPRO, 0x0620,
+                &rtl2832u_props, "Compro VideoMate U620F", NULL) },
         { }
 };
 MODULE_DEVICE_TABLE(usb, rtl28xxu_id_table);
diff --git a/drivers/media/usb/dvb-usb/Kconfig b/drivers/media/usb/dvb-usb/Kconfig
index fa0b2931d305..c5d95662e2e1 100644
--- a/drivers/media/usb/dvb-usb/Kconfig
+++ b/drivers/media/usb/dvb-usb/Kconfig
@@ -202,8 +202,12 @@ config DVB_USB_TTUSB2
         select DVB_TDA10086 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_LNBP21 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_TDA826X if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_TDA10023 if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_TDA10048 if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_TDA827X if MEDIA_SUBDRV_AUTOSELECT
         help
-          Say Y here to support the Pinnacle 400e DVB-S USB2.0 receiver. The
+          Say Y here to support the Pinnacle 400e DVB-S USB2.0 receiver and
+          the TechnoTrend CT-3650 CI DVB-C/T USB2.0 receiver. The
           firmware protocol used by this module is similar to the one used by the
           old ttusb-driver - that's why the module is called dvb-usb-ttusb2.
 
@@ -267,9 +271,11 @@ config DVB_USB_DW2102
         select DVB_MT312 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_ZL10039 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_DS3000 if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_TS2020 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_STB6100 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_STV6110 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_STV0900 if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_M88RS2000 if MEDIA_SUBDRV_AUTOSELECT
         help
           Say Y here to support the DvbWorld, TeVii, Prof DVB-S/S2 USB2.0
           receivers.
diff --git a/drivers/media/usb/dvb-usb/dib0700_core.c b/drivers/media/usb/dvb-usb/dib0700_core.c
index 19b5ed2825d7..bf2a908d74cf 100644
--- a/drivers/media/usb/dvb-usb/dib0700_core.c
+++ b/drivers/media/usb/dvb-usb/dib0700_core.c
@@ -561,10 +561,7 @@ int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
                 }
         }
 
-        if (mutex_lock_interruptible(&adap->dev->usb_mutex) < 0) {
-                err("could not acquire lock");
-                return -EINTR;
-        }
+        mutex_lock(&adap->dev->usb_mutex);
 
         st->buf[0] = REQUEST_ENABLE_VIDEO;
         /* this bit gives a kind of command,
diff --git a/drivers/media/usb/dvb-usb/dvb-usb-init.c b/drivers/media/usb/dvb-usb/dvb-usb-init.c
index 169196ec2d4e..1adf325012f7 100644
--- a/drivers/media/usb/dvb-usb/dvb-usb-init.c
+++ b/drivers/media/usb/dvb-usb/dvb-usb-init.c
@@ -38,41 +38,41 @@ static int dvb_usb_adapter_init(struct dvb_usb_device *d, short *adapter_nrs)
 
                 memcpy(&adap->props, &d->props.adapter[n], sizeof(struct dvb_usb_adapter_properties));
 
-        for (o = 0; o < adap->props.num_frontends; o++) {
-                struct dvb_usb_adapter_fe_properties *props = &adap->props.fe[o];
-                /* speed - when running at FULL speed we need a HW PID filter */
-                if (d->udev->speed == USB_SPEED_FULL && !(props->caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
-                        err("This USB2.0 device cannot be run on a USB1.1 port. (it lacks a hardware PID filter)");
-                        return -ENODEV;
-                }
+                for (o = 0; o < adap->props.num_frontends; o++) {
+                        struct dvb_usb_adapter_fe_properties *props = &adap->props.fe[o];
+                        /* speed - when running at FULL speed we need a HW PID filter */
+                        if (d->udev->speed == USB_SPEED_FULL && !(props->caps & DVB_USB_ADAP_HAS_PID_FILTER)) {
+                                err("This USB2.0 device cannot be run on a USB1.1 port. (it lacks a hardware PID filter)");
+                                return -ENODEV;
+                        }
 
-                if ((d->udev->speed == USB_SPEED_FULL && props->caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
-                        (props->caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
-                        info("will use the device's hardware PID filter (table count: %d).", props->pid_filter_count);
-                        adap->fe_adap[o].pid_filtering  = 1;
-                        adap->fe_adap[o].max_feed_count = props->pid_filter_count;
-                } else {
-                        info("will pass the complete MPEG2 transport stream to the software demuxer.");
-                        adap->fe_adap[o].pid_filtering  = 0;
-                        adap->fe_adap[o].max_feed_count = 255;
-                }
+                        if ((d->udev->speed == USB_SPEED_FULL && props->caps & DVB_USB_ADAP_HAS_PID_FILTER) ||
+                                (props->caps & DVB_USB_ADAP_NEED_PID_FILTERING)) {
+                                info("will use the device's hardware PID filter (table count: %d).", props->pid_filter_count);
+                                adap->fe_adap[o].pid_filtering  = 1;
+                                adap->fe_adap[o].max_feed_count = props->pid_filter_count;
+                        } else {
+                                info("will pass the complete MPEG2 transport stream to the software demuxer.");
+                                adap->fe_adap[o].pid_filtering  = 0;
+                                adap->fe_adap[o].max_feed_count = 255;
+                        }
 
-                if (!adap->fe_adap[o].pid_filtering &&
-                        dvb_usb_force_pid_filter_usage &&
-                        props->caps & DVB_USB_ADAP_HAS_PID_FILTER) {
-                        info("pid filter enabled by module option.");
-                        adap->fe_adap[o].pid_filtering  = 1;
-                        adap->fe_adap[o].max_feed_count = props->pid_filter_count;
-                }
+                        if (!adap->fe_adap[o].pid_filtering &&
+                                dvb_usb_force_pid_filter_usage &&
+                                props->caps & DVB_USB_ADAP_HAS_PID_FILTER) {
+                                info("pid filter enabled by module option.");
+                                adap->fe_adap[o].pid_filtering  = 1;
+                                adap->fe_adap[o].max_feed_count = props->pid_filter_count;
+                        }
 
-                if (props->size_of_priv > 0) {
-                        adap->fe_adap[o].priv = kzalloc(props->size_of_priv, GFP_KERNEL);
-                        if (adap->fe_adap[o].priv == NULL) {
-                                err("no memory for priv for adapter %d fe %d.", n, o);
-                                return -ENOMEM;
+                        if (props->size_of_priv > 0) {
+                                adap->fe_adap[o].priv = kzalloc(props->size_of_priv, GFP_KERNEL);
+                                if (adap->fe_adap[o].priv == NULL) {
+                                        err("no memory for priv for adapter %d fe %d.", n, o);
+                                        return -ENOMEM;
+                                }
                         }
                 }
-        }
 
                 if (adap->props.size_of_priv > 0) {
                         adap->priv = kzalloc(adap->props.size_of_priv, GFP_KERNEL);
diff --git a/drivers/media/usb/dvb-usb/dw2102.c b/drivers/media/usb/dvb-usb/dw2102.c
index 9382895b1b88..9578a6761f1b 100644
--- a/drivers/media/usb/dvb-usb/dw2102.c
+++ b/drivers/media/usb/dvb-usb/dw2102.c
@@ -1,9 +1,9 @@
 /* DVB USB framework compliant Linux driver for the
  *      DVBWorld DVB-S 2101, 2102, DVB-S2 2104, DVB-C 3101,
- *      TeVii S600, S630, S650, S660, S480,
+ *      TeVii S600, S630, S650, S660, S480, S421, S632
  *      Prof 1100, 7500,
  *      Geniatech SU3000 Cards
- * Copyright (C) 2008-2011 Igor M. Liplianin (liplianin@me.by)
+ * Copyright (C) 2008-2012 Igor M. Liplianin (liplianin@me.by)
  *
  *      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
@@ -22,11 +22,14 @@
 #include "tda1002x.h"
 #include "mt312.h"
 #include "zl10039.h"
+#include "ts2020.h"
 #include "ds3000.h"
 #include "stv0900.h"
 #include "stv6110.h"
 #include "stb6100.h"
 #include "stb6100_proc.h"
+#include "m88rs2000.h"
+#include "ts2020.h"
 
 #ifndef USB_PID_DW2102
 #define USB_PID_DW2102 0x2102
@@ -68,6 +71,14 @@
 #define USB_PID_PROF_1100 0xb012
 #endif
 
+#ifndef USB_PID_TEVII_S421
+#define USB_PID_TEVII_S421 0xd421
+#endif
+
+#ifndef USB_PID_TEVII_S632
+#define USB_PID_TEVII_S632 0xd632
+#endif
+
 #define DW210X_READ_MSG 0
 #define DW210X_WRITE_MSG 1
 
@@ -80,6 +91,15 @@
 #define DW2102_RC_QUERY (0x1a00)
 #define DW2102_LED_CTRL (0x1b00)
 
+#define DW2101_FIRMWARE "dvb-usb-dw2101.fw"
+#define DW2102_FIRMWARE "dvb-usb-dw2102.fw"
+#define DW2104_FIRMWARE "dvb-usb-dw2104.fw"
+#define DW3101_FIRMWARE "dvb-usb-dw3101.fw"
+#define S630_FIRMWARE   "dvb-usb-s630.fw"
+#define S660_FIRMWARE   "dvb-usb-s660.fw"
+#define P1100_FIRMWARE  "dvb-usb-p1100.fw"
+#define P7500_FIRMWARE  "dvb-usb-p7500.fw"
+
 #define err_str "did not find the firmware file. (%s) " \
                 "Please see linux/Documentation/dvb/ for more details " \
                 "on firmware-problems."
@@ -534,7 +554,7 @@ static int s6x0_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
                 }
                 /*case 0x55: cx24116
                 case 0x6a: stv0903
-                case 0x68: ds3000, stv0903
+                case 0x68: ds3000, stv0903, rs2000
                 case 0x60: ts2020, stv6110, stb6100
                 case 0xa0: eeprom */
                 default: {
@@ -932,6 +952,17 @@ static struct ds3000_config dw2104_ds3000_config = {
         .demod_address = 0x68,
 };
 
+static struct ts2020_config dw2104_ts2020_config  = {
+        .tuner_address = 0x60,
+        .clk_out_div = 1,
+};
+
+static struct ds3000_config s660_ds3000_config = {
+        .demod_address = 0x68,
+        .ci_mode = 1,
+        .set_lock_led = dw210x_led_ctrl,
+};
+
 static struct stv0900_config dw2104a_stv0900_config = {
         .demod_address = 0x6a,
         .demod_mode = 0,
@@ -981,6 +1012,30 @@ static struct stv0900_config prof_7500_stv0900_config = {
 static struct ds3000_config su3000_ds3000_config = {
         .demod_address = 0x68,
         .ci_mode = 1,
+        .set_lock_led = dw210x_led_ctrl,
+};
+
+static u8 m88rs2000_inittab[] = {
+        DEMOD_WRITE, 0x9a, 0x30,
+        DEMOD_WRITE, 0x00, 0x01,
+        WRITE_DELAY, 0x19, 0x00,
+        DEMOD_WRITE, 0x00, 0x00,
+        DEMOD_WRITE, 0x9a, 0xb0,
+        DEMOD_WRITE, 0x81, 0xc1,
+        DEMOD_WRITE, 0x81, 0x81,
+        DEMOD_WRITE, 0x86, 0xc6,
+        DEMOD_WRITE, 0x9a, 0x30,
+        DEMOD_WRITE, 0xf0, 0x80,
+        DEMOD_WRITE, 0xf1, 0xbf,
+        DEMOD_WRITE, 0xb0, 0x45,
+        DEMOD_WRITE, 0xb2, 0x01,
+        DEMOD_WRITE, 0x9a, 0xb0,
+        0xff, 0xaa, 0xff
+};
+
+static struct m88rs2000_config s421_m88rs2000_config = {
+        .demod_addr = 0x68,
+        .inittab = m88rs2000_inittab,
 };
 
 static int dw2104_frontend_attach(struct dvb_usb_adapter *d)
@@ -1033,6 +1088,8 @@ static int dw2104_frontend_attach(struct dvb_usb_adapter *d)
         d->fe_adap[0].fe = dvb_attach(ds3000_attach, &dw2104_ds3000_config,
                         &d->dev->i2c_adap);
         if (d->fe_adap[0].fe != NULL) {
+                dvb_attach(ts2020_attach, d->fe_adap[0].fe,
+                        &dw2104_ts2020_config, &d->dev->i2c_adap);
                 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
                 info("Attached DS3000!\n");
                 return 0;
@@ -1139,12 +1196,15 @@ static int ds3000_frontend_attach(struct dvb_usb_adapter *d)
         struct s6x0_state *st = (struct s6x0_state *)d->dev->priv;
         u8 obuf[] = {7, 1};
 
-        d->fe_adap[0].fe = dvb_attach(ds3000_attach, &dw2104_ds3000_config,
+        d->fe_adap[0].fe = dvb_attach(ds3000_attach, &s660_ds3000_config,
                         &d->dev->i2c_adap);
 
         if (d->fe_adap[0].fe == NULL)
                 return -EIO;
 
+        dvb_attach(ts2020_attach, d->fe_adap[0].fe, &dw2104_ts2020_config,
+                &d->dev->i2c_adap);
+
         st->old_set_voltage = d->fe_adap[0].fe->ops.set_voltage;
         d->fe_adap[0].fe->ops.set_voltage = s660_set_voltage;
 
@@ -1182,6 +1242,14 @@ static int su3000_frontend_attach(struct dvb_usb_adapter *d)
                 err("command 0x0e transfer failed.");
 
         obuf[0] = 0xe;
+        obuf[1] = 0x02;
+        obuf[2] = 1;
+
+        if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0)
+                err("command 0x0e transfer failed.");
+        msleep(300);
+
+        obuf[0] = 0xe;
         obuf[1] = 0x83;
         obuf[2] = 0;
 
@@ -1205,9 +1273,40 @@ static int su3000_frontend_attach(struct dvb_usb_adapter *d)
         if (d->fe_adap[0].fe == NULL)
                 return -EIO;
 
-        info("Attached DS3000!\n");
+        if (dvb_attach(ts2020_attach, d->fe_adap[0].fe,
+                                &dw2104_ts2020_config,
+                                &d->dev->i2c_adap)) {
+                info("Attached DS3000/TS2020!\n");
+                return 0;
+        }
 
-        return 0;
+        info("Failed to attach DS3000/TS2020!\n");
+        return -EIO;
+}
+
+static int m88rs2000_frontend_attach(struct dvb_usb_adapter *d)
+{
+        u8 obuf[] = { 0x51 };
+        u8 ibuf[] = { 0 };
+
+        if (dvb_usb_generic_rw(d->dev, obuf, 1, ibuf, 1, 0) < 0)
+                err("command 0x51 transfer failed.");
+
+        d->fe_adap[0].fe = dvb_attach(m88rs2000_attach, &s421_m88rs2000_config,
+                                        &d->dev->i2c_adap);
+
+        if (d->fe_adap[0].fe == NULL)
+                return -EIO;
+
+        if (dvb_attach(ts2020_attach, d->fe_adap[0].fe,
+                                &dw2104_ts2020_config,
+                                &d->dev->i2c_adap)) {
+                info("Attached RS2000/TS2020!\n");
+                return 0;
+        }
+
+        info("Failed to attach RS2000/TS2020!\n");
+        return -EIO;
 }
 
 static int dw2102_tuner_attach(struct dvb_usb_adapter *adap)
@@ -1447,6 +1546,8 @@ enum dw2102_table_entry {
         TEVII_S480_1,
         TEVII_S480_2,
         X3M_SPC1400HD,
+        TEVII_S421,
+        TEVII_S632,
 };
 
 static struct usb_device_id dw2102_table[] = {
@@ -1465,6 +1566,8 @@ static struct usb_device_id dw2102_table[] = {
         [TEVII_S480_1] = {USB_DEVICE(0x9022, USB_PID_TEVII_S480_1)},
         [TEVII_S480_2] = {USB_DEVICE(0x9022, USB_PID_TEVII_S480_2)},
         [X3M_SPC1400HD] = {USB_DEVICE(0x1f4d, 0x3100)},
+        [TEVII_S421] = {USB_DEVICE(0x9022, USB_PID_TEVII_S421)},
+        [TEVII_S632] = {USB_DEVICE(0x9022, USB_PID_TEVII_S632)},
         { }
 };
 
@@ -1478,13 +1581,12 @@ static int dw2102_load_firmware(struct usb_device *dev,
         u8 reset;
         u8 reset16[] = {0, 0, 0, 0, 0, 0, 0};
         const struct firmware *fw;
-        const char *fw_2101 = "dvb-usb-dw2101.fw";
 
         switch (dev->descriptor.idProduct) {
         case 0x2101:
-                ret = request_firmware(&fw, fw_2101, &dev->dev);
+                ret = request_firmware(&fw, DW2101_FIRMWARE, &dev->dev);
                 if (ret != 0) {
-                        err(err_str, fw_2101);
+                        err(err_str, DW2101_FIRMWARE);
                         return ret;
                 }
                 break;
@@ -1586,7 +1688,7 @@ static int dw2102_load_firmware(struct usb_device *dev,
 static struct dvb_usb_device_properties dw2102_properties = {
         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
         .usb_ctrl = DEVICE_SPECIFIC,
-        .firmware = "dvb-usb-dw2102.fw",
+        .firmware = DW2102_FIRMWARE,
         .no_reconnect = 1,
 
         .i2c_algo = &dw2102_serit_i2c_algo,
@@ -1641,7 +1743,7 @@ static struct dvb_usb_device_properties dw2102_properties = {
 static struct dvb_usb_device_properties dw2104_properties = {
         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
         .usb_ctrl = DEVICE_SPECIFIC,
-        .firmware = "dvb-usb-dw2104.fw",
+        .firmware = DW2104_FIRMWARE,
         .no_reconnect = 1,
 
         .i2c_algo = &dw2104_i2c_algo,
@@ -1691,7 +1793,7 @@ static struct dvb_usb_device_properties dw2104_properties = {
 static struct dvb_usb_device_properties dw3101_properties = {
         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
         .usb_ctrl = DEVICE_SPECIFIC,
-        .firmware = "dvb-usb-dw3101.fw",
+        .firmware = DW3101_FIRMWARE,
         .no_reconnect = 1,
 
         .i2c_algo = &dw3101_i2c_algo,
@@ -1739,7 +1841,7 @@ static struct dvb_usb_device_properties s6x0_properties = {
         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
         .usb_ctrl = DEVICE_SPECIFIC,
         .size_of_priv = sizeof(struct s6x0_state),
-        .firmware = "dvb-usb-s630.fw",
+        .firmware = S630_FIRMWARE,
         .no_reconnect = 1,
 
         .i2c_algo = &s6x0_i2c_algo,
@@ -1814,6 +1916,19 @@ static struct dvb_usb_device_description d7500 = {
         {NULL},
 };
 
+struct dvb_usb_device_properties *s421;
+static struct dvb_usb_device_description d421 = {
+        "TeVii S421 PCI",
+        {&dw2102_table[TEVII_S421], NULL},
+        {NULL},
+};
+
+static struct dvb_usb_device_description d632 = {
+        "TeVii S632 USB",
+        {&dw2102_table[TEVII_S632], NULL},
+        {NULL},
+};
+
 static struct dvb_usb_device_properties su3000_properties = {
         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
         .usb_ctrl = DEVICE_SPECIFIC,
@@ -1879,7 +1994,7 @@ static int dw2102_probe(struct usb_interface *intf,
                 return -ENOMEM;
         /* copy default structure */
         /* fill only different fields */
-        p1100->firmware = "dvb-usb-p1100.fw";
+        p1100->firmware = P1100_FIRMWARE;
         p1100->devices[0] = d1100;
         p1100->rc.legacy.rc_map_table = rc_map_tbs_table;
         p1100->rc.legacy.rc_map_size = ARRAY_SIZE(rc_map_tbs_table);
@@ -1891,7 +2006,7 @@ static int dw2102_probe(struct usb_interface *intf,
                 kfree(p1100);
                 return -ENOMEM;
         }
-        s660->firmware = "dvb-usb-s660.fw";
+        s660->firmware = S660_FIRMWARE;
         s660->num_device_descs = 3;
         s660->devices[0] = d660;
         s660->devices[1] = d480_1;
@@ -1905,12 +2020,26 @@ static int dw2102_probe(struct usb_interface *intf,
                 kfree(s660);
                 return -ENOMEM;
         }
-        p7500->firmware = "dvb-usb-p7500.fw";
+        p7500->firmware = P7500_FIRMWARE;
         p7500->devices[0] = d7500;
         p7500->rc.legacy.rc_map_table = rc_map_tbs_table;
         p7500->rc.legacy.rc_map_size = ARRAY_SIZE(rc_map_tbs_table);
         p7500->adapter->fe[0].frontend_attach = prof_7500_frontend_attach;
 
+
+        s421 = kmemdup(&su3000_properties,
+                       sizeof(struct dvb_usb_device_properties), GFP_KERNEL);
+        if (!s421) {
+                kfree(p1100);
+                kfree(s660);
+                kfree(p7500);
+                return -ENOMEM;
+        }
+        s421->num_device_descs = 2;
+        s421->devices[0] = d421;
+        s421->devices[1] = d632;
+        s421->adapter->fe[0].frontend_attach = m88rs2000_frontend_attach;
+
         if (0 == dvb_usb_device_init(intf, &dw2102_properties,
                         THIS_MODULE, NULL, adapter_nr) ||
             0 == dvb_usb_device_init(intf, &dw2104_properties,
@@ -1925,6 +2054,8 @@ static int dw2102_probe(struct usb_interface *intf,
                         THIS_MODULE, NULL, adapter_nr) ||
             0 == dvb_usb_device_init(intf, p7500,
                         THIS_MODULE, NULL, adapter_nr) ||
+            0 == dvb_usb_device_init(intf, s421,
+                        THIS_MODULE, NULL, adapter_nr) ||
             0 == dvb_usb_device_init(intf, &su3000_properties,
                                      THIS_MODULE, NULL, adapter_nr))
                 return 0;
@@ -1943,9 +2074,17 @@ module_usb_driver(dw2102_driver);
 
 MODULE_AUTHOR("Igor M. Liplianin (c) liplianin@me.by");
 MODULE_DESCRIPTION("Driver for DVBWorld DVB-S 2101, 2102, DVB-S2 2104,"
-                                " DVB-C 3101 USB2.0,"
-                                " TeVii S600, S630, S650, S660, S480,"
-                                " Prof 1100, 7500 USB2.0,"
-                                " Geniatech SU3000 devices");
+                        " DVB-C 3101 USB2.0,"
+                        " TeVii S600, S630, S650, S660, S480, S421, S632"
+                        " Prof 1100, 7500 USB2.0,"
+                        " Geniatech SU3000 devices");
 MODULE_VERSION("0.1");
 MODULE_LICENSE("GPL");
+MODULE_FIRMWARE(DW2101_FIRMWARE);
+MODULE_FIRMWARE(DW2102_FIRMWARE);
+MODULE_FIRMWARE(DW2104_FIRMWARE);
+MODULE_FIRMWARE(DW3101_FIRMWARE);
+MODULE_FIRMWARE(S630_FIRMWARE);
+MODULE_FIRMWARE(S660_FIRMWARE);
+MODULE_FIRMWARE(P1100_FIRMWARE);
+MODULE_FIRMWARE(P7500_FIRMWARE);
diff --git a/drivers/media/usb/dvb-usb/friio-fe.c b/drivers/media/usb/dvb-usb/friio-fe.c
index 90a70c66a96e..d56f927fc31a 100644
--- a/drivers/media/usb/dvb-usb/friio-fe.c
+++ b/drivers/media/usb/dvb-usb/friio-fe.c
@@ -421,11 +421,10 @@ struct dvb_frontend *jdvbt90502_attach(struct dvb_usb_device *d)
 
         /* setup the state */
         state->i2c = &d->i2c_adap;
-        memcpy(&state->config, &friio_fe_config, sizeof(friio_fe_config));
+        state->config = friio_fe_config;
 
         /* create dvb_frontend */
-        memcpy(&state->frontend.ops, &jdvbt90502_ops,
-               sizeof(jdvbt90502_ops));
+        state->frontend.ops = jdvbt90502_ops;
         state->frontend.demodulator_priv = state;
 
         if (jdvbt90502_init(&state->frontend) < 0)
diff --git a/drivers/media/usb/dvb-usb/m920x.c b/drivers/media/usb/dvb-usb/m920x.c
index 661bb75be955..92afeb20650f 100644
--- a/drivers/media/usb/dvb-usb/m920x.c
+++ b/drivers/media/usb/dvb-usb/m920x.c
@@ -16,6 +16,7 @@
 #include "qt1010.h"
 #include "tda1004x.h"
 #include "tda827x.h"
+#include "mt2060.h"
 
 #include <media/tuner.h>
 #include "tuner-simple.h"
@@ -63,23 +64,33 @@ static inline int m920x_write(struct usb_device *udev, u8 request,
         return ret;
 }
 
+static inline int m920x_write_seq(struct usb_device *udev, u8 request,
+                                  struct m920x_inits *seq)
+{
+        int ret;
+        while (seq->address) {
+                ret = m920x_write(udev, request, seq->data, seq->address);
+                if (ret != 0)
+                        return ret;
+
+                seq++;
+        }
+
+        return ret;
+}
+
 static int m920x_init(struct dvb_usb_device *d, struct m920x_inits *rc_seq)
 {
         int ret = 0, i, epi, flags = 0;
         int adap_enabled[M9206_MAX_ADAPTERS] = { 0 };
 
         /* Remote controller init. */
-        if (d->props.rc.legacy.rc_query) {
+        if (d->props.rc.legacy.rc_query || d->props.rc.core.rc_query) {
                 deb("Initialising remote control\n");
-                while (rc_seq->address) {
-                        if ((ret = m920x_write(d->udev, M9206_CORE,
-                                               rc_seq->data,
-                                               rc_seq->address)) != 0) {
-                                deb("Initialising remote control failed\n");
-                                return ret;
-                        }
-
-                        rc_seq++;
+                ret = m920x_write_seq(d->udev, M9206_CORE, rc_seq);
+                if (ret != 0) {
+                        deb("Initialising remote control failed\n");
+                        return ret;
                 }
 
                 deb("Initialising remote control success\n");
@@ -130,9 +141,50 @@ static int m920x_init_ep(struct usb_interface *intf)
                                  alt->desc.bAlternateSetting);
 }
 
-static int m920x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+static inline void m920x_parse_rc_state(struct dvb_usb_device *d, u8 rc_state,
+                                        int *state)
 {
         struct m920x_state *m = d->priv;
+
+        switch (rc_state) {
+        case 0x80:
+                *state = REMOTE_NO_KEY_PRESSED;
+                break;
+
+        case 0x88: /* framing error or "invalid code" */
+        case 0x99:
+        case 0xc0:
+        case 0xd8:
+                *state = REMOTE_NO_KEY_PRESSED;
+                m->rep_count = 0;
+                break;
+
+        case 0x93:
+        case 0x92:
+        case 0x83: /* pinnacle PCTV310e */
+        case 0x82:
+                m->rep_count = 0;
+                *state = REMOTE_KEY_PRESSED;
+                break;
+
+        case 0x91:
+        case 0x81: /* pinnacle PCTV310e */
+                /* prevent immediate auto-repeat */
+                if (++m->rep_count > 2)
+                        *state = REMOTE_KEY_REPEAT;
+                else
+                        *state = REMOTE_NO_KEY_PRESSED;
+                break;
+
+        default:
+                deb("Unexpected rc state %02x\n", rc_state);
+                *state = REMOTE_NO_KEY_PRESSED;
+                break;
+        }
+}
+
+static int m920x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
         int i, ret = 0;
         u8 *rc_state;
 
@@ -140,51 +192,22 @@ static int m920x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
         if (!rc_state)
                 return -ENOMEM;
 
-        if ((ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE, rc_state, 1)) != 0)
+        ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE,
+                         rc_state, 1);
+        if (ret != 0)
                 goto out;
 
-        if ((ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY, rc_state + 1, 1)) != 0)
+        ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY,
+                         rc_state + 1, 1);
+        if (ret != 0)
                 goto out;
 
+        m920x_parse_rc_state(d, rc_state[0], state);
+
         for (i = 0; i < d->props.rc.legacy.rc_map_size; i++)
                 if (rc5_data(&d->props.rc.legacy.rc_map_table[i]) == rc_state[1]) {
                         *event = d->props.rc.legacy.rc_map_table[i].keycode;
-
-                        switch(rc_state[0]) {
-                        case 0x80:
-                                *state = REMOTE_NO_KEY_PRESSED;
-                                goto out;
-
-                        case 0x88: /* framing error or "invalid code" */
-                        case 0x99:
-                        case 0xc0:
-                        case 0xd8:
-                                *state = REMOTE_NO_KEY_PRESSED;
-                                m->rep_count = 0;
-                                goto out;
-
-                        case 0x93:
-                        case 0x92:
-                        case 0x83: /* pinnacle PCTV310e */
-                        case 0x82:
-                                m->rep_count = 0;
-                                *state = REMOTE_KEY_PRESSED;
-                                goto out;
-
-                        case 0x91:
-                        case 0x81: /* pinnacle PCTV310e */
-                                /* prevent immediate auto-repeat */
-                                if (++m->rep_count > 2)
-                                        *state = REMOTE_KEY_REPEAT;
-                                else
-                                        *state = REMOTE_NO_KEY_PRESSED;
-                                goto out;
-
-                        default:
-                                deb("Unexpected rc state %02x\n", rc_state[0]);
-                                *state = REMOTE_NO_KEY_PRESSED;
-                                goto out;
-                        }
+                        goto out;
                 }
 
         if (rc_state[1] != 0)
@@ -197,6 +220,38 @@ static int m920x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
         return ret;
 }
 
+static int m920x_rc_core_query(struct dvb_usb_device *d)
+{
+        int ret = 0;
+        u8 *rc_state;
+        int state;
+
+        rc_state = kmalloc(2, GFP_KERNEL);
+        if (!rc_state)
+                return -ENOMEM;
+
+        if ((ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE, &rc_state[0], 1)) != 0)
+                goto out;
+
+        if ((ret = m920x_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY, &rc_state[1], 1)) != 0)
+                goto out;
+
+        deb("state=0x%02x keycode=0x%02x\n", rc_state[0], rc_state[1]);
+
+        m920x_parse_rc_state(d, rc_state[0], &state);
+
+        if (state == REMOTE_NO_KEY_PRESSED)
+                rc_keyup(d->rc_dev);
+        else if (state == REMOTE_KEY_REPEAT)
+                rc_repeat(d->rc_dev);
+        else
+                rc_keydown(d->rc_dev, rc_state[1], 0);
+
+out:
+        kfree(rc_state);
+        return ret;
+}
+
 /* I2C */
 static int m920x_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num)
 {
@@ -496,6 +551,12 @@ static struct qt1010_config m920x_qt1010_config = {
         .i2c_address = 0x62
 };
 
+static struct mt2060_config m920x_mt2060_config = {
+        .i2c_address = 0x60, /* 0xc0 */
+        .clock_out = 0,
+};
+
+
 /* Callbacks for DVB USB */
 static int m920x_mt352_frontend_attach(struct dvb_usb_adapter *adap)
 {
@@ -510,6 +571,37 @@ static int m920x_mt352_frontend_attach(struct dvb_usb_adapter *adap)
         return 0;
 }
 
+static int m920x_mt352_frontend_attach_vp7049(struct dvb_usb_adapter *adap)
+{
+        struct m920x_inits vp7049_fe_init_seq[] = {
+                /* XXX without these commands the frontend cannot be detected,
+                 * they must be sent BEFORE the frontend is attached */
+                { 0xff28,         0x00 },
+                { 0xff23,         0x00 },
+                { 0xff28,         0x00 },
+                { 0xff23,         0x00 },
+                { 0xff21,         0x20 },
+                { 0xff21,         0x60 },
+                { 0xff28,         0x00 },
+                { 0xff22,         0x00 },
+                { 0xff20,         0x30 },
+                { 0xff20,         0x20 },
+                { 0xff20,         0x30 },
+                { } /* terminating entry */
+        };
+        int ret;
+
+        deb("%s\n", __func__);
+
+        ret = m920x_write_seq(adap->dev->udev, M9206_CORE, vp7049_fe_init_seq);
+        if (ret != 0) {
+                deb("Initialization of vp7049 frontend failed.");
+                return ret;
+        }
+
+        return m920x_mt352_frontend_attach(adap);
+}
+
 static int m920x_tda10046_08_frontend_attach(struct dvb_usb_adapter *adap)
 {
         deb("%s\n",__func__);
@@ -574,6 +666,18 @@ static int m920x_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
         return 0;
 }
 
+static int m920x_mt2060_tuner_attach(struct dvb_usb_adapter *adap)
+{
+        deb("%s\n", __func__);
+
+        if (dvb_attach(mt2060_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
+                       &m920x_mt2060_config, 1220) == NULL)
+                return -ENODEV;
+
+        return 0;
+}
+
+
 /* device-specific initialization */
 static struct m920x_inits megasky_rc_init [] = {
         { M9206_RC_INIT2, 0xa8 },
@@ -591,7 +695,7 @@ static struct m920x_inits tvwalkertwin_rc_init [] = {
 };
 
 static struct m920x_inits pinnacle310e_init[] = {
-        /* without these the tuner don't work */
+        /* without these the tuner doesn't work */
         { 0xff20,         0x9b },
         { 0xff22,         0x70 },
 
@@ -602,6 +706,15 @@ static struct m920x_inits pinnacle310e_init[] = {
         { } /* terminating entry */
 };
 
+static struct m920x_inits vp7049_rc_init[] = {
+        { 0xff28,         0x00 },
+        { 0xff23,         0x00 },
+        { 0xff21,         0x70 },
+        { M9206_RC_INIT2, 0x00 },
+        { M9206_RC_INIT1, 0xff },
+        { } /* terminating entry */
+};
+
 /* ir keymaps */
 static struct rc_map_table rc_map_megasky_table[] = {
         { 0x0012, KEY_POWER },
@@ -704,6 +817,7 @@ static struct dvb_usb_device_properties digivox_mini_ii_properties;
 static struct dvb_usb_device_properties tvwalkertwin_properties;
 static struct dvb_usb_device_properties dposh_properties;
 static struct dvb_usb_device_properties pinnacle_pctv310e_properties;
+static struct dvb_usb_device_properties vp7049_properties;
 
 static int m920x_probe(struct usb_interface *intf,
                        const struct usb_device_id *id)
@@ -756,6 +870,13 @@ static int m920x_probe(struct usb_interface *intf,
                         goto found;
                 }
 
+                ret = dvb_usb_device_init(intf, &vp7049_properties,
+                                          THIS_MODULE, &d, adapter_nr);
+                if (ret == 0) {
+                        rc_init_seq = vp7049_rc_init;
+                        goto found;
+                }
+
                 return ret;
         } else {
                 /* Another interface on a multi-tuner device */
@@ -787,6 +908,7 @@ static struct usb_device_id m920x_table [] = {
                 { USB_DEVICE(USB_VID_DPOSH, USB_PID_DPOSH_M9206_COLD) },
                 { USB_DEVICE(USB_VID_DPOSH, USB_PID_DPOSH_M9206_WARM) },
                 { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_PINNACLE_PCTV310E) },
+                { USB_DEVICE(USB_VID_AZUREWAVE, USB_PID_TWINHAN_VP7049) },
                 { }             /* Terminating entry */
 };
 MODULE_DEVICE_TABLE (usb, m920x_table);
@@ -1079,6 +1201,61 @@ static struct dvb_usb_device_properties pinnacle_pctv310e_properties = {
         }
 };
 
+static struct dvb_usb_device_properties vp7049_properties = {
+        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
+
+        .usb_ctrl = DEVICE_SPECIFIC,
+        .firmware = "dvb-usb-vp7049-0.95.fw",
+        .download_firmware = m920x_firmware_download,
+
+        .rc.core = {
+                .rc_interval    = 150,
+                .rc_codes       = RC_MAP_TWINHAN_VP1027_DVBS,
+                .rc_query       = m920x_rc_core_query,
+                .allowed_protos = RC_TYPE_UNKNOWN,
+        },
+
+        .size_of_priv     = sizeof(struct m920x_state),
+
+        .identify_state   = m920x_identify_state,
+        .num_adapters = 1,
+        .adapter = {{
+                .num_frontends = 1,
+                .fe = {{
+
+                .caps = DVB_USB_ADAP_HAS_PID_FILTER |
+                        DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
+
+                .pid_filter_count = 8,
+                .pid_filter       = m920x_pid_filter,
+                .pid_filter_ctrl  = m920x_pid_filter_ctrl,
+
+                .frontend_attach  = m920x_mt352_frontend_attach_vp7049,
+                .tuner_attach     = m920x_mt2060_tuner_attach,
+
+                .stream = {
+                        .type = USB_BULK,
+                        .count = 8,
+                        .endpoint = 0x81,
+                        .u = {
+                                 .bulk = {
+                                         .buffersize = 512,
+                                 }
+                        }
+                },
+                } },
+        } },
+        .i2c_algo         = &m920x_i2c_algo,
+
+        .num_device_descs = 1,
+        .devices = {
+                {   "DTV-DVB UDTT7049",
+                        { &m920x_table[7], NULL },
+                        { NULL },
+                }
+         }
+};
+
 static struct usb_driver m920x_driver = {
         .name           = "dvb_usb_m920x",
         .probe          = m920x_probe,
diff --git a/drivers/media/usb/dvb-usb/ttusb2.c b/drivers/media/usb/dvb-usb/ttusb2.c
index bcdac225ebe1..2ce3d19c58ef 100644
--- a/drivers/media/usb/dvb-usb/ttusb2.c
+++ b/drivers/media/usb/dvb-usb/ttusb2.c
@@ -620,6 +620,8 @@ static struct usb_device_id ttusb2_table [] = {
                 USB_PID_TECHNOTREND_CONNECT_S2400) },
         { USB_DEVICE(USB_VID_TECHNOTREND,
                 USB_PID_TECHNOTREND_CONNECT_CT3650) },
+        { USB_DEVICE(USB_VID_TECHNOTREND,
+                USB_PID_TECHNOTREND_CONNECT_S2400_8KEEPROM) },
         {}              /* Terminating entry */
 };
 MODULE_DEVICE_TABLE (usb, ttusb2_table);
@@ -721,12 +723,16 @@ static struct dvb_usb_device_properties ttusb2_properties_s2400 = {
 
         .generic_bulk_ctrl_endpoint = 0x01,
 
-        .num_device_descs = 1,
+        .num_device_descs = 2,
         .devices = {
                 {   "Technotrend TT-connect S-2400",
                         { &ttusb2_table[2], NULL },
                         { NULL },
                 },
+                {   "Technotrend TT-connect S-2400 (8kB EEPROM)",
+                        { &ttusb2_table[4], NULL },
+                        { NULL },
+                },
         }
 };
 
diff --git a/drivers/media/usb/em28xx/Kconfig b/drivers/media/usb/em28xx/Kconfig
index 7a5bd61bd3bb..c754a80a8d8b 100644
--- a/drivers/media/usb/em28xx/Kconfig
+++ b/drivers/media/usb/em28xx/Kconfig
@@ -3,7 +3,7 @@ config VIDEO_EM28XX
         depends on VIDEO_DEV && I2C
         select VIDEO_TUNER
         select VIDEO_TVEEPROM
-        select VIDEOBUF_VMALLOC
+        select VIDEOBUF2_VMALLOC
         select VIDEO_SAA711X if MEDIA_SUBDRV_AUTOSELECT
         select VIDEO_TVP5150 if MEDIA_SUBDRV_AUTOSELECT
         select VIDEO_MSP3400 if MEDIA_SUBDRV_AUTOSELECT
@@ -34,6 +34,7 @@ config VIDEO_EM28XX_DVB
         tristate "DVB/ATSC Support for em28xx based TV cards"
         depends on VIDEO_EM28XX && DVB_CORE
         select DVB_LGDT330X if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_LGDT3305 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_ZL10353 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_TDA10023 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_S921 if MEDIA_SUBDRV_AUTOSELECT
@@ -43,7 +44,10 @@ config VIDEO_EM28XX_DVB
         select DVB_TDA18271C2DD if MEDIA_SUBDRV_AUTOSELECT
         select DVB_TDA10071 if MEDIA_SUBDRV_AUTOSELECT
         select DVB_A8293 if MEDIA_SUBDRV_AUTOSELECT
-        select VIDEOBUF_DVB
+        select DVB_MT352 if MEDIA_SUBDRV_AUTOSELECT
+        select DVB_S5H1409 if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_QT1010 if MEDIA_SUBDRV_AUTOSELECT
+        select MEDIA_TUNER_TDA18271 if MEDIA_SUBDRV_AUTOSELECT
         ---help---
           This adds support for DVB cards based on the
           Empiatech em28xx chips.
diff --git a/drivers/media/usb/em28xx/em28xx-cards.c b/drivers/media/usb/em28xx/em28xx-cards.c
index 619bffbab3bc..54a03b20de6e 100644
--- a/drivers/media/usb/em28xx/em28xx-cards.c
+++ b/drivers/media/usb/em28xx/em28xx-cards.c
@@ -6,6 +6,7 @@
                       Markus Rechberger <mrechberger@gmail.com>
                       Mauro Carvalho Chehab <mchehab@infradead.org>
                       Sascha Sommer <saschasommer@freenet.de>
+   Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.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
@@ -56,10 +57,16 @@ module_param(disable_usb_speed_check, int, 0444);
 MODULE_PARM_DESC(disable_usb_speed_check,
                  "override min bandwidth requirement of 480M bps");
 
-static unsigned int card[]     = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
+static unsigned int card[]     = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
 module_param_array(card,  int, NULL, 0444);
 MODULE_PARM_DESC(card,     "card type");
 
+static int usb_xfer_mode = -1;
+module_param(usb_xfer_mode, int, 0444);
+MODULE_PARM_DESC(usb_xfer_mode,
+                 "USB transfer mode for frame data (-1 = auto, 0 = prefer isoc, 1 = prefer bulk)");
+
+
 /* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS - 1 */
 static unsigned long em28xx_devused;
 
@@ -486,7 +493,7 @@ struct em28xx_board em28xx_boards[] = {
                 .input        = { {
                         .type     = EM28XX_VMUX_TELEVISION,
                         .vmux     = SAA7115_COMPOSITE2,
-                        .amux     = EM28XX_AMUX_LINE_IN,
+                        .amux     = EM28XX_AMUX_VIDEO,
                 }, {
                         .type     = EM28XX_VMUX_COMPOSITE1,
                         .vmux     = SAA7115_COMPOSITE0,
@@ -2073,6 +2080,8 @@ struct usb_device_id em28xx_id_table[] = {
                         .driver_info = EM2884_BOARD_TERRATEC_H5 },
         { USB_DEVICE(0x0ccd, 0x10ad),   /* H5 Rev. 2 */
                         .driver_info = EM2884_BOARD_TERRATEC_H5 },
+        { USB_DEVICE(0x0ccd, 0x10b6),   /* H5 Rev. 3 */
+                        .driver_info = EM2884_BOARD_TERRATEC_H5 },
         { USB_DEVICE(0x0ccd, 0x0084),
                         .driver_info = EM2860_BOARD_TERRATEC_AV350 },
         { USB_DEVICE(0x0ccd, 0x0096),
@@ -2905,7 +2914,7 @@ static void request_module_async(struct work_struct *work)
 
         if (dev->board.has_dvb)
                 request_module("em28xx-dvb");
-        if (dev->board.ir_codes && !disable_ir)
+        if ((dev->board.ir_codes || dev->board.has_ir_i2c) && !disable_ir)
                 request_module("em28xx-rc");
 #endif /* CONFIG_MODULES */
 }
@@ -2934,6 +2943,8 @@ void em28xx_release_resources(struct em28xx *dev)
 
         em28xx_i2c_unregister(dev);
 
+        v4l2_ctrl_handler_free(&dev->ctrl_handler);
+
         v4l2_device_unregister(&dev->v4l2_dev);
 
         usb_put_dev(dev->udev);
@@ -2950,9 +2961,14 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
                            struct usb_interface *interface,
                            int minor)
 {
+        struct v4l2_ctrl_handler *hdl = &dev->ctrl_handler;
         int retval;
+        static const char *default_chip_name = "em28xx";
+        const char *chip_name = default_chip_name;
 
         dev->udev = udev;
+        mutex_init(&dev->vb_queue_lock);
+        mutex_init(&dev->vb_vbi_queue_lock);
         mutex_init(&dev->ctrl_urb_lock);
         spin_lock_init(&dev->slock);
 
@@ -2978,51 +2994,62 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
 
                 switch (dev->chip_id) {
                 case CHIP_ID_EM2800:
-                        em28xx_info("chip ID is em2800\n");
+                        chip_name = "em2800";
                         break;
                 case CHIP_ID_EM2710:
-                        em28xx_info("chip ID is em2710\n");
+                        chip_name = "em2710";
                         break;
                 case CHIP_ID_EM2750:
-                        em28xx_info("chip ID is em2750\n");
+                        chip_name = "em2750";
                         break;
                 case CHIP_ID_EM2820:
-                        em28xx_info("chip ID is em2820 (or em2710)\n");
+                        chip_name = "em2710/2820";
                         break;
                 case CHIP_ID_EM2840:
-                        em28xx_info("chip ID is em2840\n");
+                        chip_name = "em2840";
                         break;
                 case CHIP_ID_EM2860:
-                        em28xx_info("chip ID is em2860\n");
+                        chip_name = "em2860";
                         break;
                 case CHIP_ID_EM2870:
-                        em28xx_info("chip ID is em2870\n");
+                        chip_name = "em2870";
                         dev->wait_after_write = 0;
                         break;
                 case CHIP_ID_EM2874:
-                        em28xx_info("chip ID is em2874\n");
+                        chip_name = "em2874";
                         dev->reg_gpio_num = EM2874_R80_GPIO;
                         dev->wait_after_write = 0;
                         break;
                 case CHIP_ID_EM28174:
-                        em28xx_info("chip ID is em28174\n");
+                        chip_name = "em28174";
                         dev->reg_gpio_num = EM2874_R80_GPIO;
                         dev->wait_after_write = 0;
                         break;
                 case CHIP_ID_EM2883:
-                        em28xx_info("chip ID is em2882/em2883\n");
+                        chip_name = "em2882/3";
                         dev->wait_after_write = 0;
                         break;
                 case CHIP_ID_EM2884:
-                        em28xx_info("chip ID is em2884\n");
+                        chip_name = "em2884";
                         dev->reg_gpio_num = EM2874_R80_GPIO;
                         dev->wait_after_write = 0;
                         break;
                 default:
-                        em28xx_info("em28xx chip ID = %d\n", dev->chip_id);
+                        printk(KERN_INFO DRIVER_NAME
+                               ": unknown em28xx chip ID (%d)\n", dev->chip_id);
                 }
         }
 
+        if (chip_name != default_chip_name)
+                printk(KERN_INFO DRIVER_NAME
+                       ": chip ID is %s\n", chip_name);
+
+        /*
+         * For em2820/em2710, the name may change latter, after checking
+         * if the device has a sensor (so, it is em2710) or not.
+         */
+        snprintf(dev->name, sizeof(dev->name), "%s #%d", chip_name, dev->devno);
+
         if (dev->is_audio_only) {
                 retval = em28xx_audio_setup(dev);
                 if (retval)
@@ -3039,6 +3066,14 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
 
         em28xx_pre_card_setup(dev);
 
+        if (dev->chip_id == CHIP_ID_EM2820) {
+                if (dev->board.is_webcam)
+                        chip_name = "em2710";
+                else
+                        chip_name = "em2820";
+                snprintf(dev->name, sizeof(dev->name), "%s #%d", chip_name, dev->devno);
+        }
+
         if (!dev->board.is_em2800) {
                 /* Resets I2C speed */
                 retval = em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, dev->board.i2c_speed);
@@ -3056,6 +3091,9 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
                 return retval;
         }
 
+        v4l2_ctrl_handler_init(hdl, 4);
+        dev->v4l2_dev.ctrl_handler = hdl;
+
         /* register i2c bus */
         retval = em28xx_i2c_register(dev);
         if (retval < 0) {
@@ -3081,6 +3119,18 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
                         __func__, retval);
                 goto fail;
         }
+        if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
+                v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
+                        V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
+                v4l2_ctrl_new_std(hdl, &em28xx_ctrl_ops,
+                        V4L2_CID_AUDIO_VOLUME, 0, 0x1f, 1, 0x1f);
+        } else {
+                /* install the em28xx notify callback */
+                v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_MUTE),
+                                em28xx_ctrl_notify, dev);
+                v4l2_ctrl_notify(v4l2_ctrl_find(hdl, V4L2_CID_AUDIO_VOLUME),
+                                em28xx_ctrl_notify, dev);
+        }
 
         /* wake i2c devices */
         em28xx_wake_i2c(dev);
@@ -3110,6 +3160,11 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
                 msleep(3);
         }
 
+        v4l2_ctrl_handler_setup(&dev->ctrl_handler);
+        retval = dev->ctrl_handler.error;
+        if (retval)
+                goto fail;
+
         retval = em28xx_register_analog_devices(dev);
         if (retval < 0) {
                 goto fail;
@@ -3122,6 +3177,7 @@ static int em28xx_init_dev(struct em28xx *dev, struct usb_device *udev,
 
 fail:
         em28xx_i2c_unregister(dev);
+        v4l2_ctrl_handler_free(&dev->ctrl_handler);
 
 unregister_dev:
         v4l2_device_unregister(&dev->v4l2_dev);
@@ -3143,7 +3199,7 @@ static int em28xx_usb_probe(struct usb_interface *interface,
         struct em28xx *dev = NULL;
         int retval;
         bool has_audio = false, has_video = false, has_dvb = false;
-        int i, nr;
+        int i, nr, try_bulk;
         const int ifnum = interface->altsetting[0].desc.bInterfaceNumber;
         char *speed;
 
@@ -3183,9 +3239,10 @@ static int em28xx_usb_probe(struct usb_interface *interface,
         }
 
         /* compute alternate max packet sizes */
-        dev->alt_max_pkt_size = kmalloc(sizeof(dev->alt_max_pkt_size[0]) *
+        dev->alt_max_pkt_size_isoc =
+                                kmalloc(sizeof(dev->alt_max_pkt_size_isoc[0]) *
                                         interface->num_altsetting, GFP_KERNEL);
-        if (dev->alt_max_pkt_size == NULL) {
+        if (dev->alt_max_pkt_size_isoc == NULL) {
                 em28xx_errdev("out of memory!\n");
                 kfree(dev);
                 retval = -ENOMEM;
@@ -3208,25 +3265,67 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                         if (udev->speed == USB_SPEED_HIGH)
                                 size = size * hb_mult(sizedescr);
 
-                        if (usb_endpoint_xfer_isoc(e) &&
-                            usb_endpoint_dir_in(e)) {
+                        if (usb_endpoint_dir_in(e)) {
                                 switch (e->bEndpointAddress) {
-                                case EM28XX_EP_AUDIO:
-                                        has_audio = true;
-                                        break;
-                                case EM28XX_EP_ANALOG:
+                                case 0x82:
                                         has_video = true;
-                                        dev->alt_max_pkt_size[i] = size;
+                                        if (usb_endpoint_xfer_isoc(e)) {
+                                                dev->analog_ep_isoc =
+                                                            e->bEndpointAddress;
+                                                dev->alt_max_pkt_size_isoc[i] = size;
+                                        } else if (usb_endpoint_xfer_bulk(e)) {
+                                                dev->analog_ep_bulk =
+                                                            e->bEndpointAddress;
+                                        }
                                         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;
+                                case 0x83:
+                                        if (usb_endpoint_xfer_isoc(e)) {
+                                                has_audio = true;
+                                        } else {
+                                                printk(KERN_INFO DRIVER_NAME
+                                                ": error: skipping audio endpoint 0x83, because it uses bulk transfers !\n");
+                                        }
+                                        break;
+                                case 0x84:
+                                        if (has_video &&
+                                            (usb_endpoint_xfer_bulk(e))) {
+                                                dev->analog_ep_bulk =
+                                                            e->bEndpointAddress;
+                                        } else {
+                                                has_dvb = true;
+                                                if (usb_endpoint_xfer_isoc(e)) {
+                                                        dev->dvb_ep_isoc = e->bEndpointAddress;
+                                                        if (size > dev->dvb_max_pkt_size_isoc) {
+                                                                dev->dvb_max_pkt_size_isoc = size;
+                                                                dev->dvb_alt_isoc = i;
+                                                        }
+                                                } else {
+                                                        dev->dvb_ep_bulk = e->bEndpointAddress;
+                                                }
                                         }
                                         break;
                                 }
                         }
+                        /* NOTE:
+                         * Old logic with support for isoc transfers only was:
+                         *  0x82        isoc            => analog
+                         *  0x83        isoc            => audio
+                         *  0x84        isoc            => digital
+                         *
+                         * New logic with support for bulk transfers
+                         *  0x82        isoc            => analog
+                         *  0x82        bulk            => analog
+                         *  0x83        isoc*           => audio
+                         *  0x84        isoc            => digital
+                         *  0x84        bulk            => analog or digital**
+                         * (*: audio should always be isoc)
+                         * (**: analog, if ep 0x82 is isoc, otherwise digital)
+                         *
+                         * The new logic preserves backwards compatibility and
+                         * reflects the endpoint configurations we have seen
+                         * so far. But there might be devices for which this
+                         * logic is not sufficient...
+                         */
                 }
         }
 
@@ -3261,19 +3360,6 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 ifnum,
                 interface->altsetting->desc.bInterfaceNumber);
 
-        if (has_audio)
-                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
          * video stream wouldn't likely work, since 12 Mbps is generally
@@ -3287,7 +3373,6 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 goto err_free;
         }
 
-        snprintf(dev->name, sizeof(dev->name), "em28xx #%d", nr);
         dev->devno = nr;
         dev->model = id->driver_info;
         dev->alt   = -1;
@@ -3304,6 +3389,24 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 }
         }
 
+        if (has_audio)
+                printk(KERN_INFO DRIVER_NAME
+                       ": Audio interface %i found %s\n",
+                       ifnum,
+                       dev->has_audio_class ? "(USB Audio Class)" : "(Vendor Class)");
+        if (has_video)
+                printk(KERN_INFO DRIVER_NAME
+                       ": Video interface %i found:%s%s\n",
+                       ifnum,
+                       dev->analog_ep_bulk ? " bulk" : "",
+                       dev->analog_ep_isoc ? " isoc" : "");
+        if (has_dvb)
+                printk(KERN_INFO DRIVER_NAME
+                       ": DVB interface %i found:%s%s\n",
+                       ifnum,
+                       dev->dvb_ep_bulk ? " bulk" : "",
+                       dev->dvb_ep_isoc ? " isoc" : "");
+
         dev->num_alt = interface->num_altsetting;
 
         if ((unsigned)card[nr] < em28xx_bcount)
@@ -3312,6 +3415,9 @@ static int em28xx_usb_probe(struct usb_interface *interface,
         /* save our data pointer in this interface device */
         usb_set_intfdata(interface, dev);
 
+        /* initialize videobuf2 stuff */
+        em28xx_vb2_setup(dev);
+
         /* allocate device struct */
         mutex_init(&dev->lock);
         mutex_lock(&dev->lock);
@@ -3320,13 +3426,46 @@ static int em28xx_usb_probe(struct usb_interface *interface,
                 goto unlock_and_free;
         }
 
+        if (usb_xfer_mode < 0) {
+                if (dev->board.is_webcam)
+                        try_bulk = 1;
+                else
+                        try_bulk = 0;
+        } else {
+                try_bulk = usb_xfer_mode > 0;
+        }
+
+        /* Select USB transfer types to use */
+        if (has_video) {
+            if (!dev->analog_ep_isoc || (try_bulk && dev->analog_ep_bulk))
+                dev->analog_xfer_bulk = 1;
+                em28xx_info("analog set to %s mode.\n",
+                            dev->analog_xfer_bulk ? "bulk" : "isoc");
+        }
         if (has_dvb) {
-                /* pre-allocate DVB isoc transfer buffers */
-                retval = em28xx_alloc_isoc(dev, EM28XX_DIGITAL_MODE,
-                                           EM28XX_DVB_MAX_PACKETS,
-                                           EM28XX_DVB_NUM_BUFS,
-                                           dev->dvb_max_pkt_size);
+            if (!dev->dvb_ep_isoc || (try_bulk && dev->dvb_ep_bulk))
+                dev->dvb_xfer_bulk = 1;
+
+                em28xx_info("dvb set to %s mode.\n",
+                            dev->dvb_xfer_bulk ? "bulk" : "isoc");
+
+                /* pre-allocate DVB usb transfer buffers */
+                if (dev->dvb_xfer_bulk) {
+                        retval = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
+                                            dev->dvb_xfer_bulk,
+                                            EM28XX_DVB_NUM_BUFS,
+                                            512,
+                                            EM28XX_DVB_BULK_PACKET_MULTIPLIER);
+                } else {
+                        retval = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
+                                            dev->dvb_xfer_bulk,
+                                            EM28XX_DVB_NUM_BUFS,
+                                            dev->dvb_max_pkt_size_isoc,
+                                            EM28XX_DVB_NUM_ISOC_PACKETS);
+                }
                 if (retval) {
+                        printk(DRIVER_NAME
+                               ": Failed to pre-allocate USB transfer buffers for DVB.\n");
                         goto unlock_and_free;
                 }
         }
@@ -3344,7 +3483,7 @@ unlock_and_free:
         mutex_unlock(&dev->lock);
 
 err_free:
-        kfree(dev->alt_max_pkt_size);
+        kfree(dev->alt_max_pkt_size_isoc);
         kfree(dev);
 
 err:
@@ -3370,6 +3509,8 @@ static void em28xx_usb_disconnect(struct usb_interface *interface)
         if (!dev)
                 return;
 
+        dev->disconnected = 1;
+
         if (dev->is_audio_only) {
                 mutex_lock(&dev->lock);
                 em28xx_close_extension(dev);
@@ -3381,35 +3522,28 @@ static void em28xx_usb_disconnect(struct usb_interface *interface)
 
         flush_request_modules(dev);
 
-        /* wait until all current v4l2 io is finished then deallocate
-           resources */
         mutex_lock(&dev->lock);
 
         v4l2_device_disconnect(&dev->v4l2_dev);
 
         if (dev->users) {
-                em28xx_warn
-                    ("device %s is open! Deregistration and memory "
-                     "deallocation are deferred on close.\n",
-                     video_device_node_name(dev->vdev));
-
-                dev->state |= DEV_MISCONFIGURED;
-                em28xx_uninit_isoc(dev, dev->mode);
-                dev->state |= DEV_DISCONNECTED;
-        } else {
-                dev->state |= DEV_DISCONNECTED;
-                em28xx_release_resources(dev);
+                em28xx_warn("device %s is open! Deregistration and memory deallocation are deferred on close.\n",
+                            video_device_node_name(dev->vdev));
+
+                em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
+                em28xx_uninit_usb_xfer(dev, EM28XX_DIGITAL_MODE);
         }
 
-        /* free DVB isoc buffers */
-        em28xx_uninit_isoc(dev, EM28XX_DIGITAL_MODE);
+        em28xx_close_extension(dev);
+        /* NOTE: must be called BEFORE the resources are released */
 
-        mutex_unlock(&dev->lock);
+        if (!dev->users)
+                em28xx_release_resources(dev);
 
-        em28xx_close_extension(dev);
+        mutex_unlock(&dev->lock);
 
         if (!dev->users) {
-                kfree(dev->alt_max_pkt_size);
+                kfree(dev->alt_max_pkt_size_isoc);
                 kfree(dev);
         }
 }
diff --git a/drivers/media/usb/em28xx/em28xx-core.c b/drivers/media/usb/em28xx/em28xx-core.c
index bed07a6c33f8..aaedd11791f2 100644
--- a/drivers/media/usb/em28xx/em28xx-core.c
+++ b/drivers/media/usb/em28xx/em28xx-core.c
@@ -5,6 +5,7 @@
                       Markus Rechberger <mrechberger@gmail.com>
                       Mauro Carvalho Chehab <mchehab@infradead.org>
                       Sascha Sommer <saschasommer@freenet.de>
+   Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.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
@@ -76,7 +77,7 @@ int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
         int ret;
         int pipe = usb_rcvctrlpipe(dev->udev, 0);
 
-        if (dev->state & DEV_DISCONNECTED)
+        if (dev->disconnected)
                 return -ENODEV;
 
         if (len > URB_MAX_CTRL_SIZE)
@@ -100,7 +101,7 @@ int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
                 if (reg_debug)
                         printk(" failed!\n");
                 mutex_unlock(&dev->ctrl_urb_lock);
-                return ret;
+                return usb_translate_errors(ret);
         }
 
         if (len)
@@ -152,7 +153,7 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
         int ret;
         int pipe = usb_sndctrlpipe(dev->udev, 0);
 
-        if (dev->state & DEV_DISCONNECTED)
+        if (dev->disconnected)
                 return -ENODEV;
 
         if ((len < 1) || (len > URB_MAX_CTRL_SIZE))
@@ -181,6 +182,9 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
                               0x0000, reg, dev->urb_buf, len, HZ);
         mutex_unlock(&dev->ctrl_urb_lock);
 
+        if (ret < 0)
+                return usb_translate_errors(ret);
+
         if (dev->wait_after_write)
                 msleep(dev->wait_after_write);
 
@@ -729,22 +733,24 @@ static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
         return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
 }
 
-static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
+static void em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
                                    u16 width, u16 height)
 {
-        u8 cwidth = width;
-        u8 cheight = height;
-        u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
+        u8 cwidth = width >> 2;
+        u8 cheight = height >> 2;
+        u8 overflow = (height >> 9 & 0x02) | (width >> 10 & 0x01);
+        /* NOTE: size limit: 2047x1023 = 2MPix */
 
-        em28xx_coredbg("em28xx Area Set: (%d,%d)\n",
-                        (width | (overflow & 2) << 7),
-                        (height | (overflow & 1) << 8));
+        em28xx_coredbg("capture area set to (%d,%d): %dx%d\n",
+                       hstart, vstart,
+                       ((overflow & 2) << 9 | cwidth << 2),
+                       ((overflow & 1) << 10 | cheight << 2));
 
         em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
         em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
         em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
         em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
-        return em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
+        em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
 }
 
 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
@@ -797,28 +803,30 @@ int em28xx_resolution_set(struct em28xx *dev)
            it out, we end up with the same format as the rest of the VBI
            region */
         if (em28xx_vbi_supported(dev) == 1)
-                em28xx_capture_area_set(dev, 0, 2, width >> 2, height >> 2);
+                em28xx_capture_area_set(dev, 0, 2, width, height);
         else
-                em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
+                em28xx_capture_area_set(dev, 0, 0, width, height);
 
         return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
 }
 
+/* Set USB alternate setting for analog video */
 int em28xx_set_alternate(struct em28xx *dev)
 {
-        int errCode, prev_alt = dev->alt;
+        int errCode;
         int i;
         unsigned int min_pkt_size = dev->width * 2 + 4;
 
-        /*
-         * alt = 0 is used only for control messages, so, only values
-         * greater than 0 can be used for streaming.
-         */
-        if (alt && alt < dev->num_alt) {
+        /* NOTE: for isoc transfers, only alt settings > 0 are allowed
+                 bulk transfers seem to work only with alt=0 ! */
+        dev->alt = 0;
+        if ((alt > 0) && (alt < dev->num_alt)) {
                 em28xx_coredbg("alternate forced to %d\n", dev->alt);
                 dev->alt = alt;
                 goto set_alt;
         }
+        if (dev->analog_xfer_bulk)
+                goto set_alt;
 
         /* When image size is bigger than a certain value,
            the frame size should be increased, otherwise, only
@@ -829,30 +837,38 @@ int em28xx_set_alternate(struct em28xx *dev)
 
         for (i = 0; i < dev->num_alt; i++) {
                 /* stop when the selected alt setting offers enough bandwidth */
-                if (dev->alt_max_pkt_size[i] >= min_pkt_size) {
+                if (dev->alt_max_pkt_size_isoc[i] >= min_pkt_size) {
                         dev->alt = i;
                         break;
                 /* otherwise make sure that we end up with the maximum bandwidth
                    because the min_pkt_size equation might be wrong...
                 */
-                } else if (dev->alt_max_pkt_size[i] >
-                           dev->alt_max_pkt_size[dev->alt])
+                } else if (dev->alt_max_pkt_size_isoc[i] >
+                           dev->alt_max_pkt_size_isoc[dev->alt])
                         dev->alt = i;
         }
 
 set_alt:
-        if (dev->alt != prev_alt) {
+        /* NOTE: for bulk transfers, we need to call usb_set_interface()
+         * even if the previous settings were the same. Otherwise streaming
+         * fails with all urbs having status = -EOVERFLOW ! */
+        if (dev->analog_xfer_bulk) {
+                dev->max_pkt_size = 512; /* USB 2.0 spec */
+                dev->packet_multiplier = EM28XX_BULK_PACKET_MULTIPLIER;
+        } else { /* isoc */
                 em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
-                                min_pkt_size, dev->alt);
-                dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
-                em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
-                               dev->alt, dev->max_pkt_size);
-                errCode = usb_set_interface(dev->udev, 0, dev->alt);
-                if (errCode < 0) {
-                        em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
-                                        dev->alt, errCode);
-                        return errCode;
-                }
+                               min_pkt_size, dev->alt);
+                dev->max_pkt_size =
+                                  dev->alt_max_pkt_size_isoc[dev->alt];
+                dev->packet_multiplier = EM28XX_NUM_ISOC_PACKETS;
+        }
+        em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
+                       dev->alt, dev->max_pkt_size);
+        errCode = usb_set_interface(dev->udev, 0, dev->alt);
+        if (errCode < 0) {
+                em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
+                              dev->alt, errCode);
+                return errCode;
         }
         return 0;
 }
@@ -919,7 +935,7 @@ EXPORT_SYMBOL_GPL(em28xx_set_mode);
    ------------------------------------------------------------------*/
 
 /*
- * IRQ callback, called by URB callback
+ * URB completion handler for isoc/bulk transfers
  */
 static void em28xx_irq_callback(struct urb *urb)
 {
@@ -941,11 +957,12 @@ static void em28xx_irq_callback(struct urb *urb)
 
         /* Copy data from URB */
         spin_lock(&dev->slock);
-        dev->isoc_ctl.isoc_copy(dev, urb);
+        dev->usb_ctl.urb_data_copy(dev, urb);
         spin_unlock(&dev->slock);
 
         /* Reset urb buffers */
         for (i = 0; i < urb->number_of_packets; i++) {
+                /* isoc only (bulk: number_of_packets = 0) */
                 urb->iso_frame_desc[i].status = 0;
                 urb->iso_frame_desc[i].actual_length = 0;
         }
@@ -961,49 +978,50 @@ static void em28xx_irq_callback(struct urb *urb)
 /*
  * Stop and Deallocate URBs
  */
-void em28xx_uninit_isoc(struct em28xx *dev, enum em28xx_mode mode)
+void em28xx_uninit_usb_xfer(struct em28xx *dev, enum em28xx_mode mode)
 {
         struct urb *urb;
-        struct em28xx_usb_isoc_bufs *isoc_bufs;
+        struct em28xx_usb_bufs *usb_bufs;
         int i;
 
-        em28xx_isocdbg("em28xx: called em28xx_uninit_isoc in mode %d\n", mode);
+        em28xx_isocdbg("em28xx: called em28xx_uninit_usb_xfer in mode %d\n",
+                       mode);
 
         if (mode == EM28XX_DIGITAL_MODE)
-                isoc_bufs = &dev->isoc_ctl.digital_bufs;
+                usb_bufs = &dev->usb_ctl.digital_bufs;
         else
-                isoc_bufs = &dev->isoc_ctl.analog_bufs;
+                usb_bufs = &dev->usb_ctl.analog_bufs;
 
-        for (i = 0; i < isoc_bufs->num_bufs; i++) {
-                urb = isoc_bufs->urb[i];
+        for (i = 0; i < usb_bufs->num_bufs; i++) {
+                urb = usb_bufs->urb[i];
                 if (urb) {
                         if (!irqs_disabled())
                                 usb_kill_urb(urb);
                         else
                                 usb_unlink_urb(urb);
 
-                        if (isoc_bufs->transfer_buffer[i]) {
+                        if (usb_bufs->transfer_buffer[i]) {
                                 usb_free_coherent(dev->udev,
                                         urb->transfer_buffer_length,
-                                        isoc_bufs->transfer_buffer[i],
+                                        usb_bufs->transfer_buffer[i],
                                         urb->transfer_dma);
                         }
                         usb_free_urb(urb);
-                        isoc_bufs->urb[i] = NULL;
+                        usb_bufs->urb[i] = NULL;
                 }
-                isoc_bufs->transfer_buffer[i] = NULL;
+                usb_bufs->transfer_buffer[i] = NULL;
         }
 
-        kfree(isoc_bufs->urb);
-        kfree(isoc_bufs->transfer_buffer);
+        kfree(usb_bufs->urb);
+        kfree(usb_bufs->transfer_buffer);
 
-        isoc_bufs->urb = NULL;
-        isoc_bufs->transfer_buffer = NULL;
-        isoc_bufs->num_bufs = 0;
+        usb_bufs->urb = NULL;
+        usb_bufs->transfer_buffer = NULL;
+        usb_bufs->num_bufs = 0;
 
         em28xx_capture_start(dev, 0);
 }
-EXPORT_SYMBOL_GPL(em28xx_uninit_isoc);
+EXPORT_SYMBOL_GPL(em28xx_uninit_usb_xfer);
 
 /*
  * Stop URBs
@@ -1012,7 +1030,7 @@ void em28xx_stop_urbs(struct em28xx *dev)
 {
         int i;
         struct urb *urb;
-        struct em28xx_usb_isoc_bufs *isoc_bufs = &dev->isoc_ctl.digital_bufs;
+        struct em28xx_usb_bufs *isoc_bufs = &dev->usb_ctl.digital_bufs;
 
         em28xx_isocdbg("em28xx: called em28xx_stop_urbs\n");
 
@@ -1033,10 +1051,10 @@ EXPORT_SYMBOL_GPL(em28xx_stop_urbs);
 /*
  * Allocate URBs
  */
-int em28xx_alloc_isoc(struct em28xx *dev, enum em28xx_mode mode,
-                      int max_packets, int num_bufs, int max_pkt_size)
+int em28xx_alloc_urbs(struct em28xx *dev, enum em28xx_mode mode, int xfer_bulk,
+                      int num_bufs, int max_pkt_size, int packet_multiplier)
 {
-        struct em28xx_usb_isoc_bufs *isoc_bufs;
+        struct em28xx_usb_bufs *usb_bufs;
         int i;
         int sb_size, pipe;
         struct urb *urb;
@@ -1044,140 +1062,180 @@ int em28xx_alloc_isoc(struct em28xx *dev, enum em28xx_mode mode,
 
         em28xx_isocdbg("em28xx: called em28xx_alloc_isoc in mode %d\n", mode);
 
-        if (mode == EM28XX_DIGITAL_MODE)
-                isoc_bufs = &dev->isoc_ctl.digital_bufs;
-        else
-                isoc_bufs = &dev->isoc_ctl.analog_bufs;
+        /* Check mode and if we have an endpoint for the selected
+           transfer type, select buffer                          */
+        if (mode == EM28XX_DIGITAL_MODE) {
+                if ((xfer_bulk && !dev->dvb_ep_bulk) ||
+                    (!xfer_bulk && !dev->dvb_ep_isoc)) {
+                        em28xx_errdev("no endpoint for DVB mode and transfer type %d\n",
+                                      xfer_bulk > 0);
+                        return -EINVAL;
+                }
+                usb_bufs = &dev->usb_ctl.digital_bufs;
+        } else if (mode == EM28XX_ANALOG_MODE) {
+                if ((xfer_bulk && !dev->analog_ep_bulk) ||
+                    (!xfer_bulk && !dev->analog_ep_isoc)) {
+                        em28xx_errdev("no endpoint for analog mode and transfer type %d\n",
+                                       xfer_bulk > 0);
+                        return -EINVAL;
+                }
+                usb_bufs = &dev->usb_ctl.analog_bufs;
+        } else {
+                em28xx_errdev("invalid mode selected\n");
+                return -EINVAL;
+        }
 
         /* De-allocates all pending stuff */
-        em28xx_uninit_isoc(dev, mode);
+        em28xx_uninit_usb_xfer(dev, mode);
 
-        isoc_bufs->num_bufs = num_bufs;
+        usb_bufs->num_bufs = num_bufs;
 
-        isoc_bufs->urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
-        if (!isoc_bufs->urb) {
+        usb_bufs->urb = kzalloc(sizeof(void *)*num_bufs,  GFP_KERNEL);
+        if (!usb_bufs->urb) {
                 em28xx_errdev("cannot alloc memory for usb buffers\n");
                 return -ENOMEM;
         }
 
-        isoc_bufs->transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
+        usb_bufs->transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
                                              GFP_KERNEL);
-        if (!isoc_bufs->transfer_buffer) {
+        if (!usb_bufs->transfer_buffer) {
                 em28xx_errdev("cannot allocate memory for usb transfer\n");
-                kfree(isoc_bufs->urb);
+                kfree(usb_bufs->urb);
                 return -ENOMEM;
         }
 
-        isoc_bufs->max_pkt_size = max_pkt_size;
-        isoc_bufs->num_packets = max_packets;
-        dev->isoc_ctl.vid_buf = NULL;
-        dev->isoc_ctl.vbi_buf = NULL;
+        usb_bufs->max_pkt_size = max_pkt_size;
+        if (xfer_bulk)
+                usb_bufs->num_packets = 0;
+        else
+                usb_bufs->num_packets = packet_multiplier;
+        dev->usb_ctl.vid_buf = NULL;
+        dev->usb_ctl.vbi_buf = NULL;
 
-        sb_size = isoc_bufs->num_packets * isoc_bufs->max_pkt_size;
+        sb_size = packet_multiplier * usb_bufs->max_pkt_size;
 
         /* allocate urbs and transfer buffers */
-        for (i = 0; i < isoc_bufs->num_bufs; i++) {
-                urb = usb_alloc_urb(isoc_bufs->num_packets, GFP_KERNEL);
+        for (i = 0; i < usb_bufs->num_bufs; i++) {
+                urb = usb_alloc_urb(usb_bufs->num_packets, GFP_KERNEL);
                 if (!urb) {
-                        em28xx_err("cannot alloc isoc_ctl.urb %i\n", i);
-                        em28xx_uninit_isoc(dev, mode);
+                        em28xx_err("cannot alloc usb_ctl.urb %i\n", i);
+                        em28xx_uninit_usb_xfer(dev, mode);
                         return -ENOMEM;
                 }
-                isoc_bufs->urb[i] = urb;
+                usb_bufs->urb[i] = urb;
 
-                isoc_bufs->transfer_buffer[i] = usb_alloc_coherent(dev->udev,
+                usb_bufs->transfer_buffer[i] = usb_alloc_coherent(dev->udev,
                         sb_size, GFP_KERNEL, &urb->transfer_dma);
-                if (!isoc_bufs->transfer_buffer[i]) {
+                if (!usb_bufs->transfer_buffer[i]) {
                         em28xx_err("unable to allocate %i bytes for transfer"
                                         " buffer %i%s\n",
                                         sb_size, i,
                                         in_interrupt() ? " while in int" : "");
-                        em28xx_uninit_isoc(dev, mode);
+                        em28xx_uninit_usb_xfer(dev, mode);
                         return -ENOMEM;
                 }
-                memset(isoc_bufs->transfer_buffer[i], 0, sb_size);
-
-                /* FIXME: this is a hack - should be
-                        'desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK'
-                        should also be using 'desc.bInterval'
-                 */
-                pipe = usb_rcvisocpipe(dev->udev,
-                                       mode == EM28XX_ANALOG_MODE ?
-                                       EM28XX_EP_ANALOG : EM28XX_EP_DIGITAL);
-
-                usb_fill_int_urb(urb, dev->udev, pipe,
-                                 isoc_bufs->transfer_buffer[i], sb_size,
-                                 em28xx_irq_callback, dev, 1);
-
-                urb->number_of_packets = isoc_bufs->num_packets;
-                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
-
-                k = 0;
-                for (j = 0; j < isoc_bufs->num_packets; j++) {
-                        urb->iso_frame_desc[j].offset = k;
-                        urb->iso_frame_desc[j].length =
-                                                isoc_bufs->max_pkt_size;
-                        k += isoc_bufs->max_pkt_size;
+                memset(usb_bufs->transfer_buffer[i], 0, sb_size);
+
+                if (xfer_bulk) { /* bulk */
+                        pipe = usb_rcvbulkpipe(dev->udev,
+                                               mode == EM28XX_ANALOG_MODE ?
+                                               dev->analog_ep_bulk :
+                                               dev->dvb_ep_bulk);
+                        usb_fill_bulk_urb(urb, dev->udev, pipe,
+                                          usb_bufs->transfer_buffer[i], sb_size,
+                                          em28xx_irq_callback, dev);
+                        urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+                } else { /* isoc */
+                        pipe = usb_rcvisocpipe(dev->udev,
+                                               mode == EM28XX_ANALOG_MODE ?
+                                               dev->analog_ep_isoc :
+                                               dev->dvb_ep_isoc);
+                        usb_fill_int_urb(urb, dev->udev, pipe,
+                                         usb_bufs->transfer_buffer[i], sb_size,
+                                         em28xx_irq_callback, dev, 1);
+                        urb->transfer_flags = URB_ISO_ASAP |
+                                              URB_NO_TRANSFER_DMA_MAP;
+                        k = 0;
+                        for (j = 0; j < usb_bufs->num_packets; j++) {
+                                urb->iso_frame_desc[j].offset = k;
+                                urb->iso_frame_desc[j].length =
+                                                        usb_bufs->max_pkt_size;
+                                k += usb_bufs->max_pkt_size;
+                        }
                 }
+
+                urb->number_of_packets = usb_bufs->num_packets;
         }
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(em28xx_alloc_isoc);
+EXPORT_SYMBOL_GPL(em28xx_alloc_urbs);
 
 /*
  * Allocate URBs and start IRQ
  */
-int em28xx_init_isoc(struct em28xx *dev, enum em28xx_mode mode,
-                     int max_packets, int num_bufs, int max_pkt_size,
-                     int (*isoc_copy) (struct em28xx *dev, struct urb *urb))
+int em28xx_init_usb_xfer(struct em28xx *dev, enum em28xx_mode mode,
+                    int xfer_bulk, int num_bufs, int max_pkt_size,
+                    int packet_multiplier,
+                    int (*urb_data_copy) (struct em28xx *dev, struct urb *urb))
 {
         struct em28xx_dmaqueue *dma_q = &dev->vidq;
         struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
-        struct em28xx_usb_isoc_bufs *isoc_bufs;
+        struct em28xx_usb_bufs *usb_bufs;
         int i;
         int rc;
         int alloc;
 
-        em28xx_isocdbg("em28xx: called em28xx_init_isoc in mode %d\n", mode);
+        em28xx_isocdbg("em28xx: called em28xx_init_usb_xfer in mode %d\n",
+                       mode);
 
-        dev->isoc_ctl.isoc_copy = isoc_copy;
+        dev->usb_ctl.urb_data_copy = urb_data_copy;
 
         if (mode == EM28XX_DIGITAL_MODE) {
-                isoc_bufs = &dev->isoc_ctl.digital_bufs;
-                /* no need to free/alloc isoc buffers in digital mode */
+                usb_bufs = &dev->usb_ctl.digital_bufs;
+                /* no need to free/alloc usb buffers in digital mode */
                 alloc = 0;
         } else {
-                isoc_bufs = &dev->isoc_ctl.analog_bufs;
+                usb_bufs = &dev->usb_ctl.analog_bufs;
                 alloc = 1;
         }
 
         if (alloc) {
-                rc = em28xx_alloc_isoc(dev, mode, max_packets,
-                                       num_bufs, max_pkt_size);
+                rc = em28xx_alloc_urbs(dev, mode, xfer_bulk, num_bufs,
+                                       max_pkt_size, packet_multiplier);
                 if (rc)
                         return rc;
         }
 
+        if (xfer_bulk) {
+                rc = usb_clear_halt(dev->udev, usb_bufs->urb[0]->pipe);
+                if (rc < 0) {
+                        em28xx_err("failed to clear USB bulk endpoint stall/halt condition (error=%i)\n",
+                                   rc);
+                        em28xx_uninit_usb_xfer(dev, mode);
+                        return rc;
+                }
+        }
+
         init_waitqueue_head(&dma_q->wq);
         init_waitqueue_head(&vbi_dma_q->wq);
 
         em28xx_capture_start(dev, 1);
 
         /* submit urbs and enables IRQ */
-        for (i = 0; i < isoc_bufs->num_bufs; i++) {
-                rc = usb_submit_urb(isoc_bufs->urb[i], GFP_ATOMIC);
+        for (i = 0; i < usb_bufs->num_bufs; i++) {
+                rc = usb_submit_urb(usb_bufs->urb[i], GFP_ATOMIC);
                 if (rc) {
                         em28xx_err("submit of urb %i failed (error=%i)\n", i,
                                    rc);
-                        em28xx_uninit_isoc(dev, mode);
+                        em28xx_uninit_usb_xfer(dev, mode);
                         return rc;
                 }
         }
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(em28xx_init_isoc);
+EXPORT_SYMBOL_GPL(em28xx_init_usb_xfer);
 
 /*
  * em28xx_wake_i2c()
diff --git a/drivers/media/usb/em28xx/em28xx-dvb.c b/drivers/media/usb/em28xx/em28xx-dvb.c
index 63f2e7070c00..a81ec2e8cc9b 100644
--- a/drivers/media/usb/em28xx/em28xx-dvb.c
+++ b/drivers/media/usb/em28xx/em28xx-dvb.c
@@ -10,6 +10,8 @@
 
  (c) 2008 Aidan Thornton <makosoft@googlemail.com>
 
+ (c) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
+
  Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by:
         (c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
         (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
@@ -25,7 +27,9 @@
 
 #include "em28xx.h"
 #include <media/v4l2-common.h>
-#include <media/videobuf-vmalloc.h>
+#include <dvb_demux.h>
+#include <dvb_net.h>
+#include <dmxdev.h>
 #include <media/tuner.h>
 #include "tuner-simple.h"
 #include <linux/gpio.h>
@@ -124,34 +128,47 @@ static inline void print_err_status(struct em28xx *dev,
         }
 }
 
-static inline int em28xx_dvb_isoc_copy(struct em28xx *dev, struct urb *urb)
+static inline int em28xx_dvb_urb_data_copy(struct em28xx *dev, struct urb *urb)
 {
-        int i;
+        int xfer_bulk, num_packets, i;
 
         if (!dev)
                 return 0;
 
-        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+        if (dev->disconnected)
                 return 0;
 
-        if (urb->status < 0) {
+        if (urb->status < 0)
                 print_err_status(dev, -1, urb->status);
-                if (urb->status == -ENOENT)
-                        return 0;
-        }
 
-        for (i = 0; i < urb->number_of_packets; i++) {
-                int status = urb->iso_frame_desc[i].status;
+        xfer_bulk = usb_pipebulk(urb->pipe);
 
-                if (status < 0) {
-                        print_err_status(dev, i, status);
-                        if (urb->iso_frame_desc[i].status != -EPROTO)
-                                continue;
-                }
+        if (xfer_bulk) /* bulk */
+                num_packets = 1;
+        else /* isoc */
+                num_packets = urb->number_of_packets;
 
-                dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer +
-                                 urb->iso_frame_desc[i].offset,
-                                 urb->iso_frame_desc[i].actual_length);
+        for (i = 0; i < num_packets; i++) {
+                if (xfer_bulk) {
+                        if (urb->status < 0) {
+                                print_err_status(dev, i, urb->status);
+                                if (urb->status != -EPROTO)
+                                        continue;
+                        }
+                        dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer,
+                                        urb->actual_length);
+                } else {
+                        if (urb->iso_frame_desc[i].status < 0) {
+                                print_err_status(dev, i,
+                                                 urb->iso_frame_desc[i].status);
+                                if (urb->iso_frame_desc[i].status != -EPROTO)
+                                        continue;
+                        }
+                        dvb_dmx_swfilter(&dev->dvb->demux,
+                                         urb->transfer_buffer +
+                                         urb->iso_frame_desc[i].offset,
+                                         urb->iso_frame_desc[i].actual_length);
+                }
         }
 
         return 0;
@@ -161,24 +178,40 @@ static int em28xx_start_streaming(struct em28xx_dvb *dvb)
 {
         int rc;
         struct em28xx *dev = dvb->adapter.priv;
-        int max_dvb_packet_size;
+        int dvb_max_packet_size, packet_multiplier, dvb_alt;
+
+        if (dev->dvb_xfer_bulk) {
+                if (!dev->dvb_ep_bulk)
+                        return -ENODEV;
+                dvb_max_packet_size = 512; /* USB 2.0 spec */
+                packet_multiplier = EM28XX_DVB_BULK_PACKET_MULTIPLIER;
+                dvb_alt = 0;
+        } else { /* isoc */
+                if (!dev->dvb_ep_isoc)
+                        return -ENODEV;
+                dvb_max_packet_size = dev->dvb_max_pkt_size_isoc;
+                if (dvb_max_packet_size < 0)
+                        return dvb_max_packet_size;
+                packet_multiplier = EM28XX_DVB_NUM_ISOC_PACKETS;
+                dvb_alt = dev->dvb_alt_isoc;
+        }
 
-        usb_set_interface(dev->udev, 0, dev->dvb_alt);
+        usb_set_interface(dev->udev, 0, dvb_alt);
         rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
         if (rc < 0)
                 return rc;
 
-        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 x %d bytes\n",
                 EM28XX_DVB_NUM_BUFS,
-                EM28XX_DVB_MAX_PACKETS,
-                max_dvb_packet_size);
-
-        return em28xx_init_isoc(dev, EM28XX_DIGITAL_MODE,
-                                EM28XX_DVB_MAX_PACKETS, EM28XX_DVB_NUM_BUFS,
-                                max_dvb_packet_size, em28xx_dvb_isoc_copy);
+                packet_multiplier,
+                dvb_max_packet_size);
+
+        return em28xx_init_usb_xfer(dev, EM28XX_DIGITAL_MODE,
+                                    dev->dvb_xfer_bulk,
+                                    EM28XX_DVB_NUM_BUFS,
+                                    dvb_max_packet_size,
+                                    packet_multiplier,
+                                    em28xx_dvb_urb_data_copy);
 }
 
 static int em28xx_stop_streaming(struct em28xx_dvb *dvb)
@@ -714,7 +747,8 @@ static struct tda18271_config em28xx_cxd2820r_tda18271_config = {
 };
 
 static const struct tda10071_config em28xx_tda10071_config = {
-        .i2c_address = 0x55, /* (0xaa >> 1) */
+        .demod_i2c_addr = 0x55, /* (0xaa >> 1) */
+        .tuner_i2c_addr = 0x14,
         .i2c_wr_max = 64,
         .ts_mode = TDA10071_TS_SERIAL,
         .spec_inv = 0,
@@ -1288,7 +1322,7 @@ static int em28xx_dvb_fini(struct em28xx *dev)
         if (dev->dvb) {
                 struct em28xx_dvb *dvb = dev->dvb;
 
-                if (dev->state & DEV_DISCONNECTED) {
+                if (dev->disconnected) {
                         /* We cannot tell the device to sleep
                          * once it has been unplugged. */
                         if (dvb->fe[0])
diff --git a/drivers/media/usb/em28xx/em28xx-i2c.c b/drivers/media/usb/em28xx/em28xx-i2c.c
index 1683bd9d51ee..8532c1d4fd46 100644
--- a/drivers/media/usb/em28xx/em28xx-i2c.c
+++ b/drivers/media/usb/em28xx/em28xx-i2c.c
@@ -50,15 +50,18 @@ do {							\
 } while (0)
 
 /*
- * em2800_i2c_send_max4()
- * send up to 4 bytes to the i2c device
+ * em2800_i2c_send_bytes()
+ * send up to 4 bytes to the em2800 i2c device
  */
-static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
-                                char *buf, int len)
+static int em2800_i2c_send_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
 {
         int ret;
         int write_timeout;
-        unsigned char b2[6];
+        u8 b2[6];
+
+        if (len < 1 || len > 4)
+                return -EOPNOTSUPP;
+
         BUG_ON(len < 1 || len > 4);
         b2[5] = 0x80 + len - 1;
         b2[4] = addr;
@@ -70,165 +73,212 @@ static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
         if (len > 3)
                 b2[0] = buf[3];
 
+        /* trigger write */
         ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
         if (ret != 2 + len) {
-                em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
-                return -EIO;
+                em28xx_warn("failed to trigger write to i2c address 0x%x "
+                            "(error=%i)\n", addr, ret);
+                return (ret < 0) ? ret : -EIO;
         }
-        for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
+        /* wait for completion */
+        for (write_timeout = EM2800_I2C_XFER_TIMEOUT; write_timeout > 0;
              write_timeout -= 5) {
                 ret = dev->em28xx_read_reg(dev, 0x05);
-                if (ret == 0x80 + len - 1)
+                if (ret == 0x80 + len - 1) {
                         return len;
+                } else if (ret == 0x94 + len - 1) {
+                        return -ENODEV;
+                } else if (ret < 0) {
+                        em28xx_warn("failed to get i2c transfer status from "
+                                    "bridge register (error=%i)\n", ret);
+                        return ret;
+                }
                 msleep(5);
         }
-        em28xx_warn("i2c write timed out\n");
+        em28xx_warn("write to i2c device at 0x%x timed out\n", addr);
         return -EIO;
 }
 
 /*
- * em2800_i2c_send_bytes()
- */
-static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
-                                 short len)
-{
-        char *bufPtr = buf;
-        int ret;
-        int wrcount = 0;
-        int count;
-        int maxLen = 4;
-        struct em28xx *dev = (struct em28xx *)data;
-        while (len > 0) {
-                count = (len > maxLen) ? maxLen : len;
-                ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
-                if (ret > 0) {
-                        len -= count;
-                        bufPtr += count;
-                        wrcount += count;
-                } else
-                        return (ret < 0) ? ret : -EFAULT;
-        }
-        return wrcount;
-}
-
-/*
- * em2800_i2c_check_for_device()
- * check if there is a i2c_device at the supplied address
+ * em2800_i2c_recv_bytes()
+ * read up to 4 bytes from the em2800 i2c device
  */
-static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
+static int em2800_i2c_recv_bytes(struct em28xx *dev, u8 addr, u8 *buf, u16 len)
 {
-        char msg;
+        u8 buf2[4];
         int ret;
-        int write_timeout;
-        msg = addr;
-        ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
-        if (ret < 0) {
-                em28xx_warn("setting i2c device address failed (error=%i)\n",
-                            ret);
-                return ret;
-        }
-        msg = 0x84;
-        ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
-        if (ret < 0) {
-                em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
-                return ret;
+        int read_timeout;
+        int i;
+
+        if (len < 1 || len > 4)
+                return -EOPNOTSUPP;
+
+        /* trigger read */
+        buf2[1] = 0x84 + len - 1;
+        buf2[0] = addr;
+        ret = dev->em28xx_write_regs(dev, 0x04, buf2, 2);
+        if (ret != 2) {
+                em28xx_warn("failed to trigger read from i2c address 0x%x "
+                            "(error=%i)\n", addr, ret);
+                return (ret < 0) ? ret : -EIO;
         }
-        for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
-             write_timeout -= 5) {
-                unsigned reg = dev->em28xx_read_reg(dev, 0x5);
 
-                if (reg == 0x94)
+        /* wait for completion */
+        for (read_timeout = EM2800_I2C_XFER_TIMEOUT; read_timeout > 0;
+             read_timeout -= 5) {
+                ret = dev->em28xx_read_reg(dev, 0x05);
+                if (ret == 0x84 + len - 1) {
+                        break;
+                } else if (ret == 0x94 + len - 1) {
                         return -ENODEV;
-                else if (reg == 0x84)
-                        return 0;
+                } else if (ret < 0) {
+                        em28xx_warn("failed to get i2c transfer status from "
+                                    "bridge register (error=%i)\n", ret);
+                        return ret;
+                }
                 msleep(5);
         }
-        return -ENODEV;
+        if (ret != 0x84 + len - 1)
+                em28xx_warn("read from i2c device at 0x%x timed out\n", addr);
+
+        /* get the received message */
+        ret = dev->em28xx_read_reg_req_len(dev, 0x00, 4-len, buf2, len);
+        if (ret != len) {
+                em28xx_warn("reading from i2c device at 0x%x failed: "
+                            "couldn't get the received message from the bridge "
+                            "(error=%i)\n", addr, ret);
+                return (ret < 0) ? ret : -EIO;
+        }
+        for (i = 0; i < len; i++)
+                buf[i] = buf2[len - 1 - i];
+
+        return ret;
 }
 
 /*
- * em2800_i2c_recv_bytes()
- * read from the i2c device
+ * em2800_i2c_check_for_device()
+ * check if there is an i2c device at the supplied address
  */
-static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
-                                 char *buf, int len)
+static int em2800_i2c_check_for_device(struct em28xx *dev, u8 addr)
 {
+        u8 buf;
         int ret;
-        /* check for the device and set i2c read address */
-        ret = em2800_i2c_check_for_device(dev, addr);
-        if (ret) {
-                em28xx_warn
-                    ("preparing read at i2c address 0x%x failed (error=%i)\n",
-                     addr, ret);
-                return ret;
-        }
-        ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
-        if (ret < 0) {
-                em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
-                            addr, ret);
-                return ret;
-        }
-        return ret;
+
+        ret = em2800_i2c_recv_bytes(dev, addr, &buf, 1);
+        if (ret == 1)
+                return 0;
+        return (ret < 0) ? ret : -EIO;
 }
 
 /*
  * em28xx_i2c_send_bytes()
  */
-static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
-                                 short len, int stop)
+static int em28xx_i2c_send_bytes(struct em28xx *dev, u16 addr, u8 *buf,
+                                 u16 len, int stop)
 {
-        int wrcount = 0;
-        struct em28xx *dev = (struct em28xx *)data;
         int write_timeout, ret;
 
-        wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
+        if (len < 1 || len > 64)
+                return -EOPNOTSUPP;
+        /* NOTE: limited by the USB ctrl message constraints
+         * Zero length reads always succeed, even if no device is connected */
+
+        /* Write to i2c device */
+        ret = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
+        if (ret != len) {
+                if (ret < 0) {
+                        em28xx_warn("writing to i2c device at 0x%x failed "
+                                    "(error=%i)\n", addr, ret);
+                        return ret;
+                } else {
+                        em28xx_warn("%i bytes write to i2c device at 0x%x "
+                                    "requested, but %i bytes written\n",
+                                    len, addr, ret);
+                        return -EIO;
+                }
+        }
 
-        /* Seems to be required after a write */
-        for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
+        /* Check success of the i2c operation */
+        for (write_timeout = EM2800_I2C_XFER_TIMEOUT; write_timeout > 0;
              write_timeout -= 5) {
                 ret = dev->em28xx_read_reg(dev, 0x05);
-                if (!ret)
-                        break;
+                if (ret == 0) { /* success */
+                        return len;
+                } else if (ret == 0x10) {
+                        return -ENODEV;
+                } else if (ret < 0) {
+                        em28xx_warn("failed to read i2c transfer status from "
+                                    "bridge (error=%i)\n", ret);
+                        return ret;
+                }
                 msleep(5);
+                /* NOTE: do we really have to wait for success ?
+                   Never seen anything else than 0x00 or 0x10
+                   (even with high payload) ...                 */
         }
-
-        return wrcount;
+        em28xx_warn("write to i2c device at 0x%x timed out\n", addr);
+        return -EIO;
 }
 
 /*
  * em28xx_i2c_recv_bytes()
  * read a byte from the i2c device
  */
-static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
-                                 char *buf, int len)
+static int em28xx_i2c_recv_bytes(struct em28xx *dev, u16 addr, u8 *buf, u16 len)
 {
         int ret;
+
+        if (len < 1 || len > 64)
+                return -EOPNOTSUPP;
+        /* NOTE: limited by the USB ctrl message constraints
+         * Zero length reads always succeed, even if no device is connected */
+
+        /* Read data from i2c device */
         ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
+        if (ret != len) {
+                if (ret < 0) {
+                        em28xx_warn("reading from i2c device at 0x%x failed "
+                                    "(error=%i)\n", addr, ret);
+                        return ret;
+                } else {
+                        em28xx_warn("%i bytes requested from i2c device at "
+                                    "0x%x, but %i bytes received\n",
+                                    len, addr, ret);
+                        return -EIO;
+                }
+        }
+
+        /* Check success of the i2c operation */
+        ret = dev->em28xx_read_reg(dev, 0x05);
         if (ret < 0) {
-                em28xx_warn("reading i2c device failed (error=%i)\n", ret);
+                em28xx_warn("failed to read i2c transfer status from "
+                            "bridge (error=%i)\n", ret);
                 return ret;
         }
-        if (dev->em28xx_read_reg(dev, 0x5) != 0)
-                return -ENODEV;
-        return ret;
+        if (ret > 0) {
+                if (ret == 0x10) {
+                        return -ENODEV;
+                } else {
+                        em28xx_warn("unknown i2c error (status=%i)\n", ret);
+                        return -EIO;
+                }
+        }
+        return len;
 }
 
 /*
  * em28xx_i2c_check_for_device()
  * check if there is a i2c_device at the supplied address
  */
-static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
+static int em28xx_i2c_check_for_device(struct em28xx *dev, u16 addr)
 {
         int ret;
+        u8 buf;
 
-        ret = dev->em28xx_read_reg_req(dev, 2, addr);
-        if (ret < 0) {
-                em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
-                return ret;
-        }
-        if (dev->em28xx_read_reg(dev, 0x5) != 0)
-                return -ENODEV;
-        return 0;
+        ret = em28xx_i2c_recv_bytes(dev, addr, &buf, 1);
+        if (ret == 1)
+                return 0;
+        return (ret < 0) ? ret : -EIO;
 }
 
 /*
@@ -253,11 +303,11 @@ static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
                                 rc = em2800_i2c_check_for_device(dev, addr);
                         else
                                 rc = em28xx_i2c_check_for_device(dev, addr);
-                        if (rc < 0) {
-                                dprintk2(2, " no device\n");
+                        if (rc == -ENODEV) {
+                                if (i2c_debug >= 2)
+                                        printk(" no device\n");
                                 return rc;
                         }
-
                 } else if (msgs[i].flags & I2C_M_RD) {
                         /* read bytes */
                         if (dev->board.is_em2800)
@@ -288,16 +338,16 @@ static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
                                                            msgs[i].len,
                                                            i == num - 1);
                 }
-                if (rc < 0)
-                        goto err;
+                if (rc < 0) {
+                        if (i2c_debug >= 2)
+                                printk(" ERROR: %i\n", rc);
+                        return rc;
+                }
                 if (i2c_debug >= 2)
                         printk("\n");
         }
 
         return num;
-err:
-        dprintk2(2, " ERROR: %i\n", rc);
-        return rc;
 }
 
 /* based on linux/sunrpc/svcauth.h and linux/hash.h
@@ -329,7 +379,7 @@ static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
 {
         unsigned char buf, *p = eedata;
         struct em28xx_eeprom *em_eeprom = (void *)eedata;
-        int i, err, size = len, block;
+        int i, err, size = len, block, block_max;
 
         if (dev->chip_id == CHIP_ID_EM2874 ||
             dev->chip_id == CHIP_ID_EM28174 ||
@@ -362,9 +412,15 @@ static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
                        dev->name, err);
                 return err;
         }
+
+        if (dev->board.is_em2800)
+                block_max = 4;
+        else
+                block_max = 64;
+
         while (size > 0) {
-                if (size > 16)
-                        block = 16;
+                if (size > block_max)
+                        block = block_max;
                 else
                         block = size;
 
@@ -449,7 +505,11 @@ static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
  */
 static u32 functionality(struct i2c_adapter *adap)
 {
-        return I2C_FUNC_SMBUS_EMUL;
+        struct em28xx *dev = adap->algo_data;
+        u32 func_flags = I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
+        if (dev->board.is_em2800)
+                func_flags &= ~I2C_FUNC_SMBUS_WRITE_BLOCK_DATA;
+        return func_flags;
 }
 
 static struct i2c_algorithm em28xx_algo = {
@@ -474,6 +534,7 @@ static struct i2c_client em28xx_client_template = {
  * incomplete list of known devices
  */
 static char *i2c_devs[128] = {
+        [0x3e >> 1] = "remote IR sensor",
         [0x4a >> 1] = "saa7113h",
         [0x52 >> 1] = "drxk",
         [0x60 >> 1] = "remote IR sensor",
diff --git a/drivers/media/usb/em28xx/em28xx-input.c b/drivers/media/usb/em28xx/em28xx-input.c
index 660bf803c9e4..1bef990b3f18 100644
--- a/drivers/media/usb/em28xx/em28xx-input.c
+++ b/drivers/media/usb/em28xx/em28xx-input.c
@@ -40,11 +40,6 @@ MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
 
 #define MODULE_NAME "em28xx"
 
-#define i2cdprintk(fmt, arg...) \
-        if (ir_debug) { \
-                printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
-        }
-
 #define dprintk(fmt, arg...) \
         if (ir_debug) { \
                 printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
@@ -57,8 +52,8 @@ MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
 struct em28xx_ir_poll_result {
         unsigned int toggle_bit:1;
         unsigned int read_count:7;
-        u8 rc_address;
-        u8 rc_data[4]; /* 1 byte on em2860/2880, 4 on em2874 */
+
+        u32 scancode;
 };
 
 struct em28xx_IR {
@@ -67,12 +62,17 @@ struct em28xx_IR {
         char name[32];
         char phys[32];
 
-        /* poll external decoder */
+        /* poll decoder */
         int polling;
         struct delayed_work work;
         unsigned int full_code:1;
         unsigned int last_readcount;
+        u64 rc_type;
 
+        /* i2c slave address of external device (if used) */
+        u16 i2c_dev_addr;
+
+        int  (*get_key_i2c)(struct i2c_client *, u32 *);
         int  (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *);
 };
 
@@ -80,21 +80,16 @@ struct em28xx_IR {
  I2C IR based get keycodes - should be used with ir-kbd-i2c
  **********************************************************/
 
-static int em28xx_get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+static int em28xx_get_key_terratec(struct i2c_client *i2c_dev, u32 *ir_key)
 {
         unsigned char b;
 
         /* poll IR chip */
-        if (1 != i2c_master_recv(ir->c, &b, 1)) {
-                i2cdprintk("read error\n");
+        if (1 != i2c_master_recv(i2c_dev, &b, 1))
                 return -EIO;
-        }
 
         /* it seems that 0xFE indicates that a button is still hold
-           down, while 0xff indicates that no button is hold
-           down. 0xfe sequences are sometimes interrupted by 0xFF */
-
-        i2cdprintk("key %02x\n", b);
+           down, while 0xff indicates that no button is hold down. */
 
         if (b == 0xff)
                 return 0;
@@ -104,18 +99,17 @@ static int em28xx_get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
                 return 1;
 
         *ir_key = b;
-        *ir_raw = b;
         return 1;
 }
 
-static int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
+static int em28xx_get_key_em_haup(struct i2c_client *i2c_dev, u32 *ir_key)
 {
         unsigned char buf[2];
         u16 code;
         int size;
 
         /* poll IR chip */
-        size = i2c_master_recv(ir->c, buf, sizeof(buf));
+        size = i2c_master_recv(i2c_dev, buf, sizeof(buf));
 
         if (size != 2)
                 return -EIO;
@@ -124,8 +118,6 @@ static int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
         if (buf[1] == 0xff)
                 return 0;
 
-        ir->old = buf[1];
-
         /*
          * Rearranges bits to the right order.
          * The bit order were determined experimentally by using
@@ -148,65 +140,51 @@ static int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
                  ((buf[1] & 0x40) ? 0x0200 : 0) | /* 0000 0010            */
                  ((buf[1] & 0x80) ? 0x0100 : 0);  /* 0000 0001            */
 
-        i2cdprintk("ir hauppauge (em2840): code=0x%02x (rcv=0x%02x%02x)\n",
-                        code, buf[1], buf[0]);
-
         /* return key */
         *ir_key = code;
-        *ir_raw = code;
         return 1;
 }
 
-static int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key,
-                                     u32 *ir_raw)
+static int em28xx_get_key_pinnacle_usb_grey(struct i2c_client *i2c_dev,
+                                            u32 *ir_key)
 {
         unsigned char buf[3];
 
         /* poll IR chip */
 
-        if (3 != i2c_master_recv(ir->c, buf, 3)) {
-                i2cdprintk("read error\n");
+        if (3 != i2c_master_recv(i2c_dev, buf, 3))
                 return -EIO;
-        }
 
-        i2cdprintk("key %02x\n", buf[2]&0x3f);
         if (buf[0] != 0x00)
                 return 0;
 
         *ir_key = buf[2]&0x3f;
-        *ir_raw = buf[2]&0x3f;
 
         return 1;
 }
 
-static int em28xx_get_key_winfast_usbii_deluxe(struct IR_i2c *ir, u32 *ir_key,
-                                        u32 *ir_raw)
+static int em28xx_get_key_winfast_usbii_deluxe(struct i2c_client *i2c_dev,
+                                               u32 *ir_key)
 {
         unsigned char subaddr, keydetect, key;
 
-        struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0, .buf = &subaddr, .len = 1},
-
-                                { .addr = ir->c->addr, .flags = I2C_M_RD, .buf = &keydetect, .len = 1} };
+        struct i2c_msg msg[] = { { .addr = i2c_dev->addr, .flags = 0, .buf = &subaddr, .len = 1},
+                                 { .addr = i2c_dev->addr, .flags = I2C_M_RD, .buf = &keydetect, .len = 1} };
 
         subaddr = 0x10;
-        if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
-                i2cdprintk("read error\n");
+        if (2 != i2c_transfer(i2c_dev->adapter, msg, 2))
                 return -EIO;
-        }
         if (keydetect == 0x00)
                 return 0;
 
         subaddr = 0x00;
         msg[1].buf = &key;
-        if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
-                i2cdprintk("read error\n");
-        return -EIO;
-        }
+        if (2 != i2c_transfer(i2c_dev->adapter, msg, 2))
+                return -EIO;
         if (key == 0x00)
                 return 0;
 
         *ir_key = key;
-        *ir_raw = key;
         return 1;
 }
 
@@ -236,11 +214,8 @@ static int default_polling_getkey(struct em28xx_IR *ir,
         /* Infrared read count (Reg 0x45[6:0] */
         poll_result->read_count = (msg[0] & 0x7f);
 
-        /* Remote Control Address (Reg 0x46) */
-        poll_result->rc_address = msg[1];
-
-        /* Remote Control Data (Reg 0x47) */
-        poll_result->rc_data[0] = msg[2];
+        /* Remote Control Address/Data (Regs 0x46/0x47) */
+        poll_result->scancode = msg[1] << 8 | msg[2];
 
         return 0;
 }
@@ -266,13 +241,35 @@ static int em2874_polling_getkey(struct em28xx_IR *ir,
         /* Infrared read count (Reg 0x51[6:0] */
         poll_result->read_count = (msg[0] & 0x7f);
 
-        /* Remote Control Address (Reg 0x52) */
-        poll_result->rc_address = msg[1];
-
-        /* Remote Control Data (Reg 0x53-55) */
-        poll_result->rc_data[0] = msg[2];
-        poll_result->rc_data[1] = msg[3];
-        poll_result->rc_data[2] = msg[4];
+        /*
+         * Remote Control Address (Reg 0x52)
+         * Remote Control Data (Reg 0x53-0x55)
+         */
+        switch (ir->rc_type) {
+        case RC_BIT_RC5:
+                poll_result->scancode = msg[1] << 8 | msg[2];
+                break;
+        case RC_BIT_NEC:
+                if ((msg[3] ^ msg[4]) != 0xff)          /* 32 bits NEC */
+                        poll_result->scancode = (msg[1] << 24) |
+                                                (msg[2] << 16) |
+                                                (msg[3] << 8)  |
+                                                 msg[4];
+                else if ((msg[1] ^ msg[2]) != 0xff)     /* 24 bits NEC */
+                        poll_result->scancode = (msg[1] << 16) |
+                                                (msg[2] << 8)  |
+                                                 msg[3];
+                else                                    /* Normal NEC */
+                        poll_result->scancode = msg[1] << 8 | msg[3];
+                break;
+        case RC_BIT_RC6_0:
+                poll_result->scancode = msg[1] << 8 | msg[2];
+                break;
+        default:
+                poll_result->scancode = (msg[1] << 24) | (msg[2] << 16) |
+                                        (msg[3] << 8)  | msg[4];
+                break;
+        }
 
         return 0;
 }
@@ -281,6 +278,28 @@ static int em2874_polling_getkey(struct em28xx_IR *ir,
  Polling code for em28xx
  **********************************************************/
 
+static int em28xx_i2c_ir_handle_key(struct em28xx_IR *ir)
+{
+        static u32 ir_key;
+        int rc;
+        struct i2c_client client;
+
+        client.adapter = &ir->dev->i2c_adap;
+        client.addr = ir->i2c_dev_addr;
+
+        rc = ir->get_key_i2c(&client, &ir_key);
+        if (rc < 0) {
+                dprintk("ir->get_key_i2c() failed: %d\n", rc);
+                return rc;
+        }
+
+        if (rc) {
+                dprintk("%s: keycode = 0x%04x\n", __func__, ir_key);
+                rc_keydown(ir->rc, ir_key, 0);
+        }
+        return 0;
+}
+
 static void em28xx_ir_handle_key(struct em28xx_IR *ir)
 {
         int result;
@@ -289,22 +308,21 @@ static void em28xx_ir_handle_key(struct em28xx_IR *ir)
         /* read the registers containing the IR status */
         result = ir->get_key(ir, &poll_result);
         if (unlikely(result < 0)) {
-                dprintk("ir->get_key() failed %d\n", result);
+                dprintk("ir->get_key() failed: %d\n", result);
                 return;
         }
 
         if (unlikely(poll_result.read_count != ir->last_readcount)) {
-                dprintk("%s: toggle: %d, count: %d, key 0x%02x%02x\n", __func__,
+                dprintk("%s: toggle: %d, count: %d, key 0x%04x\n", __func__,
                         poll_result.toggle_bit, poll_result.read_count,
-                        poll_result.rc_address, poll_result.rc_data[0]);
+                        poll_result.scancode);
                 if (ir->full_code)
                         rc_keydown(ir->rc,
-                                   poll_result.rc_address << 8 |
-                                   poll_result.rc_data[0],
+                                   poll_result.scancode,
                                    poll_result.toggle_bit);
                 else
                         rc_keydown(ir->rc,
-                                   poll_result.rc_data[0],
+                                   poll_result.scancode & 0xff,
                                    poll_result.toggle_bit);
 
                 if (ir->dev->chip_id == CHIP_ID_EM2874 ||
@@ -324,7 +342,10 @@ static void em28xx_ir_work(struct work_struct *work)
 {
         struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work);
 
-        em28xx_ir_handle_key(ir);
+        if (ir->i2c_dev_addr) /* external i2c device */
+                em28xx_i2c_ir_handle_key(ir);
+        else /* internal device */
+                em28xx_ir_handle_key(ir);
         schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
 }
 
@@ -345,93 +366,107 @@ static void em28xx_ir_stop(struct rc_dev *rc)
         cancel_delayed_work_sync(&ir->work);
 }
 
-static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type)
+static int em2860_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type)
 {
-        int rc = 0;
         struct em28xx_IR *ir = rc_dev->priv;
         struct em28xx *dev = ir->dev;
-        u8 ir_config = EM2874_IR_RC5;
-
-        /* Adjust xclk based o IR table for RC5/NEC tables */
 
+        /* Adjust xclk based on IR table for RC5/NEC tables */
         if (*rc_type & RC_BIT_RC5) {
                 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
                 ir->full_code = 1;
                 *rc_type = RC_BIT_RC5;
         } else if (*rc_type & RC_BIT_NEC) {
                 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
-                ir_config = EM2874_IR_NEC;
                 ir->full_code = 1;
                 *rc_type = RC_BIT_NEC;
-        } else if (*rc_type != RC_BIT_UNKNOWN)
-                rc = -EINVAL;
+        } else if (*rc_type & RC_BIT_UNKNOWN) {
+                *rc_type = RC_BIT_UNKNOWN;
+        } else {
+                *rc_type = ir->rc_type;
+                return -EINVAL;
+        }
+        em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
+                              EM28XX_XCLK_IR_RC5_MODE);
+
+        ir->rc_type = *rc_type;
 
+        return 0;
+}
+
+static int em2874_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type)
+{
+        struct em28xx_IR *ir = rc_dev->priv;
+        struct em28xx *dev = ir->dev;
+        u8 ir_config = EM2874_IR_RC5;
+
+        /* Adjust xclk and set type based on IR table for RC5/NEC/RC6 tables */
+        if (*rc_type & RC_BIT_RC5) {
+                dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
+                ir->full_code = 1;
+                *rc_type = RC_BIT_RC5;
+        } else if (*rc_type & RC_BIT_NEC) {
+                dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
+                ir_config = EM2874_IR_NEC | EM2874_IR_NEC_NO_PARITY;
+                ir->full_code = 1;
+                *rc_type = RC_BIT_NEC;
+        } else if (*rc_type & RC_BIT_RC6_0) {
+                dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
+                ir_config = EM2874_IR_RC6_MODE_0;
+                ir->full_code = 1;
+                *rc_type = RC_BIT_RC6_0;
+        } else if (*rc_type & RC_BIT_UNKNOWN) {
+                *rc_type = RC_BIT_UNKNOWN;
+        } else {
+                *rc_type = ir->rc_type;
+                return -EINVAL;
+        }
+        em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1);
         em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
                               EM28XX_XCLK_IR_RC5_MODE);
 
+        ir->rc_type = *rc_type;
+
+        return 0;
+}
+static int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 *rc_type)
+{
+        struct em28xx_IR *ir = rc_dev->priv;
+        struct em28xx *dev = ir->dev;
+
         /* Setup the proper handler based on the chip */
         switch (dev->chip_id) {
         case CHIP_ID_EM2860:
         case CHIP_ID_EM2883:
-                ir->get_key = default_polling_getkey;
-                break;
+                return em2860_ir_change_protocol(rc_dev, rc_type);
         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;
+                return em2874_ir_change_protocol(rc_dev, rc_type);
         default:
                 printk("Unrecognized em28xx chip id 0x%02x: IR not supported\n",
                         dev->chip_id);
-                rc = -EINVAL;
+                return -EINVAL;
         }
-
-        return rc;
 }
 
-static void em28xx_register_i2c_ir(struct em28xx *dev)
+static int em28xx_probe_i2c_ir(struct em28xx *dev)
 {
+        int i = 0;
         /* Leadtek winfast tv USBII deluxe can find a non working IR-device */
         /* at address 0x18, so if that address is needed for another board in */
         /* the future, please put it after 0x1f. */
-        struct i2c_board_info info;
         const unsigned short addr_list[] = {
                  0x1f, 0x30, 0x47, I2C_CLIENT_END
         };
 
-        memset(&info, 0, sizeof(struct i2c_board_info));
-        memset(&dev->init_data, 0, sizeof(dev->init_data));
-        strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
-
-        /* detect & configure */
-        switch (dev->model) {
-        case EM2800_BOARD_TERRATEC_CINERGY_200:
-        case EM2820_BOARD_TERRATEC_CINERGY_250:
-                dev->init_data.ir_codes = RC_MAP_EM_TERRATEC;
-                dev->init_data.get_key = em28xx_get_key_terratec;
-                dev->init_data.name = "i2c IR (EM28XX Terratec)";
-                break;
-        case EM2820_BOARD_PINNACLE_USB_2:
-                dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY;
-                dev->init_data.get_key = em28xx_get_key_pinnacle_usb_grey;
-                dev->init_data.name = "i2c IR (EM28XX Pinnacle PCTV)";
-                break;
-        case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
-                dev->init_data.ir_codes = RC_MAP_HAUPPAUGE;
-                dev->init_data.get_key = em28xx_get_key_em_haup;
-                dev->init_data.name = "i2c IR (EM2840 Hauppauge)";
-                break;
-        case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE:
-                dev->init_data.ir_codes = RC_MAP_WINFAST_USBII_DELUXE;
-                dev->init_data.get_key = em28xx_get_key_winfast_usbii_deluxe;
-                dev->init_data.name = "i2c IR (EM2820 Winfast TV USBII Deluxe)";
-                break;
+        while (addr_list[i] != I2C_CLIENT_END) {
+                if (i2c_probe_func_quick_read(&dev->i2c_adap, addr_list[i]) == 1)
+                        return addr_list[i];
+                i++;
         }
 
-        if (dev->init_data.name)
-                info.platform_data = &dev->init_data;
-        i2c_new_probed_device(&dev->i2c_adap, &info, addr_list, NULL);
+        return -ENODEV;
 }
 
 /**********************************************************
@@ -527,8 +562,21 @@ static int em28xx_ir_init(struct em28xx *dev)
         struct rc_dev *rc;
         int err = -ENOMEM;
         u64 rc_type;
+        u16 i2c_rc_dev_addr = 0;
+
+        if (dev->board.has_snapshot_button)
+                em28xx_register_snapshot_button(dev);
+
+        if (dev->board.has_ir_i2c) {
+                i2c_rc_dev_addr = em28xx_probe_i2c_ir(dev);
+                if (!i2c_rc_dev_addr) {
+                        dev->board.has_ir_i2c = 0;
+                        em28xx_warn("No i2c IR remote control device found.\n");
+                        return -ENODEV;
+                }
+        }
 
-        if (dev->board.ir_codes == NULL) {
+        if (dev->board.ir_codes == NULL && !dev->board.has_ir_i2c) {
                 /* No remote control support */
                 em28xx_warn("Remote control support is not available for "
                                 "this card.\n");
@@ -538,35 +586,77 @@ static int em28xx_ir_init(struct em28xx *dev)
         ir = kzalloc(sizeof(*ir), GFP_KERNEL);
         rc = rc_allocate_device();
         if (!ir || !rc)
-                goto err_out_free;
+                goto error;
 
         /* record handles to ourself */
         ir->dev = dev;
         dev->ir = ir;
         ir->rc = rc;
 
-        /*
-         * em2874 supports more protocols. For now, let's just announce
-         * the two protocols that were already tested
-         */
-        rc->allowed_protos = RC_BIT_RC5 | RC_BIT_NEC;
         rc->priv = ir;
-        rc->change_protocol = em28xx_ir_change_protocol;
         rc->open = em28xx_ir_start;
         rc->close = em28xx_ir_stop;
 
-        /* By default, keep protocol field untouched */
-        rc_type = RC_BIT_UNKNOWN;
-        err = em28xx_ir_change_protocol(rc, &rc_type);
-        if (err)
-                goto err_out_free;
+        if (dev->board.has_ir_i2c) {    /* external i2c device */
+                switch (dev->model) {
+                case EM2800_BOARD_TERRATEC_CINERGY_200:
+                case EM2820_BOARD_TERRATEC_CINERGY_250:
+                        rc->map_name = RC_MAP_EM_TERRATEC;
+                        ir->get_key_i2c = em28xx_get_key_terratec;
+                        break;
+                case EM2820_BOARD_PINNACLE_USB_2:
+                        rc->map_name = RC_MAP_PINNACLE_GREY;
+                        ir->get_key_i2c = em28xx_get_key_pinnacle_usb_grey;
+                        break;
+                case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
+                        rc->map_name = RC_MAP_HAUPPAUGE;
+                        ir->get_key_i2c = em28xx_get_key_em_haup;
+                        rc->allowed_protos = RC_BIT_RC5;
+                        break;
+                case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE:
+                        rc->map_name = RC_MAP_WINFAST_USBII_DELUXE;
+                        ir->get_key_i2c = em28xx_get_key_winfast_usbii_deluxe;
+                        break;
+                default:
+                        err = -ENODEV;
+                        goto error;
+                }
+
+                ir->i2c_dev_addr = i2c_rc_dev_addr;
+        } else {        /* internal device */
+                switch (dev->chip_id) {
+                case CHIP_ID_EM2860:
+                case CHIP_ID_EM2883:
+                        rc->allowed_protos = RC_BIT_RC5 | RC_BIT_NEC;
+                        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;
+                        rc->allowed_protos = RC_BIT_RC5 | RC_BIT_NEC |
+                                             RC_BIT_RC6_0;
+                        break;
+                default:
+                        err = -ENODEV;
+                        goto error;
+                }
+
+                rc->change_protocol = em28xx_ir_change_protocol;
+                rc->map_name = dev->board.ir_codes;
+
+                /* By default, keep protocol field untouched */
+                rc_type = RC_BIT_UNKNOWN;
+                err = em28xx_ir_change_protocol(rc, &rc_type);
+                if (err)
+                        goto error;
+        }
 
         /* This is how often we ask the chip for IR information */
         ir->polling = 100; /* ms */
 
         /* init input device */
-        snprintf(ir->name, sizeof(ir->name), "em28xx IR (%s)",
-                                                dev->name);
+        snprintf(ir->name, sizeof(ir->name), "em28xx IR (%s)", dev->name);
 
         usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
         strlcat(ir->phys, "/input0", sizeof(ir->phys));
@@ -578,28 +668,17 @@ static int em28xx_ir_init(struct em28xx *dev)
         rc->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
         rc->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
         rc->dev.parent = &dev->udev->dev;
-        rc->map_name = dev->board.ir_codes;
         rc->driver_name = MODULE_NAME;
 
         /* all done */
         err = rc_register_device(rc);
         if (err)
-                goto err_out_stop;
-
-        em28xx_register_i2c_ir(dev);
-
-#if defined(CONFIG_MODULES) && defined(MODULE)
-        if (dev->board.has_ir_i2c)
-                request_module("ir-kbd-i2c");
-#endif
-        if (dev->board.has_snapshot_button)
-                em28xx_register_snapshot_button(dev);
+                goto error;
 
         return 0;
 
- err_out_stop:
+error:
         dev->ir = NULL;
- err_out_free:
         rc_free_device(rc);
         kfree(ir);
         return err;
diff --git a/drivers/media/usb/em28xx/em28xx-reg.h b/drivers/media/usb/em28xx/em28xx-reg.h
index 6ff368297f6e..885089e22bcd 100644
--- a/drivers/media/usb/em28xx/em28xx-reg.h
+++ b/drivers/media/usb/em28xx/em28xx-reg.h
@@ -13,9 +13,9 @@
 #define EM_GPO_3   (1 << 3)
 
 /* em28xx endpoints */
-#define EM28XX_EP_ANALOG        0x82
+/* 0x82:   (always ?) analog */
 #define EM28XX_EP_AUDIO         0x83
-#define EM28XX_EP_DIGITAL       0x84
+/* 0x84:   digital or analog */
 
 /* em2800 registers */
 #define EM2800_R08_AUDIOSRC 0x08
@@ -177,6 +177,7 @@
 
 /* em2874 IR config register (0x50) */
 #define EM2874_IR_NEC           0x00
+#define EM2874_IR_NEC_NO_PARITY 0x01
 #define EM2874_IR_RC5           0x04
 #define EM2874_IR_RC6_MODE_0    0x08
 #define EM2874_IR_RC6_MODE_6A   0x0b
diff --git a/drivers/media/usb/em28xx/em28xx-vbi.c b/drivers/media/usb/em28xx/em28xx-vbi.c
index 2b4c9cba2d67..39f39c527c13 100644
--- a/drivers/media/usb/em28xx/em28xx-vbi.c
+++ b/drivers/media/usb/em28xx/em28xx-vbi.c
@@ -41,105 +41,72 @@ MODULE_PARM_DESC(vbi_debug, "enable debug messages [vbi]");
 
 /* ------------------------------------------------------------------ */
 
-static void
-free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
+static int vbi_queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
+                           unsigned int *nbuffers, unsigned int *nplanes,
+                           unsigned int sizes[], void *alloc_ctxs[])
 {
-        struct em28xx_fh     *fh  = vq->priv_data;
-        struct em28xx        *dev = fh->dev;
-        unsigned long flags = 0;
-        if (in_interrupt())
-                BUG();
-
-        /* We used to wait for the buffer to finish here, but this didn't work
-           because, as we were keeping the state as VIDEOBUF_QUEUED,
-           videobuf_queue_cancel marked it as finished for us.
-           (Also, it could wedge forever if the hardware was misconfigured.)
-
-           This should be safe; by the time we get here, the buffer isn't
-           queued anymore. If we ever start marking the buffers as
-           VIDEOBUF_ACTIVE, it won't be, though.
-        */
-        spin_lock_irqsave(&dev->slock, flags);
-        if (dev->isoc_ctl.vbi_buf == buf)
-                dev->isoc_ctl.vbi_buf = NULL;
-        spin_unlock_irqrestore(&dev->slock, flags);
+        struct em28xx *dev = vb2_get_drv_priv(vq);
+        unsigned long size;
 
-        videobuf_vmalloc_free(&buf->vb);
-        buf->vb.state = VIDEOBUF_NEEDS_INIT;
-}
+        if (fmt)
+                size = fmt->fmt.pix.sizeimage;
+        else
+                size = dev->vbi_width * dev->vbi_height * 2;
 
-static int
-vbi_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
-{
-        struct em28xx_fh     *fh  = q->priv_data;
-        struct em28xx        *dev = fh->dev;
+        if (0 == *nbuffers)
+                *nbuffers = 32;
+        if (*nbuffers < 2)
+                *nbuffers = 2;
+        if (*nbuffers > 32)
+                *nbuffers = 32;
 
-        *size = dev->vbi_width * dev->vbi_height * 2;
+        *nplanes = 1;
+        sizes[0] = size;
 
-        if (0 == *count)
-                *count = vbibufs;
-        if (*count < 2)
-                *count = 2;
-        if (*count > 32)
-                *count = 32;
         return 0;
 }
 
-static int
-vbi_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
-            enum v4l2_field field)
+static int vbi_buffer_prepare(struct vb2_buffer *vb)
 {
-        struct em28xx_fh     *fh  = q->priv_data;
-        struct em28xx        *dev = fh->dev;
+        struct em28xx        *dev = vb2_get_drv_priv(vb->vb2_queue);
         struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
-        int                  rc = 0;
+        unsigned long        size;
 
-        buf->vb.size = dev->vbi_width * dev->vbi_height * 2;
+        size = dev->vbi_width * dev->vbi_height * 2;
 
-        if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
+        if (vb2_plane_size(vb, 0) < size) {
+                printk(KERN_INFO "%s data will not fit into plane (%lu < %lu)\n",
+                       __func__, vb2_plane_size(vb, 0), size);
                 return -EINVAL;
-
-        buf->vb.width  = dev->vbi_width;
-        buf->vb.height = dev->vbi_height;
-        buf->vb.field  = field;
-
-        if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
-                rc = videobuf_iolock(q, &buf->vb, NULL);
-                if (rc < 0)
-                        goto fail;
         }
+        vb2_set_plane_payload(&buf->vb, 0, size);
 
-        buf->vb.state = VIDEOBUF_PREPARED;
         return 0;
-
-fail:
-        free_buffer(q, buf);
-        return rc;
 }
 
 static void
-vbi_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
-{
-        struct em28xx_buffer    *buf     = container_of(vb,
-                                                        struct em28xx_buffer,
-                                                        vb);
-        struct em28xx_fh        *fh      = vq->priv_data;
-        struct em28xx           *dev     = fh->dev;
-        struct em28xx_dmaqueue  *vbiq    = &dev->vbiq;
-
-        buf->vb.state = VIDEOBUF_QUEUED;
-        list_add_tail(&buf->vb.queue, &vbiq->active);
-}
-
-static void vbi_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
+vbi_buffer_queue(struct vb2_buffer *vb)
 {
+        struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
         struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
-        free_buffer(q, buf);
+        struct em28xx_dmaqueue *vbiq = &dev->vbiq;
+        unsigned long flags = 0;
+
+        buf->mem = vb2_plane_vaddr(vb, 0);
+        buf->length = vb2_plane_size(vb, 0);
+
+        spin_lock_irqsave(&dev->slock, flags);
+        list_add_tail(&buf->list, &vbiq->active);
+        spin_unlock_irqrestore(&dev->slock, flags);
 }
 
-struct videobuf_queue_ops em28xx_vbi_qops = {
-        .buf_setup    = vbi_setup,
-        .buf_prepare  = vbi_prepare,
-        .buf_queue    = vbi_queue,
-        .buf_release  = vbi_release,
+
+struct vb2_ops em28xx_vbi_qops = {
+        .queue_setup    = vbi_queue_setup,
+        .buf_prepare    = vbi_buffer_prepare,
+        .buf_queue      = vbi_buffer_queue,
+        .start_streaming = em28xx_start_analog_streaming,
+        .stop_streaming = em28xx_stop_vbi_streaming,
+        .wait_prepare   = vb2_ops_wait_prepare,
+        .wait_finish    = vb2_ops_wait_finish,
 };
diff --git a/drivers/media/usb/em28xx/em28xx-video.c b/drivers/media/usb/em28xx/em28xx-video.c
index 1e553d357380..32bd7de5dec1 100644
--- a/drivers/media/usb/em28xx/em28xx-video.c
+++ b/drivers/media/usb/em28xx/em28xx-video.c
@@ -6,6 +6,7 @@
                       Markus Rechberger <mrechberger@gmail.com>
                       Mauro Carvalho Chehab <mchehab@infradead.org>
                       Sascha Sommer <saschasommer@freenet.de>
+   Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
 
         Some parts based on SN9C10x PC Camera Controllers GPL driver made
                 by Luca Risolia <luca.risolia@studio.unibo.it>
@@ -39,6 +40,7 @@
 #include "em28xx.h"
 #include <media/v4l2-common.h>
 #include <media/v4l2-ioctl.h>
+#include <media/v4l2-event.h>
 #include <media/v4l2-chip-ident.h>
 #include <media/msp3400.h>
 #include <media/tuner.h>
@@ -74,9 +76,9 @@ MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 MODULE_VERSION(EM28XX_VERSION);
 
-static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
-static unsigned int vbi_nr[]   = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
-static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
+static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
+static unsigned int vbi_nr[]   = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
+static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = -1U };
 
 module_param_array(video_nr, int, NULL, 0444);
 module_param_array(vbi_nr, int, NULL, 0444);
@@ -124,101 +126,50 @@ static struct em28xx_fmt format[] = {
         },
 };
 
-/* supported controls */
-/* Common to all boards */
-static struct v4l2_queryctrl ac97_qctrl[] = {
-        {
-                .id = V4L2_CID_AUDIO_VOLUME,
-                .type = V4L2_CTRL_TYPE_INTEGER,
-                .name = "Volume",
-                .minimum = 0x0,
-                .maximum = 0x1f,
-                .step = 0x1,
-                .default_value = 0x1f,
-                .flags = V4L2_CTRL_FLAG_SLIDER,
-        }, {
-                .id = V4L2_CID_AUDIO_MUTE,
-                .type = V4L2_CTRL_TYPE_BOOLEAN,
-                .name = "Mute",
-                .minimum = 0,
-                .maximum = 1,
-                .step = 1,
-                .default_value = 1,
-                .flags = 0,
-        }
-};
-
 /* ------------------------------------------------------------------
         DMA and thread functions
    ------------------------------------------------------------------*/
 
 /*
- * Announces that a buffer were filled and request the next
+ * Finish the current buffer
  */
-static inline void buffer_filled(struct em28xx *dev,
-                                  struct em28xx_dmaqueue *dma_q,
-                                  struct em28xx_buffer *buf)
+static inline void finish_buffer(struct em28xx *dev,
+                                 struct em28xx_buffer *buf)
 {
-        /* Advice that buffer was filled */
-        em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
-        buf->vb.state = VIDEOBUF_DONE;
-        buf->vb.field_count++;
-        do_gettimeofday(&buf->vb.ts);
+        em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->top_field);
 
-        dev->isoc_ctl.vid_buf = NULL;
+        buf->vb.v4l2_buf.sequence = dev->field_count++;
+        buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
+        v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 
-        list_del(&buf->vb.queue);
-        wake_up(&buf->vb.done);
-}
-
-static inline void vbi_buffer_filled(struct em28xx *dev,
-                                     struct em28xx_dmaqueue *dma_q,
-                                     struct em28xx_buffer *buf)
-{
-        /* Advice that buffer was filled */
-        em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
-
-        buf->vb.state = VIDEOBUF_DONE;
-        buf->vb.field_count++;
-        do_gettimeofday(&buf->vb.ts);
-
-        dev->isoc_ctl.vbi_buf = NULL;
-
-        list_del(&buf->vb.queue);
-        wake_up(&buf->vb.done);
+        vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 }
 
 /*
- * Identify the buffer header type and properly handles
+ * Copy picture data from USB buffer to videobuf buffer
  */
 static void em28xx_copy_video(struct em28xx *dev,
-                              struct em28xx_dmaqueue  *dma_q,
                               struct em28xx_buffer *buf,
-                              unsigned char *p,
-                              unsigned char *outp, unsigned long len)
+                              unsigned char *usb_buf,
+                              unsigned long len)
 {
         void *fieldstart, *startwrite, *startread;
         int  linesdone, currlinedone, offset, lencopy, remain;
         int bytesperline = dev->width << 1;
 
-        if (dma_q->pos + len > buf->vb.size)
-                len = buf->vb.size - dma_q->pos;
+        if (buf->pos + len > buf->length)
+                len = buf->length - buf->pos;
 
-        startread = p;
+        startread = usb_buf;
         remain = len;
 
-        if (dev->progressive)
-                fieldstart = outp;
-        else {
-                /* Interlaces two half frames */
-                if (buf->top_field)
-                        fieldstart = outp;
-                else
-                        fieldstart = outp + bytesperline;
-        }
+        if (dev->progressive || buf->top_field)
+                fieldstart = buf->vb_buf;
+        else /* interlaced mode, even nr. of lines */
+                fieldstart = buf->vb_buf + bytesperline;
 
-        linesdone = dma_q->pos / bytesperline;
-        currlinedone = dma_q->pos % bytesperline;
+        linesdone = buf->pos / bytesperline;
+        currlinedone = buf->pos % bytesperline;
 
         if (dev->progressive)
                 offset = linesdone * bytesperline + currlinedone;
@@ -229,11 +180,12 @@ static void em28xx_copy_video(struct em28xx *dev,
         lencopy = bytesperline - currlinedone;
         lencopy = lencopy > remain ? remain : lencopy;
 
-        if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
+        if ((char *)startwrite + lencopy > (char *)buf->vb_buf + buf->length) {
                 em28xx_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
-                               ((char *)startwrite + lencopy) -
-                               ((char *)outp + buf->vb.size));
-                remain = (char *)outp + buf->vb.size - (char *)startwrite;
+                              ((char *)startwrite + lencopy) -
+                              ((char *)buf->vb_buf + buf->length));
+                remain = (char *)buf->vb_buf + buf->length -
+                         (char *)startwrite;
                 lencopy = remain;
         }
         if (lencopy <= 0)
@@ -243,21 +195,24 @@ static void em28xx_copy_video(struct em28xx *dev,
         remain -= lencopy;
 
         while (remain > 0) {
-                startwrite += lencopy + bytesperline;
+                if (dev->progressive)
+                        startwrite += lencopy;
+                else
+                        startwrite += lencopy + bytesperline;
                 startread += lencopy;
                 if (bytesperline > remain)
                         lencopy = remain;
                 else
                         lencopy = bytesperline;
 
-                if ((char *)startwrite + lencopy > (char *)outp +
-                    buf->vb.size) {
+                if ((char *)startwrite + lencopy > (char *)buf->vb_buf +
+                    buf->length) {
                         em28xx_isocdbg("Overflow of %zi bytes past buffer end"
                                        "(2)\n",
                                        ((char *)startwrite + lencopy) -
-                                       ((char *)outp + buf->vb.size));
-                        lencopy = remain = (char *)outp + buf->vb.size -
-                                           (char *)startwrite;
+                                       ((char *)buf->vb_buf + buf->length));
+                        lencopy = remain = (char *)buf->vb_buf + buf->length -
+                                (char *)startwrite;
                 }
                 if (lencopy <= 0)
                         break;
@@ -267,57 +222,29 @@ static void em28xx_copy_video(struct em28xx *dev,
                 remain -= lencopy;
         }
 
-        dma_q->pos += len;
+        buf->pos += len;
 }
 
+/*
+ * Copy VBI data from USB buffer to videobuf buffer
+ */
 static void em28xx_copy_vbi(struct em28xx *dev,
-                              struct em28xx_dmaqueue  *dma_q,
-                              struct em28xx_buffer *buf,
-                              unsigned char *p,
-                              unsigned char *outp, unsigned long len)
+                            struct em28xx_buffer *buf,
+                            unsigned char *usb_buf,
+                            unsigned long len)
 {
-        void *startwrite, *startread;
-        int  offset;
-        int bytesperline;
-
-        if (dev == NULL) {
-                em28xx_isocdbg("dev is null\n");
-                return;
-        }
-        bytesperline = dev->vbi_width;
+        unsigned int offset;
 
-        if (dma_q == NULL) {
-                em28xx_isocdbg("dma_q is null\n");
-                return;
-        }
-        if (buf == NULL) {
-                return;
-        }
-        if (p == NULL) {
-                em28xx_isocdbg("p is null\n");
-                return;
-        }
-        if (outp == NULL) {
-                em28xx_isocdbg("outp is null\n");
-                return;
-        }
-
-        if (dma_q->pos + len > buf->vb.size)
-                len = buf->vb.size - dma_q->pos;
-
-        startread = p;
-
-        startwrite = outp + dma_q->pos;
-        offset = dma_q->pos;
+        if (buf->pos + len > buf->length)
+                len = buf->length - buf->pos;
 
+        offset = buf->pos;
         /* Make sure the bottom field populates the second half of the frame */
-        if (buf->top_field == 0) {
-                startwrite += bytesperline * dev->vbi_height;
-                offset += bytesperline * dev->vbi_height;
-        }
+        if (buf->top_field == 0)
+                offset += dev->vbi_width * dev->vbi_height;
 
-        memcpy(startwrite, startread, len);
-        dma_q->pos += len;
+        memcpy(buf->vb_buf + offset, usb_buf, len);
+        buf->pos += len;
 }
 
 static inline void print_err_status(struct em28xx *dev,
@@ -360,470 +287,444 @@ static inline void print_err_status(struct em28xx *dev,
 }
 
 /*
- * video-buf generic routine to get the next available buffer
+ * get the next available buffer from dma queue
  */
-static inline void get_next_buf(struct em28xx_dmaqueue *dma_q,
-                                          struct em28xx_buffer **buf)
+static inline struct em28xx_buffer *get_next_buf(struct em28xx *dev,
+                                                 struct em28xx_dmaqueue *dma_q)
 {
-        struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
-        char *outp;
+        struct em28xx_buffer *buf;
 
         if (list_empty(&dma_q->active)) {
                 em28xx_isocdbg("No active queue to serve\n");
-                dev->isoc_ctl.vid_buf = NULL;
-                *buf = NULL;
-                return;
+                return NULL;
         }
 
         /* Get the next buffer */
-        *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue);
-
+        buf = list_entry(dma_q->active.next, struct em28xx_buffer, list);
         /* Cleans up buffer - Useful for testing for frame/URB loss */
-        outp = videobuf_to_vmalloc(&(*buf)->vb);
-        memset(outp, 0, (*buf)->vb.size);
+        list_del(&buf->list);
+        buf->pos = 0;
+        buf->vb_buf = buf->mem;
 
-        dev->isoc_ctl.vid_buf = *buf;
-
-        return;
+        return buf;
 }
 
 /*
- * video-buf generic routine to get the next available VBI buffer
+ * Finish the current buffer if completed and prepare for the next field
  */
-static inline void vbi_get_next_buf(struct em28xx_dmaqueue *dma_q,
-                                    struct em28xx_buffer **buf)
-{
-        struct em28xx *dev = container_of(dma_q, struct em28xx, vbiq);
-        char *outp;
-
-        if (list_empty(&dma_q->active)) {
-                em28xx_isocdbg("No active queue to serve\n");
-                dev->isoc_ctl.vbi_buf = NULL;
-                *buf = NULL;
-                return;
+static struct em28xx_buffer *
+finish_field_prepare_next(struct em28xx *dev,
+                          struct em28xx_buffer *buf,
+                          struct em28xx_dmaqueue *dma_q)
+{
+        if (dev->progressive || dev->top_field) { /* Brand new frame */
+                if (buf != NULL)
+                        finish_buffer(dev, buf);
+                buf = get_next_buf(dev, dma_q);
+        }
+        if (buf != NULL) {
+                buf->top_field = dev->top_field;
+                buf->pos = 0;
         }
 
-        /* Get the next buffer */
-        *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue);
-        /* Cleans up buffer - Useful for testing for frame/URB loss */
-        outp = videobuf_to_vmalloc(&(*buf)->vb);
-        memset(outp, 0x00, (*buf)->vb.size);
-
-        dev->isoc_ctl.vbi_buf = *buf;
-
-        return;
+        return buf;
 }
 
 /*
- * Controls the isoc copy of each urb packet
+ * Process data packet according to the em2710/em2750/em28xx frame data format
  */
-static inline int em28xx_isoc_copy(struct em28xx *dev, struct urb *urb)
+static inline void process_frame_data_em28xx(struct em28xx *dev,
+                                             unsigned char *data_pkt,
+                                             unsigned int  data_len)
 {
-        struct em28xx_buffer    *buf;
+        struct em28xx_buffer    *buf = dev->usb_ctl.vid_buf;
+        struct em28xx_buffer    *vbi_buf = dev->usb_ctl.vbi_buf;
         struct em28xx_dmaqueue  *dma_q = &dev->vidq;
-        unsigned char *outp = NULL;
-        int i, len = 0, rc = 1;
-        unsigned char *p;
-
-        if (!dev)
-                return 0;
-
-        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
-                return 0;
-
-        if (urb->status < 0) {
-                print_err_status(dev, -1, urb->status);
-                if (urb->status == -ENOENT)
-                        return 0;
-        }
-
-        buf = dev->isoc_ctl.vid_buf;
-        if (buf != NULL)
-                outp = videobuf_to_vmalloc(&buf->vb);
-
-        for (i = 0; i < urb->number_of_packets; i++) {
-                int status = urb->iso_frame_desc[i].status;
+        struct em28xx_dmaqueue  *vbi_dma_q = &dev->vbiq;
 
-                if (status < 0) {
-                        print_err_status(dev, i, status);
-                        if (urb->iso_frame_desc[i].status != -EPROTO)
-                                continue;
+        /* capture type 0 = vbi start
+           capture type 1 = vbi in progress
+           capture type 2 = video start
+           capture type 3 = video in progress */
+        if (data_len >= 4) {
+                /* NOTE: Headers are always 4 bytes and
+                 * never split across packets */
+                if (data_pkt[0] == 0x88 && data_pkt[1] == 0x88 &&
+                    data_pkt[2] == 0x88 && data_pkt[3] == 0x88) {
+                        /* Continuation */
+                        data_pkt += 4;
+                        data_len -= 4;
+                } else if (data_pkt[0] == 0x33 && data_pkt[1] == 0x95) {
+                        /* Field start (VBI mode) */
+                        dev->capture_type = 0;
+                        dev->vbi_read = 0;
+                        em28xx_isocdbg("VBI START HEADER !!!\n");
+                        dev->top_field = !(data_pkt[2] & 1);
+                        data_pkt += 4;
+                        data_len -= 4;
+                } else if (data_pkt[0] == 0x22 && data_pkt[1] == 0x5a) {
+                        /* Field start (VBI disabled) */
+                        dev->capture_type = 2;
+                        em28xx_isocdbg("VIDEO START HEADER !!!\n");
+                        dev->top_field = !(data_pkt[2] & 1);
+                        data_pkt += 4;
+                        data_len -= 4;
                 }
+        }
+        /* NOTE: With bulk transfers, intermediate data packets
+         * have no continuation header */
 
-                len = urb->iso_frame_desc[i].actual_length - 4;
+        if (dev->capture_type == 0) {
+                vbi_buf = finish_field_prepare_next(dev, vbi_buf, vbi_dma_q);
+                dev->usb_ctl.vbi_buf = vbi_buf;
+                dev->capture_type = 1;
+        }
 
-                if (urb->iso_frame_desc[i].actual_length <= 0) {
-                        /* em28xx_isocdbg("packet %d is empty",i); - spammy */
-                        continue;
-                }
-                if (urb->iso_frame_desc[i].actual_length >
-                                                dev->max_pkt_size) {
-                        em28xx_isocdbg("packet bigger than packet size");
-                        continue;
-                }
+        if (dev->capture_type == 1) {
+                int vbi_size = dev->vbi_width * dev->vbi_height;
+                int vbi_data_len = ((dev->vbi_read + data_len) > vbi_size) ?
+                                   (vbi_size - dev->vbi_read) : data_len;
 
-                p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+                /* Copy VBI data */
+                if (vbi_buf != NULL)
+                        em28xx_copy_vbi(dev, vbi_buf, data_pkt, vbi_data_len);
+                dev->vbi_read += vbi_data_len;
 
-                /* FIXME: incomplete buffer checks where removed to make
-                   logic simpler. Impacts of those changes should be evaluated
-                 */
-                if (p[0] == 0x33 && p[1] == 0x95 && p[2] == 0x00) {
-                        em28xx_isocdbg("VBI HEADER!!!\n");
-                        /* FIXME: Should add vbi copy */
-                        continue;
+                if (vbi_data_len < data_len) {
+                        /* Continue with copying video data */
+                        dev->capture_type = 2;
+                        data_pkt += vbi_data_len;
+                        data_len -= vbi_data_len;
                 }
-                if (p[0] == 0x22 && p[1] == 0x5a) {
-                        em28xx_isocdbg("Video frame %d, length=%i, %s\n", p[2],
-                                       len, (p[2] & 1) ? "odd" : "even");
-
-                        if (dev->progressive || !(p[2] & 1)) {
-                                if (buf != NULL)
-                                        buffer_filled(dev, dma_q, buf);
-                                get_next_buf(dma_q, &buf);
-                                if (buf == NULL)
-                                        outp = NULL;
-                                else
-                                        outp = videobuf_to_vmalloc(&buf->vb);
-                        }
-
-                        if (buf != NULL) {
-                                if (p[2] & 1)
-                                        buf->top_field = 0;
-                                else
-                                        buf->top_field = 1;
-                        }
+        }
 
-                        dma_q->pos = 0;
-                }
-                if (buf != NULL) {
-                        if (p[0] != 0x88 && p[0] != 0x22) {
-                                em28xx_isocdbg("frame is not complete\n");
-                                len += 4;
-                        } else {
-                                p += 4;
-                        }
-                        em28xx_copy_video(dev, dma_q, buf, p, outp, len);
-                }
+        if (dev->capture_type == 2) {
+                buf = finish_field_prepare_next(dev, buf, dma_q);
+                dev->usb_ctl.vid_buf = buf;
+                dev->capture_type = 3;
         }
-        return rc;
+
+        if (dev->capture_type == 3 && buf != NULL && data_len > 0)
+                em28xx_copy_video(dev, buf, data_pkt, data_len);
 }
 
-/* Version of isoc handler that takes into account a mixture of video and
-   VBI data */
-static inline int em28xx_isoc_copy_vbi(struct em28xx *dev, struct urb *urb)
+/* Processes and copies the URB data content (video and VBI data) */
+static inline int em28xx_urb_data_copy(struct em28xx *dev, struct urb *urb)
 {
-        struct em28xx_buffer    *buf, *vbi_buf;
-        struct em28xx_dmaqueue  *dma_q = &dev->vidq;
-        struct em28xx_dmaqueue  *vbi_dma_q = &dev->vbiq;
-        unsigned char *outp = NULL;
-        unsigned char *vbioutp = NULL;
-        int i, len = 0, rc = 1;
-        unsigned char *p;
-        int vbi_size;
+        int xfer_bulk, num_packets, i;
+        unsigned char *usb_data_pkt;
+        unsigned int usb_data_len;
 
         if (!dev)
                 return 0;
 
-        if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
+        if (dev->disconnected)
                 return 0;
 
-        if (urb->status < 0) {
+        if (urb->status < 0)
                 print_err_status(dev, -1, urb->status);
-                if (urb->status == -ENOENT)
-                        return 0;
-        }
 
-        buf = dev->isoc_ctl.vid_buf;
-        if (buf != NULL)
-                outp = videobuf_to_vmalloc(&buf->vb);
+        xfer_bulk = usb_pipebulk(urb->pipe);
 
-        vbi_buf = dev->isoc_ctl.vbi_buf;
-        if (vbi_buf != NULL)
-                vbioutp = videobuf_to_vmalloc(&vbi_buf->vb);
+        if (xfer_bulk) /* bulk */
+                num_packets = 1;
+        else /* isoc */
+                num_packets = urb->number_of_packets;
 
-        for (i = 0; i < urb->number_of_packets; i++) {
-                int status = urb->iso_frame_desc[i].status;
+        for (i = 0; i < num_packets; i++) {
+                if (xfer_bulk) { /* bulk */
+                        usb_data_len = urb->actual_length;
 
-                if (status < 0) {
-                        print_err_status(dev, i, status);
-                        if (urb->iso_frame_desc[i].status != -EPROTO)
+                        usb_data_pkt = urb->transfer_buffer;
+                } else { /* isoc */
+                        if (urb->iso_frame_desc[i].status < 0) {
+                                print_err_status(dev, i,
+                                                 urb->iso_frame_desc[i].status);
+                                if (urb->iso_frame_desc[i].status != -EPROTO)
+                                        continue;
+                        }
+
+                        usb_data_len = urb->iso_frame_desc[i].actual_length;
+                        if (usb_data_len > dev->max_pkt_size) {
+                                em28xx_isocdbg("packet bigger than packet size");
                                 continue;
-                }
+                        }
 
-                len = urb->iso_frame_desc[i].actual_length;
-                if (urb->iso_frame_desc[i].actual_length <= 0) {
-                        /* em28xx_isocdbg("packet %d is empty",i); - spammy */
-                        continue;
-                }
-                if (urb->iso_frame_desc[i].actual_length >
-                                                dev->max_pkt_size) {
-                        em28xx_isocdbg("packet bigger than packet size");
-                        continue;
+                        usb_data_pkt = urb->transfer_buffer +
+                                       urb->iso_frame_desc[i].offset;
                 }
 
-                p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
-
-                /* capture type 0 = vbi start
-                   capture type 1 = video start
-                   capture type 2 = video in progress */
-                if (p[0] == 0x33 && p[1] == 0x95) {
-                        dev->capture_type = 0;
-                        dev->vbi_read = 0;
-                        em28xx_isocdbg("VBI START HEADER!!!\n");
-                        dev->cur_field = p[2];
-                        p += 4;
-                        len -= 4;
-                } else if (p[0] == 0x88 && p[1] == 0x88 &&
-                           p[2] == 0x88 && p[3] == 0x88) {
-                        /* continuation */
-                        p += 4;
-                        len -= 4;
-                } else if (p[0] == 0x22 && p[1] == 0x5a) {
-                        /* start video */
-                        p += 4;
-                        len -= 4;
+                if (usb_data_len == 0) {
+                        /* NOTE: happens very often with isoc transfers */
+                        /* em28xx_usbdbg("packet %d is empty",i); - spammy */
+                        continue;
                 }
 
-                vbi_size = dev->vbi_width * dev->vbi_height;
-
-                if (dev->capture_type == 0) {
-                        if (dev->vbi_read >= vbi_size) {
-                                /* We've already read all the VBI data, so
-                                   treat the rest as video */
-                                em28xx_isocdbg("dev->vbi_read > vbi_size\n");
-                        } else if ((dev->vbi_read + len) < vbi_size) {
-                                /* This entire frame is VBI data */
-                                if (dev->vbi_read == 0 &&
-                                    (!(dev->cur_field & 1))) {
-                                        /* Brand new frame */
-                                        if (vbi_buf != NULL)
-                                                vbi_buffer_filled(dev,
-                                                                  vbi_dma_q,
-                                                                  vbi_buf);
-                                        vbi_get_next_buf(vbi_dma_q, &vbi_buf);
-                                        if (vbi_buf == NULL)
-                                                vbioutp = NULL;
-                                        else
-                                                vbioutp = videobuf_to_vmalloc(
-                                                        &vbi_buf->vb);
-                                }
-
-                                if (dev->vbi_read == 0) {
-                                        vbi_dma_q->pos = 0;
-                                        if (vbi_buf != NULL) {
-                                                if (dev->cur_field & 1)
-                                                        vbi_buf->top_field = 0;
-                                                else
-                                                        vbi_buf->top_field = 1;
-                                        }
-                                }
-
-                                dev->vbi_read += len;
-                                em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
-                                                vbioutp, len);
-                        } else {
-                                /* Some of this frame is VBI data and some is
-                                   video data */
-                                int vbi_data_len = vbi_size - dev->vbi_read;
-                                dev->vbi_read += vbi_data_len;
-                                em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
-                                                vbioutp, vbi_data_len);
-                                dev->capture_type = 1;
-                                p += vbi_data_len;
-                                len -= vbi_data_len;
-                        }
-                }
+                process_frame_data_em28xx(dev, usb_data_pkt, usb_data_len);
+        }
+        return 1;
+}
 
-                if (dev->capture_type == 1) {
-                        dev->capture_type = 2;
-                        if (dev->progressive || !(dev->cur_field & 1)) {
-                                if (buf != NULL)
-                                        buffer_filled(dev, dma_q, buf);
-                                get_next_buf(dma_q, &buf);
-                                if (buf == NULL)
-                                        outp = NULL;
-                                else
-                                        outp = videobuf_to_vmalloc(&buf->vb);
-                        }
-                        if (buf != NULL) {
-                                if (dev->cur_field & 1)
-                                        buf->top_field = 0;
-                                else
-                                        buf->top_field = 1;
-                        }
 
-                        dma_q->pos = 0;
-                }
+static int get_ressource(enum v4l2_buf_type f_type)
+{
+        switch (f_type) {
+        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                return EM28XX_RESOURCE_VIDEO;
+        case V4L2_BUF_TYPE_VBI_CAPTURE:
+                return EM28XX_RESOURCE_VBI;
+        default:
+                BUG();
+                return 0;
+        }
+}
 
-                if (buf != NULL && dev->capture_type == 2) {
-                        if (len >= 4 && p[0] == 0x88 && p[1] == 0x88 &&
-                            p[2] == 0x88 && p[3] == 0x88) {
-                                p += 4;
-                                len -= 4;
-                        }
-                        if (len >= 4 && p[0] == 0x22 && p[1] == 0x5a) {
-                                em28xx_isocdbg("Video frame %d, len=%i, %s\n",
-                                               p[2], len, (p[2] & 1) ?
-                                               "odd" : "even");
-                                p += 4;
-                                len -= 4;
-                        }
+/* Usage lock check functions */
+static int res_get(struct em28xx *dev, enum v4l2_buf_type f_type)
+{
+        int res_type = get_ressource(f_type);
 
-                        if (len > 0)
-                                em28xx_copy_video(dev, dma_q, buf, p, outp,
-                                                  len);
-                }
+        /* is it free? */
+        if (dev->resources & res_type) {
+                /* no, someone else uses it */
+                return -EBUSY;
         }
-        return rc;
+
+        /* it's free, grab it */
+        dev->resources |= res_type;
+        em28xx_videodbg("res: get %d\n", res_type);
+        return 0;
 }
 
+static void res_free(struct em28xx *dev, enum v4l2_buf_type f_type)
+{
+        int res_type = get_ressource(f_type);
+
+        dev->resources &= ~res_type;
+        em28xx_videodbg("res: put %d\n", res_type);
+}
 
 /* ------------------------------------------------------------------
-        Videobuf operations
+        Videobuf2 operations
    ------------------------------------------------------------------*/
 
-static int
-buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
+static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *fmt,
+                       unsigned int *nbuffers, unsigned int *nplanes,
+                       unsigned int sizes[], void *alloc_ctxs[])
 {
-        struct em28xx_fh *fh = vq->priv_data;
-        struct em28xx        *dev = fh->dev;
-        struct v4l2_frequency f;
+        struct em28xx *dev = vb2_get_drv_priv(vq);
+        unsigned long size;
 
-        *size = (fh->dev->width * fh->dev->height * dev->format->depth + 7)
-                >> 3;
-
-        if (0 == *count)
-                *count = EM28XX_DEF_BUF;
+        if (fmt)
+                size = fmt->fmt.pix.sizeimage;
+        else
+                size = (dev->width * dev->height * dev->format->depth + 7) >> 3;
 
-        if (*count < EM28XX_MIN_BUF)
-                *count = EM28XX_MIN_BUF;
+        if (size == 0)
+                return -EINVAL;
 
-        /* Ask tuner to go to analog or radio mode */
-        memset(&f, 0, sizeof(f));
-        f.frequency = dev->ctl_freq;
-        f.type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
+        if (0 == *nbuffers)
+                *nbuffers = 32;
 
-        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
+        *nplanes = 1;
+        sizes[0] = size;
 
         return 0;
 }
 
-/* This is called *without* dev->slock held; please keep it that way */
-static void free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
+static int
+buffer_prepare(struct vb2_buffer *vb)
 {
-        struct em28xx_fh     *fh  = vq->priv_data;
-        struct em28xx        *dev = fh->dev;
-        unsigned long flags = 0;
-        if (in_interrupt())
-                BUG();
+        struct em28xx        *dev = vb2_get_drv_priv(vb->vb2_queue);
+        struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
+        unsigned long size;
 
-        /* We used to wait for the buffer to finish here, but this didn't work
-           because, as we were keeping the state as VIDEOBUF_QUEUED,
-           videobuf_queue_cancel marked it as finished for us.
-           (Also, it could wedge forever if the hardware was misconfigured.)
+        em28xx_videodbg("%s, field=%d\n", __func__, vb->v4l2_buf.field);
 
-           This should be safe; by the time we get here, the buffer isn't
-           queued anymore. If we ever start marking the buffers as
-           VIDEOBUF_ACTIVE, it won't be, though.
-        */
-        spin_lock_irqsave(&dev->slock, flags);
-        if (dev->isoc_ctl.vid_buf == buf)
-                dev->isoc_ctl.vid_buf = NULL;
-        spin_unlock_irqrestore(&dev->slock, flags);
+        size = (dev->width * dev->height * dev->format->depth + 7) >> 3;
 
-        videobuf_vmalloc_free(&buf->vb);
-        buf->vb.state = VIDEOBUF_NEEDS_INIT;
+        if (vb2_plane_size(vb, 0) < size) {
+                em28xx_videodbg("%s data will not fit into plane (%lu < %lu)\n",
+                                __func__, vb2_plane_size(vb, 0), size);
+                return -EINVAL;
+        }
+        vb2_set_plane_payload(&buf->vb, 0, size);
+
+        return 0;
 }
 
-static int
-buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
-                                                enum v4l2_field field)
+int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count)
 {
-        struct em28xx_fh     *fh  = vq->priv_data;
-        struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
-        struct em28xx        *dev = fh->dev;
-        int                  rc = 0, urb_init = 0;
+        struct em28xx *dev = vb2_get_drv_priv(vq);
+        struct v4l2_frequency f;
+        int rc = 0;
 
-        buf->vb.size = (fh->dev->width * fh->dev->height * dev->format->depth
-                        + 7) >> 3;
+        em28xx_videodbg("%s\n", __func__);
 
-        if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
-                return -EINVAL;
+        /* Make sure streaming is not already in progress for this type
+           of filehandle (e.g. video, vbi) */
+        rc = res_get(dev, vq->type);
+        if (rc)
+                return rc;
+
+        if (dev->streaming_users++ == 0) {
+                /* First active streaming user, so allocate all the URBs */
 
-        buf->vb.width  = dev->width;
-        buf->vb.height = dev->height;
-        buf->vb.field  = field;
+                /* Allocate the USB bandwidth */
+                em28xx_set_alternate(dev);
+
+                /* Needed, since GPIO might have disabled power of
+                   some i2c device
+                */
+                em28xx_wake_i2c(dev);
 
-        if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
-                rc = videobuf_iolock(vq, &buf->vb, NULL);
+                dev->capture_type = -1;
+                rc = em28xx_init_usb_xfer(dev, EM28XX_ANALOG_MODE,
+                                          dev->analog_xfer_bulk,
+                                          EM28XX_NUM_BUFS,
+                                          dev->max_pkt_size,
+                                          dev->packet_multiplier,
+                                          em28xx_urb_data_copy);
                 if (rc < 0)
                         goto fail;
-        }
 
-        if (!dev->isoc_ctl.analog_bufs.num_bufs)
-                urb_init = 1;
+                /*
+                 * djh: it's not clear whether this code is still needed.  I'm
+                 * leaving it in here for now entirely out of concern for
+                 * backward compatibility (the old code did it)
+                 */
 
-        if (urb_init) {
-                if (em28xx_vbi_supported(dev) == 1)
-                        rc = em28xx_init_isoc(dev, EM28XX_ANALOG_MODE,
-                                              EM28XX_NUM_PACKETS,
-                                              EM28XX_NUM_BUFS,
-                                              dev->max_pkt_size,
-                                              em28xx_isoc_copy_vbi);
+                /* Ask tuner to go to analog or radio mode */
+                memset(&f, 0, sizeof(f));
+                f.frequency = dev->ctl_freq;
+                if (vq->owner && vq->owner->vdev->vfl_type == VFL_TYPE_RADIO)
+                        f.type = V4L2_TUNER_RADIO;
                 else
-                        rc = em28xx_init_isoc(dev, EM28XX_ANALOG_MODE,
-                                              EM28XX_NUM_PACKETS,
-                                              EM28XX_NUM_BUFS,
-                                              dev->max_pkt_size,
-                                              em28xx_isoc_copy);
-                if (rc < 0)
-                        goto fail;
+                        f.type = V4L2_TUNER_ANALOG_TV;
+                v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
         }
 
-        buf->vb.state = VIDEOBUF_PREPARED;
-        return 0;
-
 fail:
-        free_buffer(vq, buf);
         return rc;
 }
 
-static void
-buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
+static int em28xx_stop_streaming(struct vb2_queue *vq)
 {
-        struct em28xx_buffer    *buf     = container_of(vb,
-                                                        struct em28xx_buffer,
-                                                        vb);
-        struct em28xx_fh        *fh      = vq->priv_data;
-        struct em28xx           *dev     = fh->dev;
-        struct em28xx_dmaqueue  *vidq    = &dev->vidq;
+        struct em28xx *dev = vb2_get_drv_priv(vq);
+        struct em28xx_dmaqueue *vidq = &dev->vidq;
+        unsigned long flags = 0;
+
+        em28xx_videodbg("%s\n", __func__);
+
+        res_free(dev, vq->type);
+
+        if (dev->streaming_users-- == 1) {
+                /* Last active user, so shutdown all the URBS */
+                em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
+        }
 
-        buf->vb.state = VIDEOBUF_QUEUED;
-        list_add_tail(&buf->vb.queue, &vidq->active);
+        spin_lock_irqsave(&dev->slock, flags);
+        while (!list_empty(&vidq->active)) {
+                struct em28xx_buffer *buf;
+                buf = list_entry(vidq->active.next, struct em28xx_buffer, list);
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+        }
+        dev->usb_ctl.vid_buf = NULL;
+        spin_unlock_irqrestore(&dev->slock, flags);
 
+        return 0;
 }
 
-static void buffer_release(struct videobuf_queue *vq,
-                                struct videobuf_buffer *vb)
+int em28xx_stop_vbi_streaming(struct vb2_queue *vq)
 {
-        struct em28xx_buffer   *buf  = container_of(vb,
-                                                    struct em28xx_buffer,
-                                                    vb);
-        struct em28xx_fh       *fh   = vq->priv_data;
-        struct em28xx          *dev  = (struct em28xx *)fh->dev;
+        struct em28xx *dev = vb2_get_drv_priv(vq);
+        struct em28xx_dmaqueue *vbiq = &dev->vbiq;
+        unsigned long flags = 0;
+
+        em28xx_videodbg("%s\n", __func__);
 
-        em28xx_isocdbg("em28xx: called buffer_release\n");
+        res_free(dev, vq->type);
 
-        free_buffer(vq, buf);
+        if (dev->streaming_users-- == 1) {
+                /* Last active user, so shutdown all the URBS */
+                em28xx_uninit_usb_xfer(dev, EM28XX_ANALOG_MODE);
+        }
+
+        spin_lock_irqsave(&dev->slock, flags);
+        while (!list_empty(&vbiq->active)) {
+                struct em28xx_buffer *buf;
+                buf = list_entry(vbiq->active.next, struct em28xx_buffer, list);
+                list_del(&buf->list);
+                vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
+        }
+        dev->usb_ctl.vbi_buf = NULL;
+        spin_unlock_irqrestore(&dev->slock, flags);
+
+        return 0;
 }
 
-static struct videobuf_queue_ops em28xx_video_qops = {
-        .buf_setup      = buffer_setup,
+static void
+buffer_queue(struct vb2_buffer *vb)
+{
+        struct em28xx *dev = vb2_get_drv_priv(vb->vb2_queue);
+        struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
+        struct em28xx_dmaqueue *vidq = &dev->vidq;
+        unsigned long flags = 0;
+
+        em28xx_videodbg("%s\n", __func__);
+        buf->mem = vb2_plane_vaddr(vb, 0);
+        buf->length = vb2_plane_size(vb, 0);
+
+        spin_lock_irqsave(&dev->slock, flags);
+        list_add_tail(&buf->list, &vidq->active);
+        spin_unlock_irqrestore(&dev->slock, flags);
+}
+
+static struct vb2_ops em28xx_video_qops = {
+        .queue_setup    = queue_setup,
         .buf_prepare    = buffer_prepare,
         .buf_queue      = buffer_queue,
-        .buf_release    = buffer_release,
+        .start_streaming = em28xx_start_analog_streaming,
+        .stop_streaming = em28xx_stop_streaming,
+        .wait_prepare   = vb2_ops_wait_prepare,
+        .wait_finish    = vb2_ops_wait_finish,
 };
 
+int em28xx_vb2_setup(struct em28xx *dev)
+{
+        int rc;
+        struct vb2_queue *q;
+
+        /* Setup Videobuf2 for Video capture */
+        q = &dev->vb_vidq;
+        q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
+        q->drv_priv = dev;
+        q->buf_struct_size = sizeof(struct em28xx_buffer);
+        q->ops = &em28xx_video_qops;
+        q->mem_ops = &vb2_vmalloc_memops;
+
+        rc = vb2_queue_init(q);
+        if (rc < 0)
+                return rc;
+
+        /* Setup Videobuf2 for VBI capture */
+        q = &dev->vb_vbiq;
+        q->type = V4L2_BUF_TYPE_VBI_CAPTURE;
+        q->io_modes = VB2_READ | VB2_MMAP | VB2_USERPTR;
+        q->drv_priv = dev;
+        q->buf_struct_size = sizeof(struct em28xx_buffer);
+        q->ops = &em28xx_vbi_qops;
+        q->mem_ops = &vb2_vmalloc_memops;
+
+        rc = vb2_queue_init(q);
+        if (rc < 0)
+                return rc;
+
+        return 0;
+}
+
 /*********************  v4l2 interface  **************************************/
 
 static void video_mux(struct em28xx *dev, int index)
@@ -856,143 +757,54 @@ static void video_mux(struct em28xx *dev, int index)
         em28xx_audio_analog_set(dev);
 }
 
-/* Usage lock check functions */
-static int res_get(struct em28xx_fh *fh, unsigned int bit)
-{
-        struct em28xx    *dev = fh->dev;
-
-        if (fh->resources & bit)
-                /* have it already allocated */
-                return 1;
-
-        /* is it free? */
-        if (dev->resources & bit) {
-                /* no, someone else uses it */
-                return 0;
-        }
-        /* it's free, grab it */
-        fh->resources  |= bit;
-        dev->resources |= bit;
-        em28xx_videodbg("res: get %d\n", bit);
-        return 1;
-}
-
-static int res_check(struct em28xx_fh *fh, unsigned int bit)
-{
-        return fh->resources & bit;
-}
-
-static int res_locked(struct em28xx *dev, unsigned int bit)
-{
-        return dev->resources & bit;
-}
-
-static void res_free(struct em28xx_fh *fh, unsigned int bits)
+void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv)
 {
-        struct em28xx    *dev = fh->dev;
-
-        BUG_ON((fh->resources & bits) != bits);
-
-        fh->resources  &= ~bits;
-        dev->resources &= ~bits;
-        em28xx_videodbg("res: put %d\n", bits);
-}
-
-static int get_ressource(struct em28xx_fh *fh)
-{
-        switch (fh->type) {
-        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-                return EM28XX_RESOURCE_VIDEO;
-        case V4L2_BUF_TYPE_VBI_CAPTURE:
-                return EM28XX_RESOURCE_VBI;
-        default:
-                BUG();
-                return 0;
-        }
-}
-
-/*
- * ac97_queryctrl()
- * return the ac97 supported controls
- */
-static int ac97_queryctrl(struct v4l2_queryctrl *qc)
-{
-        int i;
+        struct em28xx *dev = priv;
 
-        for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) {
-                if (qc->id && qc->id == ac97_qctrl[i].id) {
-                        memcpy(qc, &(ac97_qctrl[i]), sizeof(*qc));
-                        return 0;
-                }
-        }
-
-        /* Control is not ac97 related */
-        return 1;
-}
-
-/*
- * ac97_get_ctrl()
- * return the current values for ac97 mute and volume
- */
-static int ac97_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
-{
+        /*
+         * In the case of non-AC97 volume controls, we still need
+         * to do some setups at em28xx, in order to mute/unmute
+         * and to adjust audio volume. However, the value ranges
+         * should be checked by the corresponding V4L subdriver.
+         */
         switch (ctrl->id) {
         case V4L2_CID_AUDIO_MUTE:
-                ctrl->value = dev->mute;
-                return 0;
+                dev->mute = ctrl->val;
+                em28xx_audio_analog_set(dev);
+                break;
         case V4L2_CID_AUDIO_VOLUME:
-                ctrl->value = dev->volume;
-                return 0;
-        default:
-                /* Control is not ac97 related */
-                return 1;
+                dev->volume = ctrl->val;
+                em28xx_audio_analog_set(dev);
+                break;
         }
 }
 
-/*
- * ac97_set_ctrl()
- * set values for ac97 mute and volume
- */
-static int ac97_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
+static int em28xx_s_ctrl(struct v4l2_ctrl *ctrl)
 {
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++)
-                if (ctrl->id == ac97_qctrl[i].id)
-                        goto handle;
-
-        /* Announce that hasn't handle it */
-        return 1;
-
-handle:
-        if (ctrl->value < ac97_qctrl[i].minimum ||
-            ctrl->value > ac97_qctrl[i].maximum)
-                return -ERANGE;
+        struct em28xx *dev = container_of(ctrl->handler, struct em28xx, ctrl_handler);
 
         switch (ctrl->id) {
         case V4L2_CID_AUDIO_MUTE:
-                dev->mute = ctrl->value;
+                dev->mute = ctrl->val;
                 break;
         case V4L2_CID_AUDIO_VOLUME:
-                dev->volume = ctrl->value;
+                dev->volume = ctrl->val;
                 break;
         }
 
         return em28xx_audio_analog_set(dev);
 }
 
+const struct v4l2_ctrl_ops em28xx_ctrl_ops = {
+        .s_ctrl = em28xx_s_ctrl,
+};
+
 static int check_dev(struct em28xx *dev)
 {
-        if (dev->state & DEV_DISCONNECTED) {
+        if (dev->disconnected) {
                 em28xx_errdev("v4l2 ioctl: device not present\n");
                 return -ENODEV;
         }
-
-        if (dev->state & DEV_MISCONFIGURED) {
-                em28xx_errdev("v4l2 ioctl: device is misconfigured; "
-                              "close and open it again\n");
-                return -EIO;
-        }
         return 0;
 }
 
@@ -1072,8 +884,11 @@ 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% */
+                /*
+                 * 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 {
@@ -1091,7 +906,7 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.width = width;
         f->fmt.pix.height = height;
         f->fmt.pix.pixelformat = fmt->fourcc;
-        f->fmt.pix.bytesperline = (dev->width * fmt->depth + 7) >> 3;
+        f->fmt.pix.bytesperline = (width * fmt->depth + 7) >> 3;
         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
         if (dev->progressive)
@@ -1119,7 +934,6 @@ static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
         /* set new image size */
         get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
 
-        em28xx_set_alternate(dev);
         em28xx_resolution_set(dev);
 
         return 0;
@@ -1128,21 +942,13 @@ static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
                         struct v4l2_format *f)
 {
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
+        struct em28xx *dev = video_drvdata(file);
 
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
+        if (dev->streaming_users > 0)
+                return -EBUSY;
 
         vidioc_try_fmt_vid_cap(file, priv, f);
 
-        if (videobuf_queue_is_busy(&fh->vb_vidq)) {
-                em28xx_errdev("%s queue busy\n", __func__);
-                return -EBUSY;
-        }
-
         return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
                                 f->fmt.pix.width, f->fmt.pix.height);
 }
@@ -1153,6 +959,8 @@ static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
         struct em28xx      *dev = fh->dev;
         int                rc;
 
+        if (dev->board.is_webcam)
+                return -ENOTTY;
         rc = check_dev(dev);
         if (rc < 0)
                 return rc;
@@ -1168,6 +976,8 @@ static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *norm)
         struct em28xx      *dev = fh->dev;
         int                rc;
 
+        if (dev->board.is_webcam)
+                return -ENOTTY;
         rc = check_dev(dev);
         if (rc < 0)
                 return rc;
@@ -1184,15 +994,22 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm)
         struct v4l2_format f;
         int                rc;
 
+        if (dev->board.is_webcam)
+                return -ENOTTY;
+        if (*norm == dev->norm)
+                return 0;
         rc = check_dev(dev);
         if (rc < 0)
                 return rc;
 
+        if (dev->streaming_users > 0)
+                return -EBUSY;
+
         dev->norm = *norm;
 
         /* Adjusts width/height, if needed */
-        f.fmt.pix.width = dev->width;
-        f.fmt.pix.height = dev->height;
+        f.fmt.pix.width = 720;
+        f.fmt.pix.height = (*norm & V4L2_STD_525_60) ? 480 : 576;
         vidioc_try_fmt_vid_cap(file, priv, &f);
 
         /* set new image size */
@@ -1216,6 +1033,7 @@ static int vidioc_g_parm(struct file *file, void *priv,
         if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
+        p->parm.capture.readbuffers = EM28XX_MIN_BUF;
         if (dev->board.is_webcam)
                 rc = v4l2_device_call_until_err(&dev->v4l2_dev, 0,
                                                 video, g_parm, p);
@@ -1233,11 +1051,12 @@ static int vidioc_s_parm(struct file *file, void *priv,
         struct em28xx      *dev = fh->dev;
 
         if (!dev->board.is_webcam)
-                return -EINVAL;
+                return -ENOTTY;
 
         if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
+        p->parm.capture.readbuffers = EM28XX_MIN_BUF;
         return v4l2_device_call_until_err(&dev->v4l2_dev, 0, video, s_parm, p);
 }
 
@@ -1276,6 +1095,9 @@ static int vidioc_enum_input(struct file *file, void *priv,
                 i->type = V4L2_INPUT_TYPE_TUNER;
 
         i->std = dev->vdev->tvnorms;
+        /* webcams do not have the STD API */
+        if (dev->board.is_webcam)
+                i->capabilities = 0;
 
         return 0;
 }
@@ -1375,131 +1197,6 @@ static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio
         return 0;
 }
 
-static int vidioc_queryctrl(struct file *file, void *priv,
-                                struct v4l2_queryctrl *qc)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   id  = qc->id;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        memset(qc, 0, sizeof(*qc));
-
-        qc->id = id;
-
-        /* enumerate AC97 controls */
-        if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
-                rc = ac97_queryctrl(qc);
-                if (!rc)
-                        return 0;
-        }
-
-        /* enumerate V4L2 device controls */
-        v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, qc);
-
-        if (qc->type)
-                return 0;
-        else
-                return -EINVAL;
-}
-
-/*
- * FIXME: This is an indirect way to check if a control exists at a
- * subdev. Instead of that hack, maybe the better would be to change all
- * subdevs to return -ENOIOCTLCMD, if an ioctl is not supported.
- */
-static int check_subdev_ctrl(struct em28xx *dev, int id)
-{
-        struct v4l2_queryctrl qc;
-
-        memset(&qc, 0, sizeof(qc));
-        qc.id = id;
-
-        /* enumerate V4L2 device controls */
-        v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, &qc);
-
-        if (qc.type)
-                return 0;
-        else
-                return -EINVAL;
-}
-
-static int vidioc_g_ctrl(struct file *file, void *priv,
-                                struct v4l2_control *ctrl)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-        rc = 0;
-
-        /* Set an AC97 control */
-        if (dev->audio_mode.ac97 != EM28XX_NO_AC97)
-                rc = ac97_get_ctrl(dev, ctrl);
-        else
-                rc = 1;
-
-        /* It were not an AC97 control. Sends it to the v4l2 dev interface */
-        if (rc == 1) {
-                if (check_subdev_ctrl(dev, ctrl->id))
-                        return -EINVAL;
-
-                v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl);
-                rc = 0;
-        }
-
-        return rc;
-}
-
-static int vidioc_s_ctrl(struct file *file, void *priv,
-                                struct v4l2_control *ctrl)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        /* Set an AC97 control */
-        if (dev->audio_mode.ac97 != EM28XX_NO_AC97)
-                rc = ac97_set_ctrl(dev, ctrl);
-        else
-                rc = 1;
-
-        /* It isn't an AC97 control. Sends it to the v4l2 dev interface */
-        if (rc == 1) {
-                rc = check_subdev_ctrl(dev, ctrl->id);
-                if (!rc)
-                        v4l2_device_call_all(&dev->v4l2_dev, 0,
-                                             core, s_ctrl, ctrl);
-                /*
-                 * In the case of non-AC97 volume controls, we still need
-                 * to do some setups at em28xx, in order to mute/unmute
-                 * and to adjust audio volume. However, the value ranges
-                 * should be checked by the corresponding V4L subdriver.
-                 */
-                switch (ctrl->id) {
-                case V4L2_CID_AUDIO_MUTE:
-                        dev->mute = ctrl->value;
-                        rc = em28xx_audio_analog_set(dev);
-                        break;
-                case V4L2_CID_AUDIO_VOLUME:
-                        dev->volume = ctrl->value;
-                        rc = em28xx_audio_analog_set(dev);
-                }
-        }
-        return (rc < 0) ? rc : 0;
-}
-
 static int vidioc_g_tuner(struct file *file, void *priv,
                                 struct v4l2_tuner *t)
 {
@@ -1515,7 +1212,6 @@ static int vidioc_g_tuner(struct file *file, void *priv,
                 return -EINVAL;
 
         strcpy(t->name, "Tuner");
-        t->type = V4L2_TUNER_ANALOG_TV;
 
         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
         return 0;
@@ -1545,7 +1241,9 @@ static int vidioc_g_frequency(struct file *file, void *priv,
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
 
-        f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
+        if (0 != f->tuner)
+                return -EINVAL;
+
         f->frequency = dev->ctl_freq;
         return 0;
 }
@@ -1564,13 +1262,9 @@ static int vidioc_s_frequency(struct file *file, void *priv,
         if (0 != f->tuner)
                 return -EINVAL;
 
-        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;
-
-        dev->ctl_freq = f->frequency;
         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, f);
+        v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, f);
+        dev->ctl_freq = f->frequency;
 
         return 0;
 }
@@ -1596,6 +1290,14 @@ static int vidioc_g_chip_ident(struct file *file, void *priv,
 
         chip->ident = V4L2_IDENT_NONE;
         chip->revision = 0;
+        if (chip->match.type == V4L2_CHIP_MATCH_HOST) {
+                if (v4l2_chip_match_host(&chip->match))
+                        chip->ident = V4L2_IDENT_NONE;
+                return 0;
+        }
+        if (chip->match.type != V4L2_CHIP_MATCH_I2C_DRIVER &&
+            chip->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+                return -EINVAL;
 
         v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
 
@@ -1704,72 +1406,10 @@ static int vidioc_cropcap(struct file *file, void *priv,
         return 0;
 }
 
-static int vidioc_streamon(struct file *file, void *priv,
-                                        enum v4l2_buf_type type)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc = -EINVAL;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (unlikely(type != fh->type))
-                return -EINVAL;
-
-        em28xx_videodbg("vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
-                        fh, type, fh->resources, dev->resources);
-
-        if (unlikely(!res_get(fh, get_ressource(fh))))
-                return -EBUSY;
-
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                rc = videobuf_streamon(&fh->vb_vidq);
-        else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
-                rc = videobuf_streamon(&fh->vb_vbiq);
-
-        return rc;
-}
-
-static int vidioc_streamoff(struct file *file, void *priv,
-                                        enum v4l2_buf_type type)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
-            fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
-                return -EINVAL;
-        if (type != fh->type)
-                return -EINVAL;
-
-        em28xx_videodbg("vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
-                        fh, type, fh->resources, dev->resources);
-
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                if (res_check(fh, EM28XX_RESOURCE_VIDEO)) {
-                        videobuf_streamoff(&fh->vb_vidq);
-                        res_free(fh, EM28XX_RESOURCE_VIDEO);
-                }
-        } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
-                if (res_check(fh, EM28XX_RESOURCE_VBI)) {
-                        videobuf_streamoff(&fh->vb_vbiq);
-                        res_free(fh, EM28XX_RESOURCE_VBI);
-                }
-        }
-
-        return 0;
-}
-
 static int vidioc_querycap(struct file *file, void  *priv,
                                         struct v4l2_capability *cap)
 {
+        struct video_device *vdev = video_devdata(file);
         struct em28xx_fh      *fh  = priv;
         struct em28xx         *dev = fh->dev;
 
@@ -1777,20 +1417,26 @@ static int vidioc_querycap(struct file *file, void  *priv,
         strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 
-        cap->capabilities =
-                        V4L2_CAP_SLICED_VBI_CAPTURE |
-                        V4L2_CAP_VIDEO_CAPTURE |
-                        V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
-
-        if (dev->vbi_dev)
-                cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
+        if (vdev->vfl_type == VFL_TYPE_GRABBER)
+                cap->device_caps = V4L2_CAP_READWRITE |
+                        V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        else if (vdev->vfl_type == VFL_TYPE_RADIO)
+                cap->device_caps = V4L2_CAP_RADIO;
+        else
+                cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
 
         if (dev->audio_mode.has_audio)
-                cap->capabilities |= V4L2_CAP_AUDIO;
+                cap->device_caps |= V4L2_CAP_AUDIO;
 
         if (dev->tuner_type != TUNER_ABSENT)
-                cap->capabilities |= V4L2_CAP_TUNER;
+                cap->device_caps |= V4L2_CAP_TUNER;
 
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
+                V4L2_CAP_READWRITE | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
+        if (dev->vbi_dev)
+                cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
+        if (dev->radio_dev)
+                cap->capabilities |= V4L2_CAP_RADIO;
         return 0;
 }
 
@@ -1845,46 +1491,6 @@ static int vidioc_enum_framesizes(struct file *file, void *priv,
         return 0;
 }
 
-/* Sliced VBI ioctls */
-static int vidioc_g_fmt_sliced_vbi_cap(struct file *file, void *priv,
-                                        struct v4l2_format *f)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        f->fmt.sliced.service_set = 0;
-        v4l2_device_call_all(&dev->v4l2_dev, 0, vbi, g_sliced_fmt, &f->fmt.sliced);
-
-        if (f->fmt.sliced.service_set == 0)
-                rc = -EINVAL;
-
-        return rc;
-}
-
-static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv,
-                        struct v4l2_format *f)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        v4l2_device_call_all(&dev->v4l2_dev, 0, vbi, g_sliced_fmt, &f->fmt.sliced);
-
-        if (f->fmt.sliced.service_set == 0)
-                return -EINVAL;
-
-        return 0;
-}
-
 /* RAW VBI ioctls */
 
 static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
@@ -1900,6 +1506,7 @@ static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
         format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
         format->fmt.vbi.count[0] = dev->vbi_height;
         format->fmt.vbi.count[1] = dev->vbi_height;
+        memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
 
         /* Varies by video standard (NTSC, PAL, etc.) */
         if (dev->norm & V4L2_STD_525_60) {
@@ -1928,6 +1535,7 @@ static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
         format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
         format->fmt.vbi.count[0] = dev->vbi_height;
         format->fmt.vbi.count[1] = dev->vbi_height;
+        memset(format->fmt.vbi.reserved, 0, sizeof(format->fmt.vbi.reserved));
 
         /* Varies by video standard (NTSC, PAL, etc.) */
         if (dev->norm & V4L2_STD_525_60) {
@@ -1943,100 +1551,10 @@ static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
         return 0;
 }
 
-static int vidioc_reqbufs(struct file *file, void *priv,
-                          struct v4l2_requestbuffers *rb)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return videobuf_reqbufs(&fh->vb_vidq, rb);
-        else
-                return videobuf_reqbufs(&fh->vb_vbiq, rb);
-}
-
-static int vidioc_querybuf(struct file *file, void *priv,
-                           struct v4l2_buffer *b)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return videobuf_querybuf(&fh->vb_vidq, b);
-        else {
-                /* FIXME: I'm not sure yet whether this is a bug in zvbi or
-                   the videobuf framework, but we probably shouldn't be
-                   returning a buffer larger than that which was asked for.
-                   At a minimum, it causes a crash in zvbi since it does
-                   a memcpy based on the source buffer length */
-                int result = videobuf_querybuf(&fh->vb_vbiq, b);
-                b->length = dev->vbi_width * dev->vbi_height * 2;
-
-                return result;
-        }
-}
-
-static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return videobuf_qbuf(&fh->vb_vidq, b);
-        else
-                return videobuf_qbuf(&fh->vb_vbiq, b);
-}
-
-static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
-{
-        struct em28xx_fh      *fh  = priv;
-        struct em28xx         *dev = fh->dev;
-        int                   rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags &
-                                      O_NONBLOCK);
-        else
-                return videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags &
-                                      O_NONBLOCK);
-}
-
 /* ----------------------------------------------------------- */
 /* RADIO ESPECIFIC IOCTLS                                      */
 /* ----------------------------------------------------------- */
 
-static int radio_querycap(struct file *file, void  *priv,
-                          struct v4l2_capability *cap)
-{
-        struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
-
-        strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
-        strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
-        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
-
-        cap->capabilities = V4L2_CAP_TUNER;
-        return 0;
-}
-
 static int radio_g_tuner(struct file *file, void *priv,
                          struct v4l2_tuner *t)
 {
@@ -2053,26 +1571,6 @@ static int radio_g_tuner(struct file *file, void *priv,
         return 0;
 }
 
-static int radio_enum_input(struct file *file, void *priv,
-                            struct v4l2_input *i)
-{
-        if (i->index != 0)
-                return -EINVAL;
-        strcpy(i->name, "Radio");
-        i->type = V4L2_INPUT_TYPE_TUNER;
-
-        return 0;
-}
-
-static int radio_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
-{
-        if (unlikely(a->index))
-                return -EINVAL;
-
-        strcpy(a->name, "Radio");
-        return 0;
-}
-
 static int radio_s_tuner(struct file *file, void *priv,
                          struct v4l2_tuner *t)
 {
@@ -2086,48 +1584,16 @@ static int radio_s_tuner(struct file *file, void *priv,
         return 0;
 }
 
-static int radio_s_audio(struct file *file, void *fh,
-                         const struct v4l2_audio *a)
-{
-        return 0;
-}
-
-static int radio_s_input(struct file *file, void *fh, unsigned int i)
-{
-        return 0;
-}
-
-static int radio_queryctrl(struct file *file, void *priv,
-                           struct v4l2_queryctrl *qc)
-{
-        int i;
-
-        if (qc->id <  V4L2_CID_BASE ||
-                qc->id >= V4L2_CID_LASTP1)
-                return -EINVAL;
-
-        for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) {
-                if (qc->id && qc->id == ac97_qctrl[i].id) {
-                        memcpy(qc, &(ac97_qctrl[i]), sizeof(*qc));
-                        return 0;
-                }
-        }
-
-        return -EINVAL;
-}
-
 /*
  * em28xx_v4l2_open()
  * inits the device and starts isoc transfer
  */
 static int em28xx_v4l2_open(struct file *filp)
 {
-        int errCode = 0, radio = 0;
         struct video_device *vdev = video_devdata(filp);
         struct em28xx *dev = video_drvdata(filp);
         enum v4l2_buf_type fh_type = 0;
         struct em28xx_fh *fh;
-        enum v4l2_field field;
 
         switch (vdev->vfl_type) {
         case VFL_TYPE_GRABBER:
@@ -2136,9 +1602,6 @@ static int em28xx_v4l2_open(struct file *filp)
         case VFL_TYPE_VBI:
                 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
                 break;
-        case VFL_TYPE_RADIO:
-                radio = 1;
-                break;
         }
 
         em28xx_videodbg("open dev=%s type=%s users=%d\n",
@@ -2154,14 +1617,13 @@ static int em28xx_v4l2_open(struct file *filp)
                 mutex_unlock(&dev->lock);
                 return -ENOMEM;
         }
+        v4l2_fh_init(&fh->fh, vdev);
         fh->dev = dev;
-        fh->radio = radio;
         fh->type = fh_type;
         filp->private_data = fh;
 
         if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
                 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
-                em28xx_set_alternate(dev);
                 em28xx_resolution_set(dev);
 
                 /* Needed, since GPIO might have disabled power of
@@ -2170,31 +1632,18 @@ static int em28xx_v4l2_open(struct file *filp)
                 em28xx_wake_i2c(dev);
 
         }
-        if (fh->radio) {
+
+        if (vdev->vfl_type == VFL_TYPE_RADIO) {
                 em28xx_videodbg("video_open: setting radio device\n");
                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio);
         }
 
         dev->users++;
 
-        if (dev->progressive)
-                field = V4L2_FIELD_NONE;
-        else
-                field = V4L2_FIELD_INTERLACED;
-
-        videobuf_queue_vmalloc_init(&fh->vb_vidq, &em28xx_video_qops,
-                                    NULL, &dev->slock,
-                                    V4L2_BUF_TYPE_VIDEO_CAPTURE, field,
-                                    sizeof(struct em28xx_buffer), fh, &dev->lock);
-
-        videobuf_queue_vmalloc_init(&fh->vb_vbiq, &em28xx_vbi_qops,
-                                    NULL, &dev->slock,
-                                    V4L2_BUF_TYPE_VBI_CAPTURE,
-                                    V4L2_FIELD_SEQ_TB,
-                                    sizeof(struct em28xx_buffer), fh, &dev->lock);
         mutex_unlock(&dev->lock);
+        v4l2_fh_add(&fh->fh);
 
-        return errCode;
+        return 0;
 }
 
 /*
@@ -2248,25 +1697,16 @@ static int em28xx_v4l2_close(struct file *filp)
         em28xx_videodbg("users=%d\n", dev->users);
 
         mutex_lock(&dev->lock);
-        if (res_check(fh, EM28XX_RESOURCE_VIDEO)) {
-                videobuf_stop(&fh->vb_vidq);
-                res_free(fh, EM28XX_RESOURCE_VIDEO);
-        }
-
-        if (res_check(fh, EM28XX_RESOURCE_VBI)) {
-                videobuf_stop(&fh->vb_vbiq);
-                res_free(fh, EM28XX_RESOURCE_VBI);
-        }
+        vb2_fop_release(filp);
 
         if (dev->users == 1) {
                 /* the device is already disconnect,
                    free the remaining resources */
-                if (dev->state & DEV_DISCONNECTED) {
+                if (dev->disconnected) {
                         em28xx_release_resources(dev);
-                        kfree(dev->alt_max_pkt_size);
+                        kfree(dev->alt_max_pkt_size_isoc);
                         mutex_unlock(&dev->lock);
                         kfree(dev);
-                        kfree(fh);
                         return 0;
                 }
 
@@ -2274,7 +1714,6 @@ static int em28xx_v4l2_close(struct file *filp)
                 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
 
                 /* do this before setting alternate! */
-                em28xx_uninit_isoc(dev, EM28XX_ANALOG_MODE);
                 em28xx_set_mode(dev, EM28XX_SUSPEND);
 
                 /* set alternate 0 */
@@ -2287,129 +1726,18 @@ static int em28xx_v4l2_close(struct file *filp)
                 }
         }
 
-        videobuf_mmap_free(&fh->vb_vidq);
-        videobuf_mmap_free(&fh->vb_vbiq);
-        kfree(fh);
         dev->users--;
         mutex_unlock(&dev->lock);
         return 0;
 }
 
-/*
- * em28xx_v4l2_read()
- * will allocate buffers when called for the first time
- */
-static ssize_t
-em28xx_v4l2_read(struct file *filp, char __user *buf, size_t count,
-                 loff_t *pos)
-{
-        struct em28xx_fh *fh = filp->private_data;
-        struct em28xx *dev = fh->dev;
-        int rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (mutex_lock_interruptible(&dev->lock))
-                return -ERESTARTSYS;
-        /* FIXME: read() is not prepared to allow changing the video
-           resolution while streaming. Seems a bug at em28xx_set_fmt
-         */
-
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                if (res_locked(dev, EM28XX_RESOURCE_VIDEO))
-                        rc = -EBUSY;
-                else
-                        rc = videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
-                                        filp->f_flags & O_NONBLOCK);
-        } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
-                if (!res_get(fh, EM28XX_RESOURCE_VBI))
-                        rc = -EBUSY;
-                else
-                        rc = videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
-                                        filp->f_flags & O_NONBLOCK);
-        }
-        mutex_unlock(&dev->lock);
-
-        return rc;
-}
-
-/*
- * em28xx_poll()
- * will allocate buffers when called for the first time
- */
-static unsigned int em28xx_poll(struct file *filp, poll_table *wait)
-{
-        struct em28xx_fh *fh = filp->private_data;
-        struct em28xx *dev = fh->dev;
-        int rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
-                if (!res_get(fh, EM28XX_RESOURCE_VIDEO))
-                        return POLLERR;
-                return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
-        } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
-                if (!res_get(fh, EM28XX_RESOURCE_VBI))
-                        return POLLERR;
-                return videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
-        } else {
-                return POLLERR;
-        }
-}
-
-static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table *wait)
-{
-        struct em28xx_fh *fh = filp->private_data;
-        struct em28xx *dev = fh->dev;
-        unsigned int res;
-
-        mutex_lock(&dev->lock);
-        res = em28xx_poll(filp, wait);
-        mutex_unlock(&dev->lock);
-        return res;
-}
-
-/*
- * em28xx_v4l2_mmap()
- */
-static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
-{
-        struct em28xx_fh *fh    = filp->private_data;
-        struct em28xx    *dev   = fh->dev;
-        int              rc;
-
-        rc = check_dev(dev);
-        if (rc < 0)
-                return rc;
-
-        if (mutex_lock_interruptible(&dev->lock))
-                return -ERESTARTSYS;
-        if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
-                rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
-        else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
-                rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma);
-        mutex_unlock(&dev->lock);
-
-        em28xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n",
-                (unsigned long)vma->vm_start,
-                (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
-                rc);
-
-        return rc;
-}
-
 static const struct v4l2_file_operations em28xx_v4l_fops = {
         .owner         = THIS_MODULE,
         .open          = em28xx_v4l2_open,
         .release       = em28xx_v4l2_close,
-        .read          = em28xx_v4l2_read,
-        .poll          = em28xx_v4l2_poll,
-        .mmap          = em28xx_v4l2_mmap,
+        .read          = vb2_fop_read,
+        .poll          = vb2_fop_poll,
+        .mmap          = vb2_fop_mmap,
         .unlocked_ioctl = video_ioctl2,
 };
 
@@ -2420,19 +1748,20 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
         .vidioc_try_fmt_vid_cap     = vidioc_try_fmt_vid_cap,
         .vidioc_s_fmt_vid_cap       = vidioc_s_fmt_vid_cap,
         .vidioc_g_fmt_vbi_cap       = vidioc_g_fmt_vbi_cap,
+        .vidioc_try_fmt_vbi_cap     = vidioc_g_fmt_vbi_cap,
         .vidioc_s_fmt_vbi_cap       = vidioc_s_fmt_vbi_cap,
         .vidioc_enum_framesizes     = vidioc_enum_framesizes,
         .vidioc_g_audio             = vidioc_g_audio,
         .vidioc_s_audio             = vidioc_s_audio,
         .vidioc_cropcap             = vidioc_cropcap,
-        .vidioc_g_fmt_sliced_vbi_cap   = vidioc_g_fmt_sliced_vbi_cap,
-        .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
-        .vidioc_s_fmt_sliced_vbi_cap   = vidioc_try_set_sliced_vbi_cap,
-
-        .vidioc_reqbufs             = vidioc_reqbufs,
-        .vidioc_querybuf            = vidioc_querybuf,
-        .vidioc_qbuf                = vidioc_qbuf,
-        .vidioc_dqbuf               = vidioc_dqbuf,
+
+        .vidioc_reqbufs             = vb2_ioctl_reqbufs,
+        .vidioc_create_bufs         = vb2_ioctl_create_bufs,
+        .vidioc_prepare_buf         = vb2_ioctl_prepare_buf,
+        .vidioc_querybuf            = vb2_ioctl_querybuf,
+        .vidioc_qbuf                = vb2_ioctl_qbuf,
+        .vidioc_dqbuf               = vb2_ioctl_dqbuf,
+
         .vidioc_g_std               = vidioc_g_std,
         .vidioc_querystd            = vidioc_querystd,
         .vidioc_s_std               = vidioc_s_std,
@@ -2441,15 +1770,14 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
         .vidioc_enum_input          = vidioc_enum_input,
         .vidioc_g_input             = vidioc_g_input,
         .vidioc_s_input             = vidioc_s_input,
-        .vidioc_queryctrl           = vidioc_queryctrl,
-        .vidioc_g_ctrl              = vidioc_g_ctrl,
-        .vidioc_s_ctrl              = vidioc_s_ctrl,
-        .vidioc_streamon            = vidioc_streamon,
-        .vidioc_streamoff           = vidioc_streamoff,
+        .vidioc_streamon            = vb2_ioctl_streamon,
+        .vidioc_streamoff           = vb2_ioctl_streamoff,
         .vidioc_g_tuner             = vidioc_g_tuner,
         .vidioc_s_tuner             = vidioc_s_tuner,
         .vidioc_g_frequency         = vidioc_g_frequency,
         .vidioc_s_frequency         = vidioc_s_frequency,
+        .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         .vidioc_g_register          = vidioc_g_register,
         .vidioc_s_register          = vidioc_s_register,
@@ -2459,11 +1787,10 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
 
 static const struct video_device em28xx_video_template = {
         .fops                       = &em28xx_v4l_fops,
-        .release                    = video_device_release,
+        .release                    = video_device_release_empty,
         .ioctl_ops                  = &video_ioctl_ops,
 
         .tvnorms                    = V4L2_STD_ALL,
-        .current_norm               = V4L2_STD_PAL,
 };
 
 static const struct v4l2_file_operations radio_fops = {
@@ -2474,18 +1801,13 @@ static const struct v4l2_file_operations radio_fops = {
 };
 
 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
-        .vidioc_querycap      = radio_querycap,
+        .vidioc_querycap      = vidioc_querycap,
         .vidioc_g_tuner       = radio_g_tuner,
-        .vidioc_enum_input    = radio_enum_input,
-        .vidioc_g_audio       = radio_g_audio,
         .vidioc_s_tuner       = radio_s_tuner,
-        .vidioc_s_audio       = radio_s_audio,
-        .vidioc_s_input       = radio_s_input,
-        .vidioc_queryctrl     = radio_queryctrl,
-        .vidioc_g_ctrl        = vidioc_g_ctrl,
-        .vidioc_s_ctrl        = vidioc_s_ctrl,
         .vidioc_g_frequency   = vidioc_g_frequency,
         .vidioc_s_frequency   = vidioc_s_frequency,
+        .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 #ifdef CONFIG_VIDEO_ADV_DEBUG
         .vidioc_g_register    = vidioc_g_register,
         .vidioc_s_register    = vidioc_s_register,
@@ -2514,9 +1836,11 @@ static struct video_device *em28xx_vdev_init(struct em28xx *dev,
 
         *vfd            = *template;
         vfd->v4l2_dev   = &dev->v4l2_dev;
-        vfd->release    = video_device_release;
         vfd->debug      = video_debug;
         vfd->lock       = &dev->lock;
+        set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
+        if (dev->board.is_webcam)
+                vfd->tvnorms = 0;
 
         snprintf(vfd->name, sizeof(vfd->name), "%s %s",
                  dev->name, type_name);
@@ -2527,7 +1851,7 @@ static struct video_device *em28xx_vdev_init(struct em28xx *dev,
 
 int em28xx_register_analog_devices(struct em28xx *dev)
 {
-      u8 val;
+        u8 val;
         int ret;
         unsigned int maxw;
 
@@ -2535,7 +1859,7 @@ int em28xx_register_analog_devices(struct em28xx *dev)
                 dev->name, EM28XX_VERSION);
 
         /* set default norm */
-        dev->norm = em28xx_video_template.current_norm;
+        dev->norm = V4L2_STD_PAL;
         v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
         dev->interlaced = EM28XX_INTERLACED_DEFAULT;
 
@@ -2543,10 +1867,10 @@ int em28xx_register_analog_devices(struct em28xx *dev)
         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;
+        /* 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,
                                 maxw, norm_maxh(dev));
@@ -2572,6 +1896,8 @@ int em28xx_register_analog_devices(struct em28xx *dev)
                 em28xx_errdev("cannot allocate video_device.\n");
                 return -ENODEV;
         }
+        dev->vdev->queue = &dev->vb_vidq;
+        dev->vdev->queue->lock = &dev->vb_queue_lock;
 
         /* register v4l2 video video_device */
         ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
@@ -2587,6 +1913,9 @@ int em28xx_register_analog_devices(struct em28xx *dev)
                 dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template,
                                                 "vbi");
 
+                dev->vbi_dev->queue = &dev->vb_vbiq;
+                dev->vbi_dev->queue->lock = &dev->vb_vbi_queue_lock;
+
                 /* register v4l2 vbi video_device */
                 ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
                                             vbi_nr[dev->devno]);
diff --git a/drivers/media/usb/em28xx/em28xx.h b/drivers/media/usb/em28xx/em28xx.h
index 86e90d86da6d..5f0b2c59e846 100644
--- a/drivers/media/usb/em28xx/em28xx.h
+++ b/drivers/media/usb/em28xx/em28xx.h
@@ -4,6 +4,7 @@
    Copyright (C) 2005 Markus Rechberger <mrechberger@gmail.com>
                       Ludovico Cavedon <cavedon@sssup.it>
                       Mauro Carvalho Chehab <mchehab@infradead.org>
+   Copyright (C) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
 
    Based on the em2800 driver from Sascha Sommer <saschasommer@freenet.de>
 
@@ -30,13 +31,12 @@
 #include <linux/mutex.h>
 #include <linux/videodev2.h>
 
-#include <media/videobuf-vmalloc.h>
+#include <media/videobuf2-vmalloc.h>
 #include <media/v4l2-device.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-fh.h>
 #include <media/ir-kbd-i2c.h>
 #include <media/rc-core.h>
-#if defined(CONFIG_VIDEO_EM28XX_DVB) || defined(CONFIG_VIDEO_EM28XX_DVB_MODULE)
-#include <media/videobuf-dvb.h>
-#endif
 #include "tuner-xc2028.h"
 #include "xc5000.h"
 #include "em28xx-reg.h"
@@ -157,12 +157,18 @@
 #define EM28XX_NUM_BUFS 5
 #define EM28XX_DVB_NUM_BUFS 5
 
-/* number of packets for each buffer
+/* isoc transfers: number of packets for each buffer
    windows requests only 64 packets .. so we better do the same
    this is what I found out for all alternate numbers there!
  */
-#define EM28XX_NUM_PACKETS 64
-#define EM28XX_DVB_MAX_PACKETS 64
+#define EM28XX_NUM_ISOC_PACKETS 64
+#define EM28XX_DVB_NUM_ISOC_PACKETS 64
+
+/* bulk transfers: transfer buffer size = packet size * packet multiplier
+   USB 2.0 spec says bulk packet size is always 512 bytes
+ */
+#define EM28XX_BULK_PACKET_MULTIPLIER 384
+#define EM28XX_DVB_BULK_PACKET_MULTIPLIER 384
 
 #define EM28XX_INTERLACED_DEFAULT 1
 
@@ -187,12 +193,8 @@
                         Interval: 125us
 */
 
-/* time to wait when stopping the isoc transfer */
-#define EM28XX_URB_TIMEOUT \
-                        msecs_to_jiffies(EM28XX_NUM_BUFS * EM28XX_NUM_PACKETS)
-
 /* time in msecs to wait for i2c writes to finish */
-#define EM2800_I2C_WRITE_TIMEOUT 20
+#define EM2800_I2C_XFER_TIMEOUT         20
 
 enum em28xx_mode {
         EM28XX_SUSPEND,
@@ -203,7 +205,7 @@ enum em28xx_mode {
 
 struct em28xx;
 
-struct em28xx_usb_isoc_bufs {
+struct em28xx_usb_bufs {
                 /* max packet size of isoc transaction */
         int                             max_pkt_size;
 
@@ -213,26 +215,26 @@ struct em28xx_usb_isoc_bufs {
                 /* number of allocated urbs */
         int                             num_bufs;
 
-                /* urb for isoc transfers */
+                /* urb for isoc/bulk transfers */
         struct urb                      **urb;
 
-                /* transfer buffers for isoc transfer */
+                /* transfer buffers for isoc/bulk transfer */
         char                            **transfer_buffer;
 };
 
-struct em28xx_usb_isoc_ctl {
-                /* isoc transfer buffers for analog mode */
-        struct em28xx_usb_isoc_bufs     analog_bufs;
+struct em28xx_usb_ctl {
+                /* isoc/bulk transfer buffers for analog mode */
+        struct em28xx_usb_bufs          analog_bufs;
 
-                /* isoc transfer buffers for digital mode */
-        struct em28xx_usb_isoc_bufs     digital_bufs;
+                /* isoc/bulk transfer buffers for digital mode */
+        struct em28xx_usb_bufs          digital_bufs;
 
                 /* Stores already requested buffers */
         struct em28xx_buffer            *vid_buf;
         struct em28xx_buffer            *vbi_buf;
 
-                /* isoc urb callback */
-        int (*isoc_copy) (struct em28xx *dev, struct urb *urb);
+                /* copy data from URB */
+        int (*urb_data_copy) (struct em28xx *dev, struct urb *urb);
 
 };
 
@@ -247,19 +249,26 @@ struct em28xx_fmt {
 /* buffer for one video frame */
 struct em28xx_buffer {
         /* common v4l buffer stuff -- must be first */
-        struct videobuf_buffer vb;
+        struct vb2_buffer vb;
+        struct list_head list;
 
-        struct list_head frame;
+        void *mem;
+        unsigned int length;
         int top_field;
+
+        /* counter to control buffer fill */
+        unsigned int pos;
+        /* NOTE; in interlaced mode, this value is reset to zero at
+         * the start of each new field (not frame !)               */
+
+        /* pointer to vmalloc memory address in vb */
+        char *vb_buf;
 };
 
 struct em28xx_dmaqueue {
         struct list_head       active;
 
         wait_queue_head_t          wq;
-
-        /* Counters to control buffer fill */
-        int                        pos;
 };
 
 /* inputs */
@@ -430,13 +439,6 @@ struct em28xx_eeprom {
         u8 string_idx_table;
 };
 
-/* device states */
-enum em28xx_dev_state {
-        DEV_INITIALIZED = 0x01,
-        DEV_DISCONNECTED = 0x02,
-        DEV_MISCONFIGURED = 0x04,
-};
-
 #define EM28XX_AUDIO_BUFS 5
 #define EM28XX_NUM_AUDIO_PACKETS 64
 #define EM28XX_AUDIO_MAX_PACKET_SIZE 196 /* static value */
@@ -469,12 +471,8 @@ struct em28xx_audio {
 struct em28xx;
 
 struct em28xx_fh {
+        struct v4l2_fh fh;
         struct em28xx *dev;
-        int           radio;
-        unsigned int  resources;
-
-        struct videobuf_queue        vb_vidq;
-        struct videobuf_queue        vb_vbiq;
 
         enum v4l2_buf_type           type;
 };
@@ -487,9 +485,14 @@ struct em28xx {
         int devno;              /* marks the number of this device */
         enum em28xx_chip_id chip_id;
 
+        unsigned char disconnected:1;   /* device has been diconnected */
+
         int audio_ifnum;
 
         struct v4l2_device v4l2_dev;
+        struct v4l2_ctrl_handler ctrl_handler;
+        /* provides ac97 mute and volume overrides */
+        struct v4l2_ctrl_handler ac97_ctrl_handler;
         struct em28xx_board board;
 
         /* Webcam specific fields */
@@ -497,7 +500,7 @@ struct em28xx {
         int sensor_xres, sensor_yres;
         int sensor_xtal;
 
-        /* Allows progressive (e. g. non-interlaced) mode */
+        /* Progressive (non-interlaced) mode */
         int progressive;
 
         /* Vinmode/Vinctl used at the driver */
@@ -532,6 +535,7 @@ struct em28xx {
         struct i2c_client i2c_client;
         /* video for linux */
         int users;              /* user count for exclusive use */
+        int streaming_users;    /* Number of actively streaming users */
         struct video_device *vdev;      /* video for linux device struct */
         v4l2_std_id norm;       /* selected tv norm */
         int ctl_freq;           /* selected frequency */
@@ -554,13 +558,10 @@ struct em28xx {
 
         struct em28xx_audio adev;
 
-        /* states */
-        enum em28xx_dev_state state;
-
-        /* vbi related state tracking */
+        /* capture state tracking */
         int capture_type;
+        unsigned char top_field:1;
         int vbi_read;
-        unsigned char cur_field;
         unsigned int vbi_width;
         unsigned int vbi_height; /* lines per field */
 
@@ -574,6 +575,12 @@ struct em28xx {
         struct video_device *vbi_dev;
         struct video_device *radio_dev;
 
+        /* Videobuf2 */
+        struct vb2_queue vb_vidq;
+        struct vb2_queue vb_vbiq;
+        struct mutex vb_queue_lock;
+        struct mutex vb_vbi_queue_lock;
+
         /* resources in use */
         unsigned int resources;
 
@@ -582,17 +589,31 @@ struct em28xx {
         /* Isoc control struct */
         struct em28xx_dmaqueue vidq;
         struct em28xx_dmaqueue vbiq;
-        struct em28xx_usb_isoc_ctl isoc_ctl;
+        struct em28xx_usb_ctl usb_ctl;
         spinlock_t slock;
 
+        unsigned int field_count;
+        unsigned int vbi_field_count;
+
         /* usb transfer */
         struct usb_device *udev;        /* the usb device */
-        int alt;                /* alternate */
-        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 */
+        u8 analog_ep_isoc;      /* address of isoc endpoint for analog */
+        u8 analog_ep_bulk;      /* address of bulk endpoint for analog */
+        u8 dvb_ep_isoc;         /* address of isoc endpoint for DVB */
+        u8 dvb_ep_bulk;         /* address of bulk endpoint for DVC */
+        int alt;                /* alternate setting */
+        int max_pkt_size;       /* max packet size of the selected ep at alt */
+        int packet_multiplier;  /* multiplier for wMaxPacketSize, used for
+                                   URB buffer size definition */
+        int num_alt;            /* number of alternative settings */
+        unsigned int *alt_max_pkt_size_isoc; /* array of isoc wMaxPacketSize */
+        unsigned int analog_xfer_bulk:1;        /* use bulk instead of isoc
+                                                   transfers for analog      */
+        int dvb_alt_isoc;       /* alternate setting for DVB isoc transfers */
+        unsigned int dvb_max_pkt_size_isoc;     /* isoc max packet size of the
+                                                   selected DVB ep at dvb_alt */
+        unsigned int dvb_xfer_bulk:1;           /* use bulk instead of isoc
+                                                   transfers for DVB          */
         char urb_buf[URB_MAX_CTRL_SIZE];        /* urb control msg buffer */
 
         /* helper funcs that call usb_control_msg */
@@ -619,9 +640,6 @@ struct em28xx {
         struct delayed_work sbutton_query_work;
 
         struct em28xx_dvb *dvb;
-
-        /* I2C keyboard data */
-        struct IR_i2c_init_data init_data;
 };
 
 struct em28xx_ops {
@@ -666,12 +684,14 @@ int em28xx_vbi_supported(struct em28xx *dev);
 int em28xx_set_outfmt(struct em28xx *dev);
 int em28xx_resolution_set(struct em28xx *dev);
 int em28xx_set_alternate(struct em28xx *dev);
-int em28xx_alloc_isoc(struct em28xx *dev, enum em28xx_mode mode,
-                      int max_packets, int num_bufs, int max_pkt_size);
-int em28xx_init_isoc(struct em28xx *dev, enum em28xx_mode mode,
-                     int max_packets, int num_bufs, int max_pkt_size,
-                     int (*isoc_copy) (struct em28xx *dev, struct urb *urb));
-void em28xx_uninit_isoc(struct em28xx *dev, enum em28xx_mode mode);
+int em28xx_alloc_urbs(struct em28xx *dev, enum em28xx_mode mode, int xfer_bulk,
+                      int num_bufs, int max_pkt_size, int packet_multiplier);
+int em28xx_init_usb_xfer(struct em28xx *dev, enum em28xx_mode mode,
+                         int xfer_bulk,
+                         int num_bufs, int max_pkt_size, int packet_multiplier,
+                         int (*urb_data_copy)
+                                        (struct em28xx *dev, struct urb *urb));
+void em28xx_uninit_usb_xfer(struct em28xx *dev, enum em28xx_mode mode);
 void em28xx_stop_urbs(struct em28xx *dev);
 int em28xx_isoc_dvb_max_packetsize(struct em28xx *dev);
 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode);
@@ -683,8 +703,13 @@ void em28xx_init_extension(struct em28xx *dev);
 void em28xx_close_extension(struct em28xx *dev);
 
 /* Provided by em28xx-video.c */
+int em28xx_vb2_setup(struct em28xx *dev);
 int em28xx_register_analog_devices(struct em28xx *dev);
 void em28xx_release_analog_resources(struct em28xx *dev);
+void em28xx_ctrl_notify(struct v4l2_ctrl *ctrl, void *priv);
+int em28xx_start_analog_streaming(struct vb2_queue *vq, unsigned int count);
+int em28xx_stop_vbi_streaming(struct vb2_queue *vq);
+extern const struct v4l2_ctrl_ops em28xx_ctrl_ops;
 
 /* Provided by em28xx-cards.c */
 extern int em2800_variant_detect(struct usb_device *udev, int model);
@@ -695,7 +720,7 @@ int em28xx_tuner_callback(void *ptr, int component, int command, int arg);
 void em28xx_release_resources(struct em28xx *dev);
 
 /* Provided by em28xx-vbi.c */
-extern struct videobuf_queue_ops em28xx_vbi_qops;
+extern struct vb2_ops em28xx_vbi_qops;
 
 /* printk macros */
 
diff --git a/drivers/media/usb/gspca/cpia1.c b/drivers/media/usb/gspca/cpia1.c
index b3ba47d4d6a2..1dcdd9f95f1c 100644
--- a/drivers/media/usb/gspca/cpia1.c
+++ b/drivers/media/usb/gspca/cpia1.c
@@ -541,7 +541,7 @@ static int do_command(struct gspca_dev *gspca_dev, u16 command,
                 /* test button press */
                 a = ((gspca_dev->usb_buf[1] & 0x02) == 0);
                 if (a != sd->params.qx3.button) {
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, a);
                         input_sync(gspca_dev->input_dev);
 #endif
@@ -1640,7 +1640,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
         /* Update the camera status */
         do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         /* If the last button state is pressed, release it now! */
         if (sd->params.qx3.button) {
                 /* The camera latch will hold the pressed state until we reset
@@ -1869,7 +1869,7 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .dq_callback = sd_dq_callback,
         .pkt_scan = sd_pkt_scan,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .other_input = 1,
 #endif
 };
diff --git a/drivers/media/usb/gspca/gspca.c b/drivers/media/usb/gspca/gspca.c
index e0a431bb0d42..3564bdbb2ea3 100644
--- a/drivers/media/usb/gspca/gspca.c
+++ b/drivers/media/usb/gspca/gspca.c
@@ -44,7 +44,7 @@
 
 #include "gspca.h"
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 #include <linux/input.h>
 #include <linux/usb/input.h>
 #endif
@@ -118,7 +118,7 @@ static const struct vm_operations_struct gspca_vm_ops = {
 /*
  * Input and interrupt endpoint handling functions
  */
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static void int_irq(struct urb *urb)
 {
         struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
@@ -2303,7 +2303,7 @@ int gspca_dev_probe2(struct usb_interface *intf,
 
         return 0;
 out:
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         if (gspca_dev->input_dev)
                 input_unregister_device(gspca_dev->input_dev);
 #endif
@@ -2348,7 +2348,7 @@ EXPORT_SYMBOL(gspca_dev_probe);
 void gspca_disconnect(struct usb_interface *intf)
 {
         struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         struct input_dev *input_dev;
 #endif
 
@@ -2360,7 +2360,7 @@ void gspca_disconnect(struct usb_interface *intf)
         gspca_dev->present = 0;
         destroy_urbs(gspca_dev);
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         gspca_input_destroy_urb(gspca_dev);
         input_dev = gspca_dev->input_dev;
         if (input_dev) {
diff --git a/drivers/media/usb/gspca/gspca.h b/drivers/media/usb/gspca/gspca.h
index 352317d7acdb..5559932bf2f5 100644
--- a/drivers/media/usb/gspca/gspca.h
+++ b/drivers/media/usb/gspca/gspca.h
@@ -138,7 +138,7 @@ struct sd_desc {
         cam_reg_op get_register;
 #endif
         cam_ident_op get_chip_ident;
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         cam_int_pkt_op int_pkt_scan;
         /* other_input makes the gspca core create gspca_dev->input even when
            int_pkt_scan is NULL, for cams with non interrupt driven buttons */
@@ -167,7 +167,7 @@ struct gspca_dev {
         struct usb_device *dev;
         struct file *capt_file;         /* file doing video capture */
                                         /* protected by queue_lock */
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         struct input_dev *input_dev;
         char phys[64];                  /* physical device path */
 #endif
@@ -190,7 +190,7 @@ struct gspca_dev {
 #define USB_BUF_SZ 64
         __u8 *usb_buf;                          /* buffer for USB exchanges */
         struct urb *urb[MAX_NURBS];
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         struct urb *int_urb;
 #endif
 
diff --git a/drivers/media/usb/gspca/jl2005bcd.c b/drivers/media/usb/gspca/jl2005bcd.c
index 62ba80d9b998..fdaeeb14453f 100644
--- a/drivers/media/usb/gspca/jl2005bcd.c
+++ b/drivers/media/usb/gspca/jl2005bcd.c
@@ -536,20 +536,4 @@ static struct usb_driver sd_driver = {
 #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);
+module_usb_driver(sd_driver);
diff --git a/drivers/media/usb/gspca/konica.c b/drivers/media/usb/gspca/konica.c
index bbf91e07e38b..61e25dbf2447 100644
--- a/drivers/media/usb/gspca/konica.c
+++ b/drivers/media/usb/gspca/konica.c
@@ -246,7 +246,7 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
 
         konica_stream_off(gspca_dev);
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         /* Don't keep the button in the pressed state "forever" if it was
            pressed when streaming is stopped */
         if (sd->snapshot_pressed) {
@@ -345,7 +345,7 @@ static void sd_isoc_irq(struct urb *urb)
                         gspca_frame_add(gspca_dev, LAST_PACKET, NULL, 0);
                         gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
                 } else {
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
                         u8 button_state = st & 0x40 ? 1 : 0;
                         if (sd->snapshot_pressed != button_state) {
                                 input_report_key(gspca_dev->input_dev,
@@ -452,7 +452,7 @@ static const struct sd_desc sd_desc = {
         .init_controls = sd_init_controls,
         .start = sd_start,
         .stopN = sd_stopN,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .other_input = 1,
 #endif
 };
diff --git a/drivers/media/usb/gspca/ov519.c b/drivers/media/usb/gspca/ov519.c
index 9aa09f845ce4..9ad19a7ef81b 100644
--- a/drivers/media/usb/gspca/ov519.c
+++ b/drivers/media/usb/gspca/ov519.c
@@ -4238,7 +4238,7 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
         if (sd->bridge == BRIDGE_W9968CF)
                 w9968cf_stop0(sd);
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         /* If the last button state is pressed, release it now! */
         if (sd->snapshot_pressed) {
                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
@@ -4255,7 +4255,7 @@ static void ov51x_handle_button(struct gspca_dev *gspca_dev, u8 state)
         struct sd *sd = (struct sd *) gspca_dev;
 
         if (sd->snapshot_pressed != state) {
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, state);
                 input_sync(gspca_dev->input_dev);
 #endif
@@ -4924,7 +4924,7 @@ static const struct sd_desc sd_desc = {
         .dq_callback = sd_reset_snapshot,
         .get_jcomp = sd_get_jcomp,
         .set_jcomp = sd_set_jcomp,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .other_input = 1,
 #endif
 };
diff --git a/drivers/media/usb/gspca/pac207.c b/drivers/media/usb/gspca/pac207.c
index d236d1791f78..3b75097dd34e 100644
--- a/drivers/media/usb/gspca/pac207.c
+++ b/drivers/media/usb/gspca/pac207.c
@@ -55,6 +55,11 @@ MODULE_LICENSE("GPL");
 
 #define PAC207_AUTOGAIN_DEADZONE        30
 
+/* global parameters */
+static int led_invert;
+module_param(led_invert, int, 0644);
+MODULE_PARM_DESC(led_invert, "Invert led");
+
 /* specific webcam descriptor */
 struct sd {
         struct gspca_dev gspca_dev;             /* !! must be the first item */
@@ -187,10 +192,14 @@ static int sd_config(struct gspca_dev *gspca_dev,
 /* this function is called at probe and resume time */
 static int sd_init(struct gspca_dev *gspca_dev)
 {
-        pac207_write_reg(gspca_dev, 0x41, 0x00);
-                                /* Bit_0=Image Format,
-                                 * Bit_1=LED,
-                                 * Bit_2=Compression test mode enable */
+        u8 mode;
+
+        /* mode: Image Format (Bit 0), LED (1), Compr. test mode (2) */
+        if (led_invert)
+                mode = 0x02;
+        else
+                mode = 0x00;
+        pac207_write_reg(gspca_dev, 0x41, mode);
         pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
 
         return gspca_dev->usb_err;
@@ -303,7 +312,11 @@ static int sd_start(struct gspca_dev *gspca_dev)
         pac207_write_reg(gspca_dev, 0x02,
                 v4l2_ctrl_g_ctrl(gspca_dev->exposure)); /* PXCK = 12MHz /n */
 
-        mode = 0x02; /* Image Format (Bit 0), LED (1), Compr. test mode (2) */
+        /* mode: Image Format (Bit 0), LED (1), Compr. test mode (2) */
+        if (led_invert)
+                mode = 0x00;
+        else
+                mode = 0x02;
         if (gspca_dev->width == 176) {  /* 176x144 */
                 mode |= 0x01;
                 PDEBUG(D_STREAM, "pac207_start mode 176x144");
@@ -325,8 +338,15 @@ static int sd_start(struct gspca_dev *gspca_dev)
 
 static void sd_stopN(struct gspca_dev *gspca_dev)
 {
+        u8 mode;
+
+        /* mode: Image Format (Bit 0), LED (1), Compr. test mode (2) */
+        if (led_invert)
+                mode = 0x02;
+        else
+                mode = 0x00;
         pac207_write_reg(gspca_dev, 0x40, 0x00); /* Stop ISO pipe */
-        pac207_write_reg(gspca_dev, 0x41, 0x00); /* Turn of LED */
+        pac207_write_reg(gspca_dev, 0x41, mode); /* Turn off LED */
         pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
 }
 
@@ -393,7 +413,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrput packet length */
@@ -422,7 +442,7 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .dq_callback = pac207_do_auto_gain,
         .pkt_scan = sd_pkt_scan,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
diff --git a/drivers/media/usb/gspca/pac7302.c b/drivers/media/usb/gspca/pac7302.c
index 4f5869a98082..add6f725ba50 100644
--- a/drivers/media/usb/gspca/pac7302.c
+++ b/drivers/media/usb/gspca/pac7302.c
@@ -890,7 +890,7 @@ static int sd_chip_ident(struct gspca_dev *gspca_dev,
 }
 #endif
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrput packet length */
@@ -936,7 +936,7 @@ static const struct sd_desc sd_desc = {
         .set_register = sd_dbg_s_register,
         .get_chip_ident = sd_chip_ident,
 #endif
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
diff --git a/drivers/media/usb/gspca/pac7311.c b/drivers/media/usb/gspca/pac7311.c
index ba3558d3f017..a12dfbf6e051 100644
--- a/drivers/media/usb/gspca/pac7311.c
+++ b/drivers/media/usb/gspca/pac7311.c
@@ -621,7 +621,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrupt packet length */
@@ -661,7 +661,7 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
         .dq_callback = do_autogain,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
diff --git a/drivers/media/usb/gspca/se401.c b/drivers/media/usb/gspca/se401.c
index a33cb78a839c..5f729b8aa2bd 100644
--- a/drivers/media/usb/gspca/se401.c
+++ b/drivers/media/usb/gspca/se401.c
@@ -594,7 +594,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev, u8 *data, int len)
                 sd_pkt_scan_janggu(gspca_dev, data, len);
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev, u8 *data, int len)
 {
         struct sd *sd = (struct sd *)gspca_dev;
@@ -688,7 +688,7 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .dq_callback = sd_dq_callback,
         .pkt_scan = sd_pkt_scan,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
diff --git a/drivers/media/usb/gspca/sn9c20x.c b/drivers/media/usb/gspca/sn9c20x.c
index 41f769fe340c..4ec544f4a845 100644
--- a/drivers/media/usb/gspca/sn9c20x.c
+++ b/drivers/media/usb/gspca/sn9c20x.c
@@ -2205,7 +2205,7 @@ static void qual_upd(struct work_struct *work)
         mutex_unlock(&gspca_dev->usb_lock);
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet */
                         int len)                /* interrupt packet length */
@@ -2349,7 +2349,7 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .stop0 = sd_stop0,
         .pkt_scan = sd_pkt_scan,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
         .dq_callback = sd_dqcallback,
diff --git a/drivers/media/usb/gspca/sonixb.c b/drivers/media/usb/gspca/sonixb.c
index 1220340e7602..104ae25275b4 100644
--- a/drivers/media/usb/gspca/sonixb.c
+++ b/drivers/media/usb/gspca/sonixb.c
@@ -1400,7 +1400,7 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
         return -EINVAL;
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrupt packet length */
@@ -1430,7 +1430,7 @@ static const struct sd_desc sd_desc = {
         .pkt_scan = sd_pkt_scan,
         .querymenu = sd_querymenu,
         .dq_callback = do_autogain,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
@@ -1448,7 +1448,7 @@ static const struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0c45, 0x600d), SB(PAS106, 101)},
         {USB_DEVICE(0x0c45, 0x6011), SB(OV6650, 101)},
         {USB_DEVICE(0x0c45, 0x6019), SB(OV7630, 101)},
-#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
+#if !IS_ENABLED(CONFIG_USB_SN9C102)
         {USB_DEVICE(0x0c45, 0x6024), SB(TAS5130CXX, 102)},
         {USB_DEVICE(0x0c45, 0x6025), SB(TAS5130CXX, 102)},
 #endif
diff --git a/drivers/media/usb/gspca/sonixj.c b/drivers/media/usb/gspca/sonixj.c
index 36307a9028a9..671d0c6dece3 100644
--- a/drivers/media/usb/gspca/sonixj.c
+++ b/drivers/media/usb/gspca/sonixj.c
@@ -3077,7 +3077,7 @@ static int sd_querymenu(struct gspca_dev *gspca_dev,
         return -EINVAL;
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrupt packet length */
@@ -3109,7 +3109,7 @@ static const struct sd_desc sd_desc = {
         .pkt_scan = sd_pkt_scan,
         .dq_callback = do_autogain,
         .querymenu = sd_querymenu,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
diff --git a/drivers/media/usb/gspca/spca561.c b/drivers/media/usb/gspca/spca561.c
index cfe71dd6747d..d1db3d8f6522 100644
--- a/drivers/media/usb/gspca/spca561.c
+++ b/drivers/media/usb/gspca/spca561.c
@@ -741,7 +741,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                         return;
                 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
                 if (data[0] & 0x20) {
                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
                         input_sync(gspca_dev->input_dev);
@@ -866,7 +866,7 @@ static const struct sd_desc sd_desc_12a = {
         .start = sd_start_12a,
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .other_input = 1,
 #endif
 };
@@ -879,7 +879,7 @@ static const struct sd_desc sd_desc_72a = {
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
         .dq_callback = do_autogain,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .other_input = 1,
 #endif
 };
diff --git a/drivers/media/usb/gspca/stv06xx/stv06xx.c b/drivers/media/usb/gspca/stv06xx/stv06xx.c
index 999ec7764449..657160b4a1f7 100644
--- a/drivers/media/usb/gspca/stv06xx/stv06xx.c
+++ b/drivers/media/usb/gspca/stv06xx/stv06xx.c
@@ -492,7 +492,7 @@ frame_data:
         }
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrupt packet length */
@@ -529,7 +529,7 @@ static const struct sd_desc sd_desc = {
         .pkt_scan = stv06xx_pkt_scan,
         .isoc_init = stv06xx_isoc_init,
         .isoc_nego = stv06xx_isoc_nego,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
diff --git a/drivers/media/usb/gspca/stv06xx/stv06xx_vv6410.c b/drivers/media/usb/gspca/stv06xx/stv06xx_vv6410.c
index 748e1421d6d8..e95fa8997d22 100644
--- a/drivers/media/usb/gspca/stv06xx/stv06xx_vv6410.c
+++ b/drivers/media/usb/gspca/stv06xx/stv06xx_vv6410.c
@@ -52,9 +52,13 @@ static int vv6410_s_ctrl(struct v4l2_ctrl *ctrl)
 
         switch (ctrl->id) {
         case V4L2_CID_HFLIP:
+                if (!gspca_dev->streaming)
+                        return 0;
                 err = vv6410_set_hflip(gspca_dev, ctrl->val);
                 break;
         case V4L2_CID_VFLIP:
+                if (!gspca_dev->streaming)
+                        return 0;
                 err = vv6410_set_vflip(gspca_dev, ctrl->val);
                 break;
         case V4L2_CID_GAIN:
@@ -94,11 +98,14 @@ static int vv6410_init_controls(struct sd *sd)
 {
         struct v4l2_ctrl_handler *hdl = &sd->gspca_dev.ctrl_handler;
 
-        v4l2_ctrl_handler_init(hdl, 4);
-        v4l2_ctrl_new_std(hdl, &vv6410_ctrl_ops,
-                        V4L2_CID_HFLIP, 0, 1, 1, 0);
-        v4l2_ctrl_new_std(hdl, &vv6410_ctrl_ops,
-                        V4L2_CID_VFLIP, 0, 1, 1, 0);
+        v4l2_ctrl_handler_init(hdl, 2);
+        /* Disable the hardware VFLIP and HFLIP as we currently lack a
+           mechanism to adjust the image offset in such a way that
+           we don't need to renegotiate the announced format */
+        /* v4l2_ctrl_new_std(hdl, &vv6410_ctrl_ops, */
+        /*              V4L2_CID_HFLIP, 0, 1, 1, 0); */
+        /* v4l2_ctrl_new_std(hdl, &vv6410_ctrl_ops, */
+        /*              V4L2_CID_VFLIP, 0, 1, 1, 0); */
         v4l2_ctrl_new_std(hdl, &vv6410_ctrl_ops,
                         V4L2_CID_EXPOSURE, 0, 32768, 1, 20000);
         v4l2_ctrl_new_std(hdl, &vv6410_ctrl_ops,
diff --git a/drivers/media/usb/gspca/t613.c b/drivers/media/usb/gspca/t613.c
index 8bc6c3ceec2c..e2cc4e5a0ccb 100644
--- a/drivers/media/usb/gspca/t613.c
+++ b/drivers/media/usb/gspca/t613.c
@@ -494,7 +494,7 @@ static void setcolors(struct gspca_dev *gspca_dev, s32 val)
 
 static void setgamma(struct gspca_dev *gspca_dev, s32 val)
 {
-        PDEBUG(D_CONF, "Gamma: %d", sd->gamma);
+        PDEBUG(D_CONF, "Gamma: %d", val);
         reg_w_ixbuf(gspca_dev, 0x90,
                 gamma_table[val], sizeof gamma_table[0]);
 }
@@ -823,7 +823,7 @@ 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 IS_ENABLED(CONFIG_INPUT)
         /* If the last button state is pressed, release it now! */
         if (sd->button_pressed) {
                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
@@ -841,7 +841,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         int pkt_type;
 
         if (data[0] == 0x5a) {
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
                 if (len > 20) {
                         u8 state = (data[20] & 0x80) ? 1 : 0;
                         if (sd->button_pressed != state) {
@@ -1019,7 +1019,7 @@ static const struct sd_desc sd_desc = {
         .start = sd_start,
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .other_input = 1,
 #endif
 };
diff --git a/drivers/media/usb/gspca/xirlink_cit.c b/drivers/media/usb/gspca/xirlink_cit.c
index d4b23c9bf90c..7eaf64eb867c 100644
--- a/drivers/media/usb/gspca/xirlink_cit.c
+++ b/drivers/media/usb/gspca/xirlink_cit.c
@@ -2759,7 +2759,7 @@ static void sd_stop0(struct gspca_dev *gspca_dev)
                 break;
         }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         /* If the last button state is pressed, release it now! */
         if (sd->button_state) {
                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
@@ -2914,7 +2914,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static void cit_check_button(struct gspca_dev *gspca_dev)
 {
         int new_button_state;
@@ -3062,7 +3062,7 @@ static const struct sd_desc sd_desc = {
         .stopN = sd_stopN,
         .stop0 = sd_stop0,
         .pkt_scan = sd_pkt_scan,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .dq_callback = cit_check_button,
         .other_input = 1,
 #endif
@@ -3079,7 +3079,7 @@ static const struct sd_desc sd_desc_isoc_nego = {
         .stopN = sd_stopN,
         .stop0 = sd_stop0,
         .pkt_scan = sd_pkt_scan,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .dq_callback = cit_check_button,
         .other_input = 1,
 #endif
diff --git a/drivers/media/usb/gspca/zc3xx.c b/drivers/media/usb/gspca/zc3xx.c
index 77c57755e7b4..a8dc421f9f1f 100644
--- a/drivers/media/usb/gspca/zc3xx.c
+++ b/drivers/media/usb/gspca/zc3xx.c
@@ -6902,7 +6902,7 @@ static int sd_get_jcomp(struct gspca_dev *gspca_dev,
         return 0;
 }
 
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
                         u8 *data,               /* interrupt packet data */
                         int len)                /* interrput packet length */
@@ -6929,7 +6929,7 @@ static const struct sd_desc sd_desc = {
         .pkt_scan = sd_pkt_scan,
         .get_jcomp = sd_get_jcomp,
         .set_jcomp = sd_set_jcomp,
-#if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
+#if IS_ENABLED(CONFIG_INPUT)
         .int_pkt_scan = sd_int_pkt_scan,
 #endif
 };
diff --git a/drivers/media/usb/hdpvr/hdpvr-core.c b/drivers/media/usb/hdpvr/hdpvr-core.c
index 84dc26fe80ee..5c6193536399 100644
--- a/drivers/media/usb/hdpvr/hdpvr-core.c
+++ b/drivers/media/usb/hdpvr/hdpvr-core.c
@@ -391,7 +391,7 @@ static int hdpvr_probe(struct usb_interface *interface,
                 goto error;
         }
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         retval = hdpvr_register_i2c_adapter(dev);
         if (retval < 0) {
                 v4l2_err(&dev->v4l2_dev, "i2c adapter register failed\n");
@@ -419,7 +419,7 @@ static int hdpvr_probe(struct usb_interface *interface,
         return 0;
 
 reg_fail:
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_adapter(&dev->i2c_adapter);
 #endif
 error:
@@ -451,7 +451,7 @@ static void hdpvr_disconnect(struct usb_interface *interface)
         mutex_lock(&dev->io_mutex);
         hdpvr_cancel_queue(dev);
         mutex_unlock(&dev->io_mutex);
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
         i2c_del_adapter(&dev->i2c_adapter);
 #endif
         video_unregister_device(dev->video_dev);
diff --git a/drivers/media/usb/hdpvr/hdpvr-i2c.c b/drivers/media/usb/hdpvr/hdpvr-i2c.c
index 031cf024304c..a38f58c4c6bf 100644
--- a/drivers/media/usb/hdpvr/hdpvr-i2c.c
+++ b/drivers/media/usb/hdpvr/hdpvr-i2c.c
@@ -13,7 +13,7 @@
  *
  */
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 
 #include <linux/i2c.h>
 #include <linux/slab.h>
@@ -217,8 +217,7 @@ int hdpvr_register_i2c_adapter(struct hdpvr_device *dev)
 
         hdpvr_activate_ir(dev);
 
-        memcpy(&dev->i2c_adapter, &hdpvr_i2c_adapter_template,
-               sizeof(struct i2c_adapter));
+        dev->i2c_adapter = hdpvr_i2c_adapter_template;
         dev->i2c_adapter.dev.parent = &dev->udev->dev;
 
         i2c_set_adapdata(&dev->i2c_adapter, dev);
diff --git a/drivers/media/usb/pvrusb2/pvrusb2-encoder.c b/drivers/media/usb/pvrusb2/pvrusb2-encoder.c
index e046fdaec5ae..f7702aeeda3f 100644
--- a/drivers/media/usb/pvrusb2/pvrusb2-encoder.c
+++ b/drivers/media/usb/pvrusb2/pvrusb2-encoder.c
@@ -422,8 +422,7 @@ int pvr2_encoder_adjust(struct pvr2_hdw *hdw)
                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
                            "Error from cx2341x module code=%d",ret);
         } else {
-                memcpy(&hdw->enc_cur_state,&hdw->enc_ctl_state,
-                       sizeof(struct cx2341x_mpeg_params));
+                hdw->enc_cur_state = hdw->enc_ctl_state;
                 hdw->enc_cur_valid = !0;
         }
         return ret;
diff --git a/drivers/media/usb/pvrusb2/pvrusb2-i2c-core.c b/drivers/media/usb/pvrusb2/pvrusb2-i2c-core.c
index 9ab596c78a4e..b5e929f1bf82 100644
--- a/drivers/media/usb/pvrusb2/pvrusb2-i2c-core.c
+++ b/drivers/media/usb/pvrusb2/pvrusb2-i2c-core.c
@@ -649,8 +649,8 @@ void pvr2_i2c_core_init(struct pvr2_hdw *hdw)
         }
 
         // Configure the adapter and set up everything else related to it.
-        memcpy(&hdw->i2c_adap,&pvr2_i2c_adap_template,sizeof(hdw->i2c_adap));
-        memcpy(&hdw->i2c_algo,&pvr2_i2c_algo_template,sizeof(hdw->i2c_algo));
+        hdw->i2c_adap = pvr2_i2c_adap_template;
+        hdw->i2c_algo = pvr2_i2c_algo_template;
         strlcpy(hdw->i2c_adap.name,hdw->name,sizeof(hdw->i2c_adap.name));
         hdw->i2c_adap.dev.parent = &hdw->usb_dev->dev;
         hdw->i2c_adap.algo = &hdw->i2c_algo;
diff --git a/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c b/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
index 6930676051e7..34c3b6e80e86 100644
--- a/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
+++ b/drivers/media/usb/pvrusb2/pvrusb2-v4l2.c
@@ -1339,7 +1339,7 @@ static void pvr2_v4l2_dev_init(struct pvr2_v4l2_dev *dip,
                 return;
         }
 
-        memcpy(&dip->devbase,&vdev_template,sizeof(vdev_template));
+        dip->devbase = vdev_template;
         dip->devbase.release = pvr2_video_device_release;
         dip->devbase.ioctl_ops = &pvr2_ioctl_ops;
         {
diff --git a/drivers/media/usb/pwc/pwc-if.c b/drivers/media/usb/pwc/pwc-if.c
index 5210239cbaee..5ec15cb1ed26 100644
--- a/drivers/media/usb/pwc/pwc-if.c
+++ b/drivers/media/usb/pwc/pwc-if.c
@@ -316,7 +316,8 @@ static void pwc_isoc_handler(struct urb *urb)
                         struct pwc_frame_buf *fbuf = pdev->fill_buf;
 
                         if (pdev->vsync == 1) {
-                                do_gettimeofday(&fbuf->vb.v4l2_buf.timestamp);
+                                v4l2_get_timestamp(
+                                        &fbuf->vb.v4l2_buf.timestamp);
                                 pdev->vsync = 2;
                         }
 
@@ -1007,7 +1008,7 @@ 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 = pwc_template;
         strcpy(pdev->vdev.name, name);
         pdev->vdev.queue = &pdev->vb_queue;
         pdev->vdev.queue->lock = &pdev->vb_queue_lock;
diff --git a/drivers/media/usb/pwc/pwc-v4l.c b/drivers/media/usb/pwc/pwc-v4l.c
index 545e9bbdeede..aa7449eaca08 100644
--- a/drivers/media/usb/pwc/pwc-v4l.c
+++ b/drivers/media/usb/pwc/pwc-v4l.c
@@ -434,19 +434,18 @@ static int pwc_vidioc_try_fmt(struct pwc_device *pdev, struct v4l2_format *f)
                 case V4L2_PIX_FMT_PWC1:
                         if (DEVICE_USE_CODEC23(pdev->type)) {
                                 PWC_DEBUG_IOCTL("codec1 is only supported for old pwc webcam\n");
-                                return -EINVAL;
+                                f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
                         }
                         break;
                 case V4L2_PIX_FMT_PWC2:
                         if (DEVICE_USE_CODEC1(pdev->type)) {
                                 PWC_DEBUG_IOCTL("codec23 is only supported for new pwc webcam\n");
-                                return -EINVAL;
+                                f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
                         }
                         break;
                 default:
                         PWC_DEBUG_IOCTL("Unsupported pixel format\n");
-                        return -EINVAL;
-
+                        f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
         }
 
         size = pwc_get_size(pdev, f->fmt.pix.width, f->fmt.pix.height);
diff --git a/drivers/media/usb/s2255/s2255drv.c b/drivers/media/usb/s2255/s2255drv.c
index 8ebec0d7bf59..498c57ea5d32 100644
--- a/drivers/media/usb/s2255/s2255drv.c
+++ b/drivers/media/usb/s2255/s2255drv.c
@@ -593,7 +593,7 @@ static int s2255_got_frame(struct s2255_channel *channel, int jpgsize)
         buf = list_entry(dma_q->active.next,
                          struct s2255_buffer, vb.queue);
         list_del(&buf->vb.queue);
-        do_gettimeofday(&buf->vb.ts);
+        v4l2_get_timestamp(&buf->vb.ts);
         s2255_fillbuff(channel, buf, jpgsize);
         wake_up(&buf->vb.done);
         dprintk(2, "%s: [buf/i] [%p/%d]\n", __func__, buf, buf->vb.i);
@@ -629,7 +629,6 @@ static void s2255_fillbuff(struct s2255_channel *channel,
                            struct s2255_buffer *buf, int jpgsize)
 {
         int pos = 0;
-        struct timeval ts;
         const char *tmpbuf;
         char *vbuf = videobuf_to_vmalloc(&buf->vb);
         unsigned long last_frame;
@@ -674,8 +673,7 @@ static void s2255_fillbuff(struct s2255_channel *channel,
         /* tell v4l buffer was filled */
 
         buf->vb.field_count = channel->frame_count * 2;
-        do_gettimeofday(&ts);
-        buf->vb.ts = ts;
+        v4l2_get_timestamp(&buf->vb.ts);
         buf->vb.state = VIDEOBUF_DONE;
 }
 
diff --git a/drivers/media/usb/sn9c102/sn9c102_core.c b/drivers/media/usb/sn9c102/sn9c102_core.c
index 73605864fffa..c957e9aa6077 100644
--- a/drivers/media/usb/sn9c102/sn9c102_core.c
+++ b/drivers/media/usb/sn9c102/sn9c102_core.c
@@ -173,7 +173,7 @@ sn9c102_request_buffers(struct sn9c102_device* cam, u32 count,
                 cam->frame[i].buf.sequence = 0;
                 cam->frame[i].buf.field = V4L2_FIELD_NONE;
                 cam->frame[i].buf.memory = V4L2_MEMORY_MMAP;
-                cam->frame[i].buf.flags = 0;
+                cam->frame[i].buf.flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
         }
 
         return cam->nbuffers;
@@ -773,7 +773,8 @@ end_of_frame:
                                        img);
 
                                 if ((*f)->buf.bytesused == 0)
-                                        do_gettimeofday(&(*f)->buf.timestamp);
+                                        v4l2_get_timestamp(
+                                                &(*f)->buf.timestamp);
 
                                 (*f)->buf.bytesused += img;
 
@@ -2826,7 +2827,7 @@ sn9c102_vidioc_querybuf(struct sn9c102_device* cam, void __user * arg)
             b.index >= cam->nbuffers || cam->io != IO_MMAP)
                 return -EINVAL;
 
-        memcpy(&b, &cam->frame[b.index].buf, sizeof(b));
+        b = cam->frame[b.index].buf;
 
         if (cam->frame[b.index].vma_use_count)
                 b.flags |= V4L2_BUF_FLAG_MAPPED;
@@ -2929,7 +2930,7 @@ sn9c102_vidioc_dqbuf(struct sn9c102_device* cam, struct file* filp,
 
         f->state = F_UNUSED;
 
-        memcpy(&b, &f->buf, sizeof(b));
+        b = f->buf;
         if (f->vma_use_count)
                 b.flags |= V4L2_BUF_FLAG_MAPPED;
 
diff --git a/drivers/media/usb/stk1160/stk1160-video.c b/drivers/media/usb/stk1160/stk1160-video.c
index fa3671de02aa..39f1aae209bc 100644
--- a/drivers/media/usb/stk1160/stk1160-video.c
+++ b/drivers/media/usb/stk1160/stk1160-video.c
@@ -78,7 +78,7 @@ struct stk1160_buffer *stk1160_next_buffer(struct stk1160 *dev)
         unsigned long flags = 0;
 
         /* Current buffer must be NULL when this functions gets called */
-        BUG_ON(dev->isoc_ctl.buf);
+        WARN_ON(dev->isoc_ctl.buf);
 
         spin_lock_irqsave(&dev->buf_lock, flags);
         if (!list_empty(&dev->avail_bufs)) {
@@ -101,7 +101,7 @@ void stk1160_buffer_done(struct stk1160 *dev)
         buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
         buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
         buf->vb.v4l2_buf.bytesused = buf->bytesused;
-        do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
+        v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 
         vb2_set_plane_payload(&buf->vb, 0, buf->bytesused);
         vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
diff --git a/drivers/media/usb/stkwebcam/stk-webcam.c b/drivers/media/usb/stkwebcam/stk-webcam.c
index 5d3c032d733c..4cbab085e348 100644
--- a/drivers/media/usb/stkwebcam/stk-webcam.c
+++ b/drivers/media/usb/stkwebcam/stk-webcam.c
@@ -28,6 +28,7 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 
+#include <linux/dmi.h>
 #include <linux/usb.h>
 #include <linux/mm.h>
 #include <linux/vmalloc.h>
@@ -38,12 +39,12 @@
 #include "stk-webcam.h"
 
 
-static bool hflip;
-module_param(hflip, bool, 0444);
+static int hflip = -1;
+module_param(hflip, int, 0444);
 MODULE_PARM_DESC(hflip, "Horizontal image flip (mirror). Defaults to 0");
 
-static bool vflip;
-module_param(vflip, bool, 0444);
+static int vflip = -1;
+module_param(vflip, int, 0444);
 MODULE_PARM_DESC(vflip, "Vertical image flip. Defaults to 0");
 
 static int debug;
@@ -62,6 +63,19 @@ static struct usb_device_id stkwebcam_table[] = {
 };
 MODULE_DEVICE_TABLE(usb, stkwebcam_table);
 
+/* The stk webcam laptop module is mounted upside down in some laptops :( */
+static const struct dmi_system_id stk_upside_down_dmi_table[] = {
+        {
+                .ident = "ASUS G1",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "G1")
+                }
+        },
+        {}
+};
+
+
 /*
  * Basic stuff
  */
@@ -466,6 +480,7 @@ static int stk_setup_siobuf(struct stk_camera *dev, int index)
         buf->dev = dev;
         buf->v4lbuf.index = index;
         buf->v4lbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        buf->v4lbuf.flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
         buf->v4lbuf.field = V4L2_FIELD_NONE;
         buf->v4lbuf.memory = V4L2_MEMORY_MMAP;
         buf->v4lbuf.m.offset = 2*index*buf->v4lbuf.length;
@@ -816,10 +831,16 @@ static int stk_vidioc_g_ctrl(struct file *filp,
                 c->value = dev->vsettings.brightness;
                 break;
         case V4L2_CID_HFLIP:
-                c->value = dev->vsettings.hflip;
+                if (dmi_check_system(stk_upside_down_dmi_table))
+                        c->value = !dev->vsettings.hflip;
+                else
+                        c->value = dev->vsettings.hflip;
                 break;
         case V4L2_CID_VFLIP:
-                c->value = dev->vsettings.vflip;
+                if (dmi_check_system(stk_upside_down_dmi_table))
+                        c->value = !dev->vsettings.vflip;
+                else
+                        c->value = dev->vsettings.vflip;
                 break;
         default:
                 return -EINVAL;
@@ -836,10 +857,16 @@ static int stk_vidioc_s_ctrl(struct file *filp,
                 dev->vsettings.brightness = c->value;
                 return stk_sensor_set_brightness(dev, c->value >> 8);
         case V4L2_CID_HFLIP:
-                dev->vsettings.hflip = c->value;
+                if (dmi_check_system(stk_upside_down_dmi_table))
+                        dev->vsettings.hflip = !c->value;
+                else
+                        dev->vsettings.hflip = c->value;
                 return 0;
         case V4L2_CID_VFLIP:
-                dev->vsettings.vflip = c->value;
+                if (dmi_check_system(stk_upside_down_dmi_table))
+                        dev->vsettings.vflip = !c->value;
+                else
+                        dev->vsettings.vflip = c->value;
                 return 0;
         default:
                 return -EINVAL;
@@ -1113,7 +1140,7 @@ static int stk_vidioc_dqbuf(struct file *filp,
         sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
         sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_DONE;
         sbuf->v4lbuf.sequence = ++dev->sequence;
-        do_gettimeofday(&sbuf->v4lbuf.timestamp);
+        v4l2_get_timestamp(&sbuf->v4lbuf.timestamp);
 
         *buf = sbuf->v4lbuf;
         return 0;
@@ -1275,8 +1302,18 @@ static int stk_camera_probe(struct usb_interface *interface,
         dev->interface = interface;
         usb_get_intf(interface);
 
-        dev->vsettings.vflip = vflip;
-        dev->vsettings.hflip = hflip;
+        if (hflip != -1)
+                dev->vsettings.hflip = hflip;
+        else if (dmi_check_system(stk_upside_down_dmi_table))
+                dev->vsettings.hflip = 1;
+        else
+                dev->vsettings.hflip = 0;
+        if (vflip != -1)
+                dev->vsettings.vflip = vflip;
+        else if (dmi_check_system(stk_upside_down_dmi_table))
+                dev->vsettings.vflip = 1;
+        else
+                dev->vsettings.vflip = 0;
         dev->n_sbufs = 0;
         set_present(dev);
 
diff --git a/drivers/media/usb/tlg2300/pd-video.c b/drivers/media/usb/tlg2300/pd-video.c
index 3082bfa9b2c5..21723378bb8f 100644
--- a/drivers/media/usb/tlg2300/pd-video.c
+++ b/drivers/media/usb/tlg2300/pd-video.c
@@ -212,7 +212,7 @@ static void submit_frame(struct front_face *front)
         front->curr_frame       = NULL;
         vb->state               = VIDEOBUF_DONE;
         vb->field_count++;
-        do_gettimeofday(&vb->ts);
+        v4l2_get_timestamp(&vb->ts);
 
         wake_up(&vb->done);
 }
diff --git a/drivers/media/usb/tm6000/tm6000-core.c b/drivers/media/usb/tm6000/tm6000-core.c
index 22cc0116deb6..7c32353c59db 100644
--- a/drivers/media/usb/tm6000/tm6000-core.c
+++ b/drivers/media/usb/tm6000/tm6000-core.c
@@ -40,10 +40,13 @@ int tm6000_read_write_usb(struct tm6000_core *dev, u8 req_type, u8 req,
         u8           *data = NULL;
         int delay = 5000;
 
-        mutex_lock(&dev->usb_lock);
-
-        if (len)
+        if (len) {
                 data = kzalloc(len, GFP_KERNEL);
+                if (!data)
+                        return -ENOMEM;
+        }
+
+        mutex_lock(&dev->usb_lock);
 
         if (req_type & USB_DIR_IN)
                 pipe = usb_rcvctrlpipe(dev->udev, 0);
diff --git a/drivers/media/usb/tm6000/tm6000-dvb.c b/drivers/media/usb/tm6000/tm6000-dvb.c
index e1f3f66e1e63..9fc1e940a82b 100644
--- a/drivers/media/usb/tm6000/tm6000-dvb.c
+++ b/drivers/media/usb/tm6000/tm6000-dvb.c
@@ -360,8 +360,8 @@ dvb_dmx_err:
         dvb_dmx_release(&dvb->demux);
 frontend_err:
         if (dvb->frontend) {
-                dvb_frontend_detach(dvb->frontend);
                 dvb_unregister_frontend(dvb->frontend);
+                dvb_frontend_detach(dvb->frontend);
         }
 adapter_err:
         dvb_unregister_adapter(&dvb->adapter);
@@ -384,8 +384,8 @@ static void unregister_dvb(struct tm6000_core *dev)
 
 /*      mutex_lock(&tm6000_driver.open_close_mutex); */
         if (dvb->frontend) {
-                dvb_frontend_detach(dvb->frontend);
                 dvb_unregister_frontend(dvb->frontend);
+                dvb_frontend_detach(dvb->frontend);
         }
 
         dvb_dmxdev_release(&dvb->dmxdev);
diff --git a/drivers/media/usb/tm6000/tm6000-video.c b/drivers/media/usb/tm6000/tm6000-video.c
index f656fd7a39a2..1a6857929c15 100644
--- a/drivers/media/usb/tm6000/tm6000-video.c
+++ b/drivers/media/usb/tm6000/tm6000-video.c
@@ -34,6 +34,7 @@
 #include <linux/usb.h>
 #include <linux/videodev2.h>
 #include <media/v4l2-ioctl.h>
+#include <media/v4l2-event.h>
 #include <media/tuner.h>
 #include <linux/interrupt.h>
 #include <linux/kthread.h>
@@ -49,82 +50,20 @@
 #define TM6000_MIN_BUF 4
 #define TM6000_DEF_BUF 8
 
+#define TM6000_NUM_URB_BUF 8
+
 #define TM6000_MAX_ISO_PACKETS  46      /* Max number of ISO packets */
 
 /* Declare static vars that will be used as parameters */
 static unsigned int vid_limit = 16;     /* Video memory limit, in Mb */
 static int video_nr = -1;               /* /dev/videoN, -1 for autodetect */
 static int radio_nr = -1;               /* /dev/radioN, -1 for autodetect */
+static bool keep_urb;                   /* keep urb buffers allocated */
 
 /* Debug level */
 int tm6000_debug;
 EXPORT_SYMBOL_GPL(tm6000_debug);
 
-static const struct v4l2_queryctrl no_ctrl = {
-        .name  = "42",
-        .flags = V4L2_CTRL_FLAG_DISABLED,
-};
-
-/* supported controls */
-static struct v4l2_queryctrl tm6000_qctrl[] = {
-        {
-                .id            = V4L2_CID_BRIGHTNESS,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Brightness",
-                .minimum       = 0,
-                .maximum       = 255,
-                .step          = 1,
-                .default_value = 54,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_CONTRAST,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Contrast",
-                .minimum       = 0,
-                .maximum       = 255,
-                .step          = 0x1,
-                .default_value = 119,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_SATURATION,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Saturation",
-                .minimum       = 0,
-                .maximum       = 255,
-                .step          = 0x1,
-                .default_value = 112,
-                .flags         = 0,
-        }, {
-                .id            = V4L2_CID_HUE,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-                .name          = "Hue",
-                .minimum       = -128,
-                .maximum       = 127,
-                .step          = 0x1,
-                .default_value = 0,
-                .flags         = 0,
-        },
-                /* --- audio --- */
-        {
-                .id            = V4L2_CID_AUDIO_MUTE,
-                .name          = "Mute",
-                .minimum       = 0,
-                .maximum       = 1,
-                .type          = V4L2_CTRL_TYPE_BOOLEAN,
-        }, {
-                .id            = V4L2_CID_AUDIO_VOLUME,
-                .name          = "Volume",
-                .minimum       = -15,
-                .maximum       = 15,
-                .step          = 1,
-                .default_value = 0,
-                .type          = V4L2_CTRL_TYPE_INTEGER,
-        }
-};
-
-static const unsigned int CTRLS = ARRAY_SIZE(tm6000_qctrl);
-static int qctl_regs[ARRAY_SIZE(tm6000_qctrl)];
-
 static struct tm6000_fmt format[] = {
         {
                 .name     = "4:2:2, packed, YVY2",
@@ -141,16 +80,6 @@ static struct tm6000_fmt format[] = {
         }
 };
 
-static const struct v4l2_queryctrl *ctrl_by_id(unsigned int id)
-{
-        unsigned int i;
-
-        for (i = 0; i < CTRLS; i++)
-                if (tm6000_qctrl[i].id == id)
-                        return tm6000_qctrl+i;
-        return NULL;
-}
-
 /* ------------------------------------------------------------------
  *      DMA and thread functions
  * ------------------------------------------------------------------
@@ -191,7 +120,7 @@ static inline void buffer_filled(struct tm6000_core *dev,
         dprintk(dev, V4L2_DEBUG_ISOC, "[%p/%d] wakeup\n", buf, buf->vb.i);
         buf->vb.state = VIDEOBUF_DONE;
         buf->vb.field_count++;
-        do_gettimeofday(&buf->vb.ts);
+        v4l2_get_timestamp(&buf->vb.ts);
 
         list_del(&buf->vb.queue);
         wake_up(&buf->vb.done);
@@ -538,6 +467,71 @@ static void tm6000_irq_callback(struct urb *urb)
 }
 
 /*
+ * Allocate URB buffers
+ */
+static int tm6000_alloc_urb_buffers(struct tm6000_core *dev)
+{
+        int num_bufs = TM6000_NUM_URB_BUF;
+        int i;
+
+        if (dev->urb_buffer != NULL)
+                return 0;
+
+        dev->urb_buffer = kmalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
+        if (!dev->urb_buffer) {
+                tm6000_err("cannot allocate memory for urb buffers\n");
+                return -ENOMEM;
+        }
+
+        dev->urb_dma = kmalloc(sizeof(dma_addr_t *)*num_bufs, GFP_KERNEL);
+        if (!dev->urb_dma) {
+                tm6000_err("cannot allocate memory for urb dma pointers\n");
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < num_bufs; i++) {
+                dev->urb_buffer[i] = usb_alloc_coherent(
+                                        dev->udev, dev->urb_size,
+                                        GFP_KERNEL, &dev->urb_dma[i]);
+                if (!dev->urb_buffer[i]) {
+                        tm6000_err("unable to allocate %i bytes for transfer buffer %i\n",
+                                    dev->urb_size, i);
+                        return -ENOMEM;
+                }
+                memset(dev->urb_buffer[i], 0, dev->urb_size);
+        }
+
+        return 0;
+}
+
+/*
+ * Free URB buffers
+ */
+static int tm6000_free_urb_buffers(struct tm6000_core *dev)
+{
+        int i;
+
+        if (dev->urb_buffer == NULL)
+                return 0;
+
+        for (i = 0; i < TM6000_NUM_URB_BUF; i++) {
+                if (dev->urb_buffer[i]) {
+                        usb_free_coherent(dev->udev,
+                                        dev->urb_size,
+                                        dev->urb_buffer[i],
+                                        dev->urb_dma[i]);
+                        dev->urb_buffer[i] = NULL;
+                }
+        }
+        kfree(dev->urb_buffer);
+        kfree(dev->urb_dma);
+        dev->urb_buffer = NULL;
+        dev->urb_dma = NULL;
+
+        return 0;
+}
+
+/*
  * Stop and Deallocate URBs
  */
 static void tm6000_uninit_isoc(struct tm6000_core *dev)
@@ -551,18 +545,15 @@ static void tm6000_uninit_isoc(struct tm6000_core *dev)
                 if (urb) {
                         usb_kill_urb(urb);
                         usb_unlink_urb(urb);
-                        if (dev->isoc_ctl.transfer_buffer[i]) {
-                                usb_free_coherent(dev->udev,
-                                                urb->transfer_buffer_length,
-                                                dev->isoc_ctl.transfer_buffer[i],
-                                                urb->transfer_dma);
-                        }
                         usb_free_urb(urb);
                         dev->isoc_ctl.urb[i] = NULL;
                 }
                 dev->isoc_ctl.transfer_buffer[i] = NULL;
         }
 
+        if (!keep_urb)
+                tm6000_free_urb_buffers(dev);
+
         kfree(dev->isoc_ctl.urb);
         kfree(dev->isoc_ctl.transfer_buffer);
 
@@ -572,12 +563,13 @@ static void tm6000_uninit_isoc(struct tm6000_core *dev)
 }
 
 /*
- * Allocate URBs and start IRQ
+ * Assign URBs and start IRQ
  */
 static int tm6000_prepare_isoc(struct tm6000_core *dev)
 {
         struct tm6000_dmaqueue *dma_q = &dev->vidq;
-        int i, j, sb_size, pipe, size, max_packets, num_bufs = 8;
+        int i, j, sb_size, pipe, size, max_packets;
+        int num_bufs = TM6000_NUM_URB_BUF;
         struct urb *urb;
 
         /* De-allocates all pending stuff */
@@ -605,6 +597,7 @@ static int tm6000_prepare_isoc(struct tm6000_core *dev)
 
         max_packets = TM6000_MAX_ISO_PACKETS;
         sb_size = max_packets * size;
+        dev->urb_size = sb_size;
 
         dev->isoc_ctl.num_bufs = num_bufs;
 
@@ -627,6 +620,17 @@ static int tm6000_prepare_isoc(struct tm6000_core *dev)
                     max_packets, num_bufs, sb_size,
                     dev->isoc_in.maxsize, size);
 
+
+        if (!dev->urb_buffer && tm6000_alloc_urb_buffers(dev) < 0) {
+                tm6000_err("cannot allocate memory for urb buffers\n");
+
+                /* call free, as some buffers might have been allocated */
+                tm6000_free_urb_buffers(dev);
+                kfree(dev->isoc_ctl.urb);
+                kfree(dev->isoc_ctl.transfer_buffer);
+                return -ENOMEM;
+        }
+
         /* allocate urbs and transfer buffers */
         for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
                 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
@@ -638,17 +642,8 @@ static int tm6000_prepare_isoc(struct tm6000_core *dev)
                 }
                 dev->isoc_ctl.urb[i] = urb;
 
-                dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->udev,
-                        sb_size, GFP_KERNEL, &urb->transfer_dma);
-                if (!dev->isoc_ctl.transfer_buffer[i]) {
-                        tm6000_err("unable to allocate %i bytes for transfer"
-                                        " buffer %i%s\n",
-                                        sb_size, i,
-                                        in_interrupt() ? " while in int" : "");
-                        tm6000_uninit_isoc(dev);
-                        return -ENOMEM;
-                }
-                memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
+                urb->transfer_dma = dev->urb_dma[i];
+                dev->isoc_ctl.transfer_buffer[i] = dev->urb_buffer[i];
 
                 usb_fill_bulk_urb(urb, dev->udev, pipe,
                                   dev->isoc_ctl.transfer_buffer[i], sb_size,
@@ -879,16 +874,21 @@ static int vidioc_querycap(struct file *file, void  *priv,
                                         struct v4l2_capability *cap)
 {
         struct tm6000_core *dev = ((struct tm6000_fh *)priv)->dev;
+        struct video_device *vdev = video_devdata(file);
 
         strlcpy(cap->driver, "tm6000", sizeof(cap->driver));
         strlcpy(cap->card, "Trident TVMaster TM5600/6000/6010", sizeof(cap->card));
-        cap->capabilities =     V4L2_CAP_VIDEO_CAPTURE |
-                                V4L2_CAP_STREAMING     |
-                                V4L2_CAP_AUDIO         |
-                                V4L2_CAP_READWRITE;
-
+        usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
         if (dev->tuner_type != TUNER_ABSENT)
-                cap->capabilities |= V4L2_CAP_TUNER;
+                cap->device_caps |= V4L2_CAP_TUNER;
+        if (vdev->vfl_type == VFL_TYPE_GRABBER)
+                cap->device_caps |= V4L2_CAP_VIDEO_CAPTURE |
+                                V4L2_CAP_STREAMING |
+                                V4L2_CAP_READWRITE;
+        else
+                cap->device_caps |= V4L2_CAP_RADIO;
+        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS |
+                V4L2_CAP_RADIO | V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
 
         return 0;
 }
@@ -896,7 +896,7 @@ static int vidioc_querycap(struct file *file, void  *priv,
 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
                                         struct v4l2_fmtdesc *f)
 {
-        if (unlikely(f->index >= ARRAY_SIZE(format)))
+        if (f->index >= ARRAY_SIZE(format))
                 return -EINVAL;
 
         strlcpy(f->description, format[f->index].name, sizeof(f->description));
@@ -913,10 +913,12 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.height       = fh->height;
         f->fmt.pix.field        = fh->vb_vidq.field;
         f->fmt.pix.pixelformat  = fh->fmt->fourcc;
+        f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * fh->fmt->depth) >> 3;
         f->fmt.pix.sizeimage =
                 f->fmt.pix.height * f->fmt.pix.bytesperline;
+        f->fmt.pix.priv = 0;
 
         return 0;
 }
@@ -947,12 +949,7 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 
         field = f->fmt.pix.field;
 
-        if (field == V4L2_FIELD_ANY)
-                field = V4L2_FIELD_SEQ_TB;
-        else if (V4L2_FIELD_INTERLACED != field) {
-                dprintk(dev, V4L2_DEBUG_IOCTL_ARG, "Field type invalid.\n");
-                return -EINVAL;
-        }
+        field = V4L2_FIELD_INTERLACED;
 
         tm6000_get_std_res(dev);
 
@@ -962,11 +959,13 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         f->fmt.pix.width &= ~0x01;
 
         f->fmt.pix.field = field;
+        f->fmt.pix.priv = 0;
 
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * fmt->depth) >> 3;
         f->fmt.pix.sizeimage =
                 f->fmt.pix.height * f->fmt.pix.bytesperline;
+        f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
 
         return 0;
 }
@@ -1141,79 +1140,40 @@ static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 }
 
 /* --- controls ---------------------------------------------- */
-static int vidioc_queryctrl(struct file *file, void *priv,
-                                struct v4l2_queryctrl *qc)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(tm6000_qctrl); i++)
-                if (qc->id && qc->id == tm6000_qctrl[i].id) {
-                        memcpy(qc, &(tm6000_qctrl[i]),
-                                sizeof(*qc));
-                        return 0;
-                }
 
-        return -EINVAL;
-}
-
-static int vidioc_g_ctrl(struct file *file, void *priv,
-                                struct v4l2_control *ctrl)
+static int tm6000_s_ctrl(struct v4l2_ctrl *ctrl)
 {
-        struct tm6000_fh  *fh = priv;
-        struct tm6000_core *dev    = fh->dev;
-        int  val;
+        struct tm6000_core *dev = container_of(ctrl->handler, struct tm6000_core, ctrl_handler);
+        u8  val = ctrl->val;
 
-        /* FIXME: Probably, those won't work! Maybe we need shadow regs */
         switch (ctrl->id) {
         case V4L2_CID_CONTRAST:
-                val = tm6000_get_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, 0);
-                break;
+                tm6000_set_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, val);
+                return 0;
         case V4L2_CID_BRIGHTNESS:
-                val = tm6000_get_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, 0);
+                tm6000_set_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, val);
                 return 0;
         case V4L2_CID_SATURATION:
-                val = tm6000_get_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, 0);
+                tm6000_set_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, val);
                 return 0;
         case V4L2_CID_HUE:
-                val = tm6000_get_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, 0);
-                return 0;
-        case V4L2_CID_AUDIO_MUTE:
-                val = dev->ctl_mute;
-                return 0;
-        case V4L2_CID_AUDIO_VOLUME:
-                val = dev->ctl_volume;
+                tm6000_set_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, val);
                 return 0;
-        default:
-                return -EINVAL;
         }
+        return -EINVAL;
+}
 
-        if (val < 0)
-                return val;
-
-        ctrl->value = val;
+static const struct v4l2_ctrl_ops tm6000_ctrl_ops = {
+        .s_ctrl = tm6000_s_ctrl,
+};
 
-        return 0;
-}
-static int vidioc_s_ctrl(struct file *file, void *priv,
-                                struct v4l2_control *ctrl)
+static int tm6000_radio_s_ctrl(struct v4l2_ctrl *ctrl)
 {
-        struct tm6000_fh   *fh  = priv;
-        struct tm6000_core *dev = fh->dev;
-        u8  val = ctrl->value;
+        struct tm6000_core *dev = container_of(ctrl->handler,
+                        struct tm6000_core, radio_ctrl_handler);
+        u8  val = ctrl->val;
 
         switch (ctrl->id) {
-        case V4L2_CID_CONTRAST:
-                tm6000_set_reg(dev, TM6010_REQ07_R08_LUMA_CONTRAST_ADJ, val);
-                return 0;
-        case V4L2_CID_BRIGHTNESS:
-                tm6000_set_reg(dev, TM6010_REQ07_R09_LUMA_BRIGHTNESS_ADJ, val);
-                return 0;
-        case V4L2_CID_SATURATION:
-                tm6000_set_reg(dev, TM6010_REQ07_R0A_CHROMA_SATURATION_ADJ, val);
-                return 0;
-        case V4L2_CID_HUE:
-                tm6000_set_reg(dev, TM6010_REQ07_R0B_CHROMA_HUE_PHASE_ADJ, val);
-                return 0;
         case V4L2_CID_AUDIO_MUTE:
                 dev->ctl_mute = val;
                 tm6000_tvaudio_set_mute(dev, val);
@@ -1226,20 +1186,24 @@ static int vidioc_s_ctrl(struct file *file, void *priv,
         return -EINVAL;
 }
 
+static const struct v4l2_ctrl_ops tm6000_radio_ctrl_ops = {
+        .s_ctrl = tm6000_radio_s_ctrl,
+};
+
 static int vidioc_g_tuner(struct file *file, void *priv,
                                 struct v4l2_tuner *t)
 {
         struct tm6000_fh   *fh  = priv;
         struct tm6000_core *dev = fh->dev;
 
-        if (unlikely(UNSET == dev->tuner_type))
-                return -EINVAL;
+        if (UNSET == dev->tuner_type)
+                return -ENOTTY;
         if (0 != t->index)
                 return -EINVAL;
 
         strcpy(t->name, "Television");
         t->type       = V4L2_TUNER_ANALOG_TV;
-        t->capability = V4L2_TUNER_CAP_NORM;
+        t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO;
         t->rangehigh  = 0xffffffffUL;
         t->rxsubchans = V4L2_TUNER_SUB_STEREO;
 
@@ -1257,11 +1221,14 @@ static int vidioc_s_tuner(struct file *file, void *priv,
         struct tm6000_core *dev = fh->dev;
 
         if (UNSET == dev->tuner_type)
-                return -EINVAL;
+                return -ENOTTY;
         if (0 != t->index)
                 return -EINVAL;
 
-        dev->amode = t->audmode;
+        if (t->audmode > V4L2_TUNER_MODE_STEREO)
+                dev->amode = V4L2_TUNER_MODE_STEREO;
+        else
+                dev->amode = t->audmode;
         dprintk(dev, 3, "audio mode: %x\n", t->audmode);
 
         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
@@ -1275,10 +1242,11 @@ static int vidioc_g_frequency(struct file *file, void *priv,
         struct tm6000_fh   *fh  = priv;
         struct tm6000_core *dev = fh->dev;
 
-        if (unlikely(UNSET == dev->tuner_type))
+        if (UNSET == dev->tuner_type)
+                return -ENOTTY;
+        if (f->tuner)
                 return -EINVAL;
 
-        f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
         f->frequency = dev->freq;
 
         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, f);
@@ -1292,13 +1260,9 @@ static int vidioc_s_frequency(struct file *file, void *priv,
         struct tm6000_fh   *fh  = priv;
         struct tm6000_core *dev = fh->dev;
 
-        if (unlikely(UNSET == dev->tuner_type))
-                return -EINVAL;
-        if (unlikely(f->tuner != 0))
-                return -EINVAL;
-        if (0 == fh->radio && V4L2_TUNER_ANALOG_TV != f->type)
-                return -EINVAL;
-        if (1 == fh->radio && V4L2_TUNER_RADIO != f->type)
+        if (UNSET == dev->tuner_type)
+                return -ENOTTY;
+        if (f->tuner != 0)
                 return -EINVAL;
 
         dev->freq = f->frequency;
@@ -1307,27 +1271,6 @@ static int vidioc_s_frequency(struct file *file, void *priv,
         return 0;
 }
 
-static int radio_querycap(struct file *file, void *priv,
-                                        struct v4l2_capability *cap)
-{
-        struct tm6000_fh *fh = file->private_data;
-        struct tm6000_core *dev = fh->dev;
-
-        strcpy(cap->driver, "tm6000");
-        strlcpy(cap->card, dev->name, sizeof(dev->name));
-        sprintf(cap->bus_info, "USB%04x:%04x",
-                le16_to_cpu(dev->udev->descriptor.idVendor),
-                le16_to_cpu(dev->udev->descriptor.idProduct));
-        cap->version = dev->dev_type;
-        cap->capabilities = V4L2_CAP_TUNER |
-                        V4L2_CAP_AUDIO     |
-                        V4L2_CAP_RADIO     |
-                        V4L2_CAP_READWRITE |
-                        V4L2_CAP_STREAMING;
-
-        return 0;
-}
-
 static int radio_g_tuner(struct file *file, void *priv,
                                         struct v4l2_tuner *t)
 {
@@ -1340,7 +1283,9 @@ static int radio_g_tuner(struct file *file, void *priv,
         memset(t, 0, sizeof(*t));
         strcpy(t->name, "Radio");
         t->type = V4L2_TUNER_RADIO;
+        t->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
         t->rxsubchans = V4L2_TUNER_SUB_STEREO;
+        t->audmode = V4L2_TUNER_MODE_STEREO;
 
         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
 
@@ -1355,95 +1300,14 @@ static int radio_s_tuner(struct file *file, void *priv,
 
         if (0 != t->index)
                 return -EINVAL;
+        if (t->audmode > V4L2_TUNER_MODE_STEREO)
+                t->audmode = V4L2_TUNER_MODE_STEREO;
 
         v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
 
         return 0;
 }
 
-static int radio_enum_input(struct file *file, void *priv,
-                                        struct v4l2_input *i)
-{
-        struct tm6000_fh *fh = priv;
-        struct tm6000_core *dev = fh->dev;
-
-        if (i->index != 0)
-                return -EINVAL;
-
-        if (!dev->rinput.type)
-                return -EINVAL;
-
-        strcpy(i->name, "Radio");
-        i->type = V4L2_INPUT_TYPE_TUNER;
-
-        return 0;
-}
-
-static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
-{
-        struct tm6000_fh *fh = priv;
-        struct tm6000_core *dev = fh->dev;
-
-        if (dev->input != 5)
-                return -EINVAL;
-
-        *i = dev->input - 5;
-
-        return 0;
-}
-
-static int radio_g_audio(struct file *file, void *priv,
-                                        struct v4l2_audio *a)
-{
-        memset(a, 0, sizeof(*a));
-        strcpy(a->name, "Radio");
-        return 0;
-}
-
-static int radio_s_audio(struct file *file, void *priv,
-                                        const struct v4l2_audio *a)
-{
-        return 0;
-}
-
-static int radio_s_input(struct file *filp, void *priv, unsigned int i)
-{
-        struct tm6000_fh *fh = priv;
-        struct tm6000_core *dev = fh->dev;
-
-        if (i)
-                return -EINVAL;
-
-        if (!dev->rinput.type)
-                return -EINVAL;
-
-        dev->input = i + 5;
-
-        return 0;
-}
-
-static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
-{
-        return 0;
-}
-
-static int radio_queryctrl(struct file *file, void *priv,
-                                        struct v4l2_queryctrl *c)
-{
-        const struct v4l2_queryctrl *ctrl;
-
-        if (c->id <  V4L2_CID_BASE ||
-            c->id >= V4L2_CID_LASTP1)
-                return -EINVAL;
-        if (c->id == V4L2_CID_AUDIO_MUTE) {
-                ctrl = ctrl_by_id(c->id);
-                *c = *ctrl;
-        } else
-                *c = no_ctrl;
-
-        return 0;
-}
-
 /* ------------------------------------------------------------------
         File operations for the device
    ------------------------------------------------------------------*/
@@ -1454,7 +1318,7 @@ static int __tm6000_open(struct file *file)
         struct tm6000_core *dev = video_drvdata(file);
         struct tm6000_fh *fh;
         enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-        int i, rc;
+        int rc;
         int radio = 0;
 
         dprintk(dev, V4L2_DEBUG_OPEN, "tm6000: open called (dev=%s)\n",
@@ -1486,6 +1350,7 @@ static int __tm6000_open(struct file *file)
                 return -ENOMEM;
         }
 
+        v4l2_fh_init(&fh->fh, vdev);
         file->private_data = fh;
         fh->dev      = dev;
         fh->radio    = radio;
@@ -1514,13 +1379,7 @@ static int __tm6000_open(struct file *file)
         if (rc < 0)
                 return rc;
 
-        if (dev->mode != TM6000_MODE_ANALOG) {
-                /* Put all controls at a sane state */
-                for (i = 0; i < ARRAY_SIZE(tm6000_qctrl); i++)
-                        qctl_regs[i] = tm6000_qctrl[i].default_value;
-
-                dev->mode = TM6000_MODE_ANALOG;
-        }
+        dev->mode = TM6000_MODE_ANALOG;
 
         if (!fh->radio) {
                 videobuf_queue_vmalloc_init(&fh->vb_vidq, &tm6000_video_qops,
@@ -1530,12 +1389,12 @@ static int __tm6000_open(struct file *file)
                                 sizeof(struct tm6000_buffer), fh, &dev->lock);
         } else {
                 dprintk(dev, V4L2_DEBUG_OPEN, "video_open: setting radio device\n");
-                dev->input = 5;
                 tm6000_set_audio_rinput(dev);
                 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio);
                 tm6000_prepare_isoc(dev);
                 tm6000_start_thread(dev);
         }
+        v4l2_fh_add(&fh->fh);
 
         return 0;
 }
@@ -1576,29 +1435,35 @@ tm6000_read(struct file *file, char __user *data, size_t count, loff_t *pos)
 static unsigned int
 __tm6000_poll(struct file *file, struct poll_table_struct *wait)
 {
+        unsigned long req_events = poll_requested_events(wait);
         struct tm6000_fh        *fh = file->private_data;
         struct tm6000_buffer    *buf;
+        int res = 0;
 
+        if (v4l2_event_pending(&fh->fh))
+                res = POLLPRI;
+        else if (req_events & POLLPRI)
+                poll_wait(file, &fh->fh.wait, wait);
         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
-                return POLLERR;
+                return res | POLLERR;
 
         if (!!is_res_streaming(fh->dev, fh))
-                return POLLERR;
+                return res | POLLERR;
 
         if (!is_res_read(fh->dev, fh)) {
                 /* streaming capture */
                 if (list_empty(&fh->vb_vidq.stream))
-                        return POLLERR;
+                        return res | POLLERR;
                 buf = list_entry(fh->vb_vidq.stream.next, struct tm6000_buffer, vb.stream);
-        } else {
+                poll_wait(file, &buf->vb.done, wait);
+                if (buf->vb.state == VIDEOBUF_DONE ||
+                    buf->vb.state == VIDEOBUF_ERROR)
+                        return res | POLLIN | POLLRDNORM;
+        } else if (req_events & (POLLIN | POLLRDNORM)) {
                 /* read() capture */
-                return videobuf_poll_stream(file, &fh->vb_vidq, wait);
+                return res | videobuf_poll_stream(file, &fh->vb_vidq, wait);
         }
-        poll_wait(file, &buf->vb.done, wait);
-        if (buf->vb.state == VIDEOBUF_DONE ||
-            buf->vb.state == VIDEOBUF_ERROR)
-                return POLLIN | POLLRDNORM;
-        return 0;
+        return res;
 }
 
 static unsigned int tm6000_poll(struct file *file, struct poll_table_struct *wait)
@@ -1648,7 +1513,8 @@ static int tm6000_release(struct file *file)
                 if (!fh->radio)
                         videobuf_mmap_free(&fh->vb_vidq);
         }
-
+        v4l2_fh_del(&fh->fh);
+        v4l2_fh_exit(&fh->fh);
         kfree(fh);
         mutex_unlock(&dev->lock);
 
@@ -1688,9 +1554,6 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
         .vidioc_enum_input        = vidioc_enum_input,
         .vidioc_g_input           = vidioc_g_input,
         .vidioc_s_input           = vidioc_s_input,
-        .vidioc_queryctrl         = vidioc_queryctrl,
-        .vidioc_g_ctrl            = vidioc_g_ctrl,
-        .vidioc_s_ctrl            = vidioc_s_ctrl,
         .vidioc_g_tuner           = vidioc_g_tuner,
         .vidioc_s_tuner           = vidioc_s_tuner,
         .vidioc_g_frequency       = vidioc_g_frequency,
@@ -1701,6 +1564,8 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
         .vidioc_querybuf          = vidioc_querybuf,
         .vidioc_qbuf              = vidioc_qbuf,
         .vidioc_dqbuf             = vidioc_dqbuf,
+        .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 };
 
 static struct video_device tm6000_template = {
@@ -1715,25 +1580,19 @@ static struct video_device tm6000_template = {
 static const struct v4l2_file_operations radio_fops = {
         .owner          = THIS_MODULE,
         .open           = tm6000_open,
+        .poll           = v4l2_ctrl_poll,
         .release        = tm6000_release,
         .unlocked_ioctl = video_ioctl2,
 };
 
 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
-        .vidioc_querycap        = radio_querycap,
+        .vidioc_querycap        = vidioc_querycap,
         .vidioc_g_tuner         = radio_g_tuner,
-        .vidioc_enum_input      = radio_enum_input,
-        .vidioc_g_audio         = radio_g_audio,
         .vidioc_s_tuner         = radio_s_tuner,
-        .vidioc_s_audio         = radio_s_audio,
-        .vidioc_s_input         = radio_s_input,
-        .vidioc_s_std           = radio_s_std,
-        .vidioc_queryctrl       = radio_queryctrl,
-        .vidioc_g_input         = radio_g_input,
-        .vidioc_g_ctrl          = vidioc_g_ctrl,
-        .vidioc_s_ctrl          = vidioc_s_ctrl,
         .vidioc_g_frequency     = vidioc_g_frequency,
         .vidioc_s_frequency     = vidioc_s_frequency,
+        .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
+        .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 };
 
 static struct video_device tm6000_radio_template = {
@@ -1762,6 +1621,7 @@ static struct video_device *vdev_init(struct tm6000_core *dev,
         vfd->release = video_device_release;
         vfd->debug = tm6000_debug;
         vfd->lock = &dev->lock;
+        set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
 
         snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name);
 
@@ -1771,15 +1631,41 @@ static struct video_device *vdev_init(struct tm6000_core *dev,
 
 int tm6000_v4l2_register(struct tm6000_core *dev)
 {
-        int ret = -1;
+        int ret = 0;
+
+        v4l2_ctrl_handler_init(&dev->ctrl_handler, 6);
+        v4l2_ctrl_handler_init(&dev->radio_ctrl_handler, 2);
+        v4l2_ctrl_new_std(&dev->radio_ctrl_handler, &tm6000_radio_ctrl_ops,
+                        V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
+        v4l2_ctrl_new_std(&dev->radio_ctrl_handler, &tm6000_radio_ctrl_ops,
+                        V4L2_CID_AUDIO_VOLUME, -15, 15, 1, 0);
+        v4l2_ctrl_new_std(&dev->ctrl_handler, &tm6000_ctrl_ops,
+                        V4L2_CID_BRIGHTNESS, 0, 255, 1, 54);
+        v4l2_ctrl_new_std(&dev->ctrl_handler, &tm6000_ctrl_ops,
+                        V4L2_CID_CONTRAST, 0, 255, 1, 119);
+        v4l2_ctrl_new_std(&dev->ctrl_handler, &tm6000_ctrl_ops,
+                        V4L2_CID_SATURATION, 0, 255, 1, 112);
+        v4l2_ctrl_new_std(&dev->ctrl_handler, &tm6000_ctrl_ops,
+                        V4L2_CID_HUE, -128, 127, 1, 0);
+        v4l2_ctrl_add_handler(&dev->ctrl_handler,
+                        &dev->radio_ctrl_handler, NULL);
+
+        if (dev->radio_ctrl_handler.error)
+                ret = dev->radio_ctrl_handler.error;
+        if (!ret && dev->ctrl_handler.error)
+                ret = dev->ctrl_handler.error;
+        if (ret)
+                goto free_ctrl;
 
         dev->vfd = vdev_init(dev, &tm6000_template, "video");
 
         if (!dev->vfd) {
                 printk(KERN_INFO "%s: can't register video device\n",
                        dev->name);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto free_ctrl;
         }
+        dev->vfd->ctrl_handler = &dev->ctrl_handler;
 
         /* init video dma queues */
         INIT_LIST_HEAD(&dev->vidq.active);
@@ -1790,7 +1676,9 @@ int tm6000_v4l2_register(struct tm6000_core *dev)
         if (ret < 0) {
                 printk(KERN_INFO "%s: can't register video device\n",
                        dev->name);
-                return ret;
+                video_device_release(dev->vfd);
+                dev->vfd = NULL;
+                goto free_ctrl;
         }
 
         printk(KERN_INFO "%s: registered device %s\n",
@@ -1803,15 +1691,17 @@ int tm6000_v4l2_register(struct tm6000_core *dev)
                         printk(KERN_INFO "%s: can't register radio device\n",
                                dev->name);
                         ret = -ENXIO;
-                        return ret; /* FIXME release resource */
+                        goto unreg_video;
                 }
 
+                dev->radio_dev->ctrl_handler = &dev->radio_ctrl_handler;
                 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
                                             radio_nr);
                 if (ret < 0) {
                         printk(KERN_INFO "%s: can't register radio device\n",
                                dev->name);
-                        return ret; /* FIXME release resource */
+                        video_device_release(dev->radio_dev);
+                        goto unreg_video;
                 }
 
                 printk(KERN_INFO "%s: registered device %s\n",
@@ -1820,12 +1710,22 @@ int tm6000_v4l2_register(struct tm6000_core *dev)
 
         printk(KERN_INFO "Trident TVMaster TM5600/TM6000/TM6010 USB2 board (Load status: %d)\n", ret);
         return ret;
+
+unreg_video:
+        video_unregister_device(dev->vfd);
+free_ctrl:
+        v4l2_ctrl_handler_free(&dev->ctrl_handler);
+        v4l2_ctrl_handler_free(&dev->radio_ctrl_handler);
+        return ret;
 }
 
 int tm6000_v4l2_unregister(struct tm6000_core *dev)
 {
         video_unregister_device(dev->vfd);
 
+        /* if URB buffers are still allocated free them now */
+        tm6000_free_urb_buffers(dev);
+
         if (dev->radio_dev) {
                 if (video_is_registered(dev->radio_dev))
                         video_unregister_device(dev->radio_dev);
@@ -1851,3 +1751,5 @@ MODULE_PARM_DESC(debug, "activates debug info");
 module_param(vid_limit, int, 0644);
 MODULE_PARM_DESC(vid_limit, "capture memory limit in megabytes");
 
+module_param(keep_urb, bool, 0);
+MODULE_PARM_DESC(keep_urb, "Keep urb buffers allocated even when the device is closed by the user");
diff --git a/drivers/media/usb/tm6000/tm6000.h b/drivers/media/usb/tm6000/tm6000.h
index 6df418658c9c..08bd0740dd23 100644
--- a/drivers/media/usb/tm6000/tm6000.h
+++ b/drivers/media/usb/tm6000/tm6000.h
@@ -27,6 +27,8 @@
 #include <linux/i2c.h>
 #include <linux/mutex.h>
 #include <media/v4l2-device.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-fh.h>
 
 #include <linux/dvb/frontend.h>
 #include "dvb_demux.h"
@@ -222,6 +224,8 @@ struct tm6000_core {
         struct video_device             *radio_dev;
         struct tm6000_dmaqueue          vidq;
         struct v4l2_device              v4l2_dev;
+        struct v4l2_ctrl_handler        ctrl_handler;
+        struct v4l2_ctrl_handler        radio_ctrl_handler;
 
         int                             input;
         struct tm6000_input             vinput[3];      /* video input */
@@ -264,6 +268,11 @@ struct tm6000_core {
 
         spinlock_t                   slock;
 
+        /* urb dma buffers */
+        char                            **urb_buffer;
+        dma_addr_t                      *urb_dma;
+        unsigned int                    urb_size;
+
         unsigned long quirks;
 };
 
@@ -282,6 +291,7 @@ struct tm6000_ops {
 };
 
 struct tm6000_fh {
+        struct v4l2_fh               fh;
         struct tm6000_core           *dev;
         unsigned int                 radio;
 
diff --git a/drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c b/drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c
index 5b682cc4c814..e40718552850 100644
--- a/drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c
+++ b/drivers/media/usb/ttusb-budget/dvb-ttusb-budget.c
@@ -561,6 +561,13 @@ static void ttusb_process_muxpack(struct ttusb *ttusb, const u8 * muxpack,
 {
         u16 csum = 0, cc;
         int i;
+
+        if (len < 4 || len & 0x1) {
+                pr_warn("%s: muxpack has invalid len %d\n", __func__, len);
+                numinvalid++;
+                return;
+        }
+
         for (i = 0; i < len; i += 2)
                 csum ^= le16_to_cpup((__le16 *) (muxpack + i));
         if (csum) {
diff --git a/drivers/media/usb/usbvision/usbvision-core.c b/drivers/media/usb/usbvision/usbvision-core.c
index c9b2042f8bdf..816b1cffab7d 100644
--- a/drivers/media/usb/usbvision/usbvision-core.c
+++ b/drivers/media/usb/usbvision/usbvision-core.c
@@ -1169,7 +1169,7 @@ static void usbvision_parse_data(struct usb_usbvision *usbvision)
 
         if (newstate == parse_state_next_frame) {
                 frame->grabstate = frame_state_done;
-                do_gettimeofday(&(frame->timestamp));
+                v4l2_get_timestamp(&(frame->timestamp));
                 frame->sequence = usbvision->frame_num;
 
                 spin_lock_irqsave(&usbvision->queue_lock, lock_flags);
diff --git a/drivers/media/usb/usbvision/usbvision-i2c.c b/drivers/media/usb/usbvision/usbvision-i2c.c
index 89fec029e924..ba262a32bd3a 100644
--- a/drivers/media/usb/usbvision/usbvision-i2c.c
+++ b/drivers/media/usb/usbvision/usbvision-i2c.c
@@ -189,8 +189,7 @@ int usbvision_i2c_register(struct usb_usbvision *usbvision)
         if (usbvision->registered_i2c)
                 return 0;
 
-        memcpy(&usbvision->i2c_adap, &i2c_adap_template,
-               sizeof(struct i2c_adapter));
+        usbvision->i2c_adap = i2c_adap_template;
 
         sprintf(usbvision->i2c_adap.name, "%s-%d-%s", i2c_adap_template.name,
                 usbvision->dev->bus->busnum, usbvision->dev->devpath);
diff --git a/drivers/media/usb/usbvision/usbvision-video.c b/drivers/media/usb/usbvision/usbvision-video.c
index ad7f7448072e..cd1fe78a5532 100644
--- a/drivers/media/usb/usbvision/usbvision-video.c
+++ b/drivers/media/usb/usbvision/usbvision-video.c
@@ -761,7 +761,7 @@ static int vidioc_querybuf(struct file *file,
         if (vb->index >= usbvision->num_frames)
                 return -EINVAL;
         /* Updating the corresponding frame state */
-        vb->flags = 0;
+        vb->flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
         frame = &usbvision->frame[vb->index];
         if (frame->grabstate >= frame_state_ready)
                 vb->flags |= V4L2_BUF_FLAG_QUEUED;
@@ -843,7 +843,8 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *vb)
         vb->memory = V4L2_MEMORY_MMAP;
         vb->flags = V4L2_BUF_FLAG_MAPPED |
                 V4L2_BUF_FLAG_QUEUED |
-                V4L2_BUF_FLAG_DONE;
+                V4L2_BUF_FLAG_DONE |
+                V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
         vb->index = f->index;
         vb->sequence = f->sequence;
         vb->timestamp = f->timestamp;
diff --git a/drivers/media/usb/uvc/uvc_ctrl.c b/drivers/media/usb/uvc/uvc_ctrl.c
index d5baab17a5ef..61e28dec991d 100644
--- a/drivers/media/usb/uvc/uvc_ctrl.c
+++ b/drivers/media/usb/uvc/uvc_ctrl.c
@@ -1838,7 +1838,7 @@ static int uvc_ctrl_add_info(struct uvc_device *dev, struct uvc_control *ctrl,
 {
         int ret = 0;
 
-        memcpy(&ctrl->info, info, sizeof(*info));
+        ctrl->info = *info;
         INIT_LIST_HEAD(&ctrl->info.mappings);
 
         /* Allocate an array to save control values (cur, def, max, etc.) */
diff --git a/drivers/media/usb/uvc/uvc_queue.c b/drivers/media/usb/uvc/uvc_queue.c
index 778addc5caff..6c233a54ce40 100644
--- a/drivers/media/usb/uvc/uvc_queue.c
+++ b/drivers/media/usb/uvc/uvc_queue.c
@@ -115,11 +115,27 @@ static int uvc_buffer_finish(struct vb2_buffer *vb)
         return 0;
 }
 
+static void uvc_wait_prepare(struct vb2_queue *vq)
+{
+        struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
+
+        mutex_unlock(&queue->mutex);
+}
+
+static void uvc_wait_finish(struct vb2_queue *vq)
+{
+        struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
+
+        mutex_lock(&queue->mutex);
+}
+
 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,
+        .wait_prepare = uvc_wait_prepare,
+        .wait_finish = uvc_wait_finish,
 };
 
 int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
diff --git a/drivers/media/usb/uvc/uvc_v4l2.c b/drivers/media/usb/uvc/uvc_v4l2.c
index 68d59b527492..b2dc32623a71 100644
--- a/drivers/media/usb/uvc/uvc_v4l2.c
+++ b/drivers/media/usb/uvc/uvc_v4l2.c
@@ -315,7 +315,7 @@ static int uvc_v4l2_set_format(struct uvc_streaming *stream,
                 goto done;
         }
 
-        memcpy(&stream->ctrl, &probe, sizeof probe);
+        stream->ctrl = probe;
         stream->cur_format = format;
         stream->cur_frame = frame;
 
@@ -387,7 +387,7 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
                 return -EBUSY;
         }
 
-        memcpy(&probe, &stream->ctrl, sizeof probe);
+        probe = stream->ctrl;
         probe.dwFrameInterval =
                 uvc_try_frame_interval(stream->cur_frame, interval);
 
@@ -398,7 +398,7 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
                 return ret;
         }
 
-        memcpy(&stream->ctrl, &probe, sizeof probe);
+        stream->ctrl = probe;
         mutex_unlock(&stream->mutex);
 
         /* Return the actual frame period. */
@@ -501,8 +501,8 @@ static int uvc_v4l2_open(struct file *file)
         if (atomic_inc_return(&stream->dev->users) == 1) {
                 ret = uvc_status_start(stream->dev);
                 if (ret < 0) {
-                        usb_autopm_put_interface(stream->dev->intf);
                         atomic_dec(&stream->dev->users);
+                        usb_autopm_put_interface(stream->dev->intf);
                         kfree(handle);
                         return ret;
                 }
diff --git a/drivers/media/usb/zr364xx/zr364xx.c b/drivers/media/usb/zr364xx/zr364xx.c
index 39edd4442932..74d56df3347f 100644
--- a/drivers/media/usb/zr364xx/zr364xx.c
+++ b/drivers/media/usb/zr364xx/zr364xx.c
@@ -501,7 +501,6 @@ static void zr364xx_fillbuff(struct zr364xx_camera *cam,
                              int jpgsize)
 {
         int pos = 0;
-        struct timeval ts;
         const char *tmpbuf;
         char *vbuf = videobuf_to_vmalloc(&buf->vb);
         unsigned long last_frame;
@@ -530,8 +529,7 @@ static void zr364xx_fillbuff(struct zr364xx_camera *cam,
         /* tell v4l buffer was filled */
 
         buf->vb.field_count = cam->frame_count * 2;
-        do_gettimeofday(&ts);
-        buf->vb.ts = ts;
+        v4l2_get_timestamp(&buf->vb.ts);
         buf->vb.state = VIDEOBUF_DONE;
 }
 
@@ -559,7 +557,7 @@ static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
                 goto unlock;
         }
         list_del(&buf->vb.queue);
-        do_gettimeofday(&buf->vb.ts);
+        v4l2_get_timestamp(&buf->vb.ts);
         DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
         zr364xx_fillbuff(cam, buf, jpgsize);
         wake_up(&buf->vb.done);