net/bluetooth/sco.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 SCO sockets. */
  26
  27 #include <linux/module.h>
  28 #include <linux/debugfs.h>
  29 #include <linux/seq_file.h>
  30
  31 #include <net/bluetooth/bluetooth.h>
  32 #include <net/bluetooth/hci_core.h>
  33 #include <net/bluetooth/sco.h>
  34
  35 static bool disable_esco;
  36
  37 static const struct proto_ops sco_sock_ops;
  38
  39 static struct bt_sock_list sco_sk_list = {
  40         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
  41 };
  42
  43 /* ---- SCO connections ---- */
  44 struct sco_conn {
  45         struct hci_conn *hcon;
  46
  47         spinlock_t      lock;
  48         struct sock     *sk;
  49
  50         unsigned int    mtu;
  51 };
  52
  53 #define sco_conn_lock(c)        spin_lock(&c->lock);
  54 #define sco_conn_unlock(c)      spin_unlock(&c->lock);
  55
  56 static void sco_sock_close(struct sock *sk);
  57 static void sco_sock_kill(struct sock *sk);
  58
  59 /* ----- SCO socket info ----- */
  60 #define sco_pi(sk) ((struct sco_pinfo *) sk)
  61
  62 struct sco_pinfo {
  63         struct bt_sock  bt;
  64         bdaddr_t        src;
  65         bdaddr_t        dst;
  66         __u32           flags;
  67         __u16           setting;
  68         struct sco_conn *conn;
  69 };
  70
  71 /* ---- SCO timers ---- */
  72 #define SCO_CONN_TIMEOUT        (HZ * 40)
  73 #define SCO_DISCONN_TIMEOUT     (HZ * 2)
  74
  75 static void sco_sock_timeout(unsigned long arg)
  76 {
  77         struct sock *sk = (struct sock *)arg;
  78
  79         BT_DBG("sock %p state %d", sk, sk->sk_state);
  80
  81         bh_lock_sock(sk);
  82         sk->sk_err = ETIMEDOUT;
  83         sk->sk_state_change(sk);
  84         bh_unlock_sock(sk);
  85
  86         sock_put(sk);
  87 }
  88
  89 static void sco_sock_set_timer(struct sock *sk, long timeout)
  90 {
  91         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
  92         sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
  93 }
  94
  95 static void sco_sock_clear_timer(struct sock *sk)
  96 {
  97         BT_DBG("sock %p state %d", sk, sk->sk_state);
  98         sk_stop_timer(sk, &sk->sk_timer);
  99 }
 100
 101 /* ---- SCO connections ---- */
 102 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
 103 {
 104         struct hci_dev *hdev = hcon->hdev;
 105         struct sco_conn *conn = hcon->sco_data;
 106
 107         if (conn)
 108                 return conn;
 109
 110         conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
 111         if (!conn)
 112                 return NULL;
 113
 114         spin_lock_init(&conn->lock);
 115
 116         hcon->sco_data = conn;
 117         conn->hcon = hcon;
 118
 119         if (hdev->sco_mtu > 0)
 120                 conn->mtu = hdev->sco_mtu;
 121         else
 122                 conn->mtu = 60;
 123
 124         BT_DBG("hcon %p conn %p", hcon, conn);
 125
 126         return conn;
 127 }
 128
 129 /* Delete channel.
 130  * Must be called on the locked socket. */
 131 static void sco_chan_del(struct sock *sk, int err)
 132 {
 133         struct sco_conn *conn;
 134
 135         conn = sco_pi(sk)->conn;
 136
 137         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 138
 139         if (conn) {
 140                 sco_conn_lock(conn);
 141                 conn->sk = NULL;
 142                 sco_pi(sk)->conn = NULL;
 143                 sco_conn_unlock(conn);
 144
 145                 if (conn->hcon)
 146                         hci_conn_drop(conn->hcon);
 147         }
 148
 149         sk->sk_state = BT_CLOSED;
 150         sk->sk_err   = err;
 151         sk->sk_state_change(sk);
 152
 153         sock_set_flag(sk, SOCK_ZAPPED);
 154 }
 155
 156 static void sco_conn_del(struct hci_conn *hcon, int err)
 157 {
 158         struct sco_conn *conn = hcon->sco_data;
 159         struct sock *sk;
 160
 161         if (!conn)
 162                 return;
 163
 164         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 165
 166         /* Kill socket */
 167         sco_conn_lock(conn);
 168         sk = conn->sk;
 169         sco_conn_unlock(conn);
 170
 171         if (sk) {
 172                 sock_hold(sk);
 173                 bh_lock_sock(sk);
 174                 sco_sock_clear_timer(sk);
 175                 sco_chan_del(sk, err);
 176                 bh_unlock_sock(sk);
 177                 sock_put(sk);
 178         }
 179
 180         hcon->sco_data = NULL;
 181         kfree(conn);
 182 }
 183
 184 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
 185                            struct sock *parent)
 186 {
 187         BT_DBG("conn %p", conn);
 188
 189         sco_pi(sk)->conn = conn;
 190         conn->sk = sk;
 191
 192         if (parent)
 193                 bt_accept_enqueue(parent, sk);
 194 }
 195
 196 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
 197                         struct sock *parent)
 198 {
 199         int err = 0;
 200
 201         sco_conn_lock(conn);
 202         if (conn->sk)
 203                 err = -EBUSY;
 204         else
 205                 __sco_chan_add(conn, sk, parent);
 206
 207         sco_conn_unlock(conn);
 208         return err;
 209 }
 210
 211 static int sco_connect(struct sock *sk)
 212 {
 213         struct sco_conn *conn;
 214         struct hci_conn *hcon;
 215         struct hci_dev  *hdev;
 216         int err, type;
 217
 218         BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
 219
 220         hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src);
 221         if (!hdev)
 222                 return -EHOSTUNREACH;
 223
 224         hci_dev_lock(hdev);
 225
 226         if (lmp_esco_capable(hdev) && !disable_esco)
 227                 type = ESCO_LINK;
 228         else
 229                 type = SCO_LINK;
 230
 231         if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
 232             (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
 233                 err = -EOPNOTSUPP;
 234                 goto done;
 235         }
 236
 237         hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
 238                                sco_pi(sk)->setting);
 239         if (IS_ERR(hcon)) {
 240                 err = PTR_ERR(hcon);
 241                 goto done;
 242         }
 243
 244         conn = sco_conn_add(hcon);
 245         if (!conn) {
 246                 hci_conn_drop(hcon);
 247                 err = -ENOMEM;
 248                 goto done;
 249         }
 250
 251         /* Update source addr of the socket */
 252         bacpy(&sco_pi(sk)->src, &hcon->src);
 253
 254         err = sco_chan_add(conn, sk, NULL);
 255         if (err)
 256                 goto done;
 257
 258         if (hcon->state == BT_CONNECTED) {
 259                 sco_sock_clear_timer(sk);
 260                 sk->sk_state = BT_CONNECTED;
 261         } else {
 262                 sk->sk_state = BT_CONNECT;
 263                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
 264         }
 265
 266 done:
 267         hci_dev_unlock(hdev);
 268         hci_dev_put(hdev);
 269         return err;
 270 }
 271
 272 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
 273 {
 274         struct sco_conn *conn = sco_pi(sk)->conn;
 275         struct sk_buff *skb;
 276         int err;
 277
 278         /* Check outgoing MTU */
 279         if (len > conn->mtu)
 280                 return -EINVAL;
 281
 282         BT_DBG("sk %p len %d", sk, len);
 283
 284         skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
 285         if (!skb)
 286                 return err;
 287
 288         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
 289                 kfree_skb(skb);
 290                 return -EFAULT;
 291         }
 292
 293         hci_send_sco(conn->hcon, skb);
 294
 295         return len;
 296 }
 297
 298 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 299 {
 300         struct sock *sk;
 301
 302         sco_conn_lock(conn);
 303         sk = conn->sk;
 304         sco_conn_unlock(conn);
 305
 306         if (!sk)
 307                 goto drop;
 308
 309         BT_DBG("sk %p len %d", sk, skb->len);
 310
 311         if (sk->sk_state != BT_CONNECTED)
 312                 goto drop;
 313
 314         if (!sock_queue_rcv_skb(sk, skb))
 315                 return;
 316
 317 drop:
 318         kfree_skb(skb);
 319 }
 320
 321 /* -------- Socket interface ---------- */
 322 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
 323 {
 324         struct sock *sk;
 325
 326         sk_for_each(sk, &sco_sk_list.head) {
 327                 if (sk->sk_state != BT_LISTEN)
 328                         continue;
 329
 330                 if (!bacmp(&sco_pi(sk)->src, ba))
 331                         return sk;
 332         }
 333
 334         return NULL;
 335 }
 336
 337 /* Find socket listening on source bdaddr.
 338  * Returns closest match.
 339  */
 340 static struct sock *sco_get_sock_listen(bdaddr_t *src)
 341 {
 342         struct sock *sk = NULL, *sk1 = NULL;
 343
 344         read_lock(&sco_sk_list.lock);
 345
 346         sk_for_each(sk, &sco_sk_list.head) {
 347                 if (sk->sk_state != BT_LISTEN)
 348                         continue;
 349
 350                 /* Exact match. */
 351                 if (!bacmp(&sco_pi(sk)->src, src))
 352                         break;
 353
 354                 /* Closest match */
 355                 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
 356                         sk1 = sk;
 357         }
 358
 359         read_unlock(&sco_sk_list.lock);
 360
 361         return sk ? sk : sk1;
 362 }
 363
 364 static void sco_sock_destruct(struct sock *sk)
 365 {
 366         BT_DBG("sk %p", sk);
 367
 368         skb_queue_purge(&sk->sk_receive_queue);
 369         skb_queue_purge(&sk->sk_write_queue);
 370 }
 371
 372 static void sco_sock_cleanup_listen(struct sock *parent)
 373 {
 374         struct sock *sk;
 375
 376         BT_DBG("parent %p", parent);
 377
 378         /* Close not yet accepted channels */
 379         while ((sk = bt_accept_dequeue(parent, NULL))) {
 380                 sco_sock_close(sk);
 381                 sco_sock_kill(sk);
 382         }
 383
 384         parent->sk_state  = BT_CLOSED;
 385         sock_set_flag(parent, SOCK_ZAPPED);
 386 }
 387
 388 /* Kill socket (only if zapped and orphan)
 389  * Must be called on unlocked socket.
 390  */
 391 static void sco_sock_kill(struct sock *sk)
 392 {
 393         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 394                 return;
 395
 396         BT_DBG("sk %p state %d", sk, sk->sk_state);
 397
 398         /* Kill poor orphan */
 399         bt_sock_unlink(&sco_sk_list, sk);
 400         sock_set_flag(sk, SOCK_DEAD);
 401         sock_put(sk);
 402 }
 403
 404 static void __sco_sock_close(struct sock *sk)
 405 {
 406         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 407
 408         switch (sk->sk_state) {
 409         case BT_LISTEN:
 410                 sco_sock_cleanup_listen(sk);
 411                 break;
 412
 413         case BT_CONNECTED:
 414         case BT_CONFIG:
 415                 if (sco_pi(sk)->conn->hcon) {
 416                         sk->sk_state = BT_DISCONN;
 417                         sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
 418                         sco_conn_lock(sco_pi(sk)->conn);
 419                         hci_conn_drop(sco_pi(sk)->conn->hcon);
 420                         sco_pi(sk)->conn->hcon = NULL;
 421                         sco_conn_unlock(sco_pi(sk)->conn);
 422                 } else
 423                         sco_chan_del(sk, ECONNRESET);
 424                 break;
 425
 426         case BT_CONNECT2:
 427         case BT_CONNECT:
 428         case BT_DISCONN:
 429                 sco_chan_del(sk, ECONNRESET);
 430                 break;
 431
 432         default:
 433                 sock_set_flag(sk, SOCK_ZAPPED);
 434                 break;
 435         }
 436 }
 437
 438 /* Must be called on unlocked socket. */
 439 static void sco_sock_close(struct sock *sk)
 440 {
 441         sco_sock_clear_timer(sk);
 442         lock_sock(sk);
 443         __sco_sock_close(sk);
 444         release_sock(sk);
 445 }
 446
 447 static void sco_sock_init(struct sock *sk, struct sock *parent)
 448 {
 449         BT_DBG("sk %p", sk);
 450
 451         if (parent) {
 452                 sk->sk_type = parent->sk_type;
 453                 bt_sk(sk)->flags = bt_sk(parent)->flags;
 454                 security_sk_clone(parent, sk);
 455         }
 456 }
 457
 458 static struct proto sco_proto = {
 459         .name           = "SCO",
 460         .owner          = THIS_MODULE,
 461         .obj_size       = sizeof(struct sco_pinfo)
 462 };
 463
 464 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
 465                                    int proto, gfp_t prio, int kern)
 466 {
 467         struct sock *sk;
 468
 469         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
 470         if (!sk)
 471                 return NULL;
 472
 473         sock_init_data(sock, sk);
 474         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 475
 476         sk->sk_destruct = sco_sock_destruct;
 477         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 478
 479         sock_reset_flag(sk, SOCK_ZAPPED);
 480
 481         sk->sk_protocol = proto;
 482         sk->sk_state    = BT_OPEN;
 483
 484         sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
 485
 486         setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
 487
 488         bt_sock_link(&sco_sk_list, sk);
 489         return sk;
 490 }
 491
 492 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
 493                            int kern)
 494 {
 495         struct sock *sk;
 496
 497         BT_DBG("sock %p", sock);
 498
 499         sock->state = SS_UNCONNECTED;
 500
 501         if (sock->type != SOCK_SEQPACKET)
 502                 return -ESOCKTNOSUPPORT;
 503
 504         sock->ops = &sco_sock_ops;
 505
 506         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
 507         if (!sk)
 508                 return -ENOMEM;
 509
 510         sco_sock_init(sk, NULL);
 511         return 0;
 512 }
 513
 514 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
 515                          int addr_len)
 516 {
 517         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 518         struct sock *sk = sock->sk;
 519         int err = 0;
 520
 521         BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
 522
 523         if (!addr || addr->sa_family != AF_BLUETOOTH)
 524                 return -EINVAL;
 525
 526         if (addr_len < sizeof(struct sockaddr_sco))
 527                 return -EINVAL;
 528
 529         lock_sock(sk);
 530
 531         if (sk->sk_state != BT_OPEN) {
 532                 err = -EBADFD;
 533                 goto done;
 534         }
 535
 536         if (sk->sk_type != SOCK_SEQPACKET) {
 537                 err = -EINVAL;
 538                 goto done;
 539         }
 540
 541         bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
 542
 543         sk->sk_state = BT_BOUND;
 544
 545 done:
 546         release_sock(sk);
 547         return err;
 548 }
 549
 550 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 551 {
 552         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 553         struct sock *sk = sock->sk;
 554         int err;
 555
 556         BT_DBG("sk %p", sk);
 557
 558         if (alen < sizeof(struct sockaddr_sco) ||
 559             addr->sa_family != AF_BLUETOOTH)
 560                 return -EINVAL;
 561
 562         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 563                 return -EBADFD;
 564
 565         if (sk->sk_type != SOCK_SEQPACKET)
 566                 return -EINVAL;
 567
 568         lock_sock(sk);
 569
 570         /* Set destination address and psm */
 571         bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
 572
 573         err = sco_connect(sk);
 574         if (err)
 575                 goto done;
 576
 577         err = bt_sock_wait_state(sk, BT_CONNECTED,
 578                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
 579
 580 done:
 581         release_sock(sk);
 582         return err;
 583 }
 584
 585 static int sco_sock_listen(struct socket *sock, int backlog)
 586 {
 587         struct sock *sk = sock->sk;
 588         bdaddr_t *src = &sco_pi(sk)->src;
 589         int err = 0;
 590
 591         BT_DBG("sk %p backlog %d", sk, backlog);
 592
 593         lock_sock(sk);
 594
 595         if (sk->sk_state != BT_BOUND) {
 596                 err = -EBADFD;
 597                 goto done;
 598         }
 599
 600         if (sk->sk_type != SOCK_SEQPACKET) {
 601                 err = -EINVAL;
 602                 goto done;
 603         }
 604
 605         write_lock(&sco_sk_list.lock);
 606
 607         if (__sco_get_sock_listen_by_addr(src)) {
 608                 err = -EADDRINUSE;
 609                 goto unlock;
 610         }
 611
 612         sk->sk_max_ack_backlog = backlog;
 613         sk->sk_ack_backlog = 0;
 614
 615         sk->sk_state = BT_LISTEN;
 616
 617 unlock:
 618         write_unlock(&sco_sk_list.lock);
 619
 620 done:
 621         release_sock(sk);
 622         return err;
 623 }
 624
 625 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
 626                            int flags)
 627 {
 628         DEFINE_WAIT_FUNC(wait, woken_wake_function);
 629         struct sock *sk = sock->sk, *ch;
 630         long timeo;
 631         int err = 0;
 632
 633         lock_sock(sk);
 634
 635         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 636
 637         BT_DBG("sk %p timeo %ld", sk, timeo);
 638
 639         /* Wait for an incoming connection. (wake-one). */
 640         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 641         while (1) {
 642                 if (sk->sk_state != BT_LISTEN) {
 643                         err = -EBADFD;
 644                         break;
 645                 }
 646
 647                 ch = bt_accept_dequeue(sk, newsock);
 648                 if (ch)
 649                         break;
 650
 651                 if (!timeo) {
 652                         err = -EAGAIN;
 653                         break;
 654                 }
 655
 656                 if (signal_pending(current)) {
 657                         err = sock_intr_errno(timeo);
 658                         break;
 659                 }
 660
 661                 release_sock(sk);
 662
 663                 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
 664                 lock_sock(sk);
 665         }
 666         remove_wait_queue(sk_sleep(sk), &wait);
 667
 668         if (err)
 669                 goto done;
 670
 671         newsock->state = SS_CONNECTED;
 672
 673         BT_DBG("new socket %p", ch);
 674
 675 done:
 676         release_sock(sk);
 677         return err;
 678 }
 679
 680 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
 681                             int *len, int peer)
 682 {
 683         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 684         struct sock *sk = sock->sk;
 685
 686         BT_DBG("sock %p, sk %p", sock, sk);
 687
 688         addr->sa_family = AF_BLUETOOTH;
 689         *len = sizeof(struct sockaddr_sco);
 690
 691         if (peer)
 692                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
 693         else
 694                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
 695
 696         return 0;
 697 }
 698
 699 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
 700                             size_t len)
 701 {
 702         struct sock *sk = sock->sk;
 703         int err;
 704
 705         BT_DBG("sock %p, sk %p", sock, sk);
 706
 707         err = sock_error(sk);
 708         if (err)
 709                 return err;
 710
 711         if (msg->msg_flags & MSG_OOB)
 712                 return -EOPNOTSUPP;
 713
 714         lock_sock(sk);
 715
 716         if (sk->sk_state == BT_CONNECTED)
 717                 err = sco_send_frame(sk, msg, len);
 718         else
 719                 err = -ENOTCONN;
 720
 721         release_sock(sk);
 722         return err;
 723 }
 724
 725 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
 726 {
 727         struct hci_dev *hdev = conn->hdev;
 728
 729         BT_DBG("conn %p", conn);
 730
 731         conn->state = BT_CONFIG;
 732
 733         if (!lmp_esco_capable(hdev)) {
 734                 struct hci_cp_accept_conn_req cp;
 735
 736                 bacpy(&cp.bdaddr, &conn->dst);
 737                 cp.role = 0x00; /* Ignored */
 738
 739                 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
 740         } else {
 741                 struct hci_cp_accept_sync_conn_req cp;
 742
 743                 bacpy(&cp.bdaddr, &conn->dst);
 744                 cp.pkt_type = cpu_to_le16(conn->pkt_type);
 745
 746                 cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 747                 cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 748                 cp.content_format = cpu_to_le16(setting);
 749
 750                 switch (setting & SCO_AIRMODE_MASK) {
 751                 case SCO_AIRMODE_TRANSP:
 752                         if (conn->pkt_type & ESCO_2EV3)
 753                                 cp.max_latency = cpu_to_le16(0x0008);
 754                         else
 755                                 cp.max_latency = cpu_to_le16(0x000D);
 756                         cp.retrans_effort = 0x02;
 757                         break;
 758                 case SCO_AIRMODE_CVSD:
 759                         cp.max_latency = cpu_to_le16(0xffff);
 760                         cp.retrans_effort = 0xff;
 761                         break;
 762                 default:
 763                         /* use CVSD settings as fallback */
 764                         cp.max_latency = cpu_to_le16(0xffff);
 765                         cp.retrans_effort = 0xff;
 766                         break;
 767                 }
 768
 769                 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 770                              sizeof(cp), &cp);
 771         }
 772 }
 773
 774 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
 775                             size_t len, int flags)
 776 {
 777         struct sock *sk = sock->sk;
 778         struct sco_pinfo *pi = sco_pi(sk);
 779
 780         lock_sock(sk);
 781
 782         if (sk->sk_state == BT_CONNECT2 &&
 783             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 784                 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
 785                 sk->sk_state = BT_CONFIG;
 786
 787                 release_sock(sk);
 788                 return 0;
 789         }
 790
 791         release_sock(sk);
 792
 793         return bt_sock_recvmsg(sock, msg, len, flags);
 794 }
 795
 796 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
 797                                char __user *optval, unsigned int optlen)
 798 {
 799         struct sock *sk = sock->sk;
 800         int len, err = 0;
 801         struct bt_voice voice;
 802         u32 opt;
 803
 804         BT_DBG("sk %p", sk);
 805
 806         lock_sock(sk);
 807
 808         switch (optname) {
 809
 810         case BT_DEFER_SETUP:
 811                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 812                         err = -EINVAL;
 813                         break;
 814                 }
 815
 816                 if (get_user(opt, (u32 __user *) optval)) {
 817                         err = -EFAULT;
 818                         break;
 819                 }
 820
 821                 if (opt)
 822                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 823                 else
 824                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 825                 break;
 826
 827         case BT_VOICE:
 828                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
 829                     sk->sk_state != BT_CONNECT2) {
 830                         err = -EINVAL;
 831                         break;
 832                 }
 833
 834                 voice.setting = sco_pi(sk)->setting;
 835
 836                 len = min_t(unsigned int, sizeof(voice), optlen);
 837                 if (copy_from_user((char *)&voice, optval, len)) {
 838                         err = -EFAULT;
 839                         break;
 840                 }
 841
 842                 /* Explicitly check for these values */
 843                 if (voice.setting != BT_VOICE_TRANSPARENT &&
 844                     voice.setting != BT_VOICE_CVSD_16BIT) {
 845                         err = -EINVAL;
 846                         break;
 847                 }
 848
 849                 sco_pi(sk)->setting = voice.setting;
 850                 break;
 851
 852         default:
 853                 err = -ENOPROTOOPT;
 854                 break;
 855         }
 856
 857         release_sock(sk);
 858         return err;
 859 }
 860
 861 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
 862                                    char __user *optval, int __user *optlen)
 863 {
 864         struct sock *sk = sock->sk;
 865         struct sco_options opts;
 866         struct sco_conninfo cinfo;
 867         int len, err = 0;
 868
 869         BT_DBG("sk %p", sk);
 870
 871         if (get_user(len, optlen))
 872                 return -EFAULT;
 873
 874         lock_sock(sk);
 875
 876         switch (optname) {
 877         case SCO_OPTIONS:
 878                 if (sk->sk_state != BT_CONNECTED &&
 879                     !(sk->sk_state == BT_CONNECT2 &&
 880                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 881                         err = -ENOTCONN;
 882                         break;
 883                 }
 884
 885                 opts.mtu = sco_pi(sk)->conn->mtu;
 886
 887                 BT_DBG("mtu %d", opts.mtu);
 888
 889                 len = min_t(unsigned int, len, sizeof(opts));
 890                 if (copy_to_user(optval, (char *)&opts, len))
 891                         err = -EFAULT;
 892
 893                 break;
 894
 895         case SCO_CONNINFO:
 896                 if (sk->sk_state != BT_CONNECTED &&
 897                     !(sk->sk_state == BT_CONNECT2 &&
 898                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 899                         err = -ENOTCONN;
 900                         break;
 901                 }
 902
 903                 memset(&cinfo, 0, sizeof(cinfo));
 904                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 905                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 906
 907                 len = min_t(unsigned int, len, sizeof(cinfo));
 908                 if (copy_to_user(optval, (char *)&cinfo, len))
 909                         err = -EFAULT;
 910
 911                 break;
 912
 913         default:
 914                 err = -ENOPROTOOPT;
 915                 break;
 916         }
 917
 918         release_sock(sk);
 919         return err;
 920 }
 921
 922 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
 923                                char __user *optval, int __user *optlen)
 924 {
 925         struct sock *sk = sock->sk;
 926         int len, err = 0;
 927         struct bt_voice voice;
 928
 929         BT_DBG("sk %p", sk);
 930
 931         if (level == SOL_SCO)
 932                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 933
 934         if (get_user(len, optlen))
 935                 return -EFAULT;
 936
 937         lock_sock(sk);
 938
 939         switch (optname) {
 940
 941         case BT_DEFER_SETUP:
 942                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 943                         err = -EINVAL;
 944                         break;
 945                 }
 946
 947                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
 948                              (u32 __user *)optval))
 949                         err = -EFAULT;
 950
 951                 break;
 952
 953         case BT_VOICE:
 954                 voice.setting = sco_pi(sk)->setting;
 955
 956                 len = min_t(unsigned int, len, sizeof(voice));
 957                 if (copy_to_user(optval, (char *)&voice, len))
 958                         err = -EFAULT;
 959
 960                 break;
 961
 962         default:
 963                 err = -ENOPROTOOPT;
 964                 break;
 965         }
 966
 967         release_sock(sk);
 968         return err;
 969 }
 970
 971 static int sco_sock_shutdown(struct socket *sock, int how)
 972 {
 973         struct sock *sk = sock->sk;
 974         int err = 0;
 975
 976         BT_DBG("sock %p, sk %p", sock, sk);
 977
 978         if (!sk)
 979                 return 0;
 980
 981         sock_hold(sk);
 982         lock_sock(sk);
 983
 984         if (!sk->sk_shutdown) {
 985                 sk->sk_shutdown = SHUTDOWN_MASK;
 986                 sco_sock_clear_timer(sk);
 987                 __sco_sock_close(sk);
 988
 989                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
 990                     !(current->flags & PF_EXITING))
 991                         err = bt_sock_wait_state(sk, BT_CLOSED,
 992                                                  sk->sk_lingertime);
 993         }
 994
 995         release_sock(sk);
 996         sock_put(sk);
 997
 998         return err;
 999 }
