【正点原子Linux连载】 第七章 新字符设备驱动实验 摘自【正点原子】ATK-DLRK3568嵌入式Linux驱动开发指南

1）实验平台：正点原子ATK-DLRK3568开发板
2）平台购买地址：https://detail.tmall.com/item.htm?id=731866264428
3）全套实验源码+手册+视频下载地址： http://www.openedv.com/docs/boards/xiaoxitongban

第七章 新字符设备驱动实验

经过前两章实验的实战操作，我们已经掌握了Linux字符设备驱动开发的基本步骤，字符设备驱动开发重点是使用register_chrdev函数注册字符设备，当不再使用设备的时候就使用unregister_chrdev函数注销字符设备，驱动模块加载成功以后还需要手动使用mknod命令创建设备节点。register_chrdev和unregister_chrdev这两个函数是老版本驱动使用的函数，现在新的字符设备驱动已经不再使用这两个函数，而是使用Linux内核推荐的新字符设备驱动API函数。本节我们就来学习一下如何编写新字符设备驱动，并且在驱动模块加载的时候自动创建设备节点文件。

7.1 新字符设备驱动原理
7.1.1 分配和释放设备号
使用register_chrdev函数注册字符设备的时候只需要给定一个主设备号即可，但是这样会带来两个问题：
①、需要我们事先确定好哪些主设备号没有使用。
②、会将一个主设备号下的所有次设备号都使用掉，比如现在设置LED这个主设备号为200，那么0~1048575(2^20-1)这个区间的次设备号就全部都被LED一个设备分走了。这样太浪费次设备号了！一个LED设备肯定只能有一个主设备号，一个次设备号。
解决这两个问题最好的方法就是在使用设备号的时候向Linux内核申请，需要几个就申请几个，由Linux内核分配设备可以使用的设备号。这个就是我们在5.3.2小节讲解的设备号的分配，如果没有指定设备号的话就使用如下函数来申请设备号：
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
如果给定了设备的主设备号和次设备号就使用如下所示函数来注册设备号即可：
int register_chrdev_region(dev_t from, unsigned count, const char *name)
参数from是要申请的起始设备号，也就是给定的设备号；参数count是要申请的数量，一般都是一个；参数name是设备名字。
注销字符设备之后要释放掉设备号，不管是通过alloc_chrdev_region函数还是register_chrdev_region函数申请的设备号，统一使用如下释放函数：
void unregister_chrdev_region(dev_t from, unsigned count)
新字符设备驱动下，设备号分配示例代码如下：
示例代码7.1.1.1 新字符设备驱动下设备号分配

1  int major;           					/* 主设备号 					*/
2  int minor;           					/* 次设备号 					*/
3  dev_t devid;     						/* 设备号 					*/
4  
5  if (major) {     						/* 定义了主设备号 			*/
6  		devid = MKDEV(major, 0);			/* 大部分驱动次设备号都选择0	*/
7   	register_chrdev_region(devid, 1, "test");
8  } else {                     			/* 没有定义设备号 			*/
9   	alloc_chrdev_region(&devid, 0, 1, "test");  /* 申请设备号	*/
10  	major = MAJOR(devid);   			/* 获取分配号的主设备号 		*/
11  	minor = MINOR(devid);   			/* 获取分配号的次设备号 		*/
12 }
1
2
3
4
5
6
7
8
9
10
11
12

第1~3行，定义了主/次设备号变量major和minor，以及设备号变量devid。
第5行，判断主设备号major是否有效，在Linux驱动中一般给出主设备号的话就表示这个设备的设备号已经确定了，因为次设备号基本上都选择0，这个算Linux驱动开发中约定俗成的一种规定了。
第6行，如果major有效的话就使用MKDEV来构建设备号，次设备号选择0。
第7行，使用register_chrdev_region函数来注册设备号。
第9~11行，如果major无效，那就表示没有给定设备号。此时就要使用alloc_chrdev_region函数来申请设备号。设备号申请成功以后使用MAJOR和MINOR来提取出主设备号和次设备号，当然了，第10和11行提取主设备号和次设备号的代码可以不要。
如果要注销设备号的话，使用如下代码即可：
1
2
3
4
5
6

示例代码7.1.1.2 cdev结构体
1 unregister_chrdev_region(devid, 1); /* 注销设备号 */
注销设备号的代码很简单。
7.1.2 新的字符设备注册方法
1、字符设备结构
在Linux中使用cdev结构体表示一个字符设备，cdev结构体在include/linux/cdev.h文件中的定义如下：
示例代码7.1.2.1 cdev结构体

1 struct cdev {
2   	struct kobject 	kobj;
3   	struct module 		*owner;
4   	const struct file_operations *ops;
5   	struct list_head 	list;
6   	dev_t 				dev;
7   	unsigned int 		count;
8 } __randomize_layout;
1
2
3
4
5
6
7
8

在cdev中有两个重要的成员变量：ops和dev，这两个就是字符设备文件操作函数集合file_operations以及设备号dev_t。编写字符设备驱动之前需要定义一个cdev结构体变量，这个变量就表示一个字符设备，如下所示：
1

struct cdev test_cdev;
2、cdev_init函数
定义好cdev变量以后就要使用cdev_init函数对其进行初始化，cdev_init函数原型如下：
void cdev_init(struct cdev *cdev, const struct file_operations *fops)
参数cdev就是要初始化的cdev结构体变量，参数fops就是字符设备文件操作函数集合。使用cdev_init函数初始化cdev变量的示例代码如下：
示例代码7.1.2.2 cdev_init函数使用示例代码

1  struct cdev testcdev;
2  
3  /* 设备操作函数 */
4  static struct file_operations test_fops = {
5   	.owner = THIS_MODULE,
6   	/* 其他具体的初始项 */
7  };
8  
9  testcdev.owner = THIS_MODULE;
10 cdev_init(&testcdev, &test_fops); /* 初始化cdev结构体变量 */
1
2
3
4
5
6
7
8
9
10

3、cdev_add函数
cdev_add函数用于向Linux系统添加字符设备(cdev结构体变量)，首先使用cdev_init函数完成对cdev结构体变量的初始化，然后使用cdev_add函数向Linux系统添加这个字符设备。cdev_add函数原型如下：
1
2

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
参数p指向要添加的字符设备(cdev结构体变量)，参数dev就是设备所使用的设备号，参数count是要添加的设备数量。完善示例代码7.1.2.2，加入cdev_add函数，内容如下所示：
示例代码7.1.2.2 cdev_add函数使用示例

1  struct cdev testcdev;
2  
3  /* 设备操作函数 */
4  static struct file_operations test_fops = {
5   	.owner = THIS_MODULE,
6   	/* 其他具体的初始项 */
7  };
8  
9  testcdev.owner = THIS_MODULE;
10 cdev_init(&testcdev, &test_fops);    	/* 初始化cdev结构体变量	*/
11 cdev_add(&testcdev, devid, 1);       	/* 添加字符设备   			*/
1
2
3
4
5
6
7
8
9
10
11

示例代码7.1.2.2就是新的注册字符设备代码段，Linux内核中大量的字符设备驱动都是采用这种方法向Linux内核添加字符设备。如果在加上示例代码7.1.1.1中分配设备号的程序，那么它们就一起实现的就是函数register_chrdev的功能。
3、cdev_del函数
卸载驱动的时候一定要使用cdev_del函数从Linux内核中删除相应的字符设备，cdev_del函数原型如下：
1
2
3

void cdev_del(struct cdev p)
参数p就是要删除的字符设备。如果要删除字符设备，参考如下代码：
示例代码7.1.2.3 cdev_del函数使用示例
1 cdev_del(&testcdev); / 删除cdev */
cdev_del和unregister_chrdev_region这两个函数合起来的功能相当于unregister_chrdev函数。
7.2 自动创建设备节点
在前面的Linux驱动实验中，当我们使用modprobe加载驱动程序以后还需要使用命令“mknod”手动创建设备节点。本节就来讲解一下如何实现自动创建设备节点，在驱动中实现自动创建设备节点的功能以后，使用modprobe加载驱动模块成功的话就会自动在/dev目录下创建对应的设备文件。
7.2.1 mdev机制
udev是一个用户程序，在Linux下通过udev来实现设备文件的创建与删除，udev可以检测系统中硬件设备状态，可以根据系统中硬件设备状态来创建或者删除设备文件。比如使用modprobe命令成功加载驱动模块以后就自动在/dev目录下创建对应的设备节点文件,使用rmmod命令卸载驱动模块以后就删除掉/dev目录下的设备节点文件。
开发板启动的时候会启动udev，如图7.2.1.1所示：

