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