Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* Bluetooth HCI driver model support. */ |
| 2 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 9 | struct class *bt_class = NULL; |
| 10 | EXPORT_SYMBOL_GPL(bt_class); |
| 11 | |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 12 | static struct workqueue_struct *bt_workq; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 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 | { |
Roger Quadros | f3784d8 | 2009-04-23 14:50:54 +0300 | [diff] [blame] | 90 | struct hci_conn *conn = container_of(work, struct hci_conn, work_add); |
Marcel Holtmann | 457ca7b | 2009-05-05 13:09:01 -0700 | [diff] [blame^] | 91 | struct hci_dev *hdev = conn->hdev; |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 92 | |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 93 | /* ensure previous del is complete */ |
| 94 | flush_work(&conn->work_del); |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 95 | |
Marcel Holtmann | 457ca7b | 2009-05-05 13:09:01 -0700 | [diff] [blame^] | 96 | dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle); |
| 97 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 98 | if (device_add(&conn->dev) < 0) { |
| 99 | BT_ERR("Failed to register connection device"); |
| 100 | return; |
| 101 | } |
| 102 | } |
| 103 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 104 | /* |
| 105 | * The rfcomm tty device will possibly retain even when conn |
| 106 | * is down, and sysfs doesn't support move zombie device, |
| 107 | * so we should move the device before conn device is destroyed. |
| 108 | */ |
| 109 | static int __match_tty(struct device *dev, void *data) |
| 110 | { |
Kay Sievers | fb28ad3 | 2008-11-10 13:55:14 -0800 | [diff] [blame] | 111 | return !strncmp(dev_name(dev), "rfcomm", 6); |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 112 | } |
| 113 | |
| 114 | static void del_conn(struct work_struct *work) |
| 115 | { |
Roger Quadros | f3784d8 | 2009-04-23 14:50:54 +0300 | [diff] [blame] | 116 | struct hci_conn *conn = container_of(work, struct hci_conn, work_del); |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 117 | struct hci_dev *hdev = conn->hdev; |
| 118 | |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 119 | /* ensure previous add is complete */ |
| 120 | flush_work(&conn->work_add); |
| 121 | |
| 122 | if (!device_is_registered(&conn->dev)) |
| 123 | return; |
Roger Quadros | f3784d8 | 2009-04-23 14:50:54 +0300 | [diff] [blame] | 124 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 125 | while (1) { |
| 126 | struct device *dev; |
| 127 | |
| 128 | dev = device_find_child(&conn->dev, NULL, __match_tty); |
| 129 | if (!dev) |
| 130 | break; |
Cornelia Huck | ffa6a70 | 2009-03-04 12:44:00 +0100 | [diff] [blame] | 131 | device_move(dev, NULL, DPM_ORDER_DEV_LAST); |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 132 | put_device(dev); |
| 133 | } |
| 134 | |
| 135 | device_del(&conn->dev); |
| 136 | put_device(&conn->dev); |
| 137 | hci_dev_put(hdev); |
| 138 | } |
| 139 | |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 140 | void hci_conn_init_sysfs(struct hci_conn *conn) |
| 141 | { |
| 142 | struct hci_dev *hdev = conn->hdev; |
| 143 | |
| 144 | BT_DBG("conn %p", conn); |
| 145 | |
| 146 | conn->dev.type = &bt_link; |
| 147 | conn->dev.class = bt_class; |
| 148 | conn->dev.parent = &hdev->dev; |
| 149 | |
| 150 | dev_set_drvdata(&conn->dev, conn); |
| 151 | |
| 152 | device_initialize(&conn->dev); |
| 153 | |
| 154 | INIT_WORK(&conn->work_add, add_conn); |
| 155 | INIT_WORK(&conn->work_del, del_conn); |
| 156 | } |
| 157 | |
| 158 | void hci_conn_add_sysfs(struct hci_conn *conn) |
| 159 | { |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 160 | BT_DBG("conn %p", conn); |
| 161 | |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 162 | queue_work(bt_workq, &conn->work_add); |
| 163 | } |
| 164 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 165 | void hci_conn_del_sysfs(struct hci_conn *conn) |
| 166 | { |
| 167 | BT_DBG("conn %p", conn); |
| 168 | |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 169 | queue_work(bt_workq, &conn->work_del); |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 170 | } |
| 171 | |
| 172 | static inline char *host_typetostr(int type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | { |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 174 | switch (type) { |
Marcel Holtmann | 0ac5393 | 2006-07-08 13:57:15 +0200 | [diff] [blame] | 175 | case HCI_VIRTUAL: |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 176 | return "VIRTUAL"; |
| 177 | case HCI_USB: |
| 178 | return "USB"; |
| 179 | case HCI_PCCARD: |
| 180 | return "PCCARD"; |
| 181 | case HCI_UART: |
| 182 | return "UART"; |
| 183 | case HCI_RS232: |
| 184 | return "RS232"; |
| 185 | case HCI_PCI: |
| 186 | return "PCI"; |
Marcel Holtmann | 0ac5393 | 2006-07-08 13:57:15 +0200 | [diff] [blame] | 187 | case HCI_SDIO: |
| 188 | return "SDIO"; |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 189 | default: |
| 190 | return "UNKNOWN"; |
| 191 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | } |
| 193 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 194 | static ssize_t show_type(struct device *dev, struct device_attribute *attr, char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 196 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 197 | return sprintf(buf, "%s\n", host_typetostr(hdev->type)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | } |
| 199 | |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 200 | static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf) |
| 201 | { |
| 202 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 203 | char name[249]; |
| 204 | int i; |
| 205 | |
| 206 | for (i = 0; i < 248; i++) |
| 207 | name[i] = hdev->dev_name[i]; |
| 208 | |
| 209 | name[248] = '\0'; |
| 210 | return sprintf(buf, "%s\n", name); |
| 211 | } |
| 212 | |
| 213 | static ssize_t show_class(struct device *dev, struct device_attribute *attr, char *buf) |
| 214 | { |
| 215 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 216 | return sprintf(buf, "0x%.2x%.2x%.2x\n", |
| 217 | hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]); |
| 218 | } |
| 219 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 220 | static ssize_t show_address(struct device *dev, struct device_attribute *attr, char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 222 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | bdaddr_t bdaddr; |
| 224 | baswap(&bdaddr, &hdev->bdaddr); |
| 225 | return sprintf(buf, "%s\n", batostr(&bdaddr)); |
| 226 | } |
| 227 | |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 228 | static ssize_t show_features(struct device *dev, struct device_attribute *attr, char *buf) |
| 229 | { |
| 230 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 231 | |
| 232 | return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", |
| 233 | hdev->features[0], hdev->features[1], |
| 234 | hdev->features[2], hdev->features[3], |
| 235 | hdev->features[4], hdev->features[5], |
| 236 | hdev->features[6], hdev->features[7]); |
| 237 | } |
| 238 | |
Marcel Holtmann | 1143e5a | 2006-09-23 09:57:20 +0200 | [diff] [blame] | 239 | static ssize_t show_manufacturer(struct device *dev, struct device_attribute *attr, char *buf) |
| 240 | { |
| 241 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 242 | return sprintf(buf, "%d\n", hdev->manufacturer); |
| 243 | } |
| 244 | |
| 245 | static ssize_t show_hci_version(struct device *dev, struct device_attribute *attr, char *buf) |
| 246 | { |
| 247 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 248 | return sprintf(buf, "%d\n", hdev->hci_ver); |
| 249 | } |
| 250 | |
| 251 | static ssize_t show_hci_revision(struct device *dev, struct device_attribute *attr, char *buf) |
| 252 | { |
| 253 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 254 | return sprintf(buf, "%d\n", hdev->hci_rev); |
| 255 | } |
| 256 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 257 | static ssize_t show_inquiry_cache(struct device *dev, struct device_attribute *attr, char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 259 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | struct inquiry_cache *cache = &hdev->inq_cache; |
| 261 | struct inquiry_entry *e; |
| 262 | int n = 0; |
| 263 | |
| 264 | hci_dev_lock_bh(hdev); |
| 265 | |
| 266 | for (e = cache->list; e; e = e->next) { |
| 267 | struct inquiry_data *data = &e->data; |
| 268 | bdaddr_t bdaddr; |
| 269 | baswap(&bdaddr, &data->bdaddr); |
Marcel Holtmann | a8bd28ba | 2008-07-14 20:13:49 +0200 | [diff] [blame] | 270 | n += sprintf(buf + n, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | batostr(&bdaddr), |
Marcel Holtmann | a8bd28ba | 2008-07-14 20:13:49 +0200 | [diff] [blame] | 272 | data->pscan_rep_mode, data->pscan_period_mode, |
| 273 | data->pscan_mode, data->dev_class[2], |
| 274 | data->dev_class[1], data->dev_class[0], |
| 275 | __le16_to_cpu(data->clock_offset), |
| 276 | data->rssi, data->ssp_mode, e->timestamp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | } |
| 278 | |
| 279 | hci_dev_unlock_bh(hdev); |
| 280 | return n; |
| 281 | } |
| 282 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 283 | static ssize_t show_idle_timeout(struct device *dev, struct device_attribute *attr, char *buf) |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 284 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 285 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 286 | return sprintf(buf, "%d\n", hdev->idle_timeout); |
| 287 | } |
| 288 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 289 | static ssize_t store_idle_timeout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 290 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 291 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 292 | char *ptr; |
| 293 | __u32 val; |
| 294 | |
| 295 | val = simple_strtoul(buf, &ptr, 10); |
| 296 | if (ptr == buf) |
| 297 | return -EINVAL; |
| 298 | |
| 299 | if (val != 0 && (val < 500 || val > 3600000)) |
| 300 | return -EINVAL; |
| 301 | |
| 302 | hdev->idle_timeout = val; |
| 303 | |
| 304 | return count; |
| 305 | } |
| 306 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 307 | static ssize_t show_sniff_max_interval(struct device *dev, struct device_attribute *attr, char *buf) |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 308 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 309 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 310 | return sprintf(buf, "%d\n", hdev->sniff_max_interval); |
| 311 | } |
| 312 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 313 | static ssize_t store_sniff_max_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 314 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 315 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 316 | char *ptr; |
| 317 | __u16 val; |
| 318 | |
| 319 | val = simple_strtoul(buf, &ptr, 10); |
| 320 | if (ptr == buf) |
| 321 | return -EINVAL; |
| 322 | |
| 323 | if (val < 0x0002 || val > 0xFFFE || val % 2) |
| 324 | return -EINVAL; |
| 325 | |
| 326 | if (val < hdev->sniff_min_interval) |
| 327 | return -EINVAL; |
| 328 | |
| 329 | hdev->sniff_max_interval = val; |
| 330 | |
| 331 | return count; |
| 332 | } |
| 333 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 334 | static ssize_t show_sniff_min_interval(struct device *dev, struct device_attribute *attr, char *buf) |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 335 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 336 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 337 | return sprintf(buf, "%d\n", hdev->sniff_min_interval); |
| 338 | } |
| 339 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 340 | static ssize_t store_sniff_min_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 341 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 342 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 343 | char *ptr; |
| 344 | __u16 val; |
| 345 | |
| 346 | val = simple_strtoul(buf, &ptr, 10); |
| 347 | if (ptr == buf) |
| 348 | return -EINVAL; |
| 349 | |
| 350 | if (val < 0x0002 || val > 0xFFFE || val % 2) |
| 351 | return -EINVAL; |
| 352 | |
| 353 | if (val > hdev->sniff_max_interval) |
| 354 | return -EINVAL; |
| 355 | |
| 356 | hdev->sniff_min_interval = val; |
| 357 | |
| 358 | return count; |
| 359 | } |
| 360 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 361 | static DEVICE_ATTR(type, S_IRUGO, show_type, NULL); |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 362 | static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); |
| 363 | static DEVICE_ATTR(class, S_IRUGO, show_class, NULL); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 364 | static DEVICE_ATTR(address, S_IRUGO, show_address, NULL); |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 365 | static DEVICE_ATTR(features, S_IRUGO, show_features, NULL); |
Marcel Holtmann | 1143e5a | 2006-09-23 09:57:20 +0200 | [diff] [blame] | 366 | static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL); |
| 367 | static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL); |
| 368 | static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 369 | static DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 370 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 371 | static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR, |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 372 | show_idle_timeout, store_idle_timeout); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 373 | static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR, |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 374 | show_sniff_max_interval, store_sniff_max_interval); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 375 | static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR, |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 376 | show_sniff_min_interval, store_sniff_min_interval); |
| 377 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 378 | static struct attribute *bt_host_attrs[] = { |
| 379 | &dev_attr_type.attr, |
| 380 | &dev_attr_name.attr, |
| 381 | &dev_attr_class.attr, |
| 382 | &dev_attr_address.attr, |
| 383 | &dev_attr_features.attr, |
| 384 | &dev_attr_manufacturer.attr, |
| 385 | &dev_attr_hci_version.attr, |
| 386 | &dev_attr_hci_revision.attr, |
| 387 | &dev_attr_inquiry_cache.attr, |
| 388 | &dev_attr_idle_timeout.attr, |
| 389 | &dev_attr_sniff_max_interval.attr, |
| 390 | &dev_attr_sniff_min_interval.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | NULL |
| 392 | }; |
| 393 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 394 | static struct attribute_group bt_host_group = { |
| 395 | .attrs = bt_host_attrs, |
| 396 | }; |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 397 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 398 | static struct attribute_group *bt_host_groups[] = { |
| 399 | &bt_host_group, |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 400 | NULL |
| 401 | }; |
| 402 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 403 | static void bt_host_release(struct device *dev) |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 404 | { |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 405 | void *data = dev_get_drvdata(dev); |
| 406 | kfree(data); |
| 407 | } |
| 408 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 409 | static struct device_type bt_host = { |
| 410 | .name = "host", |
| 411 | .groups = bt_host_groups, |
| 412 | .release = bt_host_release, |
| 413 | }; |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 414 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 415 | int hci_register_sysfs(struct hci_dev *hdev) |
| 416 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 417 | struct device *dev = &hdev->dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 418 | int err; |
| 419 | |
| 420 | BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); |
| 421 | |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 422 | dev->type = &bt_host; |
| 423 | dev->class = bt_class; |
Marcel Holtmann | e9c4bec | 2006-10-15 17:30:50 +0200 | [diff] [blame] | 424 | dev->parent = hdev->parent; |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 425 | |
Marcel Holtmann | 2e79299 | 2008-11-30 12:17:29 +0100 | [diff] [blame] | 426 | dev_set_name(dev, "%s", hdev->name); |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 427 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 428 | dev_set_drvdata(dev, hdev); |
| 429 | |
| 430 | err = device_register(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 431 | if (err < 0) |
| 432 | return err; |
| 433 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 434 | return 0; |
| 435 | } |
| 436 | |
| 437 | void hci_unregister_sysfs(struct hci_dev *hdev) |
| 438 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); |
| 440 | |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 441 | device_del(&hdev->dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 442 | } |
| 443 | |
| 444 | int __init bt_sysfs_init(void) |
| 445 | { |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 446 | bt_workq = create_singlethread_workqueue("bluetooth"); |
| 447 | if (!bt_workq) |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 448 | return -ENOMEM; |
Dave Young | 5396c93 | 2008-01-31 18:33:10 -0800 | [diff] [blame] | 449 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 450 | bt_class = class_create(THIS_MODULE, "bluetooth"); |
| 451 | if (IS_ERR(bt_class)) { |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 452 | destroy_workqueue(bt_workq); |
Marcel Holtmann | 90855d7 | 2008-08-18 13:23:53 +0200 | [diff] [blame] | 453 | return PTR_ERR(bt_class); |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 454 | } |
| 455 | |
| 456 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | } |
| 458 | |
Arnaud Patard | 860e13b | 2006-09-28 15:29:37 -0700 | [diff] [blame] | 459 | void bt_sysfs_cleanup(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 460 | { |
Marcel Holtmann | a67e899 | 2009-05-02 18:24:06 -0700 | [diff] [blame] | 461 | destroy_workqueue(bt_workq); |
Dave Young | 5396c93 | 2008-01-31 18:33:10 -0800 | [diff] [blame] | 462 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 463 | class_destroy(bt_class); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | } |