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_KERNEL);
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)
264 sk_for_each(sk, &sco_sk_list.head) {
265 if (sk->sk_state != BT_LISTEN)
268 if (!bacmp(&bt_sk(sk)->src, ba))
275 /* Find socket listening on source bdaddr.
276 * Returns closest match.
278 static struct sock *sco_get_sock_listen(bdaddr_t *src)
280 struct sock *sk = NULL, *sk1 = NULL;
282 read_lock(&sco_sk_list.lock);
284 sk_for_each(sk, &sco_sk_list.head) {
285 if (sk->sk_state != BT_LISTEN)
289 if (!bacmp(&bt_sk(sk)->src, src))
293 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
297 read_unlock(&sco_sk_list.lock);
299 return sk ? sk : sk1;
302 static void sco_sock_destruct(struct sock *sk)
306 skb_queue_purge(&sk->sk_receive_queue);
307 skb_queue_purge(&sk->sk_write_queue);
310 static void sco_sock_cleanup_listen(struct sock *parent)
314 BT_DBG("parent %p", parent);
316 /* Close not yet accepted channels */
317 while ((sk = bt_accept_dequeue(parent, NULL))) {
322 parent->sk_state = BT_CLOSED;
323 sock_set_flag(parent, SOCK_ZAPPED);
326 /* Kill socket (only if zapped and orphan)
327 * Must be called on unlocked socket.
329 static void sco_sock_kill(struct sock *sk)
331 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
334 BT_DBG("sk %p state %d", sk, sk->sk_state);
336 /* Kill poor orphan */
337 bt_sock_unlink(&sco_sk_list, sk);
338 sock_set_flag(sk, SOCK_DEAD);
342 static void __sco_sock_close(struct sock *sk)
344 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
346 switch (sk->sk_state) {
348 sco_sock_cleanup_listen(sk);
353 if (sco_pi(sk)->conn->hcon) {
354 sk->sk_state = BT_DISCONN;
355 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
356 hci_conn_drop(sco_pi(sk)->conn->hcon);
357 sco_pi(sk)->conn->hcon = NULL;
359 sco_chan_del(sk, ECONNRESET);
365 sco_chan_del(sk, ECONNRESET);
369 sock_set_flag(sk, SOCK_ZAPPED);
374 /* Must be called on unlocked socket. */
375 static void sco_sock_close(struct sock *sk)
377 sco_sock_clear_timer(sk);
379 __sco_sock_close(sk);
384 static void sco_sock_init(struct sock *sk, struct sock *parent)
389 sk->sk_type = parent->sk_type;
390 bt_sk(sk)->flags = bt_sk(parent)->flags;
391 security_sk_clone(parent, sk);
395 static struct proto sco_proto = {
397 .owner = THIS_MODULE,
398 .obj_size = sizeof(struct sco_pinfo)
401 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
405 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
409 sock_init_data(sock, sk);
410 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
412 sk->sk_destruct = sco_sock_destruct;
413 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
415 sock_reset_flag(sk, SOCK_ZAPPED);
417 sk->sk_protocol = proto;
418 sk->sk_state = BT_OPEN;
420 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
422 bt_sock_link(&sco_sk_list, sk);
426 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
431 BT_DBG("sock %p", sock);
433 sock->state = SS_UNCONNECTED;
435 if (sock->type != SOCK_SEQPACKET)
436 return -ESOCKTNOSUPPORT;
438 sock->ops = &sco_sock_ops;
440 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
444 sco_sock_init(sk, NULL);
448 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
450 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
451 struct sock *sk = sock->sk;
454 BT_DBG("sk %p %pMR", sk, &sa->sco_bdaddr);
456 if (!addr || addr->sa_family != AF_BLUETOOTH)
461 if (sk->sk_state != BT_OPEN) {
466 if (sk->sk_type != SOCK_SEQPACKET) {
471 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
473 sk->sk_state = BT_BOUND;
480 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
482 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
483 struct sock *sk = sock->sk;
488 if (alen < sizeof(struct sockaddr_sco) ||
489 addr->sa_family != AF_BLUETOOTH)
492 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
495 if (sk->sk_type != SOCK_SEQPACKET)
500 /* Set destination address and psm */
501 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
503 err = sco_connect(sk);
507 err = bt_sock_wait_state(sk, BT_CONNECTED,
508 sock_sndtimeo(sk, flags & O_NONBLOCK));
515 static int sco_sock_listen(struct socket *sock, int backlog)
517 struct sock *sk = sock->sk;
518 bdaddr_t *src = &bt_sk(sk)->src;
521 BT_DBG("sk %p backlog %d", sk, backlog);
525 if (sk->sk_state != BT_BOUND) {
530 if (sk->sk_type != SOCK_SEQPACKET) {
535 write_lock(&sco_sk_list.lock);
537 if (__sco_get_sock_listen_by_addr(src)) {
542 sk->sk_max_ack_backlog = backlog;
543 sk->sk_ack_backlog = 0;
545 sk->sk_state = BT_LISTEN;
548 write_unlock(&sco_sk_list.lock);
555 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
557 DECLARE_WAITQUEUE(wait, current);
558 struct sock *sk = sock->sk, *ch;
564 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
566 BT_DBG("sk %p timeo %ld", sk, timeo);
568 /* Wait for an incoming connection. (wake-one). */
569 add_wait_queue_exclusive(sk_sleep(sk), &wait);
571 set_current_state(TASK_INTERRUPTIBLE);
573 if (sk->sk_state != BT_LISTEN) {
578 ch = bt_accept_dequeue(sk, newsock);
587 if (signal_pending(current)) {
588 err = sock_intr_errno(timeo);
593 timeo = schedule_timeout(timeo);
596 __set_current_state(TASK_RUNNING);
597 remove_wait_queue(sk_sleep(sk), &wait);
602 newsock->state = SS_CONNECTED;
604 BT_DBG("new socket %p", ch);
611 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
613 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
614 struct sock *sk = sock->sk;
616 BT_DBG("sock %p, sk %p", sock, sk);
618 addr->sa_family = AF_BLUETOOTH;
619 *len = sizeof(struct sockaddr_sco);
622 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
624 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
629 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
630 struct msghdr *msg, size_t len)
632 struct sock *sk = sock->sk;
635 BT_DBG("sock %p, sk %p", sock, sk);
637 err = sock_error(sk);
641 if (msg->msg_flags & MSG_OOB)
646 if (sk->sk_state == BT_CONNECTED)
647 err = sco_send_frame(sk, msg, len);
655 static void sco_conn_defer_accept(struct hci_conn *conn, int mask)
657 struct hci_dev *hdev = conn->hdev;
659 BT_DBG("conn %p", conn);
661 conn->state = BT_CONFIG;
663 if (!lmp_esco_capable(hdev)) {
664 struct hci_cp_accept_conn_req cp;
666 bacpy(&cp.bdaddr, &conn->dst);
668 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
669 cp.role = 0x00; /* Become master */
671 cp.role = 0x01; /* Remain slave */
673 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
675 struct hci_cp_accept_sync_conn_req cp;
677 bacpy(&cp.bdaddr, &conn->dst);
678 cp.pkt_type = cpu_to_le16(conn->pkt_type);
680 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
681 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
682 cp.max_latency = __constant_cpu_to_le16(0xffff);
683 cp.content_format = cpu_to_le16(hdev->voice_setting);
684 cp.retrans_effort = 0xff;
686 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
691 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
692 struct msghdr *msg, size_t len, int flags)
694 struct sock *sk = sock->sk;
695 struct sco_pinfo *pi = sco_pi(sk);
699 if (sk->sk_state == BT_CONNECT2 &&
700 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
701 sco_conn_defer_accept(pi->conn->hcon, 0);
702 sk->sk_state = BT_CONFIG;
703 msg->msg_namelen = 0;
711 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
714 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
716 struct sock *sk = sock->sk;
727 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
732 if (get_user(opt, (u32 __user *) optval)) {
738 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
740 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
752 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
754 struct sock *sk = sock->sk;
755 struct sco_options opts;
756 struct sco_conninfo cinfo;
761 if (get_user(len, optlen))
768 if (sk->sk_state != BT_CONNECTED) {
773 opts.mtu = sco_pi(sk)->conn->mtu;
775 BT_DBG("mtu %d", opts.mtu);
777 len = min_t(unsigned int, len, sizeof(opts));
778 if (copy_to_user(optval, (char *)&opts, len))
784 if (sk->sk_state != BT_CONNECTED) {
789 memset(&cinfo, 0, sizeof(cinfo));
790 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
791 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
793 len = min_t(unsigned int, len, sizeof(cinfo));
794 if (copy_to_user(optval, (char *)&cinfo, len))
808 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
810 struct sock *sk = sock->sk;
815 if (level == SOL_SCO)
816 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
818 if (get_user(len, optlen))
826 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
831 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
832 (u32 __user *) optval))
846 static int sco_sock_shutdown(struct socket *sock, int how)
848 struct sock *sk = sock->sk;
851 BT_DBG("sock %p, sk %p", sock, sk);
857 if (!sk->sk_shutdown) {
858 sk->sk_shutdown = SHUTDOWN_MASK;
859 sco_sock_clear_timer(sk);
860 __sco_sock_close(sk);
862 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
863 err = bt_sock_wait_state(sk, BT_CLOSED,
870 static int sco_sock_release(struct socket *sock)
872 struct sock *sk = sock->sk;
875 BT_DBG("sock %p, sk %p", sock, sk);
882 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
884 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
893 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
895 BT_DBG("conn %p", conn);
897 sco_pi(sk)->conn = conn;
901 bt_accept_enqueue(parent, sk);
905 * Must be called on the locked socket. */
906 static void sco_chan_del(struct sock *sk, int err)
908 struct sco_conn *conn;
910 conn = sco_pi(sk)->conn;
912 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
917 sco_pi(sk)->conn = NULL;
918 sco_conn_unlock(conn);
921 hci_conn_drop(conn->hcon);
924 sk->sk_state = BT_CLOSED;
926 sk->sk_state_change(sk);
928 sock_set_flag(sk, SOCK_ZAPPED);
931 static void sco_conn_ready(struct sco_conn *conn)
934 struct sock *sk = conn->sk;
936 BT_DBG("conn %p", conn);
939 sco_sock_clear_timer(sk);
941 sk->sk_state = BT_CONNECTED;
942 sk->sk_state_change(sk);
947 parent = sco_get_sock_listen(conn->src);
949 sco_conn_unlock(conn);
953 bh_lock_sock(parent);
955 sk = sco_sock_alloc(sock_net(parent), NULL,
956 BTPROTO_SCO, GFP_ATOMIC);
958 bh_unlock_sock(parent);
959 sco_conn_unlock(conn);
963 sco_sock_init(sk, parent);
965 bacpy(&bt_sk(sk)->src, conn->src);
966 bacpy(&bt_sk(sk)->dst, conn->dst);
968 hci_conn_hold(conn->hcon);
969 __sco_chan_add(conn, sk, parent);
971 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
972 sk->sk_state = BT_CONNECT2;
974 sk->sk_state = BT_CONNECTED;
977 parent->sk_data_ready(parent, 1);
979 bh_unlock_sock(parent);
981 sco_conn_unlock(conn);
985 /* ----- SCO interface with lower layer (HCI) ----- */
986 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
991 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
993 /* Find listening sockets */
994 read_lock(&sco_sk_list.lock);
995 sk_for_each(sk, &sco_sk_list.head) {
996 if (sk->sk_state != BT_LISTEN)
999 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
1000 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
1001 lm |= HCI_LM_ACCEPT;
1003 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1004 *flags |= HCI_PROTO_DEFER;
1008 read_unlock(&sco_sk_list.lock);
1013 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1015 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1017 struct sco_conn *conn;
1019 conn = sco_conn_add(hcon);
1021 sco_conn_ready(conn);
1023 sco_conn_del(hcon, bt_to_errno(status));
1026 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1028 BT_DBG("hcon %p reason %d", hcon, reason);
1030 sco_conn_del(hcon, bt_to_errno(reason));
1033 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1035 struct sco_conn *conn = hcon->sco_data;
1040 BT_DBG("conn %p len %d", conn, skb->len);
1043 sco_recv_frame(conn, skb);
1052 static int sco_debugfs_show(struct seq_file *f, void *p)
1056 read_lock(&sco_sk_list.lock);
1058 sk_for_each(sk, &sco_sk_list.head) {
1059 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1060 &bt_sk(sk)->dst, sk->sk_state);
1063 read_unlock(&sco_sk_list.lock);
1068 static int sco_debugfs_open(struct inode *inode, struct file *file)
1070 return single_open(file, sco_debugfs_show, inode->i_private);
1073 static const struct file_operations sco_debugfs_fops = {
1074 .open = sco_debugfs_open,
1076 .llseek = seq_lseek,
1077 .release = single_release,
1080 static struct dentry *sco_debugfs;
1082 static const struct proto_ops sco_sock_ops = {
1083 .family = PF_BLUETOOTH,
1084 .owner = THIS_MODULE,
1085 .release = sco_sock_release,
1086 .bind = sco_sock_bind,
1087 .connect = sco_sock_connect,
1088 .listen = sco_sock_listen,
1089 .accept = sco_sock_accept,
1090 .getname = sco_sock_getname,
1091 .sendmsg = sco_sock_sendmsg,
1092 .recvmsg = sco_sock_recvmsg,
1093 .poll = bt_sock_poll,
1094 .ioctl = bt_sock_ioctl,
1095 .mmap = sock_no_mmap,
1096 .socketpair = sock_no_socketpair,
1097 .shutdown = sco_sock_shutdown,
1098 .setsockopt = sco_sock_setsockopt,
1099 .getsockopt = sco_sock_getsockopt
1102 static const struct net_proto_family sco_sock_family_ops = {
1103 .family = PF_BLUETOOTH,
1104 .owner = THIS_MODULE,
1105 .create = sco_sock_create,
1108 int __init sco_init(void)
1112 err = proto_register(&sco_proto, 0);
1116 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1118 BT_ERR("SCO socket registration failed");
1122 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1124 BT_ERR("Failed to create SCO proc file");
1125 bt_sock_unregister(BTPROTO_SCO);
1130 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1131 NULL, &sco_debugfs_fops);
1133 BT_ERR("Failed to create SCO debug file");
1136 BT_INFO("SCO socket layer initialized");
1141 proto_unregister(&sco_proto);
1145 void __exit sco_exit(void)
1147 bt_procfs_cleanup(&init_net, "sco");
1149 debugfs_remove(sco_debugfs);
1151 bt_sock_unregister(BTPROTO_SCO);
1153 proto_unregister(&sco_proto);
1156 module_param(disable_esco, bool, 0644);
1157 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");