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

	/*
	 * 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) {
		dm_warn("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
			id);
		return -ENOENT;
	}
	if (uc_drv->ops) {
		dm_warn("No ops for uclass id %d\n", id);
		return -EINVAL;
	}
	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, *tmp;
	int ret;

	list_for_each_entry_safe(dev, tmp, &uc->dev_head, uclass_node) {
		ret = device_remove(dev);
		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;
}

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;

	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
		if (!index--) {
			*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\n", dev->req_seq, dev->seq);
		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;
}

static 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 == node) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}

/**
 * uclass_get_device_tail() - handle the end of a get_device call
 *
 * This handles returning an error or probing a device as needed.
 *
 * @dev: Device that needs to be probed
 * @ret: Error to return. If non-zero then the device is not probed
 * @devp: Returns the value of 'dev' if there is no error
 * @return ret, if non-zero, else the result of the device_probe() call
 */
static int uclass_get_device_tail(struct udevice *dev, int ret,
				  struct udevice **devp)
{
	if (ret)
		return ret;

	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_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_first_device(enum uclass_id id, 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 0;

	dev = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
	ret = device_probe(dev);
	if (ret)
		return ret;
	*devp = dev;

	return 0;
}

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

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

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

	return 0;
}

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 (uc->uc_drv->post_bind) {
		ret = uc->uc_drv->post_bind(dev);
		if (ret) {
			list_del(&dev->uclass_node);
			return ret;
		}
	}

	return 0;
}

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

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

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

	uc = dev->uclass;
	uc_drv = uc->uc_drv;
	if (uc->uc_drv->pre_remove) {
		ret = uc->uc_drv->pre_remove(dev);
		if (ret)
			return ret;
	}
	if (uc_drv->per_device_auto_alloc_size) {
		free(dev->uclass_priv);
		dev->uclass_priv = NULL;
	}
	dev->seq = -1;

	return 0;
}
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>
	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
	26	/*
	27	* TODO(sjg@chromium.org): Optimise this, perhaps moving the found
	28	* node to the start of the list, or creating a linear array mapping
	29	* id to node.
	30	*/
	31	list_for_each_entry(uc, &gd->uclass_root, sibling_node) {
	32	if (uc->uc_drv->id == key)
	33	return uc;
	34	}
	35
	36	return NULL;
	37	}
	38
	39	/**
	40	* uclass_add() - Create new uclass in list
	41	* @id: Id number to create
	42	* @ucp: Returns pointer to uclass, or NULL on error
	43	* @return 0 on success, -ve on error
	44	*
	45	* The new uclass is added to the list. There must be only one uclass for
	46	* each id.
	47	*/
	48	static int uclass_add(enum uclass_id id, struct uclass **ucp)
	49	{
	50	struct uclass_driver *uc_drv;
	51	struct uclass *uc;
	52	int ret;
	53
	54	*ucp = NULL;
	55	uc_drv = lists_uclass_lookup(id);
	56	if (!uc_drv) {
	57	dm_warn("Cannot find uclass for id %d: please add the UCLASS_DRIVER() declaration for this UCLASS_... id\n",
	58	id);
	59	return -ENOENT;
	60	}
	61	if (uc_drv->ops) {
	62	dm_warn("No ops for uclass id %d\n", id);
	63	return -EINVAL;
	64	}
65	uc = calloc(1, sizeof(*uc));
66	if (!uc)
67	return -ENOMEM;
68	if (uc_drv->priv_auto_alloc_size) {
69	uc->priv = calloc(1, uc_drv->priv_auto_alloc_size);
70	if (!uc->priv) {
71	ret = -ENOMEM;
72	goto fail_mem;
73	}
74	}
75	uc->uc_drv = uc_drv;
76	INIT_LIST_HEAD(&uc->sibling_node);
77	INIT_LIST_HEAD(&uc->dev_head);
89876a55	78	list_add(&uc->sibling_node, &DM_UCLASS_ROOT_NON_CONST);
6494d708 SG	79
	80	if (uc_drv->init) {
	81	ret = uc_drv->init(uc);
	82	if (ret)
	83	goto fail;
	84	}
	85
	86	*ucp = uc;
	87
	88	return 0;
	89	fail:
	90	if (uc_drv->priv_auto_alloc_size) {
	91	free(uc->priv);
	92	uc->priv = NULL;
	93	}
	94	list_del(&uc->sibling_node);
	95	fail_mem:
	96	free(uc);
	97
	98	return ret;
	99	}
	100
	101	int uclass_destroy(struct uclass *uc)
	102	{
	103	struct uclass_driver *uc_drv;
54c5d08a	104	struct udevice dev, tmp;
6494d708 SG	105	int ret;
	106
	107	list_for_each_entry_safe(dev, tmp, &uc->dev_head, uclass_node) {
	108	ret = device_remove(dev);
	109	if (ret)
	110	return ret;
	111	ret = device_unbind(dev);
	112	if (ret)
	113	return ret;
	114	}
	115
	116	uc_drv = uc->uc_drv;
	117	if (uc_drv->destroy)
	118	uc_drv->destroy(uc);
	119	list_del(&uc->sibling_node);
	120	if (uc_drv->priv_auto_alloc_size)
	121	free(uc->priv);
	122	free(uc);
	123
	124	return 0;
	125	}
	126
	127	int uclass_get(enum uclass_id id, struct uclass **ucp)
	128	{
	129	struct uclass *uc;
	130
	131	*ucp = NULL;
	132	uc = uclass_find(id);
	133	if (!uc)
	134	return uclass_add(id, ucp);
	135	*ucp = uc;
	136
	137	return 0;
	138	}
	139
