1 /* Bluetooth HCI driver model support. */ 2 3 #include <linux/kernel.h> 4 #include <linux/init.h> 5 6 #include <net/bluetooth/bluetooth.h> 7 #include <net/bluetooth/hci_core.h> 8 9 struct class *bt_class = NULL; 10 EXPORT_SYMBOL_GPL(bt_class); 11 12 static struct workqueue_struct *btaddconn; 13 static struct workqueue_struct *btdelconn; 14 15 static inline char *link_typetostr(int type) 16 { 17 switch (type) { 18 case ACL_LINK: 19 return "ACL"; 20 case SCO_LINK: 21 return "SCO"; 22 case ESCO_LINK: 23 return "eSCO"; 24 default: 25 return "UNKNOWN"; 26 } 27 } 28 29 static ssize_t show_link_type(struct device *dev, struct device_attribute *attr, char *buf) 30 { 31 struct hci_conn *conn = dev_get_drvdata(dev); 32 return sprintf(buf, "%s\n", link_typetostr(conn->type)); 33 } 34 35 static ssize_t show_link_address(struct device *dev, struct device_attribute *attr, char *buf) 36 { 37 struct hci_conn *conn = dev_get_drvdata(dev); 38 bdaddr_t bdaddr; 39 baswap(&bdaddr, &conn->dst); 40 return sprintf(buf, "%s\n", batostr(&bdaddr)); 41 } 42 43 static ssize_t show_link_features(struct device *dev, struct device_attribute *attr, char *buf) 44 { 45 struct hci_conn *conn = dev_get_drvdata(dev); 46 47 return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 48 conn->features[0], conn->features[1], 49 conn->features[2], conn->features[3], 50 conn->features[4], conn->features[5], 51 conn->features[6], conn->features[7]); 52 } 53 54 #define LINK_ATTR(_name,_mode,_show,_store) \ 55 struct device_attribute link_attr_##_name = __ATTR(_name,_mode,_show,_store) 56 57 static LINK_ATTR(type, S_IRUGO, show_link_type, NULL); 58 static LINK_ATTR(address, S_IRUGO, show_link_address, NULL); 59 static LINK_ATTR(features, S_IRUGO, show_link_features, NULL); 60 61 static struct attribute *bt_link_attrs[] = { 62 &link_attr_type.attr, 63 &link_attr_address.attr, 64 &link_attr_features.attr, 65 NULL 66 }; 67 68 static struct attribute_group bt_link_group = { 69 .attrs = bt_link_attrs, 70 }; 71 72 static struct attribute_group *bt_link_groups[] = { 73 &bt_link_group, 74 NULL 75 }; 76 77 static void bt_link_release(struct device *dev) 78 { 79 void *data = dev_get_drvdata(dev); 80 kfree(data); 81 } 82 83 static struct device_type bt_link = { 84 .name = "link", 85 .groups = bt_link_groups, 86 .release = bt_link_release, 87 }; 88 89 static void add_conn(struct work_struct *work) 90 { 91 struct hci_conn *conn = container_of(work, struct hci_conn, work); 92 93 flush_workqueue(btdelconn); 94 95 if (device_add(&conn->dev) < 0) { 96 BT_ERR("Failed to register connection device"); 97 return; 98 } 99 } 100 101 void hci_conn_add_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 dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle); 112 113 dev_set_drvdata(&conn->dev, conn); 114 115 device_initialize(&conn->dev); 116 117 INIT_WORK(&conn->work, add_conn); 118 119 queue_work(btaddconn, &conn->work); 120 } 121 122 /* 123 * The rfcomm tty device will possibly retain even when conn 124 * is down, and sysfs doesn't support move zombie device, 125 * so we should move the device before conn device is destroyed. 126 */ 127 static int __match_tty(struct device *dev, void *data) 128 { 129 return !strncmp(dev_name(dev), "rfcomm", 6); 130 } 131 132 static void del_conn(struct work_struct *work) 133 { 134 struct hci_conn *conn = container_of(work, struct hci_conn, work); 135 struct hci_dev *hdev = conn->hdev; 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 hci_dev_put(hdev); 150 } 151 152 void hci_conn_del_sysfs(struct hci_conn *conn) 153 { 154 BT_DBG("conn %p", conn); 155 156 if (!device_is_registered(&conn->dev)) 157 return; 158 159 INIT_WORK(&conn->work, del_conn); 160 161 queue_work(btdelconn, &conn->work); 162 } 163 164 static inline char *host_typetostr(int type) 165 { 166 switch (type) { 167 case HCI_VIRTUAL: 168 return "VIRTUAL"; 169 case HCI_USB: 170 return "USB"; 171 case HCI_PCCARD: 172 return "PCCARD"; 173 case HCI_UART: 174 return "UART"; 175 case HCI_RS232: 176 return "RS232"; 177 case HCI_PCI: 178 return "PCI"; 179 case HCI_SDIO: 180 return "SDIO"; 181 default: 182 return "UNKNOWN"; 183 } 184 } 185 186 static ssize_t show_type(struct device *dev, struct device_attribute *attr, char *buf) 187 { 188 struct hci_dev *hdev = dev_get_drvdata(dev); 189 return sprintf(buf, "%s\n", host_typetostr(hdev->type)); 190 } 191 192 static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf) 193 { 194 struct hci_dev *hdev = dev_get_drvdata(dev); 195 char name[249]; 196 int i; 197 198 for (i = 0; i < 248; i++) 199 name[i] = hdev->dev_name[i]; 200 201 name[248] = '\0'; 202 return sprintf(buf, "%s\n", name); 203 } 204 205 static ssize_t show_class(struct device *dev, struct device_attribute *attr, char *buf) 206 { 207 struct hci_dev *hdev = dev_get_drvdata(dev); 208 return sprintf(buf, "0x%.2x%.2x%.2x\n", 209 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]); 210 } 211 212 static ssize_t show_address(struct device *dev, struct device_attribute *attr, char *buf) 213 { 214 struct hci_dev *hdev = dev_get_drvdata(dev); 215 bdaddr_t bdaddr; 216 baswap(&bdaddr, &hdev->bdaddr); 217 return sprintf(buf, "%s\n", batostr(&bdaddr)); 218 } 219 220 static ssize_t show_features(struct device *dev, struct device_attribute *attr, char *buf) 221 { 222 struct hci_dev *hdev = dev_get_drvdata(dev); 223 224 return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", 225 hdev->features[0], hdev->features[1], 226 hdev->features[2], hdev->features[3], 227 hdev->features[4], hdev->features[5], 228 hdev->features[6], hdev->features[7]); 229 } 230 231 static ssize_t show_manufacturer(struct device *dev, struct device_attribute *attr, char *buf) 232 { 233 struct hci_dev *hdev = dev_get_drvdata(dev); 234 return sprintf(buf, "%d\n", hdev->manufacturer); 235 } 236 237 static ssize_t show_hci_version(struct device *dev, struct device_attribute *attr, char *buf) 238 { 239 struct hci_dev *hdev = dev_get_drvdata(dev); 240 return sprintf(buf, "%d\n", hdev->hci_ver); 241 } 242 243 static ssize_t show_hci_revision(struct device *dev, struct device_attribute *attr, char *buf) 244 { 245 struct hci_dev *hdev = dev_get_drvdata(dev); 246 return sprintf(buf, "%d\n", hdev->hci_rev); 247 } 248 249 static ssize_t show_inquiry_cache(struct device *dev, struct device_attribute *attr, char *buf) 250 { 251 struct hci_dev *hdev = dev_get_drvdata(dev); 252 struct inquiry_cache *cache = &hdev->inq_cache; 253 struct inquiry_entry *e; 254 int n = 0; 255 256 hci_dev_lock_bh(hdev); 257 258 for (e = cache->list; e; e = e->next) { 259 struct inquiry_data *data = &e->data; 260 bdaddr_t bdaddr; 261 baswap(&bdaddr, &data->bdaddr); 262 n += sprintf(buf + n, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 263 batostr(&bdaddr), 264 data->pscan_rep_mode, data->pscan_period_mode, 265 data->pscan_mode, data->dev_class[2], 266 data->dev_class[1], data->dev_class[0], 267 __le16_to_cpu(data->clock_offset), 268 data->rssi, data->ssp_mode, e->timestamp); 269 } 270 271 hci_dev_unlock_bh(hdev); 272 return n; 273 } 274 275 static ssize_t show_idle_timeout(struct device *dev, struct device_attribute *attr, char *buf) 276 { 277 struct hci_dev *hdev = dev_get_drvdata(dev); 278 return sprintf(buf, "%d\n", hdev->idle_timeout); 279 } 280 281 static ssize_t store_idle_timeout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 282 { 283 struct hci_dev *hdev = dev_get_drvdata(dev); 284 char *ptr; 285 __u32 val; 286 287 val = simple_strtoul(buf, &ptr, 10); 288 if (ptr == buf) 289 return -EINVAL; 290 291 if (val != 0 && (val < 500 || val > 3600000)) 292 return -EINVAL; 293 294 hdev->idle_timeout = val; 295 296 return count; 297 } 298 299 static ssize_t show_sniff_max_interval(struct device *dev, struct device_attribute *attr, char *buf) 300 { 301 struct hci_dev *hdev = dev_get_drvdata(dev); 302 return sprintf(buf, "%d\n", hdev->sniff_max_interval); 303 } 304 305 static ssize_t store_sniff_max_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 306 { 307 struct hci_dev *hdev = dev_get_drvdata(dev); 308 char *ptr; 309 __u16 val; 310 311 val = simple_strtoul(buf, &ptr, 10); 312 if (ptr == buf) 313 return -EINVAL; 314 315 if (val < 0x0002 || val > 0xFFFE || val % 2) 316 return -EINVAL; 317 318 if (val < hdev->sniff_min_interval) 319 return -EINVAL; 320 321 hdev->sniff_max_interval = val; 322 323 return count; 324 } 325 326 static ssize_t show_sniff_min_interval(struct device *dev, struct device_attribute *attr, char *buf) 327 { 328 struct hci_dev *hdev = dev_get_drvdata(dev); 329 return sprintf(buf, "%d\n", hdev->sniff_min_interval); 330 } 331 332 static ssize_t store_sniff_min_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 333 { 334 struct hci_dev *hdev = dev_get_drvdata(dev); 335 char *ptr; 336 __u16 val; 337 338 val = simple_strtoul(buf, &ptr, 10); 339 if (ptr == buf) 340 return -EINVAL; 341 342 if (val < 0x0002 || val > 0xFFFE || val % 2) 343 return -EINVAL; 344 345 if (val > hdev->sniff_max_interval) 346 return -EINVAL; 347 348 hdev->sniff_min_interval = val; 349 350 return count; 351 } 352 353 static DEVICE_ATTR(type, S_IRUGO, show_type, NULL); 354 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); 355 static DEVICE_ATTR(class, S_IRUGO, show_class, NULL); 356 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL); 357 static DEVICE_ATTR(features, S_IRUGO, show_features, NULL); 358 static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL); 359 static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL); 360 static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL); 361 static DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL); 362 363 static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR, 364 show_idle_timeout, store_idle_timeout); 365 static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR, 366 show_sniff_max_interval, store_sniff_max_interval); 367 static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR, 368 show_sniff_min_interval, store_sniff_min_interval); 369 370 static struct attribute *bt_host_attrs[] = { 371 &dev_attr_type.attr, 372 &dev_attr_name.attr, 373 &dev_attr_class.attr, 374 &dev_attr_address.attr, 375 &dev_attr_features.attr, 376 &dev_attr_manufacturer.attr, 377 &dev_attr_hci_version.attr, 378 &dev_attr_hci_revision.attr, 379 &dev_attr_inquiry_cache.attr, 380 &dev_attr_idle_timeout.attr, 381 &dev_attr_sniff_max_interval.attr, 382 &dev_attr_sniff_min_interval.attr, 383 NULL 384 }; 385 386 static struct attribute_group bt_host_group = { 387 .attrs = bt_host_attrs, 388 }; 389 390 static struct attribute_group *bt_host_groups[] = { 391 &bt_host_group, 392 NULL 393 }; 394 395 static void bt_host_release(struct device *dev) 396 { 397 void *data = dev_get_drvdata(dev); 398 kfree(data); 399 } 400 401 static struct device_type bt_host = { 402 .name = "host", 403 .groups = bt_host_groups, 404 .release = bt_host_release, 405 }; 406 407 int hci_register_sysfs(struct hci_dev *hdev) 408 { 409 struct device *dev = &hdev->dev; 410 int err; 411 412 BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); 413 414 dev->type = &bt_host; 415 dev->class = bt_class; 416 dev->parent = hdev->parent; 417 418 dev_set_name(dev, "%s", hdev->name); 419 420 dev_set_drvdata(dev, hdev); 421 422 err = device_register(dev); 423 if (err < 0) 424 return err; 425 426 return 0; 427 } 428 429 void hci_unregister_sysfs(struct hci_dev *hdev) 430 { 431 BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); 432 433 device_del(&hdev->dev); 434 } 435 436 int __init bt_sysfs_init(void) 437 { 438 btaddconn = create_singlethread_workqueue("btaddconn"); 439 if (!btaddconn) 440 return -ENOMEM; 441 442 btdelconn = create_singlethread_workqueue("btdelconn"); 443 if (!btdelconn) { 444 destroy_workqueue(btaddconn); 445 return -ENOMEM; 446 } 447 448 bt_class = class_create(THIS_MODULE, "bluetooth"); 449 if (IS_ERR(bt_class)) { 450 destroy_workqueue(btdelconn); 451 destroy_workqueue(btaddconn); 452 return PTR_ERR(bt_class); 453 } 454 455 return 0; 456 } 457 458 void bt_sysfs_cleanup(void) 459 { 460 destroy_workqueue(btaddconn); 461 destroy_workqueue(btdelconn); 462 463 class_destroy(bt_class); 464 } 465