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