dbb74b4a847ec892e012d9b7aa524260b8e069fa
[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         struct sco_conn *conn;
162         struct hci_conn *hcon;
163         struct hci_dev  *hdev;
164         int err, type;
166         BT_DBG("%pMR -> %pMR", src, dst);
168         hdev = hci_get_route(dst, src);
169         if (!hdev)
170                 return -EHOSTUNREACH;
172         hci_dev_lock(hdev);
174         if (lmp_esco_capable(hdev) && !disable_esco)
175                 type = ESCO_LINK;
176         else
177                 type = SCO_LINK;
179         hcon = hci_connect(hdev, type, dst, BDADDR_BREDR, BT_SECURITY_LOW,
180                            HCI_AT_NO_BONDING);
181         if (IS_ERR(hcon)) {
182                 err = PTR_ERR(hcon);
183                 goto done;
184         }
186         conn = sco_conn_add(hcon);
187         if (!conn) {
188                 hci_conn_put(hcon);
189                 err = -ENOMEM;
190                 goto done;
191         }
193         /* Update source addr of the socket */
194         bacpy(src, conn->src);
196         err = sco_chan_add(conn, sk, NULL);
197         if (err)
198                 goto done;
200         if (hcon->state == BT_CONNECTED) {
201                 sco_sock_clear_timer(sk);
202                 sk->sk_state = BT_CONNECTED;
203         } else {
204                 sk->sk_state = BT_CONNECT;
205                 sco_sock_set_timer(sk, sk->sk_sndtimeo);
206         }
208 done:
209         hci_dev_unlock(hdev);
210         hci_dev_put(hdev);
211         return err;
214 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
216         struct sco_conn *conn = sco_pi(sk)->conn;
217         struct sk_buff *skb;
218         int err;
220         /* Check outgoing MTU */
221         if (len > conn->mtu)
222                 return -EINVAL;
224         BT_DBG("sk %p len %d", sk, len);
226         skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
227         if (!skb)
228                 return err;
230         if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
231                 kfree_skb(skb);
232                 return -EFAULT;
233         }
235         hci_send_sco(conn->hcon, skb);
237         return len;
240 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
242         struct sock *sk = sco_chan_get(conn);
244         if (!sk)
245                 goto drop;
247         BT_DBG("sk %p len %d", sk, skb->len);
249         if (sk->sk_state != BT_CONNECTED)
250                 goto drop;
252         if (!sock_queue_rcv_skb(sk, skb))
253                 return;
255 drop:
256         kfree_skb(skb);
259 /* -------- Socket interface ---------- */
260 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
262         struct hlist_node *node;
263         struct sock *sk;
265         sk_for_each(sk, node, &sco_sk_list.head) {
266                 if (sk->sk_state != BT_LISTEN)
267                         continue;
269                 if (!bacmp(&bt_sk(sk)->src, ba))
270                         return sk;
271         }
273         return NULL;
276 /* Find socket listening on source bdaddr.
277  * Returns closest match.
278  */
279 static struct sock *sco_get_sock_listen(bdaddr_t *src)
281         struct sock *sk = NULL, *sk1 = NULL;
282         struct hlist_node *node;
284         read_lock(&sco_sk_list.lock);
286         sk_for_each(sk, node, &sco_sk_list.head) {
287                 if (sk->sk_state != BT_LISTEN)
288                         continue;
290                 /* Exact match. */
291                 if (!bacmp(&bt_sk(sk)->src, src))
292                         break;
294                 /* Closest match */
295                 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
296                         sk1 = sk;
297         }
299         read_unlock(&sco_sk_list.lock);
301         return node ? sk : sk1;
304 static void sco_sock_destruct(struct sock *sk)
306         BT_DBG("sk %p", sk);
308         skb_queue_purge(&sk->sk_receive_queue);
309         skb_queue_purge(&sk->sk_write_queue);
312 static void sco_sock_cleanup_listen(struct sock *parent)
314         struct sock *sk;
316         BT_DBG("parent %p", parent);
318         /* Close not yet accepted channels */
319         while ((sk = bt_accept_dequeue(parent, NULL))) {
320                 sco_sock_close(sk);
321                 sco_sock_kill(sk);
322         }
324         parent->sk_state  = BT_CLOSED;
325         sock_set_flag(parent, SOCK_ZAPPED);
328 /* Kill socket (only if zapped and orphan)
329  * Must be called on unlocked socket.
330  */
331 static void sco_sock_kill(struct sock *sk)
333         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
334                 return;
336         BT_DBG("sk %p state %d", sk, sk->sk_state);
338         /* Kill poor orphan */
339         bt_sock_unlink(&sco_sk_list, sk);
340         sock_set_flag(sk, SOCK_DEAD);
341         sock_put(sk);
344 static void __sco_sock_close(struct sock *sk)
346         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
348         switch (sk->sk_state) {
349         case BT_LISTEN:
350                 sco_sock_cleanup_listen(sk);
351                 break;
353         case BT_CONNECTED:
354         case BT_CONFIG:
355                 if (sco_pi(sk)->conn->hcon) {
356                         sk->sk_state = BT_DISCONN;
357                         sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
358                         hci_conn_put(sco_pi(sk)->conn->hcon);
359                         sco_pi(sk)->conn->hcon = NULL;
360                 } else
361                         sco_chan_del(sk, ECONNRESET);
362                 break;
364         case BT_CONNECT2:
365         case BT_CONNECT:
366         case BT_DISCONN:
367                 sco_chan_del(sk, ECONNRESET);
368                 break;
370         default:
371                 sock_set_flag(sk, SOCK_ZAPPED);
372                 break;
373         }
376 /* Must be called on unlocked socket. */
377 static void sco_sock_close(struct sock *sk)
379         sco_sock_clear_timer(sk);
380         lock_sock(sk);
381         __sco_sock_close(sk);
382         release_sock(sk);
383         sco_sock_kill(sk);
386 static void sco_sock_init(struct sock *sk, struct sock *parent)
388         BT_DBG("sk %p", sk);
390         if (parent) {
391                 sk->sk_type = parent->sk_type;
392                 bt_sk(sk)->flags = bt_sk(parent)->flags;
393                 security_sk_clone(parent, sk);
394         }
397 static struct proto sco_proto = {
398         .name           = "SCO",
399         .owner          = THIS_MODULE,
400         .obj_size       = sizeof(struct sco_pinfo)
401 };
403 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
405         struct sock *sk;
407         sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
408         if (!sk)
409                 return NULL;
411         sock_init_data(sock, sk);
412         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
414         sk->sk_destruct = sco_sock_destruct;
415         sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
417         sock_reset_flag(sk, SOCK_ZAPPED);
419         sk->sk_protocol = proto;
420         sk->sk_state    = BT_OPEN;
422         setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
424         bt_sock_link(&sco_sk_list, sk);
425         return sk;
428 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
429                            int kern)
431         struct sock *sk;
433         BT_DBG("sock %p", sock);
435         sock->state = SS_UNCONNECTED;
437         if (sock->type != SOCK_SEQPACKET)
438                 return -ESOCKTNOSUPPORT;
440         sock->ops = &sco_sock_ops;
442         sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
443         if (!sk)
444                 return -ENOMEM;
446         sco_sock_init(sk, NULL);
447         return 0;
450 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
452         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
453         struct sock *sk = sock->sk;
454         int err = 0;
456         BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
458         if (!addr || addr->sa_family != AF_BLUETOOTH)
459                 return -EINVAL;
461         lock_sock(sk);
463         if (sk->sk_state != BT_OPEN) {
464                 err = -EBADFD;
465                 goto done;
466         }
468         if (sk->sk_type != SOCK_SEQPACKET) {
469                 err = -EINVAL;
470                 goto done;
471         }
473         bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
475         sk->sk_state = BT_BOUND;
477 done:
478         release_sock(sk);
479         return err;
482 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
484         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
485         struct sock *sk = sock->sk;
486         int err = 0;
489         BT_DBG("sk %p", sk);
491         if (alen < sizeof(struct sockaddr_sco) ||
492             addr->sa_family != AF_BLUETOOTH)
493                 return -EINVAL;
495         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
496                 return -EBADFD;
498         if (sk->sk_type != SOCK_SEQPACKET)
499                 return -EINVAL;
501         lock_sock(sk);
503         /* Set destination address and psm */
504         bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
506         err = sco_connect(sk);
507         if (err)
508                 goto done;
510         err = bt_sock_wait_state(sk, BT_CONNECTED,
511                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
513 done:
514         release_sock(sk);
515         return err;
518 static int sco_sock_listen(struct socket *sock, int backlog)
520         struct sock *sk = sock->sk;
521         bdaddr_t *src = &bt_sk(sk)->src;
522         int err = 0;
524         BT_DBG("sk %p backlog %d", sk, backlog);
526         lock_sock(sk);
528         if (sk->sk_state != BT_BOUND) {
529                 err = -EBADFD;
530                 goto done;
531         }
533         if (sk->sk_type != SOCK_SEQPACKET) {
534                 err = -EINVAL;
535                 goto done;
536         }
538         write_lock(&sco_sk_list.lock);
540         if (__sco_get_sock_listen_by_addr(src)) {
541                 err = -EADDRINUSE;
542                 goto unlock;
543         }
545         sk->sk_max_ack_backlog = backlog;
546         sk->sk_ack_backlog = 0;
548         sk->sk_state = BT_LISTEN;
550 unlock:
551         write_unlock(&sco_sk_list.lock);
553 done:
554         release_sock(sk);
555         return err;
558 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
560         DECLARE_WAITQUEUE(wait, current);
561         struct sock *sk = sock->sk, *ch;
562         long timeo;
563         int err = 0;
565         lock_sock(sk);
567         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
569         BT_DBG("sk %p timeo %ld", sk, timeo);
571         /* Wait for an incoming connection. (wake-one). */
572         add_wait_queue_exclusive(sk_sleep(sk), &wait);
573         while (1) {
574                 set_current_state(TASK_INTERRUPTIBLE);
576                 if (sk->sk_state != BT_LISTEN) {
577                         err = -EBADFD;
578                         break;
579                 }
581                 ch = bt_accept_dequeue(sk, newsock);
582                 if (ch)
583                         break;
585                 if (!timeo) {
586                         err = -EAGAIN;
587                         break;
588                 }
590                 if (signal_pending(current)) {
591                         err = sock_intr_errno(timeo);
592                         break;
593                 }
595                 release_sock(sk);
596                 timeo = schedule_timeout(timeo);
597                 lock_sock(sk);
598         }
599         __set_current_state(TASK_RUNNING);
600         remove_wait_queue(sk_sleep(sk), &wait);
602         if (err)
603                 goto done;
605         newsock->state = SS_CONNECTED;
607         BT_DBG("new socket %p", ch);
609 done:
610         release_sock(sk);
611         return err;
614 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
616         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
617         struct sock *sk = sock->sk;
619         BT_DBG("sock %p, sk %p", sock, sk);
621         addr->sa_family = AF_BLUETOOTH;
622         *len = sizeof(struct sockaddr_sco);
624         if (peer)
625                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
626         else
627                 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
629         return 0;
632 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
633                             struct msghdr *msg, size_t len)
635         struct sock *sk = sock->sk;
636         int err;
638         BT_DBG("sock %p, sk %p", sock, sk);
640         err = sock_error(sk);
641         if (err)
642                 return err;
644         if (msg->msg_flags & MSG_OOB)
645                 return -EOPNOTSUPP;
647         lock_sock(sk);
649         if (sk->sk_state == BT_CONNECTED)
650                 err = sco_send_frame(sk, msg, len);
651         else
652                 err = -ENOTCONN;
654         release_sock(sk);
655         return err;
658 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
659                             struct msghdr *msg, size_t len, int flags)
661         struct sock *sk = sock->sk;
662         struct sco_pinfo *pi = sco_pi(sk);
664         lock_sock(sk);
666         if (sk->sk_state == BT_CONNECT2 &&
667             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
668                 hci_conn_accept(pi->conn->hcon, 0);
669                 sk->sk_state = BT_CONFIG;
670                 msg->msg_namelen = 0;
672                 release_sock(sk);
673                 return 0;
674         }
676         release_sock(sk);
678         return bt_sock_recvmsg(iocb, sock, msg, len, flags);
681 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
683         struct sock *sk = sock->sk;
684         int err = 0;
685         u32 opt;
687         BT_DBG("sk %p", sk);
689         lock_sock(sk);
691         switch (optname) {
693         case BT_DEFER_SETUP:
694                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
695                         err = -EINVAL;
696                         break;
697                 }
699                 if (get_user(opt, (u32 __user *) optval)) {
700                         err = -EFAULT;
701                         break;
702                 }
704                 if (opt)
705                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
706                 else
707                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
708                 break;
710         default:
711                 err = -ENOPROTOOPT;
712                 break;
713         }
715         release_sock(sk);
716         return err;
719 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
721         struct sock *sk = sock->sk;
722         struct sco_options opts;
723         struct sco_conninfo cinfo;
724         int len, err = 0;
726         BT_DBG("sk %p", sk);
728         if (get_user(len, optlen))
729                 return -EFAULT;
731         lock_sock(sk);
733         switch (optname) {
734         case SCO_OPTIONS:
735                 if (sk->sk_state != BT_CONNECTED) {
736                         err = -ENOTCONN;
737                         break;
738                 }
740                 opts.mtu = sco_pi(sk)->conn->mtu;
742                 BT_DBG("mtu %d", opts.mtu);
744                 len = min_t(unsigned int, len, sizeof(opts));
745                 if (copy_to_user(optval, (char *)&opts, len))
746                         err = -EFAULT;
748                 break;
750         case SCO_CONNINFO:
751                 if (sk->sk_state != BT_CONNECTED) {
752                         err = -ENOTCONN;
753                         break;
754                 }
756                 memset(&cinfo, 0, sizeof(cinfo));
757                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
758                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
760                 len = min_t(unsigned int, len, sizeof(cinfo));
761                 if (copy_to_user(optval, (char *)&cinfo, len))
762                         err = -EFAULT;
764                 break;
766         default:
767                 err = -ENOPROTOOPT;
768                 break;
769         }
771         release_sock(sk);
772         return err;
775 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
777         struct sock *sk = sock->sk;
778         int len, err = 0;
780         BT_DBG("sk %p", sk);
782         if (level == SOL_SCO)
783                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
785         if (get_user(len, optlen))
786                 return -EFAULT;
788         lock_sock(sk);
790         switch (optname) {
792         case BT_DEFER_SETUP:
793                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
794                         err = -EINVAL;
795                         break;
796                 }
798                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
799                              (u32 __user *) optval))
800                         err = -EFAULT;
802                 break;
804         default:
805                 err = -ENOPROTOOPT;
806                 break;
807         }
809         release_sock(sk);
810         return err;
813 static int sco_sock_shutdown(struct socket *sock, int how)
815         struct sock *sk = sock->sk;
816         int err = 0;
818         BT_DBG("sock %p, sk %p", sock, sk);
820         if (!sk)
821                 return 0;
823         lock_sock(sk);
824         if (!sk->sk_shutdown) {
825                 sk->sk_shutdown = SHUTDOWN_MASK;
826                 sco_sock_clear_timer(sk);
827                 __sco_sock_close(sk);
829                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
830                         err = bt_sock_wait_state(sk, BT_CLOSED,
831                                                  sk->sk_lingertime);
832         }
833         release_sock(sk);
834         return err;
837 static int sco_sock_release(struct socket *sock)
839         struct sock *sk = sock->sk;
840         int err = 0;
842         BT_DBG("sock %p, sk %p", sock, sk);
844         if (!sk)
845                 return 0;
847         sco_sock_close(sk);
849         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
850                 lock_sock(sk);
851                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
852                 release_sock(sk);
853         }
855         sock_orphan(sk);
856         sco_sock_kill(sk);
857         return err;
860 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
862         BT_DBG("conn %p", conn);
864         sco_pi(sk)->conn = conn;
865         conn->sk = sk;
867         if (parent)
868                 bt_accept_enqueue(parent, sk);
871 /* Delete channel.
872  * Must be called on the locked socket. */
873 static void sco_chan_del(struct sock *sk, int err)
875         struct sco_conn *conn;
877         conn = sco_pi(sk)->conn;
879         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
881         if (conn) {
882                 sco_conn_lock(conn);
883                 conn->sk = NULL;
884                 sco_pi(sk)->conn = NULL;
885                 sco_conn_unlock(conn);
887                 if (conn->hcon)
888                         hci_conn_put(conn->hcon);
889         }
891         sk->sk_state = BT_CLOSED;
892         sk->sk_err   = err;
893         sk->sk_state_change(sk);
895         sock_set_flag(sk, SOCK_ZAPPED);
898 static void sco_conn_ready(struct sco_conn *conn)
900         struct sock *parent;
901         struct sock *sk = conn->sk;
903         BT_DBG("conn %p", conn);
905         if (sk) {
906                 sco_sock_clear_timer(sk);
907                 bh_lock_sock(sk);
908                 sk->sk_state = BT_CONNECTED;
909                 sk->sk_state_change(sk);
910                 bh_unlock_sock(sk);
911         } else {
912                 sco_conn_lock(conn);
914                 parent = sco_get_sock_listen(conn->src);
915                 if (!parent) {
916                         sco_conn_unlock(conn);
917                         return;
918                 }
920                 bh_lock_sock(parent);
922                 sk = sco_sock_alloc(sock_net(parent), NULL,
923                                     BTPROTO_SCO, GFP_ATOMIC);
924                 if (!sk) {
925                         bh_unlock_sock(parent);
926                         sco_conn_unlock(conn);
927                         return;
928                 }
930                 sco_sock_init(sk, parent);
932                 bacpy(&bt_sk(sk)->src, conn->src);
933                 bacpy(&bt_sk(sk)->dst, conn->dst);
935                 hci_conn_hold(conn->hcon);
936                 __sco_chan_add(conn, sk, parent);
938                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
939                         sk->sk_state = BT_CONNECT2;
940                 else
941                         sk->sk_state = BT_CONNECTED;
943                 /* Wake up parent */
944                 parent->sk_data_ready(parent, 1);
946                 bh_unlock_sock(parent);
948                 sco_conn_unlock(conn);
949         }
952 /* ----- SCO interface with lower layer (HCI) ----- */
953 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
955         struct sock *sk;
956         struct hlist_node *node;
957         int lm = 0;
959         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
961         /* Find listening sockets */
962         read_lock(&sco_sk_list.lock);
963         sk_for_each(sk, node, &sco_sk_list.head) {
964                 if (sk->sk_state != BT_LISTEN)
965                         continue;
967                 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
968                     !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
969                         lm |= HCI_LM_ACCEPT;
971                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
972                                 *flags |= HCI_PROTO_DEFER;
973                         break;
974                 }
975         }
976         read_unlock(&sco_sk_list.lock);
978         return lm;
981 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
983         BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
984         if (!status) {
985                 struct sco_conn *conn;
987                 conn = sco_conn_add(hcon);
988                 if (conn)
989                         sco_conn_ready(conn);
990         } else
991                 sco_conn_del(hcon, bt_to_errno(status));
994 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
996         BT_DBG("hcon %p reason %d", hcon, reason);
998         sco_conn_del(hcon, bt_to_errno(reason));
1001 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1003         struct sco_conn *conn = hcon->sco_data;
1005         if (!conn)
1006                 goto drop;
1008         BT_DBG("conn %p len %d", conn, skb->len);
1010         if (skb->len) {
1011                 sco_recv_frame(conn, skb);
1012                 return 0;
1013         }
1015 drop:
1016         kfree_skb(skb);
1017         return 0;
1020 static int sco_debugfs_show(struct seq_file *f, void *p)
1022         struct sock *sk;
1023         struct hlist_node *node;
1025         read_lock(&sco_sk_list.lock);
1027         sk_for_each(sk, node, &sco_sk_list.head) {
1028                 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1029                            &bt_sk(sk)->dst, sk->sk_state);
1030         }
1032         read_unlock(&sco_sk_list.lock);
1034         return 0;
1037 static int sco_debugfs_open(struct inode *inode, struct file *file)
1039         return single_open(file, sco_debugfs_show, inode->i_private);
1042 static const struct file_operations sco_debugfs_fops = {
1043         .open           = sco_debugfs_open,
1044         .read           = seq_read,
1045         .llseek         = seq_lseek,
1046         .release        = single_release,
1047 };
1049 static struct dentry *sco_debugfs;
1051 static const struct proto_ops sco_sock_ops = {
1052         .family         = PF_BLUETOOTH,
1053         .owner          = THIS_MODULE,
1054         .release        = sco_sock_release,
1055         .bind           = sco_sock_bind,
1056         .connect        = sco_sock_connect,
1057         .listen         = sco_sock_listen,
1058         .accept         = sco_sock_accept,
1059         .getname        = sco_sock_getname,
1060         .sendmsg        = sco_sock_sendmsg,
1061         .recvmsg        = sco_sock_recvmsg,
1062         .poll           = bt_sock_poll,
1063         .ioctl          = bt_sock_ioctl,
1064         .mmap           = sock_no_mmap,
1065         .socketpair     = sock_no_socketpair,
1066         .shutdown       = sco_sock_shutdown,
1067         .setsockopt     = sco_sock_setsockopt,
1068         .getsockopt     = sco_sock_getsockopt
1069 };
1071 static const struct net_proto_family sco_sock_family_ops = {
1072         .family = PF_BLUETOOTH,
1073         .owner  = THIS_MODULE,
1074         .create = sco_sock_create,
1075 };
1077 int __init sco_init(void)
1079         int err;
1081         err = proto_register(&sco_proto, 0);
1082         if (err < 0)
1083                 return err;
1085         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1086         if (err < 0) {
1087                 BT_ERR("SCO socket registration failed");
1088                 goto error;
1089         }
1091         err = bt_procfs_init(THIS_MODULE, &init_net, "sco", &sco_sk_list, NULL);
1092         if (err < 0) {
1093                 BT_ERR("Failed to create SCO proc file");
1094                 bt_sock_unregister(BTPROTO_SCO);
1095                 goto error;
1096         }
1098         if (bt_debugfs) {
1099                 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1100                                                   NULL, &sco_debugfs_fops);
1101                 if (!sco_debugfs)
1102                         BT_ERR("Failed to create SCO debug file");
1103         }
1105         BT_INFO("SCO socket layer initialized");
1107         return 0;
1109 error:
1110         proto_unregister(&sco_proto);
1111         return err;
1114 void __exit sco_exit(void)
1116         bt_procfs_cleanup(&init_net, "sco");
1118         debugfs_remove(sco_debugfs);
1120         if (bt_sock_unregister(BTPROTO_SCO) < 0)
1121                 BT_ERR("SCO socket unregistration failed");
1123         proto_unregister(&sco_proto);
1126 module_param(disable_esco, bool, 0644);
1127 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");