[people/ms/u-boot.git] / drivers / core / uclass.c

/*
 * Copyright (c) 2013 Google, Inc
 *
 * (C) Copyright 2012
 * Pavel Herrmann <morpheus.ibis@gmail.com>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <malloc.h>
#include <dm/device.h>
#include <dm/device-internal.h>
#include <dm/lists.h>
#include <dm/uclass.h>
#include <dm/uclass-internal.h>
#include <dm/util.h>

DECLARE_GLOBAL_DATA_PTR;

struct uclass *uclass_find(enum uclass_id key)
{
	struct uclass *uc;

	if (!gd->dm_root)
		return NULL;
	/*
	 * TODO(sjg@chromium.org): Optimise this, perhaps moving the found
	 * node to the start of the list, or creating a linear array mapping
	 * id to node.
	 */
	list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
		if (uc->uc_drv->id == key)
			return uc;
	}

	return NULL;
}

/**
 * uclass_add() - Create new uclass in list
 * @id: Id number to create
 * @ucp: Returns pointer to uclass, or NULL on error
 * @return 0 on success, -ve on error
 *
 * The new uclass is added to the list. There must be only one uclass for
 * each id.
 */
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);
	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;
	INIT_LIST_HEAD(&uc->sibling_node);
	INIT_LIST_HEAD(&uc->dev_head);
	list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);

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

int uclass_destroy(struct uclass *uc)
{
	struct uclass_driver *uc_drv;
	struct udevice *dev;
	int ret;

	/*
	 * We cannot use list_for_each_entry_safe() here. If a device in this
	 * uclass has a child device also in this uclass, it will be also be
	 * unbound (by the recursion in the call to device_unbind() below).
	 * We can loop until the list is empty.
	 */
	while (!list_empty(&uc->dev_head)) {
		dev = list_first_entry(&uc->dev_head, struct udevice,
				       uclass_node);
		ret = device_remove(dev, DM_REMOVE_NORMAL);
		if (ret)
			return ret;
		ret = device_unbind(dev);
		if (ret)
			return ret;
	}

	uc_drv = uc->uc_drv;
	if (uc_drv->destroy)
		uc_drv->destroy(uc);
	list_del(&uc->sibling_node);
	if (uc_drv->priv_auto_alloc_size)
		free(uc->priv);
	free(uc);

	return 0;
}

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

const char *uclass_get_name(enum uclass_id id)
{
	struct uclass *uc;

	if (uclass_get(id, &uc))
		return NULL;
	return uc->uc_drv->name;
}

int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
{
	struct uclass *uc;
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = uclass_get(id, &uc);
	if (ret)
		return ret;
	if (list_empty(&uc->dev_head))
		return -ENODEV;

	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
		if (!index--) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}

int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
{
	struct uclass *uc;
	int ret;

	*devp = NULL;
	ret = uclass_get(id, &uc);
	if (ret)
		return ret;
	if (list_empty(&uc->dev_head))
		return 0;

	*devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);

	return 0;
}

int uclass_find_next_device(struct udevice **devp)
{
	struct udevice *dev = *devp;

	*devp = NULL;
	if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
		return 0;

	*devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);

	return 0;
}

int uclass_find_device_by_name(enum uclass_id id, const char *name,
			       struct udevice **devp)
{
	struct uclass *uc;
	struct udevice *dev;
	int ret;

	*devp = NULL;
	if (!name)
		return -EINVAL;
	ret = uclass_get(id, &uc);
	if (ret)
		return ret;

	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
		if (!strncmp(dev->name, name, strlen(name))) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}

int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
			      bool find_req_seq, struct udevice **devp)
{
	struct uclass *uc;
	struct udevice *dev;
	int ret;

	*devp = NULL;
	debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq);
	if (seq_or_req_seq == -1)
		return -ENODEV;
	ret = uclass_get(id, &uc);
	if (ret)
		return ret;

	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
		debug("   - %d %d '%s'\n", dev->req_seq, dev->seq, dev->name);
		if ((find_req_seq ? dev->req_seq : dev->seq) ==
				seq_or_req_seq) {
			*devp = dev;
			debug("   - found\n");
			return 0;
		}
	}
	debug("   - not found\n");

	return -ENODEV;
}

