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>
This commit is contained in:
Hans Verkuil
Mauro Carvalho Chehab
parent
d7493e518f
commit
8ac05ae319
15 changed files with 129 additions and 130 deletions
|
|
@ -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 @@ static void ivtv_process_options(struct ivtv *itv)
|
|||
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 @@ static void ivtv_process_options(struct ivtv *itv)
|
|||
*/
|
||||
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 @@ static int __devinit ivtv_probe(struct pci_dev *dev,
|
|||
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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
|
|
|
|||
|
|
@ -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++) {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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)) {
|
||||
|
|
|
|||
Loading…
Reference in a new issue