平臺匯流排和IIC，SPI，IIS都是匯流排型別，一般的，匯流排下，掛載對應的裝置。但實際上，裝置要正常運轉，是需要驅動程式來未知提供驅動的。所以linux核心也把驅動掛載在對應的匯流排下。匯流排，驅動，裝置三者缺一不可.
相應的，核心衍生出來的平臺匯流排，那麼便衍生出來了平臺裝置和憑條驅動。他們均有自己的專屬函式來註冊，登出。這個是成一套體系結構的.在以後的驅動開發中，很是常見與重要.

一)核心中的匯流排,裝置,驅動
1)匯流排

struct bus_type {
    const char      *name;
    const char      *dev_name;
    struct
 
 device       *dev_root;
    struct bus_attribute    *bus_attrs;//匯流排屬性
    struct device_attribute *dev_attrs;//裝置屬性
    struct driver_attribute *drv_attrs;//驅動屬性

    int (*match)(struct device *dev, struct device_driver *drv);//匹配匯流排下的裝置和驅動
    int (*uevent)(struct device *dev, struct kobj_uevent_env *env);//用於匯流排環境變數的新增
 

    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 dev_pm_ops *pm;//電源管理

    struct iommu_ops *iommu_ops;

    struct
 
 subsys_private *p;//將bus device sysfs聯絡起來
    struct lock_class_key lock_key;
};

註冊：bus_register(struct bus_type *bus);
登出：bus_unregister(struct bus_type *bus);

2)裝置

struct device {
    struct device       *parent;

    struct device_private   *p;

    struct kobject kobj;
    const char      *init_name; /* initial name of the device */
    const struct device_type *type;

    struct mutex        mutex;  /* mutex 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        *platform_data; /* Platform specific data, device
                       core doesn't touch it */
    struct dev_pm_info  power;
    struct dev_pm_domain    *pm_domain;

#ifdef CONFIG_PINCTRL
    struct dev_pin_info *pins;
#endif

#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 */
#ifdef CONFIG_CMA
    struct cma *cma_area;       /* contiguous memory area for dma
                       allocations */
#endif
    /* arch specific additions */
    struct dev_archdata archdata;

    struct device_node  *of_node; /* associated device tree node */
    struct acpi_dev_node    acpi_node; /* associated ACPI device node */

    dev_t           devt;   /* dev_t, creates the sysfs "dev" */
    u32         id; /* device instance */

    spinlock_t      devres_lock;
    struct list_head    devres_head;

    struct klist_node   knode_class;
    struct class        *class;
    const struct attribute_group **groups;  /* optional groups */

    void    (*release)(struct device *dev);
    struct iommu_group  *iommu_group;
};

設備註冊：int device_register(struct device *dev)
設備註銷：void device_unregister(struct device *dev)

3)裝置驅動

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);// 裝置match到驅動，則呼叫對應驅動的probe函式，驅動裝置
    int (*remove) (struct device *dev);//當驅動或者裝置被解除安裝，則呼叫對應驅動的remove函式
    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;
};

驅動註冊：int driver_register(struct device_driver *drv)
驅動登出：void driver_unregister(struct device_driver *drv)

二)平臺裝置匯流排
匯流排：

struct bus_type platform_bus_type = {
    .name       = "platform",
    .dev_attrs  = platform_dev_attrs,
    .match      = platform_match,
    .uevent     = platform_uevent,
    .pm     = &platform_dev_pm_ops,
};

裝置：

struct platform_device {
    const char  *name;
    int     id;
    bool        id_auto;
    struct device   dev;
    u32     num_resources;
    struct resource *resource;

    const struct platform_device_id *id_entry;

    /* MFD cell pointer */
    struct mfd_cell *mfd_cell;

    /* arch specific additions */
    struct pdev_archdata    archdata;
};
平臺裝置的註冊：platform_device_register(struct platform_device * pdev)
平臺裝置的登出：platform_device_unregister(struct platform_device * pdev)

驅動：

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;
};
平臺驅動的註冊：int platform_driver_register(struct platform_driver *drv)
平臺驅動的登出：void platform_driver_unregister(struct platform_driver *drv)

平臺裝置匹配的流程：

先插入一個函式，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);

    /* Attempt an OF style match first */
    if (of_driver_match_device(dev, drv))
        return 1;

    /* Then try ACPI style match */
    if (acpi_driver_match_device(dev, drv))
        return 1;

    /* Then try to match against the id table */
    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);
}
//match 的方式：不同的核心，可能有所不同：我的核心版本：3.10.46

1.OF style match first
2.ACPI style match
3.match against the id table
4.driver name match

大概的匹配流程：
1)平臺設備註冊流程：

platform_device_register()
{
--->platform_device_add()
    {
        --->device_add()
        {
            --->device_add()
            {
                --->bus_probe_device()
                {

                    --->device_attach()
                    {
                        --->bus_for_each_drv(dev->bus, NULL, dev, __device_attach)
                        {
                            --->__device_attach()
                            {
                                --->driver_match_device()//platform_match()
                                //當match到驅動後，繼續下面步驟：
                                --->driver_probe_device()
                                {
                                    --->really_probe()
                                    {
                                        --->drv->probe()//呼叫對應驅動的probe函式
                                    }

                                }

                            }
                        }
                    }


                }
            }
        }
    }

}

2)平臺驅動註冊流程：

platform_driver_register()
{
    --->driver_register()
    {
        --->bus_add_driver()
        {
            --->driver_attach()
            {
                --->bus_for_each_dev(drv->bus, NULL, drv, __driver_attach)
                {
                    --->__driver_attach()
                    {
                        --->driver_match_device()//platform_match()
                        //當match到對應的裝置後，繼續
                        --->driver_probe_device()
                        {
                            --->really_probe()
                            {
                                --->drv->probe()//呼叫當前註冊驅動的probe函式
                            }
                        }
                    }
                }
            }
        }
    }
}

1.裝置向對應平臺bus註冊裝置，裝置掛載到平臺bus下面的dev list連結串列中.
2.驅動向對應平臺bus註冊驅動，驅動掛載到平臺bus下面的driver list連結串列中.
3.裝置和對應匯流排下的driver list連結串列中每個driver進行匹配(match).匹配成功則呼叫對應driver的probe函式，否則匹配失敗，則裝置無法被驅動，裝置無法工作.

match函式已經在上面列出。它有自己的匹配規則，上一篇的例項是按照match name來進行匹配的.
當裝置或者驅動被解除安裝時，驅動的remove函式都會被呼叫.

平臺裝置匯流排的意義：移植性強。通過我們是不需要寫平臺裝置檔案的，只需要寫對應的驅動檔案。而驅動檔案一般移植時並不需要修改。只需要修改對應的platform_data 平臺數據和resource 平臺資源列表便可.
這樣修改一個驅動或者移植一個驅動到另一個核心便變得很簡單。