// SPDX-License-Identifier: GPL-2.0
/*
 * Rockchip driver for IR-Cuter
 *
 * Copyright (C) 2020 Fuzhou Rockchip Electronics Co., Ltd.
 *
 * V0.0X01.0X00 first version.
 */
#include <linux/io.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/completion.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>
#include <linux/platform_device.h>
#include <media/v4l2-subdev.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-device.h>
#include <linux/fs.h>
#include <linux/version.h>
#include <linux/rk-camera-module.h>

#define RK_IRCUT_NAME "ircut"
#define DRIVER_VERSION	KERNEL_VERSION(0, 0x01, 0x00)

//#define USED_SYS_DEBUG

enum IRCUT_STATE_e {
	IRCUT_STATE_CLOSED,
	IRCUT_STATE_CLOSING,
	IRCUT_STATE_OPENING,
	IRCUT_STATE_OPENED,
};

struct ircut_op_work {
	struct work_struct work;
	int op_cmd;
	struct ircut_dev *dev;
};

struct ircut_drv_data {
	int	(*parse_dt)(struct ircut_dev *ircut, struct device_node *node);
	void	(*ctrl)(struct ircut_dev *ircut, int cmd);
};

struct ircut_dev {
	struct v4l2_subdev sd;
	struct v4l2_ctrl_handler ctrl_handler;
	struct device *dev;
	struct completion complete;
	/* state mutex */
	struct mutex mut_state;
	enum IRCUT_STATE_e state;
	struct workqueue_struct *wq;
	int pulse_width;
	int val;
	struct gpio_desc *open_gpio;
	struct gpio_desc *close_gpio;
	struct gpio_desc *led_gpio;
	u32 module_index;
	const char *module_facing;
	const struct ircut_drv_data *drv_data;
};

#define IRCUT_STATE_EQ(expected) \
	((ircut->state == (expected)) ? true : false)

static int ap1511a_parse_dt(struct ircut_dev *ircut, struct device_node *node)
{
	ircut->open_gpio = devm_gpiod_get(ircut->dev, "ircut-open", GPIOD_OUT_HIGH);
	if (IS_ERR(ircut->open_gpio)) {
		dev_err(ircut->dev, "Failed to get ircut-open-gpios\n");
		return PTR_ERR(ircut->open_gpio);
	}

	ircut->led_gpio = devm_gpiod_get_optional(ircut->dev, "led", GPIOD_OUT_LOW);
	if (IS_ERR(ircut->led_gpio))
		dev_err(ircut->dev, "Failed to get led-gpios\n");

	return 0;
}

static void ap1511a_ctrl(struct ircut_dev *ircut, int cmd)
{
	if (cmd > 0) {
		gpiod_set_value_cansleep(ircut->open_gpio, 1);
		if (!IS_ERR(ircut->led_gpio))
			gpiod_set_value_cansleep(ircut->led_gpio, 0);
	} else {
		gpiod_set_value_cansleep(ircut->open_gpio, 0);
		if (!IS_ERR(ircut->led_gpio))
			gpiod_set_value_cansleep(ircut->led_gpio, 1);
	}
}

static int ba6208_parse_dt(struct ircut_dev *ircut, struct device_node *node)
{
	int ret;

	dev_dbg(ircut->dev, "ircut_gpio_parse_dt");
	ret = of_property_read_u32(node,
		"rockchip,pulse-width",
		&ircut->pulse_width);
	if (ret != 0) {
		ircut->pulse_width = 100;
		dev_err(ircut->dev,
			"failed get pulse-width,use dafult value 100\n");
	}
	if (ircut->pulse_width > 2000) {
		ircut->pulse_width = 300;
		dev_info(ircut->dev,
			"pulse width to long,use default dafult 300");
	}
	dev_dbg(ircut->dev, "pulse-width value from dts %d\n",
		ircut->pulse_width);
	/* get ircut open gpio */
	ircut->open_gpio = devm_gpiod_get(ircut->dev, "ircut-open", GPIOD_OUT_LOW);
	if (IS_ERR(ircut->open_gpio))
		dev_err(ircut->dev, "Failed to get ircut-open-gpios\n");

	/* get ircut close gpio */
	ircut->close_gpio = devm_gpiod_get(ircut->dev,
				"ircut-close", GPIOD_OUT_LOW);
	if (IS_ERR(ircut->close_gpio))
		dev_err(ircut->dev, "Failed to get ircut-close-gpios\n");

	/* get led gpio */
	ircut->led_gpio = devm_gpiod_get_optional(ircut->dev, "led", GPIOD_OUT_LOW);
	if (IS_ERR(ircut->led_gpio))
		dev_err(ircut->dev, "Failed to get led-gpios\n");

	return 0;
}

