[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / hci_sock.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 HCI sockets. */

#include <linux/module.h>

#include <linux/types.h>
#include <linux/capability.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/fcntl.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/workqueue.h>
#include <linux/interrupt.h>
#include <linux/compat.h>
#include <linux/socket.h>
#include <linux/ioctl.h>
#include <net/sock.h>

#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/unaligned.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>

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

/* ----- HCI socket interface ----- */

static inline int hci_test_bit(int nr, void *addr)
{
	return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
}

/* Security filter */
static struct hci_sec_filter hci_sec_filter = {
	/* Packet types */
	0x10,
	/* Events */
	{ 0x1000d9fe, 0x0000b00c },
	/* Commands */
	{
		{ 0x0 },
		/* OGF_LINK_CTL */
		{ 0xbe000006, 0x00000001, 0x00000000, 0x00 },
		/* OGF_LINK_POLICY */
		{ 0x00005200, 0x00000000, 0x00000000, 0x00 },
		/* OGF_HOST_CTL */
		{ 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
		/* OGF_INFO_PARAM */
		{ 0x000002be, 0x00000000, 0x00000000, 0x00 },
		/* OGF_STATUS_PARAM */
		{ 0x000000ea, 0x00000000, 0x00000000, 0x00 }
	}
};

static struct bt_sock_list hci_sk_list = {
	.lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
};

/* Send frame to RAW socket */
void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct sock *sk;
	struct hlist_node *node;

	BT_DBG("hdev %p len %d", hdev, skb->len);

	read_lock(&hci_sk_list.lock);
	sk_for_each(sk, node, &hci_sk_list.head) {
		struct hci_filter *flt;
		struct sk_buff *nskb;

		if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
			continue;

		/* Don't send frame to the socket it came from */
		if (skb->sk == sk)
			continue;

		/* Apply filter */
		flt = &hci_pi(sk)->filter;

		if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
				0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
			continue;

		if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
			register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);

			if (!hci_test_bit(evt, &flt->event_mask))
				continue;

			if (flt->opcode &&
			    ((evt == HCI_EV_CMD_COMPLETE &&
			      flt->opcode !=
			      get_unaligned((__le16 *)(skb->data + 3))) ||
			     (evt == HCI_EV_CMD_STATUS &&
			      flt->opcode !=
			      get_unaligned((__le16 *)(skb->data + 4)))))
				continue;
		}

		if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
			continue;

		/* Put type byte before the data */
		memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);

		if (sock_queue_rcv_skb(sk, nskb))
			kfree_skb(nskb);
	}
	read_unlock(&hci_sk_list.lock);
}

static int hci_sock_release(struct socket *sock)
{
	struct sock *sk = sock->sk;
	struct hci_dev *hdev;

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

	if (!sk)
		return 0;

	hdev = hci_pi(sk)->hdev;

	bt_sock_unlink(&hci_sk_list, sk);

	if (hdev) {
		atomic_dec(&hdev->promisc);
		hci_dev_put(hdev);
	}

	sock_orphan(sk);

	skb_queue_purge(&sk->sk_receive_queue);
	skb_queue_purge(&sk->sk_write_queue);

	sock_put(sk);
	return 0;
}

/* Ioctls that require bound socket */
static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
{
	struct hci_dev *hdev = hci_pi(sk)->hdev;

	if (!hdev)
		return -EBADFD;

	switch (cmd) {
	case HCISETRAW:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;

		if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
			return -EPERM;

		if (arg)
			set_bit(HCI_RAW, &hdev->flags);
		else
			clear_bit(HCI_RAW, &hdev->flags);

		return 0;

	case HCIGETCONNINFO:
		return hci_get_conn_info(hdev, (void __user *) arg);

	case HCIGETAUTHINFO:
		return hci_get_auth_info(hdev, (void __user *) arg);

	default:
		if (hdev->ioctl)
			return hdev->ioctl(hdev, cmd, arg);
		return -EINVAL;
	}
}

static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct sock *sk = sock->sk;
	void __user *argp = (void __user *) arg;
	int err;

	BT_DBG("cmd %x arg %lx", cmd, arg);

	switch (cmd) {
	case HCIGETDEVLIST:
		return hci_get_dev_list(argp);

	case HCIGETDEVINFO:
		return hci_get_dev_info(argp);

	case HCIGETCONNLIST:
		return hci_get_conn_list(argp);

	case HCIDEVUP:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_open(arg);

	case HCIDEVDOWN:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_close(arg);

	case HCIDEVRESET:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_reset(arg);

	case HCIDEVRESTAT:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_reset_stat(arg);

	case HCISETSCAN:
	case HCISETAUTH:
	case HCISETENCRYPT:
	case HCISETPTYPE:
	case HCISETLINKPOL:
	case HCISETLINKMODE:
	case HCISETACLMTU:
	case HCISETSCOMTU:
		if (!capable(CAP_NET_ADMIN))
			return -EACCES;
		return hci_dev_cmd(cmd, argp);

	case HCIINQUIRY:
		return hci_inquiry(argp);

	default:
		lock_sock(sk);
		err = hci_sock_bound_ioctl(sk, cmd, arg);
		release_sock(sk);
		return err;
	}
}

