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