platform_bus,platform_driver,platform_bus

一、platform_bus
总线是处理器和一个或多个设备之间的通道，在设备模型中, 所有的设备都通过总线相连。总线可以相互插入。设备模型展示了总线和它们所控制的设备之间的实际连接。Platform总线是2.6 kernel中最近引入的一种虚拟总线，主要用来管理CPU的片上资源，具有更好的移植性，因此在2.6 kernel中，很多驱动都用platform改写了。
/linux/device.h
struct bus_type {  
        const char              *name;  
        struct bus_attribute    *bus_attrs;  
        struct device_attribute *dev_attrs;  
        struct driver_attribute *drv_attrs;  
  
        int (*match)(struct device *dev, struct device_driver *drv);  
        int (*uevent)(struct device *dev, struct kobj_uevent_env *env);  
        int (*probe)(struct device *dev);  
        int (*remove)(struct device *dev);  
        void (*shutdown)(struct device *dev);  
  
        int (*suspend)(struct device *dev, pm_message_t state);  
        int (*suspend_late)(struct device *dev, pm_message_t state);  
        int (*resume_early)(struct device *dev);  
        int (*resume)(struct device *dev);  
  
struct bus_type_private *p;  
};  
/drivers/base/platform.c
struct bus_type platform_bus_type = {  
.name           = "platform",  
        .dev_attrs      = platform_dev_attrs,  
        .match          = platform_match,  
        .uevent         = platform_uevent,  
        .suspend        = platform_suspend,  
        .suspend_late   = platform_suspend_late,  
        .resume_early   = platform_resume_early,  
        .resume         = platform_resume,  
};  
总线名称是"platform"，其只是bus_type的一种，定义了总线的属性，同时platform_bus_type还有相关操作方法，如挂起、中止、匹配及hotplug事件等。总线bus是联系driver和device的中间枢纽。Device通过所属的bus找到driver，由match操作方法进行匹配。


二、platform_device和device
Plarform device会有一个名字用于driver binding（在注册driver的时候会查找driver的目标设备的bus位置，这个过程称为driver binding），另外IRQ以及地址空间等资源也要给出 。platform_device结构体用来描述设备的名称、资源信息等。
/linux/platform_device.h
struct platform_device {  
        const char      * name; //定义平台设备的名称，此处设备的命名应和相应驱动程序命名一致   
  
        int             id;  
        struct device   dev;  
        u32             num_resources;  
        struct resource * resource;  //定义平台设备的资源   
};  
在这个结构里封装了struct device及struct resource。可知：platform_device由device派生而来，是一种特殊的device.下面来看一下platform_device结构体中最重要的一个成员struct resource * resource。struct resource被定义在
/include/linux /ioport.h中，定义原型如下：
struct resource {  
        resource_size_t start;  //定义资源的起始地址   
        resource_size_t end;  //定义资源的结束地址   
        const char *name; //定义资源的名称   
        unsigned long flags; 定义资源的类型，比如MEM，IO，IRQ，DMA类型  
        struct resource *parent, *sibling, *child;  
};  
这个结构表示设备所拥有的资源，即I/O端口、I/O映射内存、中断及DMA等。这里的地址指的是物理地址。另外还需要注意platform_device中的device结构，它详细描述了设备的情况，其为所有设备的基类：在/include/linux/device.h中定义了struct device结构。其中包含有所属总线，对应的驱动指针等信息。用于匹配总线上的驱动。


三、device_register和platform_device_register
/drivers/base/core.c 
int device_register(struct device *dev)  
{  
        device_initialize(dev);  
        return device_add(dev);  
}  
初始化一个设备，然后加入到总线中。 
/drivers/base/platform.c 
int platform_device_register(struct platform_device *pdev)  
{  
        device_initialize(&pdev->dev);  
        return platform_device_add(pdev);  
}   
int platform_device_add(struct platform_device *pdev)  
{  
        int i, ret = 0;    
        //初始化设备的parent为platform_bus，初始化设备的总线为platform_bus_type。  
        if (!pdev->dev.parent)  
                pdev->dev.parent = &platform_bus;    
        pdev->dev.bus = &platform_bus_type;   
        if (pdev->id != -1)  
                snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%d", pdev->name,  
                         pdev->id); 
        else  
strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);    
        //设置设备struct device 的bus_id成员，留心这个地方，在以后还需要用到这个的。  
        for (i = 0; i < pdev->num_resources; i++) {  
                struct resource *p, *r = &pdev->resource[i];    
                if (r->name == NULL)  
                        r->name = pdev->dev.bus_id;    
                p = r->parent;  
                if (!p) {  
                        if (r->flags & IORESOURCE_MEM)  
                                p = &iomem_resource;  
                        else if (r->flags & IORESOURCE_IO)  
                                p = &ioport_resource;  
                }  
                //resources分为两种IORESOURCE_MEM和IORESOURCE_IO   
                //CPU对外设IO端口物理地址的编址方式有两种：I/O映射方式和内存映射方式    
                if (p && insert_resource(p, r)) {  
                        printk(KERN_ERR  
                               "%s: failed to claim resource %d/n",  
                               pdev->dev.bus_id, i);  
                        ret = -EBUSY;  
                        goto failed;  
                }  
        }    
        ret = device_add(&pdev->dev);    
} 
我们看到注册一个platform device分为了两部分，初始化这个platform_device，然后将此platform_device添加到platform总线中。输入参数platform_device可以是静态的全局设备。另外一种机制就是动态申请platform_device_alloc一个platform_device设备，然后通过platform_device_add_resources及platform_device_add_data等添加相关资源和属性。无论哪一种platform_device，最终都将通过platform_device_add注册到platform总线上。
由platform_device_register和platform_device_add的实现可知，device_register()和platform_device_register()都会首先初始化设备，区别在于第二步：其实platform_device_add()包括device_add()，不过要先注册resources，然后将设备挂接到特定的platform总


四、device_driver和platform driver
platform driver是与platform_device对应的驱动模型，驱动编写人员只要将注册必须的数据结构化并调用注册驱动的系统函数就可以了。
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 (*suspend_late)(struct platform_device *, pm_message_t state);  
        int (*resume_early)(struct platform_device *);  
        int (*resume)(struct platform_device *);  
        struct device_driver driver;  
};  
platform_driver中包含了一个device_driver结构，可见device_driver是platform_driver的基类。
/include/linux/device.h
struct device_driver {  
        const char              *name;  
        struct bus_type         *bus;   
        struct module           *owner;  
        const char              *mod_name;      /* used for built-in modules */   
        int (*probe) (struct device *dev);  
        int (*remove) (struct device *dev);  
        void (*shutdown) (struct device *dev);  
        int (*suspend) (struct device *dev, pm_message_t state);  
        int (*resume) (struct device *dev);  
        struct attribute_group **groups;   
        struct driver_private *p;  
};  
device_driver提供了一些操作接口，但其并没有实现，相当于一些虚函数，由派生类platform_driver进行重载，无论何种类型driver都是基于device_driver派生而来的，具体的各种操作都是基于统一的基类接口的，这样就实现了面向对象的设计。需要注意这两个变量：name和owner。其作用主要是为了和相关的platform_device关联起来，owner的作用是说明模块的所有者，驱动程序中一般初始化为THIS_MODULE。device_driver结构中还有一个name变量。platform_driver从字面上来看就知道是设备驱动。内核正是通过这个一致性来为驱动程序找到资源，即 platform_device中的resource。


五、driver_register和platform_driver_register。


int platform_driver_register(struct platform_driver *drv)  
{  
        drv->driver.bus = &platform_bus_type;  
        /*设置成platform_bus_type这个很重要，因为driver和device是通过bus联系在一起的，具体在本例中是通过        platform_bus_type中注册的回调例程和属性来是实现的， driver与device的匹配就是通过 platform_bus_type注册的回调例程platform_match ()来完成的。*/   
        if (drv->probe)  
                drv->driver.probe = platform_drv_probe;  
            //在really_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);  
}  
不要被上面的platform_drv_XXX吓倒了，它们其实很简单，就是将struct device转换为struct platform_device和struct platform_driver，然后调用platform_driver中的相应接口函数。那为什么不直接调用platform_drv_XXX等接口呢？这就是Linux内核中面向对象的设计思想。
device_driver提供了一些操作接口，但其并没有实现，相当于一些虚函数，由派生类platform_driver进行重载，无论何种类型的 driver都是基于device_driver派生而来的，device_driver中具体的各种操作都是基于统一的基类接口的，这样就实现了面向对象的设计。
/drivers/base/driver.c
driver_register(struct device_driver *drv)调用            
bus_add_driver(drv) 
将驱动挂接到总线上，通过总线来驱动设备。 
如果总线上的driver是自动probe的话，则调用
driver_attach（）
将该总线上的driver和device绑定起来
int driver_attach(struct device_driver *drv)  
{  
        return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);  
}  
遍历该总线上的每一个设备，将当前driver和总线上的设备进行match，如果匹配成功，则将设备和driver绑定起来。


