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