Linux设备驱动简介

Linux设备驱动简介

在单片机驱动编程中，这些硬件的设备驱动由我们自己编写，然后在代码中由我们自己调用，他们没有一个统一的规范，一百个人有一百种驱动的写法。而在linux系统下编写驱动，他有严格的规范，哪些该驱动做，哪些该应用程序做；驱动程序编写要先做什么，然后再做什么、然后再做什么都有严格的定义。正因为这样的规范，所以每个人只需要注重自己的角色，做自己该做的事，这也将嵌入式Linux开发的岗位分为两个，一个是底层驱动开发的BSP（Board Support Packet）开发，另外就是应用程序（Application）开发。

对于BSP开发岗位，相关的开发人员应该了解各种硬件知识，如电路基础、各种接口技术和硬件调试工具的使用（如万用表、示波器、甚至逻辑分析仪等），此外还需要计算机组成、操作系统原理等理论基础，同时还要了解各种体系架构的CPU、汇编语言等，当然最重要的是C语言编程能力和数据结构的知识以及对Linux内核源码大量阅读和分析。

对于嵌入式应用开发的岗位，我们不需要了解底层驱动的具体实现细节，而只需要知道怎么使用他们即可，因为Linux是一个模块化、严格分成的系统，所以应用程序人员只需要了解Linux的驱动调用的统一API（Application Program Interface，应用程序编程接口）即可，这些API就是Linux的系统调用（System call）,他们在《UNIX环境高级编程》这本书里较为详细的描述，对于嵌入式应用程序的开发，我们大部分使用C、C++或python（树莓派）和数据结构，根据应用程序的不同需求，我们需要补充额外的计算机网络数据库等知识。

Linux内核设计哲学是把所有的东西都抽象成文件进行访问，这样对设备的访问都是通过文件I/O来进行操作。Linux内核将设备按照访问特性分为三类：字符设备、块设备、网络设备；

字符设备驱动程序适合于大多数简单的硬件设备，而且比起块设备或网络驱动更加容易理解，因此我们从字符设备开始慢慢熟悉驱动的软件框架。

在详细的学习字符设备驱动框架之前我们先来简单的了解一下Linux下的应用程序是如何调用驱动程序的，Linux应用程序对驱动的调用如图如所示：

应用程序运行在用户空间，而Linux驱动属于内核一部分，因此驱动运行于内核空间，当用户想要实现对内核操作时，必须使用系统调用来实现从用户空间到内核空间的操作。

字符设备驱动

Linux主次设备号

字符设备通过文件系统中的设备名来存取，惯例上它们位于/dev目录。字符驱动的特殊文件由使用ls -l的输出的第一列的“c”标识。块设备也出现在/dev中，但是它们由“b”标识。如果输入ls -l命令，设备文件项中有两个数（由一个逗号分隔）在最后修改日期前面，这里通常是文件长度出现的地方。这些数字是给特殊设备的主次设备编号。其中逗号前面为主设备号，逗号后面为次设备号。

例如下列代码中，gpiochip0设备即为字符设备，ls -l的第一个字符’c’说明它是字符（character）设备，它的主设备号为254，次设备号为0。

文件类型	说明
b	块设备，是一些提供系统存取数据的接口设备，例如硬盘。
c	字符设备，是一些串行端口的接口设备，例如键盘、鼠标、打印机、tty终端。
d	目录，类似于Windows的文件夹。
l	链接文件，类似于Windows的快捷方式。
s	套接字文件（socket），用于进程之间的通信。
-	文件，分纯文本文件（ASCII）和二进制文件（binary）。

传统上，主编号标识设备相连的驱动。例如，/dev/gpiochip0由驱动254来管理，现代Linux内核允许多个驱动共享主编号，但是你看到的大部分设备任然按照一个主设备号一个驱动的原则来组织。

次设备号被内核来决定应用哪个设备。依据你的驱动是如何编写的，你可以从内核得到一个你的设备的直接指针，或者可以自己使用次编号作为本地设备数组的索引。不论哪个方法，内核几乎都不知道次编号的任何事情，除了他们指向你的驱动实现的设备。

