forge/linux-pinenote
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

V4L/DVB (12540): v4l: simplify v4l2_i2c_new_subdev and friends

Browse source 
Rewrite v4l2_i2c_new_subdev as a simplified version of v4l2_i2c_new_subdev_cfg
and remove v4l2_i2c_new_probed_subdev and v4l2_i2c_new_probed_subdev_addr.

This simplifies this API substantially.

Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Hans Verkuil 2009-08-10 02:49:08 -03:00 • committed by Mauro Carvalho Chehab
parent 0da2808ca2
commit 53dacb1570
23 changed files with 129 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

16
Documentation/video4linux/v4l2-framework.txt
View file

@ -370,19 +370,20 @@ from the remove() callback ensures that this is always done correctly.
The bridge driver also has some helper functions it can use: The bridge driver also has some helper functions it can use:
struct v4l2_subdev *sd = v4l2_i2c_new_subdev(v4l2_dev, adapter, struct v4l2_subdev *sd = v4l2_i2c_new_subdev(v4l2_dev, adapter,
"module_foo", "chipid", 0x36); "module_foo", "chipid", 0x36, NULL);
This loads the given module (can be NULL if no module needs to be loaded) and This loads the given module (can be NULL if no module needs to be loaded) and
calls i2c_new_device() with the given i2c_adapter and chip/address arguments. calls i2c_new_device() with the given i2c_adapter and chip/address arguments.
If all goes well, then it registers the subdev with the v4l2_device. If all goes well, then it registers the subdev with the v4l2_device.
You can also use v4l2_i2c_new_probed_subdev() which is very similar to You can also use the last argument of v4l2_i2c_new_subdev() to pass an array
v4l2_i2c_new_subdev(), except that it has an array of possible I2C addresses of possible I2C addresses that it should probe. These probe addresses are
that it should probe. Internally it calls i2c_new_probed_device(). only used if the previous argument is 0. A non-zero argument means that you
know the exact i2c address so in that case no probing will take place.
Both functions return NULL if something went wrong. Both functions return NULL if something went wrong.
Note that the chipid you pass to v4l2_i2c_new_(probed_)subdev() is usually Note that the chipid you pass to v4l2_i2c_new_subdev() is usually
the same as the module name. It allows you to specify a chip variant, e.g. the same as the module name. It allows you to specify a chip variant, e.g.
"saa7114" or "saa7115". In general though the i2c driver autodetects this. "saa7114" or "saa7115". In general though the i2c driver autodetects this.
The use of chipid is something that needs to be looked at more closely at a The use of chipid is something that needs to be looked at more closely at a
@ -410,11 +411,6 @@ the irq and platform_data arguments after the subdev was setup. The older
v4l2_i2c_new_(probed_)subdev functions will call s_config as well, but with v4l2_i2c_new_(probed_)subdev functions will call s_config as well, but with
irq set to 0 and platform_data set to NULL. irq set to 0 and platform_data set to NULL.
Note that in the next kernel release the functions v4l2_i2c_new_subdev,
v4l2_i2c_new_probed_subdev and v4l2_i2c_new_probed_subdev_addr will all be
replaced by a single v4l2_i2c_new_subdev that is identical to
v4l2_i2c_new_subdev_cfg but without the irq and platform_data arguments.
struct video_device struct video_device
------------------- -------------------

4
drivers/media/video/au0828/au0828-cards.c
View file

@ -212,7 +212,7 @@ void au0828_card_setup(struct au0828_dev *dev)
be abstracted out if we ever need to support a different be abstracted out if we ever need to support a different
demod) */ demod) */
sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap, sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"au8522", "au8522", 0x8e >> 1); "au8522", "au8522", 0x8e >> 1, NULL);
if (sd == NULL) if (sd == NULL)
printk(KERN_ERR "analog subdev registration failed\n"); printk(KERN_ERR "analog subdev registration failed\n");
} }
@ -221,7 +221,7 @@ void au0828_card_setup(struct au0828_dev *dev)
if (dev->board.tuner_type != TUNER_ABSENT) { if (dev->board.tuner_type != TUNER_ABSENT) {
/* Load the tuner module, which does the attach */ /* Load the tuner module, which does the attach */
sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap, sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"tuner", "tuner", dev->board.tuner_addr); "tuner", "tuner", dev->board.tuner_addr, NULL);
if (sd == NULL) if (sd == NULL)
printk(KERN_ERR "tuner subdev registration fail\n"); printk(KERN_ERR "tuner subdev registration fail\n");

44
drivers/media/video/bt8xx/bttv-cards.c
View file

