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