在同一个系统中，一类设备的主设备号是唯一的。比如：磁盘这类，次设备号只是在驱动程序内部使用，系统内核直接把次设备号传递给应用程序，由驱动程序管理。为了保证驱动程序的通用性，避免驱动程序移植过程中出现主设备号冲突,系统为设备编了号，每个设备号又分为主设备号和次设备号。
主设备号用来区分不同种类的设备，而次设备号用来区分同一类型的多个设备。

在内核编程中，使用dev_t类型（在<linux/types.h>中定义）来定义设备编号，对于5.15.32内核，dev_t是32位的量，其中12位用作主编号，20位用作次编号。在编码时，我们不应该管哪些位是主设备号，哪些位是次设备号。而是应当利用在<linux/kdev_t.h>中的一套宏定义来获取一个dev_t的主、次编号：

#define MINORBITS 20
#define MINORMASK ((1U << MINORBITS) - 1) 
#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))

• 宏 MINORBITS 表示次设备号位数，一共是 20 位。
  宏 MINORMASK 表示次设备号掩码。
  宏 MAJOR 用于从 dev_t 中获取主设备号，将 dev_t 右移 20 位即可。
  宏 MINOR 用于从 dev_t 中获取次设备号，取 dev_t 的低 20 位的值即可。

相反，如果我们有主、次编号需要将其转换为一个dev_t，则使用MKDEV宏；

• 宏 MKDEV 用于将给定的主设备号和次设备号的值组合成 dev_t 类型的设备号。

dev_t 定义在文件 include/linux/types.h
typedef __u32 __kernel_dev_t;
......
typedef __kernel_dev_t dev_t;
可以看出 dev_t 是__u32 类型的，而__u32 定义在文件 include/uapi/asm-generic/int-ll64.h 里
面，定义如下：
typedef unsigned int __u32;
综上所述，dev_t 其实就是 unsigned int 类型，是一个 32 位的数据类型。

主设备号和次设备号两部分，其中高 12 位为主设备号，低 20 位为次设备号。因此 Linux系统中主设备号范围为 0~4095。

分配和释放设备编号

在建立一个字符驱动时你的驱动需要做的第一件事是获取一个或多个设备号来使用，在Linux内核里，一些主设备号是静态分配给最普通的设备的，这些设备列表在内核源码树的Documentation/devices.txt中列出。因此，作为一个驱动编写者，我们有两个选择：一是简单地捡一个看来没有用的主设备号，二是让内核以动态方式分配一个主设备号给你。只要你是你的驱动的唯一用户就可以捡一个编号用；一旦你的驱动更广泛的被使用了，一个随机捡来的主编号将导致冲突和麻烦。

因此，对于新驱动，我们强烈建议使用动态分配来获取你的主设备编号，而不是随机选取一个当前空闲的编号。

设备号分配

1. 静态分配设备号

静态设备指定主次设备号是指我们根据当前系统的主设备号分配情况，自己选择一个主设备号。当然我们自己随机选择的话，会跟Linux内核其他的驱动冲突，这时我们可以先查看当前系统已经使用了哪些主设备号，然后我们选择一个没有使用的作为我们新的驱动使用。Linux系统中正在使用的主设备号会保存在/proc/devices文件中：

上面列出的是当前运行的Linux内核里所有设备驱动使用的主设备号，此时我们在编写驱动时可以选定一个未用的主设备号，如111来使用

dev_t		devno;
int			result;
int			major = 251;

devno = MKDEV(major, 0);

result = register_chrdev_region(devno, 4, "chrdev");//静态的申请和注册设备号
if(result < 0)
{
    printk(KERN_ERR "chrdev can't use major %d\n", major);
    return -ENODEV;
}

这里register_chrdev_region()函数的原型为：

int register_chrdev_region(dev_t from, unsigned int count, char *name);

参数：

• from：注册的指定起始设备编号,比如:MKDEV(100,0),表示起始主设备号100,起始次设备号为0。
  count：需要连续注册的次设备编号个数，比如：起始次设备号为0,count=100,表示0~99的次设备号都要绑定在同一个file_operations操作方法结构体上。注意，如果count太大，你要求的范围可能溢出到下一次编号；但是只要你要求的编号范围可用，一切都任然会正确工作。
  name：设备名字；它会出现在/proc/devices和sysfs中。
  返回值：
