树莓派基础之树莓派芯片导读和IO口驱动编程

一：地址

1.总线地址：
AB（全称：Address Bus，中文名：地址总线）属于一种电脑总线，是由CPU或有DMA能力的单元，用来沟通这些单元想要存取电脑内存元件/地方的实体位址。
通俗的说就是CPU能够访问内存的范围。

比如现象：装了32位win7操作系统，明明内存条8G，可是系统只识别了3.8G，当装了64位的win7操作系统才能识别到8G

32位能表示/访问4.294.967.296bit
bit=4.294.967.296
kbit=4.194.304
mbit=4.096
gbit=4

树莓派也是跑32位的操作系统，所以最高只能支持到4G的内存。
查看树莓派的内存条有多大：

cat /proc/meminfo

2.物理地址：
硬件的实际地址或绝对地址。

3.虚拟地址：
逻辑（基于算法的地址（软件层面的地址，它是个假地址）），称为虚拟地址。

基于树莓派芯片手册来理解物理地址和虚拟地址：
假如树莓派的真正内存只有1G，但是有些程序内存占用空间超过了一个G，这个时候怎么办呢？
虚拟地址可以把物理地址1G映射成4G，让程序在虚拟地址上跑

查看树莓派CPU型号：

cat /proc/cpuinfo

BCM2835 是树莓派3b cpu的型号，它是ARM-cotexA53架构

二：驱动两大利器：电路图和芯片手册

电路图：通过电路图找到寄存器
芯片手册：进行编写

BCM2835芯片手册

这个手册不用去细看，做到哪个板块的开发就看哪个板块的，比如串口板块开发看串口。。。

1.芯片手册第六章：树莓派寄存器的介绍
这些寄存器都是管理GPIO的

address：总线地址
description：功能介绍
Field Name：寄存器名字

GPFSEL0 GPIO Function Select 0  //功能选择 输入/输出
GPSET0 GPIO Pin Output Set 0  //输出0

GPSET1  GPIO Pin Output Set 0  //输出1
0 = No effect
1 = Set GPIO pin n

GPCLR0  GPIO Pin Output Clear 0  //清0
0 = No effect
1 = Clear GPIO pin n

GPCLR1 GPIO Pin Output Clear 1 //清1

2.每个寄存器都是32位的，每3个位为一组配置某个I/O口
寄存器第0组位FESL0–9
寄存器第1组位FSEL10–19

例如：我们把引脚4配置为输出引脚
FSEL4 14-12 001 我们把4引脚的14-12配置成001 GPIO Pin 4 is an output

注意：我们配置的底层引脚对应得是BCM

具体的引脚也可通过官方手册查找：

树莓派引脚

3.寄存器的地址问题：
我们在编写驱动程序的时候，IO空间的起始地址是0x3f000000,加上GPIO的偏移量0x2000000,所以GPIO的物理地址应该是0x3f200000开始的，然后在这个基础上进行Linux系统的MMU内存虚拟化管理，映射到虚拟地址上。

该图的尾部偏移是对的根据GPIO的物理地址0x3f200000可以知道：
GPFSEL0 0x3f200000
GPSET0 0x3f20001c
GPCLR0 0x3f200028

这里我们得到的是物理地址是不可操作的，我们需要转化成虚拟地址，通过函数：

void __iomem * __ioremap(unsigned long phys_addr, size_t size, unsigned long flags);

ioremap宏定义在asm/io.h内：

#define ioremap(cookie,size)           __ioremap(cookie,size,0)

参数：
phys_addr：要映射的起始的IO地址
size：要映射的空间的大小
flags：要映射的IO空间和权限有关的标志
该函数返回映射后的内核虚拟地址(3G-4G). 接着便可以通过读写该返回的内核虚拟地址去访问之这段I/O内存资源。

三：I/O操控代码编程

1.

#include    //file_operations声明
#include     //module_init  module_exit声明
#include       //__init  __exit 宏定义声明
#include   //class  devise声明
#include    //copy_from_user 的头文件
#include      //设备号  dev_t 类型声明
#include           //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";   //模块名

volatile unsigned int *GPFSEL0 = NULL;
volatile unsigned int *GPSET0  = NULL;
volatile unsigned int *GPCLR0  = NULL;

//led_open函数
static int pin4_open(struct inode *inode,struct file *file)
{
   printk("pin4_open\n");  //内核的打印函数和printf类似
   //配置pin4引脚位输出引脚，bit 12--14 配置成001
   *GPFSEL0 &= ~(0x6 << 12);//把bit14 bit13配置成0
   *GPFSEL0 |= (0x1 << 12); 
   return 0;
}

//led_write函数
static ssize_t pin4_write(struct file *file,const char __user *buf,size_t count, loff_t *ppos)
{
   int userCmd;
   printk("pin4_write\n");
   //获取上层write函数的值
   copy_from_user(&userCmd,buf,count);
   //根据值来操作io口，高电平或者低电平
   if(userCmd == 1){
      printk("set 1\n");
      *GPSET0 |= 0x1 << 4;       
   }else if(userCmd == 0){
      printk("set 0\n");
      *GPCLR0 |= 0x1 << 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)   
{
    printk("insmod drive pin4 success\n");
    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);  //创建设备文件
    
    GPFSEL0 = (volatile unsigned int*)ioremap(0x3f200000,4); //物理地址转换位虚拟地址，io口寄存器映射成普通内存单元访问
    GPSET0  = (volatile unsigned int*)ioremap(0x3f20001c,4);
    GPCLR0  = (volatile unsigned int*)ioremap(0x3f200028,4);
    
    return 0;
}

void __exit pin4_drv_exit(void)
{
  iounmap(GPFSEL0);
  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");

注意：
volatile : 指令不会因为编译器的优化而省略，且要求每次直接读值。
按位与：0&0 = 0，0&1 = 0，1&0 = 0，1&1 = 1
按位或：0|0 = 0，1|0 = 1，0|1 = 1，1|1 =1

2.应用层代码：

#include 
#include 
#include 
int main()
{
        int fd;
        int cmd;
        int data;

        fd=open("/dev/pin4",O_RDWR);
        if(fd < 0){
           printf("open failed\n");
           perror("reson:");
        }else{
           printf("open success\n");
        }

        printf("input commnd : 0/1 \n 1:set pin4 high\n 0:set pin4 low\n");
        scanf("%d",&cmd);

        if(cmd == 1){
           data = 1;
        }
        if(cmd == 0){
           data = 0;
        }

        printf("data = %d\n",data);
        fd = write(fd,&data,1);
        return 0;
}

3.驱动代码进行模块化编译：

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

驱动代码的加载有两种：
第一种是直接写到内核，需要重新启动内核才能实现
第二种是把驱动代码编译成模块.ko文件，然后加载到现有的内核中就可以实现
显然第二种更加方便

4.把编译好的驱动模块文件和交叉编译的测试文件远程拷贝到树莓派：

5.把驱动模块文件加载进树莓派内核：

sudo insmod pin4driver2.ko

dmesg

查看内核打印状态，转载成功：

6：运行测试代码之前，想要给驱动代码文件加一个权限：

sudo chmod 666 /dev/pin4

上层运运行测试代码：

底层看到内核打印的信息：

然后再看到树莓派的pin4引脚信息：

这样我们就实现了一个简单的驱动了。