platform

1. 作者yuanlulu httpblogcsdnnetyuanlulu版权没有但是转载请保留此段声明
2. 第1章platform驱动管理机制
1. platform_device
1. 数据结构
2. 注册流程
2. platform_driver
3. platform使用例子
1. lpc32xx的i2c
2. platform驱动的使用总结
4. Linux资源树

============================================
作者：yuanlulu
http://blog.csdn.net/yuanlulu

版权没有，但是转载请保留此段声明
============================================

第1章platform驱动管理机制

Linux2.6内核引入了一套新的驱动管理机制：Platform_device 和 Platform_driver 。设备用Platform_device表示，驱动用Platform_driver 表示，另外设备描述了使用的资源，驱动则负责电源管理和使用资源。由于驱动和资源之间的独立，使得程序的可移植性和可扩展性大大增强。

1.1     platform_device

1.1.1  数据结构

plarform设备用platform_device来表示，如程序清单1.1所示。

程序清单1.1 platform_device

/* include/linux/platform_device.h */

struct platform_device {

constchar           *name;                                                                                                                               ①

int                        id;                                                                                                                                      
②

structdevice        dev;                                                                                                                                   
③

u32                     num_resources;                                                                                                                  ④

structresource     * resource;                                                                                                                          ⑤

};

各个成员的解释如下：

①name指向设备的名字字符串，这个名字用来和同名的platform_driver进行匹配。

②id是设备编号（如果有多个同类设备的话），如果只有一个则需设为-1。

③设备模型用到的成员。

④使用到的资源的数量。

⑤资源数组头地址。

最后一个成员resource指向此设备用到的资源的数组，struct resource的定义如程序清单1.2所示。

程序清单1.2 struct resource

/* include/linux/ioport.h */

struct resource {

resource_size_t          start;                                                                                                                          ①

resource_size_t          end;                                                                                                                           ②

constchar                   *name;                                                                                                                      ③

unsignedlong             flags;                                                                                                                         ④

structresource            *parent, *sibling,*child;                                                                                           ⑤

};

#define IORESOURCE_BITS                                    0x000000ff                  /*Bus-specific bits */

#define IORESOURCE_IO                                       0x00000100        /* Resource type */

#define IORESOURCE_MEM                                  0x00000200

#define IORESOURCE_IRQ                                     0x00000400

#define IORESOURCE_DMA                                  0x00000800

#define IORESOURCE_PREFETCH                       0x00001000        /* No side effects */

#define IORESOURCE_READONLY                     0x00002000

#define IORESOURCE_CACHEABLE                   0x00004000

#define IORESOURCE_RANGELENGTH             0x00008000

#define IORESOURCE_SHADOWABLE               0x00010000

#define IORESOURCE_SIZEALIGN                      0x00020000        /* size indicates alignment */

#define IORESOURCE_STARTALIGN                   0x00040000        /* start field is alignment */

#define IORESOURCE_DISABLED                       0x10000000

#define IORESOURCE_UNSET                              0x20000000

#define IORESOURCE_AUTO                                0x40000000

#define IORESOURCE_BUSY                                0x80000000        /* Driver has marked this resource busy*/

各个成员的解释如下：

①start记录资源范围的起始值，比如一段内存空间的首地址。

②end记录资源范围的结束位置。

③name资源的名字。

④flags用来记录资源类型以及是否可写、忙碌等信息，各位的定义如程序清单1.2所示。

⑤分别记录资源树的父节点、兄弟节点和子节点。

1.1.2  注册流程

注册platform_device有两个接口platform_add_devices和platform_device_register，它们的代码如所示。

程序清单1.3 platform_device注册接口

/* drivers/base/platform.c */

int platform_add_devices(struct platform_device**devs, int num)

{

int i,ret = 0;

for (i =0; i < num; i++) {

ret= platform_device_register(devs[i]);

if(ret) {

while(--i >= 0)

platform_device_unregister(devs[i]);

break;

}

}

returnret;

}

int platform_device_register(struct platform_device*pdev)

{

device_initialize(&pdev->dev);

returnplatform_device_add(pdev);

}

platform_add_devices注册多个设备，循环调用了platform_device_register。platform_device_register只有两步，第一步初始化platform_device的dev成员，接下来调用platform_device_add函数，它的实现如程序清单1.4所示。

程序清单1.4 platform_device_add

/* drivers/base/platform.c */

int platform_device_add(struct platform_device *pdev)

{

int i,ret = 0;

if(!pdev)

return-EINVAL;

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);

for (i =0; i < pdev->num_resources; i++) {                                                                                                  ③

structresource *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;

elseif (r->flags & IORESOURCE_IO)

p= &ioport_resource;

}

