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>
31 #include <net/bluetooth/bluetooth.h>
32 #include <net/bluetooth/hci_core.h>
33 #include <net/bluetooth/sco.h>
35 static bool disable_esco;
37 static const struct proto_ops sco_sock_ops;
39 static struct bt_sock_list sco_sk_list = {
40 .lock = __RW_LOCK_UNLOCKED(sco_sk_list.lock)
43 /* ---- SCO connections ---- */
45 struct hci_conn *hcon;
53 #define sco_conn_lock(c) spin_lock(&c->lock);
54 #define sco_conn_unlock(c) spin_unlock(&c->lock);
56 static void sco_sock_close(struct sock *sk);
57 static void sco_sock_kill(struct sock *sk);
59 /* ----- SCO socket info ----- */
60 #define sco_pi(sk) ((struct sco_pinfo *) sk)
68 struct sco_conn *conn;
71 /* ---- SCO timers ---- */
72 #define SCO_CONN_TIMEOUT (HZ * 40)
73 #define SCO_DISCONN_TIMEOUT (HZ * 2)
75 static void sco_sock_timeout(unsigned long arg)
77 struct sock *sk = (struct sock *)arg;
79 BT_DBG("sock %p state %d", sk, sk->sk_state);
82 sk->sk_err = ETIMEDOUT;
83 sk->sk_state_change(sk);
89 static void sco_sock_set_timer(struct sock *sk, long timeout)
91 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
92 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
95 static void sco_sock_clear_timer(struct sock *sk)
97 BT_DBG("sock %p state %d", sk, sk->sk_state);
98 sk_stop_timer(sk, &sk->sk_timer);
101 /* ---- SCO connections ---- */
102 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
104 struct hci_dev *hdev = hcon->hdev;
105 struct sco_conn *conn = hcon->sco_data;
110 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
114 spin_lock_init(&conn->lock);
116 hcon->sco_data = conn;
119 if (hdev->sco_mtu > 0)
120 conn->mtu = hdev->sco_mtu;
124 BT_DBG("hcon %p conn %p", hcon, conn);
130 * Must be called on the locked socket. */
131 static void sco_chan_del(struct sock *sk, int err)
133 struct sco_conn *conn;
135 conn = sco_pi(sk)->conn;
137 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
142 sco_pi(sk)->conn = NULL;
143 sco_conn_unlock(conn);
146 hci_conn_drop(conn->hcon);
149 sk->sk_state = BT_CLOSED;
151 sk->sk_state_change(sk);
153 sock_set_flag(sk, SOCK_ZAPPED);
156 static void sco_conn_del(struct hci_conn *hcon, int err)
158 struct sco_conn *conn = hcon->sco_data;
164 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
169 sco_conn_unlock(conn);
174 sco_sock_clear_timer(sk);
175 sco_chan_del(sk, err);
180 hcon->sco_data = NULL;
184 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
187 BT_DBG("conn %p", conn);
189 sco_pi(sk)->conn = conn;
193 bt_accept_enqueue(parent, sk);
196 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
205 __sco_chan_add(conn, sk, parent);
207 sco_conn_unlock(conn);
211 static int sco_connect(struct hci_dev *hdev, struct sock *sk)
213 struct sco_conn *conn;
214 struct hci_conn *hcon;
217 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
219 if (lmp_esco_capable(hdev) && !disable_esco)
224 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
225 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev)))
228 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
229 sco_pi(sk)->setting);
231 return PTR_ERR(hcon);
233 conn = sco_conn_add(hcon);
239 /* Update source addr of the socket */
240 bacpy(&sco_pi(sk)->src, &hcon->src);
242 err = sco_chan_add(conn, sk, NULL);
246 if (hcon->state == BT_CONNECTED) {
247 sco_sock_clear_timer(sk);
248 sk->sk_state = BT_CONNECTED;
250 sk->sk_state = BT_CONNECT;
251 sco_sock_set_timer(sk, sk->sk_sndtimeo);
257 static int sco_send_frame(struct sock *sk, void *buf, int len,
258 unsigned int msg_flags)
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_flags & MSG_DONTWAIT, &err);
274 memcpy(skb_put(skb, len), buf, len);
275 hci_send_sco(conn->hcon, skb);
280 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
286 sco_conn_unlock(conn);
291 BT_DBG("sk %p len %d", sk, skb->len);
293 if (sk->sk_state != BT_CONNECTED)
296 if (!sock_queue_rcv_skb(sk, skb))
303 /* -------- Socket interface ---------- */
304 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
308 sk_for_each(sk, &sco_sk_list.head) {
309 if (sk->sk_state != BT_LISTEN)
312 if (!bacmp(&sco_pi(sk)->src, ba))
319 /* Find socket listening on source bdaddr.
320 * Returns closest match.
322 static struct sock *sco_get_sock_listen(bdaddr_t *src)
324 struct sock *sk = NULL, *sk1 = NULL;
326 read_lock(&sco_sk_list.lock);
328 sk_for_each(sk, &sco_sk_list.head) {
329 if (sk->sk_state != BT_LISTEN)
333 if (!bacmp(&sco_pi(sk)->src, src))
337 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
341 read_unlock(&sco_sk_list.lock);
343 return sk ? sk : sk1;
346 static void sco_sock_destruct(struct sock *sk)
350 skb_queue_purge(&sk->sk_receive_queue);
351 skb_queue_purge(&sk->sk_write_queue);
354 static void sco_sock_cleanup_listen(struct sock *parent)
358 BT_DBG("parent %p", parent);
360 /* Close not yet accepted channels */
361 while ((sk = bt_accept_dequeue(parent, NULL))) {
366 parent->sk_state = BT_CLOSED;
367 sock_set_flag(parent, SOCK_ZAPPED);
370 /* Kill socket (only if zapped and orphan)
371 * Must be called on unlocked socket.
373 static void sco_sock_kill(struct sock *sk)
375 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
378 BT_DBG("sk %p state %d", sk, sk->sk_state);
380 /* Kill poor orphan */
381 bt_sock_unlink(&sco_sk_list, sk);
382 sock_set_flag(sk, SOCK_DEAD);
386 static void __sco_sock_close(struct sock *sk)
388 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
390 switch (sk->sk_state) {
392 sco_sock_cleanup_listen(sk);
397 if (sco_pi(sk)->conn->hcon) {
398 sk->sk_state = BT_DISCONN;
399 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
400 sco_conn_lock(sco_pi(sk)->conn);
401 hci_conn_drop(sco_pi(sk)->conn->hcon);
402 sco_pi(sk)->conn->hcon = NULL;
403 sco_conn_unlock(sco_pi(sk)->conn);
405 sco_chan_del(sk, ECONNRESET);
411 sco_chan_del(sk, ECONNRESET);
415 sock_set_flag(sk, SOCK_ZAPPED);
420 /* Must be called on unlocked socket. */
421 static void sco_sock_close(struct sock *sk)
423 sco_sock_clear_timer(sk);
425 __sco_sock_close(sk);
429 static void sco_sock_init(struct sock *sk, struct sock *parent)
434 sk->sk_type = parent->sk_type;
435 bt_sk(sk)->flags = bt_sk(parent)->flags;
436 security_sk_clone(parent, sk);
440 static struct proto sco_proto = {
442 .owner = THIS_MODULE,
443 .obj_size = sizeof(struct sco_pinfo)
446 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
447 int proto, gfp_t prio, int kern)
451 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
455 sock_init_data(sock, sk);
456 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
458 sk->sk_destruct = sco_sock_destruct;
459 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
461 sock_reset_flag(sk, SOCK_ZAPPED);
463 sk->sk_protocol = proto;
464 sk->sk_state = BT_OPEN;
466 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
468 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
470 bt_sock_link(&sco_sk_list, sk);
474 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
479 BT_DBG("sock %p", sock);
481 sock->state = SS_UNCONNECTED;
483 if (sock->type != SOCK_SEQPACKET)
484 return -ESOCKTNOSUPPORT;
486 sock->ops = &sco_sock_ops;
488 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
492 sco_sock_init(sk, NULL);
496 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
499 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
500 struct sock *sk = sock->sk;
503 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
505 if (!addr || addr->sa_family != AF_BLUETOOTH)
508 if (addr_len < sizeof(struct sockaddr_sco))
513 if (sk->sk_state != BT_OPEN) {
518 if (sk->sk_type != SOCK_SEQPACKET) {
523 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
525 sk->sk_state = BT_BOUND;
532 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
534 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
535 struct sock *sk = sock->sk;
536 struct hci_dev *hdev;
541 if (alen < sizeof(struct sockaddr_sco) ||
542 addr->sa_family != AF_BLUETOOTH)
546 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
551 if (sk->sk_type != SOCK_SEQPACKET) {
556 hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
563 /* Set destination address and psm */
564 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
566 err = sco_connect(hdev, sk);
567 hci_dev_unlock(hdev);
572 err = bt_sock_wait_state(sk, BT_CONNECTED,
573 sock_sndtimeo(sk, flags & O_NONBLOCK));
580 static int sco_sock_listen(struct socket *sock, int backlog)
582 struct sock *sk = sock->sk;
583 bdaddr_t *src = &sco_pi(sk)->src;
586 BT_DBG("sk %p backlog %d", sk, backlog);
590 if (sk->sk_state != BT_BOUND) {
595 if (sk->sk_type != SOCK_SEQPACKET) {
600 write_lock(&sco_sk_list.lock);
602 if (__sco_get_sock_listen_by_addr(src)) {
607 sk->sk_max_ack_backlog = backlog;
608 sk->sk_ack_backlog = 0;
610 sk->sk_state = BT_LISTEN;
613 write_unlock(&sco_sk_list.lock);
620 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
623 DEFINE_WAIT_FUNC(wait, woken_wake_function);
624 struct sock *sk = sock->sk, *ch;
630 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
632 BT_DBG("sk %p timeo %ld", sk, timeo);
634 /* Wait for an incoming connection. (wake-one). */
635 add_wait_queue_exclusive(sk_sleep(sk), &wait);
637 if (sk->sk_state != BT_LISTEN) {
642 ch = bt_accept_dequeue(sk, newsock);
651 if (signal_pending(current)) {
652 err = sock_intr_errno(timeo);
658 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
661 remove_wait_queue(sk_sleep(sk), &wait);
666 newsock->state = SS_CONNECTED;
668 BT_DBG("new socket %p", ch);
675 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
678 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
679 struct sock *sk = sock->sk;
681 BT_DBG("sock %p, sk %p", sock, sk);
683 addr->sa_family = AF_BLUETOOTH;
684 *len = sizeof(struct sockaddr_sco);
687 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
689 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
694 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
697 struct sock *sk = sock->sk;
701 BT_DBG("sock %p, sk %p", sock, sk);
703 err = sock_error(sk);
707 if (msg->msg_flags & MSG_OOB)
710 buf = kmalloc(len, GFP_KERNEL);
714 if (memcpy_from_msg(buf, msg, len)) {
721 if (sk->sk_state == BT_CONNECTED)
722 err = sco_send_frame(sk, buf, len, msg->msg_flags);
731 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
733 struct hci_dev *hdev = conn->hdev;
735 BT_DBG("conn %p", conn);
737 conn->state = BT_CONFIG;
739 if (!lmp_esco_capable(hdev)) {
740 struct hci_cp_accept_conn_req cp;
742 bacpy(&cp.bdaddr, &conn->dst);
743 cp.role = 0x00; /* Ignored */
745 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
747 struct hci_cp_accept_sync_conn_req cp;
749 bacpy(&cp.bdaddr, &conn->dst);
750 cp.pkt_type = cpu_to_le16(conn->pkt_type);
752 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
753 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
754 cp.content_format = cpu_to_le16(setting);
756 switch (setting & SCO_AIRMODE_MASK) {
757 case SCO_AIRMODE_TRANSP:
758 if (conn->pkt_type & ESCO_2EV3)
759 cp.max_latency = cpu_to_le16(0x0008);
761 cp.max_latency = cpu_to_le16(0x000D);
762 cp.retrans_effort = 0x02;
764 case SCO_AIRMODE_CVSD:
765 cp.max_latency = cpu_to_le16(0xffff);
766 cp.retrans_effort = 0xff;
769 /* use CVSD settings as fallback */
770 cp.max_latency = cpu_to_le16(0xffff);
771 cp.retrans_effort = 0xff;
775 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
780 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
781 size_t len, int flags)
783 struct sock *sk = sock->sk;
784 struct sco_pinfo *pi = sco_pi(sk);
788 if (sk->sk_state == BT_CONNECT2 &&
789 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
790 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
791 sk->sk_state = BT_CONFIG;
799 return bt_sock_recvmsg(sock, msg, len, flags);
802 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
803 char __user *optval, unsigned int optlen)
805 struct sock *sk = sock->sk;
807 struct bt_voice voice;
817 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
822 if (get_user(opt, (u32 __user *) optval)) {
828 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
830 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
834 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
835 sk->sk_state != BT_CONNECT2) {
840 voice.setting = sco_pi(sk)->setting;
842 len = min_t(unsigned int, sizeof(voice), optlen);
843 if (copy_from_user((char *)&voice, optval, len)) {
848 /* Explicitly check for these values */
849 if (voice.setting != BT_VOICE_TRANSPARENT &&
850 voice.setting != BT_VOICE_CVSD_16BIT) {
855 sco_pi(sk)->setting = voice.setting;
867 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
868 char __user *optval, int __user *optlen)
870 struct sock *sk = sock->sk;
871 struct sco_options opts;
872 struct sco_conninfo cinfo;
877 if (get_user(len, optlen))
884 if (sk->sk_state != BT_CONNECTED &&
885 !(sk->sk_state == BT_CONNECT2 &&
886 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
891 opts.mtu = sco_pi(sk)->conn->mtu;
893 BT_DBG("mtu %d", opts.mtu);
895 len = min_t(unsigned int, len, sizeof(opts));
896 if (copy_to_user(optval, (char *)&opts, len))
902 if (sk->sk_state != BT_CONNECTED &&
903 !(sk->sk_state == BT_CONNECT2 &&
904 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
909 memset(&cinfo, 0, sizeof(cinfo));
910 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
911 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
913 len = min_t(unsigned int, len, sizeof(cinfo));
914 if (copy_to_user(optval, (char *)&cinfo, len))
928 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
929 char __user *optval, int __user *optlen)
931 struct sock *sk = sock->sk;
933 struct bt_voice voice;
937 if (level == SOL_SCO)
938 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
940 if (get_user(len, optlen))
948 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
953 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
954 (u32 __user *)optval))
960 voice.setting = sco_pi(sk)->setting;
962 len = min_t(unsigned int, len, sizeof(voice));
963 if (copy_to_user(optval, (char *)&voice, len))
977 static int sco_sock_shutdown(struct socket *sock, int how)
979 struct sock *sk = sock->sk;
982 BT_DBG("sock %p, sk %p", sock, sk);
990 if (!sk->sk_shutdown) {
991 sk->sk_shutdown = SHUTDOWN_MASK;
992 sco_sock_clear_timer(sk);
993 __sco_sock_close(sk);
995 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
996 !(current->flags & PF_EXITING))
997 err = bt_sock_wait_state(sk, BT_CLOSED,
1007 static int sco_sock_release(struct socket *sock)
1009 struct sock *sk = sock->sk;
1012 BT_DBG("sock %p, sk %p", sock, sk);
1019 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1020 !(current->flags & PF_EXITING)) {
1022 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1031 static void sco_conn_ready(struct sco_conn *conn)
1033 struct sock *parent;
1034 struct sock *sk = conn->sk;
1036 BT_DBG("conn %p", conn);
1039 sco_sock_clear_timer(sk);
1041 sk->sk_state = BT_CONNECTED;
1042 sk->sk_state_change(sk);
1045 sco_conn_lock(conn);
1048 sco_conn_unlock(conn);
1052 parent = sco_get_sock_listen(&conn->hcon->src);
1054 sco_conn_unlock(conn);
1058 bh_lock_sock(parent);
1060 sk = sco_sock_alloc(sock_net(parent), NULL,
1061 BTPROTO_SCO, GFP_ATOMIC, 0);
1063 bh_unlock_sock(parent);
1064 sco_conn_unlock(conn);
1068 sco_sock_init(sk, parent);
1070 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1071 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1073 hci_conn_hold(conn->hcon);
1074 __sco_chan_add(conn, sk, parent);
1076 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1077 sk->sk_state = BT_CONNECT2;
1079 sk->sk_state = BT_CONNECTED;
1081 /* Wake up parent */
1082 parent->sk_data_ready(parent);
1084 bh_unlock_sock(parent);
1086 sco_conn_unlock(conn);
1090 /* ----- SCO interface with lower layer (HCI) ----- */
1091 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1096 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1098 /* Find listening sockets */
1099 read_lock(&sco_sk_list.lock);
1100 sk_for_each(sk, &sco_sk_list.head) {
1101 if (sk->sk_state != BT_LISTEN)
1104 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1105 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1106 lm |= HCI_LM_ACCEPT;
1108 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1109 *flags |= HCI_PROTO_DEFER;
1113 read_unlock(&sco_sk_list.lock);
1118 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1120 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1123 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1126 struct sco_conn *conn;
1128 conn = sco_conn_add(hcon);
1130 sco_conn_ready(conn);
1132 sco_conn_del(hcon, bt_to_errno(status));
1135 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1137 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1140 BT_DBG("hcon %p reason %d", hcon, reason);
1142 sco_conn_del(hcon, bt_to_errno(reason));
1145 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1147 struct sco_conn *conn = hcon->sco_data;
1152 BT_DBG("conn %p len %d", conn, skb->len);
1155 sco_recv_frame(conn, skb);
1163 static struct hci_cb sco_cb = {
1165 .connect_cfm = sco_connect_cfm,
1166 .disconn_cfm = sco_disconn_cfm,
1169 static int sco_debugfs_show(struct seq_file *f, void *p)
1173 read_lock(&sco_sk_list.lock);
1175 sk_for_each(sk, &sco_sk_list.head) {
1176 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1177 &sco_pi(sk)->dst, sk->sk_state);
1180 read_unlock(&sco_sk_list.lock);
1185 static int sco_debugfs_open(struct inode *inode, struct file *file)
1187 return single_open(file, sco_debugfs_show, inode->i_private);
1190 static const struct file_operations sco_debugfs_fops = {
1191 .open = sco_debugfs_open,
1193 .llseek = seq_lseek,
1194 .release = single_release,
1197 static struct dentry *sco_debugfs;
1199 static const struct proto_ops sco_sock_ops = {
1200 .family = PF_BLUETOOTH,
1201 .owner = THIS_MODULE,
1202 .release = sco_sock_release,
1203 .bind = sco_sock_bind,
1204 .connect = sco_sock_connect,
1205 .listen = sco_sock_listen,
1206 .accept = sco_sock_accept,
1207 .getname = sco_sock_getname,
1208 .sendmsg = sco_sock_sendmsg,
1209 .recvmsg = sco_sock_recvmsg,
1210 .poll = bt_sock_poll,
1211 .ioctl = bt_sock_ioctl,
1212 .mmap = sock_no_mmap,
1213 .socketpair = sock_no_socketpair,
1214 .shutdown = sco_sock_shutdown,
1215 .setsockopt = sco_sock_setsockopt,
1216 .getsockopt = sco_sock_getsockopt
1219 static const struct net_proto_family sco_sock_family_ops = {
1220 .family = PF_BLUETOOTH,
1221 .owner = THIS_MODULE,
1222 .create = sco_sock_create,
1225 int __init sco_init(void)
1229 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1231 err = proto_register(&sco_proto, 0);
1235 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1237 BT_ERR("SCO socket registration failed");
1241 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1243 BT_ERR("Failed to create SCO proc file");
1244 bt_sock_unregister(BTPROTO_SCO);
1248 BT_INFO("SCO socket layer initialized");
1250 hci_register_cb(&sco_cb);
1252 if (IS_ERR_OR_NULL(bt_debugfs))
1255 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1256 NULL, &sco_debugfs_fops);
1261 proto_unregister(&sco_proto);
1267 bt_procfs_cleanup(&init_net, "sco");
1269 debugfs_remove(sco_debugfs);
1271 hci_unregister_cb(&sco_cb);
1273 bt_sock_unregister(BTPROTO_SCO);
1275 proto_unregister(&sco_proto);
1278 module_param(disable_esco, bool, 0644);
1279 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");