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