[linux-block.git] / drivers / bluetooth / hci_vhci.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 *  Bluetooth virtual HCI driver
 *
 *  Copyright (C) 2000-2001  Qualcomm Incorporated
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
 *  Copyright (C) 2004-2006  Marcel Holtmann <marcel@holtmann.org>
 */

#include <linux/module.h>
#include <asm/unaligned.h>

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/poll.h>

#include <linux/skbuff.h>
#include <linux/miscdevice.h>
#include <linux/debugfs.h>

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

#define VERSION "1.5"

static bool amp;

struct vhci_data {
	struct hci_dev *hdev;

	wait_queue_head_t read_wait;
	struct sk_buff_head readq;

	struct mutex open_mutex;
	struct delayed_work open_timeout;
	struct work_struct suspend_work;

	bool suspended;
	bool wakeup;
	__u16 msft_opcode;
	bool aosp_capable;
};

static int vhci_open_dev(struct hci_dev *hdev)
{
	return 0;
}

static int vhci_close_dev(struct hci_dev *hdev)
{
	struct vhci_data *data = hci_get_drvdata(hdev);

	skb_queue_purge(&data->readq);

	return 0;
}

static int vhci_flush(struct hci_dev *hdev)
{
	struct vhci_data *data = hci_get_drvdata(hdev);

	skb_queue_purge(&data->readq);

	return 0;
}

static int vhci_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
	struct vhci_data *data = hci_get_drvdata(hdev);

	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
	skb_queue_tail(&data->readq, skb);

	wake_up_interruptible(&data->read_wait);
	return 0;
}

static int vhci_get_data_path_id(struct hci_dev *hdev, u8 *data_path_id)
{
	*data_path_id = 0;
	return 0;
}

static int vhci_get_codec_config_data(struct hci_dev *hdev, __u8 type,
				      struct bt_codec *codec, __u8 *vnd_len,
				      __u8 **vnd_data)
{
	if (type != ESCO_LINK)
		return -EINVAL;

	*vnd_len = 0;
	*vnd_data = NULL;
	return 0;
}

static bool vhci_wakeup(struct hci_dev *hdev)
{
	struct vhci_data *data = hci_get_drvdata(hdev);

	return data->wakeup;
}

static ssize_t force_suspend_read(struct file *file, char __user *user_buf,
				  size_t count, loff_t *ppos)
{
	struct vhci_data *data = file->private_data;
	char buf[3];

	buf[0] = data->suspended ? 'Y' : 'N';
	buf[1] = '\n';
	buf[2] = '\0';
	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
}

static void vhci_suspend_work(struct work_struct *work)
{
	struct vhci_data *data = container_of(work, struct vhci_data,
					      suspend_work);

	if (data->suspended)
		hci_suspend_dev(data->hdev);
	else
		hci_resume_dev(data->hdev);
}

static ssize_t force_suspend_write(struct file *file,
				   const char __user *user_buf,
				   size_t count, loff_t *ppos)
{
	struct vhci_data *data = file->private_data;
	bool enable;
	int err;

	err = kstrtobool_from_user(user_buf, count, &enable);
	if (err)
		return err;

	if (data->suspended == enable)
		return -EALREADY;

	data->suspended = enable;

	schedule_work(&data->suspend_work);

	return count;
}

static const struct file_operations force_suspend_fops = {
	.open		= simple_open,
	.read		= force_suspend_read,
	.write		= force_suspend_write,
	.llseek		= default_llseek,
};

static ssize_t force_wakeup_read(struct file *file, char __user *user_buf,
				 size_t count, loff_t *ppos)
{
	struct vhci_data *data = file->private_data;
	char buf[3];

	buf[0] = data->wakeup ? 'Y' : 'N';
	buf[1] = '\n';
	buf[2] = '\0';
	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
}

static ssize_t force_wakeup_write(struct file *file,
				  const char __user *user_buf, size_t count,
				  loff_t *ppos)
{
	struct vhci_data *data = file->private_data;
	bool enable;
	int err;

	err = kstrtobool_from_user(user_buf, count, &enable);
	if (err)
		return err;

	if (data->wakeup == enable)
		return -EALREADY;

	data->wakeup = enable;

	return count;
}

static const struct file_operations force_wakeup_fops = {
	.open		= simple_open,
	.read		= force_wakeup_read,
	.write		= force_wakeup_write,
	.llseek		= default_llseek,
};

static int msft_opcode_set(void *data, u64 val)
{
	struct vhci_data *vhci = data;

	if (val > 0xffff || hci_opcode_ogf(val) != 0x3f)
		return -EINVAL;

	if (vhci->msft_opcode)
		return -EALREADY;

	vhci->msft_opcode = val;

	return 0;
}

static int msft_opcode_get(void *data, u64 *val)
{
	struct vhci_data *vhci = data;

	*val = vhci->msft_opcode;

	return 0;
}

DEFINE_DEBUGFS_ATTRIBUTE(msft_opcode_fops, msft_opcode_get, msft_opcode_set,
			 "%llu\n");

static ssize_t aosp_capable_read(struct file *file, char __user *user_buf,
				 size_t count, loff_t *ppos)
{
	struct vhci_data *vhci = file->private_data;
	char buf[3];

	buf[0] = vhci->aosp_capable ? 'Y' : 'N';
	buf[1] = '\n';
	buf[2] = '\0';
	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
}

static ssize_t aosp_capable_write(struct file *file,
				  const char __user *user_buf, size_t count,
				  loff_t *ppos)
{
	struct vhci_data *vhci = file->private_data;
	bool enable;
	int err;

	err = kstrtobool_from_user(user_buf, count, &enable);
	if (err)
		return err;

	if (!enable)
		return -EINVAL;

	if (vhci->aosp_capable)
		return -EALREADY;

	vhci->aosp_capable = enable;

	return count;
}

