// SPDX-License-Identifier: (GPL-2.0-or-later OR BSD-2-Clause)/* * libfdt - Flat Device Tree manipulation * Copyright (C) 2016 Free Electrons * Copyright (C) 2016 NextThing Co. */#include "libfdt_env.h" #include <fdt.h>#include <libfdt.h> #include "libfdt_internal.h" /** * overlay_get_target_phandle - retrieves the target phandle of a fragment * @fdto: pointer to the device tree overlay blob * @fragment: node offset of the fragment in the overlay * * overlay_get_target_phandle() retrieves the target phandle of an * overlay fragment when that fragment uses a phandle (target * property) instead of a path (target-path property). * * returns: *      the phandle pointed by the target property *      0, if the phandle was not found *	-1, if the phandle was malformed */static uint32_t overlay_get_target_phandle(const void *fdto, int fragment){	const fdt32_t *val;	int len; 	val = fdt_getprop(fdto, fragment, "target", &len);	if (!val)		return 0; 	if ((len != sizeof(*val)) || (fdt32_to_cpu(*val) == (uint32_t)-1))		return (uint32_t)-1; 	return fdt32_to_cpu(*val);} int fdt_overlay_target_offset(const void *fdt, const void *fdto,			      int fragment_offset, char const **pathp){	uint32_t phandle;	const char *path = NULL;	int path_len = 0, ret; 	/* Try first to do a phandle based lookup */	phandle = overlay_get_target_phandle(fdto, fragment_offset);	if (phandle == (uint32_t)-1)		return -FDT_ERR_BADPHANDLE; 	/* no phandle, try path */	if (!phandle) {		/* And then a path based lookup */		path = fdt_getprop(fdto, fragment_offset, "target-path", &path_len);		if (path)			ret = fdt_path_offset(fdt, path);		else			ret = path_len;	} else		ret = fdt_node_offset_by_phandle(fdt, phandle); 	/*	* If we haven't found either a target or a	* target-path property in a node that contains a	* __overlay__ subnode (we wouldn't be called	* otherwise), consider it a improperly written	* overlay	*/	if (ret < 0 && path_len == -FDT_ERR_NOTFOUND)		ret = -FDT_ERR_BADOVERLAY; 	/* return on error */	if (ret < 0)		return ret; 	/* return pointer to path (if available) */	if (pathp)		*pathp = path ? path : NULL; 	return ret;} /** * overlay_phandle_add_offset - Increases a phandle by an offset * @fdt: Base device tree blob * @node: Device tree overlay blob * @name: Name of the property to modify (phandle or linux,phandle) * @delta: offset to apply * * overlay_phandle_add_offset() increments a node phandle by a given * offset. * * returns: *      0 on success. *      Negative error code on error */static int overlay_phandle_add_offset(void *fdt, int node,				      const char *name, uint32_t delta){	fdt32_t *valp, val;	int len; 	valp = fdt_getprop_w(fdt, node, name, &len);	if (!valp)		return len; 	if (len != sizeof(val))		return -FDT_ERR_BADPHANDLE; 	val = fdt32_ld(valp);	if (val + delta < val || val + delta == (uint32_t)-1)		return -FDT_ERR_NOPHANDLES; 	fdt32_st(valp, val + delta);	return 0;} /** * overlay_adjust_node_phandles - Offsets the phandles of a node * @fdto: Device tree overlay blob * @node: Offset of the node we want to adjust * @delta: Offset to shift the phandles of * * overlay_adjust_node_phandles() adds a constant to all the phandles * of a given node. This is mainly use as part of the overlay * application process, when we want to update all the overlay * phandles to not conflict with the overlays of the base device tree. * * returns: *      0 on success *      Negative error code on failure */static int overlay_adjust_node_phandles(void *fdto, int node,					uint32_t delta){	int child;	int ret; 	ret = overlay_phandle_add_offset(fdto, node, "phandle", delta);	if (ret && ret != -FDT_ERR_NOTFOUND)		return ret; 	ret = overlay_phandle_add_offset(fdto, node, "linux,phandle", delta);	if (ret && ret != -FDT_ERR_NOTFOUND)		return ret; 	fdt_for_each_subnode(child, fdto, node) {		ret = overlay_adjust_node_phandles(fdto, child, delta);		if (ret)			return ret;	} 	return 0;} /** * overlay_adjust_local_phandles - Adjust the phandles of a whole overlay * @fdto: Device tree overlay blob * @delta: Offset to shift the phandles of * * overlay_adjust_local_phandles() adds a constant to all the * phandles of an overlay. This is mainly use as part of the overlay * application process, when we want to update all the overlay * phandles to not conflict with the overlays of the base device tree. * * returns: *      0 on success *      Negative error code on failure */static int overlay_adjust_local_phandles(void *fdto, uint32_t delta){	/*	 * Start adjusting the phandles from the overlay root	 */	return overlay_adjust_node_phandles(fdto, 0, delta);} /** * overlay_update_local_node_references - Adjust the overlay references * @fdto: Device tree overlay blob * @tree_node: Node offset of the node to operate on * @fixup_node: Node offset of the matching local fixups node * @delta: Offset to shift the phandles of * * overlay_update_local_nodes_references() update the phandles * pointing to a node within the device tree overlay by adding a * constant delta. * * This is mainly used as part of a device tree application process, * where you want the device tree overlays phandles to not conflict * with the ones from the base device tree before merging them. * * returns: *      0 on success *      Negative error code on failure */static int overlay_update_local_node_references(void *fdto,						int tree_node,						int fixup_node,						uint32_t delta){	int fixup_prop;	int fixup_child;	int ret; 	fdt_for_each_property_offset(fixup_prop, fdto, fixup_node) {		const fdt32_t *fixup_val;		const char *name;		char *tree_val;		int fixup_len;		int tree_len;		int i; 		fixup_val = fdt_getprop_by_offset(fdto, fixup_prop,						  &name, &fixup_len);		if (!fixup_val)			return fixup_len; 		if (fixup_len % sizeof(uint32_t))			return -FDT_ERR_BADOVERLAY;		fixup_len /= sizeof(uint32_t); 		tree_val = fdt_getprop_w(fdto, tree_node, name, &tree_len);		if (!tree_val) {			if (tree_len == -FDT_ERR_NOTFOUND)				return -FDT_ERR_BADOVERLAY; 			return tree_len;		} 		for (i = 0; i < fixup_len; i++) {			fdt32_t *refp; 			refp = (fdt32_t *)(tree_val + fdt32_ld_(fixup_val + i)); 			/*			 * phandles to fixup can be unaligned, so use			 * fdt32_{ld,st}() to read/write them.			 */			fdt32_st(refp, fdt32_ld(refp) + delta);		}	} 	fdt_for_each_subnode(fixup_child, fdto, fixup_node) {		const char *fixup_child_name = fdt_get_name(fdto, fixup_child,							    NULL);		int tree_child; 		tree_child = fdt_subnode_offset(fdto, tree_node,						fixup_child_name);		if (tree_child == -FDT_ERR_NOTFOUND)			return -FDT_ERR_BADOVERLAY;		if (tree_child < 0)			return tree_child; 		ret = overlay_update_local_node_references(fdto,							   tree_child,							   fixup_child,							   delta);		if (ret)			return ret;	} 	return 0;} /** * overlay_update_local_references - Adjust the overlay references * @fdto: Device tree overlay blob * @delta: Offset to shift the phandles of * * overlay_update_local_references() update all the phandles pointing * to a node within the device tree overlay by adding a constant * delta to not conflict with the base overlay. * * This is mainly used as part of a device tree application process, * where you want the device tree overlays phandles to not conflict * with the ones from the base device tree before merging them. * * returns: *      0 on success *      Negative error code on failure */static int overlay_update_local_references(void *fdto, uint32_t delta){	int fixups; 	fixups = fdt_path_offset(fdto, "/__local_fixups__");	if (fixups < 0) {		/* There's no local phandles to adjust, bail out */		if (fixups == -FDT_ERR_NOTFOUND)			return 0; 		return fixups;	} 	/*	 * Update our local references from the root of the tree	 */	return overlay_update_local_node_references(fdto, 0, fixups,						    delta);} /** * overlay_fixup_one_phandle - Set an overlay phandle to the base one * @fdto: Device tree overlay blob * @symbols_off: Node offset of the symbols node in the base device tree * @path: Path to a node holding a phandle in the overlay * @path_len: number of path characters to consider * @name: Name of the property holding the phandle reference in the overlay * @name_len: number of name characters to consider * @poffset: Offset within the overlay property where the phandle is stored * @phandle: Phandle referencing the node * * overlay_fixup_one_phandle() resolves an overlay phandle pointing to * a node in the base device tree. * * This is part of the device tree overlay application process, when * you want all the phandles in the overlay to point to the actual * base dt nodes. * * returns: *      0 on success *      Negative error code on failure */static int overlay_fixup_one_phandle(void *fdto, int symbols_off,				     const char *path, uint32_t path_len,				     const char *name, uint32_t name_len,				     int poffset, uint32_t phandle){	fdt32_t phandle_prop;	int fixup_off; 	if (symbols_off < 0)		return symbols_off; 	fixup_off = fdt_path_offset_namelen(fdto, path, path_len);	if (fixup_off == -FDT_ERR_NOTFOUND)		return -FDT_ERR_BADOVERLAY;	if (fixup_off < 0)		return fixup_off; 	phandle_prop = cpu_to_fdt32(phandle);	return fdt_setprop_inplace_namelen_partial(fdto, fixup_off,						   name, name_len, poffset,						   &phandle_prop,						   sizeof(phandle_prop));} /** * overlay_fixup_phandle - Set an overlay phandle to the base one * @fdt: Base Device Tree blob * @fdto: Device tree overlay blob * @symbols_off: Node offset of the symbols node in the base device tree * @property: Property offset in the overlay holding the list of fixups * * overlay_fixup_phandle() resolves all the overlay phandles pointed * to in a __fixups__ property, and updates them to match the phandles * in use in the base device tree. * * This is part of the device tree overlay application process, when * you want all the phandles in the overlay to point to the actual * base dt nodes. * * returns: *      0 on success *      Negative error code on failure */static int overlay_fixup_phandle(void *fdt, void *fdto, int symbols_off,				 int property){	const char *value;	const char *label;	int len;	const char *symbol_path;	int prop_len;	int symbol_off;	uint32_t phandle; 	value = fdt_getprop_by_offset(fdto, property,				      &label, &len);	if (!value) {		if (len == -FDT_ERR_NOTFOUND)			return -FDT_ERR_INTERNAL; 		return len;	} 	symbol_path = fdt_getprop(fdt, symbols_off, label, &prop_len);	if (!symbol_path)		return prop_len;		symbol_off = fdt_path_offset(fdt, symbol_path);	if (symbol_off < 0)		return symbol_off;		phandle = fdt_get_phandle(fdt, symbol_off);	if (!phandle)		return -FDT_ERR_NOTFOUND; 	do {		const char *path, *name, *fixup_end;		const char *fixup_str = value;		uint32_t path_len, name_len;		uint32_t fixup_len;		const char *sep;		char *endptr;		int poffset, ret; 		fixup_end = memchr(value, '\0', len);		if (!fixup_end)			return -FDT_ERR_BADOVERLAY;		fixup_len = fixup_end - fixup_str; 		len -= fixup_len + 1;		value += fixup_len + 1; 		path = fixup_str;		sep = memchr(fixup_str, ':', fixup_len);		if (!sep || *sep != ':')			return -FDT_ERR_BADOVERLAY; 		path_len = sep - path;		if (path_len == (fixup_len - 1))			return -FDT_ERR_BADOVERLAY; 		fixup_len -= path_len + 1;		name = sep + 1;		sep = memchr(name, ':', fixup_len);		if (!sep || *sep != ':')			return -FDT_ERR_BADOVERLAY; 		name_len = sep - name;		if (!name_len)			return -FDT_ERR_BADOVERLAY; 		poffset = strtoul(sep + 1, &endptr, 10);		if ((*endptr != '\0') || (endptr <= (sep + 1)))			return -FDT_ERR_BADOVERLAY; 		ret = overlay_fixup_one_phandle(fdto, symbols_off,						path, path_len, name, name_len,						poffset, phandle);		if (ret)			return ret;	} while (len > 0); 	return 0;} /** * overlay_fixup_phandles - Resolve the overlay phandles to the base *                          device tree * @fdt: Base Device Tree blob * @fdto: Device tree overlay blob * * overlay_fixup_phandles() resolves all the overlay phandles pointing * to nodes in the base device tree. * * This is one of the steps of the device tree overlay application * process, when you want all the phandles in the overlay to point to * the actual base dt nodes. * * returns: *      0 on success *      Negative error code on failure */static int overlay_fixup_phandles(void *fdt, void *fdto){	int fixups_off, symbols_off;	int property; 	/* We can have overlays without any fixups */	fixups_off = fdt_path_offset(fdto, "/__fixups__");	if (fixups_off == -FDT_ERR_NOTFOUND)		return 0; /* nothing to do */	if (fixups_off < 0)		return fixups_off; 	/* And base DTs without symbols */	symbols_off = fdt_path_offset(fdt, "/__symbols__");	if ((symbols_off < 0 && (symbols_off != -FDT_ERR_NOTFOUND)))		return symbols_off; 	fdt_for_each_property_offset(property, fdto, fixups_off) {		int ret; 		ret = overlay_fixup_phandle(fdt, fdto, symbols_off, property);		if (ret)			return ret;	} 	return 0;} /**

Lines 1–500 of 1101. Load more