【IMX6ULL驱动开发学习】12.Linux驱动之设备树_正点原子linux开发板imx6ull 设备树

承接上一篇博客 【IMX6ULL驱动开发学习】11.驱动设计之面向对象_分层思想（学习设备树过渡部分）

代码获取：https://gitee.com/chenshao777/imx6-ull_-drivers
我后面将三个层合并了（实际上只有前两层），合并成一个dev_drv.c了，暂时没有加GPIO操作，只是个框架
合并前的代码在 11.button_drv_chip_device-tree 文件夹中
合并后的代码在 12.led_button_drv_tree 文件夹中，文章最后把代码贴出来

打算在第13次代码中加入GPIO子系统的代码，并且根据Pinctrl子系统编写设备树，使得外设控制更简单，敬请期待哦！

---

之前我们将驱动程序分为了三层
1、驱动框架程序， 包含 file_operations 结构体（内核自带）

2、硬件操作程序， 包含 chip_operations 结构体（自定义，初始化和操作GPIO），包含 platform_driver 结构体（内核自带，提取具体的引脚）

3、硬件资源定义程序， 包含 platform_device 结构体（内核自带，resource 成员中了指定了具体的GPIO引脚）

---

设备树的引入

像上面第三层那样定义硬件资源还是太麻烦，有没有一种更便捷的方式呢？
有，设备树！

1、修改设备树
介绍设备树语法的博客有很多，这就不做赘述了
直接介绍如何使用设备树来定义硬件资源吧！
以正点原子IMX6ULL阿尔法开发板来举例，首先找到你目前所使用的设备树文件
路径如下

linux内核文件名/arch/arm/boot/dts/imx6ull-alientek-emmc.dtd
1

后缀为 dtb 的是二进制的设备树文件，我们需要修改它，那么真正要操作的是其对应的 dts 文件，即 imx6ull-alientek-emmc.dts，使用任意工具打开，我这里使用 gedit 文本编辑器打开。

接着在根节点下添加自己的设备节点即可，例如

---

2、编译设备树

回到Linux内核目录下，执行命令

make dtbs
1

只要更改了 dts 文件，就会重新编译生成新的 dtb 文件，然后使用 uboot 网络加载方式加载新的设备树 设置uboot使用网络加载zImage和dtb

即可替换成新的设备树了，如何查看是否替换成功呢
查看是否有我们自己添加的设备节点就行了，输入命令

ls /proc/device-tree
1

可以看到我后来添加的三个节点，第一步成功！

3、修改硬件操作程序的 platform_driver 结构体

（1）platform_driver 结构体添加 of_match_table 属性，添加 of_device_id 结构体，匹配设备树

（2）在 probe 函数中提取设备树中的引脚，提取设备树节点中的属性（of_property_read_u32等函数）

其他地方都不用修改，下次想添加外设时，直接修改设备树，然后修改 of_device_id 结构体即可

---

三层合并后的代码（实际上是两层合并后）OK，写完，晚安了各位！

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/platform_device.h>
#include <linux/of.h>

int major;				//设备号
static struct class *my_dev_class;
int dev_cnt;
int dev_pins[10];

/*=============================file_operations ==============================*/
static ssize_t my_drv_read (struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
	printk("drv_read function run....\n");
	return 1;
}

static ssize_t my_drv_write (struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
	printk("drv_write function run....\n");
	return 0;
}

static int my_drv_open (struct inode *node, struct file *filp)
{
	printk("drv_open function run....\n");
	return 0;
}

static int my_drv_release (struct inode *node, struct file *filp)
{

	printk("drv_release function run....\n");
	return 0;
}

/* operations结构体：为应用层提供驱动接口 */
static struct file_operations my_dev_ops = {
	.owner		= 	THIS_MODULE,
	.read 		=	my_drv_read,
	.write		=	my_drv_write,
	.open		=	my_drv_open,
	.release	=	my_drv_release,
};

/*=============================platform_driver==============================*/
/*  如果匹配到了内核根据设备树生成的platform_device，
	该函数会被调用，如果有多个匹配的设备节点，该函数
	会被多次调用
*/
static int my_probe(struct platform_device *pdev)
{
	/*  从内核根据设备树生成的 platform_device 
		结构体中获取到设备节点
	*/
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;
	
	int pin;
	char a[20];
	const char *str = a;
	
	of_property_read_u32(np, "pin", &pin);
	of_property_read_string(np, "my_name", &str);

	//保存设备的引脚
	dev_pins[dev_cnt] = pin;  
	//创建设备节点 /dev/xxx
	device_create(my_dev_class, NULL, MKDEV(major, dev_cnt), NULL, str);
	dev_cnt++;

	printk("my_probe run, my_name = %s\n", str);
	
	return 0;
}

static int my_remove(struct platform_device *pdev)
{
	/*  从内核根据设备树生成的 platform_device 
		结构体中获取到设备节点
	*/
	struct device *dev = &pdev->dev;
	struct device_node *np = dev->of_node;
	
	int pin, i;
	char a[20];
	const char *str = a;
	
	of_property_read_u32(np, "pin", &pin);
	of_property_read_string(np, "my_name", &str);

	for(i = 0; i < dev_cnt; i++){
		if(dev_pins[i] == pin){
			dev_pins[i] = -1;
			device_destroy(my_dev_class, MKDEV(major, i));
			break;
		}
	}
	
	printk("my_remove run, device_destroy %s\n", str);
	return 0;
}

static struct of_device_id my_dev_match[] = {
	{.compatible = "hc-led-beep"}, 
	{.compatible = "hc-led-beep"}, 
	{.compatible = "hc-key"}, 
	{},
};

static struct platform_driver dev_driver = {
	.probe		=	my_probe,	
	.remove		= 	my_remove,
	.driver		= {
		.name	= "my_platform_driver",
		.of_match_table = my_dev_match,
	},
};

/*=============================驱动出入口函数==============================*/
/* 驱动入口函数：insmod xx.ko 时会被调用 */
static int dev_init(void)
{	
	major = register_chrdev(0, "hc_dev_drv", &my_dev_ops);
	if(major < 0){
		printk("register_chrdev famy\n");
		return major;
	}

	my_dev_class = class_create
(THIS_MODULE, "my_dev_class");
	if(IS_ERR(my_dev_class)){
		printk("class_create failed\n");
		return 1;
	}

	platform_driver_register(&dev_driver);

	return 0;
}

/* 驱动出口函数： rmmod xx.ko 时会被调用 */
static void dev_exit(void)
{
	platform_driver_unregister(&dev_driver);
	class_destroy(my_dev_class);
	unregister_chrdev(major, "hc_dev_drv");
	printk("my_dev driver exit\n");
}

module_init(dev_init);
module_exit(dev_exit);
MODULE_LICENSE("GPL");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154