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