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