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