20150226 IMX257 总线设备驱动模型编程之平台总线设备platform

20150226 IMX257 总线设备驱动模型编程之平台总线设备platform

2015-02-26 李海沿

前面我们实现了总线设备驱动模型，下面我们来了解一下平台总线，平台设备驱动

分为平台设备和平台驱动两种，和前面所说的设备驱动差不多

platform总线是一种虚拟的总线，相应的设备则为platform_device，而驱动则为platform_driver。Linux 2.6的设备驱动模型中，把I2C、RTC、LCD等都归纳为platform_device。

一、平台设备介绍

1. platform_bus_type 结构体

struct bus_type platform_bus_type = {

.name = "platform",

　　.dev_attrs = platform_dev_attrs,

　　.match = platform_match, //设备和驱动使用match函数来判断是否匹配

　　.uevent = platform_uevent,

　　.pm = PLATFORM_PM_OPS_PTR,

};

这个结构体就是linux中平台设备的结构体，所以在sysfs文件系统中的/sys/bus/目录下面会有一个名字为platform的目录。

2. platform_match 函数

platform_match函数首先判断是否由id_table，如果有则使用id_table来进行匹配，否则，判断platform_device和platform_driver成员里的name，如果二者的name字段相同则匹配，如果匹配则调用platform_driver的probe函数。

/* platform_match函数用于匹配总线中的驱动和设备 */

static int platform_match(struct device *dev, struct device_driver *drv)

{

　　struct platform_device *pdev = to_platform_device(dev);

　　struct platform_driver *pdrv = to_platform_driver(drv);

　　/* match against the id table first */

　　if (pdrv->id_table)

　　return platform_match_id(pdrv->id_table, pdev) != NULL;

　　/* fall-back to driver name match */

　　return (strcmp(pdev->name, drv->name) == 0);

}

3. platform_device 结构体

struct platform_device {

　　const char * name; /* 名字。这个名字用于与驱动进行匹配*/

　　int id; /* 设备编号 */

　　struct device dev;

　　u32 num_resources; /* 资源总数 */

　　struct resource * resource; /* 资源 */

　　struct platform_device_id *id_entry;

};

其中有个重要的成员是resource，是设备的资源信息，如IO地址，中断号等。

struct resource {

　　resource_size_t start; //资源的起始值

　　resource_size_t end; //资源的结束值

　　const char *name;

　　unsigned long flags; //资源的类型，

　　//如IORESOURCE_IO,IORESOURCE_MEM,IORESOURCE_IRQ,IORESOURCE_DMA

　　struct resource *parent, *sibling, *child;

};

有的设备可能有多个资源，通常使用platform_get_resource函数来获取资源

/**

* platform_get_resource - get a resource for a device

* @dev: platform device

* @type: resource type

* @num: resource index

struct resource *platform_get_resource(struct platform_device *dev,

unsigned int type, unsigned int num)

{

　　int i;

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

　　　　struct resource *r = &dev->resource[i];

　　　　　if (type == resource_type(r) && num-- == 0)

　　　　　　return r;

　　}

　　return NULL;

}

4. platform平台设备注册函数

int platform_device_register(struct platform_device *pdev)

{

　　device_initialize(&pdev->dev);

　　return platform_device_add(pdev);

}

从上面代码得知，platform_device_register函数先通过device_initialize函数初始化platform_device的device成员，然后调用platform_device_add向内核添加一个平台设备。

int platform_device_add(struct platform_device *pdev)
{
int i, ret = 0;
if (!pdev) /* 如果pdev为空则返回EINVAL */
return -EINVAL;
/* 如果pdev->dev.parent为空则将pdev->dev.parent设置为platform_bus */
if (!pdev->dev.parent)
pdev->dev.parent = &platform_bus;
pdev->dev.bus = &platform_bus_type; /* 设置总线类型 */
if (pdev->id != -1) /* 如果id = -1则表示自动分配name */
dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
else
dev_set_name(&pdev->dev, pdev->name);
for (i = 0; i < pdev->num_resources; i++) {
struct resource *p, *r = &pdev->resource[i]; /* 获取资源 */
if (r->name == NULL)
r->name = dev_name(&pdev->dev);
p = r->parent;
if (!p) {
if (resource_type(r) == IORESOURCE_MEM) /* 设置资源类型 */
p = &iomem_resource;
else if (resource_type(r) == IORESOURCE_IO)
p = &ioport_resource;
}
if (p && insert_resource(p, r)) {
printk(KERN_ERR
"%s: failed to claim resource %d\n",
dev_name(&pdev->dev), i);
ret = -EBUSY;
goto failed;
}
}
pr_debug("Registering platform device ‘%s‘. Parent at %s\n",
dev_name(&pdev->dev), dev_name(pdev->dev.parent));
/* 向内核添加一个device */
ret = device_add(&pdev->dev);
if (ret == 0)
return ret;
failed:
while (--i >= 0) {
struct resource *r = &pdev->resource[i];
unsigned long type = resource_type(r);
if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
release_resource(r);
}
return ret;
}

