Linux 驱动开发基础知识——LED 模板驱动程序的改造：设备树（十一）

个人名片：

🦁作者简介：学生
🐯个人主页：妄北y

🐧个人QQ：2061314755

🐻个人邮箱：2061314755@qq.com
🦉个人WeChat：Vir2021GKBS
🐼本文由妄北y原创，首发CSDN🎊🎊🎊
🐨座右铭：大多数人想要改造这个世界，但却罕有人想改造自己。

专栏导航：

妄北y系列专栏导航:

C/C++的基础算法：C/C++是一种常用的编程语言，可以用于实现各种算法，这里我们对一些基础算法进行了详细的介绍与分享。🎇🎇🎇

QT基础入门学习：对QT的基础图形化页面设计进行了一个简单的学习与认识，利用QT的基础知识进行了翻金币小游戏的制作🤹🤹🤹

Linux基础编程：初步认识什么是Linux，为什么学Linux，安装环境，进行基础命令的学习，入门级的shell编程。🍻🍻🍻

Linux应用开发基础开发：分享Linux的基本概念、命令行操作、文件系统、用户和权限管理等，网络编程相关知识，TCP/IP 协议、套接字（Socket）编程等，可以实现网络通信功能。💐💐💐

Linux项目开发：Linux基础知识的实践，做项目是最锻炼能力的一个学习方法，这里我们会学习到一些简单基础的项目开发与应用，而且都是毕业设计级别的哦。🤸🤸🤸

非常期待和您一起在这个小小的互联网世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨

文章介绍：

🎉本篇文章对Linux驱动基础学习的相关知识进行分享！🥳🥳🥳

设备树（Device Tree）是Linux内核用来描述硬件结构的数据结构。它使得内核可以在没有硬编码驱动的情况下识别并配置硬件。在嵌入式系统中，设备树特别有用，因为它们经常具有非常不同的硬件配置，而设备树提供了一种灵活的方式来描述这些配置。

如果您觉得文章不错，期待你的一键三连哦，你的鼓励是我创作动力的源泉，让我们一起加油，一起奔跑，让我们顶峰相见！！！💪💪💪

🎁感谢大家点赞👍收藏⭐评论✍️

一、总结 3 种写驱动程序的方法

1.1 资源和驱动在同一个文件里

1.2 资源用 platform_device 指定、驱动在 platform_driver 实现

1.3 资源用设备树指定驱动在 platform_driver 实现

核心永远是 file_operations 结构体。

上述三种方法，只是指定“硬件资源”的方式不一样。

platform_device/platform_driver 只是编程的技巧，不涉及驱动的核心

二、怎么使用设备树写驱动程序

2.1 设备树节点要与 platform_driver 能匹配

在我们的工作中，驱动要求设备树节点提供什么，我们就得按这要求去编写设备树。但是，匹配过程所要求的东西是固定的：

（1）设备树要有 compatible 属性，它的值是一个字符串

（2）platform_driver 中要有 of_match_table，其中一项的.compatible 成员设置为一个字符串

（3）上述 2 个字符串要一致。

示例如下：

2.2 设备树节点指定资源，platform_driver 获得资源

如果在设备树节点里使用reg属性，那么内核生成对应的platform_device 时会用 reg 属性来设置 IORESOURCE_MEM 类型的资源。

如果在设备树节点里使用 interrupts 属性，那么内核生成对应的 platform_device 时会用 reg 属性来设置 IORESOURCE_IRQ 类型的资源。对于 interrupts 属性，内核会检查它的有效性，所以不建议在设备树里使用该属性来表示其他资源。

在我们的工作中，驱动要求设备树节点提供什么，我们就得按这要求去编写设备树。驱动程序中根据 pin 属性来确定引脚，那么我们就在设备树节点中添加 pin 属性。

设备树节点中：

#define GROUP_PIN(g,p) ((g<<16) | (p))
100ask_led0 {compatible = “100ask,led”;pin = <GROUP_PIN(5, 3)>;
};

驱动程序中，可以从 platform_device 中得到 device_node，再用of_property_read_u32 得到属性的值：

struct device_node* np = pdev->dev. of_node;
int led_pin;
int err = of_property_read_u32(np, “pin”, &led_pin);

三、开始编程

3.1 修改设备树添加 led 设备节点

需要添加的设备节点代码是一样的，你需要找到你的单板所用的设备树文件，在它的根节点下添加如下内容：

