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 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
->info
.pscan_rep_mode
;
75 cp
.pscan_mode
= ie
->info
.pscan_mode
;
76 cp
.clock_offset
= ie
->info
.clock_offset
| __cpu_to_le16(0x8000);
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
, OGF_LINK_CTL
, OCF_CREATE_CONN
, sizeof(cp
), &cp
);
88 void hci_acl_disconn(struct hci_conn
*conn
, __u8 reason
)
90 struct hci_cp_disconnect cp
;
94 conn
->state
= BT_DISCONN
;
96 cp
.handle
= __cpu_to_le16(conn
->handle
);
98 hci_send_cmd(conn
->hdev
, OGF_LINK_CTL
, OCF_DISCONNECT
, sizeof(cp
), &cp
);
101 void hci_add_sco(struct hci_conn
*conn
, __u16 handle
)
103 struct hci_dev
*hdev
= conn
->hdev
;
104 struct hci_cp_add_sco cp
;
108 conn
->state
= BT_CONNECT
;
111 cp
.pkt_type
= __cpu_to_le16(hdev
->pkt_type
& SCO_PTYPE_MASK
);
112 cp
.handle
= __cpu_to_le16(handle
);
114 hci_send_cmd(hdev
, OGF_LINK_CTL
, OCF_ADD_SCO
, sizeof(cp
), &cp
);
117 static void hci_conn_timeout(unsigned long arg
)
119 struct hci_conn
*conn
= (void *)arg
;
120 struct hci_dev
*hdev
= conn
->hdev
;
122 BT_DBG("conn %p state %d", conn
, conn
->state
);
124 if (atomic_read(&conn
->refcnt
))
128 if (conn
->state
== BT_CONNECTED
)
129 hci_acl_disconn(conn
, 0x13);
131 conn
->state
= BT_CLOSED
;
132 hci_dev_unlock(hdev
);
136 static void hci_conn_init_timer(struct hci_conn
*conn
)
138 init_timer(&conn
->timer
);
139 conn
->timer
.function
= hci_conn_timeout
;
140 conn
->timer
.data
= (unsigned long)conn
;
143 struct hci_conn
*hci_conn_add(struct hci_dev
*hdev
, int type
, bdaddr_t
*dst
)
145 struct hci_conn
*conn
;
147 BT_DBG("%s dst %s", hdev
->name
, batostr(dst
));
149 if (!(conn
= kmalloc(sizeof(struct hci_conn
), GFP_ATOMIC
)))
151 memset(conn
, 0, sizeof(struct hci_conn
));
153 bacpy(&conn
->dst
, dst
);
156 conn
->state
= BT_OPEN
;
158 skb_queue_head_init(&conn
->data_q
);
159 hci_conn_init_timer(conn
);
161 atomic_set(&conn
->refcnt
, 0);
165 tasklet_disable(&hdev
->tx_task
);
166 hci_conn_hash_add(hdev
, conn
);
167 tasklet_enable(&hdev
->tx_task
);
170 hdev
->notify(hdev
, HCI_NOTIFY_CONN_ADD
);
175 int hci_conn_del(struct hci_conn
*conn
)
177 struct hci_dev
*hdev
= conn
->hdev
;
179 BT_DBG("%s conn %p handle %d", hdev
->name
, conn
, conn
->handle
);
181 hci_conn_del_timer(conn
);
183 if (conn
->type
== SCO_LINK
) {
184 struct hci_conn
*acl
= conn
->link
;
190 struct hci_conn
*sco
= conn
->link
;
195 hdev
->acl_cnt
+= conn
->sent
;
199 hdev
->notify(hdev
, HCI_NOTIFY_CONN_DEL
);
201 tasklet_disable(&hdev
->tx_task
);
202 hci_conn_hash_del(hdev
, conn
);
203 tasklet_enable(&hdev
->tx_task
);
205 skb_queue_purge(&conn
->data_q
);
213 struct hci_dev
*hci_get_route(bdaddr_t
*dst
, bdaddr_t
*src
)
215 int use_src
= bacmp(src
, BDADDR_ANY
);
216 struct hci_dev
*hdev
= NULL
;
219 BT_DBG("%s -> %s", batostr(src
), batostr(dst
));
221 read_lock_bh(&hci_dev_list_lock
);
223 list_for_each(p
, &hci_dev_list
) {
224 struct hci_dev
*d
= list_entry(p
, struct hci_dev
, list
);
226 if (!test_bit(HCI_UP
, &d
->flags
))
230 * No source address - find interface with bdaddr != dst
231 * Source address - find interface with bdaddr == src
235 if (!bacmp(&d
->bdaddr
, src
)) {
239 if (bacmp(&d
->bdaddr
, dst
)) {
246 hdev
= hci_dev_hold(hdev
);
248 read_unlock_bh(&hci_dev_list_lock
);
251 EXPORT_SYMBOL(hci_get_route
);
253 /* Create SCO or ACL connection.
254 * Device _must_ be locked */
255 struct hci_conn
* hci_connect(struct hci_dev
*hdev
, int type
, bdaddr_t
*dst
)
257 struct hci_conn
*acl
;
259 BT_DBG("%s dst %s", hdev
->name
, batostr(dst
));
261 if (!(acl
= hci_conn_hash_lookup_ba(hdev
, ACL_LINK
, dst
))) {
262 if (!(acl
= hci_conn_add(hdev
, ACL_LINK
, dst
)))
268 if (acl
->state
== BT_OPEN
|| acl
->state
== BT_CLOSED
)
269 hci_acl_connect(acl
);
271 if (type
== SCO_LINK
) {
272 struct hci_conn
*sco
;
274 if (!(sco
= hci_conn_hash_lookup_ba(hdev
, SCO_LINK
, dst
))) {
275 if (!(sco
= hci_conn_add(hdev
, SCO_LINK
, dst
))) {
285 if (acl
->state
== BT_CONNECTED
&&
286 (sco
->state
== BT_OPEN
|| sco
->state
== BT_CLOSED
))
287 hci_add_sco(sco
, acl
->handle
);
294 EXPORT_SYMBOL(hci_connect
);
296 /* Authenticate remote device */
297 int hci_conn_auth(struct hci_conn
*conn
)
299 BT_DBG("conn %p", conn
);
301 if (conn
->link_mode
& HCI_LM_AUTH
)
304 if (!test_and_set_bit(HCI_CONN_AUTH_PEND
, &conn
->pend
)) {
305 struct hci_cp_auth_requested cp
;
306 cp
.handle
= __cpu_to_le16(conn
->handle
);
307 hci_send_cmd(conn
->hdev
, OGF_LINK_CTL
, OCF_AUTH_REQUESTED
, sizeof(cp
), &cp
);
311 EXPORT_SYMBOL(hci_conn_auth
);
313 /* Enable encryption */
314 int hci_conn_encrypt(struct hci_conn
*conn
)
316 BT_DBG("conn %p", conn
);
318 if (conn
->link_mode
& HCI_LM_ENCRYPT
)
321 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND
, &conn
->pend
))
324 if (hci_conn_auth(conn
)) {
325 struct hci_cp_set_conn_encrypt cp
;
326 cp
.handle
= __cpu_to_le16(conn
->handle
);
328 hci_send_cmd(conn
->hdev
, OGF_LINK_CTL
, OCF_SET_CONN_ENCRYPT
, sizeof(cp
), &cp
);
332 EXPORT_SYMBOL(hci_conn_encrypt
);
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(void __user
*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
, 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(arg
, cl
, size
);
407 return err
? -EFAULT
: 0;
410 int hci_get_conn_info(struct hci_dev
*hdev
, void __user
*arg
)
412 struct hci_conn_info_req req
;
413 struct hci_conn_info ci
;
414 struct hci_conn
*conn
;
415 char __user
*ptr
= arg
+ sizeof(req
);
417 if (copy_from_user(&req
, 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;