platform_device_add最终调用device_add来完成平台设备的注册。

相反地，如果要注销平台设备则使用platform_device_unregister函数

void platform_device_unregister(struct platform_device *pdev)

{

　　　　platform_device_del(pdev);

　　　　platform_device_put(pdev);

}

platform_device_unregister函数调用platform_device_del函数来注销平台设备

void platform_device_del(struct platform_device *pdev)

{

　　int i;

　　if (pdev) {

　　　　device_del(&pdev->dev);

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

　　　　　　struct resource *r = &pdev->resource[i];

　　　　　　unsigned long type = resource_type(r);

　　　　　　if (type == IORESOURCE_MEM || type == IORESOURCE_IO)

　　　　　　　　release_resource(r);

　　　　}

platform_device_del函数调用device_del函数来删除平台设备，相应地，要释放资源应调用release_resource函数，前提是资源的类型必须为IORESOURCE_MEM或者IORESOURCE_IO

二、平台驱动介绍

1. 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;

　　　　const struct platform_device_id *id_table;

};

platform_driver结构体有device_driver成员

2. device_driver

struct device_driver {

　　　　const char *name; //这个名字用于与设备进行匹配

　　　　struct bus_type *bus;

　　　　struct module *owner;

　　　　const char *mod_name; /* used for built-in modules */

　　　　bool suppress_bind_attrs; /* disables bind/unbind via sysfs */

　　　　const struct of_device_id *of_match_table;

　　　　const struct acpi_device_id *acpi_match_table;

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

　　　　const struct attribute_group **groups;

　　　　const struct dev_pm_ops *pm;

　　　　struct driver_private *p;

};

device_driver也有probe、remove、shutdown等函数，在平台驱动注册的时候被初始化

当系统中存在有平台设备和平台驱动通过总线的match函数匹配后则会调用platform_driver的probe函数，参数为platform_device，有时候也通过id_table来判断是否匹配。

struct platform_device_id {

　　　　char name[PLATFORM_NAME_SIZE];

　　　　kernel_ulong_t driver_data

　　　　　　__attribute__((aligned(sizeof(kernel_ulong_t))));

};

3. 平台驱动注册函数

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;

　　return driver_register(&drv->driver);

}

如果platform_driver 自定义了probe，remove等函数，则会覆盖默认函数，否则使用默认的函数

相反地，要注销平台驱动的话，使用platform_driver_unregister函数

void platform_driver_unregister(struct platform_driver *drv)

{

　　driver_unregister(&drv->driver);

}

三、平台设备实例分析

1. 定义平台设备结构体

2.在初始化函数中分配平台设备结构体

如图所示，在init函数中先分配平台设备结构体，然后再注册设备

3. 在exit函数中卸载设备

很简单吧，下面我们来看看平台驱动

四、平台驱动实例分析

1.定义平台驱动结构体

