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