【嵌入式Linux驱动开发】二、上手Hello驱动，了解驱动开发流程

  我们知道他们在说谎，他们也知道他们在说谎，他们知道我们知道他们在说谎，我们也知道他们知道我们知道他们在说谎，但是他们依然在说谎。

---

一、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.88Linux内核）

  驱动程序与应用程序的命名（并无固定的格式）

• 驱动程序：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));
    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函数。
• 写一点编译一下，有错误及时更正！
• 函数使用参考内核中已有的驱动文件！

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

四、运行效果

启动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