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 | |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 6 | #include <linux/platform_device.h> |
| 7 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 15 | static struct workqueue_struct *btaddconn; |
| 16 | static struct workqueue_struct *btdelconn; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 18 | static inline char *typetostr(int type) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | { |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 20 | switch (type) { |
Marcel Holtmann | 0ac5393 | 2006-07-08 13:57:15 +0200 | [diff] [blame] | 21 | case HCI_VIRTUAL: |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 22 | return "VIRTUAL"; |
| 23 | case HCI_USB: |
| 24 | return "USB"; |
| 25 | case HCI_PCCARD: |
| 26 | return "PCCARD"; |
| 27 | case HCI_UART: |
| 28 | return "UART"; |
| 29 | case HCI_RS232: |
| 30 | return "RS232"; |
| 31 | case HCI_PCI: |
| 32 | return "PCI"; |
Marcel Holtmann | 0ac5393 | 2006-07-08 13:57:15 +0200 | [diff] [blame] | 33 | case HCI_SDIO: |
| 34 | return "SDIO"; |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 35 | default: |
| 36 | return "UNKNOWN"; |
| 37 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | } |
| 39 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 40 | 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] | 41 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 42 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 43 | return sprintf(buf, "%s\n", typetostr(hdev->type)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | } |
| 45 | |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 46 | static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf) |
| 47 | { |
| 48 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 49 | char name[249]; |
| 50 | int i; |
| 51 | |
| 52 | for (i = 0; i < 248; i++) |
| 53 | name[i] = hdev->dev_name[i]; |
| 54 | |
| 55 | name[248] = '\0'; |
| 56 | return sprintf(buf, "%s\n", name); |
| 57 | } |
| 58 | |
| 59 | static ssize_t show_class(struct device *dev, struct device_attribute *attr, char *buf) |
| 60 | { |
| 61 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 62 | return sprintf(buf, "0x%.2x%.2x%.2x\n", |
| 63 | hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]); |
| 64 | } |
| 65 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 66 | 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] | 67 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 68 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | bdaddr_t bdaddr; |
| 70 | baswap(&bdaddr, &hdev->bdaddr); |
| 71 | return sprintf(buf, "%s\n", batostr(&bdaddr)); |
| 72 | } |
| 73 | |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 74 | static ssize_t show_features(struct device *dev, struct device_attribute *attr, char *buf) |
| 75 | { |
| 76 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 77 | |
| 78 | return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", |
| 79 | hdev->features[0], hdev->features[1], |
| 80 | hdev->features[2], hdev->features[3], |
| 81 | hdev->features[4], hdev->features[5], |
| 82 | hdev->features[6], hdev->features[7]); |
| 83 | } |
| 84 | |
Marcel Holtmann | 1143e5a | 2006-09-23 09:57:20 +0200 | [diff] [blame] | 85 | static ssize_t show_manufacturer(struct device *dev, struct device_attribute *attr, char *buf) |
| 86 | { |
| 87 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 88 | return sprintf(buf, "%d\n", hdev->manufacturer); |
| 89 | } |
| 90 | |
| 91 | static ssize_t show_hci_version(struct device *dev, struct device_attribute *attr, char *buf) |
| 92 | { |
| 93 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 94 | return sprintf(buf, "%d\n", hdev->hci_ver); |
| 95 | } |
| 96 | |
| 97 | static ssize_t show_hci_revision(struct device *dev, struct device_attribute *attr, char *buf) |
| 98 | { |
| 99 | struct hci_dev *hdev = dev_get_drvdata(dev); |
| 100 | return sprintf(buf, "%d\n", hdev->hci_rev); |
| 101 | } |
| 102 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 103 | 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] | 104 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 105 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | struct inquiry_cache *cache = &hdev->inq_cache; |
| 107 | struct inquiry_entry *e; |
| 108 | int n = 0; |
| 109 | |
| 110 | hci_dev_lock_bh(hdev); |
| 111 | |
| 112 | for (e = cache->list; e; e = e->next) { |
| 113 | struct inquiry_data *data = &e->data; |
| 114 | bdaddr_t bdaddr; |
| 115 | baswap(&bdaddr, &data->bdaddr); |
Marcel Holtmann | a8bd28b | 2008-07-14 20:13:49 +0200 | [diff] [blame] | 116 | 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] | 117 | batostr(&bdaddr), |
Marcel Holtmann | a8bd28b | 2008-07-14 20:13:49 +0200 | [diff] [blame] | 118 | data->pscan_rep_mode, data->pscan_period_mode, |
| 119 | data->pscan_mode, data->dev_class[2], |
| 120 | data->dev_class[1], data->dev_class[0], |
| 121 | __le16_to_cpu(data->clock_offset), |
| 122 | data->rssi, data->ssp_mode, e->timestamp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | hci_dev_unlock_bh(hdev); |
| 126 | return n; |
| 127 | } |
| 128 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 129 | 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] | 130 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 131 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 132 | return sprintf(buf, "%d\n", hdev->idle_timeout); |
| 133 | } |
| 134 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 135 | 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] | 136 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 137 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 138 | char *ptr; |
| 139 | __u32 val; |
| 140 | |
| 141 | val = simple_strtoul(buf, &ptr, 10); |
| 142 | if (ptr == buf) |
| 143 | return -EINVAL; |
| 144 | |
| 145 | if (val != 0 && (val < 500 || val > 3600000)) |
| 146 | return -EINVAL; |
| 147 | |
| 148 | hdev->idle_timeout = val; |
| 149 | |
| 150 | return count; |
| 151 | } |
| 152 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 153 | 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] | 154 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 155 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 156 | return sprintf(buf, "%d\n", hdev->sniff_max_interval); |
| 157 | } |
| 158 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 159 | 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] | 160 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 161 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 162 | char *ptr; |
| 163 | __u16 val; |
| 164 | |
| 165 | val = simple_strtoul(buf, &ptr, 10); |
| 166 | if (ptr == buf) |
| 167 | return -EINVAL; |
| 168 | |
| 169 | if (val < 0x0002 || val > 0xFFFE || val % 2) |
| 170 | return -EINVAL; |
| 171 | |
| 172 | if (val < hdev->sniff_min_interval) |
| 173 | return -EINVAL; |
| 174 | |
| 175 | hdev->sniff_max_interval = val; |
| 176 | |
| 177 | return count; |
| 178 | } |
| 179 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 180 | 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] | 181 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 182 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 183 | return sprintf(buf, "%d\n", hdev->sniff_min_interval); |
| 184 | } |
| 185 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 186 | 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] | 187 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 188 | struct hci_dev *hdev = dev_get_drvdata(dev); |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 189 | char *ptr; |
| 190 | __u16 val; |
| 191 | |
| 192 | val = simple_strtoul(buf, &ptr, 10); |
| 193 | if (ptr == buf) |
| 194 | return -EINVAL; |
| 195 | |
| 196 | if (val < 0x0002 || val > 0xFFFE || val % 2) |
| 197 | return -EINVAL; |
| 198 | |
| 199 | if (val > hdev->sniff_max_interval) |
| 200 | return -EINVAL; |
| 201 | |
| 202 | hdev->sniff_min_interval = val; |
| 203 | |
| 204 | return count; |
| 205 | } |
| 206 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 207 | static DEVICE_ATTR(type, S_IRUGO, show_type, NULL); |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 208 | static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); |
| 209 | static DEVICE_ATTR(class, S_IRUGO, show_class, NULL); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 210 | static DEVICE_ATTR(address, S_IRUGO, show_address, NULL); |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 211 | static DEVICE_ATTR(features, S_IRUGO, show_features, NULL); |
Marcel Holtmann | 1143e5a | 2006-09-23 09:57:20 +0200 | [diff] [blame] | 212 | static DEVICE_ATTR(manufacturer, S_IRUGO, show_manufacturer, NULL); |
| 213 | static DEVICE_ATTR(hci_version, S_IRUGO, show_hci_version, NULL); |
| 214 | static DEVICE_ATTR(hci_revision, S_IRUGO, show_hci_revision, NULL); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 215 | static DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 217 | static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR, |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 218 | show_idle_timeout, store_idle_timeout); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 219 | static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR, |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 220 | show_sniff_max_interval, store_sniff_max_interval); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 221 | static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR, |
Marcel Holtmann | 04837f6 | 2006-07-03 10:02:33 +0200 | [diff] [blame] | 222 | show_sniff_min_interval, store_sniff_min_interval); |
| 223 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 224 | static struct device_attribute *bt_attrs[] = { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 225 | &dev_attr_type, |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 226 | &dev_attr_name, |
| 227 | &dev_attr_class, |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 228 | &dev_attr_address, |
Marcel Holtmann | a9de924 | 2007-10-20 13:33:56 +0200 | [diff] [blame] | 229 | &dev_attr_features, |
Marcel Holtmann | 1143e5a | 2006-09-23 09:57:20 +0200 | [diff] [blame] | 230 | &dev_attr_manufacturer, |
| 231 | &dev_attr_hci_version, |
| 232 | &dev_attr_hci_revision, |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 233 | &dev_attr_inquiry_cache, |
| 234 | &dev_attr_idle_timeout, |
| 235 | &dev_attr_sniff_max_interval, |
| 236 | &dev_attr_sniff_min_interval, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | NULL |
| 238 | }; |
| 239 | |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 240 | static ssize_t show_conn_type(struct device *dev, struct device_attribute *attr, char *buf) |
| 241 | { |
| 242 | struct hci_conn *conn = dev_get_drvdata(dev); |
| 243 | return sprintf(buf, "%s\n", conn->type == ACL_LINK ? "ACL" : "SCO"); |
| 244 | } |
| 245 | |
| 246 | static ssize_t show_conn_address(struct device *dev, struct device_attribute *attr, char *buf) |
| 247 | { |
| 248 | struct hci_conn *conn = dev_get_drvdata(dev); |
| 249 | bdaddr_t bdaddr; |
| 250 | baswap(&bdaddr, &conn->dst); |
| 251 | return sprintf(buf, "%s\n", batostr(&bdaddr)); |
| 252 | } |
| 253 | |
Marcel Holtmann | a8bd28b | 2008-07-14 20:13:49 +0200 | [diff] [blame] | 254 | static ssize_t show_conn_features(struct device *dev, struct device_attribute *attr, char *buf) |
| 255 | { |
| 256 | struct hci_conn *conn = dev_get_drvdata(dev); |
| 257 | |
| 258 | return sprintf(buf, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n", |
| 259 | conn->features[0], conn->features[1], |
| 260 | conn->features[2], conn->features[3], |
| 261 | conn->features[4], conn->features[5], |
| 262 | conn->features[6], conn->features[7]); |
| 263 | } |
| 264 | |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 265 | #define CONN_ATTR(_name,_mode,_show,_store) \ |
| 266 | struct device_attribute conn_attr_##_name = __ATTR(_name,_mode,_show,_store) |
| 267 | |
| 268 | static CONN_ATTR(type, S_IRUGO, show_conn_type, NULL); |
| 269 | static CONN_ATTR(address, S_IRUGO, show_conn_address, NULL); |
Marcel Holtmann | a8bd28b | 2008-07-14 20:13:49 +0200 | [diff] [blame] | 270 | static CONN_ATTR(features, S_IRUGO, show_conn_features, NULL); |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 271 | |
| 272 | static struct device_attribute *conn_attrs[] = { |
| 273 | &conn_attr_type, |
| 274 | &conn_attr_address, |
Marcel Holtmann | a8bd28b | 2008-07-14 20:13:49 +0200 | [diff] [blame] | 275 | &conn_attr_features, |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 276 | NULL |
| 277 | }; |
| 278 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 279 | struct class *bt_class = NULL; |
Marcel Holtmann | be9d122 | 2005-11-08 09:57:38 -0800 | [diff] [blame] | 280 | EXPORT_SYMBOL_GPL(bt_class); |
| 281 | |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 282 | static struct bus_type bt_bus = { |
| 283 | .name = "bluetooth", |
| 284 | }; |
| 285 | |
| 286 | static struct platform_device *bt_platform; |
| 287 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 288 | static void bt_release(struct device *dev) |
| 289 | { |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 290 | void *data = dev_get_drvdata(dev); |
| 291 | kfree(data); |
| 292 | } |
| 293 | |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 294 | static void add_conn(struct work_struct *work) |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 295 | { |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 296 | struct hci_conn *conn = container_of(work, struct hci_conn, work); |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 297 | int i; |
| 298 | |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 299 | flush_workqueue(btdelconn); |
Dave Young | 5396c93 | 2008-01-31 18:33:10 -0800 | [diff] [blame] | 300 | |
Marcel Holtmann | c893779 | 2007-01-08 02:16:38 +0100 | [diff] [blame] | 301 | if (device_add(&conn->dev) < 0) { |
Marcel Holtmann | df5c37e | 2006-10-15 17:30:45 +0200 | [diff] [blame] | 302 | BT_ERR("Failed to register connection device"); |
| 303 | return; |
| 304 | } |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 305 | |
| 306 | for (i = 0; conn_attrs[i]; i++) |
Marcel Holtmann | df5c37e | 2006-10-15 17:30:45 +0200 | [diff] [blame] | 307 | if (device_create_file(&conn->dev, conn_attrs[i]) < 0) |
| 308 | BT_ERR("Failed to create connection attribute"); |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 309 | } |
| 310 | |
| 311 | void hci_conn_add_sysfs(struct hci_conn *conn) |
| 312 | { |
| 313 | struct hci_dev *hdev = conn->hdev; |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 314 | |
| 315 | BT_DBG("conn %p", conn); |
| 316 | |
Marcel Holtmann | e52726d | 2006-11-18 22:14:05 +0100 | [diff] [blame] | 317 | conn->dev.bus = &bt_bus; |
| 318 | conn->dev.parent = &hdev->dev; |
| 319 | |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 320 | conn->dev.release = bt_release; |
| 321 | |
Marcel Holtmann | 7d0db0a | 2008-07-14 20:13:51 +0200 | [diff] [blame] | 322 | snprintf(conn->dev.bus_id, BUS_ID_SIZE, "%s:%d", |
| 323 | hdev->name, conn->handle); |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 324 | |
| 325 | dev_set_drvdata(&conn->dev, conn); |
| 326 | |
Marcel Holtmann | c893779 | 2007-01-08 02:16:38 +0100 | [diff] [blame] | 327 | device_initialize(&conn->dev); |
| 328 | |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 329 | INIT_WORK(&conn->work, add_conn); |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 330 | |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 331 | queue_work(btaddconn, &conn->work); |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 332 | } |
| 333 | |
Dave Young | 8ac62dc | 2008-02-18 20:45:41 -0800 | [diff] [blame] | 334 | /* |
| 335 | * The rfcomm tty device will possibly retain even when conn |
| 336 | * is down, and sysfs doesn't support move zombie device, |
| 337 | * so we should move the device before conn device is destroyed. |
| 338 | */ |
Dave Young | acea685 | 2008-01-21 22:35:21 -0800 | [diff] [blame] | 339 | static int __match_tty(struct device *dev, void *data) |
| 340 | { |
Dave Young | 8ac62dc | 2008-02-18 20:45:41 -0800 | [diff] [blame] | 341 | return !strncmp(dev->bus_id, "rfcomm", 6); |
Dave Young | acea685 | 2008-01-21 22:35:21 -0800 | [diff] [blame] | 342 | } |
| 343 | |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 344 | static void del_conn(struct work_struct *work) |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 345 | { |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 346 | struct hci_conn *conn = container_of(work, struct hci_conn, work); |
Dave Young | 0cd63c8 | 2008-02-18 20:44:01 -0800 | [diff] [blame] | 347 | struct hci_dev *hdev = conn->hdev; |
Dave Young | acea685 | 2008-01-21 22:35:21 -0800 | [diff] [blame] | 348 | |
David S. Miller | 988d009 | 2008-02-18 00:20:50 -0800 | [diff] [blame] | 349 | while (1) { |
| 350 | struct device *dev; |
| 351 | |
| 352 | dev = device_find_child(&conn->dev, NULL, __match_tty); |
| 353 | if (!dev) |
| 354 | break; |
Dave Young | acea685 | 2008-01-21 22:35:21 -0800 | [diff] [blame] | 355 | device_move(dev, NULL); |
| 356 | put_device(dev); |
| 357 | } |
Dave Young | 0cd63c8 | 2008-02-18 20:44:01 -0800 | [diff] [blame] | 358 | |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 359 | device_del(&conn->dev); |
Dave Young | 38b7da0 | 2007-12-29 19:17:47 -0800 | [diff] [blame] | 360 | put_device(&conn->dev); |
Dave Young | 0cd63c8 | 2008-02-18 20:44:01 -0800 | [diff] [blame] | 361 | hci_dev_put(hdev); |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 362 | } |
| 363 | |
| 364 | void hci_conn_del_sysfs(struct hci_conn *conn) |
| 365 | { |
| 366 | BT_DBG("conn %p", conn); |
| 367 | |
Marcel Holtmann | c893779 | 2007-01-08 02:16:38 +0100 | [diff] [blame] | 368 | if (!device_is_registered(&conn->dev)) |
| 369 | return; |
| 370 | |
David Howells | c402895 | 2006-11-22 14:57:56 +0000 | [diff] [blame] | 371 | INIT_WORK(&conn->work, del_conn); |
Marcel Holtmann | b219e3a | 2006-07-06 12:38:46 +0200 | [diff] [blame] | 372 | |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 373 | queue_work(btdelconn, &conn->work); |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 374 | } |
| 375 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | int hci_register_sysfs(struct hci_dev *hdev) |
| 377 | { |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 378 | struct device *dev = &hdev->dev; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | unsigned int i; |
| 380 | int err; |
| 381 | |
| 382 | BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); |
| 383 | |
Marcel Holtmann | 53c1d4b | 2007-05-05 00:36:03 +0200 | [diff] [blame] | 384 | dev->bus = &bt_bus; |
Marcel Holtmann | e9c4bec | 2006-10-15 17:30:50 +0200 | [diff] [blame] | 385 | dev->parent = hdev->parent; |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 386 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 387 | strlcpy(dev->bus_id, hdev->name, BUS_ID_SIZE); |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 388 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 389 | dev->release = bt_release; |
| 390 | |
| 391 | dev_set_drvdata(dev, hdev); |
| 392 | |
| 393 | err = device_register(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 394 | if (err < 0) |
| 395 | return err; |
| 396 | |
| 397 | for (i = 0; bt_attrs[i]; i++) |
Marcel Holtmann | df5c37e | 2006-10-15 17:30:45 +0200 | [diff] [blame] | 398 | if (device_create_file(dev, bt_attrs[i]) < 0) |
| 399 | BT_ERR("Failed to create device attribute"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | |
| 401 | return 0; |
| 402 | } |
| 403 | |
| 404 | void hci_unregister_sysfs(struct hci_dev *hdev) |
| 405 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type); |
| 407 | |
Marcel Holtmann | 4d0eb00 | 2006-07-06 12:34:41 +0200 | [diff] [blame] | 408 | device_del(&hdev->dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | } |
| 410 | |
| 411 | int __init bt_sysfs_init(void) |
| 412 | { |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 413 | int err; |
| 414 | |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 415 | btaddconn = create_singlethread_workqueue("btaddconn"); |
| 416 | if (!btaddconn) { |
| 417 | err = -ENOMEM; |
| 418 | goto out; |
| 419 | } |
Dave Young | 5396c93 | 2008-01-31 18:33:10 -0800 | [diff] [blame] | 420 | |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 421 | btdelconn = create_singlethread_workqueue("btdelconn"); |
| 422 | if (!btdelconn) { |
| 423 | err = -ENOMEM; |
| 424 | goto out_del; |
| 425 | } |
| 426 | |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 427 | bt_platform = platform_device_register_simple("bluetooth", -1, NULL, 0); |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 428 | if (IS_ERR(bt_platform)) { |
| 429 | err = PTR_ERR(bt_platform); |
| 430 | goto out_platform; |
| 431 | } |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 432 | |
| 433 | err = bus_register(&bt_bus); |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 434 | if (err < 0) |
| 435 | goto out_bus; |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 436 | |
Marcel Holtmann | a91f2e3 | 2006-07-03 10:02:41 +0200 | [diff] [blame] | 437 | bt_class = class_create(THIS_MODULE, "bluetooth"); |
| 438 | if (IS_ERR(bt_class)) { |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 439 | err = PTR_ERR(bt_class); |
| 440 | goto out_class; |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 441 | } |
| 442 | |
| 443 | return 0; |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 444 | |
| 445 | out_class: |
| 446 | bus_unregister(&bt_bus); |
| 447 | out_bus: |
| 448 | platform_device_unregister(bt_platform); |
| 449 | out_platform: |
| 450 | destroy_workqueue(btdelconn); |
| 451 | out_del: |
| 452 | destroy_workqueue(btaddconn); |
| 453 | out: |
| 454 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | } |
| 456 | |
Arnaud Patard | 860e13b | 2006-09-28 15:29:37 -0700 | [diff] [blame] | 457 | void bt_sysfs_cleanup(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 458 | { |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 459 | destroy_workqueue(btaddconn); |
Dave Young | 5396c93 | 2008-01-31 18:33:10 -0800 | [diff] [blame] | 460 | |
Dave Young | b6c0632 | 2008-01-29 21:14:08 -0800 | [diff] [blame] | 461 | destroy_workqueue(btdelconn); |
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); |
Dave Young | 5396c93 | 2008-01-31 18:33:10 -0800 | [diff] [blame] | 464 | |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 465 | bus_unregister(&bt_bus); |
Dave Young | 5396c93 | 2008-01-31 18:33:10 -0800 | [diff] [blame] | 466 | |
Marcel Holtmann | 27d3528 | 2006-07-03 10:02:37 +0200 | [diff] [blame] | 467 | platform_device_unregister(bt_platform); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | } |