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>
44 #include <linux/security.h>
47 #include <asm/system.h>
48 #include <linux/uaccess.h>
50 #include <net/bluetooth/bluetooth.h>
51 #include <net/bluetooth/hci_core.h>
52 #include <net/bluetooth/sco.h>
54 static int disable_esco;
56 static const struct proto_ops sco_sock_ops;
58 static struct bt_sock_list sco_sk_list = {
59 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
62 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
63 static void sco_chan_del(struct sock *sk, int err);
65 static int sco_conn_del(struct hci_conn *conn, int err);
67 static void sco_sock_close(struct sock *sk);
68 static void sco_sock_kill(struct sock *sk);
70 /* ---- SCO timers ---- */
71 static void sco_sock_timeout(unsigned long arg)
73 struct sock *sk = (struct sock *) arg;
75 BT_DBG("sock %p state %d", sk, sk->sk_state);
78 sk->sk_err = ETIMEDOUT;
79 sk->sk_state_change(sk);
86 static void sco_sock_set_timer(struct sock *sk, long timeout)
88 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
89 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
92 static void sco_sock_clear_timer(struct sock *sk)
94 BT_DBG("sock %p state %d", sk, sk->sk_state);
95 sk_stop_timer(sk, &sk->sk_timer);
98 /* ---- SCO connections ---- */
99 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
101 struct hci_dev *hdev = hcon->hdev;
102 struct sco_conn *conn = hcon->sco_data;
107 conn = kzalloc(sizeof(struct sco_conn), GFP_ATOMIC);
111 spin_lock_init(&conn->lock);
113 hcon->sco_data = conn;
116 conn->src = &hdev->bdaddr;
117 conn->dst = &hcon->dst;
119 if (hdev->sco_mtu > 0)
120 conn->mtu = hdev->sco_mtu;
124 BT_DBG("hcon %p conn %p", hcon, conn);
129 static inline struct sock *sco_chan_get(struct sco_conn *conn)
131 struct sock *sk = NULL;
134 sco_conn_unlock(conn);
138 static int sco_conn_del(struct hci_conn *hcon, int err)
140 struct sco_conn *conn = hcon->sco_data;
146 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
149 sk = sco_chan_get(conn);
152 sco_sock_clear_timer(sk);
153 sco_chan_del(sk, err);
158 hcon->sco_data = NULL;
163 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
171 __sco_chan_add(conn, sk, parent);
173 sco_conn_unlock(conn);
177 static int sco_connect(struct sock *sk)
179 bdaddr_t *src = &bt_sk(sk)->src;
180 bdaddr_t *dst = &bt_sk(sk)->dst;
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)
199 hcon = hci_connect(hdev, type, dst, BT_SECURITY_LOW, HCI_AT_NO_BONDING);
205 conn = sco_conn_add(hcon, 0);
212 /* Update source addr of the socket */
213 bacpy(src, conn->src);
215 err = sco_chan_add(conn, sk, NULL);
219 if (hcon->state == BT_CONNECTED) {
220 sco_sock_clear_timer(sk);
221 sk->sk_state = BT_CONNECTED;
223 sk->sk_state = BT_CONNECT;
224 sco_sock_set_timer(sk, sk->sk_sndtimeo);
228 hci_dev_unlock_bh(hdev);
233 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
235 struct sco_conn *conn = sco_pi(sk)->conn;
239 /* Check outgoing MTU */
243 BT_DBG("sk %p len %d", sk, len);
245 count = min_t(unsigned int, conn->mtu, len);
246 skb = bt_skb_send_alloc(sk, count,
247 msg->msg_flags & MSG_DONTWAIT, &err);
251 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
256 hci_send_sco(conn->hcon, skb);
261 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
263 struct sock *sk = sco_chan_get(conn);
268 BT_DBG("sk %p len %d", sk, skb->len);
270 if (sk->sk_state != BT_CONNECTED)
273 if (!sock_queue_rcv_skb(sk, skb))
280 /* -------- Socket interface ---------- */
281 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
284 struct hlist_node *node;
286 sk_for_each(sk, node, &sco_sk_list.head)
287 if (!bacmp(&bt_sk(sk)->src, ba))
294 /* Find socket listening on source bdaddr.
295 * Returns closest match.
297 static struct sock *sco_get_sock_listen(bdaddr_t *src)
299 struct sock *sk = NULL, *sk1 = NULL;
300 struct hlist_node *node;
302 read_lock(&sco_sk_list.lock);
304 sk_for_each(sk, node, &sco_sk_list.head) {
305 if (sk->sk_state != BT_LISTEN)
309 if (!bacmp(&bt_sk(sk)->src, src))
313 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
317 read_unlock(&sco_sk_list.lock);
319 return node ? sk : sk1;
322 static void sco_sock_destruct(struct sock *sk)
326 skb_queue_purge(&sk->sk_receive_queue);
327 skb_queue_purge(&sk->sk_write_queue);
330 static void sco_sock_cleanup_listen(struct sock *parent)
334 BT_DBG("parent %p", parent);
336 /* Close not yet accepted channels */
337 while ((sk = bt_accept_dequeue(parent, NULL))) {
342 parent->sk_state = BT_CLOSED;
343 sock_set_flag(parent, SOCK_ZAPPED);
346 /* Kill socket (only if zapped and orphan)
347 * Must be called on unlocked socket.
349 static void sco_sock_kill(struct sock *sk)
351 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
354 BT_DBG("sk %p state %d", sk, sk->sk_state);
356 /* Kill poor orphan */
357 bt_sock_unlink(&sco_sk_list, sk);
358 sock_set_flag(sk, SOCK_DEAD);
362 static void __sco_sock_close(struct sock *sk)
364 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
366 switch (sk->sk_state) {
368 sco_sock_cleanup_listen(sk);
373 if (sco_pi(sk)->conn) {
374 sk->sk_state = BT_DISCONN;
375 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
376 hci_conn_put(sco_pi(sk)->conn->hcon);
377 sco_pi(sk)->conn->hcon = NULL;
379 sco_chan_del(sk, ECONNRESET);
384 sco_chan_del(sk, ECONNRESET);
388 sock_set_flag(sk, SOCK_ZAPPED);
393 /* Must be called on unlocked socket. */
394 static void sco_sock_close(struct sock *sk)
396 sco_sock_clear_timer(sk);
398 __sco_sock_close(sk);
403 static void sco_sock_init(struct sock *sk, struct sock *parent)
408 sk->sk_type = parent->sk_type;
409 security_sk_clone(parent, sk);
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 addr_len)
468 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
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 if (addr_len < sizeof(struct sockaddr_sco))
483 if (sk->sk_state != BT_OPEN) {
488 write_lock_bh(&sco_sk_list.lock);
490 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
493 /* Save source address */
494 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
495 sk->sk_state = BT_BOUND;
498 write_unlock_bh(&sco_sk_list.lock);
505 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
507 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
508 struct sock *sk = sock->sk;
514 if (alen < sizeof(struct sockaddr_sco) ||
515 addr->sa_family != AF_BLUETOOTH)
518 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
521 if (sk->sk_type != SOCK_SEQPACKET)
526 /* Set destination address and psm */
527 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
529 err = sco_connect(sk);
533 err = bt_sock_wait_state(sk, BT_CONNECTED,
534 sock_sndtimeo(sk, flags & O_NONBLOCK));
541 static int sco_sock_listen(struct socket *sock, int backlog)
543 struct sock *sk = sock->sk;
546 BT_DBG("sk %p backlog %d", sk, backlog);
550 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
555 sk->sk_max_ack_backlog = backlog;
556 sk->sk_ack_backlog = 0;
557 sk->sk_state = BT_LISTEN;
564 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
566 DECLARE_WAITQUEUE(wait, current);
567 struct sock *sk = sock->sk, *ch;
573 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
575 BT_DBG("sk %p timeo %ld", sk, timeo);
577 /* Wait for an incoming connection. (wake-one). */
578 add_wait_queue_exclusive(sk_sleep(sk), &wait);
580 set_current_state(TASK_INTERRUPTIBLE);
582 if (sk->sk_state != BT_LISTEN) {
587 ch = bt_accept_dequeue(sk, newsock);
596 if (signal_pending(current)) {
597 err = sock_intr_errno(timeo);
602 timeo = schedule_timeout(timeo);
605 __set_current_state(TASK_RUNNING);
606 remove_wait_queue(sk_sleep(sk), &wait);
611 newsock->state = SS_CONNECTED;
613 BT_DBG("new socket %p", ch);
620 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
622 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
623 struct sock *sk = sock->sk;
625 BT_DBG("sock %p, sk %p", sock, sk);
627 addr->sa_family = AF_BLUETOOTH;
628 *len = sizeof(struct sockaddr_sco);
631 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
633 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
638 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
639 struct msghdr *msg, size_t len)
641 struct sock *sk = sock->sk;
644 BT_DBG("sock %p, sk %p", sock, sk);
646 err = sock_error(sk);
650 if (msg->msg_flags & MSG_OOB)
655 if (sk->sk_state == BT_CONNECTED)
656 err = sco_send_frame(sk, msg, len);
664 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
666 struct sock *sk = sock->sk;
683 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
685 struct sock *sk = sock->sk;
686 struct sco_options opts;
687 struct sco_conninfo cinfo;
692 if (get_user(len, optlen))
699 if (sk->sk_state != BT_CONNECTED) {
704 opts.mtu = sco_pi(sk)->conn->mtu;
706 BT_DBG("mtu %d", opts.mtu);
708 len = min_t(unsigned int, len, sizeof(opts));
709 if (copy_to_user(optval, (char *)&opts, len))
715 if (sk->sk_state != BT_CONNECTED) {
720 memset(&cinfo, 0, sizeof(cinfo));
721 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
722 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
724 len = min_t(unsigned int, len, sizeof(cinfo));
725 if (copy_to_user(optval, (char *)&cinfo, len))
739 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
741 struct sock *sk = sock->sk;
746 if (level == SOL_SCO)
747 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
749 if (get_user(len, optlen))
764 static int sco_sock_shutdown(struct socket *sock, int how)
766 struct sock *sk = sock->sk;
769 BT_DBG("sock %p, sk %p", sock, sk);
775 if (!sk->sk_shutdown) {
776 sk->sk_shutdown = SHUTDOWN_MASK;
777 sco_sock_clear_timer(sk);
778 __sco_sock_close(sk);
780 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
781 !(current->flags & PF_EXITING))
782 err = bt_sock_wait_state(sk, BT_CLOSED,
789 static int sco_sock_release(struct socket *sock)
791 struct sock *sk = sock->sk;
794 BT_DBG("sock %p, sk %p", sock, sk);
801 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
802 !(current->flags & PF_EXITING)) {
804 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
813 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
815 BT_DBG("conn %p", conn);
817 sco_pi(sk)->conn = conn;
821 bt_accept_enqueue(parent, sk);
825 * Must be called on the locked socket. */
826 static void sco_chan_del(struct sock *sk, int err)
828 struct sco_conn *conn;
830 conn = sco_pi(sk)->conn;
832 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
837 sco_pi(sk)->conn = NULL;
838 sco_conn_unlock(conn);
841 hci_conn_put(conn->hcon);
844 sk->sk_state = BT_CLOSED;
846 sk->sk_state_change(sk);
848 sock_set_flag(sk, SOCK_ZAPPED);
851 static void sco_conn_ready(struct sco_conn *conn)
854 struct sock *sk = conn->sk;
856 BT_DBG("conn %p", conn);
861 sco_sock_clear_timer(sk);
863 sk->sk_state = BT_CONNECTED;
864 sk->sk_state_change(sk);
867 parent = sco_get_sock_listen(conn->src);
871 bh_lock_sock(parent);
873 sk = sco_sock_alloc(sock_net(parent), NULL,
874 BTPROTO_SCO, GFP_ATOMIC);
876 bh_unlock_sock(parent);
880 sco_sock_init(sk, parent);
882 bacpy(&bt_sk(sk)->src, conn->src);
883 bacpy(&bt_sk(sk)->dst, conn->dst);
885 hci_conn_hold(conn->hcon);
886 __sco_chan_add(conn, sk, parent);
888 sk->sk_state = BT_CONNECTED;
891 parent->sk_data_ready(parent, 1);
893 bh_unlock_sock(parent);
897 sco_conn_unlock(conn);
900 /* ----- SCO interface with lower layer (HCI) ----- */
901 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
903 register struct sock *sk;
904 struct hlist_node *node;
907 if (type != SCO_LINK && type != ESCO_LINK)
910 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
912 /* Find listening sockets */
913 read_lock(&sco_sk_list.lock);
914 sk_for_each(sk, node, &sco_sk_list.head) {
915 if (sk->sk_state != BT_LISTEN)
918 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
919 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
924 read_unlock(&sco_sk_list.lock);
929 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
931 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
933 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
937 struct sco_conn *conn;
939 conn = sco_conn_add(hcon, status);
941 sco_conn_ready(conn);
943 sco_conn_del(hcon, bt_to_errno(status));
948 static int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
950 BT_DBG("hcon %p reason %d", hcon, reason);
952 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
955 sco_conn_del(hcon, bt_to_errno(reason));
960 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
962 struct sco_conn *conn = hcon->sco_data;
967 BT_DBG("conn %p len %d", conn, skb->len);
970 sco_recv_frame(conn, skb);
979 static int sco_debugfs_show(struct seq_file *f, void *p)
982 struct hlist_node *node;
984 read_lock_bh(&sco_sk_list.lock);
986 sk_for_each(sk, node, &sco_sk_list.head) {
987 seq_printf(f, "%s %s %d\n", batostr(&bt_sk(sk)->src),
988 batostr(&bt_sk(sk)->dst), sk->sk_state);
991 read_unlock_bh(&sco_sk_list.lock);
996 static int sco_debugfs_open(struct inode *inode, struct file *file)
998 return single_open(file, sco_debugfs_show, inode->i_private);
1001 static const struct file_operations sco_debugfs_fops = {
1002 .open = sco_debugfs_open,
1004 .llseek = seq_lseek,
1005 .release = single_release,
1008 static struct dentry *sco_debugfs;
1010 static const struct proto_ops sco_sock_ops = {
1011 .family = PF_BLUETOOTH,
1012 .owner = THIS_MODULE,
1013 .release = sco_sock_release,
1014 .bind = sco_sock_bind,
1015 .connect = sco_sock_connect,
1016 .listen = sco_sock_listen,
1017 .accept = sco_sock_accept,
1018 .getname = sco_sock_getname,
1019 .sendmsg = sco_sock_sendmsg,
1020 .recvmsg = bt_sock_recvmsg,
1021 .poll = bt_sock_poll,
1022 .ioctl = bt_sock_ioctl,
1023 .mmap = sock_no_mmap,
1024 .socketpair = sock_no_socketpair,
1025 .shutdown = sco_sock_shutdown,
1026 .setsockopt = sco_sock_setsockopt,
1027 .getsockopt = sco_sock_getsockopt
1030 static const struct net_proto_family sco_sock_family_ops = {
1031 .family = PF_BLUETOOTH,
1032 .owner = THIS_MODULE,
1033 .create = sco_sock_create,
1036 static struct hci_proto sco_hci_proto = {
1038 .id = HCI_PROTO_SCO,
1039 .connect_ind = sco_connect_ind,
1040 .connect_cfm = sco_connect_cfm,
1041 .disconn_cfm = sco_disconn_cfm,
1042 .recv_scodata = sco_recv_scodata
1045 int __init sco_init(void)
1049 err = proto_register(&sco_proto, 0);
1053 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1055 BT_ERR("SCO socket registration failed");
1059 err = hci_register_proto(&sco_hci_proto);
1061 BT_ERR("SCO protocol registration failed");
1062 bt_sock_unregister(BTPROTO_SCO);
1067 sco_debugfs = debugfs_create_file("sco", 0444,
1068 bt_debugfs, NULL, &sco_debugfs_fops);
1070 BT_ERR("Failed to create SCO debug file");
1073 BT_INFO("SCO socket layer initialized");
1078 proto_unregister(&sco_proto);
1082 void __exit sco_exit(void)
1084 debugfs_remove(sco_debugfs);
1086 if (bt_sock_unregister(BTPROTO_SCO) < 0)
1087 BT_ERR("SCO socket unregistration failed");
1089 if (hci_unregister_proto(&sco_hci_proto) < 0)
1090 BT_ERR("SCO protocol unregistration failed");
1092 proto_unregister(&sco_proto);
1095 module_param(disable_esco, bool, 0644);
1096 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");