• register_chrdev_region的返回值：是0。出错的情况下，返回一个负的错误码。

当驱动的主、次设备号申请成功后，/proc/devices里将会出现该设备，但是/dev路径下并不会创建该设备文件。

2. 主设备号动态分配
   静态分配设备号就是挑选一个没有使用的设备号很容易带来冲突问题。假设将来我们Linux内核系统升级需要使能其他的设备驱动，如果某个需要的驱动所用的主设备号刚好和我们的设备驱动冲突，那么我们驱动不得不对这个主设备号进行调整，而如果产品已经部署了，这种召回升级是非常致命的。所以我们在写驱动时，不应该静态指定一个设备号，而是由Linux内核根据当前主设备号使用情况动态分配一个未用的给我们的驱动使用，这样就永远不会冲突了。

设备号的申请函数如下：

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)

函数 alloc_chrdev_region用于申请设备号，此函数有 4 个参数：

• dev：存放起始设备编号的指针,当注册成功，*dev就会等于分配到的起始设备编号，可以通过MAJORO和MINNORO函数来提取主次设备号 。
• baseminor：次设备号基地址，也就是起始次设备号，它常常是0；
• count：要申请的设备号数量。起始次设备号(baseminor)为0,count=2,表示0~1的此设备号都要绑定在同一个file_operations操作方法结构体上
  name：设备名字。

动态分配的缺点是你无法提前创建设备节点，因为分配给你的主设备号会发生变化，对于驱动的正常使用这不是问题，但是一旦编号分配了，只能通过 查看 /proc/devices文件才能知道它的值，然后再创建设备节点。

释放主次设备号

注销字符设备之后要释放掉设备号，设备号释放函数如下：

void unregister_chrdev_region(dev_t from, unsigned count)

此函数有两个参数：

• from：要释放的设备号。 count：
  表示从 from 开始，要释放的设备号数量。

创建设备节点

1. 手动创建设备节点

如果我们需要创建该文件，则需要使用mknod命令创建。当然我们也可以在驱动里调用相应的函数，来通知应用程序空间自动创建该设备文件。

Usage: mknod [OPTION]... NAME TYPE [MAJOR MINOR]
Create the special file NAME of the given TYPE.

输入如下命令创建/dev/chrdevbase 这个设备节点文件： mknod /dev/chrdevbase c 251 0

“mknod”是创建节点命令，“/dev/chrdevbase”是要创建的节点文件，“c”表示这是个字符设备，“251”是设备的主设备号，“0”是设备的次设备号。

如果 chrdevbaseAPP 想要读写 chrdevbase 设备，直接对/dev/chrdevbase 进行读写操作即可。相当于/dev/chrdevbase 这个文件是 chrdevbase 设备在用户空间中的实现。

2. 自动创建设备节点
   在刚开始写Linux设备驱动程序的时候，很多时候都是利用mknod命令手动创建设备节点，实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点，当然前提条件是用户空间移植了udev。

内核中定义的struct class结构体，顾名思义，一个struct class结构体类型变量对应一个类，内核同时提供了class_create(…)函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用 device_create(…)函数来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应 device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。

class_create()和device_create()

先来了解一下跟设备文件创建相关的两个函数。

class_create()：在调用device_create()前要先用class_create()创建一个类。类这个概念在Linux中被抽象成一种设备的集合。类在/sys/class目录中。

Linux内核中有各种类，比如gpio、rtc、led等。

class_create()这个函数使用非常简单，在内核中是一个宏定义。

/include/linux/device.h中：

#define class_create(owner, name)		\
({						\
	static struct lock_class_key __key;	\
	__class_create(owner, name, &__key);	\
})

此函数有两个参数：

• owner:struct module结构体类型的指针，一般赋值为THIS_MODULE。
• name:char类型的指针，类名。

device_create()用于创建设备。

struct device *device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...)
{
	va_list vargs;
	struct device *dev;
    