@ -3524,8 +3524,8 @@ void __devinit bttv_init_card2(struct bttv *btv)
}; };
struct v4l2_subdev *sd; struct v4l2_subdev *sd;
sd = v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, sd = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "saa6588", "saa6588", addrs); &btv->c.i2c_adap, "saa6588", "saa6588", 0, addrs);
btv->has_saa6588 = (sd != NULL); btv->has_saa6588 = (sd != NULL);
} }
@ -3549,8 +3549,8 @@ void __devinit bttv_init_card2(struct bttv *btv)
I2C_CLIENT_END I2C_CLIENT_END
}; };
btv->sd_msp34xx = v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, btv->sd_msp34xx = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "msp3400", "msp3400", addrs); &btv->c.i2c_adap, "msp3400", "msp3400", 0, addrs);
if (btv->sd_msp34xx) if (btv->sd_msp34xx)
return; return;
goto no_audio; goto no_audio;
@ -3563,16 +3563,16 @@ void __devinit bttv_init_card2(struct bttv *btv)
I2C_CLIENT_END I2C_CLIENT_END
}; };
if (v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, if (v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "tda7432", "tda7432", addrs)) &btv->c.i2c_adap, "tda7432", "tda7432", 0, addrs))
return; return;
goto no_audio; goto no_audio;
} }
case 3: { case 3: {
/* The user specified that we should probe for tvaudio */ /* The user specified that we should probe for tvaudio */
btv->sd_tvaudio = v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, btv->sd_tvaudio = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "tvaudio", "tvaudio", tvaudio_addrs()); &btv->c.i2c_adap, "tvaudio", "tvaudio", 0, tvaudio_addrs());
if (btv->sd_tvaudio) if (btv->sd_tvaudio)
return; return;
goto no_audio; goto no_audio;
@ -3591,13 +3591,13 @@ void __devinit bttv_init_card2(struct bttv *btv)
it really is a msp3400, so it will return NULL when the device it really is a msp3400, so it will return NULL when the device
found is really something else (e.g. a tea6300). */ found is really something else (e.g. a tea6300). */
if (!bttv_tvcards[btv->c.type].no_msp34xx) { if (!bttv_tvcards[btv->c.type].no_msp34xx) {
btv->sd_msp34xx = v4l2_i2c_new_probed_subdev_addr(&btv->c.v4l2_dev, btv->sd_msp34xx = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "msp3400", "msp3400", &btv->c.i2c_adap, "msp3400", "msp3400",
I2C_ADDR_MSP3400 >> 1); 0, I2C_ADDRS(I2C_ADDR_MSP3400 >> 1));
} else if (bttv_tvcards[btv->c.type].msp34xx_alt) { } else if (bttv_tvcards[btv->c.type].msp34xx_alt) {
btv->sd_msp34xx = v4l2_i2c_new_probed_subdev_addr(&btv->c.v4l2_dev, btv->sd_msp34xx = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "msp3400", "msp3400", &btv->c.i2c_adap, "msp3400", "msp3400",
I2C_ADDR_MSP3400_ALT >> 1); 0, I2C_ADDRS(I2C_ADDR_MSP3400_ALT >> 1));
} }
/* If we found a msp34xx, then we're done. */ /* If we found a msp34xx, then we're done. */
@ -3611,14 +3611,14 @@ void __devinit bttv_init_card2(struct bttv *btv)
I2C_CLIENT_END I2C_CLIENT_END
}; };
if (v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, if (v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "tda7432", "tda7432", addrs)) &btv->c.i2c_adap, "tda7432", "tda7432", 0, addrs))
return; return;
} }
/* Now see if we can find one of the tvaudio devices. */ /* Now see if we can find one of the tvaudio devices. */
btv->sd_tvaudio = v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, btv->sd_tvaudio = v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "tvaudio", "tvaudio", tvaudio_addrs()); &btv->c.i2c_adap, "tvaudio", "tvaudio", 0, tvaudio_addrs());
if (btv->sd_tvaudio) if (btv->sd_tvaudio)
return; return;
@ -3641,15 +3641,15 @@ void __devinit bttv_init_tuner(struct bttv *btv)
/* Load tuner module before issuing tuner config call! */ /* Load tuner module before issuing tuner config call! */
if (bttv_tvcards[btv->c.type].has_radio) if (bttv_tvcards[btv->c.type].has_radio)
v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "tuner", "tuner", &btv->c.i2c_adap, "tuner", "tuner",
v4l2_i2c_tuner_addrs(ADDRS_RADIO)); 0, v4l2_i2c_tuner_addrs(ADDRS_RADIO));
v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "tuner", "tuner", &btv->c.i2c_adap, "tuner", "tuner",
v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
v4l2_i2c_new_probed_subdev(&btv->c.v4l2_dev, v4l2_i2c_new_subdev(&btv->c.v4l2_dev,
&btv->c.i2c_adap, "tuner", "tuner", &btv->c.i2c_adap, "tuner", "tuner",
v4l2_i2c_tuner_addrs(ADDRS_TV_WITH_DEMOD)); 0, v4l2_i2c_tuner_addrs(ADDRS_TV_WITH_DEMOD));
tun_setup.mode_mask = T_ANALOG_TV | T_DIGITAL_TV; tun_setup.mode_mask = T_ANALOG_TV | T_DIGITAL_TV;
tun_setup.type = btv->tuner_type; tun_setup.type = btv->tuner_type;

2
drivers/media/video/cafe_ccic.c
View file