#define GROUP_PIN(g,p) ((g<<16) | (p))/ {100ask_led@0 {                        //在设备树中，节点通常代表一个设备或子系统。compatible = "100as,leddrv";      //这表示该节点所代表的设备与名为 "100as,leddrv" 的驱动程序兼容pin = <GROUP_PIN(3, 1)>;          //这设置了一个名为 pin 的属性，并使用前面定义的 GROUP_PIN 宏将其初始化};100ask_led@1 {compatible = "100as,leddrv";     pin = <GROUP_PIN(5, 8)>;};};

对百问网 imx6ull Pro 板

设备树文件是：内核源码目录中 arch/arm/boot/dts/100ask_imx6ull-14x14.dts 修改、编译后得到 arch/arm/boot/dts/100ask_imx6ull-14x14.dtb 文件。

对于这款板子，本教程中我们使用 SD 卡上的系统。

要更换板上的设备树文件，你可以使用 SD 卡启动开发板后，更换这个文件：/boot/100ask_imx6ull-14x14.dtb

chip_demo_gpio.c（驱动程序）

#include <linux/module.h>#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/platform_device.h>
#include <linux/of.h>#include "led_opr.h"
#include "leddrv.h"
#include "led_resource.h"static int g_ledpins[100];
static int g_ledcnt = 0;static int board_demo_led_init (int which) /* 初始化LED, which-哪个LED */       
{   //printk("%s %s line %d, led %d\n", __FILE__, __FUNCTION__, __LINE__, which);printk("init gpio: group %d, pin %d\n", GROUP(g_ledpins[which]), PIN(g_ledpins[which]));switch(GROUP(g_ledpins[which])){case 0:{printk("init pin of group 0 ...\n");break;}case 1:{printk("init pin of group 1 ...\n");break;}case 2:{printk("init pin of group 2 ...\n");break;}case 3:{printk("init pin of group 3 ...\n");break;}}return 0;
}static int board_demo_led_ctl (int which, char status) /* 控制LED, which-哪个LED, status:1-亮,0-灭 */
{//printk("%s %s line %d, led %d, %s\n", __FILE__, __FUNCTION__, __LINE__, which, status ? "on" : "off");printk("set led %s: group %d, pin %d\n", status ? "on" : "off", GROUP(g_ledpins[which]), PIN(g_ledpins[which]));switch(GROUP(g_ledpins[which])){case 0:{printk("set pin of group 0 ...\n");break;}case 1:{printk("set pin of group 1 ...\n");break;}case 2:{printk("set pin of group 2 ...\n");break;}case 3:{printk("set pin of group 3 ...\n");break;}}return 0;
}static struct led_operations board_demo_led_opr = {.init = board_demo_led_init,.ctl  = board_demo_led_ctl,
};struct led_operations *get_board_led_opr(void)
{return &board_demo_led_opr;
}static int chip_demo_gpio_probe(struct platform_device *pdev)
{struct device_node *np;int err = 0;int led_pin;np = pdev->dev.of_node;if (!np)return -1;err = of_property_read_u32(np, "pin", &led_pin);g_ledpins[g_ledcnt] = led_pin;led_class_create_device(g_ledcnt);g_ledcnt++;return 0;}static int chip_demo_gpio_remove(struct platform_device *pdev)
{int i = 0;int err;struct device_node *np;int led_pin;np = pdev->dev.of_node;if (!np)return -1;err = of_property_read_u32(np, "pin", &led_pin);for (i = 0; i < g_ledcnt; i++){if (g_ledpins[i] == led_pin){led_class_destroy_device(i);g_ledpins[i] = -1;break;};}for (i = 0; i < g_ledcnt; i++){if (g_ledpins[i] != -1)break;}if (i == g_ledcnt)g_ledcnt = 0;return 0;
}static const struct of_device_id ask100_leds[] = {{ .compatible = "100as,leddrv" },{ },
};static struct platform_driver chip_demo_gpio_driver = {.probe      = chip_demo_gpio_probe,.remove     = chip_demo_gpio_remove,.driver     = {.name   = "100ask_led",.of_match_table = ask100_leds,},
};static int __init chip_demo_gpio_drv_init(void)
{int err;err = platform_driver_register(&chip_demo_gpio_driver); register_led_operations(&board_demo_led_opr);return 0;
}static void __exit lchip_demo_gpio_drv_exit(void)
{platform_driver_unregister(&chip_demo_gpio_driver);
}module_init(chip_demo_gpio_drv_init);
module_exit(lchip_demo_gpio_drv_exit);MODULE_LICENSE("GPL");

