git.oblomov.eu Git - linux-2.6/blob - 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_write_link_policy(struct hci_dev *hdev, struct sk_buff *skb)
 114 {
 115         struct hci_rp_write_link_policy *rp = (void *) skb->data;
 116         struct hci_conn *conn;
 117         void *sent;
 118
 119         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 120
 121         if (rp->status)
 122                 return;
 123
 124         sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LINK_POLICY);
 125         if (!sent)
 126                 return;
 127
 128         hci_dev_lock(hdev);
 129
 130         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle));
 131         if (conn) {
 132                 conn->link_policy = get_unaligned_le16(sent + 2);
 133         }
 134
 135         hci_dev_unlock(hdev);
 136 }
 137
 138 static void hci_cc_reset(struct hci_dev *hdev, struct sk_buff *skb)
 139 {
 140         __u8 status = *((__u8 *) skb->data);
 141
 142         BT_DBG("%s status 0x%x", hdev->name, status);
 143
 144         hci_req_complete(hdev, status);
 145 }
 146
 147 static void hci_cc_write_local_name(struct hci_dev *hdev, struct sk_buff *skb)
 148 {
 149         __u8 status = *((__u8 *) skb->data);
 150         void *sent;
 151
 152         BT_DBG("%s status 0x%x", hdev->name, status);
 153
 154         sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_LOCAL_NAME);
 155         if (!sent)
 156                 return;
 157
 158         if (!status)
 159                 memcpy(hdev->dev_name, sent, 248);
 160 }
 161
 162 static void hci_cc_read_local_name(struct hci_dev *hdev, struct sk_buff *skb)
 163 {
 164         struct hci_rp_read_local_name *rp = (void *) skb->data;
 165
 166         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 167
 168         if (rp->status)
 169                 return;
 170
 171         memcpy(hdev->dev_name, rp->name, 248);
 172 }
 173
 174 static void hci_cc_write_auth_enable(struct hci_dev *hdev, struct sk_buff *skb)
 175 {
 176         __u8 status = *((__u8 *) skb->data);
 177         void *sent;
 178
 179         BT_DBG("%s status 0x%x", hdev->name, status);
 180
 181         sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_AUTH_ENABLE);
 182         if (!sent)
 183                 return;
 184
 185         if (!status) {
 186                 __u8 param = *((__u8 *) sent);
 187
 188                 if (param == AUTH_ENABLED)
 189                         set_bit(HCI_AUTH, &hdev->flags);
 190                 else
 191                         clear_bit(HCI_AUTH, &hdev->flags);
 192         }
 193
 194         hci_req_complete(hdev, status);
 195 }
 196
 197 static void hci_cc_write_encrypt_mode(struct hci_dev *hdev, struct sk_buff *skb)
 198 {
 199         __u8 status = *((__u8 *) skb->data);
 200         void *sent;
 201
 202         BT_DBG("%s status 0x%x", hdev->name, status);
 203
 204         sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_ENCRYPT_MODE);
 205         if (!sent)
 206                 return;
 207
 208         if (!status) {
 209                 __u8 param = *((__u8 *) sent);
 210
 211                 if (param)
 212                         set_bit(HCI_ENCRYPT, &hdev->flags);
 213                 else
 214                         clear_bit(HCI_ENCRYPT, &hdev->flags);
 215         }
 216
 217         hci_req_complete(hdev, status);
 218 }
 219
 220 static void hci_cc_write_scan_enable(struct hci_dev *hdev, struct sk_buff *skb)
 221 {
 222         __u8 status = *((__u8 *) skb->data);
 223         void *sent;
 224
 225         BT_DBG("%s status 0x%x", hdev->name, status);
 226
 227         sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_SCAN_ENABLE);
 228         if (!sent)
 229                 return;
 230
 231         if (!status) {
 232                 __u8 param = *((__u8 *) sent);
 233
 234                 clear_bit(HCI_PSCAN, &hdev->flags);
 235                 clear_bit(HCI_ISCAN, &hdev->flags);
 236
 237                 if (param & SCAN_INQUIRY)
 238                         set_bit(HCI_ISCAN, &hdev->flags);
 239
 240                 if (param & SCAN_PAGE)
 241                         set_bit(HCI_PSCAN, &hdev->flags);
 242         }
 243
 244         hci_req_complete(hdev, status);
 245 }
 246
 247 static void hci_cc_read_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
 248 {
 249         struct hci_rp_read_class_of_dev *rp = (void *) skb->data;
 250
 251         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 252
 253         if (rp->status)
 254                 return;
 255
 256         memcpy(hdev->dev_class, rp->dev_class, 3);
 257
 258         BT_DBG("%s class 0x%.2x%.2x%.2x", hdev->name,
 259                 hdev->dev_class[2], hdev->dev_class[1], hdev->dev_class[0]);
 260 }
 261
 262 static void hci_cc_write_class_of_dev(struct hci_dev *hdev, struct sk_buff *skb)
 263 {
 264         __u8 status = *((__u8 *) skb->data);
 265         void *sent;
 266
 267         BT_DBG("%s status 0x%x", hdev->name, status);
 268
 269         sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_CLASS_OF_DEV);
 270         if (!sent)
 271                 return;
 272
 273         if (!status)
 274                 memcpy(hdev->dev_class, sent, 3);
 275 }
 276
 277 static void hci_cc_read_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
 278 {
 279         struct hci_rp_read_voice_setting *rp = (void *) skb->data;
 280         __u16 setting;
 281
 282         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 283
 284         if (rp->status)
 285                 return;
 286
 287         setting = __le16_to_cpu(rp->voice_setting);
 288
 289         if (hdev->voice_setting == setting )
 290                 return;
 291
 292         hdev->voice_setting = setting;
 293
 294         BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
 295
 296         if (hdev->notify) {
 297                 tasklet_disable(&hdev->tx_task);
 298                 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
 299                 tasklet_enable(&hdev->tx_task);
 300         }
 301 }
 302
 303 static void hci_cc_write_voice_setting(struct hci_dev *hdev, struct sk_buff *skb)
 304 {
 305         __u8 status = *((__u8 *) skb->data);
 306         void *sent;
 307
 308         BT_DBG("%s status 0x%x", hdev->name, status);
 309
 310         sent = hci_sent_cmd_data(hdev, HCI_OP_WRITE_VOICE_SETTING);
 311         if (!sent)
 312                 return;
 313
 314         if (!status) {
 315                 __u16 setting = get_unaligned_le16(sent);
 316
 317                 if (hdev->voice_setting != setting) {
 318                         hdev->voice_setting = setting;
 319
 320                         BT_DBG("%s voice setting 0x%04x", hdev->name, setting);
 321
 322                         if (hdev->notify) {
 323                                 tasklet_disable(&hdev->tx_task);
 324                                 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
 325                                 tasklet_enable(&hdev->tx_task);
 326                         }
 327                 }
 328         }
 329 }
 330
 331 static void hci_cc_host_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
 332 {
 333         __u8 status = *((__u8 *) skb->data);
 334
 335         BT_DBG("%s status 0x%x", hdev->name, status);
 336
 337         hci_req_complete(hdev, status);
 338 }
 339
 340 static void hci_cc_read_local_version(struct hci_dev *hdev, struct sk_buff *skb)
 341 {
 342         struct hci_rp_read_local_version *rp = (void *) skb->data;
 343
 344         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 345
 346         if (rp->status)
 347                 return;
 348
 349         hdev->hci_ver = rp->hci_ver;
 350         hdev->hci_rev = btohs(rp->hci_rev);
 351         hdev->manufacturer = btohs(rp->manufacturer);
 352
 353         BT_DBG("%s manufacturer %d hci ver %d:%d", hdev->name,
 354                                         hdev->manufacturer,
 355                                         hdev->hci_ver, hdev->hci_rev);
 356 }
 357
 358 static void hci_cc_read_local_commands(struct hci_dev *hdev, struct sk_buff *skb)
 359 {
 360         struct hci_rp_read_local_commands *rp = (void *) skb->data;
 361
 362         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 363
 364         if (rp->status)
 365                 return;
 366
 367         memcpy(hdev->commands, rp->commands, sizeof(hdev->commands));
 368 }
 369
 370 static void hci_cc_read_local_features(struct hci_dev *hdev, struct sk_buff *skb)
 371 {
 372         struct hci_rp_read_local_features *rp = (void *) skb->data;
 373
 374         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 375
 376         if (rp->status)
 377                 return;
 378
 379         memcpy(hdev->features, rp->features, 8);
 380
 381         /* Adjust default settings according to features
 382          * supported by device. */
 383
 384         if (hdev->features[0] & LMP_3SLOT)
 385                 hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
 386
 387         if (hdev->features[0] & LMP_5SLOT)
 388                 hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
 389
 390         if (hdev->features[1] & LMP_HV2) {
 391                 hdev->pkt_type  |= (HCI_HV2);
 392                 hdev->esco_type |= (ESCO_HV2);
 393         }
 394
 395         if (hdev->features[1] & LMP_HV3) {
 396                 hdev->pkt_type  |= (HCI_HV3);
 397                 hdev->esco_type |= (ESCO_HV3);
 398         }
 399
 400         if (hdev->features[3] & LMP_ESCO)
 401                 hdev->esco_type |= (ESCO_EV3);
 402
 403         if (hdev->features[4] & LMP_EV4)
 404                 hdev->esco_type |= (ESCO_EV4);
 405
 406         if (hdev->features[4] & LMP_EV5)
 407                 hdev->esco_type |= (ESCO_EV5);
 408
 409         BT_DBG("%s features 0x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x", hdev->name,
 410                                         hdev->features[0], hdev->features[1],
 411                                         hdev->features[2], hdev->features[3],
 412                                         hdev->features[4], hdev->features[5],
 413                                         hdev->features[6], hdev->features[7]);
 414 }
 415
 416 static void hci_cc_read_buffer_size(struct hci_dev *hdev, struct sk_buff *skb)
 417 {
 418         struct hci_rp_read_buffer_size *rp = (void *) skb->data;
 419
 420         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 421
 422         if (rp->status)
 423                 return;
 424
 425         hdev->acl_mtu  = __le16_to_cpu(rp->acl_mtu);
 426         hdev->sco_mtu  = rp->sco_mtu;
 427         hdev->acl_pkts = __le16_to_cpu(rp->acl_max_pkt);
 428         hdev->sco_pkts = __le16_to_cpu(rp->sco_max_pkt);
 429
 430         if (test_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks)) {
 431                 hdev->sco_mtu  = 64;
 432                 hdev->sco_pkts = 8;
 433         }
 434
 435         hdev->acl_cnt = hdev->acl_pkts;
 436         hdev->sco_cnt = hdev->sco_pkts;
 437
 438         BT_DBG("%s acl mtu %d:%d sco mtu %d:%d", hdev->name,
 439                                         hdev->acl_mtu, hdev->acl_pkts,
 440                                         hdev->sco_mtu, hdev->sco_pkts);
 441 }
 442
 443 static void hci_cc_read_bd_addr(struct hci_dev *hdev, struct sk_buff *skb)
 444 {
 445         struct hci_rp_read_bd_addr *rp = (void *) skb->data;
 446
 447         BT_DBG("%s status 0x%x", hdev->name, rp->status);
 448
 449         if (!rp->status)
 450                 bacpy(&hdev->bdaddr, &rp->bdaddr);
 451
 452         hci_req_complete(hdev, rp->status);
 453 }
 454
 455 static inline void hci_cs_inquiry(struct hci_dev *hdev, __u8 status)
 456 {
 457         BT_DBG("%s status 0x%x", hdev->name, status);
 458
 459         if (status) {
 460                 hci_req_complete(hdev, status);
 461
 462                 hci_conn_check_pending(hdev);
 463         } else
 464                 set_bit(HCI_INQUIRY, &hdev->flags);
 465 }
 466
 467 static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
 468 {
 469         struct hci_cp_create_conn *cp;
 470         struct hci_conn *conn;
 471
 472         BT_DBG("%s status 0x%x", hdev->name, status);
 473
 474         cp = hci_sent_cmd_data(hdev, HCI_OP_CREATE_CONN);
 475         if (!cp)
 476                 return;
 477
 478         hci_dev_lock(hdev);
 479
 480         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
 481
 482         BT_DBG("%s bdaddr %s conn %p", hdev->name, batostr(&cp->bdaddr), conn);
 483
 484         if (status) {
 485                 if (conn && conn->state == BT_CONNECT) {
 486                         if (status != 0x0c || conn->attempt > 2) {
 487                                 conn->state = BT_CLOSED;
 488                                 hci_proto_connect_cfm(conn, status);
 489                                 hci_conn_del(conn);
 490                         } else
 491                                 conn->state = BT_CONNECT2;
 492                 }
 493         } else {
 494                 if (!conn) {
 495                         conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
 496                         if (conn) {
 497                                 conn->out = 1;
 498                                 conn->link_mode |= HCI_LM_MASTER;
 499                         } else
 500                                 BT_ERR("No memmory for new connection");
 501                 }
 502         }
 503
 504         hci_dev_unlock(hdev);
 505 }
 506
 507 static void hci_cs_add_sco(struct hci_dev *hdev, __u8 status)
 508 {
 509         struct hci_cp_add_sco *cp;
 510         struct hci_conn *acl, *sco;
 511         __u16 handle;
 512
 513         BT_DBG("%s status 0x%x", hdev->name, status);
 514
 515         if (!status)
 516                 return;
 517
 518         cp = hci_sent_cmd_data(hdev, HCI_OP_ADD_SCO);
 519         if (!cp)
 520                 return;
 521
 522         handle = __le16_to_cpu(cp->handle);
 523
 524         BT_DBG("%s handle %d", hdev->name, handle);
 525
 526         hci_dev_lock(hdev);
 527
 528         acl = hci_conn_hash_lookup_handle(hdev, handle);
 529         if (acl && (sco = acl->link)) {
 530                 sco->state = BT_CLOSED;
 531
 532                 hci_proto_connect_cfm(sco, status);
 533                 hci_conn_del(sco);
 534         }
 535
 536         hci_dev_unlock(hdev);
 537 }
 538
 539 static void hci_cs_remote_name_req(struct hci_dev *hdev, __u8 status)
 540 {
 541         BT_DBG("%s status 0x%x", hdev->name, status);
 542 }
 543
 544 static void hci_cs_setup_sync_conn(struct hci_dev *hdev, __u8 status)
 545 {
 546         struct hci_cp_setup_sync_conn *cp;
 547         struct hci_conn *acl, *sco;
 548         __u16 handle;
 549
 550         BT_DBG("%s status 0x%x", hdev->name, status);
 551
 552         if (!status)
 553                 return;
 554
 555         cp = hci_sent_cmd_data(hdev, HCI_OP_SETUP_SYNC_CONN);
 556         if (!cp)
 557                 return;
 558
 559         handle = __le16_to_cpu(cp->handle);
 560
 561         BT_DBG("%s handle %d", hdev->name, handle);
 562
 563         hci_dev_lock(hdev);
 564
 565         acl = hci_conn_hash_lookup_handle(hdev, handle);
 566         if (acl && (sco = acl->link)) {
 567                 sco->state = BT_CLOSED;
 568
 569                 hci_proto_connect_cfm(sco, status);
 570                 hci_conn_del(sco);
 571         }
 572
 573         hci_dev_unlock(hdev);
 574 }
 575
 576 static void hci_cs_sniff_mode(struct hci_dev *hdev, __u8 status)
 577 {
 578         struct hci_cp_sniff_mode *cp;
 579         struct hci_conn *conn;
 580
 581         BT_DBG("%s status 0x%x", hdev->name, status);
 582
 583         if (!status)
 584                 return;
 585
 586         cp = hci_sent_cmd_data(hdev, HCI_OP_SNIFF_MODE);
 587         if (!cp)
 588                 return;
 589
 590         hci_dev_lock(hdev);
 591
 592         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 593         if (conn)
 594                 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
 595
 596         hci_dev_unlock(hdev);
 597 }
 598
 599 static void hci_cs_exit_sniff_mode(struct hci_dev *hdev, __u8 status)
 600 {
 601         struct hci_cp_exit_sniff_mode *cp;
 602         struct hci_conn *conn;
 603
 604         BT_DBG("%s status 0x%x", hdev->name, status);
 605
 606         if (!status)
 607                 return;
 608
 609         cp = hci_sent_cmd_data(hdev, HCI_OP_EXIT_SNIFF_MODE);
 610         if (!cp)
 611                 return;
 612
 613         hci_dev_lock(hdev);
 614
 615         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(cp->handle));
 616         if (conn)
 617                 clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend);
 618
 619         hci_dev_unlock(hdev);
 620 }
 621
 622 static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 623 {
 624         __u8 status = *((__u8 *) skb->data);
 625
 626         BT_DBG("%s status %d", hdev->name, status);
 627
 628         clear_bit(HCI_INQUIRY, &hdev->flags);
 629
 630         hci_req_complete(hdev, status);
 631
 632         hci_conn_check_pending(hdev);
 633 }
 634
 635 static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
 636 {
 637         struct inquiry_data data;
 638         struct inquiry_info *info = (void *) (skb->data + 1);
 639         int num_rsp = *((__u8 *) skb->data);
 640
 641         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
 642
 643         if (!num_rsp)
 644                 return;
 645
 646         hci_dev_lock(hdev);
 647
 648         for (; num_rsp; num_rsp--) {
 649                 bacpy(&data.bdaddr, &info->bdaddr);
 650                 data.pscan_rep_mode     = info->pscan_rep_mode;
 651                 data.pscan_period_mode  = info->pscan_period_mode;
 652                 data.pscan_mode         = info->pscan_mode;
 653                 memcpy(data.dev_class, info->dev_class, 3);
 654                 data.clock_offset       = info->clock_offset;
 655                 data.rssi               = 0x00;
 656                 info++;
 657                 hci_inquiry_cache_update(hdev, &data);
 658         }
 659
 660         hci_dev_unlock(hdev);
 661 }
 662
 663 static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 664 {
 665         struct hci_ev_conn_complete *ev = (void *) skb->data;
 666         struct hci_conn *conn;
 667
 668         BT_DBG("%s", hdev->name);
 669
 670         hci_dev_lock(hdev);
 671
 672         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 673         if (!conn)
 674                 goto unlock;
 675
 676         if (!ev->status) {
 677                 conn->handle = __le16_to_cpu(ev->handle);
 678                 conn->state  = BT_CONNECTED;
 679
 680                 if (test_bit(HCI_AUTH, &hdev->flags))
 681                         conn->link_mode |= HCI_LM_AUTH;
 682
 683                 if (test_bit(HCI_ENCRYPT, &hdev->flags))
 684                         conn->link_mode |= HCI_LM_ENCRYPT;
 685
 686                 /* Get remote features */
 687                 if (conn->type == ACL_LINK) {
 688                         struct hci_cp_read_remote_features cp;
 689                         cp.handle = ev->handle;
 690                         hci_send_cmd(hdev, HCI_OP_READ_REMOTE_FEATURES, sizeof(cp), &cp);
 691                 }
 692
 693                 /* Set link policy */
 694                 if (conn->type == ACL_LINK && hdev->link_policy) {
 695                         struct hci_cp_write_link_policy cp;
 696                         cp.handle = ev->handle;
 697                         cp.policy = cpu_to_le16(hdev->link_policy);
 698                         hci_send_cmd(hdev, HCI_OP_WRITE_LINK_POLICY, sizeof(cp), &cp);
 699                 }
 700
 701                 /* Set packet type for incoming connection */
 702                 if (!conn->out) {
 703                         struct hci_cp_change_conn_ptype cp;
 704                         cp.handle = ev->handle;
 705                         cp.pkt_type = (conn->type == ACL_LINK) ?
 706                                 cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK):
 707                                 cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
 708
 709                         hci_send_cmd(hdev, HCI_OP_CHANGE_CONN_PTYPE, sizeof(cp), &cp);
 710                 } else {
 711                         /* Update disconnect timer */
 712                         hci_conn_hold(conn);
 713                         hci_conn_put(conn);
 714                 }
 715         } else
 716                 conn->state = BT_CLOSED;
 717
 718         if (conn->type == ACL_LINK) {
 719                 struct hci_conn *sco = conn->link;
 720                 if (sco) {
 721                         if (!ev->status) {
 722                                 if (lmp_esco_capable(hdev))
 723                                         hci_setup_sync(sco, conn->handle);
 724                                 else
 725                                         hci_add_sco(sco, conn->handle);
 726                         } else {
 727                                 hci_proto_connect_cfm(sco, ev->status);
 728                                 hci_conn_del(sco);
 729                         }
 730                 }
 731         }
 732
 733         hci_proto_connect_cfm(conn, ev->status);
 734         if (ev->status)
 735                 hci_conn_del(conn);
 736
 737 unlock:
 738         hci_dev_unlock(hdev);
 739
 740         hci_conn_check_pending(hdev);
 741 }
 742
 743 static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
 744 {
 745         struct hci_ev_conn_request *ev = (void *) skb->data;
 746         int mask = hdev->link_mode;
 747
 748         BT_DBG("%s bdaddr %s type 0x%x", hdev->name,
 749                                         batostr(&ev->bdaddr), ev->link_type);
 750
 751         mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
 752
 753         if (mask & HCI_LM_ACCEPT) {
 754                 /* Connection accepted */
 755                 struct hci_conn *conn;
 756
 757                 hci_dev_lock(hdev);
 758
 759                 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 760                 if (!conn) {
 761                         if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
 762                                 BT_ERR("No memmory for new connection");
 763                                 hci_dev_unlock(hdev);
 764                                 return;
 765                         }
 766                 }
 767
 768                 memcpy(conn->dev_class, ev->dev_class, 3);
 769                 conn->state = BT_CONNECT;
 770
 771                 hci_dev_unlock(hdev);
 772
 773                 if (ev->link_type == ACL_LINK || !lmp_esco_capable(hdev)) {
 774                         struct hci_cp_accept_conn_req cp;
 775
 776                         bacpy(&cp.bdaddr, &ev->bdaddr);
 777
 778                         if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
 779                                 cp.role = 0x00; /* Become master */
 780                         else
 781                                 cp.role = 0x01; /* Remain slave */
 782
 783                         hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ,
 784                                                         sizeof(cp), &cp);
 785                 } else {
 786                         struct hci_cp_accept_sync_conn_req cp;
 787
 788                         bacpy(&cp.bdaddr, &ev->bdaddr);
 789                         cp.pkt_type = cpu_to_le16(hdev->esco_type);
 790
 791                         cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 792                         cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 793                         cp.max_latency    = cpu_to_le16(0xffff);
 794                         cp.content_format = cpu_to_le16(hdev->voice_setting);
 795                         cp.retrans_effort = 0xff;
 796
 797                         hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 798                                                         sizeof(cp), &cp);
 799                 }
 800         } else {
 801                 /* Connection rejected */
 802                 struct hci_cp_reject_conn_req cp;
 803
 804                 bacpy(&cp.bdaddr, &ev->bdaddr);
 805                 cp.reason = 0x0f;
 806                 hci_send_cmd(hdev, HCI_OP_REJECT_CONN_REQ, sizeof(cp), &cp);
 807         }
 808 }
 809
 810 static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 811 {
 812         struct hci_ev_disconn_complete *ev = (void *) skb->data;
 813         struct hci_conn *conn;
 814
 815         BT_DBG("%s status %d", hdev->name, ev->status);
 816
 817         if (ev->status)
 818                 return;
 819
 820         hci_dev_lock(hdev);
 821
 822         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 823         if (conn) {
 824                 conn->state = BT_CLOSED;
 825                 hci_proto_disconn_ind(conn, ev->reason);
 826                 hci_conn_del(conn);
 827         }
 828
 829         hci_dev_unlock(hdev);
 830 }
 831
 832 static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 833 {
 834         struct hci_ev_auth_complete *ev = (void *) skb->data;
 835         struct hci_conn *conn;
 836
 837         BT_DBG("%s status %d", hdev->name, ev->status);
 838
 839         hci_dev_lock(hdev);
 840
 841         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 842         if (conn) {
 843                 if (!ev->status)
 844                         conn->link_mode |= HCI_LM_AUTH;
 845
 846                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
 847
 848                 hci_auth_cfm(conn, ev->status);
 849
 850                 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
 851                         if (!ev->status) {
 852                                 struct hci_cp_set_conn_encrypt cp;
 853                                 cp.handle  = cpu_to_le16(conn->handle);
 854                                 cp.encrypt = 1;
 855                                 hci_send_cmd(conn->hdev,
 856                                         HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
 857                         } else {
 858                                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
 859                                 hci_encrypt_cfm(conn, ev->status, 0x00);
 860                         }
 861                 }
 862         }
 863
 864         hci_dev_unlock(hdev);
 865 }
 866
 867 static inline void hci_remote_name_evt(struct hci_dev *hdev, struct sk_buff *skb)
 868 {
 869         BT_DBG("%s", hdev->name);
 870
 871         hci_conn_check_pending(hdev);
 872 }
 873
 874 static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
 875 {
 876         struct hci_ev_encrypt_change *ev = (void *) skb->data;
 877         struct hci_conn *conn;
 878
 879         BT_DBG("%s status %d", hdev->name, ev->status);
 880
 881         hci_dev_lock(hdev);
 882
 883         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 884         if (conn) {
 885                 if (!ev->status) {
 886                         if (ev->encrypt)
 887                                 conn->link_mode |= HCI_LM_ENCRYPT;
 888                         else
 889                                 conn->link_mode &= ~HCI_LM_ENCRYPT;
 890                 }
 891
 892                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
 893
 894                 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
 895         }
 896
 897         hci_dev_unlock(hdev);
 898 }
 899
 900 static inline void hci_change_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 901 {
 902         struct hci_ev_change_link_key_complete *ev = (void *) skb->data;
 903         struct hci_conn *conn;
 904
 905         BT_DBG("%s status %d", hdev->name, ev->status);
 906
 907         hci_dev_lock(hdev);
 908
 909         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 910         if (conn) {
 911                 if (!ev->status)
 912                         conn->link_mode |= HCI_LM_SECURE;
 913
 914                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
 915
 916                 hci_key_change_cfm(conn, ev->status);
 917         }
 918
 919         hci_dev_unlock(hdev);
 920 }
 921
 922 static inline void hci_remote_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
 923 {
 924         struct hci_ev_remote_features *ev = (void *) skb->data;
 925         struct hci_conn *conn;
 926
 927         BT_DBG("%s status %d", hdev->name, ev->status);
 928
 929         if (ev->status)
 930                 return;
 931
 932         hci_dev_lock(hdev);
 933
 934         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
 935         if (conn)
 936                 memcpy(conn->features, ev->features, 8);
 937
 938         hci_dev_unlock(hdev);
 939 }
 940
 941 static inline void hci_remote_version_evt(struct hci_dev *hdev, struct sk_buff *skb)
 942 {
 943         BT_DBG("%s", hdev->name);
 944 }
 945
 946 static inline void hci_qos_setup_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 947 {
 948         BT_DBG("%s", hdev->name);
 949 }
 950
 951 static inline void hci_cmd_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 952 {
 953         struct hci_ev_cmd_complete *ev = (void *) skb->data;
 954         __u16 opcode;
 955
 956         skb_pull(skb, sizeof(*ev));
 957
 958         opcode = __le16_to_cpu(ev->opcode);
 959
 960         switch (opcode) {
 961         case HCI_OP_INQUIRY_CANCEL:
 962                 hci_cc_inquiry_cancel(hdev, skb);
 963                 break;
 964
 965         case HCI_OP_EXIT_PERIODIC_INQ:
 966                 hci_cc_exit_periodic_inq(hdev, skb);
 967                 break;
 968
 969         case HCI_OP_REMOTE_NAME_REQ_CANCEL:
 970                 hci_cc_remote_name_req_cancel(hdev, skb);
 971                 break;
 972
 973         case HCI_OP_ROLE_DISCOVERY:
 974                 hci_cc_role_discovery(hdev, skb);
 975                 break;
 976
 977         case HCI_OP_WRITE_LINK_POLICY:
 978                 hci_cc_write_link_policy(hdev, skb);
 979                 break;
 980
 981         case HCI_OP_RESET:
 982                 hci_cc_reset(hdev, skb);
 983                 break;
 984
 985         case HCI_OP_WRITE_LOCAL_NAME:
 986                 hci_cc_write_local_name(hdev, skb);
 987                 break;
 988
 989         case HCI_OP_READ_LOCAL_NAME:
 990                 hci_cc_read_local_name(hdev, skb);
 991                 break;
 992
 993         case HCI_OP_WRITE_AUTH_ENABLE:
 994                 hci_cc_write_auth_enable(hdev, skb);
 995                 break;
 996
 997         case HCI_OP_WRITE_ENCRYPT_MODE:
 998                 hci_cc_write_encrypt_mode(hdev, skb);
 999                 break;
1000
1001         case HCI_OP_WRITE_SCAN_ENABLE:
1002                 hci_cc_write_scan_enable(hdev, skb);
1003                 break;
1004
1005         case HCI_OP_READ_CLASS_OF_DEV:
1006                 hci_cc_read_class_of_dev(hdev, skb);
1007                 break;
1008
1009         case HCI_OP_WRITE_CLASS_OF_DEV:
1010                 hci_cc_write_class_of_dev(hdev, skb);
1011                 break;
1012
1013         case HCI_OP_READ_VOICE_SETTING:
1014                 hci_cc_read_voice_setting(hdev, skb);
1015                 break;
1016
1017         case HCI_OP_WRITE_VOICE_SETTING:
1018                 hci_cc_write_voice_setting(hdev, skb);
1019                 break;
1020
1021         case HCI_OP_HOST_BUFFER_SIZE:
1022                 hci_cc_host_buffer_size(hdev, skb);
1023                 break;
1024
1025         case HCI_OP_READ_LOCAL_VERSION:
1026                 hci_cc_read_local_version(hdev, skb);
1027                 break;
1028
1029         case HCI_OP_READ_LOCAL_COMMANDS:
1030                 hci_cc_read_local_commands(hdev, skb);
1031                 break;
1032
1033         case HCI_OP_READ_LOCAL_FEATURES:
1034                 hci_cc_read_local_features(hdev, skb);
1035                 break;
1036
1037         case HCI_OP_READ_BUFFER_SIZE:
1038                 hci_cc_read_buffer_size(hdev, skb);
1039                 break;
1040
1041         case HCI_OP_READ_BD_ADDR:
1042                 hci_cc_read_bd_addr(hdev, skb);
1043                 break;
1044
1045         default:
1046                 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1047                 break;
1048         }
1049
1050         if (ev->ncmd) {
1051                 atomic_set(&hdev->cmd_cnt, 1);
1052                 if (!skb_queue_empty(&hdev->cmd_q))
1053                         hci_sched_cmd(hdev);
1054         }
1055 }
1056
1057 static inline void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb)
1058 {
1059         struct hci_ev_cmd_status *ev = (void *) skb->data;
1060         __u16 opcode;
1061
1062         skb_pull(skb, sizeof(*ev));
1063
1064         opcode = __le16_to_cpu(ev->opcode);
1065
1066         switch (opcode) {
1067         case HCI_OP_INQUIRY:
1068                 hci_cs_inquiry(hdev, ev->status);
1069                 break;
1070
1071         case HCI_OP_CREATE_CONN:
1072                 hci_cs_create_conn(hdev, ev->status);
1073                 break;
1074
1075         case HCI_OP_ADD_SCO:
1076                 hci_cs_add_sco(hdev, ev->status);
1077                 break;
1078
1079         case HCI_OP_REMOTE_NAME_REQ:
1080                 hci_cs_remote_name_req(hdev, ev->status);
1081                 break;
1082
1083         case HCI_OP_SETUP_SYNC_CONN:
1084                 hci_cs_setup_sync_conn(hdev, ev->status);
1085                 break;
1086
1087         case HCI_OP_SNIFF_MODE:
1088                 hci_cs_sniff_mode(hdev, ev->status);
1089                 break;
1090
1091         case HCI_OP_EXIT_SNIFF_MODE:
1092                 hci_cs_exit_sniff_mode(hdev, ev->status);
1093                 break;
1094
1095         default:
1096                 BT_DBG("%s opcode 0x%x", hdev->name, opcode);
1097                 break;
1098         }
1099
1100         if (ev->ncmd) {
1101                 atomic_set(&hdev->cmd_cnt, 1);
1102                 if (!skb_queue_empty(&hdev->cmd_q))
1103                         hci_sched_cmd(hdev);
1104         }
1105 }
1106
1107 static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1108 {
1109         struct hci_ev_role_change *ev = (void *) skb->data;
1110         struct hci_conn *conn;
1111
1112         BT_DBG("%s status %d", hdev->name, ev->status);
1113
1114         hci_dev_lock(hdev);
1115
1116         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
1117         if (conn) {
1118                 if (!ev->status) {
1119                         if (ev->role)
1120                                 conn->link_mode &= ~HCI_LM_MASTER;
1121                         else
1122                                 conn->link_mode |= HCI_LM_MASTER;
1123                 }
1124
1125                 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
1126
1127                 hci_role_switch_cfm(conn, ev->status, ev->role);
1128         }
1129
1130         hci_dev_unlock(hdev);
1131 }
1132
1133 static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
1134 {
1135         struct hci_ev_num_comp_pkts *ev = (void *) skb->data;
1136         __le16 *ptr;
1137         int i;
1138
1139         skb_pull(skb, sizeof(*ev));
1140
1141         BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
1142
1143         if (skb->len < ev->num_hndl * 4) {
1144                 BT_DBG("%s bad parameters", hdev->name);
1145                 return;
1146         }
1147
1148         tasklet_disable(&hdev->tx_task);
1149
1150         for (i = 0, ptr = (__le16 *) skb->data; i < ev->num_hndl; i++) {
1151                 struct hci_conn *conn;
1152                 __u16  handle, count;
1153
1154                 handle = get_unaligned_le16(ptr++);
1155                 count  = get_unaligned_le16(ptr++);
1156
1157                 conn = hci_conn_hash_lookup_handle(hdev, handle);
1158                 if (conn) {
1159                         conn->sent -= count;
1160
1161                         if (conn->type == ACL_LINK) {
1162                                 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
1163                                         hdev->acl_cnt = hdev->acl_pkts;
1164                         } else {
1165                                 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
1166                                         hdev->sco_cnt = hdev->sco_pkts;
1167                         }
1168                 }
1169         }
1170
1171         hci_sched_tx(hdev);
1172
1173         tasklet_enable(&hdev->tx_task);
1174 }
1175
1176 static inline void hci_mode_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
1177 {
1178         struct hci_ev_mode_change *ev = (void *) skb->data;
1179         struct hci_conn *conn;
1180
1181         BT_DBG("%s status %d", hdev->name, ev->status);
1182
1183         hci_dev_lock(hdev);
1184
1185         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1186         if (conn) {
1187                 conn->mode = ev->mode;
1188                 conn->interval = __le16_to_cpu(ev->interval);
1189
1190                 if (!test_and_clear_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
1191                         if (conn->mode == HCI_CM_ACTIVE)
1192                                 conn->power_save = 1;
1193                         else
1194                                 conn->power_save = 0;
1195                 }
1196         }
1197
1198         hci_dev_unlock(hdev);
1199 }
1200
1201 static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1202 {
1203         BT_DBG("%s", hdev->name);
1204 }
1205
1206 static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
1207 {
1208         BT_DBG("%s", hdev->name);
1209 }
1210
1211 static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
1212 {
1213         BT_DBG("%s", hdev->name);
1214 }
1215
1216 static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
1217 {
1218         struct hci_ev_clock_offset *ev = (void *) skb->data;
1219         struct hci_conn *conn;
1220
1221         BT_DBG("%s status %d", hdev->name, ev->status);
1222
1223         hci_dev_lock(hdev);
1224
1225         conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(ev->handle));
1226         if (conn && !ev->status) {
1227                 struct inquiry_entry *ie;
1228
1229                 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
1230                         ie->data.clock_offset = ev->clock_offset;
1231                         ie->timestamp = jiffies;
1232                 }
1233         }
1234
1235         hci_dev_unlock(hdev);
1236 }
1237
1238 static inline void hci_pscan_rep_mode_evt(struct hci_dev *hdev, struct sk_buff *skb)
1239 {
1240         struct hci_ev_pscan_rep_mode *ev = (void *) skb->data;
1241         struct inquiry_entry *ie;
1242
1243         BT_DBG("%s", hdev->name);
1244
1245         hci_dev_lock(hdev);
1246
1247         if ((ie = hci_inquiry_cache_lookup(hdev, &ev->bdaddr))) {
1248                 ie->data.pscan_rep_mode = ev->pscan_rep_mode;
1249                 ie->timestamp = jiffies;
1250         }
1251
1252         hci_dev_unlock(hdev);
1253 }
1254
1255 static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
1256 {
1257         struct inquiry_data data;
1258         int num_rsp = *((__u8 *) skb->data);
1259
1260         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1261
1262         if (!num_rsp)
1263                 return;
1264
1265         hci_dev_lock(hdev);
1266
1267         if ((skb->len - 1) / num_rsp != sizeof(struct inquiry_info_with_rssi)) {
1268                 struct inquiry_info_with_rssi_and_pscan_mode *info = (void *) (skb->data + 1);
1269
1270                 for (; num_rsp; num_rsp--) {
1271                         bacpy(&data.bdaddr, &info->bdaddr);
1272                         data.pscan_rep_mode     = info->pscan_rep_mode;
1273                         data.pscan_period_mode  = info->pscan_period_mode;
1274                         data.pscan_mode         = info->pscan_mode;
1275                         memcpy(data.dev_class, info->dev_class, 3);
1276                         data.clock_offset       = info->clock_offset;
1277                         data.rssi               = info->rssi;
1278                         info++;
1279                         hci_inquiry_cache_update(hdev, &data);
1280                 }
1281         } else {
1282                 struct inquiry_info_with_rssi *info = (void *) (skb->data + 1);
1283
1284                 for (; num_rsp; num_rsp--) {
1285                         bacpy(&data.bdaddr, &info->bdaddr);
1286                         data.pscan_rep_mode     = info->pscan_rep_mode;
1287                         data.pscan_period_mode  = info->pscan_period_mode;
1288                         data.pscan_mode         = 0x00;
1289                         memcpy(data.dev_class, info->dev_class, 3);
1290                         data.clock_offset       = info->clock_offset;
1291                         data.rssi               = info->rssi;
1292                         info++;
1293                         hci_inquiry_cache_update(hdev, &data);
1294                 }
1295         }
1296
1297         hci_dev_unlock(hdev);
1298 }
1299
1300 static inline void hci_remote_ext_features_evt(struct hci_dev *hdev, struct sk_buff *skb)
1301 {
1302         BT_DBG("%s", hdev->name);
1303 }
1304
1305 static inline void hci_sync_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
1306 {
1307         struct hci_ev_sync_conn_complete *ev = (void *) skb->data;
1308         struct hci_conn *conn;
1309
1310         BT_DBG("%s status %d", hdev->name, ev->status);
1311
1312         hci_dev_lock(hdev);
1313
1314         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
1315         if (!conn)
1316                 goto unlock;
1317
1318         if (!ev->status) {
1319                 conn->handle = __le16_to_cpu(ev->handle);
1320                 conn->state  = BT_CONNECTED;
1321         } else
1322                 conn->state = BT_CLOSED;
1323
1324         hci_proto_connect_cfm(conn, ev->status);
1325         if (ev->status)
1326                 hci_conn_del(conn);
1327
1328 unlock:
1329         hci_dev_unlock(hdev);
1330 }
1331
1332 static inline void hci_sync_conn_changed_evt(struct hci_dev *hdev, struct sk_buff *skb)
1333 {
1334         BT_DBG("%s", hdev->name);
1335 }
1336
1337 static inline void hci_sniff_subrate_evt(struct hci_dev *hdev, struct sk_buff *skb)
1338 {
1339         struct hci_ev_sniff_subrate *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) {
1348         }
1349
1350         hci_dev_unlock(hdev);
1351 }
1352
1353 static inline void hci_extended_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
1354 {
1355         struct inquiry_data data;
1356         struct extended_inquiry_info *info = (void *) (skb->data + 1);
1357         int num_rsp = *((__u8 *) skb->data);
1358
1359         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
1360
1361         if (!num_rsp)
1362                 return;
1363
1364         hci_dev_lock(hdev);
1365
1366         for (; num_rsp; num_rsp--) {
1367                 bacpy(&data.bdaddr, &info->bdaddr);
1368                 data.pscan_rep_mode     = info->pscan_rep_mode;
1369                 data.pscan_period_mode  = info->pscan_period_mode;
1370                 data.pscan_mode         = 0x00;
1371                 memcpy(data.dev_class, info->dev_class, 3);
1372                 data.clock_offset       = info->clock_offset;
1373                 data.rssi               = info->rssi;
1374                 info++;
1375                 hci_inquiry_cache_update(hdev, &data);
1376         }
1377
1378         hci_dev_unlock(hdev);
1379 }
1380
1381 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
1382 {
1383         struct hci_event_hdr *hdr = (void *) skb->data;
1384         __u8 event = hdr->evt;
1385
1386         skb_pull(skb, HCI_EVENT_HDR_SIZE);
1387
1388         switch (event) {
1389         case HCI_EV_INQUIRY_COMPLETE:
1390                 hci_inquiry_complete_evt(hdev, skb);
1391                 break;
1392
1393         case HCI_EV_INQUIRY_RESULT:
1394                 hci_inquiry_result_evt(hdev, skb);
1395                 break;
1396
1397         case HCI_EV_CONN_COMPLETE:
1398                 hci_conn_complete_evt(hdev, skb);
1399                 break;
1400
1401         case HCI_EV_CONN_REQUEST:
1402                 hci_conn_request_evt(hdev, skb);
1403                 break;
1404
1405         case HCI_EV_DISCONN_COMPLETE:
1406                 hci_disconn_complete_evt(hdev, skb);
1407                 break;
1408
1409         case HCI_EV_AUTH_COMPLETE:
1410                 hci_auth_complete_evt(hdev, skb);
1411                 break;
1412
1413         case HCI_EV_REMOTE_NAME:
1414                 hci_remote_name_evt(hdev, skb);
1415                 break;
1416
1417         case HCI_EV_ENCRYPT_CHANGE:
1418                 hci_encrypt_change_evt(hdev, skb);
1419                 break;
1420
1421         case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
1422                 hci_change_link_key_complete_evt(hdev, skb);
1423                 break;
1424
1425         case HCI_EV_REMOTE_FEATURES:
1426                 hci_remote_features_evt(hdev, skb);
1427                 break;
1428
1429         case HCI_EV_REMOTE_VERSION:
1430                 hci_remote_version_evt(hdev, skb);
1431                 break;
1432
1433         case HCI_EV_QOS_SETUP_COMPLETE:
1434                 hci_qos_setup_complete_evt(hdev, skb);
1435                 break;
1436
1437         case HCI_EV_CMD_COMPLETE:
1438                 hci_cmd_complete_evt(hdev, skb);
1439                 break;
1440
1441         case HCI_EV_CMD_STATUS:
1442                 hci_cmd_status_evt(hdev, skb);
1443                 break;
1444
1445         case HCI_EV_ROLE_CHANGE:
1446                 hci_role_change_evt(hdev, skb);
1447                 break;
1448
1449         case HCI_EV_NUM_COMP_PKTS:
1450                 hci_num_comp_pkts_evt(hdev, skb);
1451                 break;
1452
1453         case HCI_EV_MODE_CHANGE:
1454                 hci_mode_change_evt(hdev, skb);
1455                 break;
1456
1457         case HCI_EV_PIN_CODE_REQ:
1458                 hci_pin_code_request_evt(hdev, skb);
1459                 break;
1460
1461         case HCI_EV_LINK_KEY_REQ:
1462                 hci_link_key_request_evt(hdev, skb);
1463                 break;
1464
1465         case HCI_EV_LINK_KEY_NOTIFY:
1466                 hci_link_key_notify_evt(hdev, skb);
1467                 break;
1468
1469         case HCI_EV_CLOCK_OFFSET:
1470                 hci_clock_offset_evt(hdev, skb);
1471                 break;
1472
1473         case HCI_EV_PSCAN_REP_MODE:
1474                 hci_pscan_rep_mode_evt(hdev, skb);
1475                 break;
1476
1477         case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
1478                 hci_inquiry_result_with_rssi_evt(hdev, skb);
1479                 break;
1480
1481         case HCI_EV_REMOTE_EXT_FEATURES:
1482                 hci_remote_ext_features_evt(hdev, skb);
1483                 break;
1484
1485         case HCI_EV_SYNC_CONN_COMPLETE:
1486                 hci_sync_conn_complete_evt(hdev, skb);
1487                 break;
1488
1489         case HCI_EV_SYNC_CONN_CHANGED:
1490                 hci_sync_conn_changed_evt(hdev, skb);
1491                 break;
1492
1493         case HCI_EV_SNIFF_SUBRATE:
1494                 hci_sniff_subrate_evt(hdev, skb);
1495                 break;
1496
1497         case HCI_EV_EXTENDED_INQUIRY_RESULT:
1498                 hci_extended_inquiry_result_evt(hdev, skb);
1499                 break;
1500
1501         default:
1502                 BT_DBG("%s event 0x%x", hdev->name, event);
1503                 break;
1504         }
1505
1506         kfree_skb(skb);
1507         hdev->stat.evt_rx++;
1508 }
1509
1510 /* Generate internal stack event */
1511 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1512 {
1513         struct hci_event_hdr *hdr;
1514         struct hci_ev_stack_internal *ev;
1515         struct sk_buff *skb;
1516
1517         skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1518         if (!skb)
1519                 return;
1520
1521         hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1522         hdr->evt  = HCI_EV_STACK_INTERNAL;
1523         hdr->plen = sizeof(*ev) + dlen;
1524
1525         ev  = (void *) skb_put(skb, sizeof(*ev) + dlen);
1526         ev->type = type;
1527         memcpy(ev->data, data, dlen);
1528
1529         bt_cb(skb)->incoming = 1;
1530         __net_timestamp(skb);
1531
1532         bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
1533         skb->dev = (void *) hdev;
1534         hci_send_to_sock(hdev, skb);
1535         kfree_skb(skb);
1536 }