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