projects/linux·blob master · refs

236 lines · 5.8 KiB

1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * FDT Address translation based on u-boot fdt_support.c which in turn was
4 * based on the kernel unflattened DT address translation code.
5 *
6 * (C) Copyright 2007
7 * Gerald Van Baren, Custom IDEAS, [email protected]
8 *
9 * Copyright 2010-2011 Freescale Semiconductor, Inc.
10 */
11
12#define pr_fmt(fmt) "OF: fdt: " fmt
13
14#include <linux/kernel.h>
15#include <linux/libfdt.h>
16#include <linux/of.h>
17#include <linux/of_fdt.h>
18#include <linux/sizes.h>
19
20/* Uncomment me to enable of_dump_addr() debugging output */
21// #define DEBUG
22
23#include "of_private.h"
24
25/* Callbacks for bus specific translators */
26struct of_bus {
27 void (*count_cells)(const void *blob, int parentoffset,
28 int *addrc, int *sizec);
29 u64 (*map)(__be32 *addr, const __be32 *range,
30 int na, int ns, int pna);
31 int (*translate)(__be32 *addr, u64 offset, int na);
32};
33
34/* Default translator (generic bus) */
35static void __init fdt_bus_default_count_cells(const void *blob, int parentoffset,
36 int *addrc, int *sizec)
37{
38 const __be32 *prop;
39
40 if (addrc) {
41 prop = fdt_getprop(blob, parentoffset, "#address-cells", NULL);
42 if (prop)
43 *addrc = be32_to_cpup(prop);
44 else
45 *addrc = -1;
46 }
47
48 if (sizec) {
49 prop = fdt_getprop(blob, parentoffset, "#size-cells", NULL);
50 if (prop)
51 *sizec = be32_to_cpup(prop);
52 else
53 *sizec = -1;
54 }
55}
56
57static u64 __init fdt_bus_default_map(__be32 *addr, const __be32 *range,
58 int na, int ns, int pna)
59{
60 u64 cp, s, da;
61
62 cp = of_read_number(range, na);
63 s = of_read_number(range + na + pna, ns);
64 da = of_read_number(addr, na);
65
66 pr_debug("default map, cp=%llx, s=%llx, da=%llx\n",
67 cp, s, da);
68
69 if (da < cp || da >= (cp + s))
70 return OF_BAD_ADDR;
71 return da - cp;
72}
73
74static int __init fdt_bus_default_translate(__be32 *addr, u64 offset, int na)
75{
76 u64 a = of_read_number(addr, na);
77 memset(addr, 0, na * 4);
78 a += offset;
79 if (na > 1)
80 addr[na - 2] = cpu_to_fdt32(a >> 32);
81 addr[na - 1] = cpu_to_fdt32(a & 0xffffffffu);
82
83 return 0;
84}
85
86/* Array of bus specific translators */
87static const struct of_bus of_busses[] __initconst = {
88 /* Default */
89 {
90 .count_cells = fdt_bus_default_count_cells,
91 .map = fdt_bus_default_map,
92 .translate = fdt_bus_default_translate,
93 },
94};
95
96static int __init fdt_translate_one(const void *blob, int parent,
97 const struct of_bus *bus,
98 const struct of_bus *pbus, __be32 *addr,
99 int na, int ns, int pna, const char *rprop)
100{
101 const __be32 *ranges;
102 int rlen;
103 int rone;
104 u64 offset = OF_BAD_ADDR;
105
106 ranges = fdt_getprop(blob, parent, rprop, &rlen);
107 if (!ranges)
108 return 1;
109 if (rlen == 0) {
110 offset = of_read_number(addr, na);
111 memset(addr, 0, pna * 4);
112 pr_debug("empty ranges, 1:1 translation\n");
113 goto finish;
114 }
115
116 pr_debug("walking ranges...\n");
117
118 /* Now walk through the ranges */
119 rlen /= 4;
120 rone = na + pna + ns;
121 for (; rlen >= rone; rlen -= rone, ranges += rone) {
122 offset = bus->map(addr, ranges, na, ns, pna);
123 if (offset != OF_BAD_ADDR)
124 break;
125 }
126 if (offset == OF_BAD_ADDR) {
127 pr_debug("not found !\n");
128 return 1;
129 }
130 memcpy(addr, ranges + na, 4 * pna);
131
132 finish:
133 of_dump_addr("parent translation for:", addr, pna);
134 pr_debug("with offset: %llx\n", offset);
135
136 /* Translate it into parent bus space */
137 return pbus->translate(addr, offset, pna);
138}
139
140/*
141 * Translate an address from the device-tree into a CPU physical address,
142 * this walks up the tree and applies the various bus mappings on the
143 * way.
144 *
145 * Note: We consider that crossing any level with #size-cells == 0 to mean
146 * that translation is impossible (that is we are not dealing with a value
147 * that can be mapped to a cpu physical address). This is not really specified
148 * that way, but this is traditionally the way IBM at least do things
149 */
150static u64 __init fdt_translate_address(const void *blob, int node_offset)
151{
152 int parent, len;
153 const struct of_bus *bus, *pbus;
154 const __be32 *reg;
155 __be32 addr[OF_MAX_ADDR_CELLS];
156 int na, ns, pna, pns;
157 u64 result = OF_BAD_ADDR;
158
159 pr_debug("** translation for device %s **\n",
160 fdt_get_name(blob, node_offset, NULL));
161
162 reg = fdt_getprop(blob, node_offset, "reg", &len);
163 if (!reg) {
164 pr_err("warning: device tree node '%s' has no address.\n",
165 fdt_get_name(blob, node_offset, NULL));
166 goto bail;
167 }
168
169 /* Get parent & match bus type */
170 parent = fdt_parent_offset(blob, node_offset);
171 if (parent < 0)
172 goto bail;
173 bus = &of_busses[0];
174
175 /* Cound address cells & copy address locally */
176 bus->count_cells(blob, parent, &na, &ns);
177 if (!OF_CHECK_COUNTS(na, ns)) {
178 pr_err("Bad cell count for %s\n",
179 fdt_get_name(blob, node_offset, NULL));
180 goto bail;
181 }
182 memcpy(addr, reg, na * 4);
183
184 pr_debug("bus (na=%d, ns=%d) on %s\n",
185 na, ns, fdt_get_name(blob, parent, NULL));
186 of_dump_addr("translating address:", addr, na);
187
188 /* Translate */
189 for (;;) {
190 /* Switch to parent bus */
191 node_offset = parent;
192 parent = fdt_parent_offset(blob, node_offset);
193
194 /* If root, we have finished */
195 if (parent < 0) {
196 pr_debug("reached root node\n");
197 result = of_read_number(addr, na);
198 break;
199 }
200
201 /* Get new parent bus and counts */
202 pbus = &of_busses[0];
203 pbus->count_cells(blob, parent, &pna, &pns);
204 if (!OF_CHECK_COUNTS(pna, pns)) {
205 pr_err("Bad cell count for %s\n",
206 fdt_get_name(blob, node_offset, NULL));
207 break;
208 }
209
210 pr_debug("parent bus (na=%d, ns=%d) on %s\n",
211 pna, pns, fdt_get_name(blob, parent, NULL));
212
213 /* Apply bus translation */
214 if (fdt_translate_one(blob, node_offset, bus, pbus,
215 addr, na, ns, pna, "ranges"))
216 break;
217
218 /* Complete the move up one level */
219 na = pna;
220 ns = pns;
221 bus = pbus;
222
223 of_dump_addr("one level translation:", addr, na);
224 }
225 bail:
226 return result;
227}
228
229/**
230 * of_flat_dt_translate_address - translate DT addr into CPU phys addr
231 * @node: node in the flat blob
232 */
233u64 __init of_flat_dt_translate_address(unsigned long node)
234{
235 return fdt_translate_address(initial_boot_params, node);
236}