static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
{
	struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
	struct sock *sk = sock->sk;
	struct hci_dev *hdev = NULL;
	int err = 0;

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

	if (!haddr || haddr->hci_family != AF_BLUETOOTH)
		return -EINVAL;

	lock_sock(sk);

	if (hci_pi(sk)->hdev) {
		err = -EALREADY;
		goto done;
	}

	if (haddr->hci_dev != HCI_DEV_NONE) {
		if (!(hdev = hci_dev_get(haddr->hci_dev))) {
			err = -ENODEV;
			goto done;
		}

		atomic_inc(&hdev->promisc);
	}

	hci_pi(sk)->hdev = hdev;
	sk->sk_state = BT_BOUND;

done:
	release_sock(sk);
	return err;
}

static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
{
	struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
	struct sock *sk = sock->sk;
	struct hci_dev *hdev = hci_pi(sk)->hdev;

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

	if (!hdev)
		return -EBADFD;

	lock_sock(sk);

	*addr_len = sizeof(*haddr);
	haddr->hci_family = AF_BLUETOOTH;
	haddr->hci_dev    = hdev->id;

	release_sock(sk);
	return 0;
}

static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
{
	__u32 mask = hci_pi(sk)->cmsg_mask;

	if (mask & HCI_CMSG_DIR) {
		int incoming = bt_cb(skb)->incoming;
		put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
	}

	if (mask & HCI_CMSG_TSTAMP) {
		struct timeval tv;
		void *data;
		int len;

		skb_get_timestamp(skb, &tv);

		data = &tv;
		len = sizeof(tv);
#ifdef CONFIG_COMPAT
		if (msg->msg_flags & MSG_CMSG_COMPAT) {
			struct compat_timeval ctv;
			ctv.tv_sec = tv.tv_sec;
			ctv.tv_usec = tv.tv_usec;
			data = &ctv;
			len = sizeof(ctv);
		}
#endif

		put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
	}
}

static int hci_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;
	int copied, err;

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

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

	if (sk->sk_state == BT_CLOSED)
		return 0;

	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
		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);

	hci_sock_cmsg(sk, msg, skb);

	skb_free_datagram(sk, skb);

	return err ? : copied;
}

static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
			    struct msghdr *msg, size_t len)
{
	struct sock *sk = sock->sk;
	struct hci_dev *hdev;
	struct sk_buff *skb;
	int err;

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

	if (msg->msg_flags & MSG_OOB)
		return -EOPNOTSUPP;

	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
		return -EINVAL;

	if (len < 4 || len > HCI_MAX_FRAME_SIZE)
		return -EINVAL;

	lock_sock(sk);

	if (!(hdev = hci_pi(sk)->hdev)) {
		err = -EBADFD;
		goto done;
	}

	if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
		goto done;

	if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
		err = -EFAULT;
		goto drop;
	}

	bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
	skb_pull(skb, 1);
	skb->dev = (void *) hdev;

	if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
		u16 opcode = get_unaligned_le16(skb->data);
		u16 ogf = hci_opcode_ogf(opcode);
		u16 ocf = hci_opcode_ocf(opcode);

		if (((ogf > HCI_SFLT_MAX_OGF) ||
				!hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
					!capable(CAP_NET_RAW)) {
			err = -EPERM;
			goto drop;
		}

		if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) {
			skb_queue_tail(&hdev->raw_q, skb);
			hci_sched_tx(hdev);
		} else {
			skb_queue_tail(&hdev->cmd_q, skb);
			hci_sched_cmd(hdev);
		}
	} else {
		if (!capable(CAP_NET_RAW)) {
			err = -EPERM;
			goto drop;
		}

		skb_queue_tail(&hdev->raw_q, skb);
		hci_sched_tx(hdev);
	}

	err = len;

done:
	release_sock(sk);
	return err;

drop:
	kfree_skb(skb);
	goto done;
}

static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len)
{
	struct hci_ufilter uf = { .opcode = 0 };
	struct sock *sk = sock->sk;
	int err = 0, opt = 0;

	BT_DBG("sk %p, opt %d", sk, optname);

	lock_sock(sk);

	switch (optname) {
	case HCI_DATA_DIR:
		if (get_user(opt, (int __user *)optval)) {
			err = -EFAULT;
			break;
		}

		if (opt)
			hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
		else
			hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
		break;

	case HCI_TIME_STAMP:
		if (get_user(opt, (int __user *)optval)) {
			err = -EFAULT;
			break;
		}

		if (opt)
			hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
		else
			hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
		break;

	case HCI_FILTER:
		{
			struct hci_filter *f = &hci_pi(sk)->filter;

			uf.type_mask = f->type_mask;
			uf.opcode    = f->opcode;
			uf.event_mask[0] = *((u32 *) f->event_mask + 0);
			uf.event_mask[1] = *((u32 *) f->event_mask + 1);
		}

		len = min_t(unsigned int, len, sizeof(uf));
		if (copy_from_user(&uf, optval, len)) {
			err = -EFAULT;
			break;
		}

		if (!capable(CAP_NET_RAW)) {
			uf.type_mask &= hci_sec_filter.type_mask;
			uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
			uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
		}

		{
			struct hci_filter *f = &hci_pi(sk)->filter;

			f->type_mask = uf.type_mask;
			f->opcode    = uf.opcode;
			*((u32 *) f->event_mask + 0) = uf.event_mask[0];
			*((u32 *) f->event_mask + 1) = uf.event_mask[1];
		}
		break;

	default:
		err = -ENOPROTOOPT;
		break;
	}

	release_sock(sk);
	return err;
}

