projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[IPV6]: Add raw6 drops counter.
[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;
b6a0dc82 192 int err, type;
1da177e4
LT		 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
b6a0dc82
MH		 203 type = lmp_esco_capable(hdev) ? ESCO_LINK : SCO_LINK;
204
205 hcon = hci_connect(hdev, type, dst);
1da177e4
LT		 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 }
b6a0dc82 229
1da177e4
LT		 230done:
231 hci_dev_unlock_bh(hdev);
232 hci_dev_put(hdev);
233 return err;
234}
235
236static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
237{
238 struct sco_conn *conn = sco_pi(sk)->conn;
239 struct sk_buff *skb;
240 int err, count;
241
242 /* Check outgoing MTU */
243 if (len > conn->mtu)
244 return -EINVAL;
245
246 BT_DBG("sk %p len %d", sk, len);
247
248 count = min_t(unsigned int, conn->mtu, len);
249 if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
250 return err;
251
252 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
253 err = -EFAULT;
254 goto fail;
255 }
256
257 if ((err = hci_send_sco(conn->hcon, skb)) < 0)
cdee5751 258 return err;
1da177e4
LT		 259
260 return count;
261
262fail:
263 kfree_skb(skb);
264 return err;
265}
266
267static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
268{
269 struct sock *sk = sco_chan_get(conn);
270
271 if (!sk)
272 goto drop;
273
274 BT_DBG("sk %p len %d", sk, skb->len);
275
276 if (sk->sk_state != BT_CONNECTED)
277 goto drop;
278
279 if (!sock_queue_rcv_skb(sk, skb))
280 return;
281
282drop:
283 kfree_skb(skb);
284 return;
285}
286
287/* -------- Socket interface ---------- */
288static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
289{
290 struct sock *sk;
291 struct hlist_node *node;
292
293 sk_for_each(sk, node, &sco_sk_list.head)
294 if (!bacmp(&bt_sk(sk)->src, ba))
295 goto found;
296 sk = NULL;
297found:
298 return sk;
299}
300
301/* Find socket listening on source bdaddr.
302 * Returns closest match.
303 */
304static struct sock *sco_get_sock_listen(bdaddr_t *src)
305{
306 struct sock *sk = NULL, *sk1 = NULL;
307 struct hlist_node *node;
308
309 read_lock(&sco_sk_list.lock);
310
311 sk_for_each(sk, node, &sco_sk_list.head) {
312 if (sk->sk_state != BT_LISTEN)
313 continue;
314
315 /* Exact match. */
316 if (!bacmp(&bt_sk(sk)->src, src))
317 break;
318
319 /* Closest match */
320 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
321 sk1 = sk;
322 }
323
324 read_unlock(&sco_sk_list.lock);
325
326 return node ? sk : sk1;
327}
328
329static void sco_sock_destruct(struct sock *sk)
330{
331 BT_DBG("sk %p", sk);
332
333 skb_queue_purge(&sk->sk_receive_queue);
334 skb_queue_purge(&sk->sk_write_queue);
335}
336
337static void sco_sock_cleanup_listen(struct sock *parent)
338{
339 struct sock *sk;
340
341 BT_DBG("parent %p", parent);
342
343 /* Close not yet accepted channels */
344 while ((sk = bt_accept_dequeue(parent, NULL))) {
345 sco_sock_close(sk);
346 sco_sock_kill(sk);
347 }
348
349 parent->sk_state = BT_CLOSED;
350 sock_set_flag(parent, SOCK_ZAPPED);
351}
352
353/* Kill socket (only if zapped and orphan)
354 * Must be called on unlocked socket.
355 */
356static void sco_sock_kill(struct sock *sk)
357{
358 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
359 return;
360
361 BT_DBG("sk %p state %d", sk, sk->sk_state);
362
363 /* Kill poor orphan */
364 bt_sock_unlink(&sco_sk_list, sk);
365 sock_set_flag(sk, SOCK_DEAD);
366 sock_put(sk);
367}
368
369/* Close socket.
370 * Must be called on unlocked socket.
371 */
372static void sco_sock_close(struct sock *sk)
373{
374 struct sco_conn *conn;
375
376 sco_sock_clear_timer(sk);
377
378 lock_sock(sk);
379
380 conn = sco_pi(sk)->conn;
381
382 BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
383
384 switch (sk->sk_state) {
385 case BT_LISTEN:
386 sco_sock_cleanup_listen(sk);
387 break;
388
389 case BT_CONNECTED:
390 case BT_CONFIG:
391 case BT_CONNECT:
392 case BT_DISCONN:
393 sco_chan_del(sk, ECONNRESET);
394 break;
395
396 default:
397 sock_set_flag(sk, SOCK_ZAPPED);
398 break;
3ff50b79 399 }
1da177e4
LT		 400
401 release_sock(sk);
402
403 sco_sock_kill(sk);
404}
405
406static void sco_sock_init(struct sock *sk, struct sock *parent)
407{
408 BT_DBG("sk %p", sk);
409
8e87d142 410 if (parent)
1da177e4
LT		 411 sk->sk_type = parent->sk_type;
412}
413
414static struct proto sco_proto = {
415 .name = "SCO",
416 .owner = THIS_MODULE,
417 .obj_size = sizeof(struct sco_pinfo)
418};
419
1b8d7ae4 420static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1da177e4
LT		 421{
422 struct sock *sk;
423
6257ff21 424 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
1da177e4
LT		 425 if (!sk)
426 return NULL;
427
428 sock_init_data(sock, sk);
429 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
430
431 sk->sk_destruct = sco_sock_destruct;
432 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
433
434 sock_reset_flag(sk, SOCK_ZAPPED);
435
436 sk->sk_protocol = proto;
437 sk->sk_state = BT_OPEN;
438
439 sco_sock_init_timer(sk);
440
441 bt_sock_link(&sco_sk_list, sk);
442 return sk;
443}
444
1b8d7ae4 445static int sco_sock_create(struct net *net, struct socket *sock, int protocol)
1da177e4
LT		 446{
447 struct sock *sk;
448
449 BT_DBG("sock %p", sock);
450
451 sock->state = SS_UNCONNECTED;
452
453 if (sock->type != SOCK_SEQPACKET)
454 return -ESOCKTNOSUPPORT;
455
456 sock->ops = &sco_sock_ops;
457
1b8d7ae4 458 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
74da626a 459 if (!sk)
1da177e4
LT		 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
8e87d142 528 err = bt_sock_wait_state(sk, BT_CONNECTED,
1da177e4
LT		 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
8e87d142 633static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
1da177e4
LT		 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
c1cbe4b7
BL		 641 err = sock_error(sk);
642 if (err)
643 return err;
1da177e4
LT		 644
645 if (msg->msg_flags & MSG_OOB)
646 return -EOPNOTSUPP;
647
648 lock_sock(sk);
649
650 if (sk->sk_state == BT_CONNECTED)
651 err = sco_send_frame(sk, msg, len);
652 else
653 err = -ENOTCONN;
654
655 release_sock(sk);
656 return err;
657}
658
659static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
660{
661 struct sock *sk = sock->sk;
662 int err = 0;
663
664 BT_DBG("sk %p", sk);
665
666 lock_sock(sk);
667
668 switch (optname) {
669 default:
670 err = -ENOPROTOOPT;
671 break;
672 }
673
674 release_sock(sk);
675 return err;
676}
677
678static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
679{
680 struct sock *sk = sock->sk;
681 struct sco_options opts;
682 struct sco_conninfo cinfo;
8e87d142 683 int len, err = 0;
1da177e4
LT		 684
685 BT_DBG("sk %p", sk);
686
687 if (get_user(len, optlen))
688 return -EFAULT;
689
690 lock_sock(sk);
691
692 switch (optname) {
693 case SCO_OPTIONS:
694 if (sk->sk_state != BT_CONNECTED) {
695 err = -ENOTCONN;
696 break;
697 }
698
699 opts.mtu = sco_pi(sk)->conn->mtu;
700
701 BT_DBG("mtu %d", opts.mtu);
702
703 len = min_t(unsigned int, len, sizeof(opts));
704 if (copy_to_user(optval, (char *)&opts, len))
705 err = -EFAULT;
706
707 break;
708
709 case SCO_CONNINFO:
710 if (sk->sk_state != BT_CONNECTED) {
711 err = -ENOTCONN;
712 break;
713 }
714
715 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
716 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
717
718 len = min_t(unsigned int, len, sizeof(cinfo));
719 if (copy_to_user(optval, (char *)&cinfo, len))
720 err = -EFAULT;
721
722 break;
723
724 default:
725 err = -ENOPROTOOPT;
726 break;
727 }
728
729 release_sock(sk);
730 return err;
731}
732
733static int sco_sock_release(struct socket *sock)
734{
735 struct sock *sk = sock->sk;
736 int err = 0;
737
738 BT_DBG("sock %p, sk %p", sock, sk);
739
740 if (!sk)
741 return 0;
742
743 sco_sock_close(sk);
744
745 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
746 lock_sock(sk);
747 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
748 release_sock(sk);
749 }
750
751 sock_orphan(sk);
752 sco_sock_kill(sk);
753 return err;
754}
755
756static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
757{
758 BT_DBG("conn %p", conn);
759
760 sco_pi(sk)->conn = conn;
761 conn->sk = sk;
762
763 if (parent)
764 bt_accept_enqueue(parent, sk);
765}
766
8e87d142 767/* Delete channel.
1da177e4
LT		 768 * Must be called on the locked socket. */
769static void sco_chan_del(struct sock *sk, int err)
770{
771 struct sco_conn *conn;
772
773 conn = sco_pi(sk)->conn;
774
775 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
776
8e87d142 777 if (conn) {
1da177e4
LT		 778 sco_conn_lock(conn);
779 conn->sk = NULL;
780 sco_pi(sk)->conn = NULL;
781 sco_conn_unlock(conn);
782 hci_conn_put(conn->hcon);
783 }
784
785 sk->sk_state = BT_CLOSED;
786 sk->sk_err = err;
787 sk->sk_state_change(sk);
788
789 sock_set_flag(sk, SOCK_ZAPPED);
790}
791
792static void sco_conn_ready(struct sco_conn *conn)
793{
794 struct sock *parent, *sk;
795
796 BT_DBG("conn %p", conn);
797
798 sco_conn_lock(conn);
799
800 if ((sk = conn->sk)) {
801 sco_sock_clear_timer(sk);
802 bh_lock_sock(sk);
803 sk->sk_state = BT_CONNECTED;
804 sk->sk_state_change(sk);
805 bh_unlock_sock(sk);
806 } else {
807 parent = sco_get_sock_listen(conn->src);
808 if (!parent)
809 goto done;
810
811 bh_lock_sock(parent);
812
1b8d7ae4 813 sk = sco_sock_alloc(parent->sk_net, NULL, BTPROTO_SCO, GFP_ATOMIC);
1da177e4
LT		 814 if (!sk) {
815 bh_unlock_sock(parent);
816 goto done;
817 }
818
819 sco_sock_init(sk, parent);
820
821 bacpy(&bt_sk(sk)->src, conn->src);
822 bacpy(&bt_sk(sk)->dst, conn->dst);
823
824 hci_conn_hold(conn->hcon);
825 __sco_chan_add(conn, sk, parent);
826
827 sk->sk_state = BT_CONNECTED;
828
829 /* Wake up parent */
830 parent->sk_data_ready(parent, 1);
831
832 bh_unlock_sock(parent);
833 }
834
835done:
836 sco_conn_unlock(conn);
837}
838
839/* ----- SCO interface with lower layer (HCI) ----- */
840static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
841{
842 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
843
844 /* Always accept connection */
845 return HCI_LM_ACCEPT;
846}
847
848static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
849{
850 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
851
b6a0dc82 852 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1da177e4
LT		 853 return 0;
854
855 if (!status) {
856 struct sco_conn *conn;
857
858 conn = sco_conn_add(hcon, status);
859 if (conn)
860 sco_conn_ready(conn);
8e87d142 861 } else
1da177e4
LT		 862 sco_conn_del(hcon, bt_err(status));
863
864 return 0;
865}
866
867static int sco_disconn_ind(struct hci_conn *hcon, __u8 reason)
868{
869 BT_DBG("hcon %p reason %d", hcon, reason);
870
b6a0dc82 871 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1da177e4
LT		 872 return 0;
873
874 sco_conn_del(hcon, bt_err(reason));
b6a0dc82 875
1da177e4
LT		 876 return 0;
877}
878
879static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
880{
881 struct sco_conn *conn = hcon->sco_data;
882
883 if (!conn)
884 goto drop;
885
886 BT_DBG("conn %p len %d", conn, skb->len);
887
888 if (skb->len) {
889 sco_recv_frame(conn, skb);
890 return 0;
891 }
892
893drop:
8e87d142 894 kfree_skb(skb);
1da177e4
LT		 895 return 0;
896}
897
be9d1227 898static ssize_t sco_sysfs_show(struct class *dev, char *buf)
1da177e4
LT		 899{
900 struct sock *sk;
901 struct hlist_node *node;
be9d1227 902 char *str = buf;
1da177e4
LT		 903
904 read_lock_bh(&sco_sk_list.lock);
905
be9d1227
MH		 906 sk_for_each(sk, node, &sco_sk_list.head) {
907 str += sprintf(str, "%s %s %d\n",
908 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
909 sk->sk_state);
910 }
1da177e4 911
1da177e4 912 read_unlock_bh(&sco_sk_list.lock);
1da177e4 913
be9d1227 914 return (str - buf);
1da177e4
LT		 915}
916
be9d1227 917static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
1da177e4 918
90ddc4f0 919static const struct proto_ops sco_sock_ops = {
1da177e4
LT		 920 .family = PF_BLUETOOTH,
921 .owner = THIS_MODULE,
922 .release = sco_sock_release,
923 .bind = sco_sock_bind,
924 .connect = sco_sock_connect,
925 .listen = sco_sock_listen,
926 .accept = sco_sock_accept,
927 .getname = sco_sock_getname,
928 .sendmsg = sco_sock_sendmsg,
929 .recvmsg = bt_sock_recvmsg,
930 .poll = bt_sock_poll,
931 .ioctl = sock_no_ioctl,
932 .mmap = sock_no_mmap,
933 .socketpair = sock_no_socketpair,
934 .shutdown = sock_no_shutdown,
935 .setsockopt = sco_sock_setsockopt,
936 .getsockopt = sco_sock_getsockopt
937};
938
939static struct net_proto_family sco_sock_family_ops = {
940 .family = PF_BLUETOOTH,
941 .owner = THIS_MODULE,
942 .create = sco_sock_create,
943};
944
945static struct hci_proto sco_hci_proto = {
946 .name = "SCO",
947 .id = HCI_PROTO_SCO,
948 .connect_ind = sco_connect_ind,
949 .connect_cfm = sco_connect_cfm,
950 .disconn_ind = sco_disconn_ind,
951 .recv_scodata = sco_recv_scodata
952};
953
954static int __init sco_init(void)
955{
956 int err;
957
958 err = proto_register(&sco_proto, 0);
959 if (err < 0)
960 return err;
961
962 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
963 if (err < 0) {
964 BT_ERR("SCO socket registration failed");
965 goto error;
966 }
967
968 err = hci_register_proto(&sco_hci_proto);
969 if (err < 0) {
970 BT_ERR("SCO protocol registration failed");
971 bt_sock_unregister(BTPROTO_SCO);
972 goto error;
973 }
974
df5c37ea
MH		 975 if (class_create_file(bt_class, &class_attr_sco) < 0)
976 BT_ERR("Failed to create SCO info file");
1da177e4
LT		 977
978 BT_INFO("SCO (Voice Link) ver %s", VERSION);
979 BT_INFO("SCO socket layer initialized");
980
981 return 0;
982
983error:
984 proto_unregister(&sco_proto);
985 return err;
986}
987
988static void __exit sco_exit(void)
989{
a91f2e39 990 class_remove_file(bt_class, &class_attr_sco);
1da177e4
LT		 991
992 if (bt_sock_unregister(BTPROTO_SCO) < 0)
993 BT_ERR("SCO socket unregistration failed");
994
995 if (hci_unregister_proto(&sco_hci_proto) < 0)
996 BT_ERR("SCO protocol unregistration failed");
997
998 proto_unregister(&sco_proto);
999}
1000
1001module_init(sco_init);
1002module_exit(sco_exit);
1003
1004MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1005MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1006MODULE_VERSION(VERSION);
1007MODULE_LICENSE("GPL");
1008MODULE_ALIAS("bt-proto-2");
kernel source for telekom puls (alcatel/mediatek)