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

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

#include <common.h>
#include <fdtdec.h>
#include <malloc.h>
#include <dm/device.h>
#include <dm/device-internal.h>
#include <dm/lists.h>
#include <dm/platdata.h>
#include <dm/uclass.h>
#include <dm/uclass-internal.h>
#include <dm/util.h>
#include <linux/err.h>
#include <linux/list.h>

DECLARE_GLOBAL_DATA_PTR;

int device_bind(struct udevice *parent, struct driver *drv, const char *name,
		void *platdata, int of_offset, struct udevice **devp)
{
	struct udevice *dev;
	struct uclass *uc;
	int ret = 0;

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

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

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

	INIT_LIST_HEAD(&dev->sibling_node);
	INIT_LIST_HEAD(&dev->child_head);
	INIT_LIST_HEAD(&dev->uclass_node);
	dev->platdata = platdata;
	dev->name = name;
	dev->of_offset = of_offset;
	dev->parent = parent;
	dev->driver = drv;
	dev->uclass = uc;

	/*
	 * For some devices, such as a SPI or I2C bus, the 'reg' property
	 * is a reasonable indicator of the sequence number. But if there is
	 * an alias, we use that in preference. In any case, this is just
	 * a 'requested' sequence, and will be resolved (and ->seq updated)
	 * when the device is probed.
	 */
	dev->seq = -1;
#ifdef CONFIG_OF_CONTROL
	dev->req_seq = fdtdec_get_int(gd->fdt_blob, of_offset, "reg", -1);
	if (!IS_ERR_VALUE(dev->req_seq))
		dev->req_seq &= INT_MAX;
	if (uc->uc_drv->name && of_offset != -1) {
		fdtdec_get_alias_seq(gd->fdt_blob, uc->uc_drv->name, of_offset,
				     &dev->req_seq);
	}
#else
	dev->req_seq = -1;
#endif
	if (!dev->platdata && drv->platdata_auto_alloc_size)
		dev->flags |= DM_FLAG_ALLOC_PDATA;

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

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

	/* if we fail to bind we remove device from successors and free it */
	if (drv->bind) {
		ret = drv->bind(dev);
		if (ret) {
			if (uclass_unbind_device(dev)) {
				dm_warn("Failed to unbind dev '%s' on error path\n",
					dev->name);
			}
			goto fail_bind;
		}
	}
	if (parent)
		dm_dbg("Bound device %s to %s\n", dev->name, parent->name);
	*devp = dev;

	return 0;

fail_bind:
	list_del(&dev->sibling_node);
	free(dev);
	return ret;
}

int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
			const struct driver_info *info, struct udevice **devp)
{
	struct driver *drv;

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

	return device_bind(parent, drv, info->name, (void *)info->platdata,
			   -1, devp);
}

