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