@ -1955,7 +1955,7 @@ static int cafe_pci_probe(struct pci_dev *pdev,
cam->sensor_addr = 0x42; cam->sensor_addr = 0x42;
cam->sensor = v4l2_i2c_new_subdev(&cam->v4l2_dev, &cam->i2c_adapter, cam->sensor = v4l2_i2c_new_subdev(&cam->v4l2_dev, &cam->i2c_adapter,
"ov7670", "ov7670", cam->sensor_addr); "ov7670", "ov7670", cam->sensor_addr, NULL);
if (cam->sensor == NULL) { if (cam->sensor == NULL) {
ret = -ENODEV; ret = -ENODEV;
goto out_smbus; goto out_smbus;

14
drivers/media/video/cx18/cx18-i2c.c
View file

@ -139,16 +139,16 @@ int cx18_i2c_register(struct cx18 *cx, unsigned idx)
if (hw == CX18_HW_TUNER) { if (hw == CX18_HW_TUNER) {
/* special tuner group handling */ /* special tuner group handling */
sd = v4l2_i2c_new_probed_subdev(&cx->v4l2_dev, sd = v4l2_i2c_new_subdev(&cx->v4l2_dev,
adap, mod, type, cx->card_i2c->radio); adap, mod, type, 0, cx->card_i2c->radio);
if (sd != NULL) if (sd != NULL)
sd->grp_id = hw; sd->grp_id = hw;
sd = v4l2_i2c_new_probed_subdev(&cx->v4l2_dev, sd = v4l2_i2c_new_subdev(&cx->v4l2_dev,
adap, mod, type, cx->card_i2c->demod); adap, mod, type, 0, cx->card_i2c->demod);
if (sd != NULL) if (sd != NULL)
sd->grp_id = hw; sd->grp_id = hw;
sd = v4l2_i2c_new_probed_subdev(&cx->v4l2_dev, sd = v4l2_i2c_new_subdev(&cx->v4l2_dev,
adap, mod, type, cx->card_i2c->tv); adap, mod, type, 0, cx->card_i2c->tv);
if (sd != NULL) if (sd != NULL)
sd->grp_id = hw; sd->grp_id = hw;
return sd != NULL ? 0 : -1; return sd != NULL ? 0 : -1;
@ -162,7 +162,7 @@ int cx18_i2c_register(struct cx18 *cx, unsigned idx)
return -1; return -1;
/* It's an I2C device other than an analog tuner or IR chip */ /* It's an I2C device other than an analog tuner or IR chip */
sd = v4l2_i2c_new_subdev(&cx->v4l2_dev, adap, mod, type, hw_addrs[idx]); sd = v4l2_i2c_new_subdev(&cx->v4l2_dev, adap, mod, type, hw_addrs[idx], NULL);
if (sd != NULL) if (sd != NULL)
sd->grp_id = hw; sd->grp_id = hw;
return sd != NULL ? 0 : -1; return sd != NULL ? 0 : -1;

4
drivers/media/video/cx231xx/cx231xx-cards.c
View file

@ -313,7 +313,7 @@ void cx231xx_card_setup(struct cx231xx *dev)
if (dev->board.decoder == CX231XX_AVDECODER) { if (dev->board.decoder == CX231XX_AVDECODER) {
dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev, dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_bus[0].i2c_adap, &dev->i2c_bus[0].i2c_adap,
"cx25840", "cx25840", 0x88 >> 1); "cx25840", "cx25840", 0x88 >> 1, NULL);
if (dev->sd_cx25840 == NULL) if (dev->sd_cx25840 == NULL)
cx231xx_info("cx25840 subdev registration failure\n"); cx231xx_info("cx25840 subdev registration failure\n");
cx25840_call(dev, core, load_fw); cx25840_call(dev, core, load_fw);
@ -323,7 +323,7 @@ void cx231xx_card_setup(struct cx231xx *dev)
if (dev->board.tuner_type != TUNER_ABSENT) { if (dev->board.tuner_type != TUNER_ABSENT) {
dev->sd_tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev, dev->sd_tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_bus[1].i2c_adap, &dev->i2c_bus[1].i2c_adap,
"tuner", "tuner", 0xc2 >> 1); "tuner", "tuner", 0xc2 >> 1, NULL);
if (dev->sd_tuner == NULL) if (dev->sd_tuner == NULL)
cx231xx_info("tuner subdev registration failure\n"); cx231xx_info("tuner subdev registration failure\n");

2
drivers/media/video/cx23885/cx23885-cards.c
View file

@ -929,7 +929,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
case CX23885_BOARD_NETUP_DUAL_DVBS2_CI: case CX23885_BOARD_NETUP_DUAL_DVBS2_CI:
dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev, dev->sd_cx25840 = v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_bus[2].i2c_adap, &dev->i2c_bus[2].i2c_adap,
"cx25840", "cx25840", 0x88 >> 1); "cx25840", "cx25840", 0x88 >> 1, NULL);
v4l2_subdev_call(dev->sd_cx25840, core, load_fw); v4l2_subdev_call(dev->sd_cx25840, core, load_fw);
break; break;
} }

6
drivers/media/video/cx23885/cx23885-video.c
View file

@ -1521,11 +1521,11 @@ int cx23885_video_register(struct cx23885_dev *dev)
if (dev->tuner_addr) if (dev->tuner_addr)
sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_bus[1].i2c_adap, &dev->i2c_bus[1].i2c_adap,
"tuner", "tuner", dev->tuner_addr); "tuner", "tuner", dev->tuner_addr, NULL);
else else
sd = v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_bus[1].i2c_adap, &dev->i2c_bus[1].i2c_adap,
"tuner", "tuner", v4l2_i2c_tuner_addrs(ADDRS_TV)); "tuner", "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_TV));
if (sd) { if (sd) {
struct tuner_setup tun_setup; struct tuner_setup tun_setup;

14
drivers/media/video/cx88/cx88-cards.c
View file

@ -3439,20 +3439,20 @@ struct cx88_core *cx88_core_create(struct pci_dev *pci, int nr)
The radio_type is sometimes missing, or set to UNSET but The radio_type is sometimes missing, or set to UNSET but
later code configures a tea5767. later code configures a tea5767.
*/ */
v4l2_i2c_new_probed_subdev(&core->v4l2_dev, &core->i2c_adap, v4l2_i2c_new_subdev(&core->v4l2_dev, &core->i2c_adap,
"tuner", "tuner", "tuner", "tuner",
v4l2_i2c_tuner_addrs(ADDRS_RADIO)); 0, v4l2_i2c_tuner_addrs(ADDRS_RADIO));
if (has_demod) if (has_demod)
v4l2_i2c_new_probed_subdev(&core->v4l2_dev, v4l2_i2c_new_subdev(&core->v4l2_dev,
&core->i2c_adap, "tuner", "tuner", &core->i2c_adap, "tuner", "tuner",
v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
if (core->board.tuner_addr == ADDR_UNSET) { if (core->board.tuner_addr == ADDR_UNSET) {
v4l2_i2c_new_probed_subdev(&core->v4l2_dev, v4l2_i2c_new_subdev(&core->v4l2_dev,
&core->i2c_adap, "tuner", "tuner", &core->i2c_adap, "tuner", "tuner",
has_demod ? tv_addrs + 4 : tv_addrs); 0, has_demod ? tv_addrs + 4 : tv_addrs);
} else { } else {
v4l2_i2c_new_subdev(&core->v4l2_dev, &core->i2c_adap, v4l2_i2c_new_subdev(&core->v4l2_dev, &core->i2c_adap,
"tuner", "tuner", core->board.tuner_addr); "tuner", "tuner", core->board.tuner_addr, NULL);
} }
} }

6
drivers/media/video/cx88/cx88-video.c
View file

@ -1881,14 +1881,14 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
if (core->board.audio_chip == V4L2_IDENT_WM8775) if (core->board.audio_chip == V4L2_IDENT_WM8775)
v4l2_i2c_new_subdev(&core->v4l2_dev, &core->i2c_adap, v4l2_i2c_new_subdev(&core->v4l2_dev, &core->i2c_adap,
"wm8775", "wm8775", 0x36 >> 1); "wm8775", "wm8775", 0x36 >> 1, NULL);
if (core->board.audio_chip == V4L2_IDENT_TVAUDIO) { if (core->board.audio_chip == V4L2_IDENT_TVAUDIO) {
/* This probes for a tda9874 as is used on some /* This probes for a tda9874 as is used on some
Pixelview Ultra boards. */ Pixelview Ultra boards. */
v4l2_i2c_new_probed_subdev_addr(&core->v4l2_dev, v4l2_i2c_new_subdev(&core->v4l2_dev,
&core->i2c_adap, &core->i2c_adap,
"tvaudio", "tvaudio", 0xb0 >> 1); "tvaudio", "tvaudio", 0, I2C_ADDRS(0xb0 >> 1));
} }
switch (core->boardnr) { switch (core->boardnr) {

4
drivers/media/video/davinci/vpif_display.c
View file

@ -1566,10 +1566,10 @@ static __init int vpif_probe(struct platform_device *pdev)
} }
for (i = 0; i < subdev_count; i++) { for (i = 0; i < subdev_count; i++) {
vpif_obj.sd[i] = v4l2_i2c_new_probed_subdev(&vpif_obj.v4l2_dev, vpif_obj.sd[i] = v4l2_i2c_new_subdev(&vpif_obj.v4l2_dev,
i2c_adap, subdevdata[i].name, i2c_adap, subdevdata[i].name,
subdevdata[i].name, subdevdata[i].name,
&subdevdata[i].addr); 0, I2C_ADDRS(subdevdata[i].addr));
if (!vpif_obj.sd[i]) { if (!vpif_obj.sd[i]) {
vpif_err("Error registering v4l2 subdevice\n"); vpif_err("Error registering v4l2 subdevice\n");
goto probe_subdev_out; goto probe_subdev_out;

30
drivers/media/video/em28xx/em28xx-cards.c
View file

@ -2372,55 +2372,55 @@ void em28xx_card_setup(struct em28xx *dev)
/* request some modules */ /* request some modules */
if (dev->board.has_msp34xx) if (dev->board.has_msp34xx)
v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, &dev->i2c_adap, v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"msp3400", "msp3400", msp3400_addrs); "msp3400", "msp3400", 0, msp3400_addrs);
if (dev->board.decoder == EM28XX_SAA711X) if (dev->board.decoder == EM28XX_SAA711X)
v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, &dev->i2c_adap, v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"saa7115", "saa7115_auto", saa711x_addrs); "saa7115", "saa7115_auto", 0, saa711x_addrs);
if (dev->board.decoder == EM28XX_TVP5150) if (dev->board.decoder == EM28XX_TVP5150)
v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, &dev->i2c_adap, v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"tvp5150", "tvp5150", tvp5150_addrs); "tvp5150", "tvp5150", 0, tvp5150_addrs);
if (dev->em28xx_sensor == EM28XX_MT9V011) { if (dev->em28xx_sensor == EM28XX_MT9V011) {
struct v4l2_subdev *sd; struct v4l2_subdev *sd;
sd = v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_adap, "mt9v011", "mt9v011", mt9v011_addrs); &dev->i2c_adap, "mt9v011", "mt9v011", 0, mt9v011_addrs);
v4l2_subdev_call(sd, core, s_config, 0, &dev->sensor_xtal); v4l2_subdev_call(sd, core, s_config, 0, &dev->sensor_xtal);
} }
if (dev->board.adecoder == EM28XX_TVAUDIO) if (dev->board.adecoder == EM28XX_TVAUDIO)
v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap, v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"tvaudio", "tvaudio", dev->board.tvaudio_addr); "tvaudio", "tvaudio", dev->board.tvaudio_addr, NULL);
if (dev->board.tuner_type != TUNER_ABSENT) { if (dev->board.tuner_type != TUNER_ABSENT) {
int has_demod = (dev->tda9887_conf & TDA9887_PRESENT); int has_demod = (dev->tda9887_conf & TDA9887_PRESENT);
if (dev->board.radio.type) if (dev->board.radio.type)
v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap, v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"tuner", "tuner", dev->board.radio_addr); "tuner", "tuner", dev->board.radio_addr, NULL);
if (has_demod) if (has_demod)
v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_adap, "tuner", "tuner", &dev->i2c_adap, "tuner", "tuner",
v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
if (dev->tuner_addr == 0) { if (dev->tuner_addr == 0) {
enum v4l2_i2c_tuner_type type = enum v4l2_i2c_tuner_type type =
has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV; has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
struct v4l2_subdev *sd; struct v4l2_subdev *sd;
sd = v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_adap, "tuner", "tuner", &dev->i2c_adap, "tuner", "tuner",
v4l2_i2c_tuner_addrs(type)); 0, v4l2_i2c_tuner_addrs(type));
if (sd) if (sd)
dev->tuner_addr = v4l2_i2c_subdev_addr(sd); dev->tuner_addr = v4l2_i2c_subdev_addr(sd);
} else { } else {
v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap, v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"tuner", "tuner", dev->tuner_addr); "tuner", "tuner", dev->tuner_addr, NULL);
} }
} }

