f54d743581977dd0006d218057b1a15993257a63
[android-sdk/kernel-video.git] / net / bluetooth / sco.c
1 /*
2    BlueZ - Bluetooth protocol stack for Linux
3    Copyright (C) 2000-2001 Qualcomm Incorporated
5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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 */
25 /* Bluetooth SCO sockets. */
27 #include <linux/module.h>
28 #include <linux/debugfs.h>
29 #include <linux/seq_file.h>
31 #include <net/bluetooth/bluetooth.h>
32 #include <net/bluetooth/hci_core.h>
33 #include <net/bluetooth/sco.h>
35 static bool disable_esco;
37 static const struct proto_ops sco_sock_ops;
39 static struct bt_sock_list sco_sk_list = {
40         .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
41 };
43 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
44 static void sco_chan_del(struct sock *sk, int err);
46 static void sco_sock_close(struct sock *sk);
47 static void sco_sock_kill(struct sock *sk);
49 /* ---- SCO timers ---- */
50 static void sco_sock_timeout(unsigned long arg)
51 {
52         struct sock *sk = (struct sock *) arg;
54         BT_DBG("sock %p state %d", sk, sk->sk_state);
56         bh_lock_sock(sk);
57         sk->sk_err = ETIMEDOUT;
58         sk->sk_state_change(sk);
59         bh_unlock_sock(sk);
61         sco_sock_kill(sk);
62         sock_put(sk);
63 }
65 static void sco_sock_set_timer(struct sock *sk, long timeout)
66 {
67         BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
68         sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
69 }
71 static void sco_sock_clear_timer(struct sock *sk)
72 {
73         BT_DBG("sock %p state %d", sk, sk->sk_state);
74         sk_stop_timer(sk, &sk->sk_timer);
75 }
77 /* ---- SCO connections ---- */
78 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
79 {
80         struct hci_dev *hdev = hcon->hdev;
81         struct sco_conn *conn = hcon->sco_data;
83         if (conn)
84                 return conn;
86         conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
87         if (!conn)
88                 return NULL;
90         spin_lock_init(&conn->lock);
92         hcon->sco_data = conn;
93         conn->hcon = hcon;
95         conn->src = &hdev->bdaddr;
96         conn->dst = &hcon->dst;
98         if (hdev->sco_mtu > 0)
99                 conn->mtu = hdev->sco_mtu;
100         else
101                 conn->mtu = 60;
103         BT_DBG("hcon %p conn %p", hcon, conn);
105         return conn;
108 static struct sock *sco_chan_get(struct sco_conn *conn)
110         struct sock *sk = NULL;
111         sco_conn_lock(conn);
112         sk = conn->sk;
113         sco_conn_unlock(conn);
114         return sk;
117 static int sco_conn_del(struct hci_conn *hcon, int err)
119         struct sco_conn *conn = hcon->sco_data;
120         struct sock *sk;
122         if (!conn)
123                 return 0;
125         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
127         /* Kill socket */
128         sk = sco_chan_get(conn);
129         if (sk) {
130                 bh_lock_sock(sk);
131                 sco_sock_clear_timer(sk);
132                 sco_chan_del(sk, err);
133                 bh_unlock_sock(sk);
134                 sco_sock_kill(sk);
135         }
137         hcon->sco_data = NULL;
138         kfree(conn);
139         return 0;
142 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
143                         struct sock *parent)
145         int err = 0;
147         sco_conn_lock(conn);
148         if (conn->sk)
149                 err = -EBUSY;
150         else
151                 __sco_chan_add(conn, sk, parent);
153         sco_conn_unlock(conn);
154         return err;
157 static int sco_connect(struct sock *sk)
159         bdaddr_t *src = &bt_sk(sk)->src;
160         bdaddr_t *dst = &bt_sk(sk)->dst;
161         __u16 pkt_type = sco_pi(sk)->pkt_type;
162         struct sco_conn *conn;
163         struct hci_conn *hcon;
164         struct hci_dev  *hdev;
165         int err, type;
167         BT_DBG("%pMR -> %pMR", src, dst);
169         hdev = hci_get_route(dst, src);
170         if (!hdev)
171                 return -EHOSTUNREACH;
173         hci_dev_lock(hdev);
175         if (lmp_esco_capable(hdev) && !disable_esco)
176                 type = ESCO_LINK;
177         else {
178                 type = SCO_LINK;
179                 pkt_type &= SCO_ESCO_MASK;
180         }
182         hcon = hci_connect(hdev, type, pkt_type, dst, BDADDR_BREDR,
183                            BT_SECURITY_LOW, HCI_AT_NO_BONDING);
184         if (IS_ERR(hcon)) {
185                 err = PTR_ERR(hcon);
186                 goto done;
187         }
189         conn = sco_conn_add(hcon);
190         if (!conn) {
191                 hci_conn_put(hcon);
192                 err = -ENOMEM;
193                 goto done;
194         }
196         /* Update source addr of the socket */
197         bacpy(src, conn->src);
199         err = sco_chan_add(conn, sk, NULL);
200         if (err)
201                 goto done;
203         if (hcon->state == BT_CONNECTED) {
204                 sco_sock_clear_timer(sk);
205                 sk->sk_state = BT_CONNECTED;
206         } else {
207                 sk->sk_state = BT_CONNECT;
208                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
209         }
211 done:
212         hci_dev_unlock(hdev);
213         hci_dev_put(hdev);
214         return err;
217 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
219         struct sco_conn *conn = sco_pi(sk)->conn;
220         struct sk_buff *skb;
221         int err;
223         /* Check outgoing MTU */
224         if (len > conn->mtu)
225                 return -EINVAL;
227         BT_DBG("sk %p len %d", sk, len);
229         skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
230         if (!skb)
231                 return err;
233         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
234                 kfree_skb(skb);
235                 return -EFAULT;
236         }
238         hci_send_sco(conn->hcon, skb);
240         return len;
243 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
245         struct sock *sk = sco_chan_get(conn);
247         if (!sk)
248                 goto drop;
250         BT_DBG("sk %p len %d", sk, skb->len);
252         if (sk->sk_state != BT_CONNECTED)
253                 goto drop;
255         if (!sock_queue_rcv_skb(sk, skb))
256                 return;
258 drop:
259         kfree_skb(skb);
262 /* -------- Socket interface ---------- */
263 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
265         struct hlist_node *node;
266         struct sock *sk;
268         sk_for_each(sk, node, &sco_sk_list.head) {
269                 if (sk->sk_state != BT_LISTEN)
270                         continue;
272                 if (!bacmp(&bt_sk(sk)->src, ba))
273                         return sk;
274         }
276         return NULL;
279 /* Find socket listening on source bdaddr.
280  * Returns closest match.
281  */
282 static struct sock *sco_get_sock_listen(bdaddr_t *src)
284         struct sock *sk = NULL, *sk1 = NULL;
285         struct hlist_node *node;
287         read_lock(&sco_sk_list.lock);
289         sk_for_each(sk, node, &sco_sk_list.head) {
290                 if (sk->sk_state != BT_LISTEN)
291                         continue;
293                 /* Exact match. */
294                 if (!bacmp(&bt_sk(sk)->src, src))
295                         break;
297                 /* Closest match */
298                 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
299                         sk1 = sk;
300         }
302         read_unlock(&sco_sk_list.lock);
304         return node ? sk : sk1;
307 static void sco_sock_destruct(struct sock *sk)
309         BT_DBG("sk %p", sk);
311         skb_queue_purge(&sk->sk_receive_queue);
312         skb_queue_purge(&sk->sk_write_queue);
315 static void sco_sock_cleanup_listen(struct sock *parent)
317         struct sock *sk;
319         BT_DBG("parent %p", parent);
321         /* Close not yet accepted channels */
322         while ((sk = bt_accept_dequeue(parent, NULL))) {
323                 sco_sock_close(sk);
324                 sco_sock_kill(sk);
325         }
327         parent->sk_state  = BT_CLOSED;
328         sock_set_flag(parent, SOCK_ZAPPED);
331 /* Kill socket (only if zapped and orphan)
332  * Must be called on unlocked socket.
333  */
334 static void sco_sock_kill(struct sock *sk)
336         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
337                 return;
339         BT_DBG("sk %p state %d", sk, sk->sk_state);
341         /* Kill poor orphan */
342         bt_sock_unlink(&sco_sk_list, sk);
343         sock_set_flag(sk, SOCK_DEAD);
344         sock_put(sk);
347 static void __sco_sock_close(struct sock *sk)
349         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
351         switch (sk->sk_state) {
352         case BT_LISTEN:
353                 sco_sock_cleanup_listen(sk);
354                 break;
356         case BT_CONNECTED:
357         case BT_CONFIG:
358                 if (sco_pi(sk)->conn->hcon) {
359                         sk->sk_state = BT_DISCONN;
360                         sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
361                         hci_conn_put(sco_pi(sk)->conn->hcon);
362                         sco_pi(sk)->conn->hcon = NULL;
363                 } else
364                         sco_chan_del(sk, ECONNRESET);
365                 break;
367         case BT_CONNECT2:
368         case BT_CONNECT:
369         case BT_DISCONN:
370                 sco_chan_del(sk, ECONNRESET);
371                 break;
373         default:
374                 sock_set_flag(sk, SOCK_ZAPPED);
375                 break;
376         }
379 /* Must be called on unlocked socket. */
380 static void sco_sock_close(struct sock *sk)
382         sco_sock_clear_timer(sk);
383         lock_sock(sk);
384         __sco_sock_close(sk);
385         release_sock(sk);
386         sco_sock_kill(sk);
389 static void sco_sock_init(struct sock *sk, struct sock *parent)
391         BT_DBG("sk %p", sk);
393         if (parent) {
394                 sk->sk_type = parent->sk_type;
395                 bt_sk(sk)->flags = bt_sk(parent)->flags;
396                 security_sk_clone(parent, sk);
397         }
400 static struct proto sco_proto = {
401         .name           = "SCO",
402         .owner          = THIS_MODULE,
403         .obj_size       = sizeof(struct sco_pinfo)
404 };
406 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
408         struct sock *sk;
410         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
411         if (!sk)
412                 return NULL;
414         sock_init_data(sock, sk);
415         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
417         sk->sk_destruct = sco_sock_destruct;
418         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
420         sock_reset_flag(sk, SOCK_ZAPPED);
422         sk->sk_protocol = proto;
423         sk->sk_state    = BT_OPEN;
425         setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
427         bt_sock_link(&sco_sk_list, sk);
428         return sk;
431 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
432                            int kern)
434         struct sock *sk;
436         BT_DBG("sock %p", sock);
438         sock->state = SS_UNCONNECTED;
440         if (sock->type != SOCK_SEQPACKET)
441                 return -ESOCKTNOSUPPORT;
443         sock->ops = &sco_sock_ops;
445         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
446         if (!sk)
447                 return -ENOMEM;
449         sco_sock_init(sk, NULL);
450         return 0;
453 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
455         struct sockaddr_sco sa;
456         struct sock *sk = sock->sk;
457         int len, err = 0;
459         BT_DBG("sk %p %pMR", sk, &sa.sco_bdaddr);
461         if (!addr || addr->sa_family != AF_BLUETOOTH)
462                 return -EINVAL;
464         memset(&sa, 0, sizeof(sa));
465         len = min_t(unsigned int, sizeof(sa), alen);
466         memcpy(&sa, addr, len);
468         lock_sock(sk);
470         if (sk->sk_state != BT_OPEN) {
471                 err = -EBADFD;
472                 goto done;
473         }
475         if (sk->sk_type != SOCK_SEQPACKET) {
476                 err = -EINVAL;
477                 goto done;
478         }
480         bacpy(&bt_sk(sk)->src, &sa.sco_bdaddr);
481         sco_pi(sk)->pkt_type = sa.sco_pkt_type;
483         sk->sk_state = BT_BOUND;
485 done:
486         release_sock(sk);
487         return err;
490 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
492         struct sock *sk = sock->sk;
493         struct sockaddr_sco sa;
494         int len, err = 0;
496         BT_DBG("sk %p", sk);
498         if (!addr || addr->sa_family != AF_BLUETOOTH)
499                 return -EINVAL;
501         memset(&sa, 0, sizeof(sa));
502         len = min_t(unsigned int, sizeof(sa), alen);
503         memcpy(&sa, addr, len);
505         lock_sock(sk);
507         if (sk->sk_type != SOCK_SEQPACKET) {
508                 err = -EINVAL;
509                 goto done;
510         }
512         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
513                 err = -EBADFD;
514                 goto done;
515         }
517         /* Set destination address and psm */
518         bacpy(&bt_sk(sk)->dst, &sa.sco_bdaddr);
519         sco_pi(sk)->pkt_type = sa.sco_pkt_type;
521         err = sco_connect(sk);
522         if (err)
523                 goto done;
525         err = bt_sock_wait_state(sk, BT_CONNECTED,
526                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
528 done:
529         release_sock(sk);
530         return err;
533 static int sco_sock_listen(struct socket *sock, int backlog)
535         struct sock *sk = sock->sk;
536         bdaddr_t *src = &bt_sk(sk)->src;
537         int err = 0;
539         BT_DBG("sk %p backlog %d", sk, backlog);
541         lock_sock(sk);
543         if (sk->sk_state != BT_BOUND) {
544                 err = -EBADFD;
545                 goto done;
546         }
548         if (sk->sk_type != SOCK_SEQPACKET) {
549                 err = -EINVAL;
550                 goto done;
551         }
553         write_lock(&sco_sk_list.lock);
555         if (__sco_get_sock_listen_by_addr(src)) {
556                 err = -EADDRINUSE;
557                 goto unlock;
558         }
560         sk->sk_max_ack_backlog = backlog;
561         sk->sk_ack_backlog = 0;
563         sk->sk_state = BT_LISTEN;
565 unlock:
566         write_unlock(&sco_sk_list.lock);
568 done:
569         release_sock(sk);
570         return err;
573 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
575         DECLARE_WAITQUEUE(wait, current);
576         struct sock *sk = sock->sk, *ch;
577         long timeo;
578         int err = 0;
580         lock_sock(sk);
582         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
584         BT_DBG("sk %p timeo %ld", sk, timeo);
586         /* Wait for an incoming connection. (wake-one). */
587         add_wait_queue_exclusive(sk_sleep(sk), &wait);
588         while (1) {
589                 set_current_state(TASK_INTERRUPTIBLE);
591                 if (sk->sk_state != BT_LISTEN) {
592                         err = -EBADFD;
593                         break;
594                 }
596                 ch = bt_accept_dequeue(sk, newsock);
597                 if (ch)
598                         break;
600                 if (!timeo) {
601                         err = -EAGAIN;
602                         break;
603                 }
605                 if (signal_pending(current)) {
606                         err = sock_intr_errno(timeo);
607                         break;
608                 }
610                 release_sock(sk);
611                 timeo = schedule_timeout(timeo);
612                 lock_sock(sk);
613         }
614         __set_current_state(TASK_RUNNING);
615         remove_wait_queue(sk_sleep(sk), &wait);
617         if (err)
618                 goto done;
620         newsock->state = SS_CONNECTED;
622         BT_DBG("new socket %p", ch);
624 done:
625         release_sock(sk);
626         return err;
629 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
631         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
632         struct sock *sk = sock->sk;
634         BT_DBG("sock %p, sk %p", sock, sk);
636         addr->sa_family = AF_BLUETOOTH;
637         *len = sizeof(struct sockaddr_sco);
639         if (peer)
640                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
641         else
642                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
643         sa->sco_pkt_type = sco_pi(sk)->pkt_type;
645         return 0;
648 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
649                             struct msghdr *msg, size_t len)
651         struct sock *sk = sock->sk;
652         int err;
654         BT_DBG("sock %p, sk %p", sock, sk);
656         err = sock_error(sk);
657         if (err)
658                 return err;
660         if (msg->msg_flags & MSG_OOB)
661                 return -EOPNOTSUPP;
663         lock_sock(sk);
665         if (sk->sk_state == BT_CONNECTED)
666                 err = sco_send_frame(sk, msg, len);
667         else
668                 err = -ENOTCONN;
670         release_sock(sk);
671         return err;
674 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
675                             struct msghdr *msg, size_t len, int flags)
677         struct sock *sk = sock->sk;
678         struct sco_pinfo *pi = sco_pi(sk);
680         lock_sock(sk);
682         if (sk->sk_state == BT_CONNECT2 &&
683             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
684                 hci_conn_accept(pi->conn->hcon, 0);
685                 sk->sk_state = BT_CONFIG;
687                 release_sock(sk);
688                 return 0;
689         }
691         release_sock(sk);
693         return bt_sock_recvmsg(iocb, sock, msg, len, flags);
696 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
698         struct sock *sk = sock->sk;
699         int err = 0;
700         u32 opt;
702         BT_DBG("sk %p", sk);
704         lock_sock(sk);
706         switch (optname) {
708         case BT_DEFER_SETUP:
709                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
710                         err = -EINVAL;
711                         break;
712                 }
714                 if (get_user(opt, (u32 __user *) optval)) {
715                         err = -EFAULT;
716                         break;
717                 }
719                 if (opt)
720                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
721                 else
722                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
723                 break;
725         default:
726                 err = -ENOPROTOOPT;
727                 break;
728         }
730         release_sock(sk);
731         return err;
734 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
736         struct sock *sk = sock->sk;
737         struct sco_options opts;
738         struct sco_conninfo cinfo;
739         int len, err = 0;
741         BT_DBG("sk %p", sk);
743         if (get_user(len, optlen))
744                 return -EFAULT;
746         lock_sock(sk);
748         switch (optname) {
749         case SCO_OPTIONS:
750                 if (sk->sk_state != BT_CONNECTED) {
751                         err = -ENOTCONN;
752                         break;
753                 }
755                 opts.mtu = sco_pi(sk)->conn->mtu;
757                 BT_DBG("mtu %d", opts.mtu);
759                 len = min_t(unsigned int, len, sizeof(opts));
760                 if (copy_to_user(optval, (char *)&opts, len))
761                         err = -EFAULT;
763                 break;
765         case SCO_CONNINFO:
766                 if (sk->sk_state != BT_CONNECTED) {
767                         err = -ENOTCONN;
768                         break;
769                 }
771                 memset(&cinfo, 0, sizeof(cinfo));
772                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
773                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
775                 len = min_t(unsigned int, len, sizeof(cinfo));
776                 if (copy_to_user(optval, (char *)&cinfo, len))
777                         err = -EFAULT;
779                 break;
781         default:
782                 err = -ENOPROTOOPT;
783                 break;
784         }
786         release_sock(sk);
787         return err;
790 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
792         struct sock *sk = sock->sk;
793         int len, err = 0;
795         BT_DBG("sk %p", sk);
797         if (level == SOL_SCO)
798                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
800         if (get_user(len, optlen))
801                 return -EFAULT;
803         lock_sock(sk);
805         switch (optname) {
807         case BT_DEFER_SETUP:
808                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
809                         err = -EINVAL;
810                         break;
811                 }
813                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
814                              (u32 __user *) optval))
815                         err = -EFAULT;
817                 break;
819         default:
820                 err = -ENOPROTOOPT;
821                 break;
822         }
824         release_sock(sk);
825         return err;
828 static int sco_sock_shutdown(struct socket *sock, int how)
830         struct sock *sk = sock->sk;
831         int err = 0;
833         BT_DBG("sock %p, sk %p", sock, sk);
835         if (!sk)
836                 return 0;
838         lock_sock(sk);
839         if (!sk->sk_shutdown) {
840                 sk->sk_shutdown = SHUTDOWN_MASK;
841                 sco_sock_clear_timer(sk);
842                 __sco_sock_close(sk);
844                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
845                         err = bt_sock_wait_state(sk, BT_CLOSED,
846                                                  sk->sk_lingertime);
847         }
848         release_sock(sk);
849         return err;
852 static int sco_sock_release(struct socket *sock)
854         struct sock *sk = sock->sk;
855         int err = 0;
857         BT_DBG("sock %p, sk %p", sock, sk);
859         if (!sk)
860                 return 0;
862         sco_sock_close(sk);
864         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
865                 lock_sock(sk);
866                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
867                 release_sock(sk);
868         }
870         sock_orphan(sk);
871         sco_sock_kill(sk);
872         return err;
875 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
877         BT_DBG("conn %p", conn);
879         sco_pi(sk)->conn = conn;
880         conn->sk = sk;
882         if (parent)
883                 bt_accept_enqueue(parent, sk);
886 /* Delete channel.
887  * Must be called on the locked socket. */
888 static void sco_chan_del(struct sock *sk, int err)
890         struct sco_conn *conn;
892         conn = sco_pi(sk)->conn;
894         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
896         if (conn) {
897                 sco_conn_lock(conn);
898                 conn->sk = NULL;
899                 sco_pi(sk)->conn = NULL;
900                 sco_conn_unlock(conn);
902                 if (conn->hcon)
903                         hci_conn_put(conn->hcon);
904         }
906         sk->sk_state = BT_CLOSED;
907         sk->sk_err   = err;
908         sk->sk_state_change(sk);
910         sock_set_flag(sk, SOCK_ZAPPED);
913 static void sco_conn_ready(struct sco_conn *conn)
915         struct sock *parent;
916         struct sock *sk = conn->sk;
918         BT_DBG("conn %p", conn);
920         if (sk) {
921                 sco_sock_clear_timer(sk);
922                 bh_lock_sock(sk);
923                 sk->sk_state = BT_CONNECTED;
924                 sk->sk_state_change(sk);
925                 bh_unlock_sock(sk);
926         } else {
927                 sco_conn_lock(conn);
929                 parent = sco_get_sock_listen(conn->src);
930                 if (!parent) {
931                         sco_conn_unlock(conn);
932                         return;
933                 }
935                 bh_lock_sock(parent);
937                 sk = sco_sock_alloc(sock_net(parent), NULL,
938                                     BTPROTO_SCO, GFP_ATOMIC);
939                 if (!sk) {
940                         bh_unlock_sock(parent);
941                         sco_conn_unlock(conn);
942                         return;
943                 }
945                 sco_sock_init(sk, parent);
947                 bacpy(&bt_sk(sk)->src, conn->src);
948                 bacpy(&bt_sk(sk)->dst, conn->dst);
950                 hci_conn_hold(conn->hcon);
951                 __sco_chan_add(conn, sk, parent);
953                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
954                         sk->sk_state = BT_CONNECT2;
955                 else
956                         sk->sk_state = BT_CONNECTED;
958                 /* Wake up parent */
959                 parent->sk_data_ready(parent, 1);
961                 bh_unlock_sock(parent);
963                 sco_conn_unlock(conn);
964         }
967 /* ----- SCO interface with lower layer (HCI) ----- */
968 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
970         struct sock *sk;
971         struct hlist_node *node;
972         int lm = 0;
974         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
976         /* Find listening sockets */
977         read_lock(&sco_sk_list.lock);
978         sk_for_each(sk, node, &sco_sk_list.head) {
979                 if (sk->sk_state != BT_LISTEN)
980                         continue;
982                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
983                     !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
984                         lm |= HCI_LM_ACCEPT;
986                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
987                                 *flags |= HCI_PROTO_DEFER;
988                         break;
989                 }
990         }
991         read_unlock(&sco_sk_list.lock);
993         return lm;
996 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
998         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
999         if (!status) {
1000                 struct sco_conn *conn;
1002                 conn = sco_conn_add(hcon);
1003                 if (conn)
1004                         sco_conn_ready(conn);
1005         } else
1006                 sco_conn_del(hcon, bt_to_errno(status));
1009 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1011         BT_DBG("hcon %p reason %d", hcon, reason);
1013         sco_conn_del(hcon, bt_to_errno(reason));
1016 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1018         struct sco_conn *conn = hcon->sco_data;
1020         if (!conn)
1021                 goto drop;
1023         BT_DBG("conn %p len %d", conn, skb->len);
1025         if (skb->len) {
1026                 sco_recv_frame(conn, skb);
1027                 return 0;
1028         }
1030 drop:
1031         kfree_skb(skb);
1032         return 0;
1035 static int sco_debugfs_show(struct seq_file *f, void *p)
1037         struct sock *sk;
1038         struct hlist_node *node;
1040         read_lock(&sco_sk_list.lock);
1042         sk_for_each(sk, node, &sco_sk_list.head) {
1043                 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1044                            &bt_sk(sk)->dst, sk->sk_state);
1045         }
1047         read_unlock(&sco_sk_list.lock);
1049         return 0;
1052 static int sco_debugfs_open(struct inode *inode, struct file *file)
1054         return single_open(file, sco_debugfs_show, inode->i_private);
1057 static const struct file_operations sco_debugfs_fops = {
1058         .open           = sco_debugfs_open,
1059         .read           = seq_read,
1060         .llseek         = seq_lseek,
1061         .release        = single_release,
1062 };
1064 static struct dentry *sco_debugfs;
1066 static const struct proto_ops sco_sock_ops = {
1067         .family         = PF_BLUETOOTH,
1068         .owner          = THIS_MODULE,
1069         .release        = sco_sock_release,
1070         .bind           = sco_sock_bind,
1071         .connect        = sco_sock_connect,
1072         .listen         = sco_sock_listen,
1073         .accept         = sco_sock_accept,
1074         .getname        = sco_sock_getname,
1075         .sendmsg        = sco_sock_sendmsg,
1076         .recvmsg        = sco_sock_recvmsg,
1077         .poll           = bt_sock_poll,
1078         .ioctl          = bt_sock_ioctl,
1079         .mmap           = sock_no_mmap,
1080         .socketpair     = sock_no_socketpair,
1081         .shutdown       = sco_sock_shutdown,
1082         .setsockopt     = sco_sock_setsockopt,
1083         .getsockopt     = sco_sock_getsockopt
1084 };
1086 static const struct net_proto_family sco_sock_family_ops = {
1087         .family = PF_BLUETOOTH,
1088         .owner  = THIS_MODULE,
1089         .create = sco_sock_create,
1090 };
1092 int __init sco_init(void)
1094         int err;
1096         err = proto_register(&sco_proto, 0);
1097         if (err < 0)
1098                 return err;
1100         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1101         if (err < 0) {
1102                 BT_ERR("SCO socket registration failed");
1103                 goto error;
1104         }
1106         err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1107         if (err < 0) {
1108                 BT_ERR("Failed to create SCO proc file");
1109                 bt_sock_unregister(BTPROTO_SCO);
1110                 goto error;
1111         }
1113         if (bt_debugfs) {
1114                 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1115                                                   NULL, &sco_debugfs_fops);
1116                 if (!sco_debugfs)
1117                         BT_ERR("Failed to create SCO debug file");
1118         }
1120         BT_INFO("SCO socket layer initialized");
1122         return 0;
1124 error:
1125         proto_unregister(&sco_proto);
1126         return err;
1129 void __exit sco_exit(void)
1131         bt_procfs_cleanup(&init_net, "sco");
1133         debugfs_remove(sco_debugfs);
1135         if (bt_sock_unregister(BTPROTO_SCO) < 0)
1136                 BT_ERR("SCO socket unregistration failed");
1138         proto_unregister(&sco_proto);
1141 module_param(disable_esco, bool, 0644);
1142 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");