net/bluetooth/hci_conn.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
   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 connection handling. */
  26
  27 #include <linux/export.h>
  28 #include <linux/debugfs.h>
  29
  30 #include <net/bluetooth/bluetooth.h>
  31 #include <net/bluetooth/hci_core.h>
  32 #include <net/bluetooth/l2cap.h>
  33
  34 #include "hci_request.h"
  35 #include "smp.h"
  36 #include "a2mp.h"
  37
  38 struct sco_param {
  39         u16 pkt_type;
  40         u16 max_latency;
  41         u8  retrans_effort;
  42 };
  43
  44 static const struct sco_param esco_param_cvsd[] = {
  45         { EDR_ESCO_MASK & ~ESCO_2EV3, 0x000a,   0x01 }, /* S3 */
  46         { EDR_ESCO_MASK & ~ESCO_2EV3, 0x0007,   0x01 }, /* S2 */
  47         { EDR_ESCO_MASK | ESCO_EV3,   0x0007,   0x01 }, /* S1 */
  48         { EDR_ESCO_MASK | ESCO_HV3,   0xffff,   0x01 }, /* D1 */
  49         { EDR_ESCO_MASK | ESCO_HV1,   0xffff,   0x01 }, /* D0 */
  50 };
  51
  52 static const struct sco_param sco_param_cvsd[] = {
  53         { EDR_ESCO_MASK | ESCO_HV3,   0xffff,   0xff }, /* D1 */
  54         { EDR_ESCO_MASK | ESCO_HV1,   0xffff,   0xff }, /* D0 */
  55 };
  56
  57 static const struct sco_param esco_param_msbc[] = {
  58         { EDR_ESCO_MASK & ~ESCO_2EV3, 0x000d,   0x02 }, /* T2 */
  59         { EDR_ESCO_MASK | ESCO_EV3,   0x0008,   0x02 }, /* T1 */
  60 };
  61
  62 /* This function requires the caller holds hdev->lock */
  63 static void hci_connect_le_scan_cleanup(struct hci_conn *conn)
  64 {
  65         struct hci_conn_params *params;
  66         struct hci_dev *hdev = conn->hdev;
  67         struct smp_irk *irk;
  68         bdaddr_t *bdaddr;
  69         u8 bdaddr_type;
  70
  71         bdaddr = &conn->dst;
  72         bdaddr_type = conn->dst_type;
  73
  74         /* Check if we need to convert to identity address */
  75         irk = hci_get_irk(hdev, bdaddr, bdaddr_type);
  76         if (irk) {
  77                 bdaddr = &irk->bdaddr;
  78                 bdaddr_type = irk->addr_type;
  79         }
  80
  81         params = hci_pend_le_action_lookup(&hdev->pend_le_conns, bdaddr,
  82                                            bdaddr_type);
  83         if (!params || !params->explicit_connect)
  84                 return;
  85
  86         /* The connection attempt was doing scan for new RPA, and is
  87          * in scan phase. If params are not associated with any other
  88          * autoconnect action, remove them completely. If they are, just unmark
  89          * them as waiting for connection, by clearing explicit_connect field.
  90          */
  91         params->explicit_connect = false;
  92
  93         list_del_init(&params->action);
  94
  95         switch (params->auto_connect) {
  96         case HCI_AUTO_CONN_EXPLICIT:
  97                 hci_conn_params_del(hdev, bdaddr, bdaddr_type);
  98                 /* return instead of break to avoid duplicate scan update */
  99                 return;
 100         case HCI_AUTO_CONN_DIRECT:
 101         case HCI_AUTO_CONN_ALWAYS:
 102                 list_add(&params->action, &hdev->pend_le_conns);
 103                 break;
 104         case HCI_AUTO_CONN_REPORT:
 105                 list_add(&params->action, &hdev->pend_le_reports);
 106                 break;
 107         default:
 108                 break;
 109         }
 110
 111         hci_update_background_scan(hdev);
 112 }
 113
 114 static void hci_conn_cleanup(struct hci_conn *conn)
 115 {
 116         struct hci_dev *hdev = conn->hdev;
 117
 118         if (test_bit(HCI_CONN_PARAM_REMOVAL_PEND, &conn->flags))
 119                 hci_conn_params_del(conn->hdev, &conn->dst, conn->dst_type);
 120
 121         hci_chan_list_flush(conn);
 122
 123         hci_conn_hash_del(hdev, conn);
 124
 125         if (hdev->notify)
 126                 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
 127
 128         hci_conn_del_sysfs(conn);
 129
 130         debugfs_remove_recursive(conn->debugfs);
 131
 132         hci_dev_put(hdev);
 133
 134         hci_conn_put(conn);
 135 }
 136
 137 static void le_scan_cleanup(struct work_struct *work)
 138 {
 139         struct hci_conn *conn = container_of(work, struct hci_conn,
 140                                              le_scan_cleanup);
 141         struct hci_dev *hdev = conn->hdev;
 142         struct hci_conn *c = NULL;
 143
 144         BT_DBG("%s hcon %p", hdev->name, conn);
 145
 146         hci_dev_lock(hdev);
 147
 148         /* Check that the hci_conn is still around */
 149         rcu_read_lock();
 150         list_for_each_entry_rcu(c, &hdev->conn_hash.list, list) {
 151                 if (c == conn)
 152                         break;
 153         }
 154         rcu_read_unlock();
 155
 156         if (c == conn) {
 157                 hci_connect_le_scan_cleanup(conn);
 158                 hci_conn_cleanup(conn);
 159         }
 160
 161         hci_dev_unlock(hdev);
 162         hci_dev_put(hdev);
 163         hci_conn_put(conn);
 164 }
 165
 166 static void hci_connect_le_scan_remove(struct hci_conn *conn)
 167 {
 168         BT_DBG("%s hcon %p", conn->hdev->name, conn);
 169
 170         /* We can't call hci_conn_del/hci_conn_cleanup here since that
 171          * could deadlock with another hci_conn_del() call that's holding
 172          * hci_dev_lock and doing cancel_delayed_work_sync(&conn->disc_work).
 173          * Instead, grab temporary extra references to the hci_dev and
 174          * hci_conn and perform the necessary cleanup in a separate work
 175          * callback.
 176          */
 177
 178         hci_dev_hold(conn->hdev);
 179         hci_conn_get(conn);
 180
 181         /* Even though we hold a reference to the hdev, many other
 182          * things might get cleaned up meanwhile, including the hdev's
 183          * own workqueue, so we can't use that for scheduling.
 184          */
 185         schedule_work(&conn->le_scan_cleanup);
 186 }
 187
 188 static void hci_acl_create_connection(struct hci_conn *conn)
 189 {
 190         struct hci_dev *hdev = conn->hdev;
 191         struct inquiry_entry *ie;
 192         struct hci_cp_create_conn cp;
 193
 194         BT_DBG("hcon %p", conn);
 195
 196         conn->state = BT_CONNECT;
 197         conn->out = true;
 198         conn->role = HCI_ROLE_MASTER;
 199
 200         conn->attempt++;
 201
 202         conn->link_policy = hdev->link_policy;
 203
 204         memset(&cp, 0, sizeof(cp));
 205         bacpy(&cp.bdaddr, &conn->dst);
 206         cp.pscan_rep_mode = 0x02;
 207
 208         ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
 209         if (ie) {
 210                 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
 211                         cp.pscan_rep_mode = ie->data.pscan_rep_mode;
 212                         cp.pscan_mode     = ie->data.pscan_mode;
 213                         cp.clock_offset   = ie->data.clock_offset |
 214                                             cpu_to_le16(0x8000);
 215                 }
 216
 217                 memcpy(conn->dev_class, ie->data.dev_class, 3);
 218                 if (ie->data.ssp_mode > 0)
 219                         set_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
 220         }
 221
 222         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 223         if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
 224                 cp.role_switch = 0x01;
 225         else
 226                 cp.role_switch = 0x00;
 227
 228         hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
 229 }
 230
 231 int hci_disconnect(struct hci_conn *conn, __u8 reason)
 232 {
 233         BT_DBG("hcon %p", conn);
 234
 235         /* When we are master of an established connection and it enters
 236          * the disconnect timeout, then go ahead and try to read the
 237          * current clock offset.  Processing of the result is done
 238          * within the event handling and hci_clock_offset_evt function.
 239          */
 240         if (conn->type == ACL_LINK && conn->role == HCI_ROLE_MASTER &&
 241             (conn->state == BT_CONNECTED || conn->state == BT_CONFIG)) {
 242                 struct hci_dev *hdev = conn->hdev;
 243                 struct hci_cp_read_clock_offset clkoff_cp;
 244
 245                 clkoff_cp.handle = cpu_to_le16(conn->handle);
 246                 hci_send_cmd(hdev, HCI_OP_READ_CLOCK_OFFSET, sizeof(clkoff_cp),
 247                              &clkoff_cp);
 248         }
 249
 250         return hci_abort_conn(conn, reason);
 251 }
 252
 253 static void hci_add_sco(struct hci_conn *conn, __u16 handle)
 254 {
 255         struct hci_dev *hdev = conn->hdev;
 256         struct hci_cp_add_sco cp;
 257
 258         BT_DBG("hcon %p", conn);
 259
 260         conn->state = BT_CONNECT;
 261         conn->out = true;
 262
 263         conn->attempt++;
 264
 265         cp.handle   = cpu_to_le16(handle);
 266         cp.pkt_type = cpu_to_le16(conn->pkt_type);
 267
 268         hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
 269 }
 270
 271 bool hci_setup_sync(struct hci_conn *conn, __u16 handle)
 272 {
 273         struct hci_dev *hdev = conn->hdev;
 274         struct hci_cp_setup_sync_conn cp;
 275         const struct sco_param *param;
 276
 277         BT_DBG("hcon %p", conn);
 278
 279         conn->state = BT_CONNECT;
 280         conn->out = true;
 281
 282         conn->attempt++;
 283
 284         cp.handle   = cpu_to_le16(handle);
 285
 286         cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 287         cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 288         cp.voice_setting  = cpu_to_le16(conn->setting);
 289
 290         switch (conn->setting & SCO_AIRMODE_MASK) {
 291         case SCO_AIRMODE_TRANSP:
 292                 if (conn->attempt > ARRAY_SIZE(esco_param_msbc))
 293                         return false;
 294                 param = &esco_param_msbc[conn->attempt - 1];
 295                 break;
 296         case SCO_AIRMODE_CVSD:
 297                 if (lmp_esco_capable(conn->link)) {
 298                         if (conn->attempt > ARRAY_SIZE(esco_param_cvsd))
 299                                 return false;
 300                         param = &esco_param_cvsd[conn->attempt - 1];
 301                 } else {
 302                         if (conn->attempt > ARRAY_SIZE(sco_param_cvsd))
 303                                 return false;
 304                         param = &sco_param_cvsd[conn->attempt - 1];
 305                 }
 306                 break;
 307         default:
 308                 return false;
 309         }
 310
 311         cp.retrans_effort = param->retrans_effort;
 312         cp.pkt_type = __cpu_to_le16(param->pkt_type);
 313         cp.max_latency = __cpu_to_le16(param->max_latency);
 314
 315         if (hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp) < 0)
 316                 return false;
 317
 318         return true;
 319 }
 320
 321 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
 322                       u16 to_multiplier)
 323 {
 324         struct hci_dev *hdev = conn->hdev;
 325         struct hci_conn_params *params;
 326         struct hci_cp_le_conn_update cp;
 327
 328         hci_dev_lock(hdev);
 329
 330         params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
 331         if (params) {
 332                 params->conn_min_interval = min;
 333                 params->conn_max_interval = max;
 334                 params->conn_latency = latency;
 335                 params->supervision_timeout = to_multiplier;
 336         }
 337
 338         hci_dev_unlock(hdev);
 339
 340         memset(&cp, 0, sizeof(cp));
 341         cp.handle               = cpu_to_le16(conn->handle);
 342         cp.conn_interval_min    = cpu_to_le16(min);
 343         cp.conn_interval_max    = cpu_to_le16(max);
 344         cp.conn_latency         = cpu_to_le16(latency);
 345         cp.supervision_timeout  = cpu_to_le16(to_multiplier);
 346         cp.min_ce_len           = cpu_to_le16(0x0000);
 347         cp.max_ce_len           = cpu_to_le16(0x0000);
 348
 349         hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
 350
 351         if (params)
 352                 return 0x01;
 353
 354         return 0x00;
 355 }
 356
 357 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
 358                       __u8 ltk[16], __u8 key_size)
 359 {
 360         struct hci_dev *hdev = conn->hdev;
 361         struct hci_cp_le_start_enc cp;
 362
 363         BT_DBG("hcon %p", conn);
 364
 365         memset(&cp, 0, sizeof(cp));
 366
 367         cp.handle = cpu_to_le16(conn->handle);
 368         cp.rand = rand;
 369         cp.ediv = ediv;
 370         memcpy(cp.ltk, ltk, key_size);
 371
 372         hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
 373 }
 374
 375 /* Device _must_ be locked */
 376 void hci_sco_setup(struct hci_conn *conn, __u8 status)
 377 {
 378         struct hci_conn *sco = conn->link;
 379
 380         if (!sco)
 381                 return;
 382
 383         BT_DBG("hcon %p", conn);
 384
 385         if (!status) {
 386                 if (lmp_esco_capable(conn->hdev))
 387                         hci_setup_sync(sco, conn->handle);
 388                 else
 389                         hci_add_sco(sco, conn->handle);
 390         } else {
 391                 hci_connect_cfm(sco, status);
 392                 hci_conn_del(sco);
 393         }
 394 }
 395
 396 static void hci_conn_timeout(struct work_struct *work)
 397 {
 398         struct hci_conn *conn = container_of(work, struct hci_conn,
 399                                              disc_work.work);
 400         int refcnt = atomic_read(&conn->refcnt);
 401
 402         BT_DBG("hcon %p state %s", conn, state_to_string(conn->state));
 403
 404         WARN_ON(refcnt < 0);
 405
 406         /* FIXME: It was observed that in pairing failed scenario, refcnt
 407          * drops below 0. Probably this is because l2cap_conn_del calls
 408          * l2cap_chan_del for each channel, and inside l2cap_chan_del conn is
 409          * dropped. After that loop hci_chan_del is called which also drops
 410          * conn. For now make sure that ACL is alive if refcnt is higher then 0,
 411          * otherwise drop it.
 412          */
 413         if (refcnt > 0)
 414                 return;
 415
 416         /* LE connections in scanning state need special handling */
 417         if (conn->state == BT_CONNECT && conn->type == LE_LINK &&
 418             test_bit(HCI_CONN_SCANNING, &conn->flags)) {
 419                 hci_connect_le_scan_remove(conn);
 420                 return;
 421         }
 422
 423         hci_abort_conn(conn, hci_proto_disconn_ind(conn));
 424 }
 425
 426 /* Enter sniff mode */
 427 static void hci_conn_idle(struct work_struct *work)
 428 {
 429         struct hci_conn *conn = container_of(work, struct hci_conn,
 430                                              idle_work.work);
 431         struct hci_dev *hdev = conn->hdev;
 432
 433         BT_DBG("hcon %p mode %d", conn, conn->mode);
 434
 435         if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
 436                 return;
 437
 438         if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
 439                 return;
 440
 441         if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
 442                 struct hci_cp_sniff_subrate cp;
 443                 cp.handle             = cpu_to_le16(conn->handle);
 444                 cp.max_latency        = cpu_to_le16(0);
 445                 cp.min_remote_timeout = cpu_to_le16(0);
 446                 cp.min_local_timeout  = cpu_to_le16(0);
 447                 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
 448         }
 449
 450         if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
 451                 struct hci_cp_sniff_mode cp;
 452                 cp.handle       = cpu_to_le16(conn->handle);
 453                 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
 454                 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
 455                 cp.attempt      = cpu_to_le16(4);
 456                 cp.timeout      = cpu_to_le16(1);
 457                 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
 458         }
 459 }
 460
 461 static void hci_conn_auto_accept(struct work_struct *work)
 462 {
 463         struct hci_conn *conn = container_of(work, struct hci_conn,
 464                                              auto_accept_work.work);
 465
 466         hci_send_cmd(conn->hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
 467                      &conn->dst);
 468 }
 469
 470 static void le_conn_timeout(struct work_struct *work)
 471 {
 472         struct hci_conn *conn = container_of(work, struct hci_conn,
 473                                              le_conn_timeout.work);
 474         struct hci_dev *hdev = conn->hdev;
 475
 476         BT_DBG("");
 477
 478         /* We could end up here due to having done directed advertising,
 479          * so clean up the state if necessary. This should however only
 480          * happen with broken hardware or if low duty cycle was used
 481          * (which doesn't have a timeout of its own).
 482          */
 483         if (conn->role == HCI_ROLE_SLAVE) {
 484                 u8 enable = 0x00;
 485                 hci_send_cmd(hdev, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable),
 486                              &enable);
 487                 hci_le_conn_failed(conn, HCI_ERROR_ADVERTISING_TIMEOUT);
 488                 return;
 489         }
 490
 491         hci_abort_conn(conn, HCI_ERROR_REMOTE_USER_TERM);
 492 }
 493
 494 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
 495                               u8 role)
 496 {
 497         struct hci_conn *conn;
 498
 499         BT_DBG("%s dst %pMR", hdev->name, dst);
 500
 501         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
 502         if (!conn)
 503                 return NULL;
 504
 505         bacpy(&conn->dst, dst);
 506         bacpy(&conn->src, &hdev->bdaddr);
 507         conn->hdev  = hdev;
 508         conn->type  = type;
 509         conn->role  = role;
 510         conn->mode  = HCI_CM_ACTIVE;
 511         conn->state = BT_OPEN;
 512         conn->auth_type = HCI_AT_GENERAL_BONDING;
 513         conn->io_capability = hdev->io_capability;
 514         conn->remote_auth = 0xff;
 515         conn->key_type = 0xff;
 516         conn->rssi = HCI_RSSI_INVALID;
 517         conn->tx_power = HCI_TX_POWER_INVALID;
 518         conn->max_tx_power = HCI_TX_POWER_INVALID;
 519
 520         set_bit(HCI_CONN_POWER_SAVE, &conn->flags);
 521         conn->disc_timeout = HCI_DISCONN_TIMEOUT;
 522
 523         if (conn->role == HCI_ROLE_MASTER)
 524                 conn->out = true;
 525
 526         switch (type) {
 527         case ACL_LINK:
 528                 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
 529                 break;
 530         case LE_LINK:
 531                 /* conn->src should reflect the local identity address */
 532                 hci_copy_identity_address(hdev, &conn->src, &conn->src_type);
 533                 break;
 534         case SCO_LINK:
 535                 if (lmp_esco_capable(hdev))
 536                         conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
 537                                         (hdev->esco_type & EDR_ESCO_MASK);
 538                 else
 539                         conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
 540                 break;
 541         case ESCO_LINK:
 542                 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
 543                 break;
 544         }
 545
 546         skb_queue_head_init(&conn->data_q);
 547
 548         INIT_LIST_HEAD(&conn->chan_list);
 549
 550         INIT_DELAYED_WORK(&conn->disc_work, hci_conn_timeout);
 551         INIT_DELAYED_WORK(&conn->auto_accept_work, hci_conn_auto_accept);
 552         INIT_DELAYED_WORK(&conn->idle_work, hci_conn_idle);
 553         INIT_DELAYED_WORK(&conn->le_conn_timeout, le_conn_timeout);
 554         INIT_WORK(&conn->le_scan_cleanup, le_scan_cleanup);
 555
 556         atomic_set(&conn->refcnt, 0);
 557
 558         hci_dev_hold(hdev);
 559
 560         hci_conn_hash_add(hdev, conn);
 561         if (hdev->notify)
 562                 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
 563
 564         hci_conn_init_sysfs(conn);
 565
 566         return conn;
 567 }
 568
 569 int hci_conn_del(struct hci_conn *conn)
 570 {
 571         struct hci_dev *hdev = conn->hdev;
 572
 573         BT_DBG("%s hcon %p handle %d", hdev->name, conn, conn->handle);
 574
 575         cancel_delayed_work_sync(&conn->disc_work);
 576         cancel_delayed_work_sync(&conn->auto_accept_work);
 577         cancel_delayed_work_sync(&conn->idle_work);
 578
 579         if (conn->type == ACL_LINK) {
 580                 struct hci_conn *sco = conn->link;
 581                 if (sco)
 582                         sco->link = NULL;
 583
 584                 /* Unacked frames */
 585                 hdev->acl_cnt += conn->sent;
 586         } else if (conn->type == LE_LINK) {
 587                 cancel_delayed_work(&conn->le_conn_timeout);
 588
 589                 if (hdev->le_pkts)
 590                         hdev->le_cnt += conn->sent;
 591                 else
 592                         hdev->acl_cnt += conn->sent;
 593         } else {
 594                 struct hci_conn *acl = conn->link;
 595                 if (acl) {
 596                         acl->link = NULL;
 597                         hci_conn_drop(acl);
 598                 }
 599         }
 600
 601         if (conn->amp_mgr)
 602                 amp_mgr_put(conn->amp_mgr);
 603
 604         skb_queue_purge(&conn->data_q);
 605
 606         /* Remove the connection from the list and cleanup its remaining
 607          * state. This is a separate function since for some cases like
 608          * BT_CONNECT_SCAN we *only* want the cleanup part without the
 609          * rest of hci_conn_del.
 610          */
 611         hci_conn_cleanup(conn);
 612
 613         return 0;
 614 }
 615
 616 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
 617 {
 618         int use_src = bacmp(src, BDADDR_ANY);
 619         struct hci_dev *hdev = NULL, *d;
 620
 621         BT_DBG("%pMR -> %pMR", src, dst);
 622
 623         read_lock(&hci_dev_list_lock);
 624
 625         list_for_each_entry(d, &hci_dev_list, list) {
 626                 if (!test_bit(HCI_UP, &d->flags) ||
 627                     hci_dev_test_flag(d, HCI_USER_CHANNEL) ||
 628                     d->dev_type != HCI_BREDR)
 629                         continue;
 630
 631                 /* Simple routing:
 632                  *   No source address - find interface with bdaddr != dst
 633                  *   Source address    - find interface with bdaddr == src
 634                  */
 635
 636                 if (use_src) {
 637                         if (!bacmp(&d->bdaddr, src)) {
 638                                 hdev = d; break;
 639                         }
 640                 } else {
 641                         if (bacmp(&d->bdaddr, dst)) {
 642                                 hdev = d; break;
 643                         }
 644                 }
 645         }
 646
 647         if (hdev)
 648                 hdev = hci_dev_hold(hdev);
 649
 650         read_unlock(&hci_dev_list_lock);
 651         return hdev;
 652 }
 653 EXPORT_SYMBOL(hci_get_route);
 654
 655 /* This function requires the caller holds hdev->lock */
 656 void hci_le_conn_failed(struct hci_conn *conn, u8 status)
 657 {
 658         struct hci_dev *hdev = conn->hdev;
 659         struct hci_conn_params *params;
 660
 661         params = hci_pend_le_action_lookup(&hdev->pend_le_conns, &conn->dst,
 662                                            conn->dst_type);
 663         if (params && params->conn) {
 664                 hci_conn_drop(params->conn);
 665                 hci_conn_put(params->conn);
 666                 params->conn = NULL;
 667         }
 668
 669         conn->state = BT_CLOSED;
 670
 671         /* If the status indicates successful cancellation of
 672          * the attempt (i.e. Unkown Connection Id) there's no point of
 673          * notifying failure since we'll go back to keep trying to
 674          * connect. The only exception is explicit connect requests
 675          * where a timeout + cancel does indicate an actual failure.
 676          */
 677         if (status != HCI_ERROR_UNKNOWN_CONN_ID ||
 678             (params && params->explicit_connect))
 679                 mgmt_connect_failed(hdev, &conn->dst, conn->type,
 680                                     conn->dst_type, status);
 681
 682         hci_connect_cfm(conn, status);
 683
 684         hci_conn_del(conn);
 685
 686         /* Since we may have temporarily stopped the background scanning in
 687          * favor of connection establishment, we should restart it.
 688          */
 689         hci_update_background_scan(hdev);
 690
 691         /* Re-enable advertising in case this was a failed connection
 692          * attempt as a peripheral.
 693          */
 694         hci_req_reenable_advertising(hdev);
 695 }
 696
 697 static void create_le_conn_complete(struct hci_dev *hdev, u8 status, u16 opcode)
 698 {
 699         struct hci_conn *conn;
 700
 701         hci_dev_lock(hdev);
 702
 703         conn = hci_lookup_le_connect(hdev);
 704
 705         if (!status) {
 706                 hci_connect_le_scan_cleanup(conn);
 707                 goto done;
 708         }
 709
 710         BT_ERR("HCI request failed to create LE connection: status 0x%2.2x",
 711                status);
 712
 713         if (!conn)
 714                 goto done;
 715
 716         hci_le_conn_failed(conn, status);
 717
 718 done:
 719         hci_dev_unlock(hdev);
 720 }
 721
 722 static void hci_req_add_le_create_conn(struct hci_request *req,
 723                                        struct hci_conn *conn)
 724 {
 725         struct hci_cp_le_create_conn cp;
 726         struct hci_dev *hdev = conn->hdev;
 727         u8 own_addr_type;
 728
 729         memset(&cp, 0, sizeof(cp));
 730
 731         /* Update random address, but set require_privacy to false so
 732          * that we never connect with an non-resolvable address.
 733          */
 734         if (hci_update_random_address(req, false, &own_addr_type))
 735                 return;
 736
 737         /* Set window to be the same value as the interval to enable
 738          * continuous scanning.
 739          */
 740         cp.scan_interval = cpu_to_le16(hdev->le_scan_interval);
 741         cp.scan_window = cp.scan_interval;
 742
 743         bacpy(&cp.peer_addr, &conn->dst);
 744         cp.peer_addr_type = conn->dst_type;
 745         cp.own_address_type = own_addr_type;
 746         cp.conn_interval_min = cpu_to_le16(conn->le_conn_min_interval);
 747         cp.conn_interval_max = cpu_to_le16(conn->le_conn_max_interval);
 748         cp.conn_latency = cpu_to_le16(conn->le_conn_latency);
 749         cp.supervision_timeout = cpu_to_le16(conn->le_supv_timeout);
 750         cp.min_ce_len = cpu_to_le16(0x0000);
 751         cp.max_ce_len = cpu_to_le16(0x0000);
 752
 753         hci_req_add(req, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
 754
 755         conn->state = BT_CONNECT;
 756         clear_bit(HCI_CONN_SCANNING, &conn->flags);
 757 }
 758
 759 static void hci_req_directed_advertising(struct hci_request *req,
 760                                          struct hci_conn *conn)
 761 {
 762         struct hci_dev *hdev = req->hdev;
 763         struct hci_cp_le_set_adv_param cp;
 764         u8 own_addr_type;
 765         u8 enable;
 766
 767         /* Clear the HCI_LE_ADV bit temporarily so that the
 768          * hci_update_random_address knows that it's safe to go ahead
 769          * and write a new random address. The flag will be set back on
 770          * as soon as the SET_ADV_ENABLE HCI command completes.
 771          */
 772         hci_dev_clear_flag(hdev, HCI_LE_ADV);
 773
 774         /* Set require_privacy to false so that the remote device has a
 775          * chance of identifying us.
 776          */
 777         if (hci_update_random_address(req, false, &own_addr_type) < 0)
 778                 return;
 779
 780         memset(&cp, 0, sizeof(cp));
 781         cp.type = LE_ADV_DIRECT_IND;
 782         cp.own_address_type = own_addr_type;
 783         cp.direct_addr_type = conn->dst_type;
 784         bacpy(&cp.direct_addr, &conn->dst);
 785         cp.channel_map = hdev->le_adv_channel_map;
 786
 787         hci_req_add(req, HCI_OP_LE_SET_ADV_PARAM, sizeof(cp), &cp);
 788
 789         enable = 0x01;
 790         hci_req_add(req, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable), &enable);
 791
 792         conn->state = BT_CONNECT;
 793 }
 794
 795 struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
 796                                 u8 dst_type, u8 sec_level, u16 conn_timeout,
 797                                 u8 role)
 798 {
 799         struct hci_conn_params *params;
 800         struct hci_conn *conn;
 801         struct smp_irk *irk;
 802         struct hci_request req;
 803         int err;
 804
 805         /* Let's make sure that le is enabled.*/
 806         if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
 807                 if (lmp_le_capable(hdev))
 808                         return ERR_PTR(-ECONNREFUSED);
 809
 810                 return ERR_PTR(-EOPNOTSUPP);
 811         }
 812
 813         /* Since the controller supports only one LE connection attempt at a
 814          * time, we return -EBUSY if there is any connection attempt running.
 815          */
 816         if (hci_lookup_le_connect(hdev))
 817                 return ERR_PTR(-EBUSY);
 818
 819         /* If there's already a connection object but it's not in
 820          * scanning state it means it must already be established, in
 821          * which case we can't do anything else except report a failure
 822          * to connect.
 823          */
 824         conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
 825         if (conn && !test_bit(HCI_CONN_SCANNING, &conn->flags)) {
 826                 return ERR_PTR(-EBUSY);
 827         }
 828
 829         /* When given an identity address with existing identity
 830          * resolving key, the connection needs to be established
 831          * to a resolvable random address.
 832          *
 833          * Storing the resolvable random address is required here
 834          * to handle connection failures. The address will later
 835          * be resolved back into the original identity address
 836          * from the connect request.
 837          */
 838         irk = hci_find_irk_by_addr(hdev, dst, dst_type);
 839         if (irk && bacmp(&irk->rpa, BDADDR_ANY)) {
 840                 dst = &irk->rpa;
 841                 dst_type = ADDR_LE_DEV_RANDOM;
 842         }
 843
 844         if (conn) {
 845                 bacpy(&conn->dst, dst);
 846         } else {
 847                 conn = hci_conn_add(hdev, LE_LINK, dst, role);
 848                 if (!conn)
 849                         return ERR_PTR(-ENOMEM);
 850                 hci_conn_hold(conn);
 851                 conn->pending_sec_level = sec_level;
 852         }
 853
 854         conn->dst_type = dst_type;
 855         conn->sec_level = BT_SECURITY_LOW;
 856         conn->conn_timeout = conn_timeout;
 857
 858         hci_req_init(&req, hdev);
 859
 860         /* Disable advertising if we're active. For master role
 861          * connections most controllers will refuse to connect if
 862          * advertising is enabled, and for slave role connections we
 863          * anyway have to disable it in order to start directed
 864          * advertising.
 865          */
 866         if (hci_dev_test_flag(hdev, HCI_LE_ADV)) {
 867                 u8 enable = 0x00;
 868                 hci_req_add(&req, HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable),
 869                             &enable);
 870         }
 871
 872         /* If requested to connect as slave use directed advertising */
 873         if (conn->role == HCI_ROLE_SLAVE) {
 874                 /* If we're active scanning most controllers are unable
 875                  * to initiate advertising. Simply reject the attempt.
 876                  */
 877                 if (hci_dev_test_flag(hdev, HCI_LE_SCAN) &&
 878                     hdev->le_scan_type == LE_SCAN_ACTIVE) {
 879                         skb_queue_purge(&req.cmd_q);
 880                         hci_conn_del(conn);
 881                         return ERR_PTR(-EBUSY);
 882                 }
 883
 884                 hci_req_directed_advertising(&req, conn);
 885                 goto create_conn;
 886         }
 887
 888         params = hci_conn_params_lookup(hdev, &conn->dst, conn->dst_type);
 889         if (params) {
 890                 conn->le_conn_min_interval = params->conn_min_interval;
 891                 conn->le_conn_max_interval = params->conn_max_interval;
 892                 conn->le_conn_latency = params->conn_latency;
 893                 conn->le_supv_timeout = params->supervision_timeout;
 894         } else {
 895                 conn->le_conn_min_interval = hdev->le_conn_min_interval;
 896                 conn->le_conn_max_interval = hdev->le_conn_max_interval;
 897                 conn->le_conn_latency = hdev->le_conn_latency;
 898                 conn->le_supv_timeout = hdev->le_supv_timeout;
 899         }
 900
 901         /* If controller is scanning, we stop it since some controllers are
 902          * not able to scan and connect at the same time. Also set the
 903          * HCI_LE_SCAN_INTERRUPTED flag so that the command complete
 904          * handler for scan disabling knows to set the correct discovery
 905          * state.
 906          */
 907         if (hci_dev_test_flag(hdev, HCI_LE_SCAN)) {
 908                 hci_req_add_le_scan_disable(&req);
 909                 hci_dev_set_flag(hdev, HCI_LE_SCAN_INTERRUPTED);
 910         }
 911
 912         hci_req_add_le_create_conn(&req, conn);
 913
 914 create_conn:
 915         err = hci_req_run(&req, create_le_conn_complete);
 916         if (err) {
 917                 hci_conn_del(conn);
 918                 return ERR_PTR(err);
 919         }
 920
 921         return conn;
 922 }
 923
 924 static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type)
 925 {
 926         struct hci_conn *conn;
 927
 928         conn = hci_conn_hash_lookup_le(hdev, addr, type);
 929         if (!conn)
 930                 return false;
 931
 932         if (conn->state != BT_CONNECTED)
 933                 return false;
 934
 935         return true;
 936 }
 937
 938 /* This function requires the caller holds hdev->lock */
 939 static int hci_explicit_conn_params_set(struct hci_dev *hdev,
 940                                         bdaddr_t *addr, u8 addr_type)
 941 {
 942         struct hci_conn_params *params;
 943
 944         if (is_connected(hdev, addr, addr_type))
 945                 return -EISCONN;
 946
 947         params = hci_conn_params_lookup(hdev, addr, addr_type);
 948         if (!params) {
 949                 params = hci_conn_params_add(hdev, addr, addr_type);
 950                 if (!params)
 951                         return -ENOMEM;
 952
 953                 /* If we created new params, mark them to be deleted in
 954                  * hci_connect_le_scan_cleanup. It's different case than
 955                  * existing disabled params, those will stay after cleanup.
 956                  */
 957                 params->auto_connect = HCI_AUTO_CONN_EXPLICIT;
 958         }
 959
 960         /* We're trying to connect, so make sure params are at pend_le_conns */
 961         if (params->auto_connect == HCI_AUTO_CONN_DISABLED ||
 962             params->auto_connect == HCI_AUTO_CONN_REPORT ||
 963             params->auto_connect == HCI_AUTO_CONN_EXPLICIT) {
 964                 list_del_init(&params->action);
 965                 list_add(&params->action, &hdev->pend_le_conns);
 966         }
 967
 968         params->explicit_connect = true;
 969
 970         BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type,
 971                params->auto_connect);
 972
 973         return 0;
 974 }
 975
 976 /* This function requires the caller holds hdev->lock */
 977 struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
 978                                      u8 dst_type, u8 sec_level,
 979                                      u16 conn_timeout)
 980 {
 981         struct hci_conn *conn;
 982
 983         /* Let's make sure that le is enabled.*/
 984         if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED)) {
 985                 if (lmp_le_capable(hdev))
 986                         return ERR_PTR(-ECONNREFUSED);
 987
 988                 return ERR_PTR(-EOPNOTSUPP);
 989         }
 990
 991         /* Some devices send ATT messages as soon as the physical link is
 992          * established. To be able to handle these ATT messages, the user-
 993          * space first establishes the connection and then starts the pairing
 994          * process.
 995          *
 996          * So if a hci_conn object already exists for the following connection
 997          * attempt, we simply update pending_sec_level and auth_type fields
 998          * and return the object found.
 999          */
