V4L/DVB (10488): ivtv: cleanup naming conventions

Use consistent naming for pci_dev, v4l2_device and video_device.

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

15 files changed, 129 insertions, 130 deletions

diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index c46c990987f..eca8bf92a22 100644
--- a/drivers/media/video/ivtv/ivtv-driver.c
+++ b/drivers/media/video/ivtv/ivtv-driver.c
@@ -357,7 +357,7 @@ void ivtv_read_eeprom(struct ivtv *itv, struct tveeprom *tv)
 static void ivtv_process_eeprom(struct ivtv *itv)
 {
         struct tveeprom tv;
-        int pci_slot = PCI_SLOT(itv->dev->devfn);
+        int pci_slot = PCI_SLOT(itv->pdev->devfn);
 
         ivtv_read_eeprom(itv, &tv);
 
@@ -604,7 +604,7 @@ static void ivtv_process_options(struct ivtv *itv)
         itv->std = ivtv_parse_std(itv);
         if (itv->std == 0 && tunertype >= 0)
                 itv->std = tunertype ? V4L2_STD_MN : (V4L2_STD_ALL & ~V4L2_STD_MN);
-        itv->has_cx23415 = (itv->dev->device == PCI_DEVICE_ID_IVTV15);
+        itv->has_cx23415 = (itv->pdev->device == PCI_DEVICE_ID_IVTV15);
         chipname = itv->has_cx23415 ? "cx23415" : "cx23416";
         if (itv->options.cardtype == -1) {
                 IVTV_INFO("Ignore card (detected %s based chip)\n", chipname);
@@ -617,9 +617,9 @@ static void ivtv_process_options(struct ivtv *itv)
                 IVTV_ERR("Unknown user specified type, trying to autodetect card\n");
         }
         if (itv->card == NULL) {
-                if (itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
-                    itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
-                    itv->dev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
+                if (itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE ||
+                    itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT1 ||
+                    itv->pdev->subsystem_vendor == IVTV_PCI_ID_HAUPPAUGE_ALT2) {
                         itv->card = ivtv_get_card(itv->has_cx23415 ? IVTV_CARD_PVR_350 : IVTV_CARD_PVR_150);
                         IVTV_INFO("Autodetected Hauppauge card (%s based)\n",
                                         chipname);
@@ -630,13 +630,13 @@ static void ivtv_process_options(struct ivtv *itv)
                         if (itv->card->pci_list == NULL)
                                 continue;
                         for (j = 0; itv->card->pci_list[j].device; j++) {
-                                if (itv->dev->device !=
+                                if (itv->pdev->device !=
                                     itv->card->pci_list[j].device)
                                         continue;
-                                if (itv->dev->subsystem_vendor !=
+                                if (itv->pdev->subsystem_vendor !=
                                     itv->card->pci_list[j].subsystem_vendor)
                                         continue;
-                                if (itv->dev->subsystem_device !=
+                                if (itv->pdev->subsystem_device !=
                                     itv->card->pci_list[j].subsystem_device)
                                         continue;
                                 IVTV_INFO("Autodetected %s card (%s based)\n",
@@ -650,9 +650,9 @@ done:
         if (itv->card == NULL) {
                 itv->card = ivtv_get_card(IVTV_CARD_PVR_150);
                 IVTV_ERR("Unknown card: vendor/device: [%04x:%04x]\n",
-                     itv->dev->vendor, itv->dev->device);
+                     itv->pdev->vendor, itv->pdev->device);
                 IVTV_ERR("              subsystem vendor/device: [%04x:%04x]\n",
-                     itv->dev->subsystem_vendor, itv->dev->subsystem_device);
+                     itv->pdev->subsystem_vendor, itv->pdev->subsystem_device);
                 IVTV_ERR("              %s based\n", chipname);
                 IVTV_ERR("Defaulting to %s card\n", itv->card->name);
                 IVTV_ERR("Please mail the vendor/device and subsystem vendor/device IDs and what kind of\n");
@@ -671,7 +671,7 @@ done:
  */
 static int __devinit ivtv_init_struct1(struct ivtv *itv)
 {
-        itv->base_addr = pci_resource_start(itv->dev, 0);
+        itv->base_addr = pci_resource_start(itv->pdev, 0);
         itv->enc_mbox.max_mbox = 2; /* the encoder has 3 mailboxes (0-2) */
         itv->dec_mbox.max_mbox = 1; /* the decoder has 2 mailboxes (0-1) */
 
@@ -682,7 +682,7 @@ static int __devinit ivtv_init_struct1(struct ivtv *itv)
         spin_lock_init(&itv->lock);
         spin_lock_init(&itv->dma_reg_lock);
 
-        itv->irq_work_queues = create_singlethread_workqueue(itv->device.name);
+        itv->irq_work_queues = create_singlethread_workqueue(itv->v4l2_dev.name);
         if (itv->irq_work_queues == NULL) {
                 IVTV_ERR("Could not create ivtv workqueue\n");
                 return -1;
@@ -766,7 +766,7 @@ static void __devinit ivtv_init_struct2(struct ivtv *itv)
         itv->audio_input = itv->card->video_inputs[i].audio_index;
 }
 
-static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
+static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *pdev,
                           const struct pci_device_id *pci_id)
 {
         u16 cmd;
@@ -775,11 +775,11 @@ static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
 
         IVTV_DEBUG_INFO("Enabling pci device\n");
 
-        if (pci_enable_device(dev)) {
+        if (pci_enable_device(pdev)) {
                 IVTV_ERR("Can't enable device!\n");
                 return -EIO;
         }
-        if (pci_set_dma_mask(dev, 0xffffffff)) {
+        if (pci_set_dma_mask(pdev, 0xffffffff)) {
                 IVTV_ERR("No suitable DMA available.\n");
                 return -EIO;
         }
@@ -805,11 +805,11 @@ static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
         }
 
         /* Check for bus mastering */
-        pci_read_config_word(dev, PCI_COMMAND, &cmd);
+        pci_read_config_word(pdev, PCI_COMMAND, &cmd);
         if (!(cmd & PCI_COMMAND_MASTER)) {
                 IVTV_DEBUG_INFO("Attempting to enable Bus Mastering\n");
-                pci_set_master(dev);
-                pci_read_config_word(dev, PCI_COMMAND, &cmd);
+                pci_set_master(pdev);
+                pci_read_config_word(pdev, PCI_COMMAND, &cmd);
                 if (!(cmd & PCI_COMMAND_MASTER)) {
                         IVTV_ERR("Bus Mastering is not enabled\n");
                         return -ENXIO;
@@ -817,26 +817,26 @@ static int ivtv_setup_pci(struct ivtv *itv, struct pci_dev *dev,
         }
         IVTV_DEBUG_INFO("Bus Mastering Enabled.\n");
 
-        pci_read_config_byte(dev, PCI_CLASS_REVISION, &card_rev);
-        pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
+        pci_read_config_byte(pdev, PCI_CLASS_REVISION, &card_rev);
+        pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
 
         if (pci_latency < 64 && ivtv_pci_latency) {
                 IVTV_INFO("Unreasonably low latency timer, "
                                "setting to 64 (was %d)\n", pci_latency);
-                pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
-                pci_read_config_byte(dev, PCI_LATENCY_TIMER, &pci_latency);
+                pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
+                pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
         }
         /* This config space value relates to DMA latencies. The
            default value 0x8080 is too low however and will lead
            to DMA errors. 0xffff is the max value which solves
            these problems. */
-        pci_write_config_dword(dev, 0x40, 0xffff);
+        pci_write_config_dword(pdev, 0x40, 0xffff);
 
         IVTV_DEBUG_INFO("%d (rev %d) at %02x:%02x.%x, "
                    "irq: %d, latency: %d, memory: 0x%lx\n",
-                   itv->dev->device, card_rev, dev->bus->number,
-                   PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
-                   itv->dev->irq, pci_latency, (unsigned long)itv->base_addr);
+                   pdev->device, card_rev, pdev->bus->number,
+                   PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
+                   pdev->irq, pci_latency, (unsigned long)itv->base_addr);
 
         return 0;
 }
@@ -935,7 +935,7 @@ static void ivtv_load_and_init_modules(struct ivtv *itv)
         }
 }
 
-static int __devinit ivtv_probe(struct pci_dev *dev,
+static int __devinit ivtv_probe(struct pci_dev *pdev,
                                 const struct pci_device_id *pci_id)
 {
         int retval = 0;
@@ -945,17 +945,17 @@ static int __devinit ivtv_probe(struct pci_dev *dev,
         itv = kzalloc(sizeof(struct ivtv), GFP_ATOMIC);
         if (itv == NULL)
                 return -ENOMEM;
-        itv->dev = dev;
+        itv->pdev = pdev;
         itv->instance = atomic_inc_return(&ivtv_instance) - 1;
 
-        retval = v4l2_device_register(&dev->dev, &itv->device);
+        retval = v4l2_device_register(&pdev->dev, &itv->v4l2_dev);
         if (retval) {
                 kfree(itv);
                 return retval;
         }
         /* "ivtv + PCI ID" is a bit of a mouthful, so use
            "ivtv + instance" instead. */
-        snprintf(itv->device.name, sizeof(itv->device.name),
+        snprintf(itv->v4l2_dev.name, sizeof(itv->v4l2_dev.name),
                         "ivtv%d", itv->instance);
         IVTV_INFO("Initializing card %d\n", itv->instance);
 
@@ -972,12 +972,11 @@ static int __devinit ivtv_probe(struct pci_dev *dev,
         IVTV_DEBUG_INFO("base addr: 0x%08x\n", itv->base_addr);
 
         /* PCI Device Setup */
-        if ((retval = ivtv_setup_pci(itv, dev, pci_id)) != 0) {
-                if (retval == -EIO)
-                        goto free_workqueue;
-                else if (retval == -ENXIO)
-                        goto free_mem;
-        }
+        retval = ivtv_setup_pci(itv, pdev, pci_id);
+        if (retval == -EIO)
+                goto free_workqueue;
+        if (retval == -ENXIO)
+                goto free_mem;
 
         /* map io memory */
         IVTV_DEBUG_INFO("attempting ioremap at 0x%08x len 0x%08x\n",
@@ -1154,8 +1153,8 @@ static int __devinit ivtv_probe(struct pci_dev *dev,
         ivtv_set_irq_mask(itv, 0xffffffff);
 
         /* Register IRQ */
-        retval = request_irq(itv->dev->irq, ivtv_irq_handler,
-             IRQF_SHARED | IRQF_DISABLED, itv->device.name, (void *)itv);
+        retval = request_irq(itv->pdev->irq, ivtv_irq_handler,
+             IRQF_SHARED | IRQF_DISABLED, itv->v4l2_dev.name, (void *)itv);
         if (retval) {
                 IVTV_ERR("Failed to register irq %d\n", retval);
                 goto free_i2c;
@@ -1177,7 +1176,7 @@ static int __devinit ivtv_probe(struct pci_dev *dev,
 free_streams:
         ivtv_streams_cleanup(itv, 1);
 free_irq:
-        free_irq(itv->dev->irq, (void *)itv);
+        free_irq(itv->pdev->irq, (void *)itv);
 free_i2c:
         exit_ivtv_i2c(itv);
 free_io:
@@ -1194,7 +1193,7 @@ err:
                 retval = -ENODEV;
         IVTV_ERR("Error %d on initialization\n", retval);
 
-        v4l2_device_unregister(&itv->device);
+        v4l2_device_unregister(&itv->v4l2_dev);
         kfree(itv);
         return retval;
 }
@@ -1292,10 +1291,10 @@ int ivtv_init_on_first_open(struct ivtv *itv)
         return 0;
 }
 
-static void ivtv_remove(struct pci_dev *pci_dev)
+static void ivtv_remove(struct pci_dev *pdev)
 {
-        struct v4l2_device *dev = dev_get_drvdata(&pci_dev->dev);
-        struct ivtv *itv = to_ivtv(dev);
+        struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
+        struct ivtv *itv = to_ivtv(v4l2_dev);
         int i;
 
         IVTV_DEBUG_INFO("Removing card\n");
@@ -1336,11 +1335,9 @@ static void ivtv_remove(struct pci_dev *pci_dev)
         ivtv_streams_cleanup(itv, 1);
         ivtv_udma_free(itv);
 
-        v4l2_device_unregister(&itv->device);
-
         exit_ivtv_i2c(itv);
 
-        free_irq(itv->dev->irq, (void *)itv);
+        free_irq(itv->pdev->irq, (void *)itv);
         ivtv_iounmap(itv);
 
         release_mem_region(itv->base_addr, IVTV_ENCODER_SIZE);
@@ -1348,11 +1345,13 @@ static void ivtv_remove(struct pci_dev *pci_dev)
         if (itv->has_cx23415)
                 release_mem_region(itv->base_addr + IVTV_DECODER_OFFSET, IVTV_DECODER_SIZE);
 
-        pci_disable_device(itv->dev);
+        pci_disable_device(itv->pdev);
         for (i = 0; i < IVTV_VBI_FRAMES; i++)
                 kfree(itv->vbi.sliced_mpeg_data[i]);
 
         printk(KERN_INFO "ivtv: Removed %s\n", itv->card_name);
+
+        v4l2_device_unregister(&itv->v4l2_dev);
         kfree(itv);
 }
 
diff --git a/drivers/media/video/ivtv/ivtv-driver.h b/drivers/media/video/ivtv/ivtv-driver.h
index 94f7f44d598..440f7328a7e 100644
--- a/drivers/media/video/ivtv/ivtv-driver.h
+++ b/drivers/media/video/ivtv/ivtv-driver.h
@@ -133,7 +133,7 @@ extern int ivtv_debug;
 #define IVTV_DEBUG(x, type, fmt, args...) \
         do { \
                 if ((x) & ivtv_debug) \
-                        v4l2_info(&itv->device, " " type ": " fmt , ##args);    \
+                        v4l2_info(&itv->v4l2_dev, " " type ": " fmt , ##args);  \
         } while (0)
 #define IVTV_DEBUG_WARN(fmt, args...)  IVTV_DEBUG(IVTV_DBGFLG_WARN,  "warn",  fmt , ## args)
 #define IVTV_DEBUG_INFO(fmt, args...)  IVTV_DEBUG(IVTV_DBGFLG_INFO,  "info",  fmt , ## args)
@@ -149,7 +149,7 @@ extern int ivtv_debug;
 #define IVTV_DEBUG_HIGH_VOL(x, type, fmt, args...) \
         do { \
                 if (((x) & ivtv_debug) && (ivtv_debug & IVTV_DBGFLG_HIGHVOL))   \
-                        v4l2_info(&itv->device, " " type ": " fmt , ##args);    \
+                        v4l2_info(&itv->v4l2_dev, " " type ": " fmt , ##args);  \
         } while (0)
 #define IVTV_DEBUG_HI_WARN(fmt, args...)  IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_WARN,  "warn",  fmt , ## args)
 #define IVTV_DEBUG_HI_INFO(fmt, args...)  IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_INFO,  "info",  fmt , ## args)
@@ -163,9 +163,9 @@ extern int ivtv_debug;
 #define IVTV_DEBUG_HI_YUV(fmt, args...)   IVTV_DEBUG_HIGH_VOL(IVTV_DBGFLG_YUV,   "yuv",   fmt , ## args)
 
 /* Standard kernel messages */
-#define IVTV_ERR(fmt, args...)      v4l2_err(&itv->device, fmt , ## args)
-#define IVTV_WARN(fmt, args...)     v4l2_warn(&itv->device, fmt , ## args)
-#define IVTV_INFO(fmt, args...)     v4l2_info(&itv->device, fmt , ## args)
+#define IVTV_ERR(fmt, args...)      v4l2_err(&itv->v4l2_dev, fmt , ## args)
+#define IVTV_WARN(fmt, args...)     v4l2_warn(&itv->v4l2_dev, fmt , ## args)
+#define IVTV_INFO(fmt, args...)     v4l2_info(&itv->v4l2_dev, fmt , ## args)
 
 /* output modes (cx23415 only) */
 #define OUT_NONE        0
@@ -315,7 +315,7 @@ struct ivtv;				/* forward reference */
 struct ivtv_stream {
         /* These first four fields are always set, even if the stream
            is not actually created. */
-        struct video_device *v4l2dev;   /* NULL when stream not created */
+        struct video_device *vdev;      /* NULL when stream not created */
         struct ivtv *itv;               /* for ease of use */
         const char *name;               /* name of the stream */
         int type;                       /* stream type */
@@ -592,7 +592,7 @@ struct ivtv_card;
 /* Struct to hold info about ivtv cards */
 struct ivtv {
         /* General fixed card data */
-        struct pci_dev *dev;            /* PCI device */
+        struct pci_dev *pdev;           /* PCI device */
         const struct ivtv_card *card;   /* card information */
         const char *card_name;          /* full name of the card */
         const struct ivtv_card_tuner_i2c *card_i2c; /* i2c addresses to probe for tuner */
@@ -612,7 +612,7 @@ struct ivtv {
         volatile void __iomem *reg_mem; /* pointer to mapped registers */
         struct ivtv_options options;    /* user options */
 
-        struct v4l2_device device;
+        struct v4l2_device v4l2_dev;
         struct v4l2_subdev sd_gpio;     /* GPIO sub-device */
         u16 instance;
 
@@ -719,9 +719,9 @@ struct ivtv {
         struct osd_info *osd_info;      /* ivtvfb private OSD info */
 };
 
-static inline struct ivtv *to_ivtv(struct v4l2_device *dev)
+static inline struct ivtv *to_ivtv(struct v4l2_device *v4l2_dev)
 {
-        return container_of(dev, struct ivtv, device);
+        return container_of(v4l2_dev, struct ivtv, v4l2_dev);
 }
 
 /* Globals */
@@ -788,7 +788,7 @@ static inline int ivtv_raw_vbi(const struct ivtv *itv)
 /* Call the specified callback for all subdevs matching hw (if 0, then
    match them all). Ignore any errors. */
 #define ivtv_call_hw(itv, hw, o, f, args...)                            \
-        __v4l2_device_call_subdevs(&(itv)->device, !(hw) || (sd->grp_id & (hw)), o, f , ##args)
+        __v4l2_device_call_subdevs(&(itv)->v4l2_dev, !(hw) || (sd->grp_id & (hw)), o, f , ##args)
 
 #define ivtv_call_all(itv, o, f, args...) ivtv_call_hw(itv, 0, o, f , ##args)
 
@@ -796,7 +796,7 @@ static inline int ivtv_raw_vbi(const struct ivtv *itv)
    match them all). If the callback returns an error other than 0 or
    -ENOIOCTLCMD, then return with that error code. */
 #define ivtv_call_hw_err(itv, hw, o, f, args...)                \
-        __v4l2_device_call_subdevs_until_err(&(itv)->device, !(hw) || (sd->grp_id & (hw)), o, f , ##args)
+        __v4l2_device_call_subdevs_until_err(&(itv)->v4l2_dev, !(hw) || (sd->grp_id & (hw)), o, f , ##args)
 
 #define ivtv_call_all_err(itv, o, f, args...) ivtv_call_hw_err(itv, 0, o, f , ##args)
 
diff --git a/drivers/media/video/ivtv/ivtv-fileops.c b/drivers/media/video/ivtv/ivtv-fileops.c
index 617667d1ceb..cfaacf6096d 100644
--- a/drivers/media/video/ivtv/ivtv-fileops.c
+++ b/drivers/media/video/ivtv/ivtv-fileops.c
@@ -991,7 +991,7 @@ int ivtv_v4l2_open(struct file *filp)
         mutex_lock(&itv->serialize_lock);
         if (ivtv_init_on_first_open(itv)) {
                 IVTV_ERR("Failed to initialize on minor %d\n",
-                                s->v4l2dev->minor);
+                                vdev->minor);
                 mutex_unlock(&itv->serialize_lock);
                 return -ENXIO;
         }
diff --git a/drivers/media/video/ivtv/ivtv-firmware.c b/drivers/media/video/ivtv/ivtv-firmware.c
index 6dba55b7e25..c1b7ec475c2 100644
--- a/drivers/media/video/ivtv/ivtv-firmware.c
+++ b/drivers/media/video/ivtv/ivtv-firmware.c
@@ -52,7 +52,7 @@ static int load_fw_direct(const char *fn, volatile u8 __iomem *mem, struct ivtv
         int retries = 3;
 
 retry:
-        if (retries && request_firmware(&fw, fn, &itv->dev->dev) == 0) {
+        if (retries && request_firmware(&fw, fn, &itv->pdev->dev) == 0) {
                 int i;
                 volatile u32 __iomem *dst = (volatile u32 __iomem *)mem;
                 const u32 *src = (const u32 *)fw->data;
diff --git a/drivers/media/video/ivtv/ivtv-gpio.c b/drivers/media/video/ivtv/ivtv-gpio.c
index dc2850e87a7..3321983d89e 100644
--- a/drivers/media/video/ivtv/ivtv-gpio.c
+++ b/drivers/media/video/ivtv/ivtv-gpio.c
@@ -384,7 +384,7 @@ int ivtv_gpio_init(struct ivtv *itv)
         write_reg(itv->card->gpio_init.initial_value | pin, IVTV_REG_GPIO_OUT);
         write_reg(itv->card->gpio_init.direction | pin, IVTV_REG_GPIO_DIR);
         v4l2_subdev_init(&itv->sd_gpio, &subdev_ops);
-        snprintf(itv->sd_gpio.name, sizeof(itv->sd_gpio.name), "%s-gpio", itv->device.name);
+        snprintf(itv->sd_gpio.name, sizeof(itv->sd_gpio.name), "%s-gpio", itv->v4l2_dev.name);
         itv->sd_gpio.grp_id = IVTV_HW_GPIO;
-        return v4l2_device_register_subdev(&itv->device, &itv->sd_gpio);
+        return v4l2_device_register_subdev(&itv->v4l2_dev, &itv->sd_gpio);
 }
diff --git a/drivers/media/video/ivtv/ivtv-i2c.c b/drivers/media/video/ivtv/ivtv-i2c.c
index ca1d9557945..e73a196ecc7 100644
--- a/drivers/media/video/ivtv/ivtv-i2c.c
+++ b/drivers/media/video/ivtv/ivtv-i2c.c
@@ -194,14 +194,14 @@ struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw)
         struct v4l2_subdev *result = NULL;
         struct v4l2_subdev *sd;
 
-        spin_lock(&itv->device.lock);
-        v4l2_device_for_each_subdev(sd, &itv->device) {
+        spin_lock(&itv->v4l2_dev.lock);
+        v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) {
                 if (sd->grp_id == hw) {
                         result = sd;
                         break;
                 }
         }
-        spin_unlock(&itv->device.lock);
+        spin_unlock(&itv->v4l2_dev.lock);
         return result;
 }
 
@@ -472,8 +472,8 @@ static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data,
    intervening stop condition */
 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
 {
-        struct v4l2_device *drv = i2c_get_adapdata(i2c_adap);
-        struct ivtv *itv = to_ivtv(drv);
+        struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
+        struct ivtv *itv = to_ivtv(v4l2_dev);
         int retval;
         int i;
 
@@ -604,12 +604,12 @@ int init_ivtv_i2c(struct ivtv *itv)
 
         sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
                 itv->instance);
-        i2c_set_adapdata(&itv->i2c_adap, &itv->device);
+        i2c_set_adapdata(&itv->i2c_adap, &itv->v4l2_dev);
 
         memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
                sizeof(struct i2c_client));
         itv->i2c_client.adapter = &itv->i2c_adap;
-        itv->i2c_adap.dev.parent = &itv->dev->dev;
+        itv->i2c_adap.dev.parent = &itv->pdev->dev;
 
         IVTV_DEBUG_I2C("setting scl and sda to 1\n");
         ivtv_setscl(itv, 1);
diff --git a/drivers/media/video/ivtv/ivtv-ioctl.c b/drivers/media/video/ivtv/ivtv-ioctl.c
index e8621da26d8..9a0424298af 100644
--- a/drivers/media/video/ivtv/ivtv-ioctl.c
+++ b/drivers/media/video/ivtv/ivtv-ioctl.c
@@ -770,7 +770,7 @@ static int ivtv_querycap(struct file *file, void *fh, struct v4l2_capability *vc
 
         strlcpy(vcap->driver, IVTV_DRIVER_NAME, sizeof(vcap->driver));
         strlcpy(vcap->card, itv->card_name, sizeof(vcap->card));
-        snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->dev));
+        snprintf(vcap->bus_info, sizeof(vcap->bus_info), "PCI:%s", pci_name(itv->pdev));
         vcap->version = IVTV_DRIVER_VERSION;        /* version */
         vcap->capabilities = itv->v4l2_cap;         /* capabilities */
         return 0;
@@ -1517,12 +1517,12 @@ static int ivtv_log_status(struct file *file, void *fh)
         }
         IVTV_INFO("Tuner:  %s\n",
                 test_bit(IVTV_F_I_RADIO_USER, &itv->i_flags) ? "Radio" : "TV");
-        cx2341x_log_status(&itv->params, itv->device.name);
+        cx2341x_log_status(&itv->params, itv->v4l2_dev.name);
         IVTV_INFO("Status flags:    0x%08lx\n", itv->i_flags);
         for (i = 0; i < IVTV_MAX_STREAMS; i++) {
                 struct ivtv_stream *s = &itv->streams[i];
 
-                if (s->v4l2dev == NULL || s->buffers == 0)
+                if (s->vdev == NULL || s->buffers == 0)
                         continue;
                 IVTV_INFO("Stream %s: status 0x%04lx, %d%% of %d KiB (%d buffers) in use\n", s->name, s->s_flags,
                                 (s->buffers - s->q_free.buffers) * 100 / s->buffers,
diff --git a/drivers/media/video/ivtv/ivtv-irq.c b/drivers/media/video/ivtv/ivtv-irq.c
index f5d00ec5da7..01c14d2b381 100644
--- a/drivers/media/video/ivtv/ivtv-irq.c
+++ b/drivers/media/video/ivtv/ivtv-irq.c
@@ -46,7 +46,7 @@ static void ivtv_pio_work_handler(struct ivtv *itv)
 
         IVTV_DEBUG_HI_DMA("ivtv_pio_work_handler\n");
         if (itv->cur_pio_stream < 0 || itv->cur_pio_stream >= IVTV_MAX_STREAMS ||
-                        s->v4l2dev == NULL || !ivtv_use_pio(s)) {
+                        s->vdev == NULL || !ivtv_use_pio(s)) {
                 itv->cur_pio_stream = -1;
                 /* trigger PIO complete user interrupt */
                 write_reg(IVTV_IRQ_ENC_PIO_COMPLETE, 0x44);
@@ -109,7 +109,7 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
         int rc;
 
         /* sanity checks */
-        if (s->v4l2dev == NULL) {
+        if (s->vdev == NULL) {
                 IVTV_DEBUG_WARN("Stream %s not started\n", s->name);
                 return -1;
         }
diff --git a/drivers/media/video/ivtv/ivtv-queue.c b/drivers/media/video/ivtv/ivtv-queue.c
index 71bd13e22e2..ff7b7deded4 100644
--- a/drivers/media/video/ivtv/ivtv-queue.c
+++ b/drivers/media/video/ivtv/ivtv-queue.c
@@ -230,7 +230,7 @@ int ivtv_stream_alloc(struct ivtv_stream *s)
                 return -ENOMEM;
         }
         if (ivtv_might_use_dma(s)) {
-                s->sg_handle = pci_map_single(itv->dev, s->sg_dma, sizeof(struct ivtv_sg_element), s->dma);
+                s->sg_handle = pci_map_single(itv->pdev, s->sg_dma, sizeof(struct ivtv_sg_element), s->dma);
                 ivtv_stream_sync_for_cpu(s);
         }
 
@@ -248,7 +248,7 @@ int ivtv_stream_alloc(struct ivtv_stream *s)
                 }
                 INIT_LIST_HEAD(&buf->list);
                 if (ivtv_might_use_dma(s)) {
-                        buf->dma_handle = pci_map_single(s->itv->dev,
+                        buf->dma_handle = pci_map_single(s->itv->pdev,
                                 buf->buf, s->buf_size + 256, s->dma);
                         ivtv_buf_sync_for_cpu(s, buf);
                 }
@@ -271,7 +271,7 @@ void ivtv_stream_free(struct ivtv_stream *s)
         /* empty q_free */
         while ((buf = ivtv_dequeue(s, &s->q_free))) {
                 if (ivtv_might_use_dma(s))
-                        pci_unmap_single(s->itv->dev, buf->dma_handle,
+                        pci_unmap_single(s->itv->pdev, buf->dma_handle,
                                 s->buf_size + 256, s->dma);
                 kfree(buf->buf);
                 kfree(buf);
@@ -280,7 +280,7 @@ void ivtv_stream_free(struct ivtv_stream *s)
         /* Free SG Array/Lists */
         if (s->sg_dma != NULL) {
                 if (s->sg_handle != IVTV_DMA_UNMAPPED) {
-                        pci_unmap_single(s->itv->dev, s->sg_handle,
+                        pci_unmap_single(s->itv->pdev, s->sg_handle,
                                  sizeof(struct ivtv_sg_element), PCI_DMA_TODEVICE);
                         s->sg_handle = IVTV_DMA_UNMAPPED;
                 }
diff --git a/drivers/media/video/ivtv/ivtv-queue.h b/drivers/media/video/ivtv/ivtv-queue.h
index 476556afd39..91233839a26 100644
--- a/drivers/media/video/ivtv/ivtv-queue.h
+++ b/drivers/media/video/ivtv/ivtv-queue.h
@@ -53,14 +53,14 @@ static inline int ivtv_use_dma(struct ivtv_stream *s)
 static inline void ivtv_buf_sync_for_cpu(struct ivtv_stream *s, struct ivtv_buffer *buf)
 {
         if (ivtv_use_dma(s))
-                pci_dma_sync_single_for_cpu(s->itv->dev, buf->dma_handle,
+                pci_dma_sync_single_for_cpu(s->itv->pdev, buf->dma_handle,
                                 s->buf_size + 256, s->dma);
 }
 
 static inline void ivtv_buf_sync_for_device(struct ivtv_stream *s, struct ivtv_buffer *buf)
 {
         if (ivtv_use_dma(s))
-                pci_dma_sync_single_for_device(s->itv->dev, buf->dma_handle,
+                pci_dma_sync_single_for_device(s->itv->pdev, buf->dma_handle,
                                 s->buf_size + 256, s->dma);
 }
 
@@ -82,14 +82,14 @@ void ivtv_stream_free(struct ivtv_stream *s);
 static inline void ivtv_stream_sync_for_cpu(struct ivtv_stream *s)
 {
         if (ivtv_use_dma(s))
-                pci_dma_sync_single_for_cpu(s->itv->dev, s->sg_handle,
+                pci_dma_sync_single_for_cpu(s->itv->pdev, s->sg_handle,
                         sizeof(struct ivtv_sg_element), PCI_DMA_TODEVICE);
 }
 
 static inline void ivtv_stream_sync_for_device(struct ivtv_stream *s)
 {
         if (ivtv_use_dma(s))
-                pci_dma_sync_single_for_device(s->itv->dev, s->sg_handle,
+                pci_dma_sync_single_for_device(s->itv->pdev, s->sg_handle,
                         sizeof(struct ivtv_sg_element), PCI_DMA_TODEVICE);
 }
 
diff --git a/drivers/media/video/ivtv/ivtv-streams.c b/drivers/media/video/ivtv/ivtv-streams.c
index 854a950af78..15da01710ef 100644
--- a/drivers/media/video/ivtv/ivtv-streams.c
+++ b/drivers/media/video/ivtv/ivtv-streams.c
@@ -137,11 +137,11 @@ static struct {
 static void ivtv_stream_init(struct ivtv *itv, int type)
 {
         struct ivtv_stream *s = &itv->streams[type];
-        struct video_device *dev = s->v4l2dev;
+        struct video_device *vdev = s->vdev;
 
-        /* we need to keep v4l2dev, so restore it afterwards */
+        /* we need to keep vdev, so restore it afterwards */
         memset(s, 0, sizeof(*s));
-        s->v4l2dev = dev;
+        s->vdev = vdev;
 
         /* initialize ivtv_stream fields */
         s->itv = itv;
@@ -172,10 +172,10 @@ static int ivtv_prep_dev(struct ivtv *itv, int type)
         int num_offset = ivtv_stream_info[type].num_offset;
         int num = itv->instance + ivtv_first_minor + num_offset;
 
-        /* These four fields are always initialized. If v4l2dev == NULL, then
+        /* These four fields are always initialized. If vdev == NULL, then
            this stream is not in use. In that case no other fields but these
            four can be used. */
-        s->v4l2dev = NULL;
+        s->vdev = NULL;
         s->itv = itv;
         s->type = type;
         s->name = ivtv_stream_info[type].name;
@@ -197,21 +197,21 @@ static int ivtv_prep_dev(struct ivtv *itv, int type)
         ivtv_stream_init(itv, type);
 
         /* allocate and initialize the v4l2 video device structure */
-        s->v4l2dev = video_device_alloc();
-        if (s->v4l2dev == NULL) {
+        s->vdev = video_device_alloc();
+        if (s->vdev == NULL) {
                 IVTV_ERR("Couldn't allocate v4l2 video_device for %s\n", s->name);
                 return -ENOMEM;
         }
 
-        snprintf(s->v4l2dev->name, sizeof(s->v4l2dev->name), "%s %s",
-                        itv->device.name, s->name);
+        snprintf(s->vdev->name, sizeof(s->vdev->name), "%s %s",
+                        itv->v4l2_dev.name, s->name);
 
-        s->v4l2dev->num = num;
-        s->v4l2dev->v4l2_dev = &itv->device;
-        s->v4l2dev->fops = ivtv_stream_info[type].fops;
-        s->v4l2dev->release = video_device_release;
-        s->v4l2dev->tvnorms = V4L2_STD_ALL;
-        ivtv_set_funcs(s->v4l2dev);
+        s->vdev->num = num;
+        s->vdev->v4l2_dev = &itv->v4l2_dev;
+        s->vdev->fops = ivtv_stream_info[type].fops;
+        s->vdev->release = video_device_release;
+        s->vdev->tvnorms = V4L2_STD_ALL;
+        ivtv_set_funcs(s->vdev);
         return 0;
 }
 
@@ -226,7 +226,7 @@ int ivtv_streams_setup(struct ivtv *itv)
                 if (ivtv_prep_dev(itv, type))
                         break;
 
-                if (itv->streams[type].v4l2dev == NULL)
+                if (itv->streams[type].vdev == NULL)
                         continue;
 
                 /* Allocate Stream */
@@ -247,28 +247,28 @@ static int ivtv_reg_dev(struct ivtv *itv, int type)
         int vfl_type = ivtv_stream_info[type].vfl_type;
         int num;
 
-        if (s->v4l2dev == NULL)
+        if (s->vdev == NULL)
                 return 0;
 
-        num = s->v4l2dev->num;
+        num = s->vdev->num;
         /* card number + user defined offset + device offset */
         if (type != IVTV_ENC_STREAM_TYPE_MPG) {
                 struct ivtv_stream *s_mpg = &itv->streams[IVTV_ENC_STREAM_TYPE_MPG];
 
-                if (s_mpg->v4l2dev)
-                        num = s_mpg->v4l2dev->num + ivtv_stream_info[type].num_offset;
+                if (s_mpg->vdev)
+                        num = s_mpg->vdev->num + ivtv_stream_info[type].num_offset;
         }
-        video_set_drvdata(s->v4l2dev, s);
+        video_set_drvdata(s->vdev, s);
 
         /* Register device. First try the desired minor, then any free one. */
-        if (video_register_device(s->v4l2dev, vfl_type, num)) {
+        if (video_register_device(s->vdev, vfl_type, num)) {
                 IVTV_ERR("Couldn't register v4l2 device for %s kernel number %d\n",
                                 s->name, num);
-                video_device_release(s->v4l2dev);
-                s->v4l2dev = NULL;
+                video_device_release(s->vdev);
+                s->vdev = NULL;
                 return -ENOMEM;
         }
-        num = s->v4l2dev->num;
+        num = s->vdev->num;
 
         switch (vfl_type) {
         case VFL_TYPE_GRABBER:
@@ -316,9 +316,9 @@ void ivtv_streams_cleanup(struct ivtv *itv, int unregister)
 
         /* Teardown all streams */
         for (type = 0; type < IVTV_MAX_STREAMS; type++) {
-                struct video_device *vdev = itv->streams[type].v4l2dev;
+                struct video_device *vdev = itv->streams[type].vdev;
 
-                itv->streams[type].v4l2dev = NULL;
+                itv->streams[type].vdev = NULL;
                 if (vdev == NULL)
                         continue;
 
@@ -449,7 +449,7 @@ int ivtv_start_v4l2_encode_stream(struct ivtv_stream *s)
         int captype = 0, subtype = 0;
         int enable_passthrough = 0;
 
-        if (s->v4l2dev == NULL)
+        if (s->vdev == NULL)
                 return -EINVAL;
 
         IVTV_DEBUG_INFO("Start encoder stream %s\n", s->name);
@@ -611,7 +611,7 @@ static int ivtv_setup_v4l2_decode_stream(struct ivtv_stream *s)
         struct cx2341x_mpeg_params *p = &itv->params;
         int datatype;
 
-        if (s->v4l2dev == NULL)
+        if (s->vdev == NULL)
                 return -EINVAL;
 
         IVTV_DEBUG_INFO("Setting some initial decoder settings\n");
@@ -657,7 +657,7 @@ int ivtv_start_v4l2_decode_stream(struct ivtv_stream *s, int gop_offset)
 {
         struct ivtv *itv = s->itv;
 
-        if (s->v4l2dev == NULL)
+        if (s->vdev == NULL)
                 return -EINVAL;
 
         if (test_and_set_bit(IVTV_F_S_STREAMING, &s->s_flags))
@@ -705,7 +705,7 @@ void ivtv_stop_all_captures(struct ivtv *itv)
         for (i = IVTV_MAX_STREAMS - 1; i >= 0; i--) {
                 struct ivtv_stream *s = &itv->streams[i];
 
-                if (s->v4l2dev == NULL)
+                if (s->vdev == NULL)
                         continue;
                 if (test_bit(IVTV_F_S_STREAMING, &s->s_flags)) {
                         ivtv_stop_v4l2_encode_stream(s, 0);
@@ -720,7 +720,7 @@ int ivtv_stop_v4l2_encode_stream(struct ivtv_stream *s, int gop_end)
         int cap_type;
         int stopmode;
 
-        if (s->v4l2dev == NULL)
+        if (s->vdev == NULL)
                 return -EINVAL;
 
         /* This function assumes that you are allowed to stop the capture
@@ -834,7 +834,7 @@ int ivtv_stop_v4l2_decode_stream(struct ivtv_stream *s, int flags, u64 pts)
 {
         struct ivtv *itv = s->itv;
 
-        if (s->v4l2dev == NULL)
+        if (s->vdev == NULL)
                 return -EINVAL;
 
         if (s->type != IVTV_DEC_STREAM_TYPE_YUV && s->type != IVTV_DEC_STREAM_TYPE_MPG)
@@ -895,7 +895,7 @@ int ivtv_passthrough_mode(struct ivtv *itv, int enable)
         struct ivtv_stream *yuv_stream = &itv->streams[IVTV_ENC_STREAM_TYPE_YUV];
         struct ivtv_stream *dec_stream = &itv->streams[IVTV_DEC_STREAM_TYPE_YUV];
 
-        if (yuv_stream->v4l2dev == NULL || dec_stream->v4l2dev == NULL)
+        if (yuv_stream->vdev == NULL || dec_stream->vdev == NULL)
                 return -EINVAL;
 
         IVTV_DEBUG_INFO("ivtv ioctl: Select passthrough mode\n");
diff --git a/drivers/media/video/ivtv/ivtv-udma.c b/drivers/media/video/ivtv/ivtv-udma.c
index 460db03b0ba..d07ad6c3902 100644
--- a/drivers/media/video/ivtv/ivtv-udma.c
+++ b/drivers/media/video/ivtv/ivtv-udma.c
@@ -93,7 +93,7 @@ void ivtv_udma_alloc(struct ivtv *itv)
 {
         if (itv->udma.SG_handle == 0) {
                 /* Map DMA Page Array Buffer */
-                itv->udma.SG_handle = pci_map_single(itv->dev, itv->udma.SGarray,
+                itv->udma.SG_handle = pci_map_single(itv->pdev, itv->udma.SGarray,
                            sizeof(itv->udma.SGarray), PCI_DMA_TODEVICE);
                 ivtv_udma_sync_for_cpu(itv);
         }
@@ -147,7 +147,7 @@ int ivtv_udma_setup(struct ivtv *itv, unsigned long ivtv_dest_addr,
         }
 
         /* Map SG List */
-        dma->SG_length = pci_map_sg(itv->dev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE);
+        dma->SG_length = pci_map_sg(itv->pdev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE);
 
         /* Fill SG Array with new values */
         ivtv_udma_fill_sg_array (dma, ivtv_dest_addr, 0, -1);
@@ -172,7 +172,7 @@ void ivtv_udma_unmap(struct ivtv *itv)
 
         /* Unmap Scatterlist */
         if (dma->SG_length) {
-                pci_unmap_sg(itv->dev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE);
+                pci_unmap_sg(itv->pdev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE);
                 dma->SG_length = 0;
         }
         /* sync DMA */
@@ -191,13 +191,13 @@ void ivtv_udma_free(struct ivtv *itv)
 
         /* Unmap SG Array */
         if (itv->udma.SG_handle) {
-                pci_unmap_single(itv->dev, itv->udma.SG_handle,
+                pci_unmap_single(itv->pdev, itv->udma.SG_handle,
                          sizeof(itv->udma.SGarray), PCI_DMA_TODEVICE);
         }
 
         /* Unmap Scatterlist */
         if (itv->udma.SG_length) {
-                pci_unmap_sg(itv->dev, itv->udma.SGlist, itv->udma.page_count, PCI_DMA_TODEVICE);
+                pci_unmap_sg(itv->pdev, itv->udma.SGlist, itv->udma.page_count, PCI_DMA_TODEVICE);
         }
 
         for (i = 0; i < IVTV_DMA_SG_OSD_ENT; i++) {
diff --git a/drivers/media/video/ivtv/ivtv-udma.h b/drivers/media/video/ivtv/ivtv-udma.h
index df727e23be0..ee3c9efb5b7 100644
--- a/drivers/media/video/ivtv/ivtv-udma.h
+++ b/drivers/media/video/ivtv/ivtv-udma.h
@@ -35,13 +35,13 @@ void ivtv_udma_start(struct ivtv *itv);
 
 static inline void ivtv_udma_sync_for_device(struct ivtv *itv)
 {
-        pci_dma_sync_single_for_device((struct pci_dev *)itv->dev, itv->udma.SG_handle,
+        pci_dma_sync_single_for_device(itv->pdev, itv->udma.SG_handle,
                 sizeof(itv->udma.SGarray), PCI_DMA_TODEVICE);
 }
 
 static inline void ivtv_udma_sync_for_cpu(struct ivtv *itv)
 {
-        pci_dma_sync_single_for_cpu((struct pci_dev *)itv->dev, itv->udma.SG_handle,
+        pci_dma_sync_single_for_cpu(itv->pdev, itv->udma.SG_handle,
                 sizeof(itv->udma.SGarray), PCI_DMA_TODEVICE);
 }
 
diff --git a/drivers/media/video/ivtv/ivtv-yuv.c b/drivers/media/video/ivtv/ivtv-yuv.c
index ee91107376c..7912ed6b72e 100644
--- a/drivers/media/video/ivtv/ivtv-yuv.c
+++ b/drivers/media/video/ivtv/ivtv-yuv.c
@@ -103,7 +103,7 @@ static int ivtv_yuv_prep_user_dma(struct ivtv *itv, struct ivtv_user_dma *dma,
                 dma->page_count = 0;
                 return -ENOMEM;
         }
-        dma->SG_length = pci_map_sg(itv->dev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE);
+        dma->SG_length = pci_map_sg(itv->pdev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE);
 
         /* Fill SG Array with new values */
         ivtv_udma_fill_sg_array(dma, y_buffer_offset, uv_buffer_offset, y_size);
@@ -910,7 +910,7 @@ static void ivtv_yuv_init(struct ivtv *itv)
         /* We need a buffer for blanking when Y plane is offset - non-fatal if we can't get one */
         yi->blanking_ptr = kzalloc(720 * 16, GFP_KERNEL|__GFP_NOWARN);
         if (yi->blanking_ptr) {
-                yi->blanking_dmaptr = pci_map_single(itv->dev, yi->blanking_ptr, 720*16, PCI_DMA_TODEVICE);
+                yi->blanking_dmaptr = pci_map_single(itv->pdev, yi->blanking_ptr, 720*16, PCI_DMA_TODEVICE);
         } else {
                 yi->blanking_dmaptr = 0;
                 IVTV_DEBUG_WARN("Failed to allocate yuv blanking buffer\n");
@@ -1237,7 +1237,7 @@ void ivtv_yuv_close(struct ivtv *itv)
         if (yi->blanking_ptr) {
                 kfree(yi->blanking_ptr);
                 yi->blanking_ptr = NULL;
-                pci_unmap_single(itv->dev, yi->blanking_dmaptr, 720*16, PCI_DMA_TODEVICE);
+                pci_unmap_single(itv->pdev, yi->blanking_dmaptr, 720*16, PCI_DMA_TODEVICE);
         }
 
         /* Invalidate the old dimension information */
diff --git a/drivers/media/video/ivtv/ivtvfb.c b/drivers/media/video/ivtv/ivtvfb.c
index 36abd2aef6f..66e6eb51307 100644
--- a/drivers/media/video/ivtv/ivtvfb.c
+++ b/drivers/media/video/ivtv/ivtvfb.c
@@ -1192,12 +1192,12 @@ static int ivtvfb_init_card(struct ivtv *itv)
 static int __init ivtvfb_callback_init(struct device *dev, void *p)
 {
         struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
-        struct ivtv *itv = container_of(v4l2_dev, struct ivtv, device);
+        struct ivtv *itv = container_of(v4l2_dev, struct ivtv, v4l2_dev);
 
         if (itv && (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
                 if (ivtvfb_init_card(itv) == 0) {
                         IVTVFB_INFO("Framebuffer registered on %s\n",
-                                        itv->device.name);
+                                        itv->v4l2_dev.name);
                         (*(int *)p)++;
                 }
         }
@@ -1207,7 +1207,7 @@ static int __init ivtvfb_callback_init(struct device *dev, void *p)
 static int ivtvfb_callback_cleanup(struct device *dev, void *p)
 {
         struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
-        struct ivtv *itv = container_of(v4l2_dev, struct ivtv, device);
+        struct ivtv *itv = container_of(v4l2_dev, struct ivtv, v4l2_dev);
 
         if (itv && (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) {
                 if (unregister_framebuffer(&itv->osd_info->ivtvfb_info)) {