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)
545 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
548 if (sk->sk_type != SOCK_SEQPACKET)
551 hdev = hci_get_route(&sa->sco_bdaddr, &sco_pi(sk)->src, BDADDR_BREDR);
553 return -EHOSTUNREACH;
558 /* Set destination address and psm */
559 bacpy(&sco_pi(sk)->dst, &sa->sco_bdaddr);
561 err = sco_connect(hdev, sk);
562 hci_dev_unlock(hdev);
567 err = bt_sock_wait_state(sk, BT_CONNECTED,
568 sock_sndtimeo(sk, flags & O_NONBLOCK));
575 static int sco_sock_listen(struct socket *sock, int backlog)
577 struct sock *sk = sock->sk;
578 bdaddr_t *src = &sco_pi(sk)->src;
581 BT_DBG("sk %p backlog %d", sk, backlog);
585 if (sk->sk_state != BT_BOUND) {
590 if (sk->sk_type != SOCK_SEQPACKET) {
595 write_lock(&sco_sk_list.lock);
597 if (__sco_get_sock_listen_by_addr(src)) {
602 sk->sk_max_ack_backlog = backlog;
603 sk->sk_ack_backlog = 0;
605 sk->sk_state = BT_LISTEN;
608 write_unlock(&sco_sk_list.lock);
615 static int sco_sock_accept(struct socket *sock, struct socket *newsock,
618 DEFINE_WAIT_FUNC(wait, woken_wake_function);
619 struct sock *sk = sock->sk, *ch;
625 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
627 BT_DBG("sk %p timeo %ld", sk, timeo);
629 /* Wait for an incoming connection. (wake-one). */
630 add_wait_queue_exclusive(sk_sleep(sk), &wait);
632 if (sk->sk_state != BT_LISTEN) {
637 ch = bt_accept_dequeue(sk, newsock);
646 if (signal_pending(current)) {
647 err = sock_intr_errno(timeo);
653 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
656 remove_wait_queue(sk_sleep(sk), &wait);
661 newsock->state = SS_CONNECTED;
663 BT_DBG("new socket %p", ch);
670 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr,
673 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
674 struct sock *sk = sock->sk;
676 BT_DBG("sock %p, sk %p", sock, sk);
678 addr->sa_family = AF_BLUETOOTH;
679 *len = sizeof(struct sockaddr_sco);
682 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->dst);
684 bacpy(&sa->sco_bdaddr, &sco_pi(sk)->src);
689 static int sco_sock_sendmsg(struct socket *sock, struct msghdr *msg,
692 struct sock *sk = sock->sk;
696 BT_DBG("sock %p, sk %p", sock, sk);
698 err = sock_error(sk);
702 if (msg->msg_flags & MSG_OOB)
705 buf = kmalloc(len, GFP_KERNEL);
709 if (memcpy_from_msg(buf, msg, len)) {
716 if (sk->sk_state == BT_CONNECTED)
717 err = sco_send_frame(sk, buf, len, msg->msg_flags);
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;
764 /* use CVSD settings as fallback */
765 cp.max_latency = cpu_to_le16(0xffff);
766 cp.retrans_effort = 0xff;
770 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
775 static int sco_sock_recvmsg(struct socket *sock, struct msghdr *msg,
776 size_t len, int flags)
778 struct sock *sk = sock->sk;
779 struct sco_pinfo *pi = sco_pi(sk);
783 if (sk->sk_state == BT_CONNECT2 &&
784 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
785 sco_conn_defer_accept(pi->conn->hcon, pi->setting);
786 sk->sk_state = BT_CONFIG;
794 return bt_sock_recvmsg(sock, msg, len, flags);
797 static int sco_sock_setsockopt(struct socket *sock, int level, int optname,
798 char __user *optval, unsigned int optlen)
800 struct sock *sk = sock->sk;
802 struct bt_voice voice;
812 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
817 if (get_user(opt, (u32 __user *) optval)) {
823 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
825 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
829 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND &&
830 sk->sk_state != BT_CONNECT2) {
835 voice.setting = sco_pi(sk)->setting;
837 len = min_t(unsigned int, sizeof(voice), optlen);
838 if (copy_from_user((char *)&voice, optval, len)) {
843 /* Explicitly check for these values */
844 if (voice.setting != BT_VOICE_TRANSPARENT &&
845 voice.setting != BT_VOICE_CVSD_16BIT) {
850 sco_pi(sk)->setting = voice.setting;
862 static int sco_sock_getsockopt_old(struct socket *sock, int optname,
863 char __user *optval, int __user *optlen)
865 struct sock *sk = sock->sk;
866 struct sco_options opts;
867 struct sco_conninfo cinfo;
872 if (get_user(len, optlen))
879 if (sk->sk_state != BT_CONNECTED &&
880 !(sk->sk_state == BT_CONNECT2 &&
881 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
886 opts.mtu = sco_pi(sk)->conn->mtu;
888 BT_DBG("mtu %d", opts.mtu);
890 len = min_t(unsigned int, len, sizeof(opts));
891 if (copy_to_user(optval, (char *)&opts, len))
897 if (sk->sk_state != BT_CONNECTED &&
898 !(sk->sk_state == BT_CONNECT2 &&
899 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
904 memset(&cinfo, 0, sizeof(cinfo));
905 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
906 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
908 len = min_t(unsigned int, len, sizeof(cinfo));
909 if (copy_to_user(optval, (char *)&cinfo, len))
923 static int sco_sock_getsockopt(struct socket *sock, int level, int optname,
924 char __user *optval, int __user *optlen)
926 struct sock *sk = sock->sk;
928 struct bt_voice voice;
932 if (level == SOL_SCO)
933 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
935 if (get_user(len, optlen))
943 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
948 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
949 (u32 __user *)optval))
955 voice.setting = sco_pi(sk)->setting;
957 len = min_t(unsigned int, len, sizeof(voice));
958 if (copy_to_user(optval, (char *)&voice, len))
972 static int sco_sock_shutdown(struct socket *sock, int how)
974 struct sock *sk = sock->sk;
977 BT_DBG("sock %p, sk %p", sock, sk);
985 if (!sk->sk_shutdown) {
986 sk->sk_shutdown = SHUTDOWN_MASK;
987 sco_sock_clear_timer(sk);
988 __sco_sock_close(sk);
990 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
991 !(current->flags & PF_EXITING))
992 err = bt_sock_wait_state(sk, BT_CLOSED,
1002 static int sco_sock_release(struct socket *sock)
1004 struct sock *sk = sock->sk;
1007 BT_DBG("sock %p, sk %p", sock, sk);
1014 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
1015 !(current->flags & PF_EXITING)) {
1017 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1026 static void sco_conn_ready(struct sco_conn *conn)
1028 struct sock *parent;
1029 struct sock *sk = conn->sk;
1031 BT_DBG("conn %p", conn);
1034 sco_sock_clear_timer(sk);
1036 sk->sk_state = BT_CONNECTED;
1037 sk->sk_state_change(sk);
1040 sco_conn_lock(conn);
1043 sco_conn_unlock(conn);
1047 parent = sco_get_sock_listen(&conn->hcon->src);
1049 sco_conn_unlock(conn);
1053 bh_lock_sock(parent);
1055 sk = sco_sock_alloc(sock_net(parent), NULL,
1056 BTPROTO_SCO, GFP_ATOMIC, 0);
1058 bh_unlock_sock(parent);
1059 sco_conn_unlock(conn);
1063 sco_sock_init(sk, parent);
1065 bacpy(&sco_pi(sk)->src, &conn->hcon->src);
1066 bacpy(&sco_pi(sk)->dst, &conn->hcon->dst);
1068 hci_conn_hold(conn->hcon);
1069 __sco_chan_add(conn, sk, parent);
1071 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
1072 sk->sk_state = BT_CONNECT2;
1074 sk->sk_state = BT_CONNECTED;
1076 /* Wake up parent */
1077 parent->sk_data_ready(parent);
1079 bh_unlock_sock(parent);
1081 sco_conn_unlock(conn);
1085 /* ----- SCO interface with lower layer (HCI) ----- */
1086 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1091 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1093 /* Find listening sockets */
1094 read_lock(&sco_sk_list.lock);
1095 sk_for_each(sk, &sco_sk_list.head) {
1096 if (sk->sk_state != BT_LISTEN)
1099 if (!bacmp(&sco_pi(sk)->src, &hdev->bdaddr) ||
1100 !bacmp(&sco_pi(sk)->src, BDADDR_ANY)) {
1101 lm |= HCI_LM_ACCEPT;
1103 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1104 *flags |= HCI_PROTO_DEFER;
1108 read_unlock(&sco_sk_list.lock);
1113 static void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1115 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1118 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1121 struct sco_conn *conn;
1123 conn = sco_conn_add(hcon);
1125 sco_conn_ready(conn);
1127 sco_conn_del(hcon, bt_to_errno(status));
1130 static void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1132 if (hcon->type != SCO_LINK && hcon->type != ESCO_LINK)
1135 BT_DBG("hcon %p reason %d", hcon, reason);
1137 sco_conn_del(hcon, bt_to_errno(reason));
1140 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1142 struct sco_conn *conn = hcon->sco_data;
1147 BT_DBG("conn %p len %d", conn, skb->len);
1150 sco_recv_frame(conn, skb);
1158 static struct hci_cb sco_cb = {
1160 .connect_cfm = sco_connect_cfm,
1161 .disconn_cfm = sco_disconn_cfm,
1164 static int sco_debugfs_show(struct seq_file *f, void *p)
1168 read_lock(&sco_sk_list.lock);
1170 sk_for_each(sk, &sco_sk_list.head) {
1171 seq_printf(f, "%pMR %pMR %d\n", &sco_pi(sk)->src,
1172 &sco_pi(sk)->dst, sk->sk_state);
1175 read_unlock(&sco_sk_list.lock);
1180 static int sco_debugfs_open(struct inode *inode, struct file *file)
1182 return single_open(file, sco_debugfs_show, inode->i_private);
1185 static const struct file_operations sco_debugfs_fops = {
1186 .open = sco_debugfs_open,
1188 .llseek = seq_lseek,
1189 .release = single_release,
1192 static struct dentry *sco_debugfs;
1194 static const struct proto_ops sco_sock_ops = {
1195 .family = PF_BLUETOOTH,
1196 .owner = THIS_MODULE,
1197 .release = sco_sock_release,
1198 .bind = sco_sock_bind,
1199 .connect = sco_sock_connect,
1200 .listen = sco_sock_listen,
1201 .accept = sco_sock_accept,
1202 .getname = sco_sock_getname,
1203 .sendmsg = sco_sock_sendmsg,
1204 .recvmsg = sco_sock_recvmsg,
1205 .poll = bt_sock_poll,
1206 .ioctl = bt_sock_ioctl,
1207 .mmap = sock_no_mmap,
1208 .socketpair = sock_no_socketpair,
1209 .shutdown = sco_sock_shutdown,
1210 .setsockopt = sco_sock_setsockopt,
1211 .getsockopt = sco_sock_getsockopt
1214 static const struct net_proto_family sco_sock_family_ops = {
1215 .family = PF_BLUETOOTH,
1216 .owner = THIS_MODULE,
1217 .create = sco_sock_create,
1220 int __init sco_init(void)
1224 BUILD_BUG_ON(sizeof(struct sockaddr_sco) > sizeof(struct sockaddr));
1226 err = proto_register(&sco_proto, 0);
1230 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1232 BT_ERR("SCO socket registration failed");
1236 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1238 BT_ERR("Failed to create SCO proc file");
1239 bt_sock_unregister(BTPROTO_SCO);
1243 BT_INFO("SCO socket layer initialized");
1245 hci_register_cb(&sco_cb);
1247 if (IS_ERR_OR_NULL(bt_debugfs))
1250 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1251 NULL, &sco_debugfs_fops);
1256 proto_unregister(&sco_proto);
1262 bt_procfs_cleanup(&init_net, "sco");
1264 debugfs_remove(sco_debugfs);
1266 hci_unregister_cb(&sco_cb);
1268 bt_sock_unregister(BTPROTO_SCO);
1270 proto_unregister(&sco_proto);
1273 module_param(disable_esco, bool, 0644);
1274 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");