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