int uclass_find_device_by_of_offset(enum uclass_id id, int node,
				    struct udevice **devp)
{
	struct uclass *uc;
	struct udevice *dev;
	int ret;

	*devp = NULL;
	if (node < 0)
		return -ENODEV;
	ret = uclass_get(id, &uc);
	if (ret)
		return ret;

	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
		if (dev_of_offset(dev) == node) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}

int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node,
				 struct udevice **devp)
{
	struct uclass *uc;
	struct udevice *dev;
	int ret;

	*devp = NULL;
	if (!ofnode_valid(node))
		return -ENODEV;
	ret = uclass_get(id, &uc);
	if (ret)
		return ret;

	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
		if (ofnode_equal(dev_ofnode(dev), node)) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}

#if CONFIG_IS_ENABLED(OF_CONTROL)
static int uclass_find_device_by_phandle(enum uclass_id id,
					 struct udevice *parent,
					 const char *name,
					 struct udevice **devp)
{
	struct udevice *dev;
	struct uclass *uc;
	int find_phandle;
	int ret;

	*devp = NULL;
	find_phandle = dev_read_u32_default(parent, name, -1);
	if (find_phandle <= 0)
		return -ENOENT;
	ret = uclass_get(id, &uc);
	if (ret)
		return ret;

	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
		uint phandle;

		phandle = dev_read_phandle(dev);

		if (phandle == find_phandle) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}
#endif

int uclass_get_device_by_driver(enum uclass_id id,
				const struct driver *find_drv,
				struct udevice **devp)
{
	struct udevice *dev;
	struct uclass *uc;
	int ret;

	ret = uclass_get(id, &uc);
	if (ret)
		return ret;

	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
		if (dev->driver == find_drv)
			return uclass_get_device_tail(dev, 0, devp);
	}

	return -ENODEV;
}

int uclass_get_device_tail(struct udevice *dev, int ret, struct udevice **devp)
{
	if (ret)
		return ret;

	assert(dev);
	ret = device_probe(dev);
	if (ret)
		return ret;

	*devp = dev;

	return 0;
}

int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = uclass_find_device(id, index, &dev);
	return uclass_get_device_tail(dev, ret, devp);
}

int uclass_get_device_by_name(enum uclass_id id, const char *name,
			      struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = uclass_find_device_by_name(id, name, &dev);
	return uclass_get_device_tail(dev, ret, devp);
}

int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = uclass_find_device_by_seq(id, seq, false, &dev);
	if (ret == -ENODEV) {
		/*
		 * We didn't find it in probed devices. See if there is one
		 * that will request this seq if probed.
		 */
		ret = uclass_find_device_by_seq(id, seq, true, &dev);
	}
	return uclass_get_device_tail(dev, ret, devp);
}

int uclass_get_device_by_of_offset(enum uclass_id id, int node,
				   struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = uclass_find_device_by_of_offset(id, node, &dev);
	return uclass_get_device_tail(dev, ret, devp);
}

int uclass_get_device_by_ofnode(enum uclass_id id, ofnode node,
				struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = uclass_find_device_by_ofnode(id, node, &dev);

	return uclass_get_device_tail(dev, ret, devp);
}

#if CONFIG_IS_ENABLED(OF_CONTROL)
int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
				 const char *name, struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = uclass_find_device_by_phandle(id, parent, name, &dev);
	return uclass_get_device_tail(dev, ret, devp);
}
#endif

int uclass_first_device(enum uclass_id id, struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = uclass_find_first_device(id, &dev);
	if (!dev)
		return 0;
	return uclass_get_device_tail(dev, ret, devp);
}

int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
{
	int ret;

	ret = uclass_first_device(id, devp);
	if (ret)
		return ret;
	else if (!*devp)
		return -ENODEV;

	return 0;
}

