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