[Bluetooth] Use real devices for host controllers

This patch converts the Bluetooth class devices into real devices. The
Bluetooth class is kept and the driver core provides the appropriate
symlinks for backward compatibility.

Signed-off-by: Marcel Holtmann <marcel@holtmann.org>

diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index 911ceb5cd263b51c90eee3e5803cee3206a88bd8..771d17783c1889d7d89d7875bdfb28a350e9d4e7 100644 (file)
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -175,6 +175,6 @@ extern int hci_sock_cleanup(void);
 extern int bt_sysfs_init(void);
 extern void bt_sysfs_cleanup(void);
 
-extern struct class bt_class;
+extern struct class *bt_class;
 
 #endif /* __BLUETOOTH_H */

diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index ae67b36d76dc108568518db52d00b2d6ad31af47..d84855fe7336d24938e0aed2055aaf316818cefe 100644 (file)
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -124,8 +124,8 @@ struct hci_dev {
 
        atomic_t                promisc;
 
-       struct device           *dev;
-       struct class_device     class_dev;
+       struct device           *parent;
+       struct device           dev;
 
        struct module           *owner;
 
@@ -413,7 +413,7 @@ static inline int hci_recv_frame(struct sk_buff *skb)
 int hci_register_sysfs(struct hci_dev *hdev);
 void hci_unregister_sysfs(struct hci_dev *hdev);
 
-#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->class_dev.dev = (pdev))
+#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev))
 
 /* ----- LMP capabilities ----- */
 #define lmp_rswitch_capable(dev)   ((dev)->features[0] & LMP_RSWITCH)

diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c
index 3f9f1565bf061f4089858e844ae8b7ed2edbbd2f..54e8e5ea21542ef47d87dcb84e47ae9917a581b1 100644 (file)
--- a/net/bluetooth/hci_core.c
+++ b/net/bluetooth/hci_core.c
@@ -817,8 +817,8 @@ void hci_free_dev(struct hci_dev *hdev)
 {
        skb_queue_purge(&hdev->driver_init);
 
-       /* will free via class release */
-       class_device_put(&hdev->class_dev);
+       /* will free via device release */
+       put_device(&hdev->dev);
 }
 EXPORT_SYMBOL(hci_free_dev);
 

diff --git a/net/bluetooth/hci_sysfs.c b/net/bluetooth/hci_sysfs.c
index 7789e26c84b9d20afc748d13d8e65b8d62f22d4d..3987d167f04e73225ea98556bd1f583c899e9223 100644 (file)
--- a/net/bluetooth/hci_sysfs.c
+++ b/net/bluetooth/hci_sysfs.c
@@ -13,35 +13,35 @@
 #define BT_DBG(D...)
 #endif
 
-static ssize_t show_name(struct class_device *cdev, char *buf)
+static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        return sprintf(buf, "%s\n", hdev->name);
 }
 
-static ssize_t show_type(struct class_device *cdev, char *buf)
+static ssize_t show_type(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", hdev->type);
 }
 
-static ssize_t show_address(struct class_device *cdev, char *buf)
+static ssize_t show_address(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        bdaddr_t bdaddr;
        baswap(&bdaddr, &hdev->bdaddr);
        return sprintf(buf, "%s\n", batostr(&bdaddr));
 }
 
-static ssize_t show_flags(struct class_device *cdev, char *buf)
+static ssize_t show_flags(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        return sprintf(buf, "0x%lx\n", hdev->flags);
 }
 
-static ssize_t show_inquiry_cache(struct class_device *cdev, char *buf)
+static ssize_t show_inquiry_cache(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        struct inquiry_cache *cache = &hdev->inq_cache;
        struct inquiry_entry *e;
        int n = 0;
@@ -63,15 +63,15 @@ static ssize_t show_inquiry_cache(struct class_device *cdev, char *buf)
        return n;
 }
 
-static ssize_t show_idle_timeout(struct class_device *cdev, char *buf)
+static ssize_t show_idle_timeout(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", hdev->idle_timeout);
 }
 
-static ssize_t store_idle_timeout(struct class_device *cdev, const char *buf, size_t count)
+static ssize_t store_idle_timeout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        char *ptr;
        __u32 val;
 
@@ -87,15 +87,15 @@ static ssize_t store_idle_timeout(struct class_device *cdev, const char *buf, si
        return count;
 }
 
-static ssize_t show_sniff_max_interval(struct class_device *cdev, char *buf)
+static ssize_t show_sniff_max_interval(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", hdev->sniff_max_interval);
 }
 
-static ssize_t store_sniff_max_interval(struct class_device *cdev, const char *buf, size_t count)
+static ssize_t store_sniff_max_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        char *ptr;
        __u16 val;
 
@@ -114,15 +114,15 @@ static ssize_t store_sniff_max_interval(struct class_device *cdev, const char *b
        return count;
 }
 
