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