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