static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
{
	struct hci_ufilter uf;
	struct sock *sk = sock->sk;
	int len, opt;

	if (get_user(len, optlen))
		return -EFAULT;

	switch (optname) {
	case HCI_DATA_DIR:
		if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
			opt = 1;
		else
			opt = 0;

		if (put_user(opt, optval))
			return -EFAULT;
		break;

	case HCI_TIME_STAMP:
		if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
			opt = 1;
		else
			opt = 0;

		if (put_user(opt, optval))
			return -EFAULT;
		break;

	case HCI_FILTER:
		{
			struct hci_filter *f = &hci_pi(sk)->filter;

			uf.type_mask = f->type_mask;
			uf.opcode    = f->opcode;
			uf.event_mask[0] = *((u32 *) f->event_mask + 0);
			uf.event_mask[1] = *((u32 *) f->event_mask + 1);
		}

		len = min_t(unsigned int, len, sizeof(uf));
		if (copy_to_user(optval, &uf, len))
			return -EFAULT;
		break;

	default:
		return -ENOPROTOOPT;
		break;
	}

	return 0;
}

static const struct proto_ops hci_sock_ops = {
	.family		= PF_BLUETOOTH,
	.owner		= THIS_MODULE,
	.release	= hci_sock_release,
	.bind		= hci_sock_bind,
	.getname	= hci_sock_getname,
	.sendmsg	= hci_sock_sendmsg,
	.recvmsg	= hci_sock_recvmsg,
	.ioctl		= hci_sock_ioctl,
	.poll		= datagram_poll,
	.listen		= sock_no_listen,
	.shutdown	= sock_no_shutdown,
	.setsockopt	= hci_sock_setsockopt,
	.getsockopt	= hci_sock_getsockopt,
	.connect	= sock_no_connect,
	.socketpair	= sock_no_socketpair,
	.accept		= sock_no_accept,
	.mmap		= sock_no_mmap
};

static struct proto hci_sk_proto = {
	.name		= "HCI",
	.owner		= THIS_MODULE,
	.obj_size	= sizeof(struct hci_pinfo)
};

static int hci_sock_create(struct net *net, struct socket *sock, int protocol)
{
	struct sock *sk;

	BT_DBG("sock %p", sock);

	if (sock->type != SOCK_RAW)
		return -ESOCKTNOSUPPORT;

	sock->ops = &hci_sock_ops;

	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
	if (!sk)
		return -ENOMEM;

	sock_init_data(sock, sk);

	sock_reset_flag(sk, SOCK_ZAPPED);

	sk->sk_protocol = protocol;

	sock->state = SS_UNCONNECTED;
	sk->sk_state = BT_OPEN;

	bt_sock_link(&hci_sk_list, sk);
	return 0;
}

static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
{
	struct hci_dev *hdev = (struct hci_dev *) ptr;
	struct hci_ev_si_device ev;

	BT_DBG("hdev %s event %ld", hdev->name, event);

	/* Send event to sockets */
	ev.event  = event;
	ev.dev_id = hdev->id;
	hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);

	if (event == HCI_DEV_UNREG) {
		struct sock *sk;
		struct hlist_node *node;

		/* Detach sockets from device */
		read_lock(&hci_sk_list.lock);
		sk_for_each(sk, node, &hci_sk_list.head) {
			local_bh_disable();
			bh_lock_sock_nested(sk);
			if (hci_pi(sk)->hdev == hdev) {
				hci_pi(sk)->hdev = NULL;
				sk->sk_err = EPIPE;
				sk->sk_state = BT_OPEN;
				sk->sk_state_change(sk);

				hci_dev_put(hdev);
			}
			bh_unlock_sock(sk);
			local_bh_enable();
		}
		read_unlock(&hci_sk_list.lock);
	}

	return NOTIFY_DONE;
}

static struct net_proto_family hci_sock_family_ops = {
	.family	= PF_BLUETOOTH,
	.owner	= THIS_MODULE,
	.create	= hci_sock_create,
};

static struct notifier_block hci_sock_nblock = {
	.notifier_call = hci_sock_dev_event
};

int __init hci_sock_init(void)
{
	int err;

	err = proto_register(&hci_sk_proto, 0);
	if (err < 0)
		return err;

	err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
	if (err < 0)
		goto error;

	hci_register_notifier(&hci_sock_nblock);

	BT_INFO("HCI socket layer initialized");

	return 0;

error:
	BT_ERR("HCI socket registration failed");
	proto_unregister(&hci_sk_proto);
	return err;
}

