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

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,

};

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

}

struct platform_device {

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

　　int id; /* 设备编号 */

　　struct device dev;

　　u32 num_resources; /* 资源总数 */

　　struct resource * resource; /* 资源 */

　　struct platform_device_id *id_entry;

};

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

}

int platform_device_register(struct platform_device *pdev)

{

　　device_initialize(&pdev->dev);

　　return platform_device_add(pdev);

}

1. int platform_device_add(struct platform_device *pdev)  

2. {  

3.     int i, ret = 0;  

5.     if (!pdev)  /* 如果pdev为空则返回EINVAL */  

6.         return -EINVAL;  

8.     /* 如果pdev->dev.parent为空则将pdev->dev.parent设置为platform_bus */  

9.     if (!pdev->dev.parent)  

10.         pdev->dev.parent = &platform_bus;  

12.     pdev->dev.bus = &platform_bus_type;  /* 设置总线类型 */  

14.     if (pdev->id != -1)      /* 如果id = -1则表示自动分配name */  

15.         dev_set_name(&pdev->dev, '%s.%d', pdev->name,  pdev->id);  

16.     else  

17.         dev_set_name(&pdev->dev, pdev->name);  

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

20.         struct resource *p, *r = &pdev->resource[i]; /* 获取资源 */  

22.         if (r->name == NULL)  

23.             r->name = dev_name(&pdev->dev);  

25.         p = r->parent;  

26.         if (!p) {  

27.             if (resource_type(r) == IORESOURCE_MEM) /* 设置资源类型 */  

28.                 p = &iomem_resource;  

29.             else if (resource_type(r) == IORESOURCE_IO)  

30.                 p = &ioport_resource;  

31.         }  

33.         if (p && insert_resource(p, r)) {  

34.             printk(KERN_ERR  

35.                    '%s: failed to claim resource %dn',  

36.                    dev_name(&pdev->dev), i);  

37.             ret = -EBUSY;  

38.             goto failed;  

39.         }  

40.     }  

42.     pr_debug('Registering platform device '%s'. Parent at %sn',  

43.          dev_name(&pdev->dev), dev_name(pdev->dev.parent));  

45.     /* 向内核添加一个device */  

46.     ret = device_add(&pdev->dev);  

47.     if (ret == 0)  

48.         return ret;  

50.  failed:  

51.     while (--i >= 0) {  

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

53.         unsigned long type = resource_type(r);  

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

56.             release_resource(r);  

57.     }  

59.     return ret;  

60. }  

void platform_device_unregister(struct platform_device *pdev)

{

　　　　platform_device_del(pdev);

　　　　platform_device_put(pdev);

}

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

　　　　}

　　}

}

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;

};

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;

};

struct platform_device_id {

　　　　char name[PLATFORM_NAME_SIZE];

　　　　kernel_ulong_t driver_data

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

};

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

}

void platform_driver_unregister(struct platform_driver *drv)

{

　　driver_unregister(&drv->driver);

}