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 __u16 pkt_type = sco_pi(sk)->pkt_type;
162 struct sco_conn *conn;
163 struct hci_conn *hcon;
164 struct hci_dev *hdev;
167 BT_DBG("%pMR -> %pMR", src, dst);
169 hdev = hci_get_route(dst, src);
171 return -EHOSTUNREACH;
175 if (lmp_esco_capable(hdev) && !disable_esco)
179 pkt_type &= SCO_ESCO_MASK;
182 hcon = hci_connect(hdev, type, pkt_type, dst, BDADDR_BREDR,
183 BT_SECURITY_LOW, HCI_AT_NO_BONDING);
189 conn = sco_conn_add(hcon);
196 /* Update source addr of the socket */
197 bacpy(src, conn->src);
199 err = sco_chan_add(conn, sk, NULL);
203 if (hcon->state == BT_CONNECTED) {
204 sco_sock_clear_timer(sk);
205 sk->sk_state = BT_CONNECTED;
207 sk->sk_state = BT_CONNECT;
208 sco_sock_set_timer(sk, sk->sk_sndtimeo);
212 hci_dev_unlock(hdev);
217 static int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
219 struct sco_conn *conn = sco_pi(sk)->conn;
223 /* Check outgoing MTU */
227 BT_DBG("sk %p len %d", sk, len);
229 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
233 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
238 hci_send_sco(conn->hcon, skb);
243 static void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
245 struct sock *sk = sco_chan_get(conn);
250 BT_DBG("sk %p len %d", sk, skb->len);
252 if (sk->sk_state != BT_CONNECTED)
255 if (!sock_queue_rcv_skb(sk, skb))
262 /* -------- Socket interface ---------- */
263 static struct sock *__sco_get_sock_listen_by_addr(bdaddr_t *ba)
267 sk_for_each(sk, &sco_sk_list.head) {
268 if (sk->sk_state != BT_LISTEN)
271 if (!bacmp(&bt_sk(sk)->src, ba))
278 /* Find socket listening on source bdaddr.
279 * Returns closest match.
281 static struct sock *sco_get_sock_listen(bdaddr_t *src)
283 struct sock *sk = NULL, *sk1 = NULL;
285 read_lock(&sco_sk_list.lock);
287 sk_for_each(sk, &sco_sk_list.head) {
288 if (sk->sk_state != BT_LISTEN)
292 if (!bacmp(&bt_sk(sk)->src, src))
296 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
300 read_unlock(&sco_sk_list.lock);
302 return sk ? sk : sk1;
305 static void sco_sock_destruct(struct sock *sk)
309 skb_queue_purge(&sk->sk_receive_queue);
310 skb_queue_purge(&sk->sk_write_queue);
313 static void sco_sock_cleanup_listen(struct sock *parent)
317 BT_DBG("parent %p", parent);
319 /* Close not yet accepted channels */
320 while ((sk = bt_accept_dequeue(parent, NULL))) {
325 parent->sk_state = BT_CLOSED;
326 sock_set_flag(parent, SOCK_ZAPPED);
329 /* Kill socket (only if zapped and orphan)
330 * Must be called on unlocked socket.
332 static void sco_sock_kill(struct sock *sk)
334 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
337 BT_DBG("sk %p state %d", sk, sk->sk_state);
339 /* Kill poor orphan */
340 bt_sock_unlink(&sco_sk_list, sk);
341 sock_set_flag(sk, SOCK_DEAD);
345 static void __sco_sock_close(struct sock *sk)
347 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
349 switch (sk->sk_state) {
351 sco_sock_cleanup_listen(sk);
356 if (sco_pi(sk)->conn->hcon) {
357 sk->sk_state = BT_DISCONN;
358 sco_sock_set_timer(sk, SCO_DISCONN_TIMEOUT);
359 hci_conn_drop(sco_pi(sk)->conn->hcon);
360 sco_pi(sk)->conn->hcon = NULL;
362 sco_chan_del(sk, ECONNRESET);
368 sco_chan_del(sk, ECONNRESET);
372 sock_set_flag(sk, SOCK_ZAPPED);
377 /* Must be called on unlocked socket. */
378 static void sco_sock_close(struct sock *sk)
380 sco_sock_clear_timer(sk);
382 __sco_sock_close(sk);
387 static void sco_sock_init(struct sock *sk, struct sock *parent)
392 sk->sk_type = parent->sk_type;
393 bt_sk(sk)->flags = bt_sk(parent)->flags;
394 security_sk_clone(parent, sk);
398 static struct proto sco_proto = {
400 .owner = THIS_MODULE,
401 .obj_size = sizeof(struct sco_pinfo)
404 static struct sock *sco_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
408 sk = sk_alloc(net, PF_BLUETOOTH, prio, &sco_proto);
412 sock_init_data(sock, sk);
413 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
415 sk->sk_destruct = sco_sock_destruct;
416 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
418 sock_reset_flag(sk, SOCK_ZAPPED);
420 sk->sk_protocol = proto;
421 sk->sk_state = BT_OPEN;
423 setup_timer(&sk->sk_timer, sco_sock_timeout, (unsigned long)sk);
425 bt_sock_link(&sco_sk_list, sk);
429 static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
434 BT_DBG("sock %p", sock);
436 sock->state = SS_UNCONNECTED;
438 if (sock->type != SOCK_SEQPACKET)
439 return -ESOCKTNOSUPPORT;
441 sock->ops = &sco_sock_ops;
443 sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC);
447 sco_sock_init(sk, NULL);
451 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
453 struct sockaddr_sco sa;
454 struct sock *sk = sock->sk;
457 BT_DBG("sk %p %pMR", sk, &sa.sco_bdaddr);
459 if (!addr || addr->sa_family != AF_BLUETOOTH)
462 memset(&sa, 0, sizeof(sa));
463 len = min_t(unsigned int, sizeof(sa), alen);
464 memcpy(&sa, addr, len);
468 if (sk->sk_state != BT_OPEN) {
473 if (sk->sk_type != SOCK_SEQPACKET) {
478 bacpy(&bt_sk(sk)->src, &sa.sco_bdaddr);
479 sco_pi(sk)->pkt_type = sa.sco_pkt_type;
481 sk->sk_state = BT_BOUND;
488 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
490 struct sock *sk = sock->sk;
491 struct sockaddr_sco sa;
496 if (!addr || addr->sa_family != AF_BLUETOOTH)
499 memset(&sa, 0, sizeof(sa));
500 len = min_t(unsigned int, sizeof(sa), alen);
501 memcpy(&sa, addr, len);
505 if (sk->sk_type != SOCK_SEQPACKET) {
510 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
515 /* Set destination address and psm */
516 bacpy(&bt_sk(sk)->dst, &sa.sco_bdaddr);
517 sco_pi(sk)->pkt_type = sa.sco_pkt_type;
519 err = sco_connect(sk);
523 err = bt_sock_wait_state(sk, BT_CONNECTED,
524 sock_sndtimeo(sk, flags & O_NONBLOCK));
531 static int sco_sock_listen(struct socket *sock, int backlog)
533 struct sock *sk = sock->sk;
534 bdaddr_t *src = &bt_sk(sk)->src;
537 BT_DBG("sk %p backlog %d", sk, backlog);
541 if (sk->sk_state != BT_BOUND) {
546 if (sk->sk_type != SOCK_SEQPACKET) {
551 write_lock(&sco_sk_list.lock);
553 if (__sco_get_sock_listen_by_addr(src)) {
558 sk->sk_max_ack_backlog = backlog;
559 sk->sk_ack_backlog = 0;
561 sk->sk_state = BT_LISTEN;
564 write_unlock(&sco_sk_list.lock);
571 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
573 DECLARE_WAITQUEUE(wait, current);
574 struct sock *sk = sock->sk, *ch;
580 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
582 BT_DBG("sk %p timeo %ld", sk, timeo);
584 /* Wait for an incoming connection. (wake-one). */
585 add_wait_queue_exclusive(sk_sleep(sk), &wait);
587 set_current_state(TASK_INTERRUPTIBLE);
589 if (sk->sk_state != BT_LISTEN) {
594 ch = bt_accept_dequeue(sk, newsock);
603 if (signal_pending(current)) {
604 err = sock_intr_errno(timeo);
609 timeo = schedule_timeout(timeo);
612 __set_current_state(TASK_RUNNING);
613 remove_wait_queue(sk_sleep(sk), &wait);
618 newsock->state = SS_CONNECTED;
620 BT_DBG("new socket %p", ch);
627 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
629 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
630 struct sock *sk = sock->sk;
632 BT_DBG("sock %p, sk %p", sock, sk);
634 addr->sa_family = AF_BLUETOOTH;
635 *len = sizeof(struct sockaddr_sco);
638 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
640 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
641 sa->sco_pkt_type = sco_pi(sk)->pkt_type;
646 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
647 struct msghdr *msg, size_t len)
649 struct sock *sk = sock->sk;
652 BT_DBG("sock %p, sk %p", sock, sk);
654 err = sock_error(sk);
658 if (msg->msg_flags & MSG_OOB)
663 if (sk->sk_state == BT_CONNECTED)
664 err = sco_send_frame(sk, msg, len);
672 static void sco_conn_defer_accept(struct hci_conn *conn, int mask)
674 struct hci_dev *hdev = conn->hdev;
676 BT_DBG("conn %p", conn);
678 conn->state = BT_CONFIG;
680 if (!lmp_esco_capable(hdev)) {
681 struct hci_cp_accept_conn_req cp;
683 bacpy(&cp.bdaddr, &conn->dst);
685 if (lmp_rswitch_capable(hdev) && (mask & HCI_LM_MASTER))
686 cp.role = 0x00; /* Become master */
688 cp.role = 0x01; /* Remain slave */
690 hci_send_cmd(hdev, HCI_OP_ACCEPT_CONN_REQ, sizeof(cp), &cp);
692 struct hci_cp_accept_sync_conn_req cp;
694 bacpy(&cp.bdaddr, &conn->dst);
695 cp.pkt_type = cpu_to_le16(conn->pkt_type);
697 cp.tx_bandwidth = __constant_cpu_to_le32(0x00001f40);
698 cp.rx_bandwidth = __constant_cpu_to_le32(0x00001f40);
699 cp.max_latency = __constant_cpu_to_le16(0xffff);
700 cp.content_format = cpu_to_le16(hdev->voice_setting);
701 cp.retrans_effort = 0xff;
703 hci_send_cmd(hdev, HCI_OP_ACCEPT_SYNC_CONN_REQ,
708 static int sco_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
709 struct msghdr *msg, size_t len, int flags)
711 struct sock *sk = sock->sk;
712 struct sco_pinfo *pi = sco_pi(sk);
716 if (sk->sk_state == BT_CONNECT2 &&
717 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) {
718 sco_conn_defer_accept(pi->conn->hcon, 0);
719 sk->sk_state = BT_CONFIG;
727 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
730 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
732 struct sock *sk = sock->sk;
743 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
748 if (get_user(opt, (u32 __user *) optval)) {
754 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
756 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
768 static int sco_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
770 struct sock *sk = sock->sk;
771 struct sco_options opts;
772 struct sco_conninfo cinfo;
777 if (get_user(len, optlen))
784 if (sk->sk_state != BT_CONNECTED) {
789 opts.mtu = sco_pi(sk)->conn->mtu;
791 BT_DBG("mtu %d", opts.mtu);
793 len = min_t(unsigned int, len, sizeof(opts));
794 if (copy_to_user(optval, (char *)&opts, len))
800 if (sk->sk_state != BT_CONNECTED) {
805 memset(&cinfo, 0, sizeof(cinfo));
806 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
807 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
809 len = min_t(unsigned int, len, sizeof(cinfo));
810 if (copy_to_user(optval, (char *)&cinfo, len))
824 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
826 struct sock *sk = sock->sk;
831 if (level == SOL_SCO)
832 return sco_sock_getsockopt_old(sock, optname, optval, optlen);
834 if (get_user(len, optlen))
842 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
847 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
848 (u32 __user *) optval))
862 static int sco_sock_shutdown(struct socket *sock, int how)
864 struct sock *sk = sock->sk;
867 BT_DBG("sock %p, sk %p", sock, sk);
873 if (!sk->sk_shutdown) {
874 sk->sk_shutdown = SHUTDOWN_MASK;
875 sco_sock_clear_timer(sk);
876 __sco_sock_close(sk);
878 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
879 err = bt_sock_wait_state(sk, BT_CLOSED,
886 static int sco_sock_release(struct socket *sock)
888 struct sock *sk = sock->sk;
891 BT_DBG("sock %p, sk %p", sock, sk);
898 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
900 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
909 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
911 BT_DBG("conn %p", conn);
913 sco_pi(sk)->conn = conn;
917 bt_accept_enqueue(parent, sk);
921 * Must be called on the locked socket. */
922 static void sco_chan_del(struct sock *sk, int err)
924 struct sco_conn *conn;
926 conn = sco_pi(sk)->conn;
928 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
933 sco_pi(sk)->conn = NULL;
934 sco_conn_unlock(conn);
937 hci_conn_drop(conn->hcon);
940 sk->sk_state = BT_CLOSED;
942 sk->sk_state_change(sk);
944 sock_set_flag(sk, SOCK_ZAPPED);
947 static void sco_conn_ready(struct sco_conn *conn)
950 struct sock *sk = conn->sk;
952 BT_DBG("conn %p", conn);
955 sco_sock_clear_timer(sk);
957 sk->sk_state = BT_CONNECTED;
958 sk->sk_state_change(sk);
963 parent = sco_get_sock_listen(conn->src);
965 sco_conn_unlock(conn);
969 bh_lock_sock(parent);
971 sk = sco_sock_alloc(sock_net(parent), NULL,
972 BTPROTO_SCO, GFP_ATOMIC);
974 bh_unlock_sock(parent);
975 sco_conn_unlock(conn);
979 sco_sock_init(sk, parent);
981 bacpy(&bt_sk(sk)->src, conn->src);
982 bacpy(&bt_sk(sk)->dst, conn->dst);
984 hci_conn_hold(conn->hcon);
985 __sco_chan_add(conn, sk, parent);
987 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
988 sk->sk_state = BT_CONNECT2;
990 sk->sk_state = BT_CONNECTED;
993 parent->sk_data_ready(parent, 1);
995 bh_unlock_sock(parent);
997 sco_conn_unlock(conn);
1001 /* ----- SCO interface with lower layer (HCI) ----- */
1002 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags)
1007 BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
1009 /* Find listening sockets */
1010 read_lock(&sco_sk_list.lock);
1011 sk_for_each(sk, &sco_sk_list.head) {
1012 if (sk->sk_state != BT_LISTEN)
1015 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr) ||
1016 !bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
1017 lm |= HCI_LM_ACCEPT;
1019 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))
1020 *flags |= HCI_PROTO_DEFER;
1024 read_unlock(&sco_sk_list.lock);
1029 void sco_connect_cfm(struct hci_conn *hcon, __u8 status)
1031 BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
1033 struct sco_conn *conn;
1035 conn = sco_conn_add(hcon);
1037 sco_conn_ready(conn);
1039 sco_conn_del(hcon, bt_to_errno(status));
1042 void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason)
1044 BT_DBG("hcon %p reason %d", hcon, reason);
1046 sco_conn_del(hcon, bt_to_errno(reason));
1049 int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
1051 struct sco_conn *conn = hcon->sco_data;
1056 BT_DBG("conn %p len %d", conn, skb->len);
1059 sco_recv_frame(conn, skb);
1068 static int sco_debugfs_show(struct seq_file *f, void *p)
1072 read_lock(&sco_sk_list.lock);
1074 sk_for_each(sk, &sco_sk_list.head) {
1075 seq_printf(f, "%pMR %pMR %d\n", &bt_sk(sk)->src,
1076 &bt_sk(sk)->dst, sk->sk_state);
1079 read_unlock(&sco_sk_list.lock);
1084 static int sco_debugfs_open(struct inode *inode, struct file *file)
1086 return single_open(file, sco_debugfs_show, inode->i_private);
1089 static const struct file_operations sco_debugfs_fops = {
1090 .open = sco_debugfs_open,
1092 .llseek = seq_lseek,
1093 .release = single_release,
1096 static struct dentry *sco_debugfs;
1098 static const struct proto_ops sco_sock_ops = {
1099 .family = PF_BLUETOOTH,
1100 .owner = THIS_MODULE,
1101 .release = sco_sock_release,
1102 .bind = sco_sock_bind,
1103 .connect = sco_sock_connect,
1104 .listen = sco_sock_listen,
1105 .accept = sco_sock_accept,
1106 .getname = sco_sock_getname,
1107 .sendmsg = sco_sock_sendmsg,
1108 .recvmsg = sco_sock_recvmsg,
1109 .poll = bt_sock_poll,
1110 .ioctl = bt_sock_ioctl,
1111 .mmap = sock_no_mmap,
1112 .socketpair = sock_no_socketpair,
1113 .shutdown = sco_sock_shutdown,
1114 .setsockopt = sco_sock_setsockopt,
1115 .getsockopt = sco_sock_getsockopt
1118 static const struct net_proto_family sco_sock_family_ops = {
1119 .family = PF_BLUETOOTH,
1120 .owner = THIS_MODULE,
1121 .create = sco_sock_create,
1124 int __init sco_init(void)
1128 err = proto_register(&sco_proto, 0);
1132 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
1134 BT_ERR("SCO socket registration failed");
1138 err = bt_procfs_init(&init_net, "sco", &sco_sk_list, NULL);
1140 BT_ERR("Failed to create SCO proc file");
1141 bt_sock_unregister(BTPROTO_SCO);
1146 sco_debugfs = debugfs_create_file("sco", 0444, bt_debugfs,
1147 NULL, &sco_debugfs_fops);
1149 BT_ERR("Failed to create SCO debug file");
1152 BT_INFO("SCO socket layer initialized");
1157 proto_unregister(&sco_proto);
1161 void __exit sco_exit(void)
1163 bt_procfs_cleanup(&init_net, "sco");
1165 debugfs_remove(sco_debugfs);
1167 bt_sock_unregister(BTPROTO_SCO);
1169 proto_unregister(&sco_proto);
1172 module_param(disable_esco, bool, 0644);
1173 MODULE_PARM_DESC(disable_esco, "Disable eSCO connection creation");