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);
351 /* Drop all connection on the device */
352 void hci_conn_hash_flush(struct hci_dev *hdev)
354 struct hci_conn_hash *h = &hdev->conn_hash;
357 BT_DBG("hdev %s", hdev->name);
360 while (p != &h->list) {
363 c = list_entry(p, struct hci_conn, list);
366 c->state = BT_CLOSED;
368 hci_proto_disconn_ind(c, 0x16);
373 int hci_get_conn_list(void __user *arg)
375 struct hci_conn_list_req req, *cl;
376 struct hci_conn_info *ci;
377 struct hci_dev *hdev;
379 int n = 0, size, err;
381 if (copy_from_user(&req, arg, sizeof(req)))
384 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
387 size = sizeof(req) + req.conn_num * sizeof(*ci);
389 if (!(cl = (void *) kmalloc(size, GFP_KERNEL)))
392 if (!(hdev = hci_dev_get(req.dev_id))) {
399 hci_dev_lock_bh(hdev);
400 list_for_each(p, &hdev->conn_hash.list) {
401 register struct hci_conn *c;
402 c = list_entry(p, struct hci_conn, list);
404 bacpy(&(ci + n)->bdaddr, &c->dst);
405 (ci + n)->handle = c->handle;
406 (ci + n)->type = c->type;
407 (ci + n)->out = c->out;
408 (ci + n)->state = c->state;
409 (ci + n)->link_mode = c->link_mode;
410 if (++n >= req.conn_num)
413 hci_dev_unlock_bh(hdev);
415 cl->dev_id = hdev->id;
417 size = sizeof(req) + n * sizeof(*ci);
421 err = copy_to_user(arg, cl, size);
424 return err ? -EFAULT : 0;
427 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
429 struct hci_conn_info_req req;
430 struct hci_conn_info ci;
431 struct hci_conn *conn;
432 char __user *ptr = arg + sizeof(req);
434 if (copy_from_user(&req, arg, sizeof(req)))
437 hci_dev_lock_bh(hdev);
438 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
440 bacpy(&ci.bdaddr, &conn->dst);
441 ci.handle = conn->handle;
442 ci.type = conn->type;
444 ci.state = conn->state;
445 ci.link_mode = conn->link_mode;
447 hci_dev_unlock_bh(hdev);
452 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;