V4L/DVB (10729): zoran: convert to v4l2_device/v4l2_subdev.

Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

5 files changed, 159 insertions, 288 deletions

diff --git a/drivers/media/video/zoran/zoran.h b/drivers/media/video/zoran/zoran.h
index a323eb66e7c..ab1ced26276 100644
--- a/drivers/media/video/zoran/zoran.h
+++ b/drivers/media/video/zoran/zoran.h
@@ -31,6 +31,8 @@
 #ifndef _BUZ_H_
 #define _BUZ_H_
 
+#include <media/v4l2-device.h>
+
 struct zoran_requestbuffers {
         unsigned long count;    /* Number of buffers for MJPEG grabbing */
         unsigned long size;     /* Size PER BUFFER in bytes */
@@ -339,7 +341,12 @@ struct zoran_fh {
 struct card_info {
         enum card_type type;
         char name[32];
-        u16 i2c_decoder, i2c_encoder;                   /* I2C types */
+        const char *i2c_decoder;        /* i2c decoder device */
+        const char *mod_decoder;        /* i2c decoder module */
+        const unsigned short *addrs_decoder;
+        const char *i2c_encoder;        /* i2c encoder device */
+        const char *mod_encoder;        /* i2c encoder module */
+        const unsigned short *addrs_encoder;
         u16 video_vfe, video_codec;                     /* videocodec types */
         u16 audio_chip;                                 /* audio type */
 
@@ -370,14 +377,15 @@ struct card_info {
 };
 
 struct zoran {
+        struct v4l2_device v4l2_dev;
         struct video_device *video_dev;
 
         struct i2c_adapter i2c_adapter; /* */
         struct i2c_algo_bit_data i2c_algo;      /* */
         u32 i2cbr;
 
-        struct i2c_client *decoder;     /* video decoder i2c client */
-        struct i2c_client *encoder;     /* video encoder i2c client */
+        struct v4l2_subdev *decoder;    /* video decoder sub-device */
+        struct v4l2_subdev *encoder;    /* video encoder sub-device */
 
         struct videocodec *codec;       /* video codec */
         struct videocodec *vfe; /* video front end */
@@ -481,6 +489,11 @@ struct zoran {
         wait_queue_head_t test_q;
 };
 
+static inline struct zoran *to_zoran(struct v4l2_device *v4l2_dev)
+{
+        return container_of(v4l2_dev, struct zoran, v4l2_dev);
+}
+
 /* There was something called _ALPHA_BUZ that used the PCI address instead of
  * the kernel iomapped address for btread/btwrite.  */
 #define btwrite(dat,adr)    writel((dat), zr->zr36057_mem+(adr))
diff --git a/drivers/media/video/zoran/zoran_card.c b/drivers/media/video/zoran/zoran_card.c
index 38166d40c71..0b64612e35b 100644
--- a/drivers/media/video/zoran/zoran_card.c
+++ b/drivers/media/video/zoran/zoran_card.c
@@ -332,47 +332,6 @@ avs6eyes_init (struct zoran *zr)
 }
 
 static char *
-i2cid_to_modulename (u16 i2c_id)
-{
-        char *name = NULL;
-
-        switch (i2c_id) {
-        case I2C_DRIVERID_SAA7110:
-                name = "saa7110";
-                break;
-        case I2C_DRIVERID_SAA711X:
-                name = "saa7115";
-                break;
-        case I2C_DRIVERID_SAA7185B:
-                name = "saa7185";
-                break;
-        case I2C_DRIVERID_ADV7170:
-                name = "adv7170";
-                break;
-        case I2C_DRIVERID_ADV7175:
-                name = "adv7175";
-                break;
-        case I2C_DRIVERID_BT819:
-                name = "bt819";
-                break;
-        case I2C_DRIVERID_BT856:
-                name = "bt856";
-                break;
-        case I2C_DRIVERID_BT866:
-                name = "bt866";
-                break;
-        case I2C_DRIVERID_VPX3220:
-                name = "vpx3220";
-                break;
-        case I2C_DRIVERID_KS0127:
-                name = "ks0127";
-                break;
-        }
-
-        return name;
-}
-
-static char *
 codecid_to_modulename (u16 codecid)
 {
         char *name = NULL;
@@ -422,11 +381,24 @@ static struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56+54, 788, 525, 480, 16 }
 static struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
 static struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
 
+static const unsigned short vpx3220_addrs[] = { 0x43, 0x47, I2C_CLIENT_END };
+static const unsigned short saa7110_addrs[] = { 0x4e, 0x4f, I2C_CLIENT_END };
+static const unsigned short saa7111_addrs[] = { 0x25, 0x24, I2C_CLIENT_END };
+static const unsigned short saa7114_addrs[] = { 0x21, 0x20, I2C_CLIENT_END };
+static const unsigned short adv717x_addrs[] = { 0x6a, 0x6b, 0x2a, 0x2b, I2C_CLIENT_END };
+static const unsigned short ks0127_addrs[] = { 0x6c, 0x6d, I2C_CLIENT_END };
+static const unsigned short saa7185_addrs[] = { 0x44, I2C_CLIENT_END };
+static const unsigned short bt819_addrs[] = { 0x45, I2C_CLIENT_END };
+static const unsigned short bt856_addrs[] = { 0x44, I2C_CLIENT_END };
+static const unsigned short bt866_addrs[] = { 0x44, I2C_CLIENT_END };
+
 static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         {
                 .type = DC10_old,
                 .name = "DC10(old)",
-                .i2c_decoder = I2C_DRIVERID_VPX3220,
+                .i2c_decoder = "vpx3220a",
+                .mod_decoder = "vpx3220",
+                .addrs_decoder = vpx3220_addrs,
                 .video_codec = CODEC_TYPE_ZR36050,
                 .video_vfe = CODEC_TYPE_ZR36016,
 
@@ -454,8 +426,12 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         }, {
                 .type = DC10_new,
                 .name = "DC10(new)",
-                .i2c_decoder = I2C_DRIVERID_SAA7110,
-                .i2c_encoder = I2C_DRIVERID_ADV7175,
+                .i2c_decoder = "saa7110",
+                .mod_decoder = "saa7110",
+                .addrs_decoder = saa7110_addrs,
+                .i2c_encoder = "adv7175",
+                .mod_encoder = "adv7175",
+                .addrs_encoder = adv717x_addrs,
                 .video_codec = CODEC_TYPE_ZR36060,
 
                 .inputs = 3,
@@ -481,8 +457,12 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         }, {
                 .type = DC10plus,
                 .name = "DC10plus",
-                .i2c_decoder = I2C_DRIVERID_SAA7110,
-                .i2c_encoder = I2C_DRIVERID_ADV7175,
+                .i2c_decoder = "saa7110",
+                .mod_decoder = "saa7110",
+                .addrs_decoder = saa7110_addrs,
+                .i2c_encoder = "adv7175",
+                .mod_encoder = "adv7175",
+                .addrs_encoder = adv717x_addrs,
                 .video_codec = CODEC_TYPE_ZR36060,
 
                 .inputs = 3,
@@ -509,8 +489,12 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         }, {
                 .type = DC30,
                 .name = "DC30",
-                .i2c_decoder = I2C_DRIVERID_VPX3220,
-                .i2c_encoder = I2C_DRIVERID_ADV7175,
+                .i2c_decoder = "vpx3220a",
+                .mod_decoder = "vpx3220",
+                .addrs_decoder = vpx3220_addrs,
+                .i2c_encoder = "adv7175",
+                .mod_encoder = "adv7175",
+                .addrs_encoder = adv717x_addrs,
                 .video_codec = CODEC_TYPE_ZR36050,
                 .video_vfe = CODEC_TYPE_ZR36016,
 
@@ -538,8 +522,12 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         }, {
                 .type = DC30plus,
                 .name = "DC30plus",
-                .i2c_decoder = I2C_DRIVERID_VPX3220,
-                .i2c_encoder = I2C_DRIVERID_ADV7175,
+                .i2c_decoder = "vpx3220a",
+                .mod_decoder = "vpx3220",
+                .addrs_decoder = vpx3220_addrs,
+                .i2c_encoder = "adv7175",
+                .mod_encoder = "adv7175",
+                .addrs_encoder = adv717x_addrs,
                 .video_codec = CODEC_TYPE_ZR36050,
                 .video_vfe = CODEC_TYPE_ZR36016,
 
@@ -567,8 +555,12 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         }, {
                 .type = LML33,
                 .name = "LML33",
-                .i2c_decoder = I2C_DRIVERID_BT819,
-                .i2c_encoder = I2C_DRIVERID_BT856,
+                .i2c_decoder = "bt819a",
+                .mod_decoder = "bt819",
+                .addrs_decoder = bt819_addrs,
+                .i2c_encoder = "bt856",
+                .mod_encoder = "bt856",
+                .addrs_encoder = bt856_addrs,
                 .video_codec = CODEC_TYPE_ZR36060,
 
                 .inputs = 2,
@@ -594,8 +586,12 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         }, {
                 .type = LML33R10,
                 .name = "LML33R10",
-                .i2c_decoder = I2C_DRIVERID_SAA711X,
-                .i2c_encoder = I2C_DRIVERID_ADV7170,
+                .i2c_decoder = "saa7114",
+                .mod_decoder = "saa7115",
+                .addrs_decoder = saa7114_addrs,
+                .i2c_encoder = "adv7170",
+                .mod_encoder = "adv7170",
+                .addrs_encoder = adv717x_addrs,
                 .video_codec = CODEC_TYPE_ZR36060,
 
                 .inputs = 2,
@@ -621,8 +617,12 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
         }, {
                 .type = BUZ,
                 .name = "Buz",
-                .i2c_decoder = I2C_DRIVERID_SAA711X,
-                .i2c_encoder = I2C_DRIVERID_SAA7185B,
+                .i2c_decoder = "saa7111",
+                .mod_decoder = "saa7115",
+                .addrs_decoder = saa7111_addrs,
+                .i2c_encoder = "saa7185",
+                .mod_encoder = "saa7185",
+                .addrs_encoder = saa7185_addrs,
                 .video_codec = CODEC_TYPE_ZR36060,
 
                 .inputs = 2,
@@ -650,8 +650,12 @@ static struct card_info zoran_cards[NUM_CARDS] __devinitdata = {
                 .name = "6-Eyes",
                 /* AverMedia chose not to brand the 6-Eyes. Thus it
                    can't be autodetected, and requires card=x. */
-                .i2c_decoder = I2C_DRIVERID_KS0127,
-                .i2c_encoder = I2C_DRIVERID_BT866,
+                .i2c_decoder = "ks0127",
+                .mod_decoder = "ks0127",
+                .addrs_decoder = ks0127_addrs,
+                .i2c_encoder = "bt866",
+                .mod_encoder = "bt866",
+                .addrs_encoder = bt866_addrs,
                 .video_codec = CODEC_TYPE_ZR36060,
 
                 .inputs = 10,
@@ -732,69 +736,6 @@ zoran_i2c_setscl (void *data,
         btwrite(zr->i2cbr, ZR36057_I2CBR);
 }
 
-static int
-zoran_i2c_client_register (struct i2c_client *client)
-{
-        struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
-        int res = 0;
-
-        dprintk(2,
-                KERN_DEBUG "%s: i2c_client_register() - driver id = %d\n",
-                ZR_DEVNAME(zr), client->driver->id);
-
-        mutex_lock(&zr->resource_lock);
-
-        if (zr->user > 0) {
-                /* we're already busy, so we keep a reference to
-                 * them... Could do a lot of stuff here, but this
-                 * is easiest. (Did I ever mention I'm a lazy ass?)
-                 */
-                res = -EBUSY;
-                goto clientreg_unlock_and_return;
-        }
-
-        if (client->driver->id == zr->card.i2c_decoder)
-                zr->decoder = client;
-        else if (client->driver->id == zr->card.i2c_encoder)
-                zr->encoder = client;
-        else {
-                res = -ENODEV;
-                goto clientreg_unlock_and_return;
-        }
-
-clientreg_unlock_and_return:
-        mutex_unlock(&zr->resource_lock);
-
-        return res;
-}
-
-static int
-zoran_i2c_client_unregister (struct i2c_client *client)
-{
-        struct zoran *zr = (struct zoran *) i2c_get_adapdata(client->adapter);
-        int res = 0;
-
-        dprintk(2, KERN_DEBUG "%s: i2c_client_unregister()\n", ZR_DEVNAME(zr));
-
-        mutex_lock(&zr->resource_lock);
-
-        if (zr->user > 0) {
-                res = -EBUSY;
-                goto clientunreg_unlock_and_return;
-        }
-
-        /* try to locate it */
-        if (client == zr->encoder) {
-                zr->encoder = NULL;
-        } else if (client == zr->decoder) {
-                zr->decoder = NULL;
-                snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%d]", zr->id);
-        }
-clientunreg_unlock_and_return:
-        mutex_unlock(&zr->resource_lock);
-        return res;
-}
-
 static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
         .setsda = zoran_i2c_setsda,
         .setscl = zoran_i2c_setscl,
@@ -810,13 +751,10 @@ zoran_register_i2c (struct zoran *zr)
         memcpy(&zr->i2c_algo, &zoran_i2c_bit_data_template,
                sizeof(struct i2c_algo_bit_data));
         zr->i2c_algo.data = zr;
-        zr->i2c_adapter.class = I2C_CLASS_TV_ANALOG;
         zr->i2c_adapter.id = I2C_HW_B_ZR36067;
-        zr->i2c_adapter.client_register = zoran_i2c_client_register;
-        zr->i2c_adapter.client_unregister = zoran_i2c_client_unregister;
         strlcpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
                 sizeof(zr->i2c_adapter.name));
-        i2c_set_adapdata(&zr->i2c_adapter, zr);
+        i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
         zr->i2c_adapter.algo_data = &zr->i2c_algo;
         zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
         return i2c_bit_add_bus(&zr->i2c_adapter);
@@ -1173,8 +1111,8 @@ zr36057_init (struct zoran *zr)
         if (!pass_through) {
                 struct v4l2_routing route = { 2, 0 };
 
-                decoder_command(zr, VIDIOC_STREAMOFF, 0);
-                encoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+                decoder_call(zr, video, s_stream, 0);
+                encoder_call(zr, video, s_routing, &route);
         }
 
         zr->zoran_proc = NULL;
@@ -1189,7 +1127,8 @@ exit_free:
 
 static void __devexit zoran_remove(struct pci_dev *pdev)
 {
-        struct zoran *zr = pci_get_drvdata(pdev);
+        struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
+        struct zoran *zr = to_zoran(v4l2_dev);
 
         if (!zr->initialized)
                 goto exit_free;
@@ -1222,7 +1161,7 @@ static void __devexit zoran_remove(struct pci_dev *pdev)
         pci_disable_device(zr->pci_dev);
         video_unregister_device(zr->video_dev);
 exit_free:
-        pci_set_drvdata(pdev, NULL);
+        v4l2_device_unregister(&zr->v4l2_dev);
         kfree(zr);
 }
 
@@ -1294,7 +1233,7 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
         struct videocodec_master *master_vfe = NULL;
         struct videocodec_master *master_codec = NULL;
         int card_num;
-        char *i2c_enc_name, *i2c_dec_name, *codec_name, *vfe_name;
+        char *codec_name, *vfe_name;
         unsigned int nr;
 
 
@@ -1315,13 +1254,15 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
                         ZORAN_NAME);
                 return -ENOMEM;
         }
+        if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
+                goto zr_free_mem;
         zr->pci_dev = pdev;
         zr->id = nr;
         snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
         spin_lock_init(&zr->spinlock);
         mutex_init(&zr->resource_lock);
         if (pci_enable_device(pdev))
-                goto zr_free_mem;
+                goto zr_unreg;
         pci_read_config_byte(zr->pci_dev, PCI_CLASS_REVISION, &zr->revision);
 
         dprintk(1,
@@ -1348,7 +1289,7 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
                                 KERN_ERR
                                 "%s: It is not possible to auto-detect ZR36057 based cards\n",
                                 ZR_DEVNAME(zr));
-                        goto zr_free_mem;
+                        goto zr_unreg;
                 }
 
                 card_num = ent->driver_data;
