From 14eecf0006863163c4b7817464de487fd85108f8 Mon Sep 17 00:00:00 2001 From: Fugang Duan Date: Fri, 16 Mar 2018 14:07:05 +0800 Subject: [PATCH] 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 Signed-off-by: Fugang Duan --- .../bindings/input/imx-rpmsg-input.txt | 12 + drivers/input/misc/Kconfig | 10 + drivers/input/misc/Makefile | 1 + drivers/input/misc/rpmsg_input.c | 528 ++++++++++++++++++ drivers/rpmsg/imx_rpmsg.c | 2 +- include/linux/imx_rpmsg.h | 1 + 6 files changed, 553 insertions(+), 1 deletion(-) create mode 100644 Documentation/devicetree/bindings/input/imx-rpmsg-input.txt create mode 100644 drivers/input/misc/rpmsg_input.c diff --git a/Documentation/devicetree/bindings/input/imx-rpmsg-input.txt b/Documentation/devicetree/bindings/input/imx-rpmsg-input.txt new file mode 100644 index 000000000000..397d1957e6fd --- /dev/null +++ b/Documentation/devicetree/bindings/input/imx-rpmsg-input.txt @@ -0,0 +1,12 @@ +Device-Tree bindings for inputc/rpmsg_input.c input driver over +rpmsg. For NXP i.MX7ULP EVK platform, all sensors connect with +M4, A core access sensor should communicate with M4 core by rpmsg +bus. + +Required properties: + - compatible = "fsl,rpmsg-input"; + +Examples: + rpmsg_sensor: rpmsg-sensor { + compatible = "fsl,rpmsg-input"; + }; diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig index dd968685d278..f81b4224e95b 100644 --- a/drivers/input/misc/Kconfig +++ b/drivers/input/misc/Kconfig @@ -870,6 +870,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 3d24dd327fa7..34a877d4a09c 100644 --- a/drivers/input/misc/Makefile +++ b/drivers/input/misc/Makefile @@ -84,3 +84,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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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"); diff --git a/drivers/rpmsg/imx_rpmsg.c b/drivers/rpmsg/imx_rpmsg.c index 267aca98af49..c52632deeb4d 100644 --- a/drivers/rpmsg/imx_rpmsg.c +++ b/drivers/rpmsg/imx_rpmsg.c @@ -54,7 +54,7 @@ struct imx_rpmsg_vproc { char *rproc_name; struct mutex lock; int vdev_nums; -#define MAX_VDEV_NUMS 7 +#define MAX_VDEV_NUMS 8 struct imx_virdev ivdev[MAX_VDEV_NUMS]; void __iomem *mu_base; struct delayed_work rpmsg_work; diff --git a/include/linux/imx_rpmsg.h b/include/linux/imx_rpmsg.h index 8b448bd1c72f..cabb6d6e03ce 100644 --- a/include/linux/imx_rpmsg.h +++ b/include/linux/imx_rpmsg.h @@ -29,6 +29,7 @@ #define IMX_RPMSG_KEY 4 #define IMX_RPMSG_GPIO 5 #define IMX_RPMSG_RTC 6 +#define IMX_RPMSG_SENSOR 7 /* rpmsg version */ #define IMX_RMPSG_MAJOR 1 #define IMX_RMPSG_MINOR 0