dm: core: Add livetree address functions

Add functions to access addresses in the device tree. These are brought in from Linux 4.10. Also fix up the header guard for fdtaddr.h to avoid confusion. Signed-off-by: Simon Glass <sjg@chromium.org>

dm: core: Add livetree address functions
Add functions to access addresses in the device tree. These are brought in from Linux 4.10. Also fix up the header guard for fdtaddr.h to avoid confusion. Signed-off-by: Simon Glass <sjg@chromium.org>
Simon Glass
1 parent 9e51204527
Showing 4 changed files with 426 additions and 3 deletions Side-by-side Diff
drivers/core/Makefile
drivers/core/of_addr.c
include/dm/fdtaddr.h
include/dm/of_addr.h
@@ -11,6 +11,6 @@
 obj-$(CONFIG_DM)	+= dump.o
 obj-$(CONFIG_$(SPL_)REGMAP)	+= regmap.o
 obj-$(CONFIG_$(SPL_)SYSCON)	+= syscon-uclass.o
-obj-$(CONFIG_OF_LIVE) += of_access.o
+obj-$(CONFIG_OF_LIVE) += of_access.o of_addr.o
 obj-$(CONFIG_OF_CONTROL) += ofnode.o
+/*
+ * Taken from Linux v4.9 drivers/of/address.c
+ *
+ * Modified for U-Boot
+ * Copyright (c) 2017 Google, Inc
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <libfdt.h>
+#include <dm/of_access.h>
+#include <dm/of_addr.h>
+#include <linux/err.h>
+#include <linux/ioport.h>
+
+/* Max address size we deal with */
+#define OF_MAX_ADDR_CELLS	4
+#define OF_CHECK_ADDR_COUNT(na)	((na) > 0 && (na) <= OF_MAX_ADDR_CELLS)
+#define OF_CHECK_COUNTS(na, ns)	(OF_CHECK_ADDR_COUNT(na) && (ns) > 0)
+
+static struct of_bus *of_match_bus(struct device_node *np);
+
+/* Debug utility */
+#ifdef DEBUG
+static void of_dump_addr(const char *s, const __be32 *addr, int na)
+{
+	debug("%s", s);
+	while (na--)
+		pr_cont(" %08x", be32_to_cpu(*(addr++)));
+	pr_cont("\n");
+}
+#else
+static void of_dump_addr(const char *s, const __be32 *addr, int na) { }
+#endif
+
+/* Callbacks for bus specific translators */
+struct of_bus {
+	const char *name;
+	const char *addresses;
+	int (*match)(struct device_node *parent);
+	void (*count_cells)(const struct device_node *child, int *addrc,
+			    int *sizec);
+	u64 (*map)(__be32 *addr, const __be32 *range, int na, int ns, int pna);
+	int (*translate)(__be32 *addr, u64 offset, int na);
+	unsigned int (*get_flags)(const __be32 *addr);
+};
+
+static void of_bus_default_count_cells(const struct device_node *np,
+				       int *addrc, int *sizec)
+{
+	if (addrc)
+		*addrc = of_n_addr_cells(np);
+	if (sizec)
+		*sizec = of_n_size_cells(np);
+}
+
+static u64 of_bus_default_map(__be32 *addr, const __be32 *range,
+		int na, int ns, int pna)
+{
+	u64 cp, s, da;
+
+	cp = of_read_number(range, na);
+	s  = of_read_number(range + na + pna, ns);
+	da = of_read_number(addr, na);
+
+	debug("default map, cp=%llx, s=%llx, da=%llx\n",
+	      (unsigned long long)cp, (unsigned long long)s,
+	      (unsigned long long)da);
+
+	if (da < cp || da >= (cp + s))
+		return OF_BAD_ADDR;
+	return da - cp;
+}
+
+static int of_bus_default_translate(__be32 *addr, u64 offset, int na)
+{
+	u64 a = of_read_number(addr, na);
+	memset(addr, 0, na * 4);
+	a += offset;
+	if (na > 1)
+		addr[na - 2] = cpu_to_be32(a >> 32);
+	addr[na - 1] = cpu_to_be32(a & 0xffffffffu);
+
+	return 0;
+}
+
+static unsigned int of_bus_default_get_flags(const __be32 *addr)
+{
+	return IORESOURCE_MEM;
+}
+
+/*
+ * Array of bus-specific translators
+ */
+static struct of_bus of_busses[] = {
+	/* Default */
+	{
+		.name = "default",
+		.addresses = "reg",
+		.match = NULL,
+		.count_cells = of_bus_default_count_cells,
+		.map = of_bus_default_map,
+		.translate = of_bus_default_translate,
+		.get_flags = of_bus_default_get_flags,
+	},
+};
+
+static struct of_bus *of_match_bus(struct device_node *np)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(of_busses); i++)
+		if (!of_busses[i].match || of_busses[i].match(np))
+			return &of_busses[i];
+	BUG();
+	return NULL;
+}
+
+static void dev_count_cells(const struct device_node *np, int *nap, int *nsp)
+{
+	of_bus_default_count_cells(np, nap, nsp);
+}
+
+const __be32 *of_get_address(const struct device_node *dev, int index,
+			     u64 *size, unsigned int *flags)
+{
+	const __be32 *prop;
+	int psize;
+	struct device_node *parent;
+	struct of_bus *bus;
+	int onesize, i, na, ns;
+
+	/* Get parent & match bus type */
+	parent = of_get_parent(dev);
+	if (parent == NULL)
+		return NULL;
+	dev_count_cells(dev, &na, &ns);
+	bus = of_match_bus(parent);
+	bus->count_cells(dev, &na, &ns);
+	of_node_put(parent);
+	if (!OF_CHECK_ADDR_COUNT(na))
+		return NULL;
+
+	/* Get "reg" or "assigned-addresses" property */
+	prop = of_get_property(dev, "reg", &psize);
+	if (prop == NULL)
+		return NULL;
+	psize /= 4;
+
+	onesize = na + ns;
+	for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
+		if (i == index) {
+			if (size)
+				*size = of_read_number(prop + na, ns);
+			if (flags)
+				*flags = bus->get_flags(prop);
+			return prop;
+		}
+	return NULL;
+}
+EXPORT_SYMBOL(of_get_address);
+
+static int of_empty_ranges_quirk(const struct device_node *np)
+{
+	return false;
+}
+
+static int of_translate_one(const struct device_node *parent,
+			    struct of_bus *bus, struct of_bus *pbus,
+			    __be32 *addr, int na, int ns, int pna,
+			    const char *rprop)
+{
+	const __be32 *ranges;
+	int rlen;
+	int rone;
+	u64 offset = OF_BAD_ADDR;
+
+	/*
+	 * Normally, an absence of a "ranges" property means we are
+	 * crossing a non-translatable boundary, and thus the addresses
+	 * below the current cannot be converted to CPU physical ones.
+	 * Unfortunately, while this is very clear in the spec, it's not
+	 * what Apple understood, and they do have things like /uni-n or
+	 * /ht nodes with no "ranges" property and a lot of perfectly
+	 * useable mapped devices below them. Thus we treat the absence of
+	 * "ranges" as equivalent to an empty "ranges" property which means
+	 * a 1:1 translation at that level. It's up to the caller not to try
+	 * to translate addresses that aren't supposed to be translated in
+	 * the first place. --BenH.
+	 *
+	 * As far as we know, this damage only exists on Apple machines, so
+	 * This code is only enabled on powerpc. --gcl
+	 */
+	ranges = of_get_property(parent, rprop, &rlen);
+	if (ranges == NULL && !of_empty_ranges_quirk(parent)) {
+		debug("no ranges; cannot translate\n");
+		return 1;
+	}
+	if (ranges == NULL || rlen == 0) {
+		offset = of_read_number(addr, na);
+		memset(addr, 0, pna * 4);
+		debug("empty ranges; 1:1 translation\n");
+		goto finish;
+	}
+
+	debug("walking ranges...\n");
+
+	/* Now walk through the ranges */
+	rlen /= 4;
+	rone = na + pna + ns;
+	for (; rlen >= rone; rlen -= rone, ranges += rone) {
+		offset = bus->map(addr, ranges, na, ns, pna);
+		if (offset != OF_BAD_ADDR)
+			break;
+	}
+	if (offset == OF_BAD_ADDR) {
+		debug("not found !\n");
+		return 1;
+	}
+	memcpy(addr, ranges + na, 4 * pna);
+
+ finish:
+	of_dump_addr("parent translation for:", addr, pna);
+	debug("with offset: %llx\n", (unsigned long long)offset);
+
+	/* Translate it into parent bus space */
+	return pbus->translate(addr, offset, pna);
+}
+
+/*
+ * Translate an address from the device-tree into a CPU physical address,
+ * this walks up the tree and applies the various bus mappings on the
+ * way.
+ *
+ * Note: We consider that crossing any level with #size-cells == 0 to mean
+ * that translation is impossible (that is we are not dealing with a value
+ * that can be mapped to a cpu physical address). This is not really specified
+ * that way, but this is traditionally the way IBM at least do things
+ */
+static u64 __of_translate_address(const struct device_node *dev,
+				  const __be32 *in_addr, const char *rprop)
+{
+	struct device_node *parent = NULL;
+	struct of_bus *bus, *pbus;
+	__be32 addr[OF_MAX_ADDR_CELLS];
+	int na, ns, pna, pns;
+	u64 result = OF_BAD_ADDR;
+
+	debug("** translation for device %s **\n", of_node_full_name(dev));
+
+	/* Increase refcount at current level */
+	(void)of_node_get(dev);
+
+	/* Get parent & match bus type */
+	parent = of_get_parent(dev);
+	if (parent == NULL)
+		goto bail;
+	bus = of_match_bus(parent);
+
+	/* Count address cells & copy address locally */
+	bus->count_cells(dev, &na, &ns);
+	if (!OF_CHECK_COUNTS(na, ns)) {
+		debug("Bad cell count for %s\n", of_node_full_name(dev));
+		goto bail;
+	}
+	memcpy(addr, in_addr, na * 4);
+
+	debug("bus is %s (na=%d, ns=%d) on %s\n", bus->name, na, ns,
+	      of_node_full_name(parent));
+	of_dump_addr("translating address:", addr, na);
+
+	/* Translate */
+	for (;;) {
+		/* Switch to parent bus */
+		of_node_put(dev);
+		dev = parent;
+		parent = of_get_parent(dev);
+
+		/* If root, we have finished */
+		if (parent == NULL) {
+			debug("reached root node\n");
+			result = of_read_number(addr, na);
+			break;
+		}
+
+		/* Get new parent bus and counts */
+		pbus = of_match_bus(parent);
+		pbus->count_cells(dev, &pna, &pns);
+		if (!OF_CHECK_COUNTS(pna, pns)) {
+			debug("Bad cell count for %s\n",
+			      of_node_full_name(dev));
+			break;
+		}
+
+		debug("parent bus is %s (na=%d, ns=%d) on %s\n", pbus->name,
+		      pna, pns, of_node_full_name(parent));
+
+		/* Apply bus translation */
+		if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop))
+			break;
+
+		/* Complete the move up one level */
+		na = pna;
+		ns = pns;
+		bus = pbus;
+
+		of_dump_addr("one level translation:", addr, na);
+	}
+ bail:
+	of_node_put(parent);
+	of_node_put(dev);
+
+	return result;
+}
+
+u64 of_translate_address(const struct device_node *dev, const __be32 *in_addr)
+{
+	return __of_translate_address(dev, in_addr, "ranges");
+}
+
+
+static int __of_address_to_resource(const struct device_node *dev,
+		const __be32 *addrp, u64 size, unsigned int flags,
+		const char *name, struct resource *r)
+{
+	u64 taddr;
+
+	if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0)
+		return -EINVAL;
+	taddr = of_translate_address(dev, addrp);
+	if (taddr == OF_BAD_ADDR)
+		return -EINVAL;
+	memset(r, 0, sizeof(struct resource));
+	r->start = taddr;
+	r->end = taddr + size - 1;
+	r->flags = flags;
+	r->name = name ? name : dev->full_name;
+
+	return 0;
+}
+
+int of_address_to_resource(const struct device_node *dev, int index,
+			   struct resource *r)
+{
+	const __be32	*addrp;
+	u64		size;
+	unsigned int	flags;
+	const char	*name = NULL;
+
+	addrp = of_get_address(dev, index, &size, &flags);
+	if (addrp == NULL)
+		return -EINVAL;
+
+	/* Get optional "reg-names" property to add a name to a resource */
+	of_property_read_string_index(dev, "reg-names", index, &name);
+
+	return __of_address_to_resource(dev, addrp, size, flags, name, r);
+}
@@ -8,8 +8,8 @@
  * SPDX-License-Identifier:	GPL-2.0+
  */
  
