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)
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);
104 static void sco_sock_set_timer(struct sock *sk, long timeout)
106 if (!sco_pi(sk)->conn)
109 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
110 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
111 schedule_delayed_work(&sco_pi(sk)->conn->timeout_work, timeout);
114 static void sco_sock_clear_timer(struct sock *sk)
116 if (!sco_pi(sk)->conn)
119 BT_DBG("sock %p state %d", sk, sk->sk_state);
120 cancel_delayed_work(&sco_pi(sk)->conn->timeout_work);
123 /* ---- SCO connections ---- */
124 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
126 struct hci_dev *hdev = hcon->hdev;
127 struct sco_conn *conn = hcon->sco_data;
132 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
136 spin_lock_init(&conn->lock);
137 INIT_DELAYED_WORK(&conn->timeout_work, sco_sock_timeout);
139 hcon->sco_data = conn;
142 if (hdev->sco_mtu > 0)
143 conn->mtu = hdev->sco_mtu;
147 BT_DBG("hcon %p conn %p", hcon, conn);
153 * Must be called on the locked socket. */
154 static void sco_chan_del(struct sock *sk, int err)
156 struct sco_conn *conn;
158 conn = sco_pi(sk)->conn;
160 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
165 sco_pi(sk)->conn = NULL;
166 sco_conn_unlock(conn);
169 hci_conn_drop(conn->hcon);
172 sk->sk_state = BT_CLOSED;
174 sk->sk_state_change(sk);
176 sock_set_flag(sk, SOCK_ZAPPED);
179 static void sco_conn_del(struct hci_conn *hcon, int err)
181 struct sco_conn *conn = hcon->sco_data;
187 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
192 sco_conn_unlock(conn);
197 sco_sock_clear_timer(sk);
198 sco_chan_del(sk, err);
203 /* Ensure no more work items will run before freeing conn. */
204 cancel_delayed_work_sync(&conn->timeout_work);
206 hcon->sco_data = NULL;
210 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
213 BT_DBG("conn %p", conn);
215 sco_pi(sk)->conn = conn;
219 bt_accept_enqueue(parent, sk, true);
222 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
231 __sco_chan_add(conn, sk, parent);
233 sco_conn_unlock(conn);
237 static int sco_connect(struct hci_dev *hdev, struct sock *sk)
239 struct sco_conn *conn;
240 struct hci_conn *hcon;
243 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
245 if (lmp_esco_capable(hdev) && !disable_esco)
250 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
251 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev)))
254 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
255 sco_pi(sk)->setting);
257 return PTR_ERR(hcon);
259 conn = sco_conn_add(hcon);
265 /* Update source addr of the socket */
266 bacpy(&sco_pi(sk)->src, &hcon->src);
268 err = sco_chan_add(conn, sk, NULL);
272 if (hcon->state == BT_CONNECTED) {
273 sco_sock_clear_timer(sk);
274 sk->sk_state = BT_CONNECTED;
276 sk->sk_state = BT_CONNECT;
277 sco_sock_set_timer(sk, sk->sk_sndtimeo);
283 static int sco_send_frame(struct sock *sk, struct sk_buff *skb)
285 struct sco_conn *conn = sco_pi(sk)->conn;
288 /* Check outgoing MTU */
292 BT_DBG("sk %p len %d", sk, len);
294 hci_send_sco(conn->hcon, skb);
299 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
305 sco_conn_unlock(conn);
310 BT_DBG("sk %p len %d", sk, skb->len);
312 if (sk->sk_state != BT_CONNECTED)
315 if (!sock_queue_rcv_skb(sk, skb))
322 /* -------- Socket interface ---------- */
323 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
327 sk_for_each(sk, &sco_sk_list.head) {
328 if (sk->sk_state != BT_LISTEN)
331 if (!bacmp(&sco_pi(sk)->src, ba))
338 /* Find socket listening on source bdaddr.
339 * Returns closest match.
341 static struct sock *sco_get_sock_listen(bdaddr_t *src)
343 struct sock *sk = NULL, *sk1 = NULL;
345 read_lock(&sco_sk_list.lock);
347 sk_for_each(sk, &sco_sk_list.head) {
348 if (sk->sk_state != BT_LISTEN)
352 if (!bacmp(&sco_pi(sk)->src, src))
356 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
360 read_unlock(&sco_sk_list.lock);
362 return sk ? sk : sk1;
365 static void sco_sock_destruct(struct sock *sk)
369 skb_queue_purge(&sk->sk_receive_queue);
370 skb_queue_purge(&sk->sk_write_queue);
373 static void sco_sock_cleanup_listen(struct sock *parent)
377 BT_DBG("parent %p", parent);
379 /* Close not yet accepted channels */
380 while ((sk = bt_accept_dequeue(parent, NULL))) {
385 parent->sk_state = BT_CLOSED;
386 sock_set_flag(parent, SOCK_ZAPPED);
389 /* Kill socket (only if zapped and orphan)
390 * Must be called on unlocked socket.
392 static void sco_sock_kill(struct sock *sk)
394 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
397 BT_DBG("sk %p state %d", sk, sk->sk_state);
399 /* Kill poor orphan */
400 bt_sock_unlink(&sco_sk_list, sk);
401 sock_set_flag(sk, SOCK_DEAD);
405 static void __sco_sock_close(struct sock *sk)
407 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
409 switch (sk->sk_state) {
411 sco_sock_cleanup_listen(sk);
416 if (sco_pi(sk)->conn->hcon) {
417 sk->sk_state = BT_DISCONN;
418 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
419 sco_conn_lock(sco_pi(sk)->conn);
420 hci_conn_drop(sco_pi(sk)->conn->hcon);
421 sco_pi(sk)->conn->hcon = NULL;
422 sco_conn_unlock(sco_pi(sk)->conn);
424 sco_chan_del(sk, ECONNRESET);
430 sco_chan_del(sk, ECONNRESET);
434 sock_set_flag(sk, SOCK_ZAPPED);
439 /* Must be called on unlocked socket. */
440 static void sco_sock_close(struct sock *sk)
442 sco_sock_clear_timer(sk);
444 __sco_sock_close(sk);
448 static void sco_skb_put_cmsg(struct sk_buff *skb, struct msghdr *msg,
451 if (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS)
452 put_cmsg(msg, SOL_BLUETOOTH, BT_SCM_PKT_STATUS,
453 sizeof(bt_cb(skb)->sco.pkt_status),
454 &bt_cb(skb)->sco.pkt_status);
457 static void sco_sock_init(struct sock *sk, struct sock *parent)
462 sk->sk_type = parent->sk_type;
463 bt_sk(sk)->flags = bt_sk(parent)->flags;
464 security_sk_clone(parent, sk);
466 bt_sk(sk)->skb_put_cmsg = sco_skb_put_cmsg;
470 static struct proto sco_proto = {
472 .owner = THIS_MODULE,
473 .obj_size = sizeof(struct sco_pinfo)
476 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
477 int proto, gfp_t prio, int kern)
481 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
485 sock_init_data(sock, sk);
486 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
488 sk->sk_destruct = sco_sock_destruct;
489 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
491 sock_reset_flag(sk, SOCK_ZAPPED);
493 sk->sk_protocol = proto;
494 sk->sk_state = BT_OPEN;
496 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
498 bt_sock_link(&sco_sk_list, sk);
502 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
507 BT_DBG("sock %p", sock);
509 sock->state = SS_UNCONNECTED;
511 if (sock->type != SOCK_SEQPACKET)
512 return -ESOCKTNOSUPPORT;
514 sock->ops = &sco_sock_ops;
516 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
520 sco_sock_init(sk, NULL);
524 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
527 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
528 struct sock *sk = sock->sk;
531 if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
532 addr->sa_family != AF_BLUETOOTH)
535 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
539 if (sk->sk_state != BT_OPEN) {
544 if (sk->sk_type != SOCK_SEQPACKET) {
549 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
551 sk->sk_state = BT_BOUND;
558 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
560 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
561 struct sock *sk = sock->sk;
562 struct hci_dev *hdev;
567 if (alen < sizeof(struct sockaddr_sco) ||
568 addr->sa_family != AF_BLUETOOTH)
572 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
577 if (sk->sk_type != SOCK_SEQPACKET) {
582 hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
589 /* Set destination address and psm */
590 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
592 err = sco_connect(hdev, sk);
593 hci_dev_unlock(hdev);
598 err = bt_sock_wait_state(sk, BT_CONNECTED,
599 sock_sndtimeo(sk, flags & O_NONBLOCK));
606 static int sco_sock_listen(struct socket *sock, int backlog)
608 struct sock *sk = sock->sk;
609 bdaddr_t *src = &sco_pi(sk)->src;
612 BT_DBG("sk %p backlog %d", sk, backlog);
616 if (sk->sk_state != BT_BOUND) {
621 if (sk->sk_type != SOCK_SEQPACKET) {
626 write_lock(&sco_sk_list.lock);
628 if (__sco_get_sock_listen_by_addr(src)) {
633 sk->sk_max_ack_backlog = backlog;
634 sk->sk_ack_backlog = 0;
636 sk->sk_state = BT_LISTEN;
639 write_unlock(&sco_sk_list.lock);
646 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
647 int flags, bool kern)
649 DEFINE_WAIT_FUNC(wait, woken_wake_function);
650 struct sock *sk = sock->sk, *ch;
656 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
658 BT_DBG("sk %p timeo %ld", sk, timeo);
660 /* Wait for an incoming connection. (wake-one). */
661 add_wait_queue_exclusive(sk_sleep(sk), &wait);
663 if (sk->sk_state != BT_LISTEN) {
668 ch = bt_accept_dequeue(sk, newsock);
677 if (signal_pending(current)) {
678 err = sock_intr_errno(timeo);
684 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
687 remove_wait_queue(sk_sleep(sk), &wait);
692 newsock->state = SS_CONNECTED;
694 BT_DBG("new socket %p", ch);
701 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
704 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
705 struct sock *sk = sock->sk;
707 BT_DBG("sock %p, sk %p", sock, sk);
709 addr->sa_family = AF_BLUETOOTH;
712 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
714 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
716 return sizeof(struct sockaddr_sco);
719 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
722 struct sock *sk = sock->sk;
726 BT_DBG("sock %p, sk %p", sock, sk);
728 err = sock_error(sk);
732 if (msg->msg_flags & MSG_OOB)
735 skb = bt_skb_sendmsg(sk, msg, len, len, 0, 0);
741 if (sk->sk_state == BT_CONNECTED)
742 err = sco_send_frame(sk, skb);
753 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
755 struct hci_dev *hdev = conn->hdev;
757 BT_DBG("conn %p", conn);
759 conn->state = BT_CONFIG;
761 if (!lmp_esco_capable(hdev)) {
762 struct hci_cp_accept_conn_req cp;
764 bacpy(&cp.bdaddr, &conn->dst);
765 cp.role = 0x00; /* Ignored */
767 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
769 struct hci_cp_accept_sync_conn_req cp;
771 bacpy(&cp.bdaddr, &conn->dst);
772 cp.pkt_type = cpu_to_le16(conn->pkt_type);
774 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
775 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
776 cp.content_format = cpu_to_le16(setting);
778 switch (setting & SCO_AIRMODE_MASK) {
779 case SCO_AIRMODE_TRANSP:
780 if (conn->pkt_type & ESCO_2EV3)
781 cp.max_latency = cpu_to_le16(0x0008);
783 cp.max_latency = cpu_to_le16(0x000D);
784 cp.retrans_effort = 0x02;
786 case SCO_AIRMODE_CVSD:
787 cp.max_latency = cpu_to_le16(0xffff);
788 cp.retrans_effort = 0xff;
791 /* use CVSD settings as fallback */
792 cp.max_latency = cpu_to_le16(0xffff);
793 cp.retrans_effort = 0xff;
797 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
802 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
803 size_t len, int flags)
805 struct sock *sk = sock->sk;
806 struct sco_pinfo *pi = sco_pi(sk);
810 if (sk->sk_state == BT_CONNECT2 &&
811 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
812 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
813 sk->sk_state = BT_CONFIG;
821 return bt_sock_recvmsg(sock, msg, len, flags);
824 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
825 sockptr_t optval, unsigned int optlen)
827 struct sock *sk = sock->sk;
829 struct bt_voice voice;
839 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
844 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
850 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
852 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
856 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
857 sk->sk_state != BT_CONNECT2) {
862 voice.setting = sco_pi(sk)->setting;
864 len = min_t(unsigned int, sizeof(voice), optlen);
865 if (copy_from_sockptr(&voice, optval, len)) {
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;
881 if (copy_from_sockptr(&opt, optval, sizeof(u32))) {
887 sco_pi(sk)->cmsg_mask |= SCO_CMSG_PKT_STATUS;
889 sco_pi(sk)->cmsg_mask &= SCO_CMSG_PKT_STATUS;
901 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
902 char __user *optval, int __user *optlen)
904 struct sock *sk = sock->sk;
905 struct sco_options opts;
906 struct sco_conninfo cinfo;
911 if (get_user(len, optlen))
918 if (sk->sk_state != BT_CONNECTED &&
919 !(sk->sk_state == BT_CONNECT2 &&
920 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
925 opts.mtu = sco_pi(sk)->conn->mtu;
927 BT_DBG("mtu %d", opts.mtu);
929 len = min_t(unsigned int, len, sizeof(opts));
930 if (copy_to_user(optval, (char *)&opts, len))
936 if (sk->sk_state != BT_CONNECTED &&
937 !(sk->sk_state == BT_CONNECT2 &&
938 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
943 memset(&cinfo, 0, sizeof(cinfo));
944 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
945 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
947 len = min_t(unsigned int, len, sizeof(cinfo));
948 if (copy_to_user(optval, (char *)&cinfo, len))
962 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
963 char __user *optval, int __user *optlen)
965 struct sock *sk = sock->sk;
967 struct bt_voice voice;
973 if (level == SOL_SCO)
974 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
976 if (get_user(len, optlen))
984 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
989 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
990 (u32 __user *)optval))
996 voice.setting = sco_pi(sk)->setting;
998 len = min_t(unsigned int, len, sizeof(voice));
999 if (copy_to_user(optval, (char *)&voice, len))
1005 if (sk->sk_state != BT_CONNECTED) {
1010 phys = hci_conn_get_phy(sco_pi(sk)->conn->hcon);
1012 if (put_user(phys, (u32 __user *) optval))
1017 pkt_status = (sco_pi(sk)->cmsg_mask & SCO_CMSG_PKT_STATUS);
1019 if (put_user(pkt_status, (int __user *)optval))
1025 if (sk->sk_state != BT_CONNECTED) {
1030 if (put_user(sco_pi(sk)->conn->mtu, (u32 __user *)optval))
1043 static int sco_sock_shutdown(struct socket *sock, int how)
1045 struct sock *sk = sock->sk;
1048 BT_DBG("sock %p, sk %p", sock, sk);
1056 if (!sk->sk_shutdown) {
1057 sk->sk_shutdown = SHUTDOWN_MASK;
1058 sco_sock_clear_timer(sk);
1059 __sco_sock_close(sk);
1061 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1062 !(current->flags & PF_EXITING))
1063 err = bt_sock_wait_state(sk, BT_CLOSED,
1073 static int sco_sock_release(struct socket *sock)
1075 struct sock *sk = sock->sk;
1078 BT_DBG("sock %p, sk %p", sock, sk);
1085 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1086 !(current->flags & PF_EXITING)) {
1088 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1097 static void sco_conn_ready(struct sco_conn *conn)
1099 struct sock *parent;
1100 struct sock *sk = conn->sk;
1102 BT_DBG("conn %p", conn);
1105 sco_sock_clear_timer(sk);
1107 sk->sk_state = BT_CONNECTED;
1108 sk->sk_state_change(sk);
1111 sco_conn_lock(conn);
1114 sco_conn_unlock(conn);
1118 parent = sco_get_sock_listen(&conn->hcon->src);
1120 sco_conn_unlock(conn);
1124 bh_lock_sock(parent);
1126 sk = sco_sock_alloc(sock_net(parent), NULL,
1127 BTPROTO_SCO, GFP_ATOMIC, 0);
1129 bh_unlock_sock(parent);
1130 sco_conn_unlock(conn);
1134 sco_sock_init(sk, parent);
1136 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1137 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1139 hci_conn_hold(conn->hcon);
1140 __sco_chan_add(conn, sk, parent);
1142 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1143 sk->sk_state = BT_CONNECT2;
1145 sk->sk_state = BT_CONNECTED;
1147 /* Wake up parent */
1148 parent->sk_data_ready(parent);
1150 bh_unlock_sock(parent);
1152 sco_conn_unlock(conn);
1156 /* ----- SCO interface with lower layer (HCI) ----- */
1157 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1162 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1164 /* Find listening sockets */
1165 read_lock(&sco_sk_list.lock);
1166 sk_for_each(sk, &sco_sk_list.head) {
1167 if (sk->sk_state != BT_LISTEN)
1170 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1171 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1172 lm |= HCI_LM_ACCEPT;
1174 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1175 *flags |= HCI_PROTO_DEFER;
1179 read_unlock(&sco_sk_list.lock);
1184 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1186 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1189 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1192 struct sco_conn *conn;
1194 conn = sco_conn_add(hcon);
1196 sco_conn_ready(conn);
1198 sco_conn_del(hcon, bt_to_errno(status));
1201 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1203 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1206 BT_DBG("hcon %p reason %d", hcon, reason);
1208 sco_conn_del(hcon, bt_to_errno(reason));
1211 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1213 struct sco_conn *conn = hcon->sco_data;
1218 BT_DBG("conn %p len %d", conn, skb->len);
1221 sco_recv_frame(conn, skb);
1229 static struct hci_cb sco_cb = {
1231 .connect_cfm = sco_connect_cfm,
1232 .disconn_cfm = sco_disconn_cfm,
1235 static int sco_debugfs_show(struct seq_file *f, void *p)
1239 read_lock(&sco_sk_list.lock);
1241 sk_for_each(sk, &sco_sk_list.head) {
1242 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1243 &sco_pi(sk)->dst, sk->sk_state);
1246 read_unlock(&sco_sk_list.lock);
1251 DEFINE_SHOW_ATTRIBUTE(sco_debugfs);
1253 static struct dentry *sco_debugfs;
1255 static const struct proto_ops sco_sock_ops = {
1256 .family = PF_BLUETOOTH,
1257 .owner = THIS_MODULE,
1258 .release = sco_sock_release,
1259 .bind = sco_sock_bind,
1260 .connect = sco_sock_connect,
1261 .listen = sco_sock_listen,
1262 .accept = sco_sock_accept,
1263 .getname = sco_sock_getname,
1264 .sendmsg = sco_sock_sendmsg,
1265 .recvmsg = sco_sock_recvmsg,
1266 .poll = bt_sock_poll,
1267 .ioctl = bt_sock_ioctl,
1268 .gettstamp = sock_gettstamp,
1269 .mmap = sock_no_mmap,
1270 .socketpair = sock_no_socketpair,
1271 .shutdown = sco_sock_shutdown,
1272 .setsockopt = sco_sock_setsockopt,
1273 .getsockopt = sco_sock_getsockopt
1276 static const struct net_proto_family sco_sock_family_ops = {
1277 .family = PF_BLUETOOTH,
1278 .owner = THIS_MODULE,
1279 .create = sco_sock_create,
1282 int __init sco_init(void)
1286 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1288 err = proto_register(&sco_proto, 0);
1292 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1294 BT_ERR("SCO socket registration failed");
1298 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1300 BT_ERR("Failed to create SCO proc file");
1301 bt_sock_unregister(BTPROTO_SCO);
1305 BT_INFO("SCO socket layer initialized");
1307 hci_register_cb(&sco_cb);
1309 if (IS_ERR_OR_NULL(bt_debugfs))
1312 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1313 NULL, &sco_debugfs_fops);
1318 proto_unregister(&sco_proto);
1324 bt_procfs_cleanup(&init_net, "sco");
1326 debugfs_remove(sco_debugfs);
1328 hci_unregister_cb(&sco_cb);
1330 bt_sock_unregister(BTPROTO_SCO);
1332 proto_unregister(&sco_proto);
1335 module_param(disable_esco, bool, 0644);
1336 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");