]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - net/bluetooth/hci_conn.c
Bluetooth: Remove unneeded parameter
[mirror_ubuntu-zesty-kernel.git] / net / bluetooth / hci_conn.c
CommitLineData
8e87d142 1/*
1da177e4 2 BlueZ - Bluetooth protocol stack for Linux
2d0a0346 3 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
1da177e4
LT
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
8e87d142
YH
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
1da177e4
LT
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
8e87d142
YH
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4
LT
22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI connection handling. */
26
8c520a59 27#include <linux/export.h>
1da177e4
LT
28
29#include <net/bluetooth/bluetooth.h>
30#include <net/bluetooth/hci_core.h>
9740e49d 31#include <net/bluetooth/a2mp.h>
d8343f12 32#include <net/bluetooth/smp.h>
1da177e4 33
1aef8669 34static void hci_le_create_connection(struct hci_conn *conn)
fcd89c09
VT
35{
36 struct hci_dev *hdev = conn->hdev;
37 struct hci_cp_le_create_conn cp;
38
39 conn->state = BT_CONNECT;
a0c808b3 40 conn->out = true;
b92a6223 41 conn->link_mode |= HCI_LM_MASTER;
7b5c0d52 42 conn->sec_level = BT_SECURITY_LOW;
fcd89c09
VT
43
44 memset(&cp, 0, sizeof(cp));
82781e63
AE
45 cp.scan_interval = __constant_cpu_to_le16(0x0060);
46 cp.scan_window = __constant_cpu_to_le16(0x0030);
fcd89c09 47 bacpy(&cp.peer_addr, &conn->dst);
6d3ce0e7 48 cp.peer_addr_type = conn->dst_type;
82781e63
AE
49 cp.conn_interval_min = __constant_cpu_to_le16(0x0028);
50 cp.conn_interval_max = __constant_cpu_to_le16(0x0038);
51 cp.supervision_timeout = __constant_cpu_to_le16(0x002a);
52 cp.min_ce_len = __constant_cpu_to_le16(0x0000);
53 cp.max_ce_len = __constant_cpu_to_le16(0x0000);
fcd89c09
VT
54
55 hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
56}
57
1aef8669 58static void hci_le_create_connection_cancel(struct hci_conn *conn)
fcd89c09
VT
59{
60 hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
61}
62
1aef8669 63static void hci_acl_create_connection(struct hci_conn *conn)
1da177e4
LT
64{
65 struct hci_dev *hdev = conn->hdev;
66 struct inquiry_entry *ie;
67 struct hci_cp_create_conn cp;
68
42d2d87c 69 BT_DBG("hcon %p", conn);
1da177e4
LT
70
71 conn->state = BT_CONNECT;
a0c808b3 72 conn->out = true;
a8746417 73
1da177e4
LT
74 conn->link_mode = HCI_LM_MASTER;
75
4c67bc74
MH
76 conn->attempt++;
77
e4e8e37c
MH
78 conn->link_policy = hdev->link_policy;
79
1da177e4
LT
80 memset(&cp, 0, sizeof(cp));
81 bacpy(&cp.bdaddr, &conn->dst);
82 cp.pscan_rep_mode = 0x02;
83
70f23020
AE
84 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
85 if (ie) {
41a96212
MH
86 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
87 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
88 cp.pscan_mode = ie->data.pscan_mode;
89 cp.clock_offset = ie->data.clock_offset |
82781e63 90 __constant_cpu_to_le16(0x8000);
41a96212
MH
91 }
92
1da177e4 93 memcpy(conn->dev_class, ie->data.dev_class, 3);
58a681ef
JH
94 if (ie->data.ssp_mode > 0)
95 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
1da177e4
LT
96 }
97
a8746417 98 cp.pkt_type = cpu_to_le16(conn->pkt_type);
1da177e4 99 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
b6a0dc82 100 cp.role_switch = 0x01;
1da177e4 101 else
b6a0dc82 102 cp.role_switch = 0x00;
4c67bc74 103
a9de9248 104 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
1da177e4
LT
105}
106
1aef8669 107static void hci_acl_create_connection_cancel(struct hci_conn *conn)
6ac59344
MH
108{
109 struct hci_cp_create_conn_cancel cp;
110
38b3fef1 111 BT_DBG("hcon %p", conn);
6ac59344 112
d095c1eb 113 if (conn->hdev->hci_ver < BLUETOOTH_VER_1_2)
6ac59344
MH
114 return;
115
116 bacpy(&cp.bdaddr, &conn->dst);
a9de9248 117 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
6ac59344
MH
118}
119
bed71748 120void hci_disconnect(struct hci_conn *conn, __u8 reason)
1da177e4
LT
121{
122 struct hci_cp_disconnect cp;
123
38b3fef1 124 BT_DBG("hcon %p", conn);
1da177e4
LT
125
126 conn->state = BT_DISCONN;
127
aca3192c 128 cp.handle = cpu_to_le16(conn->handle);
1da177e4 129 cp.reason = reason;
a9de9248 130 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
1da177e4
LT
131}
132
53502d69
AE
133static void hci_amp_disconn(struct hci_conn *conn, __u8 reason)
134{
135 struct hci_cp_disconn_phy_link cp;
136
137 BT_DBG("hcon %p", conn);
138
139 conn->state = BT_DISCONN;
140
141 cp.phy_handle = HCI_PHY_HANDLE(conn->handle);
142 cp.reason = reason;
143 hci_send_cmd(conn->hdev, HCI_OP_DISCONN_PHY_LINK,
144 sizeof(cp), &cp);
145}
146
57f5d0d1 147static void hci_add_sco(struct hci_conn *conn, __u16 handle)
1da177e4
LT
148{
149 struct hci_dev *hdev = conn->hdev;
150 struct hci_cp_add_sco cp;
151
38b3fef1 152 BT_DBG("hcon %p", conn);
1da177e4
LT
153
154 conn->state = BT_CONNECT;
a0c808b3 155 conn->out = true;
1da177e4 156
efc7688b
MH
157 conn->attempt++;
158
aca3192c 159 cp.handle = cpu_to_le16(handle);
a8746417 160 cp.pkt_type = cpu_to_le16(conn->pkt_type);
1da177e4 161
a9de9248 162 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
1da177e4
LT
163}
164
b6a0dc82
MH
165void hci_setup_sync(struct hci_conn *conn, __u16 handle)
166{
167 struct hci_dev *hdev = conn->hdev;
168 struct hci_cp_setup_sync_conn cp;
169
38b3fef1 170 BT_DBG("hcon %p", conn);
b6a0dc82
MH
171
172 conn->state = BT_CONNECT;
a0c808b3 173 conn->out = true;
b6a0dc82 174
efc7688b
MH
175 conn->attempt++;
176
b6a0dc82 177 cp.handle = cpu_to_le16(handle);
a8746417 178 cp.pkt_type = cpu_to_le16(conn->pkt_type);
b6a0dc82 179
82781e63
AE
180 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
181 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
182 cp.max_latency = __constant_cpu_to_le16(0xffff);
b6a0dc82
MH
183 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
184 cp.retrans_effort = 0xff;
185
186 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
187}
188
2ce603eb 189void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
5974e4c4 190 u16 latency, u16 to_multiplier)
2ce603eb
CT
191{
192 struct hci_cp_le_conn_update cp;
193 struct hci_dev *hdev = conn->hdev;
194
195 memset(&cp, 0, sizeof(cp));
196
197 cp.handle = cpu_to_le16(conn->handle);
198 cp.conn_interval_min = cpu_to_le16(min);
199 cp.conn_interval_max = cpu_to_le16(max);
200 cp.conn_latency = cpu_to_le16(latency);
201 cp.supervision_timeout = cpu_to_le16(to_multiplier);
82781e63
AE
202 cp.min_ce_len = __constant_cpu_to_le16(0x0001);
203 cp.max_ce_len = __constant_cpu_to_le16(0x0001);
2ce603eb
CT
204
205 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
206}
2ce603eb 207
a7a595f6 208void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
5974e4c4 209 __u8 ltk[16])
a7a595f6
VCG
210{
211 struct hci_dev *hdev = conn->hdev;
212 struct hci_cp_le_start_enc cp;
213
38b3fef1 214 BT_DBG("hcon %p", conn);
a7a595f6
VCG
215
216 memset(&cp, 0, sizeof(cp));
217
218 cp.handle = cpu_to_le16(conn->handle);
219 memcpy(cp.ltk, ltk, sizeof(cp.ltk));
220 cp.ediv = ediv;
51beabdf 221 memcpy(cp.rand, rand, sizeof(cp.rand));
a7a595f6
VCG
222
223 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
224}
a7a595f6 225
e73439d8
MH
226/* Device _must_ be locked */
227void hci_sco_setup(struct hci_conn *conn, __u8 status)
228{
229 struct hci_conn *sco = conn->link;
230
e73439d8
MH
231 if (!sco)
232 return;
233
38b3fef1
AE
234 BT_DBG("hcon %p", conn);
235
e73439d8
MH
236 if (!status) {
237 if (lmp_esco_capable(conn->hdev))
238 hci_setup_sync(sco, conn->handle);
239 else
240 hci_add_sco(sco, conn->handle);
241 } else {
242 hci_proto_connect_cfm(sco, status);
243 hci_conn_del(sco);
244 }
245}
246
53502d69
AE
247static void hci_conn_disconnect(struct hci_conn *conn)
248{
249 __u8 reason = hci_proto_disconn_ind(conn);
250
251 switch (conn->type) {
53502d69
AE
252 case AMP_LINK:
253 hci_amp_disconn(conn, reason);
254 break;
4c02e2d4 255 default:
bed71748 256 hci_disconnect(conn, reason);
4c02e2d4 257 break;
53502d69
AE
258 }
259}
260
19c40e3b 261static void hci_conn_timeout(struct work_struct *work)
1da177e4 262{
19c40e3b 263 struct hci_conn *conn = container_of(work, struct hci_conn,
5974e4c4 264 disc_work.work);
1da177e4 265
38b3fef1 266 BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
1da177e4
LT
267
268 if (atomic_read(&conn->refcnt))
269 return;
270
6ac59344
MH
271 switch (conn->state) {
272 case BT_CONNECT:
769be974 273 case BT_CONNECT2:
fcd89c09
VT
274 if (conn->out) {
275 if (conn->type == ACL_LINK)
1aef8669 276 hci_acl_create_connection_cancel(conn);
fcd89c09 277 else if (conn->type == LE_LINK)
1aef8669 278 hci_le_create_connection_cancel(conn);
fcd89c09 279 }
6ac59344 280 break;
769be974 281 case BT_CONFIG:
8e87d142 282 case BT_CONNECTED:
53502d69 283 hci_conn_disconnect(conn);
6ac59344
MH
284 break;
285 default:
1da177e4 286 conn->state = BT_CLOSED;
6ac59344
MH
287 break;
288 }
1da177e4
LT
289}
290
416dc94b
GP
291/* Enter sniff mode */
292static void hci_conn_enter_sniff_mode(struct hci_conn *conn)
293{
294 struct hci_dev *hdev = conn->hdev;
295
38b3fef1 296 BT_DBG("hcon %p mode %d", conn, conn->mode);
416dc94b
GP
297
298 if (test_bit(HCI_RAW, &hdev->flags))
299 return;
300
301 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
302 return;
303
304 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
305 return;
306
307 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
308 struct hci_cp_sniff_subrate cp;
309 cp.handle = cpu_to_le16(conn->handle);
82781e63
AE
310 cp.max_latency = __constant_cpu_to_le16(0);
311 cp.min_remote_timeout = __constant_cpu_to_le16(0);
312 cp.min_local_timeout = __constant_cpu_to_le16(0);
416dc94b
GP
313 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
314 }
315
51a8efd7 316 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
416dc94b
GP
317 struct hci_cp_sniff_mode cp;
318 cp.handle = cpu_to_le16(conn->handle);
319 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
320 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
82781e63
AE
321 cp.attempt = __constant_cpu_to_le16(4);
322 cp.timeout = __constant_cpu_to_le16(1);
416dc94b
GP
323 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
324 }
325}
326
04837f64 327static void hci_conn_idle(unsigned long arg)
1da177e4 328{
04837f64
MH
329 struct hci_conn *conn = (void *) arg;
330
38b3fef1 331 BT_DBG("hcon %p mode %d", conn, conn->mode);
04837f64
MH
332
333 hci_conn_enter_sniff_mode(conn);
1da177e4
LT
334}
335
9f61656a
JH
336static void hci_conn_auto_accept(unsigned long arg)
337{
338 struct hci_conn *conn = (void *) arg;
339 struct hci_dev *hdev = conn->hdev;
340
9f61656a 341 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
5974e4c4 342 &conn->dst);
9f61656a
JH
343}
344
1da177e4
LT
345struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
346{
347 struct hci_conn *conn;
348
6ed93dc6 349 BT_DBG("%s dst %pMR", hdev->name, dst);
1da177e4 350
cb601d7e 351 conn = kzalloc(sizeof(struct hci_conn), GFP_KERNEL);
04837f64 352 if (!conn)
1da177e4 353 return NULL;
1da177e4
LT
354
355 bacpy(&conn->dst, dst);
a8746417
MH
356 conn->hdev = hdev;
357 conn->type = type;
358 conn->mode = HCI_CM_ACTIVE;
359 conn->state = BT_OPEN;
93f19c9f 360 conn->auth_type = HCI_AT_GENERAL_BONDING;
17fa4b9d 361 conn->io_capability = hdev->io_capability;
a9583556 362 conn->remote_auth = 0xff;
13d39315 363 conn->key_type = 0xff;
1da177e4 364
58a681ef 365 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
052b30b0 366 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
04837f64 367
a8746417
MH
368 switch (type) {
369 case ACL_LINK:
370 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
371 break;
372 case SCO_LINK:
373 if (lmp_esco_capable(hdev))
efc7688b
MH
374 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
375 (hdev->esco_type & EDR_ESCO_MASK);
a8746417
MH
376 else
377 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
378 break;
379 case ESCO_LINK:
efc7688b 380 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
a8746417
MH
381 break;
382 }
383
1da177e4 384 skb_queue_head_init(&conn->data_q);
04837f64 385
70c1f20b 386 INIT_LIST_HEAD(&conn->chan_list);
73d80deb 387
19c40e3b 388 INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
b24b8a24 389 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
9f61656a 390 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
5974e4c4 391 (unsigned long) conn);
1da177e4
LT
392
393 atomic_set(&conn->refcnt, 0);
394
395 hci_dev_hold(hdev);
396
1da177e4 397 hci_conn_hash_add(hdev, conn);
3c54711c 398 if (hdev->notify)
1da177e4
LT
399 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
400
9eba32b8
MH
401 atomic_set(&conn->devref, 0);
402
a67e899c
MH
403 hci_conn_init_sysfs(conn);
404
1da177e4
LT
405 return conn;
406}
407
408int hci_conn_del(struct hci_conn *conn)
409{
410 struct hci_dev *hdev = conn->hdev;
411
38b3fef1 412 BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
1da177e4 413
04837f64
MH
414 del_timer(&conn->idle_timer);
415
19c40e3b 416 cancel_delayed_work_sync(&conn->disc_work);
1da177e4 417
9f61656a
JH
418 del_timer(&conn->auto_accept_timer);
419
5b7f9909 420 if (conn->type == ACL_LINK) {
1da177e4
LT
421 struct hci_conn *sco = conn->link;
422 if (sco)
423 sco->link = NULL;
424
425 /* Unacked frames */
426 hdev->acl_cnt += conn->sent;
6ed58ec5
VT
427 } else if (conn->type == LE_LINK) {
428 if (hdev->le_pkts)
429 hdev->le_cnt += conn->sent;
430 else
431 hdev->acl_cnt += conn->sent;
5b7f9909
MH
432 } else {
433 struct hci_conn *acl = conn->link;
434 if (acl) {
435 acl->link = NULL;
76a68ba0 436 hci_conn_drop(acl);
5b7f9909 437 }
1da177e4
LT
438 }
439
2c33c06a 440 hci_chan_list_flush(conn);
73d80deb 441
9740e49d
AE
442 if (conn->amp_mgr)
443 amp_mgr_put(conn->amp_mgr);
444
1da177e4 445 hci_conn_hash_del(hdev, conn);
3c54711c 446 if (hdev->notify)
1da177e4 447 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
7d0db0a3 448
1da177e4 449 skb_queue_purge(&conn->data_q);
1da177e4 450
9eba32b8 451 hci_conn_put_device(conn);
2ae9a6be 452
384943ec
MH
453 hci_dev_put(hdev);
454
163f4dab
TT
455 if (conn->handle == 0)
456 kfree(conn);
457
1da177e4
LT
458 return 0;
459}
460
461struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
462{
463 int use_src = bacmp(src, BDADDR_ANY);
8035ded4 464 struct hci_dev *hdev = NULL, *d;
1da177e4 465
6ed93dc6 466 BT_DBG("%pMR -> %pMR", src, dst);
1da177e4 467
f20d09d5 468 read_lock(&hci_dev_list_lock);
1da177e4 469
8035ded4 470 list_for_each_entry(d, &hci_dev_list, list) {
8fc9ced3 471 if (!test_bit(HCI_UP, &d->flags) ||
d300fa9b
AE
472 test_bit(HCI_RAW, &d->flags) ||
473 d->dev_type != HCI_BREDR)
1da177e4
LT
474 continue;
475
8e87d142 476 /* Simple routing:
1da177e4
LT
477 * No source address - find interface with bdaddr != dst
478 * Source address - find interface with bdaddr == src
479 */
480
481 if (use_src) {
482 if (!bacmp(&d->bdaddr, src)) {
483 hdev = d; break;
484 }
485 } else {
486 if (bacmp(&d->bdaddr, dst)) {
487 hdev = d; break;
488 }
489 }
490 }
491
492 if (hdev)
493 hdev = hci_dev_hold(hdev);
494
f20d09d5 495 read_unlock(&hci_dev_list_lock);
1da177e4
LT
496 return hdev;
497}
498EXPORT_SYMBOL(hci_get_route);
499
d04aef4c
VCG
500static struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
501 u8 dst_type, u8 sec_level, u8 auth_type)
1da177e4 502{
fcd89c09 503 struct hci_conn *le;
1da177e4 504
f1550478
JH
505 if (test_bit(HCI_LE_PERIPHERAL, &hdev->flags))
506 return ERR_PTR(-ENOTSUPP);
507
d04aef4c
VCG
508 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
509 if (!le) {
510 le = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
511 if (le)
512 return ERR_PTR(-EBUSY);
1da177e4 513
d04aef4c
VCG
514 le = hci_conn_add(hdev, LE_LINK, dst);
515 if (!le)
516 return ERR_PTR(-ENOMEM);
dfc94dbd 517
d04aef4c
VCG
518 le->dst_type = bdaddr_to_le(dst_type);
519 hci_le_create_connection(le);
520 }
9f0caeb1 521
d04aef4c
VCG
522 le->pending_sec_level = sec_level;
523 le->auth_type = auth_type;
eda42b50 524
d04aef4c 525 hci_conn_hold(le);
fcd89c09 526
d04aef4c
VCG
527 return le;
528}
fcd89c09 529
db474275
VCG
530static struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
531 u8 sec_level, u8 auth_type)
1da177e4
LT
532{
533 struct hci_conn *acl;
fcd89c09 534
70f23020
AE
535 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
536 if (!acl) {
537 acl = hci_conn_add(hdev, ACL_LINK, dst);
538 if (!acl)
48c7aba9 539 return ERR_PTR(-ENOMEM);
1da177e4
LT
540 }
541
542 hci_conn_hold(acl);
543
09ab6f4c 544 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
765c2a96
JH
545 acl->sec_level = BT_SECURITY_LOW;
546 acl->pending_sec_level = sec_level;
09ab6f4c 547 acl->auth_type = auth_type;
1aef8669 548 hci_acl_create_connection(acl);
09ab6f4c 549 }
1da177e4 550
db474275
VCG
551 return acl;
552}
553
f91c8468
VCG
554static struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type,
555 bdaddr_t *dst, u8 sec_level, u8 auth_type)
db474275
VCG
556{
557 struct hci_conn *acl;
558 struct hci_conn *sco;
559
db474275
VCG
560 acl = hci_connect_acl(hdev, dst, sec_level, auth_type);
561 if (IS_ERR(acl))
5b7f9909 562 return acl;
1da177e4 563
70f23020
AE
564 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
565 if (!sco) {
566 sco = hci_conn_add(hdev, type, dst);
567 if (!sco) {
76a68ba0 568 hci_conn_drop(acl);
48c7aba9 569 return ERR_PTR(-ENOMEM);
1da177e4 570 }
5b7f9909 571 }
1da177e4 572
5b7f9909
MH
573 acl->link = sco;
574 sco->link = acl;
1da177e4 575
5b7f9909 576 hci_conn_hold(sco);
1da177e4 577
5b7f9909 578 if (acl->state == BT_CONNECTED &&
5974e4c4 579 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
58a681ef 580 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
14b12d0b 581 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
c390216b 582
51a8efd7 583 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
e73439d8 584 /* defer SCO setup until mode change completed */
51a8efd7 585 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
e73439d8
MH
586 return sco;
587 }
588
589 hci_sco_setup(acl, 0x00);
b6a0dc82 590 }
5b7f9909
MH
591
592 return sco;
1da177e4 593}
1da177e4 594
b7d839bf
VCG
595/* Create SCO, ACL or LE connection. */
596struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst,
597 __u8 dst_type, __u8 sec_level, __u8 auth_type)
598{
6ed93dc6 599 BT_DBG("%s dst %pMR type 0x%x", hdev->name, dst, type);
b7d839bf 600
4cd2d983
VCG
601 switch (type) {
602 case LE_LINK:
b7d839bf 603 return hci_connect_le(hdev, dst, dst_type, sec_level, auth_type);
4cd2d983 604 case ACL_LINK:
b7d839bf 605 return hci_connect_acl(hdev, dst, sec_level, auth_type);
4cd2d983 606 case SCO_LINK:
f91c8468
VCG
607 case ESCO_LINK:
608 return hci_connect_sco(hdev, type, dst, sec_level, auth_type);
4cd2d983 609 }
b7d839bf 610
4cd2d983 611 return ERR_PTR(-EINVAL);
b7d839bf
VCG
612}
613
e7c29cb1
MH
614/* Check link security requirement */
615int hci_conn_check_link_mode(struct hci_conn *conn)
616{
38b3fef1 617 BT_DBG("hcon %p", conn);
e7c29cb1 618
aa64a8b5 619 if (hci_conn_ssp_enabled(conn) && !(conn->link_mode & HCI_LM_ENCRYPT))
e7c29cb1
MH
620 return 0;
621
622 return 1;
623}
e7c29cb1 624
1da177e4 625/* Authenticate remote device */
0684e5f9 626static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
1da177e4 627{
38b3fef1 628 BT_DBG("hcon %p", conn);
1da177e4 629
765c2a96
JH
630 if (conn->pending_sec_level > sec_level)
631 sec_level = conn->pending_sec_level;
632
96a31833 633 if (sec_level > conn->sec_level)
765c2a96 634 conn->pending_sec_level = sec_level;
96a31833 635 else if (conn->link_mode & HCI_LM_AUTH)
1da177e4
LT
636 return 1;
637
65cf686e
JH
638 /* Make sure we preserve an existing MITM requirement*/
639 auth_type |= (conn->auth_type & 0x01);
640
96a31833
MH
641 conn->auth_type = auth_type;
642
51a8efd7 643 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
1da177e4 644 struct hci_cp_auth_requested cp;
b7d05bad
PH
645
646 /* encrypt must be pending if auth is also pending */
647 set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
648
aca3192c 649 cp.handle = cpu_to_le16(conn->handle);
40be492f 650 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
5974e4c4 651 sizeof(cp), &cp);
19f8def0 652 if (conn->key_type != 0xff)
51a8efd7 653 set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
1da177e4 654 }
8c1b2355 655
1da177e4
LT
656 return 0;
657}
1da177e4 658
13d39315
WR
659/* Encrypt the the link */
660static void hci_conn_encrypt(struct hci_conn *conn)
661{
38b3fef1 662 BT_DBG("hcon %p", conn);
13d39315 663
51a8efd7 664 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
13d39315
WR
665 struct hci_cp_set_conn_encrypt cp;
666 cp.handle = cpu_to_le16(conn->handle);
667 cp.encrypt = 0x01;
668 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
5974e4c4 669 &cp);
13d39315
WR
670 }
671}
672
8c1b2355 673/* Enable security */
0684e5f9 674int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
1da177e4 675{
38b3fef1 676 BT_DBG("hcon %p", conn);
1da177e4 677
d8343f12
VCG
678 if (conn->type == LE_LINK)
679 return smp_conn_security(conn, sec_level);
680
13d39315 681 /* For sdp we don't need the link key. */
8c1b2355
MH
682 if (sec_level == BT_SECURITY_SDP)
683 return 1;
684
13d39315
WR
685 /* For non 2.1 devices and low security level we don't need the link
686 key. */
aa64a8b5 687 if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
3fdca1e1 688 return 1;
8c1b2355 689
13d39315
WR
690 /* For other security levels we need the link key. */
691 if (!(conn->link_mode & HCI_LM_AUTH))
692 goto auth;
693
694 /* An authenticated combination key has sufficient security for any
695 security level. */
696 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
697 goto encrypt;
698
699 /* An unauthenticated combination key has sufficient security for
700 security level 1 and 2. */
701 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
5974e4c4 702 (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW))
13d39315
WR
703 goto encrypt;
704
705 /* A combination key has always sufficient security for the security
706 levels 1 or 2. High security level requires the combination key
707 is generated using maximum PIN code length (16).
708 For pre 2.1 units. */
709 if (conn->key_type == HCI_LK_COMBINATION &&
5974e4c4 710 (sec_level != BT_SECURITY_HIGH || conn->pin_length == 16))
13d39315
WR
711 goto encrypt;
712
713auth:
51a8efd7 714 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1da177e4
LT
715 return 0;
716
6fdf658c
LAD
717 if (!hci_conn_auth(conn, sec_level, auth_type))
718 return 0;
13d39315
WR
719
720encrypt:
721 if (conn->link_mode & HCI_LM_ENCRYPT)
722 return 1;
8c1b2355 723
13d39315 724 hci_conn_encrypt(conn);
1da177e4
LT
725 return 0;
726}
8c1b2355 727EXPORT_SYMBOL(hci_conn_security);
1da177e4 728
b3b1b061
WR
729/* Check secure link requirement */
730int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
731{
38b3fef1 732 BT_DBG("hcon %p", conn);
b3b1b061
WR
733
734 if (sec_level != BT_SECURITY_HIGH)
735 return 1; /* Accept if non-secure is required */
736
ef4177e2 737 if (conn->sec_level == BT_SECURITY_HIGH)
b3b1b061
WR
738 return 1;
739
740 return 0; /* Reject not secure link */
741}
742EXPORT_SYMBOL(hci_conn_check_secure);
743
1da177e4
LT
744/* Change link key */
745int hci_conn_change_link_key(struct hci_conn *conn)
746{
38b3fef1 747 BT_DBG("hcon %p", conn);
1da177e4 748
51a8efd7 749 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
1da177e4 750 struct hci_cp_change_conn_link_key cp;
aca3192c 751 cp.handle = cpu_to_le16(conn->handle);
40be492f 752 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
5974e4c4 753 sizeof(cp), &cp);
1da177e4 754 }
8c1b2355 755
1da177e4
LT
756 return 0;
757}
1da177e4
LT
758
759/* Switch role */
8c1b2355 760int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
1da177e4 761{
38b3fef1 762 BT_DBG("hcon %p", conn);
1da177e4
LT
763
764 if (!role && conn->link_mode & HCI_LM_MASTER)
765 return 1;
766
51a8efd7 767 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
1da177e4
LT
768 struct hci_cp_switch_role cp;
769 bacpy(&cp.bdaddr, &conn->dst);
770 cp.role = role;
a9de9248 771 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
1da177e4 772 }
8c1b2355 773
1da177e4
LT
774 return 0;
775}
776EXPORT_SYMBOL(hci_conn_switch_role);
777
04837f64 778/* Enter active mode */
14b12d0b 779void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
04837f64
MH
780{
781 struct hci_dev *hdev = conn->hdev;
782
38b3fef1 783 BT_DBG("hcon %p mode %d", conn, conn->mode);
04837f64
MH
784
785 if (test_bit(HCI_RAW, &hdev->flags))
786 return;
787
14b12d0b
JG
788 if (conn->mode != HCI_CM_SNIFF)
789 goto timer;
790
58a681ef 791 if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
04837f64
MH
792 goto timer;
793
51a8efd7 794 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
04837f64 795 struct hci_cp_exit_sniff_mode cp;
aca3192c 796 cp.handle = cpu_to_le16(conn->handle);
a9de9248 797 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
04837f64
MH
798 }
799
800timer:
801 if (hdev->idle_timeout > 0)
802 mod_timer(&conn->idle_timer,
5974e4c4 803 jiffies + msecs_to_jiffies(hdev->idle_timeout));
04837f64
MH
804}
805
1da177e4
LT
806/* Drop all connection on the device */
807void hci_conn_hash_flush(struct hci_dev *hdev)
808{
809 struct hci_conn_hash *h = &hdev->conn_hash;
3c4e0df0 810 struct hci_conn *c, *n;
1da177e4
LT
811
812 BT_DBG("hdev %s", hdev->name);
813
3c4e0df0 814 list_for_each_entry_safe(c, n, &h->list, list) {
1da177e4
LT
815 c->state = BT_CLOSED;
816
9f5a0d7b 817 hci_proto_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
1da177e4
LT
818 hci_conn_del(c);
819 }
820}
821
a9de9248
MH
822/* Check pending connect attempts */
823void hci_conn_check_pending(struct hci_dev *hdev)
824{
825 struct hci_conn *conn;
826
827 BT_DBG("hdev %s", hdev->name);
828
829 hci_dev_lock(hdev);
830
831 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
832 if (conn)
1aef8669 833 hci_acl_create_connection(conn);
a9de9248
MH
834
835 hci_dev_unlock(hdev);
836}
837
9eba32b8
MH
838void hci_conn_hold_device(struct hci_conn *conn)
839{
840 atomic_inc(&conn->devref);
841}
842EXPORT_SYMBOL(hci_conn_hold_device);
843
844void hci_conn_put_device(struct hci_conn *conn)
845{
846 if (atomic_dec_and_test(&conn->devref))
847 hci_conn_del_sysfs(conn);
848}
849EXPORT_SYMBOL(hci_conn_put_device);
850
1da177e4
LT
851int hci_get_conn_list(void __user *arg)
852{
fc5fef61 853 struct hci_conn *c;
1da177e4
LT
854 struct hci_conn_list_req req, *cl;
855 struct hci_conn_info *ci;
856 struct hci_dev *hdev;
1da177e4
LT
857 int n = 0, size, err;
858
859 if (copy_from_user(&req, arg, sizeof(req)))
860 return -EFAULT;
861
862 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
863 return -EINVAL;
864
865 size = sizeof(req) + req.conn_num * sizeof(*ci);
866
70f23020
AE
867 cl = kmalloc(size, GFP_KERNEL);
868 if (!cl)
1da177e4
LT
869 return -ENOMEM;
870
70f23020
AE
871 hdev = hci_dev_get(req.dev_id);
872 if (!hdev) {
1da177e4
LT
873 kfree(cl);
874 return -ENODEV;
875 }
876
877 ci = cl->conn_info;
878
09fd0de5 879 hci_dev_lock(hdev);
8035ded4 880 list_for_each_entry(c, &hdev->conn_hash.list, list) {
1da177e4
LT
881 bacpy(&(ci + n)->bdaddr, &c->dst);
882 (ci + n)->handle = c->handle;
883 (ci + n)->type = c->type;
884 (ci + n)->out = c->out;
885 (ci + n)->state = c->state;
886 (ci + n)->link_mode = c->link_mode;
887 if (++n >= req.conn_num)
888 break;
889 }
09fd0de5 890 hci_dev_unlock(hdev);
1da177e4
LT
891
892 cl->dev_id = hdev->id;
893 cl->conn_num = n;
894 size = sizeof(req) + n * sizeof(*ci);
895
896 hci_dev_put(hdev);
897
898 err = copy_to_user(arg, cl, size);
899 kfree(cl);
900
901 return err ? -EFAULT : 0;
902}
903
904int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
905{
906 struct hci_conn_info_req req;
907 struct hci_conn_info ci;
908 struct hci_conn *conn;
909 char __user *ptr = arg + sizeof(req);
910
911 if (copy_from_user(&req, arg, sizeof(req)))
912 return -EFAULT;
913
09fd0de5 914 hci_dev_lock(hdev);
1da177e4
LT
915 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
916 if (conn) {
917 bacpy(&ci.bdaddr, &conn->dst);
918 ci.handle = conn->handle;
919 ci.type = conn->type;
920 ci.out = conn->out;
921 ci.state = conn->state;
922 ci.link_mode = conn->link_mode;
923 }
09fd0de5 924 hci_dev_unlock(hdev);
1da177e4
LT
925
926 if (!conn)
927 return -ENOENT;
928
929 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
930}
40be492f
MH
931
932int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
933{
934 struct hci_auth_info_req req;
935 struct hci_conn *conn;
936
937 if (copy_from_user(&req, arg, sizeof(req)))
938 return -EFAULT;
939
09fd0de5 940 hci_dev_lock(hdev);
40be492f
MH
941 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
942 if (conn)
943 req.type = conn->auth_type;
09fd0de5 944 hci_dev_unlock(hdev);
40be492f
MH
945
946 if (!conn)
947 return -ENOENT;
948
949 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
950}
73d80deb
LAD
951
952struct hci_chan *hci_chan_create(struct hci_conn *conn)
953{
954 struct hci_dev *hdev = conn->hdev;
955 struct hci_chan *chan;
956
38b3fef1 957 BT_DBG("%s hcon %p", hdev->name, conn);
73d80deb 958
75d7735c 959 chan = kzalloc(sizeof(struct hci_chan), GFP_KERNEL);
73d80deb
LAD
960 if (!chan)
961 return NULL;
962
963 chan->conn = conn;
964 skb_queue_head_init(&chan->data_q);
168df8e5 965 chan->state = BT_CONNECTED;
73d80deb 966
8192edef 967 list_add_rcu(&chan->list, &conn->chan_list);
73d80deb
LAD
968
969 return chan;
970}
971
9472007c 972void hci_chan_del(struct hci_chan *chan)
73d80deb
LAD
973{
974 struct hci_conn *conn = chan->conn;
975 struct hci_dev *hdev = conn->hdev;
976
38b3fef1 977 BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
73d80deb 978
8192edef
GP
979 list_del_rcu(&chan->list);
980
981 synchronize_rcu();
73d80deb 982
76a68ba0 983 hci_conn_drop(conn);
e9b02748 984
73d80deb
LAD
985 skb_queue_purge(&chan->data_q);
986 kfree(chan);
73d80deb
LAD
987}
988
2c33c06a 989void hci_chan_list_flush(struct hci_conn *conn)
73d80deb 990{
2a5a5ec6 991 struct hci_chan *chan, *n;
73d80deb 992
38b3fef1 993 BT_DBG("hcon %p", conn);
73d80deb 994
2a5a5ec6 995 list_for_each_entry_safe(chan, n, &conn->chan_list, list)
73d80deb
LAD
996 hci_chan_del(chan);
997}
42c4e53e
AE
998
999static struct hci_chan *__hci_chan_lookup_handle(struct hci_conn *hcon,
1000 __u16 handle)
1001{
1002 struct hci_chan *hchan;
1003
1004 list_for_each_entry(hchan, &hcon->chan_list, list) {
1005 if (hchan->handle == handle)
1006 return hchan;
1007 }
1008
1009 return NULL;
1010}
1011
1012struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle)
1013{
1014 struct hci_conn_hash *h = &hdev->conn_hash;
1015 struct hci_conn *hcon;
1016 struct hci_chan *hchan = NULL;
1017
1018 rcu_read_lock();
1019
1020 list_for_each_entry_rcu(hcon, &h->list, list) {
1021 hchan = __hci_chan_lookup_handle(hcon, handle);
1022 if (hchan)
1023 break;
1024 }
1025
1026 rcu_read_unlock();
1027
1028 return hchan;
1029}