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 sco_conn *conn;
74 /* ---- SCO timers ---- */
75 #define SCO_CONN_TIMEOUT (HZ * 40)
76 #define SCO_DISCONN_TIMEOUT (HZ * 2)
78 static void sco_sock_timeout(struct work_struct *work)
80 struct sco_conn *conn = container_of(work, struct sco_conn,
88 sco_conn_unlock(conn);
93 BT_DBG("sock %p state %d", sk, sk->sk_state);
96 sk->sk_err = ETIMEDOUT;
97 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;
131 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
135 spin_lock_init(&conn->lock);
136 INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
138 hcon->sco_data = conn;
141 if (hdev->sco_mtu > 0)
142 conn->mtu = hdev->sco_mtu;
146 BT_DBG("hcon %p conn %p", hcon, conn);
152 * Must be called on the locked socket. */
153 static void sco_chan_del(struct sock *sk, int err)
155 struct sco_conn *conn;
157 conn = sco_pi(sk)->conn;
159 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
164 sco_pi(sk)->conn = NULL;
165 sco_conn_unlock(conn);
168 hci_conn_drop(conn->hcon);
171 sk->sk_state = BT_CLOSED;
173 sk->sk_state_change(sk);
175 sock_set_flag(sk, SOCK_ZAPPED);
178 static void sco_conn_del(struct hci_conn *hcon, int err)
180 struct sco_conn *conn = hcon->sco_data;
186 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
191 sco_conn_unlock(conn);
196 sco_sock_clear_timer(sk);
197 sco_chan_del(sk, err);
202 /* Ensure no more work items will run before freeing conn. */
203 cancel_delayed_work_sync(&conn->timeout_work);
205 hcon->sco_data = NULL;
209 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
212 BT_DBG("conn %p", conn);
214 sco_pi(sk)->conn = conn;
218 bt_accept_enqueue(parent, sk, true);
221 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
230 __sco_chan_add(conn, sk, parent);
232 sco_conn_unlock(conn);
236 static int sco_connect(struct hci_dev *hdev, struct sock *sk)
238 struct sco_conn *conn;
239 struct hci_conn *hcon;
242 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
244 if (lmp_esco_capable(hdev) && !disable_esco)
249 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
250 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev)))
253 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
254 sco_pi(sk)->setting);
256 return PTR_ERR(hcon);
258 conn = sco_conn_add(hcon);
264 /* Update source addr of the socket */
265 bacpy(&sco_pi(sk)->src, &hcon->src);
267 err = sco_chan_add(conn, sk, NULL);
271 if (hcon->state == BT_CONNECTED) {
272 sco_sock_clear_timer(sk);
273 sk->sk_state = BT_CONNECTED;
275 sk->sk_state = BT_CONNECT;
276 sco_sock_set_timer(sk, sk->sk_sndtimeo);
282 static int sco_send_frame(struct sock *sk, void *buf, int len,
283 unsigned int msg_flags)
285 struct sco_conn *conn = sco_pi(sk)->conn;
289 /* Check outgoing MTU */
293 BT_DBG("sk %p len %d", sk, len);
295 skb = bt_skb_send_alloc(sk, len, msg_flags & MSG_DONTWAIT, &err);
299 memcpy(skb_put(skb, len), buf, len);
300 hci_send_sco(conn->hcon, skb);
305 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
311 sco_conn_unlock(conn);
316 BT_DBG("sk %p len %d", sk, skb->len);
318 if (sk->sk_state != BT_CONNECTED)
321 if (!sock_queue_rcv_skb(sk, skb))
328 /* -------- Socket interface ---------- */
329 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
333 sk_for_each(sk, &sco_sk_list.head) {
334 if (sk->sk_state != BT_LISTEN)
337 if (!bacmp(&sco_pi(sk)->src, ba))
344 /* Find socket listening on source bdaddr.
345 * Returns closest match.
347 static struct sock *sco_get_sock_listen(bdaddr_t *src)
349 struct sock *sk = NULL, *sk1 = NULL;
351 read_lock(&sco_sk_list.lock);
353 sk_for_each(sk, &sco_sk_list.head) {
354 if (sk->sk_state != BT_LISTEN)
358 if (!bacmp(&sco_pi(sk)->src, src))
362 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
366 read_unlock(&sco_sk_list.lock);
368 return sk ? sk : sk1;
371 static void sco_sock_destruct(struct sock *sk)
375 skb_queue_purge(&sk->sk_receive_queue);
376 skb_queue_purge(&sk->sk_write_queue);
379 static void sco_sock_cleanup_listen(struct sock *parent)
383 BT_DBG("parent %p", parent);
385 /* Close not yet accepted channels */
386 while ((sk = bt_accept_dequeue(parent, NULL))) {
391 parent->sk_state = BT_CLOSED;
392 sock_set_flag(parent, SOCK_ZAPPED);
395 /* Kill socket (only if zapped and orphan)
396 * Must be called on unlocked socket.
398 static void sco_sock_kill(struct sock *sk)
400 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
403 BT_DBG("sk %p state %d", sk, sk->sk_state);
405 /* Kill poor orphan */
406 bt_sock_unlink(&sco_sk_list, sk);
407 sock_set_flag(sk, SOCK_DEAD);
411 static void __sco_sock_close(struct sock *sk)
413 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
415 switch (sk->sk_state) {
417 sco_sock_cleanup_listen(sk);
422 if (sco_pi(sk)->conn->hcon) {
423 sk->sk_state = BT_DISCONN;
424 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
425 sco_conn_lock(sco_pi(sk)->conn);
426 hci_conn_drop(sco_pi(sk)->conn->hcon);
427 sco_pi(sk)->conn->hcon = NULL;
428 sco_conn_unlock(sco_pi(sk)->conn);
430 sco_chan_del(sk, ECONNRESET);
436 sco_chan_del(sk, ECONNRESET);
440 sock_set_flag(sk, SOCK_ZAPPED);
445 /* Must be called on unlocked socket. */
446 static void sco_sock_close(struct sock *sk)
448 sco_sock_clear_timer(sk);
450 __sco_sock_close(sk);
454 static void sco_sock_init(struct sock *sk, struct sock *parent)
459 sk->sk_type = parent->sk_type;
460 bt_sk(sk)->flags = bt_sk(parent)->flags;
461 security_sk_clone(parent, sk);
465 static struct proto sco_proto = {
467 .owner = THIS_MODULE,
468 .obj_size = sizeof(struct sco_pinfo)
471 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
472 int proto, gfp_t prio, int kern)
476 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
480 sock_init_data(sock, sk);
481 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
483 sk->sk_destruct = sco_sock_destruct;
484 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
486 sock_reset_flag(sk, SOCK_ZAPPED);
488 sk->sk_protocol = proto;
489 sk->sk_state = BT_OPEN;
491 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
493 bt_sock_link(&sco_sk_list, sk);
497 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
502 BT_DBG("sock %p", sock);
504 sock->state = SS_UNCONNECTED;
506 if (sock->type != SOCK_SEQPACKET)
507 return -ESOCKTNOSUPPORT;
509 sock->ops = &sco_sock_ops;
511 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
515 sco_sock_init(sk, NULL);
519 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
522 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
523 struct sock *sk = sock->sk;
526 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
528 if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
529 addr->sa_family != AF_BLUETOOTH)
534 if (sk->sk_state != BT_OPEN) {
539 if (sk->sk_type != SOCK_SEQPACKET) {
544 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
546 sk->sk_state = BT_BOUND;
553 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
555 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
556 struct sock *sk = sock->sk;
557 struct hci_dev *hdev;
562 if (alen < sizeof(struct sockaddr_sco) ||
563 addr->sa_family != AF_BLUETOOTH)
566 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
569 if (sk->sk_type != SOCK_SEQPACKET)
572 hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
574 return -EHOSTUNREACH;
579 /* Set destination address and psm */
580 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
582 err = sco_connect(hdev, sk);
583 hci_dev_unlock(hdev);
588 err = bt_sock_wait_state(sk, BT_CONNECTED,
589 sock_sndtimeo(sk, flags & O_NONBLOCK));
596 static int sco_sock_listen(struct socket *sock, int backlog)
598 struct sock *sk = sock->sk;
599 bdaddr_t *src = &sco_pi(sk)->src;
602 BT_DBG("sk %p backlog %d", sk, backlog);
606 if (sk->sk_state != BT_BOUND) {
611 if (sk->sk_type != SOCK_SEQPACKET) {
616 write_lock(&sco_sk_list.lock);
618 if (__sco_get_sock_listen_by_addr(src)) {
623 sk->sk_max_ack_backlog = backlog;
624 sk->sk_ack_backlog = 0;
626 sk->sk_state = BT_LISTEN;
629 write_unlock(&sco_sk_list.lock);
636 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
637 int flags, bool kern)
639 DEFINE_WAIT_FUNC(wait, woken_wake_function);
640 struct sock *sk = sock->sk, *ch;
646 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
648 BT_DBG("sk %p timeo %ld", sk, timeo);
650 /* Wait for an incoming connection. (wake-one). */
651 add_wait_queue_exclusive(sk_sleep(sk), &wait);
653 if (sk->sk_state != BT_LISTEN) {
658 ch = bt_accept_dequeue(sk, newsock);
667 if (signal_pending(current)) {
668 err = sock_intr_errno(timeo);
674 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
677 remove_wait_queue(sk_sleep(sk), &wait);
682 newsock->state = SS_CONNECTED;
684 BT_DBG("new socket %p", ch);
691 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
694 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
695 struct sock *sk = sock->sk;
697 BT_DBG("sock %p, sk %p", sock, sk);
699 addr->sa_family = AF_BLUETOOTH;
702 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
704 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
706 return sizeof(struct sockaddr_sco);
709 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
712 struct sock *sk = sock->sk;
716 BT_DBG("sock %p, sk %p", sock, sk);
718 err = sock_error(sk);
722 if (msg->msg_flags & MSG_OOB)
725 buf = kmalloc(len, GFP_KERNEL);
729 if (memcpy_from_msg(buf, msg, len)) {
736 if (sk->sk_state == BT_CONNECTED)
737 err = sco_send_frame(sk, buf, len, msg->msg_flags);
746 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
748 struct hci_dev *hdev = conn->hdev;
750 BT_DBG("conn %p", conn);
752 conn->state = BT_CONFIG;
754 if (!lmp_esco_capable(hdev)) {
755 struct hci_cp_accept_conn_req cp;
757 bacpy(&cp.bdaddr, &conn->dst);
758 cp.role = 0x00; /* Ignored */
760 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
762 struct hci_cp_accept_sync_conn_req cp;
764 bacpy(&cp.bdaddr, &conn->dst);
765 cp.pkt_type = cpu_to_le16(conn->pkt_type);
767 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
768 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
769 cp.content_format = cpu_to_le16(setting);
771 switch (setting & SCO_AIRMODE_MASK) {
772 case SCO_AIRMODE_TRANSP:
773 if (conn->pkt_type & ESCO_2EV3)
774 cp.max_latency = cpu_to_le16(0x0008);
776 cp.max_latency = cpu_to_le16(0x000D);
777 cp.retrans_effort = 0x02;
779 case SCO_AIRMODE_CVSD:
780 cp.max_latency = cpu_to_le16(0xffff);
781 cp.retrans_effort = 0xff;
784 /* use CVSD settings as fallback */
785 cp.max_latency = cpu_to_le16(0xffff);
786 cp.retrans_effort = 0xff;
790 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
795 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
796 size_t len, int flags)
798 struct sock *sk = sock->sk;
799 struct sco_pinfo *pi = sco_pi(sk);
803 if (sk->sk_state == BT_CONNECT2 &&
804 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
805 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
806 sk->sk_state = BT_CONFIG;
814 return bt_sock_recvmsg(sock, msg, len, flags);
817 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
818 char __user *optval, unsigned int optlen)
820 struct sock *sk = sock->sk;
822 struct bt_voice voice;
832 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
837 if (get_user(opt, (u32 __user *) optval)) {
843 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
845 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
849 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
850 sk->sk_state != BT_CONNECT2) {
855 voice.setting = sco_pi(sk)->setting;
857 len = min_t(unsigned int, sizeof(voice), optlen);
858 if (copy_from_user((char *)&voice, optval, len)) {
863 /* Explicitly check for these values */
864 if (voice.setting != BT_VOICE_TRANSPARENT &&
865 voice.setting != BT_VOICE_CVSD_16BIT) {
870 sco_pi(sk)->setting = voice.setting;
882 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
883 char __user *optval, int __user *optlen)
885 struct sock *sk = sock->sk;
886 struct sco_options opts;
887 struct sco_conninfo cinfo;
892 if (get_user(len, optlen))
899 if (sk->sk_state != BT_CONNECTED &&
900 !(sk->sk_state == BT_CONNECT2 &&
901 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
906 opts.mtu = sco_pi(sk)->conn->mtu;
908 BT_DBG("mtu %d", opts.mtu);
910 len = min_t(unsigned int, len, sizeof(opts));
911 if (copy_to_user(optval, (char *)&opts, len))
917 if (sk->sk_state != BT_CONNECTED &&
918 !(sk->sk_state == BT_CONNECT2 &&
919 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
924 memset(&cinfo, 0, sizeof(cinfo));
925 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
926 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
928 len = min_t(unsigned int, len, sizeof(cinfo));
929 if (copy_to_user(optval, (char *)&cinfo, len))
943 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
944 char __user *optval, int __user *optlen)
946 struct sock *sk = sock->sk;
948 struct bt_voice voice;
952 if (level == SOL_SCO)
953 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
955 if (get_user(len, optlen))
963 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
968 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
969 (u32 __user *)optval))
975 voice.setting = sco_pi(sk)->setting;
977 len = min_t(unsigned int, len, sizeof(voice));
978 if (copy_to_user(optval, (char *)&voice, len))
992 static int sco_sock_shutdown(struct socket *sock, int how)
994 struct sock *sk = sock->sk;
997 BT_DBG("sock %p, sk %p", sock, sk);
1005 if (!sk->sk_shutdown) {
1006 sk->sk_shutdown = SHUTDOWN_MASK;
1007 sco_sock_clear_timer(sk);
1008 __sco_sock_close(sk);
1010 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1011 !(current->flags & PF_EXITING))
1012 err = bt_sock_wait_state(sk, BT_CLOSED,
1022 static int sco_sock_release(struct socket *sock)
1024 struct sock *sk = sock->sk;
1027 BT_DBG("sock %p, sk %p", sock, sk);
1034 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1035 !(current->flags & PF_EXITING)) {
1037 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1046 static void sco_conn_ready(struct sco_conn *conn)
1048 struct sock *parent;
1049 struct sock *sk = conn->sk;
1051 BT_DBG("conn %p", conn);
1054 sco_sock_clear_timer(sk);
1056 sk->sk_state = BT_CONNECTED;
1057 sk->sk_state_change(sk);
1060 sco_conn_lock(conn);
1063 sco_conn_unlock(conn);
1067 parent = sco_get_sock_listen(&conn->hcon->src);
1069 sco_conn_unlock(conn);
1073 bh_lock_sock(parent);
1075 sk = sco_sock_alloc(sock_net(parent), NULL,
1076 BTPROTO_SCO, GFP_ATOMIC, 0);
1078 bh_unlock_sock(parent);
1079 sco_conn_unlock(conn);
1083 sco_sock_init(sk, parent);
1085 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1086 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1088 hci_conn_hold(conn->hcon);
1089 __sco_chan_add(conn, sk, parent);
1091 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1092 sk->sk_state = BT_CONNECT2;
1094 sk->sk_state = BT_CONNECTED;
1096 /* Wake up parent */
1097 parent->sk_data_ready(parent);
1099 bh_unlock_sock(parent);
1101 sco_conn_unlock(conn);
1105 /* ----- SCO interface with lower layer (HCI) ----- */
1106 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1111 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1113 /* Find listening sockets */
1114 read_lock(&sco_sk_list.lock);
1115 sk_for_each(sk, &sco_sk_list.head) {
1116 if (sk->sk_state != BT_LISTEN)
1119 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1120 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1121 lm |= HCI_LM_ACCEPT;
1123 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1124 *flags |= HCI_PROTO_DEFER;
1128 read_unlock(&sco_sk_list.lock);
1133 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1135 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1138 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1141 struct sco_conn *conn;
1143 conn = sco_conn_add(hcon);
1145 sco_conn_ready(conn);
1147 sco_conn_del(hcon, bt_to_errno(status));
1150 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1152 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1155 BT_DBG("hcon %p reason %d", hcon, reason);
1157 sco_conn_del(hcon, bt_to_errno(reason));
1160 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1162 struct sco_conn *conn = hcon->sco_data;
1167 BT_DBG("conn %p len %d", conn, skb->len);
1170 sco_recv_frame(conn, skb);
1178 static struct hci_cb sco_cb = {
1180 .connect_cfm = sco_connect_cfm,
1181 .disconn_cfm = sco_disconn_cfm,
1184 static int sco_debugfs_show(struct seq_file *f, void *p)
1188 read_lock(&sco_sk_list.lock);
1190 sk_for_each(sk, &sco_sk_list.head) {
1191 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1192 &sco_pi(sk)->dst, sk->sk_state);
1195 read_unlock(&sco_sk_list.lock);
1200 static int sco_debugfs_open(struct inode *inode, struct file *file)
1202 return single_open(file, sco_debugfs_show, inode->i_private);
1205 static const struct file_operations sco_debugfs_fops = {
1206 .open = sco_debugfs_open,
1208 .llseek = seq_lseek,
1209 .release = single_release,
1212 static struct dentry *sco_debugfs;
1214 static const struct proto_ops sco_sock_ops = {
1215 .family = PF_BLUETOOTH,
1216 .owner = THIS_MODULE,
1217 .release = sco_sock_release,
1218 .bind = sco_sock_bind,
1219 .connect = sco_sock_connect,
1220 .listen = sco_sock_listen,
1221 .accept = sco_sock_accept,
1222 .getname = sco_sock_getname,
1223 .sendmsg = sco_sock_sendmsg,
1224 .recvmsg = sco_sock_recvmsg,
1225 .poll = bt_sock_poll,
1226 .ioctl = bt_sock_ioctl,
1227 .mmap = sock_no_mmap,
1228 .socketpair = sock_no_socketpair,
1229 .shutdown = sco_sock_shutdown,
1230 .setsockopt = sco_sock_setsockopt,
1231 .getsockopt = sco_sock_getsockopt
1234 static const struct net_proto_family sco_sock_family_ops = {
1235 .family = PF_BLUETOOTH,
1236 .owner = THIS_MODULE,
1237 .create = sco_sock_create,
1240 int __init sco_init(void)
1244 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1246 err = proto_register(&sco_proto, 0);
1250 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1252 BT_ERR("SCO socket registration failed");
1256 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1258 BT_ERR("Failed to create SCO proc file");
1259 bt_sock_unregister(BTPROTO_SCO);
1263 BT_INFO("SCO socket layer initialized");
1265 hci_register_cb(&sco_cb);
1267 if (IS_ERR_OR_NULL(bt_debugfs))
1270 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1271 NULL, &sco_debugfs_fops);
1276 proto_unregister(&sco_proto);
1282 bt_procfs_cleanup(&init_net, "sco");
1284 debugfs_remove(sco_debugfs);
1286 hci_unregister_cb(&sco_cb);
1288 bt_sock_unregister(BTPROTO_SCO);
1290 proto_unregister(&sco_proto);
1293 module_param(disable_esco, bool, 0644);
1294 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");