详解platform_device_系列函数

出处：http://blog.chinaunix.net/space.php?uid=9185047&do=blog&cuid=2004387

platform_device_系列函数，实际上是注册了一个叫platform的虚拟总线。使用约定是如果一个不属于任何总线的设备，例如蓝牙，串口等设备，都需要挂在这个虚拟总线上。

driver/base/platform.c

//platform设备声明
struct device platform_bus = {
    .bus_id        = "platform",
};
EXPORT_SYMBOL_GPL(platform_bus);

//platform总线设备声明
struct bus_type platform_bus_type = {
    .name        = "platform",
    .dev_attrs    = platform_dev_attrs,
    .match        = platform_match,
    .uevent        = platform_uevent,
    .suspend    = platform_suspend,
    .suspend_late    = platform_suspend_late,
    .resume_early    = platform_resume_early,
    .resume        = platform_resume,
};
EXPORT_SYMBOL_GPL(platform_bus_type);

int __init platform_bus_init(void)
{
    int error;

    error = device_register(&platform_bus);//注册了"platform"的设备
    if (error)
        return error;
    error =  bus_register(&platform_bus_type);//注册了叫"platform"的总线
    if (error)
        device_unregister(&platform_bus);
    return error;
}


//这里在platform总线上挂设备
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;//父设备设置为platform_bus

    pdev->dev.bus = &platform_bus_type;//设置挂在platform总线上

    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++) {
        struct resource *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;
            else if (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;
            goto failed;
        }
    }

    pr_debug("Registering platform device '%s'. Parent at %s\n",
         pdev->dev.bus_id, pdev->dev.parent->bus_id);

    ret = device_add(&pdev->dev);
    if (ret == 0)
        return ret;

 failed:
    while (--i >= 0)
        if (pdev->resource[i].flags & (IORESOURCE_MEM|IORESOURCE_IO))
            release_resource(&pdev->resource[i]);
    return ret;
}
EXPORT_SYMBOL_GPL(platform_device_add);


//常用的platform_device_register，内部调用了platform_device_add，将设备挂在了platform总线上
/**
 * platform_device_register - add a platform-level device
 * @pdev: platform device we're adding
 */
int platform_device_register(struct platform_device *pdev)
{
    device_initialize(&pdev->dev);
    return platform_device_add(pdev);
}
EXPORT_SYMBOL_GPL(platform_device_register);

要用注册一个platform驱动的步骤：
1，注册设备platform_device_register
2，注册驱动platform_driver_register
注册时候的两个名字必须一样，才能match上，才能work,例如：
struct platform_device pxa3xx_device_nand = {
    .name        = "pxa3xx-nand",
    .id        = -1,
    .dev        = {
        .dma_mask = &pxa3xx_nand_dma_mask,
        .coherent_dma_mask = DMA_BIT_MASK(32),
    },
    .resource    = pxa3xx_resource_nand,
    .num_resources    = ARRAY_SIZE(pxa3xx_resource_nand),
};

static struct platform_driver pxa3xx_nand_driver = {
    .driver = {
        .name    = "pxa3xx-nand",
    },
    .probe        = pxa3xx_nand_probe,
    .remove        = pxa3xx_nand_remove,
#ifdef CONFIG_PM
    .suspend    = pxa3xx_nand_suspend,
    .resume        = pxa3xx_nand_resume,
#endif
};

而且device注册的时候，可以给driver传参数

struct device {
    struct klist        klist_children;
    struct klist_node    knode_parent;    /* node in sibling list */
    struct klist_node    knode_driver;
    struct klist_node    knode_bus;
    struct device        *parent;

    struct kobject kobj;
    char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
    struct device_type    *type;
    unsigned        is_registered:1;
    unsigned        uevent_suppress:1;

    struct semaphore    sem;    /* semaphore to synchronize calls to
                     * its driver.
                     */

    struct bus_type    *bus;        /* type of bus device is on */
    struct device_driver *driver;    /* which driver has allocated this
                       device */
    void        *driver_data;    /* data private to the driver */
    void        *platform_data;    /* Platform specific data, device
                       core doesn't touch it */
    struct dev_pm_info    power;

#ifdef CONFIG_NUMA
    int        numa_node;    /* NUMA node this device is close to */
#endif
    u64        *dma_mask;    /* dma mask (if dma'able device) */
    u64        coherent_dma_mask;/* Like dma_mask, but for
                         alloc_coherent mappings as
                         not all hardware supports
                         64 bit addresses for consistent
                         allocations such descriptors. */

    struct device_dma_parameters *dma_parms;

    struct list_head    dma_pools;    /* dma pools (if dma'ble) */

    struct dma_coherent_mem    *dma_mem; /* internal for coherent mem
                         override */
    /* arch specific additions */
    struct dev_archdata    archdata;

    spinlock_t        devres_lock;
    struct list_head    devres_head;

    /* class_device migration path */
    struct list_head    node;
    struct class        *class;
    dev_t            devt;    /* dev_t, creates the sysfs "dev" */
    struct attribute_group    **groups;    /* optional groups */

    void    (*release)(struct device *dev);
};
传参数都是通过platform_data传，所以定义为void *
    void        *platform_data;    /* Platform specific data, device




static struct pxa3xx_nand_platform_data XXX_nand_info = {
    .parts            = android_256m_v75_partitions,
    .nr_parts        = ARRAY_SIZE(android_256m_v75_partitions),
};

static void __init XXX_init_nand(void)
{
    pxa3xx_device_nand.dev.platform_data = &XXX_nand_info;
    platform_device_register(&pxa3xx_device_nand);
}




static int __init pxa3xx_nand_probe(struct platform_device *pdev)
{
    struct pxa3xx_nand_platform_data *pdata;
    struct nand_chip *this;
    struct pxa3xx_nand_info *info;
    struct resource *res;
    struct clk *clk = NULL, *smc_clk = NULL;
    int status = -1;
    struct mtd_partition *parts;
    unsigned int data_buf_len;
#ifdef CONFIG_MTD_NAND_PXA3xx_DMA
    unsigned int buf_len;
#endif
    int i, ret = 0;
#ifdef CONFIG_MTD_PARTITIONS
    int err;
#endif

    pdata = pdev->dev.platform_data;
....
....
....
}

下面解释一下pxa_register_device函数
    pxa_set_ohci_info(&XXX_ohci_info);

void __init pxa_set_ohci_info(struct pxaohci_platform_data *info)
{
    pxa_register_device(&pxa27x_device_ohci, info);
}

void __init pxa_register_device(struct platform_device *dev, void *data)
{
    int ret;

    dev->dev.platform_data = data;

    ret = platform_device_register(dev);
    if (ret)
        dev_err(&dev->dev, "unable to register device: %d\n", ret);
}

其实上，也就是给driver传参数，通过dev.platform_data。

到这里，platform_device系列函数，基本算通了，系列函数还有一堆设置的函数，和device_register同级别的那些功能函数，用法基本差不多，只不过都将设备挂在了platform总线上。