int device_probe_child(struct udevice *dev, void *parent_priv)
{
	struct driver *drv;
	int size = 0;
	int ret;
	int seq;

	if (!dev)
		return -EINVAL;

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

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

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

	/* Ensure all parents are probed */
	if (dev->parent) {
		size = dev->parent->driver->per_child_auto_alloc_size;
		if (size) {
			dev->parent_priv = calloc(1, size);
			if (!dev->parent_priv) {
				ret = -ENOMEM;
				goto fail;
			}
			if (parent_priv)
				memcpy(dev->parent_priv, parent_priv, size);
		}

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

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

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

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

	if (drv->probe) {
		ret = drv->probe(dev);
		if (ret)
			goto fail;
	}

	dev->flags |= DM_FLAG_ACTIVATED;

	ret = uclass_post_probe_device(dev);
	if (ret) {
		dev->flags &= ~DM_FLAG_ACTIVATED;
		goto fail_uclass;
	}

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

	return ret;
}

int device_probe(struct udevice *dev)
{
	return device_probe_child(dev, NULL);
}

void *dev_get_platdata(struct udevice *dev)
{
	if (!dev) {
		dm_warn("%s: null device", __func__);
		return NULL;
	}

	return dev->platdata;
}

void *dev_get_priv(struct udevice *dev)
{
	if (!dev) {
		dm_warn("%s: null device", __func__);
		return NULL;
	}

	return dev->priv;
}

void *dev_get_parentdata(struct udevice *dev)
{
	if (!dev) {
		dm_warn("%s: null device", __func__);
		return NULL;
	}

	return dev->parent_priv;
}

static int device_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 device_get_child(struct udevice *parent, int index, struct udevice **devp)
{
	struct udevice *dev;

	list_for_each_entry(dev, &parent->child_head, sibling_node) {
		if (!index--)
			return device_get_device_tail(dev, 0, devp);
	}

	return -ENODEV;
}

int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq,
			     bool find_req_seq, struct udevice **devp)
{
	struct udevice *dev;

	*devp = NULL;
	if (seq_or_req_seq == -1)
		return -ENODEV;

	list_for_each_entry(dev, &parent->child_head, sibling_node) {
		if ((find_req_seq ? dev->req_seq : dev->seq) ==
				seq_or_req_seq) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}

int device_get_child_by_seq(struct udevice *parent, int seq,
			    struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = device_find_child_by_seq(parent, 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 = device_find_child_by_seq(parent, seq, true, &dev);
	}
	return device_get_device_tail(dev, ret, devp);
}

int device_find_child_by_of_offset(struct udevice *parent, int of_offset,
				   struct udevice **devp)
{
	struct udevice *dev;

	*devp = NULL;

	list_for_each_entry(dev, &parent->child_head, sibling_node) {
		if (dev->of_offset == of_offset) {
			*devp = dev;
			return 0;
		}
	}

	return -ENODEV;
}

int device_get_child_by_of_offset(struct udevice *parent, int seq,
				  struct udevice **devp)
{
	struct udevice *dev;
	int ret;

	*devp = NULL;
	ret = device_find_child_by_of_offset(parent, seq, &dev);
	return device_get_device_tail(dev, ret, devp);
}

int device_find_first_child(struct udevice *parent, struct udevice **devp)
{
	if (list_empty(&parent->child_head)) {
		*devp = NULL;
	} else {
		*devp = list_first_entry(&parent->child_head, struct udevice,
					 sibling_node);
	}

	return 0;
}

int device_find_next_child(struct udevice **devp)
{
	struct udevice *dev = *devp;
	struct udevice *parent = dev->parent;

	if (list_is_last(&dev->sibling_node, &parent->child_head)) {
		*devp = NULL;
	} else {
		*devp = list_entry(dev->sibling_node.next, struct udevice,
				   sibling_node);
	}

	return 0;
}

struct udevice *dev_get_parent(struct udevice *child)
{
	return child->parent;
}

ulong dev_get_of_data(struct udevice *dev)
{
	return dev->of_id->data;
}
Commit	Line	Data
6494d708 SG	1	/*
	2	* Device manager
	3	*
	4	* Copyright (c) 2013 Google, Inc
	5	*
	6	* (C) Copyright 2012
	7	* Pavel Herrmann <morpheus.ibis@gmail.com>
	8	*
	9	* SPDX-License-Identifier: GPL-2.0+
	10	*/
	11
	12	#include <common.h>
5a66a8ff	13	#include <fdtdec.h>
6494d708 SG	14	#include <malloc.h>
	15	#include <dm/device.h>
	16	#include <dm/device-internal.h>
	17	#include <dm/lists.h>
	18	#include <dm/platdata.h>
	19	#include <dm/uclass.h>
	20	#include <dm/uclass-internal.h>
	21	#include <dm/util.h>
	22	#include <linux/err.h>
	23	#include <linux/list.h>
	24
5a66a8ff SG	25	DECLARE_GLOBAL_DATA_PTR;
5a66a8ff SG	26
54c5d08a HS	27	int device_bind(struct udevice parent, struct driver drv, const char *name,
54c5d08a HS	28	void platdata, int of_offset, struct udevice *devp)
6494d708	29	{
54c5d08a	30	struct udevice *dev;
6494d708 SG	31	struct uclass *uc;
	32	int ret = 0;
	33
	34	*devp = NULL;
	35	if (!name)
	36	return -EINVAL;
	37
	38	ret = uclass_get(drv->id, &uc);
	39	if (ret)
	40	return ret;
	41
54c5d08a	42	dev = calloc(1, sizeof(struct udevice));
6494d708 SG	43	if (!dev)
	44	return -ENOMEM;
	45
	46	INIT_LIST_HEAD(&dev->sibling_node);
	47	INIT_LIST_HEAD(&dev->child_head);
	48	INIT_LIST_HEAD(&dev->uclass_node);
	49	dev->platdata = platdata;
	50	dev->name = name;
	51	dev->of_offset = of_offset;
	52	dev->parent = parent;
	53	dev->driver = drv;
	54	dev->uclass = uc;
5a66a8ff SG	55
	56	/*
	57	* For some devices, such as a SPI or I2C bus, the 'reg' property
	58	* is a reasonable indicator of the sequence number. But if there is
	59	* an alias, we use that in preference. In any case, this is just
	60	* a 'requested' sequence, and will be resolved (and ->seq updated)
	61	* when the device is probed.
	62	*/
5a66a8ff	63	dev->seq = -1;
91cbd792 SG	64	#ifdef CONFIG_OF_CONTROL
91cbd792 SG	65	dev->req_seq = fdtdec_get_int(gd->fdt_blob, of_offset, "reg", -1);
cae025aa RB	66	if (!IS_ERR_VALUE(dev->req_seq))
cae025aa RB	67	dev->req_seq &= INT_MAX;
5a66a8ff SG	68	if (uc->uc_drv->name && of_offset != -1) {
	69	fdtdec_get_alias_seq(gd->fdt_blob, uc->uc_drv->name, of_offset,
	70	&dev->req_seq);
	71	}
91cbd792 SG	72	#else
	73	dev->req_seq = -1;
	74	#endif
6494d708 SG	75	if (!dev->platdata && drv->platdata_auto_alloc_size)
	76	dev->flags \|= DM_FLAG_ALLOC_PDATA;
	77
	78	/* put dev into parent's successor list */
	79	if (parent)
	80	list_add_tail(&dev->sibling_node, &parent->child_head);
	81
	82	ret = uclass_bind_device(dev);
	83	if (ret)
	84	goto fail_bind;
	85
	86	/* if we fail to bind we remove device from successors and free it */
	87	if (drv->bind) {
	88	ret = drv->bind(dev);
	89	if (ret) {
	90	if (uclass_unbind_device(dev)) {
	91	dm_warn("Failed to unbind dev '%s' on error path\n",
	92	dev->name);
	93	}
	94	goto fail_bind;
	95	}
	96	}
	97	if (parent)
	98	dm_dbg("Bound device %s to %s\n", dev->name, parent->name);
	99	*devp = dev;
	100
	101	return 0;
	102
	103	fail_bind:
	104	list_del(&dev->sibling_node);
	105	free(dev);
	106	return ret;
	107	}
	108
00606d7e SG	109	int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
00606d7e SG	110	const struct driver_info info, struct udevice *devp)
6494d708 SG	111	{
	112	struct driver *drv;
	113
	114	drv = lists_driver_lookup_name(info->name);
	115	if (!drv)
	116	return -ENOENT;
00606d7e SG	117	if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
00606d7e SG	118	return -EPERM;
6494d708 SG	119
	120	return device_bind(parent, drv, info->name, (void *)info->platdata,
	121	-1, devp);
	122	}
	123
