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 min_encrypt_key_size_set(void *data, u64 val)
 437 {
 438         struct hci_dev *hdev = data;
 439
 440         if (val < 1 || val > 16)
 441                 return -EINVAL;
 442
 443         hci_dev_lock(hdev);
 444         hdev->min_enc_key_size = val;
 445         hci_dev_unlock(hdev);
 446
 447         return 0;
 448 }
 449
 450 static int min_encrypt_key_size_get(void *data, u64 *val)
 451 {
 452         struct hci_dev *hdev = data;
 453
 454         hci_dev_lock(hdev);
 455         *val = hdev->min_enc_key_size;
 456         hci_dev_unlock(hdev);
 457
 458         return 0;
 459 }
 460
 461 DEFINE_SIMPLE_ATTRIBUTE(min_encrypt_key_size_fops,
 462                         min_encrypt_key_size_get,
 463                         min_encrypt_key_size_set, "%llu\n");
 464
 465 static int auto_accept_delay_get(void *data, u64 *val)
 466 {
 467         struct hci_dev *hdev = data;
 468
 469         hci_dev_lock(hdev);
 470         *val = hdev->auto_accept_delay;
 471         hci_dev_unlock(hdev);
 472
 473         return 0;
 474 }
 475
 476 DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
 477                         auto_accept_delay_set, "%llu\n");
 478
 479 static int idle_timeout_set(void *data, u64 val)
 480 {
 481         struct hci_dev *hdev = data;
 482
 483         if (val != 0 && (val < 500 || val > 3600000))
 484                 return -EINVAL;
 485
 486         hci_dev_lock(hdev);
 487         hdev->idle_timeout = val;
 488         hci_dev_unlock(hdev);
 489
 490         return 0;
 491 }
 492
 493 static int idle_timeout_get(void *data, u64 *val)
 494 {
 495         struct hci_dev *hdev = data;
 496
 497         hci_dev_lock(hdev);
 498         *val = hdev->idle_timeout;
 499         hci_dev_unlock(hdev);
 500
 501         return 0;
 502 }
 503
 504 DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get,
 505                         idle_timeout_set, "%llu\n");
 506
 507 static int sniff_min_interval_set(void *data, u64 val)
 508 {
 509         struct hci_dev *hdev = data;
 510
 511         if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
 512                 return -EINVAL;
 513
 514         hci_dev_lock(hdev);
 515         hdev->sniff_min_interval = val;
 516         hci_dev_unlock(hdev);
 517
 518         return 0;
 519 }
 520
 521 static int sniff_min_interval_get(void *data, u64 *val)
 522 {
 523         struct hci_dev *hdev = data;
 524
 525         hci_dev_lock(hdev);
 526         *val = hdev->sniff_min_interval;
 527         hci_dev_unlock(hdev);
 528
 529         return 0;
 530 }
 531
 532 DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get,
 533                         sniff_min_interval_set, "%llu\n");
 534
 535 static int sniff_max_interval_set(void *data, u64 val)
 536 {
 537         struct hci_dev *hdev = data;
 538
 539         if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
 540                 return -EINVAL;
 541
 542         hci_dev_lock(hdev);
 543         hdev->sniff_max_interval = val;
 544         hci_dev_unlock(hdev);
 545
 546         return 0;
 547 }
 548
 549 static int sniff_max_interval_get(void *data, u64 *val)
 550 {
 551         struct hci_dev *hdev = data;
 552
 553         hci_dev_lock(hdev);
 554         *val = hdev->sniff_max_interval;
 555         hci_dev_unlock(hdev);
 556
 557         return 0;
 558 }
 559
 560 DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get,
 561                         sniff_max_interval_set, "%llu\n");
 562
 563 void hci_debugfs_create_bredr(struct hci_dev *hdev)
 564 {
 565         debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, hdev,
 566                             &inquiry_cache_fops);
 567         debugfs_create_file("link_keys", 0400, hdev->debugfs, hdev,
 568                             &link_keys_fops);
 569         debugfs_create_file("dev_class", 0444, hdev->debugfs, hdev,
 570                             &dev_class_fops);
 571         debugfs_create_file("voice_setting", 0444, hdev->debugfs, hdev,
 572                             &voice_setting_fops);
 573
 574         if (lmp_ssp_capable(hdev)) {
 575                 debugfs_create_file("ssp_debug_mode", 0444, hdev->debugfs,
 576                                     hdev, &ssp_debug_mode_fops);
 577                 debugfs_create_file("min_encrypt_key_size", 0644, hdev->debugfs,
 578                                     hdev, &min_encrypt_key_size_fops);
 579                 debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs,
 580                                     hdev, &auto_accept_delay_fops);
 581         }
 582
 583         if (lmp_sniff_capable(hdev)) {
 584                 debugfs_create_file("idle_timeout", 0644, hdev->debugfs,
 585                                     hdev, &idle_timeout_fops);
 586                 debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs,
 587                                     hdev, &sniff_min_interval_fops);
 588                 debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs,
 589                                     hdev, &sniff_max_interval_fops);
 590         }
 591 }
 592
 593 static int identity_show(struct seq_file *f, void *p)
 594 {
 595         struct hci_dev *hdev = f->private;
 596         bdaddr_t addr;
 597         u8 addr_type;
 598
 599         hci_dev_lock(hdev);
 600
 601         hci_copy_identity_address(hdev, &addr, &addr_type);
 602
 603         seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type,
 604                    16, hdev->irk, &hdev->rpa);
 605
 606         hci_dev_unlock(hdev);
 607
 608         return 0;
 609 }
 610
 611 DEFINE_SHOW_ATTRIBUTE(identity);
 612
 613 static int rpa_timeout_set(void *data, u64 val)
 614 {
 615         struct hci_dev *hdev = data;
 616
 617         /* Require the RPA timeout to be at least 30 seconds and at most
 618          * 24 hours.
 619          */
 620         if (val < 30 || val > (60 * 60 * 24))
 621                 return -EINVAL;
 622
 623         hci_dev_lock(hdev);
 624         hdev->rpa_timeout = val;
 625         hci_dev_unlock(hdev);
 626
 627         return 0;
 628 }
 629
 630 static int rpa_timeout_get(void *data, u64 *val)
 631 {
 632         struct hci_dev *hdev = data;
 633
 634         hci_dev_lock(hdev);
 635         *val = hdev->rpa_timeout;
 636         hci_dev_unlock(hdev);
 637
 638         return 0;
 639 }
 640
 641 DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get,
 642                         rpa_timeout_set, "%llu\n");
 643
 644 static int random_address_show(struct seq_file *f, void *p)
 645 {
 646         struct hci_dev *hdev = f->private;
 647
 648         hci_dev_lock(hdev);
 649         seq_printf(f, "%pMR\n", &hdev->random_addr);
 650         hci_dev_unlock(hdev);
 651
 652         return 0;
 653 }
 654
 655 DEFINE_SHOW_ATTRIBUTE(random_address);
 656
 657 static int static_address_show(struct seq_file *f, void *p)
 658 {
 659         struct hci_dev *hdev = f->private;
 660
 661         hci_dev_lock(hdev);
 662         seq_printf(f, "%pMR\n", &hdev->static_addr);
 663         hci_dev_unlock(hdev);
 664
 665         return 0;
 666 }
 667
 668 DEFINE_SHOW_ATTRIBUTE(static_address);
 669
 670 static ssize_t force_static_address_read(struct file *file,
 671                                          char __user *user_buf,
 672                                          size_t count, loff_t *ppos)
 673 {
 674         struct hci_dev *hdev = file->private_data;
 675         char buf[3];
 676
 677         buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR) ? 'Y': 'N';
 678         buf[1] = '\n';
 679         buf[2] = '\0';
 680         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
 681 }
 682
 683 static ssize_t force_static_address_write(struct file *file,
 684                                           const char __user *user_buf,
 685                                           size_t count, loff_t *ppos)
 686 {
 687         struct hci_dev *hdev = file->private_data;
 688         bool enable;
 689         int err;
 690
 691         if (test_bit(HCI_UP, &hdev->flags))
 692                 return -EBUSY;
 693
 694         err = kstrtobool_from_user(user_buf, count, &enable);
 695         if (err)
 696                 return err;
 697
 698         if (enable == hci_dev_test_flag(hdev, HCI_FORCE_STATIC_ADDR))
 699                 return -EALREADY;
 700
 701         hci_dev_change_flag(hdev, HCI_FORCE_STATIC_ADDR);
 702
 703         return count;
 704 }
 705
 706 static const struct file_operations force_static_address_fops = {
 707         .open           = simple_open,
 708         .read           = force_static_address_read,
 709         .write          = force_static_address_write,
 710         .llseek         = default_llseek,
 711 };
 712
 713 static int white_list_show(struct seq_file *f, void *ptr)
 714 {
 715         struct hci_dev *hdev = f->private;
 716         struct bdaddr_list *b;
 717
 718         hci_dev_lock(hdev);
 719         list_for_each_entry(b, &hdev->le_white_list, list)
 720                 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
 721         hci_dev_unlock(hdev);
 722
 723         return 0;
 724 }
 725
 726 DEFINE_SHOW_ATTRIBUTE(white_list);
 727
 728 static int resolv_list_show(struct seq_file *f, void *ptr)
 729 {
 730         struct hci_dev *hdev = f->private;
 731         struct bdaddr_list *b;
 732
 733         hci_dev_lock(hdev);
 734         list_for_each_entry(b, &hdev->le_resolv_list, list)
 735                 seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type);
 736         hci_dev_unlock(hdev);
 737
 738         return 0;
 739 }
 740
 741 DEFINE_SHOW_ATTRIBUTE(resolv_list);
 742
 743 static int identity_resolving_keys_show(struct seq_file *f, void *ptr)
 744 {
 745         struct hci_dev *hdev = f->private;
 746         struct smp_irk *irk;
 747
 748         rcu_read_lock();
 749         list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
 750                 seq_printf(f, "%pMR (type %u) %*phN %pMR\n",
 751                            &irk->bdaddr, irk->addr_type,
 752                            16, irk->val, &irk->rpa);
 753         }
 754         rcu_read_unlock();
 755
 756         return 0;
 757 }
 758
 759 DEFINE_SHOW_ATTRIBUTE(identity_resolving_keys);
 760
 761 static int long_term_keys_show(struct seq_file *f, void *ptr)
 762 {
 763         struct hci_dev *hdev = f->private;
 764         struct smp_ltk *ltk;
 765
 766         rcu_read_lock();
 767         list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list)
 768                 seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n",
 769                            &ltk->bdaddr, ltk->bdaddr_type, ltk->authenticated,
 770                            ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv),
 771                            __le64_to_cpu(ltk->rand), 16, ltk->val);
 772         rcu_read_unlock();
 773
 774         return 0;
 775 }
 776
 777 DEFINE_SHOW_ATTRIBUTE(long_term_keys);
 778
 779 static int conn_min_interval_set(void *data, u64 val)
 780 {
 781         struct hci_dev *hdev = data;
 782
 783         if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval)
 784                 return -EINVAL;
 785
 786         hci_dev_lock(hdev);
 787         hdev->le_conn_min_interval = val;
 788         hci_dev_unlock(hdev);
 789
 790         return 0;
 791 }
 792
 793 static int conn_min_interval_get(void *data, u64 *val)
 794 {
 795         struct hci_dev *hdev = data;
 796
 797         hci_dev_lock(hdev);
 798         *val = hdev->le_conn_min_interval;
 799         hci_dev_unlock(hdev);
 800
 801         return 0;
 802 }
 803
 804 DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get,
 805                         conn_min_interval_set, "%llu\n");
 806
 807 static int conn_max_interval_set(void *data, u64 val)
 808 {
 809         struct hci_dev *hdev = data;
 810
 811         if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval)
 812                 return -EINVAL;
 813
 814         hci_dev_lock(hdev);
 815         hdev->le_conn_max_interval = val;
 816         hci_dev_unlock(hdev);
 817
 818         return 0;
 819 }
 820
 821 static int conn_max_interval_get(void *data, u64 *val)
 822 {
 823         struct hci_dev *hdev = data;
 824
 825         hci_dev_lock(hdev);
 826         *val = hdev->le_conn_max_interval;
 827         hci_dev_unlock(hdev);
 828
 829         return 0;
 830 }
 831
 832 DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get,
 833                         conn_max_interval_set, "%llu\n");
 834
 835 static int conn_latency_set(void *data, u64 val)
 836 {
 837         struct hci_dev *hdev = data;
 838
 839         if (val > 0x01f3)
 840                 return -EINVAL;
 841
 842         hci_dev_lock(hdev);
 843         hdev->le_conn_latency = val;
 844         hci_dev_unlock(hdev);
 845
 846         return 0;
 847 }
 848
 849 static int conn_latency_get(void *data, u64 *val)
 850 {
 851         struct hci_dev *hdev = data;
 852
 853         hci_dev_lock(hdev);
 854         *val = hdev->le_conn_latency;
 855         hci_dev_unlock(hdev);
 856
 857         return 0;
 858 }
 859
 860 DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get,
 861                         conn_latency_set, "%llu\n");
 862
 863 static int supervision_timeout_set(void *data, u64 val)
 864 {
 865         struct hci_dev *hdev = data;
 866
 867         if (val < 0x000a || val > 0x0c80)
 868                 return -EINVAL;
 869
 870         hci_dev_lock(hdev);
 871         hdev->le_supv_timeout = val;
 872         hci_dev_unlock(hdev);
 873
 874         return 0;
 875 }
 876
 877 static int supervision_timeout_get(void *data, u64 *val)
 878 {
 879         struct hci_dev *hdev = data;
 880
 881         hci_dev_lock(hdev);
 882         *val = hdev->le_supv_timeout;
 883         hci_dev_unlock(hdev);
 884
 885         return 0;
 886 }
 887
 888 DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get,
 889                         supervision_timeout_set, "%llu\n");
 890
 891 static int adv_channel_map_set(void *data, u64 val)
 892 {
 893         struct hci_dev *hdev = data;
 894
 895         if (val < 0x01 || val > 0x07)
 896                 return -EINVAL;
 897
 898         hci_dev_lock(hdev);
 899         hdev->le_adv_channel_map = val;
 900         hci_dev_unlock(hdev);
 901
 902         return 0;
 903 }
 904
 905 static int adv_channel_map_get(void *data, u64 *val)
 906 {
 907         struct hci_dev *hdev = data;
 908
 909         hci_dev_lock(hdev);
 910         *val = hdev->le_adv_channel_map;
 911         hci_dev_unlock(hdev);
 912
 913         return 0;
 914 }
 915
 916 DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get,
 917                         adv_channel_map_set, "%llu\n");
 918
 919 static int adv_min_interval_set(void *data, u64 val)
 920 {
 921         struct hci_dev *hdev = data;
 922
 923         if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval)
 924                 return -EINVAL;
 925
 926         hci_dev_lock(hdev);
 927         hdev->le_adv_min_interval = val;
 928         hci_dev_unlock(hdev);
 929
 930         return 0;
 931 }
 932
 933 static int adv_min_interval_get(void *data, u64 *val)
 934 {
 935         struct hci_dev *hdev = data;
 936
 937         hci_dev_lock(hdev);
 938         *val = hdev->le_adv_min_interval;
 939         hci_dev_unlock(hdev);
 940
 941         return 0;
 942 }
 943
 944 DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get,
 945                         adv_min_interval_set, "%llu\n");
 946
 947 static int adv_max_interval_set(void *data, u64 val)
 948 {
 949         struct hci_dev *hdev = data;
 950
 951         if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval)
 952                 return -EINVAL;
 953
 954         hci_dev_lock(hdev);
 955         hdev->le_adv_max_interval = val;
 956         hci_dev_unlock(hdev);
 957
 958         return 0;
 959 }
 960
 961 static int adv_max_interval_get(void *data, u64 *val)
 962 {
 963         struct hci_dev *hdev = data;
 964
 965         hci_dev_lock(hdev);
 966         *val = hdev->le_adv_max_interval;
 967         hci_dev_unlock(hdev);
 968
 969         return 0;
 970 }
 971
 972 DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get,
 973                         adv_max_interval_set, "%llu\n");
 974
 975 static int auth_payload_timeout_set(void *data, u64 val)
 976 {
 977         struct hci_dev *hdev = data;
 978
 979         if (val < 0x0001 || val > 0xffff)
 980                 return -EINVAL;
 981
 982         hci_dev_lock(hdev);
 983         hdev->auth_payload_timeout = val;
 984         hci_dev_unlock(hdev);
 985
 986         return 0;
 987 }
 988
 989 static int auth_payload_timeout_get(void *data, u64 *val)
 990 {
 991         struct hci_dev *hdev = data;
 992
 993         hci_dev_lock(hdev);
 994         *val = hdev->auth_payload_timeout;
 995         hci_dev_unlock(hdev);
 996
 997         return 0;
 998 }
 999
