9.驱动程序分层分离概念--总线驱动设备模型

参考：linux-platform机制实现驱动层分离(详解)

 　　  platform驱动分离

本节目标：

　　学习platform机制，如何实现驱动层分离

---

1、回顾一下上一节的输入子系统

如上图，在输入子系统中，我们通过分层及通过核心层向设备驱动层，事件处理层提供各种接口，使各层都能专注于自己的事情。

对于设备驱动层，我们会硬件相关的抽象出来，构造一个input_dev结构体，对于事件处理层，会把纯软件的比较稳定的东西抽象出来。

有了分层之后，APP就可以保持稳定·，我们只需要关心驱动层的硬件操作，注册了之后，就可以直接使用了。

同样得，我们也可以将设备驱动层中，硬件相关的易变的数据与稳定算法（改动小）的两部分分离开来。

那我们如何实现设备驱动的分离？接下来就介绍platform机制及分离的概念

2.分离的概念

　分离就是在驱动层中使用platform机制把硬件相关的代码(固定的,如板子的网卡、中断地址)和驱动(会根据程序作变动,如点哪一个灯)分离开来，

　即要编写两个文件:dev.c和drv.c(platform设备和platform驱动)

• 把硬件相关的东西抽出来，即可变的数据，具体体现在设备的差异。
• 把相对稳定的东西也抽出来，即稳定的算法，控制逻辑，可以理解成总线协议（如I2C）

　优点：

• 将所有设备挂接到一个虚拟的总线上,方便sysfs节点和设备电源的管理
• 使得驱动代码,具有更好的扩展性和跨平台性，就不会因为新的平台而再次编写驱动

3.Platform 机制　　

　platform会存在/sys/bus/里面

　如下图所示, platform目录下会有两个文件,分别就是platform设备和platform驱动

   

　

　1) device设备

　　挂接在platform总线下的设备, 使用结构体platform_device描述

　2) driver驱动

　　挂接在platform总线下,是个与某种设备相对于的驱动, 使用结构体platform_driver描述

　3) platform总线

　　是个全局变量,为platform_bus_type,属于虚拟设备总线,通过这个总线将设备和驱动联系起来,属于Linux中bus的一种

　 以下依次介绍其数据结构：

 1）设备描述—platform_device

• platform_device_register 注册设备文件,匹配后会调用驱动算法的probe
• platform_device_unregister卸载设备
• 具体数据描述如下

struct platform_device {
    const char  * name;  //设备名称,要与platform_driver的name一样,这样总线才能匹配成功
    u32             id;  //插入总线下相同name的设备编号(一个驱动可以有多个设备),如果只有一个设备填-1
    struct device   dev; //具体的device结构体
                         //成员platform_data可以给平台driver提供各种数据(比如:GPIO引脚等等)
    u32    num_resources;//资源数目
    struct resource    * resource;//资源描述,用来描述io,内存等
};

//资源文件 ,定义在includelinuxioport.h
struct resource {
    resource_size_t start;  //起始资源,如果是地址的话,必须是物理地址
    resource_size_t end;    //结束资源,如果是地址的话,必须是物理地址
    const char *name;       //资源名
    unsigned long flags;    //资源类型,可以是io/irq/mem等
    struct resource *parent, *sibling, *child;    //链表结构,可以构成链表
};
// type
#define IORESOURCE_IO         0x00000100    /* Resource type */
#define IORESOURCE_MEM        0x00000200
#define IORESOURCE_IRQ        0x00000400
#define IORESOURCE_DMA        0x00000800

 2）.驱动算法—platform_driver

 　　这里将其称为驱动算法,其实也是一个正常的驱动程序,区别在于可以获取到上面注册的设备文件信息.

　　当注册设备文件或者注册驱动文件的时候,都会调用驱动算法的 probe.

• platform_driver_register用来注册驱动,当注册设备文件或者注册驱动文件的时候,都会调用驱动算法的probe.
• platform_driver_unregister用来卸载驱动

• platform框架中的管理结构如下:

//driver
struct platform_driver {
    //函数
    (*probe)        //匹配到设备文件的name与driver中的name一致将会在注册时执行
    (*remove)       //卸载驱动出口,卸载驱动设备的时候应该也会调用
    (*shutdown)
    (*suspend)
    (*suspend_late)
    (*resume_early)
    (*resume)
    //结构体
    struct device_driver driver
    {
        .name        //用作匹配
    }
};

• probe,当有设备文件和驱动算法匹配的时候自动执行,一般用来获取资源文件信息等,注册驱动,ioremap等,可以理解为执行驱动的第一个程序
• 总线在匹配设备和驱动之后驱动要考虑一个这样的问题，设备对应的软件数据结构代表着静态的信息，真实的物理设备此时是否正常还不一定，因此驱动需要探测这个设备是否正常。我们称这个行为为probe，至于如何探测，那是驱动才知道干的事情，总线只管吩咐（摘自：嵌入式企鹅圈）