static const struct file_operations aosp_capable_fops = {
	.open		= simple_open,
	.read		= aosp_capable_read,
	.write		= aosp_capable_write,
	.llseek		= default_llseek,
};

static int vhci_setup(struct hci_dev *hdev)
{
	struct vhci_data *vhci = hci_get_drvdata(hdev);

	if (vhci->msft_opcode)
		hci_set_msft_opcode(hdev, vhci->msft_opcode);

	if (vhci->aosp_capable)
		hci_set_aosp_capable(hdev);

	return 0;
}

static void vhci_coredump(struct hci_dev *hdev)
{
	/* No need to do anything */
}

static void vhci_coredump_hdr(struct hci_dev *hdev, struct sk_buff *skb)
{
	char buf[80];

	snprintf(buf, sizeof(buf), "Controller Name: vhci_ctrl\n");
	skb_put_data(skb, buf, strlen(buf));

	snprintf(buf, sizeof(buf), "Firmware Version: vhci_fw\n");
	skb_put_data(skb, buf, strlen(buf));

	snprintf(buf, sizeof(buf), "Driver: vhci_drv\n");
	skb_put_data(skb, buf, strlen(buf));

	snprintf(buf, sizeof(buf), "Vendor: vhci\n");
	skb_put_data(skb, buf, strlen(buf));
}

#define MAX_COREDUMP_LINE_LEN	40

struct devcoredump_test_data {
	enum devcoredump_state state;
	unsigned int timeout;
	char data[MAX_COREDUMP_LINE_LEN];
};

static inline void force_devcd_timeout(struct hci_dev *hdev,
				       unsigned int timeout)
{
#ifdef CONFIG_DEV_COREDUMP
	hdev->dump.timeout = msecs_to_jiffies(timeout * 1000);
#endif
}

static ssize_t force_devcd_write(struct file *file, const char __user *user_buf,
				 size_t count, loff_t *ppos)
{
	struct vhci_data *data = file->private_data;
	struct hci_dev *hdev = data->hdev;
	struct sk_buff *skb = NULL;
	struct devcoredump_test_data dump_data;
	size_t data_size;
	int ret;

	if (count < offsetof(struct devcoredump_test_data, data) ||
	    count > sizeof(dump_data))
		return -EINVAL;

	if (copy_from_user(&dump_data, user_buf, count))
		return -EFAULT;

	data_size = count - offsetof(struct devcoredump_test_data, data);
	skb = alloc_skb(data_size, GFP_ATOMIC);
	if (!skb)
		return -ENOMEM;
	skb_put_data(skb, &dump_data.data, data_size);

	hci_devcd_register(hdev, vhci_coredump, vhci_coredump_hdr, NULL);

	/* Force the devcoredump timeout */
	if (dump_data.timeout)
		force_devcd_timeout(hdev, dump_data.timeout);

	ret = hci_devcd_init(hdev, skb->len);
	if (ret) {
		BT_ERR("Failed to generate devcoredump");
		kfree_skb(skb);
		return ret;
	}

	hci_devcd_append(hdev, skb);

	switch (dump_data.state) {
	case HCI_DEVCOREDUMP_DONE:
		hci_devcd_complete(hdev);
		break;
	case HCI_DEVCOREDUMP_ABORT:
		hci_devcd_abort(hdev);
		break;
	case HCI_DEVCOREDUMP_TIMEOUT:
		/* Do nothing */
		break;
	default:
		return -EINVAL;
	}

	return count;
}

static const struct file_operations force_devcoredump_fops = {
	.open		= simple_open,
	.write		= force_devcd_write,
};

static int __vhci_create_device(struct vhci_data *data, __u8 opcode)
{
	struct hci_dev *hdev;
	struct sk_buff *skb;
	__u8 dev_type;

	if (data->hdev)
		return -EBADFD;

	/* bits 0-1 are dev_type (Primary or AMP) */
	dev_type = opcode & 0x03;

	if (dev_type != HCI_PRIMARY && dev_type != HCI_AMP)
		return -EINVAL;

	/* bits 2-5 are reserved (must be zero) */
	if (opcode & 0x3c)
		return -EINVAL;

	skb = bt_skb_alloc(4, GFP_KERNEL);
	if (!skb)
		return -ENOMEM;

	hdev = hci_alloc_dev();
	if (!hdev) {
		kfree_skb(skb);
		return -ENOMEM;
	}

	data->hdev = hdev;

	hdev->bus = HCI_VIRTUAL;
	hdev->dev_type = dev_type;
	hci_set_drvdata(hdev, data);

	hdev->open  = vhci_open_dev;
	hdev->close = vhci_close_dev;
	hdev->flush = vhci_flush;
	hdev->send  = vhci_send_frame;
	hdev->get_data_path_id = vhci_get_data_path_id;
	hdev->get_codec_config_data = vhci_get_codec_config_data;
	hdev->wakeup = vhci_wakeup;
	hdev->setup = vhci_setup;
	set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);

	/* bit 6 is for external configuration */
	if (opcode & 0x40)
		set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);

	/* bit 7 is for raw device */
	if (opcode & 0x80)
		set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);

	set_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks);

	if (hci_register_dev(hdev) < 0) {
		BT_ERR("Can't register HCI device");
		hci_free_dev(hdev);
		data->hdev = NULL;
		kfree_skb(skb);
		return -EBUSY;
	}

	debugfs_create_file("force_suspend", 0644, hdev->debugfs, data,
			    &force_suspend_fops);

	debugfs_create_file("force_wakeup", 0644, hdev->debugfs, data,
			    &force_wakeup_fops);

	if (IS_ENABLED(CONFIG_BT_MSFTEXT))
		debugfs_create_file("msft_opcode", 0644, hdev->debugfs, data,
				    &msft_opcode_fops);

	if (IS_ENABLED(CONFIG_BT_AOSPEXT))
		debugfs_create_file("aosp_capable", 0644, hdev->debugfs, data,
				    &aosp_capable_fops);

	debugfs_create_file("force_devcoredump", 0644, hdev->debugfs, data,
			    &force_devcoredump_fops);

	hci_skb_pkt_type(skb) = HCI_VENDOR_PKT;

	skb_put_u8(skb, 0xff);
	skb_put_u8(skb, opcode);
	put_unaligned_le16(hdev->id, skb_put(skb, 2));
	skb_queue_tail(&data->readq, skb);

	wake_up_interruptible(&data->read_wait);
	return 0;
}

