[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / af_bluetooth.c

/* 
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 
   SOFTWARE IS DISCLAIMED.
*/

/* Bluetooth address family and sockets. */

#include <linux/module.h>

#include <linux/types.h>
#include <linux/list.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <net/sock.h>

#if defined(CONFIG_KMOD)
#include <linux/kmod.h>
#endif

#include <net/bluetooth/bluetooth.h>

#ifndef CONFIG_BT_SOCK_DEBUG
#undef  BT_DBG
#define BT_DBG(D...)
#endif

#define VERSION "2.11"

/* Bluetooth sockets */
#define BT_MAX_PROTO	8
static struct net_proto_family *bt_proto[BT_MAX_PROTO];
static DEFINE_RWLOCK(bt_proto_lock);

int bt_sock_register(int proto, struct net_proto_family *ops)
{
	int err = 0;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	write_lock(&bt_proto_lock);

	if (bt_proto[proto])
		err = -EEXIST;
	else
		bt_proto[proto] = ops;

	write_unlock(&bt_proto_lock);

	return err;
}
EXPORT_SYMBOL(bt_sock_register);

int bt_sock_unregister(int proto)
{
	int err = 0;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	write_lock(&bt_proto_lock);

	if (!bt_proto[proto])
		err = -ENOENT;
	else
		bt_proto[proto] = NULL;

	write_unlock(&bt_proto_lock);

	return err;
}
EXPORT_SYMBOL(bt_sock_unregister);

static int bt_sock_create(struct socket *sock, int proto)
{
	int err;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

#if defined(CONFIG_KMOD)
	if (!bt_proto[proto]) {
		request_module("bt-proto-%d", proto);
	}
#endif

	err = -EPROTONOSUPPORT;

	read_lock(&bt_proto_lock);

	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
		err = bt_proto[proto]->create(sock, proto);
		module_put(bt_proto[proto]->owner);
	}

	read_unlock(&bt_proto_lock);

	return err; 
}

void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
{
	write_lock_bh(&l->lock);
	sk_add_node(sk, &l->head);
	write_unlock_bh(&l->lock);
}
EXPORT_SYMBOL(bt_sock_link);

void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
{
	write_lock_bh(&l->lock);
	sk_del_node_init(sk);
	write_unlock_bh(&l->lock);
}
EXPORT_SYMBOL(bt_sock_unlink);

void bt_accept_enqueue(struct sock *parent, struct sock *sk)
{
	BT_DBG("parent %p, sk %p", parent, sk);

	sock_hold(sk);
	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	bt_sk(sk)->parent = parent;
	parent->sk_ack_backlog++;
}
EXPORT_SYMBOL(bt_accept_enqueue);

void bt_accept_unlink(struct sock *sk)
{
	BT_DBG("sk %p state %d", sk, sk->sk_state);

	list_del_init(&bt_sk(sk)->accept_q);
	bt_sk(sk)->parent->sk_ack_backlog--;
	bt_sk(sk)->parent = NULL;
	sock_put(sk);
}
EXPORT_SYMBOL(bt_accept_unlink);

struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
{
	struct list_head *p, *n;
	struct sock *sk;

	BT_DBG("parent %p", parent);

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);

		lock_sock(sk);

		/* FIXME: Is this check still needed */
		if (sk->sk_state == BT_CLOSED) {
			release_sock(sk);
			bt_accept_unlink(sk);
			continue;
		}

		if (sk->sk_state == BT_CONNECTED || !newsock) {
			bt_accept_unlink(sk);
			if (newsock)
				sock_graft(sk, newsock);
			release_sock(sk);
			return sk;
		}

		release_sock(sk);
	}
	return NULL;
}
EXPORT_SYMBOL(bt_accept_dequeue);

int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
	struct msghdr *msg, size_t len, int flags)
{
	int noblock = flags & MSG_DONTWAIT;
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	size_t copied;
	int err;

	BT_DBG("sock %p sk %p len %d", sock, sk, len);

	if (flags & (MSG_OOB))
		return -EOPNOTSUPP;

	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
		if (sk->sk_shutdown & RCV_SHUTDOWN)
			return 0;
		return err;
	}

	msg->msg_namelen = 0;

	copied = skb->len;
	if (len < copied) {
		msg->msg_flags |= MSG_TRUNC;
		copied = len;
	}

	skb->h.raw = skb->data;
	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);

	skb_free_datagram(sk, skb);

	return err ? : copied;
}
EXPORT_SYMBOL(bt_sock_recvmsg);

static inline unsigned int bt_accept_poll(struct sock *parent)
{
	struct list_head *p, *n;
	struct sock *sk;

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
		if (sk->sk_state == BT_CONNECTED)
			return POLLIN | POLLRDNORM;
	}

	return 0;
}

unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
{
	struct sock *sk = sock->sk;
	unsigned int mask = 0;

	BT_DBG("sock %p, sk %p", sock, sk);

	poll_wait(file, sk->sk_sleep, wait);

	if (sk->sk_state == BT_LISTEN)
		return bt_accept_poll(sk);

	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
		mask |= POLLERR;

	if (sk->sk_shutdown & RCV_SHUTDOWN)
		mask |= POLLRDHUP;

	if (sk->sk_shutdown == SHUTDOWN_MASK)
		mask |= POLLHUP;

	if (!skb_queue_empty(&sk->sk_receive_queue) || 
			(sk->sk_shutdown & RCV_SHUTDOWN))
		mask |= POLLIN | POLLRDNORM;

	if (sk->sk_state == BT_CLOSED)
		mask |= POLLHUP;

	if (sk->sk_state == BT_CONNECT ||
			sk->sk_state == BT_CONNECT2 ||
			sk->sk_state == BT_CONFIG)
		return mask;

	if (sock_writeable(sk))
		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
	else
		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

	return mask;
}
EXPORT_SYMBOL(bt_sock_poll);

int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
{
	DECLARE_WAITQUEUE(wait, current);
	int err = 0;

	BT_DBG("sk %p", sk);

	add_wait_queue(sk->sk_sleep, &wait);
	while (sk->sk_state != state) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (!timeo) {
			err = -EINPROGRESS;
			break;
		}

		if (signal_pending(current)) {
			err = sock_intr_errno(timeo);
			break;
		}

		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);

		err = sock_error(sk);
		if (err)
			break;
	}
	set_current_state(TASK_RUNNING);
	remove_wait_queue(sk->sk_sleep, &wait);
	return err;
}
EXPORT_SYMBOL(bt_sock_wait_state);

static struct net_proto_family bt_sock_family_ops = {
	.owner	= THIS_MODULE,
	.family	= PF_BLUETOOTH,
	.create	= bt_sock_create,
};

static int __init bt_init(void)
{
	int err;

	BT_INFO("Core ver %s", VERSION);

	err = bt_sysfs_init();
	if (err < 0)
		return err;

	err = sock_register(&bt_sock_family_ops);
	if (err < 0) {
		bt_sysfs_cleanup();
		return err;
	}

	BT_INFO("HCI device and connection manager initialized");

	hci_sock_init();

	return 0;
}

static void __exit bt_exit(void)
{
	hci_sock_cleanup();

	sock_unregister(PF_BLUETOOTH);

	bt_sysfs_cleanup();
}

subsys_initcall(bt_init);
module_exit(bt_exit);

MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
Commit	Line	Data
1da177e4 LT	1	/*
	2	BlueZ - Bluetooth protocol stack for Linux
	3	Copyright (C) 2000-2001 Qualcomm Incorporated
	4
	5	Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
	6
	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;
	10
	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.
	19
	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.
	23	*/
	24
	25	/* Bluetooth address family and sockets. */
	26
1da177e4 LT	27	#include <linux/module.h>
	28
	29	#include <linux/types.h>
	30	#include <linux/list.h>
	31	#include <linux/errno.h>
	32	#include <linux/kernel.h>
1da177e4 LT	33	#include <linux/sched.h>
	34	#include <linux/slab.h>
	35	#include <linux/skbuff.h>
	36	#include <linux/init.h>
	37	#include <linux/poll.h>
1da177e4 LT	38	#include <net/sock.h>
	39
	40	#if defined(CONFIG_KMOD)
	41	#include <linux/kmod.h>
	42	#endif
	43
	44	#include <net/bluetooth/bluetooth.h>
	45
	46	#ifndef CONFIG_BT_SOCK_DEBUG
	47	#undef BT_DBG
	48	#define BT_DBG(D...)
	49	#endif
	50
4c67bc74	51	#define VERSION "2.11"
1da177e4 LT	52
	53	/* Bluetooth sockets */
	54	#define BT_MAX_PROTO 8
	55	static struct net_proto_family *bt_proto[BT_MAX_PROTO];
