ARM Linux驱动开发实战：从零到一构建设备树LED驱动（基于Ubuntu 20.04）

在嵌入式Linux开发领域，设备树（Device Tree）已成为现代内核管理硬件资源的标准方式。它解耦了硬件描述与驱动代码，使得同一份驱动能适配不同的硬件平台。对于从传统寄存器直接操作转向设备树开发的工程师来说，第一个驱动实验往往充满挑战。本文将手把手带你完成一个基于设备树的LED驱动开发全流程，涵盖从设备树节点编写、OF函数使用到驱动测试的每一个环节，助你打通设备树驱动开发的关键路径。

一、设备树驱动原理与设计思路

传统的Linux驱动通常将硬件资源（如寄存器地址、中断号）硬编码在驱动文件中，这导致驱动可移植性差。设备树的引入彻底改变了这一局面。它采用一种树状结构的文本文件（.dts）来描述系统硬件，由Bootloader传递给内核。内核解析设备树后，驱动通过专用的OF（Open Firmware）函数来动态获取硬件信息。

本次LED驱动实验的核心思路是：将LED对应的GPIO寄存器信息定义在设备树节点中，驱动程序在初始化时读取这些信息，并完成GPIO的映射与配置。这类似于在JavaScript或TypeScript项目中通过配置文件管理环境变量，实现了代码与配置的分离。整个流程体现了现代嵌入式开发中“描述而非编码”的思想。

上图清晰地展示了设备树在系统启动流程中的作用，它是连接硬件、Bootloader与Linux内核的桥梁。

渡水无言：个人主页渡水无言

❄专栏传送门： 《linux专栏》   《嵌入式linux驱动开发》
⭐️流水不争先，争的是滔滔不绝

博主简介：第二十届中国研究生电子设计竞赛全国二等奖 |国家奖学金 | 省级三好学生

| 省级优秀毕业生获得者 | csdn新星杯TOP18 | 半导纵横专栏博主 | 211在读研究生

在这里主要分享自己学习的linux嵌入式领域知识；有分享错误或者不足的地方欢迎大佬指导，也欢迎各位大佬互相三连

二、硬件原理分析与设备树节点编写

在编写驱动前，必须明确硬件连接。假设我们的LED0连接到了GPIO1_IO03引脚。根据电路原理，当该引脚输出低电平时LED点亮，高电平时熄灭。这与在Arduino或Raspberry Pi上控制LED的逻辑是一致的。

接下来，我们需要在平台对应的设备树文件（如imx6ull-alientek-emmc.dts）的根节点下，添加描述该LED的节点。这类似于在Web开发中定义一个新的JSON配置块。

// 在设备树根节点下添加LED节点
alphaled {
    #address-cells = <1>;
    #size-cells = <1>;
    compatible = "atkalpha-led";
    status = "okay";
    reg = <
        0x020C406C 0x04    /* CCM_CCGR1_BASE          */
        0x020E0068 0x04    /* SW_MUX_GPIO1_IO03_BASE  */
        0x020E02F4 0x04    /* SW_PAD_GPIO1_IO03_BASE  */
        0x0209C000 0x04    /* GPIO1_DR_BASE           */
        0x0209C004 0x04 >; /* GPIO1_GDIR_BASE         */
};

对节点属性解读：

  • compatible：驱动匹配的关键字，类似于一个“设备ID”。
  • reg：定义了驱动需要操作的寄存器地址和长度。每个`<地址 长度>`对占用两个cell。
  • status：节点状态，“okay”表示启用。

修改完成后，需要编译设备树源文件（.dts）为二进制文件（.dtb）：

// 编译设备树命令
make dtbs

将新生成的.dtb文件加载到开发板，启动后可以在/proc/device-tree/目录下查看节点是否创建成功。这一步的验证至关重要，确保硬件描述已正确传递给内核。

三、驱动开发实战：OF函数详解与代码实现

驱动代码的核心任务是解析设备树节点并操作硬件。我们创建一个dtsled.c文件。与旧版直接写死寄存器地址的驱动不同，新版驱动首先需要包含设备树头文件并定义设备节点指针。