static int vhci_create_device(struct vhci_data *data, __u8 opcode)
{
	int err;

	mutex_lock(&data->open_mutex);
	err = __vhci_create_device(data, opcode);
	mutex_unlock(&data->open_mutex);

	return err;
}

static inline ssize_t vhci_get_user(struct vhci_data *data,
				    struct iov_iter *from)
{
	size_t len = iov_iter_count(from);
	struct sk_buff *skb;
	__u8 pkt_type, opcode;
	int ret;

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

	skb = bt_skb_alloc(len, GFP_KERNEL);
	if (!skb)
		return -ENOMEM;

	if (!copy_from_iter_full(skb_put(skb, len), len, from)) {
		kfree_skb(skb);
		return -EFAULT;
	}

	pkt_type = *((__u8 *) skb->data);
	skb_pull(skb, 1);

	switch (pkt_type) {
	case HCI_EVENT_PKT:
	case HCI_ACLDATA_PKT:
	case HCI_SCODATA_PKT:
	case HCI_ISODATA_PKT:
		if (!data->hdev) {
			kfree_skb(skb);
			return -ENODEV;
		}

		hci_skb_pkt_type(skb) = pkt_type;

		ret = hci_recv_frame(data->hdev, skb);
		break;

	case HCI_VENDOR_PKT:
		cancel_delayed_work_sync(&data->open_timeout);

		opcode = *((__u8 *) skb->data);
		skb_pull(skb, 1);

		if (skb->len > 0) {
			kfree_skb(skb);
			return -EINVAL;
		}

		kfree_skb(skb);

		ret = vhci_create_device(data, opcode);
		break;

	default:
		kfree_skb(skb);
		return -EINVAL;
	}

	return (ret < 0) ? ret : len;
}

static inline ssize_t vhci_put_user(struct vhci_data *data,
				    struct sk_buff *skb,
				    char __user *buf, int count)
{
	char __user *ptr = buf;
	int len;

	len = min_t(unsigned int, skb->len, count);

	if (copy_to_user(ptr, skb->data, len))
		return -EFAULT;

	if (!data->hdev)
		return len;

	data->hdev->stat.byte_tx += len;

	switch (hci_skb_pkt_type(skb)) {
	case HCI_COMMAND_PKT:
		data->hdev->stat.cmd_tx++;
		break;
	case HCI_ACLDATA_PKT:
		data->hdev->stat.acl_tx++;
		break;
	case HCI_SCODATA_PKT:
		data->hdev->stat.sco_tx++;
		break;
	}

	return len;
}

static ssize_t vhci_read(struct file *file,
			 char __user *buf, size_t count, loff_t *pos)
{
	struct vhci_data *data = file->private_data;
	struct sk_buff *skb;
	ssize_t ret = 0;

	while (count) {
		skb = skb_dequeue(&data->readq);
		if (skb) {
			ret = vhci_put_user(data, skb, buf, count);
			if (ret < 0)
				skb_queue_head(&data->readq, skb);
			else
				kfree_skb(skb);
			break;
		}

		if (file->f_flags & O_NONBLOCK) {
			ret = -EAGAIN;
			break;
		}

		ret = wait_event_interruptible(data->read_wait,
					       !skb_queue_empty(&data->readq));
		if (ret < 0)
			break;
	}

	return ret;
}

static ssize_t vhci_write(struct kiocb *iocb, struct iov_iter *from)
{
	struct file *file = iocb->ki_filp;
	struct vhci_data *data = file->private_data;

	return vhci_get_user(data, from);
}

static __poll_t vhci_poll(struct file *file, poll_table *wait)
{
	struct vhci_data *data = file->private_data;

	poll_wait(file, &data->read_wait, wait);

	if (!skb_queue_empty(&data->readq))
		return EPOLLIN | EPOLLRDNORM;

	return EPOLLOUT | EPOLLWRNORM;
}

static void vhci_open_timeout(struct work_struct *work)
{
	struct vhci_data *data = container_of(work, struct vhci_data,
					      open_timeout.work);

	vhci_create_device(data, amp ? HCI_AMP : HCI_PRIMARY);
}

