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 connection handling. */
27 #include <linux/module.h>
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/kernel.h>
32 #include <linux/slab.h>
33 #include <linux/poll.h>
34 #include <linux/fcntl.h>
35 #include <linux/init.h>
36 #include <linux/skbuff.h>
37 #include <linux/interrupt.h>
38 #include <linux/notifier.h>
41 #include <asm/system.h>
42 #include <asm/uaccess.h>
43 #include <asm/unaligned.h>
45 #include <net/bluetooth/bluetooth.h>
46 #include <net/bluetooth/hci_core.h>
48 void hci_acl_connect(struct hci_conn *conn)
50 struct hci_dev *hdev = conn->hdev;
51 struct inquiry_entry *ie;
52 struct hci_cp_create_conn cp;
56 conn->state = BT_CONNECT;
59 conn->link_mode = HCI_LM_MASTER;
63 conn->link_policy = hdev->link_policy;
65 memset(&cp, 0, sizeof(cp));
66 bacpy(&cp.bdaddr, &conn->dst);
67 cp.pscan_rep_mode = 0x02;
69 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
70 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
71 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
72 cp.pscan_mode = ie->data.pscan_mode;
73 cp.clock_offset = ie->data.clock_offset |
77 memcpy(conn->dev_class, ie->data.dev_class, 3);
78 conn->ssp_mode = ie->data.ssp_mode;
81 cp.pkt_type = cpu_to_le16(conn->pkt_type);
82 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
83 cp.role_switch = 0x01;
85 cp.role_switch = 0x00;
87 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
90 static void hci_acl_connect_cancel(struct hci_conn *conn)
92 struct hci_cp_create_conn_cancel cp;
96 if (conn->hdev->hci_ver < 2)
99 bacpy(&cp.bdaddr, &conn->dst);
100 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
103 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
105 struct hci_cp_disconnect cp;
109 conn->state = BT_DISCONN;
111 cp.handle = cpu_to_le16(conn->handle);
113 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
116 void hci_add_sco(struct hci_conn *conn, __u16 handle)
118 struct hci_dev *hdev = conn->hdev;
119 struct hci_cp_add_sco cp;
123 conn->state = BT_CONNECT;
128 cp.handle = cpu_to_le16(handle);
129 cp.pkt_type = cpu_to_le16(conn->pkt_type);
131 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
134 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
136 struct hci_dev *hdev = conn->hdev;
137 struct hci_cp_setup_sync_conn cp;
141 conn->state = BT_CONNECT;
146 cp.handle = cpu_to_le16(handle);
147 cp.pkt_type = cpu_to_le16(conn->pkt_type);
149 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
150 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
151 cp.max_latency = cpu_to_le16(0xffff);
152 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
153 cp.retrans_effort = 0xff;
155 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
158 static void hci_conn_timeout(unsigned long arg)
160 struct hci_conn *conn = (void *) arg;
161 struct hci_dev *hdev = conn->hdev;
164 BT_DBG("conn %p state %d", conn, conn->state);
166 if (atomic_read(&conn->refcnt))
171 switch (conn->state) {
174 if (conn->type == ACL_LINK && conn->out)
175 hci_acl_connect_cancel(conn);
179 reason = hci_proto_disconn_ind(conn);
180 hci_acl_disconn(conn, reason);
183 conn->state = BT_CLOSED;
187 hci_dev_unlock(hdev);
190 static void hci_conn_idle(unsigned long arg)
192 struct hci_conn *conn = (void *) arg;
194 BT_DBG("conn %p mode %d", conn, conn->mode);
196 hci_conn_enter_sniff_mode(conn);
199 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
201 struct hci_conn *conn;
203 BT_DBG("%s dst %s", hdev->name, batostr(dst));
205 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
209 bacpy(&conn->dst, dst);
212 conn->mode = HCI_CM_ACTIVE;
213 conn->state = BT_OPEN;
214 conn->auth_type = HCI_AT_GENERAL_BONDING;
216 conn->power_save = 1;
217 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
221 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
224 if (lmp_esco_capable(hdev))
225 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
226 (hdev->esco_type & EDR_ESCO_MASK);
228 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
231 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
235 skb_queue_head_init(&conn->data_q);
237 setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
238 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
240 atomic_set(&conn->refcnt, 0);
244 tasklet_disable(&hdev->tx_task);
246 hci_conn_hash_add(hdev, conn);
248 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
250 atomic_set(&conn->devref, 0);
252 hci_conn_init_sysfs(conn);
254 tasklet_enable(&hdev->tx_task);
259 int hci_conn_del(struct hci_conn *conn)
261 struct hci_dev *hdev = conn->hdev;
263 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
265 del_timer(&conn->idle_timer);
267 del_timer(&conn->disc_timer);
269 if (conn->type == ACL_LINK) {
270 struct hci_conn *sco = conn->link;
275 hdev->acl_cnt += conn->sent;
277 struct hci_conn *acl = conn->link;
284 tasklet_disable(&hdev->tx_task);
286 hci_conn_hash_del(hdev, conn);
288 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
290 tasklet_enable(&hdev->tx_task);
292 skb_queue_purge(&conn->data_q);
294 hci_conn_put_device(conn);
301 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
303 int use_src = bacmp(src, BDADDR_ANY);
304 struct hci_dev *hdev = NULL;
307 BT_DBG("%s -> %s", batostr(src), batostr(dst));
309 read_lock_bh(&hci_dev_list_lock);
311 list_for_each(p, &hci_dev_list) {
312 struct hci_dev *d = list_entry(p, struct hci_dev, list);
314 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
318 * No source address - find interface with bdaddr != dst
319 * Source address - find interface with bdaddr == src
323 if (!bacmp(&d->bdaddr, src)) {
327 if (bacmp(&d->bdaddr, dst)) {
334 hdev = hci_dev_hold(hdev);
336 read_unlock_bh(&hci_dev_list_lock);
339 EXPORT_SYMBOL(hci_get_route);
341 /* Create SCO or ACL connection.
342 * Device _must_ be locked */
343 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type)
345 struct hci_conn *acl;
346 struct hci_conn *sco;
348 BT_DBG("%s dst %s", hdev->name, batostr(dst));
350 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
351 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
357 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
358 acl->sec_level = sec_level;
359 acl->auth_type = auth_type;
360 hci_acl_connect(acl);
362 if (acl->sec_level < sec_level)
363 acl->sec_level = sec_level;
364 if (acl->auth_type < auth_type)
365 acl->auth_type = auth_type;
368 if (type == ACL_LINK)
371 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
372 if (!(sco = hci_conn_add(hdev, type, dst))) {
383 if (acl->state == BT_CONNECTED &&
384 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
386 hci_conn_enter_active_mode(acl);
388 if (lmp_esco_capable(hdev))
389 hci_setup_sync(sco, acl->handle);
391 hci_add_sco(sco, acl->handle);
396 EXPORT_SYMBOL(hci_connect);
398 /* Check link security requirement */
399 int hci_conn_check_link_mode(struct hci_conn *conn)
401 BT_DBG("conn %p", conn);
403 if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
404 !(conn->link_mode & HCI_LM_ENCRYPT))
409 EXPORT_SYMBOL(hci_conn_check_link_mode);
411 /* Authenticate remote device */
412 static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
414 BT_DBG("conn %p", conn);
416 if (sec_level > conn->sec_level)
417 conn->sec_level = sec_level;
418 else if (conn->link_mode & HCI_LM_AUTH)
421 conn->auth_type = auth_type;
423 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
424 struct hci_cp_auth_requested cp;
425 cp.handle = cpu_to_le16(conn->handle);
426 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
433 /* Enable security */
434 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
436 BT_DBG("conn %p", conn);
438 if (sec_level == BT_SECURITY_SDP)
441 if (sec_level == BT_SECURITY_LOW &&
442 (!conn->ssp_mode || !conn->hdev->ssp_mode))
445 if (conn->link_mode & HCI_LM_ENCRYPT)
446 return hci_conn_auth(conn, sec_level, auth_type);
448 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
451 if (hci_conn_auth(conn, sec_level, auth_type)) {
452 struct hci_cp_set_conn_encrypt cp;
453 cp.handle = cpu_to_le16(conn->handle);
455 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT,
461 EXPORT_SYMBOL(hci_conn_security);
463 /* Change link key */
464 int hci_conn_change_link_key(struct hci_conn *conn)
466 BT_DBG("conn %p", conn);
468 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
469 struct hci_cp_change_conn_link_key cp;
470 cp.handle = cpu_to_le16(conn->handle);
471 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
477 EXPORT_SYMBOL(hci_conn_change_link_key);
480 int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
482 BT_DBG("conn %p", conn);
484 if (!role && conn->link_mode & HCI_LM_MASTER)
487 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
488 struct hci_cp_switch_role cp;
489 bacpy(&cp.bdaddr, &conn->dst);
491 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
496 EXPORT_SYMBOL(hci_conn_switch_role);
498 /* Enter active mode */
499 void hci_conn_enter_active_mode(struct hci_conn *conn)
501 struct hci_dev *hdev = conn->hdev;
503 BT_DBG("conn %p mode %d", conn, conn->mode);
505 if (test_bit(HCI_RAW, &hdev->flags))
508 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
511 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
512 struct hci_cp_exit_sniff_mode cp;
513 cp.handle = cpu_to_le16(conn->handle);
514 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
518 if (hdev->idle_timeout > 0)
519 mod_timer(&conn->idle_timer,
520 jiffies + msecs_to_jiffies(hdev->idle_timeout));
523 /* Enter sniff mode */
524 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
526 struct hci_dev *hdev = conn->hdev;
528 BT_DBG("conn %p mode %d", conn, conn->mode);
530 if (test_bit(HCI_RAW, &hdev->flags))
533 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
536 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
539 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
540 struct hci_cp_sniff_subrate cp;
541 cp.handle = cpu_to_le16(conn->handle);
542 cp.max_latency = cpu_to_le16(0);
543 cp.min_remote_timeout = cpu_to_le16(0);
544 cp.min_local_timeout = cpu_to_le16(0);
545 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
548 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
549 struct hci_cp_sniff_mode cp;
550 cp.handle = cpu_to_le16(conn->handle);
551 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
552 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
553 cp.attempt = cpu_to_le16(4);
554 cp.timeout = cpu_to_le16(1);
555 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
559 /* Drop all connection on the device */
560 void hci_conn_hash_flush(struct hci_dev *hdev)
562 struct hci_conn_hash *h = &hdev->conn_hash;
565 BT_DBG("hdev %s", hdev->name);
568 while (p != &h->list) {
571 c = list_entry(p, struct hci_conn, list);
574 c->state = BT_CLOSED;
576 hci_proto_disconn_cfm(c, 0x16);
581 /* Check pending connect attempts */
582 void hci_conn_check_pending(struct hci_dev *hdev)
584 struct hci_conn *conn;
586 BT_DBG("hdev %s", hdev->name);
590 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
592 hci_acl_connect(conn);
594 hci_dev_unlock(hdev);
597 void hci_conn_hold_device(struct hci_conn *conn)
599 atomic_inc(&conn->devref);
601 EXPORT_SYMBOL(hci_conn_hold_device);
603 void hci_conn_put_device(struct hci_conn *conn)
605 if (atomic_dec_and_test(&conn->devref))
606 hci_conn_del_sysfs(conn);
608 EXPORT_SYMBOL(hci_conn_put_device);
610 int hci_get_conn_list(void __user *arg)
612 struct hci_conn_list_req req, *cl;
613 struct hci_conn_info *ci;
614 struct hci_dev *hdev;
616 int n = 0, size, err;
618 if (copy_from_user(&req, arg, sizeof(req)))
621 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
624 size = sizeof(req) + req.conn_num * sizeof(*ci);
626 if (!(cl = kmalloc(size, GFP_KERNEL)))
629 if (!(hdev = hci_dev_get(req.dev_id))) {
636 hci_dev_lock_bh(hdev);
637 list_for_each(p, &hdev->conn_hash.list) {
638 register struct hci_conn *c;
639 c = list_entry(p, struct hci_conn, list);
641 bacpy(&(ci + n)->bdaddr, &c->dst);
642 (ci + n)->handle = c->handle;
643 (ci + n)->type = c->type;
644 (ci + n)->out = c->out;
645 (ci + n)->state = c->state;
646 (ci + n)->link_mode = c->link_mode;
647 if (++n >= req.conn_num)
650 hci_dev_unlock_bh(hdev);
652 cl->dev_id = hdev->id;
654 size = sizeof(req) + n * sizeof(*ci);
658 err = copy_to_user(arg, cl, size);
661 return err ? -EFAULT : 0;
664 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
666 struct hci_conn_info_req req;
667 struct hci_conn_info ci;
668 struct hci_conn *conn;
669 char __user *ptr = arg + sizeof(req);
671 if (copy_from_user(&req, arg, sizeof(req)))
674 hci_dev_lock_bh(hdev);
675 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
677 bacpy(&ci.bdaddr, &conn->dst);
678 ci.handle = conn->handle;
679 ci.type = conn->type;
681 ci.state = conn->state;
682 ci.link_mode = conn->link_mode;
684 hci_dev_unlock_bh(hdev);
689 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
692 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
694 struct hci_auth_info_req req;
695 struct hci_conn *conn;
697 if (copy_from_user(&req, arg, sizeof(req)))
700 hci_dev_lock_bh(hdev);
701 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
703 req.type = conn->auth_type;
704 hci_dev_unlock_bh(hdev);
709 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;