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