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.
26 * Bluetooth SCO sockets.
28 * $Id: sco.c,v 1.3 2002/04/17 17:37:16 maxk Exp $
32 #include <linux/config.h>
33 #include <linux/module.h>
35 #include <linux/types.h>
36 #include <linux/errno.h>
37 #include <linux/kernel.h>
38 #include <linux/major.h>
39 #include <linux/sched.h>
40 #include <linux/slab.h>
41 #include <linux/poll.h>
42 #include <linux/fcntl.h>
43 #include <linux/init.h>
44 #include <linux/interrupt.h>
45 #include <linux/socket.h>
46 #include <linux/skbuff.h>
47 #include <linux/proc_fs.h>
48 #include <linux/seq_file.h>
49 #include <linux/list.h>
52 #include <asm/system.h>
53 #include <asm/uaccess.h>
55 #include <net/bluetooth/bluetooth.h>
56 #include <net/bluetooth/hci_core.h>
57 #include <net/bluetooth/sco.h>
59 #ifndef CONFIG_BT_SCO_DEBUG
61 #define BT_DBG( A... )
64 static struct proto_ops sco_sock_ops;
66 static struct bt_sock_list sco_sk_list = {
67 .lock = RW_LOCK_UNLOCKED
70 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
71 static void sco_chan_del(struct sock *sk, int err);
73 static int sco_conn_del(struct hci_conn *conn, int err);
75 static void sco_sock_close(struct sock *sk);
76 static void sco_sock_kill(struct sock *sk);
78 /* ---- SCO timers ---- */
79 static void sco_sock_timeout(unsigned long arg)
81 struct sock *sk = (struct sock *) arg;
83 BT_DBG("sock %p state %d", sk, sk->sk_state);
86 sk->sk_err = ETIMEDOUT;
87 sk->sk_state_change(sk);
94 static void sco_sock_set_timer(struct sock *sk, long timeout)
96 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
98 if (!mod_timer(&sk->sk_timer, jiffies + timeout))
102 static void sco_sock_clear_timer(struct sock *sk)
104 BT_DBG("sock %p state %d", sk, sk->sk_state);
106 if (timer_pending(&sk->sk_timer) && del_timer(&sk->sk_timer))
110 static void sco_sock_init_timer(struct sock *sk)
112 init_timer(&sk->sk_timer);
113 sk->sk_timer.function = sco_sock_timeout;
114 sk->sk_timer.data = (unsigned long)sk;
117 /* ---- SCO connections ---- */
118 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
120 struct hci_dev *hdev = hcon->hdev;
121 struct sco_conn *conn;
123 if ((conn = hcon->sco_data))
129 if (!(conn = kmalloc(sizeof(struct sco_conn), GFP_ATOMIC)))
131 memset(conn, 0, sizeof(struct sco_conn));
133 spin_lock_init(&conn->lock);
135 hcon->sco_data = conn;
138 conn->src = &hdev->bdaddr;
139 conn->dst = &hcon->dst;
141 if (hdev->sco_mtu > 0)
142 conn->mtu = hdev->sco_mtu;
146 BT_DBG("hcon %p conn %p", hcon, conn);
150 static inline struct sock *sco_chan_get(struct sco_conn *conn)
152 struct sock *sk = NULL;
155 sco_conn_unlock(conn);
159 static int sco_conn_del(struct hci_conn *hcon, int err)
161 struct sco_conn *conn;
164 if (!(conn = hcon->sco_data))
167 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
170 if ((sk = sco_chan_get(conn))) {
172 sco_sock_clear_timer(sk);
173 sco_chan_del(sk, err);
178 hcon->sco_data = NULL;
183 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
191 __sco_chan_add(conn, sk, parent);
193 sco_conn_unlock(conn);
197 static int sco_connect(struct sock *sk)
199 bdaddr_t *src = &bt_sk(sk)->src;
200 bdaddr_t *dst = &bt_sk(sk)->dst;
201 struct sco_conn *conn;
202 struct hci_conn *hcon;
203 struct hci_dev *hdev;
206 BT_DBG("%s -> %s", batostr(src), batostr(dst));
208 if (!(hdev = hci_get_route(dst, src)))
209 return -EHOSTUNREACH;
211 hci_dev_lock_bh(hdev);
215 hcon = hci_connect(hdev, SCO_LINK, dst);
219 conn = sco_conn_add(hcon, 0);
225 /* Update source addr of the socket */
226 bacpy(src, conn->src);
228 err = sco_chan_add(conn, sk, NULL);
232 if (hcon->state == BT_CONNECTED) {
233 sco_sock_clear_timer(sk);
234 sk->sk_state = BT_CONNECTED;
236 sk->sk_state = BT_CONNECT;
237 sco_sock_set_timer(sk, sk->sk_sndtimeo);
240 hci_dev_unlock_bh(hdev);
245 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
247 struct sco_conn *conn = sco_pi(sk)->conn;
251 /* Check outgoing MTU */
255 BT_DBG("sk %p len %d", sk, len);
257 count = min_t(unsigned int, conn->mtu, len);
258 if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
261 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
266 if ((err = hci_send_sco(conn->hcon, skb)) < 0)
276 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
278 struct sock *sk = sco_chan_get(conn);
283 BT_DBG("sk %p len %d", sk, skb->len);
285 if (sk->sk_state != BT_CONNECTED)
288 if (!sock_queue_rcv_skb(sk, skb))
296 /* -------- Socket interface ---------- */
297 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
300 struct hlist_node *node;
302 sk_for_each(sk, node, &sco_sk_list.head)
303 if (!bacmp(&bt_sk(sk)->src, ba))
310 /* Find socket listening on source bdaddr.
311 * Returns closest match.
313 static struct sock *sco_get_sock_listen(bdaddr_t *src)
315 struct sock *sk = NULL, *sk1 = NULL;
316 struct hlist_node *node;
318 read_lock(&sco_sk_list.lock);
320 sk_for_each(sk, node, &sco_sk_list.head) {
321 if (sk->sk_state != BT_LISTEN)
325 if (!bacmp(&bt_sk(sk)->src, src))
329 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
333 read_unlock(&sco_sk_list.lock);
335 return node ? sk : sk1;
338 static void sco_sock_destruct(struct sock *sk)
342 skb_queue_purge(&sk->sk_receive_queue);
343 skb_queue_purge(&sk->sk_write_queue);
346 kfree(sk->sk_protinfo);
349 static void sco_sock_cleanup_listen(struct sock *parent)
353 BT_DBG("parent %p", parent);
355 /* Close not yet accepted channels */
356 while ((sk = bt_accept_dequeue(parent, NULL))) {
361 parent->sk_state = BT_CLOSED;
362 parent->sk_zapped = 1;
365 /* Kill socket (only if zapped and orphan)
366 * Must be called on unlocked socket.
368 static void sco_sock_kill(struct sock *sk)
370 if (!sk->sk_zapped || sk->sk_socket)
373 BT_DBG("sk %p state %d", sk, sk->sk_state);
375 /* Kill poor orphan */
376 bt_sock_unlink(&sco_sk_list, sk);
377 sock_set_flag(sk, SOCK_DEAD);
382 * Must be called on unlocked socket.
384 static void sco_sock_close(struct sock *sk)
386 struct sco_conn *conn;
388 sco_sock_clear_timer(sk);
392 conn = sco_pi(sk)->conn;
394 BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
396 switch (sk->sk_state) {
398 sco_sock_cleanup_listen(sk);
405 sco_chan_del(sk, ECONNRESET);
418 static void sco_sock_init(struct sock *sk, struct sock *parent)
423 sk->sk_type = parent->sk_type;
426 static struct sock *sco_sock_alloc(struct socket *sock, int proto, int prio)
430 sk = bt_sock_alloc(sock, proto, sizeof(struct sco_pinfo), prio);
434 sk_set_owner(sk, THIS_MODULE);
436 sk->sk_destruct = sco_sock_destruct;
437 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
438 sk->sk_state = BT_OPEN;
440 sco_sock_init_timer(sk);
442 bt_sock_link(&sco_sk_list, sk);
446 static int sco_sock_create(struct socket *sock, int protocol)
450 BT_DBG("sock %p", sock);
452 sock->state = SS_UNCONNECTED;
454 if (sock->type != SOCK_SEQPACKET)
455 return -ESOCKTNOSUPPORT;
457 sock->ops = &sco_sock_ops;
459 if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL)))
462 sco_sock_init(sk, NULL);
466 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
468 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
469 struct sock *sk = sock->sk;
470 bdaddr_t *src = &sa->sco_bdaddr;
473 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
475 if (!addr || addr->sa_family != AF_BLUETOOTH)
480 if (sk->sk_state != BT_OPEN) {
485 write_lock_bh(&sco_sk_list.lock);
487 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
490 /* Save source address */
491 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
492 sk->sk_state = BT_BOUND;
495 write_unlock_bh(&sco_sk_list.lock);
502 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
504 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
505 struct sock *sk = sock->sk;
511 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
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 if ((err = sco_connect(sk)))
528 err = bt_sock_wait_state(sk, BT_CONNECTED,
529 sock_sndtimeo(sk, flags & O_NONBLOCK));
536 static int sco_sock_listen(struct socket *sock, int backlog)
538 struct sock *sk = sock->sk;
541 BT_DBG("sk %p backlog %d", sk, backlog);
545 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
550 sk->sk_max_ack_backlog = backlog;
551 sk->sk_ack_backlog = 0;
552 sk->sk_state = BT_LISTEN;
559 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
561 DECLARE_WAITQUEUE(wait, current);
562 struct sock *sk = sock->sk, *ch;
568 if (sk->sk_state != BT_LISTEN) {
573 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
575 BT_DBG("sk %p timeo %ld", sk, timeo);
577 /* Wait for an incoming connection. (wake-one). */
578 add_wait_queue_exclusive(sk->sk_sleep, &wait);
579 while (!(ch = bt_accept_dequeue(sk, newsock))) {
580 set_current_state(TASK_INTERRUPTIBLE);
587 timeo = schedule_timeout(timeo);
590 if (sk->sk_state != BT_LISTEN) {
595 if (signal_pending(current)) {
596 err = sock_intr_errno(timeo);
600 set_current_state(TASK_RUNNING);
601 remove_wait_queue(sk->sk_sleep, &wait);
606 newsock->state = SS_CONNECTED;
608 BT_DBG("new socket %p", ch);
615 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
617 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
618 struct sock *sk = sock->sk;
620 BT_DBG("sock %p, sk %p", sock, sk);
622 addr->sa_family = AF_BLUETOOTH;
623 *len = sizeof(struct sockaddr_sco);
626 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
628 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
633 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
634 struct msghdr *msg, size_t len)
636 struct sock *sk = sock->sk;
639 BT_DBG("sock %p, sk %p", sock, sk);
642 return sock_error(sk);
644 if (msg->msg_flags & MSG_OOB)
649 if (sk->sk_state == BT_CONNECTED)
650 err = sco_send_frame(sk, msg, len);
658 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
660 struct sock *sk = sock->sk;
677 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)
679 struct sock *sk = sock->sk;
680 struct sco_options opts;
681 struct sco_conninfo cinfo;
686 if (get_user(len, optlen))
693 if (sk->sk_state != BT_CONNECTED) {
698 opts.mtu = sco_pi(sk)->conn->mtu;
700 BT_DBG("mtu %d", opts.mtu);
702 len = min_t(unsigned int, len, sizeof(opts));
703 if (copy_to_user(optval, (char *)&opts, len))
709 if (sk->sk_state != BT_CONNECTED) {
714 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
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);
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 /* ---- Proc fs support ---- */
896 #ifdef CONFIG_PROC_FS
897 static void *sco_seq_start(struct seq_file *seq, loff_t *pos)
900 struct hlist_node *node;
903 read_lock_bh(&sco_sk_list.lock);
905 sk_for_each(sk, node, &sco_sk_list.head)
913 static void *sco_seq_next(struct seq_file *seq, void *e, loff_t *pos)
920 static void sco_seq_stop(struct seq_file *seq, void *e)
922 read_unlock_bh(&sco_sk_list.lock);
925 static int sco_seq_show(struct seq_file *seq, void *e)
928 seq_printf(seq, "%s %s %d\n",
929 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst), sk->sk_state);
933 static struct seq_operations sco_seq_ops = {
934 .start = sco_seq_start,
935 .next = sco_seq_next,
936 .stop = sco_seq_stop,
940 static int sco_seq_open(struct inode *inode, struct file *file)
942 return seq_open(file, &sco_seq_ops);
945 static struct file_operations sco_seq_fops = {
946 .owner = THIS_MODULE,
947 .open = sco_seq_open,
950 .release = seq_release,
953 static int __init sco_proc_init(void)
955 struct proc_dir_entry *p = create_proc_entry("sco", S_IRUGO, proc_bt);
958 p->owner = THIS_MODULE;
959 p->proc_fops = &sco_seq_fops;
963 static void __exit sco_proc_cleanup(void)
965 remove_proc_entry("sco", proc_bt);
968 #else /* CONFIG_PROC_FS */
970 static int __init sco_proc_init(void)
975 static void __exit sco_proc_cleanup(void)
979 #endif /* CONFIG_PROC_FS */
981 static struct proto_ops sco_sock_ops = {
982 .family = PF_BLUETOOTH,
983 .owner = THIS_MODULE,
984 .release = sco_sock_release,
985 .bind = sco_sock_bind,
986 .connect = sco_sock_connect,
987 .listen = sco_sock_listen,
988 .accept = sco_sock_accept,
989 .getname = sco_sock_getname,
990 .sendmsg = sco_sock_sendmsg,
991 .recvmsg = bt_sock_recvmsg,
992 .poll = bt_sock_poll,
993 .ioctl = sock_no_ioctl,
994 .mmap = sock_no_mmap,
995 .socketpair = sock_no_socketpair,
996 .shutdown = sock_no_shutdown,
997 .setsockopt = sco_sock_setsockopt,
998 .getsockopt = sco_sock_getsockopt
1001 static struct net_proto_family sco_sock_family_ops = {
1002 .family = PF_BLUETOOTH,
1003 .create = sco_sock_create,
1004 .owner = THIS_MODULE,
1007 static struct hci_proto sco_hci_proto = {
1009 .id = HCI_PROTO_SCO,
1010 .connect_ind = sco_connect_ind,
1011 .connect_cfm = sco_connect_cfm,
1012 .disconn_ind = sco_disconn_ind,
1013 .recv_scodata = sco_recv_scodata
1016 static int __init sco_init(void)
1020 if ((err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops))) {
1021 BT_ERR("SCO socket registration failed");
1025 if ((err = hci_register_proto(&sco_hci_proto))) {
1026 BT_ERR("SCO protocol registration failed");
1032 BT_INFO("SCO (Voice Link) ver %s", VERSION);
1033 BT_INFO("SCO socket layer initialized");
1038 static void __exit sco_exit(void)
1044 /* Unregister socket, protocol and notifier */
1045 if ((err = bt_sock_unregister(BTPROTO_SCO)))
1046 BT_ERR("SCO socket unregistration failed. %d", err);
1048 if ((err = hci_unregister_proto(&sco_hci_proto)))
1049 BT_ERR("SCO protocol unregistration failed. %d", err);
1052 module_init(sco_init);
1053 module_exit(sco_exit);
1055 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
1056 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1057 MODULE_VERSION(VERSION);
1058 MODULE_LICENSE("GPL");
1059 MODULE_ALIAS("bt-proto-2");