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(struct timer_list *t)
78 struct sock *sk = from_timer(sk, t, sk_timer);
80 BT_DBG("sock %p state %d", sk, sk->sk_state);
83 sk->sk_err = ETIMEDOUT;
84 sk->sk_state_change(sk);
91 static void sco_sock_set_timer(struct sock *sk, long timeout)
93 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
94 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
97 static void sco_sock_clear_timer(struct sock *sk)
99 BT_DBG("sock %p state %d", sk, sk->sk_state);
100 sk_stop_timer(sk, &sk->sk_timer);
103 /* ---- SCO connections ---- */
104 static struct sco_conn *sco_conn_add(struct hci_conn *hcon)
106 struct hci_dev *hdev = hcon->hdev;
107 struct sco_conn *conn = hcon->sco_data;
112 conn = kzalloc(sizeof(struct sco_conn), GFP_KERNEL);
116 spin_lock_init(&conn->lock);
118 hcon->sco_data = conn;
121 if (hdev->sco_mtu > 0)
122 conn->mtu = hdev->sco_mtu;
126 BT_DBG("hcon %p conn %p", hcon, conn);
132 * Must be called on the locked socket. */
133 static void sco_chan_del(struct sock *sk, int err)
135 struct sco_conn *conn;
137 conn = sco_pi(sk)->conn;
139 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
144 sco_pi(sk)->conn = NULL;
145 sco_conn_unlock(conn);
148 hci_conn_drop(conn->hcon);
151 sk->sk_state = BT_CLOSED;
153 sk->sk_state_change(sk);
155 sock_set_flag(sk, SOCK_ZAPPED);
158 static void sco_conn_del(struct hci_conn *hcon, int err)
160 struct sco_conn *conn = hcon->sco_data;
166 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
171 sco_conn_unlock(conn);
176 sco_sock_clear_timer(sk);
177 sco_chan_del(sk, err);
183 hcon->sco_data = NULL;
187 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk,
190 BT_DBG("conn %p", conn);
192 sco_pi(sk)->conn = conn;
196 bt_accept_enqueue(parent, sk);
199 static int sco_chan_add(struct sco_conn *conn, struct sock *sk,
208 __sco_chan_add(conn, sk, parent);
210 sco_conn_unlock(conn);
214 static int sco_connect(struct sock *sk)
216 struct sco_conn *conn;
217 struct hci_conn *hcon;
218 struct hci_dev *hdev;
221 BT_DBG("%pMR -> %pMR", &sco_pi(sk)->src, &sco_pi(sk)->dst);
223 hdev = hci_get_route(&sco_pi(sk)->dst, &sco_pi(sk)->src, BDADDR_BREDR);
225 return -EHOSTUNREACH;
229 if (lmp_esco_capable(hdev) && !disable_esco)
234 if (sco_pi(sk)->setting == BT_VOICE_TRANSPARENT &&
235 (!lmp_transp_capable(hdev) || !lmp_esco_capable(hdev))) {
240 hcon = hci_connect_sco(hdev, type, &sco_pi(sk)->dst,
241 sco_pi(sk)->setting);
247 conn = sco_conn_add(hcon);
254 /* Update source addr of the socket */
255 bacpy(&sco_pi(sk)->src, &hcon->src);
257 err = sco_chan_add(conn, sk, NULL);
261 if (hcon->state == BT_CONNECTED) {
262 sco_sock_clear_timer(sk);
263 sk->sk_state = BT_CONNECTED;
265 sk->sk_state = BT_CONNECT;
266 sco_sock_set_timer(sk, sk->sk_sndtimeo);
270 hci_dev_unlock(hdev);
275 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
277 struct sco_conn *conn = sco_pi(sk)->conn;
281 /* Check outgoing MTU */
285 BT_DBG("sk %p len %d", sk, len);
287 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
291 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
296 hci_send_sco(conn->hcon, skb);
301 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
307 sco_conn_unlock(conn);
312 BT_DBG("sk %p len %d", sk, skb->len);
314 if (sk->sk_state != BT_CONNECTED)
317 if (!sock_queue_rcv_skb(sk, skb))
324 /* -------- Socket interface ---------- */
325 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
329 sk_for_each(sk, &sco_sk_list.head) {
330 if (sk->sk_state != BT_LISTEN)
333 if (!bacmp(&sco_pi(sk)->src, ba))
340 /* Find socket listening on source bdaddr.
341 * Returns closest match.
343 static struct sock *sco_get_sock_listen(bdaddr_t *src)
345 struct sock *sk = NULL, *sk1 = NULL;
347 read_lock(&sco_sk_list.lock);
349 sk_for_each(sk, &sco_sk_list.head) {
350 if (sk->sk_state != BT_LISTEN)
354 if (!bacmp(&sco_pi(sk)->src, src))
358 if (!bacmp(&sco_pi(sk)->src, BDADDR_ANY))
362 read_unlock(&sco_sk_list.lock);
364 return sk ? sk : sk1;
367 static void sco_sock_destruct(struct sock *sk)
371 skb_queue_purge(&sk->sk_receive_queue);
372 skb_queue_purge(&sk->sk_write_queue);
375 static void sco_sock_cleanup_listen(struct sock *parent)
379 BT_DBG("parent %p", parent);
381 /* Close not yet accepted channels */
382 while ((sk = bt_accept_dequeue(parent, NULL))) {
387 parent->sk_state = BT_CLOSED;
388 sock_set_flag(parent, SOCK_ZAPPED);
391 /* Kill socket (only if zapped and orphan)
392 * Must be called on unlocked socket.
394 static void sco_sock_kill(struct sock *sk)
396 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
399 BT_DBG("sk %p state %d", sk, sk->sk_state);
401 /* Kill poor orphan */
402 bt_sock_unlink(&sco_sk_list, sk);
403 sock_set_flag(sk, SOCK_DEAD);
407 static void __sco_sock_close(struct sock *sk)
409 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
411 switch (sk->sk_state) {
413 sco_sock_cleanup_listen(sk);
418 if (sco_pi(sk)->conn->hcon) {
419 sk->sk_state = BT_DISCONN;
420 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
421 sco_conn_lock(sco_pi(sk)->conn);
422 hci_conn_drop(sco_pi(sk)->conn->hcon);
423 sco_pi(sk)->conn->hcon = NULL;
424 sco_conn_unlock(sco_pi(sk)->conn);
426 sco_chan_del(sk, ECONNRESET);
432 sco_chan_del(sk, ECONNRESET);
436 sock_set_flag(sk, SOCK_ZAPPED);
441 /* Must be called on unlocked socket. */
442 static void sco_sock_close(struct sock *sk)
444 sco_sock_clear_timer(sk);
446 __sco_sock_close(sk);
451 static void sco_sock_init(struct sock *sk, struct sock *parent)
456 sk->sk_type = parent->sk_type;
457 bt_sk(sk)->flags = bt_sk(parent)->flags;
458 security_sk_clone(parent, sk);
462 static struct proto sco_proto = {
464 .owner = THIS_MODULE,
465 .obj_size = sizeof(struct sco_pinfo)
468 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock,
469 int proto, gfp_t prio, int kern)
473 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto, kern);
477 sock_init_data(sock, sk);
478 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
480 sk->sk_destruct = sco_sock_destruct;
481 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
483 sock_reset_flag(sk, SOCK_ZAPPED);
485 sk->sk_protocol = proto;
486 sk->sk_state = BT_OPEN;
488 sco_pi(sk)->setting = BT_VOICE_CVSD_16BIT;
490 timer_setup(&sk->sk_timer, sco_sock_timeout, 0);
492 bt_sock_link(&sco_sk_list, sk);
496 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
501 BT_DBG("sock %p", sock);
503 sock->state = SS_UNCONNECTED;
505 if (sock->type != SOCK_SEQPACKET)
506 return -ESOCKTNOSUPPORT;
508 sock->ops = &sco_sock_ops;
510 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
514 sco_sock_init(sk, NULL);
518 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr,
521 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
522 struct sock *sk = sock->sk;
525 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
527 if (!addr || addr_len < sizeof(struct sockaddr_sco) ||
528 addr->sa_family != AF_BLUETOOTH)
533 if (sk->sk_state != BT_OPEN) {
538 if (sk->sk_type != SOCK_SEQPACKET) {
543 bacpy(&sco_pi(sk)->src, &sa->sco_bdaddr);
545 sk->sk_state = BT_BOUND;
552 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
554 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
555 struct sock *sk = sock->sk;
560 if (alen < sizeof(struct sockaddr_sco) ||
561 addr->sa_family != AF_BLUETOOTH)
564 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
567 if (sk->sk_type != SOCK_SEQPACKET)
572 /* Set destination address and psm */
573 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
575 err = sco_connect(sk);
579 err = bt_sock_wait_state(sk, BT_CONNECTED,
580 sock_sndtimeo(sk, flags & O_NONBLOCK));
587 static int sco_sock_listen(struct socket *sock, int backlog)
589 struct sock *sk = sock->sk;
590 bdaddr_t *src = &sco_pi(sk)->src;
593 BT_DBG("sk %p backlog %d", sk, backlog);
597 if (sk->sk_state != BT_BOUND) {
602 if (sk->sk_type != SOCK_SEQPACKET) {
607 write_lock(&sco_sk_list.lock);
609 if (__sco_get_sock_listen_by_addr(src)) {
614 sk->sk_max_ack_backlog = backlog;
615 sk->sk_ack_backlog = 0;
617 sk->sk_state = BT_LISTEN;
620 write_unlock(&sco_sk_list.lock);
627 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
628 int flags, bool kern)
630 DEFINE_WAIT_FUNC(wait, woken_wake_function);
631 struct sock *sk = sock->sk, *ch;
637 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
639 BT_DBG("sk %p timeo %ld", sk, timeo);
641 /* Wait for an incoming connection. (wake-one). */
642 add_wait_queue_exclusive(sk_sleep(sk), &wait);
644 if (sk->sk_state != BT_LISTEN) {
649 ch = bt_accept_dequeue(sk, newsock);
658 if (signal_pending(current)) {
659 err = sock_intr_errno(timeo);
665 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
668 remove_wait_queue(sk_sleep(sk), &wait);
673 newsock->state = SS_CONNECTED;
675 BT_DBG("new socket %p", ch);
682 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
685 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
686 struct sock *sk = sock->sk;
688 BT_DBG("sock %p, sk %p", sock, sk);
690 addr->sa_family = AF_BLUETOOTH;
693 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
695 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
697 return sizeof(struct sockaddr_sco);
700 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
703 struct sock *sk = sock->sk;
706 BT_DBG("sock %p, sk %p", sock, sk);
708 err = sock_error(sk);
712 if (msg->msg_flags & MSG_OOB)
717 if (sk->sk_state == BT_CONNECTED)
718 err = sco_send_frame(sk, msg, len);
726 static void sco_conn_defer_accept(struct hci_conn *conn, u16 setting)
728 struct hci_dev *hdev = conn->hdev;
730 BT_DBG("conn %p", conn);
732 conn->state = BT_CONFIG;
734 if (!lmp_esco_capable(hdev)) {
735 struct hci_cp_accept_conn_req cp;
737 bacpy(&cp.bdaddr, &conn->dst);
738 cp.role = 0x00; /* Ignored */
740 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
742 struct hci_cp_accept_sync_conn_req cp;
744 bacpy(&cp.bdaddr, &conn->dst);
745 cp.pkt_type = cpu_to_le16(conn->pkt_type);
747 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
748 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
749 cp.content_format = cpu_to_le16(setting);
751 switch (setting & SCO_AIRMODE_MASK) {
752 case SCO_AIRMODE_TRANSP:
753 if (conn->pkt_type & ESCO_2EV3)
754 cp.max_latency = cpu_to_le16(0x0008);
756 cp.max_latency = cpu_to_le16(0x000D);
757 cp.retrans_effort = 0x02;
759 case SCO_AIRMODE_CVSD:
760 cp.max_latency = cpu_to_le16(0xffff);
761 cp.retrans_effort = 0xff;
765 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
770 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
771 size_t len, int flags)
773 struct sock *sk = sock->sk;
774 struct sco_pinfo *pi = sco_pi(sk);
778 if (sk->sk_state == BT_CONNECT2 &&
779 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
780 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
781 sk->sk_state = BT_CONFIG;
789 return bt_sock_recvmsg(sock, msg, len, flags);
792 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
793 char __user *optval, unsigned int optlen)
795 struct sock *sk = sock->sk;
797 struct bt_voice voice;
807 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
812 if (get_user(opt, (u32 __user *) optval)) {
818 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
820 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
824 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
825 sk->sk_state != BT_CONNECT2) {
830 voice.setting = sco_pi(sk)->setting;
832 len = min_t(unsigned int, sizeof(voice), optlen);
833 if (copy_from_user((char *)&voice, optval, len)) {
838 /* Explicitly check for these values */
839 if (voice.setting != BT_VOICE_TRANSPARENT &&
840 voice.setting != BT_VOICE_CVSD_16BIT) {
845 sco_pi(sk)->setting = voice.setting;
857 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
858 char __user *optval, int __user *optlen)
860 struct sock *sk = sock->sk;
861 struct sco_options opts;
862 struct sco_conninfo cinfo;
867 if (get_user(len, optlen))
874 if (sk->sk_state != BT_CONNECTED &&
875 !(sk->sk_state == BT_CONNECT2 &&
876 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
881 opts.mtu = sco_pi(sk)->conn->mtu;
883 BT_DBG("mtu %d", opts.mtu);
885 len = min_t(unsigned int, len, sizeof(opts));
886 if (copy_to_user(optval, (char *)&opts, len))
892 if (sk->sk_state != BT_CONNECTED &&
893 !(sk->sk_state == BT_CONNECT2 &&
894 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
899 memset(&cinfo, 0, sizeof(cinfo));
900 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
901 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
903 len = min_t(unsigned int, len, sizeof(cinfo));
904 if (copy_to_user(optval, (char *)&cinfo, len))
918 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
919 char __user *optval, int __user *optlen)
921 struct sock *sk = sock->sk;
923 struct bt_voice voice;
927 if (level == SOL_SCO)
928 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
930 if (get_user(len, optlen))
938 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
943 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
944 (u32 __user *)optval))
950 voice.setting = sco_pi(sk)->setting;
952 len = min_t(unsigned int, len, sizeof(voice));
953 if (copy_to_user(optval, (char *)&voice, len))
967 static int sco_sock_shutdown(struct socket *sock, int how)
969 struct sock *sk = sock->sk;
972 BT_DBG("sock %p, sk %p", sock, sk);
980 if (!sk->sk_shutdown) {
981 sk->sk_shutdown = SHUTDOWN_MASK;
982 sco_sock_clear_timer(sk);
983 __sco_sock_close(sk);
985 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
986 !(current->flags & PF_EXITING))
987 err = bt_sock_wait_state(sk, BT_CLOSED,
997 static int sco_sock_release(struct socket *sock)
999 struct sock *sk = sock->sk;
1002 BT_DBG("sock %p, sk %p", sock, sk);
1009 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1010 !(current->flags & PF_EXITING)) {
1012 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1021 static void sco_conn_ready(struct sco_conn *conn)
1023 struct sock *parent;
1024 struct sock *sk = conn->sk;
1026 BT_DBG("conn %p", conn);
1029 sco_sock_clear_timer(sk);
1031 sk->sk_state = BT_CONNECTED;
1032 sk->sk_state_change(sk);
1035 sco_conn_lock(conn);
1038 sco_conn_unlock(conn);
1042 parent = sco_get_sock_listen(&conn->hcon->src);
1044 sco_conn_unlock(conn);
1048 bh_lock_sock(parent);
1050 sk = sco_sock_alloc(sock_net(parent), NULL,
1051 BTPROTO_SCO, GFP_ATOMIC, 0);
1053 bh_unlock_sock(parent);
1054 sco_conn_unlock(conn);
1058 sco_sock_init(sk, parent);
1060 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1061 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1063 hci_conn_hold(conn->hcon);
1064 __sco_chan_add(conn, sk, parent);
1066 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1067 sk->sk_state = BT_CONNECT2;
1069 sk->sk_state = BT_CONNECTED;
1071 /* Wake up parent */
1072 parent->sk_data_ready(parent);
1074 bh_unlock_sock(parent);
1076 sco_conn_unlock(conn);
1080 /* ----- SCO interface with lower layer (HCI) ----- */
1081 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1086 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1088 /* Find listening sockets */
1089 read_lock(&sco_sk_list.lock);
1090 sk_for_each(sk, &sco_sk_list.head) {
1091 if (sk->sk_state != BT_LISTEN)
1094 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1095 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1096 lm |= HCI_LM_ACCEPT;
1098 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1099 *flags |= HCI_PROTO_DEFER;
1103 read_unlock(&sco_sk_list.lock);
1108 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1110 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1113 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1116 struct sco_conn *conn;
1118 conn = sco_conn_add(hcon);
1120 sco_conn_ready(conn);
1122 sco_conn_del(hcon, bt_to_errno(status));
1125 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1127 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1130 BT_DBG("hcon %p reason %d", hcon, reason);
1132 sco_conn_del(hcon, bt_to_errno(reason));
1135 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1137 struct sco_conn *conn = hcon->sco_data;
1142 BT_DBG("conn %p len %d", conn, skb->len);
1145 sco_recv_frame(conn, skb);
1153 static struct hci_cb sco_cb = {
1155 .connect_cfm = sco_connect_cfm,
1156 .disconn_cfm = sco_disconn_cfm,
1159 static int sco_debugfs_show(struct seq_file *f, void *p)
1163 read_lock(&sco_sk_list.lock);
1165 sk_for_each(sk, &sco_sk_list.head) {
1166 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1167 &sco_pi(sk)->dst, sk->sk_state);
1170 read_unlock(&sco_sk_list.lock);
1175 static int sco_debugfs_open(struct inode *inode, struct file *file)
1177 return single_open(file, sco_debugfs_show, inode->i_private);
1180 static const struct file_operations sco_debugfs_fops = {
1181 .open = sco_debugfs_open,
1183 .llseek = seq_lseek,
1184 .release = single_release,
1187 static struct dentry *sco_debugfs;
1189 static const struct proto_ops sco_sock_ops = {
1190 .family = PF_BLUETOOTH,
1191 .owner = THIS_MODULE,
1192 .release = sco_sock_release,
1193 .bind = sco_sock_bind,
1194 .connect = sco_sock_connect,
1195 .listen = sco_sock_listen,
1196 .accept = sco_sock_accept,
1197 .getname = sco_sock_getname,
1198 .sendmsg = sco_sock_sendmsg,
1199 .recvmsg = sco_sock_recvmsg,
1200 .poll_mask = bt_sock_poll_mask,
1201 .ioctl = bt_sock_ioctl,
1202 .mmap = sock_no_mmap,
1203 .socketpair = sock_no_socketpair,
1204 .shutdown = sco_sock_shutdown,
1205 .setsockopt = sco_sock_setsockopt,
1206 .getsockopt = sco_sock_getsockopt
1209 static const struct net_proto_family sco_sock_family_ops = {
1210 .family = PF_BLUETOOTH,
1211 .owner = THIS_MODULE,
1212 .create = sco_sock_create,
1215 int __init sco_init(void)
1219 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1221 err = proto_register(&sco_proto, 0);
1225 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1227 BT_ERR("SCO socket registration failed");
1231 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1233 BT_ERR("Failed to create SCO proc file");
1234 bt_sock_unregister(BTPROTO_SCO);
1238 BT_INFO("SCO socket layer initialized");
1240 hci_register_cb(&sco_cb);
1242 if (IS_ERR_OR_NULL(bt_debugfs))
1245 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1246 NULL, &sco_debugfs_fops);
1251 proto_unregister(&sco_proto);
1257 bt_procfs_cleanup(&init_net, "sco");
1259 debugfs_remove(sco_debugfs);
1261 hci_unregister_cb(&sco_cb);
1263 bt_sock_unregister(BTPROTO_SCO);
1265 proto_unregister(&sco_proto);
1268 module_param(disable_esco, bool, 0644);
1269 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");