【u-boot】u-boot中initf_dm()函数执行流程（转）

前部分设备模型初始化

为了便于阅读，删掉部分代码，只留关键的过程：

static int initf_dm(void)
{
    int ret;
    ret = dm_init_and_scan(true);
    if (ret)
        return ret;
    return 0;
}

该函数调用了 dm_init_and_scan();并且传入的参数为true，uboot中对该函数的注释如下：

/**
 * dm_init_and_scan() - Initialise Driver Model structures and scan for devices
 *
 * This function initialises the roots of the driver tree and uclass trees,
 * then scans and binds available devices from platform data and the FDT.
 * This calls dm_init() to set up Driver Model structures.
 *
 * @pre_reloc_only: If true, bind only nodes with special devicetree properties,
 * or drivers with the DM_FLAG_PRE_RELOC flag. If false bind all drivers.
 * @return 0 if OK, -ve on error
 */

下面看具体的执行过程，删除参数检查等相关代码，如下图：

int dm_init_and_scan(bool pre_reloc_only)
{
   ret = dm_init(IS_ENABLED(CONFIG_OF_LIVE));
   ret = dm_scan_platdata(pre_reloc_only);
   ret = dm_extended_scan_fdt(gd->fdt_blob, pre_reloc_only);
   ret = dm_scan_other(pre_reloc_only);
}

该函数一共调用了四个函数，首先看第一个函数 dm_init()，该函数中涉及到关键的结构体struct global_data，该结构体的具体作用此处不做展开，只看结构体中和DM相关的部分

struct udevice    *dm_root;    /* Root instance for Driver Model */
    struct udevice    *dm_root_f;    /* Pre-relocation root instance */
    struct list_head uclass_root;    /* Head of core tree */

#define DM_ROOT_NON_CONST        (((gd_t *)gd)->dm_root)
    #define DM_UCLASS_ROOT_NON_CONST    (((gd_t *)gd)->uclass_root)

删除参数检查和返回值检查等代码，注释和实现过程如下：

/**
 * dm_init() - Initialise Driver Model structures
 * This function will initialize roots of driver tree and class tree.
 * This needs to be called before anything uses the DM
 * @of_live:    Enable live device tree
 * @return 0 if OK, -ve on error
 */
int dm_init(bool of_live)
{
    int ret;
    if (gd->dm_root) {
        dm_warn("Virtual root driver already exists!\n");
        return -EINVAL;
    }
    INIT_LIST_HEAD(&DM_UCLASS_ROOT_NON_CONST);

ret = device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST);

#if CONFIG_IS_ENABLED(OF_CONTROL)
        DM_ROOT_NON_CONST->node = offset_to_ofnode(0);
#endif
    ret = device_probe(DM_ROOT_NON_CONST);
    return 0;
}

该函数又调用了device_bind_by_name()函数

/**
* device_bind_by_name: Create a device and bind it to a driver
*
* This is a helper function used to bind devices which do not use device
* tree.
*
* @parent: Pointer to device's parent
* @pre_reloc_only: If true, bind the driver only if its DM_FLAG_PRE_RELOC flag
* is set. If false bind the driver always.
* @info: Name and platdata for this device
* @devp: if non-NULL, returns a pointer to the bound device
* @return 0 if OK, -ve on error
*/
int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
           const struct driver_info *info, struct udevice **devp)
{
   struct driver *drv;
   uint platdata_size = 0;

drv = lists_driver_lookup_name(info->name);
   if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
       return -EPERM;

#if CONFIG_IS_ENABLED(OF_PLATDATA)
   platdata_size = info->platdata_size;
#endif
   return device_bind_common(parent, drv, info->name,
           (void *)info->platdata, 0, ofnode_null(), platdata_size,
           devp);
}

该函数最终调用了device_bind_common()函数