54c5d08a	140	int uclass_find_device(enum uclass_id id, int index, struct udevice **devp)
6494d708 SG	141	{
6494d708 SG	142	struct uclass *uc;
54c5d08a	143	struct udevice *dev;
6494d708 SG	144	int ret;
	145
	146	*devp = NULL;
	147	ret = uclass_get(id, &uc);
	148	if (ret)
	149	return ret;
	150
	151	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
	152	if (!index--) {
	153	*devp = dev;
	154	return 0;
	155	}
	156	}
	157
	158	return -ENODEV;
	159	}
	160
5a66a8ff SG	161	int uclass_find_device_by_seq(enum uclass_id id, int seq_or_req_seq,
	162	bool find_req_seq, struct udevice **devp)
	163	{
	164	struct uclass *uc;
	165	struct udevice *dev;
	166	int ret;
	167
	168	*devp = NULL;
	169	debug("%s: %d %d\n", __func__, find_req_seq, seq_or_req_seq);
	170	if (seq_or_req_seq == -1)
	171	return -ENODEV;
	172	ret = uclass_get(id, &uc);
	173	if (ret)
	174	return ret;
	175
	176	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
	177	debug(" - %d %d\n", dev->req_seq, dev->seq);
	178	if ((find_req_seq ? dev->req_seq : dev->seq) ==
	179	seq_or_req_seq) {
	180	*devp = dev;
	181	debug(" - found\n");
	182	return 0;
	183	}
	184	}
	185	debug(" - not found\n");
	186
	187	return -ENODEV;
	188	}
	189
f4cdead2 SG	190	static int uclass_find_device_by_of_offset(enum uclass_id id, int node,
	191	struct udevice **devp)
	192	{
	193	struct uclass *uc;
	194	struct udevice *dev;
	195	int ret;
	196
	197	*devp = NULL;
	198	if (node < 0)
	199	return -ENODEV;
	200	ret = uclass_get(id, &uc);
	201	if (ret)
	202	return ret;
	203
	204	list_for_each_entry(dev, &uc->dev_head, uclass_node) {
	205	if (dev->of_offset == node) {
	206	*devp = dev;
	207	return 0;
	208	}
	209	}
	210
	211	return -ENODEV;
	212	}
	213
9ca296a1 SG	214	/**
	215	* uclass_get_device_tail() - handle the end of a get_device call
	216	*
	217	* This handles returning an error or probing a device as needed.
	218	*
	219	* @dev: Device that needs to be probed
	220	* @ret: Error to return. If non-zero then the device is not probed
	221	* @devp: Returns the value of 'dev' if there is no error
	222	* @return ret, if non-zero, else the result of the device_probe() call
	223	*/
	224	static int uclass_get_device_tail(struct udevice *dev, int ret,
	225	struct udevice **devp)
6494d708	226	{
6494d708 SG	227	if (ret)
	228	return ret;
	229
	230	ret = device_probe(dev);
	231	if (ret)
	232	return ret;
	233
	234	*devp = dev;
	235
	236	return 0;
	237	}
	238
9ca296a1 SG	239	int uclass_get_device(enum uclass_id id, int index, struct udevice **devp)
	240	{
	241	struct udevice *dev;
	242	int ret;
	243
	244	*devp = NULL;
	245	ret = uclass_find_device(id, index, &dev);
	246	return uclass_get_device_tail(dev, ret, devp);
	247	}
	248
5a66a8ff SG	249	int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp)
	250	{
	251	struct udevice *dev;
	252	int ret;
	253
	254	*devp = NULL;
	255	ret = uclass_find_device_by_seq(id, seq, false, &dev);
	256	if (ret == -ENODEV) {
	257	/*
	258	* We didn't find it in probed devices. See if there is one
	259	* that will request this seq if probed.
	260	*/
	261	ret = uclass_find_device_by_seq(id, seq, true, &dev);
	262	}
	263	return uclass_get_device_tail(dev, ret, devp);
	264	}
	265