static void ba6208_ctrl(struct ircut_dev *ircut, int cmd)
{
	if (cmd > 0) {
		if (!IS_ERR(ircut->open_gpio))
			gpiod_set_value_cansleep(ircut->open_gpio, 1);
		msleep(ircut->pulse_width);
		if (!IS_ERR(ircut->open_gpio))
			gpiod_set_value_cansleep(ircut->open_gpio, 0);
		if (!IS_ERR(ircut->led_gpio))
			gpiod_set_value_cansleep(ircut->led_gpio, 0);
	} else {
		if (!IS_ERR(ircut->close_gpio))
			gpiod_set_value_cansleep(ircut->close_gpio, 1);
		msleep(ircut->pulse_width);
		if (!IS_ERR(ircut->close_gpio))
			gpiod_set_value_cansleep(ircut->close_gpio, 0);
		if (!IS_ERR(ircut->led_gpio))
			gpiod_set_value_cansleep(ircut->led_gpio, 1);
	}
}

static void ircut_op_work(struct work_struct *work)
{
	struct ircut_op_work *wk =
		container_of(work, struct ircut_op_work, work);
	struct ircut_dev *ircut = wk->dev;
	enum IRCUT_STATE_e state;

	if (ircut->drv_data->ctrl)
		ircut->drv_data->ctrl(ircut, wk->op_cmd);

	state = (wk->op_cmd > 0) ? IRCUT_STATE_OPENED : IRCUT_STATE_CLOSED;
	mutex_lock(&ircut->mut_state);
	complete(&ircut->complete);
	ircut->state = state;
	mutex_unlock(&ircut->mut_state);
	kfree(wk);
	wk = NULL;
}

static int ircut_operation(struct ircut_dev *ircut, int op)
{
	struct ircut_op_work *wk = NULL;
	bool should_wait = false;
	bool do_nothing = false;
	enum IRCUT_STATE_e old_state;

	dev_dbg(ircut->dev, "%s, status %d\n", __func__, op);
	mutex_lock(&ircut->mut_state);
	old_state = ircut->state;
	if (op > 0) {
		/* check state */
		if (IRCUT_STATE_EQ(IRCUT_STATE_OPENING) ||
			IRCUT_STATE_EQ(IRCUT_STATE_OPENED)) {
			/* already in opening or opened state, do nothing */
			do_nothing = true;
		} else if (IRCUT_STATE_EQ(IRCUT_STATE_CLOSING)) {
			/* in closing state,should wait */
			should_wait = true;
		} else {
			/* in closed state,queue work */
		}
	} else {
		/* check state */
		if (IRCUT_STATE_EQ(IRCUT_STATE_CLOSING) ||
			IRCUT_STATE_EQ(IRCUT_STATE_CLOSED)) {
			/* already in closing or closed state, do nothing */
			do_nothing = true;
		} else if (IRCUT_STATE_EQ(IRCUT_STATE_OPENING)) {
			/* in opening state,should wait */
			should_wait = true;
		} else {
			/* in opened state,queue work */
		}
	}
	mutex_unlock(&ircut->mut_state);
	if (do_nothing)
		goto op_done;
	if (should_wait)
		wait_for_completion(&ircut->complete);
	wk = kmalloc(sizeof(*wk),
		GFP_KERNEL);
	if (!wk) {
		dev_err(ircut->dev, "failed to alloc ircut work struct\n");
		goto err_ircut_operation;
	}
	wk->op_cmd = op;
	wk->dev = ircut;
	mutex_lock(&ircut->mut_state);
	if (op > 0)
		ircut->state = IRCUT_STATE_OPENING;
	else
		ircut->state = IRCUT_STATE_CLOSING;
	reinit_completion(&ircut->complete);
	mutex_unlock(&ircut->mut_state);
	/* queue work */
	INIT_WORK(&wk->work, ircut_op_work);
	if (!queue_work(ircut->wq, &wk->work)) {
		dev_err(ircut->dev, "queue work failed\n");
		kfree(wk);
		ircut->state = old_state;
		goto err_ircut_operation;
	}
op_done:
	return 0;
err_ircut_operation:
	return -1;
}

