[J-u-boot.git] / boot / upl_read.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * UPL handoff parsing
 *
 * Copyright 2024 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEGORY UCLASS_BOOTSTD

#include <log.h>
#include <upl.h>
#include <dm/ofnode.h>
#include "upl_common.h"

/**
 * read_addr() - Read an address
 *
 * Reads an address in the correct format, either 32- or 64-bit
 *
 * @upl: UPL state
 * @node: Node to read from
 * @prop: Property name to read
 * @addr: Place to put the address
 * Return: 0 if OK, -ve on error
 */
static int read_addr(const struct upl *upl, ofnode node, const char *prop,
		     ulong *addrp)
{
	int ret;

	if (upl->addr_cells == 1) {
		u32 val;

		ret = ofnode_read_u32(node, prop, &val);
		if (!ret)
			*addrp = val;
	} else {
		u64 val;

		ret = ofnode_read_u64(node, prop, &val);
		if (!ret)
			*addrp = val;
	}

	return ret;
}

/**
 * read_size() - Read a size
 *
 * Reads a size in the correct format, either 32- or 64-bit
 *
 * @upl: UPL state
 * @node: Node to read from
 * @prop: Property name to read
 * @addr: Place to put the size
 * Return: 0 if OK, -ve on error
 */
static int read_size(const struct upl *upl, ofnode node, const char *prop,
		     ulong *sizep)
{
	int ret;

	if (upl->size_cells == 1) {
		u32 val;

		ret = ofnode_read_u32(node, prop, &val);
		if (!ret)
			*sizep = val;
	} else {
		u64 val;

		ret = ofnode_read_u64(node, prop, &val);
		if (!ret)
			*sizep = val;
	}

	return ret;
}

/**
 * ofnode_read_bitmask() - Read a bit mask from a string list
 *
 * @node: Node to read from
 * @prop: Property name to read
 * @names: Array of names for each bit
 * @count: Number of array entries
 * @value: Returns resulting bit-mask value on success
 * Return: 0 if OK, -EINVAL if a bit number is not defined, -ENOSPC if the
 * string is too long for the (internal) buffer, -EINVAL if no such property
 */
static int ofnode_read_bitmask(ofnode node, const char *prop,
			       const char *const names[], uint count,
			       uint *valuep)
{
	const char **list;
	const char **strp;
	uint val;
	uint bit;
	int ret;

	ret = ofnode_read_string_list(node, prop, &list);
	if (ret < 0)
		return log_msg_ret("rea", ret);

	val = 0;
	for (strp = list; *strp; strp++) {
		const char *str = *strp;
		bool found = false;

		for (bit = 0; bit < count; bit++) {
			if (!strcmp(str, names[bit])) {
				found = true;
				break;
			}
		}
		if (found)
			val |= BIT(bit);
		else
			log_warning("%s/%s: Invalid value '%s'\n",
				    ofnode_get_name(node), prop, str);
	}
	*valuep = val;

	return 0;
}

/**
 * ofnode_read_value() - Read a string value as an int using a lookup
 *
 * @node: Node to read from
 * @prop: Property name to read
 * @names: Array of names for each int value
 * @count: Number of array entries
 * @valuep: Returns int value read
 * Return: 0 if OK, -EINVAL if a bit number is not defined, -ENOENT if the
 * property does not exist
 */
static int ofnode_read_value(ofnode node, const char *prop,
			     const char *const names[], uint count,
			     uint *valuep)
{
	const char *str;
	int i;

	str = ofnode_read_string(node, prop);
	if (!str)
		return log_msg_ret("rd", -ENOENT);

	for (i = 0; i < count; i++) {
		if (!strcmp(names[i], str)) {
			*valuep = i;
			return 0;
		}
	}

	log_debug("Unnamed value '%s'\n", str);
	return log_msg_ret("val", -EINVAL);
}

static int read_uint(ofnode node, const char *prop, uint *valp)
{
	u32 val;
	int ret;

	ret = ofnode_read_u32(node, prop, &val);
	if (ret)
		return ret;
	*valp = val;

	return 0;
}

/**
 * decode_root_props() - Decode root properties from the tree
 *
 * @upl: UPL state
 * @node: Node to decode
 * Return 0 if OK, -ve on error
 */
static int decode_root_props(struct upl *upl, ofnode node)
{
	int ret;

	ret = read_uint(node, UPLP_ADDRESS_CELLS, &upl->addr_cells);
	if (!ret)
		ret = read_uint(node, UPLP_SIZE_CELLS, &upl->size_cells);
	if (ret)
		return log_msg_ret("cel", ret);

	return 0;
}