74da626a	56	static DEFINE_RWLOCK(bt_proto_lock);
1da177e4 LT	57
	58	int bt_sock_register(int proto, struct net_proto_family *ops)
	59	{
74da626a MH	60	int err = 0;
74da626a MH	61
1da177e4 LT	62	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	63	return -EINVAL;
	64
74da626a MH	65	write_lock(&bt_proto_lock);
74da626a MH	66
1da177e4	67	if (bt_proto[proto])
74da626a MH	68	err = -EEXIST;
	69	else
	70	bt_proto[proto] = ops;
	71
	72	write_unlock(&bt_proto_lock);
1da177e4	73
74da626a	74	return err;
1da177e4 LT	75	}
	76	EXPORT_SYMBOL(bt_sock_register);
	77
	78	int bt_sock_unregister(int proto)
	79	{
74da626a MH	80	int err = 0;
74da626a MH	81
1da177e4 LT	82	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	83	return -EINVAL;
	84
74da626a MH	85	write_lock(&bt_proto_lock);
74da626a MH	86
1da177e4	87	if (!bt_proto[proto])
74da626a MH	88	err = -ENOENT;
	89	else
	90	bt_proto[proto] = NULL;
1da177e4	91
74da626a MH	92	write_unlock(&bt_proto_lock);
	93
	94	return err;
1da177e4 LT	95	}
	96	EXPORT_SYMBOL(bt_sock_unregister);
	97
	98	static int bt_sock_create(struct socket *sock, int proto)
	99	{
74da626a	100	int err;
1da177e4 LT	101
	102	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	103	return -EINVAL;
	104
	105	#if defined(CONFIG_KMOD)
	106	if (!bt_proto[proto]) {
	107	request_module("bt-proto-%d", proto);
	108	}
	109	#endif
74da626a	110
1da177e4	111	err = -EPROTONOSUPPORT;
74da626a MH	112
	113	read_lock(&bt_proto_lock);
	114
1da177e4 LT	115	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
	116	err = bt_proto[proto]->create(sock, proto);
	117	module_put(bt_proto[proto]->owner);
	118	}
74da626a MH	119
	120	read_unlock(&bt_proto_lock);
	121
