blob: e6daa67990d8ed86b8843825bea6df2214af62ed [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Gerald Van Baren64dbbd42007-04-06 14:19:43 -04002/*
3 * (C) Copyright 2007
4 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com
5 *
Shengzhou Liu2a523f52011-10-14 16:26:05 +08006 * Copyright 2010-2011 Freescale Semiconductor, Inc.
Gerald Van Baren64dbbd42007-04-06 14:19:43 -04007 */
8
9#include <common.h>
Anton Vorontsov3e303f72009-10-15 17:47:04 +040010#include <stdio_dev.h>
Gerald Van Baren64dbbd42007-04-06 14:19:43 -040011#include <linux/ctype.h>
12#include <linux/types.h>
Gerald Van Baren64dbbd42007-04-06 14:19:43 -040013#include <asm/global_data.h>
Masahiro Yamadab08c8c42018-03-05 01:20:11 +090014#include <linux/libfdt.h>
Gerald Van Baren64dbbd42007-04-06 14:19:43 -040015#include <fdt_support.h>
Kumar Gala151c8b02007-11-26 17:06:15 -060016#include <exports.h>
Bin Menga0ae3802015-12-07 01:39:47 -080017#include <fdtdec.h>
Gerald Van Baren64dbbd42007-04-06 14:19:43 -040018
Kumar Gala3bed2aa2008-10-23 00:05:47 -050019/**
Alexander Graf94fb1822014-04-11 17:09:40 +020020 * fdt_getprop_u32_default_node - Return a node's property or a default
21 *
22 * @fdt: ptr to device tree
23 * @off: offset of node
24 * @cell: cell offset in property
25 * @prop: property name
26 * @dflt: default value if the property isn't found
27 *
28 * Convenience function to return a node's property or a default value if
29 * the property doesn't exist.
30 */
31u32 fdt_getprop_u32_default_node(const void *fdt, int off, int cell,
32 const char *prop, const u32 dflt)
33{
34 const fdt32_t *val;
35 int len;
36
37 val = fdt_getprop(fdt, off, prop, &len);
38
39 /* Check if property exists */
40 if (!val)
41 return dflt;
42
43 /* Check if property is long enough */
44 if (len < ((cell + 1) * sizeof(uint32_t)))
45 return dflt;
46
47 return fdt32_to_cpu(*val);
48}
49
50/**
Kumar Gala3bed2aa2008-10-23 00:05:47 -050051 * fdt_getprop_u32_default - Find a node and return it's property or a default
52 *
53 * @fdt: ptr to device tree
54 * @path: path of node
55 * @prop: property name
56 * @dflt: default value if the property isn't found
57 *
58 * Convenience function to find a node and return it's property or a
59 * default value if it doesn't exist.
60 */
Gabe Black07e12782011-11-08 01:09:44 -080061u32 fdt_getprop_u32_default(const void *fdt, const char *path,
62 const char *prop, const u32 dflt)
Kumar Gala3bed2aa2008-10-23 00:05:47 -050063{
Kumar Gala3bed2aa2008-10-23 00:05:47 -050064 int off;
65
66 off = fdt_path_offset(fdt, path);
67 if (off < 0)
68 return dflt;
69
Alexander Graf94fb1822014-04-11 17:09:40 +020070 return fdt_getprop_u32_default_node(fdt, off, 0, prop, dflt);
Kumar Gala3bed2aa2008-10-23 00:05:47 -050071}
Gerald Van Baren64dbbd42007-04-06 14:19:43 -040072
Kumar Galaa3c29332007-10-24 10:21:57 -050073/**
74 * fdt_find_and_setprop: Find a node and set it's property
75 *
76 * @fdt: ptr to device tree
77 * @node: path of node
78 * @prop: property name
79 * @val: ptr to new value
80 * @len: length of new property value
81 * @create: flag to create the property if it doesn't exist
82 *
83 * Convenience function to directly set a property given the path to the node.
84 */
85int fdt_find_and_setprop(void *fdt, const char *node, const char *prop,
86 const void *val, int len, int create)
87{
Kumar Gala8d04f022007-10-24 11:04:22 -050088 int nodeoff = fdt_path_offset(fdt, node);
Kumar Galaa3c29332007-10-24 10:21:57 -050089
90 if (nodeoff < 0)
91 return nodeoff;
92
Kim Phillips8aa5ec62013-01-16 14:00:11 +000093 if ((!create) && (fdt_get_property(fdt, nodeoff, prop, NULL) == NULL))
Kumar Galaa3c29332007-10-24 10:21:57 -050094 return 0; /* create flag not set; so exit quietly */
95
96 return fdt_setprop(fdt, nodeoff, prop, val, len);
97}
98
Masahiro Yamada8edb2192014-04-18 17:40:58 +090099/**
Simon Glassa9e8e292014-10-23 18:58:49 -0600100 * fdt_find_or_add_subnode() - find or possibly add a subnode of a given node
101 *
Masahiro Yamada8edb2192014-04-18 17:40:58 +0900102 * @fdt: pointer to the device tree blob
103 * @parentoffset: structure block offset of a node
104 * @name: name of the subnode to locate
105 *
106 * fdt_subnode_offset() finds a subnode of the node with a given name.
107 * If the subnode does not exist, it will be created.
108 */
Simon Glassa9e8e292014-10-23 18:58:49 -0600109int fdt_find_or_add_subnode(void *fdt, int parentoffset, const char *name)
Masahiro Yamada8edb2192014-04-18 17:40:58 +0900110{
111 int offset;
112
113 offset = fdt_subnode_offset(fdt, parentoffset, name);
114
115 if (offset == -FDT_ERR_NOTFOUND)
116 offset = fdt_add_subnode(fdt, parentoffset, name);
117
118 if (offset < 0)
119 printf("%s: %s: %s\n", __func__, name, fdt_strerror(offset));
120
121 return offset;
122}
123
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900124/* rename to CONFIG_OF_STDOUT_PATH ? */
125#if defined(OF_STDOUT_PATH)
126static int fdt_fixup_stdout(void *fdt, int chosenoff)
127{
128 return fdt_setprop(fdt, chosenoff, "linux,stdout-path",
129 OF_STDOUT_PATH, strlen(OF_STDOUT_PATH) + 1);
130}
131#elif defined(CONFIG_OF_STDOUT_VIA_ALIAS) && defined(CONFIG_CONS_INDEX)
Detlev Zundel40777812008-06-20 22:24:05 +0200132static int fdt_fixup_stdout(void *fdt, int chosenoff)
Kumar Gala151c8b02007-11-26 17:06:15 -0600133{
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900134 int err;
135 int aliasoff;
Kumar Gala151c8b02007-11-26 17:06:15 -0600136 char sername[9] = { 0 };
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900137 const void *path;
138 int len;
139 char tmp[256]; /* long enough */
Kumar Gala151c8b02007-11-26 17:06:15 -0600140
Bin Meng9f29aeb2016-01-13 19:38:58 -0800141 sprintf(sername, "serial%d", CONFIG_CONS_INDEX - 1);
Kumar Gala151c8b02007-11-26 17:06:15 -0600142
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900143 aliasoff = fdt_path_offset(fdt, "/aliases");
144 if (aliasoff < 0) {
145 err = aliasoff;
Scott Woodda77c812015-09-01 22:48:08 -0500146 goto noalias;
Kumar Gala151c8b02007-11-26 17:06:15 -0600147 }
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900148
149 path = fdt_getprop(fdt, aliasoff, sername, &len);
150 if (!path) {
151 err = len;
Scott Woodda77c812015-09-01 22:48:08 -0500152 goto noalias;
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900153 }
154
155 /* fdt_setprop may break "path" so we copy it to tmp buffer */
156 memcpy(tmp, path, len);
157
158 err = fdt_setprop(fdt, chosenoff, "linux,stdout-path", tmp, len);
Kumar Gala151c8b02007-11-26 17:06:15 -0600159 if (err < 0)
160 printf("WARNING: could not set linux,stdout-path %s.\n",
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900161 fdt_strerror(err));
Kumar Gala151c8b02007-11-26 17:06:15 -0600162
163 return err;
Scott Woodda77c812015-09-01 22:48:08 -0500164
165noalias:
166 printf("WARNING: %s: could not read %s alias: %s\n",
167 __func__, sername, fdt_strerror(err));
168
169 return 0;
Kumar Gala151c8b02007-11-26 17:06:15 -0600170}
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900171#else
172static int fdt_fixup_stdout(void *fdt, int chosenoff)
173{
174 return 0;
175}
Kumar Gala151c8b02007-11-26 17:06:15 -0600176#endif
177
Masahiro Yamadaf18295d2014-04-18 17:41:04 +0900178static inline int fdt_setprop_uxx(void *fdt, int nodeoffset, const char *name,
179 uint64_t val, int is_u64)
180{
181 if (is_u64)
182 return fdt_setprop_u64(fdt, nodeoffset, name, val);
183 else
184 return fdt_setprop_u32(fdt, nodeoffset, name, (uint32_t)val);
185}
186
Paul Kocialkowski10be5b52015-05-21 11:27:03 +0200187int fdt_root(void *fdt)
188{
189 char *serial;
190 int err;
191
192 err = fdt_check_header(fdt);
193 if (err < 0) {
194 printf("fdt_root: %s\n", fdt_strerror(err));
195 return err;
196 }
197
Simon Glass00caae62017-08-03 12:22:12 -0600198 serial = env_get("serial#");
Paul Kocialkowski10be5b52015-05-21 11:27:03 +0200199 if (serial) {
200 err = fdt_setprop(fdt, 0, "serial-number", serial,
201 strlen(serial) + 1);
202
203 if (err < 0) {
204 printf("WARNING: could not set serial-number %s.\n",
205 fdt_strerror(err));
206 return err;
207 }
208 }
209
210 return 0;
211}
Masahiro Yamadaf18295d2014-04-18 17:41:04 +0900212
Masahiro Yamadadbe963a2014-04-18 17:40:59 +0900213int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end)
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500214{
Masahiro Yamadaf18295d2014-04-18 17:41:04 +0900215 int nodeoffset;
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500216 int err, j, total;
Masahiro Yamadaf18295d2014-04-18 17:41:04 +0900217 int is_u64;
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500218 uint64_t addr, size;
219
Masahiro Yamada50babaf2014-04-18 17:41:05 +0900220 /* just return if the size of initrd is zero */
221 if (initrd_start == initrd_end)
222 return 0;
223
Masahiro Yamada8edb2192014-04-18 17:40:58 +0900224 /* find or create "/chosen" node. */
225 nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");
226 if (nodeoffset < 0)
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500227 return nodeoffset;
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500228
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500229 total = fdt_num_mem_rsv(fdt);
230
231 /*
232 * Look for an existing entry and update it. If we don't find
233 * the entry, we will j be the next available slot.
234 */
235 for (j = 0; j < total; j++) {
236 err = fdt_get_mem_rsv(fdt, j, &addr, &size);
237 if (addr == initrd_start) {
238 fdt_del_mem_rsv(fdt, j);
239 break;
240 }
241 }
242
Grant Likelyce6b27a2011-03-28 09:58:55 +0000243 err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start);
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500244 if (err < 0) {
245 printf("fdt_initrd: %s\n", fdt_strerror(err));
246 return err;
247 }
248
Simon Glass933cdbb2014-10-23 18:58:57 -0600249 is_u64 = (fdt_address_cells(fdt, 0) == 2);
David Fengf77a6062013-12-14 11:47:29 +0800250
Masahiro Yamadaf18295d2014-04-18 17:41:04 +0900251 err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-start",
252 (uint64_t)initrd_start, is_u64);
253
Masahiro Yamadadbe963a2014-04-18 17:40:59 +0900254 if (err < 0) {
255 printf("WARNING: could not set linux,initrd-start %s.\n",
256 fdt_strerror(err));
257 return err;
258 }
Masahiro Yamadaf18295d2014-04-18 17:41:04 +0900259
260 err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-end",
261 (uint64_t)initrd_end, is_u64);
262
Masahiro Yamadadbe963a2014-04-18 17:40:59 +0900263 if (err < 0) {
264 printf("WARNING: could not set linux,initrd-end %s.\n",
265 fdt_strerror(err));
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500266
Masahiro Yamadadbe963a2014-04-18 17:40:59 +0900267 return err;
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500268 }
269
270 return 0;
271}
272
Masahiro Yamadabc6ed0f2014-04-18 17:41:00 +0900273int fdt_chosen(void *fdt)
Gerald Van Baren64dbbd42007-04-06 14:19:43 -0400274{
Gerald Van Baren64dbbd42007-04-06 14:19:43 -0400275 int nodeoffset;
276 int err;
Gerald Van Baren35ec3982007-05-25 22:08:57 -0400277 char *str; /* used to set string properties */
Gerald Van Baren64dbbd42007-04-06 14:19:43 -0400278
279 err = fdt_check_header(fdt);
280 if (err < 0) {
Gerald Van Baren5fe6be62007-08-07 21:14:22 -0400281 printf("fdt_chosen: %s\n", fdt_strerror(err));
Gerald Van Baren64dbbd42007-04-06 14:19:43 -0400282 return err;
283 }
284
Masahiro Yamada8edb2192014-04-18 17:40:58 +0900285 /* find or create "/chosen" node. */
286 nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");
287 if (nodeoffset < 0)
288 return nodeoffset;
Gerald Van Baren64dbbd42007-04-06 14:19:43 -0400289
Simon Glass00caae62017-08-03 12:22:12 -0600290 str = env_get("bootargs");
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900291 if (str) {
292 err = fdt_setprop(fdt, nodeoffset, "bootargs", str,
293 strlen(str) + 1);
294 if (err < 0) {
Masahiro Yamadabc6ed0f2014-04-18 17:41:00 +0900295 printf("WARNING: could not set bootargs %s.\n",
296 fdt_strerror(err));
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900297 return err;
298 }
Gerald Van Baren64dbbd42007-04-06 14:19:43 -0400299 }
Kumar Gala2a1a2cb2008-08-15 08:24:43 -0500300
Masahiro Yamada972f2a82014-04-18 17:41:01 +0900301 return fdt_fixup_stdout(fdt, nodeoffset);
Gerald Van Baren64dbbd42007-04-06 14:19:43 -0400302}
303
Kumar Galae93becf2007-11-03 19:46:28 -0500304void do_fixup_by_path(void *fdt, const char *path, const char *prop,
305 const void *val, int len, int create)
306{
307#if defined(DEBUG)
308 int i;
Kumar Galad9ad1152008-02-13 15:09:58 -0600309 debug("Updating property '%s/%s' = ", path, prop);
Kumar Galae93becf2007-11-03 19:46:28 -0500310 for (i = 0; i < len; i++)
311 debug(" %.2x", *(u8*)(val+i));
312 debug("\n");
313#endif
314 int rc = fdt_find_and_setprop(fdt, path, prop, val, len, create);
315 if (rc)
316 printf("Unable to update property %s:%s, err=%s\n",
317 path, prop, fdt_strerror(rc));
318}
319
320void do_fixup_by_path_u32(void *fdt, const char *path, const char *prop,
321 u32 val, int create)
322{
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000323 fdt32_t tmp = cpu_to_fdt32(val);
324 do_fixup_by_path(fdt, path, prop, &tmp, sizeof(tmp), create);
Kumar Galae93becf2007-11-03 19:46:28 -0500325}
326
Kumar Gala9eb77ce2007-11-21 13:30:15 -0600327void do_fixup_by_prop(void *fdt,
328 const char *pname, const void *pval, int plen,
329 const char *prop, const void *val, int len,
330 int create)
331{
332 int off;
333#if defined(DEBUG)
334 int i;
Kumar Galad9ad1152008-02-13 15:09:58 -0600335 debug("Updating property '%s' = ", prop);
Kumar Gala9eb77ce2007-11-21 13:30:15 -0600336 for (i = 0; i < len; i++)
337 debug(" %.2x", *(u8*)(val+i));
338 debug("\n");
339#endif
340 off = fdt_node_offset_by_prop_value(fdt, -1, pname, pval, plen);
341 while (off != -FDT_ERR_NOTFOUND) {
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000342 if (create || (fdt_get_property(fdt, off, prop, NULL) != NULL))
Kumar Gala9eb77ce2007-11-21 13:30:15 -0600343 fdt_setprop(fdt, off, prop, val, len);
344 off = fdt_node_offset_by_prop_value(fdt, off, pname, pval, plen);
345 }
346}
347
348void do_fixup_by_prop_u32(void *fdt,
349 const char *pname, const void *pval, int plen,
350 const char *prop, u32 val, int create)
351{
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000352 fdt32_t tmp = cpu_to_fdt32(val);
353 do_fixup_by_prop(fdt, pname, pval, plen, prop, &tmp, 4, create);
Kumar Gala9eb77ce2007-11-21 13:30:15 -0600354}
355
356void do_fixup_by_compat(void *fdt, const char *compat,
357 const char *prop, const void *val, int len, int create)
358{
359 int off = -1;
360#if defined(DEBUG)
361 int i;
Kumar Galad9ad1152008-02-13 15:09:58 -0600362 debug("Updating property '%s' = ", prop);
Kumar Gala9eb77ce2007-11-21 13:30:15 -0600363 for (i = 0; i < len; i++)
364 debug(" %.2x", *(u8*)(val+i));
365 debug("\n");
366#endif
367 off = fdt_node_offset_by_compatible(fdt, -1, compat);
368 while (off != -FDT_ERR_NOTFOUND) {
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000369 if (create || (fdt_get_property(fdt, off, prop, NULL) != NULL))
Kumar Gala9eb77ce2007-11-21 13:30:15 -0600370 fdt_setprop(fdt, off, prop, val, len);
371 off = fdt_node_offset_by_compatible(fdt, off, compat);
372 }
373}
374
375void do_fixup_by_compat_u32(void *fdt, const char *compat,
376 const char *prop, u32 val, int create)
377{
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000378 fdt32_t tmp = cpu_to_fdt32(val);
379 do_fixup_by_compat(fdt, compat, prop, &tmp, 4, create);
Kumar Gala9eb77ce2007-11-21 13:30:15 -0600380}
381
Masahiro Yamada63c09412016-11-26 11:02:10 +0900382#ifdef CONFIG_ARCH_FIXUP_FDT_MEMORY
Masahiro Yamada739a01e2014-04-18 17:41:03 +0900383/*
384 * fdt_pack_reg - pack address and size array into the "reg"-suitable stream
385 */
Simon Glass41f09bb2014-10-23 18:58:55 -0600386static int fdt_pack_reg(const void *fdt, void *buf, u64 *address, u64 *size,
387 int n)
Masahiro Yamada739a01e2014-04-18 17:41:03 +0900388{
389 int i;
Hans de Goedeffccb842014-11-28 14:23:51 +0100390 int address_cells = fdt_address_cells(fdt, 0);
391 int size_cells = fdt_size_cells(fdt, 0);
Masahiro Yamada739a01e2014-04-18 17:41:03 +0900392 char *p = buf;
393
394 for (i = 0; i < n; i++) {
Hans de Goedeffccb842014-11-28 14:23:51 +0100395 if (address_cells == 2)
Masahiro Yamada739a01e2014-04-18 17:41:03 +0900396 *(fdt64_t *)p = cpu_to_fdt64(address[i]);
397 else
398 *(fdt32_t *)p = cpu_to_fdt32(address[i]);
Hans de Goedeffccb842014-11-28 14:23:51 +0100399 p += 4 * address_cells;
Masahiro Yamada739a01e2014-04-18 17:41:03 +0900400
Hans de Goedeffccb842014-11-28 14:23:51 +0100401 if (size_cells == 2)
Masahiro Yamada739a01e2014-04-18 17:41:03 +0900402 *(fdt64_t *)p = cpu_to_fdt64(size[i]);
403 else
404 *(fdt32_t *)p = cpu_to_fdt32(size[i]);
Hans de Goedeffccb842014-11-28 14:23:51 +0100405 p += 4 * size_cells;
Masahiro Yamada739a01e2014-04-18 17:41:03 +0900406 }
407
408 return p - (char *)buf;
409}
410
Ramon Fried6b6f2162018-08-14 00:35:42 +0300411#if CONFIG_NR_DRAM_BANKS > 4
412#define MEMORY_BANKS_MAX CONFIG_NR_DRAM_BANKS
413#else
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000414#define MEMORY_BANKS_MAX 4
Ramon Fried6b6f2162018-08-14 00:35:42 +0300415#endif
John Rigbya6bd9e82010-10-13 13:57:33 -0600416int fdt_fixup_memory_banks(void *blob, u64 start[], u64 size[], int banks)
417{
418 int err, nodeoffset;
Thierry Reding6d29cc72018-01-30 11:34:17 +0100419 int len, i;
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000420 u8 tmp[MEMORY_BANKS_MAX * 16]; /* Up to 64-bit address + 64-bit size */
Kumar Gala3c927282007-11-26 14:57:45 -0600421
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000422 if (banks > MEMORY_BANKS_MAX) {
423 printf("%s: num banks %d exceeds hardcoded limit %d."
424 " Recompile with higher MEMORY_BANKS_MAX?\n",
425 __FUNCTION__, banks, MEMORY_BANKS_MAX);
426 return -1;
427 }
428
Kumar Gala3c927282007-11-26 14:57:45 -0600429 err = fdt_check_header(blob);
430 if (err < 0) {
431 printf("%s: %s\n", __FUNCTION__, fdt_strerror(err));
432 return err;
433 }
434
Masahiro Yamada8edb2192014-04-18 17:40:58 +0900435 /* find or create "/memory" node. */
436 nodeoffset = fdt_find_or_add_subnode(blob, 0, "memory");
437 if (nodeoffset < 0)
Miao Yan35940de2013-11-28 17:51:39 +0800438 return nodeoffset;
Masahiro Yamada8edb2192014-04-18 17:40:58 +0900439
Kumar Gala3c927282007-11-26 14:57:45 -0600440 err = fdt_setprop(blob, nodeoffset, "device_type", "memory",
441 sizeof("memory"));
442 if (err < 0) {
443 printf("WARNING: could not set %s %s.\n", "device_type",
444 fdt_strerror(err));
445 return err;
446 }
447
Thierry Redinged5af032018-02-15 19:05:59 +0100448 for (i = 0; i < banks; i++) {
449 if (start[i] == 0 && size[i] == 0)
450 break;
451 }
452
453 banks = i;
454
Andre Przywara5c1cf892015-06-21 00:29:54 +0100455 if (!banks)
456 return 0;
457
Thierry Reding6d29cc72018-01-30 11:34:17 +0100458 for (i = 0; i < banks; i++)
459 if (start[i] == 0 && size[i] == 0)
460 break;
461
462 banks = i;
463
Masahiro Yamada739a01e2014-04-18 17:41:03 +0900464 len = fdt_pack_reg(blob, tmp, start, size, banks);
Kumar Gala3c927282007-11-26 14:57:45 -0600465
466 err = fdt_setprop(blob, nodeoffset, "reg", tmp, len);
467 if (err < 0) {
468 printf("WARNING: could not set %s %s.\n",
469 "reg", fdt_strerror(err));
470 return err;
471 }
472 return 0;
473}
Masahiro Yamada63c09412016-11-26 11:02:10 +0900474#endif
Kumar Gala3c927282007-11-26 14:57:45 -0600475
John Rigbya6bd9e82010-10-13 13:57:33 -0600476int fdt_fixup_memory(void *blob, u64 start, u64 size)
477{
478 return fdt_fixup_memory_banks(blob, &start, &size, 1);
479}
480
Kumar Galaba37aa02008-08-19 15:41:18 -0500481void fdt_fixup_ethernet(void *fdt)
Kumar Galaab544632007-11-21 11:11:03 -0600482{
Prabhakar Kushwaha24acb832017-11-23 16:51:32 +0530483 int i = 0, j, prop;
Bin Mengbc393a72015-11-03 04:24:41 -0800484 char *tmp, *end;
Stephen Warren064d55f2013-05-27 18:01:19 +0000485 char mac[16];
Kumar Galaab544632007-11-21 11:11:03 -0600486 const char *path;
oliver@schinagl.nla40db6d2016-11-25 16:30:19 +0100487 unsigned char mac_addr[ARP_HLEN];
Bin Mengbc393a72015-11-03 04:24:41 -0800488 int offset;
Prabhakar Kushwaha24acb832017-11-23 16:51:32 +0530489#ifdef FDT_SEQ_MACADDR_FROM_ENV
490 int nodeoff;
491 const struct fdt_property *fdt_prop;
492#endif
Kumar Galaab544632007-11-21 11:11:03 -0600493
Lev Iserovicha434fd12016-01-07 18:04:16 -0500494 if (fdt_path_offset(fdt, "/aliases") < 0)
Kumar Galaba37aa02008-08-19 15:41:18 -0500495 return;
496
Lev Iserovicha434fd12016-01-07 18:04:16 -0500497 /* Cycle through all aliases */
498 for (prop = 0; ; prop++) {
Bin Mengbc393a72015-11-03 04:24:41 -0800499 const char *name;
Bin Mengbc393a72015-11-03 04:24:41 -0800500
Lev Iserovicha434fd12016-01-07 18:04:16 -0500501 /* FDT might have been edited, recompute the offset */
502 offset = fdt_first_property_offset(fdt,
503 fdt_path_offset(fdt, "/aliases"));
504 /* Select property number 'prop' */
Prabhakar Kushwaha24acb832017-11-23 16:51:32 +0530505 for (j = 0; j < prop; j++)
Lev Iserovicha434fd12016-01-07 18:04:16 -0500506 offset = fdt_next_property_offset(fdt, offset);
507
508 if (offset < 0)
509 break;
510
Bin Mengbc393a72015-11-03 04:24:41 -0800511 path = fdt_getprop_by_offset(fdt, offset, &name, NULL);
Tuomas Tynkkynenf8e57c62017-03-20 10:04:55 +0200512 if (!strncmp(name, "ethernet", 8)) {
513 /* Treat plain "ethernet" same as "ethernet0". */
Prabhakar Kushwaha24acb832017-11-23 16:51:32 +0530514 if (!strcmp(name, "ethernet")
515#ifdef FDT_SEQ_MACADDR_FROM_ENV
516 || !strcmp(name, "ethernet0")
517#endif
518 )
Tuomas Tynkkynenf8e57c62017-03-20 10:04:55 +0200519 i = 0;
Prabhakar Kushwaha24acb832017-11-23 16:51:32 +0530520#ifndef FDT_SEQ_MACADDR_FROM_ENV
Tuomas Tynkkynenf8e57c62017-03-20 10:04:55 +0200521 else
522 i = trailing_strtol(name);
Prabhakar Kushwaha24acb832017-11-23 16:51:32 +0530523#endif
Bin Mengbc393a72015-11-03 04:24:41 -0800524 if (i != -1) {
525 if (i == 0)
526 strcpy(mac, "ethaddr");
527 else
528 sprintf(mac, "eth%daddr", i);
529 } else {
530 continue;
531 }
Prabhakar Kushwaha24acb832017-11-23 16:51:32 +0530532#ifdef FDT_SEQ_MACADDR_FROM_ENV
533 nodeoff = fdt_path_offset(fdt, path);
534 fdt_prop = fdt_get_property(fdt, nodeoff, "status",
535 NULL);
536 if (fdt_prop && !strcmp(fdt_prop->data, "disabled"))
537 continue;
538 i++;
539#endif
Simon Glass00caae62017-08-03 12:22:12 -0600540 tmp = env_get(mac);
Bin Mengbc393a72015-11-03 04:24:41 -0800541 if (!tmp)
542 continue;
543
544 for (j = 0; j < 6; j++) {
545 mac_addr[j] = tmp ?
546 simple_strtoul(tmp, &end, 16) : 0;
547 if (tmp)
548 tmp = (*end) ? end + 1 : end;
549 }
550
551 do_fixup_by_path(fdt, path, "mac-address",
552 &mac_addr, 6, 0);
553 do_fixup_by_path(fdt, path, "local-mac-address",
554 &mac_addr, 6, 1);
Dan Murphyb1f49ab2013-10-02 14:00:15 -0500555 }
Kumar Galaab544632007-11-21 11:11:03 -0600556 }
557}
Anton Vorontsov18e69a32008-03-14 23:20:18 +0300558
Philipp Tomsicha5af51a2018-02-02 12:01:44 +0100559int fdt_record_loadable(void *blob, u32 index, const char *name,
560 uintptr_t load_addr, u32 size, uintptr_t entry_point,
561 const char *type, const char *os)
562{
563 int err, node;
564
565 err = fdt_check_header(blob);
566 if (err < 0) {
567 printf("%s: %s\n", __func__, fdt_strerror(err));
568 return err;
569 }
570
571 /* find or create "/fit-images" node */
572 node = fdt_find_or_add_subnode(blob, 0, "fit-images");
573 if (node < 0)
574 return node;
575
576 /* find or create "/fit-images/<name>" node */
577 node = fdt_find_or_add_subnode(blob, node, name);
578 if (node < 0)
579 return node;
580
581 /*
582 * We record these as 32bit entities, possibly truncating addresses.
583 * However, spl_fit.c is not 64bit safe either: i.e. we should not
584 * have an issue here.
585 */
586 fdt_setprop_u32(blob, node, "load-addr", load_addr);
587 if (entry_point != -1)
588 fdt_setprop_u32(blob, node, "entry-point", entry_point);
589 fdt_setprop_u32(blob, node, "size", size);
590 if (type)
591 fdt_setprop_string(blob, node, "type", type);
592 if (os)
593 fdt_setprop_string(blob, node, "os", os);
594
595 return node;
596}
597
Kumar Gala3082d232008-08-15 08:24:42 -0500598/* Resize the fdt to its actual size + a bit of padding */
Hannes Schmelzeref476832016-09-20 18:10:43 +0200599int fdt_shrink_to_minimum(void *blob, uint extrasize)
Kumar Gala3082d232008-08-15 08:24:42 -0500600{
601 int i;
602 uint64_t addr, size;
603 int total, ret;
604 uint actualsize;
605
606 if (!blob)
607 return 0;
608
609 total = fdt_num_mem_rsv(blob);
610 for (i = 0; i < total; i++) {
611 fdt_get_mem_rsv(blob, i, &addr, &size);
Simon Glass92549352011-09-17 06:48:58 +0000612 if (addr == (uintptr_t)blob) {
Kumar Gala3082d232008-08-15 08:24:42 -0500613 fdt_del_mem_rsv(blob, i);
614 break;
615 }
616 }
617
Peter Korsgaardf242a082008-10-28 08:26:52 +0100618 /*
619 * Calculate the actual size of the fdt
Feng Wang3840ebf2010-08-03 16:22:43 +0200620 * plus the size needed for 5 fdt_add_mem_rsv, one
621 * for the fdt itself and 4 for a possible initrd
622 * ((initrd-start + initrd-end) * 2 (name & value))
Peter Korsgaardf242a082008-10-28 08:26:52 +0100623 */
Kumar Gala3082d232008-08-15 08:24:42 -0500624 actualsize = fdt_off_dt_strings(blob) +
Feng Wang3840ebf2010-08-03 16:22:43 +0200625 fdt_size_dt_strings(blob) + 5 * sizeof(struct fdt_reserve_entry);
Kumar Gala3082d232008-08-15 08:24:42 -0500626
Hannes Schmelzeref476832016-09-20 18:10:43 +0200627 actualsize += extrasize;
Kumar Gala3082d232008-08-15 08:24:42 -0500628 /* Make it so the fdt ends on a page boundary */
Simon Glass92549352011-09-17 06:48:58 +0000629 actualsize = ALIGN(actualsize + ((uintptr_t)blob & 0xfff), 0x1000);
630 actualsize = actualsize - ((uintptr_t)blob & 0xfff);
Kumar Gala3082d232008-08-15 08:24:42 -0500631
632 /* Change the fdt header to reflect the correct size */
633 fdt_set_totalsize(blob, actualsize);
634
635 /* Add the new reservation */
Simon Glass92549352011-09-17 06:48:58 +0000636 ret = fdt_add_mem_rsv(blob, (uintptr_t)blob, actualsize);
Kumar Gala3082d232008-08-15 08:24:42 -0500637 if (ret < 0)
638 return ret;
639
640 return actualsize;
641}
Kumar Gala8ab451c2008-10-22 23:33:56 -0500642
643#ifdef CONFIG_PCI
Kumar Galacfd700b2009-08-05 09:03:54 -0500644#define CONFIG_SYS_PCI_NR_INBOUND_WIN 4
Kumar Gala8ab451c2008-10-22 23:33:56 -0500645
646#define FDT_PCI_PREFETCH (0x40000000)
647#define FDT_PCI_MEM32 (0x02000000)
648#define FDT_PCI_IO (0x01000000)
649#define FDT_PCI_MEM64 (0x03000000)
650
651int fdt_pci_dma_ranges(void *blob, int phb_off, struct pci_controller *hose) {
652
653 int addrcell, sizecell, len, r;
654 u32 *dma_range;
655 /* sized based on pci addr cells, size-cells, & address-cells */
656 u32 dma_ranges[(3 + 2 + 2) * CONFIG_SYS_PCI_NR_INBOUND_WIN];
657
658 addrcell = fdt_getprop_u32_default(blob, "/", "#address-cells", 1);
659 sizecell = fdt_getprop_u32_default(blob, "/", "#size-cells", 1);
660
661 dma_range = &dma_ranges[0];
662 for (r = 0; r < hose->region_count; r++) {
663 u64 bus_start, phys_start, size;
664
Kumar Galaff4e66e2009-02-06 09:49:31 -0600665 /* skip if !PCI_REGION_SYS_MEMORY */
666 if (!(hose->regions[r].flags & PCI_REGION_SYS_MEMORY))
Kumar Gala8ab451c2008-10-22 23:33:56 -0500667 continue;
668
669 bus_start = (u64)hose->regions[r].bus_start;
670 phys_start = (u64)hose->regions[r].phys_start;
671 size = (u64)hose->regions[r].size;
672
673 dma_range[0] = 0;
Kumar Galacfd700b2009-08-05 09:03:54 -0500674 if (size >= 0x100000000ull)
Kumar Gala8ab451c2008-10-22 23:33:56 -0500675 dma_range[0] |= FDT_PCI_MEM64;
676 else
677 dma_range[0] |= FDT_PCI_MEM32;
678 if (hose->regions[r].flags & PCI_REGION_PREFETCH)
679 dma_range[0] |= FDT_PCI_PREFETCH;
680#ifdef CONFIG_SYS_PCI_64BIT
681 dma_range[1] = bus_start >> 32;
682#else
683 dma_range[1] = 0;
684#endif
685 dma_range[2] = bus_start & 0xffffffff;
686
687 if (addrcell == 2) {
688 dma_range[3] = phys_start >> 32;
689 dma_range[4] = phys_start & 0xffffffff;
690 } else {
691 dma_range[3] = phys_start & 0xffffffff;
692 }
693
694 if (sizecell == 2) {
695 dma_range[3 + addrcell + 0] = size >> 32;
696 dma_range[3 + addrcell + 1] = size & 0xffffffff;
697 } else {
698 dma_range[3 + addrcell + 0] = size & 0xffffffff;
699 }
700
701 dma_range += (3 + addrcell + sizecell);
702 }
703
704 len = dma_range - &dma_ranges[0];
705 if (len)
706 fdt_setprop(blob, phb_off, "dma-ranges", &dma_ranges[0], len*4);
707
708 return 0;
709}
710#endif
Stefan Roese30d45c02009-10-21 11:59:52 +0200711
Matthew McClintockcb2707a2010-10-13 13:39:26 +0200712int fdt_increase_size(void *fdt, int add_len)
713{
714 int newlen;
715
716 newlen = fdt_totalsize(fdt) + add_len;
717
718 /* Open in place with a new len */
719 return fdt_open_into(fdt, fdt, newlen);
720}
721
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100722#ifdef CONFIG_FDT_FIXUP_PARTITIONS
723#include <jffs2/load_kernel.h>
724#include <mtd_node.h>
725
726struct reg_cell {
727 unsigned int r0;
728 unsigned int r1;
729};
730
Michal Simekcd1457d2018-07-31 14:31:04 +0200731static int fdt_del_subnodes(const void *blob, int parent_offset)
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100732{
733 int off, ndepth;
734 int ret;
735
736 for (ndepth = 0, off = fdt_next_node(blob, parent_offset, &ndepth);
737 (off >= 0) && (ndepth > 0);
738 off = fdt_next_node(blob, off, &ndepth)) {
739 if (ndepth == 1) {
740 debug("delete %s: offset: %x\n",
741 fdt_get_name(blob, off, 0), off);
742 ret = fdt_del_node((void *)blob, off);
743 if (ret < 0) {
744 printf("Can't delete node: %s\n",
745 fdt_strerror(ret));
746 return ret;
747 } else {
748 ndepth = 0;
749 off = parent_offset;
750 }
751 }
752 }
753 return 0;
754}
755
Michal Simekcd1457d2018-07-31 14:31:04 +0200756static int fdt_del_partitions(void *blob, int parent_offset)
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100757{
758 const void *prop;
759 int ndepth = 0;
760 int off;
761 int ret;
762
763 off = fdt_next_node(blob, parent_offset, &ndepth);
764 if (off > 0 && ndepth == 1) {
765 prop = fdt_getprop(blob, off, "label", NULL);
766 if (prop == NULL) {
767 /*
768 * Could not find label property, nand {}; node?
769 * Check subnode, delete partitions there if any.
770 */
771 return fdt_del_partitions(blob, off);
772 } else {
773 ret = fdt_del_subnodes(blob, parent_offset);
774 if (ret < 0) {
775 printf("Can't remove subnodes: %s\n",
776 fdt_strerror(ret));
777 return ret;
778 }
779 }
780 }
781 return 0;
782}
783
784int fdt_node_set_part_info(void *blob, int parent_offset,
785 struct mtd_device *dev)
786{
787 struct list_head *pentry;
788 struct part_info *part;
789 struct reg_cell cell;
790 int off, ndepth = 0;
791 int part_num, ret;
792 char buf[64];
793
794 ret = fdt_del_partitions(blob, parent_offset);
795 if (ret < 0)
796 return ret;
797
798 /*
799 * Check if it is nand {}; subnode, adjust
800 * the offset in this case
801 */
802 off = fdt_next_node(blob, parent_offset, &ndepth);
803 if (off > 0 && ndepth == 1)
804 parent_offset = off;
805
806 part_num = 0;
807 list_for_each_prev(pentry, &dev->parts) {
808 int newoff;
809
810 part = list_entry(pentry, struct part_info, link);
811
Scott Wood06503f12013-10-15 17:41:27 -0500812 debug("%2d: %-20s0x%08llx\t0x%08llx\t%d\n",
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100813 part_num, part->name, part->size,
814 part->offset, part->mask_flags);
815
Scott Wood06503f12013-10-15 17:41:27 -0500816 sprintf(buf, "partition@%llx", part->offset);
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100817add_sub:
818 ret = fdt_add_subnode(blob, parent_offset, buf);
819 if (ret == -FDT_ERR_NOSPACE) {
820 ret = fdt_increase_size(blob, 512);
821 if (!ret)
822 goto add_sub;
823 else
824 goto err_size;
825 } else if (ret < 0) {
826 printf("Can't add partition node: %s\n",
827 fdt_strerror(ret));
828 return ret;
829 }
830 newoff = ret;
831
832 /* Check MTD_WRITEABLE_CMD flag */
833 if (part->mask_flags & 1) {
834add_ro:
835 ret = fdt_setprop(blob, newoff, "read_only", NULL, 0);
836 if (ret == -FDT_ERR_NOSPACE) {
837 ret = fdt_increase_size(blob, 512);
838 if (!ret)
839 goto add_ro;
840 else
841 goto err_size;
842 } else if (ret < 0)
843 goto err_prop;
844 }
845
846 cell.r0 = cpu_to_fdt32(part->offset);
847 cell.r1 = cpu_to_fdt32(part->size);
848add_reg:
849 ret = fdt_setprop(blob, newoff, "reg", &cell, sizeof(cell));
850 if (ret == -FDT_ERR_NOSPACE) {
851 ret = fdt_increase_size(blob, 512);
852 if (!ret)
853 goto add_reg;
854 else
855 goto err_size;
856 } else if (ret < 0)
857 goto err_prop;
858
859add_label:
860 ret = fdt_setprop_string(blob, newoff, "label", part->name);
861 if (ret == -FDT_ERR_NOSPACE) {
862 ret = fdt_increase_size(blob, 512);
863 if (!ret)
864 goto add_label;
865 else
866 goto err_size;
867 } else if (ret < 0)
868 goto err_prop;
869
870 part_num++;
871 }
872 return 0;
873err_size:
874 printf("Can't increase blob size: %s\n", fdt_strerror(ret));
875 return ret;
876err_prop:
877 printf("Can't add property: %s\n", fdt_strerror(ret));
878 return ret;
879}
880
881/*
882 * Update partitions in nor/nand nodes using info from
883 * mtdparts environment variable. The nodes to update are
884 * specified by node_info structure which contains mtd device
885 * type and compatible string: E. g. the board code in
886 * ft_board_setup() could use:
887 *
888 * struct node_info nodes[] = {
889 * { "fsl,mpc5121-nfc", MTD_DEV_TYPE_NAND, },
890 * { "cfi-flash", MTD_DEV_TYPE_NOR, },
891 * };
892 *
893 * fdt_fixup_mtdparts(blob, nodes, ARRAY_SIZE(nodes));
894 */
Masahiro Yamada5f4e32d2018-07-19 16:28:22 +0900895void fdt_fixup_mtdparts(void *blob, const struct node_info *node_info,
896 int node_info_size)
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100897{
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100898 struct mtd_device *dev;
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100899 int i, idx;
900 int noff;
901
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100902 if (mtdparts_init() != 0)
903 return;
904
905 for (i = 0; i < node_info_size; i++) {
906 idx = 0;
Masahiro Yamada5f4e32d2018-07-19 16:28:22 +0900907 noff = fdt_node_offset_by_compatible(blob, -1,
908 node_info[i].compat);
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100909 while (noff != -FDT_ERR_NOTFOUND) {
910 debug("%s: %s, mtd dev type %d\n",
911 fdt_get_name(blob, noff, 0),
Masahiro Yamada5f4e32d2018-07-19 16:28:22 +0900912 node_info[i].compat, node_info[i].type);
913 dev = device_find(node_info[i].type, idx++);
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100914 if (dev) {
915 if (fdt_node_set_part_info(blob, noff, dev))
916 return; /* return on error */
917 }
918
919 /* Jump to next flash node */
920 noff = fdt_node_offset_by_compatible(blob, noff,
Masahiro Yamada5f4e32d2018-07-19 16:28:22 +0900921 node_info[i].compat);
Anatolij Gustschin3c950e22010-03-16 17:10:05 +0100922 }
923 }
924}
925#endif
Kumar Gala49b97d92010-03-30 10:19:26 -0500926
927void fdt_del_node_and_alias(void *blob, const char *alias)
928{
929 int off = fdt_path_offset(blob, alias);
930
931 if (off < 0)
932 return;
933
934 fdt_del_node(blob, off);
935
936 off = fdt_path_offset(blob, "/aliases");
937 fdt_delprop(blob, off, alias);
938}
Kumar Galaa0342c02010-06-16 14:27:38 -0500939
Kumar Galaa0342c02010-06-16 14:27:38 -0500940/* Max address size we deal with */
941#define OF_MAX_ADDR_CELLS 4
Bin Menga0ae3802015-12-07 01:39:47 -0800942#define OF_BAD_ADDR FDT_ADDR_T_NONE
Przemyslaw Marczak4428f3c2016-01-12 15:40:44 +0100943#define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \
944 (ns) > 0)
Kumar Galaa0342c02010-06-16 14:27:38 -0500945
946/* Debug utility */
947#ifdef DEBUG
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000948static void of_dump_addr(const char *s, const fdt32_t *addr, int na)
Kumar Galaa0342c02010-06-16 14:27:38 -0500949{
950 printf("%s", s);
951 while(na--)
952 printf(" %08x", *(addr++));
953 printf("\n");
954}
955#else
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000956static void of_dump_addr(const char *s, const fdt32_t *addr, int na) { }
Kumar Galaa0342c02010-06-16 14:27:38 -0500957#endif
958
Paul Burton0a222d52016-05-17 07:43:24 +0100959/**
960 * struct of_bus - Callbacks for bus specific translators
Paul Burton49717b12016-05-17 07:43:25 +0100961 * @name: A string used to identify this bus in debug output.
962 * @addresses: The name of the DT property from which addresses are
963 * to be read, typically "reg".
Paul Burton0a222d52016-05-17 07:43:24 +0100964 * @match: Return non-zero if the node whose parent is at
965 * parentoffset in the FDT blob corresponds to a bus
966 * of this type, otherwise return zero. If NULL a match
967 * is assumed.
Paul Burton49717b12016-05-17 07:43:25 +0100968 * @count_cells:Count how many cells (be32 values) a node whose parent
969 * is at parentoffset in the FDT blob will require to
970 * represent its address (written to *addrc) & size
971 * (written to *sizec).
972 * @map: Map the address addr from the address space of this
973 * bus to that of its parent, making use of the ranges
974 * read from DT to an array at range. na and ns are the
975 * number of cells (be32 values) used to hold and address
976 * or size, respectively, for this bus. pna is the number
977 * of cells used to hold an address for the parent bus.
978 * Returns the address in the address space of the parent
979 * bus.
980 * @translate: Update the value of the address cells at addr within an
981 * FDT by adding offset to it. na specifies the number of
982 * cells used to hold the address being translated. Returns
983 * zero on success, non-zero on error.
Paul Burton0a222d52016-05-17 07:43:24 +0100984 *
985 * Each bus type will include a struct of_bus in the of_busses array,
986 * providing implementations of some or all of the functions used to
987 * match the bus & handle address translation for its children.
988 */
Kumar Galaa0342c02010-06-16 14:27:38 -0500989struct of_bus {
990 const char *name;
991 const char *addresses;
Stephen Warren11e44fc2016-08-05 09:47:50 -0600992 int (*match)(const void *blob, int parentoffset);
993 void (*count_cells)(const void *blob, int parentoffset,
Kumar Galaa0342c02010-06-16 14:27:38 -0500994 int *addrc, int *sizec);
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000995 u64 (*map)(fdt32_t *addr, const fdt32_t *range,
Kumar Galaa0342c02010-06-16 14:27:38 -0500996 int na, int ns, int pna);
Kim Phillips8aa5ec62013-01-16 14:00:11 +0000997 int (*translate)(fdt32_t *addr, u64 offset, int na);
Kumar Galaa0342c02010-06-16 14:27:38 -0500998};
999
1000/* Default translator (generic bus) */
Simon Glasseed36602017-05-18 20:09:26 -06001001void fdt_support_default_count_cells(const void *blob, int parentoffset,
Kumar Galaa0342c02010-06-16 14:27:38 -05001002 int *addrc, int *sizec)
1003{
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001004 const fdt32_t *prop;
Scott Wood6395f312010-08-12 18:37:39 -05001005
Simon Glass933cdbb2014-10-23 18:58:57 -06001006 if (addrc)
1007 *addrc = fdt_address_cells(blob, parentoffset);
Scott Wood6395f312010-08-12 18:37:39 -05001008
1009 if (sizec) {
1010 prop = fdt_getprop(blob, parentoffset, "#size-cells", NULL);
1011 if (prop)
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001012 *sizec = be32_to_cpup(prop);
Scott Wood6395f312010-08-12 18:37:39 -05001013 else
1014 *sizec = 1;
1015 }
Kumar Galaa0342c02010-06-16 14:27:38 -05001016}
1017
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001018static u64 of_bus_default_map(fdt32_t *addr, const fdt32_t *range,
Kumar Galaa0342c02010-06-16 14:27:38 -05001019 int na, int ns, int pna)
1020{
1021 u64 cp, s, da;
1022
Simon Glasseed36602017-05-18 20:09:26 -06001023 cp = fdt_read_number(range, na);
1024 s = fdt_read_number(range + na + pna, ns);
1025 da = fdt_read_number(addr, na);
Kumar Galaa0342c02010-06-16 14:27:38 -05001026
Masahiro Yamadadee37fc2018-08-06 20:47:40 +09001027 debug("OF: default map, cp=%llu, s=%llu, da=%llu\n", cp, s, da);
Kumar Galaa0342c02010-06-16 14:27:38 -05001028
1029 if (da < cp || da >= (cp + s))
1030 return OF_BAD_ADDR;
1031 return da - cp;
1032}
1033
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001034static int of_bus_default_translate(fdt32_t *addr, u64 offset, int na)
Kumar Galaa0342c02010-06-16 14:27:38 -05001035{
Simon Glasseed36602017-05-18 20:09:26 -06001036 u64 a = fdt_read_number(addr, na);
Kumar Galaa0342c02010-06-16 14:27:38 -05001037 memset(addr, 0, na * 4);
1038 a += offset;
1039 if (na > 1)
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001040 addr[na - 2] = cpu_to_fdt32(a >> 32);
1041 addr[na - 1] = cpu_to_fdt32(a & 0xffffffffu);
Kumar Galaa0342c02010-06-16 14:27:38 -05001042
1043 return 0;
1044}
1045
Paul Burton0a222d52016-05-17 07:43:24 +01001046#ifdef CONFIG_OF_ISA_BUS
1047
1048/* ISA bus translator */
Stephen Warren11e44fc2016-08-05 09:47:50 -06001049static int of_bus_isa_match(const void *blob, int parentoffset)
Paul Burton0a222d52016-05-17 07:43:24 +01001050{
1051 const char *name;
1052
1053 name = fdt_get_name(blob, parentoffset, NULL);
1054 if (!name)
1055 return 0;
1056
1057 return !strcmp(name, "isa");
1058}
1059
Stephen Warren11e44fc2016-08-05 09:47:50 -06001060static void of_bus_isa_count_cells(const void *blob, int parentoffset,
Paul Burton0a222d52016-05-17 07:43:24 +01001061 int *addrc, int *sizec)
1062{
1063 if (addrc)
1064 *addrc = 2;
1065 if (sizec)
1066 *sizec = 1;
1067}
1068
1069static u64 of_bus_isa_map(fdt32_t *addr, const fdt32_t *range,
1070 int na, int ns, int pna)
1071{
1072 u64 cp, s, da;
1073
1074 /* Check address type match */
1075 if ((addr[0] ^ range[0]) & cpu_to_be32(1))
1076 return OF_BAD_ADDR;
1077
Simon Glasseed36602017-05-18 20:09:26 -06001078 cp = fdt_read_number(range + 1, na - 1);
1079 s = fdt_read_number(range + na + pna, ns);
1080 da = fdt_read_number(addr + 1, na - 1);
Paul Burton0a222d52016-05-17 07:43:24 +01001081
Masahiro Yamadadee37fc2018-08-06 20:47:40 +09001082 debug("OF: ISA map, cp=%llu, s=%llu, da=%llu\n", cp, s, da);
Paul Burton0a222d52016-05-17 07:43:24 +01001083
1084 if (da < cp || da >= (cp + s))
1085 return OF_BAD_ADDR;
1086 return da - cp;
1087}
1088
1089static int of_bus_isa_translate(fdt32_t *addr, u64 offset, int na)
1090{
1091 return of_bus_default_translate(addr + 1, offset, na - 1);
1092}
1093
1094#endif /* CONFIG_OF_ISA_BUS */
1095
Kumar Galaa0342c02010-06-16 14:27:38 -05001096/* Array of bus specific translators */
1097static struct of_bus of_busses[] = {
Paul Burton0a222d52016-05-17 07:43:24 +01001098#ifdef CONFIG_OF_ISA_BUS
1099 /* ISA */
1100 {
1101 .name = "isa",
1102 .addresses = "reg",
1103 .match = of_bus_isa_match,
1104 .count_cells = of_bus_isa_count_cells,
1105 .map = of_bus_isa_map,
1106 .translate = of_bus_isa_translate,
1107 },
1108#endif /* CONFIG_OF_ISA_BUS */
Kumar Galaa0342c02010-06-16 14:27:38 -05001109 /* Default */
1110 {
1111 .name = "default",
1112 .addresses = "reg",
Simon Glasseed36602017-05-18 20:09:26 -06001113 .count_cells = fdt_support_default_count_cells,
Kumar Galaa0342c02010-06-16 14:27:38 -05001114 .map = of_bus_default_map,
1115 .translate = of_bus_default_translate,
1116 },
1117};
1118
Stephen Warren11e44fc2016-08-05 09:47:50 -06001119static struct of_bus *of_match_bus(const void *blob, int parentoffset)
Paul Burton0a222d52016-05-17 07:43:24 +01001120{
1121 struct of_bus *bus;
1122
1123 if (ARRAY_SIZE(of_busses) == 1)
1124 return of_busses;
1125
1126 for (bus = of_busses; bus; bus++) {
1127 if (!bus->match || bus->match(blob, parentoffset))
1128 return bus;
1129 }
1130
1131 /*
1132 * We should always have matched the default bus at least, since
1133 * it has a NULL match field. If we didn't then it somehow isn't
1134 * in the of_busses array or something equally catastrophic has
1135 * gone wrong.
1136 */
1137 assert(0);
1138 return NULL;
1139}
1140
Stephen Warren11e44fc2016-08-05 09:47:50 -06001141static int of_translate_one(const void *blob, int parent, struct of_bus *bus,
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001142 struct of_bus *pbus, fdt32_t *addr,
Kumar Galaa0342c02010-06-16 14:27:38 -05001143 int na, int ns, int pna, const char *rprop)
1144{
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001145 const fdt32_t *ranges;
Kumar Galaa0342c02010-06-16 14:27:38 -05001146 int rlen;
1147 int rone;
1148 u64 offset = OF_BAD_ADDR;
1149
1150 /* Normally, an absence of a "ranges" property means we are
1151 * crossing a non-translatable boundary, and thus the addresses
1152 * below the current not cannot be converted to CPU physical ones.
1153 * Unfortunately, while this is very clear in the spec, it's not
1154 * what Apple understood, and they do have things like /uni-n or
1155 * /ht nodes with no "ranges" property and a lot of perfectly
1156 * useable mapped devices below them. Thus we treat the absence of
1157 * "ranges" as equivalent to an empty "ranges" property which means
1158 * a 1:1 translation at that level. It's up to the caller not to try
1159 * to translate addresses that aren't supposed to be translated in
1160 * the first place. --BenH.
1161 */
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001162 ranges = fdt_getprop(blob, parent, rprop, &rlen);
Kumar Galaa0342c02010-06-16 14:27:38 -05001163 if (ranges == NULL || rlen == 0) {
Simon Glasseed36602017-05-18 20:09:26 -06001164 offset = fdt_read_number(addr, na);
Kumar Galaa0342c02010-06-16 14:27:38 -05001165 memset(addr, 0, pna * 4);
1166 debug("OF: no ranges, 1:1 translation\n");
1167 goto finish;
1168 }
1169
1170 debug("OF: walking ranges...\n");
1171
1172 /* Now walk through the ranges */
1173 rlen /= 4;
1174 rone = na + pna + ns;
1175 for (; rlen >= rone; rlen -= rone, ranges += rone) {
1176 offset = bus->map(addr, ranges, na, ns, pna);
1177 if (offset != OF_BAD_ADDR)
1178 break;
1179 }
1180 if (offset == OF_BAD_ADDR) {
1181 debug("OF: not found !\n");
1182 return 1;
1183 }
1184 memcpy(addr, ranges + na, 4 * pna);
1185
1186 finish:
1187 of_dump_addr("OF: parent translation for:", addr, pna);
Masahiro Yamadadee37fc2018-08-06 20:47:40 +09001188 debug("OF: with offset: %llu\n", offset);
Kumar Galaa0342c02010-06-16 14:27:38 -05001189
1190 /* Translate it into parent bus space */
1191 return pbus->translate(addr, offset, pna);
1192}
1193
1194/*
1195 * Translate an address from the device-tree into a CPU physical address,
1196 * this walks up the tree and applies the various bus mappings on the
1197 * way.
1198 *
1199 * Note: We consider that crossing any level with #size-cells == 0 to mean
1200 * that translation is impossible (that is we are not dealing with a value
1201 * that can be mapped to a cpu physical address). This is not really specified
1202 * that way, but this is traditionally the way IBM at least do things
1203 */
Stephen Warren11e44fc2016-08-05 09:47:50 -06001204static u64 __of_translate_address(const void *blob, int node_offset,
1205 const fdt32_t *in_addr, const char *rprop)
Kumar Galaa0342c02010-06-16 14:27:38 -05001206{
1207 int parent;
1208 struct of_bus *bus, *pbus;
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001209 fdt32_t addr[OF_MAX_ADDR_CELLS];
Kumar Galaa0342c02010-06-16 14:27:38 -05001210 int na, ns, pna, pns;
1211 u64 result = OF_BAD_ADDR;
1212
1213 debug("OF: ** translation for device %s **\n",
1214 fdt_get_name(blob, node_offset, NULL));
1215
1216 /* Get parent & match bus type */
1217 parent = fdt_parent_offset(blob, node_offset);
1218 if (parent < 0)
1219 goto bail;
Paul Burton0a222d52016-05-17 07:43:24 +01001220 bus = of_match_bus(blob, parent);
Kumar Galaa0342c02010-06-16 14:27:38 -05001221
1222 /* Cound address cells & copy address locally */
Scott Wood6395f312010-08-12 18:37:39 -05001223 bus->count_cells(blob, parent, &na, &ns);
Przemyslaw Marczak4428f3c2016-01-12 15:40:44 +01001224 if (!OF_CHECK_COUNTS(na, ns)) {
Kumar Galaa0342c02010-06-16 14:27:38 -05001225 printf("%s: Bad cell count for %s\n", __FUNCTION__,
1226 fdt_get_name(blob, node_offset, NULL));
1227 goto bail;
1228 }
1229 memcpy(addr, in_addr, na * 4);
1230
1231 debug("OF: bus is %s (na=%d, ns=%d) on %s\n",
1232 bus->name, na, ns, fdt_get_name(blob, parent, NULL));
1233 of_dump_addr("OF: translating address:", addr, na);
1234
1235 /* Translate */
1236 for (;;) {
1237 /* Switch to parent bus */
1238 node_offset = parent;
1239 parent = fdt_parent_offset(blob, node_offset);
1240
1241 /* If root, we have finished */
1242 if (parent < 0) {
1243 debug("OF: reached root node\n");
Simon Glasseed36602017-05-18 20:09:26 -06001244 result = fdt_read_number(addr, na);
Kumar Galaa0342c02010-06-16 14:27:38 -05001245 break;
1246 }
1247
1248 /* Get new parent bus and counts */
Paul Burton0a222d52016-05-17 07:43:24 +01001249 pbus = of_match_bus(blob, parent);
Scott Wood6395f312010-08-12 18:37:39 -05001250 pbus->count_cells(blob, parent, &pna, &pns);
Przemyslaw Marczak4428f3c2016-01-12 15:40:44 +01001251 if (!OF_CHECK_COUNTS(pna, pns)) {
Kumar Galaa0342c02010-06-16 14:27:38 -05001252 printf("%s: Bad cell count for %s\n", __FUNCTION__,
1253 fdt_get_name(blob, node_offset, NULL));
1254 break;
1255 }
1256
1257 debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
1258 pbus->name, pna, pns, fdt_get_name(blob, parent, NULL));
1259
1260 /* Apply bus translation */
1261 if (of_translate_one(blob, node_offset, bus, pbus,
1262 addr, na, ns, pna, rprop))
1263 break;
1264
1265 /* Complete the move up one level */
1266 na = pna;
1267 ns = pns;
1268 bus = pbus;
1269
1270 of_dump_addr("OF: one level translation:", addr, na);
1271 }
1272 bail:
1273
1274 return result;
1275}
1276
Stephen Warren11e44fc2016-08-05 09:47:50 -06001277u64 fdt_translate_address(const void *blob, int node_offset,
1278 const fdt32_t *in_addr)
Kumar Galaa0342c02010-06-16 14:27:38 -05001279{
1280 return __of_translate_address(blob, node_offset, in_addr, "ranges");
1281}
Kumar Gala75e73af2010-07-04 12:48:21 -05001282
1283/**
1284 * fdt_node_offset_by_compat_reg: Find a node that matches compatiable and
1285 * who's reg property matches a physical cpu address
1286 *
1287 * @blob: ptr to device tree
1288 * @compat: compatiable string to match
1289 * @compat_off: property name
1290 *
1291 */
1292int fdt_node_offset_by_compat_reg(void *blob, const char *compat,
1293 phys_addr_t compat_off)
1294{
1295 int len, off = fdt_node_offset_by_compatible(blob, -1, compat);
1296 while (off != -FDT_ERR_NOTFOUND) {
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001297 const fdt32_t *reg = fdt_getprop(blob, off, "reg", &len);
Kumar Gala75e73af2010-07-04 12:48:21 -05001298 if (reg) {
1299 if (compat_off == fdt_translate_address(blob, off, reg))
1300 return off;
1301 }
1302 off = fdt_node_offset_by_compatible(blob, off, compat);
1303 }
1304
1305 return -FDT_ERR_NOTFOUND;
1306}
1307
Kumar Galab4b847e2010-07-09 16:18:58 -05001308/**
1309 * fdt_alloc_phandle: Return next free phandle value
1310 *
1311 * @blob: ptr to device tree
1312 */
1313int fdt_alloc_phandle(void *blob)
1314{
Masahiro Yamadab4141192014-11-07 03:03:31 +09001315 int offset;
1316 uint32_t phandle = 0;
Kumar Gala75e73af2010-07-04 12:48:21 -05001317
Kumar Galab4b847e2010-07-09 16:18:58 -05001318 for (offset = fdt_next_node(blob, -1, NULL); offset >= 0;
1319 offset = fdt_next_node(blob, offset, NULL)) {
Timur Tabi50bf17b2011-09-20 18:24:35 -05001320 phandle = max(phandle, fdt_get_phandle(blob, offset));
Kumar Galab4b847e2010-07-09 16:18:58 -05001321 }
1322
1323 return phandle + 1;
1324}
Anatolij Gustschinbeca5a52010-08-18 11:25:20 +02001325
Gerald Van Barena8d2a752011-07-14 21:40:10 -04001326/*
Kumar Galaf117c0f2011-08-01 00:23:23 -05001327 * fdt_set_phandle: Create a phandle property for the given node
Gerald Van Barena8d2a752011-07-14 21:40:10 -04001328 *
1329 * @fdt: ptr to device tree
1330 * @nodeoffset: node to update
1331 * @phandle: phandle value to set (must be unique)
Kumar Galaf117c0f2011-08-01 00:23:23 -05001332 */
1333int fdt_set_phandle(void *fdt, int nodeoffset, uint32_t phandle)
Gerald Van Barena8d2a752011-07-14 21:40:10 -04001334{
1335 int ret;
1336
1337#ifdef DEBUG
1338 int off = fdt_node_offset_by_phandle(fdt, phandle);
1339
1340 if ((off >= 0) && (off != nodeoffset)) {
1341 char buf[64];
1342
1343 fdt_get_path(fdt, nodeoffset, buf, sizeof(buf));
1344 printf("Trying to update node %s with phandle %u ",
1345 buf, phandle);
1346
1347 fdt_get_path(fdt, off, buf, sizeof(buf));
1348 printf("that already exists in node %s.\n", buf);
1349 return -FDT_ERR_BADPHANDLE;
1350 }
1351#endif
1352
1353 ret = fdt_setprop_cell(fdt, nodeoffset, "phandle", phandle);
1354 if (ret < 0)
1355 return ret;
1356
1357 /*
1358 * For now, also set the deprecated "linux,phandle" property, so that we
1359 * don't break older kernels.
1360 */
1361 ret = fdt_setprop_cell(fdt, nodeoffset, "linux,phandle", phandle);
1362
1363 return ret;
1364}
1365
Kumar Gala10aeabd2011-08-01 00:25:20 -05001366/*
1367 * fdt_create_phandle: Create a phandle property for the given node
1368 *
1369 * @fdt: ptr to device tree
1370 * @nodeoffset: node to update
1371 */
Timur Tabi3c927cc2011-09-20 18:24:34 -05001372unsigned int fdt_create_phandle(void *fdt, int nodeoffset)
Kumar Gala10aeabd2011-08-01 00:25:20 -05001373{
1374 /* see if there is a phandle already */
1375 int phandle = fdt_get_phandle(fdt, nodeoffset);
1376
1377 /* if we got 0, means no phandle so create one */
1378 if (phandle == 0) {
Timur Tabi3c927cc2011-09-20 18:24:34 -05001379 int ret;
1380
Kumar Gala10aeabd2011-08-01 00:25:20 -05001381 phandle = fdt_alloc_phandle(fdt);
Timur Tabi3c927cc2011-09-20 18:24:34 -05001382 ret = fdt_set_phandle(fdt, nodeoffset, phandle);
1383 if (ret < 0) {
1384 printf("Can't set phandle %u: %s\n", phandle,
1385 fdt_strerror(ret));
1386 return 0;
1387 }
Kumar Gala10aeabd2011-08-01 00:25:20 -05001388 }
1389
1390 return phandle;
1391}
1392
Shengzhou Liu2a523f52011-10-14 16:26:05 +08001393/*
1394 * fdt_set_node_status: Set status for the given node
1395 *
1396 * @fdt: ptr to device tree
1397 * @nodeoffset: node to update
1398 * @status: FDT_STATUS_OKAY, FDT_STATUS_DISABLED,
1399 * FDT_STATUS_FAIL, FDT_STATUS_FAIL_ERROR_CODE
1400 * @error_code: optional, only used if status is FDT_STATUS_FAIL_ERROR_CODE
1401 */
1402int fdt_set_node_status(void *fdt, int nodeoffset,
1403 enum fdt_status status, unsigned int error_code)
1404{
1405 char buf[16];
1406 int ret = 0;
1407
1408 if (nodeoffset < 0)
1409 return nodeoffset;
1410
1411 switch (status) {
1412 case FDT_STATUS_OKAY:
1413 ret = fdt_setprop_string(fdt, nodeoffset, "status", "okay");
1414 break;
1415 case FDT_STATUS_DISABLED:
1416 ret = fdt_setprop_string(fdt, nodeoffset, "status", "disabled");
1417 break;
1418 case FDT_STATUS_FAIL:
1419 ret = fdt_setprop_string(fdt, nodeoffset, "status", "fail");
1420 break;
1421 case FDT_STATUS_FAIL_ERROR_CODE:
1422 sprintf(buf, "fail-%d", error_code);
1423 ret = fdt_setprop_string(fdt, nodeoffset, "status", buf);
1424 break;
1425 default:
1426 printf("Invalid fdt status: %x\n", status);
1427 ret = -1;
1428 break;
1429 }
1430
1431 return ret;
1432}
1433
1434/*
1435 * fdt_set_status_by_alias: Set status for the given node given an alias
1436 *
1437 * @fdt: ptr to device tree
1438 * @alias: alias of node to update
1439 * @status: FDT_STATUS_OKAY, FDT_STATUS_DISABLED,
1440 * FDT_STATUS_FAIL, FDT_STATUS_FAIL_ERROR_CODE
1441 * @error_code: optional, only used if status is FDT_STATUS_FAIL_ERROR_CODE
1442 */
1443int fdt_set_status_by_alias(void *fdt, const char* alias,
1444 enum fdt_status status, unsigned int error_code)
1445{
1446 int offset = fdt_path_offset(fdt, alias);
1447
1448 return fdt_set_node_status(fdt, offset, status, error_code);
1449}
1450
Tom Wai-Hong Tam096eb3f2012-12-05 14:46:41 +00001451#if defined(CONFIG_VIDEO) || defined(CONFIG_LCD)
Anatolij Gustschinbeca5a52010-08-18 11:25:20 +02001452int fdt_add_edid(void *blob, const char *compat, unsigned char *edid_buf)
1453{
1454 int noff;
1455 int ret;
1456
1457 noff = fdt_node_offset_by_compatible(blob, -1, compat);
1458 if (noff != -FDT_ERR_NOTFOUND) {
1459 debug("%s: %s\n", fdt_get_name(blob, noff, 0), compat);
1460add_edid:
1461 ret = fdt_setprop(blob, noff, "edid", edid_buf, 128);
1462 if (ret == -FDT_ERR_NOSPACE) {
1463 ret = fdt_increase_size(blob, 512);
1464 if (!ret)
1465 goto add_edid;
1466 else
1467 goto err_size;
1468 } else if (ret < 0) {
1469 printf("Can't add property: %s\n", fdt_strerror(ret));
1470 return ret;
1471 }
1472 }
1473 return 0;
1474err_size:
1475 printf("Can't increase blob size: %s\n", fdt_strerror(ret));
1476 return ret;
1477}
1478#endif
Timur Tabibb682002011-05-03 13:24:07 -05001479
1480/*
1481 * Verify the physical address of device tree node for a given alias
1482 *
1483 * This function locates the device tree node of a given alias, and then
1484 * verifies that the physical address of that device matches the given
1485 * parameter. It displays a message if there is a mismatch.
1486 *
1487 * Returns 1 on success, 0 on failure
1488 */
1489int fdt_verify_alias_address(void *fdt, int anode, const char *alias, u64 addr)
1490{
1491 const char *path;
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001492 const fdt32_t *reg;
Timur Tabibb682002011-05-03 13:24:07 -05001493 int node, len;
1494 u64 dt_addr;
1495
1496 path = fdt_getprop(fdt, anode, alias, NULL);
1497 if (!path) {
1498 /* If there's no such alias, then it's not a failure */
1499 return 1;
1500 }
1501
1502 node = fdt_path_offset(fdt, path);
1503 if (node < 0) {
1504 printf("Warning: device tree alias '%s' points to invalid "
1505 "node %s.\n", alias, path);
1506 return 0;
1507 }
1508
1509 reg = fdt_getprop(fdt, node, "reg", &len);
1510 if (!reg) {
1511 printf("Warning: device tree node '%s' has no address.\n",
1512 path);
1513 return 0;
1514 }
1515
1516 dt_addr = fdt_translate_address(fdt, node, reg);
1517 if (addr != dt_addr) {
Masahiro Yamadadee37fc2018-08-06 20:47:40 +09001518 printf("Warning: U-Boot configured device %s at address %llu,\n"
1519 "but the device tree has it address %llx.\n",
1520 alias, addr, dt_addr);
Timur Tabibb682002011-05-03 13:24:07 -05001521 return 0;
1522 }
1523
1524 return 1;
1525}
1526
1527/*
1528 * Returns the base address of an SOC or PCI node
1529 */
Simon Glassec002112017-05-18 20:09:00 -06001530u64 fdt_get_base_address(const void *fdt, int node)
Timur Tabibb682002011-05-03 13:24:07 -05001531{
1532 int size;
Kim Phillips8aa5ec62013-01-16 14:00:11 +00001533 const fdt32_t *prop;
Timur Tabibb682002011-05-03 13:24:07 -05001534
Simon Glass336a4482017-07-04 13:31:20 -06001535 prop = fdt_getprop(fdt, node, "reg", &size);
Timur Tabibb682002011-05-03 13:24:07 -05001536
Simon Glass336a4482017-07-04 13:31:20 -06001537 return prop ? fdt_translate_address(fdt, node, prop) : 0;
Timur Tabibb682002011-05-03 13:24:07 -05001538}
Alexander Grafc48e6862014-04-11 17:09:41 +02001539
1540/*
1541 * Read a property of size <prop_len>. Currently only supports 1 or 2 cells.
1542 */
1543static int fdt_read_prop(const fdt32_t *prop, int prop_len, int cell_off,
1544 uint64_t *val, int cells)
1545{
1546 const fdt32_t *prop32 = &prop[cell_off];
1547 const fdt64_t *prop64 = (const fdt64_t *)&prop[cell_off];
1548
1549 if ((cell_off + cells) > prop_len)
1550 return -FDT_ERR_NOSPACE;
1551
1552 switch (cells) {
1553 case 1:
1554 *val = fdt32_to_cpu(*prop32);
1555 break;
1556 case 2:
1557 *val = fdt64_to_cpu(*prop64);
1558 break;
1559 default:
1560 return -FDT_ERR_NOSPACE;
1561 }
1562
1563 return 0;
1564}
1565
1566/**
1567 * fdt_read_range - Read a node's n'th range property
1568 *
1569 * @fdt: ptr to device tree
1570 * @node: offset of node
1571 * @n: range index
1572 * @child_addr: pointer to storage for the "child address" field
1573 * @addr: pointer to storage for the CPU view translated physical start
1574 * @len: pointer to storage for the range length
1575 *
1576 * Convenience function that reads and interprets a specific range out of
1577 * a number of the "ranges" property array.
1578 */
1579int fdt_read_range(void *fdt, int node, int n, uint64_t *child_addr,
1580 uint64_t *addr, uint64_t *len)
1581{
1582 int pnode = fdt_parent_offset(fdt, node);
1583 const fdt32_t *ranges;
1584 int pacells;
1585 int acells;
1586 int scells;
1587 int ranges_len;
1588 int cell = 0;
1589 int r = 0;
1590
1591 /*
1592 * The "ranges" property is an array of
1593 * { <child address> <parent address> <size in child address space> }
1594 *
1595 * All 3 elements can span a diffent number of cells. Fetch their size.
1596 */
1597 pacells = fdt_getprop_u32_default_node(fdt, pnode, 0, "#address-cells", 1);
1598 acells = fdt_getprop_u32_default_node(fdt, node, 0, "#address-cells", 1);
1599 scells = fdt_getprop_u32_default_node(fdt, node, 0, "#size-cells", 1);
1600
1601 /* Now try to get the ranges property */
1602 ranges = fdt_getprop(fdt, node, "ranges", &ranges_len);
1603 if (!ranges)
1604 return -FDT_ERR_NOTFOUND;
1605 ranges_len /= sizeof(uint32_t);
1606
1607 /* Jump to the n'th entry */
1608 cell = n * (pacells + acells + scells);
1609
1610 /* Read <child address> */
1611 if (child_addr) {
1612 r = fdt_read_prop(ranges, ranges_len, cell, child_addr,
1613 acells);
1614 if (r)
1615 return r;
1616 }
1617 cell += acells;
1618
1619 /* Read <parent address> */
1620 if (addr)
1621 *addr = fdt_translate_address(fdt, node, ranges + cell);
1622 cell += pacells;
1623
1624 /* Read <size in child address space> */
1625 if (len) {
1626 r = fdt_read_prop(ranges, ranges_len, cell, len, scells);
1627 if (r)
1628 return r;
1629 }
1630
1631 return 0;
1632}
Hans de Goeded4f495a2014-11-17 15:29:11 +01001633
1634/**
1635 * fdt_setup_simplefb_node - Fill and enable a simplefb node
1636 *
1637 * @fdt: ptr to device tree
1638 * @node: offset of the simplefb node
1639 * @base_address: framebuffer base address
1640 * @width: width in pixels
1641 * @height: height in pixels
1642 * @stride: bytes per line
1643 * @format: pixel format string
1644 *
1645 * Convenience function to fill and enable a simplefb node.
1646 */
1647int fdt_setup_simplefb_node(void *fdt, int node, u64 base_address, u32 width,
1648 u32 height, u32 stride, const char *format)
1649{
1650 char name[32];
1651 fdt32_t cells[4];
1652 int i, addrc, sizec, ret;
1653
Simon Glasseed36602017-05-18 20:09:26 -06001654 fdt_support_default_count_cells(fdt, fdt_parent_offset(fdt, node),
1655 &addrc, &sizec);
Hans de Goeded4f495a2014-11-17 15:29:11 +01001656 i = 0;
1657 if (addrc == 2)
1658 cells[i++] = cpu_to_fdt32(base_address >> 32);
1659 cells[i++] = cpu_to_fdt32(base_address);
1660 if (sizec == 2)
1661 cells[i++] = 0;
1662 cells[i++] = cpu_to_fdt32(height * stride);
1663
1664 ret = fdt_setprop(fdt, node, "reg", cells, sizeof(cells[0]) * i);
1665 if (ret < 0)
1666 return ret;
1667
Masahiro Yamadadee37fc2018-08-06 20:47:40 +09001668 snprintf(name, sizeof(name), "framebuffer@%llx", base_address);
Hans de Goeded4f495a2014-11-17 15:29:11 +01001669 ret = fdt_set_name(fdt, node, name);
1670 if (ret < 0)
1671 return ret;
1672
1673 ret = fdt_setprop_u32(fdt, node, "width", width);
1674 if (ret < 0)
1675 return ret;
1676
1677 ret = fdt_setprop_u32(fdt, node, "height", height);
1678 if (ret < 0)
1679 return ret;
1680
1681 ret = fdt_setprop_u32(fdt, node, "stride", stride);
1682 if (ret < 0)
1683 return ret;
1684
1685 ret = fdt_setprop_string(fdt, node, "format", format);
1686 if (ret < 0)
1687 return ret;
1688
1689 ret = fdt_setprop_string(fdt, node, "status", "okay");
1690 if (ret < 0)
1691 return ret;
1692
1693 return 0;
1694}
Tim Harvey08daa252015-04-08 11:45:39 -07001695
1696/*
1697 * Update native-mode in display-timings from display environment variable.
1698 * The node to update are specified by path.
1699 */
1700int fdt_fixup_display(void *blob, const char *path, const char *display)
1701{
1702 int off, toff;
1703
1704 if (!display || !path)
1705 return -FDT_ERR_NOTFOUND;
1706
1707 toff = fdt_path_offset(blob, path);
1708 if (toff >= 0)
1709 toff = fdt_subnode_offset(blob, toff, "display-timings");
1710 if (toff < 0)
1711 return toff;
1712
1713 for (off = fdt_first_subnode(blob, toff);
1714 off >= 0;
1715 off = fdt_next_subnode(blob, off)) {
1716 uint32_t h = fdt_get_phandle(blob, off);
1717 debug("%s:0x%x\n", fdt_get_name(blob, off, NULL),
1718 fdt32_to_cpu(h));
1719 if (strcasecmp(fdt_get_name(blob, off, NULL), display) == 0)
1720 return fdt_setprop_u32(blob, toff, "native-mode", h);
1721 }
1722 return toff;
1723}
Pantelis Antonioufc7c3182017-09-04 23:12:11 +03001724
1725#ifdef CONFIG_OF_LIBFDT_OVERLAY
1726/**
1727 * fdt_overlay_apply_verbose - Apply an overlay with verbose error reporting
1728 *
1729 * @fdt: ptr to device tree
1730 * @fdto: ptr to device tree overlay
1731 *
1732 * Convenience function to apply an overlay and display helpful messages
1733 * in the case of an error
1734 */
1735int fdt_overlay_apply_verbose(void *fdt, void *fdto)
1736{
1737 int err;
1738 bool has_symbols;
1739
1740 err = fdt_path_offset(fdt, "/__symbols__");
1741 has_symbols = err >= 0;
1742
1743 err = fdt_overlay_apply(fdt, fdto);
1744 if (err < 0) {
1745 printf("failed on fdt_overlay_apply(): %s\n",
1746 fdt_strerror(err));
1747 if (!has_symbols) {
1748 printf("base fdt does did not have a /__symbols__ node\n");
1749 printf("make sure you've compiled with -@\n");
1750 }
1751 }
1752 return err;
1753}
1754#endif