	va_start(vargs, fmt);
	dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
	va_end(vargs);
return dev;
}

参数：

• class:该设备依附的类
• parent:父设备
• devt:设备号(此处的设备号为主次设备号)
• drvdata:私有数据
• fmt:设备名。

device_create能自动创建设备文件是依赖于udev这个应用程序。udev是一种工具，它能够根据系统中的硬件设备的状态动态更新设备文件，包括设备文件的创建，删除等。设备文件通常放在/dev目录下。使用udev后，在/dev目录下就只包含系统中真正存在的设备。

删除设备节点

函数class_destroy()用于从Linux内核系统中删除设备节点。此函数执行的效果是删除函数__class_create()或宏class_create()在/sys/class目录下创建的节点对应的文件夹。

/include/linux/device.h中：

void class_destroy(struct class *cls)
{
	if ((cls == NULL) || (IS_ERR(cls)))
	return;
 
	class_unregister(cls);
}

参数说明

• cls：struct class结构体类型的变量，代表通过class_create创建的设备的节点。

  函数device_destroy()用于从linux内核系统设备驱动程序模型中移除一个设备，并删除/sys/devices/virtual目录下对应的设备目录及/dev/目录下对应的设备文件。

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

参数说明

• cls：代表与待注销的逻辑设备相关的逻辑类，用于Linux内核系统逻辑设备的查找。
• devt：逻辑设备的设备号，与第一个参数共同确定一个逻辑设备。

字符设备重要数据结构

file_operations结构体

file_operations就是把系统调用和驱动函数关联起来的关键数据结构。这个结构的每一个成员都对应着一个系统调用，相应的系统调用将读取file_operations中相应的函数指针，接着把控制权转交给函数，从而完成了Linux设备驱动程序工作。在系统内部，I/O设备的存取操作通过特定的入口点来进行，而这组特定的入口点恰恰是由设备驱动提供的。通常这组设备驱动程序接口是由结构file_operations结构体向系统说明的，它定义在include/linux/fs.h中。传统上，一个file_operations结构或者其一个指针称为fops（或者它的一些变体），结构中的每个成员必须指向驱动中的函数，这些函数实现一个特别的操作，或者对于不支持的操作留置为NULL。当指定为NULL指针时内核的确切的行为是每个函数不同的。

struct file_operations {
	struct module *owner;  // 指向拥有此结构体的模块的指针

	// 读取操作函数指针
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

	// 写入操作函数指针
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

	// 使用迭代器进行读取操作的函数指针
	ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);

	// 使用迭代器进行写入操作的函数指针
	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);

	// 目录遍历的函数指针
	int (*iterate) (struct file *, struct dir_context *);

	// 获取文件状态的函数指针
	unsigned int (*poll) (struct file *, struct poll_table_struct *);

	// 未加锁的IO控制操作的函数指针
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);

	// 兼容的IO控制操作的函数指针
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);

	// 内存映射操作的函数指针
	int (*mmap) (struct file *, struct vm_area_struct *);

	// 内存重新映射操作的函数指针
	int (*mremap)(struct file *, struct vm_area_struct *);

	// 打开文件的函数指针
	int (*open) (struct inode *, struct file *);

	// 刷新操作的函数指针
	int (*flush) (struct file *, fl_owner_t id);

	// 关闭文件的函数指针
	int (*release) (struct inode *, struct file *);

	// 同步操作的函数指针
	int (*fsync) (struct file *, loff_t, loff_t, int datasync);

	// 异步IO同步操作的函数指针
	int (*aio_fsync) (struct kiocb *, int datasync);

	// 文件异步通知操作的函数指针
	int (*fasync) (int, struct file *, int);

	// 锁定文件的函数指针
	int (*lock) (struct file *, int, struct file_lock *);

	// 其他操作函数指针...
};

简单介绍一下 file_operation 结构体中比较重要的、常用的函数：

