Linux字符设备驱动-详解与实操：驱动架构、设备树、Pinctrl子系统和GPIO子 ...

怎样编写一个驱动程序：

（1）确定主设备号
（2）定义自己的file_operations结构体：
                        包含对应的open(drv_open)/read(drv_read)等设备操作函数，必要到内核中去注册
（3）实现对应的open/read/write等函数，填入file_operations结构体
（4）把file_operations结构体告诉内核：注册驱动程序
                        要把file_operations结构体注册到内核中，应用程序才气调用对应的操作函数
（5）谁来注册驱动程序啊？得由一个入口函数：安装设备驱动程序时，就会去调用这个入口函数
                        用register_chrdev（major（设备号），file_operations）
                        注册的设备放入chrdevs[ ]数组里记录
（6）有入口函数就应该有出口函数：卸载驱动程序时，会去调用这个出口函数
                        用unregister_chardev(    )
                        从chrdevs[ ]数组中去掉该设备
（7）其他美满“提供设备信息，自动创建立备节点
                        设备节点创建：class_create、device_create
每一步的代码详解

驱动框架：最简朴的驱动程序-单个LED

1、字符设备名字在注册设备号时指定：“100ask_led”

字符设备驱动注册
register_chrdev(unsigned int major, const char *name, const struct file_operations *fops)
        第一个参数：主设备号，0由系统分配
        第二个参数：字符设备名字
        第三个参数：要注册的file_operation结构体
返回值：major为0时，返回一个自动分配的设备号

设备号分配为240
2、类和设备节点创建
类：同一个类别的设备，比如led中的led0、led1
设备节点：具体有几个设备，通过对具体的设备节点操作
每个设备节点都是一个文件，对设备的操作也是对文件的读取和写入

（1）设备类创建：
class_create(struct module *owner, const char *name)        
        第一个参数：拥有这个类的指针，‘THIS_MODULE’宏，代表当前加载的模块
        第二参数：设备类名字。该名字位于/sys/class目录下。
是udev等用户空间工具用来识别和操作设备的关键标识。

sys/class中可以查看已经创建的类
（2）设备节点创建：
device_create(struct class *class, struct device *parent,
     dev_t devt, void *drvdata, const char *fmt, ...)
                第一个参数：设备类的指针
                第二个参数：父设备的指针，一样寻常为NULL
                第三个参数：设备类型和编号的组成，MKDEV宏生成，代表设备的主设备号和次设备号
                第四个参数：用于通报数据，可设为NULL。
                第五个参数：设备节点的名字

/dev/中可查看创建的设备
3、字符设备驱动、设备类、设备节点的销毁

（1）设备节点销毁
device_destroy（）：第一个参数，设备类指针，哪个设备类。第二个参数：MKDEV宏，指定设备的主设备号和次设备号
（2）设备类销毁
class_destroy（）：第一个参数，设备类指针。
（3）设备驱动销毁
unregister_chrdev（）：第一个参数，要销毁的主设备号，第二个参数，字符设备名字
4、寄存器变量：
（1）寄存器变量定义

volatile防止编译器优化
定义的变量为指针（地址），赋值的值就是指向一个地址
（2）寄存器变量映射

映射到实际的地址空间中
ioremap（）：
        第一个参数：必要映射的物理地址起始点
        第二个参数：要映射的内存区域大小，单元字节
（3）对寄存器的操作

5、file_operation函数
（1）结构体成员初始化

操作符（.）用于访问结构体的成员，.fb_fillrect = cfb_fillrect这行代码是在初始化一个结构体时使用的语法，这种语法特别用于结构体的直接初始化。
在C语言中，当你使用一个函数的名称而不加任何括号时，你实际上是在引用那个函数的地址。（即函数名作为地址使用）

结构体在内核中的定义：
struct file_operations {
    struct module *owner;
    ssize_t            (*write)(struct file *, const char __user *, size_t, loff_t *);
    int                 (*open)(struct inode *, struct file *);
    // 其他成员...
};
（2）成员变量初始化的函数：