18
drivers/media/video/ivtv/ivtv-i2c.c
View file

@ -161,19 +161,19 @@ int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
return -1; return -1;
if (hw == IVTV_HW_TUNER) { if (hw == IVTV_HW_TUNER) {
/* special tuner handling */ /* special tuner handling */
sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev, sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
adap, mod, type, adap, mod, type,
itv->card_i2c->radio); 0, itv->card_i2c->radio);
if (sd) if (sd)
sd->grp_id = 1 << idx; sd->grp_id = 1 << idx;
sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev, sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
adap, mod, type, adap, mod, type,
itv->card_i2c->demod); 0, itv->card_i2c->demod);
if (sd) if (sd)
sd->grp_id = 1 << idx; sd->grp_id = 1 << idx;
sd = v4l2_i2c_new_probed_subdev(&itv->v4l2_dev, sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
adap, mod, type, adap, mod, type,
itv->card_i2c->tv); 0, itv->card_i2c->tv);
if (sd) if (sd)
sd->grp_id = 1 << idx; sd->grp_id = 1 << idx;
return sd ? 0 : -1; return sd ? 0 : -1;
@ -181,11 +181,11 @@ int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
if (!hw_addrs[idx]) if (!hw_addrs[idx])
return -1; return -1;
if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) { if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
sd = v4l2_i2c_new_probed_subdev_addr(&itv->v4l2_dev, sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
adap, mod, type, hw_addrs[idx]); adap, mod, type, 0, I2C_ADDRS(hw_addrs[idx]));
} else { } else {
sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
adap, mod, type, hw_addrs[idx]); adap, mod, type, hw_addrs[idx], NULL);
} }
if (sd) if (sd)
sd->grp_id = 1 << idx; sd->grp_id = 1 << idx;

