RK3568 Linux驱动学习——新字符设备驱动

前言

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

本节学习一下如何编写新字符设备驱动，并且在驱动模块加载的时候自动创建设备节点文件。

新字符设备驱动原理

分配和释放设备号

使用 register_chrdev 函数注册字符设备的时候只需要给定一个主设备号即可，但是这样会带来两个问题：

• 需要事先确定好哪些主设备号没有使用。
• 会将一个主设备号下的所有次设备号都使用掉，比如现在设置 LED 这个主设备号为 200，那么 0~1048575(2^20-1)这个区间的次设备号就全部都被 LED 一个设备分走了。

解决这两个问题最好的方法就是在使用设备号的时候向 Linux 内核申请，需要几个就申请几个，由 Linux 内核分配设备可以使用的设备号。这个就是之前讲解的设备号的分配，如果没有指定设备号的话就使用如下函数来申请设备号：

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);

新字符设备驱动下，设备号分配示例代码如下：

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

如果要注销设备号的话，使用如下代码即可：

unregister_chrdev_region(devid, 1); /* 注销设备号 */

新的字符设备注册方法

• 字符设备结构

在 Linux 中使用 cdev 结构体表示一个字符设备，cdev 结构体在 include/linux/cdev.h 文件中的定义如下：

struct cdev {struct kobject kobj;struct module *owner;const struct file_operations *ops;struct list_head list;dev_t dev;unsigned int count;
} __randomize_layout;

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

struct cdev test_cdev;

• cdev_init 函数

定义好 cdev 变量以后就要使用 cdev_init 函数对其进行初始化，cdev_init 函数原型如下：

void cdev_init(struct cdev *cdev, const struct file_operations *fops);

参数 cdev 就是要初始化的 cdev 结构体变量，参数 fops 就是字符设备文件操作函数集合。使用 cdev_init 函数初始化 cdev 变量的示例代码如下：

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 结构体变量 */

• cdev_add 函数

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

cdev_add 函数原型如下：

int cdev_add(struct cdev *p, dev_t dev, unsigned count);

参数 p 指向要添加的字符设备(cdev 结构体变量)，参数 dev 就是设备所使用的设备号，参数 count 是要添加的设备数量。加入 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); /* 添加字符设备 */

以上就是新的注册字符设备代码段，Linux 内核中大量的字符设备驱动都是采用这种方法向 Linux 内核添加字符设备。

• cdev_del 函数

卸载驱动的时候一定要使用 cdev_del 函数从 Linux 内核中删除相应的字符设备，cdev_del 函数原型如下：

void cdev_del(struct cdev *p);

参数 p 就是要删除的字符设备。如果要删除字符设备，参考如下代码：

cdev_del(&testcdev); /* 删除 cdev */

cdev_del 和 unregister_chrdev_region 这两个函数合起来的功能相当于 unregister_chrdev 函数。

自动创建设备节点

在前面的 Linux 驱动实验中，当使用 modprobe 加载驱动程序以后还需要使用命令 “mknod” 手动创建设备节点。本节就来讲解一下如何实现自动创建设备节点，在驱动中实现自动创建设备节点的功能以后，使用 modprobe 加载驱动模块成功的话就会自动在 /dev 目录下创建对应的设备文件。

mdev 机制

udev 是一个用户程序，在 Linux 下通过 udev 来实现设备文件的创建与删除，udev 可以检测系统中硬件设备状态，可以根据系统中硬件设备状态来创建或者删除设备文件。比如使用 modprobe 命令成功加载驱动模块以后就自动在 /dev 目录下创建对应的设备节点文件,使用 rmmod 命令卸载驱动模块以后就删除掉/dev 目录下的设备节点文件。开发板启动的时候会启动 udev，如下图所示：

创建和删除类

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

extern struct class * __must_check __class_create(struct module *owner,const char *name,struct lock_class_key *key);
extern void class_destroy(struct class *cls);/* This is a #define to keep the compiler from merging different* instances of the __key variable */
#define class_create(owner, name)		\
({						\static struct lock_class_key __key;	\__class_create(owner, name, &__key);	\
})

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

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 就是要删除的类。

创建设备

上一小节创建好类以后还不能实现自动创建设备节点，还需要在这个类下创建一个设备。使用 device_create 函数在类下面创建设备，device_create 函数原型如下：

struct device *device_create(struct class *cls, struct device *parent,dev_t devt, void *drvdata,const char *fmt, ...);

