?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.19-rc6
[cris-mirror.git] / net / bluetooth / hci_event.c
blob65f094845719126013cfb9f3c1c19e11f4b2b566
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/sched.h>
33 #include <linux/slab.h>
34 #include <linux/poll.h>
35 #include <linux/fcntl.h>
36 #include <linux/init.h>
37 #include <linux/skbuff.h>
38 #include <linux/interrupt.h>
39 #include <linux/notifier.h>
40 #include <net/sock.h>
41
42 #include <asm/system.h>
43 #include <asm/uaccess.h>
44 #include <asm/unaligned.h>
45
46 #include <net/bluetooth/bluetooth.h>
47 #include <net/bluetooth/hci_core.h>
48
49 #ifndef CONFIG_BT_HCI_CORE_DEBUG
50 #undef BT_DBG
51 #define BT_DBG(D...)
52 #endif
53
54 /* Handle HCI Event packets */
55
56 /* Command Complete OGF LINK_CTL */
57 static void hci_cc_link_ctl(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
58 {
59 __u8 status;
60
61 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
62
63 switch (ocf) {
64 case OCF_INQUIRY_CANCEL:
65 case OCF_EXIT_PERIODIC_INQ:
66 status = *((__u8 *) skb->data);
67
68 if (status) {
69 BT_DBG("%s Inquiry cancel error: status 0x%x", hdev->name, status);
70 } else {
71 clear_bit(HCI_INQUIRY, &hdev->flags);
72 hci_req_complete(hdev, status);
73 }
74 break;
75
76 default:
77 BT_DBG("%s Command complete: ogf LINK_CTL ocf %x", hdev->name, ocf);
78 break;
79 }
80 }
81
82 /* Command Complete OGF LINK_POLICY */
83 static void hci_cc_link_policy(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
84 {
85 struct hci_conn *conn;
86 struct hci_rp_role_discovery *rd;
87 struct hci_rp_write_link_policy *lp;
88 void *sent;
89
90 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
91
92 switch (ocf) {
93 case OCF_ROLE_DISCOVERY:
94 rd = (void *) skb->data;
95
96 if (rd->status)
97 break;
98
99 hci_dev_lock(hdev);
100
101 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rd->handle));
102 if (conn) {
103 if (rd->role)
104 conn->link_mode &= ~HCI_LM_MASTER;
105 else
106 conn->link_mode |= HCI_LM_MASTER;
107 }
108
109 hci_dev_unlock(hdev);
110 break;
111
112 case OCF_WRITE_LINK_POLICY:
113 sent = hci_sent_cmd_data(hdev, OGF_LINK_POLICY, OCF_WRITE_LINK_POLICY);
114 if (!sent)
115 break;
116
117 lp = (struct hci_rp_write_link_policy *) skb->data;
118
119 if (lp->status)
120 break;
121
122 hci_dev_lock(hdev);
123
124 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(lp->handle));
125 if (conn) {
126 __le16 policy = get_unaligned((__le16 *) (sent + 2));
127 conn->link_policy = __le16_to_cpu(policy);
128 }
129
130 hci_dev_unlock(hdev);
131 break;
132
133 default:
134 BT_DBG("%s: Command complete: ogf LINK_POLICY ocf %x",
135 hdev->name, ocf);
136 break;
137 }
138 }
139
140 /* Command Complete OGF HOST_CTL */
141 static void hci_cc_host_ctl(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
142 {
143 __u8 status, param;
144 __u16 setting;
145 struct hci_rp_read_voice_setting *vs;
146 void *sent;
147
148 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
149
150 switch (ocf) {
151 case OCF_RESET:
152 status = *((__u8 *) skb->data);
153 hci_req_complete(hdev, status);
154 break;
155
156 case OCF_SET_EVENT_FLT:
157 status = *((__u8 *) skb->data);
158 if (status) {
159 BT_DBG("%s SET_EVENT_FLT failed %d", hdev->name, status);
160 } else {
161 BT_DBG("%s SET_EVENT_FLT succeseful", hdev->name);
162 }
163 break;
164
165 case OCF_WRITE_AUTH_ENABLE:
166 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_AUTH_ENABLE);
167 if (!sent)
168 break;
169
170 status = *((__u8 *) skb->data);
171 param = *((__u8 *) sent);
172
173 if (!status) {
174 if (param == AUTH_ENABLED)
175 set_bit(HCI_AUTH, &hdev->flags);
176 else
177 clear_bit(HCI_AUTH, &hdev->flags);
178 }
179 hci_req_complete(hdev, status);
180 break;
181
182 case OCF_WRITE_ENCRYPT_MODE:
183 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_ENCRYPT_MODE);
184 if (!sent)
185 break;
186
187 status = *((__u8 *) skb->data);
188 param = *((__u8 *) sent);
189
190 if (!status) {
191 if (param)
192 set_bit(HCI_ENCRYPT, &hdev->flags);
193 else
194 clear_bit(HCI_ENCRYPT, &hdev->flags);
195 }
196 hci_req_complete(hdev, status);
197 break;
198
199 case OCF_WRITE_CA_TIMEOUT:
200 status = *((__u8 *) skb->data);
201 if (status) {
202 BT_DBG("%s OCF_WRITE_CA_TIMEOUT failed %d", hdev->name, status);
203 } else {
204 BT_DBG("%s OCF_WRITE_CA_TIMEOUT succeseful", hdev->name);
205 }
206 break;
207
208 case OCF_WRITE_PG_TIMEOUT:
209 status = *((__u8 *) skb->data);
210 if (status) {
211 BT_DBG("%s OCF_WRITE_PG_TIMEOUT failed %d", hdev->name, status);
212 } else {
213 BT_DBG("%s: OCF_WRITE_PG_TIMEOUT succeseful", hdev->name);
214 }
215 break;
216
217 case OCF_WRITE_SCAN_ENABLE:
218 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE);
219 if (!sent)
220 break;
221
222 status = *((__u8 *) skb->data);
223 param = *((__u8 *) sent);
224
225 BT_DBG("param 0x%x", param);
226
227 if (!status) {
228 clear_bit(HCI_PSCAN, &hdev->flags);
229 clear_bit(HCI_ISCAN, &hdev->flags);
230 if (param & SCAN_INQUIRY)
231 set_bit(HCI_ISCAN, &hdev->flags);
232
233 if (param & SCAN_PAGE)
234 set_bit(HCI_PSCAN, &hdev->flags);
235 }
236 hci_req_complete(hdev, status);
237 break;
238
239 case OCF_READ_VOICE_SETTING:
240 vs = (struct hci_rp_read_voice_setting *) skb->data;
241
242 if (vs->status) {
243 BT_DBG("%s READ_VOICE_SETTING failed %d", hdev->name, vs->status);
244 break;
245 }
246
247 setting = __le16_to_cpu(vs->voice_setting);
248
249 if (hdev->voice_setting != setting ) {
250 hdev->voice_setting = setting;
251
252 BT_DBG("%s: voice setting 0x%04x", hdev->name, setting);
253
254 if (hdev->notify) {
255 tasklet_disable(&hdev->tx_task);
256 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
257 tasklet_enable(&hdev->tx_task);
258 }
259 }
260 break;
261
262 case OCF_WRITE_VOICE_SETTING:
263 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_VOICE_SETTING);
264 if (!sent)
265 break;
266
267 status = *((__u8 *) skb->data);
268 setting = __le16_to_cpu(get_unaligned((__le16 *) sent));
269
270 if (!status && hdev->voice_setting != setting) {
271 hdev->voice_setting = setting;
272
273 BT_DBG("%s: voice setting 0x%04x", hdev->name, setting);
274
275 if (hdev->notify) {
276 tasklet_disable(&hdev->tx_task);
277 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
278 tasklet_enable(&hdev->tx_task);
279 }
280 }
281 hci_req_complete(hdev, status);
282 break;
283
284 case OCF_HOST_BUFFER_SIZE:
285 status = *((__u8 *) skb->data);
286 if (status) {
287 BT_DBG("%s OCF_BUFFER_SIZE failed %d", hdev->name, status);
288 hci_req_complete(hdev, status);
289 }
290 break;
291
292 default:
293 BT_DBG("%s Command complete: ogf HOST_CTL ocf %x", hdev->name, ocf);
294 break;
295 }
296 }
297
298 /* Command Complete OGF INFO_PARAM */
299 static void hci_cc_info_param(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
300 {
301 struct hci_rp_read_loc_version *lv;
302 struct hci_rp_read_local_features *lf;
303 struct hci_rp_read_buffer_size *bs;
304 struct hci_rp_read_bd_addr *ba;
305
306 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
307
308 switch (ocf) {
309 case OCF_READ_LOCAL_VERSION:
310 lv = (struct hci_rp_read_loc_version *) skb->data;
311
312 if (lv->status) {
313 BT_DBG("%s READ_LOCAL_VERSION failed %d", hdev->name, lf->status);
314 break;
315 }
316
317 hdev->hci_ver = lv->hci_ver;
318 hdev->hci_rev = btohs(lv->hci_rev);
319 hdev->manufacturer = btohs(lv->manufacturer);
320
321 BT_DBG("%s: manufacturer %d hci_ver %d hci_rev %d", hdev->name,
322 hdev->manufacturer, hdev->hci_ver, hdev->hci_rev);
323
324 break;
325
326 case OCF_READ_LOCAL_FEATURES:
327 lf = (struct hci_rp_read_local_features *) skb->data;
328
329 if (lf->status) {
330 BT_DBG("%s READ_LOCAL_FEATURES failed %d", hdev->name, lf->status);
331 break;
332 }
333
334 memcpy(hdev->features, lf->features, sizeof(hdev->features));
335
336 /* Adjust default settings according to features
337 * supported by device. */
338 if (hdev->features[0] & LMP_3SLOT)
339 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
340
341 if (hdev->features[0] & LMP_5SLOT)
342 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
343
344 if (hdev->features[1] & LMP_HV2)
345 hdev->pkt_type |= (HCI_HV2);
346
347 if (hdev->features[1] & LMP_HV3)
348 hdev->pkt_type |= (HCI_HV3);
349
350 BT_DBG("%s: features 0x%x 0x%x 0x%x", hdev->name,
351 lf->features[0], lf->features[1], lf->features[2]);
352
353 break;
354
355 case OCF_READ_BUFFER_SIZE:
356 bs = (struct hci_rp_read_buffer_size *) skb->data;
357
358 if (bs->status) {
359 BT_DBG("%s READ_BUFFER_SIZE failed %d", hdev->name, bs->status);
360 hci_req_complete(hdev, bs->status);
361 break;
362 }
363
364 hdev->acl_mtu = __le16_to_cpu(bs->acl_mtu);
365 hdev->sco_mtu = bs->sco_mtu;
366 hdev->acl_pkts = __le16_to_cpu(bs->acl_max_pkt);
367 hdev->sco_pkts = __le16_to_cpu(bs->sco_max_pkt);
368
369 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
370 hdev->sco_mtu = 64;
371 hdev->sco_pkts = 8;
372 }
373
374 hdev->acl_cnt = hdev->acl_pkts;
375 hdev->sco_cnt = hdev->sco_pkts;
376
377 BT_DBG("%s mtu: acl %d, sco %d max_pkt: acl %d, sco %d", hdev->name,
378 hdev->acl_mtu, hdev->sco_mtu, hdev->acl_pkts, hdev->sco_pkts);
379 break;
380
381 case OCF_READ_BD_ADDR:
382 ba = (struct hci_rp_read_bd_addr *) skb->data;
383
384 if (!ba->status) {
385 bacpy(&hdev->bdaddr, &ba->bdaddr);
386 } else {
387 BT_DBG("%s: READ_BD_ADDR failed %d", hdev->name, ba->status);
388 }
389
390 hci_req_complete(hdev, ba->status);
391 break;
392
393 default:
394 BT_DBG("%s Command complete: ogf INFO_PARAM ocf %x", hdev->name, ocf);
395 break;
396 }
397 }
398
399 /* Command Status OGF LINK_CTL */
400 static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
401 {
402 struct hci_conn *conn;
403 struct hci_cp_create_conn *cp = hci_sent_cmd_data(hdev, OGF_LINK_CTL, OCF_CREATE_CONN);
404
405 if (!cp)
406 return;
407
408 hci_dev_lock(hdev);
409
410 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
411
412 BT_DBG("%s status 0x%x bdaddr %s conn %p", hdev->name,
413 status, batostr(&cp->bdaddr), conn);
414
415 if (status) {
416 if (conn && conn->state == BT_CONNECT) {
417 if (status != 0x0c || conn->attempt > 2) {
418 conn->state = BT_CLOSED;
419 hci_proto_connect_cfm(conn, status);
420 hci_conn_del(conn);
421 } else
422 conn->state = BT_CONNECT2;
423 }
424 } else {
425 if (!conn) {
426 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
427 if (conn) {
428 conn->out = 1;
429 conn->link_mode |= HCI_LM_MASTER;
430 } else
431 BT_ERR("No memmory for new connection");
432 }
433 }
434
435 hci_dev_unlock(hdev);
436 }
437
438 static void hci_cs_link_ctl(struct hci_dev *hdev, __u16 ocf, __u8 status)
439 {
440 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
441
442 switch (ocf) {
443 case OCF_CREATE_CONN:
444 hci_cs_create_conn(hdev, status);
445 break;
446
447 case OCF_ADD_SCO:
448 if (status) {
449 struct hci_conn *acl, *sco;
450 struct hci_cp_add_sco *cp = hci_sent_cmd_data(hdev, OGF_LINK_CTL, OCF_ADD_SCO);
451 __u16 handle;
452
453 if (!cp)
454 break;
455
456 handle = __le16_to_cpu(cp->handle);
457
458 BT_DBG("%s Add SCO error: handle %d status 0x%x", hdev->name, handle, status);
459
460 hci_dev_lock(hdev);
461
462 acl = hci_conn_hash_lookup_handle(hdev, handle);
463 if (acl && (sco = acl->link)) {
464 sco->state = BT_CLOSED;
465
466 hci_proto_connect_cfm(sco, status);
467 hci_conn_del(sco);
468 }
469
470 hci_dev_unlock(hdev);
471 }
472 break;
473
474 case OCF_INQUIRY:
475 if (status) {
476 BT_DBG("%s Inquiry error: status 0x%x", hdev->name, status);
477 hci_req_complete(hdev, status);
478 } else {
479 set_bit(HCI_INQUIRY, &hdev->flags);
480 }
481 break;
482
483 default:
484 BT_DBG("%s Command status: ogf LINK_CTL ocf %x status %d",
485 hdev->name, ocf, status);
486 break;
487 }
488 }
489
490 /* Command Status OGF LINK_POLICY */
491 static void hci_cs_link_policy(struct hci_dev *hdev, __u16 ocf, __u8 status)
492 {
493 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
494
495 switch (ocf) {
496 case OCF_SNIFF_MODE:
497 if (status) {
498 struct hci_conn *conn;
499 struct hci_cp_sniff_mode *cp = hci_sent_cmd_data(hdev, OGF_LINK_POLICY, OCF_SNIFF_MODE);
500
501 if (!cp)
502 break;
503
504 hci_dev_lock(hdev);
505
506 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
507 if (conn) {
508 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
509 }
510
511 hci_dev_unlock(hdev);
512 }
513 break;
514
515 case OCF_EXIT_SNIFF_MODE:
516 if (status) {
517 struct hci_conn *conn;
518 struct hci_cp_exit_sniff_mode *cp = hci_sent_cmd_data(hdev, OGF_LINK_POLICY, OCF_EXIT_SNIFF_MODE);
519
520 if (!cp)
521 break;
522
523 hci_dev_lock(hdev);
524
525 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
526 if (conn) {
527 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
528 }
529
530 hci_dev_unlock(hdev);
531 }
532 break;
533
534 default:
535 BT_DBG("%s Command status: ogf LINK_POLICY ocf %x", hdev->name, ocf);
536 break;
537 }
538 }
539
540 /* Command Status OGF HOST_CTL */
541 static void hci_cs_host_ctl(struct hci_dev *hdev, __u16 ocf, __u8 status)
542 {
543 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
544
545 switch (ocf) {
546 default:
547 BT_DBG("%s Command status: ogf HOST_CTL ocf %x", hdev->name, ocf);
548 break;
549 }
550 }
551
552 /* Command Status OGF INFO_PARAM */
553 static void hci_cs_info_param(struct hci_dev *hdev, __u16 ocf, __u8 status)
554 {
555 BT_DBG("%s: hci_cs_info_param: ocf 0x%x", hdev->name, ocf);
556
557 switch (ocf) {
558 default:
559 BT_DBG("%s Command status: ogf INFO_PARAM ocf %x", hdev->name, ocf);
560 break;
561 }
562 }
563
564 /* Inquiry Complete */
565 static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
566 {
567 __u8 status = *((__u8 *) skb->data);
568
569 BT_DBG("%s status %d", hdev->name, status);
570
571 clear_bit(HCI_INQUIRY, &hdev->flags);
572 hci_req_complete(hdev, status);
573 }
574
575 /* Inquiry Result */
576 static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
577 {
578 struct inquiry_data data;
579 struct inquiry_info *info = (struct inquiry_info *) (skb->data + 1);
580 int num_rsp = *((__u8 *) skb->data);
581
582 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
583
584 if (!num_rsp)
585 return;
586
587 hci_dev_lock(hdev);
588
589 for (; num_rsp; num_rsp--) {
590 bacpy(&data.bdaddr, &info->bdaddr);
591 data.pscan_rep_mode = info->pscan_rep_mode;
592 data.pscan_period_mode = info->pscan_period_mode;
593 data.pscan_mode = info->pscan_mode;
594 memcpy(data.dev_class, info->dev_class, 3);
595 data.clock_offset = info->clock_offset;
596 data.rssi = 0x00;
597 info++;
598 hci_inquiry_cache_update(hdev, &data);
599 }
600
601 hci_dev_unlock(hdev);
602 }
603
604 /* Inquiry Result With RSSI */
605 static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
606 {
607 struct inquiry_data data;
608 int num_rsp = *((__u8 *) skb->data);
609
610 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
611
612 if (!num_rsp)
613 return;
614
615 hci_dev_lock(hdev);
616
617 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
618 struct inquiry_info_with_rssi_and_pscan_mode *info =
619 (struct inquiry_info_with_rssi_and_pscan_mode *) (skb->data + 1);
620
621 for (; num_rsp; num_rsp--) {
622 bacpy(&data.bdaddr, &info->bdaddr);
623 data.pscan_rep_mode = info->pscan_rep_mode;
624 data.pscan_period_mode = info->pscan_period_mode;
625 data.pscan_mode = info->pscan_mode;
626 memcpy(data.dev_class, info->dev_class, 3);
627 data.clock_offset = info->clock_offset;
628 data.rssi = info->rssi;
629 info++;
630 hci_inquiry_cache_update(hdev, &data);
631 }
632 } else {
633 struct inquiry_info_with_rssi *info =
634 (struct inquiry_info_with_rssi *) (skb->data + 1);
635
636 for (; num_rsp; num_rsp--) {
637 bacpy(&data.bdaddr, &info->bdaddr);
638 data.pscan_rep_mode = info->pscan_rep_mode;
639 data.pscan_period_mode = info->pscan_period_mode;
640 data.pscan_mode = 0x00;
641 memcpy(data.dev_class, info->dev_class, 3);
642 data.clock_offset = info->clock_offset;
643 data.rssi = info->rssi;
644 info++;
645 hci_inquiry_cache_update(hdev, &data);
646 }
647 }
648
649 hci_dev_unlock(hdev);
650 }
651
652 /* Extended Inquiry Result */
653 static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
654 {
655 struct inquiry_data data;
656 struct extended_inquiry_info *info = (struct extended_inquiry_info *) (skb->data + 1);
657 int num_rsp = *((__u8 *) skb->data);
658
659 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
660
661 if (!num_rsp)
662 return;
663
664 hci_dev_lock(hdev);
665
666 for (; num_rsp; num_rsp--) {
667 bacpy(&data.bdaddr, &info->bdaddr);
668 data.pscan_rep_mode = info->pscan_rep_mode;
669 data.pscan_period_mode = info->pscan_period_mode;
670 data.pscan_mode = 0x00;
671 memcpy(data.dev_class, info->dev_class, 3);
672 data.clock_offset = info->clock_offset;
673 data.rssi = info->rssi;
674 info++;
675 hci_inquiry_cache_update(hdev, &data);
676 }
677
678 hci_dev_unlock(hdev);
679 }
680
681 /* Connect Request */
682 static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
683 {
684 struct hci_ev_conn_request *ev = (struct hci_ev_conn_request *) skb->data;
685 int mask = hdev->link_mode;
686
687 BT_DBG("%s Connection request: %s type 0x%x", hdev->name,
688 batostr(&ev->bdaddr), ev->link_type);
689
690 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
691
692 if (mask & HCI_LM_ACCEPT) {
693 /* Connection accepted */
694 struct hci_conn *conn;
695 struct hci_cp_accept_conn_req cp;
696
697 hci_dev_lock(hdev);
698 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
699 if (!conn) {
700 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
701 BT_ERR("No memmory for new connection");
702 hci_dev_unlock(hdev);
703 return;
704 }
705 }
706 memcpy(conn->dev_class, ev->dev_class, 3);
707 conn->state = BT_CONNECT;
708 hci_dev_unlock(hdev);
709
710 bacpy(&cp.bdaddr, &ev->bdaddr);
711
712 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
713 cp.role = 0x00; /* Become master */
714 else
715 cp.role = 0x01; /* Remain slave */
716
717 hci_send_cmd(hdev, OGF_LINK_CTL,
718 OCF_ACCEPT_CONN_REQ, sizeof(cp), &cp);
719 } else {
720 /* Connection rejected */
721 struct hci_cp_reject_conn_req cp;
722
723 bacpy(&cp.bdaddr, &ev->bdaddr);
724 cp.reason = 0x0f;
725 hci_send_cmd(hdev, OGF_LINK_CTL,
726 OCF_REJECT_CONN_REQ, sizeof(cp), &cp);
727 }
728 }
729
730 /* Connect Complete */
731 static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
732 {
733 struct hci_ev_conn_complete *ev = (struct hci_ev_conn_complete *) skb->data;
734 struct hci_conn *conn, *pend;
735
736 BT_DBG("%s", hdev->name);
737
738 hci_dev_lock(hdev);
739
740 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
741 if (!conn) {
742 hci_dev_unlock(hdev);
743 return;
744 }
745
746 if (!ev->status) {
747 conn->handle = __le16_to_cpu(ev->handle);
748 conn->state = BT_CONNECTED;
749
750 if (test_bit(HCI_AUTH, &hdev->flags))
751 conn->link_mode |= HCI_LM_AUTH;
752
753 if (test_bit(HCI_ENCRYPT, &hdev->flags))
754 conn->link_mode |= HCI_LM_ENCRYPT;
755
756 /* Get remote features */
757 if (conn->type == ACL_LINK) {
758 struct hci_cp_read_remote_features cp;
759 cp.handle = ev->handle;
760 hci_send_cmd(hdev, OGF_LINK_CTL,
761 OCF_READ_REMOTE_FEATURES, sizeof(cp), &cp);
762 }
763
764 /* Set link policy */
765 if (conn->type == ACL_LINK && hdev->link_policy) {
766 struct hci_cp_write_link_policy cp;
767 cp.handle = ev->handle;
768 cp.policy = __cpu_to_le16(hdev->link_policy);
769 hci_send_cmd(hdev, OGF_LINK_POLICY,
770 OCF_WRITE_LINK_POLICY, sizeof(cp), &cp);
771 }
772
773 /* Set packet type for incoming connection */
774 if (!conn->out) {
775 struct hci_cp_change_conn_ptype cp;
776 cp.handle = ev->handle;
777 cp.pkt_type = (conn->type == ACL_LINK) ?
778 __cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK):
779 __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
780
781 hci_send_cmd(hdev, OGF_LINK_CTL,
782 OCF_CHANGE_CONN_PTYPE, sizeof(cp), &cp);
783 } else {
784 /* Update disconnect timer */
785 hci_conn_hold(conn);
786 hci_conn_put(conn);
787 }
788 } else
789 conn->state = BT_CLOSED;
790
791 if (conn->type == ACL_LINK) {
792 struct hci_conn *sco = conn->link;
793 if (sco) {
794 if (!ev->status)
795 hci_add_sco(sco, conn->handle);
796 else {
797 hci_proto_connect_cfm(sco, ev->status);
798 hci_conn_del(sco);
799 }
800 }
801 }
802
803 hci_proto_connect_cfm(conn, ev->status);
804 if (ev->status)
805 hci_conn_del(conn);
806
807 pend = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
808 if (pend)
809 hci_acl_connect(pend);
810
811 hci_dev_unlock(hdev);
812 }
813
814 /* Disconnect Complete */
815 static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
816 {
817 struct hci_ev_disconn_complete *ev = (struct hci_ev_disconn_complete *) skb->data;
818 struct hci_conn *conn;
819
820 BT_DBG("%s status %d", hdev->name, ev->status);
821
822 if (ev->status)
823 return;
824
825 hci_dev_lock(hdev);
826
827 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
828 if (conn) {
829 conn->state = BT_CLOSED;
830 hci_proto_disconn_ind(conn, ev->reason);
831 hci_conn_del(conn);
832 }
833
834 hci_dev_unlock(hdev);
835 }
836
837 /* Number of completed packets */
838 static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
839 {
840 struct hci_ev_num_comp_pkts *ev = (struct hci_ev_num_comp_pkts *) skb->data;
841 __le16 *ptr;
842 int i;
843
844 skb_pull(skb, sizeof(*ev));
845
846 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
847
848 if (skb->len < ev->num_hndl * 4) {
849 BT_DBG("%s bad parameters", hdev->name);
850 return;
851 }
852
853 tasklet_disable(&hdev->tx_task);
854
855 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
856 struct hci_conn *conn;
857 __u16 handle, count;
858
859 handle = __le16_to_cpu(get_unaligned(ptr++));
860 count = __le16_to_cpu(get_unaligned(ptr++));
861
862 conn = hci_conn_hash_lookup_handle(hdev, handle);
863 if (conn) {
864 conn->sent -= count;
865
866 if (conn->type == SCO_LINK) {
867 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
868 hdev->sco_cnt = hdev->sco_pkts;
869 } else {
870 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
871 hdev->acl_cnt = hdev->acl_pkts;
872 }
873 }
874 }
875 hci_sched_tx(hdev);
876
877 tasklet_enable(&hdev->tx_task);
878 }
879
880 /* Role Change */
881 static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
882 {
883 struct hci_ev_role_change *ev = (struct hci_ev_role_change *) skb->data;
884 struct hci_conn *conn;
885
886 BT_DBG("%s status %d", hdev->name, ev->status);
887
888 hci_dev_lock(hdev);
889
890 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
891 if (conn) {
892 if (!ev->status) {
893 if (ev->role)
894 conn->link_mode &= ~HCI_LM_MASTER;
895 else
896 conn->link_mode |= HCI_LM_MASTER;
897 }
898
899 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
900
901 hci_role_switch_cfm(conn, ev->status, ev->role);
902 }
903
904 hci_dev_unlock(hdev);
905 }
906
907 /* Mode Change */
908 static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
909 {
910 struct hci_ev_mode_change *ev = (struct hci_ev_mode_change *) skb->data;
911 struct hci_conn *conn;
912
913 BT_DBG("%s status %d", hdev->name, ev->status);
914
915 hci_dev_lock(hdev);
916
917 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
918 if (conn) {
919 conn->mode = ev->mode;
920 conn->interval = __le16_to_cpu(ev->interval);
921
922 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
923 if (conn->mode == HCI_CM_ACTIVE)
924 conn->power_save = 1;
925 else
926 conn->power_save = 0;
927 }
928 }
929
930 hci_dev_unlock(hdev);
931 }
932
933 /* Authentication Complete */
934 static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
935 {
936 struct hci_ev_auth_complete *ev = (struct hci_ev_auth_complete *) skb->data;
937 struct hci_conn *conn;
938
939 BT_DBG("%s status %d", hdev->name, ev->status);
940
941 hci_dev_lock(hdev);
942
943 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
944 if (conn) {
945 if (!ev->status)
946 conn->link_mode |= HCI_LM_AUTH;
947
948 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
949
950 hci_auth_cfm(conn, ev->status);
951
952 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
953 if (!ev->status) {
954 struct hci_cp_set_conn_encrypt cp;
955 cp.handle = __cpu_to_le16(conn->handle);
956 cp.encrypt = 1;
957 hci_send_cmd(conn->hdev, OGF_LINK_CTL,
958 OCF_SET_CONN_ENCRYPT, sizeof(cp), &cp);
959 } else {
960 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
961 hci_encrypt_cfm(conn, ev->status, 0x00);
962 }
963 }
964 }
965
966 hci_dev_unlock(hdev);
967 }
968
969 /* Encryption Change */
970 static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
971 {
972 struct hci_ev_encrypt_change *ev = (struct hci_ev_encrypt_change *) skb->data;
973 struct hci_conn *conn;
974
975 BT_DBG("%s status %d", hdev->name, ev->status);
976
977 hci_dev_lock(hdev);
978
979 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
980 if (conn) {
981 if (!ev->status) {
982 if (ev->encrypt)
983 conn->link_mode |= HCI_LM_ENCRYPT;
984 else
985 conn->link_mode &= ~HCI_LM_ENCRYPT;
986 }
987
988 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
989
990 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
991 }
992
993 hci_dev_unlock(hdev);
994 }
995
996 /* Change Connection Link Key Complete */
997 static inline void hci_change_conn_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
998 {
999 struct hci_ev_change_conn_link_key_complete *ev = (struct hci_ev_change_conn_link_key_complete *) skb->data;
1000 struct hci_conn *conn;
1001
1002 BT_DBG("%s status %d", hdev->name, ev->status);
1003
1004 hci_dev_lock(hdev);
1005
1006 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1007 if (conn) {
1008 if (!ev->status)
1009 conn->link_mode |= HCI_LM_SECURE;
1010
1011 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1012
1013 hci_key_change_cfm(conn, ev->status);
1014 }
1015
1016 hci_dev_unlock(hdev);
1017 }
1018
1019 /* Pin Code Request*/
1020 static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1021 {
1022 }
1023
1024 /* Link Key Request */
1025 static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1026 {
1027 }
1028
1029 /* Link Key Notification */
1030 static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1031 {
1032 }
1033
1034 /* Remote Features */
1035 static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1036 {
1037 struct hci_ev_remote_features *ev = (struct hci_ev_remote_features *) skb->data;
1038 struct hci_conn *conn;
1039
1040 BT_DBG("%s status %d", hdev->name, ev->status);
1041
1042 hci_dev_lock(hdev);
1043
1044 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1045 if (conn && !ev->status) {
1046 memcpy(conn->features, ev->features, sizeof(conn->features));
1047 }
1048
1049 hci_dev_unlock(hdev);
1050 }
1051
1052 /* Clock Offset */
1053 static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1054 {
1055 struct hci_ev_clock_offset *ev = (struct hci_ev_clock_offset *) skb->data;
1056 struct hci_conn *conn;
1057
1058 BT_DBG("%s status %d", hdev->name, ev->status);
1059
1060 hci_dev_lock(hdev);
1061
1062 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1063 if (conn && !ev->status) {
1064 struct inquiry_entry *ie;
1065
1066 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1067 ie->data.clock_offset = ev->clock_offset;
1068 ie->timestamp = jiffies;
1069 }
1070 }
1071
1072 hci_dev_unlock(hdev);
1073 }
1074
1075 /* Page Scan Repetition Mode */
1076 static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1077 {
1078 struct hci_ev_pscan_rep_mode *ev = (struct hci_ev_pscan_rep_mode *) skb->data;
1079 struct inquiry_entry *ie;
1080
1081 BT_DBG("%s", hdev->name);
1082
1083 hci_dev_lock(hdev);
1084
1085 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1086 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1087 ie->timestamp = jiffies;
1088 }
1089
1090 hci_dev_unlock(hdev);
1091 }
1092
1093 /* Sniff Subrate */
1094 static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1095 {
1096 struct hci_ev_sniff_subrate *ev = (struct hci_ev_sniff_subrate *) skb->data;
1097 struct hci_conn *conn;
1098
1099 BT_DBG("%s status %d", hdev->name, ev->status);
1100
1101 hci_dev_lock(hdev);
1102
1103 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1104 if (conn) {
1105 }
1106
1107 hci_dev_unlock(hdev);
1108 }
1109
1110 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1111 {
1112 struct hci_event_hdr *hdr = (struct hci_event_hdr *) skb->data;
1113 struct hci_ev_cmd_complete *ec;
1114 struct hci_ev_cmd_status *cs;
1115 u16 opcode, ocf, ogf;
1116
1117 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1118
1119 BT_DBG("%s evt 0x%x", hdev->name, hdr->evt);
1120
1121 switch (hdr->evt) {
1122 case HCI_EV_NUM_COMP_PKTS:
1123 hci_num_comp_pkts_evt(hdev, skb);
1124 break;
1125
1126 case HCI_EV_INQUIRY_COMPLETE:
1127 hci_inquiry_complete_evt(hdev, skb);
1128 break;
1129
1130 case HCI_EV_INQUIRY_RESULT:
1131 hci_inquiry_result_evt(hdev, skb);
1132 break;
1133
1134 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1135 hci_inquiry_result_with_rssi_evt(hdev, skb);
1136 break;
1137
1138 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1139 hci_extended_inquiry_result_evt(hdev, skb);
1140 break;
1141
1142 case HCI_EV_CONN_REQUEST:
1143 hci_conn_request_evt(hdev, skb);
1144 break;
1145
1146 case HCI_EV_CONN_COMPLETE:
1147 hci_conn_complete_evt(hdev, skb);
1148 break;
1149
1150 case HCI_EV_DISCONN_COMPLETE:
1151 hci_disconn_complete_evt(hdev, skb);
1152 break;
1153
1154 case HCI_EV_ROLE_CHANGE:
1155 hci_role_change_evt(hdev, skb);
1156 break;
1157
1158 case HCI_EV_MODE_CHANGE:
1159 hci_mode_change_evt(hdev, skb);
1160 break;
1161
1162 case HCI_EV_AUTH_COMPLETE:
1163 hci_auth_complete_evt(hdev, skb);
1164 break;
1165
1166 case HCI_EV_ENCRYPT_CHANGE:
1167 hci_encrypt_change_evt(hdev, skb);
1168 break;
1169
1170 case HCI_EV_CHANGE_CONN_LINK_KEY_COMPLETE:
1171 hci_change_conn_link_key_complete_evt(hdev, skb);
1172 break;
1173
1174 case HCI_EV_PIN_CODE_REQ:
1175 hci_pin_code_request_evt(hdev, skb);
1176 break;
1177
1178 case HCI_EV_LINK_KEY_REQ:
1179 hci_link_key_request_evt(hdev, skb);
1180 break;
1181
1182 case HCI_EV_LINK_KEY_NOTIFY:
1183 hci_link_key_notify_evt(hdev, skb);
1184 break;
1185
1186 case HCI_EV_REMOTE_FEATURES:
1187 hci_remote_features_evt(hdev, skb);
1188 break;
1189
1190 case HCI_EV_CLOCK_OFFSET:
1191 hci_clock_offset_evt(hdev, skb);
1192 break;
1193
1194 case HCI_EV_PSCAN_REP_MODE:
1195 hci_pscan_rep_mode_evt(hdev, skb);
1196 break;
1197
1198 case HCI_EV_SNIFF_SUBRATE:
1199 hci_sniff_subrate_evt(hdev, skb);
1200 break;
1201
1202 case HCI_EV_CMD_STATUS:
1203 cs = (struct hci_ev_cmd_status *) skb->data;
1204 skb_pull(skb, sizeof(cs));
1205
1206 opcode = __le16_to_cpu(cs->opcode);
1207 ogf = hci_opcode_ogf(opcode);
1208 ocf = hci_opcode_ocf(opcode);
1209
1210 switch (ogf) {
1211 case OGF_INFO_PARAM:
1212 hci_cs_info_param(hdev, ocf, cs->status);
1213 break;
1214
1215 case OGF_HOST_CTL:
1216 hci_cs_host_ctl(hdev, ocf, cs->status);
1217 break;
1218
1219 case OGF_LINK_CTL:
1220 hci_cs_link_ctl(hdev, ocf, cs->status);
1221 break;
1222
1223 case OGF_LINK_POLICY:
1224 hci_cs_link_policy(hdev, ocf, cs->status);
1225 break;
1226
1227 default:
1228 BT_DBG("%s Command Status OGF %x", hdev->name, ogf);
1229 break;
1230 }
1231
1232 if (cs->ncmd) {
1233 atomic_set(&hdev->cmd_cnt, 1);
1234 if (!skb_queue_empty(&hdev->cmd_q))
1235 hci_sched_cmd(hdev);
1236 }
1237 break;
1238
1239 case HCI_EV_CMD_COMPLETE:
1240 ec = (struct hci_ev_cmd_complete *) skb->data;
1241 skb_pull(skb, sizeof(*ec));
1242
1243 opcode = __le16_to_cpu(ec->opcode);
1244 ogf = hci_opcode_ogf(opcode);
1245 ocf = hci_opcode_ocf(opcode);
1246
1247 switch (ogf) {
1248 case OGF_INFO_PARAM:
1249 hci_cc_info_param(hdev, ocf, skb);
1250 break;
1251
1252 case OGF_HOST_CTL:
1253 hci_cc_host_ctl(hdev, ocf, skb);
1254 break;
1255
1256 case OGF_LINK_CTL:
1257 hci_cc_link_ctl(hdev, ocf, skb);
1258 break;
1259
1260 case OGF_LINK_POLICY:
1261 hci_cc_link_policy(hdev, ocf, skb);
1262 break;
1263
1264 default:
1265 BT_DBG("%s Command Completed OGF %x", hdev->name, ogf);
1266 break;
1267 }
1268
1269 if (ec->ncmd) {
1270 atomic_set(&hdev->cmd_cnt, 1);
1271 if (!skb_queue_empty(&hdev->cmd_q))
1272 hci_sched_cmd(hdev);
1273 }
1274 break;
1275 }
1276
1277 kfree_skb(skb);
1278 hdev->stat.evt_rx++;
1279 }
1280
1281 /* Generate internal stack event */
1282 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1283 {
1284 struct hci_event_hdr *hdr;
1285 struct hci_ev_stack_internal *ev;
1286 struct sk_buff *skb;
1287
1288 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1289 if (!skb)
1290 return;
1291
1292 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1293 hdr->evt = HCI_EV_STACK_INTERNAL;
1294 hdr->plen = sizeof(*ev) + dlen;
1295
1296 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1297 ev->type = type;
1298 memcpy(ev->data, data, dlen);
1299
1300 bt_cb(skb)->incoming = 1;
1301 __net_timestamp(skb);
1302
1303 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1304 skb->dev = (void *) hdev;
1305 hci_send_to_sock(hdev, skb);
1306 kfree_skb(skb);
1307 }
CRIS linux kernel tree