projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[Bluetooth] Check if DLC is still attached to the TTY
[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;
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
152 if (!(conn = hcon->sco_data))
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
407 if (parent)
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
455 if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL)))
456 return -ENOMEM;
457
458 sco_sock_init(sk, NULL);
459 return 0;
460}
461
462static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
463{
464 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
465 struct sock *sk = sock->sk;
466 bdaddr_t *src = &sa->sco_bdaddr;
467 int err = 0;
468
469 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
470
471 if (!addr || addr->sa_family != AF_BLUETOOTH)
472 return -EINVAL;
473
474 lock_sock(sk);
475
476 if (sk->sk_state != BT_OPEN) {
477 err = -EBADFD;
478 goto done;
479 }
480
481 write_lock_bh(&sco_sk_list.lock);
482
483 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
484 err = -EADDRINUSE;
485 } else {
486 /* Save source address */
487 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
488 sk->sk_state = BT_BOUND;
489 }
490
491 write_unlock_bh(&sco_sk_list.lock);
492
493done:
494 release_sock(sk);
495 return err;
496}
497
498static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
499{
500 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
501 struct sock *sk = sock->sk;
502 int err = 0;
503
504
505 BT_DBG("sk %p", sk);
506
507 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
508 return -EINVAL;
509
510 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
511 return -EBADFD;
512
513 if (sk->sk_type != SOCK_SEQPACKET)
514 return -EINVAL;
515
516 lock_sock(sk);
517
518 /* Set destination address and psm */
519 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
520
521 if ((err = sco_connect(sk)))
522 goto done;
523
524 err = bt_sock_wait_state(sk, BT_CONNECTED,
525 sock_sndtimeo(sk, flags & O_NONBLOCK));
526
527done:
528 release_sock(sk);
529 return err;
530}
531
532static int sco_sock_listen(struct socket *sock, int backlog)
533{
534 struct sock *sk = sock->sk;
535 int err = 0;
536
537 BT_DBG("sk %p backlog %d", sk, backlog);
538
539 lock_sock(sk);
540
541 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
542 err = -EBADFD;
543 goto done;
544 }
545
546 sk->sk_max_ack_backlog = backlog;
547 sk->sk_ack_backlog = 0;
548 sk->sk_state = BT_LISTEN;
549
550done:
551 release_sock(sk);
552 return err;
553}
554
555static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
556{
557 DECLARE_WAITQUEUE(wait, current);
558 struct sock *sk = sock->sk, *ch;
559 long timeo;
560 int err = 0;
561
562 lock_sock(sk);
563
564 if (sk->sk_state != BT_LISTEN) {
565 err = -EBADFD;
566 goto done;
567 }
568
569 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
570
571 BT_DBG("sk %p timeo %ld", sk, timeo);
572
573 /* Wait for an incoming connection. (wake-one). */
574 add_wait_queue_exclusive(sk->sk_sleep, &wait);
575 while (!(ch = bt_accept_dequeue(sk, newsock))) {
576 set_current_state(TASK_INTERRUPTIBLE);
577 if (!timeo) {
578 err = -EAGAIN;
579 break;
580 }
581
582 release_sock(sk);
583 timeo = schedule_timeout(timeo);
584 lock_sock(sk);
585
586 if (sk->sk_state != BT_LISTEN) {
587 err = -EBADFD;
588 break;
589 }
590
591 if (signal_pending(current)) {
592 err = sock_intr_errno(timeo);
593 break;
594 }
595 }
596 set_current_state(TASK_RUNNING);
597 remove_wait_queue(sk->sk_sleep, &wait);
598
599 if (err)
600 goto done;
601
602 newsock->state = SS_CONNECTED;
603
604 BT_DBG("new socket %p", ch);
605
606done:
607 release_sock(sk);
608 return err;
609}
610
611static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
612{
613 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
614 struct sock *sk = sock->sk;
615
616 BT_DBG("sock %p, sk %p", sock, sk);
617
618 addr->sa_family = AF_BLUETOOTH;
619 *len = sizeof(struct sockaddr_sco);
620
621 if (peer)
622 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
623 else
624 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
625
626 return 0;
627}
628
629static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
630 struct msghdr *msg, size_t len)
631{
632 struct sock *sk = sock->sk;
633 int err = 0;
634
635 BT_DBG("sock %p, sk %p", sock, sk);
636
c1cbe4b7
BL		 637 err = sock_error(sk);
638 if (err)
639 return err;
1da177e4
LT		 640
641 if (msg->msg_flags & MSG_OOB)
642 return -EOPNOTSUPP;
643
644 lock_sock(sk);
645
646 if (sk->sk_state == BT_CONNECTED)
647 err = sco_send_frame(sk, msg, len);
648 else
649 err = -ENOTCONN;
650
651 release_sock(sk);
652 return err;
653}
654
655static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
656{
657 struct sock *sk = sock->sk;
658 int err = 0;
659
660 BT_DBG("sk %p", sk);
661
662 lock_sock(sk);
663
664 switch (optname) {
665 default:
666 err = -ENOPROTOOPT;
667 break;
668 }
669
670 release_sock(sk);
671 return err;
672}
673
674static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
675{
676 struct sock *sk = sock->sk;
677 struct sco_options opts;
678 struct sco_conninfo cinfo;
679 int len, err = 0;
680
681 BT_DBG("sk %p", sk);
682
683 if (get_user(len, optlen))
684 return -EFAULT;
685
686 lock_sock(sk);
687
688 switch (optname) {
689 case SCO_OPTIONS:
690 if (sk->sk_state != BT_CONNECTED) {
691 err = -ENOTCONN;
692 break;
693 }
694
695 opts.mtu = sco_pi(sk)->conn->mtu;
696
697 BT_DBG("mtu %d", opts.mtu);
698
699 len = min_t(unsigned int, len, sizeof(opts));
700 if (copy_to_user(optval, (char *)&opts, len))
701 err = -EFAULT;
702
703 break;
704
705 case SCO_CONNINFO:
706 if (sk->sk_state != BT_CONNECTED) {
707 err = -ENOTCONN;
708 break;
709 }
710
711 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
712 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
713
714 len = min_t(unsigned int, len, sizeof(cinfo));
715 if (copy_to_user(optval, (char *)&cinfo, len))
716 err = -EFAULT;
717
718 break;
719
720 default:
721 err = -ENOPROTOOPT;
722 break;
723 }
724
725 release_sock(sk);
726 return err;
727}
728
729static int sco_sock_release(struct socket *sock)
730{
731 struct sock *sk = sock->sk;
732 int err = 0;
733
734 BT_DBG("sock %p, sk %p", sock, sk);
735
736 if (!sk)
737 return 0;
738
739 sco_sock_close(sk);
740
741 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
742 lock_sock(sk);
743 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
744 release_sock(sk);
745 }
746
747 sock_orphan(sk);
748 sco_sock_kill(sk);
749 return err;
750}
751
752static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
753{
754 BT_DBG("conn %p", conn);
755
756 sco_pi(sk)->conn = conn;
757 conn->sk = sk;
758
759 if (parent)
760 bt_accept_enqueue(parent, sk);
761}
762
763/* Delete channel.
764 * Must be called on the locked socket. */
765static void sco_chan_del(struct sock *sk, int err)
766{
767 struct sco_conn *conn;
768
769 conn = sco_pi(sk)->conn;
770
771 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
772
773 if (conn) {
774 sco_conn_lock(conn);
775 conn->sk = NULL;
776 sco_pi(sk)->conn = NULL;
777 sco_conn_unlock(conn);
778 hci_conn_put(conn->hcon);
779 }
780
781 sk->sk_state = BT_CLOSED;
782 sk->sk_err = err;
783 sk->sk_state_change(sk);
784
785 sock_set_flag(sk, SOCK_ZAPPED);
786}
787
788static void sco_conn_ready(struct sco_conn *conn)
789{
790 struct sock *parent, *sk;
791
792 BT_DBG("conn %p", conn);
793
794 sco_conn_lock(conn);
795
796 if ((sk = conn->sk)) {
797 sco_sock_clear_timer(sk);
798 bh_lock_sock(sk);
799 sk->sk_state = BT_CONNECTED;
800 sk->sk_state_change(sk);
801 bh_unlock_sock(sk);
802 } else {
803 parent = sco_get_sock_listen(conn->src);
804 if (!parent)
805 goto done;
806
807 bh_lock_sock(parent);
808
809 sk = sco_sock_alloc(NULL, BTPROTO_SCO, GFP_ATOMIC);
810 if (!sk) {
811 bh_unlock_sock(parent);
812 goto done;
813 }
814
815 sco_sock_init(sk, parent);
816
817 bacpy(&bt_sk(sk)->src, conn->src);
818 bacpy(&bt_sk(sk)->dst, conn->dst);
819
820 hci_conn_hold(conn->hcon);
821 __sco_chan_add(conn, sk, parent);
822
823 sk->sk_state = BT_CONNECTED;
824
825 /* Wake up parent */
826 parent->sk_data_ready(parent, 1);
827
828 bh_unlock_sock(parent);
829 }
830
831done:
832 sco_conn_unlock(conn);
833}
834
835/* ----- SCO interface with lower layer (HCI) ----- */
836static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
837{
838 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
839
840 /* Always accept connection */
841 return HCI_LM_ACCEPT;
842}
843
844static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
845{
846 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
847
848 if (hcon->type != SCO_LINK)
849 return 0;
850
851 if (!status) {
852 struct sco_conn *conn;
853
854 conn = sco_conn_add(hcon, status);
855 if (conn)
856 sco_conn_ready(conn);
857 } else
858 sco_conn_del(hcon, bt_err(status));
859
860 return 0;
861}
862
863static int sco_disconn_ind(struct hci_conn *hcon, __u8 reason)
864{
865 BT_DBG("hcon %p reason %d", hcon, reason);
866
867 if (hcon->type != SCO_LINK)
868 return 0;
869
870 sco_conn_del(hcon, bt_err(reason));
871 return 0;
872}
873
874static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
875{
876 struct sco_conn *conn = hcon->sco_data;
877
878 if (!conn)
879 goto drop;
880
881 BT_DBG("conn %p len %d", conn, skb->len);
882
883 if (skb->len) {
884 sco_recv_frame(conn, skb);
885 return 0;
886 }
887
888drop:
889 kfree_skb(skb);
890 return 0;
891}
892
be9d1227 893static ssize_t sco_sysfs_show(struct class *dev, char *buf)
1da177e4
LT		 894{
895 struct sock *sk;
896 struct hlist_node *node;
be9d1227 897 char *str = buf;
1da177e4
LT		 898
899 read_lock_bh(&sco_sk_list.lock);
900
be9d1227
MH		 901 sk_for_each(sk, node, &sco_sk_list.head) {
902 str += sprintf(str, "%s %s %d\n",
903 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
904 sk->sk_state);
905 }
1da177e4 906
1da177e4 907 read_unlock_bh(&sco_sk_list.lock);
1da177e4 908
be9d1227 909 return (str - buf);
1da177e4
LT		 910}
911
be9d1227 912static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
1da177e4 913
90ddc4f0 914static const struct proto_ops sco_sock_ops = {
1da177e4
LT		 915 .family = PF_BLUETOOTH,
916 .owner = THIS_MODULE,
917 .release = sco_sock_release,
918 .bind = sco_sock_bind,
919 .connect = sco_sock_connect,
920 .listen = sco_sock_listen,
921 .accept = sco_sock_accept,
922 .getname = sco_sock_getname,
923 .sendmsg = sco_sock_sendmsg,
924 .recvmsg = bt_sock_recvmsg,
925 .poll = bt_sock_poll,
926 .ioctl = sock_no_ioctl,
927 .mmap = sock_no_mmap,
928 .socketpair = sock_no_socketpair,
929 .shutdown = sock_no_shutdown,
930 .setsockopt = sco_sock_setsockopt,
931 .getsockopt = sco_sock_getsockopt
932};
933
934static struct net_proto_family sco_sock_family_ops = {
935 .family = PF_BLUETOOTH,
936 .owner = THIS_MODULE,
937 .create = sco_sock_create,
938};
939
940static struct hci_proto sco_hci_proto = {
941 .name = "SCO",
942 .id = HCI_PROTO_SCO,
943 .connect_ind = sco_connect_ind,
944 .connect_cfm = sco_connect_cfm,
945 .disconn_ind = sco_disconn_ind,
946 .recv_scodata = sco_recv_scodata
947};
948
949static int __init sco_init(void)
950{
951 int err;
952
953 err = proto_register(&sco_proto, 0);
954 if (err < 0)
955 return err;
956
957 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
958 if (err < 0) {
959 BT_ERR("SCO socket registration failed");
960 goto error;
961 }
962
963 err = hci_register_proto(&sco_hci_proto);
964 if (err < 0) {
965 BT_ERR("SCO protocol registration failed");
966 bt_sock_unregister(BTPROTO_SCO);
967 goto error;
968 }
969
df5c37ea
MH		 970 if (class_create_file(bt_class, &class_attr_sco) < 0)
971 BT_ERR("Failed to create SCO info file");
1da177e4
LT		 972
973 BT_INFO("SCO (Voice Link) ver %s", VERSION);
974 BT_INFO("SCO socket layer initialized");
975
976 return 0;
977
978error:
979 proto_unregister(&sco_proto);
980 return err;
981}
982
983static void __exit sco_exit(void)
984{
a91f2e39 985 class_remove_file(bt_class, &class_attr_sco);
1da177e4
LT		 986
987 if (bt_sock_unregister(BTPROTO_SCO) < 0)
988 BT_ERR("SCO socket unregistration failed");
989
990 if (hci_unregister_proto(&sco_hci_proto) < 0)
991 BT_ERR("SCO protocol unregistration failed");
992
993 proto_unregister(&sco_proto);
994}
995
996module_init(sco_init);
997module_exit(sco_exit);
998
999MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1000MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1001MODULE_VERSION(VERSION);
1002MODULE_LICENSE("GPL");
1003MODULE_ALIAS("bt-proto-2");
kernel source for telekom puls (alcatel/mediatek)