这一过程的具体函数调用实现为：
driver_attach->__driver_attach->driver_probe_device(drv, dev)
driver_probe_device函数调用了
driver->bus->match，具体实现为platform_match中简单的进行字符串匹配，这也是我们强调platform_device和platform_driver中的name属性需要一致的原因。 
还调用了really_probe函数，在该函数中有如下一段代码
        if (dev->bus->probe) {  
                ret = dev->bus->probe(dev);  
                if (ret)  
                        goto probe_failed;  
        } else if (drv->probe) {  
                ret = drv->probe(dev);  
                if (ret)  
                        goto probe_failed;  
        }  
如果bus和driver同时具备probe方法，则优先调用总线的probe函数。否则调用device_driver的probe函数，此probe 函数是经过各种类型的driver重载的函数，这就实现了利用基类的统一方法来实现不同的功能。对于platform_driver来说，其就是
static int platform_drv_probe(struct device *_dev)  
{  
        struct platform_driver *drv = to_platform_driver(_dev->driver);  
        struct platform_device *dev = to_platform_device(_dev);   
        return drv->probe(dev);  
}  
然后调用特定platform_driver所定义的操作方法，这个是在定义某个platform_driver时静态指定的操作接口。至此，platform_driver成功挂接到platform bus上了，并与特定的设备实现了绑定，并对设备进行了probe处理。 
platform_driver_register在经过match匹配设备和驱动后最终调用了自定义的platform_driver中的probe函数，在该函数中一般会初始化一些资源。


六、bus、device及driver三者之间的关系
在数据结构设计上，总线、设备及驱动三者相互关联。platform device包含device，根据device可以获得相应的bus及driver。
设备添加到总线上后形成一个双向循环链表，根据总线可以获得其上挂接的所有device，进而获得了 platform device。根据device也可以获得驱动该总线上所有设备的相关driver。
platform driver包含driver，根据driver可以获得相应的bus，进而获得bus上所有的device，进一步获得platform device，根据name对driver与platform device进行匹配，匹配成功后将device与相应的driver关联起来，即实现了platform device和platform driver的关联。
匹配成功后调用driver的probe进而调用platform driver的probe，在probe里实现驱动特定的功能。 


七、适用于plarform的驱动
platform机制将设备本身的资源注册进内核，由内核统一管理，在驱动程序中使用这些资源时通过platform device提供的标准接口进行申请并使用。这样提高了驱动和资源管理的独立性，这样拥有更好的可移植性。platform机制的本身使用并不复杂，由两部分组成：platform_device和platfrom_driver。Platform driver通过platform bus获取platform_device。通常情况下只要和内核本身运行依赖性不大的外围设备，相对独立的，拥有各自独立的资源(地址总线和IRQs)，都可以用 platform_driver来管理，而timer，irq等小系统之内的设备则最好不用platfrom_driver机制。platform_device最大的特定是CPU直接寻址设备的寄存器空间，即使对于其他总线设备，设备本身的寄存器无法通过CPU总线访问，但总线的controller仍然需要通过platform bus来管理。
总之，platfrom_driver的根本目的是为了统一管理系统的外设资源，为驱动程序提供统一的接口来访问系统资源，将驱动和资源分离，提高程序的可移植性。


八、基于platform总线的驱动开发流程
基于Platform总线的驱动开发流程如下：
定义初始化platform bus
定义各种platform devices
注册各种platform devices
定义相关platform driver
注册相关platform driver
操作相关设备  file_operations


