基于树莓派驱动开发详解

一、驱动开发认知
1、驱动开发思想
要想进行驱动开发首先我们应该知道，上层到底层是如何进行的，上层调用c库的open函数，首先会发生一次软中断，从用户空间进入内核空间，触发系统调用接口函数sys_call，然后通过open函数的设备名找到设备号， 调用虚拟文件系统的sys_open，最后去调用底层驱动的open，操作相关的寄存器，实现io口拉高电平或者低电平。
因此我们在进行驱动开发的时候，从底层到上层依次实现，首先在内核空间添加驱动，通过文件名和设备号来区分底层驱动，然后编写底层设备驱动函数，最后编译驱动，将驱动加载到驱动链表上，而驱动插入的顺序由设备号决定。
驱动开发通俗的来说，自己实现底层的驱动，实现wiringPi库。
2、 设备号
Linux设备管理和文件系统紧密结合的，各种设备文件都以文件形式存放在/dev目录下，称为设备文件，应用程序可以打开读写这些设备文件，完成对设备的操作。为了管理这些设备，给这些设备编号，每个设备号又分为主设备号和次设备号，主设备号用来区分不同种类的设备，次备号用来区分同一类型的多个设备，即主设备就是华为这个品牌，次设备号就是华为的各种型号。
二、基于驱动框架编写驱动代码
驱动代码框架

#include <linux/fs.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <asm/io.h>

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";   //模块名
static int pin4_open(struct inodesinode,struct file *file)
{
   printk("pin4_open\n");
   return 0;
}
static ssize_t pin4_write(struct file *file,const char __user *buf,size_t count, loff_t *ppos)
{
   printk("pin4_write\n");
   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);   // 2.创建设备号 
    ret   = register_chrdev(major, module_name,&pin4_fops);    //3.h驱动 告诉内核，
                                                              // 把这个驱动
                                                              //加入到内核的链表中
    pin4_class=class_create(THIS_MODULE,"myfirstdemo");  // 让代码在dev自动生成设备
    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_duinit);     //入口，  内核加载驱动的时候，这个宏会被调用
module_exit(pin4_drv_exit);
MODULE_LICENSE("GPL v2");

以上是通过框架代码添加底层驱动结点
手动添加底层驱动结点 sudo mknod ghc c 8 1
//ghc：设备名 c：字符设备驱动 8：主设备号 1：次设备号
在/dev目录下 ls -l 便可查看手动添加的设备
三、驱动框架代码的编译和测试
1、将编写好的驱动代码拷贝到linux内核/drivers/char目录下
cp pin4Driver.c /home/ghc/SYSTEM/linux-rpi-4.14.y/drivers/char
修改Makefile文件，将驱动编译进模块
vi Makefile
添加 obj-m +=pin4Driver.o

2、回到源码目录下 cd /home/ghc/SYSTEM/linux-rpi-4.14.y
输入以下指令 ARCH=arm CROSS_COMPILE=arm-lin’cux-gnueabihf- KERNEL=kernel7 make modules

3、将/drivers/char目录下新生成的pin4Driver.ko文件拷贝到树莓派
scp drivers/char/pin4Driver.ko pi@192.168.1.123:/home/pi
4、在树莓派下
sudo insmod pin4Driver.ko 装载驱动
然后用ls /dev/pin4 -l 就会发现生成了pin4 设备文件
lsmod 就会发现生成了pin4Driver 设备驱动

然后 sudo chmod 666 /dev/pin4 让所有人都有读写的权限 后运行realtest

便可通过上层open("/dev/pin4",O_RDWR); 来打开这个设备文件，向底层写入相应的值，拉高或者拉低电平
还可以dmesg检索内核的printk查看打印信息

最后通过gpio readall命令可以查看io口状态

四、硬件地址的相关介绍
1、总线地址
32位的操作系统 ，cpu最多只能访问2^32bit，即只能访问4G的内存
64位的操作系统 ，cpu最多只能访问2^64bit，即只能访问8G的内存
2、物理地址
物理地址又叫硬件的实际地址或绝对地址
3、虚拟地址
是逻辑地址，有了虚拟地址cpu访问的内存可完全u大于8g。程序大都跑在由物理地址映射成的逻辑地址上。
五、树莓派博通芯片BCM2835导读
由于我们要进行 引脚 驱动的编写，所以我们直接查看第六章的内容

这张图片类似的 总共有六张，分别是GPFSET0-GPFSET5，代表六个寄存器，每个寄存器可以操作9个引脚，操作引脚可以通过设置对应寄存器的位数，三位代表一个引脚，比如上图中FSET19，表示第19个引脚可以从右往左数的27 28 29位设置成001，可将对应引脚设置成输出引脚。下面代码以操作引脚4为例编写驱动代码。

