Merge tag 'arm-defconfig-5.19' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc
[linux-2.6-microblaze.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 #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
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
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
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 ---- */
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. */
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
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
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
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
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
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
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 ---------- */
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  */
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
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
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  */
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
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. */
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
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
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
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
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
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
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         lock_sock(sk);
578         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
579                 err = -EBADFD;
580                 goto done;
581         }
582
583         if (sk->sk_type != SOCK_SEQPACKET) {
584                 err = -EINVAL;
585                 goto done;
586         }
587
588         hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
589         if (!hdev) {
590                 err = -EHOSTUNREACH;
591                 goto done;
592         }
593         hci_dev_lock(hdev);
594
595         /* Set destination address and psm */
596         bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
597
598         err = sco_connect(hdev, sk);
599         hci_dev_unlock(hdev);
600         hci_dev_put(hdev);
601         if (err)
602                 goto done;
603
604         err = bt_sock_wait_state(sk, BT_CONNECTED,
605                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
606
607 done:
608         release_sock(sk);
609         return err;
610 }
611
612 static int sco_sock_listen(struct socket *sock, int backlog)
613 {
614         struct sock *sk = sock->sk;
615         bdaddr_t *src = &sco_pi(sk)->src;
616         int err = 0;
617
618         BT_DBG("sk %p backlog %d", sk, backlog);
619
620         lock_sock(sk);
621
622         if (sk->sk_state != BT_BOUND) {
623                 err = -EBADFD;
624                 goto done;
625         }
626
627         if (sk->sk_type != SOCK_SEQPACKET) {
628                 err = -EINVAL;
629                 goto done;
630         }
631
632         write_lock(&sco_sk_list.lock);
633
634         if (__sco_get_sock_listen_by_addr(src)) {
635                 err = -EADDRINUSE;
636                 goto unlock;
637         }
638
639         sk->sk_max_ack_backlog = backlog;
640         sk->sk_ack_backlog = 0;
641
642         sk->sk_state = BT_LISTEN;
643
644 unlock:
645         write_unlock(&sco_sk_list.lock);
646
647 done:
648         release_sock(sk);
649         return err;
650 }
651
652 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
653                            int flags, bool kern)
654 {
655         DEFINE_WAIT_FUNC(wait, woken_wake_function);
656         struct sock *sk = sock->sk, *ch;
657         long timeo;
658         int err = 0;
659
660         lock_sock(sk);
661
662         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
663
664         BT_DBG("sk %p timeo %ld", sk, timeo);
665
666         /* Wait for an incoming connection. (wake-one). */
667         add_wait_queue_exclusive(sk_sleep(sk), &wait);
668         while (1) {
669                 if (sk->sk_state != BT_LISTEN) {
670                         err = -EBADFD;
671                         break;
672                 }
673
674                 ch = bt_accept_dequeue(sk, newsock);
675                 if (ch)
676                         break;
677
678                 if (!timeo) {
679                         err = -EAGAIN;
680                         break;
681                 }
682
683                 if (signal_pending(current)) {
684                         err = sock_intr_errno(timeo);
685                         break;
686                 }
687
688                 release_sock(sk);
689
690                 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
691                 lock_sock(sk);
692         }
693         remove_wait_queue(sk_sleep(sk), &wait);
694
695         if (err)
696                 goto done;
697
698         newsock->state = SS_CONNECTED;
699
700         BT_DBG("new socket %p", ch);
701
702 done:
703         release_sock(sk);
704         return err;
705 }
706
707 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
708                             int peer)
709 {
710         struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
711         struct sock *sk = sock->sk;
712
713         BT_DBG("sock %p, sk %p", sock, sk);
714
715         addr->sa_family = AF_BLUETOOTH;
716
717         if (peer)
718                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
719         else
720                 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
721
722         return sizeof(struct sockaddr_sco);
723 }
724
725 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
726                             size_t len)
727 {
728         struct sock *sk = sock->sk;
729         struct sk_buff *skb;
730         int err;
731
732         BT_DBG("sock %p, sk %p", sock, sk);
733
734         err = sock_error(sk);
735         if (err)
736                 return err;
737
738         if (msg->msg_flags & MSG_OOB)
739                 return -EOPNOTSUPP;
740
741         skb = bt_skb_sendmsg(sk, msg, len, len, 0, 0);
742         if (IS_ERR(skb))
743                 return PTR_ERR(skb);
744
745         lock_sock(sk);
746
747         if (sk->sk_state == BT_CONNECTED)
748                 err = sco_send_frame(sk, skb);
749         else
750                 err = -ENOTCONN;
751
752         release_sock(sk);
753
754         if (err < 0)
755                 kfree_skb(skb);
756         return err;
757 }
758
759 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
760 {
761         struct hci_dev *hdev = conn->hdev;
762
763         BT_DBG("conn %p", conn);
764
765         conn->state = BT_CONFIG;
766
767         if (!lmp_esco_capable(hdev)) {
768                 struct hci_cp_accept_conn_req cp;
769
770                 bacpy(&cp.bdaddr, &conn->dst);
771                 cp.role = 0x00; /* Ignored */
772
773                 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
774         } else {
775                 struct hci_cp_accept_sync_conn_req cp;
776
777                 bacpy(&cp.bdaddr, &conn->dst);
778                 cp.pkt_type = cpu_to_le16(conn->pkt_type);
779
780                 cp.tx_bandwidth   = cpu_to_le32(0x00001f40);
781                 cp.rx_bandwidth   = cpu_to_le32(0x00001f40);
782                 cp.content_format = cpu_to_le16(setting);
783
784                 switch (setting & SCO_AIRMODE_MASK) {
785                 case SCO_AIRMODE_TRANSP:
786                         if (conn->pkt_type & ESCO_2EV3)
787                                 cp.max_latency = cpu_to_le16(0x0008);
788                         else
789                                 cp.max_latency = cpu_to_le16(0x000D);
790                         cp.retrans_effort = 0x02;
791                         break;
792                 case SCO_AIRMODE_CVSD:
793                         cp.max_latency = cpu_to_le16(0xffff);
794                         cp.retrans_effort = 0xff;
795                         break;
796                 default:
797                         /* use CVSD settings as fallback */
798                         cp.max_latency = cpu_to_le16(0xffff);
799                         cp.retrans_effort = 0xff;
800                         break;
801                 }
802
803                 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
804                              sizeof(cp), &cp);
805         }
806 }
807
808 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
809                             size_t len, int flags)
810 {
811         struct sock *sk = sock->sk;
812         struct sco_pinfo *pi = sco_pi(sk);
813
814         lock_sock(sk);
815
816         if (sk->sk_state == BT_CONNECT2 &&
817             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
818                 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
819                 sk->sk_state = BT_CONFIG;
820
821                 release_sock(sk);
822                 return 0;
823         }
824
825         release_sock(sk);
826
827         return bt_sock_recvmsg(sock, msg, len, flags);
828 }
829
830 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
831                                sockptr_t optval, unsigned int optlen)
832 {
833         struct sock *sk = sock->sk;
834         int len, err = 0;
835         struct bt_voice voice;
836         u32 opt;
837         struct bt_codecs *codecs;
838         struct hci_dev *hdev;
839         __u8 buffer[255];
840
841         BT_DBG("sk %p", sk);
842
843         lock_sock(sk);
844
845         switch (optname) {
846
847         case BT_DEFER_SETUP:
848                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
849                         err = -EINVAL;
850                         break;
851                 }
852
853                 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
854                         err = -EFAULT;
855                         break;
856                 }
857
858                 if (opt)
859                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
860                 else
861                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
862                 break;
863
864         case BT_VOICE:
865                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
866                     sk->sk_state != BT_CONNECT2) {
867                         err = -EINVAL;
868                         break;
869                 }
870
871                 voice.setting = sco_pi(sk)->setting;
872
873                 len = min_t(unsigned int, sizeof(voice), optlen);
874                 if (copy_from_sockptr(&voice, optval, len)) {
875                         err = -EFAULT;
876                         break;
877                 }
878
879                 /* Explicitly check for these values */
880                 if (voice.setting != BT_VOICE_TRANSPARENT &&
881                     voice.setting != BT_VOICE_CVSD_16BIT) {
882                         err = -EINVAL;
883                         break;
884                 }
885
886                 sco_pi(sk)->setting = voice.setting;
887                 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
888                                      BDADDR_BREDR);
889                 if (!hdev) {
890                         err = -EBADFD;
891                         break;
892                 }
893                 if (enhanced_sync_conn_capable(hdev) &&
894                     voice.setting == BT_VOICE_TRANSPARENT)
895                         sco_pi(sk)->codec.id = BT_CODEC_TRANSPARENT;
896                 hci_dev_put(hdev);
897                 break;
898
899         case BT_PKT_STATUS:
900                 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
901                         err = -EFAULT;
902                         break;
903                 }
904
905                 if (opt)
906                         sco_pi(sk)->cmsg_mask |= SCO_CMSG_PKT_STATUS;
907                 else
908                         sco_pi(sk)->cmsg_mask &= SCO_CMSG_PKT_STATUS;
909                 break;
910
911         case BT_CODEC:
912                 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
913                     sk->sk_state != BT_CONNECT2) {
914                         err = -EINVAL;
915                         break;
916                 }
917
918                 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
919                                      BDADDR_BREDR);
920                 if (!hdev) {
921                         err = -EBADFD;
922                         break;
923                 }
924
925                 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
926                         hci_dev_put(hdev);
927                         err = -EOPNOTSUPP;
928                         break;
929                 }
930
931                 if (!hdev->get_data_path_id) {
932                         hci_dev_put(hdev);
933                         err = -EOPNOTSUPP;
934                         break;
935                 }
936
937                 if (optlen < sizeof(struct bt_codecs) ||
938                     optlen > sizeof(buffer)) {
939                         hci_dev_put(hdev);
940                         err = -EINVAL;
941                         break;
942                 }
943
944                 if (copy_from_sockptr(buffer, optval, optlen)) {
945                         hci_dev_put(hdev);
946                         err = -EFAULT;
947                         break;
948                 }
949
950                 codecs = (void *)buffer;
951
952                 if (codecs->num_codecs > 1) {
953                         hci_dev_put(hdev);
954                         err = -EINVAL;
955                         break;
956                 }
957
958                 sco_pi(sk)->codec = codecs->codecs[0];
959                 hci_dev_put(hdev);
960                 break;
961
962         default:
963                 err = -ENOPROTOOPT;
964                 break;
965         }
966
967         release_sock(sk);
968         return err;
969 }
970
971 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
972                                    char __user *optval, int __user *optlen)
973 {
974         struct sock *sk = sock->sk;
975         struct sco_options opts;
976         struct sco_conninfo cinfo;
977         int len, err = 0;
978
979         BT_DBG("sk %p", sk);
980
981         if (get_user(len, optlen))
982                 return -EFAULT;
983
984         lock_sock(sk);
985
986         switch (optname) {
987         case SCO_OPTIONS:
988                 if (sk->sk_state != BT_CONNECTED &&
989                     !(sk->sk_state == BT_CONNECT2 &&
990                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
991                         err = -ENOTCONN;
992                         break;
993                 }
994
995                 opts.mtu = sco_pi(sk)->conn->mtu;
996
997                 BT_DBG("mtu %u", opts.mtu);
998
999                 len = min_t(unsigned int, len, sizeof(opts));
1000                 if (copy_to_user(optval, (char *)&opts, len))
1001                         err = -EFAULT;
1002
1003                 break;
1004
1005         case SCO_CONNINFO:
1006                 if (sk->sk_state != BT_CONNECTED &&
1007                     !(sk->sk_state == BT_CONNECT2 &&
1008                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
1009                         err = -ENOTCONN;
1010                         break;
1011                 }
1012
1013                 memset(&cinfo, 0, sizeof(cinfo));
1014                 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
1015                 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
1016
1017                 len = min_t(unsigned int, len, sizeof(cinfo));
1018                 if (copy_to_user(optval, (char *)&cinfo, len))
1019                         err = -EFAULT;
1020
1021                 break;
1022
1023         default:
1024                 err = -ENOPROTOOPT;
1025                 break;
1026         }
1027
1028         release_sock(sk);
1029         return err;
1030 }
1031
1032 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
1033                                char __user *optval, int __user *optlen)
1034 {
1035         struct sock *sk = sock->sk;
1036         int len, err = 0;
1037         struct bt_voice voice;
1038         u32 phys;
1039         int pkt_status;
1040         int buf_len;
1041         struct codec_list *c;
1042         u8 num_codecs, i, __user *ptr;
1043         struct hci_dev *hdev;
1044         struct hci_codec_caps *caps;
1045         struct bt_codec codec;
1046
1047         BT_DBG("sk %p", sk);
1048
1049         if (level == SOL_SCO)
1050                 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
1051
1052         if (get_user(len, optlen))
1053                 return -EFAULT;
1054
1055         lock_sock(sk);
1056
1057         switch (optname) {
1058
1059         case BT_DEFER_SETUP:
1060                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1061                         err = -EINVAL;
1062                         break;
1063                 }
1064
1065                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
1066                              (u32 __user *)optval))
1067                         err = -EFAULT;
1068
1069                 break;
1070
1071         case BT_VOICE:
1072                 voice.setting = sco_pi(sk)->setting;
1073
1074                 len = min_t(unsigned int, len, sizeof(voice));
1075                 if (copy_to_user(optval, (char *)&voice, len))
1076                         err = -EFAULT;
1077
1078                 break;
1079
1080         case BT_PHY:
1081                 if (sk->sk_state != BT_CONNECTED) {
1082                         err = -ENOTCONN;
1083                         break;
1084                 }
1085
1086                 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1087
1088                 if (put_user(phys, (u32 __user *) optval))
1089                         err = -EFAULT;
1090                 break;
1091
1092         case BT_PKT_STATUS:
1093                 pkt_status = (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS);
1094
1095                 if (put_user(pkt_status, (int __user *)optval))
1096                         err = -EFAULT;
1097                 break;
1098
1099         case BT_SNDMTU:
1100         case BT_RCVMTU:
1101                 if (sk->sk_state != BT_CONNECTED) {
1102                         err = -ENOTCONN;
1103                         break;
1104                 }
1105
1106                 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1107                         err = -EFAULT;
1108                 break;
1109
1110         case BT_CODEC:
1111                 num_codecs = 0;
1112                 buf_len = 0;
1113
1114                 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
1115                 if (!hdev) {
1116                         err = -EBADFD;
1117                         break;
1118                 }
1119
1120                 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
1121                         hci_dev_put(hdev);
1122                         err = -EOPNOTSUPP;
1123                         break;
1124                 }
1125
1126                 if (!hdev->get_data_path_id) {
1127                         hci_dev_put(hdev);
1128                         err = -EOPNOTSUPP;
1129                         break;
1130                 }
1131
1132                 /* find total buffer size required to copy codec + caps */
1133                 hci_dev_lock(hdev);
1134                 list_for_each_entry(c, &hdev->local_codecs, list) {
1135                         if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1136                                 continue;
1137                         num_codecs++;
1138                         for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1139                                 buf_len += 1 + caps->len;
1140                                 caps = (void *)&caps->data[caps->len];
1141                         }
1142                         buf_len += sizeof(struct bt_codec);
1143                 }
1144                 hci_dev_unlock(hdev);
1145
1146                 buf_len += sizeof(struct bt_codecs);
1147                 if (buf_len > len) {
1148                         hci_dev_put(hdev);
1149                         err = -ENOBUFS;
1150                         break;
1151                 }
1152                 ptr = optval;
1153
1154                 if (put_user(num_codecs, ptr)) {
1155                         hci_dev_put(hdev);
1156                         err = -EFAULT;
1157                         break;
1158                 }
1159                 ptr += sizeof(num_codecs);
1160
1161                 /* Iterate all the codecs supported over SCO and populate
1162                  * codec data
1163                  */
1164                 hci_dev_lock(hdev);
1165                 list_for_each_entry(c, &hdev->local_codecs, list) {
1166                         if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1167                                 continue;
1168
1169                         codec.id = c->id;
1170                         codec.cid = c->cid;
1171                         codec.vid = c->vid;
1172                         err = hdev->get_data_path_id(hdev, &codec.data_path);
1173                         if (err < 0)
1174                                 break;
1175                         codec.num_caps = c->num_caps;
1176                         if (copy_to_user(ptr, &codec, sizeof(codec))) {
1177                                 err = -EFAULT;
1178                                 break;
1179                         }
1180                         ptr += sizeof(codec);
1181
1182                         /* find codec capabilities data length */
1183                         len = 0;
1184                         for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1185                                 len += 1 + caps->len;
1186                                 caps = (void *)&caps->data[caps->len];
1187                         }
1188
1189                         /* copy codec capabilities data */
1190                         if (len && copy_to_user(ptr, c->caps, len)) {
1191                                 err = -EFAULT;
1192                                 break;
1193                         }
1194                         ptr += len;
1195                 }
1196
1197                 if (!err && put_user(buf_len, optlen))
1198                         err = -EFAULT;
1199
1200                 hci_dev_unlock(hdev);
1201                 hci_dev_put(hdev);
1202
1203                 break;
1204
1205         default:
1206                 err = -ENOPROTOOPT;
1207                 break;
1208         }
1209
1210         release_sock(sk);
1211         return err;
1212 }
1213
1214 static int sco_sock_shutdown(struct socket *sock, int how)
1215 {
1216         struct sock *sk = sock->sk;
1217         int err = 0;
1218
1219         BT_DBG("sock %p, sk %p", sock, sk);
1220
1221         if (!sk)
1222                 return 0;
1223
1224         sock_hold(sk);
1225         lock_sock(sk);
1226
1227         if (!sk->sk_shutdown) {
1228                 sk->sk_shutdown = SHUTDOWN_MASK;
1229                 sco_sock_clear_timer(sk);
1230                 __sco_sock_close(sk);
1231
1232                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1233                     !(current->flags & PF_EXITING))
1234                         err = bt_sock_wait_state(sk, BT_CLOSED,
1235                                                  sk->sk_lingertime);
1236         }
1237
1238         release_sock(sk);
1239         sock_put(sk);
1240
1241         return err;
1242 }
1243
1244 static int sco_sock_release(struct socket *sock)
1245 {
1246         struct sock *sk = sock->sk;
1247         int err = 0;
1248
1249         BT_DBG("sock %p, sk %p", sock, sk);
1250
1251         if (!sk)
1252                 return 0;
1253
1254         sco_sock_close(sk);
1255
1256         if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1257             !(current->flags & PF_EXITING)) {
1258                 lock_sock(sk);
1259                 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1260                 release_sock(sk);
1261         }
1262
1263         sock_orphan(sk);
1264         sco_sock_kill(sk);
1265         return err;
1266 }
1267
1268 static void sco_conn_ready(struct sco_conn *conn)
1269 {
1270         struct sock *parent;
1271         struct sock *sk = conn->sk;
1272
1273         BT_DBG("conn %p", conn);
1274
1275         if (sk) {
1276                 lock_sock(sk);
1277                 sco_sock_clear_timer(sk);
1278                 sk->sk_state = BT_CONNECTED;
1279                 sk->sk_state_change(sk);
1280                 release_sock(sk);
1281         } else {
1282                 sco_conn_lock(conn);
1283
1284                 if (!conn->hcon) {
1285                         sco_conn_unlock(conn);
1286                         return;
1287                 }
1288
1289                 parent = sco_get_sock_listen(&conn->hcon->src);
1290                 if (!parent) {
1291                         sco_conn_unlock(conn);
1292                         return;
1293                 }
1294
1295                 lock_sock(parent);
1296
1297                 sk = sco_sock_alloc(sock_net(parent), NULL,
1298                                     BTPROTO_SCO, GFP_ATOMIC, 0);
1299                 if (!sk) {
1300                         release_sock(parent);
1301                         sco_conn_unlock(conn);
1302                         return;
1303                 }
1304
1305                 sco_sock_init(sk, parent);
1306
1307                 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1308                 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1309
1310                 hci_conn_hold(conn->hcon);
1311                 __sco_chan_add(conn, sk, parent);
1312
1313                 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1314                         sk->sk_state = BT_CONNECT2;
1315                 else
1316                         sk->sk_state = BT_CONNECTED;
1317
1318                 /* Wake up parent */
1319                 parent->sk_data_ready(parent);
1320
1321                 release_sock(parent);
1322
1323                 sco_conn_unlock(conn);
1324         }
1325 }
1326
1327 /* ----- SCO interface with lower layer (HCI) ----- */
1328 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1329 {
1330         struct sock *sk;
1331         int lm = 0;
1332
1333         BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1334
1335         /* Find listening sockets */
1336         read_lock(&sco_sk_list.lock);
1337         sk_for_each(sk, &sco_sk_list.head) {
1338                 if (sk->sk_state != BT_LISTEN)
1339                         continue;
1340
1341                 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1342                     !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1343                         lm |= HCI_LM_ACCEPT;
1344
1345                         if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1346                                 *flags |= HCI_PROTO_DEFER;
1347                         break;
1348                 }
1349         }
1350         read_unlock(&sco_sk_list.lock);
1351
1352         return lm;
1353 }
1354
1355 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1356 {
1357         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1358                 return;
1359
1360         BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);
1361
1362         if (!status) {
1363                 struct sco_conn *conn;
1364
1365                 conn = sco_conn_add(hcon);
1366                 if (conn)
1367                         sco_conn_ready(conn);
1368         } else
1369                 sco_conn_del(hcon, bt_to_errno(status));
1370 }
1371
1372 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1373 {
1374         if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1375                 return;
1376
1377         BT_DBG("hcon %p reason %d", hcon, reason);
1378
1379         sco_conn_del(hcon, bt_to_errno(reason));
1380 }
1381
1382 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1383 {
1384         struct sco_conn *conn = hcon->sco_data;
1385
1386         if (!conn)
1387                 goto drop;
1388
1389         BT_DBG("conn %p len %u", conn, skb->len);
1390
1391         if (skb->len) {
1392                 sco_recv_frame(conn, skb);
1393                 return;
1394         }
1395
1396 drop:
1397         kfree_skb(skb);
1398 }
1399
1400 static struct hci_cb sco_cb = {
1401         .name           = "SCO",
1402         .connect_cfm    = sco_connect_cfm,
1403         .disconn_cfm    = sco_disconn_cfm,
1404 };
1405
1406 static int sco_debugfs_show(struct seq_file *f, void *p)
1407 {
1408         struct sock *sk;
1409
1410         read_lock(&sco_sk_list.lock);
1411
1412         sk_for_each(sk, &sco_sk_list.head) {
1413                 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1414                            &sco_pi(sk)->dst, sk->sk_state);
1415         }
1416
1417         read_unlock(&sco_sk_list.lock);
1418
1419         return 0;
1420 }
1421
1422 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1423
1424 static struct dentry *sco_debugfs;
1425
1426 static const struct proto_ops sco_sock_ops = {
1427         .family         = PF_BLUETOOTH,
1428         .owner          = THIS_MODULE,
1429         .release        = sco_sock_release,
1430         .bind           = sco_sock_bind,
1431         .connect        = sco_sock_connect,
1432         .listen         = sco_sock_listen,
1433         .accept         = sco_sock_accept,
1434         .getname        = sco_sock_getname,
1435         .sendmsg        = sco_sock_sendmsg,
1436         .recvmsg        = sco_sock_recvmsg,
1437         .poll           = bt_sock_poll,
1438         .ioctl          = bt_sock_ioctl,
1439         .gettstamp      = sock_gettstamp,
1440         .mmap           = sock_no_mmap,
1441         .socketpair     = sock_no_socketpair,
1442         .shutdown       = sco_sock_shutdown,
1443         .setsockopt     = sco_sock_setsockopt,
1444         .getsockopt     = sco_sock_getsockopt
1445 };
1446
1447 static const struct net_proto_family sco_sock_family_ops = {
1448         .family = PF_BLUETOOTH,
1449         .owner  = THIS_MODULE,
1450         .create = sco_sock_create,
1451 };
1452
1453 int __init sco_init(void)
1454 {
1455         int err;
1456
1457         BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1458
1459         err = proto_register(&sco_proto, 0);
1460         if (err < 0)
1461                 return err;
1462
1463         err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1464         if (err < 0) {
1465                 BT_ERR("SCO socket registration failed");
1466                 goto error;
1467         }
1468
1469         err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1470         if (err < 0) {
1471                 BT_ERR("Failed to create SCO proc file");
1472                 bt_sock_unregister(BTPROTO_SCO);
1473                 goto error;
1474         }
1475
1476         BT_INFO("SCO socket layer initialized");
1477
1478         hci_register_cb(&sco_cb);
1479
1480         if (IS_ERR_OR_NULL(bt_debugfs))
1481                 return 0;
1482
1483         sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1484                                           NULL, &sco_debugfs_fops);
1485
1486         return 0;
1487
1488 error:
1489         proto_unregister(&sco_proto);
1490         return err;
1491 }
1492
1493 void sco_exit(void)
1494 {
1495         bt_procfs_cleanup(&init_net, "sco");
1496
1497         debugfs_remove(sco_debugfs);
1498
1499         hci_unregister_cb(&sco_cb);
1500
1501         bt_sock_unregister(BTPROTO_SCO);
1502
1503         proto_unregister(&sco_proto);
1504 }
1505
1506 module_param(disable_esco, bool, 0644);
1507 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");