if(p && insert_resource(p, r)) {                                                                                                           ⑤

printk(KERN_ERR

"%s: failed to claim resource%d/n",

pdev->dev.bus_id, i);

ret= -EBUSY;

gotofailed;

}

}

pr_debug("Registeringplatform device '%s'. Parent at %s/n",

pdev->dev.bus_id,pdev->dev.parent->bus_id);

ret =device_add(&pdev->dev);                                                                                                                     ⑥

if (ret== 0)

returnret;

failed:

while(--i >= 0)

if(pdev->resource[i].flags & (IORESOURCE_MEM|IORESOURCE_IO))

release_resource(&pdev->resource[i]);

returnret;

}

代码的解释如下：

①处初始化设备的父设备和总线类型。

②处填写该设备在设备模型中的名字：如果编号不为-1则名字为设备名加编号，否则只包含设备名。

③处循环处理设备的每一个资源。

④如果父资源指针为空，则为IO端口和IO内存设置默认的父资源节点。这里看到，中断资源和DMA资源并不设置父节点，因为内核没有为这两类资源建立资源树，它们的使用情况使用另外的方式记录。

⑤如果有父资源节点，则将资源注册进内核资源树（仅仅针对IO端口和IO内存）。

⑥将本设备注册进内核的驱动模型中。

1.2     platform_driver

platform驱动用platform_driver来表示，它的定义如程序清单1.5所示。

程序清单1.5 platform_driver

/* include/linux/platform_device.h */

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 *);

structpm_ext_ops *pm;

structdevice_driver driver;

};

platform_driver的各个成员主要用来进行电源管理。其成员driver.name用来匹配支持的设备，它支持的platfirm_device必须使用这个名字。当有platform_device和该驱动名字匹配时，probe成员会被调用，传入匹配的设备指针。解除绑定时remove被调用。

platform_driver的注册较为简单，如程序清单1.6所示。

程序清单1.6 platform_driver_register

/* drivers/base/platform.c */

int platform_driver_register(struct platform_driver*drv)

{

drv->driver.bus= &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;

if(drv->pm)

drv->driver.pm= &drv->pm->base;

returndriver_register(&drv->driver);

}

注册过程就是将platform_driver的成员函数赋给driver成员的成员函数指针，然后注册进设备模型。

1.3     platform使用例子

1.3.1  lpc32xx的i2c

platform提供了设备的资源视图，可以比较集中的管理资源的使用。在Linux内核硬件相关的文件当中，Linux使用platform机制定义了很多驱动使用的资源，可以在一个文件中看到多个驱动的资源分配情况，有利于资源的规划和分配。对于smartarm3250来说，这个文件是arch/arm/mach-lpc32xx/arch-lpc32xx.c，这个文件定义了看门狗、rtc、i2c、spi等各种总线/设备用到的资源，定义了这些模块的驱动platform_device，对于i2c的定义如程序清单1.7所示。

程序清单1.7 i2c的platform_device

/* arch/arm/mach-lpc32xx/arch-lpc32xx.c */

#if defined (CONFIG_MACH_LPC32XX_I2C0_ENABLE)

static struct i2c_pnx_algo_data lpc32xx_algo_data0 = {

.base =I2C1_BASE,

.irq =IRQ_I2C_1,

};

static struct i2c_adapter lpc32xx_adapter0 = {

.name =I2C_CHIP_NAME "0",

.algo_data= &lpc32xx_algo_data0,

};

static struct i2c_pnx_data i2c0_data = {

.suspend= i2c_lpc32xx_suspend,

.resume= i2c_lpc32xx_resume,

.calculate_input_freq= calculate_input_freq,

.set_clock_run= set_clock_run,

.set_clock_stop= set_clock_stop,

.adapter= &lpc32xx_adapter0,

};

static struct platform_device i2c0_device = {

.name ="pnx-i2c",

.id = 0,

.dev = {

.platform_data= &i2c0_data,

},

};

#endif

这里资源的传递没有通过struct resource来传递，而是使用了struct platform_device的dev. platform_data传递过去的，这种用法不多见，其它模块的资源通过struct platform_device的resource成员来传递。可见这里已经定义好了设备的一切资源。

lpc32xx的platform_device是通过phy3250_board_init()->lpc32xx_init()->platform_add_devices()来注册的。而phy3250_board_init是在硬件架构的初始化时被调用的。

上面的内容是platform_device的定义，完整的驱动模型包含驱动和设备两部分。对应的platform_driver定义在driver/i2c/busses/i2c-pnx.c，如所示。

程序清单1.8 lpc32xx的platform_driver

/* driver/i2c/busses/i2c-pnx.c */

