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