Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-16 00:52:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

V4L/DVB (6293): V4L: convert struct class_device to struct device

Browse Source 
The currently used "struct class_device" will be removed from the
kernel. Here is a patch that converts all users in drivers/media/video/
to struct device.

Reviewed-by: Thierry Merle <thierry.merle@free.fr>
Reviewed-by: Mike Isely <isely@pobox.com>
Reviewed-by: Luca Risolia <luca.risolia@studio.unibo.it>
Signed-off-by: Kay Sievers <kay.sievers@vrfy.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
This commit is contained in:
Kay Sievers 2007-10-08 16:26:13 -03:00 committed by Mauro Carvalho Chehab
parent d4cae5a500
commit 54bd5b66c8
10 changed files with 387 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
drivers/media/video/bt8xx/bttv-driver.c
View File

@ -154,13 +154,14 @@ MODULE_LICENSE("GPL");
/* ----------------------------------------------------------------------- */
/* sysfs */
static ssize_t show_card(struct class_device *cd, char *buf)
static ssize_t show_card(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vfd = to_video_device(cd);
struct bttv *btv = dev_get_drvdata(vfd->dev);
return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
}
static CLASS_DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
/* ----------------------------------------------------------------------- */
/* dvb auto-load setup */
@ -4615,9 +4616,9 @@ static int __devinit bttv_register_video(struct bttv *btv)
goto err;
printk(KERN_INFO "bttv%d: registered device video%d\n",
btv->c.nr,btv->video_dev->minor & 0x1f);
if (class_device_create_file(&btv->video_dev->class_dev,
&class_device_attr_card)<0) {
printk(KERN_ERR "bttv%d: class_device_create_file 'card' "
if (device_create_file(&btv->video_dev->class_dev,
&dev_attr_card)<0) {
printk(KERN_ERR "bttv%d: device_create_file 'card' "
"failed\n", btv->c.nr);
goto err;
}

50
drivers/media/video/et61x251/et61x251_core.c
View File

@ -706,7 +706,8 @@ static u8 et61x251_strtou8(const char* buff, size_t len, ssize_t* count)
NOTE 2: buffers are PAGE_SIZE long
*/
static ssize_t et61x251_show_reg(struct class_device* cd, char* buf)
static ssize_t et61x251_show_reg(struct device* cd,
struct device_attribute *attr, char* buf)
{
struct et61x251_device* cam;
ssize_t count;
@ -729,7 +730,8 @@ static ssize_t et61x251_show_reg(struct class_device* cd, char* buf)
static ssize_t
et61x251_store_reg(struct class_device* cd, const char* buf, size_t len)
et61x251_store_reg(struct device* cd,
struct device_attribute *attr, const char* buf, size_t len)
{
struct et61x251_device* cam;
u8 index;
@ -761,7 +763,8 @@ et61x251_store_reg(struct class_device* cd, const char* buf, size_t len)
}
static ssize_t et61x251_show_val(struct class_device* cd, char* buf)
static ssize_t et61x251_show_val(struct device* cd,
struct device_attribute *attr, char* buf)
{
struct et61x251_device* cam;
ssize_t count;
@ -792,7 +795,8 @@ static ssize_t et61x251_show_val(struct class_device* cd, char* buf)
static ssize_t
et61x251_store_val(struct class_device* cd, const char* buf, size_t len)
et61x251_store_val(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
struct et61x251_device* cam;
u8 value;
@ -830,7 +834,8 @@ et61x251_store_val(struct class_device* cd, const char* buf, size_t len)
}
static ssize_t et61x251_show_i2c_reg(struct class_device* cd, char* buf)
static ssize_t et61x251_show_i2c_reg(struct device* cd,
struct device_attribute *attr, char* buf)
{
struct et61x251_device* cam;
ssize_t count;
@ -855,7 +860,8 @@ static ssize_t et61x251_show_i2c_reg(struct class_device* cd, char* buf)
static ssize_t
et61x251_store_i2c_reg(struct class_device* cd, const char* buf, size_t len)
et61x251_store_i2c_reg(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
struct et61x251_device* cam;
u8 index;
@ -887,7 +893,8 @@ et61x251_store_i2c_reg(struct class_device* cd, const char* buf, size_t len)
}
static ssize_t et61x251_show_i2c_val(struct class_device* cd, char* buf)
static ssize_t et61x251_show_i2c_val(struct device* cd,
struct device_attribute *attr, char* buf)
{
struct et61x251_device* cam;
ssize_t count;
@ -923,7 +930,8 @@ static ssize_t et61x251_show_i2c_val(struct class_device* cd, char* buf)
static ssize_t
et61x251_store_i2c_val(struct class_device* cd, const char* buf, size_t len)
et61x251_store_i2c_val(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
struct et61x251_device* cam;
u8 value;
@ -966,42 +974,40 @@ et61x251_store_i2c_val(struct class_device* cd, const char* buf, size_t len)
}
static CLASS_DEVICE_ATTR(reg, S_IRUGO | S_IWUSR,
static DEVICE_ATTR(reg, S_IRUGO | S_IWUSR,
et61x251_show_reg, et61x251_store_reg);
static CLASS_DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
static DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
et61x251_show_val, et61x251_store_val);
static CLASS_DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
static DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
et61x251_show_i2c_reg, et61x251_store_i2c_reg);
static CLASS_DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
static DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
et61x251_show_i2c_val, et61x251_store_i2c_val);
static int et61x251_create_sysfs(struct et61x251_device* cam)
{
struct class_device *classdev = &(cam->v4ldev->class_dev);
struct device *classdev = &(cam->v4ldev->class_dev);
int err = 0;
if ((err = class_device_create_file(classdev, &class_device_attr_reg)))
if ((err = device_create_file(classdev, &dev_attr_reg)))
goto err_out;
if ((err = class_device_create_file(classdev, &class_device_attr_val)))
if ((err = device_create_file(classdev, &dev_attr_val)))
goto err_reg;
if (cam->sensor.sysfs_ops) {
if ((err = class_device_create_file(classdev,
&class_device_attr_i2c_reg)))
if ((err = device_create_file(classdev, &dev_attr_i2c_reg)))
goto err_val;
if ((err = class_device_create_file(classdev,
&class_device_attr_i2c_val)))
if ((err = device_create_file(classdev, &dev_attr_i2c_val)))
goto err_i2c_reg;
}
err_i2c_reg:
if (cam->sensor.sysfs_ops)
class_device_remove_file(classdev, &class_device_attr_i2c_reg);
device_remove_file(classdev, &dev_attr_i2c_reg);
err_val:
class_device_remove_file(classdev, &class_device_attr_val);
device_remove_file(classdev, &dev_attr_val);
err_reg:
class_device_remove_file(classdev, &class_device_attr_reg);
device_remove_file(classdev, &dev_attr_reg);
err_out:
return err;
}

81
drivers/media/video/ov511.c
View File

@ -5554,41 +5554,46 @@ error:
* sysfs
***************************************************************************/
static inline struct usb_ov511 *cd_to_ov(struct class_device *cd)
static inline struct usb_ov511 *cd_to_ov(struct device *cd)
{
struct video_device *vdev = to_video_device(cd);
return video_get_drvdata(vdev);
}
static ssize_t show_custom_id(struct class_device *cd, char *buf)
static ssize_t show_custom_id(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
return sprintf(buf, "%d\n", ov->customid);
}
static CLASS_DEVICE_ATTR(custom_id, S_IRUGO, show_custom_id, NULL);
static DEVICE_ATTR(custom_id, S_IRUGO, show_custom_id, NULL);
static ssize_t show_model(struct class_device *cd, char *buf)
static ssize_t show_model(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
return sprintf(buf, "%s\n", ov->desc);
}
static CLASS_DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
static DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
static ssize_t show_bridge(struct class_device *cd, char *buf)
static ssize_t show_bridge(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
return sprintf(buf, "%s\n", symbolic(brglist, ov->bridge));
}
static CLASS_DEVICE_ATTR(bridge, S_IRUGO, show_bridge, NULL);
static DEVICE_ATTR(bridge, S_IRUGO, show_bridge, NULL);
static ssize_t show_sensor(struct class_device *cd, char *buf)
static ssize_t show_sensor(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
return sprintf(buf, "%s\n", symbolic(senlist, ov->sensor));
}
static CLASS_DEVICE_ATTR(sensor, S_IRUGO, show_sensor, NULL);
static DEVICE_ATTR(sensor, S_IRUGO, show_sensor, NULL);
static ssize_t show_brightness(struct class_device *cd, char *buf)
static ssize_t show_brightness(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
unsigned short x;
@ -5598,9 +5603,10 @@ static ssize_t show_brightness(struct class_device *cd, char *buf)
sensor_get_brightness(ov, &x);
return sprintf(buf, "%d\n", x >> 8);
}
static CLASS_DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);
static DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);
static ssize_t show_saturation(struct class_device *cd, char *buf)
static ssize_t show_saturation(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
unsigned short x;
@ -5610,9 +5616,10 @@ static ssize_t show_saturation(struct class_device *cd, char *buf)
sensor_get_saturation(ov, &x);
return sprintf(buf, "%d\n", x >> 8);
}
static CLASS_DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);
static DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);
static ssize_t show_contrast(struct class_device *cd, char *buf)
static ssize_t show_contrast(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
unsigned short x;
@ -5622,9 +5629,10 @@ static ssize_t show_contrast(struct class_device *cd, char *buf)
sensor_get_contrast(ov, &x);
return sprintf(buf, "%d\n", x >> 8);
}
static CLASS_DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);
static DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);
static ssize_t show_hue(struct class_device *cd, char *buf)
static ssize_t show_hue(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
unsigned short x;
@ -5634,9 +5642,10 @@ static ssize_t show_hue(struct class_device *cd, char *buf)
sensor_get_hue(ov, &x);
return sprintf(buf, "%d\n", x >> 8);
}
static CLASS_DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);
static DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);
static ssize_t show_exposure(struct class_device *cd, char *buf)
static ssize_t show_exposure(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct usb_ov511 *ov = cd_to_ov(cd);
unsigned char exp = 0;
@ -5646,49 +5655,49 @@ static ssize_t show_exposure(struct class_device *cd, char *buf)
sensor_get_exposure(ov, &exp);
return sprintf(buf, "%d\n", exp >> 8);
}
static CLASS_DEVICE_ATTR(exposure, S_IRUGO, show_exposure, NULL);
static DEVICE_ATTR(exposure, S_IRUGO, show_exposure, NULL);
static int ov_create_sysfs(struct video_device *vdev)
{
int rc;
rc = video_device_create_file(vdev, &class_device_attr_custom_id);
rc = video_device_create_file(vdev, &dev_attr_custom_id);
if (rc) goto err;
rc = video_device_create_file(vdev, &class_device_attr_model);
rc = video_device_create_file(vdev, &dev_attr_model);
if (rc) goto err_id;
rc = video_device_create_file(vdev, &class_device_attr_bridge);
rc = video_device_create_file(vdev, &dev_attr_bridge);
if (rc) goto err_model;
rc = video_device_create_file(vdev, &class_device_attr_sensor);
rc = video_device_create_file(vdev, &dev_attr_sensor);
if (rc) goto err_bridge;
rc = video_device_create_file(vdev, &class_device_attr_brightness);
rc = video_device_create_file(vdev, &dev_attr_brightness);
if (rc) goto err_sensor;
rc = video_device_create_file(vdev, &class_device_attr_saturation);
rc = video_device_create_file(vdev, &dev_attr_saturation);
if (rc) goto err_bright;
rc = video_device_create_file(vdev, &class_device_attr_contrast);
rc = video_device_create_file(vdev, &dev_attr_contrast);
if (rc) goto err_sat;
rc = video_device_create_file(vdev, &class_device_attr_hue);
rc = video_device_create_file(vdev, &dev_attr_hue);
if (rc) goto err_contrast;
rc = video_device_create_file(vdev, &class_device_attr_exposure);
rc = video_device_create_file(vdev, &dev_attr_exposure);
if (rc) goto err_hue;
return 0;
err_hue:
video_device_remove_file(vdev, &class_device_attr_hue);
video_device_remove_file(vdev, &dev_attr_hue);
err_contrast:
video_device_remove_file(vdev, &class_device_attr_contrast);
video_device_remove_file(vdev, &dev_attr_contrast);
err_sat:
video_device_remove_file(vdev, &class_device_attr_saturation);
video_device_remove_file(vdev, &dev_attr_saturation);
err_bright:
video_device_remove_file(vdev, &class_device_attr_brightness);
video_device_remove_file(vdev, &dev_attr_brightness);
err_sensor:
video_device_remove_file(vdev, &class_device_attr_sensor);
video_device_remove_file(vdev, &dev_attr_sensor);
err_bridge:
video_device_remove_file(vdev, &class_device_attr_bridge);
video_device_remove_file(vdev, &dev_attr_bridge);
err_model:
video_device_remove_file(vdev, &class_device_attr_model);
video_device_remove_file(vdev, &dev_attr_model);
err_id:
video_device_remove_file(vdev, &class_device_attr_custom_id);
video_device_remove_file(vdev, &dev_attr_custom_id);
err:
return rc;
}

