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