blob: 62d166097329187578c0bf23760e9403e6cc70ee [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001/* SPDX-License-Identifier: GPL-2.0+ */
Simon Glass2d2af852011-10-24 19:15:32 +00002/*
3 * Copyright (c) 2011 The Chromium OS Authors.
Simon Glass2d2af852011-10-24 19:15:32 +00004 */
5
Simon Glass0a9d66f2012-07-12 05:25:02 +00006#ifndef __fdtdec_h
7#define __fdtdec_h
Simon Glass2d2af852011-10-24 19:15:32 +00008
9/*
10 * This file contains convenience functions for decoding useful and
11 * enlightening information from FDTs. It is intended to be used by device
12 * drivers and board-specific code within U-Boot. It aims to reduce the
13 * amount of FDT munging required within U-Boot itself, so that driver code
14 * changes to support FDT are minimized.
15 */
16
Masahiro Yamada75f82d02018-03-05 01:20:11 +090017#include <linux/libfdt.h>
Bin Meng779847e2014-12-31 16:05:11 +080018#include <pci.h>
Simon Glass2d2af852011-10-24 19:15:32 +000019
20/*
21 * A typedef for a physical address. Note that fdt data is always big
22 * endian even on a litle endian machine.
23 */
York Sun56893722015-08-03 12:02:04 -070024typedef phys_addr_t fdt_addr_t;
25typedef phys_size_t fdt_size_t;
Thierry Reding3d4ffa02019-03-21 19:10:00 +010026
Simon Glass2d2af852011-10-24 19:15:32 +000027#ifdef CONFIG_PHYS_64BIT
Mario Six61efece2018-02-12 08:05:57 +010028#define FDT_ADDR_T_NONE (-1U)
Simon Glass2d2af852011-10-24 19:15:32 +000029#define fdt_addr_to_cpu(reg) be64_to_cpu(reg)
Simon Glassf909b9c2012-10-25 16:31:00 +000030#define fdt_size_to_cpu(reg) be64_to_cpu(reg)
Thierry Reding570a7932019-03-21 19:09:59 +010031#define cpu_to_fdt_addr(reg) cpu_to_be64(reg)
32#define cpu_to_fdt_size(reg) cpu_to_be64(reg)
Simon Glass1b1fe412017-08-29 14:15:50 -060033typedef fdt64_t fdt_val_t;
Simon Glass2d2af852011-10-24 19:15:32 +000034#else
Simon Glass2d2af852011-10-24 19:15:32 +000035#define FDT_ADDR_T_NONE (-1U)
36#define fdt_addr_to_cpu(reg) be32_to_cpu(reg)
Simon Glassf909b9c2012-10-25 16:31:00 +000037#define fdt_size_to_cpu(reg) be32_to_cpu(reg)
Thierry Reding570a7932019-03-21 19:09:59 +010038#define cpu_to_fdt_addr(reg) cpu_to_be32(reg)
39#define cpu_to_fdt_size(reg) cpu_to_be32(reg)
Simon Glass1b1fe412017-08-29 14:15:50 -060040typedef fdt32_t fdt_val_t;
Simon Glass2d2af852011-10-24 19:15:32 +000041#endif
42
43/* Information obtained about memory from the FDT */
44struct fdt_memory {
45 fdt_addr_t start;
46 fdt_addr_t end;
47};
48
Michael Prattfa28d142018-06-11 13:07:09 -060049struct bd_info;
50
Simon Glass8579a512015-03-06 13:19:03 -070051#ifdef CONFIG_SPL_BUILD
52#define SPL_BUILD 1
53#else
54#define SPL_BUILD 0
55#endif
56
Lukas Auer3f47b632019-08-21 21:14:40 +020057#ifdef CONFIG_OF_PRIOR_STAGE
Thomas Fitzsimmons919646d2018-06-08 17:59:45 -040058extern phys_addr_t prior_stage_fdt_address;
59#endif
60
Thierry Redinga937b802014-08-26 17:33:53 +020061/*
62 * Information about a resource. start is the first address of the resource
63 * and end is the last address (inclusive). The length of the resource will
64 * be equal to: end - start + 1.
65 */
66struct fdt_resource {
67 fdt_addr_t start;
68 fdt_addr_t end;
69};
70
Bin Meng779847e2014-12-31 16:05:11 +080071enum fdt_pci_space {
72 FDT_PCI_SPACE_CONFIG = 0,
73 FDT_PCI_SPACE_IO = 0x01000000,
74 FDT_PCI_SPACE_MEM32 = 0x02000000,
75 FDT_PCI_SPACE_MEM64 = 0x03000000,
76 FDT_PCI_SPACE_MEM32_PREF = 0x42000000,
77 FDT_PCI_SPACE_MEM64_PREF = 0x43000000,
78};
79
80#define FDT_PCI_ADDR_CELLS 3
81#define FDT_PCI_SIZE_CELLS 2
82#define FDT_PCI_REG_SIZE \
83 ((FDT_PCI_ADDR_CELLS + FDT_PCI_SIZE_CELLS) * sizeof(u32))
84
85/*
86 * The Open Firmware spec defines PCI physical address as follows:
87 *
88 * bits# 31 .... 24 23 .... 16 15 .... 08 07 .... 00
89 *
90 * phys.hi cell: npt000ss bbbbbbbb dddddfff rrrrrrrr
91 * phys.mid cell: hhhhhhhh hhhhhhhh hhhhhhhh hhhhhhhh
92 * phys.lo cell: llllllll llllllll llllllll llllllll
93 *
94 * where:
95 *
96 * n: is 0 if the address is relocatable, 1 otherwise
97 * p: is 1 if addressable region is prefetchable, 0 otherwise
98 * t: is 1 if the address is aliased (for non-relocatable I/O) below 1MB
99 * (for Memory), or below 64KB (for relocatable I/O)
100 * ss: is the space code, denoting the address space
101 * bbbbbbbb: is the 8-bit Bus Number
102 * ddddd: is the 5-bit Device Number
103 * fff: is the 3-bit Function Number
104 * rrrrrrrr: is the 8-bit Register Number
105 * hhhhhhhh: is a 32-bit unsigned number
106 * llllllll: is a 32-bit unsigned number
107 */
108struct fdt_pci_addr {
109 u32 phys_hi;
110 u32 phys_mid;
111 u32 phys_lo;
112};
113
Simon Glasse16f4c42019-12-28 10:44:42 -0700114extern u8 __dtb_dt_begin[]; /* embedded device tree blob */
115extern u8 __dtb_dt_spl_begin[]; /* embedded device tree blob for SPL/TPL */
116
Thierry Redinga937b802014-08-26 17:33:53 +0200117/**
118 * Compute the size of a resource.
119 *
120 * @param res the resource to operate on
121 * @return the size of the resource
122 */
123static inline fdt_size_t fdt_resource_size(const struct fdt_resource *res)
124{
125 return res->end - res->start + 1;
126}
127
Simon Glass2d2af852011-10-24 19:15:32 +0000128/**
129 * Compat types that we know about and for which we might have drivers.
130 * Each is named COMPAT_<dir>_<filename> where <dir> is the directory
131 * within drivers.
132 */
133enum fdt_compat_id {
134 COMPAT_UNKNOWN,
Allen Martin55d98a12012-08-31 08:30:00 +0000135 COMPAT_NVIDIA_TEGRA20_EMC, /* Tegra20 memory controller */
136 COMPAT_NVIDIA_TEGRA20_EMC_TABLE, /* Tegra20 memory timing table */
Jim Lin5d309e62012-07-29 20:53:29 +0000137 COMPAT_NVIDIA_TEGRA20_NAND, /* Tegra2 NAND controller */
Thierry Redingf202e022014-12-09 22:25:09 -0700138 COMPAT_NVIDIA_TEGRA124_XUSB_PADCTL,
139 /* Tegra124 XUSB pad controller */
Tom Warrenab0cc6b2015-03-04 16:36:00 -0700140 COMPAT_NVIDIA_TEGRA210_XUSB_PADCTL,
141 /* Tegra210 XUSB pad controller */
Hatim RVbe5ad5a2012-12-11 00:52:46 +0000142 COMPAT_SMSC_LAN9215, /* SMSC 10/100 Ethernet LAN9215 */
143 COMPAT_SAMSUNG_EXYNOS5_SROMC, /* Exynos5 SROMC */
Rajeshwari Shinded6e9f442013-01-07 23:35:05 +0000144 COMPAT_SAMSUNG_EXYNOS_USB_PHY, /* Exynos phy controller for usb2.0 */
Vivek Gautamf8745232013-09-14 14:02:48 +0530145 COMPAT_SAMSUNG_EXYNOS5_USB3_PHY,/* Exynos phy controller for usb3.0 */
Akshay Saraswataa773182013-02-25 01:13:01 +0000146 COMPAT_SAMSUNG_EXYNOS_TMU, /* Exynos TMU */
Piotr Wilczek24e368a2014-03-07 14:59:39 +0100147 COMPAT_SAMSUNG_EXYNOS_MIPI_DSI, /* Exynos mipi dsi */
Jaehoon Chunge3fb6fa2014-05-16 13:59:51 +0900148 COMPAT_SAMSUNG_EXYNOS_DWMMC, /* Exynos DWMMC controller */
Simon Glass609560942013-03-11 06:08:08 +0000149 COMPAT_GENERIC_SPI_FLASH, /* Generic SPI Flash chip */
Ajay Kumare24c5022014-09-05 16:53:33 +0530150 COMPAT_SAMSUNG_EXYNOS_SYSMMU, /* Exynos sysmmu */
Simon Glassf79d5382014-11-12 22:42:21 -0700151 COMPAT_INTEL_MICROCODE, /* Intel microcode update */
Bin Meng2bfd2642015-02-05 23:42:26 +0800152 COMPAT_INTEL_QRK_MRC, /* Intel Quark MRC */
Marek Vasutf3f8fe22015-07-25 19:33:56 +0200153 COMPAT_ALTERA_SOCFPGA_DWMAC, /* SoCFPGA Ethernet controller */
Marek Vasut17497232015-07-25 10:48:14 +0200154 COMPAT_ALTERA_SOCFPGA_DWMMC, /* SoCFPGA DWMMC controller */
Marek Vasutf26c1ae2015-12-05 19:28:44 +0100155 COMPAT_ALTERA_SOCFPGA_DWC2USB, /* SoCFPGA DWC2 USB controller */
Andrew Bradford74fdb582015-08-07 08:36:35 -0400156 COMPAT_INTEL_BAYTRAIL_FSP, /* Intel Bay Trail FSP */
157 COMPAT_INTEL_BAYTRAIL_FSP_MDP, /* Intel FSP memory-down params */
Bin Meng5ce2d8b2015-12-11 02:55:44 -0800158 COMPAT_INTEL_IVYBRIDGE_FSP, /* Intel Ivy Bridge FSP */
Boris Brezillon57f20382016-06-15 21:09:23 +0200159 COMPAT_SUNXI_NAND, /* SUNXI NAND controller */
Ley Foon Tanb25ae722017-04-05 17:32:47 +0800160 COMPAT_ALTERA_SOCFPGA_CLK, /* SoCFPGA Clock initialization */
161 COMPAT_ALTERA_SOCFPGA_PINCTRL_SINGLE, /* SoCFPGA pinctrl-single */
162 COMPAT_ALTERA_SOCFPGA_H2F_BRG, /* SoCFPGA hps2fpga bridge */
163 COMPAT_ALTERA_SOCFPGA_LWH2F_BRG, /* SoCFPGA lwhps2fpga bridge */
164 COMPAT_ALTERA_SOCFPGA_F2H_BRG, /* SoCFPGA fpga2hps bridge */
165 COMPAT_ALTERA_SOCFPGA_F2SDR0, /* SoCFPGA fpga2SDRAM0 bridge */
166 COMPAT_ALTERA_SOCFPGA_F2SDR1, /* SoCFPGA fpga2SDRAM1 bridge */
167 COMPAT_ALTERA_SOCFPGA_F2SDR2, /* SoCFPGA fpga2SDRAM2 bridge */
Tien Fong Cheebbfa5eb2017-09-25 16:40:03 +0800168 COMPAT_ALTERA_SOCFPGA_FPGA0, /* SOCFPGA FPGA manager */
169 COMPAT_ALTERA_SOCFPGA_NOC, /* SOCFPGA Arria 10 NOC */
Marek Vasutee4e36b2018-05-12 11:56:10 +0200170 COMPAT_ALTERA_SOCFPGA_CLK_INIT, /* SOCFPGA Arria 10 clk init */
Simon Glass2d2af852011-10-24 19:15:32 +0000171
172 COMPAT_COUNT,
173};
174
Simon Glassb491e9c2015-01-05 20:05:26 -0700175#define MAX_PHANDLE_ARGS 16
176struct fdtdec_phandle_args {
177 int node;
178 int args_count;
179 uint32_t args[MAX_PHANDLE_ARGS];
180};
181
182/**
183 * fdtdec_parse_phandle_with_args() - Find a node pointed by phandle in a list
184 *
185 * This function is useful to parse lists of phandles and their arguments.
186 *
187 * Example:
188 *
189 * phandle1: node1 {
190 * #list-cells = <2>;
191 * }
192 *
193 * phandle2: node2 {
194 * #list-cells = <1>;
195 * }
196 *
197 * node3 {
198 * list = <&phandle1 1 2 &phandle2 3>;
199 * }
200 *
201 * To get a device_node of the `node2' node you may call this:
202 * fdtdec_parse_phandle_with_args(blob, node3, "list", "#list-cells", 0, 1,
203 * &args);
204 *
205 * (This function is a modified version of __of_parse_phandle_with_args() from
206 * Linux 3.18)
207 *
208 * @blob: Pointer to device tree
209 * @src_node: Offset of device tree node containing a list
210 * @list_name: property name that contains a list
211 * @cells_name: property name that specifies the phandles' arguments count,
212 * or NULL to use @cells_count
213 * @cells_count: Cell count to use if @cells_name is NULL
214 * @index: index of a phandle to parse out
215 * @out_args: optional pointer to output arguments structure (will be filled)
216 * @return 0 on success (with @out_args filled out if not NULL), -ENOENT if
217 * @list_name does not exist, a phandle was not found, @cells_name
218 * could not be found, the arguments were truncated or there were too
219 * many arguments.
220 *
221 */
222int fdtdec_parse_phandle_with_args(const void *blob, int src_node,
223 const char *list_name,
224 const char *cells_name,
225 int cell_count, int index,
226 struct fdtdec_phandle_args *out_args);
227
Sean Pauladbcfc92012-10-25 16:31:06 +0000228/**
Simon Glass2d2af852011-10-24 19:15:32 +0000229 * Find the next numbered alias for a peripheral. This is used to enumerate
230 * all the peripherals of a certain type.
231 *
232 * Do the first call with *upto = 0. Assuming /aliases/<name>0 exists then
233 * this function will return a pointer to the node the alias points to, and
234 * then update *upto to 1. Next time you call this function, the next node
235 * will be returned.
236 *
237 * All nodes returned will match the compatible ID, as it is assumed that
238 * all peripherals use the same driver.
239 *
240 * @param blob FDT blob to use
241 * @param name Root name of alias to search for
242 * @param id Compatible ID to look for
243 * @return offset of next compatible node, or -FDT_ERR_NOTFOUND if no more
244 */
245int fdtdec_next_alias(const void *blob, const char *name,
246 enum fdt_compat_id id, int *upto);
247
248/**
Gerald Van Barencdac3392012-11-12 23:13:54 -0500249 * Find the compatible ID for a given node.
250 *
251 * Generally each node has at least one compatible string attached to it.
252 * This function looks through our list of known compatible strings and
253 * returns the corresponding ID which matches the compatible string.
254 *
255 * @param blob FDT blob to use
256 * @param node Node containing compatible string to find
257 * @return compatible ID, or COMPAT_UNKNOWN if we cannot find a match
258 */
259enum fdt_compat_id fdtdec_lookup(const void *blob, int node);
260
261/**
Simon Glass65444982012-02-27 10:52:34 +0000262 * Find the next compatible node for a peripheral.
263 *
264 * Do the first call with node = 0. This function will return a pointer to
265 * the next compatible node. Next time you call this function, pass the
266 * value returned, and the next node will be provided.
267 *
268 * @param blob FDT blob to use
269 * @param node Start node for search
270 * @param id Compatible ID to look for (enum fdt_compat_id)
271 * @return offset of next compatible node, or -FDT_ERR_NOTFOUND if no more
272 */
273int fdtdec_next_compatible(const void *blob, int node,
274 enum fdt_compat_id id);
275
276/**
Simon Glass2e979b12012-04-02 13:18:42 +0000277 * Find the next compatible subnode for a peripheral.
278 *
279 * Do the first call with node set to the parent and depth = 0. This
280 * function will return the offset of the next compatible node. Next time
281 * you call this function, pass the node value returned last time, with
282 * depth unchanged, and the next node will be provided.
283 *
284 * @param blob FDT blob to use
285 * @param node Start node for search
286 * @param id Compatible ID to look for (enum fdt_compat_id)
287 * @param depthp Current depth (set to 0 before first call)
288 * @return offset of next compatible node, or -FDT_ERR_NOTFOUND if no more
289 */
290int fdtdec_next_compatible_subnode(const void *blob, int node,
291 enum fdt_compat_id id, int *depthp);
292
Stephen Warren6dfe6182015-08-06 15:31:02 -0600293/*
294 * Look up an address property in a node and return the parsed address, and
295 * optionally the parsed size.
296 *
297 * This variant assumes a known and fixed number of cells are used to
298 * represent the address and size.
299 *
300 * You probably don't want to use this function directly except to parse
301 * non-standard properties, and never to parse the "reg" property. Instead,
302 * use one of the "auto" variants below, which automatically honor the
303 * #address-cells and #size-cells properties in the parent node.
304 *
305 * @param blob FDT blob
306 * @param node node to examine
307 * @param prop_name name of property to find
308 * @param index which address to retrieve from a list of addresses. Often 0.
309 * @param na the number of cells used to represent an address
310 * @param ns the number of cells used to represent a size
311 * @param sizep a pointer to store the size into. Use NULL if not required
Stephen Warren7d30e102016-08-05 09:47:51 -0600312 * @param translate Indicates whether to translate the returned value
313 * using the parent node's ranges property.
Stephen Warren6dfe6182015-08-06 15:31:02 -0600314 * @return address, if found, or FDT_ADDR_T_NONE if not
315 */
316fdt_addr_t fdtdec_get_addr_size_fixed(const void *blob, int node,
317 const char *prop_name, int index, int na, int ns,
Stephen Warren7d30e102016-08-05 09:47:51 -0600318 fdt_size_t *sizep, bool translate);
Stephen Warren6dfe6182015-08-06 15:31:02 -0600319
320/*
321 * Look up an address property in a node and return the parsed address, and
322 * optionally the parsed size.
323 *
324 * This variant automatically determines the number of cells used to represent
325 * the address and size by parsing the provided parent node's #address-cells
326 * and #size-cells properties.
327 *
328 * @param blob FDT blob
329 * @param parent parent node of @node
330 * @param node node to examine
331 * @param prop_name name of property to find
332 * @param index which address to retrieve from a list of addresses. Often 0.
333 * @param sizep a pointer to store the size into. Use NULL if not required
Stephen Warren7d30e102016-08-05 09:47:51 -0600334 * @param translate Indicates whether to translate the returned value
335 * using the parent node's ranges property.
Stephen Warren6dfe6182015-08-06 15:31:02 -0600336 * @return address, if found, or FDT_ADDR_T_NONE if not
337 */
338fdt_addr_t fdtdec_get_addr_size_auto_parent(const void *blob, int parent,
Stephen Warren7d30e102016-08-05 09:47:51 -0600339 int node, const char *prop_name, int index, fdt_size_t *sizep,
340 bool translate);
Stephen Warren6dfe6182015-08-06 15:31:02 -0600341
342/*
343 * Look up an address property in a node and return the parsed address, and
344 * optionally the parsed size.
345 *
346 * This variant automatically determines the number of cells used to represent
347 * the address and size by parsing the parent node's #address-cells
348 * and #size-cells properties. The parent node is automatically found.
349 *
350 * The automatic parent lookup implemented by this function is slow.
351 * Consequently, fdtdec_get_addr_size_auto_parent() should be used where
352 * possible.
Simon Glass2d2af852011-10-24 19:15:32 +0000353 *
354 * @param blob FDT blob
Stephen Warren6dfe6182015-08-06 15:31:02 -0600355 * @param parent parent node of @node
Simon Glass2d2af852011-10-24 19:15:32 +0000356 * @param node node to examine
357 * @param prop_name name of property to find
Stephen Warren6dfe6182015-08-06 15:31:02 -0600358 * @param index which address to retrieve from a list of addresses. Often 0.
359 * @param sizep a pointer to store the size into. Use NULL if not required
Stephen Warren7d30e102016-08-05 09:47:51 -0600360 * @param translate Indicates whether to translate the returned value
361 * using the parent node's ranges property.
Simon Glass2d2af852011-10-24 19:15:32 +0000362 * @return address, if found, or FDT_ADDR_T_NONE if not
363 */
Stephen Warren6dfe6182015-08-06 15:31:02 -0600364fdt_addr_t fdtdec_get_addr_size_auto_noparent(const void *blob, int node,
Stephen Warren7d30e102016-08-05 09:47:51 -0600365 const char *prop_name, int index, fdt_size_t *sizep,
366 bool translate);
Stephen Warren6dfe6182015-08-06 15:31:02 -0600367
368/*
369 * Look up an address property in a node and return the parsed address.
370 *
371 * This variant hard-codes the number of cells used to represent the address
372 * and size based on sizeof(fdt_addr_t) and sizeof(fdt_size_t). It also
373 * always returns the first address value in the property (index 0).
374 *
375 * Use of this function is not recommended due to the hard-coding of cell
376 * counts. There is no programmatic validation that these hard-coded values
377 * actually match the device tree content in any way at all. This assumption
378 * can be satisfied by manually ensuring CONFIG_PHYS_64BIT is appropriately
379 * set in the U-Boot build and exercising strict control over DT content to
380 * ensure use of matching #address-cells/#size-cells properties. However, this
381 * approach is error-prone; those familiar with DT will not expect the
382 * assumption to exist, and could easily invalidate it. If the assumption is
383 * invalidated, this function will not report the issue, and debugging will
384 * be required. Instead, use fdtdec_get_addr_size_auto_parent().
385 *
386 * @param blob FDT blob
387 * @param node node to examine
388 * @param prop_name name of property to find
389 * @return address, if found, or FDT_ADDR_T_NONE if not
390 */
Simon Glass2d2af852011-10-24 19:15:32 +0000391fdt_addr_t fdtdec_get_addr(const void *blob, int node,
392 const char *prop_name);
393
Stephen Warren6dfe6182015-08-06 15:31:02 -0600394/*
395 * Look up an address property in a node and return the parsed address, and
396 * optionally the parsed size.
397 *
398 * This variant hard-codes the number of cells used to represent the address
399 * and size based on sizeof(fdt_addr_t) and sizeof(fdt_size_t). It also
400 * always returns the first address value in the property (index 0).
401 *
402 * Use of this function is not recommended due to the hard-coding of cell
403 * counts. There is no programmatic validation that these hard-coded values
404 * actually match the device tree content in any way at all. This assumption
405 * can be satisfied by manually ensuring CONFIG_PHYS_64BIT is appropriately
406 * set in the U-Boot build and exercising strict control over DT content to
407 * ensure use of matching #address-cells/#size-cells properties. However, this
408 * approach is error-prone; those familiar with DT will not expect the
409 * assumption to exist, and could easily invalidate it. If the assumption is
410 * invalidated, this function will not report the issue, and debugging will
411 * be required. Instead, use fdtdec_get_addr_size_auto_parent().
Simon Glassf4299552013-03-19 04:58:51 +0000412 *
413 * @param blob FDT blob
414 * @param node node to examine
415 * @param prop_name name of property to find
Stephen Warren6dfe6182015-08-06 15:31:02 -0600416 * @param sizep a pointer to store the size into. Use NULL if not required
Simon Glassf4299552013-03-19 04:58:51 +0000417 * @return address, if found, or FDT_ADDR_T_NONE if not
418 */
419fdt_addr_t fdtdec_get_addr_size(const void *blob, int node,
420 const char *prop_name, fdt_size_t *sizep);
421
422/**
Bin Meng779847e2014-12-31 16:05:11 +0800423 * Look at the compatible property of a device node that represents a PCI
424 * device and extract pci vendor id and device id from it.
425 *
426 * @param blob FDT blob
427 * @param node node to examine
428 * @param vendor vendor id of the pci device
429 * @param device device id of the pci device
430 * @return 0 if ok, negative on error
431 */
432int fdtdec_get_pci_vendev(const void *blob, int node,
433 u16 *vendor, u16 *device);
434
435/**
436 * Look at the pci address of a device node that represents a PCI device
Bin Meng779847e2014-12-31 16:05:11 +0800437 * and return base address of the pci device's registers.
438 *
Simon Glassf1037ad2015-11-29 13:17:54 -0700439 * @param dev device to examine
Bin Meng779847e2014-12-31 16:05:11 +0800440 * @param addr pci address in the form of fdt_pci_addr
441 * @param bar returns base address of the pci device's registers
442 * @return 0 if ok, negative on error
443 */
Simon Glassc92aac12020-01-27 08:49:38 -0700444int fdtdec_get_pci_bar32(const struct udevice *dev, struct fdt_pci_addr *addr,
Simon Glassf1037ad2015-11-29 13:17:54 -0700445 u32 *bar);
Bin Meng779847e2014-12-31 16:05:11 +0800446
447/**
Suneel Garapati78d0bea2019-10-19 15:19:35 -0700448 * Look at the bus range property of a device node and return the pci bus
449 * range for this node.
450 * The property must hold one fdt_pci_addr with a length.
451 * @param blob FDT blob
452 * @param node node to examine
453 * @param res the resource structure to return the bus range
454 * @return 0 if ok, negative on error
455 */
456
457int fdtdec_get_pci_bus_range(const void *blob, int node,
458 struct fdt_resource *res);
459
460/**
Simon Glass2d2af852011-10-24 19:15:32 +0000461 * Look up a 32-bit integer property in a node and return it. The property
462 * must have at least 4 bytes of data. The value of the first cell is
463 * returned.
464 *
465 * @param blob FDT blob
466 * @param node node to examine
467 * @param prop_name name of property to find
468 * @param default_val default value to return if the property is not found
469 * @return integer value, if found, or default_val if not
470 */
471s32 fdtdec_get_int(const void *blob, int node, const char *prop_name,
472 s32 default_val);
473
474/**
Chin Liang Seec97b0742015-10-17 08:30:32 -0500475 * Unsigned version of fdtdec_get_int. The property must have at least
476 * 4 bytes of data. The value of the first cell is returned.
477 *
478 * @param blob FDT blob
479 * @param node node to examine
480 * @param prop_name name of property to find
481 * @param default_val default value to return if the property is not found
482 * @return unsigned integer value, if found, or default_val if not
483 */
484unsigned int fdtdec_get_uint(const void *blob, int node, const char *prop_name,
485 unsigned int default_val);
486
487/**
Simon Glass9ffbe332015-03-05 12:25:14 -0700488 * Get a variable-sized number from a property
489 *
490 * This reads a number from one or more cells.
491 *
492 * @param ptr Pointer to property
493 * @param cells Number of cells containing the number
494 * @return the value in the cells
495 */
496u64 fdtdec_get_number(const fdt32_t *ptr, unsigned int cells);
497
498/**
Che-Liang Chioud81d0172012-10-25 16:31:05 +0000499 * Look up a 64-bit integer property in a node and return it. The property
500 * must have at least 8 bytes of data (2 cells). The first two cells are
501 * concatenated to form a 8 bytes value, where the first cell is top half and
502 * the second cell is bottom half.
503 *
504 * @param blob FDT blob
505 * @param node node to examine
506 * @param prop_name name of property to find
507 * @param default_val default value to return if the property is not found
508 * @return integer value, if found, or default_val if not
509 */
510uint64_t fdtdec_get_uint64(const void *blob, int node, const char *prop_name,
511 uint64_t default_val);
512
513/**
Simon Glass2d2af852011-10-24 19:15:32 +0000514 * Checks whether a node is enabled.
515 * This looks for a 'status' property. If this exists, then returns 1 if
516 * the status is 'ok' and 0 otherwise. If there is no status property,
Simon Glass65444982012-02-27 10:52:34 +0000517 * it returns 1 on the assumption that anything mentioned should be enabled
518 * by default.
Simon Glass2d2af852011-10-24 19:15:32 +0000519 *
520 * @param blob FDT blob
521 * @param node node to examine
Simon Glass65444982012-02-27 10:52:34 +0000522 * @return integer value 0 (not enabled) or 1 (enabled)
Simon Glass2d2af852011-10-24 19:15:32 +0000523 */
Simon Glass65444982012-02-27 10:52:34 +0000524int fdtdec_get_is_enabled(const void *blob, int node);
Simon Glass2d2af852011-10-24 19:15:32 +0000525
526/**
Simon Glass1691f692012-03-28 10:08:24 +0000527 * Make sure we have a valid fdt available to control U-Boot.
528 *
529 * If not, a message is printed to the console if the console is ready.
530 *
531 * @return 0 if all ok, -1 if not
532 */
533int fdtdec_prepare_fdt(void);
534
535/**
536 * Checks that we have a valid fdt available to control U-Boot.
537
538 * However, if not then for the moment nothing is done, since this function
539 * is called too early to panic().
540 *
541 * @returns 0
Simon Glass2d2af852011-10-24 19:15:32 +0000542 */
543int fdtdec_check_fdt(void);
Simon Glassb022ead2012-01-17 08:20:50 +0000544
545/**
546 * Find the nodes for a peripheral and return a list of them in the correct
547 * order. This is used to enumerate all the peripherals of a certain type.
548 *
549 * To use this, optionally set up a /aliases node with alias properties for
550 * a peripheral. For example, for usb you could have:
551 *
552 * aliases {
553 * usb0 = "/ehci@c5008000";
554 * usb1 = "/ehci@c5000000";
555 * };
556 *
557 * Pass "usb" as the name to this function and will return a list of two
558 * nodes offsets: /ehci@c5008000 and ehci@c5000000.
559 *
560 * All nodes returned will match the compatible ID, as it is assumed that
561 * all peripherals use the same driver.
562 *
563 * If no alias node is found, then the node list will be returned in the
564 * order found in the fdt. If the aliases mention a node which doesn't
565 * exist, then this will be ignored. If nodes are found with no aliases,
566 * they will be added in any order.
567 *
568 * If there is a gap in the aliases, then this function return a 0 node at
569 * that position. The return value will also count these gaps.
570 *
571 * This function checks node properties and will not return nodes which are
572 * marked disabled (status = "disabled").
573 *
574 * @param blob FDT blob to use
575 * @param name Root name of alias to search for
576 * @param id Compatible ID to look for
577 * @param node_list Place to put list of found nodes
578 * @param maxcount Maximum number of nodes to find
Robert P. J. Day8c60f922016-05-04 04:47:31 -0400579 * @return number of nodes found on success, FDT_ERR_... on error
Simon Glassb022ead2012-01-17 08:20:50 +0000580 */
581int fdtdec_find_aliases_for_id(const void *blob, const char *name,
582 enum fdt_compat_id id, int *node_list, int maxcount);
583
584/*
Simon Glass1f772662012-02-03 15:13:53 +0000585 * This function is similar to fdtdec_find_aliases_for_id() except that it
586 * adds to the node_list that is passed in. Any 0 elements are considered
587 * available for allocation - others are considered already used and are
588 * skipped.
589 *
590 * You can use this by calling fdtdec_find_aliases_for_id() with an
591 * uninitialised array, then setting the elements that are returned to -1,
592 * say, then calling this function, perhaps with a different compat id.
593 * Any elements you get back that are >0 are new nodes added by the call
594 * to this function.
595 *
596 * Note that if you have some nodes with aliases and some without, you are
597 * sailing close to the wind. The call to fdtdec_find_aliases_for_id() with
598 * one compat_id may fill in positions for which you have aliases defined
599 * for another compat_id. When you later call *this* function with the second
600 * compat_id, the alias positions may already be used. A debug warning may
601 * be generated in this case, but it is safest to define aliases for all
602 * nodes when you care about the ordering.
603 */
604int fdtdec_add_aliases_for_id(const void *blob, const char *name,
605 enum fdt_compat_id id, int *node_list, int maxcount);
606
Simon Glass9908ad42014-07-23 06:55:09 -0600607/**
608 * Get the alias sequence number of a node
609 *
610 * This works out whether a node is pointed to by an alias, and if so, the
611 * sequence number of that alias. Aliases are of the form <base><num> where
612 * <num> is the sequence number. For example spi2 would be sequence number
613 * 2.
614 *
615 * @param blob Device tree blob (if NULL, then error is returned)
616 * @param base Base name for alias (before the underscore)
617 * @param node Node to look up
618 * @param seqp This is set to the sequence number if one is found,
619 * but otherwise the value is left alone
620 * @return 0 if a sequence was found, -ve if not
621 */
622int fdtdec_get_alias_seq(const void *blob, const char *base, int node,
623 int *seqp);
624
Simon Glassc95f6782014-07-23 06:55:16 -0600625/**
Michal Simek4b586672019-01-31 16:30:58 +0100626 * Get the highest alias number for susbystem.
627 *
628 * It parses all aliases and find out highest recorded alias for subsystem.
629 * Aliases are of the form <base><num> where <num> is the sequence number.
630 *
631 * @param blob Device tree blob (if NULL, then error is returned)
632 * @param base Base name for alias susbystem (before the number)
633 *
634 * @return 0 highest alias ID, -1 if not found
635 */
636int fdtdec_get_alias_highest_id(const void *blob, const char *base);
637
638/**
Simon Glass088dccb2015-10-17 19:41:14 -0600639 * Get a property from the /chosen node
640 *
641 * @param blob Device tree blob (if NULL, then NULL is returned)
642 * @param name Property name to look up
643 * @return Value of property, or NULL if it does not exist
644 */
645const char *fdtdec_get_chosen_prop(const void *blob, const char *name);
646
647/**
648 * Get the offset of the given /chosen node
Simon Glass1e374fb2014-09-04 16:27:24 -0600649 *
650 * This looks up a property in /chosen containing the path to another node,
651 * then finds the offset of that node.
652 *
653 * @param blob Device tree blob (if NULL, then error is returned)
654 * @param name Property name, e.g. "stdout-path"
655 * @return Node offset referred to by that chosen node, or -ve FDT_ERR_...
656 */
657int fdtdec_get_chosen_node(const void *blob, const char *name);
658
Simon Glass1f772662012-02-03 15:13:53 +0000659/*
Simon Glassb022ead2012-01-17 08:20:50 +0000660 * Get the name for a compatible ID
661 *
662 * @param id Compatible ID to look for
663 * @return compatible string for that id
664 */
665const char *fdtdec_get_compatible(enum fdt_compat_id id);
Simon Glassc4697362012-02-27 10:52:35 +0000666
667/* Look up a phandle and follow it to its node. Then return the offset
668 * of that node.
669 *
670 * @param blob FDT blob
671 * @param node node to examine
672 * @param prop_name name of property to find
673 * @return node offset if found, -ve error code on error
674 */
675int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name);
676
677/**
678 * Look up a property in a node and return its contents in an integer
679 * array of given length. The property must have at least enough data for
680 * the array (4*count bytes). It may have more, but this will be ignored.
681 *
682 * @param blob FDT blob
683 * @param node node to examine
684 * @param prop_name name of property to find
685 * @param array array to fill with data
686 * @param count number of array elements
687 * @return 0 if ok, or -FDT_ERR_NOTFOUND if the property is not found,
688 * or -FDT_ERR_BADLAYOUT if not enough data
689 */
690int fdtdec_get_int_array(const void *blob, int node, const char *prop_name,
691 u32 *array, int count);
692
693/**
Simon Glasseda0c3f2014-11-10 18:00:19 -0700694 * Look up a property in a node and return its contents in an integer
695 * array of given length. The property must exist but may have less data that
696 * expected (4*count bytes). It may have more, but this will be ignored.
697 *
698 * @param blob FDT blob
699 * @param node node to examine
700 * @param prop_name name of property to find
701 * @param array array to fill with data
702 * @param count number of array elements
703 * @return number of array elements if ok, or -FDT_ERR_NOTFOUND if the
704 * property is not found
705 */
706int fdtdec_get_int_array_count(const void *blob, int node,
707 const char *prop_name, u32 *array, int count);
708
709/**
Simon Glass744ec232012-04-02 13:18:41 +0000710 * Look up a property in a node and return a pointer to its contents as a
711 * unsigned int array of given length. The property must have at least enough
712 * data for the array ('count' cells). It may have more, but this will be
713 * ignored. The data is not copied.
714 *
715 * Note that you must access elements of the array with fdt32_to_cpu(),
716 * since the elements will be big endian even on a little endian machine.
717 *
718 * @param blob FDT blob
719 * @param node node to examine
720 * @param prop_name name of property to find
721 * @param count number of array elements
722 * @return pointer to array if found, or NULL if the property is not
723 * found or there is not enough data
724 */
725const u32 *fdtdec_locate_array(const void *blob, int node,
726 const char *prop_name, int count);
727
728/**
Simon Glassc4697362012-02-27 10:52:35 +0000729 * Look up a boolean property in a node and return it.
730 *
731 * A boolean properly is true if present in the device tree and false if not
732 * present, regardless of its value.
733 *
734 * @param blob FDT blob
735 * @param node node to examine
736 * @param prop_name name of property to find
737 * @return 1 if the properly is present; 0 if it isn't present
738 */
739int fdtdec_get_bool(const void *blob, int node, const char *prop_name);
Simon Glass0d83c4d2012-02-27 10:52:36 +0000740
Peng Fan23dd3a02016-02-01 13:31:15 +0800741/*
742 * Count child nodes of one parent node.
743 *
744 * @param blob FDT blob
745 * @param node parent node
746 * @return number of child node; 0 if there is not child node
747 */
748int fdtdec_get_child_count(const void *blob, int node);
749
Simon Glass0d83c4d2012-02-27 10:52:36 +0000750/**
Abhilash Kesavan67217af2012-10-25 16:30:58 +0000751 * Look in the FDT for a config item with the given name and return its value
752 * as a 32-bit integer. The property must have at least 4 bytes of data. The
753 * value of the first cell is returned.
754 *
755 * @param blob FDT blob to use
756 * @param prop_name Node property name
757 * @param default_val default value to return if the property is not found
758 * @return integer value, if found, or default_val if not
759 */
760int fdtdec_get_config_int(const void *blob, const char *prop_name,
761 int default_val);
762
Simon Glassb0494472012-10-25 16:30:59 +0000763/**
Gabe Black3e1c1512012-10-25 16:31:04 +0000764 * Look in the FDT for a config item with the given name
765 * and return whether it exists.
766 *
767 * @param blob FDT blob
768 * @param prop_name property name to look up
769 * @return 1, if it exists, or 0 if not
770 */
771int fdtdec_get_config_bool(const void *blob, const char *prop_name);
772
773/**
Simon Glassb0494472012-10-25 16:30:59 +0000774 * Look in the FDT for a config item with the given name and return its value
775 * as a string.
776 *
777 * @param blob FDT blob
778 * @param prop_name property name to look up
779 * @returns property string, NULL on error.
780 */
781char *fdtdec_get_config_string(const void *blob, const char *prop_name);
782
Anton Stafff2305ec2012-04-17 09:01:28 +0000783/*
784 * Look up a property in a node and return its contents in a byte
785 * array of given length. The property must have at least enough data for
786 * the array (count bytes). It may have more, but this will be ignored.
787 *
788 * @param blob FDT blob
789 * @param node node to examine
790 * @param prop_name name of property to find
791 * @param array array to fill with data
792 * @param count number of array elements
793 * @return 0 if ok, or -FDT_ERR_MISSING if the property is not found,
794 * or -FDT_ERR_BADLAYOUT if not enough data
795 */
796int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name,
797 u8 *array, int count);
798
799/**
800 * Look up a property in a node and return a pointer to its contents as a
801 * byte array of given length. The property must have at least enough data
802 * for the array (count bytes). It may have more, but this will be ignored.
803 * The data is not copied.
804 *
805 * @param blob FDT blob
806 * @param node node to examine
807 * @param prop_name name of property to find
808 * @param count number of array elements
809 * @return pointer to byte array if found, or NULL if the property is not
810 * found or there is not enough data
811 */
812const u8 *fdtdec_locate_byte_array(const void *blob, int node,
813 const char *prop_name, int count);
Simon Glassf909b9c2012-10-25 16:31:00 +0000814
815/**
Thierry Redinga937b802014-08-26 17:33:53 +0200816 * Obtain an indexed resource from a device property.
817 *
818 * @param fdt FDT blob
819 * @param node node to examine
820 * @param property name of the property to parse
821 * @param index index of the resource to retrieve
822 * @param res returns the resource
823 * @return 0 if ok, negative on error
824 */
825int fdt_get_resource(const void *fdt, int node, const char *property,
826 unsigned int index, struct fdt_resource *res);
827
828/**
829 * Obtain a named resource from a device property.
830 *
831 * Look up the index of the name in a list of strings and return the resource
832 * at that index.
833 *
834 * @param fdt FDT blob
835 * @param node node to examine
836 * @param property name of the property to parse
837 * @param prop_names name of the property containing the list of names
838 * @param name the name of the entry to look up
839 * @param res returns the resource
840 */
841int fdt_get_named_resource(const void *fdt, int node, const char *property,
842 const char *prop_names, const char *name,
843 struct fdt_resource *res);
844
Simon Glassb24e8642015-04-14 21:03:21 -0600845/* Display timings from linux include/video/display_timing.h */
846enum display_flags {
847 DISPLAY_FLAGS_HSYNC_LOW = 1 << 0,
848 DISPLAY_FLAGS_HSYNC_HIGH = 1 << 1,
849 DISPLAY_FLAGS_VSYNC_LOW = 1 << 2,
850 DISPLAY_FLAGS_VSYNC_HIGH = 1 << 3,
851
852 /* data enable flag */
853 DISPLAY_FLAGS_DE_LOW = 1 << 4,
854 DISPLAY_FLAGS_DE_HIGH = 1 << 5,
855 /* drive data on pos. edge */
856 DISPLAY_FLAGS_PIXDATA_POSEDGE = 1 << 6,
857 /* drive data on neg. edge */
858 DISPLAY_FLAGS_PIXDATA_NEGEDGE = 1 << 7,
859 DISPLAY_FLAGS_INTERLACED = 1 << 8,
860 DISPLAY_FLAGS_DOUBLESCAN = 1 << 9,
861 DISPLAY_FLAGS_DOUBLECLK = 1 << 10,
862};
863
864/*
865 * A single signal can be specified via a range of minimal and maximal values
866 * with a typical value, that lies somewhere inbetween.
867 */
868struct timing_entry {
869 u32 min;
870 u32 typ;
871 u32 max;
872};
873
874/*
875 * Single "mode" entry. This describes one set of signal timings a display can
876 * have in one setting. This struct can later be converted to struct videomode
877 * (see include/video/videomode.h). As each timing_entry can be defined as a
878 * range, one struct display_timing may become multiple struct videomodes.
879 *
880 * Example: hsync active high, vsync active low
881 *
882 * Active Video
883 * Video ______________________XXXXXXXXXXXXXXXXXXXXXX_____________________
884 * |<- sync ->|<- back ->|<----- active ----->|<- front ->|<- sync..
885 * | | porch | | porch |
886 *
887 * HSync _|¯¯¯¯¯¯¯¯¯¯|___________________________________________|¯¯¯¯¯¯¯¯¯
888 *
889 * VSync ¯|__________|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|_________
890 */
891struct display_timing {
892 struct timing_entry pixelclock;
893
894 struct timing_entry hactive; /* hor. active video */
895 struct timing_entry hfront_porch; /* hor. front porch */
896 struct timing_entry hback_porch; /* hor. back porch */
897 struct timing_entry hsync_len; /* hor. sync len */
898
899 struct timing_entry vactive; /* ver. active video */
900 struct timing_entry vfront_porch; /* ver. front porch */
901 struct timing_entry vback_porch; /* ver. back porch */
902 struct timing_entry vsync_len; /* ver. sync len */
903
904 enum display_flags flags; /* display flags */
Jernej Skrabec55884e52017-04-29 14:43:36 +0200905 bool hdmi_monitor; /* is hdmi monitor? */
Simon Glassb24e8642015-04-14 21:03:21 -0600906};
907
908/**
909 * fdtdec_decode_display_timing() - decode display timings
910 *
911 * Decode display timings from the supplied 'display-timings' node.
912 * See doc/device-tree-bindings/video/display-timing.txt for binding
913 * information.
914 *
915 * @param blob FDT blob
916 * @param node 'display-timing' node containing the timing subnodes
917 * @param index Index number to read (0=first timing subnode)
918 * @param config Place to put timings
919 * @return 0 if OK, -FDT_ERR_NOTFOUND if not found
920 */
921int fdtdec_decode_display_timing(const void *blob, int node, int index,
922 struct display_timing *config);
Nathan Rossiba97b722016-12-19 00:03:34 +1000923
924/**
Siva Durga Prasad Paladugub3d55ea2018-07-16 15:56:11 +0530925 * fdtdec_setup_mem_size_base() - decode and setup gd->ram_size and
926 * gd->ram_start
Nathan Rossiba97b722016-12-19 00:03:34 +1000927 *
Siva Durga Prasad Paladugub3d55ea2018-07-16 15:56:11 +0530928 * Decode the /memory 'reg' property to determine the size and start of the
929 * first memory bank, populate the global data with the size and start of the
930 * first bank of memory.
Nathan Rossiba97b722016-12-19 00:03:34 +1000931 *
932 * This function should be called from a boards dram_init(). This helper
Siva Durga Prasad Paladugub3d55ea2018-07-16 15:56:11 +0530933 * function allows for boards to query the device tree for DRAM size and start
934 * address instead of hard coding the value in the case where the memory size
935 * and start address cannot be detected automatically.
Nathan Rossiba97b722016-12-19 00:03:34 +1000936 *
937 * @return 0 if OK, -EINVAL if the /memory node or reg property is missing or
938 * invalid
939 */
Siva Durga Prasad Paladugub3d55ea2018-07-16 15:56:11 +0530940int fdtdec_setup_mem_size_base(void);
Nathan Rossiba97b722016-12-19 00:03:34 +1000941
942/**
Michal Simek9d2cf072020-07-09 14:09:52 +0200943 * fdtdec_setup_mem_size_base_lowest() - decode and setup gd->ram_size and
944 * gd->ram_start by lowest available memory base
945 *
946 * Decode the /memory 'reg' property to determine the lowest start of the memory
947 * bank bank and populate the global data with it.
948 *
949 * This function should be called from a boards dram_init(). This helper
950 * function allows for boards to query the device tree for DRAM size and start
951 * address instead of hard coding the value in the case where the memory size
952 * and start address cannot be detected automatically.
953 *
954 * @return 0 if OK, -EINVAL if the /memory node or reg property is missing or
955 * invalid
956 */
957int fdtdec_setup_mem_size_base_lowest(void);
958
959/**
Nathan Rossiba97b722016-12-19 00:03:34 +1000960 * fdtdec_setup_memory_banksize() - decode and populate gd->bd->bi_dram
961 *
962 * Decode the /memory 'reg' property to determine the address and size of the
963 * memory banks. Use this data to populate the global data board info with the
964 * phys address and size of memory banks.
965 *
966 * This function should be called from a boards dram_init_banksize(). This
967 * helper function allows for boards to query the device tree for memory bank
968 * information instead of hard coding the information in cases where it cannot
969 * be detected automatically.
970 *
971 * @return 0 if OK, -EINVAL if the /memory node or reg property is missing or
972 * invalid
973 */
974int fdtdec_setup_memory_banksize(void);
975
Simon Glass26b78b22015-02-27 22:06:34 -0700976/**
Thierry Reding1bb59a92019-04-15 11:32:13 +0200977 * fdtdec_set_ethernet_mac_address() - set MAC address for default interface
978 *
979 * Looks up the default interface via the "ethernet" alias (in the /aliases
980 * node) and stores the given MAC in its "local-mac-address" property. This
981 * is useful on platforms that store the MAC address in a custom location.
982 * Board code can call this in the late init stage to make sure that the
983 * interface device tree node has the right MAC address configured for the
984 * Ethernet uclass to pick it up.
985 *
986 * Typically the FDT passed into this function will be U-Boot's control DTB.
987 * Given that a lot of code may be holding offsets to various nodes in that
988 * tree, this code will only set the "local-mac-address" property in-place,
989 * which means that it needs to exist and have space for the 6-byte address.
990 * This ensures that the operation is non-destructive and does not invalidate
991 * offsets that other drivers may be using.
992 *
993 * @param fdt FDT blob
994 * @param mac buffer containing the MAC address to set
995 * @param size size of MAC address
996 * @return 0 on success or a negative error code on failure
997 */
998int fdtdec_set_ethernet_mac_address(void *fdt, const u8 *mac, size_t size);
999
1000/**
Thierry Reding15956ad2019-03-21 19:10:01 +01001001 * fdtdec_set_phandle() - sets the phandle of a given node
1002 *
1003 * @param blob FDT blob
1004 * @param node offset in the FDT blob of the node whose phandle is to
1005 * be set
1006 * @param phandle phandle to set for the given node
1007 * @return 0 on success or a negative error code on failure
1008 */
Thierry Redinga3123092019-04-15 10:08:20 +02001009static inline int fdtdec_set_phandle(void *blob, int node, uint32_t phandle)
1010{
1011 return fdt_setprop_u32(blob, node, "phandle", phandle);
1012}
Thierry Reding15956ad2019-03-21 19:10:01 +01001013
1014/**
Thierry Redinge8dfad42019-03-21 19:10:02 +01001015 * fdtdec_add_reserved_memory() - add or find a reserved-memory node
1016 *
1017 * If a reserved-memory node already exists for the given carveout, a phandle
1018 * for that node will be returned. Otherwise a new node will be created and a
1019 * phandle corresponding to it will be returned.
1020 *
1021 * See Documentation/devicetree/bindings/reserved-memory/reserved-memory.txt
1022 * for details on how to use reserved memory regions.
1023 *
1024 * As an example, consider the following code snippet:
1025 *
1026 * struct fdt_memory fb = {
1027 * .start = 0x92cb3000,
1028 * .end = 0x934b2fff,
1029 * };
1030 * uint32_t phandle;
1031 *
Etienne Carriere646f8c62020-09-10 10:49:59 +02001032 * fdtdec_add_reserved_memory(fdt, "framebuffer", &fb, &phandle, false);
Thierry Redinge8dfad42019-03-21 19:10:02 +01001033 *
1034 * This results in the following subnode being added to the top-level
1035 * /reserved-memory node:
1036 *
1037 * reserved-memory {
1038 * #address-cells = <0x00000002>;
1039 * #size-cells = <0x00000002>;
1040 * ranges;
1041 *
1042 * framebuffer@92cb3000 {
1043 * reg = <0x00000000 0x92cb3000 0x00000000 0x00800000>;
1044 * phandle = <0x0000004d>;
1045 * };
1046 * };
1047 *
1048 * If the top-level /reserved-memory node does not exist, it will be created.
1049 * The phandle returned from the function call can be used to reference this
1050 * reserved memory region from other nodes.
1051 *
Thierry Redinge629b0d2019-03-21 19:10:03 +01001052 * See fdtdec_set_carveout() for a more elaborate example.
1053 *
Thierry Redinge8dfad42019-03-21 19:10:02 +01001054 * @param blob FDT blob
1055 * @param basename base name of the node to create
1056 * @param carveout information about the carveout region
1057 * @param phandlep return location for the phandle of the carveout region
Heiko Stuebner754302f2019-10-23 16:46:39 +02001058 * can be NULL if no phandle should be added
Etienne Carriere646f8c62020-09-10 10:49:59 +02001059 * @param no_map add "no-map" property if true
Thierry Redinge8dfad42019-03-21 19:10:02 +01001060 * @return 0 on success or a negative error code on failure
1061 */
1062int fdtdec_add_reserved_memory(void *blob, const char *basename,
1063 const struct fdt_memory *carveout,
Etienne Carriere646f8c62020-09-10 10:49:59 +02001064 uint32_t *phandlep, bool no_map);
Thierry Redinge8dfad42019-03-21 19:10:02 +01001065
1066/**
Thierry Redinge629b0d2019-03-21 19:10:03 +01001067 * fdtdec_get_carveout() - reads a carveout from an FDT
1068 *
1069 * Reads information about a carveout region from an FDT. The carveout is a
1070 * referenced by its phandle that is read from a given property in a given
1071 * node.
1072 *
1073 * @param blob FDT blob
1074 * @param node name of a node
1075 * @param name name of the property in the given node that contains
1076 * the phandle for the carveout
1077 * @param index index of the phandle for which to read the carveout
1078 * @param carveout return location for the carveout information
1079 * @return 0 on success or a negative error code on failure
1080 */
1081int fdtdec_get_carveout(const void *blob, const char *node, const char *name,
1082 unsigned int index, struct fdt_memory *carveout);
1083
1084/**
1085 * fdtdec_set_carveout() - sets a carveout region for a given node
1086 *
1087 * Sets a carveout region for a given node. If a reserved-memory node already
1088 * exists for the carveout, the phandle for that node will be reused. If no
1089 * such node exists, a new one will be created and a phandle to it stored in
1090 * a specified property of the given node.
1091 *
1092 * As an example, consider the following code snippet:
1093 *
1094 * const char *node = "/host1x@50000000/dc@54240000";
1095 * struct fdt_memory fb = {
1096 * .start = 0x92cb3000,
1097 * .end = 0x934b2fff,
1098 * };
1099 *
1100 * fdtdec_set_carveout(fdt, node, "memory-region", 0, "framebuffer", &fb);
1101 *
1102 * dc@54200000 is a display controller and was set up by the bootloader to
1103 * scan out the framebuffer specified by "fb". This would cause the following
1104 * reserved memory region to be added:
1105 *
1106 * reserved-memory {
1107 * #address-cells = <0x00000002>;
1108 * #size-cells = <0x00000002>;
1109 * ranges;
1110 *
1111 * framebuffer@92cb3000 {
1112 * reg = <0x00000000 0x92cb3000 0x00000000 0x00800000>;
1113 * phandle = <0x0000004d>;
1114 * };
1115 * };
1116 *
1117 * A "memory-region" property will also be added to the node referenced by the
1118 * offset parameter.
1119 *
1120 * host1x@50000000 {
1121 * ...
1122 *
1123 * dc@54240000 {
1124 * ...
1125 * memory-region = <0x0000004d>;
1126 * ...
1127 * };
1128 *
1129 * ...
1130 * };
1131 *
1132 * @param blob FDT blob
1133 * @param node name of the node to add the carveout to
1134 * @param prop_name name of the property in which to store the phandle of
1135 * the carveout
1136 * @param index index of the phandle to store
1137 * @param name base name of the reserved-memory node to create
1138 * @param carveout information about the carveout to add
1139 * @return 0 on success or a negative error code on failure
1140 */
1141int fdtdec_set_carveout(void *blob, const char *node, const char *prop_name,
1142 unsigned int index, const char *name,
1143 const struct fdt_memory *carveout);
1144
1145/**
Simon Glass26b78b22015-02-27 22:06:34 -07001146 * Set up the device tree ready for use
1147 */
Simon Glassa0877672015-02-27 22:06:35 -07001148int fdtdec_setup(void);
Simon Glass26b78b22015-02-27 22:06:34 -07001149
Marek Vasutedeb6542020-04-11 21:18:59 +02001150/**
1151 * Perform board-specific early DT adjustments
1152 */
1153int fdtdec_board_setup(const void *fdt_blob);
1154
Jean-Jacques Hiblot7c530e32018-12-07 14:50:52 +01001155#if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
1156/**
1157 * fdtdec_resetup() - Set up the device tree again
1158 *
1159 * The main difference with fdtdec_setup() is that it returns if the fdt has
1160 * changed because a better match has been found.
1161 * This is typically used for boards that rely on a DM driver to detect the
1162 * board type. This function sould be called by the board code after the stuff
1163 * needed by board_fit_config_name_match() to operate porperly is available.
1164 * If this functions signals that a rescan is necessary, the board code must
1165 * unbind all the drivers using dm_uninit() and then rescan the DT with
1166 * dm_init_and_scan().
1167 *
1168 * @param rescan Returns a flag indicating that fdt has changed and rescanning
1169 * the fdt is required
1170 *
1171 * @return 0 if OK, -ve on error
1172 */
1173int fdtdec_resetup(int *rescan);
1174#endif
1175
Alex Deymo5b661ec2017-04-02 01:25:20 -07001176/**
1177 * Board-specific FDT initialization. Returns the address to a device tree blob.
Rob Clark974dcac2018-01-10 11:34:37 +01001178 * Called when CONFIG_OF_BOARD is defined, or if CONFIG_OF_SEPARATE is defined
1179 * and the board implements it.
Alex Deymo5b661ec2017-04-02 01:25:20 -07001180 */
Baruch Siach99a097d2018-10-28 14:41:14 +02001181void *board_fdt_blob_setup(void);
Michael Prattfa28d142018-06-11 13:07:09 -06001182
1183/*
1184 * Decode the size of memory
1185 *
1186 * RAM size is normally set in a /memory node and consists of a list of
1187 * (base, size) cells in the 'reg' property. This information is used to
1188 * determine the total available memory as well as the address and size
1189 * of each bank.
1190 *
1191 * Optionally the memory configuration can vary depending on a board id,
1192 * typically read from strapping resistors or an EEPROM on the board.
1193 *
1194 * Finally, memory size can be detected (within certain limits) by probing
1195 * the available memory. It is safe to do so within the limits provides by
1196 * the board's device tree information. This makes it possible to produce
1197 * boards with different memory sizes, where the device tree specifies the
1198 * maximum memory configuration, and the smaller memory configuration is
1199 * probed.
1200 *
1201 * This function decodes that information, returning the memory base address,
1202 * size and bank information. See the memory.txt binding for full
1203 * documentation.
1204 *
1205 * @param blob Device tree blob
1206 * @param area Name of node to check (NULL means "/memory")
1207 * @param board_id Board ID to look up
1208 * @param basep Returns base address of first memory bank (NULL to
1209 * ignore)
1210 * @param sizep Returns total memory size (NULL to ignore)
1211 * @param bd Updated with the memory bank information (NULL to skip)
1212 * @return 0 if OK, -ve on error
1213 */
1214int fdtdec_decode_ram_size(const void *blob, const char *area, int board_id,
1215 phys_addr_t *basep, phys_size_t *sizep,
1216 struct bd_info *bd);
Alex Deymo5b661ec2017-04-02 01:25:20 -07001217
Simon Glass0a9d66f2012-07-12 05:25:02 +00001218#endif