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