【Linux 驱动基础】设备树驱动

# 前置知识

在图中，树的主干就是系统总线， IIC 控制器、 SPI 控制器等都是接到系统主线上的分支。其中 IIC1 上接了 AT24C02这个 IIC 设备， DTS 文件的主要功能就是按照图所示的结构来描述板子上的设备信息。

1. Device格式

DTS文件格式

/dts-v1/; // 表示版本
[memory reservations] // 格式为: /memreserve/ <address> <length>;
/ {[property definitions][child nodes]
};

node格式

[label:] node-name[@unit-address] {[properties definitions][child nodes]
};

label：标号，可以省略，可以使用&label来引用node；

node-name：节点的名称，长度应该为 1-31 个字符，命名应该以小写或者大写字母开头

unit-address：表示设备地址或者寄存器首地址

properties

简单地说， properties 就是“name=value”， value 有多种取值方式

Property 格式 1:

[label:] property-name = value;

Property 格式 2(没有值):

[label:] property-name;

Property 取值只有 3 种:

arrays of cells(1 个或多个 32 位数据, 64 位数据使用 2 个 32 位数据表示， eg：interrupts = <17 0xc>;),

string(字符串，eg：compatible = "simple-bus"),

bytestring(1 个或多个字节，eg：local-mac-address = [00 00 12 34 56 78]; // 每个 byte 使用 2 个 16 进制数来表示)

2. 标准属性

2.1 compatible

compatible 属性值由 string list 组成，定义了设备的兼容性，推荐格式为manufacturer,model，manufacturer 描述了生产商，model 描述了型号：

compatible = "fsl,imx6ull-14x14-evk", "fsl,imx6ull";

根节点下 compatible 属性，用来选择哪一个“ machine desc”：一个内核可以支持 machine A，也支持 machine B，内核启动后会根据根节点的compatible 属性找到对应的 machine desc 结构体，执行其中的初始化函数

compatible = "fsl,imx6ul-evk-wm8960","fsl,imx-audio-wm8960"

设备节点下的compatible属性，是用来匹配驱动程序的，一般驱动程序文件都会有一个 OF 匹配表，此 OF 匹配表保存着一些 compatible 值，如果设备节点的 compatible 属性值核 OF 匹配表中的任何一个值相等，那么就表示这个设备可以使用这个驱动。如下：

static const struct of_device_id imx_wm8960_dt_ids[] = {{ .compatible = "fsl,imx-audio-wm8960", },{ /* sentinel */ }
};

2.2 model

model 属性值是一个 string，指明了设备的厂商和型号，推荐格式为manufacturer,model。

model = "Freescale i.MX6 ULL 14x14 EVK Board";

2.3 phandle

phandle 属性值是一个 u32，为设备树中唯一的节点指定一个数字标识符，用于其它节点指明关系。

2.4 status

status 属性值是一个 string，表示设备的运行状态，可用值如下表：

2.5 #address-cells 和 #size-cells

#address-cells and #size-cells 属性值是一个 u32，可以用在任何拥有子节点的设备中，并描述子设备节点应该如何寻址。

#address-cells属性定义子节点 reg 属性中地址字段所占用的字长，也就是占用 u32 单元格的数量。

#size-cells属性定义子节点 reg 属性值的长度所占用的 u32 单元格的数量。

2.6 reg

reg 属性值是一个 prop-encoded-array，用来描述设备地址空间资源信息，一般是某个外设的寄存器地址范围信息，包括起始地址和地址长度。

reg = <address1 length1 address2 length2 address3 length3……>

2.7 name(过时了，建议不用)

它的值是字符串，用来表示节点的名字。在跟 platform_driver 匹配时，优先级最低。

compatible 属性在匹配过程中，优先级最高

3. 常用节点

3.1 根节点

树是由树根开始的，在设备树中称之为根节点，路径为/，根节点不需要节点名称，所有子节点都是挂在根节点上的，可以看到最简单的根节点如下：

/ {};

根节点的属性有：

3.2 aliases

aliases 节点用来定义别名，为了内核方便访问节点。

aliases {can0 = &flexcan1;can1 = &flexcan2;ethernet0 = &fec1;ethernet1 = &fec2;gpio0 = &gpio1;gpio1 = &gpio2;gpio2 = &gpio3;gpio3 = &gpio4;gpio4 = &gpio5;i2c0 = &i2c1;i2c1 = &i2c2;i2c2 = &i2c3;i2c3 = &i2c4;mmc0 = &usdhc1;mmc1 = &usdhc2;serial0 = &uart1;serial1 = &uart2;serial2 = &uart3;serial3 = &uart4;serial4 = &uart5;serial5 = &uart6;serial6 = &uart7;serial7 = &uart8;spi0 = &ecspi1;spi1 = &ecspi2;spi2 = &ecspi3;spi3 = &ecspi4;usbphy0 = &usbphy1;usbphy1 = &usbphy2;};

3.3 chosen

chosen 节点是为了uboot 向 Linux 内核传递数据，重点是 bootargs 参数，一般.dts 文件中 chosen 节点通常为空或者内容很少。

chosen {stdout-path = &uart1;};

3.4 CPU

一般不需要我们设置，在 dtsi 文件中都定义好了：

cpus {#address-cells = <1>;#size-cells = <0>;cpu0: cpu@0 {.......}
};

3.5 memory

芯片厂家不可能事先确定你的板子使用多大的内存，所以 memory 节点需要板厂设置，比如：

memory {reg = <0x80000000 0x20000000>;};

4. OF 操作函数

of.h // 提供设备树的一般处理函数,
// 比如 of_property_read_u32(读取某个属性的 u32 值),
// of_get_child_count(获取某个 device_node 的子节点数)
of_address.h // 地址相关的函数,
// 比如 of_get_address(获得 reg 属性中的 addr, size 值)
// of_match_device (从 matches 数组中取出与当前设备最匹配的一项)
of_dma.h // 设备树中 DMA 相关属性的函数
of_gpio.h // GPIO 相关的函数
of_graph.h // GPU 相关驱动中用到的函数, 从设备树中获得 GPU 信息
of_iommu.h // 很少用到
of_irq.h // 中断相关的函数
of_mdio.h // MDIO (Ethernet PHY) API
of_net.h // OF helpers for network devices.
of_pci.h // PCI 相关函数
of_pdt.h // 很少用到
of_reserved_mem.h // reserved_mem 的相关函数

4.1 查找节点

通过节点名字查找节点

extern struct device_node *of_find_node_by_name(struct device_node *from,const char *name);

参数意义如下：

from：开始查找的节点，NULL 表示根节点
name：要查找的节点名称

返回值为找到的节点，NULL 为查找失败。

通过节点类型查找节点

extern struct device_node *of_find_node_by_type(struct device_node *from,const char *type);

type 参数指定要查看节点对应的 type 字符串，也就是 device_type 属性值。

通过 device_type 和 compatible 查找节点

extern struct device_node *of_find_compatible_node(struct device_node *from,const char *type, const char *compat);

通过 of_device_id 匹配表来查找节点

extern struct device_node *of_find_matching_node_and_match(struct device_node *from,const struct of_device_id *matches,const struct of_device_id **match);

通过路径来查找节点

static inline struct device_node *of_find_node_by_path(const char *path)
{return of_find_node_opts_by_path(path, NULL);
}

4.2 获取父子节点

获取父节点

extern struct device_node *of_get_parent(const struct device_node *node);

迭代查找子节点

extern struct device_node *of_get_next_child(const struct device_node *node,struct device_node *prev);

4.3 提取属性值

查找指定节点的属性

extern struct property *of_find_property(const struct device_node *np,const char *name,int *lenp);

参数 name 指属性名字，lenp 指属性值的字节数。

获取属性中元素的数量

extern int of_property_count_elems_of_size(const struct device_node *np,const char *propname, int elem_size);

参数 propname 是需要统计元素数量的属性名字，参数 elem_size 是元素的长度。

返回值是获取到的属性元素数量。

eg. reg 属性的值通常是一个数组，使用此函数可以获取的数组的大小。

从属性中获取指定索引的 u32 类型数据值

extern int of_property_read_u32_index(const struct device_node *np,const char *propname,u32 index, u32 *out_value);

参数 out_value 用来返回获取到的值。

返回值用来表示是否获取成功。

从属性中获取数组值

extern int of_property_read_u8_array(const struct device_node *np,const char *propname, u8 *out_values, size_t sz);
extern int of_property_read_u16_array(const struct device_node *np,const char *propname, u16 *out_values, size_t sz);
extern int of_property_read_u32_array(const struct device_node *np,const char *propname,u32 *out_values,size_t sz);
extern int of_property_read_u64_array(const struct device_node *np,const char *propname,u64 *out_values,size_t sz);

eg. reg 属性的值通常是一个数组，使用这个函数可以一次读取出一个数组，也就是 reg 属性的全部值。

从属性中获取布尔值/整形值

/*** of_property_read_bool - Findfrom a property* @np:  device node from which the property value is to be read.* @propname: name of the property to be searched.** Search for a property in a device node.* Returns true if the property exist false otherwise.*/
static inline bool of_property_read_bool(const struct device_node *np,const char *propname)
{struct property *prop = of_find_property(np, propname, NULL);return prop ? true : false;
}static inline int of_property_read_u8(const struct device_node *np,const char *propname,u8 *out_value)
{return of_property_read_u8_array(np, propname, out_value, 1);
}static inline int of_property_read_u16(const struct device_node *np,const char *propname,u16 *out_value)
{return of_property_read_u16_array(np, propname, out_value, 1);
}static inline int of_property_read_u32(const struct device_node *np,const char *propname,u32 *out_value)
{return of_property_read_u32_array(np, propname, out_value, 1);
}static inline int of_property_read_s32(const struct device_node *np,const char *propname,s32 *out_value)
{return of_property_read_u32(np, propname, (u32*) out_value);
}

从属性中获取字符串

extern int of_property_read_string(struct device_node *np,const char *propname,const char **out_string);

获取#address-cells 和#size-cells 属性值

extern int of_n_addr_cells(struct device_node *np);
extern int of_n_size_cells(struct device_node *np);

# 驱动示例

	atk-led{#address-cells = <1>;#size-cells = <1>;compatible = "atk,led";status = "okay";reg = < 0x20C406C 40x20E0068 4 0x20E02F4 4 0x209C000 4>;};

#include <linux/console.h>
#include <linux/dma-mapping.h>
#include <linux/init.h>
#include <linux/ipu-v3.h>
#include <linux/module.h>
#include <linux/mxcfb.h>
#include <linux/mxc_v4l2.h>
#include <linux/platform_device.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/videodev2.h>
#include <linux/vmalloc.h>
#include <linux/of.h>
#include <linux/io.h>
#include <linux/fs.h>
#include <linux/of_platform.h>
#include <linux/uaccess.h>typedef struct
{volatile uint32_t GPIO_DR;volatile uint32_t GPIO_GDIR;volatile uint32_t GPIO_PSR;volatile uint32_t GPIO_ICR1;volatile uint32_t GPIO_ICR2;volatile uint32_t GPIO_IMR;volatile uint32_t GPIO_ISR;volatile uint32_t GPIO_EDGE_SEL;
}GPIO_TypeDef;static GPIO_TypeDef *GPIO;static volatile uint32_t *CCM_CCGR;
static volatile uint32_t *IOMUXC_SW_MUX_CTL_PAD;
static volatile uint32_t *IOMUXC_SW_PAD_CTL_PAD;typedef struct
{struct device_node *devNode;    /* 设备节点 */int reg_num;        /* reg长度 */u32 *reg_value;char drv_name[50];  /* 驱动名称 */int major;      /* 主设备号 */int minor;      /* 次设备号 */dev_t devt;     /* 设备号 */struct device *device;   /* 设备 */char device_name[50];    /* 设备名称 */struct class *class;    /* 类 */char class_name[50];    /* 类名称 */
}atk_led_private;atk_led_private led_pri = {.devNode = NULL,.drv_name = "led_drv",.reg_value = NULL,.major  = 0,.minor  = 0,.devt   = 0,.device = NULL,.device_name = "led_dev",.class  = NULL,.class_name  = "led_class",
};static int led_open(struct inode *inode, struct file *file)
{uint32_t val;/* 使能GPIO1时钟 */*CCM_CCGR |= (3 << 26);/* 设置IO复用 */val = *IOMUXC_SW_MUX_CTL_PAD;val &= ~(0x0F);val |= 5;*IOMUXC_SW_MUX_CTL_PAD = val;/* 设置IO属性 *//* 设置IO方向,设置GPIO1_IO03为输出 */GPIO->GPIO_GDIR |= (1 << 3);return 0;
}static int led_release(struct inode *inode, struct file *file)
{return 0;
}static ssize_t led_write(struct file *file, const char __user *buff, size_t size, loff_t *ppos)
{uint8_t status;int err;err = copy_from_user(&status, buff, 1);if(status == 1){GPIO->GPIO_DR &= ~(1<<3);}else{GPIO->GPIO_DR |= (1<<3);}return 1;
}static const struct file_operations led_op = {.owner      = THIS_MODULE,.open       = led_open,.release    = led_release,.write      = led_write,
};static int atk_led_probe(struct platform_device *device)
{int err;int i;printk("atk_led_probe\r\n");/* 获取节点 */led_pri.devNode = of_find_node_by_path("/atk-led");if(led_pri.devNode == NULL){printk("of_find_node_by_path fail\r\n");return -1;}/* 获取数字属性的长度 */led_pri.reg_num = of_property_count_elems_of_size(led_pri.devNode, "reg", sizeof(uint32_t));if(led_pri.reg_num < 0) {printk("of_property_count_elems_of_size error\r\n");return -1;}/* 读取数字属性 */led_pri.reg_value = (u32*)kmalloc(sizeof(u32)*led_pri.reg_num, GFP_KERNEL);err = of_property_read_u32_array(led_pri.devNode, "reg", led_pri.reg_value, led_pri.reg_num);if(err != 0) {printk("of_property_read_u32_array fail\r\n");return -1;}/* 打印属性值 */for(i=0; i<led_pri.reg_num; i+=2) {printk("reg = %x  %x \r\n", led_pri.reg_value[i], led_pri.reg_value[i+1]);}CCM_CCGR = ioremap(led_pri.reg_value[0], led_pri.reg_value[1]);IOMUXC_SW_MUX_CTL_PAD = ioremap(led_pri.reg_value[2], led_pri.reg_value[3]);IOMUXC_SW_PAD_CTL_PAD = ioremap(led_pri.reg_value[4], led_pri.reg_value[5]);GPIO = ioremap(led_pri.reg_value[6], led_pri.reg_value[7]);led_pri.major = register_chrdev(0, led_pri.drv_name, &led_op);led_pri.devt = MKDEV(led_pri.major, led_pri.minor);led_pri.class = class_create(THIS_MODULE, led_pri.class_name);if(IS_ERR(led_pri.class)){printk("class_create error\r\n");err = PTR_ERR(led_pri.class);goto err_class_create_out;}led_pri.device = device_create(led_pri.class, NULL, led_pri.devt, NULL, led_pri.device_name);if(IS_ERR(led_pri.device)){printk("device_create error\r\n");err = PTR_ERR(led_pri.device);goto err_device_create_out;}return 0;err_device_create_out:class_destroy(led_pri.class);
err_class_create_out:unregister_chrdev(led_pri.major, led_pri.drv_name);return err;
}static int atk_led_remove(struct platform_device *device)
{printk("atk_led_drv_remove\r\n");device_destroy(led_pri.class, led_pri.devt);class_destroy(led_pri.class);unregister_chrdev(led_pri.major, led_pri.drv_name);return 0;
}static struct of_device_id atk_led_id[] = {{.compatible = "atk,led"},{}
};static struct platform_driver atk_led_driver = 
{.probe = atk_led_probe,.remove = atk_led_remove,.driver = {.owner = THIS_MODULE,.name = "atk,led",.of_match_table = atk_led_id,},
};static int __init atk_led_init(void)
{int err;printk("atk_led_init");err = platform_driver_register(&atk_led_driver);return 0;
}static void __exit atk_led_exit(void)
{platform_driver_unregister(&atk_led_driver);
}module_init(atk_led_init);
module_exit(atk_led_exit);MODULE_LICENSE("GPL");