a、设备打开操作函数
led_open（）：
        第一个参数：指向‘inode’结构体
                              ‘inode’中记录了文件数据自己外的所有信息，比如文件权限、文件大小等
                              ‘inode’结构体可以获取主、次设备号
                               通过‘inode’的‘i_cdev’字段，驱动可以访问与设备相关联的‘cdev’结构，该结构                                 包含设备的核心信息和操作
        第二个参数：指向‘struct file’结构体的指针，表示用户打开的文件形貌符。
                              该结构体是用户程序与内核之间的关键接口。
b、写操作函数:
led_write（）：
        第一个参数：指向‘struct file’结构体的指针，表示打开的文件对象
                                此中的‘private_data’字段可用来存储特定于设备的数据
        第二个参数：要写入设备的数据缓冲区
        第三个参数：buf的数据字节数
        第四个参数：文件当前位置的偏移量（不支持寻址的设备不重要）
6、应用层：

argc：通报给程序的参数总数
argv：指针数组，每个元素指向一个字符数组的指针（字符串）

argv[1]：/dev/myled  设备节点名字
fd：文件形貌符，整数，标识要写入的文件或设备

argv[2]：on
fd：文件形貌符
&status：指向数据缓冲区的指针
Count：要写入的字节数，指定‘buf’中有多少数据
驱动代码：led_drv.c

1. #include <linux/kernel.h>
2. #include <linux/module.h>
3. #include <linux/slab.h>
4. #include <linux/init.h>
5. #include <linux/fs.h>
6. #include <linux/delay.h>
7. #include <linux/poll.h>
8. #include <linux/mutex.h>
9. #include <linux/wait.h>
10. #include <asm/uaccess.h>
11. #include <linux/device.h>
12. #include <asm/io.h>
15. static int major;
16. static struct class *led_class;
18. /* registers */
19. //IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3地址：0x02290000 + 0x14
20. static volatile unsigned int *IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3;
22. //GPIO5_GDIR地址：0x020AC004
23. static volatile unsigned int *GPIO5_GDIR;
25. //GPIO5_DR地址：0x020AC000
26. static volatile unsigned int *GPIO5_DR;
28. static ssize_t led_write(struct file *filp, const char __user *buf,
29.                          size_t count, loff_t *ppos)
30. {
31.         char val;
32.         int ret;
33.         /* copy_from_user : get data from app */
34.         ret = copy_from_user(&val, buf, 1);
35.         /* to set gpio register: out 1/0 */
36.         if(val)
37.         {
38.                 /* set gpio to let led on  */
39.                 *GPIO5_DR &= ~(1<<3);                                //输出低电平，根据原理图低电平点亮
40.         }
41.         else
42.         {
43.                 /* set gpio to let led off  */
44.                 *GPIO5_DR |= (1<<3);                //输出高电平
45.         }
46.         return 1;
47. }
50. static int led_open(struct inode *inode, struct file *filp)
51. {
52.         /* enable gpio5
53.          * configure gpio5_io3 as gpio
54.          * configure gpio5_io3 as output
55.          */
56.         *IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 &= ~0xf;     //先清零低4位
57.         *IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 |= 0x05;     //低4位配置101
59.         *GPIO5_GDIR |= (1<<3);
60.        
61.         return 0;
62. }
65. static struct file_operations led_fops = {
66.         .owner                = THIS_MODULE,
67.         .write                = led_write,
68.         .open                = led_open,
69. };
70. /* 入口函数 */
71. static int __init led_init(void)
72. {
73.         printk("%s %s %d/n", __FILE__, __FUNCTION__, __LINE__);
75.         /* 加载字符驱动 */
76.         major = register_chrdev(0, "100ask_led", &led_fops);
78.         /* ioremap */
79.         //IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3地址：0x02290000 + 0x14
80.         IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3 = ioremap(0x02290000 + 0x14, 4);     //映射4个字节
82.         //GPIO5_GDIR地址：0x020AC004
83.         GPIO5_GDIR = ioremap(0x020AC004, 4);
85.         //GPIO5_DR地址：0x020AC000
86.         GPIO5_DR = ioremap(0x020AC000, 4);
88.         /* 创建设备节点 */
89.         led_class = class_create(THIS_MODULE, "myled");                     //要在THIS_MODULE下创建类
90.         device_create(led_class, NULL, MKDEV(major, 0), NULL, "myled0");
91.         //device_create(led_class, NULL, MKDEV(major, 1), NULL, "myled1");
92.                
93.         return 0;
94. }
96. static void __exit led_exit(void)
97. {
98.         /* iounmap */
99.         iounmap(IOMUXC_SNVS_SW_MUX_CTL_PAD_SNVS_TAMPER3);
100.         iounmap(GPIO5_GDIR);
101.         iounmap(GPIO5_DR);
102.        
103.         /* 销毁设备节点 */
104.         device_destroy(led_class, MKDEV(major, 0));
105.         class_destroy(led_class);
106.        
107.         /* 销毁字符设备驱动 */
108.         unregister_chrdev(major, "100ask_led");
109. }
111. module_init(led_init);
112. module_exit(led_exit);
113. MODULE_LICENSE("GPL");