// LED驱动核心代码框架
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
版本	   	: V1.0
描述	   	: LED驱动文件。
其他	   	: 无
***************************************************************/
#define DTSLED_CNT			1		  	/* 设备号个数 */
#define DTSLED_NAME			"dtsled"	/* 名字 */
#define LEDOFF 					0			/* 关灯 */
#define LEDON 					1			/* 开灯 */
/* 映射后的寄存器虚拟地址指针 */
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_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(GPIO1_DR);
		val &= ~(1 << 3);
		writel(val, GPIO1_DR);
	}else if(sta == LEDOFF) {
		val = readl(GPIO1_DR);
		val|= (1 << 3);
		writel(val, GPIO1_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("/alphaled");
	if(dtsled.nd == NULL) {
		printk("alphaled node nost find!\r\n");
		return -EINVAL;
	} else {
		printk("alphaled 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、寄存器地址映射 */
	IMX6U_CCM_CCGR1 = ioremap(regdata[0], regdata[1]);
	SW_MUX_GPIO1_IO03 = ioremap(regdata[2], regdata[3]);
  	SW_PAD_GPIO1_IO03 = ioremap(regdata[4], regdata[5]);
	GPIO1_DR = ioremap(regdata[6], regdata[7]);
	GPIO1_GDIR = ioremap(regdata[8], regdata[9]);
#else
	IMX6U_CCM_CCGR1 = of_iomap(dtsled.nd, 0);
	SW_MUX_GPIO1_IO03 = of_iomap(dtsled.nd, 1);
  	SW_PAD_GPIO1_IO03 = of_iomap(dtsled.nd, 2);
	GPIO1_DR = of_iomap(dtsled.nd, 3);
	GPIO1_GDIR = of_iomap(dtsled.nd, 4);
#endif
	/* 2、使能GPIO1时钟 */
	val = readl(IMX6U_CCM_CCGR1);
	val &= ~(3 << 26);	/* 清楚以前的设置 */
	val |= (3 << 26);	/* 设置新值 */
	writel(val, IMX6U_CCM_CCGR1);
	/* 3、设置GPIO1_IO03的复用功能，将其复用为
	 *    GPIO1_IO03，最后设置IO属性。
	 */
	writel(5, SW_MUX_GPIO1_IO03);
	/*寄存器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_GPIO1_IO03);
	/* 4、设置GPIO1_IO03为输出功能 */
	val = readl(GPIO1_GDIR);
	val &= ~(1 << 3);	/* 清除以前的设置 */
	val |= (1 << 3);	/* 设置为输出 */
	writel(val, GPIO1_GDIR);
	/* 5、默认关闭LED */
	val = readl(GPIO1_DR);
	val |= (1 << 3);
	writel(val, GPIO1_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(IMX6U_CCM_CCGR1);
	iounmap(SW_MUX_GPIO1_IO03);
	iounmap(SW_PAD_GPIO1_IO03);
	iounmap(GPIO1_DR);
	iounmap(GPIO1_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");
MODULE_AUTHOR("duan");

驱动初始化函数led_init中，我们使用了一系列OF函数：

  1. of_find_node_by_path：通过路径查找设备树节点，这是获取设备信息的起点。
  2. of_find_property 与 of_property_read_string：用于读取节点的字符串属性，如`compatible`和`status`，进行设备匹配和状态判断。
  3. of_property_read_u32_array：读取`reg`属性中的多个32位整数值（地址和长度），存入数组。
  4. 内存映射：获取物理地址后，传统方法是调用ioremap。而设备树更推荐使用of_iomap函数，它能一站式完成属性读取和地址映射，代码更简洁。

⚠️ 注意事项：使用OF函数时务必检查返回值，确保节点和属性查找成功，这是避免驱动加载失败的关键。这种防御性编程思想在Go、Java等语言中同样重要。

[AFFILIATE_SLOT_1]

四、测试程序编写与全流程编译运行

驱动加载后，需要一个用户空间的测试程序（Test APP）通过设备文件来控制LED。测试程序逻辑很简单：接收用户输入，调用`ioctl`向驱动发送控制命令。

// 用户态测试APP代码
#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名		: ledApp.c
版本	   	: V1.0
描述	   	:led驱测试APP。
其他	   	: 无
使用方法	 ：./ledtest /dev/led  0 关闭LED
		     ./ledtest /dev/led  1 打开LED
***************************************************************/
#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;
}

接下来是编译环节。我们需要编写一个Makefile来编译内核模块：

// 驱动模块的Makefile
KERNELDIR := /home/duan/linux/linux-imx-rel_imx_4.1.15_2.1.1_ga_alientek_v2.2
CURRENT_PATH := $(shell pwd)
obj-m :=  dtsled.o
build: kernel_modules
kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

使用make命令编译生成dtsled.ko驱动模块。测试APP则用交叉编译工具链直接编译：

// 编译测试APP
arm-linux-gnueabihf-gcc ledApp.c -o ledApp

将编译好的驱动模块和测试APP拷贝到开发板，按顺序执行以下命令进行测试：

  • insmod dtsled.ko – 加载驱动模块
  • ./ledApp /dev/dtsled 1 – 打开LED
  • ./ledApp /dev/dtsled 0 – 关闭LED
  • rmmod dtsled – 卸载模块

如果LED能随命令亮灭，恭喜你，第一个设备树驱动实验成功！

[AFFILIATE_SLOT_2]

五、总结与进阶思考

通过本实验，我们完整实践了设备树驱动开发的闭环：硬件描述（DTS）→ 驱动解析（OF函数）→ 硬件操作 → 用户控制。与直接在C++或Java中硬编码配置相比，设备树方案使驱动具备了出色的可移植性和可配置性。

掌握设备树驱动开发，是深入Linux内核和嵌入式领域的必经之路。你可以尝试在此基础上进行扩展：

  • 为LED节点添加自定义属性（如“active-low”），并在驱动中解析。
  • 使用platform_driver框架更规范地实现驱动，实现自动探测与匹配。
  • 探索中断、PWM等更复杂外设在设备树中的描述与驱动实现。

设备树就像嵌入式系统的“蓝图”，理解它，你就能更自如地驾驭复杂的ARM Linux世界。希望这篇指南能为你点亮设备树开发的第一盏灯！

posted on 2026-03-20 08:16  blfbuaa  阅读(48)  评论(0)    收藏  举报

博客园  ©  2004-2026
浙公网安备 33010602011771号 浙ICP备2021040463号-3