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/config.h>
28 #include <linux/module.h>
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/major.h>
34 #include <linux/sched.h>
35 #include <linux/slab.h>
36 #include <linux/poll.h>
37 #include <linux/fcntl.h>
38 #include <linux/init.h>
39 #include <linux/interrupt.h>
40 #include <linux/socket.h>
41 #include <linux/skbuff.h>
42 #include <linux/proc_fs.h>
43 #include <linux/seq_file.h>
44 #include <linux/list.h>
47 #include <asm/system.h>
48 #include <asm/uaccess.h>
50 #include <net/bluetooth/bluetooth.h>
51 #include <net/bluetooth/hci_core.h>
52 #include <net/bluetooth/sco.h>
54 #ifndef CONFIG_BT_SCO_DEBUG
61 static struct proto_ops sco_sock_ops;
63 static struct bt_sock_list sco_sk_list = {
64 .lock = RW_LOCK_UNLOCKED
67 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
68 static void sco_chan_del(struct sock *sk, int err);
70 static int sco_conn_del(struct hci_conn *conn, int err);
72 static void sco_sock_close(struct sock *sk);
73 static void sco_sock_kill(struct sock *sk);
75 /* ---- SCO timers ---- */
76 static void sco_sock_timeout(unsigned long arg)
78 struct sock *sk = (struct sock *) arg;
80 BT_DBG("sock %p state %d", sk, sk->sk_state);
83 sk->sk_err = ETIMEDOUT;
84 sk->sk_state_change(sk);
91 static void sco_sock_set_timer(struct sock *sk, long timeout)
93 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
95 if (!mod_timer(&sk->sk_timer, jiffies + timeout))
99 static void sco_sock_clear_timer(struct sock *sk)
101 BT_DBG("sock %p state %d", sk, sk->sk_state);
103 if (timer_pending(&sk->sk_timer) && del_timer(&sk->sk_timer))
107 static void sco_sock_init_timer(struct sock *sk)
109 init_timer(&sk->sk_timer);
110 sk->sk_timer.function = sco_sock_timeout;
111 sk->sk_timer.data = (unsigned long)sk;
114 /* ---- SCO connections ---- */
115 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
117 struct hci_dev *hdev = hcon->hdev;
118 struct sco_conn *conn;
120 if ((conn = hcon->sco_data))
126 if (!(conn = kmalloc(sizeof(struct sco_conn), GFP_ATOMIC)))
128 memset(conn, 0, sizeof(struct sco_conn));
130 spin_lock_init(&conn->lock);
132 hcon->sco_data = conn;
135 conn->src = &hdev->bdaddr;
136 conn->dst = &hcon->dst;
138 if (hdev->sco_mtu > 0)
139 conn->mtu = hdev->sco_mtu;
143 BT_DBG("hcon %p conn %p", hcon, conn);
147 static inline struct sock *sco_chan_get(struct sco_conn *conn)
149 struct sock *sk = NULL;
152 sco_conn_unlock(conn);
156 static int sco_conn_del(struct hci_conn *hcon, int err)
158 struct sco_conn *conn;
161 if (!(conn = hcon->sco_data))
164 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
167 if ((sk = sco_chan_get(conn))) {
169 sco_sock_clear_timer(sk);
170 sco_chan_del(sk, err);
175 hcon->sco_data = NULL;
180 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
188 __sco_chan_add(conn, sk, parent);
190 sco_conn_unlock(conn);
194 static int sco_connect(struct sock *sk)
196 bdaddr_t *src = &bt_sk(sk)->src;
197 bdaddr_t *dst = &bt_sk(sk)->dst;
198 struct sco_conn *conn;
199 struct hci_conn *hcon;
200 struct hci_dev *hdev;
203 BT_DBG("%s -> %s", batostr(src), batostr(dst));
205 if (!(hdev = hci_get_route(dst, src)))
206 return -EHOSTUNREACH;
208 hci_dev_lock_bh(hdev);
212 hcon = hci_connect(hdev, SCO_LINK, dst);
216 conn = sco_conn_add(hcon, 0);
222 /* Update source addr of the socket */
223 bacpy(src, conn->src);
225 err = sco_chan_add(conn, sk, NULL);
229 if (hcon->state == BT_CONNECTED) {
230 sco_sock_clear_timer(sk);
231 sk->sk_state = BT_CONNECTED;
233 sk->sk_state = BT_CONNECT;
234 sco_sock_set_timer(sk, sk->sk_sndtimeo);
237 hci_dev_unlock_bh(hdev);
242 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
244 struct sco_conn *conn = sco_pi(sk)->conn;
248 /* Check outgoing MTU */
252 BT_DBG("sk %p len %d", sk, len);
254 count = min_t(unsigned int, conn->mtu, len);
255 if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
258 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
263 if ((err = hci_send_sco(conn->hcon, skb)) < 0)
273 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
275 struct sock *sk = sco_chan_get(conn);
280 BT_DBG("sk %p len %d", sk, skb->len);
282 if (sk->sk_state != BT_CONNECTED)
285 if (!sock_queue_rcv_skb(sk, skb))
293 /* -------- Socket interface ---------- */
294 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
297 struct hlist_node *node;
299 sk_for_each(sk, node, &sco_sk_list.head)
300 if (!bacmp(&bt_sk(sk)->src, ba))
307 /* Find socket listening on source bdaddr.
308 * Returns closest match.
310 static struct sock *sco_get_sock_listen(bdaddr_t *src)
312 struct sock *sk = NULL, *sk1 = NULL;
313 struct hlist_node *node;
315 read_lock(&sco_sk_list.lock);
317 sk_for_each(sk, node, &sco_sk_list.head) {
318 if (sk->sk_state != BT_LISTEN)
322 if (!bacmp(&bt_sk(sk)->src, src))
326 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
330 read_unlock(&sco_sk_list.lock);
332 return node ? sk : sk1;
335 static void sco_sock_destruct(struct sock *sk)
339 skb_queue_purge(&sk->sk_receive_queue);
340 skb_queue_purge(&sk->sk_write_queue);
343 kfree(sk->sk_protinfo);
346 static void sco_sock_cleanup_listen(struct sock *parent)
350 BT_DBG("parent %p", parent);
352 /* Close not yet accepted channels */
353 while ((sk = bt_accept_dequeue(parent, NULL))) {
358 parent->sk_state = BT_CLOSED;
359 parent->sk_zapped = 1;
362 /* Kill socket (only if zapped and orphan)
363 * Must be called on unlocked socket.
365 static void sco_sock_kill(struct sock *sk)
367 if (!sk->sk_zapped || sk->sk_socket)
370 BT_DBG("sk %p state %d", sk, sk->sk_state);
372 /* Kill poor orphan */
373 bt_sock_unlink(&sco_sk_list, sk);
374 sock_set_flag(sk, SOCK_DEAD);
379 * Must be called on unlocked socket.
381 static void sco_sock_close(struct sock *sk)
383 struct sco_conn *conn;
385 sco_sock_clear_timer(sk);
389 conn = sco_pi(sk)->conn;
391 BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
393 switch (sk->sk_state) {
395 sco_sock_cleanup_listen(sk);
402 sco_chan_del(sk, ECONNRESET);
415 static void sco_sock_init(struct sock *sk, struct sock *parent)
420 sk->sk_type = parent->sk_type;
423 static struct sock *sco_sock_alloc(struct socket *sock, int proto, int prio)
427 sk = bt_sock_alloc(sock, proto, sizeof(struct sco_pinfo), prio);
431 sk_set_owner(sk, THIS_MODULE);
433 sk->sk_destruct = sco_sock_destruct;
434 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
435 sk->sk_state = BT_OPEN;
437 sco_sock_init_timer(sk);
439 bt_sock_link(&sco_sk_list, sk);
443 static int sco_sock_create(struct socket *sock, int protocol)
447 BT_DBG("sock %p", sock);
449 sock->state = SS_UNCONNECTED;
451 if (sock->type != SOCK_SEQPACKET)
452 return -ESOCKTNOSUPPORT;
454 sock->ops = &sco_sock_ops;
456 if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL)))
459 sco_sock_init(sk, NULL);
463 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
465 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
466 struct sock *sk = sock->sk;
467 bdaddr_t *src = &sa->sco_bdaddr;
470 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
472 if (!addr || addr->sa_family != AF_BLUETOOTH)
477 if (sk->sk_state != BT_OPEN) {
482 write_lock_bh(&sco_sk_list.lock);
484 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
487 /* Save source address */
488 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
489 sk->sk_state = BT_BOUND;
492 write_unlock_bh(&sco_sk_list.lock);
499 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
501 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
502 struct sock *sk = sock->sk;
508 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
511 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
514 if (sk->sk_type != SOCK_SEQPACKET)
519 /* Set destination address and psm */
520 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
522 if ((err = sco_connect(sk)))
525 err = bt_sock_wait_state(sk, BT_CONNECTED,
526 sock_sndtimeo(sk, flags & O_NONBLOCK));
533 static int sco_sock_listen(struct socket *sock, int backlog)
535 struct sock *sk = sock->sk;
538 BT_DBG("sk %p backlog %d", sk, backlog);
542 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
547 sk->sk_max_ack_backlog = backlog;
548 sk->sk_ack_backlog = 0;
549 sk->sk_state = BT_LISTEN;
556 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
558 DECLARE_WAITQUEUE(wait, current);
559 struct sock *sk = sock->sk, *ch;
565 if (sk->sk_state != BT_LISTEN) {
570 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
572 BT_DBG("sk %p timeo %ld", sk, timeo);
574 /* Wait for an incoming connection. (wake-one). */
575 add_wait_queue_exclusive(sk->sk_sleep, &wait);
576 while (!(ch = bt_accept_dequeue(sk, newsock))) {
577 set_current_state(TASK_INTERRUPTIBLE);
584 timeo = schedule_timeout(timeo);
587 if (sk->sk_state != BT_LISTEN) {
592 if (signal_pending(current)) {
593 err = sock_intr_errno(timeo);
597 set_current_state(TASK_RUNNING);
598 remove_wait_queue(sk->sk_sleep, &wait);
603 newsock->state = SS_CONNECTED;
605 BT_DBG("new socket %p", ch);
612 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
614 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
615 struct sock *sk = sock->sk;
617 BT_DBG("sock %p, sk %p", sock, sk);
619 addr->sa_family = AF_BLUETOOTH;
620 *len = sizeof(struct sockaddr_sco);
623 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
625 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
630 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
631 struct msghdr *msg, size_t len)
633 struct sock *sk = sock->sk;
636 BT_DBG("sock %p, sk %p", sock, sk);
639 return 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 int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
657 struct sock *sk = sock->sk;
674 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
676 struct sock *sk = sock->sk;
677 struct sco_options opts;
678 struct sco_conninfo cinfo;
683 if (get_user(len, optlen))
690 if (sk->sk_state != BT_CONNECTED) {
695 opts.mtu = sco_pi(sk)->conn->mtu;
697 BT_DBG("mtu %d", opts.mtu);
699 len = min_t(unsigned int, len, sizeof(opts));
700 if (copy_to_user(optval, (char *)&opts, len))
706 if (sk->sk_state != BT_CONNECTED) {
711 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
713 len = min_t(unsigned int, len, sizeof(cinfo));
714 if (copy_to_user(optval, (char *)&cinfo, len))
728 static int sco_sock_release(struct socket *sock)
730 struct sock *sk = sock->sk;
733 BT_DBG("sock %p, sk %p", sock, sk);
740 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
742 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
751 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
753 BT_DBG("conn %p", conn);
755 sco_pi(sk)->conn = conn;
759 bt_accept_enqueue(parent, sk);
763 * Must be called on the locked socket. */
764 static void sco_chan_del(struct sock *sk, int err)
766 struct sco_conn *conn;
768 conn = sco_pi(sk)->conn;
770 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
775 sco_pi(sk)->conn = NULL;
776 sco_conn_unlock(conn);
777 hci_conn_put(conn->hcon);
780 sk->sk_state = BT_CLOSED;
782 sk->sk_state_change(sk);
787 static void sco_conn_ready(struct sco_conn *conn)
789 struct sock *parent, *sk;
791 BT_DBG("conn %p", conn);
795 if ((sk = conn->sk)) {
796 sco_sock_clear_timer(sk);
798 sk->sk_state = BT_CONNECTED;
799 sk->sk_state_change(sk);
802 parent = sco_get_sock_listen(conn->src);
806 bh_lock_sock(parent);
808 sk = sco_sock_alloc(NULL, BTPROTO_SCO, GFP_ATOMIC);
810 bh_unlock_sock(parent);
814 sco_sock_init(sk, parent);
816 bacpy(&bt_sk(sk)->src, conn->src);
817 bacpy(&bt_sk(sk)->dst, conn->dst);
819 hci_conn_hold(conn->hcon);
820 __sco_chan_add(conn, sk, parent);
822 sk->sk_state = BT_CONNECTED;
825 parent->sk_data_ready(parent, 1);
827 bh_unlock_sock(parent);
831 sco_conn_unlock(conn);
834 /* ----- SCO interface with lower layer (HCI) ----- */
835 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
837 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
839 /* Always accept connection */
840 return HCI_LM_ACCEPT;
843 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
845 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
847 if (hcon->type != SCO_LINK)
851 struct sco_conn *conn;
853 conn = sco_conn_add(hcon, status);
855 sco_conn_ready(conn);
857 sco_conn_del(hcon, bt_err(status));
862 static int sco_disconn_ind(struct hci_conn *hcon, __u8 reason)
864 BT_DBG("hcon %p reason %d", hcon, reason);
866 if (hcon->type != SCO_LINK)
869 sco_conn_del(hcon, bt_err(reason));
873 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
875 struct sco_conn *conn = hcon->sco_data;
880 BT_DBG("conn %p len %d", conn, skb->len);
883 sco_recv_frame(conn, skb);
892 /* ---- Proc fs support ---- */
893 #ifdef CONFIG_PROC_FS
894 static void *sco_seq_start(struct seq_file *seq, loff_t *pos)
897 struct hlist_node *node;
900 read_lock_bh(&sco_sk_list.lock);
902 sk_for_each(sk, node, &sco_sk_list.head)
910 static void *sco_seq_next(struct seq_file *seq, void *e, loff_t *pos)
917 static void sco_seq_stop(struct seq_file *seq, void *e)
919 read_unlock_bh(&sco_sk_list.lock);
922 static int sco_seq_show(struct seq_file *seq, void *e)
925 seq_printf(seq, "%s %s %d\n",
926 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst), sk->sk_state);
930 static struct seq_operations sco_seq_ops = {
931 .start = sco_seq_start,
932 .next = sco_seq_next,
933 .stop = sco_seq_stop,
937 static int sco_seq_open(struct inode *inode, struct file *file)
939 return seq_open(file, &sco_seq_ops);
942 static struct file_operations sco_seq_fops = {
943 .owner = THIS_MODULE,
944 .open = sco_seq_open,
947 .release = seq_release,
950 static int __init sco_proc_init(void)
952 struct proc_dir_entry *p = create_proc_entry("sco", S_IRUGO, proc_bt);
955 p->owner = THIS_MODULE;
956 p->proc_fops = &sco_seq_fops;
960 static void __exit sco_proc_cleanup(void)
962 remove_proc_entry("sco", proc_bt);
965 #else /* CONFIG_PROC_FS */
967 static int __init sco_proc_init(void)
972 static void __exit sco_proc_cleanup(void)
976 #endif /* CONFIG_PROC_FS */
978 static struct proto_ops sco_sock_ops = {
979 .family = PF_BLUETOOTH,
980 .owner = THIS_MODULE,
981 .release = sco_sock_release,
982 .bind = sco_sock_bind,
983 .connect = sco_sock_connect,
984 .listen = sco_sock_listen,
985 .accept = sco_sock_accept,
986 .getname = sco_sock_getname,
987 .sendmsg = sco_sock_sendmsg,
988 .recvmsg = bt_sock_recvmsg,
989 .poll = bt_sock_poll,
990 .ioctl = sock_no_ioctl,
991 .mmap = sock_no_mmap,
992 .socketpair = sock_no_socketpair,
993 .shutdown = sock_no_shutdown,
994 .setsockopt = sco_sock_setsockopt,
995 .getsockopt = sco_sock_getsockopt
998 static struct net_proto_family sco_sock_family_ops = {
999 .family = PF_BLUETOOTH,
1000 .owner = THIS_MODULE,
1001 .create = sco_sock_create,
1004 static struct hci_proto sco_hci_proto = {
1006 .id = HCI_PROTO_SCO,
1007 .connect_ind = sco_connect_ind,
1008 .connect_cfm = sco_connect_cfm,
1009 .disconn_ind = sco_disconn_ind,
1010 .recv_scodata = sco_recv_scodata
1013 static int __init sco_init(void)
1017 if ((err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops))) {
1018 BT_ERR("SCO socket registration failed");
1022 if ((err = hci_register_proto(&sco_hci_proto))) {
1023 BT_ERR("SCO protocol registration failed");
1029 BT_INFO("SCO (Voice Link) ver %s", VERSION);
1030 BT_INFO("SCO socket layer initialized");
1035 static void __exit sco_exit(void)
1041 /* Unregister socket, protocol and notifier */
1042 if ((err = bt_sock_unregister(BTPROTO_SCO)))
1043 BT_ERR("SCO socket unregistration failed. %d", err);
1045 if ((err = hci_unregister_proto(&sco_hci_proto)))
1046 BT_ERR("SCO protocol unregistration failed. %d", err);
1049 module_init(sco_init);
1050 module_exit(sco_exit);
1052 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
1053 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1054 MODULE_VERSION(VERSION);
1055 MODULE_LICENSE("GPL");
1056 MODULE_ALIAS("bt-proto-2");