static int vhci_open(struct inode *inode, struct file *file)
{
	struct vhci_data *data;

	data = kzalloc(sizeof(struct vhci_data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	skb_queue_head_init(&data->readq);
	init_waitqueue_head(&data->read_wait);

	mutex_init(&data->open_mutex);
	INIT_DELAYED_WORK(&data->open_timeout, vhci_open_timeout);
	INIT_WORK(&data->suspend_work, vhci_suspend_work);

	file->private_data = data;
	nonseekable_open(inode, file);

	schedule_delayed_work(&data->open_timeout, msecs_to_jiffies(1000));

	return 0;
}

static int vhci_release(struct inode *inode, struct file *file)
{
	struct vhci_data *data = file->private_data;
	struct hci_dev *hdev;

	cancel_delayed_work_sync(&data->open_timeout);
	flush_work(&data->suspend_work);

	hdev = data->hdev;

	if (hdev) {
		hci_unregister_dev(hdev);
		hci_free_dev(hdev);
	}

	skb_queue_purge(&data->readq);
	file->private_data = NULL;
	kfree(data);

	return 0;
}

static const struct file_operations vhci_fops = {
	.owner		= THIS_MODULE,
	.read		= vhci_read,
	.write_iter	= vhci_write,
	.poll		= vhci_poll,
	.open		= vhci_open,
	.release	= vhci_release,
	.llseek		= no_llseek,
};

static struct miscdevice vhci_miscdev = {
	.name	= "vhci",
	.fops	= &vhci_fops,
	.minor	= VHCI_MINOR,
};
module_misc_device(vhci_miscdev);

module_param(amp, bool, 0644);
MODULE_PARM_DESC(amp, "Create AMP controller device");

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth virtual HCI driver ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS("devname:vhci");
MODULE_ALIAS_MISCDEV(VHCI_MINOR);
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4	2	/*
1da177e4	3	*
4aa769b9 MH	4	* Bluetooth virtual HCI driver
4aa769b9 MH	5	*
9c724357 MH	6	* Copyright (C) 2000-2001 Qualcomm Incorporated
	7	* Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
	8	* Copyright (C) 2004-2006 Marcel Holtmann <marcel@holtmann.org>
1da177e4	9	*/
1da177e4	10
1da177e4	11	#include <linux/module.h>
23424c0d	12	#include <asm/unaligned.h>
1da177e4	13
1da177e4	14	#include <linux/kernel.h>
4aa769b9	15	#include <linux/init.h>
1da177e4	16	#include <linux/slab.h>
4aa769b9 MH	17	#include <linux/types.h>
	18	#include <linux/errno.h>
	19	#include <linux/sched.h>
1da177e4	20	#include <linux/poll.h>
1da177e4 LT	21
	22	#include <linux/skbuff.h>
	23	#include <linux/miscdevice.h>
59c218ca	24	#include <linux/debugfs.h>
1da177e4	25
1da177e4 LT	26	#include <net/bluetooth/bluetooth.h>
1da177e4 LT	27	#include <net/bluetooth/hci_core.h>
1da177e4	28
82a30cfc	29	#define VERSION "1.5"
4aa769b9	30
36acbb1a AE	31	static bool amp;
36acbb1a AE	32
4aa769b9 MH	33	struct vhci_data {
	34	struct hci_dev *hdev;
	35
4aa769b9 MH	36	wait_queue_head_t read_wait;
4aa769b9 MH	37	struct sk_buff_head readq;
23424c0d	38
c7c999cb	39	struct mutex open_mutex;
23424c0d	40	struct delayed_work open_timeout;
d16e6d19	41	struct work_struct suspend_work;
59c218ca LAD	42
59c218ca LAD	43	bool suspended;
4539ca67	44	bool wakeup;
b8f5482c LAD	45	__u16 msft_opcode;
b8f5482c LAD	46	bool aosp_capable;
4aa769b9 MH	47	};
4aa769b9 MH	48
4aa769b9	49	static int vhci_open_dev(struct hci_dev *hdev)
1da177e4	50	{
1da177e4 LT	51	return 0;
	52	}
	53
4aa769b9	54	static int vhci_close_dev(struct hci_dev *hdev)
1da177e4	55	{
155961e8	56	struct vhci_data *data = hci_get_drvdata(hdev);
4aa769b9	57
9c724357	58	skb_queue_purge(&data->readq);
4aa769b9	59
1da177e4 LT	60	return 0;
	61	}
	62
4aa769b9	63	static int vhci_flush(struct hci_dev *hdev)
1da177e4	64	{
155961e8	65	struct vhci_data *data = hci_get_drvdata(hdev);
1da177e4	66
9c724357	67	skb_queue_purge(&data->readq);
1da177e4	68
4aa769b9	69	return 0;
1da177e4 LT	70	}
1da177e4 LT	71
7bd8f09f	72	static int vhci_send_frame(struct hci_dev hdev, struct sk_buff skb)
1da177e4	73	{
60298775	74	struct vhci_data *data = hci_get_drvdata(hdev);
1da177e4	75
618e8bc2	76	memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
9c724357	77	skb_queue_tail(&data->readq, skb);
4aa769b9	78
9c724357	79	wake_up_interruptible(&data->read_wait);
23424c0d MH	80	return 0;
	81	}
	82
9682d36c K	83	static int vhci_get_data_path_id(struct hci_dev hdev, u8 data_path_id)
	84	{
	85	*data_path_id = 0;
	86	return 0;
	87	}
	88
	89	static int vhci_get_codec_config_data(struct hci_dev *hdev, __u8 type,
	90	struct bt_codec codec, __u8 vnd_len,
	91	__u8 **vnd_data)
	92	{
	93	if (type != ESCO_LINK)
	94	return -EINVAL;
	95
	96	*vnd_len = 0;
	97	*vnd_data = NULL;
	98	return 0;
	99	}
	100
4539ca67	101	static bool vhci_wakeup(struct hci_dev *hdev)
60edfad4 LAD	102	{
	103	struct vhci_data *data = hci_get_drvdata(hdev);
	104
4539ca67	105	return data->wakeup;
60edfad4 LAD	106	}
60edfad4 LAD	107
59c218ca LAD	108	static ssize_t force_suspend_read(struct file file, char __user user_buf,
	109	size_t count, loff_t *ppos)
	110	{
	111	struct vhci_data *data = file->private_data;
	112	char buf[3];
	113
	114	buf[0] = data->suspended ? 'Y' : 'N';
	115	buf[1] = '\n';
	116	buf[2] = '\0';
	117	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
	118	}
	119
d16e6d19 LAD	120	static void vhci_suspend_work(struct work_struct *work)
	121	{
	122	struct vhci_data *data = container_of(work, struct vhci_data,
	123	suspend_work);
	124
	125	if (data->suspended)
	126	hci_suspend_dev(data->hdev);
	127	else
	128	hci_resume_dev(data->hdev);
	129	}
	130
59c218ca LAD	131	static ssize_t force_suspend_write(struct file *file,
	132	const char __user *user_buf,
	133	size_t count, loff_t *ppos)
	134	{
	135	struct vhci_data *data = file->private_data;
	136	bool enable;
	137	int err;
	138
	139	err = kstrtobool_from_user(user_buf, count, &enable);
	140	if (err)
	141	return err;
	142
	143	if (data->suspended == enable)
	144	return -EALREADY;
	145
59c218ca LAD	146	data->suspended = enable;
59c218ca LAD	147
d16e6d19 LAD	148	schedule_work(&data->suspend_work);
d16e6d19 LAD	149
59c218ca LAD	150	return count;
	151	}
	152
	153	static const struct file_operations force_suspend_fops = {
	154	.open = simple_open,
	155	.read = force_suspend_read,
	156	.write = force_suspend_write,
	157	.llseek = default_llseek,
	158	};
	159
4539ca67 LAD	160	static ssize_t force_wakeup_read(struct file file, char __user user_buf,
4539ca67 LAD	161	size_t count, loff_t *ppos)
60edfad4 LAD	162	{
	163	struct vhci_data *data = file->private_data;
	164	char buf[3];
	165
4539ca67	166	buf[0] = data->wakeup ? 'Y' : 'N';
60edfad4 LAD	167	buf[1] = '\n';
	168	buf[2] = '\0';
	169	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
	170	}
	171
4539ca67 LAD	172	static ssize_t force_wakeup_write(struct file *file,
	173	const char __user *user_buf, size_t count,
	174	loff_t *ppos)
60edfad4 LAD	175	{
	176	struct vhci_data *data = file->private_data;
	177	bool enable;
	178	int err;
	179
	180	err = kstrtobool_from_user(user_buf, count, &enable);
	181	if (err)
	182	return err;
	183
4539ca67	184	if (data->wakeup == enable)
60edfad4 LAD	185	return -EALREADY;
60edfad4 LAD	186
8b89637d THJA	187	data->wakeup = enable;
8b89637d THJA	188
60edfad4 LAD	189	return count;
	190	}
	191
4539ca67	192	static const struct file_operations force_wakeup_fops = {
60edfad4	193	.open = simple_open,
4539ca67 LAD	194	.read = force_wakeup_read,
4539ca67 LAD	195	.write = force_wakeup_write,
60edfad4 LAD	196	.llseek = default_llseek,
	197	};
	198
b8f5482c LAD	199	static int msft_opcode_set(void *data, u64 val)
	200	{
	201	struct vhci_data *vhci = data;
	202
f33b0068	203	if (val > 0xffff \|\| hci_opcode_ogf(val) != 0x3f)
b8f5482c LAD	204	return -EINVAL;
	205
	206	if (vhci->msft_opcode)
	207	return -EALREADY;
	208
	209	vhci->msft_opcode = val;
	210
	211	return 0;
	212	}
	213
	214	static int msft_opcode_get(void data, u64 val)
	215	{
	216	struct vhci_data *vhci = data;
	217
	218	*val = vhci->msft_opcode;
	219
	220	return 0;
	221	}
	222
	223	DEFINE_DEBUGFS_ATTRIBUTE(msft_opcode_fops, msft_opcode_get, msft_opcode_set,
	224	"%llu\n");
	225
	226	static ssize_t aosp_capable_read(struct file file, char __user user_buf,
	227	size_t count, loff_t *ppos)
	228	{
	229	struct vhci_data *vhci = file->private_data;
	230	char buf[3];
	231
	232	buf[0] = vhci->aosp_capable ? 'Y' : 'N';
	233	buf[1] = '\n';
	234	buf[2] = '\0';
	235	return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
	236	}
	237
	238	static ssize_t aosp_capable_write(struct file *file,
	239	const char __user *user_buf, size_t count,
	240	loff_t *ppos)
	241	{
	242	struct vhci_data *vhci = file->private_data;
	243	bool enable;
	244	int err;
	245
	246	err = kstrtobool_from_user(user_buf, count, &enable);
	247	if (err)
	248	return err;
	249
	250	if (!enable)
	251	return -EINVAL;
	252
	253	if (vhci->aosp_capable)
	254	return -EALREADY;
	255
	256	vhci->aosp_capable = enable;
	257
	258	return count;
	259	}
	260
	261	static const struct file_operations aosp_capable_fops = {
	262	.open = simple_open,
	263	.read = aosp_capable_read,
	264	.write = aosp_capable_write,
	265	.llseek = default_llseek,
	266	};
	267
268	static int vhci_setup(struct hci_dev *hdev)
269	{
270	struct vhci_data *vhci = hci_get_drvdata(hdev);
271
272	if (vhci->msft_opcode)
273	hci_set_msft_opcode(hdev, vhci->msft_opcode);
274
275	if (vhci->aosp_capable)
276	hci_set_aosp_capable(hdev);
277
278	return 0;
279	}
280
ab4e4380 MM	281	static void vhci_coredump(struct hci_dev *hdev)
	282	{
	283	/* No need to do anything */
	284	}
	285
	286	static void vhci_coredump_hdr(struct hci_dev hdev, struct sk_buff skb)
	287	{
	288	char buf[80];
	289
	290	snprintf(buf, sizeof(buf), "Controller Name: vhci_ctrl\n");
	291	skb_put_data(skb, buf, strlen(buf));
	292
	293	snprintf(buf, sizeof(buf), "Firmware Version: vhci_fw\n");
	294	skb_put_data(skb, buf, strlen(buf));
	295
	296	snprintf(buf, sizeof(buf), "Driver: vhci_drv\n");
	297	skb_put_data(skb, buf, strlen(buf));
	298
	299	snprintf(buf, sizeof(buf), "Vendor: vhci\n");
	300	skb_put_data(skb, buf, strlen(buf));
	301	}
	302
	303	#define MAX_COREDUMP_LINE_LEN 40
	304
	305	struct devcoredump_test_data {
	306	enum devcoredump_state state;
	307	unsigned int timeout;
	308	char data[MAX_COREDUMP_LINE_LEN];
	309	};
	310
	311	static inline void force_devcd_timeout(struct hci_dev *hdev,
	312	unsigned int timeout)
	313	{
	314	#ifdef CONFIG_DEV_COREDUMP
	315	hdev->dump.timeout = msecs_to_jiffies(timeout * 1000);
	316	#endif
	317	}
	318
	319	static ssize_t force_devcd_write(struct file file, const char __user user_buf,
	320	size_t count, loff_t *ppos)
	321	{
	322	struct vhci_data *data = file->private_data;
	323	struct hci_dev *hdev = data->hdev;
	324	struct sk_buff *skb = NULL;
	325	struct devcoredump_test_data dump_data;
e4eea890	326	size_t data_size;
ab4e4380 MM	327	int ret;
ab4e4380 MM	328
e4eea890 DC	329	if (count < offsetof(struct devcoredump_test_data, data) \|\|
	330	count > sizeof(dump_data))
	331	return -EINVAL;
	332
	333	if (copy_from_user(&dump_data, user_buf, count))
	334	return -EFAULT;
ab4e4380	335
e4eea890 DC	336	data_size = count - offsetof(struct devcoredump_test_data, data);
e4eea890 DC	337	skb = alloc_skb(data_size, GFP_ATOMIC);
ab4e4380 MM	338	if (!skb)
ab4e4380 MM	339	return -ENOMEM;
e4eea890	340	skb_put_data(skb, &dump_data.data, data_size);
ab4e4380 MM	341
	342	hci_devcd_register(hdev, vhci_coredump, vhci_coredump_hdr, NULL);
	343
	344	/* Force the devcoredump timeout */
	345	if (dump_data.timeout)
	346	force_devcd_timeout(hdev, dump_data.timeout);
	347
	348	ret = hci_devcd_init(hdev, skb->len);
	349	if (ret) {
	350	BT_ERR("Failed to generate devcoredump");
	351	kfree_skb(skb);
	352	return ret;
	353	}
	354
	355	hci_devcd_append(hdev, skb);
	356
	357	switch (dump_data.state) {
	358	case HCI_DEVCOREDUMP_DONE:
	359	hci_devcd_complete(hdev);
	360	break;
	361	case HCI_DEVCOREDUMP_ABORT:
	362	hci_devcd_abort(hdev);
	363	break;
	364	case HCI_DEVCOREDUMP_TIMEOUT:
	365	/* Do nothing */
	366	break;
	367	default:
	368	return -EINVAL;
	369	}
	370
	371	return count;
	372	}
	373
	374	static const struct file_operations force_devcoredump_fops = {
	375	.open = simple_open,
	376	.write = force_devcd_write,
	377	};
	378
c7c999cb	379	static int __vhci_create_device(struct vhci_data *data, __u8 opcode)
23424c0d MH	380	{
	381	struct hci_dev *hdev;
	382	struct sk_buff *skb;
82a30cfc MH	383	__u8 dev_type;
82a30cfc MH	384
c7c999cb TI	385	if (data->hdev)
	386	return -EBADFD;
	387
ca8bee5d	388	/* bits 0-1 are dev_type (Primary or AMP) */
82a30cfc MH	389	dev_type = opcode & 0x03;
82a30cfc MH	390
ca8bee5d	391	if (dev_type != HCI_PRIMARY && dev_type != HCI_AMP)
82a30cfc MH	392	return -EINVAL;
82a30cfc MH	393
0ad184ef MH	394	/* bits 2-5 are reserved (must be zero) */
0ad184ef MH	395	if (opcode & 0x3c)
82a30cfc	396	return -EINVAL;
23424c0d MH	397
	398	skb = bt_skb_alloc(4, GFP_KERNEL);
	399	if (!skb)
	400	return -ENOMEM;
	401
	402	hdev = hci_alloc_dev();
	403	if (!hdev) {
	404	kfree_skb(skb);
	405	return -ENOMEM;
	406	}
	407
	408	data->hdev = hdev;
	409
	410	hdev->bus = HCI_VIRTUAL;
	411	hdev->dev_type = dev_type;
	412	hci_set_drvdata(hdev, data);
	413
	414	hdev->open = vhci_open_dev;
	415	hdev->close = vhci_close_dev;
	416	hdev->flush = vhci_flush;
	417	hdev->send = vhci_send_frame;
9682d36c K	418	hdev->get_data_path_id = vhci_get_data_path_id;
9682d36c K	419	hdev->get_codec_config_data = vhci_get_codec_config_data;
4539ca67	420	hdev->wakeup = vhci_wakeup;
b8f5482c LAD	421	hdev->setup = vhci_setup;
b8f5482c LAD	422	set_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks);
1da177e4	423
0ad184ef MH	424	/* bit 6 is for external configuration */
	425	if (opcode & 0x40)
	426	set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks);
	427
82a30cfc MH	428	/* bit 7 is for raw device */
	429	if (opcode & 0x80)
	430	set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
	431
cfb4c313 LAD	432	set_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks);
cfb4c313 LAD	433
23424c0d MH	434	if (hci_register_dev(hdev) < 0) {
	435	BT_ERR("Can't register HCI device");
	436	hci_free_dev(hdev);
	437	data->hdev = NULL;
	438	kfree_skb(skb);
	439	return -EBUSY;
	440	}
	441
