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 #ifndef CONFIG_BT_HCI_CORE_DEBUG
53 void hci_acl_connect(struct hci_conn *conn)
55 struct hci_dev *hdev = conn->hdev;
56 struct inquiry_entry *ie;
57 struct hci_cp_create_conn cp;
61 conn->state = BT_CONNECT;
64 conn->link_mode = HCI_LM_MASTER;
68 conn->link_policy = hdev->link_policy;
70 memset(&cp, 0, sizeof(cp));
71 bacpy(&cp.bdaddr, &conn->dst);
72 cp.pscan_rep_mode = 0x02;
74 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
75 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
76 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
77 cp.pscan_mode = ie->data.pscan_mode;
78 cp.clock_offset = ie->data.clock_offset |
82 memcpy(conn->dev_class, ie->data.dev_class, 3);
83 conn->ssp_mode = ie->data.ssp_mode;
86 cp.pkt_type = cpu_to_le16(conn->pkt_type);
87 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
88 cp.role_switch = 0x01;
90 cp.role_switch = 0x00;
92 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
95 static void hci_acl_connect_cancel(struct hci_conn *conn)
97 struct hci_cp_create_conn_cancel cp;
101 if (conn->hdev->hci_ver < 2)
104 bacpy(&cp.bdaddr, &conn->dst);
105 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
108 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
110 struct hci_cp_disconnect cp;
114 conn->state = BT_DISCONN;
116 cp.handle = cpu_to_le16(conn->handle);
118 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
121 void hci_add_sco(struct hci_conn *conn, __u16 handle)
123 struct hci_dev *hdev = conn->hdev;
124 struct hci_cp_add_sco cp;
128 conn->state = BT_CONNECT;
131 cp.handle = cpu_to_le16(handle);
132 cp.pkt_type = cpu_to_le16(conn->pkt_type);
134 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
137 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
139 struct hci_dev *hdev = conn->hdev;
140 struct hci_cp_setup_sync_conn cp;
144 conn->state = BT_CONNECT;
147 cp.handle = cpu_to_le16(handle);
148 cp.pkt_type = cpu_to_le16(conn->pkt_type);
150 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
151 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
152 cp.max_latency = cpu_to_le16(0xffff);
153 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
154 cp.retrans_effort = 0xff;
156 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
159 static void hci_conn_timeout(unsigned long arg)
161 struct hci_conn *conn = (void *) arg;
162 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) {
173 if (conn->type == ACL_LINK)
174 hci_acl_connect_cancel(conn);
176 hci_acl_disconn(conn, 0x13);
179 hci_acl_disconn(conn, 0x13);
182 conn->state = BT_CLOSED;
186 hci_dev_unlock(hdev);
189 static void hci_conn_idle(unsigned long arg)
191 struct hci_conn *conn = (void *) arg;
193 BT_DBG("conn %p mode %d", conn, conn->mode);
195 hci_conn_enter_sniff_mode(conn);
198 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
200 struct hci_conn *conn;
202 BT_DBG("%s dst %s", hdev->name, batostr(dst));
204 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
208 bacpy(&conn->dst, dst);
211 conn->mode = HCI_CM_ACTIVE;
212 conn->state = BT_OPEN;
214 conn->power_save = 1;
218 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
221 if (lmp_esco_capable(hdev))
222 conn->pkt_type = hdev->esco_type & SCO_ESCO_MASK;
224 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
227 conn->pkt_type = hdev->esco_type;
231 skb_queue_head_init(&conn->data_q);
233 setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
234 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
236 atomic_set(&conn->refcnt, 0);
240 tasklet_disable(&hdev->tx_task);
242 hci_conn_hash_add(hdev, conn);
244 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
246 hci_conn_add_sysfs(conn);
248 tasklet_enable(&hdev->tx_task);
253 int hci_conn_del(struct hci_conn *conn)
255 struct hci_dev *hdev = conn->hdev;
257 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
259 del_timer(&conn->idle_timer);
261 del_timer(&conn->disc_timer);
263 if (conn->type == ACL_LINK) {
264 struct hci_conn *sco = conn->link;
269 hdev->acl_cnt += conn->sent;
271 struct hci_conn *acl = conn->link;
278 tasklet_disable(&hdev->tx_task);
279 hci_conn_hash_del(hdev, conn);
281 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
282 tasklet_enable(&hdev->tx_task);
283 skb_queue_purge(&conn->data_q);
284 hci_conn_del_sysfs(conn);
289 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
291 int use_src = bacmp(src, BDADDR_ANY);
292 struct hci_dev *hdev = NULL;
295 BT_DBG("%s -> %s", batostr(src), batostr(dst));
297 read_lock_bh(&hci_dev_list_lock);
299 list_for_each(p, &hci_dev_list) {
300 struct hci_dev *d = list_entry(p, struct hci_dev, list);
302 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
306 * No source address - find interface with bdaddr != dst
307 * Source address - find interface with bdaddr == src
311 if (!bacmp(&d->bdaddr, src)) {
315 if (bacmp(&d->bdaddr, dst)) {
322 hdev = hci_dev_hold(hdev);
324 read_unlock_bh(&hci_dev_list_lock);
327 EXPORT_SYMBOL(hci_get_route);
329 /* Create SCO or ACL connection.
330 * Device _must_ be locked */
331 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
333 struct hci_conn *acl;
334 struct hci_conn *sco;
336 BT_DBG("%s dst %s", hdev->name, batostr(dst));
338 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
339 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
345 if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
346 hci_acl_connect(acl);
348 if (type == ACL_LINK)
351 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
352 if (!(sco = hci_conn_add(hdev, type, dst))) {
363 if (acl->state == BT_CONNECTED &&
364 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
365 if (lmp_esco_capable(hdev))
366 hci_setup_sync(sco, acl->handle);
368 hci_add_sco(sco, acl->handle);
373 EXPORT_SYMBOL(hci_connect);
375 /* Authenticate remote device */
376 int hci_conn_auth(struct hci_conn *conn)
378 BT_DBG("conn %p", conn);
380 if (conn->link_mode & HCI_LM_AUTH)
383 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
384 struct hci_cp_auth_requested cp;
385 cp.handle = cpu_to_le16(conn->handle);
386 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
390 EXPORT_SYMBOL(hci_conn_auth);
392 /* Enable encryption */
393 int hci_conn_encrypt(struct hci_conn *conn)
395 BT_DBG("conn %p", conn);
397 if (conn->link_mode & HCI_LM_ENCRYPT)
400 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
403 if (hci_conn_auth(conn)) {
404 struct hci_cp_set_conn_encrypt cp;
405 cp.handle = cpu_to_le16(conn->handle);
407 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
411 EXPORT_SYMBOL(hci_conn_encrypt);
413 /* Change link key */
414 int hci_conn_change_link_key(struct hci_conn *conn)
416 BT_DBG("conn %p", conn);
418 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
419 struct hci_cp_change_conn_link_key cp;
420 cp.handle = cpu_to_le16(conn->handle);
421 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
425 EXPORT_SYMBOL(hci_conn_change_link_key);
428 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
430 BT_DBG("conn %p", conn);
432 if (!role && conn->link_mode & HCI_LM_MASTER)
435 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
436 struct hci_cp_switch_role cp;
437 bacpy(&cp.bdaddr, &conn->dst);
439 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
443 EXPORT_SYMBOL(hci_conn_switch_role);
445 /* Enter active mode */
446 void hci_conn_enter_active_mode(struct hci_conn *conn)
448 struct hci_dev *hdev = conn->hdev;
450 BT_DBG("conn %p mode %d", conn, conn->mode);
452 if (test_bit(HCI_RAW, &hdev->flags))
455 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
458 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
459 struct hci_cp_exit_sniff_mode cp;
460 cp.handle = cpu_to_le16(conn->handle);
461 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
465 if (hdev->idle_timeout > 0)
466 mod_timer(&conn->idle_timer,
467 jiffies + msecs_to_jiffies(hdev->idle_timeout));
470 /* Enter sniff mode */
471 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
473 struct hci_dev *hdev = conn->hdev;
475 BT_DBG("conn %p mode %d", conn, conn->mode);
477 if (test_bit(HCI_RAW, &hdev->flags))
480 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
483 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
486 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
487 struct hci_cp_sniff_subrate cp;
488 cp.handle = cpu_to_le16(conn->handle);
489 cp.max_latency = cpu_to_le16(0);
490 cp.min_remote_timeout = cpu_to_le16(0);
491 cp.min_local_timeout = cpu_to_le16(0);
492 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
495 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
496 struct hci_cp_sniff_mode cp;
497 cp.handle = cpu_to_le16(conn->handle);
498 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
499 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
500 cp.attempt = cpu_to_le16(4);
501 cp.timeout = cpu_to_le16(1);
502 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
506 /* Drop all connection on the device */
507 void hci_conn_hash_flush(struct hci_dev *hdev)
509 struct hci_conn_hash *h = &hdev->conn_hash;
512 BT_DBG("hdev %s", hdev->name);
515 while (p != &h->list) {
518 c = list_entry(p, struct hci_conn, list);
521 c->state = BT_CLOSED;
523 hci_proto_disconn_ind(c, 0x16);
528 /* Check pending connect attempts */
529 void hci_conn_check_pending(struct hci_dev *hdev)
531 struct hci_conn *conn;
533 BT_DBG("hdev %s", hdev->name);
537 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
539 hci_acl_connect(conn);
541 hci_dev_unlock(hdev);
544 int hci_get_conn_list(void __user *arg)
546 struct hci_conn_list_req req, *cl;
547 struct hci_conn_info *ci;
548 struct hci_dev *hdev;
550 int n = 0, size, err;
552 if (copy_from_user(&req, arg, sizeof(req)))
555 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
558 size = sizeof(req) + req.conn_num * sizeof(*ci);
560 if (!(cl = kmalloc(size, GFP_KERNEL)))
563 if (!(hdev = hci_dev_get(req.dev_id))) {
570 hci_dev_lock_bh(hdev);
571 list_for_each(p, &hdev->conn_hash.list) {
572 register struct hci_conn *c;
573 c = list_entry(p, struct hci_conn, list);
575 bacpy(&(ci + n)->bdaddr, &c->dst);
576 (ci + n)->handle = c->handle;
577 (ci + n)->type = c->type;
578 (ci + n)->out = c->out;
579 (ci + n)->state = c->state;
580 (ci + n)->link_mode = c->link_mode;
581 if (++n >= req.conn_num)
584 hci_dev_unlock_bh(hdev);
586 cl->dev_id = hdev->id;
588 size = sizeof(req) + n * sizeof(*ci);
592 err = copy_to_user(arg, cl, size);
595 return err ? -EFAULT : 0;
598 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
600 struct hci_conn_info_req req;
601 struct hci_conn_info ci;
602 struct hci_conn *conn;
603 char __user *ptr = arg + sizeof(req);
605 if (copy_from_user(&req, arg, sizeof(req)))
608 hci_dev_lock_bh(hdev);
609 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
611 bacpy(&ci.bdaddr, &conn->dst);
612 ci.handle = conn->handle;
613 ci.type = conn->type;
615 ci.state = conn->state;
616 ci.link_mode = conn->link_mode;
618 hci_dev_unlock_bh(hdev);
623 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;