一、bus_type结构体及涉及的函数：
（1）bus_type结构体
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;
struct lock_class_key lock_key;
};
（2）涉及的函数
kernel/linux-3.10/drivers/base/core.c：
device_create()、device_register()、device_add()
kernel/linux-3.10/drivers/base/driver.c:
driver_register()
kernel/linux-3.10/drivers/base/busc:
bus_add_driver()、bus_add_device()、bus_probe_device()
kernel/linux-3.10/drivers/base/dd.c:
device_attach()、__device_attach()、driver_attach()、__driver_attach()
kernel/linux-3.10/drivers/base/base.h:
driver_match_device()、driver_probe_device()
二、注册过程：
Linux设备驱动注册过程如下所示:
xxxx_driver_register()/xxxx_register_driver()--->driver_register()---> bus_add_driver()--->driver_attach()--->__driver_attach()
如：platform_driver_register()、spi_register_driver()、i2c_register_driver()
Linux设备添加过程如下所示：
device_create()/xxxx_device_register()/xxxx_new_device()--->device_register()/xxxx_device_add()/xxxx_add_device()
--->device_add()--->bus_add_device()--->bus_probe_device()---> device_attach()---> __device_attach()
(1）可以直接使用device_create()创建设备，其最终会调用device_register()函数创建设备。
(2）platform_device_register()--->platform_device_add()。
(3）spi_new_device()--->spi_add_device()。 (4）i2c_new_device()--->device_register()。
从设备和驱动的注册过程可以看到两者处理的过程是非常类似，下面分别从最后的函数展开进行深入探索。
三、驱动匹配设备过程
static int __driver_attach(struct device *dev, void *data)
{
struct device_driver *drv = data;
if (!driver_match_device(drv, dev))
return 0;
if (dev->parent) /* Needed for USB */
device_lock(dev->parent);
device_lock(dev);
if (!dev->driver)
driver_probe_device(drv, dev);
device_unlock(dev);
if (dev->parent)
device_unlock(dev->parent);
return 0;
}
从上述函数可以看到在driver注册时调用函数driver_match_device进行driver和device的匹配，在匹配之后执行driver的probe函数进行初始化等操作。我们主要看一下driver和device的匹配过程，不再详细研究probe过程。
static inline int driver_match_device(struct device_driver *drv, struct device *dev)
{
return drv->bus->match ?drv->bus->match(dev, drv) : 1;
}
可以看到，会调用相应总线的match函数来匹配driver和device。一般总线的调用过程如下所示，具体可参考每个总线的match函数。
static int xxxx_match(struct device *dev,struct device_driver *drv)
{
struct xxxx_device *xxxdev = to_xxxx_device(dev);
struct xxxx_driver *xxxdrv =to_xxxx_driver(drv);
/* Attempt an OF style match first */
if((of_driver_match_device(dev, drv))
return 1;
/* Then ACPI style match */
if((acpi_driver_match_device(dev, drv))
return 1;
/* Then try to match against the id table*/
if((xxxdrv->id_table)
return xxxx_match_id(xxxdrv->id_table,xxxdev) != NULL;
/* fall-back to driver name match */
return (strcmp([xxxdev/dev]->[name/modalias], drv->name)== 0);
}
可以看到基本上有四种方式，第一种是调用of_driver_match_device()函数；第二种方式是是ACPI系统专用的；第三种通过driver的id_table；第四种比较简单，是通过设备的名称或别名和驱动的名称进行匹配的。
下面详细看一下前第一种和第三种匹配方式：
（1）、of_driver_match_device()
该函数的调用过程如下:
static inline int of_driver_match_device(struct device *dev, const structdevice_driver *drv)
{
returnof_match_device(drv->of_match_table, dev) != NULL;
}
const struct of_device_id *of_match_device(const struct of_device_id *matches, conststruct device *dev)
{
if ((!matches) || (!dev->of_node))
return NULL;
return of_match_node(matches, dev->of_node);
}
const struct of_device_id *of_match_node(const struct of_device_id *matches, conststruct device_node *node)
{
const struct of_device_id *match;
unsigned long flags;
raw_spin_lock_irqsave(&devtree_lock,flags);
match = __of_match_node(matches, node);
raw_spin_unlock_irqrestore(&devtree_lock,flags);
return match;
}
static const struct of_device_id *__of_match_node(const struct of_device_id *matches,const struct device_node *node)
{
if (!matches)
return NULL;
while (matches->name[0] ||matches->type[0] || matches->compatible[0]) {
int match = 1;
if (matches->name[0])
match &= node->name &&!strcmp(matches->name, node->name);
if (matches->type[0])
match &= node->type &&!strcmp(matches->type, node->type);
if (matches->compatible[0])
match &= __of_device_is_compatible(node,matches->compatible);
if (match)
return matches;
matches++;
}
return NULL;
}
可以发现最终匹配会调用__of_match_node，该函数通过of_device_id的名称、类型和兼容性和设备节点的名称、类型和兼容性进行匹配，其中兼容性具有最高优先级，如果兼容性不匹配，即使前两者匹配，最终结果还是不匹配。另外，of_device_id中一般只有兼容性一项。
在进行兼容性匹配时会调用__of_device_is_compatible()，该函数最终会调用strcasecmp函数，比较兼容性字符串是否一致，一致则匹配。调用过程如下:
static int__of_device_is_compatible(const struct device_node *device, const char *compat)
{
const char* cp;
int cplen, l;
cp = __of_get_property(device,"compatible", &cplen);
if (cp == NULL)
return0;
while (cplen > 0) {
if (of_compat_cmp(cp, compat,strlen(compat)) == 0)
return 1;
l = strlen(cp) + 1;
cp += l;
cplen -= l;
}
return 0;
}
#defineof_compat_cmp(s1, s2, l) strcasecmp((s1), (s2))
（2）、id_table
一般是调用xxxx_match_id函数比较id_table的名称和设备相关属性的名称来进行匹配。xxxx_match_id的一般形式如下，具体可以参考各个总线的函数。
static const struct xxxx_device_id *xxxx_match_id(const struct xxxx_device_id *id,const struct _xxxx *xxxx)
{
while (id->name[0]) {
if (strcmp(xxxx->name, id->name) == 0)
return id;
id++;
}
return NULL;
}
我们可以看一下i2c总线和SPI总线的xxxx_match_id函数，如下所示：
static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id, conststruct i2c_client *client)
{
while (id->name[0]) {
if (strcmp(client->name, id->name) == 0)
return id;
id++;
}
return NULL;
}
可以看到I2C总线使用i2c_client的名称和id_table的名称来进行匹配。
static const struct spi_device_id *spi_match_id(const struct spi_device_id *id, conststruct spi_device *sdev)
{
while (id->name[0]) {
if (!strcmp(sdev->modalias, id->name))
return id;
id++;
}
return NULL;
}
可以看到SPI总线使用SPI设备的别名和id_table的名称来进行匹配。其它总线的匹配方式请自行查看，再此不再赘述。
四、设备匹配驱动过程
static int__device_attach(struct device_driver *drv, void *data)
{
struct device *dev = data;
if (!driver_match_device(drv, dev))
return 0;
return driver_probe_device(drv, dev);
}
staticinline int driver_match_device(struct device_driver *drv, struct device *dev)
{
return drv->bus->match ?drv->bus->match(dev, drv) : 1;
}
从上述函数可以看到device注册时也是调用函数driver_match_device来进行driver和device的匹配，在匹配之后执行driver的probe函数进行初始化等操作。
由此可见无论是设备还是驱动注册，都是调用总线的match函数进行匹配。在设备和驱动匹配之后，会调用driver_probe_device()函数，调用驱动的probe函数进行初始化工作。
五、常见总线的match函数：
（1）platform_bus：
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);//比较平台设备的名称和驱动名称进行匹配
}
（2）spi_bus:
static int spi_match_device(struct device *dev, struct device_driver *drv)
{
const struct spi_device*spi = to_spi_device(dev);
const struct spi_driver*sdrv = to_spi_driver(drv);
/* Attempt an OF style match */
if (of_driver_match_device(dev, drv))
return 1;
/* Then try ACPI */
if (acpi_driver_match_device(dev, drv))
return 1;
if (sdrv->id_table)
return !!spi_match_id(sdrv->id_table, spi);
return strcmp(spi->modalias, drv->name) == 0;//通过比较spi_device的别名和驱动的名称进行匹配
}
（3）i2c_bus:
static int i2c_device_match(struct device *dev, struct device_driver *drv)
{
struct i2c_client*client = i2c_verify_client(dev);
struct i2c_driver*driver;
if (!client)
return 0;
/* Attempt an OF style match */
if (of_driver_match_device(dev, drv))
return 1;
/* Then ACPI style match */
if (acpi_driver_match_device(dev, drv))
return 1;
driver = to_i2c_driver(drv);
/* match on an id table if there is one */
if (driver->id_table)
return i2c_match_id(driver->id_table, client) != NULL;
return 0;
}