MLK-17837-01 input: misc: rpmsg_input: add rpmsg virtual sensor driver

NXP i.MX7ULP EVK boards all sensors connect with M4 core, A core
has to conmunicate with sensors by virtual io bus like rpmsg bus.
The driver implement the virtual sensor input driver to configure
sensors active/idle/delay actions and report the sensors' event to
user space.

Supply below sysfs for user to enable/disable detector and counter,
set poll delay:
	/sys/class/misc/step_counter/enable
	/sys/class/misc/step_detector/enable
	/sys/class/misc/step_counter/poll_delay

Reviewed-by: Elven Wang <elven.wang@nxp.com>
Signed-off-by: Fugang Duan <fugang.duan@nxp.com>

3 files changed, 539 insertions, 0 deletions

diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index c6aefc266fbb..adeac9208505 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -846,6 +846,16 @@ config SENSOR_FXLS8471
 	depends on I2C
 	default n
 
+config SENSOR_IMX_RPMSG
+	tristate "NXP IMX rpmsg virtual sensor device driver"
+	depends on (SOC_IMX7ULP)
+	depends on RPMSG && SYSFS
+	depends on OF
+	default n
+	help
+	  This is rpmsg virtual sensor driver on i.mx7ulp, because some
+	  sensors connect with M4 core.
+
 config INPUT_ISL29023
 	tristate "Intersil ISL29023 ambient light sensor"
 	depends on I2C && SYSFS
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index cac4fcad3801..a6d887f50de0 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -81,3 +81,4 @@ obj-$(CONFIG_INPUT_IDEAPAD_SLIDEBAR)	+= ideapad_slidebar.o
 obj-$(CONFIG_INPUT_MPL3115)		+= mpl3115.o
 obj-$(CONFIG_SENSOR_FXLS8471)       	+= fxls8471.o fxls8471_i2c.o
 obj-$(CONFIG_INPUT_ISL29023)            += isl29023.o