void __exit hci_sock_cleanup(void)
{
	if (bt_sock_unregister(BTPROTO_HCI) < 0)
		BT_ERR("HCI socket unregistration failed");

	hci_unregister_notifier(&hci_sock_nblock);

	proto_unregister(&hci_sk_proto);
}
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 HCI sockets. */
	26
1da177e4 LT	27	#include <linux/module.h>
	28
	29	#include <linux/types.h>
4fc268d2	30	#include <linux/capability.h>
1da177e4 LT	31	#include <linux/errno.h>
1da177e4 LT	32	#include <linux/kernel.h>
1da177e4 LT	33	#include <linux/slab.h>
	34	#include <linux/poll.h>
	35	#include <linux/fcntl.h>
	36	#include <linux/init.h>
	37	#include <linux/skbuff.h>
	38	#include <linux/workqueue.h>
	39	#include <linux/interrupt.h>
767c5eb5	40	#include <linux/compat.h>
1da177e4 LT	41	#include <linux/socket.h>
	42	#include <linux/ioctl.h>
	43	#include <net/sock.h>
	44
	45	#include <asm/system.h>
	46	#include <asm/uaccess.h>
	47	#include <asm/unaligned.h>
	48
	49	#include <net/bluetooth/bluetooth.h>
	50	#include <net/bluetooth/hci_core.h>
	51
	52	#ifndef CONFIG_BT_HCI_SOCK_DEBUG
	53	#undef BT_DBG
	54	#define BT_DBG(D...)
	55	#endif
	56
	57	/* ----- HCI socket interface ----- */
	58
	59	static inline int hci_test_bit(int nr, void *addr)
	60	{
	61	return ((__u32 ) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
	62	}
	63
	64	/* Security filter */
	65	static struct hci_sec_filter hci_sec_filter = {
	66	/* Packet types */
	67	0x10,
	68	/* Events */
dd7f5527	69	{ 0x1000d9fe, 0x0000b00c },
1da177e4 LT	70	/* Commands */
	71	{
	72	{ 0x0 },
	73	/* OGF_LINK_CTL */
7c631a67	74	{ 0xbe000006, 0x00000001, 0x00000000, 0x00 },
1da177e4	75	/* OGF_LINK_POLICY */
7c631a67	76	{ 0x00005200, 0x00000000, 0x00000000, 0x00 },
1da177e4	77	/* OGF_HOST_CTL */
7c631a67	78	{ 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
1da177e4	79	/* OGF_INFO_PARAM */
7c631a67	80	{ 0x000002be, 0x00000000, 0x00000000, 0x00 },
1da177e4	81	/* OGF_STATUS_PARAM */
7c631a67	82	{ 0x000000ea, 0x00000000, 0x00000000, 0x00 }
1da177e4 LT	83	}
	84	};
	85
	86	static struct bt_sock_list hci_sk_list = {
d5fb2962	87	.lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
1da177e4 LT	88	};
	89
	90	/* Send frame to RAW socket */
	91	void hci_send_to_sock(struct hci_dev hdev, struct sk_buff skb)
	92	{
	93	struct sock *sk;
	94	struct hlist_node *node;
	95
	96	BT_DBG("hdev %p len %d", hdev, skb->len);
	97
	98	read_lock(&hci_sk_list.lock);
	99	sk_for_each(sk, node, &hci_sk_list.head) {
	100	struct hci_filter *flt;
	101	struct sk_buff *nskb;
	102
	103	if (sk->sk_state != BT_BOUND \|\| hci_pi(sk)->hdev != hdev)
	104	continue;
	105
	106	/* Don't send frame to the socket it came from */
	107	if (skb->sk == sk)
	108	continue;
	109
	110	/* Apply filter */
	111	flt = &hci_pi(sk)->filter;
	112
0d48d939 MH	113	if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
0d48d939 MH	114	0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
1da177e4 LT	115	continue;
1da177e4 LT	116
0d48d939	117	if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
1da177e4 LT	118	register int evt = ((__u8 )skb->data & HCI_FLT_EVENT_BITS);
	119
	120	if (!hci_test_bit(evt, &flt->event_mask))
	121	continue;
	122
4498c80d DM	123	if (flt->opcode &&
	124	((evt == HCI_EV_CMD_COMPLETE &&
	125	flt->opcode !=
905f3ed6	126	get_unaligned((__le16 *)(skb->data + 3))) \|\|
4498c80d DM	127	(evt == HCI_EV_CMD_STATUS &&
4498c80d DM	128	flt->opcode !=
905f3ed6	129	get_unaligned((__le16 *)(skb->data + 4)))))
1da177e4 LT	130	continue;
	131	}
	132
	133	if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
	134	continue;
	135
	136	/* Put type byte before the data */
0d48d939	137	memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);
1da177e4 LT	138
	139	if (sock_queue_rcv_skb(sk, nskb))
	140	kfree_skb(nskb);
	141	}
	142	read_unlock(&hci_sk_list.lock);
	143	}
	144
	145	static int hci_sock_release(struct socket *sock)
	146	{
	147	struct sock *sk = sock->sk;
7b005bd3	148	struct hci_dev *hdev;
1da177e4 LT	149
	150	BT_DBG("sock %p sk %p", sock, sk);
	151
	152	if (!sk)
	153	return 0;
	154
7b005bd3 MH	155	hdev = hci_pi(sk)->hdev;
7b005bd3 MH	156
1da177e4 LT	157	bt_sock_unlink(&hci_sk_list, sk);
	158
	159	if (hdev) {
	160	atomic_dec(&hdev->promisc);
	161	hci_dev_put(hdev);
	162	}
	163
	164	sock_orphan(sk);
	165
	166	skb_queue_purge(&sk->sk_receive_queue);
	167	skb_queue_purge(&sk->sk_write_queue);
	168
	169	sock_put(sk);
	170	return 0;
	171	}
	172
