#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <linux/uaccess.h>
#include <asm/io.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>

#define GPIOLED_CNT 1
#define GPIOLED_NAME "gpioled0"

/* dtsled 设备结构体 */
struct gpioled_dev {
	dev_t devid; /* 设备号 */
	struct cdev cdev; /* cdev */
	struct class *class; /* 类 */
	struct device *device; /* 设备 */
	int major; /* 主设备号 */
	int minor; /* 次设备号 */
	struct device_node *nd; /* 设备节点 */
	int led_gpio; /* LED 所使用的 GPIO 编号 */
};

static struct gpioled_dev gpioled; /* led 设备 */

static int led_open(struct inode *inode, struct file *filp)
{
	filp->private_data = &gpioled; /* 设置私有数据 */
	return 0;
}

static ssize_t led_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt)
{
	return 0;
}

static ssize_t led_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
{
	int ret;
	char kern_buf[1];
	struct gpioled_dev* pgpioled=(struct gpioled_dev*)filp->private_data;

	ret = copy_from_user(kern_buf, buf, cnt); // 得到应用层传递过来的数据
	if(0 > ret) {
		printk(KERN_ERR "kernel write failed!\r\n");
		return -EFAULT;
	}

	if (0 == kern_buf[0])
		gpio_set_value(pgpioled->led_gpio, 0); // 如果传递过来的数据是 0 则关闭 led
	else if (1 == kern_buf[0])
		gpio_set_value(pgpioled->led_gpio, 1); // 如果传递过来的数据是 1 则点亮 led

	return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
return 0;
}

/* 设备操作函数 */
static struct file_operations gpioled_fops = {
.owner = THIS_MODULE,
.open = led_open,
.read = led_read,
.write = led_write,
.release = led_release,
};

static int __init led_init(void)
{
	const char *str;
	int ret;

	/* 1.获取 led 设备节点 */
	gpioled.nd = of_find_node_by_path("/leds/led0");
	if(NULL == gpioled.nd) {
		printk(KERN_ERR "gpioled: Failed to get /led node\n");
		return -EINVAL;
	}

	/* 2.读取 status 属性 */
	ret = of_property_read_string(gpioled.nd, "status", &str);
	if(!ret) {
		if (strcmp(str, "okay"))
			return -EINVAL;
	}

	/* 2、获取 label 属性值并进行匹配 */
	ret = of_property_read_string(gpioled.nd, "label", &str);
	if(0 > ret) {
		printk(KERN_ERR "gpioled: Failed to get compatible property\n");
		return ret;
	}

	if (strcmp(str, "ps_led")) {
		printk(KERN_ERR "gpioled: Compatible match failed\n");
		return -EINVAL;
	}

	printk(KERN_INFO "gpioled: device matching successful!\r\n");

	/* 4.获取设备树中的 led-gpio 属性，得到 LED 所使用的 GPIO 编号 */
	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
	if(!gpio_is_valid(gpioled.led_gpio)) {
		printk(KERN_ERR "gpioled: Failed to get led-gpio\n");
		return -EINVAL;
	}

	printk(KERN_INFO "gpioled: led-gpio num = %d\r\n", gpioled.led_gpio);

	/* 5.向 gpio 子系统申请使用 GPIO */
	ret = gpio_request(gpioled.led_gpio, "LED-GPIO");
	if (ret) {
		printk(KERN_ERR "gpioled: Failed to request led-gpio\n");
		return ret;
	}

	/* 6.将 led gpio 管脚设置为输出模式 */
	gpio_direction_output(gpioled.led_gpio, 0);

	/* 7.初始化 LED 的默认状态 */
	ret = of_property_read_string(gpioled.nd, "default-state", &str);
	if(!ret) {
		if (!strcmp(str, "on"))
			gpio_set_value(gpioled.led_gpio, 1);
		else
			gpio_set_value(gpioled.led_gpio, 0);
	} else
		gpio_set_value(gpioled.led_gpio, 0);

	/* 8.注册字符设备驱动 */
	/* 创建设备号 */
	if (gpioled.major) {
		gpioled.devid = MKDEV(gpioled.major, 0);
		ret = register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
		if (ret)
			goto out1;
	} else {
		ret = alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);
		if (ret)
			goto out1;

		gpioled.major = MAJOR(gpioled.devid);
		gpioled.minor = MINOR(gpioled.devid);
	}

	printk("gpioled: major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);

	/* 初始化 cdev */
	gpioled.cdev.owner = THIS_MODULE;
	cdev_init(&gpioled.cdev, &gpioled_fops);

	/* 添加一个 cdev */
	ret = cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
	if (ret)
		goto out2;

	/* 创建类 */
	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
	if (IS_ERR(gpioled.class)) {
		ret = PTR_ERR(gpioled.class);
		goto out3;
	}

	/* 创建设备 */
	gpioled.device = device_create(gpioled.class, NULL,
	gpioled.devid, NULL, GPIOLED_NAME);
	if (IS_ERR(gpioled.device)) {
		ret = PTR_ERR(gpioled.device);
		goto out4;
	}
	return 0;

out4:
	class_destroy(gpioled.class);

out3:
	cdev_del(&gpioled.cdev);

out2:
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);

out1:
	gpio_free(gpioled.led_gpio);

return ret;
}

static void __exit led_exit(void)
{
	/* 注销设备 */
	device_destroy(gpioled.class, gpioled.devid);

	/* 注销类 */
	class_destroy(gpioled.class);

	/* 删除 cdev */
	cdev_del(&gpioled.cdev);

	/* 注销设备号 */
	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT);

	/* 释放 GPIO */
	gpio_free(gpioled.led_gpio);
}

/* 驱动模块入口和出口函数注册 */
module_init(led_init);
module_exit(led_exit);

MODULE_AUTHOR("LO");
MODULE_DESCRIPTION("LO ZYNQ GPIO LED Driver");
MODULE_LICENSE("GPL");

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>

/*
* @description : main 主程序
* @param - argc : argv 数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd, ret;
unsigned char buf[1];

if(3 != argc) {
printf("Usage:\n"
"\t./ledApp /dev/led 1 @ close LED\n"
"\t./ledApp /dev/led 0 @ open LED\n"
);
return -1;
}

/* 打开设备 */
fd = open(argv[1], O_RDWR);
if(0 > fd) {
printf("file %s open failed!\r\n", argv[1]);
return -1;
}

/* 将字符串转换为 int 型数据 */
buf[0] = atoi(argv[2]);

/* 向驱动写入数据 */
ret = write(fd, buf, sizeof(buf));
if(0 > ret){
printf("LED Control Failed!\r\n");
close(fd);
return -1;
}

/* 关闭设备 */
close(fd);
return 0;
}