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>
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/kernel.h>
32 #include <linux/sched.h>
33 #include <linux/slab.h>
34 #include <linux/poll.h>
35 #include <linux/fcntl.h>
36 #include <linux/init.h>
37 #include <linux/interrupt.h>
38 #include <linux/socket.h>
39 #include <linux/skbuff.h>
40 #include <linux/device.h>
41 #include <linux/debugfs.h>
42 #include <linux/seq_file.h>
43 #include <linux/list.h>
46 #include <asm/system.h>
47 #include <linux/uaccess.h>
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
51 #include <net/bluetooth/sco.h>
53 static int disable_esco
;
55 static const struct proto_ops sco_sock_ops
;
57 static struct bt_sock_list sco_sk_list
= {
58 .lock
= __RW_LOCK_UNLOCKED(sco_sk_list
.lock
)
61 static void __sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
, struct sock
*parent
);
62 static void sco_chan_del(struct sock
*sk
, int err
);
64 static int sco_conn_del(struct hci_conn
*conn
, int err
);
66 static void sco_sock_close(struct sock
*sk
);
67 static void sco_sock_kill(struct sock
*sk
);
69 /* ---- SCO timers ---- */
70 static void sco_sock_timeout(unsigned long arg
)
72 struct sock
*sk
= (struct sock
*) arg
;
74 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
77 sk
->sk_err
= ETIMEDOUT
;
78 sk
->sk_state_change(sk
);
85 static void sco_sock_set_timer(struct sock
*sk
, long timeout
)
87 BT_DBG("sock %p state %d timeout %ld", sk
, sk
->sk_state
, timeout
);
88 sk_reset_timer(sk
, &sk
->sk_timer
, jiffies
+ timeout
);
91 static void sco_sock_clear_timer(struct sock
*sk
)
93 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
94 sk_stop_timer(sk
, &sk
->sk_timer
);
97 /* ---- SCO connections ---- */
98 static struct sco_conn
*sco_conn_add(struct hci_conn
*hcon
, __u8 status
)
100 struct hci_dev
*hdev
= hcon
->hdev
;
101 struct sco_conn
*conn
= hcon
->sco_data
;
106 conn
= kzalloc(sizeof(struct sco_conn
), GFP_ATOMIC
);
110 spin_lock_init(&conn
->lock
);
112 hcon
->sco_data
= conn
;
115 conn
->src
= &hdev
->bdaddr
;
116 conn
->dst
= &hcon
->dst
;
118 if (hdev
->sco_mtu
> 0)
119 conn
->mtu
= hdev
->sco_mtu
;
123 BT_DBG("hcon %p conn %p", hcon
, conn
);
128 static inline struct sock
*sco_chan_get(struct sco_conn
*conn
)
130 struct sock
*sk
= NULL
;
133 sco_conn_unlock(conn
);
137 static int sco_conn_del(struct hci_conn
*hcon
, int err
)
139 struct sco_conn
*conn
= hcon
->sco_data
;
145 BT_DBG("hcon %p conn %p, err %d", hcon
, conn
, err
);
148 sk
= sco_chan_get(conn
);
151 sco_sock_clear_timer(sk
);
152 sco_chan_del(sk
, err
);
157 hcon
->sco_data
= NULL
;
162 static inline int sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
, struct sock
*parent
)
170 __sco_chan_add(conn
, sk
, parent
);
172 sco_conn_unlock(conn
);
176 static int sco_connect(struct sock
*sk
)
178 bdaddr_t
*src
= &bt_sk(sk
)->src
;
179 bdaddr_t
*dst
= &bt_sk(sk
)->dst
;
180 struct sco_conn
*conn
;
181 struct hci_conn
*hcon
;
182 struct hci_dev
*hdev
;
185 BT_DBG("%s -> %s", batostr(src
), batostr(dst
));
187 hdev
= hci_get_route(dst
, src
);
189 return -EHOSTUNREACH
;
191 hci_dev_lock_bh(hdev
);
195 if (lmp_esco_capable(hdev
) && !disable_esco
)
200 hcon
= hci_connect(hdev
, type
, dst
, BT_SECURITY_LOW
, HCI_AT_NO_BONDING
);
204 conn
= sco_conn_add(hcon
, 0);
210 /* Update source addr of the socket */
211 bacpy(src
, conn
->src
);
213 err
= sco_chan_add(conn
, sk
, NULL
);
217 if (hcon
->state
== BT_CONNECTED
) {
218 sco_sock_clear_timer(sk
);
219 sk
->sk_state
= BT_CONNECTED
;
221 sk
->sk_state
= BT_CONNECT
;
222 sco_sock_set_timer(sk
, sk
->sk_sndtimeo
);
226 hci_dev_unlock_bh(hdev
);
231 static inline int sco_send_frame(struct sock
*sk
, struct msghdr
*msg
, int len
)
233 struct sco_conn
*conn
= sco_pi(sk
)->conn
;
237 /* Check outgoing MTU */
241 BT_DBG("sk %p len %d", sk
, len
);
243 count
= min_t(unsigned int, conn
->mtu
, len
);
244 skb
= bt_skb_send_alloc(sk
, count
,
245 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
249 if (memcpy_fromiovec(skb_put(skb
, count
), msg
->msg_iov
, count
)) {
254 hci_send_sco(conn
->hcon
, skb
);
259 static inline void sco_recv_frame(struct sco_conn
*conn
, struct sk_buff
*skb
)
261 struct sock
*sk
= sco_chan_get(conn
);
266 BT_DBG("sk %p len %d", sk
, skb
->len
);
268 if (sk
->sk_state
!= BT_CONNECTED
)
271 if (!sock_queue_rcv_skb(sk
, skb
))
278 /* -------- Socket interface ---------- */
279 static struct sock
*__sco_get_sock_by_addr(bdaddr_t
*ba
)
282 struct hlist_node
*node
;
284 sk_for_each(sk
, node
, &sco_sk_list
.head
)
285 if (!bacmp(&bt_sk(sk
)->src
, ba
))
292 /* Find socket listening on source bdaddr.
293 * Returns closest match.
295 static struct sock
*sco_get_sock_listen(bdaddr_t
*src
)
297 struct sock
*sk
= NULL
, *sk1
= NULL
;
298 struct hlist_node
*node
;
300 read_lock(&sco_sk_list
.lock
);
302 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
303 if (sk
->sk_state
!= BT_LISTEN
)
307 if (!bacmp(&bt_sk(sk
)->src
, src
))
311 if (!bacmp(&bt_sk(sk
)->src
, BDADDR_ANY
))
315 read_unlock(&sco_sk_list
.lock
);
317 return node
? sk
: sk1
;
320 static void sco_sock_destruct(struct sock
*sk
)
324 skb_queue_purge(&sk
->sk_receive_queue
);
325 skb_queue_purge(&sk
->sk_write_queue
);
328 static void sco_sock_cleanup_listen(struct sock
*parent
)
332 BT_DBG("parent %p", parent
);
334 /* Close not yet accepted channels */
335 while ((sk
= bt_accept_dequeue(parent
, NULL
))) {
340 parent
->sk_state
= BT_CLOSED
;
341 sock_set_flag(parent
, SOCK_ZAPPED
);
344 /* Kill socket (only if zapped and orphan)
345 * Must be called on unlocked socket.
347 static void sco_sock_kill(struct sock
*sk
)
349 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
)
352 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
354 /* Kill poor orphan */
355 bt_sock_unlink(&sco_sk_list
, sk
);
356 sock_set_flag(sk
, SOCK_DEAD
);
360 static void __sco_sock_close(struct sock
*sk
)
362 BT_DBG("sk %p state %d socket %p", sk
, sk
->sk_state
, sk
->sk_socket
);
364 switch (sk
->sk_state
) {
366 sco_sock_cleanup_listen(sk
);
373 sco_chan_del(sk
, ECONNRESET
);
377 sock_set_flag(sk
, SOCK_ZAPPED
);
382 /* Must be called on unlocked socket. */
383 static void sco_sock_close(struct sock
*sk
)
385 sco_sock_clear_timer(sk
);
387 __sco_sock_close(sk
);
392 static void sco_sock_init(struct sock
*sk
, struct sock
*parent
)
397 sk
->sk_type
= parent
->sk_type
;
400 static struct proto sco_proto
= {
402 .owner
= THIS_MODULE
,
403 .obj_size
= sizeof(struct sco_pinfo
)
406 static struct sock
*sco_sock_alloc(struct net
*net
, struct socket
*sock
, int proto
, gfp_t prio
)
410 sk
= sk_alloc(net
, PF_BLUETOOTH
, prio
, &sco_proto
);
414 sock_init_data(sock
, sk
);
415 INIT_LIST_HEAD(&bt_sk(sk
)->accept_q
);
417 sk
->sk_destruct
= sco_sock_destruct
;
418 sk
->sk_sndtimeo
= SCO_CONN_TIMEOUT
;
420 sock_reset_flag(sk
, SOCK_ZAPPED
);
422 sk
->sk_protocol
= proto
;
423 sk
->sk_state
= BT_OPEN
;
425 setup_timer(&sk
->sk_timer
, sco_sock_timeout
, (unsigned long)sk
);
427 bt_sock_link(&sco_sk_list
, sk
);
431 static int sco_sock_create(struct net
*net
, struct socket
*sock
, int protocol
,
436 BT_DBG("sock %p", sock
);
438 sock
->state
= SS_UNCONNECTED
;
440 if (sock
->type
!= SOCK_SEQPACKET
)
441 return -ESOCKTNOSUPPORT
;
443 sock
->ops
= &sco_sock_ops
;
445 sk
= sco_sock_alloc(net
, sock
, protocol
, GFP_ATOMIC
);
449 sco_sock_init(sk
, NULL
);
453 static int sco_sock_bind(struct socket
*sock
, struct sockaddr
*addr
, int addr_len
)
455 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
456 struct sock
*sk
= sock
->sk
;
457 bdaddr_t
*src
= &sa
->sco_bdaddr
;
460 BT_DBG("sk %p %s", sk
, batostr(&sa
->sco_bdaddr
));
462 if (!addr
|| addr
->sa_family
!= AF_BLUETOOTH
)
467 if (sk
->sk_state
!= BT_OPEN
) {
472 write_lock_bh(&sco_sk_list
.lock
);
474 if (bacmp(src
, BDADDR_ANY
) && __sco_get_sock_by_addr(src
)) {
477 /* Save source address */
478 bacpy(&bt_sk(sk
)->src
, &sa
->sco_bdaddr
);
479 sk
->sk_state
= BT_BOUND
;
482 write_unlock_bh(&sco_sk_list
.lock
);
489 static int sco_sock_connect(struct socket
*sock
, struct sockaddr
*addr
, int alen
, int flags
)
491 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
492 struct sock
*sk
= sock
->sk
;
498 if (alen
< sizeof(struct sockaddr_sco
) ||
499 addr
->sa_family
!= AF_BLUETOOTH
)
502 if (sk
->sk_state
!= BT_OPEN
&& sk
->sk_state
!= BT_BOUND
)
505 if (sk
->sk_type
!= SOCK_SEQPACKET
)
510 /* Set destination address and psm */
511 bacpy(&bt_sk(sk
)->dst
, &sa
->sco_bdaddr
);
513 err
= sco_connect(sk
);
517 err
= bt_sock_wait_state(sk
, BT_CONNECTED
,
518 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
525 static int sco_sock_listen(struct socket
*sock
, int backlog
)
527 struct sock
*sk
= sock
->sk
;
530 BT_DBG("sk %p backlog %d", sk
, backlog
);
534 if (sk
->sk_state
!= BT_BOUND
|| sock
->type
!= SOCK_SEQPACKET
) {
539 sk
->sk_max_ack_backlog
= backlog
;
540 sk
->sk_ack_backlog
= 0;
541 sk
->sk_state
= BT_LISTEN
;
548 static int sco_sock_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
550 DECLARE_WAITQUEUE(wait
, current
);
551 struct sock
*sk
= sock
->sk
, *ch
;
557 if (sk
->sk_state
!= BT_LISTEN
) {
562 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
564 BT_DBG("sk %p timeo %ld", sk
, timeo
);
566 /* Wait for an incoming connection. (wake-one). */
567 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
568 while (!(ch
= bt_accept_dequeue(sk
, newsock
))) {
569 set_current_state(TASK_INTERRUPTIBLE
);
576 timeo
= schedule_timeout(timeo
);
579 if (sk
->sk_state
!= BT_LISTEN
) {
584 if (signal_pending(current
)) {
585 err
= sock_intr_errno(timeo
);
589 set_current_state(TASK_RUNNING
);
590 remove_wait_queue(sk_sleep(sk
), &wait
);
595 newsock
->state
= SS_CONNECTED
;
597 BT_DBG("new socket %p", ch
);
604 static int sco_sock_getname(struct socket
*sock
, struct sockaddr
*addr
, int *len
, int peer
)
606 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
607 struct sock
*sk
= sock
->sk
;
609 BT_DBG("sock %p, sk %p", sock
, sk
);
611 addr
->sa_family
= AF_BLUETOOTH
;
612 *len
= sizeof(struct sockaddr_sco
);
615 bacpy(&sa
->sco_bdaddr
, &bt_sk(sk
)->dst
);
617 bacpy(&sa
->sco_bdaddr
, &bt_sk(sk
)->src
);
622 static int sco_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
623 struct msghdr
*msg
, size_t len
)
625 struct sock
*sk
= sock
->sk
;
628 BT_DBG("sock %p, sk %p", sock
, sk
);
630 err
= sock_error(sk
);
634 if (msg
->msg_flags
& MSG_OOB
)
639 if (sk
->sk_state
== BT_CONNECTED
)
640 err
= sco_send_frame(sk
, msg
, len
);
648 static int sco_sock_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, unsigned int optlen
)
650 struct sock
*sk
= sock
->sk
;
667 static int sco_sock_getsockopt_old(struct socket
*sock
, int optname
, char __user
*optval
, int __user
*optlen
)
669 struct sock
*sk
= sock
->sk
;
670 struct sco_options opts
;
671 struct sco_conninfo cinfo
;
676 if (get_user(len
, optlen
))
683 if (sk
->sk_state
!= BT_CONNECTED
) {
688 opts
.mtu
= sco_pi(sk
)->conn
->mtu
;
690 BT_DBG("mtu %d", opts
.mtu
);
692 len
= min_t(unsigned int, len
, sizeof(opts
));
693 if (copy_to_user(optval
, (char *)&opts
, len
))
699 if (sk
->sk_state
!= BT_CONNECTED
) {
704 memset(&cinfo
, 0, sizeof(cinfo
));
705 cinfo
.hci_handle
= sco_pi(sk
)->conn
->hcon
->handle
;
706 memcpy(cinfo
.dev_class
, sco_pi(sk
)->conn
->hcon
->dev_class
, 3);
708 len
= min_t(unsigned int, len
, sizeof(cinfo
));
709 if (copy_to_user(optval
, (char *)&cinfo
, len
))
723 static int sco_sock_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
)
725 struct sock
*sk
= sock
->sk
;
730 if (level
== SOL_SCO
)
731 return sco_sock_getsockopt_old(sock
, optname
, optval
, optlen
);
733 if (get_user(len
, optlen
))
748 static int sco_sock_shutdown(struct socket
*sock
, int how
)
750 struct sock
*sk
= sock
->sk
;
753 BT_DBG("sock %p, sk %p", sock
, sk
);
759 if (!sk
->sk_shutdown
) {
760 sk
->sk_shutdown
= SHUTDOWN_MASK
;
761 sco_sock_clear_timer(sk
);
762 __sco_sock_close(sk
);
764 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
)
765 err
= bt_sock_wait_state(sk
, BT_CLOSED
,
772 static int sco_sock_release(struct socket
*sock
)
774 struct sock
*sk
= sock
->sk
;
777 BT_DBG("sock %p, sk %p", sock
, sk
);
784 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
) {
786 err
= bt_sock_wait_state(sk
, BT_CLOSED
, sk
->sk_lingertime
);
795 static void __sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
, struct sock
*parent
)
797 BT_DBG("conn %p", conn
);
799 sco_pi(sk
)->conn
= conn
;
803 bt_accept_enqueue(parent
, sk
);
807 * Must be called on the locked socket. */
808 static void sco_chan_del(struct sock
*sk
, int err
)
810 struct sco_conn
*conn
;
812 conn
= sco_pi(sk
)->conn
;
814 BT_DBG("sk %p, conn %p, err %d", sk
, conn
, err
);
819 sco_pi(sk
)->conn
= NULL
;
820 sco_conn_unlock(conn
);
821 hci_conn_put(conn
->hcon
);
824 sk
->sk_state
= BT_CLOSED
;
826 sk
->sk_state_change(sk
);
828 sock_set_flag(sk
, SOCK_ZAPPED
);
831 static void sco_conn_ready(struct sco_conn
*conn
)
834 struct sock
*sk
= conn
->sk
;
836 BT_DBG("conn %p", conn
);
841 sco_sock_clear_timer(sk
);
843 sk
->sk_state
= BT_CONNECTED
;
844 sk
->sk_state_change(sk
);
847 parent
= sco_get_sock_listen(conn
->src
);
851 bh_lock_sock(parent
);
853 sk
= sco_sock_alloc(sock_net(parent
), NULL
,
854 BTPROTO_SCO
, GFP_ATOMIC
);
856 bh_unlock_sock(parent
);
860 sco_sock_init(sk
, parent
);
862 bacpy(&bt_sk(sk
)->src
, conn
->src
);
863 bacpy(&bt_sk(sk
)->dst
, conn
->dst
);
865 hci_conn_hold(conn
->hcon
);
866 __sco_chan_add(conn
, sk
, parent
);
868 sk
->sk_state
= BT_CONNECTED
;
871 parent
->sk_data_ready(parent
, 1);
873 bh_unlock_sock(parent
);
877 sco_conn_unlock(conn
);
880 /* ----- SCO interface with lower layer (HCI) ----- */
881 static int sco_connect_ind(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
, __u8 type
)
883 register struct sock
*sk
;
884 struct hlist_node
*node
;
887 if (type
!= SCO_LINK
&& type
!= ESCO_LINK
)
890 BT_DBG("hdev %s, bdaddr %s", hdev
->name
, batostr(bdaddr
));
892 /* Find listening sockets */
893 read_lock(&sco_sk_list
.lock
);
894 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
895 if (sk
->sk_state
!= BT_LISTEN
)
898 if (!bacmp(&bt_sk(sk
)->src
, &hdev
->bdaddr
) ||
899 !bacmp(&bt_sk(sk
)->src
, BDADDR_ANY
)) {
904 read_unlock(&sco_sk_list
.lock
);
909 static int sco_connect_cfm(struct hci_conn
*hcon
, __u8 status
)
911 BT_DBG("hcon %p bdaddr %s status %d", hcon
, batostr(&hcon
->dst
), status
);
913 if (hcon
->type
!= SCO_LINK
&& hcon
->type
!= ESCO_LINK
)
917 struct sco_conn
*conn
;
919 conn
= sco_conn_add(hcon
, status
);
921 sco_conn_ready(conn
);
923 sco_conn_del(hcon
, bt_err(status
));
928 static int sco_disconn_cfm(struct hci_conn
*hcon
, __u8 reason
)
930 BT_DBG("hcon %p reason %d", hcon
, reason
);
932 if (hcon
->type
!= SCO_LINK
&& hcon
->type
!= ESCO_LINK
)
935 sco_conn_del(hcon
, bt_err(reason
));
940 static int sco_recv_scodata(struct hci_conn
*hcon
, struct sk_buff
*skb
)
942 struct sco_conn
*conn
= hcon
->sco_data
;
947 BT_DBG("conn %p len %d", conn
, skb
->len
);
950 sco_recv_frame(conn
, skb
);
959 static int sco_debugfs_show(struct seq_file
*f
, void *p
)
962 struct hlist_node
*node
;
964 read_lock_bh(&sco_sk_list
.lock
);
966 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
967 seq_printf(f
, "%s %s %d\n", batostr(&bt_sk(sk
)->src
),
968 batostr(&bt_sk(sk
)->dst
), sk
->sk_state
);
971 read_unlock_bh(&sco_sk_list
.lock
);
976 static int sco_debugfs_open(struct inode
*inode
, struct file
*file
)
978 return single_open(file
, sco_debugfs_show
, inode
->i_private
);
981 static const struct file_operations sco_debugfs_fops
= {
982 .open
= sco_debugfs_open
,
985 .release
= single_release
,
988 static struct dentry
*sco_debugfs
;
990 static const struct proto_ops sco_sock_ops
= {
991 .family
= PF_BLUETOOTH
,
992 .owner
= THIS_MODULE
,
993 .release
= sco_sock_release
,
994 .bind
= sco_sock_bind
,
995 .connect
= sco_sock_connect
,
996 .listen
= sco_sock_listen
,
997 .accept
= sco_sock_accept
,
998 .getname
= sco_sock_getname
,
999 .sendmsg
= sco_sock_sendmsg
,
1000 .recvmsg
= bt_sock_recvmsg
,
1001 .poll
= bt_sock_poll
,
1002 .ioctl
= bt_sock_ioctl
,
1003 .mmap
= sock_no_mmap
,
1004 .socketpair
= sock_no_socketpair
,
1005 .shutdown
= sco_sock_shutdown
,
1006 .setsockopt
= sco_sock_setsockopt
,
1007 .getsockopt
= sco_sock_getsockopt
1010 static const struct net_proto_family sco_sock_family_ops
= {
1011 .family
= PF_BLUETOOTH
,
1012 .owner
= THIS_MODULE
,
1013 .create
= sco_sock_create
,
1016 static struct hci_proto sco_hci_proto
= {
1018 .id
= HCI_PROTO_SCO
,
1019 .connect_ind
= sco_connect_ind
,
1020 .connect_cfm
= sco_connect_cfm
,
1021 .disconn_cfm
= sco_disconn_cfm
,
1022 .recv_scodata
= sco_recv_scodata
1025 int __init
sco_init(void)
1029 err
= proto_register(&sco_proto
, 0);
1033 err
= bt_sock_register(BTPROTO_SCO
, &sco_sock_family_ops
);
1035 BT_ERR("SCO socket registration failed");
1039 err
= hci_register_proto(&sco_hci_proto
);
1041 BT_ERR("SCO protocol registration failed");
1042 bt_sock_unregister(BTPROTO_SCO
);
1047 sco_debugfs
= debugfs_create_file("sco", 0444,
1048 bt_debugfs
, NULL
, &sco_debugfs_fops
);
1050 BT_ERR("Failed to create SCO debug file");
1053 BT_INFO("SCO socket layer initialized");
1058 proto_unregister(&sco_proto
);
1062 void __exit
sco_exit(void)
1064 debugfs_remove(sco_debugfs
);
1066 if (bt_sock_unregister(BTPROTO_SCO
) < 0)
1067 BT_ERR("SCO socket unregistration failed");
1069 if (hci_unregister_proto(&sco_hci_proto
) < 0)
1070 BT_ERR("SCO protocol unregistration failed");
1072 proto_unregister(&sco_proto
);
1075 module_param(disable_esco
, bool, 0644);
1076 MODULE_PARM_DESC(disable_esco
, "Disable eSCO connection creation");