projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[Bluetooth] Make use of the default link policy settings
[deliverable/linux.git] / net / bluetooth / hci_event.c
1 /*
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
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 <asm/uaccess.h>
43 #include <asm/unaligned.h>
44
45 #include <net/bluetooth/bluetooth.h>
46 #include <net/bluetooth/hci_core.h>
47
48 #ifndef CONFIG_BT_HCI_CORE_DEBUG
49 #undef BT_DBG
50 #define BT_DBG(D...)
51 #endif
52
53 /* Handle HCI Event packets */
54
55 static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb)
56 {
57 __u8 status = *((__u8 *) skb->data);
58
59 BT_DBG("%s status 0x%x", hdev->name, status);
60
61 if (status)
62 return;
63
64 clear_bit(HCI_INQUIRY, &hdev->flags);
65
66 hci_req_complete(hdev, status);
67
68 hci_conn_check_pending(hdev);
69 }
70
71 static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb)
72 {
73 __u8 status = *((__u8 *) skb->data);
74
75 BT_DBG("%s status 0x%x", hdev->name, status);
76
77 if (status)
78 return;
79
80 clear_bit(HCI_INQUIRY, &hdev->flags);
81
82 hci_conn_check_pending(hdev);
83 }
84
85 static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
86 {
87 BT_DBG("%s", hdev->name);
88 }
89
90 static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb)
91 {
92 struct hci_rp_role_discovery *rp = (void *) skb->data;
93 struct hci_conn *conn;
94
95 BT_DBG("%s status 0x%x", hdev->name, rp->status);
96
97 if (rp->status)
98 return;
99
100 hci_dev_lock(hdev);
101
102 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
103 if (conn) {
104 if (rp->role)
105 conn->link_mode &= ~HCI_LM_MASTER;
106 else
107 conn->link_mode |= HCI_LM_MASTER;
108 }
109
110 hci_dev_unlock(hdev);
111 }
112
113 static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
114 {
115 struct hci_rp_read_link_policy *rp = (void *) skb->data;
116 struct hci_conn *conn;
117
118 BT_DBG("%s status 0x%x", hdev->name, rp->status);
119
120 if (rp->status)
121 return;
122
123 hci_dev_lock(hdev);
124
125 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
126 if (conn)
127 conn->link_policy = __le16_to_cpu(rp->policy);
128
129 hci_dev_unlock(hdev);
130 }
131
132 static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
133 {
134 struct hci_rp_write_link_policy *rp = (void *) skb->data;
135 struct hci_conn *conn;
136 void *sent;
137
138 BT_DBG("%s status 0x%x", hdev->name, rp->status);
139
140 if (rp->status)
141 return;
142
143 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
144 if (!sent)
145 return;
146
147 hci_dev_lock(hdev);
148
149 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
150 if (conn)
151 conn->link_policy = get_unaligned_le16(sent + 2);
152
153 hci_dev_unlock(hdev);
154 }
155
156 static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
157 {
158 struct hci_rp_read_def_link_policy *rp = (void *) skb->data;
159
160 BT_DBG("%s status 0x%x", hdev->name, rp->status);
161
162 if (rp->status)
163 return;
164
165 hdev->link_policy = __le16_to_cpu(rp->policy);
166 }
167
168 static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
169 {
170 __u8 status = *((__u8 *) skb->data);
171 void *sent;
172
173 BT_DBG("%s status 0x%x", hdev->name, status);
174
175 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY);
176 if (!sent)
177 return;
178
179 if (!status)
180 hdev->link_policy = get_unaligned_le16(sent);
181
182 hci_req_complete(hdev, status);
183 }
184
185 static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
186 {
187 __u8 status = *((__u8 *) skb->data);
188
189 BT_DBG("%s status 0x%x", hdev->name, status);
190
191 hci_req_complete(hdev, status);
192 }
193
194 static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
195 {
196 __u8 status = *((__u8 *) skb->data);
197 void *sent;
198
199 BT_DBG("%s status 0x%x", hdev->name, status);
200
201 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
202 if (!sent)
203 return;
204
205 if (!status)
206 memcpy(hdev->dev_name, sent, 248);
207 }
208
209 static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
210 {
211 struct hci_rp_read_local_name *rp = (void *) skb->data;
212
213 BT_DBG("%s status 0x%x", hdev->name, rp->status);
214
215 if (rp->status)
216 return;
217
218 memcpy(hdev->dev_name, rp->name, 248);
219 }
220
221 static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
222 {
223 __u8 status = *((__u8 *) skb->data);
224 void *sent;
225
226 BT_DBG("%s status 0x%x", hdev->name, status);
227
228 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
229 if (!sent)
230 return;
231
232 if (!status) {
233 __u8 param = *((__u8 *) sent);
234
235 if (param == AUTH_ENABLED)
236 set_bit(HCI_AUTH, &hdev->flags);
237 else
238 clear_bit(HCI_AUTH, &hdev->flags);
239 }
240
241 hci_req_complete(hdev, status);
242 }
243
244 static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
245 {
246 __u8 status = *((__u8 *) skb->data);
247 void *sent;
248
249 BT_DBG("%s status 0x%x", hdev->name, status);
250
251 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
252 if (!sent)
253 return;
254
255 if (!status) {
256 __u8 param = *((__u8 *) sent);
257
258 if (param)
259 set_bit(HCI_ENCRYPT, &hdev->flags);
260 else
261 clear_bit(HCI_ENCRYPT, &hdev->flags);
262 }
263
264 hci_req_complete(hdev, status);
265 }
266
267 static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
268 {
269 __u8 status = *((__u8 *) skb->data);
270 void *sent;
271
272 BT_DBG("%s status 0x%x", hdev->name, status);
273
274 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
275 if (!sent)
276 return;
277
278 if (!status) {
279 __u8 param = *((__u8 *) sent);
280
281 clear_bit(HCI_PSCAN, &hdev->flags);
282 clear_bit(HCI_ISCAN, &hdev->flags);
283
284 if (param & SCAN_INQUIRY)
285 set_bit(HCI_ISCAN, &hdev->flags);
286
287 if (param & SCAN_PAGE)
288 set_bit(HCI_PSCAN, &hdev->flags);
289 }
290
291 hci_req_complete(hdev, status);
292 }
293
294 static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
295 {
296 struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
297
298 BT_DBG("%s status 0x%x", hdev->name, rp->status);
299
300 if (rp->status)
301 return;
302
303 memcpy(hdev->dev_class, rp->dev_class, 3);
304
305 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
306 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
307 }
308
309 static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
310 {
311 __u8 status = *((__u8 *) skb->data);
312 void *sent;
313
314 BT_DBG("%s status 0x%x", hdev->name, status);
315
316 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
317 if (!sent)
318 return;
319
320 if (!status)
321 memcpy(hdev->dev_class, sent, 3);
322 }
323
324 static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
325 {
326 struct hci_rp_read_voice_setting *rp = (void *) skb->data;
327 __u16 setting;
328
329 BT_DBG("%s status 0x%x", hdev->name, rp->status);
330
331 if (rp->status)
332 return;
333
334 setting = __le16_to_cpu(rp->voice_setting);
335
336 if (hdev->voice_setting == setting )
337 return;
338
339 hdev->voice_setting = setting;
340
341 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
342
343 if (hdev->notify) {
344 tasklet_disable(&hdev->tx_task);
345 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
346 tasklet_enable(&hdev->tx_task);
347 }
348 }
349
350 static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
351 {
352 __u8 status = *((__u8 *) skb->data);
353 void *sent;
354
355 BT_DBG("%s status 0x%x", hdev->name, status);
356
357 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
358 if (!sent)
359 return;
360
361 if (!status) {
362 __u16 setting = get_unaligned_le16(sent);
363
364 if (hdev->voice_setting != setting) {
365 hdev->voice_setting = setting;
366
367 BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
368
369 if (hdev->notify) {
370 tasklet_disable(&hdev->tx_task);
371 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
372 tasklet_enable(&hdev->tx_task);
373 }
374 }
375 }
376 }
377
378 static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
379 {
380 __u8 status = *((__u8 *) skb->data);
381
382 BT_DBG("%s status 0x%x", hdev->name, status);
383
384 hci_req_complete(hdev, status);
385 }
386
387 static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
388 {
389 struct hci_rp_read_local_version *rp = (void *) skb->data;
390
391 BT_DBG("%s status 0x%x", hdev->name, rp->status);
392
393 if (rp->status)
394 return;
395
396 hdev->hci_ver = rp->hci_ver;
397 hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
398 hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
399
400 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
401 hdev->manufacturer,
402 hdev->hci_ver, hdev->hci_rev);
403 }
404
405 static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
406 {
407 struct hci_rp_read_local_commands *rp = (void *) skb->data;
408
409 BT_DBG("%s status 0x%x", hdev->name, rp->status);
410
411 if (rp->status)
412 return;
413
414 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
415 }
416
417 static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
418 {
419 struct hci_rp_read_local_features *rp = (void *) skb->data;
420
421 BT_DBG("%s status 0x%x", hdev->name, rp->status);
422
423 if (rp->status)
424 return;
425
426 memcpy(hdev->features, rp->features, 8);
427
428 /* Adjust default settings according to features
429 * supported by device. */
430
431 if (hdev->features[0] & LMP_3SLOT)
432 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
433
434 if (hdev->features[0] & LMP_5SLOT)
435 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
436
437 if (hdev->features[1] & LMP_HV2) {
438 hdev->pkt_type |= (HCI_HV2);
439 hdev->esco_type |= (ESCO_HV2);
440 }
441
442 if (hdev->features[1] & LMP_HV3) {
443 hdev->pkt_type |= (HCI_HV3);
444 hdev->esco_type |= (ESCO_HV3);
445 }
446
447 if (hdev->features[3] & LMP_ESCO)
448 hdev->esco_type |= (ESCO_EV3);
449
450 if (hdev->features[4] & LMP_EV4)
451 hdev->esco_type |= (ESCO_EV4);
452
453 if (hdev->features[4] & LMP_EV5)
454 hdev->esco_type |= (ESCO_EV5);
455
456 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
457 hdev->features[0], hdev->features[1],
458 hdev->features[2], hdev->features[3],
459 hdev->features[4], hdev->features[5],
460 hdev->features[6], hdev->features[7]);
461 }
462
463 static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
464 {
465 struct hci_rp_read_buffer_size *rp = (void *) skb->data;
466
467 BT_DBG("%s status 0x%x", hdev->name, rp->status);
468
469 if (rp->status)
470 return;
471
472 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu);
473 hdev->sco_mtu = rp->sco_mtu;
474 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
475 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
476
477 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
478 hdev->sco_mtu = 64;
479 hdev->sco_pkts = 8;
480 }
481
482 hdev->acl_cnt = hdev->acl_pkts;
483 hdev->sco_cnt = hdev->sco_pkts;
484
485 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
486 hdev->acl_mtu, hdev->acl_pkts,
487 hdev->sco_mtu, hdev->sco_pkts);
488 }
489
490 static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
491 {
492 struct hci_rp_read_bd_addr *rp = (void *) skb->data;
493
494 BT_DBG("%s status 0x%x", hdev->name, rp->status);
495
496 if (!rp->status)
497 bacpy(&hdev->bdaddr, &rp->bdaddr);
498
499 hci_req_complete(hdev, rp->status);
500 }
501
502 static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
503 {
504 BT_DBG("%s status 0x%x", hdev->name, status);
505
506 if (status) {
507 hci_req_complete(hdev, status);
508
509 hci_conn_check_pending(hdev);
510 } else
511 set_bit(HCI_INQUIRY, &hdev->flags);
512 }
513
514 static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
515 {
516 struct hci_cp_create_conn *cp;
517 struct hci_conn *conn;
518
519 BT_DBG("%s status 0x%x", hdev->name, status);
520
521 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
522 if (!cp)
523 return;
524
525 hci_dev_lock(hdev);
526
527 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
528
529 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
530
531 if (status) {
532 if (conn && conn->state == BT_CONNECT) {
533 if (status != 0x0c || conn->attempt > 2) {
534 conn->state = BT_CLOSED;
535 hci_proto_connect_cfm(conn, status);
536 hci_conn_del(conn);
537 } else
538 conn->state = BT_CONNECT2;
539 }
540 } else {
541 if (!conn) {
542 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
543 if (conn) {
544 conn->out = 1;
545 conn->link_mode |= HCI_LM_MASTER;
546 } else
547 BT_ERR("No memmory for new connection");
548 }
549 }
550
551 hci_dev_unlock(hdev);
552 }
553
554 static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
555 {
556 struct hci_cp_add_sco *cp;
557 struct hci_conn *acl, *sco;
558 __u16 handle;
559
560 BT_DBG("%s status 0x%x", hdev->name, status);
561
562 if (!status)
563 return;
564
565 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
566 if (!cp)
567 return;
568
569 handle = __le16_to_cpu(cp->handle);
570
571 BT_DBG("%s handle %d", hdev->name, handle);
572
573 hci_dev_lock(hdev);
574
575 acl = hci_conn_hash_lookup_handle(hdev, handle);
576 if (acl && (sco = acl->link)) {
577 sco->state = BT_CLOSED;
578
579 hci_proto_connect_cfm(sco, status);
580 hci_conn_del(sco);
581 }
582
583 hci_dev_unlock(hdev);
584 }
585
586 static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
587 {
588 BT_DBG("%s status 0x%x", hdev->name, status);
589 }
590
591 static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
592 {
593 struct hci_cp_setup_sync_conn *cp;
594 struct hci_conn *acl, *sco;
595 __u16 handle;
596
597 BT_DBG("%s status 0x%x", hdev->name, status);
598
599 if (!status)
600 return;
601
602 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
603 if (!cp)
604 return;
605
606 handle = __le16_to_cpu(cp->handle);
607
608 BT_DBG("%s handle %d", hdev->name, handle);
609
610 hci_dev_lock(hdev);
611
612 acl = hci_conn_hash_lookup_handle(hdev, handle);
613 if (acl && (sco = acl->link)) {
614 sco->state = BT_CLOSED;
615
616 hci_proto_connect_cfm(sco, status);
617 hci_conn_del(sco);
618 }
619
620 hci_dev_unlock(hdev);
621 }
622
623 static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
624 {
625 struct hci_cp_sniff_mode *cp;
626 struct hci_conn *conn;
627
628 BT_DBG("%s status 0x%x", hdev->name, status);
629
630 if (!status)
631 return;
632
633 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
634 if (!cp)
635 return;
636
637 hci_dev_lock(hdev);
638
639 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
640 if (conn)
641 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
642
643 hci_dev_unlock(hdev);
644 }
645
646 static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
647 {
648 struct hci_cp_exit_sniff_mode *cp;
649 struct hci_conn *conn;
650
651 BT_DBG("%s status 0x%x", hdev->name, status);
652
653 if (!status)
654 return;
655
656 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
657 if (!cp)
658 return;
659
660 hci_dev_lock(hdev);
661
662 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
663 if (conn)
664 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
665
666 hci_dev_unlock(hdev);
667 }
668
669 static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
670 {
671 __u8 status = *((__u8 *) skb->data);
672
673 BT_DBG("%s status %d", hdev->name, status);
674
675 clear_bit(HCI_INQUIRY, &hdev->flags);
676
677 hci_req_complete(hdev, status);
678
679 hci_conn_check_pending(hdev);
680 }
681
682 static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
683 {
684 struct inquiry_data data;
685 struct inquiry_info *info = (void *) (skb->data + 1);
686 int num_rsp = *((__u8 *) skb->data);
687
688 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
689
690 if (!num_rsp)
691 return;
692
693 hci_dev_lock(hdev);
694
695 for (; num_rsp; num_rsp--) {
696 bacpy(&data.bdaddr, &info->bdaddr);
697 data.pscan_rep_mode = info->pscan_rep_mode;
698 data.pscan_period_mode = info->pscan_period_mode;
699 data.pscan_mode = info->pscan_mode;
700 memcpy(data.dev_class, info->dev_class, 3);
701 data.clock_offset = info->clock_offset;
702 data.rssi = 0x00;
703 info++;
704 hci_inquiry_cache_update(hdev, &data);
705 }
706
707 hci_dev_unlock(hdev);
708 }
709
710 static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
711 {
712 struct hci_ev_conn_complete *ev = (void *) skb->data;
713 struct hci_conn *conn;
714
715 BT_DBG("%s", hdev->name);
716
717 hci_dev_lock(hdev);
718
719 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
720 if (!conn)
721 goto unlock;
722
723 if (!ev->status) {
724 conn->handle = __le16_to_cpu(ev->handle);
725 conn->state = BT_CONNECTED;
726
727 if (test_bit(HCI_AUTH, &hdev->flags))
728 conn->link_mode |= HCI_LM_AUTH;
729
730 if (test_bit(HCI_ENCRYPT, &hdev->flags))
731 conn->link_mode |= HCI_LM_ENCRYPT;
732
733 /* Get remote features */
734 if (conn->type == ACL_LINK) {
735 struct hci_cp_read_remote_features cp;
736 cp.handle = ev->handle;
737 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES, sizeof(cp), &cp);
738 }
739
740 /* Set packet type for incoming connection */
741 if (!conn->out && hdev->hci_ver < 3) {
742 struct hci_cp_change_conn_ptype cp;
743 cp.handle = ev->handle;
744 cp.pkt_type = cpu_to_le16(conn->pkt_type);
745 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
746 sizeof(cp), &cp);
747 } else {
748 /* Update disconnect timer */
749 hci_conn_hold(conn);
750 hci_conn_put(conn);
751 }
752 } else
753 conn->state = BT_CLOSED;
754
755 if (conn->type == ACL_LINK) {
756 struct hci_conn *sco = conn->link;
757 if (sco) {
758 if (!ev->status) {
759 if (lmp_esco_capable(hdev))
760 hci_setup_sync(sco, conn->handle);
761 else
762 hci_add_sco(sco, conn->handle);
763 } else {
764 hci_proto_connect_cfm(sco, ev->status);
765 hci_conn_del(sco);
766 }
767 }
768 }
769
770 hci_proto_connect_cfm(conn, ev->status);
771 if (ev->status)
772 hci_conn_del(conn);
773
774 unlock:
775 hci_dev_unlock(hdev);
776
777 hci_conn_check_pending(hdev);
778 }
779
780 static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
781 {
782 struct hci_ev_conn_request *ev = (void *) skb->data;
783 int mask = hdev->link_mode;
784
785 BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
786 batostr(&ev->bdaddr), ev->link_type);
787
788 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
789
790 if (mask & HCI_LM_ACCEPT) {
791 /* Connection accepted */
792 struct hci_conn *conn;
793
794 hci_dev_lock(hdev);
795
796 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
797 if (!conn) {
798 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
799 BT_ERR("No memmory for new connection");
800 hci_dev_unlock(hdev);
801 return;
802 }
803 }
804
805 memcpy(conn->dev_class, ev->dev_class, 3);
806 conn->state = BT_CONNECT;
807
808 hci_dev_unlock(hdev);
809
810 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
811 struct hci_cp_accept_conn_req cp;
812
813 bacpy(&cp.bdaddr, &ev->bdaddr);
814
815 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
816 cp.role = 0x00; /* Become master */
817 else
818 cp.role = 0x01; /* Remain slave */
819
820 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
821 sizeof(cp), &cp);
822 } else {
823 struct hci_cp_accept_sync_conn_req cp;
824
825 bacpy(&cp.bdaddr, &ev->bdaddr);
826 cp.pkt_type = cpu_to_le16(conn->pkt_type);
827
828 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
829 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
830 cp.max_latency = cpu_to_le16(0xffff);
831 cp.content_format = cpu_to_le16(hdev->voice_setting);
832 cp.retrans_effort = 0xff;
833
834 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
835 sizeof(cp), &cp);
836 }
837 } else {
838 /* Connection rejected */
839 struct hci_cp_reject_conn_req cp;
840
841 bacpy(&cp.bdaddr, &ev->bdaddr);
842 cp.reason = 0x0f;
843 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
844 }
845 }
846
847 static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
848 {
849 struct hci_ev_disconn_complete *ev = (void *) skb->data;
850 struct hci_conn *conn;
851
852 BT_DBG("%s status %d", hdev->name, ev->status);
853
854 if (ev->status)
855 return;
856
857 hci_dev_lock(hdev);
858
859 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
860 if (conn) {
861 conn->state = BT_CLOSED;
862 hci_proto_disconn_ind(conn, ev->reason);
863 hci_conn_del(conn);
864 }
865
866 hci_dev_unlock(hdev);
867 }
868
869 static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
870 {
871 struct hci_ev_auth_complete *ev = (void *) skb->data;
872 struct hci_conn *conn;
873
874 BT_DBG("%s status %d", hdev->name, ev->status);
875
876 hci_dev_lock(hdev);
877
878 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
879 if (conn) {
880 if (!ev->status)
881 conn->link_mode |= HCI_LM_AUTH;
882
883 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
884
885 hci_auth_cfm(conn, ev->status);
886
887 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
888 if (!ev->status) {
889 struct hci_cp_set_conn_encrypt cp;
890 cp.handle = cpu_to_le16(conn->handle);
891 cp.encrypt = 1;
892 hci_send_cmd(conn->hdev,
893 HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
894 } else {
895 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
896 hci_encrypt_cfm(conn, ev->status, 0x00);
897 }
898 }
899 }
900
901 hci_dev_unlock(hdev);
902 }
903
904 static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
905 {
906 BT_DBG("%s", hdev->name);
907
908 hci_conn_check_pending(hdev);
909 }
910
911 static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
912 {
913 struct hci_ev_encrypt_change *ev = (void *) skb->data;
914 struct hci_conn *conn;
915
916 BT_DBG("%s status %d", hdev->name, ev->status);
917
918 hci_dev_lock(hdev);
919
920 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
921 if (conn) {
922 if (!ev->status) {
923 if (ev->encrypt) {
924 /* Encryption implies authentication */
925 conn->link_mode |= HCI_LM_AUTH;
926 conn->link_mode |= HCI_LM_ENCRYPT;
927 } else
928 conn->link_mode &= ~HCI_LM_ENCRYPT;
929 }
930
931 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
932
933 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
934 }
935
936 hci_dev_unlock(hdev);
937 }
938
939 static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
940 {
941 struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
942 struct hci_conn *conn;
943
944 BT_DBG("%s status %d", hdev->name, ev->status);
945
946 hci_dev_lock(hdev);
947
948 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
949 if (conn) {
950 if (!ev->status)
951 conn->link_mode |= HCI_LM_SECURE;
952
953 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
954
955 hci_key_change_cfm(conn, ev->status);
956 }
957
958 hci_dev_unlock(hdev);
959 }
960
961 static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
962 {
963 struct hci_ev_remote_features *ev = (void *) skb->data;
964 struct hci_conn *conn;
965
966 BT_DBG("%s status %d", hdev->name, ev->status);
967
968 if (ev->status)
969 return;
970
971 hci_dev_lock(hdev);
972
973 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
974 if (conn)
975 memcpy(conn->features, ev->features, 8);
976
977 hci_dev_unlock(hdev);
978 }
979
980 static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
981 {
982 BT_DBG("%s", hdev->name);
983 }
984
985 static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
986 {
987 BT_DBG("%s", hdev->name);
988 }
989
990 static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
991 {
992 struct hci_ev_cmd_complete *ev = (void *) skb->data;
993 __u16 opcode;
994
995 skb_pull(skb, sizeof(*ev));
996
997 opcode = __le16_to_cpu(ev->opcode);
998
999 switch (opcode) {
1000 case HCI_OP_INQUIRY_CANCEL:
1001 hci_cc_inquiry_cancel(hdev, skb);
1002 break;
1003
1004 case HCI_OP_EXIT_PERIODIC_INQ:
1005 hci_cc_exit_periodic_inq(hdev, skb);
1006 break;
1007
1008 case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1009 hci_cc_remote_name_req_cancel(hdev, skb);
1010 break;
1011
1012 case HCI_OP_ROLE_DISCOVERY:
1013 hci_cc_role_discovery(hdev, skb);
1014 break;
1015
1016 case HCI_OP_READ_LINK_POLICY:
1017 hci_cc_read_link_policy(hdev, skb);
1018 break;
1019
1020 case HCI_OP_WRITE_LINK_POLICY:
1021 hci_cc_write_link_policy(hdev, skb);
1022 break;
1023
1024 case HCI_OP_READ_DEF_LINK_POLICY:
1025 hci_cc_read_def_link_policy(hdev, skb);
1026 break;
1027
1028 case HCI_OP_WRITE_DEF_LINK_POLICY:
1029 hci_cc_write_def_link_policy(hdev, skb);
1030 break;
1031
1032 case HCI_OP_RESET:
1033 hci_cc_reset(hdev, skb);
1034 break;
1035
1036 case HCI_OP_WRITE_LOCAL_NAME:
1037 hci_cc_write_local_name(hdev, skb);
1038 break;
1039
1040 case HCI_OP_READ_LOCAL_NAME:
1041 hci_cc_read_local_name(hdev, skb);
1042 break;
1043
1044 case HCI_OP_WRITE_AUTH_ENABLE:
1045 hci_cc_write_auth_enable(hdev, skb);
1046 break;
1047
1048 case HCI_OP_WRITE_ENCRYPT_MODE:
1049 hci_cc_write_encrypt_mode(hdev, skb);
1050 break;
1051
1052 case HCI_OP_WRITE_SCAN_ENABLE:
1053 hci_cc_write_scan_enable(hdev, skb);
1054 break;
1055
1056 case HCI_OP_READ_CLASS_OF_DEV:
1057 hci_cc_read_class_of_dev(hdev, skb);
1058 break;
1059
1060 case HCI_OP_WRITE_CLASS_OF_DEV:
1061 hci_cc_write_class_of_dev(hdev, skb);
1062 break;
1063
1064 case HCI_OP_READ_VOICE_SETTING:
1065 hci_cc_read_voice_setting(hdev, skb);
1066 break;
1067
1068 case HCI_OP_WRITE_VOICE_SETTING:
1069 hci_cc_write_voice_setting(hdev, skb);
1070 break;
1071
1072 case HCI_OP_HOST_BUFFER_SIZE:
1073 hci_cc_host_buffer_size(hdev, skb);
1074 break;
1075
1076 case HCI_OP_READ_LOCAL_VERSION:
1077 hci_cc_read_local_version(hdev, skb);
1078 break;
1079
1080 case HCI_OP_READ_LOCAL_COMMANDS:
1081 hci_cc_read_local_commands(hdev, skb);
1082 break;
1083
1084 case HCI_OP_READ_LOCAL_FEATURES:
1085 hci_cc_read_local_features(hdev, skb);
1086 break;
1087
1088 case HCI_OP_READ_BUFFER_SIZE:
1089 hci_cc_read_buffer_size(hdev, skb);
1090 break;
1091
1092 case HCI_OP_READ_BD_ADDR:
1093 hci_cc_read_bd_addr(hdev, skb);
1094 break;
1095
1096 default:
1097 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1098 break;
1099 }
1100
1101 if (ev->ncmd) {
1102 atomic_set(&hdev->cmd_cnt, 1);
1103 if (!skb_queue_empty(&hdev->cmd_q))
1104 hci_sched_cmd(hdev);
1105 }
1106 }
1107
1108 static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1109 {
1110 struct hci_ev_cmd_status *ev = (void *) skb->data;
1111 __u16 opcode;
1112
1113 skb_pull(skb, sizeof(*ev));
1114
1115 opcode = __le16_to_cpu(ev->opcode);
1116
1117 switch (opcode) {
1118 case HCI_OP_INQUIRY:
1119 hci_cs_inquiry(hdev, ev->status);
1120 break;
1121
1122 case HCI_OP_CREATE_CONN:
1123 hci_cs_create_conn(hdev, ev->status);
1124 break;
1125
1126 case HCI_OP_ADD_SCO:
1127 hci_cs_add_sco(hdev, ev->status);
1128 break;
1129
1130 case HCI_OP_REMOTE_NAME_REQ:
1131 hci_cs_remote_name_req(hdev, ev->status);
1132 break;
1133
1134 case HCI_OP_SETUP_SYNC_CONN:
1135 hci_cs_setup_sync_conn(hdev, ev->status);
1136 break;
1137
1138 case HCI_OP_SNIFF_MODE:
1139 hci_cs_sniff_mode(hdev, ev->status);
1140 break;
1141
1142 case HCI_OP_EXIT_SNIFF_MODE:
1143 hci_cs_exit_sniff_mode(hdev, ev->status);
1144 break;
1145
1146 default:
1147 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1148 break;
1149 }
1150
1151 if (ev->ncmd) {
1152 atomic_set(&hdev->cmd_cnt, 1);
1153 if (!skb_queue_empty(&hdev->cmd_q))
1154 hci_sched_cmd(hdev);
1155 }
1156 }
1157
1158 static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1159 {
1160 struct hci_ev_role_change *ev = (void *) skb->data;
1161 struct hci_conn *conn;
1162
1163 BT_DBG("%s status %d", hdev->name, ev->status);
1164
1165 hci_dev_lock(hdev);
1166
1167 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1168 if (conn) {
1169 if (!ev->status) {
1170 if (ev->role)
1171 conn->link_mode &= ~HCI_LM_MASTER;
1172 else
1173 conn->link_mode |= HCI_LM_MASTER;
1174 }
1175
1176 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1177
1178 hci_role_switch_cfm(conn, ev->status, ev->role);
1179 }
1180
1181 hci_dev_unlock(hdev);
1182 }
1183
1184 static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1185 {
1186 struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1187 __le16 *ptr;
1188 int i;
1189
1190 skb_pull(skb, sizeof(*ev));
1191
1192 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1193
1194 if (skb->len < ev->num_hndl * 4) {
1195 BT_DBG("%s bad parameters", hdev->name);
1196 return;
1197 }
1198
1199 tasklet_disable(&hdev->tx_task);
1200
1201 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1202 struct hci_conn *conn;
1203 __u16 handle, count;
1204
1205 handle = get_unaligned_le16(ptr++);
1206 count = get_unaligned_le16(ptr++);
1207
1208 conn = hci_conn_hash_lookup_handle(hdev, handle);
1209 if (conn) {
1210 conn->sent -= count;
1211
1212 if (conn->type == ACL_LINK) {
1213 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1214 hdev->acl_cnt = hdev->acl_pkts;
1215 } else {
1216 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1217 hdev->sco_cnt = hdev->sco_pkts;
1218 }
1219 }
1220 }
1221
1222 hci_sched_tx(hdev);
1223
1224 tasklet_enable(&hdev->tx_task);
1225 }
1226
1227 static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1228 {
1229 struct hci_ev_mode_change *ev = (void *) skb->data;
1230 struct hci_conn *conn;
1231
1232 BT_DBG("%s status %d", hdev->name, ev->status);
1233
1234 hci_dev_lock(hdev);
1235
1236 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1237 if (conn) {
1238 conn->mode = ev->mode;
1239 conn->interval = __le16_to_cpu(ev->interval);
1240
1241 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1242 if (conn->mode == HCI_CM_ACTIVE)
1243 conn->power_save = 1;
1244 else
1245 conn->power_save = 0;
1246 }
1247 }
1248
1249 hci_dev_unlock(hdev);
1250 }
1251
1252 static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1253 {
1254 BT_DBG("%s", hdev->name);
1255 }
1256
1257 static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1258 {
1259 BT_DBG("%s", hdev->name);
1260 }
1261
1262 static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1263 {
1264 BT_DBG("%s", hdev->name);
1265 }
1266
1267 static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1268 {
1269 struct hci_ev_clock_offset *ev = (void *) skb->data;
1270 struct hci_conn *conn;
1271
1272 BT_DBG("%s status %d", hdev->name, ev->status);
1273
1274 hci_dev_lock(hdev);
1275
1276 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1277 if (conn && !ev->status) {
1278 struct inquiry_entry *ie;
1279
1280 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1281 ie->data.clock_offset = ev->clock_offset;
1282 ie->timestamp = jiffies;
1283 }
1284 }
1285
1286 hci_dev_unlock(hdev);
1287 }
1288
1289 static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1290 {
1291 struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1292 struct hci_conn *conn;
1293
1294 BT_DBG("%s status %d", hdev->name, ev->status);
1295
1296 hci_dev_lock(hdev);
1297
1298 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1299 if (conn && !ev->status)
1300 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1301
1302 hci_dev_unlock(hdev);
1303 }
1304
1305 static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1306 {
1307 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
1308 struct inquiry_entry *ie;
1309
1310 BT_DBG("%s", hdev->name);
1311
1312 hci_dev_lock(hdev);
1313
1314 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1315 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1316 ie->timestamp = jiffies;
1317 }
1318
1319 hci_dev_unlock(hdev);
1320 }
1321
1322 static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1323 {
1324 struct inquiry_data data;
1325 int num_rsp = *((__u8 *) skb->data);
1326
1327 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1328
1329 if (!num_rsp)
1330 return;
1331
1332 hci_dev_lock(hdev);
1333
1334 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1335 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1336
1337 for (; num_rsp; num_rsp--) {
1338 bacpy(&data.bdaddr, &info->bdaddr);
1339 data.pscan_rep_mode = info->pscan_rep_mode;
1340 data.pscan_period_mode = info->pscan_period_mode;
1341 data.pscan_mode = info->pscan_mode;
1342 memcpy(data.dev_class, info->dev_class, 3);
1343 data.clock_offset = info->clock_offset;
1344 data.rssi = info->rssi;
1345 info++;
1346 hci_inquiry_cache_update(hdev, &data);
1347 }
1348 } else {
1349 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1350
1351 for (; num_rsp; num_rsp--) {
1352 bacpy(&data.bdaddr, &info->bdaddr);
1353 data.pscan_rep_mode = info->pscan_rep_mode;
1354 data.pscan_period_mode = info->pscan_period_mode;
1355 data.pscan_mode = 0x00;
1356 memcpy(data.dev_class, info->dev_class, 3);
1357 data.clock_offset = info->clock_offset;
1358 data.rssi = info->rssi;
1359 info++;
1360 hci_inquiry_cache_update(hdev, &data);
1361 }
1362 }
1363
1364 hci_dev_unlock(hdev);
1365 }
1366
1367 static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1368 {
1369 BT_DBG("%s", hdev->name);
1370 }
1371
1372 static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1373 {
1374 struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1375 struct hci_conn *conn;
1376
1377 BT_DBG("%s status %d", hdev->name, ev->status);
1378
1379 hci_dev_lock(hdev);
1380
1381 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1382 if (!conn) {
1383 if (ev->link_type == ESCO_LINK)
1384 goto unlock;
1385
1386 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1387 if (!conn)
1388 goto unlock;
1389
1390 conn->type = SCO_LINK;
1391 }
1392
1393 if (!ev->status) {
1394 conn->handle = __le16_to_cpu(ev->handle);
1395 conn->state = BT_CONNECTED;
1396 } else
1397 conn->state = BT_CLOSED;
1398
1399 hci_proto_connect_cfm(conn, ev->status);
1400 if (ev->status)
1401 hci_conn_del(conn);
1402
1403 unlock:
1404 hci_dev_unlock(hdev);
1405 }
1406
1407 static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1408 {
1409 BT_DBG("%s", hdev->name);
1410 }
1411
1412 static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1413 {
1414 struct hci_ev_sniff_subrate *ev = (void *) skb->data;
1415 struct hci_conn *conn;
1416
1417 BT_DBG("%s status %d", hdev->name, ev->status);
1418
1419 hci_dev_lock(hdev);
1420
1421 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1422 if (conn) {
1423 }
1424
1425 hci_dev_unlock(hdev);
1426 }
1427
1428 static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1429 {
1430 struct inquiry_data data;
1431 struct extended_inquiry_info *info = (void *) (skb->data + 1);
1432 int num_rsp = *((__u8 *) skb->data);
1433
1434 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1435
1436 if (!num_rsp)
1437 return;
1438
1439 hci_dev_lock(hdev);
1440
1441 for (; num_rsp; num_rsp--) {
1442 bacpy(&data.bdaddr, &info->bdaddr);
1443 data.pscan_rep_mode = info->pscan_rep_mode;
1444 data.pscan_period_mode = info->pscan_period_mode;
1445 data.pscan_mode = 0x00;
1446 memcpy(data.dev_class, info->dev_class, 3);
1447 data.clock_offset = info->clock_offset;
1448 data.rssi = info->rssi;
1449 info++;
1450 hci_inquiry_cache_update(hdev, &data);
1451 }
1452
1453 hci_dev_unlock(hdev);
1454 }
1455
1456 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1457 {
1458 struct hci_event_hdr *hdr = (void *) skb->data;
1459 __u8 event = hdr->evt;
1460
1461 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1462
1463 switch (event) {
1464 case HCI_EV_INQUIRY_COMPLETE:
1465 hci_inquiry_complete_evt(hdev, skb);
1466 break;
1467
1468 case HCI_EV_INQUIRY_RESULT:
1469 hci_inquiry_result_evt(hdev, skb);
1470 break;
1471
1472 case HCI_EV_CONN_COMPLETE:
1473 hci_conn_complete_evt(hdev, skb);
1474 break;
1475
1476 case HCI_EV_CONN_REQUEST:
1477 hci_conn_request_evt(hdev, skb);
1478 break;
1479
1480 case HCI_EV_DISCONN_COMPLETE:
1481 hci_disconn_complete_evt(hdev, skb);
1482 break;
1483
1484 case HCI_EV_AUTH_COMPLETE:
1485 hci_auth_complete_evt(hdev, skb);
1486 break;
1487
1488 case HCI_EV_REMOTE_NAME:
1489 hci_remote_name_evt(hdev, skb);
1490 break;
1491
1492 case HCI_EV_ENCRYPT_CHANGE:
1493 hci_encrypt_change_evt(hdev, skb);
1494 break;
1495
1496 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1497 hci_change_link_key_complete_evt(hdev, skb);
1498 break;
1499
1500 case HCI_EV_REMOTE_FEATURES:
1501 hci_remote_features_evt(hdev, skb);
1502 break;
1503
1504 case HCI_EV_REMOTE_VERSION:
1505 hci_remote_version_evt(hdev, skb);
1506 break;
1507
1508 case HCI_EV_QOS_SETUP_COMPLETE:
1509 hci_qos_setup_complete_evt(hdev, skb);
1510 break;
1511
1512 case HCI_EV_CMD_COMPLETE:
1513 hci_cmd_complete_evt(hdev, skb);
1514 break;
1515
1516 case HCI_EV_CMD_STATUS:
1517 hci_cmd_status_evt(hdev, skb);
1518 break;
1519
1520 case HCI_EV_ROLE_CHANGE:
1521 hci_role_change_evt(hdev, skb);
1522 break;
1523
1524 case HCI_EV_NUM_COMP_PKTS:
1525 hci_num_comp_pkts_evt(hdev, skb);
1526 break;
1527
1528 case HCI_EV_MODE_CHANGE:
1529 hci_mode_change_evt(hdev, skb);
1530 break;
1531
1532 case HCI_EV_PIN_CODE_REQ:
1533 hci_pin_code_request_evt(hdev, skb);
1534 break;
1535
1536 case HCI_EV_LINK_KEY_REQ:
1537 hci_link_key_request_evt(hdev, skb);
1538 break;
1539
1540 case HCI_EV_LINK_KEY_NOTIFY:
1541 hci_link_key_notify_evt(hdev, skb);
1542 break;
1543
1544 case HCI_EV_CLOCK_OFFSET:
1545 hci_clock_offset_evt(hdev, skb);
1546 break;
1547
1548 case HCI_EV_PKT_TYPE_CHANGE:
1549 hci_pkt_type_change_evt(hdev, skb);
1550 break;
1551
1552 case HCI_EV_PSCAN_REP_MODE:
1553 hci_pscan_rep_mode_evt(hdev, skb);
1554 break;
1555
1556 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1557 hci_inquiry_result_with_rssi_evt(hdev, skb);
1558 break;
1559
1560 case HCI_EV_REMOTE_EXT_FEATURES:
1561 hci_remote_ext_features_evt(hdev, skb);
1562 break;
1563
1564 case HCI_EV_SYNC_CONN_COMPLETE:
1565 hci_sync_conn_complete_evt(hdev, skb);
1566 break;
1567
1568 case HCI_EV_SYNC_CONN_CHANGED:
1569 hci_sync_conn_changed_evt(hdev, skb);
1570 break;
1571
1572 case HCI_EV_SNIFF_SUBRATE:
1573 hci_sniff_subrate_evt(hdev, skb);
1574 break;
1575
1576 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1577 hci_extended_inquiry_result_evt(hdev, skb);
1578 break;
1579
1580 default:
1581 BT_DBG("%s event 0x%x", hdev->name, event);
1582 break;
1583 }
1584
1585 kfree_skb(skb);
1586 hdev->stat.evt_rx++;
1587 }
1588
1589 /* Generate internal stack event */
1590 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1591 {
1592 struct hci_event_hdr *hdr;
1593 struct hci_ev_stack_internal *ev;
1594 struct sk_buff *skb;
1595
1596 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1597 if (!skb)
1598 return;
1599
1600 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1601 hdr->evt = HCI_EV_STACK_INTERNAL;
1602 hdr->plen = sizeof(*ev) + dlen;
1603
1604 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1605 ev->type = type;
1606 memcpy(ev->data, data, dlen);
1607
1608 bt_cb(skb)->incoming = 1;
1609 __net_timestamp(skb);
1610
1611 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1612 skb->dev = (void *) hdev;
1613 hci_send_to_sock(hdev, skb);
1614 kfree_skb(skb);
1615 }
Linux kernel - Deliverables
This page took 1.00941 seconds and 5 git commands to generate.