• owner 拥有该结构体的模块的指针，一般设置为 THIS_MODULE。
• read 函数用于读取设备文件。
• write 函数用于向设备文件写入(发送)数据。 第 1596 行，poll 是个轮询函数，用于查询设备是否可以进行非阻塞的读写。
• unlocked_ioctl 函数提供对于设备的控制功能，与应用程序中的 ioctl 函数对应。
• compat_ioctl 函数与 unlocked_ioctl 函数功能一样，区别在于在 64 位系统上，32位的应用程序调用将会使用此函数。在 32 位的系统上运行 32 位的应用程序调用的是unlocked_ioctl。
• mmap 函数用于将将设备的内存映射到进程空间中(也就是用户空间)，一般帧缓冲设备会使用此函数，比如 LCD 驱动的显存，将帧缓冲(LCD显存)映射到用户空间中以后应用程序就可以直接操作显存了，这样就不用在用户空间和内核空间之间来回复制。
• open 函数用于打开设备文件。
• release 函数用于释放(关闭)设备文件，与应用程序中的 close 函数对应
• fasync 函数用于刷新待处理的数据，用于将缓冲区中的数据刷新到磁盘中。
• aio_fsync 函数与 fasync 函数的功能类似，只是 aio_fsync 是异步刷新待处理的数据。

inode结构体

Linux中一切皆文件，当我们在Linux中创建一个文件时，就会在相应的文件系统中创建一个inode与之对应，文件实体和文件inode是一一对应的，创建好一个inode会存在存储器中。第一次open就会将inode在内存中有一个备份，同一个文件被多次打开并不会产生多个inode，当所有被打开的文件都被close之后，inode在内存中的实例才会被释放。既然如此，当我们使用mknod（或其他方法）创建一个设备文件时，也会在文件系统中创建一个inode，这个inode和其他的inode一样，用来存储关于这个文件的静态信息（不变的信息），包括这个设备文件对应的设备号，文件的路径以及对应的驱动对象等。

对于不同的文件类型，inode被填充的成员内容也会有所不同，以创建字符设备为例，我们知道，alloc_chrdev_region其实是把一个驱动对象和一个（一组）设备号联系到一起。而创建设备文件，其实就是把设备文件和设备号联系在一起。至此，这三者就被绑定在一起了。这样，内核就有能力创建一个struct inode实例了。

inode一样定义在inlude/linux/fs.h文件中：

struct inode {
	umode_t			i_mode;		// 文件的类型和访问权限
	unsigned short		i_opflags;	// 操作标志
	kuid_t			i_uid;		// 文件所有者的用户ID
	kgid_t			i_gid;		// 文件所有者的组ID
	unsigned int		i_flags;	// inode 的标志

#ifdef CONFIG_FS_POSIX_ACL
	struct posix_acl	*i_acl;		// POSIX ACL（访问控制列表）
	struct posix_acl	*i_default_acl;	// 默认的 POSIX ACL
#endif

	const struct inode_operations	*i_op;	// 指向 inode 操作函数的指针
	struct super_block	*i_sb;		// 指向超级块的指针
	struct address_space	*i_mapping;	// 指向地址空间对象的指针

	// 其他字段省略...

	const struct file_operations	*i_fop;	// 指向文件操作函数的指针，之前是 ->i_op->default_file_ops
	struct file_lock_context	*i_flctx;	// 文件锁的上下文
	struct address_space	i_data;		// 文件数据的地址空间对象
	struct list_head	i_devices;	// 用于设备的列表

	union {
		struct pipe_inode_info	*i_pipe;	// 管道 inode 信息
		struct block_device	*i_bdev;	// 块设备 inode 信息
		struct cdev		*i_cdev;	// 字符设备 inode 信息
	};
};

inod结构体包含大量关于文件的信息，作为一个通用规则，这个结构体只有两个成员对于编写驱动代码有用：

dev_t i_rdev； 代表设备文件的节点，这个成员包含实际的设备编号

struct cdev *i_cdev; 这个结构体代表字符设备，这个成员包含一个指针，指向这个结构体，当节点指的是一个字符设备文件时。

file结构体

file结构体代表一个打开的文件。它由内核在open时创建，并传递给在文件上操作的任何函数，直到最后的关闭。在文件的所有实例都关闭后，内核释放这个数据结构。

