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