59c218ca LAD	442	debugfs_create_file("force_suspend", 0644, hdev->debugfs, data,
	443	&force_suspend_fops);
	444
4539ca67 LAD	445	debugfs_create_file("force_wakeup", 0644, hdev->debugfs, data,
4539ca67 LAD	446	&force_wakeup_fops);
60edfad4	447
b8f5482c LAD	448	if (IS_ENABLED(CONFIG_BT_MSFTEXT))
	449	debugfs_create_file("msft_opcode", 0644, hdev->debugfs, data,
	450	&msft_opcode_fops);
	451
	452	if (IS_ENABLED(CONFIG_BT_AOSPEXT))
	453	debugfs_create_file("aosp_capable", 0644, hdev->debugfs, data,
	454	&aosp_capable_fops);
	455
ab4e4380 MM	456	debugfs_create_file("force_devcoredump", 0644, hdev->debugfs, data,
	457	&force_devcoredump_fops);
	458
618e8bc2	459	hci_skb_pkt_type(skb) = HCI_VENDOR_PKT;
23424c0d	460
634fef61 JB	461	skb_put_u8(skb, 0xff);
634fef61 JB	462	skb_put_u8(skb, opcode);
23424c0d MH	463	put_unaligned_le16(hdev->id, skb_put(skb, 2));
	464	skb_queue_tail(&data->readq, skb);
	465
	466	wake_up_interruptible(&data->read_wait);