在内核源码中。struct file的指针常常称为file或者filp（file pointer)。 我们将一直成这个指针为filp以避免核结构自身混淆，因此，file指的是结构体，而filp指的是结构体指针。

下面是file的主要内容，它一样是定义在include/linux/fs.h文件中：

struct file {
	union {
		struct llist_node	fu_llist;    // 用于将文件链接到打开文件列表中的节点
		struct rcu_head 	fu_rcuhead;  // RCU 头，用于在释放文件时进行回收
	} f_u;
	struct path		f_path;             // 文件路径
	struct inode		*f_inode;	     // 指向文件对应的 inode 结构体的指针（缓存值）
	const struct file_operations	*f_op;  // 指向文件操作函数的指针

	// 其他字段省略...
};

字符设备注册

cdev结构体

内核在内部使用类型struct cdev的结构体来代表字符设备。在内核调用你的设备操作之前，你必须分配一个这样的结构体并注册给linux内核，在这个结构体里有对于这个设备进行操作的函数，具体定义在file_operation结构体中。该结构体定义在include/linux/cdev.h文件中：

struct cdev {
	struct kobject kobj;                    // 用于字符设备的内核对象
	struct module *owner;                   // 拥有此字符设备的模块指针
	const struct file_operations *ops;     // 指向字符设备的文件操作函数指针
	struct list_head list;                  // 用于将 cdev 结构体连接到内核中的其他 cdev 结构体的链表
	dev_t dev;                              // 字符设备的主设备号和次设备号
	unsigned int count;                     // 在一组相关的字符设备中，此字符设备的索引号
};

在内核编程中，我们可以使用两种方法获取结构体。

一是运行时想获取一个独立的cdev结构：

struct cdev *chrtest;
if(NULL　== chrtest = cdev_alloc())
{
	printk(KERN_ERR "S3C %s driver can't alloc for the cdev.\n", DEV_NAME);
	unregister_chrdev_region_region(devno, dev_vount);
	return -ENOMEM;
}
chrtest->ops = &my_fops;

但是，偶尔你会想将cdev结构体嵌入一个你自己的设备特定结构。这样的情况下你需要初始化已经分配的结构体。

cdev_init(struct cdev *dev, struct file_operations *fops);

struct cdev有一个拥有者成员，应当设置为THIS_MODULE，一旦cdev结构建立，最后的步骤就是告诉内核。

注册cdev到内核

在分配到cdev结构体后，接下来我们将它初始化，并将对该设备驱动所支持的系统调用函数存放在file_operations结构体添加进来，然后我们通过cdev_add函数将他们注册给Linux内核，这样完成整个Linux设备的注册过程。其中cdev_add的函数原型如下：

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

• dev是cdev结构
• num是这个设备相应的第一个设备号
• count是应当关联到设备的设备号的数目

下面是字符设备驱动cdev的分配和注册过程：

static struct file_operations chrtest_fods =
{
    .owner = THIS_MODULE,
    .open = chrtest_open,
    .release = chrtest_release,
    .unlocked_ioctl = chrtest_ioctl,
};

struct cdev *chrtest_cdev;
if(NULL == (chrtest_cdev = cdev_alloc))
{
    printk(KERN_ERR "S3C %s driver can't alloc for the cdev.\n", DEV_NAME);
    unregister_chdev_region(devno, dev_count);
    return -ENOMEM;   
}

chrtest_cdev->owner = THIS_MODULE;
cdev_init(led_cdev, &led_fops);

result = cdev_add(chrtest_cdev, devno, dev_count);

if(0 != result)
{
    printk(KERN_INFO "S3C %s drive can't register cdev:result = %d\n", DEV_NAME, result);
    goto ERROR;
}

Linux内核驱动和系统调用之间的联系

字符设备驱动开发步骤

①相应的设备硬件初始化
②分配主次设备号，这里即支持静态指定，也支持动态申请
③分配cdev结构体，我们这里使用动态申请的方式
④绑定主次设备号、fops到cdev结构体中，并注册给Linux内核

字符设备驱动源码

