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