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,
89 sco_conn_unlock(conn);
94 BT_DBG("sock %p state %d", sk, sk->sk_state);
97 sk->sk_err = ETIMEDOUT;
98 sk->sk_state_change(sk);
103 static void sco_sock_set_timer(struct sock *sk, long timeout)
105 if (!sco_pi(sk)->conn)
108 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
109 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
110 schedule_delayed_work(&sco_pi(sk)->conn->timeout_work, timeout);
113 static void sco_sock_clear_timer(struct sock *sk)
115 if (!sco_pi(sk)->conn)
118 BT_DBG("sock %p state %d", sk, sk->sk_state);
119 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
122 /* ---- SCO connections ---- */
123 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
125 struct hci_dev *hdev = hcon->hdev;
126 struct sco_conn *conn = hcon->sco_data;
134 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
138 spin_lock_init(&conn->lock);
139 INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
141 hcon->sco_data = conn;
144 if (hdev->sco_mtu > 0)
145 conn->mtu = hdev->sco_mtu;
149 BT_DBG("hcon %p conn %p", hcon, conn);
155 * Must be called on the locked socket. */
156 static void sco_chan_del(struct sock *sk, int err)
158 struct sco_conn *conn;
160 conn = sco_pi(sk)->conn;
162 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
167 sco_pi(sk)->conn = NULL;
168 sco_conn_unlock(conn);
171 hci_conn_drop(conn->hcon);
174 sk->sk_state = BT_CLOSED;
176 sk->sk_state_change(sk);
178 sock_set_flag(sk, SOCK_ZAPPED);
181 static void sco_conn_del(struct hci_conn *hcon, int err)
183 struct sco_conn *conn = hcon->sco_data;
189 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
196 sco_conn_unlock(conn);
200 sco_sock_clear_timer(sk);
201 sco_chan_del(sk, err);
206 /* Ensure no more work items will run before freeing conn. */
207 cancel_delayed_work_sync(&conn->timeout_work);
209 hcon->sco_data = NULL;
213 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
216 BT_DBG("conn %p", conn);
218 sco_pi(sk)->conn = conn;
222 bt_accept_enqueue(parent, sk, true);
225 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
234 __sco_chan_add(conn, sk, parent);
236 sco_conn_unlock(conn);
240 static int sco_connect(struct sock *sk)
242 struct sco_conn *conn;
243 struct hci_conn *hcon;
244 struct hci_dev *hdev;
247 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
249 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
251 return -EHOSTUNREACH;
255 if (lmp_esco_capable(hdev) && !disable_esco)
260 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
261 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
266 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
267 sco_pi(sk)->setting, &sco_pi(sk)->codec,
274 conn = sco_conn_add(hcon);
283 err = sco_chan_add(conn, sk, NULL);
289 /* Update source addr of the socket */
290 bacpy(&sco_pi(sk)->src, &hcon->src);
292 if (hcon->state == BT_CONNECTED) {
293 sco_sock_clear_timer(sk);
294 sk->sk_state = BT_CONNECTED;
296 sk->sk_state = BT_CONNECT;
297 sco_sock_set_timer(sk, sk->sk_sndtimeo);
303 hci_dev_unlock(hdev);
308 static int sco_send_frame(struct sock *sk, struct sk_buff *skb)
310 struct sco_conn *conn = sco_pi(sk)->conn;
313 /* Check outgoing MTU */
317 BT_DBG("sk %p len %d", sk, len);
319 hci_send_sco(conn->hcon, skb);
324 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
330 sco_conn_unlock(conn);
335 BT_DBG("sk %p len %u", sk, skb->len);
337 if (sk->sk_state != BT_CONNECTED)
340 if (!sock_queue_rcv_skb(sk, skb))
347 /* -------- Socket interface ---------- */
348 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
352 sk_for_each(sk, &sco_sk_list.head) {
353 if (sk->sk_state != BT_LISTEN)
356 if (!bacmp(&sco_pi(sk)->src, ba))
363 /* Find socket listening on source bdaddr.
364 * Returns closest match.
366 static struct sock *sco_get_sock_listen(bdaddr_t *src)
368 struct sock *sk = NULL, *sk1 = NULL;
370 read_lock(&sco_sk_list.lock);
372 sk_for_each(sk, &sco_sk_list.head) {
373 if (sk->sk_state != BT_LISTEN)
377 if (!bacmp(&sco_pi(sk)->src, src))
381 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
385 read_unlock(&sco_sk_list.lock);
387 return sk ? sk : sk1;
390 static void sco_sock_destruct(struct sock *sk)
394 skb_queue_purge(&sk->sk_receive_queue);
395 skb_queue_purge(&sk->sk_write_queue);
398 static void sco_sock_cleanup_listen(struct sock *parent)
402 BT_DBG("parent %p", parent);
404 /* Close not yet accepted channels */
405 while ((sk = bt_accept_dequeue(parent, NULL))) {
410 parent->sk_state = BT_CLOSED;
411 sock_set_flag(parent, SOCK_ZAPPED);
414 /* Kill socket (only if zapped and orphan)
415 * Must be called on unlocked socket.
417 static void sco_sock_kill(struct sock *sk)
419 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
422 BT_DBG("sk %p state %d", sk, sk->sk_state);
424 /* Kill poor orphan */
425 bt_sock_unlink(&sco_sk_list, sk);
426 sock_set_flag(sk, SOCK_DEAD);
430 static void __sco_sock_close(struct sock *sk)
432 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
434 switch (sk->sk_state) {
436 sco_sock_cleanup_listen(sk);
441 if (sco_pi(sk)->conn->hcon) {
442 sk->sk_state = BT_DISCONN;
443 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
444 sco_conn_lock(sco_pi(sk)->conn);
445 hci_conn_drop(sco_pi(sk)->conn->hcon);
446 sco_pi(sk)->conn->hcon = NULL;
447 sco_conn_unlock(sco_pi(sk)->conn);
449 sco_chan_del(sk, ECONNRESET);
455 sco_chan_del(sk, ECONNRESET);
459 sock_set_flag(sk, SOCK_ZAPPED);
465 /* Must be called on unlocked socket. */
466 static void sco_sock_close(struct sock *sk)
469 sco_sock_clear_timer(sk);
470 __sco_sock_close(sk);
474 static void sco_sock_init(struct sock *sk, struct sock *parent)
479 sk->sk_type = parent->sk_type;
480 bt_sk(sk)->flags = bt_sk(parent)->flags;
481 security_sk_clone(parent, sk);
485 static struct proto sco_proto = {
487 .owner = THIS_MODULE,
488 .obj_size = sizeof(struct sco_pinfo)
491 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
492 int proto, gfp_t prio, int kern)
496 sk = bt_sock_alloc(net, sock, &sco_proto, proto, prio, kern);
500 sk->sk_destruct = sco_sock_destruct;
501 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
503 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
504 sco_pi(sk)->codec.id = BT_CODEC_CVSD;
505 sco_pi(sk)->codec.cid = 0xffff;
506 sco_pi(sk)->codec.vid = 0xffff;
507 sco_pi(sk)->codec.data_path = 0x00;
509 bt_sock_link(&sco_sk_list, sk);
513 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
518 BT_DBG("sock %p", sock);
520 sock->state = SS_UNCONNECTED;
522 if (sock->type != SOCK_SEQPACKET)
523 return -ESOCKTNOSUPPORT;
525 sock->ops = &sco_sock_ops;
527 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
531 sco_sock_init(sk, NULL);
535 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
538 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
539 struct sock *sk = sock->sk;
542 if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
543 addr->sa_family != AF_BLUETOOTH)
546 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
550 if (sk->sk_state != BT_OPEN) {
555 if (sk->sk_type != SOCK_SEQPACKET) {
560 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
562 sk->sk_state = BT_BOUND;
569 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
571 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
572 struct sock *sk = sock->sk;
577 if (alen < sizeof(struct sockaddr_sco) ||
578 addr->sa_family != AF_BLUETOOTH)
581 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
584 if (sk->sk_type != SOCK_SEQPACKET)
588 /* Set destination address and psm */
589 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
592 err = sco_connect(sk);
598 err = bt_sock_wait_state(sk, BT_CONNECTED,
599 sock_sndtimeo(sk, flags & O_NONBLOCK));
605 static int sco_sock_listen(struct socket *sock, int backlog)
607 struct sock *sk = sock->sk;
608 bdaddr_t *src = &sco_pi(sk)->src;
611 BT_DBG("sk %p backlog %d", sk, backlog);
615 if (sk->sk_state != BT_BOUND) {
620 if (sk->sk_type != SOCK_SEQPACKET) {
625 write_lock(&sco_sk_list.lock);
627 if (__sco_get_sock_listen_by_addr(src)) {
632 sk->sk_max_ack_backlog = backlog;
633 sk->sk_ack_backlog = 0;
635 sk->sk_state = BT_LISTEN;
638 write_unlock(&sco_sk_list.lock);
645 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
646 int flags, bool kern)
648 DEFINE_WAIT_FUNC(wait, woken_wake_function);
649 struct sock *sk = sock->sk, *ch;
655 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
657 BT_DBG("sk %p timeo %ld", sk, timeo);
659 /* Wait for an incoming connection. (wake-one). */
660 add_wait_queue_exclusive(sk_sleep(sk), &wait);
662 if (sk->sk_state != BT_LISTEN) {
667 ch = bt_accept_dequeue(sk, newsock);
676 if (signal_pending(current)) {
677 err = sock_intr_errno(timeo);
683 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
686 remove_wait_queue(sk_sleep(sk), &wait);
691 newsock->state = SS_CONNECTED;
693 BT_DBG("new socket %p", ch);
700 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
703 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
704 struct sock *sk = sock->sk;
706 BT_DBG("sock %p, sk %p", sock, sk);
708 addr->sa_family = AF_BLUETOOTH;
711 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
713 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
715 return sizeof(struct sockaddr_sco);
718 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
721 struct sock *sk = sock->sk;
725 BT_DBG("sock %p, sk %p", sock, sk);
727 err = sock_error(sk);
731 if (msg->msg_flags & MSG_OOB)
734 skb = bt_skb_sendmsg(sk, msg, len, len, 0, 0);
740 if (sk->sk_state == BT_CONNECTED)
741 err = sco_send_frame(sk, skb);
752 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
754 struct hci_dev *hdev = conn->hdev;
756 BT_DBG("conn %p", conn);
758 conn->state = BT_CONFIG;
760 if (!lmp_esco_capable(hdev)) {
761 struct hci_cp_accept_conn_req cp;
763 bacpy(&cp.bdaddr, &conn->dst);
764 cp.role = 0x00; /* Ignored */
766 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
768 struct hci_cp_accept_sync_conn_req cp;
770 bacpy(&cp.bdaddr, &conn->dst);
771 cp.pkt_type = cpu_to_le16(conn->pkt_type);
773 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
774 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
775 cp.content_format = cpu_to_le16(setting);
777 switch (setting & SCO_AIRMODE_MASK) {
778 case SCO_AIRMODE_TRANSP:
779 if (conn->pkt_type & ESCO_2EV3)
780 cp.max_latency = cpu_to_le16(0x0008);
782 cp.max_latency = cpu_to_le16(0x000D);
783 cp.retrans_effort = 0x02;
785 case SCO_AIRMODE_CVSD:
786 cp.max_latency = cpu_to_le16(0xffff);
787 cp.retrans_effort = 0xff;
790 /* use CVSD settings as fallback */
791 cp.max_latency = cpu_to_le16(0xffff);
792 cp.retrans_effort = 0xff;
796 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
801 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
802 size_t len, int flags)
804 struct sock *sk = sock->sk;
805 struct sco_pinfo *pi = sco_pi(sk);
809 if (sk->sk_state == BT_CONNECT2 &&
810 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
811 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
812 sk->sk_state = BT_CONFIG;
820 return bt_sock_recvmsg(sock, msg, len, flags);
823 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
824 sockptr_t optval, unsigned int optlen)
826 struct sock *sk = sock->sk;
828 struct bt_voice voice;
830 struct bt_codecs *codecs;
831 struct hci_dev *hdev;
841 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
846 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
851 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
853 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
857 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
858 sk->sk_state != BT_CONNECT2) {
863 voice.setting = sco_pi(sk)->setting;
865 err = bt_copy_from_sockptr(&voice, sizeof(voice), optval,
870 /* Explicitly check for these values */
871 if (voice.setting != BT_VOICE_TRANSPARENT &&
872 voice.setting != BT_VOICE_CVSD_16BIT) {
877 sco_pi(sk)->setting = voice.setting;
878 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
884 if (enhanced_sync_conn_capable(hdev) &&
885 voice.setting == BT_VOICE_TRANSPARENT)
886 sco_pi(sk)->codec.id = BT_CODEC_TRANSPARENT;
891 err = bt_copy_from_sockptr(&opt, sizeof(opt), optval, optlen);
896 set_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
898 clear_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
902 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
903 sk->sk_state != BT_CONNECT2) {
908 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
915 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
921 if (!hdev->get_data_path_id) {
927 if (optlen < sizeof(struct bt_codecs) ||
928 optlen > sizeof(buffer)) {
934 err = bt_copy_from_sockptr(buffer, optlen, optval, optlen);
940 codecs = (void *)buffer;
942 if (codecs->num_codecs > 1) {
948 sco_pi(sk)->codec = codecs->codecs[0];
961 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
962 char __user *optval, int __user *optlen)
964 struct sock *sk = sock->sk;
965 struct sco_options opts;
966 struct sco_conninfo cinfo;
972 if (get_user(len, optlen))
979 if (sk->sk_state != BT_CONNECTED &&
980 !(sk->sk_state == BT_CONNECT2 &&
981 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
986 opts.mtu = sco_pi(sk)->conn->mtu;
988 BT_DBG("mtu %u", opts.mtu);
990 len = min(len, sizeof(opts));
991 if (copy_to_user(optval, (char *)&opts, len))
997 if (sk->sk_state != BT_CONNECTED &&
998 !(sk->sk_state == BT_CONNECT2 &&
999 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
1004 memset(&cinfo, 0, sizeof(cinfo));
1005 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
1006 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
1008 len = min(len, sizeof(cinfo));
1009 if (copy_to_user(optval, (char *)&cinfo, len))
1023 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
1024 char __user *optval, int __user *optlen)
1026 struct sock *sk = sock->sk;
1028 struct bt_voice voice;
1031 struct codec_list *c;
1032 u8 num_codecs, i, __user *ptr;
1033 struct hci_dev *hdev;
1034 struct hci_codec_caps *caps;
1035 struct bt_codec codec;
1037 BT_DBG("sk %p", sk);
1039 if (level == SOL_SCO)
1040 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
1042 if (get_user(len, optlen))
1049 case BT_DEFER_SETUP:
1050 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1055 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
1056 (u32 __user *)optval))
1062 voice.setting = sco_pi(sk)->setting;
1064 len = min_t(unsigned int, len, sizeof(voice));
1065 if (copy_to_user(optval, (char *)&voice, len))
1071 if (sk->sk_state != BT_CONNECTED) {
1076 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1078 if (put_user(phys, (u32 __user *) optval))
1083 if (put_user(test_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags),
1084 (int __user *)optval))
1090 if (sk->sk_state != BT_CONNECTED) {
1095 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1103 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
1109 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
1115 if (!hdev->get_data_path_id) {
1123 /* find total buffer size required to copy codec + caps */
1125 list_for_each_entry(c, &hdev->local_codecs, list) {
1126 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1129 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1130 buf_len += 1 + caps->len;
1131 caps = (void *)&caps->data[caps->len];
1133 buf_len += sizeof(struct bt_codec);
1135 hci_dev_unlock(hdev);
1137 buf_len += sizeof(struct bt_codecs);
1138 if (buf_len > len) {
1144 if (put_user(num_codecs, ptr)) {
1148 ptr += sizeof(num_codecs);
1150 /* Iterate all the codecs supported over SCO and populate
1154 list_for_each_entry(c, &hdev->local_codecs, list) {
1155 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1161 err = hdev->get_data_path_id(hdev, &codec.data_path);
1164 codec.num_caps = c->num_caps;
1165 if (copy_to_user(ptr, &codec, sizeof(codec))) {
1169 ptr += sizeof(codec);
1171 /* find codec capabilities data length */
1173 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1174 len += 1 + caps->len;
1175 caps = (void *)&caps->data[caps->len];
1178 /* copy codec capabilities data */
1179 if (len && copy_to_user(ptr, c->caps, len)) {
1186 hci_dev_unlock(hdev);
1191 if (!err && put_user(buf_len, optlen))
1205 static int sco_sock_shutdown(struct socket *sock, int how)
1207 struct sock *sk = sock->sk;
1210 BT_DBG("sock %p, sk %p", sock, sk);
1218 if (!sk->sk_shutdown) {
1219 sk->sk_shutdown = SHUTDOWN_MASK;
1220 sco_sock_clear_timer(sk);
1221 __sco_sock_close(sk);
1223 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1224 !(current->flags & PF_EXITING))
1225 err = bt_sock_wait_state(sk, BT_CLOSED,
1235 static int sco_sock_release(struct socket *sock)
1237 struct sock *sk = sock->sk;
1240 BT_DBG("sock %p, sk %p", sock, sk);
1247 if (sock_flag(sk, SOCK_LINGER) && READ_ONCE(sk->sk_lingertime) &&
1248 !(current->flags & PF_EXITING)) {
1250 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1259 static void sco_conn_ready(struct sco_conn *conn)
1261 struct sock *parent;
1262 struct sock *sk = conn->sk;
1264 BT_DBG("conn %p", conn);
1268 sco_sock_clear_timer(sk);
1269 sk->sk_state = BT_CONNECTED;
1270 sk->sk_state_change(sk);
1273 sco_conn_lock(conn);
1276 sco_conn_unlock(conn);
1280 parent = sco_get_sock_listen(&conn->hcon->src);
1282 sco_conn_unlock(conn);
1288 sk = sco_sock_alloc(sock_net(parent), NULL,
1289 BTPROTO_SCO, GFP_ATOMIC, 0);
1291 release_sock(parent);
1292 sco_conn_unlock(conn);
1296 sco_sock_init(sk, parent);
1298 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1299 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1301 hci_conn_hold(conn->hcon);
1302 __sco_chan_add(conn, sk, parent);
1304 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1305 sk->sk_state = BT_CONNECT2;
1307 sk->sk_state = BT_CONNECTED;
1309 /* Wake up parent */
1310 parent->sk_data_ready(parent);
1312 release_sock(parent);
1314 sco_conn_unlock(conn);
1318 /* ----- SCO interface with lower layer (HCI) ----- */
1319 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1324 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1326 /* Find listening sockets */
1327 read_lock(&sco_sk_list.lock);
1328 sk_for_each(sk, &sco_sk_list.head) {
1329 if (sk->sk_state != BT_LISTEN)
1332 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1333 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1334 lm |= HCI_LM_ACCEPT;
1336 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1337 *flags |= HCI_PROTO_DEFER;
1341 read_unlock(&sco_sk_list.lock);
1346 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1348 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1351 BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);
1354 struct sco_conn *conn;
1356 conn = sco_conn_add(hcon);
1358 sco_conn_ready(conn);
1360 sco_conn_del(hcon, bt_to_errno(status));
1363 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1365 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1368 BT_DBG("hcon %p reason %d", hcon, reason);
1370 sco_conn_del(hcon, bt_to_errno(reason));
1373 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1375 struct sco_conn *conn = hcon->sco_data;
1380 BT_DBG("conn %p len %u", conn, skb->len);
1383 sco_recv_frame(conn, skb);
1391 static struct hci_cb sco_cb = {
1393 .connect_cfm = sco_connect_cfm,
1394 .disconn_cfm = sco_disconn_cfm,
1397 static int sco_debugfs_show(struct seq_file *f, void *p)
1401 read_lock(&sco_sk_list.lock);
1403 sk_for_each(sk, &sco_sk_list.head) {
1404 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1405 &sco_pi(sk)->dst, sk->sk_state);
1408 read_unlock(&sco_sk_list.lock);
1413 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1415 static struct dentry *sco_debugfs;
1417 static const struct proto_ops sco_sock_ops = {
1418 .family = PF_BLUETOOTH,
1419 .owner = THIS_MODULE,
1420 .release = sco_sock_release,
1421 .bind = sco_sock_bind,
1422 .connect = sco_sock_connect,
1423 .listen = sco_sock_listen,
1424 .accept = sco_sock_accept,
1425 .getname = sco_sock_getname,
1426 .sendmsg = sco_sock_sendmsg,
1427 .recvmsg = sco_sock_recvmsg,
1428 .poll = bt_sock_poll,
1429 .ioctl = bt_sock_ioctl,
1430 .gettstamp = sock_gettstamp,
1431 .mmap = sock_no_mmap,
1432 .socketpair = sock_no_socketpair,
1433 .shutdown = sco_sock_shutdown,
1434 .setsockopt = sco_sock_setsockopt,
1435 .getsockopt = sco_sock_getsockopt
1438 static const struct net_proto_family sco_sock_family_ops = {
1439 .family = PF_BLUETOOTH,
1440 .owner = THIS_MODULE,
1441 .create = sco_sock_create,
1444 int __init sco_init(void)
1448 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1450 err = proto_register(&sco_proto, 0);
1454 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1456 BT_ERR("SCO socket registration failed");
1460 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1462 BT_ERR("Failed to create SCO proc file");
1463 bt_sock_unregister(BTPROTO_SCO);
1467 BT_INFO("SCO socket layer initialized");
1469 hci_register_cb(&sco_cb);
1471 if (IS_ERR_OR_NULL(bt_debugfs))
1474 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1475 NULL, &sco_debugfs_fops);
1480 proto_unregister(&sco_proto);
1486 bt_procfs_cleanup(&init_net, "sco");
1488 debugfs_remove(sco_debugfs);
1490 hci_unregister_cb(&sco_cb);
1492 bt_sock_unregister(BTPROTO_SCO);
1494 proto_unregister(&sco_proto);
1497 module_param(disable_esco, bool, 0644);
1498 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");