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 min_encrypt_key_size_set(void *data, u64 val) 437 { 438 struct hci_dev *hdev = data; 439 440 if (val < 1 || val > 16) 441 return -EINVAL; 442 443 hci_dev_lock(hdev); 444 hdev->min_enc_key_size = val; 445 hci_dev_unlock(hdev); 446 447 return 0; 448 } 449 450 static int min_encrypt_key_size_get(void *data, u64 *val) 451 { 452 struct hci_dev *hdev = data; 453 454 hci_dev_lock(hdev); 455 *val = hdev->min_enc_key_size; 456 hci_dev_unlock(hdev); 457 458 return 0; 459 } 460 461 DEFINE_SIMPLE_ATTRIBUTE(min_encrypt_key_size_fops, 462 min_encrypt_key_size_get, 463 min_encrypt_key_size_set, "%llu\n"); 464 465 static int auto_accept_delay_get(void *data, u64 *val) 466 { 467 struct hci_dev *hdev = data; 468 469 hci_dev_lock(hdev); 470 *val = hdev->auto_accept_delay; 471 hci_dev_unlock(hdev); 472 473 return 0; 474 } 475 476 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 477 auto_accept_delay_set, "%llu\n"); 478 479 static int idle_timeout_set(void *data, u64 val) 480 { 481 struct hci_dev *hdev = data; 482 483 if (val != 0 && (val < 500 || val > 3600000)) 484 return -EINVAL; 485 486 hci_dev_lock(hdev); 487 hdev->idle_timeout = val; 488 hci_dev_unlock(hdev); 489 490 return 0; 491 } 492 493 static int idle_timeout_get(void *data, u64 *val) 494 { 495 struct hci_dev *hdev = data; 496 497 hci_dev_lock(hdev); 498 *val = hdev->idle_timeout; 499 hci_dev_unlock(hdev); 500 501 return 0; 502 } 503 504 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 505 idle_timeout_set, "%llu\n"); 506 507 static int sniff_min_interval_set(void *data, u64 val) 508 { 509 struct hci_dev *hdev = data; 510 511 if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 512 return -EINVAL; 513 514 hci_dev_lock(hdev); 515 hdev->sniff_min_interval = val; 516 hci_dev_unlock(hdev); 517 518 return 0; 519 } 520 521 static int sniff_min_interval_get(void *data, u64 *val) 522 { 523 struct hci_dev *hdev = data; 524 525 hci_dev_lock(hdev); 526 *val = hdev->sniff_min_interval; 527 hci_dev_unlock(hdev); 528 529 return 0; 530 } 531 532 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 533 sniff_min_interval_set, "%llu\n"); 534 535 static int sniff_max_interval_set(void *data, u64 val) 536 { 537 struct hci_dev *hdev = data; 538 539 if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 540 return -EINVAL; 541 542 hci_dev_lock(hdev); 543 hdev->sniff_max_interval = val; 544 hci_dev_unlock(hdev); 545 546 return 0; 547 } 548 549 static int sniff_max_interval_get(void *data, u64 *val) 550 { 551 struct hci_dev *hdev = data; 552 553 hci_dev_lock(hdev); 554 *val = hdev->sniff_max_interval; 555 hci_dev_unlock(hdev); 556 557 return 0; 558 } 559 560 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 561 sniff_max_interval_set, "%llu\n"); 562 563 void hci_debugfs_create_bredr(struct hci_dev *hdev) 564 { 565 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev, 566 &inquiry_cache_fops); 567 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev, 568 &link_keys_fops); 569 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev, 570 &dev_class_fops); 571 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev, 572 &voice_setting_fops); 573 574 if (lmp_ssp_capable(hdev)) { 575 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs, 576 hdev, &ssp_debug_mode_fops); 577 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs, 578 hdev, &min_encrypt_key_size_fops); 579 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 580 hdev, &auto_accept_delay_fops); 581 } 582 583 if (lmp_sniff_capable(hdev)) { 584 debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 585 hdev, &idle_timeout_fops); 586 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 587 hdev, &sniff_min_interval_fops); 588 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 589 hdev, &sniff_max_interval_fops); 590 } 591 } 592 593 static int identity_show(struct seq_file *f, void *p) 594 { 595 struct hci_dev *hdev = f->private; 596 bdaddr_t addr; 597 u8 addr_type; 598 599 hci_dev_lock(hdev); 600 601 hci_copy_identity_address(hdev, &addr, &addr_type); 602 603 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type, 604 16, hdev->irk, &hdev->rpa); 605 606 hci_dev_unlock(hdev); 607 608 return 0; 609 } 610 611 DEFINE_SHOW_ATTRIBUTE(identity); 612 613 static int rpa_timeout_set(void *data, u64 val) 614 { 615 struct hci_dev *hdev = data; 616 617 /* Require the RPA timeout to be at least 30 seconds and at most 618 * 24 hours. 619 */ 620 if (val < 30 || val > (60 * 60 * 24)) 621 return -EINVAL; 622 623 hci_dev_lock(hdev); 624 hdev->rpa_timeout = val; 625 hci_dev_unlock(hdev); 626 627 return 0; 628 } 629 630 static int rpa_timeout_get(void *data, u64 *val) 631 { 632 struct hci_dev *hdev = data; 633 634 hci_dev_lock(hdev); 635 *val = hdev->rpa_timeout; 636 hci_dev_unlock(hdev); 637 638 return 0; 639 } 640 641 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get, 642 rpa_timeout_set, "%llu\n"); 643 644 static int random_address_show(struct seq_file *f, void *p) 645 { 646 struct hci_dev *hdev = f->private; 647 648 hci_dev_lock(hdev); 649 seq_printf(f, "%pMR\n", &hdev->random_addr); 650 hci_dev_unlock(hdev); 651 652 return 0; 653 } 654 655 DEFINE_SHOW_ATTRIBUTE(random_address); 656 657 static int static_address_show(struct seq_file *f, void *p) 658 { 659 struct hci_dev *hdev = f->private; 660 661 hci_dev_lock(hdev); 662 seq_printf(f, "%pMR\n", &hdev->static_addr); 663 hci_dev_unlock(hdev); 664 665 return 0; 666 } 667 668 DEFINE_SHOW_ATTRIBUTE(static_address); 669 670 static ssize_t force_static_address_read(struct file *file, 671 char __user *user_buf, 672 size_t count, loff_t *ppos) 673 { 674 struct hci_dev *hdev = file->private_data; 675 char buf[3]; 676 677 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N'; 678 buf[1] = '\n'; 679 buf[2] = '\0'; 680 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 681 } 682 683 static ssize_t force_static_address_write(struct file *file, 684 const char __user *user_buf, 685 size_t count, loff_t *ppos) 686 { 687 struct hci_dev *hdev = file->private_data; 688 bool enable; 689 int err; 690 691 if (test_bit(HCI_UP, &hdev->flags)) 692 return -EBUSY; 693 694 err = kstrtobool_from_user(user_buf, count, &enable); 695 if (err) 696 return err; 697 698 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR)) 699 return -EALREADY; 700 701 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR); 702 703 return count; 704 } 705 706 static const struct file_operations force_static_address_fops = { 707 .open = simple_open, 708 .read = force_static_address_read, 709 .write = force_static_address_write, 710 .llseek = default_llseek, 711 }; 712 713 static int white_list_show(struct seq_file *f, void *ptr) 714 { 715 struct hci_dev *hdev = f->private; 716 struct bdaddr_list *b; 717 718 hci_dev_lock(hdev); 719 list_for_each_entry(b, &hdev->le_white_list, list) 720 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 721 hci_dev_unlock(hdev); 722 723 return 0; 724 } 725 726 DEFINE_SHOW_ATTRIBUTE(white_list); 727 728 static int resolv_list_show(struct seq_file *f, void *ptr) 729 { 730 struct hci_dev *hdev = f->private; 731 struct bdaddr_list *b; 732 733 hci_dev_lock(hdev); 734 list_for_each_entry(b, &hdev->le_resolv_list, list) 735 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 736 hci_dev_unlock(hdev); 737 738 return 0; 739 } 740 741 DEFINE_SHOW_ATTRIBUTE(resolv_list); 742 743 static int identity_resolving_keys_show(struct seq_file *f, void *ptr) 744 { 745 struct hci_dev *hdev = f->private; 746 struct smp_irk *irk; 747 748 rcu_read_lock(); 749 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 750 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", 751 &irk->bdaddr, irk->addr_type, 752 16, irk->val, &irk->rpa); 753 } 754 rcu_read_unlock(); 755 756 return 0; 757 } 758 759 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys); 760 761 static int long_term_keys_show(struct seq_file *f, void *ptr) 762 { 763 struct hci_dev *hdev = f->private; 764 struct smp_ltk *ltk; 765 766 rcu_read_lock(); 767 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list) 768 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n", 769 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 770 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 771 __le64_to_cpu(ltk->rand), 16, ltk->val); 772 rcu_read_unlock(); 773 774 return 0; 775 } 776 777 DEFINE_SHOW_ATTRIBUTE(long_term_keys); 778 779 static int conn_min_interval_set(void *data, u64 val) 780 { 781 struct hci_dev *hdev = data; 782 783 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) 784 return -EINVAL; 785 786 hci_dev_lock(hdev); 787 hdev->le_conn_min_interval = val; 788 hci_dev_unlock(hdev); 789 790 return 0; 791 } 792 793 static int conn_min_interval_get(void *data, u64 *val) 794 { 795 struct hci_dev *hdev = data; 796 797 hci_dev_lock(hdev); 798 *val = hdev->le_conn_min_interval; 799 hci_dev_unlock(hdev); 800 801 return 0; 802 } 803 804 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get, 805 conn_min_interval_set, "%llu\n"); 806 807 static int conn_max_interval_set(void *data, u64 val) 808 { 809 struct hci_dev *hdev = data; 810 811 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) 812 return -EINVAL; 813 814 hci_dev_lock(hdev); 815 hdev->le_conn_max_interval = val; 816 hci_dev_unlock(hdev); 817 818 return 0; 819 } 820 821 static int conn_max_interval_get(void *data, u64 *val) 822 { 823 struct hci_dev *hdev = data; 824 825 hci_dev_lock(hdev); 826 *val = hdev->le_conn_max_interval; 827 hci_dev_unlock(hdev); 828 829 return 0; 830 } 831 832 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get, 833 conn_max_interval_set, "%llu\n"); 834 835 static int conn_latency_set(void *data, u64 val) 836 { 837 struct hci_dev *hdev = data; 838 839 if (val > 0x01f3) 840 return -EINVAL; 841 842 hci_dev_lock(hdev); 843 hdev->le_conn_latency = val; 844 hci_dev_unlock(hdev); 845 846 return 0; 847 } 848 849 static int conn_latency_get(void *data, u64 *val) 850 { 851 struct hci_dev *hdev = data; 852 853 hci_dev_lock(hdev); 854 *val = hdev->le_conn_latency; 855 hci_dev_unlock(hdev); 856 857 return 0; 858 } 859 860 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get, 861 conn_latency_set, "%llu\n"); 862 863 static int supervision_timeout_set(void *data, u64 val) 864 { 865 struct hci_dev *hdev = data; 866 867 if (val < 0x000a || val > 0x0c80) 868 return -EINVAL; 869 870 hci_dev_lock(hdev); 871 hdev->le_supv_timeout = val; 872 hci_dev_unlock(hdev); 873 874 return 0; 875 } 876 877 static int supervision_timeout_get(void *data, u64 *val) 878 { 879 struct hci_dev *hdev = data; 880 881 hci_dev_lock(hdev); 882 *val = hdev->le_supv_timeout; 883 hci_dev_unlock(hdev); 884 885 return 0; 886 } 887 888 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get, 889 supervision_timeout_set, "%llu\n"); 890 891 static int adv_channel_map_set(void *data, u64 val) 892 { 893 struct hci_dev *hdev = data; 894 895 if (val < 0x01 || val > 0x07) 896 return -EINVAL; 897 898 hci_dev_lock(hdev); 899 hdev->le_adv_channel_map = val; 900 hci_dev_unlock(hdev); 901 902 return 0; 903 } 904 905 static int adv_channel_map_get(void *data, u64 *val) 906 { 907 struct hci_dev *hdev = data; 908 909 hci_dev_lock(hdev); 910 *val = hdev->le_adv_channel_map; 911 hci_dev_unlock(hdev); 912 913 return 0; 914 } 915 916 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get, 917 adv_channel_map_set, "%llu\n"); 918 919 static int adv_min_interval_set(void *data, u64 val) 920 { 921 struct hci_dev *hdev = data; 922 923 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval) 924 return -EINVAL; 925 926 hci_dev_lock(hdev); 927 hdev->le_adv_min_interval = val; 928 hci_dev_unlock(hdev); 929 930 return 0; 931 } 932 933 static int adv_min_interval_get(void *data, u64 *val) 934 { 935 struct hci_dev *hdev = data; 936 937 hci_dev_lock(hdev); 938 *val = hdev->le_adv_min_interval; 939 hci_dev_unlock(hdev); 940 941 return 0; 942 } 943 944 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get, 945 adv_min_interval_set, "%llu\n"); 946 947 static int adv_max_interval_set(void *data, u64 val) 948 { 949 struct hci_dev *hdev = data; 950 951 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval) 952 return -EINVAL; 953 954 hci_dev_lock(hdev); 955 hdev->le_adv_max_interval = val; 956 hci_dev_unlock(hdev); 957 958 return 0; 959 } 960 961 static int adv_max_interval_get(void *data, u64 *val) 962 { 963 struct hci_dev *hdev = data; 964 965 hci_dev_lock(hdev); 966 *val = hdev->le_adv_max_interval; 967 hci_dev_unlock(hdev); 968 969 return 0; 970 } 971 972 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get, 973 adv_max_interval_set, "%llu\n"); 974 975 static int auth_payload_timeout_set(void *data, u64 val) 976 { 977 struct hci_dev *hdev = data; 978 979 if (val < 0x0001 || val > 0xffff) 980 return -EINVAL; 981 982 hci_dev_lock(hdev); 983 hdev->auth_payload_timeout = val; 984 hci_dev_unlock(hdev); 985 986 return 0; 987 } 988 989 static int auth_payload_timeout_get(void *data, u64 *val) 990 { 991 struct hci_dev *hdev = data; 992 993 hci_dev_lock(hdev); 994 *val = hdev->auth_payload_timeout; 995 hci_dev_unlock(hdev); 996 997 return 0; 998 } 999 1000 DEFINE_SIMPLE_ATTRIBUTE(auth_payload_timeout_fops, 1001 auth_payload_timeout_get, 1002 auth_payload_timeout_set, "%llu\n"); 1003 1004 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter, 1005 HCI_QUIRK_STRICT_DUPLICATE_FILTER); 1006 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery, 1007 HCI_QUIRK_SIMULTANEOUS_DISCOVERY); 1008 1009 void hci_debugfs_create_le(struct hci_dev *hdev) 1010 { 1011 debugfs_create_file("identity", 0400, hdev->debugfs, hdev, 1012 &identity_fops); 1013 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev, 1014 &rpa_timeout_fops); 1015 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev, 1016 &random_address_fops); 1017 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev, 1018 &static_address_fops); 1019 1020 /* For controllers with a public address, provide a debug 1021 * option to force the usage of the configured static 1022 * address. By default the public address is used. 1023 */ 1024 if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 1025 debugfs_create_file("force_static_address", 0644, 1026 hdev->debugfs, hdev, 1027 &force_static_address_fops); 1028 1029 debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1030 &hdev->le_white_list_size); 1031 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 1032 &white_list_fops); 1033 debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs, 1034 &hdev->le_resolv_list_size); 1035 debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev, 1036 &resolv_list_fops); 1037 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs, 1038 hdev, &identity_resolving_keys_fops); 1039 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev, 1040 &long_term_keys_fops); 1041 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev, 1042 &conn_min_interval_fops); 1043 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev, 1044 &conn_max_interval_fops); 1045 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev, 1046 &conn_latency_fops); 1047 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev, 1048 &supervision_timeout_fops); 1049 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev, 1050 &adv_channel_map_fops); 1051 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev, 1052 &adv_min_interval_fops); 1053 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev, 1054 &adv_max_interval_fops); 1055 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs, 1056 &hdev->discov_interleaved_timeout); 1057 debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev, 1058 &auth_payload_timeout_fops); 1059 1060 debugfs_create_file("quirk_strict_duplicate_filter", 0644, 1061 hdev->debugfs, hdev, 1062 &quirk_strict_duplicate_filter_fops); 1063 debugfs_create_file("quirk_simultaneous_discovery", 0644, 1064 hdev->debugfs, hdev, 1065 &quirk_simultaneous_discovery_fops); 1066 } 1067 1068 void hci_debugfs_create_conn(struct hci_conn *conn) 1069 { 1070 struct hci_dev *hdev = conn->hdev; 1071 char name[6]; 1072 1073 if (IS_ERR_OR_NULL(hdev->debugfs)) 1074 return; 1075 1076 snprintf(name, sizeof(name), "%u", conn->handle); 1077 conn->debugfs = debugfs_create_dir(name, hdev->debugfs); 1078 } 1079