linux内核device生成流程

一、前言

在驱动模型的框架下，设备驱动的开发主要包含以下两个步骤：

步骤1：分配一个struct device类型的变量，填充必要的信息后，把它注册到内核中。

步骤2：分配一个struct device_driver类型的变量，填充必要的信息后，把它注册到内核中。

上述两个步骤完成后，内核会在合适的时机（注册device、注册device_driver等）执行probe等回调函数，那么每个设备对应的struct device结构是何时创建的呢？本文主要针对这个问题分析。

注：本文涉及的代码基于linux 3.10版本

二、device初始化流程

对于平台设备等无法热插拔的设备，必须在内核初始化的时候就生成对应的struct device结构体。而对于挂在真正总线（如i2c、usb等）上的设备，struct device结构体由对应的总线驱动在初始化或设备热插拔时生成。本文只对前一种设备做介绍。

内核启动过程中，会调用arm64_device_init函数，代码如下：

const struct of_device_id of_default_bus_match_table[] = {
{ .compatible = "simple-bus", },
#ifdef CONFIG_ARM_AMBA
{ .compatible = "arm,amba-bus", },
#endif /* CONFIG_ARM_AMBA */
{} /* Empty terminated list */
};
static int __init arm64_device_init(void)
{
of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL);
return 0;
}
arch_initcall_sync(arm64_device_init);

从arch_initcall_sync的宏定义我们可以知道，arch_initcall_sync的优先级是比较高的，相比于驱动的初始化要早，也就是说在驱动的初始化前，内核已经对平台设备进行了初始化

int of_platform_populate(struct device_node *root,
const struct of_device_id *matches,
const struct of_dev_auxdata *lookup,
struct device *parent)
{
struct device_node *child;
int rc = 0;

root = root ? of_node_get(root) : of_find_node_by_path("/");            ---（1）
if (!root)
return -EINVAL;

for_each_child_of_node(root, child) {                                   ---（2）
rc = of_platform_bus_create(child, matches, lookup, parent, true);  ---（3）
if (rc)
break;
}

of_node_put(root);
return rc;
}

代码（1）解析：

从前面传入的参数可知，root=NULL，因此执行流程of_find_node_by_path，of_find_node_by_path函数代码如下：

struct device_node *of_find_node_by_path(const char *path)
{
struct device_node *np = of_allnodes;
unsigned long flags;

raw_spin_lock_irqsave(&devtree_lock, flags);
for (; np; np = np->allnext) {
if (np->full_name && (of_node_cmp(np->full_name, path) == 0)
&& of_node_get(np))
break;
}
raw_spin_unlock_irqrestore(&devtree_lock, flags);
return np;
}

of_allnodes我在linux内核device tree的初始化流程中有讲到，就是dts的根节点。

代码（2）解析：

遍历dts中根节点下面的所有子节点。

代码（3）解析：

of_platform_bus_create函数代码如下：

static int of_platform_bus_create(struct device_node *bus,
const struct of_device_id *matches,
const struct of_dev_auxdata *lookup,
struct device *parent, bool strict)
{
const struct of_dev_auxdata *auxdata;
struct device_node *child;
struct platform_device *dev;
const char *bus_id = NULL;
void *platform_data = NULL;
int rc = 0;

/* Make sure it has a compatible property */
if (strict && (!of_get_property(bus, "compatible", NULL))) { //忽略没有compatible属性的节点
pr_debug("%s() - skipping %s, no compatible prop\n",
__func__, bus->full_name);
return 0;
}

auxdata = of_dev_lookup(lookup, bus);
if (auxdata) {
bus_id = auxdata->name;
platform_data = auxdata->platform_data;
}

if (of_device_is_compatible(bus, "arm,primecell")) { //特殊节点处理，不深入
of_amba_device_create(bus, bus_id, platform_data, parent);
return 0;
}
/*这个函数是真正生成struct device的地方*/
dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
/*如果compatible属性不是"simple-bus"和"arm,amba-bus"则在返回，不继续遍历子节点。这里我的理解是"simple-bus"和"arm,amba-bus"这两种设备不具备热插拔能力，因此在这里就先创建了struct device*/
if (!dev || !of_match_node(matches, bus))
return 0;
/*对于"simple-bus"和"arm,amba-bus"设备要继续遍历子节点，并创建对应的 struct device*/
for_each_child_of_node(bus, child) {
pr_debug("   create child: %s\n", child->full_name);
rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);
if (rc) {
of_node_put(child);
break;
}
}
return rc;
}

具体创建device的代码在of_platform_device_create_pdata中，代码如下：

struct platform_device *of_platform_device_create_pdata(
struct device_node *np,
const char *bus_id,
void *platform_data,
struct device *parent)
{
struct platform_device *dev;

if (!of_device_is_available(np))
return NULL;

/* of_device_alloc除了分配struct platform_device的内存，还分配了该platform device需要的resource的内存（参考struct platform_device 中的resource成员）。当然，这就需要解析该device node的interrupt资源以及memory address资源,这些资源的原始数据都来自dtb中。*/
dev = of_device_alloc(np, bus_id, parent);
if (!dev)
return NULL;

#if defined(CONFIG_MICROBLAZE)
dev->archdata.dma_mask = 0xffffffffUL;
#endif
dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
if (!dev->dev.dma_mask)
dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
dev->dev.bus = &platform_bus_type;
dev->dev.platform_data = platform_data;

of_reserved_mem_device_init(&dev->dev);

if (of_device_add(dev) != 0) {//把这个device加入到设备模型中，后续驱动注册的时候就可以匹配到了
platform_device_put(dev);
of_reserved_mem_device_release(&dev->dev);
return NULL;
}

return dev;
}