/*********************************************************************************
 *      Copyright:  (C) 2024 Chenyujiang<2631336290@qq.com>
 *                  All rights reserved.
 *
 *       Filename:  chrdevbase.c
 *    Description:  This file 
 *                 
 *        Version:  1.0.0(2024年03月18日)
 *         Author:  Chenyujiang <2631336290@qq.com>
 *      ChangeLog:  1, Release initial version on "2024年03月18日 18时15分55秒"
 *                 
 ********************************************************************************/



#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>


//#define 	DEV_MAJOR	79
#ifndef	 	DEV_MAJOR		
#define		DEV_MAJOR		0
#endif

int	dev_major = DEV_MAJOR;

#define DEV_NAME	"chrdev"

static struct cdev	*chrtest_cdev;

static struct class *chrdev_class;



static char kernel_buf[1024];

#define		MIN(a,b)	(a < b ? a:b)

static ssize_t chrtest_drv_read(struct file *file, char __user *buf,size_t size, loff_t *offset)
{
	int err;
	printk("%s %s line %d\n",__FILE__,__FUNCTION__,__LINE__);
	err = copy_to_user(buf,kernel_buf,MIN(1024,size));
	return MIN(1024,size);
}

static ssize_t chrtest_drv_write(struct file *file, const char __user *buf,size_t size, loff_t *offset)
{
	int err;
	printk("%s %s line %d\n",__FILE__,__FUNCTION__,__LINE__);
	err = copy_from_user(kernel_buf,buf,MIN(1024,size));
	return MIN(1024,size);
}


static int chrtest_drv_open(struct inode *node, struct file *file)
{
	printk("%s %s line %d\n",__FILE__,__FUNCTION__,__LINE__);
	return 0;
}

static int chrtest_drv_close(struct inode *inode, struct file *file)
{
	printk("%s %s line %d\n",__FILE__,__FUNCTION__,__LINE__);
	return 0;
}

static struct file_operations chrtest_fops = 
{
	.owner 		= THIS_MODULE,
	.open		= chrtest_drv_open,
	.read		= chrtest_drv_read,
	.write		= chrtest_drv_write,
	.release 	= chrtest_drv_close,
};


static int __init chrdev_init(void)
{
	int 	result;
	dev_t	devno;

	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

	if(0 != dev_major)
	{
		devno = MKDEV(dev_major, 0);
		result = register_chrdev_region(devno, 1, DEV_NAME);
	}
	else
	{
		result = alloc_chrdev_region(&devno, 0, 1, DEV_NAME);
		dev_major = MAJOR(devno);
	}

	if(result < 0)
	{
		printk(KERN_ERR " %s driver can't use major %d\n", DEV_NAME, dev_major);
		return -ENODEV;
	}
	printk(KERN_DEBUG "%s driver use major %d\n", DEV_NAME, dev_major);

	if(NULL == (chrtest_cdev = cdev_alloc()))
	{
		printk(KERN_ERR "%s driver can't alloc for the cdev", DEV_NAME);
		unregister_chrdev_region(devno, 1);
		return -ENOMEM;
	}


	chrtest_cdev->owner = THIS_MODULE;

	cdev_init(chrtest_cdev,&chrtest_fops);


	result = cdev_add(chrtest_cdev,devno,1);


	if(0 != result)

	{
	
		printk(KERN_INFO "%s driver can't register cdev:result=%d\n",DEV_NAME,result);
	
		goto ERROR;

	}


	printk(KERN_INFO "%s driver can register cdev:result=%d\n",DEV_NAME,result);



#if 1


	chrdev_class = class_create(THIS_MODULE,DEV_NAME);


	if(IS_ERR(chrdev_class))

	{
	
		result = PTR_ERR(chrdev_class);
	
		goto ERROR;

	}


	device_create(chrdev_class,NULL,MKDEV(dev_major,0),NULL,DEV_NAME);

#endif


	return 0;

ERROR:
	printk(KERN_ERR" %s driver installed failure.\n", DEV_NAME);
    cdev_del(chrtest_cdev);
    unregister_chrdev_region(devno, 1); 
    return result;

}


