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>
28 #include <linux/debugfs.h>
29 #include <linux/seq_file.h>
30 #include <linux/sched/signal.h>
32 #include <net/bluetooth/bluetooth.h>
33 #include <net/bluetooth/hci_core.h>
34 #include <net/bluetooth/sco.h>
36 static bool disable_esco;
38 static const struct proto_ops sco_sock_ops;
40 static struct bt_sock_list sco_sk_list = {
41 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
44 /* ---- SCO connections ---- */
46 struct hci_conn *hcon;
51 struct delayed_work timeout_work;
56 #define sco_conn_lock(c) spin_lock(&c->lock)
57 #define sco_conn_unlock(c) spin_unlock(&c->lock)
59 static void sco_sock_close(struct sock *sk);
60 static void sco_sock_kill(struct sock *sk);
62 /* ----- SCO socket info ----- */
63 #define sco_pi(sk) ((struct sco_pinfo *) sk)
71 struct bt_codec codec;
72 struct sco_conn *conn;
75 /* ---- SCO timers ---- */
76 #define SCO_CONN_TIMEOUT (HZ * 40)
77 #define SCO_DISCONN_TIMEOUT (HZ * 2)
79 static void sco_sock_timeout(struct work_struct *work)
81 struct sco_conn *conn = container_of(work, struct sco_conn,
87 sco_conn_unlock(conn);
93 sco_conn_unlock(conn);
98 BT_DBG("sock %p state %d", sk, sk->sk_state);
101 sk->sk_err = ETIMEDOUT;
102 sk->sk_state_change(sk);
107 static void sco_sock_set_timer(struct sock *sk, long timeout)
109 if (!sco_pi(sk)->conn)
112 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
113 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
114 schedule_delayed_work(&sco_pi(sk)->conn->timeout_work, timeout);
117 static void sco_sock_clear_timer(struct sock *sk)
119 if (!sco_pi(sk)->conn)
122 BT_DBG("sock %p state %d", sk, sk->sk_state);
123 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
126 /* ---- SCO connections ---- */
127 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
129 struct sco_conn *conn = hcon->sco_data;
137 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
141 spin_lock_init(&conn->lock);
142 INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
144 hcon->sco_data = conn;
146 conn->mtu = hcon->mtu;
149 conn->mtu = hcon->mtu;
153 BT_DBG("hcon %p conn %p", hcon, conn);
159 * Must be called on the locked socket. */
160 static void sco_chan_del(struct sock *sk, int err)
162 struct sco_conn *conn;
164 conn = sco_pi(sk)->conn;
166 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
171 sco_pi(sk)->conn = NULL;
172 sco_conn_unlock(conn);
175 hci_conn_drop(conn->hcon);
178 sk->sk_state = BT_CLOSED;
180 sk->sk_state_change(sk);
182 sock_set_flag(sk, SOCK_ZAPPED);
185 static void sco_conn_del(struct hci_conn *hcon, int err)
187 struct sco_conn *conn = hcon->sco_data;
193 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
200 sco_conn_unlock(conn);
204 sco_sock_clear_timer(sk);
205 sco_chan_del(sk, err);
210 /* Ensure no more work items will run before freeing conn. */
211 cancel_delayed_work_sync(&conn->timeout_work);
213 hcon->sco_data = NULL;
217 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
220 BT_DBG("conn %p", conn);
222 sco_pi(sk)->conn = conn;
226 bt_accept_enqueue(parent, sk, true);
229 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
238 __sco_chan_add(conn, sk, parent);
240 sco_conn_unlock(conn);
244 static int sco_connect(struct sock *sk)
246 struct sco_conn *conn;
247 struct hci_conn *hcon;
248 struct hci_dev *hdev;
251 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
253 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
255 return -EHOSTUNREACH;
259 if (lmp_esco_capable(hdev) && !disable_esco)
264 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
265 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
270 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
271 sco_pi(sk)->setting, &sco_pi(sk)->codec,
278 conn = sco_conn_add(hcon);
287 err = sco_chan_add(conn, sk, NULL);
293 /* Update source addr of the socket */
294 bacpy(&sco_pi(sk)->src, &hcon->src);
296 if (hcon->state == BT_CONNECTED) {
297 sco_sock_clear_timer(sk);
298 sk->sk_state = BT_CONNECTED;
300 sk->sk_state = BT_CONNECT;
301 sco_sock_set_timer(sk, sk->sk_sndtimeo);
307 hci_dev_unlock(hdev);
312 static int sco_send_frame(struct sock *sk, struct sk_buff *skb)
314 struct sco_conn *conn = sco_pi(sk)->conn;
317 /* Check outgoing MTU */
321 BT_DBG("sk %p len %d", sk, len);
323 hci_send_sco(conn->hcon, skb);
328 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
334 sco_conn_unlock(conn);
339 BT_DBG("sk %p len %u", sk, skb->len);
341 if (sk->sk_state != BT_CONNECTED)
344 if (!sock_queue_rcv_skb(sk, skb))
351 /* -------- Socket interface ---------- */
352 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
356 sk_for_each(sk, &sco_sk_list.head) {
357 if (sk->sk_state != BT_LISTEN)
360 if (!bacmp(&sco_pi(sk)->src, ba))
367 /* Find socket listening on source bdaddr.
368 * Returns closest match.
370 static struct sock *sco_get_sock_listen(bdaddr_t *src)
372 struct sock *sk = NULL, *sk1 = NULL;
374 read_lock(&sco_sk_list.lock);
376 sk_for_each(sk, &sco_sk_list.head) {
377 if (sk->sk_state != BT_LISTEN)
381 if (!bacmp(&sco_pi(sk)->src, src))
385 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
389 read_unlock(&sco_sk_list.lock);
391 return sk ? sk : sk1;
394 static void sco_sock_destruct(struct sock *sk)
398 skb_queue_purge(&sk->sk_receive_queue);
399 skb_queue_purge(&sk->sk_write_queue);
402 static void sco_sock_cleanup_listen(struct sock *parent)
406 BT_DBG("parent %p", parent);
408 /* Close not yet accepted channels */
409 while ((sk = bt_accept_dequeue(parent, NULL))) {
414 parent->sk_state = BT_CLOSED;
415 sock_set_flag(parent, SOCK_ZAPPED);
418 /* Kill socket (only if zapped and orphan)
419 * Must be called on unlocked socket.
421 static void sco_sock_kill(struct sock *sk)
423 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
426 BT_DBG("sk %p state %d", sk, sk->sk_state);
428 /* Kill poor orphan */
429 bt_sock_unlink(&sco_sk_list, sk);
430 sock_set_flag(sk, SOCK_DEAD);
434 static void __sco_sock_close(struct sock *sk)
436 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
438 switch (sk->sk_state) {
440 sco_sock_cleanup_listen(sk);
445 if (sco_pi(sk)->conn->hcon) {
446 sk->sk_state = BT_DISCONN;
447 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
448 sco_conn_lock(sco_pi(sk)->conn);
449 hci_conn_drop(sco_pi(sk)->conn->hcon);
450 sco_pi(sk)->conn->hcon = NULL;
451 sco_conn_unlock(sco_pi(sk)->conn);
453 sco_chan_del(sk, ECONNRESET);
459 sco_chan_del(sk, ECONNRESET);
463 sock_set_flag(sk, SOCK_ZAPPED);
469 /* Must be called on unlocked socket. */
470 static void sco_sock_close(struct sock *sk)
473 sco_sock_clear_timer(sk);
474 __sco_sock_close(sk);
478 static void sco_sock_init(struct sock *sk, struct sock *parent)
483 sk->sk_type = parent->sk_type;
484 bt_sk(sk)->flags = bt_sk(parent)->flags;
485 security_sk_clone(parent, sk);
489 static struct proto sco_proto = {
491 .owner = THIS_MODULE,
492 .obj_size = sizeof(struct sco_pinfo)
495 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
496 int proto, gfp_t prio, int kern)
500 sk = bt_sock_alloc(net, sock, &sco_proto, proto, prio, kern);
504 sk->sk_destruct = sco_sock_destruct;
505 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
507 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
508 sco_pi(sk)->codec.id = BT_CODEC_CVSD;
509 sco_pi(sk)->codec.cid = 0xffff;
510 sco_pi(sk)->codec.vid = 0xffff;
511 sco_pi(sk)->codec.data_path = 0x00;
513 bt_sock_link(&sco_sk_list, sk);
517 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
522 BT_DBG("sock %p", sock);
524 sock->state = SS_UNCONNECTED;
526 if (sock->type != SOCK_SEQPACKET)
527 return -ESOCKTNOSUPPORT;
529 sock->ops = &sco_sock_ops;
531 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
535 sco_sock_init(sk, NULL);
539 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
542 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
543 struct sock *sk = sock->sk;
546 if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
547 addr->sa_family != AF_BLUETOOTH)
550 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
554 if (sk->sk_state != BT_OPEN) {
559 if (sk->sk_type != SOCK_SEQPACKET) {
564 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
566 sk->sk_state = BT_BOUND;
573 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
575 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
576 struct sock *sk = sock->sk;
581 if (alen < sizeof(struct sockaddr_sco) ||
582 addr->sa_family != AF_BLUETOOTH)
585 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
588 if (sk->sk_type != SOCK_SEQPACKET)
592 /* Set destination address and psm */
593 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
596 err = sco_connect(sk);
602 err = bt_sock_wait_state(sk, BT_CONNECTED,
603 sock_sndtimeo(sk, flags & O_NONBLOCK));
609 static int sco_sock_listen(struct socket *sock, int backlog)
611 struct sock *sk = sock->sk;
612 bdaddr_t *src = &sco_pi(sk)->src;
615 BT_DBG("sk %p backlog %d", sk, backlog);
619 if (sk->sk_state != BT_BOUND) {
624 if (sk->sk_type != SOCK_SEQPACKET) {
629 write_lock(&sco_sk_list.lock);
631 if (__sco_get_sock_listen_by_addr(src)) {
636 sk->sk_max_ack_backlog = backlog;
637 sk->sk_ack_backlog = 0;
639 sk->sk_state = BT_LISTEN;
642 write_unlock(&sco_sk_list.lock);
649 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
650 struct proto_accept_arg *arg)
652 DEFINE_WAIT_FUNC(wait, woken_wake_function);
653 struct sock *sk = sock->sk, *ch;
659 timeo = sock_rcvtimeo(sk, arg->flags & O_NONBLOCK);
661 BT_DBG("sk %p timeo %ld", sk, timeo);
663 /* Wait for an incoming connection. (wake-one). */
664 add_wait_queue_exclusive(sk_sleep(sk), &wait);
666 if (sk->sk_state != BT_LISTEN) {
671 ch = bt_accept_dequeue(sk, newsock);
680 if (signal_pending(current)) {
681 err = sock_intr_errno(timeo);
687 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
690 remove_wait_queue(sk_sleep(sk), &wait);
695 newsock->state = SS_CONNECTED;
697 BT_DBG("new socket %p", ch);
704 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
707 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
708 struct sock *sk = sock->sk;
710 BT_DBG("sock %p, sk %p", sock, sk);
712 addr->sa_family = AF_BLUETOOTH;
715 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
717 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
719 return sizeof(struct sockaddr_sco);
722 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
725 struct sock *sk = sock->sk;
729 BT_DBG("sock %p, sk %p", sock, sk);
731 err = sock_error(sk);
735 if (msg->msg_flags & MSG_OOB)
738 skb = bt_skb_sendmsg(sk, msg, len, len, 0, 0);
744 if (sk->sk_state == BT_CONNECTED)
745 err = sco_send_frame(sk, skb);
756 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
758 struct hci_dev *hdev = conn->hdev;
760 BT_DBG("conn %p", conn);
762 conn->state = BT_CONFIG;
764 if (!lmp_esco_capable(hdev)) {
765 struct hci_cp_accept_conn_req cp;
767 bacpy(&cp.bdaddr, &conn->dst);
768 cp.role = 0x00; /* Ignored */
770 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
772 struct hci_cp_accept_sync_conn_req cp;
774 bacpy(&cp.bdaddr, &conn->dst);
775 cp.pkt_type = cpu_to_le16(conn->pkt_type);
777 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
778 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
779 cp.content_format = cpu_to_le16(setting);
781 switch (setting & SCO_AIRMODE_MASK) {
782 case SCO_AIRMODE_TRANSP:
783 if (conn->pkt_type & ESCO_2EV3)
784 cp.max_latency = cpu_to_le16(0x0008);
786 cp.max_latency = cpu_to_le16(0x000D);
787 cp.retrans_effort = 0x02;
789 case SCO_AIRMODE_CVSD:
790 cp.max_latency = cpu_to_le16(0xffff);
791 cp.retrans_effort = 0xff;
794 /* use CVSD settings as fallback */
795 cp.max_latency = cpu_to_le16(0xffff);
796 cp.retrans_effort = 0xff;
800 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
805 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
806 size_t len, int flags)
808 struct sock *sk = sock->sk;
809 struct sco_pinfo *pi = sco_pi(sk);
813 if (sk->sk_state == BT_CONNECT2 &&
814 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
815 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
816 sk->sk_state = BT_CONFIG;
824 return bt_sock_recvmsg(sock, msg, len, flags);
827 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
828 sockptr_t optval, unsigned int optlen)
830 struct sock *sk = sock->sk;
832 struct bt_voice voice;
834 struct bt_codecs *codecs;
835 struct hci_dev *hdev;
845 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
850 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
855 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
857 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
861 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
862 sk->sk_state != BT_CONNECT2) {
867 voice.setting = sco_pi(sk)->setting;
869 err = bt_copy_from_sockptr(&voice, sizeof(voice), optval,
874 /* Explicitly check for these values */
875 if (voice.setting != BT_VOICE_TRANSPARENT &&
876 voice.setting != BT_VOICE_CVSD_16BIT) {
881 sco_pi(sk)->setting = voice.setting;
882 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
888 if (enhanced_sync_conn_capable(hdev) &&
889 voice.setting == BT_VOICE_TRANSPARENT)
890 sco_pi(sk)->codec.id = BT_CODEC_TRANSPARENT;
895 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
900 set_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
902 clear_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
906 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
907 sk->sk_state != BT_CONNECT2) {
912 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
919 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
925 if (!hdev->get_data_path_id) {
931 if (optlen < sizeof(struct bt_codecs) ||
932 optlen > sizeof(buffer)) {
938 err = bt_copy_from_sockptr(buffer, optlen, optval, optlen);
944 codecs = (void *)buffer;
946 if (codecs->num_codecs > 1) {
952 sco_pi(sk)->codec = codecs->codecs[0];
965 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
966 char __user *optval, int __user *optlen)
968 struct sock *sk = sock->sk;
969 struct sco_options opts;
970 struct sco_conninfo cinfo;
976 if (get_user(len, optlen))
983 if (sk->sk_state != BT_CONNECTED &&
984 !(sk->sk_state == BT_CONNECT2 &&
985 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
990 opts.mtu = sco_pi(sk)->conn->mtu;
992 BT_DBG("mtu %u", opts.mtu);
994 len = min(len, sizeof(opts));
995 if (copy_to_user(optval, (char *)&opts, len))
1001 if (sk->sk_state != BT_CONNECTED &&
1002 !(sk->sk_state == BT_CONNECT2 &&
1003 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
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);
1012 len = min(len, sizeof(cinfo));
1013 if (copy_to_user(optval, (char *)&cinfo, len))
1027 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
1028 char __user *optval, int __user *optlen)
1030 struct sock *sk = sock->sk;
1032 struct bt_voice voice;
1035 struct codec_list *c;
1036 u8 num_codecs, i, __user *ptr;
1037 struct hci_dev *hdev;
1038 struct hci_codec_caps *caps;
1039 struct bt_codec codec;
1041 BT_DBG("sk %p", sk);
1043 if (level == SOL_SCO)
1044 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
1046 if (get_user(len, optlen))
1053 case BT_DEFER_SETUP:
1054 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1059 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
1060 (u32 __user *)optval))
1066 voice.setting = sco_pi(sk)->setting;
1068 len = min_t(unsigned int, len, sizeof(voice));
1069 if (copy_to_user(optval, (char *)&voice, len))
1075 if (sk->sk_state != BT_CONNECTED) {
1080 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1082 if (put_user(phys, (u32 __user *) optval))
1087 if (put_user(test_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags),
1088 (int __user *)optval))
1094 if (sk->sk_state != BT_CONNECTED) {
1099 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1107 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
1113 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
1119 if (!hdev->get_data_path_id) {
1127 /* find total buffer size required to copy codec + caps */
1129 list_for_each_entry(c, &hdev->local_codecs, list) {
1130 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
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];
1137 buf_len += sizeof(struct bt_codec);
1139 hci_dev_unlock(hdev);
1141 buf_len += sizeof(struct bt_codecs);
1142 if (buf_len > len) {
1148 if (put_user(num_codecs, ptr)) {
1152 ptr += sizeof(num_codecs);
1154 /* Iterate all the codecs supported over SCO and populate
1158 list_for_each_entry(c, &hdev->local_codecs, list) {
1159 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1165 err = hdev->get_data_path_id(hdev, &codec.data_path);
1168 codec.num_caps = c->num_caps;
1169 if (copy_to_user(ptr, &codec, sizeof(codec))) {
1173 ptr += sizeof(codec);
1175 /* find codec capabilities data length */
1177 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1178 len += 1 + caps->len;
1179 caps = (void *)&caps->data[caps->len];
1182 /* copy codec capabilities data */
1183 if (len && copy_to_user(ptr, c->caps, len)) {
1190 hci_dev_unlock(hdev);
1195 if (!err && put_user(buf_len, optlen))
1209 static int sco_sock_shutdown(struct socket *sock, int how)
1211 struct sock *sk = sock->sk;
1214 BT_DBG("sock %p, sk %p", sock, sk);
1222 if (!sk->sk_shutdown) {
1223 sk->sk_shutdown = SHUTDOWN_MASK;
1224 sco_sock_clear_timer(sk);
1225 __sco_sock_close(sk);
1227 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1228 !(current->flags & PF_EXITING))
1229 err = bt_sock_wait_state(sk, BT_CLOSED,
1239 static int sco_sock_release(struct socket *sock)
1241 struct sock *sk = sock->sk;
1244 BT_DBG("sock %p, sk %p", sock, sk);
1251 if (sock_flag(sk, SOCK_LINGER) && READ_ONCE(sk->sk_lingertime) &&
1252 !(current->flags & PF_EXITING)) {
1254 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1263 static void sco_conn_ready(struct sco_conn *conn)
1265 struct sock *parent;
1266 struct sock *sk = conn->sk;
1268 BT_DBG("conn %p", conn);
1272 sco_sock_clear_timer(sk);
1273 sk->sk_state = BT_CONNECTED;
1274 sk->sk_state_change(sk);
1277 sco_conn_lock(conn);
1280 sco_conn_unlock(conn);
1284 parent = sco_get_sock_listen(&conn->hcon->src);
1286 sco_conn_unlock(conn);
1292 sk = sco_sock_alloc(sock_net(parent), NULL,
1293 BTPROTO_SCO, GFP_ATOMIC, 0);
1295 release_sock(parent);
1296 sco_conn_unlock(conn);
1300 sco_sock_init(sk, parent);
1302 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1303 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1305 hci_conn_hold(conn->hcon);
1306 __sco_chan_add(conn, sk, parent);
1308 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1309 sk->sk_state = BT_CONNECT2;
1311 sk->sk_state = BT_CONNECTED;
1313 /* Wake up parent */
1314 parent->sk_data_ready(parent);
1316 release_sock(parent);
1318 sco_conn_unlock(conn);
1322 /* ----- SCO interface with lower layer (HCI) ----- */
1323 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1328 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
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)
1336 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1337 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1338 lm |= HCI_LM_ACCEPT;
1340 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1341 *flags |= HCI_PROTO_DEFER;
1345 read_unlock(&sco_sk_list.lock);
1350 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1352 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1355 BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);
1358 struct sco_conn *conn;
1360 conn = sco_conn_add(hcon);
1362 sco_conn_ready(conn);
1364 sco_conn_del(hcon, bt_to_errno(status));
1367 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1369 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1372 BT_DBG("hcon %p reason %d", hcon, reason);
1374 sco_conn_del(hcon, bt_to_errno(reason));
1377 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1379 struct sco_conn *conn = hcon->sco_data;
1384 BT_DBG("conn %p len %u", conn, skb->len);
1387 sco_recv_frame(conn, skb);
1395 static struct hci_cb sco_cb = {
1397 .connect_cfm = sco_connect_cfm,
1398 .disconn_cfm = sco_disconn_cfm,
1401 static int sco_debugfs_show(struct seq_file *f, void *p)
1405 read_lock(&sco_sk_list.lock);
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);
1412 read_unlock(&sco_sk_list.lock);
1417 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1419 static struct dentry *sco_debugfs;
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
1442 static const struct net_proto_family sco_sock_family_ops = {
1443 .family = PF_BLUETOOTH,
1444 .owner = THIS_MODULE,
1445 .create = sco_sock_create,
1448 int __init sco_init(void)
1452 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1454 err = proto_register(&sco_proto, 0);
1458 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1460 BT_ERR("SCO socket registration failed");
1464 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1466 BT_ERR("Failed to create SCO proc file");
1467 bt_sock_unregister(BTPROTO_SCO);
1471 BT_INFO("SCO socket layer initialized");
1473 hci_register_cb(&sco_cb);
1475 if (IS_ERR_OR_NULL(bt_debugfs))
1478 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1479 NULL, &sco_debugfs_fops);
1484 proto_unregister(&sco_proto);
1490 bt_procfs_cleanup(&init_net, "sco");
1492 debugfs_remove(sco_debugfs);
1494 hci_unregister_cb(&sco_cb);
1496 bt_sock_unregister(BTPROTO_SCO);
1498 proto_unregister(&sco_proto);
1501 module_param(disable_esco, bool, 0644);
1502 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");