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