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.
26 * HCI Connection handling.
28 * $Id: hci_conn.c,v 1.2 2002/04/17 17:37:16 maxk Exp $
31 #include <linux/config.h>
32 #include <linux/module.h>
34 #include <linux/types.h>
35 #include <linux/errno.h>
36 #include <linux/kernel.h>
37 #include <linux/major.h>
38 #include <linux/sched.h>
39 #include <linux/slab.h>
40 #include <linux/poll.h>
41 #include <linux/fcntl.h>
42 #include <linux/init.h>
43 #include <linux/skbuff.h>
44 #include <linux/interrupt.h>
45 #include <linux/notifier.h>
48 #include <asm/system.h>
49 #include <asm/uaccess.h>
50 #include <asm/unaligned.h>
52 #include <net/bluetooth/bluetooth.h>
53 #include <net/bluetooth/hci_core.h>
55 #ifndef CONFIG_BT_HCI_CORE_DEBUG
57 #define BT_DBG( A... )
60 void hci_acl_connect(struct hci_conn *conn)
62 struct hci_dev *hdev = conn->hdev;
63 struct inquiry_entry *ie;
64 struct hci_cp_create_conn cp;
68 conn->state = BT_CONNECT;
70 conn->link_mode = HCI_LM_MASTER;
72 memset(&cp, 0, sizeof(cp));
73 bacpy(&cp.bdaddr, &conn->dst);
74 cp.pscan_rep_mode = 0x02;
76 if ((ie = inquiry_cache_lookup(hdev, &conn->dst)) &&
77 inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
78 cp.pscan_rep_mode = ie->info.pscan_rep_mode;
79 cp.pscan_mode = ie->info.pscan_mode;
80 cp.clock_offset = ie->info.clock_offset | __cpu_to_le16(0x8000);
83 cp.pkt_type = __cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
84 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
85 cp.role_switch = 0x01;
87 cp.role_switch = 0x00;
89 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_CREATE_CONN, sizeof(cp), &cp);
92 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
94 struct hci_cp_disconnect cp;
98 conn->state = BT_DISCONN;
100 cp.handle = __cpu_to_le16(conn->handle);
102 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_DISCONNECT, sizeof(cp), &cp);
105 void hci_add_sco(struct hci_conn *conn, __u16 handle)
107 struct hci_dev *hdev = conn->hdev;
108 struct hci_cp_add_sco cp;
112 conn->state = BT_CONNECT;
115 cp.pkt_type = __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
116 cp.handle = __cpu_to_le16(handle);
118 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ADD_SCO, sizeof(cp), &cp);
121 static void hci_conn_timeout(unsigned long arg)
123 struct hci_conn *conn = (void *)arg;
124 struct hci_dev *hdev = conn->hdev;
126 BT_DBG("conn %p state %d", conn, conn->state);
128 if (atomic_read(&conn->refcnt))
132 if (conn->state == BT_CONNECTED)
133 hci_acl_disconn(conn, 0x13);
135 conn->state = BT_CLOSED;
136 hci_dev_unlock(hdev);
140 static void hci_conn_init_timer(struct hci_conn *conn)
142 init_timer(&conn->timer);
143 conn->timer.function = hci_conn_timeout;
144 conn->timer.data = (unsigned long)conn;
147 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
149 struct hci_conn *conn;
151 BT_DBG("%s dst %s", hdev->name, batostr(dst));
153 if (!(conn = kmalloc(sizeof(struct hci_conn), GFP_ATOMIC)))
155 memset(conn, 0, sizeof(struct hci_conn));
157 bacpy(&conn->dst, dst);
160 conn->state = BT_OPEN;
162 skb_queue_head_init(&conn->data_q);
163 hci_conn_init_timer(conn);
165 atomic_set(&conn->refcnt, 0);
169 tasklet_disable(&hdev->tx_task);
170 hci_conn_hash_add(hdev, conn);
171 tasklet_enable(&hdev->tx_task);
174 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
179 int hci_conn_del(struct hci_conn *conn)
181 struct hci_dev *hdev = conn->hdev;
183 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
185 hci_conn_del_timer(conn);
187 if (conn->type == SCO_LINK) {
188 struct hci_conn *acl = conn->link;
194 struct hci_conn *sco = conn->link;
199 hdev->acl_cnt += conn->sent;
203 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
205 tasklet_disable(&hdev->tx_task);
206 hci_conn_hash_del(hdev, conn);
207 tasklet_enable(&hdev->tx_task);
209 skb_queue_purge(&conn->data_q);
217 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
219 int use_src = bacmp(src, BDADDR_ANY);
220 struct hci_dev *hdev = NULL;
223 BT_DBG("%s -> %s", batostr(src), batostr(dst));
225 read_lock_bh(&hci_dev_list_lock);
227 list_for_each(p, &hci_dev_list) {
228 struct hci_dev *d = list_entry(p, struct hci_dev, list);
230 if (!test_bit(HCI_UP, &d->flags))
234 * No source address - find interface with bdaddr != dst
235 * Source address - find interface with bdaddr == src
239 if (!bacmp(&d->bdaddr, src)) {
243 if (bacmp(&d->bdaddr, dst)) {
250 hdev = hci_dev_hold(hdev);
252 read_unlock_bh(&hci_dev_list_lock);
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);
298 /* Authenticate remote device */
299 int hci_conn_auth(struct hci_conn *conn)
301 BT_DBG("conn %p", conn);
303 if (conn->link_mode & HCI_LM_AUTH)
306 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
307 struct hci_cp_auth_requested cp;
308 cp.handle = __cpu_to_le16(conn->handle);
309 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_AUTH_REQUESTED, sizeof(cp), &cp);
314 /* Enable encryption */
315 int hci_conn_encrypt(struct hci_conn *conn)
317 BT_DBG("conn %p", conn);
319 if (conn->link_mode & HCI_LM_ENCRYPT)
322 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
325 if (hci_conn_auth(conn)) {
326 struct hci_cp_set_conn_encrypt cp;
327 cp.handle = __cpu_to_le16(conn->handle);
329 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, sizeof(cp), &cp);
334 /* Drop all connection on the device */
335 void hci_conn_hash_flush(struct hci_dev *hdev)
337 struct hci_conn_hash *h = &hdev->conn_hash;
340 BT_DBG("hdev %s", hdev->name);
343 while (p != &h->list) {
346 c = list_entry(p, struct hci_conn, list);
349 c->state = BT_CLOSED;
351 hci_proto_disconn_ind(c, 0x16);
356 int hci_get_conn_list(unsigned long arg)
358 struct hci_conn_list_req req, *cl;
359 struct hci_conn_info *ci;
360 struct hci_dev *hdev;
362 int n = 0, size, err;
364 if (copy_from_user(&req, (void *) arg, sizeof(req)))
367 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
370 size = sizeof(req) + req.conn_num * sizeof(*ci);
372 if (!(cl = (void *) kmalloc(size, GFP_KERNEL)))
375 if (!(hdev = hci_dev_get(req.dev_id))) {
382 hci_dev_lock_bh(hdev);
383 list_for_each(p, &hdev->conn_hash.list) {
384 register struct hci_conn *c;
385 c = list_entry(p, struct hci_conn, list);
387 bacpy(&(ci + n)->bdaddr, &c->dst);
388 (ci + n)->handle = c->handle;
389 (ci + n)->type = c->type;
390 (ci + n)->out = c->out;
391 (ci + n)->state = c->state;
392 (ci + n)->link_mode = c->link_mode;
393 if (++n >= req.conn_num)
396 hci_dev_unlock_bh(hdev);
398 cl->dev_id = hdev->id;
400 size = sizeof(req) + n * sizeof(*ci);
404 err = copy_to_user((void *) arg, cl, size);
407 return err ? -EFAULT : 0;
410 int hci_get_conn_info(struct hci_dev *hdev, unsigned long arg)
412 struct hci_conn_info_req req;
413 struct hci_conn_info ci;
414 struct hci_conn *conn;
415 char *ptr = (void *) arg + sizeof(req);
417 if (copy_from_user(&req, (void *) arg, sizeof(req)))
420 hci_dev_lock_bh(hdev);
421 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
423 bacpy(&ci.bdaddr, &conn->dst);
424 ci.handle = conn->handle;
425 ci.type = conn->type;
427 ci.state = conn->state;
428 ci.link_mode = conn->link_mode;
430 hci_dev_unlock_bh(hdev);
435 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;