复制代码

应用代码：ledtest.c

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <stdio.h>
9. // ledtest /dev/myled0 on
10. // ledtest /dev/myled0 off
12. int main(int argc, char **argv)
13. {
14.         int fd;
15.         char status = 0;
17.         if(argc != 3)
19.         {
20.                 printf("Usage: %s <dev> <on/off>\n", argv[0]);
21.                 printf("   eg: %s /dev/myled0 on\n", argv[0]);
22.                 printf("   eg: %s /dev/myled0 off\n", argv[0]);
23.                 return -1;
24.         }
25.        
26.         //open
27.         fd = open(argv[1], O_RDWR);
28.         if (fd < 0)
29.         {
30.                 printf("can not open %s \n", argv[0]);
31.         }
33.        
34.         //write
35.         if(strcmp(argv[2], "on")==0)
36.         {
37.                 status = 1;
38.         }
40.         write(fd, &status, 1);
41.         return 0;
42. }

复制代码

多个按键：

要对GPIO5_1和GPIO4_14配置（key1和key2）

1、定义GPIO通用设置的结构体（按照手册中寄存器的位置）

（1）GPIO_DR：Data register                    
数据寄存器（读取或写入GPIO引脚当前状态）
（2）GPIO_GDIR：GPIO direction             
方向寄存器（配置GPIO输入或输出）
（3）GPIO_PSR：Pad sample register        
 读取GPIO引脚当前状态（高电平或低电平） 
（4）GPIO_ICR1, GPIO_ICR2：Interrupt control registers
终端控制寄存器（配置GPIO引脚终端触发方式和其他中断相关设置）
（5）GPIO_EDGE_SEL：Edge select register
边沿选择寄存器（配置GPIO引脚的边沿触发类型）
（6）GPIO_IMR：Interrupt mask register
中断屏蔽寄存器（配置哪些GPIO引脚中断应该被屏蔽）
（7）GPIO_ISR：Interrupt status register
中断状态寄存器（表现当前GPIO引脚的中断状态）
2、配置过程：
（1）定义要寄存器变量（要修改的寄存器）
GPIO时钟使能、GPIO模式配置、GPIO模式下引脚配置

（2）手册中找到相应的地址，重映射

CCM_CCGR1中30-31为默认保留位，默认使能GPIO5
CCM_CCGR3中12-13位为gpio_4的时钟配置

对GPIO各寄存器的映射（按照地址顺序下来，只必要找到首个寄存器GPIOxx_DR的地址就好）

（3）给寄存器赋值

时钟配置11，第30、31位：（3<<30），对gpio的访问，从结构体中找到对应的成员变量即可

