/*
 * 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");