1da177e4 LT	467	return 0;
	468	}
	469
c7c999cb TI	470	static int vhci_create_device(struct vhci_data *data, __u8 opcode)
	471	{
	472	int err;
	473
	474	mutex_lock(&data->open_mutex);
	475	err = __vhci_create_device(data, opcode);
	476	mutex_unlock(&data->open_mutex);
	477
	478	return err;
	479	}
	480
9c724357	481	static inline ssize_t vhci_get_user(struct vhci_data *data,
512b2268	482	struct iov_iter *from)
1da177e4	483	{
512b2268	484	size_t len = iov_iter_count(from);
1da177e4	485	struct sk_buff *skb;
82a30cfc	486	__u8 pkt_type, opcode;
23424c0d	487	int ret;
1da177e4	488
5bc00b5c	489	if (len < 2 \|\| len > HCI_MAX_FRAME_SIZE)
1da177e4 LT	490	return -EINVAL;
1da177e4 LT	491
5bc00b5c	492	skb = bt_skb_alloc(len, GFP_KERNEL);
4aa769b9	493	if (!skb)
1da177e4	494	return -ENOMEM;
4aa769b9	495
cbbd26b8	496	if (!copy_from_iter_full(skb_put(skb, len), len, from)) {
512b2268 AV	497	kfree_skb(skb);
512b2268 AV	498	return -EFAULT;
1da177e4 LT	499	}
1da177e4 LT	500
23424c0d	501	pkt_type = ((__u8 ) skb->data);
1da177e4 LT	502	skb_pull(skb, 1);
1da177e4 LT	503
23424c0d MH	504	switch (pkt_type) {
	505	case HCI_EVENT_PKT:
	506	case HCI_ACLDATA_PKT:
	507	case HCI_SCODATA_PKT:
f92a8cb5	508	case HCI_ISODATA_PKT:
23424c0d MH	509	if (!data->hdev) {
	510	kfree_skb(skb);
	511	return -ENODEV;
	512	}
	513
618e8bc2	514	hci_skb_pkt_type(skb) = pkt_type;
23424c0d	515
e1a26170	516	ret = hci_recv_frame(data->hdev, skb);
23424c0d MH	517	break;
	518
	519	case HCI_VENDOR_PKT:
373a32c8 JS	520	cancel_delayed_work_sync(&data->open_timeout);
373a32c8 JS	521
82a30cfc	522	opcode = ((__u8 ) skb->data);
23424c0d MH	523	skb_pull(skb, 1);
	524
	525	if (skb->len > 0) {
	526	kfree_skb(skb);
	527	return -EINVAL;
	528	}
	529
	530	kfree_skb(skb);
	531
82a30cfc	532	ret = vhci_create_device(data, opcode);
23424c0d MH	533	break;
	534
	535	default:
	536	kfree_skb(skb);
	537	return -EINVAL;
	538	}
	539
5bc00b5c	540	return (ret < 0) ? ret : len;
1da177e4 LT	541	}
1da177e4 LT	542
9c724357	543	static inline ssize_t vhci_put_user(struct vhci_data *data,
23424c0d MH	544	struct sk_buff *skb,
23424c0d MH	545	char __user *buf, int count)
1da177e4	546	{
1da177e4	547	char __user *ptr = buf;
23424c0d	548	int len;
4aa769b9 MH	549
4aa769b9 MH	550	len = min_t(unsigned int, skb->len, count);
1da177e4	551
1da177e4 LT	552	if (copy_to_user(ptr, skb->data, len))
1da177e4 LT	553	return -EFAULT;
4aa769b9	554
23424c0d MH	555	if (!data->hdev)
23424c0d MH	556	return len;
1da177e4	557
9c724357	558	data->hdev->stat.byte_tx += len;
4aa769b9	559
618e8bc2	560	switch (hci_skb_pkt_type(skb)) {
0d48d939	561	case HCI_COMMAND_PKT:
9c724357	562	data->hdev->stat.cmd_tx++;
0d48d939	563	break;
0d48d939	564	case HCI_ACLDATA_PKT:
9c724357	565	data->hdev->stat.acl_tx++;
0d48d939	566	break;
0d48d939	567	case HCI_SCODATA_PKT:
4f7ac181	568	data->hdev->stat.sco_tx++;
0d48d939	569	break;
2c24d454	570	}
1da177e4	571
23424c0d	572	return len;
1da177e4 LT	573	}
1da177e4 LT	574
9c724357	575	static ssize_t vhci_read(struct file *file,
23424c0d	576	char __user buf, size_t count, loff_t pos)
1da177e4	577	{
9c724357	578	struct vhci_data *data = file->private_data;
1da177e4 LT	579	struct sk_buff *skb;
	580	ssize_t ret = 0;
	581
1da177e4	582	while (count) {
9c724357	583	skb = skb_dequeue(&data->readq);
4db7589f MH	584	if (skb) {
	585	ret = vhci_put_user(data, skb, buf, count);
	586	if (ret < 0)
	587	skb_queue_head(&data->readq, skb);
	588	else
	589	kfree_skb(skb);
	590	break;
1da177e4 LT	591	}
1da177e4 LT	592
4db7589f MH	593	if (file->f_flags & O_NONBLOCK) {
	594	ret = -EAGAIN;
	595	break;
	596	}
1da177e4	597
4db7589f	598	ret = wait_event_interruptible(data->read_wait,
23424c0d	599	!skb_queue_empty(&data->readq));
4db7589f MH	600	if (ret < 0)
4db7589f MH	601	break;
1da177e4	602	}
1da177e4 LT	603
	604	return ret;
	605	}
	606