14
drivers/media/video/mxb.c
View file

@ -186,19 +186,19 @@ static int mxb_probe(struct saa7146_dev *dev)
} }
mxb->saa7111a = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter, mxb->saa7111a = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
"saa7115", "saa7111", I2C_SAA7111A); "saa7115", "saa7111", I2C_SAA7111A, NULL);
mxb->tea6420_1 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter, mxb->tea6420_1 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
"tea6420", "tea6420", I2C_TEA6420_1); "tea6420", "tea6420", I2C_TEA6420_1, NULL);
mxb->tea6420_2 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter, mxb->tea6420_2 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
"tea6420", "tea6420", I2C_TEA6420_2); "tea6420", "tea6420", I2C_TEA6420_2, NULL);
mxb->tea6415c = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter, mxb->tea6415c = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
"tea6415c", "tea6415c", I2C_TEA6415C); "tea6415c", "tea6415c", I2C_TEA6415C, NULL);
mxb->tda9840 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter, mxb->tda9840 = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
"tda9840", "tda9840", I2C_TDA9840); "tda9840", "tda9840", I2C_TDA9840, NULL);
mxb->tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter, mxb->tuner = v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
"tuner", "tuner", I2C_TUNER); "tuner", "tuner", I2C_TUNER, NULL);
if (v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter, if (v4l2_i2c_new_subdev(&dev->v4l2_dev, &mxb->i2c_adapter,
"saa5246a", "saa5246a", I2C_SAA5246A)) { "saa5246a", "saa5246a", I2C_SAA5246A, NULL)) {
printk(KERN_INFO "mxb: found teletext decoder\n"); printk(KERN_INFO "mxb: found teletext decoder\n");
} }

10
drivers/media/video/pvrusb2/pvrusb2-hdw.c
View file

