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