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;
63 conn->link_mode = HCI_LM_MASTER;
67 memset(&cp, 0, sizeof(cp));
68 bacpy(&cp.bdaddr, &conn->dst);
69 cp.pscan_rep_mode = 0x02;
71 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)) &&
72 inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
73 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
74 cp.pscan_mode = ie->data.pscan_mode;
75 cp.clock_offset = ie->data.clock_offset | cpu_to_le16(0x8000);
76 memcpy(conn->dev_class, ie->data.dev_class, 3);
79 cp.pkt_type = cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
80 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
81 cp.role_switch = 0x01;
83 cp.role_switch = 0x00;
85 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
88 static void hci_acl_connect_cancel(struct hci_conn *conn)
90 struct hci_cp_create_conn_cancel cp;
94 if (conn->hdev->hci_ver < 2)
97 bacpy(&cp.bdaddr, &conn->dst);
98 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
101 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
103 struct hci_cp_disconnect cp;
107 conn->state = BT_DISCONN;
109 cp.handle = cpu_to_le16(conn->handle);
111 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
114 void hci_add_sco(struct hci_conn *conn, __u16 handle)
116 struct hci_dev *hdev = conn->hdev;
117 struct hci_cp_add_sco cp;
121 conn->state = BT_CONNECT;
124 cp.handle = cpu_to_le16(handle);
125 cp.pkt_type = cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
127 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
130 static void hci_conn_timeout(unsigned long arg)
132 struct hci_conn *conn = (void *) arg;
133 struct hci_dev *hdev = conn->hdev;
135 BT_DBG("conn %p state %d", conn, conn->state);
137 if (atomic_read(&conn->refcnt))
142 switch (conn->state) {
144 hci_acl_connect_cancel(conn);
147 hci_acl_disconn(conn, 0x13);
150 conn->state = BT_CLOSED;
154 hci_dev_unlock(hdev);
157 static void hci_conn_idle(unsigned long arg)
159 struct hci_conn *conn = (void *) arg;
161 BT_DBG("conn %p mode %d", conn, conn->mode);
163 hci_conn_enter_sniff_mode(conn);
166 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
168 struct hci_conn *conn;
170 BT_DBG("%s dst %s", hdev->name, batostr(dst));
172 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
176 bacpy(&conn->dst, dst);
179 conn->mode = HCI_CM_ACTIVE;
180 conn->state = BT_OPEN;
182 conn->power_save = 1;
184 skb_queue_head_init(&conn->data_q);
186 init_timer(&conn->disc_timer);
187 conn->disc_timer.function = hci_conn_timeout;
188 conn->disc_timer.data = (unsigned long) conn;
190 init_timer(&conn->idle_timer);
191 conn->idle_timer.function = hci_conn_idle;
192 conn->idle_timer.data = (unsigned long) conn;
194 atomic_set(&conn->refcnt, 0);
198 tasklet_disable(&hdev->tx_task);
200 hci_conn_hash_add(hdev, conn);
202 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
204 hci_conn_add_sysfs(conn);
206 tasklet_enable(&hdev->tx_task);
211 int hci_conn_del(struct hci_conn *conn)
213 struct hci_dev *hdev = conn->hdev;
215 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
217 del_timer(&conn->idle_timer);
219 del_timer(&conn->disc_timer);
221 if (conn->type == ACL_LINK) {
222 struct hci_conn *sco = conn->link;
227 hdev->acl_cnt += conn->sent;
229 struct hci_conn *acl = conn->link;
236 tasklet_disable(&hdev->tx_task);
238 hci_conn_del_sysfs(conn);
240 hci_conn_hash_del(hdev, conn);
242 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
244 tasklet_enable(&hdev->tx_task);
246 skb_queue_purge(&conn->data_q);
250 /* will free via device release */
251 put_device(&conn->dev);
256 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
258 int use_src = bacmp(src, BDADDR_ANY);
259 struct hci_dev *hdev = NULL;
262 BT_DBG("%s -> %s", batostr(src), batostr(dst));
264 read_lock_bh(&hci_dev_list_lock);
266 list_for_each(p, &hci_dev_list) {
267 struct hci_dev *d = list_entry(p, struct hci_dev, list);
269 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
273 * No source address - find interface with bdaddr != dst
274 * Source address - find interface with bdaddr == src
278 if (!bacmp(&d->bdaddr, src)) {
282 if (bacmp(&d->bdaddr, dst)) {
289 hdev = hci_dev_hold(hdev);
291 read_unlock_bh(&hci_dev_list_lock);
294 EXPORT_SYMBOL(hci_get_route);
296 /* Create SCO or ACL connection.
297 * Device _must_ be locked */
298 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
300 struct hci_conn *acl;
301 struct hci_conn *sco;
303 BT_DBG("%s dst %s", hdev->name, batostr(dst));
305 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
306 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
312 if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
313 hci_acl_connect(acl);
315 if (type == ACL_LINK)
318 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
319 if (!(sco = hci_conn_add(hdev, type, dst))) {
330 if (acl->state == BT_CONNECTED &&
331 (sco->state == BT_OPEN || sco->state == BT_CLOSED))
332 hci_add_sco(sco, acl->handle);
336 EXPORT_SYMBOL(hci_connect);
338 /* Authenticate remote device */
339 int hci_conn_auth(struct hci_conn *conn)
341 BT_DBG("conn %p", conn);
343 if (conn->link_mode & HCI_LM_AUTH)
346 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
347 struct hci_cp_auth_requested cp;
348 cp.handle = cpu_to_le16(conn->handle);
349 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
353 EXPORT_SYMBOL(hci_conn_auth);
355 /* Enable encryption */
356 int hci_conn_encrypt(struct hci_conn *conn)
358 BT_DBG("conn %p", conn);
360 if (conn->link_mode & HCI_LM_ENCRYPT)
363 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
366 if (hci_conn_auth(conn)) {
367 struct hci_cp_set_conn_encrypt cp;
368 cp.handle = cpu_to_le16(conn->handle);
370 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
374 EXPORT_SYMBOL(hci_conn_encrypt);
376 /* Change link key */
377 int hci_conn_change_link_key(struct hci_conn *conn)
379 BT_DBG("conn %p", conn);
381 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
382 struct hci_cp_change_conn_link_key cp;
383 cp.handle = cpu_to_le16(conn->handle);
384 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
388 EXPORT_SYMBOL(hci_conn_change_link_key);
391 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
393 BT_DBG("conn %p", conn);
395 if (!role && conn->link_mode & HCI_LM_MASTER)
398 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
399 struct hci_cp_switch_role cp;
400 bacpy(&cp.bdaddr, &conn->dst);
402 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
406 EXPORT_SYMBOL(hci_conn_switch_role);
408 /* Enter active mode */
409 void hci_conn_enter_active_mode(struct hci_conn *conn)
411 struct hci_dev *hdev = conn->hdev;
413 BT_DBG("conn %p mode %d", conn, conn->mode);
415 if (test_bit(HCI_RAW, &hdev->flags))
418 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
421 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
422 struct hci_cp_exit_sniff_mode cp;
423 cp.handle = cpu_to_le16(conn->handle);
424 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
428 if (hdev->idle_timeout > 0)
429 mod_timer(&conn->idle_timer,
430 jiffies + msecs_to_jiffies(hdev->idle_timeout));
433 /* Enter sniff mode */
434 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
436 struct hci_dev *hdev = conn->hdev;
438 BT_DBG("conn %p mode %d", conn, conn->mode);
440 if (test_bit(HCI_RAW, &hdev->flags))
443 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
446 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
449 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
450 struct hci_cp_sniff_subrate cp;
451 cp.handle = cpu_to_le16(conn->handle);
452 cp.max_latency = cpu_to_le16(0);
453 cp.min_remote_timeout = cpu_to_le16(0);
454 cp.min_local_timeout = cpu_to_le16(0);
455 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
458 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
459 struct hci_cp_sniff_mode cp;
460 cp.handle = cpu_to_le16(conn->handle);
461 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
462 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
463 cp.attempt = cpu_to_le16(4);
464 cp.timeout = cpu_to_le16(1);
465 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
469 /* Drop all connection on the device */
470 void hci_conn_hash_flush(struct hci_dev *hdev)
472 struct hci_conn_hash *h = &hdev->conn_hash;
475 BT_DBG("hdev %s", hdev->name);
478 while (p != &h->list) {
481 c = list_entry(p, struct hci_conn, list);
484 c->state = BT_CLOSED;
486 hci_proto_disconn_ind(c, 0x16);
491 /* Check pending connect attempts */
492 void hci_conn_check_pending(struct hci_dev *hdev)
494 struct hci_conn *conn;
496 BT_DBG("hdev %s", hdev->name);
500 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
502 hci_acl_connect(conn);
504 hci_dev_unlock(hdev);
507 int hci_get_conn_list(void __user *arg)
509 struct hci_conn_list_req req, *cl;
510 struct hci_conn_info *ci;
511 struct hci_dev *hdev;
513 int n = 0, size, err;
515 if (copy_from_user(&req, arg, sizeof(req)))
518 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
521 size = sizeof(req) + req.conn_num * sizeof(*ci);
523 if (!(cl = kmalloc(size, GFP_KERNEL)))
526 if (!(hdev = hci_dev_get(req.dev_id))) {
533 hci_dev_lock_bh(hdev);
534 list_for_each(p, &hdev->conn_hash.list) {
535 register struct hci_conn *c;
536 c = list_entry(p, struct hci_conn, list);
538 bacpy(&(ci + n)->bdaddr, &c->dst);
539 (ci + n)->handle = c->handle;
540 (ci + n)->type = c->type;
541 (ci + n)->out = c->out;
542 (ci + n)->state = c->state;
543 (ci + n)->link_mode = c->link_mode;
544 if (++n >= req.conn_num)
547 hci_dev_unlock_bh(hdev);
549 cl->dev_id = hdev->id;
551 size = sizeof(req) + n * sizeof(*ci);
555 err = copy_to_user(arg, cl, size);
558 return err ? -EFAULT : 0;
561 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
563 struct hci_conn_info_req req;
564 struct hci_conn_info ci;
565 struct hci_conn *conn;
566 char __user *ptr = arg + sizeof(req);
568 if (copy_from_user(&req, arg, sizeof(req)))
571 hci_dev_lock_bh(hdev);
572 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
574 bacpy(&ci.bdaddr, &conn->dst);
575 ci.handle = conn->handle;
576 ci.type = conn->type;
578 ci.state = conn->state;
579 ci.link_mode = conn->link_mode;
581 hci_dev_unlock_bh(hdev);
586 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;