图7.2.1.1 启动udev
7.2.1 创建和删除类
自动创建设备节点的工作是在驱动程序的入口函数中完成的，一般在cdev_add函数后面添加自动创建设备节点相关代码。首先要创建一个class类，class是个结构体，定义在文件include/linux/device.h里面。class_create是类创建函数，class_create是个宏定义，内容如下：
示例代码7.2.1.1 class_create函数

546 extern struct class * __must_check __class_create(struct module 
547                           *owner,const char *name,
548                           struct lock_class_key *key);
549 extern void class_destroy(struct class *cls);
550 
551 /* This is a #define to keep the compiler from merging different
552  * instances of the __key variable */
553 #define class_create(owner, name)       \
554 ({                      \
555     static struct lock_class_key __key; \
556     __class_create(owner, name, &__key);    \
557 })
1
2
3
4
5
6
7
8
9
10
11
12

根据上述代码，将宏class_create展开以后内容如下：
1

struct class *class_create (struct module *owner, const char *name)
class_create一共有两个参数，参数owner一般为THIS_MODULE，参数name是类名字。返回值是个指向结构体class的指针，也就是创建的类。
卸载驱动程序的时候需要删除掉类，类删除函数为class_destroy，函数原型如下：
void class_destroy(struct class *cls);
参数cls就是要删除的类。
7.2.2 创建设备
上一小节创建好类以后还不能实现自动创建设备节点，我们还需要在这个类下创建一个设备。使用device_create函数在类下面创建设备，device_create函数原型如下：

struct device *device_create(struct class 	*class, 
struct device 	*parent, 
dev_t 		devt, 
void 			*drvdata, 
const char 	*fmt, ...)
1
2
3
4
5

device_create是个可变参数函数，参数class就是设备要到创建哪个类下面；参数parent是父设备，一般为NULL，也就是没有父设备；参数devt是设备号；参数drvdata是设备可能会使用的一些数据，一般为NULL；参数fmt是设备名字，如果设置fmt=xxx的话，就会生成/dev/xxx这个设备文件。返回值就是创建好的设备。
同样的，卸载驱动的时候需要删除掉创建的设备，设备删除函数为device_destroy，函数原型如下：
1
2

void device_destroy(struct class *cls, dev_t devt)
参数classs是要删除的设备所处的类，参数devt是要删除的设备号。
7.2.3 参考示例
在驱动入口函数里面创建类和设备，在驱动出口函数里面删除类和设备，参考示例如下：
示例代码7.2.3.1 创建/删除类/设备参考代码

1  struct class *class; 		/* 类 		*/       
2  struct device *device;   	/* 设备 	*/
3  dev_t devid;         		/* 设备号 	*/         
4  
5  /* 驱动入口函数 */ 
6  static int __init xxx_init(void)
7  {
8   	/* 创建类 	*/
9   	class = class_create(THIS_MODULE, "xxx");
10 	 	/* 创建设备 */
11  	device = device_create(class, NULL, devid, NULL, "xxx");
12  	return 0;
13 }
14 
15 /* 驱动出口函数 */
16 static void __exit led_exit(void)
17 {
18  	/* 删除设备 */
19  	device_destroy(newchrled.class, newchrled.devid);
20  	/* 删除类   */
21  	class_destroy(newchrled.class);
22 }
23 
24 module_init(led_init);
25 module_exit(led_exit);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

7.3 设置文件私有数据
每个硬件设备都有一些属性，比如主设备号(dev_t)，类(class)、设备(device)、开关状态(state)等等，在编写驱动的时候你可以将这些属性全部写成变量的形式，如下所示：
示例代码7.3.1 变量形式的设备属性

dev_t devid;            	/* 设备号   	*/
struct cdev cdev;       	/* cdev   	*/
struct class *class;    	/* 类      	*/
struct device *device;  	/* 设备    	*/
int major;              	/* 主设备号	*/
int minor;              	/* 次设备号 	*/
1
2
3
4
5
6

这样写肯定没有问题，但是这样写不专业！对于一个设备的所有属性信息我们最好将其做成一个结构体。编写驱动open函数的时候将设备结构体作为私有数据添加到设备文件中，如下所示：
1

示例代码7.3.2 设备结构体作为私有数据
/* 设备结构体 */

