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/list.h>
44 #include <asm/system.h>
45 #include <asm/uaccess.h>
47 #include <net/bluetooth/bluetooth.h>
48 #include <net/bluetooth/hci_core.h>
49 #include <net/bluetooth/sco.h>
51 #ifndef CONFIG_BT_SCO_DEBUG
58 static const struct proto_ops sco_sock_ops;
60 static struct bt_sock_list sco_sk_list = {
61 .lock = RW_LOCK_UNLOCKED
64 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
65 static void sco_chan_del(struct sock *sk, int err);
67 static int sco_conn_del(struct hci_conn *conn, int err);
69 static void sco_sock_close(struct sock *sk);
70 static void sco_sock_kill(struct sock *sk);
72 /* ---- SCO timers ---- */
73 static void sco_sock_timeout(unsigned long arg)
75 struct sock *sk = (struct sock *) arg;
77 BT_DBG("sock %p state %d", sk, sk->sk_state);
80 sk->sk_err = ETIMEDOUT;
81 sk->sk_state_change(sk);
88 static void sco_sock_set_timer(struct sock *sk, long timeout)
90 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
91 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
94 static void sco_sock_clear_timer(struct sock *sk)
96 BT_DBG("sock %p state %d", sk, sk->sk_state);
97 sk_stop_timer(sk, &sk->sk_timer);
100 static void sco_sock_init_timer(struct sock *sk)
102 init_timer(&sk->sk_timer);
103 sk->sk_timer.function = sco_sock_timeout;
104 sk->sk_timer.data = (unsigned long)sk;
107 /* ---- SCO connections ---- */
108 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
110 struct hci_dev *hdev = hcon->hdev;
111 struct sco_conn *conn;
113 if ((conn = hcon->sco_data))
119 if (!(conn = kmalloc(sizeof(struct sco_conn), GFP_ATOMIC)))
121 memset(conn, 0, sizeof(struct sco_conn));
123 spin_lock_init(&conn->lock);
125 hcon->sco_data = conn;
128 conn->src = &hdev->bdaddr;
129 conn->dst = &hcon->dst;
131 if (hdev->sco_mtu > 0)
132 conn->mtu = hdev->sco_mtu;
136 BT_DBG("hcon %p conn %p", hcon, conn);
140 static inline struct sock *sco_chan_get(struct sco_conn *conn)
142 struct sock *sk = NULL;
145 sco_conn_unlock(conn);
149 static int sco_conn_del(struct hci_conn *hcon, int err)
151 struct sco_conn *conn;
154 if (!(conn = hcon->sco_data))
157 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
160 if ((sk = sco_chan_get(conn))) {
162 sco_sock_clear_timer(sk);
163 sco_chan_del(sk, err);
168 hcon->sco_data = NULL;
173 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
181 __sco_chan_add(conn, sk, parent);
183 sco_conn_unlock(conn);
187 static int sco_connect(struct sock *sk)
189 bdaddr_t *src = &bt_sk(sk)->src;
190 bdaddr_t *dst = &bt_sk(sk)->dst;
191 struct sco_conn *conn;
192 struct hci_conn *hcon;
193 struct hci_dev *hdev;
196 BT_DBG("%s -> %s", batostr(src), batostr(dst));
198 if (!(hdev = hci_get_route(dst, src)))
199 return -EHOSTUNREACH;
201 hci_dev_lock_bh(hdev);
205 hcon = hci_connect(hdev, SCO_LINK, dst);
209 conn = sco_conn_add(hcon, 0);
215 /* Update source addr of the socket */
216 bacpy(src, conn->src);
218 err = sco_chan_add(conn, sk, NULL);
222 if (hcon->state == BT_CONNECTED) {
223 sco_sock_clear_timer(sk);
224 sk->sk_state = BT_CONNECTED;
226 sk->sk_state = BT_CONNECT;
227 sco_sock_set_timer(sk, sk->sk_sndtimeo);
230 hci_dev_unlock_bh(hdev);
235 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
237 struct sco_conn *conn = sco_pi(sk)->conn;
241 /* Check outgoing MTU */
245 BT_DBG("sk %p len %d", sk, len);
247 count = min_t(unsigned int, conn->mtu, len);
248 if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
251 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
256 if ((err = hci_send_sco(conn->hcon, skb)) < 0)
266 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
268 struct sock *sk = sco_chan_get(conn);
273 BT_DBG("sk %p len %d", sk, skb->len);
275 if (sk->sk_state != BT_CONNECTED)
278 if (!sock_queue_rcv_skb(sk, skb))
286 /* -------- Socket interface ---------- */
287 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
290 struct hlist_node *node;
292 sk_for_each(sk, node, &sco_sk_list.head)
293 if (!bacmp(&bt_sk(sk)->src, ba))
300 /* Find socket listening on source bdaddr.
301 * Returns closest match.
303 static struct sock *sco_get_sock_listen(bdaddr_t *src)
305 struct sock *sk = NULL, *sk1 = NULL;
306 struct hlist_node *node;
308 read_lock(&sco_sk_list.lock);
310 sk_for_each(sk, node, &sco_sk_list.head) {
311 if (sk->sk_state != BT_LISTEN)
315 if (!bacmp(&bt_sk(sk)->src, src))
319 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
323 read_unlock(&sco_sk_list.lock);
325 return node ? sk : sk1;
328 static void sco_sock_destruct(struct sock *sk)
332 skb_queue_purge(&sk->sk_receive_queue);
333 skb_queue_purge(&sk->sk_write_queue);
336 static void sco_sock_cleanup_listen(struct sock *parent)
340 BT_DBG("parent %p", parent);
342 /* Close not yet accepted channels */
343 while ((sk = bt_accept_dequeue(parent, NULL))) {
348 parent->sk_state = BT_CLOSED;
349 sock_set_flag(parent, SOCK_ZAPPED);
352 /* Kill socket (only if zapped and orphan)
353 * Must be called on unlocked socket.
355 static void sco_sock_kill(struct sock *sk)
357 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
360 BT_DBG("sk %p state %d", sk, sk->sk_state);
362 /* Kill poor orphan */
363 bt_sock_unlink(&sco_sk_list, sk);
364 sock_set_flag(sk, SOCK_DEAD);
369 * Must be called on unlocked socket.
371 static void sco_sock_close(struct sock *sk)
373 struct sco_conn *conn;
375 sco_sock_clear_timer(sk);
379 conn = sco_pi(sk)->conn;
381 BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
383 switch (sk->sk_state) {
385 sco_sock_cleanup_listen(sk);
392 sco_chan_del(sk, ECONNRESET);
396 sock_set_flag(sk, SOCK_ZAPPED);
405 static void sco_sock_init(struct sock *sk, struct sock *parent)
410 sk->sk_type = parent->sk_type;
413 static struct proto sco_proto = {
415 .owner = THIS_MODULE,
416 .obj_size = sizeof(struct sco_pinfo)
419 static struct sock *sco_sock_alloc(struct socket *sock, int proto, gfp_t prio)
423 sk = sk_alloc(PF_BLUETOOTH, prio, &sco_proto, 1);
427 sock_init_data(sock, sk);
428 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
430 sk->sk_destruct = sco_sock_destruct;
431 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
433 sock_reset_flag(sk, SOCK_ZAPPED);
435 sk->sk_protocol = proto;
436 sk->sk_state = BT_OPEN;
438 sco_sock_init_timer(sk);
440 bt_sock_link(&sco_sk_list, sk);
444 static int sco_sock_create(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 if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL)))
460 sco_sock_init(sk, NULL);
464 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
466 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
467 struct sock *sk = sock->sk;
468 bdaddr_t *src = &sa->sco_bdaddr;
471 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
473 if (!addr || addr->sa_family != AF_BLUETOOTH)
478 if (sk->sk_state != BT_OPEN) {
483 write_lock_bh(&sco_sk_list.lock);
485 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
488 /* Save source address */
489 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
490 sk->sk_state = BT_BOUND;
493 write_unlock_bh(&sco_sk_list.lock);
500 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
502 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
503 struct sock *sk = sock->sk;
509 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
512 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
515 if (sk->sk_type != SOCK_SEQPACKET)
520 /* Set destination address and psm */
521 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
523 if ((err = sco_connect(sk)))
526 err = bt_sock_wait_state(sk, BT_CONNECTED,
527 sock_sndtimeo(sk, flags & O_NONBLOCK));
534 static int sco_sock_listen(struct socket *sock, int backlog)
536 struct sock *sk = sock->sk;
539 BT_DBG("sk %p backlog %d", sk, backlog);
543 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
548 sk->sk_max_ack_backlog = backlog;
549 sk->sk_ack_backlog = 0;
550 sk->sk_state = BT_LISTEN;
557 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
559 DECLARE_WAITQUEUE(wait, current);
560 struct sock *sk = sock->sk, *ch;
566 if (sk->sk_state != BT_LISTEN) {
571 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
573 BT_DBG("sk %p timeo %ld", sk, timeo);
575 /* Wait for an incoming connection. (wake-one). */
576 add_wait_queue_exclusive(sk->sk_sleep, &wait);
577 while (!(ch = bt_accept_dequeue(sk, newsock))) {
578 set_current_state(TASK_INTERRUPTIBLE);
585 timeo = schedule_timeout(timeo);
588 if (sk->sk_state != BT_LISTEN) {
593 if (signal_pending(current)) {
594 err = sock_intr_errno(timeo);
598 set_current_state(TASK_RUNNING);
599 remove_wait_queue(sk->sk_sleep, &wait);
604 newsock->state = SS_CONNECTED;
606 BT_DBG("new socket %p", ch);
613 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
615 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
616 struct sock *sk = sock->sk;
618 BT_DBG("sock %p, sk %p", sock, sk);
620 addr->sa_family = AF_BLUETOOTH;
621 *len = sizeof(struct sockaddr_sco);
624 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
626 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
631 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
632 struct msghdr *msg, size_t len)
634 struct sock *sk = sock->sk;
637 BT_DBG("sock %p, sk %p", sock, sk);
639 err = sock_error(sk);
643 if (msg->msg_flags & MSG_OOB)
648 if (sk->sk_state == BT_CONNECTED)
649 err = sco_send_frame(sk, msg, len);
657 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
659 struct sock *sk = sock->sk;
676 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
678 struct sock *sk = sock->sk;
679 struct sco_options opts;
680 struct sco_conninfo cinfo;
685 if (get_user(len, optlen))
692 if (sk->sk_state != BT_CONNECTED) {
697 opts.mtu = sco_pi(sk)->conn->mtu;
699 BT_DBG("mtu %d", opts.mtu);
701 len = min_t(unsigned int, len, sizeof(opts));
702 if (copy_to_user(optval, (char *)&opts, len))
708 if (sk->sk_state != BT_CONNECTED) {
713 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
714 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
716 len = min_t(unsigned int, len, sizeof(cinfo));
717 if (copy_to_user(optval, (char *)&cinfo, len))
731 static int sco_sock_release(struct socket *sock)
733 struct sock *sk = sock->sk;
736 BT_DBG("sock %p, sk %p", sock, sk);
743 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
745 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
754 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
756 BT_DBG("conn %p", conn);
758 sco_pi(sk)->conn = conn;
762 bt_accept_enqueue(parent, sk);
766 * Must be called on the locked socket. */
767 static void sco_chan_del(struct sock *sk, int err)
769 struct sco_conn *conn;
771 conn = sco_pi(sk)->conn;
773 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
778 sco_pi(sk)->conn = NULL;
779 sco_conn_unlock(conn);
780 hci_conn_put(conn->hcon);
783 sk->sk_state = BT_CLOSED;
785 sk->sk_state_change(sk);
787 sock_set_flag(sk, SOCK_ZAPPED);
790 static void sco_conn_ready(struct sco_conn *conn)
792 struct sock *parent, *sk;
794 BT_DBG("conn %p", conn);
798 if ((sk = conn->sk)) {
799 sco_sock_clear_timer(sk);
801 sk->sk_state = BT_CONNECTED;
802 sk->sk_state_change(sk);
805 parent = sco_get_sock_listen(conn->src);
809 bh_lock_sock(parent);
811 sk = sco_sock_alloc(NULL, BTPROTO_SCO, GFP_ATOMIC);
813 bh_unlock_sock(parent);
817 sco_sock_init(sk, parent);
819 bacpy(&bt_sk(sk)->src, conn->src);
820 bacpy(&bt_sk(sk)->dst, conn->dst);
822 hci_conn_hold(conn->hcon);
823 __sco_chan_add(conn, sk, parent);
825 sk->sk_state = BT_CONNECTED;
828 parent->sk_data_ready(parent, 1);
830 bh_unlock_sock(parent);
834 sco_conn_unlock(conn);
837 /* ----- SCO interface with lower layer (HCI) ----- */
838 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
840 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
842 /* Always accept connection */
843 return HCI_LM_ACCEPT;
846 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
848 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
850 if (hcon->type != SCO_LINK)
854 struct sco_conn *conn;
856 conn = sco_conn_add(hcon, status);
858 sco_conn_ready(conn);
860 sco_conn_del(hcon, bt_err(status));
865 static int sco_disconn_ind(struct hci_conn *hcon, __u8 reason)
867 BT_DBG("hcon %p reason %d", hcon, reason);
869 if (hcon->type != SCO_LINK)
872 sco_conn_del(hcon, bt_err(reason));
876 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
878 struct sco_conn *conn = hcon->sco_data;
883 BT_DBG("conn %p len %d", conn, skb->len);
886 sco_recv_frame(conn, skb);
895 static ssize_t sco_sysfs_show(struct class *dev, char *buf)
898 struct hlist_node *node;
901 read_lock_bh(&sco_sk_list.lock);
903 sk_for_each(sk, node, &sco_sk_list.head) {
904 str += sprintf(str, "%s %s %d\n",
905 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
909 read_unlock_bh(&sco_sk_list.lock);
914 static CLASS_ATTR(sco, S_IRUGO, sco_sysfs_show, NULL);
916 static const struct proto_ops sco_sock_ops = {
917 .family = PF_BLUETOOTH,
918 .owner = THIS_MODULE,
919 .release = sco_sock_release,
920 .bind = sco_sock_bind,
921 .connect = sco_sock_connect,
922 .listen = sco_sock_listen,
923 .accept = sco_sock_accept,
924 .getname = sco_sock_getname,
925 .sendmsg = sco_sock_sendmsg,
926 .recvmsg = bt_sock_recvmsg,
927 .poll = bt_sock_poll,
928 .ioctl = sock_no_ioctl,
929 .mmap = sock_no_mmap,
930 .socketpair = sock_no_socketpair,
931 .shutdown = sock_no_shutdown,
932 .setsockopt = sco_sock_setsockopt,
933 .getsockopt = sco_sock_getsockopt
936 static struct net_proto_family sco_sock_family_ops = {
937 .family = PF_BLUETOOTH,
938 .owner = THIS_MODULE,
939 .create = sco_sock_create,
942 static struct hci_proto sco_hci_proto = {
945 .connect_ind = sco_connect_ind,
946 .connect_cfm = sco_connect_cfm,
947 .disconn_ind = sco_disconn_ind,
948 .recv_scodata = sco_recv_scodata
951 static int __init sco_init(void)
955 err = proto_register(&sco_proto, 0);
959 err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops);
961 BT_ERR("SCO socket registration failed");
965 err = hci_register_proto(&sco_hci_proto);
967 BT_ERR("SCO protocol registration failed");
968 bt_sock_unregister(BTPROTO_SCO);
972 class_create_file(bt_class, &class_attr_sco);
974 BT_INFO("SCO (Voice Link) ver %s", VERSION);
975 BT_INFO("SCO socket layer initialized");
980 proto_unregister(&sco_proto);
984 static void __exit sco_exit(void)
986 class_remove_file(bt_class, &class_attr_sco);
988 if (bt_sock_unregister(BTPROTO_SCO) < 0)
989 BT_ERR("SCO socket unregistration failed");
991 if (hci_unregister_proto(&sco_hci_proto) < 0)
992 BT_ERR("SCO protocol unregistration failed");
994 proto_unregister(&sco_proto);
997 module_init(sco_init);
998 module_exit(sco_exit);
1000 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1001 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1002 MODULE_VERSION(VERSION);
1003 MODULE_LICENSE("GPL");
1004 MODULE_ALIAS("bt-proto-2");