accd4b19	124	int device_probe_child(struct udevice dev, void parent_priv)
6494d708 SG	125	{
	126	struct driver *drv;
	127	int size = 0;
	128	int ret;
5a66a8ff	129	int seq;
6494d708 SG	130
	131	if (!dev)
	132	return -EINVAL;
	133
	134	if (dev->flags & DM_FLAG_ACTIVATED)
	135	return 0;
	136
	137	drv = dev->driver;
	138	assert(drv);
	139
	140	/* Allocate private data and platdata if requested */
	141	if (drv->priv_auto_alloc_size) {
	142	dev->priv = calloc(1, drv->priv_auto_alloc_size);
	143	if (!dev->priv) {
	144	ret = -ENOMEM;
	145	goto fail;
	146	}
	147	}
	148	/* Allocate private data if requested */
	149	if (dev->flags & DM_FLAG_ALLOC_PDATA) {
	150	dev->platdata = calloc(1, drv->platdata_auto_alloc_size);
	151	if (!dev->platdata) {
	152	ret = -ENOMEM;
	153	goto fail;
	154	}
	155	}
	156	size = dev->uclass->uc_drv->per_device_auto_alloc_size;
	157	if (size) {
	158	dev->uclass_priv = calloc(1, size);
	159	if (!dev->uclass_priv) {
	160	ret = -ENOMEM;
	161	goto fail;
	162	}
	163	}
	164
	165	/* Ensure all parents are probed */
	166	if (dev->parent) {
e59f458d SG	167	size = dev->parent->driver->per_child_auto_alloc_size;
	168	if (size) {
	169	dev->parent_priv = calloc(1, size);
	170	if (!dev->parent_priv) {
	171	ret = -ENOMEM;
	172	goto fail;
	173	}
accd4b19 SG	174	if (parent_priv)
accd4b19 SG	175	memcpy(dev->parent_priv, parent_priv, size);
e59f458d SG	176	}
e59f458d SG	177
6494d708 SG	178	ret = device_probe(dev->parent);
	179	if (ret)
	180	goto fail;
	181	}
	182
5a66a8ff SG	183	seq = uclass_resolve_seq(dev);
	184	if (seq < 0) {
	185	ret = seq;
	186	goto fail;
	187	}
	188	dev->seq = seq;
	189
a327dee0 SG	190	if (dev->parent && dev->parent->driver->child_pre_probe) {
	191	ret = dev->parent->driver->child_pre_probe(dev);
	192	if (ret)
	193	goto fail;
	194	}
	195
6494d708 SG	196	if (drv->ofdata_to_platdata && dev->of_offset >= 0) {
	197	ret = drv->ofdata_to_platdata(dev);
	198	if (ret)
	199	goto fail;
	200	}
	201
	202	if (drv->probe) {
	203	ret = drv->probe(dev);
	204	if (ret)
	205	goto fail;
	206	}
	207
	208	dev->flags \|= DM_FLAG_ACTIVATED;
	209
	210	ret = uclass_post_probe_device(dev);
	211	if (ret) {
	212	dev->flags &= ~DM_FLAG_ACTIVATED;
	213	goto fail_uclass;
	214	}
	215
	216	return 0;
	217	fail_uclass:
	218	if (device_remove(dev)) {
	219	dm_warn("%s: Device '%s' failed to remove on error path\n",
	220	__func__, dev->name);
	221	}
	222	fail:
5a66a8ff	223	dev->seq = -1;
6494d708 SG	224	device_free(dev);
	225
	226	return ret;
	227	}
	228
