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/config.h>
  28 #include <linux/module.h>
  29
  30 #include <linux/types.h>
  31 #include <linux/errno.h>
  32 #include <linux/kernel.h>
  33 #include <linux/major.h>
  34 #include <linux/sched.h>
  35 #include <linux/slab.h>
  36 #include <linux/poll.h>
  37 #include <linux/fcntl.h>
  38 #include <linux/init.h>
  39 #include <linux/skbuff.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/notifier.h>
  42 #include <net/sock.h>
  43
  44 #include <asm/system.h>
  45 #include <asm/uaccess.h>
  46 #include <asm/unaligned.h>
  47
  48 #include <net/bluetooth/bluetooth.h>
  49 #include <net/bluetooth/hci_core.h>
  50
  51 #ifndef CONFIG_BT_HCI_CORE_DEBUG
  52 #undef  BT_DBG
  53 #define BT_DBG(D...)
  54 #endif
  55
  56 /* Handle HCI Event packets */
  57
  58 /* Command Complete OGF LINK_CTL  */
  59 static void hci_cc_link_ctl(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
  60 {
  61         __u8 status;
  62
  63         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
  64
  65         switch (ocf) {
  66         case OCF_INQUIRY_CANCEL:
  67                 status = *((__u8 *) skb->data);
  68
  69                 if (status) {
  70                         BT_DBG("%s Inquiry cancel error: status 0x%x", hdev->name, status);
  71                 } else {
  72                         clear_bit(HCI_INQUIRY, &hdev->flags);
  73                         hci_req_complete(hdev, status);
  74                 }
  75                 break;
  76
  77         default:
  78                 BT_DBG("%s Command complete: ogf LINK_CTL ocf %x", hdev->name, ocf);
  79                 break;
  80         }
  81 }
  82
  83 /* Command Complete OGF LINK_POLICY  */
  84 static void hci_cc_link_policy(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
  85 {
  86         struct hci_conn *conn;
  87         struct hci_rp_role_discovery *rd;
  88
  89         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
  90
  91         switch (ocf) {
  92         case OCF_ROLE_DISCOVERY:
  93                 rd = (void *) skb->data;
  94
  95                 if (rd->status)
  96                         break;
  97
  98                 hci_dev_lock(hdev);
  99
 100                 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rd->handle));
 101                 if (conn) {
 102                         if (rd->role)
 103                                 conn->link_mode &= ~HCI_LM_MASTER;
 104                         else
 105                                 conn->link_mode |= HCI_LM_MASTER;
 106                 }
 107
 108                 hci_dev_unlock(hdev);
 109                 break;
 110
 111         default:
 112                 BT_DBG("%s: Command complete: ogf LINK_POLICY ocf %x",
 113                                 hdev->name, ocf);
 114                 break;
 115         }
 116 }
 117
 118 /* Command Complete OGF HOST_CTL  */
 119 static void hci_cc_host_ctl(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
 120 {
 121         __u8 status, param;
 122         __u16 setting;
 123         struct hci_rp_read_voice_setting *vs;
 124         void *sent;
 125
 126         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
 127
 128         switch (ocf) {
 129         case OCF_RESET:
 130                 status = *((__u8 *) skb->data);
 131                 hci_req_complete(hdev, status);
 132                 break;
 133
 134         case OCF_SET_EVENT_FLT:
 135                 status = *((__u8 *) skb->data);
 136                 if (status) {
 137                         BT_DBG("%s SET_EVENT_FLT failed %d", hdev->name, status);
 138                 } else {
 139                         BT_DBG("%s SET_EVENT_FLT succeseful", hdev->name);
 140                 }
 141                 break;
 142
 143         case OCF_WRITE_AUTH_ENABLE:
 144                 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_AUTH_ENABLE);
 145                 if (!sent)
 146                         break;
 147
 148                 status = *((__u8 *) skb->data);
 149                 param  = *((__u8 *) sent);
 150
 151                 if (!status) {
 152                         if (param == AUTH_ENABLED)
 153                                 set_bit(HCI_AUTH, &hdev->flags);
 154                         else
 155                                 clear_bit(HCI_AUTH, &hdev->flags);
 156                 }
 157                 hci_req_complete(hdev, status);
 158                 break;
 159
 160         case OCF_WRITE_ENCRYPT_MODE:
 161                 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_ENCRYPT_MODE);
 162                 if (!sent)
 163                         break;
 164
 165                 status = *((__u8 *) skb->data);
 166                 param  = *((__u8 *) sent);
 167
 168                 if (!status) {
 169                         if (param)
 170                                 set_bit(HCI_ENCRYPT, &hdev->flags);
 171                         else
 172                                 clear_bit(HCI_ENCRYPT, &hdev->flags);
 173                 }
 174                 hci_req_complete(hdev, status);
 175                 break;
 176
 177         case OCF_WRITE_CA_TIMEOUT:
 178                 status = *((__u8 *) skb->data);
 179                 if (status) {
 180                         BT_DBG("%s OCF_WRITE_CA_TIMEOUT failed %d", hdev->name, status);
 181                 } else {
 182                         BT_DBG("%s OCF_WRITE_CA_TIMEOUT succeseful", hdev->name);
 183                 }
 184                 break;
 185
 186         case OCF_WRITE_PG_TIMEOUT:
 187                 status = *((__u8 *) skb->data);
 188                 if (status) {
 189                         BT_DBG("%s OCF_WRITE_PG_TIMEOUT failed %d", hdev->name, status);
 190                 } else {
 191                         BT_DBG("%s: OCF_WRITE_PG_TIMEOUT succeseful", hdev->name);
 192                 }
 193                 break;
 194
 195         case OCF_WRITE_SCAN_ENABLE:
 196                 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE);
 197                 if (!sent)
 198                         break;
 199
 200                 status = *((__u8 *) skb->data);
 201                 param  = *((__u8 *) sent);
 202
 203                 BT_DBG("param 0x%x", param);
 204
 205                 if (!status) {
 206                         clear_bit(HCI_PSCAN, &hdev->flags);
 207                         clear_bit(HCI_ISCAN, &hdev->flags);
 208                         if (param & SCAN_INQUIRY)
 209                                 set_bit(HCI_ISCAN, &hdev->flags);
 210
 211                         if (param & SCAN_PAGE)
 212                                 set_bit(HCI_PSCAN, &hdev->flags);
 213                 }
 214                 hci_req_complete(hdev, status);
 215                 break;
 216
 217         case OCF_READ_VOICE_SETTING:
 218                 vs = (struct hci_rp_read_voice_setting *) skb->data;
 219
 220                 if (vs->status) {
 221                         BT_DBG("%s READ_VOICE_SETTING failed %d", hdev->name, vs->status);
 222                         break;
 223                 }
 224
 225                 setting = __le16_to_cpu(vs->voice_setting);
 226
 227                 if (hdev->voice_setting != setting ) {
 228                         hdev->voice_setting = setting;
 229
 230                         BT_DBG("%s: voice setting 0x%04x", hdev->name, setting);
 231
 232                         if (hdev->notify) {
 233                                 tasklet_disable(&hdev->tx_task);
 234                                 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
 235                                 tasklet_enable(&hdev->tx_task);
 236                         }
 237                 }
 238                 break;
 239
 240         case OCF_WRITE_VOICE_SETTING:
 241                 sent = hci_sent_cmd_data(hdev, OGF_HOST_CTL, OCF_WRITE_VOICE_SETTING);
 242                 if (!sent)
 243                         break;
 244
 245                 status = *((__u8 *) skb->data);
 246                 setting = __le16_to_cpu(get_unaligned((__u16 *) sent));
 247
 248                 if (!status && hdev->voice_setting != setting) {
 249                         hdev->voice_setting = setting;
 250
 251                         BT_DBG("%s: voice setting 0x%04x", hdev->name, setting);
 252
 253                         if (hdev->notify) {
 254                                 tasklet_disable(&hdev->tx_task);
 255                                 hdev->notify(hdev, HCI_NOTIFY_VOICE_SETTING);
 256                                 tasklet_enable(&hdev->tx_task);
 257                         }
 258                 }
 259                 hci_req_complete(hdev, status);
 260                 break;
 261
 262         case OCF_HOST_BUFFER_SIZE:
 263                 status = *((__u8 *) skb->data);
 264                 if (status) {
 265                         BT_DBG("%s OCF_BUFFER_SIZE failed %d", hdev->name, status);
 266                         hci_req_complete(hdev, status);
 267                 }
 268                 break;
 269
 270         default:
 271                 BT_DBG("%s Command complete: ogf HOST_CTL ocf %x", hdev->name, ocf);
 272                 break;
 273         }
 274 }
 275
 276 /* Command Complete OGF INFO_PARAM  */
 277 static void hci_cc_info_param(struct hci_dev *hdev, __u16 ocf, struct sk_buff *skb)
 278 {
 279         struct hci_rp_read_loc_features *lf;
 280         struct hci_rp_read_buffer_size *bs;
 281         struct hci_rp_read_bd_addr *ba;
 282
 283         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
 284
 285         switch (ocf) {
 286         case OCF_READ_LOCAL_FEATURES:
 287                 lf = (struct hci_rp_read_loc_features *) skb->data;
 288
 289                 if (lf->status) {
 290                         BT_DBG("%s READ_LOCAL_FEATURES failed %d", hdev->name, lf->status);
 291                         break;
 292                 }
 293
 294                 memcpy(hdev->features, lf->features, sizeof(hdev->features));
 295
 296                 /* Adjust default settings according to features
 297                  * supported by device. */
 298                 if (hdev->features[0] & LMP_3SLOT)
 299                         hdev->pkt_type |= (HCI_DM3 | HCI_DH3);
 300
 301                 if (hdev->features[0] & LMP_5SLOT)
 302                         hdev->pkt_type |= (HCI_DM5 | HCI_DH5);
 303
 304                 if (hdev->features[1] & LMP_HV2)
 305                         hdev->pkt_type |= (HCI_HV2);
 306
 307                 if (hdev->features[1] & LMP_HV3)
 308                         hdev->pkt_type |= (HCI_HV3);
 309
 310                 BT_DBG("%s: features 0x%x 0x%x 0x%x", hdev->name, lf->features[0], lf->features[1], lf->features[2]);
 311
 312                 break;
 313
 314         case OCF_READ_BUFFER_SIZE:
 315                 bs = (struct hci_rp_read_buffer_size *) skb->data;
 316
 317                 if (bs->status) {
 318                         BT_DBG("%s READ_BUFFER_SIZE failed %d", hdev->name, bs->status);
 319                         hci_req_complete(hdev, bs->status);
 320                         break;
 321                 }
 322
 323                 hdev->acl_mtu  = __le16_to_cpu(bs->acl_mtu);
 324                 hdev->sco_mtu  = bs->sco_mtu ? bs->sco_mtu : 64;
 325                 hdev->acl_pkts = hdev->acl_cnt = __le16_to_cpu(bs->acl_max_pkt);
 326                 hdev->sco_pkts = hdev->sco_cnt = __le16_to_cpu(bs->sco_max_pkt);
 327
 328                 BT_DBG("%s mtu: acl %d, sco %d max_pkt: acl %d, sco %d", hdev->name,
 329                         hdev->acl_mtu, hdev->sco_mtu, hdev->acl_pkts, hdev->sco_pkts);
 330                 break;
 331
 332         case OCF_READ_BD_ADDR:
 333                 ba = (struct hci_rp_read_bd_addr *) skb->data;
 334
 335                 if (!ba->status) {
 336                         bacpy(&hdev->bdaddr, &ba->bdaddr);
 337                 } else {
 338                         BT_DBG("%s: READ_BD_ADDR failed %d", hdev->name, ba->status);
 339                 }
 340
 341                 hci_req_complete(hdev, ba->status);
 342                 break;
 343
 344         default:
 345                 BT_DBG("%s Command complete: ogf INFO_PARAM ocf %x", hdev->name, ocf);
 346                 break;
 347         }
 348 }
 349
 350 /* Command Status OGF LINK_CTL  */
 351 static inline void hci_cs_create_conn(struct hci_dev *hdev, __u8 status)
 352 {
 353         struct hci_conn *conn;
 354         struct hci_cp_create_conn *cp = hci_sent_cmd_data(hdev, OGF_LINK_CTL, OCF_CREATE_CONN);
 355
 356         if (!cp)
 357                 return;
 358
 359         hci_dev_lock(hdev);
 360
 361         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
 362
 363         BT_DBG("%s status 0x%x bdaddr %s conn %p", hdev->name,
 364                         status, batostr(&cp->bdaddr), conn);
 365
 366         if (status) {
 367                 if (conn && conn->state == BT_CONNECT) {
 368                         conn->state = BT_CLOSED;
 369                         hci_proto_connect_cfm(conn, status);
 370                         hci_conn_del(conn);
 371                 }
 372         } else {
 373                 if (!conn) {
 374                         conn = hci_conn_add(hdev, ACL_LINK, &cp->bdaddr);
 375                         if (conn) {
 376                                 conn->out = 1;
 377                                 conn->link_mode |= HCI_LM_MASTER;
 378                         } else
 379                                 BT_ERR("No memmory for new connection");
 380                 }
 381         }
 382
 383         hci_dev_unlock(hdev);
 384 }
 385
 386 static void hci_cs_link_ctl(struct hci_dev *hdev, __u16 ocf, __u8 status)
 387 {
 388         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
 389
 390         switch (ocf) {
 391         case OCF_CREATE_CONN:
 392                 hci_cs_create_conn(hdev, status);
 393                 break;
 394
 395         case OCF_ADD_SCO:
 396                 if (status) {
 397                         struct hci_conn *acl, *sco;
 398                         struct hci_cp_add_sco *cp = hci_sent_cmd_data(hdev, OGF_LINK_CTL, OCF_ADD_SCO);
 399                         __u16 handle;
 400
 401                         if (!cp)
 402                                 break;
 403
 404                         handle = __le16_to_cpu(cp->handle);
 405
 406                         BT_DBG("%s Add SCO error: handle %d status 0x%x", hdev->name, handle, status);
 407
 408                         hci_dev_lock(hdev);
 409
 410                         acl = hci_conn_hash_lookup_handle(hdev, handle);
 411                         if (acl && (sco = acl->link)) {
 412                                 sco->state = BT_CLOSED;
 413
 414                                 hci_proto_connect_cfm(sco, status);
 415                                 hci_conn_del(sco);
 416                         }
 417
 418                         hci_dev_unlock(hdev);
 419                 }
 420                 break;
 421
 422         case OCF_INQUIRY:
 423                 if (status) {
 424                         BT_DBG("%s Inquiry error: status 0x%x", hdev->name, status);
 425                         hci_req_complete(hdev, status);
 426                 } else {
 427                         set_bit(HCI_INQUIRY, &hdev->flags);
 428                 }
 429                 break;
 430
 431         default:
 432                 BT_DBG("%s Command status: ogf LINK_CTL ocf %x status %d",
 433                         hdev->name, ocf, status);
 434                 break;
 435         }
 436 }
 437
 438 /* Command Status OGF LINK_POLICY */
 439 static void hci_cs_link_policy(struct hci_dev *hdev, __u16 ocf, __u8 status)
 440 {
 441         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
 442
 443         switch (ocf) {
 444         default:
 445                 BT_DBG("%s Command status: ogf HOST_POLICY ocf %x", hdev->name, ocf);
 446                 break;
 447         }
 448 }
 449
 450 /* Command Status OGF HOST_CTL */
 451 static void hci_cs_host_ctl(struct hci_dev *hdev, __u16 ocf, __u8 status)
 452 {
 453         BT_DBG("%s ocf 0x%x", hdev->name, ocf);
 454
 455         switch (ocf) {
 456         default:
 457                 BT_DBG("%s Command status: ogf HOST_CTL ocf %x", hdev->name, ocf);
 458                 break;
 459         }
 460 }
 461
 462 /* Command Status OGF INFO_PARAM  */
 463 static void hci_cs_info_param(struct hci_dev *hdev, __u16 ocf, __u8 status)
 464 {
 465         BT_DBG("%s: hci_cs_info_param: ocf 0x%x", hdev->name, ocf);
 466
 467         switch (ocf) {
 468         default:
 469                 BT_DBG("%s Command status: ogf INFO_PARAM ocf %x", hdev->name, ocf);
 470                 break;
 471         }
 472 }
 473
 474 /* Inquiry Complete */
 475 static inline void hci_inquiry_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 476 {
 477         __u8 status = *((__u8 *) skb->data);
 478
 479         BT_DBG("%s status %d", hdev->name, status);
 480
 481         clear_bit(HCI_INQUIRY, &hdev->flags);
 482         hci_req_complete(hdev, status);
 483 }
 484
 485 /* Inquiry Result */
 486 static inline void hci_inquiry_result_evt(struct hci_dev *hdev, struct sk_buff *skb)
 487 {
 488         struct inquiry_info *info = (struct inquiry_info *) (skb->data + 1);
 489         int num_rsp = *((__u8 *) skb->data);
 490
 491         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
 492
 493         hci_dev_lock(hdev);
 494         for (; num_rsp; num_rsp--) {
 495                 struct inquiry_data data;
 496                 bacpy(&data.bdaddr, &info->bdaddr);
 497                 data.pscan_rep_mode     = info->pscan_rep_mode;
 498                 data.pscan_period_mode  = info->pscan_period_mode;
 499                 data.pscan_mode         = info->pscan_mode;
 500                 memcpy(data.dev_class, info->dev_class, 3);
 501                 data.clock_offset       = info->clock_offset;
 502                 data.rssi               = 0x00;
 503                 info++;
 504                 hci_inquiry_cache_update(hdev, &data);
 505         }
 506         hci_dev_unlock(hdev);
 507 }
 508
 509 /* Inquiry Result With RSSI */
 510 static inline void hci_inquiry_result_with_rssi_evt(struct hci_dev *hdev, struct sk_buff *skb)
 511 {
 512         struct inquiry_info_with_rssi *info = (struct inquiry_info_with_rssi *) (skb->data + 1);
 513         int num_rsp = *((__u8 *) skb->data);
 514
 515         BT_DBG("%s num_rsp %d", hdev->name, num_rsp);
 516
 517         hci_dev_lock(hdev);
 518         for (; num_rsp; num_rsp--) {
 519                 struct inquiry_data data;
 520                 bacpy(&data.bdaddr, &info->bdaddr);
 521                 data.pscan_rep_mode     = info->pscan_rep_mode;
 522                 data.pscan_period_mode  = info->pscan_period_mode;
 523                 data.pscan_mode         = 0x00;
 524                 memcpy(data.dev_class, info->dev_class, 3);
 525                 data.clock_offset       = info->clock_offset;
 526                 data.rssi               = info->rssi;
 527                 info++;
 528                 hci_inquiry_cache_update(hdev, &data);
 529         }
 530         hci_dev_unlock(hdev);
 531 }
 532
 533 /* Connect Request */
 534 static inline void hci_conn_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
 535 {
 536         struct hci_ev_conn_request *ev = (struct hci_ev_conn_request *) skb->data;
 537         int mask = hdev->link_mode;
 538
 539         BT_DBG("%s Connection request: %s type 0x%x", hdev->name,
 540                         batostr(&ev->bdaddr), ev->link_type);
 541
 542         mask |= hci_proto_connect_ind(hdev, &ev->bdaddr, ev->link_type);
 543
 544         if (mask & HCI_LM_ACCEPT) {
 545                 /* Connection accepted */
 546                 struct hci_conn *conn;
 547                 struct hci_cp_accept_conn_req cp;
 548
 549                 hci_dev_lock(hdev);
 550                 conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 551                 if (!conn) {
 552                         if (!(conn = hci_conn_add(hdev, ev->link_type, &ev->bdaddr))) {
 553                                 BT_ERR("No memmory for new connection");
 554                                 hci_dev_unlock(hdev);
 555                                 return;
 556                         }
 557                 }
 558                 memcpy(conn->dev_class, ev->dev_class, 3);
 559                 conn->state = BT_CONNECT;
 560                 hci_dev_unlock(hdev);
 561
 562                 bacpy(&cp.bdaddr, &ev->bdaddr);
 563
 564                 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
 565                         cp.role = 0x00; /* Become master */
 566                 else
 567                         cp.role = 0x01; /* Remain slave */
 568
 569                 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ACCEPT_CONN_REQ, sizeof(cp), &cp);
 570         } else {
 571                 /* Connection rejected */
 572                 struct hci_cp_reject_conn_req cp;
 573
 574                 bacpy(&cp.bdaddr, &ev->bdaddr);
 575                 cp.reason = 0x0f;
 576                 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_REJECT_CONN_REQ, sizeof(cp), &cp);
 577         }
 578 }
 579
 580 /* Connect Complete */
 581 static inline void hci_conn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 582 {
 583         struct hci_ev_conn_complete *ev = (struct hci_ev_conn_complete *) skb->data;
 584         struct hci_conn *conn = NULL;
 585
 586         BT_DBG("%s", hdev->name);
 587
 588         hci_dev_lock(hdev);
 589
 590         conn = hci_conn_hash_lookup_ba(hdev, ev->link_type, &ev->bdaddr);
 591         if (!conn) {
 592                 hci_dev_unlock(hdev);
 593                 return;
 594         }
 595
 596         if (!ev->status) {
 597                 conn->handle = __le16_to_cpu(ev->handle);
 598                 conn->state  = BT_CONNECTED;
 599
 600                 if (test_bit(HCI_AUTH, &hdev->flags))
 601                         conn->link_mode |= HCI_LM_AUTH;
 602
 603                 if (test_bit(HCI_ENCRYPT, &hdev->flags))
 604                         conn->link_mode |= HCI_LM_ENCRYPT;
 605
 606                 /* Set link policy */
 607                 if (conn->type == ACL_LINK && hdev->link_policy) {
 608                         struct hci_cp_write_link_policy cp;
 609                         cp.handle = ev->handle;
 610                         cp.policy = __cpu_to_le16(hdev->link_policy);
 611                         hci_send_cmd(hdev, OGF_LINK_POLICY, OCF_WRITE_LINK_POLICY, sizeof(cp), &cp);
 612                 }
 613
 614                 /* Set packet type for incoming connection */
 615                 if (!conn->out) {
 616                         struct hci_cp_change_conn_ptype cp;
 617                         cp.handle = ev->handle;
 618                         cp.pkt_type = (conn->type == ACL_LINK) ?
 619                                 __cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK):
 620                                 __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
 621
 622                         hci_send_cmd(hdev, OGF_LINK_CTL, OCF_CHANGE_CONN_PTYPE, sizeof(cp), &cp);
 623                 }
 624         } else
 625                 conn->state = BT_CLOSED;
 626
 627         if (conn->type == ACL_LINK) {
 628                 struct hci_conn *sco = conn->link;
 629                 if (sco) {
 630                         if (!ev->status)
 631                                 hci_add_sco(sco, conn->handle);
 632                         else {
 633                                 hci_proto_connect_cfm(sco, ev->status);
 634                                 hci_conn_del(sco);
 635                         }
 636                 }
 637         }
 638
 639         hci_proto_connect_cfm(conn, ev->status);
 640         if (ev->status)
 641                 hci_conn_del(conn);
 642
 643         hci_dev_unlock(hdev);
 644 }
 645
 646 /* Disconnect Complete */
 647 static inline void hci_disconn_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 648 {
 649         struct hci_ev_disconn_complete *ev = (struct hci_ev_disconn_complete *) skb->data;
 650         struct hci_conn *conn = NULL;
 651         __u16 handle = __le16_to_cpu(ev->handle);
 652
 653         BT_DBG("%s status %d", hdev->name, ev->status);
 654
 655         if (ev->status)
 656                 return;
 657
 658         hci_dev_lock(hdev);
 659
 660         conn = hci_conn_hash_lookup_handle(hdev, handle);
 661         if (conn) {
 662                 conn->state = BT_CLOSED;
 663                 hci_proto_disconn_ind(conn, ev->reason);
 664                 hci_conn_del(conn);
 665         }
 666
 667         hci_dev_unlock(hdev);
 668 }
 669
 670 /* Number of completed packets */
 671 static inline void hci_num_comp_pkts_evt(struct hci_dev *hdev, struct sk_buff *skb)
 672 {
 673         struct hci_ev_num_comp_pkts *ev = (struct hci_ev_num_comp_pkts *) skb->data;
 674         __u16 *ptr;
 675         int i;
 676
 677         skb_pull(skb, sizeof(*ev));
 678
 679         BT_DBG("%s num_hndl %d", hdev->name, ev->num_hndl);
 680
 681         if (skb->len < ev->num_hndl * 4) {
 682                 BT_DBG("%s bad parameters", hdev->name);
 683                 return;
 684         }
 685
 686         tasklet_disable(&hdev->tx_task);
 687
 688         for (i = 0, ptr = (__u16 *) skb->data; i < ev->num_hndl; i++) {
 689                 struct hci_conn *conn;
 690                 __u16  handle, count;
 691
 692                 handle = __le16_to_cpu(get_unaligned(ptr++));
 693                 count  = __le16_to_cpu(get_unaligned(ptr++));
 694
 695                 conn = hci_conn_hash_lookup_handle(hdev, handle);
 696                 if (conn) {
 697                         conn->sent -= count;
 698
 699                         if (conn->type == SCO_LINK) {
 700                                 if ((hdev->sco_cnt += count) > hdev->sco_pkts)
 701                                         hdev->sco_cnt = hdev->sco_pkts;
 702                         } else {
 703                                 if ((hdev->acl_cnt += count) > hdev->acl_pkts)
 704                                         hdev->acl_cnt = hdev->acl_pkts;
 705                         }
 706                 }
 707         }
 708         hci_sched_tx(hdev);
 709
 710         tasklet_enable(&hdev->tx_task);
 711 }
 712
 713 /* Role Change */
 714 static inline void hci_role_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
 715 {
 716         struct hci_ev_role_change *ev = (struct hci_ev_role_change *) skb->data;
 717         struct hci_conn *conn = NULL;
 718
 719         BT_DBG("%s status %d", hdev->name, ev->status);
 720
 721         hci_dev_lock(hdev);
 722
 723         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &ev->bdaddr);
 724         if (conn) {
 725                 if (!ev->status) {
 726                         if (ev->role)
 727                                 conn->link_mode &= ~HCI_LM_MASTER;
 728                         else
 729                                 conn->link_mode |= HCI_LM_MASTER;
 730                 }
 731
 732                 clear_bit(HCI_CONN_RSWITCH_PEND, &conn->pend);
 733
 734                 hci_role_switch_cfm(conn, ev->status, ev->role);
 735         }
 736
 737         hci_dev_unlock(hdev);
 738 }
 739
 740 /* Authentication Complete */
 741 static inline void hci_auth_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 742 {
 743         struct hci_ev_auth_complete *ev = (struct hci_ev_auth_complete *) skb->data;
 744         struct hci_conn *conn = NULL;
 745         __u16 handle = __le16_to_cpu(ev->handle);
 746
 747         BT_DBG("%s status %d", hdev->name, ev->status);
 748
 749         hci_dev_lock(hdev);
 750
 751         conn = hci_conn_hash_lookup_handle(hdev, handle);
 752         if (conn) {
 753                 if (!ev->status)
 754                         conn->link_mode |= HCI_LM_AUTH;
 755
 756                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
 757
 758                 hci_auth_cfm(conn, ev->status);
 759
 760                 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
 761                         if (!ev->status) {
 762                                 struct hci_cp_set_conn_encrypt cp;
 763                                 cp.handle  = __cpu_to_le16(conn->handle);
 764                                 cp.encrypt = 1;
 765                                 hci_send_cmd(conn->hdev, OGF_LINK_CTL,
 766                                                 OCF_SET_CONN_ENCRYPT,
 767                                                 sizeof(cp), &cp);
 768                         } else {
 769                                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
 770                                 hci_encrypt_cfm(conn, ev->status, 0x00);
 771                         }
 772                 }
 773         }
 774
 775         hci_dev_unlock(hdev);
 776 }
 777
 778 /* Encryption Change */
 779 static inline void hci_encrypt_change_evt(struct hci_dev *hdev, struct sk_buff *skb)
 780 {
 781         struct hci_ev_encrypt_change *ev = (struct hci_ev_encrypt_change *) skb->data;
 782         struct hci_conn *conn = NULL;
 783         __u16 handle = __le16_to_cpu(ev->handle);
 784
 785         BT_DBG("%s status %d", hdev->name, ev->status);
 786
 787         hci_dev_lock(hdev);
 788
 789         conn = hci_conn_hash_lookup_handle(hdev, handle);
 790         if (conn) {
 791                 if (!ev->status) {
 792                         if (ev->encrypt)
 793                                 conn->link_mode |= HCI_LM_ENCRYPT;
 794                         else
 795                                 conn->link_mode &= ~HCI_LM_ENCRYPT;
 796                 }
 797
 798                 clear_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend);
 799
 800                 hci_encrypt_cfm(conn, ev->status, ev->encrypt);
 801         }
 802
 803         hci_dev_unlock(hdev);
 804 }
 805
 806 /* Change Connection Link Key Complete */
 807 static inline void hci_change_conn_link_key_complete_evt(struct hci_dev *hdev, struct sk_buff *skb)
 808 {
 809         struct hci_ev_change_conn_link_key_complete *ev = (struct hci_ev_change_conn_link_key_complete *) skb->data;
 810         struct hci_conn *conn = NULL;
 811         __u16 handle = __le16_to_cpu(ev->handle);
 812
 813         BT_DBG("%s status %d", hdev->name, ev->status);
 814
 815         hci_dev_lock(hdev);
 816
 817         conn = hci_conn_hash_lookup_handle(hdev, handle);
 818         if (conn) {
 819                 if (!ev->status)
 820                         conn->link_mode |= HCI_LM_SECURE;
 821
 822                 clear_bit(HCI_CONN_AUTH_PEND, &conn->pend);
 823
 824                 hci_key_change_cfm(conn, ev->status);
 825         }
 826
 827         hci_dev_unlock(hdev);
 828 }
 829
 830 /* Pin Code Request*/
 831 static inline void hci_pin_code_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
 832 {
 833 }
 834
 835 /* Link Key Request */
 836 static inline void hci_link_key_request_evt(struct hci_dev *hdev, struct sk_buff *skb)
 837 {
 838 }
 839
 840 /* Link Key Notification */
 841 static inline void hci_link_key_notify_evt(struct hci_dev *hdev, struct sk_buff *skb)
 842 {
 843 }
 844
 845 /* Clock Offset */
 846 static inline void hci_clock_offset_evt(struct hci_dev *hdev, struct sk_buff *skb)
 847 {
 848         struct hci_ev_clock_offset *ev = (struct hci_ev_clock_offset *) skb->data;
 849         struct hci_conn *conn = NULL;
 850         __u16 handle = __le16_to_cpu(ev->handle);
 851
 852         BT_DBG("%s status %d", hdev->name, ev->status);
 853
 854         hci_dev_lock(hdev);
 855
 856         conn = hci_conn_hash_lookup_handle(hdev, handle);
 857         if (conn && !ev->status) {
 858                 struct inquiry_entry *ie;
 859
 860                 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
 861                         ie->data.clock_offset = ev->clock_offset;
 862                         ie->timestamp = jiffies;
 863                 }
 864         }
 865
 866         hci_dev_unlock(hdev);
 867 }
 868
 869 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb)
 870 {
 871         struct hci_event_hdr *hdr = (struct hci_event_hdr *) skb->data;
 872         struct hci_ev_cmd_complete *ec;
 873         struct hci_ev_cmd_status *cs;
 874         u16 opcode, ocf, ogf;
 875
 876         skb_pull(skb, HCI_EVENT_HDR_SIZE);
 877
 878         BT_DBG("%s evt 0x%x", hdev->name, hdr->evt);
 879
 880         switch (hdr->evt) {
 881         case HCI_EV_NUM_COMP_PKTS:
 882                 hci_num_comp_pkts_evt(hdev, skb);
 883                 break;
 884
 885         case HCI_EV_INQUIRY_COMPLETE:
 886                 hci_inquiry_complete_evt(hdev, skb);
 887                 break;
 888
 889         case HCI_EV_INQUIRY_RESULT:
 890                 hci_inquiry_result_evt(hdev, skb);
 891                 break;
 892
 893         case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
 894                 hci_inquiry_result_with_rssi_evt(hdev, skb);
 895                 break;
 896
 897         case HCI_EV_CONN_REQUEST:
 898                 hci_conn_request_evt(hdev, skb);
 899                 break;
 900
 901         case HCI_EV_CONN_COMPLETE:
 902                 hci_conn_complete_evt(hdev, skb);
 903                 break;
 904
 905         case HCI_EV_DISCONN_COMPLETE:
 906                 hci_disconn_complete_evt(hdev, skb);
 907                 break;
 908
 909         case HCI_EV_ROLE_CHANGE:
 910                 hci_role_change_evt(hdev, skb);
 911                 break;
 912
 913         case HCI_EV_AUTH_COMPLETE:
 914                 hci_auth_complete_evt(hdev, skb);
 915                 break;
 916
 917         case HCI_EV_ENCRYPT_CHANGE:
 918                 hci_encrypt_change_evt(hdev, skb);
 919                 break;
 920
 921         case HCI_EV_CHANGE_CONN_LINK_KEY_COMPLETE:
 922                 hci_change_conn_link_key_complete_evt(hdev, skb);
 923                 break;
 924
 925         case HCI_EV_PIN_CODE_REQ:
 926                 hci_pin_code_request_evt(hdev, skb);
 927                 break;
 928
 929         case HCI_EV_LINK_KEY_REQ:
 930                 hci_link_key_request_evt(hdev, skb);
 931                 break;
 932
 933         case HCI_EV_LINK_KEY_NOTIFY:
 934                 hci_link_key_notify_evt(hdev, skb);
 935                 break;
 936
 937         case HCI_EV_CLOCK_OFFSET:
 938                 hci_clock_offset_evt(hdev, skb);
 939                 break;
 940
 941         case HCI_EV_CMD_STATUS:
 942                 cs = (struct hci_ev_cmd_status *) skb->data;
 943                 skb_pull(skb, sizeof(cs));
 944
 945                 opcode = __le16_to_cpu(cs->opcode);
 946                 ogf = hci_opcode_ogf(opcode);
 947                 ocf = hci_opcode_ocf(opcode);
 948
 949                 switch (ogf) {
 950                 case OGF_INFO_PARAM:
 951                         hci_cs_info_param(hdev, ocf, cs->status);
 952                         break;
 953
 954                 case OGF_HOST_CTL:
 955                         hci_cs_host_ctl(hdev, ocf, cs->status);
 956                         break;
 957
 958                 case OGF_LINK_CTL:
 959                         hci_cs_link_ctl(hdev, ocf, cs->status);
 960                         break;
 961
 962                 case OGF_LINK_POLICY:
 963                         hci_cs_link_policy(hdev, ocf, cs->status);
 964                         break;
 965
 966                 default:
 967                         BT_DBG("%s Command Status OGF %x", hdev->name, ogf);
 968                         break;
 969                 }
 970
 971                 if (cs->ncmd) {
 972                         atomic_set(&hdev->cmd_cnt, 1);
 973                         if (!skb_queue_empty(&hdev->cmd_q))
 974                                 hci_sched_cmd(hdev);
 975                 }
 976                 break;
 977
 978         case HCI_EV_CMD_COMPLETE:
 979                 ec = (struct hci_ev_cmd_complete *) skb->data;
 980                 skb_pull(skb, sizeof(*ec));
 981
 982                 opcode = __le16_to_cpu(ec->opcode);
 983                 ogf = hci_opcode_ogf(opcode);
 984                 ocf = hci_opcode_ocf(opcode);
 985
 986                 switch (ogf) {
 987                 case OGF_INFO_PARAM:
 988                         hci_cc_info_param(hdev, ocf, skb);
 989                         break;
 990
 991                 case OGF_HOST_CTL:
 992                         hci_cc_host_ctl(hdev, ocf, skb);
 993                         break;
 994
 995                 case OGF_LINK_CTL:
 996                         hci_cc_link_ctl(hdev, ocf, skb);
 997                         break;
 998
 999                 case OGF_LINK_POLICY:
1000                         hci_cc_link_policy(hdev, ocf, skb);
1001                         break;
1002
1003                 default:
1004                         BT_DBG("%s Command Completed OGF %x", hdev->name, ogf);
1005                         break;
1006                 }
1007
1008                 if (ec->ncmd) {
1009                         atomic_set(&hdev->cmd_cnt, 1);
1010                         if (!skb_queue_empty(&hdev->cmd_q))
1011                                 hci_sched_cmd(hdev);
1012                 }
1013                 break;
1014         }
1015
1016         kfree_skb(skb);
1017         hdev->stat.evt_rx++;
1018 }
1019
1020 /* Generate internal stack event */
1021 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
1022 {
1023         struct hci_event_hdr *hdr;
1024         struct hci_ev_stack_internal *ev;
1025         struct sk_buff *skb;
1026
1027         skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
1028         if (!skb)
1029                 return;
1030
1031         hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
1032         hdr->evt  = HCI_EV_STACK_INTERNAL;
1033         hdr->plen = sizeof(*ev) + dlen;
1034
1035         ev  = (void *) skb_put(skb, sizeof(*ev) + dlen);
1036         ev->type = type;
1037         memcpy(ev->data, data, dlen);
1038
1039         skb->pkt_type = HCI_EVENT_PKT;
1040         skb->dev = (void *) hdev;
1041         hci_send_to_sock(hdev, skb);
1042         kfree_skb(skb);
1043 }
1044 EXPORT_SYMBOL(hci_si_event);