2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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
15 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
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
25 /* Bluetooth HCI core. */
27 #include <linux/config.h>
28 #include <linux/module.h>
29 #include <linux/kmod.h>
31 #include <linux/types.h>
32 #include <linux/errno.h>
33 #include <linux/kernel.h>
34 #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>
44 #include <asm/system.h>
45 #include <asm/uaccess.h>
46 #include <asm/unaligned.h>
48 #include <net/bluetooth/bluetooth.h>
49 #include <net/bluetooth/hci_core.h>
51 #ifndef CONFIG_BT_HCI_CORE_DEBUG
56 static void hci_cmd_task(unsigned long arg
);
57 static void hci_rx_task(unsigned long arg
);
58 static void hci_tx_task(unsigned long arg
);
59 static void hci_notify(struct hci_dev
*hdev
, int event
);
61 static DEFINE_RWLOCK(hci_task_lock
);
64 LIST_HEAD(hci_dev_list
);
65 DEFINE_RWLOCK(hci_dev_list_lock
);
67 /* HCI callback list */
68 LIST_HEAD(hci_cb_list
);
69 DEFINE_RWLOCK(hci_cb_list_lock
);
72 #define HCI_MAX_PROTO 2
73 struct hci_proto
*hci_proto
[HCI_MAX_PROTO
];
75 /* HCI notifiers list */
76 static struct notifier_block
*hci_notifier
;
78 /* ---- HCI notifications ---- */
80 int hci_register_notifier(struct notifier_block
*nb
)
82 return notifier_chain_register(&hci_notifier
, nb
);
85 int hci_unregister_notifier(struct notifier_block
*nb
)
87 return notifier_chain_unregister(&hci_notifier
, nb
);
90 void hci_notify(struct hci_dev
*hdev
, int event
)
92 notifier_call_chain(&hci_notifier
, event
, hdev
);
95 /* ---- HCI requests ---- */
97 void hci_req_complete(struct hci_dev
*hdev
, int result
)
99 BT_DBG("%s result 0x%2.2x", hdev
->name
, result
);
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
);
108 static void hci_req_cancel(struct hci_dev
*hdev
, int err
)
110 BT_DBG("%s err 0x%2.2x", hdev
->name
, err
);
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
);
119 /* Execute request and wait for completion. */
120 static int __hci_request(struct hci_dev
*hdev
, void (*req
)(struct hci_dev
*hdev
, unsigned long opt
),
121 unsigned long opt
, __u32 timeout
)
123 DECLARE_WAITQUEUE(wait
, current
);
126 BT_DBG("%s start", hdev
->name
);
128 hdev
->req_status
= HCI_REQ_PEND
;
130 add_wait_queue(&hdev
->req_wait_q
, &wait
);
131 set_current_state(TASK_INTERRUPTIBLE
);
134 schedule_timeout(timeout
);
136 remove_wait_queue(&hdev
->req_wait_q
, &wait
);
138 if (signal_pending(current
))
141 switch (hdev
->req_status
) {
143 err
= -bt_err(hdev
->req_result
);
146 case HCI_REQ_CANCELED
:
147 err
= -hdev
->req_result
;
155 hdev
->req_status
= hdev
->req_result
= 0;
157 BT_DBG("%s end: err %d", hdev
->name
, err
);
162 static inline int hci_request(struct hci_dev
*hdev
, void (*req
)(struct hci_dev
*hdev
, unsigned long opt
),
163 unsigned long opt
, __u32 timeout
)
167 /* Serialize all requests */
169 ret
= __hci_request(hdev
, req
, opt
, timeout
);
170 hci_req_unlock(hdev
);
175 static void hci_reset_req(struct hci_dev
*hdev
, unsigned long opt
)
177 BT_DBG("%s %ld", hdev
->name
, opt
);
180 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_RESET
, 0, NULL
);
183 static void hci_init_req(struct hci_dev
*hdev
, unsigned long opt
)
188 BT_DBG("%s %ld", hdev
->name
, opt
);
190 /* Driver initialization */
192 /* Special commands */
193 while ((skb
= skb_dequeue(&hdev
->driver_init
))) {
194 bt_cb(skb
)->pkt_type
= HCI_COMMAND_PKT
;
195 skb
->dev
= (void *) hdev
;
196 skb_queue_tail(&hdev
->cmd_q
, skb
);
199 skb_queue_purge(&hdev
->driver_init
);
201 /* Mandatory initialization */
204 if (test_bit(HCI_QUIRK_RESET_ON_INIT
, &hdev
->quirks
))
205 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_RESET
, 0, NULL
);
207 /* Read Local Supported Features */
208 hci_send_cmd(hdev
, OGF_INFO_PARAM
, OCF_READ_LOCAL_FEATURES
, 0, NULL
);
210 /* Read Buffer Size (ACL mtu, max pkt, etc.) */
211 hci_send_cmd(hdev
, OGF_INFO_PARAM
, OCF_READ_BUFFER_SIZE
, 0, NULL
);
214 /* Host buffer size */
216 struct hci_cp_host_buffer_size cp
;
217 cp
.acl_mtu
= __cpu_to_le16(HCI_MAX_ACL_SIZE
);
218 cp
.sco_mtu
= HCI_MAX_SCO_SIZE
;
219 cp
.acl_max_pkt
= __cpu_to_le16(0xffff);
220 cp
.sco_max_pkt
= __cpu_to_le16(0xffff);
221 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_HOST_BUFFER_SIZE
, sizeof(cp
), &cp
);
225 /* Read BD Address */
226 hci_send_cmd(hdev
, OGF_INFO_PARAM
, OCF_READ_BD_ADDR
, 0, NULL
);
228 /* Read Voice Setting */
229 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_READ_VOICE_SETTING
, 0, NULL
);
231 /* Optional initialization */
233 /* Clear Event Filters */
235 struct hci_cp_set_event_flt cp
;
236 cp
.flt_type
= HCI_FLT_CLEAR_ALL
;
237 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_SET_EVENT_FLT
, sizeof(cp
), &cp
);
240 /* Page timeout ~20 secs */
241 param
= __cpu_to_le16(0x8000);
242 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_WRITE_PG_TIMEOUT
, 2, ¶m
);
244 /* Connection accept timeout ~20 secs */
245 param
= __cpu_to_le16(0x7d00);
246 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_WRITE_CA_TIMEOUT
, 2, ¶m
);
249 static void hci_scan_req(struct hci_dev
*hdev
, unsigned long opt
)
253 BT_DBG("%s %x", hdev
->name
, scan
);
255 /* Inquiry and Page scans */
256 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_WRITE_SCAN_ENABLE
, 1, &scan
);
259 static void hci_auth_req(struct hci_dev
*hdev
, unsigned long opt
)
263 BT_DBG("%s %x", hdev
->name
, auth
);
266 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_WRITE_AUTH_ENABLE
, 1, &auth
);
269 static void hci_encrypt_req(struct hci_dev
*hdev
, unsigned long opt
)
273 BT_DBG("%s %x", hdev
->name
, encrypt
);
276 hci_send_cmd(hdev
, OGF_HOST_CTL
, OCF_WRITE_ENCRYPT_MODE
, 1, &encrypt
);
279 /* Get HCI device by index.
280 * Device is held on return. */
281 struct hci_dev
*hci_dev_get(int index
)
283 struct hci_dev
*hdev
= NULL
;
291 read_lock(&hci_dev_list_lock
);
292 list_for_each(p
, &hci_dev_list
) {
293 struct hci_dev
*d
= list_entry(p
, struct hci_dev
, list
);
294 if (d
->id
== index
) {
295 hdev
= hci_dev_hold(d
);
299 read_unlock(&hci_dev_list_lock
);
303 /* ---- Inquiry support ---- */
304 static void inquiry_cache_flush(struct hci_dev
*hdev
)
306 struct inquiry_cache
*cache
= &hdev
->inq_cache
;
307 struct inquiry_entry
*next
= cache
->list
, *e
;
309 BT_DBG("cache %p", cache
);
318 struct inquiry_entry
*hci_inquiry_cache_lookup(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
)
320 struct inquiry_cache
*cache
= &hdev
->inq_cache
;
321 struct inquiry_entry
*e
;
323 BT_DBG("cache %p, %s", cache
, batostr(bdaddr
));
325 for (e
= cache
->list
; e
; e
= e
->next
)
326 if (!bacmp(&e
->data
.bdaddr
, bdaddr
))
331 void hci_inquiry_cache_update(struct hci_dev
*hdev
, struct inquiry_data
*data
)
333 struct inquiry_cache
*cache
= &hdev
->inq_cache
;
334 struct inquiry_entry
*e
;
336 BT_DBG("cache %p, %s", cache
, batostr(&data
->bdaddr
));
338 if (!(e
= hci_inquiry_cache_lookup(hdev
, &data
->bdaddr
))) {
339 /* Entry not in the cache. Add new one. */
340 if (!(e
= kmalloc(sizeof(struct inquiry_entry
), GFP_ATOMIC
)))
342 memset(e
, 0, sizeof(struct inquiry_entry
));
343 e
->next
= cache
->list
;
347 memcpy(&e
->data
, data
, sizeof(*data
));
348 e
->timestamp
= jiffies
;
349 cache
->timestamp
= jiffies
;
352 static int inquiry_cache_dump(struct hci_dev
*hdev
, int num
, __u8
*buf
)
354 struct inquiry_cache
*cache
= &hdev
->inq_cache
;
355 struct inquiry_info
*info
= (struct inquiry_info
*) buf
;
356 struct inquiry_entry
*e
;
359 for (e
= cache
->list
; e
&& copied
< num
; e
= e
->next
, copied
++) {
360 struct inquiry_data
*data
= &e
->data
;
361 bacpy(&info
->bdaddr
, &data
->bdaddr
);
362 info
->pscan_rep_mode
= data
->pscan_rep_mode
;
363 info
->pscan_period_mode
= data
->pscan_period_mode
;
364 info
->pscan_mode
= data
->pscan_mode
;
365 memcpy(info
->dev_class
, data
->dev_class
, 3);
366 info
->clock_offset
= data
->clock_offset
;
370 BT_DBG("cache %p, copied %d", cache
, copied
);
374 static void hci_inq_req(struct hci_dev
*hdev
, unsigned long opt
)
376 struct hci_inquiry_req
*ir
= (struct hci_inquiry_req
*) opt
;
377 struct hci_cp_inquiry cp
;
379 BT_DBG("%s", hdev
->name
);
381 if (test_bit(HCI_INQUIRY
, &hdev
->flags
))
385 memcpy(&cp
.lap
, &ir
->lap
, 3);
386 cp
.length
= ir
->length
;
387 cp
.num_rsp
= ir
->num_rsp
;
388 hci_send_cmd(hdev
, OGF_LINK_CTL
, OCF_INQUIRY
, sizeof(cp
), &cp
);
391 int hci_inquiry(void __user
*arg
)
393 __u8 __user
*ptr
= arg
;
394 struct hci_inquiry_req ir
;
395 struct hci_dev
*hdev
;
396 int err
= 0, do_inquiry
= 0, max_rsp
;
400 if (copy_from_user(&ir
, ptr
, sizeof(ir
)))
403 if (!(hdev
= hci_dev_get(ir
.dev_id
)))
406 hci_dev_lock_bh(hdev
);
407 if (inquiry_cache_age(hdev
) > INQUIRY_CACHE_AGE_MAX
||
408 inquiry_cache_empty(hdev
) ||
409 ir
.flags
& IREQ_CACHE_FLUSH
) {
410 inquiry_cache_flush(hdev
);
413 hci_dev_unlock_bh(hdev
);
415 timeo
= ir
.length
* 2 * HZ
;
416 if (do_inquiry
&& (err
= hci_request(hdev
, hci_inq_req
, (unsigned long)&ir
, timeo
)) < 0)
419 /* for unlimited number of responses we will use buffer with 255 entries */
420 max_rsp
= (ir
.num_rsp
== 0) ? 255 : ir
.num_rsp
;
422 /* cache_dump can't sleep. Therefore we allocate temp buffer and then
423 * copy it to the user space.
425 if (!(buf
= kmalloc(sizeof(struct inquiry_info
) * max_rsp
, GFP_KERNEL
))) {
430 hci_dev_lock_bh(hdev
);
431 ir
.num_rsp
= inquiry_cache_dump(hdev
, max_rsp
, buf
);
432 hci_dev_unlock_bh(hdev
);
434 BT_DBG("num_rsp %d", ir
.num_rsp
);
436 if (!copy_to_user(ptr
, &ir
, sizeof(ir
))) {
438 if (copy_to_user(ptr
, buf
, sizeof(struct inquiry_info
) *
451 /* ---- HCI ioctl helpers ---- */
453 int hci_dev_open(__u16 dev
)
455 struct hci_dev
*hdev
;
458 if (!(hdev
= hci_dev_get(dev
)))
461 BT_DBG("%s %p", hdev
->name
, hdev
);
465 if (test_bit(HCI_UP
, &hdev
->flags
)) {
470 if (test_bit(HCI_QUIRK_RAW_DEVICE
, &hdev
->quirks
))
471 set_bit(HCI_RAW
, &hdev
->flags
);
473 if (hdev
->open(hdev
)) {
478 if (!test_bit(HCI_RAW
, &hdev
->flags
)) {
479 atomic_set(&hdev
->cmd_cnt
, 1);
480 set_bit(HCI_INIT
, &hdev
->flags
);
482 //__hci_request(hdev, hci_reset_req, 0, HZ);
483 ret
= __hci_request(hdev
, hci_init_req
, 0, HCI_INIT_TIMEOUT
);
485 clear_bit(HCI_INIT
, &hdev
->flags
);
490 set_bit(HCI_UP
, &hdev
->flags
);
491 hci_notify(hdev
, HCI_DEV_UP
);
493 /* Init failed, cleanup */
494 tasklet_kill(&hdev
->rx_task
);
495 tasklet_kill(&hdev
->tx_task
);
496 tasklet_kill(&hdev
->cmd_task
);
498 skb_queue_purge(&hdev
->cmd_q
);
499 skb_queue_purge(&hdev
->rx_q
);
504 if (hdev
->sent_cmd
) {
505 kfree_skb(hdev
->sent_cmd
);
506 hdev
->sent_cmd
= NULL
;
514 hci_req_unlock(hdev
);
519 static int hci_dev_do_close(struct hci_dev
*hdev
)
521 BT_DBG("%s %p", hdev
->name
, hdev
);
523 hci_req_cancel(hdev
, ENODEV
);
526 if (!test_and_clear_bit(HCI_UP
, &hdev
->flags
)) {
527 hci_req_unlock(hdev
);
531 /* Kill RX and TX tasks */
532 tasklet_kill(&hdev
->rx_task
);
533 tasklet_kill(&hdev
->tx_task
);
535 hci_dev_lock_bh(hdev
);
536 inquiry_cache_flush(hdev
);
537 hci_conn_hash_flush(hdev
);
538 hci_dev_unlock_bh(hdev
);
540 hci_notify(hdev
, HCI_DEV_DOWN
);
546 skb_queue_purge(&hdev
->cmd_q
);
547 atomic_set(&hdev
->cmd_cnt
, 1);
548 if (!test_bit(HCI_RAW
, &hdev
->flags
)) {
549 set_bit(HCI_INIT
, &hdev
->flags
);
550 __hci_request(hdev
, hci_reset_req
, 0, HZ
/4);
551 clear_bit(HCI_INIT
, &hdev
->flags
);
555 tasklet_kill(&hdev
->cmd_task
);
558 skb_queue_purge(&hdev
->rx_q
);
559 skb_queue_purge(&hdev
->cmd_q
);
560 skb_queue_purge(&hdev
->raw_q
);
562 /* Drop last sent command */
563 if (hdev
->sent_cmd
) {
564 kfree_skb(hdev
->sent_cmd
);
565 hdev
->sent_cmd
= NULL
;
568 /* After this point our queues are empty
569 * and no tasks are scheduled. */
575 hci_req_unlock(hdev
);
581 int hci_dev_close(__u16 dev
)
583 struct hci_dev
*hdev
;
586 if (!(hdev
= hci_dev_get(dev
)))
588 err
= hci_dev_do_close(hdev
);
593 int hci_dev_reset(__u16 dev
)
595 struct hci_dev
*hdev
;
598 if (!(hdev
= hci_dev_get(dev
)))
602 tasklet_disable(&hdev
->tx_task
);
604 if (!test_bit(HCI_UP
, &hdev
->flags
))
608 skb_queue_purge(&hdev
->rx_q
);
609 skb_queue_purge(&hdev
->cmd_q
);
611 hci_dev_lock_bh(hdev
);
612 inquiry_cache_flush(hdev
);
613 hci_conn_hash_flush(hdev
);
614 hci_dev_unlock_bh(hdev
);
619 atomic_set(&hdev
->cmd_cnt
, 1);
620 hdev
->acl_cnt
= 0; hdev
->sco_cnt
= 0;
622 if (!test_bit(HCI_RAW
, &hdev
->flags
))
623 ret
= __hci_request(hdev
, hci_reset_req
, 0, HCI_INIT_TIMEOUT
);
626 tasklet_enable(&hdev
->tx_task
);
627 hci_req_unlock(hdev
);
632 int hci_dev_reset_stat(__u16 dev
)
634 struct hci_dev
*hdev
;
637 if (!(hdev
= hci_dev_get(dev
)))
640 memset(&hdev
->stat
, 0, sizeof(struct hci_dev_stats
));
647 int hci_dev_cmd(unsigned int cmd
, void __user
*arg
)
649 struct hci_dev
*hdev
;
650 struct hci_dev_req dr
;
653 if (copy_from_user(&dr
, arg
, sizeof(dr
)))
656 if (!(hdev
= hci_dev_get(dr
.dev_id
)))
661 err
= hci_request(hdev
, hci_auth_req
, dr
.dev_opt
, HCI_INIT_TIMEOUT
);
665 if (!lmp_encrypt_capable(hdev
)) {
670 if (!test_bit(HCI_AUTH
, &hdev
->flags
)) {
671 /* Auth must be enabled first */
672 err
= hci_request(hdev
, hci_auth_req
,
673 dr
.dev_opt
, HCI_INIT_TIMEOUT
);
678 err
= hci_request(hdev
, hci_encrypt_req
,
679 dr
.dev_opt
, HCI_INIT_TIMEOUT
);
683 err
= hci_request(hdev
, hci_scan_req
, dr
.dev_opt
, HCI_INIT_TIMEOUT
);
687 hdev
->pkt_type
= (__u16
) dr
.dev_opt
;
691 hdev
->link_policy
= (__u16
) dr
.dev_opt
;
695 hdev
->link_mode
= ((__u16
) dr
.dev_opt
) & (HCI_LM_MASTER
| HCI_LM_ACCEPT
);
699 hdev
->acl_mtu
= *((__u16
*)&dr
.dev_opt
+ 1);
700 hdev
->acl_pkts
= *((__u16
*)&dr
.dev_opt
+ 0);
704 hdev
->sco_mtu
= *((__u16
*)&dr
.dev_opt
+ 1);
705 hdev
->sco_pkts
= *((__u16
*)&dr
.dev_opt
+ 0);
716 int hci_get_dev_list(void __user
*arg
)
718 struct hci_dev_list_req
*dl
;
719 struct hci_dev_req
*dr
;
721 int n
= 0, size
, err
;
724 if (get_user(dev_num
, (__u16 __user
*) arg
))
727 if (!dev_num
|| dev_num
> (PAGE_SIZE
* 2) / sizeof(*dr
))
730 size
= sizeof(*dl
) + dev_num
* sizeof(*dr
);
732 if (!(dl
= kmalloc(size
, GFP_KERNEL
)))
737 read_lock_bh(&hci_dev_list_lock
);
738 list_for_each(p
, &hci_dev_list
) {
739 struct hci_dev
*hdev
;
740 hdev
= list_entry(p
, struct hci_dev
, list
);
741 (dr
+ n
)->dev_id
= hdev
->id
;
742 (dr
+ n
)->dev_opt
= hdev
->flags
;
746 read_unlock_bh(&hci_dev_list_lock
);
749 size
= sizeof(*dl
) + n
* sizeof(*dr
);
751 err
= copy_to_user(arg
, dl
, size
);
754 return err
? -EFAULT
: 0;
757 int hci_get_dev_info(void __user
*arg
)
759 struct hci_dev
*hdev
;
760 struct hci_dev_info di
;
763 if (copy_from_user(&di
, arg
, sizeof(di
)))
766 if (!(hdev
= hci_dev_get(di
.dev_id
)))
769 strcpy(di
.name
, hdev
->name
);
770 di
.bdaddr
= hdev
->bdaddr
;
771 di
.type
= hdev
->type
;
772 di
.flags
= hdev
->flags
;
773 di
.pkt_type
= hdev
->pkt_type
;
774 di
.acl_mtu
= hdev
->acl_mtu
;
775 di
.acl_pkts
= hdev
->acl_pkts
;
776 di
.sco_mtu
= hdev
->sco_mtu
;
777 di
.sco_pkts
= hdev
->sco_pkts
;
778 di
.link_policy
= hdev
->link_policy
;
779 di
.link_mode
= hdev
->link_mode
;
781 memcpy(&di
.stat
, &hdev
->stat
, sizeof(di
.stat
));
782 memcpy(&di
.features
, &hdev
->features
, sizeof(di
.features
));
784 if (copy_to_user(arg
, &di
, sizeof(di
)))
792 /* ---- Interface to HCI drivers ---- */
794 /* Alloc HCI device */
795 struct hci_dev
*hci_alloc_dev(void)
797 struct hci_dev
*hdev
;
799 hdev
= kmalloc(sizeof(struct hci_dev
), GFP_KERNEL
);
803 memset(hdev
, 0, sizeof(struct hci_dev
));
805 skb_queue_head_init(&hdev
->driver_init
);
809 EXPORT_SYMBOL(hci_alloc_dev
);
811 /* Free HCI device */
812 void hci_free_dev(struct hci_dev
*hdev
)
814 skb_queue_purge(&hdev
->driver_init
);
816 /* will free via class release */
817 class_device_put(&hdev
->class_dev
);
819 EXPORT_SYMBOL(hci_free_dev
);
821 /* Register HCI device */
822 int hci_register_dev(struct hci_dev
*hdev
)
824 struct list_head
*head
= &hci_dev_list
, *p
;
827 BT_DBG("%p name %s type %d owner %p", hdev
, hdev
->name
, hdev
->type
, hdev
->owner
);
829 if (!hdev
->open
|| !hdev
->close
|| !hdev
->destruct
)
832 write_lock_bh(&hci_dev_list_lock
);
834 /* Find first available device id */
835 list_for_each(p
, &hci_dev_list
) {
836 if (list_entry(p
, struct hci_dev
, list
)->id
!= id
)
841 sprintf(hdev
->name
, "hci%d", id
);
843 list_add(&hdev
->list
, head
);
845 atomic_set(&hdev
->refcnt
, 1);
846 spin_lock_init(&hdev
->lock
);
849 hdev
->pkt_type
= (HCI_DM1
| HCI_DH1
| HCI_HV1
);
850 hdev
->link_mode
= (HCI_LM_ACCEPT
);
852 tasklet_init(&hdev
->cmd_task
, hci_cmd_task
,(unsigned long) hdev
);
853 tasklet_init(&hdev
->rx_task
, hci_rx_task
, (unsigned long) hdev
);
854 tasklet_init(&hdev
->tx_task
, hci_tx_task
, (unsigned long) hdev
);
856 skb_queue_head_init(&hdev
->rx_q
);
857 skb_queue_head_init(&hdev
->cmd_q
);
858 skb_queue_head_init(&hdev
->raw_q
);
860 init_waitqueue_head(&hdev
->req_wait_q
);
861 init_MUTEX(&hdev
->req_lock
);
863 inquiry_cache_init(hdev
);
865 hci_conn_hash_init(hdev
);
867 memset(&hdev
->stat
, 0, sizeof(struct hci_dev_stats
));
869 atomic_set(&hdev
->promisc
, 0);
871 write_unlock_bh(&hci_dev_list_lock
);
873 hci_register_sysfs(hdev
);
875 hci_notify(hdev
, HCI_DEV_REG
);
879 EXPORT_SYMBOL(hci_register_dev
);
881 /* Unregister HCI device */
882 int hci_unregister_dev(struct hci_dev
*hdev
)
884 BT_DBG("%p name %s type %d", hdev
, hdev
->name
, hdev
->type
);
886 hci_unregister_sysfs(hdev
);
888 write_lock_bh(&hci_dev_list_lock
);
889 list_del(&hdev
->list
);
890 write_unlock_bh(&hci_dev_list_lock
);
892 hci_dev_do_close(hdev
);
894 hci_notify(hdev
, HCI_DEV_UNREG
);
899 EXPORT_SYMBOL(hci_unregister_dev
);
901 /* Suspend HCI device */
902 int hci_suspend_dev(struct hci_dev
*hdev
)
904 hci_notify(hdev
, HCI_DEV_SUSPEND
);
907 EXPORT_SYMBOL(hci_suspend_dev
);
909 /* Resume HCI device */
910 int hci_resume_dev(struct hci_dev
*hdev
)
912 hci_notify(hdev
, HCI_DEV_RESUME
);
915 EXPORT_SYMBOL(hci_resume_dev
);
917 /* ---- Interface to upper protocols ---- */
919 /* Register/Unregister protocols.
920 * hci_task_lock is used to ensure that no tasks are running. */
921 int hci_register_proto(struct hci_proto
*hp
)
925 BT_DBG("%p name %s id %d", hp
, hp
->name
, hp
->id
);
927 if (hp
->id
>= HCI_MAX_PROTO
)
930 write_lock_bh(&hci_task_lock
);
932 if (!hci_proto
[hp
->id
])
933 hci_proto
[hp
->id
] = hp
;
937 write_unlock_bh(&hci_task_lock
);
941 EXPORT_SYMBOL(hci_register_proto
);
943 int hci_unregister_proto(struct hci_proto
*hp
)
947 BT_DBG("%p name %s id %d", hp
, hp
->name
, hp
->id
);
949 if (hp
->id
>= HCI_MAX_PROTO
)
952 write_lock_bh(&hci_task_lock
);
954 if (hci_proto
[hp
->id
])
955 hci_proto
[hp
->id
] = NULL
;
959 write_unlock_bh(&hci_task_lock
);
963 EXPORT_SYMBOL(hci_unregister_proto
);
965 int hci_register_cb(struct hci_cb
*cb
)
967 BT_DBG("%p name %s", cb
, cb
->name
);
969 write_lock_bh(&hci_cb_list_lock
);
970 list_add(&cb
->list
, &hci_cb_list
);
971 write_unlock_bh(&hci_cb_list_lock
);
975 EXPORT_SYMBOL(hci_register_cb
);
977 int hci_unregister_cb(struct hci_cb
*cb
)
979 BT_DBG("%p name %s", cb
, cb
->name
);
981 write_lock_bh(&hci_cb_list_lock
);
983 write_unlock_bh(&hci_cb_list_lock
);
987 EXPORT_SYMBOL(hci_unregister_cb
);
989 static int hci_send_frame(struct sk_buff
*skb
)
991 struct hci_dev
*hdev
= (struct hci_dev
*) skb
->dev
;
998 BT_DBG("%s type %d len %d", hdev
->name
, bt_cb(skb
)->pkt_type
, skb
->len
);
1000 if (atomic_read(&hdev
->promisc
)) {
1002 __net_timestamp(skb
);
1004 hci_send_to_sock(hdev
, skb
);
1007 /* Get rid of skb owner, prior to sending to the driver. */
1010 return hdev
->send(skb
);
1013 /* Send HCI command */
1014 int hci_send_cmd(struct hci_dev
*hdev
, __u16 ogf
, __u16 ocf
, __u32 plen
, void *param
)
1016 int len
= HCI_COMMAND_HDR_SIZE
+ plen
;
1017 struct hci_command_hdr
*hdr
;
1018 struct sk_buff
*skb
;
1020 BT_DBG("%s ogf 0x%x ocf 0x%x plen %d", hdev
->name
, ogf
, ocf
, plen
);
1022 skb
= bt_skb_alloc(len
, GFP_ATOMIC
);
1024 BT_ERR("%s Can't allocate memory for HCI command", hdev
->name
);
1028 hdr
= (struct hci_command_hdr
*) skb_put(skb
, HCI_COMMAND_HDR_SIZE
);
1029 hdr
->opcode
= __cpu_to_le16(hci_opcode_pack(ogf
, ocf
));
1033 memcpy(skb_put(skb
, plen
), param
, plen
);
1035 BT_DBG("skb len %d", skb
->len
);
1037 bt_cb(skb
)->pkt_type
= HCI_COMMAND_PKT
;
1038 skb
->dev
= (void *) hdev
;
1039 skb_queue_tail(&hdev
->cmd_q
, skb
);
1040 hci_sched_cmd(hdev
);
1045 /* Get data from the previously sent command */
1046 void *hci_sent_cmd_data(struct hci_dev
*hdev
, __u16 ogf
, __u16 ocf
)
1048 struct hci_command_hdr
*hdr
;
1050 if (!hdev
->sent_cmd
)
1053 hdr
= (void *) hdev
->sent_cmd
->data
;
1055 if (hdr
->opcode
!= __cpu_to_le16(hci_opcode_pack(ogf
, ocf
)))
1058 BT_DBG("%s ogf 0x%x ocf 0x%x", hdev
->name
, ogf
, ocf
);
1060 return hdev
->sent_cmd
->data
+ HCI_COMMAND_HDR_SIZE
;
1064 static void hci_add_acl_hdr(struct sk_buff
*skb
, __u16 handle
, __u16 flags
)
1066 struct hci_acl_hdr
*hdr
;
1069 hdr
= (struct hci_acl_hdr
*) skb_push(skb
, HCI_ACL_HDR_SIZE
);
1070 hdr
->handle
= __cpu_to_le16(hci_handle_pack(handle
, flags
));
1071 hdr
->dlen
= __cpu_to_le16(len
);
1073 skb
->h
.raw
= (void *) hdr
;
1076 int hci_send_acl(struct hci_conn
*conn
, struct sk_buff
*skb
, __u16 flags
)
1078 struct hci_dev
*hdev
= conn
->hdev
;
1079 struct sk_buff
*list
;
1081 BT_DBG("%s conn %p flags 0x%x", hdev
->name
, conn
, flags
);
1083 skb
->dev
= (void *) hdev
;
1084 bt_cb(skb
)->pkt_type
= HCI_ACLDATA_PKT
;
1085 hci_add_acl_hdr(skb
, conn
->handle
, flags
| ACL_START
);
1087 if (!(list
= skb_shinfo(skb
)->frag_list
)) {
1088 /* Non fragmented */
1089 BT_DBG("%s nonfrag skb %p len %d", hdev
->name
, skb
, skb
->len
);
1091 skb_queue_tail(&conn
->data_q
, skb
);
1094 BT_DBG("%s frag %p len %d", hdev
->name
, skb
, skb
->len
);
1096 skb_shinfo(skb
)->frag_list
= NULL
;
1098 /* Queue all fragments atomically */
1099 spin_lock_bh(&conn
->data_q
.lock
);
1101 __skb_queue_tail(&conn
->data_q
, skb
);
1103 skb
= list
; list
= list
->next
;
1105 skb
->dev
= (void *) hdev
;
1106 bt_cb(skb
)->pkt_type
= HCI_ACLDATA_PKT
;
1107 hci_add_acl_hdr(skb
, conn
->handle
, flags
| ACL_CONT
);
1109 BT_DBG("%s frag %p len %d", hdev
->name
, skb
, skb
->len
);
1111 __skb_queue_tail(&conn
->data_q
, skb
);
1114 spin_unlock_bh(&conn
->data_q
.lock
);
1120 EXPORT_SYMBOL(hci_send_acl
);
1123 int hci_send_sco(struct hci_conn
*conn
, struct sk_buff
*skb
)
1125 struct hci_dev
*hdev
= conn
->hdev
;
1126 struct hci_sco_hdr hdr
;
1128 BT_DBG("%s len %d", hdev
->name
, skb
->len
);
1130 if (skb
->len
> hdev
->sco_mtu
) {
1135 hdr
.handle
= __cpu_to_le16(conn
->handle
);
1136 hdr
.dlen
= skb
->len
;
1138 skb
->h
.raw
= skb_push(skb
, HCI_SCO_HDR_SIZE
);
1139 memcpy(skb
->h
.raw
, &hdr
, HCI_SCO_HDR_SIZE
);
1141 skb
->dev
= (void *) hdev
;
1142 bt_cb(skb
)->pkt_type
= HCI_SCODATA_PKT
;
1143 skb_queue_tail(&conn
->data_q
, skb
);
1147 EXPORT_SYMBOL(hci_send_sco
);
1149 /* ---- HCI TX task (outgoing data) ---- */
1151 /* HCI Connection scheduler */
1152 static inline struct hci_conn
*hci_low_sent(struct hci_dev
*hdev
, __u8 type
, int *quote
)
1154 struct hci_conn_hash
*h
= &hdev
->conn_hash
;
1155 struct hci_conn
*conn
= NULL
;
1156 int num
= 0, min
= ~0;
1157 struct list_head
*p
;
1159 /* We don't have to lock device here. Connections are always
1160 * added and removed with TX task disabled. */
1161 list_for_each(p
, &h
->list
) {
1163 c
= list_entry(p
, struct hci_conn
, list
);
1165 if (c
->type
!= type
|| c
->state
!= BT_CONNECTED
1166 || skb_queue_empty(&c
->data_q
))
1170 if (c
->sent
< min
) {
1177 int cnt
= (type
== ACL_LINK
? hdev
->acl_cnt
: hdev
->sco_cnt
);
1183 BT_DBG("conn %p quote %d", conn
, *quote
);
1187 static inline void hci_acl_tx_to(struct hci_dev
*hdev
)
1189 struct hci_conn_hash
*h
= &hdev
->conn_hash
;
1190 struct list_head
*p
;
1193 BT_ERR("%s ACL tx timeout", hdev
->name
);
1195 /* Kill stalled connections */
1196 list_for_each(p
, &h
->list
) {
1197 c
= list_entry(p
, struct hci_conn
, list
);
1198 if (c
->type
== ACL_LINK
&& c
->sent
) {
1199 BT_ERR("%s killing stalled ACL connection %s",
1200 hdev
->name
, batostr(&c
->dst
));
1201 hci_acl_disconn(c
, 0x13);
1206 static inline void hci_sched_acl(struct hci_dev
*hdev
)
1208 struct hci_conn
*conn
;
1209 struct sk_buff
*skb
;
1212 BT_DBG("%s", hdev
->name
);
1214 if (!test_bit(HCI_RAW
, &hdev
->flags
)) {
1215 /* ACL tx timeout must be longer than maximum
1216 * link supervision timeout (40.9 seconds) */
1217 if (!hdev
->acl_cnt
&& (jiffies
- hdev
->acl_last_tx
) > (HZ
* 45))
1218 hci_acl_tx_to(hdev
);
1221 while (hdev
->acl_cnt
&& (conn
= hci_low_sent(hdev
, ACL_LINK
, "e
))) {
1222 while (quote
-- && (skb
= skb_dequeue(&conn
->data_q
))) {
1223 BT_DBG("skb %p len %d", skb
, skb
->len
);
1224 hci_send_frame(skb
);
1225 hdev
->acl_last_tx
= jiffies
;
1234 static inline void hci_sched_sco(struct hci_dev
*hdev
)
1236 struct hci_conn
*conn
;
1237 struct sk_buff
*skb
;
1240 BT_DBG("%s", hdev
->name
);
1242 while (hdev
->sco_cnt
&& (conn
= hci_low_sent(hdev
, SCO_LINK
, "e
))) {
1243 while (quote
-- && (skb
= skb_dequeue(&conn
->data_q
))) {
1244 BT_DBG("skb %p len %d", skb
, skb
->len
);
1245 hci_send_frame(skb
);
1248 if (conn
->sent
== ~0)
1254 static void hci_tx_task(unsigned long arg
)
1256 struct hci_dev
*hdev
= (struct hci_dev
*) arg
;
1257 struct sk_buff
*skb
;
1259 read_lock(&hci_task_lock
);
1261 BT_DBG("%s acl %d sco %d", hdev
->name
, hdev
->acl_cnt
, hdev
->sco_cnt
);
1263 /* Schedule queues and send stuff to HCI driver */
1265 hci_sched_acl(hdev
);
1267 hci_sched_sco(hdev
);
1269 /* Send next queued raw (unknown type) packet */
1270 while ((skb
= skb_dequeue(&hdev
->raw_q
)))
1271 hci_send_frame(skb
);
1273 read_unlock(&hci_task_lock
);
1276 /* ----- HCI RX task (incoming data proccessing) ----- */
1278 /* ACL data packet */
1279 static inline void hci_acldata_packet(struct hci_dev
*hdev
, struct sk_buff
*skb
)
1281 struct hci_acl_hdr
*hdr
= (void *) skb
->data
;
1282 struct hci_conn
*conn
;
1283 __u16 handle
, flags
;
1285 skb_pull(skb
, HCI_ACL_HDR_SIZE
);
1287 handle
= __le16_to_cpu(hdr
->handle
);
1288 flags
= hci_flags(handle
);
1289 handle
= hci_handle(handle
);
1291 BT_DBG("%s len %d handle 0x%x flags 0x%x", hdev
->name
, skb
->len
, handle
, flags
);
1293 hdev
->stat
.acl_rx
++;
1296 conn
= hci_conn_hash_lookup_handle(hdev
, handle
);
1297 hci_dev_unlock(hdev
);
1300 register struct hci_proto
*hp
;
1302 /* Send to upper protocol */
1303 if ((hp
= hci_proto
[HCI_PROTO_L2CAP
]) && hp
->recv_acldata
) {
1304 hp
->recv_acldata(conn
, skb
, flags
);
1308 BT_ERR("%s ACL packet for unknown connection handle %d",
1309 hdev
->name
, handle
);
1315 /* SCO data packet */
1316 static inline void hci_scodata_packet(struct hci_dev
*hdev
, struct sk_buff
*skb
)
1318 struct hci_sco_hdr
*hdr
= (void *) skb
->data
;
1319 struct hci_conn
*conn
;
1322 skb_pull(skb
, HCI_SCO_HDR_SIZE
);
1324 handle
= __le16_to_cpu(hdr
->handle
);
1326 BT_DBG("%s len %d handle 0x%x", hdev
->name
, skb
->len
, handle
);
1328 hdev
->stat
.sco_rx
++;
1331 conn
= hci_conn_hash_lookup_handle(hdev
, handle
);
1332 hci_dev_unlock(hdev
);
1335 register struct hci_proto
*hp
;
1337 /* Send to upper protocol */
1338 if ((hp
= hci_proto
[HCI_PROTO_SCO
]) && hp
->recv_scodata
) {
1339 hp
->recv_scodata(conn
, skb
);
1343 BT_ERR("%s SCO packet for unknown connection handle %d",
1344 hdev
->name
, handle
);
1350 void hci_rx_task(unsigned long arg
)
1352 struct hci_dev
*hdev
= (struct hci_dev
*) arg
;
1353 struct sk_buff
*skb
;
1355 BT_DBG("%s", hdev
->name
);
1357 read_lock(&hci_task_lock
);
1359 while ((skb
= skb_dequeue(&hdev
->rx_q
))) {
1360 if (atomic_read(&hdev
->promisc
)) {
1361 /* Send copy to the sockets */
1362 hci_send_to_sock(hdev
, skb
);
1365 if (test_bit(HCI_RAW
, &hdev
->flags
)) {
1370 if (test_bit(HCI_INIT
, &hdev
->flags
)) {
1371 /* Don't process data packets in this states. */
1372 switch (bt_cb(skb
)->pkt_type
) {
1373 case HCI_ACLDATA_PKT
:
1374 case HCI_SCODATA_PKT
:
1381 switch (bt_cb(skb
)->pkt_type
) {
1383 hci_event_packet(hdev
, skb
);
1386 case HCI_ACLDATA_PKT
:
1387 BT_DBG("%s ACL data packet", hdev
->name
);
1388 hci_acldata_packet(hdev
, skb
);
1391 case HCI_SCODATA_PKT
:
1392 BT_DBG("%s SCO data packet", hdev
->name
);
1393 hci_scodata_packet(hdev
, skb
);
1402 read_unlock(&hci_task_lock
);
1405 static void hci_cmd_task(unsigned long arg
)
1407 struct hci_dev
*hdev
= (struct hci_dev
*) arg
;
1408 struct sk_buff
*skb
;
1410 BT_DBG("%s cmd %d", hdev
->name
, atomic_read(&hdev
->cmd_cnt
));
1412 if (!atomic_read(&hdev
->cmd_cnt
) && (jiffies
- hdev
->cmd_last_tx
) > HZ
) {
1413 BT_ERR("%s command tx timeout", hdev
->name
);
1414 atomic_set(&hdev
->cmd_cnt
, 1);
1417 /* Send queued commands */
1418 if (atomic_read(&hdev
->cmd_cnt
) && (skb
= skb_dequeue(&hdev
->cmd_q
))) {
1420 kfree_skb(hdev
->sent_cmd
);
1422 if ((hdev
->sent_cmd
= skb_clone(skb
, GFP_ATOMIC
))) {
1423 atomic_dec(&hdev
->cmd_cnt
);
1424 hci_send_frame(skb
);
1425 hdev
->cmd_last_tx
= jiffies
;
1427 skb_queue_head(&hdev
->cmd_q
, skb
);
1428 hci_sched_cmd(hdev
);