net: rework recvmsg handler msg_name and msg_namelen logic
[linux-3.10.git] / net / bluetooth / hci_sysfs.c
1 /* Bluetooth HCI driver model support. */
2
3 #include <linux/debugfs.h>
4 #include <linux/module.h>
5 #include <asm/unaligned.h>
6
7 #include <net/bluetooth/bluetooth.h>
8 #include <net/bluetooth/hci_core.h>
9
10 static struct class *bt_class;
11
12 struct dentry *bt_debugfs;
13 EXPORT_SYMBOL_GPL(bt_debugfs);
14
15 static inline char *link_typetostr(int type)
16 {
17         switch (type) {
18         case ACL_LINK:
19                 return "ACL";
20         case SCO_LINK:
21                 return "SCO";
22         case ESCO_LINK:
23                 return "eSCO";
24         case LE_LINK:
25                 return "LE";
26         default:
27                 return "UNKNOWN";
28         }
29 }
30
31 static ssize_t show_link_type(struct device *dev,
32                               struct device_attribute *attr, char *buf)
33 {
34         struct hci_conn *conn = to_hci_conn(dev);
35         return sprintf(buf, "%s\n", link_typetostr(conn->type));
36 }
37
38 static ssize_t show_link_address(struct device *dev,
39                                  struct device_attribute *attr, char *buf)
40 {
41         struct hci_conn *conn = to_hci_conn(dev);
42         return sprintf(buf, "%pMR\n", &conn->dst);
43 }
44
45 static ssize_t show_link_features(struct device *dev,
46                                   struct device_attribute *attr, char *buf)
47 {
48         struct hci_conn *conn = to_hci_conn(dev);
49
50         return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
51                        conn->features[0][0], conn->features[0][1],
52                        conn->features[0][2], conn->features[0][3],
53                        conn->features[0][4], conn->features[0][5],
54                        conn->features[0][6], conn->features[0][7]);
55 }
56
57 #define LINK_ATTR(_name, _mode, _show, _store) \
58 struct device_attribute link_attr_##_name = __ATTR(_name, _mode, _show, _store)
59
60 static LINK_ATTR(type, S_IRUGO, show_link_type, NULL);
61 static LINK_ATTR(address, S_IRUGO, show_link_address, NULL);
62 static LINK_ATTR(features, S_IRUGO, show_link_features, NULL);
63
64 static struct attribute *bt_link_attrs[] = {
65         &link_attr_type.attr,
66         &link_attr_address.attr,
67         &link_attr_features.attr,
68         NULL
69 };
70
71 static struct attribute_group bt_link_group = {
72         .attrs = bt_link_attrs,
73 };
74
75 static const struct attribute_group *bt_link_groups[] = {
76         &bt_link_group,
77         NULL
78 };
79
80 static void bt_link_release(struct device *dev)
81 {
82         struct hci_conn *conn = to_hci_conn(dev);
83         kfree(conn);
84 }
85
86 static struct device_type bt_link = {
87         .name    = "link",
88         .groups  = bt_link_groups,
89         .release = bt_link_release,
90 };
91
92 /*
93  * The rfcomm tty device will possibly retain even when conn
94  * is down, and sysfs doesn't support move zombie device,
95  * so we should move the device before conn device is destroyed.
96  */
97 static int __match_tty(struct device *dev, void *data)
98 {
99         return !strncmp(dev_name(dev), "rfcomm", 6);
100 }
101
102 void hci_conn_init_sysfs(struct hci_conn *conn)
103 {
104         struct hci_dev *hdev = conn->hdev;
105
106         BT_DBG("conn %p", conn);
107
108         conn->dev.type = &bt_link;
109         conn->dev.class = bt_class;
110         conn->dev.parent = &hdev->dev;
111
112         device_initialize(&conn->dev);
113 }
114
115 void hci_conn_add_sysfs(struct hci_conn *conn)
116 {
117         struct hci_dev *hdev = conn->hdev;
118
119         BT_DBG("conn %p", conn);
120
121         dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle);
122
123         if (device_add(&conn->dev) < 0) {
124                 BT_ERR("Failed to register connection device");
125                 return;
126         }
127
128         hci_dev_hold(hdev);
129 }
130
131 void hci_conn_del_sysfs(struct hci_conn *conn)
132 {
133         struct hci_dev *hdev = conn->hdev;
134
135         if (!device_is_registered(&conn->dev))
136                 return;
137
138         while (1) {
139                 struct device *dev;
140
141                 dev = device_find_child(&conn->dev, NULL, __match_tty);
142                 if (!dev)
143                         break;
144                 device_move(dev, NULL, DPM_ORDER_DEV_LAST);
145                 put_device(dev);
146         }
147
148         device_del(&conn->dev);
149
150         hci_dev_put(hdev);
151 }
152
153 static inline char *host_bustostr(int bus)
154 {
155         switch (bus) {
156         case HCI_VIRTUAL:
157                 return "VIRTUAL";
158         case HCI_USB:
159                 return "USB";
160         case HCI_PCCARD:
161                 return "PCCARD";
162         case HCI_UART:
163                 return "UART";
164         case HCI_RS232:
165                 return "RS232";
166         case HCI_PCI:
167                 return "PCI";
168         case HCI_SDIO:
169                 return "SDIO";
170         default:
171                 return "UNKNOWN";
172         }
173 }
174
175 static inline char *host_typetostr(int type)
176 {
177         switch (type) {
178         case HCI_BREDR:
179                 return "BR/EDR";
180         case HCI_AMP:
181                 return "AMP";
182         default:
183                 return "UNKNOWN";
184         }
185 }
186
187 static ssize_t show_bus(struct device *dev,
188                         struct device_attribute *attr, char *buf)
189 {
190         struct hci_dev *hdev = to_hci_dev(dev);
191         return sprintf(buf, "%s\n", host_bustostr(hdev->bus));
192 }
193
194 static ssize_t show_type(struct device *dev,
195                          struct device_attribute *attr, char *buf)
196 {
197         struct hci_dev *hdev = to_hci_dev(dev);
198         return sprintf(buf, "%s\n", host_typetostr(hdev->dev_type));
199 }
200
201 static ssize_t show_name(struct device *dev,
202                          struct device_attribute *attr, char *buf)
203 {
204         struct hci_dev *hdev = to_hci_dev(dev);
205         char name[HCI_MAX_NAME_LENGTH + 1];
206         int i;
207
208         for (i = 0; i < HCI_MAX_NAME_LENGTH; i++)
209                 name[i] = hdev->dev_name[i];
210
211         name[HCI_MAX_NAME_LENGTH] = '\0';
212         return sprintf(buf, "%s\n", name);
213 }
214
215 static ssize_t show_class(struct device *dev,
216                           struct device_attribute *attr, char *buf)
217 {
218         struct hci_dev *hdev = to_hci_dev(dev);
219         return sprintf(buf, "0x%.2x%.2x%.2x\n", hdev->dev_class[2],
220                        hdev->dev_class[1], hdev->dev_class[0]);
221 }
222
223 static ssize_t show_address(struct device *dev,
224                             struct device_attribute *attr, char *buf)
225 {
226         struct hci_dev *hdev = to_hci_dev(dev);
227         return sprintf(buf, "%pMR\n", &hdev->bdaddr);
228 }
229
230 static ssize_t show_features(struct device *dev,
231                              struct device_attribute *attr, char *buf)
232 {
233         struct hci_dev *hdev = to_hci_dev(dev);
234
235         return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
236                        hdev->features[0][0], hdev->features[0][1],
237                        hdev->features[0][2], hdev->features[0][3],
238                        hdev->features[0][4], hdev->features[0][5],
239                        hdev->features[0][6], hdev->features[0][7]);
240 }
241
242 static ssize_t show_manufacturer(struct device *dev,
243                                  struct device_attribute *attr, char *buf)
244 {
245         struct hci_dev *hdev = to_hci_dev(dev);
246         return sprintf(buf, "%d\n", hdev->manufacturer);
247 }
248
249 static ssize_t show_hci_version(struct device *dev,
250                                 struct device_attribute *attr, char *buf)
251 {
252         struct hci_dev *hdev = to_hci_dev(dev);
253         return sprintf(buf, "%d\n", hdev->hci_ver);
254 }
255
256 static ssize_t show_hci_revision(struct device *dev,
257                                  struct device_attribute *attr, char *buf)
258 {
259         struct hci_dev *hdev = to_hci_dev(dev);
260         return sprintf(buf, "%d\n", hdev->hci_rev);
261 }
262
263 static ssize_t show_idle_timeout(struct device *dev,
264                                  struct device_attribute *attr, char *buf)
265 {
266         struct hci_dev *hdev = to_hci_dev(dev);
267         return sprintf(buf, "%d\n", hdev->idle_timeout);
268 }
269
270 static ssize_t store_idle_timeout(struct device *dev,
271                                   struct device_attribute *attr,
272                                   const char *buf, size_t count)
273 {
274         struct hci_dev *hdev = to_hci_dev(dev);
275         unsigned int val;
276         int rv;
277
278         rv = kstrtouint(buf, 0, &val);
279         if (rv < 0)
280                 return rv;
281
282         if (val != 0 && (val < 500 || val > 3600000))
283                 return -EINVAL;
284
285         hdev->idle_timeout = val;
286
287         return count;
288 }
289
290 static ssize_t show_sniff_max_interval(struct device *dev,
291                                        struct device_attribute *attr, char *buf)
292 {
293         struct hci_dev *hdev = to_hci_dev(dev);
294         return sprintf(buf, "%d\n", hdev->sniff_max_interval);
295 }
296
297 static ssize_t store_sniff_max_interval(struct device *dev,
298                                         struct device_attribute *attr,
299                                         const char *buf, size_t count)
300 {
301         struct hci_dev *hdev = to_hci_dev(dev);
302         u16 val;
303         int rv;
304
305         rv = kstrtou16(buf, 0, &val);
306         if (rv < 0)
307                 return rv;
308
309         if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
310                 return -EINVAL;
311
312         hdev->sniff_max_interval = val;
313
314         return count;
315 }
316
317 static ssize_t show_sniff_min_interval(struct device *dev,
318                                        struct device_attribute *attr, char *buf)
319 {
320         struct hci_dev *hdev = to_hci_dev(dev);
321         return sprintf(buf, "%d\n", hdev->sniff_min_interval);
322 }
323
324 static ssize_t store_sniff_min_interval(struct device *dev,
325                                         struct device_attribute *attr,
326                                         const char *buf, size_t count)
327 {
328         struct hci_dev *hdev = to_hci_dev(dev);
329         u16 val;
330         int rv;
331
332         rv = kstrtou16(buf, 0, &val);
333         if (rv < 0)
334                 return rv;
335
336         if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
337                 return -EINVAL;
338
339         hdev->sniff_min_interval = val;
340
341         return count;
342 }
343
344 static DEVICE_ATTR(bus, S_IRUGO, show_bus, NULL);
345 static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
346 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
347 static DEVICE_ATTR(class, S_IRUGO, show_class, NULL);
348 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
349 static DEVICE_ATTR(features, S_IRUGO, show_features, NULL);
350 static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL);
351 static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL);
352 static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL);
353
354 static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
355                    show_idle_timeout, store_idle_timeout);
356 static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR,
357                    show_sniff_max_interval, store_sniff_max_interval);
358 static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
359                    show_sniff_min_interval, store_sniff_min_interval);
360
361 static struct attribute *bt_host_attrs[] = {
362         &dev_attr_bus.attr,
363         &dev_attr_type.attr,
364         &dev_attr_name.attr,
365         &dev_attr_class.attr,
366         &dev_attr_address.attr,
367         &dev_attr_features.attr,
368         &dev_attr_manufacturer.attr,
369         &dev_attr_hci_version.attr,
370         &dev_attr_hci_revision.attr,
371         &dev_attr_idle_timeout.attr,
372         &dev_attr_sniff_max_interval.attr,
373         &dev_attr_sniff_min_interval.attr,
374         NULL
375 };
376
377 static struct attribute_group bt_host_group = {
378         .attrs = bt_host_attrs,
379 };
380
381 static const struct attribute_group *bt_host_groups[] = {
382         &bt_host_group,
383         NULL
384 };
385
386 static void bt_host_release(struct device *dev)
387 {
388         struct hci_dev *hdev = to_hci_dev(dev);
389         kfree(hdev);
390         module_put(THIS_MODULE);
391 }
392
393 static struct device_type bt_host = {
394         .name    = "host",
395         .groups  = bt_host_groups,
396         .release = bt_host_release,
397 };
398
399 static int inquiry_cache_show(struct seq_file *f, void *p)
400 {
401         struct hci_dev *hdev = f->private;
402         struct discovery_state *cache = &hdev->discovery;
403         struct inquiry_entry *e;
404
405         hci_dev_lock(hdev);
406
407         list_for_each_entry(e, &cache->all, all) {
408                 struct inquiry_data *data = &e->data;
409                 seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
410                            &data->bdaddr,
411                            data->pscan_rep_mode, data->pscan_period_mode,
412                            data->pscan_mode, data->dev_class[2],
413                            data->dev_class[1], data->dev_class[0],
414                            __le16_to_cpu(data->clock_offset),
415                            data->rssi, data->ssp_mode, e->timestamp);
416         }
417
418         hci_dev_unlock(hdev);
419
420         return 0;
421 }
422
423 static int inquiry_cache_open(struct inode *inode, struct file *file)
424 {
425         return single_open(file, inquiry_cache_show, inode->i_private);
426 }
427
428 static const struct file_operations inquiry_cache_fops = {
429         .open           = inquiry_cache_open,
430         .read           = seq_read,
431         .llseek         = seq_lseek,
432         .release        = single_release,
433 };
434
435 static int blacklist_show(struct seq_file *f, void *p)
436 {
437         struct hci_dev *hdev = f->private;
438         struct bdaddr_list *b;
439
440         hci_dev_lock(hdev);
441
442         list_for_each_entry(b, &hdev->blacklist, list)
443                 seq_printf(f, "%pMR\n", &b->bdaddr);
444
445         hci_dev_unlock(hdev);
446
447         return 0;
448 }
449
450 static int blacklist_open(struct inode *inode, struct file *file)
451 {
452         return single_open(file, blacklist_show, inode->i_private);
453 }
454
455 static const struct file_operations blacklist_fops = {
456         .open           = blacklist_open,
457         .read           = seq_read,
458         .llseek         = seq_lseek,
459         .release        = single_release,
460 };
461
462 static void print_bt_uuid(struct seq_file *f, u8 *uuid)
463 {
464         u32 data0, data5;
465         u16 data1, data2, data3, data4;
466
467         data5 = get_unaligned_le32(uuid);
468         data4 = get_unaligned_le16(uuid + 4);
469         data3 = get_unaligned_le16(uuid + 6);
470         data2 = get_unaligned_le16(uuid + 8);
471         data1 = get_unaligned_le16(uuid + 10);
472         data0 = get_unaligned_le32(uuid + 12);
473
474         seq_printf(f, "%.8x-%.4x-%.4x-%.4x-%.4x%.8x\n",
475                    data0, data1, data2, data3, data4, data5);
476 }
477
478 static int uuids_show(struct seq_file *f, void *p)
479 {
480         struct hci_dev *hdev = f->private;
481         struct bt_uuid *uuid;
482
483         hci_dev_lock(hdev);
484
485         list_for_each_entry(uuid, &hdev->uuids, list)
486                 print_bt_uuid(f, uuid->uuid);
487
488         hci_dev_unlock(hdev);
489
490         return 0;
491 }
492
493 static int uuids_open(struct inode *inode, struct file *file)
494 {
495         return single_open(file, uuids_show, inode->i_private);
496 }
497
498 static const struct file_operations uuids_fops = {
499         .open           = uuids_open,
500         .read           = seq_read,
501         .llseek         = seq_lseek,
502         .release        = single_release,
503 };
504
505 static int auto_accept_delay_set(void *data, u64 val)
506 {
507         struct hci_dev *hdev = data;
508
509         hci_dev_lock(hdev);
510
511         hdev->auto_accept_delay = val;
512
513         hci_dev_unlock(hdev);
514
515         return 0;
516 }
517
518 static int auto_accept_delay_get(void *data, u64 *val)
519 {
520         struct hci_dev *hdev = data;
521
522         hci_dev_lock(hdev);
523
524         *val = hdev->auto_accept_delay;
525
526         hci_dev_unlock(hdev);
527
528         return 0;
529 }
530
531 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
532                         auto_accept_delay_set, "%llu\n");
533
534 void hci_init_sysfs(struct hci_dev *hdev)
535 {
536         struct device *dev = &hdev->dev;
537
538         dev->type = &bt_host;
539         dev->class = bt_class;
540
541         __module_get(THIS_MODULE);
542         device_initialize(dev);
543 }
544
545 int hci_add_sysfs(struct hci_dev *hdev)
546 {
547         struct device *dev = &hdev->dev;
548         int err;
549
550         BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
551
552         dev_set_name(dev, "%s", hdev->name);
553
554         err = device_add(dev);
555         if (err < 0)
556                 return err;
557
558         if (!bt_debugfs)
559                 return 0;
560
561         hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs);
562         if (!hdev->debugfs)
563                 return 0;
564
565         debugfs_create_file("inquiry_cache", 0444, hdev->debugfs,
566                             hdev, &inquiry_cache_fops);
567
568         debugfs_create_file("blacklist", 0444, hdev->debugfs,
569                             hdev, &blacklist_fops);
570
571         debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
572
573         debugfs_create_file("auto_accept_delay", 0444, hdev->debugfs, hdev,
574                             &auto_accept_delay_fops);
575         return 0;
576 }
577
578 void hci_del_sysfs(struct hci_dev *hdev)
579 {
580         BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
581
582         debugfs_remove_recursive(hdev->debugfs);
583
584         device_del(&hdev->dev);
585 }
586
587 int __init bt_sysfs_init(void)
588 {
589         bt_debugfs = debugfs_create_dir("bluetooth", NULL);
590
591         bt_class = class_create(THIS_MODULE, "bluetooth");
592
593         return PTR_RET(bt_class);
594 }
595
596 void bt_sysfs_cleanup(void)
597 {
598         class_destroy(bt_class);
599
600         debugfs_remove_recursive(bt_debugfs);
601 }