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;
54 #define sco_conn_lock(c) spin_lock(&c->lock);
55 #define sco_conn_unlock(c) spin_unlock(&c->lock);
57 static void sco_sock_close(struct sock *sk);
58 static void sco_sock_kill(struct sock *sk);
60 /* ----- SCO socket info ----- */
61 #define sco_pi(sk) ((struct sco_pinfo *) sk)
69 struct sco_conn *conn;
72 /* ---- SCO timers ---- */
73 #define SCO_CONN_TIMEOUT (HZ * 40)
74 #define SCO_DISCONN_TIMEOUT (HZ * 2)
76 static void sco_sock_timeout(unsigned long arg)
78 struct sock *sk = (struct sock *)arg;
80 BT_DBG("sock %p state %d", sk, sk->sk_state);
83 sk->sk_err = ETIMEDOUT;
84 sk->sk_state_change(sk);
90 static void sco_sock_set_timer(struct sock *sk, long timeout)
92 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
93 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
96 static void sco_sock_clear_timer(struct sock *sk)
98 BT_DBG("sock %p state %d", sk, sk->sk_state);
99 sk_stop_timer(sk, &sk->sk_timer);
102 /* ---- SCO connections ---- */
103 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
105 struct hci_dev *hdev = hcon->hdev;
106 struct sco_conn *conn = hcon->sco_data;
111 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
115 spin_lock_init(&conn->lock);
117 hcon->sco_data = conn;
120 if (hdev->sco_mtu > 0)
121 conn->mtu = hdev->sco_mtu;
125 BT_DBG("hcon %p conn %p", hcon, conn);
131 * Must be called on the locked socket. */
132 static void sco_chan_del(struct sock *sk, int err)
134 struct sco_conn *conn;
136 conn = sco_pi(sk)->conn;
138 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
143 sco_pi(sk)->conn = NULL;
144 sco_conn_unlock(conn);
147 hci_conn_drop(conn->hcon);
150 sk->sk_state = BT_CLOSED;
152 sk->sk_state_change(sk);
154 sock_set_flag(sk, SOCK_ZAPPED);
157 static void sco_conn_del(struct hci_conn *hcon, int err)
159 struct sco_conn *conn = hcon->sco_data;
165 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
170 sco_conn_unlock(conn);
175 sco_sock_clear_timer(sk);
176 sco_chan_del(sk, err);
181 hcon->sco_data = NULL;
185 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
188 BT_DBG("conn %p", conn);
190 sco_pi(sk)->conn = conn;
194 bt_accept_enqueue(parent, sk, true);
197 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
206 __sco_chan_add(conn, sk, parent);
208 sco_conn_unlock(conn);
212 static int sco_connect(struct hci_dev *hdev, struct sock *sk)
214 struct sco_conn *conn;
215 struct hci_conn *hcon;
218 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
220 if (lmp_esco_capable(hdev) && !disable_esco)
225 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
226 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev)))
229 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
230 sco_pi(sk)->setting);
232 return PTR_ERR(hcon);
234 conn = sco_conn_add(hcon);
240 /* Update source addr of the socket */
241 bacpy(&sco_pi(sk)->src, &hcon->src);
243 err = sco_chan_add(conn, sk, NULL);
247 if (hcon->state == BT_CONNECTED) {
248 sco_sock_clear_timer(sk);
249 sk->sk_state = BT_CONNECTED;
251 sk->sk_state = BT_CONNECT;
252 sco_sock_set_timer(sk, sk->sk_sndtimeo);
258 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
260 struct sco_conn *conn = sco_pi(sk)->conn;
264 /* Check outgoing MTU */
268 BT_DBG("sk %p len %d", sk, len);
270 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
274 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
279 hci_send_sco(conn->hcon, skb);
284 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
290 sco_conn_unlock(conn);
295 BT_DBG("sk %p len %d", sk, skb->len);
297 if (sk->sk_state != BT_CONNECTED)
300 if (!sock_queue_rcv_skb(sk, skb))
307 /* -------- Socket interface ---------- */
308 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
312 sk_for_each(sk, &sco_sk_list.head) {
313 if (sk->sk_state != BT_LISTEN)
316 if (!bacmp(&sco_pi(sk)->src, ba))
323 /* Find socket listening on source bdaddr.
324 * Returns closest match.
326 static struct sock *sco_get_sock_listen(bdaddr_t *src)
328 struct sock *sk = NULL, *sk1 = NULL;
330 read_lock(&sco_sk_list.lock);
332 sk_for_each(sk, &sco_sk_list.head) {
333 if (sk->sk_state != BT_LISTEN)
337 if (!bacmp(&sco_pi(sk)->src, src))
341 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
345 read_unlock(&sco_sk_list.lock);
347 return sk ? sk : sk1;
350 static void sco_sock_destruct(struct sock *sk)
354 skb_queue_purge(&sk->sk_receive_queue);
355 skb_queue_purge(&sk->sk_write_queue);
358 static void sco_sock_cleanup_listen(struct sock *parent)
362 BT_DBG("parent %p", parent);
364 /* Close not yet accepted channels */
365 while ((sk = bt_accept_dequeue(parent, NULL))) {
370 parent->sk_state = BT_CLOSED;
371 sock_set_flag(parent, SOCK_ZAPPED);
374 /* Kill socket (only if zapped and orphan)
375 * Must be called on unlocked socket.
377 static void sco_sock_kill(struct sock *sk)
379 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
382 BT_DBG("sk %p state %d", sk, sk->sk_state);
384 /* Kill poor orphan */
385 bt_sock_unlink(&sco_sk_list, sk);
386 sock_set_flag(sk, SOCK_DEAD);
390 static void __sco_sock_close(struct sock *sk)
392 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
394 switch (sk->sk_state) {
396 sco_sock_cleanup_listen(sk);
401 if (sco_pi(sk)->conn->hcon) {
402 sk->sk_state = BT_DISCONN;
403 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
404 sco_conn_lock(sco_pi(sk)->conn);
405 hci_conn_drop(sco_pi(sk)->conn->hcon);
406 sco_pi(sk)->conn->hcon = NULL;
407 sco_conn_unlock(sco_pi(sk)->conn);
409 sco_chan_del(sk, ECONNRESET);
415 sco_chan_del(sk, ECONNRESET);
419 sock_set_flag(sk, SOCK_ZAPPED);
424 /* Must be called on unlocked socket. */
425 static void sco_sock_close(struct sock *sk)
427 sco_sock_clear_timer(sk);
429 __sco_sock_close(sk);
433 static void sco_sock_init(struct sock *sk, struct sock *parent)
438 sk->sk_type = parent->sk_type;
439 bt_sk(sk)->flags = bt_sk(parent)->flags;
440 security_sk_clone(parent, sk);
444 static struct proto sco_proto = {
446 .owner = THIS_MODULE,
447 .obj_size = sizeof(struct sco_pinfo)
450 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
451 int proto, gfp_t prio, int kern)
455 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
459 sock_init_data(sock, sk);
460 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
462 sk->sk_destruct = sco_sock_destruct;
463 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
465 sock_reset_flag(sk, SOCK_ZAPPED);
467 sk->sk_protocol = proto;
468 sk->sk_state = BT_OPEN;
470 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
472 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
474 bt_sock_link(&sco_sk_list, sk);
478 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
483 BT_DBG("sock %p", sock);
485 sock->state = SS_UNCONNECTED;
487 if (sock->type != SOCK_SEQPACKET)
488 return -ESOCKTNOSUPPORT;
490 sock->ops = &sco_sock_ops;
492 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
496 sco_sock_init(sk, NULL);
500 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
503 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
504 struct sock *sk = sock->sk;
507 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
509 if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
510 addr->sa_family != AF_BLUETOOTH)
515 if (sk->sk_state != BT_OPEN) {
520 if (sk->sk_type != SOCK_SEQPACKET) {
525 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
527 sk->sk_state = BT_BOUND;
534 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
536 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
537 struct sock *sk = sock->sk;
538 struct hci_dev *hdev;
543 if (alen < sizeof(struct sockaddr_sco) ||
544 addr->sa_family != AF_BLUETOOTH)
547 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
550 if (sk->sk_type != SOCK_SEQPACKET)
553 hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
555 return -EHOSTUNREACH;
560 /* Set destination address and psm */
561 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
563 err = sco_connect(hdev, sk);
564 hci_dev_unlock(hdev);
569 err = bt_sock_wait_state(sk, BT_CONNECTED,
570 sock_sndtimeo(sk, flags & O_NONBLOCK));
577 static int sco_sock_listen(struct socket *sock, int backlog)
579 struct sock *sk = sock->sk;
580 bdaddr_t *src = &sco_pi(sk)->src;
583 BT_DBG("sk %p backlog %d", sk, backlog);
587 if (sk->sk_state != BT_BOUND) {
592 if (sk->sk_type != SOCK_SEQPACKET) {
597 write_lock(&sco_sk_list.lock);
599 if (__sco_get_sock_listen_by_addr(src)) {
604 sk->sk_max_ack_backlog = backlog;
605 sk->sk_ack_backlog = 0;
607 sk->sk_state = BT_LISTEN;
610 write_unlock(&sco_sk_list.lock);
617 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
618 int flags, bool kern)
620 DEFINE_WAIT_FUNC(wait, woken_wake_function);
621 struct sock *sk = sock->sk, *ch;
627 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
629 BT_DBG("sk %p timeo %ld", sk, timeo);
631 /* Wait for an incoming connection. (wake-one). */
632 add_wait_queue_exclusive(sk_sleep(sk), &wait);
634 if (sk->sk_state != BT_LISTEN) {
639 ch = bt_accept_dequeue(sk, newsock);
648 if (signal_pending(current)) {
649 err = sock_intr_errno(timeo);
655 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
658 remove_wait_queue(sk_sleep(sk), &wait);
663 newsock->state = SS_CONNECTED;
665 BT_DBG("new socket %p", ch);
672 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
675 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
676 struct sock *sk = sock->sk;
678 BT_DBG("sock %p, sk %p", sock, sk);
680 addr->sa_family = AF_BLUETOOTH;
681 *len = sizeof(struct sockaddr_sco);
684 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
686 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
691 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
694 struct sock *sk = sock->sk;
697 BT_DBG("sock %p, sk %p", sock, sk);
699 err = sock_error(sk);
703 if (msg->msg_flags & MSG_OOB)
708 if (sk->sk_state == BT_CONNECTED)
709 err = sco_send_frame(sk, msg, len);
717 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
719 struct hci_dev *hdev = conn->hdev;
721 BT_DBG("conn %p", conn);
723 conn->state = BT_CONFIG;
725 if (!lmp_esco_capable(hdev)) {
726 struct hci_cp_accept_conn_req cp;
728 bacpy(&cp.bdaddr, &conn->dst);
729 cp.role = 0x00; /* Ignored */
731 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
733 struct hci_cp_accept_sync_conn_req cp;
735 bacpy(&cp.bdaddr, &conn->dst);
736 cp.pkt_type = cpu_to_le16(conn->pkt_type);
738 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
739 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
740 cp.content_format = cpu_to_le16(setting);
742 switch (setting & SCO_AIRMODE_MASK) {
743 case SCO_AIRMODE_TRANSP:
744 if (conn->pkt_type & ESCO_2EV3)
745 cp.max_latency = cpu_to_le16(0x0008);
747 cp.max_latency = cpu_to_le16(0x000D);
748 cp.retrans_effort = 0x02;
750 case SCO_AIRMODE_CVSD:
751 cp.max_latency = cpu_to_le16(0xffff);
752 cp.retrans_effort = 0xff;
755 /* use CVSD settings as fallback */
756 cp.max_latency = cpu_to_le16(0xffff);
757 cp.retrans_effort = 0xff;
761 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
766 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
767 size_t len, int flags)
769 struct sock *sk = sock->sk;
770 struct sco_pinfo *pi = sco_pi(sk);
774 if (sk->sk_state == BT_CONNECT2 &&
775 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
776 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
777 sk->sk_state = BT_CONFIG;
785 return bt_sock_recvmsg(sock, msg, len, flags);
788 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
789 char __user *optval, unsigned int optlen)
791 struct sock *sk = sock->sk;
793 struct bt_voice voice;
803 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
808 if (get_user(opt, (u32 __user *) optval)) {
814 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
816 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
820 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
821 sk->sk_state != BT_CONNECT2) {
826 voice.setting = sco_pi(sk)->setting;
828 len = min_t(unsigned int, sizeof(voice), optlen);
829 if (copy_from_user((char *)&voice, optval, len)) {
834 /* Explicitly check for these values */
835 if (voice.setting != BT_VOICE_TRANSPARENT &&
836 voice.setting != BT_VOICE_CVSD_16BIT) {
841 sco_pi(sk)->setting = voice.setting;
853 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
854 char __user *optval, int __user *optlen)
856 struct sock *sk = sock->sk;
857 struct sco_options opts;
858 struct sco_conninfo cinfo;
863 if (get_user(len, optlen))
870 if (sk->sk_state != BT_CONNECTED &&
871 !(sk->sk_state == BT_CONNECT2 &&
872 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
877 opts.mtu = sco_pi(sk)->conn->mtu;
879 BT_DBG("mtu %d", opts.mtu);
881 len = min_t(unsigned int, len, sizeof(opts));
882 if (copy_to_user(optval, (char *)&opts, len))
888 if (sk->sk_state != BT_CONNECTED &&
889 !(sk->sk_state == BT_CONNECT2 &&
890 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
895 memset(&cinfo, 0, sizeof(cinfo));
896 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
897 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
899 len = min_t(unsigned int, len, sizeof(cinfo));
900 if (copy_to_user(optval, (char *)&cinfo, len))
914 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
915 char __user *optval, int __user *optlen)
917 struct sock *sk = sock->sk;
919 struct bt_voice voice;
923 if (level == SOL_SCO)
924 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
926 if (get_user(len, optlen))
934 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
939 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
940 (u32 __user *)optval))
946 voice.setting = sco_pi(sk)->setting;
948 len = min_t(unsigned int, len, sizeof(voice));
949 if (copy_to_user(optval, (char *)&voice, len))
963 static int sco_sock_shutdown(struct socket *sock, int how)
965 struct sock *sk = sock->sk;
968 BT_DBG("sock %p, sk %p", sock, sk);
976 if (!sk->sk_shutdown) {
977 sk->sk_shutdown = SHUTDOWN_MASK;
978 sco_sock_clear_timer(sk);
979 __sco_sock_close(sk);
981 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
982 !(current->flags & PF_EXITING))
983 err = bt_sock_wait_state(sk, BT_CLOSED,
993 static int sco_sock_release(struct socket *sock)
995 struct sock *sk = sock->sk;
998 BT_DBG("sock %p, sk %p", sock, sk);
1005 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1006 !(current->flags & PF_EXITING)) {
1008 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1017 static void sco_conn_ready(struct sco_conn *conn)
1019 struct sock *parent;
1020 struct sock *sk = conn->sk;
1022 BT_DBG("conn %p", conn);
1025 sco_sock_clear_timer(sk);
1027 sk->sk_state = BT_CONNECTED;
1028 sk->sk_state_change(sk);
1031 sco_conn_lock(conn);
1034 sco_conn_unlock(conn);
1038 parent = sco_get_sock_listen(&conn->hcon->src);
1040 sco_conn_unlock(conn);
1044 bh_lock_sock(parent);
1046 sk = sco_sock_alloc(sock_net(parent), NULL,
1047 BTPROTO_SCO, GFP_ATOMIC, 0);
1049 bh_unlock_sock(parent);
1050 sco_conn_unlock(conn);
1054 sco_sock_init(sk, parent);
1056 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1057 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1059 hci_conn_hold(conn->hcon);
1060 __sco_chan_add(conn, sk, parent);
1062 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1063 sk->sk_state = BT_CONNECT2;
1065 sk->sk_state = BT_CONNECTED;
1067 /* Wake up parent */
1068 parent->sk_data_ready(parent);
1070 bh_unlock_sock(parent);
1072 sco_conn_unlock(conn);
1076 /* ----- SCO interface with lower layer (HCI) ----- */
1077 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1082 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1084 /* Find listening sockets */
1085 read_lock(&sco_sk_list.lock);
1086 sk_for_each(sk, &sco_sk_list.head) {
1087 if (sk->sk_state != BT_LISTEN)
1090 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1091 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1092 lm |= HCI_LM_ACCEPT;
1094 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1095 *flags |= HCI_PROTO_DEFER;
1099 read_unlock(&sco_sk_list.lock);
1104 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1106 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1109 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1112 struct sco_conn *conn;
1114 conn = sco_conn_add(hcon);
1116 sco_conn_ready(conn);
1118 sco_conn_del(hcon, bt_to_errno(status));
1121 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1123 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1126 BT_DBG("hcon %p reason %d", hcon, reason);
1128 sco_conn_del(hcon, bt_to_errno(reason));
1131 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1133 struct sco_conn *conn = hcon->sco_data;
1138 BT_DBG("conn %p len %d", conn, skb->len);
1141 sco_recv_frame(conn, skb);
1149 static struct hci_cb sco_cb = {
1151 .connect_cfm = sco_connect_cfm,
1152 .disconn_cfm = sco_disconn_cfm,
1155 static int sco_debugfs_show(struct seq_file *f, void *p)
1159 read_lock(&sco_sk_list.lock);
1161 sk_for_each(sk, &sco_sk_list.head) {
1162 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1163 &sco_pi(sk)->dst, sk->sk_state);
1166 read_unlock(&sco_sk_list.lock);
1171 static int sco_debugfs_open(struct inode *inode, struct file *file)
1173 return single_open(file, sco_debugfs_show, inode->i_private);
1176 static const struct file_operations sco_debugfs_fops = {
1177 .open = sco_debugfs_open,
1179 .llseek = seq_lseek,
1180 .release = single_release,
1183 static struct dentry *sco_debugfs;
1185 static const struct proto_ops sco_sock_ops = {
1186 .family = PF_BLUETOOTH,
1187 .owner = THIS_MODULE,
1188 .release = sco_sock_release,
1189 .bind = sco_sock_bind,
1190 .connect = sco_sock_connect,
1191 .listen = sco_sock_listen,
1192 .accept = sco_sock_accept,
1193 .getname = sco_sock_getname,
1194 .sendmsg = sco_sock_sendmsg,
1195 .recvmsg = sco_sock_recvmsg,
1196 .poll = bt_sock_poll,
1197 .ioctl = bt_sock_ioctl,
1198 .mmap = sock_no_mmap,
1199 .socketpair = sock_no_socketpair,
1200 .shutdown = sco_sock_shutdown,
1201 .setsockopt = sco_sock_setsockopt,
1202 .getsockopt = sco_sock_getsockopt
1205 static const struct net_proto_family sco_sock_family_ops = {
1206 .family = PF_BLUETOOTH,
1207 .owner = THIS_MODULE,
1208 .create = sco_sock_create,
1211 int __init sco_init(void)
1215 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1217 err = proto_register(&sco_proto, 0);
1221 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1223 BT_ERR("SCO socket registration failed");
1227 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1229 BT_ERR("Failed to create SCO proc file");
1230 bt_sock_unregister(BTPROTO_SCO);
1234 BT_INFO("SCO socket layer initialized");
1236 hci_register_cb(&sco_cb);
1238 if (IS_ERR_OR_NULL(bt_debugfs))
1241 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1242 NULL, &sco_debugfs_fops);
1247 proto_unregister(&sco_proto);
1253 bt_procfs_cleanup(&init_net, "sco");
1255 debugfs_remove(sco_debugfs);
1257 hci_unregister_cb(&sco_cb);
1259 bt_sock_unregister(BTPROTO_SCO);
1261 proto_unregister(&sco_proto);
1264 module_param(disable_esco, bool, 0644);
1265 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");