8e87d142	173	/* Ioctls that require bound socket */
1da177e4 LT	174	static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
	175	{
	176	struct hci_dev *hdev = hci_pi(sk)->hdev;
	177
	178	if (!hdev)
	179	return -EBADFD;
	180
	181	switch (cmd) {
	182	case HCISETRAW:
	183	if (!capable(CAP_NET_ADMIN))
	184	return -EACCES;
	185
	186	if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
	187	return -EPERM;
	188
	189	if (arg)
	190	set_bit(HCI_RAW, &hdev->flags);
	191	else
	192	clear_bit(HCI_RAW, &hdev->flags);
	193
	194	return 0;
	195
1da177e4	196	case HCIGETCONNINFO:
40be492f MH	197	return hci_get_conn_info(hdev, (void __user *) arg);
	198
	199	case HCIGETAUTHINFO:
	200	return hci_get_auth_info(hdev, (void __user *) arg);
1da177e4 LT	201
	202	default:
	203	if (hdev->ioctl)
	204	return hdev->ioctl(hdev, cmd, arg);
	205	return -EINVAL;
	206	}
	207	}
	208
	209	static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	210	{
	211	struct sock *sk = sock->sk;
40be492f	212	void __user argp = (void __user ) arg;
1da177e4 LT	213	int err;
	214
	215	BT_DBG("cmd %x arg %lx", cmd, arg);
	216
	217	switch (cmd) {
	218	case HCIGETDEVLIST:
	219	return hci_get_dev_list(argp);
	220
	221	case HCIGETDEVINFO:
	222	return hci_get_dev_info(argp);
	223
	224	case HCIGETCONNLIST:
	225	return hci_get_conn_list(argp);
	226
	227	case HCIDEVUP:
	228	if (!capable(CAP_NET_ADMIN))
	229	return -EACCES;
	230	return hci_dev_open(arg);
	231
	232	case HCIDEVDOWN:
	233	if (!capable(CAP_NET_ADMIN))
	234	return -EACCES;
	235	return hci_dev_close(arg);
	236
	237	case HCIDEVRESET:
	238	if (!capable(CAP_NET_ADMIN))
	239	return -EACCES;
	240	return hci_dev_reset(arg);
	241
	242	case HCIDEVRESTAT:
	243	if (!capable(CAP_NET_ADMIN))
	244	return -EACCES;
	245	return hci_dev_reset_stat(arg);
	246
	247	case HCISETSCAN:
	248	case HCISETAUTH:
	249	case HCISETENCRYPT:
	250	case HCISETPTYPE:
	251	case HCISETLINKPOL:
	252	case HCISETLINKMODE:
	253	case HCISETACLMTU:
	254	case HCISETSCOMTU:
	255	if (!capable(CAP_NET_ADMIN))
	256	return -EACCES;
	257	return hci_dev_cmd(cmd, argp);
	258
	259	case HCIINQUIRY:
	260	return hci_inquiry(argp);
	261
	262	default:
	263	lock_sock(sk);
	264	err = hci_sock_bound_ioctl(sk, cmd, arg);
	265	release_sock(sk);
	266	return err;
	267	}
	268	}
	269
	270	static int hci_sock_bind(struct socket sock, struct sockaddr addr, int addr_len)
	271	{
	272	struct sockaddr_hci haddr = (struct sockaddr_hci ) addr;
	273	struct sock *sk = sock->sk;
	274	struct hci_dev *hdev = NULL;
	275	int err = 0;
	276
277	BT_DBG("sock %p sk %p", sock, sk);
278
279	if (!haddr \|\| haddr->hci_family != AF_BLUETOOTH)
280	return -EINVAL;
281
282	lock_sock(sk);
283
284	if (hci_pi(sk)->hdev) {
285	err = -EALREADY;
286	goto done;
287	}
288
289	if (haddr->hci_dev != HCI_DEV_NONE) {
290	if (!(hdev = hci_dev_get(haddr->hci_dev))) {
291	err = -ENODEV;
292	goto done;
293	}
294
295	atomic_inc(&hdev->promisc);
296	}
297
298	hci_pi(sk)->hdev = hdev;
299	sk->sk_state = BT_BOUND;
300
301	done:
302	release_sock(sk);
303	return err;
304	}
305
306	static int hci_sock_getname(struct socket sock, struct sockaddr addr, int *addr_len, int peer)
307	{
308	struct sockaddr_hci haddr = (struct sockaddr_hci ) addr;
309	struct sock *sk = sock->sk;
7b005bd3	310	struct hci_dev *hdev = hci_pi(sk)->hdev;
1da177e4 LT	311
	312	BT_DBG("sock %p sk %p", sock, sk);
	313
7b005bd3 MH	314	if (!hdev)
	315	return -EBADFD;
	316
1da177e4 LT	317	lock_sock(sk);
	318
	319	addr_len = sizeof(haddr);
	320	haddr->hci_family = AF_BLUETOOTH;
7b005bd3	321	haddr->hci_dev = hdev->id;
1da177e4 LT	322
	323	release_sock(sk);
	324	return 0;
	325	}
	326
	327	static inline void hci_sock_cmsg(struct sock sk, struct msghdr msg, struct sk_buff *skb)
	328	{
	329	__u32 mask = hci_pi(sk)->cmsg_mask;
	330
0d48d939 MH	331	if (mask & HCI_CMSG_DIR) {
	332	int incoming = bt_cb(skb)->incoming;
	333	put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
	334	}
1da177e4	335
a61bbcf2 PM	336	if (mask & HCI_CMSG_TSTAMP) {
a61bbcf2 PM	337	struct timeval tv;
767c5eb5 MH	338	void *data;
767c5eb5 MH	339	int len;
a61bbcf2 PM	340
a61bbcf2 PM	341	skb_get_timestamp(skb, &tv);
767c5eb5	342
1da97f83 DM	343	data = &tv;
	344	len = sizeof(tv);
	345	#ifdef CONFIG_COMPAT
767c5eb5 MH	346	if (msg->msg_flags & MSG_CMSG_COMPAT) {
	347	struct compat_timeval ctv;
	348	ctv.tv_sec = tv.tv_sec;
	349	ctv.tv_usec = tv.tv_usec;
	350	data = &ctv;
	351	len = sizeof(ctv);
767c5eb5	352	}
1da97f83	353	#endif
767c5eb5 MH	354
767c5eb5 MH	355	put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
a61bbcf2	356	}
1da177e4	357	}
8e87d142 YH	358
8e87d142 YH	359	static int hci_sock_recvmsg(struct kiocb iocb, struct socket sock,
1da177e4 LT	360	struct msghdr *msg, size_t len, int flags)
	361	{
	362	int noblock = flags & MSG_DONTWAIT;
	363	struct sock *sk = sock->sk;
	364	struct sk_buff *skb;
	365	int copied, err;
	366
	367	BT_DBG("sock %p, sk %p", sock, sk);
	368
	369	if (flags & (MSG_OOB))
	370	return -EOPNOTSUPP;
	371
	372	if (sk->sk_state == BT_CLOSED)
	373	return 0;
	374
	375	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
	376	return err;
	377
	378	msg->msg_namelen = 0;
	379
	380	copied = skb->len;
	381	if (len < copied) {
	382	msg->msg_flags \|= MSG_TRUNC;
	383	copied = len;
	384	}
	385
badff6d0	386	skb_reset_transport_header(skb);
1da177e4 LT	387	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	388
	389	hci_sock_cmsg(sk, msg, skb);
	390
	391	skb_free_datagram(sk, skb);
	392
	393	return err ? : copied;
	394	}
	395