/**
 * decode_root_props() - Decode UPL parameters from the tree
 *
 * @upl: UPL state
 * @node: Node to decode
 * Return 0 if OK, -ve on error
 */
static int decode_upl_params(struct upl *upl, ofnode options)
{
	ofnode node;
	int ret;

	node = ofnode_find_subnode(options, UPLN_UPL_PARAMS);
	if (!ofnode_valid(node))
		return log_msg_ret("par", -EINVAL);
	log_debug("decoding '%s'\n", ofnode_get_name(node));

	ret = read_addr(upl, node, UPLP_SMBIOS, &upl->smbios);
	if (ret)
		return log_msg_ret("smb", ret);
	ret = read_addr(upl, node, UPLP_ACPI, &upl->acpi);
	if (ret)
		return log_msg_ret("acp", ret);
	ret = ofnode_read_bitmask(node, UPLP_BOOTMODE, bootmode_names,
				  UPLBM_COUNT, &upl->bootmode);
	if (ret)
		return log_msg_ret("boo", ret);
	ret = read_uint(node, UPLP_ADDR_WIDTH, &upl->addr_width);
	if (ret)
		return log_msg_ret("add", ret);
	ret = read_uint(node, UPLP_ACPI_NVS_SIZE, &upl->acpi_nvs_size);
	if (ret)
		return log_msg_ret("nvs", ret);

	return 0;
}

/**
 * decode_upl_images() - Decode /options/upl-image nodes
 *
 * @node: /options node in which to look for the node
 * Return 0 if OK, -ve on error
 */
static int decode_upl_images(struct upl *upl, ofnode options)
{
	ofnode node, images;
	int ret;

	images = ofnode_find_subnode(options, UPLN_UPL_IMAGE);
	if (!ofnode_valid(images))
		return log_msg_ret("img", -EINVAL);
	log_debug("decoding '%s'\n", ofnode_get_name(images));

	ret = read_addr(upl, images, UPLP_FIT, &upl->fit);
	if (!ret)
		ret = read_uint(images, UPLP_CONF_OFFSET, &upl->conf_offset);
	if (ret)
		return log_msg_ret("cnf", ret);

	ofnode_for_each_subnode(node, images) {
		struct upl_image img;

		ret = read_addr(upl, node, UPLP_LOAD, &img.load);
		if (!ret)
			ret = read_size(upl, node, UPLP_SIZE, &img.size);
		if (!ret)
			ret = read_uint(node, UPLP_OFFSET, &img.offset);
		img.description = ofnode_read_string(node, UPLP_DESCRIPTION);
		if (!img.description)
			return log_msg_ret("sim", ret);
		if (!alist_add(&upl->image, img))
			return log_msg_ret("img", -ENOMEM);
	}

	return 0;
}

/**
 * decode_addr_size() - Decide a set of addr/size pairs
 *
 * Each base/size value from the devicetree is written to the region list
 *
 * @upl: UPL state
 * @buf: Bytes to decode
 * @size: Number of bytes to decode
 * @regions: List of regions to process (struct memregion)
 * Returns: number of regions found, if OK, else -ve on error
 */
static int decode_addr_size(const struct upl *upl, const char *buf, int size,
			    struct alist *regions)
{
	const char *ptr, *end = buf + size;
	int i;

	alist_init_struct(regions, struct memregion);
	ptr = buf;
	for (i = 0; ptr < end; i++) {
		struct memregion reg;

		if (upl->addr_cells == 1)
			reg.base = fdt32_to_cpu(*(u32 *)ptr);
		else
			reg.base = fdt64_to_cpu(*(u64 *)ptr);
		ptr += upl->addr_cells * sizeof(u32);

		if (upl->size_cells == 1)
			reg.size = fdt32_to_cpu(*(u32 *)ptr);
		else
			reg.size = fdt64_to_cpu(*(u64 *)ptr);
		ptr += upl->size_cells * sizeof(u32);
		if (ptr > end)
			return -ENOSPC;

		if (!alist_add(regions, reg))
			return log_msg_ret("reg", -ENOMEM);
	}

	return i;
}

/**
 * node_matches_at() - Check if a node name matches "base@..."
 *
 * Return: true if the node name matches the base string followed by an @ sign;
 * false otherwise
 */
static bool node_matches_at(ofnode node, const char *base)
{
	const char *name = ofnode_get_name(node);
	int len = strlen(base);

	return !strncmp(base, name, len) && name[len] == '@';
}

/**
 * decode_upl_memory_node() - Decode a /memory node from the tree
 *
 * @upl: UPL state
 * @node: Node to decode
 * Return 0 if OK, -ve on error
 */
