1 /* 2 BlueZ - Bluetooth protocol stack for Linux 3 4 Copyright (C) 2014 Intel Corporation 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License version 2 as 8 published by the Free Software Foundation; 9 10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 21 SOFTWARE IS DISCLAIMED. 22 */ 23 24 #include <linux/debugfs.h> 25 26 #include <net/bluetooth/bluetooth.h> 27 #include <net/bluetooth/hci_core.h> 28 29 #include "hci_debugfs.h" 30 31 #define DEFINE_QUIRK_ATTRIBUTE(__name, __quirk) \ 32 static ssize_t __name ## _read(struct file *file, \ 33 char __user *user_buf, \ 34 size_t count, loff_t *ppos) \ 35 { \ 36 struct hci_dev *hdev = file->private_data; \ 37 char buf[3]; \ 38 \ 39 buf[0] = test_bit(__quirk, &hdev->quirks) ? 'Y' : 'N'; \ 40 buf[1] = '\n'; \ 41 buf[2] = '\0'; \ 42 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); \ 43 } \ 44 \ 45 static ssize_t __name ## _write(struct file *file, \ 46 const char __user *user_buf, \ 47 size_t count, loff_t *ppos) \ 48 { \ 49 struct hci_dev *hdev = file->private_data; \ 50 char buf[32]; \ 51 size_t buf_size = min(count, (sizeof(buf) - 1)); \ 52 bool enable; \ 53 \ 54 if (test_bit(HCI_UP, &hdev->flags)) \ 55 return -EBUSY; \ 56 \ 57 if (copy_from_user(buf, user_buf, buf_size)) \ 58 return -EFAULT; \ 59 \ 60 buf[buf_size] = '\0'; \ 61 if (strtobool(buf, &enable)) \ 62 return -EINVAL; \ 63 \ 64 if (enable == test_bit(__quirk, &hdev->quirks)) \ 65 return -EALREADY; \ 66 \ 67 change_bit(__quirk, &hdev->quirks); \ 68 \ 69 return count; \ 70 } \ 71 \ 72 static const struct file_operations __name ## _fops = { \ 73 .open = simple_open, \ 74 .read = __name ## _read, \ 75 .write = __name ## _write, \ 76 .llseek = default_llseek, \ 77 } \ 78 79 #define DEFINE_INFO_ATTRIBUTE(__name, __field) \ 80 static int __name ## _show(struct seq_file *f, void *ptr) \ 81 { \ 82 struct hci_dev *hdev = f->private; \ 83 \ 84 hci_dev_lock(hdev); \ 85 seq_printf(f, "%s\n", hdev->__field ? : ""); \ 86 hci_dev_unlock(hdev); \ 87 \ 88 return 0; \ 89 } \ 90 \ 91 DEFINE_SHOW_ATTRIBUTE(__name) 92 93 #define DEFINE_SHOW_ATTRIBUTE(__name) \ 94 static int __name ## _open(struct inode *inode, struct file *file) \ 95 { \ 96 return single_open(file, __name ## _show, inode->i_private); \ 97 } \ 98 \ 99 static const struct file_operations __name ## _fops = { \ 100 .open = __name ## _open, \ 101 .read = seq_read, \ 102 .llseek = seq_lseek, \ 103 .release = single_release, \ 104 } \ 105 106 static int features_show(struct seq_file *f, void *ptr) 107 { 108 struct hci_dev *hdev = f->private; 109 u8 p; 110 111 hci_dev_lock(hdev); 112 for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) 113 seq_printf(f, "%2u: %8ph\n", p, hdev->features[p]); 114 if (lmp_le_capable(hdev)) 115 seq_printf(f, "LE: %8ph\n", hdev->le_features); 116 hci_dev_unlock(hdev); 117 118 return 0; 119 } 120 121 DEFINE_SHOW_ATTRIBUTE(features); 122 123 static int device_id_show(struct seq_file *f, void *ptr) 124 { 125 struct hci_dev *hdev = f->private; 126 127 hci_dev_lock(hdev); 128 seq_printf(f, "%4.4x:%4.4x:%4.4x:%4.4x\n", hdev->devid_source, 129 hdev->devid_vendor, hdev->devid_product, hdev->devid_version); 130 hci_dev_unlock(hdev); 131 132 return 0; 133 } 134 135 DEFINE_SHOW_ATTRIBUTE(device_id); 136 137 static int device_list_show(struct seq_file *f, void *ptr) 138 { 139 struct hci_dev *hdev = f->private; 140 struct hci_conn_params *p; 141 struct bdaddr_list *b; 142 143 hci_dev_lock(hdev); 144 list_for_each_entry(b, &hdev->whitelist, list) 145 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 146 list_for_each_entry(p, &hdev->le_conn_params, list) { 147 seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type, 148 p->auto_connect); 149 } 150 hci_dev_unlock(hdev); 151 152 return 0; 153 } 154 155 DEFINE_SHOW_ATTRIBUTE(device_list); 156 157 static int blacklist_show(struct seq_file *f, void *p) 158 { 159 struct hci_dev *hdev = f->private; 160 struct bdaddr_list *b; 161 162 hci_dev_lock(hdev); 163 list_for_each_entry(b, &hdev->blacklist, list) 164 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 165 hci_dev_unlock(hdev); 166 167 return 0; 168 } 169 170 DEFINE_SHOW_ATTRIBUTE(blacklist); 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_SIMPLE_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_SIMPLE_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("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 329 debugfs_create_file("remote_oob", 0400, hdev->debugfs, hdev, 330 &remote_oob_fops); 331 332 debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 333 &conn_info_min_age_fops); 334 debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 335 &conn_info_max_age_fops); 336 337 if (lmp_ssp_capable(hdev) || lmp_le_capable(hdev)) 338 debugfs_create_file("use_debug_keys", 0444, hdev->debugfs, 339 hdev, &use_debug_keys_fops); 340 341 if (lmp_sc_capable(hdev) || lmp_le_capable(hdev)) 342 debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 343 hdev, &sc_only_mode_fops); 344 345 if (hdev->hw_info) 346 debugfs_create_file("hardware_info", 0444, hdev->debugfs, 347 hdev, &hardware_info_fops); 348 349 if (hdev->fw_info) 350 debugfs_create_file("firmware_info", 0444, hdev->debugfs, 351 hdev, &firmware_info_fops); 352 } 353 354 static int inquiry_cache_show(struct seq_file *f, void *p) 355 { 356 struct hci_dev *hdev = f->private; 357 struct discovery_state *cache = &hdev->discovery; 358 struct inquiry_entry *e; 359 360 hci_dev_lock(hdev); 361 362 list_for_each_entry(e, &cache->all, all) { 363 struct inquiry_data *data = &e->data; 364 seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 365 &data->bdaddr, 366 data->pscan_rep_mode, data->pscan_period_mode, 367 data->pscan_mode, data->dev_class[2], 368 data->dev_class[1], data->dev_class[0], 369 __le16_to_cpu(data->clock_offset), 370 data->rssi, data->ssp_mode, e->timestamp); 371 } 372 373 hci_dev_unlock(hdev); 374 375 return 0; 376 } 377 378 DEFINE_SHOW_ATTRIBUTE(inquiry_cache); 379 380 static int link_keys_show(struct seq_file *f, void *ptr) 381 { 382 struct hci_dev *hdev = f->private; 383 struct link_key *key; 384 385 rcu_read_lock(); 386 list_for_each_entry_rcu(key, &hdev->link_keys, list) 387 seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type, 388 HCI_LINK_KEY_SIZE, key->val, key->pin_len); 389 rcu_read_unlock(); 390 391 return 0; 392 } 393 394 DEFINE_SHOW_ATTRIBUTE(link_keys); 395 396 static int dev_class_show(struct seq_file *f, void *ptr) 397 { 398 struct hci_dev *hdev = f->private; 399 400 hci_dev_lock(hdev); 401 seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2], 402 hdev->dev_class[1], hdev->dev_class[0]); 403 hci_dev_unlock(hdev); 404 405 return 0; 406 } 407 408 DEFINE_SHOW_ATTRIBUTE(dev_class); 409 410 static int voice_setting_get(void *data, u64 *val) 411 { 412 struct hci_dev *hdev = data; 413 414 hci_dev_lock(hdev); 415 *val = hdev->voice_setting; 416 hci_dev_unlock(hdev); 417 418 return 0; 419 } 420 421 DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 422 NULL, "0x%4.4llx\n"); 423 424 static ssize_t ssp_debug_mode_read(struct file *file, char __user *user_buf, 425 size_t count, loff_t *ppos) 426 { 427 struct hci_dev *hdev = file->private_data; 428 char buf[3]; 429 430 buf[0] = hdev->ssp_debug_mode ? 'Y': 'N'; 431 buf[1] = '\n'; 432 buf[2] = '\0'; 433 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 434 } 435 436 static const struct file_operations ssp_debug_mode_fops = { 437 .open = simple_open, 438 .read = ssp_debug_mode_read, 439 .llseek = default_llseek, 440 }; 441 442 static int auto_accept_delay_set(void *data, u64 val) 443 { 444 struct hci_dev *hdev = data; 445 446 hci_dev_lock(hdev); 447 hdev->auto_accept_delay = val; 448 hci_dev_unlock(hdev); 449 450 return 0; 451 } 452 453 static int auto_accept_delay_get(void *data, u64 *val) 454 { 455 struct hci_dev *hdev = data; 456 457 hci_dev_lock(hdev); 458 *val = hdev->auto_accept_delay; 459 hci_dev_unlock(hdev); 460 461 return 0; 462 } 463 464 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 465 auto_accept_delay_set, "%llu\n"); 466 467 static int idle_timeout_set(void *data, u64 val) 468 { 469 struct hci_dev *hdev = data; 470 471 if (val != 0 && (val < 500 || val > 3600000)) 472 return -EINVAL; 473 474 hci_dev_lock(hdev); 475 hdev->idle_timeout = val; 476 hci_dev_unlock(hdev); 477 478 return 0; 479 } 480 481 static int idle_timeout_get(void *data, u64 *val) 482 { 483 struct hci_dev *hdev = data; 484 485 hci_dev_lock(hdev); 486 *val = hdev->idle_timeout; 487 hci_dev_unlock(hdev); 488 489 return 0; 490 } 491 492 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 493 idle_timeout_set, "%llu\n"); 494 495 static int sniff_min_interval_set(void *data, u64 val) 496 { 497 struct hci_dev *hdev = data; 498 499 if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 500 return -EINVAL; 501 502 hci_dev_lock(hdev); 503 hdev->sniff_min_interval = val; 504 hci_dev_unlock(hdev); 505 506 return 0; 507 } 508 509 static int sniff_min_interval_get(void *data, u64 *val) 510 { 511 struct hci_dev *hdev = data; 512 513 hci_dev_lock(hdev); 514 *val = hdev->sniff_min_interval; 515 hci_dev_unlock(hdev); 516 517 return 0; 518 } 519 520 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 521 sniff_min_interval_set, "%llu\n"); 522 523 static int sniff_max_interval_set(void *data, u64 val) 524 { 525 struct hci_dev *hdev = data; 526 527 if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 528 return -EINVAL; 529 530 hci_dev_lock(hdev); 531 hdev->sniff_max_interval = val; 532 hci_dev_unlock(hdev); 533 534 return 0; 535 } 536 537 static int sniff_max_interval_get(void *data, u64 *val) 538 { 539 struct hci_dev *hdev = data; 540 541 hci_dev_lock(hdev); 542 *val = hdev->sniff_max_interval; 543 hci_dev_unlock(hdev); 544 545 return 0; 546 } 547 548 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 549 sniff_max_interval_set, "%llu\n"); 550 551 void hci_debugfs_create_bredr(struct hci_dev *hdev) 552 { 553 debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev, 554 &inquiry_cache_fops); 555 debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev, 556 &link_keys_fops); 557 debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev, 558 &dev_class_fops); 559 debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev, 560 &voice_setting_fops); 561 562 if (lmp_ssp_capable(hdev)) { 563 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs, 564 hdev, &ssp_debug_mode_fops); 565 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 566 hdev, &auto_accept_delay_fops); 567 } 568 569 if (lmp_sniff_capable(hdev)) { 570 debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 571 hdev, &idle_timeout_fops); 572 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 573 hdev, &sniff_min_interval_fops); 574 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 575 hdev, &sniff_max_interval_fops); 576 } 577 } 578 579 static int identity_show(struct seq_file *f, void *p) 580 { 581 struct hci_dev *hdev = f->private; 582 bdaddr_t addr; 583 u8 addr_type; 584 585 hci_dev_lock(hdev); 586 587 hci_copy_identity_address(hdev, &addr, &addr_type); 588 589 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type, 590 16, hdev->irk, &hdev->rpa); 591 592 hci_dev_unlock(hdev); 593 594 return 0; 595 } 596 597 DEFINE_SHOW_ATTRIBUTE(identity); 598 599 static int rpa_timeout_set(void *data, u64 val) 600 { 601 struct hci_dev *hdev = data; 602 603 /* Require the RPA timeout to be at least 30 seconds and at most 604 * 24 hours. 605 */ 606 if (val < 30 || val > (60 * 60 * 24)) 607 return -EINVAL; 608 609 hci_dev_lock(hdev); 610 hdev->rpa_timeout = val; 611 hci_dev_unlock(hdev); 612 613 return 0; 614 } 615 616 static int rpa_timeout_get(void *data, u64 *val) 617 { 618 struct hci_dev *hdev = data; 619 620 hci_dev_lock(hdev); 621 *val = hdev->rpa_timeout; 622 hci_dev_unlock(hdev); 623 624 return 0; 625 } 626 627 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get, 628 rpa_timeout_set, "%llu\n"); 629 630 static int random_address_show(struct seq_file *f, void *p) 631 { 632 struct hci_dev *hdev = f->private; 633 634 hci_dev_lock(hdev); 635 seq_printf(f, "%pMR\n", &hdev->random_addr); 636 hci_dev_unlock(hdev); 637 638 return 0; 639 } 640 641 DEFINE_SHOW_ATTRIBUTE(random_address); 642 643 static int static_address_show(struct seq_file *f, void *p) 644 { 645 struct hci_dev *hdev = f->private; 646 647 hci_dev_lock(hdev); 648 seq_printf(f, "%pMR\n", &hdev->static_addr); 649 hci_dev_unlock(hdev); 650 651 return 0; 652 } 653 654 DEFINE_SHOW_ATTRIBUTE(static_address); 655 656 static ssize_t force_static_address_read(struct file *file, 657 char __user *user_buf, 658 size_t count, loff_t *ppos) 659 { 660 struct hci_dev *hdev = file->private_data; 661 char buf[3]; 662 663 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N'; 664 buf[1] = '\n'; 665 buf[2] = '\0'; 666 return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 667 } 668 669 static ssize_t force_static_address_write(struct file *file, 670 const char __user *user_buf, 671 size_t count, loff_t *ppos) 672 { 673 struct hci_dev *hdev = file->private_data; 674 char buf[32]; 675 size_t buf_size = min(count, (sizeof(buf)-1)); 676 bool enable; 677 678 if (test_bit(HCI_UP, &hdev->flags)) 679 return -EBUSY; 680 681 if (copy_from_user(buf, user_buf, buf_size)) 682 return -EFAULT; 683 684 buf[buf_size] = '\0'; 685 if (strtobool(buf, &enable)) 686 return -EINVAL; 687 688 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR)) 689 return -EALREADY; 690 691 hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR); 692 693 return count; 694 } 695 696 static const struct file_operations force_static_address_fops = { 697 .open = simple_open, 698 .read = force_static_address_read, 699 .write = force_static_address_write, 700 .llseek = default_llseek, 701 }; 702 703 static int white_list_show(struct seq_file *f, void *ptr) 704 { 705 struct hci_dev *hdev = f->private; 706 struct bdaddr_list *b; 707 708 hci_dev_lock(hdev); 709 list_for_each_entry(b, &hdev->le_white_list, list) 710 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 711 hci_dev_unlock(hdev); 712 713 return 0; 714 } 715 716 DEFINE_SHOW_ATTRIBUTE(white_list); 717 718 static int identity_resolving_keys_show(struct seq_file *f, void *ptr) 719 { 720 struct hci_dev *hdev = f->private; 721 struct smp_irk *irk; 722 723 rcu_read_lock(); 724 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 725 seq_printf(f, "%pMR (type %u) %*phN %pMR\n", 726 &irk->bdaddr, irk->addr_type, 727 16, irk->val, &irk->rpa); 728 } 729 rcu_read_unlock(); 730 731 return 0; 732 } 733 734 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys); 735 736 static int long_term_keys_show(struct seq_file *f, void *ptr) 737 { 738 struct hci_dev *hdev = f->private; 739 struct smp_ltk *ltk; 740 741 rcu_read_lock(); 742 list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list) 743 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n", 744 <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 745 ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 746 __le64_to_cpu(ltk->rand), 16, ltk->val); 747 rcu_read_unlock(); 748 749 return 0; 750 } 751 752 DEFINE_SHOW_ATTRIBUTE(long_term_keys); 753 754 static int conn_min_interval_set(void *data, u64 val) 755 { 756 struct hci_dev *hdev = data; 757 758 if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) 759 return -EINVAL; 760 761 hci_dev_lock(hdev); 762 hdev->le_conn_min_interval = val; 763 hci_dev_unlock(hdev); 764 765 return 0; 766 } 767 768 static int conn_min_interval_get(void *data, u64 *val) 769 { 770 struct hci_dev *hdev = data; 771 772 hci_dev_lock(hdev); 773 *val = hdev->le_conn_min_interval; 774 hci_dev_unlock(hdev); 775 776 return 0; 777 } 778 779 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get, 780 conn_min_interval_set, "%llu\n"); 781 782 static int conn_max_interval_set(void *data, u64 val) 783 { 784 struct hci_dev *hdev = data; 785 786 if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) 787 return -EINVAL; 788 789 hci_dev_lock(hdev); 790 hdev->le_conn_max_interval = val; 791 hci_dev_unlock(hdev); 792 793 return 0; 794 } 795 796 static int conn_max_interval_get(void *data, u64 *val) 797 { 798 struct hci_dev *hdev = data; 799 800 hci_dev_lock(hdev); 801 *val = hdev->le_conn_max_interval; 802 hci_dev_unlock(hdev); 803 804 return 0; 805 } 806 807 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get, 808 conn_max_interval_set, "%llu\n"); 809 810 static int conn_latency_set(void *data, u64 val) 811 { 812 struct hci_dev *hdev = data; 813 814 if (val > 0x01f3) 815 return -EINVAL; 816 817 hci_dev_lock(hdev); 818 hdev->le_conn_latency = val; 819 hci_dev_unlock(hdev); 820 821 return 0; 822 } 823 824 static int conn_latency_get(void *data, u64 *val) 825 { 826 struct hci_dev *hdev = data; 827 828 hci_dev_lock(hdev); 829 *val = hdev->le_conn_latency; 830 hci_dev_unlock(hdev); 831 832 return 0; 833 } 834 835 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get, 836 conn_latency_set, "%llu\n"); 837 838 static int supervision_timeout_set(void *data, u64 val) 839 { 840 struct hci_dev *hdev = data; 841 842 if (val < 0x000a || val > 0x0c80) 843 return -EINVAL; 844 845 hci_dev_lock(hdev); 846 hdev->le_supv_timeout = val; 847 hci_dev_unlock(hdev); 848 849 return 0; 850 } 851 852 static int supervision_timeout_get(void *data, u64 *val) 853 { 854 struct hci_dev *hdev = data; 855 856 hci_dev_lock(hdev); 857 *val = hdev->le_supv_timeout; 858 hci_dev_unlock(hdev); 859 860 return 0; 861 } 862 863 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get, 864 supervision_timeout_set, "%llu\n"); 865 866 static int adv_channel_map_set(void *data, u64 val) 867 { 868 struct hci_dev *hdev = data; 869 870 if (val < 0x01 || val > 0x07) 871 return -EINVAL; 872 873 hci_dev_lock(hdev); 874 hdev->le_adv_channel_map = val; 875 hci_dev_unlock(hdev); 876 877 return 0; 878 } 879 880 static int adv_channel_map_get(void *data, u64 *val) 881 { 882 struct hci_dev *hdev = data; 883 884 hci_dev_lock(hdev); 885 *val = hdev->le_adv_channel_map; 886 hci_dev_unlock(hdev); 887 888 return 0; 889 } 890 891 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get, 892 adv_channel_map_set, "%llu\n"); 893 894 static int adv_min_interval_set(void *data, u64 val) 895 { 896 struct hci_dev *hdev = data; 897 898 if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval) 899 return -EINVAL; 900 901 hci_dev_lock(hdev); 902 hdev->le_adv_min_interval = val; 903 hci_dev_unlock(hdev); 904 905 return 0; 906 } 907 908 static int adv_min_interval_get(void *data, u64 *val) 909 { 910 struct hci_dev *hdev = data; 911 912 hci_dev_lock(hdev); 913 *val = hdev->le_adv_min_interval; 914 hci_dev_unlock(hdev); 915 916 return 0; 917 } 918 919 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get, 920 adv_min_interval_set, "%llu\n"); 921 922 static int adv_max_interval_set(void *data, u64 val) 923 { 924 struct hci_dev *hdev = data; 925 926 if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval) 927 return -EINVAL; 928 929 hci_dev_lock(hdev); 930 hdev->le_adv_max_interval = val; 931 hci_dev_unlock(hdev); 932 933 return 0; 934 } 935 936 static int adv_max_interval_get(void *data, u64 *val) 937 { 938 struct hci_dev *hdev = data; 939 940 hci_dev_lock(hdev); 941 *val = hdev->le_adv_max_interval; 942 hci_dev_unlock(hdev); 943 944 return 0; 945 } 946 947 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get, 948 adv_max_interval_set, "%llu\n"); 949 950 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter, 951 HCI_QUIRK_STRICT_DUPLICATE_FILTER); 952 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery, 953 HCI_QUIRK_SIMULTANEOUS_DISCOVERY); 954 955 void hci_debugfs_create_le(struct hci_dev *hdev) 956 { 957 debugfs_create_file("identity", 0400, hdev->debugfs, hdev, 958 &identity_fops); 959 debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev, 960 &rpa_timeout_fops); 961 debugfs_create_file("random_address", 0444, hdev->debugfs, hdev, 962 &random_address_fops); 963 debugfs_create_file("static_address", 0444, hdev->debugfs, hdev, 964 &static_address_fops); 965 966 /* For controllers with a public address, provide a debug 967 * option to force the usage of the configured static 968 * address. By default the public address is used. 969 */ 970 if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 971 debugfs_create_file("force_static_address", 0644, 972 hdev->debugfs, hdev, 973 &force_static_address_fops); 974 975 debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 976 &hdev->le_white_list_size); 977 debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 978 &white_list_fops); 979 debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs, 980 hdev, &identity_resolving_keys_fops); 981 debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev, 982 &long_term_keys_fops); 983 debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev, 984 &conn_min_interval_fops); 985 debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev, 986 &conn_max_interval_fops); 987 debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev, 988 &conn_latency_fops); 989 debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev, 990 &supervision_timeout_fops); 991 debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev, 992 &adv_channel_map_fops); 993 debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev, 994 &adv_min_interval_fops); 995 debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev, 996 &adv_max_interval_fops); 997 debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs, 998 &hdev->discov_interleaved_timeout); 999 1000 debugfs_create_file("quirk_strict_duplicate_filter", 0644, 1001 hdev->debugfs, hdev, 1002 &quirk_strict_duplicate_filter_fops); 1003 debugfs_create_file("quirk_simultaneous_discovery", 0644, 1004 hdev->debugfs, hdev, 1005 &quirk_simultaneous_discovery_fops); 1006 } 1007 1008 void hci_debugfs_create_conn(struct hci_conn *conn) 1009 { 1010 struct hci_dev *hdev = conn->hdev; 1011 char name[6]; 1012 1013 if (IS_ERR_OR_NULL(hdev->debugfs)) 1014 return; 1015 1016 snprintf(name, sizeof(name), "%u", conn->handle); 1017 conn->debugfs = debugfs_create_dir(name, hdev->debugfs); 1018 } 1019