一、Hello 驱动(不涉及硬件操作)
我们选用的内核都是 4.x 版本，操作都是类似的：
rk3399 linux 4.4.154
rk3288 linux 4.4.154
imx6ul linux 4.9.88
am3358 linux 4.9.168
1.如何编写驱动程序
2.APP 打开的文件在内核中如何表示
APP 打开文件时，可以得到一个整数，这个整数被称为文件句柄。对于 APP 的每一个文件句柄，在内核里面都有一个“struct file”与之对应。
可以猜测，我们使用 open 打开文件时，传入的 flags、mode 等参数会被记录在内核中对应的 struct file 结构体里(f_flags、f_mode)：
int open(const char *pathname, int flags, mode_t mode);
去读写文件时，文件的当前偏移地址也会保存在 struct file 结构体的 f_pos 成员里。
3. 打开字符设备节点时，内核中也有对应的 struct file
注意这个结构体中的结构体：struct file_operations *f_op，这是由驱动程序提供的。
结构体 struct file_operations 的定义如下： 
二、编写代码
1.写驱动程序
参考 driver/char 中的程序，包含头文件，写框架，传输数据：
（1）驱动中实现 open, read, write, release，APP 调用这些函数时，都打印内核信息
（2）APP 调用 write 函数时，传入的数据保存在驱动中
（3）APP 调用 read 函数时，把驱动中保存的数据返回给 APP
2.hello_drv.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> /* 1. 确定主设备号 */ static int major = 0; static char kernel_buf[1024]; static struct class *hello_class; #define MIN(a, b) (a < b ? a : b) /* 3. 实现对应的open/read/write等函数，填入file_operations结构体 */ static ssize_t hello_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 hello_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 hello_drv_open (struct inode *node, struct file *file) { printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); return 0; } static int hello_drv_close (struct inode *node, struct file *file) { printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); return 0; } /* 2. 定义自己的file_operations结构体 */ static struct file_operations hello_drv = { .owner = THIS_MODULE, .open = hello_drv_open, .read = hello_drv_read, .write = hello_drv_write, .release = hello_drv_close, }; /* 4. 把file_operations结构体告诉内核：注册驱动程序 */ /* 5. 谁来注册驱动程序啊？得有一个入口函数：安装驱动程序时，就会去调用这个入口函数 */ static int __init hello_init(void) { int err; printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); major = register_chrdev(0, "hello", &hello_drv); /* /dev/hello */ hello_class = class_create(THIS_MODULE, "hello_class"); err = PTR_ERR(hello_class); if (IS_ERR(hello_class)) { printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); unregister_chrdev(major, "hello"); return -1; } device_create(hello_class, NULL, MKDEV(major, 0), NULL, "hello"); /* /dev/hello */ return 0; } /* 6. 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数 */ static void __exit hello_exit(void) { printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__); device_destroy(hello_class, MKDEV(major, 0)); class_destroy(hello_class); unregister_chrdev(major, "hello"); } /* 7. 其他完善：提供设备信息，自动创建设备节点 */ module_init(hello_init); module_exit(hello_exit); MODULE_LICENSE("GPL");
参考Linux的内核进行编写程序D:\linux\Linux-4.9.88\Linux-4.9.88\drivers\char（字符驱动程序）
第18~24行：确定主设备号
第19行：主设备号
第20行：将write得到的数据传入数组 kernel_buf中
第24行：得到数据长度的最小值
第26~53行：实现对应的open/read/write等函数，填入file_operations结构体
第31行：读取 kernel_buf中的信息
第39行：将信息写入 kernel_buf
第55~62行：定义自己的file_operations结构体
在结构体内设置open, read, write, release这四个成员
第66~85行：得有一个入口函数：安装驱动程序时，就会去调用这个入口函数
第82行：创造设备
第87~94行：得到一个出口函数：卸载驱动程序时，就会去调用这个出口函数
第92行：销毁设备
第99~102行：提供设备信息，自动创建设备节点
第102行：增加GPL协议
阅读一个驱动程序，从它的入口函数开始，第 66 行就是入口函数。它的主要工作就是第 71 行，向内核注册一个 file_operations 结构体：hello_drv， 这就是字符设备驱动程序的核心。
file_operations 结构体 hello_drv 在第 56 行定义，里面提供了 open/read/write/release 成员，应用程序调用 open/read/write/close 时就会导致这些成员函数被调用。
file_operations 结构体 hello_drv 中的成员函数都比较简单，大多数只是打印而已。要注意的是，驱动程序和应用程序之间传递数据要使用 copy_from_user/copy_to_user 函数。
3.写测试程序
测试程序要实现写、读功能：
./hello_drv_test -w www.100ask.net // 把字符串“www.100ask.net”发给驱动程序 ./hello_drv_test -r // 把驱动中保存的字符串读回来
#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <stdio.h> #include <string.h> /* * ./hello_drv_test -w abc * ./hello_drv_test -r */ int main(int argc, char **argv) { int fd; char buf[1024]; int len; /* 1. 判断参数 */ if (argc < 2) { printf("Usage: %s -w <string>\n", argv[0]); printf(" %s -r\n", argv[0]); return -1; } /* 2. 打开文件 */ fd = open("/dev/hello", O_RDWR); if (fd == -1) { printf("can not open file /dev/hello\n"); return -1; } /* 3. 写文件或读文件 */ if ((0 == strcmp(argv[1], "-w")) && (argc == 3)) { len = strlen(argv[2]) + 1; len = len < 1024 ? len : 1024; write(fd, argv[2], len); } else { len = read(fd, buf, 1024); buf[1023] = '\0'; printf("APP read : %s\n", buf); } close(fd); return 0; }
三、测试
编写驱动程序的 Makefile
驱动程序中包含了很多头文件，这些头文件来自内核，不同的 ARM 板它的某些头文件可能不同。所以编译驱动程序时，需要指定板子所用的内核的源码路径。、
要编译哪个文件？这也需要指定，设置 obj-m 变量即可，怎么把.c 文件编译为驱动程序.ko？这要借助内核的顶层 Makefile。 本驱动程序的 Makefile 内容如下：
# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR # 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量: # 2.1 ARCH, 比如: export ARCH=arm64 # 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu- # 2.3 PATH, 比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin # 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同, # 请参考各开发板的高级用户使用手册 KERN_DIR = KERN_DIR = /home/book/100ask_imx6ull-sdk/Linux-4.9.88 all: make -C $(KERN_DIR) M=`pwd` modules $(CROSS_COMPILE)gcc -o hello_drv_test hello_drv_test.c clean: make -C $(KERN_DIR) M=`pwd` modules clean rm -rf modules.order rm -f hello_drv_test obj-m += hello_drv.o
先设置好交叉编译工具链，编译好你的板子所用的内核，然后修改 Makefile 指定内核源码路径，最后即可执行 make 命令编译驱动程序和测试程序。
注意：我们是在 Ubuntu 中编译程序，但是需要在 ARM 板子上测试。所以需要把程序放到 ARM 板子上。
启动单板后，可以通过 NFS 挂载 Ubuntu 的某个目录，访问该目录中的程序。
cp *.ko hello_drv_test ~/nfs_rootfs/
在 ARM 板上测试：
//安装驱动程序
[root@100ask:/mnt]# insmod hello_drv.ko
// 驱动程序会生成设备节点
// 查看测试程序的用法
//往驱动程序中写入字符串
// 从驱动程序中读出字符串