int uclass_next_device(struct udevice **devp)
{
	struct udevice *dev = *devp;
	int ret;

	*devp = NULL;
	ret = uclass_find_next_device(&dev);
	if (!dev)
		return 0;
	return uclass_get_device_tail(dev, ret, devp);
}

int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
{
	int ret;

	*devp = NULL;
	ret = uclass_find_first_device(id, devp);
	if (ret)
		return ret;
	if (!*devp)
		return 0;

	return device_probe(*devp);
}

int uclass_next_device_check(struct udevice **devp)
{
	int ret;

	ret = uclass_find_next_device(devp);
	if (ret)
		return ret;
	if (!*devp)
		return 0;

	return device_probe(*devp);
}

int uclass_bind_device(struct udevice *dev)
{
	struct uclass *uc;
	int ret;

	uc = dev->uclass;
	list_add_tail(&dev->uclass_node, &uc->dev_head);

	if (dev->parent) {
		struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;

		if (uc_drv->child_post_bind) {
			ret = uc_drv->child_post_bind(dev);
			if (ret)
				goto err;
		}
	}

	return 0;
err:
	/* There is no need to undo the parent's post_bind call */
	list_del(&dev->uclass_node);

	return ret;
}

#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
int uclass_unbind_device(struct udevice *dev)
{
	struct uclass *uc;
	int ret;

	uc = dev->uclass;
	if (uc->uc_drv->pre_unbind) {
		ret = uc->uc_drv->pre_unbind(dev);
		if (ret)
			return ret;
	}

	list_del(&dev->uclass_node);
	return 0;
}
#endif

int uclass_resolve_seq(struct udevice *dev)
{
	struct udevice *dup;
	int seq;
	int ret;

	assert(dev->seq == -1);
	ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq,
					false, &dup);
	if (!ret) {
		dm_warn("Device '%s': seq %d is in use by '%s'\n",
			dev->name, dev->req_seq, dup->name);
	} else if (ret == -ENODEV) {
		/* Our requested sequence number is available */
		if (dev->req_seq != -1)
			return dev->req_seq;
	} else {
		return ret;
	}

	for (seq = 0; seq < DM_MAX_SEQ; seq++) {
		ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq,
						false, &dup);
		if (ret == -ENODEV)
			break;
		if (ret)
			return ret;
	}
	return seq;
}

int uclass_pre_probe_device(struct udevice *dev)
{
	struct uclass_driver *uc_drv;
	int ret;

	uc_drv = dev->uclass->uc_drv;
	if (uc_drv->pre_probe) {
		ret = uc_drv->pre_probe(dev);
		if (ret)
			return ret;
	}

	if (!dev->parent)
		return 0;
	uc_drv = dev->parent->uclass->uc_drv;
	if (uc_drv->child_pre_probe)
		return uc_drv->child_pre_probe(dev);

	return 0;
}

int uclass_post_probe_device(struct udevice *dev)
{
	struct uclass_driver *uc_drv = dev->uclass->uc_drv;

	if (uc_drv->post_probe)
		return uc_drv->post_probe(dev);

	return 0;
}

#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
int uclass_pre_remove_device(struct udevice *dev)
{
	struct uclass *uc;
	int ret;

	uc = dev->uclass;
	if (uc->uc_drv->pre_remove) {
		ret = uc->uc_drv->pre_remove(dev);
		if (ret)
			return ret;
	}

	return 0;
}
#endif
Commit	Line	Data
6494d708 SG	1	/*
	2	* Copyright (c) 2013 Google, Inc
	3	*
	4	* (C) Copyright 2012
	5	* Pavel Herrmann <morpheus.ibis@gmail.com>
	6	*
	7	* SPDX-License-Identifier: GPL-2.0+
	8	*/
	9
	10	#include <common.h>
