]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
V4L/DVB (6293): V4L: convert struct class_device to struct device
authorKay Sievers <kay.sievers@vrfy.org>
Mon, 8 Oct 2007 19:26:13 +0000 (16:26 -0300)
committerMauro Carvalho Chehab <mchehab@infradead.org>
Wed, 10 Oct 2007 03:03:14 +0000 (00:03 -0300)
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>
drivers/media/video/bt8xx/bttv-driver.c
drivers/media/video/et61x251/et61x251_core.c
drivers/media/video/ov511.c
drivers/media/video/pvrusb2/pvrusb2-sysfs.c
drivers/media/video/pwc/pwc-if.c
drivers/media/video/sn9c102/sn9c102_core.c
drivers/media/video/stv680.c
drivers/media/video/usbvision/usbvision-video.c
drivers/media/video/videodev.c
include/media/v4l2-dev.h

index 4ab4e14b5c645261e041812940c60bd6cbf83276..49278537eec4bbd9122b1567297046fe5421b9b8 100644 (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;
        }
index 31062a981e36cbfb5f9fb47c275960f314569c7b..d5fef4c01c87a9ff0f100a34f9925670245a32eb 100644 (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,
-                        et61x251_show_reg, et61x251_store_reg);
-static CLASS_DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
-                        et61x251_show_val, et61x251_store_val);
-static CLASS_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,
-                        et61x251_show_i2c_val, et61x251_store_i2c_val);
+static DEVICE_ATTR(reg, S_IRUGO | S_IWUSR,
+                  et61x251_show_reg, et61x251_store_reg);
+static DEVICE_ATTR(val, S_IRUGO | S_IWUSR,
+                  et61x251_show_val, et61x251_store_val);
+static DEVICE_ATTR(i2c_reg, S_IRUGO | S_IWUSR,
+                  et61x251_show_i2c_reg, et61x251_store_i2c_reg);
+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;
 }
index e5edff1059a28f43f8a7487f25ac859a9c306d13..9eb2562347a8dd19622ae94b53ef43c1255ff41e 100644 (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;
 }
index 7ab79baa1c8ce43aa771e21001b83e24006d25e5..b20dc4421d592630fe379dc85abda523d67b3944 100644 (file)
 
 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);
index 0ff5718bf9b92d7c37eae208b0adf33b905c689b..0b67d4ec0318f7ab9ef675940cb45057aad12524 100644 (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,
-                        store_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,26 +1039,26 @@ 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,
-                        NULL);
+static DEVICE_ATTR(button, S_IRUGO | S_IWUSR, show_snapshot_button_status,
+                  NULL);
 
 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
index e0accf1b87135b771fb5ba733b48c96be4e2e0a7..6991e06f7651a1601c33688f10bc4e1f16e37f5d 100644 (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,
-                        sn9c102_show_i2c_reg, sn9c102_store_i2c_reg);
-static CLASS_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(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 DEVICE_ATTR(i2c_val, S_IRUGO | S_IWUSR,
+                  sn9c102_show_i2c_val, sn9c102_store_i2c_val);
+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;
 }
index 4dc5bc714b953044467a8b7020a65884767ed51b..9e009a7ab863d020a9fe01e42c4174027c5c8af3 100644 (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);
 }
 
 /********************************************************************
index 2f9b2b9e3b0988b51afd84b5dece4a8fa78a33ac..e2f3c01cfa134c2290507d3de9d806554bbc69a6 100644 (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);
        }
 }
 
index 0334b9aaf12ad63dc8200e03adb9f61fa7c7f1dd..0fbe8a1a91b3681812216edd62880585a2f66d07 100644 (file)
  *     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);
+                                               class_dev);
+       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);
 }
 
index 8b79e2cf77fa1c0dffbfffd8b8af1f45b5eac1d9..e75d5e6c4cea083ed8429b1fe1adaa09d6e63cd9 100644 (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 */