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/sched.h>
34 #include <linux/slab.h>
35 #include <linux/poll.h>
36 #include <linux/fcntl.h>
37 #include <linux/init.h>
38 #include <linux/interrupt.h>
39 #include <linux/socket.h>
40 #include <linux/skbuff.h>
41 #include <linux/device.h>
42 #include <linux/list.h>
45 #include <asm/system.h>
46 #include <asm/uaccess.h>
48 #include <net/bluetooth/bluetooth.h>
49 #include <net/bluetooth/hci_core.h>
50 #include <net/bluetooth/sco.h>
52 #ifndef CONFIG_BT_SCO_DEBUG
59 static struct proto_ops sco_sock_ops
;
61 static struct bt_sock_list sco_sk_list
= {
62 .lock
= RW_LOCK_UNLOCKED
65 static void __sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
, struct sock
*parent
);
66 static void sco_chan_del(struct sock
*sk
, int err
);
68 static int sco_conn_del(struct hci_conn
*conn
, int err
);
70 static void sco_sock_close(struct sock
*sk
);
71 static void sco_sock_kill(struct sock
*sk
);
73 /* ---- SCO timers ---- */
74 static void sco_sock_timeout(unsigned long arg
)
76 struct sock
*sk
= (struct sock
*) arg
;
78 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
81 sk
->sk_err
= ETIMEDOUT
;
82 sk
->sk_state_change(sk
);
89 static void sco_sock_set_timer(struct sock
*sk
, long timeout
)
91 BT_DBG("sock %p state %d timeout %ld", sk
, sk
->sk_state
, timeout
);
92 sk_reset_timer(sk
, &sk
->sk_timer
, jiffies
+ timeout
);
95 static void sco_sock_clear_timer(struct sock
*sk
)
97 BT_DBG("sock %p state %d", sk
, sk
->sk_state
);
98 sk_stop_timer(sk
, &sk
->sk_timer
);
101 static void sco_sock_init_timer(struct sock
*sk
)
103 init_timer(&sk
->sk_timer
);
104 sk
->sk_timer
.function
= sco_sock_timeout
;
105 sk
->sk_timer
.data
= (unsigned long)sk
;
108 /* ---- SCO connections ---- */
109 static struct sco_conn
*sco_conn_add(struct hci_conn
*hcon
, __u8 status
)
111 struct hci_dev
*hdev
= hcon
->hdev
;
112 struct sco_conn
*conn
;
114 if ((conn
= hcon
->sco_data
))
120 if (!(conn
= kmalloc(sizeof(struct sco_conn
), GFP_ATOMIC
)))
122 memset(conn
, 0, sizeof(struct sco_conn
));
124 spin_lock_init(&conn
->lock
);
126 hcon
->sco_data
= conn
;
129 conn
->src
= &hdev
->bdaddr
;
130 conn
->dst
= &hcon
->dst
;
132 if (hdev
->sco_mtu
> 0)
133 conn
->mtu
= hdev
->sco_mtu
;
137 BT_DBG("hcon %p conn %p", hcon
, conn
);
141 static inline struct sock
*sco_chan_get(struct sco_conn
*conn
)
143 struct sock
*sk
= NULL
;
146 sco_conn_unlock(conn
);
150 static int sco_conn_del(struct hci_conn
*hcon
, int err
)
152 struct sco_conn
*conn
;
155 if (!(conn
= hcon
->sco_data
))
158 BT_DBG("hcon %p conn %p, err %d", hcon
, conn
, err
);
161 if ((sk
= sco_chan_get(conn
))) {
163 sco_sock_clear_timer(sk
);
164 sco_chan_del(sk
, err
);
169 hcon
->sco_data
= NULL
;
174 static inline int sco_chan_add(struct sco_conn
*conn
, struct sock
*sk
, struct sock
*parent
)
182 __sco_chan_add(conn
, sk
, parent
);
184 sco_conn_unlock(conn
);
188 static int sco_connect(struct sock
*sk
)
190 bdaddr_t
*src
= &bt_sk(sk
)->src
;
191 bdaddr_t
*dst
= &bt_sk(sk
)->dst
;
192 struct sco_conn
*conn
;
193 struct hci_conn
*hcon
;
194 struct hci_dev
*hdev
;
197 BT_DBG("%s -> %s", batostr(src
), batostr(dst
));
199 if (!(hdev
= hci_get_route(dst
, src
)))
200 return -EHOSTUNREACH
;
202 hci_dev_lock_bh(hdev
);
206 hcon
= hci_connect(hdev
, SCO_LINK
, dst
);
210 conn
= sco_conn_add(hcon
, 0);
216 /* Update source addr of the socket */
217 bacpy(src
, conn
->src
);
219 err
= sco_chan_add(conn
, sk
, NULL
);
223 if (hcon
->state
== BT_CONNECTED
) {
224 sco_sock_clear_timer(sk
);
225 sk
->sk_state
= BT_CONNECTED
;
227 sk
->sk_state
= BT_CONNECT
;
228 sco_sock_set_timer(sk
, sk
->sk_sndtimeo
);
231 hci_dev_unlock_bh(hdev
);
236 static inline int sco_send_frame(struct sock
*sk
, struct msghdr
*msg
, int len
)
238 struct sco_conn
*conn
= sco_pi(sk
)->conn
;
242 /* Check outgoing MTU */
246 BT_DBG("sk %p len %d", sk
, len
);
248 count
= min_t(unsigned int, conn
->mtu
, len
);
249 if (!(skb
= bt_skb_send_alloc(sk
, count
, msg
->msg_flags
& MSG_DONTWAIT
, &err
)))
252 if (memcpy_fromiovec(skb_put(skb
, count
), msg
->msg_iov
, count
)) {
257 if ((err
= hci_send_sco(conn
->hcon
, skb
)) < 0)
267 static inline void sco_recv_frame(struct sco_conn
*conn
, struct sk_buff
*skb
)
269 struct sock
*sk
= sco_chan_get(conn
);
274 BT_DBG("sk %p len %d", sk
, skb
->len
);
276 if (sk
->sk_state
!= BT_CONNECTED
)
279 if (!sock_queue_rcv_skb(sk
, skb
))
287 /* -------- Socket interface ---------- */
288 static struct sock
*__sco_get_sock_by_addr(bdaddr_t
*ba
)
291 struct hlist_node
*node
;
293 sk_for_each(sk
, node
, &sco_sk_list
.head
)
294 if (!bacmp(&bt_sk(sk
)->src
, ba
))
301 /* Find socket listening on source bdaddr.
302 * Returns closest match.
304 static struct sock
*sco_get_sock_listen(bdaddr_t
*src
)
306 struct sock
*sk
= NULL
, *sk1
= NULL
;
307 struct hlist_node
*node
;
309 read_lock(&sco_sk_list
.lock
);
311 sk_for_each(sk
, node
, &sco_sk_list
.head
) {
312 if (sk
->sk_state
!= BT_LISTEN
)
316 if (!bacmp(&bt_sk(sk
)->src
, src
))
320 if (!bacmp(&bt_sk(sk
)->src
, BDADDR_ANY
))
324 read_unlock(&sco_sk_list
.lock
);
326 return node
? sk
: sk1
;
329 static void sco_sock_destruct(struct sock
*sk
)
333 skb_queue_purge(&sk
->sk_receive_queue
);
334 skb_queue_purge(&sk
->sk_write_queue
);
337 static void sco_sock_cleanup_listen(struct sock
*parent
)
341 BT_DBG("parent %p", parent
);
343 /* Close not yet accepted channels */
344 while ((sk
= bt_accept_dequeue(parent
, NULL
))) {
349 parent
->sk_state
= BT_CLOSED
;
350 sock_set_flag(parent
, SOCK_ZAPPED
);
353 /* Kill socket (only if zapped and orphan)
354 * Must be called on unlocked socket.
356 static void sco_sock_kill(struct sock
*sk
)
358 if (!sock_flag(sk
, SOCK_ZAPPED
) || sk
->sk_socket
)
361 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
363 /* Kill poor orphan */
364 bt_sock_unlink(&sco_sk_list
, sk
);
365 sock_set_flag(sk
, SOCK_DEAD
);
370 * Must be called on unlocked socket.
372 static void sco_sock_close(struct sock
*sk
)
374 struct sco_conn
*conn
;
376 sco_sock_clear_timer(sk
);
380 conn
= sco_pi(sk
)->conn
;
382 BT_DBG("sk %p state %d conn %p socket %p", sk
, sk
->sk_state
, conn
, sk
->sk_socket
);
384 switch (sk
->sk_state
) {
386 sco_sock_cleanup_listen(sk
);
393 sco_chan_del(sk
, ECONNRESET
);
397 sock_set_flag(sk
, SOCK_ZAPPED
);
406 static void sco_sock_init(struct sock
*sk
, struct sock
*parent
)
411 sk
->sk_type
= parent
->sk_type
;
414 static struct proto sco_proto
= {
416 .owner
= THIS_MODULE
,
417 .obj_size
= sizeof(struct sco_pinfo
)
420 static struct sock
*sco_sock_alloc(struct socket
*sock
, int proto
, gfp_t prio
)
424 sk
= sk_alloc(PF_BLUETOOTH
, prio
, &sco_proto
, 1);
428 sock_init_data(sock
, sk
);
429 INIT_LIST_HEAD(&bt_sk(sk
)->accept_q
);
431 sk
->sk_destruct
= sco_sock_destruct
;
432 sk
->sk_sndtimeo
= SCO_CONN_TIMEOUT
;
434 sock_reset_flag(sk
, SOCK_ZAPPED
);
436 sk
->sk_protocol
= proto
;
437 sk
->sk_state
= BT_OPEN
;
439 sco_sock_init_timer(sk
);
441 bt_sock_link(&sco_sk_list
, sk
);
445 static int sco_sock_create(struct socket
*sock
, int protocol
)
449 BT_DBG("sock %p", sock
);
451 sock
->state
= SS_UNCONNECTED
;
453 if (sock
->type
!= SOCK_SEQPACKET
)
454 return -ESOCKTNOSUPPORT
;
456 sock
->ops
= &sco_sock_ops
;
458 if (!(sk
= sco_sock_alloc(sock
, protocol
, GFP_KERNEL
)))
461 sco_sock_init(sk
, NULL
);
465 static int sco_sock_bind(struct socket
*sock
, struct sockaddr
*addr
, int addr_len
)
467 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
468 struct sock
*sk
= sock
->sk
;
469 bdaddr_t
*src
= &sa
->sco_bdaddr
;
472 BT_DBG("sk %p %s", sk
, batostr(&sa
->sco_bdaddr
));
474 if (!addr
|| addr
->sa_family
!= AF_BLUETOOTH
)
479 if (sk
->sk_state
!= BT_OPEN
) {
484 write_lock_bh(&sco_sk_list
.lock
);
486 if (bacmp(src
, BDADDR_ANY
) && __sco_get_sock_by_addr(src
)) {
489 /* Save source address */
490 bacpy(&bt_sk(sk
)->src
, &sa
->sco_bdaddr
);
491 sk
->sk_state
= BT_BOUND
;
494 write_unlock_bh(&sco_sk_list
.lock
);
501 static int sco_sock_connect(struct socket
*sock
, struct sockaddr
*addr
, int alen
, int flags
)
503 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
504 struct sock
*sk
= sock
->sk
;
510 if (addr
->sa_family
!= AF_BLUETOOTH
|| alen
< sizeof(struct sockaddr_sco
))
513 if (sk
->sk_state
!= BT_OPEN
&& sk
->sk_state
!= BT_BOUND
)
516 if (sk
->sk_type
!= SOCK_SEQPACKET
)
521 /* Set destination address and psm */
522 bacpy(&bt_sk(sk
)->dst
, &sa
->sco_bdaddr
);
524 if ((err
= sco_connect(sk
)))
527 err
= bt_sock_wait_state(sk
, BT_CONNECTED
,
528 sock_sndtimeo(sk
, flags
& O_NONBLOCK
));
535 static int sco_sock_listen(struct socket
*sock
, int backlog
)
537 struct sock
*sk
= sock
->sk
;
540 BT_DBG("sk %p backlog %d", sk
, backlog
);
544 if (sk
->sk_state
!= BT_BOUND
|| sock
->type
!= SOCK_SEQPACKET
) {
549 sk
->sk_max_ack_backlog
= backlog
;
550 sk
->sk_ack_backlog
= 0;
551 sk
->sk_state
= BT_LISTEN
;
558 static int sco_sock_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
560 DECLARE_WAITQUEUE(wait
, current
);
561 struct sock
*sk
= sock
->sk
, *ch
;
567 if (sk
->sk_state
!= BT_LISTEN
) {
572 timeo
= sock_rcvtimeo(sk
, flags
& O_NONBLOCK
);
574 BT_DBG("sk %p timeo %ld", sk
, timeo
);
576 /* Wait for an incoming connection. (wake-one). */
577 add_wait_queue_exclusive(sk
->sk_sleep
, &wait
);
578 while (!(ch
= bt_accept_dequeue(sk
, newsock
))) {
579 set_current_state(TASK_INTERRUPTIBLE
);
586 timeo
= schedule_timeout(timeo
);
589 if (sk
->sk_state
!= BT_LISTEN
) {
594 if (signal_pending(current
)) {
595 err
= sock_intr_errno(timeo
);
599 set_current_state(TASK_RUNNING
);
600 remove_wait_queue(sk
->sk_sleep
, &wait
);
605 newsock
->state
= SS_CONNECTED
;
607 BT_DBG("new socket %p", ch
);
614 static int sco_sock_getname(struct socket
*sock
, struct sockaddr
*addr
, int *len
, int peer
)
616 struct sockaddr_sco
*sa
= (struct sockaddr_sco
*) addr
;
617 struct sock
*sk
= sock
->sk
;
619 BT_DBG("sock %p, sk %p", sock
, sk
);
621 addr
->sa_family
= AF_BLUETOOTH
;
622 *len
= sizeof(struct sockaddr_sco
);
625 bacpy(&sa
->sco_bdaddr
, &bt_sk(sk
)->dst
);
627 bacpy(&sa
->sco_bdaddr
, &bt_sk(sk
)->src
);
632 static int sco_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
633 struct msghdr
*msg
, size_t len
)
635 struct sock
*sk
= sock
->sk
;
638 BT_DBG("sock %p, sk %p", sock
, sk
);
641 return 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 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");