第161~168行： chip_demo_gpio_driver（驱动程序）

static struct platform_driver chip_demo_gpio_driver = {.probe      = chip_demo_gpio_probe,.remove     = chip_demo_gpio_remove,.driver     = {.name   = "100ask_led",.of_match_table = ask100_leds,    //用于支持设备树},
};

第156~159行：指向ask100_leds[]数组

static const struct of_device_id ask100_leds[] = {{ .compatible = "100as,leddrv" },         //这里需要与设备树文件的字符串相互对应{ },
};

第101~119行：chip_demo_gpio_probe

当我们装载上面的驱动程序时，对于俩个100ask_led的节点都需要调用 chip_demo_gpio_probe 函数，需要调用俩次，对于每个匹配的 platform_device 都会去调用一次
static int chip_demo_gpio_probe(struct platform_device *pdev)
{struct device_node *np;int err = 0;int led_pin;np = pdev->dev.of_node;if (!np)return -1;err = of_property_read_u32(np, "pin", &led_pin);g_ledpins[g_ledcnt] = led_pin;led_class_create_device(g_ledcnt);g_ledcnt++;return 0;}
从 platform_device里面找到对应的设备节点找到pin属性
 np = pdev->dev.of_node;if (!np)return -1;
这个platform_driver支持的platform_device,可能来自设备树，也可能不是来自设备树,所以这里要判断一下
用 of_property_read_u32 得到属性的值：
 err = of_property_read_u32(np, "pin", &led_pin);
从np节点中读取pin属性，把它的值保存在led_pin的变量里面

将led_pin幅值给g_ledpins[g_ledcnt]
g_ledpins[g_ledcnt] = led_pin;

韦东山老师对整个驱动程序框架的梳理

整个驱动程序框架的梳理

3.2 修改上层对应代码

leddrv.c（上层程序）

#include <linux/module.h>#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>#include "led_opr.h"/* 1. 确定主设备号                                                                 */
static int major = 0;
static struct class *led_class;
struct led_operations *p_led_opr;#define MIN(a, b) (a < b ? a : b)void led_class_create_device(int minor)
{device_create(led_class, NULL, MKDEV(major, minor), NULL, "100ask_led%d", minor); /* /dev/100ask_led0,1,... */
}
void led_class_destroy_device(int minor)
{device_destroy(led_class, MKDEV(major, minor));
}
void register_led_operations(struct led_operations *opr)
{p_led_opr = opr;
}EXPORT_SYMBOL(led_class_create_device);
EXPORT_SYMBOL(led_class_destroy_device);
EXPORT_SYMBOL(register_led_operations);/* 3. 实现对应的open/read/write等函数，填入file_operations结构体                   */
static ssize_t led_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);return 0;
}/* write(fd, &val, 1); */
static ssize_t led_drv_write (struct file *file, const char __user *buf, size_t size, loff_t *offset)
{int err;char status;struct inode *inode = file_inode(file);int minor = iminor(inode);printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);err = copy_from_user(&status, buf, 1);/* 根据次设备号和status控制LED */p_led_opr->ctl(minor, status);return 1;
}static int led_drv_open (struct inode *node, struct file *file)
{int minor = iminor(node);printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);/* 根据次设备号初始化LED */p_led_opr->init(minor);return 0;
}static int led_drv_close (struct inode *node, struct file *file)
{printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);return 0;
}/* 2. 定义自己的file_operations结构体                                              */
static struct file_operations led_drv = {.owner	 = THIS_MODULE,.open    = led_drv_open,.read    = led_drv_read,.write   = led_drv_write,.release = led_drv_close,
};/* 4. 把file_operations结构体告诉内核：注册驱动程序                                */
/* 5. 谁来注册驱动程序啊？得有一个入口函数：安装驱动程序时，就会去调用这个入口函数 */
static int __init led_init(void)
{int err;printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);major = register_chrdev(0, "100ask_led", &led_drv);  /* /dev/led */led_class = class_create(THIS_MODULE, "100ask_led_class");err = PTR_ERR(led_class);if (IS_ERR(led_class)) {printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);unregister_chrdev(major, "led");return -1;}return 0;
}/* 6. 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数           */
static void __exit led_exit(void)
{printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);class_destroy(led_class);unregister_chrdev(major, "100ask_led");
}/* 7. 其他完善：提供设备信息，自动创建设备节点                                     */module_init(led_init);
module_exit(led_exit);MODULE_LICENSE("GPL");

