net/bluetooth/hci_conn.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 connection handling. */
  26
  27 #include <linux/module.h>
  28
  29 #include <linux/types.h>
  30 #include <linux/errno.h>
  31 #include <linux/kernel.h>
  32 #include <linux/slab.h>
  33 #include <linux/poll.h>
  34 #include <linux/fcntl.h>
  35 #include <linux/init.h>
  36 #include <linux/skbuff.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/notifier.h>
  39 #include <net/sock.h>
  40
  41 #include <asm/system.h>
  42 #include <asm/uaccess.h>
  43 #include <asm/unaligned.h>
  44
  45 #include <net/bluetooth/bluetooth.h>
  46 #include <net/bluetooth/hci_core.h>
  47
  48 #ifndef CONFIG_BT_HCI_CORE_DEBUG
  49 #undef  BT_DBG
  50 #define BT_DBG(D...)
  51 #endif
  52
  53 void hci_acl_connect(struct hci_conn *conn)
  54 {
  55         struct hci_dev *hdev = conn->hdev;
  56         struct inquiry_entry *ie;
  57         struct hci_cp_create_conn cp;
  58
  59         BT_DBG("%p", conn);
  60
  61         conn->state = BT_CONNECT;
  62         conn->out   = 1;
  63         conn->link_mode = HCI_LM_MASTER;
  64
  65         conn->attempt++;
  66
  67         memset(&cp, 0, sizeof(cp));
  68         bacpy(&cp.bdaddr, &conn->dst);
  69         cp.pscan_rep_mode = 0x02;
  70
  71         if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)) &&
  72                         inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
  73                 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
  74                 cp.pscan_mode     = ie->data.pscan_mode;
  75                 cp.clock_offset   = ie->data.clock_offset | cpu_to_le16(0x8000);
  76                 memcpy(conn->dev_class, ie->data.dev_class, 3);
  77         }
  78
  79         cp.pkt_type = cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
  80         if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
  81                 cp.role_switch = 0x01;
  82         else
  83                 cp.role_switch = 0x00;
  84
  85         hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
  86 }
  87
  88 static void hci_acl_connect_cancel(struct hci_conn *conn)
  89 {
  90         struct hci_cp_create_conn_cancel cp;
  91
  92         BT_DBG("%p", conn);
  93
  94         if (conn->hdev->hci_ver < 2)
  95                 return;
  96
  97         bacpy(&cp.bdaddr, &conn->dst);
  98         hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
  99 }
 100
 101 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
 102 {
 103         struct hci_cp_disconnect cp;
 104
 105         BT_DBG("%p", conn);
 106
 107         conn->state = BT_DISCONN;
 108
 109         cp.handle = cpu_to_le16(conn->handle);
 110         cp.reason = reason;
 111         hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
 112 }
 113
 114 void hci_add_sco(struct hci_conn *conn, __u16 handle)
 115 {
 116         struct hci_dev *hdev = conn->hdev;
 117         struct hci_cp_add_sco cp;
 118
 119         BT_DBG("%p", conn);
 120
 121         conn->state = BT_CONNECT;
 122         conn->out = 1;
 123
 124         cp.handle   = cpu_to_le16(handle);
 125         cp.pkt_type = cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
 126
 127         hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
 128 }
 129
 130 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
 131 {
 132         struct hci_dev *hdev = conn->hdev;
 133         struct hci_cp_setup_sync_conn cp;
 134
 135         BT_DBG("%p", conn);
 136
 137         conn->state = BT_CONNECT;
 138         conn->out = 1;
 139
 140         cp.handle   = cpu_to_le16(handle);
 141         cp.pkt_type = cpu_to_le16(hdev->esco_type);
 142
 143         cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 144         cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 145         cp.max_latency    = cpu_to_le16(0xffff);
 146         cp.voice_setting  = cpu_to_le16(hdev->voice_setting);
 147         cp.retrans_effort = 0xff;
 148
 149         hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
 150 }
 151
 152 static void hci_conn_timeout(unsigned long arg)
 153 {
 154         struct hci_conn *conn = (void *) arg;
 155         struct hci_dev *hdev = conn->hdev;
 156
 157         BT_DBG("conn %p state %d", conn, conn->state);
 158
 159         if (atomic_read(&conn->refcnt))
 160                 return;
 161
 162         hci_dev_lock(hdev);
 163
 164         switch (conn->state) {
 165         case BT_CONNECT:
 166                 if (conn->type == ACL_LINK)
 167                         hci_acl_connect_cancel(conn);
 168                 else
 169                         hci_acl_disconn(conn, 0x13);
 170                 break;
 171         case BT_CONNECTED:
 172                 hci_acl_disconn(conn, 0x13);
 173                 break;
 174         default:
 175                 conn->state = BT_CLOSED;
 176                 break;
 177         }
 178
 179         hci_dev_unlock(hdev);
 180 }
 181
 182 static void hci_conn_idle(unsigned long arg)
 183 {
 184         struct hci_conn *conn = (void *) arg;
 185
 186         BT_DBG("conn %p mode %d", conn, conn->mode);
 187
 188         hci_conn_enter_sniff_mode(conn);
 189 }
 190
 191 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
 192 {
 193         struct hci_conn *conn;
 194
 195         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 196
 197         conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
 198         if (!conn)
 199                 return NULL;
 200
 201         bacpy(&conn->dst, dst);
 202         conn->hdev   = hdev;
 203         conn->type   = type;
 204         conn->mode   = HCI_CM_ACTIVE;
 205         conn->state  = BT_OPEN;
 206
 207         conn->power_save = 1;
 208
 209         skb_queue_head_init(&conn->data_q);
 210
 211         setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
 212         setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
 213
 214         atomic_set(&conn->refcnt, 0);
 215
 216         hci_dev_hold(hdev);
 217
 218         tasklet_disable(&hdev->tx_task);
 219
 220         hci_conn_hash_add(hdev, conn);
 221         if (hdev->notify)
 222                 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
 223
 224         hci_conn_add_sysfs(conn);
 225
 226         tasklet_enable(&hdev->tx_task);
 227
 228         return conn;
 229 }
 230
 231 int hci_conn_del(struct hci_conn *conn)
 232 {
 233         struct hci_dev *hdev = conn->hdev;
 234
 235         BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
 236
 237         del_timer(&conn->idle_timer);
 238
 239         del_timer(&conn->disc_timer);
 240
 241         if (conn->type == ACL_LINK) {
 242                 struct hci_conn *sco = conn->link;
 243                 if (sco)
 244                         sco->link = NULL;
 245
 246                 /* Unacked frames */
 247                 hdev->acl_cnt += conn->sent;
 248         } else {
 249                 struct hci_conn *acl = conn->link;
 250                 if (acl) {
 251                         acl->link = NULL;
 252                         hci_conn_put(acl);
 253                 }
 254         }
 255
 256         tasklet_disable(&hdev->tx_task);
 257         hci_conn_hash_del(hdev, conn);
 258         if (hdev->notify)
 259                 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
 260         tasklet_enable(&hdev->tx_task);
 261         skb_queue_purge(&conn->data_q);
 262         hci_conn_del_sysfs(conn);
 263 <<<<<<< HEAD:net/bluetooth/hci_conn.c
 264         hci_dev_put(hdev);
 265 =======
 266 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:net/bluetooth/hci_conn.c
 267
 268         return 0;
 269 }
 270
 271 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
 272 {
 273         int use_src = bacmp(src, BDADDR_ANY);
 274         struct hci_dev *hdev = NULL;
 275         struct list_head *p;
 276
 277         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 278
 279         read_lock_bh(&hci_dev_list_lock);
 280
 281         list_for_each(p, &hci_dev_list) {
 282                 struct hci_dev *d = list_entry(p, struct hci_dev, list);
 283
 284                 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
 285                         continue;
 286
 287                 /* Simple routing:
 288                  *   No source address - find interface with bdaddr != dst
 289                  *   Source address    - find interface with bdaddr == src
 290                  */
 291
 292                 if (use_src) {
 293                         if (!bacmp(&d->bdaddr, src)) {
 294                                 hdev = d; break;
 295                         }
 296                 } else {
 297                         if (bacmp(&d->bdaddr, dst)) {
 298                                 hdev = d; break;
 299                         }
 300                 }
 301         }
 302
 303         if (hdev)
 304                 hdev = hci_dev_hold(hdev);
 305
 306         read_unlock_bh(&hci_dev_list_lock);
 307         return hdev;
 308 }
 309 EXPORT_SYMBOL(hci_get_route);
 310
 311 /* Create SCO or ACL connection.
 312  * Device _must_ be locked */
 313 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
 314 {
 315         struct hci_conn *acl;
 316         struct hci_conn *sco;
 317
 318         BT_DBG("%s dst %s", hdev->name, batostr(dst));
 319
 320         if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
 321                 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
 322                         return NULL;
 323         }
 324
 325         hci_conn_hold(acl);
 326
 327         if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
 328                 hci_acl_connect(acl);
 329
 330         if (type == ACL_LINK)
 331                 return acl;
 332
 333         if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
 334                 if (!(sco = hci_conn_add(hdev, type, dst))) {
 335                         hci_conn_put(acl);
 336                         return NULL;
 337                 }
 338         }
 339
 340         acl->link = sco;
 341         sco->link = acl;
 342
 343         hci_conn_hold(sco);
 344
 345         if (acl->state == BT_CONNECTED &&
 346                         (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
 347                 if (lmp_esco_capable(hdev))
 348                         hci_setup_sync(sco, acl->handle);
 349                 else
 350                         hci_add_sco(sco, acl->handle);
 351         }
 352
 353         return sco;
 354 }
 355 EXPORT_SYMBOL(hci_connect);
 356
 357 /* Authenticate remote device */
 358 int hci_conn_auth(struct hci_conn *conn)
 359 {
 360         BT_DBG("conn %p", conn);
 361
 362         if (conn->link_mode & HCI_LM_AUTH)
 363                 return 1;
 364
 365         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
 366                 struct hci_cp_auth_requested cp;
 367                 cp.handle = cpu_to_le16(conn->handle);
 368                 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
 369         }
 370         return 0;
 371 }
 372 EXPORT_SYMBOL(hci_conn_auth);
 373
 374 /* Enable encryption */
 375 int hci_conn_encrypt(struct hci_conn *conn)
 376 {
 377         BT_DBG("conn %p", conn);
 378
 379         if (conn->link_mode & HCI_LM_ENCRYPT)
 380                 return 1;
 381
 382         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
 383                 return 0;
 384
 385         if (hci_conn_auth(conn)) {
 386                 struct hci_cp_set_conn_encrypt cp;
 387                 cp.handle  = cpu_to_le16(conn->handle);
 388                 cp.encrypt = 1;
 389                 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
 390         }
 391         return 0;
 392 }
 393 EXPORT_SYMBOL(hci_conn_encrypt);
 394
 395 /* Change link key */
 396 int hci_conn_change_link_key(struct hci_conn *conn)
 397 {
 398         BT_DBG("conn %p", conn);
 399
 400         if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
 401                 struct hci_cp_change_conn_link_key cp;
 402                 cp.handle = cpu_to_le16(conn->handle);
 403                 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
 404         }
 405         return 0;
 406 }
 407 EXPORT_SYMBOL(hci_conn_change_link_key);
 408
 409 /* Switch role */
 410 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
 411 {
 412         BT_DBG("conn %p", conn);
 413
 414         if (!role && conn->link_mode & HCI_LM_MASTER)
 415                 return 1;
 416
 417         if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
 418                 struct hci_cp_switch_role cp;
 419                 bacpy(&cp.bdaddr, &conn->dst);
 420                 cp.role = role;
 421                 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
 422         }
 423         return 0;
 424 }
 425 EXPORT_SYMBOL(hci_conn_switch_role);
 426
 427 /* Enter active mode */
 428 void hci_conn_enter_active_mode(struct hci_conn *conn)
 429 {
 430         struct hci_dev *hdev = conn->hdev;
 431
 432         BT_DBG("conn %p mode %d", conn, conn->mode);
 433
 434         if (test_bit(HCI_RAW, &hdev->flags))
 435                 return;
 436
 437         if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
 438                 goto timer;
 439
 440         if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
 441                 struct hci_cp_exit_sniff_mode cp;
 442                 cp.handle = cpu_to_le16(conn->handle);
 443                 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
 444         }
 445
 446 timer:
 447         if (hdev->idle_timeout > 0)
 448                 mod_timer(&conn->idle_timer,
 449                         jiffies + msecs_to_jiffies(hdev->idle_timeout));
 450 }
 451
 452 /* Enter sniff mode */
 453 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
 454 {
 455         struct hci_dev *hdev = conn->hdev;
 456
 457         BT_DBG("conn %p mode %d", conn, conn->mode);
 458
 459         if (test_bit(HCI_RAW, &hdev->flags))
 460                 return;
 461
 462         if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
 463                 return;
 464
 465         if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
 466                 return;
 467
 468         if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
 469                 struct hci_cp_sniff_subrate cp;
 470                 cp.handle             = cpu_to_le16(conn->handle);
 471                 cp.max_latency        = cpu_to_le16(0);
 472                 cp.min_remote_timeout = cpu_to_le16(0);
 473                 cp.min_local_timeout  = cpu_to_le16(0);
 474                 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
 475         }
 476
 477         if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
 478                 struct hci_cp_sniff_mode cp;
 479                 cp.handle       = cpu_to_le16(conn->handle);
 480                 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
 481                 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
 482                 cp.attempt      = cpu_to_le16(4);
 483                 cp.timeout      = cpu_to_le16(1);
 484                 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
 485         }
 486 }
 487
 488 /* Drop all connection on the device */
 489 void hci_conn_hash_flush(struct hci_dev *hdev)
 490 {
 491         struct hci_conn_hash *h = &hdev->conn_hash;
 492         struct list_head *p;
 493
 494         BT_DBG("hdev %s", hdev->name);
 495
 496         p = h->list.next;
 497         while (p != &h->list) {
 498                 struct hci_conn *c;
 499
 500                 c = list_entry(p, struct hci_conn, list);
 501                 p = p->next;
 502
 503                 c->state = BT_CLOSED;
 504
 505                 hci_proto_disconn_ind(c, 0x16);
 506                 hci_conn_del(c);
 507         }
 508 }
 509
 510 /* Check pending connect attempts */
 511 void hci_conn_check_pending(struct hci_dev *hdev)
 512 {
 513         struct hci_conn *conn;
 514
 515         BT_DBG("hdev %s", hdev->name);
 516
 517         hci_dev_lock(hdev);
 518
 519         conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
 520         if (conn)
 521                 hci_acl_connect(conn);
 522
 523         hci_dev_unlock(hdev);
 524 }
 525
 526 int hci_get_conn_list(void __user *arg)
 527 {
 528         struct hci_conn_list_req req, *cl;
 529         struct hci_conn_info *ci;
 530         struct hci_dev *hdev;
 531         struct list_head *p;
 532         int n = 0, size, err;
 533
 534         if (copy_from_user(&req, arg, sizeof(req)))
 535                 return -EFAULT;
 536
 537         if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
 538                 return -EINVAL;
 539
 540         size = sizeof(req) + req.conn_num * sizeof(*ci);
 541
 542         if (!(cl = kmalloc(size, GFP_KERNEL)))
 543                 return -ENOMEM;
 544
 545         if (!(hdev = hci_dev_get(req.dev_id))) {
 546                 kfree(cl);
 547                 return -ENODEV;
 548         }
 549
 550         ci = cl->conn_info;
 551
 552         hci_dev_lock_bh(hdev);
 553         list_for_each(p, &hdev->conn_hash.list) {
 554                 register struct hci_conn *c;
 555                 c = list_entry(p, struct hci_conn, list);
 556
 557                 bacpy(&(ci + n)->bdaddr, &c->dst);
 558                 (ci + n)->handle = c->handle;
 559                 (ci + n)->type  = c->type;
 560                 (ci + n)->out   = c->out;
 561                 (ci + n)->state = c->state;
 562                 (ci + n)->link_mode = c->link_mode;
 563                 if (++n >= req.conn_num)
 564                         break;
 565         }
 566         hci_dev_unlock_bh(hdev);
 567
 568         cl->dev_id = hdev->id;
 569         cl->conn_num = n;
 570         size = sizeof(req) + n * sizeof(*ci);
 571
 572         hci_dev_put(hdev);
 573
 574         err = copy_to_user(arg, cl, size);
 575         kfree(cl);
 576
 577         return err ? -EFAULT : 0;
 578 }
 579
 580 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
 581 {
 582         struct hci_conn_info_req req;
 583         struct hci_conn_info ci;
 584         struct hci_conn *conn;
 585         char __user *ptr = arg + sizeof(req);
 586
 587         if (copy_from_user(&req, arg, sizeof(req)))
 588                 return -EFAULT;
 589
 590         hci_dev_lock_bh(hdev);
 591         conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
 592         if (conn) {
 593                 bacpy(&ci.bdaddr, &conn->dst);
 594                 ci.handle = conn->handle;
 595                 ci.type  = conn->type;
 596                 ci.out   = conn->out;
 597                 ci.state = conn->state;
 598                 ci.link_mode = conn->link_mode;
 599         }
 600         hci_dev_unlock_bh(hdev);
 601
 602         if (!conn)
 603                 return -ENOENT;
 604
 605         return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
 606 }