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