Linux内核中因为MMU的存在不能直接访问物理地址，必要通过ioremap把假造地址映射到对应的物理地址，我们对假造地址的访问，会自动修改到对应的物理地址。而结构体寄存器会映射整块对应大小的内存，里面的假造地址和物理地址也是一一对应的关系
3、怎样指定操作哪个设备
（1）通过传参which，指定该类下要操作的设备
init举行寄存器的初始化，read实现Key状态的读取（状态寄存器的读取）
CCM_CCGR1若未有值（未映射），则先完成寄存器的映射。

（2）operation操作函数中，获取要操作的次设备号，调用init或read函数

从inode设备节点中，获取次设备号，在调用操作函数
若无inode，则先从file结构体中获取inode结构体，再从中获取次设备号。
（3）设备的创建和销毁：
创建

销毁

新字符设备注册方式：

cdev结构体无论传统的还是新的注册方式都必要，传统会自动创建和注册cdev结构，新的（即设备模子）必要手动分配和初始化cdev结构，然后将其注册到内核中可以或许手动配置注册cdev，更加灵活和具备可操作性。
相比与传统的register_chrdev（），新的register_chrdev_region（）、alloc_chrdev_region优缺点对比：

• 提供对主设备和次设备号的精确控制，适合管理大量设备实例。（传统方式只能管理主设备号）
  
• 分离设备号注册和设备操作设置，在设备号分配乐成后再举行设备操作的注册。（传统方式会将设备操作一起注册）
  
• 更好地与当代内核的设备模子（如cdev）集成。（传统方式中不会单独对cdev设置，会自动注册cdev）
  

1、cdev字符设备结构

有两个最重要的成员变量

• ops：设备文件操作函数指针
  
• dev：设备号
  

2、新字符设备结构注册方式
定义一个设备结构体来记录信息（只是为了方便记录和设置信息，非内审定义，是用户自己定义的）

（1）创建立备号

若事先定义了设备号

• 将设备号赋值给devid（dev_t类型）
  

register_chrdev_region(dev_t from, unsigned count, const char *name);
        Linux内核中静态分配一个或多个一连的设备号给字符设备
        第一个参数：要注册的设备号的起始值，包含主次设备号
        第二个参数：要注册的设备号的数量（若支持多个次设备号）
        第三个参数：与设备号范围关联的名称，通常与驱动程序名字雷同
若没有定义

• 则必要申请设备号
  
• 申请乐成后，把申请到的主次设备号记录回设备结构体，方便后续调用。
  

alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, const char *name);
        Linux内核中动态分配一个或多个一连的设备号给字符设备。
        相比于 register_chrdev_region 提供了更大的灵活性，不必要指定具体的起始主设备号，而是由内核动态分配，确保不会与现有的设备号辩论。
        第一个参数：指向 dev_t 类型变量的指针，该变量在函数实行乐成后将包含分配的设备号。
        第二个参数：请求分配的次设备号，通常设为0，表示从0开始分配。
        第三个参数：必要分配的一连设备号的数量（必要的设备实例数量）
        第四个参数：与设备号关联的名称。
（2）初始化cdev

cdev_init(struct cdev *cdev, const struct file_operations *fops);
        主要任务是将字符设备结构体与对应的文件操作关联起来
        第一个参数：指向字符设备结构体的指针
        第二个参数：指向文件操作结构体的指针
（3）将cdev添加到内核的设备模子中

cdev_add(struct cdev *dev, dev_t num, unsigned int count);
        初始化完成后，cdev_add在系统中注册一个字符设备，使其处于激活状态，从而答应用户空间通过设备文件访问设备。这个过程包罗将 cdev 结构链接到内核的设备表中。
        第一个参数：已经初始化的'cdev'结构体的指针。
        第二个参数：设备号，包罗主设备号和起始的次设备号。
        第三个参数：表示与此字符设备相关的次设备号的数量。
在cdev_add是将 cdev 结构体与指定的设备号关联起来，并将其注册到内核中，使之成为系统的一部分。这个关联过程并不涉及在 cdev 结构体内部修改或设置一个 dev 成员，而是在内核的设备管理结构中建立关联。但这个设备号不是作为 cdev 结构的一部分直接存储的。
（4）创建类和设备