static int device_bind_common(struct udevice *parent, const struct driver *drv,
                  const char *name, void *platdata,
                  ulong driver_data, ofnode node,
                  uint of_platdata_size, struct udevice **devp)
{
    struct udevice *dev;
    struct uclass *uc;
    int size, ret = 0;

if (devp)
        *devp = NULL;
    if (!name)
        return -EINVAL;

ret = uclass_get(drv->id, &uc);
    if (ret) {
        debug("Missing uclass for driver %s\n", drv->name);
        return ret;
    }

dev = calloc(1, sizeof(struct udevice));
    if (!dev)
        return -ENOMEM;

INIT_LIST_HEAD(&dev->sibling_node);
    INIT_LIST_HEAD(&dev->child_head);
    INIT_LIST_HEAD(&dev->uclass_node);
#ifdef CONFIG_DEVRES
    INIT_LIST_HEAD(&dev->devres_head);
#endif
    dev->platdata = platdata;
    dev->driver_data = driver_data;
    dev->name = name;
    dev->node = node;
    dev->parent = parent;
    dev->driver = drv;
    dev->uclass = uc;

dev->seq = -1;
    dev->req_seq = -1;
    if (CONFIG_IS_ENABLED(DM_SEQ_ALIAS) &&
        (uc->uc_drv->flags & DM_UC_FLAG_SEQ_ALIAS)) {
        /*
         * Some devices, such as a SPI bus, I2C bus and serial ports
         * are numbered using aliases.
         *
         * This is just a 'requested' sequence, and will be
         * resolved (and ->seq updated) when the device is probed.
         */
        if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
            if (uc->uc_drv->name && ofnode_valid(node))
                dev_read_alias_seq(dev, &dev->req_seq);
        } else {
            dev->req_seq = uclass_find_next_free_req_seq(drv->id);
        }
    }

if (drv->platdata_auto_alloc_size) {
        bool alloc = !platdata;

if (CONFIG_IS_ENABLED(OF_PLATDATA)) {
            if (of_platdata_size) {
                dev->flags |= DM_FLAG_OF_PLATDATA;
                if (of_platdata_size <
                        drv->platdata_auto_alloc_size)
                    alloc = true;
            }
        }
        if (alloc) {
            dev->flags |= DM_FLAG_ALLOC_PDATA;
            dev->platdata = calloc(1,
                           drv->platdata_auto_alloc_size);
            if (!dev->platdata) {
                ret = -ENOMEM;
                goto fail_alloc1;
            }
            if (CONFIG_IS_ENABLED(OF_PLATDATA) && platdata) {
                memcpy(dev->platdata, platdata,
                       of_platdata_size);
            }
        }
    }

size = uc->uc_drv->per_device_platdata_auto_alloc_size;
    if (size) {
        dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA;
        dev->uclass_platdata = calloc(1, size);
        if (!dev->uclass_platdata) {
            ret = -ENOMEM;
            goto fail_alloc2;
        }
    }

if (parent) {
        size = parent->driver->per_child_platdata_auto_alloc_size;
        if (!size) {
            size = parent->uclass->uc_drv->
                    per_child_platdata_auto_alloc_size;
        }
        if (size) {
            dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA;
            dev->parent_platdata = calloc(1, size);
            if (!dev->parent_platdata) {
                ret = -ENOMEM;
                goto fail_alloc3;
            }
        }
    }

/* put dev into parent's successor list */
    if (parent)
        list_add_tail(&dev->sibling_node, &parent->child_head);

ret = uclass_bind_device(dev);
    if (ret)
        goto fail_uclass_bind;

/* if we fail to bind we remove device from successors and free it */
    if (drv->bind) {
        ret = drv->bind(dev);
        if (ret)
            goto fail_bind;
    }
    if (parent && parent->driver->child_post_bind) {
        ret = parent->driver->child_post_bind(dev);
        if (ret)
            goto fail_child_post_bind;
    }
    if (uc->uc_drv->post_bind) {
        ret = uc->uc_drv->post_bind(dev);
        if (ret)
            goto fail_uclass_post_bind;
    }

if (parent)
        pr_debug("Bound device %s to %s\n", dev->name, parent->name);
    if (devp)
        *devp = dev;

dev->flags |= DM_FLAG_BOUND;

return 0;

fail_uclass_post_bind:
    /* There is no child unbind() method, so no clean-up required */
fail_child_post_bind:
    if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
        if (drv->unbind && drv->unbind(dev)) {
            dm_warn("unbind() method failed on dev '%s' on error path\n",
                dev->name);
        }
    }

fail_bind:
    if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
        if (uclass_unbind_device(dev)) {
            dm_warn("Failed to unbind dev '%s' on error path\n",
                dev->name);
        }
    }
fail_uclass_bind:
    if (CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)) {
        list_del(&dev->sibling_node);
        if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) {
            free(dev->parent_platdata);
            dev->parent_platdata = NULL;
        }
    }
fail_alloc3:
    if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) {
        free(dev->uclass_platdata);
        dev->uclass_platdata = NULL;
    }
