linux/net/bluetooth/hci_sysfs.c
<<
>>
Prefs
   1/* Bluetooth HCI driver model support. */
   2
   3#include <linux/debugfs.h>
   4#include <linux/module.h>
   5
   6#include <net/bluetooth/bluetooth.h>
   7#include <net/bluetooth/hci_core.h>
   8
   9static struct class *bt_class;
  10
  11struct dentry *bt_debugfs;
  12EXPORT_SYMBOL_GPL(bt_debugfs);
  13
  14static inline char *link_typetostr(int type)
  15{
  16        switch (type) {
  17        case ACL_LINK:
  18                return "ACL";
  19        case SCO_LINK:
  20                return "SCO";
  21        case ESCO_LINK:
  22                return "eSCO";
  23        case LE_LINK:
  24                return "LE";
  25        default:
  26                return "UNKNOWN";
  27        }
  28}
  29
  30static ssize_t show_link_type(struct device *dev,
  31                              struct device_attribute *attr, char *buf)
  32{
  33        struct hci_conn *conn = to_hci_conn(dev);
  34        return sprintf(buf, "%s\n", link_typetostr(conn->type));
  35}
  36
  37static ssize_t show_link_address(struct device *dev,
  38                                 struct device_attribute *attr, char *buf)
  39{
  40        struct hci_conn *conn = to_hci_conn(dev);
  41        return sprintf(buf, "%s\n", batostr(&conn->dst));
  42}
  43
  44static ssize_t show_link_features(struct device *dev,
  45                                  struct device_attribute *attr, char *buf)
  46{
  47        struct hci_conn *conn = to_hci_conn(dev);
  48
  49        return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
  50                       conn->features[0], conn->features[1],
  51                       conn->features[2], conn->features[3],
  52                       conn->features[4], conn->features[5],
  53                       conn->features[6], conn->features[7]);
  54}
  55
  56#define LINK_ATTR(_name, _mode, _show, _store) \
  57struct device_attribute link_attr_##_name = __ATTR(_name, _mode, _show, _store)
  58
  59static LINK_ATTR(type, S_IRUGO, show_link_type, NULL);
  60static LINK_ATTR(address, S_IRUGO, show_link_address, NULL);
  61static LINK_ATTR(features, S_IRUGO, show_link_features, NULL);
  62
  63static struct attribute *bt_link_attrs[] = {
  64        &link_attr_type.attr,
  65        &link_attr_address.attr,
  66        &link_attr_features.attr,
  67        NULL
  68};
  69
  70static struct attribute_group bt_link_group = {
  71        .attrs = bt_link_attrs,
  72};
  73
  74static const struct attribute_group *bt_link_groups[] = {
  75        &bt_link_group,
  76        NULL
  77};
  78
  79static void bt_link_release(struct device *dev)
  80{
  81        struct hci_conn *conn = to_hci_conn(dev);
  82        kfree(conn);
  83}
  84
  85static struct device_type bt_link = {
  86        .name    = "link",
  87        .groups  = bt_link_groups,
  88        .release = bt_link_release,
  89};
  90
  91/*
  92 * The rfcomm tty device will possibly retain even when conn
  93 * is down, and sysfs doesn't support move zombie device,
  94 * so we should move the device before conn device is destroyed.
  95 */
  96static int __match_tty(struct device *dev, void *data)
  97{
  98        return !strncmp(dev_name(dev), "rfcomm", 6);
  99}
 100
 101void hci_conn_init_sysfs(struct hci_conn *conn)
 102{
 103        struct hci_dev *hdev = conn->hdev;
 104
 105        BT_DBG("conn %p", conn);
 106
 107        conn->dev.type = &bt_link;
 108        conn->dev.class = bt_class;
 109        conn->dev.parent = &hdev->dev;
 110
 111        device_initialize(&conn->dev);
 112}
 113
 114void hci_conn_add_sysfs(struct hci_conn *conn)
 115{
 116        struct hci_dev *hdev = conn->hdev;
 117
 118        BT_DBG("conn %p", conn);
 119
 120        dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle);
 121
 122        if (device_add(&conn->dev) < 0) {
 123                BT_ERR("Failed to register connection device");
 124                return;
 125        }
 126
 127        hci_dev_hold(hdev);
 128}
 129
 130void hci_conn_del_sysfs(struct hci_conn *conn)
 131{
 132        struct hci_dev *hdev = conn->hdev;
 133
 134        if (!device_is_registered(&conn->dev))
 135                return;
 136
 137        while (1) {
 138                struct device *dev;
 139
 140                dev = device_find_child(&conn->dev, NULL, __match_tty);
 141                if (!dev)
 142                        break;
 143                device_move(dev, NULL, DPM_ORDER_DEV_LAST);
 144                put_device(dev);
 145        }
 146
 147        device_del(&conn->dev);
 148        put_device(&conn->dev);
 149
 150        hci_dev_put(hdev);
 151}
 152
 153static inline char *host_bustostr(int bus)
 154{
 155        switch (bus) {
 156        case HCI_VIRTUAL:
 157                return "VIRTUAL";
 158        case HCI_USB:
 159                return "USB";
 160        case HCI_PCCARD:
 161                return "PCCARD";
 162        case HCI_UART:
 163                return "UART";
 164        case HCI_RS232:
 165                return "RS232";
 166        case HCI_PCI:
 167                return "PCI";
 168        case HCI_SDIO:
 169                return "SDIO";
 170        default:
 171                return "UNKNOWN";
 172        }
 173}
 174
 175static inline char *host_typetostr(int type)
 176{
 177        switch (type) {
 178        case HCI_BREDR:
 179                return "BR/EDR";
 180        case HCI_AMP:
 181                return "AMP";
 182        default:
 183                return "UNKNOWN";
 184        }
 185}
 186
 187static ssize_t show_bus(struct device *dev,
 188                        struct device_attribute *attr, char *buf)
 189{
 190        struct hci_dev *hdev = to_hci_dev(dev);
 191        return sprintf(buf, "%s\n", host_bustostr(hdev->bus));
 192}
 193
 194static ssize_t show_type(struct device *dev,
 195                         struct device_attribute *attr, char *buf)
 196{
 197        struct hci_dev *hdev = to_hci_dev(dev);
 198        return sprintf(buf, "%s\n", host_typetostr(hdev->dev_type));
 199}
 200
 201static ssize_t show_name(struct device *dev,
 202                         struct device_attribute *attr, char *buf)
 203{
 204        struct hci_dev *hdev = to_hci_dev(dev);
 205        char name[HCI_MAX_NAME_LENGTH + 1];
 206        int i;
 207
 208        for (i = 0; i < HCI_MAX_NAME_LENGTH; i++)
 209                name[i] = hdev->dev_name[i];
 210
 211        name[HCI_MAX_NAME_LENGTH] = '\0';
 212        return sprintf(buf, "%s\n", name);
 213}
 214
 215static ssize_t show_class(struct device *dev,
 216                          struct device_attribute *attr, char *buf)
 217{
 218        struct hci_dev *hdev = to_hci_dev(dev);
 219        return sprintf(buf, "0x%.2x%.2x%.2x\n", hdev->dev_class[2],
 220                       hdev->dev_class[1], hdev->dev_class[0]);
 221}
 222
 223static ssize_t show_address(struct device *dev,
 224                            struct device_attribute *attr, char *buf)
 225{
 226        struct hci_dev *hdev = to_hci_dev(dev);
 227        return sprintf(buf, "%s\n", batostr(&hdev->bdaddr));
 228}
 229
 230static ssize_t show_features(struct device *dev,
 231                             struct device_attribute *attr, char *buf)
 232{
 233        struct hci_dev *hdev = to_hci_dev(dev);
 234
 235        return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
 236                       hdev->features[0], hdev->features[1],
 237                       hdev->features[2], hdev->features[3],
 238                       hdev->features[4], hdev->features[5],
 239                       hdev->features[6], hdev->features[7]);
 240}
 241
 242static ssize_t show_manufacturer(struct device *dev,
 243                                 struct device_attribute *attr, char *buf)
 244{
 245        struct hci_dev *hdev = to_hci_dev(dev);
 246        return sprintf(buf, "%d\n", hdev->manufacturer);
 247}
 248
 249static ssize_t show_hci_version(struct device *dev,
 250                                struct device_attribute *attr, char *buf)
 251{
 252        struct hci_dev *hdev = to_hci_dev(dev);
 253        return sprintf(buf, "%d\n", hdev->hci_ver);
 254}
 255
 256static ssize_t show_hci_revision(struct device *dev,
 257                                 struct device_attribute *attr, char *buf)
 258{
 259        struct hci_dev *hdev = to_hci_dev(dev);
 260        return sprintf(buf, "%d\n", hdev->hci_rev);
 261}
 262
 263static ssize_t show_idle_timeout(struct device *dev,
 264                                 struct device_attribute *attr, char *buf)
 265{
 266        struct hci_dev *hdev = to_hci_dev(dev);
 267        return sprintf(buf, "%d\n", hdev->idle_timeout);
 268}
 269
 270static ssize_t store_idle_timeout(struct device *dev,
 271                                  struct device_attribute *attr,
 272                                  const char *buf, size_t count)
 273{
 274        struct hci_dev *hdev = to_hci_dev(dev);
 275        unsigned int val;
 276        int rv;
 277
 278        rv = kstrtouint(buf, 0, &val);
 279        if (rv < 0)
 280                return rv;
 281
 282        if (val != 0 && (val < 500 || val > 3600000))
 283                return -EINVAL;
 284
 285        hdev->idle_timeout = val;
 286
 287        return count;
 288}
 289
 290static ssize_t show_sniff_max_interval(struct device *dev,
 291                                       struct device_attribute *attr, char *buf)
 292{
 293        struct hci_dev *hdev = to_hci_dev(dev);
 294        return sprintf(buf, "%d\n", hdev->sniff_max_interval);
 295}
 296
 297static ssize_t store_sniff_max_interval(struct device *dev,
 298                                        struct device_attribute *attr,
 299                                        const char *buf, size_t count)
 300{
 301        struct hci_dev *hdev = to_hci_dev(dev);
 302        u16 val;
 303        int rv;
 304
 305        rv = kstrtou16(buf, 0, &val);
 306        if (rv < 0)
 307                return rv;
 308
 309        if (val == 0 || val % 2 || val < hdev->sniff_min_interval)
 310                return -EINVAL;
 311
 312        hdev->sniff_max_interval = val;
 313
 314        return count;
 315}
 316
 317static ssize_t show_sniff_min_interval(struct device *dev,
 318                                       struct device_attribute *attr, char *buf)
 319{
 320        struct hci_dev *hdev = to_hci_dev(dev);
 321        return sprintf(buf, "%d\n", hdev->sniff_min_interval);
 322}
 323
 324static ssize_t store_sniff_min_interval(struct device *dev,
 325                                        struct device_attribute *attr,
 326                                        const char *buf, size_t count)
 327{
 328        struct hci_dev *hdev = to_hci_dev(dev);
 329        u16 val;
 330        int rv;
 331
 332        rv = kstrtou16(buf, 0, &val);
 333        if (rv < 0)
 334                return rv;
 335
 336        if (val == 0 || val % 2 || val > hdev->sniff_max_interval)
 337                return -EINVAL;
 338
 339        hdev->sniff_min_interval = val;
 340
 341        return count;
 342}
 343
 344static DEVICE_ATTR(bus, S_IRUGO, show_bus, NULL);
 345static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
 346static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 347static DEVICE_ATTR(class, S_IRUGO, show_class, NULL);
 348static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
 349static DEVICE_ATTR(features, S_IRUGO, show_features, NULL);
 350static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL);
 351static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL);
 352static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL);
 353
 354static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
 355                   show_idle_timeout, store_idle_timeout);
 356static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR,
 357                   show_sniff_max_interval, store_sniff_max_interval);
 358static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
 359                   show_sniff_min_interval, store_sniff_min_interval);
 360
 361static struct attribute *bt_host_attrs[] = {
 362        &dev_attr_bus.attr,
 363        &dev_attr_type.attr,
 364        &dev_attr_name.attr,
 365        &dev_attr_class.attr,
 366        &dev_attr_address.attr,
 367        &dev_attr_features.attr,
 368        &dev_attr_manufacturer.attr,
 369        &dev_attr_hci_version.attr,
 370        &dev_attr_hci_revision.attr,
 371        &dev_attr_idle_timeout.attr,
 372        &dev_attr_sniff_max_interval.attr,
 373        &dev_attr_sniff_min_interval.attr,
 374        NULL
 375};
 376
 377static struct attribute_group bt_host_group = {
 378        .attrs = bt_host_attrs,
 379};
 380
 381static const struct attribute_group *bt_host_groups[] = {
 382        &bt_host_group,
 383        NULL
 384};
 385
 386static void bt_host_release(struct device *dev)
 387{
 388        struct hci_dev *hdev = to_hci_dev(dev);
 389        kfree(hdev);
 390        module_put(THIS_MODULE);
 391}
 392
 393static struct device_type bt_host = {
 394        .name    = "host",
 395        .groups  = bt_host_groups,
 396        .release = bt_host_release,
 397};
 398
 399static int inquiry_cache_show(struct seq_file *f, void *p)
 400{
 401        struct hci_dev *hdev = f->private;
 402        struct discovery_state *cache = &hdev->discovery;
 403        struct inquiry_entry *e;
 404
 405        hci_dev_lock(hdev);
 406
 407        list_for_each_entry(e, &cache->all, all) {
 408                struct inquiry_data *data = &e->data;
 409                seq_printf(f, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n",
 410                           batostr(&data->bdaddr),
 411                           data->pscan_rep_mode, data->pscan_period_mode,
 412                           data->pscan_mode, data->dev_class[2],
 413                           data->dev_class[1], data->dev_class[0],
 414                           __le16_to_cpu(data->clock_offset),
 415                           data->rssi, data->ssp_mode, e->timestamp);
 416        }
 417
 418        hci_dev_unlock(hdev);
 419
 420        return 0;
 421}
 422
 423static int inquiry_cache_open(struct inode *inode, struct file *file)
 424{
 425        return single_open(file, inquiry_cache_show, inode->i_private);
 426}
 427
 428static const struct file_operations inquiry_cache_fops = {
 429        .open           = inquiry_cache_open,
 430        .read           = seq_read,
 431        .llseek         = seq_lseek,
 432        .release        = single_release,
 433};
 434
 435static int blacklist_show(struct seq_file *f, void *p)
 436{
 437        struct hci_dev *hdev = f->private;
 438        struct bdaddr_list *b;
 439
 440        hci_dev_lock(hdev);
 441
 442        list_for_each_entry(b, &hdev->blacklist, list)
 443                seq_printf(f, "%s\n", batostr(&b->bdaddr));
 444
 445        hci_dev_unlock(hdev);
 446
 447        return 0;
 448}
 449
 450static int blacklist_open(struct inode *inode, struct file *file)
 451{
 452        return single_open(file, blacklist_show, inode->i_private);
 453}
 454
 455static const struct file_operations blacklist_fops = {
 456        .open           = blacklist_open,
 457        .read           = seq_read,
 458        .llseek         = seq_lseek,
 459        .release        = single_release,
 460};
 461
 462static void print_bt_uuid(struct seq_file *f, u8 *uuid)
 463{
 464        __be32 data0, data4;
 465        __be16 data1, data2, data3, data5;
 466
 467        memcpy(&data0, &uuid[0], 4);
 468        memcpy(&data1, &uuid[4], 2);
 469        memcpy(&data2, &uuid[6], 2);
 470        memcpy(&data3, &uuid[8], 2);
 471        memcpy(&data4, &uuid[10], 4);
 472        memcpy(&data5, &uuid[14], 2);
 473
 474        seq_printf(f, "%.8x-%.4x-%.4x-%.4x-%.8x%.4x\n",
 475                   ntohl(data0), ntohs(data1), ntohs(data2), ntohs(data3),
 476                   ntohl(data4), ntohs(data5));
 477}
 478
 479static int uuids_show(struct seq_file *f, void *p)
 480{
 481        struct hci_dev *hdev = f->private;
 482        struct bt_uuid *uuid;
 483
 484        hci_dev_lock(hdev);
 485
 486        list_for_each_entry(uuid, &hdev->uuids, list)
 487                print_bt_uuid(f, uuid->uuid);
 488
 489        hci_dev_unlock(hdev);
 490
 491        return 0;
 492}
 493
 494static int uuids_open(struct inode *inode, struct file *file)
 495{
 496        return single_open(file, uuids_show, inode->i_private);
 497}
 498
 499static const struct file_operations uuids_fops = {
 500        .open           = uuids_open,
 501        .read           = seq_read,
 502        .llseek         = seq_lseek,
 503        .release        = single_release,
 504};
 505
 506static int auto_accept_delay_set(void *data, u64 val)
 507{
 508        struct hci_dev *hdev = data;
 509
 510        hci_dev_lock(hdev);
 511
 512        hdev->auto_accept_delay = val;
 513
 514        hci_dev_unlock(hdev);
 515
 516        return 0;
 517}
 518
 519static int auto_accept_delay_get(void *data, u64 *val)
 520{
 521        struct hci_dev *hdev = data;
 522
 523        hci_dev_lock(hdev);
 524
 525        *val = hdev->auto_accept_delay;
 526
 527        hci_dev_unlock(hdev);
 528
 529        return 0;
 530}
 531
 532DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get,
 533                        auto_accept_delay_set, "%llu\n");
 534
 535void hci_init_sysfs(struct hci_dev *hdev)
 536{
 537        struct device *dev = &hdev->dev;
 538
 539        dev->type = &bt_host;
 540        dev->class = bt_class;
 541
 542        __module_get(THIS_MODULE);
 543        device_initialize(dev);
 544}
 545
 546int hci_add_sysfs(struct hci_dev *hdev)
 547{
 548        struct device *dev = &hdev->dev;
 549        int err;
 550
 551        BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
 552
 553        dev_set_name(dev, "%s", hdev->name);
 554
 555        err = device_add(dev);
 556        if (err < 0)
 557                return err;
 558
 559        if (!bt_debugfs)
 560                return 0;
 561
 562        hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs);
 563        if (!hdev->debugfs)
 564                return 0;
 565
 566        debugfs_create_file("inquiry_cache", 0444, hdev->debugfs,
 567                            hdev, &inquiry_cache_fops);
 568
 569        debugfs_create_file("blacklist", 0444, hdev->debugfs,
 570                            hdev, &blacklist_fops);
 571
 572        debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops);
 573
 574        debugfs_create_file("auto_accept_delay", 0444, hdev->debugfs, hdev,
 575                            &auto_accept_delay_fops);
 576        return 0;
 577}
 578
 579void hci_del_sysfs(struct hci_dev *hdev)
 580{
 581        BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
 582
 583        debugfs_remove_recursive(hdev->debugfs);
 584
 585        device_del(&hdev->dev);
 586}
 587
 588int __init bt_sysfs_init(void)
 589{
 590        bt_debugfs = debugfs_create_dir("bluetooth", NULL);
 591
 592        bt_class = class_create(THIS_MODULE, "bluetooth");
 593        if (IS_ERR(bt_class))
 594                return PTR_ERR(bt_class);
 595
 596        return 0;
 597}
 598
 599void bt_sysfs_cleanup(void)
 600{
 601        class_destroy(bt_class);
 602
 603        debugfs_remove_recursive(bt_debugfs);
 604}
 605
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.