首先引入两个问题：

• 为什么要引入设备树，引入设备树有什么优点
• 设备树如何与驱动匹配

1.设备树的引入

​ 在没有引入设备树之前，如（linux3.0.35），硬件的配置基本都放在板级文件中，内容很繁杂，修改起来也不方便，可移植性差如下图：

可以看到有2569行代码，引入设备树后：只有480行代码

设备树的引入可以方便我们对硬件的移植与修改

2.设备树的优点

a、对于传统字符驱动的编写有两种方式：

一是在驱动程序中，直接写死硬件资源，如：GPIO、寄存器地址、中断号等，使得硬件改动时，必须修改驱动程序。

二是采用总线驱动platform模型，将硬件资源与驱动软件分离，在platform_device中描述硬件资源，arch/arm/mach-xxx对应的文件，便是以platform_device描述各自CPU对应的硬件资源；在platform_driver中分配/设置/注册 file_operations结构体, 并从platform_device获得硬件资源。这种编写方式使得驱动易于扩展，硬件改动时只需修改platform_device或者platform_driver，这就导致linux内核产生大量的冗余代码。

b、 使用设备树的优点在于，在设备树dts文件指定硬件资源，dts被编译为dtb文件, 在启动板子时，U-boot会将dtb文件传给内核，使得驱动程序与硬件分离，我们只需要修改dts文件，便能实现需求。这就是设备树易于扩展，硬件有变动时不需要重新编译内核或驱动程序，只需要提供不一样的dtb文件。

3.设备树与驱动的联系

1、使用设备树之前设备匹配方法

​ 在没有使用设备树以前，uboot 会向 Linux 内核传递一个叫做 machine id 的值，machine id 也就是设备 ID，告诉 Linux 内核自己是个什么设备，看看 Linux 内核是否支持。Linux 内核是支持很多设备的，针对每一个设备(板子)，Linux内核都用MACHINE_START和MACHINE_END来定义一个 machine_desc 结构体来描述这个设备，比如在文件 arch/arm/mach-mx6/board-mx6q_c_sabresd.c中有如下定义

/*
 * initialize __mach_desc_MX6Q_SABRESD data structure.
 */
MACHINE_START(MX6Q_SABRESD, "Freescale i.MX 6Quad/DualLite/Solo Sabre-SD Board")
  /* Maintainer: Freescale Semiconductor, Inc. */
  .boot_params = MX6_PHYS_OFFSET + 0x100,
  .fixup = fixup_mxc_board,
  .map_io = mx6_map_io,
  .init_irq = mx6_init_irq,
  .init_machine = mx6_sabresd_board_init,
  .timer = &mx6_sabresd_timer,
  .reserve = mx6q_sabresd_reserve,
MACHINE_END