fail_alloc2:
    if (dev->flags & DM_FLAG_ALLOC_PDATA) {
        free(dev->platdata);
        dev->platdata = NULL;
    }
fail_alloc1:
    devres_release_all(dev);

free(dev);

return ret;
}

在dm_init()函数中，最后执行的是device_probe()函数

/**
 * device_probe() - Probe a device, activating it
 *
 * Activate a device so that it is ready for use. All its parents are probed
 * first.
 *
 * @dev: Pointer to device to probe
 * @return 0 if OK, -ve on error
 */
int device_probe(struct udevice *dev)
{
    struct power_domain pd;
    const struct driver *drv;
    int size = 0;
    int ret;
    int seq;

if (!dev)
        return -EINVAL;

if (dev->flags & DM_FLAG_ACTIVATED)
        return 0;

drv = dev->driver;
    assert(drv);

/* Allocate private data if requested and not reentered */
    if (drv->priv_auto_alloc_size && !dev->priv) {
        dev->priv = alloc_priv(drv->priv_auto_alloc_size, drv->flags);
        if (!dev->priv) {
            ret = -ENOMEM;
            goto fail;
        }
    }
    /* Allocate private data if requested and not reentered */
    size = dev->uclass->uc_drv->per_device_auto_alloc_size;
    if (size && !dev->uclass_priv) {
        dev->uclass_priv = alloc_priv(size,
                          dev->uclass->uc_drv->flags);
        if (!dev->uclass_priv) {
            ret = -ENOMEM;
            goto fail;
        }
    }

/* Ensure all parents are probed */
    if (dev->parent) {
        size = dev->parent->driver->per_child_auto_alloc_size;
        if (!size) {
            size = dev->parent->uclass->uc_drv->
                    per_child_auto_alloc_size;
        }
        if (size && !dev->parent_priv) {
            dev->parent_priv = alloc_priv(size, drv->flags);
            if (!dev->parent_priv) {
                ret = -ENOMEM;
                goto fail;
            }
        }

ret = device_probe(dev->parent);
        if (ret)
            goto fail;

/*
         * The device might have already been probed during
         * the call to device_probe() on its parent device
         * (e.g. PCI bridge devices). Test the flags again
         * so that we don't mess up the device.
         */
        if (dev->flags & DM_FLAG_ACTIVATED)
            return 0;
    }

seq = uclass_resolve_seq(dev);
    if (seq < 0) {
        ret = seq;
        goto fail;
    }
    dev->seq = seq;

dev->flags |= DM_FLAG_ACTIVATED;

/*
     * Process pinctrl for everything except the root device, and
     * continue regardless of the result of pinctrl. Don't process pinctrl
     * settings for pinctrl devices since the device may not yet be
     * probed.
     */
    if (dev->parent && device_get_uclass_id(dev) != UCLASS_PINCTRL)
        pinctrl_select_state(dev, "default");

if (dev->parent && device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) {
        if (!power_domain_get(dev, &pd))
            power_domain_on(&pd);
    }

ret = uclass_pre_probe_device(dev);
    if (ret)
        goto fail;

if (dev->parent && dev->parent->driver->child_pre_probe) {
        ret = dev->parent->driver->child_pre_probe(dev);
        if (ret)
            goto fail;
    }

if (drv->ofdata_to_platdata && dev_has_of_node(dev)) {
        ret = drv->ofdata_to_platdata(dev);
        if (ret)
            goto fail;
    }

/* Process 'assigned-{clocks/clock-parents/clock-rates}' properties */
    ret = clk_set_defaults(dev);
    if (ret)
        goto fail;

if (drv->probe) {
        ret = drv->probe(dev);
        if (ret) {
            dev->flags &= ~DM_FLAG_ACTIVATED;
            goto fail;
        }
    }

ret = uclass_post_probe_device(dev);
    if (ret)
        goto fail_uclass;

if (dev->parent && device_get_uclass_id(dev) == UCLASS_PINCTRL)
        pinctrl_select_state(dev, "default");

return 0;
fail_uclass:
    if (device_remove(dev, DM_REMOVE_NORMAL)) {
        dm_warn("%s: Device '%s' failed to remove on error path\n",
            __func__, dev->name);
    }
fail:
    dev->flags &= ~DM_FLAG_ACTIVATED;

dev->seq = -1;
    device_free(dev);

return ret;
}
————————————————
版权声明：本文为CSDN博主「liuduanfei」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/A_orz_/article/details/100117065