net/bluetooth/hci_event.c

   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 static 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
  71 static 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
  85 static void hci_cc_remote_name_req_cancel(struct hci_dev *hdev, struct sk_buff *skb)
  86 {
  87         BT_DBG("%s", hdev->name);
  88 }
  89
  90 static 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
 113 static 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
 132 static 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
 156 static 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
 168 static 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
 185 static 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
 194 static 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
 211 static 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
 223 static 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
 246 static 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
 269 static 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
 296 static 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
 311 static 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
 328 static 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
 354 static 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
 385 static 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
 394 static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
 395 {
 396         struct hci_rp_read_local_version *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->hci_ver = rp->hci_ver;
 404         hdev->hci_rev = __le16_to_cpu(rp->hci_rev);
 405         hdev->manufacturer = __le16_to_cpu(rp->manufacturer);
 406
 407         BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
 408                                         hdev->manufacturer,
 409                                         hdev->hci_ver, hdev->hci_rev);
 410 }
 411
 412 static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
 413 {
 414         struct hci_rp_read_local_commands *rp = (void *) skb->data;
 415
 416         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 417
 418         if (rp->status)
 419                 return;
 420
 421         memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
 422 }
 423
 424 static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
 425 {
 426         struct hci_rp_read_local_features *rp = (void *) skb->data;
 427
 428         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 429
 430         if (rp->status)
 431                 return;
 432
 433         memcpy(hdev->features, rp->features, 8);
 434
 435         /* Adjust default settings according to features
 436          * supported by device. */
 437
 438         if (hdev->features[0] & LMP_3SLOT)
 439                 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
 440
 441         if (hdev->features[0] & LMP_5SLOT)
 442                 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
 443
 444         if (hdev->features[1] & LMP_HV2) {
 445                 hdev->pkt_type  |= (HCI_HV2);
 446                 hdev->esco_type |= (ESCO_HV2);
 447         }
 448
 449         if (hdev->features[1] & LMP_HV3) {
 450                 hdev->pkt_type  |= (HCI_HV3);
 451                 hdev->esco_type |= (ESCO_HV3);
 452         }
 453
 454         if (hdev->features[3] & LMP_ESCO)
 455                 hdev->esco_type |= (ESCO_EV3);
 456
 457         if (hdev->features[4] & LMP_EV4)
 458                 hdev->esco_type |= (ESCO_EV4);
 459
 460         if (hdev->features[4] & LMP_EV5)
 461                 hdev->esco_type |= (ESCO_EV5);
 462
 463         BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
 464                                         hdev->features[0], hdev->features[1],
 465                                         hdev->features[2], hdev->features[3],
 466                                         hdev->features[4], hdev->features[5],
 467                                         hdev->features[6], hdev->features[7]);
 468 }
 469
 470 static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
 471 {
 472         struct hci_rp_read_buffer_size *rp = (void *) skb->data;
 473
 474         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 475
 476         if (rp->status)
 477                 return;
 478
 479         hdev->acl_mtu  = __le16_to_cpu(rp->acl_mtu);
 480         hdev->sco_mtu  = rp->sco_mtu;
 481         hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
 482         hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
 483
 484         if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
 485                 hdev->sco_mtu  = 64;
 486                 hdev->sco_pkts = 8;
 487         }
 488
 489         hdev->acl_cnt = hdev->acl_pkts;
 490         hdev->sco_cnt = hdev->sco_pkts;
 491
 492         BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
 493                                         hdev->acl_mtu, hdev->acl_pkts,
 494                                         hdev->sco_mtu, hdev->sco_pkts);
 495 }
 496
 497 static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
 498 {
 499         struct hci_rp_read_bd_addr *rp = (void *) skb->data;
 500
 501         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 502
 503         if (!rp->status)
 504                 bacpy(&hdev->bdaddr, &rp->bdaddr);
 505
 506         hci_req_complete(hdev, rp->status);
 507 }
 508
 509 static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
 510 {
 511         BT_DBG("%s status 0x%x", hdev->name, status);
 512
 513         if (status) {
 514                 hci_req_complete(hdev, status);
 515
 516                 hci_conn_check_pending(hdev);
 517         } else
 518                 set_bit(HCI_INQUIRY, &hdev->flags);
 519 }
 520
 521 static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
 522 {
 523         struct hci_cp_create_conn *cp;
 524         struct hci_conn *conn;
 525
 526         BT_DBG("%s status 0x%x", hdev->name, status);
 527
 528         cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
 529         if (!cp)
 530                 return;
 531
 532         hci_dev_lock(hdev);
 533
 534         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
 535
 536         BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
 537
 538         if (status) {
 539                 if (conn && conn->state == BT_CONNECT) {
 540                         if (status != 0x0c || conn->attempt > 2) {
 541                                 conn->state = BT_CLOSED;
 542                                 hci_proto_connect_cfm(conn, status);
 543                                 hci_conn_del(conn);
 544                         } else
 545                                 conn->state = BT_CONNECT2;
 546                 }
 547         } else {
 548                 if (!conn) {
 549                         conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
 550                         if (conn) {
 551                                 conn->out = 1;
 552                                 conn->link_mode |= HCI_LM_MASTER;
 553                         } else
 554                                 BT_ERR("No memmory for new connection");
 555                 }
 556         }
 557
 558         hci_dev_unlock(hdev);
 559 }
 560
 561 static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
 562 {
 563         struct hci_cp_add_sco *cp;
 564         struct hci_conn *acl, *sco;
 565         __u16 handle;
 566
 567         BT_DBG("%s status 0x%x", hdev->name, status);
 568
 569         if (!status)
 570                 return;
 571
 572         cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
 573         if (!cp)
 574                 return;
 575
 576         handle = __le16_to_cpu(cp->handle);
 577
 578         BT_DBG("%s handle %d", hdev->name, handle);
 579
 580         hci_dev_lock(hdev);
 581
 582         acl = hci_conn_hash_lookup_handle(hdev, handle);
 583         if (acl && (sco = acl->link)) {
 584                 sco->state = BT_CLOSED;
 585
 586                 hci_proto_connect_cfm(sco, status);
 587                 hci_conn_del(sco);
 588         }
 589
 590         hci_dev_unlock(hdev);
 591 }
 592
 593 static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
 594 {
 595         BT_DBG("%s status 0x%x", hdev->name, status);
 596 }
 597
 598 static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
 599 {
 600         struct hci_cp_setup_sync_conn *cp;
 601         struct hci_conn *acl, *sco;
 602         __u16 handle;
 603
 604         BT_DBG("%s status 0x%x", hdev->name, status);
 605
 606         if (!status)
 607                 return;
 608
 609         cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
 610         if (!cp)
 611                 return;
 612
 613         handle = __le16_to_cpu(cp->handle);
 614
 615         BT_DBG("%s handle %d", hdev->name, handle);
 616
 617         hci_dev_lock(hdev);
 618
 619         acl = hci_conn_hash_lookup_handle(hdev, handle);
 620         if (acl && (sco = acl->link)) {
 621                 sco->state = BT_CLOSED;
 622
 623                 hci_proto_connect_cfm(sco, status);
 624                 hci_conn_del(sco);
 625         }
 626
 627         hci_dev_unlock(hdev);
 628 }
 629
 630 static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
 631 {
 632         struct hci_cp_sniff_mode *cp;
 633         struct hci_conn *conn;
 634
 635         BT_DBG("%s status 0x%x", hdev->name, status);
 636
 637         if (!status)
 638                 return;
 639
 640         cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
 641         if (!cp)
 642                 return;
 643
 644         hci_dev_lock(hdev);
 645
 646         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 647         if (conn)
 648                 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
 649
 650         hci_dev_unlock(hdev);
 651 }
 652
 653 static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
 654 {
 655         struct hci_cp_exit_sniff_mode *cp;
 656         struct hci_conn *conn;
 657
 658         BT_DBG("%s status 0x%x", hdev->name, status);
 659
 660         if (!status)
 661                 return;
 662
 663         cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
 664         if (!cp)
 665                 return;
 666
 667         hci_dev_lock(hdev);
 668
 669         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 670         if (conn)
 671                 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
 672
 673         hci_dev_unlock(hdev);
 674 }
 675
 676 static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 677 {
 678         __u8 status = *((__u8 *) skb->data);
 679
 680         BT_DBG("%s status %d", hdev->name, status);
 681
 682         clear_bit(HCI_INQUIRY, &hdev->flags);
 683
 684         hci_req_complete(hdev, status);
 685
 686         hci_conn_check_pending(hdev);
 687 }
 688
 689 static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
 690 {
 691         struct inquiry_data data;
 692         struct inquiry_info *info = (void *) (skb->data + 1);
 693         int num_rsp = *((__u8 *) skb->data);
 694
 695         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
 696
 697         if (!num_rsp)
 698                 return;
 699
 700         hci_dev_lock(hdev);
 701
 702         for (; num_rsp; num_rsp--) {
 703                 bacpy(&data.bdaddr, &info->bdaddr);
 704                 data.pscan_rep_mode     = info->pscan_rep_mode;
 705                 data.pscan_period_mode  = info->pscan_period_mode;
 706                 data.pscan_mode         = info->pscan_mode;
 707                 memcpy(data.dev_class, info->dev_class, 3);
 708                 data.clock_offset       = info->clock_offset;
 709                 data.rssi               = 0x00;
 710                 info++;
 711                 hci_inquiry_cache_update(hdev, &data);
 712         }
 713
 714         hci_dev_unlock(hdev);
 715 }
 716
 717 static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 718 {
 719         struct hci_ev_conn_complete *ev = (void *) skb->data;
 720         struct hci_conn *conn;
 721
 722         BT_DBG("%s", hdev->name);
 723
 724         hci_dev_lock(hdev);
 725
 726         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 727         if (!conn)
 728                 goto unlock;
 729
 730         if (!ev->status) {
 731                 conn->handle = __le16_to_cpu(ev->handle);
 732                 conn->state  = BT_CONNECTED;
 733
 734                 if (test_bit(HCI_AUTH, &hdev->flags))
 735                         conn->link_mode |= HCI_LM_AUTH;
 736
 737                 if (test_bit(HCI_ENCRYPT, &hdev->flags))
 738                         conn->link_mode |= HCI_LM_ENCRYPT;
 739
 740                 /* Get remote features */
 741                 if (conn->type == ACL_LINK) {
 742                         struct hci_cp_read_remote_features cp;
 743                         cp.handle = ev->handle;
 744                         hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES, sizeof(cp), &cp);
 745                 }
 746
 747                 /* Set packet type for incoming connection */
 748                 if (!conn->out && hdev->hci_ver < 3) {
 749                         struct hci_cp_change_conn_ptype cp;
 750                         cp.handle = ev->handle;
 751                         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 752                         hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
 753                                                         sizeof(cp), &cp);
 754                 } else {
 755                         /* Update disconnect timer */
 756                         hci_conn_hold(conn);
 757                         hci_conn_put(conn);
 758                 }
 759         } else
 760                 conn->state = BT_CLOSED;
 761
 762         if (conn->type == ACL_LINK) {
 763                 struct hci_conn *sco = conn->link;
 764                 if (sco) {
 765                         if (!ev->status) {
 766                                 if (lmp_esco_capable(hdev))
 767                                         hci_setup_sync(sco, conn->handle);
 768                                 else
 769                                         hci_add_sco(sco, conn->handle);
 770                         } else {
 771                                 hci_proto_connect_cfm(sco, ev->status);
 772                                 hci_conn_del(sco);
 773                         }
 774                 }
 775         }
 776
 777         hci_proto_connect_cfm(conn, ev->status);
 778         if (ev->status)
 779                 hci_conn_del(conn);
 780
 781 unlock:
 782         hci_dev_unlock(hdev);
 783
 784         hci_conn_check_pending(hdev);
 785 }
 786
 787 static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
 788 {
 789         struct hci_ev_conn_request *ev = (void *) skb->data;
 790         int mask = hdev->link_mode;
 791
 792         BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
 793                                         batostr(&ev->bdaddr), ev->link_type);
 794
 795         mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
 796
 797         if (mask & HCI_LM_ACCEPT) {
 798                 /* Connection accepted */
 799                 struct hci_conn *conn;
 800
 801                 hci_dev_lock(hdev);
 802
 803                 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 804                 if (!conn) {
 805                         if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
 806                                 BT_ERR("No memmory for new connection");
 807                                 hci_dev_unlock(hdev);
 808                                 return;
 809                         }
 810                 }
 811
 812                 memcpy(conn->dev_class, ev->dev_class, 3);
 813                 conn->state = BT_CONNECT;
 814
 815                 hci_dev_unlock(hdev);
 816
 817                 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
 818                         struct hci_cp_accept_conn_req cp;
 819
 820                         bacpy(&cp.bdaddr, &ev->bdaddr);
 821
 822                         if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
 823                                 cp.role = 0x00; /* Become master */
 824                         else
 825                                 cp.role = 0x01; /* Remain slave */
 826
 827                         hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
 828                                                         sizeof(cp), &cp);
 829                 } else {
 830                         struct hci_cp_accept_sync_conn_req cp;
 831
 832                         bacpy(&cp.bdaddr, &ev->bdaddr);
 833                         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 834
 835                         cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 836                         cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 837                         cp.max_latency    = cpu_to_le16(0xffff);
 838                         cp.content_format = cpu_to_le16(hdev->voice_setting);
 839                         cp.retrans_effort = 0xff;
 840
 841                         hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 842                                                         sizeof(cp), &cp);
 843                 }
 844         } else {
 845                 /* Connection rejected */
 846                 struct hci_cp_reject_conn_req cp;
 847
 848                 bacpy(&cp.bdaddr, &ev->bdaddr);
 849                 cp.reason = 0x0f;
 850                 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
 851         }
 852 }
 853
 854 static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 855 {
 856         struct hci_ev_disconn_complete *ev = (void *) skb->data;
 857         struct hci_conn *conn;
 858
 859         BT_DBG("%s status %d", hdev->name, ev->status);
 860
 861         if (ev->status)
 862                 return;
 863
 864         hci_dev_lock(hdev);
 865
 866         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 867         if (conn) {
 868                 conn->state = BT_CLOSED;
 869                 hci_proto_disconn_ind(conn, ev->reason);
 870                 hci_conn_del(conn);
 871         }
 872
 873         hci_dev_unlock(hdev);
 874 }
 875
 876 static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 877 {
 878         struct hci_ev_auth_complete *ev = (void *) skb->data;
 879         struct hci_conn *conn;
 880
 881         BT_DBG("%s status %d", hdev->name, ev->status);
 882
 883         hci_dev_lock(hdev);
 884
 885         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 886         if (conn) {
 887                 if (!ev->status)
 888                         conn->link_mode |= HCI_LM_AUTH;
 889
 890                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
 891
 892                 hci_auth_cfm(conn, ev->status);
 893
 894                 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
 895                         if (!ev->status) {
 896                                 struct hci_cp_set_conn_encrypt cp;
 897                                 cp.handle  = cpu_to_le16(conn->handle);
 898                                 cp.encrypt = 1;
 899                                 hci_send_cmd(conn->hdev,
 900                                         HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
 901                         } else {
 902                                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
 903                                 hci_encrypt_cfm(conn, ev->status, 0x00);
 904                         }
 905                 }
 906         }
 907
 908         hci_dev_unlock(hdev);
 909 }
 910
 911 static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
 912 {
 913         BT_DBG("%s", hdev->name);
 914
 915         hci_conn_check_pending(hdev);
 916 }
 917
 918 static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
 919 {
 920         struct hci_ev_encrypt_change *ev = (void *) skb->data;
 921         struct hci_conn *conn;
 922
 923         BT_DBG("%s status %d", hdev->name, ev->status);
 924
 925         hci_dev_lock(hdev);
 926
 927         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 928         if (conn) {
 929                 if (!ev->status) {
 930                         if (ev->encrypt) {
 931                                 /* Encryption implies authentication */
 932                                 conn->link_mode |= HCI_LM_AUTH;
 933                                 conn->link_mode |= HCI_LM_ENCRYPT;
 934                         } else
 935                                 conn->link_mode &= ~HCI_LM_ENCRYPT;
 936                 }
 937
 938                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
 939
 940                 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
 941         }
 942
 943         hci_dev_unlock(hdev);
 944 }
 945
 946 static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 947 {
 948         struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
 949         struct hci_conn *conn;
 950
 951         BT_DBG("%s status %d", hdev->name, ev->status);
 952
 953         hci_dev_lock(hdev);
 954
 955         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 956         if (conn) {
 957                 if (!ev->status)
 958                         conn->link_mode |= HCI_LM_SECURE;
 959
 960                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
 961
 962                 hci_key_change_cfm(conn, ev->status);
 963         }
 964
 965         hci_dev_unlock(hdev);
 966 }
 967
 968 static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
 969 {
 970         struct hci_ev_remote_features *ev = (void *) skb->data;
 971         struct hci_conn *conn;
 972
 973         BT_DBG("%s status %d", hdev->name, ev->status);
 974
 975         if (ev->status)
 976                 return;
 977
 978         hci_dev_lock(hdev);
 979
 980         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 981         if (conn)
 982                 memcpy(conn->features, ev->features, 8);
 983
 984         hci_dev_unlock(hdev);
 985 }
 986
 987 static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
 988 {
 989         BT_DBG("%s", hdev->name);
 990 }
 991
 992 static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 993 {
 994         BT_DBG("%s", hdev->name);
 995 }
 996
 997 static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 998 {
 999         struct hci_ev_cmd_complete *ev = (void *) skb->data;
1000         __u16 opcode;
1001
1002         skb_pull(skb, sizeof(*ev));
1003
1004         opcode = __le16_to_cpu(ev->opcode);
1005
1006         switch (opcode) {
1007         case HCI_OP_INQUIRY_CANCEL:
1008                 hci_cc_inquiry_cancel(hdev, skb);
1009                 break;
1010
1011         case HCI_OP_EXIT_PERIODIC_INQ:
1012                 hci_cc_exit_periodic_inq(hdev, skb);
1013                 break;
1014
1015         case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1016                 hci_cc_remote_name_req_cancel(hdev, skb);
1017                 break;
1018
1019         case HCI_OP_ROLE_DISCOVERY:
1020                 hci_cc_role_discovery(hdev, skb);
1021                 break;
1022
1023         case HCI_OP_READ_LINK_POLICY:
1024                 hci_cc_read_link_policy(hdev, skb);
1025                 break;
1026
1027         case HCI_OP_WRITE_LINK_POLICY:
1028                 hci_cc_write_link_policy(hdev, skb);
1029                 break;
1030
1031         case HCI_OP_READ_DEF_LINK_POLICY:
1032                 hci_cc_read_def_link_policy(hdev, skb);
1033                 break;
1034
1035         case HCI_OP_WRITE_DEF_LINK_POLICY:
1036                 hci_cc_write_def_link_policy(hdev, skb);
1037                 break;
1038
1039         case HCI_OP_RESET:
1040                 hci_cc_reset(hdev, skb);
1041                 break;
1042
1043         case HCI_OP_WRITE_LOCAL_NAME:
1044                 hci_cc_write_local_name(hdev, skb);
1045                 break;
1046
1047         case HCI_OP_READ_LOCAL_NAME:
1048                 hci_cc_read_local_name(hdev, skb);
1049                 break;
1050
1051         case HCI_OP_WRITE_AUTH_ENABLE:
1052                 hci_cc_write_auth_enable(hdev, skb);
1053                 break;
1054
1055         case HCI_OP_WRITE_ENCRYPT_MODE:
1056                 hci_cc_write_encrypt_mode(hdev, skb);
1057                 break;
1058
1059         case HCI_OP_WRITE_SCAN_ENABLE:
1060                 hci_cc_write_scan_enable(hdev, skb);
1061                 break;
1062
1063         case HCI_OP_READ_CLASS_OF_DEV:
1064                 hci_cc_read_class_of_dev(hdev, skb);
1065                 break;
1066
1067         case HCI_OP_WRITE_CLASS_OF_DEV:
1068                 hci_cc_write_class_of_dev(hdev, skb);
1069                 break;
1070
1071         case HCI_OP_READ_VOICE_SETTING:
1072                 hci_cc_read_voice_setting(hdev, skb);
1073                 break;
1074
1075         case HCI_OP_WRITE_VOICE_SETTING:
1076                 hci_cc_write_voice_setting(hdev, skb);
1077                 break;
1078
1079         case HCI_OP_HOST_BUFFER_SIZE:
1080                 hci_cc_host_buffer_size(hdev, skb);
1081                 break;
1082
1083         case HCI_OP_READ_LOCAL_VERSION:
1084                 hci_cc_read_local_version(hdev, skb);
1085                 break;
1086
1087         case HCI_OP_READ_LOCAL_COMMANDS:
1088                 hci_cc_read_local_commands(hdev, skb);
1089                 break;
1090
1091         case HCI_OP_READ_LOCAL_FEATURES:
1092                 hci_cc_read_local_features(hdev, skb);
1093                 break;
1094
1095         case HCI_OP_READ_BUFFER_SIZE:
1096                 hci_cc_read_buffer_size(hdev, skb);
1097                 break;
1098
1099         case HCI_OP_READ_BD_ADDR:
1100                 hci_cc_read_bd_addr(hdev, skb);
1101                 break;
1102
1103         default:
1104                 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1105                 break;
1106         }
1107
1108         if (ev->ncmd) {
1109                 atomic_set(&hdev->cmd_cnt, 1);
1110                 if (!skb_queue_empty(&hdev->cmd_q))
1111                         hci_sched_cmd(hdev);
1112         }
1113 }
1114
1115 static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1116 {
1117         struct hci_ev_cmd_status *ev = (void *) skb->data;
1118         __u16 opcode;
1119
1120         skb_pull(skb, sizeof(*ev));
1121
1122         opcode = __le16_to_cpu(ev->opcode);
1123
1124         switch (opcode) {
1125         case HCI_OP_INQUIRY:
1126                 hci_cs_inquiry(hdev, ev->status);
1127                 break;
1128
1129         case HCI_OP_CREATE_CONN:
1130                 hci_cs_create_conn(hdev, ev->status);
1131                 break;
1132
1133         case HCI_OP_ADD_SCO:
1134                 hci_cs_add_sco(hdev, ev->status);
1135                 break;
1136
1137         case HCI_OP_REMOTE_NAME_REQ:
1138                 hci_cs_remote_name_req(hdev, ev->status);
1139                 break;
1140
1141         case HCI_OP_SETUP_SYNC_CONN:
1142                 hci_cs_setup_sync_conn(hdev, ev->status);
1143                 break;
1144
1145         case HCI_OP_SNIFF_MODE:
1146                 hci_cs_sniff_mode(hdev, ev->status);
1147                 break;
1148
1149         case HCI_OP_EXIT_SNIFF_MODE:
1150                 hci_cs_exit_sniff_mode(hdev, ev->status);
1151                 break;
1152
1153         default:
1154                 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1155                 break;
1156         }
1157
1158         if (ev->ncmd) {
1159                 atomic_set(&hdev->cmd_cnt, 1);
1160                 if (!skb_queue_empty(&hdev->cmd_q))
1161                         hci_sched_cmd(hdev);
1162         }
1163 }
1164
1165 static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1166 {
1167         struct hci_ev_role_change *ev = (void *) skb->data;
1168         struct hci_conn *conn;
1169
1170         BT_DBG("%s status %d", hdev->name, ev->status);
1171
1172         hci_dev_lock(hdev);
1173
1174         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1175         if (conn) {
1176                 if (!ev->status) {
1177                         if (ev->role)
1178                                 conn->link_mode &= ~HCI_LM_MASTER;
1179                         else
1180                                 conn->link_mode |= HCI_LM_MASTER;
1181                 }
1182
1183                 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1184
1185                 hci_role_switch_cfm(conn, ev->status, ev->role);
1186         }
1187
1188         hci_dev_unlock(hdev);
1189 }
1190
1191 static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1192 {
1193         struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1194         __le16 *ptr;
1195         int i;
1196
1197         skb_pull(skb, sizeof(*ev));
1198
1199         BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1200
1201         if (skb->len < ev->num_hndl * 4) {
1202                 BT_DBG("%s bad parameters", hdev->name);
1203                 return;
1204         }
1205
1206         tasklet_disable(&hdev->tx_task);
1207
1208         for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1209                 struct hci_conn *conn;
1210                 __u16  handle, count;
1211
1212                 handle = get_unaligned_le16(ptr++);
1213                 count  = get_unaligned_le16(ptr++);
1214
1215                 conn = hci_conn_hash_lookup_handle(hdev, handle);
1216                 if (conn) {
1217                         conn->sent -= count;
1218
1219                         if (conn->type == ACL_LINK) {
1220                                 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1221                                         hdev->acl_cnt = hdev->acl_pkts;
1222                         } else {
1223                                 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1224                                         hdev->sco_cnt = hdev->sco_pkts;
1225                         }
1226                 }
1227         }
1228
1229         hci_sched_tx(hdev);
1230
1231         tasklet_enable(&hdev->tx_task);
1232 }
1233
1234 static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1235 {
1236         struct hci_ev_mode_change *ev = (void *) skb->data;
1237         struct hci_conn *conn;
1238
1239         BT_DBG("%s status %d", hdev->name, ev->status);
1240
1241         hci_dev_lock(hdev);
1242
1243         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1244         if (conn) {
1245                 conn->mode = ev->mode;
1246                 conn->interval = __le16_to_cpu(ev->interval);
1247
1248                 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1249                         if (conn->mode == HCI_CM_ACTIVE)
1250                                 conn->power_save = 1;
1251                         else
1252                                 conn->power_save = 0;
1253                 }
1254         }
1255
1256         hci_dev_unlock(hdev);
1257 }
1258
1259 static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1260 {
1261         BT_DBG("%s", hdev->name);
1262 }
1263
1264 static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1265 {
1266         BT_DBG("%s", hdev->name);
1267 }
1268
1269 static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1270 {
1271         BT_DBG("%s", hdev->name);
1272 }
1273
1274 static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1275 {
1276         struct hci_ev_clock_offset *ev = (void *) skb->data;
1277         struct hci_conn *conn;
1278
1279         BT_DBG("%s status %d", hdev->name, ev->status);
1280
1281         hci_dev_lock(hdev);
1282
1283         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1284         if (conn && !ev->status) {
1285                 struct inquiry_entry *ie;
1286
1287                 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1288                         ie->data.clock_offset = ev->clock_offset;
1289                         ie->timestamp = jiffies;
1290                 }
1291         }
1292
1293         hci_dev_unlock(hdev);
1294 }
1295
1296 static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1297 {
1298         struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1299         struct hci_conn *conn;
1300
1301         BT_DBG("%s status %d", hdev->name, ev->status);
1302
1303         hci_dev_lock(hdev);
1304
1305         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1306         if (conn && !ev->status)
1307                 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1308
1309         hci_dev_unlock(hdev);
1310 }
1311
1312 static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1313 {
1314         struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
1315         struct inquiry_entry *ie;
1316
1317         BT_DBG("%s", hdev->name);
1318
1319         hci_dev_lock(hdev);
1320
1321         if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1322                 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1323                 ie->timestamp = jiffies;
1324         }
1325
1326         hci_dev_unlock(hdev);
1327 }
1328
1329 static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1330 {
1331         struct inquiry_data data;
1332         int num_rsp = *((__u8 *) skb->data);
1333
1334         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1335
1336         if (!num_rsp)
1337                 return;
1338
1339         hci_dev_lock(hdev);
1340
1341         if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1342                 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1343
1344                 for (; num_rsp; num_rsp--) {
1345                         bacpy(&data.bdaddr, &info->bdaddr);
1346                         data.pscan_rep_mode     = info->pscan_rep_mode;
1347                         data.pscan_period_mode  = info->pscan_period_mode;
1348                         data.pscan_mode         = info->pscan_mode;
1349                         memcpy(data.dev_class, info->dev_class, 3);
1350                         data.clock_offset       = info->clock_offset;
1351                         data.rssi               = info->rssi;
1352                         info++;
1353                         hci_inquiry_cache_update(hdev, &data);
1354                 }
1355         } else {
1356                 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1357
1358                 for (; num_rsp; num_rsp--) {
1359                         bacpy(&data.bdaddr, &info->bdaddr);
1360                         data.pscan_rep_mode     = info->pscan_rep_mode;
1361                         data.pscan_period_mode  = info->pscan_period_mode;
1362                         data.pscan_mode         = 0x00;
1363                         memcpy(data.dev_class, info->dev_class, 3);
1364                         data.clock_offset       = info->clock_offset;
1365                         data.rssi               = info->rssi;
1366                         info++;
1367                         hci_inquiry_cache_update(hdev, &data);
1368                 }
1369         }
1370
1371         hci_dev_unlock(hdev);
1372 }
1373
1374 static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1375 {
1376         BT_DBG("%s", hdev->name);
1377 }
1378
1379 static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1380 {
1381         struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1382         struct hci_conn *conn;
1383
1384         BT_DBG("%s status %d", hdev->name, ev->status);
1385
1386         hci_dev_lock(hdev);
1387
1388         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1389         if (!conn) {
1390                 if (ev->link_type == ESCO_LINK)
1391                         goto unlock;
1392
1393                 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1394                 if (!conn)
1395                         goto unlock;
1396
1397                 conn->type = SCO_LINK;
1398         }
1399
1400         if (!ev->status) {
1401                 conn->handle = __le16_to_cpu(ev->handle);
1402                 conn->state  = BT_CONNECTED;
1403         } else
1404                 conn->state = BT_CLOSED;
1405
1406         hci_proto_connect_cfm(conn, ev->status);
1407         if (ev->status)
1408                 hci_conn_del(conn);
1409
1410 unlock:
1411         hci_dev_unlock(hdev);
1412 }
1413
1414 static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1415 {
1416         BT_DBG("%s", hdev->name);
1417 }
1418
1419 static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1420 {
1421         struct hci_ev_sniff_subrate *ev = (void *) skb->data;
1422         struct hci_conn *conn;
1423
1424         BT_DBG("%s status %d", hdev->name, ev->status);
1425
1426         hci_dev_lock(hdev);
1427
1428         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1429         if (conn) {
1430         }
1431
1432         hci_dev_unlock(hdev);
1433 }
1434
1435 static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1436 {
1437         struct inquiry_data data;
1438         struct extended_inquiry_info *info = (void *) (skb->data + 1);
1439         int num_rsp = *((__u8 *) skb->data);
1440
1441         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1442
1443         if (!num_rsp)
1444                 return;
1445
1446         hci_dev_lock(hdev);
1447
1448         for (; num_rsp; num_rsp--) {
1449                 bacpy(&data.bdaddr, &info->bdaddr);
1450                 data.pscan_rep_mode     = info->pscan_rep_mode;
1451                 data.pscan_period_mode  = info->pscan_period_mode;
1452                 data.pscan_mode         = 0x00;
1453                 memcpy(data.dev_class, info->dev_class, 3);
1454                 data.clock_offset       = info->clock_offset;
1455                 data.rssi               = info->rssi;
1456                 info++;
1457                 hci_inquiry_cache_update(hdev, &data);
1458         }
1459
1460         hci_dev_unlock(hdev);
1461 }
1462
1463 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1464 {
1465         struct hci_event_hdr *hdr = (void *) skb->data;
1466         __u8 event = hdr->evt;
1467
1468         skb_pull(skb, HCI_EVENT_HDR_SIZE);
1469
1470         switch (event) {
1471         case HCI_EV_INQUIRY_COMPLETE:
1472                 hci_inquiry_complete_evt(hdev, skb);
1473                 break;
1474
1475         case HCI_EV_INQUIRY_RESULT:
1476                 hci_inquiry_result_evt(hdev, skb);
1477                 break;
1478
1479         case HCI_EV_CONN_COMPLETE:
1480                 hci_conn_complete_evt(hdev, skb);
1481                 break;
1482
1483         case HCI_EV_CONN_REQUEST:
1484                 hci_conn_request_evt(hdev, skb);
1485                 break;
1486
1487         case HCI_EV_DISCONN_COMPLETE:
1488                 hci_disconn_complete_evt(hdev, skb);
1489                 break;
1490
1491         case HCI_EV_AUTH_COMPLETE:
1492                 hci_auth_complete_evt(hdev, skb);
1493                 break;
1494
1495         case HCI_EV_REMOTE_NAME:
1496                 hci_remote_name_evt(hdev, skb);
1497                 break;
1498
1499         case HCI_EV_ENCRYPT_CHANGE:
1500                 hci_encrypt_change_evt(hdev, skb);
1501                 break;
1502
1503         case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1504                 hci_change_link_key_complete_evt(hdev, skb);
1505                 break;
1506
1507         case HCI_EV_REMOTE_FEATURES:
1508                 hci_remote_features_evt(hdev, skb);
1509                 break;
1510
1511         case HCI_EV_REMOTE_VERSION:
1512                 hci_remote_version_evt(hdev, skb);
1513                 break;
1514
1515         case HCI_EV_QOS_SETUP_COMPLETE:
1516                 hci_qos_setup_complete_evt(hdev, skb);
1517                 break;
1518
1519         case HCI_EV_CMD_COMPLETE:
1520                 hci_cmd_complete_evt(hdev, skb);
1521                 break;
1522
1523         case HCI_EV_CMD_STATUS:
1524                 hci_cmd_status_evt(hdev, skb);
1525                 break;
1526
1527         case HCI_EV_ROLE_CHANGE:
1528                 hci_role_change_evt(hdev, skb);
1529                 break;
1530
1531         case HCI_EV_NUM_COMP_PKTS:
1532                 hci_num_comp_pkts_evt(hdev, skb);
1533                 break;
1534
1535         case HCI_EV_MODE_CHANGE:
1536                 hci_mode_change_evt(hdev, skb);
1537                 break;
1538
1539         case HCI_EV_PIN_CODE_REQ:
1540                 hci_pin_code_request_evt(hdev, skb);
1541                 break;
1542
1543         case HCI_EV_LINK_KEY_REQ:
1544                 hci_link_key_request_evt(hdev, skb);
1545                 break;
1546
1547         case HCI_EV_LINK_KEY_NOTIFY:
1548                 hci_link_key_notify_evt(hdev, skb);
1549                 break;
1550
1551         case HCI_EV_CLOCK_OFFSET:
1552                 hci_clock_offset_evt(hdev, skb);
1553                 break;
1554
1555         case HCI_EV_PKT_TYPE_CHANGE:
1556                 hci_pkt_type_change_evt(hdev, skb);
1557                 break;
1558
1559         case HCI_EV_PSCAN_REP_MODE:
1560                 hci_pscan_rep_mode_evt(hdev, skb);
1561                 break;
1562
1563         case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1564                 hci_inquiry_result_with_rssi_evt(hdev, skb);
1565                 break;
1566
1567         case HCI_EV_REMOTE_EXT_FEATURES:
1568                 hci_remote_ext_features_evt(hdev, skb);
1569                 break;
1570
1571         case HCI_EV_SYNC_CONN_COMPLETE:
1572                 hci_sync_conn_complete_evt(hdev, skb);
1573                 break;
1574
1575         case HCI_EV_SYNC_CONN_CHANGED:
1576                 hci_sync_conn_changed_evt(hdev, skb);
1577                 break;
1578
1579         case HCI_EV_SNIFF_SUBRATE:
1580                 hci_sniff_subrate_evt(hdev, skb);
1581                 break;
1582
1583         case HCI_EV_EXTENDED_INQUIRY_RESULT:
1584                 hci_extended_inquiry_result_evt(hdev, skb);
1585                 break;
1586
1587         default:
1588                 BT_DBG("%s event 0x%x", hdev->name, event);
1589                 break;
1590         }
1591
1592         kfree_skb(skb);
1593         hdev->stat.evt_rx++;
1594 }
1595
1596 /* Generate internal stack event */
1597 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1598 {
1599         struct hci_event_hdr *hdr;
1600         struct hci_ev_stack_internal *ev;
1601         struct sk_buff *skb;
1602
1603         skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1604         if (!skb)
1605                 return;
1606
1607         hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1608         hdr->evt  = HCI_EV_STACK_INTERNAL;
1609         hdr->plen = sizeof(*ev) + dlen;
1610
1611         ev  = (void *) skb_put(skb, sizeof(*ev) + dlen);
1612         ev->type = type;
1613         memcpy(ev->data, data, dlen);
1614
1615         bt_cb(skb)->incoming = 1;
1616         __net_timestamp(skb);
1617
1618         bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1619         skb->dev = (void *) hdev;
1620         hci_send_to_sock(hdev, skb);
1621         kfree_skb(skb);
1622 }