8e87d142	396	static int hci_sock_sendmsg(struct kiocb iocb, struct socket sock,
1da177e4 LT	397	struct msghdr *msg, size_t len)
	398	{
	399	struct sock *sk = sock->sk;
	400	struct hci_dev *hdev;
	401	struct sk_buff *skb;
	402	int err;
	403
	404	BT_DBG("sock %p sk %p", sock, sk);
	405
	406	if (msg->msg_flags & MSG_OOB)
	407	return -EOPNOTSUPP;
	408
	409	if (msg->msg_flags & ~(MSG_DONTWAIT\|MSG_NOSIGNAL\|MSG_ERRQUEUE))
	410	return -EINVAL;
	411
	412	if (len < 4 \|\| len > HCI_MAX_FRAME_SIZE)
	413	return -EINVAL;
	414
	415	lock_sock(sk);
	416
	417	if (!(hdev = hci_pi(sk)->hdev)) {
	418	err = -EBADFD;
	419	goto done;
	420	}
	421
	422	if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
	423	goto done;
	424
	425	if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
	426	err = -EFAULT;
	427	goto drop;
	428	}
	429
0d48d939	430	bt_cb(skb)->pkt_type = ((unsigned char ) skb->data);
1da177e4 LT	431	skb_pull(skb, 1);
	432	skb->dev = (void *) hdev;
	433
