三、Uboot驱动模型 #

typedef struct global_data {
...
#ifdef CONFIG_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 */
#endif
...
}

/**
 * struct uclass - a U-Boot drive class, collecting together similar drivers
 *
 * A uclass provides an interface to a particular function, which is
 * implemented by one or more drivers. Every driver belongs to a uclass even
 * if it is the only driver in that uclass. An example uclass is GPIO, which
 * provides the ability to change read inputs, set and clear outputs, etc.
 * There may be drivers for on-chip SoC GPIO banks, I2C GPIO expanders and
 * PMIC IO lines, all made available in a unified way through the uclass.
 *
 * @priv: Private data for this uclass
 * @uc_drv: The driver for the uclass itself, not to be confused with a
 * 'struct driver'
 * @dev_head: List of devices in this uclass (devices are attached to their
 * uclass when their bind method is called)
 * @sibling_node: Next uclass in the linked list of uclasses
 */
struct uclass {
    void *priv;								//uclass的私有数据
    struct uclass_driver *uc_drv;			//uclass类的操作函数集合
    struct list_head dev_head;				//该uclass的所有设备
    struct list_head sibling_node;			//下一个uclass的节点
};

int uclass_get(enum uclass_id key, struct uclass **ucp);
// 从gd->uclass_root链表获取对应的ucla ss

/**
 * struct uclass_driver - Driver for the uclass
 *
 * A uclass_driver provides a consistent interface to a set of related
 * drivers.
 */
struct uclass_driver {
    const char *name; // 该uclass_driver的命令
    enum uclass_id id; // 对应的uclass id
/* 以下函数指针主要是调用时机的区别 */
    int (*post_bind)(struct udevice *dev); // 在udevice被绑定到该uclass之后调用
    int (*pre_unbind)(struct udevice *dev); // 在udevice被解绑出该uclass之前调用
    int (*pre_probe)(struct udevice *dev); // 在该uclass的一个udevice进行probe之前调用
    int (*post_probe)(struct udevice *dev); // 在该uclass的一个udevice进行probe之后调用
    int (*pre_remove)(struct udevice *dev);// 在该uclass的一个udevice进行remove之前调用
    int (*child_post_bind)(struct udevice *dev); // 在该uclass的一个udevice的一个子设备被绑定到该udevice之后调用
    int (*child_pre_probe)(struct udevice *dev); // 在该uclass的一个udevice的一个子设备进行probe之前调用
    int (*init)(struct uclass *class); // 安装该uclass的时候调用
    int (*destroy)(struct uclass *class); // 销毁该uclass的时候调用
    int priv_auto_alloc_size; // 需要为对应的uclass分配多少私有数据
    int per_device_auto_alloc_size; //
    int per_device_platdata_auto_alloc_size; //
    int per_child_auto_alloc_size; //
    int per_child_platdata_auto_alloc_size;  //
    const void *ops; //操作集合
    uint32_t flags;   // 标识为
};

UCLASS_DRIVER(pinctrl) = {
    .id = UCLASS_PINCTRL,
    .post_bind = pinctrl_post_bind,
    .flags = DM_UC_FLAG_SEQ_ALIAS,
    .name = "pinctrl",
};

/* Declare a new uclass_driver */
#define UCLASS_DRIVER(__name)						\
    ll_entry_declare(struct uclass_driver, __name, uclass)

