44 linux内核里的platform设备驱动模型

内核里的设备驱动模型分成三部分： bus(struct bus_type), device(struct device), driver(struct device_driver)

我们最常用的设备驱动模型是基于上面的模型封装出来的，叫platform驱动模型，也是分成三部分：
platform_bus_type(struct bus_type) , 内核里已实现好这个总线，并且总线匹配函数也写好的。
platform_device(基于struct device结构体扩展而来, device在platform_devices结构体里就是一个成员)
platform_driver(基于device_driver扩展而来)

/
platform总线,已在linux内核里实现好相关功能:
“drivers/base/platform.c”

 824 struct bus_type platform_bus_type = {
 825     .name       = "platform",
 826     .dev_attrs  = platform_dev_attrs,
 827     .match      = platform_match, //匹配函数
 828     .uevent     = platform_uevent,
 829     .pm     = &platform_dev_pm_ops,
 830 };  
 831 EXPORT_SYMBOL_GPL(platform_bus_type);

 656 static int platform_match(struct device *dev, struct device_driver *drv)
 657 {
 658     struct platform_device *pdev = to_platform_device(dev); //通过dev的地址获取platform_device对象的首地址
 659     struct platform_driver *pdrv = to_platform_driver(drv);
 660 
 661     
 662     if (of_driver_match_device(dev, drv)) //使用device_driver里的of_match_table数组来匹配设备名.(目录内核里基本不用)
 663         return 1; //匹配成功直接返回, 匹配失败则接着往后执行.
 664 
 665     
 666     if (pdrv->id_table) //如果platform_driver对象有设置id_table成员，则用id_table里指定的设备名来与设备进行匹配. 按名字(字符串)比较来匹配.
 667         return platform_match_id(pdrv->id_table, pdev) != NULL; 
 668 
 669    
 670     return (strcmp(pdev->name, drv->name) == 0); //如果platform_driver没有设置id_table成员的值，则使用platform_device对象的名字与device_driver对象的名字进行匹配
 671 }

///
平台设备, struct platform_device每个对象表示一个具体的硬件， 用于提供硬件相关的资源

#include <linux/platform_device.h>

struct platform_device {
        const char      * name;  //设备名字可以重复. 
        int             id;   //设备的id. 注册时dev.init_name=name.id   
        struct device   dev; //平台设备其于原device类型上封装出来的, dev.platform_data也可以提供信息给设备驱动.  设备驱动里可以使用platform_set_drvdata(pdev, data)设置针对此设备的数据. platform_get_drvdata(pdev)获取挂载的数据

        u32             num_resources; //数组元素个数
        struct resource * resource;   //数组首地址, 用于提供信息给设备驱动(中断号, IO口，寄存器地址)
                     //当注册设备时，系统会检查这里设置的资源，独占使用这些资源.
    ...
    const struct platform_device_id *id_entry; //指向platform_driver里的id_table数组里匹配上的元素的地址
};



extern int platform_device_register(struct platform_device *pdev); //注册平台设备,注册时会指定pdev->dev.bus为平台总线的地址. 设置pdev->dev.init_name.
extern void platform_device_unregister(struct platform_device *); //反注册平台设备

//在设备驱动里获取指定的资源的函数:
struct resource *platform_get_resource(struct platform_device *dev,
                       unsigned int type, unsigned int num)  // type用于指定资源类型, num为指定类型的资源里的第几个.
 如: platform_get_resource(pdev, IORESOURCE_IO, 2); //获取pdev平台设备的关于io口的第2个资源
int platform_get_irq(struct platform_device *dev, unsigned int num) //用于在设备驱动里获取设备提供的第num个中断号资源

/

//////// platform_device 里的资源 /////////////////////////////
include <linux/ioport.h>

 18 struct resource {
 19     resource_size_t start;
 20     resource_size_t end;
 21     const char *name;
 22     unsigned long flags; //表示资源的类型（有中断号， IO口，DMA通道号,  内存地址...）
 23     struct resource *parent, *sibling, *child;
 24 };

 31 #define IORESOURCE_TYPE_BITS    0x00001f00  /* Resource type */
 32 #define IORESOURCE_IO       0x00000100  //表示io口的资源
 33 #define IORESOURCE_MEM      0x00000200  //表示内存地址
 34 #define IORESOURCE_IRQ      0x00000400   //中断号
 35 #define IORESOURCE_DMA      0x00000800   // DMA通道号
 36 #define IORESOURCE_BUS      0x00001000   //总线号