static int decode_upl_memory_node(struct upl *upl, ofnode node)
{
	struct upl_mem mem;
	const char *buf;
	int size, len;

	buf = ofnode_read_prop(node, UPLP_REG, &size);
	if (!buf) {
		log_warning("Node '%s': Missing '%s' property\n",
			    ofnode_get_name(node), UPLP_REG);
		return log_msg_ret("reg", -EINVAL);
	}
	len = decode_addr_size(upl, buf, size, &mem.region);
	if (len < 0)
		return log_msg_ret("buf", len);
	mem.hotpluggable = ofnode_read_bool(node, UPLP_HOTPLUGGABLE);
	if (!alist_add(&upl->mem, mem))
		return log_msg_ret("mem", -ENOMEM);

	return 0;
}

/**
 * decode_upl_memmap() - Decode memory-map nodes from the tree
 *
 * @upl: UPL state
 * @root: Parent node containing the /memory-map nodes
 * Return 0 if OK, -ve on error
 */
static int decode_upl_memmap(struct upl *upl, ofnode root)
{
	ofnode node;

	ofnode_for_each_subnode(node, root) {
		struct upl_memmap memmap;
		int size, len, ret;
		const char *buf;

		memmap.name = ofnode_get_name(node);
		memmap.usage = 0;

		buf = ofnode_read_prop(node, UPLP_REG, &size);
		if (!buf) {
			log_warning("Node '%s': Missing '%s' property\n",
				    ofnode_get_name(node), UPLP_REG);
			continue;
		}

		len = decode_addr_size(upl, buf, size, &memmap.region);
		if (len < 0)
			return log_msg_ret("buf", len);
		ret = ofnode_read_bitmask(node, UPLP_USAGE, usage_names,
					  UPLUS_COUNT, &memmap.usage);
		if (ret && ret != -EINVAL)	/* optional property */
			return log_msg_ret("bit", ret);

		if (!alist_add(&upl->memmap, memmap))
			return log_msg_ret("mmp", -ENOMEM);
	}

	return 0;
}

/**
 * decode_upl_memres() - Decode reserved-memory nodes from the tree
 *
 * @upl: UPL state
 * @root: Parent node containing the reserved-memory nodes
 * Return 0 if OK, -ve on error
 */
static int decode_upl_memres(struct upl *upl, ofnode root)
{
	ofnode node;

	ofnode_for_each_subnode(node, root) {
		struct upl_memres memres;
		const char *buf;
		int size, len;

		log_debug("decoding '%s'\n", ofnode_get_name(node));
		memres.name = ofnode_get_name(node);

		buf = ofnode_read_prop(node, UPLP_REG, &size);
		if (!buf) {
			log_warning("Node '%s': Missing 'reg' property\n",
				    ofnode_get_name(node));
			continue;
		}

		len = decode_addr_size(upl, buf, size, &memres.region);
		if (len < 0)
			return log_msg_ret("buf", len);
		memres.no_map = ofnode_read_bool(node, UPLP_NO_MAP);

		if (!alist_add(&upl->memres, memres))
			return log_msg_ret("mre", -ENOMEM);
	}

	return 0;
}

/**
 * decode_upl_serial() - Decode the serial node
 *
 * @upl: UPL state
 * @root: Parent node contain node
 * Return 0 if OK, -ve on error
 */
static int decode_upl_serial(struct upl *upl, ofnode node)
{
	struct upl_serial *ser = &upl->serial;
	const char *buf;
	int len, size;
	int ret;

	ser->compatible = ofnode_read_string(node, UPLP_COMPATIBLE);
	if (!ser->compatible) {
		log_warning("Node '%s': Missing compatible string\n",
			    ofnode_get_name(node));
		return log_msg_ret("com", -EINVAL);
	}
	ret = read_uint(node, UPLP_CLOCK_FREQUENCY, &ser->clock_frequency);
	if (!ret)
		ret = read_uint(node, UPLP_CURRENT_SPEED, &ser->current_speed);
	if (ret)
		return log_msg_ret("spe", ret);

	buf = ofnode_read_prop(node, UPLP_REG, &size);
	if (!buf) {
		log_warning("Node '%s': Missing 'reg' property\n",
			    ofnode_get_name(node));
		return log_msg_ret("reg", -EINVAL);
	}

	len = decode_addr_size(upl, buf, sizeof(buf), &ser->reg);
	if (len < 0)
		return log_msg_ret("buf", len);

	/* set defaults */
	ser->reg_io_shift = UPLD_REG_IO_SHIFT;
	ser->reg_offset = UPLD_REG_OFFSET;
	ser->reg_io_width = UPLD_REG_IO_WIDTH;
	read_uint(node, UPLP_REG_IO_SHIFT, &ser->reg_io_shift);
	read_uint(node, UPLP_REG_OFFSET, &ser->reg_offset);
	read_uint(node, UPLP_REG_IO_WIDTH, &ser->reg_io_width);
	read_addr(upl, node, UPLP_VIRTUAL_REG, &ser->virtual_reg);
	ret = ofnode_read_value(node, UPLP_ACCESS_TYPE, access_types,
				ARRAY_SIZE(access_types), &ser->access_type);
	if (ret && ret != -ENOENT)
		return log_msg_ret("ser", ret);

	return 0;
}