#define ll_entry_declare(_type, _name, _list)				\
    _type _u_boot_list_2_##_list##_2_##_name __aligned(4)		\
            __attribute__((unused,				\
            section(".u_boot_list_2_"#_list"_2_"#_name)))

struct uclass_driver _u_boot_list_2_uclass_2_pinctrl = {
    .id = UCLASS_PINCTRL,
    .post_bind = pinctrl_post_bind,
    .flags = DM_UC_FLAG_SEQ_ALIAS,
    .name = "pinctrl",
}
//同时存放在段._u_boot_list_2_uclass_2_pinctrl中，也就是section段的内容

struct uclass_driver *uclass =
        ll_entry_start(struct uclass_driver, uclass); 
// 会根据.u_boot_list_2_uclass_1的段地址来得到uclass_driver table的地址

    const int n_ents = ll_entry_count(struct uclass_driver, uclass);
// 获得uclass_driver table的长度

struct uclass_driver *lists_uclass_lookup(enum uclass_id id)
// 从uclass_driver table中获取uclass id为id的uclass_driver。

enum uclass_id {
    /* These are used internally by driver model */
    UCLASS_ROOT = 0,
    UCLASS_DEMO,
    UCLASS_TEST,
    UCLASS_TEST_FDT,
    UCLASS_TEST_BUS,
    UCLASS_TEST_PROBE,
......
    /* U-Boot uclasses start here - in alphabetical order */
    UCLASS_ACPI_PMC,	/* (x86) Power-management controller (PMC) */
    UCLASS_ADC,		/* Analog-to-digital converter */
    UCLASS_AHCI,		/* SATA disk controller */
    UCLASS_AUDIO_CODEC,	/* Audio codec with control and data path */
    UCLASS_AXI,		/* AXI bus */
    UCLASS_BLK,		/* Block device */
    UCLASS_BOARD,		/* Device information from hardware */
......
};

/**
 * struct udevice - An instance of a driver
 *
 * This holds information about a device, which is a driver bound to a
 * particular port or peripheral (essentially a driver instance).
 *
 */
struct udevice {
    const struct driver *driver;		//device 对应的driver
    const char *name;					//device 的名称
    void *platdata;
    void *parent_platdata;
    void *uclass_platdata;
    ofnode node;						//设备树节点
    ulong driver_data;
    struct udevice *parent;				//父设备
    void *priv;							// 私有数据的指针
    struct uclass *uclass;				//驱动所属的uclass
    void *uclass_priv;
    void *parent_priv;
    struct list_head uclass_node;
    struct list_head child_head;
    struct list_head sibling_node;
    uint32_t flags;
    int req_seq;
    int seq;
#ifdef CONFIG_DEVRES
    struct list_head devres_head;
#endif
};

#define uclass_foreach_dev(pos, uc) \
    list_for_each_entry(pos, &uc->dev_head, uclass_node)

#define uclass_foreach_dev_safe(pos, next, uc)  \
    list_for_each_entry_safe(pos, next, &uc->dev_head, uclass_node)

int uclass_get_device(enum uclass_id id, int index, struct udevice **devp); // 通过索引从uclass中获取udevice
int uclass_get_device_by_name(enum uclass_id id, const char *name, // 通过设备名从uclass中获取udevice
                  struct udevice **devp);
int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp);
int uclass_get_device_by_of_offset(enum uclass_id id, int node,
                   struct udevice **devp);
int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
                 const char *name, struct udevice **devp);
int uclass_first_device(enum uclass_id id, struct udevice **devp);
int uclass_first_device_err(enum uclass_id id, struct udevice **devp);
int uclass_next_device(struct udevice **devp);
int uclass_resolve_seq(struct udevice *dev);

struct driver {
    char *name;							//驱动名称
    enum uclass_id id;					//驱动所对应的uclass_id	
    const struct udevice_id *of_match;	//匹配函数
    int (*bind)(struct udevice *dev);	//绑定函数
    int (*probe)(struct udevice *dev);	//注册函数
    int (*remove)(struct udevice *dev);
    int (*unbind)(struct udevice *dev);
    int (*ofdata_to_platdata)(struct udevice *dev);
    int (*child_post_bind)(struct udevice *dev);
    int (*child_pre_probe)(struct udevice *dev);
    int (*child_post_remove)(struct udevice *dev);
    int priv_auto_alloc_size;
    int platdata_auto_alloc_size;
    int per_child_auto_alloc_size;
    int per_child_platdata_auto_alloc_size;
    const void *ops;	/* driver-specific operations */
    uint32_t flags;
#if CONFIG_IS_ENABLED(ACPIGEN)
    struct acpi_ops *acpi_ops;
#endif
};

U_BOOT_DRIVER(xxx_pinctrl) = {
    .name		= "xxx_pinctrl",
    .id		= UCLASS_PINCTRL,
    .of_match	= arobot_pinctrl_match,
    .priv_auto_alloc_size = sizeof(struct xxx_pinctrl),
    .ops		= &arobot_pinctrl_ops,
    .probe		= arobot_v2s_pinctrl_probe,
    .remove 	= arobot_v2s_pinctrl_remove,
};

/* Declare a new U-Boot driver */
#define U_BOOT_DRIVER(__name)						\
    ll_entry_declare(struct driver, __name, driver)


#define ll_entry_declare(_type, _name, _list)				\
    _type _u_boot_list_2_##_list##_2_##_name __aligned(4)		\
            __attribute__((unused,				\
            section(".u_boot_list_2_"#_list"_2_"#_name)))

struct driver _u_boot_list_2_driver_2_xxx_pinctrl = {
    .name		= "xxx_pinctrl",
    .id		= UCLASS_PINCTRL,
    .of_match	= arobot_pinctrl_match,
    .priv_auto_alloc_size = sizeof(struct xxx_pinctrl),
    .ops		= &arobot_pinctrl_ops,
    .probe		= arobot_v2s_pinctrl_probe,
    .remove 	= arobot_v2s_pinctrl_remove,
}
//同时存放在段._u_boot_list_2_driver_2_xxx_pinctrl中

 
/*先获取driver table 表*/
struct driver *drv =
        ll_entry_start(struct driver, driver);		// 会根据.u_boot_list_2_driver_1的段地址来得到uclass_driver table的地址
  const int n_ents = ll_entry_count(struct driver, driver);		// 通过.u_boot_list_2_driver_3的段地址 减去 .u_boot_list_2_driver_1的段地址 获得driver table的长度

/*遍历所有的driver*/
struct driver *lists_driver_lookup_name(const char *name)	// 从driver table中获取名字为name的driver。

/**
 * struct udevice - An instance of a driver
 *
 * This holds information about a device, which is a driver bound to a
 * particular port or peripheral (essentially a driver instance).
 *
 */

/**
 * struct uclass - a U-Boot drive class, collecting together similar drivers
 *
 */


/**
 * struct uclass_driver - Driver for the uclass
 *
 * A uclass_driver provides a consistent interface to a set of related
 * drivers.
 *
 */

static int initf_dm(void)
{
#if defined(CONFIG_DM) && CONFIG_VAL(SYS_MALLOC_F_LEN)
    int ret;

    bootstage_start(BOOTSTAGE_ID_ACCUM_DM_F, "dm_f");
    ret = dm_init_and_scan(true);					//这里为true
    bootstage_accum(BOOTSTAGE_ID_ACCUM_DM_F);
    if (ret)
        return ret;
#endif
#ifdef CONFIG_TIMER_EARLY
    ret = dm_timer_init();
    if (ret)
        return ret;
#endif

    return 0;
}

static int initr_dm(void)
{
    int ret;

    /* Save the pre-reloc driver model and start a new one */
    gd->dm_root_f = gd->dm_root;
    gd->dm_root = NULL;
#ifdef CONFIG_TIMER
    gd->timer = NULL;
#endif
    bootstage_start(BOOTSTAGE_ID_ACCUM_DM_R, "dm_r");
    ret = dm_init_and_scan(false);						//这里为false
    bootstage_accum(BOOTSTAGE_ID_ACCUM_DM_R);
    if (ret)
        return ret;

    return 0;
}

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);

#if defined(CONFIG_NEEDS_MANUAL_RELOC)
    fix_drivers();
    fix_uclass();
    fix_devices();
#endif

    ret = device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST);		//查找root_driver驱动，并绑定
    if (ret)
        return ret;
#if CONFIG_IS_ENABLED(OF_CONTROL)
# if CONFIG_IS_ENABLED(OF_LIVE)
    if (of_live)
        DM_ROOT_NON_CONST->node = np_to_ofnode(gd->of_root);
    else
#endif
        DM_ROOT_NON_CONST->node = offset_to_ofnode(0);
#endif
    ret = device_probe(DM_ROOT_NON_CONST);										//probe激活root_driver驱动
    if (ret)
        return ret;

    return 0;
}

int lists_bind_fdt(struct udevice *parent, ofnode node, struct udevice **devp,
           bool pre_reloc_only)
{
    struct driver *driver = ll_entry_start(struct driver, driver);				//获得驱动列表的起始地址
    const int n_ents = ll_entry_count(struct driver, driver);					//获得驱动列表的总数量
    const struct udevice_id *id;
    struct driver *entry;
    struct udevice *dev;
    bool found = false;
    const char *name, *compat_list, *compat;
    int compat_length, i;
    int result = 0;
    int ret = 0;

    if (devp)
        *devp = NULL;
    name = ofnode_get_name(node);
    log_debug("bind node %s\n", name);

    compat_list = ofnode_get_property(node, "compatible", &compat_length);		//得到compatible属性，用于匹配driver驱动
    if (!compat_list) {
        if (compat_length == -FDT_ERR_NOTFOUND) {
            log_debug("Device '%s' has no compatible string\n",
                  name);
            return 0;
        }

        dm_warn("Device tree error at node '%s'\n", name);
        return compat_length;
    }

    /*
     * Walk through the compatible string list, attempting to match each
     * compatible string in order such that we match in order of priority
     * from the first string to the last.
     */
    for (i = 0; i < compat_length; i += strlen(compat) + 1) {
        compat = compat_list + i;
        log_debug("   - attempt to match compatible string '%s'\n",
              compat);

        for (entry = driver; entry != driver + n_ents; entry++) {				//循环判断所有驱动是否匹配	
            ret = driver_check_compatible(entry->of_match, &id,
                              compat);
            if (!ret)
                break;
        }
        if (entry == driver + n_ents)
            continue;

        if (pre_reloc_only) {
            if (!ofnode_pre_reloc(node) &&
                !(entry->flags & DM_FLAG_PRE_RELOC)) {
                log_debug("Skipping device pre-relocation\n");
                return 0;
            }
        }

        log_debug("   - found match at '%s': '%s' matches '%s'\n",
              entry->name, entry->of_match->compatible,
              id->compatible);
        ret = device_bind_with_driver_data(parent, entry, name,
                           id->data, node, &dev);								//该函数，用于创建udevice对象，并与查找到的driver绑定
        if (ret == -ENODEV) {
            log_debug("Driver '%s' refuses to bind\n", entry->name);
            continue;
        }
        if (ret) {
            dm_warn("Error binding driver '%s': %d\n", entry->name,
                ret);
            return ret;
        } else {
            found = true;
            if (devp)
                *devp = dev;
        }
        break;
    }

    if (!found && !result && ret != -ENODEV)
        log_debug("No match for node '%s'\n", name);

    return result;
}

int device_probe(struct udevice *dev)
{
    const struct driver *drv;
    int ret;
    int seq;

    if (!dev)
        return -EINVAL;

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

    drv = dev->driver;													//获取driver
    assert(drv);

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

    /* Ensure all parents are probed */
    if (dev->parent) {													//父设备probe
        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 (CONFIG_IS_ENABLED(POWER_DOMAIN) && dev->parent &&
        (device_get_uclass_id(dev) != UCLASS_POWER_DOMAIN) &&
        !(drv->flags & DM_FLAG_DEFAULT_PD_CTRL_OFF)) {
        ret = dev_power_domain_on(dev);
        if (ret)
            goto fail;
    }

    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;
    }

    /* Only handle devices that have a valid ofnode */
    if (dev_of_valid(dev)) {
        /*
         * Process 'assigned-{clocks/clock-parents/clock-rates}'
         * properties
         */
        ret = clk_set_defaults(dev, 0);
        if (ret)
            goto fail;
    }

    if (drv->probe) {												
        ret = drv->probe(dev);										//调用驱动的probe
        if (ret)
            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;
}

int uclass_get(enum uclass_id id, struct uclass **ucp)
{
    struct uclass *uc;

    *ucp = NULL;
    uc = uclass_find(id);
    if (!uc)
        return uclass_add(id, ucp);
    *ucp = uc;

    return 0;
}

static int uclass_add(enum uclass_id id, struct uclass **ucp)
{
    struct uclass_driver *uc_drv;
    struct uclass *uc;
    int ret;

    *ucp = NULL;
    uc_drv = lists_uclass_lookup(id);					//根据uclass_id查找到对应的driver
    if (!uc_drv) {
        debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
              id);
        /*
         * Use a strange error to make this case easier to find. When
         * a uclass is not available it can prevent driver model from
         * starting up and this failure is otherwise hard to debug.
         */
        return -EPFNOSUPPORT;
    }
    uc = calloc(1, sizeof(*uc));
    if (!uc)
        return -ENOMEM;
    if (uc_drv->priv_auto_alloc_size) {
        uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
        if (!uc->priv) {
            ret = -ENOMEM;
            goto fail_mem;
        }
    }
    uc->uc_drv = uc_drv;												//uclass与uclass_driver绑定
    INIT_LIST_HEAD(&uc->sibling_node);
    INIT_LIST_HEAD(&uc->dev_head);
    list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);				//添加到global_data->uclass_root链表中

    if (uc_drv->init) {
        ret = uc_drv->init(uc);
        if (ret)
            goto fail;
    }

    *ucp = uc;

    return 0;
fail:
    if (uc_drv->priv_auto_alloc_size) {
        free(uc->priv);
        uc->priv = NULL;
    }
    list_del(&uc->sibling_node);
fail_mem:
    free(uc);

    return ret;
}