f4cdead2 SG	266	int uclass_get_device_by_of_offset(enum uclass_id id, int node,
	267	struct udevice **devp)
	268	{
	269	struct udevice *dev;
	270	int ret;
	271
	272	*devp = NULL;
	273	ret = uclass_find_device_by_of_offset(id, node, &dev);
	274	return uclass_get_device_tail(dev, ret, devp);
	275	}
	276
54c5d08a	277	int uclass_first_device(enum uclass_id id, struct udevice **devp)
6494d708 SG	278	{
6494d708 SG	279	struct uclass *uc;
54c5d08a	280	struct udevice *dev;
6494d708 SG	281	int ret;
	282
	283	*devp = NULL;
	284	ret = uclass_get(id, &uc);
	285	if (ret)
	286	return ret;
	287	if (list_empty(&uc->dev_head))
	288	return 0;
	289
54c5d08a	290	dev = list_first_entry(&uc->dev_head, struct udevice, uclass_node);
6494d708 SG	291	ret = device_probe(dev);
	292	if (ret)
	293	return ret;
	294	*devp = dev;
	295
	296	return 0;
	297	}
	298
54c5d08a	299	int uclass_next_device(struct udevice **devp)
6494d708	300	{
54c5d08a	301	struct udevice dev = devp;
6494d708 SG	302	int ret;
	303
	304	*devp = NULL;
	305	if (list_is_last(&dev->uclass_node, &dev->uclass->dev_head))
	306	return 0;
	307
54c5d08a HS	308	dev = list_entry(dev->uclass_node.next, struct udevice,
54c5d08a HS	309	uclass_node);
6494d708 SG	310	ret = device_probe(dev);
	311	if (ret)
	312	return ret;
	313	*devp = dev;
	314
	315	return 0;
	316	}
	317
54c5d08a	318	int uclass_bind_device(struct udevice *dev)
6494d708 SG	319	{
	320	struct uclass *uc;
	321	int ret;
	322
	323	uc = dev->uclass;
	324
	325	list_add_tail(&dev->uclass_node, &uc->dev_head);
	326
	327	if (uc->uc_drv->post_bind) {
	328	ret = uc->uc_drv->post_bind(dev);
	329	if (ret) {
	330	list_del(&dev->uclass_node);
	331	return ret;
	332	}
	333	}
	334
	335	return 0;
	336	}
	337
54c5d08a	338	int uclass_unbind_device(struct udevice *dev)
6494d708 SG	339	{
	340	struct uclass *uc;
	341	int ret;
	342
	343	uc = dev->uclass;
	344	if (uc->uc_drv->pre_unbind) {
	345	ret = uc->uc_drv->pre_unbind(dev);
	346	if (ret)
	347	return ret;
	348	}
	349
	350	list_del(&dev->uclass_node);
	351	return 0;
	352	}
	353
5a66a8ff SG	354	int uclass_resolve_seq(struct udevice *dev)
	355	{
	356	struct udevice *dup;
	357	int seq;
	358	int ret;
	359
	360	assert(dev->seq == -1);
	361	ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, dev->req_seq,
	362	false, &dup);
	363	if (!ret) {
	364	dm_warn("Device '%s': seq %d is in use by '%s'\n",
	365	dev->name, dev->req_seq, dup->name);
	366	} else if (ret == -ENODEV) {
	367	/* Our requested sequence number is available */
	368	if (dev->req_seq != -1)
	369	return dev->req_seq;
	370	} else {
	371	return ret;
	372	}
	373
	374	for (seq = 0; seq < DM_MAX_SEQ; seq++) {
	375	ret = uclass_find_device_by_seq(dev->uclass->uc_drv->id, seq,
	376	false, &dup);
	377	if (ret == -ENODEV)
	378	break;
	379	if (ret)
	380	return ret;
	381	}
	382	return seq;
	383	}
	384
54c5d08a	385	int uclass_post_probe_device(struct udevice *dev)
6494d708 SG	386	{
	387	struct uclass_driver *uc_drv = dev->uclass->uc_drv;
	388
	389	if (uc_drv->post_probe)
	390	return uc_drv->post_probe(dev);
	391
	392	return 0;
	393	}
	394
54c5d08a	395	int uclass_pre_remove_device(struct udevice *dev)
6494d708 SG	396	{
	397	struct uclass_driver *uc_drv;
	398	struct uclass *uc;
	399	int ret;
	400
	401	uc = dev->uclass;
	402	uc_drv = uc->uc_drv;
	403	if (uc->uc_drv->pre_remove) {
	404	ret = uc->uc_drv->pre_remove(dev);
	405	if (ret)
	406	return ret;
	407	}
	408	if (uc_drv->per_device_auto_alloc_size) {
	409	free(dev->uclass_priv);
	410	dev->uclass_priv = NULL;
	411	}
5a66a8ff	412	dev->seq = -1;
6494d708 SG	413
	414	return 0;
	415	}