accd4b19 SG	229	int device_probe(struct udevice *dev)
	230	{
	231	return device_probe_child(dev, NULL);
	232	}
	233
54c5d08a	234	void dev_get_platdata(struct udevice dev)
6494d708 SG	235	{
	236	if (!dev) {
	237	dm_warn("%s: null device", __func__);
	238	return NULL;
	239	}
	240
	241	return dev->platdata;
	242	}
	243
54c5d08a	244	void dev_get_priv(struct udevice dev)
6494d708 SG	245	{
	246	if (!dev) {
	247	dm_warn("%s: null device", __func__);
	248	return NULL;
	249	}
	250
	251	return dev->priv;
	252	}
997c87bb	253
e59f458d SG	254	void dev_get_parentdata(struct udevice dev)
	255	{
	256	if (!dev) {
	257	dm_warn("%s: null device", __func__);
	258	return NULL;
	259	}
	260
	261	return dev->parent_priv;
	262	}
	263
997c87bb SG	264	static int device_get_device_tail(struct udevice *dev, int ret,
	265	struct udevice **devp)
	266	{
	267	if (ret)
	268	return ret;
	269
	270	ret = device_probe(dev);
	271	if (ret)
	272	return ret;
	273
	274	*devp = dev;
	275
	276	return 0;
	277	}
	278
	279	int device_get_child(struct udevice parent, int index, struct udevice *devp)
	280	{
	281	struct udevice *dev;
	282
	283	list_for_each_entry(dev, &parent->child_head, sibling_node) {
	284	if (!index--)
	285	return device_get_device_tail(dev, 0, devp);
	286	}
	287
	288	return -ENODEV;
	289	}
	290
	291	int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq,
	292	bool find_req_seq, struct udevice **devp)
	293	{
	294	struct udevice *dev;
	295
	296	*devp = NULL;
	297	if (seq_or_req_seq == -1)
	298	return -ENODEV;
	299
	300	list_for_each_entry(dev, &parent->child_head, sibling_node) {
	301	if ((find_req_seq ? dev->req_seq : dev->seq) ==
	302	seq_or_req_seq) {
	303	*devp = dev;
	304	return 0;
	305	}
	306	}
	307
	308	return -ENODEV;
	309	}
	310
	311	int device_get_child_by_seq(struct udevice *parent, int seq,
	312	struct udevice **devp)
	313	{
	314	struct udevice *dev;
	315	int ret;
	316
	317	*devp = NULL;
	318	ret = device_find_child_by_seq(parent, seq, false, &dev);
	319	if (ret == -ENODEV) {
	320	/*
	321	* We didn't find it in probed devices. See if there is one
	322	* that will request this seq if probed.
	323	*/
	324	ret = device_find_child_by_seq(parent, seq, true, &dev);
	325	}
	326	return device_get_device_tail(dev, ret, devp);
	327	}
