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