/**
 * decode_upl_graphics() - Decode graphics node
 *
 * @upl: UPL state
 * @root: Node to decode
 * Return 0 if OK, -ve on error
 */
static int decode_upl_graphics(struct upl *upl, ofnode node)
{
	struct upl_graphics *gra = &upl->graphics;
	const char *buf, *compat;
	int len, size;
	int ret;

	compat = ofnode_read_string(node, UPLP_COMPATIBLE);
	if (!compat) {
		log_warning("Node '%s': Missing compatible string\n",
			    ofnode_get_name(node));
		return log_msg_ret("com", -EINVAL);
	}
	if (strcmp(UPLC_GRAPHICS, compat)) {
		log_warning("Node '%s': Ignoring compatible '%s'\n",
			    ofnode_get_name(node), compat);
		return 0;
	}

	buf = ofnode_read_prop(node, UPLP_REG, &size);
	if (!buf) {
		log_warning("Node '%s': Missing 'reg' property\n",
			    ofnode_get_name(node));
		return log_msg_ret("reg", -EINVAL);
	}

	len = decode_addr_size(upl, buf, sizeof(buf), &gra->reg);
	if (len < 0)
		return log_msg_ret("buf", len);

	ret = read_uint(node, UPLP_WIDTH, &gra->width);
	if (!ret)
		ret = read_uint(node, UPLP_HEIGHT, &gra->height);
	if (!ret)
		ret = read_uint(node, UPLP_STRIDE, &gra->stride);
	if (!ret) {
		ret = ofnode_read_value(node, UPLP_GRAPHICS_FORMAT,
					graphics_formats,
					ARRAY_SIZE(graphics_formats),
					&gra->format);
	}
	if (ret)
		return log_msg_ret("pro", ret);

	return 0;
}

