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

/*
 * Device manager
 *
 * Copyright (c) 2013 Google, Inc
 *
 * (C) Copyright 2012
 * Pavel Herrmann <[email protected]>
 *
 * 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_uclass_bind;

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

	return 0;

fail_bind:
	if (uclass_unbind_device(dev)) {
		dm_warn("Failed to unbind dev '%s' on error path\n",
			dev->name);
	}
fail_uclass_bind:
	if (parent)
		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\n", __func__);
		return NULL;
	}

	return dev->platdata;
}

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

	return dev->priv;
}

void *dev_get_parentdata(struct udevice *dev)
{
	if (!dev) {
		dm_warn("%s: null device\n", __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 <[email protected]>
	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)
72ebfe86	84	goto fail_uclass_bind;
6494d708 SG	85
	86	/* if we fail to bind we remove device from successors and free it */
	87	if (drv->bind) {
	88	ret = drv->bind(dev);
72ebfe86	89	if (ret)
6494d708	90	goto fail_bind;
6494d708 SG	91	}
	92	if (parent)
	93	dm_dbg("Bound device %s to %s\n", dev->name, parent->name);
	94	*devp = dev;
	95
	96	return 0;
	97
	98	fail_bind:
72ebfe86 SG	99	if (uclass_unbind_device(dev)) {
	100	dm_warn("Failed to unbind dev '%s' on error path\n",
	101	dev->name);
	102	}
	103	fail_uclass_bind:
	104	if (parent)
	105	list_del(&dev->sibling_node);
6494d708	106	free(dev);
72ebfe86	107
6494d708 SG	108	return ret;
	109	}
	110
00606d7e SG	111	int device_bind_by_name(struct udevice *parent, bool pre_reloc_only,
00606d7e SG	112	const struct driver_info info, struct udevice *devp)
6494d708 SG	113	{
	114	struct driver *drv;
	115
	116	drv = lists_driver_lookup_name(info->name);
	117	if (!drv)
	118	return -ENOENT;
00606d7e SG	119	if (pre_reloc_only && !(drv->flags & DM_FLAG_PRE_RELOC))
00606d7e SG	120	return -EPERM;
6494d708 SG	121
	122	return device_bind(parent, drv, info->name, (void *)info->platdata,
	123	-1, devp);
	124	}
	125
accd4b19	126	int device_probe_child(struct udevice dev, void parent_priv)
6494d708 SG	127	{
	128	struct driver *drv;
	129	int size = 0;
	130	int ret;
5a66a8ff	131	int seq;
6494d708 SG	132
	133	if (!dev)
	134	return -EINVAL;
	135
	136	if (dev->flags & DM_FLAG_ACTIVATED)
	137	return 0;
	138
	139	drv = dev->driver;
	140	assert(drv);
	141
	142	/* Allocate private data and platdata if requested */
	143	if (drv->priv_auto_alloc_size) {
	144	dev->priv = calloc(1, drv->priv_auto_alloc_size);
	145	if (!dev->priv) {
	146	ret = -ENOMEM;
	147	goto fail;
	148	}
	149	}
	150	/* Allocate private data if requested */
	151	if (dev->flags & DM_FLAG_ALLOC_PDATA) {
	152	dev->platdata = calloc(1, drv->platdata_auto_alloc_size);
	153	if (!dev->platdata) {
	154	ret = -ENOMEM;
	155	goto fail;
	156	}
	157	}
	158	size = dev->uclass->uc_drv->per_device_auto_alloc_size;
	159	if (size) {
	160	dev->uclass_priv = calloc(1, size);
	161	if (!dev->uclass_priv) {
	162	ret = -ENOMEM;
	163	goto fail;
	164	}
	165	}
	166
	167	/* Ensure all parents are probed */
	168	if (dev->parent) {
e59f458d SG	169	size = dev->parent->driver->per_child_auto_alloc_size;
	170	if (size) {
	171	dev->parent_priv = calloc(1, size);
	172	if (!dev->parent_priv) {
	173	ret = -ENOMEM;
	174	goto fail;
	175	}
accd4b19 SG	176	if (parent_priv)
accd4b19 SG	177	memcpy(dev->parent_priv, parent_priv, size);
e59f458d SG	178	}
e59f458d SG	179
6494d708 SG	180	ret = device_probe(dev->parent);
	181	if (ret)
	182	goto fail;
	183	}
	184
5a66a8ff SG	185	seq = uclass_resolve_seq(dev);
	186	if (seq < 0) {
	187	ret = seq;
	188	goto fail;
	189	}
	190	dev->seq = seq;
	191
a327dee0 SG	192	if (dev->parent && dev->parent->driver->child_pre_probe) {
	193	ret = dev->parent->driver->child_pre_probe(dev);
	194	if (ret)
	195	goto fail;
	196	}
	197
6494d708 SG	198	if (drv->ofdata_to_platdata && dev->of_offset >= 0) {
	199	ret = drv->ofdata_to_platdata(dev);
	200	if (ret)
	201	goto fail;
	202	}
	203
	204	if (drv->probe) {
	205	ret = drv->probe(dev);
	206	if (ret)
	207	goto fail;
	208	}
	209
	210	dev->flags \|= DM_FLAG_ACTIVATED;
	211
	212	ret = uclass_post_probe_device(dev);
	213	if (ret) {
	214	dev->flags &= ~DM_FLAG_ACTIVATED;
	215	goto fail_uclass;
	216	}
	217
	218	return 0;
	219	fail_uclass:
	220	if (device_remove(dev)) {
	221	dm_warn("%s: Device '%s' failed to remove on error path\n",
	222	__func__, dev->name);
	223	}
	224	fail:
5a66a8ff	225	dev->seq = -1;
6494d708 SG	226	device_free(dev);
	227
	228	return ret;
	229	}
	230