static void __exit chrdev_exit(void)
{
	printk("%s %s line %d\n",__FILE__,__FUNCTION__,__LINE__);

#if 1
	device_destroy(chrdev_class,MKDEV(dev_major,0));
	class_destroy(chrdev_class);
#endif

	cdev_del(chrtest_cdev);
	unregister_chrdev_region(MKDEV(dev_major,0),1);

	printk(KERN_ERR" %s driver version 1.0.0 removed!\n",DEV_NAME);
	return;
}


module_init(chrdev_init);
module_exit(chrdev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ChenYujiang <yjchen81@foxmail.com>");

copy_to_user和copy_from_user是在进行驱动相关程序设计的时候，要经常遇到的函数。由于内核空间与用户空间的内存不能直接互访，因此借助函数copy_to_user()完成内核空间到用户空间的复制，函数copy_from_user()完成用户空间到内核空间的复制。

①copy_to_user 函数来完成内核空间的数据到用户空间的复制。

static inline long copy_to_user(void __user *to, const void *from, unsigned long n)

• to 目标地址，这个地址是用户空间的地址；
• from 源地址，这个地址是内核空间的地址；
• n 将要拷贝的数据的字节数。

② copy_from_user 函数完成用户空间到内核空间的复制。

unsigned long copy_from_user (void * to, const void __user * from, unsigned long n);

• to 目标地址，这个地址是内核空间的地址；
• from 源地址，这个地址是用户空间的地址；
• n 将要拷贝的数据的字节数。

编写字符测试 APP

/*********************************************************************************
 *      Copyright:  (C) 2024 Chenyujiang<2631336290@qq.com>
 *                  All rights reserved.
 *
 *       Filename:  chrdevbaseApp.c
 *    Description:  This file 
 *                 
 *        Version:  1.0.0(2024年03月21日)
 *         Author:  Chenyujiang <2631336290@qq.com>
 *      ChangeLog:  1, Release initial version on "2024年03月21日 12时16分13秒"
 *                 
 ********************************************************************************/

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>


int main(int argc, char **argv)
{
	int		fd;
	char	buf[1024];
	int		len;


	if(argc < 2)
	{
		printf("Usage: %s -w <string>\n",argv[0]);
		printf("	   %S -r\n",argv[0]);
		return -1;
	}

	fd = open("/dev/chrdev",O_RDWR);

	if(fd == -1)
	{
		printf("can't open file.\n");
		return -2;
	}

	if((0 == strcmp(argv[1],"-w")) && (argc == 3))
	{
		len = strlen(argv[2])+1;
		len = len < 1024 ? len : 1024;
		write(fd,argv[1],len);
	}
	else if((0 == strcmp(argv[1], "-r")) && (argc==2))
	{
		len = read(fd,buf,1024);
		buf[1023]='\0';
		printf("APP read: %s\n",buf);
	}
	else
	{
		printf("Usage: %s -w <string>\n",argv[0]);
		printf("	   %S -r\n",argv[0]);
		return -1;
	}

	close(fd);

	return 0;

}

Makefile

ARCH := arm
CROSS_COMPILE := /opt/gcc-aarch32-10.3-2021.07/bin/arm-none-linux-gnueabihf-


TFTP_DIR := /tftp/chenyujiang/
KERNEL_DIR := /home/lingyun/build-imxboard/igkboard-imx6ull/kernel/linux-imx
#KERNEL_DIR := /home/chenyujiang/imx6ull/bsp/kernel/linux-imx/
PWD :=$(shell pwd)
obj-m := chrdevbase.o
NAME := chrdevbaseApp

modules:
	$(MAKE) -C $(KERNEL_DIR) M=$(PWD) ARCH=$(ARCH)  CROSS_COMPILE=$(CROSS_COMPILE) modules
	$(CROSS_COMPILE)gcc $(NAME).c -o $(NAME)	
	@make clear
	cp $(NAME) chrdevbase.ko $(TFTP_DIR) -f
clear:
	@rm -f *.o *.cmd *.mod *.mod.c
	@rm -rf *~ core .depend .tmp_versions Module.symvers modules.order -f
	@rm -f .*ko.cmd .*.o.cmd .*.o.d
	@rm -f *.unsigned

clean:
	@rm -f *.ko

结果测试

将make之后的文件下载到开发板上如图所示