projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / hci_event.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 event handling. */
26
1da177e4
LT		 27#include <asm/unaligned.h>
28
29#include <net/bluetooth/bluetooth.h>
30#include <net/bluetooth/hci_core.h>
f0d6a0ea 31#include <net/bluetooth/mgmt.h>
8e2a0d92 32#include <net/bluetooth/a2mp.h>
903e4541 33#include <net/bluetooth/amp.h>
1da177e4 34
1da177e4
LT		 35/* Handle HCI Event packets */
36
a9de9248 37static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 38{
a9de9248 39 __u8 status = *((__u8 *) skb->data);
1da177e4 40
9f1db00c 41 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 42
e6d465cb
AG		 43 if (status) {
44 hci_dev_lock(hdev);
45 mgmt_stop_discovery_failed(hdev, status);
46 hci_dev_unlock(hdev);
a9de9248 47 return;
e6d465cb 48 }
1da177e4 49
89352e7d 50 clear_bit(HCI_INQUIRY, &hdev->flags);
3e13fa1e
AG		 51 smp_mb__after_clear_bit(); /* wake_up_bit advises about this barrier */
52 wake_up_bit(&hdev->flags, HCI_INQUIRY);
89352e7d 53
56e5cb86 54 hci_dev_lock(hdev);
ff9ef578 55 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
56e5cb86 56 hci_dev_unlock(hdev);
6bd57416 57
a9de9248
MH		 58 hci_conn_check_pending(hdev);
59}
6bd57416 60
4d93483b
AG		 61static void hci_cc_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
62{
63 __u8 status = *((__u8 *) skb->data);
64
9f1db00c 65 BT_DBG("%s status 0x%2.2x", hdev->name, status);
ae854a70
AG		 66
67 if (status)
68 return;
69
70 set_bit(HCI_PERIODIC_INQ, &hdev->dev_flags);
4d93483b
AG		 71}
72
a9de9248
MH		 73static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
74{
75 __u8 status = *((__u8 *) skb->data);
6bd57416 76
9f1db00c 77 BT_DBG("%s status 0x%2.2x", hdev->name, status);
6bd57416 78
a9de9248
MH		 79 if (status)
80 return;
1da177e4 81
ae854a70
AG		 82 clear_bit(HCI_PERIODIC_INQ, &hdev->dev_flags);
83
a9de9248
MH		 84 hci_conn_check_pending(hdev);
85}
86
807deac2
GP		 87static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev,
88 struct sk_buff *skb)
a9de9248
MH		 89{
90 BT_DBG("%s", hdev->name);
91}
92
93static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
94{
95 struct hci_rp_role_discovery *rp = (void *) skb->data;
96 struct hci_conn *conn;
97
9f1db00c 98 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a9de9248
MH		 99
100 if (rp->status)
101 return;
102
103 hci_dev_lock(hdev);
104
105 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
106 if (conn) {
107 if (rp->role)
108 conn->link_mode &= ~HCI_LM_MASTER;
109 else
110 conn->link_mode |= HCI_LM_MASTER;
1da177e4 111 }
a9de9248
MH		 112
113 hci_dev_unlock(hdev);
1da177e4
LT		 114}
115
e4e8e37c
MH		 116static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
117{
118 struct hci_rp_read_link_policy *rp = (void *) skb->data;
119 struct hci_conn *conn;
120
9f1db00c 121 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
e4e8e37c
MH		 122
123 if (rp->status)
124 return;
125
126 hci_dev_lock(hdev);
127
128 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
129 if (conn)
130 conn->link_policy = __le16_to_cpu(rp->policy);
131
132 hci_dev_unlock(hdev);
133}
134
a9de9248 135static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 136{
a9de9248 137 struct hci_rp_write_link_policy *rp = (void *) skb->data;
1da177e4 138 struct hci_conn *conn;
04837f64 139 void *sent;
1da177e4 140
9f1db00c 141 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 142
a9de9248
MH		 143 if (rp->status)
144 return;
1da177e4 145
a9de9248
MH		 146 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
147 if (!sent)
148 return;
1da177e4 149
a9de9248 150 hci_dev_lock(hdev);
1da177e4 151
a9de9248 152 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
e4e8e37c 153 if (conn)
83985319 154 conn->link_policy = get_unaligned_le16(sent + 2);
1da177e4 155
a9de9248
MH		 156 hci_dev_unlock(hdev);
157}
1da177e4 158
807deac2
GP		 159static void hci_cc_read_def_link_policy(struct hci_dev *hdev,
160 struct sk_buff *skb)
e4e8e37c
MH		 161{
162 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
163
9f1db00c 164 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
e4e8e37c
MH		 165
166 if (rp->status)
167 return;
168
169 hdev->link_policy = __le16_to_cpu(rp->policy);
170}
171
807deac2
GP		 172static void hci_cc_write_def_link_policy(struct hci_dev *hdev,
173 struct sk_buff *skb)
e4e8e37c
MH		 174{
175 __u8 status = *((__u8 *) skb->data);
176 void *sent;
177
9f1db00c 178 BT_DBG("%s status 0x%2.2x", hdev->name, status);
e4e8e37c
MH		 179
180 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
181 if (!sent)
182 return;
183
184 if (!status)
185 hdev->link_policy = get_unaligned_le16(sent);
e4e8e37c
MH		 186}
187
a9de9248
MH		 188static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
189{
190 __u8 status = *((__u8 *) skb->data);
04837f64 191
9f1db00c 192 BT_DBG("%s status 0x%2.2x", hdev->name, status);
04837f64 193
10572132
GP		 194 clear_bit(HCI_RESET, &hdev->flags);
195
a297e97c 196 /* Reset all non-persistent flags */
2cc6fb00 197 hdev->dev_flags &= ~HCI_PERSISTENT_MASK;
69775ff6
AG		 198
199 hdev->discovery.state = DISCOVERY_STOPPED;
bbaf444a
JH		 200 hdev->inq_tx_power = HCI_TX_POWER_INVALID;
201 hdev->adv_tx_power = HCI_TX_POWER_INVALID;
3f0f524b
JH		 202
203 memset(hdev->adv_data, 0, sizeof(hdev->adv_data));
204 hdev->adv_data_len = 0;
a9de9248 205}
04837f64 206
a9de9248
MH		 207static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
208{
209 __u8 status = *((__u8 *) skb->data);
210 void *sent;
04837f64 211
9f1db00c 212 BT_DBG("%s status 0x%2.2x", hdev->name, status);
04837f64 213
a9de9248
MH		 214 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
215 if (!sent)
216 return;
04837f64 217
56e5cb86
JH		 218 hci_dev_lock(hdev);
219
f51d5b24
JH		 220 if (test_bit(HCI_MGMT, &hdev->dev_flags))
221 mgmt_set_local_name_complete(hdev, sent, status);
28cc7bde
JH		 222 else if (!status)
223 memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
f51d5b24 224
56e5cb86 225 hci_dev_unlock(hdev);
a9de9248
MH		 226}
227
228static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
229{
230 struct hci_rp_read_local_name *rp = (void *) skb->data;
231
9f1db00c 232 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a9de9248
MH		 233
234 if (rp->status)
235 return;
236
db99b5fc
JH		 237 if (test_bit(HCI_SETUP, &hdev->dev_flags))
238 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
a9de9248
MH		 239}
240
241static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
242{
243 __u8 status = *((__u8 *) skb->data);
244 void *sent;
245
9f1db00c 246 BT_DBG("%s status 0x%2.2x", hdev->name, status);
a9de9248
MH		 247
248 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
249 if (!sent)
250 return;
251
252 if (!status) {
253 __u8 param = *((__u8 *) sent);
254
255 if (param == AUTH_ENABLED)
256 set_bit(HCI_AUTH, &hdev->flags);
257 else
258 clear_bit(HCI_AUTH, &hdev->flags);
1da177e4 259 }
a9de9248 260
33ef95ed
JH		 261 if (test_bit(HCI_MGMT, &hdev->dev_flags))
262 mgmt_auth_enable_complete(hdev, status);
1da177e4
LT		 263}
264
a9de9248 265static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 266{
a9de9248 267 __u8 status = *((__u8 *) skb->data);
1da177e4
LT		 268 void *sent;
269
9f1db00c 270 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 271
a9de9248
MH		 272 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
273 if (!sent)
274 return;
1da177e4 275
a9de9248
MH		 276 if (!status) {
277 __u8 param = *((__u8 *) sent);
278
279 if (param)
280 set_bit(HCI_ENCRYPT, &hdev->flags);
281 else
282 clear_bit(HCI_ENCRYPT, &hdev->flags);
283 }
a9de9248 284}
1da177e4 285
a9de9248
MH		 286static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
287{
36f7fc7e
JH		 288 __u8 param, status = *((__u8 *) skb->data);
289 int old_pscan, old_iscan;
a9de9248 290 void *sent;
1da177e4 291
9f1db00c 292 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 293
a9de9248
MH		 294 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
295 if (!sent)
296 return;
1da177e4 297
36f7fc7e
JH		 298 param = *((__u8 *) sent);
299
56e5cb86
JH		 300 hci_dev_lock(hdev);
301
fa1bd918 302 if (status) {
744cf19e 303 mgmt_write_scan_failed(hdev, param, status);
2d7cee58
JH		 304 hdev->discov_timeout = 0;
305 goto done;
306 }
307
36f7fc7e
JH		 308 old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
309 old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);
310
311 if (param & SCAN_INQUIRY) {
312 set_bit(HCI_ISCAN, &hdev->flags);
313 if (!old_iscan)
744cf19e 314 mgmt_discoverable(hdev, 1);
16ab91ab
JH		 315 if (hdev->discov_timeout > 0) {
316 int to = msecs_to_jiffies(hdev->discov_timeout * 1000);
317 queue_delayed_work(hdev->workqueue, &hdev->discov_off,
807deac2 318 to);
16ab91ab 319 }
36f7fc7e 320 } else if (old_iscan)
744cf19e 321 mgmt_discoverable(hdev, 0);
36f7fc7e
JH		 322
323 if (param & SCAN_PAGE) {
324 set_bit(HCI_PSCAN, &hdev->flags);
325 if (!old_pscan)
744cf19e 326 mgmt_connectable(hdev, 1);
36f7fc7e 327 } else if (old_pscan)
744cf19e 328 mgmt_connectable(hdev, 0);
1da177e4 329
36f7fc7e 330done:
56e5cb86 331 hci_dev_unlock(hdev);
a9de9248 332}
1da177e4 333
a9de9248
MH		 334static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
335{
336 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
1da177e4 337
9f1db00c 338 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 339
a9de9248
MH		 340 if (rp->status)
341 return;
1da177e4 342
a9de9248 343 memcpy(hdev->dev_class, rp->dev_class, 3);
1da177e4 344
a9de9248 345 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
807deac2 346 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
a9de9248 347}
1da177e4 348
a9de9248
MH		 349static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
350{
351 __u8 status = *((__u8 *) skb->data);
352 void *sent;
1da177e4 353
9f1db00c 354 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 355
a9de9248
MH		 356 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
357 if (!sent)
358 return;
1da177e4 359
7f9a903c
MH		 360 hci_dev_lock(hdev);
361
362 if (status == 0)
363 memcpy(hdev->dev_class, sent, 3);
364
365 if (test_bit(HCI_MGMT, &hdev->dev_flags))
366 mgmt_set_class_of_dev_complete(hdev, sent, status);
367
368 hci_dev_unlock(hdev);
a9de9248 369}
1da177e4 370
a9de9248
MH		 371static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
372{
373 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
374 __u16 setting;
375
9f1db00c 376 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a9de9248
MH		 377
378 if (rp->status)
379 return;
380
381 setting = __le16_to_cpu(rp->voice_setting);
382
f383f275 383 if (hdev->voice_setting == setting)
a9de9248
MH		 384 return;
385
386 hdev->voice_setting = setting;
387
9f1db00c 388 BT_DBG("%s voice setting 0x%4.4x", hdev->name, setting);
a9de9248 389
3c54711c 390 if (hdev->notify)
a9de9248 391 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
a9de9248
MH		 392}
393
8fc9ced3
GP		 394static void hci_cc_write_voice_setting(struct hci_dev *hdev,
395 struct sk_buff *skb)
a9de9248
MH		 396{
397 __u8 status = *((__u8 *) skb->data);
f383f275 398 __u16 setting;
a9de9248
MH		 399 void *sent;
400
9f1db00c 401 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 402
f383f275
MH		 403 if (status)
404 return;
405
a9de9248
MH		 406 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
407 if (!sent)
408 return;
1da177e4 409
f383f275 410 setting = get_unaligned_le16(sent);
1da177e4 411
f383f275
MH		 412 if (hdev->voice_setting == setting)
413 return;
414
415 hdev->voice_setting = setting;
1da177e4 416
9f1db00c 417 BT_DBG("%s voice setting 0x%4.4x", hdev->name, setting);
1da177e4 418
3c54711c 419 if (hdev->notify)
f383f275 420 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
1da177e4
LT		 421}
422
333140b5
MH		 423static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
424{
425 __u8 status = *((__u8 *) skb->data);
5ed8eb2f 426 struct hci_cp_write_ssp_mode *sent;
333140b5 427
9f1db00c 428 BT_DBG("%s status 0x%2.2x", hdev->name, status);
333140b5 429
333140b5
MH		 430 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
431 if (!sent)
432 return;
433
5ed8eb2f
JH		 434 if (!status) {
435 if (sent->mode)
cad718ed 436 hdev->features[1][0] |= LMP_HOST_SSP;
5ed8eb2f 437 else
cad718ed 438 hdev->features[1][0] &= ~LMP_HOST_SSP;
5ed8eb2f
JH		 439 }
440
ed2c4ee3 441 if (test_bit(HCI_MGMT, &hdev->dev_flags))
5ed8eb2f 442 mgmt_ssp_enable_complete(hdev, sent->mode, status);
c0ecddc2 443 else if (!status) {
5ed8eb2f 444 if (sent->mode)
c0ecddc2
JH		 445 set_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
446 else
447 clear_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
448 }
333140b5
MH		 449}
450
a9de9248
MH		 451static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
452{
453 struct hci_rp_read_local_version *rp = (void *) skb->data;
1143e5a6 454
9f1db00c 455 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1143e5a6 456
a9de9248 457 if (rp->status)
42c6b129 458 return;
1143e5a6 459
a9de9248 460 hdev->hci_ver = rp->hci_ver;
e4e8e37c 461 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
d5859e22 462 hdev->lmp_ver = rp->lmp_ver;
e4e8e37c 463 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
d5859e22 464 hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
1143e5a6 465
9f1db00c 466 BT_DBG("%s manufacturer 0x%4.4x hci ver %d:%d", hdev->name,
807deac2 467 hdev->manufacturer, hdev->hci_ver, hdev->hci_rev);
d5859e22
JH		 468}
469
8fc9ced3
GP		 470static void hci_cc_read_local_commands(struct hci_dev *hdev,
471 struct sk_buff *skb)
a9de9248
MH		 472{
473 struct hci_rp_read_local_commands *rp = (void *) skb->data;
1da177e4 474
9f1db00c 475 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 476
2177bab5
JH		 477 if (!rp->status)
478 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
a9de9248 479}
1da177e4 480
8fc9ced3
GP		 481static void hci_cc_read_local_features(struct hci_dev *hdev,
482 struct sk_buff *skb)
a9de9248
MH		 483{
484 struct hci_rp_read_local_features *rp = (void *) skb->data;
5b7f9909 485
9f1db00c 486 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 487
a9de9248
MH		 488 if (rp->status)
489 return;
5b7f9909 490
a9de9248 491 memcpy(hdev->features, rp->features, 8);
5b7f9909 492
a9de9248
MH		 493 /* Adjust default settings according to features
494 * supported by device. */
1da177e4 495
cad718ed 496 if (hdev->features[0][0] & LMP_3SLOT)
a9de9248 497 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
1da177e4 498
cad718ed 499 if (hdev->features[0][0] & LMP_5SLOT)
a9de9248 500 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
1da177e4 501
cad718ed 502 if (hdev->features[0][1] & LMP_HV2) {
a9de9248
MH		 503 hdev->pkt_type |= (HCI_HV2);
504 hdev->esco_type |= (ESCO_HV2);
505 }
1da177e4 506
cad718ed 507 if (hdev->features[0][1] & LMP_HV3) {
a9de9248
MH		 508 hdev->pkt_type |= (HCI_HV3);
509 hdev->esco_type |= (ESCO_HV3);
510 }
1da177e4 511
45db810f 512 if (lmp_esco_capable(hdev))
a9de9248 513 hdev->esco_type |= (ESCO_EV3);
da1f5198 514
cad718ed 515 if (hdev->features[0][4] & LMP_EV4)
a9de9248 516 hdev->esco_type |= (ESCO_EV4);
da1f5198 517
cad718ed 518 if (hdev->features[0][4] & LMP_EV5)
a9de9248 519 hdev->esco_type |= (ESCO_EV5);
1da177e4 520
cad718ed 521 if (hdev->features[0][5] & LMP_EDR_ESCO_2M)
efc7688b
MH		 522 hdev->esco_type |= (ESCO_2EV3);
523
cad718ed 524 if (hdev->features[0][5] & LMP_EDR_ESCO_3M)
efc7688b
MH		 525 hdev->esco_type |= (ESCO_3EV3);
526
cad718ed 527 if (hdev->features[0][5] & LMP_EDR_3S_ESCO)
efc7688b
MH		 528 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
529
a9de9248 530 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
cad718ed
JH		 531 hdev->features[0][0], hdev->features[0][1],
532 hdev->features[0][2], hdev->features[0][3],
533 hdev->features[0][4], hdev->features[0][5],
534 hdev->features[0][6], hdev->features[0][7]);
a9de9248 535}
1da177e4 536
971e3a4b 537static void hci_cc_read_local_ext_features(struct hci_dev *hdev,
807deac2 538 struct sk_buff *skb)
971e3a4b
AG		 539{
540 struct hci_rp_read_local_ext_features *rp = (void *) skb->data;
541
9f1db00c 542 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
971e3a4b
AG		 543
544 if (rp->status)
42c6b129 545 return;
971e3a4b 546
d2c5d77f
JH		 547 hdev->max_page = rp->max_page;
548
cad718ed
JH		 549 if (rp->page < HCI_MAX_PAGES)
550 memcpy(hdev->features[rp->page], rp->features, 8);
971e3a4b
AG		 551}
552
1e89cffb 553static void hci_cc_read_flow_control_mode(struct hci_dev *hdev,
807deac2 554 struct sk_buff *skb)
1e89cffb
AE		 555{
556 struct hci_rp_read_flow_control_mode *rp = (void *) skb->data;
557
9f1db00c 558 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1e89cffb 559
42c6b129
JH		 560 if (!rp->status)
561 hdev->flow_ctl_mode = rp->mode;
1e89cffb
AE		 562}
563
a9de9248
MH		 564static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
565{
566 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
1da177e4 567
9f1db00c 568 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 569
a9de9248
MH		 570 if (rp->status)
571 return;
1da177e4 572
a9de9248
MH		 573 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
574 hdev->sco_mtu = rp->sco_mtu;
575 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
576 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
577
578 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
579 hdev->sco_mtu = 64;
580 hdev->sco_pkts = 8;
1da177e4 581 }
a9de9248
MH		 582
583 hdev->acl_cnt = hdev->acl_pkts;
584 hdev->sco_cnt = hdev->sco_pkts;
585
807deac2
GP		 586 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name, hdev->acl_mtu,
587 hdev->acl_pkts, hdev->sco_mtu, hdev->sco_pkts);
a9de9248
MH		 588}
589
590static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
591{
592 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
593
9f1db00c 594 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a9de9248
MH		 595
596 if (!rp->status)
597 bacpy(&hdev->bdaddr, &rp->bdaddr);
23bb5763
JH		 598}
599
f332ec66
JH		 600static void hci_cc_read_page_scan_activity(struct hci_dev *hdev,
601 struct sk_buff *skb)
602{
603 struct hci_rp_read_page_scan_activity *rp = (void *) skb->data;
604
605 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
606
607 if (test_bit(HCI_INIT, &hdev->flags) && !rp->status) {
608 hdev->page_scan_interval = __le16_to_cpu(rp->interval);
609 hdev->page_scan_window = __le16_to_cpu(rp->window);
610 }
611}
612
4a3ee763
JH		 613static void hci_cc_write_page_scan_activity(struct hci_dev *hdev,
614 struct sk_buff *skb)
615{
616 u8 status = *((u8 *) skb->data);
617 struct hci_cp_write_page_scan_activity *sent;
618
619 BT_DBG("%s status 0x%2.2x", hdev->name, status);
620
621 if (status)
622 return;
623
624 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY);
625 if (!sent)
626 return;
627
628 hdev->page_scan_interval = __le16_to_cpu(sent->interval);
629 hdev->page_scan_window = __le16_to_cpu(sent->window);
630}
631
f332ec66
JH		 632static void hci_cc_read_page_scan_type(struct hci_dev *hdev,
633 struct sk_buff *skb)
634{
635 struct hci_rp_read_page_scan_type *rp = (void *) skb->data;
636
637 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
638
639 if (test_bit(HCI_INIT, &hdev->flags) && !rp->status)
640 hdev->page_scan_type = rp->type;
641}
642
4a3ee763
JH		 643static void hci_cc_write_page_scan_type(struct hci_dev *hdev,
644 struct sk_buff *skb)
645{
646 u8 status = *((u8 *) skb->data);
647 u8 *type;
648
649 BT_DBG("%s status 0x%2.2x", hdev->name, status);
650
651 if (status)
652 return;
653
654 type = hci_sent_cmd_data(hdev, HCI_OP_WRITE_PAGE_SCAN_TYPE);
655 if (type)
656 hdev->page_scan_type = *type;
657}
658
350ee4cf 659static void hci_cc_read_data_block_size(struct hci_dev *hdev,
807deac2 660 struct sk_buff *skb)
350ee4cf
AE		 661{
662 struct hci_rp_read_data_block_size *rp = (void *) skb->data;
663
9f1db00c 664 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
350ee4cf
AE		 665
666 if (rp->status)
667 return;
668
669 hdev->block_mtu = __le16_to_cpu(rp->max_acl_len);
670 hdev->block_len = __le16_to_cpu(rp->block_len);
671 hdev->num_blocks = __le16_to_cpu(rp->num_blocks);
672
673 hdev->block_cnt = hdev->num_blocks;
674
675 BT_DBG("%s blk mtu %d cnt %d len %d", hdev->name, hdev->block_mtu,
807deac2 676 hdev->block_cnt, hdev->block_len);
350ee4cf
AE		 677}
678
928abaa7 679static void hci_cc_read_local_amp_info(struct hci_dev *hdev,
807deac2 680 struct sk_buff *skb)
928abaa7
AE		 681{
682 struct hci_rp_read_local_amp_info *rp = (void *) skb->data;
683
9f1db00c 684 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
928abaa7
AE		 685
686 if (rp->status)
8e2a0d92 687 goto a2mp_rsp;
928abaa7
AE		 688
689 hdev->amp_status = rp->amp_status;
690 hdev->amp_total_bw = __le32_to_cpu(rp->total_bw);
691 hdev->amp_max_bw = __le32_to_cpu(rp->max_bw);
692 hdev->amp_min_latency = __le32_to_cpu(rp->min_latency);
693 hdev->amp_max_pdu = __le32_to_cpu(rp->max_pdu);
694 hdev->amp_type = rp->amp_type;
695 hdev->amp_pal_cap = __le16_to_cpu(rp->pal_cap);
696 hdev->amp_assoc_size = __le16_to_cpu(rp->max_assoc_size);
697 hdev->amp_be_flush_to = __le32_to_cpu(rp->be_flush_to);
698 hdev->amp_max_flush_to = __le32_to_cpu(rp->max_flush_to);
699
8e2a0d92
AE		 700a2mp_rsp:
701 a2mp_send_getinfo_rsp(hdev);
928abaa7
AE		 702}
703
903e4541
AE		 704static void hci_cc_read_local_amp_assoc(struct hci_dev *hdev,
705 struct sk_buff *skb)
706{
707 struct hci_rp_read_local_amp_assoc *rp = (void *) skb->data;
708 struct amp_assoc *assoc = &hdev->loc_assoc;
709 size_t rem_len, frag_len;
710
711 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
712
713 if (rp->status)
714 goto a2mp_rsp;
715
716 frag_len = skb->len - sizeof(*rp);
717 rem_len = __le16_to_cpu(rp->rem_len);
718
719 if (rem_len > frag_len) {
2e430be3 720 BT_DBG("frag_len %zu rem_len %zu", frag_len, rem_len);
903e4541
AE		 721
722 memcpy(assoc->data + assoc->offset, rp->frag, frag_len);
723 assoc->offset += frag_len;
724
725 /* Read other fragments */
726 amp_read_loc_assoc_frag(hdev, rp->phy_handle);
727
728 return;
729 }
730
731 memcpy(assoc->data + assoc->offset, rp->frag, rem_len);
732 assoc->len = assoc->offset + rem_len;
733 assoc->offset = 0;
734
735a2mp_rsp:
736 /* Send A2MP Rsp when all fragments are received */
737 a2mp_send_getampassoc_rsp(hdev, rp->status);
9495b2ee 738 a2mp_send_create_phy_link_req(hdev, rp->status);
903e4541
AE		 739}
740
d5859e22 741static void hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev,
807deac2 742 struct sk_buff *skb)
d5859e22 743{
91c4e9b1 744 struct hci_rp_read_inq_rsp_tx_power *rp = (void *) skb->data;
d5859e22 745
9f1db00c 746 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
91c4e9b1
MH		 747
748 if (!rp->status)
749 hdev->inq_tx_power = rp->tx_power;
d5859e22
JH		 750}
751
980e1a53
JH		 752static void hci_cc_pin_code_reply(struct hci_dev *hdev, struct sk_buff *skb)
753{
754 struct hci_rp_pin_code_reply *rp = (void *) skb->data;
755 struct hci_cp_pin_code_reply *cp;
756 struct hci_conn *conn;
757
9f1db00c 758 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
980e1a53 759
56e5cb86
JH		 760 hci_dev_lock(hdev);
761
a8b2d5c2 762 if (test_bit(HCI_MGMT, &hdev->dev_flags))
744cf19e 763 mgmt_pin_code_reply_complete(hdev, &rp->bdaddr, rp->status);
980e1a53 764
fa1bd918 765 if (rp->status)
56e5cb86 766 goto unlock;
980e1a53
JH		 767
768 cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
769 if (!cp)
56e5cb86 770 goto unlock;
980e1a53
JH		 771
772 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
773 if (conn)
774 conn->pin_length = cp->pin_len;
56e5cb86
JH		 775
776unlock:
777 hci_dev_unlock(hdev);
980e1a53
JH		 778}
779
780static void hci_cc_pin_code_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
781{
782 struct hci_rp_pin_code_neg_reply *rp = (void *) skb->data;
783
9f1db00c 784 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
980e1a53 785
56e5cb86
JH		 786 hci_dev_lock(hdev);
787
a8b2d5c2 788 if (test_bit(HCI_MGMT, &hdev->dev_flags))
744cf19e 789 mgmt_pin_code_neg_reply_complete(hdev, &rp->bdaddr,
807deac2 790 rp->status);
56e5cb86
JH		 791
792 hci_dev_unlock(hdev);
980e1a53 793}
56e5cb86 794
6ed58ec5
VT		 795static void hci_cc_le_read_buffer_size(struct hci_dev *hdev,
796 struct sk_buff *skb)
797{
798 struct hci_rp_le_read_buffer_size *rp = (void *) skb->data;
799
9f1db00c 800 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
6ed58ec5
VT		 801
802 if (rp->status)
803 return;
804
805 hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
806 hdev->le_pkts = rp->le_max_pkt;
807
808 hdev->le_cnt = hdev->le_pkts;
809
810 BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);
6ed58ec5 811}
980e1a53 812
60e77321
JH		 813static void hci_cc_le_read_local_features(struct hci_dev *hdev,
814 struct sk_buff *skb)
815{
816 struct hci_rp_le_read_local_features *rp = (void *) skb->data;
817
818 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
819
820 if (!rp->status)
821 memcpy(hdev->le_features, rp->features, 8);
60e77321
JH		 822}
823
8fa19098
JH		 824static void hci_cc_le_read_adv_tx_power(struct hci_dev *hdev,
825 struct sk_buff *skb)
826{
827 struct hci_rp_le_read_adv_tx_power *rp = (void *) skb->data;
828
829 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
830
04b4edcb 831 if (!rp->status)
8fa19098 832 hdev->adv_tx_power = rp->tx_power;
8fa19098
JH		 833}
834
a5c29683
JH		 835static void hci_cc_user_confirm_reply(struct hci_dev *hdev, struct sk_buff *skb)
836{
837 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
838
9f1db00c 839 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a5c29683 840
56e5cb86
JH		 841 hci_dev_lock(hdev);
842
a8b2d5c2 843 if (test_bit(HCI_MGMT, &hdev->dev_flags))
04124681
GP		 844 mgmt_user_confirm_reply_complete(hdev, &rp->bdaddr, ACL_LINK, 0,
845 rp->status);
56e5cb86
JH		 846
847 hci_dev_unlock(hdev);
a5c29683
JH		 848}
849
850static void hci_cc_user_confirm_neg_reply(struct hci_dev *hdev,
807deac2 851 struct sk_buff *skb)
a5c29683
JH		 852{
853 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
854
9f1db00c 855 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a5c29683 856
56e5cb86
JH		 857 hci_dev_lock(hdev);
858
a8b2d5c2 859 if (test_bit(HCI_MGMT, &hdev->dev_flags))
744cf19e 860 mgmt_user_confirm_neg_reply_complete(hdev, &rp->bdaddr,
04124681 861 ACL_LINK, 0, rp->status);
56e5cb86
JH		 862
863 hci_dev_unlock(hdev);
a5c29683
JH		 864}
865
1143d458
BG		 866static void hci_cc_user_passkey_reply(struct hci_dev *hdev, struct sk_buff *skb)
867{
868 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
869
9f1db00c 870 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1143d458
BG		 871
872 hci_dev_lock(hdev);
873
a8b2d5c2 874 if (test_bit(HCI_MGMT, &hdev->dev_flags))
272d90df 875 mgmt_user_passkey_reply_complete(hdev, &rp->bdaddr, ACL_LINK,
04124681 876 0, rp->status);
1143d458
BG		 877
878 hci_dev_unlock(hdev);
879}
880
881static void hci_cc_user_passkey_neg_reply(struct hci_dev *hdev,
807deac2 882 struct sk_buff *skb)
1143d458
BG		 883{
884 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
885
9f1db00c 886 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1143d458
BG		 887
888 hci_dev_lock(hdev);
889
a8b2d5c2 890 if (test_bit(HCI_MGMT, &hdev->dev_flags))
1143d458 891 mgmt_user_passkey_neg_reply_complete(hdev, &rp->bdaddr,
04124681 892 ACL_LINK, 0, rp->status);
1143d458
BG		 893
894 hci_dev_unlock(hdev);
895}
896
c35938b2 897static void hci_cc_read_local_oob_data_reply(struct hci_dev *hdev,
807deac2 898 struct sk_buff *skb)
c35938b2
SJ		 899{
900 struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
901
9f1db00c 902 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
c35938b2 903
56e5cb86 904 hci_dev_lock(hdev);
744cf19e 905 mgmt_read_local_oob_data_reply_complete(hdev, rp->hash,
c35938b2 906 rp->randomizer, rp->status);
56e5cb86 907 hci_dev_unlock(hdev);
c35938b2
SJ		 908}
909
c1d5dc4a
JH		 910static void hci_cc_le_set_adv_enable(struct hci_dev *hdev, struct sk_buff *skb)
911{
912 __u8 *sent, status = *((__u8 *) skb->data);
913
914 BT_DBG("%s status 0x%2.2x", hdev->name, status);
915
916 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_ADV_ENABLE);
917 if (!sent)
918 return;
919
920 hci_dev_lock(hdev);
921
922 if (!status) {
923 if (*sent)
924 set_bit(HCI_LE_PERIPHERAL, &hdev->dev_flags);
925 else
926 clear_bit(HCI_LE_PERIPHERAL, &hdev->dev_flags);
927 }
928
04b4edcb
JH		 929 if (!test_bit(HCI_INIT, &hdev->flags)) {
930 struct hci_request req;
c1d5dc4a 931
04b4edcb
JH		 932 hci_req_init(&req, hdev);
933 hci_update_ad(&req);
934 hci_req_run(&req, NULL);
935 }
936
937 hci_dev_unlock(hdev);
c1d5dc4a
JH		 938}
939
07f7fa5d
AG		 940static void hci_cc_le_set_scan_param(struct hci_dev *hdev, struct sk_buff *skb)
941{
942 __u8 status = *((__u8 *) skb->data);
943
9f1db00c 944 BT_DBG("%s status 0x%2.2x", hdev->name, status);
7ba8b4be 945
3fd24153
AG		 946 if (status) {
947 hci_dev_lock(hdev);
948 mgmt_start_discovery_failed(hdev, status);
949 hci_dev_unlock(hdev);
950 return;
951 }
07f7fa5d
AG		 952}
953
eb9d91f5 954static void hci_cc_le_set_scan_enable(struct hci_dev *hdev,
807deac2 955 struct sk_buff *skb)
eb9d91f5
AG		 956{
957 struct hci_cp_le_set_scan_enable *cp;
958 __u8 status = *((__u8 *) skb->data);
959
9f1db00c 960 BT_DBG("%s status 0x%2.2x", hdev->name, status);
eb9d91f5 961
eb9d91f5
AG		 962 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
963 if (!cp)
964 return;
965
68a8aea4 966 switch (cp->enable) {
76a388be 967 case LE_SCAN_ENABLE:
3fd24153
AG		 968 if (status) {
969 hci_dev_lock(hdev);
970 mgmt_start_discovery_failed(hdev, status);
971 hci_dev_unlock(hdev);
7ba8b4be 972 return;
3fd24153 973 }
7ba8b4be 974
d23264a8
AG		 975 set_bit(HCI_LE_SCAN, &hdev->dev_flags);
976
a8f13c8c 977 hci_dev_lock(hdev);
343f935b 978 hci_discovery_set_state(hdev, DISCOVERY_FINDING);
a8f13c8c 979 hci_dev_unlock(hdev);
68a8aea4
AE		 980 break;
981
76a388be 982 case LE_SCAN_DISABLE:
c9ecc48e
AG		 983 if (status) {
984 hci_dev_lock(hdev);
985 mgmt_stop_discovery_failed(hdev, status);
986 hci_dev_unlock(hdev);
7ba8b4be 987 return;
c9ecc48e 988 }
7ba8b4be 989
d23264a8
AG		 990 clear_bit(HCI_LE_SCAN, &hdev->dev_flags);
991
bc3dd33c
AG		 992 if (hdev->discovery.type == DISCOV_TYPE_INTERLEAVED &&
993 hdev->discovery.state == DISCOVERY_FINDING) {
5e0452c0
AG		 994 mgmt_interleaved_discovery(hdev);
995 } else {
996 hci_dev_lock(hdev);
997 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
998 hci_dev_unlock(hdev);
999 }
1000
68a8aea4
AE		 1001 break;
1002
1003 default:
1004 BT_ERR("Used reserved LE_Scan_Enable param %d", cp->enable);
1005 break;
35815085 1006 }
eb9d91f5
AG		 1007}
1008
cf1d081f
JH		 1009static void hci_cc_le_read_white_list_size(struct hci_dev *hdev,
1010 struct sk_buff *skb)
1011{
1012 struct hci_rp_le_read_white_list_size *rp = (void *) skb->data;
1013
1014 BT_DBG("%s status 0x%2.2x size %u", hdev->name, rp->status, rp->size);
1015
1016 if (!rp->status)
1017 hdev->le_white_list_size = rp->size;
cf1d081f
JH		 1018}
1019
9b008c04
JH		 1020static void hci_cc_le_read_supported_states(struct hci_dev *hdev,
1021 struct sk_buff *skb)
1022{
1023 struct hci_rp_le_read_supported_states *rp = (void *) skb->data;
1024
1025 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1026
1027 if (!rp->status)
1028 memcpy(hdev->le_states, rp->le_states, 8);
9b008c04
JH		 1029}
1030
6039aa73
GP		 1031static void hci_cc_write_le_host_supported(struct hci_dev *hdev,
1032 struct sk_buff *skb)
f9b49306 1033{
06199cf8 1034 struct hci_cp_write_le_host_supported *sent;
f9b49306
AG		 1035 __u8 status = *((__u8 *) skb->data);
1036
9f1db00c 1037 BT_DBG("%s status 0x%2.2x", hdev->name, status);
f9b49306 1038
06199cf8 1039 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED);
8f984dfa 1040 if (!sent)
f9b49306
AG		 1041 return;
1042
8f984dfa
JH		 1043 if (!status) {
1044 if (sent->le)
cad718ed 1045 hdev->features[1][0] |= LMP_HOST_LE;
8f984dfa 1046 else
cad718ed 1047 hdev->features[1][0] &= ~LMP_HOST_LE;
53b2caab
JH		 1048
1049 if (sent->simul)
cad718ed 1050 hdev->features[1][0] |= LMP_HOST_LE_BREDR;
53b2caab 1051 else
cad718ed 1052 hdev->features[1][0] &= ~LMP_HOST_LE_BREDR;
8f984dfa
JH		 1053 }
1054
1055 if (test_bit(HCI_MGMT, &hdev->dev_flags) &&
807deac2 1056 !test_bit(HCI_INIT, &hdev->flags))
8f984dfa 1057 mgmt_le_enable_complete(hdev, sent->le, status);
f9b49306
AG		 1058}
1059
93c284ee
AE		 1060static void hci_cc_write_remote_amp_assoc(struct hci_dev *hdev,
1061 struct sk_buff *skb)
1062{
1063 struct hci_rp_write_remote_amp_assoc *rp = (void *) skb->data;
1064
1065 BT_DBG("%s status 0x%2.2x phy_handle 0x%2.2x",
1066 hdev->name, rp->status, rp->phy_handle);
1067
1068 if (rp->status)
1069 return;
1070
1071 amp_write_rem_assoc_continue(hdev, rp->phy_handle);
1072}
1073
6039aa73 1074static void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
a9de9248 1075{
9f1db00c 1076 BT_DBG("%s status 0x%2.2x", hdev->name, status);
a9de9248
MH		 1077
1078 if (status) {
a9de9248 1079 hci_conn_check_pending(hdev);
56e5cb86 1080 hci_dev_lock(hdev);
a8b2d5c2 1081 if (test_bit(HCI_MGMT, &hdev->dev_flags))
7a135109 1082 mgmt_start_discovery_failed(hdev, status);
56e5cb86 1083 hci_dev_unlock(hdev);
314b2381
JH		 1084 return;
1085 }
1086
89352e7d
AG		 1087 set_bit(HCI_INQUIRY, &hdev->flags);
1088
56e5cb86 1089 hci_dev_lock(hdev);
343f935b 1090 hci_discovery_set_state(hdev, DISCOVERY_FINDING);
56e5cb86 1091 hci_dev_unlock(hdev);
1da177e4
LT		 1092}
1093
6039aa73 1094static void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
1da177e4 1095{
a9de9248 1096 struct hci_cp_create_conn *cp;
1da177e4 1097 struct hci_conn *conn;
1da177e4 1098
9f1db00c 1099 BT_DBG("%s status 0x%2.2x", hdev->name, status);
a9de9248
MH		 1100
1101 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
1da177e4
LT		 1102 if (!cp)
1103 return;
1104
1105 hci_dev_lock(hdev);
1106
1107 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1108
6ed93dc6 1109 BT_DBG("%s bdaddr %pMR hcon %p", hdev->name, &cp->bdaddr, conn);
1da177e4
LT		 1110
1111 if (status) {
1112 if (conn && conn->state == BT_CONNECT) {
4c67bc74
MH		 1113 if (status != 0x0c || conn->attempt > 2) {
1114 conn->state = BT_CLOSED;
1115 hci_proto_connect_cfm(conn, status);
1116 hci_conn_del(conn);
1117 } else
1118 conn->state = BT_CONNECT2;
1da177e4
LT		 1119 }
1120 } else {
1121 if (!conn) {
1122 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
1123 if (conn) {
a0c808b3 1124 conn->out = true;
1da177e4
LT		 1125 conn->link_mode |= HCI_LM_MASTER;
1126 } else
893ef971 1127 BT_ERR("No memory for new connection");
1da177e4
LT		 1128 }
1129 }
1130
1131 hci_dev_unlock(hdev);
1132}
1133
a9de9248 1134static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
1da177e4 1135{
a9de9248
MH		 1136 struct hci_cp_add_sco *cp;
1137 struct hci_conn *acl, *sco;
1138 __u16 handle;
1da177e4 1139
9f1db00c 1140 BT_DBG("%s status 0x%2.2x", hdev->name, status);
b6a0dc82 1141
a9de9248
MH		 1142 if (!status)
1143 return;
1da177e4 1144
a9de9248
MH		 1145 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
1146 if (!cp)
1147 return;
1da177e4 1148
a9de9248 1149 handle = __le16_to_cpu(cp->handle);
1da177e4 1150
9f1db00c 1151 BT_DBG("%s handle 0x%4.4x", hdev->name, handle);
1da177e4 1152
a9de9248 1153 hci_dev_lock(hdev);
1da177e4 1154
a9de9248 1155 acl = hci_conn_hash_lookup_handle(hdev, handle);
5a08ecce
AE		 1156 if (acl) {
1157 sco = acl->link;
1158 if (sco) {
1159 sco->state = BT_CLOSED;
1da177e4 1160
5a08ecce
AE		 1161 hci_proto_connect_cfm(sco, status);
1162 hci_conn_del(sco);
1163 }
a9de9248 1164 }
1da177e4 1165
a9de9248
MH		 1166 hci_dev_unlock(hdev);
1167}
1da177e4 1168
f8558555
MH		 1169static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
1170{
1171 struct hci_cp_auth_requested *cp;
1172 struct hci_conn *conn;
1173
9f1db00c 1174 BT_DBG("%s status 0x%2.2x", hdev->name, status);
f8558555
MH		 1175
1176 if (!status)
1177 return;
1178
1179 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
1180 if (!cp)
1181 return;
1182
1183 hci_dev_lock(hdev);
1184
1185 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1186 if (conn) {
1187 if (conn->state == BT_CONFIG) {
1188 hci_proto_connect_cfm(conn, status);
76a68ba0 1189 hci_conn_drop(conn);
f8558555
MH		 1190 }
1191 }
1192
1193 hci_dev_unlock(hdev);
1194}
1195
1196static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
1197{
1198 struct hci_cp_set_conn_encrypt *cp;
1199 struct hci_conn *conn;
1200
9f1db00c 1201 BT_DBG("%s status 0x%2.2x", hdev->name, status);
f8558555
MH		 1202
1203 if (!status)
1204 return;
1205
1206 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
1207 if (!cp)
1208 return;
1209
1210 hci_dev_lock(hdev);
1211
1212 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1213 if (conn) {
1214 if (conn->state == BT_CONFIG) {
1215 hci_proto_connect_cfm(conn, status);
76a68ba0 1216 hci_conn_drop(conn);
f8558555
MH		 1217 }
1218 }
1219
1220 hci_dev_unlock(hdev);
1221}
1222
127178d2 1223static int hci_outgoing_auth_needed(struct hci_dev *hdev,
807deac2 1224 struct hci_conn *conn)
392599b9 1225{
392599b9
JH		 1226 if (conn->state != BT_CONFIG || !conn->out)
1227 return 0;
1228
765c2a96 1229 if (conn->pending_sec_level == BT_SECURITY_SDP)
392599b9
JH		 1230 return 0;
1231
1232 /* Only request authentication for SSP connections or non-SSP
e9bf2bf0 1233 * devices with sec_level HIGH or if MITM protection is requested */
807deac2
GP		 1234 if (!hci_conn_ssp_enabled(conn) && !(conn->auth_type & 0x01) &&
1235 conn->pending_sec_level != BT_SECURITY_HIGH)
392599b9
JH		 1236 return 0;
1237
392599b9
JH		 1238 return 1;
1239}
1240
6039aa73 1241static int hci_resolve_name(struct hci_dev *hdev,
04124681 1242 struct inquiry_entry *e)
30dc78e1
JH		 1243{
1244 struct hci_cp_remote_name_req cp;
1245
1246 memset(&cp, 0, sizeof(cp));
1247
1248 bacpy(&cp.bdaddr, &e->data.bdaddr);
1249 cp.pscan_rep_mode = e->data.pscan_rep_mode;
1250 cp.pscan_mode = e->data.pscan_mode;
1251 cp.clock_offset = e->data.clock_offset;
1252
1253 return hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
1254}
1255
b644ba33 1256static bool hci_resolve_next_name(struct hci_dev *hdev)
30dc78e1
JH		 1257{
1258 struct discovery_state *discov = &hdev->discovery;
1259 struct inquiry_entry *e;
1260
b644ba33
JH		 1261 if (list_empty(&discov->resolve))
1262 return false;
1263
1264 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
c810089c
RM		 1265 if (!e)
1266 return false;
1267
b644ba33
JH		 1268 if (hci_resolve_name(hdev, e) == 0) {
1269 e->name_state = NAME_PENDING;
1270 return true;
1271 }
1272
1273 return false;
1274}
1275
1276static void hci_check_pending_name(struct hci_dev *hdev, struct hci_conn *conn,
04124681 1277 bdaddr_t *bdaddr, u8 *name, u8 name_len)
b644ba33
JH		 1278{
1279 struct discovery_state *discov = &hdev->discovery;
1280 struct inquiry_entry *e;
1281
1282 if (conn && !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
04124681
GP		 1283 mgmt_device_connected(hdev, bdaddr, ACL_LINK, 0x00, 0, name,
1284 name_len, conn->dev_class);
b644ba33
JH		 1285
1286 if (discov->state == DISCOVERY_STOPPED)
1287 return;
1288
30dc78e1
JH		 1289 if (discov->state == DISCOVERY_STOPPING)
1290 goto discov_complete;
1291
1292 if (discov->state != DISCOVERY_RESOLVING)
1293 return;
1294
1295 e = hci_inquiry_cache_lookup_resolve(hdev, bdaddr, NAME_PENDING);
7cc8380e
RM		 1296 /* If the device was not found in a list of found devices names of which
1297 * are pending. there is no need to continue resolving a next name as it
1298 * will be done upon receiving another Remote Name Request Complete
1299 * Event */
1300 if (!e)
1301 return;
1302
1303 list_del(&e->list);
1304 if (name) {
30dc78e1 1305 e->name_state = NAME_KNOWN;
7cc8380e
RM		 1306 mgmt_remote_name(hdev, bdaddr, ACL_LINK, 0x00,
1307 e->data.rssi, name, name_len);
c3e7c0d9
RM		 1308 } else {
1309 e->name_state = NAME_NOT_KNOWN;
30dc78e1
JH		 1310 }
1311
b644ba33 1312 if (hci_resolve_next_name(hdev))
30dc78e1 1313 return;
30dc78e1
JH		 1314
1315discov_complete:
1316 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1317}
1318
a9de9248
MH		 1319static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
1320{
127178d2
JH		 1321 struct hci_cp_remote_name_req *cp;
1322 struct hci_conn *conn;
1323
9f1db00c 1324 BT_DBG("%s status 0x%2.2x", hdev->name, status);
127178d2
JH		 1325
1326 /* If successful wait for the name req complete event before
1327 * checking for the need to do authentication */
1328 if (!status)
1329 return;
1330
1331 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
1332 if (!cp)
1333 return;
1334
1335 hci_dev_lock(hdev);
1336
b644ba33
JH		 1337 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1338
a8b2d5c2 1339 if (test_bit(HCI_MGMT, &hdev->dev_flags))
b644ba33 1340 hci_check_pending_name(hdev, conn, &cp->bdaddr, NULL, 0);
30dc78e1 1341
79c6c70c
JH		 1342 if (!conn)
1343 goto unlock;
1344
1345 if (!hci_outgoing_auth_needed(hdev, conn))
1346 goto unlock;
1347
51a8efd7 1348 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
127178d2
JH		 1349 struct hci_cp_auth_requested cp;
1350 cp.handle = __cpu_to_le16(conn->handle);
1351 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1352 }
1353
79c6c70c 1354unlock:
127178d2 1355 hci_dev_unlock(hdev);
a9de9248 1356}
1da177e4 1357
769be974
MH		 1358static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
1359{
1360 struct hci_cp_read_remote_features *cp;
1361 struct hci_conn *conn;
1362
9f1db00c 1363 BT_DBG("%s status 0x%2.2x", hdev->name, status);
769be974
MH		 1364
1365 if (!status)
1366 return;
1367
1368 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
1369 if (!cp)
1370 return;
1371
1372 hci_dev_lock(hdev);
1373
1374 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1375 if (conn) {
1376 if (conn->state == BT_CONFIG) {
769be974 1377 hci_proto_connect_cfm(conn, status);
76a68ba0 1378 hci_conn_drop(conn);
769be974
MH		 1379 }
1380 }
1381
1382 hci_dev_unlock(hdev);
1383}
1384
1385static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
1386{
1387 struct hci_cp_read_remote_ext_features *cp;
1388 struct hci_conn *conn;
1389
9f1db00c 1390 BT_DBG("%s status 0x%2.2x", hdev->name, status);
769be974
MH		 1391
1392 if (!status)
1393 return;
1394
1395 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
1396 if (!cp)
1397 return;
1398
1399 hci_dev_lock(hdev);
1400
1401 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1402 if (conn) {
1403 if (conn->state == BT_CONFIG) {
769be974 1404 hci_proto_connect_cfm(conn, status);
76a68ba0 1405 hci_conn_drop(conn);
769be974
MH		 1406 }
1407 }
1408
1409 hci_dev_unlock(hdev);
1410}
1411
a9de9248
MH		 1412static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
1413{
b6a0dc82
MH		 1414 struct hci_cp_setup_sync_conn *cp;
1415 struct hci_conn *acl, *sco;
1416 __u16 handle;
1417
9f1db00c 1418 BT_DBG("%s status 0x%2.2x", hdev->name, status);
b6a0dc82
MH		 1419
1420 if (!status)
1421 return;
1422
1423 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
1424 if (!cp)
1425 return;
1426
1427 handle = __le16_to_cpu(cp->handle);
1428
9f1db00c 1429 BT_DBG("%s handle 0x%4.4x", hdev->name, handle);
b6a0dc82
MH		 1430
1431 hci_dev_lock(hdev);
1432
1433 acl = hci_conn_hash_lookup_handle(hdev, handle);
5a08ecce
AE		 1434 if (acl) {
1435 sco = acl->link;
1436 if (sco) {
1437 sco->state = BT_CLOSED;
b6a0dc82 1438
5a08ecce
AE		 1439 hci_proto_connect_cfm(sco, status);
1440 hci_conn_del(sco);
1441 }
b6a0dc82
MH		 1442 }
1443
1444 hci_dev_unlock(hdev);
1da177e4
LT		 1445}
1446
a9de9248 1447static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1da177e4 1448{
a9de9248
MH		 1449 struct hci_cp_sniff_mode *cp;
1450 struct hci_conn *conn;
1da177e4 1451
9f1db00c 1452 BT_DBG("%s status 0x%2.2x", hdev->name, status);
04837f64 1453
a9de9248
MH		 1454 if (!status)
1455 return;
04837f64 1456
a9de9248
MH		 1457 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
1458 if (!cp)
1459 return;
04837f64 1460
a9de9248 1461 hci_dev_lock(hdev);
04837f64 1462
a9de9248 1463 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
e73439d8 1464 if (conn) {
51a8efd7 1465 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
04837f64 1466
51a8efd7 1467 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
e73439d8
MH		 1468 hci_sco_setup(conn, status);
1469 }
1470
a9de9248
MH		 1471 hci_dev_unlock(hdev);
1472}
04837f64 1473
a9de9248
MH		 1474static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
1475{
1476 struct hci_cp_exit_sniff_mode *cp;
1477 struct hci_conn *conn;
04837f64 1478
9f1db00c 1479 BT_DBG("%s status 0x%2.2x", hdev->name, status);
04837f64 1480
a9de9248
MH		 1481 if (!status)
1482 return;
04837f64 1483
a9de9248
MH		 1484 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
1485 if (!cp)
1486 return;
04837f64 1487
a9de9248 1488 hci_dev_lock(hdev);
1da177e4 1489
a9de9248 1490 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
e73439d8 1491 if (conn) {
51a8efd7 1492 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
1da177e4 1493
51a8efd7 1494 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
e73439d8
MH		 1495 hci_sco_setup(conn, status);
1496 }
1497
a9de9248 1498 hci_dev_unlock(hdev);
1da177e4
LT		 1499}
1500
88c3df13
JH		 1501static void hci_cs_disconnect(struct hci_dev *hdev, u8 status)
1502{
1503 struct hci_cp_disconnect *cp;
1504 struct hci_conn *conn;
1505
1506 if (!status)
1507 return;
1508
1509 cp = hci_sent_cmd_data(hdev, HCI_OP_DISCONNECT);
1510 if (!cp)
1511 return;
1512
1513 hci_dev_lock(hdev);
1514
1515 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1516 if (conn)
1517 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
04124681 1518 conn->dst_type, status);
88c3df13
JH		 1519
1520 hci_dev_unlock(hdev);
1521}
1522
fcd89c09
VT		 1523static void hci_cs_le_create_conn(struct hci_dev *hdev, __u8 status)
1524{
fcd89c09
VT		 1525 struct hci_conn *conn;
1526
9f1db00c 1527 BT_DBG("%s status 0x%2.2x", hdev->name, status);
fcd89c09 1528
f00a06ac
AG		 1529 if (status) {
1530 hci_dev_lock(hdev);
fcd89c09 1531
0c95ab78 1532 conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
f00a06ac
AG		 1533 if (!conn) {
1534 hci_dev_unlock(hdev);
1535 return;
1536 }
fcd89c09 1537
6ed93dc6 1538 BT_DBG("%s bdaddr %pMR conn %p", hdev->name, &conn->dst, conn);
fcd89c09 1539
f00a06ac 1540 conn->state = BT_CLOSED;
0c95ab78 1541 mgmt_connect_failed(hdev, &conn->dst, conn->type,
f00a06ac
AG		 1542 conn->dst_type, status);
1543 hci_proto_connect_cfm(conn, status);
1544 hci_conn_del(conn);
fcd89c09 1545
f00a06ac
AG		 1546 hci_dev_unlock(hdev);
1547 }
fcd89c09
VT		 1548}
1549
a02226d6
AE		 1550static void hci_cs_create_phylink(struct hci_dev *hdev, u8 status)
1551{
93c284ee
AE		 1552 struct hci_cp_create_phy_link *cp;
1553
a02226d6 1554 BT_DBG("%s status 0x%2.2x", hdev->name, status);
93c284ee 1555
93c284ee
AE		 1556 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_PHY_LINK);
1557 if (!cp)
1558 return;
1559
e58917b9
AE		 1560 hci_dev_lock(hdev);
1561
1562 if (status) {
1563 struct hci_conn *hcon;
1564
1565 hcon = hci_conn_hash_lookup_handle(hdev, cp->phy_handle);
1566 if (hcon)
1567 hci_conn_del(hcon);
1568 } else {
1569 amp_write_remote_assoc(hdev, cp->phy_handle);
1570 }
1571
1572 hci_dev_unlock(hdev);
a02226d6
AE		 1573}
1574
0b26ab9d
AE		 1575static void hci_cs_accept_phylink(struct hci_dev *hdev, u8 status)
1576{
1577 struct hci_cp_accept_phy_link *cp;
1578
1579 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1580
1581 if (status)
1582 return;
1583
1584 cp = hci_sent_cmd_data(hdev, HCI_OP_ACCEPT_PHY_LINK);
1585 if (!cp)
1586 return;
1587
1588 amp_write_remote_assoc(hdev, cp->phy_handle);
1589}
1590
6039aa73 1591static void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4
LT		 1592{
1593 __u8 status = *((__u8 *) skb->data);
30dc78e1
JH		 1594 struct discovery_state *discov = &hdev->discovery;
1595 struct inquiry_entry *e;
1da177e4 1596
9f1db00c 1597 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 1598
a9de9248 1599 hci_conn_check_pending(hdev);
89352e7d
AG		 1600
1601 if (!test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
1602 return;
1603
3e13fa1e
AG		 1604 smp_mb__after_clear_bit(); /* wake_up_bit advises about this barrier */
1605 wake_up_bit(&hdev->flags, HCI_INQUIRY);
1606
a8b2d5c2 1607 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
30dc78e1
JH		 1608 return;
1609
56e5cb86 1610 hci_dev_lock(hdev);
30dc78e1 1611
343f935b 1612 if (discov->state != DISCOVERY_FINDING)
30dc78e1
JH		 1613 goto unlock;
1614
1615 if (list_empty(&discov->resolve)) {
1616 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1617 goto unlock;
1618 }
1619
1620 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
1621 if (e && hci_resolve_name(hdev, e) == 0) {
1622 e->name_state = NAME_PENDING;
1623 hci_discovery_set_state(hdev, DISCOVERY_RESOLVING);
1624 } else {
1625 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1626 }
1627
1628unlock:
56e5cb86 1629 hci_dev_unlock(hdev);
1da177e4
LT		 1630}
1631
6039aa73 1632static void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1633{
45bb4bf0 1634 struct inquiry_data data;
a9de9248 1635 struct inquiry_info *info = (void *) (skb->data + 1);
1da177e4
LT		 1636 int num_rsp = *((__u8 *) skb->data);
1637
1638 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1639
45bb4bf0
MH		 1640 if (!num_rsp)
1641 return;
1642
1519cc17
AG		 1643 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
1644 return;
1645
1da177e4 1646 hci_dev_lock(hdev);
45bb4bf0 1647
e17acd40 1648 for (; num_rsp; num_rsp--, info++) {
388fc8fa 1649 bool name_known, ssp;
3175405b 1650
1da177e4
LT		 1651 bacpy(&data.bdaddr, &info->bdaddr);
1652 data.pscan_rep_mode = info->pscan_rep_mode;
1653 data.pscan_period_mode = info->pscan_period_mode;
1654 data.pscan_mode = info->pscan_mode;
1655 memcpy(data.dev_class, info->dev_class, 3);
1656 data.clock_offset = info->clock_offset;
1657 data.rssi = 0x00;
41a96212 1658 data.ssp_mode = 0x00;
3175405b 1659
388fc8fa 1660 name_known = hci_inquiry_cache_update(hdev, &data, false, &ssp);
48264f06 1661 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
04124681
GP		 1662 info->dev_class, 0, !name_known, ssp, NULL,
1663 0);
1da177e4 1664 }
45bb4bf0 1665
1da177e4
LT		 1666 hci_dev_unlock(hdev);
1667}
1668
6039aa73 1669static void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1670{
a9de9248
MH		 1671 struct hci_ev_conn_complete *ev = (void *) skb->data;
1672 struct hci_conn *conn;
1da177e4
LT		 1673
1674 BT_DBG("%s", hdev->name);
1675
1676 hci_dev_lock(hdev);
1677
1678 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
9499237a
MH		 1679 if (!conn) {
1680 if (ev->link_type != SCO_LINK)
1681 goto unlock;
1682
1683 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1684 if (!conn)
1685 goto unlock;
1686
1687 conn->type = SCO_LINK;
1688 }
1da177e4
LT		 1689
1690 if (!ev->status) {
1691 conn->handle = __le16_to_cpu(ev->handle);
769be974
MH		 1692
1693 if (conn->type == ACL_LINK) {
1694 conn->state = BT_CONFIG;
1695 hci_conn_hold(conn);
a9ea3ed9
SJ		 1696
1697 if (!conn->out && !hci_conn_ssp_enabled(conn) &&
1698 !hci_find_link_key(hdev, &ev->bdaddr))
1699 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
1700 else
1701 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
769be974
MH		 1702 } else
1703 conn->state = BT_CONNECTED;
1da177e4 1704
7d0db0a3
MH		 1705 hci_conn_add_sysfs(conn);
1706
1da177e4
LT		 1707 if (test_bit(HCI_AUTH, &hdev->flags))
1708 conn->link_mode |= HCI_LM_AUTH;
1709
1710 if (test_bit(HCI_ENCRYPT, &hdev->flags))
1711 conn->link_mode |= HCI_LM_ENCRYPT;
1712
04837f64
MH		 1713 /* Get remote features */
1714 if (conn->type == ACL_LINK) {
1715 struct hci_cp_read_remote_features cp;
1716 cp.handle = ev->handle;
769be974 1717 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
04124681 1718 sizeof(cp), &cp);
04837f64
MH		 1719 }
1720
1da177e4 1721 /* Set packet type for incoming connection */
d095c1eb 1722 if (!conn->out && hdev->hci_ver < BLUETOOTH_VER_2_0) {
1da177e4
LT		 1723 struct hci_cp_change_conn_ptype cp;
1724 cp.handle = ev->handle;
a8746417 1725 cp.pkt_type = cpu_to_le16(conn->pkt_type);
04124681
GP		 1726 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE, sizeof(cp),
1727 &cp);
1da177e4 1728 }
17d5c04c 1729 } else {
1da177e4 1730 conn->state = BT_CLOSED;
17d5c04c 1731 if (conn->type == ACL_LINK)
744cf19e 1732 mgmt_connect_failed(hdev, &ev->bdaddr, conn->type,
04124681 1733 conn->dst_type, ev->status);
17d5c04c 1734 }
1da177e4 1735
e73439d8
MH		 1736 if (conn->type == ACL_LINK)
1737 hci_sco_setup(conn, ev->status);
1da177e4 1738
769be974
MH		 1739 if (ev->status) {
1740 hci_proto_connect_cfm(conn, ev->status);
1da177e4 1741 hci_conn_del(conn);
c89b6e6b
MH		 1742 } else if (ev->link_type != ACL_LINK)
1743 hci_proto_connect_cfm(conn, ev->status);
1da177e4 1744
a9de9248 1745unlock:
1da177e4 1746 hci_dev_unlock(hdev);
1da177e4 1747
a9de9248 1748 hci_conn_check_pending(hdev);
1da177e4
LT		 1749}
1750
6039aa73 1751static void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1752{
a9de9248
MH		 1753 struct hci_ev_conn_request *ev = (void *) skb->data;
1754 int mask = hdev->link_mode;
20714bfe 1755 __u8 flags = 0;
1da177e4 1756
6ed93dc6 1757 BT_DBG("%s bdaddr %pMR type 0x%x", hdev->name, &ev->bdaddr,
807deac2 1758 ev->link_type);
1da177e4 1759
20714bfe
FD		 1760 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type,
1761 &flags);
1da177e4 1762
138d22ef 1763 if ((mask & HCI_LM_ACCEPT) &&
807deac2 1764 !hci_blacklist_lookup(hdev, &ev->bdaddr)) {
a9de9248 1765 /* Connection accepted */
c7bdd502 1766 struct inquiry_entry *ie;
1da177e4 1767 struct hci_conn *conn;
1da177e4 1768
a9de9248 1769 hci_dev_lock(hdev);
b6a0dc82 1770
cc11b9c1
AE		 1771 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1772 if (ie)
c7bdd502
MH		 1773 memcpy(ie->data.dev_class, ev->dev_class, 3);
1774
8fc9ced3
GP		 1775 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type,
1776 &ev->bdaddr);
a9de9248 1777 if (!conn) {
cc11b9c1
AE		 1778 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr);
1779 if (!conn) {
893ef971 1780 BT_ERR("No memory for new connection");
a9de9248
MH		 1781 hci_dev_unlock(hdev);
1782 return;
1da177e4
LT		 1783 }
1784 }
b6a0dc82 1785
a9de9248 1786 memcpy(conn->dev_class, ev->dev_class, 3);
b6a0dc82 1787
a9de9248 1788 hci_dev_unlock(hdev);
1da177e4 1789
20714bfe
FD		 1790 if (ev->link_type == ACL_LINK ||
1791 (!(flags & HCI_PROTO_DEFER) && !lmp_esco_capable(hdev))) {
b6a0dc82 1792 struct hci_cp_accept_conn_req cp;
20714bfe 1793 conn->state = BT_CONNECT;
1da177e4 1794
b6a0dc82
MH		 1795 bacpy(&cp.bdaddr, &ev->bdaddr);
1796
1797 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
1798 cp.role = 0x00; /* Become master */
1799 else
1800 cp.role = 0x01; /* Remain slave */
1801
04124681
GP		 1802 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp),
1803 &cp);
20714bfe 1804 } else if (!(flags & HCI_PROTO_DEFER)) {
b6a0dc82 1805 struct hci_cp_accept_sync_conn_req cp;
20714bfe 1806 conn->state = BT_CONNECT;
b6a0dc82
MH		 1807
1808 bacpy(&cp.bdaddr, &ev->bdaddr);
a8746417 1809 cp.pkt_type = cpu_to_le16(conn->pkt_type);
b6a0dc82 1810
82781e63
AE		 1811 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1812 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1813 cp.max_latency = __constant_cpu_to_le16(0xffff);
b6a0dc82
MH		 1814 cp.content_format = cpu_to_le16(hdev->voice_setting);
1815 cp.retrans_effort = 0xff;
1da177e4 1816
b6a0dc82 1817 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
04124681 1818 sizeof(cp), &cp);
20714bfe
FD		 1819 } else {
1820 conn->state = BT_CONNECT2;
1821 hci_proto_connect_cfm(conn, 0);
b6a0dc82 1822 }
a9de9248
MH		 1823 } else {
1824 /* Connection rejected */
1825 struct hci_cp_reject_conn_req cp;
1da177e4 1826
a9de9248 1827 bacpy(&cp.bdaddr, &ev->bdaddr);
9f5a0d7b 1828 cp.reason = HCI_ERROR_REJ_BAD_ADDR;
a9de9248 1829 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
1da177e4 1830 }
1da177e4
LT		 1831}
1832
f0d6a0ea
MA		 1833static u8 hci_to_mgmt_reason(u8 err)
1834{
1835 switch (err) {
1836 case HCI_ERROR_CONNECTION_TIMEOUT:
1837 return MGMT_DEV_DISCONN_TIMEOUT;
1838 case HCI_ERROR_REMOTE_USER_TERM:
1839 case HCI_ERROR_REMOTE_LOW_RESOURCES:
1840 case HCI_ERROR_REMOTE_POWER_OFF:
1841 return MGMT_DEV_DISCONN_REMOTE;
1842 case HCI_ERROR_LOCAL_HOST_TERM:
1843 return MGMT_DEV_DISCONN_LOCAL_HOST;
1844 default:
1845 return MGMT_DEV_DISCONN_UNKNOWN;
1846 }
1847}
1848
6039aa73 1849static void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 1850{
a9de9248 1851 struct hci_ev_disconn_complete *ev = (void *) skb->data;
04837f64
MH		 1852 struct hci_conn *conn;
1853
9f1db00c 1854 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
04837f64
MH		 1855
1856 hci_dev_lock(hdev);
1857
1858 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
f7520543
JH		 1859 if (!conn)
1860 goto unlock;
7d0db0a3 1861
37d9ef76
JH		 1862 if (ev->status == 0)
1863 conn->state = BT_CLOSED;
04837f64 1864
b644ba33 1865 if (test_and_clear_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags) &&
807deac2 1866 (conn->type == ACL_LINK || conn->type == LE_LINK)) {
f0d6a0ea 1867 if (ev->status) {
88c3df13 1868 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
807deac2 1869 conn->dst_type, ev->status);
f0d6a0ea
MA		 1870 } else {
1871 u8 reason = hci_to_mgmt_reason(ev->reason);
1872
afc747a6 1873 mgmt_device_disconnected(hdev, &conn->dst, conn->type,
f0d6a0ea
MA		 1874 conn->dst_type, reason);
1875 }
37d9ef76 1876 }
f7520543 1877
37d9ef76 1878 if (ev->status == 0) {
6ec5bcad
VA		 1879 if (conn->type == ACL_LINK && conn->flush_key)
1880 hci_remove_link_key(hdev, &conn->dst);
37d9ef76
JH		 1881 hci_proto_disconn_cfm(conn, ev->reason);
1882 hci_conn_del(conn);
1883 }
f7520543
JH		 1884
1885unlock:
04837f64
MH		 1886 hci_dev_unlock(hdev);
1887}
1888
6039aa73 1889static void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1890{
a9de9248 1891 struct hci_ev_auth_complete *ev = (void *) skb->data;
04837f64 1892 struct hci_conn *conn;
1da177e4 1893
9f1db00c 1894 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
1da177e4
LT		 1895
1896 hci_dev_lock(hdev);
1897
04837f64 1898 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
d7556e20
WR		 1899 if (!conn)
1900 goto unlock;
1901
1902 if (!ev->status) {
aa64a8b5 1903 if (!hci_conn_ssp_enabled(conn) &&
807deac2 1904 test_bit(HCI_CONN_REAUTH_PEND, &conn->flags)) {
d7556e20 1905 BT_INFO("re-auth of legacy device is not possible.");
2a611692 1906 } else {
d7556e20
WR		 1907 conn->link_mode |= HCI_LM_AUTH;
1908 conn->sec_level = conn->pending_sec_level;
2a611692 1909 }
d7556e20 1910 } else {
bab73cb6 1911 mgmt_auth_failed(hdev, &conn->dst, conn->type, conn->dst_type,
04124681 1912 ev->status);
d7556e20 1913 }
1da177e4 1914
51a8efd7
JH		 1915 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
1916 clear_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
1da177e4 1917
d7556e20 1918 if (conn->state == BT_CONFIG) {
aa64a8b5 1919 if (!ev->status && hci_conn_ssp_enabled(conn)) {
d7556e20
WR		 1920 struct hci_cp_set_conn_encrypt cp;
1921 cp.handle = ev->handle;
1922 cp.encrypt = 0x01;
1923 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
807deac2 1924 &cp);
052b30b0 1925 } else {
d7556e20
WR		 1926 conn->state = BT_CONNECTED;
1927 hci_proto_connect_cfm(conn, ev->status);
76a68ba0 1928 hci_conn_drop(conn);
052b30b0 1929 }
d7556e20
WR		 1930 } else {
1931 hci_auth_cfm(conn, ev->status);
052b30b0 1932
d7556e20
WR		 1933 hci_conn_hold(conn);
1934 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
76a68ba0 1935 hci_conn_drop(conn);
d7556e20
WR		 1936 }
1937
51a8efd7 1938 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
d7556e20
WR		 1939 if (!ev->status) {
1940 struct hci_cp_set_conn_encrypt cp;
1941 cp.handle = ev->handle;
1942 cp.encrypt = 0x01;
1943 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
807deac2 1944 &cp);
d7556e20 1945 } else {
51a8efd7 1946 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
d7556e20 1947 hci_encrypt_cfm(conn, ev->status, 0x00);
1da177e4
LT		 1948 }
1949 }
1950
d7556e20 1951unlock:
1da177e4
LT		 1952 hci_dev_unlock(hdev);
1953}
1954
6039aa73 1955static void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1956{
127178d2
JH		 1957 struct hci_ev_remote_name *ev = (void *) skb->data;
1958 struct hci_conn *conn;
1959
a9de9248 1960 BT_DBG("%s", hdev->name);
1da177e4 1961
a9de9248 1962 hci_conn_check_pending(hdev);
127178d2
JH		 1963
1964 hci_dev_lock(hdev);
1965
b644ba33 1966 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
30dc78e1 1967
b644ba33
JH		 1968 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
1969 goto check_auth;
a88a9652 1970
b644ba33
JH		 1971 if (ev->status == 0)
1972 hci_check_pending_name(hdev, conn, &ev->bdaddr, ev->name,
04124681 1973 strnlen(ev->name, HCI_MAX_NAME_LENGTH));
b644ba33
JH		 1974 else
1975 hci_check_pending_name(hdev, conn, &ev->bdaddr, NULL, 0);
1976
1977check_auth:
79c6c70c
JH		 1978 if (!conn)
1979 goto unlock;
1980
1981 if (!hci_outgoing_auth_needed(hdev, conn))
1982 goto unlock;
1983
51a8efd7 1984 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
127178d2
JH		 1985 struct hci_cp_auth_requested cp;
1986 cp.handle = __cpu_to_le16(conn->handle);
1987 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1988 }
1989
79c6c70c 1990unlock:
127178d2 1991 hci_dev_unlock(hdev);
a9de9248
MH		 1992}
1993
6039aa73 1994static void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248
MH		 1995{
1996 struct hci_ev_encrypt_change *ev = (void *) skb->data;
1997 struct hci_conn *conn;
1998
9f1db00c 1999 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
1da177e4
LT		 2000
2001 hci_dev_lock(hdev);
2002
04837f64 2003 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 2004 if (conn) {
2005 if (!ev->status) {
ae293196
MH		 2006 if (ev->encrypt) {
2007 /* Encryption implies authentication */
2008 conn->link_mode |= HCI_LM_AUTH;
1da177e4 2009 conn->link_mode |= HCI_LM_ENCRYPT;
da85e5e5 2010 conn->sec_level = conn->pending_sec_level;
ae293196 2011 } else
1da177e4
LT		 2012 conn->link_mode &= ~HCI_LM_ENCRYPT;
2013 }
2014
51a8efd7 2015 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
1da177e4 2016
a7d7723a 2017 if (ev->status && conn->state == BT_CONNECTED) {
bed71748 2018 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
76a68ba0 2019 hci_conn_drop(conn);
a7d7723a
GP		 2020 goto unlock;
2021 }
2022
f8558555
MH		 2023 if (conn->state == BT_CONFIG) {
2024 if (!ev->status)
2025 conn->state = BT_CONNECTED;
2026
2027 hci_proto_connect_cfm(conn, ev->status);
76a68ba0 2028 hci_conn_drop(conn);
f8558555
MH		 2029 } else
2030 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
1da177e4
LT		 2031 }
2032
a7d7723a 2033unlock:
1da177e4
LT		 2034 hci_dev_unlock(hdev);
2035}
2036
6039aa73
GP		 2037static void hci_change_link_key_complete_evt(struct hci_dev *hdev,
2038 struct sk_buff *skb)
1da177e4 2039{
a9de9248 2040 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
04837f64 2041 struct hci_conn *conn;
1da177e4 2042
9f1db00c 2043 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
1da177e4
LT		 2044
2045 hci_dev_lock(hdev);
2046
04837f64 2047 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 2048 if (conn) {
2049 if (!ev->status)
2050 conn->link_mode |= HCI_LM_SECURE;
2051
51a8efd7 2052 clear_bit(HCI_CONN_AUTH_PEND, &conn->flags);
1da177e4
LT		 2053
2054 hci_key_change_cfm(conn, ev->status);
2055 }
2056
2057 hci_dev_unlock(hdev);
2058}
2059
6039aa73
GP		 2060static void hci_remote_features_evt(struct hci_dev *hdev,
2061 struct sk_buff *skb)
1da177e4 2062{
a9de9248
MH		 2063 struct hci_ev_remote_features *ev = (void *) skb->data;
2064 struct hci_conn *conn;
2065
9f1db00c 2066 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
a9de9248 2067
a9de9248
MH		 2068 hci_dev_lock(hdev);
2069
2070 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
ccd556fe
JH		 2071 if (!conn)
2072 goto unlock;
769be974 2073
ccd556fe 2074 if (!ev->status)
cad718ed 2075 memcpy(conn->features[0], ev->features, 8);
ccd556fe
JH		 2076
2077 if (conn->state != BT_CONFIG)
2078 goto unlock;
2079
2080 if (!ev->status && lmp_ssp_capable(hdev) && lmp_ssp_capable(conn)) {
2081 struct hci_cp_read_remote_ext_features cp;
2082 cp.handle = ev->handle;
2083 cp.page = 0x01;
2084 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES,
807deac2 2085 sizeof(cp), &cp);
392599b9
JH		 2086 goto unlock;
2087 }
2088
671267bf 2089 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
127178d2
JH		 2090 struct hci_cp_remote_name_req cp;
2091 memset(&cp, 0, sizeof(cp));
2092 bacpy(&cp.bdaddr, &conn->dst);
2093 cp.pscan_rep_mode = 0x02;
2094 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
b644ba33
JH		 2095 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2096 mgmt_device_connected(hdev, &conn->dst, conn->type,
04124681
GP		 2097 conn->dst_type, 0, NULL, 0,
2098 conn->dev_class);
392599b9 2099
127178d2 2100 if (!hci_outgoing_auth_needed(hdev, conn)) {
ccd556fe
JH		 2101 conn->state = BT_CONNECTED;
2102 hci_proto_connect_cfm(conn, ev->status);
76a68ba0 2103 hci_conn_drop(conn);
769be974 2104 }
a9de9248 2105
ccd556fe 2106unlock:
a9de9248 2107 hci_dev_unlock(hdev);
1da177e4
LT		 2108}
2109
6039aa73 2110static void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248
MH		 2111{
2112 struct hci_ev_cmd_complete *ev = (void *) skb->data;
9238f36a 2113 u8 status = skb->data[sizeof(*ev)];
a9de9248
MH		 2114 __u16 opcode;
2115
2116 skb_pull(skb, sizeof(*ev));
2117
2118 opcode = __le16_to_cpu(ev->opcode);
2119
2120 switch (opcode) {
2121 case HCI_OP_INQUIRY_CANCEL:
2122 hci_cc_inquiry_cancel(hdev, skb);
2123 break;
2124
4d93483b
AG		 2125 case HCI_OP_PERIODIC_INQ:
2126 hci_cc_periodic_inq(hdev, skb);
2127 break;
2128
a9de9248
MH		 2129 case HCI_OP_EXIT_PERIODIC_INQ:
2130 hci_cc_exit_periodic_inq(hdev, skb);
2131 break;
2132
2133 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
2134 hci_cc_remote_name_req_cancel(hdev, skb);
2135 break;
2136
2137 case HCI_OP_ROLE_DISCOVERY:
2138 hci_cc_role_discovery(hdev, skb);
2139 break;
2140
e4e8e37c
MH		 2141 case HCI_OP_READ_LINK_POLICY:
2142 hci_cc_read_link_policy(hdev, skb);
2143 break;
2144
a9de9248
MH		 2145 case HCI_OP_WRITE_LINK_POLICY:
2146 hci_cc_write_link_policy(hdev, skb);
2147 break;
2148
e4e8e37c
MH		 2149 case HCI_OP_READ_DEF_LINK_POLICY:
2150 hci_cc_read_def_link_policy(hdev, skb);
2151 break;
2152
2153 case HCI_OP_WRITE_DEF_LINK_POLICY:
2154 hci_cc_write_def_link_policy(hdev, skb);
2155 break;
2156
a9de9248
MH		 2157 case HCI_OP_RESET:
2158 hci_cc_reset(hdev, skb);
2159 break;
2160
2161 case HCI_OP_WRITE_LOCAL_NAME:
2162 hci_cc_write_local_name(hdev, skb);
2163 break;
2164
2165 case HCI_OP_READ_LOCAL_NAME:
2166 hci_cc_read_local_name(hdev, skb);
2167 break;
2168
2169 case HCI_OP_WRITE_AUTH_ENABLE:
2170 hci_cc_write_auth_enable(hdev, skb);
2171 break;
2172
2173 case HCI_OP_WRITE_ENCRYPT_MODE:
2174 hci_cc_write_encrypt_mode(hdev, skb);
2175 break;
2176
2177 case HCI_OP_WRITE_SCAN_ENABLE:
2178 hci_cc_write_scan_enable(hdev, skb);
2179 break;
2180
2181 case HCI_OP_READ_CLASS_OF_DEV:
2182 hci_cc_read_class_of_dev(hdev, skb);
2183 break;
2184
2185 case HCI_OP_WRITE_CLASS_OF_DEV:
2186 hci_cc_write_class_of_dev(hdev, skb);
2187 break;
2188
2189 case HCI_OP_READ_VOICE_SETTING:
2190 hci_cc_read_voice_setting(hdev, skb);
2191 break;
2192
2193 case HCI_OP_WRITE_VOICE_SETTING:
2194 hci_cc_write_voice_setting(hdev, skb);
2195 break;
2196
333140b5
MH		 2197 case HCI_OP_WRITE_SSP_MODE:
2198 hci_cc_write_ssp_mode(hdev, skb);
2199 break;
2200
a9de9248
MH		 2201 case HCI_OP_READ_LOCAL_VERSION:
2202 hci_cc_read_local_version(hdev, skb);
2203 break;
2204
2205 case HCI_OP_READ_LOCAL_COMMANDS:
2206 hci_cc_read_local_commands(hdev, skb);
2207 break;
2208
2209 case HCI_OP_READ_LOCAL_FEATURES:
2210 hci_cc_read_local_features(hdev, skb);
2211 break;
2212
971e3a4b
AG		 2213 case HCI_OP_READ_LOCAL_EXT_FEATURES:
2214 hci_cc_read_local_ext_features(hdev, skb);
2215 break;
2216
a9de9248
MH		 2217 case HCI_OP_READ_BUFFER_SIZE:
2218 hci_cc_read_buffer_size(hdev, skb);
2219 break;
2220
2221 case HCI_OP_READ_BD_ADDR:
2222 hci_cc_read_bd_addr(hdev, skb);
2223 break;
2224
f332ec66
JH		 2225 case HCI_OP_READ_PAGE_SCAN_ACTIVITY:
2226 hci_cc_read_page_scan_activity(hdev, skb);
2227 break;
2228
4a3ee763
JH		 2229 case HCI_OP_WRITE_PAGE_SCAN_ACTIVITY:
2230 hci_cc_write_page_scan_activity(hdev, skb);
2231 break;
2232
f332ec66
JH		 2233 case HCI_OP_READ_PAGE_SCAN_TYPE:
2234 hci_cc_read_page_scan_type(hdev, skb);
2235 break;
2236
4a3ee763
JH		 2237 case HCI_OP_WRITE_PAGE_SCAN_TYPE:
2238 hci_cc_write_page_scan_type(hdev, skb);
2239 break;
2240
350ee4cf
AE		 2241 case HCI_OP_READ_DATA_BLOCK_SIZE:
2242 hci_cc_read_data_block_size(hdev, skb);
2243 break;
2244
1e89cffb
AE		 2245 case HCI_OP_READ_FLOW_CONTROL_MODE:
2246 hci_cc_read_flow_control_mode(hdev, skb);
2247 break;
2248
928abaa7
AE		 2249 case HCI_OP_READ_LOCAL_AMP_INFO:
2250 hci_cc_read_local_amp_info(hdev, skb);
2251 break;
2252
903e4541
AE		 2253 case HCI_OP_READ_LOCAL_AMP_ASSOC:
2254 hci_cc_read_local_amp_assoc(hdev, skb);
2255 break;
2256
d5859e22
JH		 2257 case HCI_OP_READ_INQ_RSP_TX_POWER:
2258 hci_cc_read_inq_rsp_tx_power(hdev, skb);
2259 break;
2260
980e1a53
JH		 2261 case HCI_OP_PIN_CODE_REPLY:
2262 hci_cc_pin_code_reply(hdev, skb);
2263 break;
2264
2265 case HCI_OP_PIN_CODE_NEG_REPLY:
2266 hci_cc_pin_code_neg_reply(hdev, skb);
2267 break;
2268
c35938b2
SJ		 2269 case HCI_OP_READ_LOCAL_OOB_DATA:
2270 hci_cc_read_local_oob_data_reply(hdev, skb);
2271 break;
2272
6ed58ec5
VT		 2273 case HCI_OP_LE_READ_BUFFER_SIZE:
2274 hci_cc_le_read_buffer_size(hdev, skb);
2275 break;
2276
60e77321
JH		 2277 case HCI_OP_LE_READ_LOCAL_FEATURES:
2278 hci_cc_le_read_local_features(hdev, skb);
2279 break;
2280
8fa19098
JH		 2281 case HCI_OP_LE_READ_ADV_TX_POWER:
2282 hci_cc_le_read_adv_tx_power(hdev, skb);
2283 break;
2284
a5c29683
JH		 2285 case HCI_OP_USER_CONFIRM_REPLY:
2286 hci_cc_user_confirm_reply(hdev, skb);
2287 break;
2288
2289 case HCI_OP_USER_CONFIRM_NEG_REPLY:
2290 hci_cc_user_confirm_neg_reply(hdev, skb);
2291 break;
2292
1143d458
BG		 2293 case HCI_OP_USER_PASSKEY_REPLY:
2294 hci_cc_user_passkey_reply(hdev, skb);
2295 break;
2296
2297 case HCI_OP_USER_PASSKEY_NEG_REPLY:
2298 hci_cc_user_passkey_neg_reply(hdev, skb);
16cde993 2299 break;
07f7fa5d
AG		 2300
2301 case HCI_OP_LE_SET_SCAN_PARAM:
2302 hci_cc_le_set_scan_param(hdev, skb);
1143d458
BG		 2303 break;
2304
c1d5dc4a
JH		 2305 case HCI_OP_LE_SET_ADV_ENABLE:
2306 hci_cc_le_set_adv_enable(hdev, skb);
2307 break;
2308
eb9d91f5
AG		 2309 case HCI_OP_LE_SET_SCAN_ENABLE:
2310 hci_cc_le_set_scan_enable(hdev, skb);
2311 break;
2312
cf1d081f
JH		 2313 case HCI_OP_LE_READ_WHITE_LIST_SIZE:
2314 hci_cc_le_read_white_list_size(hdev, skb);
2315 break;
2316
9b008c04
JH		 2317 case HCI_OP_LE_READ_SUPPORTED_STATES:
2318 hci_cc_le_read_supported_states(hdev, skb);
2319 break;
2320
f9b49306
AG		 2321 case HCI_OP_WRITE_LE_HOST_SUPPORTED:
2322 hci_cc_write_le_host_supported(hdev, skb);
2323 break;
2324
93c284ee
AE		 2325 case HCI_OP_WRITE_REMOTE_AMP_ASSOC:
2326 hci_cc_write_remote_amp_assoc(hdev, skb);
2327 break;
2328
a9de9248 2329 default:
9f1db00c 2330 BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
a9de9248
MH		 2331 break;
2332 }
2333
ad82cdd1 2334 if (opcode != HCI_OP_NOP)
6bd32326
VT		 2335 del_timer(&hdev->cmd_timer);
2336
ad82cdd1 2337 hci_req_cmd_complete(hdev, opcode, status);
9238f36a 2338
dbccd791 2339 if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
a9de9248
MH		 2340 atomic_set(&hdev->cmd_cnt, 1);
2341 if (!skb_queue_empty(&hdev->cmd_q))
c347b765 2342 queue_work(hdev->workqueue, &hdev->cmd_work);
a9de9248
MH		 2343 }
2344}
2345
6039aa73 2346static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248
MH		 2347{
2348 struct hci_ev_cmd_status *ev = (void *) skb->data;
2349 __u16 opcode;
2350
2351 skb_pull(skb, sizeof(*ev));
2352
2353 opcode = __le16_to_cpu(ev->opcode);
2354
2355 switch (opcode) {
2356 case HCI_OP_INQUIRY:
2357 hci_cs_inquiry(hdev, ev->status);
2358 break;
2359
2360 case HCI_OP_CREATE_CONN:
2361 hci_cs_create_conn(hdev, ev->status);
2362 break;
2363
2364 case HCI_OP_ADD_SCO:
2365 hci_cs_add_sco(hdev, ev->status);
2366 break;
2367
f8558555
MH		 2368 case HCI_OP_AUTH_REQUESTED:
2369 hci_cs_auth_requested(hdev, ev->status);
2370 break;
2371
2372 case HCI_OP_SET_CONN_ENCRYPT:
2373 hci_cs_set_conn_encrypt(hdev, ev->status);
2374 break;
2375
a9de9248
MH		 2376 case HCI_OP_REMOTE_NAME_REQ:
2377 hci_cs_remote_name_req(hdev, ev->status);
2378 break;
2379
769be974
MH		 2380 case HCI_OP_READ_REMOTE_FEATURES:
2381 hci_cs_read_remote_features(hdev, ev->status);
2382 break;
2383
2384 case HCI_OP_READ_REMOTE_EXT_FEATURES:
2385 hci_cs_read_remote_ext_features(hdev, ev->status);
2386 break;
2387
a9de9248
MH		 2388 case HCI_OP_SETUP_SYNC_CONN:
2389 hci_cs_setup_sync_conn(hdev, ev->status);
2390 break;
2391
2392 case HCI_OP_SNIFF_MODE:
2393 hci_cs_sniff_mode(hdev, ev->status);
2394 break;
2395
2396 case HCI_OP_EXIT_SNIFF_MODE:
2397 hci_cs_exit_sniff_mode(hdev, ev->status);
2398 break;
2399
8962ee74 2400 case HCI_OP_DISCONNECT:
88c3df13 2401 hci_cs_disconnect(hdev, ev->status);
8962ee74
JH		 2402 break;
2403
fcd89c09
VT		 2404 case HCI_OP_LE_CREATE_CONN:
2405 hci_cs_le_create_conn(hdev, ev->status);
2406 break;
2407
a02226d6
AE		 2408 case HCI_OP_CREATE_PHY_LINK:
2409 hci_cs_create_phylink(hdev, ev->status);
2410 break;
2411
0b26ab9d
AE		 2412 case HCI_OP_ACCEPT_PHY_LINK:
2413 hci_cs_accept_phylink(hdev, ev->status);
2414 break;
2415
a9de9248 2416 default:
9f1db00c 2417 BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode);
a9de9248
MH		 2418 break;
2419 }
2420
ad82cdd1 2421 if (opcode != HCI_OP_NOP)
6bd32326
VT		 2422 del_timer(&hdev->cmd_timer);
2423
02350a72
JH		 2424 if (ev->status ||
2425 (hdev->sent_cmd && !bt_cb(hdev->sent_cmd)->req.event))
2426 hci_req_cmd_complete(hdev, opcode, ev->status);
9238f36a 2427
10572132 2428 if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags)) {
a9de9248
MH		 2429 atomic_set(&hdev->cmd_cnt, 1);
2430 if (!skb_queue_empty(&hdev->cmd_q))
c347b765 2431 queue_work(hdev->workqueue, &hdev->cmd_work);
a9de9248
MH		 2432 }
2433}
2434
6039aa73 2435static void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248
MH		 2436{
2437 struct hci_ev_role_change *ev = (void *) skb->data;
2438 struct hci_conn *conn;
2439
9f1db00c 2440 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
a9de9248
MH		 2441
2442 hci_dev_lock(hdev);
2443
2444 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2445 if (conn) {
2446 if (!ev->status) {
2447 if (ev->role)
2448 conn->link_mode &= ~HCI_LM_MASTER;
2449 else
2450 conn->link_mode |= HCI_LM_MASTER;
2451 }
2452
51a8efd7 2453 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->flags);
a9de9248
MH		 2454
2455 hci_role_switch_cfm(conn, ev->status, ev->role);
2456 }
2457
2458 hci_dev_unlock(hdev);
2459}
2460
6039aa73 2461static void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248
MH		 2462{
2463 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
a9de9248
MH		 2464 int i;
2465
32ac5b9b
AE		 2466 if (hdev->flow_ctl_mode != HCI_FLOW_CTL_MODE_PACKET_BASED) {
2467 BT_ERR("Wrong event for mode %d", hdev->flow_ctl_mode);
2468 return;
2469 }
2470
c5993de8 2471 if (skb->len < sizeof(*ev) || skb->len < sizeof(*ev) +
807deac2 2472 ev->num_hndl * sizeof(struct hci_comp_pkts_info)) {
a9de9248
MH		 2473 BT_DBG("%s bad parameters", hdev->name);
2474 return;
2475 }
2476
c5993de8
AE		 2477 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
2478
613a1c0c
AE		 2479 for (i = 0; i < ev->num_hndl; i++) {
2480 struct hci_comp_pkts_info *info = &ev->handles[i];
a9de9248
MH		 2481 struct hci_conn *conn;
2482 __u16 handle, count;
2483
613a1c0c
AE		 2484 handle = __le16_to_cpu(info->handle);
2485 count = __le16_to_cpu(info->count);
a9de9248
MH		 2486
2487 conn = hci_conn_hash_lookup_handle(hdev, handle);
f4280918
AE		 2488 if (!conn)
2489 continue;
2490
2491 conn->sent -= count;
2492
2493 switch (conn->type) {
2494 case ACL_LINK:
2495 hdev->acl_cnt += count;
2496 if (hdev->acl_cnt > hdev->acl_pkts)
2497 hdev->acl_cnt = hdev->acl_pkts;
2498 break;
2499
2500 case LE_LINK:
2501 if (hdev->le_pkts) {
2502 hdev->le_cnt += count;
2503 if (hdev->le_cnt > hdev->le_pkts)
2504 hdev->le_cnt = hdev->le_pkts;
2505 } else {
70f23020
AE		 2506 hdev->acl_cnt += count;
2507 if (hdev->acl_cnt > hdev->acl_pkts)
a9de9248 2508 hdev->acl_cnt = hdev->acl_pkts;
a9de9248 2509 }
f4280918
AE		 2510 break;
2511
2512 case SCO_LINK:
2513 hdev->sco_cnt += count;
2514 if (hdev->sco_cnt > hdev->sco_pkts)
2515 hdev->sco_cnt = hdev->sco_pkts;
2516 break;
2517
2518 default:
2519 BT_ERR("Unknown type %d conn %p", conn->type, conn);
2520 break;
a9de9248
MH		 2521 }
2522 }
2523
3eff45ea 2524 queue_work(hdev->workqueue, &hdev->tx_work);
a9de9248
MH		 2525}
2526
76ef7cf7
AE		 2527static struct hci_conn *__hci_conn_lookup_handle(struct hci_dev *hdev,
2528 __u16 handle)
2529{
2530 struct hci_chan *chan;
2531
2532 switch (hdev->dev_type) {
2533 case HCI_BREDR:
2534 return hci_conn_hash_lookup_handle(hdev, handle);
2535 case HCI_AMP:
2536 chan = hci_chan_lookup_handle(hdev, handle);
2537 if (chan)
2538 return chan->conn;
2539 break;
2540 default:
2541 BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type);
2542 break;
2543 }
2544
2545 return NULL;
2546}
2547
6039aa73 2548static void hci_num_comp_blocks_evt(struct hci_dev *hdev, struct sk_buff *skb)
25e89e99
AE		 2549{
2550 struct hci_ev_num_comp_blocks *ev = (void *) skb->data;
2551 int i;
2552
2553 if (hdev->flow_ctl_mode != HCI_FLOW_CTL_MODE_BLOCK_BASED) {
2554 BT_ERR("Wrong event for mode %d", hdev->flow_ctl_mode);
2555 return;
2556 }
2557
2558 if (skb->len < sizeof(*ev) || skb->len < sizeof(*ev) +
807deac2 2559 ev->num_hndl * sizeof(struct hci_comp_blocks_info)) {
25e89e99
AE		 2560 BT_DBG("%s bad parameters", hdev->name);
2561 return;
2562 }
2563
2564 BT_DBG("%s num_blocks %d num_hndl %d", hdev->name, ev->num_blocks,
807deac2 2565 ev->num_hndl);
25e89e99
AE		 2566
2567 for (i = 0; i < ev->num_hndl; i++) {
2568 struct hci_comp_blocks_info *info = &ev->handles[i];
76ef7cf7 2569 struct hci_conn *conn = NULL;
25e89e99
AE		 2570 __u16 handle, block_count;
2571
2572 handle = __le16_to_cpu(info->handle);
2573 block_count = __le16_to_cpu(info->blocks);
2574
76ef7cf7 2575 conn = __hci_conn_lookup_handle(hdev, handle);
25e89e99
AE		 2576 if (!conn)
2577 continue;
2578
2579 conn->sent -= block_count;
2580
2581 switch (conn->type) {
2582 case ACL_LINK:
bd1eb66b 2583 case AMP_LINK:
25e89e99
AE		 2584 hdev->block_cnt += block_count;
2585 if (hdev->block_cnt > hdev->num_blocks)
2586 hdev->block_cnt = hdev->num_blocks;
2587 break;
2588
2589 default:
2590 BT_ERR("Unknown type %d conn %p", conn->type, conn);
2591 break;
2592 }
2593 }
2594
2595 queue_work(hdev->workqueue, &hdev->tx_work);
2596}
2597
6039aa73 2598static void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 2599{
a9de9248 2600 struct hci_ev_mode_change *ev = (void *) skb->data;
04837f64
MH		 2601 struct hci_conn *conn;
2602
9f1db00c 2603 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
04837f64
MH		 2604
2605 hci_dev_lock(hdev);
2606
2607 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
a9de9248
MH		 2608 if (conn) {
2609 conn->mode = ev->mode;
2610 conn->interval = __le16_to_cpu(ev->interval);
2611
8fc9ced3
GP		 2612 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND,
2613 &conn->flags)) {
a9de9248 2614 if (conn->mode == HCI_CM_ACTIVE)
58a681ef 2615 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
a9de9248 2616 else
58a681ef 2617 clear_bit(HCI_CONN_POWER_SAVE, &conn->flags);
a9de9248 2618 }
e73439d8 2619
51a8efd7 2620 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
e73439d8 2621 hci_sco_setup(conn, ev->status);
04837f64
MH		 2622 }
2623
2624 hci_dev_unlock(hdev);
2625}
2626
6039aa73 2627static void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248 2628{
052b30b0
MH		 2629 struct hci_ev_pin_code_req *ev = (void *) skb->data;
2630 struct hci_conn *conn;
2631
a9de9248 2632 BT_DBG("%s", hdev->name);
052b30b0
MH		 2633
2634 hci_dev_lock(hdev);
2635
2636 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
b6f98044
WR		 2637 if (!conn)
2638 goto unlock;
2639
2640 if (conn->state == BT_CONNECTED) {
052b30b0
MH		 2641 hci_conn_hold(conn);
2642 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
76a68ba0 2643 hci_conn_drop(conn);
052b30b0
MH		 2644 }
2645
a8b2d5c2 2646 if (!test_bit(HCI_PAIRABLE, &hdev->dev_flags))
03b555e1 2647 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
807deac2 2648 sizeof(ev->bdaddr), &ev->bdaddr);
a8b2d5c2 2649 else if (test_bit(HCI_MGMT, &hdev->dev_flags)) {
a770bb5a
WR		 2650 u8 secure;
2651
2652 if (conn->pending_sec_level == BT_SECURITY_HIGH)
2653 secure = 1;
2654 else
2655 secure = 0;
2656
744cf19e 2657 mgmt_pin_code_request(hdev, &ev->bdaddr, secure);
a770bb5a 2658 }
980e1a53 2659
b6f98044 2660unlock:
052b30b0 2661 hci_dev_unlock(hdev);
a9de9248
MH		 2662}
2663
6039aa73 2664static void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248 2665{
55ed8ca1
JH		 2666 struct hci_ev_link_key_req *ev = (void *) skb->data;
2667 struct hci_cp_link_key_reply cp;
2668 struct hci_conn *conn;
2669 struct link_key *key;
2670
a9de9248 2671 BT_DBG("%s", hdev->name);
55ed8ca1 2672
a8b2d5c2 2673 if (!test_bit(HCI_LINK_KEYS, &hdev->dev_flags))
55ed8ca1
JH		 2674 return;
2675
2676 hci_dev_lock(hdev);
2677
2678 key = hci_find_link_key(hdev, &ev->bdaddr);
2679 if (!key) {
6ed93dc6
AE		 2680 BT_DBG("%s link key not found for %pMR", hdev->name,
2681 &ev->bdaddr);
55ed8ca1
JH		 2682 goto not_found;
2683 }
2684
6ed93dc6
AE		 2685 BT_DBG("%s found key type %u for %pMR", hdev->name, key->type,
2686 &ev->bdaddr);
55ed8ca1 2687
a8b2d5c2 2688 if (!test_bit(HCI_DEBUG_KEYS, &hdev->dev_flags) &&
807deac2 2689 key->type == HCI_LK_DEBUG_COMBINATION) {
55ed8ca1
JH		 2690 BT_DBG("%s ignoring debug key", hdev->name);
2691 goto not_found;
2692 }
2693
2694 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
60b83f57
WR		 2695 if (conn) {
2696 if (key->type == HCI_LK_UNAUTH_COMBINATION &&
807deac2 2697 conn->auth_type != 0xff && (conn->auth_type & 0x01)) {
60b83f57
WR		 2698 BT_DBG("%s ignoring unauthenticated key", hdev->name);
2699 goto not_found;
2700 }
55ed8ca1 2701
60b83f57 2702 if (key->type == HCI_LK_COMBINATION && key->pin_len < 16 &&
807deac2 2703 conn->pending_sec_level == BT_SECURITY_HIGH) {
8fc9ced3
GP		 2704 BT_DBG("%s ignoring key unauthenticated for high security",
2705 hdev->name);
60b83f57
WR		 2706 goto not_found;
2707 }
2708
2709 conn->key_type = key->type;
2710 conn->pin_length = key->pin_len;
55ed8ca1
JH		 2711 }
2712
2713 bacpy(&cp.bdaddr, &ev->bdaddr);
9b3b4460 2714 memcpy(cp.link_key, key->val, HCI_LINK_KEY_SIZE);
55ed8ca1
JH		 2715
2716 hci_send_cmd(hdev, HCI_OP_LINK_KEY_REPLY, sizeof(cp), &cp);
2717
2718 hci_dev_unlock(hdev);
2719
2720 return;
2721
2722not_found:
2723 hci_send_cmd(hdev, HCI_OP_LINK_KEY_NEG_REPLY, 6, &ev->bdaddr);
2724 hci_dev_unlock(hdev);
a9de9248
MH		 2725}
2726
6039aa73 2727static void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248 2728{
052b30b0
MH		 2729 struct hci_ev_link_key_notify *ev = (void *) skb->data;
2730 struct hci_conn *conn;
55ed8ca1 2731 u8 pin_len = 0;
052b30b0 2732
a9de9248 2733 BT_DBG("%s", hdev->name);
052b30b0
MH		 2734
2735 hci_dev_lock(hdev);
2736
2737 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2738 if (conn) {
2739 hci_conn_hold(conn);
2740 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
980e1a53 2741 pin_len = conn->pin_length;
13d39315
WR		 2742
2743 if (ev->key_type != HCI_LK_CHANGED_COMBINATION)
2744 conn->key_type = ev->key_type;
2745
76a68ba0 2746 hci_conn_drop(conn);
052b30b0
MH		 2747 }
2748
a8b2d5c2 2749 if (test_bit(HCI_LINK_KEYS, &hdev->dev_flags))
d25e28ab 2750 hci_add_link_key(hdev, conn, 1, &ev->bdaddr, ev->link_key,
807deac2 2751 ev->key_type, pin_len);
55ed8ca1 2752
052b30b0 2753 hci_dev_unlock(hdev);
a9de9248
MH		 2754}
2755
6039aa73 2756static void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 2757{
a9de9248 2758 struct hci_ev_clock_offset *ev = (void *) skb->data;
04837f64 2759 struct hci_conn *conn;
1da177e4 2760
9f1db00c 2761 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
1da177e4
LT		 2762
2763 hci_dev_lock(hdev);
2764
04837f64 2765 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 2766 if (conn && !ev->status) {
2767 struct inquiry_entry *ie;
2768
cc11b9c1
AE		 2769 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2770 if (ie) {
1da177e4
LT		 2771 ie->data.clock_offset = ev->clock_offset;
2772 ie->timestamp = jiffies;
2773 }
2774 }
2775
2776 hci_dev_unlock(hdev);
2777}
2778
6039aa73 2779static void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
a8746417
MH		 2780{
2781 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
2782 struct hci_conn *conn;
2783
9f1db00c 2784 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
a8746417
MH		 2785
2786 hci_dev_lock(hdev);
2787
2788 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2789 if (conn && !ev->status)
2790 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
2791
2792 hci_dev_unlock(hdev);
2793}
2794
6039aa73 2795static void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
85a1e930 2796{
a9de9248 2797 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
85a1e930
MH		 2798 struct inquiry_entry *ie;
2799
2800 BT_DBG("%s", hdev->name);
2801
2802 hci_dev_lock(hdev);
2803
cc11b9c1
AE		 2804 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2805 if (ie) {
85a1e930
MH		 2806 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
2807 ie->timestamp = jiffies;
2808 }
2809
2810 hci_dev_unlock(hdev);
2811}
2812
6039aa73
GP		 2813static void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev,
2814 struct sk_buff *skb)
a9de9248
MH		 2815{
2816 struct inquiry_data data;
2817 int num_rsp = *((__u8 *) skb->data);
388fc8fa 2818 bool name_known, ssp;
a9de9248
MH		 2819
2820 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2821
2822 if (!num_rsp)
2823 return;
2824
1519cc17
AG		 2825 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
2826 return;
2827
a9de9248
MH		 2828 hci_dev_lock(hdev);
2829
2830 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
138d22ef
SJ		 2831 struct inquiry_info_with_rssi_and_pscan_mode *info;
2832 info = (void *) (skb->data + 1);
a9de9248 2833
e17acd40 2834 for (; num_rsp; num_rsp--, info++) {
a9de9248
MH		 2835 bacpy(&data.bdaddr, &info->bdaddr);
2836 data.pscan_rep_mode = info->pscan_rep_mode;
2837 data.pscan_period_mode = info->pscan_period_mode;
2838 data.pscan_mode = info->pscan_mode;
2839 memcpy(data.dev_class, info->dev_class, 3);
2840 data.clock_offset = info->clock_offset;
2841 data.rssi = info->rssi;
41a96212 2842 data.ssp_mode = 0x00;
3175405b
JH		 2843
2844 name_known = hci_inquiry_cache_update(hdev, &data,
04124681 2845 false, &ssp);
48264f06 2846 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
04124681
GP		 2847 info->dev_class, info->rssi,
2848 !name_known, ssp, NULL, 0);
a9de9248
MH		 2849 }
2850 } else {
2851 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
2852
e17acd40 2853 for (; num_rsp; num_rsp--, info++) {
a9de9248
MH		 2854 bacpy(&data.bdaddr, &info->bdaddr);
2855 data.pscan_rep_mode = info->pscan_rep_mode;
2856 data.pscan_period_mode = info->pscan_period_mode;
2857 data.pscan_mode = 0x00;
2858 memcpy(data.dev_class, info->dev_class, 3);
2859 data.clock_offset = info->clock_offset;
2860 data.rssi = info->rssi;
41a96212 2861 data.ssp_mode = 0x00;
3175405b 2862 name_known = hci_inquiry_cache_update(hdev, &data,
04124681 2863 false, &ssp);
48264f06 2864 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
04124681
GP		 2865 info->dev_class, info->rssi,
2866 !name_known, ssp, NULL, 0);
a9de9248
MH		 2867 }
2868 }
2869
2870 hci_dev_unlock(hdev);
2871}
2872
6039aa73
GP		 2873static void hci_remote_ext_features_evt(struct hci_dev *hdev,
2874 struct sk_buff *skb)
a9de9248 2875{
41a96212
MH		 2876 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
2877 struct hci_conn *conn;
2878
a9de9248 2879 BT_DBG("%s", hdev->name);
41a96212 2880
41a96212
MH		 2881 hci_dev_lock(hdev);
2882
2883 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
ccd556fe
JH		 2884 if (!conn)
2885 goto unlock;
41a96212 2886
cad718ed
JH		 2887 if (ev->page < HCI_MAX_PAGES)
2888 memcpy(conn->features[ev->page], ev->features, 8);
2889
ccd556fe
JH		 2890 if (!ev->status && ev->page == 0x01) {
2891 struct inquiry_entry *ie;
41a96212 2892
cc11b9c1
AE		 2893 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2894 if (ie)
02b7cc62 2895 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
769be974 2896
bbb0eada 2897 if (ev->features[0] & LMP_HOST_SSP) {
58a681ef 2898 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
bbb0eada
JK		 2899 } else {
2900 /* It is mandatory by the Bluetooth specification that
2901 * Extended Inquiry Results are only used when Secure
2902 * Simple Pairing is enabled, but some devices violate
2903 * this.
2904 *
2905 * To make these devices work, the internal SSP
2906 * enabled flag needs to be cleared if the remote host
2907 * features do not indicate SSP support */
2908 clear_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
2909 }
ccd556fe
JH		 2910 }
2911
2912 if (conn->state != BT_CONFIG)
2913 goto unlock;
2914
671267bf 2915 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
127178d2
JH		 2916 struct hci_cp_remote_name_req cp;
2917 memset(&cp, 0, sizeof(cp));
2918 bacpy(&cp.bdaddr, &conn->dst);
2919 cp.pscan_rep_mode = 0x02;
2920 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
b644ba33
JH		 2921 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2922 mgmt_device_connected(hdev, &conn->dst, conn->type,
04124681
GP		 2923 conn->dst_type, 0, NULL, 0,
2924 conn->dev_class);
392599b9 2925
127178d2 2926 if (!hci_outgoing_auth_needed(hdev, conn)) {
ccd556fe
JH		 2927 conn->state = BT_CONNECTED;
2928 hci_proto_connect_cfm(conn, ev->status);
76a68ba0 2929 hci_conn_drop(conn);
41a96212
MH		 2930 }
2931
ccd556fe 2932unlock:
41a96212 2933 hci_dev_unlock(hdev);
a9de9248
MH		 2934}
2935
6039aa73
GP		 2936static void hci_sync_conn_complete_evt(struct hci_dev *hdev,
2937 struct sk_buff *skb)
a9de9248 2938{
b6a0dc82
MH		 2939 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
2940 struct hci_conn *conn;
2941
9f1db00c 2942 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
b6a0dc82
MH		 2943
2944 hci_dev_lock(hdev);
2945
2946 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
9dc0a3af
MH		 2947 if (!conn) {
2948 if (ev->link_type == ESCO_LINK)
2949 goto unlock;
2950
2951 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
2952 if (!conn)
2953 goto unlock;
2954
2955 conn->type = SCO_LINK;
2956 }
b6a0dc82 2957
732547f9
MH		 2958 switch (ev->status) {
2959 case 0x00:
b6a0dc82
MH		 2960 conn->handle = __le16_to_cpu(ev->handle);
2961 conn->state = BT_CONNECTED;
7d0db0a3
MH		 2962
2963 hci_conn_add_sysfs(conn);
732547f9
MH		 2964 break;
2965
705e5711 2966 case 0x11: /* Unsupported Feature or Parameter Value */
732547f9 2967 case 0x1c: /* SCO interval rejected */
1038a00b 2968 case 0x1a: /* Unsupported Remote Feature */
732547f9
MH		 2969 case 0x1f: /* Unspecified error */
2970 if (conn->out && conn->attempt < 2) {
2971 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
2972 (hdev->esco_type & EDR_ESCO_MASK);
2973 hci_setup_sync(conn, conn->link->handle);
2974 goto unlock;
2975 }
2976 /* fall through */
2977
2978 default:
b6a0dc82 2979 conn->state = BT_CLOSED;
732547f9
MH		 2980 break;
2981 }
b6a0dc82
MH		 2982
2983 hci_proto_connect_cfm(conn, ev->status);
2984 if (ev->status)
2985 hci_conn_del(conn);
2986
2987unlock:
2988 hci_dev_unlock(hdev);
a9de9248
MH		 2989}
2990
6039aa73
GP		 2991static void hci_extended_inquiry_result_evt(struct hci_dev *hdev,
2992 struct sk_buff *skb)
1da177e4 2993{
a9de9248
MH		 2994 struct inquiry_data data;
2995 struct extended_inquiry_info *info = (void *) (skb->data + 1);
2996 int num_rsp = *((__u8 *) skb->data);
9d939d94 2997 size_t eir_len;
1da177e4 2998
a9de9248 2999 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1da177e4 3000
a9de9248
MH		 3001 if (!num_rsp)
3002 return;
1da177e4 3003
1519cc17
AG		 3004 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
3005 return;
3006
a9de9248
MH		 3007 hci_dev_lock(hdev);
3008
e17acd40 3009 for (; num_rsp; num_rsp--, info++) {
388fc8fa 3010 bool name_known, ssp;
561aafbc 3011
a9de9248 3012 bacpy(&data.bdaddr, &info->bdaddr);
138d22ef
SJ		 3013 data.pscan_rep_mode = info->pscan_rep_mode;
3014 data.pscan_period_mode = info->pscan_period_mode;
3015 data.pscan_mode = 0x00;
a9de9248 3016 memcpy(data.dev_class, info->dev_class, 3);
138d22ef
SJ		 3017 data.clock_offset = info->clock_offset;
3018 data.rssi = info->rssi;
41a96212 3019 data.ssp_mode = 0x01;
561aafbc 3020
a8b2d5c2 3021 if (test_bit(HCI_MGMT, &hdev->dev_flags))
4ddb1930 3022 name_known = eir_has_data_type(info->data,
04124681
GP		 3023 sizeof(info->data),
3024 EIR_NAME_COMPLETE);
561aafbc
JH		 3025 else
3026 name_known = true;
3027
388fc8fa 3028 name_known = hci_inquiry_cache_update(hdev, &data, name_known,
04124681 3029 &ssp);
9d939d94 3030 eir_len = eir_get_length(info->data, sizeof(info->data));
48264f06 3031 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
04124681 3032 info->dev_class, info->rssi, !name_known,
9d939d94 3033 ssp, info->data, eir_len);
a9de9248
MH		 3034 }
3035
3036 hci_dev_unlock(hdev);
3037}
1da177e4 3038
1c2e0041
JH		 3039static void hci_key_refresh_complete_evt(struct hci_dev *hdev,
3040 struct sk_buff *skb)
3041{
3042 struct hci_ev_key_refresh_complete *ev = (void *) skb->data;
3043 struct hci_conn *conn;
3044
9f1db00c 3045 BT_DBG("%s status 0x%2.2x handle 0x%4.4x", hdev->name, ev->status,
1c2e0041
JH		 3046 __le16_to_cpu(ev->handle));
3047
3048 hci_dev_lock(hdev);
3049
3050 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
3051 if (!conn)
3052 goto unlock;
3053
3054 if (!ev->status)
3055 conn->sec_level = conn->pending_sec_level;
3056
3057 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
3058
3059 if (ev->status && conn->state == BT_CONNECTED) {
bed71748 3060 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
76a68ba0 3061 hci_conn_drop(conn);
1c2e0041
JH		 3062 goto unlock;
3063 }
3064
3065 if (conn->state == BT_CONFIG) {
3066 if (!ev->status)
3067 conn->state = BT_CONNECTED;
3068
3069 hci_proto_connect_cfm(conn, ev->status);
76a68ba0 3070 hci_conn_drop(conn);
1c2e0041
JH		 3071 } else {
3072 hci_auth_cfm(conn, ev->status);
3073
3074 hci_conn_hold(conn);
3075 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
76a68ba0 3076 hci_conn_drop(conn);
1c2e0041
JH		 3077 }
3078
3079unlock:
3080 hci_dev_unlock(hdev);
3081}
3082
6039aa73 3083static u8 hci_get_auth_req(struct hci_conn *conn)
17fa4b9d
JH		 3084{
3085 /* If remote requests dedicated bonding follow that lead */
3086 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) {
3087 /* If both remote and local IO capabilities allow MITM
3088 * protection then require it, otherwise don't */
3089 if (conn->remote_cap == 0x03 || conn->io_capability == 0x03)
3090 return 0x02;
3091 else
3092 return 0x03;
3093 }
3094
3095 /* If remote requests no-bonding follow that lead */
3096 if (conn->remote_auth == 0x00 || conn->remote_auth == 0x01)
58797bf7 3097 return conn->remote_auth | (conn->auth_type & 0x01);
17fa4b9d
JH		 3098
3099 return conn->auth_type;
3100}
3101
6039aa73 3102static void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
0493684e
MH		 3103{
3104 struct hci_ev_io_capa_request *ev = (void *) skb->data;
3105 struct hci_conn *conn;
3106
3107 BT_DBG("%s", hdev->name);
3108
3109 hci_dev_lock(hdev);
3110
3111 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
03b555e1
JH		 3112 if (!conn)
3113 goto unlock;
3114
3115 hci_conn_hold(conn);
3116
a8b2d5c2 3117 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
03b555e1
JH		 3118 goto unlock;
3119
a8b2d5c2 3120 if (test_bit(HCI_PAIRABLE, &hdev->dev_flags) ||
807deac2 3121 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
17fa4b9d
JH		 3122 struct hci_cp_io_capability_reply cp;
3123
3124 bacpy(&cp.bdaddr, &ev->bdaddr);
7a7f1e7c
HG		 3125 /* Change the IO capability from KeyboardDisplay
3126 * to DisplayYesNo as it is not supported by BT spec. */
3127 cp.capability = (conn->io_capability == 0x04) ?
3128 0x01 : conn->io_capability;
7cbc9bd9
JH		 3129 conn->auth_type = hci_get_auth_req(conn);
3130 cp.authentication = conn->auth_type;
17fa4b9d 3131
8fc9ced3
GP		 3132 if (hci_find_remote_oob_data(hdev, &conn->dst) &&
3133 (conn->out || test_bit(HCI_CONN_REMOTE_OOB, &conn->flags)))
ce85ee13
SJ		 3134 cp.oob_data = 0x01;
3135 else
3136 cp.oob_data = 0x00;
3137
17fa4b9d 3138 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_REPLY,
807deac2 3139 sizeof(cp), &cp);
03b555e1
JH		 3140 } else {
3141 struct hci_cp_io_capability_neg_reply cp;
3142
3143 bacpy(&cp.bdaddr, &ev->bdaddr);
9f5a0d7b 3144 cp.reason = HCI_ERROR_PAIRING_NOT_ALLOWED;
0493684e 3145
03b555e1 3146 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
807deac2 3147 sizeof(cp), &cp);
03b555e1
JH		 3148 }
3149
3150unlock:
3151 hci_dev_unlock(hdev);
3152}
3153
6039aa73 3154static void hci_io_capa_reply_evt(struct hci_dev *hdev, struct sk_buff *skb)
03b555e1
JH		 3155{
3156 struct hci_ev_io_capa_reply *ev = (void *) skb->data;
3157 struct hci_conn *conn;
3158
3159 BT_DBG("%s", hdev->name);
3160
3161 hci_dev_lock(hdev);
3162
3163 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3164 if (!conn)
3165 goto unlock;
3166
03b555e1 3167 conn->remote_cap = ev->capability;
03b555e1 3168 conn->remote_auth = ev->authentication;
58a681ef
JH		 3169 if (ev->oob_data)
3170 set_bit(HCI_CONN_REMOTE_OOB, &conn->flags);
03b555e1
JH		 3171
3172unlock:
0493684e
MH		 3173 hci_dev_unlock(hdev);
3174}
3175
6039aa73
GP		 3176static void hci_user_confirm_request_evt(struct hci_dev *hdev,
3177 struct sk_buff *skb)
a5c29683
JH		 3178{
3179 struct hci_ev_user_confirm_req *ev = (void *) skb->data;
55bc1a37 3180 int loc_mitm, rem_mitm, confirm_hint = 0;
7a828908 3181 struct hci_conn *conn;
a5c29683
JH		 3182
3183 BT_DBG("%s", hdev->name);
3184
3185 hci_dev_lock(hdev);
3186
a8b2d5c2 3187 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
7a828908 3188 goto unlock;
a5c29683 3189
7a828908
JH		 3190 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3191 if (!conn)
3192 goto unlock;
3193
3194 loc_mitm = (conn->auth_type & 0x01);
3195 rem_mitm = (conn->remote_auth & 0x01);
3196
3197 /* If we require MITM but the remote device can't provide that
3198 * (it has NoInputNoOutput) then reject the confirmation
3199 * request. The only exception is when we're dedicated bonding
3200 * initiators (connect_cfm_cb set) since then we always have the MITM
3201 * bit set. */
3202 if (!conn->connect_cfm_cb && loc_mitm && conn->remote_cap == 0x03) {
3203 BT_DBG("Rejecting request: remote device can't provide MITM");
3204 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_NEG_REPLY,
807deac2 3205 sizeof(ev->bdaddr), &ev->bdaddr);
7a828908
JH		 3206 goto unlock;
3207 }
3208
3209 /* If no side requires MITM protection; auto-accept */
3210 if ((!loc_mitm || conn->remote_cap == 0x03) &&
807deac2 3211 (!rem_mitm || conn->io_capability == 0x03)) {
55bc1a37
JH		 3212
3213 /* If we're not the initiators request authorization to
3214 * proceed from user space (mgmt_user_confirm with
3215 * confirm_hint set to 1). */
51a8efd7 3216 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
55bc1a37
JH		 3217 BT_DBG("Confirming auto-accept as acceptor");
3218 confirm_hint = 1;
3219 goto confirm;
3220 }
3221
9f61656a 3222 BT_DBG("Auto-accept of user confirmation with %ums delay",
807deac2 3223 hdev->auto_accept_delay);
9f61656a
JH		 3224
3225 if (hdev->auto_accept_delay > 0) {
3226 int delay = msecs_to_jiffies(hdev->auto_accept_delay);
3227 mod_timer(&conn->auto_accept_timer, jiffies + delay);
3228 goto unlock;
3229 }
3230
7a828908 3231 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY,
807deac2 3232 sizeof(ev->bdaddr), &ev->bdaddr);
7a828908
JH		 3233 goto unlock;
3234 }
3235
55bc1a37 3236confirm:
272d90df 3237 mgmt_user_confirm_request(hdev, &ev->bdaddr, ACL_LINK, 0, ev->passkey,
04124681 3238 confirm_hint);
7a828908
JH		 3239
3240unlock:
a5c29683
JH		 3241 hci_dev_unlock(hdev);
3242}
3243
6039aa73
GP		 3244static void hci_user_passkey_request_evt(struct hci_dev *hdev,
3245 struct sk_buff *skb)
1143d458
BG		 3246{
3247 struct hci_ev_user_passkey_req *ev = (void *) skb->data;
3248
3249 BT_DBG("%s", hdev->name);
3250
a8b2d5c2 3251 if (test_bit(HCI_MGMT, &hdev->dev_flags))
272d90df 3252 mgmt_user_passkey_request(hdev, &ev->bdaddr, ACL_LINK, 0);
1143d458
BG		 3253}
3254
92a25256
JH		 3255static void hci_user_passkey_notify_evt(struct hci_dev *hdev,
3256 struct sk_buff *skb)
3257{
3258 struct hci_ev_user_passkey_notify *ev = (void *) skb->data;
3259 struct hci_conn *conn;
3260
3261 BT_DBG("%s", hdev->name);
3262
3263 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3264 if (!conn)
3265 return;
3266
3267 conn->passkey_notify = __le32_to_cpu(ev->passkey);
3268 conn->passkey_entered = 0;
3269
3270 if (test_bit(HCI_MGMT, &hdev->dev_flags))
3271 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
3272 conn->dst_type, conn->passkey_notify,
3273 conn->passkey_entered);
3274}
3275
3276static void hci_keypress_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
3277{
3278 struct hci_ev_keypress_notify *ev = (void *) skb->data;
3279 struct hci_conn *conn;
3280
3281 BT_DBG("%s", hdev->name);
3282
3283 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3284 if (!conn)
3285 return;
3286
3287 switch (ev->type) {
3288 case HCI_KEYPRESS_STARTED:
3289 conn->passkey_entered = 0;
3290 return;
3291
3292 case HCI_KEYPRESS_ENTERED:
3293 conn->passkey_entered++;
3294 break;
3295
3296 case HCI_KEYPRESS_ERASED:
3297 conn->passkey_entered--;
3298 break;
3299
3300 case HCI_KEYPRESS_CLEARED:
3301 conn->passkey_entered = 0;
3302 break;
3303
3304 case HCI_KEYPRESS_COMPLETED:
3305 return;
3306 }
3307
3308 if (test_bit(HCI_MGMT, &hdev->dev_flags))
3309 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
3310 conn->dst_type, conn->passkey_notify,
3311 conn->passkey_entered);
3312}
3313
6039aa73
GP		 3314static void hci_simple_pair_complete_evt(struct hci_dev *hdev,
3315 struct sk_buff *skb)
0493684e
MH		 3316{
3317 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
3318 struct hci_conn *conn;
3319
3320 BT_DBG("%s", hdev->name);
3321
3322 hci_dev_lock(hdev);
3323
3324 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2a611692
JH		 3325 if (!conn)
3326 goto unlock;
3327
3328 /* To avoid duplicate auth_failed events to user space we check
3329 * the HCI_CONN_AUTH_PEND flag which will be set if we
3330 * initiated the authentication. A traditional auth_complete
3331 * event gets always produced as initiator and is also mapped to
3332 * the mgmt_auth_failed event */
fa1bd918 3333 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags) && ev->status)
bab73cb6 3334 mgmt_auth_failed(hdev, &conn->dst, conn->type, conn->dst_type,
04124681 3335 ev->status);
0493684e 3336
76a68ba0 3337 hci_conn_drop(conn);
2a611692
JH		 3338
3339unlock:
0493684e
MH		 3340 hci_dev_unlock(hdev);
3341}
3342
6039aa73
GP		 3343static void hci_remote_host_features_evt(struct hci_dev *hdev,
3344 struct sk_buff *skb)
41a96212
MH		 3345{
3346 struct hci_ev_remote_host_features *ev = (void *) skb->data;
3347 struct inquiry_entry *ie;
cad718ed 3348 struct hci_conn *conn;
41a96212
MH		 3349
3350 BT_DBG("%s", hdev->name);
3351
3352 hci_dev_lock(hdev);
3353
cad718ed
JH		 3354 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3355 if (conn)
3356 memcpy(conn->features[1], ev->features, 8);
3357
cc11b9c1
AE		 3358 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
3359 if (ie)
02b7cc62 3360 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
41a96212
MH		 3361
3362 hci_dev_unlock(hdev);
3363}
3364
6039aa73
GP		 3365static void hci_remote_oob_data_request_evt(struct hci_dev *hdev,
3366 struct sk_buff *skb)
2763eda6
SJ		 3367{
3368 struct hci_ev_remote_oob_data_request *ev = (void *) skb->data;
3369 struct oob_data *data;
3370
3371 BT_DBG("%s", hdev->name);
3372
3373 hci_dev_lock(hdev);
3374
a8b2d5c2 3375 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
e1ba1f15
SJ		 3376 goto unlock;
3377
2763eda6
SJ		 3378 data = hci_find_remote_oob_data(hdev, &ev->bdaddr);
3379 if (data) {
3380 struct hci_cp_remote_oob_data_reply cp;
3381
3382 bacpy(&cp.bdaddr, &ev->bdaddr);
3383 memcpy(cp.hash, data->hash, sizeof(cp.hash));
3384 memcpy(cp.randomizer, data->randomizer, sizeof(cp.randomizer));
3385
3386 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_REPLY, sizeof(cp),
807deac2 3387 &cp);
2763eda6
SJ		 3388 } else {
3389 struct hci_cp_remote_oob_data_neg_reply cp;
3390
3391 bacpy(&cp.bdaddr, &ev->bdaddr);
3392 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_NEG_REPLY, sizeof(cp),
807deac2 3393 &cp);
2763eda6
SJ		 3394 }
3395
e1ba1f15 3396unlock:
2763eda6
SJ		 3397 hci_dev_unlock(hdev);
3398}
3399
d5e91192
AE		 3400static void hci_phy_link_complete_evt(struct hci_dev *hdev,
3401 struct sk_buff *skb)
3402{
3403 struct hci_ev_phy_link_complete *ev = (void *) skb->data;
3404 struct hci_conn *hcon, *bredr_hcon;
3405
3406 BT_DBG("%s handle 0x%2.2x status 0x%2.2x", hdev->name, ev->phy_handle,
3407 ev->status);
3408
3409 hci_dev_lock(hdev);
3410
3411 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3412 if (!hcon) {
3413 hci_dev_unlock(hdev);
3414 return;
3415 }
3416
3417 if (ev->status) {
3418 hci_conn_del(hcon);
3419 hci_dev_unlock(hdev);
3420 return;
3421 }
3422
3423 bredr_hcon = hcon->amp_mgr->l2cap_conn->hcon;
3424
3425 hcon->state = BT_CONNECTED;
3426 bacpy(&hcon->dst, &bredr_hcon->dst);
3427
3428 hci_conn_hold(hcon);
3429 hcon->disc_timeout = HCI_DISCONN_TIMEOUT;
76a68ba0 3430 hci_conn_drop(hcon);
d5e91192 3431
d5e91192
AE		 3432 hci_conn_add_sysfs(hcon);
3433
cf70ff22 3434 amp_physical_cfm(bredr_hcon, hcon);
d5e91192 3435
cf70ff22 3436 hci_dev_unlock(hdev);
d5e91192
AE		 3437}
3438
27695fb4
AE		 3439static void hci_loglink_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
3440{
3441 struct hci_ev_logical_link_complete *ev = (void *) skb->data;
3442 struct hci_conn *hcon;
3443 struct hci_chan *hchan;
3444 struct amp_mgr *mgr;
3445
3446 BT_DBG("%s log_handle 0x%4.4x phy_handle 0x%2.2x status 0x%2.2x",
3447 hdev->name, le16_to_cpu(ev->handle), ev->phy_handle,
3448 ev->status);
3449
3450 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3451 if (!hcon)
3452 return;
3453
3454 /* Create AMP hchan */
3455 hchan = hci_chan_create(hcon);
3456 if (!hchan)
3457 return;
3458
3459 hchan->handle = le16_to_cpu(ev->handle);
3460
3461 BT_DBG("hcon %p mgr %p hchan %p", hcon, hcon->amp_mgr, hchan);
3462
3463 mgr = hcon->amp_mgr;
3464 if (mgr && mgr->bredr_chan) {
3465 struct l2cap_chan *bredr_chan = mgr->bredr_chan;
3466
3467 l2cap_chan_lock(bredr_chan);
3468
3469 bredr_chan->conn->mtu = hdev->block_mtu;
3470 l2cap_logical_cfm(bredr_chan, hchan, 0);
3471 hci_conn_hold(hcon);
3472
3473 l2cap_chan_unlock(bredr_chan);
3474 }
3475}
3476
606e2a10
AE		 3477static void hci_disconn_loglink_complete_evt(struct hci_dev *hdev,
3478 struct sk_buff *skb)
3479{
3480 struct hci_ev_disconn_logical_link_complete *ev = (void *) skb->data;
3481 struct hci_chan *hchan;
3482
3483 BT_DBG("%s log handle 0x%4.4x status 0x%2.2x", hdev->name,
3484 le16_to_cpu(ev->handle), ev->status);
3485
3486 if (ev->status)
3487 return;
3488
3489 hci_dev_lock(hdev);
3490
3491 hchan = hci_chan_lookup_handle(hdev, le16_to_cpu(ev->handle));
3492 if (!hchan)
3493 goto unlock;
3494
3495 amp_destroy_logical_link(hchan, ev->reason);
3496
3497unlock:
3498 hci_dev_unlock(hdev);
3499}
3500
9eef6b3a
AE		 3501static void hci_disconn_phylink_complete_evt(struct hci_dev *hdev,
3502 struct sk_buff *skb)
3503{
3504 struct hci_ev_disconn_phy_link_complete *ev = (void *) skb->data;
3505 struct hci_conn *hcon;
3506
3507 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
3508
3509 if (ev->status)
3510 return;
3511
3512 hci_dev_lock(hdev);
3513
3514 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3515 if (hcon) {
3516 hcon->state = BT_CLOSED;
3517 hci_conn_del(hcon);
3518 }
3519
3520 hci_dev_unlock(hdev);
3521}
3522
6039aa73 3523static void hci_le_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
fcd89c09
VT		 3524{
3525 struct hci_ev_le_conn_complete *ev = (void *) skb->data;
3526 struct hci_conn *conn;
3527
9f1db00c 3528 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
fcd89c09
VT		 3529
3530 hci_dev_lock(hdev);
3531
b47a09b3 3532 conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
b62f328b
VT		 3533 if (!conn) {
3534 conn = hci_conn_add(hdev, LE_LINK, &ev->bdaddr);
3535 if (!conn) {
3536 BT_ERR("No memory for new connection");
230fd16a 3537 goto unlock;
b62f328b 3538 }
29b7988a
AG		 3539
3540 conn->dst_type = ev->bdaddr_type;
b9b343d2
AG		 3541
3542 if (ev->role == LE_CONN_ROLE_MASTER) {
3543 conn->out = true;
3544 conn->link_mode |= HCI_LM_MASTER;
3545 }
b62f328b 3546 }
fcd89c09 3547
cd17decb
AG		 3548 if (ev->status) {
3549 mgmt_connect_failed(hdev, &conn->dst, conn->type,
3550 conn->dst_type, ev->status);
3551 hci_proto_connect_cfm(conn, ev->status);
3552 conn->state = BT_CLOSED;
3553 hci_conn_del(conn);
3554 goto unlock;
3555 }
3556
b644ba33
JH		 3557 if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
3558 mgmt_device_connected(hdev, &ev->bdaddr, conn->type,
04124681 3559 conn->dst_type, 0, NULL, 0, NULL);
83bc71b4 3560
7b5c0d52 3561 conn->sec_level = BT_SECURITY_LOW;
fcd89c09
VT		 3562 conn->handle = __le16_to_cpu(ev->handle);
3563 conn->state = BT_CONNECTED;
3564
fcd89c09
VT		 3565 hci_conn_add_sysfs(conn);
3566
3567 hci_proto_connect_cfm(conn, ev->status);
3568
3569unlock:
3570 hci_dev_unlock(hdev);
3571}
3572
6039aa73 3573static void hci_le_adv_report_evt(struct hci_dev *hdev, struct sk_buff *skb)
9aa04c91 3574{
e95beb41
AG		 3575 u8 num_reports = skb->data[0];
3576 void *ptr = &skb->data[1];
3c9e9195 3577 s8 rssi;
9aa04c91 3578
e95beb41
AG		 3579 while (num_reports--) {
3580 struct hci_ev_le_advertising_info *ev = ptr;
9aa04c91 3581
3c9e9195
AG		 3582 rssi = ev->data[ev->length];
3583 mgmt_device_found(hdev, &ev->bdaddr, LE_LINK, ev->bdaddr_type,
04124681 3584 NULL, rssi, 0, 1, ev->data, ev->length);
3c9e9195 3585
e95beb41 3586 ptr += sizeof(*ev) + ev->length + 1;
9aa04c91 3587 }
9aa04c91
AG		 3588}
3589
6039aa73 3590static void hci_le_ltk_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
a7a595f6
VCG		 3591{
3592 struct hci_ev_le_ltk_req *ev = (void *) skb->data;
3593 struct hci_cp_le_ltk_reply cp;
bea710fe 3594 struct hci_cp_le_ltk_neg_reply neg;
a7a595f6 3595 struct hci_conn *conn;
c9839a11 3596 struct smp_ltk *ltk;
a7a595f6 3597
9f1db00c 3598 BT_DBG("%s handle 0x%4.4x", hdev->name, __le16_to_cpu(ev->handle));
a7a595f6
VCG		 3599
3600 hci_dev_lock(hdev);
3601
3602 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
bea710fe
VCG		 3603 if (conn == NULL)
3604 goto not_found;
a7a595f6 3605
bea710fe
VCG		 3606 ltk = hci_find_ltk(hdev, ev->ediv, ev->random);
3607 if (ltk == NULL)
3608 goto not_found;
3609
3610 memcpy(cp.ltk, ltk->val, sizeof(ltk->val));
a7a595f6 3611 cp.handle = cpu_to_le16(conn->handle);
c9839a11
VCG		 3612
3613 if (ltk->authenticated)
3614 conn->sec_level = BT_SECURITY_HIGH;
a7a595f6
VCG		 3615
3616 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
3617
c9839a11
VCG		 3618 if (ltk->type & HCI_SMP_STK) {
3619 list_del(&ltk->list);
3620 kfree(ltk);
3621 }
3622
a7a595f6 3623 hci_dev_unlock(hdev);
bea710fe
VCG		 3624
3625 return;
3626
3627not_found:
3628 neg.handle = ev->handle;
3629 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(neg), &neg);
3630 hci_dev_unlock(hdev);
a7a595f6
VCG		 3631}
3632
6039aa73 3633static void hci_le_meta_evt(struct hci_dev *hdev, struct sk_buff *skb)
fcd89c09
VT		 3634{
3635 struct hci_ev_le_meta *le_ev = (void *) skb->data;
3636
3637 skb_pull(skb, sizeof(*le_ev));
3638
3639 switch (le_ev->subevent) {
3640 case HCI_EV_LE_CONN_COMPLETE:
3641 hci_le_conn_complete_evt(hdev, skb);
3642 break;
3643
9aa04c91
AG		 3644 case HCI_EV_LE_ADVERTISING_REPORT:
3645 hci_le_adv_report_evt(hdev, skb);
3646 break;
3647
a7a595f6
VCG		 3648 case HCI_EV_LE_LTK_REQ:
3649 hci_le_ltk_request_evt(hdev, skb);
3650 break;
3651
fcd89c09
VT		 3652 default:
3653 break;
3654 }
3655}
3656
9495b2ee
AE		 3657static void hci_chan_selected_evt(struct hci_dev *hdev, struct sk_buff *skb)
3658{
3659 struct hci_ev_channel_selected *ev = (void *) skb->data;
3660 struct hci_conn *hcon;
3661
3662 BT_DBG("%s handle 0x%2.2x", hdev->name, ev->phy_handle);
3663
3664 skb_pull(skb, sizeof(*ev));
3665
3666 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3667 if (!hcon)
3668 return;
3669
3670 amp_read_loc_assoc_final_data(hdev, hcon);
3671}
3672
a9de9248
MH		 3673void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
3674{
3675 struct hci_event_hdr *hdr = (void *) skb->data;
3676 __u8 event = hdr->evt;
3677
b6ddb638
JH		 3678 hci_dev_lock(hdev);
3679
3680 /* Received events are (currently) only needed when a request is
3681 * ongoing so avoid unnecessary memory allocation.
3682 */
3683 if (hdev->req_status == HCI_REQ_PEND) {
3684 kfree_skb(hdev->recv_evt);
3685 hdev->recv_evt = skb_clone(skb, GFP_KERNEL);
3686 }
3687
3688 hci_dev_unlock(hdev);
3689
a9de9248
MH		 3690 skb_pull(skb, HCI_EVENT_HDR_SIZE);
3691
02350a72
JH		 3692 if (hdev->sent_cmd && bt_cb(hdev->sent_cmd)->req.event == event) {
3693 struct hci_command_hdr *hdr = (void *) hdev->sent_cmd->data;
3694 u16 opcode = __le16_to_cpu(hdr->opcode);
3695
3696 hci_req_cmd_complete(hdev, opcode, 0);
3697 }
3698
a9de9248 3699 switch (event) {
1da177e4
LT		 3700 case HCI_EV_INQUIRY_COMPLETE:
3701 hci_inquiry_complete_evt(hdev, skb);
3702 break;
3703
3704 case HCI_EV_INQUIRY_RESULT:
3705 hci_inquiry_result_evt(hdev, skb);
3706 break;
3707
a9de9248
MH		 3708 case HCI_EV_CONN_COMPLETE:
3709 hci_conn_complete_evt(hdev, skb);
21d9e30e
MH		 3710 break;
3711
1da177e4
LT		 3712 case HCI_EV_CONN_REQUEST:
3713 hci_conn_request_evt(hdev, skb);
3714 break;
3715
1da177e4
LT		 3716 case HCI_EV_DISCONN_COMPLETE:
3717 hci_disconn_complete_evt(hdev, skb);
3718 break;
3719
1da177e4
LT		 3720 case HCI_EV_AUTH_COMPLETE:
3721 hci_auth_complete_evt(hdev, skb);
3722 break;
3723
a9de9248
MH		 3724 case HCI_EV_REMOTE_NAME:
3725 hci_remote_name_evt(hdev, skb);
3726 break;
3727
1da177e4
LT		 3728 case HCI_EV_ENCRYPT_CHANGE:
3729 hci_encrypt_change_evt(hdev, skb);
3730 break;
3731
a9de9248
MH		 3732 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
3733 hci_change_link_key_complete_evt(hdev, skb);
3734 break;
3735
3736 case HCI_EV_REMOTE_FEATURES:
3737 hci_remote_features_evt(hdev, skb);
3738 break;
3739
a9de9248
MH		 3740 case HCI_EV_CMD_COMPLETE:
3741 hci_cmd_complete_evt(hdev, skb);
3742 break;
3743
3744 case HCI_EV_CMD_STATUS:
3745 hci_cmd_status_evt(hdev, skb);
3746 break;
3747
3748 case HCI_EV_ROLE_CHANGE:
3749 hci_role_change_evt(hdev, skb);
3750 break;
3751
3752 case HCI_EV_NUM_COMP_PKTS:
3753 hci_num_comp_pkts_evt(hdev, skb);
3754 break;
3755
3756 case HCI_EV_MODE_CHANGE:
3757 hci_mode_change_evt(hdev, skb);
1da177e4
LT		 3758 break;
3759
3760 case HCI_EV_PIN_CODE_REQ:
3761 hci_pin_code_request_evt(hdev, skb);
3762 break;
3763
3764 case HCI_EV_LINK_KEY_REQ:
3765 hci_link_key_request_evt(hdev, skb);
3766 break;
3767
3768 case HCI_EV_LINK_KEY_NOTIFY:
3769 hci_link_key_notify_evt(hdev, skb);
3770 break;
3771
3772 case HCI_EV_CLOCK_OFFSET:
3773 hci_clock_offset_evt(hdev, skb);
3774 break;
3775
a8746417
MH		 3776 case HCI_EV_PKT_TYPE_CHANGE:
3777 hci_pkt_type_change_evt(hdev, skb);
3778 break;
3779
85a1e930
MH		 3780 case HCI_EV_PSCAN_REP_MODE:
3781 hci_pscan_rep_mode_evt(hdev, skb);
3782 break;
3783
a9de9248
MH		 3784 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
3785 hci_inquiry_result_with_rssi_evt(hdev, skb);
04837f64
MH		 3786 break;
3787
a9de9248
MH		 3788 case HCI_EV_REMOTE_EXT_FEATURES:
3789 hci_remote_ext_features_evt(hdev, skb);
1da177e4
LT		 3790 break;
3791
a9de9248
MH		 3792 case HCI_EV_SYNC_CONN_COMPLETE:
3793 hci_sync_conn_complete_evt(hdev, skb);
3794 break;
1da177e4 3795
a9de9248
MH		 3796 case HCI_EV_EXTENDED_INQUIRY_RESULT:
3797 hci_extended_inquiry_result_evt(hdev, skb);
3798 break;
1da177e4 3799
1c2e0041
JH		 3800 case HCI_EV_KEY_REFRESH_COMPLETE:
3801 hci_key_refresh_complete_evt(hdev, skb);
3802 break;
3803
0493684e
MH		 3804 case HCI_EV_IO_CAPA_REQUEST:
3805 hci_io_capa_request_evt(hdev, skb);
3806 break;
3807
03b555e1
JH		 3808 case HCI_EV_IO_CAPA_REPLY:
3809 hci_io_capa_reply_evt(hdev, skb);
3810 break;
3811
a5c29683
JH		 3812 case HCI_EV_USER_CONFIRM_REQUEST:
3813 hci_user_confirm_request_evt(hdev, skb);
3814 break;
3815
1143d458
BG		 3816 case HCI_EV_USER_PASSKEY_REQUEST:
3817 hci_user_passkey_request_evt(hdev, skb);
3818 break;
3819
92a25256
JH		 3820 case HCI_EV_USER_PASSKEY_NOTIFY:
3821 hci_user_passkey_notify_evt(hdev, skb);
3822 break;
3823
3824 case HCI_EV_KEYPRESS_NOTIFY:
3825 hci_keypress_notify_evt(hdev, skb);
3826 break;
3827
0493684e
MH		 3828 case HCI_EV_SIMPLE_PAIR_COMPLETE:
3829 hci_simple_pair_complete_evt(hdev, skb);
3830 break;
3831
41a96212
MH		 3832 case HCI_EV_REMOTE_HOST_FEATURES:
3833 hci_remote_host_features_evt(hdev, skb);
3834 break;
3835
fcd89c09
VT		 3836 case HCI_EV_LE_META:
3837 hci_le_meta_evt(hdev, skb);
3838 break;
3839
9495b2ee
AE		 3840 case HCI_EV_CHANNEL_SELECTED:
3841 hci_chan_selected_evt(hdev, skb);
3842 break;
3843
2763eda6
SJ		 3844 case HCI_EV_REMOTE_OOB_DATA_REQUEST:
3845 hci_remote_oob_data_request_evt(hdev, skb);
3846 break;
3847
d5e91192
AE		 3848 case HCI_EV_PHY_LINK_COMPLETE:
3849 hci_phy_link_complete_evt(hdev, skb);
3850 break;
3851
27695fb4
AE		 3852 case HCI_EV_LOGICAL_LINK_COMPLETE:
3853 hci_loglink_complete_evt(hdev, skb);
3854 break;
3855
606e2a10
AE		 3856 case HCI_EV_DISCONN_LOGICAL_LINK_COMPLETE:
3857 hci_disconn_loglink_complete_evt(hdev, skb);
3858 break;
3859
9eef6b3a
AE		 3860 case HCI_EV_DISCONN_PHY_LINK_COMPLETE:
3861 hci_disconn_phylink_complete_evt(hdev, skb);
3862 break;
3863
25e89e99
AE		 3864 case HCI_EV_NUM_COMP_BLOCKS:
3865 hci_num_comp_blocks_evt(hdev, skb);
3866 break;
3867
a9de9248 3868 default:
9f1db00c 3869 BT_DBG("%s event 0x%2.2x", hdev->name, event);
1da177e4
LT		 3870 break;
3871 }
3872
3873 kfree_skb(skb);
3874 hdev->stat.evt_rx++;
3875}
kernel source for telekom puls (alcatel/mediatek)