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