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