blob: 375f4b4f7f79a25c328523227ba17679b8b29092 [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
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;
10
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
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI connection handling. */
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/errno.h>
31#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#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>
39#include <net/sock.h>
40
41#include <asm/system.h>
42#include <asm/uaccess.h>
43#include <asm/unaligned.h>
44
45#include <net/bluetooth/bluetooth.h>
46#include <net/bluetooth/hci_core.h>
47
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020048void hci_acl_connect(struct hci_conn *conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049{
50 struct hci_dev *hdev = conn->hdev;
51 struct inquiry_entry *ie;
52 struct hci_cp_create_conn cp;
53
54 BT_DBG("%p", conn);
55
56 conn->state = BT_CONNECT;
Marcel Holtmanna8746412008-07-14 20:13:46 +020057 conn->out = 1;
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 conn->link_mode = HCI_LM_MASTER;
60
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020061 conn->attempt++;
62
Marcel Holtmanne4e8e372008-07-14 20:13:47 +020063 conn->link_policy = hdev->link_policy;
64
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 memset(&cp, 0, sizeof(cp));
66 bacpy(&cp.bdaddr, &conn->dst);
67 cp.pscan_rep_mode = 0x02;
68
Marcel Holtmann41a96212008-07-14 20:13:48 +020069 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
70 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
71 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
72 cp.pscan_mode = ie->data.pscan_mode;
73 cp.clock_offset = ie->data.clock_offset |
74 cpu_to_le16(0x8000);
75 }
76
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 memcpy(conn->dev_class, ie->data.dev_class, 3);
Marcel Holtmann41a96212008-07-14 20:13:48 +020078 conn->ssp_mode = ie->data.ssp_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 }
80
Marcel Holtmanna8746412008-07-14 20:13:46 +020081 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +020083 cp.role_switch = 0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 else
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +020085 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020086
Marcel Holtmanna9de9242007-10-20 13:33:56 +020087 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088}
89
Marcel Holtmann6ac59342006-09-26 09:43:48 +020090static void hci_acl_connect_cancel(struct hci_conn *conn)
91{
92 struct hci_cp_create_conn_cancel cp;
93
94 BT_DBG("%p", conn);
95
96 if (conn->hdev->hci_ver < 2)
97 return;
98
99 bacpy(&cp.bdaddr, &conn->dst);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200100 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200101}
102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
104{
105 struct hci_cp_disconnect cp;
106
107 BT_DBG("%p", conn);
108
109 conn->state = BT_DISCONN;
110
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700111 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 cp.reason = reason;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200113 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
116void hci_add_sco(struct hci_conn *conn, __u16 handle)
117{
118 struct hci_dev *hdev = conn->hdev;
119 struct hci_cp_add_sco cp;
120
121 BT_DBG("%p", conn);
122
123 conn->state = BT_CONNECT;
124 conn->out = 1;
125
Marcel Holtmannefc76882009-02-06 09:13:37 +0100126 conn->attempt++;
127
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700128 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200129 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200131 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132}
133
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200134void hci_setup_sync(struct hci_conn *conn, __u16 handle)
135{
136 struct hci_dev *hdev = conn->hdev;
137 struct hci_cp_setup_sync_conn cp;
138
139 BT_DBG("%p", conn);
140
141 conn->state = BT_CONNECT;
142 conn->out = 1;
143
Marcel Holtmannefc76882009-02-06 09:13:37 +0100144 conn->attempt++;
145
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200146 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200147 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200148
149 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
150 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
151 cp.max_latency = cpu_to_le16(0xffff);
152 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
153 cp.retrans_effort = 0xff;
154
155 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
156}
157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158static void hci_conn_timeout(unsigned long arg)
159{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200160 struct hci_conn *conn = (void *) arg;
161 struct hci_dev *hdev = conn->hdev;
Marcel Holtmann2950f212009-02-12 14:02:50 +0100162 __u8 reason;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
164 BT_DBG("conn %p state %d", conn, conn->state);
165
166 if (atomic_read(&conn->refcnt))
167 return;
168
169 hci_dev_lock(hdev);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200170
171 switch (conn->state) {
172 case BT_CONNECT:
Marcel Holtmann769be972008-07-14 20:13:49 +0200173 case BT_CONNECT2:
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200174 if (conn->type == ACL_LINK)
175 hci_acl_connect_cancel(conn);
176 else
177 hci_acl_disconn(conn, 0x13);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200178 break;
Marcel Holtmann769be972008-07-14 20:13:49 +0200179 case BT_CONFIG:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900180 case BT_CONNECTED:
Marcel Holtmann2950f212009-02-12 14:02:50 +0100181 reason = hci_proto_disconn_ind(conn);
182 hci_acl_disconn(conn, reason);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200183 break;
184 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 conn->state = BT_CLOSED;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200186 break;
187 }
188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190}
191
Marcel Holtmann04837f62006-07-03 10:02:33 +0200192static void hci_conn_idle(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200194 struct hci_conn *conn = (void *) arg;
195
196 BT_DBG("conn %p mode %d", conn, conn->mode);
197
198 hci_conn_enter_sniff_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199}
200
201struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
202{
203 struct hci_conn *conn;
204
205 BT_DBG("%s dst %s", hdev->name, batostr(dst));
206
Marcel Holtmann04837f62006-07-03 10:02:33 +0200207 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
208 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 bacpy(&conn->dst, dst);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200212 conn->hdev = hdev;
213 conn->type = type;
214 conn->mode = HCI_CM_ACTIVE;
215 conn->state = BT_OPEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
Marcel Holtmann04837f62006-07-03 10:02:33 +0200217 conn->power_save = 1;
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200218 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200219
Marcel Holtmanna8746412008-07-14 20:13:46 +0200220 switch (type) {
221 case ACL_LINK:
222 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
223 break;
224 case SCO_LINK:
225 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100226 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
227 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200228 else
229 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
230 break;
231 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100232 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200233 break;
234 }
235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200237
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800238 setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
239 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 atomic_set(&conn->refcnt, 0);
242
243 hci_dev_hold(hdev);
244
245 tasklet_disable(&hdev->tx_task);
246
247 hci_conn_hash_add(hdev, conn);
248 if (hdev->notify)
249 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
250
251 tasklet_enable(&hdev->tx_task);
252
253 return conn;
254}
255
256int hci_conn_del(struct hci_conn *conn)
257{
258 struct hci_dev *hdev = conn->hdev;
259
260 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
261
Marcel Holtmann04837f62006-07-03 10:02:33 +0200262 del_timer(&conn->idle_timer);
263
264 del_timer(&conn->disc_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200266 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 struct hci_conn *sco = conn->link;
268 if (sco)
269 sco->link = NULL;
270
271 /* Unacked frames */
272 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200273 } else {
274 struct hci_conn *acl = conn->link;
275 if (acl) {
276 acl->link = NULL;
277 hci_conn_put(acl);
278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280
281 tasklet_disable(&hdev->tx_task);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 hci_conn_hash_del(hdev, conn);
284 if (hdev->notify)
285 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 tasklet_enable(&hdev->tx_task);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Dave Young2ae9a6b2009-02-21 16:13:34 +0800291 hci_conn_del_sysfs(conn);
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 return 0;
294}
295
296struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
297{
298 int use_src = bacmp(src, BDADDR_ANY);
299 struct hci_dev *hdev = NULL;
300 struct list_head *p;
301
302 BT_DBG("%s -> %s", batostr(src), batostr(dst));
303
304 read_lock_bh(&hci_dev_list_lock);
305
306 list_for_each(p, &hci_dev_list) {
307 struct hci_dev *d = list_entry(p, struct hci_dev, list);
308
309 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
310 continue;
311
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900312 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 * No source address - find interface with bdaddr != dst
314 * Source address - find interface with bdaddr == src
315 */
316
317 if (use_src) {
318 if (!bacmp(&d->bdaddr, src)) {
319 hdev = d; break;
320 }
321 } else {
322 if (bacmp(&d->bdaddr, dst)) {
323 hdev = d; break;
324 }
325 }
326 }
327
328 if (hdev)
329 hdev = hci_dev_hold(hdev);
330
331 read_unlock_bh(&hci_dev_list_lock);
332 return hdev;
333}
334EXPORT_SYMBOL(hci_get_route);
335
336/* Create SCO or ACL connection.
337 * Device _must_ be locked */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100338struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
340 struct hci_conn *acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200341 struct hci_conn *sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
343 BT_DBG("%s dst %s", hdev->name, batostr(dst));
344
345 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
346 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
347 return NULL;
348 }
349
350 hci_conn_hold(acl);
351
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200352 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100353 acl->sec_level = sec_level;
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200354 acl->auth_type = auth_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 hci_acl_connect(acl);
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200356 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200358 if (type == ACL_LINK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 return acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200360
361 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
362 if (!(sco = hci_conn_add(hdev, type, dst))) {
363 hci_conn_put(acl);
364 return NULL;
365 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200367
368 acl->link = sco;
369 sco->link = acl;
370
371 hci_conn_hold(sco);
372
373 if (acl->state == BT_CONNECTED &&
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200374 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
375 if (lmp_esco_capable(hdev))
376 hci_setup_sync(sco, acl->handle);
377 else
378 hci_add_sco(sco, acl->handle);
379 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200380
381 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383EXPORT_SYMBOL(hci_connect);
384
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200385/* Check link security requirement */
386int hci_conn_check_link_mode(struct hci_conn *conn)
387{
388 BT_DBG("conn %p", conn);
389
390 if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
391 !(conn->link_mode & HCI_LM_ENCRYPT))
392 return 0;
393
394 return 1;
395}
396EXPORT_SYMBOL(hci_conn_check_link_mode);
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398/* Authenticate remote device */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100399static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
401 BT_DBG("conn %p", conn);
402
Marcel Holtmann96a31832009-02-12 16:23:03 +0100403 if (sec_level > conn->sec_level)
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100404 conn->sec_level = sec_level;
Marcel Holtmann96a31832009-02-12 16:23:03 +0100405 else if (conn->link_mode & HCI_LM_AUTH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return 1;
407
Marcel Holtmann96a31832009-02-12 16:23:03 +0100408 conn->auth_type = auth_type;
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
411 struct hci_cp_auth_requested cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700412 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200413 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
414 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return 0;
418}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100420/* Enable security */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100421int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
423 BT_DBG("conn %p", conn);
424
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100425 if (sec_level == BT_SECURITY_SDP)
426 return 1;
427
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -0700428 if (sec_level == BT_SECURITY_LOW &&
429 (!conn->ssp_mode || !conn->hdev->ssp_mode))
430 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 if (conn->link_mode & HCI_LM_ENCRYPT)
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100433 return hci_conn_auth(conn, sec_level, auth_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
436 return 0;
437
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100438 if (hci_conn_auth(conn, sec_level, auth_type)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 struct hci_cp_set_conn_encrypt cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700440 cp.handle = cpu_to_le16(conn->handle);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900441 cp.encrypt = 1;
Marcel Holtmann40be4922008-07-14 20:13:50 +0200442 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT,
443 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100445
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 return 0;
447}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100448EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
450/* Change link key */
451int hci_conn_change_link_key(struct hci_conn *conn)
452{
453 BT_DBG("conn %p", conn);
454
455 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
456 struct hci_cp_change_conn_link_key cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700457 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200458 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
459 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 return 0;
463}
464EXPORT_SYMBOL(hci_conn_change_link_key);
465
466/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100467int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468{
469 BT_DBG("conn %p", conn);
470
471 if (!role && conn->link_mode & HCI_LM_MASTER)
472 return 1;
473
474 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
475 struct hci_cp_switch_role cp;
476 bacpy(&cp.bdaddr, &conn->dst);
477 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200478 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 return 0;
482}
483EXPORT_SYMBOL(hci_conn_switch_role);
484
Marcel Holtmann04837f62006-07-03 10:02:33 +0200485/* Enter active mode */
486void hci_conn_enter_active_mode(struct hci_conn *conn)
487{
488 struct hci_dev *hdev = conn->hdev;
489
490 BT_DBG("conn %p mode %d", conn, conn->mode);
491
492 if (test_bit(HCI_RAW, &hdev->flags))
493 return;
494
495 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
496 goto timer;
497
498 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
499 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700500 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200501 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200502 }
503
504timer:
505 if (hdev->idle_timeout > 0)
506 mod_timer(&conn->idle_timer,
507 jiffies + msecs_to_jiffies(hdev->idle_timeout));
508}
509
510/* Enter sniff mode */
511void hci_conn_enter_sniff_mode(struct hci_conn *conn)
512{
513 struct hci_dev *hdev = conn->hdev;
514
515 BT_DBG("conn %p mode %d", conn, conn->mode);
516
517 if (test_bit(HCI_RAW, &hdev->flags))
518 return;
519
520 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
521 return;
522
523 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
524 return;
525
526 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
527 struct hci_cp_sniff_subrate cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700528 cp.handle = cpu_to_le16(conn->handle);
529 cp.max_latency = cpu_to_le16(0);
530 cp.min_remote_timeout = cpu_to_le16(0);
531 cp.min_local_timeout = cpu_to_le16(0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200532 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200533 }
534
535 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
536 struct hci_cp_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700537 cp.handle = cpu_to_le16(conn->handle);
538 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
539 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
540 cp.attempt = cpu_to_le16(4);
541 cp.timeout = cpu_to_le16(1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200542 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200543 }
544}
545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546/* Drop all connection on the device */
547void hci_conn_hash_flush(struct hci_dev *hdev)
548{
549 struct hci_conn_hash *h = &hdev->conn_hash;
550 struct list_head *p;
551
552 BT_DBG("hdev %s", hdev->name);
553
554 p = h->list.next;
555 while (p != &h->list) {
556 struct hci_conn *c;
557
558 c = list_entry(p, struct hci_conn, list);
559 p = p->next;
560
561 c->state = BT_CLOSED;
562
Marcel Holtmann2950f212009-02-12 14:02:50 +0100563 hci_proto_disconn_cfm(c, 0x16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 hci_conn_del(c);
565 }
566}
567
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200568/* Check pending connect attempts */
569void hci_conn_check_pending(struct hci_dev *hdev)
570{
571 struct hci_conn *conn;
572
573 BT_DBG("hdev %s", hdev->name);
574
575 hci_dev_lock(hdev);
576
577 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
578 if (conn)
579 hci_acl_connect(conn);
580
581 hci_dev_unlock(hdev);
582}
583
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584int hci_get_conn_list(void __user *arg)
585{
586 struct hci_conn_list_req req, *cl;
587 struct hci_conn_info *ci;
588 struct hci_dev *hdev;
589 struct list_head *p;
590 int n = 0, size, err;
591
592 if (copy_from_user(&req, arg, sizeof(req)))
593 return -EFAULT;
594
595 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
596 return -EINVAL;
597
598 size = sizeof(req) + req.conn_num * sizeof(*ci);
599
Jesper Juhl12fe2c52006-01-10 13:08:21 -0800600 if (!(cl = kmalloc(size, GFP_KERNEL)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return -ENOMEM;
602
603 if (!(hdev = hci_dev_get(req.dev_id))) {
604 kfree(cl);
605 return -ENODEV;
606 }
607
608 ci = cl->conn_info;
609
610 hci_dev_lock_bh(hdev);
611 list_for_each(p, &hdev->conn_hash.list) {
612 register struct hci_conn *c;
613 c = list_entry(p, struct hci_conn, list);
614
615 bacpy(&(ci + n)->bdaddr, &c->dst);
616 (ci + n)->handle = c->handle;
617 (ci + n)->type = c->type;
618 (ci + n)->out = c->out;
619 (ci + n)->state = c->state;
620 (ci + n)->link_mode = c->link_mode;
621 if (++n >= req.conn_num)
622 break;
623 }
624 hci_dev_unlock_bh(hdev);
625
626 cl->dev_id = hdev->id;
627 cl->conn_num = n;
628 size = sizeof(req) + n * sizeof(*ci);
629
630 hci_dev_put(hdev);
631
632 err = copy_to_user(arg, cl, size);
633 kfree(cl);
634
635 return err ? -EFAULT : 0;
636}
637
638int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
639{
640 struct hci_conn_info_req req;
641 struct hci_conn_info ci;
642 struct hci_conn *conn;
643 char __user *ptr = arg + sizeof(req);
644
645 if (copy_from_user(&req, arg, sizeof(req)))
646 return -EFAULT;
647
648 hci_dev_lock_bh(hdev);
649 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
650 if (conn) {
651 bacpy(&ci.bdaddr, &conn->dst);
652 ci.handle = conn->handle;
653 ci.type = conn->type;
654 ci.out = conn->out;
655 ci.state = conn->state;
656 ci.link_mode = conn->link_mode;
657 }
658 hci_dev_unlock_bh(hdev);
659
660 if (!conn)
661 return -ENOENT;
662
663 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
664}
Marcel Holtmann40be4922008-07-14 20:13:50 +0200665
666int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
667{
668 struct hci_auth_info_req req;
669 struct hci_conn *conn;
670
671 if (copy_from_user(&req, arg, sizeof(req)))
672 return -EFAULT;
673
674 hci_dev_lock_bh(hdev);
675 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
676 if (conn)
677 req.type = conn->auth_type;
678 hci_dev_unlock_bh(hdev);
679
680 if (!conn)
681 return -ENOENT;
682
683 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
684}