net/bluetooth/hci_event.c

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