打开盒子，里面来个全家福。

盒子里面包含的东西有，开发板（底板+核心板）一块，12V2A电源适配器一个，micro usb安卓数据线一根，type-c安装数据线一根，显示屏排线一根。

再来个开发板的近景图

这款开发板有两个版本，一个是NAND版本，内存容量512MB+512MB，另一款是eMMC版本，内存是512MB+8GB。我手上的是NAND版本，NAND和eMMC开发的程序除了U-boot不一样，其它都一样，很容易切换。
野火i.MX6ULL处理器主频800MHz，包含两个网口，很容易进行网络编程。

该开发板配置如上图。板载一个HDMI的高清视频接口，在没有屏幕的情况下，可以直接接电脑屏幕使用。
关于开箱内容，就写到这里。

NFS的环境搭建

本文在win10的虚拟机中安装ubuntu18.04进行开发，其中所有的坑及解决方法都基于此系统。
在ubuntu的终端中输入

sudo apt-get update
sudo apt install net-tools
sudo apt install make gcc-arm-linux-gnueabihf gcc bison flex libssl-dev dpkg-dev lzop

将ubuntu和开发板连接到同一台路由器上，确保两者的ip在同一个网段。
Ubuntu中输入

sudo apt install nfs-kernel-server

在home/user下建立nfs文件夹,并通过以下命令赋予权限(我的user目录为hasee)

sudo chmod -R 777 nfs

使用vim命令打开/etc/exports
更改如下内容

保存后重启虚拟机。
在ubuntu下使用ifconfig查询本机ip

我的ip：192.168.2.217
通过串口终端连接win10电脑和开发板，分享一个我经常用的工具，MobaXterm_Personal_20.6，功能非常强大，谁用谁知道。
打开MobaXterm按照如下图操作

这样就可以操作开发板的终端了，首先在根目录下的mnt目录下建立nfs文件夹,
输入pwd后返回如下路径

在开发板中输入

sudo mount -t nfs 192.168.2.217:/home/user/nfs /mnt/nfs

说明: 192.168.2.217这个IP是电脑虚拟机ubuntu的ip
/home/user/nfs是虚拟机的ubuntu的nfs文件夹路径
/mnt/nfs是开发板中nfs的路径
只要没有出现如下提示即表示成功:

编写第一个测试程序

在ubuntu中编写简单的测试程序,文件名helloworld.c,源码如下

#include "stdio.h"
int main(int argc,char **argv)
{
     printf("hello world!\n");
     return 0;
}

执行如下命令进行编译,这里必须使用交叉编译工具,否则无法再开发板上运行:

gcc-arm-linux-gnueabihf-gcc helloworld.c -o helloworld

会在相同路径下生成一个helloworld文件,如下

将新生成的helloworld文件通过cp命令拷贝到ubuntu的home/user/nfs路径下。
从win10上的MobaXterm工具操作开发板终端，进入到/mnt/nfs路径下,发现里面的helloworld文件,执行命令

./helloworld

这就表示程序成功执行，搭建的环境可用。
前面我们实现了最简单的驱动模版，这次我们继续探究驱动程序的编写。
驱动代码核心的两句，是注册模块加载函数module_init（）和注册模块卸载函数module_exit（）。
本次我们要提到的是设备号的申请，字符设备的注册和节点的创建。

申请设备号

申请设备号通常有两种申请方式：静态申请和动态申请。

静态申请设备号

静态申请设备号的函数原型

int register_chrdev_region(dev_t from, unsigned count, const char *name)
//参数dev_t from： dev_t类型的变量，用于指定字符设备的起始设备号，如果要注册的设备号已经被其他的设备注册了，那么就会导致注册失败。
//参数unsigned count：指定要申请的设备号个数，count的值不可以太大，否则会与下一个主设备号重叠。
//参数const char *name：表示设备名称，我们可以在/proc/devices中看到该设备。
//返回值0表示申请成功，返回其它表示失败，并且失败的原因可以通过错误码获取。

使用静态申请设备号时，都需要去查阅内核哪些设备号被使用，一旦有重复的将导致设备号申请失败，对应的设备注册不成功，使用十分不便。

动态申请设备号

动态申请设备号的函数原型

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
//参数dev_t *dev：指向dev_t类型数据的指针变量，用于存放分配到的设备编号的起始值；
//参数unsigned baseminor：次设备号的起始值，通常情况下，设置为0；
//参数unsigned count：同register_chrdev_region类型，用于指定需要分配的设备编号的个数以及设备的名称。
//返回值0表示申请成功，返回其它表示失败，并且失败的原因可以通过错误码获取。

该函数函数，内核会自动分配给我们一个尚未使用的主设备号，不要认为操作，使用比静态方便多了，在司机程序开发中，特别是在3.x的内核中使用十分普遍。

释放设备号

