2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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.
25 /* Bluetooth SCO sockets. */
27 #include <linux/module.h>
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/kernel.h>
32 #include <linux/sched.h>
33 #include <linux/slab.h>
34 #include <linux/poll.h>
35 #include <linux/fcntl.h>
36 #include <linux/init.h>
37 #include <linux/interrupt.h>
38 #include <linux/socket.h>
39 #include <linux/skbuff.h>
40 #include <linux/device.h>
41 #include <linux/debugfs.h>
42 #include <linux/seq_file.h>
43 #include <linux/list.h>
46 #include <asm/system.h>
47 #include <linux/uaccess.h>
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
51 #include <net/bluetooth/sco.h>
53 static int disable_esco;
55 static const struct proto_ops sco_sock_ops;
57 static struct bt_sock_list sco_sk_list = {
58 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
61 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
62 static void sco_chan_del(struct sock *sk, int err);
64 static int sco_conn_del(struct hci_conn *conn, int err);
66 static void sco_sock_close(struct sock *sk);
67 static void sco_sock_kill(struct sock *sk);
69 /* ---- SCO timers ---- */
70 static void sco_sock_timeout(unsigned long arg)
72 struct sock *sk = (struct sock *) arg;
74 BT_DBG("sock %p state %d", sk, sk->sk_state);
77 sk->sk_err = ETIMEDOUT;
78 sk->sk_state_change(sk);
85 static void sco_sock_set_timer(struct sock *sk, long timeout)
87 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
88 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
91 static void sco_sock_clear_timer(struct sock *sk)
93 BT_DBG("sock %p state %d", sk, sk->sk_state);
94 sk_stop_timer(sk, &sk->sk_timer);
97 /* ---- SCO connections ---- */
98 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
100 struct hci_dev *hdev = hcon->hdev;
101 struct sco_conn *conn = hcon->sco_data;
106 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
110 spin_lock_init(&conn->lock);
112 hcon->sco_data = conn;
115 conn->src = &hdev->bdaddr;
116 conn->dst = &hcon->dst;
118 if (hdev->sco_mtu > 0)
119 conn->mtu = hdev->sco_mtu;
123 BT_DBG("hcon %p conn %p", hcon, conn);
128 static inline struct sock *sco_chan_get(struct sco_conn *conn)
130 struct sock *sk = NULL;
133 sco_conn_unlock(conn);
137 static int sco_conn_del(struct hci_conn *hcon, int err)
139 struct sco_conn *conn = hcon->sco_data;
145 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
148 sk = sco_chan_get(conn);
151 sco_sock_clear_timer(sk);
152 sco_chan_del(sk, err);
157 hcon->sco_data = NULL;
162 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
170 __sco_chan_add(conn, sk, parent);
172 sco_conn_unlock(conn);
176 static int sco_connect(struct sock *sk)
178 bdaddr_t *src = &bt_sk(sk)->src;
179 bdaddr_t *dst = &bt_sk(sk)->dst;
180 __u16 pkt_type = sco_pi(sk)->pkt_type;
181 struct sco_conn *conn;
182 struct hci_conn *hcon;
183 struct hci_dev *hdev;
186 BT_DBG("%s -> %s", batostr(src), batostr(dst));
188 hdev = hci_get_route(dst, src);
190 return -EHOSTUNREACH;
192 hci_dev_lock_bh(hdev);
194 if (lmp_esco_capable(hdev) && !disable_esco)
198 pkt_type &= SCO_ESCO_MASK;
201 hcon = hci_connect(hdev, type, pkt_type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
207 conn = sco_conn_add(hcon, 0);
214 /* Update source addr of the socket */
215 bacpy(src, conn->src);
217 err = sco_chan_add(conn, sk, NULL);
221 if (hcon->state == BT_CONNECTED) {
222 sco_sock_clear_timer(sk);
223 sk->sk_state = BT_CONNECTED;
225 sk->sk_state = BT_CONNECT;
226 sco_sock_set_timer(sk, sk->sk_sndtimeo);
230 hci_dev_unlock_bh(hdev);
235 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
237 struct sco_conn *conn = sco_pi(sk)->conn;
241 /* Check outgoing MTU */
245 BT_DBG("sk %p len %d", sk, len);
247 count = min_t(unsigned int, conn->mtu, len);
248 skb = bt_skb_send_alloc(sk, count,
249 msg->msg_flags & MSG_DONTWAIT, &err);
253 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
258 hci_send_sco(conn->hcon, skb);
263 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
265 struct sock *sk = sco_chan_get(conn);
270 BT_DBG("sk %p len %d", sk, skb->len);
272 if (sk->sk_state != BT_CONNECTED)
275 if (!sock_queue_rcv_skb(sk, skb))
282 /* -------- Socket interface ---------- */
283 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
286 struct hlist_node *node;
288 sk_for_each(sk, node, &sco_sk_list.head)
289 if (!bacmp(&bt_sk(sk)->src, ba))
296 /* Find socket listening on source bdaddr.
297 * Returns closest match.
299 static struct sock *sco_get_sock_listen(bdaddr_t *src)
301 struct sock *sk = NULL, *sk1 = NULL;
302 struct hlist_node *node;
304 read_lock(&sco_sk_list.lock);
306 sk_for_each(sk, node, &sco_sk_list.head) {
307 if (sk->sk_state != BT_LISTEN)
311 if (!bacmp(&bt_sk(sk)->src, src))
315 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
319 read_unlock(&sco_sk_list.lock);
321 return node ? sk : sk1;
324 static void sco_sock_destruct(struct sock *sk)
328 skb_queue_purge(&sk->sk_receive_queue);
329 skb_queue_purge(&sk->sk_write_queue);
332 static void sco_sock_cleanup_listen(struct sock *parent)
336 BT_DBG("parent %p", parent);
338 /* Close not yet accepted channels */
339 while ((sk = bt_accept_dequeue(parent, NULL))) {
344 parent->sk_state = BT_CLOSED;
345 sock_set_flag(parent, SOCK_ZAPPED);
348 /* Kill socket (only if zapped and orphan)
349 * Must be called on unlocked socket.
351 static void sco_sock_kill(struct sock *sk)
353 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
356 BT_DBG("sk %p state %d", sk, sk->sk_state);
358 /* Kill poor orphan */
359 bt_sock_unlink(&sco_sk_list, sk);
360 sock_set_flag(sk, SOCK_DEAD);
364 static void __sco_sock_close(struct sock *sk)
366 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
368 switch (sk->sk_state) {
370 sco_sock_cleanup_listen(sk);
375 if (sco_pi(sk)->conn) {
376 sk->sk_state = BT_DISCONN;
377 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
378 hci_conn_put(sco_pi(sk)->conn->hcon);
379 sco_pi(sk)->conn->hcon = NULL;
381 sco_chan_del(sk, ECONNRESET);
386 sco_chan_del(sk, ECONNRESET);
390 sock_set_flag(sk, SOCK_ZAPPED);
395 /* Must be called on unlocked socket. */
396 static void sco_sock_close(struct sock *sk)
398 sco_sock_clear_timer(sk);
400 __sco_sock_close(sk);
405 static void sco_sock_init(struct sock *sk, struct sock *parent)
410 sk->sk_type = parent->sk_type;
413 static struct proto sco_proto = {
415 .owner = THIS_MODULE,
416 .obj_size = sizeof(struct sco_pinfo)
419 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
423 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
427 sock_init_data(sock, sk);
428 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
430 sk->sk_destruct = sco_sock_destruct;
431 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
433 sock_reset_flag(sk, SOCK_ZAPPED);
435 sk->sk_protocol = proto;
436 sk->sk_state = BT_OPEN;
438 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
440 bt_sock_link(&sco_sk_list, sk);
444 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
449 BT_DBG("sock %p", sock);
451 sock->state = SS_UNCONNECTED;
453 if (sock->type != SOCK_SEQPACKET)
454 return -ESOCKTNOSUPPORT;
456 sock->ops = &sco_sock_ops;
458 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
462 sco_sock_init(sk, NULL);
466 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
468 struct sockaddr_sco sa;
469 struct sock *sk = sock->sk;
470 bdaddr_t *src = &sa.sco_bdaddr;
473 BT_DBG("sk %p %s", sk, batostr(&sa.sco_bdaddr));
475 if (!addr || addr->sa_family != AF_BLUETOOTH)
478 memset(&sa, 0, sizeof(sa));
479 len = min_t(unsigned int, sizeof(sa), alen);
480 memcpy(&sa, addr, len);
484 if (sk->sk_state != BT_OPEN) {
489 write_lock_bh(&sco_sk_list.lock);
491 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
494 /* Save source address */
495 bacpy(&bt_sk(sk)->src, &sa.sco_bdaddr);
496 sco_pi(sk)->pkt_type = sa.sco_pkt_type;
497 sk->sk_state = BT_BOUND;
500 write_unlock_bh(&sco_sk_list.lock);
507 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
509 struct sock *sk = sock->sk;
510 struct sockaddr_sco sa;
515 if (!addr || addr->sa_family != AF_BLUETOOTH)
518 memset(&sa, 0, sizeof(sa));
519 len = min_t(unsigned int, sizeof(sa), alen);
520 memcpy(&sa, addr, len);
524 if (sk->sk_type != SOCK_SEQPACKET) {
529 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
534 /* Set destination address and psm */
535 bacpy(&bt_sk(sk)->dst, &sa.sco_bdaddr);
536 sco_pi(sk)->pkt_type = sa.sco_pkt_type;
538 err = sco_connect(sk);
542 err = bt_sock_wait_state(sk, BT_CONNECTED,
543 sock_sndtimeo(sk, flags & O_NONBLOCK));
550 static int sco_sock_listen(struct socket *sock, int backlog)
552 struct sock *sk = sock->sk;
555 BT_DBG("sk %p backlog %d", sk, backlog);
559 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
564 sk->sk_max_ack_backlog = backlog;
565 sk->sk_ack_backlog = 0;
566 sk->sk_state = BT_LISTEN;
573 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
575 DECLARE_WAITQUEUE(wait, current);
576 struct sock *sk = sock->sk, *ch;
582 if (sk->sk_state != BT_LISTEN) {
587 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
589 BT_DBG("sk %p timeo %ld", sk, timeo);
591 /* Wait for an incoming connection. (wake-one). */
592 add_wait_queue_exclusive(sk_sleep(sk), &wait);
593 while (!(ch = bt_accept_dequeue(sk, newsock))) {
594 set_current_state(TASK_INTERRUPTIBLE);
601 timeo = schedule_timeout(timeo);
604 if (sk->sk_state != BT_LISTEN) {
609 if (signal_pending(current)) {
610 err = sock_intr_errno(timeo);
614 set_current_state(TASK_RUNNING);
615 remove_wait_queue(sk_sleep(sk), &wait);
620 newsock->state = SS_CONNECTED;
622 BT_DBG("new socket %p", ch);
629 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
631 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
632 struct sock *sk = sock->sk;
634 BT_DBG("sock %p, sk %p", sock, sk);
636 addr->sa_family = AF_BLUETOOTH;
637 *len = sizeof(struct sockaddr_sco);
640 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
642 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
643 sa->sco_pkt_type = sco_pi(sk)->pkt_type;
648 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
649 struct msghdr *msg, size_t len)
651 struct sock *sk = sock->sk;
654 BT_DBG("sock %p, sk %p", sock, sk);
656 err = sock_error(sk);
660 if (msg->msg_flags & MSG_OOB)
665 if (sk->sk_state == BT_CONNECTED)
666 err = sco_send_frame(sk, msg, len);
674 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
676 struct sock *sk = sock->sk;
693 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
695 struct sock *sk = sock->sk;
696 struct sco_options opts;
697 struct sco_conninfo cinfo;
702 if (get_user(len, optlen))
709 if (sk->sk_state != BT_CONNECTED) {
714 opts.mtu = sco_pi(sk)->conn->mtu;
716 BT_DBG("mtu %d", opts.mtu);
718 len = min_t(unsigned int, len, sizeof(opts));
719 if (copy_to_user(optval, (char *)&opts, len))
725 if (sk->sk_state != BT_CONNECTED) {
730 memset(&cinfo, 0, sizeof(cinfo));
731 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
732 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
734 len = min_t(unsigned int, len, sizeof(cinfo));
735 if (copy_to_user(optval, (char *)&cinfo, len))
749 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
751 struct sock *sk = sock->sk;
756 if (level == SOL_SCO)
757 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
759 if (get_user(len, optlen))
774 static int sco_sock_shutdown(struct socket *sock, int how)
776 struct sock *sk = sock->sk;
779 BT_DBG("sock %p, sk %p", sock, sk);
785 if (!sk->sk_shutdown) {
786 sk->sk_shutdown = SHUTDOWN_MASK;
787 sco_sock_clear_timer(sk);
788 __sco_sock_close(sk);
790 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
791 err = bt_sock_wait_state(sk, BT_CLOSED,
798 static int sco_sock_release(struct socket *sock)
800 struct sock *sk = sock->sk;
803 BT_DBG("sock %p, sk %p", sock, sk);
810 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
812 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
821 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
823 BT_DBG("conn %p", conn);
825 sco_pi(sk)->conn = conn;
829 bt_accept_enqueue(parent, sk);
833 * Must be called on the locked socket. */
834 static void sco_chan_del(struct sock *sk, int err)
836 struct sco_conn *conn;
838 conn = sco_pi(sk)->conn;
840 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
845 sco_pi(sk)->conn = NULL;
846 sco_conn_unlock(conn);
849 hci_conn_put(conn->hcon);
852 sk->sk_state = BT_CLOSED;
854 sk->sk_state_change(sk);
856 sock_set_flag(sk, SOCK_ZAPPED);
859 static void sco_conn_ready(struct sco_conn *conn)
862 struct sock *sk = conn->sk;
864 BT_DBG("conn %p", conn);
869 sco_sock_clear_timer(sk);
871 sk->sk_state = BT_CONNECTED;
872 sk->sk_state_change(sk);
875 parent = sco_get_sock_listen(conn->src);
879 bh_lock_sock(parent);
881 sk = sco_sock_alloc(sock_net(parent), NULL,
882 BTPROTO_SCO, GFP_ATOMIC);
884 bh_unlock_sock(parent);
888 sco_sock_init(sk, parent);
890 bacpy(&bt_sk(sk)->src, conn->src);
891 bacpy(&bt_sk(sk)->dst, conn->dst);
893 hci_conn_hold(conn->hcon);
894 __sco_chan_add(conn, sk, parent);
896 sk->sk_state = BT_CONNECTED;
899 parent->sk_data_ready(parent, 1);
901 bh_unlock_sock(parent);
905 sco_conn_unlock(conn);
908 /* ----- SCO interface with lower layer (HCI) ----- */
909 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
911 register struct sock *sk;
912 struct hlist_node *node;
915 if (type != SCO_LINK && type != ESCO_LINK)
918 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
920 /* Find listening sockets */
921 read_lock(&sco_sk_list.lock);
922 sk_for_each(sk, node, &sco_sk_list.head) {
923 if (sk->sk_state != BT_LISTEN)
926 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
927 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
932 read_unlock(&sco_sk_list.lock);
937 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
939 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
941 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
945 struct sco_conn *conn;
947 conn = sco_conn_add(hcon, status);
949 sco_conn_ready(conn);
951 sco_conn_del(hcon, bt_err(status));
956 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
958 BT_DBG("hcon %p reason %d", hcon, reason);
960 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
963 sco_conn_del(hcon, bt_err(reason));
968 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
970 struct sco_conn *conn = hcon->sco_data;
975 BT_DBG("conn %p len %d", conn, skb->len);
978 sco_recv_frame(conn, skb);
987 static int sco_debugfs_show(struct seq_file *f, void *p)
990 struct hlist_node *node;
992 read_lock_bh(&sco_sk_list.lock);
994 sk_for_each(sk, node, &sco_sk_list.head) {
995 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
996 batostr(&bt_sk(sk)->dst), sk->sk_state);
999 read_unlock_bh(&sco_sk_list.lock);
1004 static int sco_debugfs_open(struct inode *inode, struct file *file)
1006 return single_open(file, sco_debugfs_show, inode->i_private);
1009 static const struct file_operations sco_debugfs_fops = {
1010 .open = sco_debugfs_open,
1012 .llseek = seq_lseek,
1013 .release = single_release,
1016 static struct dentry *sco_debugfs;
1018 static const struct proto_ops sco_sock_ops = {
1019 .family = PF_BLUETOOTH,
1020 .owner = THIS_MODULE,
1021 .release = sco_sock_release,
1022 .bind = sco_sock_bind,
1023 .connect = sco_sock_connect,
1024 .listen = sco_sock_listen,
1025 .accept = sco_sock_accept,
1026 .getname = sco_sock_getname,
1027 .sendmsg = sco_sock_sendmsg,
1028 .recvmsg = bt_sock_recvmsg,
1029 .poll = bt_sock_poll,
1030 .ioctl = bt_sock_ioctl,
1031 .mmap = sock_no_mmap,
1032 .socketpair = sock_no_socketpair,
1033 .shutdown = sco_sock_shutdown,
1034 .setsockopt = sco_sock_setsockopt,
1035 .getsockopt = sco_sock_getsockopt
1038 static const struct net_proto_family sco_sock_family_ops = {
1039 .family = PF_BLUETOOTH,
1040 .owner = THIS_MODULE,
1041 .create = sco_sock_create,
1044 static struct hci_proto sco_hci_proto = {
1046 .id = HCI_PROTO_SCO,
1047 .connect_ind = sco_connect_ind,
1048 .connect_cfm = sco_connect_cfm,
1049 .disconn_cfm = sco_disconn_cfm,
1050 .recv_scodata = sco_recv_scodata
1053 int __init sco_init(void)
1057 err = proto_register(&sco_proto, 0);
1061 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1063 BT_ERR("SCO socket registration failed");
1067 err = hci_register_proto(&sco_hci_proto);
1069 BT_ERR("SCO protocol registration failed");
1070 bt_sock_unregister(BTPROTO_SCO);
1075 sco_debugfs = debugfs_create_file("sco", 0444,
1076 bt_debugfs, NULL, &sco_debugfs_fops);
1078 BT_ERR("Failed to create SCO debug file");
1081 BT_INFO("SCO socket layer initialized");
1086 proto_unregister(&sco_proto);
1090 void __exit sco_exit(void)
1092 debugfs_remove(sco_debugfs);
1094 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1095 BT_ERR("SCO socket unregistration failed");
1097 if (hci_unregister_proto(&sco_hci_proto) < 0)
1098 BT_ERR("SCO protocol unregistration failed");
1100 proto_unregister(&sco_proto);
1103 module_param(disable_esco, bool, 0644);
1104 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");