Linux平臺總線驅動設備模型

platform總線是一種虛擬的總線，相應的設備則爲platform_device，而驅動則爲platform_driver。Linux 2.6的設備驅動模型中，把I2C、RTC、LCD等都概括爲platform_device。

總線將設備和驅動綁定，在系統每註冊一個設備的時候，會尋找與之匹配的驅動；相反的，在系統每註冊一個驅動的時候，會尋找與之匹配的設備，而匹配由總線完成。

Linux2.6系統中定義了一個bus_type的實例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,
};

 

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

 

platform_match函數首先判斷是否由id_table，若是有則使用id_table來進行匹配，不然，判斷platform_device和platform_driver成員裏的name，若是兩者的name字段相同則匹配，若是匹配則調用platform_driver的probe函數。

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

 

平臺設備的註冊，使用platform_device_register函數

 

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

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

 

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

 

 

platform_driver結構體有device_driver成員，該成員的各自字段如上所示，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))));
};

 

平臺驅動的註冊使用platform_driver_register函數

 

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裏的driver，該driver的類型爲device_driver，設置driver的bus爲platform_bus_type；設置driver的probe爲platform_drv_probe；設置driver的remove爲platform_drv_remove；設置driver的shutdown爲platform_drv_shutdown；設置driver的suspend爲platform_drv_suspend；設置driver的resume爲platform_drv_resume，最後調用driver_register函數來註冊平臺驅動。

 

相反地，要註銷平臺驅動的話，使用platform_driver_unregister函數

 

void platform_driver_unregister(struct platform_driver *drv)
{
    driver_unregister(&drv->driver);
}

附韋老師總結的bus_drv_dev模型的框架圖