[PATCH] as-iosched: use new io context counting mechanism
[linux-2.6.git] / net / bluetooth / hci_sysfs.c
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(void *data)
241 {
242         struct hci_conn *conn = data;
243         int i;
244
245         device_register(&conn->dev);
246
247         for (i = 0; conn_attrs[i]; i++)
248                 device_create_file(&conn->dev, conn_attrs[i]);
249 }
250
251 void hci_conn_add_sysfs(struct hci_conn *conn)
252 {
253         struct hci_dev *hdev = conn->hdev;
254         bdaddr_t *ba = &conn->dst;
255
256         BT_DBG("conn %p", conn);
257
258         conn->dev.parent  = &hdev->dev;
259         conn->dev.release = bt_release;
260
261         snprintf(conn->dev.bus_id, BUS_ID_SIZE,
262                         "%s%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
263                         conn->type == ACL_LINK ? "acl" : "sco",
264                         ba->b[5], ba->b[4], ba->b[3],
265                         ba->b[2], ba->b[1], ba->b[0]);
266
267         dev_set_drvdata(&conn->dev, conn);
268
269         INIT_WORK(&conn->work, add_conn, (void *) conn);
270
271         schedule_work(&conn->work);
272 }
273
274 static void del_conn(void *data)
275 {
276         struct hci_conn *conn = data;
277         device_del(&conn->dev);
278 }
279
280 void hci_conn_del_sysfs(struct hci_conn *conn)
281 {
282         BT_DBG("conn %p", conn);
283
284         INIT_WORK(&conn->work, del_conn, (void *) conn);
285
286         schedule_work(&conn->work);
287 }
288
289 int hci_register_sysfs(struct hci_dev *hdev)
290 {
291         struct device *dev = &hdev->dev;
292         unsigned int i;
293         int err;
294
295         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
296
297         dev->class = bt_class;
298
299         if (hdev->parent)
300                 dev->parent = hdev->parent;
301         else
302                 dev->parent = &bt_platform->dev;
303
304         strlcpy(dev->bus_id, hdev->name, BUS_ID_SIZE);
305
306         dev->release = bt_release;
307
308         dev_set_drvdata(dev, hdev);
309
310         err = device_register(dev);
311         if (err < 0)
312                 return err;
313
314         for (i = 0; bt_attrs[i]; i++)
315                 device_create_file(dev, bt_attrs[i]);
316
317         return 0;
318 }
319
320 void hci_unregister_sysfs(struct hci_dev *hdev)
321 {
322         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
323
324         device_del(&hdev->dev);
325 }
326
327 int __init bt_sysfs_init(void)
328 {
329         int err;
330
331         bt_platform = platform_device_register_simple("bluetooth", -1, NULL, 0);
332         if (IS_ERR(bt_platform))
333                 return PTR_ERR(bt_platform);
334
335         err = bus_register(&bt_bus);
336         if (err < 0) {
337                 platform_device_unregister(bt_platform);
338                 return err;
339         }
340
341         bt_class = class_create(THIS_MODULE, "bluetooth");
342         if (IS_ERR(bt_class)) {
343                 bus_unregister(&bt_bus);
344                 platform_device_unregister(bt_platform);
345                 return PTR_ERR(bt_class);
346         }
347
348         return 0;
349 }
350
351 void bt_sysfs_cleanup(void)
352 {
353         class_destroy(bt_class);
354
355         bus_unregister(&bt_bus);
356
357         platform_device_unregister(bt_platform);
358 }