1  struct test_dev{
2   	dev_t devid;            	/* 设备号    	*/
3   	struct cdev cdev;       	/* cdev     	*/
4   	struct class *class;   	/* 类      		*/
5   	struct device *device;  	/* 设备    		*/
6   	int major;              	/* 主设备号   	*/
7   	int minor;              	/* 次设备号   	*/
8  };
9  
10 struct test_dev testdev;
11  
12 /* open函数 */
13 static int test_open(struct inode *inode, struct file *filp)
14 {
15  	filp->private_data = &testdev; /* 设置私有数据 */
16  	return 0;
17 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在open函数里面设置好私有数据以后，在write、read、close等函数中直接读取private_data即可得到设备结构体。
1

7.4 硬件原理图分析
本实验的硬件原理参6.2小节即可。
7.5 实验程序编写
本实验对应的例程路径为：开发板光盘 06、Linux驱动例程源码03_newchrled。
本章实验在上一章实验的基础上完成，重点是使用了新的字符设备驱动、设置了文件私有数据、添加了自动创建设备节点相关内容。
7.5.1 LED灯驱动程序编写
新建名为“03_newchrled”文件夹，然后在03_newchrled文件夹里面创建vscode工程，工作区命名为“newchrled”。工程创建好以后新建newchrled.c文件，在newchrled.c里面输入如下内容：
示例代码7.5.1.1 newchrled.c文件

1   #include <linux/types.h>
2   #include <linux/kernel.h>
3   #include <linux/delay.h>
4   #include <linux/ide.h>
5   #include <linux/init.h>
6   #include <linux/module.h>
7   #include <linux/errno.h>
8   #include <linux/gpio.h>
9   #include <linux/cdev.h>
10  #include <linux/device.h>
11  //#include <asm/mach/map.h>
12  #include <asm/uaccess.h>
13  #include <asm/io.h>
14  /***************************************************************
15  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
16  文件名       : newchrled.c
17  作者          : 正点原子
18  版本          : V1.0
19  描述          : LED驱动文件。
20  其他          : 无
21  论坛          : www.openedv.com
22  日志          : 初版V1.0 2022/12/02 正点原子团队创建
23  ***************************************************************/
24  #define NEWCHRLED_CNT           1                   /* 设备号个数  */
25  #define NEWCHRLED_NAME          "newchrled"     /* 名字       */
26  #define LEDOFF                  0                   /* 关灯       */
27  #define LEDON                   1                   /* 开灯       */
28 
29  #define PMU_GRF_BASE                (0xFDC20000)
30  #define PMU_GRF_GPIO0C_IOMUX_L  (PMU_GRF_BASE + 0x0010)
31  #define PMU_GRF_GPIO0C_DS_0     (PMU_GRF_BASE + 0X0090)
32 
33  #define GPIO0_BASE              (0xFDD60000)
34  #define GPIO0_SWPORT_DR_H       (GPIO0_BASE + 0X0004)
35  #define GPIO0_SWPORT_DDR_H  (GPIO0_BASE + 0X000C)
36 
37  /* 映射后的寄存器虚拟地址指针 */
38  static void __iomem *PMU_GRF_GPIO0C_IOMUX_L_PI;
39  static void __iomem *PMU_GRF_GPIO0C_DS_0_PI;
40  static void __iomem *GPIO0_SWPORT_DR_H_PI;
41  static void __iomem *GPIO0_SWPORT_DDR_H_PI;
42 
43  /* newchrled设备结构体 */
44  struct newchrled_dev{
45      dev_t devid;                /* 设备号        */
46      struct cdev cdev;           /* cdev         */
47      struct class *class;        /* 类              */
48      struct device *device;      /* 设备           */
49      int major;                  /* 主设备号     */
50      int minor;                  /* 次设备号     */
51  };
52 
53  struct newchrled_dev newchrled; /* led设备 */
54 
55  /*
56   * @description     : LED打开/关闭
57   * @param - sta     : LEDON(0) 打开LED，LEDOFF(1) 关闭LED
58   * @return          : 无
59   */
60  void led_switch(u8 sta)
61  {
62      u32 val = 0;
63      if(sta == LEDON) {
64          val = readl(GPIO0_SWPORT_DR_H_PI);
65          val &= ~(0X1 << 0); /* bit0 清零*/
66          val |= ((0X1 << 16) | (0X1 << 0));  /* bit16 置1，允许写bit0，
67                                             bit0，高电平*/
68          writel(val, GPIO0_SWPORT_DR_H_PI);
69      }else if(sta == LEDOFF) { 
70          val = readl(GPIO0_SWPORT_DR_H_PI);
71          val &= ~(0X1 << 0); /* bit0 清零*/
72          val |= ((0X1 << 16) | (0X0 << 0));  /* bit16 置1，允许写bit0，
73                                             bit0，低电平 */
74          writel(val, GPIO0_SWPORT_DR_H_PI);
75      } 
76  }
77 
78  /*
79   * @description     : 物理地址映射
80   * @return          : 无
81   */
82  void led_remap(void)
83  {
84      PMU_GRF_GPIO0C_IOMUX_L_PI = ioremap(PMU_GRF_GPIO0C_IOMUX_L, 4);
85      PMU_GRF_GPIO0C_DS_0_PI = ioremap(PMU_GRF_GPIO0C_DS_0, 4);
86      GPIO0_SWPORT_DR_H_PI = ioremap(GPIO0_SWPORT_DR_H, 4);
87      GPIO0_SWPORT_DDR_H_PI = ioremap(GPIO0_SWPORT_DDR_H, 4);
88  }
89 
90  /*
91   * @description     : 取消映射
92   * @return          : 无
93   */
94  void led_unmap(void)
95  {
96      /* 取消映射 */
97      iounmap(PMU_GRF_GPIO0C_IOMUX_L_PI);
98      iounmap(PMU_GRF_GPIO0C_DS_0_PI);
99      iounmap(GPIO0_SWPORT_DR_H_PI);
100     iounmap(GPIO0_SWPORT_DDR_H_PI);
101 }
102
103 /*
104  * @description     : 打开设备
105  * @param – inode : 传递给驱动的inode
106  * @param - filp    : 设备文件，file结构体有个叫做private_data的成员变量
107  *                    一般在open的时候将private_data指向设备结构体。
108  * @return          : 0 成功;其他 失败
109  */
110 static int led_open(struct inode *inode, struct file *filp)
111 {
112     filp->private_data = &newchrled; /* 设置私有数据 */
113     return 0;
114 }
115
116 /*
117  * @description     : 从设备读取数据 
118  * @param - filp    : 要打开的设备文件(文件描述符)
119  * @param - buf     : 返回给用户空间的数据缓冲区
120  * @param - cnt     : 要读取的数据长度
121  * @param - offt    : 相对于文件首地址的偏移
122  * @return          : 读取的字节数，如果为负值，表示读取失败
123  */
124 static ssize_t led_read(struct file *filp, char __user *buf, 
125 size_t cnt, loff_t *offt)
126 {
127     return 0;
128 }
129
130 /*
131  * @description     : 向设备写数据 
132  * @param – filp  : 设备文件，表示打开的文件描述符
133  * @param - buf     : 要写给设备写入的数据
134  * @param - cnt     : 要写入的数据长度
135  * @param - offt    : 相对于文件首地址的偏移
136  * @return          : 写入的字节数，如果为负值，表示写入失败
137  */
138 static ssize_t led_write(struct file *filp, const char __user *buf, 
139 size_t cnt, loff_t *offt)
140 {
141     int retvalue;
142     unsigned char databuf[1];
143     unsigned char ledstat;
144
145     retvalue = copy_from_user(databuf, buf, cnt);
146     if(retvalue < 0) {
147         printk("kernel write failed!\r\n");
148         return -EFAULT;
149     }
150
151     ledstat = databuf[0];       /* 获取状态值 */
152
153     if(ledstat == LEDON) {  
154         led_switch(LEDON);      /* 打开LED灯 */
155     } else if(ledstat == LEDOFF) {
156         led_switch(LEDOFF);     /* 关闭LED灯 */
157     }
158     return 0;
159 }
160
161 /*
162  * @description   : 关闭/释放设备
163  * @param - filp    : 要关闭的设备文件(文件描述符)
164  * @return          : 0 成功;其他 失败
165  */
166 static int led_release(struct inode *inode, struct file *filp)
167 {
168     return 0;
169 }
170
171 /* 设备操作函数 */
172 static struct file_operations newchrled_fops = {
173     .owner = THIS_MODULE,
174     .open = led_open,
175     .read = led_read,
176     .write = led_write,
177     .release =  led_release,
178 };
179
180 /*
181  * @description     : 驱动出口函数
182  * @param           : 无
183  * @return          : 无
184  */
185 static int __init led_init(void)
186 {
187     u32 val = 0;
188     int ret;
189
190     /* 初始化LED */
191     /* 1、寄存器地址映射 */
192     led_remap();
193
194     /* 2、设置GPIO0_C0为GPIO功能。*/
195     val = readl(PMU_GRF_GPIO0C_IOMUX_L_PI);
196     val &= ~(0X7 << 0); /* bit2:0，清零 */
197     val |= ((0X7 << 16) | (0X0 << 0));  /* bit18:16 置1，允许写bit2:0，
198                                            bit2:0：0，用作GPIO0_C0  */
199     writel(val, PMU_GRF_GPIO0C_IOMUX_L_PI);
200
201     /* 3、设置GPIO0_C0驱动能力为level5 */
202     val = readl(PMU_GRF_GPIO0C_DS_0_PI);
203     val &= ~(0X3F << 0);    /* bit5:0清零*/
204     val |= ((0X3F << 16) | (0X3F << 0));    /* bit21:16 置1，允许写bit5:0，
205                                            bit5:0：0，用作GPIO0_C0  */
206     writel(val, PMU_GRF_GPIO0C_DS_0_PI);
207
208     /* 4、设置GPIO0_C0为输出 */
209     val = readl(GPIO0_SWPORT_DDR_H_PI);
210     val &= ~(0X1 << 0); /* bit0 清零*/
211     val |= ((0X1 << 16) | (0X1 << 0));  /* bit16 置1，允许写bit0，
212                                            bit0，高电平 */
213     writel(val, GPIO0_SWPORT_DDR_H_PI);
214
215     /* 5、设置GPIO0_C0为低电平，关闭LED灯。*/
216     val = readl(GPIO0_SWPORT_DR_H_PI);
217     val &= ~(0X1 << 0); /* bit0 清零*/
218     val |= ((0X1 << 16) | (0X0 << 0));  /* bit16 置1，允许写bit0，
219                                            bit0，低电平 */
220     writel(val, GPIO0_SWPORT_DR_H_PI);
221
222     /* 注册字符设备驱动 */
223     /* 1、创建设备号 */
224     if (newchrled.major) {      /*  定义了设备号 */
225         newchrled.devid = MKDEV(newchrled.major, 0);
226         ret = register_chrdev_region(newchrled.devid, NEWCHRLED_CNT, 
227 NEWCHRLED_NAME);
228          if(ret < 0) {
229              pr_err("cannot register %s char driver [ret=%d]\n",
230 NEWCHRLED_NAME, NEWCHRLED_CNT);
231              goto fail_map;
232          }
233      } else {                        /* 没有定义设备号 */
234          ret = alloc_chrdev_region(&newchrled.devid, 0, NEWCHRLED_CNT, 
235 NEWCHRLED_NAME);  /* 申请设备号 */
236          if(ret < 0) {
237              pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", 
238 NEWCHRLED_NAME, ret);
239              goto fail_map;
240          }
241          newchrled.major = MAJOR(newchrled.devid);/* 获取主设备号 */
242          newchrled.minor = MINOR(newchrled.devid);/* 获取次设备号 */
243      }
244      printk("newcheled major=%d,minor=%d\r\n",newchrled.major, 
245 newchrled.minor); 
246      
247      /* 2、初始化cdev */
248      newchrled.cdev.owner = THIS_MODULE;
249      cdev_init(&newchrled.cdev, &newchrled_fops);
250      
251      /* 3、添加一个cdev */
252      ret = cdev_add(&newchrled.cdev, newchrled.devid, NEWCHRLED_CNT);
253      if(ret < 0)
254          goto del_unregister;
255          
256      /* 4、创建类 */
257      newchrled.class = class_create(THIS_MODULE, NEWCHRLED_NAME);
258      if (IS_ERR(newchrled.class)) {
259          goto del_cdev;
260      }
261  
262      /* 5、创建设备 */
263      newchrled.device = device_create(newchrled.class, NULL, 
264 newchrled.devid, NULL, NEWCHRLED_NAME);
265      if (IS_ERR(newchrled.device)) {
266          goto destroy_class;
267      }
268      
269      return 0;
270  
271 destroy_class:
272     class_destroy(newchrled.class);
273 del_cdev:
274     cdev_del(&newchrled.cdev);
275 del_unregister:
276     unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT);
277 fail_map:
278     led_unmap();
279     return -EIO;
280 }
281
282 /*
283  * @description     : 驱动出口函数
284  * @param           : 无
285  * @return          : 无
286  */
287 static void __exit led_exit(void)
288 {
289     /* 取消映射 */
290     led_unmap();
291    
292     /* 注销字符设备驱动 */
293     cdev_del(&newchrled.cdev);/*  删除cdev */
294     unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT);
295
296     device_destroy(newchrled.class, newchrled.devid);
297     class_destroy(newchrled.class);
298 }
299
300 module_init(led_init);
301 module_exit(led_exit);
302 MODULE_LICENSE("GPL");
303 MODULE_AUTHOR("ALIENTEK");
304 MODULE_INFO(intree, "Y");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304

