USB: make usbdevices export their device nodes instead of using a separate class

[linux-2.6-omap-h63xx.git] / drivers / usb / core / devio.c

diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index fc3545ddb06e14d7b8b25fc61768f9b82ec489a9..e023f3d562483cc2c7dfd1052d83b2eb7ca30b39 100644 (file)
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -57,7 +57,6 @@
 
 #define USB_MAXBUS                     64
 #define USB_DEVICE_MAX                 USB_MAXBUS * 128
-static struct class *usb_device_class;
 
 /* Mutual exclusion for removal, open, and release */
 DEFINE_MUTEX(usbfs_mutex);
@@ -514,22 +513,25 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, unsig
        return ret;
 }
 
-static struct usb_device *usbdev_lookup_minor(int minor)
+static int __match_minor(struct device *dev, void *data)
 {
-       struct device *device;
-       struct usb_device *udev = NULL;
+       int minor = *((int *)data);
 
-       down(&usb_device_class->sem);
-       list_for_each_entry(device, &usb_device_class->devices, node) {
-               if (device->devt == MKDEV(USB_DEVICE_MAJOR, minor)) {
-                       udev = device->platform_data;
-                       break;
-               }
-       }
-       up(&usb_device_class->sem);
+       if (dev->devt == MKDEV(USB_DEVICE_MAJOR, minor))
+               return 1;
+       return 0;
+}
 
-       return udev;
-};
+static struct usb_device *usbdev_lookup_by_minor(int minor)
+{
+       struct device *dev;
+
+       dev = bus_find_device(&usb_bus_type, NULL, &minor, __match_minor);
+       if (!dev)
+               return NULL;
+       put_device(dev);
+       return container_of(dev, struct usb_device, dev);
+}
 
 /*
  * file operations
@@ -548,11 +550,14 @@ static int usbdev_open(struct inode *inode, struct file *file)
                goto out;
 
        ret = -ENOENT;
-       /* check if we are called from a real node or usbfs */
+       /* usbdev device-node */
        if (imajor(inode) == USB_DEVICE_MAJOR)
-               dev = usbdev_lookup_minor(iminor(inode));
+               dev = usbdev_lookup_by_minor(iminor(inode));
+#ifdef CONFIG_USB_DEVICEFS
+       /* procfs file */
        if (!dev)
                dev = inode->i_private;
+#endif
        if (!dev)
                goto out;
        ret = usb_autoresume_device(dev);
@@ -1570,7 +1575,7 @@ static unsigned int usbdev_poll(struct file *file, struct poll_table_struct *wai
        return mask;
 }
 
-const struct file_operations usbfs_device_file_operations = {
+const struct file_operations usbdev_file_operations = {
        .llseek =       usbdev_lseek,
        .read =         usbdev_read,
        .poll =         usbdev_poll,
@@ -1579,50 +1584,53 @@ const struct file_operations usbfs_device_file_operations = {
        .release =      usbdev_release,
 };
 
-static int usbdev_add(struct usb_device *dev)
+#ifdef CONFIG_USB_DEVICE_CLASS
+static struct class *usb_classdev_class;
+
+static int usb_classdev_add(struct usb_device *dev)
 {
        int minor = ((dev->bus->busnum-1) * 128) + (dev->devnum-1);
 
-       dev->usbfs_dev = device_create(usb_device_class, &dev->dev,
+       dev->usb_classdev = device_create(usb_classdev_class, &dev->dev,
                                MKDEV(USB_DEVICE_MAJOR, minor),
                                "usbdev%d.%d", dev->bus->busnum, dev->devnum);
-       if (IS_ERR(dev->usbfs_dev))
-               return PTR_ERR(dev->usbfs_dev);
+       if (IS_ERR(dev->usb_classdev))
+               return PTR_ERR(dev->usb_classdev);
 
-       dev->usbfs_dev->platform_data = dev;
        return 0;
 }
 
-static void usbdev_remove(struct usb_device *dev)
+static void usb_classdev_remove(struct usb_device *dev)
 {
-       device_unregister(dev->usbfs_dev);
+       device_unregister(dev->usb_classdev);
 }
 
-static int usbdev_notify(struct notifier_block *self, unsigned long action,
-                        void *dev)
+static int usb_classdev_notify(struct notifier_block *self,
+                              unsigned long action, void *dev)
 {
        switch (action) {
        case USB_DEVICE_ADD:
-               if (usbdev_add(dev))
+               if (usb_classdev_add(dev))
                        return NOTIFY_BAD;
                break;
        case USB_DEVICE_REMOVE:
-               usbdev_remove(dev);
+               usb_classdev_remove(dev);
                break;
        }
        return NOTIFY_OK;
 }
 
 static struct notifier_block usbdev_nb = {
-       .notifier_call =        usbdev_notify,
+       .notifier_call =        usb_classdev_notify,
 };
+#endif
 
 static struct cdev usb_device_cdev = {
        .kobj   = {.name = "usb_device", },
        .owner  = THIS_MODULE,
 };
 
-int __init usbdev_init(void)
+int __init usb_devio_init(void)
 {
        int retval;
 
@@ -1632,38 +1640,38 @@ int __init usbdev_init(void)
                err("unable to register minors for usb_device");
                goto out;
        }
-       cdev_init(&usb_device_cdev, &usbfs_device_file_operations);
+       cdev_init(&usb_device_cdev, &usbdev_file_operations);
        retval = cdev_add(&usb_device_cdev, USB_DEVICE_DEV, USB_DEVICE_MAX);
        if (retval) {
                err("unable to get usb_device major %d", USB_DEVICE_MAJOR);
                goto error_cdev;
        }
-       usb_device_class = class_create(THIS_MODULE, "usb_device");
-       if (IS_ERR(usb_device_class)) {
+#ifdef CONFIG_USB_DEVICE_CLASS
+       usb_classdev_class = class_create(THIS_MODULE, "usb_device");
+       if (IS_ERR(usb_classdev_class)) {
                err("unable to register usb_device class");
-               retval = PTR_ERR(usb_device_class);
-               goto error_class;
+               retval = PTR_ERR(usb_classdev_class);
+               cdev_del(&usb_device_cdev);
+               usb_classdev_class = NULL;
+               goto out;
        }
 
        usb_register_notify(&usbdev_nb);
-
+#endif
 out:
        return retval;
 
-error_class:
-       usb_device_class = NULL;
-       cdev_del(&usb_device_cdev);
-
 error_cdev:
        unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
        goto out;
 }
 
-void usbdev_cleanup(void)
+void usb_devio_cleanup(void)
 {
+#ifdef CONFIG_USB_DEVICE_CLASS
        usb_unregister_notify(&usbdev_nb);
-       class_destroy(usb_device_class);
+       class_destroy(usb_classdev_class);
+#endif
        cdev_del(&usb_device_cdev);
        unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
 }
-