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/config.h>
28 #include <linux/module.h>
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/major.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_acl_connect(struct hci_conn *conn)
58 struct hci_dev *hdev = conn->hdev;
59 struct inquiry_entry *ie;
60 struct hci_cp_create_conn cp;
64 conn->state = BT_CONNECT;
66 conn->link_mode = HCI_LM_MASTER;
68 memset(&cp, 0, sizeof(cp));
69 bacpy(&cp.bdaddr, &conn->dst);
70 cp.pscan_rep_mode = 0x02;
72 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)) &&
73 inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
74 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
75 cp.pscan_mode = ie->data.pscan_mode;
76 cp.clock_offset = ie->data.clock_offset | __cpu_to_le16(0x8000);
77 memcpy(conn->dev_class, ie->data.dev_class, 3);
80 cp.pkt_type = __cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
81 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
82 cp.role_switch = 0x01;
84 cp.role_switch = 0x00;
86 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_CREATE_CONN, sizeof(cp), &cp);
89 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
91 struct hci_cp_disconnect cp;
95 conn->state = BT_DISCONN;
97 cp.handle = __cpu_to_le16(conn->handle);
99 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_DISCONNECT, sizeof(cp), &cp);
102 void hci_add_sco(struct hci_conn *conn, __u16 handle)
104 struct hci_dev *hdev = conn->hdev;
105 struct hci_cp_add_sco cp;
109 conn->state = BT_CONNECT;
112 cp.pkt_type = __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
113 cp.handle = __cpu_to_le16(handle);
115 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ADD_SCO, sizeof(cp), &cp);
118 static void hci_conn_timeout(unsigned long arg)
120 struct hci_conn *conn = (void *)arg;
121 struct hci_dev *hdev = conn->hdev;
123 BT_DBG("conn %p state %d", conn, conn->state);
125 if (atomic_read(&conn->refcnt))
129 if (conn->state == BT_CONNECTED)
130 hci_acl_disconn(conn, 0x13);
132 conn->state = BT_CLOSED;
133 hci_dev_unlock(hdev);
137 static void hci_conn_init_timer(struct hci_conn *conn)
139 init_timer(&conn->timer);
140 conn->timer.function = hci_conn_timeout;
141 conn->timer.data = (unsigned long)conn;
144 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
146 struct hci_conn *conn;
148 BT_DBG("%s dst %s", hdev->name, batostr(dst));
150 if (!(conn = kmalloc(sizeof(struct hci_conn), GFP_ATOMIC)))
152 memset(conn, 0, sizeof(struct hci_conn));
154 bacpy(&conn->dst, dst);
157 conn->state = BT_OPEN;
159 skb_queue_head_init(&conn->data_q);
160 hci_conn_init_timer(conn);
162 atomic_set(&conn->refcnt, 0);
166 tasklet_disable(&hdev->tx_task);
168 hci_conn_hash_add(hdev, conn);
170 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
172 tasklet_enable(&hdev->tx_task);
177 int hci_conn_del(struct hci_conn *conn)
179 struct hci_dev *hdev = conn->hdev;
181 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
183 hci_conn_del_timer(conn);
185 if (conn->type == SCO_LINK) {
186 struct hci_conn *acl = conn->link;
192 struct hci_conn *sco = conn->link;
197 hdev->acl_cnt += conn->sent;
200 tasklet_disable(&hdev->tx_task);
202 hci_conn_hash_del(hdev, conn);
204 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
206 tasklet_enable(&hdev->tx_task);
208 skb_queue_purge(&conn->data_q);
216 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
218 int use_src = bacmp(src, BDADDR_ANY);
219 struct hci_dev *hdev = NULL;
222 BT_DBG("%s -> %s", batostr(src), batostr(dst));
224 read_lock_bh(&hci_dev_list_lock);
226 list_for_each(p, &hci_dev_list) {
227 struct hci_dev *d = list_entry(p, struct hci_dev, list);
229 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
233 * No source address - find interface with bdaddr != dst
234 * Source address - find interface with bdaddr == src
238 if (!bacmp(&d->bdaddr, src)) {
242 if (bacmp(&d->bdaddr, dst)) {
249 hdev = hci_dev_hold(hdev);
251 read_unlock_bh(&hci_dev_list_lock);
254 EXPORT_SYMBOL(hci_get_route);
256 /* Create SCO or ACL connection.
257 * Device _must_ be locked */
258 struct hci_conn * hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
260 struct hci_conn *acl;
262 BT_DBG("%s dst %s", hdev->name, batostr(dst));
264 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
265 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
271 if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
272 hci_acl_connect(acl);
274 if (type == SCO_LINK) {
275 struct hci_conn *sco;
277 if (!(sco = hci_conn_hash_lookup_ba(hdev, SCO_LINK, dst))) {
278 if (!(sco = hci_conn_add(hdev, SCO_LINK, dst))) {
288 if (acl->state == BT_CONNECTED &&
289 (sco->state == BT_OPEN || sco->state == BT_CLOSED))
290 hci_add_sco(sco, acl->handle);
297 EXPORT_SYMBOL(hci_connect);
299 /* Authenticate remote device */
300 int hci_conn_auth(struct hci_conn *conn)
302 BT_DBG("conn %p", conn);
304 if (conn->link_mode & HCI_LM_AUTH)
307 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
308 struct hci_cp_auth_requested cp;
309 cp.handle = __cpu_to_le16(conn->handle);
310 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_AUTH_REQUESTED, sizeof(cp), &cp);
314 EXPORT_SYMBOL(hci_conn_auth);
316 /* Enable encryption */
317 int hci_conn_encrypt(struct hci_conn *conn)
319 BT_DBG("conn %p", conn);
321 if (conn->link_mode & HCI_LM_ENCRYPT)
324 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
327 if (hci_conn_auth(conn)) {
328 struct hci_cp_set_conn_encrypt cp;
329 cp.handle = __cpu_to_le16(conn->handle);
331 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, sizeof(cp), &cp);
335 EXPORT_SYMBOL(hci_conn_encrypt);
337 /* Change link key */
338 int hci_conn_change_link_key(struct hci_conn *conn)
340 BT_DBG("conn %p", conn);
342 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
343 struct hci_cp_change_conn_link_key cp;
344 cp.handle = __cpu_to_le16(conn->handle);
345 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
349 EXPORT_SYMBOL(hci_conn_change_link_key);
352 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
354 BT_DBG("conn %p", conn);
356 if (!role && conn->link_mode & HCI_LM_MASTER)
359 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
360 struct hci_cp_switch_role cp;
361 bacpy(&cp.bdaddr, &conn->dst);
363 hci_send_cmd(conn->hdev, OGF_LINK_POLICY, OCF_SWITCH_ROLE, sizeof(cp), &cp);
367 EXPORT_SYMBOL(hci_conn_switch_role);
369 /* Drop all connection on the device */
370 void hci_conn_hash_flush(struct hci_dev *hdev)
372 struct hci_conn_hash *h = &hdev->conn_hash;
375 BT_DBG("hdev %s", hdev->name);
378 while (p != &h->list) {
381 c = list_entry(p, struct hci_conn, list);
384 c->state = BT_CLOSED;
386 hci_proto_disconn_ind(c, 0x16);
391 int hci_get_conn_list(void __user *arg)
393 struct hci_conn_list_req req, *cl;
394 struct hci_conn_info *ci;
395 struct hci_dev *hdev;
397 int n = 0, size, err;
399 if (copy_from_user(&req, arg, sizeof(req)))
402 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
405 size = sizeof(req) + req.conn_num * sizeof(*ci);
407 if (!(cl = (void *) kmalloc(size, GFP_KERNEL)))
410 if (!(hdev = hci_dev_get(req.dev_id))) {
417 hci_dev_lock_bh(hdev);
418 list_for_each(p, &hdev->conn_hash.list) {
419 register struct hci_conn *c;
420 c = list_entry(p, struct hci_conn, list);
422 bacpy(&(ci + n)->bdaddr, &c->dst);
423 (ci + n)->handle = c->handle;
424 (ci + n)->type = c->type;
425 (ci + n)->out = c->out;
426 (ci + n)->state = c->state;
427 (ci + n)->link_mode = c->link_mode;
428 if (++n >= req.conn_num)
431 hci_dev_unlock_bh(hdev);
433 cl->dev_id = hdev->id;
435 size = sizeof(req) + n * sizeof(*ci);
439 err = copy_to_user(arg, cl, size);
442 return err ? -EFAULT : 0;
445 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
447 struct hci_conn_info_req req;
448 struct hci_conn_info ci;
449 struct hci_conn *conn;
450 char __user *ptr = arg + sizeof(req);
452 if (copy_from_user(&req, arg, sizeof(req)))
455 hci_dev_lock_bh(hdev);
456 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
458 bacpy(&ci.bdaddr, &conn->dst);
459 ci.handle = conn->handle;
460 ci.type = conn->type;
462 ci.state = conn->state;
463 ci.link_mode = conn->link_mode;
465 hci_dev_unlock_bh(hdev);
470 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;