如果设备驱动必要管理多个设备实例，大概想在系统中更高效地使用设备号资源，使用register_chrdev_region()通常是更好的选择。这不仅可以避免次设备号的浪费，还可以保证设备号分配的明确性和系统资源的合理利用。相反，如果驱动只管理单一设备或对设备号管理的精确性要求不高，register_chrdev()可能仍然足够使用。但建议养成设备号合理管理和系统资源最优化的好习惯。
设备树：

在设备树中指定硬件资源的形貌（对LED操作）

设备树加载后，可以进入/proc/device-tree/目录下查看根节点下的节点。
1、设备树dts文件：添加led节点

设备树中的节点由一堆属性组成，不同设备必要的属性不同
（1）#address-cells、#size-cells属性：
                cell指一个32位的数值，
                #address-cells决定子节点reg属性中地址信息所占用的字长（32字节）
                #size-cells决定子节点reg属性中长度信息所占的字长

该节点用1个数表示地址，1个数表示大小
（2）compatible属性：
                值为字符串列表，可能有多个驱动支持它（多个字符串）
                将设备和驱动绑定起来，通过compatible中的名字找到要加载probe的驱动模块
（3）status属性：
设备状态
                “okay”：      表明设备是可操作的
                “disabled”：表示当前设备不可操作（禁用掉），但在将来可变为可操作的
                “fail”：         表明设备不可操作，检测到错误，不大可能变为可操作
                “fail-sss”：   含义与“fail”雷同，背面的sss部分是检测到的错误内容
（4）reg属性：
                reg属性的值一样寻常是（address，length）对。
                一样寻常用于形貌设备地址空间资源信息，一样寻常是某个外设的寄存器地址范围信息。
2、驱动程序：获取硬件资源（获取设备树中的属性数据）
led_init（）函数中

（1）获取设备节点：alphaled

获取设备节点后，才气获取属性内容
of_find_node_by_path()：
用于操作设备树的函数，主要作用是根据给定的设备树路径来查找并返回对应的设备树节点。
                参数：设备树中的一个路径，根节点开始的绝对路径。
                dtsled.nd为device_node结构体的指针
（2）获取设备节点属性，包罗reg
获取compatible属性内容

获取status属性内容

获取reg属性内容，必须要先获取设备节点dtsled.nd

of_property_read_u32_array( );
从设备节点中读取一个包含多个'u32'元素的属性到一个用户提供的数组中。
                第一个参数：指向设备树节点的指针
                第二个参数：要读取的设备树属性的名称。
                第三个参数：用户提供的数组，用于存储读取到的数据。
                第四个参数：希望读取到的元素的数量。
（3）寄存器地址映射

其他对寄存器的操作一样

Pinctrl和GPIO子系统：

省去了对硬件的寄存器的复杂配置（对LED操作）

Pinctrl：设置pin的复用和电气属性
GPIO子系统：若pinctcl子系统将一个pin复用为GPIO的话，接下里就会用到gpio子系统了
用于初始化gpio并提供相应的API函数，对gpio操作
设备树：
1、pinctrl节点：
在 iomuxc 节点的 imx6ul-evk 子节点下创建一个名为“pinctrl_led”的子节点

（1）label：node-name@unit-address
                label：方便访问节点，可以通过&label来访问这个节点。
                node-name：节点名字。
                unit-address：设备的地址或寄存器首地址，若节点没有地址或寄存器，可以不要。
（2）MX6UL_PAD_GPIO1_IO03__GPIO1_IO03
                MX6UL                   - 表示芯片或处置惩罚器的型号
                PAD_GPIO1_IO03   - 引脚的物理位置或名称
                GPIO1_IO03            - 引脚的复勤奋能，复用为GPIO1的第03号引脚
（3）0x10B0：引脚配置寄存器的值，定义了引脚的各种电气属性。
                如上拉/下拉电阻、驱动能力、速度等
                在这一步已经完成了引脚的配置
2、LED设备节点
在根节点“/”下创建LED灯节点，节点名为“gpioled”

