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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2013 Google, Inc
 *
 * (C) Copyright 2012
 * Pavel Herrmann <[email protected]>
 */

#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([email protected]): 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;
}

enum uclass_id uclass_get_by_name(const char *name)
{
	int i;

	for (i = 0; i < UCLASS_COUNT; i++) {
		struct uclass_driver *uc_drv = lists_uclass_lookup(i);

		if (uc_drv && !strcmp(uc_drv->name, name))
			return i;
	}

	return UCLASS_INVALID;
}

int dev_get_uclass_index(struct udevice *dev, struct uclass **ucp)
{
	struct udevice *iter;
	struct uclass *uc = dev->uclass;
	int i = 0;

	if (list_empty(&uc->dev_head))
		return -ENODEV;

	list_for_each_entry(iter, &uc->dev_head, uclass_node) {
		if (iter == dev) {
			if (ucp)
				*ucp = uc;
			return i;
		}
		i++;
	}

	return -ENODEV;
}

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;

	log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
	*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) {
		log(LOGC_DM, LOGL_DEBUG_CONTENT, "      - checking %s\n",
		    dev->name);
		if (ofnode_equal(dev_ofnode(dev), node)) {
			*devp = dev;
			goto done;
		}
	}
	ret = -ENODEV;

done:
	log(LOGC_DM, LOGL_DEBUG, "   - result for %s: %s (ret=%d)\n",
	    ofnode_get_name(node), *devp ? (*devp)->name : "(none)", ret);
	return ret;
}

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

	log(LOGC_DM, LOGL_DEBUG, "Looking for %s\n", ofnode_get_name(node));
	*devp = NULL;
	ret = uclass_find_device_by_ofnode(id, node, &dev);
	log(LOGC_DM, LOGL_DEBUG, "   - result for %s: %s (ret=%d)\n",
	    ofnode_get_name(node), dev ? dev->name : "(none)", ret);

	return uclass_get_device_tail(dev, ret, devp);
}

#if CONFIG_IS_ENABLED(OF_CONTROL)
int uclass_get_device_by_phandle_id(enum uclass_id id, uint phandle_id,
				    struct udevice **devp)
{
	struct udevice *dev;
	struct uclass *uc;
	int ret;

	*devp = NULL;
	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 == phandle_id) {
			*devp = dev;
			return uclass_get_device_tail(dev, ret, devp);
		}
	}

	return -ENODEV;
}

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;
	int ret;

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

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