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 static void __sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
, struct sock
*parent
);
44 static void sco_chan_del(struct sock
*sk
, int err
);
46 static void sco_sock_close(struct sock
*sk
);
47 static void sco_sock_kill(struct sock
*sk
);
49 /* ---- SCO timers ---- */
50 static void sco_sock_timeout(unsigned long arg
)
52 struct sock
*sk
= (struct sock
*) arg
;
54 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
57 sk
->sk_err
= ETIMEDOUT
;
58 sk
->sk_state_change(sk
);
65 static void sco_sock_set_timer(struct sock
*sk
, long timeout
)
67 BT_DBG("sock %p state %d timeout %ld", sk
, sk
->sk_state
, timeout
);
68 sk_reset_timer(sk
, &sk
->sk_timer
, jiffies
+ timeout
);
71 static void sco_sock_clear_timer(struct sock
*sk
)
73 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
74 sk_stop_timer(sk
, &sk
->sk_timer
);
77 /* ---- SCO connections ---- */
78 static struct sco_conn
*sco_conn_add(struct hci_conn
*hcon
)
80 struct hci_dev
*hdev
= hcon
->hdev
;
81 struct sco_conn
*conn
= hcon
->sco_data
;
86 conn
= kzalloc(sizeof(struct sco_conn
), GFP_ATOMIC
);
90 spin_lock_init(&conn
->lock
);
92 hcon
->sco_data
= conn
;
95 conn
->src
= &hdev
->bdaddr
;
96 conn
->dst
= &hcon
->dst
;
98 if (hdev
->sco_mtu
> 0)
99 conn
->mtu
= hdev
->sco_mtu
;
103 BT_DBG("hcon %p conn %p", hcon
, conn
);
108 static struct sock
*sco_chan_get(struct sco_conn
*conn
)
110 struct sock
*sk
= NULL
;
113 sco_conn_unlock(conn
);
117 static int sco_conn_del(struct hci_conn
*hcon
, int err
)
119 struct sco_conn
*conn
= hcon
->sco_data
;
125 BT_DBG("hcon %p conn %p, err %d", hcon
, conn
, err
);
128 sk
= sco_chan_get(conn
);
131 sco_sock_clear_timer(sk
);
132 sco_chan_del(sk
, err
);
137 hcon
->sco_data
= NULL
;
142 static int sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
,
151 __sco_chan_add(conn
, sk
, parent
);
153 sco_conn_unlock(conn
);
157 static int sco_connect(struct sock
*sk
)
159 bdaddr_t
*src
= &bt_sk(sk
)->src
;
160 bdaddr_t
*dst
= &bt_sk(sk
)->dst
;
161 struct sco_conn
*conn
;
162 struct hci_conn
*hcon
;
163 struct hci_dev
*hdev
;
166 BT_DBG("%pMR -> %pMR", src
, dst
);
168 hdev
= hci_get_route(dst
, src
);
170 return -EHOSTUNREACH
;
174 if (lmp_esco_capable(hdev
) && !disable_esco
)
179 hcon
= hci_connect(hdev
, type
, dst
, BDADDR_BREDR
, BT_SECURITY_LOW
,
186 conn
= sco_conn_add(hcon
);
193 /* Update source addr of the socket */
194 bacpy(src
, conn
->src
);
196 err
= sco_chan_add(conn
, sk
, NULL
);
200 if (hcon
->state
== BT_CONNECTED
) {
201 sco_sock_clear_timer(sk
);
202 sk
->sk_state
= BT_CONNECTED
;
204 sk
->sk_state
= BT_CONNECT
;
205 sco_sock_set_timer(sk
, sk
->sk_sndtimeo
);
209 hci_dev_unlock(hdev
);
214 static int sco_send_frame(struct sock
*sk
, struct msghdr
*msg
, int len
)
216 struct sco_conn
*conn
= sco_pi(sk
)->conn
;
220 /* Check outgoing MTU */
224 BT_DBG("sk %p len %d", sk
, len
);
226 skb
= bt_skb_send_alloc(sk
, len
, msg
->msg_flags
& MSG_DONTWAIT
, &err
);
230 if (memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
)) {
235 hci_send_sco(conn
->hcon
, skb
);
240 static void sco_recv_frame(struct sco_conn
*conn
, struct sk_buff
*skb
)
242 struct sock
*sk
= sco_chan_get(conn
);
247 BT_DBG("sk %p len %d", sk
, skb
->len
);
249 if (sk
->sk_state
!= BT_CONNECTED
)
252 if (!sock_queue_rcv_skb(sk
, skb
))
259 /* -------- Socket interface ---------- */
260 static struct sock
*__sco_get_sock_listen_by_addr(bdaddr_t
*ba
)
262 struct hlist_node
*node
;
265 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
266 if (sk
->sk_state
!= BT_LISTEN
)
269 if (!bacmp(&bt_sk(sk
)->src
, ba
))
276 /* Find socket listening on source bdaddr.
277 * Returns closest match.
279 static struct sock
*sco_get_sock_listen(bdaddr_t
*src
)
281 struct sock
*sk
= NULL
, *sk1
= NULL
;
282 struct hlist_node
*node
;
284 read_lock(&sco_sk_list
.lock
);
286 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
287 if (sk
->sk_state
!= BT_LISTEN
)
291 if (!bacmp(&bt_sk(sk
)->src
, src
))
295 if (!bacmp(&bt_sk(sk
)->src
, BDADDR_ANY
))
299 read_unlock(&sco_sk_list
.lock
);
301 return node
? sk
: sk1
;
304 static void sco_sock_destruct(struct sock
*sk
)
308 skb_queue_purge(&sk
->sk_receive_queue
);
309 skb_queue_purge(&sk
->sk_write_queue
);
312 static void sco_sock_cleanup_listen(struct sock
*parent
)
316 BT_DBG("parent %p", parent
);
318 /* Close not yet accepted channels */
319 while ((sk
= bt_accept_dequeue(parent
, NULL
))) {
324 parent
->sk_state
= BT_CLOSED
;
325 sock_set_flag(parent
, SOCK_ZAPPED
);
328 /* Kill socket (only if zapped and orphan)
329 * Must be called on unlocked socket.
331 static void sco_sock_kill(struct sock
*sk
)
333 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
)
336 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
338 /* Kill poor orphan */
339 bt_sock_unlink(&sco_sk_list
, sk
);
340 sock_set_flag(sk
, SOCK_DEAD
);
344 static void __sco_sock_close(struct sock
*sk
)
346 BT_DBG("sk %p state %d socket %p", sk
, sk
->sk_state
, sk
->sk_socket
);
348 switch (sk
->sk_state
) {
350 sco_sock_cleanup_listen(sk
);
355 if (sco_pi(sk
)->conn
->hcon
) {
356 sk
->sk_state
= BT_DISCONN
;
357 sco_sock_set_timer(sk
, SCO_DISCONN_TIMEOUT
);
358 hci_conn_put(sco_pi(sk
)->conn
->hcon
);
359 sco_pi(sk
)->conn
->hcon
= NULL
;
361 sco_chan_del(sk
, ECONNRESET
);
367 sco_chan_del(sk
, ECONNRESET
);
371 sock_set_flag(sk
, SOCK_ZAPPED
);
376 /* Must be called on unlocked socket. */
377 static void sco_sock_close(struct sock
*sk
)
379 sco_sock_clear_timer(sk
);
381 __sco_sock_close(sk
);
386 static void sco_sock_init(struct sock
*sk
, struct sock
*parent
)
391 sk
->sk_type
= parent
->sk_type
;
392 bt_sk(sk
)->flags
= bt_sk(parent
)->flags
;
393 security_sk_clone(parent
, sk
);
397 static struct proto sco_proto
= {
399 .owner
= THIS_MODULE
,
400 .obj_size
= sizeof(struct sco_pinfo
)
403 static struct sock
*sco_sock_alloc(struct net
*net
, struct socket
*sock
, int proto
, gfp_t prio
)
407 sk
= sk_alloc(net
, PF_BLUETOOTH
, prio
, &sco_proto
);
411 sock_init_data(sock
, sk
);
412 INIT_LIST_HEAD(&bt_sk(sk
)->accept_q
);
414 sk
->sk_destruct
= sco_sock_destruct
;
415 sk
->sk_sndtimeo
= SCO_CONN_TIMEOUT
;
417 sock_reset_flag(sk
, SOCK_ZAPPED
);
419 sk
->sk_protocol
= proto
;
420 sk
->sk_state
= BT_OPEN
;
422 setup_timer(&sk
->sk_timer
, sco_sock_timeout
, (unsigned long)sk
);
424 bt_sock_link(&sco_sk_list
, sk
);
428 static int sco_sock_create(struct net
*net
, struct socket
*sock
, int protocol
,
433 BT_DBG("sock %p", sock
);
435 sock
->state
= SS_UNCONNECTED
;
437 if (sock
->type
!= SOCK_SEQPACKET
)
438 return -ESOCKTNOSUPPORT
;
440 sock
->ops
= &sco_sock_ops
;
442 sk
= sco_sock_alloc(net
, sock
, protocol
, GFP_ATOMIC
);
446 sco_sock_init(sk
, NULL
);
450 static int sco_sock_bind(struct socket
*sock
, struct sockaddr
*addr
, int addr_len
)
452 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
453 struct sock
*sk
= sock
->sk
;
456 BT_DBG("sk %p %pMR", sk
, &sa
->sco_bdaddr
);
458 if (!addr
|| addr
->sa_family
!= AF_BLUETOOTH
)
463 if (sk
->sk_state
!= BT_OPEN
) {
468 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
473 bacpy(&bt_sk(sk
)->src
, &sa
->sco_bdaddr
);
475 sk
->sk_state
= BT_BOUND
;
482 static int sco_sock_connect(struct socket
*sock
, struct sockaddr
*addr
, int alen
, int flags
)
484 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
485 struct sock
*sk
= sock
->sk
;
491 if (alen
< sizeof(struct sockaddr_sco
) ||
492 addr
->sa_family
!= AF_BLUETOOTH
)
495 if (sk
->sk_state
!= BT_OPEN
&& sk
->sk_state
!= BT_BOUND
)
498 if (sk
->sk_type
!= SOCK_SEQPACKET
)
503 /* Set destination address and psm */
504 bacpy(&bt_sk(sk
)->dst
, &sa
->sco_bdaddr
);
506 err
= sco_connect(sk
);
510 err
= bt_sock_wait_state(sk
, BT_CONNECTED
,
511 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
518 static int sco_sock_listen(struct socket
*sock
, int backlog
)
520 struct sock
*sk
= sock
->sk
;
521 bdaddr_t
*src
= &bt_sk(sk
)->src
;
524 BT_DBG("sk %p backlog %d", sk
, backlog
);
528 if (sk
->sk_state
!= BT_BOUND
) {
533 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
538 write_lock(&sco_sk_list
.lock
);
540 if (__sco_get_sock_listen_by_addr(src
)) {
545 sk
->sk_max_ack_backlog
= backlog
;
546 sk
->sk_ack_backlog
= 0;
548 sk
->sk_state
= BT_LISTEN
;
551 write_unlock(&sco_sk_list
.lock
);
558 static int sco_sock_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
560 DECLARE_WAITQUEUE(wait
, current
);
561 struct sock
*sk
= sock
->sk
, *ch
;
567 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
569 BT_DBG("sk %p timeo %ld", sk
, timeo
);
571 /* Wait for an incoming connection. (wake-one). */
572 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
574 set_current_state(TASK_INTERRUPTIBLE
);
576 if (sk
->sk_state
!= BT_LISTEN
) {
581 ch
= bt_accept_dequeue(sk
, newsock
);
590 if (signal_pending(current
)) {
591 err
= sock_intr_errno(timeo
);
596 timeo
= schedule_timeout(timeo
);
599 __set_current_state(TASK_RUNNING
);
600 remove_wait_queue(sk_sleep(sk
), &wait
);
605 newsock
->state
= SS_CONNECTED
;
607 BT_DBG("new socket %p", ch
);
614 static int sco_sock_getname(struct socket
*sock
, struct sockaddr
*addr
, int *len
, int peer
)
616 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
617 struct sock
*sk
= sock
->sk
;
619 BT_DBG("sock %p, sk %p", sock
, sk
);
621 addr
->sa_family
= AF_BLUETOOTH
;
622 *len
= sizeof(struct sockaddr_sco
);
625 bacpy(&sa
->sco_bdaddr
, &bt_sk(sk
)->dst
);
627 bacpy(&sa
->sco_bdaddr
, &bt_sk(sk
)->src
);
632 static int sco_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
633 struct msghdr
*msg
, size_t len
)
635 struct sock
*sk
= sock
->sk
;
638 BT_DBG("sock %p, sk %p", sock
, sk
);
640 err
= sock_error(sk
);
644 if (msg
->msg_flags
& MSG_OOB
)
649 if (sk
->sk_state
== BT_CONNECTED
)
650 err
= sco_send_frame(sk
, msg
, len
);
658 static int sco_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
659 struct msghdr
*msg
, size_t len
, int flags
)
661 struct sock
*sk
= sock
->sk
;
662 struct sco_pinfo
*pi
= sco_pi(sk
);
666 if (sk
->sk_state
== BT_CONNECT2
&&
667 test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
)) {
668 hci_conn_accept(pi
->conn
->hcon
, 0);
669 sk
->sk_state
= BT_CONFIG
;
677 return bt_sock_recvmsg(iocb
, sock
, msg
, len
, flags
);
680 static int sco_sock_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, unsigned int optlen
)
682 struct sock
*sk
= sock
->sk
;
693 if (sk
->sk_state
!= BT_BOUND
&& sk
->sk_state
!= BT_LISTEN
) {
698 if (get_user(opt
, (u32 __user
*) optval
)) {
704 set_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
);
706 clear_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
);
718 static int sco_sock_getsockopt_old(struct socket
*sock
, int optname
, char __user
*optval
, int __user
*optlen
)
720 struct sock
*sk
= sock
->sk
;
721 struct sco_options opts
;
722 struct sco_conninfo cinfo
;
727 if (get_user(len
, optlen
))
734 if (sk
->sk_state
!= BT_CONNECTED
) {
739 opts
.mtu
= sco_pi(sk
)->conn
->mtu
;
741 BT_DBG("mtu %d", opts
.mtu
);
743 len
= min_t(unsigned int, len
, sizeof(opts
));
744 if (copy_to_user(optval
, (char *)&opts
, len
))
750 if (sk
->sk_state
!= BT_CONNECTED
) {
755 memset(&cinfo
, 0, sizeof(cinfo
));
756 cinfo
.hci_handle
= sco_pi(sk
)->conn
->hcon
->handle
;
757 memcpy(cinfo
.dev_class
, sco_pi(sk
)->conn
->hcon
->dev_class
, 3);
759 len
= min_t(unsigned int, len
, sizeof(cinfo
));
760 if (copy_to_user(optval
, (char *)&cinfo
, len
))
774 static int sco_sock_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
)
776 struct sock
*sk
= sock
->sk
;
781 if (level
== SOL_SCO
)
782 return sco_sock_getsockopt_old(sock
, optname
, optval
, optlen
);
784 if (get_user(len
, optlen
))
792 if (sk
->sk_state
!= BT_BOUND
&& sk
->sk_state
!= BT_LISTEN
) {
797 if (put_user(test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
),
798 (u32 __user
*) optval
))
812 static int sco_sock_shutdown(struct socket
*sock
, int how
)
814 struct sock
*sk
= sock
->sk
;
817 BT_DBG("sock %p, sk %p", sock
, sk
);
823 if (!sk
->sk_shutdown
) {
824 sk
->sk_shutdown
= SHUTDOWN_MASK
;
825 sco_sock_clear_timer(sk
);
826 __sco_sock_close(sk
);
828 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
)
829 err
= bt_sock_wait_state(sk
, BT_CLOSED
,
836 static int sco_sock_release(struct socket
*sock
)
838 struct sock
*sk
= sock
->sk
;
841 BT_DBG("sock %p, sk %p", sock
, sk
);
848 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
) {
850 err
= bt_sock_wait_state(sk
, BT_CLOSED
, sk
->sk_lingertime
);
859 static void __sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
, struct sock
*parent
)
861 BT_DBG("conn %p", conn
);
863 sco_pi(sk
)->conn
= conn
;
867 bt_accept_enqueue(parent
, sk
);
871 * Must be called on the locked socket. */
872 static void sco_chan_del(struct sock
*sk
, int err
)
874 struct sco_conn
*conn
;
876 conn
= sco_pi(sk
)->conn
;
878 BT_DBG("sk %p, conn %p, err %d", sk
, conn
, err
);
883 sco_pi(sk
)->conn
= NULL
;
884 sco_conn_unlock(conn
);
887 hci_conn_put(conn
->hcon
);
890 sk
->sk_state
= BT_CLOSED
;
892 sk
->sk_state_change(sk
);
894 sock_set_flag(sk
, SOCK_ZAPPED
);
897 static void sco_conn_ready(struct sco_conn
*conn
)
900 struct sock
*sk
= conn
->sk
;
902 BT_DBG("conn %p", conn
);
907 sco_sock_clear_timer(sk
);
909 sk
->sk_state
= BT_CONNECTED
;
910 sk
->sk_state_change(sk
);
913 parent
= sco_get_sock_listen(conn
->src
);
917 bh_lock_sock(parent
);
919 sk
= sco_sock_alloc(sock_net(parent
), NULL
,
920 BTPROTO_SCO
, GFP_ATOMIC
);
922 bh_unlock_sock(parent
);
926 sco_sock_init(sk
, parent
);
928 bacpy(&bt_sk(sk
)->src
, conn
->src
);
929 bacpy(&bt_sk(sk
)->dst
, conn
->dst
);
931 hci_conn_hold(conn
->hcon
);
932 __sco_chan_add(conn
, sk
, parent
);
934 if (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(parent
)->flags
))
935 sk
->sk_state
= BT_CONNECT2
;
937 sk
->sk_state
= BT_CONNECTED
;
940 parent
->sk_data_ready(parent
, 1);
942 bh_unlock_sock(parent
);
946 sco_conn_unlock(conn
);
949 /* ----- SCO interface with lower layer (HCI) ----- */
950 int sco_connect_ind(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, __u8
*flags
)
953 struct hlist_node
*node
;
956 BT_DBG("hdev %s, bdaddr %pMR", hdev
->name
, bdaddr
);
958 /* Find listening sockets */
959 read_lock(&sco_sk_list
.lock
);
960 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
961 if (sk
->sk_state
!= BT_LISTEN
)
964 if (!bacmp(&bt_sk(sk
)->src
, &hdev
->bdaddr
) ||
965 !bacmp(&bt_sk(sk
)->src
, BDADDR_ANY
)) {
968 if (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(sk
)->flags
))
969 *flags
|= HCI_PROTO_DEFER
;
973 read_unlock(&sco_sk_list
.lock
);
978 void sco_connect_cfm(struct hci_conn
*hcon
, __u8 status
)
980 BT_DBG("hcon %p bdaddr %pMR status %d", hcon
, &hcon
->dst
, status
);
982 struct sco_conn
*conn
;
984 conn
= sco_conn_add(hcon
);
986 sco_conn_ready(conn
);
988 sco_conn_del(hcon
, bt_to_errno(status
));
991 void sco_disconn_cfm(struct hci_conn
*hcon
, __u8 reason
)
993 BT_DBG("hcon %p reason %d", hcon
, reason
);
995 sco_conn_del(hcon
, bt_to_errno(reason
));
998 int sco_recv_scodata(struct hci_conn
*hcon
, struct sk_buff
*skb
)
1000 struct sco_conn
*conn
= hcon
->sco_data
;
1005 BT_DBG("conn %p len %d", conn
, skb
->len
);
1008 sco_recv_frame(conn
, skb
);
1017 static int sco_debugfs_show(struct seq_file
*f
, void *p
)
1020 struct hlist_node
*node
;
1022 read_lock(&sco_sk_list
.lock
);
1024 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
1025 seq_printf(f
, "%pMR %pMR %d\n", &bt_sk(sk
)->src
,
1026 &bt_sk(sk
)->dst
, sk
->sk_state
);
1029 read_unlock(&sco_sk_list
.lock
);
1034 static int sco_debugfs_open(struct inode
*inode
, struct file
*file
)
1036 return single_open(file
, sco_debugfs_show
, inode
->i_private
);
1039 static const struct file_operations sco_debugfs_fops
= {
1040 .open
= sco_debugfs_open
,
1042 .llseek
= seq_lseek
,
1043 .release
= single_release
,
1046 static struct dentry
*sco_debugfs
;
1048 static const struct proto_ops sco_sock_ops
= {
1049 .family
= PF_BLUETOOTH
,
1050 .owner
= THIS_MODULE
,
1051 .release
= sco_sock_release
,
1052 .bind
= sco_sock_bind
,
1053 .connect
= sco_sock_connect
,
1054 .listen
= sco_sock_listen
,
1055 .accept
= sco_sock_accept
,
1056 .getname
= sco_sock_getname
,
1057 .sendmsg
= sco_sock_sendmsg
,
1058 .recvmsg
= sco_sock_recvmsg
,
1059 .poll
= bt_sock_poll
,
1060 .ioctl
= bt_sock_ioctl
,
1061 .mmap
= sock_no_mmap
,
1062 .socketpair
= sock_no_socketpair
,
1063 .shutdown
= sco_sock_shutdown
,
1064 .setsockopt
= sco_sock_setsockopt
,
1065 .getsockopt
= sco_sock_getsockopt
1068 static const struct net_proto_family sco_sock_family_ops
= {
1069 .family
= PF_BLUETOOTH
,
1070 .owner
= THIS_MODULE
,
1071 .create
= sco_sock_create
,
1074 int __init
sco_init(void)
1078 err
= proto_register(&sco_proto
, 0);
1082 err
= bt_sock_register(BTPROTO_SCO
, &sco_sock_family_ops
);
1084 BT_ERR("SCO socket registration failed");
1088 err
= bt_procfs_init(THIS_MODULE
, &init_net
, "sco", &sco_sk_list
, NULL
);
1090 BT_ERR("Failed to create SCO proc file");
1091 bt_sock_unregister(BTPROTO_SCO
);
1096 sco_debugfs
= debugfs_create_file("sco", 0444, bt_debugfs
,
1097 NULL
, &sco_debugfs_fops
);
1099 BT_ERR("Failed to create SCO debug file");
1102 BT_INFO("SCO socket layer initialized");
1107 proto_unregister(&sco_proto
);
1111 void __exit
sco_exit(void)
1113 bt_procfs_cleanup(&init_net
, "sco");
1115 debugfs_remove(sco_debugfs
);
1117 if (bt_sock_unregister(BTPROTO_SCO
) < 0)
1118 BT_ERR("SCO socket unregistration failed");
1120 proto_unregister(&sco_proto
);
1123 module_param(disable_esco
, bool, 0644);
1124 MODULE_PARM_DESC(disable_esco
, "Disable eSCO connection creation");