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