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 = dev_get_drvdata(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 = dev_get_drvdata(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 = 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) \ 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 void *data = dev_get_drvdata(dev); 83 kfree(data); 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 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 133 void 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 156 static 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 178 static 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 190 static 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 196 static 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 202 static 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 215 static 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 222 static 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 228 static 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 239 static 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 245 static 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 251 static 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 257 static 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 263 static 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 281 static 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 287 static 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 305 static 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 311 static 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 329 static DEVICE_ATTR(bus, S_IRUGO, show_bus, NULL); 330 static DEVICE_ATTR(type, S_IRUGO, show_type, NULL); 331 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 332 static DEVICE_ATTR(class, S_IRUGO, show_class, NULL); 333 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL); 334 static DEVICE_ATTR(features, S_IRUGO, show_features, NULL); 335 static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL); 336 static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL); 337 static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL); 338 339 static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR, 340 show_idle_timeout, store_idle_timeout); 341 static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR, 342 show_sniff_max_interval, store_sniff_max_interval); 343 static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR, 344 show_sniff_min_interval, store_sniff_min_interval); 345 346 static 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 362 static struct attribute_group bt_host_group = { 363 .attrs = bt_host_attrs, 364 }; 365 366 static const struct attribute_group *bt_host_groups[] = { 367 &bt_host_group, 368 NULL 369 }; 370 371 static void bt_host_release(struct device *dev) 372 { 373 void *data = dev_get_drvdata(dev); 374 kfree(data); 375 } 376 377 static struct device_type bt_host = { 378 .name = "host", 379 .groups = bt_host_groups, 380 .release = bt_host_release, 381 }; 382 383 static int inquiry_cache_show(struct seq_file *f, void *p) 384 { 385 struct hci_dev *hdev = f->private; 386 struct inquiry_cache *cache = &hdev->inq_cache; 387 struct inquiry_entry *e; 388 389 hci_dev_lock(hdev); 390 391 for (e = cache->list; e; e = e->next) { 392 struct inquiry_data *data = &e->data; 393 seq_printf(f, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 394 batostr(&data->bdaddr), 395 data->pscan_rep_mode, data->pscan_period_mode, 396 data->pscan_mode, data->dev_class[2], 397 data->dev_class[1], data->dev_class[0], 398 __le16_to_cpu(data->clock_offset), 399 data->rssi, data->ssp_mode, e->timestamp); 400 } 401 402 hci_dev_unlock(hdev); 403 404 return 0; 405 } 406 407 static int inquiry_cache_open(struct inode *inode, struct file *file) 408 { 409 return single_open(file, inquiry_cache_show, inode->i_private); 410 } 411 412 static const struct file_operations inquiry_cache_fops = { 413 .open = inquiry_cache_open, 414 .read = seq_read, 415 .llseek = seq_lseek, 416 .release = single_release, 417 }; 418 419 static int blacklist_show(struct seq_file *f, void *p) 420 { 421 struct hci_dev *hdev = f->private; 422 struct bdaddr_list *b; 423 424 hci_dev_lock(hdev); 425 426 list_for_each_entry(b, &hdev->blacklist, list) 427 seq_printf(f, "%s\n", batostr(&b->bdaddr)); 428 429 hci_dev_unlock(hdev); 430 431 return 0; 432 } 433 434 static int blacklist_open(struct inode *inode, struct file *file) 435 { 436 return single_open(file, blacklist_show, inode->i_private); 437 } 438 439 static const struct file_operations blacklist_fops = { 440 .open = blacklist_open, 441 .read = seq_read, 442 .llseek = seq_lseek, 443 .release = single_release, 444 }; 445 446 static void print_bt_uuid(struct seq_file *f, u8 *uuid) 447 { 448 u32 data0, data4; 449 u16 data1, data2, data3, data5; 450 451 memcpy(&data0, &uuid[0], 4); 452 memcpy(&data1, &uuid[4], 2); 453 memcpy(&data2, &uuid[6], 2); 454 memcpy(&data3, &uuid[8], 2); 455 memcpy(&data4, &uuid[10], 4); 456 memcpy(&data5, &uuid[14], 2); 457 458 seq_printf(f, "%.8x-%.4x-%.4x-%.4x-%.8x%.4x\n", 459 ntohl(data0), ntohs(data1), ntohs(data2), 460 ntohs(data3), ntohl(data4), ntohs(data5)); 461 } 462 463 static int uuids_show(struct seq_file *f, void *p) 464 { 465 struct hci_dev *hdev = f->private; 466 struct bt_uuid *uuid; 467 468 hci_dev_lock(hdev); 469 470 list_for_each_entry(uuid, &hdev->uuids, list) 471 print_bt_uuid(f, uuid->uuid); 472 473 hci_dev_unlock(hdev); 474 475 return 0; 476 } 477 478 static int uuids_open(struct inode *inode, struct file *file) 479 { 480 return single_open(file, uuids_show, inode->i_private); 481 } 482 483 static const struct file_operations uuids_fops = { 484 .open = uuids_open, 485 .read = seq_read, 486 .llseek = seq_lseek, 487 .release = single_release, 488 }; 489 490 static int auto_accept_delay_set(void *data, u64 val) 491 { 492 struct hci_dev *hdev = data; 493 494 hci_dev_lock(hdev); 495 496 hdev->auto_accept_delay = val; 497 498 hci_dev_unlock(hdev); 499 500 return 0; 501 } 502 503 static int auto_accept_delay_get(void *data, u64 *val) 504 { 505 struct hci_dev *hdev = data; 506 507 hci_dev_lock(hdev); 508 509 *val = hdev->auto_accept_delay; 510 511 hci_dev_unlock(hdev); 512 513 return 0; 514 } 515 516 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 517 auto_accept_delay_set, "%llu\n"); 518 519 void hci_init_sysfs(struct hci_dev *hdev) 520 { 521 struct device *dev = &hdev->dev; 522 523 dev->type = &bt_host; 524 dev->class = bt_class; 525 526 dev_set_drvdata(dev, hdev); 527 device_initialize(dev); 528 } 529 530 int hci_add_sysfs(struct hci_dev *hdev) 531 { 532 struct device *dev = &hdev->dev; 533 int err; 534 535 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 536 537 dev->parent = hdev->parent; 538 dev_set_name(dev, "%s", hdev->name); 539 540 err = device_add(dev); 541 if (err < 0) 542 return err; 543 544 if (!bt_debugfs) 545 return 0; 546 547 hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 548 if (!hdev->debugfs) 549 return 0; 550 551 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 552 hdev, &inquiry_cache_fops); 553 554 debugfs_create_file("blacklist", 0444, hdev->debugfs, 555 hdev, &blacklist_fops); 556 557 debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 558 559 debugfs_create_file("auto_accept_delay", 0444, hdev->debugfs, hdev, 560 &auto_accept_delay_fops); 561 return 0; 562 } 563 564 void hci_del_sysfs(struct hci_dev *hdev) 565 { 566 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 567 568 debugfs_remove_recursive(hdev->debugfs); 569 570 device_del(&hdev->dev); 571 } 572 573 int __init bt_sysfs_init(void) 574 { 575 bt_debugfs = debugfs_create_dir("bluetooth", NULL); 576 577 bt_class = class_create(THIS_MODULE, "bluetooth"); 578 if (IS_ERR(bt_class)) 579 return PTR_ERR(bt_class); 580 581 return 0; 582 } 583 584 void bt_sysfs_cleanup(void) 585 { 586 class_destroy(bt_class); 587 588 debugfs_remove_recursive(bt_debugfs); 589 } 590