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