git.oblomov.eu Git - linux-2.6/blob - net/bluetooth/hci_sysfs.c

   1 /* Bluetooth HCI driver model support. */
   2
   3 #include <linux/kernel.h>
   4 #include <linux/init.h>
   5
   6 #include <linux/platform_device.h>
   7
   8 #include <net/bluetooth/bluetooth.h>
   9 #include <net/bluetooth/hci_core.h>
  10
  11 #ifndef CONFIG_BT_HCI_CORE_DEBUG
  12 #undef  BT_DBG
  13 #define BT_DBG(D...)
  14 #endif
  15
  16 static inline char *typetostr(int type)
  17 {
  18         switch (type) {
  19         case HCI_VIRTUAL:
  20                 return "VIRTUAL";
  21         case HCI_USB:
  22                 return "USB";
  23         case HCI_PCCARD:
  24                 return "PCCARD";
  25         case HCI_UART:
  26                 return "UART";
  27         case HCI_RS232:
  28                 return "RS232";
  29         case HCI_PCI:
  30                 return "PCI";
  31         case HCI_SDIO:
  32                 return "SDIO";
  33         default:
  34                 return "UNKNOWN";
  35         }
  36 }
  37
  38 static ssize_t show_type(struct device *dev, struct device_attribute *attr, char *buf)
  39 {
  40         struct hci_dev *hdev = dev_get_drvdata(dev);
  41         return sprintf(buf, "%s\n", typetostr(hdev->type));
  42 }
  43
  44 static ssize_t show_address(struct device *dev, struct device_attribute *attr, char *buf)
  45 {
  46         struct hci_dev *hdev = dev_get_drvdata(dev);
  47         bdaddr_t bdaddr;
  48         baswap(&bdaddr, &hdev->bdaddr);
  49         return sprintf(buf, "%s\n", batostr(&bdaddr));
  50 }
  51
  52 static ssize_t show_manufacturer(struct device *dev, struct device_attribute *attr, char *buf)
  53 {
  54         struct hci_dev *hdev = dev_get_drvdata(dev);
  55         return sprintf(buf, "%d\n", hdev->manufacturer);
  56 }
  57
  58 static ssize_t show_hci_version(struct device *dev, struct device_attribute *attr, char *buf)
  59 {
  60         struct hci_dev *hdev = dev_get_drvdata(dev);
  61         return sprintf(buf, "%d\n", hdev->hci_ver);
  62 }
  63
  64 static ssize_t show_hci_revision(struct device *dev, struct device_attribute *attr, char *buf)
  65 {
  66         struct hci_dev *hdev = dev_get_drvdata(dev);
  67         return sprintf(buf, "%d\n", hdev->hci_rev);
  68 }
  69
  70 static ssize_t show_inquiry_cache(struct device *dev, struct device_attribute *attr, char *buf)
  71 {
  72         struct hci_dev *hdev = dev_get_drvdata(dev);
  73         struct inquiry_cache *cache = &hdev->inq_cache;
  74         struct inquiry_entry *e;
  75         int n = 0;
  76
  77         hci_dev_lock_bh(hdev);
  78
  79         for (e = cache->list; e; e = e->next) {
  80                 struct inquiry_data *data = &e->data;
  81                 bdaddr_t bdaddr;
  82                 baswap(&bdaddr, &data->bdaddr);
  83                 n += sprintf(buf + n, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %u\n",
  84                                 batostr(&bdaddr),
  85                                 data->pscan_rep_mode, data->pscan_period_mode, data->pscan_mode,
  86                                 data->dev_class[2], data->dev_class[1], data->dev_class[0],
  87                                 __le16_to_cpu(data->clock_offset), data->rssi, e->timestamp);
  88         }
  89
  90         hci_dev_unlock_bh(hdev);
  91         return n;
  92 }
  93
  94 static ssize_t show_idle_timeout(struct device *dev, struct device_attribute *attr, char *buf)
  95 {
  96         struct hci_dev *hdev = dev_get_drvdata(dev);
  97         return sprintf(buf, "%d\n", hdev->idle_timeout);
  98 }
  99
 100 static ssize_t store_idle_timeout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 101 {
 102         struct hci_dev *hdev = dev_get_drvdata(dev);
 103         char *ptr;
 104         __u32 val;
 105
 106         val = simple_strtoul(buf, &ptr, 10);
 107         if (ptr == buf)
 108                 return -EINVAL;
 109
 110         if (val != 0 && (val < 500 || val > 3600000))
 111                 return -EINVAL;
 112
 113         hdev->idle_timeout = val;
 114
 115         return count;
 116 }
 117
 118 static ssize_t show_sniff_max_interval(struct device *dev, struct device_attribute *attr, char *buf)
 119 {
 120         struct hci_dev *hdev = dev_get_drvdata(dev);
 121         return sprintf(buf, "%d\n", hdev->sniff_max_interval);
 122 }
 123
 124 static ssize_t store_sniff_max_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 125 {
 126         struct hci_dev *hdev = dev_get_drvdata(dev);
 127         char *ptr;
 128         __u16 val;
 129
 130         val = simple_strtoul(buf, &ptr, 10);
 131         if (ptr == buf)
 132                 return -EINVAL;
 133
 134         if (val < 0x0002 || val > 0xFFFE || val % 2)
 135                 return -EINVAL;
 136
 137         if (val < hdev->sniff_min_interval)
 138                 return -EINVAL;
 139
 140         hdev->sniff_max_interval = val;
 141
 142         return count;
 143 }
 144
 145 static ssize_t show_sniff_min_interval(struct device *dev, struct device_attribute *attr, char *buf)
 146 {
 147         struct hci_dev *hdev = dev_get_drvdata(dev);
 148         return sprintf(buf, "%d\n", hdev->sniff_min_interval);
 149 }
 150
 151 static ssize_t store_sniff_min_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 152 {
 153         struct hci_dev *hdev = dev_get_drvdata(dev);
 154         char *ptr;
 155         __u16 val;
 156
 157         val = simple_strtoul(buf, &ptr, 10);
 158         if (ptr == buf)
 159                 return -EINVAL;
 160
 161         if (val < 0x0002 || val > 0xFFFE || val % 2)
 162                 return -EINVAL;
 163
 164         if (val > hdev->sniff_max_interval)
 165                 return -EINVAL;
 166
 167         hdev->sniff_min_interval = val;
 168
 169         return count;
 170 }
 171
 172 static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
 173 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
 174 static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL);
 175 static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL);
 176 static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL);
 177 static DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL);
 178
 179 static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
 180                                 show_idle_timeout, store_idle_timeout);
 181 static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR,
 182                                 show_sniff_max_interval, store_sniff_max_interval);
 183 static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
 184                                 show_sniff_min_interval, store_sniff_min_interval);
 185
 186 static struct device_attribute *bt_attrs[] = {
 187         &dev_attr_type,
 188         &dev_attr_address,
 189         &dev_attr_manufacturer,
 190         &dev_attr_hci_version,
 191         &dev_attr_hci_revision,
 192         &dev_attr_inquiry_cache,
 193         &dev_attr_idle_timeout,
 194         &dev_attr_sniff_max_interval,
 195         &dev_attr_sniff_min_interval,
 196         NULL
 197 };
 198
 199 static ssize_t show_conn_type(struct device *dev, struct device_attribute *attr, char *buf)
 200 {
 201         struct hci_conn *conn = dev_get_drvdata(dev);
 202         return sprintf(buf, "%s\n", conn->type == ACL_LINK ? "ACL" : "SCO");
 203 }
 204
 205 static ssize_t show_conn_address(struct device *dev, struct device_attribute *attr, char *buf)
 206 {
 207         struct hci_conn *conn = dev_get_drvdata(dev);
 208         bdaddr_t bdaddr;
 209         baswap(&bdaddr, &conn->dst);
 210         return sprintf(buf, "%s\n", batostr(&bdaddr));
 211 }
 212
 213 #define CONN_ATTR(_name,_mode,_show,_store) \
 214 struct device_attribute conn_attr_##_name = __ATTR(_name,_mode,_show,_store)
 215
 216 static CONN_ATTR(type, S_IRUGO, show_conn_type, NULL);
 217 static CONN_ATTR(address, S_IRUGO, show_conn_address, NULL);
 218
 219 static struct device_attribute *conn_attrs[] = {
 220         &conn_attr_type,
 221         &conn_attr_address,
 222         NULL
 223 };
 224
 225 struct class *bt_class = NULL;
 226 EXPORT_SYMBOL_GPL(bt_class);
 227
 228 static struct bus_type bt_bus = {
 229         .name   = "bluetooth",
 230 };
 231
 232 static struct platform_device *bt_platform;
 233
 234 static void bt_release(struct device *dev)
 235 {
 236         void *data = dev_get_drvdata(dev);
 237         kfree(data);
 238 }
 239
 240 static void add_conn(struct work_struct *work)
 241 {
 242         struct hci_conn *conn = container_of(work, struct hci_conn, work);
 243         int i;
 244
 245         if (device_register(&conn->dev) < 0) {
 246                 BT_ERR("Failed to register connection device");
 247                 return;
 248         }
 249
 250         for (i = 0; conn_attrs[i]; i++)
 251                 if (device_create_file(&conn->dev, conn_attrs[i]) < 0)
 252                         BT_ERR("Failed to create connection attribute");
 253 }
 254
 255 void hci_conn_add_sysfs(struct hci_conn *conn)
 256 {
 257         struct hci_dev *hdev = conn->hdev;
 258         bdaddr_t *ba = &conn->dst;
 259
 260         BT_DBG("conn %p", conn);
 261
 262         conn->dev.bus = &bt_bus;
 263         conn->dev.parent = &hdev->dev;
 264
 265         conn->dev.release = bt_release;
 266
 267         snprintf(conn->dev.bus_id, BUS_ID_SIZE,
 268                         "%s%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
 269                         conn->type == ACL_LINK ? "acl" : "sco",
 270                         ba->b[5], ba->b[4], ba->b[3],
 271                         ba->b[2], ba->b[1], ba->b[0]);
 272
 273         dev_set_drvdata(&conn->dev, conn);
 274
 275         INIT_WORK(&conn->work, add_conn);
 276
 277         schedule_work(&conn->work);
 278 }
 279
 280 static void del_conn(struct work_struct *work)
 281 {
 282         struct hci_conn *conn = container_of(work, struct hci_conn, work);
 283         device_del(&conn->dev);
 284 }
 285
 286 void hci_conn_del_sysfs(struct hci_conn *conn)
 287 {
 288         BT_DBG("conn %p", conn);
 289
 290         INIT_WORK(&conn->work, del_conn);
 291
 292         schedule_work(&conn->work);
 293 }
 294
 295 int hci_register_sysfs(struct hci_dev *hdev)
 296 {
 297         struct device *dev = &hdev->dev;
 298         unsigned int i;
 299         int err;
 300
 301         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
 302
 303         dev->class = bt_class;
 304         dev->parent = hdev->parent;
 305
 306         strlcpy(dev->bus_id, hdev->name, BUS_ID_SIZE);
 307
 308         dev->release = bt_release;
 309
 310         dev_set_drvdata(dev, hdev);
 311
 312         err = device_register(dev);
 313         if (err < 0)
 314                 return err;
 315
 316         for (i = 0; bt_attrs[i]; i++)
 317                 if (device_create_file(dev, bt_attrs[i]) < 0)
 318                         BT_ERR("Failed to create device attribute");
 319
 320         return 0;
 321 }
 322
 323 void hci_unregister_sysfs(struct hci_dev *hdev)
 324 {
 325         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
 326
 327         device_del(&hdev->dev);
 328 }
 329
 330 int __init bt_sysfs_init(void)
 331 {
 332         int err;
 333
 334         bt_platform = platform_device_register_simple("bluetooth", -1, NULL, 0);
 335         if (IS_ERR(bt_platform))
 336                 return PTR_ERR(bt_platform);
 337
 338         err = bus_register(&bt_bus);
 339         if (err < 0) {
 340                 platform_device_unregister(bt_platform);
 341                 return err;
 342         }
 343
 344         bt_class = class_create(THIS_MODULE, "bluetooth");
 345         if (IS_ERR(bt_class)) {
 346                 bus_unregister(&bt_bus);
 347                 platform_device_unregister(bt_platform);
 348                 return PTR_ERR(bt_class);
 349         }
 350
 351         return 0;
 352 }
 353
 354 void bt_sysfs_cleanup(void)
 355 {
 356         class_destroy(bt_class);
 357
 358         bus_unregister(&bt_bus);
 359
 360         platform_device_unregister(bt_platform);
 361 }