如图所示，先定义平台驱动结构体，然后实现相关的函数。

注意.driver = 这个是一个device_driver结构体，其中的成员.name就是用于和设备进行匹配。

2.注册平台驱动

如图所示，剩下的工作就是分别在 init 和exit 函数中注册和卸载驱动了。

五、编译测试

上面有关平台设备的部分知识点摘自大牛文章：

http://blog.csdn.net/lwj103862095/article/details/17957637

附平台设备程序；

 1 //platform_device.c
 2 #include <linux/device.h>
 3 #include <linux/module.h>
 4 #include <linux/kernel.h>
 5 #include <linux/init.h>
 6 #include <linux/string.h>
 7 #include <linux/platform_device.h>
 8
 9 //定义平台设备结构体
10 static struct platform_device *my_device;
11
12 static int __init my_device_init(void){
13     int ret = 0;
14     /* 分配结构体 */
15     my_device = platform_device_alloc("my_platform_dev",-1);
16
17     /* 注册设备 */
18     ret = platform_device_add(my_device);
19
20     /* 注册失败，则释放相关内存 */
21     if(ret)
22         platform_device_put(my_device);
23     return ret;
24 }
25
26 static void my_device_exit(void){
27     platform_device_unregister(my_device);
28 }
29
30 module_init(my_device_init);
31 module_exit(my_device_exit);
32
33 MODULE_AUTHOR("Lover雪儿");
34 MODULE_LICENSE("GPL");

附平台驱动程序

 1 //platform_driver.c
 2 #include <linux/device.h>
 3 #include <linux/module.h>
 4 #include <linux/kernel.h>
 5 #include <linux/init.h>
 6 #include <linux/string.h>
 7 #include <linux/platform_device.h>
 8
 9 //探测函数
10 static int my_probe(struct platform_device *dev){
11     printk("Driver found device which my driver can handle!\n");
12     return 0;
13 }
14 static int my_remove(struct platform_device *dev){
15     printk("Driver found device unpluged!\n");
16     return 0;
17 }
18 //定义平台驱动结构体
19 static struct platform_driver my_driver = {
20     .probe = my_probe,
21     .remove = my_remove,
22     .driver = {
23         .owner = THIS_MODULE,
24         .name  = "my_platform_dev",
25     },
26 };
27
28 static int __init my_driver_init(void){
29     /* 注册平台驱动 */
30     return platform_driver_register(&my_driver);
31 }
32
33 static void my_driver_exit(void){
34     platform_driver_unregister(&my_driver);
35 }
36
37 module_init(my_driver_init);
38 module_exit(my_driver_exit);
39
40 MODULE_AUTHOR("Lover雪儿");
41 MODULE_LICENSE("GPL");

附MAKEFILE程序

 1 ifeq ($(KERNELRELEASE),)
 2     KERNELDIR ?= /home/study/system/linux-2.6.31
 3     PWD := $(shell pwd)
 4 modules:
 5     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
 6 modules_install:
 7     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
 8 clean:
 9     rm -rf *.o *~ core .depend  *.cmd *.ko *.mod.c .tmp_versions *.markers *.order *.symvers
10
11 else
12     obj-m := platform_device.o platform_driver.o
13 endif

时间： 2024-08-25 11:50:10

20150226 IMX257 总线设备驱动模型编程之平台总线设备platform

20150226 IMX257 总线设备驱动模型编程之平台总线设备platform的相关文章

20150226 IMX257 总线设备驱动模型编程之设备篇

20150226 IMX257 总线设备驱动模型编程之驱动篇

20150225 IMX257 总线设备驱动模型编程之总线篇

字符设备驱动、平台设备驱动、设备驱动模型、sysfs的关系

[kernel]字符设备驱动、平台设备驱动、设备驱动模型、sysfs几者之间的比较和关联

平台设备驱动模型

Linux 设备驱动模型

第四季-专题13-总线设备驱动模型

6410-混杂设备驱动模型