2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
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/export.h>
29 #include <net/bluetooth/bluetooth.h>
30 #include <net/bluetooth/hci_core.h>
31 #include <net/bluetooth/a2mp.h>
32 #include <net/bluetooth/smp.h>
34 static void hci_le_create_connection(struct hci_conn *conn)
36 struct hci_dev *hdev = conn->hdev;
37 struct hci_cp_le_create_conn cp;
39 conn->state = BT_CONNECT;
41 conn->link_mode |= HCI_LM_MASTER;
42 conn->sec_level = BT_SECURITY_LOW;
44 memset(&cp, 0, sizeof(cp));
45 cp.scan_interval = __constant_cpu_to_le16(0x0060);
46 cp.scan_window = __constant_cpu_to_le16(0x0030);
47 bacpy(&cp.peer_addr, &conn->dst);
48 cp.peer_addr_type = conn->dst_type;
49 cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
50 cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
51 cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
52 cp.min_ce_len = __constant_cpu_to_le16(0x0000);
53 cp.max_ce_len = __constant_cpu_to_le16(0x0000);
55 hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
58 static void hci_le_create_connection_cancel(struct hci_conn *conn)
60 hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
63 static void hci_acl_create_connection(struct hci_conn *conn)
65 struct hci_dev *hdev = conn->hdev;
66 struct inquiry_entry *ie;
67 struct hci_cp_create_conn cp;
69 BT_DBG("hcon %p", conn);
71 conn->state = BT_CONNECT;
74 conn->link_mode = HCI_LM_MASTER;
78 conn->link_policy = hdev->link_policy;
80 memset(&cp, 0, sizeof(cp));
81 bacpy(&cp.bdaddr, &conn->dst);
82 cp.pscan_rep_mode = 0x02;
84 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
86 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
87 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
88 cp.pscan_mode = ie->data.pscan_mode;
89 cp.clock_offset = ie->data.clock_offset |
90 __constant_cpu_to_le16(0x8000);
93 memcpy(conn->dev_class, ie->data.dev_class, 3);
94 if (ie->data.ssp_mode > 0)
95 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
98 cp.pkt_type = cpu_to_le16(conn->pkt_type);
99 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
100 cp.role_switch = 0x01;
102 cp.role_switch = 0x00;
104 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
107 static void hci_acl_create_connection_cancel(struct hci_conn *conn)
109 struct hci_cp_create_conn_cancel cp;
111 BT_DBG("hcon %p", conn);
113 if (conn->hdev->hci_ver < BLUETOOTH_VER_1_2)
116 bacpy(&cp.bdaddr, &conn->dst);
117 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
120 static void hci_reject_sco(struct hci_conn *conn)
122 struct hci_cp_reject_sync_conn_req cp;
124 cp.reason = HCI_ERROR_REMOTE_USER_TERM;
125 bacpy(&cp.bdaddr, &conn->dst);
127 hci_send_cmd(conn->hdev, HCI_OP_REJECT_SYNC_CONN_REQ, sizeof(cp), &cp);
130 void hci_disconnect(struct hci_conn *conn, __u8 reason)
132 struct hci_cp_disconnect cp;
134 BT_DBG("hcon %p", conn);
136 conn->state = BT_DISCONN;
138 cp.handle = cpu_to_le16(conn->handle);
140 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
143 static void hci_amp_disconn(struct hci_conn *conn, __u8 reason)
145 struct hci_cp_disconn_phy_link cp;
147 BT_DBG("hcon %p", conn);
149 conn->state = BT_DISCONN;
151 cp.phy_handle = HCI_PHY_HANDLE(conn->handle);
153 hci_send_cmd(conn->hdev, HCI_OP_DISCONN_PHY_LINK,
157 static void hci_add_sco(struct hci_conn *conn, __u16 handle)
159 struct hci_dev *hdev = conn->hdev;
160 struct hci_cp_add_sco cp;
162 BT_DBG("hcon %p", conn);
164 conn->state = BT_CONNECT;
169 cp.handle = cpu_to_le16(handle);
170 cp.pkt_type = cpu_to_le16(conn->pkt_type);
172 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
175 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
177 struct hci_dev *hdev = conn->hdev;
178 struct hci_cp_setup_sync_conn cp;
180 BT_DBG("hcon %p", conn);
182 conn->state = BT_CONNECT;
187 cp.handle = cpu_to_le16(handle);
188 cp.pkt_type = cpu_to_le16(conn->pkt_type);
190 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
191 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
192 cp.max_latency = __constant_cpu_to_le16(0xffff);
193 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
194 cp.retrans_effort = 0xff;
196 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
199 void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
200 u16 latency, u16 to_multiplier)
202 struct hci_cp_le_conn_update cp;
203 struct hci_dev *hdev = conn->hdev;
205 memset(&cp, 0, sizeof(cp));
207 cp.handle = cpu_to_le16(conn->handle);
208 cp.conn_interval_min = cpu_to_le16(min);
209 cp.conn_interval_max = cpu_to_le16(max);
210 cp.conn_latency = cpu_to_le16(latency);
211 cp.supervision_timeout = cpu_to_le16(to_multiplier);
212 cp.min_ce_len = __constant_cpu_to_le16(0x0001);
213 cp.max_ce_len = __constant_cpu_to_le16(0x0001);
215 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
218 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
221 struct hci_dev *hdev = conn->hdev;
222 struct hci_cp_le_start_enc cp;
224 BT_DBG("hcon %p", conn);
226 memset(&cp, 0, sizeof(cp));
228 cp.handle = cpu_to_le16(conn->handle);
229 memcpy(cp.ltk, ltk, sizeof(cp.ltk));
231 memcpy(cp.rand, rand, sizeof(cp.rand));
233 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
236 /* Device _must_ be locked */
237 void hci_sco_setup(struct hci_conn *conn, __u8 status)
239 struct hci_conn *sco = conn->link;
244 BT_DBG("hcon %p", conn);
247 if (lmp_esco_capable(conn->hdev))
248 hci_setup_sync(sco, conn->handle);
250 hci_add_sco(sco, conn->handle);
252 hci_proto_connect_cfm(sco, status);
257 static void hci_conn_disconnect(struct hci_conn *conn)
259 __u8 reason = hci_proto_disconn_ind(conn);
261 switch (conn->type) {
263 hci_amp_disconn(conn, reason);
266 hci_disconnect(conn, reason);
271 static void hci_conn_timeout(struct work_struct *work)
273 struct hci_conn *conn = container_of(work, struct hci_conn,
276 BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
278 if (atomic_read(&conn->refcnt))
281 switch (conn->state) {
285 if (conn->type == ACL_LINK)
286 hci_acl_create_connection_cancel(conn);
287 else if (conn->type == LE_LINK)
288 hci_le_create_connection_cancel(conn);
289 } else if (conn->type == SCO_LINK || conn->type == ESCO_LINK) {
290 hci_reject_sco(conn);
295 hci_conn_disconnect(conn);
298 conn->state = BT_CLOSED;
303 /* Enter sniff mode */
304 static void hci_conn_enter_sniff_mode(struct hci_conn *conn)
306 struct hci_dev *hdev = conn->hdev;
308 BT_DBG("hcon %p mode %d", conn, conn->mode);
310 if (test_bit(HCI_RAW, &hdev->flags))
313 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
316 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
319 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
320 struct hci_cp_sniff_subrate cp;
321 cp.handle = cpu_to_le16(conn->handle);
322 cp.max_latency = __constant_cpu_to_le16(0);
323 cp.min_remote_timeout = __constant_cpu_to_le16(0);
324 cp.min_local_timeout = __constant_cpu_to_le16(0);
325 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
328 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
329 struct hci_cp_sniff_mode cp;
330 cp.handle = cpu_to_le16(conn->handle);
331 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
332 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
333 cp.attempt = __constant_cpu_to_le16(4);
334 cp.timeout = __constant_cpu_to_le16(1);
335 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
339 static void hci_conn_idle(unsigned long arg)
341 struct hci_conn *conn = (void *) arg;
343 BT_DBG("hcon %p mode %d", conn, conn->mode);
345 hci_conn_enter_sniff_mode(conn);
348 static void hci_conn_auto_accept(unsigned long arg)
350 struct hci_conn *conn = (void *) arg;
351 struct hci_dev *hdev = conn->hdev;
353 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
357 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
359 struct hci_conn *conn;
361 BT_DBG("%s dst %pMR", hdev->name, dst);
363 conn = kzalloc(sizeof(struct hci_conn), GFP_KERNEL);
367 bacpy(&conn->dst, dst);
370 conn->mode = HCI_CM_ACTIVE;
371 conn->state = BT_OPEN;
372 conn->auth_type = HCI_AT_GENERAL_BONDING;
373 conn->io_capability = hdev->io_capability;
374 conn->remote_auth = 0xff;
375 conn->key_type = 0xff;
377 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
378 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
382 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
385 if (lmp_esco_capable(hdev))
386 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
387 (hdev->esco_type & EDR_ESCO_MASK);
389 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
392 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
396 skb_queue_head_init(&conn->data_q);
398 INIT_LIST_HEAD(&conn->chan_list);
400 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
401 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
402 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
403 (unsigned long) conn);
405 atomic_set(&conn->refcnt, 0);
409 hci_conn_hash_add(hdev, conn);
411 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
413 hci_conn_init_sysfs(conn);
418 int hci_conn_del(struct hci_conn *conn)
420 struct hci_dev *hdev = conn->hdev;
422 BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
424 del_timer(&conn->idle_timer);
426 cancel_delayed_work_sync(&conn->disc_work);
428 del_timer(&conn->auto_accept_timer);
430 if (conn->type == ACL_LINK) {
431 struct hci_conn *sco = conn->link;
436 hdev->acl_cnt += conn->sent;
437 } else if (conn->type == LE_LINK) {
439 hdev->le_cnt += conn->sent;
441 hdev->acl_cnt += conn->sent;
443 struct hci_conn *acl = conn->link;
450 hci_chan_list_flush(conn);
453 amp_mgr_put(conn->amp_mgr);
455 hci_conn_hash_del(hdev, conn);
457 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
459 skb_queue_purge(&conn->data_q);
461 hci_conn_del_sysfs(conn);
470 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
472 int use_src = bacmp(src, BDADDR_ANY);
473 struct hci_dev *hdev = NULL, *d;
475 BT_DBG("%pMR -> %pMR", src, dst);
477 read_lock(&hci_dev_list_lock);
479 list_for_each_entry(d, &hci_dev_list, list) {
480 if (!test_bit(HCI_UP, &d->flags) ||
481 test_bit(HCI_RAW, &d->flags) ||
482 d->dev_type != HCI_BREDR)
486 * No source address - find interface with bdaddr != dst
487 * Source address - find interface with bdaddr == src
491 if (!bacmp(&d->bdaddr, src)) {
495 if (bacmp(&d->bdaddr, dst)) {
502 hdev = hci_dev_hold(hdev);
504 read_unlock(&hci_dev_list_lock);
507 EXPORT_SYMBOL(hci_get_route);
509 static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
510 u8 dst_type, u8 sec_level, u8 auth_type)
514 if (test_bit(HCI_LE_PERIPHERAL, &hdev->flags))
515 return ERR_PTR(-ENOTSUPP);
517 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
519 le = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
521 return ERR_PTR(-EBUSY);
523 le = hci_conn_add(hdev, LE_LINK, dst);
525 return ERR_PTR(-ENOMEM);
527 le->dst_type = bdaddr_to_le(dst_type);
528 hci_le_create_connection(le);
531 le->pending_sec_level = sec_level;
532 le->auth_type = auth_type;
539 static struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
540 u8 sec_level, u8 auth_type)
542 struct hci_conn *acl;
544 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
546 acl = hci_conn_add(hdev, ACL_LINK, dst);
548 return ERR_PTR(-ENOMEM);
553 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
554 acl->sec_level = BT_SECURITY_LOW;
555 acl->pending_sec_level = sec_level;
556 acl->auth_type = auth_type;
557 hci_acl_create_connection(acl);
563 static struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type,
564 bdaddr_t *dst, u8 sec_level, u8 auth_type)
566 struct hci_conn *acl;
567 struct hci_conn *sco;
569 acl = hci_connect_acl(hdev, dst, sec_level, auth_type);
573 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
575 sco = hci_conn_add(hdev, type, dst);
578 return ERR_PTR(-ENOMEM);
587 if (acl->state == BT_CONNECTED &&
588 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
589 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
590 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
592 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
593 /* defer SCO setup until mode change completed */
594 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
598 hci_sco_setup(acl, 0x00);
604 /* Create SCO, ACL or LE connection. */
605 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst,
606 __u8 dst_type, __u8 sec_level, __u8 auth_type)
608 BT_DBG("%s dst %pMR type 0x%x", hdev->name, dst, type);
612 return hci_connect_le(hdev, dst, dst_type, sec_level, auth_type);
614 return hci_connect_acl(hdev, dst, sec_level, auth_type);
617 return hci_connect_sco(hdev, type, dst, sec_level, auth_type);
620 return ERR_PTR(-EINVAL);
623 /* Check link security requirement */
624 int hci_conn_check_link_mode(struct hci_conn *conn)
626 BT_DBG("hcon %p", conn);
628 if (hci_conn_ssp_enabled(conn) && !(conn->link_mode & HCI_LM_ENCRYPT))
634 /* Authenticate remote device */
635 static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
637 BT_DBG("hcon %p", conn);
639 if (conn->pending_sec_level > sec_level)
640 sec_level = conn->pending_sec_level;
642 if (sec_level > conn->sec_level)
643 conn->pending_sec_level = sec_level;
644 else if (conn->link_mode & HCI_LM_AUTH)
647 /* Make sure we preserve an existing MITM requirement*/
648 auth_type |= (conn->auth_type & 0x01);
650 conn->auth_type = auth_type;
652 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
653 struct hci_cp_auth_requested cp;
655 cp.handle = cpu_to_le16(conn->handle);
656 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
659 /* If we're already encrypted set the REAUTH_PEND flag,
660 * otherwise set the ENCRYPT_PEND.
662 if (conn->key_type != 0xff)
663 set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
665 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
671 /* Encrypt the the link */
672 static void hci_conn_encrypt(struct hci_conn *conn)
674 BT_DBG("hcon %p", conn);
676 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
677 struct hci_cp_set_conn_encrypt cp;
678 cp.handle = cpu_to_le16(conn->handle);
680 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
685 /* Enable security */
686 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
688 BT_DBG("hcon %p", conn);
690 if (conn->type == LE_LINK)
691 return smp_conn_security(conn, sec_level);
693 /* For sdp we don't need the link key. */
694 if (sec_level == BT_SECURITY_SDP)
697 /* For non 2.1 devices and low security level we don't need the link
699 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
702 /* For other security levels we need the link key. */
703 if (!(conn->link_mode & HCI_LM_AUTH))
706 /* An authenticated combination key has sufficient security for any
708 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
711 /* An unauthenticated combination key has sufficient security for
712 security level 1 and 2. */
713 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
714 (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW))
717 /* A combination key has always sufficient security for the security
718 levels 1 or 2. High security level requires the combination key
719 is generated using maximum PIN code length (16).
720 For pre 2.1 units. */
721 if (conn->key_type == HCI_LK_COMBINATION &&
722 (sec_level != BT_SECURITY_HIGH || conn->pin_length == 16))
726 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
729 if (!hci_conn_auth(conn, sec_level, auth_type))
733 if (conn->link_mode & HCI_LM_ENCRYPT)
736 hci_conn_encrypt(conn);
739 EXPORT_SYMBOL(hci_conn_security);
741 /* Check secure link requirement */
742 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
744 BT_DBG("hcon %p", conn);
746 if (sec_level != BT_SECURITY_HIGH)
747 return 1; /* Accept if non-secure is required */
749 if (conn->sec_level == BT_SECURITY_HIGH)
752 return 0; /* Reject not secure link */
754 EXPORT_SYMBOL(hci_conn_check_secure);
756 /* Change link key */
757 int hci_conn_change_link_key(struct hci_conn *conn)
759 BT_DBG("hcon %p", conn);
761 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
762 struct hci_cp_change_conn_link_key cp;
763 cp.handle = cpu_to_le16(conn->handle);
764 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
772 int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
774 BT_DBG("hcon %p", conn);
776 if (!role && conn->link_mode & HCI_LM_MASTER)
779 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
780 struct hci_cp_switch_role cp;
781 bacpy(&cp.bdaddr, &conn->dst);
783 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
788 EXPORT_SYMBOL(hci_conn_switch_role);
790 /* Enter active mode */
791 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
793 struct hci_dev *hdev = conn->hdev;
795 BT_DBG("hcon %p mode %d", conn, conn->mode);
797 if (test_bit(HCI_RAW, &hdev->flags))
800 if (conn->mode != HCI_CM_SNIFF)
803 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
806 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
807 struct hci_cp_exit_sniff_mode cp;
808 cp.handle = cpu_to_le16(conn->handle);
809 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
813 if (hdev->idle_timeout > 0)
814 mod_timer(&conn->idle_timer,
815 jiffies + msecs_to_jiffies(hdev->idle_timeout));
818 /* Drop all connection on the device */
819 void hci_conn_hash_flush(struct hci_dev *hdev)
821 struct hci_conn_hash *h = &hdev->conn_hash;
822 struct hci_conn *c, *n;
824 BT_DBG("hdev %s", hdev->name);
826 list_for_each_entry_safe(c, n, &h->list, list) {
827 c->state = BT_CLOSED;
829 hci_proto_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
834 /* Check pending connect attempts */
835 void hci_conn_check_pending(struct hci_dev *hdev)
837 struct hci_conn *conn;
839 BT_DBG("hdev %s", hdev->name);
843 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
845 hci_acl_create_connection(conn);
847 hci_dev_unlock(hdev);
850 int hci_get_conn_list(void __user *arg)
853 struct hci_conn_list_req req, *cl;
854 struct hci_conn_info *ci;
855 struct hci_dev *hdev;
856 int n = 0, size, err;
858 if (copy_from_user(&req, arg, sizeof(req)))
861 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
864 size = sizeof(req) + req.conn_num * sizeof(*ci);
866 cl = kmalloc(size, GFP_KERNEL);
870 hdev = hci_dev_get(req.dev_id);
879 list_for_each_entry(c, &hdev->conn_hash.list, list) {
880 bacpy(&(ci + n)->bdaddr, &c->dst);
881 (ci + n)->handle = c->handle;
882 (ci + n)->type = c->type;
883 (ci + n)->out = c->out;
884 (ci + n)->state = c->state;
885 (ci + n)->link_mode = c->link_mode;
886 if (++n >= req.conn_num)
889 hci_dev_unlock(hdev);
891 cl->dev_id = hdev->id;
893 size = sizeof(req) + n * sizeof(*ci);
897 err = copy_to_user(arg, cl, size);
900 return err ? -EFAULT : 0;
903 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
905 struct hci_conn_info_req req;
906 struct hci_conn_info ci;
907 struct hci_conn *conn;
908 char __user *ptr = arg + sizeof(req);
910 if (copy_from_user(&req, arg, sizeof(req)))
914 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
916 bacpy(&ci.bdaddr, &conn->dst);
917 ci.handle = conn->handle;
918 ci.type = conn->type;
920 ci.state = conn->state;
921 ci.link_mode = conn->link_mode;
923 hci_dev_unlock(hdev);
928 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
931 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
933 struct hci_auth_info_req req;
934 struct hci_conn *conn;
936 if (copy_from_user(&req, arg, sizeof(req)))
940 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
942 req.type = conn->auth_type;
943 hci_dev_unlock(hdev);
948 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
951 struct hci_chan *hci_chan_create(struct hci_conn *conn)
953 struct hci_dev *hdev = conn->hdev;
954 struct hci_chan *chan;
956 BT_DBG("%s hcon %p", hdev->name, conn);
958 chan = kzalloc(sizeof(struct hci_chan), GFP_KERNEL);
963 skb_queue_head_init(&chan->data_q);
964 chan->state = BT_CONNECTED;
966 list_add_rcu(&chan->list, &conn->chan_list);
971 void hci_chan_del(struct hci_chan *chan)
973 struct hci_conn *conn = chan->conn;
974 struct hci_dev *hdev = conn->hdev;
976 BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
978 list_del_rcu(&chan->list);
984 skb_queue_purge(&chan->data_q);
988 void hci_chan_list_flush(struct hci_conn *conn)
990 struct hci_chan *chan, *n;
992 BT_DBG("hcon %p", conn);
994 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
998 static struct hci_chan *__hci_chan_lookup_handle(struct hci_conn *hcon,
1001 struct hci_chan *hchan;
1003 list_for_each_entry(hchan, &hcon->chan_list, list) {
1004 if (hchan->handle == handle)
1011 struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle)
1013 struct hci_conn_hash *h = &hdev->conn_hash;
1014 struct hci_conn *hcon;
1015 struct hci_chan *hchan = NULL;
1019 list_for_each_entry_rcu(hcon, &h->list, list) {
1020 hchan = __hci_chan_lookup_handle(hcon, handle);