projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Move eir_append_data() function into mgmt.c
[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;
a9de9248 198}
04837f64 199
a9de9248
MH		 200static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
201{
202 __u8 status = *((__u8 *) skb->data);
203 void *sent;
04837f64 204
9f1db00c 205 BT_DBG("%s status 0x%2.2x", hdev->name, status);
04837f64 206
a9de9248
MH		 207 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
208 if (!sent)
209 return;
04837f64 210
56e5cb86
JH		 211 hci_dev_lock(hdev);
212
f51d5b24
JH		 213 if (test_bit(HCI_MGMT, &hdev->dev_flags))
214 mgmt_set_local_name_complete(hdev, sent, status);
28cc7bde
JH		 215 else if (!status)
216 memcpy(hdev->dev_name, sent, HCI_MAX_NAME_LENGTH);
f51d5b24 217
56e5cb86 218 hci_dev_unlock(hdev);
a9de9248
MH		 219}
220
221static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
222{
223 struct hci_rp_read_local_name *rp = (void *) skb->data;
224
9f1db00c 225 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a9de9248
MH		 226
227 if (rp->status)
228 return;
229
db99b5fc
JH		 230 if (test_bit(HCI_SETUP, &hdev->dev_flags))
231 memcpy(hdev->dev_name, rp->name, HCI_MAX_NAME_LENGTH);
a9de9248
MH		 232}
233
234static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
235{
236 __u8 status = *((__u8 *) skb->data);
237 void *sent;
238
9f1db00c 239 BT_DBG("%s status 0x%2.2x", hdev->name, status);
a9de9248
MH		 240
241 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
242 if (!sent)
243 return;
244
245 if (!status) {
246 __u8 param = *((__u8 *) sent);
247
248 if (param == AUTH_ENABLED)
249 set_bit(HCI_AUTH, &hdev->flags);
250 else
251 clear_bit(HCI_AUTH, &hdev->flags);
1da177e4 252 }
a9de9248 253
33ef95ed
JH		 254 if (test_bit(HCI_MGMT, &hdev->dev_flags))
255 mgmt_auth_enable_complete(hdev, status);
1da177e4
LT		 256}
257
a9de9248 258static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 259{
a9de9248 260 __u8 status = *((__u8 *) skb->data);
1da177e4
LT		 261 void *sent;
262
9f1db00c 263 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 264
a9de9248
MH		 265 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
266 if (!sent)
267 return;
1da177e4 268
a9de9248
MH		 269 if (!status) {
270 __u8 param = *((__u8 *) sent);
271
272 if (param)
273 set_bit(HCI_ENCRYPT, &hdev->flags);
274 else
275 clear_bit(HCI_ENCRYPT, &hdev->flags);
276 }
a9de9248 277}
1da177e4 278
a9de9248
MH		 279static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
280{
36f7fc7e
JH		 281 __u8 param, status = *((__u8 *) skb->data);
282 int old_pscan, old_iscan;
a9de9248 283 void *sent;
1da177e4 284
9f1db00c 285 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 286
a9de9248
MH		 287 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
288 if (!sent)
289 return;
1da177e4 290
36f7fc7e
JH		 291 param = *((__u8 *) sent);
292
56e5cb86
JH		 293 hci_dev_lock(hdev);
294
fa1bd918 295 if (status) {
744cf19e 296 mgmt_write_scan_failed(hdev, param, status);
2d7cee58
JH		 297 hdev->discov_timeout = 0;
298 goto done;
299 }
300
0663ca2a
JH		 301 /* We need to ensure that we set this back on if someone changed
302 * the scan mode through a raw HCI socket.
303 */
304 set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags);
305
36f7fc7e
JH		 306 old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
307 old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);
308
309 if (param & SCAN_INQUIRY) {
310 set_bit(HCI_ISCAN, &hdev->flags);
311 if (!old_iscan)
744cf19e 312 mgmt_discoverable(hdev, 1);
36f7fc7e 313 } else if (old_iscan)
744cf19e 314 mgmt_discoverable(hdev, 0);
36f7fc7e
JH		 315
316 if (param & SCAN_PAGE) {
317 set_bit(HCI_PSCAN, &hdev->flags);
318 if (!old_pscan)
744cf19e 319 mgmt_connectable(hdev, 1);
36f7fc7e 320 } else if (old_pscan)
744cf19e 321 mgmt_connectable(hdev, 0);
1da177e4 322
36f7fc7e 323done:
56e5cb86 324 hci_dev_unlock(hdev);
a9de9248 325}
1da177e4 326
a9de9248
MH		 327static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
328{
329 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
1da177e4 330
9f1db00c 331 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 332
a9de9248
MH		 333 if (rp->status)
334 return;
1da177e4 335
a9de9248 336 memcpy(hdev->dev_class, rp->dev_class, 3);
1da177e4 337
a9de9248 338 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
807deac2 339 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
a9de9248 340}
1da177e4 341
a9de9248
MH		 342static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
343{
344 __u8 status = *((__u8 *) skb->data);
345 void *sent;
1da177e4 346
9f1db00c 347 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 348
a9de9248
MH		 349 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
350 if (!sent)
351 return;
1da177e4 352
7f9a903c
MH		 353 hci_dev_lock(hdev);
354
355 if (status == 0)
356 memcpy(hdev->dev_class, sent, 3);
357
358 if (test_bit(HCI_MGMT, &hdev->dev_flags))
359 mgmt_set_class_of_dev_complete(hdev, sent, status);
360
361 hci_dev_unlock(hdev);
a9de9248 362}
1da177e4 363
a9de9248
MH		 364static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
365{
366 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
367 __u16 setting;
368
9f1db00c 369 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a9de9248
MH		 370
371 if (rp->status)
372 return;
373
374 setting = __le16_to_cpu(rp->voice_setting);
375
f383f275 376 if (hdev->voice_setting == setting)
a9de9248
MH		 377 return;
378
379 hdev->voice_setting = setting;
380
9f1db00c 381 BT_DBG("%s voice setting 0x%4.4x", hdev->name, setting);
a9de9248 382
3c54711c 383 if (hdev->notify)
a9de9248 384 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
a9de9248
MH		 385}
386
8fc9ced3
GP		 387static void hci_cc_write_voice_setting(struct hci_dev *hdev,
388 struct sk_buff *skb)
a9de9248
MH		 389{
390 __u8 status = *((__u8 *) skb->data);
f383f275 391 __u16 setting;
a9de9248
MH		 392 void *sent;
393
9f1db00c 394 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 395
f383f275
MH		 396 if (status)
397 return;
398
a9de9248
MH		 399 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
400 if (!sent)
401 return;
1da177e4 402
f383f275 403 setting = get_unaligned_le16(sent);
1da177e4 404
f383f275
MH		 405 if (hdev->voice_setting == setting)
406 return;
407
408 hdev->voice_setting = setting;
1da177e4 409
9f1db00c 410 BT_DBG("%s voice setting 0x%4.4x", hdev->name, setting);
1da177e4 411
3c54711c 412 if (hdev->notify)
f383f275 413 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
1da177e4
LT		 414}
415
b4cb9fb2
MH		 416static void hci_cc_read_num_supported_iac(struct hci_dev *hdev,
417 struct sk_buff *skb)
418{
419 struct hci_rp_read_num_supported_iac *rp = (void *) skb->data;
420
421 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
422
423 if (rp->status)
424 return;
425
426 hdev->num_iac = rp->num_iac;
427
428 BT_DBG("%s num iac %d", hdev->name, hdev->num_iac);
429}
430
333140b5
MH		 431static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
432{
433 __u8 status = *((__u8 *) skb->data);
5ed8eb2f 434 struct hci_cp_write_ssp_mode *sent;
333140b5 435
9f1db00c 436 BT_DBG("%s status 0x%2.2x", hdev->name, status);
333140b5 437
333140b5
MH		 438 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
439 if (!sent)
440 return;
441
5ed8eb2f
JH		 442 if (!status) {
443 if (sent->mode)
cad718ed 444 hdev->features[1][0] |= LMP_HOST_SSP;
5ed8eb2f 445 else
cad718ed 446 hdev->features[1][0] &= ~LMP_HOST_SSP;
5ed8eb2f
JH		 447 }
448
ed2c4ee3 449 if (test_bit(HCI_MGMT, &hdev->dev_flags))
5ed8eb2f 450 mgmt_ssp_enable_complete(hdev, sent->mode, status);
c0ecddc2 451 else if (!status) {
5ed8eb2f 452 if (sent->mode)
c0ecddc2
JH		 453 set_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
454 else
455 clear_bit(HCI_SSP_ENABLED, &hdev->dev_flags);
456 }
333140b5
MH		 457}
458
a9de9248
MH		 459static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
460{
461 struct hci_rp_read_local_version *rp = (void *) skb->data;
1143e5a6 462
9f1db00c 463 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1143e5a6 464
a9de9248 465 if (rp->status)
42c6b129 466 return;
1143e5a6 467
a9de9248 468 hdev->hci_ver = rp->hci_ver;
e4e8e37c 469 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
d5859e22 470 hdev->lmp_ver = rp->lmp_ver;
e4e8e37c 471 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
d5859e22 472 hdev->lmp_subver = __le16_to_cpu(rp->lmp_subver);
1143e5a6 473
9f1db00c 474 BT_DBG("%s manufacturer 0x%4.4x hci ver %d:%d", hdev->name,
807deac2 475 hdev->manufacturer, hdev->hci_ver, hdev->hci_rev);
d5859e22
JH		 476}
477
8fc9ced3
GP		 478static void hci_cc_read_local_commands(struct hci_dev *hdev,
479 struct sk_buff *skb)
a9de9248
MH		 480{
481 struct hci_rp_read_local_commands *rp = (void *) skb->data;
1da177e4 482
9f1db00c 483 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 484
2177bab5
JH		 485 if (!rp->status)
486 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
a9de9248 487}
1da177e4 488
8fc9ced3
GP		 489static void hci_cc_read_local_features(struct hci_dev *hdev,
490 struct sk_buff *skb)
a9de9248
MH		 491{
492 struct hci_rp_read_local_features *rp = (void *) skb->data;
5b7f9909 493
9f1db00c 494 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 495
a9de9248
MH		 496 if (rp->status)
497 return;
5b7f9909 498
a9de9248 499 memcpy(hdev->features, rp->features, 8);
5b7f9909 500
a9de9248
MH		 501 /* Adjust default settings according to features
502 * supported by device. */
1da177e4 503
cad718ed 504 if (hdev->features[0][0] & LMP_3SLOT)
a9de9248 505 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
1da177e4 506
cad718ed 507 if (hdev->features[0][0] & LMP_5SLOT)
a9de9248 508 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
1da177e4 509
cad718ed 510 if (hdev->features[0][1] & LMP_HV2) {
a9de9248
MH		 511 hdev->pkt_type |= (HCI_HV2);
512 hdev->esco_type |= (ESCO_HV2);
513 }
1da177e4 514
cad718ed 515 if (hdev->features[0][1] & LMP_HV3) {
a9de9248
MH		 516 hdev->pkt_type |= (HCI_HV3);
517 hdev->esco_type |= (ESCO_HV3);
518 }
1da177e4 519
45db810f 520 if (lmp_esco_capable(hdev))
a9de9248 521 hdev->esco_type |= (ESCO_EV3);
da1f5198 522
cad718ed 523 if (hdev->features[0][4] & LMP_EV4)
a9de9248 524 hdev->esco_type |= (ESCO_EV4);
da1f5198 525
cad718ed 526 if (hdev->features[0][4] & LMP_EV5)
a9de9248 527 hdev->esco_type |= (ESCO_EV5);
1da177e4 528
cad718ed 529 if (hdev->features[0][5] & LMP_EDR_ESCO_2M)
efc7688b
MH		 530 hdev->esco_type |= (ESCO_2EV3);
531
cad718ed 532 if (hdev->features[0][5] & LMP_EDR_ESCO_3M)
efc7688b
MH		 533 hdev->esco_type |= (ESCO_3EV3);
534
cad718ed 535 if (hdev->features[0][5] & LMP_EDR_3S_ESCO)
efc7688b
MH		 536 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
537
a9de9248 538 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
cad718ed
JH		 539 hdev->features[0][0], hdev->features[0][1],
540 hdev->features[0][2], hdev->features[0][3],
541 hdev->features[0][4], hdev->features[0][5],
542 hdev->features[0][6], hdev->features[0][7]);
a9de9248 543}
1da177e4 544
971e3a4b 545static void hci_cc_read_local_ext_features(struct hci_dev *hdev,
807deac2 546 struct sk_buff *skb)
971e3a4b
AG		 547{
548 struct hci_rp_read_local_ext_features *rp = (void *) skb->data;
549
9f1db00c 550 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
971e3a4b
AG		 551
552 if (rp->status)
42c6b129 553 return;
971e3a4b 554
d2c5d77f
JH		 555 hdev->max_page = rp->max_page;
556
cad718ed
JH		 557 if (rp->page < HCI_MAX_PAGES)
558 memcpy(hdev->features[rp->page], rp->features, 8);
971e3a4b
AG		 559}
560
1e89cffb 561static void hci_cc_read_flow_control_mode(struct hci_dev *hdev,
807deac2 562 struct sk_buff *skb)
1e89cffb
AE		 563{
564 struct hci_rp_read_flow_control_mode *rp = (void *) skb->data;
565
9f1db00c 566 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1e89cffb 567
42c6b129
JH		 568 if (!rp->status)
569 hdev->flow_ctl_mode = rp->mode;
1e89cffb
AE		 570}
571
a9de9248
MH		 572static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
573{
574 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
1da177e4 575
9f1db00c 576 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1da177e4 577
a9de9248
MH		 578 if (rp->status)
579 return;
1da177e4 580
a9de9248
MH		 581 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
582 hdev->sco_mtu = rp->sco_mtu;
583 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
584 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
585
586 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
587 hdev->sco_mtu = 64;
588 hdev->sco_pkts = 8;
1da177e4 589 }
a9de9248
MH		 590
591 hdev->acl_cnt = hdev->acl_pkts;
592 hdev->sco_cnt = hdev->sco_pkts;
593
807deac2
GP		 594 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name, hdev->acl_mtu,
595 hdev->acl_pkts, hdev->sco_mtu, hdev->sco_pkts);
a9de9248
MH		 596}
597
598static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
599{
600 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
601
9f1db00c 602 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a9de9248
MH		 603
604 if (!rp->status)
605 bacpy(&hdev->bdaddr, &rp->bdaddr);
23bb5763
JH		 606}
607
f332ec66
JH		 608static void hci_cc_read_page_scan_activity(struct hci_dev *hdev,
609 struct sk_buff *skb)
610{
611 struct hci_rp_read_page_scan_activity *rp = (void *) skb->data;
612
613 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
614
615 if (test_bit(HCI_INIT, &hdev->flags) && !rp->status) {
616 hdev->page_scan_interval = __le16_to_cpu(rp->interval);
617 hdev->page_scan_window = __le16_to_cpu(rp->window);
618 }
619}
620
4a3ee763
JH		 621static void hci_cc_write_page_scan_activity(struct hci_dev *hdev,
622 struct sk_buff *skb)
623{
624 u8 status = *((u8 *) skb->data);
625 struct hci_cp_write_page_scan_activity *sent;
626
627 BT_DBG("%s status 0x%2.2x", hdev->name, status);
628
629 if (status)
630 return;
631
632 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_PAGE_SCAN_ACTIVITY);
633 if (!sent)
634 return;
635
636 hdev->page_scan_interval = __le16_to_cpu(sent->interval);
637 hdev->page_scan_window = __le16_to_cpu(sent->window);
638}
639
f332ec66
JH		 640static void hci_cc_read_page_scan_type(struct hci_dev *hdev,
641 struct sk_buff *skb)
642{
643 struct hci_rp_read_page_scan_type *rp = (void *) skb->data;
644
645 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
646
647 if (test_bit(HCI_INIT, &hdev->flags) && !rp->status)
648 hdev->page_scan_type = rp->type;
649}
650
4a3ee763
JH		 651static void hci_cc_write_page_scan_type(struct hci_dev *hdev,
652 struct sk_buff *skb)
653{
654 u8 status = *((u8 *) skb->data);
655 u8 *type;
656
657 BT_DBG("%s status 0x%2.2x", hdev->name, status);
658
659 if (status)
660 return;
661
662 type = hci_sent_cmd_data(hdev, HCI_OP_WRITE_PAGE_SCAN_TYPE);
663 if (type)
664 hdev->page_scan_type = *type;
665}
666
350ee4cf 667static void hci_cc_read_data_block_size(struct hci_dev *hdev,
807deac2 668 struct sk_buff *skb)
350ee4cf
AE		 669{
670 struct hci_rp_read_data_block_size *rp = (void *) skb->data;
671
9f1db00c 672 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
350ee4cf
AE		 673
674 if (rp->status)
675 return;
676
677 hdev->block_mtu = __le16_to_cpu(rp->max_acl_len);
678 hdev->block_len = __le16_to_cpu(rp->block_len);
679 hdev->num_blocks = __le16_to_cpu(rp->num_blocks);
680
681 hdev->block_cnt = hdev->num_blocks;
682
683 BT_DBG("%s blk mtu %d cnt %d len %d", hdev->name, hdev->block_mtu,
807deac2 684 hdev->block_cnt, hdev->block_len);
350ee4cf
AE		 685}
686
928abaa7 687static void hci_cc_read_local_amp_info(struct hci_dev *hdev,
807deac2 688 struct sk_buff *skb)
928abaa7
AE		 689{
690 struct hci_rp_read_local_amp_info *rp = (void *) skb->data;
691
9f1db00c 692 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
928abaa7
AE		 693
694 if (rp->status)
8e2a0d92 695 goto a2mp_rsp;
928abaa7
AE		 696
697 hdev->amp_status = rp->amp_status;
698 hdev->amp_total_bw = __le32_to_cpu(rp->total_bw);
699 hdev->amp_max_bw = __le32_to_cpu(rp->max_bw);
700 hdev->amp_min_latency = __le32_to_cpu(rp->min_latency);
701 hdev->amp_max_pdu = __le32_to_cpu(rp->max_pdu);
702 hdev->amp_type = rp->amp_type;
703 hdev->amp_pal_cap = __le16_to_cpu(rp->pal_cap);
704 hdev->amp_assoc_size = __le16_to_cpu(rp->max_assoc_size);
705 hdev->amp_be_flush_to = __le32_to_cpu(rp->be_flush_to);
706 hdev->amp_max_flush_to = __le32_to_cpu(rp->max_flush_to);
707
8e2a0d92
AE		 708a2mp_rsp:
709 a2mp_send_getinfo_rsp(hdev);
928abaa7
AE		 710}
711
903e4541
AE		 712static void hci_cc_read_local_amp_assoc(struct hci_dev *hdev,
713 struct sk_buff *skb)
714{
715 struct hci_rp_read_local_amp_assoc *rp = (void *) skb->data;
716 struct amp_assoc *assoc = &hdev->loc_assoc;
717 size_t rem_len, frag_len;
718
719 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
720
721 if (rp->status)
722 goto a2mp_rsp;
723
724 frag_len = skb->len - sizeof(*rp);
725 rem_len = __le16_to_cpu(rp->rem_len);
726
727 if (rem_len > frag_len) {
2e430be3 728 BT_DBG("frag_len %zu rem_len %zu", frag_len, rem_len);
903e4541
AE		 729
730 memcpy(assoc->data + assoc->offset, rp->frag, frag_len);
731 assoc->offset += frag_len;
732
733 /* Read other fragments */
734 amp_read_loc_assoc_frag(hdev, rp->phy_handle);
735
736 return;
737 }
738
739 memcpy(assoc->data + assoc->offset, rp->frag, rem_len);
740 assoc->len = assoc->offset + rem_len;
741 assoc->offset = 0;
742
743a2mp_rsp:
744 /* Send A2MP Rsp when all fragments are received */
745 a2mp_send_getampassoc_rsp(hdev, rp->status);
9495b2ee 746 a2mp_send_create_phy_link_req(hdev, rp->status);
903e4541
AE		 747}
748
d5859e22 749static void hci_cc_read_inq_rsp_tx_power(struct hci_dev *hdev,
807deac2 750 struct sk_buff *skb)
d5859e22 751{
91c4e9b1 752 struct hci_rp_read_inq_rsp_tx_power *rp = (void *) skb->data;
d5859e22 753
9f1db00c 754 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
91c4e9b1
MH		 755
756 if (!rp->status)
757 hdev->inq_tx_power = rp->tx_power;
d5859e22
JH		 758}
759
980e1a53
JH		 760static void hci_cc_pin_code_reply(struct hci_dev *hdev, struct sk_buff *skb)
761{
762 struct hci_rp_pin_code_reply *rp = (void *) skb->data;
763 struct hci_cp_pin_code_reply *cp;
764 struct hci_conn *conn;
765
9f1db00c 766 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
980e1a53 767
56e5cb86
JH		 768 hci_dev_lock(hdev);
769
a8b2d5c2 770 if (test_bit(HCI_MGMT, &hdev->dev_flags))
744cf19e 771 mgmt_pin_code_reply_complete(hdev, &rp->bdaddr, rp->status);
980e1a53 772
fa1bd918 773 if (rp->status)
56e5cb86 774 goto unlock;
980e1a53
JH		 775
776 cp = hci_sent_cmd_data(hdev, HCI_OP_PIN_CODE_REPLY);
777 if (!cp)
56e5cb86 778 goto unlock;
980e1a53
JH		 779
780 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
781 if (conn)
782 conn->pin_length = cp->pin_len;
56e5cb86
JH		 783
784unlock:
785 hci_dev_unlock(hdev);
980e1a53
JH		 786}
787
788static void hci_cc_pin_code_neg_reply(struct hci_dev *hdev, struct sk_buff *skb)
789{
790 struct hci_rp_pin_code_neg_reply *rp = (void *) skb->data;
791
9f1db00c 792 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
980e1a53 793
56e5cb86
JH		 794 hci_dev_lock(hdev);
795
a8b2d5c2 796 if (test_bit(HCI_MGMT, &hdev->dev_flags))
744cf19e 797 mgmt_pin_code_neg_reply_complete(hdev, &rp->bdaddr,
807deac2 798 rp->status);
56e5cb86
JH		 799
800 hci_dev_unlock(hdev);
980e1a53 801}
56e5cb86 802
6ed58ec5
VT		 803static void hci_cc_le_read_buffer_size(struct hci_dev *hdev,
804 struct sk_buff *skb)
805{
806 struct hci_rp_le_read_buffer_size *rp = (void *) skb->data;
807
9f1db00c 808 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
6ed58ec5
VT		 809
810 if (rp->status)
811 return;
812
813 hdev->le_mtu = __le16_to_cpu(rp->le_mtu);
814 hdev->le_pkts = rp->le_max_pkt;
815
816 hdev->le_cnt = hdev->le_pkts;
817
818 BT_DBG("%s le mtu %d:%d", hdev->name, hdev->le_mtu, hdev->le_pkts);
6ed58ec5 819}
980e1a53 820
60e77321
JH		 821static void hci_cc_le_read_local_features(struct hci_dev *hdev,
822 struct sk_buff *skb)
823{
824 struct hci_rp_le_read_local_features *rp = (void *) skb->data;
825
826 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
827
828 if (!rp->status)
829 memcpy(hdev->le_features, rp->features, 8);
60e77321
JH		 830}
831
8fa19098
JH		 832static void hci_cc_le_read_adv_tx_power(struct hci_dev *hdev,
833 struct sk_buff *skb)
834{
835 struct hci_rp_le_read_adv_tx_power *rp = (void *) skb->data;
836
837 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
838
04b4edcb 839 if (!rp->status)
8fa19098 840 hdev->adv_tx_power = rp->tx_power;
8fa19098
JH		 841}
842
a5c29683
JH		 843static void hci_cc_user_confirm_reply(struct hci_dev *hdev, struct sk_buff *skb)
844{
845 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
846
9f1db00c 847 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a5c29683 848
56e5cb86
JH		 849 hci_dev_lock(hdev);
850
a8b2d5c2 851 if (test_bit(HCI_MGMT, &hdev->dev_flags))
04124681
GP		 852 mgmt_user_confirm_reply_complete(hdev, &rp->bdaddr, ACL_LINK, 0,
853 rp->status);
56e5cb86
JH		 854
855 hci_dev_unlock(hdev);
a5c29683
JH		 856}
857
858static void hci_cc_user_confirm_neg_reply(struct hci_dev *hdev,
807deac2 859 struct sk_buff *skb)
a5c29683
JH		 860{
861 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
862
9f1db00c 863 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
a5c29683 864
56e5cb86
JH		 865 hci_dev_lock(hdev);
866
a8b2d5c2 867 if (test_bit(HCI_MGMT, &hdev->dev_flags))
744cf19e 868 mgmt_user_confirm_neg_reply_complete(hdev, &rp->bdaddr,
04124681 869 ACL_LINK, 0, rp->status);
56e5cb86
JH		 870
871 hci_dev_unlock(hdev);
a5c29683
JH		 872}
873
1143d458
BG		 874static void hci_cc_user_passkey_reply(struct hci_dev *hdev, struct sk_buff *skb)
875{
876 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
877
9f1db00c 878 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1143d458
BG		 879
880 hci_dev_lock(hdev);
881
a8b2d5c2 882 if (test_bit(HCI_MGMT, &hdev->dev_flags))
272d90df 883 mgmt_user_passkey_reply_complete(hdev, &rp->bdaddr, ACL_LINK,
04124681 884 0, rp->status);
1143d458
BG		 885
886 hci_dev_unlock(hdev);
887}
888
889static void hci_cc_user_passkey_neg_reply(struct hci_dev *hdev,
807deac2 890 struct sk_buff *skb)
1143d458
BG		 891{
892 struct hci_rp_user_confirm_reply *rp = (void *) skb->data;
893
9f1db00c 894 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
1143d458
BG		 895
896 hci_dev_lock(hdev);
897
a8b2d5c2 898 if (test_bit(HCI_MGMT, &hdev->dev_flags))
1143d458 899 mgmt_user_passkey_neg_reply_complete(hdev, &rp->bdaddr,
04124681 900 ACL_LINK, 0, rp->status);
1143d458
BG		 901
902 hci_dev_unlock(hdev);
903}
904
c35938b2 905static void hci_cc_read_local_oob_data_reply(struct hci_dev *hdev,
807deac2 906 struct sk_buff *skb)
c35938b2
SJ		 907{
908 struct hci_rp_read_local_oob_data *rp = (void *) skb->data;
909
9f1db00c 910 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
c35938b2 911
56e5cb86 912 hci_dev_lock(hdev);
744cf19e 913 mgmt_read_local_oob_data_reply_complete(hdev, rp->hash,
c35938b2 914 rp->randomizer, rp->status);
56e5cb86 915 hci_dev_unlock(hdev);
c35938b2
SJ		 916}
917
c1d5dc4a
JH		 918static void hci_cc_le_set_adv_enable(struct hci_dev *hdev, struct sk_buff *skb)
919{
920 __u8 *sent, status = *((__u8 *) skb->data);
921
922 BT_DBG("%s status 0x%2.2x", hdev->name, status);
923
924 sent = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_ADV_ENABLE);
925 if (!sent)
926 return;
927
928 hci_dev_lock(hdev);
929
930 if (!status) {
931 if (*sent)
f3d3444a 932 set_bit(HCI_ADVERTISING, &hdev->dev_flags);
c1d5dc4a 933 else
f3d3444a 934 clear_bit(HCI_ADVERTISING, &hdev->dev_flags);
c1d5dc4a
JH		 935 }
936
04b4edcb 937 hci_dev_unlock(hdev);
c1d5dc4a
JH		 938}
939
eb9d91f5 940static void hci_cc_le_set_scan_enable(struct hci_dev *hdev,
807deac2 941 struct sk_buff *skb)
eb9d91f5
AG		 942{
943 struct hci_cp_le_set_scan_enable *cp;
944 __u8 status = *((__u8 *) skb->data);
945
9f1db00c 946 BT_DBG("%s status 0x%2.2x", hdev->name, status);
eb9d91f5 947
eb9d91f5
AG		 948 cp = hci_sent_cmd_data(hdev, HCI_OP_LE_SET_SCAN_ENABLE);
949 if (!cp)
950 return;
951
3fd319b8
AG		 952 if (status)
953 return;
954
68a8aea4 955 switch (cp->enable) {
76a388be 956 case LE_SCAN_ENABLE:
d23264a8 957 set_bit(HCI_LE_SCAN, &hdev->dev_flags);
68a8aea4
AE		 958 break;
959
76a388be 960 case LE_SCAN_DISABLE:
d23264a8 961 clear_bit(HCI_LE_SCAN, &hdev->dev_flags);
68a8aea4
AE		 962 break;
963
964 default:
965 BT_ERR("Used reserved LE_Scan_Enable param %d", cp->enable);
966 break;
35815085 967 }
eb9d91f5
AG		 968}
969
cf1d081f
JH		 970static void hci_cc_le_read_white_list_size(struct hci_dev *hdev,
971 struct sk_buff *skb)
972{
973 struct hci_rp_le_read_white_list_size *rp = (void *) skb->data;
974
975 BT_DBG("%s status 0x%2.2x size %u", hdev->name, rp->status, rp->size);
976
977 if (!rp->status)
978 hdev->le_white_list_size = rp->size;
cf1d081f
JH		 979}
980
9b008c04
JH		 981static void hci_cc_le_read_supported_states(struct hci_dev *hdev,
982 struct sk_buff *skb)
983{
984 struct hci_rp_le_read_supported_states *rp = (void *) skb->data;
985
986 BT_DBG("%s status 0x%2.2x", hdev->name, rp->status);
987
988 if (!rp->status)
989 memcpy(hdev->le_states, rp->le_states, 8);
9b008c04
JH		 990}
991
6039aa73
GP		 992static void hci_cc_write_le_host_supported(struct hci_dev *hdev,
993 struct sk_buff *skb)
f9b49306 994{
06199cf8 995 struct hci_cp_write_le_host_supported *sent;
f9b49306
AG		 996 __u8 status = *((__u8 *) skb->data);
997
9f1db00c 998 BT_DBG("%s status 0x%2.2x", hdev->name, status);
f9b49306 999
06199cf8 1000 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LE_HOST_SUPPORTED);
8f984dfa 1001 if (!sent)
f9b49306
AG		 1002 return;
1003
8f984dfa 1004 if (!status) {
416a4ae5 1005 if (sent->le) {
cad718ed 1006 hdev->features[1][0] |= LMP_HOST_LE;
416a4ae5
JH		 1007 set_bit(HCI_LE_ENABLED, &hdev->dev_flags);
1008 } else {
cad718ed 1009 hdev->features[1][0] &= ~LMP_HOST_LE;
416a4ae5 1010 clear_bit(HCI_LE_ENABLED, &hdev->dev_flags);
f3d3444a 1011 clear_bit(HCI_ADVERTISING, &hdev->dev_flags);
416a4ae5 1012 }
53b2caab
JH		 1013
1014 if (sent->simul)
cad718ed 1015 hdev->features[1][0] |= LMP_HOST_LE_BREDR;
53b2caab 1016 else
cad718ed 1017 hdev->features[1][0] &= ~LMP_HOST_LE_BREDR;
8f984dfa 1018 }
f9b49306
AG		 1019}
1020
93c284ee
AE		 1021static void hci_cc_write_remote_amp_assoc(struct hci_dev *hdev,
1022 struct sk_buff *skb)
1023{
1024 struct hci_rp_write_remote_amp_assoc *rp = (void *) skb->data;
1025
1026 BT_DBG("%s status 0x%2.2x phy_handle 0x%2.2x",
1027 hdev->name, rp->status, rp->phy_handle);
1028
1029 if (rp->status)
1030 return;
1031
1032 amp_write_rem_assoc_continue(hdev, rp->phy_handle);
1033}
1034
6039aa73 1035static void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
a9de9248 1036{
9f1db00c 1037 BT_DBG("%s status 0x%2.2x", hdev->name, status);
a9de9248
MH		 1038
1039 if (status) {
a9de9248 1040 hci_conn_check_pending(hdev);
314b2381
JH		 1041 return;
1042 }
1043
89352e7d 1044 set_bit(HCI_INQUIRY, &hdev->flags);
1da177e4
LT		 1045}
1046
6039aa73 1047static void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
1da177e4 1048{
a9de9248 1049 struct hci_cp_create_conn *cp;
1da177e4 1050 struct hci_conn *conn;
1da177e4 1051
9f1db00c 1052 BT_DBG("%s status 0x%2.2x", hdev->name, status);
a9de9248
MH		 1053
1054 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
1da177e4
LT		 1055 if (!cp)
1056 return;
1057
1058 hci_dev_lock(hdev);
1059
1060 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1061
6ed93dc6 1062 BT_DBG("%s bdaddr %pMR hcon %p", hdev->name, &cp->bdaddr, conn);
1da177e4
LT		 1063
1064 if (status) {
1065 if (conn && conn->state == BT_CONNECT) {
4c67bc74
MH		 1066 if (status != 0x0c || conn->attempt > 2) {
1067 conn->state = BT_CLOSED;
1068 hci_proto_connect_cfm(conn, status);
1069 hci_conn_del(conn);
1070 } else
1071 conn->state = BT_CONNECT2;
1da177e4
LT		 1072 }
1073 } else {
1074 if (!conn) {
1075 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
1076 if (conn) {
a0c808b3 1077 conn->out = true;
1da177e4
LT		 1078 conn->link_mode |= HCI_LM_MASTER;
1079 } else
893ef971 1080 BT_ERR("No memory for new connection");
1da177e4
LT		 1081 }
1082 }
1083
1084 hci_dev_unlock(hdev);
1085}
1086
a9de9248 1087static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
1da177e4 1088{
a9de9248
MH		 1089 struct hci_cp_add_sco *cp;
1090 struct hci_conn *acl, *sco;
1091 __u16 handle;
1da177e4 1092
9f1db00c 1093 BT_DBG("%s status 0x%2.2x", hdev->name, status);
b6a0dc82 1094
a9de9248
MH		 1095 if (!status)
1096 return;
1da177e4 1097
a9de9248
MH		 1098 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
1099 if (!cp)
1100 return;
1da177e4 1101
a9de9248 1102 handle = __le16_to_cpu(cp->handle);
1da177e4 1103
9f1db00c 1104 BT_DBG("%s handle 0x%4.4x", hdev->name, handle);
1da177e4 1105
a9de9248 1106 hci_dev_lock(hdev);
1da177e4 1107
a9de9248 1108 acl = hci_conn_hash_lookup_handle(hdev, handle);
5a08ecce
AE		 1109 if (acl) {
1110 sco = acl->link;
1111 if (sco) {
1112 sco->state = BT_CLOSED;
1da177e4 1113
5a08ecce
AE		 1114 hci_proto_connect_cfm(sco, status);
1115 hci_conn_del(sco);
1116 }
a9de9248 1117 }
1da177e4 1118
a9de9248
MH		 1119 hci_dev_unlock(hdev);
1120}
1da177e4 1121
f8558555
MH		 1122static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
1123{
1124 struct hci_cp_auth_requested *cp;
1125 struct hci_conn *conn;
1126
9f1db00c 1127 BT_DBG("%s status 0x%2.2x", hdev->name, status);
f8558555
MH		 1128
1129 if (!status)
1130 return;
1131
1132 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
1133 if (!cp)
1134 return;
1135
1136 hci_dev_lock(hdev);
1137
1138 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1139 if (conn) {
1140 if (conn->state == BT_CONFIG) {
1141 hci_proto_connect_cfm(conn, status);
76a68ba0 1142 hci_conn_drop(conn);
f8558555
MH		 1143 }
1144 }
1145
1146 hci_dev_unlock(hdev);
1147}
1148
1149static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
1150{
1151 struct hci_cp_set_conn_encrypt *cp;
1152 struct hci_conn *conn;
1153
9f1db00c 1154 BT_DBG("%s status 0x%2.2x", hdev->name, status);
f8558555
MH		 1155
1156 if (!status)
1157 return;
1158
1159 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
1160 if (!cp)
1161 return;
1162
1163 hci_dev_lock(hdev);
1164
1165 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1166 if (conn) {
1167 if (conn->state == BT_CONFIG) {
1168 hci_proto_connect_cfm(conn, status);
76a68ba0 1169 hci_conn_drop(conn);
f8558555
MH		 1170 }
1171 }
1172
1173 hci_dev_unlock(hdev);
1174}
1175
127178d2 1176static int hci_outgoing_auth_needed(struct hci_dev *hdev,
807deac2 1177 struct hci_conn *conn)
392599b9 1178{
392599b9
JH		 1179 if (conn->state != BT_CONFIG || !conn->out)
1180 return 0;
1181
765c2a96 1182 if (conn->pending_sec_level == BT_SECURITY_SDP)
392599b9
JH		 1183 return 0;
1184
1185 /* Only request authentication for SSP connections or non-SSP
e9bf2bf0 1186 * devices with sec_level HIGH or if MITM protection is requested */
807deac2
GP		 1187 if (!hci_conn_ssp_enabled(conn) && !(conn->auth_type & 0x01) &&
1188 conn->pending_sec_level != BT_SECURITY_HIGH)
392599b9
JH		 1189 return 0;
1190
392599b9
JH		 1191 return 1;
1192}
1193
6039aa73 1194static int hci_resolve_name(struct hci_dev *hdev,
04124681 1195 struct inquiry_entry *e)
30dc78e1
JH		 1196{
1197 struct hci_cp_remote_name_req cp;
1198
1199 memset(&cp, 0, sizeof(cp));
1200
1201 bacpy(&cp.bdaddr, &e->data.bdaddr);
1202 cp.pscan_rep_mode = e->data.pscan_rep_mode;
1203 cp.pscan_mode = e->data.pscan_mode;
1204 cp.clock_offset = e->data.clock_offset;
1205
1206 return hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
1207}
1208
b644ba33 1209static bool hci_resolve_next_name(struct hci_dev *hdev)
30dc78e1
JH		 1210{
1211 struct discovery_state *discov = &hdev->discovery;
1212 struct inquiry_entry *e;
1213
b644ba33
JH		 1214 if (list_empty(&discov->resolve))
1215 return false;
1216
1217 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
c810089c
RM		 1218 if (!e)
1219 return false;
1220
b644ba33
JH		 1221 if (hci_resolve_name(hdev, e) == 0) {
1222 e->name_state = NAME_PENDING;
1223 return true;
1224 }
1225
1226 return false;
1227}
1228
1229static void hci_check_pending_name(struct hci_dev *hdev, struct hci_conn *conn,
04124681 1230 bdaddr_t *bdaddr, u8 *name, u8 name_len)
b644ba33
JH		 1231{
1232 struct discovery_state *discov = &hdev->discovery;
1233 struct inquiry_entry *e;
1234
1235 if (conn && !test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
04124681
GP		 1236 mgmt_device_connected(hdev, bdaddr, ACL_LINK, 0x00, 0, name,
1237 name_len, conn->dev_class);
b644ba33
JH		 1238
1239 if (discov->state == DISCOVERY_STOPPED)
1240 return;
1241
30dc78e1
JH		 1242 if (discov->state == DISCOVERY_STOPPING)
1243 goto discov_complete;
1244
1245 if (discov->state != DISCOVERY_RESOLVING)
1246 return;
1247
1248 e = hci_inquiry_cache_lookup_resolve(hdev, bdaddr, NAME_PENDING);
7cc8380e
RM		 1249 /* If the device was not found in a list of found devices names of which
1250 * are pending. there is no need to continue resolving a next name as it
1251 * will be done upon receiving another Remote Name Request Complete
1252 * Event */
1253 if (!e)
1254 return;
1255
1256 list_del(&e->list);
1257 if (name) {
30dc78e1 1258 e->name_state = NAME_KNOWN;
7cc8380e
RM		 1259 mgmt_remote_name(hdev, bdaddr, ACL_LINK, 0x00,
1260 e->data.rssi, name, name_len);
c3e7c0d9
RM		 1261 } else {
1262 e->name_state = NAME_NOT_KNOWN;
30dc78e1
JH		 1263 }
1264
b644ba33 1265 if (hci_resolve_next_name(hdev))
30dc78e1 1266 return;
30dc78e1
JH		 1267
1268discov_complete:
1269 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1270}
1271
a9de9248
MH		 1272static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
1273{
127178d2
JH		 1274 struct hci_cp_remote_name_req *cp;
1275 struct hci_conn *conn;
1276
9f1db00c 1277 BT_DBG("%s status 0x%2.2x", hdev->name, status);
127178d2
JH		 1278
1279 /* If successful wait for the name req complete event before
1280 * checking for the need to do authentication */
1281 if (!status)
1282 return;
1283
1284 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
1285 if (!cp)
1286 return;
1287
1288 hci_dev_lock(hdev);
1289
b644ba33
JH		 1290 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
1291
a8b2d5c2 1292 if (test_bit(HCI_MGMT, &hdev->dev_flags))
b644ba33 1293 hci_check_pending_name(hdev, conn, &cp->bdaddr, NULL, 0);
30dc78e1 1294
79c6c70c
JH		 1295 if (!conn)
1296 goto unlock;
1297
1298 if (!hci_outgoing_auth_needed(hdev, conn))
1299 goto unlock;
1300
51a8efd7 1301 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
c1f23a2b
JB		 1302 struct hci_cp_auth_requested auth_cp;
1303
1304 auth_cp.handle = __cpu_to_le16(conn->handle);
1305 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
1306 sizeof(auth_cp), &auth_cp);
127178d2
JH		 1307 }
1308
79c6c70c 1309unlock:
127178d2 1310 hci_dev_unlock(hdev);
a9de9248 1311}
1da177e4 1312
769be974
MH		 1313static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
1314{
1315 struct hci_cp_read_remote_features *cp;
1316 struct hci_conn *conn;
1317
9f1db00c 1318 BT_DBG("%s status 0x%2.2x", hdev->name, status);
769be974
MH		 1319
1320 if (!status)
1321 return;
1322
1323 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
1324 if (!cp)
1325 return;
1326
1327 hci_dev_lock(hdev);
1328
1329 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1330 if (conn) {
1331 if (conn->state == BT_CONFIG) {
769be974 1332 hci_proto_connect_cfm(conn, status);
76a68ba0 1333 hci_conn_drop(conn);
769be974
MH		 1334 }
1335 }
1336
1337 hci_dev_unlock(hdev);
1338}
1339
1340static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
1341{
1342 struct hci_cp_read_remote_ext_features *cp;
1343 struct hci_conn *conn;
1344
9f1db00c 1345 BT_DBG("%s status 0x%2.2x", hdev->name, status);
769be974
MH		 1346
1347 if (!status)
1348 return;
1349
1350 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
1351 if (!cp)
1352 return;
1353
1354 hci_dev_lock(hdev);
1355
1356 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1357 if (conn) {
1358 if (conn->state == BT_CONFIG) {
769be974 1359 hci_proto_connect_cfm(conn, status);
76a68ba0 1360 hci_conn_drop(conn);
769be974
MH		 1361 }
1362 }
1363
1364 hci_dev_unlock(hdev);
1365}
1366
a9de9248
MH		 1367static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
1368{
b6a0dc82
MH		 1369 struct hci_cp_setup_sync_conn *cp;
1370 struct hci_conn *acl, *sco;
1371 __u16 handle;
1372
9f1db00c 1373 BT_DBG("%s status 0x%2.2x", hdev->name, status);
b6a0dc82
MH		 1374
1375 if (!status)
1376 return;
1377
1378 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
1379 if (!cp)
1380 return;
1381
1382 handle = __le16_to_cpu(cp->handle);
1383
9f1db00c 1384 BT_DBG("%s handle 0x%4.4x", hdev->name, handle);
b6a0dc82
MH		 1385
1386 hci_dev_lock(hdev);
1387
1388 acl = hci_conn_hash_lookup_handle(hdev, handle);
5a08ecce
AE		 1389 if (acl) {
1390 sco = acl->link;
1391 if (sco) {
1392 sco->state = BT_CLOSED;
b6a0dc82 1393
5a08ecce
AE		 1394 hci_proto_connect_cfm(sco, status);
1395 hci_conn_del(sco);
1396 }
b6a0dc82
MH		 1397 }
1398
1399 hci_dev_unlock(hdev);
1da177e4
LT		 1400}
1401
a9de9248 1402static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1da177e4 1403{
a9de9248
MH		 1404 struct hci_cp_sniff_mode *cp;
1405 struct hci_conn *conn;
1da177e4 1406
9f1db00c 1407 BT_DBG("%s status 0x%2.2x", hdev->name, status);
04837f64 1408
a9de9248
MH		 1409 if (!status)
1410 return;
04837f64 1411
a9de9248
MH		 1412 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
1413 if (!cp)
1414 return;
04837f64 1415
a9de9248 1416 hci_dev_lock(hdev);
04837f64 1417
a9de9248 1418 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
e73439d8 1419 if (conn) {
51a8efd7 1420 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
04837f64 1421
51a8efd7 1422 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
e73439d8
MH		 1423 hci_sco_setup(conn, status);
1424 }
1425
a9de9248
MH		 1426 hci_dev_unlock(hdev);
1427}
04837f64 1428
a9de9248
MH		 1429static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
1430{
1431 struct hci_cp_exit_sniff_mode *cp;
1432 struct hci_conn *conn;
04837f64 1433
9f1db00c 1434 BT_DBG("%s status 0x%2.2x", hdev->name, status);
04837f64 1435
a9de9248
MH		 1436 if (!status)
1437 return;
04837f64 1438
a9de9248
MH		 1439 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
1440 if (!cp)
1441 return;
04837f64 1442
a9de9248 1443 hci_dev_lock(hdev);
1da177e4 1444
a9de9248 1445 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
e73439d8 1446 if (conn) {
51a8efd7 1447 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags);
1da177e4 1448
51a8efd7 1449 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
e73439d8
MH		 1450 hci_sco_setup(conn, status);
1451 }
1452
a9de9248 1453 hci_dev_unlock(hdev);
1da177e4
LT		 1454}
1455
88c3df13
JH		 1456static void hci_cs_disconnect(struct hci_dev *hdev, u8 status)
1457{
1458 struct hci_cp_disconnect *cp;
1459 struct hci_conn *conn;
1460
1461 if (!status)
1462 return;
1463
1464 cp = hci_sent_cmd_data(hdev, HCI_OP_DISCONNECT);
1465 if (!cp)
1466 return;
1467
1468 hci_dev_lock(hdev);
1469
1470 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
1471 if (conn)
1472 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
04124681 1473 conn->dst_type, status);
88c3df13
JH		 1474
1475 hci_dev_unlock(hdev);
1476}
1477
a02226d6
AE		 1478static void hci_cs_create_phylink(struct hci_dev *hdev, u8 status)
1479{
93c284ee
AE		 1480 struct hci_cp_create_phy_link *cp;
1481
a02226d6 1482 BT_DBG("%s status 0x%2.2x", hdev->name, status);
93c284ee 1483
93c284ee
AE		 1484 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_PHY_LINK);
1485 if (!cp)
1486 return;
1487
e58917b9
AE		 1488 hci_dev_lock(hdev);
1489
1490 if (status) {
1491 struct hci_conn *hcon;
1492
1493 hcon = hci_conn_hash_lookup_handle(hdev, cp->phy_handle);
1494 if (hcon)
1495 hci_conn_del(hcon);
1496 } else {
1497 amp_write_remote_assoc(hdev, cp->phy_handle);
1498 }
1499
1500 hci_dev_unlock(hdev);
a02226d6
AE		 1501}
1502
0b26ab9d
AE		 1503static void hci_cs_accept_phylink(struct hci_dev *hdev, u8 status)
1504{
1505 struct hci_cp_accept_phy_link *cp;
1506
1507 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1508
1509 if (status)
1510 return;
1511
1512 cp = hci_sent_cmd_data(hdev, HCI_OP_ACCEPT_PHY_LINK);
1513 if (!cp)
1514 return;
1515
1516 amp_write_remote_assoc(hdev, cp->phy_handle);
1517}
1518
6039aa73 1519static void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4
LT		 1520{
1521 __u8 status = *((__u8 *) skb->data);
30dc78e1
JH		 1522 struct discovery_state *discov = &hdev->discovery;
1523 struct inquiry_entry *e;
1da177e4 1524
9f1db00c 1525 BT_DBG("%s status 0x%2.2x", hdev->name, status);
1da177e4 1526
a9de9248 1527 hci_conn_check_pending(hdev);
89352e7d
AG		 1528
1529 if (!test_and_clear_bit(HCI_INQUIRY, &hdev->flags))
1530 return;
1531
3e13fa1e
AG		 1532 smp_mb__after_clear_bit(); /* wake_up_bit advises about this barrier */
1533 wake_up_bit(&hdev->flags, HCI_INQUIRY);
1534
a8b2d5c2 1535 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
30dc78e1
JH		 1536 return;
1537
56e5cb86 1538 hci_dev_lock(hdev);
30dc78e1 1539
343f935b 1540 if (discov->state != DISCOVERY_FINDING)
30dc78e1
JH		 1541 goto unlock;
1542
1543 if (list_empty(&discov->resolve)) {
1544 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1545 goto unlock;
1546 }
1547
1548 e = hci_inquiry_cache_lookup_resolve(hdev, BDADDR_ANY, NAME_NEEDED);
1549 if (e && hci_resolve_name(hdev, e) == 0) {
1550 e->name_state = NAME_PENDING;
1551 hci_discovery_set_state(hdev, DISCOVERY_RESOLVING);
1552 } else {
1553 hci_discovery_set_state(hdev, DISCOVERY_STOPPED);
1554 }
1555
1556unlock:
56e5cb86 1557 hci_dev_unlock(hdev);
1da177e4
LT		 1558}
1559
6039aa73 1560static void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1561{
45bb4bf0 1562 struct inquiry_data data;
a9de9248 1563 struct inquiry_info *info = (void *) (skb->data + 1);
1da177e4
LT		 1564 int num_rsp = *((__u8 *) skb->data);
1565
1566 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1567
45bb4bf0
MH		 1568 if (!num_rsp)
1569 return;
1570
1519cc17
AG		 1571 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
1572 return;
1573
1da177e4 1574 hci_dev_lock(hdev);
45bb4bf0 1575
e17acd40 1576 for (; num_rsp; num_rsp--, info++) {
388fc8fa 1577 bool name_known, ssp;
3175405b 1578
1da177e4
LT		 1579 bacpy(&data.bdaddr, &info->bdaddr);
1580 data.pscan_rep_mode = info->pscan_rep_mode;
1581 data.pscan_period_mode = info->pscan_period_mode;
1582 data.pscan_mode = info->pscan_mode;
1583 memcpy(data.dev_class, info->dev_class, 3);
1584 data.clock_offset = info->clock_offset;
1585 data.rssi = 0x00;
41a96212 1586 data.ssp_mode = 0x00;
3175405b 1587
388fc8fa 1588 name_known = hci_inquiry_cache_update(hdev, &data, false, &ssp);
48264f06 1589 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
04124681
GP		 1590 info->dev_class, 0, !name_known, ssp, NULL,
1591 0);
1da177e4 1592 }
45bb4bf0 1593
1da177e4
LT		 1594 hci_dev_unlock(hdev);
1595}
1596
6039aa73 1597static void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1598{
a9de9248
MH		 1599 struct hci_ev_conn_complete *ev = (void *) skb->data;
1600 struct hci_conn *conn;
1da177e4
LT		 1601
1602 BT_DBG("%s", hdev->name);
1603
1604 hci_dev_lock(hdev);
1605
1606 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
9499237a
MH		 1607 if (!conn) {
1608 if (ev->link_type != SCO_LINK)
1609 goto unlock;
1610
1611 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1612 if (!conn)
1613 goto unlock;
1614
1615 conn->type = SCO_LINK;
1616 }
1da177e4
LT		 1617
1618 if (!ev->status) {
1619 conn->handle = __le16_to_cpu(ev->handle);
769be974
MH		 1620
1621 if (conn->type == ACL_LINK) {
1622 conn->state = BT_CONFIG;
1623 hci_conn_hold(conn);
a9ea3ed9
SJ		 1624
1625 if (!conn->out && !hci_conn_ssp_enabled(conn) &&
1626 !hci_find_link_key(hdev, &ev->bdaddr))
1627 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
1628 else
1629 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
769be974
MH		 1630 } else
1631 conn->state = BT_CONNECTED;
1da177e4 1632
7d0db0a3
MH		 1633 hci_conn_add_sysfs(conn);
1634
1da177e4
LT		 1635 if (test_bit(HCI_AUTH, &hdev->flags))
1636 conn->link_mode |= HCI_LM_AUTH;
1637
1638 if (test_bit(HCI_ENCRYPT, &hdev->flags))
1639 conn->link_mode |= HCI_LM_ENCRYPT;
1640
04837f64
MH		 1641 /* Get remote features */
1642 if (conn->type == ACL_LINK) {
1643 struct hci_cp_read_remote_features cp;
1644 cp.handle = ev->handle;
769be974 1645 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
04124681 1646 sizeof(cp), &cp);
04837f64
MH		 1647 }
1648
1da177e4 1649 /* Set packet type for incoming connection */
d095c1eb 1650 if (!conn->out && hdev->hci_ver < BLUETOOTH_VER_2_0) {
1da177e4
LT		 1651 struct hci_cp_change_conn_ptype cp;
1652 cp.handle = ev->handle;
a8746417 1653 cp.pkt_type = cpu_to_le16(conn->pkt_type);
04124681
GP		 1654 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE, sizeof(cp),
1655 &cp);
1da177e4 1656 }
17d5c04c 1657 } else {
1da177e4 1658 conn->state = BT_CLOSED;
17d5c04c 1659 if (conn->type == ACL_LINK)
744cf19e 1660 mgmt_connect_failed(hdev, &ev->bdaddr, conn->type,
04124681 1661 conn->dst_type, ev->status);
17d5c04c 1662 }
1da177e4 1663
e73439d8
MH		 1664 if (conn->type == ACL_LINK)
1665 hci_sco_setup(conn, ev->status);
1da177e4 1666
769be974
MH		 1667 if (ev->status) {
1668 hci_proto_connect_cfm(conn, ev->status);
1da177e4 1669 hci_conn_del(conn);
c89b6e6b
MH		 1670 } else if (ev->link_type != ACL_LINK)
1671 hci_proto_connect_cfm(conn, ev->status);
1da177e4 1672
a9de9248 1673unlock:
1da177e4 1674 hci_dev_unlock(hdev);
1da177e4 1675
a9de9248 1676 hci_conn_check_pending(hdev);
1da177e4
LT		 1677}
1678
6039aa73 1679static void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1680{
a9de9248
MH		 1681 struct hci_ev_conn_request *ev = (void *) skb->data;
1682 int mask = hdev->link_mode;
20714bfe 1683 __u8 flags = 0;
1da177e4 1684
6ed93dc6 1685 BT_DBG("%s bdaddr %pMR type 0x%x", hdev->name, &ev->bdaddr,
807deac2 1686 ev->link_type);
1da177e4 1687
20714bfe
FD		 1688 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type,
1689 &flags);
1da177e4 1690
138d22ef 1691 if ((mask & HCI_LM_ACCEPT) &&
807deac2 1692 !hci_blacklist_lookup(hdev, &ev->bdaddr)) {
a9de9248 1693 /* Connection accepted */
c7bdd502 1694 struct inquiry_entry *ie;
1da177e4 1695 struct hci_conn *conn;
1da177e4 1696
a9de9248 1697 hci_dev_lock(hdev);
b6a0dc82 1698
cc11b9c1
AE		 1699 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1700 if (ie)
c7bdd502
MH		 1701 memcpy(ie->data.dev_class, ev->dev_class, 3);
1702
8fc9ced3
GP		 1703 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type,
1704 &ev->bdaddr);
a9de9248 1705 if (!conn) {
cc11b9c1
AE		 1706 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr);
1707 if (!conn) {
893ef971 1708 BT_ERR("No memory for new connection");
a9de9248
MH		 1709 hci_dev_unlock(hdev);
1710 return;
1da177e4
LT		 1711 }
1712 }
b6a0dc82 1713
a9de9248 1714 memcpy(conn->dev_class, ev->dev_class, 3);
b6a0dc82 1715
a9de9248 1716 hci_dev_unlock(hdev);
1da177e4 1717
20714bfe
FD		 1718 if (ev->link_type == ACL_LINK ||
1719 (!(flags & HCI_PROTO_DEFER) && !lmp_esco_capable(hdev))) {
b6a0dc82 1720 struct hci_cp_accept_conn_req cp;
20714bfe 1721 conn->state = BT_CONNECT;
1da177e4 1722
b6a0dc82
MH		 1723 bacpy(&cp.bdaddr, &ev->bdaddr);
1724
1725 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
1726 cp.role = 0x00; /* Become master */
1727 else
1728 cp.role = 0x01; /* Remain slave */
1729
04124681
GP		 1730 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp),
1731 &cp);
20714bfe 1732 } else if (!(flags & HCI_PROTO_DEFER)) {
b6a0dc82 1733 struct hci_cp_accept_sync_conn_req cp;
20714bfe 1734 conn->state = BT_CONNECT;
b6a0dc82
MH		 1735
1736 bacpy(&cp.bdaddr, &ev->bdaddr);
a8746417 1737 cp.pkt_type = cpu_to_le16(conn->pkt_type);
b6a0dc82 1738
82781e63
AE		 1739 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1740 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
1741 cp.max_latency = __constant_cpu_to_le16(0xffff);
b6a0dc82
MH		 1742 cp.content_format = cpu_to_le16(hdev->voice_setting);
1743 cp.retrans_effort = 0xff;
1da177e4 1744
b6a0dc82 1745 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
04124681 1746 sizeof(cp), &cp);
20714bfe
FD		 1747 } else {
1748 conn->state = BT_CONNECT2;
1749 hci_proto_connect_cfm(conn, 0);
b6a0dc82 1750 }
a9de9248
MH		 1751 } else {
1752 /* Connection rejected */
1753 struct hci_cp_reject_conn_req cp;
1da177e4 1754
a9de9248 1755 bacpy(&cp.bdaddr, &ev->bdaddr);
9f5a0d7b 1756 cp.reason = HCI_ERROR_REJ_BAD_ADDR;
a9de9248 1757 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
1da177e4 1758 }
1da177e4
LT		 1759}
1760
f0d6a0ea
MA		 1761static u8 hci_to_mgmt_reason(u8 err)
1762{
1763 switch (err) {
1764 case HCI_ERROR_CONNECTION_TIMEOUT:
1765 return MGMT_DEV_DISCONN_TIMEOUT;
1766 case HCI_ERROR_REMOTE_USER_TERM:
1767 case HCI_ERROR_REMOTE_LOW_RESOURCES:
1768 case HCI_ERROR_REMOTE_POWER_OFF:
1769 return MGMT_DEV_DISCONN_REMOTE;
1770 case HCI_ERROR_LOCAL_HOST_TERM:
1771 return MGMT_DEV_DISCONN_LOCAL_HOST;
1772 default:
1773 return MGMT_DEV_DISCONN_UNKNOWN;
1774 }
1775}
1776
6039aa73 1777static void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 1778{
a9de9248 1779 struct hci_ev_disconn_complete *ev = (void *) skb->data;
04837f64
MH		 1780 struct hci_conn *conn;
1781
9f1db00c 1782 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
04837f64
MH		 1783
1784 hci_dev_lock(hdev);
1785
1786 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
f7520543
JH		 1787 if (!conn)
1788 goto unlock;
7d0db0a3 1789
37d9ef76
JH		 1790 if (ev->status == 0)
1791 conn->state = BT_CLOSED;
04837f64 1792
b644ba33 1793 if (test_and_clear_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags) &&
807deac2 1794 (conn->type == ACL_LINK || conn->type == LE_LINK)) {
f0d6a0ea 1795 if (ev->status) {
88c3df13 1796 mgmt_disconnect_failed(hdev, &conn->dst, conn->type,
807deac2 1797 conn->dst_type, ev->status);
f0d6a0ea
MA		 1798 } else {
1799 u8 reason = hci_to_mgmt_reason(ev->reason);
1800
afc747a6 1801 mgmt_device_disconnected(hdev, &conn->dst, conn->type,
f0d6a0ea
MA		 1802 conn->dst_type, reason);
1803 }
37d9ef76 1804 }
f7520543 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;
2549 conn->interval = __le16_to_cpu(ev->interval);
2550
8fc9ced3
GP		 2551 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND,
2552 &conn->flags)) {
a9de9248 2553 if (conn->mode == HCI_CM_ACTIVE)
58a681ef 2554 set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
a9de9248 2555 else
58a681ef 2556 clear_bit(HCI_CONN_POWER_SAVE, &conn->flags);
a9de9248 2557 }
e73439d8 2558
51a8efd7 2559 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->flags))
e73439d8 2560 hci_sco_setup(conn, ev->status);
04837f64
MH		 2561 }
2562
2563 hci_dev_unlock(hdev);
2564}
2565
6039aa73 2566static void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248 2567{
052b30b0
MH		 2568 struct hci_ev_pin_code_req *ev = (void *) skb->data;
2569 struct hci_conn *conn;
2570
a9de9248 2571 BT_DBG("%s", hdev->name);
052b30b0
MH		 2572
2573 hci_dev_lock(hdev);
2574
2575 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
b6f98044
WR		 2576 if (!conn)
2577 goto unlock;
2578
2579 if (conn->state == BT_CONNECTED) {
052b30b0
MH		 2580 hci_conn_hold(conn);
2581 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
76a68ba0 2582 hci_conn_drop(conn);
052b30b0
MH		 2583 }
2584
a8b2d5c2 2585 if (!test_bit(HCI_PAIRABLE, &hdev->dev_flags))
03b555e1 2586 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
807deac2 2587 sizeof(ev->bdaddr), &ev->bdaddr);
a8b2d5c2 2588 else if (test_bit(HCI_MGMT, &hdev->dev_flags)) {
a770bb5a
WR		 2589 u8 secure;
2590
2591 if (conn->pending_sec_level == BT_SECURITY_HIGH)
2592 secure = 1;
2593 else
2594 secure = 0;
2595
744cf19e 2596 mgmt_pin_code_request(hdev, &ev->bdaddr, secure);
a770bb5a 2597 }
980e1a53 2598
b6f98044 2599unlock:
052b30b0 2600 hci_dev_unlock(hdev);
a9de9248
MH		 2601}
2602
6039aa73 2603static void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248 2604{
55ed8ca1
JH		 2605 struct hci_ev_link_key_req *ev = (void *) skb->data;
2606 struct hci_cp_link_key_reply cp;
2607 struct hci_conn *conn;
2608 struct link_key *key;
2609
a9de9248 2610 BT_DBG("%s", hdev->name);
55ed8ca1 2611
034cbea0 2612 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
55ed8ca1
JH		 2613 return;
2614
2615 hci_dev_lock(hdev);
2616
2617 key = hci_find_link_key(hdev, &ev->bdaddr);
2618 if (!key) {
6ed93dc6
AE		 2619 BT_DBG("%s link key not found for %pMR", hdev->name,
2620 &ev->bdaddr);
55ed8ca1
JH		 2621 goto not_found;
2622 }
2623
6ed93dc6
AE		 2624 BT_DBG("%s found key type %u for %pMR", hdev->name, key->type,
2625 &ev->bdaddr);
55ed8ca1 2626
a8b2d5c2 2627 if (!test_bit(HCI_DEBUG_KEYS, &hdev->dev_flags) &&
807deac2 2628 key->type == HCI_LK_DEBUG_COMBINATION) {
55ed8ca1
JH		 2629 BT_DBG("%s ignoring debug key", hdev->name);
2630 goto not_found;
2631 }
2632
2633 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
60b83f57
WR		 2634 if (conn) {
2635 if (key->type == HCI_LK_UNAUTH_COMBINATION &&
807deac2 2636 conn->auth_type != 0xff && (conn->auth_type & 0x01)) {
60b83f57
WR		 2637 BT_DBG("%s ignoring unauthenticated key", hdev->name);
2638 goto not_found;
2639 }
55ed8ca1 2640
60b83f57 2641 if (key->type == HCI_LK_COMBINATION && key->pin_len < 16 &&
807deac2 2642 conn->pending_sec_level == BT_SECURITY_HIGH) {
8fc9ced3
GP		 2643 BT_DBG("%s ignoring key unauthenticated for high security",
2644 hdev->name);
60b83f57
WR		 2645 goto not_found;
2646 }
2647
2648 conn->key_type = key->type;
2649 conn->pin_length = key->pin_len;
55ed8ca1
JH		 2650 }
2651
2652 bacpy(&cp.bdaddr, &ev->bdaddr);
9b3b4460 2653 memcpy(cp.link_key, key->val, HCI_LINK_KEY_SIZE);
55ed8ca1
JH		 2654
2655 hci_send_cmd(hdev, HCI_OP_LINK_KEY_REPLY, sizeof(cp), &cp);
2656
2657 hci_dev_unlock(hdev);
2658
2659 return;
2660
2661not_found:
2662 hci_send_cmd(hdev, HCI_OP_LINK_KEY_NEG_REPLY, 6, &ev->bdaddr);
2663 hci_dev_unlock(hdev);
a9de9248
MH		 2664}
2665
6039aa73 2666static void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
a9de9248 2667{
052b30b0
MH		 2668 struct hci_ev_link_key_notify *ev = (void *) skb->data;
2669 struct hci_conn *conn;
55ed8ca1 2670 u8 pin_len = 0;
052b30b0 2671
a9de9248 2672 BT_DBG("%s", hdev->name);
052b30b0
MH		 2673
2674 hci_dev_lock(hdev);
2675
2676 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2677 if (conn) {
2678 hci_conn_hold(conn);
2679 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
980e1a53 2680 pin_len = conn->pin_length;
13d39315
WR		 2681
2682 if (ev->key_type != HCI_LK_CHANGED_COMBINATION)
2683 conn->key_type = ev->key_type;
2684
76a68ba0 2685 hci_conn_drop(conn);
052b30b0
MH		 2686 }
2687
034cbea0 2688 if (test_bit(HCI_MGMT, &hdev->dev_flags))
d25e28ab 2689 hci_add_link_key(hdev, conn, 1, &ev->bdaddr, ev->link_key,
807deac2 2690 ev->key_type, pin_len);
55ed8ca1 2691
052b30b0 2692 hci_dev_unlock(hdev);
a9de9248
MH		 2693}
2694
6039aa73 2695static void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 2696{
a9de9248 2697 struct hci_ev_clock_offset *ev = (void *) skb->data;
04837f64 2698 struct hci_conn *conn;
1da177e4 2699
9f1db00c 2700 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
1da177e4
LT		 2701
2702 hci_dev_lock(hdev);
2703
04837f64 2704 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 2705 if (conn && !ev->status) {
2706 struct inquiry_entry *ie;
2707
cc11b9c1
AE		 2708 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2709 if (ie) {
1da177e4
LT		 2710 ie->data.clock_offset = ev->clock_offset;
2711 ie->timestamp = jiffies;
2712 }
2713 }
2714
2715 hci_dev_unlock(hdev);
2716}
2717
6039aa73 2718static void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
a8746417
MH		 2719{
2720 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
2721 struct hci_conn *conn;
2722
9f1db00c 2723 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
a8746417
MH		 2724
2725 hci_dev_lock(hdev);
2726
2727 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2728 if (conn && !ev->status)
2729 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
2730
2731 hci_dev_unlock(hdev);
2732}
2733
6039aa73 2734static void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
85a1e930 2735{
a9de9248 2736 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
85a1e930
MH		 2737 struct inquiry_entry *ie;
2738
2739 BT_DBG("%s", hdev->name);
2740
2741 hci_dev_lock(hdev);
2742
cc11b9c1
AE		 2743 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
2744 if (ie) {
85a1e930
MH		 2745 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
2746 ie->timestamp = jiffies;
2747 }
2748
2749 hci_dev_unlock(hdev);
2750}
2751
6039aa73
GP		 2752static void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev,
2753 struct sk_buff *skb)
a9de9248
MH		 2754{
2755 struct inquiry_data data;
2756 int num_rsp = *((__u8 *) skb->data);
388fc8fa 2757 bool name_known, ssp;
a9de9248
MH		 2758
2759 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
2760
2761 if (!num_rsp)
2762 return;
2763
1519cc17
AG		 2764 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
2765 return;
2766
a9de9248
MH		 2767 hci_dev_lock(hdev);
2768
2769 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
138d22ef
SJ		 2770 struct inquiry_info_with_rssi_and_pscan_mode *info;
2771 info = (void *) (skb->data + 1);
a9de9248 2772
e17acd40 2773 for (; num_rsp; num_rsp--, info++) {
a9de9248
MH		 2774 bacpy(&data.bdaddr, &info->bdaddr);
2775 data.pscan_rep_mode = info->pscan_rep_mode;
2776 data.pscan_period_mode = info->pscan_period_mode;
2777 data.pscan_mode = info->pscan_mode;
2778 memcpy(data.dev_class, info->dev_class, 3);
2779 data.clock_offset = info->clock_offset;
2780 data.rssi = info->rssi;
41a96212 2781 data.ssp_mode = 0x00;
3175405b
JH		 2782
2783 name_known = hci_inquiry_cache_update(hdev, &data,
04124681 2784 false, &ssp);
48264f06 2785 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
04124681
GP		 2786 info->dev_class, info->rssi,
2787 !name_known, ssp, NULL, 0);
a9de9248
MH		 2788 }
2789 } else {
2790 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
2791
e17acd40 2792 for (; num_rsp; num_rsp--, info++) {
a9de9248
MH		 2793 bacpy(&data.bdaddr, &info->bdaddr);
2794 data.pscan_rep_mode = info->pscan_rep_mode;
2795 data.pscan_period_mode = info->pscan_period_mode;
2796 data.pscan_mode = 0x00;
2797 memcpy(data.dev_class, info->dev_class, 3);
2798 data.clock_offset = info->clock_offset;
2799 data.rssi = info->rssi;
41a96212 2800 data.ssp_mode = 0x00;
3175405b 2801 name_known = hci_inquiry_cache_update(hdev, &data,
04124681 2802 false, &ssp);
48264f06 2803 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
04124681
GP		 2804 info->dev_class, info->rssi,
2805 !name_known, ssp, NULL, 0);
a9de9248
MH		 2806 }
2807 }
2808
2809 hci_dev_unlock(hdev);
2810}
2811
6039aa73
GP		 2812static void hci_remote_ext_features_evt(struct hci_dev *hdev,
2813 struct sk_buff *skb)
a9de9248 2814{
41a96212
MH		 2815 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
2816 struct hci_conn *conn;
2817
a9de9248 2818 BT_DBG("%s", hdev->name);
41a96212 2819
41a96212
MH		 2820 hci_dev_lock(hdev);
2821
2822 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
ccd556fe
JH		 2823 if (!conn)
2824 goto unlock;
41a96212 2825
cad718ed
JH		 2826 if (ev->page < HCI_MAX_PAGES)
2827 memcpy(conn->features[ev->page], ev->features, 8);
2828
ccd556fe
JH		 2829 if (!ev->status && ev->page == 0x01) {
2830 struct inquiry_entry *ie;
41a96212 2831
cc11b9c1
AE		 2832 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
2833 if (ie)
02b7cc62 2834 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
769be974 2835
bbb0eada 2836 if (ev->features[0] & LMP_HOST_SSP) {
58a681ef 2837 set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
bbb0eada
JK		 2838 } else {
2839 /* It is mandatory by the Bluetooth specification that
2840 * Extended Inquiry Results are only used when Secure
2841 * Simple Pairing is enabled, but some devices violate
2842 * this.
2843 *
2844 * To make these devices work, the internal SSP
2845 * enabled flag needs to be cleared if the remote host
2846 * features do not indicate SSP support */
2847 clear_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
2848 }
ccd556fe
JH		 2849 }
2850
2851 if (conn->state != BT_CONFIG)
2852 goto unlock;
2853
671267bf 2854 if (!ev->status && !test_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags)) {
127178d2
JH		 2855 struct hci_cp_remote_name_req cp;
2856 memset(&cp, 0, sizeof(cp));
2857 bacpy(&cp.bdaddr, &conn->dst);
2858 cp.pscan_rep_mode = 0x02;
2859 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
b644ba33
JH		 2860 } else if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
2861 mgmt_device_connected(hdev, &conn->dst, conn->type,
04124681
GP		 2862 conn->dst_type, 0, NULL, 0,
2863 conn->dev_class);
392599b9 2864
127178d2 2865 if (!hci_outgoing_auth_needed(hdev, conn)) {
ccd556fe
JH		 2866 conn->state = BT_CONNECTED;
2867 hci_proto_connect_cfm(conn, ev->status);
76a68ba0 2868 hci_conn_drop(conn);
41a96212
MH		 2869 }
2870
ccd556fe 2871unlock:
41a96212 2872 hci_dev_unlock(hdev);
a9de9248
MH		 2873}
2874
6039aa73
GP		 2875static void hci_sync_conn_complete_evt(struct hci_dev *hdev,
2876 struct sk_buff *skb)
a9de9248 2877{
b6a0dc82
MH		 2878 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
2879 struct hci_conn *conn;
2880
9f1db00c 2881 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
b6a0dc82
MH		 2882
2883 hci_dev_lock(hdev);
2884
2885 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
9dc0a3af
MH		 2886 if (!conn) {
2887 if (ev->link_type == ESCO_LINK)
2888 goto unlock;
2889
2890 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
2891 if (!conn)
2892 goto unlock;
2893
2894 conn->type = SCO_LINK;
2895 }
b6a0dc82 2896
732547f9
MH		 2897 switch (ev->status) {
2898 case 0x00:
b6a0dc82
MH		 2899 conn->handle = __le16_to_cpu(ev->handle);
2900 conn->state = BT_CONNECTED;
7d0db0a3
MH		 2901
2902 hci_conn_add_sysfs(conn);
732547f9
MH		 2903 break;
2904
1a4c958c 2905 case 0x0d: /* Connection Rejected due to Limited Resources */
705e5711 2906 case 0x11: /* Unsupported Feature or Parameter Value */
732547f9 2907 case 0x1c: /* SCO interval rejected */
1038a00b 2908 case 0x1a: /* Unsupported Remote Feature */
732547f9 2909 case 0x1f: /* Unspecified error */
2dea632f 2910 if (conn->out) {
732547f9
MH		 2911 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
2912 (hdev->esco_type & EDR_ESCO_MASK);
2dea632f
FD		 2913 if (hci_setup_sync(conn, conn->link->handle))
2914 goto unlock;
732547f9
MH		 2915 }
2916 /* fall through */
2917
2918 default:
b6a0dc82 2919 conn->state = BT_CLOSED;
732547f9
MH		 2920 break;
2921 }
b6a0dc82
MH		 2922
2923 hci_proto_connect_cfm(conn, ev->status);
2924 if (ev->status)
2925 hci_conn_del(conn);
2926
2927unlock:
2928 hci_dev_unlock(hdev);
a9de9248
MH		 2929}
2930
6039aa73
GP		 2931static void hci_extended_inquiry_result_evt(struct hci_dev *hdev,
2932 struct sk_buff *skb)
1da177e4 2933{
a9de9248
MH		 2934 struct inquiry_data data;
2935 struct extended_inquiry_info *info = (void *) (skb->data + 1);
2936 int num_rsp = *((__u8 *) skb->data);
9d939d94 2937 size_t eir_len;
1da177e4 2938
a9de9248 2939 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1da177e4 2940
a9de9248
MH		 2941 if (!num_rsp)
2942 return;
1da177e4 2943
1519cc17
AG		 2944 if (test_bit(HCI_PERIODIC_INQ, &hdev->dev_flags))
2945 return;
2946
a9de9248
MH		 2947 hci_dev_lock(hdev);
2948
e17acd40 2949 for (; num_rsp; num_rsp--, info++) {
388fc8fa 2950 bool name_known, ssp;
561aafbc 2951
a9de9248 2952 bacpy(&data.bdaddr, &info->bdaddr);
138d22ef
SJ		 2953 data.pscan_rep_mode = info->pscan_rep_mode;
2954 data.pscan_period_mode = info->pscan_period_mode;
2955 data.pscan_mode = 0x00;
a9de9248 2956 memcpy(data.dev_class, info->dev_class, 3);
138d22ef
SJ		 2957 data.clock_offset = info->clock_offset;
2958 data.rssi = info->rssi;
41a96212 2959 data.ssp_mode = 0x01;
561aafbc 2960
a8b2d5c2 2961 if (test_bit(HCI_MGMT, &hdev->dev_flags))
4ddb1930 2962 name_known = eir_has_data_type(info->data,
04124681
GP		 2963 sizeof(info->data),
2964 EIR_NAME_COMPLETE);
561aafbc
JH		 2965 else
2966 name_known = true;
2967
388fc8fa 2968 name_known = hci_inquiry_cache_update(hdev, &data, name_known,
04124681 2969 &ssp);
9d939d94 2970 eir_len = eir_get_length(info->data, sizeof(info->data));
48264f06 2971 mgmt_device_found(hdev, &info->bdaddr, ACL_LINK, 0x00,
04124681 2972 info->dev_class, info->rssi, !name_known,
9d939d94 2973 ssp, info->data, eir_len);
a9de9248
MH		 2974 }
2975
2976 hci_dev_unlock(hdev);
2977}
1da177e4 2978
1c2e0041
JH		 2979static void hci_key_refresh_complete_evt(struct hci_dev *hdev,
2980 struct sk_buff *skb)
2981{
2982 struct hci_ev_key_refresh_complete *ev = (void *) skb->data;
2983 struct hci_conn *conn;
2984
9f1db00c 2985 BT_DBG("%s status 0x%2.2x handle 0x%4.4x", hdev->name, ev->status,
1c2e0041
JH		 2986 __le16_to_cpu(ev->handle));
2987
2988 hci_dev_lock(hdev);
2989
2990 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
2991 if (!conn)
2992 goto unlock;
2993
2994 if (!ev->status)
2995 conn->sec_level = conn->pending_sec_level;
2996
2997 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
2998
2999 if (ev->status && conn->state == BT_CONNECTED) {
bed71748 3000 hci_disconnect(conn, HCI_ERROR_AUTH_FAILURE);
76a68ba0 3001 hci_conn_drop(conn);
1c2e0041
JH		 3002 goto unlock;
3003 }
3004
3005 if (conn->state == BT_CONFIG) {
3006 if (!ev->status)
3007 conn->state = BT_CONNECTED;
3008
3009 hci_proto_connect_cfm(conn, ev->status);
76a68ba0 3010 hci_conn_drop(conn);
1c2e0041
JH		 3011 } else {
3012 hci_auth_cfm(conn, ev->status);
3013
3014 hci_conn_hold(conn);
3015 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
76a68ba0 3016 hci_conn_drop(conn);
1c2e0041
JH		 3017 }
3018
3019unlock:
3020 hci_dev_unlock(hdev);
3021}
3022
6039aa73 3023static u8 hci_get_auth_req(struct hci_conn *conn)
17fa4b9d
JH		 3024{
3025 /* If remote requests dedicated bonding follow that lead */
acabae96
MA		 3026 if (conn->remote_auth == HCI_AT_DEDICATED_BONDING ||
3027 conn->remote_auth == HCI_AT_DEDICATED_BONDING_MITM) {
17fa4b9d
JH		 3028 /* If both remote and local IO capabilities allow MITM
3029 * protection then require it, otherwise don't */
acabae96
MA		 3030 if (conn->remote_cap == HCI_IO_NO_INPUT_OUTPUT ||
3031 conn->io_capability == HCI_IO_NO_INPUT_OUTPUT)
3032 return HCI_AT_DEDICATED_BONDING;
17fa4b9d 3033 else
acabae96 3034 return HCI_AT_DEDICATED_BONDING_MITM;
17fa4b9d
JH		 3035 }
3036
3037 /* If remote requests no-bonding follow that lead */
acabae96
MA		 3038 if (conn->remote_auth == HCI_AT_NO_BONDING ||
3039 conn->remote_auth == HCI_AT_NO_BONDING_MITM)
58797bf7 3040 return conn->remote_auth | (conn->auth_type & 0x01);
17fa4b9d
JH		 3041
3042 return conn->auth_type;
3043}
3044
6039aa73 3045static void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
0493684e
MH		 3046{
3047 struct hci_ev_io_capa_request *ev = (void *) skb->data;
3048 struct hci_conn *conn;
3049
3050 BT_DBG("%s", hdev->name);
3051
3052 hci_dev_lock(hdev);
3053
3054 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
03b555e1
JH		 3055 if (!conn)
3056 goto unlock;
3057
3058 hci_conn_hold(conn);
3059
a8b2d5c2 3060 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
03b555e1
JH		 3061 goto unlock;
3062
a8b2d5c2 3063 if (test_bit(HCI_PAIRABLE, &hdev->dev_flags) ||
807deac2 3064 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
17fa4b9d
JH		 3065 struct hci_cp_io_capability_reply cp;
3066
3067 bacpy(&cp.bdaddr, &ev->bdaddr);
7a7f1e7c
HG		 3068 /* Change the IO capability from KeyboardDisplay
3069 * to DisplayYesNo as it is not supported by BT spec. */
3070 cp.capability = (conn->io_capability == 0x04) ?
a767631a 3071 HCI_IO_DISPLAY_YESNO : conn->io_capability;
7cbc9bd9
JH		 3072 conn->auth_type = hci_get_auth_req(conn);
3073 cp.authentication = conn->auth_type;
17fa4b9d 3074
8fc9ced3
GP		 3075 if (hci_find_remote_oob_data(hdev, &conn->dst) &&
3076 (conn->out || test_bit(HCI_CONN_REMOTE_OOB, &conn->flags)))
ce85ee13
SJ		 3077 cp.oob_data = 0x01;
3078 else
3079 cp.oob_data = 0x00;
3080
17fa4b9d 3081 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_REPLY,
807deac2 3082 sizeof(cp), &cp);
03b555e1
JH		 3083 } else {
3084 struct hci_cp_io_capability_neg_reply cp;
3085
3086 bacpy(&cp.bdaddr, &ev->bdaddr);
9f5a0d7b 3087 cp.reason = HCI_ERROR_PAIRING_NOT_ALLOWED;
0493684e 3088
03b555e1 3089 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
807deac2 3090 sizeof(cp), &cp);
03b555e1
JH		 3091 }
3092
3093unlock:
3094 hci_dev_unlock(hdev);
3095}
3096
6039aa73 3097static void hci_io_capa_reply_evt(struct hci_dev *hdev, struct sk_buff *skb)
03b555e1
JH		 3098{
3099 struct hci_ev_io_capa_reply *ev = (void *) skb->data;
3100 struct hci_conn *conn;
3101
3102 BT_DBG("%s", hdev->name);
3103
3104 hci_dev_lock(hdev);
3105
3106 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3107 if (!conn)
3108 goto unlock;
3109
03b555e1 3110 conn->remote_cap = ev->capability;
03b555e1 3111 conn->remote_auth = ev->authentication;
58a681ef
JH		 3112 if (ev->oob_data)
3113 set_bit(HCI_CONN_REMOTE_OOB, &conn->flags);
03b555e1
JH		 3114
3115unlock:
0493684e
MH		 3116 hci_dev_unlock(hdev);
3117}
3118
6039aa73
GP		 3119static void hci_user_confirm_request_evt(struct hci_dev *hdev,
3120 struct sk_buff *skb)
a5c29683
JH		 3121{
3122 struct hci_ev_user_confirm_req *ev = (void *) skb->data;
55bc1a37 3123 int loc_mitm, rem_mitm, confirm_hint = 0;
7a828908 3124 struct hci_conn *conn;
a5c29683
JH		 3125
3126 BT_DBG("%s", hdev->name);
3127
3128 hci_dev_lock(hdev);
3129
a8b2d5c2 3130 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
7a828908 3131 goto unlock;
a5c29683 3132
7a828908
JH		 3133 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3134 if (!conn)
3135 goto unlock;
3136
3137 loc_mitm = (conn->auth_type & 0x01);
3138 rem_mitm = (conn->remote_auth & 0x01);
3139
3140 /* If we require MITM but the remote device can't provide that
3141 * (it has NoInputNoOutput) then reject the confirmation
3142 * request. The only exception is when we're dedicated bonding
3143 * initiators (connect_cfm_cb set) since then we always have the MITM
3144 * bit set. */
a767631a
MA		 3145 if (!conn->connect_cfm_cb && loc_mitm &&
3146 conn->remote_cap == HCI_IO_NO_INPUT_OUTPUT) {
7a828908
JH		 3147 BT_DBG("Rejecting request: remote device can't provide MITM");
3148 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_NEG_REPLY,
807deac2 3149 sizeof(ev->bdaddr), &ev->bdaddr);
7a828908
JH		 3150 goto unlock;
3151 }
3152
3153 /* If no side requires MITM protection; auto-accept */
a767631a
MA		 3154 if ((!loc_mitm || conn->remote_cap == HCI_IO_NO_INPUT_OUTPUT) &&
3155 (!rem_mitm || conn->io_capability == HCI_IO_NO_INPUT_OUTPUT)) {
55bc1a37
JH		 3156
3157 /* If we're not the initiators request authorization to
3158 * proceed from user space (mgmt_user_confirm with
3159 * confirm_hint set to 1). */
51a8efd7 3160 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
55bc1a37
JH		 3161 BT_DBG("Confirming auto-accept as acceptor");
3162 confirm_hint = 1;
3163 goto confirm;
3164 }
3165
9f61656a 3166 BT_DBG("Auto-accept of user confirmation with %ums delay",
807deac2 3167 hdev->auto_accept_delay);
9f61656a
JH		 3168
3169 if (hdev->auto_accept_delay > 0) {
3170 int delay = msecs_to_jiffies(hdev->auto_accept_delay);
3171 mod_timer(&conn->auto_accept_timer, jiffies + delay);
3172 goto unlock;
3173 }
3174
7a828908 3175 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY,
807deac2 3176 sizeof(ev->bdaddr), &ev->bdaddr);
7a828908
JH		 3177 goto unlock;
3178 }
3179
55bc1a37 3180confirm:
272d90df 3181 mgmt_user_confirm_request(hdev, &ev->bdaddr, ACL_LINK, 0, ev->passkey,
04124681 3182 confirm_hint);
7a828908
JH		 3183
3184unlock:
a5c29683
JH		 3185 hci_dev_unlock(hdev);
3186}
3187
6039aa73
GP		 3188static void hci_user_passkey_request_evt(struct hci_dev *hdev,
3189 struct sk_buff *skb)
1143d458
BG		 3190{
3191 struct hci_ev_user_passkey_req *ev = (void *) skb->data;
3192
3193 BT_DBG("%s", hdev->name);
3194
a8b2d5c2 3195 if (test_bit(HCI_MGMT, &hdev->dev_flags))
272d90df 3196 mgmt_user_passkey_request(hdev, &ev->bdaddr, ACL_LINK, 0);
1143d458
BG		 3197}
3198
92a25256
JH		 3199static void hci_user_passkey_notify_evt(struct hci_dev *hdev,
3200 struct sk_buff *skb)
3201{
3202 struct hci_ev_user_passkey_notify *ev = (void *) skb->data;
3203 struct hci_conn *conn;
3204
3205 BT_DBG("%s", hdev->name);
3206
3207 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3208 if (!conn)
3209 return;
3210
3211 conn->passkey_notify = __le32_to_cpu(ev->passkey);
3212 conn->passkey_entered = 0;
3213
3214 if (test_bit(HCI_MGMT, &hdev->dev_flags))
3215 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
3216 conn->dst_type, conn->passkey_notify,
3217 conn->passkey_entered);
3218}
3219
3220static void hci_keypress_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
3221{
3222 struct hci_ev_keypress_notify *ev = (void *) skb->data;
3223 struct hci_conn *conn;
3224
3225 BT_DBG("%s", hdev->name);
3226
3227 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3228 if (!conn)
3229 return;
3230
3231 switch (ev->type) {
3232 case HCI_KEYPRESS_STARTED:
3233 conn->passkey_entered = 0;
3234 return;
3235
3236 case HCI_KEYPRESS_ENTERED:
3237 conn->passkey_entered++;
3238 break;
3239
3240 case HCI_KEYPRESS_ERASED:
3241 conn->passkey_entered--;
3242 break;
3243
3244 case HCI_KEYPRESS_CLEARED:
3245 conn->passkey_entered = 0;
3246 break;
3247
3248 case HCI_KEYPRESS_COMPLETED:
3249 return;
3250 }
3251
3252 if (test_bit(HCI_MGMT, &hdev->dev_flags))
3253 mgmt_user_passkey_notify(hdev, &conn->dst, conn->type,
3254 conn->dst_type, conn->passkey_notify,
3255 conn->passkey_entered);
3256}
3257
6039aa73
GP		 3258static void hci_simple_pair_complete_evt(struct hci_dev *hdev,
3259 struct sk_buff *skb)
0493684e
MH		 3260{
3261 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
3262 struct hci_conn *conn;
3263
3264 BT_DBG("%s", hdev->name);
3265
3266 hci_dev_lock(hdev);
3267
3268 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
2a611692
JH		 3269 if (!conn)
3270 goto unlock;
3271
3272 /* To avoid duplicate auth_failed events to user space we check
3273 * the HCI_CONN_AUTH_PEND flag which will be set if we
3274 * initiated the authentication. A traditional auth_complete
3275 * event gets always produced as initiator and is also mapped to
3276 * the mgmt_auth_failed event */
fa1bd918 3277 if (!test_bit(HCI_CONN_AUTH_PEND, &conn->flags) && ev->status)
bab73cb6 3278 mgmt_auth_failed(hdev, &conn->dst, conn->type, conn->dst_type,
04124681 3279 ev->status);
0493684e 3280
76a68ba0 3281 hci_conn_drop(conn);
2a611692
JH		 3282
3283unlock:
0493684e
MH		 3284 hci_dev_unlock(hdev);
3285}
3286
6039aa73
GP		 3287static void hci_remote_host_features_evt(struct hci_dev *hdev,
3288 struct sk_buff *skb)
41a96212
MH		 3289{
3290 struct hci_ev_remote_host_features *ev = (void *) skb->data;
3291 struct inquiry_entry *ie;
cad718ed 3292 struct hci_conn *conn;
41a96212
MH		 3293
3294 BT_DBG("%s", hdev->name);
3295
3296 hci_dev_lock(hdev);
3297
cad718ed
JH		 3298 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3299 if (conn)
3300 memcpy(conn->features[1], ev->features, 8);
3301
cc11b9c1
AE		 3302 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
3303 if (ie)
02b7cc62 3304 ie->data.ssp_mode = (ev->features[0] & LMP_HOST_SSP);
41a96212
MH		 3305
3306 hci_dev_unlock(hdev);
3307}
3308
6039aa73
GP		 3309static void hci_remote_oob_data_request_evt(struct hci_dev *hdev,
3310 struct sk_buff *skb)
2763eda6
SJ		 3311{
3312 struct hci_ev_remote_oob_data_request *ev = (void *) skb->data;
3313 struct oob_data *data;
3314
3315 BT_DBG("%s", hdev->name);
3316
3317 hci_dev_lock(hdev);
3318
a8b2d5c2 3319 if (!test_bit(HCI_MGMT, &hdev->dev_flags))
e1ba1f15
SJ		 3320 goto unlock;
3321
2763eda6
SJ		 3322 data = hci_find_remote_oob_data(hdev, &ev->bdaddr);
3323 if (data) {
3324 struct hci_cp_remote_oob_data_reply cp;
3325
3326 bacpy(&cp.bdaddr, &ev->bdaddr);
3327 memcpy(cp.hash, data->hash, sizeof(cp.hash));
3328 memcpy(cp.randomizer, data->randomizer, sizeof(cp.randomizer));
3329
3330 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_REPLY, sizeof(cp),
807deac2 3331 &cp);
2763eda6
SJ		 3332 } else {
3333 struct hci_cp_remote_oob_data_neg_reply cp;
3334
3335 bacpy(&cp.bdaddr, &ev->bdaddr);
3336 hci_send_cmd(hdev, HCI_OP_REMOTE_OOB_DATA_NEG_REPLY, sizeof(cp),
807deac2 3337 &cp);
2763eda6
SJ		 3338 }
3339
e1ba1f15 3340unlock:
2763eda6
SJ		 3341 hci_dev_unlock(hdev);
3342}
3343
d5e91192
AE		 3344static void hci_phy_link_complete_evt(struct hci_dev *hdev,
3345 struct sk_buff *skb)
3346{
3347 struct hci_ev_phy_link_complete *ev = (void *) skb->data;
3348 struct hci_conn *hcon, *bredr_hcon;
3349
3350 BT_DBG("%s handle 0x%2.2x status 0x%2.2x", hdev->name, ev->phy_handle,
3351 ev->status);
3352
3353 hci_dev_lock(hdev);
3354
3355 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3356 if (!hcon) {
3357 hci_dev_unlock(hdev);
3358 return;
3359 }
3360
3361 if (ev->status) {
3362 hci_conn_del(hcon);
3363 hci_dev_unlock(hdev);
3364 return;
3365 }
3366
3367 bredr_hcon = hcon->amp_mgr->l2cap_conn->hcon;
3368
3369 hcon->state = BT_CONNECTED;
3370 bacpy(&hcon->dst, &bredr_hcon->dst);
3371
3372 hci_conn_hold(hcon);
3373 hcon->disc_timeout = HCI_DISCONN_TIMEOUT;
76a68ba0 3374 hci_conn_drop(hcon);
d5e91192 3375
d5e91192
AE		 3376 hci_conn_add_sysfs(hcon);
3377
cf70ff22 3378 amp_physical_cfm(bredr_hcon, hcon);
d5e91192 3379
cf70ff22 3380 hci_dev_unlock(hdev);
d5e91192
AE		 3381}
3382
27695fb4
AE		 3383static void hci_loglink_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
3384{
3385 struct hci_ev_logical_link_complete *ev = (void *) skb->data;
3386 struct hci_conn *hcon;
3387 struct hci_chan *hchan;
3388 struct amp_mgr *mgr;
3389
3390 BT_DBG("%s log_handle 0x%4.4x phy_handle 0x%2.2x status 0x%2.2x",
3391 hdev->name, le16_to_cpu(ev->handle), ev->phy_handle,
3392 ev->status);
3393
3394 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3395 if (!hcon)
3396 return;
3397
3398 /* Create AMP hchan */
3399 hchan = hci_chan_create(hcon);
3400 if (!hchan)
3401 return;
3402
3403 hchan->handle = le16_to_cpu(ev->handle);
3404
3405 BT_DBG("hcon %p mgr %p hchan %p", hcon, hcon->amp_mgr, hchan);
3406
3407 mgr = hcon->amp_mgr;
3408 if (mgr && mgr->bredr_chan) {
3409 struct l2cap_chan *bredr_chan = mgr->bredr_chan;
3410
3411 l2cap_chan_lock(bredr_chan);
3412
3413 bredr_chan->conn->mtu = hdev->block_mtu;
3414 l2cap_logical_cfm(bredr_chan, hchan, 0);
3415 hci_conn_hold(hcon);
3416
3417 l2cap_chan_unlock(bredr_chan);
3418 }
3419}
3420
606e2a10
AE		 3421static void hci_disconn_loglink_complete_evt(struct hci_dev *hdev,
3422 struct sk_buff *skb)
3423{
3424 struct hci_ev_disconn_logical_link_complete *ev = (void *) skb->data;
3425 struct hci_chan *hchan;
3426
3427 BT_DBG("%s log handle 0x%4.4x status 0x%2.2x", hdev->name,
3428 le16_to_cpu(ev->handle), ev->status);
3429
3430 if (ev->status)
3431 return;
3432
3433 hci_dev_lock(hdev);
3434
3435 hchan = hci_chan_lookup_handle(hdev, le16_to_cpu(ev->handle));
3436 if (!hchan)
3437 goto unlock;
3438
3439 amp_destroy_logical_link(hchan, ev->reason);
3440
3441unlock:
3442 hci_dev_unlock(hdev);
3443}
3444
9eef6b3a
AE		 3445static void hci_disconn_phylink_complete_evt(struct hci_dev *hdev,
3446 struct sk_buff *skb)
3447{
3448 struct hci_ev_disconn_phy_link_complete *ev = (void *) skb->data;
3449 struct hci_conn *hcon;
3450
3451 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
3452
3453 if (ev->status)
3454 return;
3455
3456 hci_dev_lock(hdev);
3457
3458 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3459 if (hcon) {
3460 hcon->state = BT_CLOSED;
3461 hci_conn_del(hcon);
3462 }
3463
3464 hci_dev_unlock(hdev);
3465}
3466
6039aa73 3467static void hci_le_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
fcd89c09
VT		 3468{
3469 struct hci_ev_le_conn_complete *ev = (void *) skb->data;
3470 struct hci_conn *conn;
3471
9f1db00c 3472 BT_DBG("%s status 0x%2.2x", hdev->name, ev->status);
fcd89c09
VT		 3473
3474 hci_dev_lock(hdev);
3475
b47a09b3 3476 conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT);
b62f328b
VT		 3477 if (!conn) {
3478 conn = hci_conn_add(hdev, LE_LINK, &ev->bdaddr);
3479 if (!conn) {
3480 BT_ERR("No memory for new connection");
230fd16a 3481 goto unlock;
b62f328b 3482 }
29b7988a
AG		 3483
3484 conn->dst_type = ev->bdaddr_type;
b9b343d2 3485
880be4e8
MH		 3486 /* The advertising parameters for own address type
3487 * define which source address and source address
3488 * type this connections has.
3489 */
3490 if (bacmp(&conn->src, BDADDR_ANY)) {
3491 conn->src_type = ADDR_LE_DEV_PUBLIC;
3492 } else {
3493 bacpy(&conn->src, &hdev->static_addr);
3494 conn->src_type = ADDR_LE_DEV_RANDOM;
3495 }
3496
b9b343d2
AG		 3497 if (ev->role == LE_CONN_ROLE_MASTER) {
3498 conn->out = true;
3499 conn->link_mode |= HCI_LM_MASTER;
3500 }
b62f328b 3501 }
fcd89c09 3502
cd17decb
AG		 3503 if (ev->status) {
3504 mgmt_connect_failed(hdev, &conn->dst, conn->type,
3505 conn->dst_type, ev->status);
3506 hci_proto_connect_cfm(conn, ev->status);
3507 conn->state = BT_CLOSED;
3508 hci_conn_del(conn);
3509 goto unlock;
3510 }
3511
b644ba33
JH		 3512 if (!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &conn->flags))
3513 mgmt_device_connected(hdev, &ev->bdaddr, conn->type,
04124681 3514 conn->dst_type, 0, NULL, 0, NULL);
83bc71b4 3515
7b5c0d52 3516 conn->sec_level = BT_SECURITY_LOW;
fcd89c09
VT		 3517 conn->handle = __le16_to_cpu(ev->handle);
3518 conn->state = BT_CONNECTED;
3519
fcd89c09
VT		 3520 hci_conn_add_sysfs(conn);
3521
3522 hci_proto_connect_cfm(conn, ev->status);
3523
3524unlock:
3525 hci_dev_unlock(hdev);
3526}
3527
6039aa73 3528static void hci_le_adv_report_evt(struct hci_dev *hdev, struct sk_buff *skb)
9aa04c91 3529{
e95beb41
AG		 3530 u8 num_reports = skb->data[0];
3531 void *ptr = &skb->data[1];
3c9e9195 3532 s8 rssi;
9aa04c91 3533
e95beb41
AG		 3534 while (num_reports--) {
3535 struct hci_ev_le_advertising_info *ev = ptr;
9aa04c91 3536
3c9e9195
AG		 3537 rssi = ev->data[ev->length];
3538 mgmt_device_found(hdev, &ev->bdaddr, LE_LINK, ev->bdaddr_type,
04124681 3539 NULL, rssi, 0, 1, ev->data, ev->length);
3c9e9195 3540
e95beb41 3541 ptr += sizeof(*ev) + ev->length + 1;
9aa04c91 3542 }
9aa04c91
AG		 3543}
3544
6039aa73 3545static void hci_le_ltk_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
a7a595f6
VCG		 3546{
3547 struct hci_ev_le_ltk_req *ev = (void *) skb->data;
3548 struct hci_cp_le_ltk_reply cp;
bea710fe 3549 struct hci_cp_le_ltk_neg_reply neg;
a7a595f6 3550 struct hci_conn *conn;
c9839a11 3551 struct smp_ltk *ltk;
a7a595f6 3552
9f1db00c 3553 BT_DBG("%s handle 0x%4.4x", hdev->name, __le16_to_cpu(ev->handle));
a7a595f6
VCG		 3554
3555 hci_dev_lock(hdev);
3556
3557 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
bea710fe
VCG		 3558 if (conn == NULL)
3559 goto not_found;
a7a595f6 3560
bea710fe
VCG		 3561 ltk = hci_find_ltk(hdev, ev->ediv, ev->random);
3562 if (ltk == NULL)
3563 goto not_found;
3564
3565 memcpy(cp.ltk, ltk->val, sizeof(ltk->val));
a7a595f6 3566 cp.handle = cpu_to_le16(conn->handle);
c9839a11
VCG		 3567
3568 if (ltk->authenticated)
f8776218
AG		 3569 conn->pending_sec_level = BT_SECURITY_HIGH;
3570 else
3571 conn->pending_sec_level = BT_SECURITY_MEDIUM;
a7a595f6 3572
89cbb4da 3573 conn->enc_key_size = ltk->enc_size;
a7a595f6
VCG		 3574
3575 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
3576
c9839a11
VCG		 3577 if (ltk->type & HCI_SMP_STK) {
3578 list_del(&ltk->list);
3579 kfree(ltk);
3580 }
3581
a7a595f6 3582 hci_dev_unlock(hdev);
bea710fe
VCG		 3583
3584 return;
3585
3586not_found:
3587 neg.handle = ev->handle;
3588 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(neg), &neg);
3589 hci_dev_unlock(hdev);
a7a595f6
VCG		 3590}
3591
6039aa73 3592static void hci_le_meta_evt(struct hci_dev *hdev, struct sk_buff *skb)
fcd89c09
VT		 3593{
3594 struct hci_ev_le_meta *le_ev = (void *) skb->data;
3595
3596 skb_pull(skb, sizeof(*le_ev));
3597
3598 switch (le_ev->subevent) {
3599 case HCI_EV_LE_CONN_COMPLETE:
3600 hci_le_conn_complete_evt(hdev, skb);
3601 break;
3602
9aa04c91
AG		 3603 case HCI_EV_LE_ADVERTISING_REPORT:
3604 hci_le_adv_report_evt(hdev, skb);
3605 break;
3606
a7a595f6
VCG		 3607 case HCI_EV_LE_LTK_REQ:
3608 hci_le_ltk_request_evt(hdev, skb);
3609 break;
3610
fcd89c09
VT		 3611 default:
3612 break;
3613 }
3614}
3615
9495b2ee
AE		 3616static void hci_chan_selected_evt(struct hci_dev *hdev, struct sk_buff *skb)
3617{
3618 struct hci_ev_channel_selected *ev = (void *) skb->data;
3619 struct hci_conn *hcon;
3620
3621 BT_DBG("%s handle 0x%2.2x", hdev->name, ev->phy_handle);
3622
3623 skb_pull(skb, sizeof(*ev));
3624
3625 hcon = hci_conn_hash_lookup_handle(hdev, ev->phy_handle);
3626 if (!hcon)
3627 return;
3628
3629 amp_read_loc_assoc_final_data(hdev, hcon);
3630}
3631
a9de9248
MH		 3632void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
3633{
3634 struct hci_event_hdr *hdr = (void *) skb->data;
3635 __u8 event = hdr->evt;
3636
b6ddb638
JH		 3637 hci_dev_lock(hdev);
3638
3639 /* Received events are (currently) only needed when a request is
3640 * ongoing so avoid unnecessary memory allocation.
3641 */
3642 if (hdev->req_status == HCI_REQ_PEND) {
3643 kfree_skb(hdev->recv_evt);
3644 hdev->recv_evt = skb_clone(skb, GFP_KERNEL);
3645 }
3646
3647 hci_dev_unlock(hdev);
3648
a9de9248
MH		 3649 skb_pull(skb, HCI_EVENT_HDR_SIZE);
3650
02350a72 3651 if (hdev->sent_cmd && bt_cb(hdev->sent_cmd)->req.event == event) {
c1f23a2b
JB		 3652 struct hci_command_hdr *cmd_hdr = (void *) hdev->sent_cmd->data;
3653 u16 opcode = __le16_to_cpu(cmd_hdr->opcode);
02350a72
JH		 3654
3655 hci_req_cmd_complete(hdev, opcode, 0);
3656 }
3657
a9de9248 3658 switch (event) {
1da177e4
LT		 3659 case HCI_EV_INQUIRY_COMPLETE:
3660 hci_inquiry_complete_evt(hdev, skb);
3661 break;
3662
3663 case HCI_EV_INQUIRY_RESULT:
3664 hci_inquiry_result_evt(hdev, skb);
3665 break;
3666
a9de9248
MH		 3667 case HCI_EV_CONN_COMPLETE:
3668 hci_conn_complete_evt(hdev, skb);
21d9e30e
MH		 3669 break;
3670
1da177e4
LT		 3671 case HCI_EV_CONN_REQUEST:
3672 hci_conn_request_evt(hdev, skb);
3673 break;
3674
1da177e4
LT		 3675 case HCI_EV_DISCONN_COMPLETE:
3676 hci_disconn_complete_evt(hdev, skb);
3677 break;
3678
1da177e4
LT		 3679 case HCI_EV_AUTH_COMPLETE:
3680 hci_auth_complete_evt(hdev, skb);
3681 break;
3682
a9de9248
MH		 3683 case HCI_EV_REMOTE_NAME:
3684 hci_remote_name_evt(hdev, skb);
3685 break;
3686
1da177e4
LT		 3687 case HCI_EV_ENCRYPT_CHANGE:
3688 hci_encrypt_change_evt(hdev, skb);
3689 break;
3690
a9de9248
MH		 3691 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
3692 hci_change_link_key_complete_evt(hdev, skb);
3693 break;
3694
3695 case HCI_EV_REMOTE_FEATURES:
3696 hci_remote_features_evt(hdev, skb);
3697 break;
3698
a9de9248
MH		 3699 case HCI_EV_CMD_COMPLETE:
3700 hci_cmd_complete_evt(hdev, skb);
3701 break;
3702
3703 case HCI_EV_CMD_STATUS:
3704 hci_cmd_status_evt(hdev, skb);
3705 break;
3706
3707 case HCI_EV_ROLE_CHANGE:
3708 hci_role_change_evt(hdev, skb);
3709 break;
3710
3711 case HCI_EV_NUM_COMP_PKTS:
3712 hci_num_comp_pkts_evt(hdev, skb);
3713 break;
3714
3715 case HCI_EV_MODE_CHANGE:
3716 hci_mode_change_evt(hdev, skb);
1da177e4
LT		 3717 break;
3718
3719 case HCI_EV_PIN_CODE_REQ:
3720 hci_pin_code_request_evt(hdev, skb);
3721 break;
3722
3723 case HCI_EV_LINK_KEY_REQ:
3724 hci_link_key_request_evt(hdev, skb);
3725 break;
3726
3727 case HCI_EV_LINK_KEY_NOTIFY:
3728 hci_link_key_notify_evt(hdev, skb);
3729 break;
3730
3731 case HCI_EV_CLOCK_OFFSET:
3732 hci_clock_offset_evt(hdev, skb);
3733 break;
3734
a8746417
MH		 3735 case HCI_EV_PKT_TYPE_CHANGE:
3736 hci_pkt_type_change_evt(hdev, skb);
3737 break;
3738
85a1e930
MH		 3739 case HCI_EV_PSCAN_REP_MODE:
3740 hci_pscan_rep_mode_evt(hdev, skb);
3741 break;
3742
a9de9248
MH		 3743 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
3744 hci_inquiry_result_with_rssi_evt(hdev, skb);
04837f64
MH		 3745 break;
3746
a9de9248
MH		 3747 case HCI_EV_REMOTE_EXT_FEATURES:
3748 hci_remote_ext_features_evt(hdev, skb);
1da177e4
LT		 3749 break;
3750
a9de9248
MH		 3751 case HCI_EV_SYNC_CONN_COMPLETE:
3752 hci_sync_conn_complete_evt(hdev, skb);
3753 break;
1da177e4 3754
a9de9248
MH		 3755 case HCI_EV_EXTENDED_INQUIRY_RESULT:
3756 hci_extended_inquiry_result_evt(hdev, skb);
3757 break;
1da177e4 3758
1c2e0041
JH		 3759 case HCI_EV_KEY_REFRESH_COMPLETE:
3760 hci_key_refresh_complete_evt(hdev, skb);
3761 break;
3762
0493684e
MH		 3763 case HCI_EV_IO_CAPA_REQUEST:
3764 hci_io_capa_request_evt(hdev, skb);
3765 break;
3766
03b555e1
JH		 3767 case HCI_EV_IO_CAPA_REPLY:
3768 hci_io_capa_reply_evt(hdev, skb);
3769 break;
3770
a5c29683
JH		 3771 case HCI_EV_USER_CONFIRM_REQUEST:
3772 hci_user_confirm_request_evt(hdev, skb);
3773 break;
3774
1143d458
BG		 3775 case HCI_EV_USER_PASSKEY_REQUEST:
3776 hci_user_passkey_request_evt(hdev, skb);
3777 break;
3778
92a25256
JH		 3779 case HCI_EV_USER_PASSKEY_NOTIFY:
3780 hci_user_passkey_notify_evt(hdev, skb);
3781 break;
3782
3783 case HCI_EV_KEYPRESS_NOTIFY:
3784 hci_keypress_notify_evt(hdev, skb);
3785 break;
3786
0493684e
MH		 3787 case HCI_EV_SIMPLE_PAIR_COMPLETE:
3788 hci_simple_pair_complete_evt(hdev, skb);
3789 break;
3790
41a96212
MH		 3791 case HCI_EV_REMOTE_HOST_FEATURES:
3792 hci_remote_host_features_evt(hdev, skb);
3793 break;
3794
fcd89c09
VT		 3795 case HCI_EV_LE_META:
3796 hci_le_meta_evt(hdev, skb);
3797 break;
3798
9495b2ee
AE		 3799 case HCI_EV_CHANNEL_SELECTED:
3800 hci_chan_selected_evt(hdev, skb);
3801 break;
3802
2763eda6
SJ		 3803 case HCI_EV_REMOTE_OOB_DATA_REQUEST:
3804 hci_remote_oob_data_request_evt(hdev, skb);
3805 break;
3806
d5e91192
AE		 3807 case HCI_EV_PHY_LINK_COMPLETE:
3808 hci_phy_link_complete_evt(hdev, skb);
3809 break;
3810
27695fb4
AE		 3811 case HCI_EV_LOGICAL_LINK_COMPLETE:
3812 hci_loglink_complete_evt(hdev, skb);
3813 break;
3814
606e2a10
AE		 3815 case HCI_EV_DISCONN_LOGICAL_LINK_COMPLETE:
3816 hci_disconn_loglink_complete_evt(hdev, skb);
3817 break;
3818
9eef6b3a
AE		 3819 case HCI_EV_DISCONN_PHY_LINK_COMPLETE:
3820 hci_disconn_phylink_complete_evt(hdev, skb);
3821 break;
3822
25e89e99
AE		 3823 case HCI_EV_NUM_COMP_BLOCKS:
3824 hci_num_comp_blocks_evt(hdev, skb);
3825 break;
3826
a9de9248 3827 default:
9f1db00c 3828 BT_DBG("%s event 0x%2.2x", hdev->name, event);
1da177e4
LT		 3829 break;
3830 }
3831
3832 kfree_skb(skb);
3833 hdev->stat.evt_rx++;
3834}
Linux kernel - Deliverables
This page took 1.589276 seconds and 5 git commands to generate.