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