​ 上述代码就是定义了“Freescale i.MX 6Quad/DualLite/Solo Sabre-SD Board”这个设备，其中 MACHINE_START 和MACHINE_END 定义在文件 arch/arm/include/asm/mach/arch.h 中，内容如下：

 /*
 * Set of macros to define architecture features.  This is built into
 * a table by the linker.
 */
   #define MACHINE_START(_type,_name)			\
   static const struct machine_desc __mach_desc_##_type	\
    __used							\
    __attribute__((__section__(".arch.info.init"))) = {	\
   .nr		= MACH_TYPE_##_type,		\
   .name		= _name,

将MACHINE_START宏定义展开

.nr=MACH_TYPE_MX6Q_SABRESD
.NAME="Freescale i.MX 6Quad/DualLite/Solo Sabre-SD Board"

MACH_TYPE_MX6Q_SABRESD 就 是 “ Freescale i.MX 6Quad/DualLite/Solo Sabre-SD Board ” 这 个 板 子 的 machine id ，MACH_TYPE_MX6Q_SABRESD 定义在文件include/generated/mach-types.h中，此文件定义了大量的machine id，内容如下所示：

如果uboot传入的machine id在此文件中有定义，相等的话就表示 Linux 内核支持这个设备，如果不支持的话那么这个设备就没法启动 Linux 内核

2、使用设备树以后的设备匹配方法

​ 当 Linux 内 核 引 入 设 备 树 以 后 就 不 再 使 用 MACHINE_START 了 ， 而 是 换 为 了DT_MACHINE_START。DT_MACHINE_START 也定义在文件 arch/arm/include/asm/mach/arch.h里面，定义如下：

​ 可以看出，DT_MACHINE_START 和 MACHINE_START 基本相同，只是.nr 的设置不同，在 DT_MACHINE_START 里面直接将.nr 设置为~0。说明引入设备树以后不会再根据 machine id 来检查 Linux 内核是否支持某个设备了。打开文件 arch/arm/mach-imx/mach-imx6q.c，有如下所示内容：

machine_desc 结构体中有个.dt_compat 成员变量，此成员变量保存着本设备兼容属性，设置.dt_compat = imx6q_dt_compat，imx6q_dt_compat 表里面有"fsl,imx6dl"和"fsl,imx6q"这两个兼容值。只要某个设备(板子)根节点“/”的 compatible 属性值与imx6q_dt_compat 表中的任何一个值相等，那么就表示 Linux 内核支持此设备。imx6q-c-sabresd.dts 中根节点的 compatible 属性值如下：

那每一个硬件设备驱动是如何匹配设备树中的compatible的呢？

​ 这就引入了设备树常用 OF 操作函数，设备树描述了设备的详细信息，驱动需要获取到这些信息，就要用到Linux 内核提供的一些函数，因为这一系列函数有一个统一的前缀“of_”，所以也被叫做OF 函数，OF 函数原型定义在include/linux/of.h 文件中。

例子：led实验（从设备树获取信息）

设备树文件：imx6dl-c-sabresd.dts

在根节点下写了一个xcled节点，将寄存器物理地址写入reg，重新编译dtb文件烧入板子

接下来是驱动文件的编写：

1.用of_find_node_by_path函数来获取设备节点

of_find_node_by_path(“/xcled”);           //获取根节点下xcled节点

2.用of_find_property函数获取compatible 属性内容

of_find_property(dtsled.nd, "compatible", NULL**)

3.用of_property_read_string获取 status 属性内容

ret = of_property_read_string(dtsled.nd, "status", &str);

4.用of_property_read_u32_array获取 reg 属性内容

ret = of_property_read_u32_array(dtsled.nd, "reg", regdata, 10);

of_iomap通过设备结点直接进行设备内存区间的 ioremap()

IMX6Q_CCM_CCGR2 = of_iomap(dtsled.nd, 0);
SW_MUX_GPIO3_IO18 = of_iomap(dtsled.nd, 1);
SW_PAD_GPIO3_IO18 = of_iomap(dtsled.nd, 2);
GPIO3_DR = of_iomap(dtsled.nd, 3);
GPIO3_GDIR = of_iomap(dtsled.nd, 4);

编写好驱动后在板子上加载驱动：

通过app可以成功控制led

驱动文件：

#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 <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>


#define DTSLED_CNT			1		  	/* 设备号个数 */
#define DTSLED_NAME			"dtsled"	/* 名字 */
#define LEDOFF 					0			/* 关灯 */
#define LEDON 					1			/* 开灯 */


/* 寄存器物理地址 */

/*
#define CCM_CCGR2_BASE (0X020c4070)
#define SW_MUX_GPIO3_IO18_BASE (0X020E0098)
#define SW_PAD_GPIO3_IO18_BASE (0X020E03AC)
#define GPIO3_DR_BASE (0X020A4000)
#define GPIO3_GDIR_BASE (0X020A4004)
*/

/* 映射后的寄存器虚拟地址指针 */
static void __iomem *IMX6Q_CCM_CCGR2;
static void __iomem *SW_MUX_GPIO3_IO18;
static void __iomem *SW_PAD_GPIO3_IO18;
static void __iomem *GPIO3_DR;
static void __iomem *GPIO3_GDIR;


/* dtsled设备结构体 */
struct dtsled_dev{
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;		/* 类 		*/
	struct device *device;	/* 设备 	 */
	int major;				/* 主设备号	  */
	int minor;				/* 次设备号   */
	struct device_node	*nd; /* 设备节点 */
};


struct dtsled_dev dtsled;	/* led设备 */


/*
 * @description		: LED打开/关闭
 * @param - sta 	: LEDON(0) 打开LED，LEDOFF(1) 关闭LED
 * @return 			: 无
 */
void led_switch(u8 sta)
{

	u32 val = 0;
	if(sta == LEDON) {
		val = readl(GPIO3_DR);
		val &= ~(1 << 18);	
		writel(val, GPIO3_DR);
	}else if(sta == LEDOFF) {
		val = readl(GPIO3_DR);
		val|= (1 << 18);	
		writel(val, GPIO3_DR);
	}	
}


/*

 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */

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


/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */

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


/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */

static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;


	retvalue = copy_from_user(databuf, buf, cnt);
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}


	ledstat = databuf[0];		/* 获取状态值 */


	if(ledstat == LEDON) {	
		led_switch(LEDON);		/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
		led_switch(LEDOFF);	/* 关闭LED灯 */
	}
	return 0;
}


