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