@ -2063,8 +2063,8 @@ static int pvr2_hdw_load_subdev(struct pvr2_hdw *hdw,
return -EINVAL; return -EINVAL;
} }
/* Note how the 2nd and 3rd arguments are the same for both /* Note how the 2nd and 3rd arguments are the same for
* v4l2_i2c_new_subdev() and v4l2_i2c_new_probed_subdev(). Why? * v4l2_i2c_new_subdev(). Why?
* Well the 2nd argument is the module name to load, while the 3rd * Well the 2nd argument is the module name to load, while the 3rd
* argument is documented in the framework as being the "chipid" - * argument is documented in the framework as being the "chipid" -
* and every other place where I can find examples of this, the * and every other place where I can find examples of this, the
@ -2077,15 +2077,15 @@ static int pvr2_hdw_load_subdev(struct pvr2_hdw *hdw,
mid, i2caddr[0]); mid, i2caddr[0]);
sd = v4l2_i2c_new_subdev(&hdw->v4l2_dev, &hdw->i2c_adap, sd = v4l2_i2c_new_subdev(&hdw->v4l2_dev, &hdw->i2c_adap,
fname, fname, fname, fname,
i2caddr[0]); i2caddr[0], NULL);
} else { } else {
pvr2_trace(PVR2_TRACE_INIT, pvr2_trace(PVR2_TRACE_INIT,
"Module ID %u:" "Module ID %u:"
" Setting up with address probe list", " Setting up with address probe list",
mid); mid);
sd = v4l2_i2c_new_probed_subdev(&hdw->v4l2_dev, &hdw->i2c_adap, sd = v4l2_i2c_new_subdev(&hdw->v4l2_dev, &hdw->i2c_adap,
fname, fname, fname, fname,
i2caddr); 0, i2caddr);
} }
if (!sd) { if (!sd) {

12
drivers/media/video/saa7134/saa7134-cards.c
View file

@ -7208,22 +7208,22 @@ int saa7134_board_init2(struct saa7134_dev *dev)
if (dev->radio_type != UNSET) if (dev->radio_type != UNSET)
v4l2_i2c_new_subdev(&dev->v4l2_dev, v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_adap, "tuner", "tuner", &dev->i2c_adap, "tuner", "tuner",
dev->radio_addr); dev->radio_addr, NULL);
if (has_demod) if (has_demod)
v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_adap, "tuner", "tuner", &dev->i2c_adap, "tuner", "tuner",
v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
if (dev->tuner_addr == ADDR_UNSET) { if (dev->tuner_addr == ADDR_UNSET) {
enum v4l2_i2c_tuner_type type = enum v4l2_i2c_tuner_type type =
has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV; has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
v4l2_i2c_new_probed_subdev(&dev->v4l2_dev, v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_adap, "tuner", "tuner", &dev->i2c_adap, "tuner", "tuner",
v4l2_i2c_tuner_addrs(type)); 0, v4l2_i2c_tuner_addrs(type));
} else { } else {
v4l2_i2c_new_subdev(&dev->v4l2_dev, v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_adap, "tuner", "tuner", &dev->i2c_adap, "tuner", "tuner",
dev->tuner_addr); dev->tuner_addr, NULL);
} }
} }

6
drivers/media/video/saa7134/saa7134-core.c
View file

@ -1000,7 +1000,7 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
struct v4l2_subdev *sd = struct v4l2_subdev *sd =
v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap, v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
"saa6752hs", "saa6752hs", "saa6752hs", "saa6752hs",
saa7134_boards[dev->board].empress_addr); saa7134_boards[dev->board].empress_addr, NULL);
if (sd) if (sd)
sd->grp_id = GRP_EMPRESS; sd->grp_id = GRP_EMPRESS;
@ -1009,9 +1009,9 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
if (saa7134_boards[dev->board].rds_addr) { if (saa7134_boards[dev->board].rds_addr) {
struct v4l2_subdev *sd; struct v4l2_subdev *sd;
sd = v4l2_i2c_new_probed_subdev_addr(&dev->v4l2_dev, sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
&dev->i2c_adap, "saa6588", "saa6588", &dev->i2c_adap, "saa6588", "saa6588",
saa7134_boards[dev->board].rds_addr); 0, I2C_ADDRS(saa7134_boards[dev->board].rds_addr));
if (sd) { if (sd) {
printk(KERN_INFO "%s: found RDS decoder\n", dev->name); printk(KERN_INFO "%s: found RDS decoder\n", dev->name);
dev->has_rds = 1; dev->has_rds = 1;

12
drivers/media/video/usbvision/usbvision-i2c.c
View file

@ -246,9 +246,9 @@ int usbvision_i2c_register(struct usb_usbvision *usbvision)
switch (usbvision_device_data[usbvision->DevModel].Codec) { switch (usbvision_device_data[usbvision->DevModel].Codec) {
case CODEC_SAA7113: case CODEC_SAA7113:
case CODEC_SAA7111: case CODEC_SAA7111:
v4l2_i2c_new_probed_subdev(&usbvision->v4l2_dev, v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
&usbvision->i2c_adap, "saa7115", &usbvision->i2c_adap, "saa7115",
"saa7115_auto", saa711x_addrs); "saa7115_auto", 0, saa711x_addrs);
break; break;
} }
if (usbvision_device_data[usbvision->DevModel].Tuner == 1) { if (usbvision_device_data[usbvision->DevModel].Tuner == 1) {
@ -256,16 +256,16 @@ int usbvision_i2c_register(struct usb_usbvision *usbvision)
enum v4l2_i2c_tuner_type type; enum v4l2_i2c_tuner_type type;
struct tuner_setup tun_setup; struct tuner_setup tun_setup;
sd = v4l2_i2c_new_probed_subdev(&usbvision->v4l2_dev, sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
&usbvision->i2c_adap, "tuner", &usbvision->i2c_adap, "tuner",
"tuner", v4l2_i2c_tuner_addrs(ADDRS_DEMOD)); "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
/* depending on whether we found a demod or not, select /* depending on whether we found a demod or not, select
the tuner type. */ the tuner type. */
type = sd ? ADDRS_TV_WITH_DEMOD : ADDRS_TV; type = sd ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
sd = v4l2_i2c_new_probed_subdev(&usbvision->v4l2_dev, sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
&usbvision->i2c_adap, "tuner", &usbvision->i2c_adap, "tuner",
"tuner", v4l2_i2c_tuner_addrs(type)); "tuner", 0, v4l2_i2c_tuner_addrs(type));
if (usbvision->tuner_type != -1) { if (usbvision->tuner_type != -1) {
tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;

133
drivers/media/video/v4l2-common.c
View file

@ -813,139 +813,6 @@ EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
/* Load an i2c sub-device. */
struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
struct i2c_adapter *adapter,
const char *module_name, const char *client_type, u8 addr)
{
struct v4l2_subdev *sd = NULL;
struct i2c_client *client;
struct i2c_board_info info;
BUG_ON(!v4l2_dev);
if (module_name)
request_module(module_name);
/* Setup the i2c board info with the device type and
the device address. */
memset(&info, 0, sizeof(info));
strlcpy(info.type, client_type, sizeof(info.type));
info.addr = addr;
/* Create the i2c client */
client = i2c_new_device(adapter, &info);
/* Note: it is possible in the future that
c->driver is NULL if the driver is still being loaded.
We need better support from the kernel so that we
can easily wait for the load to finish. */
if (client == NULL || client->driver == NULL)
goto error;
/* Lock the module so we can safely get the v4l2_subdev pointer */
if (!try_module_get(client->driver->driver.owner))
goto error;
sd = i2c_get_clientdata(client);
/* Register with the v4l2_device which increases the module's
use count as well. */
if (v4l2_device_register_subdev(v4l2_dev, sd))
sd = NULL;
/* Decrease the module use count to match the first try_module_get. */
module_put(client->driver->driver.owner);
if (sd) {
/* We return errors from v4l2_subdev_call only if we have the
callback as the .s_config is not mandatory */
int err = v4l2_subdev_call(sd, core, s_config, 0, NULL);
if (err && err != -ENOIOCTLCMD) {
v4l2_device_unregister_subdev(sd);
sd = NULL;
}
}
error:
/* If we have a client but no subdev, then something went wrong and
we must unregister the client. */
if (client && sd == NULL)
i2c_unregister_device(client);
return sd;
}
EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
/* Probe and load an i2c sub-device. */
struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct v4l2_device *v4l2_dev,
struct i2c_adapter *adapter,
const char *module_name, const char *client_type,
const unsigned short *addrs)
{
struct v4l2_subdev *sd = NULL;
struct i2c_client *client = NULL;
struct i2c_board_info info;
BUG_ON(!v4l2_dev);
if (module_name)
request_module(module_name);
/* Setup the i2c board info with the device type and
the device address. */
memset(&info, 0, sizeof(info));
strlcpy(info.type, client_type, sizeof(info.type));
/* Probe and create the i2c client */
client = i2c_new_probed_device(adapter, &info, addrs);
/* Note: it is possible in the future that
c->driver is NULL if the driver is still being loaded.
We need better support from the kernel so that we
can easily wait for the load to finish. */
if (client == NULL || client->driver == NULL)
goto error;
/* Lock the module so we can safely get the v4l2_subdev pointer */
if (!try_module_get(client->driver->driver.owner))
goto error;
sd = i2c_get_clientdata(client);
/* Register with the v4l2_device which increases the module's
use count as well. */
if (v4l2_device_register_subdev(v4l2_dev, sd))
sd = NULL;
/* Decrease the module use count to match the first try_module_get. */
module_put(client->driver->driver.owner);
if (sd) {
/* We return errors from v4l2_subdev_call only if we have the
callback as the .s_config is not mandatory */
int err = v4l2_subdev_call(sd, core, s_config, 0, NULL);
if (err && err != -ENOIOCTLCMD) {
v4l2_device_unregister_subdev(sd);
sd = NULL;
}
}
error:
/* If we have a client but no subdev, then something went wrong and
we must unregister the client. */
if (client && sd == NULL)
i2c_unregister_device(client);
return sd;
}
EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev);
struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev,
struct i2c_adapter *adapter,
const char *module_name, const char *client_type, u8 addr)
{
unsigned short addrs[2] = { addr, I2C_CLIENT_END };
return v4l2_i2c_new_probed_subdev(v4l2_dev, adapter,
module_name, client_type, addrs);
}
EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev_addr);
/* Load an i2c sub-device. */ /* Load an i2c sub-device. */
struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev, struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
struct i2c_adapter *adapter, const char *module_name, struct i2c_adapter *adapter, const char *module_name,

