1 /* Bluetooth HCI driver model support. */
3 #include <linux/kernel.h>
4 #include <linux/init.h>
6 #include <net/bluetooth/bluetooth.h>
7 #include <net/bluetooth/hci_core.h>
9 struct class *bt_class
= NULL
;
10 EXPORT_SYMBOL_GPL(bt_class
);
12 static struct workqueue_struct
*bt_workq
;
14 static inline char *link_typetostr(int type
)
28 static ssize_t
show_link_type(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
30 struct hci_conn
*conn
= dev_get_drvdata(dev
);
31 return sprintf(buf
, "%s\n", link_typetostr(conn
->type
));
34 static ssize_t
show_link_address(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
36 struct hci_conn
*conn
= dev_get_drvdata(dev
);
38 baswap(&bdaddr
, &conn
->dst
);
39 return sprintf(buf
, "%s\n", batostr(&bdaddr
));
42 static ssize_t
show_link_features(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
44 struct hci_conn
*conn
= dev_get_drvdata(dev
);
46 return sprintf(buf
, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
47 conn
->features
[0], conn
->features
[1],
48 conn
->features
[2], conn
->features
[3],
49 conn
->features
[4], conn
->features
[5],
50 conn
->features
[6], conn
->features
[7]);
53 #define LINK_ATTR(_name,_mode,_show,_store) \
54 struct device_attribute link_attr_##_name = __ATTR(_name,_mode,_show,_store)
56 static LINK_ATTR(type
, S_IRUGO
, show_link_type
, NULL
);
57 static LINK_ATTR(address
, S_IRUGO
, show_link_address
, NULL
);
58 static LINK_ATTR(features
, S_IRUGO
, show_link_features
, NULL
);
60 static struct attribute
*bt_link_attrs
[] = {
62 &link_attr_address
.attr
,
63 &link_attr_features
.attr
,
67 static struct attribute_group bt_link_group
= {
68 .attrs
= bt_link_attrs
,
71 static struct attribute_group
*bt_link_groups
[] = {
76 static void bt_link_release(struct device
*dev
)
78 void *data
= dev_get_drvdata(dev
);
82 static struct device_type bt_link
= {
84 .groups
= bt_link_groups
,
85 .release
= bt_link_release
,
88 static void add_conn(struct work_struct
*work
)
90 struct hci_conn
*conn
= container_of(work
, struct hci_conn
, work_add
);
91 struct hci_dev
*hdev
= conn
->hdev
;
93 /* ensure previous del is complete */
94 flush_work(&conn
->work_del
);
96 dev_set_name(&conn
->dev
, "%s:%d", hdev
->name
, conn
->handle
);
98 if (device_add(&conn
->dev
) < 0) {
99 BT_ERR("Failed to register connection device");
105 * The rfcomm tty device will possibly retain even when conn
106 * is down, and sysfs doesn't support move zombie device,
107 * so we should move the device before conn device is destroyed.
109 static int __match_tty(struct device
*dev
, void *data
)
111 return !strncmp(dev_name(dev
), "rfcomm", 6);
114 static void del_conn(struct work_struct
*work
)
116 struct hci_conn
*conn
= container_of(work
, struct hci_conn
, work_del
);
117 struct hci_dev
*hdev
= conn
->hdev
;
119 /* ensure previous add is complete */
120 flush_work(&conn
->work_add
);
122 if (!device_is_registered(&conn
->dev
))
128 dev
= device_find_child(&conn
->dev
, NULL
, __match_tty
);
131 device_move(dev
, NULL
, DPM_ORDER_DEV_LAST
);
135 device_del(&conn
->dev
);
136 put_device(&conn
->dev
);
140 void hci_conn_init_sysfs(struct hci_conn
*conn
)
142 struct hci_dev
*hdev
= conn
->hdev
;
144 BT_DBG("conn %p", conn
);
146 conn
->dev
.type
= &bt_link
;
147 conn
->dev
.class = bt_class
;
148 conn
->dev
.parent
= &hdev
->dev
;
150 dev_set_drvdata(&conn
->dev
, conn
);
152 device_initialize(&conn
->dev
);
154 INIT_WORK(&conn
->work_add
, add_conn
);
155 INIT_WORK(&conn
->work_del
, del_conn
);
158 void hci_conn_add_sysfs(struct hci_conn
*conn
)
160 BT_DBG("conn %p", conn
);
162 queue_work(bt_workq
, &conn
->work_add
);
165 void hci_conn_del_sysfs(struct hci_conn
*conn
)
167 BT_DBG("conn %p", conn
);
169 queue_work(bt_workq
, &conn
->work_del
);
172 static inline char *host_typetostr(int type
)
194 static ssize_t
show_type(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
196 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
197 return sprintf(buf
, "%s\n", host_typetostr(hdev
->type
));
200 static ssize_t
show_name(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
202 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
206 for (i
= 0; i
< 248; i
++)
207 name
[i
] = hdev
->dev_name
[i
];
210 return sprintf(buf
, "%s\n", name
);
213 static ssize_t
show_class(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
215 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
216 return sprintf(buf
, "0x%.2x%.2x%.2x\n",
217 hdev
->dev_class
[2], hdev
->dev_class
[1], hdev
->dev_class
[0]);
220 static ssize_t
show_address(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
222 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
224 baswap(&bdaddr
, &hdev
->bdaddr
);
225 return sprintf(buf
, "%s\n", batostr(&bdaddr
));
228 static ssize_t
show_features(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
230 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
232 return sprintf(buf
, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
233 hdev
->features
[0], hdev
->features
[1],
234 hdev
->features
[2], hdev
->features
[3],
235 hdev
->features
[4], hdev
->features
[5],
236 hdev
->features
[6], hdev
->features
[7]);
239 static ssize_t
show_manufacturer(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
241 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
242 return sprintf(buf
, "%d\n", hdev
->manufacturer
);
245 static ssize_t
show_hci_version(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
247 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
248 return sprintf(buf
, "%d\n", hdev
->hci_ver
);
251 static ssize_t
show_hci_revision(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
253 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
254 return sprintf(buf
, "%d\n", hdev
->hci_rev
);
257 static ssize_t
show_inquiry_cache(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
259 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
260 struct inquiry_cache
*cache
= &hdev
->inq_cache
;
261 struct inquiry_entry
*e
;
264 hci_dev_lock_bh(hdev
);
266 for (e
= cache
->list
; e
; e
= e
->next
) {
267 struct inquiry_data
*data
= &e
->data
;
269 baswap(&bdaddr
, &data
->bdaddr
);
270 n
+= sprintf(buf
+ n
, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
272 data
->pscan_rep_mode
, data
->pscan_period_mode
,
273 data
->pscan_mode
, data
->dev_class
[2],
274 data
->dev_class
[1], data
->dev_class
[0],
275 __le16_to_cpu(data
->clock_offset
),
276 data
->rssi
, data
->ssp_mode
, e
->timestamp
);
279 hci_dev_unlock_bh(hdev
);
283 static ssize_t
show_idle_timeout(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
285 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
286 return sprintf(buf
, "%d\n", hdev
->idle_timeout
);
289 static ssize_t
store_idle_timeout(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
291 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
295 val
= simple_strtoul(buf
, &ptr
, 10);
299 if (val
!= 0 && (val
< 500 || val
> 3600000))
302 hdev
->idle_timeout
= val
;
307 static ssize_t
show_sniff_max_interval(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
309 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
310 return sprintf(buf
, "%d\n", hdev
->sniff_max_interval
);
313 static ssize_t
store_sniff_max_interval(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
315 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
319 val
= simple_strtoul(buf
, &ptr
, 10);
323 if (val
< 0x0002 || val
> 0xFFFE || val
% 2)
326 if (val
< hdev
->sniff_min_interval
)
329 hdev
->sniff_max_interval
= val
;
334 static ssize_t
show_sniff_min_interval(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
336 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
337 return sprintf(buf
, "%d\n", hdev
->sniff_min_interval
);
340 static ssize_t
store_sniff_min_interval(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
342 struct hci_dev
*hdev
= dev_get_drvdata(dev
);
346 val
= simple_strtoul(buf
, &ptr
, 10);
350 if (val
< 0x0002 || val
> 0xFFFE || val
% 2)
353 if (val
> hdev
->sniff_max_interval
)
356 hdev
->sniff_min_interval
= val
;
361 static DEVICE_ATTR(type
, S_IRUGO
, show_type
, NULL
);
362 static DEVICE_ATTR(name
, S_IRUGO
, show_name
, NULL
);
363 static DEVICE_ATTR(class, S_IRUGO
, show_class
, NULL
);
364 static DEVICE_ATTR(address
, S_IRUGO
, show_address
, NULL
);
365 static DEVICE_ATTR(features
, S_IRUGO
, show_features
, NULL
);
366 static DEVICE_ATTR(manufacturer
, S_IRUGO
, show_manufacturer
, NULL
);
367 static DEVICE_ATTR(hci_version
, S_IRUGO
, show_hci_version
, NULL
);
368 static DEVICE_ATTR(hci_revision
, S_IRUGO
, show_hci_revision
, NULL
);
369 static DEVICE_ATTR(inquiry_cache
, S_IRUGO
, show_inquiry_cache
, NULL
);
371 static DEVICE_ATTR(idle_timeout
, S_IRUGO
| S_IWUSR
,
372 show_idle_timeout
, store_idle_timeout
);
373 static DEVICE_ATTR(sniff_max_interval
, S_IRUGO
| S_IWUSR
,
374 show_sniff_max_interval
, store_sniff_max_interval
);
375 static DEVICE_ATTR(sniff_min_interval
, S_IRUGO
| S_IWUSR
,
376 show_sniff_min_interval
, store_sniff_min_interval
);
378 static struct attribute
*bt_host_attrs
[] = {
381 &dev_attr_class
.attr
,
382 &dev_attr_address
.attr
,
383 &dev_attr_features
.attr
,
384 &dev_attr_manufacturer
.attr
,
385 &dev_attr_hci_version
.attr
,
386 &dev_attr_hci_revision
.attr
,
387 &dev_attr_inquiry_cache
.attr
,
388 &dev_attr_idle_timeout
.attr
,
389 &dev_attr_sniff_max_interval
.attr
,
390 &dev_attr_sniff_min_interval
.attr
,
394 static struct attribute_group bt_host_group
= {
395 .attrs
= bt_host_attrs
,
398 static struct attribute_group
*bt_host_groups
[] = {
403 static void bt_host_release(struct device
*dev
)
405 void *data
= dev_get_drvdata(dev
);
409 static struct device_type bt_host
= {
411 .groups
= bt_host_groups
,
412 .release
= bt_host_release
,
415 int hci_register_sysfs(struct hci_dev
*hdev
)
417 struct device
*dev
= &hdev
->dev
;
420 BT_DBG("%p name %s type %d", hdev
, hdev
->name
, hdev
->type
);
422 dev
->type
= &bt_host
;
423 dev
->class = bt_class
;
424 dev
->parent
= hdev
->parent
;
426 dev_set_name(dev
, "%s", hdev
->name
);
428 dev_set_drvdata(dev
, hdev
);
430 err
= device_register(dev
);
437 void hci_unregister_sysfs(struct hci_dev
*hdev
)
439 BT_DBG("%p name %s type %d", hdev
, hdev
->name
, hdev
->type
);
441 device_del(&hdev
->dev
);
444 int __init
bt_sysfs_init(void)
446 bt_workq
= create_singlethread_workqueue("bluetooth");
450 bt_class
= class_create(THIS_MODULE
, "bluetooth");
451 if (IS_ERR(bt_class
)) {
452 destroy_workqueue(bt_workq
);
453 return PTR_ERR(bt_class
);
459 void bt_sysfs_cleanup(void)
461 destroy_workqueue(bt_workq
);
463 class_destroy(bt_class
);