（1）pinctrl-0属性，6行：设置LED灯所使用的PIN对应的pinctrl节点。
要检测PIN是否被其他外设使用，要将其关掉（status="disabled"等）。
（2）led-gpio属性，7行：指定LED灯所使用的GPIO，GPIO1的IO03，低电平有用。
驱动程序中会获取led-gpio属性内容得到GPIO编号，因为gpio子系统的API操作函数必要GPIO编号。
驱动程序：
1、设备节点结构体定义：

2、gpio子系统控制引脚
（1）获取设备节点：

（2）获取设备树中的gpio属性，得到LED所使用的GPIO编号

of_get_named_gpio（）：
读取设备树中定义的GPIO属性，将其转换为GPIO编号。通过此编号可以在驱动中请求、配置和控制GPIO。
                第一个参数：指向‘device_node’的指针，表示当前设备的设备树节点
                第二个参数：节点中GPIO属性的名字。
                第三个参数：索引，表示有多个GPIO同一属性下定义是，应选择哪一个。
（3）设置gpio为输出，并且输出高电平，默认关闭LED灯
（在对gpio设置前要先用gpio_request（）申请这个gpio的控制权，确保资源不辩论）

gpio_direction_output（）：
Linux内核中提供的操作GPIO的函数，设置指定引脚为输出模式。
                第一个参数：GPIO引脚的编号，标识要设置哪个引脚
                第二个参数：设置GPIO引脚的初始电平，“1”高电平
（4）设置gpio的值

dev是指向gpioled_dev结构体的指针
gpio_set_value（）：
设置指定GPIO引脚的输出电平。
                第一个参数：GPIO引脚编号。
                第二个参数：设置GPIO引脚的初始电平。

Platform设备驱动（无设备树程序）：

驱动的分层和分离。

将驱动中的硬件部分分离出来为platform_device，保留的驱动为platform_driver，通过总线匹配注册probe。设备树实质上就是platform_device这部分，替代了原先必要每次编写和加载的.c文件，每次自动加载和生成platform_device。

platform结构体详解、定义和框架可参考上篇博客：
Linux驱动进化：传统模子、设备总线驱动模子、设备树-CSDN博客
1、leddevice.c硬件资源（paltform_device）：
（1）resource

struct resource：
                start：资源的起始地址
                end：资源的竣事地址
                name：资源的名称
                flags：资源类型和属性标志
（2）platform_device结构体

名字为“imx6ul-led”以和platform_deriver配对
（3）注册platform_device结构体
便于通过总线bus和platform_driver配对

2、platform_driver：
（1）从platform_device中获取资源（led_probe函数）

platform_get_resource（）：
用于从平台设备中获取特定类型和序号的资源。        
                第一个参数：指向“platform_device”结构的指针，表示正在被操作的平台设备。
                第二个参数：资源类型标志，指定要获取的资源类型。IORESOURCE_MEM表示一个内                                         存类型的资源。
                第三个参数：资源的索引，设备的资源有多个，要获取哪一个。
（2）初始化LED

设置寄存器的初始值：···省略
（3）platform_driver结构体

通过名字"imx6ul-led"和device匹配。
（4）注册platform_driver
通过bus总线和platform_driver配对后会自动调用probe函数完成资源初始化

3、匹配过程：
驱动模块加载完后，到/sys/bus/platform/drivers/目录下

led的设备文件在/sys/bus/platform/devices/目录下

驱动和设备匹配

设备树下的Platform设备驱动：

前面已经实现了设备树（加载设备树时会自动生成platform_device），这里只看platform_driver
leddriver.c
1、初始化IO
（1）从设备树中获取设备节点

（2）获取设备树中的gpio属性，得到LED所使用的GPIO编号

（3） Linux 内核中用于请求一个 GPIO（通用输入输出）引脚的使用权。之后操作gpio引脚

gpio_request（）：
Linux内核中用于请求一个GPIO引脚的使用权
                第一个参数：要申请的GPIO引脚的编号。
                第二个参数：请求的GPIO引脚相关联的标签或名称，可自定义。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。