当资源个数与用到多种类型时，可以直接使用下面函数获取指定类型下的第几个资源.
  60 struct resource *platform_get_resource(struct platform_device *dev,
                          unsigned int type, unsigned int num)
  61 {
  62     int i;
  63 
  64     for (i = 0; i < dev->num_resources; i++) {
  65         struct resource *r = &dev->resource[i];
  66 
  67         if (type == resource_type(r) && num-- == 0)
  68             return r;
  69     }
  70     return NULL;
  71 }

/
平台设备驱动, 每个struct platform_driver对象表示一个驱动方法.

struct platform_driver {
        int (*probe)(struct platform_device *); //与匹配上的平台设备进行初始化
        int (*remove)(struct platform_device *); //匹配上的平台设备移除时触发调用, 用于设备结束驱动工作的事性

    //电源管理部分触发调用
    void (*shutdown)(struct platform_device *);
        int (*suspend)(struct platform_device *, pm_message_t state);
        int (*resume)(struct platform_device *);

        struct device_driver driver; //其于原device_driver上封装出来的
        const struct platform_device_id *id_table; //一个数组用于指定哪些设备的名字可以与此设备驱动匹配上
    /*     struct platform_device_id { 
            char name[PLATFORM_NAME_SIZE]; //名字
            kernel_ulong_t driver_data; //当设备与此项的内容匹配上时，设备驱动可用driver_data里的数据对匹配的设备作针对性的初始化工作. 
                __attribute__((aligned(sizeof(kernel_ulong_t)))); //对齐作用
        };
    */

};

注意device_driver里也有probe,remove函数指针，但它与platform_driver的probe, remove函数原型不一样。device_driver里函数原型的参数为”struct device “, platform_driver的函数原型的参数为”struct platform_device “.

extern int platform_driver_register(struct platform_driver *); //注册平台设备驱动
extern void platform_driver_unregister(struct platform_driver *); //反注册平台设备驱动

linux内核里的驱动模型只是bus, device, device_driver这三者. 当platform_device对象注册时，是仅仅把平台设备对象中的dev成员注册而已。当platform_driver对象注册时，也是仅仅把对象里的driver成员注册. 都可以通过成员的地址获取出对象的首地址. platform_driver是基于device_driver扩展而来, 当总线匹配上时， 应是先触发device_driver的probe函数. 那又怎样触发调用platform_driver的probe函数?

1 当注册平台设备驱动时:

    int platform_driver_register(struct platform_driver *drv)
    {
        drv->driver.bus = &platform_bus_type; //指定属于平台总线
        if (drv->probe) 
        drv->driver.probe = platform_drv_probe; //当平台设备驱动有probe函数时, device_driver成员设置probe函数为"platform_drv_probe"函数
        if (drv->remove)
        drv->driver.remove = platform_drv_remove;
        if (drv->shutdown)
        drv->driver.shutdown = platform_drv_shutdown;

        return driver_register(&drv->driver);
    }

2 当有设备与设备驱动匹配上时, platform_drv_probe函数就会被触发调用.

    static int platform_drv_probe(struct device *_dev)
    {
        struct platform_driver *drv = to_platform_driver(_dev->driver); //_dev->driver是platform_driver对象里的driver成员的地址。然后根据此成员的地址获取出整个platform_driver对象的首地址.
        struct platform_device *dev = to_platform_device(_dev); //根据platform_device里的dev 成员的地址获取出整个platform_device对象的首地址

        return drv->probe(dev); //调用platform_driver对象里的probe函数，并传递platform_device对象的地址.
    }

///
一个简单的测试例子:
mypdev.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>


struct platform_device mydev = {
    .name = "distancer",
    .id = 0,
    .dev = {
        .platform_data = NULL,
    },
    .resource = NULL,
};

//生成初始化函数和卸载函数，并用module_init, module_exit指定相应的函数
module_driver(mydev, platform_device_register, platform_device_unregister);

MODULE_LICENSE("GPL");

///
mypdrv.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/fs.h>

int myprobe(struct platform_device *pdev)
{
    printk("in myprobe : %s.%d, driver_data=%p\n", pdev->name, pdev->id, pdev->id_entry->driver_data);
    return 0;
}

int myremove(struct platform_device *pdev)
{
    printk("in myremove : %s.%d, driver_data=%p\n", pdev->name, pdev->id, pdev->id_entry->driver_data);
    return 0;
}

struct platform_device_id ids[] = {
    {"mykey", 0x11},
    {"myir",  0x22},
    {"distancer", 0x33},
    {}, //最后必须给一个空的元素,标明是最后一个
};  

struct platform_driver mypdrv = {
    .probe = myprobe,
    .remove = myremove, 

    .driver = {
        .owner = THIS_MODULE,
        .name = "mydrv",    
    },
    .id_table = ids,
};

module_platform_driver(mypdrv);

MODULE_LICENSE("GPL");