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