40bb637d	11	#include <dm.h>
6494d708 SG	12	#include <errno.h>
	13	#include <malloc.h>
	14	#include <dm/device.h>
	15	#include <dm/device-internal.h>
	16	#include <dm/lists.h>
	17	#include <dm/uclass.h>
	18	#include <dm/uclass-internal.h>
	19	#include <dm/util.h>
	20
	21	DECLARE_GLOBAL_DATA_PTR;
	22
	23	struct uclass *uclass_find(enum uclass_id key)
	24	{
	25	struct uclass *uc;
	26
c910e2e2 SG	27	if (!gd->dm_root)
c910e2e2 SG	28	return NULL;
6494d708 SG	29	/*
	30	* TODO(sjg@chromium.org): Optimise this, perhaps moving the found
	31	* node to the start of the list, or creating a linear array mapping
	32	* id to node.
	33	*/
	34	list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
	35	if (uc->uc_drv->id == key)
	36	return uc;
	37	}
	38
	39	return NULL;
	40	}
	41
	42	/**
	43	* uclass_add() - Create new uclass in list
	44	* @id: Id number to create
	45	* @ucp: Returns pointer to uclass, or NULL on error
	46	* @return 0 on success, -ve on error
	47	*
	48	* The new uclass is added to the list. There must be only one uclass for
	49	* each id.
	50	*/
	51	static int uclass_add(enum uclass_id id, struct uclass **ucp)
	52	{
	53	struct uclass_driver *uc_drv;
	54	struct uclass *uc;
	55	int ret;
	56
	57	*ucp = NULL;
	58	uc_drv = lists_uclass_lookup(id);
	59	if (!uc_drv) {
643e6902 MY	60	debug("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
643e6902 MY	61	id);
3346c876 SG	62	/*
	63	* Use a strange error to make this case easier to find. When
	64	* a uclass is not available it can prevent driver model from
	65	* starting up and this failure is otherwise hard to debug.
	66	*/
	67	return -EPFNOSUPPORT;
6494d708	68	}
6494d708 SG	69	uc = calloc(1, sizeof(*uc));
	70	if (!uc)
	71	return -ENOMEM;
	72	if (uc_drv->priv_auto_alloc_size) {
	73	uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
	74	if (!uc->priv) {
	75	ret = -ENOMEM;
	76	goto fail_mem;
	77	}
	78	}
	79	uc->uc_drv = uc_drv;
	80	INIT_LIST_HEAD(&uc->sibling_node);
	81	INIT_LIST_HEAD(&uc->dev_head);
89876a55	82	list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);
6494d708 SG	83
	84	if (uc_drv->init) {
	85	ret = uc_drv->init(uc);
	86	if (ret)
	87	goto fail;
	88	}
	89
	90	*ucp = uc;
	91
	92	return 0;
	93	fail:
	94	if (uc_drv->priv_auto_alloc_size) {
	95	free(uc->priv);
	96	uc->priv = NULL;
	97	}
	98	list_del(&uc->sibling_node);
	99	fail_mem:
	100	free(uc);
	101
	102	return ret;
	103	}
	104
	105	int uclass_destroy(struct uclass *uc)
	106	{
	107	struct uclass_driver *uc_drv;
07d260e0	108	struct udevice *dev;
6494d708 SG	109	int ret;
6494d708 SG	110
07d260e0 SG	111	/*
	112	* We cannot use list_for_each_entry_safe() here. If a device in this
	113	* uclass has a child device also in this uclass, it will be also be
	114	* unbound (by the recursion in the call to device_unbind() below).
	115	* We can loop until the list is empty.
	116	*/
	117	while (!list_empty(&uc->dev_head)) {
	118	dev = list_first_entry(&uc->dev_head, struct udevice,
	119	uclass_node);
706865af	120	ret = device_remove(dev, DM_REMOVE_NORMAL);
6494d708 SG	121	if (ret)
	122	return ret;
	123	ret = device_unbind(dev);
	124	if (ret)
	125	return ret;
	126	}
	127
	128	uc_drv = uc->uc_drv;
	129	if (uc_drv->destroy)
	130	uc_drv->destroy(uc);
	131	list_del(&uc->sibling_node);
	132	if (uc_drv->priv_auto_alloc_size)
	133	free(uc->priv);
	134	free(uc);
	135
	136	return 0;
	137	}
	138
	139	int uclass_get(enum uclass_id id, struct uclass **ucp)
	140	{
	141	struct uclass *uc;
	142
	143	*ucp = NULL;
	144	uc = uclass_find(id);
	145	if (!uc)
	146	return uclass_add(id, ucp);
	147	*ucp = uc;
	148
	149	return 0;
	150	}
	151