无论是以上哪种方式申请设备号，都需要使用unregister_chrdev_region（）函数来释放设备号，释放设备号的函数在删除设备时被调用，以供设备重新注册时提供可用的设备号。如果删除时不释放，在设备重新添加时将报错，导致新设备不可用，进而影响驱动的稳定。
函数原型

void unregister_chrdev_region(dev_t from, unsigned count)
//参数dev_t from：指定需要注销的字符设备的设备编号起始值，我们一般将定义的dev_t变量作为实参。
//参数unsigned count：指定需要注销的字符设备编号的个数，该值应与申请函数的count值相等，通常采用宏定义进行管理。

动静态综合方式申请设备号

在内核中提供了一个函数既可以用于动态申请，也可以用于静态申请，原型如下

static inline int register_chrdev(unsigned int major, const char *name,const struct file_operations *fops)
{
   return __register_chrdev(major, 0, 256, name, fops);
}
//参数unsigned int major：该参数用于指定要申请的主设备号，相当于静态申请，当该值设为0时，由系统自动分配，相当于动态申请。
//参数const char *name：指定设备的名称。
//参数const struct file_operations *fops：设备的函数接口指针。

该函数的释放设备号函数原型如下

该函数的释放设备号函数原型如下
static inline void unregister_chrdev(unsigned int major, const char *name)
{
    __unregister_chrdev(major, 0, 256, name);
}

至于该部分，贴出我的代码

printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module Init\n");
ret = alloc_chrdev_region(&devno, 0,1, "HelloWorld");
if(ret == 0)
    printk(KERN_EMERG "[ KERN_EMERG ]  baseminor ok\n");
else
    return 0;
major = MAJOR(devno);
minor = MINOR(devno);

cdev操作

初始化

我们使用驱动的API与系统的API进行关联，主要是要实现file_operations结构体，而这个结构体需要使用cdev_init（）函数来操作。

void cdev_init(struct cdev *cdev, const struct file_operations *fops)
//cdev：struct cdev类型的指针变量，指向需要关联的字符设备结构体；
//fops：file_operations类型的结构体指针变量，一般将实现操作该设备的结构体file_operations结构体作为实参。

注册

注册使用如下函数

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
//p：struct cdev类型的指针，用于指定需要添加的字符设备；
//dev：dev_t类型变量，用于指定设备的起始编号；
//count：指定注册多少个设备。

只有注册了才能通过后续操作来创建设备节点。

注销

void cdev_del(struct cdev *p)
//p：struct cdev类型的指针，用于指定需要添加的字符设备。
//注册和注销是配对的，注销函数实在删除设备时执行的。

该部分我的代码

cdev_init(&cdev,&fops);
ret = cdev_add(&cdev, devno, 1);
if(ret < 0)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  cdev_add error\n");
}

file_operations结构体

该结构体是api的主要实现地方，该结构体原型很庞大，我就截个图上来吧

这只是其中一部分，本文实现的函数仅仅是open()，release()，write()，read()，这是个函数将通过应用层的api一一调用演示。
该部分我的代码如下

ssize_t hello_read(struct file *file, char __user *data, size_t length, loff_t *loff)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module hello_read\n");
    return 0;
}

ssize_t hello_write(struct file *file, const char __user *data, size_t length, loff_t *loff)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module hello_write\n");
    return 0;
}

int hello_open(struct inode *inode, struct file *file)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module hello_open\n");
    return 0;
}
int hello_release(struct inode *inode, struct file *file)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module hello_release\n");
    return 0;
}


struct file_operations fops = 
{
    .owner = THIS_MODULE,
    .open = hello_open,
    .release = hello_release,
    .write = hello_write,
    .read = hello_read,
};

设备节点

设备节点的创建

节点的创建就是要讲设备创建并且注册到文件系统中，其函数原型如下

struct device *device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt)
//struct class *class：指向这个设备应该注册到的struct类的指针；
//struct device *parent：指向此新设备的父结构设备（如果有）的指针，通常是NULL；
//dev_t devt：要添加的字符设备的设备号；
//void *drvdata：要添加到设备进行回调的数据；
//const char *fmt：输入设备名称。

创建成功时返回设备结构体指针，失败时返回错误码。

设备节点的删除

删除设备节点原型函数如下

void device_destroy(struct class *class, dev_t devt)
//struct class *class：指向注册此设备的struct类的指针；
//dev_t devt：要添加的字符设备的设备号。

设备号的删除是在设备删除时执行的。
该部分我的代码如下，代码很简单，只要理解到了，很容易就写出来

hello_class = class_create(THIS_MODULE,"HelloWorld");
device_create(hello_class,NULL,devno,NULL,"HelloWorld");//创建设备节点

代码

Hellomodule.c文件如下

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/types.h>
#include "linux/cdev.h"
#include <linux/fs.h>
#include <linux/device.h>

int major = 0;
int minor = 0;
dev_t devno = 0;
struct cdev cdev;
static struct class *hello_class;

ssize_t hello_read(struct file *file, char __user *data, size_t length, loff_t *loff)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module hello_read\n");
    return 0;
}

