1 /* 2 BlueZ - Bluetooth protocol stack for Linux 3 4 Copyright (C) 2014 Intel Corporation 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License version 2 as 8 published by the Free Software Foundation; 9 10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 21 SOFTWARE IS DISCLAIMED. 22 */ 23 24 #include <linux/debugfs.h> 25 26 #include <net/bluetooth/bluetooth.h> 27 #include <net/bluetooth/hci_core.h> 28 29 #include "hci_debugfs.h" 30 31 #define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \ 32 static ssize_t __name ## _read(struct file *file, \ 33 char __user *user_buf, \ 34 size_t count, loff_t *ppos) \ 35 { \ 36 struct hci_dev *hdev = file->private_data; \ 37 char buf[3]; \ 38 \ 39 buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N'; \ 40 buf[1] = '\n'; \ 41 buf[2] = '\0'; \ 42 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); \ 43 } \ 44 \ 45 static ssize_t __name ## _write(struct file *file, \ 46 const char __user *user_buf, \ 47 size_t count, loff_t *ppos) \ 48 { \ 49 struct hci_dev *hdev = file->private_data; \ 50 char buf[32]; \ 51 size_t buf_size = min(count, (sizeof(buf) - 1)); \ 52 bool enable; \ 53 \ 54 if (test_bit(HCI_UP, &hdev->flags)) \ 55 return -EBUSY; \ 56 \ 57 if (copy_from_user(buf, user_buf, buf_size)) \ 58 return -EFAULT; \ 59 \ 60 buf[buf_size] = '\0'; \ 61 if (strtobool(buf, &enable)) \ 62 return -EINVAL; \ 63 \ 64 if (enable == test_bit(__quirk, &hdev->quirks)) \ 65 return -EALREADY; \ 66 \ 67 change_bit(__quirk, &hdev->quirks); \ 68 \ 69 return count; \ 70 } \ 71 \ 72 static const struct file_operations __name ## _fops = { \ 73 .open = simple_open, \ 74 .read = __name ## _read, \ 75 .write = __name ## _write, \ 76 .llseek = default_llseek, \ 77 } \ 78 79 #define DEFINE_INFO_ATTRIBUTE(__name, __field) \ 80 static int __name ## _show(struct seq_file *f, void *ptr) \ 81 { \ 82 struct hci_dev *hdev = f->private; \ 83 \ 84 hci_dev_lock(hdev); \ 85 seq_printf(f, "%s\n", hdev->__field ? : ""); \ 86 hci_dev_unlock(hdev); \ 87 \ 88 return 0; \ 89 } \ 90 \ 91 DEFINE_SHOW_ATTRIBUTE(__name) 92 93 static int features_show(struct seq_file *f, void *ptr) 94 { 95 struct hci_dev *hdev = f->private; 96 u8 p; 97 98 hci_dev_lock(hdev); 99 for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) 100 seq_printf(f, "%2u: %8ph\n", p, hdev->features[p]); 101 if (lmp_le_capable(hdev)) 102 seq_printf(f, "LE: %8ph\n", hdev->le_features); 103 hci_dev_unlock(hdev); 104 105 return 0; 106 } 107 108 DEFINE_SHOW_ATTRIBUTE(features); 109 110 static int device_id_show(struct seq_file *f, void *ptr) 111 { 112 struct hci_dev *hdev = f->private; 113 114 hci_dev_lock(hdev); 115 seq_printf(f, "%4.4x:%4.4x:%4.4x:%4.4x\n", hdev->devid_source, 116 hdev->devid_vendor, hdev->devid_product, hdev->devid_version); 117 hci_dev_unlock(hdev); 118 119 return 0; 120 } 121 122 DEFINE_SHOW_ATTRIBUTE(device_id); 123 124 static int device_list_show(struct seq_file *f, void *ptr) 125 { 126 struct hci_dev *hdev = f->private; 127 struct hci_conn_params *p; 128 struct bdaddr_list *b; 129 130 hci_dev_lock(hdev); 131 list_for_each_entry(b, &hdev->whitelist, list) 132 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 133 list_for_each_entry(p, &hdev->le_conn_params, list) { 134 seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type, 135 p->auto_connect); 136 } 137 hci_dev_unlock(hdev); 138 139 return 0; 140 } 141 142 DEFINE_SHOW_ATTRIBUTE(device_list); 143 144 static int blacklist_show(struct seq_file *f, void *p) 145 { 146 struct hci_dev *hdev = f->private; 147 struct bdaddr_list *b; 148 149 hci_dev_lock(hdev); 150 list_for_each_entry(b, &hdev->blacklist, list) 151 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 152 hci_dev_unlock(hdev); 153 154 return 0; 155 } 156 157 DEFINE_SHOW_ATTRIBUTE(blacklist); 158 159 static int uuids_show(struct seq_file *f, void *p) 160 { 161 struct hci_dev *hdev = f->private; 162 struct bt_uuid *uuid; 163 164 hci_dev_lock(hdev); 165 list_for_each_entry(uuid, &hdev->uuids, list) { 166 u8 i, val[16]; 167 168 /* The Bluetooth UUID values are stored in big endian, 169 * but with reversed byte order. So convert them into 170 * the right order for the %pUb modifier. 171 */ 172 for (i = 0; i < 16; i++) 173 val[i] = uuid->uuid[15 - i]; 174 175 seq_printf(f, "%pUb\n", val); 176 } 177 hci_dev_unlock(hdev); 178 179 return 0; 180 } 181 182 DEFINE_SHOW_ATTRIBUTE(uuids); 183 184 static int remote_oob_show(struct seq_file *f, void *ptr) 185 { 186 struct hci_dev *hdev = f->private; 187 struct oob_data *data; 188 189 hci_dev_lock(hdev); 190 list_for_each_entry(data, &hdev->remote_oob_data, list) { 191 seq_printf(f, "%pMR (type %u) %u %*phN %*phN %*phN %*phN\n", 192 &data->bdaddr, data->bdaddr_type, data->present, 193 16, data->hash192, 16, data->rand192, 194 16, data->hash256, 16, data->rand256); 195 } 196 hci_dev_unlock(hdev); 197 198 return 0; 199 } 200 201 DEFINE_SHOW_ATTRIBUTE(remote_oob); 202 203 static int conn_info_min_age_set(void *data, u64 val) 204 { 205 struct hci_dev *hdev = data; 206 207 if (val == 0 || val > hdev->conn_info_max_age) 208 return -EINVAL; 209 210 hci_dev_lock(hdev); 211 hdev->conn_info_min_age = val; 212 hci_dev_unlock(hdev); 213 214 return 0; 215 } 216 217 static int conn_info_min_age_get(void *data, u64 *val) 218 { 219 struct hci_dev *hdev = data; 220 221 hci_dev_lock(hdev); 222 *val = hdev->conn_info_min_age; 223 hci_dev_unlock(hdev); 224 225 return 0; 226 } 227 228 DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get, 229 conn_info_min_age_set, "%llu\n"); 230 231 static int conn_info_max_age_set(void *data, u64 val) 232 { 233 struct hci_dev *hdev = data; 234 235 if (val == 0 || val < hdev->conn_info_min_age) 236 return -EINVAL; 237 238 hci_dev_lock(hdev); 239 hdev->conn_info_max_age = val; 240 hci_dev_unlock(hdev); 241 242 return 0; 243 } 244 245 static int conn_info_max_age_get(void *data, u64 *val) 246 { 247 struct hci_dev *hdev = data; 248 249 hci_dev_lock(hdev); 250 *val = hdev->conn_info_max_age; 251 hci_dev_unlock(hdev); 252 253 return 0; 254 } 255 256 DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get, 257 conn_info_max_age_set, "%llu\n"); 258 259 static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf, 260 size_t count, loff_t *ppos) 261 { 262 struct hci_dev *hdev = file->private_data; 263 char buf[3]; 264 265 buf[0] = hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS) ? 'Y': 'N'; 266 buf[1] = '\n'; 267 buf[2] = '\0'; 268 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 269 } 270 271 static const struct file_operations use_debug_keys_fops = { 272 .open = simple_open, 273 .read = use_debug_keys_read, 274 .llseek = default_llseek, 275 }; 276 277 static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf, 278 size_t count, loff_t *ppos) 279 { 280 struct hci_dev *hdev = file->private_data; 281 char buf[3]; 282 283 buf[0] = hci_dev_test_flag(hdev, HCI_SC_ONLY) ? 'Y': 'N'; 284 buf[1] = '\n'; 285 buf[2] = '\0'; 286 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 287 } 288 289 static const struct file_operations sc_only_mode_fops = { 290 .open = simple_open, 291 .read = sc_only_mode_read, 292 .llseek = default_llseek, 293 }; 294 295 DEFINE_INFO_ATTRIBUTE(hardware_info, hw_info); 296 DEFINE_INFO_ATTRIBUTE(firmware_info, fw_info); 297 298 void hci_debugfs_create_common(struct hci_dev *hdev) 299 { 300 debugfs_create_file("features", 0444, hdev->debugfs, hdev, 301 &features_fops); 302 debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 303 &hdev->manufacturer); 304 debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 305 debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 306 debugfs_create_u8("hardware_error", 0444, hdev->debugfs, 307 &hdev->hw_error_code); 308 debugfs_create_file("device_id", 0444, hdev->debugfs, hdev, 309 &device_id_fops); 310 311 debugfs_create_file("device_list", 0444, hdev->debugfs, hdev, 312 &device_list_fops); 313 debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 314 &blacklist_fops); 315 debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 316 debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev, 317 &remote_oob_fops); 318 319 debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 320 &conn_info_min_age_fops); 321 debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 322 &conn_info_max_age_fops); 323 324 if (lmp_ssp_capable(hdev) || lmp_le_capable(hdev)) 325 debugfs_create_file("use_debug_keys", 0444, hdev->debugfs, 326 hdev, &use_debug_keys_fops); 327 328 if (lmp_sc_capable(hdev) || lmp_le_capable(hdev)) 329 debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 330 hdev, &sc_only_mode_fops); 331 332 if (hdev->hw_info) 333 debugfs_create_file("hardware_info", 0444, hdev->debugfs, 334 hdev, &hardware_info_fops); 335 336 if (hdev->fw_info) 337 debugfs_create_file("firmware_info", 0444, hdev->debugfs, 338 hdev, &firmware_info_fops); 339 } 340 341 static int inquiry_cache_show(struct seq_file *f, void *p) 342 { 343 struct hci_dev *hdev = f->private; 344 struct discovery_state *cache = &hdev->discovery; 345 struct inquiry_entry *e; 346 347 hci_dev_lock(hdev); 348 349 list_for_each_entry(e, &cache->all, all) { 350 struct inquiry_data *data = &e->data; 351 seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 352 &data->bdaddr, 353 data->pscan_rep_mode, data->pscan_period_mode, 354 data->pscan_mode, data->dev_class[2], 355 data->dev_class[1], data->dev_class[0], 356 __le16_to_cpu(data->clock_offset), 357 data->rssi, data->ssp_mode, e->timestamp); 358 } 359 360 hci_dev_unlock(hdev); 361 362 return 0; 363 } 364 365 DEFINE_SHOW_ATTRIBUTE(inquiry_cache); 366 367 static int link_keys_show(struct seq_file *f, void *ptr) 368 { 369 struct hci_dev *hdev = f->private; 370 struct link_key *key; 371 372 rcu_read_lock(); 373 list_for_each_entry_rcu(key, &hdev->link_keys, list) 374 seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type, 375 HCI_LINK_KEY_SIZE, key->val, key->pin_len); 376 rcu_read_unlock(); 377 378 return 0; 379 } 380 381 DEFINE_SHOW_ATTRIBUTE(link_keys); 382 383 static int dev_class_show(struct seq_file *f, void *ptr) 384 { 385 struct hci_dev *hdev = f->private; 386 387 hci_dev_lock(hdev); 388 seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2], 389 hdev->dev_class[1], hdev->dev_class[0]); 390 hci_dev_unlock(hdev); 391 392 return 0; 393 } 394 395 DEFINE_SHOW_ATTRIBUTE(dev_class); 396 397 static int voice_setting_get(void *data, u64 *val) 398 { 399 struct hci_dev *hdev = data; 400 401 hci_dev_lock(hdev); 402 *val = hdev->voice_setting; 403 hci_dev_unlock(hdev); 404 405 return 0; 406 } 407 408 DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 409 NULL, "0x%4.4llx\n"); 410 411 static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf, 412 size_t count, loff_t *ppos) 413 { 414 struct hci_dev *hdev = file->private_data; 415 char buf[3]; 416 417 buf[0] = hdev->ssp_debug_mode ? 'Y': 'N'; 418 buf[1] = '\n'; 419 buf[2] = '\0'; 420 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 421 } 422 423 static const struct file_operations ssp_debug_mode_fops = { 424 .open = simple_open, 425 .read = ssp_debug_mode_read, 426 .llseek = default_llseek, 427 }; 428 429 static int auto_accept_delay_set(void *data, u64 val) 430 { 431 struct hci_dev *hdev = data; 432 433 hci_dev_lock(hdev); 434 hdev->auto_accept_delay = val; 435 hci_dev_unlock(hdev); 436 437 return 0; 438 } 439 440 static int auto_accept_delay_get(void *data, u64 *val) 441 { 442 struct hci_dev *hdev = data; 443 444 hci_dev_lock(hdev); 445 *val = hdev->auto_accept_delay; 446 hci_dev_unlock(hdev); 447 448 return 0; 449 } 450 451 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 452 auto_accept_delay_set, "%llu\n"); 453 454 static int idle_timeout_set(void *data, u64 val) 455 { 456 struct hci_dev *hdev = data; 457 458 if (val != 0 && (val < 500 || val > 3600000)) 459 return -EINVAL; 460 461 hci_dev_lock(hdev); 462 hdev->idle_timeout = val; 463 hci_dev_unlock(hdev); 464 465 return 0; 466 } 467 468 static int idle_timeout_get(void *data, u64 *val) 469 { 470 struct hci_dev *hdev = data; 471 472 hci_dev_lock(hdev); 473 *val = hdev->idle_timeout; 474 hci_dev_unlock(hdev); 475 476 return 0; 477 } 478 479 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 480 idle_timeout_set, "%llu\n"); 481 482 static int sniff_min_interval_set(void *data, u64 val) 483 { 484 struct hci_dev *hdev = data; 485 486 if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 487 return -EINVAL; 488 489 hci_dev_lock(hdev); 490 hdev->sniff_min_interval = val; 491 hci_dev_unlock(hdev); 492 493 return 0; 494 } 495 496 static int sniff_min_interval_get(void *data, u64 *val) 497 { 498 struct hci_dev *hdev = data; 499 500 hci_dev_lock(hdev); 501 *val = hdev->sniff_min_interval; 502 hci_dev_unlock(hdev); 503 504 return 0; 505 } 506 507 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 508 sniff_min_interval_set, "%llu\n"); 509 510 static int sniff_max_interval_set(void *data, u64 val) 511 { 512 struct hci_dev *hdev = data; 513 514 if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 515 return -EINVAL; 516 517 hci_dev_lock(hdev); 518 hdev->sniff_max_interval = val; 519 hci_dev_unlock(hdev); 520 521 return 0; 522 } 523 524 static int sniff_max_interval_get(void *data, u64 *val) 525 { 526 struct hci_dev *hdev = data; 527 528 hci_dev_lock(hdev); 529 *val = hdev->sniff_max_interval; 530 hci_dev_unlock(hdev); 531 532 return 0; 533 } 534 535 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 536 sniff_max_interval_set, "%llu\n"); 537 538 void hci_debugfs_create_bredr(struct hci_dev *hdev) 539 { 540 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev, 541 &inquiry_cache_fops); 542 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev, 543 &link_keys_fops); 544 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev, 545 &dev_class_fops); 546 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev, 547 &voice_setting_fops); 548 549 if (lmp_ssp_capable(hdev)) { 550 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs, 551 hdev, &ssp_debug_mode_fops); 552 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 553 hdev, &auto_accept_delay_fops); 554 } 555 556 if (lmp_sniff_capable(hdev)) { 557 debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 558 hdev, &idle_timeout_fops); 559 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 560 hdev, &sniff_min_interval_fops); 561 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 562 hdev, &sniff_max_interval_fops); 563 } 564 } 565 566 static int identity_show(struct seq_file *f, void *p) 567 { 568 struct hci_dev *hdev = f->private; 569 bdaddr_t addr; 570 u8 addr_type; 571 572 hci_dev_lock(hdev); 573 574 hci_copy_identity_address(hdev, &addr, &addr_type); 575 576 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type, 577 16, hdev->irk, &hdev->rpa); 578 579 hci_dev_unlock(hdev); 580 581 return 0; 582 } 583 584 DEFINE_SHOW_ATTRIBUTE(identity); 585 586 static int rpa_timeout_set(void *data, u64 val) 587 { 588 struct hci_dev *hdev = data; 589 590 /* Require the RPA timeout to be at least 30 seconds and at most 591 * 24 hours. 592 */ 593 if (val < 30 || val > (60 * 60 * 24)) 594 return -EINVAL; 595 596 hci_dev_lock(hdev); 597 hdev->rpa_timeout = val; 598 hci_dev_unlock(hdev); 599 600 return 0; 601 } 602 603 static int rpa_timeout_get(void *data, u64 *val) 604 { 605 struct hci_dev *hdev = data; 606 607 hci_dev_lock(hdev); 608 *val = hdev->rpa_timeout; 609 hci_dev_unlock(hdev); 610 611 return 0; 612 } 613 614 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get, 615 rpa_timeout_set, "%llu\n"); 616 617 static int random_address_show(struct seq_file *f, void *p) 618 { 619 struct hci_dev *hdev = f->private; 620 621 hci_dev_lock(hdev); 622 seq_printf(f, "%pMR\n", &hdev->random_addr); 623 hci_dev_unlock(hdev); 624 625 return 0; 626 } 627 628 DEFINE_SHOW_ATTRIBUTE(random_address); 629 630 static int static_address_show(struct seq_file *f, void *p) 631 { 632 struct hci_dev *hdev = f->private; 633 634 hci_dev_lock(hdev); 635 seq_printf(f, "%pMR\n", &hdev->static_addr); 636 hci_dev_unlock(hdev); 637 638 return 0; 639 } 640 641 DEFINE_SHOW_ATTRIBUTE(static_address); 642 643 static ssize_t force_static_address_read(struct file *file, 644 char __user *user_buf, 645 size_t count, loff_t *ppos) 646 { 647 struct hci_dev *hdev = file->private_data; 648 char buf[3]; 649 650 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N'; 651 buf[1] = '\n'; 652 buf[2] = '\0'; 653 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 654 } 655 656 static ssize_t force_static_address_write(struct file *file, 657 const char __user *user_buf, 658 size_t count, loff_t *ppos) 659 { 660 struct hci_dev *hdev = file->private_data; 661 char buf[32]; 662 size_t buf_size = min(count, (sizeof(buf)-1)); 663 bool enable; 664 665 if (test_bit(HCI_UP, &hdev->flags)) 666 return -EBUSY; 667 668 if (copy_from_user(buf, user_buf, buf_size)) 669 return -EFAULT; 670 671 buf[buf_size] = '\0'; 672 if (strtobool(buf, &enable)) 673 return -EINVAL; 674 675 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR)) 676 return -EALREADY; 677 678 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR); 679 680 return count; 681 } 682 683 static const struct file_operations force_static_address_fops = { 684 .open = simple_open, 685 .read = force_static_address_read, 686 .write = force_static_address_write, 687 .llseek = default_llseek, 688 }; 689 690 static int white_list_show(struct seq_file *f, void *ptr) 691 { 692 struct hci_dev *hdev = f->private; 693 struct bdaddr_list *b; 694 695 hci_dev_lock(hdev); 696 list_for_each_entry(b, &hdev->le_white_list, list) 697 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 698 hci_dev_unlock(hdev); 699 700 return 0; 701 } 702 703 DEFINE_SHOW_ATTRIBUTE(white_list); 704 705 static int identity_resolving_keys_show(struct seq_file *f, void *ptr) 706 { 707 struct hci_dev *hdev = f->private; 708 struct smp_irk *irk; 709 710 rcu_read_lock(); 711 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 712 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", 713 &irk->bdaddr, irk->addr_type, 714 16, irk->val, &irk->rpa); 715 } 716 rcu_read_unlock(); 717 718 return 0; 719 } 720 721 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys); 722 723 static int long_term_keys_show(struct seq_file *f, void *ptr) 724 { 725 struct hci_dev *hdev = f->private; 726 struct smp_ltk *ltk; 727 728 rcu_read_lock(); 729 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list) 730 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n", 731 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 732 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 733 __le64_to_cpu(ltk->rand), 16, ltk->val); 734 rcu_read_unlock(); 735 736 return 0; 737 } 738 739 DEFINE_SHOW_ATTRIBUTE(long_term_keys); 740 741 static int conn_min_interval_set(void *data, u64 val) 742 { 743 struct hci_dev *hdev = data; 744 745 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) 746 return -EINVAL; 747 748 hci_dev_lock(hdev); 749 hdev->le_conn_min_interval = val; 750 hci_dev_unlock(hdev); 751 752 return 0; 753 } 754 755 static int conn_min_interval_get(void *data, u64 *val) 756 { 757 struct hci_dev *hdev = data; 758 759 hci_dev_lock(hdev); 760 *val = hdev->le_conn_min_interval; 761 hci_dev_unlock(hdev); 762 763 return 0; 764 } 765 766 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get, 767 conn_min_interval_set, "%llu\n"); 768 769 static int conn_max_interval_set(void *data, u64 val) 770 { 771 struct hci_dev *hdev = data; 772 773 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) 774 return -EINVAL; 775 776 hci_dev_lock(hdev); 777 hdev->le_conn_max_interval = val; 778 hci_dev_unlock(hdev); 779 780 return 0; 781 } 782 783 static int conn_max_interval_get(void *data, u64 *val) 784 { 785 struct hci_dev *hdev = data; 786 787 hci_dev_lock(hdev); 788 *val = hdev->le_conn_max_interval; 789 hci_dev_unlock(hdev); 790 791 return 0; 792 } 793 794 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get, 795 conn_max_interval_set, "%llu\n"); 796 797 static int conn_latency_set(void *data, u64 val) 798 { 799 struct hci_dev *hdev = data; 800 801 if (val > 0x01f3) 802 return -EINVAL; 803 804 hci_dev_lock(hdev); 805 hdev->le_conn_latency = val; 806 hci_dev_unlock(hdev); 807 808 return 0; 809 } 810 811 static int conn_latency_get(void *data, u64 *val) 812 { 813 struct hci_dev *hdev = data; 814 815 hci_dev_lock(hdev); 816 *val = hdev->le_conn_latency; 817 hci_dev_unlock(hdev); 818 819 return 0; 820 } 821 822 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get, 823 conn_latency_set, "%llu\n"); 824 825 static int supervision_timeout_set(void *data, u64 val) 826 { 827 struct hci_dev *hdev = data; 828 829 if (val < 0x000a || val > 0x0c80) 830 return -EINVAL; 831 832 hci_dev_lock(hdev); 833 hdev->le_supv_timeout = val; 834 hci_dev_unlock(hdev); 835 836 return 0; 837 } 838 839 static int supervision_timeout_get(void *data, u64 *val) 840 { 841 struct hci_dev *hdev = data; 842 843 hci_dev_lock(hdev); 844 *val = hdev->le_supv_timeout; 845 hci_dev_unlock(hdev); 846 847 return 0; 848 } 849 850 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get, 851 supervision_timeout_set, "%llu\n"); 852 853 static int adv_channel_map_set(void *data, u64 val) 854 { 855 struct hci_dev *hdev = data; 856 857 if (val < 0x01 || val > 0x07) 858 return -EINVAL; 859 860 hci_dev_lock(hdev); 861 hdev->le_adv_channel_map = val; 862 hci_dev_unlock(hdev); 863 864 return 0; 865 } 866 867 static int adv_channel_map_get(void *data, u64 *val) 868 { 869 struct hci_dev *hdev = data; 870 871 hci_dev_lock(hdev); 872 *val = hdev->le_adv_channel_map; 873 hci_dev_unlock(hdev); 874 875 return 0; 876 } 877 878 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get, 879 adv_channel_map_set, "%llu\n"); 880 881 static int adv_min_interval_set(void *data, u64 val) 882 { 883 struct hci_dev *hdev = data; 884 885 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval) 886 return -EINVAL; 887 888 hci_dev_lock(hdev); 889 hdev->le_adv_min_interval = val; 890 hci_dev_unlock(hdev); 891 892 return 0; 893 } 894 895 static int adv_min_interval_get(void *data, u64 *val) 896 { 897 struct hci_dev *hdev = data; 898 899 hci_dev_lock(hdev); 900 *val = hdev->le_adv_min_interval; 901 hci_dev_unlock(hdev); 902 903 return 0; 904 } 905 906 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get, 907 adv_min_interval_set, "%llu\n"); 908 909 static int adv_max_interval_set(void *data, u64 val) 910 { 911 struct hci_dev *hdev = data; 912 913 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval) 914 return -EINVAL; 915 916 hci_dev_lock(hdev); 917 hdev->le_adv_max_interval = val; 918 hci_dev_unlock(hdev); 919 920 return 0; 921 } 922 923 static int adv_max_interval_get(void *data, u64 *val) 924 { 925 struct hci_dev *hdev = data; 926 927 hci_dev_lock(hdev); 928 *val = hdev->le_adv_max_interval; 929 hci_dev_unlock(hdev); 930 931 return 0; 932 } 933 934 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get, 935 adv_max_interval_set, "%llu\n"); 936 937 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter, 938 HCI_QUIRK_STRICT_DUPLICATE_FILTER); 939 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery, 940 HCI_QUIRK_SIMULTANEOUS_DISCOVERY); 941 942 void hci_debugfs_create_le(struct hci_dev *hdev) 943 { 944 debugfs_create_file("identity", 0400, hdev->debugfs, hdev, 945 &identity_fops); 946 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev, 947 &rpa_timeout_fops); 948 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev, 949 &random_address_fops); 950 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev, 951 &static_address_fops); 952 953 /* For controllers with a public address, provide a debug 954 * option to force the usage of the configured static 955 * address. By default the public address is used. 956 */ 957 if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 958 debugfs_create_file("force_static_address", 0644, 959 hdev->debugfs, hdev, 960 &force_static_address_fops); 961 962 debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 963 &hdev->le_white_list_size); 964 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 965 &white_list_fops); 966 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs, 967 hdev, &identity_resolving_keys_fops); 968 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev, 969 &long_term_keys_fops); 970 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev, 971 &conn_min_interval_fops); 972 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev, 973 &conn_max_interval_fops); 974 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev, 975 &conn_latency_fops); 976 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev, 977 &supervision_timeout_fops); 978 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev, 979 &adv_channel_map_fops); 980 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev, 981 &adv_min_interval_fops); 982 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev, 983 &adv_max_interval_fops); 984 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs, 985 &hdev->discov_interleaved_timeout); 986 987 debugfs_create_file("quirk_strict_duplicate_filter", 0644, 988 hdev->debugfs, hdev, 989 &quirk_strict_duplicate_filter_fops); 990 debugfs_create_file("quirk_simultaneous_discovery", 0644, 991 hdev->debugfs, hdev, 992 &quirk_simultaneous_discovery_fops); 993 } 994 995 void hci_debugfs_create_conn(struct hci_conn *conn) 996 { 997 struct hci_dev *hdev = conn->hdev; 998 char name[6]; 999 1000 if (IS_ERR_OR_NULL(hdev->debugfs)) 1001 return; 1002 1003 snprintf(name, sizeof(name), "%u", conn->handle); 1004 conn->debugfs = debugfs_create_dir(name, hdev->debugfs); 1005 } 1006