0a5f6f86 SG	152	const char *uclass_get_name(enum uclass_id id)
	153	{
	154	struct uclass *uc;
	155
	156	if (uclass_get(id, &uc))
	157	return NULL;
	158	return uc->uc_drv->name;
	159	}
	160
54c5d08a	161	int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
6494d708 SG	162	{
6494d708 SG	163	struct uclass *uc;
54c5d08a	164	struct udevice *dev;
6494d708 SG	165	int ret;
	166
	167	*devp = NULL;
	168	ret = uclass_get(id, &uc);
	169	if (ret)
	170	return ret;
2fda14ae SG	171	if (list_empty(&uc->dev_head))
2fda14ae SG	172	return -ENODEV;
6494d708 SG	173
	174	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
	175	if (!index--) {
	176	*devp = dev;
	177	return 0;
	178	}
	179	}
	180
	181	return -ENODEV;
	182	}
	183
c1d6f919 PM	184	int uclass_find_first_device(enum uclass_id id, struct udevice **devp)
	185	{
	186	struct uclass *uc;
	187	int ret;
	188
	189	*devp = NULL;
	190	ret = uclass_get(id, &uc);
	191	if (ret)
	192	return ret;
	193	if (list_empty(&uc->dev_head))
	194	return 0;
	195
	196	*devp = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
	197
	198	return 0;
	199	}
	200
	201	int uclass_find_next_device(struct udevice **devp)
	202	{
	203	struct udevice dev = devp;
	204
	205	*devp = NULL;
	206	if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
	207	return 0;
	208
	209	*devp = list_entry(dev->uclass_node.next, struct udevice, uclass_node);
	210
	211	return 0;
	212	}
	213
e0735a4c PM	214	int uclass_find_device_by_name(enum uclass_id id, const char *name,
	215	struct udevice **devp)
	216	{
	217	struct uclass *uc;
	218	struct udevice *dev;
	219	int ret;
	220
	221	*devp = NULL;
	222	if (!name)
	223	return -EINVAL;
	224	ret = uclass_get(id, &uc);
	225	if (ret)
	226	return ret;
	227
	228	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
	229	if (!strncmp(dev->name, name, strlen(name))) {
	230	*devp = dev;
	231	return 0;
	232	}
	233	}
	234
	235	return -ENODEV;
	236	}
	237
5a66a8ff SG	238	int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
	239	bool find_req_seq, struct udevice **devp)
	240	{
	241	struct uclass *uc;
	242	struct udevice *dev;
	243	int ret;
	244
	245	*devp = NULL;
	246	debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq);
	247	if (seq_or_req_seq == -1)
	248	return -ENODEV;
	249	ret = uclass_get(id, &uc);
	250	if (ret)
	251	return ret;
	252
	253	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
ea168e33	254	debug(" - %d %d '%s'\n", dev->req_seq, dev->seq, dev->name);
5a66a8ff SG	255	if ((find_req_seq ? dev->req_seq : dev->seq) ==
	256	seq_or_req_seq) {
	257	*devp = dev;
	258	debug(" - found\n");
	259	return 0;
	260	}
	261	}
	262	debug(" - not found\n");
	263
	264	return -ENODEV;
	265	}
	266
