[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 net *net, struct socket *sock, int proto)
{
	int err;

	if (net != &init_net)
		return -EAFNOSUPPORT;

	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(net, 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_reset_transport_header(skb);
	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
8e87d142	1	/*
1da177e4 LT	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
8e87d142 YH	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
1da177e4 LT	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	19
8e87d142 YH	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	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
1b8d7ae4	98	static int bt_sock_create(struct net net, struct socket sock, int proto)
1da177e4	99	{
74da626a	100	int err;
1da177e4	101
1b8d7ae4 EB	102	if (net != &init_net)
	103	return -EAFNOSUPPORT;
	104
1da177e4 LT	105	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	106	return -EINVAL;
	107
	108	#if defined(CONFIG_KMOD)
	109	if (!bt_proto[proto]) {
	110	request_module("bt-proto-%d", proto);
	111	}
	112	#endif
74da626a	113
1da177e4	114	err = -EPROTONOSUPPORT;
74da626a MH	115
	116	read_lock(&bt_proto_lock);
	117
1da177e4	118	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
1b8d7ae4	119	err = bt_proto[proto]->create(net, sock, proto);
1da177e4 LT	120	module_put(bt_proto[proto]->owner);
1da177e4 LT	121	}
74da626a MH	122
	123	read_unlock(&bt_proto_lock);
	124
8e87d142	125	return err;
1da177e4 LT	126	}
	127
	128	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	129	{
	130	write_lock_bh(&l->lock);
	131	sk_add_node(sk, &l->head);
	132	write_unlock_bh(&l->lock);
	133	}
	134	EXPORT_SYMBOL(bt_sock_link);
	135
	136	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	137	{
	138	write_lock_bh(&l->lock);
	139	sk_del_node_init(sk);
	140	write_unlock_bh(&l->lock);
	141	}
	142	EXPORT_SYMBOL(bt_sock_unlink);
	143
	144	void bt_accept_enqueue(struct sock parent, struct sock sk)
	145	{
	146	BT_DBG("parent %p, sk %p", parent, sk);
	147
	148	sock_hold(sk);
	149	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	150	bt_sk(sk)->parent = parent;
	151	parent->sk_ack_backlog++;
	152	}
	153	EXPORT_SYMBOL(bt_accept_enqueue);
	154
	155	void bt_accept_unlink(struct sock *sk)
	156	{
	157	BT_DBG("sk %p state %d", sk, sk->sk_state);
	158
	159	list_del_init(&bt_sk(sk)->accept_q);
	160	bt_sk(sk)->parent->sk_ack_backlog--;
	161	bt_sk(sk)->parent = NULL;
	162	sock_put(sk);
	163	}
	164	EXPORT_SYMBOL(bt_accept_unlink);
	165
	166	struct sock bt_accept_dequeue(struct sock parent, struct socket *newsock)
	167	{
	168	struct list_head p, n;
	169	struct sock *sk;
	170
	171	BT_DBG("parent %p", parent);
	172
	173	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	174	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	175
	176	lock_sock(sk);
	177
	178	/* FIXME: Is this check still needed */
	179	if (sk->sk_state == BT_CLOSED) {
	180	release_sock(sk);
	181	bt_accept_unlink(sk);
	182	continue;
	183	}
	184
	185	if (sk->sk_state == BT_CONNECTED \|\| !newsock) {
	186	bt_accept_unlink(sk);
	187	if (newsock)
	188	sock_graft(sk, newsock);
	189	release_sock(sk);
190	return sk;
191	}
192
193	release_sock(sk);
194	}
195	return NULL;
196	}
197	EXPORT_SYMBOL(bt_accept_dequeue);
198
199	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
200	struct msghdr *msg, size_t len, int flags)
201	{
202	int noblock = flags & MSG_DONTWAIT;
203	struct sock *sk = sock->sk;
204	struct sk_buff *skb;
205	size_t copied;
206	int err;
207
208	BT_DBG("sock %p sk %p len %d", sock, sk, len);
209
210	if (flags & (MSG_OOB))
211	return -EOPNOTSUPP;
212
213	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
214	if (sk->sk_shutdown & RCV_SHUTDOWN)
215	return 0;
216	return err;
217	}
218
219	msg->msg_namelen = 0;
220
221	copied = skb->len;
222	if (len < copied) {
223	msg->msg_flags \|= MSG_TRUNC;
224	copied = len;
225	}
226
badff6d0	227	skb_reset_transport_header(skb);
1da177e4 LT	228	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	229
	230	skb_free_datagram(sk, skb);
	231
	232	return err ? : copied;
	233	}
	234	EXPORT_SYMBOL(bt_sock_recvmsg);
	235
	236	static inline unsigned int bt_accept_poll(struct sock *parent)
	237	{
	238	struct list_head p, n;
	239	struct sock *sk;
	240
	241	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	242	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
	243	if (sk->sk_state == BT_CONNECTED)
	244	return POLLIN \| POLLRDNORM;
	245	}
	246
	247	return 0;
	248	}
	249
	250	unsigned int bt_sock_poll(struct file * file, struct socket sock, poll_table wait)
	251	{
	252	struct sock *sk = sock->sk;
	253	unsigned int mask = 0;
	254
	255	BT_DBG("sock %p, sk %p", sock, sk);
	256
	257	poll_wait(file, sk->sk_sleep, wait);
	258
	259	if (sk->sk_state == BT_LISTEN)
	260	return bt_accept_poll(sk);
	261
	262	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
	263	mask \|= POLLERR;
	264
f348d70a DL	265	if (sk->sk_shutdown & RCV_SHUTDOWN)
	266	mask \|= POLLRDHUP;
	267
1da177e4 LT	268	if (sk->sk_shutdown == SHUTDOWN_MASK)
	269	mask \|= POLLHUP;
	270
8e87d142	271	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
1da177e4 LT	272	(sk->sk_shutdown & RCV_SHUTDOWN))
	273	mask \|= POLLIN \| POLLRDNORM;
	274
	275	if (sk->sk_state == BT_CLOSED)
	276	mask \|= POLLHUP;
	277
	278	if (sk->sk_state == BT_CONNECT \|\|
	279	sk->sk_state == BT_CONNECT2 \|\|
	280	sk->sk_state == BT_CONFIG)
	281	return mask;
	282
	283	if (sock_writeable(sk))
	284	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	285	else
	286	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	287
	288	return mask;
	289	}
	290	EXPORT_SYMBOL(bt_sock_poll);
	291
	292	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	293	{
	294	DECLARE_WAITQUEUE(wait, current);
	295	int err = 0;
	296
	297	BT_DBG("sk %p", sk);
	298
	299	add_wait_queue(sk->sk_sleep, &wait);
	300	while (sk->sk_state != state) {
	301	set_current_state(TASK_INTERRUPTIBLE);
	302
	303	if (!timeo) {
b4c612a4	304	err = -EINPROGRESS;
1da177e4 LT	305	break;
	306	}
	307
	308	if (signal_pending(current)) {
	309	err = sock_intr_errno(timeo);
	310	break;
	311	}
	312
	313	release_sock(sk);
	314	timeo = schedule_timeout(timeo);
	315	lock_sock(sk);
	316
c1cbe4b7 BL	317	err = sock_error(sk);
c1cbe4b7 BL	318	if (err)
1da177e4	319	break;
1da177e4 LT	320	}
	321	set_current_state(TASK_RUNNING);
	322	remove_wait_queue(sk->sk_sleep, &wait);
	323	return err;
	324	}
	325	EXPORT_SYMBOL(bt_sock_wait_state);
	326
	327	static struct net_proto_family bt_sock_family_ops = {
	328	.owner = THIS_MODULE,
	329	.family = PF_BLUETOOTH,
	330	.create = bt_sock_create,
	331	};
	332
1da177e4 LT	333	static int __init bt_init(void)
1da177e4 LT	334	{
27d35284 MH	335	int err;
27d35284 MH	336
1da177e4 LT	337	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	338
27d35284 MH	339	err = bt_sysfs_init();
	340	if (err < 0)
	341	return err;
1da177e4	342
27d35284 MH	343	err = sock_register(&bt_sock_family_ops);
	344	if (err < 0) {
	345	bt_sysfs_cleanup();
	346	return err;
	347	}
1da177e4	348
27d35284	349	BT_INFO("HCI device and connection manager initialized");
1da177e4 LT	350
	351	hci_sock_init();
	352
	353	return 0;
	354	}
	355
	356	static void __exit bt_exit(void)
	357	{
	358	hci_sock_cleanup();
	359
1da177e4	360	sock_unregister(PF_BLUETOOTH);
27d35284 MH	361
27d35284 MH	362	bt_sysfs_cleanup();
1da177e4 LT	363	}
	364
	365	subsys_initcall(bt_init);
	366	module_exit(bt_exit);
	367
	368	MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
	369	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	370	MODULE_VERSION(VERSION);
	371	MODULE_LICENSE("GPL");
	372	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);