hci_event.c revision 41a96212b3b7b3cd59e8e8d33e6dabf0e21d9778
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 55static void hci_cc_inquiry_cancel(struct hci_dev *hdev, struct sk_buff *skb) 56{ 57 __u8 status = *((__u8 *) skb->data); 58 59 BT_DBG("%s status 0x%x", hdev->name, status); 60 61 if (status) 62 return; 63 64 clear_bit(HCI_INQUIRY, &hdev->flags); 65 66 hci_req_complete(hdev, status); 67 68 hci_conn_check_pending(hdev); 69} 70 71static void hci_cc_exit_periodic_inq(struct hci_dev *hdev, struct sk_buff *skb) 72{ 73 __u8 status = *((__u8 *) skb->data); 74 75 BT_DBG("%s status 0x%x", hdev->name, status); 76 77 if (status) 78 return; 79 80 clear_bit(HCI_INQUIRY, &hdev->flags); 81 82 hci_conn_check_pending(hdev); 83} 84 85static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb) 86{ 87 BT_DBG("%s", hdev->name); 88} 89 90static void hci_cc_role_discovery(struct hci_dev *hdev, struct sk_buff *skb) 91{ 92 struct hci_rp_role_discovery *rp = (void *) skb->data; 93 struct hci_conn *conn; 94 95 BT_DBG("%s status 0x%x", hdev->name, rp->status); 96 97 if (rp->status) 98 return; 99 100 hci_dev_lock(hdev); 101 102 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle)); 103 if (conn) { 104 if (rp->role) 105 conn->link_mode &= ~HCI_LM_MASTER; 106 else 107 conn->link_mode |= HCI_LM_MASTER; 108 } 109 110 hci_dev_unlock(hdev); 111} 112 113static void hci_cc_read_link_policy(struct hci_dev *hdev, struct sk_buff *skb) 114{ 115 struct hci_rp_read_link_policy *rp = (void *) skb->data; 116 struct hci_conn *conn; 117 118 BT_DBG("%s status 0x%x", hdev->name, rp->status); 119 120 if (rp->status) 121 return; 122 123 hci_dev_lock(hdev); 124 125 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle)); 126 if (conn) 127 conn->link_policy = __le16_to_cpu(rp->policy); 128 129 hci_dev_unlock(hdev); 130} 131 132static void hci_cc_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb) 133{ 134 struct hci_rp_write_link_policy *rp = (void *) skb->data; 135 struct hci_conn *conn; 136 void *sent; 137 138 BT_DBG("%s status 0x%x", hdev->name, rp->status); 139 140 if (rp->status) 141 return; 142 143 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY); 144 if (!sent) 145 return; 146 147 hci_dev_lock(hdev); 148 149 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle)); 150 if (conn) 151 conn->link_policy = get_unaligned_le16(sent + 2); 152 153 hci_dev_unlock(hdev); 154} 155 156static void hci_cc_read_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb) 157{ 158 struct hci_rp_read_def_link_policy *rp = (void *) skb->data; 159 160 BT_DBG("%s status 0x%x", hdev->name, rp->status); 161 162 if (rp->status) 163 return; 164 165 hdev->link_policy = __le16_to_cpu(rp->policy); 166} 167 168static void hci_cc_write_def_link_policy(struct hci_dev *hdev, struct sk_buff *skb) 169{ 170 __u8 status = *((__u8 *) skb->data); 171 void *sent; 172 173 BT_DBG("%s status 0x%x", hdev->name, status); 174 175 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_DEF_LINK_POLICY); 176 if (!sent) 177 return; 178 179 if (!status) 180 hdev->link_policy = get_unaligned_le16(sent); 181 182 hci_req_complete(hdev, status); 183} 184 185static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb) 186{ 187 __u8 status = *((__u8 *) skb->data); 188 189 BT_DBG("%s status 0x%x", hdev->name, status); 190 191 hci_req_complete(hdev, status); 192} 193 194static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb) 195{ 196 __u8 status = *((__u8 *) skb->data); 197 void *sent; 198 199 BT_DBG("%s status 0x%x", hdev->name, status); 200 201 if (status) 202 return; 203 204 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME); 205 if (!sent) 206 return; 207 208 memcpy(hdev->dev_name, sent, 248); 209} 210 211static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb) 212{ 213 struct hci_rp_read_local_name *rp = (void *) skb->data; 214 215 BT_DBG("%s status 0x%x", hdev->name, rp->status); 216 217 if (rp->status) 218 return; 219 220 memcpy(hdev->dev_name, rp->name, 248); 221} 222 223static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb) 224{ 225 __u8 status = *((__u8 *) skb->data); 226 void *sent; 227 228 BT_DBG("%s status 0x%x", hdev->name, status); 229 230 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE); 231 if (!sent) 232 return; 233 234 if (!status) { 235 __u8 param = *((__u8 *) sent); 236 237 if (param == AUTH_ENABLED) 238 set_bit(HCI_AUTH, &hdev->flags); 239 else 240 clear_bit(HCI_AUTH, &hdev->flags); 241 } 242 243 hci_req_complete(hdev, status); 244} 245 246static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb) 247{ 248 __u8 status = *((__u8 *) skb->data); 249 void *sent; 250 251 BT_DBG("%s status 0x%x", hdev->name, status); 252 253 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE); 254 if (!sent) 255 return; 256 257 if (!status) { 258 __u8 param = *((__u8 *) sent); 259 260 if (param) 261 set_bit(HCI_ENCRYPT, &hdev->flags); 262 else 263 clear_bit(HCI_ENCRYPT, &hdev->flags); 264 } 265 266 hci_req_complete(hdev, status); 267} 268 269static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb) 270{ 271 __u8 status = *((__u8 *) skb->data); 272 void *sent; 273 274 BT_DBG("%s status 0x%x", hdev->name, status); 275 276 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE); 277 if (!sent) 278 return; 279 280 if (!status) { 281 __u8 param = *((__u8 *) sent); 282 283 clear_bit(HCI_PSCAN, &hdev->flags); 284 clear_bit(HCI_ISCAN, &hdev->flags); 285 286 if (param & SCAN_INQUIRY) 287 set_bit(HCI_ISCAN, &hdev->flags); 288 289 if (param & SCAN_PAGE) 290 set_bit(HCI_PSCAN, &hdev->flags); 291 } 292 293 hci_req_complete(hdev, status); 294} 295 296static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb) 297{ 298 struct hci_rp_read_class_of_dev *rp = (void *) skb->data; 299 300 BT_DBG("%s status 0x%x", hdev->name, rp->status); 301 302 if (rp->status) 303 return; 304 305 memcpy(hdev->dev_class, rp->dev_class, 3); 306 307 BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name, 308 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]); 309} 310 311static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb) 312{ 313 __u8 status = *((__u8 *) skb->data); 314 void *sent; 315 316 BT_DBG("%s status 0x%x", hdev->name, status); 317 318 if (status) 319 return; 320 321 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV); 322 if (!sent) 323 return; 324 325 memcpy(hdev->dev_class, sent, 3); 326} 327 328static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb) 329{ 330 struct hci_rp_read_voice_setting *rp = (void *) skb->data; 331 __u16 setting; 332 333 BT_DBG("%s status 0x%x", hdev->name, rp->status); 334 335 if (rp->status) 336 return; 337 338 setting = __le16_to_cpu(rp->voice_setting); 339 340 if (hdev->voice_setting == setting) 341 return; 342 343 hdev->voice_setting = setting; 344 345 BT_DBG("%s voice setting 0x%04x", hdev->name, setting); 346 347 if (hdev->notify) { 348 tasklet_disable(&hdev->tx_task); 349 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING); 350 tasklet_enable(&hdev->tx_task); 351 } 352} 353 354static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb) 355{ 356 __u8 status = *((__u8 *) skb->data); 357 __u16 setting; 358 void *sent; 359 360 BT_DBG("%s status 0x%x", hdev->name, status); 361 362 if (status) 363 return; 364 365 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING); 366 if (!sent) 367 return; 368 369 setting = get_unaligned_le16(sent); 370 371 if (hdev->voice_setting == setting) 372 return; 373 374 hdev->voice_setting = setting; 375 376 BT_DBG("%s voice setting 0x%04x", hdev->name, setting); 377 378 if (hdev->notify) { 379 tasklet_disable(&hdev->tx_task); 380 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING); 381 tasklet_enable(&hdev->tx_task); 382 } 383} 384 385static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb) 386{ 387 __u8 status = *((__u8 *) skb->data); 388 389 BT_DBG("%s status 0x%x", hdev->name, status); 390 391 hci_req_complete(hdev, status); 392} 393 394static void hci_cc_read_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb) 395{ 396 struct hci_rp_read_ssp_mode *rp = (void *) skb->data; 397 398 BT_DBG("%s status 0x%x", hdev->name, rp->status); 399 400 if (rp->status) 401 return; 402 403 hdev->ssp_mode = rp->mode; 404} 405 406static void hci_cc_write_ssp_mode(struct hci_dev *hdev, struct sk_buff *skb) 407{ 408 __u8 status = *((__u8 *) skb->data); 409 void *sent; 410 411 BT_DBG("%s status 0x%x", hdev->name, status); 412 413 if (status) 414 return; 415 416 sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SSP_MODE); 417 if (!sent) 418 return; 419 420 hdev->ssp_mode = *((__u8 *) sent); 421} 422 423static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb) 424{ 425 struct hci_rp_read_local_version *rp = (void *) skb->data; 426 427 BT_DBG("%s status 0x%x", hdev->name, rp->status); 428 429 if (rp->status) 430 return; 431 432 hdev->hci_ver = rp->hci_ver; 433 hdev->hci_rev = __le16_to_cpu(rp->hci_rev); 434 hdev->manufacturer = __le16_to_cpu(rp->manufacturer); 435 436 BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name, 437 hdev->manufacturer, 438 hdev->hci_ver, hdev->hci_rev); 439} 440 441static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb) 442{ 443 struct hci_rp_read_local_commands *rp = (void *) skb->data; 444 445 BT_DBG("%s status 0x%x", hdev->name, rp->status); 446 447 if (rp->status) 448 return; 449 450 memcpy(hdev->commands, rp->commands, sizeof(hdev->commands)); 451} 452 453static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb) 454{ 455 struct hci_rp_read_local_features *rp = (void *) skb->data; 456 457 BT_DBG("%s status 0x%x", hdev->name, rp->status); 458 459 if (rp->status) 460 return; 461 462 memcpy(hdev->features, rp->features, 8); 463 464 /* Adjust default settings according to features 465 * supported by device. */ 466 467 if (hdev->features[0] & LMP_3SLOT) 468 hdev->pkt_type |= (HCI_DM3 | HCI_DH3); 469 470 if (hdev->features[0] & LMP_5SLOT) 471 hdev->pkt_type |= (HCI_DM5 | HCI_DH5); 472 473 if (hdev->features[1] & LMP_HV2) { 474 hdev->pkt_type |= (HCI_HV2); 475 hdev->esco_type |= (ESCO_HV2); 476 } 477 478 if (hdev->features[1] & LMP_HV3) { 479 hdev->pkt_type |= (HCI_HV3); 480 hdev->esco_type |= (ESCO_HV3); 481 } 482 483 if (hdev->features[3] & LMP_ESCO) 484 hdev->esco_type |= (ESCO_EV3); 485 486 if (hdev->features[4] & LMP_EV4) 487 hdev->esco_type |= (ESCO_EV4); 488 489 if (hdev->features[4] & LMP_EV5) 490 hdev->esco_type |= (ESCO_EV5); 491 492 BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name, 493 hdev->features[0], hdev->features[1], 494 hdev->features[2], hdev->features[3], 495 hdev->features[4], hdev->features[5], 496 hdev->features[6], hdev->features[7]); 497} 498 499static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb) 500{ 501 struct hci_rp_read_buffer_size *rp = (void *) skb->data; 502 503 BT_DBG("%s status 0x%x", hdev->name, rp->status); 504 505 if (rp->status) 506 return; 507 508 hdev->acl_mtu = __le16_to_cpu(rp->acl_mtu); 509 hdev->sco_mtu = rp->sco_mtu; 510 hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt); 511 hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt); 512 513 if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) { 514 hdev->sco_mtu = 64; 515 hdev->sco_pkts = 8; 516 } 517 518 hdev->acl_cnt = hdev->acl_pkts; 519 hdev->sco_cnt = hdev->sco_pkts; 520 521 BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name, 522 hdev->acl_mtu, hdev->acl_pkts, 523 hdev->sco_mtu, hdev->sco_pkts); 524} 525 526static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb) 527{ 528 struct hci_rp_read_bd_addr *rp = (void *) skb->data; 529 530 BT_DBG("%s status 0x%x", hdev->name, rp->status); 531 532 if (!rp->status) 533 bacpy(&hdev->bdaddr, &rp->bdaddr); 534 535 hci_req_complete(hdev, rp->status); 536} 537 538static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status) 539{ 540 BT_DBG("%s status 0x%x", hdev->name, status); 541 542 if (status) { 543 hci_req_complete(hdev, status); 544 545 hci_conn_check_pending(hdev); 546 } else 547 set_bit(HCI_INQUIRY, &hdev->flags); 548} 549 550static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status) 551{ 552 struct hci_cp_create_conn *cp; 553 struct hci_conn *conn; 554 555 BT_DBG("%s status 0x%x", hdev->name, status); 556 557 cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN); 558 if (!cp) 559 return; 560 561 hci_dev_lock(hdev); 562 563 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr); 564 565 BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn); 566 567 if (status) { 568 if (conn && conn->state == BT_CONNECT) { 569 if (status != 0x0c || conn->attempt > 2) { 570 conn->state = BT_CLOSED; 571 hci_proto_connect_cfm(conn, status); 572 hci_conn_del(conn); 573 } else 574 conn->state = BT_CONNECT2; 575 } 576 } else { 577 if (!conn) { 578 conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr); 579 if (conn) { 580 conn->out = 1; 581 conn->link_mode |= HCI_LM_MASTER; 582 } else 583 BT_ERR("No memmory for new connection"); 584 } 585 } 586 587 hci_dev_unlock(hdev); 588} 589 590static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status) 591{ 592 struct hci_cp_add_sco *cp; 593 struct hci_conn *acl, *sco; 594 __u16 handle; 595 596 BT_DBG("%s status 0x%x", hdev->name, status); 597 598 if (!status) 599 return; 600 601 cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO); 602 if (!cp) 603 return; 604 605 handle = __le16_to_cpu(cp->handle); 606 607 BT_DBG("%s handle %d", hdev->name, handle); 608 609 hci_dev_lock(hdev); 610 611 acl = hci_conn_hash_lookup_handle(hdev, handle); 612 if (acl && (sco = acl->link)) { 613 sco->state = BT_CLOSED; 614 615 hci_proto_connect_cfm(sco, status); 616 hci_conn_del(sco); 617 } 618 619 hci_dev_unlock(hdev); 620} 621 622static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status) 623{ 624 BT_DBG("%s status 0x%x", hdev->name, status); 625} 626 627static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status) 628{ 629 struct hci_cp_setup_sync_conn *cp; 630 struct hci_conn *acl, *sco; 631 __u16 handle; 632 633 BT_DBG("%s status 0x%x", hdev->name, status); 634 635 if (!status) 636 return; 637 638 cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN); 639 if (!cp) 640 return; 641 642 handle = __le16_to_cpu(cp->handle); 643 644 BT_DBG("%s handle %d", hdev->name, handle); 645 646 hci_dev_lock(hdev); 647 648 acl = hci_conn_hash_lookup_handle(hdev, handle); 649 if (acl && (sco = acl->link)) { 650 sco->state = BT_CLOSED; 651 652 hci_proto_connect_cfm(sco, status); 653 hci_conn_del(sco); 654 } 655 656 hci_dev_unlock(hdev); 657} 658 659static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status) 660{ 661 struct hci_cp_sniff_mode *cp; 662 struct hci_conn *conn; 663 664 BT_DBG("%s status 0x%x", hdev->name, status); 665 666 if (!status) 667 return; 668 669 cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE); 670 if (!cp) 671 return; 672 673 hci_dev_lock(hdev); 674 675 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle)); 676 if (conn) 677 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend); 678 679 hci_dev_unlock(hdev); 680} 681 682static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status) 683{ 684 struct hci_cp_exit_sniff_mode *cp; 685 struct hci_conn *conn; 686 687 BT_DBG("%s status 0x%x", hdev->name, status); 688 689 if (!status) 690 return; 691 692 cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE); 693 if (!cp) 694 return; 695 696 hci_dev_lock(hdev); 697 698 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle)); 699 if (conn) 700 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend); 701 702 hci_dev_unlock(hdev); 703} 704 705static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 706{ 707 __u8 status = *((__u8 *) skb->data); 708 709 BT_DBG("%s status %d", hdev->name, status); 710 711 clear_bit(HCI_INQUIRY, &hdev->flags); 712 713 hci_req_complete(hdev, status); 714 715 hci_conn_check_pending(hdev); 716} 717 718static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb) 719{ 720 struct inquiry_data data; 721 struct inquiry_info *info = (void *) (skb->data + 1); 722 int num_rsp = *((__u8 *) skb->data); 723 724 BT_DBG("%s num_rsp %d", hdev->name, num_rsp); 725 726 if (!num_rsp) 727 return; 728 729 hci_dev_lock(hdev); 730 731 for (; num_rsp; num_rsp--) { 732 bacpy(&data.bdaddr, &info->bdaddr); 733 data.pscan_rep_mode = info->pscan_rep_mode; 734 data.pscan_period_mode = info->pscan_period_mode; 735 data.pscan_mode = info->pscan_mode; 736 memcpy(data.dev_class, info->dev_class, 3); 737 data.clock_offset = info->clock_offset; 738 data.rssi = 0x00; 739 data.ssp_mode = 0x00; 740 info++; 741 hci_inquiry_cache_update(hdev, &data); 742 } 743 744 hci_dev_unlock(hdev); 745} 746 747static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 748{ 749 struct hci_ev_conn_complete *ev = (void *) skb->data; 750 struct hci_conn *conn; 751 752 BT_DBG("%s", hdev->name); 753 754 hci_dev_lock(hdev); 755 756 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr); 757 if (!conn) 758 goto unlock; 759 760 if (!ev->status) { 761 conn->handle = __le16_to_cpu(ev->handle); 762 conn->state = BT_CONNECTED; 763 764 if (test_bit(HCI_AUTH, &hdev->flags)) 765 conn->link_mode |= HCI_LM_AUTH; 766 767 if (test_bit(HCI_ENCRYPT, &hdev->flags)) 768 conn->link_mode |= HCI_LM_ENCRYPT; 769 770 /* Get remote features */ 771 if (conn->type == ACL_LINK) { 772 struct hci_cp_read_remote_features cp; 773 cp.handle = ev->handle; 774 hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES, sizeof(cp), &cp); 775 } 776 777 /* Set packet type for incoming connection */ 778 if (!conn->out && hdev->hci_ver < 3) { 779 struct hci_cp_change_conn_ptype cp; 780 cp.handle = ev->handle; 781 cp.pkt_type = cpu_to_le16(conn->pkt_type); 782 hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE, 783 sizeof(cp), &cp); 784 } else { 785 /* Update disconnect timer */ 786 hci_conn_hold(conn); 787 hci_conn_put(conn); 788 } 789 } else 790 conn->state = BT_CLOSED; 791 792 if (conn->type == ACL_LINK) { 793 struct hci_conn *sco = conn->link; 794 if (sco) { 795 if (!ev->status) { 796 if (lmp_esco_capable(hdev)) 797 hci_setup_sync(sco, conn->handle); 798 else 799 hci_add_sco(sco, conn->handle); 800 } else { 801 hci_proto_connect_cfm(sco, ev->status); 802 hci_conn_del(sco); 803 } 804 } 805 } 806 807 hci_proto_connect_cfm(conn, ev->status); 808 if (ev->status) 809 hci_conn_del(conn); 810 811unlock: 812 hci_dev_unlock(hdev); 813 814 hci_conn_check_pending(hdev); 815} 816 817static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb) 818{ 819 struct hci_ev_conn_request *ev = (void *) skb->data; 820 int mask = hdev->link_mode; 821 822 BT_DBG("%s bdaddr %s type 0x%x", hdev->name, 823 batostr(&ev->bdaddr), ev->link_type); 824 825 mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type); 826 827 if (mask & HCI_LM_ACCEPT) { 828 /* Connection accepted */ 829 struct inquiry_entry *ie; 830 struct hci_conn *conn; 831 832 hci_dev_lock(hdev); 833 834 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) 835 memcpy(ie->data.dev_class, ev->dev_class, 3); 836 837 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr); 838 if (!conn) { 839 if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) { 840 BT_ERR("No memmory for new connection"); 841 hci_dev_unlock(hdev); 842 return; 843 } 844 } 845 846 memcpy(conn->dev_class, ev->dev_class, 3); 847 conn->state = BT_CONNECT; 848 849 hci_dev_unlock(hdev); 850 851 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) { 852 struct hci_cp_accept_conn_req cp; 853 854 bacpy(&cp.bdaddr, &ev->bdaddr); 855 856 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER)) 857 cp.role = 0x00; /* Become master */ 858 else 859 cp.role = 0x01; /* Remain slave */ 860 861 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, 862 sizeof(cp), &cp); 863 } else { 864 struct hci_cp_accept_sync_conn_req cp; 865 866 bacpy(&cp.bdaddr, &ev->bdaddr); 867 cp.pkt_type = cpu_to_le16(conn->pkt_type); 868 869 cp.tx_bandwidth = cpu_to_le32(0x00001f40); 870 cp.rx_bandwidth = cpu_to_le32(0x00001f40); 871 cp.max_latency = cpu_to_le16(0xffff); 872 cp.content_format = cpu_to_le16(hdev->voice_setting); 873 cp.retrans_effort = 0xff; 874 875 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ, 876 sizeof(cp), &cp); 877 } 878 } else { 879 /* Connection rejected */ 880 struct hci_cp_reject_conn_req cp; 881 882 bacpy(&cp.bdaddr, &ev->bdaddr); 883 cp.reason = 0x0f; 884 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp); 885 } 886} 887 888static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 889{ 890 struct hci_ev_disconn_complete *ev = (void *) skb->data; 891 struct hci_conn *conn; 892 893 BT_DBG("%s status %d", hdev->name, ev->status); 894 895 if (ev->status) 896 return; 897 898 hci_dev_lock(hdev); 899 900 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 901 if (conn) { 902 conn->state = BT_CLOSED; 903 hci_proto_disconn_ind(conn, ev->reason); 904 hci_conn_del(conn); 905 } 906 907 hci_dev_unlock(hdev); 908} 909 910static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 911{ 912 struct hci_ev_auth_complete *ev = (void *) skb->data; 913 struct hci_conn *conn; 914 915 BT_DBG("%s status %d", hdev->name, ev->status); 916 917 hci_dev_lock(hdev); 918 919 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 920 if (conn) { 921 if (!ev->status) 922 conn->link_mode |= HCI_LM_AUTH; 923 924 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend); 925 926 hci_auth_cfm(conn, ev->status); 927 928 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) { 929 if (!ev->status) { 930 struct hci_cp_set_conn_encrypt cp; 931 cp.handle = cpu_to_le16(conn->handle); 932 cp.encrypt = 1; 933 hci_send_cmd(conn->hdev, 934 HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp); 935 } else { 936 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend); 937 hci_encrypt_cfm(conn, ev->status, 0x00); 938 } 939 } 940 } 941 942 hci_dev_unlock(hdev); 943} 944 945static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb) 946{ 947 BT_DBG("%s", hdev->name); 948 949 hci_conn_check_pending(hdev); 950} 951 952static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb) 953{ 954 struct hci_ev_encrypt_change *ev = (void *) skb->data; 955 struct hci_conn *conn; 956 957 BT_DBG("%s status %d", hdev->name, ev->status); 958 959 hci_dev_lock(hdev); 960 961 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 962 if (conn) { 963 if (!ev->status) { 964 if (ev->encrypt) { 965 /* Encryption implies authentication */ 966 conn->link_mode |= HCI_LM_AUTH; 967 conn->link_mode |= HCI_LM_ENCRYPT; 968 } else 969 conn->link_mode &= ~HCI_LM_ENCRYPT; 970 } 971 972 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend); 973 974 hci_encrypt_cfm(conn, ev->status, ev->encrypt); 975 } 976 977 hci_dev_unlock(hdev); 978} 979 980static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 981{ 982 struct hci_ev_change_link_key_complete *ev = (void *) skb->data; 983 struct hci_conn *conn; 984 985 BT_DBG("%s status %d", hdev->name, ev->status); 986 987 hci_dev_lock(hdev); 988 989 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 990 if (conn) { 991 if (!ev->status) 992 conn->link_mode |= HCI_LM_SECURE; 993 994 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend); 995 996 hci_key_change_cfm(conn, ev->status); 997 } 998 999 hci_dev_unlock(hdev); 1000} 1001 1002static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb) 1003{ 1004 struct hci_ev_remote_features *ev = (void *) skb->data; 1005 struct hci_conn *conn; 1006 1007 BT_DBG("%s status %d", hdev->name, ev->status); 1008 1009 if (ev->status) 1010 return; 1011 1012 hci_dev_lock(hdev); 1013 1014 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 1015 if (conn) 1016 memcpy(conn->features, ev->features, 8); 1017 1018 hci_dev_unlock(hdev); 1019} 1020 1021static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb) 1022{ 1023 BT_DBG("%s", hdev->name); 1024} 1025 1026static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 1027{ 1028 BT_DBG("%s", hdev->name); 1029} 1030 1031static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 1032{ 1033 struct hci_ev_cmd_complete *ev = (void *) skb->data; 1034 __u16 opcode; 1035 1036 skb_pull(skb, sizeof(*ev)); 1037 1038 opcode = __le16_to_cpu(ev->opcode); 1039 1040 switch (opcode) { 1041 case HCI_OP_INQUIRY_CANCEL: 1042 hci_cc_inquiry_cancel(hdev, skb); 1043 break; 1044 1045 case HCI_OP_EXIT_PERIODIC_INQ: 1046 hci_cc_exit_periodic_inq(hdev, skb); 1047 break; 1048 1049 case HCI_OP_REMOTE_NAME_REQ_CANCEL: 1050 hci_cc_remote_name_req_cancel(hdev, skb); 1051 break; 1052 1053 case HCI_OP_ROLE_DISCOVERY: 1054 hci_cc_role_discovery(hdev, skb); 1055 break; 1056 1057 case HCI_OP_READ_LINK_POLICY: 1058 hci_cc_read_link_policy(hdev, skb); 1059 break; 1060 1061 case HCI_OP_WRITE_LINK_POLICY: 1062 hci_cc_write_link_policy(hdev, skb); 1063 break; 1064 1065 case HCI_OP_READ_DEF_LINK_POLICY: 1066 hci_cc_read_def_link_policy(hdev, skb); 1067 break; 1068 1069 case HCI_OP_WRITE_DEF_LINK_POLICY: 1070 hci_cc_write_def_link_policy(hdev, skb); 1071 break; 1072 1073 case HCI_OP_RESET: 1074 hci_cc_reset(hdev, skb); 1075 break; 1076 1077 case HCI_OP_WRITE_LOCAL_NAME: 1078 hci_cc_write_local_name(hdev, skb); 1079 break; 1080 1081 case HCI_OP_READ_LOCAL_NAME: 1082 hci_cc_read_local_name(hdev, skb); 1083 break; 1084 1085 case HCI_OP_WRITE_AUTH_ENABLE: 1086 hci_cc_write_auth_enable(hdev, skb); 1087 break; 1088 1089 case HCI_OP_WRITE_ENCRYPT_MODE: 1090 hci_cc_write_encrypt_mode(hdev, skb); 1091 break; 1092 1093 case HCI_OP_WRITE_SCAN_ENABLE: 1094 hci_cc_write_scan_enable(hdev, skb); 1095 break; 1096 1097 case HCI_OP_READ_CLASS_OF_DEV: 1098 hci_cc_read_class_of_dev(hdev, skb); 1099 break; 1100 1101 case HCI_OP_WRITE_CLASS_OF_DEV: 1102 hci_cc_write_class_of_dev(hdev, skb); 1103 break; 1104 1105 case HCI_OP_READ_VOICE_SETTING: 1106 hci_cc_read_voice_setting(hdev, skb); 1107 break; 1108 1109 case HCI_OP_WRITE_VOICE_SETTING: 1110 hci_cc_write_voice_setting(hdev, skb); 1111 break; 1112 1113 case HCI_OP_HOST_BUFFER_SIZE: 1114 hci_cc_host_buffer_size(hdev, skb); 1115 break; 1116 1117 case HCI_OP_READ_SSP_MODE: 1118 hci_cc_read_ssp_mode(hdev, skb); 1119 break; 1120 1121 case HCI_OP_WRITE_SSP_MODE: 1122 hci_cc_write_ssp_mode(hdev, skb); 1123 break; 1124 1125 case HCI_OP_READ_LOCAL_VERSION: 1126 hci_cc_read_local_version(hdev, skb); 1127 break; 1128 1129 case HCI_OP_READ_LOCAL_COMMANDS: 1130 hci_cc_read_local_commands(hdev, skb); 1131 break; 1132 1133 case HCI_OP_READ_LOCAL_FEATURES: 1134 hci_cc_read_local_features(hdev, skb); 1135 break; 1136 1137 case HCI_OP_READ_BUFFER_SIZE: 1138 hci_cc_read_buffer_size(hdev, skb); 1139 break; 1140 1141 case HCI_OP_READ_BD_ADDR: 1142 hci_cc_read_bd_addr(hdev, skb); 1143 break; 1144 1145 default: 1146 BT_DBG("%s opcode 0x%x", hdev->name, opcode); 1147 break; 1148 } 1149 1150 if (ev->ncmd) { 1151 atomic_set(&hdev->cmd_cnt, 1); 1152 if (!skb_queue_empty(&hdev->cmd_q)) 1153 hci_sched_cmd(hdev); 1154 } 1155} 1156 1157static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb) 1158{ 1159 struct hci_ev_cmd_status *ev = (void *) skb->data; 1160 __u16 opcode; 1161 1162 skb_pull(skb, sizeof(*ev)); 1163 1164 opcode = __le16_to_cpu(ev->opcode); 1165 1166 switch (opcode) { 1167 case HCI_OP_INQUIRY: 1168 hci_cs_inquiry(hdev, ev->status); 1169 break; 1170 1171 case HCI_OP_CREATE_CONN: 1172 hci_cs_create_conn(hdev, ev->status); 1173 break; 1174 1175 case HCI_OP_ADD_SCO: 1176 hci_cs_add_sco(hdev, ev->status); 1177 break; 1178 1179 case HCI_OP_REMOTE_NAME_REQ: 1180 hci_cs_remote_name_req(hdev, ev->status); 1181 break; 1182 1183 case HCI_OP_SETUP_SYNC_CONN: 1184 hci_cs_setup_sync_conn(hdev, ev->status); 1185 break; 1186 1187 case HCI_OP_SNIFF_MODE: 1188 hci_cs_sniff_mode(hdev, ev->status); 1189 break; 1190 1191 case HCI_OP_EXIT_SNIFF_MODE: 1192 hci_cs_exit_sniff_mode(hdev, ev->status); 1193 break; 1194 1195 default: 1196 BT_DBG("%s opcode 0x%x", hdev->name, opcode); 1197 break; 1198 } 1199 1200 if (ev->ncmd) { 1201 atomic_set(&hdev->cmd_cnt, 1); 1202 if (!skb_queue_empty(&hdev->cmd_q)) 1203 hci_sched_cmd(hdev); 1204 } 1205} 1206 1207static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb) 1208{ 1209 struct hci_ev_role_change *ev = (void *) skb->data; 1210 struct hci_conn *conn; 1211 1212 BT_DBG("%s status %d", hdev->name, ev->status); 1213 1214 hci_dev_lock(hdev); 1215 1216 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr); 1217 if (conn) { 1218 if (!ev->status) { 1219 if (ev->role) 1220 conn->link_mode &= ~HCI_LM_MASTER; 1221 else 1222 conn->link_mode |= HCI_LM_MASTER; 1223 } 1224 1225 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend); 1226 1227 hci_role_switch_cfm(conn, ev->status, ev->role); 1228 } 1229 1230 hci_dev_unlock(hdev); 1231} 1232 1233static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb) 1234{ 1235 struct hci_ev_num_comp_pkts *ev = (void *) skb->data; 1236 __le16 *ptr; 1237 int i; 1238 1239 skb_pull(skb, sizeof(*ev)); 1240 1241 BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl); 1242 1243 if (skb->len < ev->num_hndl * 4) { 1244 BT_DBG("%s bad parameters", hdev->name); 1245 return; 1246 } 1247 1248 tasklet_disable(&hdev->tx_task); 1249 1250 for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) { 1251 struct hci_conn *conn; 1252 __u16 handle, count; 1253 1254 handle = get_unaligned_le16(ptr++); 1255 count = get_unaligned_le16(ptr++); 1256 1257 conn = hci_conn_hash_lookup_handle(hdev, handle); 1258 if (conn) { 1259 conn->sent -= count; 1260 1261 if (conn->type == ACL_LINK) { 1262 if ((hdev->acl_cnt += count) > hdev->acl_pkts) 1263 hdev->acl_cnt = hdev->acl_pkts; 1264 } else { 1265 if ((hdev->sco_cnt += count) > hdev->sco_pkts) 1266 hdev->sco_cnt = hdev->sco_pkts; 1267 } 1268 } 1269 } 1270 1271 hci_sched_tx(hdev); 1272 1273 tasklet_enable(&hdev->tx_task); 1274} 1275 1276static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb) 1277{ 1278 struct hci_ev_mode_change *ev = (void *) skb->data; 1279 struct hci_conn *conn; 1280 1281 BT_DBG("%s status %d", hdev->name, ev->status); 1282 1283 hci_dev_lock(hdev); 1284 1285 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 1286 if (conn) { 1287 conn->mode = ev->mode; 1288 conn->interval = __le16_to_cpu(ev->interval); 1289 1290 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) { 1291 if (conn->mode == HCI_CM_ACTIVE) 1292 conn->power_save = 1; 1293 else 1294 conn->power_save = 0; 1295 } 1296 } 1297 1298 hci_dev_unlock(hdev); 1299} 1300 1301static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb) 1302{ 1303 BT_DBG("%s", hdev->name); 1304} 1305 1306static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb) 1307{ 1308 BT_DBG("%s", hdev->name); 1309} 1310 1311static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb) 1312{ 1313 BT_DBG("%s", hdev->name); 1314} 1315 1316static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb) 1317{ 1318 struct hci_ev_clock_offset *ev = (void *) skb->data; 1319 struct hci_conn *conn; 1320 1321 BT_DBG("%s status %d", hdev->name, ev->status); 1322 1323 hci_dev_lock(hdev); 1324 1325 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 1326 if (conn && !ev->status) { 1327 struct inquiry_entry *ie; 1328 1329 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) { 1330 ie->data.clock_offset = ev->clock_offset; 1331 ie->timestamp = jiffies; 1332 } 1333 } 1334 1335 hci_dev_unlock(hdev); 1336} 1337 1338static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb) 1339{ 1340 struct hci_ev_pkt_type_change *ev = (void *) skb->data; 1341 struct hci_conn *conn; 1342 1343 BT_DBG("%s status %d", hdev->name, ev->status); 1344 1345 hci_dev_lock(hdev); 1346 1347 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 1348 if (conn && !ev->status) 1349 conn->pkt_type = __le16_to_cpu(ev->pkt_type); 1350 1351 hci_dev_unlock(hdev); 1352} 1353 1354static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb) 1355{ 1356 struct hci_ev_pscan_rep_mode *ev = (void *) skb->data; 1357 struct inquiry_entry *ie; 1358 1359 BT_DBG("%s", hdev->name); 1360 1361 hci_dev_lock(hdev); 1362 1363 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) { 1364 ie->data.pscan_rep_mode = ev->pscan_rep_mode; 1365 ie->timestamp = jiffies; 1366 } 1367 1368 hci_dev_unlock(hdev); 1369} 1370 1371static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb) 1372{ 1373 struct inquiry_data data; 1374 int num_rsp = *((__u8 *) skb->data); 1375 1376 BT_DBG("%s num_rsp %d", hdev->name, num_rsp); 1377 1378 if (!num_rsp) 1379 return; 1380 1381 hci_dev_lock(hdev); 1382 1383 if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) { 1384 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1); 1385 1386 for (; num_rsp; num_rsp--) { 1387 bacpy(&data.bdaddr, &info->bdaddr); 1388 data.pscan_rep_mode = info->pscan_rep_mode; 1389 data.pscan_period_mode = info->pscan_period_mode; 1390 data.pscan_mode = info->pscan_mode; 1391 memcpy(data.dev_class, info->dev_class, 3); 1392 data.clock_offset = info->clock_offset; 1393 data.rssi = info->rssi; 1394 data.ssp_mode = 0x00; 1395 info++; 1396 hci_inquiry_cache_update(hdev, &data); 1397 } 1398 } else { 1399 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1); 1400 1401 for (; num_rsp; num_rsp--) { 1402 bacpy(&data.bdaddr, &info->bdaddr); 1403 data.pscan_rep_mode = info->pscan_rep_mode; 1404 data.pscan_period_mode = info->pscan_period_mode; 1405 data.pscan_mode = 0x00; 1406 memcpy(data.dev_class, info->dev_class, 3); 1407 data.clock_offset = info->clock_offset; 1408 data.rssi = info->rssi; 1409 data.ssp_mode = 0x00; 1410 info++; 1411 hci_inquiry_cache_update(hdev, &data); 1412 } 1413 } 1414 1415 hci_dev_unlock(hdev); 1416} 1417 1418static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb) 1419{ 1420 struct hci_ev_remote_ext_features *ev = (void *) skb->data; 1421 struct hci_conn *conn; 1422 1423 BT_DBG("%s", hdev->name); 1424 1425 if (ev->status || ev->page != 0x01) 1426 return; 1427 1428 hci_dev_lock(hdev); 1429 1430 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 1431 if (conn) { 1432 struct inquiry_entry *ie; 1433 1434 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) 1435 ie->data.ssp_mode = (ev->features[0] & 0x01); 1436 1437 conn->ssp_mode = (ev->features[0] & 0x01); 1438 } 1439 1440 hci_dev_unlock(hdev); 1441} 1442 1443static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 1444{ 1445 struct hci_ev_sync_conn_complete *ev = (void *) skb->data; 1446 struct hci_conn *conn; 1447 1448 BT_DBG("%s status %d", hdev->name, ev->status); 1449 1450 hci_dev_lock(hdev); 1451 1452 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr); 1453 if (!conn) { 1454 if (ev->link_type == ESCO_LINK) 1455 goto unlock; 1456 1457 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr); 1458 if (!conn) 1459 goto unlock; 1460 1461 conn->type = SCO_LINK; 1462 } 1463 1464 if (!ev->status) { 1465 conn->handle = __le16_to_cpu(ev->handle); 1466 conn->state = BT_CONNECTED; 1467 } else 1468 conn->state = BT_CLOSED; 1469 1470 hci_proto_connect_cfm(conn, ev->status); 1471 if (ev->status) 1472 hci_conn_del(conn); 1473 1474unlock: 1475 hci_dev_unlock(hdev); 1476} 1477 1478static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb) 1479{ 1480 BT_DBG("%s", hdev->name); 1481} 1482 1483static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb) 1484{ 1485 struct hci_ev_sniff_subrate *ev = (void *) skb->data; 1486 struct hci_conn *conn; 1487 1488 BT_DBG("%s status %d", hdev->name, ev->status); 1489 1490 hci_dev_lock(hdev); 1491 1492 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle)); 1493 if (conn) { 1494 } 1495 1496 hci_dev_unlock(hdev); 1497} 1498 1499static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb) 1500{ 1501 struct inquiry_data data; 1502 struct extended_inquiry_info *info = (void *) (skb->data + 1); 1503 int num_rsp = *((__u8 *) skb->data); 1504 1505 BT_DBG("%s num_rsp %d", hdev->name, num_rsp); 1506 1507 if (!num_rsp) 1508 return; 1509 1510 hci_dev_lock(hdev); 1511 1512 for (; num_rsp; num_rsp--) { 1513 bacpy(&data.bdaddr, &info->bdaddr); 1514 data.pscan_rep_mode = info->pscan_rep_mode; 1515 data.pscan_period_mode = info->pscan_period_mode; 1516 data.pscan_mode = 0x00; 1517 memcpy(data.dev_class, info->dev_class, 3); 1518 data.clock_offset = info->clock_offset; 1519 data.rssi = info->rssi; 1520 data.ssp_mode = 0x01; 1521 info++; 1522 hci_inquiry_cache_update(hdev, &data); 1523 } 1524 1525 hci_dev_unlock(hdev); 1526} 1527 1528static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb) 1529{ 1530 struct hci_ev_io_capa_request *ev = (void *) skb->data; 1531 struct hci_conn *conn; 1532 1533 BT_DBG("%s", hdev->name); 1534 1535 hci_dev_lock(hdev); 1536 1537 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr); 1538 if (conn) 1539 hci_conn_hold(conn); 1540 1541 hci_dev_unlock(hdev); 1542} 1543 1544static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb) 1545{ 1546 struct hci_ev_simple_pair_complete *ev = (void *) skb->data; 1547 struct hci_conn *conn; 1548 1549 BT_DBG("%s", hdev->name); 1550 1551 hci_dev_lock(hdev); 1552 1553 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr); 1554 if (conn) 1555 hci_conn_put(conn); 1556 1557 hci_dev_unlock(hdev); 1558} 1559 1560static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb) 1561{ 1562 struct hci_ev_remote_host_features *ev = (void *) skb->data; 1563 struct inquiry_entry *ie; 1564 1565 BT_DBG("%s", hdev->name); 1566 1567 hci_dev_lock(hdev); 1568 1569 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) 1570 ie->data.ssp_mode = (ev->features[0] & 0x01); 1571 1572 hci_dev_unlock(hdev); 1573} 1574 1575void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb) 1576{ 1577 struct hci_event_hdr *hdr = (void *) skb->data; 1578 __u8 event = hdr->evt; 1579 1580 skb_pull(skb, HCI_EVENT_HDR_SIZE); 1581 1582 switch (event) { 1583 case HCI_EV_INQUIRY_COMPLETE: 1584 hci_inquiry_complete_evt(hdev, skb); 1585 break; 1586 1587 case HCI_EV_INQUIRY_RESULT: 1588 hci_inquiry_result_evt(hdev, skb); 1589 break; 1590 1591 case HCI_EV_CONN_COMPLETE: 1592 hci_conn_complete_evt(hdev, skb); 1593 break; 1594 1595 case HCI_EV_CONN_REQUEST: 1596 hci_conn_request_evt(hdev, skb); 1597 break; 1598 1599 case HCI_EV_DISCONN_COMPLETE: 1600 hci_disconn_complete_evt(hdev, skb); 1601 break; 1602 1603 case HCI_EV_AUTH_COMPLETE: 1604 hci_auth_complete_evt(hdev, skb); 1605 break; 1606 1607 case HCI_EV_REMOTE_NAME: 1608 hci_remote_name_evt(hdev, skb); 1609 break; 1610 1611 case HCI_EV_ENCRYPT_CHANGE: 1612 hci_encrypt_change_evt(hdev, skb); 1613 break; 1614 1615 case HCI_EV_CHANGE_LINK_KEY_COMPLETE: 1616 hci_change_link_key_complete_evt(hdev, skb); 1617 break; 1618 1619 case HCI_EV_REMOTE_FEATURES: 1620 hci_remote_features_evt(hdev, skb); 1621 break; 1622 1623 case HCI_EV_REMOTE_VERSION: 1624 hci_remote_version_evt(hdev, skb); 1625 break; 1626 1627 case HCI_EV_QOS_SETUP_COMPLETE: 1628 hci_qos_setup_complete_evt(hdev, skb); 1629 break; 1630 1631 case HCI_EV_CMD_COMPLETE: 1632 hci_cmd_complete_evt(hdev, skb); 1633 break; 1634 1635 case HCI_EV_CMD_STATUS: 1636 hci_cmd_status_evt(hdev, skb); 1637 break; 1638 1639 case HCI_EV_ROLE_CHANGE: 1640 hci_role_change_evt(hdev, skb); 1641 break; 1642 1643 case HCI_EV_NUM_COMP_PKTS: 1644 hci_num_comp_pkts_evt(hdev, skb); 1645 break; 1646 1647 case HCI_EV_MODE_CHANGE: 1648 hci_mode_change_evt(hdev, skb); 1649 break; 1650 1651 case HCI_EV_PIN_CODE_REQ: 1652 hci_pin_code_request_evt(hdev, skb); 1653 break; 1654 1655 case HCI_EV_LINK_KEY_REQ: 1656 hci_link_key_request_evt(hdev, skb); 1657 break; 1658 1659 case HCI_EV_LINK_KEY_NOTIFY: 1660 hci_link_key_notify_evt(hdev, skb); 1661 break; 1662 1663 case HCI_EV_CLOCK_OFFSET: 1664 hci_clock_offset_evt(hdev, skb); 1665 break; 1666 1667 case HCI_EV_PKT_TYPE_CHANGE: 1668 hci_pkt_type_change_evt(hdev, skb); 1669 break; 1670 1671 case HCI_EV_PSCAN_REP_MODE: 1672 hci_pscan_rep_mode_evt(hdev, skb); 1673 break; 1674 1675 case HCI_EV_INQUIRY_RESULT_WITH_RSSI: 1676 hci_inquiry_result_with_rssi_evt(hdev, skb); 1677 break; 1678 1679 case HCI_EV_REMOTE_EXT_FEATURES: 1680 hci_remote_ext_features_evt(hdev, skb); 1681 break; 1682 1683 case HCI_EV_SYNC_CONN_COMPLETE: 1684 hci_sync_conn_complete_evt(hdev, skb); 1685 break; 1686 1687 case HCI_EV_SYNC_CONN_CHANGED: 1688 hci_sync_conn_changed_evt(hdev, skb); 1689 break; 1690 1691 case HCI_EV_SNIFF_SUBRATE: 1692 hci_sniff_subrate_evt(hdev, skb); 1693 break; 1694 1695 case HCI_EV_EXTENDED_INQUIRY_RESULT: 1696 hci_extended_inquiry_result_evt(hdev, skb); 1697 break; 1698 1699 case HCI_EV_IO_CAPA_REQUEST: 1700 hci_io_capa_request_evt(hdev, skb); 1701 break; 1702 1703 case HCI_EV_SIMPLE_PAIR_COMPLETE: 1704 hci_simple_pair_complete_evt(hdev, skb); 1705 break; 1706 1707 case HCI_EV_REMOTE_HOST_FEATURES: 1708 hci_remote_host_features_evt(hdev, skb); 1709 break; 1710 1711 default: 1712 BT_DBG("%s event 0x%x", hdev->name, event); 1713 break; 1714 } 1715 1716 kfree_skb(skb); 1717 hdev->stat.evt_rx++; 1718} 1719 1720/* Generate internal stack event */ 1721void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data) 1722{ 1723 struct hci_event_hdr *hdr; 1724 struct hci_ev_stack_internal *ev; 1725 struct sk_buff *skb; 1726 1727 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC); 1728 if (!skb) 1729 return; 1730 1731 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE); 1732 hdr->evt = HCI_EV_STACK_INTERNAL; 1733 hdr->plen = sizeof(*ev) + dlen; 1734 1735 ev = (void *) skb_put(skb, sizeof(*ev) + dlen); 1736 ev->type = type; 1737 memcpy(ev->data, data, dlen); 1738 1739 bt_cb(skb)->incoming = 1; 1740 __net_timestamp(skb); 1741 1742 bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 1743 skb->dev = (void *) hdev; 1744 hci_send_to_sock(hdev, skb); 1745 kfree_skb(skb); 1746} 1747