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