blob: 8f3d07b59ef00ec7f1659aea9633064e2154babd [file] [log] [blame]
/*
* 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");