static struct platform_driver i2c_pnx_driver = {

.driver= {

.name= "pnx-i2c",

.owner= THIS_MODULE,

},

.probe =i2c_pnx_probe,

.remove= __devexit_p(i2c_pnx_remove),

.suspend= i2c_pnx_controller_suspend,

.resume= i2c_pnx_controller_resume,

};

static int __init i2c_adap_pnx_init(void)

{

returnplatform_driver_register(&i2c_pnx_driver);

}

static void __exit i2c_adap_pnx_exit(void)

{

platform_driver_unregister(&i2c_pnx_driver);

}

subsys_initcall(i2c_adap_pnx_init);

module_exit(i2c_adap_pnx_exit);

可以看到这个驱动的名字和platform_device的名字是一致的，因为名字是它们相互绑定的依据。在Linux设备模型中，当发现新注册的驱动和已经注册的设备符合绑定条件之后，驱动的probe函数将被调用，probe的主要职能是申请设备定义的资源（比如中断和IO内存空间）并初始化设备的硬件，注册设备的其它子系统资源（比如i2c的适配器结构体）。

由于i2c_adap_pnx_init是在子系统初始化的时候被调用的，因此比platform_device的初始化要晚。

1.3.2  platform驱动的使用总结

最典型的platform应用就是1.3.1节的所示的形式，在一个文件中定义设备的资源和数据结构，在另一个文件的驱动中进行申请和初始化。设备和驱动的绑定由Linux设备模型负责。驱动和设备的分离使得每个驱动可以对应多个同类的设备，资源独立之后可以在不修改设备资源配置的情况下升级驱动模块。

典型的应用是在内核编译之前就定义好了各种平台设备和它们的资源，如果想在驱动模块中定义platform_device并申请资源也是可以的。可以使用以下接口动态申请一个platform_device:

struct platform_device *platform_device_alloc( constchar *name, int id);

进行适当的初始化之后就可以使用platform_device_register()进行注册了。当然也可以直接动态构并注册：

struct platform_device*platform_device_register_simple(

const char *name, int id,

struct resource *res, unsigned int nres);

在模块当中定义platform_devic和platform_driver并不是内核文档推荐的用法，因为platform_devic可能被其他模块或者子系统所依赖或引用。当本模块卸载时，其它模块可能还在使用。因此在驱动模块中定义设备是不合适的，因为驱动的职责不包含设备的定义，这违背了Linux设备模型的思想。但是如果保证不会和其它模块产生依赖，使用平台设备可以添加设备电源管理的接口，这对需要低功耗的嵌入式设备具有重大意义。因此如果对功耗没有要求，尽量不要用platform，如果有需求则需要小心使用，如果这个设备比较固定，最好将设备的定义添加到内核中。

1.4     Linux资源树

我们看到Linux的平台设备使用了资源的概念，如程序清单1.2所示。如程序清单1.4所示，platform_device注册过程中会将没有设置父节点的IO端口和IO内存资源的父节点指针指向默认的两个节点：ioport_resource和iomem_resource，内核会以倒置的兄弟节点树的形式来记录资源的使用情况。它们的定义如程序清单1.9所示。

程序清单1.9 ioport_resource和iomem_resource

/* kernel/resource.c */

struct resource ioport_resource = {

.name         = "PCI IO",

.start  = 0,

.end   = IO_SPACE_LIMIT,

.flags = IORESOURCE_IO,

};

struct resource iomem_resource = {

.name         = "PCI mem",

.start  = 0,

.end   = -1,

.flags = IORESOURCE_MEM,

};

对于中断和DMA类的资源，内核中并没有相应的资源树。

在使用IO端口和IO内存资源之前，首先要进行申请，也就是从资源树中申请。IO端口空间的申请接口如下所示：

/* include/linux/ioport.h */

#define request_region(start,n,name)    __request_region(&ioport_resource,(start), (n), (name));

#define release_region(start,n)__release_region(&ioport_resource, (start), (n));

static inline int __deprecatedcheck_region(resource_size_t s, resource_size_t n);

这三个接口分别用来申请一段IO端口资源、释放一段资源和检查一段资源是否被占用。但是最后一个接口是不安全的，不推荐使用，因为检查和申请资源并不是原子的。

IO内存资源的管理接口如下：

#define request_mem_region(start,n,name)__request_region(&iomem_resource, (start), (n), (name));

#define release_mem_region(start,n)     __release_region(&iomem_resource,(start), (n));

#define check_mem_region(start,n)       __check_region(&iomem_resource,(start), (n));

这三个接口的功能分别用来申请一段IO内存资源、释放一段资源和检查一段资源是否被占用。同样check_mem_region也是不安全的。

资源树仅仅用来使用的记录，实际使用IO端口和IO内存之前还要进行物理地址到虚拟地址之间的映射。