1000
1001 static int sco_sock_release(struct socket *sock)
1002 {
1003         struct sock *sk = sock->sk;
1004         int err = 0;
1005
1006         BT_DBG("sock %p, sk %p", sock, sk);
1007
1008         if (!sk)
1009                 return 0;
1010
1011         sco_sock_close(sk);
1012
1013         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1014             !(current->flags & PF_EXITING)) {
1015                 lock_sock(sk);
1016                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1017                 release_sock(sk);
1018         }
1019
1020         sock_orphan(sk);
1021         sco_sock_kill(sk);
1022         return err;
1023 }
1024
1025 static void sco_conn_ready(struct sco_conn *conn)
1026 {
1027         struct sock *parent;
1028         struct sock *sk = conn->sk;
1029
1030         BT_DBG("conn %p", conn);
1031
1032         if (sk) {
1033                 sco_sock_clear_timer(sk);
1034                 bh_lock_sock(sk);
1035                 sk->sk_state = BT_CONNECTED;
1036                 sk->sk_state_change(sk);
1037                 bh_unlock_sock(sk);
1038         } else {
1039                 sco_conn_lock(conn);
1040
1041                 if (!conn->hcon) {
1042                         sco_conn_unlock(conn);
1043                         return;
1044                 }
1045
1046                 parent = sco_get_sock_listen(&conn->hcon->src);
1047                 if (!parent) {
1048                         sco_conn_unlock(conn);
1049                         return;
1050                 }
1051
1052                 bh_lock_sock(parent);
1053
1054                 sk = sco_sock_alloc(sock_net(parent), NULL,
1055                                     BTPROTO_SCO, GFP_ATOMIC, 0);
1056                 if (!sk) {
1057                         bh_unlock_sock(parent);
1058                         sco_conn_unlock(conn);
1059                         return;
1060                 }
1061
1062                 sco_sock_init(sk, parent);
1063
1064                 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1065                 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1066
1067                 hci_conn_hold(conn->hcon);
1068                 __sco_chan_add(conn, sk, parent);
1069
1070                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1071                         sk->sk_state = BT_CONNECT2;
1072                 else
1073                         sk->sk_state = BT_CONNECTED;
1074
1075                 /* Wake up parent */
1076                 parent->sk_data_ready(parent);
1077
1078                 bh_unlock_sock(parent);
1079
1080                 sco_conn_unlock(conn);
1081         }
1082 }
1083
1084 /* ----- SCO interface with lower layer (HCI) ----- */
1085 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1086 {
1087         struct sock *sk;
1088         int lm = 0;
1089
1090         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1091
1092         /* Find listening sockets */
1093         read_lock(&sco_sk_list.lock);
1094         sk_for_each(sk, &sco_sk_list.head) {
1095                 if (sk->sk_state != BT_LISTEN)
1096                         continue;
1097
1098                 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1099                     !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1100                         lm |= HCI_LM_ACCEPT;
1101
1102                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1103                                 *flags |= HCI_PROTO_DEFER;
1104                         break;
1105                 }
1106         }
1107         read_unlock(&sco_sk_list.lock);
1108
1109         return lm;
1110 }
1111
1112 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1113 {
1114         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1115                 return;
1116
1117         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1118
1119         if (!status) {
1120                 struct sco_conn *conn;
1121
1122                 conn = sco_conn_add(hcon);
1123                 if (conn)
1124                         sco_conn_ready(conn);
1125         } else
1126                 sco_conn_del(hcon, bt_to_errno(status));
1127 }
1128
1129 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1130 {
1131         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1132                 return;
1133
1134         BT_DBG("hcon %p reason %d", hcon, reason);
1135
1136         sco_conn_del(hcon, bt_to_errno(reason));
1137 }
1138
1139 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1140 {
1141         struct sco_conn *conn = hcon->sco_data;
1142
1143         if (!conn)
1144                 goto drop;
1145
1146         BT_DBG("conn %p len %d", conn, skb->len);
1147
1148         if (skb->len) {
1149                 sco_recv_frame(conn, skb);
1150                 return;
1151         }
1152
1153 drop:
1154         kfree_skb(skb);
1155 }
1156
1157 static struct hci_cb sco_cb = {
1158         .name           = "SCO",
1159         .connect_cfm    = sco_connect_cfm,
1160         .disconn_cfm    = sco_disconn_cfm,
1161 };
1162
1163 static int sco_debugfs_show(struct seq_file *f, void *p)
1164 {
1165         struct sock *sk;
1166
1167         read_lock(&sco_sk_list.lock);
1168
1169         sk_for_each(sk, &sco_sk_list.head) {
1170                 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1171                            &sco_pi(sk)->dst, sk->sk_state);
1172         }
1173
1174         read_unlock(&sco_sk_list.lock);
1175
1176         return 0;
1177 }
1178
1179 static int sco_debugfs_open(struct inode *inode, struct file *file)
1180 {
1181         return single_open(file, sco_debugfs_show, inode->i_private);
1182 }
1183
1184 static const struct file_operations sco_debugfs_fops = {
1185         .open           = sco_debugfs_open,
1186         .read           = seq_read,
1187         .llseek         = seq_lseek,
1188         .release        = single_release,
1189 };
1190
1191 static struct dentry *sco_debugfs;
1192
1193 static const struct proto_ops sco_sock_ops = {
1194         .family         = PF_BLUETOOTH,
1195         .owner          = THIS_MODULE,
1196         .release        = sco_sock_release,
1197         .bind           = sco_sock_bind,
1198         .connect        = sco_sock_connect,
1199         .listen         = sco_sock_listen,
1200         .accept         = sco_sock_accept,
1201         .getname        = sco_sock_getname,
1202         .sendmsg        = sco_sock_sendmsg,
1203         .recvmsg        = sco_sock_recvmsg,
1204         .poll           = bt_sock_poll,
1205         .ioctl          = bt_sock_ioctl,
1206         .mmap           = sock_no_mmap,
1207         .socketpair     = sock_no_socketpair,
1208         .shutdown       = sco_sock_shutdown,
1209         .setsockopt     = sco_sock_setsockopt,
1210         .getsockopt     = sco_sock_getsockopt
1211 };
1212
1213 static const struct net_proto_family sco_sock_family_ops = {
1214         .family = PF_BLUETOOTH,
1215         .owner  = THIS_MODULE,
1216         .create = sco_sock_create,
1217 };
1218
1219 int __init sco_init(void)
1220 {
1221         int err;
1222
1223         BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1224
1225         err = proto_register(&sco_proto, 0);
1226         if (err < 0)
1227                 return err;
1228
1229         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1230         if (err < 0) {
1231                 BT_ERR("SCO socket registration failed");
1232                 goto error;
1233         }
1234
1235         err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1236         if (err < 0) {
1237                 BT_ERR("Failed to create SCO proc file");
1238                 bt_sock_unregister(BTPROTO_SCO);
1239                 goto error;
1240         }
1241
1242         BT_INFO("SCO socket layer initialized");
1243
1244         hci_register_cb(&sco_cb);
1245
1246         if (IS_ERR_OR_NULL(bt_debugfs))
1247                 return 0;
1248
1249         sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1250                                           NULL, &sco_debugfs_fops);
1251
1252         return 0;
1253
1254 error:
1255         proto_unregister(&sco_proto);
1256         return err;
1257 }
1258
1259 void sco_exit(void)
1260 {
1261         bt_procfs_cleanup(&init_net, "sco");
1262
1263         debugfs_remove(sco_debugfs);
1264
1265         hci_unregister_cb(&sco_cb);
1266
1267         bt_sock_unregister(BTPROTO_SCO);
1268
1269         proto_unregister(&sco_proto);
1270 }
1271
1272 module_param(disable_esco, bool, 0644);
1273 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");