• Driver->probe()

  I.探测设备是否正常

  II.cdev_add(struct file_operations)注册操作接口

  III. device_create()创建设备文件

 注意：

1. 这里的platform_driver也是一个普通的驱动,可以用最原始的方式来注册驱动,创建class类,再在下面添加具体的设备文件来使用mdev机制自动创建所需要的文件.
2. 也可以使用输入子系统的 框架,输入子系统所需要的驱动程序需要一套约定的接口,我们可以将输入子系统中的左侧的设备驱动再分割成设备描述与驱动算法.

 3）Platform 总线

　　 platform_bus_type的结构体定义如下所示(位于drivers/base):

struct bus_type platform_bus_type = {              
.name              = "platform",        //设备名称
.dev_attrs        = platform_dev_attrs, //设备属性、含获取sys文件名,该总线会放在/sys/bus下
.match              = platform_match,   //匹配设备和驱动,匹配成功就调用driver的.probe函数
.uevent             = platform_uevent,  //消息传递,比如热插拔操作
.suspend         = platform_suspend,     //电源管理的低功耗挂起
.suspend_late          = platform_suspend_late,  
.resume_early         = platform_resume_early,
.resume           = platform_resume,　　　　//恢复
};

驱动、设备注册匹配图如下所示:

只要有一方注册,就会调用platform_bus_type的.match匹配函数,来找对方,成功就调用driver驱动结构体里的.probe函数来使总线将设备和驱动联系起来

 注册机制（drivers/base/Platform.c）

　　1.device 使用 platform_device_register 注册

int platform_device_register(struct platform_device * pdev)
{
    device_initialize(&pdev->dev);  //初始化
    return platform_device_add(pdev);  
}　  //最终会进入device_add(&pdev->dev)，放入平台总线的设备链表中

　　

　　2.驱动算法使用platform_driver_register来注册,如下:

int platform_driver_register(struct platform_driver *drv)
{
   drv->driver.bus = &platform_bus_type;   //(1)挂接到虚拟总线platform_bus_type上
   if (drv->probe)
         drv->driver.probe = platform_drv_probe;
   if (drv->remove)
        drv->driver.remove = platform_drv_remove;
   if (drv->shutdown)
        drv->driver.shutdown = platform_drv_shutdown;
   if (drv->suspend)
        drv->driver.suspend = platform_drv_suspend;
    if (drv->resume)
        drv->driver.resume = platform_drv_resume;

   return driver_register(&drv->driver);      //(2) 注册到driver目录下,创建/sys/bus/platform/driver
}　　

　

　　1）. 从代码上看,platform只是只是bus中的一种,挂载到platform_bus_type　　　　

struct bus_type platform_bus_type = {              
    .nam            = "platform",           //设备名称
    .dev_attrs        = platform_dev_attrs,   //设备属性、含获取sys文件名,该总线会放在/sys/bus下
    .match            = platform_match,       //匹配函数,成功调用driver的.probe函数
    .uevent            = platform_uevent,      //消息传递,比如热插拔操作
    .suspend        = platform_suspend,     //电源管理的低功耗挂起
    .suspend_late    = platform_suspend_late,  
    .resume_early    = platform_resume_early,
    .resume            = platform_resume,　　　//恢复
};

　

  　2）. 可以看到匹配函数match=platform_match,是匹配dev和driver的name

static int platform_match(struct device * dev, struct device_driver * drv)
{
    /*找到所有的device设备*/
    struct platform_device *pdev = container_of(dev, struct platform_device, dev);
    return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
}

 4. 使用platform机制,编写LED驱动层

　　首先创建设备代码和驱动代码:led_dev.c 、led_drv.c

　　led_dev.c用来指定灯的引脚地址,当更换平台时,只需要修改这个就行

　　led_drv.c用来初始化灯以及如何控制灯的逻辑,当更换控制逻辑时,只需要修改这个就行    

 4.1 led_dev.c

　　1）先写要注册的led设备:platform_device结构体

　　2）完成结构体中的函数

　　3）入口出口函数

/* 分配/设置/注册一个platform_device */
#include <linux/module.h>
#include <linux/version.h>

#include <linux/init.h>

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>



/* 可以在resource中更改寄存器与引脚 */
static struct resource led_resource[] = {    //资源数组
    [0] = {
        .start = 0x56000050,    //led寄存器GPFCON的起始地址
        .end   = 0x56000050 + 8 - 1,   //led寄存器GPFDAT的结束地址--为什么减1
        .flags = IORESOURCE_MEM, //表示地址资源
    },

    [1] = {
        .start = 5,        //表示GPF从第几个引脚开始
        .end   = 5,        //结束引脚
        .flags = IORESOURCE_IRQ,  //表示中断资源
    }

};

static void led_release(struct device * dev)       //释放函数
{}