@@ -1357,7 +1298,7 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
                                 KERN_ERR
                                 "%s: Unknown card, try specifying card=X module parameter\n",
                                 ZR_DEVNAME(zr));
-                        goto zr_free_mem;
+                        goto zr_unreg;
                 }
                 dprintk(3,
                         KERN_DEBUG
@@ -1370,7 +1311,7 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
                                 KERN_ERR
                                 "%s: User specified card type %d out of range (0 .. %d)\n",
                                 ZR_DEVNAME(zr), card_num, NUM_CARDS - 1);
-                        goto zr_free_mem;
+                        goto zr_unreg;
                 }
         }
 
@@ -1389,7 +1330,7 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
                         KERN_ERR
                         "%s: %s() - ioremap failed\n",
                         ZR_DEVNAME(zr), __func__);
-                goto zr_free_mem;
+                goto zr_unreg;
         }
 
         result = request_irq(zr->pci_dev->irq, zoran_irq,
@@ -1432,46 +1373,6 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
         dprintk(2, KERN_INFO "%s: Initializing i2c bus...\n",
                 ZR_DEVNAME(zr));
 
-        /* i2c decoder */
-        if (decoder[zr->id] != -1) {
-                i2c_dec_name = i2cid_to_modulename(decoder[zr->id]);
-                zr->card.i2c_decoder = decoder[zr->id];
-        } else if (zr->card.i2c_decoder != 0) {
-                i2c_dec_name = i2cid_to_modulename(zr->card.i2c_decoder);
-        } else {
-                i2c_dec_name = NULL;
-        }
-
-        if (i2c_dec_name) {
-                result = request_module(i2c_dec_name);
-                if (result < 0) {
-                        dprintk(1,
-                                KERN_ERR
-                                "%s: failed to load module %s: %d\n",
-                                ZR_DEVNAME(zr), i2c_dec_name, result);
-                }
-        }
-
-        /* i2c encoder */
-        if (encoder[zr->id] != -1) {
-                i2c_enc_name = i2cid_to_modulename(encoder[zr->id]);
-                zr->card.i2c_encoder = encoder[zr->id];
-        } else if (zr->card.i2c_encoder != 0) {
-                i2c_enc_name = i2cid_to_modulename(zr->card.i2c_encoder);
-        } else {
-                i2c_enc_name = NULL;
-        }
-
-        if (i2c_enc_name) {
-                result = request_module(i2c_enc_name);
-                if (result < 0) {
-                        dprintk(1,
-                                KERN_ERR
-                                "%s: failed to load module %s: %d\n",
-                                ZR_DEVNAME(zr), i2c_enc_name, result);
-                }
-        }
-
         if (zoran_register_i2c(zr) < 0) {
                 dprintk(1,
                         KERN_ERR
@@ -1480,6 +1381,14 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
                 goto zr_free_irq;
         }
 
+        zr->decoder = v4l2_i2c_new_probed_subdev(&zr->i2c_adapter,
+                zr->card.mod_decoder, zr->card.i2c_decoder, zr->card.addrs_decoder);
+
+        if (zr->card.mod_encoder)
+                zr->encoder = v4l2_i2c_new_probed_subdev(&zr->i2c_adapter,
+                        zr->card.mod_encoder, zr->card.i2c_encoder,
+                        zr->card.addrs_encoder);
+
         dprintk(2,
                 KERN_INFO "%s: Initializing videocodec bus...\n",
                 ZR_DEVNAME(zr));
@@ -1569,8 +1478,6 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
 
         zoran_proc_init(zr);
 
-        pci_set_drvdata(pdev, zr);
-
         return 0;
 
 zr_detach_vfe:
@@ -1588,6 +1495,8 @@ zr_free_irq:
         free_irq(zr->pci_dev->irq, zr);
 zr_unmap:
         iounmap(zr->zr36057_mem);
+zr_unreg:
+        v4l2_device_unregister(&zr->v4l2_dev);
 zr_free_mem:
         kfree(zr);
 
diff --git a/drivers/media/video/zoran/zoran_device.c b/drivers/media/video/zoran/zoran_device.c
index 712599a5ed7..3336611c0cd 100644
--- a/drivers/media/video/zoran/zoran_device.c
+++ b/drivers/media/video/zoran/zoran_device.c
@@ -36,15 +36,12 @@
 #include <linux/proc_fs.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
-#include <linux/videodev.h>
 #include <linux/videodev2.h>
 #include <media/v4l2-common.h>
 #include <linux/spinlock.h>
 #include <linux/sem.h>
 
 #include <linux/pci.h>
-#include <linux/video_decoder.h>
-#include <linux/video_encoder.h>
 #include <linux/delay.h>
 #include <linux/wait.h>
 
@@ -1000,9 +997,9 @@ zr36057_enable_jpg (struct zoran          *zr,
                  * the video bus direction set to input.
                  */
                 set_videobus_dir(zr, 0);
-                decoder_command(zr, VIDIOC_STREAMON, 0);
+                decoder_call(zr, video, s_stream, 1);
                 route.input = 0;
-                encoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+                encoder_call(zr, video, s_routing, &route);
 
                 /* Take the JPEG codec and the VFE out of sleep */
                 jpeg_codec_sleep(zr, 0);
@@ -1048,10 +1045,10 @@ zr36057_enable_jpg (struct zoran          *zr,
                 /* In motion decompression mode, the decoder output must be disabled, and
                  * the video bus direction set to output.
                  */
-                decoder_command(zr, VIDIOC_STREAMOFF, 0);
+                decoder_call(zr, video, s_stream, 0);
                 set_videobus_dir(zr, 1);
                 route.input = 1;
-                encoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+                encoder_call(zr, video, s_routing, &route);
 
                 /* Take the JPEG codec and the VFE out of sleep */
                 jpeg_codec_sleep(zr, 0);
@@ -1095,9 +1092,9 @@ zr36057_enable_jpg (struct zoran          *zr,
                 jpeg_codec_sleep(zr, 1);
                 zr36057_adjust_vfe(zr, mode);
 
-                decoder_command(zr, VIDIOC_STREAMON, 0);
+                decoder_call(zr, video, s_stream, 1);
                 route.input = 0;
-                encoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+                encoder_call(zr, video, s_routing, &route);
 
                 dprintk(2, KERN_INFO "%s: enable_jpg(IDLE)\n", ZR_DEVNAME(zr));
                 break;
@@ -1210,7 +1207,7 @@ static void zoran_restart(struct zoran *zr)
         int status = 0, mode;
 
         if (zr->codec_mode == BUZ_MODE_MOTION_COMPRESS) {
-                decoder_command(zr, VIDIOC_INT_G_INPUT_STATUS, &status);
+                decoder_call(zr, video, g_input_status, &status);
                 mode = CODEC_DO_COMPRESSION;
         } else {
                 status = V4L2_IN_ST_NO_SIGNAL;
@@ -1590,14 +1587,14 @@ zoran_init_hardware (struct zoran *zr)
 
         route.input = zr->card.input[zr->input].muxsel;
 
-        decoder_command(zr, VIDIOC_INT_INIT, NULL);
-        decoder_command(zr, VIDIOC_S_STD, &zr->norm);
-        decoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+        decoder_call(zr, core, init, 0);
+        decoder_s_std(zr, zr->norm);
+        decoder_s_routing(zr, &route);
 
-        encoder_command(zr, VIDIOC_INT_INIT, NULL);
-        encoder_command(zr, VIDIOC_INT_S_STD_OUTPUT, &zr->norm);
+        encoder_call(zr, core, init, 0);
+        encoder_call(zr, video, s_std_output, zr->norm);
         route.input = 0;
-        encoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+        encoder_call(zr, video, s_routing, &route);
 
         /* toggle JPEG codec sleep to sync PLL */
         jpeg_codec_sleep(zr, 1);
@@ -1662,37 +1659,30 @@ zr36057_init_vfe (struct zoran *zr)
  * Interface to decoder and encoder chips using i2c bus
  */
 
-int
-decoder_command (struct zoran *zr,
-                 int           cmd,
-                 void         *data)
+int decoder_s_std(struct zoran *zr, v4l2_std_id std)
 {
-        if (zr->decoder == NULL)
-                return -EIO;
-
-        if (zr->card.type == LML33 &&
-            (cmd == VIDIOC_S_STD || cmd == VIDIOC_INT_S_VIDEO_ROUTING)) {
-                int res;
+        int res;
 
-                // Bt819 needs to reset its FIFO buffer using #FRST pin and
-                // LML33 card uses GPIO(7) for that.
+        /* Bt819 needs to reset its FIFO buffer using #FRST pin and
+           LML33 card uses GPIO(7) for that. */
+        if (zr->card.type == LML33)
                 GPIO(zr, 7, 0);
-                res = zr->decoder->driver->command(zr->decoder, cmd, data);
-                // Pull #FRST high.
-                GPIO(zr, 7, 1);
-                return res;
-        } else
-                return zr->decoder->driver->command(zr->decoder, cmd,
-                                                    data);
+        res = decoder_call(zr, tuner, s_std, std);
+        if (zr->card.type == LML33)
+                GPIO(zr, 7, 1); /* Pull #FRST high. */
+        return res;
 }
 
-int
-encoder_command (struct zoran *zr,
-                 int           cmd,
-                 void         *data)
+int decoder_s_routing(struct zoran *zr, struct v4l2_routing *route)
 {
-        if (zr->encoder == NULL)
-                return -1;
+        int res;
 
-        return zr->encoder->driver->command(zr->encoder, cmd, data);
+        /* Bt819 needs to reset its FIFO buffer using #FRST pin and
+           LML33 card uses GPIO(7) for that. */
+        if (zr->card.type == LML33)
+                GPIO(zr, 7, 0);
+        res = decoder_call(zr, video, s_routing, route);
+        if (zr->card.type == LML33)
+                GPIO(zr, 7, 1); /* Pull #FRST high. */
+        return res;
 }
diff --git a/drivers/media/video/zoran/zoran_device.h b/drivers/media/video/zoran/zoran_device.h
index 74c6c8edb7d..14d4e7aa6ce 100644
--- a/drivers/media/video/zoran/zoran_device.h
+++ b/drivers/media/video/zoran/zoran_device.h
@@ -87,11 +87,12 @@ extern int jpg_bufsize;
 extern int pass_through;
 
 /* i2c */
-extern int decoder_command(struct zoran *zr,
-                           int cmd,
-                           void *data);
-extern int encoder_command(struct zoran *zr,
-                           int cmd,
-                           void *data);
+#define decoder_call(zr, o, f, args...) \
+        v4l2_subdev_call(zr->decoder, o, f, ##args)
+#define encoder_call(zr, o, f, args...) \
+        v4l2_subdev_call(zr->encoder, o, f, ##args)
+
+int decoder_s_std(struct zoran *zr, v4l2_std_id std);
+int decoder_s_routing(struct zoran *zr, struct v4l2_routing *route);
 
 #endif                          /* __ZORAN_DEVICE_H__ */
diff --git a/drivers/media/video/zoran/zoran_driver.c b/drivers/media/video/zoran/zoran_driver.c
index 611fc7f18e1..b027a68e8c6 100644
--- a/drivers/media/video/zoran/zoran_driver.c
+++ b/drivers/media/video/zoran/zoran_driver.c
@@ -963,10 +963,6 @@ static int zoran_open(struct file *file)
 
         lock_kernel();
 
-        /* see fs/device.c - the kernel already locks during open(),
-         * so locking ourselves only causes deadlocks */
-        /*mutex_lock(&zr->resource_lock);*/
-
         if (zr->user >= 2048) {
                 dprintk(1, KERN_ERR "%s: too many users (%d) on device\n",
                         ZR_DEVNAME(zr), zr->user);
@@ -974,32 +970,6 @@ static int zoran_open(struct file *file)
                 goto fail_unlock;
         }
 
-        if (!zr->decoder) {
-                dprintk(1,
-                        KERN_ERR "%s: no TV decoder loaded for device!\n",
-                        ZR_DEVNAME(zr));
-                res = -EIO;
-                goto fail_unlock;
-        }
-
-        if (!try_module_get(zr->decoder->driver->driver.owner)) {
-                dprintk(1,
-                        KERN_ERR
-                        "%s: failed to grab ownership of video decoder\n",
-                        ZR_DEVNAME(zr));
-                res = -EIO;
-                goto fail_unlock;
-        }
-        if (zr->encoder &&
-            !try_module_get(zr->encoder->driver->driver.owner)) {
-                dprintk(1,
-                        KERN_ERR
-                        "%s: failed to grab ownership of video encoder\n",
-                        ZR_DEVNAME(zr));
-                res = -EIO;
-                goto fail_decoder;
-        }
-
         /* now, create the open()-specific file_ops struct */
         fh = kzalloc(sizeof(struct zoran_fh), GFP_KERNEL);
         if (!fh) {
@@ -1008,7 +978,7 @@ static int zoran_open(struct file *file)
                         "%s: zoran_open() - allocation of zoran_fh failed\n",
                         ZR_DEVNAME(zr));
                 res = -ENOMEM;
-                goto fail_encoder;
+                goto fail_unlock;
         }
         /* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows
          * on norm-change! */
@@ -1047,11 +1017,6 @@ static int zoran_open(struct file *file)
 
 fail_fh:
         kfree(fh);
-fail_encoder:
-        if (zr->encoder)
-                module_put(zr->encoder->driver->driver.owner);
-fail_decoder:
-        module_put(zr->decoder->driver->driver.owner);
 fail_unlock:
         unlock_kernel();
 
@@ -1104,8 +1069,8 @@ zoran_close(struct file  *file)
                 if (!pass_through) {    /* Switch to color bar */
                         struct v4l2_routing route = { 2, 0 };
 
-                        decoder_command(zr, VIDIOC_STREAMOFF, 0);
-                        encoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+                        decoder_call(zr, video, s_stream, 0);
+                        encoder_call(zr, video, s_routing, &route);
                 }
         }
 
@@ -1113,13 +1078,6 @@ zoran_close(struct file  *file)
         kfree(fh->overlay_mask);
         kfree(fh);
 
-        /* release locks on the i2c modules */
-        module_put(zr->decoder->driver->driver.owner);
-        if (zr->encoder)
-                module_put(zr->encoder->driver->driver.owner);
-
-        /*mutex_unlock(&zr->resource_lock);*/
-
         dprintk(4, KERN_INFO "%s: zoran_close() done\n", ZR_DEVNAME(zr));
 
         return 0;
@@ -1567,20 +1525,20 @@ zoran_set_norm (struct zoran *zr,
                 int status = 0;
                 v4l2_std_id std = 0;
 
-                decoder_command(zr, VIDIOC_QUERYSTD, &std);
-                decoder_command(zr, VIDIOC_S_STD, &std);
+                decoder_call(zr, video, querystd, &std);
+                decoder_s_std(zr, std);
 
                 /* let changes come into effect */
                 ssleep(2);
 
-                decoder_command(zr, VIDIOC_INT_G_INPUT_STATUS, &status);
+                decoder_call(zr, video, g_input_status, &status);
                 if (status & V4L2_IN_ST_NO_SIGNAL) {
                         dprintk(1,
                                 KERN_ERR
                                 "%s: set_norm() - no norm detected\n",
                                 ZR_DEVNAME(zr));
                         /* reset norm */
-                        decoder_command(zr, VIDIOC_S_STD, &zr->norm);
+                        decoder_s_std(zr, zr->norm);
                         return -EIO;
                 }
 
@@ -1599,8 +1557,8 @@ zoran_set_norm (struct zoran *zr,
         if (on)
                 zr36057_overlay(zr, 0);
 
-        decoder_command(zr, VIDIOC_S_STD, &norm);
-        encoder_command(zr, VIDIOC_INT_S_STD_OUTPUT, &norm);
+        decoder_s_std(zr, norm);
+        encoder_call(zr, video, s_std_output, norm);
 
         if (on)
                 zr36057_overlay(zr, 1);
@@ -1641,7 +1599,7 @@ zoran_set_input (struct zoran *zr,
         route.input = zr->card.input[input].muxsel;
         zr->input = input;
 
-        decoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+        decoder_s_routing(zr, &route);
 
         return 0;
 }
@@ -1886,18 +1844,18 @@ jpgreqbuf_unlock_and_return:
                         goto gstat_unlock_and_return;
                 }
 
-                decoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+                decoder_s_routing(zr, &route);
 
                 /* sleep 1 second */
                 ssleep(1);
 
                 /* Get status of video decoder */
-                decoder_command(zr, VIDIOC_QUERYSTD, &norm);
-                decoder_command(zr, VIDIOC_INT_G_INPUT_STATUS, &status);
+                decoder_call(zr, video, querystd, &norm);
+                decoder_call(zr, video, g_input_status, &status);
 
                 /* restore previous input and norm */
                 route.input = zr->card.input[zr->input].muxsel;
-                decoder_command(zr, VIDIOC_INT_S_VIDEO_ROUTING, &route);
+                decoder_s_routing(zr, &route);
 gstat_unlock_and_return:
                 mutex_unlock(&zr->resource_lock);
 
@@ -2836,7 +2794,7 @@ static int zoran_queryctrl(struct file *file, void *__fh,
             ctrl->id > V4L2_CID_HUE)
                 return -EINVAL;
 
-        decoder_command(zr, VIDIOC_QUERYCTRL, ctrl);
+        decoder_call(zr, core, queryctrl, ctrl);
 
         return 0;
 }
@@ -2852,7 +2810,7 @@ static int zoran_g_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl
                 return -EINVAL;
 
         mutex_lock(&zr->resource_lock);
-        decoder_command(zr, VIDIOC_G_CTRL, ctrl);
+        decoder_call(zr, core, g_ctrl, ctrl);
         mutex_unlock(&zr->resource_lock);
 
         return 0;
@@ -2869,7 +2827,7 @@ static int zoran_s_ctrl(struct file *file, void *__fh, struct v4l2_control *ctrl
                 return -EINVAL;
 
         mutex_lock(&zr->resource_lock);
-        decoder_command(zr, VIDIOC_S_CTRL, ctrl);
+        decoder_call(zr, core, s_ctrl, ctrl);
         mutex_unlock(&zr->resource_lock);
 
         return 0;
@@ -2924,7 +2882,7 @@ static int zoran_enum_input(struct file *file, void *__fh,
 
         /* Get status of video decoder */
         mutex_lock(&zr->resource_lock);
-        decoder_command(zr, VIDIOC_INT_G_INPUT_STATUS, &inp->status);
+        decoder_call(zr, video, g_input_status, &inp->status);
         mutex_unlock(&zr->resource_lock);
         return 0;
 }