int upl_read_handoff(struct upl *upl, oftree tree)
{
	ofnode root, node;
	int ret;

	if (!oftree_valid(tree))
		return log_msg_ret("tre", -EINVAL);

	root = oftree_root(tree);

	upl_init(upl);
	ret = decode_root_props(upl, root);
	if (ret)
		return log_msg_ret("roo", ret);

	ofnode_for_each_subnode(node, root) {
		const char *name = ofnode_get_name(node);

		log_debug("decoding '%s'\n", name);
		if (!strcmp(UPLN_OPTIONS, name)) {
			ret = decode_upl_params(upl, node);
			if (ret)
				return log_msg_ret("opt", ret);

			ret = decode_upl_images(upl, node);
		} else if (node_matches_at(node, UPLN_MEMORY)) {
			ret = decode_upl_memory_node(upl, node);
		} else if (!strcmp(UPLN_MEMORY_MAP, name)) {
			ret = decode_upl_memmap(upl, node);
		} else if (!strcmp(UPLN_MEMORY_RESERVED, name)) {
			ret = decode_upl_memres(upl, node);
		} else if (node_matches_at(node, UPLN_SERIAL)) {
			ret = decode_upl_serial(upl, node);
		} else if (node_matches_at(node, UPLN_GRAPHICS)) {
			ret = decode_upl_graphics(upl, node);
		} else {
			log_debug("Unknown node '%s'\n", name);
			ret = 0;
		}
		if (ret)
			return log_msg_ret("err", ret);
	}

	return 0;
}
Commit	Line	Data
90469da3 SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* UPL handoff parsing
	4	*
	5	* Copyright 2024 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
	9	#define LOG_CATEGORY UCLASS_BOOTSTD
	10
	11	#include <log.h>
	12	#include <upl.h>
	13	#include <dm/ofnode.h>
	14	#include "upl_common.h"
	15
	16	/**
	17	* read_addr() - Read an address
	18	*
	19	* Reads an address in the correct format, either 32- or 64-bit
	20	*
	21	* @upl: UPL state
	22	* @node: Node to read from
	23	* @prop: Property name to read
	24	* @addr: Place to put the address
	25	* Return: 0 if OK, -ve on error
	26	*/
	27	static int read_addr(const struct upl upl, ofnode node, const char prop,
	28	ulong *addrp)
	29	{
	30	int ret;
	31
	32	if (upl->addr_cells == 1) {
	33	u32 val;
	34
	35	ret = ofnode_read_u32(node, prop, &val);
	36	if (!ret)
	37	*addrp = val;
	38	} else {
	39	u64 val;
	40
	41	ret = ofnode_read_u64(node, prop, &val);
	42	if (!ret)
	43	*addrp = val;
	44	}
	45
	46	return ret;
	47	}
	48
	49	/**
	50	* read_size() - Read a size
	51	*
	52	* Reads a size in the correct format, either 32- or 64-bit
	53	*
	54	* @upl: UPL state
	55	* @node: Node to read from
	56	* @prop: Property name to read
	57	* @addr: Place to put the size
	58	* Return: 0 if OK, -ve on error
	59	*/
	60	static int read_size(const struct upl upl, ofnode node, const char prop,
	61	ulong *sizep)
	62	{
	63	int ret;
	64
65	if (upl->size_cells == 1) {
66	u32 val;
67
68	ret = ofnode_read_u32(node, prop, &val);
69	if (!ret)
70	*sizep = val;
71	} else {
72	u64 val;
73
74	ret = ofnode_read_u64(node, prop, &val);
75	if (!ret)
76	*sizep = val;
77	}
78
79	return ret;
80	}
81
82	/**
83	* ofnode_read_bitmask() - Read a bit mask from a string list
84	*
85	* @node: Node to read from
86	* @prop: Property name to read
87	* @names: Array of names for each bit
88	* @count: Number of array entries
89	* @value: Returns resulting bit-mask value on success
90	* Return: 0 if OK, -EINVAL if a bit number is not defined, -ENOSPC if the
91	* string is too long for the (internal) buffer, -EINVAL if no such property
92	*/
93	static int ofnode_read_bitmask(ofnode node, const char *prop,
94	const char *const names[], uint count,
95	uint *valuep)
96	{
97	const char **list;
98	const char **strp;
99	uint val;
100	uint bit;
101	int ret;
102
103	ret = ofnode_read_string_list(node, prop, &list);
104	if (ret < 0)
105	return log_msg_ret("rea", ret);
106
107	val = 0;
108	for (strp = list; *strp; strp++) {
109	const char str = strp;
110	bool found = false;
111
112	for (bit = 0; bit < count; bit++) {
113	if (!strcmp(str, names[bit])) {
114	found = true;
115	break;
116	}
117	}
118	if (found)
119	val \|= BIT(bit);
120	else
121	log_warning("%s/%s: Invalid value '%s'\n",
122	ofnode_get_name(node), prop, str);
123	}
124	*valuep = val;
125
126	return 0;
127	}
128
129	/**
130	* ofnode_read_value() - Read a string value as an int using a lookup
131	*
132	* @node: Node to read from
133	* @prop: Property name to read
134	* @names: Array of names for each int value
135	* @count: Number of array entries
136	* @valuep: Returns int value read
137	* Return: 0 if OK, -EINVAL if a bit number is not defined, -ENOENT if the
138	* property does not exist
139	*/
140	static int ofnode_read_value(ofnode node, const char *prop,
141	const char *const names[], uint count,
142	uint *valuep)
143	{
144	const char *str;
145	int i;
146
147	str = ofnode_read_string(node, prop);
148	if (!str)
149	return log_msg_ret("rd", -ENOENT);
150
151	for (i = 0; i < count; i++) {
152	if (!strcmp(names[i], str)) {
153	*valuep = i;
154	return 0;
155	}
156	}
157
158	log_debug("Unnamed value '%s'\n", str);
159	return log_msg_ret("val", -EINVAL);
160	}
161
162	static int read_uint(ofnode node, const char prop, uint valp)
163	{
164	u32 val;
165	int ret;
166
167	ret = ofnode_read_u32(node, prop, &val);
168	if (ret)
169	return ret;
170	*valp = val;
171
172	return 0;
173	}
174
175	/**
176	* decode_root_props() - Decode root properties from the tree
177	*
178	* @upl: UPL state
179	* @node: Node to decode
180	* Return 0 if OK, -ve on error
181	*/
182	static int decode_root_props(struct upl *upl, ofnode node)
183	{
184	int ret;
185
186	ret = read_uint(node, UPLP_ADDRESS_CELLS, &upl->addr_cells);
187	if (!ret)
188	ret = read_uint(node, UPLP_SIZE_CELLS, &upl->size_cells);
189	if (ret)
190	return log_msg_ret("cel", ret);
191
192	return 0;
193	}
194
195	/**
196	* decode_root_props() - Decode UPL parameters from the tree
197	*
198	* @upl: UPL state
199	* @node: Node to decode
200	* Return 0 if OK, -ve on error
201	*/
202	static int decode_upl_params(struct upl *upl, ofnode options)
203	{
204	ofnode node;
205	int ret;
206
207	node = ofnode_find_subnode(options, UPLN_UPL_PARAMS);
208	if (!ofnode_valid(node))
209	return log_msg_ret("par", -EINVAL);
210	log_debug("decoding '%s'\n", ofnode_get_name(node));
211
212	ret = read_addr(upl, node, UPLP_SMBIOS, &upl->smbios);
213	if (ret)
214	return log_msg_ret("smb", ret);
215	ret = read_addr(upl, node, UPLP_ACPI, &upl->acpi);
216	if (ret)
217	return log_msg_ret("acp", ret);
218	ret = ofnode_read_bitmask(node, UPLP_BOOTMODE, bootmode_names,
219	UPLBM_COUNT, &upl->bootmode);
220	if (ret)
221	return log_msg_ret("boo", ret);
222	ret = read_uint(node, UPLP_ADDR_WIDTH, &upl->addr_width);
223	if (ret)
224	return log_msg_ret("add", ret);
225	ret = read_uint(node, UPLP_ACPI_NVS_SIZE, &upl->acpi_nvs_size);
226	if (ret)
227	return log_msg_ret("nvs", ret);
228
229	return 0;
230	}
231
232	/**
233	* decode_upl_images() - Decode /options/upl-image nodes
234	*
235	* @node: /options node in which to look for the node
236	* Return 0 if OK, -ve on error
237	*/
238	static int decode_upl_images(struct upl *upl, ofnode options)
239	{
240	ofnode node, images;
241	int ret;
242
243	images = ofnode_find_subnode(options, UPLN_UPL_IMAGE);
244	if (!ofnode_valid(images))
245	return log_msg_ret("img", -EINVAL);
246	log_debug("decoding '%s'\n", ofnode_get_name(images));
247
248	ret = read_addr(upl, images, UPLP_FIT, &upl->fit);
249	if (!ret)
250	ret = read_uint(images, UPLP_CONF_OFFSET, &upl->conf_offset);
251	if (ret)
252	return log_msg_ret("cnf", ret);
253
254	ofnode_for_each_subnode(node, images) {
255	struct upl_image img;
256
257	ret = read_addr(upl, node, UPLP_LOAD, &img.load);
258	if (!ret)
259	ret = read_size(upl, node, UPLP_SIZE, &img.size);
260	if (!ret)
261	ret = read_uint(node, UPLP_OFFSET, &img.offset);
262	img.description = ofnode_read_string(node, UPLP_DESCRIPTION);
263	if (!img.description)
264	return log_msg_ret("sim", ret);
265	if (!alist_add(&upl->image, img))
266	return log_msg_ret("img", -ENOMEM);
267	}
268
269	return 0;
270	}
271
272	/**
273	* decode_addr_size() - Decide a set of addr/size pairs
274	*
275	* Each base/size value from the devicetree is written to the region list
276	*
277	* @upl: UPL state
278	* @buf: Bytes to decode
279	* @size: Number of bytes to decode
280	* @regions: List of regions to process (struct memregion)
281	* Returns: number of regions found, if OK, else -ve on error
282	*/
283	static int decode_addr_size(const struct upl upl, const char buf, int size,
284	struct alist *regions)
285	{
286	const char ptr, end = buf + size;
287	int i;
288
289	alist_init_struct(regions, struct memregion);
290	ptr = buf;
291	for (i = 0; ptr < end; i++) {
292	struct memregion reg;
293
294	if (upl->addr_cells == 1)
295	reg.base = fdt32_to_cpu((u32 )ptr);
296	else
297	reg.base = fdt64_to_cpu((u64 )ptr);
298	ptr += upl->addr_cells * sizeof(u32);
299
300	if (upl->size_cells == 1)
301	reg.size = fdt32_to_cpu((u32 )ptr);
302	else
303	reg.size = fdt64_to_cpu((u64 )ptr);
304	ptr += upl->size_cells * sizeof(u32);
305	if (ptr > end)
306	return -ENOSPC;
307
308	if (!alist_add(regions, reg))
309	return log_msg_ret("reg", -ENOMEM);
310	}
311
312	return i;
313	}
314
315	/**
316	* node_matches_at() - Check if a node name matches "base@..."
317	*
318	* Return: true if the node name matches the base string followed by an @ sign;
319	* false otherwise
320	*/
321	static bool node_matches_at(ofnode node, const char *base)
322	{
323	const char *name = ofnode_get_name(node);
324	int len = strlen(base);
325
326	return !strncmp(base, name, len) && name[len] == '@';
327	}
328
329	/**
330	* decode_upl_memory_node() - Decode a /memory node from the tree
331	*
332	* @upl: UPL state
333	* @node: Node to decode
334	* Return 0 if OK, -ve on error
335	*/
336	static int decode_upl_memory_node(struct upl *upl, ofnode node)
337	{
338	struct upl_mem mem;
339	const char *buf;
340	int size, len;
341
342	buf = ofnode_read_prop(node, UPLP_REG, &size);
343	if (!buf) {
344	log_warning("Node '%s': Missing '%s' property\n",
345	ofnode_get_name(node), UPLP_REG);
346	return log_msg_ret("reg", -EINVAL);
347	}
348	len = decode_addr_size(upl, buf, size, &mem.region);
349	if (len < 0)
350	return log_msg_ret("buf", len);
351	mem.hotpluggable = ofnode_read_bool(node, UPLP_HOTPLUGGABLE);
352	if (!alist_add(&upl->mem, mem))
353	return log_msg_ret("mem", -ENOMEM);
354
355	return 0;
356	}
357
358	/**
359	* decode_upl_memmap() - Decode memory-map nodes from the tree
360	*
361	* @upl: UPL state
362	* @root: Parent node containing the /memory-map nodes
363	* Return 0 if OK, -ve on error
364	*/
365	static int decode_upl_memmap(struct upl *upl, ofnode root)
366	{
367	ofnode node;
368
369	ofnode_for_each_subnode(node, root) {
370	struct upl_memmap memmap;
371	int size, len, ret;
372	const char *buf;
373
374	memmap.name = ofnode_get_name(node);
375	memmap.usage = 0;
376
377	buf = ofnode_read_prop(node, UPLP_REG, &size);
378	if (!buf) {
379	log_warning("Node '%s': Missing '%s' property\n",
380	ofnode_get_name(node), UPLP_REG);
381	continue;
382	}
383
384	len = decode_addr_size(upl, buf, size, &memmap.region);
385	if (len < 0)
386	return log_msg_ret("buf", len);
387	ret = ofnode_read_bitmask(node, UPLP_USAGE, usage_names,
388	UPLUS_COUNT, &memmap.usage);
389	if (ret && ret != -EINVAL) /* optional property */
390	return log_msg_ret("bit", ret);
391
392	if (!alist_add(&upl->memmap, memmap))
393	return log_msg_ret("mmp", -ENOMEM);
394	}
395
396	return 0;
397	}
398
399	/**
400	* decode_upl_memres() - Decode reserved-memory nodes from the tree
401	*
402	* @upl: UPL state
403	* @root: Parent node containing the reserved-memory nodes
404	* Return 0 if OK, -ve on error
405	*/
406	static int decode_upl_memres(struct upl *upl, ofnode root)
407	{
408	ofnode node;
409
410	ofnode_for_each_subnode(node, root) {
411	struct upl_memres memres;
412	const char *buf;
413	int size, len;
414
415	log_debug("decoding '%s'\n", ofnode_get_name(node));
416	memres.name = ofnode_get_name(node);
417
418	buf = ofnode_read_prop(node, UPLP_REG, &size);
419	if (!buf) {
420	log_warning("Node '%s': Missing 'reg' property\n",
421	ofnode_get_name(node));
422	continue;
423	}
424
425	len = decode_addr_size(upl, buf, size, &memres.region);
426	if (len < 0)
427	return log_msg_ret("buf", len);
428	memres.no_map = ofnode_read_bool(node, UPLP_NO_MAP);
429
430	if (!alist_add(&upl->memres, memres))
431	return log_msg_ret("mre", -ENOMEM);
432	}
433
434	return 0;
435	}
436
437	/**
438	* decode_upl_serial() - Decode the serial node
439	*
440	* @upl: UPL state
441	* @root: Parent node contain node
442	* Return 0 if OK, -ve on error
443	*/
444	static int decode_upl_serial(struct upl *upl, ofnode node)
445	{
446	struct upl_serial *ser = &upl->serial;
447	const char *buf;
448	int len, size;
449	int ret;
450
451	ser->compatible = ofnode_read_string(node, UPLP_COMPATIBLE);
452	if (!ser->compatible) {
453	log_warning("Node '%s': Missing compatible string\n",
454	ofnode_get_name(node));
455	return log_msg_ret("com", -EINVAL);
456	}
457	ret = read_uint(node, UPLP_CLOCK_FREQUENCY, &ser->clock_frequency);
458	if (!ret)
459	ret = read_uint(node, UPLP_CURRENT_SPEED, &ser->current_speed);
460	if (ret)
461	return log_msg_ret("spe", ret);
462
463	buf = ofnode_read_prop(node, UPLP_REG, &size);
464	if (!buf) {
465	log_warning("Node '%s': Missing 'reg' property\n",
466	ofnode_get_name(node));
467	return log_msg_ret("reg", -EINVAL);
468	}
469
470	len = decode_addr_size(upl, buf, sizeof(buf), &ser->reg);
471	if (len < 0)
472	return log_msg_ret("buf", len);
473
474	/* set defaults */
475	ser->reg_io_shift = UPLD_REG_IO_SHIFT;
476	ser->reg_offset = UPLD_REG_OFFSET;
477	ser->reg_io_width = UPLD_REG_IO_WIDTH;
478	read_uint(node, UPLP_REG_IO_SHIFT, &ser->reg_io_shift);
479	read_uint(node, UPLP_REG_OFFSET, &ser->reg_offset);
480	read_uint(node, UPLP_REG_IO_WIDTH, &ser->reg_io_width);
481	read_addr(upl, node, UPLP_VIRTUAL_REG, &ser->virtual_reg);
482	ret = ofnode_read_value(node, UPLP_ACCESS_TYPE, access_types,
483	ARRAY_SIZE(access_types), &ser->access_type);
484	if (ret && ret != -ENOENT)
485	return log_msg_ret("ser", ret);
486
487	return 0;
488	}
489
490	/**
491	* decode_upl_graphics() - Decode graphics node
492	*
493	* @upl: UPL state
494	* @root: Node to decode
495	* Return 0 if OK, -ve on error
496	*/
497	static int decode_upl_graphics(struct upl *upl, ofnode node)
498	{
499	struct upl_graphics *gra = &upl->graphics;
500	const char buf, compat;
501	int len, size;
502	int ret;
503
504	compat = ofnode_read_string(node, UPLP_COMPATIBLE);
505	if (!compat) {
506	log_warning("Node '%s': Missing compatible string\n",
507	ofnode_get_name(node));
508	return log_msg_ret("com", -EINVAL);
509	}
510	if (strcmp(UPLC_GRAPHICS, compat)) {
511	log_warning("Node '%s': Ignoring compatible '%s'\n",
512	ofnode_get_name(node), compat);
513	return 0;
514	}
515
516	buf = ofnode_read_prop(node, UPLP_REG, &size);
517	if (!buf) {
518	log_warning("Node '%s': Missing 'reg' property\n",
519	ofnode_get_name(node));
520	return log_msg_ret("reg", -EINVAL);
521	}
522
523	len = decode_addr_size(upl, buf, sizeof(buf), &gra->reg);
524	if (len < 0)
525	return log_msg_ret("buf", len);
526
527	ret = read_uint(node, UPLP_WIDTH, &gra->width);
528	if (!ret)
529	ret = read_uint(node, UPLP_HEIGHT, &gra->height);
530	if (!ret)
531	ret = read_uint(node, UPLP_STRIDE, &gra->stride);
532	if (!ret) {
533	ret = ofnode_read_value(node, UPLP_GRAPHICS_FORMAT,
534	graphics_formats,
535	ARRAY_SIZE(graphics_formats),
536	&gra->format);
537	}
538	if (ret)
539	return log_msg_ret("pro", ret);
540
541	return 0;
542	}
543
544	int upl_read_handoff(struct upl *upl, oftree tree)
545	{
546	ofnode root, node;
547	int ret;
548
549	if (!oftree_valid(tree))
550	return log_msg_ret("tre", -EINVAL);
551
552	root = oftree_root(tree);
553
554	upl_init(upl);
555	ret = decode_root_props(upl, root);
556	if (ret)
557	return log_msg_ret("roo", ret);
558
559	ofnode_for_each_subnode(node, root) {
560	const char *name = ofnode_get_name(node);
561
562	log_debug("decoding '%s'\n", name);
563	if (!strcmp(UPLN_OPTIONS, name)) {
564	ret = decode_upl_params(upl, node);
565	if (ret)
566	return log_msg_ret("opt", ret);
567
568	ret = decode_upl_images(upl, node);
569	} else if (node_matches_at(node, UPLN_MEMORY)) {
570	ret = decode_upl_memory_node(upl, node);
571	} else if (!strcmp(UPLN_MEMORY_MAP, name)) {
572	ret = decode_upl_memmap(upl, node);
573	} else if (!strcmp(UPLN_MEMORY_RESERVED, name)) {
574	ret = decode_upl_memres(upl, node);
575	} else if (node_matches_at(node, UPLN_SERIAL)) {
576	ret = decode_upl_serial(upl, node);
577	} else if (node_matches_at(node, UPLN_GRAPHICS)) {
578	ret = decode_upl_graphics(upl, node);
579	} else {
580	log_debug("Unknown node '%s'\n", name);
581	ret = 0;
582	}
583	if (ret)
584	return log_msg_ret("err", ret);
585	}
586
587	return 0;
588	}