1b30d61d SG	267	int uclass_find_device_by_of_offset(enum uclass_id id, int node,
1b30d61d SG	268	struct udevice **devp)
f4cdead2 SG	269	{
	270	struct uclass *uc;
	271	struct udevice *dev;
	272	int ret;
	273
	274	*devp = NULL;
	275	if (node < 0)
	276	return -ENODEV;
	277	ret = uclass_get(id, &uc);
	278	if (ret)
	279	return ret;
	280
	281	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
e160f7d4	282	if (dev_of_offset(dev) == node) {
f4cdead2 SG	283	*devp = dev;
	284	return 0;
	285	}
	286	}
	287
	288	return -ENODEV;
	289	}
	290
40bb637d SG	291	int uclass_find_device_by_ofnode(enum uclass_id id, ofnode node,
	292	struct udevice **devp)
	293	{
	294	struct uclass *uc;
	295	struct udevice *dev;
	296	int ret;
	297
	298	*devp = NULL;
	299	if (!ofnode_valid(node))
	300	return -ENODEV;
	301	ret = uclass_get(id, &uc);
	302	if (ret)
	303	return ret;
	304
	305	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
	306	if (ofnode_equal(dev_ofnode(dev), node)) {
	307	*devp = dev;
	308	return 0;
	309	}
	310	}
	311
	312	return -ENODEV;
	313	}
	314
c275dfef	315	#if CONFIG_IS_ENABLED(OF_CONTROL)
d82ba4c0 SG	316	static int uclass_find_device_by_phandle(enum uclass_id id,
	317	struct udevice *parent,
	318	const char *name,
	319	struct udevice **devp)
	320	{
	321	struct udevice *dev;
	322	struct uclass *uc;
	323	int find_phandle;
	324	int ret;
	325
	326	*devp = NULL;
a40cc8e1	327	find_phandle = dev_read_u32_default(parent, name, -1);
d82ba4c0 SG	328	if (find_phandle <= 0)
	329	return -ENOENT;
	330	ret = uclass_get(id, &uc);
	331	if (ret)
	332	return ret;
	333
	334	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
e160f7d4 SG	335	uint phandle;
e160f7d4 SG	336
a40cc8e1	337	phandle = dev_read_phandle(dev);
d82ba4c0 SG	338
	339	if (phandle == find_phandle) {
	340	*devp = dev;
	341	return 0;
	342	}
	343	}
	344
	345	return -ENODEV;
	346	}
c275dfef	347	#endif
d82ba4c0	348
c57f806b SG	349	int uclass_get_device_by_driver(enum uclass_id id,
	350	const struct driver *find_drv,
	351	struct udevice **devp)
	352	{
	353	struct udevice *dev;
	354	struct uclass *uc;
	355	int ret;
	356
	357	ret = uclass_get(id, &uc);
	358	if (ret)
	359	return ret;
	360
	361	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
	362	if (dev->driver == find_drv)
	363	return uclass_get_device_tail(dev, 0, devp);
	364	}
	365
	366	return -ENODEV;
	367	}
	368
30a570a9	369	int uclass_get_device_tail(struct udevice dev, int ret, struct udevice *devp)
6494d708	370	{
6494d708 SG	371	if (ret)
	372	return ret;
	373
f66529f9	374	assert(dev);
6494d708 SG	375	ret = device_probe(dev);
	376	if (ret)
	377	return ret;
	378
	379	*devp = dev;
	380
	381	return 0;
	382	}
	383
9ca296a1 SG	384	int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
	385	{
	386	struct udevice *dev;
	387	int ret;
	388
	389	*devp = NULL;
	390	ret = uclass_find_device(id, index, &dev);
	391	return uclass_get_device_tail(dev, ret, devp);
	392	}
	393
b7af1a2d PM	394	int uclass_get_device_by_name(enum uclass_id id, const char *name,
	395	struct udevice **devp)
	396	{
	397	struct udevice *dev;
	398	int ret;
	399
	400	*devp = NULL;
	401	ret = uclass_find_device_by_name(id, name, &dev);
	402	return uclass_get_device_tail(dev, ret, devp);
	403	}
	404
