Bluetooth: mgmt: Fix return value of add/remove_uuid
[linux-2.6.git] / net / bluetooth / hci_sysfs.c
1 /* Bluetooth HCI driver model support. */
2
3 #include <linux/kernel.h>
4 #include <linux/slab.h>
5 #include <linux/init.h>
6 #include <linux/debugfs.h>
7 #include <linux/seq_file.h>
8 #include <linux/module.h>
9
10 #include <net/bluetooth/bluetooth.h>
11 #include <net/bluetooth/hci_core.h>
12
13 static struct class *bt_class;
14
15 struct dentry *bt_debugfs;
16 EXPORT_SYMBOL_GPL(bt_debugfs);
17
18 static inline char *link_typetostr(int type)
19 {
20         switch (type) {
21         case ACL_LINK:
22                 return "ACL";
23         case SCO_LINK:
24                 return "SCO";
25         case ESCO_LINK:
26                 return "eSCO";
27         case LE_LINK:
28                 return "LE";
29         default:
30                 return "UNKNOWN";
31         }
32 }
33
34 static ssize_t show_link_type(struct device *dev, struct device_attribute *attr, char *buf)
35 {
36         struct hci_conn *conn = to_hci_conn(dev);
37         return sprintf(buf, "%s\n", link_typetostr(conn->type));
38 }
39
40 static ssize_t show_link_address(struct device *dev, struct device_attribute *attr, char *buf)
41 {
42         struct hci_conn *conn = to_hci_conn(dev);
43         return sprintf(buf, "%s\n", batostr(&conn->dst));
44 }
45
46 static ssize_t show_link_features(struct device *dev, 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], conn->features[1],
52                                 conn->features[2], conn->features[3],
53                                 conn->features[4], conn->features[5],
54                                 conn->features[6], conn->features[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         put_device(&conn->dev);
150
151         hci_dev_put(hdev);
152 }
153
154 static inline char *host_bustostr(int bus)
155 {
156         switch (bus) {
157         case HCI_VIRTUAL:
158                 return "VIRTUAL";
159         case HCI_USB:
160                 return "USB";
161         case HCI_PCCARD:
162                 return "PCCARD";
163         case HCI_UART:
164                 return "UART";
165         case HCI_RS232:
166                 return "RS232";
167         case HCI_PCI:
168                 return "PCI";
169         case HCI_SDIO:
170                 return "SDIO";
171         default:
172                 return "UNKNOWN";
173         }
174 }
175
176 static inline char *host_typetostr(int type)
177 {
178         switch (type) {
179         case HCI_BREDR:
180                 return "BR/EDR";
181         case HCI_AMP:
182                 return "AMP";
183         default:
184                 return "UNKNOWN";
185         }
186 }
187
188 static ssize_t show_bus(struct device *dev, 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, struct device_attribute *attr, char *buf)
195 {
196         struct hci_dev *hdev = to_hci_dev(dev);
197         return sprintf(buf, "%s\n", host_typetostr(hdev->dev_type));
198 }
199
200 static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf)
201 {
202         struct hci_dev *hdev = to_hci_dev(dev);
203         char name[HCI_MAX_NAME_LENGTH + 1];
204         int i;
205
206         for (i = 0; i < HCI_MAX_NAME_LENGTH; i++)
207                 name[i] = hdev->dev_name[i];
208
209         name[HCI_MAX_NAME_LENGTH] = '\0';
210         return sprintf(buf, "%s\n", name);
211 }
212
213 static ssize_t show_class(struct device *dev, struct device_attribute *attr, char *buf)
214 {
215         struct hci_dev *hdev = to_hci_dev(dev);
216         return sprintf(buf, "0x%.2x%.2x%.2x\n",
217                         hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
218 }
219
220 static ssize_t show_address(struct device *dev, struct device_attribute *attr, char *buf)
221 {
222         struct hci_dev *hdev = to_hci_dev(dev);
223         return sprintf(buf, "%s\n", batostr(&hdev->bdaddr));
224 }
225
226 static ssize_t show_features(struct device *dev, struct device_attribute *attr, char *buf)
227 {
228         struct hci_dev *hdev = to_hci_dev(dev);
229
230         return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
231                                 hdev->features[0], hdev->features[1],
232                                 hdev->features[2], hdev->features[3],
233                                 hdev->features[4], hdev->features[5],
234                                 hdev->features[6], hdev->features[7]);
235 }
236
237 static ssize_t show_manufacturer(struct device *dev, struct device_attribute *attr, char *buf)
238 {
239         struct hci_dev *hdev = to_hci_dev(dev);
240         return sprintf(buf, "%d\n", hdev->manufacturer);
241 }
242
243 static ssize_t show_hci_version(struct device *dev, struct device_attribute *attr, char *buf)
244 {
245         struct hci_dev *hdev = to_hci_dev(dev);
246         return sprintf(buf, "%d\n", hdev->hci_ver);
247 }
248
249 static ssize_t show_hci_revision(struct device *dev, struct device_attribute *attr, char *buf)
250 {
251         struct hci_dev *hdev = to_hci_dev(dev);
252         return sprintf(buf, "%d\n", hdev->hci_rev);
253 }
254
255 static ssize_t show_idle_timeout(struct device *dev, struct device_attribute *attr, char *buf)
256 {
257         struct hci_dev *hdev = to_hci_dev(dev);
258         return sprintf(buf, "%d\n", hdev->idle_timeout);
259 }
260
261 static ssize_t store_idle_timeout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
262 {
263         struct hci_dev *hdev = to_hci_dev(dev);
264         unsigned int val;
265         int rv;
266
267         rv = kstrtouint(buf, 0, &val);
268         if (rv < 0)
269                 return rv;
270
271         if (val != 0 && (val < 500 || val > 3600000))
272                 return -EINVAL;
273
274         hdev->idle_timeout = val;
275
276         return count;
277 }
278
279 static ssize_t show_sniff_max_interval(struct device *dev, struct device_attribute *attr, char *buf)
280 {
281         struct hci_dev *hdev = to_hci_dev(dev);
282         return sprintf(buf, "%d\n", hdev->sniff_max_interval);
283 }
284
285 static ssize_t store_sniff_max_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
286 {
287         struct hci_dev *hdev = to_hci_dev(dev);
288         u16 val;
289         int rv;
290
291         rv = kstrtou16(buf, 0, &val);
292         if (rv < 0)
293                 return rv;
294
295         if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
296                 return -EINVAL;
297
298         hdev->sniff_max_interval = val;
299
300         return count;
301 }
302
303 static ssize_t show_sniff_min_interval(struct device *dev, struct device_attribute *attr, char *buf)
304 {
305         struct hci_dev *hdev = to_hci_dev(dev);
306         return sprintf(buf, "%d\n", hdev->sniff_min_interval);
307 }
308
309 static ssize_t store_sniff_min_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
310 {
311         struct hci_dev *hdev = to_hci_dev(dev);
312         u16 val;
313         int rv;
314
315         rv = kstrtou16(buf, 0, &val);
316         if (rv < 0)
317                 return rv;
318
319         if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
320                 return -EINVAL;
321
322         hdev->sniff_min_interval = val;
323
324         return count;
325 }
326
327 static DEVICE_ATTR(bus, S_IRUGO, show_bus, NULL);
328 static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
329 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
330 static DEVICE_ATTR(class, S_IRUGO, show_class, NULL);
331 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
332 static DEVICE_ATTR(features, S_IRUGO, show_features, NULL);
333 static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL);
334 static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL);
335 static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL);
336
337 static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
338                                 show_idle_timeout, store_idle_timeout);
339 static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR,
340                                 show_sniff_max_interval, store_sniff_max_interval);
341 static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
342                                 show_sniff_min_interval, store_sniff_min_interval);
343
344 static struct attribute *bt_host_attrs[] = {
345         &dev_attr_bus.attr,
346         &dev_attr_type.attr,
347         &dev_attr_name.attr,
348         &dev_attr_class.attr,
349         &dev_attr_address.attr,
350         &dev_attr_features.attr,
351         &dev_attr_manufacturer.attr,
352         &dev_attr_hci_version.attr,
353         &dev_attr_hci_revision.attr,
354         &dev_attr_idle_timeout.attr,
355         &dev_attr_sniff_max_interval.attr,
356         &dev_attr_sniff_min_interval.attr,
357         NULL
358 };
359
360 static struct attribute_group bt_host_group = {
361         .attrs = bt_host_attrs,
362 };
363
364 static const struct attribute_group *bt_host_groups[] = {
365         &bt_host_group,
366         NULL
367 };
368
369 static void bt_host_release(struct device *dev)
370 {
371         struct hci_dev *hdev = to_hci_dev(dev);
372         kfree(hdev);
373         module_put(THIS_MODULE);
374 }
375
376 static struct device_type bt_host = {
377         .name    = "host",
378         .groups  = bt_host_groups,
379         .release = bt_host_release,
380 };
381
382 static int inquiry_cache_show(struct seq_file *f, void *p)
383 {
384         struct hci_dev *hdev = f->private;
385         struct discovery_state *cache = &hdev->discovery;
386         struct inquiry_entry *e;
387
388         hci_dev_lock(hdev);
389
390         list_for_each_entry(e, &cache->all, all) {
391                 struct inquiry_data *data = &e->data;
392                 seq_printf(f, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
393                            batostr(&data->bdaddr),
394                            data->pscan_rep_mode, data->pscan_period_mode,
395                            data->pscan_mode, data->dev_class[2],
396                            data->dev_class[1], data->dev_class[0],
397                            __le16_to_cpu(data->clock_offset),
398                            data->rssi, data->ssp_mode, e->timestamp);
399         }
400
401         hci_dev_unlock(hdev);
402
403         return 0;
404 }
405
406 static int inquiry_cache_open(struct inode *inode, struct file *file)
407 {
408         return single_open(file, inquiry_cache_show, inode->i_private);
409 }
410
411 static const struct file_operations inquiry_cache_fops = {
412         .open           = inquiry_cache_open,
413         .read           = seq_read,
414         .llseek         = seq_lseek,
415         .release        = single_release,
416 };
417
418 static int blacklist_show(struct seq_file *f, void *p)
419 {
420         struct hci_dev *hdev = f->private;
421         struct bdaddr_list *b;
422
423         hci_dev_lock(hdev);
424
425         list_for_each_entry(b, &hdev->blacklist, list)
426                 seq_printf(f, "%s\n", batostr(&b->bdaddr));
427
428         hci_dev_unlock(hdev);
429
430         return 0;
431 }
432
433 static int blacklist_open(struct inode *inode, struct file *file)
434 {
435         return single_open(file, blacklist_show, inode->i_private);
436 }
437
438 static const struct file_operations blacklist_fops = {
439         .open           = blacklist_open,
440         .read           = seq_read,
441         .llseek         = seq_lseek,
442         .release        = single_release,
443 };
444
445 static void print_bt_uuid(struct seq_file *f, u8 *uuid)
446 {
447         u32 data0, data4;
448         u16 data1, data2, data3, data5;
449
450         memcpy(&data0, &uuid[0], 4);
451         memcpy(&data1, &uuid[4], 2);
452         memcpy(&data2, &uuid[6], 2);
453         memcpy(&data3, &uuid[8], 2);
454         memcpy(&data4, &uuid[10], 4);
455         memcpy(&data5, &uuid[14], 2);
456
457         seq_printf(f, "%.8x-%.4x-%.4x-%.4x-%.8x%.4x\n",
458                                 ntohl(data0), ntohs(data1), ntohs(data2),
459                                 ntohs(data3), ntohl(data4), ntohs(data5));
460 }
461
462 static int uuids_show(struct seq_file *f, void *p)
463 {
464         struct hci_dev *hdev = f->private;
465         struct bt_uuid *uuid;
466
467         hci_dev_lock(hdev);
468
469         list_for_each_entry(uuid, &hdev->uuids, list)
470                 print_bt_uuid(f, uuid->uuid);
471
472         hci_dev_unlock(hdev);
473
474         return 0;
475 }
476
477 static int uuids_open(struct inode *inode, struct file *file)
478 {
479         return single_open(file, uuids_show, inode->i_private);
480 }
481
482 static const struct file_operations uuids_fops = {
483         .open           = uuids_open,
484         .read           = seq_read,
485         .llseek         = seq_lseek,
486         .release        = single_release,
487 };
488
489 static int auto_accept_delay_set(void *data, u64 val)
490 {
491         struct hci_dev *hdev = data;
492
493         hci_dev_lock(hdev);
494
495         hdev->auto_accept_delay = val;
496
497         hci_dev_unlock(hdev);
498
499         return 0;
500 }
501
502 static int auto_accept_delay_get(void *data, u64 *val)
503 {
504         struct hci_dev *hdev = data;
505
506         hci_dev_lock(hdev);
507
508         *val = hdev->auto_accept_delay;
509
510         hci_dev_unlock(hdev);
511
512         return 0;
513 }
514
515 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
516                                         auto_accept_delay_set, "%llu\n");
517
518 void hci_init_sysfs(struct hci_dev *hdev)
519 {
520         struct device *dev = &hdev->dev;
521
522         dev->type = &bt_host;
523         dev->class = bt_class;
524
525         __module_get(THIS_MODULE);
526         device_initialize(dev);
527 }
528
529 int hci_add_sysfs(struct hci_dev *hdev)
530 {
531         struct device *dev = &hdev->dev;
532         int err;
533
534         BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
535
536         dev->parent = hdev->parent;
537         dev_set_name(dev, "%s", hdev->name);
538
539         err = device_add(dev);
540         if (err < 0)
541                 return err;
542
543         if (!bt_debugfs)
544                 return 0;
545
546         hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs);
547         if (!hdev->debugfs)
548                 return 0;
549
550         debugfs_create_file("inquiry_cache", 0444, hdev->debugfs,
551                                                 hdev, &inquiry_cache_fops);
552
553         debugfs_create_file("blacklist", 0444, hdev->debugfs,
554                                                 hdev, &blacklist_fops);
555
556         debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
557
558         debugfs_create_file("auto_accept_delay", 0444, hdev->debugfs, hdev,
559                                                 &auto_accept_delay_fops);
560         return 0;
561 }
562
563 void hci_del_sysfs(struct hci_dev *hdev)
564 {
565         BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
566
567         debugfs_remove_recursive(hdev->debugfs);
568
569         device_del(&hdev->dev);
570 }
571
572 int __init bt_sysfs_init(void)
573 {
574         bt_debugfs = debugfs_create_dir("bluetooth", NULL);
575
576         bt_class = class_create(THIS_MODULE, "bluetooth");
577         if (IS_ERR(bt_class))
578                 return PTR_ERR(bt_class);
579
580         return 0;
581 }
582
583 void bt_sysfs_cleanup(void)
584 {
585         class_destroy(bt_class);
586
587         debugfs_remove_recursive(bt_debugfs);
588 }