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_add(&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 device_initialize(&conn->dev); 276 277 INIT_WORK(&conn->work, add_conn); 278 279 schedule_work(&conn->work); 280 } 281 282 static void del_conn(struct work_struct *work) 283 { 284 struct hci_conn *conn = container_of(work, struct hci_conn, work); 285 device_del(&conn->dev); 286 } 287 288 void hci_conn_del_sysfs(struct hci_conn *conn) 289 { 290 BT_DBG("conn %p", conn); 291 292 if (!device_is_registered(&conn->dev)) 293 return; 294 295 INIT_WORK(&conn->work, del_conn); 296 297 schedule_work(&conn->work); 298 } 299 300 int hci_register_sysfs(struct hci_dev *hdev) 301 { 302 struct device *dev = &hdev->dev; 303 unsigned int i; 304 int err; 305 306 BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); 307 308 dev->bus = &bt_bus; 309 dev->parent = hdev->parent; 310 311 strlcpy(dev->bus_id, hdev->name, BUS_ID_SIZE); 312 313 dev->release = bt_release; 314 315 dev_set_drvdata(dev, hdev); 316 317 err = device_register(dev); 318 if (err < 0) 319 return err; 320 321 for (i = 0; bt_attrs[i]; i++) 322 if (device_create_file(dev, bt_attrs[i]) < 0) 323 BT_ERR("Failed to create device attribute"); 324 325 if (sysfs_create_link(&bt_class->subsys.kobj, 326 &dev->kobj, kobject_name(&dev->kobj)) < 0) 327 BT_ERR("Failed to create class symlink"); 328 329 return 0; 330 } 331 332 void hci_unregister_sysfs(struct hci_dev *hdev) 333 { 334 BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); 335 336 sysfs_remove_link(&bt_class->subsys.kobj, 337 kobject_name(&hdev->dev.kobj)); 338 339 device_del(&hdev->dev); 340 } 341 342 int __init bt_sysfs_init(void) 343 { 344 int err; 345 346 bt_platform = platform_device_register_simple("bluetooth", -1, NULL, 0); 347 if (IS_ERR(bt_platform)) 348 return PTR_ERR(bt_platform); 349 350 err = bus_register(&bt_bus); 351 if (err < 0) { 352 platform_device_unregister(bt_platform); 353 return err; 354 } 355 356 bt_class = class_create(THIS_MODULE, "bluetooth"); 357 if (IS_ERR(bt_class)) { 358 bus_unregister(&bt_bus); 359 platform_device_unregister(bt_platform); 360 return PTR_ERR(bt_class); 361 } 362 363 return 0; 364 } 365 366 void bt_sysfs_cleanup(void) 367 { 368 class_destroy(bt_class); 369 370 bus_unregister(&bt_bus); 371 372 platform_device_unregister(bt_platform); 373 } 374