diff options
author | Fugang Duan <fugang.duan@nxp.com> | 2018-03-16 14:07:05 +0800 |
---|---|---|
committer | Leonard Crestez <leonard.crestez@nxp.com> | 2018-08-24 12:41:33 +0300 |
commit | 0ebe9c9f6952d8f3a0f45c7b9d03a0ab089aca25 (patch) | |
tree | e3dd7c69aaff3b1931867e647fcc0c7cd3cf0106 /drivers/input/misc | |
parent | e0898567b1a7afd935fc28f07dce1feca72ea824 (diff) |
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>
Diffstat (limited to 'drivers/input/misc')
-rw-r--r-- | drivers/input/misc/Kconfig | 10 | ||||
-rw-r--r-- | drivers/input/misc/Makefile | 1 | ||||
-rw-r--r-- | drivers/input/misc/rpmsg_input.c | 528 |
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"); |