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