~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/bluetooth/hci_sysfs.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 }
589 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp