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 #include <linux/sched/signal.h>
  31
  32 #include <net/bluetooth/bluetooth.h>
  33 #include <net/bluetooth/hci_core.h>
  34 #include <net/bluetooth/sco.h>
  35
  36 #ifdef TIZEN_BT
  37 #include <net/bluetooth/mgmt.h>
  38 #include <net/bluetooth/mgmt_tizen.h>
  39 #endif
  40
  41 static bool disable_esco;
  42
  43 static const struct proto_ops sco_sock_ops;
  44
  45 static struct bt_sock_list sco_sk_list = {
  46         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
  47 };
  48
  49 /* ---- SCO connections ---- */
  50 struct sco_conn {
  51         struct hci_conn *hcon;
  52
  53         spinlock_t      lock;
  54         struct sock     *sk;
  55
  56         struct delayed_work     timeout_work;
  57
  58         unsigned int    mtu;
  59 };
  60
  61 #define sco_conn_lock(c)        spin_lock(&c->lock)
  62 #define sco_conn_unlock(c)      spin_unlock(&c->lock)
  63
  64 static void sco_sock_close(struct sock *sk);
  65 static void sco_sock_kill(struct sock *sk);
  66
  67 /* ----- SCO socket info ----- */
  68 #define sco_pi(sk) ((struct sco_pinfo *) sk)
  69
  70 struct sco_pinfo {
  71         struct bt_sock  bt;
  72         bdaddr_t        src;
  73         bdaddr_t        dst;
  74         __u32           flags;
  75         __u16           setting;
  76         __u8            cmsg_mask;
  77         struct sco_conn *conn;
  78 };
  79
  80 /* ---- SCO timers ---- */
  81 #define SCO_CONN_TIMEOUT        (HZ * 40)
  82 #define SCO_DISCONN_TIMEOUT     (HZ * 2)
  83
  84 static void sco_sock_timeout(struct work_struct *work)
  85 {
  86         struct sco_conn *conn = container_of(work, struct sco_conn,
  87                                              timeout_work.work);
  88         struct sock *sk;
  89
  90         sco_conn_lock(conn);
  91         sk = conn->sk;
  92         if (sk)
  93                 sock_hold(sk);
  94         sco_conn_unlock(conn);
  95
  96         if (!sk)
  97                 return;
  98
  99         BT_DBG("sock %p state %d", sk, sk->sk_state);
 100
 101         lock_sock(sk);
 102         sk->sk_err = ETIMEDOUT;
 103         sk->sk_state_change(sk);
 104         release_sock(sk);
 105         sock_put(sk);
 106 }
 107
 108 static void sco_sock_set_timer(struct sock *sk, long timeout)
 109 {
 110         if (!sco_pi(sk)->conn)
 111                 return;
 112
 113         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
 114         cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
 115         schedule_delayed_work(&sco_pi(sk)->conn->timeout_work, timeout);
 116 }
 117
 118 static void sco_sock_clear_timer(struct sock *sk)
 119 {
 120         if (!sco_pi(sk)->conn)
 121                 return;
 122
 123         BT_DBG("sock %p state %d", sk, sk->sk_state);
 124         cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
 125 }
 126
 127 /* ---- SCO connections ---- */
 128 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
 129 {
 130         struct hci_dev *hdev = hcon->hdev;
 131         struct sco_conn *conn = hcon->sco_data;
 132
 133         if (conn)
 134                 return conn;
 135
 136         conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
 137         if (!conn)
 138                 return NULL;
 139
 140         spin_lock_init(&conn->lock);
 141
 142         hcon->sco_data = conn;
 143         conn->hcon = hcon;
 144
 145         if (hdev->sco_mtu > 0)
 146                 conn->mtu = hdev->sco_mtu;
 147         else
 148                 conn->mtu = 60;
 149
 150         BT_DBG("hcon %p conn %p", hcon, conn);
 151
 152         return conn;
 153 }
 154
 155 /* Delete channel.
 156  * Must be called on the locked socket. */
 157 static void sco_chan_del(struct sock *sk, int err)
 158 {
 159         struct sco_conn *conn;
 160
 161         conn = sco_pi(sk)->conn;
 162
 163         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 164
 165         if (conn) {
 166                 sco_conn_lock(conn);
 167                 conn->sk = NULL;
 168                 sco_pi(sk)->conn = NULL;
 169                 sco_conn_unlock(conn);
 170
 171                 if (conn->hcon)
 172                         hci_conn_drop(conn->hcon);
 173         }
 174
 175         sk->sk_state = BT_CLOSED;
 176         sk->sk_err   = err;
 177         sk->sk_state_change(sk);
 178
 179         sock_set_flag(sk, SOCK_ZAPPED);
 180 }
 181
 182 static void sco_conn_del(struct hci_conn *hcon, int err)
 183 {
 184         struct sco_conn *conn = hcon->sco_data;
 185         struct sock *sk;
 186
 187         if (!conn)
 188                 return;
 189
 190         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 191
 192         /* Kill socket */
 193         sco_conn_lock(conn);
 194         sk = conn->sk;
 195         sco_conn_unlock(conn);
 196
 197         if (sk) {
 198                 sock_hold(sk);
 199                 lock_sock(sk);
 200                 sco_sock_clear_timer(sk);
 201                 sco_chan_del(sk, err);
 202                 release_sock(sk);
 203                 sock_put(sk);
 204
 205                 /* Ensure no more work items will run before freeing conn. */
 206                 cancel_delayed_work_sync(&conn->timeout_work);
 207         }
 208
 209         hcon->sco_data = NULL;
 210         kfree(conn);
 211 }
 212
 213 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
 214                            struct sock *parent)
 215 {
 216         BT_DBG("conn %p", conn);
 217
 218         sco_pi(sk)->conn = conn;
 219         conn->sk = sk;
 220
 221         INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
 222
 223         if (parent)
 224                 bt_accept_enqueue(parent, sk, true);
 225 }
 226
 227 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
 228                         struct sock *parent)
 229 {
 230         int err = 0;
 231
 232         sco_conn_lock(conn);
 233         if (conn->sk)
 234                 err = -EBUSY;
 235         else
 236                 __sco_chan_add(conn, sk, parent);
 237
 238         sco_conn_unlock(conn);
 239         return err;
 240 }
 241
 242 static int sco_connect(struct hci_dev *hdev, struct sock *sk)
 243 {
 244         struct sco_conn *conn;
 245         struct hci_conn *hcon;
 246         int err, type;
 247
 248         BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
 249
 250         if (lmp_esco_capable(hdev) && !disable_esco)
 251                 type = ESCO_LINK;
 252         else
 253                 type = SCO_LINK;
 254
 255         if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
 256             (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev)))
 257                 return -EOPNOTSUPP;
 258
 259         hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
 260                                sco_pi(sk)->setting);
 261         if (IS_ERR(hcon))
 262                 return PTR_ERR(hcon);
 263
 264         conn = sco_conn_add(hcon);
 265         if (!conn) {
 266                 hci_conn_drop(hcon);
 267                 return -ENOMEM;
 268         }
 269
 270         /* Update source addr of the socket */
 271         bacpy(&sco_pi(sk)->src, &hcon->src);
 272
 273         err = sco_chan_add(conn, sk, NULL);
 274         if (err)
 275                 return err;
 276
 277         if (hcon->state == BT_CONNECTED) {
 278                 sco_sock_clear_timer(sk);
 279                 sk->sk_state = BT_CONNECTED;
 280         } else {
 281                 sk->sk_state = BT_CONNECT;
 282                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
 283         }
 284
 285         return err;
 286 }
 287
 288 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
 289 {
 290         struct sco_conn *conn = sco_pi(sk)->conn;
 291         struct sk_buff *skb;
 292         int err;
 293
 294         /* Check outgoing MTU */
 295         if (len > conn->mtu)
 296                 return -EINVAL;
 297
 298         BT_DBG("sk %p len %d", sk, len);
 299
 300         skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
 301         if (!skb)
 302                 return err;
 303
 304         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
 305                 kfree_skb(skb);
 306                 return -EFAULT;
 307         }
 308
 309         hci_send_sco(conn->hcon, skb);
 310
 311         return len;
 312 }
 313
 314 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 315 {
 316         struct sock *sk;
 317
 318         sco_conn_lock(conn);
 319         sk = conn->sk;
 320         sco_conn_unlock(conn);
 321
 322         if (!sk)
 323                 goto drop;
 324
 325         BT_DBG("sk %p len %u", sk, skb->len);
 326
 327         if (sk->sk_state != BT_CONNECTED)
 328                 goto drop;
 329
 330         if (!sock_queue_rcv_skb(sk, skb))
 331                 return;
 332
 333 drop:
 334         kfree_skb(skb);
 335 }
 336
 337 /* -------- Socket interface ---------- */
 338 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
 339 {
 340         struct sock *sk;
 341
 342         sk_for_each(sk, &sco_sk_list.head) {
 343                 if (sk->sk_state != BT_LISTEN)
 344                         continue;
 345
 346                 if (!bacmp(&sco_pi(sk)->src, ba))
 347                         return sk;
 348         }
 349
 350         return NULL;
 351 }
 352
 353 /* Find socket listening on source bdaddr.
 354  * Returns closest match.
 355  */
 356 static struct sock *sco_get_sock_listen(bdaddr_t *src)
 357 {
 358         struct sock *sk = NULL, *sk1 = NULL;
 359
 360         read_lock(&sco_sk_list.lock);
 361
 362         sk_for_each(sk, &sco_sk_list.head) {
 363                 if (sk->sk_state != BT_LISTEN)
 364                         continue;
 365
 366                 /* Exact match. */
 367                 if (!bacmp(&sco_pi(sk)->src, src))
 368                         break;
 369
 370                 /* Closest match */
 371                 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
 372                         sk1 = sk;
 373         }
 374
 375         read_unlock(&sco_sk_list.lock);
 376
 377         return sk ? sk : sk1;
 378 }
 379
 380 static void sco_sock_destruct(struct sock *sk)
 381 {
 382         BT_DBG("sk %p", sk);
 383
 384         skb_queue_purge(&sk->sk_receive_queue);
 385         skb_queue_purge(&sk->sk_write_queue);
 386 }
 387
 388 static void sco_sock_cleanup_listen(struct sock *parent)
 389 {
 390         struct sock *sk;
 391
 392         BT_DBG("parent %p", parent);
 393
 394         /* Close not yet accepted channels */
 395         while ((sk = bt_accept_dequeue(parent, NULL))) {
 396                 sco_sock_close(sk);
 397                 sco_sock_kill(sk);
 398         }
 399
 400         parent->sk_state  = BT_CLOSED;
 401         sock_set_flag(parent, SOCK_ZAPPED);
 402 }
 403
 404 /* Kill socket (only if zapped and orphan)
 405  * Must be called on unlocked socket.
 406  */
 407 static void sco_sock_kill(struct sock *sk)
 408 {
 409         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 410                 return;
 411
 412         BT_DBG("sk %p state %d", sk, sk->sk_state);
 413
 414         /* Kill poor orphan */
 415         bt_sock_unlink(&sco_sk_list, sk);
 416         sock_set_flag(sk, SOCK_DEAD);
 417         sock_put(sk);
 418 }
 419
 420 static void __sco_sock_close(struct sock *sk)
 421 {
 422         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 423
 424         switch (sk->sk_state) {
 425         case BT_LISTEN:
 426                 sco_sock_cleanup_listen(sk);
 427                 break;
 428
 429         case BT_CONNECTED:
 430         case BT_CONFIG:
 431                 if (sco_pi(sk)->conn->hcon) {
 432                         sk->sk_state = BT_DISCONN;
 433                         sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
 434                         sco_conn_lock(sco_pi(sk)->conn);
 435                         hci_conn_drop(sco_pi(sk)->conn->hcon);
 436                         sco_pi(sk)->conn->hcon = NULL;
 437                         sco_conn_unlock(sco_pi(sk)->conn);
 438                 } else
 439                         sco_chan_del(sk, ECONNRESET);
 440                 break;
 441
 442         case BT_CONNECT2:
 443         case BT_CONNECT:
 444         case BT_DISCONN:
 445                 sco_chan_del(sk, ECONNRESET);
 446                 break;
 447
 448         default:
 449                 sock_set_flag(sk, SOCK_ZAPPED);
 450                 break;
 451         }
 452 }
 453
 454 /* Must be called on unlocked socket. */
 455 static void sco_sock_close(struct sock *sk)
 456 {
 457         lock_sock(sk);
 458         sco_sock_clear_timer(sk);
 459         __sco_sock_close(sk);
 460         release_sock(sk);
 461 }
 462
 463 static void sco_skb_put_cmsg(struct sk_buff *skb, struct msghdr *msg,
 464                              struct sock *sk)
 465 {
 466         if (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS)
 467                 put_cmsg(msg, SOL_BLUETOOTH, BT_SCM_PKT_STATUS,
 468                          sizeof(bt_cb(skb)->sco.pkt_status),
 469                          &bt_cb(skb)->sco.pkt_status);
 470 }
 471
 472 static void sco_sock_init(struct sock *sk, struct sock *parent)
 473 {
 474         BT_DBG("sk %p", sk);
 475
 476         if (parent) {
 477                 sk->sk_type = parent->sk_type;
 478                 bt_sk(sk)->flags = bt_sk(parent)->flags;
 479                 security_sk_clone(parent, sk);
 480         } else {
 481                 bt_sk(sk)->skb_put_cmsg = sco_skb_put_cmsg;
 482         }
 483 }
 484
 485 static struct proto sco_proto = {
 486         .name           = "SCO",
 487         .owner          = THIS_MODULE,
 488         .obj_size       = sizeof(struct sco_pinfo)
 489 };
 490
 491 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
 492                                    int proto, gfp_t prio, int kern)
 493 {
 494         struct sock *sk;
 495
 496         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
 497         if (!sk)
 498                 return NULL;
 499
 500         sock_init_data(sock, sk);
 501         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 502
 503         sk->sk_destruct = sco_sock_destruct;
 504         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 505
 506         sock_reset_flag(sk, SOCK_ZAPPED);
 507
 508         sk->sk_protocol = proto;
 509         sk->sk_state    = BT_OPEN;
 510
 511         sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
 512
 513         bt_sock_link(&sco_sk_list, sk);
 514         return sk;
 515 }
 516
 517 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
 518                            int kern)
 519 {
 520         struct sock *sk;
 521
 522         BT_DBG("sock %p", sock);
 523
 524         sock->state = SS_UNCONNECTED;
 525
 526         if (sock->type != SOCK_SEQPACKET)
 527                 return -ESOCKTNOSUPPORT;
 528
 529         sock->ops = &sco_sock_ops;
 530
 531         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
 532         if (!sk)
 533                 return -ENOMEM;
 534
 535         sco_sock_init(sk, NULL);
 536         return 0;
 537 }
 538
 539 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
 540                          int addr_len)
 541 {
 542         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 543         struct sock *sk = sock->sk;
 544         int err = 0;
 545
 546         if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
 547             addr->sa_family != AF_BLUETOOTH)
 548                 return -EINVAL;
 549
 550         BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
 551
 552         lock_sock(sk);
 553
 554         if (sk->sk_state != BT_OPEN) {
 555                 err = -EBADFD;
 556                 goto done;
 557         }
 558
 559         if (sk->sk_type != SOCK_SEQPACKET) {
 560                 err = -EINVAL;
 561                 goto done;
 562         }
 563
 564         bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
 565
 566         sk->sk_state = BT_BOUND;
 567
 568 done:
 569         release_sock(sk);
 570         return err;
 571 }
 572
 573 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 574 {
 575         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 576         struct sock *sk = sock->sk;
 577         struct hci_dev  *hdev;
 578         int err;
 579
 580         BT_DBG("sk %p", sk);
 581
 582         if (alen < sizeof(struct sockaddr_sco) ||
 583             addr->sa_family != AF_BLUETOOTH)
 584                 return -EINVAL;
 585
 586         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 587                 return -EBADFD;
 588
 589         if (sk->sk_type != SOCK_SEQPACKET)
 590                 return -EINVAL;
 591
 592         hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
 593         if (!hdev)
 594                 return -EHOSTUNREACH;
 595         hci_dev_lock(hdev);
 596
 597         lock_sock(sk);
 598
 599         /* Set destination address and psm */
 600         bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
 601
 602         err = sco_connect(hdev, sk);
 603         hci_dev_unlock(hdev);
 604         hci_dev_put(hdev);
 605         if (err)
 606                 goto done;
 607
 608         err = bt_sock_wait_state(sk, BT_CONNECTED,
 609                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
 610
 611 done:
 612         release_sock(sk);
 613         return err;
 614 }
 615
 616 static int sco_sock_listen(struct socket *sock, int backlog)
 617 {
 618         struct sock *sk = sock->sk;
 619         bdaddr_t *src = &sco_pi(sk)->src;
 620         int err = 0;
 621
 622         BT_DBG("sk %p backlog %d", sk, backlog);
 623
 624         lock_sock(sk);
 625
 626         if (sk->sk_state != BT_BOUND) {
 627                 err = -EBADFD;
 628                 goto done;
 629         }
 630
 631         if (sk->sk_type != SOCK_SEQPACKET) {
 632                 err = -EINVAL;
 633                 goto done;
 634         }
 635
 636         write_lock(&sco_sk_list.lock);
 637
 638         if (__sco_get_sock_listen_by_addr(src)) {
 639                 err = -EADDRINUSE;
 640                 goto unlock;
 641         }
 642
 643         sk->sk_max_ack_backlog = backlog;
 644         sk->sk_ack_backlog = 0;
 645
 646         sk->sk_state = BT_LISTEN;
 647
 648 unlock:
 649         write_unlock(&sco_sk_list.lock);
 650
 651 done:
 652         release_sock(sk);
 653         return err;
 654 }
 655
 656 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
 657                            int flags, bool kern)
 658 {
 659         DEFINE_WAIT_FUNC(wait, woken_wake_function);
 660         struct sock *sk = sock->sk, *ch;
 661         long timeo;
 662         int err = 0;
 663
 664         lock_sock(sk);
 665
 666         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 667
 668         BT_DBG("sk %p timeo %ld", sk, timeo);
 669
 670         /* Wait for an incoming connection. (wake-one). */
 671         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 672         while (1) {
 673                 if (sk->sk_state != BT_LISTEN) {
 674                         err = -EBADFD;
 675                         break;
 676                 }
 677
 678                 ch = bt_accept_dequeue(sk, newsock);
 679                 if (ch)
 680                         break;
 681
 682                 if (!timeo) {
 683                         err = -EAGAIN;
 684                         break;
 685                 }
 686
 687                 if (signal_pending(current)) {
 688                         err = sock_intr_errno(timeo);
 689                         break;
 690                 }
 691
 692                 release_sock(sk);
 693
 694                 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
 695                 lock_sock(sk);
 696         }
 697         remove_wait_queue(sk_sleep(sk), &wait);
 698
 699         if (err)
 700                 goto done;
 701
 702         newsock->state = SS_CONNECTED;
 703
 704         BT_DBG("new socket %p", ch);
 705
 706 done:
 707         release_sock(sk);
 708         return err;
 709 }
 710
 711 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
 712                             int peer)
 713 {
 714         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 715         struct sock *sk = sock->sk;
 716
 717         BT_DBG("sock %p, sk %p", sock, sk);
 718
 719         addr->sa_family = AF_BLUETOOTH;
 720
 721         if (peer)
 722                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
 723         else
 724                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
 725
 726         return sizeof(struct sockaddr_sco);
 727 }
 728
 729 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
 730                             size_t len)
 731 {
 732         struct sock *sk = sock->sk;
 733         int err;
 734
 735         BT_DBG("sock %p, sk %p", sock, sk);
 736
 737         err = sock_error(sk);
 738         if (err)
 739                 return err;
 740
 741         if (msg->msg_flags & MSG_OOB)
 742                 return -EOPNOTSUPP;
 743
 744         lock_sock(sk);
 745
 746         if (sk->sk_state == BT_CONNECTED)
 747                 err = sco_send_frame(sk, msg, len);
 748         else
 749                 err = -ENOTCONN;
 750
 751         release_sock(sk);
 752         return err;
 753 }
 754
 755 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
 756 {
 757         struct hci_dev *hdev = conn->hdev;
 758
 759         BT_DBG("conn %p", conn);
 760
 761         conn->state = BT_CONFIG;
 762
 763         if (!lmp_esco_capable(hdev)) {
 764                 struct hci_cp_accept_conn_req cp;
 765
 766                 bacpy(&cp.bdaddr, &conn->dst);
 767                 cp.role = 0x00; /* Ignored */
 768
 769                 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
 770         } else {
 771                 struct hci_cp_accept_sync_conn_req cp;
 772
 773                 bacpy(&cp.bdaddr, &conn->dst);
 774                 cp.pkt_type = cpu_to_le16(conn->pkt_type);
 775
 776                 cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
 777                 cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
 778                 cp.content_format = cpu_to_le16(setting);
 779
 780                 switch (setting & SCO_AIRMODE_MASK) {
 781                 case SCO_AIRMODE_TRANSP:
 782                         if (conn->pkt_type & ESCO_2EV3)
 783                                 cp.max_latency = cpu_to_le16(0x0008);
 784                         else
 785                                 cp.max_latency = cpu_to_le16(0x000D);
 786                         cp.retrans_effort = 0x02;
 787                         break;
 788                 case SCO_AIRMODE_CVSD:
 789                         cp.max_latency = cpu_to_le16(0xffff);
 790                         cp.retrans_effort = 0xff;
 791                         break;
 792                 default:
 793                         /* use CVSD settings as fallback */
 794                         cp.max_latency = cpu_to_le16(0xffff);
 795                         cp.retrans_effort = 0xff;
 796                         break;
 797                 }
 798
 799                 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
 800                              sizeof(cp), &cp);
 801         }
 802 }
 803
 804 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
 805                             size_t len, int flags)
 806 {
 807         struct sock *sk = sock->sk;
 808         struct sco_pinfo *pi = sco_pi(sk);
 809
 810         lock_sock(sk);
 811
 812         if (sk->sk_state == BT_CONNECT2 &&
 813             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
 814                 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
 815                 sk->sk_state = BT_CONFIG;
 816
 817                 release_sock(sk);
 818                 return 0;
 819         }
 820
 821         release_sock(sk);
 822
 823         return bt_sock_recvmsg(sock, msg, len, flags);
 824 }
 825
 826 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
 827                                sockptr_t optval, unsigned int optlen)
 828 {
 829         struct sock *sk = sock->sk;
 830         int len, err = 0;
 831         struct bt_voice voice;
 832         u32 opt;
 833
 834         BT_DBG("sk %p", sk);
 835
 836         lock_sock(sk);
 837
 838         switch (optname) {
 839
 840         case BT_DEFER_SETUP:
 841                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 842                         err = -EINVAL;
 843                         break;
 844                 }
 845
 846                 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
 847                         err = -EFAULT;
 848                         break;
 849                 }
 850
 851                 if (opt)
 852                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 853                 else
 854                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 855                 break;
 856
 857         case BT_VOICE:
 858                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
 859                     sk->sk_state != BT_CONNECT2) {
 860                         err = -EINVAL;
 861                         break;
 862                 }
 863
 864                 voice.setting = sco_pi(sk)->setting;
 865
 866                 len = min_t(unsigned int, sizeof(voice), optlen);
 867                 if (copy_from_sockptr(&voice, optval, len)) {
 868                         err = -EFAULT;
 869                         break;
 870                 }
 871
 872                 /* Explicitly check for these values */
 873 #ifdef TIZEN_BT
 874                 /* Codec defer accept */
 875                 if (voice.setting != (BT_VOICE_TRANSPARENT |
 876                     BT_VOICE_CVSD_16BIT) &&
 877                     voice.setting != BT_VOICE_CVSD_16BIT) {
 878 #else
 879                 if (voice.setting != BT_VOICE_TRANSPARENT &&
 880                     voice.setting != BT_VOICE_CVSD_16BIT) {
 881 #endif
 882                         err = -EINVAL;
 883                         break;
 884                 }
 885
 886                 sco_pi(sk)->setting = voice.setting;
 887                 break;
 888
 889         case BT_PKT_STATUS:
 890                 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
 891                         err = -EFAULT;
 892                         break;
 893                 }
 894
 895                 if (opt)
 896                         sco_pi(sk)->cmsg_mask |= SCO_CMSG_PKT_STATUS;
 897                 else
 898                         sco_pi(sk)->cmsg_mask &= SCO_CMSG_PKT_STATUS;
 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_old(struct socket *sock, int optname,
 911                                    char __user *optval, int __user *optlen)
 912 {
 913         struct sock *sk = sock->sk;
 914         struct sco_options opts;
 915         struct sco_conninfo cinfo;
 916         int len, err = 0;
 917
 918         BT_DBG("sk %p", sk);
 919
 920         if (get_user(len, optlen))
 921                 return -EFAULT;
 922
 923         lock_sock(sk);
 924
 925         switch (optname) {
 926         case SCO_OPTIONS:
 927                 if (sk->sk_state != BT_CONNECTED &&
 928                     !(sk->sk_state == BT_CONNECT2 &&
 929                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 930                         err = -ENOTCONN;
 931                         break;
 932                 }
 933
 934                 opts.mtu = sco_pi(sk)->conn->mtu;
 935
 936                 BT_DBG("mtu %u", opts.mtu);
 937
 938                 len = min_t(unsigned int, len, sizeof(opts));
 939                 if (copy_to_user(optval, (char *)&opts, len))
 940                         err = -EFAULT;
 941
 942                 break;
 943
 944         case SCO_CONNINFO:
 945                 if (sk->sk_state != BT_CONNECTED &&
 946                     !(sk->sk_state == BT_CONNECT2 &&
 947                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 948                         err = -ENOTCONN;
 949                         break;
 950                 }
 951
 952                 memset(&cinfo, 0, sizeof(cinfo));
 953                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 954                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 955
 956                 len = min_t(unsigned int, len, sizeof(cinfo));
 957                 if (copy_to_user(optval, (char *)&cinfo, len))
 958                         err = -EFAULT;
 959
 960                 break;
 961
 962         default:
 963                 err = -ENOPROTOOPT;
 964                 break;
 965         }
 966
 967         release_sock(sk);
 968         return err;
 969 }
 970
 971 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
 972                                char __user *optval, int __user *optlen)
 973 {
 974         struct sock *sk = sock->sk;
 975         int len, err = 0;
 976         struct bt_voice voice;
 977         u32 phys;
 978         int pkt_status;
 979
 980         BT_DBG("sk %p", sk);
 981
 982         if (level == SOL_SCO)
 983                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
 984
 985         if (get_user(len, optlen))
 986                 return -EFAULT;
 987
 988         lock_sock(sk);
 989
 990         switch (optname) {
 991
 992         case BT_DEFER_SETUP:
 993                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 994                         err = -EINVAL;
 995                         break;
 996                 }
 997
 998                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
 999                              (u32 __user *)optval))
