net/bluetooth/hci_event.c

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