Linux底层驱动编译原理 ，编译过程 以及 装载（树莓派）

一.用户支配驱动工作的过程

1. 上层应用调用open，read，write等标准C库函数
2. 触发软中断：0x80 ，由用户态进入到内核态，发生系统调用
3. 系统调用syscall，文件子系统会调用相应的sysopen，sysread，syswrite，
4. sysopen，sysread，syswrite根据设备号和设备名找到相应的驱动
5. 设备驱动根据会根据用户的输入调用自己的open，read，write，从而实现对硬件的控制

二.驱动的框架

1. 一个驱动由设备名和和设备号组成的结构体，设备号又分为主设备号和次设备号，例如：pin5 8 3
   df -T:查看文件系统（树莓派）
   sudo mknod +name +主设备号+次设备号：手动生成设备
2. 众多的 驱动在内核中，是以驱动链表的形式存储的
3. 驱动的增删查找，是通过设备名和设备号实现的
4. 最简单的驱动框架（没做任何事）如下：

#include <linux/fs.h>		 //file_operations声明
#include <linux/module.h>    //module_init  module_exit声明
#include <linux/init.h>      //__init  __exit 宏定义声明
#include <linux/device.h>	 //class  devise声明
#include <linux/uaccess.h>   //copy_from_user 的头文件
#include <linux/types.h>     //设备号  dev_t 类型声明
#include <asm/io.h>          //ioremap iounmap的头文件


static struct class *pin4_class;  
static struct device *pin4_class_dev;

static dev_t devno;                //设备号
static int major =231;  		   //主设备号
static int minor =0;			   //次设备号
static char *module_name="pin4";   //模块名




//led_open函数
static int pin4_open(struct inode *inode,struct file *file)
{
    printk("pin4_open\n");  //内核的打印函数和printf类似
   

    
    return 0;
}

//led_write函数
static ssize_t pin4_write(struct file *file,const char __user *buf,size_t count, loff_t *ppos)
{


    return 0;
}

static struct file_operations pin4_fops = {

    .owner = THIS_MODULE,
    .open  = pin4_open,
    .write = pin4_write,
};

int __init pin4_drv_init(void)   
{

    int ret;
    devno = MKDEV(major,minor);  //创建设备号
    ret   = register_chrdev(major, module_name,&pin4_fops);  //注册驱动  告诉内核，把这个驱动加入到内核驱动的链表中

    pin4_class=class_create(THIS_MODULE,"myfirstdemo");
    pin4_class_dev =device_create(pin4_class,NULL,devno,NULL,module_name);  //创建设备文件

 
    return 0;
}

void __exit pin4_drv_exit(void)
{

    device_destroy(pin4_class,devno);
    class_destroy(pin4_class);
    unregister_chrdev(major, module_name);  //卸载驱动

}

module_init(pin4_drv_init);  //入口
module_exit(pin4_drv_exit);
MODULE_LICENSE("GPL v2");

三.框架解读

• 涉及底层内核方面的代码，跟上层代码不一样，内核里面的代码已经形成了非常大的一个结构，我们编写代码的时候就必须按照内核的框架进行。

3.1 驱动框架的原理：

1. 上层程序，调用open打开设备驱动，
2. 驱动程序打开以后，内核驱动按照提前写好的框架，上层一旦调用open，底层就响应open生成配置好相应的设备驱动，然后等待用户的指令。
3. 上层程序肯定，调用上层的read/write，会触发软中断0x80，导致系统调用sys_call，文件系统就会调用sys_read和sys_write,进而导致驱动程序调用驱动的read和write，这样就完成了上层和底层之间的通信。
4. 驱动程序通过read/write获取或者发送指令后，就会进行相应的逻辑判断，然后执行相应的代码
5. 不同的上层指令，会导致底层对寄存器不同的操作，从而控制引脚输入输出，实现不同的功能
6. 执行完相应的操作后，底层还会卸载驱动，然后结束程序。

3.2 module_init（）

module_init(pin5_drv_init);  //入口

• 它不是一个函数，是一个宏，当宏被调用时候，就会调用括号里面的函数，它是整个程序的入口。

3.3 file_operations

static struct file_operations pin5_fops = {

    .owner = THIS_MODULE,
    .open  = pin5_open,
    .write = pin5_write,
};

• 它是一个结构体，里面包含了很多个函数声明，远不止上面看到的哪些
• 如图我们只需要用到的函数单独赋值就行了
• 注意，只有Linux里面可以这样赋值
• static的作用
  内核代码数量庞大，为了防止与其他的文件有变量命名冲突，static限定变量的作用域仅仅只在这个文件。

3.4 copy_from_user（）和copy_to_user（）

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