device_create 是个可变参数函数，参数 class 就是设备要到创建哪个类下面；参数 parent 是父设备，一般为 NULL，也就是没有父设备；参数 devt 是设备号；参数 drvdata 是设备可能会使用的一些数据，一般为 NULL；参数 fmt 是设备名字，如果设置 fmt=xxx 的话，就会生成 /dev/xxx 这个设备文件。返回值就是创建好的设备。

同样的，卸载驱动的时候需要删除掉创建的设备，设备删除函数为 device_destroy，函数原型如下：

void device_destroy(struct class *cls, dev_t devt);

参数 classs 是要删除的设备所处的类，参数 devt 是要删除的设备号。

设置文件私有数据

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

dev_t devid; /* 设备号 */
struct cdev cdev; /* cdev */
struct class *class; /* 类 */
struct device *device; /* 设备 */
int major; /* 主设备号 */
int minor; /* 次设备号 */

对于一个设备的所有属性信息最好将其做成一个结构体。编写驱动 open 函数的时候将设备结构体作为私有数据添加到设备文件中，如下所示：

/* 设备结构体 */
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 }

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

硬件原理图分析

跟之前是一样的。

实验程序编写

本章实验在上一章实验的基础上完成，重点是使用了新的字符设备驱动、设置了文件私有数据、添加了自动创建设备节点相关内容。

LED 灯驱动程序编写

#define NEWCHRLED_CNT       	1           		/* 设备号个数 	*/
#define NEWCHRLED_NAME      	"newchrled" 		/* 名字 		*/

宏 NEWCHRLED_CNT 表示设备数量，在申请设备号或者向 Linux 内核添加字符设备的时候需要设置设备数量，一般一个驱动一个设备，所以这个宏为 1。

宏 NEWCHRLED_NAME 表示设备名字，本实验的设备名为 “newchrdev”，为了方便管理，所有使用到设备名字的地方统一使用此宏，当驱动加载成功以后就生成 /dev/newchrled 这个设备文件。

/* newchrled设备结构体 */
struct newchrled_dev{dev_t devid;            	/* 设备号     	*/struct cdev cdev;       	/* cdev     	*/struct class *class;    	/* 类      		*/struct device *device;  	/* 设备    		*/int major;              	/* 主设备号   	*/int minor;              	/* 次设备号   	*/
};

以上创建设备结构体 newchrled_dev。

struct newchrled_dev newchrled; /* led设备 */

定义一个设备结构体变量 newchrdev，此变量表示 led 设备。

/** @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 = &newchrled; /* 设置私有数据 */return 0;
}

在 led_open 函数中设置文件的私有数据 private_data 指向 newchrdev。

/** @description 	: 驱动出口函数* @param       	: 无* @return      	: 无*/
static int __init led_init(void)
{u32 val = 0;int ret;/* 初始化LED *//* 1、寄存器地址映射 */led_remap();/* 2、设置GPIO0_C0为GPIO功能。*/val = readl(PMU_GRF_GPIO0C_IOMUX_L_PI);val &= ~(0X7 << 0);	/* bit2:0，清零 */val |= ((0X7 << 16) | (0X0 << 0));	/* bit18:16 置1，允许写bit2:0，bit2:0：0，用作GPIO0_C0	*/writel(val, PMU_GRF_GPIO0C_IOMUX_L_PI);/* 3、设置GPIO0_C0驱动能力为level5 */val = readl(PMU_GRF_GPIO0C_DS_0_PI);val &= ~(0X3F << 0);	/* bit5:0清零*/val |= ((0X3F << 16) | (0X3F << 0));	/* bit21:16 置1，允许写bit5:0，bit5:0：0，用作GPIO0_C0	*/writel(val, PMU_GRF_GPIO0C_DS_0_PI);/* 4、设置GPIO0_C0为输出 */val = readl(GPIO0_SWPORT_DDR_H_PI);val &= ~(0X1 << 0); /* bit0 清零*/val |= ((0X1 << 16) | (0X1 << 0));	/* bit16 置1，允许写bit0，bit0，高电平	*/writel(val, GPIO0_SWPORT_DDR_H_PI);/* 5、设置GPIO0_C0为低电平，关闭LED灯。*/val = readl(GPIO0_SWPORT_DR_H_PI);val &= ~(0X1 << 0); /* bit0 清零*/val |= ((0X1 << 16) | (0X0 << 0));	/* bit16 置1，允许写bit0，bit0，低电平	*/writel(val, GPIO0_SWPORT_DR_H_PI);/* 注册字符设备驱动 *//* 1、创建设备号 */if (newchrled.major) {      /*  定义了设备号 */newchrled.devid = MKDEV(newchrled.major, 0);ret = register_chrdev_region(newchrled.devid, NEWCHRLED_CNT, 
NEWCHRLED_NAME);if(ret < 0) {pr_err("cannot register %s char driver [ret=%d]\n",NEWCHRLED_NAME, NEWCHRLED_CNT);goto fail_map;}} else {                        /* 没有定义设备号 */ret = alloc_chrdev_region(&newchrled.devid, 0, NEWCHRLED_CNT, 
NEWCHRLED_NAME);  /* 申请设备号 */if(ret < 0) {pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", 
NEWCHRLED_NAME, ret);goto fail_map;}newchrled.major = MAJOR(newchrled.devid);/* 获取主设备号 */newchrled.minor = MINOR(newchrled.devid);/* 获取次设备号 */}printk("newcheled major=%d,minor=%d\r\n",newchrled.major, 
newchrled.minor); /* 2、初始化cdev */newchrled.cdev.owner = THIS_MODULE;cdev_init(&newchrled.cdev, &newchrled_fops);/* 3、添加一个cdev */ret = cdev_add(&newchrled.cdev, newchrled.devid, NEWCHRLED_CNT);if(ret < 0)goto del_unregister;/* 4、创建类 */newchrled.class = class_create(THIS_MODULE, NEWCHRLED_NAME);if (IS_ERR(newchrled.class)) {goto del_cdev;}/* 5、创建设备 */newchrled.device = device_create(newchrled.class, NULL, 
newchrled.devid, NULL, NEWCHRLED_NAME);if (IS_ERR(newchrled.device)) {goto destroy_class;}return 0;destroy_class:class_destroy(newchrled.class);
del_cdev:cdev_del(&newchrled.cdev);
del_unregister:unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT);
fail_map:led_unmap();return -EIO;
}

