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