/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */

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


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


/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */

static int __init led_init(void)
{

	u32 val = 0;
	int ret;
	u32 regdata[14];
	const char *str;
	struct property *proper;


	/* 获取设备树中的属性数据 */
	/* 1、获取设备节点：alphaled */
	dtsled.nd = of_find_node_by_path("/xcled");
	if(dtsled.nd == NULL) {
		printk("xcled node nost find!\r\n");
		return -EINVAL;
	} else {
		printk("xcled node find!\r\n");
	}


	/* 2、获取compatible属性内容 */
	proper = of_find_property(dtsled.nd, "compatible", NULL);
	if(proper == NULL) {
		printk("compatible property find failed\r\n");
	} else {
		printk("compatible = %s\r\n", (char*)proper->value);
	}


	/* 3、获取status属性内容 */
	ret = of_property_read_string(dtsled.nd, "status", &str);
	if(ret < 0){
		printk("status read failed!\r\n");
	} else {
		printk("status = %s\r\n",str);
	}


	/* 4、获取reg属性内容 */
	ret = of_property_read_u32_array(dtsled.nd, "reg", regdata, 10);
	if(ret < 0) {
		printk("reg property read failed!\r\n");
	} else {
		u8 i = 0;
		printk("reg data:\r\n");
		for(i = 0; i < 10; i++)
			printk("%#X ", regdata[i]);
		printk("\r\n");
	}


	/* 初始化LED */
#if 0
	/* 1、寄存器地址映射 */
	IMX6Q_CCM_CCGR2 = ioremap(regdata[0], regdata[1]);
	SW_MUX_GPIO3_IO18 = ioremap(regdata[2], regdata[3]);
  	SW_PAD_GPIO3_IO18 = ioremap(regdata[4], regdata[5]);
	GPIO3_DR = ioremap(regdata[6], regdata[7]);
	GPIO3_GDIR = ioremap(regdata[8], regdata[9]);

#else
	IMX6Q_CCM_CCGR2 = of_iomap(dtsled.nd, 0);
	SW_MUX_GPIO3_IO18 = of_iomap(dtsled.nd, 1);
  	SW_PAD_GPIO3_IO18 = of_iomap(dtsled.nd, 2);
	GPIO3_DR = of_iomap(dtsled.nd, 3);
	GPIO3_GDIR = of_iomap(dtsled.nd, 4);
#endif


	/* 2、使能GPIO1时钟 */
	val = readl(IMX6Q_CCM_CCGR2);
	val &= ~(3 << 18);	/* 清楚以前的设置 */
	val |= (3 << 18);	/* 设置新值 */
	writel(val, IMX6Q_CCM_CCGR2);


	/* 3、设置GPIO1_IO03的复用功能，将其复用为
	 *    GPIO1_IO03，最后设置IO属性。
	 */
	writel(5, SW_MUX_GPIO3_IO18);


	/*寄存器SW_PAD_GPIO1_IO03设置IO属性
	 *bit 16:0 HYS关闭
	 *bit [15:14]: 00 默认下拉
     *bit [13]: 0 kepper功能
     *bit [12]: 1 pull/keeper使能
     *bit [11]: 0 关闭开路输出
     *bit [7:6]: 10 速度100Mhz
     *bit [5:3]: 110 R0/6驱动能力
     *bit [0]: 0 低转换率
	 */

	writel(0x10B0, SW_PAD_GPIO3_IO18);


	/* 4、设置GPIO3_IO18为输出功能 */
	val = readl(GPIO3_GDIR);
	val &= ~(1 << 18);	/* 清除以前的设置 */
	val |= (1 << 18);	/* 设置为输出 */
	writel(val, GPIO3_GDIR);


	/* 5、默认关闭LED */
	val = readl(GPIO3_DR);
	val |= (1 << 18);	
	writel(val, GPIO3_DR);


	/* 注册字符设备驱动 */
	/* 1、创建设备号 */
	if (dtsled.major) {		/*  定义了设备号 */
		dtsled.devid = MKDEV(dtsled.major, 0);
		register_chrdev_region(dtsled.devid, DTSLED_CNT, DTSLED_NAME);
	} else {						/* 没有定义设备号 */
		alloc_chrdev_region(&dtsled.devid, 0, DTSLED_CNT, DTSLED_NAME);	/* 申请设备号 */
		dtsled.major = MAJOR(dtsled.devid);	/* 获取分配号的主设备号 */
		dtsled.minor = MINOR(dtsled.devid);	/* 获取分配号的次设备号 */
	}

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

	
	/* 2、初始化cdev */
	dtsled.cdev.owner = THIS_MODULE;
	cdev_init(&dtsled.cdev, &dtsled_fops);
	

	/* 3、添加一个cdev */
	cdev_add(&dtsled.cdev, dtsled.devid, DTSLED_CNT);


	/* 4、创建类 */
	dtsled.class = class_create(THIS_MODULE, DTSLED_NAME);
	if (IS_ERR(dtsled.class)) {
		return PTR_ERR(dtsled.class);
	}



	/* 5、创建设备 */
	dtsled.device = device_create(dtsled.class, NULL, dtsled.devid, NULL, DTSLED_NAME);
	if (IS_ERR(dtsled.device)) {
		return PTR_ERR(dtsled.device);
	}
	

	return 0;
}


