projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[WAN]: converting generic HDLC to use netif_dormant*()
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / sco.c
CommitLineData
1da177e4
LT		 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
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;
111 struct sco_conn *conn;
112
113 if ((conn = hcon->sco_data))
114 return conn;
115
116 if (status)
117 return conn;
118
119 if (!(conn = kmalloc(sizeof(struct sco_conn), GFP_ATOMIC)))
120 return NULL;
121 memset(conn, 0, sizeof(struct sco_conn));
122
123 spin_lock_init(&conn->lock);
124
125 hcon->sco_data = conn;
126 conn->hcon = hcon;
127
128 conn->src = &hdev->bdaddr;
129 conn->dst = &hcon->dst;
130
131 if (hdev->sco_mtu > 0)
132 conn->mtu = hdev->sco_mtu;
133 else
134 conn->mtu = 60;
135
136 BT_DBG("hcon %p conn %p", hcon, conn);
137 return conn;
138}
139
140static inline struct sock *sco_chan_get(struct sco_conn *conn)
141{
142 struct sock *sk = NULL;
143 sco_conn_lock(conn);
144 sk = conn->sk;
145 sco_conn_unlock(conn);
146 return sk;
147}
148
149static int sco_conn_del(struct hci_conn *hcon, int err)
150{
151 struct sco_conn *conn;
152 struct sock *sk;
153
154 if (!(conn = hcon->sco_data))
155 return 0;
156
157 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
158
159 /* Kill socket */
160 if ((sk = sco_chan_get(conn))) {
161 bh_lock_sock(sk);
162 sco_sock_clear_timer(sk);
163 sco_chan_del(sk, err);
164 bh_unlock_sock(sk);
165 sco_sock_kill(sk);
166 }
167
168 hcon->sco_data = NULL;
169 kfree(conn);
170 return 0;
171}
172
173static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
174{
175 int err = 0;
176
177 sco_conn_lock(conn);
178 if (conn->sk) {
179 err = -EBUSY;
180 } else {
181 __sco_chan_add(conn, sk, parent);
182 }
183 sco_conn_unlock(conn);
184 return err;
185}
186
187static int sco_connect(struct sock *sk)
188{
189 bdaddr_t *src = &bt_sk(sk)->src;
190 bdaddr_t *dst = &bt_sk(sk)->dst;
191 struct sco_conn *conn;
192 struct hci_conn *hcon;
193 struct hci_dev *hdev;
194 int err = 0;
195
196 BT_DBG("%s -> %s", batostr(src), batostr(dst));
197
198 if (!(hdev = hci_get_route(dst, src)))
199 return -EHOSTUNREACH;
200
201 hci_dev_lock_bh(hdev);
202
203 err = -ENOMEM;
204
205 hcon = hci_connect(hdev, SCO_LINK, dst);
206 if (!hcon)
207 goto done;
208
209 conn = sco_conn_add(hcon, 0);
210 if (!conn) {
211 hci_conn_put(hcon);
212 goto done;
213 }
214
215 /* Update source addr of the socket */
216 bacpy(src, conn->src);
217
218 err = sco_chan_add(conn, sk, NULL);
219 if (err)
220 goto done;
221
222 if (hcon->state == BT_CONNECTED) {
223 sco_sock_clear_timer(sk);
224 sk->sk_state = BT_CONNECTED;
225 } else {
226 sk->sk_state = BT_CONNECT;
227 sco_sock_set_timer(sk, sk->sk_sndtimeo);
228 }
229done:
230 hci_dev_unlock_bh(hdev);
231 hci_dev_put(hdev);
232 return err;
233}
234
235static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
236{
237 struct sco_conn *conn = sco_pi(sk)->conn;
238 struct sk_buff *skb;
239 int err, count;
240
241 /* Check outgoing MTU */
242 if (len > conn->mtu)
243 return -EINVAL;
244
245 BT_DBG("sk %p len %d", sk, len);
246
247 count = min_t(unsigned int, conn->mtu, len);
248 if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
249 return err;
250
251 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
252 err = -EFAULT;
253 goto fail;
254 }
255
256 if ((err = hci_send_sco(conn->hcon, skb)) < 0)
cdee5751 257 return err;
1da177e4
LT		 258
259 return count;
260
261fail:
262 kfree_skb(skb);
263 return err;
264}
265
266static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
267{
268 struct sock *sk = sco_chan_get(conn);
269
270 if (!sk)
271 goto drop;
272
273 BT_DBG("sk %p len %d", sk, skb->len);
274
275 if (sk->sk_state != BT_CONNECTED)
276 goto drop;
277
278 if (!sock_queue_rcv_skb(sk, skb))
279 return;
280
281drop:
282 kfree_skb(skb);
283 return;
284}
285
286/* -------- Socket interface ---------- */
287static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
288{
289 struct sock *sk;
290 struct hlist_node *node;
291
292 sk_for_each(sk, node, &sco_sk_list.head)
293 if (!bacmp(&bt_sk(sk)->src, ba))
294 goto found;
295 sk = NULL;
296found:
297 return sk;
298}
299
300/* Find socket listening on source bdaddr.
301 * Returns closest match.
302 */
303static struct sock *sco_get_sock_listen(bdaddr_t *src)
304{
305 struct sock *sk = NULL, *sk1 = NULL;
306 struct hlist_node *node;
307
308 read_lock(&sco_sk_list.lock);
309
310 sk_for_each(sk, node, &sco_sk_list.head) {
311 if (sk->sk_state != BT_LISTEN)
312 continue;
313
314 /* Exact match. */
315 if (!bacmp(&bt_sk(sk)->src, src))
316 break;
317
318 /* Closest match */
319 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
320 sk1 = sk;
321 }
322
323 read_unlock(&sco_sk_list.lock);
324
325 return node ? sk : sk1;
326}
327
328static void sco_sock_destruct(struct sock *sk)
329{
330 BT_DBG("sk %p", sk);
331
332 skb_queue_purge(&sk->sk_receive_queue);
333 skb_queue_purge(&sk->sk_write_queue);
334}
335
336static void sco_sock_cleanup_listen(struct sock *parent)
337{
338 struct sock *sk;
339
340 BT_DBG("parent %p", parent);
341
342 /* Close not yet accepted channels */
343 while ((sk = bt_accept_dequeue(parent, NULL))) {
344 sco_sock_close(sk);
345 sco_sock_kill(sk);
346 }
347
348 parent->sk_state = BT_CLOSED;
349 sock_set_flag(parent, SOCK_ZAPPED);
350}
351
352/* Kill socket (only if zapped and orphan)
353 * Must be called on unlocked socket.
354 */
355static void sco_sock_kill(struct sock *sk)
356{
357 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
358 return;
359
360 BT_DBG("sk %p state %d", sk, sk->sk_state);
361
362 /* Kill poor orphan */
363 bt_sock_unlink(&sco_sk_list, sk);
364 sock_set_flag(sk, SOCK_DEAD);
365 sock_put(sk);
366}
367
368/* Close socket.
369 * Must be called on unlocked socket.
370 */
371static void sco_sock_close(struct sock *sk)
372{
373 struct sco_conn *conn;
374
375 sco_sock_clear_timer(sk);
376
377 lock_sock(sk);
378
379 conn = sco_pi(sk)->conn;
380
381 BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
382
383 switch (sk->sk_state) {
384 case BT_LISTEN:
385 sco_sock_cleanup_listen(sk);
386 break;
387
388 case BT_CONNECTED:
389 case BT_CONFIG:
390 case BT_CONNECT:
391 case BT_DISCONN:
392 sco_chan_del(sk, ECONNRESET);
393 break;
394
395 default:
396 sock_set_flag(sk, SOCK_ZAPPED);
397 break;
398 };
399
400 release_sock(sk);
401
402 sco_sock_kill(sk);
403}
404
405static void sco_sock_init(struct sock *sk, struct sock *parent)
406{
407 BT_DBG("sk %p", sk);
408
409 if (parent)
410 sk->sk_type = parent->sk_type;
411}
412
413static struct proto sco_proto = {
414 .name = "SCO",
415 .owner = THIS_MODULE,
416 .obj_size = sizeof(struct sco_pinfo)
417};
418
dd0fc66f 419static struct sock *sco_sock_alloc(struct socket *sock, int proto, gfp_t prio)
1da177e4
LT		 420{
421 struct sock *sk;
422
423 sk = sk_alloc(PF_BLUETOOTH, prio, &sco_proto, 1);
424 if (!sk)
425 return NULL;
426
427 sock_init_data(sock, sk);
428 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
429
430 sk->sk_destruct = sco_sock_destruct;
431 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
432
433 sock_reset_flag(sk, SOCK_ZAPPED);
434
435 sk->sk_protocol = proto;
436 sk->sk_state = BT_OPEN;
437
438 sco_sock_init_timer(sk);
439
440 bt_sock_link(&sco_sk_list, sk);
441 return sk;
442}
443
444static int sco_sock_create(struct socket *sock, int protocol)
445{
446 struct sock *sk;
447
448 BT_DBG("sock %p", sock);
449
450 sock->state = SS_UNCONNECTED;
451
452 if (sock->type != SOCK_SEQPACKET)
453 return -ESOCKTNOSUPPORT;
454
455 sock->ops = &sco_sock_ops;
456
457 if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL)))
458 return -ENOMEM;
459
460 sco_sock_init(sk, NULL);
461 return 0;
462}
463
464static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
465{
466 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
467 struct sock *sk = sock->sk;
468 bdaddr_t *src = &sa->sco_bdaddr;
469 int err = 0;
470
471 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
472
473 if (!addr || addr->sa_family != AF_BLUETOOTH)
474 return -EINVAL;
475
476 lock_sock(sk);
477
478 if (sk->sk_state != BT_OPEN) {
479 err = -EBADFD;
480 goto done;
481 }
482
483 write_lock_bh(&sco_sk_list.lock);
484
485 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
486 err = -EADDRINUSE;
487 } else {
488 /* Save source address */
489 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
490 sk->sk_state = BT_BOUND;
491 }
492
493 write_unlock_bh(&sco_sk_list.lock);
494
495done:
496 release_sock(sk);
497 return err;
498}
499
500static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
501{
502 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
503 struct sock *sk = sock->sk;
504 int err = 0;
505
506
507 BT_DBG("sk %p", sk);
508
509 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
510 return -EINVAL;
511
512 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
513 return -EBADFD;
514
515 if (sk->sk_type != SOCK_SEQPACKET)
516 return -EINVAL;
517
518 lock_sock(sk);
519
520 /* Set destination address and psm */
521 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
522
523 if ((err = sco_connect(sk)))
524 goto done;
525
526 err = bt_sock_wait_state(sk, BT_CONNECTED,
527 sock_sndtimeo(sk, flags & O_NONBLOCK));
528
529done:
530 release_sock(sk);
531 return err;
532}
533
534static int sco_sock_listen(struct socket *sock, int backlog)
535{
536 struct sock *sk = sock->sk;
537 int err = 0;
538
539 BT_DBG("sk %p backlog %d", sk, backlog);
540
541 lock_sock(sk);
542
543 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
544 err = -EBADFD;
545 goto done;
546 }
547
548 sk->sk_max_ack_backlog = backlog;
549 sk->sk_ack_backlog = 0;
550 sk->sk_state = BT_LISTEN;
551
552done:
553 release_sock(sk);
554 return err;
555}
556
557static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
558{
559 DECLARE_WAITQUEUE(wait, current);
560 struct sock *sk = sock->sk, *ch;
561 long timeo;
562 int err = 0;
563
564 lock_sock(sk);
565
566 if (sk->sk_state != BT_LISTEN) {
567 err = -EBADFD;
568 goto done;
569 }
570
571 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
572
573 BT_DBG("sk %p timeo %ld", sk, timeo);
574
575 /* Wait for an incoming connection. (wake-one). */
576 add_wait_queue_exclusive(sk->sk_sleep, &wait);
577 while (!(ch = bt_accept_dequeue(sk, newsock))) {
578 set_current_state(TASK_INTERRUPTIBLE);
579 if (!timeo) {
580 err = -EAGAIN;
581 break;
582 }
583
584 release_sock(sk);
585 timeo = schedule_timeout(timeo);
586 lock_sock(sk);
587
588 if (sk->sk_state != BT_LISTEN) {
589 err = -EBADFD;
590 break;
591 }
592
593 if (signal_pending(current)) {
594 err = sock_intr_errno(timeo);
595 break;
596 }
597 }
598 set_current_state(TASK_RUNNING);
599 remove_wait_queue(sk->sk_sleep, &wait);
600
601 if (err)
602 goto done;
603
604 newsock->state = SS_CONNECTED;
605
606 BT_DBG("new socket %p", ch);
607
608done:
609 release_sock(sk);
610 return err;
611}
612
613static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
614{
615 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
616 struct sock *sk = sock->sk;
617
618 BT_DBG("sock %p, sk %p", sock, sk);
619
620 addr->sa_family = AF_BLUETOOTH;
621 *len = sizeof(struct sockaddr_sco);
622
623 if (peer)
624 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
625 else
626 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
627
628 return 0;
629}
630
631static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
632 struct msghdr *msg, size_t len)
633{
634 struct sock *sk = sock->sk;
635 int err = 0;
636
637 BT_DBG("sock %p, sk %p", sock, sk);
638
c1cbe4b7
BL		 639 err = sock_error(sk);
640 if (err)
641 return err;
1da177e4
LT		 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
657static 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
676static 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
731static 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
754static 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. */
767static 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
790static 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
833done:
834 sco_conn_unlock(conn);
835}
836
837/* ----- SCO interface with lower layer (HCI) ----- */
838static 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
846static 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
865static 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
876static 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
890drop:
891 kfree_skb(skb);
892 return 0;
893}
894
be9d1227 895static ssize_t sco_sysfs_show(struct class *dev, char *buf)
1da177e4
LT		 896{
897 struct sock *sk;
898 struct hlist_node *node;
be9d1227 899 char *str = buf;
1da177e4
LT		 900
901 read_lock_bh(&sco_sk_list.lock);
902
be9d1227
MH		 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 }
1da177e4 908
1da177e4 909 read_unlock_bh(&sco_sk_list.lock);
1da177e4 910
be9d1227 911 return (str - buf);
1da177e4
LT		 912}
913
be9d1227 914static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
1da177e4 915
90ddc4f0 916static const struct proto_ops sco_sock_ops = {
1da177e4
LT		 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
936static struct net_proto_family sco_sock_family_ops = {
937 .family = PF_BLUETOOTH,
938 .owner = THIS_MODULE,
939 .create = sco_sock_create,
940};
941
942static 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
951static 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
a91f2e39 972 class_create_file(bt_class, &class_attr_sco);
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)