-static ssize_t show_sniff_min_interval(struct class_device *cdev, char *buf)
+static ssize_t show_sniff_min_interval(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        return sprintf(buf, "%d\n", hdev->sniff_min_interval);
 }
 
-static ssize_t store_sniff_min_interval(struct class_device *cdev, const char *buf, size_t count)
+static ssize_t store_sniff_min_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
-       struct hci_dev *hdev = class_get_devdata(cdev);
+       struct hci_dev *hdev = dev_get_drvdata(dev);
        char *ptr;
        __u16 val;
 
@@ -141,64 +141,32 @@ static ssize_t store_sniff_min_interval(struct class_device *cdev, const char *b
        return count;
 }
 
-static CLASS_DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
-static CLASS_DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
-static CLASS_DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
-static CLASS_DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);
-static CLASS_DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL);
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
+static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
+static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);
+static DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL);
 
-static CLASS_DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
+static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
                                show_idle_timeout, store_idle_timeout);
-static CLASS_DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR,
+static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR,
                                show_sniff_max_interval, store_sniff_max_interval);
-static CLASS_DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
+static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
                                show_sniff_min_interval, store_sniff_min_interval);
 
-static struct class_device_attribute *bt_attrs[] = {
-       &class_device_attr_name,
-       &class_device_attr_type,
-       &class_device_attr_address,
-       &class_device_attr_flags,
-       &class_device_attr_inquiry_cache,
-       &class_device_attr_idle_timeout,
-       &class_device_attr_sniff_max_interval,
-       &class_device_attr_sniff_min_interval,
+static struct device_attribute *bt_attrs[] = {
+       &dev_attr_name,
+       &dev_attr_type,
+       &dev_attr_address,
+       &dev_attr_flags,
+       &dev_attr_inquiry_cache,
+       &dev_attr_idle_timeout,
+       &dev_attr_sniff_max_interval,
+       &dev_attr_sniff_min_interval,
        NULL
 };
 
-#ifdef CONFIG_HOTPLUG
-static int bt_uevent(struct class_device *cdev, char **envp, int num_envp, char *buf, int size)
-{
-       struct hci_dev *hdev = class_get_devdata(cdev);
-       int n, i = 0;
-
-       envp[i++] = buf;
-       n = snprintf(buf, size, "INTERFACE=%s", hdev->name) + 1;
-       buf += n;
-       size -= n;
-
-       if ((size <= 0) || (i >= num_envp))
-               return -ENOMEM;
-
-       envp[i] = NULL;
-       return 0;
-}
-#endif
-
-static void bt_release(struct class_device *cdev)
-{
-       struct hci_dev *hdev = class_get_devdata(cdev);
-
-       kfree(hdev);
-}
-
-struct class bt_class = {
-       .name           = "bluetooth",
-       .release        = bt_release,
-#ifdef CONFIG_HOTPLUG
-       .uevent         = bt_uevent,
-#endif
-};
+struct class *bt_class = NULL;
 EXPORT_SYMBOL_GPL(bt_class);
 
 static struct bus_type bt_bus = {
@@ -207,40 +175,50 @@ static struct bus_type bt_bus = {
 
 static struct platform_device *bt_platform;
 
+static void bt_release(struct device *dev)
+{
+       struct hci_dev *hdev = dev_get_drvdata(dev);
+       kfree(hdev);
+}
+
 int hci_register_sysfs(struct hci_dev *hdev)
 {
-       struct class_device *cdev = &hdev->class_dev;
+       struct device *dev = &hdev->dev;
        unsigned int i;
        int err;
 
        BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
 
-       cdev->class = &bt_class;
-       class_set_devdata(cdev, hdev);
+       dev->class = bt_class;
+
+       if (hdev->parent)
+               dev->parent = hdev->parent;
+       else
+               dev->parent = &bt_platform->dev;
+
+       strlcpy(dev->bus_id, hdev->name, BUS_ID_SIZE);
 
-       if (!cdev->dev)
-               cdev->dev = &bt_platform->dev;
+       dev->release = bt_release;
 
-       hdev->dev = cdev->dev;
+       dev_set_drvdata(dev, hdev);
 
-       strlcpy(cdev->class_id, hdev->name, BUS_ID_SIZE);
-       err = class_device_register(cdev);
+       err = device_register(dev);
        if (err < 0)
                return err;
 
        for (i = 0; bt_attrs[i]; i++)
-               class_device_create_file(cdev, bt_attrs[i]);
+               device_create_file(dev, bt_attrs[i]);
 
        return 0;
 }
 
 void hci_unregister_sysfs(struct hci_dev *hdev)
 {
-       struct class_device * cdev = &hdev->class_dev;
+       struct device *dev = &hdev->dev;
 
        BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
 
-       class_device_del(cdev);
+       device_del(dev);
 }
 
 int __init bt_sysfs_init(void)
@@ -257,11 +235,11 @@ int __init bt_sysfs_init(void)
                return err;
        }
 
-       err = class_register(&bt_class);
-       if (err < 0) {
+       bt_class = class_create(THIS_MODULE, "bluetooth");
+       if (IS_ERR(bt_class)) {
                bus_unregister(&bt_bus);
                platform_device_unregister(bt_platform);
-               return err;
+               return PTR_ERR(bt_class);
        }
 
        return 0;
@@ -269,7 +247,7 @@ int __init bt_sysfs_init(void)
 
 void __exit bt_sysfs_cleanup(void)
 {
-       class_unregister(&bt_class);
+       class_destroy(bt_class);
 
        bus_unregister(&bt_bus);
 

diff --git a/net/bluetooth/l2cap.c b/net/bluetooth/l2cap.c
index 770101177da106e1bb78ff84aa5241ffbce7cd1a..f6501fa0d59f517003b3516ac9c32f6b14276e0d 100644 (file)
--- a/net/bluetooth/l2cap.c
+++ b/net/bluetooth/l2cap.c
@@ -2219,7 +2219,7 @@ static int __init l2cap_init(void)
                goto error;
        }
 
-       class_create_file(&bt_class, &class_attr_l2cap);
+       class_create_file(bt_class, &class_attr_l2cap);
 
        BT_INFO("L2CAP ver %s", VERSION);
        BT_INFO("L2CAP socket layer initialized");
@@ -2233,7 +2233,7 @@ error:
 
 static void __exit l2cap_exit(void)
 {
-       class_remove_file(&bt_class, &class_attr_l2cap);
+       class_remove_file(bt_class, &class_attr_l2cap);
 
        if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
                BT_ERR("L2CAP socket unregistration failed");

diff --git a/net/bluetooth/rfcomm/core.c b/net/bluetooth/rfcomm/core.c
index bd46e8927f299c34aeddb80130a5af462e479af8..6de33fe7bf5ba6d8ea6620f498e15bc758669ac0 100644 (file)
--- a/net/bluetooth/rfcomm/core.c
+++ b/net/bluetooth/rfcomm/core.c
@@ -2035,7 +2035,7 @@ static int __init rfcomm_init(void)
 
        kernel_thread(rfcomm_run, NULL, CLONE_KERNEL);
 
-       class_create_file(&bt_class, &class_attr_rfcomm_dlc);
+       class_create_file(bt_class, &class_attr_rfcomm_dlc);
 
        rfcomm_init_sockets();
 
@@ -2050,7 +2050,7 @@ static int __init rfcomm_init(void)
 
 static void __exit rfcomm_exit(void)
 {
-       class_remove_file(&bt_class, &class_attr_rfcomm_dlc);
+       class_remove_file(bt_class, &class_attr_rfcomm_dlc);
 
        hci_unregister_cb(&rfcomm_cb);
 

diff --git a/net/bluetooth/rfcomm/sock.c b/net/bluetooth/rfcomm/sock.c
index 4e9962c8cfa6b9dfabedd54ac9e47cd477b2facf..220fee04e7f274a3d31505f0133af59e742a4f74 100644 (file)
--- a/net/bluetooth/rfcomm/sock.c
+++ b/net/bluetooth/rfcomm/sock.c
@@ -944,7 +944,7 @@ int __init rfcomm_init_sockets(void)
        if (err < 0)
                goto error;
 
-       class_create_file(&bt_class, &class_attr_rfcomm);
+       class_create_file(bt_class, &class_attr_rfcomm);
 
        BT_INFO("RFCOMM socket layer initialized");
 
@@ -958,7 +958,7 @@ error:
 
 void __exit rfcomm_cleanup_sockets(void)
 {
-       class_remove_file(&bt_class, &class_attr_rfcomm);
+       class_remove_file(bt_class, &class_attr_rfcomm);
 
        if (bt_sock_unregister(BTPROTO_RFCOMM) < 0)
                BT_ERR("RFCOMM socket layer unregistration failed");

diff --git a/net/bluetooth/sco.c b/net/bluetooth/sco.c
index a5f1e44db5d363b2b3dae5146d7164237180d8c2..85defccc028791bc7cde5f0b37de5c3dc7b5fa11 100644 (file)
--- a/net/bluetooth/sco.c
+++ b/net/bluetooth/sco.c
@@ -969,7 +969,7 @@ static int __init sco_init(void)
                goto error;
        }
 
-       class_create_file(&bt_class, &class_attr_sco);
+       class_create_file(bt_class, &class_attr_sco);
 
        BT_INFO("SCO (Voice Link) ver %s", VERSION);
        BT_INFO("SCO socket layer initialized");
@@ -983,7 +983,7 @@ error:
 
 static void __exit sco_exit(void)
 {
-       class_remove_file(&bt_class, &class_attr_sco);
+       class_remove_file(bt_class, &class_attr_sco);
 
        if (bt_sock_unregister(BTPROTO_SCO) < 0)
                BT_ERR("SCO socket unregistration failed");