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