/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */

static void __exit led_exit(void)
{
	/* 取消映射 */


	iounmap(IMX6Q_CCM_CCGR2);
	iounmap(SW_MUX_GPIO3_IO18);
	iounmap(SW_PAD_GPIO3_IO18);
	iounmap(GPIO3_DR);
	iounmap(GPIO3_GDIR);
	/* 注销字符设备驱动 */
	cdev_del(&dtsled.cdev);/*  删除cdev */
	unregister_chrdev_region(dtsled.devid, DTSLED_CNT); /* 注销设备号 */


	device_destroy(dtsled.class, dtsled.devid);
	class_destroy(dtsled.class);
}


module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");

app文件：

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



#define LEDOFF 	0
#define LEDON 	1


/*
 * @description		: main主程序
 * @param - argc 	: argv数组元素个数
 * @param - argv 	: 具体参数
 * @return 			: 0 成功;其他 失败
 */

int main(int argc, char *argv[])
{
	int fd, retvalue;
	char *filename;
	unsigned char databuf[1];
	

	if(argc != 3){
		printf("Error Usage!\r\n");
		return -1;
	}


	filename = argv[1];


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


	databuf[0] = atoi(argv[2]);	/* 要执行的操作：打开或关闭 */


	/* 向/dev/led文件写入数据 */
	retvalue = write(fd, databuf, sizeof(databuf));
	if(retvalue < 0){
		printf("LED Control Failed!\r\n");
		close(fd);
		return -1;
	}


	retvalue = close(fd); /* 关闭文件 */
	if(retvalue < 0){
		printf("file %s close failed!\r\n", argv[1]);
		return -1;
	}
	return 0;
}