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