#ifdef USED_SYS_DEBUG
static ssize_t set_ircut_status(struct device *dev,
	struct device_attribute *attr,
	const char *buf,
	size_t count)
{
	struct ircut_dev *ircut = dev_get_drvdata(dev);
	int status = 0;
	int ret = 0;

	ret = sscanf(buf, "%d", &status);
	if (ret)
		ircut_operation(ircut, status);
	return count;
}

static struct device_attribute attributes[] = {
	__ATTR(sys_set_ircut, S_IWUSR, NULL, set_ircut_status),
};

static int add_sysfs_interfaces(struct device *dev)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(attributes); i++)
		if (device_create_file(dev, attributes + i))
			goto undo;
	return 0;
undo:
	for (i--; i >= 0 ; i--)
		device_remove_file(dev, attributes + i);
	dev_err(dev, "%s: failed to create sysfs interface\n", __func__);
	return -ENODEV;
}
#endif

static int ircut_s_ctrl(struct v4l2_ctrl *ctrl)
{
	int ret = -EINVAL;
	struct ircut_dev *ircut = container_of(ctrl->handler,
					     struct ircut_dev, ctrl_handler);

	if (ctrl->id == V4L2_CID_BAND_STOP_FILTER) {
		ret = ircut_operation(ircut, ctrl->val);
		if (ret == 0)
			ircut->val = ctrl->val;
	}
	return ret;
}

static long ircut_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
{
	return -EINVAL;
}

static const struct v4l2_subdev_core_ops ircut_core_ops = {
	.ioctl = ircut_ioctl,
};

static const struct v4l2_subdev_ops ircut_subdev_ops = {
	.core	= &ircut_core_ops,
};

static const struct v4l2_ctrl_ops ircut_ctrl_ops = {
	.s_ctrl = ircut_s_ctrl,
};

static const struct ircut_drv_data ap1511a_drv_data = {
	.parse_dt	= ap1511a_parse_dt,
	.ctrl		= ap1511a_ctrl,
};

static const struct ircut_drv_data ba6208_drv_data = {
	.parse_dt	= ba6208_parse_dt,
	.ctrl		= ba6208_ctrl,
};

#if defined(CONFIG_OF)
static const struct of_device_id ircut_of_match[] = {
	{ .compatible = "rockchip,ircut",
		.data = &ba6208_drv_data },
	{ .compatible = "ap1511a,ircut",
		.data = &ap1511a_drv_data },
	{},
};
MODULE_DEVICE_TABLE(of, ircut_of_match);
#endif