1da177e4 LT	122	return err;
	123	}
	124
	125	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	126	{
	127	write_lock_bh(&l->lock);
	128	sk_add_node(sk, &l->head);
	129	write_unlock_bh(&l->lock);
	130	}
	131	EXPORT_SYMBOL(bt_sock_link);
	132
	133	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	134	{
	135	write_lock_bh(&l->lock);
	136	sk_del_node_init(sk);
	137	write_unlock_bh(&l->lock);
	138	}
	139	EXPORT_SYMBOL(bt_sock_unlink);
	140
	141	void bt_accept_enqueue(struct sock parent, struct sock sk)
	142	{
	143	BT_DBG("parent %p, sk %p", parent, sk);
	144
	145	sock_hold(sk);
	146	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	147	bt_sk(sk)->parent = parent;
	148	parent->sk_ack_backlog++;
	149	}
	150	EXPORT_SYMBOL(bt_accept_enqueue);
	151
	152	void bt_accept_unlink(struct sock *sk)
	153	{
	154	BT_DBG("sk %p state %d", sk, sk->sk_state);
	155
	156	list_del_init(&bt_sk(sk)->accept_q);
	157	bt_sk(sk)->parent->sk_ack_backlog--;
	158	bt_sk(sk)->parent = NULL;
	159	sock_put(sk);
	160	}
	161	EXPORT_SYMBOL(bt_accept_unlink);
	162
	163	struct sock bt_accept_dequeue(struct sock parent, struct socket *newsock)
	164	{
	165	struct list_head p, n;
	166	struct sock *sk;
	167
	168	BT_DBG("parent %p", parent);
	169
	170	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	171	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	172
	173	lock_sock(sk);
	174
	175	/* FIXME: Is this check still needed */
	176	if (sk->sk_state == BT_CLOSED) {
	177	release_sock(sk);
	178	bt_accept_unlink(sk);
	179	continue;
	180	}
	181
	182	if (sk->sk_state == BT_CONNECTED \|\| !newsock) {
	183	bt_accept_unlink(sk);
	184	if (newsock)
	185	sock_graft(sk, newsock);
186	release_sock(sk);
187	return sk;
188	}
189
190	release_sock(sk);
191	}
192	return NULL;
193	}
194	EXPORT_SYMBOL(bt_accept_dequeue);
195
196	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
197	struct msghdr *msg, size_t len, int flags)
198	{
199	int noblock = flags & MSG_DONTWAIT;
200	struct sock *sk = sock->sk;
201	struct sk_buff *skb;
202	size_t copied;
203	int err;
204
205	BT_DBG("sock %p sk %p len %d", sock, sk, len);
206
207	if (flags & (MSG_OOB))
208	return -EOPNOTSUPP;
209
210	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
211	if (sk->sk_shutdown & RCV_SHUTDOWN)
212	return 0;
213	return err;
214	}
215
216	msg->msg_namelen = 0;
217
218	copied = skb->len;
219	if (len < copied) {
220	msg->msg_flags \|= MSG_TRUNC;
221	copied = len;
222	}
223
224	skb->h.raw = skb->data;
225	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
226
227	skb_free_datagram(sk, skb);
228
229	return err ? : copied;
230	}
231	EXPORT_SYMBOL(bt_sock_recvmsg);
232
233	static inline unsigned int bt_accept_poll(struct sock *parent)
234	{
235	struct list_head p, n;
236	struct sock *sk;
237
238	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
239	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
240	if (sk->sk_state == BT_CONNECTED)
241	return POLLIN \| POLLRDNORM;
242	}
243
244	return 0;
245	}
246
247	unsigned int bt_sock_poll(struct file * file, struct socket sock, poll_table wait)
248	{
249	struct sock *sk = sock->sk;
250	unsigned int mask = 0;
251
252	BT_DBG("sock %p, sk %p", sock, sk);
253
254	poll_wait(file, sk->sk_sleep, wait);
255
256	if (sk->sk_state == BT_LISTEN)
257	return bt_accept_poll(sk);
258
259	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
260	mask \|= POLLERR;
261
f348d70a DL	262	if (sk->sk_shutdown & RCV_SHUTDOWN)
	263	mask \|= POLLRDHUP;
	264
1da177e4 LT	265	if (sk->sk_shutdown == SHUTDOWN_MASK)
	266	mask \|= POLLHUP;
	267
	268	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
	269	(sk->sk_shutdown & RCV_SHUTDOWN))
	270	mask \|= POLLIN \| POLLRDNORM;
	271
	272	if (sk->sk_state == BT_CLOSED)
	273	mask \|= POLLHUP;
	274
	275	if (sk->sk_state == BT_CONNECT \|\|
	276	sk->sk_state == BT_CONNECT2 \|\|
	277	sk->sk_state == BT_CONFIG)
	278	return mask;
	279
	280	if (sock_writeable(sk))
	281	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	282	else
	283	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	284
	285	return mask;
	286	}
	287	EXPORT_SYMBOL(bt_sock_poll);
	288
	289	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	290	{
	291	DECLARE_WAITQUEUE(wait, current);
	292	int err = 0;
	293
	294	BT_DBG("sk %p", sk);
	295
	296	add_wait_queue(sk->sk_sleep, &wait);
	297	while (sk->sk_state != state) {
	298	set_current_state(TASK_INTERRUPTIBLE);
	299
	300	if (!timeo) {
b4c612a4	301	err = -EINPROGRESS;
1da177e4 LT	302	break;
	303	}
	304
	305	if (signal_pending(current)) {
	306	err = sock_intr_errno(timeo);
	307	break;
	308	}
	309
	310	release_sock(sk);
	311	timeo = schedule_timeout(timeo);
	312	lock_sock(sk);
	313
c1cbe4b7 BL	314	err = sock_error(sk);
c1cbe4b7 BL	315	if (err)
1da177e4	316	break;
1da177e4 LT	317	}
	318	set_current_state(TASK_RUNNING);
	319	remove_wait_queue(sk->sk_sleep, &wait);
	320	return err;
	321	}
	322	EXPORT_SYMBOL(bt_sock_wait_state);
	323
	324	static struct net_proto_family bt_sock_family_ops = {
	325	.owner = THIS_MODULE,
	326	.family = PF_BLUETOOTH,
	327	.create = bt_sock_create,
	328	};
	329
1da177e4 LT	330	static int __init bt_init(void)
1da177e4 LT	331	{
27d35284 MH	332	int err;
27d35284 MH	333
1da177e4 LT	334	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	335
27d35284 MH	336	err = bt_sysfs_init();
	337	if (err < 0)
	338	return err;
1da177e4	339
27d35284 MH	340	err = sock_register(&bt_sock_family_ops);
	341	if (err < 0) {
	342	bt_sysfs_cleanup();
	343	return err;
	344	}
1da177e4	345
27d35284	346	BT_INFO("HCI device and connection manager initialized");
1da177e4 LT	347
	348	hci_sock_init();
	349
	350	return 0;
	351	}
	352
	353	static void __exit bt_exit(void)
	354	{
	355	hci_sock_cleanup();
	356
1da177e4	357	sock_unregister(PF_BLUETOOTH);
27d35284 MH	358
27d35284 MH	359	bt_sysfs_cleanup();
1da177e4 LT	360	}
	361
	362	subsys_initcall(bt_init);
	363	module_exit(bt_exit);
	364
	365	MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
	366	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	367	MODULE_VERSION(VERSION);
	368	MODULE_LICENSE("GPL");
	369	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);