/* 1)先写要注册的led设备:platform_device结构体 */
static struct platform_device led_dev = {
    .name          = "myled",                    //对应的platform_driver驱动的名字
    .id              = -1,                         //表示只有一个设备
    .num_resources  = ARRAY_SIZE(led_resource),   //资源数量,ARRAY_SIZE()函数:获取数量
    .resource      = led_resource,      //资源数组led_resource
    .dev = {
    .release = led_release,             //释放函数，必须向内核提供一个release函数, 、
                                       //否则卸载时,内核找不到该函数会报错
       },
};


static int  led_dev_init(void) //入口函数，注册dev设备
{
    platform_device_register(&led_dev);
    return 0;
}

static void  led_dev_exit(void) //出口函数，卸载dev设备
{
    platform_device_unregister(&led_dev);
}


module_init(led_dev_init); //修饰入口函数
module_exit(led_dev_exit); //修饰出口函数

MODULE_LICENSE("GPL");       //声明函数

4.2 led_drv.c

　　1）先写要注册的led驱动:platform_driver结构体

　　2）写file_operations 结构体、以及成员函数(.open、.write)、.probe函数、

　　　  当驱动和设备都insmod加载后,然后bus总线会匹配成功,就进入.probe函数,

　　　  在.probe函数中便使用platform_get_resource()函数获取LED的地址和引脚,然后初始化LED,并注册字符设备和设备节点"led"

/* 分配/设置/注册一个platform_driver */
#include <linux/module.h>
#include <linux/version.h>

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>

static int major;

static struct class *cls;
static volatile unsigned long *gpio_con;
static volatile unsigned long *gpio_dat;
static int pin;

static int led_open(struct inode *inode, struct file *file)
{
    //printk("first_drv_open
");
    /* 配置为输出引脚 */
    *gpio_con &= ~(0x3<<(pin*2));
    *gpio_con |=  (0x1<<(pin*2));
    return 0; 
}

static ssize_t led_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    int val;
    /*获取用户传进来的值*/
    copy_from_user(&val, buf, count);

    if (val == 1)
    {
        //点灯
        *gpio_dat &= ~(1<<pin);
    }
    else
    {
        //灭灯
        *gpio_dat |= (1<<pin);
    }
    
    return 0;
}

static struct file_operations led_fops = {
    .owner = THIS_MODULE,  /* 宏，指向编译模块时自动创建的_this_moudle变量 */
    .open  = led_open,
    .write = led_write,
};

/* probe实现的功能完全可以自定 */
static int  led_probe(struct platform_device *pdev)
{
    struct resource        *res;
    /* 根据platform_device的资源进行ioremap */
    /* 获取寄存器资源 */
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);  //获取寄存器地址
    gpio_con = ioremap(res->start, res->end - res->start + 1); //起始地址，映射大小->获取虚拟地址
    gpio_dat = gpio_con + 1; //指针加1 = 地址加4，指向另一个寄存器

    /* 获取引脚资源 */
    res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);  //获取寄存器地址
    pin = res->start;

    /* 注册字符设备驱动程序 */
    printk("led_probe, found led
");

    major = register_chrdev( 0, "myled", &led_fops);     //注册告诉内核，注册后返回主设备号

    cls = class_create(THIS_MODULE, "myled");
    class_device_create(cls, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led */

    return 0;
}

static int led_remove(struct platform_device *pdev)
{
    /* 卸载字符设备驱动程序 */
    /* */
    printk("remove ok!
");
    /* 与上面反着来 */
    class_device_destroy(cls, MKDEV(major, 0));
    class_destroy( cls);
    unregister_chrdev(major, "myled");
    iounmap(gpio_con);
}

struct platform_driver led_drv = {
    .probe        = led_probe,      //当与设备匹配，调用此函数
    .remove        = led_remove, //删除设备
    .driver        = {
        .name    = "myled",    //名字相同才匹配
    }
};


static int  led_drv_init(void) //入口函数，注册dev设备
{
    platform_driver_register(&led_drv);
    return 0;
}

static void  led_drv_exit(void) //出口函数，卸载dev设备
{
    platform_driver_unregister(&led_drv);
}


module_init(led_drv_init); //修饰入口函数
module_exit(led_drv_exit); //修饰出口函数

MODULE_LICENSE("GPL");       //声明函数

4.3 led_test.c

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

/* leddrvtest on
  * leddrvtest off
  */
int main(int argc, char **argv)
{
    int fd;
    int val = 1;
    fd = open("/dev/led", O_RDWR);
    if (fd < 0)
    {
        printf("can't open!
");
    }
    if (argc != 2)
    {
        printf("Usage :
");
        printf("%s <on|off>
", argv[0]);
        return 0;
    }

    if (strcmp(argv[1], "on") == 0)
    {
        val  = 1;
    }
    else
    {
        val = 0;
    }
    
    write(fd, &val, 4);
    return 0;
}

1. 注册两个驱动,会自动生成文件/sys/bus/platform/下的devices和drives生成驱动
2. 测试使用./led_test on点灯, 使用 ./led_test  off 关灯