-#ifndef _DM_ADDR_H
-#define _DM_ADDR_H
+#ifndef _DM_FDTADDR_H
+#define _DM_FDTADDR_H
  
 #include <fdtdec.h>
  
+/*
+ * Taken from Linux v4.9 drivers/of/address.c
+ *
+ * Modified for U-Boot
+ * Copyright (c) 2017 Google, Inc
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef _DM_OF_ADDR_H
+#define _DM_OF_ADDR_H
+
+/**
+ * of_translate_address() - translate a device-tree address to a CPU address
+ *
+ * Translate an address from the device-tree into a CPU physical address,
+ * this walks up the tree and applies the various bus mappings on the  way.
+ *
+ * Note: We consider that crossing any level with #size-cells == 0 to mean
+ * that translation is impossible (that is we are not dealing with a value
+ * that can be mapped to a cpu physical address). This is not really specified
+ * that way, but this is traditionally the way IBM at least do things
+ *
+ * @np: node to check
+ * @in_addr: pointer to input address
+ * @return translated address or OF_BAD_ADDR on error
+ */
+u64 of_translate_address(const struct device_node *no, const __be32 *in_addr);
+
+/**
+ * of_get_address() - obtain an address from a node
+ *
+ * Extract an address from a node, returns the region size and the address
+ * space flags too. The PCI version uses a BAR number instead of an absolute
+ * index.
+ *
+ * @np: Node to check
+ * @index: Index of address to read (0 = first)
+ * @size: place to put size on success
+ * @flags: place to put flags on success
+ * @return pointer to address which can be read
+ */
+const __be32 *of_get_address(const struct device_node *no, int index,
+			     u64 *size, unsigned int *flags);
+
+struct resource;
+
+/**
+ * of_address_to_resource() - translate device tree address to resource
+ *
+ * Note that if your address is a PIO address, the conversion will fail if
+ * the physical address can't be internally converted to an IO token with
+ * pci_address_to_pio(), that is because it's either called to early or it
+ * can't be matched to any host bridge IO space
+ *
+ * @np: node to check
+ * @index: index of address to read (0 = first)
+ * @r: place to put resource information
+ * @return 0 if OK, -ve on error
+ */
+int of_address_to_resource(const struct device_node *no, int index,
+			   struct resource *r);
+
+#endif
...	...	@@ -11,6 +11,6 @@
11	11	obj-$(CONFIG_DM) += dump.o
12	12	obj-$(CONFIG_$(SPL_)REGMAP) += regmap.o
13	13	obj-$(CONFIG_$(SPL_)SYSCON) += syscon-uclass.o
14		-obj-$(CONFIG_OF_LIVE) += of_access.o
	14	+obj-$(CONFIG_OF_LIVE) += of_access.o of_addr.o