0d48d939	434	if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
83985319	435	u16 opcode = get_unaligned_le16(skb->data);
1da177e4 LT	436	u16 ogf = hci_opcode_ogf(opcode);
	437	u16 ocf = hci_opcode_ocf(opcode);
	438
	439	if (((ogf > HCI_SFLT_MAX_OGF) \|\|
	440	!hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
	441	!capable(CAP_NET_RAW)) {
	442	err = -EPERM;
	443	goto drop;
	444	}
	445
a9de9248	446	if (test_bit(HCI_RAW, &hdev->flags) \|\| (ogf == 0x3f)) {
1da177e4 LT	447	skb_queue_tail(&hdev->raw_q, skb);
	448	hci_sched_tx(hdev);
	449	} else {
	450	skb_queue_tail(&hdev->cmd_q, skb);
	451	hci_sched_cmd(hdev);
	452	}
	453	} else {
	454	if (!capable(CAP_NET_RAW)) {
	455	err = -EPERM;
	456	goto drop;
	457	}
	458
	459	skb_queue_tail(&hdev->raw_q, skb);
	460	hci_sched_tx(hdev);
	461	}
	462
	463	err = len;
	464
	465	done:
	466	release_sock(sk);
	467	return err;
	468
	469	drop:
	470	kfree_skb(skb);
	471	goto done;
	472	}
	473
	474	static int hci_sock_setsockopt(struct socket sock, int level, int optname, char __user optval, int len)
	475	{
	476	struct hci_ufilter uf = { .opcode = 0 };
	477	struct sock *sk = sock->sk;
	478	int err = 0, opt = 0;
	479
	480	BT_DBG("sk %p, opt %d", sk, optname);
	481
	482	lock_sock(sk);
	483
	484	switch (optname) {
	485	case HCI_DATA_DIR:
	486	if (get_user(opt, (int __user *)optval)) {
	487	err = -EFAULT;
	488	break;
	489	}
	490
	491	if (opt)
	492	hci_pi(sk)->cmsg_mask \|= HCI_CMSG_DIR;
	493	else
	494	hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
	495	break;
	496
	497	case HCI_TIME_STAMP:
	498	if (get_user(opt, (int __user *)optval)) {
	499	err = -EFAULT;
	500	break;
	501	}
	502
	503	if (opt)
	504	hci_pi(sk)->cmsg_mask \|= HCI_CMSG_TSTAMP;
	505	else
	506	hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
	507	break;
	508
	509	case HCI_FILTER:
0878b666 MH	510	{
	511	struct hci_filter *f = &hci_pi(sk)->filter;
	512
	513	uf.type_mask = f->type_mask;
	514	uf.opcode = f->opcode;
	515	uf.event_mask[0] = ((u32 ) f->event_mask + 0);
	516	uf.event_mask[1] = ((u32 ) f->event_mask + 1);
	517	}
	518
1da177e4 LT	519	len = min_t(unsigned int, len, sizeof(uf));
	520	if (copy_from_user(&uf, optval, len)) {
	521	err = -EFAULT;
	522	break;
	523	}
	524
	525	if (!capable(CAP_NET_RAW)) {
	526	uf.type_mask &= hci_sec_filter.type_mask;
	527	uf.event_mask[0] &= ((u32 ) hci_sec_filter.event_mask + 0);
	528	uf.event_mask[1] &= ((u32 ) hci_sec_filter.event_mask + 1);
	529	}
	530
	531	{
	532	struct hci_filter *f = &hci_pi(sk)->filter;
	533
	534	f->type_mask = uf.type_mask;
	535	f->opcode = uf.opcode;
	536	((u32 ) f->event_mask + 0) = uf.event_mask[0];
	537	((u32 ) f->event_mask + 1) = uf.event_mask[1];
	538	}
8e87d142	539	break;
1da177e4 LT	540
	541	default:
	542	err = -ENOPROTOOPT;
	543	break;
	544	}
	545
	546	release_sock(sk);
	547	return err;
	548	}
	549
	550	static int hci_sock_getsockopt(struct socket sock, int level, int optname, char __user optval, int __user *optlen)
	551	{
	552	struct hci_ufilter uf;
	553	struct sock *sk = sock->sk;
8e87d142	554	int len, opt;
1da177e4 LT	555
	556	if (get_user(len, optlen))
	557	return -EFAULT;
	558
	559	switch (optname) {
	560	case HCI_DATA_DIR:
	561	if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
	562	opt = 1;
8e87d142	563	else
1da177e4 LT	564	opt = 0;
	565
	566	if (put_user(opt, optval))
	567	return -EFAULT;
	568	break;
	569
	570	case HCI_TIME_STAMP:
	571	if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
	572	opt = 1;
8e87d142	573	else
1da177e4 LT	574	opt = 0;
	575
	576	if (put_user(opt, optval))
	577	return -EFAULT;
	578	break;
	579
	580	case HCI_FILTER:
	581	{
	582	struct hci_filter *f = &hci_pi(sk)->filter;
	583
	584	uf.type_mask = f->type_mask;
	585	uf.opcode = f->opcode;
	586	uf.event_mask[0] = ((u32 ) f->event_mask + 0);
	587	uf.event_mask[1] = ((u32 ) f->event_mask + 1);
	588	}
	589
	590	len = min_t(unsigned int, len, sizeof(uf));
	591	if (copy_to_user(optval, &uf, len))
	592	return -EFAULT;
	593	break;
	594
	595	default:
	596	return -ENOPROTOOPT;
	597	break;
	598	}
	599
	600	return 0;
	601	}
	602
