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

这篇具有很好参考价值的文章主要介绍了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 驱动开发基础知识——LED 模板驱动程序的改造：设备树（十一）,Linux 驱动开发基础知识,linux,运维,服务器,驱动开发,设备驱动框架,LED驱动,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.88

all:
	make -C $(KERN_DIR) M=`pwd` modules 
	$(CROSS_COMPILE)gcc -o ledtest ledtest.c 

clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order
	rm -f ledtest

# 参考内核源码drivers/char/ipmi/Makefile
# 要想把a.c, b.c编译成ab.ko, 可以这样指定:
# ab-y := a.o b.o
# obj-m += ab.o



obj-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/

Linux 驱动开发基础知识——LED 模板驱动程序的改造：设备树（十一）,Linux 驱动开发基础知识,linux,运维,服务器,驱动开发,设备驱动框架,LED驱动,linux驱动基础内核源码目录中 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”配对了：

当出现 /sys/devices/platform 路径下找不到设备的情况时

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”配对了：

针对以上问题可以这样查看，后面的路径应该就是platform_driver 的信息

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

4.5 重新装载驱动程序

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

4.6 模拟效果

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

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

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

Linux 驱动开发基础知识——LED 模板驱动程序的改造：设备树（十一）,Linux 驱动开发基础知识,linux,运维,服务器,驱动开发,设备驱动框架,LED驱动,linux驱动基础文章来源地址https://www.toymoban.com/news/detail-832409.html

到了这里，关于Linux 驱动开发基础知识——LED 模板驱动程序的改造：设备树（十一）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

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