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
  29 #include <linux/types.h>
  30 #include <linux/errno.h>
  31 #include <linux/kernel.h>
  32 #include <linux/sched.h>
  33 #include <linux/slab.h>
  34 #include <linux/poll.h>
  35 #include <linux/fcntl.h>
  36 #include <linux/init.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/socket.h>
  39 #include <linux/skbuff.h>
  40 #include <linux/device.h>
  41 #include <linux/list.h>
  42 #include <net/sock.h>
  43
  44 #include <asm/system.h>
  45 #include <asm/uaccess.h>
  46
  47 #include <net/bluetooth/bluetooth.h>
  48 #include <net/bluetooth/hci_core.h>
  49 #include <net/bluetooth/sco.h>
  50
  51 #ifndef CONFIG_BT_SCO_DEBUG
  52 #undef  BT_DBG
  53 #define BT_DBG(D...)
  54 #endif
  55
  56 #define VERSION "0.6"
  57
  58 static int disable_esco = 0;
  59
  60 static const struct proto_ops sco_sock_ops;
  61
  62 static struct bt_sock_list sco_sk_list = {
  63         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
  64 };
  65
  66 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
  67 static void sco_chan_del(struct sock *sk, int err);
  68
  69 static int  sco_conn_del(struct hci_conn *conn, int err);
  70
  71 static void sco_sock_close(struct sock *sk);
  72 static void sco_sock_kill(struct sock *sk);
  73
  74 /* ---- SCO timers ---- */
  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, __u8 status)
 104 {
 105         struct hci_dev *hdev = hcon->hdev;
 106         struct sco_conn *conn = hcon->sco_data;
 107
 108         if (conn || status)
 109                 return conn;
 110
 111         conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
 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         conn->src = &hdev->bdaddr;
 121         conn->dst = &hcon->dst;
 122
 123         if (hdev->sco_mtu > 0)
 124                 conn->mtu = hdev->sco_mtu;
 125         else
 126                 conn->mtu = 60;
 127
 128         BT_DBG("hcon %p conn %p", hcon, conn);
 129
 130         return conn;
 131 }
 132
 133 static inline struct sock *sco_chan_get(struct sco_conn *conn)
 134 {
 135         struct sock *sk = NULL;
 136         sco_conn_lock(conn);
 137         sk = conn->sk;
 138         sco_conn_unlock(conn);
 139         return sk;
 140 }
 141
 142 static int sco_conn_del(struct hci_conn *hcon, int err)
 143 {
 144         struct sco_conn *conn;
 145         struct sock *sk;
 146
 147         if (!(conn = hcon->sco_data))
 148                 return 0;
 149
 150         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 151
 152         /* Kill socket */
 153         if ((sk = sco_chan_get(conn))) {
 154                 bh_lock_sock(sk);
 155                 sco_sock_clear_timer(sk);
 156                 sco_chan_del(sk, err);
 157                 bh_unlock_sock(sk);
 158                 sco_sock_kill(sk);
 159         }
 160
 161         hcon->sco_data = NULL;
 162         kfree(conn);
 163         return 0;
 164 }
 165
 166 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 167 {
 168         int err = 0;
 169
 170         sco_conn_lock(conn);
 171         if (conn->sk) {
 172                 err = -EBUSY;
 173         } else {
 174                 __sco_chan_add(conn, sk, parent);
 175         }
 176         sco_conn_unlock(conn);
 177         return err;
 178 }
 179
 180 static int sco_connect(struct sock *sk)
 181 {
 182         bdaddr_t *src = &bt_sk(sk)->src;
 183         bdaddr_t *dst = &bt_sk(sk)->dst;
 184         struct sco_conn *conn;
 185         struct hci_conn *hcon;
 186         struct hci_dev  *hdev;
 187         int err, type;
 188
 189         BT_DBG("%s -> %s", batostr(src), batostr(dst));
 190
 191         if (!(hdev = hci_get_route(dst, src)))
 192                 return -EHOSTUNREACH;
 193
 194         hci_dev_lock_bh(hdev);
 195
 196         err = -ENOMEM;
 197
 198         if (lmp_esco_capable(hdev) && !disable_esco)
 199                 type = ESCO_LINK;
 200         else
 201                 type = SCO_LINK;
 202
 203         hcon = hci_connect(hdev, type, dst, HCI_AT_NO_BONDING);
 204         if (!hcon)
 205                 goto done;
 206
 207         conn = sco_conn_add(hcon, 0);
 208         if (!conn) {
 209                 hci_conn_put(hcon);
 210                 goto done;
 211         }
 212
 213         /* Update source addr of the socket */
 214         bacpy(src, conn->src);
 215
 216         err = sco_chan_add(conn, sk, NULL);
 217         if (err)
 218                 goto done;
 219
 220         if (hcon->state == BT_CONNECTED) {
 221                 sco_sock_clear_timer(sk);
 222                 sk->sk_state = BT_CONNECTED;
 223         } else {
 224                 sk->sk_state = BT_CONNECT;
 225                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
 226         }
 227
 228 done:
 229         hci_dev_unlock_bh(hdev);
 230         hci_dev_put(hdev);
 231         return err;
 232 }
 233
 234 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
 235 {
 236         struct sco_conn *conn = sco_pi(sk)->conn;
 237         struct sk_buff *skb;
 238         int err, count;
 239
 240         /* Check outgoing MTU */
 241         if (len > conn->mtu)
 242                 return -EINVAL;
 243
 244         BT_DBG("sk %p len %d", sk, len);
 245
 246         count = min_t(unsigned int, conn->mtu, len);
 247         if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
 248                 return err;
 249
 250         if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
 251                 err = -EFAULT;
 252                 goto fail;
 253         }
 254
 255         if ((err = hci_send_sco(conn->hcon, skb)) < 0)
 256                 return err;
 257
 258         return count;
 259
 260 fail:
 261         kfree_skb(skb);
 262         return err;
 263 }
 264
 265 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
 266 {
 267         struct sock *sk = sco_chan_get(conn);
 268
 269         if (!sk)
 270                 goto drop;
 271
 272         BT_DBG("sk %p len %d", sk, skb->len);
 273
 274         if (sk->sk_state != BT_CONNECTED)
 275                 goto drop;
 276
 277         if (!sock_queue_rcv_skb(sk, skb))
 278                 return;
 279
 280 drop:
 281         kfree_skb(skb);
 282         return;
 283 }
 284
 285 /* -------- Socket interface ---------- */
 286 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
 287 {
 288         struct sock *sk;
 289         struct hlist_node *node;
 290
 291         sk_for_each(sk, node, &sco_sk_list.head)
 292                 if (!bacmp(&bt_sk(sk)->src, ba))
 293                         goto found;
 294         sk = NULL;
 295 found:
 296         return sk;
 297 }
 298
 299 /* Find socket listening on source bdaddr.
 300  * Returns closest match.
 301  */
 302 static struct sock *sco_get_sock_listen(bdaddr_t *src)
 303 {
 304         struct sock *sk = NULL, *sk1 = NULL;
 305         struct hlist_node *node;
 306
 307         read_lock(&sco_sk_list.lock);
 308
 309         sk_for_each(sk, node, &sco_sk_list.head) {
 310                 if (sk->sk_state != BT_LISTEN)
 311                         continue;
 312
 313                 /* Exact match. */
 314                 if (!bacmp(&bt_sk(sk)->src, src))
 315                         break;
 316
 317                 /* Closest match */
 318                 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
 319                         sk1 = sk;
 320         }
 321
 322         read_unlock(&sco_sk_list.lock);
 323
 324         return node ? sk : sk1;
 325 }
 326
 327 static void sco_sock_destruct(struct sock *sk)
 328 {
 329         BT_DBG("sk %p", sk);
 330
 331         skb_queue_purge(&sk->sk_receive_queue);
 332         skb_queue_purge(&sk->sk_write_queue);
 333 }
 334
 335 static void sco_sock_cleanup_listen(struct sock *parent)
 336 {
 337         struct sock *sk;
 338
 339         BT_DBG("parent %p", parent);
 340
 341         /* Close not yet accepted channels */
 342         while ((sk = bt_accept_dequeue(parent, NULL))) {
 343                 sco_sock_close(sk);
 344                 sco_sock_kill(sk);
 345         }
 346
 347         parent->sk_state  = BT_CLOSED;
 348         sock_set_flag(parent, SOCK_ZAPPED);
 349 }
 350
 351 /* Kill socket (only if zapped and orphan)
 352  * Must be called on unlocked socket.
 353  */
 354 static void sco_sock_kill(struct sock *sk)
 355 {
 356         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 357                 return;
 358
 359         BT_DBG("sk %p state %d", sk, sk->sk_state);
 360
 361         /* Kill poor orphan */
 362         bt_sock_unlink(&sco_sk_list, sk);
 363         sock_set_flag(sk, SOCK_DEAD);
 364         sock_put(sk);
 365 }
 366
 367 /* Close socket.
 368  * Must be called on unlocked socket.
 369  */
 370 static void sco_sock_close(struct sock *sk)
 371 {
 372         struct sco_conn *conn;
 373
 374         sco_sock_clear_timer(sk);
 375
 376         lock_sock(sk);
 377
 378         conn = sco_pi(sk)->conn;
 379
 380         BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
 381
 382         switch (sk->sk_state) {
 383         case BT_LISTEN:
 384                 sco_sock_cleanup_listen(sk);
 385                 break;
 386
 387         case BT_CONNECTED:
 388         case BT_CONFIG:
 389         case BT_CONNECT:
 390         case BT_DISCONN:
 391                 sco_chan_del(sk, ECONNRESET);
 392                 break;
 393
 394         default:
 395                 sock_set_flag(sk, SOCK_ZAPPED);
 396                 break;
 397         }
 398
 399         release_sock(sk);
 400
 401         sco_sock_kill(sk);
 402 }
 403
 404 static void sco_sock_init(struct sock *sk, struct sock *parent)
 405 {
 406         BT_DBG("sk %p", sk);
 407
 408         if (parent)
 409                 sk->sk_type = parent->sk_type;
 410 }
 411
 412 static struct proto sco_proto = {
 413         .name           = "SCO",
 414         .owner          = THIS_MODULE,
 415         .obj_size       = sizeof(struct sco_pinfo)
 416 };
 417
 418 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
 419 {
 420         struct sock *sk;
 421
 422         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
 423         if (!sk)
 424                 return NULL;
 425
 426         sock_init_data(sock, sk);
 427         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 428
 429         sk->sk_destruct = sco_sock_destruct;
 430         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
 431
 432         sock_reset_flag(sk, SOCK_ZAPPED);
 433
 434         sk->sk_protocol = proto;
 435         sk->sk_state    = BT_OPEN;
 436
 437         setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
 438
 439         bt_sock_link(&sco_sk_list, sk);
 440         return sk;
 441 }
 442
 443 static int sco_sock_create(struct net *net, struct socket *sock, int protocol)
 444 {
 445         struct sock *sk;
 446
 447         BT_DBG("sock %p", sock);
 448
 449         sock->state = SS_UNCONNECTED;
 450
 451         if (sock->type != SOCK_SEQPACKET)
 452                 return -ESOCKTNOSUPPORT;
 453
 454         sock->ops = &sco_sock_ops;
 455
 456         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
 457         if (!sk)
 458                 return -ENOMEM;
 459
 460         sco_sock_init(sk, NULL);
 461         return 0;
 462 }
 463
 464 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 465 {
 466         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 467         struct sock *sk = sock->sk;
 468         bdaddr_t *src = &sa->sco_bdaddr;
 469         int err = 0;
 470
 471         BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
 472
 473         if (!addr || addr->sa_family != AF_BLUETOOTH)
 474                 return -EINVAL;
 475
 476         lock_sock(sk);
 477
 478         if (sk->sk_state != BT_OPEN) {
 479                 err = -EBADFD;
 480                 goto done;
 481         }
 482
 483         write_lock_bh(&sco_sk_list.lock);
 484
 485         if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
 486                 err = -EADDRINUSE;
 487         } else {
 488                 /* Save source address */
 489                 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
 490                 sk->sk_state = BT_BOUND;
 491         }
 492
 493         write_unlock_bh(&sco_sk_list.lock);
 494
 495 done:
 496         release_sock(sk);
 497         return err;
 498 }
 499
 500 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 501 {
 502         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 503         struct sock *sk = sock->sk;
 504         int err = 0;
 505
 506
 507         BT_DBG("sk %p", sk);
 508
 509         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
 510                 return -EINVAL;
 511
 512         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
 513                 return -EBADFD;
 514
 515         if (sk->sk_type != SOCK_SEQPACKET)
 516                 return -EINVAL;
 517
 518         lock_sock(sk);
 519
 520         /* Set destination address and psm */
 521         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
 522
 523         if ((err = sco_connect(sk)))
 524                 goto done;
 525
 526         err = bt_sock_wait_state(sk, BT_CONNECTED,
 527                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 528
 529 done:
 530         release_sock(sk);
 531         return err;
 532 }
 533
 534 static int sco_sock_listen(struct socket *sock, int backlog)
 535 {
 536         struct sock *sk = sock->sk;
 537         int err = 0;
 538
 539         BT_DBG("sk %p backlog %d", sk, backlog);
 540
 541         lock_sock(sk);
 542
 543         if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
 544                 err = -EBADFD;
 545                 goto done;
 546         }
 547
 548         sk->sk_max_ack_backlog = backlog;
 549         sk->sk_ack_backlog = 0;
 550         sk->sk_state = BT_LISTEN;
 551
 552 done:
 553         release_sock(sk);
 554         return err;
 555 }
 556
 557 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 558 {
 559         DECLARE_WAITQUEUE(wait, current);
 560         struct sock *sk = sock->sk, *ch;
 561         long timeo;
 562         int err = 0;
 563
 564         lock_sock(sk);
 565
 566         if (sk->sk_state != BT_LISTEN) {
 567                 err = -EBADFD;
 568                 goto done;
 569         }
 570
 571         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 572
 573         BT_DBG("sk %p timeo %ld", sk, timeo);
 574
 575         /* Wait for an incoming connection. (wake-one). */
 576         add_wait_queue_exclusive(sk->sk_sleep, &wait);
 577         while (!(ch = bt_accept_dequeue(sk, newsock))) {
 578                 set_current_state(TASK_INTERRUPTIBLE);
 579                 if (!timeo) {
 580                         err = -EAGAIN;
 581                         break;
 582                 }
 583
 584                 release_sock(sk);
 585                 timeo = schedule_timeout(timeo);
 586                 lock_sock(sk);
 587
 588                 if (sk->sk_state != BT_LISTEN) {
 589                         err = -EBADFD;
 590                         break;
 591                 }
 592
 593                 if (signal_pending(current)) {
 594                         err = sock_intr_errno(timeo);
 595                         break;
 596                 }
 597         }
 598         set_current_state(TASK_RUNNING);
 599         remove_wait_queue(sk->sk_sleep, &wait);
 600
 601         if (err)
 602                 goto done;
 603
 604         newsock->state = SS_CONNECTED;
 605
 606         BT_DBG("new socket %p", ch);
 607
 608 done:
 609         release_sock(sk);
 610         return err;
 611 }
 612
 613 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 614 {
 615         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
 616         struct sock *sk = sock->sk;
 617
 618         BT_DBG("sock %p, sk %p", sock, sk);
 619
 620         addr->sa_family = AF_BLUETOOTH;
 621         *len = sizeof(struct sockaddr_sco);
 622
 623         if (peer)
 624                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
 625         else
 626                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
 627
 628         return 0;
 629 }
 630
 631 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 632                             struct msghdr *msg, size_t len)
 633 {
 634         struct sock *sk = sock->sk;
 635         int err = 0;
 636
 637         BT_DBG("sock %p, sk %p", sock, sk);
 638
 639         err = sock_error(sk);
 640         if (err)
 641                 return err;
 642
 643         if (msg->msg_flags & MSG_OOB)
 644                 return -EOPNOTSUPP;
 645
 646         lock_sock(sk);
 647
 648         if (sk->sk_state == BT_CONNECTED)
 649                 err = sco_send_frame(sk, msg, len);
 650         else
 651                 err = -ENOTCONN;
 652
 653         release_sock(sk);
 654         return err;
 655 }
 656
 657 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
 658 {
 659         struct sock *sk = sock->sk;
 660         int err = 0;
 661
 662         BT_DBG("sk %p", sk);
 663
 664         lock_sock(sk);
 665
 666         switch (optname) {
 667         default:
 668                 err = -ENOPROTOOPT;
 669                 break;
 670         }
 671
 672         release_sock(sk);
 673         return err;
 674 }
 675
 676 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 677 {
 678         struct sock *sk = sock->sk;
 679         struct sco_options opts;
 680         struct sco_conninfo cinfo;
 681         int len, err = 0;
 682
 683         BT_DBG("sk %p", sk);
 684
 685         if (get_user(len, optlen))
 686                 return -EFAULT;
 687
 688         lock_sock(sk);
 689
 690         switch (optname) {
 691         case SCO_OPTIONS:
 692                 if (sk->sk_state != BT_CONNECTED) {
 693                         err = -ENOTCONN;
 694                         break;
 695                 }
 696
 697                 opts.mtu = sco_pi(sk)->conn->mtu;
 698
 699                 BT_DBG("mtu %d", opts.mtu);
 700
 701                 len = min_t(unsigned int, len, sizeof(opts));
 702                 if (copy_to_user(optval, (char *)&opts, len))
 703                         err = -EFAULT;
 704
 705                 break;
 706
 707         case SCO_CONNINFO:
 708                 if (sk->sk_state != BT_CONNECTED) {
 709                         err = -ENOTCONN;
 710                         break;
 711                 }
 712
 713                 memset(&cinfo, 0, sizeof(cinfo));
 714                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
 715                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
 716
 717                 len = min_t(unsigned int, len, sizeof(cinfo));
 718                 if (copy_to_user(optval, (char *)&cinfo, len))
 719                         err = -EFAULT;
 720
 721                 break;
 722
 723         default:
 724                 err = -ENOPROTOOPT;
 725                 break;
 726         }
 727
 728         release_sock(sk);
 729         return err;
 730 }
 731
 732 static int sco_sock_release(struct socket *sock)
 733 {
 734         struct sock *sk = sock->sk;
 735         int err = 0;
 736
 737         BT_DBG("sock %p, sk %p", sock, sk);
 738
 739         if (!sk)
 740                 return 0;
 741
 742         sco_sock_close(sk);
 743
 744         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
 745                 lock_sock(sk);
 746                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
 747                 release_sock(sk);
 748         }
 749
 750         sock_orphan(sk);
 751         sco_sock_kill(sk);
 752         return err;
 753 }
 754
 755 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
 756 {
 757         BT_DBG("conn %p", conn);
 758
 759         sco_pi(sk)->conn = conn;
 760         conn->sk = sk;
 761
 762         if (parent)
 763                 bt_accept_enqueue(parent, sk);
 764 }
 765
 766 /* Delete channel.
 767  * Must be called on the locked socket. */
 768 static void sco_chan_del(struct sock *sk, int err)
 769 {
 770         struct sco_conn *conn;
 771
 772         conn = sco_pi(sk)->conn;
 773
 774         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 775
 776         if (conn) {
 777                 sco_conn_lock(conn);
 778                 conn->sk = NULL;
 779                 sco_pi(sk)->conn = NULL;
 780                 sco_conn_unlock(conn);
 781                 hci_conn_put(conn->hcon);
 782         }
 783
 784         sk->sk_state = BT_CLOSED;
 785         sk->sk_err   = err;
 786         sk->sk_state_change(sk);
 787
 788         sock_set_flag(sk, SOCK_ZAPPED);
 789 }
 790
 791 static void sco_conn_ready(struct sco_conn *conn)
 792 {
 793         struct sock *parent, *sk;
 794
 795         BT_DBG("conn %p", conn);
 796
 797         sco_conn_lock(conn);
 798
 799         if ((sk = conn->sk)) {
 800                 sco_sock_clear_timer(sk);
 801                 bh_lock_sock(sk);
 802                 sk->sk_state = BT_CONNECTED;
 803                 sk->sk_state_change(sk);
 804                 bh_unlock_sock(sk);
 805         } else {
 806                 parent = sco_get_sock_listen(conn->src);
 807                 if (!parent)
 808                         goto done;
 809
 810                 bh_lock_sock(parent);
 811
 812                 sk = sco_sock_alloc(sock_net(parent), NULL, BTPROTO_SCO, GFP_ATOMIC);
 813                 if (!sk) {
 814                         bh_unlock_sock(parent);
 815                         goto done;
 816                 }
 817
 818                 sco_sock_init(sk, parent);
 819
 820                 bacpy(&bt_sk(sk)->src, conn->src);
 821                 bacpy(&bt_sk(sk)->dst, conn->dst);
 822
 823                 hci_conn_hold(conn->hcon);
 824                 __sco_chan_add(conn, sk, parent);
 825
 826                 sk->sk_state = BT_CONNECTED;
 827
 828                 /* Wake up parent */
 829                 parent->sk_data_ready(parent, 1);
 830
 831                 bh_unlock_sock(parent);
 832         }
 833
 834 done:
 835         sco_conn_unlock(conn);
 836 }
 837
 838 /* ----- SCO interface with lower layer (HCI) ----- */
 839 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 840 {
 841         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
 842
 843         /* Always accept connection */
 844         return HCI_LM_ACCEPT;
 845 }
 846
 847 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
 848 {
 849         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
 850
 851         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 852                 return 0;
 853
 854         if (!status) {
 855                 struct sco_conn *conn;
 856
 857                 conn = sco_conn_add(hcon, status);
 858                 if (conn)
 859                         sco_conn_ready(conn);
 860         } else
 861                 sco_conn_del(hcon, bt_err(status));
 862
 863         return 0;
 864 }
 865
 866 static int sco_disconn_ind(struct hci_conn *hcon, __u8 reason)
 867 {
 868         BT_DBG("hcon %p reason %d", hcon, reason);
 869
 870         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
 871                 return 0;
 872
 873         sco_conn_del(hcon, bt_err(reason));
 874
 875         return 0;
 876 }
 877
 878 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 879 {
 880         struct sco_conn *conn = hcon->sco_data;
 881
 882         if (!conn)
 883                 goto drop;
 884
 885         BT_DBG("conn %p len %d", conn, skb->len);
 886
 887         if (skb->len) {
 888                 sco_recv_frame(conn, skb);
 889                 return 0;
 890         }
 891
 892 drop:
 893         kfree_skb(skb);
 894         return 0;
 895 }
 896
 897 static ssize_t sco_sysfs_show(struct class *dev, char *buf)
 898 {
 899         struct sock *sk;
 900         struct hlist_node *node;
 901         char *str = buf;
 902
 903         read_lock_bh(&sco_sk_list.lock);
 904
 905         sk_for_each(sk, node, &sco_sk_list.head) {
 906                 str += sprintf(str, "%s %s %d\n",
 907                                 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
 908                                 sk->sk_state);
 909         }
 910
 911         read_unlock_bh(&sco_sk_list.lock);
 912
 913         return (str - buf);
 914 }
 915
 916 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
 917
 918 static const struct proto_ops sco_sock_ops = {
 919         .family         = PF_BLUETOOTH,
 920         .owner          = THIS_MODULE,
 921         .release        = sco_sock_release,
 922         .bind           = sco_sock_bind,
 923         .connect        = sco_sock_connect,
 924         .listen         = sco_sock_listen,
 925         .accept         = sco_sock_accept,
 926         .getname        = sco_sock_getname,
 927         .sendmsg        = sco_sock_sendmsg,
 928         .recvmsg        = bt_sock_recvmsg,
 929         .poll           = bt_sock_poll,
 930         .ioctl          = bt_sock_ioctl,
 931         .mmap           = sock_no_mmap,
 932         .socketpair     = sock_no_socketpair,
 933         .shutdown       = sock_no_shutdown,
 934         .setsockopt     = sco_sock_setsockopt,
 935         .getsockopt     = sco_sock_getsockopt
 936 };
 937
 938 static struct net_proto_family sco_sock_family_ops = {
 939         .family = PF_BLUETOOTH,
 940         .owner  = THIS_MODULE,
 941         .create = sco_sock_create,
 942 };
 943
 944 static struct hci_proto sco_hci_proto = {
 945         .name           = "SCO",
 946         .id             = HCI_PROTO_SCO,
 947         .connect_ind    = sco_connect_ind,
 948         .connect_cfm    = sco_connect_cfm,
 949         .disconn_ind    = sco_disconn_ind,
 950         .recv_scodata   = sco_recv_scodata
 951 };
 952
 953 static int __init sco_init(void)
 954 {
 955         int err;
 956
 957         err = proto_register(&sco_proto, 0);
 958         if (err < 0)
 959                 return err;
 960
 961         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
 962         if (err < 0) {
 963                 BT_ERR("SCO socket registration failed");
 964                 goto error;
 965         }
 966
 967         err = hci_register_proto(&sco_hci_proto);
 968         if (err < 0) {
 969                 BT_ERR("SCO protocol registration failed");
 970                 bt_sock_unregister(BTPROTO_SCO);
 971                 goto error;
 972         }
 973
 974         if (class_create_file(bt_class, &class_attr_sco) < 0)
 975                 BT_ERR("Failed to create SCO info file");
 976
 977         BT_INFO("SCO (Voice Link) ver %s", VERSION);
 978         BT_INFO("SCO socket layer initialized");
 979
 980         return 0;
 981
 982 error:
 983         proto_unregister(&sco_proto);
 984         return err;
 985 }
 986
 987 static void __exit sco_exit(void)
 988 {
 989         class_remove_file(bt_class, &class_attr_sco);
 990
 991         if (bt_sock_unregister(BTPROTO_SCO) < 0)
 992                 BT_ERR("SCO socket unregistration failed");
 993
 994         if (hci_unregister_proto(&sco_hci_proto) < 0)
 995                 BT_ERR("SCO protocol unregistration failed");
 996
 997         proto_unregister(&sco_proto);
 998 }
 999
1000 module_init(sco_init);
1001 module_exit(sco_exit);
1002
1003 module_param(disable_esco, bool, 0644);
1004 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1005
1006 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1007 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1008 MODULE_VERSION(VERSION);
1009 MODULE_LICENSE("GPL");
1010 MODULE_ALIAS("bt-proto-2");