第73~82行：入口函数 led_drv_open
static int led_drv_open (struct inode *node, struct file *file)
{int minor = iminor(node);printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);/* 根据次设备号初始化LED */p_led_opr->init(minor);return 0;
}
用p_led_opr结构体初始化引脚
	/* 根据次设备号初始化LED */p_led_opr->init(minor);
p_led_opr结构体由底层代码调用register_led_operations函数提供上来的
void register_led_operations(struct led_operations *opr)
{p_led_opr = opr;
}

第170~178行：这里是底层chip_demo_gpio.c的部分代码
static int __init chip_demo_gpio_drv_init(void)
{int err;err = platform_driver_register(&chip_demo_gpio_driver); register_led_operations(&board_demo_led_opr);return 0;
}
第91~94行：由代码中的入口函数提供结构体 board_demo_led_opr 并且注册了一个chip_demo_gpio_driver
static struct led_operations board_demo_led_opr = {.init = board_demo_led_init,.ctl  = board_demo_led_ctl,
};
这个结构体有操作硬件的具体函数
static struct platform_driver chip_demo_gpio_driver = {.probe      = chip_demo_gpio_probe,.remove     = chip_demo_gpio_remove,.driver     = {.name   = "100ask_led",.of_match_table = ask100_leds,},
};
第161~168行：发现有和他匹配的 platform_device 时候会配用 chip_demo_gpio_probe