ssize_t hello_write(struct file *file, const char __user *data, size_t length, loff_t *loff)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module hello_write\n");
    return 0;
}

int hello_open(struct inode *inode, struct file *file)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module hello_open\n");
    return 0;
}
int hello_release(struct inode *inode, struct file *file)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module hello_release\n");
    return 0;
}


struct file_operations fops = 
{
    .owner = THIS_MODULE,
    .open = hello_open,
    .release = hello_release,
    .write = hello_write,
    .read = hello_read,
};

static int __init hello_init(void)
 {
    int ret = 0;
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module Init\n");
    ret = alloc_chrdev_region(&devno, 0,1, "HelloWorld");
    if(ret == 0)
        printk(KERN_EMERG "[ KERN_EMERG ]  baseminor ok\n");
    else
        return 0;
    major = MAJOR(devno);
    minor = MINOR(devno);
    cdev_init(&cdev,&fops);
    ret = cdev_add(&cdev, devno, 1);
    if(ret < 0)
    {
        printk(KERN_EMERG "[ KERN_EMERG ]  cdev_add error\n");
    }
    hello_class = class_create(THIS_MODULE,"HelloWorld");
    device_create(hello_class,NULL,devno,NULL,"HelloWorld");//创建设备节点
    return 0;
}

static void __exit hello_exit(void)
{
    device_destroy(hello_class, devno);
    class_destroy(hello_class);
    cdev_del(&cdev);
    unregister_chrdev_region(devno, 1);
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module Exit\n");
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("chen");

Helloworld.c代码如下

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

int main()
{
    char buf[4] = {0};
    char *hello = "/dev/HelloWorld";
    int fd = open(hello,O_RDWR|O_NDELAY);
    if(fd < 0)
    {
        printf("open error\n");
        return 0;
    }
    write(fd,"0",1);
    read(fd,buf,1);
    close(fd);
    return 0;
}

Helloworld.c代码是一个应用层的测试代码，编译时使用如下命令

arm-linux-gnueabihf-gcc helloworld.c -o helloworld

效果

输入安装命令，可以看到打印了模块初始化语句

执行sudo ./helloworld可以看到我们程序中调用的4个函数都分别执行了一遍

同时使用命令ls /dev/H*能够看到我们自己的设备名称

通过卸载命令，可以看到卸载函数的打印信息

驱动简介

字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、 IIC、 SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。
在linux中，驱动加载成功后会在“/dev”目录下生成一个相应的文件，我们自己编写的应用程序可以通过这个文件进行open来打开这个文件，使用close来关闭这个文件。open、 close这些函数是由 C 库提供的，在 Linux 系统中，系统调用作为 C 库的一部分。

驱动入口和出口

Linux的驱动加载有两种方式，一种是将驱动编译到内核中，在内核启动的时候，驱动一起启动。另一种是将驱动编译成模块，在内核启动起来之后通过手动或者脚脚本再添加到内核中，添加到内核的命令insmod，卸载驱动的命令rmmod。
在编写驱动中，使用如下入口来加载和卸载驱动

module_init(hello_init); //注册模块加载函数
module_exit(hello_exit); //注册模块卸载函数

在驱动加载时，输入insmod命令加载驱动, hello_init函数会首先被调用,在卸载驱动时,输入rmmod命令, hello_exit就会被调用。

代码实践

下面来写一个最简单的驱动模版。

static int __init hello_init(void)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module Init\n");
return 0;
}
static void __exit hello_exit(void)
{
    printk(KERN_EMERG "[ KERN_EMERG ]  Hello  Module Exit\n");
}

编写makefile文件

KERNEL_DIR=~/Kernel/ebf-buster-linux/build_image/build
ARCH=arm
CROSS_COMPILE=arm-linux-gnueabihf-
export  ARCH  CROSS_COMPILE
obj-m := hellomodule.o
all:
     $(MAKE) -C $(KERNEL_DIR) M=$(CURDIR) modules

然后进行make,在makefile相同目录中会产生一个*.ko的文件

将hellomodule.ko文件拷贝到nfs路径下,命令

cp ./ hellomodule.ko /home/hasee/nfs

打开开发板的串口终端，在nfs中执行insmod命令，结果如下

在该图中，我们看到已经打印出来的[ KERN_EMERG ] Hello Module Init内容，说明模块已经加载成功。
我们可以执行lsmod来查看当前内核中有没有我们的模块名存在

然后我们执行命令rmmod来卸载模块

这里有一点不一样，在安装模块时，我们用的命令中模块名写的hellomodule.ko，而卸载是模块名写的hellomodule，这一点一定要注意。
如上我们完成了一个简单的设备驱动，以后所有的驱动都是在这个模板上进行功能的添加的。
完整代码如下

下一篇文章我们将在该模板中添加设备号,实现open,close,write,read等函数,按照如下图的关系实现一个完整的字符设备测试案例

本篇完,下次见。