第24行，宏NEWCHRLED_CNT表示设备数量，在申请设备号或者向Linux内核添加字符设备的时候需要设置设备数量，一般我们一个驱动一个设备，所以这个宏为1。
第25行，宏NEWCHRLED_NAME表示设备名字，本实验的设备名为“newchrdev”，为了方便管理，所有使用到设备名字的地方统一使用此宏，当驱动加载成功以后就生成/dev/newchrled这个设备文件。
第44~51行，创建设备结构体newchrled_dev。
第53行，定义一个设备结构体变量newchrdev，此变量表示led设备。
第110~114行，在led_open函数中设置文件的私有数据private_data指向newchrdev。
第185~280行，根据前面讲解的方法在驱动入口函数led_init中申请设备号、添加字符设备、创建类和设备。本实验我们采用动态申请设备号的方法，第44行使用printk在终端上显示出申请到的主设备号和次设备号。
第288~298行，根据前面讲解的方法，在驱动出口函数led_exit中注销字符新设备、删除类和设备。
总体来说newchrled.c文件中的内容不复杂，LED灯驱动部分的程序和上一章一样。重点就是使用了新的字符设备驱动方法。
7.5.2 编写测试APP
本章直接使用上一章的测试APP，将上一章的ledApp.c文件复制到本章实验工程下即可。
7.6 运行测试
7.6.1 编译驱动程序和测试APP
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第五章实验基本一样，只是将obj-m变量的值改为newchrled.o，Makefile内容如下所示：
示例代码7.6.1.1 Makefile文件

