net/bluetooth/sco.c

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