Blame view
include/fdtdec.h
36.1 KB
b5220bc6e fdt: add decode h... |
1 2 |
/* * Copyright (c) 2011 The Chromium OS Authors. |
1a4596601 Add GPL-2.0+ SPDX... |
3 |
* SPDX-License-Identifier: GPL-2.0+ |
b5220bc6e fdt: add decode h... |
4 |
*/ |
5bfa78db4 fdt: Add header g... |
5 6 |
#ifndef __fdtdec_h #define __fdtdec_h |
b5220bc6e fdt: add decode h... |
7 8 9 10 11 12 13 14 |
/* * This file contains convenience functions for decoding useful and * enlightening information from FDTs. It is intended to be used by device * drivers and board-specific code within U-Boot. It aims to reduce the * amount of FDT munging required within U-Boot itself, so that driver code * changes to support FDT are minimized. */ |
b08c8c487 libfdt: move head... |
15 |
#include <linux/libfdt.h> |
a62e84d7b fdt: Add several ... |
16 |
#include <pci.h> |
b5220bc6e fdt: add decode h... |
17 18 19 20 21 |
/* * A typedef for a physical address. Note that fdt data is always big * endian even on a litle endian machine. */ |
28445aa7e lib/fdtdec: Fix f... |
22 23 |
typedef phys_addr_t fdt_addr_t; typedef phys_size_t fdt_size_t; |
b5220bc6e fdt: add decode h... |
24 |
#ifdef CONFIG_PHYS_64BIT |
c6b89f318 sandbox: Add 64-b... |
25 |
#define FDT_ADDR_T_NONE (-1U) |
b5220bc6e fdt: add decode h... |
26 |
#define fdt_addr_to_cpu(reg) be64_to_cpu(reg) |
f20c46198 fdt: Add fdtdec_d... |
27 |
#define fdt_size_to_cpu(reg) be64_to_cpu(reg) |
c20ee0ed0 dtoc: Add support... |
28 |
typedef fdt64_t fdt_val_t; |
b5220bc6e fdt: add decode h... |
29 |
#else |
b5220bc6e fdt: add decode h... |
30 31 |
#define FDT_ADDR_T_NONE (-1U) #define fdt_addr_to_cpu(reg) be32_to_cpu(reg) |
f20c46198 fdt: Add fdtdec_d... |
32 |
#define fdt_size_to_cpu(reg) be32_to_cpu(reg) |
c20ee0ed0 dtoc: Add support... |
33 |
typedef fdt32_t fdt_val_t; |
b5220bc6e fdt: add decode h... |
34 35 36 37 38 39 40 |
#endif /* Information obtained about memory from the FDT */ struct fdt_memory { fdt_addr_t start; fdt_addr_t end; }; |
af2822454 sandbox: Move CON... |
41 42 43 44 45 |
#ifdef CONFIG_SPL_BUILD #define SPL_BUILD 1 #else #define SPL_BUILD 0 #endif |
56f42242f fdt: Add resource... |
46 47 48 49 50 51 52 53 54 |
/* * Information about a resource. start is the first address of the resource * and end is the last address (inclusive). The length of the resource will * be equal to: end - start + 1. */ struct fdt_resource { fdt_addr_t start; fdt_addr_t end; }; |
a62e84d7b fdt: Add several ... |
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 |
enum fdt_pci_space { FDT_PCI_SPACE_CONFIG = 0, FDT_PCI_SPACE_IO = 0x01000000, FDT_PCI_SPACE_MEM32 = 0x02000000, FDT_PCI_SPACE_MEM64 = 0x03000000, FDT_PCI_SPACE_MEM32_PREF = 0x42000000, FDT_PCI_SPACE_MEM64_PREF = 0x43000000, }; #define FDT_PCI_ADDR_CELLS 3 #define FDT_PCI_SIZE_CELLS 2 #define FDT_PCI_REG_SIZE \ ((FDT_PCI_ADDR_CELLS + FDT_PCI_SIZE_CELLS) * sizeof(u32)) /* * The Open Firmware spec defines PCI physical address as follows: * * bits# 31 .... 24 23 .... 16 15 .... 08 07 .... 00 * * phys.hi cell: npt000ss bbbbbbbb dddddfff rrrrrrrr * phys.mid cell: hhhhhhhh hhhhhhhh hhhhhhhh hhhhhhhh * phys.lo cell: llllllll llllllll llllllll llllllll * * where: * * n: is 0 if the address is relocatable, 1 otherwise * p: is 1 if addressable region is prefetchable, 0 otherwise * t: is 1 if the address is aliased (for non-relocatable I/O) below 1MB * (for Memory), or below 64KB (for relocatable I/O) * ss: is the space code, denoting the address space * bbbbbbbb: is the 8-bit Bus Number * ddddd: is the 5-bit Device Number * fff: is the 3-bit Function Number * rrrrrrrr: is the 8-bit Register Number * hhhhhhhh: is a 32-bit unsigned number * llllllll: is a 32-bit unsigned number */ struct fdt_pci_addr { u32 phys_hi; u32 phys_mid; u32 phys_lo; }; |
56f42242f fdt: Add resource... |
97 98 99 100 101 102 103 104 105 106 |
/** * Compute the size of a resource. * * @param res the resource to operate on * @return the size of the resource */ static inline fdt_size_t fdt_resource_size(const struct fdt_resource *res) { return res->end - res->start + 1; } |
b5220bc6e fdt: add decode h... |
107 108 109 110 111 112 113 |
/** * Compat types that we know about and for which we might have drivers. * Each is named COMPAT_<dir>_<filename> where <dir> is the directory * within drivers. */ enum fdt_compat_id { COMPAT_UNKNOWN, |
00a2749d7 tegra20: rename t... |
114 115 |
COMPAT_NVIDIA_TEGRA20_EMC, /* Tegra20 memory controller */ COMPAT_NVIDIA_TEGRA20_EMC_TABLE, /* Tegra20 memory timing table */ |
312693c3d tegra: nand: Add ... |
116 |
COMPAT_NVIDIA_TEGRA20_NAND, /* Tegra2 NAND controller */ |
79c7a90f6 ARM: tegra: Imple... |
117 118 |
COMPAT_NVIDIA_TEGRA124_XUSB_PADCTL, /* Tegra124 XUSB pad controller */ |
7aaa5a60c ARM: Tegra210: Ad... |
119 120 |
COMPAT_NVIDIA_TEGRA210_XUSB_PADCTL, /* Tegra210 XUSB pad controller */ |
cc9fe33a3 fdt: exynos5: Add... |
121 122 |
COMPAT_SMSC_LAN9215, /* SMSC 10/100 Ethernet LAN9215 */ COMPAT_SAMSUNG_EXYNOS5_SROMC, /* Exynos5 SROMC */ |
c34253d1f FDT: Add compatib... |
123 |
COMPAT_SAMSUNG_S3C2440_I2C, /* Exynos I2C Controller */ |
72dbff12a EXYNOS5: FDT: Add... |
124 125 |
COMPAT_SAMSUNG_EXYNOS5_SOUND, /* Exynos Sound */ COMPAT_WOLFSON_WM8994_CODEC, /* Wolfson WM8994 Sound Codec */ |
6abd1620b EXYNOS5: FDT: Add... |
126 |
COMPAT_SAMSUNG_EXYNOS_USB_PHY, /* Exynos phy controller for usb2.0 */ |
108b85be2 exynos5: dts: Add... |
127 |
COMPAT_SAMSUNG_EXYNOS5_USB3_PHY,/* Exynos phy controller for usb3.0 */ |
618766c09 Exynos5: FDT: Add... |
128 |
COMPAT_SAMSUNG_EXYNOS_TMU, /* Exynos TMU */ |
de461c526 video:mipidsim:fd... |
129 |
COMPAT_SAMSUNG_EXYNOS_MIPI_DSI, /* Exynos mipi dsi */ |
7d3ca0f89 ARM: dts: exynos:... |
130 |
COMPAT_SAMSUNG_EXYNOS_DWMMC, /* Exynos DWMMC controller */ |
3577fe8be drivers:mmc:sdhci... |
131 |
COMPAT_SAMSUNG_EXYNOS_MMC, /* Exynos MMC controller */ |
cd577e2b5 EXYNOS5: FDT: Add... |
132 |
COMPAT_MAXIM_MAX77686_PMIC, /* MAX77686 PMIC */ |
bb8215f43 sf: Enable FDT-ba... |
133 |
COMPAT_GENERIC_SPI_FLASH, /* Generic SPI Flash chip */ |
7772bb787 EXYNOS5: FDT: Add... |
134 |
COMPAT_MAXIM_98095_CODEC, /* MAX98095 Codec */ |
ecbd7e1ec fdtdec: Add compa... |
135 |
COMPAT_SAMSUNG_EXYNOS5_I2C, /* Exynos5 High Speed I2C Controller */ |
45c480c9f video: exynos_fim... |
136 |
COMPAT_SAMSUNG_EXYNOS_SYSMMU, /* Exynos sysmmu */ |
77f9b1fb6 x86: ivybridge: P... |
137 |
COMPAT_INTEL_MICROCODE, /* Intel microcode update */ |
6173c45b2 power: Add AMS AS... |
138 |
COMPAT_AMS_AS3722, /* AMS AS3722 PMIC */ |
c89ada017 fdtdec: Add compa... |
139 |
COMPAT_INTEL_QRK_MRC, /* Intel Quark MRC */ |
6ab00db22 arm: socfpga: mis... |
140 |
COMPAT_ALTERA_SOCFPGA_DWMAC, /* SoCFPGA Ethernet controller */ |
129adf5bf mmc: dw_mmc: Prob... |
141 |
COMPAT_ALTERA_SOCFPGA_DWMMC, /* SoCFPGA DWMMC controller */ |
ef4b01b2f arm: socfpga: All... |
142 |
COMPAT_ALTERA_SOCFPGA_DWC2USB, /* SoCFPGA DWC2 USB controller */ |
f3b84a303 x86: baytrail: Co... |
143 144 |
COMPAT_INTEL_BAYTRAIL_FSP, /* Intel Bay Trail FSP */ COMPAT_INTEL_BAYTRAIL_FSP_MDP, /* Intel FSP memory-down params */ |
394e0b662 fdtdec: Add compa... |
145 |
COMPAT_INTEL_IVYBRIDGE_FSP, /* Intel Ivy Bridge FSP */ |
4ccae81cd mtd: nand: Add th... |
146 |
COMPAT_SUNXI_NAND, /* SUNXI NAND controller */ |
e11b5e8d6 fdt: Add compatib... |
147 148 149 150 151 152 153 154 |
COMPAT_ALTERA_SOCFPGA_CLK, /* SoCFPGA Clock initialization */ COMPAT_ALTERA_SOCFPGA_PINCTRL_SINGLE, /* SoCFPGA pinctrl-single */ COMPAT_ALTERA_SOCFPGA_H2F_BRG, /* SoCFPGA hps2fpga bridge */ COMPAT_ALTERA_SOCFPGA_LWH2F_BRG, /* SoCFPGA lwhps2fpga bridge */ COMPAT_ALTERA_SOCFPGA_F2H_BRG, /* SoCFPGA fpga2hps bridge */ COMPAT_ALTERA_SOCFPGA_F2SDR0, /* SoCFPGA fpga2SDRAM0 bridge */ COMPAT_ALTERA_SOCFPGA_F2SDR1, /* SoCFPGA fpga2SDRAM1 bridge */ COMPAT_ALTERA_SOCFPGA_F2SDR2, /* SoCFPGA fpga2SDRAM2 bridge */ |
eb57c0be1 fdt: Add compatib... |
155 156 |
COMPAT_ALTERA_SOCFPGA_FPGA0, /* SOCFPGA FPGA manager */ COMPAT_ALTERA_SOCFPGA_NOC, /* SOCFPGA Arria 10 NOC */ |
b5220bc6e fdt: add decode h... |
157 158 159 |
COMPAT_COUNT, }; |
57068a7ae dm: fdt: Add a fu... |
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 |
#define MAX_PHANDLE_ARGS 16 struct fdtdec_phandle_args { int node; int args_count; uint32_t args[MAX_PHANDLE_ARGS]; }; /** * fdtdec_parse_phandle_with_args() - Find a node pointed by phandle in a list * * This function is useful to parse lists of phandles and their arguments. * * Example: * * phandle1: node1 { * #list-cells = <2>; * } * * phandle2: node2 { * #list-cells = <1>; * } * * node3 { * list = <&phandle1 1 2 &phandle2 3>; * } * * To get a device_node of the `node2' node you may call this: * fdtdec_parse_phandle_with_args(blob, node3, "list", "#list-cells", 0, 1, * &args); * * (This function is a modified version of __of_parse_phandle_with_args() from * Linux 3.18) * * @blob: Pointer to device tree * @src_node: Offset of device tree node containing a list * @list_name: property name that contains a list * @cells_name: property name that specifies the phandles' arguments count, * or NULL to use @cells_count * @cells_count: Cell count to use if @cells_name is NULL * @index: index of a phandle to parse out * @out_args: optional pointer to output arguments structure (will be filled) * @return 0 on success (with @out_args filled out if not NULL), -ENOENT if * @list_name does not exist, a phandle was not found, @cells_name * could not be found, the arguments were truncated or there were too * many arguments. * */ int fdtdec_parse_phandle_with_args(const void *blob, int src_node, const char *list_name, const char *cells_name, int cell_count, int index, struct fdtdec_phandle_args *out_args); |
202ff7537 fdt: Add polarity... |
212 |
/** |
b5220bc6e fdt: add decode h... |
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 |
* Find the next numbered alias for a peripheral. This is used to enumerate * all the peripherals of a certain type. * * Do the first call with *upto = 0. Assuming /aliases/<name>0 exists then * this function will return a pointer to the node the alias points to, and * then update *upto to 1. Next time you call this function, the next node * will be returned. * * All nodes returned will match the compatible ID, as it is assumed that * all peripherals use the same driver. * * @param blob FDT blob to use * @param name Root name of alias to search for * @param id Compatible ID to look for * @return offset of next compatible node, or -FDT_ERR_NOTFOUND if no more */ int fdtdec_next_alias(const void *blob, const char *name, enum fdt_compat_id id, int *upto); /** |
7cde397b2 fdt: Export fdtde... |
233 234 235 236 237 238 239 240 241 242 243 244 245 |
* Find the compatible ID for a given node. * * Generally each node has at least one compatible string attached to it. * This function looks through our list of known compatible strings and * returns the corresponding ID which matches the compatible string. * * @param blob FDT blob to use * @param node Node containing compatible string to find * @return compatible ID, or COMPAT_UNKNOWN if we cannot find a match */ enum fdt_compat_id fdtdec_lookup(const void *blob, int node); /** |
f88fe2ded fdt: Tidy up a fe... |
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 |
* Find the next compatible node for a peripheral. * * Do the first call with node = 0. This function will return a pointer to * the next compatible node. Next time you call this function, pass the * value returned, and the next node will be provided. * * @param blob FDT blob to use * @param node Start node for search * @param id Compatible ID to look for (enum fdt_compat_id) * @return offset of next compatible node, or -FDT_ERR_NOTFOUND if no more */ int fdtdec_next_compatible(const void *blob, int node, enum fdt_compat_id id); /** |
3ddecfc74 fdt: Add function... |
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 |
* Find the next compatible subnode for a peripheral. * * Do the first call with node set to the parent and depth = 0. This * function will return the offset of the next compatible node. Next time * you call this function, pass the node value returned last time, with * depth unchanged, and the next node will be provided. * * @param blob FDT blob to use * @param node Start node for search * @param id Compatible ID to look for (enum fdt_compat_id) * @param depthp Current depth (set to 0 before first call) * @return offset of next compatible node, or -FDT_ERR_NOTFOUND if no more */ int fdtdec_next_compatible_subnode(const void *blob, int node, enum fdt_compat_id id, int *depthp); |
02464e386 fdt: add new fdt ... |
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 |
/* * Look up an address property in a node and return the parsed address, and * optionally the parsed size. * * This variant assumes a known and fixed number of cells are used to * represent the address and size. * * You probably don't want to use this function directly except to parse * non-standard properties, and never to parse the "reg" property. Instead, * use one of the "auto" variants below, which automatically honor the * #address-cells and #size-cells properties in the parent node. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param index which address to retrieve from a list of addresses. Often 0. * @param na the number of cells used to represent an address * @param ns the number of cells used to represent a size * @param sizep a pointer to store the size into. Use NULL if not required |
6e06acb73 fdt: allow fdtdec... |
295 296 |
* @param translate Indicates whether to translate the returned value * using the parent node's ranges property. |
02464e386 fdt: add new fdt ... |
297 298 299 300 |
* @return address, if found, or FDT_ADDR_T_NONE if not */ fdt_addr_t fdtdec_get_addr_size_fixed(const void *blob, int node, const char *prop_name, int index, int na, int ns, |
6e06acb73 fdt: allow fdtdec... |
301 |
fdt_size_t *sizep, bool translate); |
02464e386 fdt: add new fdt ... |
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 |
/* * Look up an address property in a node and return the parsed address, and * optionally the parsed size. * * This variant automatically determines the number of cells used to represent * the address and size by parsing the provided parent node's #address-cells * and #size-cells properties. * * @param blob FDT blob * @param parent parent node of @node * @param node node to examine * @param prop_name name of property to find * @param index which address to retrieve from a list of addresses. Often 0. * @param sizep a pointer to store the size into. Use NULL if not required |
6e06acb73 fdt: allow fdtdec... |
317 318 |
* @param translate Indicates whether to translate the returned value * using the parent node's ranges property. |
02464e386 fdt: add new fdt ... |
319 320 321 |
* @return address, if found, or FDT_ADDR_T_NONE if not */ fdt_addr_t fdtdec_get_addr_size_auto_parent(const void *blob, int parent, |
6e06acb73 fdt: allow fdtdec... |
322 323 |
int node, const char *prop_name, int index, fdt_size_t *sizep, bool translate); |
02464e386 fdt: add new fdt ... |
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 |
/* * Look up an address property in a node and return the parsed address, and * optionally the parsed size. * * This variant automatically determines the number of cells used to represent * the address and size by parsing the parent node's #address-cells * and #size-cells properties. The parent node is automatically found. * * The automatic parent lookup implemented by this function is slow. * Consequently, fdtdec_get_addr_size_auto_parent() should be used where * possible. * * @param blob FDT blob * @param parent parent node of @node * @param node node to examine * @param prop_name name of property to find * @param index which address to retrieve from a list of addresses. Often 0. * @param sizep a pointer to store the size into. Use NULL if not required |
6e06acb73 fdt: allow fdtdec... |
343 344 |
* @param translate Indicates whether to translate the returned value * using the parent node's ranges property. |
02464e386 fdt: add new fdt ... |
345 346 347 |
* @return address, if found, or FDT_ADDR_T_NONE if not */ fdt_addr_t fdtdec_get_addr_size_auto_noparent(const void *blob, int node, |
6e06acb73 fdt: allow fdtdec... |
348 349 |
const char *prop_name, int index, fdt_size_t *sizep, bool translate); |
02464e386 fdt: add new fdt ... |
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 |
/* * Look up an address property in a node and return the parsed address. * * This variant hard-codes the number of cells used to represent the address * and size based on sizeof(fdt_addr_t) and sizeof(fdt_size_t). It also * always returns the first address value in the property (index 0). * * Use of this function is not recommended due to the hard-coding of cell * counts. There is no programmatic validation that these hard-coded values * actually match the device tree content in any way at all. This assumption * can be satisfied by manually ensuring CONFIG_PHYS_64BIT is appropriately * set in the U-Boot build and exercising strict control over DT content to * ensure use of matching #address-cells/#size-cells properties. However, this * approach is error-prone; those familiar with DT will not expect the * assumption to exist, and could easily invalidate it. If the assumption is * invalidated, this function will not report the issue, and debugging will * be required. Instead, use fdtdec_get_addr_size_auto_parent(). |
b5220bc6e fdt: add decode h... |
368 369 370 371 372 373 374 375 |
* * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @return address, if found, or FDT_ADDR_T_NONE if not */ fdt_addr_t fdtdec_get_addr(const void *blob, int node, const char *prop_name); |
02464e386 fdt: add new fdt ... |
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 |
/* * Look up an address property in a node and return the parsed address, and * optionally the parsed size. * * This variant hard-codes the number of cells used to represent the address * and size based on sizeof(fdt_addr_t) and sizeof(fdt_size_t). It also * always returns the first address value in the property (index 0). * * Use of this function is not recommended due to the hard-coding of cell * counts. There is no programmatic validation that these hard-coded values * actually match the device tree content in any way at all. This assumption * can be satisfied by manually ensuring CONFIG_PHYS_64BIT is appropriately * set in the U-Boot build and exercising strict control over DT content to * ensure use of matching #address-cells/#size-cells properties. However, this * approach is error-prone; those familiar with DT will not expect the * assumption to exist, and could easily invalidate it. If the assumption is * invalidated, this function will not report the issue, and debugging will * be required. Instead, use fdtdec_get_addr_size_auto_parent(). |
4397a2a80 fdt: Add fdtdec_g... |
394 395 396 397 |
* * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find |
02464e386 fdt: add new fdt ... |
398 |
* @param sizep a pointer to store the size into. Use NULL if not required |
4397a2a80 fdt: Add fdtdec_g... |
399 400 401 402 403 404 |
* @return address, if found, or FDT_ADDR_T_NONE if not */ fdt_addr_t fdtdec_get_addr_size(const void *blob, int node, const char *prop_name, fdt_size_t *sizep); /** |
a62e84d7b fdt: Add several ... |
405 406 407 408 409 410 411 412 413 |
* Look at an address property in a node and return the pci address which * corresponds to the given type in the form of fdt_pci_addr. * The property must hold one fdt_pci_addr with a lengh. * * @param blob FDT blob * @param node node to examine * @param type pci address type (FDT_PCI_SPACE_xxx) * @param prop_name name of property to find * @param addr returns pci address in the form of fdt_pci_addr |
106cce960 fdt: Tighten up e... |
414 415 416 |
* @return 0 if ok, -ENOENT if the property did not exist, -EINVAL if the * format of the property was invalid, -ENXIO if the requested * address type was not found |
a62e84d7b fdt: Add several ... |
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 |
*/ int fdtdec_get_pci_addr(const void *blob, int node, enum fdt_pci_space type, const char *prop_name, struct fdt_pci_addr *addr); /** * Look at the compatible property of a device node that represents a PCI * device and extract pci vendor id and device id from it. * * @param blob FDT blob * @param node node to examine * @param vendor vendor id of the pci device * @param device device id of the pci device * @return 0 if ok, negative on error */ int fdtdec_get_pci_vendev(const void *blob, int node, u16 *vendor, u16 *device); /** * Look at the pci address of a device node that represents a PCI device |
a62e84d7b fdt: Add several ... |
436 437 |
* and return base address of the pci device's registers. * |
fcc0a8774 dm: serial: Conve... |
438 |
* @param dev device to examine |
a62e84d7b fdt: Add several ... |
439 440 441 442 |
* @param addr pci address in the form of fdt_pci_addr * @param bar returns base address of the pci device's registers * @return 0 if ok, negative on error */ |
fcc0a8774 dm: serial: Conve... |
443 444 |
int fdtdec_get_pci_bar32(struct udevice *dev, struct fdt_pci_addr *addr, u32 *bar); |
a62e84d7b fdt: Add several ... |
445 446 |
/** |
b5220bc6e fdt: add decode h... |
447 448 449 450 451 452 453 454 455 456 457 458 459 460 |
* Look up a 32-bit integer property in a node and return it. The property * must have at least 4 bytes of data. The value of the first cell is * returned. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param default_val default value to return if the property is not found * @return integer value, if found, or default_val if not */ s32 fdtdec_get_int(const void *blob, int node, const char *prop_name, s32 default_val); /** |
bfa3e55b4 lib, fdt: Adding ... |
461 462 463 464 465 466 467 468 469 470 471 472 473 |
* Unsigned version of fdtdec_get_int. The property must have at least * 4 bytes of data. The value of the first cell is returned. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param default_val default value to return if the property is not found * @return unsigned integer value, if found, or default_val if not */ unsigned int fdtdec_get_uint(const void *blob, int node, const char *prop_name, unsigned int default_val); /** |
5f7bfdd63 fdt: Export fdtde... |
474 475 476 477 478 479 480 481 482 483 484 |
* Get a variable-sized number from a property * * This reads a number from one or more cells. * * @param ptr Pointer to property * @param cells Number of cells containing the number * @return the value in the cells */ u64 fdtdec_get_number(const fdt32_t *ptr, unsigned int cells); /** |
aadef0a1b fdt: Add fdtdec_g... |
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 |
* Look up a 64-bit integer property in a node and return it. The property * must have at least 8 bytes of data (2 cells). The first two cells are * concatenated to form a 8 bytes value, where the first cell is top half and * the second cell is bottom half. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param default_val default value to return if the property is not found * @return integer value, if found, or default_val if not */ uint64_t fdtdec_get_uint64(const void *blob, int node, const char *prop_name, uint64_t default_val); /** |
b5220bc6e fdt: add decode h... |
500 501 502 |
* Checks whether a node is enabled. * This looks for a 'status' property. If this exists, then returns 1 if * the status is 'ok' and 0 otherwise. If there is no status property, |
f88fe2ded fdt: Tidy up a fe... |
503 504 |
* it returns 1 on the assumption that anything mentioned should be enabled * by default. |
b5220bc6e fdt: add decode h... |
505 506 507 |
* * @param blob FDT blob * @param node node to examine |
f88fe2ded fdt: Tidy up a fe... |
508 |
* @return integer value 0 (not enabled) or 1 (enabled) |
b5220bc6e fdt: add decode h... |
509 |
*/ |
f88fe2ded fdt: Tidy up a fe... |
510 |
int fdtdec_get_is_enabled(const void *blob, int node); |
b5220bc6e fdt: add decode h... |
511 512 |
/** |
9a263e55d fdt: Avoid early ... |
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 |
* Make sure we have a valid fdt available to control U-Boot. * * If not, a message is printed to the console if the console is ready. * * @return 0 if all ok, -1 if not */ int fdtdec_prepare_fdt(void); /** * Checks that we have a valid fdt available to control U-Boot. * However, if not then for the moment nothing is done, since this function * is called too early to panic(). * * @returns 0 |
b5220bc6e fdt: add decode h... |
528 529 |
*/ int fdtdec_check_fdt(void); |
a53f4a29a fdt: Add fdtdec_f... |
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 |
/** * Find the nodes for a peripheral and return a list of them in the correct * order. This is used to enumerate all the peripherals of a certain type. * * To use this, optionally set up a /aliases node with alias properties for * a peripheral. For example, for usb you could have: * * aliases { * usb0 = "/ehci@c5008000"; * usb1 = "/ehci@c5000000"; * }; * * Pass "usb" as the name to this function and will return a list of two * nodes offsets: /ehci@c5008000 and ehci@c5000000. * * All nodes returned will match the compatible ID, as it is assumed that * all peripherals use the same driver. * * If no alias node is found, then the node list will be returned in the * order found in the fdt. If the aliases mention a node which doesn't * exist, then this will be ignored. If nodes are found with no aliases, * they will be added in any order. * * If there is a gap in the aliases, then this function return a 0 node at * that position. The return value will also count these gaps. * * This function checks node properties and will not return nodes which are * marked disabled (status = "disabled"). * * @param blob FDT blob to use * @param name Root name of alias to search for * @param id Compatible ID to look for * @param node_list Place to put list of found nodes * @param maxcount Maximum number of nodes to find |
1cc0a9f49 Fix various typos... |
565 |
* @return number of nodes found on success, FDT_ERR_... on error |
a53f4a29a fdt: Add fdtdec_f... |
566 567 568 569 570 |
*/ int fdtdec_find_aliases_for_id(const void *blob, const char *name, enum fdt_compat_id id, int *node_list, int maxcount); /* |
c67822704 fdt: Add function... |
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 |
* This function is similar to fdtdec_find_aliases_for_id() except that it * adds to the node_list that is passed in. Any 0 elements are considered * available for allocation - others are considered already used and are * skipped. * * You can use this by calling fdtdec_find_aliases_for_id() with an * uninitialised array, then setting the elements that are returned to -1, * say, then calling this function, perhaps with a different compat id. * Any elements you get back that are >0 are new nodes added by the call * to this function. * * Note that if you have some nodes with aliases and some without, you are * sailing close to the wind. The call to fdtdec_find_aliases_for_id() with * one compat_id may fill in positions for which you have aliases defined * for another compat_id. When you later call *this* function with the second * compat_id, the alias positions may already be used. A debug warning may * be generated in this case, but it is safest to define aliases for all * nodes when you care about the ordering. */ int fdtdec_add_aliases_for_id(const void *blob, const char *name, enum fdt_compat_id id, int *node_list, int maxcount); |
5c33c9fdb fdt: Add a functi... |
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 |
/** * Get the alias sequence number of a node * * This works out whether a node is pointed to by an alias, and if so, the * sequence number of that alias. Aliases are of the form <base><num> where * <num> is the sequence number. For example spi2 would be sequence number * 2. * * @param blob Device tree blob (if NULL, then error is returned) * @param base Base name for alias (before the underscore) * @param node Node to look up * @param seqp This is set to the sequence number if one is found, * but otherwise the value is left alone * @return 0 if a sequence was found, -ve if not */ int fdtdec_get_alias_seq(const void *blob, const char *base, int node, int *seqp); |
3234aa4ba fdt: Add a functi... |
609 |
/** |
3bc37a50e fdt: Add a functi... |
610 611 612 613 614 615 616 617 618 619 |
* Get a property from the /chosen node * * @param blob Device tree blob (if NULL, then NULL is returned) * @param name Property name to look up * @return Value of property, or NULL if it does not exist */ const char *fdtdec_get_chosen_prop(const void *blob, const char *name); /** * Get the offset of the given /chosen node |
aac07d49d dm: fdt: Add a fu... |
620 621 622 623 624 625 626 627 628 |
* * This looks up a property in /chosen containing the path to another node, * then finds the offset of that node. * * @param blob Device tree blob (if NULL, then error is returned) * @param name Property name, e.g. "stdout-path" * @return Node offset referred to by that chosen node, or -ve FDT_ERR_... */ int fdtdec_get_chosen_node(const void *blob, const char *name); |
c67822704 fdt: Add function... |
629 |
/* |
a53f4a29a fdt: Add fdtdec_f... |
630 631 632 633 634 635 |
* Get the name for a compatible ID * * @param id Compatible ID to look for * @return compatible string for that id */ const char *fdtdec_get_compatible(enum fdt_compat_id id); |
d17da6556 fdt: Add function... |
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 |
/* Look up a phandle and follow it to its node. Then return the offset * of that node. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @return node offset if found, -ve error code on error */ int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name); /** * Look up a property in a node and return its contents in an integer * array of given length. The property must have at least enough data for * the array (4*count bytes). It may have more, but this will be ignored. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param array array to fill with data * @param count number of array elements * @return 0 if ok, or -FDT_ERR_NOTFOUND if the property is not found, * or -FDT_ERR_BADLAYOUT if not enough data */ int fdtdec_get_int_array(const void *blob, int node, const char *prop_name, u32 *array, int count); /** |
a9f04d49e fdt: Add a functi... |
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 |
* Look up a property in a node and return its contents in an integer * array of given length. The property must exist but may have less data that * expected (4*count bytes). It may have more, but this will be ignored. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param array array to fill with data * @param count number of array elements * @return number of array elements if ok, or -FDT_ERR_NOTFOUND if the * property is not found */ int fdtdec_get_int_array_count(const void *blob, int node, const char *prop_name, u32 *array, int count); /** |
96875e7d3 fdt: Add function... |
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 |
* Look up a property in a node and return a pointer to its contents as a * unsigned int array of given length. The property must have at least enough * data for the array ('count' cells). It may have more, but this will be * ignored. The data is not copied. * * Note that you must access elements of the array with fdt32_to_cpu(), * since the elements will be big endian even on a little endian machine. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param count number of array elements * @return pointer to array if found, or NULL if the property is not * found or there is not enough data */ const u32 *fdtdec_locate_array(const void *blob, int node, const char *prop_name, int count); /** |
d17da6556 fdt: Add function... |
699 700 701 702 703 704 705 706 707 708 709 |
* Look up a boolean property in a node and return it. * * A boolean properly is true if present in the device tree and false if not * present, regardless of its value. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @return 1 if the properly is present; 0 if it isn't present */ int fdtdec_get_bool(const void *blob, int node, const char *prop_name); |
ed3ee5cd0 fdt: Add basic su... |
710 |
|
1889a7e27 fdt: introduce fd... |
711 712 713 714 715 716 717 718 |
/* * Count child nodes of one parent node. * * @param blob FDT blob * @param node parent node * @return number of child node; 0 if there is not child node */ int fdtdec_get_child_count(const void *blob, int node); |
ed3ee5cd0 fdt: Add basic su... |
719 |
/** |
09258f1e8 fdt: Add function... |
720 721 722 723 724 725 726 727 728 729 730 |
* Look in the FDT for a config item with the given name and return its value * as a 32-bit integer. The property must have at least 4 bytes of data. The * value of the first cell is returned. * * @param blob FDT blob to use * @param prop_name Node property name * @param default_val default value to return if the property is not found * @return integer value, if found, or default_val if not */ int fdtdec_get_config_int(const void *blob, const char *prop_name, int default_val); |
332ab0d54 fdt: Add function... |
731 |
/** |
79289c0b5 fdt: Add function... |
732 733 734 735 736 737 738 739 740 741 |
* Look in the FDT for a config item with the given name * and return whether it exists. * * @param blob FDT blob * @param prop_name property name to look up * @return 1, if it exists, or 0 if not */ int fdtdec_get_config_bool(const void *blob, const char *prop_name); /** |
332ab0d54 fdt: Add function... |
742 743 744 745 746 747 748 749 |
* Look in the FDT for a config item with the given name and return its value * as a string. * * @param blob FDT blob * @param prop_name property name to look up * @returns property string, NULL on error. */ char *fdtdec_get_config_string(const void *blob, const char *prop_name); |
bed4d8927 fdt: Add fdtdec f... |
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 |
/* * Look up a property in a node and return its contents in a byte * array of given length. The property must have at least enough data for * the array (count bytes). It may have more, but this will be ignored. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param array array to fill with data * @param count number of array elements * @return 0 if ok, or -FDT_ERR_MISSING if the property is not found, * or -FDT_ERR_BADLAYOUT if not enough data */ int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name, u8 *array, int count); /** * Look up a property in a node and return a pointer to its contents as a * byte array of given length. The property must have at least enough data * for the array (count bytes). It may have more, but this will be ignored. * The data is not copied. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find * @param count number of array elements * @return pointer to byte array if found, or NULL if the property is not * found or there is not enough data */ const u8 *fdtdec_locate_byte_array(const void *blob, int node, const char *prop_name, int count); |
f20c46198 fdt: Add fdtdec_d... |
781 782 783 784 785 786 787 788 789 790 791 |
/** * Look up a property in a node which contains a memory region address and * size. Then return a pointer to this address. * * The property must hold one address with a length. This is only tested on * 32-bit machines. * * @param blob FDT blob * @param node node to examine * @param prop_name name of property to find |
76489832b fdt: Use the corr... |
792 793 794 |
* @param basep Returns base address of region * @param size Returns size of region * @return 0 if ok, -1 on error (property not found) |
f20c46198 fdt: Add fdtdec_d... |
795 |
*/ |
76489832b fdt: Use the corr... |
796 797 |
int fdtdec_decode_region(const void *blob, int node, const char *prop_name, fdt_addr_t *basep, fdt_size_t *sizep); |
006e73b9c cros_ec: Add a fu... |
798 |
|
56f42242f fdt: Add resource... |
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 |
/** * Obtain an indexed resource from a device property. * * @param fdt FDT blob * @param node node to examine * @param property name of the property to parse * @param index index of the resource to retrieve * @param res returns the resource * @return 0 if ok, negative on error */ int fdt_get_resource(const void *fdt, int node, const char *property, unsigned int index, struct fdt_resource *res); /** * Obtain a named resource from a device property. * * Look up the index of the name in a list of strings and return the resource * at that index. * * @param fdt FDT blob * @param node node to examine * @param property name of the property to parse * @param prop_names name of the property containing the list of names * @param name the name of the entry to look up * @param res returns the resource */ int fdt_get_named_resource(const void *fdt, int node, const char *property, const char *prop_names, const char *name, struct fdt_resource *res); |
9f85eee72 fdt: Add a functi... |
828 |
/** |
264038714 fdt: Add a functi... |
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 |
* Decode a named region within a memory bank of a given type. * * This function handles selection of a memory region. The region is * specified as an offset/size within a particular type of memory. * * The properties used are: * * <mem_type>-memory<suffix> for the name of the memory bank * <mem_type>-offset<suffix> for the offset in that bank * * The property value must have an offset and a size. The function checks * that the region is entirely within the memory bank.5 * * @param blob FDT blob * @param node Node containing the properties (-1 for /config) * @param mem_type Type of memory to use, which is a name, such as * "u-boot" or "kernel". * @param suffix String to append to the memory/offset * property names * @param basep Returns base of region * @param sizep Returns size of region * @return 0 if OK, -ive on error */ int fdtdec_decode_memory_region(const void *blob, int node, const char *mem_type, const char *suffix, fdt_addr_t *basep, fdt_size_t *sizep); |
b45122fdf fdt: sandbox: Mov... |
855 |
|
12e671142 fdt: Add binding ... |
856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 |
/* Display timings from linux include/video/display_timing.h */ enum display_flags { DISPLAY_FLAGS_HSYNC_LOW = 1 << 0, DISPLAY_FLAGS_HSYNC_HIGH = 1 << 1, DISPLAY_FLAGS_VSYNC_LOW = 1 << 2, DISPLAY_FLAGS_VSYNC_HIGH = 1 << 3, /* data enable flag */ DISPLAY_FLAGS_DE_LOW = 1 << 4, DISPLAY_FLAGS_DE_HIGH = 1 << 5, /* drive data on pos. edge */ DISPLAY_FLAGS_PIXDATA_POSEDGE = 1 << 6, /* drive data on neg. edge */ DISPLAY_FLAGS_PIXDATA_NEGEDGE = 1 << 7, DISPLAY_FLAGS_INTERLACED = 1 << 8, DISPLAY_FLAGS_DOUBLESCAN = 1 << 9, DISPLAY_FLAGS_DOUBLECLK = 1 << 10, }; /* * A single signal can be specified via a range of minimal and maximal values * with a typical value, that lies somewhere inbetween. */ struct timing_entry { u32 min; u32 typ; u32 max; }; /* * Single "mode" entry. This describes one set of signal timings a display can * have in one setting. This struct can later be converted to struct videomode * (see include/video/videomode.h). As each timing_entry can be defined as a * range, one struct display_timing may become multiple struct videomodes. * * Example: hsync active high, vsync active low * * Active Video * Video ______________________XXXXXXXXXXXXXXXXXXXXXX_____________________ * |<- sync ->|<- back ->|<----- active ----->|<- front ->|<- sync.. * | | porch | | porch | * * HSync _|¯¯¯¯¯¯¯¯¯¯|___________________________________________|¯¯¯¯¯¯¯¯¯ * * VSync ¯|__________|¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯|_________ */ struct display_timing { struct timing_entry pixelclock; struct timing_entry hactive; /* hor. active video */ struct timing_entry hfront_porch; /* hor. front porch */ struct timing_entry hback_porch; /* hor. back porch */ struct timing_entry hsync_len; /* hor. sync len */ struct timing_entry vactive; /* ver. active video */ struct timing_entry vfront_porch; /* ver. front porch */ struct timing_entry vback_porch; /* ver. back porch */ struct timing_entry vsync_len; /* ver. sync len */ enum display_flags flags; /* display flags */ |
43c6bdd02 edid: Add HDMI fl... |
916 |
bool hdmi_monitor; /* is hdmi monitor? */ |
12e671142 fdt: Add binding ... |
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 |
}; /** * fdtdec_decode_display_timing() - decode display timings * * Decode display timings from the supplied 'display-timings' node. * See doc/device-tree-bindings/video/display-timing.txt for binding * information. * * @param blob FDT blob * @param node 'display-timing' node containing the timing subnodes * @param index Index number to read (0=first timing subnode) * @param config Place to put timings * @return 0 if OK, -FDT_ERR_NOTFOUND if not found */ int fdtdec_decode_display_timing(const void *blob, int node, int index, struct display_timing *config); |
623f60198 fdt: add memory b... |
934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 |
/** * fdtdec_setup_memory_size() - decode and setup gd->ram_size * * Decode the /memory 'reg' property to determine the size of the first memory * bank, populate the global data with the size of the first bank of memory. * * This function should be called from a boards dram_init(). This helper * function allows for boards to query the device tree for DRAM size instead of * hard coding the value in the case where the memory size cannot be detected * automatically. * * @return 0 if OK, -EINVAL if the /memory node or reg property is missing or * invalid */ int fdtdec_setup_memory_size(void); /** * fdtdec_setup_memory_banksize() - decode and populate gd->bd->bi_dram * * Decode the /memory 'reg' property to determine the address and size of the * memory banks. Use this data to populate the global data board info with the * phys address and size of memory banks. * * This function should be called from a boards dram_init_banksize(). This * helper function allows for boards to query the device tree for memory bank * information instead of hard coding the information in cases where it cannot * be detected automatically. * * @return 0 if OK, -EINVAL if the /memory node or reg property is missing or * invalid */ int fdtdec_setup_memory_banksize(void); |
b45122fdf fdt: sandbox: Mov... |
967 968 969 |
/** * Set up the device tree ready for use */ |
0879361fd fdt: Rename setup... |
970 |
int fdtdec_setup(void); |
b45122fdf fdt: sandbox: Mov... |
971 |
|
82f766d1d Allow boards to i... |
972 973 |
/** * Board-specific FDT initialization. Returns the address to a device tree blob. |
3b595da44 fdtdec: allow boa... |
974 975 |
* Called when CONFIG_OF_BOARD is defined, or if CONFIG_OF_SEPARATE is defined * and the board implements it. |
82f766d1d Allow boards to i... |
976 977 |
*/ void *board_fdt_blob_setup(void); |
5bfa78db4 fdt: Add header g... |
978 |
#endif |