90ddc4f0	603	static const struct proto_ops hci_sock_ops = {
1da177e4 LT	604	.family = PF_BLUETOOTH,
	605	.owner = THIS_MODULE,
	606	.release = hci_sock_release,
	607	.bind = hci_sock_bind,
	608	.getname = hci_sock_getname,
	609	.sendmsg = hci_sock_sendmsg,
	610	.recvmsg = hci_sock_recvmsg,
	611	.ioctl = hci_sock_ioctl,
	612	.poll = datagram_poll,
	613	.listen = sock_no_listen,
	614	.shutdown = sock_no_shutdown,
	615	.setsockopt = hci_sock_setsockopt,
	616	.getsockopt = hci_sock_getsockopt,
	617	.connect = sock_no_connect,
	618	.socketpair = sock_no_socketpair,
	619	.accept = sock_no_accept,
	620	.mmap = sock_no_mmap
	621	};
	622
	623	static struct proto hci_sk_proto = {
	624	.name = "HCI",
	625	.owner = THIS_MODULE,
	626	.obj_size = sizeof(struct hci_pinfo)
	627	};
	628
1b8d7ae4	629	static int hci_sock_create(struct net net, struct socket sock, int protocol)
1da177e4 LT	630	{
	631	struct sock *sk;
	632
	633	BT_DBG("sock %p", sock);
	634
	635	if (sock->type != SOCK_RAW)
	636	return -ESOCKTNOSUPPORT;
	637
	638	sock->ops = &hci_sock_ops;
	639
6257ff21	640	sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
1da177e4 LT	641	if (!sk)
	642	return -ENOMEM;
	643
	644	sock_init_data(sock, sk);
	645
	646	sock_reset_flag(sk, SOCK_ZAPPED);
	647
	648	sk->sk_protocol = protocol;
	649
	650	sock->state = SS_UNCONNECTED;
	651	sk->sk_state = BT_OPEN;
	652
	653	bt_sock_link(&hci_sk_list, sk);
	654	return 0;
	655	}
	656
	657	static int hci_sock_dev_event(struct notifier_block this, unsigned long event, void ptr)
	658	{
	659	struct hci_dev hdev = (struct hci_dev ) ptr;
	660	struct hci_ev_si_device ev;
	661
	662	BT_DBG("hdev %s event %ld", hdev->name, event);
	663
	664	/* Send event to sockets */
	665	ev.event = event;
	666	ev.dev_id = hdev->id;
	667	hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
	668
	669	if (event == HCI_DEV_UNREG) {
	670	struct sock *sk;
	671	struct hlist_node *node;
	672
	673	/* Detach sockets from device */
	674	read_lock(&hci_sk_list.lock);
	675	sk_for_each(sk, node, &hci_sk_list.head) {
4ce61d1c SS	676	local_bh_disable();
4ce61d1c SS	677	bh_lock_sock_nested(sk);
1da177e4 LT	678	if (hci_pi(sk)->hdev == hdev) {
	679	hci_pi(sk)->hdev = NULL;
	680	sk->sk_err = EPIPE;
	681	sk->sk_state = BT_OPEN;
	682	sk->sk_state_change(sk);
	683
	684	hci_dev_put(hdev);
	685	}
4ce61d1c SS	686	bh_unlock_sock(sk);
4ce61d1c SS	687	local_bh_enable();
1da177e4 LT	688	}
	689	read_unlock(&hci_sk_list.lock);
	690	}
	691
	692	return NOTIFY_DONE;
	693	}
	694
	695	static struct net_proto_family hci_sock_family_ops = {
	696	.family = PF_BLUETOOTH,
	697	.owner = THIS_MODULE,
	698	.create = hci_sock_create,
	699	};
	700
	701	static struct notifier_block hci_sock_nblock = {
	702	.notifier_call = hci_sock_dev_event
	703	};
	704
	705	int __init hci_sock_init(void)
	706	{
	707	int err;
	708
	709	err = proto_register(&hci_sk_proto, 0);
	710	if (err < 0)
	711	return err;
	712
	713	err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
	714	if (err < 0)
	715	goto error;
	716
	717	hci_register_notifier(&hci_sock_nblock);
	718
	719	BT_INFO("HCI socket layer initialized");
	720
	721	return 0;
	722
	723	error:
	724	BT_ERR("HCI socket registration failed");
	725	proto_unregister(&hci_sk_proto);
	726	return err;
	727	}
	728
04005dd9	729	void __exit hci_sock_cleanup(void)
1da177e4 LT	730	{
	731	if (bt_sock_unregister(BTPROTO_HCI) < 0)
	732	BT_ERR("HCI socket unregistration failed");
	733
	734	hci_unregister_notifier(&hci_sock_nblock);
	735
	736	proto_unregister(&hci_sk_proto);
1da177e4	737	}