我们知道他们在说谎,他们也知道他们在说谎,他们知道我们知道他们在说谎,我们也知道他们知道我们知道他们在说谎,但是他们依然在说谎。
一、Linux驱动分类
Linux 中的三大类驱动:字符设备驱动、块设备驱动和网络设备驱动。其中字符设备驱动是占用篇幅最大的一类驱动,因为字符设备最多,从最简单的点灯到 I2C、 SPI、音频等都属于字符设备驱动的类型。
块设备和网络设备驱动要比字符设备驱动复杂,就是因为其复杂所以半导体厂商一般都给我们编写好了,大多数情况下都是直接可以使用的。所谓的块设备驱动就是存储器设备的驱动,比如 EMMC、 NAND、 SD 卡和 U 盘等存储设备,因为这些存储设备的特点是以存储块为基础,因此叫做块设备。网络设备驱动就更好理解了,就是网络驱动,不管是有线的还是无线的,都属于网络设备驱动的范畴。
需要一提的是,一个设备可以属于多种设备驱动类型。比如 USB WIFI,其使用 USB 接口,所以属于字符设备,但是其又能上网,所以也属于网络设备驱动。
二、Linux驱动初探
什么是Linux驱动开发?
- ① 驱动在Linux开发中承上启下,上承Linux应用开发,下启具体的硬件。
- ② Linux应用程序 -> Linux驱动程序 -> 操作具体硬件
- ③ 这样便实现了开发中的分层(当然也派生出了不同的岗位),各司其职,提高工作效率。
Linux 驱动运行方式
- ① 将驱动编译进 Linux 内核中,这样当 Linux 内核启动的时候就会自动运行驱动程序
- ② 将驱动编译成模块(Linux 下模块扩展名为.ko),在Linux 内核启动以后使用“insmod”命令加载驱动模块,在开发中我们常用这种方式。
需要一提的是,Linux应用程序运行在用户空间,而Linux驱动程序运行在内核的空间,换句话说Linux驱动程序依赖于 Linux 内核。为开发板 A 开发驱动,那就需要先在 Linux中下载、 配置、编译开发板 A 所使用的 Linux 内核。(上一节qemu模拟的imx6ull单板使用的4.9.88
Linux内核)
驱动程序与应用程序的命名(并无固定的格式)
- 驱动程序:
xxx.c
- 应用程序:
xxxAPP.c
三、Hello驱动程序编写
毫无疑问,本节要实现的Hello驱动程序属于字符设备的一种!
实现功能:
- A. 加载驱动时,打印内核信息
hello init
- B. 卸载驱动时,打印内核信息
hello exit
- B. APP 调用 write 函数时,将APP中保存的数据
This is app data!
保存在驱动中,同时在驱动中打印出来! - C. APP 调用 read 函数时,将驱动中保存的数据
This is kernel data!
保存在APP中,同时在APP中打印出来!
编写驱动程序步骤
- ① 确定主设备号,也可以让内核分配
- ② 定义自己的 file_operations 结构体
- ③ 实现对应的 drv_open/drv_read/drv_write 等函数,填入 file_operations 结构体
- ④ 把 file_operations 结构体告诉内核: register_chrdev
- ⑤ 谁来注册驱动程序啊?得有一个入口函数:安装驱动程序时,就会去调用这个入口函数
- ⑥ 有入口函数就应该有出口函数:卸载驱动程序时,出口函数调用 unregister_chrdev
- ⑦ 其他完善:提供设备信息,自动创建设备节点: class_create, device_create
hello.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>
#define MIN(a, b) (a < b ? a : b)
/* 1. 确定主设备号 */
static int major = 0;
static struct class *hello_class;
static char write_buf[100];
static char read_buf[100];
static char kernel_data[] = "This is kernel data!";
/* 3. 实现对应的open/read/write等函数,填入file_operations结构体 */
/*
* @description : 打开设备
* @param - inode : 传递给驱动的inode
* @param - filp : 设备文件,file结构体有个叫做private_data的成员变量
* 一般在open的时候将private_data指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int hello_open (struct inode *inode, struct file *filp)
{
return 0;
}
/*
* @description : 关闭/释放设备
* @param - filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int hello_close (struct inode *inode, struct file *filp)
{
return 0;
}
/*
* @description : 从设备读取数据
* @param - filp : 要打开的设备文件(文件描述符)
* @param - buf : 返回给用户空间的数据缓冲区
* @param - cnt : 要读取的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 读取的字节数,如果为负值,表示读取失败
*/
static ssize_t hello_read (struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
int ret;
memcpy(read_buf, kernel_data, sizeof(kernel_data));//(目的地址,源地址,长度)
ret = copy_to_user(buf, read_buf, MIN(100, cnt)); //static inline long copy_to_user(void __user *to, const void *from, unsigned long n)
if(ret < 0){
printk("kernel send data failed!\r\n");
return -1;
}else{
printk("kernel send data ok!\r\n");
return MIN(100, cnt);
}
return 0;
}
/*
* @description : 向设备写数据
* @param - filp : 设备文件,表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 写入的字节数,如果为负值,表示写入失败
*/
static ssize_t hello_write (struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
int ret;
ret = copy_from_user(write_buf, buf, MIN(100, cnt));
if(ret < 0){
printk("kernel receive data failed!\r\n");
return -1;
}else{
printk("kernel receive data: %s \r\n", write_buf);
return MIN(100, cnt);
}
return 0;
}
/* 2. 定义自己的file_operations结构体 */
/*
* 设备操作函数结构体 注意成员之间是逗号隔开的,结构最后还有个分号
*/
static struct file_operations hello = {
.owner = THIS_MODULE,
.open = hello_open,
.read = hello_read,
.write = hello_write,
.release = hello_close,
};
/* 5. 谁来注册驱动程序啊?得有一个入口函数:安装驱动程序时,就会去调用这个入口函数 */
/*
* @description : 驱动入口函数
* @param : 无
* @return : 0 成功;其他 失败
*/
static int __init hello_init(void)
{
int err;
printk("hello init\r\n");
/* 4. 把file_operations结构体告诉内核:注册驱动程序 */
major = register_chrdev(0, "hello", &hello); /* /dev/hello */
/* 7. 其他完善:提供设备信息,自动创建设备节点 */
hello_class = class_create(THIS_MODULE, "hello_class");
err = PTR_ERR(hello_class);
if (IS_ERR(hello_class)) {
unregister_chrdev(major, "hello");
return -1;
}
device_create(hello_class, NULL, MKDEV(major, 0), NULL, "hello"); /* /dev/hello */
return 0;
}
/* 6. 有入口函数就应该有出口函数:卸载驱动程序时,就会去调用这个出口函数 */
/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit hello_exit(void)
{
printk("hello exit\r\n");
device_destroy(hello_class, MKDEV(major, 0));
class_destroy(hello_class);
unregister_chrdev(major, "hello");
}
/*
* 指定为驱动入口和出口函数,以及LICENSE信息
*/
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");
驱动编写说明:
- 关于file的初始化直接是.xxx = xxx,这种结构体初始化方式是在C99及C11标准提出的指定初始化器,具体可参考这里。
- Linux驱动源文件需要使用 printk 来打印输出信息,Linux应用源文件使用 printf来打印输出信息!
- 内核空间不能直接操作用户空间的内存,因此需要借助
copy_to_user
函数来完成内核空间的数据到用户空间的复制。同理用户数据拷贝到内核用copy_from_user
函数。 register_chrdev
三个参数:主设备号、设备名字、 file_operations 类型指针- 写一点编译一下,有错误及时更正!
- 函数使用参考内核中已有的驱动文件!
helloApp.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
static char write_buf[100];
static char read_buf[100];
static char app_data[] = "This is app data!";
/*
* @description : main主程序
* @param - argc : argv数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd, ret;
char *filename;
if(argc != 3){
printf("Input Error!\r\n");
}
/* 打开设备文件,若失败直接退出并返回-1 */
filename = argv[1];
fd = open(filename, O_RDWR);
if(fd < 0){
printf("Can't open file %s !\r\n", filename);
return -1;
}
/* 判断argv参数是否等于1,然后向设备发送数据 */
if(atoi(argv[2]) == 1)
{
memcpy(write_buf, app_data, sizeof(app_data));
ret = write(fd, write_buf, 50);
if(ret < 0){
printf("APP send data failed!\r\n");
}else{
printf("App send data ok!\r\n");
}
}
/* 判断argv参数是否等于2,然后读取设备数据 */
if(atoi(argv[2]) == 2)
{
ret = read(fd, read_buf, 50);
if(ret < 0){
printf("App receive data failed!\r\n");
}else{
printf("App receive data: %s\r\n", read_buf);
}
}
/* 关闭设备文件 */
ret = close(fd);
if(ret < 0){
printf("Can't Close file %s!\r\n", filename);
return -1;
}
return 0;
}
应用程序编写说明:
- 驱动开发中的main函数是带参数的,详细可参考这里
- 向驱动写数据:
./hello /dev/hello 1
、读取驱动数据:./hello /dev/hello 2
- argc表示参数个数,argv是参数内容存放的地方
- argv[0] - ./hello
- argv[1] - /dev/hello
- argv[2] - 1或0
- atoi函数可以把字符串转换成数字!
- 应用程序函数的具体用法以及头文件参考man手册
Makefile
KERNELDIR := /home/clay/linux/IMX6ULL/Linux_Drivers/linux-4.9.88
CURRENT_PATH := $(shell pwd)
obj-m := hello.o
build: kernel_modules
kernel_modules:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
Makefile程序编写说明:
- 驱动程序名字更改:
obj-m :=
后面的内容 - Makefile只能编译驱动程序,应用程序需要单独编译
- 应用程序编译需要在命令行输入:
arm-linux-gnueabihf-gcc helloApp.c -o hello
- Linux内核路径根据实际情况更改。
四、运行
4.1、qemu开发板
启动qemu,并且正确挂载NFS。
- 在ubuntu终端,拷贝编译后的驱动程序及应用程序到NFS文件夹下
cp *.ko hello ~/linux/qemu/NFS/
- 在qemu终端,进入/mnt目录查看拷贝的文件
cd /mnt && ls /mnt
- 在qemu终端,加载hello驱动,可以看到驱动入口函数打印
hello init
- 在qemu终端,通过应用程序向驱动程序写数据。
- 返回的信息第一行是驱动打印信息,第二行是应用程序打印信息。
- 返回的信息第一行是驱动打印信息,第二行是应用程序打印信息。
- 在qemu终端,通过应用程序向驱动程序读数据。
- 返回的信息第一行是驱动打印信息,第二行是应用程序打印信息。
- 在qemu终端,卸载驱动程序,可以看到驱动出口函数打印
hello exit
4.1、ATK-IMX6ULL开发板
注意,“/lib/modules/4.1.15
”这个目录用来存放驱动模块,使用modprobe 命令加载驱动模块的时候,驱动模块要存放在此目录下。“/lib/modules
”是通用的,不管你用的什么板子、什么内核,这部分是一样的。不一样的是后面的“4.1.15”,这里要根据你所使用的 Linux 内核版本来设置,比如 ALPHA 开发板现在用的是 4.1.15 版本的 Linux 内核,因此就是“/lib/modules/4.1.15
”。如果你使用的其他版本内核,比如 5.14.31,那么就应该创建“/lib/modules/5.14.31
”目录,否则 modprobe 命令无法加载驱动模块。
驱动加载成功需要在/dev 目录下创建一个与之对应的设备节点文件,应用程序就是通过操作这个设备节点文件来完成对具体设备的操作。
- 拷贝驱动
.ko
文件和应用程序文件到文件系统sudo cp -f *.ko hello ~/linux/nfs/rootfs/lib/modules/4.1.15
- 输入如下命令加载
hello.ko
驱动文件:modprobe hello.ko
加载过程中若出现
modprobe: module hello.ko not found in modules.dep
错误,直接输入depmod
即可解决
-
卸载驱动
rmmod hello
-
其他需要知道的
- 加载成功后,输入
lsmod
可查看当前系统存在的模块 - 输入
cat /proc/devices
,可查看当前系统有无驱动程序注册的设备 - 输入
ls /dev/hello
,可以查看注册的驱动设备
- 加载成功后,输入