+obj-$(CONFIG_SENSOR_IMX_RPMSG)		+= rpmsg_input.o
diff --git a/drivers/input/misc/rpmsg_input.c b/drivers/input/misc/rpmsg_input.c
new file mode 100644
index 000000000000..8f3d07b59ef0
--- /dev/null
+++ b/drivers/input/misc/rpmsg_input.c
@@ -0,0 +1,528 @@
+/*
+ * Copyright 2018 NXP
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/imx_rpmsg.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/pm_qos.h>
+#include <linux/rpmsg.h>
+#include <linux/uaccess.h>
+#include <linux/virtio.h>
+
+#define RPMSG_INPUT_DEV_STANDBY	 	0x00
+#define RPMSG_INPUT_DEV_ACTIVED 	0x01
+#define DETECTOR_DEVICE			"step_detector"
+#define COUNTER_DEVICE			"step_counter"
+
+#define PEDOMETER_TYPE			0x0
+#define PEDOMETER_IDX			0x0
+
+#define RPMSG_TIMEOUT 			1000
+
+enum rpmsg_input_header_type {
+	RPMSG_INPUT_SETUP,
+	RPMSG_INPUT_REPLY,
+	RPMSG_INPUT_NOTIFY,
+};
+
+enum rpmsg_input_header_cmd {
+	RPMSG_INPUT_DETECTOR_CMD,
+	RPMSG_INPUT_COUNTER_CMD,
+	RPMSG_INPUT_POLL_DELAY_CMD,
+};
+
+struct rpmsg_input_msg {
+	struct imx_rpmsg_head header;
+	u8 sensor_type;
+	u8 sensor_index;
+	union {
+		union {
+			u8 enable;
+			u8 retcode;
+		} inout;
+
+		u32 val;
+	} instruct;
+} __packed __aligned(8);
+
+struct rpmsg_input_data {
+	struct device *dev;
+	struct miscdevice *detector_miscdev;
+	struct miscdevice *counter_miscdev;
+	struct input_dev *detector_input;
+	struct input_dev *counter_input;
+	atomic_t detector_active;
+	atomic_t counter_active;
+	atomic_t counter_delay;
+
+	struct rpmsg_device *rpdev;
+	struct rpmsg_input_msg *reply_msg;
+	struct rpmsg_input_msg *notify_msg;
+	struct pm_qos_request pm_qos_req;
+	struct completion cmd_complete;
+	struct mutex lock;
+};
+
+static struct rpmsg_input_data *input_rpmsg;
+
+static int input_send_message(struct rpmsg_input_msg *msg,
+			      struct rpmsg_input_data *info)
+{
+	int err;
+
+	if (!info->rpdev) {
+		dev_dbg(info->dev,
+			"rpmsg channel not ready, m4 image ready?\n");
+		return -EINVAL;
+	}
+
+	mutex_lock(&info->lock);
+	pm_qos_add_request(&info->pm_qos_req,
+			   PM_QOS_CPU_DMA_LATENCY, 0);
+
+	reinit_completion(&info->cmd_complete);
+
+	err = rpmsg_send(info->rpdev->ept, (void *)msg,
+			 sizeof(struct rpmsg_input_msg));
+	if (err) {
+		dev_err(&info->rpdev->dev, "rpmsg_send failed: %d\n", err);
+		goto err_out;
+	}
+
+	err = wait_for_completion_timeout(&info->cmd_complete,
+				msecs_to_jiffies(RPMSG_TIMEOUT));
+	if (!err) {
+		dev_err(&info->rpdev->dev, "rpmsg_send timeout!\n");
+		err = -ETIMEDOUT;
+		goto err_out;
+	}
+
+	err = info->reply_msg->instruct.inout.retcode;
+	if (err != 0) {
+		dev_err(&info->rpdev->dev, "rpmsg not ack %d!\n", err);
+		err = -EINVAL;
+		goto err_out;
+	}
+
+	err = 0;
+
+err_out:
+	pm_qos_remove_request(&info->pm_qos_req);
+	mutex_unlock(&info->lock);
+
+	return err;
+}
+
+static inline void rpmsg_input_evt_report(struct rpmsg_input_msg *msg)
+{
+	int val = 0x1;
+
+	if (msg->header.cmd == RPMSG_INPUT_DETECTOR_CMD) {
+		input_report_rel(input_rpmsg->detector_input, REL_MISC, val);
+		input_sync(input_rpmsg->detector_input);
+	} else if (msg->header.cmd ==  RPMSG_INPUT_COUNTER_CMD) {
+		val = msg->instruct.val;
+		input_report_abs(input_rpmsg->counter_input, ABS_MISC, val);
+		input_sync(input_rpmsg->counter_input);
+	}
+}
+
+static int rpmsg_input_cb(struct rpmsg_device *rpdev,
+	void *data, int len, void *priv, u32 src)
+{
+	struct rpmsg_input_msg *msg = (struct rpmsg_input_msg *)data;
+
+	if (msg->header.type == RPMSG_INPUT_REPLY) {
+		input_rpmsg->reply_msg = msg;
+		complete(&input_rpmsg->cmd_complete);
+		return 0;
+	} else if (msg->header.type == RPMSG_INPUT_NOTIFY) {
+		input_rpmsg->notify_msg = msg;
+		rpmsg_input_evt_report(msg);
+	} else
+		dev_err(&input_rpmsg->rpdev->dev, "wrong command type!\n");
+
+	return 0;
+}
+
+static int rpmsg_input_probe(struct rpmsg_device *rpdev)
+{
+	input_rpmsg->rpdev = rpdev;
+
+	dev_info(&rpdev->dev, "new channel: 0x%x -> 0x%x!\n",
+			rpdev->src, rpdev->dst);
+
+	init_completion(&input_rpmsg->cmd_complete);
+	mutex_init(&input_rpmsg->lock);
+
+	return 0;
+}
+
+static struct rpmsg_device_id rpmsg_input_id_table[] = {
+	{ .name	= "rpmsg-sensor-channel" },
+	{ },
+};
+
+static struct rpmsg_driver rpmsg_input_driver = {
+	.drv.name	= "input_rpmsg",
+	.drv.owner	= THIS_MODULE,
+	.id_table	= rpmsg_input_id_table,
+	.probe		= rpmsg_input_probe,
+	.callback	= rpmsg_input_cb,
+};
+
+static int rpmsg_input_open(struct inode *inode, struct file *file)
+{
+	file->private_data = input_rpmsg;
+	return nonseekable_open(inode, file);
+}
+
+static int rpmsg_input_release(struct inode *inode, struct file *file)
+{
+	return 0;
+}
+
+static long
+rpmsg_input_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	/* TBD: for future sensor interfaces support */
+	return 0;
+}
+
+static const struct file_operations rpmsg_input_fops = {
+	.owner = THIS_MODULE,
+	.open = rpmsg_input_open,
+	.release = rpmsg_input_release,
+	.unlocked_ioctl = rpmsg_input_ioctl,
+};
+
+static struct miscdevice step_detector_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = "step_detector",
+	.fops = &rpmsg_input_fops,
+};
+
+static struct miscdevice step_counter_device = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = "step_counter",
+	.fops = &rpmsg_input_fops,
+};
+
+static int rpmsg_input_change_mode(int cmd, int enable)
+{
+
+	struct rpmsg_input_msg msg;
+
+	memset(&msg, 0, sizeof(struct rpmsg_input_msg));
+	msg.header.cate = IMX_RPMSG_SENSOR;
+	msg.header.major = IMX_RMPSG_MAJOR;
+	msg.header.minor = IMX_RMPSG_MINOR;
+	msg.header.type = RPMSG_INPUT_SETUP;
+	msg.header.cmd = cmd;
+	msg.sensor_type = PEDOMETER_TYPE;
+	msg.sensor_index = PEDOMETER_IDX;
+	msg.instruct.inout.enable = enable;
+
+	return input_send_message(&msg, input_rpmsg);
+}
+
+static int rpmsg_input_set_poll_delay(int cmd, int delay)
+{
+	struct rpmsg_input_msg msg;
+
+	memset(&msg, 0, sizeof(struct rpmsg_input_msg));
+	msg.header.cate = IMX_RPMSG_SENSOR;
+	msg.header.major = IMX_RMPSG_MAJOR;
+	msg.header.minor = IMX_RMPSG_MINOR;
+	msg.header.type = RPMSG_INPUT_SETUP;
+	msg.header.cmd = cmd;
+	msg.sensor_type = PEDOMETER_TYPE;
+	msg.sensor_index = PEDOMETER_IDX;
+	msg.instruct.val = delay;
+
+	return input_send_message(&msg, input_rpmsg);
+}
+
+static ssize_t rpmsg_input_enable_show(struct device *dev,
+				       struct device_attribute *attr,
+				       char *buf)
+{
+	struct miscdevice *misc_dev = dev_get_drvdata(dev);
+	struct rpmsg_input_data *pdata = input_rpmsg;
+	int enable = 0;
+
+	if (pdata->detector_miscdev == misc_dev)
+		enable = atomic_read(&pdata->detector_active);
+	if (pdata->counter_miscdev == misc_dev)
+		enable = atomic_read(&pdata->counter_active);
+
+	return sprintf(buf, "%d\n", enable);
+}
+
+static ssize_t rpmsg_input_enable_store(struct device *dev,
+					struct device_attribute *attr,
+					const char *buf, size_t count)
+{
+	struct miscdevice *misc_dev = dev_get_drvdata(dev);
+	struct rpmsg_input_data *pdata = input_rpmsg;
+	unsigned long enable;
+	int cmd;
+	int ret;
+
+	if (kstrtoul(buf, 10, &enable) < 0)
+		return -EINVAL;
+
+	if (misc_dev == pdata->detector_miscdev)
+		cmd = RPMSG_INPUT_DETECTOR_CMD;
+	if (misc_dev == pdata->counter_miscdev)
+		cmd = RPMSG_INPUT_COUNTER_CMD;
+
+	enable = enable > 0 ? RPMSG_INPUT_DEV_ACTIVED :
+			      RPMSG_INPUT_DEV_STANDBY;
+	ret = rpmsg_input_change_mode(cmd, enable);
+	if (!ret) {
+		if (cmd == RPMSG_INPUT_DETECTOR_CMD)
+			atomic_set(&pdata->detector_active, enable);
+		else if (cmd == RPMSG_INPUT_COUNTER_CMD)
+			atomic_set(&pdata->counter_active, enable);
+	}
+
+	return count;
+}
+
+static ssize_t rpmsg_input_poll_delay_show(struct device *dev,
+					   struct device_attribute *attr,
+					   char *buf)
+{
+	struct miscdevice *misc_dev = dev_get_drvdata(dev);
+	struct rpmsg_input_data *pdata = input_rpmsg;
+	int poll_delay = 0;
+
+	if (pdata->detector_miscdev == misc_dev)
+		return -ENOTSUPP;
+
+	if (pdata->counter_miscdev == misc_dev)
+		poll_delay = atomic_read(&pdata->counter_delay);
+
+	return sprintf(buf, "%d\n", poll_delay);
+}
+
+
+static ssize_t rpmsg_input_poll_delay_store(struct device *dev,
+					    struct device_attribute *attr,
+					    const char *buf, size_t count)
+{
+	struct miscdevice *misc_dev = dev_get_drvdata(dev);
+	struct rpmsg_input_data *pdata = input_rpmsg;
+	unsigned long delay;
+	int cmd;
+	int ret;
+
+	if (kstrtoul(buf, 10, &delay) < 0)
+		return -EINVAL;
+
+	if (pdata->detector_miscdev == misc_dev)
+		return -ENOTSUPP;
+
+	if (pdata->counter_miscdev == misc_dev)
+		cmd = RPMSG_INPUT_POLL_DELAY_CMD;
+
+	ret = rpmsg_input_set_poll_delay(cmd, delay);
+	if (!ret) {
+		if (cmd == RPMSG_INPUT_POLL_DELAY_CMD)
+			atomic_set(&pdata->counter_delay, delay);
+	}
+
+	return count;
+}
+
+static DEVICE_ATTR(enable, S_IWUSR | S_IRUGO,
+		   rpmsg_input_enable_show,
+		   rpmsg_input_enable_store);
+static DEVICE_ATTR(poll_delay, S_IWUSR | S_IRUGO,
+		   rpmsg_input_poll_delay_show,
+		   rpmsg_input_poll_delay_store);
+
+static struct attribute *rpmsg_input_attributes[] = {
+	&dev_attr_enable.attr,
+	&dev_attr_poll_delay.attr,
+	NULL
+};
+
+static const struct attribute_group rpmsg_input_attr_group = {
+	.attrs = rpmsg_input_attributes,
+};
+
+static int rpmsg_input_register_sysfs_device(struct rpmsg_input_data *pdata)
+{
+	struct miscdevice *misc_dev = NULL;
+	int err = 0;
+
+	/* register sysfs for detector */
+	misc_dev = pdata->detector_miscdev;
+	err = sysfs_create_group(&misc_dev->this_device->kobj,
+				 &rpmsg_input_attr_group);
+	if (err)
+		goto out;
+
+	/* register sysfs for counter */
+	misc_dev = pdata->counter_miscdev;
+	err = sysfs_create_group(&misc_dev->this_device->kobj,
+				 &rpmsg_input_attr_group);
+	if (err)
+		goto err_register_sysfs;
+
+	return 0;
+
+err_register_sysfs:
+	misc_dev = pdata->detector_miscdev;
+	sysfs_remove_group(&misc_dev->this_device->kobj, &rpmsg_input_attr_group);
+out:
+	return err;
+}
+
+static int rpmsg_input_device_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct rpmsg_input_data *pdata;
+	struct input_dev *detector_input;
+	struct input_dev *counter_input;
+	int ret = 0;
+
+	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+	if (!pdata)
+		return -ENOMEM;
+
+	detector_input = devm_input_allocate_device(dev);
+	if (!detector_input) {
+		dev_err(dev, "failed to allocate detector device\n");
+		return -ENOMEM;
+	}
+
+	counter_input = devm_input_allocate_device(dev);
+	if (!counter_input) {
+		dev_err(dev, "failed to allocate counter device\n");
+		return -ENOMEM;
+	}
+
+	detector_input->name = DETECTOR_DEVICE;
+	detector_input->phys = "rpmsg-input/input0";
+	detector_input->dev.parent = &pdev->dev;
+	detector_input->id.bustype = BUS_HOST;
+	detector_input->evbit[0] = BIT_MASK(EV_REL);
+	detector_input->relbit[0] = BIT_MASK(REL_MISC);
+	pdata->detector_input = detector_input;
+
+	counter_input->name = COUNTER_DEVICE;
+	counter_input->phys = "rpmsg-input/input1";
+	counter_input->dev.parent = &pdev->dev;
+	counter_input->id.bustype = BUS_HOST;
+	counter_input->evbit[0] = BIT_MASK(EV_ABS);
+	input_set_abs_params(counter_input, ABS_MISC, 0, 0xFFFFFFFF, 0, 0);
+	pdata->counter_input = counter_input;
+
+	input_rpmsg = pdata;
+	platform_set_drvdata(pdev, pdata);
+
+	ret = misc_register(&step_detector_device);
+	if (ret != 0) {
+		dev_err(dev, "register acc miscdevice error");
+		goto err_register_detector_misc;
+	}
+	pdata->detector_miscdev = &step_detector_device;
+
+	ret = misc_register(&step_counter_device);
+	if (ret != 0) {
+		dev_err(dev, "register acc miscdevice error");
+		goto err_register_counter_misc;
+	}
+	pdata->counter_miscdev = &step_counter_device;
+
+	ret = rpmsg_input_register_sysfs_device(pdata);
+	if (ret) {
+		dev_err(dev, "Unable to register input sysfs, error: %d\n",
+			ret);
+		goto err_register_sysfs;
+	}
+
+	ret = input_register_device(detector_input);
+	if (ret) {
+		dev_err(dev, "Unable to register detector device, error: %d\n",
+			ret);
+		goto err_register_detector_input;
+	}
+
+	ret = input_register_device(counter_input);
+	if (ret) {
+		dev_err(dev, "Unable to register counter device, error: %d\n",
+			ret);
+		goto err_register_counter_input;
+	}
+
+	ret =  register_rpmsg_driver(&rpmsg_input_driver);
+	if (ret) {
+		dev_err(dev, "Unable to register rpmsg driver, error: %d\n",
+			ret);
+		goto err_register_rmpsg_driver;
+	}
+
+	return ret;
+
+err_register_rmpsg_driver:
+	input_unregister_device(counter_input);
+err_register_counter_input:
+	input_unregister_device(detector_input);
+err_register_detector_input:
+err_register_sysfs:
+	misc_deregister(&step_counter_device);
+	pdata->counter_miscdev = NULL;
+err_register_counter_misc:
+	misc_deregister(&step_detector_device);
+	pdata->detector_miscdev = NULL;
+err_register_detector_misc:
+	pdata->detector_input = NULL;
+	pdata->counter_input = NULL;
+	platform_set_drvdata(pdev, NULL);
+	return ret;
+}
+
+static const struct of_device_id rpmsg_input_of_match[] = {
+	{ .compatible = "fsl,rpmsg-input", },
+	{ },
+};
+
+MODULE_DEVICE_TABLE(of, rpmsg_input_of_match);
+
+static struct platform_driver rpmsg_input_device_driver = {
+	.probe		= rpmsg_input_device_probe,
+	.driver		=  {
+		.name	= "rpmsg-input",
+		.of_match_table = of_match_ptr(rpmsg_input_of_match)
+	}
+};
+
+module_platform_driver(rpmsg_input_device_driver);
+
+MODULE_AUTHOR("NXP Semiconductor");
+MODULE_DESCRIPTION("NXP i.MX7ULP rpmsg sensor input driver");
+MODULE_LICENSE("GPL v2");