328
329	int device_find_child_by_of_offset(struct udevice *parent, int of_offset,
330	struct udevice **devp)
331	{
332	struct udevice *dev;
333
334	*devp = NULL;
335
336	list_for_each_entry(dev, &parent->child_head, sibling_node) {
337	if (dev->of_offset == of_offset) {
338	*devp = dev;
339	return 0;
340	}
341	}
342
343	return -ENODEV;
344	}
345
346	int device_get_child_by_of_offset(struct udevice *parent, int seq,
347	struct udevice **devp)
348	{
349	struct udevice *dev;
350	int ret;
351
352	*devp = NULL;
353	ret = device_find_child_by_of_offset(parent, seq, &dev);
354	return device_get_device_tail(dev, ret, devp);
355	}
a8981d4f SG	356
	357	int device_find_first_child(struct udevice parent, struct udevice *devp)
	358	{
	359	if (list_empty(&parent->child_head)) {
	360	*devp = NULL;
	361	} else {
	362	*devp = list_first_entry(&parent->child_head, struct udevice,
	363	sibling_node);
	364	}
	365
	366	return 0;
	367	}
	368
	369	int device_find_next_child(struct udevice **devp)
	370	{
	371	struct udevice dev = devp;
	372	struct udevice *parent = dev->parent;
	373
	374	if (list_is_last(&dev->sibling_node, &parent->child_head)) {
	375	*devp = NULL;
	376	} else {
	377	*devp = list_entry(dev->sibling_node.next, struct udevice,
	378	sibling_node);
	379	}
	380
	381	return 0;
	382	}
2ef249b4	383
479728cb SG	384	struct udevice dev_get_parent(struct udevice child)
	385	{
	386	return child->parent;
	387	}
	388
2ef249b4 SG	389	ulong dev_get_of_data(struct udevice *dev)
	390	{
	391	return dev->of_id->data;
	392	}