static int ircut_probe(struct platform_device *pdev)
{
	struct ircut_dev *ircut = NULL;
	struct device_node *node = pdev->dev.of_node;
	struct v4l2_ctrl_handler *handler;
	const struct of_device_id *match;
	int ret = 0;
	struct v4l2_subdev *sd;
	char facing[2];

	dev_info(&pdev->dev, "driver version: %02x.%02x.%02x",
		DRIVER_VERSION >> 16,
		(DRIVER_VERSION & 0xff00) >> 8,
		DRIVER_VERSION & 0x00ff);
	ircut = devm_kzalloc(&pdev->dev, sizeof(*ircut), GFP_KERNEL);
	if (!ircut) {
		dev_err(&pdev->dev, "alloc ircut failed\n");
		return -ENOMEM;
	}

	match = of_match_node(ircut_of_match, pdev->dev.of_node);
	if (!match)
		return -ENODEV;

	ircut->drv_data = match->data;

	ret = of_property_read_u32(node, RKMODULE_CAMERA_MODULE_INDEX,
				   &ircut->module_index);
	ret |= of_property_read_string(node, RKMODULE_CAMERA_MODULE_FACING,
				       &ircut->module_facing);
	if (ret) {
		dev_err(&pdev->dev,
			"could not get module information!\n");
		return -EINVAL;
	}
	ircut->dev = &pdev->dev;
	mutex_init(&ircut->mut_state);
	init_completion(&ircut->complete);
	ircut->wq = alloc_workqueue("ircut wq",
			WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
	v4l2_subdev_init(&ircut->sd, &ircut_subdev_ops);
	ircut->sd.owner = pdev->dev.driver->owner;
	ircut->sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
	ircut->sd.dev = &pdev->dev;
	v4l2_set_subdevdata(&ircut->sd, pdev);
	platform_set_drvdata(pdev, &ircut->sd);

	handler = &ircut->ctrl_handler;
	ret = v4l2_ctrl_handler_init(handler, 1);
	if (ret)
		return ret;
	v4l2_ctrl_new_std(handler, &ircut_ctrl_ops,
		V4L2_CID_BAND_STOP_FILTER, 0, 4, 1, 1);
	if (handler->error) {
		ret = handler->error;
		dev_err(&pdev->dev, "Failed to init controls(%d)\n", ret);
		goto err_free;
	}
	ircut->sd.ctrl_handler = handler;
	ret = media_entity_pads_init(&ircut->sd.entity, 0, NULL);
	if (ret < 0)
		goto err_free;

	if (ircut->drv_data->parse_dt) {
		ret = ircut->drv_data->parse_dt(ircut, node);
		if (ret)
			goto err_free;
	}

	sd = &ircut->sd;
	sd->entity.function = MEDIA_ENT_F_LENS;
	sd->entity.flags = 1;

	memset(facing, 0, sizeof(facing));
	if (strcmp(ircut->module_facing, "back") == 0)
		facing[0] = 'b';
	else
		facing[0] = 'f';

	snprintf(sd->name, sizeof(sd->name), "m%02d_%s_%s",
		 ircut->module_index, facing,
		 RK_IRCUT_NAME);
	ret = v4l2_async_register_subdev(sd);
	if (ret)
		dev_err(&pdev->dev, "v4l2 async register subdev failed\n");

	/* set default state to open */
	ircut_operation(ircut, 3);
	ircut->val = 3;
#ifdef USED_SYS_DEBUG
	add_sysfs_interfaces(ircut->dev);
#endif
	dev_info(&pdev->dev, "probe successful!");
	return 0;

err_free:
	v4l2_ctrl_handler_free(handler);
	v4l2_device_unregister_subdev(&ircut->sd);
	media_entity_cleanup(&ircut->sd.entity);
	return ret;
}

static int ircut_drv_remove(struct platform_device *pdev)
{
	struct v4l2_subdev *sd = platform_get_drvdata(pdev);
	struct ircut_dev *ircut = NULL;

	if (sd)
		ircut = v4l2_get_subdevdata(sd);
	if (ircut && ircut->wq)
		drain_workqueue(ircut->wq);
	if (sd)
		v4l2_device_unregister_subdev(sd);
	v4l2_ctrl_handler_free(&ircut->ctrl_handler);
	media_entity_cleanup(&ircut->sd.entity);
	return 0;
}

static struct platform_driver ircut_driver = {
	.driver = {
		.name = RK_IRCUT_NAME,
		.of_match_table = of_match_ptr(ircut_of_match),
	},
	.probe = ircut_probe,
	.remove = ircut_drv_remove,
};

module_platform_driver(ircut_driver);

MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:rockchip-ircut");
MODULE_AUTHOR("ROCKCHIP");