[Bluetooth] Use real devices for host controllers
authorMarcel Holtmann <marcel@holtmann.org>
Mon, 3 Jul 2006 08:02:41 +0000 (10:02 +0200)
committerDavid S. Miller <davem@sunset.davemloft.net>
Tue, 4 Jul 2006 02:54:02 +0000 (19:54 -0700)
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>
include/net/bluetooth/bluetooth.h
include/net/bluetooth/hci_core.h
net/bluetooth/hci_core.c
net/bluetooth/hci_sysfs.c
net/bluetooth/l2cap.c
net/bluetooth/rfcomm/core.c
net/bluetooth/rfcomm/sock.c
net/bluetooth/sco.c

index 911ceb5cd263b51c90eee3e5803cee3206a88bd8..771d17783c1889d7d89d7875bdfb28a350e9d4e7 100644 (file)
@@ -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 */
index ae67b36d76dc108568518db52d00b2d6ad31af47..d84855fe7336d24938e0aed2055aaf316818cefe 100644 (file)
@@ -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)
index 3f9f1565bf061f4089858e844ae8b7ed2edbbd2f..54e8e5ea21542ef47d87dcb84e47ae9917a581b1 100644 (file)
@@ -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);
 
index 7789e26c84b9d20afc748d13d8e65b8d62f22d4d..3987d167f04e73225ea98556bd1f583c899e9223 100644 (file)
 #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);
 
index 770101177da106e1bb78ff84aa5241ffbce7cd1a..f6501fa0d59f517003b3516ac9c32f6b14276e0d 100644 (file)
@@ -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");
index bd46e8927f299c34aeddb80130a5af462e479af8..6de33fe7bf5ba6d8ea6620f498e15bc758669ac0 100644 (file)
@@ -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);
 
index 4e9962c8cfa6b9dfabedd54ac9e47cd477b2facf..220fee04e7f274a3d31505f0133af59e742a4f74 100644 (file)
@@ -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");
index a5f1e44db5d363b2b3dae5146d7164237180d8c2..85defccc028791bc7cde5f0b37de5c3dc7b5fa11 100644 (file)
@@ -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");