blob: e13cf5ef144cd59a8a8f7eee15ae24d7826020ba [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* Bluetooth HCI driver model support. */
2
Linus Torvalds1da177e2005-04-16 15:20:36 -07003#include <linux/kernel.h>
4#include <linux/init.h>
5
Marcel Holtmann27d35282006-07-03 10:02:37 +02006#include <linux/platform_device.h>
7
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <net/bluetooth/bluetooth.h>
9#include <net/bluetooth/hci_core.h>
10
11#ifndef CONFIG_BT_HCI_CORE_DEBUG
12#undef BT_DBG
13#define BT_DBG(D...)
14#endif
Dave Youngb6c06322008-01-29 21:14:08 -080015static struct workqueue_struct *btaddconn;
16static struct workqueue_struct *btdelconn;
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
Marcel Holtmann4d0eb002006-07-06 12:34:41 +020018static inline char *typetostr(int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -070019{
Marcel Holtmann4d0eb002006-07-06 12:34:41 +020020 switch (type) {
Marcel Holtmann0ac53932006-07-08 13:57:15 +020021 case HCI_VIRTUAL:
Marcel Holtmann4d0eb002006-07-06 12:34:41 +020022 return "VIRTUAL";
23 case HCI_USB:
24 return "USB";
25 case HCI_PCCARD:
26 return "PCCARD";
27 case HCI_UART:
28 return "UART";
29 case HCI_RS232:
30 return "RS232";
31 case HCI_PCI:
32 return "PCI";
Marcel Holtmann0ac53932006-07-08 13:57:15 +020033 case HCI_SDIO:
34 return "SDIO";
Marcel Holtmann4d0eb002006-07-06 12:34:41 +020035 default:
36 return "UNKNOWN";
37 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070038}
39
Marcel Holtmanna91f2e32006-07-03 10:02:41 +020040static ssize_t show_type(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +020042 struct hci_dev *hdev = dev_get_drvdata(dev);
Marcel Holtmann4d0eb002006-07-06 12:34:41 +020043 return sprintf(buf, "%s\n", typetostr(hdev->type));
Linus Torvalds1da177e2005-04-16 15:20:36 -070044}
45
Marcel Holtmanna9de9242007-10-20 13:33:56 +020046static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf)
47{
48 struct hci_dev *hdev = dev_get_drvdata(dev);
49 char name[249];
50 int i;
51
52 for (i = 0; i < 248; i++)
53 name[i] = hdev->dev_name[i];
54
55 name[248] = '\0';
56 return sprintf(buf, "%s\n", name);
57}
58
59static ssize_t show_class(struct device *dev, struct device_attribute *attr, char *buf)
60{
61 struct hci_dev *hdev = dev_get_drvdata(dev);
62 return sprintf(buf, "0x%.2x%.2x%.2x\n",
63 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
64}
65
Marcel Holtmanna91f2e32006-07-03 10:02:41 +020066static ssize_t show_address(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +020068 struct hci_dev *hdev = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 bdaddr_t bdaddr;
70 baswap(&bdaddr, &hdev->bdaddr);
71 return sprintf(buf, "%s\n", batostr(&bdaddr));
72}
73
Marcel Holtmanna9de9242007-10-20 13:33:56 +020074static ssize_t show_features(struct device *dev, struct device_attribute *attr, char *buf)
75{
76 struct hci_dev *hdev = dev_get_drvdata(dev);
77
78 return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
79 hdev->features[0], hdev->features[1],
80 hdev->features[2], hdev->features[3],
81 hdev->features[4], hdev->features[5],
82 hdev->features[6], hdev->features[7]);
83}
84
Marcel Holtmann1143e5a2006-09-23 09:57:20 +020085static ssize_t show_manufacturer(struct device *dev, struct device_attribute *attr, char *buf)
86{
87 struct hci_dev *hdev = dev_get_drvdata(dev);
88 return sprintf(buf, "%d\n", hdev->manufacturer);
89}
90
91static ssize_t show_hci_version(struct device *dev, struct device_attribute *attr, char *buf)
92{
93 struct hci_dev *hdev = dev_get_drvdata(dev);
94 return sprintf(buf, "%d\n", hdev->hci_ver);
95}
96
97static ssize_t show_hci_revision(struct device *dev, struct device_attribute *attr, char *buf)
98{
99 struct hci_dev *hdev = dev_get_drvdata(dev);
100 return sprintf(buf, "%d\n", hdev->hci_rev);
101}
102
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200103static ssize_t show_inquiry_cache(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200105 struct hci_dev *hdev = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 struct inquiry_cache *cache = &hdev->inq_cache;
107 struct inquiry_entry *e;
108 int n = 0;
109
110 hci_dev_lock_bh(hdev);
111
112 for (e = cache->list; e; e = e->next) {
113 struct inquiry_data *data = &e->data;
114 bdaddr_t bdaddr;
115 baswap(&bdaddr, &data->bdaddr);
116 n += sprintf(buf + n, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %u\n",
117 batostr(&bdaddr),
118 data->pscan_rep_mode, data->pscan_period_mode, data->pscan_mode,
119 data->dev_class[2], data->dev_class[1], data->dev_class[0],
120 __le16_to_cpu(data->clock_offset), data->rssi, e->timestamp);
121 }
122
123 hci_dev_unlock_bh(hdev);
124 return n;
125}
126
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200127static ssize_t show_idle_timeout(struct device *dev, struct device_attribute *attr, char *buf)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200128{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200129 struct hci_dev *hdev = dev_get_drvdata(dev);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200130 return sprintf(buf, "%d\n", hdev->idle_timeout);
131}
132
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200133static ssize_t store_idle_timeout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200134{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200135 struct hci_dev *hdev = dev_get_drvdata(dev);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200136 char *ptr;
137 __u32 val;
138
139 val = simple_strtoul(buf, &ptr, 10);
140 if (ptr == buf)
141 return -EINVAL;
142
143 if (val != 0 && (val < 500 || val > 3600000))
144 return -EINVAL;
145
146 hdev->idle_timeout = val;
147
148 return count;
149}
150
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200151static ssize_t show_sniff_max_interval(struct device *dev, struct device_attribute *attr, char *buf)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200152{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200153 struct hci_dev *hdev = dev_get_drvdata(dev);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200154 return sprintf(buf, "%d\n", hdev->sniff_max_interval);
155}
156
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200157static ssize_t store_sniff_max_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200158{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200159 struct hci_dev *hdev = dev_get_drvdata(dev);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200160 char *ptr;
161 __u16 val;
162
163 val = simple_strtoul(buf, &ptr, 10);
164 if (ptr == buf)
165 return -EINVAL;
166
167 if (val < 0x0002 || val > 0xFFFE || val % 2)
168 return -EINVAL;
169
170 if (val < hdev->sniff_min_interval)
171 return -EINVAL;
172
173 hdev->sniff_max_interval = val;
174
175 return count;
176}
177
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200178static ssize_t show_sniff_min_interval(struct device *dev, struct device_attribute *attr, char *buf)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200179{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200180 struct hci_dev *hdev = dev_get_drvdata(dev);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200181 return sprintf(buf, "%d\n", hdev->sniff_min_interval);
182}
183
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200184static ssize_t store_sniff_min_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200185{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200186 struct hci_dev *hdev = dev_get_drvdata(dev);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200187 char *ptr;
188 __u16 val;
189
190 val = simple_strtoul(buf, &ptr, 10);
191 if (ptr == buf)
192 return -EINVAL;
193
194 if (val < 0x0002 || val > 0xFFFE || val % 2)
195 return -EINVAL;
196
197 if (val > hdev->sniff_max_interval)
198 return -EINVAL;
199
200 hdev->sniff_min_interval = val;
201
202 return count;
203}
204
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200205static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200206static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
207static DEVICE_ATTR(class, S_IRUGO, show_class, NULL);
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200208static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200209static DEVICE_ATTR(features, S_IRUGO, show_features, NULL);
Marcel Holtmann1143e5a2006-09-23 09:57:20 +0200210static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL);
211static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL);
212static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL);
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200213static DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200215static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
Marcel Holtmann04837f62006-07-03 10:02:33 +0200216 show_idle_timeout, store_idle_timeout);
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200217static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR,
Marcel Holtmann04837f62006-07-03 10:02:33 +0200218 show_sniff_max_interval, store_sniff_max_interval);
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200219static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
Marcel Holtmann04837f62006-07-03 10:02:33 +0200220 show_sniff_min_interval, store_sniff_min_interval);
221
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200222static struct device_attribute *bt_attrs[] = {
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200223 &dev_attr_type,
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200224 &dev_attr_name,
225 &dev_attr_class,
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200226 &dev_attr_address,
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200227 &dev_attr_features,
Marcel Holtmann1143e5a2006-09-23 09:57:20 +0200228 &dev_attr_manufacturer,
229 &dev_attr_hci_version,
230 &dev_attr_hci_revision,
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200231 &dev_attr_inquiry_cache,
232 &dev_attr_idle_timeout,
233 &dev_attr_sniff_max_interval,
234 &dev_attr_sniff_min_interval,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 NULL
236};
237
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200238static ssize_t show_conn_type(struct device *dev, struct device_attribute *attr, char *buf)
239{
240 struct hci_conn *conn = dev_get_drvdata(dev);
241 return sprintf(buf, "%s\n", conn->type == ACL_LINK ? "ACL" : "SCO");
242}
243
244static ssize_t show_conn_address(struct device *dev, struct device_attribute *attr, char *buf)
245{
246 struct hci_conn *conn = dev_get_drvdata(dev);
247 bdaddr_t bdaddr;
248 baswap(&bdaddr, &conn->dst);
249 return sprintf(buf, "%s\n", batostr(&bdaddr));
250}
251
252#define CONN_ATTR(_name,_mode,_show,_store) \
253struct device_attribute conn_attr_##_name = __ATTR(_name,_mode,_show,_store)
254
255static CONN_ATTR(type, S_IRUGO, show_conn_type, NULL);
256static CONN_ATTR(address, S_IRUGO, show_conn_address, NULL);
257
258static struct device_attribute *conn_attrs[] = {
259 &conn_attr_type,
260 &conn_attr_address,
261 NULL
262};
263
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200264struct class *bt_class = NULL;
Marcel Holtmannbe9d1222005-11-08 09:57:38 -0800265EXPORT_SYMBOL_GPL(bt_class);
266
Marcel Holtmann27d35282006-07-03 10:02:37 +0200267static struct bus_type bt_bus = {
268 .name = "bluetooth",
269};
270
271static struct platform_device *bt_platform;
272
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200273static void bt_release(struct device *dev)
274{
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200275 void *data = dev_get_drvdata(dev);
276 kfree(data);
277}
278
David Howellsc4028952006-11-22 14:57:56 +0000279static void add_conn(struct work_struct *work)
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200280{
David Howellsc4028952006-11-22 14:57:56 +0000281 struct hci_conn *conn = container_of(work, struct hci_conn, work);
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200282 int i;
283
Dave Youngb6c06322008-01-29 21:14:08 -0800284 flush_workqueue(btdelconn);
Dave Young5396c932008-01-31 18:33:10 -0800285
Marcel Holtmannc8937792007-01-08 02:16:38 +0100286 if (device_add(&conn->dev) < 0) {
Marcel Holtmanndf5c37e2006-10-15 17:30:45 +0200287 BT_ERR("Failed to register connection device");
288 return;
289 }
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200290
291 for (i = 0; conn_attrs[i]; i++)
Marcel Holtmanndf5c37e2006-10-15 17:30:45 +0200292 if (device_create_file(&conn->dev, conn_attrs[i]) < 0)
293 BT_ERR("Failed to create connection attribute");
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200294}
295
296void hci_conn_add_sysfs(struct hci_conn *conn)
297{
298 struct hci_dev *hdev = conn->hdev;
299 bdaddr_t *ba = &conn->dst;
300
301 BT_DBG("conn %p", conn);
302
Marcel Holtmanne52726d2006-11-18 22:14:05 +0100303 conn->dev.bus = &bt_bus;
304 conn->dev.parent = &hdev->dev;
305
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200306 conn->dev.release = bt_release;
307
308 snprintf(conn->dev.bus_id, BUS_ID_SIZE,
309 "%s%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
310 conn->type == ACL_LINK ? "acl" : "sco",
311 ba->b[5], ba->b[4], ba->b[3],
312 ba->b[2], ba->b[1], ba->b[0]);
313
314 dev_set_drvdata(&conn->dev, conn);
315
Marcel Holtmannc8937792007-01-08 02:16:38 +0100316 device_initialize(&conn->dev);
317
David Howellsc4028952006-11-22 14:57:56 +0000318 INIT_WORK(&conn->work, add_conn);
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200319
Dave Youngb6c06322008-01-29 21:14:08 -0800320 queue_work(btaddconn, &conn->work);
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200321}
322
Dave Youngacea6852008-01-21 22:35:21 -0800323static int __match_tty(struct device *dev, void *data)
324{
325 /* The rfcomm tty device will possibly retain even when conn
326 * is down, and sysfs doesn't support move zombie device,
327 * so we should move the device before conn device is destroyed.
328 * Due to the only child device of hci_conn dev is rfcomm
329 * tty_dev, here just return 1
330 */
331 return 1;
332}
333
David Howellsc4028952006-11-22 14:57:56 +0000334static void del_conn(struct work_struct *work)
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200335{
Dave Youngacea6852008-01-21 22:35:21 -0800336 struct device *dev;
David Howellsc4028952006-11-22 14:57:56 +0000337 struct hci_conn *conn = container_of(work, struct hci_conn, work);
Dave Youngacea6852008-01-21 22:35:21 -0800338
339 while (dev = device_find_child(&conn->dev, NULL, __match_tty)) {
340 device_move(dev, NULL);
341 put_device(dev);
342 }
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200343 device_del(&conn->dev);
Dave Young38b7da02007-12-29 19:17:47 -0800344 put_device(&conn->dev);
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200345}
346
347void hci_conn_del_sysfs(struct hci_conn *conn)
348{
349 BT_DBG("conn %p", conn);
350
Marcel Holtmannc8937792007-01-08 02:16:38 +0100351 if (!device_is_registered(&conn->dev))
352 return;
353
David Howellsc4028952006-11-22 14:57:56 +0000354 INIT_WORK(&conn->work, del_conn);
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200355
Dave Youngb6c06322008-01-29 21:14:08 -0800356 queue_work(btdelconn, &conn->work);
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200357}
358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359int hci_register_sysfs(struct hci_dev *hdev)
360{
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200361 struct device *dev = &hdev->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 unsigned int i;
363 int err;
364
365 BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
366
Marcel Holtmann53c1d4b2007-05-05 00:36:03 +0200367 dev->bus = &bt_bus;
Marcel Holtmanne9c4bec2006-10-15 17:30:50 +0200368 dev->parent = hdev->parent;
Marcel Holtmann27d35282006-07-03 10:02:37 +0200369
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200370 strlcpy(dev->bus_id, hdev->name, BUS_ID_SIZE);
Marcel Holtmann27d35282006-07-03 10:02:37 +0200371
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200372 dev->release = bt_release;
373
374 dev_set_drvdata(dev, hdev);
375
376 err = device_register(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 if (err < 0)
378 return err;
379
380 for (i = 0; bt_attrs[i]; i++)
Marcel Holtmanndf5c37e2006-10-15 17:30:45 +0200381 if (device_create_file(dev, bt_attrs[i]) < 0)
382 BT_ERR("Failed to create device attribute");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Linus Torvaldsd12db0b2007-05-07 17:32:08 -0700384 if (sysfs_create_link(&bt_class->subsys.kobj,
Marcel Holtmann53c1d4b2007-05-05 00:36:03 +0200385 &dev->kobj, kobject_name(&dev->kobj)) < 0)
386 BT_ERR("Failed to create class symlink");
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return 0;
389}
390
391void hci_unregister_sysfs(struct hci_dev *hdev)
392{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
394
Linus Torvaldsd12db0b2007-05-07 17:32:08 -0700395 sysfs_remove_link(&bt_class->subsys.kobj,
Marcel Holtmann53c1d4b2007-05-05 00:36:03 +0200396 kobject_name(&hdev->dev.kobj));
397
Marcel Holtmann4d0eb002006-07-06 12:34:41 +0200398 device_del(&hdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399}
400
401int __init bt_sysfs_init(void)
402{
Marcel Holtmann27d35282006-07-03 10:02:37 +0200403 int err;
404
Dave Youngb6c06322008-01-29 21:14:08 -0800405 btaddconn = create_singlethread_workqueue("btaddconn");
406 if (!btaddconn) {
407 err = -ENOMEM;
408 goto out;
409 }
Dave Young5396c932008-01-31 18:33:10 -0800410
Dave Youngb6c06322008-01-29 21:14:08 -0800411 btdelconn = create_singlethread_workqueue("btdelconn");
412 if (!btdelconn) {
413 err = -ENOMEM;
414 goto out_del;
415 }
416
Marcel Holtmann27d35282006-07-03 10:02:37 +0200417 bt_platform = platform_device_register_simple("bluetooth", -1, NULL, 0);
Dave Youngb6c06322008-01-29 21:14:08 -0800418 if (IS_ERR(bt_platform)) {
419 err = PTR_ERR(bt_platform);
420 goto out_platform;
421 }
Marcel Holtmann27d35282006-07-03 10:02:37 +0200422
423 err = bus_register(&bt_bus);
Dave Youngb6c06322008-01-29 21:14:08 -0800424 if (err < 0)
425 goto out_bus;
Marcel Holtmann27d35282006-07-03 10:02:37 +0200426
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200427 bt_class = class_create(THIS_MODULE, "bluetooth");
428 if (IS_ERR(bt_class)) {
Dave Youngb6c06322008-01-29 21:14:08 -0800429 err = PTR_ERR(bt_class);
430 goto out_class;
Marcel Holtmann27d35282006-07-03 10:02:37 +0200431 }
432
433 return 0;
Dave Youngb6c06322008-01-29 21:14:08 -0800434
435out_class:
436 bus_unregister(&bt_bus);
437out_bus:
438 platform_device_unregister(bt_platform);
439out_platform:
440 destroy_workqueue(btdelconn);
441out_del:
442 destroy_workqueue(btaddconn);
443out:
444 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445}
446
Arnaud Patard860e13b2006-09-28 15:29:37 -0700447void bt_sysfs_cleanup(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448{
Dave Youngb6c06322008-01-29 21:14:08 -0800449 destroy_workqueue(btaddconn);
Dave Young5396c932008-01-31 18:33:10 -0800450
Dave Youngb6c06322008-01-29 21:14:08 -0800451 destroy_workqueue(btdelconn);
Dave Young5396c932008-01-31 18:33:10 -0800452
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200453 class_destroy(bt_class);
Dave Young5396c932008-01-31 18:33:10 -0800454
Marcel Holtmann27d35282006-07-03 10:02:37 +0200455 bus_unregister(&bt_bus);
Dave Young5396c932008-01-31 18:33:10 -0800456
Marcel Holtmann27d35282006-07-03 10:02:37 +0200457 platform_device_unregister(bt_platform);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458}