1000         conn = hci_conn_hash_lookup_le(hdev, dst, dst_type);
1001         if (conn) {
1002                 if (conn->pending_sec_level < sec_level)
1003                         conn->pending_sec_level = sec_level;
1004                 goto done;
1005         }
1006
1007         BT_DBG("requesting refresh of dst_addr");
1008
1009         conn = hci_conn_add(hdev, LE_LINK, dst, HCI_ROLE_MASTER);
1010         if (!conn)
1011                 return ERR_PTR(-ENOMEM);
1012
1013         if (hci_explicit_conn_params_set(hdev, dst, dst_type) < 0)
1014                 return ERR_PTR(-EBUSY);
1015
1016         conn->state = BT_CONNECT;
1017         set_bit(HCI_CONN_SCANNING, &conn->flags);
1018         conn->dst_type = dst_type;
1019         conn->sec_level = BT_SECURITY_LOW;
1020         conn->pending_sec_level = sec_level;
1021         conn->conn_timeout = conn_timeout;
1022
1023         hci_update_background_scan(hdev);
1024
1025 done:
1026         hci_conn_hold(conn);
1027         return conn;
1028 }
1029
1030 struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1031                                  u8 sec_level, u8 auth_type)
1032 {
1033         struct hci_conn *acl;
1034
1035         if (!hci_dev_test_flag(hdev, HCI_BREDR_ENABLED)) {
1036                 if (lmp_bredr_capable(hdev))
1037                         return ERR_PTR(-ECONNREFUSED);
1038
1039                 return ERR_PTR(-EOPNOTSUPP);
1040         }
1041
1042         acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
1043         if (!acl) {
1044                 acl = hci_conn_add(hdev, ACL_LINK, dst, HCI_ROLE_MASTER);
1045                 if (!acl)
1046                         return ERR_PTR(-ENOMEM);
1047         }
1048
1049         hci_conn_hold(acl);
1050
1051         if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
1052                 acl->sec_level = BT_SECURITY_LOW;
1053                 acl->pending_sec_level = sec_level;
1054                 acl->auth_type = auth_type;
1055                 hci_acl_create_connection(acl);
1056         }
1057
1058         return acl;
1059 }
1060
1061 struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1062                                  __u16 setting)
1063 {
1064         struct hci_conn *acl;
1065         struct hci_conn *sco;
1066
1067         acl = hci_connect_acl(hdev, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
1068         if (IS_ERR(acl))
1069                 return acl;
1070
1071         sco = hci_conn_hash_lookup_ba(hdev, type, dst);
1072         if (!sco) {
1073                 sco = hci_conn_add(hdev, type, dst, HCI_ROLE_MASTER);
1074                 if (!sco) {
1075                         hci_conn_drop(acl);
1076                         return ERR_PTR(-ENOMEM);
1077                 }
1078         }
1079
1080         acl->link = sco;
1081         sco->link = acl;
1082
1083         hci_conn_hold(sco);
1084
1085         sco->setting = setting;
1086
1087         if (acl->state == BT_CONNECTED &&
1088             (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
1089                 set_bit(HCI_CONN_POWER_SAVE, &acl->flags);
1090                 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
1091
1092                 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->flags)) {
1093                         /* defer SCO setup until mode change completed */
1094                         set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->flags);
1095                         return sco;
1096                 }
1097
1098                 hci_sco_setup(acl, 0x00);
1099         }
1100
1101         return sco;
1102 }
1103
1104 /* Check link security requirement */
1105 int hci_conn_check_link_mode(struct hci_conn *conn)
1106 {
1107         BT_DBG("hcon %p", conn);
1108
1109         /* In Secure Connections Only mode, it is required that Secure
1110          * Connections is used and the link is encrypted with AES-CCM
1111          * using a P-256 authenticated combination key.
1112          */
1113         if (hci_dev_test_flag(conn->hdev, HCI_SC_ONLY)) {
1114                 if (!hci_conn_sc_enabled(conn) ||
1115                     !test_bit(HCI_CONN_AES_CCM, &conn->flags) ||
1116                     conn->key_type != HCI_LK_AUTH_COMBINATION_P256)
1117                         return 0;
1118         }
1119
1120         if (hci_conn_ssp_enabled(conn) &&
1121             !test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1122                 return 0;
1123
1124         return 1;
1125 }
1126
1127 /* Authenticate remote device */
1128 static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
1129 {
1130         BT_DBG("hcon %p", conn);
1131
1132         if (conn->pending_sec_level > sec_level)
1133                 sec_level = conn->pending_sec_level;
1134
1135         if (sec_level > conn->sec_level)
1136                 conn->pending_sec_level = sec_level;
1137         else if (test_bit(HCI_CONN_AUTH, &conn->flags))
1138                 return 1;
1139
1140         /* Make sure we preserve an existing MITM requirement*/
1141         auth_type |= (conn->auth_type & 0x01);
1142
1143         conn->auth_type = auth_type;
1144
1145         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->flags)) {
1146                 struct hci_cp_auth_requested cp;
1147
1148                 cp.handle = cpu_to_le16(conn->handle);
1149                 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
1150                              sizeof(cp), &cp);
1151
1152                 /* If we're already encrypted set the REAUTH_PEND flag,
1153                  * otherwise set the ENCRYPT_PEND.
1154                  */
1155                 if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1156                         set_bit(HCI_CONN_REAUTH_PEND, &conn->flags);
1157                 else
1158                         set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags);
1159         }
1160
1161         return 0;
1162 }
1163
1164 /* Encrypt the the link */
1165 static void hci_conn_encrypt(struct hci_conn *conn)
1166 {
1167         BT_DBG("hcon %p", conn);
1168
1169         if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags)) {
1170                 struct hci_cp_set_conn_encrypt cp;
1171                 cp.handle  = cpu_to_le16(conn->handle);
1172                 cp.encrypt = 0x01;
1173                 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
1174                              &cp);
1175         }
1176 }
1177
1178 /* Enable security */
1179 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1180                       bool initiator)
1181 {
1182         BT_DBG("hcon %p", conn);
1183
1184         if (conn->type == LE_LINK)
1185                 return smp_conn_security(conn, sec_level);
1186
1187         /* For sdp we don't need the link key. */
1188         if (sec_level == BT_SECURITY_SDP)
1189                 return 1;
1190
1191         /* For non 2.1 devices and low security level we don't need the link
1192            key. */
1193         if (sec_level == BT_SECURITY_LOW && !hci_conn_ssp_enabled(conn))
1194                 return 1;
1195
1196         /* For other security levels we need the link key. */
1197         if (!test_bit(HCI_CONN_AUTH, &conn->flags))
1198                 goto auth;
1199
1200         /* An authenticated FIPS approved combination key has sufficient
1201          * security for security level 4. */
1202         if (conn->key_type == HCI_LK_AUTH_COMBINATION_P256 &&
1203             sec_level == BT_SECURITY_FIPS)
1204                 goto encrypt;
1205
1206         /* An authenticated combination key has sufficient security for
1207            security level 3. */
1208         if ((conn->key_type == HCI_LK_AUTH_COMBINATION_P192 ||
1209              conn->key_type == HCI_LK_AUTH_COMBINATION_P256) &&
1210             sec_level == BT_SECURITY_HIGH)
1211                 goto encrypt;
1212
1213         /* An unauthenticated combination key has sufficient security for
1214            security level 1 and 2. */
1215         if ((conn->key_type == HCI_LK_UNAUTH_COMBINATION_P192 ||
1216              conn->key_type == HCI_LK_UNAUTH_COMBINATION_P256) &&
1217             (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW))
1218                 goto encrypt;
1219
1220         /* A combination key has always sufficient security for the security
1221            levels 1 or 2. High security level requires the combination key
1222            is generated using maximum PIN code length (16).
1223            For pre 2.1 units. */
1224         if (conn->key_type == HCI_LK_COMBINATION &&
1225             (sec_level == BT_SECURITY_MEDIUM || sec_level == BT_SECURITY_LOW ||
1226              conn->pin_length == 16))
1227                 goto encrypt;
1228
1229 auth:
1230         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1231                 return 0;
1232
1233         if (initiator)
1234                 set_bit(HCI_CONN_AUTH_INITIATOR, &conn->flags);
1235
1236         if (!hci_conn_auth(conn, sec_level, auth_type))
1237                 return 0;
1238
1239 encrypt:
1240         if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1241                 return 1;
1242
1243         hci_conn_encrypt(conn);
1244         return 0;
1245 }
1246 EXPORT_SYMBOL(hci_conn_security);
1247
1248 /* Check secure link requirement */
1249 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
1250 {
1251         BT_DBG("hcon %p", conn);
1252
1253         /* Accept if non-secure or higher security level is required */
1254         if (sec_level != BT_SECURITY_HIGH && sec_level != BT_SECURITY_FIPS)
1255                 return 1;
1256
1257         /* Accept if secure or higher security level is already present */
1258         if (conn->sec_level == BT_SECURITY_HIGH ||
1259             conn->sec_level == BT_SECURITY_FIPS)
1260                 return 1;
1261
1262         /* Reject not secure link */
1263         return 0;
1264 }
1265 EXPORT_SYMBOL(hci_conn_check_secure);
1266
1267 /* Switch role */
1268 int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
1269 {
1270         BT_DBG("hcon %p", conn);
1271
1272         if (role == conn->role)
1273                 return 1;
1274
1275         if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->flags)) {
1276                 struct hci_cp_switch_role cp;
1277                 bacpy(&cp.bdaddr, &conn->dst);
1278                 cp.role = role;
1279                 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
1280         }
1281
1282         return 0;
1283 }
1284 EXPORT_SYMBOL(hci_conn_switch_role);
1285
1286 /* Enter active mode */
1287 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
1288 {
1289         struct hci_dev *hdev = conn->hdev;
1290
1291         BT_DBG("hcon %p mode %d", conn, conn->mode);
1292
1293         if (conn->mode != HCI_CM_SNIFF)
1294                 goto timer;
1295
1296         if (!test_bit(HCI_CONN_POWER_SAVE, &conn->flags) && !force_active)
1297                 goto timer;
1298
1299         if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->flags)) {
1300                 struct hci_cp_exit_sniff_mode cp;
1301                 cp.handle = cpu_to_le16(conn->handle);
1302                 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
1303         }
1304
1305 timer:
1306         if (hdev->idle_timeout > 0)
1307                 queue_delayed_work(hdev->workqueue, &conn->idle_work,
1308                                    msecs_to_jiffies(hdev->idle_timeout));
1309 }
1310
1311 /* Drop all connection on the device */
1312 void hci_conn_hash_flush(struct hci_dev *hdev)
1313 {
1314         struct hci_conn_hash *h = &hdev->conn_hash;
1315         struct hci_conn *c, *n;
1316
1317         BT_DBG("hdev %s", hdev->name);
1318
1319         list_for_each_entry_safe(c, n, &h->list, list) {
1320                 c->state = BT_CLOSED;
1321
1322                 hci_disconn_cfm(c, HCI_ERROR_LOCAL_HOST_TERM);
1323                 hci_conn_del(c);
1324         }
1325 }
1326
1327 /* Check pending connect attempts */
1328 void hci_conn_check_pending(struct hci_dev *hdev)
1329 {
1330         struct hci_conn *conn;
1331
1332         BT_DBG("hdev %s", hdev->name);
1333
1334         hci_dev_lock(hdev);
1335
1336         conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
1337         if (conn)
1338                 hci_acl_create_connection(conn);
1339
1340         hci_dev_unlock(hdev);
1341 }
1342
1343 static u32 get_link_mode(struct hci_conn *conn)
1344 {
1345         u32 link_mode = 0;
1346
1347         if (conn->role == HCI_ROLE_MASTER)
1348                 link_mode |= HCI_LM_MASTER;
1349
1350         if (test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1351                 link_mode |= HCI_LM_ENCRYPT;
1352
1353         if (test_bit(HCI_CONN_AUTH, &conn->flags))
1354                 link_mode |= HCI_LM_AUTH;
1355
1356         if (test_bit(HCI_CONN_SECURE, &conn->flags))
1357                 link_mode |= HCI_LM_SECURE;
1358
1359         if (test_bit(HCI_CONN_FIPS, &conn->flags))
1360                 link_mode |= HCI_LM_FIPS;
1361
1362         return link_mode;
1363 }
1364
1365 int hci_get_conn_list(void __user *arg)
1366 {
1367         struct hci_conn *c;
1368         struct hci_conn_list_req req, *cl;
1369         struct hci_conn_info *ci;
1370         struct hci_dev *hdev;
1371         int n = 0, size, err;
1372
1373         if (copy_from_user(&req, arg, sizeof(req)))
1374                 return -EFAULT;
1375
1376         if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
1377                 return -EINVAL;
1378
1379         size = sizeof(req) + req.conn_num * sizeof(*ci);
1380
1381         cl = kmalloc(size, GFP_KERNEL);
1382         if (!cl)
1383                 return -ENOMEM;
1384
1385         hdev = hci_dev_get(req.dev_id);
1386         if (!hdev) {
1387                 kfree(cl);
1388                 return -ENODEV;
1389         }
1390
1391         ci = cl->conn_info;
1392
1393         hci_dev_lock(hdev);
1394         list_for_each_entry(c, &hdev->conn_hash.list, list) {
1395                 bacpy(&(ci + n)->bdaddr, &c->dst);
1396                 (ci + n)->handle = c->handle;
1397                 (ci + n)->type  = c->type;
1398                 (ci + n)->out   = c->out;
1399                 (ci + n)->state = c->state;
1400                 (ci + n)->link_mode = get_link_mode(c);
1401                 if (++n >= req.conn_num)
1402                         break;
1403         }
1404         hci_dev_unlock(hdev);
1405
1406         cl->dev_id = hdev->id;
1407         cl->conn_num = n;
1408         size = sizeof(req) + n * sizeof(*ci);
1409
1410         hci_dev_put(hdev);
1411
1412         err = copy_to_user(arg, cl, size);
1413         kfree(cl);
1414
1415         return err ? -EFAULT : 0;
1416 }
1417
1418 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
1419 {
1420         struct hci_conn_info_req req;
1421         struct hci_conn_info ci;
1422         struct hci_conn *conn;
1423         char __user *ptr = arg + sizeof(req);
1424
1425         if (copy_from_user(&req, arg, sizeof(req)))
1426                 return -EFAULT;
1427
1428         hci_dev_lock(hdev);
1429         conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
1430         if (conn) {
1431                 bacpy(&ci.bdaddr, &conn->dst);
1432                 ci.handle = conn->handle;
1433                 ci.type  = conn->type;
1434                 ci.out   = conn->out;
1435                 ci.state = conn->state;
1436                 ci.link_mode = get_link_mode(conn);
1437         }
1438         hci_dev_unlock(hdev);
1439
1440         if (!conn)
1441                 return -ENOENT;
1442
1443         return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
1444 }
1445
1446 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
1447 {
1448         struct hci_auth_info_req req;
1449         struct hci_conn *conn;
1450
1451         if (copy_from_user(&req, arg, sizeof(req)))
1452                 return -EFAULT;
1453
1454         hci_dev_lock(hdev);
1455         conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
1456         if (conn)
1457                 req.type = conn->auth_type;
1458         hci_dev_unlock(hdev);
1459
1460         if (!conn)
1461                 return -ENOENT;
1462
1463         return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
1464 }
1465
1466 struct hci_chan *hci_chan_create(struct hci_conn *conn)
1467 {
1468         struct hci_dev *hdev = conn->hdev;
1469         struct hci_chan *chan;
1470
1471         BT_DBG("%s hcon %p", hdev->name, conn);
1472
1473         if (test_bit(HCI_CONN_DROP, &conn->flags)) {
1474                 BT_DBG("Refusing to create new hci_chan");
1475                 return NULL;
1476         }
1477
1478         chan = kzalloc(sizeof(*chan), GFP_KERNEL);
1479         if (!chan)
1480                 return NULL;
1481
1482         chan->conn = hci_conn_get(conn);
1483         skb_queue_head_init(&chan->data_q);
1484         chan->state = BT_CONNECTED;
1485
1486         list_add_rcu(&chan->list, &conn->chan_list);
1487
1488         return chan;
1489 }
1490
1491 void hci_chan_del(struct hci_chan *chan)
1492 {
1493         struct hci_conn *conn = chan->conn;
1494         struct hci_dev *hdev = conn->hdev;
1495
1496         BT_DBG("%s hcon %p chan %p", hdev->name, conn, chan);
1497
1498         list_del_rcu(&chan->list);
1499
1500         synchronize_rcu();
1501
1502         /* Prevent new hci_chan's to be created for this hci_conn */
1503         set_bit(HCI_CONN_DROP, &conn->flags);
1504
1505         hci_conn_put(conn);
1506
1507         skb_queue_purge(&chan->data_q);
1508         kfree(chan);
1509 }
1510
1511 void hci_chan_list_flush(struct hci_conn *conn)
1512 {
1513         struct hci_chan *chan, *n;
1514
1515         BT_DBG("hcon %p", conn);
1516
1517         list_for_each_entry_safe(chan, n, &conn->chan_list, list)
1518                 hci_chan_del(chan);
1519 }
1520
1521 static struct hci_chan *__hci_chan_lookup_handle(struct hci_conn *hcon,
1522                                                  __u16 handle)
1523 {
1524         struct hci_chan *hchan;
1525
1526         list_for_each_entry(hchan, &hcon->chan_list, list) {
1527                 if (hchan->handle == handle)
1528                         return hchan;
1529         }
1530
1531         return NULL;
1532 }
1533
1534 struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle)
1535 {
1536         struct hci_conn_hash *h = &hdev->conn_hash;
1537         struct hci_conn *hcon;
1538         struct hci_chan *hchan = NULL;
1539
1540         rcu_read_lock();
1541
1542         list_for_each_entry_rcu(hcon, &h->list, list) {
1543                 hchan = __hci_chan_lookup_handle(hcon, handle);
1544                 if (hchan)
1545                         break;
1546         }
1547
1548         rcu_read_unlock();
1549
1550         return hchan;
1551 }