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