根据前面讲解的方法在驱动入口函数 led_init 中申请设备号、添加字符设备、创建类和设备。本实验采用动态申请设备号的方法。

/** @description 	: 驱动出口函数* @param       	: 无* @return      	: 无*/
static void __exit led_exit(void)
{/* 取消映射 */led_unmap();/* 注销字符设备驱动 */cdev_del(&newchrled.cdev);/*  删除cdev */unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT);device_destroy(newchrled.class, newchrled.devid);class_destroy(newchrled.class);
}

根据前面讲解的方法，在驱动出口函数 led_exit 中注销字符新设备、删除
类和设备。

总体来说 newchrled.c 文件中的内容不复杂，LED 灯驱动部分的程序和上一章一样。重点就是使用了新的字符设备驱动方法。

运行测试

编译驱动程序和测试 APP

• 编译驱动程序

编写 Makefile 文件，本章实验的 Makefile 文件和之前实验基本一样，只是将 obj-m 变量的值改为 newchrled.o，Makefile 内容如下所示：

KERNELDIR := /home/xhj/rk3568_linux_sdk/kernel
CURRENT_PATH := $(shell pwd)
obj-m := newchrled.obuild: kernel_moduleskernel_modules:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

输入如下命令编译出驱动模块文件：

make ARCH=arm64 //ARCH=arm64 必须指定，否则编译会失败

编译成功以后就会生成一个名为“newchrled.ko”的驱动模块文件。

• 编译测试 APP

输入如下命令编译测试 ledApp.c 这个测试程序：

/opt/atk-dlrk356x-toolchain/bin/aarch64-buildroot-linux-gnu-gcc ledApp.c -o ledApp

编译成功以后就会生成 ledApp 这个应用程序。

运行测试

先在开发板中输入如下命令关闭 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 //加载驱动

驱动加载成功以后会输出申请到的主设备号和次设备号，如下图所示：

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

ls /dev/newchrled -l

结果如下图所示：

从上图中可以看出，/dev/newchrled 这个设备文件存在，而且主设备号为 241，次设备号为 0，说明设备节点文件创建成功。

驱动节点创建成功以后就可以使用 ledApp 软件来测试驱动是否工作正常，输入如下命令打开 LED 灯：

./ledApp /dev/newchrled 1 //打开 LED 灯

输入上述命令以后观察 ATK-DLRK3568 开发板上的红色 LED 灯是否点亮，如果点亮的话说明驱动工作正常。在输入如下命令关闭 LED 灯：

./ledApp /dev/newchrled 0 //关闭 LED 灯

输入上述命令以后观察开发板上的红色 LED 灯是否熄灭。如果要卸载驱动的话输入如下命令即可：

rmmod newchrled