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 #include <linux/debugfs.h>
29 #include <linux/seq_file.h>
30 #include <linux/sched/signal.h>
31
32 #include <net/bluetooth/bluetooth.h>
33 #include <net/bluetooth/hci_core.h>
34 #include <net/bluetooth/sco.h>
35
36 static bool disable_esco;
37
38 static const struct proto_ops sco_sock_ops;
39
40 static struct bt_sock_list sco_sk_list = {
41 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
42 };
43
44 /* ---- SCO connections ---- */
45 struct sco_conn {
46 struct hci_conn *hcon;
47
48 spinlock_t lock;
49 struct sock *sk;
50
51 struct delayed_work timeout_work;
52
53 unsigned int mtu;
54 };
55
56 #define sco_conn_lock(c) spin_lock(&c->lock)
57 #define sco_conn_unlock(c) spin_unlock(&c->lock)
58
59 static void sco_sock_close(struct sock *sk);
60 static void sco_sock_kill(struct sock *sk);
61
62 /* ----- SCO socket info ----- */
63 #define sco_pi(sk) ((struct sco_pinfo *) sk)
64
65 struct sco_pinfo {
66 struct bt_sock bt;
67 bdaddr_t src;
68 bdaddr_t dst;
69 __u32 flags;
70 __u16 setting;
71 __u8 cmsg_mask;
72 struct bt_codec codec;
73 struct sco_conn *conn;
74 };
75
76 /* ---- SCO timers ---- */
77 #define SCO_CONN_TIMEOUT (HZ * 40)
78 #define SCO_DISCONN_TIMEOUT (HZ * 2)
79
sco_sock_timeout(struct work_struct * work)80 static void sco_sock_timeout(struct work_struct *work)
81 {
82 struct sco_conn *conn = container_of(work, struct sco_conn,
83 timeout_work.work);
84 struct sock *sk;
85
86 sco_conn_lock(conn);
87 sk = conn->sk;
88 if (sk)
89 sock_hold(sk);
90 sco_conn_unlock(conn);
91
92 if (!sk)
93 return;
94
95 BT_DBG("sock %p state %d", sk, sk->sk_state);
96
97 lock_sock(sk);
98 sk->sk_err = ETIMEDOUT;
99 sk->sk_state_change(sk);
100 release_sock(sk);
101 sock_put(sk);
102 }
103
sco_sock_set_timer(struct sock * sk,long timeout)104 static void sco_sock_set_timer(struct sock *sk, long timeout)
105 {
106 if (!sco_pi(sk)->conn)
107 return;
108
109 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
110 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
111 schedule_delayed_work(&sco_pi(sk)->conn->timeout_work, timeout);
112 }
113
sco_sock_clear_timer(struct sock * sk)114 static void sco_sock_clear_timer(struct sock *sk)
115 {
116 if (!sco_pi(sk)->conn)
117 return;
118
119 BT_DBG("sock %p state %d", sk, sk->sk_state);
120 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
121 }
122
123 /* ---- SCO connections ---- */
sco_conn_add(struct hci_conn * hcon)124 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
125 {
126 struct hci_dev *hdev = hcon->hdev;
127 struct sco_conn *conn = hcon->sco_data;
128
129 if (conn)
130 return conn;
131
132 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
133 if (!conn)
134 return NULL;
135
136 spin_lock_init(&conn->lock);
137 INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
138
139 hcon->sco_data = conn;
140 conn->hcon = hcon;
141
142 if (hdev->sco_mtu > 0)
143 conn->mtu = hdev->sco_mtu;
144 else
145 conn->mtu = 60;
146
147 BT_DBG("hcon %p conn %p", hcon, conn);
148
149 return conn;
150 }
151
152 /* Delete channel.
153 * Must be called on the locked socket. */
sco_chan_del(struct sock * sk,int err)154 static void sco_chan_del(struct sock *sk, int err)
155 {
156 struct sco_conn *conn;
157
158 conn = sco_pi(sk)->conn;
159
160 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
161
162 if (conn) {
163 sco_conn_lock(conn);
164 conn->sk = NULL;
165 sco_pi(sk)->conn = NULL;
166 sco_conn_unlock(conn);
167
168 if (conn->hcon)
169 hci_conn_drop(conn->hcon);
170 }
171
172 sk->sk_state = BT_CLOSED;
173 sk->sk_err = err;
174 sk->sk_state_change(sk);
175
176 sock_set_flag(sk, SOCK_ZAPPED);
177 }
178
sco_conn_del(struct hci_conn * hcon,int err)179 static void sco_conn_del(struct hci_conn *hcon, int err)
180 {
181 struct sco_conn *conn = hcon->sco_data;
182 struct sock *sk;
183
184 if (!conn)
185 return;
186
187 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
188
189 /* Kill socket */
190 sco_conn_lock(conn);
191 sk = conn->sk;
192 if (sk)
193 sock_hold(sk);
194 sco_conn_unlock(conn);
195
196 if (sk) {
197 lock_sock(sk);
198 sco_sock_clear_timer(sk);
199 sco_chan_del(sk, err);
200 release_sock(sk);
201 sock_put(sk);
202 }
203
204 /* Ensure no more work items will run before freeing conn. */
205 cancel_delayed_work_sync(&conn->timeout_work);
206
207 hcon->sco_data = NULL;
208 kfree(conn);
209 }
210
__sco_chan_add(struct sco_conn * conn,struct sock * sk,struct sock * parent)211 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
212 struct sock *parent)
213 {
214 BT_DBG("conn %p", conn);
215
216 sco_pi(sk)->conn = conn;
217 conn->sk = sk;
218
219 if (parent)
220 bt_accept_enqueue(parent, sk, true);
221 }
222
sco_chan_add(struct sco_conn * conn,struct sock * sk,struct sock * parent)223 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
224 struct sock *parent)
225 {
226 int err = 0;
227
228 sco_conn_lock(conn);
229 if (conn->sk)
230 err = -EBUSY;
231 else
232 __sco_chan_add(conn, sk, parent);
233
234 sco_conn_unlock(conn);
235 return err;
236 }
237
sco_connect(struct hci_dev * hdev,struct sock * sk)238 static int sco_connect(struct hci_dev *hdev, struct sock *sk)
239 {
240 struct sco_conn *conn;
241 struct hci_conn *hcon;
242 int err, type;
243
244 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
245
246 if (lmp_esco_capable(hdev) && !disable_esco)
247 type = ESCO_LINK;
248 else
249 type = SCO_LINK;
250
251 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
252 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev)))
253 return -EOPNOTSUPP;
254
255 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
256 sco_pi(sk)->setting, &sco_pi(sk)->codec);
257 if (IS_ERR(hcon))
258 return PTR_ERR(hcon);
259
260 conn = sco_conn_add(hcon);
261 if (!conn) {
262 hci_conn_drop(hcon);
263 return -ENOMEM;
264 }
265
266 /* Update source addr of the socket */
267 bacpy(&sco_pi(sk)->src, &hcon->src);
268
269 err = sco_chan_add(conn, sk, NULL);
270 if (err)
271 return err;
272
273 if (hcon->state == BT_CONNECTED) {
274 sco_sock_clear_timer(sk);
275 sk->sk_state = BT_CONNECTED;
276 } else {
277 sk->sk_state = BT_CONNECT;
278 sco_sock_set_timer(sk, sk->sk_sndtimeo);
279 }
280
281 return err;
282 }
283
sco_send_frame(struct sock * sk,struct sk_buff * skb)284 static int sco_send_frame(struct sock *sk, struct sk_buff *skb)
285 {
286 struct sco_conn *conn = sco_pi(sk)->conn;
287 int len = skb->len;
288
289 /* Check outgoing MTU */
290 if (len > conn->mtu)
291 return -EINVAL;
292
293 BT_DBG("sk %p len %d", sk, len);
294
295 hci_send_sco(conn->hcon, skb);
296
297 return len;
298 }
299
sco_recv_frame(struct sco_conn * conn,struct sk_buff * skb)300 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
301 {
302 struct sock *sk;
303
304 sco_conn_lock(conn);
305 sk = conn->sk;
306 sco_conn_unlock(conn);
307
308 if (!sk)
309 goto drop;
310
311 BT_DBG("sk %p len %u", sk, skb->len);
312
313 if (sk->sk_state != BT_CONNECTED)
314 goto drop;
315
316 if (!sock_queue_rcv_skb(sk, skb))
317 return;
318
319 drop:
320 kfree_skb(skb);
321 }
322
323 /* -------- Socket interface ---------- */
__sco_get_sock_listen_by_addr(bdaddr_t * ba)324 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
325 {
326 struct sock *sk;
327
328 sk_for_each(sk, &sco_sk_list.head) {
329 if (sk->sk_state != BT_LISTEN)
330 continue;
331
332 if (!bacmp(&sco_pi(sk)->src, ba))
333 return sk;
334 }
335
336 return NULL;
337 }
338
339 /* Find socket listening on source bdaddr.
340 * Returns closest match.
341 */
sco_get_sock_listen(bdaddr_t * src)342 static struct sock *sco_get_sock_listen(bdaddr_t *src)
343 {
344 struct sock *sk = NULL, *sk1 = NULL;
345
346 read_lock(&sco_sk_list.lock);
347
348 sk_for_each(sk, &sco_sk_list.head) {
349 if (sk->sk_state != BT_LISTEN)
350 continue;
351
352 /* Exact match. */
353 if (!bacmp(&sco_pi(sk)->src, src))
354 break;
355
356 /* Closest match */
357 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
358 sk1 = sk;
359 }
360
361 read_unlock(&sco_sk_list.lock);
362
363 return sk ? sk : sk1;
364 }
365
sco_sock_destruct(struct sock * sk)366 static void sco_sock_destruct(struct sock *sk)
367 {
368 BT_DBG("sk %p", sk);
369
370 skb_queue_purge(&sk->sk_receive_queue);
371 skb_queue_purge(&sk->sk_write_queue);
372 }
373
sco_sock_cleanup_listen(struct sock * parent)374 static void sco_sock_cleanup_listen(struct sock *parent)
375 {
376 struct sock *sk;
377
378 BT_DBG("parent %p", parent);
379
380 /* Close not yet accepted channels */
381 while ((sk = bt_accept_dequeue(parent, NULL))) {
382 sco_sock_close(sk);
383 sco_sock_kill(sk);
384 }
385
386 parent->sk_state = BT_CLOSED;
387 sock_set_flag(parent, SOCK_ZAPPED);
388 }
389
390 /* Kill socket (only if zapped and orphan)
391 * Must be called on unlocked socket.
392 */
sco_sock_kill(struct sock * sk)393 static void sco_sock_kill(struct sock *sk)
394 {
395 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
396 return;
397
398 BT_DBG("sk %p state %d", sk, sk->sk_state);
399
400 /* Kill poor orphan */
401 bt_sock_unlink(&sco_sk_list, sk);
402 sock_set_flag(sk, SOCK_DEAD);
403 sock_put(sk);
404 }
405
__sco_sock_close(struct sock * sk)406 static void __sco_sock_close(struct sock *sk)
407 {
408 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
409
410 switch (sk->sk_state) {
411 case BT_LISTEN:
412 sco_sock_cleanup_listen(sk);
413 break;
414
415 case BT_CONNECTED:
416 case BT_CONFIG:
417 if (sco_pi(sk)->conn->hcon) {
418 sk->sk_state = BT_DISCONN;
419 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
420 sco_conn_lock(sco_pi(sk)->conn);
421 hci_conn_drop(sco_pi(sk)->conn->hcon);
422 sco_pi(sk)->conn->hcon = NULL;
423 sco_conn_unlock(sco_pi(sk)->conn);
424 } else
425 sco_chan_del(sk, ECONNRESET);
426 break;
427
428 case BT_CONNECT2:
429 case BT_CONNECT:
430 case BT_DISCONN:
431 sco_chan_del(sk, ECONNRESET);
432 break;
433
434 default:
435 sock_set_flag(sk, SOCK_ZAPPED);
436 break;
437 }
438
439 }
440
441 /* Must be called on unlocked socket. */
sco_sock_close(struct sock * sk)442 static void sco_sock_close(struct sock *sk)
443 {
444 lock_sock(sk);
445 sco_sock_clear_timer(sk);
446 __sco_sock_close(sk);
447 release_sock(sk);
448 }
449
sco_skb_put_cmsg(struct sk_buff * skb,struct msghdr * msg,struct sock * sk)450 static void sco_skb_put_cmsg(struct sk_buff *skb, struct msghdr *msg,
451 struct sock *sk)
452 {
453 if (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS)
454 put_cmsg(msg, SOL_BLUETOOTH, BT_SCM_PKT_STATUS,
455 sizeof(bt_cb(skb)->sco.pkt_status),
456 &bt_cb(skb)->sco.pkt_status);
457 }
458
sco_sock_init(struct sock * sk,struct sock * parent)459 static void sco_sock_init(struct sock *sk, struct sock *parent)
460 {
461 BT_DBG("sk %p", sk);
462
463 if (parent) {
464 sk->sk_type = parent->sk_type;
465 bt_sk(sk)->flags = bt_sk(parent)->flags;
466 security_sk_clone(parent, sk);
467 } else {
468 bt_sk(sk)->skb_put_cmsg = sco_skb_put_cmsg;
469 }
470 }
471
472 static struct proto sco_proto = {
473 .name = "SCO",
474 .owner = THIS_MODULE,
475 .obj_size = sizeof(struct sco_pinfo)
476 };
477
sco_sock_alloc(struct net * net,struct socket * sock,int proto,gfp_t prio,int kern)478 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
479 int proto, gfp_t prio, int kern)
480 {
481 struct sock *sk;
482
483 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
484 if (!sk)
485 return NULL;
486
487 sock_init_data(sock, sk);
488 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
489
490 sk->sk_destruct = sco_sock_destruct;
491 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
492
493 sock_reset_flag(sk, SOCK_ZAPPED);
494
495 sk->sk_protocol = proto;
496 sk->sk_state = BT_OPEN;
497
498 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
499 sco_pi(sk)->codec.id = BT_CODEC_CVSD;
500 sco_pi(sk)->codec.cid = 0xffff;
501 sco_pi(sk)->codec.vid = 0xffff;
502 sco_pi(sk)->codec.data_path = 0x00;
503
504 bt_sock_link(&sco_sk_list, sk);
505 return sk;
506 }
507
sco_sock_create(struct net * net,struct socket * sock,int protocol,int kern)508 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
509 int kern)
510 {
511 struct sock *sk;
512
513 BT_DBG("sock %p", sock);
514
515 sock->state = SS_UNCONNECTED;
516
517 if (sock->type != SOCK_SEQPACKET)
518 return -ESOCKTNOSUPPORT;
519
520 sock->ops = &sco_sock_ops;
521
522 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
523 if (!sk)
524 return -ENOMEM;
525
526 sco_sock_init(sk, NULL);
527 return 0;
528 }
529
sco_sock_bind(struct socket * sock,struct sockaddr * addr,int addr_len)530 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
531 int addr_len)
532 {
533 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
534 struct sock *sk = sock->sk;
535 int err = 0;
536
537 if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
538 addr->sa_family != AF_BLUETOOTH)
539 return -EINVAL;
540
541 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
542
543 lock_sock(sk);
544
545 if (sk->sk_state != BT_OPEN) {
546 err = -EBADFD;
547 goto done;
548 }
549
550 if (sk->sk_type != SOCK_SEQPACKET) {
551 err = -EINVAL;
552 goto done;
553 }
554
555 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
556
557 sk->sk_state = BT_BOUND;
558
559 done:
560 release_sock(sk);
561 return err;
562 }
563
sco_sock_connect(struct socket * sock,struct sockaddr * addr,int alen,int flags)564 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
565 {
566 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
567 struct sock *sk = sock->sk;
568 struct hci_dev *hdev;
569 int err;
570
571 BT_DBG("sk %p", sk);
572
573 if (alen < sizeof(struct sockaddr_sco) ||
574 addr->sa_family != AF_BLUETOOTH)
575 return -EINVAL;
576
577 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
578 return -EBADFD;
579
580 if (sk->sk_type != SOCK_SEQPACKET)
581 return -EINVAL;
582
583 hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
584 if (!hdev)
585 return -EHOSTUNREACH;
586 hci_dev_lock(hdev);
587
588 lock_sock(sk);
589
590 /* Set destination address and psm */
591 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
592
593 err = sco_connect(hdev, sk);
594 hci_dev_unlock(hdev);
595 hci_dev_put(hdev);
596 if (err)
597 goto done;
598
599 err = bt_sock_wait_state(sk, BT_CONNECTED,
600 sock_sndtimeo(sk, flags & O_NONBLOCK));
601
602 done:
603 release_sock(sk);
604 return err;
605 }
606
sco_sock_listen(struct socket * sock,int backlog)607 static int sco_sock_listen(struct socket *sock, int backlog)
608 {
609 struct sock *sk = sock->sk;
610 bdaddr_t *src = &sco_pi(sk)->src;
611 int err = 0;
612
613 BT_DBG("sk %p backlog %d", sk, backlog);
614
615 lock_sock(sk);
616
617 if (sk->sk_state != BT_BOUND) {
618 err = -EBADFD;
619 goto done;
620 }
621
622 if (sk->sk_type != SOCK_SEQPACKET) {
623 err = -EINVAL;
624 goto done;
625 }
626
627 write_lock(&sco_sk_list.lock);
628
629 if (__sco_get_sock_listen_by_addr(src)) {
630 err = -EADDRINUSE;
631 goto unlock;
632 }
633
634 sk->sk_max_ack_backlog = backlog;
635 sk->sk_ack_backlog = 0;
636
637 sk->sk_state = BT_LISTEN;
638
639 unlock:
640 write_unlock(&sco_sk_list.lock);
641
642 done:
643 release_sock(sk);
644 return err;
645 }
646
sco_sock_accept(struct socket * sock,struct socket * newsock,int flags,bool kern)647 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
648 int flags, bool kern)
649 {
650 DEFINE_WAIT_FUNC(wait, woken_wake_function);
651 struct sock *sk = sock->sk, *ch;
652 long timeo;
653 int err = 0;
654
655 lock_sock(sk);
656
657 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
658
659 BT_DBG("sk %p timeo %ld", sk, timeo);
660
661 /* Wait for an incoming connection. (wake-one). */
662 add_wait_queue_exclusive(sk_sleep(sk), &wait);
663 while (1) {
664 if (sk->sk_state != BT_LISTEN) {
665 err = -EBADFD;
666 break;
667 }
668
669 ch = bt_accept_dequeue(sk, newsock);
670 if (ch)
671 break;
672
673 if (!timeo) {
674 err = -EAGAIN;
675 break;
676 }
677
678 if (signal_pending(current)) {
679 err = sock_intr_errno(timeo);
680 break;
681 }
682
683 release_sock(sk);
684
685 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
686 lock_sock(sk);
687 }
688 remove_wait_queue(sk_sleep(sk), &wait);
689
690 if (err)
691 goto done;
692
693 newsock->state = SS_CONNECTED;
694
695 BT_DBG("new socket %p", ch);
696
697 done:
698 release_sock(sk);
699 return err;
700 }
701
sco_sock_getname(struct socket * sock,struct sockaddr * addr,int peer)702 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
703 int peer)
704 {
705 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
706 struct sock *sk = sock->sk;
707
708 BT_DBG("sock %p, sk %p", sock, sk);
709
710 addr->sa_family = AF_BLUETOOTH;
711
712 if (peer)
713 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
714 else
715 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
716
717 return sizeof(struct sockaddr_sco);
718 }
719
sco_sock_sendmsg(struct socket * sock,struct msghdr * msg,size_t len)720 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
721 size_t len)
722 {
723 struct sock *sk = sock->sk;
724 struct sk_buff *skb;
725 int err;
726
727 BT_DBG("sock %p, sk %p", sock, sk);
728
729 err = sock_error(sk);
730 if (err)
731 return err;
732
733 if (msg->msg_flags & MSG_OOB)
734 return -EOPNOTSUPP;
735
736 skb = bt_skb_sendmsg(sk, msg, len, len, 0, 0);
737 if (IS_ERR(skb))
738 return PTR_ERR(skb);
739
740 lock_sock(sk);
741
742 if (sk->sk_state == BT_CONNECTED)
743 err = sco_send_frame(sk, skb);
744 else
745 err = -ENOTCONN;
746
747 release_sock(sk);
748
749 if (err < 0)
750 kfree_skb(skb);
751 return err;
752 }
753
sco_conn_defer_accept(struct hci_conn * conn,u16 setting)754 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
755 {
756 struct hci_dev *hdev = conn->hdev;
757
758 BT_DBG("conn %p", conn);
759
760 conn->state = BT_CONFIG;
761
762 if (!lmp_esco_capable(hdev)) {
763 struct hci_cp_accept_conn_req cp;
764
765 bacpy(&cp.bdaddr, &conn->dst);
766 cp.role = 0x00; /* Ignored */
767
768 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
769 } else {
770 struct hci_cp_accept_sync_conn_req cp;
771
772 bacpy(&cp.bdaddr, &conn->dst);
773 cp.pkt_type = cpu_to_le16(conn->pkt_type);
774
775 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
776 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
777 cp.content_format = cpu_to_le16(setting);
778
779 switch (setting & SCO_AIRMODE_MASK) {
780 case SCO_AIRMODE_TRANSP:
781 if (conn->pkt_type & ESCO_2EV3)
782 cp.max_latency = cpu_to_le16(0x0008);
783 else
784 cp.max_latency = cpu_to_le16(0x000D);
785 cp.retrans_effort = 0x02;
786 break;
787 case SCO_AIRMODE_CVSD:
788 cp.max_latency = cpu_to_le16(0xffff);
789 cp.retrans_effort = 0xff;
790 break;
791 default:
792 /* use CVSD settings as fallback */
793 cp.max_latency = cpu_to_le16(0xffff);
794 cp.retrans_effort = 0xff;
795 break;
796 }
797
798 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
799 sizeof(cp), &cp);
800 }
801 }
802
sco_sock_recvmsg(struct socket * sock,struct msghdr * msg,size_t len,int flags)803 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
804 size_t len, int flags)
805 {
806 struct sock *sk = sock->sk;
807 struct sco_pinfo *pi = sco_pi(sk);
808
809 lock_sock(sk);
810
811 if (sk->sk_state == BT_CONNECT2 &&
812 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
813 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
814 sk->sk_state = BT_CONFIG;
815
816 release_sock(sk);
817 return 0;
818 }
819
820 release_sock(sk);
821
822 return bt_sock_recvmsg(sock, msg, len, flags);
823 }
824
sco_sock_setsockopt(struct socket * sock,int level,int optname,sockptr_t optval,unsigned int optlen)825 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
826 sockptr_t optval, unsigned int optlen)
827 {
828 struct sock *sk = sock->sk;
829 int len, err = 0;
830 struct bt_voice voice;
831 u32 opt;
832 struct bt_codecs *codecs;
833 struct hci_dev *hdev;
834 __u8 buffer[255];
835
836 BT_DBG("sk %p", sk);
837
838 lock_sock(sk);
839
840 switch (optname) {
841
842 case BT_DEFER_SETUP:
843 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
844 err = -EINVAL;
845 break;
846 }
847
848 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
849 err = -EFAULT;
850 break;
851 }
852
853 if (opt)
854 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
855 else
856 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
857 break;
858
859 case BT_VOICE:
860 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
861 sk->sk_state != BT_CONNECT2) {
862 err = -EINVAL;
863 break;
864 }
865
866 voice.setting = sco_pi(sk)->setting;
867
868 len = min_t(unsigned int, sizeof(voice), optlen);
869 if (copy_from_sockptr(&voice, optval, len)) {
870 err = -EFAULT;
871 break;
872 }
873
874 /* Explicitly check for these values */
875 if (voice.setting != BT_VOICE_TRANSPARENT &&
876 voice.setting != BT_VOICE_CVSD_16BIT) {
877 err = -EINVAL;
878 break;
879 }
880
881 sco_pi(sk)->setting = voice.setting;
882 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
883 BDADDR_BREDR);
884 if (!hdev) {
885 err = -EBADFD;
886 break;
887 }
888 if (enhanced_sco_capable(hdev) &&
889 voice.setting == BT_VOICE_TRANSPARENT)
890 sco_pi(sk)->codec.id = BT_CODEC_TRANSPARENT;
891 hci_dev_put(hdev);
892 break;
893
894 case BT_PKT_STATUS:
895 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
896 err = -EFAULT;
897 break;
898 }
899
900 if (opt)
901 sco_pi(sk)->cmsg_mask |= SCO_CMSG_PKT_STATUS;
902 else
903 sco_pi(sk)->cmsg_mask &= SCO_CMSG_PKT_STATUS;
904 break;
905
906 case BT_CODEC:
907 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
908 sk->sk_state != BT_CONNECT2) {
909 err = -EINVAL;
910 break;
911 }
912
913 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
914 BDADDR_BREDR);
915 if (!hdev) {
916 err = -EBADFD;
917 break;
918 }
919
920 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
921 hci_dev_put(hdev);
922 err = -EOPNOTSUPP;
923 break;
924 }
925
926 if (!hdev->get_data_path_id) {
927 hci_dev_put(hdev);
928 err = -EOPNOTSUPP;
929 break;
930 }
931
932 if (optlen < sizeof(struct bt_codecs) ||
933 optlen > sizeof(buffer)) {
934 hci_dev_put(hdev);
935 err = -EINVAL;
936 break;
937 }
938
939 if (copy_from_sockptr(buffer, optval, optlen)) {
940 hci_dev_put(hdev);
941 err = -EFAULT;
942 break;
943 }
944
945 codecs = (void *)buffer;
946
947 if (codecs->num_codecs > 1) {
948 hci_dev_put(hdev);
949 err = -EINVAL;
950 break;
951 }
952
953 sco_pi(sk)->codec = codecs->codecs[0];
954 hci_dev_put(hdev);
955 break;
956
957 default:
958 err = -ENOPROTOOPT;
959 break;
960 }
961
962 release_sock(sk);
963 return err;
964 }
965
sco_sock_getsockopt_old(struct socket * sock,int optname,char __user * optval,int __user * optlen)966 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
967 char __user *optval, int __user *optlen)
968 {
969 struct sock *sk = sock->sk;
970 struct sco_options opts;
971 struct sco_conninfo cinfo;
972 int len, err = 0;
973
974 BT_DBG("sk %p", sk);
975
976 if (get_user(len, optlen))
977 return -EFAULT;
978
979 lock_sock(sk);
980
981 switch (optname) {
982 case SCO_OPTIONS:
983 if (sk->sk_state != BT_CONNECTED &&
984 !(sk->sk_state == BT_CONNECT2 &&
985 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
986 err = -ENOTCONN;
987 break;
988 }
989
990 opts.mtu = sco_pi(sk)->conn->mtu;
991
992 BT_DBG("mtu %u", opts.mtu);
993
994 len = min_t(unsigned int, len, sizeof(opts));
995 if (copy_to_user(optval, (char *)&opts, len))
996 err = -EFAULT;
997
998 break;
999
1000 case SCO_CONNINFO:
1001 if (sk->sk_state != BT_CONNECTED &&
1002 !(sk->sk_state == BT_CONNECT2 &&
1003 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
1004 err = -ENOTCONN;
1005 break;
1006 }
1007
1008 memset(&cinfo, 0, sizeof(cinfo));
1009 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
1010 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
1011
1012 len = min_t(unsigned int, len, sizeof(cinfo));
1013 if (copy_to_user(optval, (char *)&cinfo, len))
1014 err = -EFAULT;
1015
1016 break;
1017
1018 default:
1019 err = -ENOPROTOOPT;
1020 break;
1021 }
1022
1023 release_sock(sk);
1024 return err;
1025 }
1026
sco_sock_getsockopt(struct socket * sock,int level,int optname,char __user * optval,int __user * optlen)1027 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
1028 char __user *optval, int __user *optlen)
1029 {
1030 struct sock *sk = sock->sk;
1031 int len, err = 0;
1032 struct bt_voice voice;
1033 u32 phys;
1034 int pkt_status;
1035 int buf_len;
1036 struct codec_list *c;
1037 u8 num_codecs, i, __user *ptr;
1038 struct hci_dev *hdev;
1039 struct hci_codec_caps *caps;
1040 struct bt_codec codec;
1041
1042 BT_DBG("sk %p", sk);
1043
1044 if (level == SOL_SCO)
1045 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
1046
1047 if (get_user(len, optlen))
1048 return -EFAULT;
1049
1050 lock_sock(sk);
1051
1052 switch (optname) {
1053
1054 case BT_DEFER_SETUP:
1055 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1056 err = -EINVAL;
1057 break;
1058 }
1059
1060 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
1061 (u32 __user *)optval))
1062 err = -EFAULT;
1063
1064 break;
1065
1066 case BT_VOICE:
1067 voice.setting = sco_pi(sk)->setting;
1068
1069 len = min_t(unsigned int, len, sizeof(voice));
1070 if (copy_to_user(optval, (char *)&voice, len))
1071 err = -EFAULT;
1072
1073 break;
1074
1075 case BT_PHY:
1076 if (sk->sk_state != BT_CONNECTED) {
1077 err = -ENOTCONN;
1078 break;
1079 }
1080
1081 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1082
1083 if (put_user(phys, (u32 __user *) optval))
1084 err = -EFAULT;
1085 break;
1086
1087 case BT_PKT_STATUS:
1088 pkt_status = (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS);
1089
1090 if (put_user(pkt_status, (int __user *)optval))
1091 err = -EFAULT;
1092 break;
1093
1094 case BT_SNDMTU:
1095 case BT_RCVMTU:
1096 if (sk->sk_state != BT_CONNECTED) {
1097 err = -ENOTCONN;
1098 break;
1099 }
1100
1101 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1102 err = -EFAULT;
1103 break;
1104
1105 case BT_CODEC:
1106 num_codecs = 0;
1107 buf_len = 0;
1108
1109 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
1110 if (!hdev) {
1111 err = -EBADFD;
1112 break;
1113 }
1114
1115 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
1116 hci_dev_put(hdev);
1117 err = -EOPNOTSUPP;
1118 break;
1119 }
1120
1121 if (!hdev->get_data_path_id) {
1122 hci_dev_put(hdev);
1123 err = -EOPNOTSUPP;
1124 break;
1125 }
1126
1127 /* find total buffer size required to copy codec + caps */
1128 hci_dev_lock(hdev);
1129 list_for_each_entry(c, &hdev->local_codecs, list) {
1130 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1131 continue;
1132 num_codecs++;
1133 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1134 buf_len += 1 + caps->len;
1135 caps = (void *)&caps->data[caps->len];
1136 }
1137 buf_len += sizeof(struct bt_codec);
1138 }
1139 hci_dev_unlock(hdev);
1140
1141 buf_len += sizeof(struct bt_codecs);
1142 if (buf_len > len) {
1143 hci_dev_put(hdev);
1144 err = -ENOBUFS;
1145 break;
1146 }
1147 ptr = optval;
1148
1149 if (put_user(num_codecs, ptr)) {
1150 hci_dev_put(hdev);
1151 err = -EFAULT;
1152 break;
1153 }
1154 ptr += sizeof(num_codecs);
1155
1156 /* Iterate all the codecs supported over SCO and populate
1157 * codec data
1158 */
1159 hci_dev_lock(hdev);
1160 list_for_each_entry(c, &hdev->local_codecs, list) {
1161 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1162 continue;
1163
1164 codec.id = c->id;
1165 codec.cid = c->cid;
1166 codec.vid = c->vid;
1167 err = hdev->get_data_path_id(hdev, &codec.data_path);
1168 if (err < 0)
1169 break;
1170 codec.num_caps = c->num_caps;
1171 if (copy_to_user(ptr, &codec, sizeof(codec))) {
1172 err = -EFAULT;
1173 break;
1174 }
1175 ptr += sizeof(codec);
1176
1177 /* find codec capabilities data length */
1178 len = 0;
1179 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1180 len += 1 + caps->len;
1181 caps = (void *)&caps->data[caps->len];
1182 }
1183
1184 /* copy codec capabilities data */
1185 if (len && copy_to_user(ptr, c->caps, len)) {
1186 err = -EFAULT;
1187 break;
1188 }
1189 ptr += len;
1190 }
1191
1192 if (!err && put_user(buf_len, optlen))
1193 err = -EFAULT;
1194
1195 hci_dev_unlock(hdev);
1196 hci_dev_put(hdev);
1197
1198 break;
1199
1200 default:
1201 err = -ENOPROTOOPT;
1202 break;
1203 }
1204
1205 release_sock(sk);
1206 return err;
1207 }
1208
sco_sock_shutdown(struct socket * sock,int how)1209 static int sco_sock_shutdown(struct socket *sock, int how)
1210 {
1211 struct sock *sk = sock->sk;
1212 int err = 0;
1213
1214 BT_DBG("sock %p, sk %p", sock, sk);
1215
1216 if (!sk)
1217 return 0;
1218
1219 sock_hold(sk);
1220 lock_sock(sk);
1221
1222 if (!sk->sk_shutdown) {
1223 sk->sk_shutdown = SHUTDOWN_MASK;
1224 sco_sock_clear_timer(sk);
1225 __sco_sock_close(sk);
1226
1227 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1228 !(current->flags & PF_EXITING))
1229 err = bt_sock_wait_state(sk, BT_CLOSED,
1230 sk->sk_lingertime);
1231 }
1232
1233 release_sock(sk);
1234 sock_put(sk);
1235
1236 return err;
1237 }
1238
sco_sock_release(struct socket * sock)1239 static int sco_sock_release(struct socket *sock)
1240 {
1241 struct sock *sk = sock->sk;
1242 int err = 0;
1243
1244 BT_DBG("sock %p, sk %p", sock, sk);
1245
1246 if (!sk)
1247 return 0;
1248
1249 sco_sock_close(sk);
1250
1251 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1252 !(current->flags & PF_EXITING)) {
1253 lock_sock(sk);
1254 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1255 release_sock(sk);
1256 }
1257
1258 sock_orphan(sk);
1259 sco_sock_kill(sk);
1260 return err;
1261 }
1262
sco_conn_ready(struct sco_conn * conn)1263 static void sco_conn_ready(struct sco_conn *conn)
1264 {
1265 struct sock *parent;
1266 struct sock *sk = conn->sk;
1267
1268 BT_DBG("conn %p", conn);
1269
1270 if (sk) {
1271 lock_sock(sk);
1272 sco_sock_clear_timer(sk);
1273 sk->sk_state = BT_CONNECTED;
1274 sk->sk_state_change(sk);
1275 release_sock(sk);
1276 } else {
1277 sco_conn_lock(conn);
1278
1279 if (!conn->hcon) {
1280 sco_conn_unlock(conn);
1281 return;
1282 }
1283
1284 parent = sco_get_sock_listen(&conn->hcon->src);
1285 if (!parent) {
1286 sco_conn_unlock(conn);
1287 return;
1288 }
1289
1290 lock_sock(parent);
1291
1292 sk = sco_sock_alloc(sock_net(parent), NULL,
1293 BTPROTO_SCO, GFP_ATOMIC, 0);
1294 if (!sk) {
1295 release_sock(parent);
1296 sco_conn_unlock(conn);
1297 return;
1298 }
1299
1300 sco_sock_init(sk, parent);
1301
1302 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1303 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1304
1305 hci_conn_hold(conn->hcon);
1306 __sco_chan_add(conn, sk, parent);
1307
1308 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1309 sk->sk_state = BT_CONNECT2;
1310 else
1311 sk->sk_state = BT_CONNECTED;
1312
1313 /* Wake up parent */
1314 parent->sk_data_ready(parent);
1315
1316 release_sock(parent);
1317
1318 sco_conn_unlock(conn);
1319 }
1320 }
1321
1322 /* ----- SCO interface with lower layer (HCI) ----- */
sco_connect_ind(struct hci_dev * hdev,bdaddr_t * bdaddr,__u8 * flags)1323 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1324 {
1325 struct sock *sk;
1326 int lm = 0;
1327
1328 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1329
1330 /* Find listening sockets */
1331 read_lock(&sco_sk_list.lock);
1332 sk_for_each(sk, &sco_sk_list.head) {
1333 if (sk->sk_state != BT_LISTEN)
1334 continue;
1335
1336 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1337 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1338 lm |= HCI_LM_ACCEPT;
1339
1340 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1341 *flags |= HCI_PROTO_DEFER;
1342 break;
1343 }
1344 }
1345 read_unlock(&sco_sk_list.lock);
1346
1347 return lm;
1348 }
1349
sco_connect_cfm(struct hci_conn * hcon,__u8 status)1350 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1351 {
1352 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1353 return;
1354
1355 BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);
1356
1357 if (!status) {
1358 struct sco_conn *conn;
1359
1360 conn = sco_conn_add(hcon);
1361 if (conn)
1362 sco_conn_ready(conn);
1363 } else
1364 sco_conn_del(hcon, bt_to_errno(status));
1365 }
1366
sco_disconn_cfm(struct hci_conn * hcon,__u8 reason)1367 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1368 {
1369 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1370 return;
1371
1372 BT_DBG("hcon %p reason %d", hcon, reason);
1373
1374 sco_conn_del(hcon, bt_to_errno(reason));
1375 }
1376
sco_recv_scodata(struct hci_conn * hcon,struct sk_buff * skb)1377 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1378 {
1379 struct sco_conn *conn = hcon->sco_data;
1380
1381 if (!conn)
1382 goto drop;
1383
1384 BT_DBG("conn %p len %u", conn, skb->len);
1385
1386 if (skb->len) {
1387 sco_recv_frame(conn, skb);
1388 return;
1389 }
1390
1391 drop:
1392 kfree_skb(skb);
1393 }
1394
1395 static struct hci_cb sco_cb = {
1396 .name = "SCO",
1397 .connect_cfm = sco_connect_cfm,
1398 .disconn_cfm = sco_disconn_cfm,
1399 };
1400
sco_debugfs_show(struct seq_file * f,void * p)1401 static int sco_debugfs_show(struct seq_file *f, void *p)
1402 {
1403 struct sock *sk;
1404
1405 read_lock(&sco_sk_list.lock);
1406
1407 sk_for_each(sk, &sco_sk_list.head) {
1408 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1409 &sco_pi(sk)->dst, sk->sk_state);
1410 }
1411
1412 read_unlock(&sco_sk_list.lock);
1413
1414 return 0;
1415 }
1416
1417 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1418
1419 static struct dentry *sco_debugfs;
1420
1421 static const struct proto_ops sco_sock_ops = {
1422 .family = PF_BLUETOOTH,
1423 .owner = THIS_MODULE,
1424 .release = sco_sock_release,
1425 .bind = sco_sock_bind,
1426 .connect = sco_sock_connect,
1427 .listen = sco_sock_listen,
1428 .accept = sco_sock_accept,
1429 .getname = sco_sock_getname,
1430 .sendmsg = sco_sock_sendmsg,
1431 .recvmsg = sco_sock_recvmsg,
1432 .poll = bt_sock_poll,
1433 .ioctl = bt_sock_ioctl,
1434 .gettstamp = sock_gettstamp,
1435 .mmap = sock_no_mmap,
1436 .socketpair = sock_no_socketpair,
1437 .shutdown = sco_sock_shutdown,
1438 .setsockopt = sco_sock_setsockopt,
1439 .getsockopt = sco_sock_getsockopt
1440 };
1441
1442 static const struct net_proto_family sco_sock_family_ops = {
1443 .family = PF_BLUETOOTH,
1444 .owner = THIS_MODULE,
1445 .create = sco_sock_create,
1446 };
1447
sco_init(void)1448 int __init sco_init(void)
1449 {
1450 int err;
1451
1452 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1453
1454 err = proto_register(&sco_proto, 0);
1455 if (err < 0)
1456 return err;
1457
1458 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1459 if (err < 0) {
1460 BT_ERR("SCO socket registration failed");
1461 goto error;
1462 }
1463
1464 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1465 if (err < 0) {
1466 BT_ERR("Failed to create SCO proc file");
1467 bt_sock_unregister(BTPROTO_SCO);
1468 goto error;
1469 }
1470
1471 BT_INFO("SCO socket layer initialized");
1472
1473 hci_register_cb(&sco_cb);
1474
1475 if (IS_ERR_OR_NULL(bt_debugfs))
1476 return 0;
1477
1478 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1479 NULL, &sco_debugfs_fops);
1480
1481 return 0;
1482
1483 error:
1484 proto_unregister(&sco_proto);
1485 return err;
1486 }
1487
sco_exit(void)1488 void sco_exit(void)
1489 {
1490 bt_procfs_cleanup(&init_net, "sco");
1491
1492 debugfs_remove(sco_debugfs);
1493
1494 hci_unregister_cb(&sco_cb);
1495
1496 bt_sock_unregister(BTPROTO_SCO);
1497
1498 proto_unregister(&sco_proto);
1499 }
1500
1501 module_param(disable_esco, bool, 0644);
1502 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");
1503