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