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 } 1339