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 resolv_list_show(struct seq_file *f, void *ptr)
 698 {
 699         struct hci_dev *hdev = f->private;
 700         struct bdaddr_list *b;
 701
 702         hci_dev_lock(hdev);
 703         list_for_each_entry(b, &hdev->le_resolv_list, list)
 704                 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
 705         hci_dev_unlock(hdev);
 706
 707         return 0;
 708 }
 709
 710 DEFINE_SHOW_ATTRIBUTE(resolv_list);
 711
 712 static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
 713 {
 714         struct hci_dev *hdev = f->private;
 715         struct smp_irk *irk;
 716
 717         rcu_read_lock();
 718         list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
 719                 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
 720                            &irk->bdaddr, irk->addr_type,
 721                            16, irk->val, &irk->rpa);
 722         }
 723         rcu_read_unlock();
 724
 725         return 0;
 726 }
 727
 728 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
 729
 730 static int long_term_keys_show(struct seq_file *f, void *ptr)
 731 {
 732         struct hci_dev *hdev = f->private;
 733         struct smp_ltk *ltk;
 734
 735         rcu_read_lock();
 736         list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
 737                 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
 738                            &ltk->bdaddr, ltk->bdaddr_type, ltk->authenticated,
 739                            ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
 740                            __le64_to_cpu(ltk->rand), 16, ltk->val);
 741         rcu_read_unlock();
 742
 743         return 0;
 744 }
 745
 746 DEFINE_SHOW_ATTRIBUTE(long_term_keys);
 747
 748 static int conn_min_interval_set(void *data, u64 val)
 749 {
 750         struct hci_dev *hdev = data;
 751
 752         if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
 753                 return -EINVAL;
 754
 755         hci_dev_lock(hdev);
 756         hdev->le_conn_min_interval = val;
 757         hci_dev_unlock(hdev);
 758
 759         return 0;
 760 }
 761
 762 static int conn_min_interval_get(void *data, u64 *val)
 763 {
 764         struct hci_dev *hdev = data;
 765
 766         hci_dev_lock(hdev);
 767         *val = hdev->le_conn_min_interval;
 768         hci_dev_unlock(hdev);
 769
 770         return 0;
 771 }
 772
 773 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
 774                         conn_min_interval_set, "%llu\n");
 775
 776 static int conn_max_interval_set(void *data, u64 val)
 777 {
 778         struct hci_dev *hdev = data;
 779
 780         if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
 781                 return -EINVAL;
 782
 783         hci_dev_lock(hdev);
 784         hdev->le_conn_max_interval = val;
 785         hci_dev_unlock(hdev);
 786
 787         return 0;
 788 }
 789
 790 static int conn_max_interval_get(void *data, u64 *val)
 791 {
 792         struct hci_dev *hdev = data;
 793
 794         hci_dev_lock(hdev);
 795         *val = hdev->le_conn_max_interval;
 796         hci_dev_unlock(hdev);
 797
 798         return 0;
 799 }
 800
 801 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
 802                         conn_max_interval_set, "%llu\n");
 803
 804 static int conn_latency_set(void *data, u64 val)
 805 {
 806         struct hci_dev *hdev = data;
 807
 808         if (val > 0x01f3)
 809                 return -EINVAL;
 810
 811         hci_dev_lock(hdev);
 812         hdev->le_conn_latency = val;
 813         hci_dev_unlock(hdev);
 814
 815         return 0;
 816 }
 817
 818 static int conn_latency_get(void *data, u64 *val)
 819 {
 820         struct hci_dev *hdev = data;
 821
 822         hci_dev_lock(hdev);
 823         *val = hdev->le_conn_latency;
 824         hci_dev_unlock(hdev);
 825
 826         return 0;
 827 }
 828
 829 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
 830                         conn_latency_set, "%llu\n");
 831
 832 static int supervision_timeout_set(void *data, u64 val)
 833 {
 834         struct hci_dev *hdev = data;
 835
 836         if (val < 0x000a || val > 0x0c80)
 837                 return -EINVAL;
 838
 839         hci_dev_lock(hdev);
 840         hdev->le_supv_timeout = val;
 841         hci_dev_unlock(hdev);
 842
 843         return 0;
 844 }
 845
 846 static int supervision_timeout_get(void *data, u64 *val)
 847 {
 848         struct hci_dev *hdev = data;
 849
 850         hci_dev_lock(hdev);
 851         *val = hdev->le_supv_timeout;
 852         hci_dev_unlock(hdev);
 853
 854         return 0;
 855 }
 856
 857 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
 858                         supervision_timeout_set, "%llu\n");
 859
 860 static int adv_channel_map_set(void *data, u64 val)
 861 {
 862         struct hci_dev *hdev = data;
 863
 864         if (val < 0x01 || val > 0x07)
 865                 return -EINVAL;
 866
 867         hci_dev_lock(hdev);
 868         hdev->le_adv_channel_map = val;
 869         hci_dev_unlock(hdev);
 870
 871         return 0;
 872 }
 873
 874 static int adv_channel_map_get(void *data, u64 *val)
 875 {
 876         struct hci_dev *hdev = data;
 877
 878         hci_dev_lock(hdev);
 879         *val = hdev->le_adv_channel_map;
 880         hci_dev_unlock(hdev);
 881
 882         return 0;
 883 }
 884
 885 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
 886                         adv_channel_map_set, "%llu\n");
 887
 888 static int adv_min_interval_set(void *data, u64 val)
 889 {
 890         struct hci_dev *hdev = data;
 891
 892         if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
 893                 return -EINVAL;
 894
 895         hci_dev_lock(hdev);
 896         hdev->le_adv_min_interval = val;
 897         hci_dev_unlock(hdev);
 898
 899         return 0;
 900 }
 901
 902 static int adv_min_interval_get(void *data, u64 *val)
 903 {
 904         struct hci_dev *hdev = data;
 905
 906         hci_dev_lock(hdev);
 907         *val = hdev->le_adv_min_interval;
 908         hci_dev_unlock(hdev);
 909
 910         return 0;
 911 }
 912
 913 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
 914                         adv_min_interval_set, "%llu\n");
 915
 916 static int adv_max_interval_set(void *data, u64 val)
 917 {
 918         struct hci_dev *hdev = data;
 919
 920         if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
 921                 return -EINVAL;
 922
 923         hci_dev_lock(hdev);
 924         hdev->le_adv_max_interval = val;
 925         hci_dev_unlock(hdev);
 926
 927         return 0;
 928 }
 929
 930 static int adv_max_interval_get(void *data, u64 *val)
 931 {
 932         struct hci_dev *hdev = data;
 933
 934         hci_dev_lock(hdev);
 935         *val = hdev->le_adv_max_interval;
 936         hci_dev_unlock(hdev);
 937
 938         return 0;
 939 }
 940
 941 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
 942                         adv_max_interval_set, "%llu\n");
 943
 944 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
 945                        HCI_QUIRK_STRICT_DUPLICATE_FILTER);
 946 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
 947                        HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
 948
 949 void hci_debugfs_create_le(struct hci_dev *hdev)
 950 {
 951         debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
 952                             &identity_fops);
 953         debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
 954                             &rpa_timeout_fops);
 955         debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
 956                             &random_address_fops);
 957         debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
 958                             &static_address_fops);
 959
 960         /* For controllers with a public address, provide a debug
 961          * option to force the usage of the configured static
 962          * address. By default the public address is used.
 963          */
 964         if (bacmp(&hdev->bdaddr, BDADDR_ANY))
 965                 debugfs_create_file("force_static_address", 0644,
 966                                     hdev->debugfs, hdev,
 967                                     &force_static_address_fops);
 968
 969         debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
 970                           &hdev->le_white_list_size);
 971         debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
 972                             &white_list_fops);
 973         debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
 974                           &hdev->le_resolv_list_size);
 975         debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
 976                             &resolv_list_fops);
 977         debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
 978                             hdev, &identity_resolving_keys_fops);
 979         debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
 980                             &long_term_keys_fops);
 981         debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
 982                             &conn_min_interval_fops);
 983         debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
 984                             &conn_max_interval_fops);
 985         debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
 986                             &conn_latency_fops);
 987         debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
 988                             &supervision_timeout_fops);
 989         debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
 990                             &adv_channel_map_fops);
 991         debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
 992                             &adv_min_interval_fops);
 993         debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
 994                             &adv_max_interval_fops);
 995         debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
 996                            &hdev->discov_interleaved_timeout);
 997
 998         debugfs_create_file("quirk_strict_duplicate_filter", 0644,
 999                             hdev->debugfs, hdev,
1000                             &quirk_strict_duplicate_filter_fops);
1001         debugfs_create_file("quirk_simultaneous_discovery", 0644,
1002                             hdev->debugfs, hdev,
1003                             &quirk_simultaneous_discovery_fops);
1004 }
1005
1006 void hci_debugfs_create_conn(struct hci_conn *conn)
1007 {
1008         struct hci_dev *hdev = conn->hdev;
1009         char name[6];
1010
1011         if (IS_ERR_OR_NULL(hdev->debugfs))
1012                 return;
1013
1014         snprintf(name, sizeof(name), "%u", conn->handle);
1015         conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1016 }