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