accd4b19 SG	231	int device_probe(struct udevice *dev)
	232	{
	233	return device_probe_child(dev, NULL);
	234	}
	235
54c5d08a	236	void dev_get_platdata(struct udevice dev)
6494d708 SG	237	{
6494d708 SG	238	if (!dev) {
964d153c	239	dm_warn("%s: null device\n", __func__);
6494d708 SG	240	return NULL;
	241	}
	242
	243	return dev->platdata;
	244	}
	245
54c5d08a	246	void dev_get_priv(struct udevice dev)
6494d708 SG	247	{
6494d708 SG	248	if (!dev) {
964d153c	249	dm_warn("%s: null device\n", __func__);
6494d708 SG	250	return NULL;
	251	}
	252
	253	return dev->priv;
	254	}
997c87bb	255
e59f458d SG	256	void dev_get_parentdata(struct udevice dev)
	257	{
	258	if (!dev) {
964d153c	259	dm_warn("%s: null device\n", __func__);
e59f458d SG	260	return NULL;
	261	}
	262
	263	return dev->parent_priv;
	264	}
	265
997c87bb SG	266	static int device_get_device_tail(struct udevice *dev, int ret,
	267	struct udevice **devp)
	268	{
	269	if (ret)
	270	return ret;
	271
	272	ret = device_probe(dev);
	273	if (ret)
	274	return ret;
	275
	276	*devp = dev;
	277
	278	return 0;
	279	}
	280
	281	int device_get_child(struct udevice parent, int index, struct udevice *devp)
	282	{
	283	struct udevice *dev;
	284
	285	list_for_each_entry(dev, &parent->child_head, sibling_node) {
	286	if (!index--)
	287	return device_get_device_tail(dev, 0, devp);
	288	}
	289
	290	return -ENODEV;
	291	}
	292
	293	int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq,
	294	bool find_req_seq, struct udevice **devp)
	295	{
	296	struct udevice *dev;
	297
	298	*devp = NULL;
	299	if (seq_or_req_seq == -1)
	300	return -ENODEV;
	301
	302	list_for_each_entry(dev, &parent->child_head, sibling_node) {
	303	if ((find_req_seq ? dev->req_seq : dev->seq) ==
	304	seq_or_req_seq) {
	305	*devp = dev;
	306	return 0;
	307	}
	308	}
	309
	310	return -ENODEV;
	311	}
	312
	313	int device_get_child_by_seq(struct udevice *parent, int seq,
	314	struct udevice **devp)
	315	{
	316	struct udevice *dev;
	317	int ret;
	318
	319	*devp = NULL;
	320	ret = device_find_child_by_seq(parent, seq, false, &dev);
	321	if (ret == -ENODEV) {
	322	/*
	323	* We didn't find it in probed devices. See if there is one
	324	* that will request this seq if probed.
	325	*/
	326	ret = device_find_child_by_seq(parent, seq, true, &dev);
	327	}
	328	return device_get_device_tail(dev, ret, devp);
	329	}
330
331	int device_find_child_by_of_offset(struct udevice *parent, int of_offset,
332	struct udevice **devp)
333	{
334	struct udevice *dev;
335
336	*devp = NULL;
337
338	list_for_each_entry(dev, &parent->child_head, sibling_node) {
339	if (dev->of_offset == of_offset) {
340	*devp = dev;
341	return 0;
342	}
343	}
344
345	return -ENODEV;
346	}
347
348	int device_get_child_by_of_offset(struct udevice *parent, int seq,
349	struct udevice **devp)
350	{
351	struct udevice *dev;
352	int ret;
353
354	*devp = NULL;
355	ret = device_find_child_by_of_offset(parent, seq, &dev);
356	return device_get_device_tail(dev, ret, devp);
357	}
a8981d4f SG	358
	359	int device_find_first_child(struct udevice parent, struct udevice *devp)
	360	{
	361	if (list_empty(&parent->child_head)) {
	362	*devp = NULL;
	363	} else {
	364	*devp = list_first_entry(&parent->child_head, struct udevice,
	365	sibling_node);
	366	}
	367
	368	return 0;
	369	}
	370
	371	int device_find_next_child(struct udevice **devp)
	372	{
	373	struct udevice dev = devp;
	374	struct udevice *parent = dev->parent;
	375
	376	if (list_is_last(&dev->sibling_node, &parent->child_head)) {
	377	*devp = NULL;
	378	} else {
	379	*devp = list_entry(dev->sibling_node.next, struct udevice,
	380	sibling_node);
	381	}
	382
	383	return 0;
	384	}
2ef249b4	385
479728cb SG	386	struct udevice dev_get_parent(struct udevice child)
	387	{
	388	return child->parent;
	389	}
	390
2ef249b4 SG	391	ulong dev_get_of_data(struct udevice *dev)
	392	{
	393	return dev->of_id->data;
	394	}