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                 data.ssp_mode           = 0x00;
 740                 info++;
 741                 hci_inquiry_cache_update(hdev, &data);
 742         }
 743
 744         hci_dev_unlock(hdev);
 745 }
 746
 747 static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 748 {
 749         struct hci_ev_conn_complete *ev = (void *) skb->data;
 750         struct hci_conn *conn;
 751
 752         BT_DBG("%s", hdev->name);
 753
 754         hci_dev_lock(hdev);
 755
 756         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 757         if (!conn)
 758                 goto unlock;
 759
 760         if (!ev->status) {
 761                 conn->handle = __le16_to_cpu(ev->handle);
 762                 conn->state  = BT_CONNECTED;
 763
 764                 if (test_bit(HCI_AUTH, &hdev->flags))
 765                         conn->link_mode |= HCI_LM_AUTH;
 766
 767                 if (test_bit(HCI_ENCRYPT, &hdev->flags))
 768                         conn->link_mode |= HCI_LM_ENCRYPT;
 769
 770                 /* Get remote features */
 771                 if (conn->type == ACL_LINK) {
 772                         struct hci_cp_read_remote_features cp;
 773                         cp.handle = ev->handle;
 774                         hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES, sizeof(cp), &cp);
 775                 }
 776
 777                 /* Set packet type for incoming connection */
 778                 if (!conn->out && hdev->hci_ver < 3) {
 779                         struct hci_cp_change_conn_ptype cp;
 780                         cp.handle = ev->handle;
 781                         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 782                         hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE,
 783                                                         sizeof(cp), &cp);
 784                 } else {
 785                         /* Update disconnect timer */
 786                         hci_conn_hold(conn);
 787                         hci_conn_put(conn);
 788                 }
 789         } else
 790                 conn->state = BT_CLOSED;
 791
 792         if (conn->type == ACL_LINK) {
 793                 struct hci_conn *sco = conn->link;
 794                 if (sco) {
 795                         if (!ev->status) {
 796                                 if (lmp_esco_capable(hdev))
 797                                         hci_setup_sync(sco, conn->handle);
 798                                 else
 799                                         hci_add_sco(sco, conn->handle);
 800                         } else {
 801                                 hci_proto_connect_cfm(sco, ev->status);
 802                                 hci_conn_del(sco);
 803                         }
 804                 }
 805         }
 806
 807         hci_proto_connect_cfm(conn, ev->status);
 808         if (ev->status)
 809                 hci_conn_del(conn);
 810
 811 unlock:
 812         hci_dev_unlock(hdev);
 813
 814         hci_conn_check_pending(hdev);
 815 }
 816
 817 static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
 818 {
 819         struct hci_ev_conn_request *ev = (void *) skb->data;
 820         int mask = hdev->link_mode;
 821
 822         BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
 823                                         batostr(&ev->bdaddr), ev->link_type);
 824
 825         mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
 826
 827         if (mask & HCI_LM_ACCEPT) {
 828                 /* Connection accepted */
 829                 struct inquiry_entry *ie;
 830                 struct hci_conn *conn;
 831
 832                 hci_dev_lock(hdev);
 833
 834                 if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
 835                         memcpy(ie->data.dev_class, ev->dev_class, 3);
 836
 837                 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 838                 if (!conn) {
 839                         if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
 840                                 BT_ERR("No memmory for new connection");
 841                                 hci_dev_unlock(hdev);
 842                                 return;
 843                         }
 844                 }
 845
 846                 memcpy(conn->dev_class, ev->dev_class, 3);
 847                 conn->state = BT_CONNECT;
 848
 849                 hci_dev_unlock(hdev);
 850
 851                 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
 852                         struct hci_cp_accept_conn_req cp;
 853
 854                         bacpy(&cp.bdaddr, &ev->bdaddr);
 855
 856                         if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
 857                                 cp.role = 0x00; /* Become master */
 858                         else
 859                                 cp.role = 0x01; /* Remain slave */
 860
 861                         hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
 862                                                         sizeof(cp), &cp);
 863                 } else {
 864                         struct hci_cp_accept_sync_conn_req cp;
 865
 866                         bacpy(&cp.bdaddr, &ev->bdaddr);
 867                         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 868
 869                         cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 870                         cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 871                         cp.max_latency    = cpu_to_le16(0xffff);
 872                         cp.content_format = cpu_to_le16(hdev->voice_setting);
 873                         cp.retrans_effort = 0xff;
 874
 875                         hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 876                                                         sizeof(cp), &cp);
 877                 }
 878         } else {
 879                 /* Connection rejected */
 880                 struct hci_cp_reject_conn_req cp;
 881
 882                 bacpy(&cp.bdaddr, &ev->bdaddr);
 883                 cp.reason = 0x0f;
 884                 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
 885         }
 886 }
 887
 888 static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 889 {
 890         struct hci_ev_disconn_complete *ev = (void *) skb->data;
 891         struct hci_conn *conn;
 892
 893         BT_DBG("%s status %d", hdev->name, ev->status);
 894
 895         if (ev->status)
 896                 return;
 897
 898         hci_dev_lock(hdev);
 899
 900         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 901         if (conn) {
 902                 conn->state = BT_CLOSED;
 903                 hci_proto_disconn_ind(conn, ev->reason);
 904                 hci_conn_del(conn);
 905         }
 906
 907         hci_dev_unlock(hdev);
 908 }
 909
 910 static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 911 {
 912         struct hci_ev_auth_complete *ev = (void *) skb->data;
 913         struct hci_conn *conn;
 914
 915         BT_DBG("%s status %d", hdev->name, ev->status);
 916
 917         hci_dev_lock(hdev);
 918
 919         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 920         if (conn) {
 921                 if (!ev->status)
 922                         conn->link_mode |= HCI_LM_AUTH;
 923
 924                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
 925
 926                 hci_auth_cfm(conn, ev->status);
 927
 928                 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
 929                         if (!ev->status) {
 930                                 struct hci_cp_set_conn_encrypt cp;
 931                                 cp.handle  = cpu_to_le16(conn->handle);
 932                                 cp.encrypt = 1;
 933                                 hci_send_cmd(conn->hdev,
 934                                         HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
 935                         } else {
 936                                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
 937                                 hci_encrypt_cfm(conn, ev->status, 0x00);
 938                         }
 939                 }
 940         }
 941
 942         hci_dev_unlock(hdev);
 943 }
 944
 945 static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
 946 {
 947         BT_DBG("%s", hdev->name);
 948
 949         hci_conn_check_pending(hdev);
 950 }
 951
 952 static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
 953 {
 954         struct hci_ev_encrypt_change *ev = (void *) skb->data;
 955         struct hci_conn *conn;
 956
 957         BT_DBG("%s status %d", hdev->name, ev->status);
 958
 959         hci_dev_lock(hdev);
 960
 961         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 962         if (conn) {
 963                 if (!ev->status) {
 964                         if (ev->encrypt) {
 965                                 /* Encryption implies authentication */
 966                                 conn->link_mode |= HCI_LM_AUTH;
 967                                 conn->link_mode |= HCI_LM_ENCRYPT;
 968                         } else
 969                                 conn->link_mode &= ~HCI_LM_ENCRYPT;
 970                 }
 971
 972                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
 973
 974                 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
 975         }
 976
 977         hci_dev_unlock(hdev);
 978 }
 979
 980 static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 981 {
 982         struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
 983         struct hci_conn *conn;
 984
 985         BT_DBG("%s status %d", hdev->name, ev->status);
 986
 987         hci_dev_lock(hdev);
 988
 989         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 990         if (conn) {
 991                 if (!ev->status)
 992                         conn->link_mode |= HCI_LM_SECURE;
 993
 994                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
 995
 996                 hci_key_change_cfm(conn, ev->status);
 997         }
 998
 999         hci_dev_unlock(hdev);
1000 }
1001
1002 static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1003 {
1004         struct hci_ev_remote_features *ev = (void *) skb->data;
1005         struct hci_conn *conn;
1006
1007         BT_DBG("%s status %d", hdev->name, ev->status);
1008
1009         if (ev->status)
1010                 return;
1011
1012         hci_dev_lock(hdev);
1013
1014         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1015         if (conn)
1016                 memcpy(conn->features, ev->features, 8);
1017
1018         hci_dev_unlock(hdev);
1019 }
1020
1021 static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
1022 {
1023         BT_DBG("%s", hdev->name);
1024 }
1025
1026 static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1027 {
1028         BT_DBG("%s", hdev->name);
1029 }
1030
1031 static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1032 {
1033         struct hci_ev_cmd_complete *ev = (void *) skb->data;
1034         __u16 opcode;
1035
1036         skb_pull(skb, sizeof(*ev));
1037
1038         opcode = __le16_to_cpu(ev->opcode);
1039
1040         switch (opcode) {
1041         case HCI_OP_INQUIRY_CANCEL:
1042                 hci_cc_inquiry_cancel(hdev, skb);
1043                 break;
1044
1045         case HCI_OP_EXIT_PERIODIC_INQ:
1046                 hci_cc_exit_periodic_inq(hdev, skb);
1047                 break;
1048
1049         case HCI_OP_REMOTE_NAME_REQ_CANCEL:
1050                 hci_cc_remote_name_req_cancel(hdev, skb);
1051                 break;
1052
1053         case HCI_OP_ROLE_DISCOVERY:
1054                 hci_cc_role_discovery(hdev, skb);
1055                 break;
1056
1057         case HCI_OP_READ_LINK_POLICY:
1058                 hci_cc_read_link_policy(hdev, skb);
1059                 break;
1060
1061         case HCI_OP_WRITE_LINK_POLICY:
1062                 hci_cc_write_link_policy(hdev, skb);
1063                 break;
1064
1065         case HCI_OP_READ_DEF_LINK_POLICY:
1066                 hci_cc_read_def_link_policy(hdev, skb);
1067                 break;
1068
1069         case HCI_OP_WRITE_DEF_LINK_POLICY:
1070                 hci_cc_write_def_link_policy(hdev, skb);
1071                 break;
1072
1073         case HCI_OP_RESET:
1074                 hci_cc_reset(hdev, skb);
1075                 break;
1076
1077         case HCI_OP_WRITE_LOCAL_NAME:
1078                 hci_cc_write_local_name(hdev, skb);
1079                 break;
1080
1081         case HCI_OP_READ_LOCAL_NAME:
1082                 hci_cc_read_local_name(hdev, skb);
1083                 break;
1084
1085         case HCI_OP_WRITE_AUTH_ENABLE:
1086                 hci_cc_write_auth_enable(hdev, skb);
1087                 break;
1088
1089         case HCI_OP_WRITE_ENCRYPT_MODE:
1090                 hci_cc_write_encrypt_mode(hdev, skb);
1091                 break;
1092
1093         case HCI_OP_WRITE_SCAN_ENABLE:
1094                 hci_cc_write_scan_enable(hdev, skb);
1095                 break;
1096
1097         case HCI_OP_READ_CLASS_OF_DEV:
1098                 hci_cc_read_class_of_dev(hdev, skb);
1099                 break;
1100
1101         case HCI_OP_WRITE_CLASS_OF_DEV:
1102                 hci_cc_write_class_of_dev(hdev, skb);
1103                 break;
1104
1105         case HCI_OP_READ_VOICE_SETTING:
1106                 hci_cc_read_voice_setting(hdev, skb);
1107                 break;
1108
1109         case HCI_OP_WRITE_VOICE_SETTING:
1110                 hci_cc_write_voice_setting(hdev, skb);
1111                 break;
1112
1113         case HCI_OP_HOST_BUFFER_SIZE:
1114                 hci_cc_host_buffer_size(hdev, skb);
1115                 break;
1116
1117         case HCI_OP_READ_SSP_MODE:
1118                 hci_cc_read_ssp_mode(hdev, skb);
1119                 break;
1120
1121         case HCI_OP_WRITE_SSP_MODE:
1122                 hci_cc_write_ssp_mode(hdev, skb);
1123                 break;
1124
1125         case HCI_OP_READ_LOCAL_VERSION:
1126                 hci_cc_read_local_version(hdev, skb);
1127                 break;
1128
1129         case HCI_OP_READ_LOCAL_COMMANDS:
1130                 hci_cc_read_local_commands(hdev, skb);
1131                 break;
1132
1133         case HCI_OP_READ_LOCAL_FEATURES:
1134                 hci_cc_read_local_features(hdev, skb);
1135                 break;
1136
1137         case HCI_OP_READ_BUFFER_SIZE:
1138                 hci_cc_read_buffer_size(hdev, skb);
1139                 break;
1140
1141         case HCI_OP_READ_BD_ADDR:
1142                 hci_cc_read_bd_addr(hdev, skb);
1143                 break;
1144
1145         default:
1146                 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1147                 break;
1148         }
1149
1150         if (ev->ncmd) {
1151                 atomic_set(&hdev->cmd_cnt, 1);
1152                 if (!skb_queue_empty(&hdev->cmd_q))
1153                         hci_sched_cmd(hdev);
1154         }
1155 }
1156
1157 static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1158 {
1159         struct hci_ev_cmd_status *ev = (void *) skb->data;
1160         __u16 opcode;
1161
1162         skb_pull(skb, sizeof(*ev));
1163
1164         opcode = __le16_to_cpu(ev->opcode);
1165
1166         switch (opcode) {
1167         case HCI_OP_INQUIRY:
1168                 hci_cs_inquiry(hdev, ev->status);
1169                 break;
1170
1171         case HCI_OP_CREATE_CONN:
1172                 hci_cs_create_conn(hdev, ev->status);
1173                 break;
1174
1175         case HCI_OP_ADD_SCO:
1176                 hci_cs_add_sco(hdev, ev->status);
1177                 break;
1178
1179         case HCI_OP_REMOTE_NAME_REQ:
1180                 hci_cs_remote_name_req(hdev, ev->status);
1181                 break;
1182
1183         case HCI_OP_SETUP_SYNC_CONN:
1184                 hci_cs_setup_sync_conn(hdev, ev->status);
1185                 break;
1186
1187         case HCI_OP_SNIFF_MODE:
1188                 hci_cs_sniff_mode(hdev, ev->status);
1189                 break;
1190
1191         case HCI_OP_EXIT_SNIFF_MODE:
1192                 hci_cs_exit_sniff_mode(hdev, ev->status);
1193                 break;
1194
1195         default:
1196                 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1197                 break;
1198         }
1199
1200         if (ev->ncmd) {
1201                 atomic_set(&hdev->cmd_cnt, 1);
1202                 if (!skb_queue_empty(&hdev->cmd_q))
1203                         hci_sched_cmd(hdev);
1204         }
1205 }
1206
1207 static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1208 {
1209         struct hci_ev_role_change *ev = (void *) skb->data;
1210         struct hci_conn *conn;
1211
1212         BT_DBG("%s status %d", hdev->name, ev->status);
1213
1214         hci_dev_lock(hdev);
1215
1216         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1217         if (conn) {
1218                 if (!ev->status) {
1219                         if (ev->role)
1220                                 conn->link_mode &= ~HCI_LM_MASTER;
1221                         else
1222                                 conn->link_mode |= HCI_LM_MASTER;
1223                 }
1224
1225                 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1226
1227                 hci_role_switch_cfm(conn, ev->status, ev->role);
1228         }
1229
1230         hci_dev_unlock(hdev);
1231 }
1232
1233 static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1234 {
1235         struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1236         __le16 *ptr;
1237         int i;
1238
1239         skb_pull(skb, sizeof(*ev));
1240
1241         BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1242
1243         if (skb->len < ev->num_hndl * 4) {
1244                 BT_DBG("%s bad parameters", hdev->name);
1245                 return;
1246         }
1247
1248         tasklet_disable(&hdev->tx_task);
1249
1250         for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1251                 struct hci_conn *conn;
1252                 __u16  handle, count;
1253
1254                 handle = get_unaligned_le16(ptr++);
1255                 count  = get_unaligned_le16(ptr++);
1256
1257                 conn = hci_conn_hash_lookup_handle(hdev, handle);
1258                 if (conn) {
1259                         conn->sent -= count;
1260
1261                         if (conn->type == ACL_LINK) {
1262                                 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1263                                         hdev->acl_cnt = hdev->acl_pkts;
1264                         } else {
1265                                 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1266                                         hdev->sco_cnt = hdev->sco_pkts;
1267                         }
1268                 }
1269         }
1270
1271         hci_sched_tx(hdev);
1272
1273         tasklet_enable(&hdev->tx_task);
1274 }
1275
1276 static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1277 {
1278         struct hci_ev_mode_change *ev = (void *) skb->data;
1279         struct hci_conn *conn;
1280
1281         BT_DBG("%s status %d", hdev->name, ev->status);
1282
1283         hci_dev_lock(hdev);
1284
1285         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1286         if (conn) {
1287                 conn->mode = ev->mode;
1288                 conn->interval = __le16_to_cpu(ev->interval);
1289
1290                 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1291                         if (conn->mode == HCI_CM_ACTIVE)
1292                                 conn->power_save = 1;
1293                         else
1294                                 conn->power_save = 0;
1295                 }
1296         }
1297
1298         hci_dev_unlock(hdev);
1299 }
1300
1301 static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1302 {
1303         BT_DBG("%s", hdev->name);
1304 }
1305
1306 static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1307 {
1308         BT_DBG("%s", hdev->name);
1309 }
1310
1311 static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1312 {
1313         BT_DBG("%s", hdev->name);
1314 }
1315
1316 static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1317 {
1318         struct hci_ev_clock_offset *ev = (void *) skb->data;
1319         struct hci_conn *conn;
1320
1321         BT_DBG("%s status %d", hdev->name, ev->status);
1322
1323         hci_dev_lock(hdev);
1324
1325         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1326         if (conn && !ev->status) {
1327                 struct inquiry_entry *ie;
1328
1329                 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1330                         ie->data.clock_offset = ev->clock_offset;
1331                         ie->timestamp = jiffies;
1332                 }
1333         }
1334
1335         hci_dev_unlock(hdev);
1336 }
1337
1338 static inline void hci_pkt_type_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1339 {
1340         struct hci_ev_pkt_type_change *ev = (void *) skb->data;
1341         struct hci_conn *conn;
1342
1343         BT_DBG("%s status %d", hdev->name, ev->status);
1344
1345         hci_dev_lock(hdev);
1346
1347         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1348         if (conn && !ev->status)
1349                 conn->pkt_type = __le16_to_cpu(ev->pkt_type);
1350
1351         hci_dev_unlock(hdev);
1352 }
1353
1354 static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1355 {
1356         struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
1357         struct inquiry_entry *ie;
1358
1359         BT_DBG("%s", hdev->name);
1360
1361         hci_dev_lock(hdev);
1362
1363         if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1364                 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1365                 ie->timestamp = jiffies;
1366         }
1367
1368         hci_dev_unlock(hdev);
1369 }
1370
1371 static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1372 {
1373         struct inquiry_data data;
1374         int num_rsp = *((__u8 *) skb->data);
1375
1376         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1377
1378         if (!num_rsp)
1379                 return;
1380
1381         hci_dev_lock(hdev);
1382
1383         if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1384                 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1385
1386                 for (; num_rsp; num_rsp--) {
1387                         bacpy(&data.bdaddr, &info->bdaddr);
1388                         data.pscan_rep_mode     = info->pscan_rep_mode;
1389                         data.pscan_period_mode  = info->pscan_period_mode;
1390                         data.pscan_mode         = info->pscan_mode;
1391                         memcpy(data.dev_class, info->dev_class, 3);
1392                         data.clock_offset       = info->clock_offset;
1393                         data.rssi               = info->rssi;
1394                         data.ssp_mode           = 0x00;
1395                         info++;
1396                         hci_inquiry_cache_update(hdev, &data);
1397                 }
1398         } else {
1399                 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1400
1401                 for (; num_rsp; num_rsp--) {
1402                         bacpy(&data.bdaddr, &info->bdaddr);
1403                         data.pscan_rep_mode     = info->pscan_rep_mode;
1404                         data.pscan_period_mode  = info->pscan_period_mode;
1405                         data.pscan_mode         = 0x00;
1406                         memcpy(data.dev_class, info->dev_class, 3);
1407                         data.clock_offset       = info->clock_offset;
1408                         data.rssi               = info->rssi;
1409                         data.ssp_mode           = 0x00;
1410                         info++;
1411                         hci_inquiry_cache_update(hdev, &data);
1412                 }
1413         }
1414
1415         hci_dev_unlock(hdev);
1416 }
1417
1418 static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1419 {
1420         struct hci_ev_remote_ext_features *ev = (void *) skb->data;
1421         struct hci_conn *conn;
1422
1423         BT_DBG("%s", hdev->name);
1424
1425         if (ev->status || ev->page != 0x01)
1426                 return;
1427
1428         hci_dev_lock(hdev);
1429
1430         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1431         if (conn) {
1432                 struct inquiry_entry *ie;
1433
1434                 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)))
1435                         ie->data.ssp_mode = (ev->features[0] & 0x01);
1436
1437                 conn->ssp_mode = (ev->features[0] & 0x01);
1438         }
1439
1440         hci_dev_unlock(hdev);
1441 }
1442
1443 static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1444 {
1445         struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1446         struct hci_conn *conn;
1447
1448         BT_DBG("%s status %d", hdev->name, ev->status);
1449
1450         hci_dev_lock(hdev);
1451
1452         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1453         if (!conn) {
1454                 if (ev->link_type == ESCO_LINK)
1455                         goto unlock;
1456
1457                 conn = hci_conn_hash_lookup_ba(hdev, ESCO_LINK, &ev->bdaddr);
1458                 if (!conn)
1459                         goto unlock;
1460
1461                 conn->type = SCO_LINK;
1462         }
1463
1464         if (!ev->status) {
1465                 conn->handle = __le16_to_cpu(ev->handle);
1466                 conn->state  = BT_CONNECTED;
1467         } else
1468                 conn->state = BT_CLOSED;
1469
1470         hci_proto_connect_cfm(conn, ev->status);
1471         if (ev->status)
1472                 hci_conn_del(conn);
1473
1474 unlock:
1475         hci_dev_unlock(hdev);
1476 }
1477
1478 static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1479 {
1480         BT_DBG("%s", hdev->name);
1481 }
1482
1483 static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1484 {
1485         struct hci_ev_sniff_subrate *ev = (void *) skb->data;
1486         struct hci_conn *conn;
1487
1488         BT_DBG("%s status %d", hdev->name, ev->status);
1489
1490         hci_dev_lock(hdev);
1491
1492         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1493         if (conn) {
1494         }
1495
1496         hci_dev_unlock(hdev);
1497 }
1498
1499 static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1500 {
1501         struct inquiry_data data;
1502         struct extended_inquiry_info *info = (void *) (skb->data + 1);
1503         int num_rsp = *((__u8 *) skb->data);
1504
1505         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1506
1507         if (!num_rsp)
1508                 return;
1509
1510         hci_dev_lock(hdev);
1511
1512         for (; num_rsp; num_rsp--) {
1513                 bacpy(&data.bdaddr, &info->bdaddr);
1514                 data.pscan_rep_mode     = info->pscan_rep_mode;
1515                 data.pscan_period_mode  = info->pscan_period_mode;
1516                 data.pscan_mode         = 0x00;
1517                 memcpy(data.dev_class, info->dev_class, 3);
1518                 data.clock_offset       = info->clock_offset;
1519                 data.rssi               = info->rssi;
1520                 data.ssp_mode           = 0x01;
1521                 info++;
1522                 hci_inquiry_cache_update(hdev, &data);
1523         }
1524
1525         hci_dev_unlock(hdev);
1526 }
1527
1528 static inline void hci_io_capa_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1529 {
1530         struct hci_ev_io_capa_request *ev = (void *) skb->data;
1531         struct hci_conn *conn;
1532
1533         BT_DBG("%s", hdev->name);
1534
1535         hci_dev_lock(hdev);
1536
1537         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1538         if (conn)
1539                 hci_conn_hold(conn);
1540
1541         hci_dev_unlock(hdev);
1542 }
1543
1544 static inline void hci_simple_pair_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1545 {
1546         struct hci_ev_simple_pair_complete *ev = (void *) skb->data;
1547         struct hci_conn *conn;
1548
1549         BT_DBG("%s", hdev->name);
1550
1551         hci_dev_lock(hdev);
1552
1553         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1554         if (conn)
1555                 hci_conn_put(conn);
1556
1557         hci_dev_unlock(hdev);
1558 }
1559
1560 static inline void hci_remote_host_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1561 {
1562         struct hci_ev_remote_host_features *ev = (void *) skb->data;
1563         struct inquiry_entry *ie;
1564
1565         BT_DBG("%s", hdev->name);
1566
1567         hci_dev_lock(hdev);
1568
1569         if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr)))
1570                 ie->data.ssp_mode = (ev->features[0] & 0x01);
1571
1572         hci_dev_unlock(hdev);
1573 }
1574
1575 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1576 {
1577         struct hci_event_hdr *hdr = (void *) skb->data;
1578         __u8 event = hdr->evt;
1579
1580         skb_pull(skb, HCI_EVENT_HDR_SIZE);
1581
1582         switch (event) {
1583         case HCI_EV_INQUIRY_COMPLETE:
1584                 hci_inquiry_complete_evt(hdev, skb);
1585                 break;
1586
1587         case HCI_EV_INQUIRY_RESULT:
1588                 hci_inquiry_result_evt(hdev, skb);
1589                 break;
1590
1591         case HCI_EV_CONN_COMPLETE:
1592                 hci_conn_complete_evt(hdev, skb);
1593                 break;
1594
1595         case HCI_EV_CONN_REQUEST:
1596                 hci_conn_request_evt(hdev, skb);
1597                 break;
1598
1599         case HCI_EV_DISCONN_COMPLETE:
1600                 hci_disconn_complete_evt(hdev, skb);
1601                 break;
1602
1603         case HCI_EV_AUTH_COMPLETE:
1604                 hci_auth_complete_evt(hdev, skb);
1605                 break;
1606
1607         case HCI_EV_REMOTE_NAME:
1608                 hci_remote_name_evt(hdev, skb);
1609                 break;
1610
1611         case HCI_EV_ENCRYPT_CHANGE:
1612                 hci_encrypt_change_evt(hdev, skb);
1613                 break;
1614
1615         case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1616                 hci_change_link_key_complete_evt(hdev, skb);
1617                 break;
1618
1619         case HCI_EV_REMOTE_FEATURES:
1620                 hci_remote_features_evt(hdev, skb);
1621                 break;
1622
1623         case HCI_EV_REMOTE_VERSION:
1624                 hci_remote_version_evt(hdev, skb);
1625                 break;
1626
1627         case HCI_EV_QOS_SETUP_COMPLETE:
1628                 hci_qos_setup_complete_evt(hdev, skb);
1629                 break;
1630
1631         case HCI_EV_CMD_COMPLETE:
1632                 hci_cmd_complete_evt(hdev, skb);
1633                 break;
1634
1635         case HCI_EV_CMD_STATUS:
1636                 hci_cmd_status_evt(hdev, skb);
1637                 break;
1638
1639         case HCI_EV_ROLE_CHANGE:
1640                 hci_role_change_evt(hdev, skb);
1641                 break;
1642
1643         case HCI_EV_NUM_COMP_PKTS:
1644                 hci_num_comp_pkts_evt(hdev, skb);
1645                 break;
1646
1647         case HCI_EV_MODE_CHANGE:
1648                 hci_mode_change_evt(hdev, skb);
1649                 break;
1650
1651         case HCI_EV_PIN_CODE_REQ:
1652                 hci_pin_code_request_evt(hdev, skb);
1653                 break;
1654
1655         case HCI_EV_LINK_KEY_REQ:
1656                 hci_link_key_request_evt(hdev, skb);
1657                 break;
1658
1659         case HCI_EV_LINK_KEY_NOTIFY:
1660                 hci_link_key_notify_evt(hdev, skb);
1661                 break;
1662
1663         case HCI_EV_CLOCK_OFFSET:
1664                 hci_clock_offset_evt(hdev, skb);
1665                 break;
1666
1667         case HCI_EV_PKT_TYPE_CHANGE:
1668                 hci_pkt_type_change_evt(hdev, skb);
1669                 break;
1670
1671         case HCI_EV_PSCAN_REP_MODE:
1672                 hci_pscan_rep_mode_evt(hdev, skb);
1673                 break;
1674
1675         case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1676                 hci_inquiry_result_with_rssi_evt(hdev, skb);
1677                 break;
1678
1679         case HCI_EV_REMOTE_EXT_FEATURES:
1680                 hci_remote_ext_features_evt(hdev, skb);
1681                 break;
1682
1683         case HCI_EV_SYNC_CONN_COMPLETE:
1684                 hci_sync_conn_complete_evt(hdev, skb);
1685                 break;
1686
1687         case HCI_EV_SYNC_CONN_CHANGED:
1688                 hci_sync_conn_changed_evt(hdev, skb);
1689                 break;
1690
1691         case HCI_EV_SNIFF_SUBRATE:
1692                 hci_sniff_subrate_evt(hdev, skb);
1693                 break;
1694
1695         case HCI_EV_EXTENDED_INQUIRY_RESULT:
1696                 hci_extended_inquiry_result_evt(hdev, skb);
1697                 break;
1698
1699         case HCI_EV_IO_CAPA_REQUEST:
1700                 hci_io_capa_request_evt(hdev, skb);
1701                 break;
1702
1703         case HCI_EV_SIMPLE_PAIR_COMPLETE:
1704                 hci_simple_pair_complete_evt(hdev, skb);
1705                 break;
1706
1707         case HCI_EV_REMOTE_HOST_FEATURES:
1708                 hci_remote_host_features_evt(hdev, skb);
1709                 break;
1710
1711         default:
1712                 BT_DBG("%s event 0x%x", hdev->name, event);
1713                 break;
1714         }
1715
1716         kfree_skb(skb);
1717         hdev->stat.evt_rx++;
1718 }
1719
1720 /* Generate internal stack event */
1721 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1722 {
1723         struct hci_event_hdr *hdr;
1724         struct hci_ev_stack_internal *ev;
1725         struct sk_buff *skb;
1726
1727         skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1728         if (!skb)
1729                 return;
1730
1731         hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1732         hdr->evt  = HCI_EV_STACK_INTERNAL;
1733         hdr->plen = sizeof(*ev) + dlen;
1734
1735         ev  = (void *) skb_put(skb, sizeof(*ev) + dlen);
1736         ev->type = type;
1737         memcpy(ev->data, data, dlen);
1738
1739         bt_cb(skb)->incoming = 1;
1740         __net_timestamp(skb);
1741
1742         bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1743         skb->dev = (void *) hdev;
1744         hci_send_to_sock(hdev, skb);
1745         kfree_skb(skb);
1746 }