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 /* 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, 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, 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, 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, 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, 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, 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, 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, rp->status);
 540 }
 541
 542 static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
 543 {
 544         BT_DBG("%s status 0x%x", hdev->name, status);
 545
 546         if (status) {
 547                 hci_req_complete(hdev, status);
 548
 549                 hci_conn_check_pending(hdev);
 550         } else
 551                 set_bit(HCI_INQUIRY, &hdev->flags);
 552 }
 553
 554 static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
 555 {
 556         struct hci_cp_create_conn *cp;
 557         struct hci_conn *conn;
 558
 559         BT_DBG("%s status 0x%x", hdev->name, status);
 560
 561         cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
 562         if (!cp)
 563                 return;
 564
 565         hci_dev_lock(hdev);
 566
 567         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
 568
 569         BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
 570
 571         if (status) {
 572                 if (conn && conn->state == BT_CONNECT) {
 573                         if (status != 0x0c || conn->attempt > 2) {
 574                                 conn->state = BT_CLOSED;
 575                                 hci_proto_connect_cfm(conn, status);
 576                                 hci_conn_del(conn);
 577                         } else
 578                                 conn->state = BT_CONNECT2;
 579                 }
 580         } else {
 581                 if (!conn) {
 582                         conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
 583                         if (conn) {
 584                                 conn->out = 1;
 585                                 conn->link_mode |= HCI_LM_MASTER;
 586                         } else
 587                                 BT_ERR("No memmory for new connection");
 588                 }
 589         }
 590
 591         hci_dev_unlock(hdev);
 592 }
 593
 594 static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
 595 {
 596         struct hci_cp_add_sco *cp;
 597         struct hci_conn *acl, *sco;
 598         __u16 handle;
 599
 600         BT_DBG("%s status 0x%x", hdev->name, status);
 601
 602         if (!status)
 603                 return;
 604
 605         cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
 606         if (!cp)
 607                 return;
 608
 609         handle = __le16_to_cpu(cp->handle);
 610
 611         BT_DBG("%s handle %d", hdev->name, handle);
 612
 613         hci_dev_lock(hdev);
 614
 615         acl = hci_conn_hash_lookup_handle(hdev, handle);
 616         if (acl && (sco = acl->link)) {
 617                 sco->state = BT_CLOSED;
 618
 619                 hci_proto_connect_cfm(sco, status);
 620                 hci_conn_del(sco);
 621         }
 622
 623         hci_dev_unlock(hdev);
 624 }
 625
 626 static void hci_cs_auth_requested(struct hci_dev *hdev, __u8 status)
 627 {
 628         struct hci_cp_auth_requested *cp;
 629         struct hci_conn *conn;
 630
 631         BT_DBG("%s status 0x%x", hdev->name, status);
 632
 633         if (!status)
 634                 return;
 635
 636         cp = hci_sent_cmd_data(hdev, HCI_OP_AUTH_REQUESTED);
 637         if (!cp)
 638                 return;
 639
 640         hci_dev_lock(hdev);
 641
 642         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 643         if (conn) {
 644                 if (conn->state == BT_CONFIG) {
 645                         hci_proto_connect_cfm(conn, status);
 646                         hci_conn_put(conn);
 647                 }
 648         }
 649
 650         hci_dev_unlock(hdev);
 651 }
 652
 653 static void hci_cs_set_conn_encrypt(struct hci_dev *hdev, __u8 status)
 654 {
 655         struct hci_cp_set_conn_encrypt *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_SET_CONN_ENCRYPT);
 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                 if (conn->state == BT_CONFIG) {
 672                         hci_proto_connect_cfm(conn, status);
 673                         hci_conn_put(conn);
 674                 }
 675         }
 676
 677         hci_dev_unlock(hdev);
 678 }
 679
 680 static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
 681 {
 682         BT_DBG("%s status 0x%x", hdev->name, status);
 683 }
 684
 685 static void hci_cs_read_remote_features(struct hci_dev *hdev, __u8 status)
 686 {
 687         struct hci_cp_read_remote_features *cp;
 688         struct hci_conn *conn;
 689
 690         BT_DBG("%s status 0x%x", hdev->name, status);
 691
 692         if (!status)
 693                 return;
 694
 695         cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_FEATURES);
 696         if (!cp)
 697                 return;
 698
 699         hci_dev_lock(hdev);
 700
 701         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 702         if (conn) {
 703                 if (conn->state == BT_CONFIG) {
 704                         hci_proto_connect_cfm(conn, status);
 705                         hci_conn_put(conn);
 706                 }
 707         }
 708
 709         hci_dev_unlock(hdev);
 710 }
 711
 712 static void hci_cs_read_remote_ext_features(struct hci_dev *hdev, __u8 status)
 713 {
 714         struct hci_cp_read_remote_ext_features *cp;
 715         struct hci_conn *conn;
 716
 717         BT_DBG("%s status 0x%x", hdev->name, status);
 718
 719         if (!status)
 720                 return;
 721
 722         cp = hci_sent_cmd_data(hdev, HCI_OP_READ_REMOTE_EXT_FEATURES);
 723         if (!cp)
 724                 return;
 725
 726         hci_dev_lock(hdev);
 727
 728         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 729         if (conn) {
 730                 if (conn->state == BT_CONFIG) {
 731                         hci_proto_connect_cfm(conn, status);
 732                         hci_conn_put(conn);
 733                 }
 734         }
 735
 736         hci_dev_unlock(hdev);
 737 }
 738
 739 static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
 740 {
 741         struct hci_cp_setup_sync_conn *cp;
 742         struct hci_conn *acl, *sco;
 743         __u16 handle;
 744
 745         BT_DBG("%s status 0x%x", hdev->name, status);
 746
 747         if (!status)
 748                 return;
 749
 750         cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
 751         if (!cp)
 752                 return;
 753
 754         handle = __le16_to_cpu(cp->handle);
 755
 756         BT_DBG("%s handle %d", hdev->name, handle);
 757
 758         hci_dev_lock(hdev);
 759
 760         acl = hci_conn_hash_lookup_handle(hdev, handle);
 761         if (acl && (sco = acl->link)) {
 762                 sco->state = BT_CLOSED;
 763
 764                 hci_proto_connect_cfm(sco, status);
 765                 hci_conn_del(sco);
 766         }
 767
 768         hci_dev_unlock(hdev);
 769 }
 770
 771 static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
 772 {
 773         struct hci_cp_sniff_mode *cp;
 774         struct hci_conn *conn;
 775
 776         BT_DBG("%s status 0x%x", hdev->name, status);
 777
 778         if (!status)
 779                 return;
 780
 781         cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
 782         if (!cp)
 783                 return;
 784
 785         hci_dev_lock(hdev);
 786
 787         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 788         if (conn)
 789                 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
 790
 791         hci_dev_unlock(hdev);
 792 }
 793
 794 static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
 795 {
 796         struct hci_cp_exit_sniff_mode *cp;
 797         struct hci_conn *conn;
 798
 799         BT_DBG("%s status 0x%x", hdev->name, status);
 800
 801         if (!status)
 802                 return;
 803
 804         cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
 805         if (!cp)
 806                 return;
 807
 808         hci_dev_lock(hdev);
 809
 810         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 811         if (conn)
 812                 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
 813
 814         hci_dev_unlock(hdev);
 815 }
 816
 817 static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 818 {
 819         __u8 status = *((__u8 *) skb->data);
 820
 821         BT_DBG("%s status %d", hdev->name, status);
 822
 823         clear_bit(HCI_INQUIRY, &hdev->flags);
 824
 825         hci_req_complete(hdev, status);
 826
 827         hci_conn_check_pending(hdev);
 828 }
 829
 830 static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
 831 {
 832         struct inquiry_data data;
 833         struct inquiry_info *info = (void *) (skb->data + 1);
 834         int num_rsp = *((__u8 *) skb->data);
 835
 836         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
 837
 838         if (!num_rsp)
 839                 return;
 840
 841         hci_dev_lock(hdev);
 842
 843         for (; num_rsp; num_rsp--) {
 844                 bacpy(&data.bdaddr, &info->bdaddr);
 845                 data.pscan_rep_mode     = info->pscan_rep_mode;
 846                 data.pscan_period_mode  = info->pscan_period_mode;
 847                 data.pscan_mode         = info->pscan_mode;
 848                 memcpy(data.dev_class, info->dev_class, 3);
 849                 data.clock_offset       = info->clock_offset;
 850                 data.rssi               = 0x00;
 851                 data.ssp_mode           = 0x00;
 852                 info++;
 853                 hci_inquiry_cache_update(hdev, &data);
 854         }
 855
 856         hci_dev_unlock(hdev);
 857 }
 858
 859 static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 860 {
 861         struct hci_ev_conn_complete *ev = (void *) skb->data;
 862         struct hci_conn *conn;
 863
 864         BT_DBG("%s", hdev->name);
 865
 866         hci_dev_lock(hdev);
 867
 868         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 869         if (!conn)
 870                 goto unlock;
 871
 872         if (!ev->status) {
 873                 conn->handle = __le16_to_cpu(ev->handle);
 874
 875                 if (conn->type == ACL_LINK) {
 876                         conn->state = BT_CONFIG;
 877                         hci_conn_hold(conn);
 878                 } else
 879                         conn->state = BT_CONNECTED;
 880
 881                 hci_conn_add_sysfs(conn);
 882
 883                 if (test_bit(HCI_AUTH, &hdev->flags))
 884                         conn->link_mode |= HCI_LM_AUTH;
 885
 886                 if (test_bit(HCI_ENCRYPT, &hdev->flags))
 887                         conn->link_mode |= HCI_LM_ENCRYPT;
 888
 889                 /* Get remote features */
 890                 if (conn->type == ACL_LINK) {
 891                         struct hci_cp_read_remote_features cp;
 892                         cp.handle = ev->handle;
 893                         hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES,
 894                                                         sizeof(cp), &cp);
 895                 }
 896
 897                 /* Set packet type for incoming connection */
 898                 if (!conn->out && hdev->hci_ver < 3) {
 899                         struct hci_cp_change_conn_ptype cp;
 900                         cp.handle = ev->handle;
 901                         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 902                         hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
 903                                                         sizeof(cp), &cp);
 904                 }
 905         } else
 906                 conn->state = BT_CLOSED;
 907
 908         if (conn->type == ACL_LINK) {
 909                 struct hci_conn *sco = conn->link;
 910                 if (sco) {
 911                         if (!ev->status) {
 912                                 if (lmp_esco_capable(hdev))
 913                                         hci_setup_sync(sco, conn->handle);
 914                                 else
 915                                         hci_add_sco(sco, conn->handle);
 916                         } else {
 917                                 hci_proto_connect_cfm(sco, ev->status);
 918                                 hci_conn_del(sco);
 919                         }
 920                 }
 921         }
 922
 923         if (ev->status) {
 924                 hci_proto_connect_cfm(conn, ev->status);
 925                 hci_conn_del(conn);
 926         } else if (ev->link_type != ACL_LINK)
 927                 hci_proto_connect_cfm(conn, ev->status);
 928
 929 unlock:
 930         hci_dev_unlock(hdev);
 931
 932         hci_conn_check_pending(hdev);
 933 }
 934
 935 static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
 936 {
 937         struct hci_ev_conn_request *ev = (void *) skb->data;
 938         int mask = hdev->link_mode;
 939
 940         BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
 941                                         batostr(&ev->bdaddr), ev->link_type);
 942
 943         mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
 944
 945         if (mask & HCI_LM_ACCEPT) {
 946                 /* Connection accepted */
 947                 struct inquiry_entry *ie;
 948                 struct hci_conn *conn;
 949
 950                 hci_dev_lock(hdev);
 951
 952                 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
 953                         memcpy(ie->data.dev_class, ev->dev_class, 3);
 954
 955                 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 956                 if (!conn) {
 957                         if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
 958                                 BT_ERR("No memmory for new connection");
 959                                 hci_dev_unlock(hdev);
 960                                 return;
 961                         }
 962                 }
 963
 964                 memcpy(conn->dev_class, ev->dev_class, 3);
 965                 conn->state = BT_CONNECT;
 966
 967                 hci_dev_unlock(hdev);
 968
 969                 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
 970                         struct hci_cp_accept_conn_req cp;
 971
 972                         bacpy(&cp.bdaddr, &ev->bdaddr);
 973
 974                         if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
 975                                 cp.role = 0x00; /* Become master */
 976                         else
 977                                 cp.role = 0x01; /* Remain slave */
 978
 979                         hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
 980                                                         sizeof(cp), &cp);
 981                 } else {
 982                         struct hci_cp_accept_sync_conn_req cp;
 983
 984                         bacpy(&cp.bdaddr, &ev->bdaddr);
 985                         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 986
 987                         cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 988                         cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 989                         cp.max_latency    = cpu_to_le16(0xffff);
 990                         cp.content_format = cpu_to_le16(hdev->voice_setting);
 991                         cp.retrans_effort = 0xff;
 992
 993                         hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 994                                                         sizeof(cp), &cp);
 995                 }
 996         } else {
 997                 /* Connection rejected */
 998                 struct hci_cp_reject_conn_req cp;
 999
1000                 bacpy(&cp.bdaddr, &ev->bdaddr);
1001                 cp.reason = 0x0f;
1002                 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
1003         }
1004 }
1005
1006 static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1007 {
1008         struct hci_ev_disconn_complete *ev = (void *) skb->data;
1009         struct hci_conn *conn;
1010
1011         BT_DBG("%s status %d", hdev->name, ev->status);
1012
1013         if (ev->status)
1014                 return;
1015
1016         hci_dev_lock(hdev);
1017
1018         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1019         if (conn) {
1020                 conn->state = BT_CLOSED;
1021
1022                 hci_conn_del_sysfs(conn);
1023
1024                 hci_proto_disconn_cfm(conn, ev->reason);
1025                 hci_conn_del(conn);
1026         }
1027
1028         hci_dev_unlock(hdev);
1029 }
1030
1031 static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1032 {
1033         struct hci_ev_auth_complete *ev = (void *) skb->data;
1034         struct hci_conn *conn;
1035
1036         BT_DBG("%s status %d", hdev->name, ev->status);
1037
1038         hci_dev_lock(hdev);
1039
1040         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1041         if (conn) {
1042                 if (!ev->status)
1043                         conn->link_mode |= HCI_LM_AUTH;
1044
1045                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1046
1047                 if (conn->state == BT_CONFIG) {
1048                         if (!ev->status && hdev->ssp_mode > 0 &&
1049                                                         conn->ssp_mode > 0) {
1050                                 struct hci_cp_set_conn_encrypt cp;
1051                                 cp.handle  = ev->handle;
1052                                 cp.encrypt = 0x01;
1053                                 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1054                                                         sizeof(cp), &cp);
1055                         } else {
1056                                 conn->state = BT_CONNECTED;
1057                                 hci_proto_connect_cfm(conn, ev->status);
1058                                 hci_conn_put(conn);
1059                         }
1060                 } else
1061                         hci_auth_cfm(conn, ev->status);
1062
1063                 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
1064                         if (!ev->status) {
1065                                 struct hci_cp_set_conn_encrypt cp;
1066                                 cp.handle  = ev->handle;
1067                                 cp.encrypt = 0x01;
1068                                 hci_send_cmd(hdev, HCI_OP_SET_CONN_ENCRYPT,
1069                                                         sizeof(cp), &cp);
1070                         } else {
1071                                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1072                                 hci_encrypt_cfm(conn, ev->status, 0x00);
1073                         }
1074                 }
1075         }
1076
1077         hci_dev_unlock(hdev);
1078 }
1079
1080 static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
1081 {
1082         BT_DBG("%s", hdev->name);
1083
1084         hci_conn_check_pending(hdev);
1085 }
1086
1087 static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1088 {
1089         struct hci_ev_encrypt_change *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                         if (ev->encrypt) {
1100                                 /* Encryption implies authentication */
1101                                 conn->link_mode |= HCI_LM_AUTH;
1102                                 conn->link_mode |= HCI_LM_ENCRYPT;
1103                         } else
1104                                 conn->link_mode &= ~HCI_LM_ENCRYPT;
1105                 }
1106
1107                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
1108
1109                 if (conn->state == BT_CONFIG) {
1110                         if (!ev->status)
1111                                 conn->state = BT_CONNECTED;
1112
1113                         hci_proto_connect_cfm(conn, ev->status);
1114                         hci_conn_put(conn);
1115                 } else
1116                         hci_encrypt_cfm(conn, ev->status, ev->encrypt);
1117         }
1118
1119         hci_dev_unlock(hdev);
1120 }
1121
1122 static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1123 {
1124         struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
1125         struct hci_conn *conn;
1126
1127         BT_DBG("%s status %d", hdev->name, ev->status);
1128
1129         hci_dev_lock(hdev);
1130
1131         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1132         if (conn) {
1133                 if (!ev->status)
1134                         conn->link_mode |= HCI_LM_SECURE;
1135
1136                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
1137
1138                 hci_key_change_cfm(conn, ev->status);
1139         }
1140
1141         hci_dev_unlock(hdev);
1142 }
1143
1144 static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1145 {
1146         struct hci_ev_remote_features *ev = (void *) skb->data;
1147         struct hci_conn *conn;
1148
1149         BT_DBG("%s status %d", hdev->name, ev->status);
1150
1151         hci_dev_lock(hdev);
1152
1153         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1154         if (conn) {
1155                 if (!ev->status)
1156                         memcpy(conn->features, ev->features, 8);
1157
1158                 if (conn->state == BT_CONFIG) {
1159                         if (!ev->status && lmp_ssp_capable(hdev) &&
1160                                                 lmp_ssp_capable(conn)) {
1161                                 struct hci_cp_read_remote_ext_features cp;
1162                                 cp.handle = ev->handle;
1163                                 cp.page = 0x01;
1164                                 hci_send_cmd(hdev,
1165                                         HCI_OP_READ_REMOTE_EXT_FEATURES,
1166                                                         sizeof(cp), &cp);
1167                         } else {
1168                                 conn->state = BT_CONNECTED;
1169                                 hci_proto_connect_cfm(conn, ev->status);
1170                                 hci_conn_put(conn);
1171                         }
1172                 }
1173         }
1174
1175         hci_dev_unlock(hdev);
1176 }
1177
1178 static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1179 {
1180         BT_DBG("%s", hdev->name);
1181 }
1182
1183 static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1184 {
1185         BT_DBG("%s", hdev->name);
1186 }
1187
1188 static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1189 {
1190         struct hci_ev_cmd_complete *ev = (void *) skb->data;
1191         __u16 opcode;
1192
1193         skb_pull(skb, sizeof(*ev));
1194
1195         opcode = __le16_to_cpu(ev->opcode);
1196
1197         switch (opcode) {
1198         case HCI_OP_INQUIRY_CANCEL:
1199                 hci_cc_inquiry_cancel(hdev, skb);
1200                 break;
1201
1202         case HCI_OP_EXIT_PERIODIC_INQ:
1203                 hci_cc_exit_periodic_inq(hdev, skb);
1204                 break;
1205
1206         case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1207                 hci_cc_remote_name_req_cancel(hdev, skb);
1208                 break;
1209
1210         case HCI_OP_ROLE_DISCOVERY:
1211                 hci_cc_role_discovery(hdev, skb);
1212                 break;
1213
1214         case HCI_OP_READ_LINK_POLICY:
1215                 hci_cc_read_link_policy(hdev, skb);
1216                 break;
1217
1218         case HCI_OP_WRITE_LINK_POLICY:
1219                 hci_cc_write_link_policy(hdev, skb);
1220                 break;
1221
1222         case HCI_OP_READ_DEF_LINK_POLICY:
1223                 hci_cc_read_def_link_policy(hdev, skb);
1224                 break;
1225
1226         case HCI_OP_WRITE_DEF_LINK_POLICY:
1227                 hci_cc_write_def_link_policy(hdev, skb);
1228                 break;
1229
1230         case HCI_OP_RESET:
1231                 hci_cc_reset(hdev, skb);
1232                 break;
1233
1234         case HCI_OP_WRITE_LOCAL_NAME:
1235                 hci_cc_write_local_name(hdev, skb);
1236                 break;
1237
1238         case HCI_OP_READ_LOCAL_NAME:
1239                 hci_cc_read_local_name(hdev, skb);
1240                 break;
1241
1242         case HCI_OP_WRITE_AUTH_ENABLE:
1243                 hci_cc_write_auth_enable(hdev, skb);
1244                 break;
1245
1246         case HCI_OP_WRITE_ENCRYPT_MODE:
1247                 hci_cc_write_encrypt_mode(hdev, skb);
1248                 break;
1249
1250         case HCI_OP_WRITE_SCAN_ENABLE:
1251                 hci_cc_write_scan_enable(hdev, skb);
1252                 break;
1253
1254         case HCI_OP_READ_CLASS_OF_DEV:
1255                 hci_cc_read_class_of_dev(hdev, skb);
1256                 break;
1257
1258         case HCI_OP_WRITE_CLASS_OF_DEV:
1259                 hci_cc_write_class_of_dev(hdev, skb);
1260                 break;
1261
1262         case HCI_OP_READ_VOICE_SETTING:
1263                 hci_cc_read_voice_setting(hdev, skb);
1264                 break;
1265
1266         case HCI_OP_WRITE_VOICE_SETTING:
1267                 hci_cc_write_voice_setting(hdev, skb);
1268                 break;
1269
1270         case HCI_OP_HOST_BUFFER_SIZE:
1271                 hci_cc_host_buffer_size(hdev, skb);
1272                 break;
1273
1274         case HCI_OP_READ_SSP_MODE:
1275                 hci_cc_read_ssp_mode(hdev, skb);
1276                 break;
1277
1278         case HCI_OP_WRITE_SSP_MODE:
1279                 hci_cc_write_ssp_mode(hdev, skb);
1280                 break;
1281
1282         case HCI_OP_READ_LOCAL_VERSION:
1283                 hci_cc_read_local_version(hdev, skb);
1284                 break;
1285
1286         case HCI_OP_READ_LOCAL_COMMANDS:
1287                 hci_cc_read_local_commands(hdev, skb);
1288                 break;
1289
1290         case HCI_OP_READ_LOCAL_FEATURES:
1291                 hci_cc_read_local_features(hdev, skb);
1292                 break;
1293
1294         case HCI_OP_READ_BUFFER_SIZE:
1295                 hci_cc_read_buffer_size(hdev, skb);
1296                 break;
1297
1298         case HCI_OP_READ_BD_ADDR:
1299                 hci_cc_read_bd_addr(hdev, skb);
1300                 break;
1301
1302         default:
1303                 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1304                 break;
1305         }
1306
1307         if (ev->ncmd) {
1308                 atomic_set(&hdev->cmd_cnt, 1);
1309                 if (!skb_queue_empty(&hdev->cmd_q))
1310                         hci_sched_cmd(hdev);
1311         }
1312 }
1313
1314 static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1315 {
1316         struct hci_ev_cmd_status *ev = (void *) skb->data;
1317         __u16 opcode;
1318
1319         skb_pull(skb, sizeof(*ev));
1320
1321         opcode = __le16_to_cpu(ev->opcode);
1322
1323         switch (opcode) {
1324         case HCI_OP_INQUIRY:
1325                 hci_cs_inquiry(hdev, ev->status);
1326                 break;
1327
1328         case HCI_OP_CREATE_CONN:
1329                 hci_cs_create_conn(hdev, ev->status);
1330                 break;
1331
1332         case HCI_OP_ADD_SCO:
1333                 hci_cs_add_sco(hdev, ev->status);
1334                 break;
1335
1336         case HCI_OP_AUTH_REQUESTED:
1337                 hci_cs_auth_requested(hdev, ev->status);
1338                 break;
1339
1340         case HCI_OP_SET_CONN_ENCRYPT:
1341                 hci_cs_set_conn_encrypt(hdev, ev->status);
1342                 break;
1343
1344         case HCI_OP_REMOTE_NAME_REQ:
1345                 hci_cs_remote_name_req(hdev, ev->status);
1346                 break;
1347
1348         case HCI_OP_READ_REMOTE_FEATURES:
1349                 hci_cs_read_remote_features(hdev, ev->status);
1350                 break;
1351
1352         case HCI_OP_READ_REMOTE_EXT_FEATURES:
1353                 hci_cs_read_remote_ext_features(hdev, ev->status);
1354                 break;
1355
1356         case HCI_OP_SETUP_SYNC_CONN:
1357                 hci_cs_setup_sync_conn(hdev, ev->status);
1358                 break;
1359
1360         case HCI_OP_SNIFF_MODE:
1361                 hci_cs_sniff_mode(hdev, ev->status);
1362                 break;
1363
1364         case HCI_OP_EXIT_SNIFF_MODE:
1365                 hci_cs_exit_sniff_mode(hdev, ev->status);
1366                 break;
1367
1368         default:
1369                 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1370                 break;
1371         }
1372
1373         if (ev->ncmd) {
1374                 atomic_set(&hdev->cmd_cnt, 1);
1375                 if (!skb_queue_empty(&hdev->cmd_q))
1376                         hci_sched_cmd(hdev);
1377         }
1378 }
1379
1380 static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1381 {
1382         struct hci_ev_role_change *ev = (void *) skb->data;
1383         struct hci_conn *conn;
1384
1385         BT_DBG("%s status %d", hdev->name, ev->status);
1386
1387         hci_dev_lock(hdev);
1388
1389         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1390         if (conn) {
1391                 if (!ev->status) {
1392                         if (ev->role)
1393                                 conn->link_mode &= ~HCI_LM_MASTER;
1394                         else
1395                                 conn->link_mode |= HCI_LM_MASTER;
1396                 }
1397
1398                 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1399
1400                 hci_role_switch_cfm(conn, ev->status, ev->role);
1401         }
1402
1403         hci_dev_unlock(hdev);
1404 }
1405
1406 static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1407 {
1408         struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1409         __le16 *ptr;
1410         int i;
1411
1412         skb_pull(skb, sizeof(*ev));
1413
1414         BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1415
1416         if (skb->len < ev->num_hndl * 4) {
1417                 BT_DBG("%s bad parameters", hdev->name);
1418                 return;
1419         }
1420
1421         tasklet_disable(&hdev->tx_task);
1422
1423         for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1424                 struct hci_conn *conn;
1425                 __u16  handle, count;
1426
1427                 handle = get_unaligned_le16(ptr++);
1428                 count  = get_unaligned_le16(ptr++);
1429
1430                 conn = hci_conn_hash_lookup_handle(hdev, handle);
1431                 if (conn) {
1432                         conn->sent -= count;
1433
1434                         if (conn->type == ACL_LINK) {
1435                                 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1436                                         hdev->acl_cnt = hdev->acl_pkts;
1437                         } else {
1438                                 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1439                                         hdev->sco_cnt = hdev->sco_pkts;
1440                         }
1441                 }
1442         }
1443
1444         hci_sched_tx(hdev);
1445
1446         tasklet_enable(&hdev->tx_task);
1447 }
1448
1449 static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1450 {
1451         struct hci_ev_mode_change *ev = (void *) skb->data;
1452         struct hci_conn *conn;
1453
1454         BT_DBG("%s status %d", hdev->name, ev->status);
1455
1456         hci_dev_lock(hdev);
1457
1458         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1459         if (conn) {
1460                 conn->mode = ev->mode;
1461                 conn->interval = __le16_to_cpu(ev->interval);
1462
1463                 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1464                         if (conn->mode == HCI_CM_ACTIVE)
1465                                 conn->power_save = 1;
1466                         else
1467                                 conn->power_save = 0;
1468                 }
1469         }
1470
1471         hci_dev_unlock(hdev);
1472 }
1473
1474 static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1475 {
1476         BT_DBG("%s", hdev->name);
1477 }
1478
1479 static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1480 {
1481         BT_DBG("%s", hdev->name);
1482 }
1483
1484 static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1485 {
1486         BT_DBG("%s", hdev->name);
1487 }
1488
1489 static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1490 {
1491         struct hci_ev_clock_offset *ev = (void *) skb->data;
1492         struct hci_conn *conn;
1493
1494         BT_DBG("%s status %d", hdev->name, ev->status);
1495
1496         hci_dev_lock(hdev);
1497
1498         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1499         if (conn && !ev->status) {
1500                 struct inquiry_entry *ie;
1501
1502                 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1503                         ie->data.clock_offset = ev->clock_offset;
1504                         ie->timestamp = jiffies;
1505                 }
1506         }
1507
1508         hci_dev_unlock(hdev);
1509 }
1510
1511 static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1512 {
1513         struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1514         struct hci_conn *conn;
1515
1516         BT_DBG("%s status %d", hdev->name, ev->status);
1517
1518         hci_dev_lock(hdev);
1519
1520         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1521         if (conn && !ev->status)
1522                 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1523
1524         hci_dev_unlock(hdev);
1525 }
1526
1527 static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1528 {
1529         struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
1530         struct inquiry_entry *ie;
1531
1532         BT_DBG("%s", hdev->name);
1533
1534         hci_dev_lock(hdev);
1535
1536         if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1537                 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1538                 ie->timestamp = jiffies;
1539         }
1540
1541         hci_dev_unlock(hdev);
1542 }
1543
1544 static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1545 {
1546         struct inquiry_data data;
1547         int num_rsp = *((__u8 *) skb->data);
1548
1549         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1550
1551         if (!num_rsp)
1552                 return;
1553
1554         hci_dev_lock(hdev);
1555
1556         if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1557                 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1558
1559                 for (; num_rsp; num_rsp--) {
1560                         bacpy(&data.bdaddr, &info->bdaddr);
1561                         data.pscan_rep_mode     = info->pscan_rep_mode;
1562                         data.pscan_period_mode  = info->pscan_period_mode;
1563                         data.pscan_mode         = info->pscan_mode;
1564                         memcpy(data.dev_class, info->dev_class, 3);
1565                         data.clock_offset       = info->clock_offset;
1566                         data.rssi               = info->rssi;
1567                         data.ssp_mode           = 0x00;
1568                         info++;
1569                         hci_inquiry_cache_update(hdev, &data);
1570                 }
1571         } else {
1572                 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1573
1574                 for (; num_rsp; num_rsp--) {
1575                         bacpy(&data.bdaddr, &info->bdaddr);
1576                         data.pscan_rep_mode     = info->pscan_rep_mode;
1577                         data.pscan_period_mode  = info->pscan_period_mode;
1578                         data.pscan_mode         = 0x00;
1579                         memcpy(data.dev_class, info->dev_class, 3);
1580                         data.clock_offset       = info->clock_offset;
1581                         data.rssi               = info->rssi;
1582                         data.ssp_mode           = 0x00;
1583                         info++;
1584                         hci_inquiry_cache_update(hdev, &data);
1585                 }
1586         }
1587
1588         hci_dev_unlock(hdev);
1589 }
1590
1591 static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1592 {
1593         struct hci_ev_remote_ext_features *ev = (void *) skb->data;
1594         struct hci_conn *conn;
1595
1596         BT_DBG("%s", hdev->name);
1597
1598         hci_dev_lock(hdev);
1599
1600         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1601         if (conn) {
1602                 if (!ev->status && ev->page == 0x01) {
1603                         struct inquiry_entry *ie;
1604
1605                         if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)))
1606                                 ie->data.ssp_mode = (ev->features[0] & 0x01);
1607
1608                         conn->ssp_mode = (ev->features[0] & 0x01);
1609                 }
1610
1611                 if (conn->state == BT_CONFIG) {
1612                         if (!ev->status && hdev->ssp_mode > 0 &&
1613                                         conn->ssp_mode > 0 && conn->out &&
1614                                         conn->sec_level != BT_SECURITY_SDP) {
1615                                 struct hci_cp_auth_requested cp;
1616                                 cp.handle = ev->handle;
1617                                 hci_send_cmd(hdev, HCI_OP_AUTH_REQUESTED,
1618                                                         sizeof(cp), &cp);
1619                         } else {
1620                                 conn->state = BT_CONNECTED;
1621                                 hci_proto_connect_cfm(conn, ev->status);
1622                                 hci_conn_put(conn);
1623                         }
1624                 }
1625         }
1626
1627         hci_dev_unlock(hdev);
1628 }
1629
1630 static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1631 {
1632         struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1633         struct hci_conn *conn;
1634
1635         BT_DBG("%s status %d", hdev->name, ev->status);
1636
1637         hci_dev_lock(hdev);
1638
1639         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1640         if (!conn) {
1641                 if (ev->link_type == ESCO_LINK)
1642                         goto unlock;
1643
1644                 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1645                 if (!conn)
1646                         goto unlock;
1647
1648                 conn->type = SCO_LINK;
1649         }
1650
1651         if (conn->out && ev->status == 0x1c && conn->attempt < 2) {
1652                 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
1653                                         (hdev->esco_type & EDR_ESCO_MASK);
1654                 hci_setup_sync(conn, conn->link->handle);
1655                 goto unlock;
1656         }
1657
1658         if (!ev->status) {
1659                 conn->handle = __le16_to_cpu(ev->handle);
1660                 conn->state  = BT_CONNECTED;
1661
1662                 hci_conn_add_sysfs(conn);
1663         } else
1664                 conn->state = BT_CLOSED;
1665
1666         hci_proto_connect_cfm(conn, ev->status);
1667         if (ev->status)
1668                 hci_conn_del(conn);
1669
1670 unlock:
1671         hci_dev_unlock(hdev);
1672 }
1673
1674 static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1675 {
1676         BT_DBG("%s", hdev->name);
1677 }
1678
1679 static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1680 {
1681         struct hci_ev_sniff_subrate *ev = (void *) skb->data;
1682         struct hci_conn *conn;
1683
1684         BT_DBG("%s status %d", hdev->name, ev->status);
1685
1686         hci_dev_lock(hdev);
1687
1688         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1689         if (conn) {
1690         }
1691
1692         hci_dev_unlock(hdev);
1693 }
1694
1695 static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1696 {
1697         struct inquiry_data data;
1698         struct extended_inquiry_info *info = (void *) (skb->data + 1);
1699         int num_rsp = *((__u8 *) skb->data);
1700
1701         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1702
1703         if (!num_rsp)
1704                 return;
1705
1706         hci_dev_lock(hdev);
1707
1708         for (; num_rsp; num_rsp--) {
1709                 bacpy(&data.bdaddr, &info->bdaddr);
1710                 data.pscan_rep_mode     = info->pscan_rep_mode;
1711                 data.pscan_period_mode  = info->pscan_period_mode;
1712                 data.pscan_mode         = 0x00;
1713                 memcpy(data.dev_class, info->dev_class, 3);
1714                 data.clock_offset       = info->clock_offset;
1715                 data.rssi               = info->rssi;
1716                 data.ssp_mode           = 0x01;
1717                 info++;
1718                 hci_inquiry_cache_update(hdev, &data);
1719         }
1720
1721         hci_dev_unlock(hdev);
1722 }
1723
1724 static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1725 {
1726         struct hci_ev_io_capa_request *ev = (void *) skb->data;
1727         struct hci_conn *conn;
1728
1729         BT_DBG("%s", hdev->name);
1730
1731         hci_dev_lock(hdev);
1732
1733         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1734         if (conn)
1735                 hci_conn_hold(conn);
1736
1737         hci_dev_unlock(hdev);
1738 }
1739
1740 static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1741 {
1742         struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
1743         struct hci_conn *conn;
1744
1745         BT_DBG("%s", hdev->name);
1746
1747         hci_dev_lock(hdev);
1748
1749         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1750         if (conn)
1751                 hci_conn_put(conn);
1752
1753         hci_dev_unlock(hdev);
1754 }
1755
1756 static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1757 {
1758         struct hci_ev_remote_host_features *ev = (void *) skb->data;
1759         struct inquiry_entry *ie;
1760
1761         BT_DBG("%s", hdev->name);
1762
1763         hci_dev_lock(hdev);
1764
1765         if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
1766                 ie->data.ssp_mode = (ev->features[0] & 0x01);
1767
1768         hci_dev_unlock(hdev);
1769 }
1770
1771 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1772 {
1773         struct hci_event_hdr *hdr = (void *) skb->data;
1774         __u8 event = hdr->evt;
1775
1776         skb_pull(skb, HCI_EVENT_HDR_SIZE);
1777
1778         switch (event) {
1779         case HCI_EV_INQUIRY_COMPLETE:
1780                 hci_inquiry_complete_evt(hdev, skb);
1781                 break;
1782
1783         case HCI_EV_INQUIRY_RESULT:
1784                 hci_inquiry_result_evt(hdev, skb);
1785                 break;
1786
1787         case HCI_EV_CONN_COMPLETE:
1788                 hci_conn_complete_evt(hdev, skb);
1789                 break;
1790
1791         case HCI_EV_CONN_REQUEST:
1792                 hci_conn_request_evt(hdev, skb);
1793                 break;
1794
1795         case HCI_EV_DISCONN_COMPLETE:
1796                 hci_disconn_complete_evt(hdev, skb);
1797                 break;
1798
1799         case HCI_EV_AUTH_COMPLETE:
1800                 hci_auth_complete_evt(hdev, skb);
1801                 break;
1802
1803         case HCI_EV_REMOTE_NAME:
1804                 hci_remote_name_evt(hdev, skb);
1805                 break;
1806
1807         case HCI_EV_ENCRYPT_CHANGE:
1808                 hci_encrypt_change_evt(hdev, skb);
1809                 break;
1810
1811         case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1812                 hci_change_link_key_complete_evt(hdev, skb);
1813                 break;
1814
1815         case HCI_EV_REMOTE_FEATURES:
1816                 hci_remote_features_evt(hdev, skb);
1817                 break;
1818
1819         case HCI_EV_REMOTE_VERSION:
1820                 hci_remote_version_evt(hdev, skb);
1821                 break;
1822
1823         case HCI_EV_QOS_SETUP_COMPLETE:
1824                 hci_qos_setup_complete_evt(hdev, skb);
1825                 break;
1826
1827         case HCI_EV_CMD_COMPLETE:
1828                 hci_cmd_complete_evt(hdev, skb);
1829                 break;
1830
1831         case HCI_EV_CMD_STATUS:
1832                 hci_cmd_status_evt(hdev, skb);
1833                 break;
1834
1835         case HCI_EV_ROLE_CHANGE:
1836                 hci_role_change_evt(hdev, skb);
1837                 break;
1838
1839         case HCI_EV_NUM_COMP_PKTS:
1840                 hci_num_comp_pkts_evt(hdev, skb);
1841                 break;
1842
1843         case HCI_EV_MODE_CHANGE:
1844                 hci_mode_change_evt(hdev, skb);
1845                 break;
1846
1847         case HCI_EV_PIN_CODE_REQ:
1848                 hci_pin_code_request_evt(hdev, skb);
1849                 break;
1850
1851         case HCI_EV_LINK_KEY_REQ:
1852                 hci_link_key_request_evt(hdev, skb);
1853                 break;
1854
1855         case HCI_EV_LINK_KEY_NOTIFY:
1856                 hci_link_key_notify_evt(hdev, skb);
1857                 break;
1858
1859         case HCI_EV_CLOCK_OFFSET:
1860                 hci_clock_offset_evt(hdev, skb);
1861                 break;
1862
1863         case HCI_EV_PKT_TYPE_CHANGE:
1864                 hci_pkt_type_change_evt(hdev, skb);
1865                 break;
1866
1867         case HCI_EV_PSCAN_REP_MODE:
1868                 hci_pscan_rep_mode_evt(hdev, skb);
1869                 break;
1870
1871         case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1872                 hci_inquiry_result_with_rssi_evt(hdev, skb);
1873                 break;
1874
1875         case HCI_EV_REMOTE_EXT_FEATURES:
1876                 hci_remote_ext_features_evt(hdev, skb);
1877                 break;
1878
1879         case HCI_EV_SYNC_CONN_COMPLETE:
1880                 hci_sync_conn_complete_evt(hdev, skb);
1881                 break;
1882
1883         case HCI_EV_SYNC_CONN_CHANGED:
1884                 hci_sync_conn_changed_evt(hdev, skb);
1885                 break;
1886
1887         case HCI_EV_SNIFF_SUBRATE:
1888                 hci_sniff_subrate_evt(hdev, skb);
1889                 break;
1890
1891         case HCI_EV_EXTENDED_INQUIRY_RESULT:
1892                 hci_extended_inquiry_result_evt(hdev, skb);
1893                 break;
1894
1895         case HCI_EV_IO_CAPA_REQUEST:
1896                 hci_io_capa_request_evt(hdev, skb);
1897                 break;
1898
1899         case HCI_EV_SIMPLE_PAIR_COMPLETE:
1900                 hci_simple_pair_complete_evt(hdev, skb);
1901                 break;
1902
1903         case HCI_EV_REMOTE_HOST_FEATURES:
1904                 hci_remote_host_features_evt(hdev, skb);
1905                 break;
1906
1907         default:
1908                 BT_DBG("%s event 0x%x", hdev->name, event);
1909                 break;
1910         }
1911
1912         kfree_skb(skb);
1913         hdev->stat.evt_rx++;
1914 }
1915
1916 /* Generate internal stack event */
1917 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1918 {
1919         struct hci_event_hdr *hdr;
1920         struct hci_ev_stack_internal *ev;
1921         struct sk_buff *skb;
1922
1923         skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1924         if (!skb)
1925                 return;
1926
1927         hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1928         hdr->evt  = HCI_EV_STACK_INTERNAL;
1929         hdr->plen = sizeof(*ev) + dlen;
1930
1931         ev  = (void *) skb_put(skb, sizeof(*ev) + dlen);
1932         ev->type = type;
1933         memcpy(ev->data, data, dlen);
1934
1935         bt_cb(skb)->incoming = 1;
1936         __net_timestamp(skb);
1937
1938         bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1939         skb->dev = (void *) hdev;
1940         hci_send_to_sock(hdev, skb);
1941         kfree_skb(skb);
1942 }