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