210
drivers/media/video/pvrusb2/pvrusb2-sysfs.c
View File

@ -33,16 +33,16 @@
struct pvr2_sysfs {
struct pvr2_channel channel;
struct class_device *class_dev;
struct device *class_dev;
#ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
struct pvr2_sysfs_debugifc *debugifc;
#endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
struct pvr2_sysfs_ctl_item *item_first;
struct pvr2_sysfs_ctl_item *item_last;
struct class_device_attribute attr_v4l_minor_number;
struct class_device_attribute attr_v4l_radio_minor_number;
struct class_device_attribute attr_unit_number;
struct class_device_attribute attr_bus_info;
struct device_attribute attr_v4l_minor_number;
struct device_attribute attr_v4l_radio_minor_number;
struct device_attribute attr_unit_number;
struct device_attribute attr_bus_info;
int v4l_minor_number_created_ok;
int v4l_radio_minor_number_created_ok;
int unit_number_created_ok;
@ -51,22 +51,22 @@ struct pvr2_sysfs {
#ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
struct pvr2_sysfs_debugifc {
struct class_device_attribute attr_debugcmd;
struct class_device_attribute attr_debuginfo;
struct device_attribute attr_debugcmd;
struct device_attribute attr_debuginfo;
int debugcmd_created_ok;
int debuginfo_created_ok;
};
#endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
struct pvr2_sysfs_ctl_item {
struct class_device_attribute attr_name;
struct class_device_attribute attr_type;
struct class_device_attribute attr_min;
struct class_device_attribute attr_max;
struct class_device_attribute attr_enum;
struct class_device_attribute attr_bits;
struct class_device_attribute attr_val;
struct class_device_attribute attr_custom;
struct device_attribute attr_name;
struct device_attribute attr_type;
struct device_attribute attr_min;
struct device_attribute attr_max;
struct device_attribute attr_enum;
struct device_attribute attr_bits;
struct device_attribute attr_val;
struct device_attribute attr_custom;
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *chptr;
struct pvr2_sysfs_ctl_item *item_next;
@ -80,13 +80,13 @@ struct pvr2_sysfs_class {
struct class class;
};
static ssize_t show_name(int id,struct class_device *class_dev,char *buf)
static ssize_t show_name(int id,struct device *class_dev,char *buf)
{
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *sfp;
const char *name;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
if (!cptr) return -EINVAL;
@ -99,14 +99,14 @@ static ssize_t show_name(int id,struct class_device *class_dev,char *buf)
return scnprintf(buf,PAGE_SIZE,"%s\n",name);
}
static ssize_t show_type(int id,struct class_device *class_dev,char *buf)
static ssize_t show_type(int id,struct device *class_dev,char *buf)
{
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *sfp;
const char *name;
enum pvr2_ctl_type tp;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
if (!cptr) return -EINVAL;
@ -126,13 +126,13 @@ static ssize_t show_type(int id,struct class_device *class_dev,char *buf)
return scnprintf(buf,PAGE_SIZE,"%s\n",name);
}
static ssize_t show_min(int id,struct class_device *class_dev,char *buf)
static ssize_t show_min(int id,struct device *class_dev,char *buf)
{
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *sfp;
long val;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
if (!cptr) return -EINVAL;
@ -143,13 +143,13 @@ static ssize_t show_min(int id,struct class_device *class_dev,char *buf)
return scnprintf(buf,PAGE_SIZE,"%ld\n",val);
}
static ssize_t show_max(int id,struct class_device *class_dev,char *buf)
static ssize_t show_max(int id,struct device *class_dev,char *buf)
{
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *sfp;
long val;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
if (!cptr) return -EINVAL;
@ -160,14 +160,14 @@ static ssize_t show_max(int id,struct class_device *class_dev,char *buf)
return scnprintf(buf,PAGE_SIZE,"%ld\n",val);
}
static ssize_t show_val_norm(int id,struct class_device *class_dev,char *buf)
static ssize_t show_val_norm(int id,struct device *class_dev,char *buf)
{
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *sfp;
int val,ret;
unsigned int cnt = 0;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
if (!cptr) return -EINVAL;
@ -184,14 +184,14 @@ static ssize_t show_val_norm(int id,struct class_device *class_dev,char *buf)
return cnt+1;
}
static ssize_t show_val_custom(int id,struct class_device *class_dev,char *buf)
static ssize_t show_val_custom(int id,struct device *class_dev,char *buf)
{
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *sfp;
int val,ret;
unsigned int cnt = 0;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
if (!cptr) return -EINVAL;
@ -208,14 +208,14 @@ static ssize_t show_val_custom(int id,struct class_device *class_dev,char *buf)
return cnt+1;
}
static ssize_t show_enum(int id,struct class_device *class_dev,char *buf)
static ssize_t show_enum(int id,struct device *class_dev,char *buf)
{
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *sfp;
long val;
unsigned int bcnt,ccnt,ecnt;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
if (!cptr) return -EINVAL;
@ -233,14 +233,14 @@ static ssize_t show_enum(int id,struct class_device *class_dev,char *buf)
return bcnt;
}
static ssize_t show_bits(int id,struct class_device *class_dev,char *buf)
static ssize_t show_bits(int id,struct device *class_dev,char *buf)
{
struct pvr2_ctrl *cptr;
struct pvr2_sysfs *sfp;
int valid_bits,msk;
unsigned int bcnt,ccnt;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,id);
if (!cptr) return -EINVAL;
@ -278,23 +278,23 @@ static int store_val_any(int id,int customfl,struct pvr2_sysfs *sfp,
return ret;
}
static ssize_t store_val_norm(int id,struct class_device *class_dev,
static ssize_t store_val_norm(int id,struct device *class_dev,
const char *buf,size_t count)
{
struct pvr2_sysfs *sfp;
int ret;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
ret = store_val_any(id,0,sfp,buf,count);
if (!ret) ret = count;
return ret;
}
static ssize_t store_val_custom(int id,struct class_device *class_dev,
static ssize_t store_val_custom(int id,struct device *class_dev,
const char *buf,size_t count)
{
struct pvr2_sysfs *sfp;
int ret;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
ret = store_val_any(id,1,sfp,buf,count);
if (!ret) ret = count;
return ret;
@ -304,7 +304,7 @@ static ssize_t store_val_custom(int id,struct class_device *class_dev,
Mike Isely <isely@pobox.com> 30-April-2005
This next batch of horrible preprocessor hackery is needed because the
kernel's class_device_attribute mechanism fails to pass the actual
kernel's device_attribute mechanism fails to pass the actual
attribute through to the show / store functions, which means we have no
way to package up any attribute-specific parameters, like for example the
control id. So we work around this brain-damage by encoding the control
@ -314,11 +314,13 @@ static ssize_t store_val_custom(int id,struct class_device *class_dev,
*/
#define CREATE_SHOW_INSTANCE(sf_name,ctl_id) \
static ssize_t sf_name##_##ctl_id(struct class_device *class_dev,char *buf) \
static ssize_t sf_name##_##ctl_id(struct device *class_dev, \
struct device_attribute *attr, char *buf) \
{ return sf_name(ctl_id,class_dev,buf); }
#define CREATE_STORE_INSTANCE(sf_name,ctl_id) \
static ssize_t sf_name##_##ctl_id(struct class_device *class_dev,const char *buf,size_t count) \
static ssize_t sf_name##_##ctl_id(struct device *class_dev, \
struct device_attribute *attr, const char *buf, size_t count) \
{ return sf_name(ctl_id,class_dev,buf,count); }
#define CREATE_BATCH(ctl_id) \
@ -395,17 +397,27 @@ CREATE_BATCH(58)
CREATE_BATCH(59)
struct pvr2_sysfs_func_set {
ssize_t (*show_name)(struct class_device *,char *);
ssize_t (*show_type)(struct class_device *,char *);
ssize_t (*show_min)(struct class_device *,char *);
ssize_t (*show_max)(struct class_device *,char *);
ssize_t (*show_enum)(struct class_device *,char *);
ssize_t (*show_bits)(struct class_device *,char *);
ssize_t (*show_val_norm)(struct class_device *,char *);
ssize_t (*store_val_norm)(struct class_device *,
ssize_t (*show_name)(struct device *,
struct device_attribute *attr, char *);
ssize_t (*show_type)(struct device *,
struct device_attribute *attr, char *);
ssize_t (*show_min)(struct device *,
struct device_attribute *attr, char *);
ssize_t (*show_max)(struct device *,
struct device_attribute *attr, char *);
ssize_t (*show_enum)(struct device *,
struct device_attribute *attr, char *);
ssize_t (*show_bits)(struct device *,
struct device_attribute *attr, char *);
ssize_t (*show_val_norm)(struct device *,
struct device_attribute *attr, char *);
ssize_t (*store_val_norm)(struct device *,
struct device_attribute *attr,
const char *,size_t);
ssize_t (*show_val_custom)(struct class_device *,char *);
ssize_t (*store_val_custom)(struct class_device *,
ssize_t (*show_val_custom)(struct device *,
struct device_attribute *attr, char *);
ssize_t (*store_val_custom)(struct device *,
struct device_attribute *attr,
const char *,size_t);
};
@ -597,9 +609,9 @@ static void pvr2_sysfs_add_control(struct pvr2_sysfs *sfp,int ctl_id)
}
#ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
static ssize_t debuginfo_show(struct class_device *,char *);
static ssize_t debugcmd_show(struct class_device *,char *);
static ssize_t debugcmd_store(struct class_device *,const char *,size_t count);
static ssize_t debuginfo_show(struct device *,char *);
static ssize_t debugcmd_show(struct device *,char *);
static ssize_t debugcmd_store(struct device *,const char *,size_t count);
static void pvr2_sysfs_add_debugifc(struct pvr2_sysfs *sfp)
{
@ -616,16 +628,16 @@ static void pvr2_sysfs_add_debugifc(struct pvr2_sysfs *sfp)
dip->attr_debuginfo.attr.mode = S_IRUGO;
dip->attr_debuginfo.show = debuginfo_show;
sfp->debugifc = dip;
ret = class_device_create_file(sfp->class_dev,&dip->attr_debugcmd);
ret = device_create_file(sfp->class_dev,&dip->attr_debugcmd);
if (ret < 0) {
printk(KERN_WARNING "%s: class_device_create_file error: %d\n",
printk(KERN_WARNING "%s: device_create_file error: %d\n",
__FUNCTION__, ret);
} else {
dip->debugcmd_created_ok = !0;
}
ret = class_device_create_file(sfp->class_dev,&dip->attr_debuginfo);
ret = device_create_file(sfp->class_dev,&dip->attr_debuginfo);
if (ret < 0) {
printk(KERN_WARNING "%s: class_device_create_file error: %d\n",
printk(KERN_WARNING "%s: device_create_file error: %d\n",
__FUNCTION__, ret);
} else {
dip->debuginfo_created_ok = !0;
@ -637,11 +649,11 @@ static void pvr2_sysfs_tear_down_debugifc(struct pvr2_sysfs *sfp)
{
if (!sfp->debugifc) return;
if (sfp->debugifc->debuginfo_created_ok) {
class_device_remove_file(sfp->class_dev,
device_remove_file(sfp->class_dev,
&sfp->debugifc->attr_debuginfo);
}
if (sfp->debugifc->debugcmd_created_ok) {
class_device_remove_file(sfp->class_dev,
device_remove_file(sfp->class_dev,
&sfp->debugifc->attr_debugcmd);
}
kfree(sfp->debugifc);
@ -683,7 +695,7 @@ static void pvr2_sysfs_class_release(struct class *class)
}
static void pvr2_sysfs_release(struct class_device *class_dev)
static void pvr2_sysfs_release(struct device *class_dev)
{
pvr2_sysfs_trace("Releasing class_dev id=%p",class_dev);
kfree(class_dev);
@ -698,32 +710,33 @@ static void class_dev_destroy(struct pvr2_sysfs *sfp)
#endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
pvr2_sysfs_tear_down_controls(sfp);
if (sfp->bus_info_created_ok) {
class_device_remove_file(sfp->class_dev,
device_remove_file(sfp->class_dev,
&sfp->attr_bus_info);
}
if (sfp->v4l_minor_number_created_ok) {
class_device_remove_file(sfp->class_dev,
device_remove_file(sfp->class_dev,
&sfp->attr_v4l_minor_number);
}
if (sfp->v4l_radio_minor_number_created_ok) {
class_device_remove_file(sfp->class_dev,
device_remove_file(sfp->class_dev,
&sfp->attr_v4l_radio_minor_number);
}
if (sfp->unit_number_created_ok) {
class_device_remove_file(sfp->class_dev,
device_remove_file(sfp->class_dev,
&sfp->attr_unit_number);
}
pvr2_sysfs_trace("Destroying class_dev id=%p",sfp->class_dev);
sfp->class_dev->class_data = NULL;
class_device_unregister(sfp->class_dev);
sfp->class_dev->driver_data = NULL;
device_unregister(sfp->class_dev);
sfp->class_dev = NULL;
}
static ssize_t v4l_minor_number_show(struct class_device *class_dev,char *buf)
static ssize_t v4l_minor_number_show(struct device *class_dev,
struct device_attribute *attr, char *buf)
{
struct pvr2_sysfs *sfp;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
return scnprintf(buf,PAGE_SIZE,"%d\n",
pvr2_hdw_v4l_get_minor_number(sfp->channel.hdw,
@ -731,21 +744,23 @@ static ssize_t v4l_minor_number_show(struct class_device *class_dev,char *buf)
}
static ssize_t bus_info_show(struct class_device *class_dev,char *buf)
static ssize_t bus_info_show(struct device *class_dev,
struct device_attribute *attr, char *buf)
{
struct pvr2_sysfs *sfp;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
return scnprintf(buf,PAGE_SIZE,"%s\n",
pvr2_hdw_get_bus_info(sfp->channel.hdw));
}
static ssize_t v4l_radio_minor_number_show(struct class_device *class_dev,
static ssize_t v4l_radio_minor_number_show(struct device *class_dev,
struct device_attribute *attr,
char *buf)
{
struct pvr2_sysfs *sfp;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
return scnprintf(buf,PAGE_SIZE,"%d\n",
pvr2_hdw_v4l_get_minor_number(sfp->channel.hdw,
@ -753,10 +768,11 @@ static ssize_t v4l_radio_minor_number_show(struct class_device *class_dev,
}
static ssize_t unit_number_show(struct class_device *class_dev,char *buf)
static ssize_t unit_number_show(struct device *class_dev,
struct device_attribute *attr, char *buf)
{
struct pvr2_sysfs *sfp;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
return scnprintf(buf,PAGE_SIZE,"%d\n",
pvr2_hdw_get_unit_number(sfp->channel.hdw));
@ -767,7 +783,7 @@ static void class_dev_create(struct pvr2_sysfs *sfp,
struct pvr2_sysfs_class *class_ptr)
{
struct usb_device *usb_dev;
struct class_device *class_dev;
struct device *class_dev;
int ret;
usb_dev = pvr2_hdw_get_dev(sfp->channel.hdw);
@ -779,23 +795,23 @@ static void class_dev_create(struct pvr2_sysfs *sfp,
class_dev->class = &class_ptr->class;
if (pvr2_hdw_get_sn(sfp->channel.hdw)) {
snprintf(class_dev->class_id,BUS_ID_SIZE,"sn-%lu",
snprintf(class_dev->bus_id, BUS_ID_SIZE, "sn-%lu",
pvr2_hdw_get_sn(sfp->channel.hdw));
} else if (pvr2_hdw_get_unit_number(sfp->channel.hdw) >= 0) {
snprintf(class_dev->class_id,BUS_ID_SIZE,"unit-%c",
snprintf(class_dev->bus_id, BUS_ID_SIZE, "unit-%c",
pvr2_hdw_get_unit_number(sfp->channel.hdw) + 'a');
} else {
kfree(class_dev);
return;
}
class_dev->dev = &usb_dev->dev;
class_dev->parent = &usb_dev->dev;
sfp->class_dev = class_dev;
class_dev->class_data = sfp;
ret = class_device_register(class_dev);
class_dev->driver_data = sfp;
ret = device_register(class_dev);
if (ret) {
printk(KERN_ERR "%s: class_device_register failed\n",
printk(KERN_ERR "%s: device_register failed\n",
__FUNCTION__);
kfree(class_dev);
return;
@ -805,10 +821,10 @@ static void class_dev_create(struct pvr2_sysfs *sfp,
sfp->attr_v4l_minor_number.attr.mode = S_IRUGO;
sfp->attr_v4l_minor_number.show = v4l_minor_number_show;
sfp->attr_v4l_minor_number.store = NULL;
ret = class_device_create_file(sfp->class_dev,
ret = device_create_file(sfp->class_dev,
&sfp->attr_v4l_minor_number);
if (ret < 0) {
printk(KERN_WARNING "%s: class_device_create_file error: %d\n",
printk(KERN_WARNING "%s: device_create_file error: %d\n",
__FUNCTION__, ret);
} else {
sfp->v4l_minor_number_created_ok = !0;
@ -818,10 +834,10 @@ static void class_dev_create(struct pvr2_sysfs *sfp,
sfp->attr_v4l_radio_minor_number.attr.mode = S_IRUGO;
sfp->attr_v4l_radio_minor_number.show = v4l_radio_minor_number_show;
sfp->attr_v4l_radio_minor_number.store = NULL;
ret = class_device_create_file(sfp->class_dev,
ret = device_create_file(sfp->class_dev,
&sfp->attr_v4l_radio_minor_number);
if (ret < 0) {
printk(KERN_WARNING "%s: class_device_create_file error: %d\n",
printk(KERN_WARNING "%s: device_create_file error: %d\n",
__FUNCTION__, ret);
} else {
sfp->v4l_radio_minor_number_created_ok = !0;
@ -831,9 +847,9 @@ static void class_dev_create(struct pvr2_sysfs *sfp,
sfp->attr_unit_number.attr.mode = S_IRUGO;
sfp->attr_unit_number.show = unit_number_show;
sfp->attr_unit_number.store = NULL;
ret = class_device_create_file(sfp->class_dev,&sfp->attr_unit_number);
ret = device_create_file(sfp->class_dev,&sfp->attr_unit_number);
if (ret < 0) {
printk(KERN_WARNING "%s: class_device_create_file error: %d\n",
printk(KERN_WARNING "%s: device_create_file error: %d\n",
__FUNCTION__, ret);
} else {
sfp->unit_number_created_ok = !0;
@ -843,10 +859,10 @@ static void class_dev_create(struct pvr2_sysfs *sfp,
sfp->attr_bus_info.attr.mode = S_IRUGO;
sfp->attr_bus_info.show = bus_info_show;
sfp->attr_bus_info.store = NULL;
ret = class_device_create_file(sfp->class_dev,
ret = device_create_file(sfp->class_dev,
&sfp->attr_bus_info);
if (ret < 0) {
printk(KERN_WARNING "%s: class_device_create_file error: %d\n",
printk(KERN_WARNING "%s: device_create_file error: %d\n",
__FUNCTION__, ret);
} else {
sfp->bus_info_created_ok = !0;
@ -886,7 +902,7 @@ struct pvr2_sysfs *pvr2_sysfs_create(struct pvr2_context *mp,
}
static int pvr2_sysfs_hotplug(struct class_device *cd,char **envp,
static int pvr2_sysfs_hotplug(struct device *cd,char **envp,
int numenvp,char *buf,int size)
{
/* Even though we don't do anything here, we still need this function
@ -902,8 +918,8 @@ struct pvr2_sysfs_class *pvr2_sysfs_class_create(void)
pvr2_sysfs_trace("Creating pvr2_sysfs_class id=%p",clp);
clp->class.name = "pvrusb2";
clp->class.class_release = pvr2_sysfs_class_release;
clp->class.release = pvr2_sysfs_release;
clp->class.uevent = pvr2_sysfs_hotplug;
clp->class.dev_release = pvr2_sysfs_release;
clp->class.dev_uevent = pvr2_sysfs_hotplug;
if (class_register(&clp->class)) {
pvr2_sysfs_trace(
"Registration failed for pvr2_sysfs_class id=%p",clp);
@ -921,32 +937,32 @@ void pvr2_sysfs_class_destroy(struct pvr2_sysfs_class *clp)
#ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
static ssize_t debuginfo_show(struct class_device *class_dev,char *buf)
static ssize_t debuginfo_show(struct device *class_dev,char *buf)
{
struct pvr2_sysfs *sfp;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
pvr2_hdw_trigger_module_log(sfp->channel.hdw);
return pvr2_debugifc_print_info(sfp->channel.hdw,buf,PAGE_SIZE);
}
static ssize_t debugcmd_show(struct class_device *class_dev,char *buf)
static ssize_t debugcmd_show(struct device *class_dev,char *buf)
{
struct pvr2_sysfs *sfp;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
return pvr2_debugifc_print_status(sfp->channel.hdw,buf,PAGE_SIZE);
}
static ssize_t debugcmd_store(struct class_device *class_dev,
const char *buf,size_t count)
static ssize_t debugcmd_store(struct device *class_dev,
const char *buf, size_t count)
{
struct pvr2_sysfs *sfp;
int ret;
sfp = (struct pvr2_sysfs *)class_dev->class_data;
sfp = (struct pvr2_sysfs *)class_dev->driver_data;
if (!sfp) return -EINVAL;
ret = pvr2_debugifc_docmd(sfp->channel.hdw,buf,count);

27
drivers/media/video/pwc/pwc-if.c
View File

@ -996,20 +996,22 @@ int pwc_try_video_mode(struct pwc_device *pdev, int width, int height, int new_f
/*********
* sysfs
*********/
static struct pwc_device *cd_to_pwc(struct class_device *cd)
static struct pwc_device *cd_to_pwc(struct device *cd)
{
struct video_device *vdev = to_video_device(cd);
return video_get_drvdata(vdev);
}
static ssize_t show_pan_tilt(struct class_device *class_dev, char *buf)
static ssize_t show_pan_tilt(struct device *class_dev,
struct device_attribute *attr, char *buf)
{
struct pwc_device *pdev = cd_to_pwc(class_dev);
return sprintf(buf, "%d %d\n", pdev->pan_angle, pdev->tilt_angle);
}
static ssize_t store_pan_tilt(struct class_device *class_dev, const char *buf,
size_t count)
static ssize_t store_pan_tilt(struct device *class_dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct pwc_device *pdev = cd_to_pwc(class_dev);
int pan, tilt;
@ -1025,10 +1027,11 @@ static ssize_t store_pan_tilt(struct class_device *class_dev, const char *buf,
return ret;
return strlen(buf);
}
static CLASS_DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
static DEVICE_ATTR(pan_tilt, S_IRUGO | S_IWUSR, show_pan_tilt,
store_pan_tilt);
static ssize_t show_snapshot_button_status(struct class_device *class_dev, char *buf)
static ssize_t show_snapshot_button_status(struct device *class_dev,
struct device_attribute *attr, char *buf)
{
struct pwc_device *pdev = cd_to_pwc(class_dev);
int status = pdev->snapshot_button_status;
@ -1036,7 +1039,7 @@ static ssize_t show_snapshot_button_status(struct class_device *class_dev, char
return sprintf(buf, "%d\n", status);
}
static CLASS_DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
NULL);
static int pwc_create_sysfs_files(struct video_device *vdev)
@ -1044,18 +1047,18 @@ static int pwc_create_sysfs_files(struct video_device *vdev)
struct pwc_device *pdev = video_get_drvdata(vdev);
int rc;
rc = video_device_create_file(vdev, &class_device_attr_button);
rc = video_device_create_file(vdev, &dev_attr_button);
if (rc)
goto err;
if (pdev->features & FEATURE_MOTOR_PANTILT) {
rc = video_device_create_file(vdev,&class_device_attr_pan_tilt);
rc = video_device_create_file(vdev, &dev_attr_pan_tilt);
if (rc) goto err_button;
}
return 0;
err_button:
video_device_remove_file(vdev, &class_device_attr_button);
video_device_remove_file(vdev, &dev_attr_button);
err:
return rc;
}
@ -1064,8 +1067,8 @@ static void pwc_remove_sysfs_files(struct video_device *vdev)
{
struct pwc_device *pdev = video_get_drvdata(vdev);
if (pdev->features & FEATURE_MOTOR_PANTILT)
video_device_remove_file(vdev, &class_device_attr_pan_tilt);
video_device_remove_file(vdev, &class_device_attr_button);
video_device_remove_file(vdev, &dev_attr_pan_tilt);
video_device_remove_file(vdev, &dev_attr_button);
}
#ifdef CONFIG_USB_PWC_DEBUG

108
drivers/media/video/sn9c102/sn9c102_core.c
View File

@ -1029,7 +1029,8 @@ static u16 sn9c102_strtou16(const char* buff, size_t len, ssize_t* count)
NOTE 2: buffers are PAGE_SIZE long
*/
static ssize_t sn9c102_show_reg(struct class_device* cd, char* buf)
static ssize_t sn9c102_show_reg(struct device* cd,
struct device_attribute *attr, char* buf)
{
struct sn9c102_device* cam;
ssize_t count;
@ -1053,7 +1054,8 @@ static ssize_t sn9c102_show_reg(struct class_device* cd, char* buf)
static ssize_t
sn9c102_store_reg(struct class_device* cd, const char* buf, size_t len)
sn9c102_store_reg(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
struct sn9c102_device* cam;
u16 index;
@ -1086,7 +1088,8 @@ sn9c102_store_reg(struct class_device* cd, const char* buf, size_t len)
}
static ssize_t sn9c102_show_val(struct class_device* cd, char* buf)
static ssize_t sn9c102_show_val(struct device* cd,
struct device_attribute *attr, char* buf)
{
struct sn9c102_device* cam;
ssize_t count;
@ -1118,7 +1121,8 @@ static ssize_t sn9c102_show_val(struct class_device* cd, char* buf)
static ssize_t
sn9c102_store_val(struct class_device* cd, const char* buf, size_t len)
sn9c102_store_val(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
struct sn9c102_device* cam;
u16 value;
@ -1157,7 +1161,8 @@ sn9c102_store_val(struct class_device* cd, const char* buf, size_t len)
}
static ssize_t sn9c102_show_i2c_reg(struct class_device* cd, char* buf)
static ssize_t sn9c102_show_i2c_reg(struct device* cd,
struct device_attribute *attr, char* buf)
{
struct sn9c102_device* cam;
ssize_t count;
@ -1183,7 +1188,8 @@ static ssize_t sn9c102_show_i2c_reg(struct class_device* cd, char* buf)
static ssize_t
sn9c102_store_i2c_reg(struct class_device* cd, const char* buf, size_t len)
sn9c102_store_i2c_reg(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
struct sn9c102_device* cam;
u16 index;
@ -1216,7 +1222,8 @@ sn9c102_store_i2c_reg(struct class_device* cd, const char* buf, size_t len)
}
static ssize_t sn9c102_show_i2c_val(struct class_device* cd, char* buf)
static ssize_t sn9c102_show_i2c_val(struct device* cd,
struct device_attribute *attr, char* buf)
{
struct sn9c102_device* cam;
ssize_t count;
@ -1253,7 +1260,8 @@ static ssize_t sn9c102_show_i2c_val(struct class_device* cd, char* buf)
static ssize_t
sn9c102_store_i2c_val(struct class_device* cd, const char* buf, size_t len)
sn9c102_store_i2c_val(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
struct sn9c102_device* cam;
u16 value;
@ -1298,7 +1306,8 @@ sn9c102_store_i2c_val(struct class_device* cd, const char* buf, size_t len)
static ssize_t
sn9c102_store_green(struct class_device* cd, const char* buf, size_t len)
sn9c102_store_green(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
struct sn9c102_device* cam;
enum sn9c102_bridge bridge;
@ -1329,16 +1338,16 @@ sn9c102_store_green(struct class_device* cd, const char* buf, size_t len)
case BRIDGE_SN9C102:
if (value > 0x0f)
return -EINVAL;
if ((res = sn9c102_store_reg(cd, "0x11", 4)) >= 0)
res = sn9c102_store_val(cd, buf, len);
if ((res = sn9c102_store_reg(cd, attr, "0x11", 4)) >= 0)
res = sn9c102_store_val(cd, attr, buf, len);
break;
case BRIDGE_SN9C103:
case BRIDGE_SN9C105:
case BRIDGE_SN9C120:
if (value > 0x7f)
return -EINVAL;
if ((res = sn9c102_store_reg(cd, "0x07", 4)) >= 0)
res = sn9c102_store_val(cd, buf, len);
if ((res = sn9c102_store_reg(cd, attr, "0x07", 4)) >= 0)
res = sn9c102_store_val(cd, attr, buf, len);
break;
}
@ -1347,7 +1356,8 @@ sn9c102_store_green(struct class_device* cd, const char* buf, size_t len)
static ssize_t
sn9c102_store_blue(struct class_device* cd, const char* buf, size_t len)
sn9c102_store_blue(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
ssize_t res = 0;
u16 value;
@ -1357,15 +1367,16 @@ sn9c102_store_blue(struct class_device* cd, const char* buf, size_t len)
if (!count || value > 0x7f)
return -EINVAL;
if ((res = sn9c102_store_reg(cd, "0x06", 4)) >= 0)
res = sn9c102_store_val(cd, buf, len);
if ((res = sn9c102_store_reg(cd, attr, "0x06", 4)) >= 0)
res = sn9c102_store_val(cd, attr, buf, len);
return res;
}
static ssize_t
sn9c102_store_red(struct class_device* cd, const char* buf, size_t len)
sn9c102_store_red(struct device* cd, struct device_attribute *attr,
const char* buf, size_t len)
{
ssize_t res = 0;
u16 value;
@ -1375,14 +1386,16 @@ sn9c102_store_red(struct class_device* cd, const char* buf, size_t len)
if (!count || value > 0x7f)
return -EINVAL;
if ((res = sn9c102_store_reg(cd, "0x05", 4)) >= 0)
res = sn9c102_store_val(cd, buf, len);
if ((res = sn9c102_store_reg(cd, attr, "0x05", 4)) >= 0)
res = sn9c102_store_val(cd, attr, buf, len);
return res;
}
static ssize_t sn9c102_show_frame_header(struct class_device* cd, char* buf)
static ssize_t sn9c102_show_frame_header(struct device* cd,
struct device_attribute *attr,
char* buf)
{
struct sn9c102_device* cam;
ssize_t count;
@ -1401,72 +1414,63 @@ static ssize_t sn9c102_show_frame_header(struct class_device* cd, char* buf)
}
static CLASS_DEVICE_ATTR(reg, S_IRUGO | S_IWUSR,
sn9c102_show_reg, sn9c102_store_reg);
static CLASS_DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
sn9c102_show_val, sn9c102_store_val);
static CLASS_DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
static DEVICE_ATTR(reg, S_IRUGO | S_IWUSR, sn9c102_show_reg, sn9c102_store_reg);
static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, sn9c102_show_val, sn9c102_store_val);
static DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
static CLASS_DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
static DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
sn9c102_show_i2c_val, sn9c102_store_i2c_val);
static CLASS_DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
static CLASS_DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
static CLASS_DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
static CLASS_DEVICE_ATTR(frame_header, S_IRUGO,
sn9c102_show_frame_header, NULL);
static DEVICE_ATTR(green, S_IWUGO, NULL, sn9c102_store_green);
static DEVICE_ATTR(blue, S_IWUGO, NULL, sn9c102_store_blue);
static DEVICE_ATTR(red, S_IWUGO, NULL, sn9c102_store_red);
static DEVICE_ATTR(frame_header, S_IRUGO, sn9c102_show_frame_header, NULL);
static int sn9c102_create_sysfs(struct sn9c102_device* cam)
{
struct class_device *classdev = &(cam->v4ldev->class_dev);
struct device *classdev = &(cam->v4ldev->class_dev);
int err = 0;
if ((err = class_device_create_file(classdev, &class_device_attr_reg)))
if ((err = device_create_file(classdev, &dev_attr_reg)))
goto err_out;
if ((err = class_device_create_file(classdev, &class_device_attr_val)))
if ((err = device_create_file(classdev, &dev_attr_val)))
goto err_reg;
if ((err = class_device_create_file(classdev,
&class_device_attr_frame_header)))
if ((err = device_create_file(classdev, &dev_attr_frame_header)))
goto err_val;
if (cam->sensor.sysfs_ops) {
if ((err = class_device_create_file(classdev,
&class_device_attr_i2c_reg)))
if ((err = device_create_file(classdev, &dev_attr_i2c_reg)))
goto err_frame_header;
if ((err = class_device_create_file(classdev,
&class_device_attr_i2c_val)))
if ((err = device_create_file(classdev, &dev_attr_i2c_val)))
goto err_i2c_reg;
}
if (cam->bridge == BRIDGE_SN9C101 || cam->bridge == BRIDGE_SN9C102) {
if ((err = class_device_create_file(classdev,
&class_device_attr_green)))
if ((err = device_create_file(classdev, &dev_attr_green)))
goto err_i2c_val;
} else {
if ((err = class_device_create_file(classdev,
&class_device_attr_blue)))
if ((err = device_create_file(classdev, &dev_attr_blue)))
goto err_i2c_val;
if ((err = class_device_create_file(classdev,
&class_device_attr_red)))
if ((err = device_create_file(classdev, &dev_attr_red)))
goto err_blue;
}
return 0;
err_blue:
class_device_remove_file(classdev, &class_device_attr_blue);
device_remove_file(classdev, &dev_attr_blue);
err_i2c_val:
if (cam->sensor.sysfs_ops)
class_device_remove_file(classdev, &class_device_attr_i2c_val);
device_remove_file(classdev, &dev_attr_i2c_val);
err_i2c_reg:
if (cam->sensor.sysfs_ops)
class_device_remove_file(classdev, &class_device_attr_i2c_reg);
device_remove_file(classdev, &dev_attr_i2c_reg);
err_frame_header:
class_device_remove_file(classdev, &class_device_attr_frame_header);
device_remove_file(classdev, &dev_attr_frame_header);
err_val:
class_device_remove_file(classdev, &class_device_attr_val);
device_remove_file(classdev, &dev_attr_val);
err_reg:
class_device_remove_file(classdev, &class_device_attr_reg);
device_remove_file(classdev, &dev_attr_reg);
err_out:
return err;
}

51
drivers/media/video/stv680.c
View File

@ -499,13 +499,14 @@ exit:
* sysfs
***************************************************************************/
#define stv680_file(name, variable, field) \
static ssize_t show_##name(struct class_device *class_dev, char *buf) \
static ssize_t show_##name(struct device *class_dev, \
struct device_attribute *attr, char *buf) \
{ \
struct video_device *vdev = to_video_device(class_dev); \
struct usb_stv *stv = video_get_drvdata(vdev); \
return sprintf(buf, field, stv->variable); \
} \
static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
stv680_file(model, camera_name, "%s\n");
stv680_file(in_use, user, "%d\n");
@ -520,53 +521,53 @@ static int stv680_create_sysfs_files(struct video_device *vdev)
{
int rc;
rc = video_device_create_file(vdev, &class_device_attr_model);
rc = video_device_create_file(vdev, &dev_attr_model);
if (rc) goto err;
rc = video_device_create_file(vdev, &class_device_attr_in_use);
rc = video_device_create_file(vdev, &dev_attr_in_use);
if (rc) goto err_model;
rc = video_device_create_file(vdev, &class_device_attr_streaming);
rc = video_device_create_file(vdev, &dev_attr_streaming);
if (rc) goto err_inuse;
rc = video_device_create_file(vdev, &class_device_attr_palette);
rc = video_device_create_file(vdev, &dev_attr_palette);
if (rc) goto err_stream;
rc = video_device_create_file(vdev, &class_device_attr_frames_total);
rc = video_device_create_file(vdev, &dev_attr_frames_total);
if (rc) goto err_pal;
rc = video_device_create_file(vdev, &class_device_attr_frames_read);
rc = video_device_create_file(vdev, &dev_attr_frames_read);
if (rc) goto err_framtot;
rc = video_device_create_file(vdev, &class_device_attr_packets_dropped);
rc = video_device_create_file(vdev, &dev_attr_packets_dropped);
if (rc) goto err_framread;
rc = video_device_create_file(vdev, &class_device_attr_decoding_errors);
rc = video_device_create_file(vdev, &dev_attr_decoding_errors);
if (rc) goto err_dropped;
return 0;
err_dropped:
video_device_remove_file(vdev, &class_device_attr_packets_dropped);
video_device_remove_file(vdev, &dev_attr_packets_dropped);
err_framread:
video_device_remove_file(vdev, &class_device_attr_frames_read);
video_device_remove_file(vdev, &dev_attr_frames_read);
err_framtot:
video_device_remove_file(vdev, &class_device_attr_frames_total);
video_device_remove_file(vdev, &dev_attr_frames_total);
err_pal:
video_device_remove_file(vdev, &class_device_attr_palette);
video_device_remove_file(vdev, &dev_attr_palette);
err_stream:
video_device_remove_file(vdev, &class_device_attr_streaming);
video_device_remove_file(vdev, &dev_attr_streaming);
err_inuse:
video_device_remove_file(vdev, &class_device_attr_in_use);
video_device_remove_file(vdev, &dev_attr_in_use);
err_model:
video_device_remove_file(vdev, &class_device_attr_model);
video_device_remove_file(vdev, &dev_attr_model);
err:
return rc;
}
static void stv680_remove_sysfs_files(struct video_device *vdev)
{
video_device_remove_file(vdev, &class_device_attr_model);
video_device_remove_file(vdev, &class_device_attr_in_use);
video_device_remove_file(vdev, &class_device_attr_streaming);
video_device_remove_file(vdev, &class_device_attr_palette);
video_device_remove_file(vdev, &class_device_attr_frames_total);
video_device_remove_file(vdev, &class_device_attr_frames_read);
video_device_remove_file(vdev, &class_device_attr_packets_dropped);
video_device_remove_file(vdev, &class_device_attr_decoding_errors);
video_device_remove_file(vdev, &dev_attr_model);
video_device_remove_file(vdev, &dev_attr_in_use);
video_device_remove_file(vdev, &dev_attr_streaming);
video_device_remove_file(vdev, &dev_attr_palette);
video_device_remove_file(vdev, &dev_attr_frames_total);
video_device_remove_file(vdev, &dev_attr_frames_read);
video_device_remove_file(vdev, &dev_attr_packets_dropped);
video_device_remove_file(vdev, &dev_attr_decoding_errors);
}
/********************************************************************

119
drivers/media/video/usbvision/usbvision-video.c
View File

@ -182,20 +182,22 @@ MODULE_ALIAS(DRIVER_ALIAS);
#define YES_NO(x) ((x) ? "Yes" : "No")
static inline struct usb_usbvision *cd_to_usbvision(struct class_device *cd)
static inline struct usb_usbvision *cd_to_usbvision(struct device *cd)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
return video_get_drvdata(vdev);
}
static ssize_t show_version(struct class_device *cd, char *buf)
static ssize_t show_version(struct device *cd,
struct device_attribute *attr, char *buf)
{
return sprintf(buf, "%s\n", USBVISION_VERSION_STRING);
}
static CLASS_DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
static ssize_t show_model(struct class_device *cd, char *buf)
static ssize_t show_model(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
@ -203,9 +205,10 @@ static ssize_t show_model(struct class_device *cd, char *buf)
return sprintf(buf, "%s\n",
usbvision_device_data[usbvision->DevModel].ModelString);
}
static CLASS_DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
static DEVICE_ATTR(model, S_IRUGO, show_model, NULL);
static ssize_t show_hue(struct class_device *cd, char *buf)
static ssize_t show_hue(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
@ -217,9 +220,10 @@ static ssize_t show_hue(struct class_device *cd, char *buf)
call_i2c_clients(usbvision, VIDIOC_G_CTRL, &ctrl);
return sprintf(buf, "%d\n", ctrl.value);
}
static CLASS_DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);
static DEVICE_ATTR(hue, S_IRUGO, show_hue, NULL);
static ssize_t show_contrast(struct class_device *cd, char *buf)
static ssize_t show_contrast(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
@ -231,9 +235,10 @@ static ssize_t show_contrast(struct class_device *cd, char *buf)
call_i2c_clients(usbvision, VIDIOC_G_CTRL, &ctrl);
return sprintf(buf, "%d\n", ctrl.value);
}
static CLASS_DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);
static DEVICE_ATTR(contrast, S_IRUGO, show_contrast, NULL);
static ssize_t show_brightness(struct class_device *cd, char *buf)
static ssize_t show_brightness(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
@ -245,9 +250,10 @@ static ssize_t show_brightness(struct class_device *cd, char *buf)
call_i2c_clients(usbvision, VIDIOC_G_CTRL, &ctrl);
return sprintf(buf, "%d\n", ctrl.value);
}
static CLASS_DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);
static DEVICE_ATTR(brightness, S_IRUGO, show_brightness, NULL);
static ssize_t show_saturation(struct class_device *cd, char *buf)
static ssize_t show_saturation(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
@ -259,9 +265,10 @@ static ssize_t show_saturation(struct class_device *cd, char *buf)
call_i2c_clients(usbvision, VIDIOC_G_CTRL, &ctrl);
return sprintf(buf, "%d\n", ctrl.value);
}
static CLASS_DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);
static DEVICE_ATTR(saturation, S_IRUGO, show_saturation, NULL);
static ssize_t show_streaming(struct class_device *cd, char *buf)
static ssize_t show_streaming(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
@ -269,9 +276,10 @@ static ssize_t show_streaming(struct class_device *cd, char *buf)
return sprintf(buf, "%s\n",
YES_NO(usbvision->streaming==Stream_On?1:0));
}
static CLASS_DEVICE_ATTR(streaming, S_IRUGO, show_streaming, NULL);
static DEVICE_ATTR(streaming, S_IRUGO, show_streaming, NULL);
static ssize_t show_compression(struct class_device *cd, char *buf)
static ssize_t show_compression(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
@ -279,16 +287,17 @@ static ssize_t show_compression(struct class_device *cd, char *buf)
return sprintf(buf, "%s\n",
YES_NO(usbvision->isocMode==ISOC_MODE_COMPRESS));
}
static CLASS_DEVICE_ATTR(compression, S_IRUGO, show_compression, NULL);
static DEVICE_ATTR(compression, S_IRUGO, show_compression, NULL);
static ssize_t show_device_bridge(struct class_device *cd, char *buf)
static ssize_t show_device_bridge(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vdev =
container_of(cd, struct video_device, class_dev);
struct usb_usbvision *usbvision = video_get_drvdata(vdev);
return sprintf(buf, "%d\n", usbvision->bridgeType);
}
static CLASS_DEVICE_ATTR(bridge, S_IRUGO, show_device_bridge, NULL);
static DEVICE_ATTR(bridge, S_IRUGO, show_device_bridge, NULL);
static void usbvision_create_sysfs(struct video_device *vdev)
{
@ -296,40 +305,40 @@ static void usbvision_create_sysfs(struct video_device *vdev)
if (!vdev)
return;
do {
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_version);
res = device_create_file(&vdev->class_dev,
&dev_attr_version);
if (res<0)
break;
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_model);
res = device_create_file(&vdev->class_dev,
&dev_attr_model);
if (res<0)
break;
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_hue);
res = device_create_file(&vdev->class_dev,
&dev_attr_hue);
if (res<0)
break;
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_contrast);
res = device_create_file(&vdev->class_dev,
&dev_attr_contrast);
if (res<0)
break;
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_brightness);
res = device_create_file(&vdev->class_dev,
&dev_attr_brightness);
if (res<0)
break;
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_saturation);
res = device_create_file(&vdev->class_dev,
&dev_attr_saturation);
if (res<0)
break;
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_streaming);
res = device_create_file(&vdev->class_dev,
&dev_attr_streaming);
if (res<0)
break;
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_compression);
res = device_create_file(&vdev->class_dev,
&dev_attr_compression);
if (res<0)
break;
res=class_device_create_file(&vdev->class_dev,
&class_device_attr_bridge);
res = device_create_file(&vdev->class_dev,
&dev_attr_bridge);
if (res>=0)
return;
} while (0);
@ -340,24 +349,24 @@ static void usbvision_create_sysfs(struct video_device *vdev)
static void usbvision_remove_sysfs(struct video_device *vdev)
{
if (vdev) {
class_device_remove_file(&vdev->class_dev,
&class_device_attr_version);
class_device_remove_file(&vdev->class_dev,
&class_device_attr_model);
class_device_remove_file(&vdev->class_dev,
&class_device_attr_hue);
class_device_remove_file(&vdev->class_dev,
&class_device_attr_contrast);
class_device_remove_file(&vdev->class_dev,
&class_device_attr_brightness);
class_device_remove_file(&vdev->class_dev,
&class_device_attr_saturation);
class_device_remove_file(&vdev->class_dev,
&class_device_attr_streaming);
class_device_remove_file(&vdev->class_dev,
&class_device_attr_compression);
class_device_remove_file(&vdev->class_dev,
&class_device_attr_bridge);
device_remove_file(&vdev->class_dev,
&dev_attr_version);
device_remove_file(&vdev->class_dev,
&dev_attr_model);
device_remove_file(&vdev->class_dev,
&dev_attr_hue);
device_remove_file(&vdev->class_dev,
&dev_attr_contrast);
device_remove_file(&vdev->class_dev,
&dev_attr_brightness);
device_remove_file(&vdev->class_dev,
&dev_attr_saturation);
device_remove_file(&vdev->class_dev,
&dev_attr_streaming);
device_remove_file(&vdev->class_dev,
&dev_attr_compression);
device_remove_file(&vdev->class_dev,
&dev_attr_bridge);
}
}

38
drivers/media/video/videodev.c
View File

@ -54,15 +54,14 @@
* sysfs stuff
*/
static ssize_t show_name(struct class_device *cd, char *buf)
static ssize_t show_name(struct device *cd,
struct device_attribute *attr, char *buf)
{
struct video_device *vfd = container_of(cd, struct video_device,
class_dev);
return sprintf(buf,"%.*s\n",(int)sizeof(vfd->name),vfd->name);
return sprintf(buf, "%.*s\n", (int)sizeof(vfd->name), vfd->name);
}
static CLASS_DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
struct video_device *video_device_alloc(void)
{
struct video_device *vfd;
@ -76,10 +75,9 @@ void video_device_release(struct video_device *vfd)
kfree(vfd);
}
static void video_release(struct class_device *cd)
static void video_release(struct device *cd)
{
struct video_device *vfd = container_of(cd, struct video_device,
class_dev);
struct video_device *vfd = container_of(cd, struct video_device, class_dev);
#if 1
/* needed until all drivers are fixed */
@ -89,9 +87,15 @@ static void video_release(struct class_device *cd)
vfd->release(vfd);
}
static struct device_attribute video_device_attrs[] = {
__ATTR(name, S_IRUGO, show_name, NULL),
__ATTR_NULL
};
static struct class video_class = {
.name = VIDEO_NAME,
.release = video_release,
.dev_attrs = video_device_attrs,
.dev_release = video_release,
};
/*
@ -1753,22 +1757,16 @@ int video_register_device(struct video_device *vfd, int type, int nr)
/* sysfs class */
memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));
if (vfd->dev)
vfd->class_dev.dev = vfd->dev;
vfd->class_dev.parent = vfd->dev;
vfd->class_dev.class = &video_class;
vfd->class_dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
sprintf(vfd->class_dev.class_id, "%s%d", name_base, i - base);
ret = class_device_register(&vfd->class_dev);
sprintf(vfd->class_dev.bus_id, "%s%d", name_base, i - base);
ret = device_register(&vfd->class_dev);
if (ret < 0) {
printk(KERN_ERR "%s: class_device_register failed\n",
printk(KERN_ERR "%s: device_register failed\n",
__FUNCTION__);
goto fail_minor;
}
ret = class_device_create_file(&vfd->class_dev, &class_device_attr_name);
if (ret < 0) {
printk(KERN_ERR "%s: class_device_create_file 'name' failed\n",
__FUNCTION__);
goto fail_classdev;
}
#if 1
/* needed until all drivers are fixed */
@ -1779,8 +1777,6 @@ int video_register_device(struct video_device *vfd, int type, int nr)
#endif
return 0;
fail_classdev:
class_device_unregister(&vfd->class_dev);
fail_minor:
mutex_lock(&videodev_lock);
video_device[vfd->minor] = NULL;
@ -1804,7 +1800,7 @@ void video_unregister_device(struct video_device *vfd)
panic("videodev: bad unregister");
video_device[vfd->minor]=NULL;
class_device_unregister(&vfd->class_dev);
device_unregister(&vfd->class_dev);
mutex_unlock(&videodev_lock);
}

14
include/media/v4l2-dev.h
View File

@ -86,8 +86,11 @@ struct video_device
/* device ops */
const struct file_operations *fops;
/* sysfs */
struct device class_dev; /* v4l device */
struct device *dev; /* device parent */
/* device info */
struct device *dev;
char name[32];
int type; /* v4l1 */
int type2; /* v4l2 */
@ -332,7 +335,6 @@ void *priv;
/* for videodev.c intenal usage -- please don't touch */
int users; /* video_exclusive_{open|close} ... */
struct mutex lock; /* ... helper function uses these */
struct class_device class_dev; /* sysfs */
};
/* Class-dev to video-device */
@ -360,18 +362,18 @@ extern int video_usercopy(struct inode *inode, struct file *file,
static inline int __must_check
video_device_create_file(struct video_device *vfd,
struct class_device_attribute *attr)
struct device_attribute *attr)
{
int ret = class_device_create_file(&vfd->class_dev, attr);
int ret = device_create_file(&vfd->class_dev, attr);
if (ret < 0)
printk(KERN_WARNING "%s error: %d\n", __FUNCTION__, ret);
return ret;
}
static inline void
video_device_remove_file(struct video_device *vfd,
struct class_device_attribute *attr)
struct device_attribute *attr)
{
class_device_remove_file(&vfd->class_dev, attr);
device_remove_file(&vfd->class_dev, attr);
}
#endif /* CONFIG_VIDEO_V4L1_COMPAT */