projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[Bluetooth] Return EINPROGRESS for non-blocking socket calls
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / hci_event.c
CommitLineData
1da177e4
LT		 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
1da177e4
LT		 27#include <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/errno.h>
31#include <linux/kernel.h>
1da177e4
LT		 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 */
57static 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:
defc761b 65 case OCF_EXIT_PERIODIC_INQ:
1da177e4
LT		 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 */
83static 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;
04837f64
MH		 87 struct hci_rp_write_link_policy *lp;
88 void *sent;
1da177e4
LT		 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
04837f64
MH		 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
1da177e4
LT		 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 */
141static 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);
1ebb9252 268 setting = __le16_to_cpu(get_unaligned((__le16 *) sent));
1da177e4
LT		 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 */
299static void hci_cc_info_param(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
300{
04837f64 301 struct hci_rp_read_local_features *lf;
1da177e4
LT		 302 struct hci_rp_read_buffer_size *bs;
303 struct hci_rp_read_bd_addr *ba;
304
305 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
306
307 switch (ocf) {
308 case OCF_READ_LOCAL_FEATURES:
04837f64 309 lf = (struct hci_rp_read_local_features *) skb->data;
1da177e4
LT		 310
311 if (lf->status) {
312 BT_DBG("%s READ_LOCAL_FEATURES failed %d", hdev->name, lf->status);
313 break;
314 }
315
316 memcpy(hdev->features, lf->features, sizeof(hdev->features));
317
318 /* Adjust default settings according to features
319 * supported by device. */
320 if (hdev->features[0] & LMP_3SLOT)
321 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
322
323 if (hdev->features[0] & LMP_5SLOT)
324 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
325
326 if (hdev->features[1] & LMP_HV2)
327 hdev->pkt_type |= (HCI_HV2);
328
329 if (hdev->features[1] & LMP_HV3)
330 hdev->pkt_type |= (HCI_HV3);
331
332 BT_DBG("%s: features 0x%x 0x%x 0x%x", hdev->name, lf->features[0], lf->features[1], lf->features[2]);
333
334 break;
335
336 case OCF_READ_BUFFER_SIZE:
337 bs = (struct hci_rp_read_buffer_size *) skb->data;
338
339 if (bs->status) {
340 BT_DBG("%s READ_BUFFER_SIZE failed %d", hdev->name, bs->status);
341 hci_req_complete(hdev, bs->status);
342 break;
343 }
344
345 hdev->acl_mtu = __le16_to_cpu(bs->acl_mtu);
da1f5198
MH		 346 hdev->sco_mtu = bs->sco_mtu;
347 hdev->acl_pkts = __le16_to_cpu(bs->acl_max_pkt);
348 hdev->sco_pkts = __le16_to_cpu(bs->sco_max_pkt);
349
350 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
351 hdev->sco_mtu = 64;
352 hdev->sco_pkts = 8;
353 }
354
355 hdev->acl_cnt = hdev->acl_pkts;
356 hdev->sco_cnt = hdev->sco_pkts;
1da177e4
LT		 357
358 BT_DBG("%s mtu: acl %d, sco %d max_pkt: acl %d, sco %d", hdev->name,
359 hdev->acl_mtu, hdev->sco_mtu, hdev->acl_pkts, hdev->sco_pkts);
360 break;
361
362 case OCF_READ_BD_ADDR:
363 ba = (struct hci_rp_read_bd_addr *) skb->data;
364
365 if (!ba->status) {
366 bacpy(&hdev->bdaddr, &ba->bdaddr);
367 } else {
368 BT_DBG("%s: READ_BD_ADDR failed %d", hdev->name, ba->status);
369 }
370
371 hci_req_complete(hdev, ba->status);
372 break;
373
374 default:
375 BT_DBG("%s Command complete: ogf INFO_PARAM ocf %x", hdev->name, ocf);
376 break;
377 }
378}
379
380/* Command Status OGF LINK_CTL */
381static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
382{
383 struct hci_conn *conn;
384 struct hci_cp_create_conn *cp = hci_sent_cmd_data(hdev, OGF_LINK_CTL, OCF_CREATE_CONN);
385
386 if (!cp)
387 return;
388
389 hci_dev_lock(hdev);
390
391 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
392
393 BT_DBG("%s status 0x%x bdaddr %s conn %p", hdev->name,
394 status, batostr(&cp->bdaddr), conn);
395
396 if (status) {
397 if (conn && conn->state == BT_CONNECT) {
398 conn->state = BT_CLOSED;
399 hci_proto_connect_cfm(conn, status);
400 hci_conn_del(conn);
401 }
402 } else {
403 if (!conn) {
404 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
405 if (conn) {
406 conn->out = 1;
407 conn->link_mode |= HCI_LM_MASTER;
408 } else
409 BT_ERR("No memmory for new connection");
410 }
411 }
412
413 hci_dev_unlock(hdev);
414}
415
416static void hci_cs_link_ctl(struct hci_dev *hdev, __u16 ocf, __u8 status)
417{
418 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
419
420 switch (ocf) {
421 case OCF_CREATE_CONN:
422 hci_cs_create_conn(hdev, status);
423 break;
424
425 case OCF_ADD_SCO:
426 if (status) {
427 struct hci_conn *acl, *sco;
428 struct hci_cp_add_sco *cp = hci_sent_cmd_data(hdev, OGF_LINK_CTL, OCF_ADD_SCO);
429 __u16 handle;
430
431 if (!cp)
432 break;
433
434 handle = __le16_to_cpu(cp->handle);
435
436 BT_DBG("%s Add SCO error: handle %d status 0x%x", hdev->name, handle, status);
437
438 hci_dev_lock(hdev);
439
440 acl = hci_conn_hash_lookup_handle(hdev, handle);
441 if (acl && (sco = acl->link)) {
442 sco->state = BT_CLOSED;
443
444 hci_proto_connect_cfm(sco, status);
445 hci_conn_del(sco);
446 }
447
448 hci_dev_unlock(hdev);
449 }
450 break;
451
452 case OCF_INQUIRY:
453 if (status) {
454 BT_DBG("%s Inquiry error: status 0x%x", hdev->name, status);
455 hci_req_complete(hdev, status);
456 } else {
457 set_bit(HCI_INQUIRY, &hdev->flags);
458 }
459 break;
460
461 default:
462 BT_DBG("%s Command status: ogf LINK_CTL ocf %x status %d",
463 hdev->name, ocf, status);
464 break;
465 }
466}
467
468/* Command Status OGF LINK_POLICY */
469static void hci_cs_link_policy(struct hci_dev *hdev, __u16 ocf, __u8 status)
470{
471 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
472
473 switch (ocf) {
04837f64
MH		 474 case OCF_SNIFF_MODE:
475 if (status) {
476 struct hci_conn *conn;
477 struct hci_cp_sniff_mode *cp = hci_sent_cmd_data(hdev, OGF_LINK_POLICY, OCF_SNIFF_MODE);
478
479 if (!cp)
480 break;
481
482 hci_dev_lock(hdev);
483
484 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
485 if (conn) {
486 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
487 }
488
489 hci_dev_unlock(hdev);
490 }
491 break;
492
493 case OCF_EXIT_SNIFF_MODE:
494 if (status) {
495 struct hci_conn *conn;
496 struct hci_cp_exit_sniff_mode *cp = hci_sent_cmd_data(hdev, OGF_LINK_POLICY, OCF_EXIT_SNIFF_MODE);
497
498 if (!cp)
499 break;
500
501 hci_dev_lock(hdev);
502
503 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
504 if (conn) {
505 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
506 }
507
508 hci_dev_unlock(hdev);
509 }
510 break;
511
1da177e4 512 default:
04837f64 513 BT_DBG("%s Command status: ogf LINK_POLICY ocf %x", hdev->name, ocf);
1da177e4
LT		 514 break;
515 }
516}
517
518/* Command Status OGF HOST_CTL */
519static void hci_cs_host_ctl(struct hci_dev *hdev, __u16 ocf, __u8 status)
520{
521 BT_DBG("%s ocf 0x%x", hdev->name, ocf);
522
523 switch (ocf) {
524 default:
525 BT_DBG("%s Command status: ogf HOST_CTL ocf %x", hdev->name, ocf);
526 break;
527 }
528}
529
530/* Command Status OGF INFO_PARAM */
531static void hci_cs_info_param(struct hci_dev *hdev, __u16 ocf, __u8 status)
532{
533 BT_DBG("%s: hci_cs_info_param: ocf 0x%x", hdev->name, ocf);
534
535 switch (ocf) {
536 default:
537 BT_DBG("%s Command status: ogf INFO_PARAM ocf %x", hdev->name, ocf);
538 break;
539 }
540}
541
542/* Inquiry Complete */
543static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
544{
545 __u8 status = *((__u8 *) skb->data);
546
547 BT_DBG("%s status %d", hdev->name, status);
548
549 clear_bit(HCI_INQUIRY, &hdev->flags);
550 hci_req_complete(hdev, status);
551}
552
553/* Inquiry Result */
554static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
555{
45bb4bf0 556 struct inquiry_data data;
1da177e4
LT		 557 struct inquiry_info *info = (struct inquiry_info *) (skb->data + 1);
558 int num_rsp = *((__u8 *) skb->data);
559
560 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
561
45bb4bf0
MH		 562 if (!num_rsp)
563 return;
564
1da177e4 565 hci_dev_lock(hdev);
45bb4bf0 566
1da177e4 567 for (; num_rsp; num_rsp--) {
1da177e4
LT		 568 bacpy(&data.bdaddr, &info->bdaddr);
569 data.pscan_rep_mode = info->pscan_rep_mode;
570 data.pscan_period_mode = info->pscan_period_mode;
571 data.pscan_mode = info->pscan_mode;
572 memcpy(data.dev_class, info->dev_class, 3);
573 data.clock_offset = info->clock_offset;
574 data.rssi = 0x00;
575 info++;
576 hci_inquiry_cache_update(hdev, &data);
577 }
45bb4bf0 578
1da177e4
LT		 579 hci_dev_unlock(hdev);
580}
581
582/* Inquiry Result With RSSI */
583static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
584{
45bb4bf0 585 struct inquiry_data data;
1da177e4
LT		 586 int num_rsp = *((__u8 *) skb->data);
587
588 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
589
45bb4bf0
MH		 590 if (!num_rsp)
591 return;
592
1da177e4 593 hci_dev_lock(hdev);
45bb4bf0
MH		 594
595 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
596 struct inquiry_info_with_rssi_and_pscan_mode *info =
597 (struct inquiry_info_with_rssi_and_pscan_mode *) (skb->data + 1);
598
599 for (; num_rsp; num_rsp--) {
600 bacpy(&data.bdaddr, &info->bdaddr);
601 data.pscan_rep_mode = info->pscan_rep_mode;
602 data.pscan_period_mode = info->pscan_period_mode;
603 data.pscan_mode = info->pscan_mode;
604 memcpy(data.dev_class, info->dev_class, 3);
605 data.clock_offset = info->clock_offset;
606 data.rssi = info->rssi;
607 info++;
608 hci_inquiry_cache_update(hdev, &data);
609 }
610 } else {
611 struct inquiry_info_with_rssi *info =
612 (struct inquiry_info_with_rssi *) (skb->data + 1);
613
614 for (; num_rsp; num_rsp--) {
615 bacpy(&data.bdaddr, &info->bdaddr);
616 data.pscan_rep_mode = info->pscan_rep_mode;
617 data.pscan_period_mode = info->pscan_period_mode;
618 data.pscan_mode = 0x00;
619 memcpy(data.dev_class, info->dev_class, 3);
620 data.clock_offset = info->clock_offset;
621 data.rssi = info->rssi;
622 info++;
623 hci_inquiry_cache_update(hdev, &data);
624 }
1da177e4 625 }
45bb4bf0 626
1da177e4
LT		 627 hci_dev_unlock(hdev);
628}
629
21d9e30e
MH		 630/* Extended Inquiry Result */
631static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
632{
633 struct inquiry_data data;
634 struct extended_inquiry_info *info = (struct extended_inquiry_info *) (skb->data + 1);
635 int num_rsp = *((__u8 *) skb->data);
636
637 BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
638
639 if (!num_rsp)
640 return;
641
642 hci_dev_lock(hdev);
643
644 for (; num_rsp; num_rsp--) {
645 bacpy(&data.bdaddr, &info->bdaddr);
646 data.pscan_rep_mode = info->pscan_rep_mode;
647 data.pscan_period_mode = info->pscan_period_mode;
648 data.pscan_mode = 0x00;
649 memcpy(data.dev_class, info->dev_class, 3);
650 data.clock_offset = info->clock_offset;
651 data.rssi = info->rssi;
652 info++;
653 hci_inquiry_cache_update(hdev, &data);
654 }
655
656 hci_dev_unlock(hdev);
657}
658
1da177e4
LT		 659/* Connect Request */
660static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
661{
662 struct hci_ev_conn_request *ev = (struct hci_ev_conn_request *) skb->data;
663 int mask = hdev->link_mode;
664
665 BT_DBG("%s Connection request: %s type 0x%x", hdev->name,
666 batostr(&ev->bdaddr), ev->link_type);
667
668 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
669
670 if (mask & HCI_LM_ACCEPT) {
671 /* Connection accepted */
672 struct hci_conn *conn;
673 struct hci_cp_accept_conn_req cp;
674
675 hci_dev_lock(hdev);
676 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
677 if (!conn) {
678 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
679 BT_ERR("No memmory for new connection");
680 hci_dev_unlock(hdev);
681 return;
682 }
683 }
684 memcpy(conn->dev_class, ev->dev_class, 3);
685 conn->state = BT_CONNECT;
686 hci_dev_unlock(hdev);
687
688 bacpy(&cp.bdaddr, &ev->bdaddr);
689
690 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
691 cp.role = 0x00; /* Become master */
692 else
693 cp.role = 0x01; /* Remain slave */
694
04837f64
MH		 695 hci_send_cmd(hdev, OGF_LINK_CTL,
696 OCF_ACCEPT_CONN_REQ, sizeof(cp), &cp);
1da177e4
LT		 697 } else {
698 /* Connection rejected */
699 struct hci_cp_reject_conn_req cp;
700
701 bacpy(&cp.bdaddr, &ev->bdaddr);
702 cp.reason = 0x0f;
04837f64
MH		 703 hci_send_cmd(hdev, OGF_LINK_CTL,
704 OCF_REJECT_CONN_REQ, sizeof(cp), &cp);
1da177e4
LT		 705 }
706}
707
708/* Connect Complete */
709static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
710{
711 struct hci_ev_conn_complete *ev = (struct hci_ev_conn_complete *) skb->data;
04837f64 712 struct hci_conn *conn;
1da177e4
LT		 713
714 BT_DBG("%s", hdev->name);
715
716 hci_dev_lock(hdev);
717
718 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
719 if (!conn) {
720 hci_dev_unlock(hdev);
721 return;
722 }
723
724 if (!ev->status) {
725 conn->handle = __le16_to_cpu(ev->handle);
726 conn->state = BT_CONNECTED;
727
728 if (test_bit(HCI_AUTH, &hdev->flags))
729 conn->link_mode |= HCI_LM_AUTH;
730
731 if (test_bit(HCI_ENCRYPT, &hdev->flags))
732 conn->link_mode |= HCI_LM_ENCRYPT;
733
04837f64
MH		 734 /* Get remote features */
735 if (conn->type == ACL_LINK) {
736 struct hci_cp_read_remote_features cp;
737 cp.handle = ev->handle;
738 hci_send_cmd(hdev, OGF_LINK_CTL,
739 OCF_READ_REMOTE_FEATURES, sizeof(cp), &cp);
740 }
741
1da177e4
LT		 742 /* Set link policy */
743 if (conn->type == ACL_LINK && hdev->link_policy) {
744 struct hci_cp_write_link_policy cp;
745 cp.handle = ev->handle;
746 cp.policy = __cpu_to_le16(hdev->link_policy);
04837f64
MH		 747 hci_send_cmd(hdev, OGF_LINK_POLICY,
748 OCF_WRITE_LINK_POLICY, sizeof(cp), &cp);
1da177e4
LT		 749 }
750
751 /* Set packet type for incoming connection */
752 if (!conn->out) {
753 struct hci_cp_change_conn_ptype cp;
754 cp.handle = ev->handle;
755 cp.pkt_type = (conn->type == ACL_LINK) ?
756 __cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK):
757 __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
758
04837f64
MH		 759 hci_send_cmd(hdev, OGF_LINK_CTL,
760 OCF_CHANGE_CONN_PTYPE, sizeof(cp), &cp);
1da177e4
LT		 761 }
762 } else
763 conn->state = BT_CLOSED;
764
765 if (conn->type == ACL_LINK) {
766 struct hci_conn *sco = conn->link;
767 if (sco) {
768 if (!ev->status)
769 hci_add_sco(sco, conn->handle);
770 else {
771 hci_proto_connect_cfm(sco, ev->status);
772 hci_conn_del(sco);
773 }
774 }
775 }
776
777 hci_proto_connect_cfm(conn, ev->status);
778 if (ev->status)
779 hci_conn_del(conn);
780
781 hci_dev_unlock(hdev);
782}
783
784/* Disconnect Complete */
785static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
786{
787 struct hci_ev_disconn_complete *ev = (struct hci_ev_disconn_complete *) skb->data;
04837f64 788 struct hci_conn *conn;
1da177e4
LT		 789
790 BT_DBG("%s status %d", hdev->name, ev->status);
791
792 if (ev->status)
793 return;
794
795 hci_dev_lock(hdev);
796
04837f64 797 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 798 if (conn) {
799 conn->state = BT_CLOSED;
800 hci_proto_disconn_ind(conn, ev->reason);
801 hci_conn_del(conn);
802 }
803
804 hci_dev_unlock(hdev);
805}
806
807/* Number of completed packets */
808static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
809{
810 struct hci_ev_num_comp_pkts *ev = (struct hci_ev_num_comp_pkts *) skb->data;
1ebb9252 811 __le16 *ptr;
1da177e4
LT		 812 int i;
813
814 skb_pull(skb, sizeof(*ev));
815
816 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
817
818 if (skb->len < ev->num_hndl * 4) {
819 BT_DBG("%s bad parameters", hdev->name);
820 return;
821 }
822
823 tasklet_disable(&hdev->tx_task);
824
1ebb9252 825 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1da177e4
LT		 826 struct hci_conn *conn;
827 __u16 handle, count;
828
829 handle = __le16_to_cpu(get_unaligned(ptr++));
830 count = __le16_to_cpu(get_unaligned(ptr++));
831
832 conn = hci_conn_hash_lookup_handle(hdev, handle);
833 if (conn) {
834 conn->sent -= count;
835
836 if (conn->type == SCO_LINK) {
837 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
838 hdev->sco_cnt = hdev->sco_pkts;
839 } else {
840 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
841 hdev->acl_cnt = hdev->acl_pkts;
842 }
843 }
844 }
845 hci_sched_tx(hdev);
846
847 tasklet_enable(&hdev->tx_task);
848}
849
850/* Role Change */
851static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
852{
853 struct hci_ev_role_change *ev = (struct hci_ev_role_change *) skb->data;
04837f64 854 struct hci_conn *conn;
1da177e4
LT		 855
856 BT_DBG("%s status %d", hdev->name, ev->status);
857
858 hci_dev_lock(hdev);
859
860 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
861 if (conn) {
862 if (!ev->status) {
863 if (ev->role)
864 conn->link_mode &= ~HCI_LM_MASTER;
865 else
866 conn->link_mode |= HCI_LM_MASTER;
867 }
868
869 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
870
871 hci_role_switch_cfm(conn, ev->status, ev->role);
872 }
873
874 hci_dev_unlock(hdev);
875}
876
04837f64
MH		 877/* Mode Change */
878static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
879{
880 struct hci_ev_mode_change *ev = (struct hci_ev_mode_change *) skb->data;
881 struct hci_conn *conn;
882
883 BT_DBG("%s status %d", hdev->name, ev->status);
884
885 hci_dev_lock(hdev);
886
887 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
888 if (conn) {
889 conn->mode = ev->mode;
890 conn->interval = __le16_to_cpu(ev->interval);
891
892 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
893 if (conn->mode == HCI_CM_ACTIVE)
894 conn->power_save = 1;
895 else
896 conn->power_save = 0;
897 }
898 }
899
900 hci_dev_unlock(hdev);
901}
902
1da177e4
LT		 903/* Authentication Complete */
904static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
905{
906 struct hci_ev_auth_complete *ev = (struct hci_ev_auth_complete *) skb->data;
04837f64 907 struct hci_conn *conn;
1da177e4
LT		 908
909 BT_DBG("%s status %d", hdev->name, ev->status);
910
911 hci_dev_lock(hdev);
912
04837f64 913 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 914 if (conn) {
915 if (!ev->status)
916 conn->link_mode |= HCI_LM_AUTH;
917
918 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
919
920 hci_auth_cfm(conn, ev->status);
921
922 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
923 if (!ev->status) {
924 struct hci_cp_set_conn_encrypt cp;
925 cp.handle = __cpu_to_le16(conn->handle);
926 cp.encrypt = 1;
927 hci_send_cmd(conn->hdev, OGF_LINK_CTL,
04837f64 928 OCF_SET_CONN_ENCRYPT, sizeof(cp), &cp);
1da177e4
LT		 929 } else {
930 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
931 hci_encrypt_cfm(conn, ev->status, 0x00);
932 }
933 }
934 }
935
936 hci_dev_unlock(hdev);
937}
938
939/* Encryption Change */
940static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
941{
942 struct hci_ev_encrypt_change *ev = (struct hci_ev_encrypt_change *) skb->data;
04837f64 943 struct hci_conn *conn;
1da177e4
LT		 944
945 BT_DBG("%s status %d", hdev->name, ev->status);
946
947 hci_dev_lock(hdev);
948
04837f64 949 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 950 if (conn) {
951 if (!ev->status) {
952 if (ev->encrypt)
953 conn->link_mode |= HCI_LM_ENCRYPT;
954 else
955 conn->link_mode &= ~HCI_LM_ENCRYPT;
956 }
957
958 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
959
960 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
961 }
962
963 hci_dev_unlock(hdev);
964}
965
966/* Change Connection Link Key Complete */
967static inline void hci_change_conn_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
968{
969 struct hci_ev_change_conn_link_key_complete *ev = (struct hci_ev_change_conn_link_key_complete *) skb->data;
04837f64 970 struct hci_conn *conn;
1da177e4
LT		 971
972 BT_DBG("%s status %d", hdev->name, ev->status);
973
974 hci_dev_lock(hdev);
975
04837f64 976 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 977 if (conn) {
978 if (!ev->status)
979 conn->link_mode |= HCI_LM_SECURE;
980
981 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
982
983 hci_key_change_cfm(conn, ev->status);
984 }
985
986 hci_dev_unlock(hdev);
987}
988
989/* Pin Code Request*/
990static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
991{
992}
993
994/* Link Key Request */
995static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
996{
997}
998
999/* Link Key Notification */
1000static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1001{
1002}
1003
04837f64
MH		 1004/* Remote Features */
1005static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1006{
1007 struct hci_ev_remote_features *ev = (struct hci_ev_remote_features *) skb->data;
1008 struct hci_conn *conn;
1009
1010 BT_DBG("%s status %d", hdev->name, ev->status);
1011
1012 hci_dev_lock(hdev);
1013
1014 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1015 if (conn && !ev->status) {
1016 memcpy(conn->features, ev->features, sizeof(conn->features));
1017 }
1018
1019 hci_dev_unlock(hdev);
1020}
1021
1da177e4
LT		 1022/* Clock Offset */
1023static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1024{
1025 struct hci_ev_clock_offset *ev = (struct hci_ev_clock_offset *) skb->data;
04837f64 1026 struct hci_conn *conn;
1da177e4
LT		 1027
1028 BT_DBG("%s status %d", hdev->name, ev->status);
1029
1030 hci_dev_lock(hdev);
1031
04837f64 1032 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1da177e4
LT		 1033 if (conn && !ev->status) {
1034 struct inquiry_entry *ie;
1035
1036 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1037 ie->data.clock_offset = ev->clock_offset;
1038 ie->timestamp = jiffies;
1039 }
1040 }
1041
1042 hci_dev_unlock(hdev);
1043}
1044
85a1e930
MH		 1045/* Page Scan Repetition Mode */
1046static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1047{
1048 struct hci_ev_pscan_rep_mode *ev = (struct hci_ev_pscan_rep_mode *) skb->data;
1049 struct inquiry_entry *ie;
1050
1051 BT_DBG("%s", hdev->name);
1052
1053 hci_dev_lock(hdev);
1054
1055 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1056 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1057 ie->timestamp = jiffies;
1058 }
1059
1060 hci_dev_unlock(hdev);
1061}
1062
04837f64
MH		 1063/* Sniff Subrate */
1064static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1065{
1066 struct hci_ev_sniff_subrate *ev = (struct hci_ev_sniff_subrate *) skb->data;
1067 struct hci_conn *conn;
1068
1069 BT_DBG("%s status %d", hdev->name, ev->status);
1070
1071 hci_dev_lock(hdev);
1072
1073 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1074 if (conn) {
1075 }
1076
1077 hci_dev_unlock(hdev);
1078}
1079
1da177e4
LT		 1080void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1081{
1082 struct hci_event_hdr *hdr = (struct hci_event_hdr *) skb->data;
1083 struct hci_ev_cmd_complete *ec;
1084 struct hci_ev_cmd_status *cs;
1085 u16 opcode, ocf, ogf;
1086
1087 skb_pull(skb, HCI_EVENT_HDR_SIZE);
1088
1089 BT_DBG("%s evt 0x%x", hdev->name, hdr->evt);
1090
1091 switch (hdr->evt) {
1092 case HCI_EV_NUM_COMP_PKTS:
1093 hci_num_comp_pkts_evt(hdev, skb);
1094 break;
1095
1096 case HCI_EV_INQUIRY_COMPLETE:
1097 hci_inquiry_complete_evt(hdev, skb);
1098 break;
1099
1100 case HCI_EV_INQUIRY_RESULT:
1101 hci_inquiry_result_evt(hdev, skb);
1102 break;
1103
1104 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1105 hci_inquiry_result_with_rssi_evt(hdev, skb);
1106 break;
1107
21d9e30e
MH		 1108 case HCI_EV_EXTENDED_INQUIRY_RESULT:
1109 hci_extended_inquiry_result_evt(hdev, skb);
1110 break;
1111
1da177e4
LT		 1112 case HCI_EV_CONN_REQUEST:
1113 hci_conn_request_evt(hdev, skb);
1114 break;
1115
1116 case HCI_EV_CONN_COMPLETE:
1117 hci_conn_complete_evt(hdev, skb);
1118 break;
1119
1120 case HCI_EV_DISCONN_COMPLETE:
1121 hci_disconn_complete_evt(hdev, skb);
1122 break;
1123
1124 case HCI_EV_ROLE_CHANGE:
1125 hci_role_change_evt(hdev, skb);
1126 break;
1127
04837f64
MH		 1128 case HCI_EV_MODE_CHANGE:
1129 hci_mode_change_evt(hdev, skb);
1130 break;
1131
1da177e4
LT		 1132 case HCI_EV_AUTH_COMPLETE:
1133 hci_auth_complete_evt(hdev, skb);
1134 break;
1135
1136 case HCI_EV_ENCRYPT_CHANGE:
1137 hci_encrypt_change_evt(hdev, skb);
1138 break;
1139
1140 case HCI_EV_CHANGE_CONN_LINK_KEY_COMPLETE:
1141 hci_change_conn_link_key_complete_evt(hdev, skb);
1142 break;
1143
1144 case HCI_EV_PIN_CODE_REQ:
1145 hci_pin_code_request_evt(hdev, skb);
1146 break;
1147
1148 case HCI_EV_LINK_KEY_REQ:
1149 hci_link_key_request_evt(hdev, skb);
1150 break;
1151
1152 case HCI_EV_LINK_KEY_NOTIFY:
1153 hci_link_key_notify_evt(hdev, skb);
1154 break;
1155
04837f64
MH		 1156 case HCI_EV_REMOTE_FEATURES:
1157 hci_remote_features_evt(hdev, skb);
1158 break;
1159
1da177e4
LT		 1160 case HCI_EV_CLOCK_OFFSET:
1161 hci_clock_offset_evt(hdev, skb);
1162 break;
1163
85a1e930
MH		 1164 case HCI_EV_PSCAN_REP_MODE:
1165 hci_pscan_rep_mode_evt(hdev, skb);
1166 break;
1167
04837f64
MH		 1168 case HCI_EV_SNIFF_SUBRATE:
1169 hci_sniff_subrate_evt(hdev, skb);
1170 break;
1171
1da177e4
LT		 1172 case HCI_EV_CMD_STATUS:
1173 cs = (struct hci_ev_cmd_status *) skb->data;
1174 skb_pull(skb, sizeof(cs));
1175
1176 opcode = __le16_to_cpu(cs->opcode);
1177 ogf = hci_opcode_ogf(opcode);
1178 ocf = hci_opcode_ocf(opcode);
1179
1180 switch (ogf) {
1181 case OGF_INFO_PARAM:
1182 hci_cs_info_param(hdev, ocf, cs->status);
1183 break;
1184
1185 case OGF_HOST_CTL:
1186 hci_cs_host_ctl(hdev, ocf, cs->status);
1187 break;
1188
1189 case OGF_LINK_CTL:
1190 hci_cs_link_ctl(hdev, ocf, cs->status);
1191 break;
1192
1193 case OGF_LINK_POLICY:
1194 hci_cs_link_policy(hdev, ocf, cs->status);
1195 break;
1196
1197 default:
1198 BT_DBG("%s Command Status OGF %x", hdev->name, ogf);
1199 break;
1200 }
1201
1202 if (cs->ncmd) {
1203 atomic_set(&hdev->cmd_cnt, 1);
1204 if (!skb_queue_empty(&hdev->cmd_q))
1205 hci_sched_cmd(hdev);
1206 }
1207 break;
1208
1209 case HCI_EV_CMD_COMPLETE:
1210 ec = (struct hci_ev_cmd_complete *) skb->data;
1211 skb_pull(skb, sizeof(*ec));
1212
1213 opcode = __le16_to_cpu(ec->opcode);
1214 ogf = hci_opcode_ogf(opcode);
1215 ocf = hci_opcode_ocf(opcode);
1216
1217 switch (ogf) {
1218 case OGF_INFO_PARAM:
1219 hci_cc_info_param(hdev, ocf, skb);
1220 break;
1221
1222 case OGF_HOST_CTL:
1223 hci_cc_host_ctl(hdev, ocf, skb);
1224 break;
1225
1226 case OGF_LINK_CTL:
1227 hci_cc_link_ctl(hdev, ocf, skb);
1228 break;
1229
1230 case OGF_LINK_POLICY:
1231 hci_cc_link_policy(hdev, ocf, skb);
1232 break;
1233
1234 default:
1235 BT_DBG("%s Command Completed OGF %x", hdev->name, ogf);
1236 break;
1237 }
1238
1239 if (ec->ncmd) {
1240 atomic_set(&hdev->cmd_cnt, 1);
1241 if (!skb_queue_empty(&hdev->cmd_q))
1242 hci_sched_cmd(hdev);
1243 }
1244 break;
1245 }
1246
1247 kfree_skb(skb);
1248 hdev->stat.evt_rx++;
1249}
1250
1251/* Generate internal stack event */
1252void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1253{
1254 struct hci_event_hdr *hdr;
1255 struct hci_ev_stack_internal *ev;
1256 struct sk_buff *skb;
1257
1258 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1259 if (!skb)
1260 return;
1261
1262 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1263 hdr->evt = HCI_EV_STACK_INTERNAL;
1264 hdr->plen = sizeof(*ev) + dlen;
1265
1266 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
1267 ev->type = type;
1268 memcpy(ev->data, data, dlen);
1269
576c7d85 1270 bt_cb(skb)->incoming = 1;
a61bbcf2 1271 __net_timestamp(skb);
576c7d85 1272
0d48d939 1273 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1da177e4
LT		 1274 skb->dev = (void *) hdev;
1275 hci_send_to_sock(hdev, skb);
1276 kfree_skb(skb);
1277}
kernel source for telekom puls (alcatel/mediatek)