2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
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 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
852 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
854 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
858 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
859 sk->sk_state != BT_CONNECT2) {
864 voice.setting = sco_pi(sk)->setting;
866 len = min_t(unsigned int, sizeof(voice), optlen);
867 if (copy_from_sockptr(&voice, optval, len)) {
872 /* Explicitly check for these values */
873 if (voice.setting != BT_VOICE_TRANSPARENT &&
874 voice.setting != BT_VOICE_CVSD_16BIT) {
879 sco_pi(sk)->setting = voice.setting;
880 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
886 if (enhanced_sync_conn_capable(hdev) &&
887 voice.setting == BT_VOICE_TRANSPARENT)
888 sco_pi(sk)->codec.id = BT_CODEC_TRANSPARENT;
893 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
899 set_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
901 clear_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags);
905 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
906 sk->sk_state != BT_CONNECT2) {
911 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src,
918 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
924 if (!hdev->get_data_path_id) {
930 if (optlen < sizeof(struct bt_codecs) ||
931 optlen > sizeof(buffer)) {
937 if (copy_from_sockptr(buffer, optval, optlen)) {
943 codecs = (void *)buffer;
945 if (codecs->num_codecs > 1) {
951 sco_pi(sk)->codec = codecs->codecs[0];
964 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
965 char __user *optval, int __user *optlen)
967 struct sock *sk = sock->sk;
968 struct sco_options opts;
969 struct sco_conninfo cinfo;
974 if (get_user(len, optlen))
981 if (sk->sk_state != BT_CONNECTED &&
982 !(sk->sk_state == BT_CONNECT2 &&
983 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
988 opts.mtu = sco_pi(sk)->conn->mtu;
990 BT_DBG("mtu %u", opts.mtu);
992 len = min_t(unsigned int, len, sizeof(opts));
993 if (copy_to_user(optval, (char *)&opts, len))
999 if (sk->sk_state != BT_CONNECTED &&
1000 !(sk->sk_state == BT_CONNECT2 &&
1001 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
1006 memset(&cinfo, 0, sizeof(cinfo));
1007 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
1008 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
1010 len = min_t(unsigned int, len, sizeof(cinfo));
1011 if (copy_to_user(optval, (char *)&cinfo, len))
1025 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
1026 char __user *optval, int __user *optlen)
1028 struct sock *sk = sock->sk;
1030 struct bt_voice voice;
1033 struct codec_list *c;
1034 u8 num_codecs, i, __user *ptr;
1035 struct hci_dev *hdev;
1036 struct hci_codec_caps *caps;
1037 struct bt_codec codec;
1039 BT_DBG("sk %p", sk);
1041 if (level == SOL_SCO)
1042 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
1044 if (get_user(len, optlen))
1051 case BT_DEFER_SETUP:
1052 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
1057 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
1058 (u32 __user *)optval))
1064 voice.setting = sco_pi(sk)->setting;
1066 len = min_t(unsigned int, len, sizeof(voice));
1067 if (copy_to_user(optval, (char *)&voice, len))
1073 if (sk->sk_state != BT_CONNECTED) {
1078 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1080 if (put_user(phys, (u32 __user *) optval))
1085 if (put_user(test_bit(BT_SK_PKT_STATUS, &bt_sk(sk)->flags),
1086 (int __user *)optval))
1092 if (sk->sk_state != BT_CONNECTED) {
1097 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1105 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
1111 if (!hci_dev_test_flag(hdev, HCI_OFFLOAD_CODECS_ENABLED)) {
1117 if (!hdev->get_data_path_id) {
1125 /* find total buffer size required to copy codec + caps */
1127 list_for_each_entry(c, &hdev->local_codecs, list) {
1128 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1131 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1132 buf_len += 1 + caps->len;
1133 caps = (void *)&caps->data[caps->len];
1135 buf_len += sizeof(struct bt_codec);
1137 hci_dev_unlock(hdev);
1139 buf_len += sizeof(struct bt_codecs);
1140 if (buf_len > len) {
1146 if (put_user(num_codecs, ptr)) {
1150 ptr += sizeof(num_codecs);
1152 /* Iterate all the codecs supported over SCO and populate
1156 list_for_each_entry(c, &hdev->local_codecs, list) {
1157 if (c->transport != HCI_TRANSPORT_SCO_ESCO)
1163 err = hdev->get_data_path_id(hdev, &codec.data_path);
1166 codec.num_caps = c->num_caps;
1167 if (copy_to_user(ptr, &codec, sizeof(codec))) {
1171 ptr += sizeof(codec);
1173 /* find codec capabilities data length */
1175 for (i = 0, caps = c->caps; i < c->num_caps; i++) {
1176 len += 1 + caps->len;
1177 caps = (void *)&caps->data[caps->len];
1180 /* copy codec capabilities data */
1181 if (len && copy_to_user(ptr, c->caps, len)) {
1188 hci_dev_unlock(hdev);
1193 if (!err && put_user(buf_len, optlen))
1207 static int sco_sock_shutdown(struct socket *sock, int how)
1209 struct sock *sk = sock->sk;
1212 BT_DBG("sock %p, sk %p", sock, sk);
1220 if (!sk->sk_shutdown) {
1221 sk->sk_shutdown = SHUTDOWN_MASK;
1222 sco_sock_clear_timer(sk);
1223 __sco_sock_close(sk);
1225 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1226 !(current->flags & PF_EXITING))
1227 err = bt_sock_wait_state(sk, BT_CLOSED,
1237 static int sco_sock_release(struct socket *sock)
1239 struct sock *sk = sock->sk;
1242 BT_DBG("sock %p, sk %p", sock, sk);
1249 if (sock_flag(sk, SOCK_LINGER) && READ_ONCE(sk->sk_lingertime) &&
1250 !(current->flags & PF_EXITING)) {
1252 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1261 static void sco_conn_ready(struct sco_conn *conn)
1263 struct sock *parent;
1264 struct sock *sk = conn->sk;
1266 BT_DBG("conn %p", conn);
1270 sco_sock_clear_timer(sk);
1271 sk->sk_state = BT_CONNECTED;
1272 sk->sk_state_change(sk);
1275 sco_conn_lock(conn);
1278 sco_conn_unlock(conn);
1282 parent = sco_get_sock_listen(&conn->hcon->src);
1284 sco_conn_unlock(conn);
1290 sk = sco_sock_alloc(sock_net(parent), NULL,
1291 BTPROTO_SCO, GFP_ATOMIC, 0);
1293 release_sock(parent);
1294 sco_conn_unlock(conn);
1298 sco_sock_init(sk, parent);
1300 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1301 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1303 hci_conn_hold(conn->hcon);
1304 __sco_chan_add(conn, sk, parent);
1306 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1307 sk->sk_state = BT_CONNECT2;
1309 sk->sk_state = BT_CONNECTED;
1311 /* Wake up parent */
1312 parent->sk_data_ready(parent);
1314 release_sock(parent);
1316 sco_conn_unlock(conn);
1320 /* ----- SCO interface with lower layer (HCI) ----- */
1321 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1326 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1328 /* Find listening sockets */
1329 read_lock(&sco_sk_list.lock);
1330 sk_for_each(sk, &sco_sk_list.head) {
1331 if (sk->sk_state != BT_LISTEN)
1334 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1335 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1336 lm |= HCI_LM_ACCEPT;
1338 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1339 *flags |= HCI_PROTO_DEFER;
1343 read_unlock(&sco_sk_list.lock);
1348 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1350 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1353 BT_DBG("hcon %p bdaddr %pMR status %u", hcon, &hcon->dst, status);
1356 struct sco_conn *conn;
1358 conn = sco_conn_add(hcon);
1360 sco_conn_ready(conn);
1362 sco_conn_del(hcon, bt_to_errno(status));
1365 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1367 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1370 BT_DBG("hcon %p reason %d", hcon, reason);
1372 sco_conn_del(hcon, bt_to_errno(reason));
1375 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1377 struct sco_conn *conn = hcon->sco_data;
1382 BT_DBG("conn %p len %u", conn, skb->len);
1385 sco_recv_frame(conn, skb);
1393 static struct hci_cb sco_cb = {
1395 .connect_cfm = sco_connect_cfm,
1396 .disconn_cfm = sco_disconn_cfm,
1399 static int sco_debugfs_show(struct seq_file *f, void *p)
1403 read_lock(&sco_sk_list.lock);
1405 sk_for_each(sk, &sco_sk_list.head) {
1406 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1407 &sco_pi(sk)->dst, sk->sk_state);
1410 read_unlock(&sco_sk_list.lock);
1415 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1417 static struct dentry *sco_debugfs;
1419 static const struct proto_ops sco_sock_ops = {
1420 .family = PF_BLUETOOTH,
1421 .owner = THIS_MODULE,
1422 .release = sco_sock_release,
1423 .bind = sco_sock_bind,
1424 .connect = sco_sock_connect,
1425 .listen = sco_sock_listen,
1426 .accept = sco_sock_accept,
1427 .getname = sco_sock_getname,
1428 .sendmsg = sco_sock_sendmsg,
1429 .recvmsg = sco_sock_recvmsg,
1430 .poll = bt_sock_poll,
1431 .ioctl = bt_sock_ioctl,
1432 .gettstamp = sock_gettstamp,
1433 .mmap = sock_no_mmap,
1434 .socketpair = sock_no_socketpair,
1435 .shutdown = sco_sock_shutdown,
1436 .setsockopt = sco_sock_setsockopt,
1437 .getsockopt = sco_sock_getsockopt
1440 static const struct net_proto_family sco_sock_family_ops = {
1441 .family = PF_BLUETOOTH,
1442 .owner = THIS_MODULE,
1443 .create = sco_sock_create,
1446 int __init sco_init(void)
1450 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1452 err = proto_register(&sco_proto, 0);
1456 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1458 BT_ERR("SCO socket registration failed");
1462 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1464 BT_ERR("Failed to create SCO proc file");
1465 bt_sock_unregister(BTPROTO_SCO);
1469 BT_INFO("SCO socket layer initialized");
1471 hci_register_cb(&sco_cb);
1473 if (IS_ERR_OR_NULL(bt_debugfs))
1476 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1477 NULL, &sco_debugfs_fops);
1482 proto_unregister(&sco_proto);
1488 bt_procfs_cleanup(&init_net, "sco");
1490 debugfs_remove(sco_debugfs);
1492 hci_unregister_cb(&sco_cb);
1494 bt_sock_unregister(BTPROTO_SCO);
1496 proto_unregister(&sco_proto);
1499 module_param(disable_esco, bool, 0644);
1500 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");