projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Remove page timeout setting from HCI init sequence
[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
1da177e4
LT		 48/* Handle HCI Event packets */
49
a9de9248 50static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 51{
a9de9248 52 __u8 status = *((__u8 *) skb->data);
1da177e4 53
a9de9248 54 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 55
a9de9248
MH		 56 if (status)
57 return;
1da177e4 58
a9de9248 59 clear_bit(HCI_INQUIRY, &hdev->flags);
6bd57416 60
23bb5763 61 hci_req_complete(hdev, HCI_OP_INQUIRY_CANCEL, status);
a9de9248
MH		 62
63 hci_conn_check_pending(hdev);
64}
6bd57416 65
a9de9248
MH		 66static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
67{
68 __u8 status = *((__u8 *) skb->data);
6bd57416 69
a9de9248 70 BT_DBG("%s status 0x%x", hdev->name, status);
6bd57416 71
a9de9248
MH		 72 if (status)
73 return;
1da177e4 74
a9de9248
MH		 75 clear_bit(HCI_INQUIRY, &hdev->flags);
76
77 hci_conn_check_pending(hdev);
78}
79
80static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
81{
82 BT_DBG("%s", hdev->name);
83}
84
85static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
86{
87 struct hci_rp_role_discovery *rp = (void *) skb->data;
88 struct hci_conn *conn;
89
90 BT_DBG("%s status 0x%x", hdev->name, rp->status);
91
92 if (rp->status)
93 return;
94
95 hci_dev_lock(hdev);
96
97 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
98 if (conn) {
99 if (rp->role)
100 conn->link_mode &= ~HCI_LM_MASTER;
101 else
102 conn->link_mode |= HCI_LM_MASTER;
1da177e4 103 }
a9de9248
MH		 104
105 hci_dev_unlock(hdev);
1da177e4
LT		 106}
107
e4e8e37c
MH		 108static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
109{
110 struct hci_rp_read_link_policy *rp = (void *) skb->data;
111 struct hci_conn *conn;
112
113 BT_DBG("%s status 0x%x", hdev->name, rp->status);
114
115 if (rp->status)
116 return;
117
118 hci_dev_lock(hdev);
119
120 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
121 if (conn)
122 conn->link_policy = __le16_to_cpu(rp->policy);
123
124 hci_dev_unlock(hdev);
125}
126
a9de9248 127static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 128{
a9de9248 129 struct hci_rp_write_link_policy *rp = (void *) skb->data;
1da177e4 130 struct hci_conn *conn;
04837f64 131 void *sent;
1da177e4 132
a9de9248 133 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 134
a9de9248
MH		 135 if (rp->status)
136 return;
1da177e4 137
a9de9248
MH		 138 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
139 if (!sent)
140 return;
1da177e4 141
a9de9248 142 hci_dev_lock(hdev);
1da177e4 143
a9de9248 144 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
e4e8e37c 145 if (conn)
83985319 146 conn->link_policy = get_unaligned_le16(sent + 2);
1da177e4 147
a9de9248
MH		 148 hci_dev_unlock(hdev);
149}
1da177e4 150
e4e8e37c
MH		 151static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
152{
153 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
154
155 BT_DBG("%s status 0x%x", hdev->name, rp->status);
156
157 if (rp->status)
158 return;
159
160 hdev->link_policy = __le16_to_cpu(rp->policy);
161}
162
163static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
164{
165 __u8 status = *((__u8 *) skb->data);
166 void *sent;
167
168 BT_DBG("%s status 0x%x", hdev->name, status);
169
170 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
171 if (!sent)
172 return;
173
174 if (!status)
175 hdev->link_policy = get_unaligned_le16(sent);
176
23bb5763 177 hci_req_complete(hdev, HCI_OP_WRITE_DEF_LINK_POLICY, status);
e4e8e37c
MH		 178}
179
a9de9248
MH		 180static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
181{
182 __u8 status = *((__u8 *) skb->data);
04837f64 183
a9de9248 184 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 185
23bb5763 186 hci_req_complete(hdev, HCI_OP_RESET, status);
a9de9248 187}
04837f64 188
a9de9248
MH		 189static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
190{
191 __u8 status = *((__u8 *) skb->data);
192 void *sent;
04837f64 193
a9de9248 194 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 195
f383f275
MH		 196 if (status)
197 return;
198
a9de9248
MH		 199 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
200 if (!sent)
201 return;
04837f64 202
f383f275 203 memcpy(hdev->dev_name, sent, 248);
a9de9248
MH		 204}
205
206static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
207{
208 struct hci_rp_read_local_name *rp = (void *) skb->data;
209
210 BT_DBG("%s status 0x%x", hdev->name, rp->status);
211
212 if (rp->status)
213 return;
214
215 memcpy(hdev->dev_name, rp->name, 248);
216}
217
218static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
219{
220 __u8 status = *((__u8 *) skb->data);
221 void *sent;
222
223 BT_DBG("%s status 0x%x", hdev->name, status);
224
225 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
226 if (!sent)
227 return;
228
229 if (!status) {
230 __u8 param = *((__u8 *) sent);
231
232 if (param == AUTH_ENABLED)
233 set_bit(HCI_AUTH, &hdev->flags);
234 else
235 clear_bit(HCI_AUTH, &hdev->flags);
1da177e4 236 }
a9de9248 237
23bb5763 238 hci_req_complete(hdev, HCI_OP_WRITE_AUTH_ENABLE, status);
1da177e4
LT		 239}
240
a9de9248 241static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 242{
a9de9248 243 __u8 status = *((__u8 *) skb->data);
1da177e4
LT		 244 void *sent;
245
a9de9248 246 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 247
a9de9248
MH		 248 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
249 if (!sent)
250 return;
1da177e4 251
a9de9248
MH		 252 if (!status) {
253 __u8 param = *((__u8 *) sent);
254
255 if (param)
256 set_bit(HCI_ENCRYPT, &hdev->flags);
257 else
258 clear_bit(HCI_ENCRYPT, &hdev->flags);
259 }
1da177e4 260
23bb5763 261 hci_req_complete(hdev, HCI_OP_WRITE_ENCRYPT_MODE, status);
a9de9248 262}
1da177e4 263
a9de9248
MH		 264static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
265{
266 __u8 status = *((__u8 *) skb->data);
267 void *sent;
1da177e4 268
a9de9248 269 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 270
a9de9248
MH		 271 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
272 if (!sent)
273 return;
1da177e4 274
a9de9248
MH		 275 if (!status) {
276 __u8 param = *((__u8 *) sent);
9fbcbb45 277 int old_pscan, old_iscan;
1da177e4 278
9fbcbb45
JH		 279 old_pscan = test_and_clear_bit(HCI_PSCAN, &hdev->flags);
280 old_iscan = test_and_clear_bit(HCI_ISCAN, &hdev->flags);
1da177e4 281
73f22f62 282 if (param & SCAN_INQUIRY) {
a9de9248 283 set_bit(HCI_ISCAN, &hdev->flags);
9fbcbb45
JH		 284 if (!old_iscan)
285 mgmt_discoverable(hdev->id, 1);
286 } else if (old_iscan)
73f22f62 287 mgmt_discoverable(hdev->id, 0);
1da177e4 288
9fbcbb45 289 if (param & SCAN_PAGE) {
a9de9248 290 set_bit(HCI_PSCAN, &hdev->flags);
9fbcbb45
JH		 291 if (!old_pscan)
292 mgmt_connectable(hdev->id, 1);
293 } else if (old_pscan)
294 mgmt_connectable(hdev->id, 0);
a9de9248 295 }
1da177e4 296
23bb5763 297 hci_req_complete(hdev, HCI_OP_WRITE_SCAN_ENABLE, status);
a9de9248 298}
1da177e4 299
a9de9248
MH		 300static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
301{
302 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
1da177e4 303
a9de9248 304 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 305
a9de9248
MH		 306 if (rp->status)
307 return;
1da177e4 308
a9de9248 309 memcpy(hdev->dev_class, rp->dev_class, 3);
1da177e4 310
a9de9248
MH		 311 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
312 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
313}
1da177e4 314
a9de9248
MH		 315static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
316{
317 __u8 status = *((__u8 *) skb->data);
318 void *sent;
1da177e4 319
a9de9248 320 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 321
f383f275
MH		 322 if (status)
323 return;
324
a9de9248
MH		 325 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
326 if (!sent)
327 return;
1da177e4 328
f383f275 329 memcpy(hdev->dev_class, sent, 3);
a9de9248 330}
1da177e4 331
a9de9248
MH		 332static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
333{
334 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
335 __u16 setting;
336
337 BT_DBG("%s status 0x%x", hdev->name, rp->status);
338
339 if (rp->status)
340 return;
341
342 setting = __le16_to_cpu(rp->voice_setting);
343
f383f275 344 if (hdev->voice_setting == setting)
a9de9248
MH		 345 return;
346
347 hdev->voice_setting = setting;
348
349 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
350
351 if (hdev->notify) {
352 tasklet_disable(&hdev->tx_task);
353 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
354 tasklet_enable(&hdev->tx_task);
355 }
356}
357
358static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
359{
360 __u8 status = *((__u8 *) skb->data);
f383f275 361 __u16 setting;
a9de9248
MH		 362 void *sent;
363
364 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 365
f383f275
MH		 366 if (status)
367 return;
368
a9de9248
MH		 369 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
370 if (!sent)
371 return;
1da177e4 372
f383f275 373 setting = get_unaligned_le16(sent);
1da177e4 374
f383f275
MH		 375 if (hdev->voice_setting == setting)
376 return;
377
378 hdev->voice_setting = setting;
1da177e4 379
f383f275 380 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
1da177e4 381
f383f275
MH		 382 if (hdev->notify) {
383 tasklet_disable(&hdev->tx_task);
384 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
385 tasklet_enable(&hdev->tx_task);
1da177e4
LT		 386 }
387}
388
a9de9248 389static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 390{
a9de9248 391 __u8 status = *((__u8 *) skb->data);
1da177e4 392
a9de9248 393 BT_DBG("%s status 0x%x", hdev->name, status);
1da177e4 394
23bb5763 395 hci_req_complete(hdev, HCI_OP_HOST_BUFFER_SIZE, status);
a9de9248 396}
1143e5a6 397
333140b5
MH		 398static void hci_cc_read_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
399{
400 struct hci_rp_read_ssp_mode *rp = (void *) skb->data;
401
402 BT_DBG("%s status 0x%x", hdev->name, rp->status);
403
404 if (rp->status)
405 return;
406
407 hdev->ssp_mode = rp->mode;
408}
409
410static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb)
411{
412 __u8 status = *((__u8 *) skb->data);
413 void *sent;
414
415 BT_DBG("%s status 0x%x", hdev->name, status);
416
417 if (status)
418 return;
419
420 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE);
421 if (!sent)
422 return;
423
424 hdev->ssp_mode = *((__u8 *) sent);
425}
426
a9de9248
MH		 427static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
428{
429 struct hci_rp_read_local_version *rp = (void *) skb->data;
1143e5a6 430
a9de9248 431 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1143e5a6 432
a9de9248
MH		 433 if (rp->status)
434 return;
1143e5a6 435
a9de9248 436 hdev->hci_ver = rp->hci_ver;
e4e8e37c
MH		 437 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
438 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
1143e5a6 439
a9de9248
MH		 440 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
441 hdev->manufacturer,
442 hdev->hci_ver, hdev->hci_rev);
443}
1da177e4 444
a9de9248
MH		 445static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
446{
447 struct hci_rp_read_local_commands *rp = (void *) skb->data;
1da177e4 448
a9de9248 449 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 450
a9de9248
MH		 451 if (rp->status)
452 return;
1da177e4 453
a9de9248
MH		 454 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
455}
1da177e4 456
a9de9248
MH		 457static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
458{
459 struct hci_rp_read_local_features *rp = (void *) skb->data;
5b7f9909 460
a9de9248 461 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 462
a9de9248
MH		 463 if (rp->status)
464 return;
5b7f9909 465
a9de9248 466 memcpy(hdev->features, rp->features, 8);
5b7f9909 467
a9de9248
MH		 468 /* Adjust default settings according to features
469 * supported by device. */
1da177e4 470
a9de9248
MH		 471 if (hdev->features[0] & LMP_3SLOT)
472 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
1da177e4 473
a9de9248
MH		 474 if (hdev->features[0] & LMP_5SLOT)
475 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
1da177e4 476
a9de9248
MH		 477 if (hdev->features[1] & LMP_HV2) {
478 hdev->pkt_type |= (HCI_HV2);
479 hdev->esco_type |= (ESCO_HV2);
480 }
1da177e4 481
a9de9248
MH		 482 if (hdev->features[1] & LMP_HV3) {
483 hdev->pkt_type |= (HCI_HV3);
484 hdev->esco_type |= (ESCO_HV3);
485 }
1da177e4 486
a9de9248
MH		 487 if (hdev->features[3] & LMP_ESCO)
488 hdev->esco_type |= (ESCO_EV3);
da1f5198 489
a9de9248
MH		 490 if (hdev->features[4] & LMP_EV4)
491 hdev->esco_type |= (ESCO_EV4);
da1f5198 492
a9de9248
MH		 493 if (hdev->features[4] & LMP_EV5)
494 hdev->esco_type |= (ESCO_EV5);
1da177e4 495
efc7688b
MH		 496 if (hdev->features[5] & LMP_EDR_ESCO_2M)
497 hdev->esco_type |= (ESCO_2EV3);
498
499 if (hdev->features[5] & LMP_EDR_ESCO_3M)
500 hdev->esco_type |= (ESCO_3EV3);
501
502 if (hdev->features[5] & LMP_EDR_3S_ESCO)
503 hdev->esco_type |= (ESCO_2EV5 | ESCO_3EV5);
504
a9de9248
MH		 505 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
506 hdev->features[0], hdev->features[1],
507 hdev->features[2], hdev->features[3],
508 hdev->features[4], hdev->features[5],
509 hdev->features[6], hdev->features[7]);
510}
1da177e4 511
a9de9248
MH		 512static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
513{
514 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
1da177e4 515
a9de9248 516 BT_DBG("%s status 0x%x", hdev->name, rp->status);
1da177e4 517
a9de9248
MH		 518 if (rp->status)
519 return;
1da177e4 520
a9de9248
MH		 521 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
522 hdev->sco_mtu = rp->sco_mtu;
523 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
524 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
525
526 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
527 hdev->sco_mtu = 64;
528 hdev->sco_pkts = 8;
1da177e4 529 }
a9de9248
MH		 530
531 hdev->acl_cnt = hdev->acl_pkts;
532 hdev->sco_cnt = hdev->sco_pkts;
533
534 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
535 hdev->acl_mtu, hdev->acl_pkts,
536 hdev->sco_mtu, hdev->sco_pkts);
537}
538
539static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
540{
541 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
542
543 BT_DBG("%s status 0x%x", hdev->name, rp->status);
544
545 if (!rp->status)
546 bacpy(&hdev->bdaddr, &rp->bdaddr);
547
23bb5763
JH		 548 hci_req_complete(hdev, HCI_OP_READ_BD_ADDR, rp->status);
549}
550
551static void hci_cc_write_ca_timeout(struct hci_dev *hdev, struct sk_buff *skb)
552{
553 __u8 status = *((__u8 *) skb->data);
554
555 BT_DBG("%s status 0x%x", hdev->name, status);
556
557 hci_req_complete(hdev, HCI_OP_WRITE_CA_TIMEOUT, status);
a9de9248
MH		 558}
559
b0916ea0
JH		 560static void hci_cc_delete_stored_link_key(struct hci_dev *hdev,
561 struct sk_buff *skb)
562{
563 __u8 status = *((__u8 *) skb->data);
564
565 BT_DBG("%s status 0x%x", hdev->name, status);
566
567 hci_req_complete(hdev, HCI_OP_DELETE_STORED_LINK_KEY, status);
568}
569
a9de9248
MH		 570static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
571{
572 BT_DBG("%s status 0x%x", hdev->name, status);
573
574 if (status) {
23bb5763 575 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
a9de9248
MH		 576
577 hci_conn_check_pending(hdev);
578 } else
579 set_bit(HCI_INQUIRY, &hdev->flags);
1da177e4
LT		 580}
581
1da177e4
LT		 582static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
583{
a9de9248 584 struct hci_cp_create_conn *cp;
1da177e4 585 struct hci_conn *conn;
1da177e4 586
a9de9248
MH		 587 BT_DBG("%s status 0x%x", hdev->name, status);
588
589 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
1da177e4
LT		 590 if (!cp)
591 return;
592
593 hci_dev_lock(hdev);
594
595 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
596
a9de9248 597 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
1da177e4
LT		 598
599 if (status) {
600 if (conn && conn->state == BT_CONNECT) {
4c67bc74
MH		 601 if (status != 0x0c || conn->attempt > 2) {
602 conn->state = BT_CLOSED;
603 hci_proto_connect_cfm(conn, status);
604 hci_conn_del(conn);
605 } else
606 conn->state = BT_CONNECT2;
1da177e4
LT		 607 }
608 } else {
609 if (!conn) {
610 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
611 if (conn) {
612 conn->out = 1;
613 conn->link_mode |= HCI_LM_MASTER;
614 } else
893ef971 615 BT_ERR("No memory for new connection");
1da177e4
LT		 616 }
617 }
618
619 hci_dev_unlock(hdev);
620}
621
a9de9248 622static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
1da177e4 623{
a9de9248
MH		 624 struct hci_cp_add_sco *cp;
625 struct hci_conn *acl, *sco;
626 __u16 handle;
1da177e4 627
b6a0dc82
MH		 628 BT_DBG("%s status 0x%x", hdev->name, status);
629
a9de9248
MH		 630 if (!status)
631 return;
1da177e4 632
a9de9248
MH		 633 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
634 if (!cp)
635 return;
1da177e4 636
a9de9248 637 handle = __le16_to_cpu(cp->handle);
1da177e4 638
a9de9248 639 BT_DBG("%s handle %d", hdev->name, handle);
1da177e4 640
a9de9248 641 hci_dev_lock(hdev);
1da177e4 642
a9de9248
MH		 643 acl = hci_conn_hash_lookup_handle(hdev, handle);
644 if (acl && (sco = acl->link)) {
645 sco->state = BT_CLOSED;
1da177e4 646
a9de9248
MH		 647 hci_proto_connect_cfm(sco, status);
648 hci_conn_del(sco);
649 }
1da177e4 650
a9de9248
MH		 651 hci_dev_unlock(hdev);
652}
1da177e4 653
f8558555
MH		 654static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
655{
656 struct hci_cp_auth_requested *cp;
657 struct hci_conn *conn;
658
659 BT_DBG("%s status 0x%x", hdev->name, status);
660
661 if (!status)
662 return;
663
664 cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
665 if (!cp)
666 return;
667
668 hci_dev_lock(hdev);
669
670 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
671 if (conn) {
672 if (conn->state == BT_CONFIG) {
673 hci_proto_connect_cfm(conn, status);
674 hci_conn_put(conn);
675 }
676 }
677
678 hci_dev_unlock(hdev);
679}
680
681static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
682{
683 struct hci_cp_set_conn_encrypt *cp;
684 struct hci_conn *conn;
685
686 BT_DBG("%s status 0x%x", hdev->name, status);
687
688 if (!status)
689 return;
690
691 cp = hci_sent_cmd_data(hdev, HCI_OP_SET_CONN_ENCRYPT);
692 if (!cp)
693 return;
694
695 hci_dev_lock(hdev);
696
697 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
698 if (conn) {
699 if (conn->state == BT_CONFIG) {
700 hci_proto_connect_cfm(conn, status);
701 hci_conn_put(conn);
702 }
703 }
704
705 hci_dev_unlock(hdev);
706}
707
127178d2 708static int hci_outgoing_auth_needed(struct hci_dev *hdev,
392599b9
JH		 709 struct hci_conn *conn)
710{
392599b9
JH		 711 if (conn->state != BT_CONFIG || !conn->out)
712 return 0;
713
765c2a96 714 if (conn->pending_sec_level == BT_SECURITY_SDP)
392599b9
JH		 715 return 0;
716
717 /* Only request authentication for SSP connections or non-SSP
718 * devices with sec_level HIGH */
719 if (!(hdev->ssp_mode > 0 && conn->ssp_mode > 0) &&
765c2a96 720 conn->pending_sec_level != BT_SECURITY_HIGH)
392599b9
JH		 721 return 0;
722
392599b9
JH		 723 return 1;
724}
725
a9de9248
MH		 726static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
727{
127178d2
JH		 728 struct hci_cp_remote_name_req *cp;
729 struct hci_conn *conn;
730
a9de9248 731 BT_DBG("%s status 0x%x", hdev->name, status);
127178d2
JH		 732
733 /* If successful wait for the name req complete event before
734 * checking for the need to do authentication */
735 if (!status)
736 return;
737
738 cp = hci_sent_cmd_data(hdev, HCI_OP_REMOTE_NAME_REQ);
739 if (!cp)
740 return;
741
742 hci_dev_lock(hdev);
743
744 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
745 if (conn && hci_outgoing_auth_needed(hdev, conn)) {
746 struct hci_cp_auth_requested cp;
747 cp.handle = __cpu_to_le16(conn->handle);
748 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
749 }
750
751 hci_dev_unlock(hdev);
a9de9248 752}
1da177e4 753
769be974
MH		 754static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
755{
756 struct hci_cp_read_remote_features *cp;
757 struct hci_conn *conn;
758
759 BT_DBG("%s status 0x%x", hdev->name, status);
760
761 if (!status)
762 return;
763
764 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
765 if (!cp)
766 return;
767
768 hci_dev_lock(hdev);
769
770 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
771 if (conn) {
772 if (conn->state == BT_CONFIG) {
769be974
MH		 773 hci_proto_connect_cfm(conn, status);
774 hci_conn_put(conn);
775 }
776 }
777
778 hci_dev_unlock(hdev);
779}
780
781static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
782{
783 struct hci_cp_read_remote_ext_features *cp;
784 struct hci_conn *conn;
785
786 BT_DBG("%s status 0x%x", hdev->name, status);
787
788 if (!status)
789 return;
790
791 cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
792 if (!cp)
793 return;
794
795 hci_dev_lock(hdev);
796
797 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
798 if (conn) {
799 if (conn->state == BT_CONFIG) {
769be974
MH		 800 hci_proto_connect_cfm(conn, status);
801 hci_conn_put(conn);
802 }
803 }
804
805 hci_dev_unlock(hdev);
806}
807
a9de9248
MH		 808static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
809{
b6a0dc82
MH		 810 struct hci_cp_setup_sync_conn *cp;
811 struct hci_conn *acl, *sco;
812 __u16 handle;
813
a9de9248 814 BT_DBG("%s status 0x%x", hdev->name, status);
b6a0dc82
MH		 815
816 if (!status)
817 return;
818
819 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
820 if (!cp)
821 return;
822
823 handle = __le16_to_cpu(cp->handle);
824
825 BT_DBG("%s handle %d", hdev->name, handle);
826
827 hci_dev_lock(hdev);
828
829 acl = hci_conn_hash_lookup_handle(hdev, handle);
830 if (acl && (sco = acl->link)) {
831 sco->state = BT_CLOSED;
832
833 hci_proto_connect_cfm(sco, status);
834 hci_conn_del(sco);
835 }
836
837 hci_dev_unlock(hdev);
1da177e4
LT		 838}
839
a9de9248 840static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
1da177e4 841{
a9de9248
MH		 842 struct hci_cp_sniff_mode *cp;
843 struct hci_conn *conn;
1da177e4 844
a9de9248 845 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 846
a9de9248
MH		 847 if (!status)
848 return;
04837f64 849
a9de9248
MH		 850 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
851 if (!cp)
852 return;
04837f64 853
a9de9248 854 hci_dev_lock(hdev);
04837f64 855
a9de9248 856 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
e73439d8 857 if (conn) {
a9de9248 858 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
04837f64 859
e73439d8
MH		 860 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
861 hci_sco_setup(conn, status);
862 }
863
a9de9248
MH		 864 hci_dev_unlock(hdev);
865}
04837f64 866
a9de9248
MH		 867static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
868{
869 struct hci_cp_exit_sniff_mode *cp;
870 struct hci_conn *conn;
04837f64 871
a9de9248 872 BT_DBG("%s status 0x%x", hdev->name, status);
04837f64 873
a9de9248
MH		 874 if (!status)
875 return;
04837f64 876
a9de9248
MH		 877 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
878 if (!cp)
879 return;
04837f64 880
a9de9248 881 hci_dev_lock(hdev);
1da177e4 882
a9de9248 883 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
e73439d8 884 if (conn) {
a9de9248 885 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
1da177e4 886
e73439d8
MH		 887 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
888 hci_sco_setup(conn, status);
889 }
890
a9de9248 891 hci_dev_unlock(hdev);
1da177e4
LT		 892}
893
1da177e4
LT		 894static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
895{
896 __u8 status = *((__u8 *) skb->data);
897
898 BT_DBG("%s status %d", hdev->name, status);
899
900 clear_bit(HCI_INQUIRY, &hdev->flags);
6bd57416 901
23bb5763 902 hci_req_complete(hdev, HCI_OP_INQUIRY, status);
6bd57416 903
a9de9248 904 hci_conn_check_pending(hdev);
1da177e4
LT		 905}
906
1da177e4
LT		 907static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
908{
45bb4bf0 909 struct inquiry_data data;
a9de9248 910 struct inquiry_info *info = (void *) (skb->data + 1);
1da177e4
LT		 911 int num_rsp = *((__u8 *) skb->data);
912
913 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
914
45bb4bf0
MH		 915 if (!num_rsp)
916 return;
917
1da177e4 918 hci_dev_lock(hdev);
45bb4bf0 919
1da177e4 920 for (; num_rsp; num_rsp--) {
1da177e4
LT		 921 bacpy(&data.bdaddr, &info->bdaddr);
922 data.pscan_rep_mode = info->pscan_rep_mode;
923 data.pscan_period_mode = info->pscan_period_mode;
924 data.pscan_mode = info->pscan_mode;
925 memcpy(data.dev_class, info->dev_class, 3);
926 data.clock_offset = info->clock_offset;
927 data.rssi = 0x00;
41a96212 928 data.ssp_mode = 0x00;
1da177e4
LT		 929 info++;
930 hci_inquiry_cache_update(hdev, &data);
931 }
45bb4bf0 932
1da177e4
LT		 933 hci_dev_unlock(hdev);
934}
935
1da177e4
LT		 936static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
937{
a9de9248
MH		 938 struct hci_ev_conn_complete *ev = (void *) skb->data;
939 struct hci_conn *conn;
1da177e4
LT		 940
941 BT_DBG("%s", hdev->name);
942
943 hci_dev_lock(hdev);
944
945 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
9499237a
MH		 946 if (!conn) {
947 if (ev->link_type != SCO_LINK)
948 goto unlock;
949
950 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
951 if (!conn)
952 goto unlock;
953
954 conn->type = SCO_LINK;
955 }
1da177e4
LT		 956
957 if (!ev->status) {
958 conn->handle = __le16_to_cpu(ev->handle);
769be974
MH		 959
960 if (conn->type == ACL_LINK) {
961 conn->state = BT_CONFIG;
962 hci_conn_hold(conn);
052b30b0 963 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
769be974
MH		 964 } else
965 conn->state = BT_CONNECTED;
1da177e4 966
9eba32b8 967 hci_conn_hold_device(conn);
7d0db0a3
MH		 968 hci_conn_add_sysfs(conn);
969
1da177e4
LT		 970 if (test_bit(HCI_AUTH, &hdev->flags))
971 conn->link_mode |= HCI_LM_AUTH;
972
973 if (test_bit(HCI_ENCRYPT, &hdev->flags))
974 conn->link_mode |= HCI_LM_ENCRYPT;
975
04837f64
MH		 976 /* Get remote features */
977 if (conn->type == ACL_LINK) {
978 struct hci_cp_read_remote_features cp;
979 cp.handle = ev->handle;
769be974
MH		 980 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
981 sizeof(cp), &cp);
04837f64
MH		 982 }
983
1da177e4 984 /* Set packet type for incoming connection */
a8746417 985 if (!conn->out && hdev->hci_ver < 3) {
1da177e4
LT		 986 struct hci_cp_change_conn_ptype cp;
987 cp.handle = ev->handle;
a8746417
MH		 988 cp.pkt_type = cpu_to_le16(conn->pkt_type);
989 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
990 sizeof(cp), &cp);
1da177e4
LT		 991 }
992 } else
993 conn->state = BT_CLOSED;
994
e73439d8
MH		 995 if (conn->type == ACL_LINK)
996 hci_sco_setup(conn, ev->status);
1da177e4 997
769be974
MH		 998 if (ev->status) {
999 hci_proto_connect_cfm(conn, ev->status);
1da177e4 1000 hci_conn_del(conn);
c89b6e6b
MH		 1001 } else if (ev->link_type != ACL_LINK)
1002 hci_proto_connect_cfm(conn, ev->status);
1da177e4 1003
a9de9248 1004unlock:
1da177e4 1005 hci_dev_unlock(hdev);
1da177e4 1006
a9de9248 1007 hci_conn_check_pending(hdev);
1da177e4
LT		 1008}
1009
a9de9248 1010static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1011{
a9de9248
MH		 1012 struct hci_ev_conn_request *ev = (void *) skb->data;
1013 int mask = hdev->link_mode;
1da177e4 1014
a9de9248
MH		 1015 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
1016 batostr(&ev->bdaddr), ev->link_type);
1da177e4 1017
a9de9248 1018 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
1da177e4 1019
f0358568 1020 if ((mask & HCI_LM_ACCEPT) && !hci_blacklist_lookup(hdev, &ev->bdaddr)) {
a9de9248 1021 /* Connection accepted */
c7bdd502 1022 struct inquiry_entry *ie;
1da177e4 1023 struct hci_conn *conn;
1da177e4 1024
a9de9248 1025 hci_dev_lock(hdev);
b6a0dc82 1026
cc11b9c1
AE		 1027 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1028 if (ie)
c7bdd502
MH		 1029 memcpy(ie->data.dev_class, ev->dev_class, 3);
1030
a9de9248
MH		 1031 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1032 if (!conn) {
cc11b9c1
AE		 1033 conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr);
1034 if (!conn) {
893ef971 1035 BT_ERR("No memory for new connection");
a9de9248
MH		 1036 hci_dev_unlock(hdev);
1037 return;
1da177e4
LT		 1038 }
1039 }
b6a0dc82 1040
a9de9248
MH		 1041 memcpy(conn->dev_class, ev->dev_class, 3);
1042 conn->state = BT_CONNECT;
b6a0dc82 1043
a9de9248 1044 hci_dev_unlock(hdev);
1da177e4 1045
b6a0dc82
MH		 1046 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
1047 struct hci_cp_accept_conn_req cp;
1da177e4 1048
b6a0dc82
MH		 1049 bacpy(&cp.bdaddr, &ev->bdaddr);
1050
1051 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
1052 cp.role = 0x00; /* Become master */
1053 else
1054 cp.role = 0x01; /* Remain slave */
1055
1056 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
1057 sizeof(cp), &cp);
1058 } else {
1059 struct hci_cp_accept_sync_conn_req cp;
1060
1061 bacpy(&cp.bdaddr, &ev->bdaddr);
a8746417 1062 cp.pkt_type = cpu_to_le16(conn->pkt_type);
b6a0dc82
MH		 1063
1064 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
1065 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
1066 cp.max_latency = cpu_to_le16(0xffff);
1067 cp.content_format = cpu_to_le16(hdev->voice_setting);
1068 cp.retrans_effort = 0xff;
1da177e4 1069
b6a0dc82
MH		 1070 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
1071 sizeof(cp), &cp);
1072 }
a9de9248
MH		 1073 } else {
1074 /* Connection rejected */
1075 struct hci_cp_reject_conn_req cp;
1da177e4 1076
a9de9248
MH		 1077 bacpy(&cp.bdaddr, &ev->bdaddr);
1078 cp.reason = 0x0f;
1079 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
1da177e4 1080 }
1da177e4
LT		 1081}
1082
a9de9248 1083static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 1084{
a9de9248 1085 struct hci_ev_disconn_complete *ev = (void *) skb->data;
04837f64
MH		 1086 struct hci_conn *conn;
1087
1088 BT_DBG("%s status %d", hdev->name, ev->status);
1089
a9de9248
MH		 1090 if (ev->status)
1091 return;
1092
04837f64
MH		 1093 hci_dev_lock(hdev);
1094
1095 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1096 if (conn) {
a9de9248 1097 conn->state = BT_CLOSED;
7d0db0a3 1098
2950f21a 1099 hci_proto_disconn_cfm(conn, ev->reason);
a9de9248 1100 hci_conn_del(conn);
04837f64
MH		 1101 }
1102
1103 hci_dev_unlock(hdev);
1104}
1105
1da177e4
LT		 1106static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1107{
a9de9248 1108 struct hci_ev_auth_complete *ev = (void *) skb->data;
04837f64 1109 struct hci_conn *conn;
1da177e4
LT		 1110
1111 BT_DBG("%s status %d", hdev->name, ev->status);
1112
1113 hci_dev_lock(hdev);
1114
04837f64 1115 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4 1116 if (conn) {
765c2a96 1117 if (!ev->status) {
1da177e4 1118 conn->link_mode |= HCI_LM_AUTH;
765c2a96
JH		 1119 conn->sec_level = conn->pending_sec_level;
1120 } else
da213f41 1121 conn->sec_level = BT_SECURITY_LOW;
1da177e4
LT		 1122
1123 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1124
f8558555
MH		 1125 if (conn->state == BT_CONFIG) {
1126 if (!ev->status && hdev->ssp_mode > 0 &&
1127 conn->ssp_mode > 0) {
1128 struct hci_cp_set_conn_encrypt cp;
1129 cp.handle = ev->handle;
1130 cp.encrypt = 0x01;
1131 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1132 sizeof(cp), &cp);
1133 } else {
1134 conn->state = BT_CONNECTED;
1135 hci_proto_connect_cfm(conn, ev->status);
1136 hci_conn_put(conn);
1137 }
052b30b0 1138 } else {
f8558555 1139 hci_auth_cfm(conn, ev->status);
1da177e4 1140
052b30b0
MH		 1141 hci_conn_hold(conn);
1142 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
1143 hci_conn_put(conn);
1144 }
1145
1da177e4
LT		 1146 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1147 if (!ev->status) {
1148 struct hci_cp_set_conn_encrypt cp;
f8558555
MH		 1149 cp.handle = ev->handle;
1150 cp.encrypt = 0x01;
1151 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1152 sizeof(cp), &cp);
1da177e4
LT		 1153 } else {
1154 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1155 hci_encrypt_cfm(conn, ev->status, 0x00);
1156 }
1157 }
1158 }
1159
1160 hci_dev_unlock(hdev);
1161}
1162
a9de9248 1163static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1164{
127178d2
JH		 1165 struct hci_ev_remote_name *ev = (void *) skb->data;
1166 struct hci_conn *conn;
1167
a9de9248 1168 BT_DBG("%s", hdev->name);
1da177e4 1169
a9de9248 1170 hci_conn_check_pending(hdev);
127178d2
JH		 1171
1172 hci_dev_lock(hdev);
1173
1174 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1175 if (conn && hci_outgoing_auth_needed(hdev, conn)) {
1176 struct hci_cp_auth_requested cp;
1177 cp.handle = __cpu_to_le16(conn->handle);
1178 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
1179 }
1180
1181 hci_dev_unlock(hdev);
a9de9248
MH		 1182}
1183
1184static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1185{
1186 struct hci_ev_encrypt_change *ev = (void *) skb->data;
1187 struct hci_conn *conn;
1188
1189 BT_DBG("%s status %d", hdev->name, ev->status);
1da177e4
LT		 1190
1191 hci_dev_lock(hdev);
1192
04837f64 1193 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 1194 if (conn) {
1195 if (!ev->status) {
ae293196
MH		 1196 if (ev->encrypt) {
1197 /* Encryption implies authentication */
1198 conn->link_mode |= HCI_LM_AUTH;
1da177e4 1199 conn->link_mode |= HCI_LM_ENCRYPT;
ae293196 1200 } else
1da177e4
LT		 1201 conn->link_mode &= ~HCI_LM_ENCRYPT;
1202 }
1203
1204 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1205
f8558555
MH		 1206 if (conn->state == BT_CONFIG) {
1207 if (!ev->status)
1208 conn->state = BT_CONNECTED;
1209
1210 hci_proto_connect_cfm(conn, ev->status);
1211 hci_conn_put(conn);
1212 } else
1213 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
1da177e4
LT		 1214 }
1215
1216 hci_dev_unlock(hdev);
1217}
1218
a9de9248 1219static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1220{
a9de9248 1221 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
04837f64 1222 struct hci_conn *conn;
1da177e4
LT		 1223
1224 BT_DBG("%s status %d", hdev->name, ev->status);
1225
1226 hci_dev_lock(hdev);
1227
04837f64 1228 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 1229 if (conn) {
1230 if (!ev->status)
1231 conn->link_mode |= HCI_LM_SECURE;
1232
1233 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1234
1235 hci_key_change_cfm(conn, ev->status);
1236 }
1237
1238 hci_dev_unlock(hdev);
1239}
1240
a9de9248 1241static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1242{
a9de9248
MH		 1243 struct hci_ev_remote_features *ev = (void *) skb->data;
1244 struct hci_conn *conn;
1245
1246 BT_DBG("%s status %d", hdev->name, ev->status);
1247
a9de9248
MH		 1248 hci_dev_lock(hdev);
1249
1250 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
ccd556fe
JH		 1251 if (!conn)
1252 goto unlock;
769be974 1253
ccd556fe
JH		 1254 if (!ev->status)
1255 memcpy(conn->features, ev->features, 8);
1256
1257 if (conn->state != BT_CONFIG)
1258 goto unlock;
1259
1260 if (!ev->status && lmp_ssp_capable(hdev) && lmp_ssp_capable(conn)) {
1261 struct hci_cp_read_remote_ext_features cp;
1262 cp.handle = ev->handle;
1263 cp.page = 0x01;
1264 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES,
bdb7524a 1265 sizeof(cp), &cp);
392599b9
JH		 1266 goto unlock;
1267 }
1268
127178d2
JH		 1269 if (!ev->status) {
1270 struct hci_cp_remote_name_req cp;
1271 memset(&cp, 0, sizeof(cp));
1272 bacpy(&cp.bdaddr, &conn->dst);
1273 cp.pscan_rep_mode = 0x02;
1274 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
1275 }
392599b9 1276
127178d2 1277 if (!hci_outgoing_auth_needed(hdev, conn)) {
ccd556fe
JH		 1278 conn->state = BT_CONNECTED;
1279 hci_proto_connect_cfm(conn, ev->status);
1280 hci_conn_put(conn);
769be974 1281 }
a9de9248 1282
ccd556fe 1283unlock:
a9de9248 1284 hci_dev_unlock(hdev);
1da177e4
LT		 1285}
1286
a9de9248 1287static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1288{
a9de9248 1289 BT_DBG("%s", hdev->name);
1da177e4
LT		 1290}
1291
a9de9248 1292static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1293{
a9de9248 1294 BT_DBG("%s", hdev->name);
1da177e4
LT		 1295}
1296
a9de9248
MH		 1297static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1298{
1299 struct hci_ev_cmd_complete *ev = (void *) skb->data;
1300 __u16 opcode;
1301
1302 skb_pull(skb, sizeof(*ev));
1303
1304 opcode = __le16_to_cpu(ev->opcode);
1305
1306 switch (opcode) {
1307 case HCI_OP_INQUIRY_CANCEL:
1308 hci_cc_inquiry_cancel(hdev, skb);
1309 break;
1310
1311 case HCI_OP_EXIT_PERIODIC_INQ:
1312 hci_cc_exit_periodic_inq(hdev, skb);
1313 break;
1314
1315 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1316 hci_cc_remote_name_req_cancel(hdev, skb);
1317 break;
1318
1319 case HCI_OP_ROLE_DISCOVERY:
1320 hci_cc_role_discovery(hdev, skb);
1321 break;
1322
e4e8e37c
MH		 1323 case HCI_OP_READ_LINK_POLICY:
1324 hci_cc_read_link_policy(hdev, skb);
1325 break;
1326
a9de9248
MH		 1327 case HCI_OP_WRITE_LINK_POLICY:
1328 hci_cc_write_link_policy(hdev, skb);
1329 break;
1330
e4e8e37c
MH		 1331 case HCI_OP_READ_DEF_LINK_POLICY:
1332 hci_cc_read_def_link_policy(hdev, skb);
1333 break;
1334
1335 case HCI_OP_WRITE_DEF_LINK_POLICY:
1336 hci_cc_write_def_link_policy(hdev, skb);
1337 break;
1338
a9de9248
MH		 1339 case HCI_OP_RESET:
1340 hci_cc_reset(hdev, skb);
1341 break;
1342
1343 case HCI_OP_WRITE_LOCAL_NAME:
1344 hci_cc_write_local_name(hdev, skb);
1345 break;
1346
1347 case HCI_OP_READ_LOCAL_NAME:
1348 hci_cc_read_local_name(hdev, skb);
1349 break;
1350
1351 case HCI_OP_WRITE_AUTH_ENABLE:
1352 hci_cc_write_auth_enable(hdev, skb);
1353 break;
1354
1355 case HCI_OP_WRITE_ENCRYPT_MODE:
1356 hci_cc_write_encrypt_mode(hdev, skb);
1357 break;
1358
1359 case HCI_OP_WRITE_SCAN_ENABLE:
1360 hci_cc_write_scan_enable(hdev, skb);
1361 break;
1362
1363 case HCI_OP_READ_CLASS_OF_DEV:
1364 hci_cc_read_class_of_dev(hdev, skb);
1365 break;
1366
1367 case HCI_OP_WRITE_CLASS_OF_DEV:
1368 hci_cc_write_class_of_dev(hdev, skb);
1369 break;
1370
1371 case HCI_OP_READ_VOICE_SETTING:
1372 hci_cc_read_voice_setting(hdev, skb);
1373 break;
1374
1375 case HCI_OP_WRITE_VOICE_SETTING:
1376 hci_cc_write_voice_setting(hdev, skb);
1377 break;
1378
1379 case HCI_OP_HOST_BUFFER_SIZE:
1380 hci_cc_host_buffer_size(hdev, skb);
1381 break;
1382
333140b5
MH		 1383 case HCI_OP_READ_SSP_MODE:
1384 hci_cc_read_ssp_mode(hdev, skb);
1385 break;
1386
1387 case HCI_OP_WRITE_SSP_MODE:
1388 hci_cc_write_ssp_mode(hdev, skb);
1389 break;
1390
a9de9248
MH		 1391 case HCI_OP_READ_LOCAL_VERSION:
1392 hci_cc_read_local_version(hdev, skb);
1393 break;
1394
1395 case HCI_OP_READ_LOCAL_COMMANDS:
1396 hci_cc_read_local_commands(hdev, skb);
1397 break;
1398
1399 case HCI_OP_READ_LOCAL_FEATURES:
1400 hci_cc_read_local_features(hdev, skb);
1401 break;
1402
1403 case HCI_OP_READ_BUFFER_SIZE:
1404 hci_cc_read_buffer_size(hdev, skb);
1405 break;
1406
1407 case HCI_OP_READ_BD_ADDR:
1408 hci_cc_read_bd_addr(hdev, skb);
1409 break;
1410
23bb5763
JH		 1411 case HCI_OP_WRITE_CA_TIMEOUT:
1412 hci_cc_write_ca_timeout(hdev, skb);
1413 break;
1414
b0916ea0
JH		 1415 case HCI_OP_DELETE_STORED_LINK_KEY:
1416 hci_cc_delete_stored_link_key(hdev, skb);
1417 break;
1418
a9de9248
MH		 1419 default:
1420 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1421 break;
1422 }
1423
1424 if (ev->ncmd) {
1425 atomic_set(&hdev->cmd_cnt, 1);
1426 if (!skb_queue_empty(&hdev->cmd_q))
c78ae283 1427 tasklet_schedule(&hdev->cmd_task);
a9de9248
MH		 1428 }
1429}
1430
1431static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1432{
1433 struct hci_ev_cmd_status *ev = (void *) skb->data;
1434 __u16 opcode;
1435
1436 skb_pull(skb, sizeof(*ev));
1437
1438 opcode = __le16_to_cpu(ev->opcode);
1439
1440 switch (opcode) {
1441 case HCI_OP_INQUIRY:
1442 hci_cs_inquiry(hdev, ev->status);
1443 break;
1444
1445 case HCI_OP_CREATE_CONN:
1446 hci_cs_create_conn(hdev, ev->status);
1447 break;
1448
1449 case HCI_OP_ADD_SCO:
1450 hci_cs_add_sco(hdev, ev->status);
1451 break;
1452
f8558555
MH		 1453 case HCI_OP_AUTH_REQUESTED:
1454 hci_cs_auth_requested(hdev, ev->status);
1455 break;
1456
1457 case HCI_OP_SET_CONN_ENCRYPT:
1458 hci_cs_set_conn_encrypt(hdev, ev->status);
1459 break;
1460
a9de9248
MH		 1461 case HCI_OP_REMOTE_NAME_REQ:
1462 hci_cs_remote_name_req(hdev, ev->status);
1463 break;
1464
769be974
MH		 1465 case HCI_OP_READ_REMOTE_FEATURES:
1466 hci_cs_read_remote_features(hdev, ev->status);
1467 break;
1468
1469 case HCI_OP_READ_REMOTE_EXT_FEATURES:
1470 hci_cs_read_remote_ext_features(hdev, ev->status);
1471 break;
1472
a9de9248
MH		 1473 case HCI_OP_SETUP_SYNC_CONN:
1474 hci_cs_setup_sync_conn(hdev, ev->status);
1475 break;
1476
1477 case HCI_OP_SNIFF_MODE:
1478 hci_cs_sniff_mode(hdev, ev->status);
1479 break;
1480
1481 case HCI_OP_EXIT_SNIFF_MODE:
1482 hci_cs_exit_sniff_mode(hdev, ev->status);
1483 break;
1484
1485 default:
1486 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1487 break;
1488 }
1489
1490 if (ev->ncmd) {
1491 atomic_set(&hdev->cmd_cnt, 1);
1492 if (!skb_queue_empty(&hdev->cmd_q))
c78ae283 1493 tasklet_schedule(&hdev->cmd_task);
a9de9248
MH		 1494 }
1495}
1496
1497static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1498{
1499 struct hci_ev_role_change *ev = (void *) skb->data;
1500 struct hci_conn *conn;
1501
1502 BT_DBG("%s status %d", hdev->name, ev->status);
1503
1504 hci_dev_lock(hdev);
1505
1506 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1507 if (conn) {
1508 if (!ev->status) {
1509 if (ev->role)
1510 conn->link_mode &= ~HCI_LM_MASTER;
1511 else
1512 conn->link_mode |= HCI_LM_MASTER;
1513 }
1514
1515 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1516
1517 hci_role_switch_cfm(conn, ev->status, ev->role);
1518 }
1519
1520 hci_dev_unlock(hdev);
1521}
1522
1523static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1524{
1525 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1526 __le16 *ptr;
1527 int i;
1528
1529 skb_pull(skb, sizeof(*ev));
1530
1531 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1532
1533 if (skb->len < ev->num_hndl * 4) {
1534 BT_DBG("%s bad parameters", hdev->name);
1535 return;
1536 }
1537
1538 tasklet_disable(&hdev->tx_task);
1539
1540 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1541 struct hci_conn *conn;
1542 __u16 handle, count;
1543
83985319
HH		 1544 handle = get_unaligned_le16(ptr++);
1545 count = get_unaligned_le16(ptr++);
a9de9248
MH		 1546
1547 conn = hci_conn_hash_lookup_handle(hdev, handle);
1548 if (conn) {
1549 conn->sent -= count;
1550
1551 if (conn->type == ACL_LINK) {
70f23020
AE		 1552 hdev->acl_cnt += count;
1553 if (hdev->acl_cnt > hdev->acl_pkts)
a9de9248
MH		 1554 hdev->acl_cnt = hdev->acl_pkts;
1555 } else {
70f23020
AE		 1556 hdev->sco_cnt += count;
1557 if (hdev->sco_cnt > hdev->sco_pkts)
a9de9248
MH		 1558 hdev->sco_cnt = hdev->sco_pkts;
1559 }
1560 }
1561 }
1562
c78ae283 1563 tasklet_schedule(&hdev->tx_task);
a9de9248
MH		 1564
1565 tasklet_enable(&hdev->tx_task);
1566}
1567
1568static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
04837f64 1569{
a9de9248 1570 struct hci_ev_mode_change *ev = (void *) skb->data;
04837f64
MH		 1571 struct hci_conn *conn;
1572
1573 BT_DBG("%s status %d", hdev->name, ev->status);
1574
1575 hci_dev_lock(hdev);
1576
1577 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
a9de9248
MH		 1578 if (conn) {
1579 conn->mode = ev->mode;
1580 conn->interval = __le16_to_cpu(ev->interval);
1581
1582 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1583 if (conn->mode == HCI_CM_ACTIVE)
1584 conn->power_save = 1;
1585 else
1586 conn->power_save = 0;
1587 }
e73439d8
MH		 1588
1589 if (test_and_clear_bit(HCI_CONN_SCO_SETUP_PEND, &conn->pend))
1590 hci_sco_setup(conn, ev->status);
04837f64
MH		 1591 }
1592
1593 hci_dev_unlock(hdev);
1594}
1595
a9de9248
MH		 1596static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1597{
052b30b0
MH		 1598 struct hci_ev_pin_code_req *ev = (void *) skb->data;
1599 struct hci_conn *conn;
1600
a9de9248 1601 BT_DBG("%s", hdev->name);
052b30b0
MH		 1602
1603 hci_dev_lock(hdev);
1604
1605 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
3d7a9d1c 1606 if (conn && conn->state == BT_CONNECTED) {
052b30b0
MH		 1607 hci_conn_hold(conn);
1608 conn->disc_timeout = HCI_PAIRING_TIMEOUT;
1609 hci_conn_put(conn);
1610 }
1611
03b555e1
JH		 1612 if (!test_bit(HCI_PAIRABLE, &hdev->flags))
1613 hci_send_cmd(hdev, HCI_OP_PIN_CODE_NEG_REPLY,
1614 sizeof(ev->bdaddr), &ev->bdaddr);
1615
052b30b0 1616 hci_dev_unlock(hdev);
a9de9248
MH		 1617}
1618
1619static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1620{
1621 BT_DBG("%s", hdev->name);
1622}
1623
1624static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1625{
052b30b0
MH		 1626 struct hci_ev_link_key_notify *ev = (void *) skb->data;
1627 struct hci_conn *conn;
1628
a9de9248 1629 BT_DBG("%s", hdev->name);
052b30b0
MH		 1630
1631 hci_dev_lock(hdev);
1632
1633 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1634 if (conn) {
1635 hci_conn_hold(conn);
1636 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
1637 hci_conn_put(conn);
1638 }
1639
1640 hci_dev_unlock(hdev);
a9de9248
MH		 1641}
1642
1da177e4
LT		 1643static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1644{
a9de9248 1645 struct hci_ev_clock_offset *ev = (void *) skb->data;
04837f64 1646 struct hci_conn *conn;
1da177e4
LT		 1647
1648 BT_DBG("%s status %d", hdev->name, ev->status);
1649
1650 hci_dev_lock(hdev);
1651
04837f64 1652 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 1653 if (conn && !ev->status) {
1654 struct inquiry_entry *ie;
1655
cc11b9c1
AE		 1656 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
1657 if (ie) {
1da177e4
LT		 1658 ie->data.clock_offset = ev->clock_offset;
1659 ie->timestamp = jiffies;
1660 }
1661 }
1662
1663 hci_dev_unlock(hdev);
1664}
1665
a8746417
MH		 1666static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1667{
1668 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1669 struct hci_conn *conn;
1670
1671 BT_DBG("%s status %d", hdev->name, ev->status);
1672
1673 hci_dev_lock(hdev);
1674
1675 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1676 if (conn && !ev->status)
1677 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1678
1679 hci_dev_unlock(hdev);
1680}
1681
85a1e930
MH		 1682static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1683{
a9de9248 1684 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
85a1e930
MH		 1685 struct inquiry_entry *ie;
1686
1687 BT_DBG("%s", hdev->name);
1688
1689 hci_dev_lock(hdev);
1690
cc11b9c1
AE		 1691 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1692 if (ie) {
85a1e930
MH		 1693 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1694 ie->timestamp = jiffies;
1695 }
1696
1697 hci_dev_unlock(hdev);
1698}
1699
a9de9248
MH		 1700static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1701{
1702 struct inquiry_data data;
1703 int num_rsp = *((__u8 *) skb->data);
1704
1705 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1706
1707 if (!num_rsp)
1708 return;
1709
1710 hci_dev_lock(hdev);
1711
1712 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1713 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1714
1715 for (; num_rsp; num_rsp--) {
1716 bacpy(&data.bdaddr, &info->bdaddr);
1717 data.pscan_rep_mode = info->pscan_rep_mode;
1718 data.pscan_period_mode = info->pscan_period_mode;
1719 data.pscan_mode = info->pscan_mode;
1720 memcpy(data.dev_class, info->dev_class, 3);
1721 data.clock_offset = info->clock_offset;
1722 data.rssi = info->rssi;
41a96212 1723 data.ssp_mode = 0x00;
a9de9248
MH		 1724 info++;
1725 hci_inquiry_cache_update(hdev, &data);
1726 }
1727 } else {
1728 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1729
1730 for (; num_rsp; num_rsp--) {
1731 bacpy(&data.bdaddr, &info->bdaddr);
1732 data.pscan_rep_mode = info->pscan_rep_mode;
1733 data.pscan_period_mode = info->pscan_period_mode;
1734 data.pscan_mode = 0x00;
1735 memcpy(data.dev_class, info->dev_class, 3);
1736 data.clock_offset = info->clock_offset;
1737 data.rssi = info->rssi;
41a96212 1738 data.ssp_mode = 0x00;
a9de9248
MH		 1739 info++;
1740 hci_inquiry_cache_update(hdev, &data);
1741 }
1742 }
1743
1744 hci_dev_unlock(hdev);
1745}
1746
1747static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1748{
41a96212
MH		 1749 struct hci_ev_remote_ext_features *ev = (void *) skb->data;
1750 struct hci_conn *conn;
1751
a9de9248 1752 BT_DBG("%s", hdev->name);
41a96212 1753
41a96212
MH		 1754 hci_dev_lock(hdev);
1755
1756 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
ccd556fe
JH		 1757 if (!conn)
1758 goto unlock;
41a96212 1759
ccd556fe
JH		 1760 if (!ev->status && ev->page == 0x01) {
1761 struct inquiry_entry *ie;
41a96212 1762
cc11b9c1
AE		 1763 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
1764 if (ie)
ccd556fe 1765 ie->data.ssp_mode = (ev->features[0] & 0x01);
769be974 1766
ccd556fe
JH		 1767 conn->ssp_mode = (ev->features[0] & 0x01);
1768 }
1769
1770 if (conn->state != BT_CONFIG)
1771 goto unlock;
1772
127178d2
JH		 1773 if (!ev->status) {
1774 struct hci_cp_remote_name_req cp;
1775 memset(&cp, 0, sizeof(cp));
1776 bacpy(&cp.bdaddr, &conn->dst);
1777 cp.pscan_rep_mode = 0x02;
1778 hci_send_cmd(hdev, HCI_OP_REMOTE_NAME_REQ, sizeof(cp), &cp);
1779 }
392599b9 1780
127178d2 1781 if (!hci_outgoing_auth_needed(hdev, conn)) {
ccd556fe
JH		 1782 conn->state = BT_CONNECTED;
1783 hci_proto_connect_cfm(conn, ev->status);
1784 hci_conn_put(conn);
41a96212
MH		 1785 }
1786
ccd556fe 1787unlock:
41a96212 1788 hci_dev_unlock(hdev);
a9de9248
MH		 1789}
1790
1791static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1792{
b6a0dc82
MH		 1793 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1794 struct hci_conn *conn;
1795
1796 BT_DBG("%s status %d", hdev->name, ev->status);
1797
1798 hci_dev_lock(hdev);
1799
1800 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
9dc0a3af
MH		 1801 if (!conn) {
1802 if (ev->link_type == ESCO_LINK)
1803 goto unlock;
1804
1805 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1806 if (!conn)
1807 goto unlock;
1808
1809 conn->type = SCO_LINK;
1810 }
b6a0dc82 1811
732547f9
MH		 1812 switch (ev->status) {
1813 case 0x00:
b6a0dc82
MH		 1814 conn->handle = __le16_to_cpu(ev->handle);
1815 conn->state = BT_CONNECTED;
7d0db0a3 1816
9eba32b8 1817 hci_conn_hold_device(conn);
7d0db0a3 1818 hci_conn_add_sysfs(conn);
732547f9
MH		 1819 break;
1820
705e5711 1821 case 0x11: /* Unsupported Feature or Parameter Value */
732547f9 1822 case 0x1c: /* SCO interval rejected */
1038a00b 1823 case 0x1a: /* Unsupported Remote Feature */
732547f9
MH		 1824 case 0x1f: /* Unspecified error */
1825 if (conn->out && conn->attempt < 2) {
1826 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
1827 (hdev->esco_type & EDR_ESCO_MASK);
1828 hci_setup_sync(conn, conn->link->handle);
1829 goto unlock;
1830 }
1831 /* fall through */
1832
1833 default:
b6a0dc82 1834 conn->state = BT_CLOSED;
732547f9
MH		 1835 break;
1836 }
b6a0dc82
MH		 1837
1838 hci_proto_connect_cfm(conn, ev->status);
1839 if (ev->status)
1840 hci_conn_del(conn);
1841
1842unlock:
1843 hci_dev_unlock(hdev);
a9de9248
MH		 1844}
1845
1846static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1847{
1848 BT_DBG("%s", hdev->name);
1849}
1850
04837f64
MH		 1851static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1852{
a9de9248 1853 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
04837f64
MH		 1854 struct hci_conn *conn;
1855
1856 BT_DBG("%s status %d", hdev->name, ev->status);
1857
1858 hci_dev_lock(hdev);
1859
1860 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1861 if (conn) {
1862 }
1863
1864 hci_dev_unlock(hdev);
1865}
1866
a9de9248 1867static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4 1868{
a9de9248
MH		 1869 struct inquiry_data data;
1870 struct extended_inquiry_info *info = (void *) (skb->data + 1);
1871 int num_rsp = *((__u8 *) skb->data);
1da177e4 1872
a9de9248 1873 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1da177e4 1874
a9de9248
MH		 1875 if (!num_rsp)
1876 return;
1da177e4 1877
a9de9248
MH		 1878 hci_dev_lock(hdev);
1879
1880 for (; num_rsp; num_rsp--) {
1881 bacpy(&data.bdaddr, &info->bdaddr);
1882 data.pscan_rep_mode = info->pscan_rep_mode;
1883 data.pscan_period_mode = info->pscan_period_mode;
1884 data.pscan_mode = 0x00;
1885 memcpy(data.dev_class, info->dev_class, 3);
1886 data.clock_offset = info->clock_offset;
1887 data.rssi = info->rssi;
41a96212 1888 data.ssp_mode = 0x01;
a9de9248
MH		 1889 info++;
1890 hci_inquiry_cache_update(hdev, &data);
1891 }
1892
1893 hci_dev_unlock(hdev);
1894}
1da177e4 1895
0493684e
MH		 1896static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1897{
1898 struct hci_ev_io_capa_request *ev = (void *) skb->data;
1899 struct hci_conn *conn;
1900
1901 BT_DBG("%s", hdev->name);
1902
1903 hci_dev_lock(hdev);
1904
1905 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
03b555e1
JH		 1906 if (!conn)
1907 goto unlock;
1908
1909 hci_conn_hold(conn);
1910
1911 if (!test_bit(HCI_MGMT, &hdev->flags))
1912 goto unlock;
1913
1914 if (test_bit(HCI_PAIRABLE, &hdev->flags) ||
1915 (conn->remote_auth & ~0x01) == HCI_AT_NO_BONDING) {
1916 /* FIXME: Do IO capa response based on information
1917 * provided through the management interface */
1918 } else {
1919 struct hci_cp_io_capability_neg_reply cp;
1920
1921 bacpy(&cp.bdaddr, &ev->bdaddr);
1922 cp.reason = 0x16; /* Pairing not allowed */
0493684e 1923
03b555e1
JH		 1924 hci_send_cmd(hdev, HCI_OP_IO_CAPABILITY_NEG_REPLY,
1925 sizeof(cp), &cp);
1926 }
1927
1928unlock:
1929 hci_dev_unlock(hdev);
1930}
1931
1932static inline void hci_io_capa_reply_evt(struct hci_dev *hdev, struct sk_buff *skb)
1933{
1934 struct hci_ev_io_capa_reply *ev = (void *) skb->data;
1935 struct hci_conn *conn;
1936
1937 BT_DBG("%s", hdev->name);
1938
1939 hci_dev_lock(hdev);
1940
1941 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1942 if (!conn)
1943 goto unlock;
1944
1945 hci_conn_hold(conn);
1946
1947 conn->remote_cap = ev->capability;
1948 conn->remote_oob = ev->oob_data;
1949 conn->remote_auth = ev->authentication;
1950
1951unlock:
0493684e
MH		 1952 hci_dev_unlock(hdev);
1953}
1954
1955static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1956{
1957 struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
1958 struct hci_conn *conn;
1959
1960 BT_DBG("%s", hdev->name);
1961
1962 hci_dev_lock(hdev);
1963
1964 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1965 if (conn)
1966 hci_conn_put(conn);
1967
1968 hci_dev_unlock(hdev);
1969}
1970
41a96212
MH		 1971static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1972{
1973 struct hci_ev_remote_host_features *ev = (void *) skb->data;
1974 struct inquiry_entry *ie;
1975
1976 BT_DBG("%s", hdev->name);
1977
1978 hci_dev_lock(hdev);
1979
cc11b9c1
AE		 1980 ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr);
1981 if (ie)
41a96212
MH		 1982 ie->data.ssp_mode = (ev->features[0] & 0x01);
1983
1984 hci_dev_unlock(hdev);
1985}
1986
a9de9248
MH		 1987void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1988{
1989 struct hci_event_hdr *hdr = (void *) skb->data;
1990 __u8 event = hdr->evt;
1991
1992 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1993
1994 switch (event) {
1da177e4
LT		 1995 case HCI_EV_INQUIRY_COMPLETE:
1996 hci_inquiry_complete_evt(hdev, skb);
1997 break;
1998
1999 case HCI_EV_INQUIRY_RESULT:
2000 hci_inquiry_result_evt(hdev, skb);
2001 break;
2002
a9de9248
MH		 2003 case HCI_EV_CONN_COMPLETE:
2004 hci_conn_complete_evt(hdev, skb);
21d9e30e
MH		 2005 break;
2006
1da177e4
LT		 2007 case HCI_EV_CONN_REQUEST:
2008 hci_conn_request_evt(hdev, skb);
2009 break;
2010
1da177e4
LT		 2011 case HCI_EV_DISCONN_COMPLETE:
2012 hci_disconn_complete_evt(hdev, skb);
2013 break;
2014
1da177e4
LT		 2015 case HCI_EV_AUTH_COMPLETE:
2016 hci_auth_complete_evt(hdev, skb);
2017 break;
2018
a9de9248
MH		 2019 case HCI_EV_REMOTE_NAME:
2020 hci_remote_name_evt(hdev, skb);
2021 break;
2022
1da177e4
LT		 2023 case HCI_EV_ENCRYPT_CHANGE:
2024 hci_encrypt_change_evt(hdev, skb);
2025 break;
2026
a9de9248
MH		 2027 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
2028 hci_change_link_key_complete_evt(hdev, skb);
2029 break;
2030
2031 case HCI_EV_REMOTE_FEATURES:
2032 hci_remote_features_evt(hdev, skb);
2033 break;
2034
2035 case HCI_EV_REMOTE_VERSION:
2036 hci_remote_version_evt(hdev, skb);
2037 break;
2038
2039 case HCI_EV_QOS_SETUP_COMPLETE:
2040 hci_qos_setup_complete_evt(hdev, skb);
2041 break;
2042
2043 case HCI_EV_CMD_COMPLETE:
2044 hci_cmd_complete_evt(hdev, skb);
2045 break;
2046
2047 case HCI_EV_CMD_STATUS:
2048 hci_cmd_status_evt(hdev, skb);
2049 break;
2050
2051 case HCI_EV_ROLE_CHANGE:
2052 hci_role_change_evt(hdev, skb);
2053 break;
2054
2055 case HCI_EV_NUM_COMP_PKTS:
2056 hci_num_comp_pkts_evt(hdev, skb);
2057 break;
2058
2059 case HCI_EV_MODE_CHANGE:
2060 hci_mode_change_evt(hdev, skb);
1da177e4
LT		 2061 break;
2062
2063 case HCI_EV_PIN_CODE_REQ:
2064 hci_pin_code_request_evt(hdev, skb);
2065 break;
2066
2067 case HCI_EV_LINK_KEY_REQ:
2068 hci_link_key_request_evt(hdev, skb);
2069 break;
2070
2071 case HCI_EV_LINK_KEY_NOTIFY:
2072 hci_link_key_notify_evt(hdev, skb);
2073 break;
2074
2075 case HCI_EV_CLOCK_OFFSET:
2076 hci_clock_offset_evt(hdev, skb);
2077 break;
2078
a8746417
MH		 2079 case HCI_EV_PKT_TYPE_CHANGE:
2080 hci_pkt_type_change_evt(hdev, skb);
2081 break;
2082
85a1e930
MH		 2083 case HCI_EV_PSCAN_REP_MODE:
2084 hci_pscan_rep_mode_evt(hdev, skb);
2085 break;
2086
a9de9248
MH		 2087 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
2088 hci_inquiry_result_with_rssi_evt(hdev, skb);
04837f64
MH		 2089 break;
2090
a9de9248
MH		 2091 case HCI_EV_REMOTE_EXT_FEATURES:
2092 hci_remote_ext_features_evt(hdev, skb);
1da177e4
LT		 2093 break;
2094
a9de9248
MH		 2095 case HCI_EV_SYNC_CONN_COMPLETE:
2096 hci_sync_conn_complete_evt(hdev, skb);
2097 break;
1da177e4 2098
a9de9248
MH		 2099 case HCI_EV_SYNC_CONN_CHANGED:
2100 hci_sync_conn_changed_evt(hdev, skb);
2101 break;
1da177e4 2102
a9de9248
MH		 2103 case HCI_EV_SNIFF_SUBRATE:
2104 hci_sniff_subrate_evt(hdev, skb);
2105 break;
1da177e4 2106
a9de9248
MH		 2107 case HCI_EV_EXTENDED_INQUIRY_RESULT:
2108 hci_extended_inquiry_result_evt(hdev, skb);
2109 break;
1da177e4 2110
0493684e
MH		 2111 case HCI_EV_IO_CAPA_REQUEST:
2112 hci_io_capa_request_evt(hdev, skb);
2113 break;
2114
03b555e1
JH		 2115 case HCI_EV_IO_CAPA_REPLY:
2116 hci_io_capa_reply_evt(hdev, skb);
2117 break;
2118
0493684e
MH		 2119 case HCI_EV_SIMPLE_PAIR_COMPLETE:
2120 hci_simple_pair_complete_evt(hdev, skb);
2121 break;
2122
41a96212
MH		 2123 case HCI_EV_REMOTE_HOST_FEATURES:
2124 hci_remote_host_features_evt(hdev, skb);
2125 break;
2126
a9de9248
MH		 2127 default:
2128 BT_DBG("%s event 0x%x", hdev->name, event);
1da177e4
LT		 2129 break;
2130 }
2131
2132 kfree_skb(skb);
2133 hdev->stat.evt_rx++;
2134}
2135
2136/* Generate internal stack event */
2137void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
2138{
2139 struct hci_event_hdr *hdr;
2140 struct hci_ev_stack_internal *ev;
2141 struct sk_buff *skb;
2142
2143 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
2144 if (!skb)
2145 return;
2146
2147 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
2148 hdr->evt = HCI_EV_STACK_INTERNAL;
2149 hdr->plen = sizeof(*ev) + dlen;
2150
2151 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
2152 ev->type = type;
2153 memcpy(ev->data, data, dlen);
2154
576c7d85 2155 bt_cb(skb)->incoming = 1;
a61bbcf2 2156 __net_timestamp(skb);
576c7d85 2157
0d48d939 2158 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1da177e4 2159 skb->dev = (void *) hdev;
eec8d2bc 2160 hci_send_to_sock(hdev, skb, NULL);
1da177e4
LT		 2161 kfree_skb(skb);
2162}
kernel source for telekom puls (alcatel/mediatek)