/*
 * PWM driver for Rockchip SoCs
 */

//original include file
#include <linux/module.h>
#include <linux/pwm.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>

//#include <dt-bindings/pwm/pwm.h>
#include <linux/platform_device.h>
#include <asm/io.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/init.h>

//creat proc directory and file
#include <linux/proc_fs.h>
#include <linux/kernel.h>

//print driver information
#define PWM_INFO(fmt,arg...)          // printk("<<-PWM-INFO->> "fmt"\n",##arg)

static unsigned int gval = 0;
struct rp_pwm_data {
	int     pwm_id;
	struct pwm_device       *pwm;
	unsigned int            period;
	unsigned int pwm_period_ns;
	unsigned int max_period;
	unsigned int min_period;
	unsigned int duty_ns;
	bool	enabled;
};
struct rp_pwm_data g_rpdzkj_pdata;

static int pwm_open(struct inode *inode, struct file *file)
{
	PWM_INFO("here is %s", __func__);
	
	return 0;
}
static ssize_t  pwm_write(struct file *file, const char *buffer,size_t count, loff_t *data)
{
	char buf[7] = {0};		//maxmum is 10000, and the str include a single newline before its terminating null, so be sizeof(10000)+2(\n\0)
	unsigned long state;
	int tmp_duty,ret;

	PWM_INFO("here is %s", __func__);
	
	if(copy_from_user(buf,buffer,count)){
		printk("failed to copy data to kernel space\n");
		return -EFAULT;     
	}
	PWM_INFO("buf is %s, size is %ld", buf, sizeof(buf));
	
	ret = kstrtoul(buf, 10, &state);
	if (ret){
		PWM_INFO("str_to_ul_faild!");
		return ret;
	}
	if (state > g_rpdzkj_pdata.max_period)
		state = g_rpdzkj_pdata.max_period;
	else if (state < g_rpdzkj_pdata.min_period)
		state = g_rpdzkj_pdata.min_period;
	tmp_duty = state;

	g_rpdzkj_pdata.enabled = true;
	pwm_config(g_rpdzkj_pdata.pwm, tmp_duty, g_rpdzkj_pdata.pwm_period_ns);
	pwm_enable(g_rpdzkj_pdata.pwm);
	gval = tmp_duty;

	return count;
	
}
static ssize_t  pwm_read(struct file *file, char __user * buffer, size_t count, loff_t *data)
{
	PWM_INFO("here is %s", __func__);
	
	PWM_INFO(":\n\
				duty: %d\n\
				period: %d\n", gval, g_rpdzkj_pdata.pwm_period_ns);
	
	return 0;
}

static const struct file_operations pwm_ops = {
	.owner          = THIS_MODULE,
    .open           = pwm_open,
    .write          = pwm_write,
    .read           = pwm_read,
};

static int rp_pwm_status_update(struct rp_pwm_data *pdata)
{
	if (pdata->enabled)
		return 0;

	pwm_enable(pdata->pwm);
	pwm_config(pdata->pwm, pdata->duty_ns, g_rpdzkj_pdata.pwm_period_ns);
	pdata->enabled = true;
	gval = pdata->duty_ns;
	return 0;
}

ssize_t rp_pwm_parse_dt(struct rp_pwm_data *rp_pdata, struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.of_node;
	const __be32 *id, *min_period, *max_period, *duty_ns;
	int  len;

	id = of_get_property(np, "pwm_id", &len);
	if (id)
		rp_pdata->pwm_id = be32_to_cpu(*id);

	min_period = of_get_property(np, "min_period", &len);
	if (min_period)
		rp_pdata->min_period = be32_to_cpu(*min_period);

	max_period = of_get_property(np, "max_period", &len);
	if (max_period)
		rp_pdata->max_period = be32_to_cpu(*max_period);

	rp_pdata->pwm_period_ns = rp_pdata->max_period - rp_pdata->min_period;

	duty_ns = of_get_property(np, "duty_ns", &len);
	if (duty_ns)
		rp_pdata->duty_ns = be32_to_cpu(*duty_ns);

	return 0;
}









static int rp_pwm_probe(struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.of_node;
	struct rp_pwm_data *rp_pdata = pdev->dev.platform_data;
	int ret;
	static struct proc_dir_entry *root_entry_pwm;

	if (!np) {
		dev_err(&pdev->dev, "Device Tree node missing\n");
		return -EINVAL;
	}

	rp_pdata = devm_kzalloc(&pdev->dev, sizeof(*rp_pdata), GFP_KERNEL);
	if (!rp_pdata)
		return -ENOMEM;

	if (np)
		ret = rp_pwm_parse_dt(rp_pdata, pdev);

	rp_pdata->enabled = false;

	rp_pdata->pwm = pwm_request(rp_pdata->pwm_id, "rp-pwm");
	if (IS_ERR(rp_pdata->pwm)) {
		dev_err(&pdev->dev, "unable to request legacy PWM\n");
		ret = PTR_ERR(rp_pdata->pwm);
		goto err;
	}
	
	if (rp_pdata->pwm_period_ns > 0)
		pwm_set_period(rp_pdata->pwm, rp_pdata->pwm_period_ns);
	rp_pdata->period = pwm_get_period(rp_pdata->pwm);

	g_rpdzkj_pdata = *rp_pdata;
	rp_pwm_status_update(rp_pdata);
	dev_info(&pdev->dev, "%s: rp PWM Demo !\n", __func__);


/*creat folder for operat pwn Conveniently*/
	root_entry_pwm = proc_mkdir("rp_pwm", NULL);
	
	proc_create("rp_pwm1", 0666 , root_entry_pwm , &pwm_ops);

	return 0;
err:
	//pwm_free(rp_pdata->pwm);
	devm_kfree(&pdev->dev, rp_pdata);
	return ret;
}

static int rp_pwm_remove(struct platform_device *pdev)
{
	struct rp_pwm_data *rp_pdata = pdev->dev.platform_data;
	
	pwm_free(rp_pdata->pwm);
	return 0;
}

static const struct of_device_id rp_pwm_dt_ids[] = {
	{ .compatible = "rp_pwm"},
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, rp_pwm_dt_ids);

static struct platform_driver rp_pwm_driver = {
	.driver = {
		.name = "rp_pwm",
		.of_match_table = rp_pwm_dt_ids,
	},
	.probe = rp_pwm_probe,
	.remove = rp_pwm_remove,
};

module_platform_driver(rp_pwm_driver);

MODULE_AUTHOR("rpdzkj Jsomeone");
MODULE_DESCRIPTION("rpdzkj pwm control");
MODULE_LICENSE("GPL v2");