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>
44 #include <linux/security.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 bool 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
;
193 if (lmp_esco_capable(hdev
) && !disable_esco
)
198 hcon
= hci_connect(hdev
, type
, dst
, BT_SECURITY_LOW
, HCI_AT_NO_BONDING
);
204 conn
= sco_conn_add(hcon
, 0);
211 /* Update source addr of the socket */
212 bacpy(src
, conn
->src
);
214 err
= sco_chan_add(conn
, sk
, NULL
);
218 if (hcon
->state
== BT_CONNECTED
) {
219 sco_sock_clear_timer(sk
);
220 sk
->sk_state
= BT_CONNECTED
;
222 sk
->sk_state
= BT_CONNECT
;
223 sco_sock_set_timer(sk
, sk
->sk_sndtimeo
);
227 hci_dev_unlock(hdev
);
232 static inline int sco_send_frame(struct sock
*sk
, struct msghdr
*msg
, int len
)
234 struct sco_conn
*conn
= sco_pi(sk
)->conn
;
238 /* Check outgoing MTU */
242 BT_DBG("sk %p len %d", sk
, len
);
244 count
= min_t(unsigned int, conn
->mtu
, len
);
245 skb
= bt_skb_send_alloc(sk
, count
,
246 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
250 if (memcpy_fromiovec(skb_put(skb
, count
), msg
->msg_iov
, count
)) {
255 hci_send_sco(conn
->hcon
, skb
);
260 static inline void sco_recv_frame(struct sco_conn
*conn
, struct sk_buff
*skb
)
262 struct sock
*sk
= sco_chan_get(conn
);
267 BT_DBG("sk %p len %d", sk
, skb
->len
);
269 if (sk
->sk_state
!= BT_CONNECTED
)
272 if (!sock_queue_rcv_skb(sk
, skb
))
279 /* -------- Socket interface ---------- */
280 static struct sock
*__sco_get_sock_by_addr(bdaddr_t
*ba
)
283 struct hlist_node
*node
;
285 sk_for_each(sk
, node
, &sco_sk_list
.head
)
286 if (!bacmp(&bt_sk(sk
)->src
, ba
))
293 /* Find socket listening on source bdaddr.
294 * Returns closest match.
296 static struct sock
*sco_get_sock_listen(bdaddr_t
*src
)
298 struct sock
*sk
= NULL
, *sk1
= NULL
;
299 struct hlist_node
*node
;
301 read_lock(&sco_sk_list
.lock
);
303 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
304 if (sk
->sk_state
!= BT_LISTEN
)
308 if (!bacmp(&bt_sk(sk
)->src
, src
))
312 if (!bacmp(&bt_sk(sk
)->src
, BDADDR_ANY
))
316 read_unlock(&sco_sk_list
.lock
);
318 return node
? sk
: sk1
;
321 static void sco_sock_destruct(struct sock
*sk
)
325 skb_queue_purge(&sk
->sk_receive_queue
);
326 skb_queue_purge(&sk
->sk_write_queue
);
329 static void sco_sock_cleanup_listen(struct sock
*parent
)
333 BT_DBG("parent %p", parent
);
335 /* Close not yet accepted channels */
336 while ((sk
= bt_accept_dequeue(parent
, NULL
))) {
341 parent
->sk_state
= BT_CLOSED
;
342 sock_set_flag(parent
, SOCK_ZAPPED
);
345 /* Kill socket (only if zapped and orphan)
346 * Must be called on unlocked socket.
348 static void sco_sock_kill(struct sock
*sk
)
350 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
)
353 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
355 /* Kill poor orphan */
356 bt_sock_unlink(&sco_sk_list
, sk
);
357 sock_set_flag(sk
, SOCK_DEAD
);
361 static void __sco_sock_close(struct sock
*sk
)
363 BT_DBG("sk %p state %d socket %p", sk
, sk
->sk_state
, sk
->sk_socket
);
365 switch (sk
->sk_state
) {
367 sco_sock_cleanup_listen(sk
);
372 if (sco_pi(sk
)->conn
) {
373 sk
->sk_state
= BT_DISCONN
;
374 sco_sock_set_timer(sk
, SCO_DISCONN_TIMEOUT
);
375 hci_conn_put(sco_pi(sk
)->conn
->hcon
);
376 sco_pi(sk
)->conn
->hcon
= NULL
;
378 sco_chan_del(sk
, ECONNRESET
);
383 sco_chan_del(sk
, ECONNRESET
);
387 sock_set_flag(sk
, SOCK_ZAPPED
);
392 /* Must be called on unlocked socket. */
393 static void sco_sock_close(struct sock
*sk
)
395 sco_sock_clear_timer(sk
);
397 __sco_sock_close(sk
);
402 static void sco_sock_init(struct sock
*sk
, struct sock
*parent
)
407 sk
->sk_type
= parent
->sk_type
;
408 security_sk_clone(parent
, sk
);
412 static struct proto sco_proto
= {
414 .owner
= THIS_MODULE
,
415 .obj_size
= sizeof(struct sco_pinfo
)
418 static struct sock
*sco_sock_alloc(struct net
*net
, struct socket
*sock
, int proto
, gfp_t prio
)
422 sk
= sk_alloc(net
, PF_BLUETOOTH
, prio
, &sco_proto
);
426 sock_init_data(sock
, sk
);
427 INIT_LIST_HEAD(&bt_sk(sk
)->accept_q
);
429 sk
->sk_destruct
= sco_sock_destruct
;
430 sk
->sk_sndtimeo
= SCO_CONN_TIMEOUT
;
432 sock_reset_flag(sk
, SOCK_ZAPPED
);
434 sk
->sk_protocol
= proto
;
435 sk
->sk_state
= BT_OPEN
;
437 setup_timer(&sk
->sk_timer
, sco_sock_timeout
, (unsigned long)sk
);
439 bt_sock_link(&sco_sk_list
, sk
);
443 static int sco_sock_create(struct net
*net
, struct socket
*sock
, int protocol
,
448 BT_DBG("sock %p", sock
);
450 sock
->state
= SS_UNCONNECTED
;
452 if (sock
->type
!= SOCK_SEQPACKET
)
453 return -ESOCKTNOSUPPORT
;
455 sock
->ops
= &sco_sock_ops
;
457 sk
= sco_sock_alloc(net
, sock
, protocol
, GFP_ATOMIC
);
461 sco_sock_init(sk
, NULL
);
465 static int sco_sock_bind(struct socket
*sock
, struct sockaddr
*addr
, int addr_len
)
467 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
468 struct sock
*sk
= sock
->sk
;
469 bdaddr_t
*src
= &sa
->sco_bdaddr
;
472 BT_DBG("sk %p %s", sk
, batostr(&sa
->sco_bdaddr
));
474 if (!addr
|| addr
->sa_family
!= AF_BLUETOOTH
)
479 if (sk
->sk_state
!= BT_OPEN
) {
484 write_lock(&sco_sk_list
.lock
);
486 if (bacmp(src
, BDADDR_ANY
) && __sco_get_sock_by_addr(src
)) {
489 /* Save source address */
490 bacpy(&bt_sk(sk
)->src
, &sa
->sco_bdaddr
);
491 sk
->sk_state
= BT_BOUND
;
494 write_unlock(&sco_sk_list
.lock
);
501 static int sco_sock_connect(struct socket
*sock
, struct sockaddr
*addr
, int alen
, int flags
)
503 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
504 struct sock
*sk
= sock
->sk
;
510 if (alen
< sizeof(struct sockaddr_sco
) ||
511 addr
->sa_family
!= AF_BLUETOOTH
)
514 if (sk
->sk_state
!= BT_OPEN
&& sk
->sk_state
!= BT_BOUND
)
517 if (sk
->sk_type
!= SOCK_SEQPACKET
)
522 /* Set destination address and psm */
523 bacpy(&bt_sk(sk
)->dst
, &sa
->sco_bdaddr
);
525 err
= sco_connect(sk
);
529 err
= bt_sock_wait_state(sk
, BT_CONNECTED
,
530 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
537 static int sco_sock_listen(struct socket
*sock
, int backlog
)
539 struct sock
*sk
= sock
->sk
;
542 BT_DBG("sk %p backlog %d", sk
, backlog
);
546 if (sk
->sk_state
!= BT_BOUND
|| sock
->type
!= SOCK_SEQPACKET
) {
551 sk
->sk_max_ack_backlog
= backlog
;
552 sk
->sk_ack_backlog
= 0;
553 sk
->sk_state
= BT_LISTEN
;
560 static int sco_sock_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
562 DECLARE_WAITQUEUE(wait
, current
);
563 struct sock
*sk
= sock
->sk
, *ch
;
569 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
571 BT_DBG("sk %p timeo %ld", sk
, timeo
);
573 /* Wait for an incoming connection. (wake-one). */
574 add_wait_queue_exclusive(sk_sleep(sk
), &wait
);
576 set_current_state(TASK_INTERRUPTIBLE
);
578 if (sk
->sk_state
!= BT_LISTEN
) {
583 ch
= bt_accept_dequeue(sk
, newsock
);
592 if (signal_pending(current
)) {
593 err
= sock_intr_errno(timeo
);
598 timeo
= schedule_timeout(timeo
);
601 __set_current_state(TASK_RUNNING
);
602 remove_wait_queue(sk_sleep(sk
), &wait
);
607 newsock
->state
= SS_CONNECTED
;
609 BT_DBG("new socket %p", ch
);
616 static int sco_sock_getname(struct socket
*sock
, struct sockaddr
*addr
, int *len
, int peer
)
618 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
619 struct sock
*sk
= sock
->sk
;
621 BT_DBG("sock %p, sk %p", sock
, sk
);
623 addr
->sa_family
= AF_BLUETOOTH
;
624 *len
= sizeof(struct sockaddr_sco
);
627 bacpy(&sa
->sco_bdaddr
, &bt_sk(sk
)->dst
);
629 bacpy(&sa
->sco_bdaddr
, &bt_sk(sk
)->src
);
634 static int sco_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
635 struct msghdr
*msg
, size_t len
)
637 struct sock
*sk
= sock
->sk
;
640 BT_DBG("sock %p, sk %p", sock
, sk
);
642 err
= sock_error(sk
);
646 if (msg
->msg_flags
& MSG_OOB
)
651 if (sk
->sk_state
== BT_CONNECTED
)
652 err
= sco_send_frame(sk
, msg
, len
);
660 static int sco_sock_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, unsigned int optlen
)
662 struct sock
*sk
= sock
->sk
;
679 static int sco_sock_getsockopt_old(struct socket
*sock
, int optname
, char __user
*optval
, int __user
*optlen
)
681 struct sock
*sk
= sock
->sk
;
682 struct sco_options opts
;
683 struct sco_conninfo cinfo
;
688 if (get_user(len
, optlen
))
695 if (sk
->sk_state
!= BT_CONNECTED
) {
700 opts
.mtu
= sco_pi(sk
)->conn
->mtu
;
702 BT_DBG("mtu %d", opts
.mtu
);
704 len
= min_t(unsigned int, len
, sizeof(opts
));
705 if (copy_to_user(optval
, (char *)&opts
, len
))
711 if (sk
->sk_state
!= BT_CONNECTED
) {
716 memset(&cinfo
, 0, sizeof(cinfo
));
717 cinfo
.hci_handle
= sco_pi(sk
)->conn
->hcon
->handle
;
718 memcpy(cinfo
.dev_class
, sco_pi(sk
)->conn
->hcon
->dev_class
, 3);
720 len
= min_t(unsigned int, len
, sizeof(cinfo
));
721 if (copy_to_user(optval
, (char *)&cinfo
, len
))
735 static int sco_sock_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
)
737 struct sock
*sk
= sock
->sk
;
742 if (level
== SOL_SCO
)
743 return sco_sock_getsockopt_old(sock
, optname
, optval
, optlen
);
745 if (get_user(len
, optlen
))
760 static int sco_sock_shutdown(struct socket
*sock
, int how
)
762 struct sock
*sk
= sock
->sk
;
765 BT_DBG("sock %p, sk %p", sock
, sk
);
771 if (!sk
->sk_shutdown
) {
772 sk
->sk_shutdown
= SHUTDOWN_MASK
;
773 sco_sock_clear_timer(sk
);
774 __sco_sock_close(sk
);
776 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
)
777 err
= bt_sock_wait_state(sk
, BT_CLOSED
,
784 static int sco_sock_release(struct socket
*sock
)
786 struct sock
*sk
= sock
->sk
;
789 BT_DBG("sock %p, sk %p", sock
, sk
);
796 if (sock_flag(sk
, SOCK_LINGER
) && sk
->sk_lingertime
) {
798 err
= bt_sock_wait_state(sk
, BT_CLOSED
, sk
->sk_lingertime
);
807 static void __sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
, struct sock
*parent
)
809 BT_DBG("conn %p", conn
);
811 sco_pi(sk
)->conn
= conn
;
815 bt_accept_enqueue(parent
, sk
);
819 * Must be called on the locked socket. */
820 static void sco_chan_del(struct sock
*sk
, int err
)
822 struct sco_conn
*conn
;
824 conn
= sco_pi(sk
)->conn
;
826 BT_DBG("sk %p, conn %p, err %d", sk
, conn
, err
);
831 sco_pi(sk
)->conn
= NULL
;
832 sco_conn_unlock(conn
);
835 hci_conn_put(conn
->hcon
);
838 sk
->sk_state
= BT_CLOSED
;
840 sk
->sk_state_change(sk
);
842 sock_set_flag(sk
, SOCK_ZAPPED
);
845 static void sco_conn_ready(struct sco_conn
*conn
)
848 struct sock
*sk
= conn
->sk
;
850 BT_DBG("conn %p", conn
);
855 sco_sock_clear_timer(sk
);
857 sk
->sk_state
= BT_CONNECTED
;
858 sk
->sk_state_change(sk
);
861 parent
= sco_get_sock_listen(conn
->src
);
865 bh_lock_sock(parent
);
867 sk
= sco_sock_alloc(sock_net(parent
), NULL
,
868 BTPROTO_SCO
, GFP_ATOMIC
);
870 bh_unlock_sock(parent
);
874 sco_sock_init(sk
, parent
);
876 bacpy(&bt_sk(sk
)->src
, conn
->src
);
877 bacpy(&bt_sk(sk
)->dst
, conn
->dst
);
879 hci_conn_hold(conn
->hcon
);
880 __sco_chan_add(conn
, sk
, parent
);
882 sk
->sk_state
= BT_CONNECTED
;
885 parent
->sk_data_ready(parent
, 1);
887 bh_unlock_sock(parent
);
891 sco_conn_unlock(conn
);
894 /* ----- SCO interface with lower layer (HCI) ----- */
895 int sco_connect_ind(struct hci_dev
*hdev
, bdaddr_t
*bdaddr
)
897 register struct sock
*sk
;
898 struct hlist_node
*node
;
901 BT_DBG("hdev %s, bdaddr %s", hdev
->name
, batostr(bdaddr
));
903 /* Find listening sockets */
904 read_lock(&sco_sk_list
.lock
);
905 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
906 if (sk
->sk_state
!= BT_LISTEN
)
909 if (!bacmp(&bt_sk(sk
)->src
, &hdev
->bdaddr
) ||
910 !bacmp(&bt_sk(sk
)->src
, BDADDR_ANY
)) {
915 read_unlock(&sco_sk_list
.lock
);
920 int sco_connect_cfm(struct hci_conn
*hcon
, __u8 status
)
922 BT_DBG("hcon %p bdaddr %s status %d", hcon
, batostr(&hcon
->dst
), status
);
924 struct sco_conn
*conn
;
926 conn
= sco_conn_add(hcon
, status
);
928 sco_conn_ready(conn
);
930 sco_conn_del(hcon
, bt_to_errno(status
));
935 int sco_disconn_cfm(struct hci_conn
*hcon
, __u8 reason
)
937 BT_DBG("hcon %p reason %d", hcon
, reason
);
939 sco_conn_del(hcon
, bt_to_errno(reason
));
943 int sco_recv_scodata(struct hci_conn
*hcon
, struct sk_buff
*skb
)
945 struct sco_conn
*conn
= hcon
->sco_data
;
950 BT_DBG("conn %p len %d", conn
, skb
->len
);
953 sco_recv_frame(conn
, skb
);
962 static int sco_debugfs_show(struct seq_file
*f
, void *p
)
965 struct hlist_node
*node
;
967 read_lock(&sco_sk_list
.lock
);
969 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
970 seq_printf(f
, "%s %s %d\n", batostr(&bt_sk(sk
)->src
),
971 batostr(&bt_sk(sk
)->dst
), sk
->sk_state
);
974 read_unlock(&sco_sk_list
.lock
);
979 static int sco_debugfs_open(struct inode
*inode
, struct file
*file
)
981 return single_open(file
, sco_debugfs_show
, inode
->i_private
);
984 static const struct file_operations sco_debugfs_fops
= {
985 .open
= sco_debugfs_open
,
988 .release
= single_release
,
991 static struct dentry
*sco_debugfs
;
993 static const struct proto_ops sco_sock_ops
= {
994 .family
= PF_BLUETOOTH
,
995 .owner
= THIS_MODULE
,
996 .release
= sco_sock_release
,
997 .bind
= sco_sock_bind
,
998 .connect
= sco_sock_connect
,
999 .listen
= sco_sock_listen
,
1000 .accept
= sco_sock_accept
,
1001 .getname
= sco_sock_getname
,
1002 .sendmsg
= sco_sock_sendmsg
,
1003 .recvmsg
= bt_sock_recvmsg
,
1004 .poll
= bt_sock_poll
,
1005 .ioctl
= bt_sock_ioctl
,
1006 .mmap
= sock_no_mmap
,
1007 .socketpair
= sock_no_socketpair
,
1008 .shutdown
= sco_sock_shutdown
,
1009 .setsockopt
= sco_sock_setsockopt
,
1010 .getsockopt
= sco_sock_getsockopt
1013 static const struct net_proto_family sco_sock_family_ops
= {
1014 .family
= PF_BLUETOOTH
,
1015 .owner
= THIS_MODULE
,
1016 .create
= sco_sock_create
,
1019 int __init
sco_init(void)
1023 err
= proto_register(&sco_proto
, 0);
1027 err
= bt_sock_register(BTPROTO_SCO
, &sco_sock_family_ops
);
1029 BT_ERR("SCO socket registration failed");
1034 sco_debugfs
= debugfs_create_file("sco", 0444,
1035 bt_debugfs
, NULL
, &sco_debugfs_fops
);
1037 BT_ERR("Failed to create SCO debug file");
1040 BT_INFO("SCO socket layer initialized");
1045 proto_unregister(&sco_proto
);
1049 void __exit
sco_exit(void)
1051 debugfs_remove(sco_debugfs
);
1053 if (bt_sock_unregister(BTPROTO_SCO
) < 0)
1054 BT_ERR("SCO socket unregistration failed");
1056 proto_unregister(&sco_proto
);
1059 module_param(disable_esco
, bool, 0644);
1060 MODULE_PARM_DESC(disable_esco
, "Disable eSCO connection creation");