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