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