Platform驱动程序

Platform总线是linux2.6内核加入的一种虚拟总线。platform机制的本身使用并不复杂，由两部分组成：platform_device和platform_driver

Platform 驱动与传统的设备驱动模型相比，优势在于platform机制将设备本身的资源注册进内核，由内核统一管理，在驱动程序使用这些资源时使用统一的接口，这样提高了程序的可移植性。

 

平台设备描述

平台设备使用Struct Platform_device来描述:

struct platform_device {

const char *name; /*设备名*/

int id; /*设备编号，配合设备名使用*/

struct device dev;

u32 num_resources;

struct resource *resource; /*设备资源*/

}

 

Struct Platform_device的分配使用：

struct platform_device *platform_device_alloc(const char *name, int id)

参数：

name: 设备名

id: 设备id，一般为-1

 

注册平台设备，使用函数:  int platform_device_add(struct platform_device *pdev)

 

设备资源

平台设备资源使用struct resource来描述：

struct resource {

resource_size_t start; //资源的起始物理地址

resource_size_t end; //资源的结束物理地址

const char *name; //资源的名称

unsigned long flags; //资源的类型，比如MEM，IO，IRQ类型

struct resource *parent, *sibling, *child; //资源链表指针

}

 

设备资源-例

static struct resource s3c_wdt_resource1 = {

.start = 0x44100000,

.end = 0x44200000,

.flags = IORESOURCE_MEM,

}

 

获取资源

struct resource *platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num)

参数：

 dev: 资源所属的设备

 type: 获取的资源类型

 num: 获取的资源数

例：platform_get_resource(pdev, IORESOURCE_IRQ, 0)获取中断号

 

平台驱动描述

平台驱动使用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 (*suspend_late)(struct platform_device *, pm_message_t state);

int (*resume_early)(struct platform_device *);

int (*resume)(struct platform_device *);

struct device_driver driver;

}

 

平台驱动注册

平台驱动注册使用函数：int platform_driver_register(struct platform_driver *)

例子

device.c

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


MODULE_AUTHOR("David Xie");
MODULE_LICENSE("Dual BSD/GPL");


static struct platform_device *my_device;


static int __init my_device_init(void)
{
int ret = 0;
        
        /* 分配结构 */
my_device = platform_device_alloc("my_dev", -1);
        
        /*注册设备*/
ret = platform_device_add(my_device);

/*注册失败，释放相关内存*/
if (ret)
   platform_device_put(my_device);

return ret;
}


static void my_device_exit(void)
{
platform_device_unregister(my_device);
}


module_init(my_device_init);
module_exit(my_device_exit);

driver.c

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


MODULE_AUTHOR("David Xie");
MODULE_LICENSE("Dual BSD/GPL");


static int my_probe(struct device *dev)
{
    printk("Driver found device which my driver can handle!\n");
    return 0;
}


static int my_remove(struct device *dev)
{
    printk("Driver found device unpluged!\n");
    return 0;
}


static struct platform_driver my_driver = {
.probe = my_probe,
.remove = my_remove,
.driver = {
.owner = THIS_MODULE,
.name = "my_dev",/*匹配*/
},
};


static int __init my_driver_init(void)
{       
        /*注册平台驱动*/
return platform_driver_register(&my_driver);
}


static void my_driver_exit(void)
{
platform_driver_unregister(&my_driver);
}


module_init(my_driver_init);
module_exit(my_driver_exit);