512b2268	607	static ssize_t vhci_write(struct kiocb iocb, struct iov_iter from)
1da177e4	608	{
5bc00b5c	609	struct file *file = iocb->ki_filp;
9c724357	610	struct vhci_data *data = file->private_data;
1da177e4	611
512b2268	612	return vhci_get_user(data, from);
1da177e4 LT	613	}
1da177e4 LT	614
afc9a42b	615	static __poll_t vhci_poll(struct file file, poll_table wait)
1da177e4	616	{
9c724357	617	struct vhci_data *data = file->private_data;
1da177e4	618
9c724357	619	poll_wait(file, &data->read_wait, wait);
1da177e4	620
9c724357	621	if (!skb_queue_empty(&data->readq))
a9a08845	622	return EPOLLIN \| EPOLLRDNORM;
4aa769b9	623
a9a08845	624	return EPOLLOUT \| EPOLLWRNORM;
4aa769b9 MH	625	}
4aa769b9 MH	626
23424c0d MH	627	static void vhci_open_timeout(struct work_struct *work)
	628	{
	629	struct vhci_data *data = container_of(work, struct vhci_data,
	630	open_timeout.work);
	631
ca8bee5d	632	vhci_create_device(data, amp ? HCI_AMP : HCI_PRIMARY);
23424c0d MH	633	}
23424c0d MH	634
4aa769b9	635	static int vhci_open(struct inode inode, struct file file)
1da177e4	636	{
9c724357	637	struct vhci_data *data;
1da177e4	638
9c724357 MH	639	data = kzalloc(sizeof(struct vhci_data), GFP_KERNEL);
9c724357 MH	640	if (!data)
1da177e4 LT	641	return -ENOMEM;
1da177e4 LT	642
9c724357 MH	643	skb_queue_head_init(&data->readq);
9c724357 MH	644	init_waitqueue_head(&data->read_wait);
1da177e4	645
c7c999cb	646	mutex_init(&data->open_mutex);
23424c0d	647	INIT_DELAYED_WORK(&data->open_timeout, vhci_open_timeout);
d16e6d19	648	INIT_WORK(&data->suspend_work, vhci_suspend_work);
1da177e4	649
9c724357	650	file->private_data = data;
0dea0141	651	nonseekable_open(inode, file);
4aa769b9	652
23424c0d MH	653	schedule_delayed_work(&data->open_timeout, msecs_to_jiffies(1000));
23424c0d MH	654
0dea0141	655	return 0;
1da177e4 LT	656	}
1da177e4 LT	657
4aa769b9	658	static int vhci_release(struct inode inode, struct file file)
1da177e4	659	{
9c724357	660	struct vhci_data *data = file->private_data;
373a32c8	661	struct hci_dev *hdev;
1da177e4	662
23424c0d	663	cancel_delayed_work_sync(&data->open_timeout);
d16e6d19	664	flush_work(&data->suspend_work);
23424c0d	665
373a32c8 JS	666	hdev = data->hdev;
373a32c8 JS	667
23424c0d MH	668	if (hdev) {
	669	hci_unregister_dev(hdev);
	670	hci_free_dev(hdev);
	671	}
1da177e4	672
13407376	673	skb_queue_purge(&data->readq);
1da177e4	674	file->private_data = NULL;
bf18c711	675	kfree(data);
4aa769b9 MH	676
	677	return 0;
	678	}
	679
