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