//#define DEBUG

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <linux/of_platform.h>
#include <linux/of_gpio.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/module.h>
#include <linux/device.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/fs.h>
#include <linux/timer.h>
#include <linux/jiffies.h>

static struct timer_list mytimer;
static unsigned int hw_margin = 3;
static int khadas_input_pin;
static unsigned int khadas_enble = 1;

static void time_pre(struct timer_list *timer)
{
	static unsigned int flag=0;
    flag = !flag;
	gpio_direction_output(khadas_input_pin, flag);

    //printk("%s\n", __func__);
    mytimer.expires = jiffies + hw_margin * HZ/1000;  // 500ms 运行一次
	if(khadas_enble)
		mod_timer(&mytimer, mytimer.expires);
}

/*
static void wdt_exit(void)
{
    if(timer_pending(&mytimer))
    {
        del_timer(&mytimer);
    }
    printk("exit Success \n");
}*/

static ssize_t show_enble(struct class *cls,
				struct class_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", khadas_enble);
}

static ssize_t store_enble(struct class *cls, struct class_attribute *attr,
		        const char *buf, size_t count)
{
	int enable;

	if (kstrtoint(buf, 0, &enable)){
		printk("khadas_enble error\n");
		return -EINVAL;
	}
	printk("khadas_enble=%d\n",enable);
	khadas_enble = enable;
	if(khadas_enble){
		mytimer.expires = jiffies + hw_margin * HZ/1000;  // 500ms 运行一次
		mod_timer(&mytimer, mytimer.expires);
	}
	return count;
}

static ssize_t store_pin_out(struct class *cls, struct class_attribute *attr,
		        const char *buf, size_t count)
{
	int enable;

	if (kstrtoint(buf, 0, &enable)){
		printk("khadas_pin_out error\n");
		return -EINVAL;
	}
	printk("khadas_pin_out=%d\n",enable);
	gpio_direction_output(khadas_input_pin, enable);
	return count;
}

static struct class_attribute khadas_attrs[] = {
	__ATTR(enble, 0644, show_enble, store_enble),
	__ATTR(pin_out, 0644, NULL, store_pin_out),
};

static void create_khadas_attrs(void)
{
	int i;
	struct class *khadas_class;
	printk("%s\n",__func__);
	khadas_class = class_create(THIS_MODULE, "khadas");
	if (IS_ERR(khadas_class)) {
		pr_err("create khadas_class debug class fail\n");
		return;
	}
	for (i = 0; i < ARRAY_SIZE(khadas_attrs); i++) {
		if (class_create_file(khadas_class, &khadas_attrs[i]))
			pr_err("create khadas attribute %s fail\n", khadas_attrs[i].attr.name);
	}
}

static int wdt_probe(struct platform_device *pdev)
{
	const char *value;
	int ret;
	printk("hw_wdt enter probe\n");

	ret = of_property_read_u32(pdev->dev.of_node,"hw_margin_ms", &hw_margin);
	if (ret)
		return ret;

	ret = of_property_read_string(pdev->dev.of_node,
					  "hw-gpios", &value);
	if (ret) {
		printk("no hw-gpios");
		return -1;
	} else {
		khadas_input_pin = of_get_named_gpio_flags
						(pdev->dev.of_node,
						"hw-gpios",
						0, NULL);
		printk("hlm hw-gpios: %d.\n", khadas_input_pin);
		ret = gpio_request(khadas_input_pin, "khadas");
	}

    timer_setup(&mytimer, time_pre, 0);
    mytimer.expires = jiffies + hw_margin * HZ/1000; //// 5ms 运行一次
    add_timer(&mytimer);
	create_khadas_attrs();
	return 0;
}

static const struct of_device_id hw_khadas_wdt_dt_ids[] = {
	{ .compatible = "linux,wdt-khadas", },
	{ }
};
MODULE_DEVICE_TABLE(of, hw_khadas_wdt_dt_ids);

static struct platform_driver khadas_wdt_driver = {
	.driver	= {
		.name		= "hw_khadas_wdt",
		.of_match_table	= hw_khadas_wdt_dt_ids,
	},
	.probe	= wdt_probe,
};

static int __init wdt_drv_init(void)
{
	return platform_driver_register(&khadas_wdt_driver);
}
arch_initcall(wdt_drv_init);

MODULE_LICENSE("GPL");