第101~119行：
static int chip_demo_gpio_probe(struct platform_device *pdev)
{struct device_node *np;int err = 0;int led_pin;np = pdev->dev.of_node;if (!np)return -1;err = of_property_read_u32(np, "pin", &led_pin);    //确定引脚是哪一个g_ledpins[g_ledcnt] = led_pin;led_class_create_device(g_ledcnt);                  //向上一层注册这些引脚g_ledcnt++;return 0;}
第30~33行：根据引脚创建设备节点，这里的设备节点与设备树中的设备节点不是一回事，是文件系统里面的设备节点，应用程序就可以使用这个文件系统中的设备节点来访问我们的硬件
void led_class_create_device(int minor)
{device_create(led_class, NULL, MKDEV(major, minor), NULL, "100ask_led%d", minor); /* /dev/100ask_led0,1,... */
}

第121~ 154行：去除某个platform_device时候需要调用led_class_destroy_device(i);将文件设备节点销毁

static int chip_demo_gpio_remove(struct platform_device *pdev)
{int i = 0;int err;struct device_node *np;int led_pin;np = pdev->dev.of_node;if (!np)return -1;err = of_property_read_u32(np, "pin", &led_pin);for (i = 0; i < g_ledcnt; i++){if (g_ledpins[i] == led_pin){led_class_destroy_device(i);g_ledpins[i] = -1;break;};}for (i = 0; i < g_ledcnt; i++){if (g_ledpins[i] != -1)break;}if (i == g_ledcnt)g_ledcnt = 0;return 0;
}

根据pin属性消除设备

 for (i = 0; i < g_ledcnt; i++){if (g_ledpins[i] == led_pin){led_class_destroy_device(i);g_ledpins[i] = -1;break;};}

3.3 Makefile


# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR
# 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量:
# 2.1 ARCH,          比如: export ARCH=arm64
# 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu-
# 2.3 PATH,          比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin 
# 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同,
#       请参考各开发板的高级用户使用手册KERN_DIR = /home/book/100ask_imx6ull-sdk/Linux-4.9.88all:make -C $(KERN_DIR) M=`pwd` modules $(CROSS_COMPILE)gcc -o ledtest ledtest.c clean:make -C $(KERN_DIR) M=`pwd` modules cleanrm -rf modules.orderrm -f ledtest# 参考内核源码drivers/char/ipmi/Makefile
# 要想把a.c, b.c编译成ab.ko, 可以这样指定:
# ab-y := a.o b.o
# obj-m += ab.oobj-m += leddrv.o chip_demo_gpio.o

3.4 ledtest.c


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>/** ./ledtest /dev/100ask_led0 on* ./ledtest /dev/100ask_led0 off*/
int main(int argc, char **argv)
{int fd;char status;/* 1. 判断参数 */if (argc != 3) {printf("Usage: %s <dev> <on | off>\n", argv[0]);return -1;}/* 2. 打开文件 */fd = open(argv[1], O_RDWR);if (fd == -1){printf("can not open file %s\n", argv[1]);return -1;}/* 3. 写文件 */if (0 == strcmp(argv[2], "on")){status = 1;write(fd, &status, 1);}else{status = 0;write(fd, &status, 1);}close(fd);return 0;
}

四、上机测试

4.1编译

编译程序，把代码上传代服务器后执行 make 命令。

cp *.ko ledtest ~/nfs_rootfs/

4.2 挂载到开发板

在开发板上挂载 NFS

4.3 修改设备树

//进入内核修改设备树
book@100ask:~$ cd 100ask_imx6ull-sdk/
book@100ask:~/100ask_imx6ull-sdk$ cd Linux-4.9.88/

内核源码目录中 arch/arm/boot/dts/100ask_imx6ull-14x14.dts 修改、编译后得到 arch/arm/boot/dts/100ask_imx6ull-14x14.dtb 文件。

book@100ask:~/100ask_imx6ull-sdk/Linux-4.9.88$ vi arch/arm/boot/dts/100ask_imx6ull-14x14.dts

加入我们之前写好了的设备节点

修改后重新编译后得到 arch/arm/boot/dts/100ask_imx6ull-14x14.dtb 文件拷贝到开发板上

book@100ask:~/100ask_imx6ull-sdk/Linux-4.9.88$ make dtbs

book@100ask:~/100ask_imx6ull-sdk/Linux-4.9.88$ cp arch/arm/boot/dts/100ask_imx6ull-14x14.dtb ~/nfs_rootfs/

将100ask_imx6ull-14x14.dtb 放到boot目录下后重启开发板

[root@100ask:/mnt]# cp /mnt/100ask_imx6ull-14x14.dtb /boot/
[root@100ask:/mnt]# reboot

4.4 调试技巧

4.4.1 设备树信息

/sys 目录下有很多内核、驱动的信息。以下目录对应设备树的根节点，可以从此进去找到自己定义的节点。cd /sys/firmware/devicetree/base/

[root@100ask:~]# cd /sys/firmware/devicetree/base/
[root@100ask:/sys/firmware/devicetree/base]# ls -ld 100ask*

节点是目录，属性是文件。属性值是字符串时，用 cat 命令可以打印出来；属性值是数值时，用 hexdump 命令可以打印出来。

[root@100ask:/sys/firmware/devicetree/base]# cd 100ask_led\@0
[root@100ask:/sys/firmware/devicetree/base/100ask_led@0]# ls
[root@100ask:/sys/firmware/devicetree/base/100ask_led@0]# cat compatible
100as,leddrv[root@100ask:/sys/firmware/devicetree/base/100ask_led@0]# cat pin
[root@100ask:/sys/firmware/devicetree/base/100ask_led@0]# hexdump pin
0000000 0300 0100
0000004

4.4.2 platform_device 的信息

以下目录含有注册进内核的所有 platform_device：/sys/devices/platform

一个设备对应一个目录，进入某个目录后，如果它有“driver”子目录，就表示这个 platform_device 跟某个 platform_driver 配对了。

比如下面的结果中，平台设备“ff8a0000.i2s”已经跟平台驱动“rockchip-i2s”配对了：

4.4.3 platform_driver 的信息

以下目录含有注册进内核的所有 platform_driver：/sys/bus/platform/drivers

一个 driver 对应一个目录，进入某个目录后，如果它有配对的设备，可以直接看到。

[root@100ask:/sys/firmware/devicetree/base/100ask_led@0]# cd /sys/bus/platform/drivers

比如下面的结果中，平台驱动“rockchip-i2s”跟 2 个平台设备“平台设备“ff890000.i2s”、“ff8a0000.i2s”配对了：

注意：一个平台设备只能配对一个平台驱动，一个平台驱动可以配对多个平台设备。

4.5 重新装载驱动程序

[root@100ask:/sys/devices/platform]# insmod /mnt/leddrv.ko
[root@100ask:/sys/devices/platform]# insmod /mnt/chip_demo_gpio.ko

大佬觉得有用的话点个赞 👍🏻 呗。
❤️❤️❤️本人水平有限，如有纰漏，欢迎各位大佬评论批评指正！😄😄😄

💘💘💘如果觉得这篇文对你有帮助的话，也请给个点赞、收藏下吧，非常感谢!👍 👍 👍

🔥🔥🔥任务在无形中完成，价值在无形中升华,让我们一起加油吧！🌙🌙🌙