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