九、platform_bus必须在系统注册任何platform driver和platform device之前初始化，那么这是如何实现的呢？
/init/main.c
执行顺序：start_kernel-> rest_init-> kernel_init->do_basic_setup->driver_init->platform_bus_init  
void __init driver_init(void)  
{  
        /* These are the core pieces */  
        devices_init();  
        buses_init();  
        classes_init();  
        firmware_init();  
        hypervisor_init();  
        /* These are also core pieces, but must come after the 
         * core core pieces. 
         */  
        platform_bus_init();  
        system_bus_init();  
        cpu_dev_init();  
        memory_dev_init();  
}  
static void __init do_basic_setup(void)  
{  
        /* drivers will send hotplug events */  
        init_workqueues();  
        usermodehelper_init();  
        driver_init();  
        init_irq_proc();  
        do_initcalls();  
}  
可以看出platform_bus是在driver_init中初始化的，而所有的平台设备和平台驱动的注册都是在do_initcalls中，滞后于platform_bus的初始化。platform_bus的初始化发生在
int __init platform_bus_init(void)  
{  
        int error;  
  
        error = device_register(&platform_bus);  
        if (error)  
                return error;  
        error =  bus_register(&platform_bus_type);  
        if (error)  
                device_unregister(&platform_bus);  
        return error;  
}  
struct device platform_bus = {  
        .bus_id         = "platform",  
};  
该函数创建了一个名为 “platform”的设备，后续platform的设备都会以此为parent。在sysfs中表示为：所有platform类型的设备都会添加在 platform_bus所代表的目录下，即 /sys/devices/platform下面。




十、平台设备在linux系统下的实现过程
/arch/arm/plat-s5p/devs.c
/arch/arm/plat-s3c24xx/devs.c
中定义了系统的资源，是一个高度可移植的文件，大部分板级资源都在这里集中定义
/arch/arm/plat-s3c24xx/devs.c
static struct resource s3c_i2c_resource[] = {  
        [0] = {  
                .start = S3C24XX_PA_IIC,  
                .end   = S3C24XX_PA_IIC + S3C24XX_SZ_IIC - 1,  
                .flags = IORESOURCE_MEM,  
        },  
        [1] = {  
                .start = IRQ_IIC,  
                .end   = IRQ_IIC,  
                .flags = IORESOURCE_IRQ,  
        }  
};  
  
struct platform_device s3c_device_i2c = {  
        .name             = "s3c2410-i2c",  
        .id               = -1,  
        .num_resources    = ARRAY_SIZE(s3c_i2c_resource),  
        .resource         = s3c_i2c_resource,  
};  
设备名称为s3c2410-i2c，“-1”只有一个i2c设备，两个资源s3c_i2c_resource，分别为i2c控制器的寄存器空间和中断信息。


注册platform_device
定义了platform_device后，需要添加到系统中，就可以调用函数platform_add_devices。
/arch/arm/mach-s3c2440/mach-smdk2440.c  smdk2440_devices将系统资源组织起来，统一注册进内核。
static struct platform_device *smdk2440_devices[] __initdata = {
        &s3c_device_usb,
        &s3c_device_lcd,
        &s3c_device_wdt,
        &s3c_device_i2c,
        &s3c_device_iis,
};
static void __init smdk2440_machine_init(void)
{
        s3c24xx_fb_set_platdata(&smdk2440_fb_info);


        platform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices));
        smdk_machine_init();
}
platform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices));将系统所有资源注册进系统，在此之前platform bus需要初始化成功，否则无法将platform devices挂接到platform bus上。为了保证platform driver初始化时，相关platform资源已经注册进系统,smdk2440_machine_init需要很早执行，而其作为平台初始化 init_machine 时，将优先于系统所有驱动的初始化。
其调用顺序如下：
1.平台资源的初始化
smdk2440_machine_init
2.平台总线的初始化
driver_init->platform_bus_init
3.平台设备和平台驱动的总线挂载。
do_initcalls   驱动程序的module_init加载过程在该函数中运行。这里还是以ht9032c_uart.c为例
一般情况下，当进入probe函数后，需要获取设备的资源信息，常用获取资源的函数主要是：
struct resource * platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num);
根据参数type所指定类型，例如IORESOURCE_MEM，来获取指定的资源。
struct int platform_get_irq(struct platform_device *dev, unsigned int num);
获取资源中的中断号。
struct resource * platform_get_resource_byname(struct platform_device *dev, unsigned int type, char *name);
根据参数name所指定的名称，来获取指定的资源。
int platform_get_irq_byname(struct platform_device *dev, char *name);
根据参数name所指定的名称，来获取资源中的中断号。
此probe函数获取物理IO空间，通过request_mem_region和ioremap等操作物理地址转换成内核中的虚拟地址，初始化I2C控制器，通过platform_get_irq或platform_get_resource得到设备的中断号以后，就可以调用request_irq函数来向系统注册中断，并将此I2C控制器添加到系统中。