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>

diff --git a/drivers/media/video/ivtv/ivtv-driver.c b/drivers/media/video/ivtv/ivtv-driver.c
index c46c990987f9b417a263e51782eb0ec3915b05a0..eca8bf92a225c3e7236717302ff3228ff81a77bc 100644 (file)
--- 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 94f7f44d59894f5b7633915224564fd201a490b6..440f7328a7eda1aacb6bb1416f7c58718572d87d 100644 (file)
--- 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 617667d1ceba9c8f769790cf3cd18237d45d4563..cfaacf6096d00735f7703f66fd5c282b592d54d8 100644 (file)
--- 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 6dba55b7e25aea7cd5892869edf36f72598238f7..c1b7ec475c27cc1813c2a89dd42a8a807e6c04c4 100644 (file)
--- 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 dc2850e87a7e1b1106b8da0a8eac50b9363c0ce6..3321983d89e55124516801296fd9caeaa81b88dc 100644 (file)
--- 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 ca1d9557945eef807310b8dbaad09bab69d9a674..e73a196ecc7ac88f9518a9c0539cf0defcbe198f 100644 (file)
--- 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 e8621da26d808dab39f7e53351717c8bcabd7281..9a0424298af1452c30562c730ef10f4f85d96279 100644 (file)
--- 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 f5d00ec5da73501cb2b99ad93404b9b5dc63a881..01c14d2b381a3111ab9db4389aa8ce09a8dd4757 100644 (file)
--- 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 71bd13e22e2ee20a5f6d27c2a4bceda494fd6d61..ff7b7deded4f5108def042ffc8e6cdf665982201 100644 (file)
--- 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 476556afd39aa2bc99c8f3b4cee03d91d07a0fd8..91233839a26c7747b298a5b2523e43e87455da26 100644 (file)
--- 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 854a950af78c757ae95ff9f8a39a6a7a6f1d3ede..15da01710efc61f044d5ba6854b406135fd174ee 100644 (file)
--- 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 460db03b0ba061477ae321038378f99b08c6b61e..d07ad6c39024774c11cb41c14f451d57b52c6f6d 100644 (file)
--- 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 df727e23be0a4719a57c2e6698821c46a8c1cf3e..ee3c9efb5b727d0ae86b24c9bdb251f3692a6a77 100644 (file)
--- 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 ee91107376c75440ca56f6620924724a2267c5ab..7912ed6b72eec0e70a4028cfefc66efe04dbb1d8 100644 (file)
--- 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 36abd2aef6f1473b6ff90948bb3235de5941ddbd..66e6eb513076a8073831bacdc462e34955c9d885 100644 (file)
--- 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)) {