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