58df4360d242fc2c3ee80025adb055453bc02b58
[pandora-kernel.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_VHCI:
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         default:
32                 return "UNKNOWN";
33         }
34 }
35
36 static ssize_t show_type(struct device *dev, struct device_attribute *attr, char *buf)
37 {
38         struct hci_dev *hdev = dev_get_drvdata(dev);
39         return sprintf(buf, "%s\n", typetostr(hdev->type));
40 }
41
42 static ssize_t show_address(struct device *dev, struct device_attribute *attr, char *buf)
43 {
44         struct hci_dev *hdev = dev_get_drvdata(dev);
45         bdaddr_t bdaddr;
46         baswap(&bdaddr, &hdev->bdaddr);
47         return sprintf(buf, "%s\n", batostr(&bdaddr));
48 }
49
50 static ssize_t show_inquiry_cache(struct device *dev, struct device_attribute *attr, char *buf)
51 {
52         struct hci_dev *hdev = dev_get_drvdata(dev);
53         struct inquiry_cache *cache = &hdev->inq_cache;
54         struct inquiry_entry *e;
55         int n = 0;
56
57         hci_dev_lock_bh(hdev);
58
59         for (e = cache->list; e; e = e->next) {
60                 struct inquiry_data *data = &e->data;
61                 bdaddr_t bdaddr;
62                 baswap(&bdaddr, &data->bdaddr);
63                 n += sprintf(buf + n, "%s %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %u\n",
64                                 batostr(&bdaddr),
65                                 data->pscan_rep_mode, data->pscan_period_mode, data->pscan_mode,
66                                 data->dev_class[2], data->dev_class[1], data->dev_class[0],
67                                 __le16_to_cpu(data->clock_offset), data->rssi, e->timestamp);
68         }
69
70         hci_dev_unlock_bh(hdev);
71         return n;
72 }
73
74 static ssize_t show_idle_timeout(struct device *dev, struct device_attribute *attr, char *buf)
75 {
76         struct hci_dev *hdev = dev_get_drvdata(dev);
77         return sprintf(buf, "%d\n", hdev->idle_timeout);
78 }
79
80 static ssize_t store_idle_timeout(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
81 {
82         struct hci_dev *hdev = dev_get_drvdata(dev);
83         char *ptr;
84         __u32 val;
85
86         val = simple_strtoul(buf, &ptr, 10);
87         if (ptr == buf)
88                 return -EINVAL;
89
90         if (val != 0 && (val < 500 || val > 3600000))
91                 return -EINVAL;
92
93         hdev->idle_timeout = val;
94
95         return count;
96 }
97
98 static ssize_t show_sniff_max_interval(struct device *dev, struct device_attribute *attr, char *buf)
99 {
100         struct hci_dev *hdev = dev_get_drvdata(dev);
101         return sprintf(buf, "%d\n", hdev->sniff_max_interval);
102 }
103
104 static ssize_t store_sniff_max_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
105 {
106         struct hci_dev *hdev = dev_get_drvdata(dev);
107         char *ptr;
108         __u16 val;
109
110         val = simple_strtoul(buf, &ptr, 10);
111         if (ptr == buf)
112                 return -EINVAL;
113
114         if (val < 0x0002 || val > 0xFFFE || val % 2)
115                 return -EINVAL;
116
117         if (val < hdev->sniff_min_interval)
118                 return -EINVAL;
119
120         hdev->sniff_max_interval = val;
121
122         return count;
123 }
124
125 static ssize_t show_sniff_min_interval(struct device *dev, struct device_attribute *attr, char *buf)
126 {
127         struct hci_dev *hdev = dev_get_drvdata(dev);
128         return sprintf(buf, "%d\n", hdev->sniff_min_interval);
129 }
130
131 static ssize_t store_sniff_min_interval(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
132 {
133         struct hci_dev *hdev = dev_get_drvdata(dev);
134         char *ptr;
135         __u16 val;
136
137         val = simple_strtoul(buf, &ptr, 10);
138         if (ptr == buf)
139                 return -EINVAL;
140
141         if (val < 0x0002 || val > 0xFFFE || val % 2)
142                 return -EINVAL;
143
144         if (val > hdev->sniff_max_interval)
145                 return -EINVAL;
146
147         hdev->sniff_min_interval = val;
148
149         return count;
150 }
151
152 static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
153 static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
154 static DEVICE_ATTR(inquiry_cache, S_IRUGO, show_inquiry_cache, NULL);
155
156 static DEVICE_ATTR(idle_timeout, S_IRUGO | S_IWUSR,
157                                 show_idle_timeout, store_idle_timeout);
158 static DEVICE_ATTR(sniff_max_interval, S_IRUGO | S_IWUSR,
159                                 show_sniff_max_interval, store_sniff_max_interval);
160 static DEVICE_ATTR(sniff_min_interval, S_IRUGO | S_IWUSR,
161                                 show_sniff_min_interval, store_sniff_min_interval);
162
163 static struct device_attribute *bt_attrs[] = {
164         &dev_attr_type,
165         &dev_attr_address,
166         &dev_attr_inquiry_cache,
167         &dev_attr_idle_timeout,
168         &dev_attr_sniff_max_interval,
169         &dev_attr_sniff_min_interval,
170         NULL
171 };
172
173 static ssize_t show_conn_type(struct device *dev, struct device_attribute *attr, char *buf)
174 {
175         struct hci_conn *conn = dev_get_drvdata(dev);
176         return sprintf(buf, "%s\n", conn->type == ACL_LINK ? "ACL" : "SCO");
177 }
178
179 static ssize_t show_conn_address(struct device *dev, struct device_attribute *attr, char *buf)
180 {
181         struct hci_conn *conn = dev_get_drvdata(dev);
182         bdaddr_t bdaddr;
183         baswap(&bdaddr, &conn->dst);
184         return sprintf(buf, "%s\n", batostr(&bdaddr));
185 }
186
187 #define CONN_ATTR(_name,_mode,_show,_store) \
188 struct device_attribute conn_attr_##_name = __ATTR(_name,_mode,_show,_store)
189
190 static CONN_ATTR(type, S_IRUGO, show_conn_type, NULL);
191 static CONN_ATTR(address, S_IRUGO, show_conn_address, NULL);
192
193 static struct device_attribute *conn_attrs[] = {
194         &conn_attr_type,
195         &conn_attr_address,
196         NULL
197 };
198
199 struct class *bt_class = NULL;
200 EXPORT_SYMBOL_GPL(bt_class);
201
202 static struct bus_type bt_bus = {
203         .name   = "bluetooth",
204 };
205
206 static struct platform_device *bt_platform;
207
208 static void bt_release(struct device *dev)
209 {
210         void *data = dev_get_drvdata(dev);
211         kfree(data);
212 }
213
214 static void add_conn(void *data)
215 {
216         struct hci_conn *conn = data;
217         int i;
218
219         device_register(&conn->dev);
220
221         for (i = 0; conn_attrs[i]; i++)
222                 device_create_file(&conn->dev, conn_attrs[i]);
223 }
224
225 void hci_conn_add_sysfs(struct hci_conn *conn)
226 {
227         struct hci_dev *hdev = conn->hdev;
228         bdaddr_t *ba = &conn->dst;
229
230         BT_DBG("conn %p", conn);
231
232         conn->dev.parent  = &hdev->dev;
233         conn->dev.release = bt_release;
234
235         snprintf(conn->dev.bus_id, BUS_ID_SIZE,
236                         "%s%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
237                         conn->type == ACL_LINK ? "acl" : "sco",
238                         ba->b[5], ba->b[4], ba->b[3],
239                         ba->b[2], ba->b[1], ba->b[0]);
240
241         dev_set_drvdata(&conn->dev, conn);
242
243         INIT_WORK(&conn->work, add_conn, (void *) conn);
244
245         schedule_work(&conn->work);
246 }
247
248 static void del_conn(void *data)
249 {
250         struct hci_conn *conn = data;
251         device_del(&conn->dev);
252 }
253
254 void hci_conn_del_sysfs(struct hci_conn *conn)
255 {
256         BT_DBG("conn %p", conn);
257
258         INIT_WORK(&conn->work, del_conn, (void *) conn);
259
260         schedule_work(&conn->work);
261 }
262
263 int hci_register_sysfs(struct hci_dev *hdev)
264 {
265         struct device *dev = &hdev->dev;
266         unsigned int i;
267         int err;
268
269         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
270
271         dev->class = bt_class;
272
273         if (hdev->parent)
274                 dev->parent = hdev->parent;
275         else
276                 dev->parent = &bt_platform->dev;
277
278         strlcpy(dev->bus_id, hdev->name, BUS_ID_SIZE);
279
280         dev->release = bt_release;
281
282         dev_set_drvdata(dev, hdev);
283
284         err = device_register(dev);
285         if (err < 0)
286                 return err;
287
288         for (i = 0; bt_attrs[i]; i++)
289                 device_create_file(dev, bt_attrs[i]);
290
291         return 0;
292 }
293
294 void hci_unregister_sysfs(struct hci_dev *hdev)
295 {
296         BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
297
298         device_del(&hdev->dev);
299 }
300
301 int __init bt_sysfs_init(void)
302 {
303         int err;
304
305         bt_platform = platform_device_register_simple("bluetooth", -1, NULL, 0);
306         if (IS_ERR(bt_platform))
307                 return PTR_ERR(bt_platform);
308
309         err = bus_register(&bt_bus);
310         if (err < 0) {
311                 platform_device_unregister(bt_platform);
312                 return err;
313         }
314
315         bt_class = class_create(THIS_MODULE, "bluetooth");
316         if (IS_ERR(bt_class)) {
317                 bus_unregister(&bt_bus);
318                 platform_device_unregister(bt_platform);
319                 return PTR_ERR(bt_class);
320         }
321
322         return 0;
323 }
324
325 void __exit bt_sysfs_cleanup(void)
326 {
327         class_destroy(bt_class);
328
329         bus_unregister(&bt_bus);
330
331         platform_device_unregister(bt_platform);
332 }