8
drivers/media/video/vino.c
View file

@ -4333,11 +4333,11 @@ static int __init vino_module_init(void)
vino_init_stage++; vino_init_stage++;
vino_drvdata->decoder = vino_drvdata->decoder =
v4l2_i2c_new_probed_subdev_addr(&vino_drvdata->v4l2_dev, v4l2_i2c_new_subdev(&vino_drvdata->v4l2_dev, &vino_i2c_adapter,
&vino_i2c_adapter, "saa7191", "saa7191", 0x45); "saa7191", "saa7191", 0, I2C_ADDRS(0x45));
vino_drvdata->camera = vino_drvdata->camera =
v4l2_i2c_new_probed_subdev_addr(&vino_drvdata->v4l2_dev, v4l2_i2c_new_subdev(&vino_drvdata->v4l2_dev, &vino_i2c_adapter,
&vino_i2c_adapter, "indycam", "indycam", 0x2b); "indycam", "indycam", 0, I2C_ADDRS(0x2b));
dprintk("init complete!\n"); dprintk("init complete!\n");

4
drivers/media/video/w9968cf.c
View file

@ -3515,9 +3515,9 @@ w9968cf_usb_probe(struct usb_interface* intf, const struct usb_device_id* id)
w9968cf_turn_on_led(cam); w9968cf_turn_on_led(cam);
w9968cf_i2c_init(cam); w9968cf_i2c_init(cam);
cam->sensor_sd = v4l2_i2c_new_probed_subdev(&cam->v4l2_dev, cam->sensor_sd = v4l2_i2c_new_subdev(&cam->v4l2_dev,
&cam->i2c_adapter, &cam->i2c_adapter,
"ovcamchip", "ovcamchip", addrs); "ovcamchip", "ovcamchip", 0, addrs);
usb_set_intfdata(intf, cam); usb_set_intfdata(intf, cam);
mutex_unlock(&cam->dev_mutex); mutex_unlock(&cam->dev_mutex);