1000 DEFINE_SIMPLE_ATTRIBUTE(auth_payload_timeout_fops,
1001                         auth_payload_timeout_get,
1002                         auth_payload_timeout_set, "%llu\n");
1003
1004 DEFINE_QUIRK_ATTRIBUTE(quirk_strict_duplicate_filter,
1005                        HCI_QUIRK_STRICT_DUPLICATE_FILTER);
1006 DEFINE_QUIRK_ATTRIBUTE(quirk_simultaneous_discovery,
1007                        HCI_QUIRK_SIMULTANEOUS_DISCOVERY);
1008
1009 void hci_debugfs_create_le(struct hci_dev *hdev)
1010 {
1011         debugfs_create_file("identity", 0400, hdev->debugfs, hdev,
1012                             &identity_fops);
1013         debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, hdev,
1014                             &rpa_timeout_fops);
1015         debugfs_create_file("random_address", 0444, hdev->debugfs, hdev,
1016                             &random_address_fops);
1017         debugfs_create_file("static_address", 0444, hdev->debugfs, hdev,
1018                             &static_address_fops);
1019
1020         /* For controllers with a public address, provide a debug
1021          * option to force the usage of the configured static
1022          * address. By default the public address is used.
1023          */
1024         if (bacmp(&hdev->bdaddr, BDADDR_ANY))
1025                 debugfs_create_file("force_static_address", 0644,
1026                                     hdev->debugfs, hdev,
1027                                     &force_static_address_fops);
1028
1029         debugfs_create_u8("white_list_size", 0444, hdev->debugfs,
1030                           &hdev->le_white_list_size);
1031         debugfs_create_file("white_list", 0444, hdev->debugfs, hdev,
1032                             &white_list_fops);
1033         debugfs_create_u8("resolv_list_size", 0444, hdev->debugfs,
1034                           &hdev->le_resolv_list_size);
1035         debugfs_create_file("resolv_list", 0444, hdev->debugfs, hdev,
1036                             &resolv_list_fops);
1037         debugfs_create_file("identity_resolving_keys", 0400, hdev->debugfs,
1038                             hdev, &identity_resolving_keys_fops);
1039         debugfs_create_file("long_term_keys", 0400, hdev->debugfs, hdev,
1040                             &long_term_keys_fops);
1041         debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, hdev,
1042                             &conn_min_interval_fops);
1043         debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, hdev,
1044                             &conn_max_interval_fops);
1045         debugfs_create_file("conn_latency", 0644, hdev->debugfs, hdev,
1046                             &conn_latency_fops);
1047         debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, hdev,
1048                             &supervision_timeout_fops);
1049         debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, hdev,
1050                             &adv_channel_map_fops);
1051         debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, hdev,
1052                             &adv_min_interval_fops);
1053         debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, hdev,
1054                             &adv_max_interval_fops);
1055         debugfs_create_u16("discov_interleaved_timeout", 0644, hdev->debugfs,
1056                            &hdev->discov_interleaved_timeout);
1057         debugfs_create_file("auth_payload_timeout", 0644, hdev->debugfs, hdev,
1058                             &auth_payload_timeout_fops);
1059
1060         debugfs_create_file("quirk_strict_duplicate_filter", 0644,
1061                             hdev->debugfs, hdev,
1062                             &quirk_strict_duplicate_filter_fops);
1063         debugfs_create_file("quirk_simultaneous_discovery", 0644,
1064                             hdev->debugfs, hdev,
1065                             &quirk_simultaneous_discovery_fops);
1066 }
1067
1068 void hci_debugfs_create_conn(struct hci_conn *conn)
1069 {
1070         struct hci_dev *hdev = conn->hdev;
1071         char name[6];
1072
1073         if (IS_ERR_OR_NULL(hdev->debugfs))
1074                 return;
1075
1076         snprintf(name, sizeof(name), "%u", conn->handle);
1077         conn->debugfs = debugfs_create_dir(name, hdev->debugfs);
1078 }