5a66a8ff SG	405	int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
	406	{
	407	struct udevice *dev;
	408	int ret;
	409
	410	*devp = NULL;
	411	ret = uclass_find_device_by_seq(id, seq, false, &dev);
	412	if (ret == -ENODEV) {
	413	/*
	414	* We didn't find it in probed devices. See if there is one
	415	* that will request this seq if probed.
	416	*/
	417	ret = uclass_find_device_by_seq(id, seq, true, &dev);
	418	}
	419	return uclass_get_device_tail(dev, ret, devp);
	420	}
	421
f4cdead2 SG	422	int uclass_get_device_by_of_offset(enum uclass_id id, int node,
	423	struct udevice **devp)
	424	{
	425	struct udevice *dev;
	426	int ret;
	427
	428	*devp = NULL;
	429	ret = uclass_find_device_by_of_offset(id, node, &dev);
	430	return uclass_get_device_tail(dev, ret, devp);
	431	}
	432
40bb637d SG	433	int uclass_get_device_by_ofnode(enum uclass_id id, ofnode node,
	434	struct udevice **devp)
	435	{
	436	struct udevice *dev;
	437	int ret;
	438
	439	*devp = NULL;
	440	ret = uclass_find_device_by_ofnode(id, node, &dev);
	441
	442	return uclass_get_device_tail(dev, ret, devp);
	443	}
	444
c275dfef	445	#if CONFIG_IS_ENABLED(OF_CONTROL)
d82ba4c0 SG	446	int uclass_get_device_by_phandle(enum uclass_id id, struct udevice *parent,
	447	const char name, struct udevice *devp)
	448	{
	449	struct udevice *dev;
	450	int ret;
	451
	452	*devp = NULL;
	453	ret = uclass_find_device_by_phandle(id, parent, name, &dev);
	454	return uclass_get_device_tail(dev, ret, devp);
	455	}
c275dfef	456	#endif
d82ba4c0	457
54c5d08a	458	int uclass_first_device(enum uclass_id id, struct udevice **devp)
6494d708	459	{
54c5d08a	460	struct udevice *dev;
6494d708 SG	461	int ret;
	462
	463	*devp = NULL;
c1d6f919	464	ret = uclass_find_first_device(id, &dev);
f66529f9 SG	465	if (!dev)
f66529f9 SG	466	return 0;
c1d6f919	467	return uclass_get_device_tail(dev, ret, devp);
6494d708 SG	468	}
6494d708 SG	469
b0675050 SG	470	int uclass_first_device_err(enum uclass_id id, struct udevice **devp)
	471	{
	472	int ret;
	473
	474	ret = uclass_first_device(id, devp);
	475	if (ret)
	476	return ret;
	477	else if (!*devp)
	478	return -ENODEV;
	479
	480	return 0;
	481	}
	482
54c5d08a	483	int uclass_next_device(struct udevice **devp)
6494d708	484	{
54c5d08a	485	struct udevice dev = devp;
6494d708 SG	486	int ret;
	487
	488	*devp = NULL;
c1d6f919	489	ret = uclass_find_next_device(&dev);
f66529f9 SG	490	if (!dev)
f66529f9 SG	491	return 0;
c1d6f919	492	return uclass_get_device_tail(dev, ret, devp);
6494d708 SG	493	}
6494d708 SG	494
95ce385a SG	495	int uclass_first_device_check(enum uclass_id id, struct udevice **devp)
	496	{
	497	int ret;
	498
	499	*devp = NULL;
	500	ret = uclass_find_first_device(id, devp);
	501	if (ret)
	502	return ret;
	503	if (!*devp)
	504	return 0;
	505
	506	return device_probe(*devp);
	507	}
	508
	509	int uclass_next_device_check(struct udevice **devp)
	510	{
	511	int ret;
	512
	513	ret = uclass_find_next_device(devp);
	514	if (ret)
	515	return ret;
	516	if (!*devp)
	517	return 0;
	518
	519	return device_probe(*devp);
	520	}
	521
