net/bluetooth/hci_debugfs.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3
   4    Copyright (C) 2014 Intel Corporation
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License version 2 as
   8    published by the Free Software Foundation;
   9
  10    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  11    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  12    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  13    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  14    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  15    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18
  19    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  20    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  21    SOFTWARE IS DISCLAIMED.
  22 */
  23
  24 #include <linux/debugfs.h>
  25
  26 #include <net/bluetooth/bluetooth.h>
  27 #include <net/bluetooth/hci_core.h>
  28
  29 #include "smp.h"
  30 #include "hci_request.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 (test_bit(HCI_UP, &hdev->flags))
 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                            &ltk->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 (strtobool(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 }