15	15	obj-$(CONFIG_OF_CONTROL) += ofnode.o
	1	+/*
	2	+ * Taken from Linux v4.9 drivers/of/address.c
	3	+ *
	4	+ * Modified for U-Boot
	5	+ * Copyright (c) 2017 Google, Inc
	6	+ *
	7	+ * SPDX-License-Identifier: GPL-2.0+
	8	+ */
	9	+
	10	+#include <common.h>
	11	+#include <libfdt.h>
	12	+#include <dm/of_access.h>
	13	+#include <dm/of_addr.h>
	14	+#include <linux/err.h>
	15	+#include <linux/ioport.h>
	16	+
	17	+/* Max address size we deal with */
	18	+#define OF_MAX_ADDR_CELLS 4
	19	+#define OF_CHECK_ADDR_COUNT(na) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS)
	20	+#define OF_CHECK_COUNTS(na, ns) (OF_CHECK_ADDR_COUNT(na) && (ns) > 0)
	21	+
	22	+static struct of_bus of_match_bus(struct device_node np);
	23	+
	24	+/* Debug utility */
	25	+#ifdef DEBUG
	26	+static void of_dump_addr(const char s, const __be32 addr, int na)
	27	+{
	28	+ debug("%s", s);
	29	+ while (na--)
	30	+ pr_cont(" %08x", be32_to_cpu(*(addr++)));
	31	+ pr_cont("\n");
	32	+}
	33	+#else
	34	+static void of_dump_addr(const char s, const __be32 addr, int na) { }
	35	+#endif
	36	+
	37	+/* Callbacks for bus specific translators */
	38	+struct of_bus {
	39	+ const char *name;
	40	+ const char *addresses;
	41	+ int (match)(struct device_node parent);
	42	+ void (count_cells)(const struct device_node child, int *addrc,
	43	+ int *sizec);
	44	+ u64 (map)(__be32 addr, const __be32 *range, int na, int ns, int pna);
	45	+ int (translate)(__be32 addr, u64 offset, int na);
	46	+ unsigned int (get_flags)(const __be32 addr);
	47	+};
	48	+
	49	+static void of_bus_default_count_cells(const struct device_node *np,
	50	+ int addrc, int sizec)
	51	+{
	52	+ if (addrc)
	53	+ *addrc = of_n_addr_cells(np);
	54	+ if (sizec)
	55	+ *sizec = of_n_size_cells(np);
	56	+}
	57	+
	58	+static u64 of_bus_default_map(__be32 addr, const __be32 range,
	59	+ int na, int ns, int pna)
	60	+{
	61	+ u64 cp, s, da;
	62	+
	63	+ cp = of_read_number(range, na);
	64	+ s = of_read_number(range + na + pna, ns);
	65	+ da = of_read_number(addr, na);
	66	+
	67	+ debug("default map, cp=%llx, s=%llx, da=%llx\n",
	68	+ (unsigned long long)cp, (unsigned long long)s,
	69	+ (unsigned long long)da);
	70	+
	71	+ if (da < cp \|\| da >= (cp + s))
	72	+ return OF_BAD_ADDR;
	73	+ return da - cp;
	74	+}
	75	+
	76	+static int of_bus_default_translate(__be32 *addr, u64 offset, int na)
	77	+{
	78	+ u64 a = of_read_number(addr, na);
	79	+ memset(addr, 0, na * 4);
	80	+ a += offset;
	81	+ if (na > 1)
	82	+ addr[na - 2] = cpu_to_be32(a >> 32);
	83	+ addr[na - 1] = cpu_to_be32(a & 0xffffffffu);
	84	+
	85	+ return 0;
	86	+}
	87	+
	88	+static unsigned int of_bus_default_get_flags(const __be32 *addr)
	89	+{
	90	+ return IORESOURCE_MEM;
	91	+}
	92	+
	93	+/*
	94	+ * Array of bus-specific translators
	95	+ */
	96	+static struct of_bus of_busses[] = {
	97	+ /* Default */
	98	+ {
	99	+ .name = "default",
	100	+ .addresses = "reg",
	101	+ .match = NULL,
	102	+ .count_cells = of_bus_default_count_cells,
	103	+ .map = of_bus_default_map,
	104	+ .translate = of_bus_default_translate,
	105	+ .get_flags = of_bus_default_get_flags,
	106	+ },
	107	+};
	108	+
	109	+static struct of_bus of_match_bus(struct device_node np)
	110	+{
	111	+ int i;
	112	+
	113	+ for (i = 0; i < ARRAY_SIZE(of_busses); i++)
	114	+ if (!of_busses[i].match \|\| of_busses[i].match(np))
	115	+ return &of_busses[i];
	116	+ BUG();
	117	+ return NULL;
	118	+}
	119	+
	120	+static void dev_count_cells(const struct device_node np, int nap, int *nsp)
	121	+{
	122	+ of_bus_default_count_cells(np, nap, nsp);
	123	+}
	124	+
	125	+const __be32 of_get_address(const struct device_node dev, int index,
	126	+ u64 size, unsigned int flags)
	127	+{
	128	+ const __be32 *prop;
	129	+ int psize;
	130	+ struct device_node *parent;
	131	+ struct of_bus *bus;
	132	+ int onesize, i, na, ns;
	133	+
	134	+ /* Get parent & match bus type */
	135	+ parent = of_get_parent(dev);
	136	+ if (parent == NULL)
	137	+ return NULL;
	138	+ dev_count_cells(dev, &na, &ns);
	139	+ bus = of_match_bus(parent);
	140	+ bus->count_cells(dev, &na, &ns);
	141	+ of_node_put(parent);
	142	+ if (!OF_CHECK_ADDR_COUNT(na))
	143	+ return NULL;
	144	+
	145	+ /* Get "reg" or "assigned-addresses" property */
	146	+ prop = of_get_property(dev, "reg", &psize);
	147	+ if (prop == NULL)
	148	+ return NULL;
	149	+ psize /= 4;
	150	+
	151	+ onesize = na + ns;
	152	+ for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
	153	+ if (i == index) {
	154	+ if (size)
	155	+ *size = of_read_number(prop + na, ns);
	156	+ if (flags)
	157	+ *flags = bus->get_flags(prop);
	158	+ return prop;
	159	+ }
	160	+ return NULL;
	161	+}
	162	+EXPORT_SYMBOL(of_get_address);
	163	+
	164	+static int of_empty_ranges_quirk(const struct device_node *np)
	165	+{
	166	+ return false;
	167	+}
	168	+
	169	+static int of_translate_one(const struct device_node *parent,
	170	+ struct of_bus bus, struct of_bus pbus,
	171	+ __be32 *addr, int na, int ns, int pna,
	172	+ const char *rprop)
	173	+{
	174	+ const __be32 *ranges;
	175	+ int rlen;
	176	+ int rone;
	177	+ u64 offset = OF_BAD_ADDR;
	178	+
	179	+ /*
	180	+ * Normally, an absence of a "ranges" property means we are
	181	+ * crossing a non-translatable boundary, and thus the addresses
	182	+ * below the current cannot be converted to CPU physical ones.
	183	+ * Unfortunately, while this is very clear in the spec, it's not
	184	+ * what Apple understood, and they do have things like /uni-n or
	185	+ * /ht nodes with no "ranges" property and a lot of perfectly
	186	+ * useable mapped devices below them. Thus we treat the absence of
	187	+ * "ranges" as equivalent to an empty "ranges" property which means
	188	+ * a 1:1 translation at that level. It's up to the caller not to try
	189	+ * to translate addresses that aren't supposed to be translated in
	190	+ * the first place. --BenH.
	191	+ *
	192	+ * As far as we know, this damage only exists on Apple machines, so
	193	+ * This code is only enabled on powerpc. --gcl
	194	+ */
	195	+ ranges = of_get_property(parent, rprop, &rlen);
	196	+ if (ranges == NULL && !of_empty_ranges_quirk(parent)) {
	197	+ debug("no ranges; cannot translate\n");
	198	+ return 1;
	199	+ }
	200	+ if (ranges == NULL \|\| rlen == 0) {
	201	+ offset = of_read_number(addr, na);
	202	+ memset(addr, 0, pna * 4);
	203	+ debug("empty ranges; 1:1 translation\n");
	204	+ goto finish;
	205	+ }
	206	+
	207	+ debug("walking ranges...\n");
	208	+
	209	+ /* Now walk through the ranges */
	210	+ rlen /= 4;
	211	+ rone = na + pna + ns;
	212	+ for (; rlen >= rone; rlen -= rone, ranges += rone) {
	213	+ offset = bus->map(addr, ranges, na, ns, pna);
	214	+ if (offset != OF_BAD_ADDR)
	215	+ break;
	216	+ }
	217	+ if (offset == OF_BAD_ADDR) {
	218	+ debug("not found !\n");
	219	+ return 1;
	220	+ }
	221	+ memcpy(addr, ranges + na, 4 * pna);
	222	+
	223	+ finish:
	224	+ of_dump_addr("parent translation for:", addr, pna);
	225	+ debug("with offset: %llx\n", (unsigned long long)offset);
	226	+
	227	+ /* Translate it into parent bus space */
	228	+ return pbus->translate(addr, offset, pna);
	229	+}
	230	+
	231	+/*
	232	+ * Translate an address from the device-tree into a CPU physical address,
	233	+ * this walks up the tree and applies the various bus mappings on the
	234	+ * way.
	235	+ *
	236	+ * Note: We consider that crossing any level with #size-cells == 0 to mean
	237	+ * that translation is impossible (that is we are not dealing with a value
	238	+ * that can be mapped to a cpu physical address). This is not really specified
	239	+ * that way, but this is traditionally the way IBM at least do things
	240	+ */
	241	+static u64 __of_translate_address(const struct device_node *dev,
	242	+ const __be32 in_addr, const char rprop)
	243	+{
	244	+ struct device_node *parent = NULL;
	245	+ struct of_bus bus, pbus;
	246	+ __be32 addr[OF_MAX_ADDR_CELLS];
	247	+ int na, ns, pna, pns;
	248	+ u64 result = OF_BAD_ADDR;
	249	+
	250	+ debug(" translation for device %s \n", of_node_full_name(dev));
	251	+
	252	+ /* Increase refcount at current level */
	253	+ (void)of_node_get(dev);
	254	+
	255	+ /* Get parent & match bus type */
	256	+ parent = of_get_parent(dev);
	257	+ if (parent == NULL)
	258	+ goto bail;
	259	+ bus = of_match_bus(parent);
	260	+
	261	+ /* Count address cells & copy address locally */
	262	+ bus->count_cells(dev, &na, &ns);
	263	+ if (!OF_CHECK_COUNTS(na, ns)) {
	264	+ debug("Bad cell count for %s\n", of_node_full_name(dev));
	265	+ goto bail;
	266	+ }
	267	+ memcpy(addr, in_addr, na * 4);
	268	+
	269	+ debug("bus is %s (na=%d, ns=%d) on %s\n", bus->name, na, ns,
	270	+ of_node_full_name(parent));
	271	+ of_dump_addr("translating address:", addr, na);
	272	+
	273	+ /* Translate */
	274	+ for (;;) {
	275	+ /* Switch to parent bus */
	276	+ of_node_put(dev);
	277	+ dev = parent;
	278	+ parent = of_get_parent(dev);
	279	+
	280	+ /* If root, we have finished */
	281	+ if (parent == NULL) {
	282	+ debug("reached root node\n");
	283	+ result = of_read_number(addr, na);
	284	+ break;
	285	+ }
	286	+
	287	+ /* Get new parent bus and counts */
	288	+ pbus = of_match_bus(parent);
	289	+ pbus->count_cells(dev, &pna, &pns);
	290	+ if (!OF_CHECK_COUNTS(pna, pns)) {
	291	+ debug("Bad cell count for %s\n",
	292	+ of_node_full_name(dev));
	293	+ break;
	294	+ }
	295	+
	296	+ debug("parent bus is %s (na=%d, ns=%d) on %s\n", pbus->name,
	297	+ pna, pns, of_node_full_name(parent));
	298	+
	299	+ /* Apply bus translation */
	300	+ if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop))
	301	+ break;
	302	+
	303	+ /* Complete the move up one level */
	304	+ na = pna;
	305	+ ns = pns;
	306	+ bus = pbus;
	307	+
	308	+ of_dump_addr("one level translation:", addr, na);
	309	+ }
	310	+ bail:
	311	+ of_node_put(parent);
	312	+ of_node_put(dev);
	313	+
	314	+ return result;
	315	+}
	316	+
	317	+u64 of_translate_address(const struct device_node dev, const __be32 in_addr)
	318	+{
	319	+ return __of_translate_address(dev, in_addr, "ranges");
	320	+}
	321	+
	322	+
	323	+static int __of_address_to_resource(const struct device_node *dev,
	324	+ const __be32 *addrp, u64 size, unsigned int flags,
	325	+ const char name, struct resource r)
	326	+{
	327	+ u64 taddr;
	328	+
	329	+ if ((flags & (IORESOURCE_IO \| IORESOURCE_MEM)) == 0)
	330	+ return -EINVAL;
	331	+ taddr = of_translate_address(dev, addrp);
	332	+ if (taddr == OF_BAD_ADDR)
	333	+ return -EINVAL;
	334	+ memset(r, 0, sizeof(struct resource));
	335	+ r->start = taddr;
	336	+ r->end = taddr + size - 1;
	337	+ r->flags = flags;
	338	+ r->name = name ? name : dev->full_name;
	339	+
	340	+ return 0;
	341	+}
	342	+
	343	+int of_address_to_resource(const struct device_node *dev, int index,
	344	+ struct resource *r)
	345	+{
	346	+ const __be32 *addrp;
	347	+ u64 size;
	348	+ unsigned int flags;
	349	+ const char *name = NULL;
	350	+
	351	+ addrp = of_get_address(dev, index, &size, &flags);
	352	+ if (addrp == NULL)
	353	+ return -EINVAL;
	354	+
	355	+ /* Get optional "reg-names" property to add a name to a resource */
	356	+ of_property_read_string_index(dev, "reg-names", index, &name);
	357	+
	358	+ return __of_address_to_resource(dev, addrp, size, flags, name, r);
	359	+}
...	...	@@ -8,8 +8,8 @@
8	8	* SPDX-License-Identifier: GPL-2.0+
9	9	*/
10	10
11		-#ifndef _DM_ADDR_H
12		-#define _DM_ADDR_H
	11	+#ifndef _DM_FDTADDR_H
	12	+#define _DM_FDTADDR_H
13	13
14	14	#include <fdtdec.h>
15	15