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