blob: f5b21cb936996b87ec7138d8b8b81c3e1fa6f006 [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI core. */
26
S.Çağlar Onur824530212008-02-17 23:25:57 -080027#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/module.h>
29#include <linux/kmod.h>
30
31#include <linux/types.h>
32#include <linux/errno.h>
33#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/sched.h>
35#include <linux/slab.h>
36#include <linux/poll.h>
37#include <linux/fcntl.h>
38#include <linux/init.h>
39#include <linux/skbuff.h>
40#include <linux/interrupt.h>
41#include <linux/notifier.h>
42#include <net/sock.h>
43
44#include <asm/system.h>
45#include <asm/uaccess.h>
46#include <asm/unaligned.h>
47
48#include <net/bluetooth/bluetooth.h>
49#include <net/bluetooth/hci_core.h>
50
51#ifndef CONFIG_BT_HCI_CORE_DEBUG
52#undef BT_DBG
53#define BT_DBG(D...)
54#endif
55
56static void hci_cmd_task(unsigned long arg);
57static void hci_rx_task(unsigned long arg);
58static void hci_tx_task(unsigned long arg);
59static void hci_notify(struct hci_dev *hdev, int event);
60
61static DEFINE_RWLOCK(hci_task_lock);
62
63/* HCI device list */
64LIST_HEAD(hci_dev_list);
65DEFINE_RWLOCK(hci_dev_list_lock);
66
67/* HCI callback list */
68LIST_HEAD(hci_cb_list);
69DEFINE_RWLOCK(hci_cb_list_lock);
70
71/* HCI protocols */
72#define HCI_MAX_PROTO 2
73struct hci_proto *hci_proto[HCI_MAX_PROTO];
74
75/* HCI notifiers list */
Alan Sterne041c682006-03-27 01:16:30 -080076static ATOMIC_NOTIFIER_HEAD(hci_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78/* ---- HCI notifications ---- */
79
80int hci_register_notifier(struct notifier_block *nb)
81{
Alan Sterne041c682006-03-27 01:16:30 -080082 return atomic_notifier_chain_register(&hci_notifier, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083}
84
85int hci_unregister_notifier(struct notifier_block *nb)
86{
Alan Sterne041c682006-03-27 01:16:30 -080087 return atomic_notifier_chain_unregister(&hci_notifier, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088}
89
Marcel Holtmann65164552005-10-28 19:20:48 +020090static void hci_notify(struct hci_dev *hdev, int event)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Alan Sterne041c682006-03-27 01:16:30 -080092 atomic_notifier_call_chain(&hci_notifier, event, hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94
95/* ---- HCI requests ---- */
96
97void hci_req_complete(struct hci_dev *hdev, int result)
98{
99 BT_DBG("%s result 0x%2.2x", hdev->name, result);
100
101 if (hdev->req_status == HCI_REQ_PEND) {
102 hdev->req_result = result;
103 hdev->req_status = HCI_REQ_DONE;
104 wake_up_interruptible(&hdev->req_wait_q);
105 }
106}
107
108static void hci_req_cancel(struct hci_dev *hdev, int err)
109{
110 BT_DBG("%s err 0x%2.2x", hdev->name, err);
111
112 if (hdev->req_status == HCI_REQ_PEND) {
113 hdev->req_result = err;
114 hdev->req_status = HCI_REQ_CANCELED;
115 wake_up_interruptible(&hdev->req_wait_q);
116 }
117}
118
119/* Execute request and wait for completion. */
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900120static int __hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 unsigned long opt, __u32 timeout)
122{
123 DECLARE_WAITQUEUE(wait, current);
124 int err = 0;
125
126 BT_DBG("%s start", hdev->name);
127
128 hdev->req_status = HCI_REQ_PEND;
129
130 add_wait_queue(&hdev->req_wait_q, &wait);
131 set_current_state(TASK_INTERRUPTIBLE);
132
133 req(hdev, opt);
134 schedule_timeout(timeout);
135
136 remove_wait_queue(&hdev->req_wait_q, &wait);
137
138 if (signal_pending(current))
139 return -EINTR;
140
141 switch (hdev->req_status) {
142 case HCI_REQ_DONE:
143 err = -bt_err(hdev->req_result);
144 break;
145
146 case HCI_REQ_CANCELED:
147 err = -hdev->req_result;
148 break;
149
150 default:
151 err = -ETIMEDOUT;
152 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700153 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 hdev->req_status = hdev->req_result = 0;
156
157 BT_DBG("%s end: err %d", hdev->name, err);
158
159 return err;
160}
161
162static inline int hci_request(struct hci_dev *hdev, void (*req)(struct hci_dev *hdev, unsigned long opt),
163 unsigned long opt, __u32 timeout)
164{
165 int ret;
166
167 /* Serialize all requests */
168 hci_req_lock(hdev);
169 ret = __hci_request(hdev, req, opt, timeout);
170 hci_req_unlock(hdev);
171
172 return ret;
173}
174
175static void hci_reset_req(struct hci_dev *hdev, unsigned long opt)
176{
177 BT_DBG("%s %ld", hdev->name, opt);
178
179 /* Reset device */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200180 hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181}
182
183static void hci_init_req(struct hci_dev *hdev, unsigned long opt)
184{
185 struct sk_buff *skb;
Marcel Holtmann1ebb9252005-11-08 09:57:21 -0800186 __le16 param;
Marcel Holtmann89f27832007-09-09 08:39:49 +0200187 __u8 flt_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189 BT_DBG("%s %ld", hdev->name, opt);
190
191 /* Driver initialization */
192
193 /* Special commands */
194 while ((skb = skb_dequeue(&hdev->driver_init))) {
Marcel Holtmann0d48d932005-08-09 20:30:28 -0700195 bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 skb->dev = (void *) hdev;
197 skb_queue_tail(&hdev->cmd_q, skb);
198 hci_sched_cmd(hdev);
199 }
200 skb_queue_purge(&hdev->driver_init);
201
202 /* Mandatory initialization */
203
204 /* Reset */
205 if (test_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks))
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200206 hci_send_cmd(hdev, HCI_OP_RESET, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
208 /* Read Local Supported Features */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200209 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_FEATURES, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Marcel Holtmann1143e5a2006-09-23 09:57:20 +0200211 /* Read Local Version */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200212 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL);
Marcel Holtmann1143e5a2006-09-23 09:57:20 +0200213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 /* Read Buffer Size (ACL mtu, max pkt, etc.) */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200215 hci_send_cmd(hdev, HCI_OP_READ_BUFFER_SIZE, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
217#if 0
218 /* Host buffer size */
219 {
220 struct hci_cp_host_buffer_size cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700221 cp.acl_mtu = cpu_to_le16(HCI_MAX_ACL_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 cp.sco_mtu = HCI_MAX_SCO_SIZE;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700223 cp.acl_max_pkt = cpu_to_le16(0xffff);
224 cp.sco_max_pkt = cpu_to_le16(0xffff);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200225 hci_send_cmd(hdev, HCI_OP_HOST_BUFFER_SIZE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 }
227#endif
228
229 /* Read BD Address */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200230 hci_send_cmd(hdev, HCI_OP_READ_BD_ADDR, 0, NULL);
231
232 /* Read Class of Device */
233 hci_send_cmd(hdev, HCI_OP_READ_CLASS_OF_DEV, 0, NULL);
234
235 /* Read Local Name */
236 hci_send_cmd(hdev, HCI_OP_READ_LOCAL_NAME, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238 /* Read Voice Setting */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200239 hci_send_cmd(hdev, HCI_OP_READ_VOICE_SETTING, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 /* Optional initialization */
242
243 /* Clear Event Filters */
Marcel Holtmann89f27832007-09-09 08:39:49 +0200244 flt_type = HCI_FLT_CLEAR_ALL;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200245 hci_send_cmd(hdev, HCI_OP_SET_EVENT_FLT, 1, &flt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
247 /* Page timeout ~20 secs */
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700248 param = cpu_to_le16(0x8000);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200249 hci_send_cmd(hdev, HCI_OP_WRITE_PG_TIMEOUT, 2, &param);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
251 /* Connection accept timeout ~20 secs */
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700252 param = cpu_to_le16(0x7d00);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200253 hci_send_cmd(hdev, HCI_OP_WRITE_CA_TIMEOUT, 2, &param);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254}
255
256static void hci_scan_req(struct hci_dev *hdev, unsigned long opt)
257{
258 __u8 scan = opt;
259
260 BT_DBG("%s %x", hdev->name, scan);
261
262 /* Inquiry and Page scans */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200263 hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264}
265
266static void hci_auth_req(struct hci_dev *hdev, unsigned long opt)
267{
268 __u8 auth = opt;
269
270 BT_DBG("%s %x", hdev->name, auth);
271
272 /* Authentication */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200273 hci_send_cmd(hdev, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274}
275
276static void hci_encrypt_req(struct hci_dev *hdev, unsigned long opt)
277{
278 __u8 encrypt = opt;
279
280 BT_DBG("%s %x", hdev->name, encrypt);
281
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200282 /* Encryption */
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200283 hci_send_cmd(hdev, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284}
285
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200286static void hci_linkpol_req(struct hci_dev *hdev, unsigned long opt)
287{
288 __le16 policy = cpu_to_le16(opt);
289
290 BT_DBG("%s %x", hdev->name, opt);
291
292 /* Default link policy */
293 hci_send_cmd(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy);
294}
295
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900296/* Get HCI device by index.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 * Device is held on return. */
298struct hci_dev *hci_dev_get(int index)
299{
300 struct hci_dev *hdev = NULL;
301 struct list_head *p;
302
303 BT_DBG("%d", index);
304
305 if (index < 0)
306 return NULL;
307
308 read_lock(&hci_dev_list_lock);
309 list_for_each(p, &hci_dev_list) {
310 struct hci_dev *d = list_entry(p, struct hci_dev, list);
311 if (d->id == index) {
312 hdev = hci_dev_hold(d);
313 break;
314 }
315 }
316 read_unlock(&hci_dev_list_lock);
317 return hdev;
318}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320/* ---- Inquiry support ---- */
321static void inquiry_cache_flush(struct hci_dev *hdev)
322{
323 struct inquiry_cache *cache = &hdev->inq_cache;
324 struct inquiry_entry *next = cache->list, *e;
325
326 BT_DBG("cache %p", cache);
327
328 cache->list = NULL;
329 while ((e = next)) {
330 next = e->next;
331 kfree(e);
332 }
333}
334
335struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr)
336{
337 struct inquiry_cache *cache = &hdev->inq_cache;
338 struct inquiry_entry *e;
339
340 BT_DBG("cache %p, %s", cache, batostr(bdaddr));
341
342 for (e = cache->list; e; e = e->next)
343 if (!bacmp(&e->data.bdaddr, bdaddr))
344 break;
345 return e;
346}
347
348void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data)
349{
350 struct inquiry_cache *cache = &hdev->inq_cache;
351 struct inquiry_entry *e;
352
353 BT_DBG("cache %p, %s", cache, batostr(&data->bdaddr));
354
355 if (!(e = hci_inquiry_cache_lookup(hdev, &data->bdaddr))) {
356 /* Entry not in the cache. Add new one. */
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200357 if (!(e = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 e->next = cache->list;
360 cache->list = e;
361 }
362
363 memcpy(&e->data, data, sizeof(*data));
364 e->timestamp = jiffies;
365 cache->timestamp = jiffies;
366}
367
368static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf)
369{
370 struct inquiry_cache *cache = &hdev->inq_cache;
371 struct inquiry_info *info = (struct inquiry_info *) buf;
372 struct inquiry_entry *e;
373 int copied = 0;
374
375 for (e = cache->list; e && copied < num; e = e->next, copied++) {
376 struct inquiry_data *data = &e->data;
377 bacpy(&info->bdaddr, &data->bdaddr);
378 info->pscan_rep_mode = data->pscan_rep_mode;
379 info->pscan_period_mode = data->pscan_period_mode;
380 info->pscan_mode = data->pscan_mode;
381 memcpy(info->dev_class, data->dev_class, 3);
382 info->clock_offset = data->clock_offset;
383 info++;
384 }
385
386 BT_DBG("cache %p, copied %d", cache, copied);
387 return copied;
388}
389
390static void hci_inq_req(struct hci_dev *hdev, unsigned long opt)
391{
392 struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt;
393 struct hci_cp_inquiry cp;
394
395 BT_DBG("%s", hdev->name);
396
397 if (test_bit(HCI_INQUIRY, &hdev->flags))
398 return;
399
400 /* Start Inquiry */
401 memcpy(&cp.lap, &ir->lap, 3);
402 cp.length = ir->length;
403 cp.num_rsp = ir->num_rsp;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200404 hci_send_cmd(hdev, HCI_OP_INQUIRY, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405}
406
407int hci_inquiry(void __user *arg)
408{
409 __u8 __user *ptr = arg;
410 struct hci_inquiry_req ir;
411 struct hci_dev *hdev;
412 int err = 0, do_inquiry = 0, max_rsp;
413 long timeo;
414 __u8 *buf;
415
416 if (copy_from_user(&ir, ptr, sizeof(ir)))
417 return -EFAULT;
418
419 if (!(hdev = hci_dev_get(ir.dev_id)))
420 return -ENODEV;
421
422 hci_dev_lock_bh(hdev);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900423 if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 inquiry_cache_empty(hdev) ||
425 ir.flags & IREQ_CACHE_FLUSH) {
426 inquiry_cache_flush(hdev);
427 do_inquiry = 1;
428 }
429 hci_dev_unlock_bh(hdev);
430
Marcel Holtmann04837f62006-07-03 10:02:33 +0200431 timeo = ir.length * msecs_to_jiffies(2000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 if (do_inquiry && (err = hci_request(hdev, hci_inq_req, (unsigned long)&ir, timeo)) < 0)
433 goto done;
434
435 /* for unlimited number of responses we will use buffer with 255 entries */
436 max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp;
437
438 /* cache_dump can't sleep. Therefore we allocate temp buffer and then
439 * copy it to the user space.
440 */
441 if (!(buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL))) {
442 err = -ENOMEM;
443 goto done;
444 }
445
446 hci_dev_lock_bh(hdev);
447 ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf);
448 hci_dev_unlock_bh(hdev);
449
450 BT_DBG("num_rsp %d", ir.num_rsp);
451
452 if (!copy_to_user(ptr, &ir, sizeof(ir))) {
453 ptr += sizeof(ir);
454 if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) *
455 ir.num_rsp))
456 err = -EFAULT;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900457 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 err = -EFAULT;
459
460 kfree(buf);
461
462done:
463 hci_dev_put(hdev);
464 return err;
465}
466
467/* ---- HCI ioctl helpers ---- */
468
469int hci_dev_open(__u16 dev)
470{
471 struct hci_dev *hdev;
472 int ret = 0;
473
474 if (!(hdev = hci_dev_get(dev)))
475 return -ENODEV;
476
477 BT_DBG("%s %p", hdev->name, hdev);
478
479 hci_req_lock(hdev);
480
481 if (test_bit(HCI_UP, &hdev->flags)) {
482 ret = -EALREADY;
483 goto done;
484 }
485
486 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
487 set_bit(HCI_RAW, &hdev->flags);
488
489 if (hdev->open(hdev)) {
490 ret = -EIO;
491 goto done;
492 }
493
494 if (!test_bit(HCI_RAW, &hdev->flags)) {
495 atomic_set(&hdev->cmd_cnt, 1);
496 set_bit(HCI_INIT, &hdev->flags);
497
498 //__hci_request(hdev, hci_reset_req, 0, HZ);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200499 ret = __hci_request(hdev, hci_init_req, 0,
500 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502 clear_bit(HCI_INIT, &hdev->flags);
503 }
504
505 if (!ret) {
506 hci_dev_hold(hdev);
507 set_bit(HCI_UP, &hdev->flags);
508 hci_notify(hdev, HCI_DEV_UP);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900509 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 /* Init failed, cleanup */
511 tasklet_kill(&hdev->rx_task);
512 tasklet_kill(&hdev->tx_task);
513 tasklet_kill(&hdev->cmd_task);
514
515 skb_queue_purge(&hdev->cmd_q);
516 skb_queue_purge(&hdev->rx_q);
517
518 if (hdev->flush)
519 hdev->flush(hdev);
520
521 if (hdev->sent_cmd) {
522 kfree_skb(hdev->sent_cmd);
523 hdev->sent_cmd = NULL;
524 }
525
526 hdev->close(hdev);
527 hdev->flags = 0;
528 }
529
530done:
531 hci_req_unlock(hdev);
532 hci_dev_put(hdev);
533 return ret;
534}
535
536static int hci_dev_do_close(struct hci_dev *hdev)
537{
538 BT_DBG("%s %p", hdev->name, hdev);
539
540 hci_req_cancel(hdev, ENODEV);
541 hci_req_lock(hdev);
542
543 if (!test_and_clear_bit(HCI_UP, &hdev->flags)) {
544 hci_req_unlock(hdev);
545 return 0;
546 }
547
548 /* Kill RX and TX tasks */
549 tasklet_kill(&hdev->rx_task);
550 tasklet_kill(&hdev->tx_task);
551
552 hci_dev_lock_bh(hdev);
553 inquiry_cache_flush(hdev);
554 hci_conn_hash_flush(hdev);
555 hci_dev_unlock_bh(hdev);
556
557 hci_notify(hdev, HCI_DEV_DOWN);
558
559 if (hdev->flush)
560 hdev->flush(hdev);
561
562 /* Reset device */
563 skb_queue_purge(&hdev->cmd_q);
564 atomic_set(&hdev->cmd_cnt, 1);
565 if (!test_bit(HCI_RAW, &hdev->flags)) {
566 set_bit(HCI_INIT, &hdev->flags);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200567 __hci_request(hdev, hci_reset_req, 0,
568 msecs_to_jiffies(250));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 clear_bit(HCI_INIT, &hdev->flags);
570 }
571
572 /* Kill cmd task */
573 tasklet_kill(&hdev->cmd_task);
574
575 /* Drop queues */
576 skb_queue_purge(&hdev->rx_q);
577 skb_queue_purge(&hdev->cmd_q);
578 skb_queue_purge(&hdev->raw_q);
579
580 /* Drop last sent command */
581 if (hdev->sent_cmd) {
582 kfree_skb(hdev->sent_cmd);
583 hdev->sent_cmd = NULL;
584 }
585
586 /* After this point our queues are empty
587 * and no tasks are scheduled. */
588 hdev->close(hdev);
589
590 /* Clear flags */
591 hdev->flags = 0;
592
593 hci_req_unlock(hdev);
594
595 hci_dev_put(hdev);
596 return 0;
597}
598
599int hci_dev_close(__u16 dev)
600{
601 struct hci_dev *hdev;
602 int err;
603
604 if (!(hdev = hci_dev_get(dev)))
605 return -ENODEV;
606 err = hci_dev_do_close(hdev);
607 hci_dev_put(hdev);
608 return err;
609}
610
611int hci_dev_reset(__u16 dev)
612{
613 struct hci_dev *hdev;
614 int ret = 0;
615
616 if (!(hdev = hci_dev_get(dev)))
617 return -ENODEV;
618
619 hci_req_lock(hdev);
620 tasklet_disable(&hdev->tx_task);
621
622 if (!test_bit(HCI_UP, &hdev->flags))
623 goto done;
624
625 /* Drop queues */
626 skb_queue_purge(&hdev->rx_q);
627 skb_queue_purge(&hdev->cmd_q);
628
629 hci_dev_lock_bh(hdev);
630 inquiry_cache_flush(hdev);
631 hci_conn_hash_flush(hdev);
632 hci_dev_unlock_bh(hdev);
633
634 if (hdev->flush)
635 hdev->flush(hdev);
636
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900637 atomic_set(&hdev->cmd_cnt, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 hdev->acl_cnt = 0; hdev->sco_cnt = 0;
639
640 if (!test_bit(HCI_RAW, &hdev->flags))
Marcel Holtmann04837f62006-07-03 10:02:33 +0200641 ret = __hci_request(hdev, hci_reset_req, 0,
642 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
644done:
645 tasklet_enable(&hdev->tx_task);
646 hci_req_unlock(hdev);
647 hci_dev_put(hdev);
648 return ret;
649}
650
651int hci_dev_reset_stat(__u16 dev)
652{
653 struct hci_dev *hdev;
654 int ret = 0;
655
656 if (!(hdev = hci_dev_get(dev)))
657 return -ENODEV;
658
659 memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
660
661 hci_dev_put(hdev);
662
663 return ret;
664}
665
666int hci_dev_cmd(unsigned int cmd, void __user *arg)
667{
668 struct hci_dev *hdev;
669 struct hci_dev_req dr;
670 int err = 0;
671
672 if (copy_from_user(&dr, arg, sizeof(dr)))
673 return -EFAULT;
674
675 if (!(hdev = hci_dev_get(dr.dev_id)))
676 return -ENODEV;
677
678 switch (cmd) {
679 case HCISETAUTH:
Marcel Holtmann04837f62006-07-03 10:02:33 +0200680 err = hci_request(hdev, hci_auth_req, dr.dev_opt,
681 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 break;
683
684 case HCISETENCRYPT:
685 if (!lmp_encrypt_capable(hdev)) {
686 err = -EOPNOTSUPP;
687 break;
688 }
689
690 if (!test_bit(HCI_AUTH, &hdev->flags)) {
691 /* Auth must be enabled first */
Marcel Holtmann04837f62006-07-03 10:02:33 +0200692 err = hci_request(hdev, hci_auth_req, dr.dev_opt,
693 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 if (err)
695 break;
696 }
697
Marcel Holtmann04837f62006-07-03 10:02:33 +0200698 err = hci_request(hdev, hci_encrypt_req, dr.dev_opt,
699 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 break;
701
702 case HCISETSCAN:
Marcel Holtmann04837f62006-07-03 10:02:33 +0200703 err = hci_request(hdev, hci_scan_req, dr.dev_opt,
704 msecs_to_jiffies(HCI_INIT_TIMEOUT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 break;
706
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200707 case HCISETLINKPOL:
708 err = hci_request(hdev, hci_linkpol_req, dr.dev_opt,
709 msecs_to_jiffies(HCI_INIT_TIMEOUT));
710 break;
711
712 case HCISETLINKMODE:
713 hdev->link_mode = ((__u16) dr.dev_opt) &
714 (HCI_LM_MASTER | HCI_LM_ACCEPT);
715 break;
716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 case HCISETPTYPE:
718 hdev->pkt_type = (__u16) dr.dev_opt;
719 break;
720
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 case HCISETACLMTU:
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200722 hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1);
723 hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 break;
725
726 case HCISETSCOMTU:
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200727 hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1);
728 hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 break;
730
731 default:
732 err = -EINVAL;
733 break;
734 }
Marcel Holtmanne4e8e372008-07-14 20:13:47 +0200735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 hci_dev_put(hdev);
737 return err;
738}
739
740int hci_get_dev_list(void __user *arg)
741{
742 struct hci_dev_list_req *dl;
743 struct hci_dev_req *dr;
744 struct list_head *p;
745 int n = 0, size, err;
746 __u16 dev_num;
747
748 if (get_user(dev_num, (__u16 __user *) arg))
749 return -EFAULT;
750
751 if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr))
752 return -EINVAL;
753
754 size = sizeof(*dl) + dev_num * sizeof(*dr);
755
756 if (!(dl = kmalloc(size, GFP_KERNEL)))
757 return -ENOMEM;
758
759 dr = dl->dev_req;
760
761 read_lock_bh(&hci_dev_list_lock);
762 list_for_each(p, &hci_dev_list) {
763 struct hci_dev *hdev;
764 hdev = list_entry(p, struct hci_dev, list);
765 (dr + n)->dev_id = hdev->id;
766 (dr + n)->dev_opt = hdev->flags;
767 if (++n >= dev_num)
768 break;
769 }
770 read_unlock_bh(&hci_dev_list_lock);
771
772 dl->dev_num = n;
773 size = sizeof(*dl) + n * sizeof(*dr);
774
775 err = copy_to_user(arg, dl, size);
776 kfree(dl);
777
778 return err ? -EFAULT : 0;
779}
780
781int hci_get_dev_info(void __user *arg)
782{
783 struct hci_dev *hdev;
784 struct hci_dev_info di;
785 int err = 0;
786
787 if (copy_from_user(&di, arg, sizeof(di)))
788 return -EFAULT;
789
790 if (!(hdev = hci_dev_get(di.dev_id)))
791 return -ENODEV;
792
793 strcpy(di.name, hdev->name);
794 di.bdaddr = hdev->bdaddr;
795 di.type = hdev->type;
796 di.flags = hdev->flags;
797 di.pkt_type = hdev->pkt_type;
798 di.acl_mtu = hdev->acl_mtu;
799 di.acl_pkts = hdev->acl_pkts;
800 di.sco_mtu = hdev->sco_mtu;
801 di.sco_pkts = hdev->sco_pkts;
802 di.link_policy = hdev->link_policy;
803 di.link_mode = hdev->link_mode;
804
805 memcpy(&di.stat, &hdev->stat, sizeof(di.stat));
806 memcpy(&di.features, &hdev->features, sizeof(di.features));
807
808 if (copy_to_user(arg, &di, sizeof(di)))
809 err = -EFAULT;
810
811 hci_dev_put(hdev);
812
813 return err;
814}
815
816/* ---- Interface to HCI drivers ---- */
817
818/* Alloc HCI device */
819struct hci_dev *hci_alloc_dev(void)
820{
821 struct hci_dev *hdev;
822
Marcel Holtmann25ea6db2006-07-06 15:40:09 +0200823 hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 if (!hdev)
825 return NULL;
826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 skb_queue_head_init(&hdev->driver_init);
828
829 return hdev;
830}
831EXPORT_SYMBOL(hci_alloc_dev);
832
833/* Free HCI device */
834void hci_free_dev(struct hci_dev *hdev)
835{
836 skb_queue_purge(&hdev->driver_init);
837
Marcel Holtmanna91f2e32006-07-03 10:02:41 +0200838 /* will free via device release */
839 put_device(&hdev->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840}
841EXPORT_SYMBOL(hci_free_dev);
842
843/* Register HCI device */
844int hci_register_dev(struct hci_dev *hdev)
845{
846 struct list_head *head = &hci_dev_list, *p;
Marcel Holtmannef222012007-07-11 06:42:04 +0200847 int i, id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
849 BT_DBG("%p name %s type %d owner %p", hdev, hdev->name, hdev->type, hdev->owner);
850
851 if (!hdev->open || !hdev->close || !hdev->destruct)
852 return -EINVAL;
853
854 write_lock_bh(&hci_dev_list_lock);
855
856 /* Find first available device id */
857 list_for_each(p, &hci_dev_list) {
858 if (list_entry(p, struct hci_dev, list)->id != id)
859 break;
860 head = p; id++;
861 }
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 sprintf(hdev->name, "hci%d", id);
864 hdev->id = id;
865 list_add(&hdev->list, head);
866
867 atomic_set(&hdev->refcnt, 1);
868 spin_lock_init(&hdev->lock);
869
870 hdev->flags = 0;
871 hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200872 hdev->esco_type = (ESCO_HV1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 hdev->link_mode = (HCI_LM_ACCEPT);
874
Marcel Holtmann04837f62006-07-03 10:02:33 +0200875 hdev->idle_timeout = 0;
876 hdev->sniff_max_interval = 800;
877 hdev->sniff_min_interval = 80;
878
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 tasklet_init(&hdev->cmd_task, hci_cmd_task,(unsigned long) hdev);
880 tasklet_init(&hdev->rx_task, hci_rx_task, (unsigned long) hdev);
881 tasklet_init(&hdev->tx_task, hci_tx_task, (unsigned long) hdev);
882
883 skb_queue_head_init(&hdev->rx_q);
884 skb_queue_head_init(&hdev->cmd_q);
885 skb_queue_head_init(&hdev->raw_q);
886
Marcel Holtmannef222012007-07-11 06:42:04 +0200887 for (i = 0; i < 3; i++)
888 hdev->reassembly[i] = NULL;
889
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 init_waitqueue_head(&hdev->req_wait_q);
891 init_MUTEX(&hdev->req_lock);
892
893 inquiry_cache_init(hdev);
894
895 hci_conn_hash_init(hdev);
896
897 memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
898
899 atomic_set(&hdev->promisc, 0);
900
901 write_unlock_bh(&hci_dev_list_lock);
902
903 hci_register_sysfs(hdev);
904
905 hci_notify(hdev, HCI_DEV_REG);
906
907 return id;
908}
909EXPORT_SYMBOL(hci_register_dev);
910
911/* Unregister HCI device */
912int hci_unregister_dev(struct hci_dev *hdev)
913{
Marcel Holtmannef222012007-07-11 06:42:04 +0200914 int i;
915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 BT_DBG("%p name %s type %d", hdev, hdev->name, hdev->type);
917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 write_lock_bh(&hci_dev_list_lock);
919 list_del(&hdev->list);
920 write_unlock_bh(&hci_dev_list_lock);
921
922 hci_dev_do_close(hdev);
923
Marcel Holtmannef222012007-07-11 06:42:04 +0200924 for (i = 0; i < 3; i++)
925 kfree_skb(hdev->reassembly[i]);
926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 hci_notify(hdev, HCI_DEV_UNREG);
928
Dave Young147e2d52008-03-05 18:45:59 -0800929 hci_unregister_sysfs(hdev);
930
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 __hci_dev_put(hdev);
Marcel Holtmannef222012007-07-11 06:42:04 +0200932
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 return 0;
934}
935EXPORT_SYMBOL(hci_unregister_dev);
936
937/* Suspend HCI device */
938int hci_suspend_dev(struct hci_dev *hdev)
939{
940 hci_notify(hdev, HCI_DEV_SUSPEND);
941 return 0;
942}
943EXPORT_SYMBOL(hci_suspend_dev);
944
945/* Resume HCI device */
946int hci_resume_dev(struct hci_dev *hdev)
947{
948 hci_notify(hdev, HCI_DEV_RESUME);
949 return 0;
950}
951EXPORT_SYMBOL(hci_resume_dev);
952
Marcel Holtmannef222012007-07-11 06:42:04 +0200953/* Receive packet type fragment */
954#define __reassembly(hdev, type) ((hdev)->reassembly[(type) - 2])
955
956int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count)
957{
958 if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT)
959 return -EILSEQ;
960
961 while (count) {
962 struct sk_buff *skb = __reassembly(hdev, type);
963 struct { int expect; } *scb;
964 int len = 0;
965
966 if (!skb) {
967 /* Start of the frame */
968
969 switch (type) {
970 case HCI_EVENT_PKT:
971 if (count >= HCI_EVENT_HDR_SIZE) {
972 struct hci_event_hdr *h = data;
973 len = HCI_EVENT_HDR_SIZE + h->plen;
974 } else
975 return -EILSEQ;
976 break;
977
978 case HCI_ACLDATA_PKT:
979 if (count >= HCI_ACL_HDR_SIZE) {
980 struct hci_acl_hdr *h = data;
981 len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
982 } else
983 return -EILSEQ;
984 break;
985
986 case HCI_SCODATA_PKT:
987 if (count >= HCI_SCO_HDR_SIZE) {
988 struct hci_sco_hdr *h = data;
989 len = HCI_SCO_HDR_SIZE + h->dlen;
990 } else
991 return -EILSEQ;
992 break;
993 }
994
995 skb = bt_skb_alloc(len, GFP_ATOMIC);
996 if (!skb) {
997 BT_ERR("%s no memory for packet", hdev->name);
998 return -ENOMEM;
999 }
1000
1001 skb->dev = (void *) hdev;
1002 bt_cb(skb)->pkt_type = type;
YOSHIFUJI Hideaki00ae02f2007-07-19 10:43:16 +09001003
Marcel Holtmannef222012007-07-11 06:42:04 +02001004 __reassembly(hdev, type) = skb;
1005
1006 scb = (void *) skb->cb;
1007 scb->expect = len;
1008 } else {
1009 /* Continuation */
1010
1011 scb = (void *) skb->cb;
1012 len = scb->expect;
1013 }
1014
1015 len = min(len, count);
1016
1017 memcpy(skb_put(skb, len), data, len);
1018
1019 scb->expect -= len;
1020
1021 if (scb->expect == 0) {
1022 /* Complete frame */
1023
1024 __reassembly(hdev, type) = NULL;
1025
1026 bt_cb(skb)->pkt_type = type;
1027 hci_recv_frame(skb);
1028 }
1029
1030 count -= len; data += len;
1031 }
1032
1033 return 0;
1034}
1035EXPORT_SYMBOL(hci_recv_fragment);
1036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037/* ---- Interface to upper protocols ---- */
1038
1039/* Register/Unregister protocols.
1040 * hci_task_lock is used to ensure that no tasks are running. */
1041int hci_register_proto(struct hci_proto *hp)
1042{
1043 int err = 0;
1044
1045 BT_DBG("%p name %s id %d", hp, hp->name, hp->id);
1046
1047 if (hp->id >= HCI_MAX_PROTO)
1048 return -EINVAL;
1049
1050 write_lock_bh(&hci_task_lock);
1051
1052 if (!hci_proto[hp->id])
1053 hci_proto[hp->id] = hp;
1054 else
1055 err = -EEXIST;
1056
1057 write_unlock_bh(&hci_task_lock);
1058
1059 return err;
1060}
1061EXPORT_SYMBOL(hci_register_proto);
1062
1063int hci_unregister_proto(struct hci_proto *hp)
1064{
1065 int err = 0;
1066
1067 BT_DBG("%p name %s id %d", hp, hp->name, hp->id);
1068
1069 if (hp->id >= HCI_MAX_PROTO)
1070 return -EINVAL;
1071
1072 write_lock_bh(&hci_task_lock);
1073
1074 if (hci_proto[hp->id])
1075 hci_proto[hp->id] = NULL;
1076 else
1077 err = -ENOENT;
1078
1079 write_unlock_bh(&hci_task_lock);
1080
1081 return err;
1082}
1083EXPORT_SYMBOL(hci_unregister_proto);
1084
1085int hci_register_cb(struct hci_cb *cb)
1086{
1087 BT_DBG("%p name %s", cb, cb->name);
1088
1089 write_lock_bh(&hci_cb_list_lock);
1090 list_add(&cb->list, &hci_cb_list);
1091 write_unlock_bh(&hci_cb_list_lock);
1092
1093 return 0;
1094}
1095EXPORT_SYMBOL(hci_register_cb);
1096
1097int hci_unregister_cb(struct hci_cb *cb)
1098{
1099 BT_DBG("%p name %s", cb, cb->name);
1100
1101 write_lock_bh(&hci_cb_list_lock);
1102 list_del(&cb->list);
1103 write_unlock_bh(&hci_cb_list_lock);
1104
1105 return 0;
1106}
1107EXPORT_SYMBOL(hci_unregister_cb);
1108
1109static int hci_send_frame(struct sk_buff *skb)
1110{
1111 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
1112
1113 if (!hdev) {
1114 kfree_skb(skb);
1115 return -ENODEV;
1116 }
1117
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001118 BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
1120 if (atomic_read(&hdev->promisc)) {
1121 /* Time stamp */
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001122 __net_timestamp(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
1124 hci_send_to_sock(hdev, skb);
1125 }
1126
1127 /* Get rid of skb owner, prior to sending to the driver. */
1128 skb_orphan(skb);
1129
1130 return hdev->send(skb);
1131}
1132
1133/* Send HCI command */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001134int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135{
1136 int len = HCI_COMMAND_HDR_SIZE + plen;
1137 struct hci_command_hdr *hdr;
1138 struct sk_buff *skb;
1139
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001140 BT_DBG("%s opcode 0x%x plen %d", hdev->name, opcode, plen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
1142 skb = bt_skb_alloc(len, GFP_ATOMIC);
1143 if (!skb) {
Marcel Holtmannef222012007-07-11 06:42:04 +02001144 BT_ERR("%s no memory for command", hdev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 return -ENOMEM;
1146 }
1147
1148 hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE);
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001149 hdr->opcode = cpu_to_le16(opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 hdr->plen = plen;
1151
1152 if (plen)
1153 memcpy(skb_put(skb, plen), param, plen);
1154
1155 BT_DBG("skb len %d", skb->len);
1156
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001157 bt_cb(skb)->pkt_type = HCI_COMMAND_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 skb->dev = (void *) hdev;
1159 skb_queue_tail(&hdev->cmd_q, skb);
1160 hci_sched_cmd(hdev);
1161
1162 return 0;
1163}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
1165/* Get data from the previously sent command */
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001166void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
1168 struct hci_command_hdr *hdr;
1169
1170 if (!hdev->sent_cmd)
1171 return NULL;
1172
1173 hdr = (void *) hdev->sent_cmd->data;
1174
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001175 if (hdr->opcode != cpu_to_le16(opcode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 return NULL;
1177
Marcel Holtmanna9de9242007-10-20 13:33:56 +02001178 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180 return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE;
1181}
1182
1183/* Send ACL data */
1184static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags)
1185{
1186 struct hci_acl_hdr *hdr;
1187 int len = skb->len;
1188
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001189 skb_push(skb, HCI_ACL_HDR_SIZE);
1190 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001191 hdr = (struct hci_acl_hdr *)skb_transport_header(skb);
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07001192 hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags));
1193 hdr->dlen = cpu_to_le16(len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194}
1195
1196int hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags)
1197{
1198 struct hci_dev *hdev = conn->hdev;
1199 struct sk_buff *list;
1200
1201 BT_DBG("%s conn %p flags 0x%x", hdev->name, conn, flags);
1202
1203 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001204 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 hci_add_acl_hdr(skb, conn->handle, flags | ACL_START);
1206
1207 if (!(list = skb_shinfo(skb)->frag_list)) {
1208 /* Non fragmented */
1209 BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len);
1210
1211 skb_queue_tail(&conn->data_q, skb);
1212 } else {
1213 /* Fragmented */
1214 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
1215
1216 skb_shinfo(skb)->frag_list = NULL;
1217
1218 /* Queue all fragments atomically */
1219 spin_lock_bh(&conn->data_q.lock);
1220
1221 __skb_queue_tail(&conn->data_q, skb);
1222 do {
1223 skb = list; list = list->next;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001224
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001226 bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 hci_add_acl_hdr(skb, conn->handle, flags | ACL_CONT);
1228
1229 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
1230
1231 __skb_queue_tail(&conn->data_q, skb);
1232 } while (list);
1233
1234 spin_unlock_bh(&conn->data_q.lock);
1235 }
1236
1237 hci_sched_tx(hdev);
1238 return 0;
1239}
1240EXPORT_SYMBOL(hci_send_acl);
1241
1242/* Send SCO data */
1243int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb)
1244{
1245 struct hci_dev *hdev = conn->hdev;
1246 struct hci_sco_hdr hdr;
1247
1248 BT_DBG("%s len %d", hdev->name, skb->len);
1249
1250 if (skb->len > hdev->sco_mtu) {
1251 kfree_skb(skb);
1252 return -EINVAL;
1253 }
1254
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -07001255 hdr.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 hdr.dlen = skb->len;
1257
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001258 skb_push(skb, HCI_SCO_HDR_SIZE);
1259 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001260 memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
1262 skb->dev = (void *) hdev;
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001263 bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 skb_queue_tail(&conn->data_q, skb);
1265 hci_sched_tx(hdev);
1266 return 0;
1267}
1268EXPORT_SYMBOL(hci_send_sco);
1269
1270/* ---- HCI TX task (outgoing data) ---- */
1271
1272/* HCI Connection scheduler */
1273static inline struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, int *quote)
1274{
1275 struct hci_conn_hash *h = &hdev->conn_hash;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +02001276 struct hci_conn *conn = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 int num = 0, min = ~0;
1278 struct list_head *p;
1279
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001280 /* We don't have to lock device here. Connections are always
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 * added and removed with TX task disabled. */
1282 list_for_each(p, &h->list) {
1283 struct hci_conn *c;
1284 c = list_entry(p, struct hci_conn, list);
1285
Marcel Holtmann769be972008-07-14 20:13:49 +02001286 if (c->type != type || skb_queue_empty(&c->data_q))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 continue;
Marcel Holtmann769be972008-07-14 20:13:49 +02001288
1289 if (c->state != BT_CONNECTED && c->state != BT_CONFIG)
1290 continue;
1291
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 num++;
1293
1294 if (c->sent < min) {
1295 min = c->sent;
1296 conn = c;
1297 }
1298 }
1299
1300 if (conn) {
1301 int cnt = (type == ACL_LINK ? hdev->acl_cnt : hdev->sco_cnt);
1302 int q = cnt / num;
1303 *quote = q ? q : 1;
1304 } else
1305 *quote = 0;
1306
1307 BT_DBG("conn %p quote %d", conn, *quote);
1308 return conn;
1309}
1310
1311static inline void hci_acl_tx_to(struct hci_dev *hdev)
1312{
1313 struct hci_conn_hash *h = &hdev->conn_hash;
1314 struct list_head *p;
1315 struct hci_conn *c;
1316
1317 BT_ERR("%s ACL tx timeout", hdev->name);
1318
1319 /* Kill stalled connections */
1320 list_for_each(p, &h->list) {
1321 c = list_entry(p, struct hci_conn, list);
1322 if (c->type == ACL_LINK && c->sent) {
1323 BT_ERR("%s killing stalled ACL connection %s",
1324 hdev->name, batostr(&c->dst));
1325 hci_acl_disconn(c, 0x13);
1326 }
1327 }
1328}
1329
1330static inline void hci_sched_acl(struct hci_dev *hdev)
1331{
1332 struct hci_conn *conn;
1333 struct sk_buff *skb;
1334 int quote;
1335
1336 BT_DBG("%s", hdev->name);
1337
1338 if (!test_bit(HCI_RAW, &hdev->flags)) {
1339 /* ACL tx timeout must be longer than maximum
1340 * link supervision timeout (40.9 seconds) */
S.Çağlar Onur824530212008-02-17 23:25:57 -08001341 if (!hdev->acl_cnt && time_after(jiffies, hdev->acl_last_tx + HZ * 45))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 hci_acl_tx_to(hdev);
1343 }
1344
1345 while (hdev->acl_cnt && (conn = hci_low_sent(hdev, ACL_LINK, &quote))) {
1346 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
1347 BT_DBG("skb %p len %d", skb, skb->len);
Marcel Holtmann04837f62006-07-03 10:02:33 +02001348
1349 hci_conn_enter_active_mode(conn);
1350
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 hci_send_frame(skb);
1352 hdev->acl_last_tx = jiffies;
1353
1354 hdev->acl_cnt--;
1355 conn->sent++;
1356 }
1357 }
1358}
1359
1360/* Schedule SCO */
1361static inline void hci_sched_sco(struct hci_dev *hdev)
1362{
1363 struct hci_conn *conn;
1364 struct sk_buff *skb;
1365 int quote;
1366
1367 BT_DBG("%s", hdev->name);
1368
1369 while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, &quote))) {
1370 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
1371 BT_DBG("skb %p len %d", skb, skb->len);
1372 hci_send_frame(skb);
1373
1374 conn->sent++;
1375 if (conn->sent == ~0)
1376 conn->sent = 0;
1377 }
1378 }
1379}
1380
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001381static inline void hci_sched_esco(struct hci_dev *hdev)
1382{
1383 struct hci_conn *conn;
1384 struct sk_buff *skb;
1385 int quote;
1386
1387 BT_DBG("%s", hdev->name);
1388
1389 while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, &quote))) {
1390 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
1391 BT_DBG("skb %p len %d", skb, skb->len);
1392 hci_send_frame(skb);
1393
1394 conn->sent++;
1395 if (conn->sent == ~0)
1396 conn->sent = 0;
1397 }
1398 }
1399}
1400
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401static void hci_tx_task(unsigned long arg)
1402{
1403 struct hci_dev *hdev = (struct hci_dev *) arg;
1404 struct sk_buff *skb;
1405
1406 read_lock(&hci_task_lock);
1407
1408 BT_DBG("%s acl %d sco %d", hdev->name, hdev->acl_cnt, hdev->sco_cnt);
1409
1410 /* Schedule queues and send stuff to HCI driver */
1411
1412 hci_sched_acl(hdev);
1413
1414 hci_sched_sco(hdev);
1415
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +02001416 hci_sched_esco(hdev);
1417
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 /* Send next queued raw (unknown type) packet */
1419 while ((skb = skb_dequeue(&hdev->raw_q)))
1420 hci_send_frame(skb);
1421
1422 read_unlock(&hci_task_lock);
1423}
1424
1425/* ----- HCI RX task (incoming data proccessing) ----- */
1426
1427/* ACL data packet */
1428static inline void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb)
1429{
1430 struct hci_acl_hdr *hdr = (void *) skb->data;
1431 struct hci_conn *conn;
1432 __u16 handle, flags;
1433
1434 skb_pull(skb, HCI_ACL_HDR_SIZE);
1435
1436 handle = __le16_to_cpu(hdr->handle);
1437 flags = hci_flags(handle);
1438 handle = hci_handle(handle);
1439
1440 BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev->name, skb->len, handle, flags);
1441
1442 hdev->stat.acl_rx++;
1443
1444 hci_dev_lock(hdev);
1445 conn = hci_conn_hash_lookup_handle(hdev, handle);
1446 hci_dev_unlock(hdev);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001447
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 if (conn) {
1449 register struct hci_proto *hp;
1450
Marcel Holtmann04837f62006-07-03 10:02:33 +02001451 hci_conn_enter_active_mode(conn);
1452
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 /* Send to upper protocol */
1454 if ((hp = hci_proto[HCI_PROTO_L2CAP]) && hp->recv_acldata) {
1455 hp->recv_acldata(conn, skb, flags);
1456 return;
1457 }
1458 } else {
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001459 BT_ERR("%s ACL packet for unknown connection handle %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 hdev->name, handle);
1461 }
1462
1463 kfree_skb(skb);
1464}
1465
1466/* SCO data packet */
1467static inline void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb)
1468{
1469 struct hci_sco_hdr *hdr = (void *) skb->data;
1470 struct hci_conn *conn;
1471 __u16 handle;
1472
1473 skb_pull(skb, HCI_SCO_HDR_SIZE);
1474
1475 handle = __le16_to_cpu(hdr->handle);
1476
1477 BT_DBG("%s len %d handle 0x%x", hdev->name, skb->len, handle);
1478
1479 hdev->stat.sco_rx++;
1480
1481 hci_dev_lock(hdev);
1482 conn = hci_conn_hash_lookup_handle(hdev, handle);
1483 hci_dev_unlock(hdev);
1484
1485 if (conn) {
1486 register struct hci_proto *hp;
1487
1488 /* Send to upper protocol */
1489 if ((hp = hci_proto[HCI_PROTO_SCO]) && hp->recv_scodata) {
1490 hp->recv_scodata(conn, skb);
1491 return;
1492 }
1493 } else {
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001494 BT_ERR("%s SCO packet for unknown connection handle %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 hdev->name, handle);
1496 }
1497
1498 kfree_skb(skb);
1499}
1500
Marcel Holtmann65164552005-10-28 19:20:48 +02001501static void hci_rx_task(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502{
1503 struct hci_dev *hdev = (struct hci_dev *) arg;
1504 struct sk_buff *skb;
1505
1506 BT_DBG("%s", hdev->name);
1507
1508 read_lock(&hci_task_lock);
1509
1510 while ((skb = skb_dequeue(&hdev->rx_q))) {
1511 if (atomic_read(&hdev->promisc)) {
1512 /* Send copy to the sockets */
1513 hci_send_to_sock(hdev, skb);
1514 }
1515
1516 if (test_bit(HCI_RAW, &hdev->flags)) {
1517 kfree_skb(skb);
1518 continue;
1519 }
1520
1521 if (test_bit(HCI_INIT, &hdev->flags)) {
1522 /* Don't process data packets in this states. */
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001523 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 case HCI_ACLDATA_PKT:
1525 case HCI_SCODATA_PKT:
1526 kfree_skb(skb);
1527 continue;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 }
1530
1531 /* Process frame */
Marcel Holtmann0d48d932005-08-09 20:30:28 -07001532 switch (bt_cb(skb)->pkt_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 case HCI_EVENT_PKT:
1534 hci_event_packet(hdev, skb);
1535 break;
1536
1537 case HCI_ACLDATA_PKT:
1538 BT_DBG("%s ACL data packet", hdev->name);
1539 hci_acldata_packet(hdev, skb);
1540 break;
1541
1542 case HCI_SCODATA_PKT:
1543 BT_DBG("%s SCO data packet", hdev->name);
1544 hci_scodata_packet(hdev, skb);
1545 break;
1546
1547 default:
1548 kfree_skb(skb);
1549 break;
1550 }
1551 }
1552
1553 read_unlock(&hci_task_lock);
1554}
1555
1556static void hci_cmd_task(unsigned long arg)
1557{
1558 struct hci_dev *hdev = (struct hci_dev *) arg;
1559 struct sk_buff *skb;
1560
1561 BT_DBG("%s cmd %d", hdev->name, atomic_read(&hdev->cmd_cnt));
1562
S.Çağlar Onur824530212008-02-17 23:25:57 -08001563 if (!atomic_read(&hdev->cmd_cnt) && time_after(jiffies, hdev->cmd_last_tx + HZ)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 BT_ERR("%s command tx timeout", hdev->name);
1565 atomic_set(&hdev->cmd_cnt, 1);
1566 }
1567
1568 /* Send queued commands */
1569 if (atomic_read(&hdev->cmd_cnt) && (skb = skb_dequeue(&hdev->cmd_q))) {
1570 if (hdev->sent_cmd)
1571 kfree_skb(hdev->sent_cmd);
1572
1573 if ((hdev->sent_cmd = skb_clone(skb, GFP_ATOMIC))) {
1574 atomic_dec(&hdev->cmd_cnt);
1575 hci_send_frame(skb);
1576 hdev->cmd_last_tx = jiffies;
1577 } else {
1578 skb_queue_head(&hdev->cmd_q, skb);
1579 hci_sched_cmd(hdev);
1580 }
1581 }
1582}