• copy_from_user：将用户空间的数据拷贝到内核空间，用户空间用write写
• copy_to_user：将内核空间中的数据拷贝到用户空间，用户空间用read读

3.5 module_exit（）

module_exit(pin4_drv_exit);//出口

3.6 MODULE_LICENSE(“GPL v2”);

• 模块的许可证声明：内核接受的有意义的许可证有 “GPL”，“GPL v2”，“GPL and additional rights”，“Dual BSD/GPL”，“Dual MPL/GPL”，“Proprietary”。

四.驱动的编译

1. 写完把它放到驱动设备目录中，如：pin4引脚驱动，我把它放到内核源码的~/SYSTEM/linux-rpi-4.14.y/drivers/char，因为这是个字符设备

ztj@ubuntu:~/SYSTEM/linux-rpi-4.14.y/drivers$ cd char
ztj@ubuntu:~/SYSTEM/linux-rpi-4.14.y/drivers/char$ ls
agp              ds1302.c           hw_random  mem.o            nvram.c             ps3flash.c     snsc_event.c  ttyprintk.c
apm-emulation.c  ds1620.c           ipmi       misc.c           nwbutton.c          random.c       snsc.h        ttyprintk.o
applicom.c       dsp56k.c           Kconfig    misc.o           nwbutton.h          random.o       sonypi.c      uv_mmtimer.c
applicom.h       dtlk.c             lp.c       modules.builtin  nwflash.c           raw.c          tb0219.c      virtio_console.c
bfin-otp.c       efirtc.c           Makefile   modules.order    pc8736x_gpio.c      raw.o          tile-srom.c   xilinx_hwicap
broadcom         generic_nvram.c    mbcs.c     mspec.c          pcmcia              rtc.c          tlclk.c       xillybus
bsr.c            hangcheck-timer.c  mbcs.h     mwave            powernv-op-panel.c  scx200_gpio.c  toshiba.c
built-in.o       hpet.c             mem.c      nsc_gpio.c       ppdev.c             snsc.c         tpm

3. 找到该目录下的Makefile文件，用它可以进行目录下的驱动的编译
4. 驱动的两种编译模式，一是直接编译进内核，二是编译成模块module，
5. 我们选择编译成模块，先vi进入编辑文件

# SPDX-License-Identifier: GPL-2.0
#
# Makefile for the kernel character device drivers.
#

obj-y                           += mem.o random.o
obj-$(CONFIG_TTY_PRINTK)        += ttyprintk.o
obj-y                           += misc.o
obj-$(CONFIG_ATARI_DSP56K)      += dsp56k.o
obj-$(CONFIG_VIRTIO_CONSOLE)    += virtio_console.o
obj-$(CONFIG_RAW_DRIVER)        += raw.o
obj-$(CONFIG_SGI_SNSC)          += snsc.o snsc_event.o
obj-$(CONFIG_MSPEC)             += mspec.o
obj-$(CONFIG_UV_MMTIMER)        += uv_mmtimer.o
obj-$(CONFIG_IBM_BSR)           += bsr.o
obj-$(CONFIG_SGI_MBCS)          += mbcs.o
obj-$(CONFIG_BFIN_OTP)          += bfin-otp.o

obj-$(CONFIG_PRINTER)           += lp.o

obj-$(CONFIG_APM_EMULATION)     += apm-emulation.o

obj-$(CONFIG_DTLK)              += dtlk.o
obj-$(CONFIG_APPLICOM)          += applicom.o
obj-$(CONFIG_SONYPI)            += sonypi.o
obj-$(CONFIG_RTC)               += rtc.o
obj-$(CONFIG_HPET)              += hpet.o
obj-$(CONFIG_EFI_RTC)           += efirtc.o

6. 我们仿照已经写好的代码，在注释后的第一行加上：obj-m += 你要生成的驱动， 注意设备名要带后缀
7. 回到内核源码树根目录下，用配置好的交叉编译工具编译即可，只要生成modules，

ARCH=arm CROSS_COMPILE=arm-gnueabihf- KERNEL=kernel7 make modules 

8. 编译成功，会生成一个.ko镜像文件，用scp把.ko文件拷贝到目标平台上
9. 在目标平台上，加载驱动

sudo  insmod  XXXX.ko

10. ls /dev/查看是否生成了驱动
11. lsmod 查看驱动是否装载
12. sudo rmmod xxx.ko：可以卸载驱动，每次重新编译都要卸载一下，不然会提示驱动已存在。
13. sudo chmod 666 /dev/驱动 给所有用户驱动权限
14. 自己写一个驱动的调用代码，简单的验证一下，驱动的调用就跟操作普通文件一样
15. 调用的过程中，因为驱动时在下层态，上层窗口看不到，程序打印的信息可以使用dmesg查看