1  KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
...... 
4  obj-m := newchrled.o
......
11 clean:
12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
1
2
3
4
5
6

第4行，设置obj-m变量的值为newchrled.o。
输入如下命令编译出驱动模块文件：
1
2

make ARCH=arm64 //ARCH=arm64必须指定，否则编译会失败
编译成功以后就会生成一个名为“newchrled.ko”的驱动模块文件。
2、编译测试APP
输入如下命令编译测试ledApp.c这个测试程序：
/opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc ledApp.c -o ledApp
编译成功以后就会生成ledApp这个应用程序。
7.6.2 运行测试
先在开发板中输入如下命令关闭LED0的心跳灯功能：
echo none > /sys/class/leds/work/trigger
在Ubuntu中将上一小节编译出来的newchrled.ko和ledApp这两个文件通过adb命令发送到开发板的/lib/modules/4.19.232目录下，命令如下：
adb push newchrled.ko ledApp /lib/modules/4.19.232
发送成功以后进入到开发板目录lib/modules/4.19.232中，输入如下命令加载newchrled.ko驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe newchrled //加载驱动
驱动加载成功以后会输出申请到的主设备号和次设备号，如图7.6.2.1所示：

图7.6.2.1 申请到的主设备号和次设备号
从图7.6.2.1可以看出，申请到的主设备号为241，次设备号为0。驱动加载成功以后会自动在/dev目录下创建设备节点文件/dev/newchrdev，输入如下命令查看/dev/newchrdev这个设备节点文件是否存在：
ls /dev/newchrled -l
结果如图7.6.2.2所示：

图7.6.2.2 /dev/newchrled设备节点文件
从图7.6.2.2中可以看出，/dev/newchrled这个设备文件存在，而且主设备号为241，次设备号为0，说明设备节点文件创建成功。
驱动节点创建成功以后就可以使用ledApp软件来测试驱动是否工作正常，输入如下命令打开LED灯：
./ledApp /dev/newchrled 1 //打开LED灯
输入上述命令以后观察ATK-DLRK3568开发板上的红色LED灯是否点亮，如果点亮的话说明驱动工作正常。在输入如下命令关闭LED灯：
./ledApp /dev/newchrled 0 //关闭LED灯
输入上述命令以后观察开发板上的红色LED灯是否熄灭。如果要卸载驱动的话输入如下命令即可：
rmmod newchrled