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 identity_resolving_keys_show(struct seq_file *f, void *ptr) 698 { 699 struct hci_dev *hdev = f->private; 700 struct smp_irk *irk; 701 702 rcu_read_lock(); 703 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 704 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", 705 &irk->bdaddr, irk->addr_type, 706 16, irk->val, &irk->rpa); 707 } 708 rcu_read_unlock(); 709 710 return 0; 711 } 712 713 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys); 714 715 static int long_term_keys_show(struct seq_file *f, void *ptr) 716 { 717 struct hci_dev *hdev = f->private; 718 struct smp_ltk *ltk; 719 720 rcu_read_lock(); 721 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list) 722 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n", 723 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 724 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 725 __le64_to_cpu(ltk->rand), 16, ltk->val); 726 rcu_read_unlock(); 727 728 return 0; 729 } 730 731 DEFINE_SHOW_ATTRIBUTE(long_term_keys); 732 733 static int conn_min_interval_set(void *data, u64 val) 734 { 735 struct hci_dev *hdev = data; 736 737 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) 738 return -EINVAL; 739 740 hci_dev_lock(hdev); 741 hdev->le_conn_min_interval = val; 742 hci_dev_unlock(hdev); 743 744 return 0; 745 } 746 747 static int conn_min_interval_get(void *data, u64 *val) 748 { 749 struct hci_dev *hdev = data; 750 751 hci_dev_lock(hdev); 752 *val = hdev->le_conn_min_interval; 753 hci_dev_unlock(hdev); 754 755 return 0; 756 } 757 758 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get, 759 conn_min_interval_set, "%llu\n"); 760 761 static int conn_max_interval_set(void *data, u64 val) 762 { 763 struct hci_dev *hdev = data; 764 765 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) 766 return -EINVAL; 767 768 hci_dev_lock(hdev); 769 hdev->le_conn_max_interval = val; 770 hci_dev_unlock(hdev); 771 772 return 0; 773 } 774 775 static int conn_max_interval_get(void *data, u64 *val) 776 { 777 struct hci_dev *hdev = data; 778 779 hci_dev_lock(hdev); 780 *val = hdev->le_conn_max_interval; 781 hci_dev_unlock(hdev); 782 783 return 0; 784 } 785 786 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get, 787 conn_max_interval_set, "%llu\n"); 788 789 static int conn_latency_set(void *data, u64 val) 790 { 791 struct hci_dev *hdev = data; 792 793 if (val > 0x01f3) 794 return -EINVAL; 795 796 hci_dev_lock(hdev); 797 hdev->le_conn_latency = val; 798 hci_dev_unlock(hdev); 799 800 return 0; 801 } 802 803 static int conn_latency_get(void *data, u64 *val) 804 { 805 struct hci_dev *hdev = data; 806 807 hci_dev_lock(hdev); 808 *val = hdev->le_conn_latency; 809 hci_dev_unlock(hdev); 810 811 return 0; 812 } 813 814 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get, 815 conn_latency_set, "%llu\n"); 816 817 static int supervision_timeout_set(void *data, u64 val) 818 { 819 struct hci_dev *hdev = data; 820 821 if (val < 0x000a || val > 0x0c80) 822 return -EINVAL; 823 824 hci_dev_lock(hdev); 825 hdev->le_supv_timeout = val; 826 hci_dev_unlock(hdev); 827 828 return 0; 829 } 830 831 static int supervision_timeout_get(void *data, u64 *val) 832 { 833 struct hci_dev *hdev = data; 834 835 hci_dev_lock(hdev); 836 *val = hdev->le_supv_timeout; 837 hci_dev_unlock(hdev); 838 839 return 0; 840 } 841 842 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get, 843 supervision_timeout_set, "%llu\n"); 844 845 static int adv_channel_map_set(void *data, u64 val) 846 { 847 struct hci_dev *hdev = data; 848 849 if (val < 0x01 || val > 0x07) 850 return -EINVAL; 851 852 hci_dev_lock(hdev); 853 hdev->le_adv_channel_map = val; 854 hci_dev_unlock(hdev); 855 856 return 0; 857 } 858 859 static int adv_channel_map_get(void *data, u64 *val) 860 { 861 struct hci_dev *hdev = data; 862 863 hci_dev_lock(hdev); 864 *val = hdev->le_adv_channel_map; 865 hci_dev_unlock(hdev); 866 867 return 0; 868 } 869 870 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get, 871 adv_channel_map_set, "%llu\n"); 872 873 static int adv_min_interval_set(void *data, u64 val) 874 { 875 struct hci_dev *hdev = data; 876 877 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval) 878 return -EINVAL; 879 880 hci_dev_lock(hdev); 881 hdev->le_adv_min_interval = val; 882 hci_dev_unlock(hdev); 883 884 return 0; 885 } 886 887 static int adv_min_interval_get(void *data, u64 *val) 888 { 889 struct hci_dev *hdev = data; 890 891 hci_dev_lock(hdev); 892 *val = hdev->le_adv_min_interval; 893 hci_dev_unlock(hdev); 894 895 return 0; 896 } 897 898 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get, 899 adv_min_interval_set, "%llu\n"); 900 901 static int adv_max_interval_set(void *data, u64 val) 902 { 903 struct hci_dev *hdev = data; 904 905 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval) 906 return -EINVAL; 907 908 hci_dev_lock(hdev); 909 hdev->le_adv_max_interval = val; 910 hci_dev_unlock(hdev); 911 912 return 0; 913 } 914 915 static int adv_max_interval_get(void *data, u64 *val) 916 { 917 struct hci_dev *hdev = data; 918 919 hci_dev_lock(hdev); 920 *val = hdev->le_adv_max_interval; 921 hci_dev_unlock(hdev); 922 923 return 0; 924 } 925 926 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get, 927 adv_max_interval_set, "%llu\n"); 928 929 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter, 930 HCI_QUIRK_STRICT_DUPLICATE_FILTER); 931 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery, 932 HCI_QUIRK_SIMULTANEOUS_DISCOVERY); 933 934 void hci_debugfs_create_le(struct hci_dev *hdev) 935 { 936 debugfs_create_file("identity", 0400, hdev->debugfs, hdev, 937 &identity_fops); 938 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev, 939 &rpa_timeout_fops); 940 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev, 941 &random_address_fops); 942 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev, 943 &static_address_fops); 944 945 /* For controllers with a public address, provide a debug 946 * option to force the usage of the configured static 947 * address. By default the public address is used. 948 */ 949 if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 950 debugfs_create_file("force_static_address", 0644, 951 hdev->debugfs, hdev, 952 &force_static_address_fops); 953 954 debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 955 &hdev->le_white_list_size); 956 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 957 &white_list_fops); 958 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs, 959 hdev, &identity_resolving_keys_fops); 960 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev, 961 &long_term_keys_fops); 962 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev, 963 &conn_min_interval_fops); 964 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev, 965 &conn_max_interval_fops); 966 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev, 967 &conn_latency_fops); 968 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev, 969 &supervision_timeout_fops); 970 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev, 971 &adv_channel_map_fops); 972 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev, 973 &adv_min_interval_fops); 974 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev, 975 &adv_max_interval_fops); 976 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs, 977 &hdev->discov_interleaved_timeout); 978 979 debugfs_create_file("quirk_strict_duplicate_filter", 0644, 980 hdev->debugfs, hdev, 981 &quirk_strict_duplicate_filter_fops); 982 debugfs_create_file("quirk_simultaneous_discovery", 0644, 983 hdev->debugfs, hdev, 984 &quirk_simultaneous_discovery_fops); 985 } 986 987 void hci_debugfs_create_conn(struct hci_conn *conn) 988 { 989 struct hci_dev *hdev = conn->hdev; 990 char name[6]; 991 992 if (IS_ERR_OR_NULL(hdev->debugfs)) 993 return; 994 995 snprintf(name, sizeof(name), "%u", conn->handle); 996 conn->debugfs = debugfs_create_dir(name, hdev->debugfs); 997 } 998