8
drivers/media/video/zoran/zoran_card.c
View file

@ -1357,15 +1357,15 @@ static int __devinit zoran_probe(struct pci_dev *pdev,
goto zr_free_irq; goto zr_free_irq;
} }
zr->decoder = v4l2_i2c_new_probed_subdev(&zr->v4l2_dev, zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
&zr->i2c_adapter, zr->card.mod_decoder, zr->card.i2c_decoder, &zr->i2c_adapter, zr->card.mod_decoder, zr->card.i2c_decoder,
zr->card.addrs_decoder); 0, zr->card.addrs_decoder);
if (zr->card.mod_encoder) if (zr->card.mod_encoder)
zr->encoder = v4l2_i2c_new_probed_subdev(&zr->v4l2_dev, zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev,
&zr->i2c_adapter, &zr->i2c_adapter,
zr->card.mod_encoder, zr->card.i2c_encoder, zr->card.mod_encoder, zr->card.i2c_encoder,
zr->card.addrs_encoder); 0, zr->card.addrs_encoder);
dprintk(2, dprintk(2,
KERN_INFO "%s: Initializing videocodec bus...\n", KERN_INFO "%s: Initializing videocodec bus...\n",

30
include/media/v4l2-common.h
View file

@ -136,24 +136,6 @@ struct v4l2_subdev;
struct v4l2_subdev_ops; struct v4l2_subdev_ops;
/* Load an i2c module and return an initialized v4l2_subdev struct.
Only call request_module if module_name != NULL.
The client_type argument is the name of the chip that's on the adapter. */
struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
struct i2c_adapter *adapter,
const char *module_name, const char *client_type, u8 addr);
/* Probe and load an i2c module and return an initialized v4l2_subdev struct.
Only call request_module if module_name != NULL.
The client_type argument is the name of the chip that's on the adapter. */
struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct v4l2_device *v4l2_dev,
struct i2c_adapter *adapter,
const char *module_name, const char *client_type,
const unsigned short *addrs);
/* Like v4l2_i2c_new_probed_subdev, except probe for a single address. */
struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev,
struct i2c_adapter *adapter,
const char *module_name, const char *client_type, u8 addr);
/* Load an i2c module and return an initialized v4l2_subdev struct. /* Load an i2c module and return an initialized v4l2_subdev struct.
Only call request_module if module_name != NULL. Only call request_module if module_name != NULL.
The client_type argument is the name of the chip that's on the adapter. */ The client_type argument is the name of the chip that's on the adapter. */
@ -163,6 +145,18 @@ struct v4l2_subdev *v4l2_i2c_new_subdev_cfg(struct v4l2_device *v4l2_dev,
int irq, void *platform_data, int irq, void *platform_data,
u8 addr, const unsigned short *probe_addrs); u8 addr, const unsigned short *probe_addrs);
/* Load an i2c module and return an initialized v4l2_subdev struct.
Only call request_module if module_name != NULL.
The client_type argument is the name of the chip that's on the adapter. */
static inline struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
struct i2c_adapter *adapter,
const char *module_name, const char *client_type,
u8 addr, const unsigned short *probe_addrs)
{
return v4l2_i2c_new_subdev_cfg(v4l2_dev, adapter, module_name,
client_type, 0, NULL, addr, probe_addrs);
}
struct i2c_board_info; struct i2c_board_info;
struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev, struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,