net/bluetooth/hci_debugfs.c

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