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