54c5d08a	522	int uclass_bind_device(struct udevice *dev)
6494d708 SG	523	{
	524	struct uclass *uc;
	525	int ret;
	526
	527	uc = dev->uclass;
6494d708 SG	528	list_add_tail(&dev->uclass_node, &uc->dev_head);
6494d708 SG	529
081f2fcb SG	530	if (dev->parent) {
	531	struct uclass_driver *uc_drv = dev->parent->uclass->uc_drv;
	532
	533	if (uc_drv->child_post_bind) {
	534	ret = uc_drv->child_post_bind(dev);
	535	if (ret)
	536	goto err;
	537	}
	538	}
6494d708 SG	539
6494d708 SG	540	return 0;
081f2fcb SG	541	err:
	542	/* There is no need to undo the parent's post_bind call */
	543	list_del(&dev->uclass_node);
	544
	545	return ret;
6494d708 SG	546	}
6494d708 SG	547
0a5804b5	548	#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
54c5d08a	549	int uclass_unbind_device(struct udevice *dev)
6494d708 SG	550	{
	551	struct uclass *uc;
	552	int ret;
	553
	554	uc = dev->uclass;
	555	if (uc->uc_drv->pre_unbind) {
	556	ret = uc->uc_drv->pre_unbind(dev);
	557	if (ret)
	558	return ret;
	559	}
	560
	561	list_del(&dev->uclass_node);
	562	return 0;
	563	}
7f9875e7	564	#endif
6494d708	565
5a66a8ff SG	566	int uclass_resolve_seq(struct udevice *dev)
	567	{
	568	struct udevice *dup;
	569	int seq;
	570	int ret;
	571
	572	assert(dev->seq == -1);
	573	ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq,
	574	false, &dup);
	575	if (!ret) {
	576	dm_warn("Device '%s': seq %d is in use by '%s'\n",
	577	dev->name, dev->req_seq, dup->name);
	578	} else if (ret == -ENODEV) {
	579	/* Our requested sequence number is available */
	580	if (dev->req_seq != -1)
	581	return dev->req_seq;
	582	} else {
	583	return ret;
	584	}
	585
	586	for (seq = 0; seq < DM_MAX_SEQ; seq++) {
	587	ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq,
	588	false, &dup);
	589	if (ret == -ENODEV)
	590	break;
	591	if (ret)
	592	return ret;
	593	}
	594	return seq;
	595	}
	596
02c07b37	597	int uclass_pre_probe_device(struct udevice *dev)
83c7e434 SG	598	{
83c7e434 SG	599	struct uclass_driver *uc_drv;
02c07b37 SG	600	int ret;
	601
	602	uc_drv = dev->uclass->uc_drv;
	603	if (uc_drv->pre_probe) {
	604	ret = uc_drv->pre_probe(dev);
	605	if (ret)
	606	return ret;
	607	}
83c7e434 SG	608
	609	if (!dev->parent)
	610	return 0;
	611	uc_drv = dev->parent->uclass->uc_drv;
	612	if (uc_drv->child_pre_probe)
	613	return uc_drv->child_pre_probe(dev);
	614
	615	return 0;
	616	}
	617
54c5d08a	618	int uclass_post_probe_device(struct udevice *dev)
6494d708 SG	619	{
	620	struct uclass_driver *uc_drv = dev->uclass->uc_drv;
	621
	622	if (uc_drv->post_probe)
	623	return uc_drv->post_probe(dev);
	624
	625	return 0;
	626	}
	627
0a5804b5	628	#if CONFIG_IS_ENABLED(DM_DEVICE_REMOVE)
54c5d08a	629	int uclass_pre_remove_device(struct udevice *dev)
6494d708	630	{
6494d708 SG	631	struct uclass *uc;
	632	int ret;
	633
	634	uc = dev->uclass;
6494d708 SG	635	if (uc->uc_drv->pre_remove) {
	636	ret = uc->uc_drv->pre_remove(dev);
	637	if (ret)
	638	return ret;
	639	}
6494d708 SG	640
	641	return 0;
	642	}
7f9875e7	643	#endif