2b8693c0	680	static const struct file_operations vhci_fops = {
fed4c250	681	.owner = THIS_MODULE,
4aa769b9	682	.read = vhci_read,
512b2268	683	.write_iter = vhci_write,
4aa769b9	684	.poll = vhci_poll,
4aa769b9 MH	685	.open = vhci_open,
4aa769b9 MH	686	.release = vhci_release,
6038f373	687	.llseek = no_llseek,
1da177e4 LT	688	};
1da177e4 LT	689
4eeab599	690	static struct miscdevice vhci_miscdev = {
ac28494c MH	691	.name = "vhci",
ac28494c MH	692	.fops = &vhci_fops,
b075dd40	693	.minor = VHCI_MINOR,
1da177e4	694	};
d6a38c0b	695	module_misc_device(vhci_miscdev);
4aa769b9	696
36acbb1a AE	697	module_param(amp, bool, 0644);
	698	MODULE_PARM_DESC(amp, "Create AMP controller device");
	699
63fbd24e	700	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
4aa769b9 MH	701	MODULE_DESCRIPTION("Bluetooth virtual HCI driver ver " VERSION);
	702	MODULE_VERSION(VERSION);
	703	MODULE_LICENSE("GPL");
bfacbb9a	704	MODULE_ALIAS("devname:vhci");
b075dd40	705	MODULE_ALIAS_MISCDEV(VHCI_MINOR);