1000                         err = -EFAULT;
1001
1002                 break;
1003
1004         case BT_VOICE:
1005                 voice.setting = sco_pi(sk)->setting;
1006
1007                 len = min_t(unsigned int, len, sizeof(voice));
1008                 if (copy_to_user(optval, (char *)&voice, len))
1009                         err = -EFAULT;
1010
1011                 break;
1012
1013         case BT_PHY:
1014                 if (sk->sk_state != BT_CONNECTED) {
1015                         err = -ENOTCONN;
1016                         break;
1017                 }
1018
1019                 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1020
1021                 if (put_user(phys, (u32 __user *) optval))
1022                         err = -EFAULT;
1023                 break;
1024
1025         case BT_PKT_STATUS:
1026                 pkt_status = (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS);
1027
1028                 if (put_user(pkt_status, (int __user *)optval))
1029                         err = -EFAULT;
1030                 break;
1031
1032         case BT_SNDMTU:
1033         case BT_RCVMTU:
1034                 if (sk->sk_state != BT_CONNECTED) {
1035                         err = -ENOTCONN;
1036                         break;
1037                 }
1038
1039                 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1040                         err = -EFAULT;
1041                 break;
1042
1043         default:
1044                 err = -ENOPROTOOPT;
1045                 break;
1046         }
1047
1048         release_sock(sk);
1049         return err;
1050 }
1051
1052 static int sco_sock_shutdown(struct socket *sock, int how)
1053 {
1054         struct sock *sk = sock->sk;
1055         int err = 0;
1056
1057         BT_DBG("sock %p, sk %p", sock, sk);
1058
1059         if (!sk)
1060                 return 0;
1061
1062         sock_hold(sk);
1063         lock_sock(sk);
1064
1065         if (!sk->sk_shutdown) {
1066                 sk->sk_shutdown = SHUTDOWN_MASK;
1067                 sco_sock_clear_timer(sk);
1068                 __sco_sock_close(sk);
1069
1070                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1071                     !(current->flags & PF_EXITING))
1072                         err = bt_sock_wait_state(sk, BT_CLOSED,
1073                                                  sk->sk_lingertime);
1074         }
1075
1076         release_sock(sk);
1077         sock_put(sk);
1078
1079         return err;
1080 }
1081
1082 static int sco_sock_release(struct socket *sock)
1083 {
1084         struct sock *sk = sock->sk;
1085         int err = 0;
1086
1087         BT_DBG("sock %p, sk %p", sock, sk);
1088
1089         if (!sk)
1090                 return 0;
1091
1092         sco_sock_close(sk);
1093
1094         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1095             !(current->flags & PF_EXITING)) {
1096                 lock_sock(sk);
1097                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1098                 release_sock(sk);
1099         }
1100
1101 #ifdef TIZEN_BT
1102         /* SCO kernel panic fix */
1103         bt_sock_unlink(&sco_sk_list, sk);
1104 #endif
1105         sock_orphan(sk);
1106         sco_sock_kill(sk);
1107         return err;
1108 }
1109
1110 static void sco_conn_ready(struct sco_conn *conn)
1111 {
1112         struct sock *parent;
1113         struct sock *sk = conn->sk;
1114
1115         BT_DBG("conn %p", conn);
1116
1117         if (sk) {
1118                 lock_sock(sk);
1119                 sco_sock_clear_timer(sk);
1120                 sk->sk_state = BT_CONNECTED;
1121                 sk->sk_state_change(sk);
1122                 release_sock(sk);
1123         } else {
1124                 sco_conn_lock(conn);
1125
1126                 if (!conn->hcon) {
1127                         sco_conn_unlock(conn);
1128                         return;
1129                 }
1130
1131 #ifdef TIZEN_BT
1132                 /* Multiple SCO accept feature */
1133                 parent = sco_get_sock_listen(&conn->hcon->dst);
1134 #else
1135                 parent = sco_get_sock_listen(&conn->hcon->src);
1136 #endif
1137                 if (!parent) {
1138                         sco_conn_unlock(conn);
1139                         return;
1140                 }
1141
1142                 lock_sock(parent);
1143
1144                 sk = sco_sock_alloc(sock_net(parent), NULL,
1145                                     BTPROTO_SCO, GFP_ATOMIC, 0);
1146                 if (!sk) {
1147                         release_sock(parent);
1148                         sco_conn_unlock(conn);
1149                         return;
1150                 }
1151
1152                 sco_sock_init(sk, parent);
1153
1154                 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1155                 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1156
1157                 hci_conn_hold(conn->hcon);
1158                 __sco_chan_add(conn, sk, parent);
1159
1160                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1161                         sk->sk_state = BT_CONNECT2;
1162                 else
1163                         sk->sk_state = BT_CONNECTED;
1164
1165                 /* Wake up parent */
1166                 parent->sk_data_ready(parent);
1167
1168                 release_sock(parent);
1169
1170                 sco_conn_unlock(conn);
1171         }
1172 }
1173
1174 #ifdef TIZEN_BT
1175 /* WBC/NBC feature */
1176 void sco_connect_set_gw_nbc(struct hci_dev *hdev)
1177 {
1178         struct hci_cp_write_voice_setting cp1;
1179         struct hci_cp_bcm_wbs_req cp2;
1180         struct hci_cp_i2c_pcm_req cp3;
1181         struct hci_cp_sco_pcm_req cp4;
1182
1183         BT_DBG("Setting the NBC params, hdev = %p", hdev);
1184
1185         cp1.voice_setting = cpu_to_le16(0x0060);
1186         hci_send_cmd(hdev, HCI_OP_WRITE_VOICE_SETTING, sizeof(cp1), &cp1);
1187         hdev->voice_setting = cpu_to_le16(0x0060);
1188
1189         cp2.role = 0x00;  /* WbDisable */
1190         cp2.pkt_type = cpu_to_le16(0x0002);
1191         hci_send_cmd(hdev, HCI_BCM_ENABLE_WBS_REQ, sizeof(cp2), &cp2);
1192
1193         cp3.i2c_enable = 0x01;
1194         cp3.is_master = 0x00;
1195         cp3.pcm_rate = 0x00;
1196         cp3.clock_rate = 0x01;
1197         hci_send_cmd(hdev, HCI_BCM_I2C_PCM_REQ, sizeof(cp3), &cp3);
1198
1199         cp4.sco_routing = 0x00;
1200         cp4.pcm_rate = 0x01;
1201         cp4.frame_type = 0x00;
1202         cp4.sync_mode = 0x00;
1203         cp4.clock_mode = 0x00;
1204         hci_send_cmd(hdev, HCI_BCM_SCO_PCM_REQ, sizeof(cp4), &cp4);
1205 }
1206
1207 void sco_connect_set_gw_wbc(struct hci_dev *hdev)
1208 {
1209         struct hci_cp_write_voice_setting cp1;
1210         struct hci_cp_bcm_wbs_req cp2;
1211         struct hci_cp_i2c_pcm_req cp3;
1212         struct hci_cp_sco_pcm_req cp4;
1213
1214         BT_DBG("Setting the WBC params, hdev = %p", hdev);
1215         cp1.voice_setting = cpu_to_le16(0x0003 | 0x0060);
1216         hci_send_cmd(hdev, HCI_OP_WRITE_VOICE_SETTING, sizeof(cp1), &cp1);
1217         hdev->voice_setting = cpu_to_le16(0x0003 | 0x0060);
1218
1219         cp2.role = 0x01; /* Enable */
1220         cp2.pkt_type = cpu_to_le16(0x0002);
1221         hci_send_cmd(hdev, HCI_BCM_ENABLE_WBS_REQ, sizeof(cp2), &cp2);
1222
1223         cp3.i2c_enable = 0x00;
1224         cp3.is_master = 0x00;
1225         cp3.pcm_rate = 0x01;
1226         cp3.clock_rate = 0x02;
1227         hci_send_cmd(hdev, HCI_BCM_I2C_PCM_REQ, sizeof(cp3), &cp3);
1228
1229         cp4.sco_routing = 0x00;
1230         cp4.pcm_rate = 0x00;
1231         cp4.frame_type = 0x00;
1232         cp4.sync_mode = 0x00;
1233         cp4.clock_mode = 0x00;
1234         hci_send_cmd(hdev, HCI_BCM_SCO_PCM_REQ, sizeof(cp4), &cp4);
1235 }
1236
1237 void sco_connect_set_nbc(struct hci_dev *hdev)
1238 {
1239         struct hci_cp_write_voice_setting cp1;
1240         struct hci_cp_bcm_wbs_req cp2;
1241         struct hci_cp_i2c_pcm_req cp3;
1242         struct hci_cp_sco_pcm_req cp4;
1243
1244         BT_DBG("Setting the NBC params, hdev = %p", hdev);
1245
1246         cp1.voice_setting = cpu_to_le16(0x0060);
1247         hci_send_cmd(hdev, HCI_OP_WRITE_VOICE_SETTING, sizeof(cp1), &cp1);
1248         hdev->voice_setting = cpu_to_le16(0x0060);
1249
1250         cp2.role = 0x00; /* WbDisable */
1251         cp2.pkt_type = cpu_to_le16(0x0002);
1252         hci_send_cmd(hdev, HCI_BCM_ENABLE_WBS_REQ, sizeof(cp2), &cp2);
1253
1254         cp3.i2c_enable = 0x00;
1255         cp3.is_master = 0x00;
1256         cp3.pcm_rate = 0x00;
1257         cp3.clock_rate = 0x04;
1258         hci_send_cmd(hdev, HCI_BCM_I2C_PCM_REQ, sizeof(cp3), &cp3);
1259
1260         cp4.sco_routing = 0x00;
1261         cp4.pcm_rate = 0x04;
1262         cp4.frame_type = 0x00;
1263         cp4.sync_mode = 0x00;
1264         cp4.clock_mode = 0x00;
1265         hci_send_cmd(hdev, HCI_BCM_SCO_PCM_REQ, sizeof(cp4), &cp4);
1266 }
1267
1268 void sco_connect_set_wbc(struct hci_dev *hdev)
1269 {
1270         struct hci_cp_write_voice_setting cp1;
1271         struct hci_cp_bcm_wbs_req cp2;
1272         struct hci_cp_i2c_pcm_req cp3;
1273         struct hci_cp_sco_pcm_req cp4;
1274
1275         BT_DBG("Setting the WBC params, hdev = %p", hdev);
1276         cp1.voice_setting = cpu_to_le16(0x0003 | 0x0060);
1277         hci_send_cmd(hdev, HCI_OP_WRITE_VOICE_SETTING, sizeof(cp1), &cp1);
1278         hdev->voice_setting = cpu_to_le16(0x0003 | 0x0060);
1279
1280         cp2.role = 0x01; /* Enable */
1281         cp2.pkt_type = cpu_to_le16(0x0002);
1282         hci_send_cmd(hdev, HCI_BCM_ENABLE_WBS_REQ, sizeof(cp2), &cp2);
1283
1284         cp3.i2c_enable = 0x00;
1285         cp3.is_master = 0x00;
1286         cp3.pcm_rate = 0x01;
1287         cp3.clock_rate = 0x04;
1288         hci_send_cmd(hdev, HCI_BCM_I2C_PCM_REQ, sizeof(cp3), &cp3);
1289
1290         cp4.sco_routing = 0x00;
1291         cp4.pcm_rate = 0x04;
1292         cp4.frame_type = 0x00;
1293         cp4.sync_mode = 0x00;
1294         cp4.clock_mode = 0x00;
1295         hci_send_cmd(hdev, HCI_BCM_SCO_PCM_REQ, sizeof(cp4), &cp4);
1296 }
1297 #endif
1298
1299 /* ----- SCO interface with lower layer (HCI) ----- */
1300 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1301 {
1302         struct sock *sk;
1303         int lm = 0;
1304
1305         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1306
1307         /* Find listening sockets */
1308         read_lock(&sco_sk_list.lock);
1309         sk_for_each(sk, &sco_sk_list.head) {
1310                 if (sk->sk_state != BT_LISTEN)
1311                         continue;
1312
1313 #ifdef TIZEN_BT
1314                 /* Multiple SCO accept feature */
1315                 if (!bacmp(&sco_pi(sk)->src, bdaddr) ||
1316                     !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1317 #else
1318                 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1319                     !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1320 #endif
1321                         lm |= HCI_LM_ACCEPT;
1322
1323                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1324                                 *flags |= HCI_PROTO_DEFER;
1325                         break;
1326                 }
1327         }
1328         read_unlock(&sco_sk_list.lock);
1329
1330 #ifdef TIZEN_BT
1331         /* WBC/NBC feature */
1332         if ((lm & HCI_LM_ACCEPT) && !hci_conn_hash_lookup_sco(hdev)) {
1333                 struct hci_conn *hcon_acl;
1334
1335                 hcon_acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, bdaddr);
1336                 if (!hcon_acl) {
1337                         BT_ERR("ACL doesn't alive. Use 0x%X",
1338                                hdev->voice_setting);
1339
1340                         if (hdev->voice_setting == 0x0063)
1341                                 sco_connect_set_wbc(hdev);
1342                         else
1343                                 sco_connect_set_nbc(hdev);
1344                 } else if (hcon_acl->sco_role == MGMT_SCO_ROLE_HANDSFREE) {
1345                         BT_DBG("Handsfree SCO 0x%X", hcon_acl->voice_setting);
1346                         if (hcon_acl->voice_setting == 0x0063)
1347                                 sco_connect_set_wbc(hdev);
1348                         else
1349                                 sco_connect_set_nbc(hdev);
1350                 } else {
1351                         BT_DBG("Gateway SCO 0x%X", hcon_acl->voice_setting);
1352                         if (hcon_acl->voice_setting == 0x0063)
1353                                 sco_connect_set_gw_wbc(hdev);
1354                         else
1355                                 sco_connect_set_gw_nbc(hdev);
1356                 }
1357         }
1358 #endif
1359
1360         return lm;
1361 }
1362
1363 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1364 {
1365         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1366                 return;
1367
1368         BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);
1369
1370         if (!status) {
1371                 struct sco_conn *conn;
1372
1373                 conn = sco_conn_add(hcon);
1374                 if (conn)
1375                         sco_conn_ready(conn);
1376         } else
1377                 sco_conn_del(hcon, bt_to_errno(status));
1378 }
1379
1380 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1381 {
1382         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1383                 return;
1384
1385         BT_DBG("hcon %p reason %d", hcon, reason);
1386
1387         sco_conn_del(hcon, bt_to_errno(reason));
1388 }
1389
1390 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1391 {
1392         struct sco_conn *conn = hcon->sco_data;
1393
1394         if (!conn)
1395                 goto drop;
1396
1397         BT_DBG("conn %p len %u", conn, skb->len);
1398
1399         if (skb->len) {
1400                 sco_recv_frame(conn, skb);
1401                 return;
1402         }
1403
1404 drop:
1405         kfree_skb(skb);
1406 }
1407
1408 static struct hci_cb sco_cb = {
1409         .name           = "SCO",
1410         .connect_cfm    = sco_connect_cfm,
1411         .disconn_cfm    = sco_disconn_cfm,
1412 };
1413
1414 static int sco_debugfs_show(struct seq_file *f, void *p)
1415 {
1416         struct sock *sk;
1417
1418         read_lock(&sco_sk_list.lock);
1419
1420         sk_for_each(sk, &sco_sk_list.head) {
1421                 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1422                            &sco_pi(sk)->dst, sk->sk_state);
1423         }
1424
1425         read_unlock(&sco_sk_list.lock);
1426
1427         return 0;
1428 }
1429
1430 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1431
1432 static struct dentry *sco_debugfs;
1433
1434 static const struct proto_ops sco_sock_ops = {
1435         .family         = PF_BLUETOOTH,
1436         .owner          = THIS_MODULE,
1437         .release        = sco_sock_release,
1438         .bind           = sco_sock_bind,
1439         .connect        = sco_sock_connect,
1440         .listen         = sco_sock_listen,
1441         .accept         = sco_sock_accept,
1442         .getname        = sco_sock_getname,
1443         .sendmsg        = sco_sock_sendmsg,
1444         .recvmsg        = sco_sock_recvmsg,
1445         .poll           = bt_sock_poll,
1446         .ioctl          = bt_sock_ioctl,
1447         .gettstamp      = sock_gettstamp,
1448         .mmap           = sock_no_mmap,
1449         .socketpair     = sock_no_socketpair,
1450         .shutdown       = sco_sock_shutdown,
1451         .setsockopt     = sco_sock_setsockopt,
1452         .getsockopt     = sco_sock_getsockopt
1453 };
1454
1455 static const struct net_proto_family sco_sock_family_ops = {
1456         .family = PF_BLUETOOTH,
1457         .owner  = THIS_MODULE,
1458         .create = sco_sock_create,
1459 };
1460
1461 int __init sco_init(void)
1462 {
1463         int err;
1464
1465         BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1466
1467         err = proto_register(&sco_proto, 0);
1468         if (err < 0)
1469                 return err;
1470
1471         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1472         if (err < 0) {
1473                 BT_ERR("SCO socket registration failed");
1474                 goto error;
1475         }
1476
1477         err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1478         if (err < 0) {
1479                 BT_ERR("Failed to create SCO proc file");
1480                 bt_sock_unregister(BTPROTO_SCO);
1481                 goto error;
1482         }
1483
1484         BT_INFO("SCO socket layer initialized");
1485
1486         hci_register_cb(&sco_cb);
1487
1488         if (IS_ERR_OR_NULL(bt_debugfs))
1489                 return 0;
1490
1491         sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1492                                           NULL, &sco_debugfs_fops);
1493
1494         return 0;
1495
1496 error:
1497         proto_unregister(&sco_proto);
1498         return err;
1499 }
1500
1501 void sco_exit(void)
1502 {
1503         bt_procfs_cleanup(&init_net, "sco");
1504
1505         debugfs_remove(sco_debugfs);
1506
1507         hci_unregister_cb(&sco_cb);
1508
1509         bt_sock_unregister(BTPROTO_SCO);
1510
1511         proto_unregister(&sco_proto);
1512 }
1513
1514 module_param(disable_esco, bool, 0644);
1515 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");