这张图片表示有GPSET0和GPSET1两个寄存器，其中GPSET0表示操作0-31引脚，将对应引脚设置成1，可置高电平，设置成0，表示没有效果。

这张图片表示有GPCLR0和GPCLR1两个寄存器，其中GPCLR0表示操作0-31引脚，将对应引脚设置成1，可置低电平，设置成0，表示没有效果。
六、寄存器地址问题
我们在编写驱动程序的时候，IO空间的起始地址是0x3f000000,加上GPIO的偏移量0x200000,所以GPIO的物理地址应该是从0x3f200000开始的，然后在这个基础上进行Linux系统的MMU内存虚拟化管理，映射到虚拟地址上。并由下图address总线地址尾部偏移可知，GPFSET0 物理地址为0x3f200000，GPSET0物理地址为0x3f20001c，GPCLR0物理地址为0x3f200028。

该图的address是总线地址，并不是我们要的物理地址
七、底层引脚驱动代码及上层测试文件

底层驱动代码

#include <linux/fs.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <asm/io.h>
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";   //模块名
volatile unsigned int* GPFSEL0=NULL;         //不会因编译器的优化而省略，每次直接读值
volatile unsigned int* GPSET0=NULL;
volatile unsigned int* GPCLR0=NULL;
static int pin4_open(struct inode *inode,struct file *file)
{
      printk("pin4_open\n");
      *GPFSEL0 &=~(0x6<<12);   //0x6  0110 左移12位    
        //取反后1001与上 结果为把bit1314配置成0
        //&= 有0则是0 取反后只有13 14位是0 其余位是1 因此&=可以保证GPFSEL0 只有13 14位变为0 
        //其余位仍保持原位
      *GPFSEL0 |=(0x1<<12);     //把第12位配置成1       
        //14～12位001输出  000为输入  
        //|= 有1则是1 |=可以保证GPFSET0 只有12位变成1，其余位仍保持原位
        //上述操作是将引脚4 12-14配置成001 变为输出引脚
       return 0;
}
static ssize_t pin4_write(struct file *file,const char __user *buf,size_t count, loff_t *ppos)
{
      int userCmd;
      printk("pin4_write\n");
      copy_from_user(&userCmd,buf,count);  
   //从上层获取函数的值第一个参数是一个char类型的指针const char __user *buf,用int也行，但编译的过程中会有警告
      if(userCmd==1)
      {
         printk("set 1\n");
         *GPSET0 |=0x1<<4;    
   //置1寄存器将引脚4置1，输出高电平
      }else if(userCmd==0)
      {
      *GPCLR0 |=0x1<<4;
         printk("set 0\n");   
   //清零寄存器将引脚4清零，输出低电平
      }else
      {
         printk("undo\n");
      }
      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;
    printk("insmod driver pin4 success\n");
    devno = MKDEV(major,minor)      // 2.创建设备号 
    ret   = register_chrdev(major, module_name,&pin4_fops); 
 //3.注册驱动 告诉内核，把这个驱动加入到内核的链表中
    pin4_class=class_create(THIS_MODULE,"myfirstdemo");
 // 让代码在dev自动生成设备
    pin4_class_dev =device_create(pin4_class,NULL,devno,NULL,module_name);   
    //创建设备文件
    GPFSEL0=(volatile unsigned int *)ioremap(0x3f200000,4); 
 //第一个参数真正的物理地址，第二个参数映射的大小  一个寄存器4个字节 4*8=32bit
    GPSET0=(volatile unsigned int*)ioremap(0x3f20001c,4);                                                 
    //由于返回值是void*型需要强制转换  void __iomem * __ioremap(unsigned long phys_addr, size_t size, unsigned long flags)
    GPCLR0=(volatile unsigned int*)ioremap(0x3f200028,4);                                               
 //物理地址转换成虚拟地址
    return 0;
}
void __exit pin4_drv_exit(void)
{
   iounmap(GPFSEL0);                                                                                            
   //iounmap函数用于取消ioremap（）所做的映射
   iounmap(GPSET0);
   iounmap(GPCLR0);
   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");

上层测试文件

#include  <sys/types.h>
#include  <sys/stat.h>
#include  <fcntl.h>
#include  <stdio.h>
int main()
{
 int fd;
 int cmd; 
 fd=open("/dev/pin4",O_RDWR);
 if(fd<0)
 {
  printf("open failed\n");
  perror("reson:");
 }else
 {
  printf("open success\n");
 }
 printf("input commnd : 1/0 \n1: pin4 high\n0: pin4 low\n");
 scanf("%d",&cmd);//与驱动代码保持一致 int userCmd判断为整型1的时候拉高电平
 if(cmd==1)
 {
  write(fd,&cmd,sizeof(int));
 }
 if(cmd==0)
 {
  write(fd,&cmd,sizeof(int));
 }
}

编译和测试详见目录三