183d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
2b5220bc6SSimon Glass /*
3b5220bc6SSimon Glass * Copyright (c) 2011 The Chromium OS Authors.
4b5220bc6SSimon Glass */
5b5220bc6SSimon Glass
629a23f9dSHeiko Schocher #ifndef USE_HOSTCC
7b5220bc6SSimon Glass #include <common.h>
8035d6402SJean-Jacques Hiblot #include <boot_fit.h>
9fcc0a877SSimon Glass #include <dm.h>
10b7e0d73bSSimon Glass #include <dm/of_extra.h>
11035d6402SJean-Jacques Hiblot #include <errno.h>
12035d6402SJean-Jacques Hiblot #include <fdtdec.h>
13035d6402SJean-Jacques Hiblot #include <fdt_support.h>
14f980c999SHeinrich Schuchardt #include <mapmem.h>
15b08c8c48SMasahiro Yamada #include <linux/libfdt.h>
16035d6402SJean-Jacques Hiblot #include <serial.h>
17035d6402SJean-Jacques Hiblot #include <asm/sections.h>
185c33c9fdSSimon Glass #include <linux/ctype.h>
192f57c951SJean-Jacques Hiblot #include <linux/lzo.h>
20b5220bc6SSimon Glass
21b5220bc6SSimon Glass DECLARE_GLOBAL_DATA_PTR;
22b5220bc6SSimon Glass
23b5220bc6SSimon Glass /*
24b5220bc6SSimon Glass * Here are the type we know about. One day we might allow drivers to
25b5220bc6SSimon Glass * register. For now we just put them here. The COMPAT macro allows us to
26b5220bc6SSimon Glass * turn this into a sparse list later, and keeps the ID with the name.
2701a227dfSSimon Glass *
2801a227dfSSimon Glass * NOTE: This list is basically a TODO list for things that need to be
2901a227dfSSimon Glass * converted to driver model. So don't add new things here unless there is a
3001a227dfSSimon Glass * good reason why driver-model conversion is infeasible. Examples include
3101a227dfSSimon Glass * things which are used before driver model is available.
32b5220bc6SSimon Glass */
33b5220bc6SSimon Glass #define COMPAT(id, name) name
34b5220bc6SSimon Glass static const char * const compat_names[COMPAT_COUNT] = {
35f88fe2deSSimon Glass COMPAT(UNKNOWN, "<none>"),
360e35ad05SJimmy Zhang COMPAT(NVIDIA_TEGRA20_EMC, "nvidia,tegra20-emc"),
370e35ad05SJimmy Zhang COMPAT(NVIDIA_TEGRA20_EMC_TABLE, "nvidia,tegra20-emc-table"),
38312693c3SJim Lin COMPAT(NVIDIA_TEGRA20_NAND, "nvidia,tegra20-nand"),
3979c7a90fSThierry Reding COMPAT(NVIDIA_TEGRA124_XUSB_PADCTL, "nvidia,tegra124-xusb-padctl"),
407aaa5a60STom Warren COMPAT(NVIDIA_TEGRA210_XUSB_PADCTL, "nvidia,tegra210-xusb-padctl"),
41cc9fe33aSHatim RV COMPAT(SMSC_LAN9215, "smsc,lan9215"),
42cc9fe33aSHatim RV COMPAT(SAMSUNG_EXYNOS5_SROMC, "samsung,exynos-sromc"),
436abd1620SRajeshwari Shinde COMPAT(SAMSUNG_EXYNOS_USB_PHY, "samsung,exynos-usb-phy"),
44108b85beSVivek Gautam COMPAT(SAMSUNG_EXYNOS5_USB3_PHY, "samsung,exynos5250-usb3-phy"),
45618766c0SAkshay Saraswat COMPAT(SAMSUNG_EXYNOS_TMU, "samsung,exynos-tmu"),
46de461c52SPiotr Wilczek COMPAT(SAMSUNG_EXYNOS_MIPI_DSI, "samsung,exynos-mipi-dsi"),
477d3ca0f8SJaehoon Chung COMPAT(SAMSUNG_EXYNOS_DWMMC, "samsung,exynos-dwmmc"),
48bb8215f4SSimon Glass COMPAT(GENERIC_SPI_FLASH, "spi-flash"),
4945c480c9SAjay Kumar COMPAT(SAMSUNG_EXYNOS_SYSMMU, "samsung,sysmmu-v3.3"),
5077f9b1fbSSimon Glass COMPAT(INTEL_MICROCODE, "intel,microcode"),
51c89ada01SBin Meng COMPAT(INTEL_QRK_MRC, "intel,quark-mrc"),
526ab00db2SMarek Vasut COMPAT(ALTERA_SOCFPGA_DWMAC, "altr,socfpga-stmmac"),
53129adf5bSMarek Vasut COMPAT(ALTERA_SOCFPGA_DWMMC, "altr,socfpga-dw-mshc"),
54ef4b01b2SMarek Vasut COMPAT(ALTERA_SOCFPGA_DWC2USB, "snps,dwc2"),
5539ea0ee9SSimon Glass COMPAT(INTEL_BAYTRAIL_FSP, "intel,baytrail-fsp"),
5639ea0ee9SSimon Glass COMPAT(INTEL_BAYTRAIL_FSP_MDP, "intel,baytrail-fsp-mdp"),
5739ea0ee9SSimon Glass COMPAT(INTEL_IVYBRIDGE_FSP, "intel,ivybridge-fsp"),
584ccae81cSBoris Brezillon COMPAT(COMPAT_SUNXI_NAND, "allwinner,sun4i-a10-nand"),
59e11b5e8dSLey Foon Tan COMPAT(ALTERA_SOCFPGA_CLK, "altr,clk-mgr"),
60e11b5e8dSLey Foon Tan COMPAT(ALTERA_SOCFPGA_PINCTRL_SINGLE, "pinctrl-single"),
61e11b5e8dSLey Foon Tan COMPAT(ALTERA_SOCFPGA_H2F_BRG, "altr,socfpga-hps2fpga-bridge"),
62e11b5e8dSLey Foon Tan COMPAT(ALTERA_SOCFPGA_LWH2F_BRG, "altr,socfpga-lwhps2fpga-bridge"),
63e11b5e8dSLey Foon Tan COMPAT(ALTERA_SOCFPGA_F2H_BRG, "altr,socfpga-fpga2hps-bridge"),
64e11b5e8dSLey Foon Tan COMPAT(ALTERA_SOCFPGA_F2SDR0, "altr,socfpga-fpga2sdram0-bridge"),
65e11b5e8dSLey Foon Tan COMPAT(ALTERA_SOCFPGA_F2SDR1, "altr,socfpga-fpga2sdram1-bridge"),
66e11b5e8dSLey Foon Tan COMPAT(ALTERA_SOCFPGA_F2SDR2, "altr,socfpga-fpga2sdram2-bridge"),
67eb57c0beSTien Fong Chee COMPAT(ALTERA_SOCFPGA_FPGA0, "altr,socfpga-a10-fpga-mgr"),
68eb57c0beSTien Fong Chee COMPAT(ALTERA_SOCFPGA_NOC, "altr,socfpga-a10-noc"),
6919c8fc77SMarek Vasut COMPAT(ALTERA_SOCFPGA_CLK_INIT, "altr,socfpga-a10-clk-init")
70b5220bc6SSimon Glass };
71b5220bc6SSimon Glass
fdtdec_get_compatible(enum fdt_compat_id id)72a53f4a29SSimon Glass const char *fdtdec_get_compatible(enum fdt_compat_id id)
73a53f4a29SSimon Glass {
74a53f4a29SSimon Glass /* We allow reading of the 'unknown' ID for testing purposes */
75a53f4a29SSimon Glass assert(id >= 0 && id < COMPAT_COUNT);
76a53f4a29SSimon Glass return compat_names[id];
77a53f4a29SSimon Glass }
78a53f4a29SSimon Glass
fdtdec_get_addr_size_fixed(const void * blob,int node,const char * prop_name,int index,int na,int ns,fdt_size_t * sizep,bool translate)7902464e38SStephen Warren fdt_addr_t fdtdec_get_addr_size_fixed(const void *blob, int node,
802e38662dSMario Six const char *prop_name, int index, int na,
812e38662dSMario Six int ns, fdt_size_t *sizep,
822e38662dSMario Six bool translate)
8302464e38SStephen Warren {
8402464e38SStephen Warren const fdt32_t *prop, *prop_end;
8502464e38SStephen Warren const fdt32_t *prop_addr, *prop_size, *prop_after_size;
8602464e38SStephen Warren int len;
8702464e38SStephen Warren fdt_addr_t addr;
8802464e38SStephen Warren
8902464e38SStephen Warren debug("%s: %s: ", __func__, prop_name);
9002464e38SStephen Warren
9102464e38SStephen Warren prop = fdt_getprop(blob, node, prop_name, &len);
9202464e38SStephen Warren if (!prop) {
9302464e38SStephen Warren debug("(not found)\n");
9402464e38SStephen Warren return FDT_ADDR_T_NONE;
9502464e38SStephen Warren }
9602464e38SStephen Warren prop_end = prop + (len / sizeof(*prop));
9702464e38SStephen Warren
9802464e38SStephen Warren prop_addr = prop + (index * (na + ns));
9902464e38SStephen Warren prop_size = prop_addr + na;
10002464e38SStephen Warren prop_after_size = prop_size + ns;
10102464e38SStephen Warren if (prop_after_size > prop_end) {
10202464e38SStephen Warren debug("(not enough data: expected >= %d cells, got %d cells)\n",
10302464e38SStephen Warren (u32)(prop_after_size - prop), ((u32)(prop_end - prop)));
10402464e38SStephen Warren return FDT_ADDR_T_NONE;
10502464e38SStephen Warren }
10602464e38SStephen Warren
1075efa1bfbSVignesh R #if CONFIG_IS_ENABLED(OF_TRANSLATE)
1086e06acb7SStephen Warren if (translate)
1096e06acb7SStephen Warren addr = fdt_translate_address(blob, node, prop_addr);
1106e06acb7SStephen Warren else
1116e06acb7SStephen Warren #endif
11202464e38SStephen Warren addr = fdtdec_get_number(prop_addr, na);
11302464e38SStephen Warren
11402464e38SStephen Warren if (sizep) {
11502464e38SStephen Warren *sizep = fdtdec_get_number(prop_size, ns);
116fd30d2c6SSimon Glass debug("addr=%08llx, size=%llx\n", (unsigned long long)addr,
117fd30d2c6SSimon Glass (unsigned long long)*sizep);
11802464e38SStephen Warren } else {
119fd30d2c6SSimon Glass debug("addr=%08llx\n", (unsigned long long)addr);
12002464e38SStephen Warren }
12102464e38SStephen Warren
12202464e38SStephen Warren return addr;
12302464e38SStephen Warren }
12402464e38SStephen Warren
fdtdec_get_addr_size_auto_parent(const void * blob,int parent,int node,const char * prop_name,int index,fdt_size_t * sizep,bool translate)12502464e38SStephen Warren fdt_addr_t fdtdec_get_addr_size_auto_parent(const void *blob, int parent,
1262e38662dSMario Six int node, const char *prop_name,
1272e38662dSMario Six int index, fdt_size_t *sizep,
1286e06acb7SStephen Warren bool translate)
12902464e38SStephen Warren {
13002464e38SStephen Warren int na, ns;
13102464e38SStephen Warren
13202464e38SStephen Warren debug("%s: ", __func__);
13302464e38SStephen Warren
13402464e38SStephen Warren na = fdt_address_cells(blob, parent);
13502464e38SStephen Warren if (na < 1) {
13602464e38SStephen Warren debug("(bad #address-cells)\n");
13702464e38SStephen Warren return FDT_ADDR_T_NONE;
13802464e38SStephen Warren }
13902464e38SStephen Warren
14002464e38SStephen Warren ns = fdt_size_cells(blob, parent);
141ff0a6358SPrzemyslaw Marczak if (ns < 0) {
14202464e38SStephen Warren debug("(bad #size-cells)\n");
14302464e38SStephen Warren return FDT_ADDR_T_NONE;
14402464e38SStephen Warren }
14502464e38SStephen Warren
14602464e38SStephen Warren debug("na=%d, ns=%d, ", na, ns);
14702464e38SStephen Warren
14802464e38SStephen Warren return fdtdec_get_addr_size_fixed(blob, node, prop_name, index, na,
1496e06acb7SStephen Warren ns, sizep, translate);
15002464e38SStephen Warren }
15102464e38SStephen Warren
fdtdec_get_addr_size_auto_noparent(const void * blob,int node,const char * prop_name,int index,fdt_size_t * sizep,bool translate)15202464e38SStephen Warren fdt_addr_t fdtdec_get_addr_size_auto_noparent(const void *blob, int node,
1532e38662dSMario Six const char *prop_name, int index,
1542e38662dSMario Six fdt_size_t *sizep,
1556e06acb7SStephen Warren bool translate)
15602464e38SStephen Warren {
15702464e38SStephen Warren int parent;
15802464e38SStephen Warren
15902464e38SStephen Warren debug("%s: ", __func__);
16002464e38SStephen Warren
16102464e38SStephen Warren parent = fdt_parent_offset(blob, node);
16202464e38SStephen Warren if (parent < 0) {
16302464e38SStephen Warren debug("(no parent found)\n");
16402464e38SStephen Warren return FDT_ADDR_T_NONE;
16502464e38SStephen Warren }
16602464e38SStephen Warren
16702464e38SStephen Warren return fdtdec_get_addr_size_auto_parent(blob, parent, node, prop_name,
1686e06acb7SStephen Warren index, sizep, translate);
16902464e38SStephen Warren }
17002464e38SStephen Warren
fdtdec_get_addr_size(const void * blob,int node,const char * prop_name,fdt_size_t * sizep)1714397a2a8SSimon Glass fdt_addr_t fdtdec_get_addr_size(const void *blob, int node,
1724397a2a8SSimon Glass const char *prop_name, fdt_size_t *sizep)
173b5220bc6SSimon Glass {
174d93b9a07SStephen Warren int ns = sizep ? (sizeof(fdt_size_t) / sizeof(fdt32_t)) : 0;
175d93b9a07SStephen Warren
17602464e38SStephen Warren return fdtdec_get_addr_size_fixed(blob, node, prop_name, 0,
17702464e38SStephen Warren sizeof(fdt_addr_t) / sizeof(fdt32_t),
1786e06acb7SStephen Warren ns, sizep, false);
179b5220bc6SSimon Glass }
180b5220bc6SSimon Glass
fdtdec_get_addr(const void * blob,int node,const char * prop_name)1812e38662dSMario Six fdt_addr_t fdtdec_get_addr(const void *blob, int node, const char *prop_name)
1824397a2a8SSimon Glass {
1834397a2a8SSimon Glass return fdtdec_get_addr_size(blob, node, prop_name, NULL);
1844397a2a8SSimon Glass }
1854397a2a8SSimon Glass
186d50d6817SSekhar Nori #if CONFIG_IS_ENABLED(PCI) && defined(CONFIG_DM_PCI)
fdtdec_get_pci_addr(const void * blob,int node,enum fdt_pci_space type,const char * prop_name,struct fdt_pci_addr * addr)187a62e84d7SBin Meng int fdtdec_get_pci_addr(const void *blob, int node, enum fdt_pci_space type,
188a62e84d7SBin Meng const char *prop_name, struct fdt_pci_addr *addr)
189a62e84d7SBin Meng {
190a62e84d7SBin Meng const u32 *cell;
191a62e84d7SBin Meng int len;
192a62e84d7SBin Meng int ret = -ENOENT;
193a62e84d7SBin Meng
194a62e84d7SBin Meng debug("%s: %s: ", __func__, prop_name);
195a62e84d7SBin Meng
196a62e84d7SBin Meng /*
197a62e84d7SBin Meng * If we follow the pci bus bindings strictly, we should check
198a62e84d7SBin Meng * the value of the node's parent node's #address-cells and
199a62e84d7SBin Meng * #size-cells. They need to be 3 and 2 accordingly. However,
200a62e84d7SBin Meng * for simplicity we skip the check here.
201a62e84d7SBin Meng */
202a62e84d7SBin Meng cell = fdt_getprop(blob, node, prop_name, &len);
203a62e84d7SBin Meng if (!cell)
204a62e84d7SBin Meng goto fail;
205a62e84d7SBin Meng
206a62e84d7SBin Meng if ((len % FDT_PCI_REG_SIZE) == 0) {
207a62e84d7SBin Meng int num = len / FDT_PCI_REG_SIZE;
208a62e84d7SBin Meng int i;
209a62e84d7SBin Meng
210a62e84d7SBin Meng for (i = 0; i < num; i++) {
211a62e84d7SBin Meng debug("pci address #%d: %08lx %08lx %08lx\n", i,
2124ea5243aSStephen Warren (ulong)fdt32_to_cpu(cell[0]),
2134ea5243aSStephen Warren (ulong)fdt32_to_cpu(cell[1]),
2144ea5243aSStephen Warren (ulong)fdt32_to_cpu(cell[2]));
2154ea5243aSStephen Warren if ((fdt32_to_cpu(*cell) & type) == type) {
2164ea5243aSStephen Warren addr->phys_hi = fdt32_to_cpu(cell[0]);
2174ea5243aSStephen Warren addr->phys_mid = fdt32_to_cpu(cell[1]);
2184ea5243aSStephen Warren addr->phys_lo = fdt32_to_cpu(cell[1]);
219a62e84d7SBin Meng break;
220b79221a7SMario Six }
221b79221a7SMario Six
222a62e84d7SBin Meng cell += (FDT_PCI_ADDR_CELLS +
223a62e84d7SBin Meng FDT_PCI_SIZE_CELLS);
224a62e84d7SBin Meng }
225a62e84d7SBin Meng
226106cce96SSimon Glass if (i == num) {
227106cce96SSimon Glass ret = -ENXIO;
228a62e84d7SBin Meng goto fail;
229106cce96SSimon Glass }
230a62e84d7SBin Meng
231a62e84d7SBin Meng return 0;
232a62e84d7SBin Meng }
233a62e84d7SBin Meng
234b79221a7SMario Six ret = -EINVAL;
235b79221a7SMario Six
236a62e84d7SBin Meng fail:
237a62e84d7SBin Meng debug("(not found)\n");
238a62e84d7SBin Meng return ret;
239a62e84d7SBin Meng }
240a62e84d7SBin Meng
fdtdec_get_pci_vendev(const void * blob,int node,u16 * vendor,u16 * device)241a62e84d7SBin Meng int fdtdec_get_pci_vendev(const void *blob, int node, u16 *vendor, u16 *device)
242a62e84d7SBin Meng {
243a62e84d7SBin Meng const char *list, *end;
244a62e84d7SBin Meng int len;
245a62e84d7SBin Meng
246a62e84d7SBin Meng list = fdt_getprop(blob, node, "compatible", &len);
247a62e84d7SBin Meng if (!list)
248a62e84d7SBin Meng return -ENOENT;
249a62e84d7SBin Meng
250a62e84d7SBin Meng end = list + len;
251a62e84d7SBin Meng while (list < end) {
252a62e84d7SBin Meng len = strlen(list);
253a62e84d7SBin Meng if (len >= strlen("pciVVVV,DDDD")) {
254b79221a7SMario Six char *s = strstr(list, "pci");
255a62e84d7SBin Meng
256a62e84d7SBin Meng /*
257a62e84d7SBin Meng * check if the string is something like pciVVVV,DDDD.RR
258a62e84d7SBin Meng * or just pciVVVV,DDDD
259a62e84d7SBin Meng */
260a62e84d7SBin Meng if (s && s[7] == ',' &&
261a62e84d7SBin Meng (s[12] == '.' || s[12] == 0)) {
262a62e84d7SBin Meng s += 3;
263a62e84d7SBin Meng *vendor = simple_strtol(s, NULL, 16);
264a62e84d7SBin Meng
265a62e84d7SBin Meng s += 5;
266a62e84d7SBin Meng *device = simple_strtol(s, NULL, 16);
267a62e84d7SBin Meng
268a62e84d7SBin Meng return 0;
269a62e84d7SBin Meng }
270a62e84d7SBin Meng }
271bc6351ebSBin Meng list += (len + 1);
272a62e84d7SBin Meng }
273a62e84d7SBin Meng
274a62e84d7SBin Meng return -ENOENT;
275a62e84d7SBin Meng }
276a62e84d7SBin Meng
fdtdec_get_pci_bar32(struct udevice * dev,struct fdt_pci_addr * addr,u32 * bar)277fcc0a877SSimon Glass int fdtdec_get_pci_bar32(struct udevice *dev, struct fdt_pci_addr *addr,
278fcc0a877SSimon Glass u32 *bar)
279a62e84d7SBin Meng {
280a62e84d7SBin Meng int barnum;
281a62e84d7SBin Meng
282a62e84d7SBin Meng /* extract the bar number from fdt_pci_addr */
283a62e84d7SBin Meng barnum = addr->phys_hi & 0xff;
284b79221a7SMario Six if (barnum < PCI_BASE_ADDRESS_0 || barnum > PCI_CARDBUS_CIS)
285a62e84d7SBin Meng return -EINVAL;
286a62e84d7SBin Meng
287a62e84d7SBin Meng barnum = (barnum - PCI_BASE_ADDRESS_0) / 4;
288fcc0a877SSimon Glass *bar = dm_pci_read_bar32(dev, barnum);
289a62e84d7SBin Meng
290a62e84d7SBin Meng return 0;
291a62e84d7SBin Meng }
292a62e84d7SBin Meng #endif
293a62e84d7SBin Meng
fdtdec_get_uint64(const void * blob,int node,const char * prop_name,uint64_t default_val)294aadef0a1SChe-Liang Chiou uint64_t fdtdec_get_uint64(const void *blob, int node, const char *prop_name,
295aadef0a1SChe-Liang Chiou uint64_t default_val)
296aadef0a1SChe-Liang Chiou {
297aadef0a1SChe-Liang Chiou const uint64_t *cell64;
298aadef0a1SChe-Liang Chiou int length;
299aadef0a1SChe-Liang Chiou
300aadef0a1SChe-Liang Chiou cell64 = fdt_getprop(blob, node, prop_name, &length);
301aadef0a1SChe-Liang Chiou if (!cell64 || length < sizeof(*cell64))
302aadef0a1SChe-Liang Chiou return default_val;
303aadef0a1SChe-Liang Chiou
304aadef0a1SChe-Liang Chiou return fdt64_to_cpu(*cell64);
305aadef0a1SChe-Liang Chiou }
306aadef0a1SChe-Liang Chiou
fdtdec_get_is_enabled(const void * blob,int node)307f88fe2deSSimon Glass int fdtdec_get_is_enabled(const void *blob, int node)
308b5220bc6SSimon Glass {
309b5220bc6SSimon Glass const char *cell;
310b5220bc6SSimon Glass
311f88fe2deSSimon Glass /*
312f88fe2deSSimon Glass * It should say "okay", so only allow that. Some fdts use "ok" but
313f88fe2deSSimon Glass * this is a bug. Please fix your device tree source file. See here
314f88fe2deSSimon Glass * for discussion:
315f88fe2deSSimon Glass *
316f88fe2deSSimon Glass * http://www.mail-archive.com/u-boot@lists.denx.de/msg71598.html
317f88fe2deSSimon Glass */
318b5220bc6SSimon Glass cell = fdt_getprop(blob, node, "status", NULL);
319b5220bc6SSimon Glass if (cell)
320b79221a7SMario Six return strcmp(cell, "okay") == 0;
321f88fe2deSSimon Glass return 1;
322b5220bc6SSimon Glass }
323b5220bc6SSimon Glass
fdtdec_lookup(const void * blob,int node)3247cde397bSGerald Van Baren enum fdt_compat_id fdtdec_lookup(const void *blob, int node)
325b5220bc6SSimon Glass {
326b5220bc6SSimon Glass enum fdt_compat_id id;
327b5220bc6SSimon Glass
328b5220bc6SSimon Glass /* Search our drivers */
329b5220bc6SSimon Glass for (id = COMPAT_UNKNOWN; id < COMPAT_COUNT; id++)
330b79221a7SMario Six if (fdt_node_check_compatible(blob, node,
331b79221a7SMario Six compat_names[id]) == 0)
332b5220bc6SSimon Glass return id;
333b5220bc6SSimon Glass return COMPAT_UNKNOWN;
334b5220bc6SSimon Glass }
335b5220bc6SSimon Glass
fdtdec_next_compatible(const void * blob,int node,enum fdt_compat_id id)3362e38662dSMario Six int fdtdec_next_compatible(const void *blob, int node, enum fdt_compat_id id)
337b5220bc6SSimon Glass {
338b5220bc6SSimon Glass return fdt_node_offset_by_compatible(blob, node, compat_names[id]);
339b5220bc6SSimon Glass }
340b5220bc6SSimon Glass
fdtdec_next_compatible_subnode(const void * blob,int node,enum fdt_compat_id id,int * depthp)3413ddecfc7SSimon Glass int fdtdec_next_compatible_subnode(const void *blob, int node,
3423ddecfc7SSimon Glass enum fdt_compat_id id, int *depthp)
3433ddecfc7SSimon Glass {
3443ddecfc7SSimon Glass do {
3453ddecfc7SSimon Glass node = fdt_next_node(blob, node, depthp);
3463ddecfc7SSimon Glass } while (*depthp > 1);
3473ddecfc7SSimon Glass
3483ddecfc7SSimon Glass /* If this is a direct subnode, and compatible, return it */
3493ddecfc7SSimon Glass if (*depthp == 1 && 0 == fdt_node_check_compatible(
3503ddecfc7SSimon Glass blob, node, compat_names[id]))
3513ddecfc7SSimon Glass return node;
3523ddecfc7SSimon Glass
3533ddecfc7SSimon Glass return -FDT_ERR_NOTFOUND;
3543ddecfc7SSimon Glass }
3553ddecfc7SSimon Glass
fdtdec_next_alias(const void * blob,const char * name,enum fdt_compat_id id,int * upto)3562e38662dSMario Six int fdtdec_next_alias(const void *blob, const char *name, enum fdt_compat_id id,
3572e38662dSMario Six int *upto)
358b5220bc6SSimon Glass {
359b5220bc6SSimon Glass #define MAX_STR_LEN 20
360b5220bc6SSimon Glass char str[MAX_STR_LEN + 20];
361b5220bc6SSimon Glass int node, err;
362b5220bc6SSimon Glass
363b5220bc6SSimon Glass /* snprintf() is not available */
364b5220bc6SSimon Glass assert(strlen(name) < MAX_STR_LEN);
365b5220bc6SSimon Glass sprintf(str, "%.*s%d", MAX_STR_LEN, name, *upto);
36600878476SSimon Glass node = fdt_path_offset(blob, str);
367b5220bc6SSimon Glass if (node < 0)
368b5220bc6SSimon Glass return node;
369b5220bc6SSimon Glass err = fdt_node_check_compatible(blob, node, compat_names[id]);
370b5220bc6SSimon Glass if (err < 0)
371b5220bc6SSimon Glass return err;
372f88fe2deSSimon Glass if (err)
373f88fe2deSSimon Glass return -FDT_ERR_NOTFOUND;
374f88fe2deSSimon Glass (*upto)++;
375f88fe2deSSimon Glass return node;
376b5220bc6SSimon Glass }
377b5220bc6SSimon Glass
fdtdec_find_aliases_for_id(const void * blob,const char * name,enum fdt_compat_id id,int * node_list,int maxcount)378a53f4a29SSimon Glass int fdtdec_find_aliases_for_id(const void *blob, const char *name,
3792e38662dSMario Six enum fdt_compat_id id, int *node_list,
3802e38662dSMario Six int maxcount)
381a53f4a29SSimon Glass {
382c6782270SSimon Glass memset(node_list, '\0', sizeof(*node_list) * maxcount);
383c6782270SSimon Glass
384c6782270SSimon Glass return fdtdec_add_aliases_for_id(blob, name, id, node_list, maxcount);
385c6782270SSimon Glass }
386c6782270SSimon Glass
387c6782270SSimon Glass /* TODO: Can we tighten this code up a little? */
fdtdec_add_aliases_for_id(const void * blob,const char * name,enum fdt_compat_id id,int * node_list,int maxcount)388c6782270SSimon Glass int fdtdec_add_aliases_for_id(const void *blob, const char *name,
3892e38662dSMario Six enum fdt_compat_id id, int *node_list,
3902e38662dSMario Six int maxcount)
391c6782270SSimon Glass {
392a53f4a29SSimon Glass int name_len = strlen(name);
393a53f4a29SSimon Glass int nodes[maxcount];
394a53f4a29SSimon Glass int num_found = 0;
395a53f4a29SSimon Glass int offset, node;
396a53f4a29SSimon Glass int alias_node;
397a53f4a29SSimon Glass int count;
398a53f4a29SSimon Glass int i, j;
399a53f4a29SSimon Glass
400a53f4a29SSimon Glass /* find the alias node if present */
401a53f4a29SSimon Glass alias_node = fdt_path_offset(blob, "/aliases");
402a53f4a29SSimon Glass
403a53f4a29SSimon Glass /*
404a53f4a29SSimon Glass * start with nothing, and we can assume that the root node can't
405a53f4a29SSimon Glass * match
406a53f4a29SSimon Glass */
407a53f4a29SSimon Glass memset(nodes, '\0', sizeof(nodes));
408a53f4a29SSimon Glass
409a53f4a29SSimon Glass /* First find all the compatible nodes */
410a53f4a29SSimon Glass for (node = count = 0; node >= 0 && count < maxcount;) {
411a53f4a29SSimon Glass node = fdtdec_next_compatible(blob, node, id);
412a53f4a29SSimon Glass if (node >= 0)
413a53f4a29SSimon Glass nodes[count++] = node;
414a53f4a29SSimon Glass }
415a53f4a29SSimon Glass if (node >= 0)
416a53f4a29SSimon Glass debug("%s: warning: maxcount exceeded with alias '%s'\n",
417a53f4a29SSimon Glass __func__, name);
418a53f4a29SSimon Glass
419a53f4a29SSimon Glass /* Now find all the aliases */
420a53f4a29SSimon Glass for (offset = fdt_first_property_offset(blob, alias_node);
421a53f4a29SSimon Glass offset > 0;
422a53f4a29SSimon Glass offset = fdt_next_property_offset(blob, offset)) {
423a53f4a29SSimon Glass const struct fdt_property *prop;
424a53f4a29SSimon Glass const char *path;
425a53f4a29SSimon Glass int number;
426a53f4a29SSimon Glass int found;
427a53f4a29SSimon Glass
428a53f4a29SSimon Glass node = 0;
429a53f4a29SSimon Glass prop = fdt_get_property_by_offset(blob, offset, NULL);
430a53f4a29SSimon Glass path = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
431a53f4a29SSimon Glass if (prop->len && 0 == strncmp(path, name, name_len))
432a53f4a29SSimon Glass node = fdt_path_offset(blob, prop->data);
433a53f4a29SSimon Glass if (node <= 0)
434a53f4a29SSimon Glass continue;
435a53f4a29SSimon Glass
436a53f4a29SSimon Glass /* Get the alias number */
437a53f4a29SSimon Glass number = simple_strtoul(path + name_len, NULL, 10);
438a53f4a29SSimon Glass if (number < 0 || number >= maxcount) {
439a53f4a29SSimon Glass debug("%s: warning: alias '%s' is out of range\n",
440a53f4a29SSimon Glass __func__, path);
441a53f4a29SSimon Glass continue;
442a53f4a29SSimon Glass }
443a53f4a29SSimon Glass
444a53f4a29SSimon Glass /* Make sure the node we found is actually in our list! */
445a53f4a29SSimon Glass found = -1;
446a53f4a29SSimon Glass for (j = 0; j < count; j++)
447a53f4a29SSimon Glass if (nodes[j] == node) {
448a53f4a29SSimon Glass found = j;
449a53f4a29SSimon Glass break;
450a53f4a29SSimon Glass }
451a53f4a29SSimon Glass
452a53f4a29SSimon Glass if (found == -1) {
453a53f4a29SSimon Glass debug("%s: warning: alias '%s' points to a node "
454a53f4a29SSimon Glass "'%s' that is missing or is not compatible "
455a53f4a29SSimon Glass " with '%s'\n", __func__, path,
456a53f4a29SSimon Glass fdt_get_name(blob, node, NULL),
457a53f4a29SSimon Glass compat_names[id]);
458a53f4a29SSimon Glass continue;
459a53f4a29SSimon Glass }
460a53f4a29SSimon Glass
461a53f4a29SSimon Glass /*
462a53f4a29SSimon Glass * Add this node to our list in the right place, and mark
463a53f4a29SSimon Glass * it as done.
464a53f4a29SSimon Glass */
465a53f4a29SSimon Glass if (fdtdec_get_is_enabled(blob, node)) {
466c6782270SSimon Glass if (node_list[number]) {
467c6782270SSimon Glass debug("%s: warning: alias '%s' requires that "
468c6782270SSimon Glass "a node be placed in the list in a "
469c6782270SSimon Glass "position which is already filled by "
470c6782270SSimon Glass "node '%s'\n", __func__, path,
471c6782270SSimon Glass fdt_get_name(blob, node, NULL));
472c6782270SSimon Glass continue;
473c6782270SSimon Glass }
474a53f4a29SSimon Glass node_list[number] = node;
475a53f4a29SSimon Glass if (number >= num_found)
476a53f4a29SSimon Glass num_found = number + 1;
477a53f4a29SSimon Glass }
478c6782270SSimon Glass nodes[found] = 0;
479a53f4a29SSimon Glass }
480a53f4a29SSimon Glass
481a53f4a29SSimon Glass /* Add any nodes not mentioned by an alias */
482a53f4a29SSimon Glass for (i = j = 0; i < maxcount; i++) {
483a53f4a29SSimon Glass if (!node_list[i]) {
484a53f4a29SSimon Glass for (; j < maxcount; j++)
485a53f4a29SSimon Glass if (nodes[j] &&
486a53f4a29SSimon Glass fdtdec_get_is_enabled(blob, nodes[j]))
487a53f4a29SSimon Glass break;
488a53f4a29SSimon Glass
489a53f4a29SSimon Glass /* Have we run out of nodes to add? */
490a53f4a29SSimon Glass if (j == maxcount)
491a53f4a29SSimon Glass break;
492a53f4a29SSimon Glass
493a53f4a29SSimon Glass assert(!node_list[i]);
494a53f4a29SSimon Glass node_list[i] = nodes[j++];
495a53f4a29SSimon Glass if (i >= num_found)
496a53f4a29SSimon Glass num_found = i + 1;
497a53f4a29SSimon Glass }
498a53f4a29SSimon Glass }
499a53f4a29SSimon Glass
500a53f4a29SSimon Glass return num_found;
501a53f4a29SSimon Glass }
502a53f4a29SSimon Glass
fdtdec_get_alias_seq(const void * blob,const char * base,int offset,int * seqp)5035c33c9fdSSimon Glass int fdtdec_get_alias_seq(const void *blob, const char *base, int offset,
5045c33c9fdSSimon Glass int *seqp)
5055c33c9fdSSimon Glass {
5065c33c9fdSSimon Glass int base_len = strlen(base);
5075c33c9fdSSimon Glass const char *find_name;
5085c33c9fdSSimon Glass int find_namelen;
5095c33c9fdSSimon Glass int prop_offset;
5105c33c9fdSSimon Glass int aliases;
5115c33c9fdSSimon Glass
5125c33c9fdSSimon Glass find_name = fdt_get_name(blob, offset, &find_namelen);
5135c33c9fdSSimon Glass debug("Looking for '%s' at %d, name %s\n", base, offset, find_name);
5145c33c9fdSSimon Glass
5155c33c9fdSSimon Glass aliases = fdt_path_offset(blob, "/aliases");
5165c33c9fdSSimon Glass for (prop_offset = fdt_first_property_offset(blob, aliases);
5175c33c9fdSSimon Glass prop_offset > 0;
5185c33c9fdSSimon Glass prop_offset = fdt_next_property_offset(blob, prop_offset)) {
5195c33c9fdSSimon Glass const char *prop;
5205c33c9fdSSimon Glass const char *name;
5215c33c9fdSSimon Glass const char *slash;
522c4af6732SSimon Glass int len, val;
5235c33c9fdSSimon Glass
5245c33c9fdSSimon Glass prop = fdt_getprop_by_offset(blob, prop_offset, &name, &len);
5255c33c9fdSSimon Glass debug(" - %s, %s\n", name, prop);
5265c33c9fdSSimon Glass if (len < find_namelen || *prop != '/' || prop[len - 1] ||
5275c33c9fdSSimon Glass strncmp(name, base, base_len))
5285c33c9fdSSimon Glass continue;
5295c33c9fdSSimon Glass
5305c33c9fdSSimon Glass slash = strrchr(prop, '/');
5315c33c9fdSSimon Glass if (strcmp(slash + 1, find_name))
5325c33c9fdSSimon Glass continue;
533c4af6732SSimon Glass val = trailing_strtol(name);
534c4af6732SSimon Glass if (val != -1) {
535c4af6732SSimon Glass *seqp = val;
5365c33c9fdSSimon Glass debug("Found seq %d\n", *seqp);
5375c33c9fdSSimon Glass return 0;
5385c33c9fdSSimon Glass }
5395c33c9fdSSimon Glass }
5405c33c9fdSSimon Glass
5415c33c9fdSSimon Glass debug("Not found\n");
5425c33c9fdSSimon Glass return -ENOENT;
5435c33c9fdSSimon Glass }
5445c33c9fdSSimon Glass
fdtdec_get_alias_highest_id(const void * blob,const char * base)545*003c9dc8SMichal Simek int fdtdec_get_alias_highest_id(const void *blob, const char *base)
546*003c9dc8SMichal Simek {
547*003c9dc8SMichal Simek int base_len = strlen(base);
548*003c9dc8SMichal Simek int prop_offset;
549*003c9dc8SMichal Simek int aliases;
550*003c9dc8SMichal Simek int max = -1;
551*003c9dc8SMichal Simek
552*003c9dc8SMichal Simek debug("Looking for highest alias id for '%s'\n", base);
553*003c9dc8SMichal Simek
554*003c9dc8SMichal Simek aliases = fdt_path_offset(blob, "/aliases");
555*003c9dc8SMichal Simek for (prop_offset = fdt_first_property_offset(blob, aliases);
556*003c9dc8SMichal Simek prop_offset > 0;
557*003c9dc8SMichal Simek prop_offset = fdt_next_property_offset(blob, prop_offset)) {
558*003c9dc8SMichal Simek const char *prop;
559*003c9dc8SMichal Simek const char *name;
560*003c9dc8SMichal Simek int len, val;
561*003c9dc8SMichal Simek
562*003c9dc8SMichal Simek prop = fdt_getprop_by_offset(blob, prop_offset, &name, &len);
563*003c9dc8SMichal Simek debug(" - %s, %s\n", name, prop);
564*003c9dc8SMichal Simek if (*prop != '/' || prop[len - 1] ||
565*003c9dc8SMichal Simek strncmp(name, base, base_len))
566*003c9dc8SMichal Simek continue;
567*003c9dc8SMichal Simek
568*003c9dc8SMichal Simek val = trailing_strtol(name);
569*003c9dc8SMichal Simek if (val > max) {
570*003c9dc8SMichal Simek debug("Found seq %d\n", val);
571*003c9dc8SMichal Simek max = val;
572*003c9dc8SMichal Simek }
573*003c9dc8SMichal Simek }
574*003c9dc8SMichal Simek
575*003c9dc8SMichal Simek return max;
576*003c9dc8SMichal Simek }
577*003c9dc8SMichal Simek
fdtdec_get_chosen_prop(const void * blob,const char * name)5783bc37a50SSimon Glass const char *fdtdec_get_chosen_prop(const void *blob, const char *name)
5793bc37a50SSimon Glass {
5803bc37a50SSimon Glass int chosen_node;
5813bc37a50SSimon Glass
5823bc37a50SSimon Glass if (!blob)
5833bc37a50SSimon Glass return NULL;
5843bc37a50SSimon Glass chosen_node = fdt_path_offset(blob, "/chosen");
5853bc37a50SSimon Glass return fdt_getprop(blob, chosen_node, name, NULL);
5863bc37a50SSimon Glass }
5873bc37a50SSimon Glass
fdtdec_get_chosen_node(const void * blob,const char * name)588aac07d49SSimon Glass int fdtdec_get_chosen_node(const void *blob, const char *name)
589aac07d49SSimon Glass {
590aac07d49SSimon Glass const char *prop;
591aac07d49SSimon Glass
5923bc37a50SSimon Glass prop = fdtdec_get_chosen_prop(blob, name);
593aac07d49SSimon Glass if (!prop)
594aac07d49SSimon Glass return -FDT_ERR_NOTFOUND;
595aac07d49SSimon Glass return fdt_path_offset(blob, prop);
596aac07d49SSimon Glass }
597aac07d49SSimon Glass
fdtdec_check_fdt(void)5989a263e55SSimon Glass int fdtdec_check_fdt(void)
5999a263e55SSimon Glass {
6009a263e55SSimon Glass /*
6019a263e55SSimon Glass * We must have an FDT, but we cannot panic() yet since the console
6029a263e55SSimon Glass * is not ready. So for now, just assert(). Boards which need an early
6039a263e55SSimon Glass * FDT (prior to console ready) will need to make their own
6049a263e55SSimon Glass * arrangements and do their own checks.
6059a263e55SSimon Glass */
6069a263e55SSimon Glass assert(!fdtdec_prepare_fdt());
6079a263e55SSimon Glass return 0;
6089a263e55SSimon Glass }
6099a263e55SSimon Glass
610b5220bc6SSimon Glass /*
611b5220bc6SSimon Glass * This function is a little odd in that it accesses global data. At some
612b5220bc6SSimon Glass * point if the architecture board.c files merge this will make more sense.
613b5220bc6SSimon Glass * Even now, it is common code.
614b5220bc6SSimon Glass */
fdtdec_prepare_fdt(void)6159a263e55SSimon Glass int fdtdec_prepare_fdt(void)
616b5220bc6SSimon Glass {
617c309c2daSSimon Glass if (!gd->fdt_blob || ((uintptr_t)gd->fdt_blob & 3) ||
618c309c2daSSimon Glass fdt_check_header(gd->fdt_blob)) {
61966312374SSimon Glass #ifdef CONFIG_SPL_BUILD
62066312374SSimon Glass puts("Missing DTB\n");
62166312374SSimon Glass #else
62266312374SSimon Glass puts("No valid device tree binary found - please append one to U-Boot binary, use u-boot-dtb.bin or define CONFIG_OF_EMBED. For sandbox, use -d <file.dtb>\n");
623cb5f97f7SSimon Glass # ifdef DEBUG
624cb5f97f7SSimon Glass if (gd->fdt_blob) {
625cb5f97f7SSimon Glass printf("fdt_blob=%p\n", gd->fdt_blob);
626cb5f97f7SSimon Glass print_buffer((ulong)gd->fdt_blob, gd->fdt_blob, 4,
627cb5f97f7SSimon Glass 32, 0);
628cb5f97f7SSimon Glass }
629cb5f97f7SSimon Glass # endif
63066312374SSimon Glass #endif
6319a263e55SSimon Glass return -1;
6329a263e55SSimon Glass }
633b5220bc6SSimon Glass return 0;
634b5220bc6SSimon Glass }
635d17da655SSimon Glass
fdtdec_lookup_phandle(const void * blob,int node,const char * prop_name)636d17da655SSimon Glass int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name)
637d17da655SSimon Glass {
638d17da655SSimon Glass const u32 *phandle;
639d17da655SSimon Glass int lookup;
640d17da655SSimon Glass
6411cb2323bSSimon Glass debug("%s: %s\n", __func__, prop_name);
642d17da655SSimon Glass phandle = fdt_getprop(blob, node, prop_name, NULL);
643d17da655SSimon Glass if (!phandle)
644d17da655SSimon Glass return -FDT_ERR_NOTFOUND;
645d17da655SSimon Glass
646d17da655SSimon Glass lookup = fdt_node_offset_by_phandle(blob, fdt32_to_cpu(*phandle));
647d17da655SSimon Glass return lookup;
648d17da655SSimon Glass }
649d17da655SSimon Glass
650d17da655SSimon Glass /**
651d17da655SSimon Glass * Look up a property in a node and check that it has a minimum length.
652d17da655SSimon Glass *
653d17da655SSimon Glass * @param blob FDT blob
654d17da655SSimon Glass * @param node node to examine
655d17da655SSimon Glass * @param prop_name name of property to find
656d17da655SSimon Glass * @param min_len minimum property length in bytes
657d17da655SSimon Glass * @param err 0 if ok, or -FDT_ERR_NOTFOUND if the property is not
658d17da655SSimon Glass found, or -FDT_ERR_BADLAYOUT if not enough data
659d17da655SSimon Glass * @return pointer to cell, which is only valid if err == 0
660d17da655SSimon Glass */
get_prop_check_min_len(const void * blob,int node,const char * prop_name,int min_len,int * err)661d17da655SSimon Glass static const void *get_prop_check_min_len(const void *blob, int node,
6622e38662dSMario Six const char *prop_name, int min_len,
6632e38662dSMario Six int *err)
664d17da655SSimon Glass {
665d17da655SSimon Glass const void *cell;
666d17da655SSimon Glass int len;
667d17da655SSimon Glass
668d17da655SSimon Glass debug("%s: %s\n", __func__, prop_name);
669d17da655SSimon Glass cell = fdt_getprop(blob, node, prop_name, &len);
670d17da655SSimon Glass if (!cell)
671d17da655SSimon Glass *err = -FDT_ERR_NOTFOUND;
672d17da655SSimon Glass else if (len < min_len)
673d17da655SSimon Glass *err = -FDT_ERR_BADLAYOUT;
674d17da655SSimon Glass else
675d17da655SSimon Glass *err = 0;
676d17da655SSimon Glass return cell;
677d17da655SSimon Glass }
678d17da655SSimon Glass
fdtdec_get_int_array(const void * blob,int node,const char * prop_name,u32 * array,int count)679d17da655SSimon Glass int fdtdec_get_int_array(const void *blob, int node, const char *prop_name,
680d17da655SSimon Glass u32 *array, int count)
681d17da655SSimon Glass {
682d17da655SSimon Glass const u32 *cell;
683b79221a7SMario Six int err = 0;
684d17da655SSimon Glass
685d17da655SSimon Glass debug("%s: %s\n", __func__, prop_name);
686d17da655SSimon Glass cell = get_prop_check_min_len(blob, node, prop_name,
687d17da655SSimon Glass sizeof(u32) * count, &err);
688d17da655SSimon Glass if (!err) {
689b79221a7SMario Six int i;
690b79221a7SMario Six
691d17da655SSimon Glass for (i = 0; i < count; i++)
692d17da655SSimon Glass array[i] = fdt32_to_cpu(cell[i]);
693d17da655SSimon Glass }
694d17da655SSimon Glass return err;
695d17da655SSimon Glass }
696d17da655SSimon Glass
fdtdec_get_int_array_count(const void * blob,int node,const char * prop_name,u32 * array,int count)697a9f04d49SSimon Glass int fdtdec_get_int_array_count(const void *blob, int node,
698a9f04d49SSimon Glass const char *prop_name, u32 *array, int count)
699a9f04d49SSimon Glass {
700a9f04d49SSimon Glass const u32 *cell;
701a9f04d49SSimon Glass int len, elems;
702a9f04d49SSimon Glass int i;
703a9f04d49SSimon Glass
704a9f04d49SSimon Glass debug("%s: %s\n", __func__, prop_name);
705a9f04d49SSimon Glass cell = fdt_getprop(blob, node, prop_name, &len);
706a9f04d49SSimon Glass if (!cell)
707a9f04d49SSimon Glass return -FDT_ERR_NOTFOUND;
708a9f04d49SSimon Glass elems = len / sizeof(u32);
709a9f04d49SSimon Glass if (count > elems)
710a9f04d49SSimon Glass count = elems;
711a9f04d49SSimon Glass for (i = 0; i < count; i++)
712a9f04d49SSimon Glass array[i] = fdt32_to_cpu(cell[i]);
713a9f04d49SSimon Glass
714a9f04d49SSimon Glass return count;
715a9f04d49SSimon Glass }
716a9f04d49SSimon Glass
fdtdec_locate_array(const void * blob,int node,const char * prop_name,int count)71796875e7dSSimon Glass const u32 *fdtdec_locate_array(const void *blob, int node,
71896875e7dSSimon Glass const char *prop_name, int count)
71996875e7dSSimon Glass {
72096875e7dSSimon Glass const u32 *cell;
72196875e7dSSimon Glass int err;
72296875e7dSSimon Glass
72396875e7dSSimon Glass cell = get_prop_check_min_len(blob, node, prop_name,
72496875e7dSSimon Glass sizeof(u32) * count, &err);
72596875e7dSSimon Glass return err ? NULL : cell;
72696875e7dSSimon Glass }
72796875e7dSSimon Glass
fdtdec_get_bool(const void * blob,int node,const char * prop_name)728d17da655SSimon Glass int fdtdec_get_bool(const void *blob, int node, const char *prop_name)
729d17da655SSimon Glass {
730d17da655SSimon Glass const s32 *cell;
731d17da655SSimon Glass int len;
732d17da655SSimon Glass
733d17da655SSimon Glass debug("%s: %s\n", __func__, prop_name);
734d17da655SSimon Glass cell = fdt_getprop(blob, node, prop_name, &len);
735d17da655SSimon Glass return cell != NULL;
736d17da655SSimon Glass }
737ed3ee5cdSSimon Glass
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)73857068a7aSSimon Glass int fdtdec_parse_phandle_with_args(const void *blob, int src_node,
73957068a7aSSimon Glass const char *list_name,
74057068a7aSSimon Glass const char *cells_name,
74157068a7aSSimon Glass int cell_count, int index,
74257068a7aSSimon Glass struct fdtdec_phandle_args *out_args)
74357068a7aSSimon Glass {
74457068a7aSSimon Glass const __be32 *list, *list_end;
74557068a7aSSimon Glass int rc = 0, size, cur_index = 0;
74657068a7aSSimon Glass uint32_t count = 0;
74757068a7aSSimon Glass int node = -1;
74857068a7aSSimon Glass int phandle;
74957068a7aSSimon Glass
75057068a7aSSimon Glass /* Retrieve the phandle list property */
75157068a7aSSimon Glass list = fdt_getprop(blob, src_node, list_name, &size);
75257068a7aSSimon Glass if (!list)
75357068a7aSSimon Glass return -ENOENT;
75457068a7aSSimon Glass list_end = list + size / sizeof(*list);
75557068a7aSSimon Glass
75657068a7aSSimon Glass /* Loop over the phandles until all the requested entry is found */
75757068a7aSSimon Glass while (list < list_end) {
75857068a7aSSimon Glass rc = -EINVAL;
75957068a7aSSimon Glass count = 0;
76057068a7aSSimon Glass
76157068a7aSSimon Glass /*
76257068a7aSSimon Glass * If phandle is 0, then it is an empty entry with no
76357068a7aSSimon Glass * arguments. Skip forward to the next entry.
76457068a7aSSimon Glass */
76557068a7aSSimon Glass phandle = be32_to_cpup(list++);
76657068a7aSSimon Glass if (phandle) {
76757068a7aSSimon Glass /*
76857068a7aSSimon Glass * Find the provider node and parse the #*-cells
76957068a7aSSimon Glass * property to determine the argument length.
77057068a7aSSimon Glass *
77157068a7aSSimon Glass * This is not needed if the cell count is hard-coded
77257068a7aSSimon Glass * (i.e. cells_name not set, but cell_count is set),
77357068a7aSSimon Glass * except when we're going to return the found node
77457068a7aSSimon Glass * below.
77557068a7aSSimon Glass */
77657068a7aSSimon Glass if (cells_name || cur_index == index) {
77757068a7aSSimon Glass node = fdt_node_offset_by_phandle(blob,
77857068a7aSSimon Glass phandle);
77957068a7aSSimon Glass if (!node) {
78057068a7aSSimon Glass debug("%s: could not find phandle\n",
78157068a7aSSimon Glass fdt_get_name(blob, src_node,
78257068a7aSSimon Glass NULL));
78357068a7aSSimon Glass goto err;
78457068a7aSSimon Glass }
78557068a7aSSimon Glass }
78657068a7aSSimon Glass
78757068a7aSSimon Glass if (cells_name) {
78857068a7aSSimon Glass count = fdtdec_get_int(blob, node, cells_name,
78957068a7aSSimon Glass -1);
79057068a7aSSimon Glass if (count == -1) {
79157068a7aSSimon Glass debug("%s: could not get %s for %s\n",
79257068a7aSSimon Glass fdt_get_name(blob, src_node,
79357068a7aSSimon Glass NULL),
79457068a7aSSimon Glass cells_name,
79557068a7aSSimon Glass fdt_get_name(blob, node,
79657068a7aSSimon Glass NULL));
79757068a7aSSimon Glass goto err;
79857068a7aSSimon Glass }
79957068a7aSSimon Glass } else {
80057068a7aSSimon Glass count = cell_count;
80157068a7aSSimon Glass }
80257068a7aSSimon Glass
80357068a7aSSimon Glass /*
80457068a7aSSimon Glass * Make sure that the arguments actually fit in the
80557068a7aSSimon Glass * remaining property data length
80657068a7aSSimon Glass */
80757068a7aSSimon Glass if (list + count > list_end) {
80857068a7aSSimon Glass debug("%s: arguments longer than property\n",
80957068a7aSSimon Glass fdt_get_name(blob, src_node, NULL));
81057068a7aSSimon Glass goto err;
81157068a7aSSimon Glass }
81257068a7aSSimon Glass }
81357068a7aSSimon Glass
81457068a7aSSimon Glass /*
81557068a7aSSimon Glass * All of the error cases above bail out of the loop, so at
81657068a7aSSimon Glass * this point, the parsing is successful. If the requested
81757068a7aSSimon Glass * index matches, then fill the out_args structure and return,
81857068a7aSSimon Glass * or return -ENOENT for an empty entry.
81957068a7aSSimon Glass */
82057068a7aSSimon Glass rc = -ENOENT;
82157068a7aSSimon Glass if (cur_index == index) {
82257068a7aSSimon Glass if (!phandle)
82357068a7aSSimon Glass goto err;
82457068a7aSSimon Glass
82557068a7aSSimon Glass if (out_args) {
82657068a7aSSimon Glass int i;
82757068a7aSSimon Glass
82857068a7aSSimon Glass if (count > MAX_PHANDLE_ARGS) {
82957068a7aSSimon Glass debug("%s: too many arguments %d\n",
83057068a7aSSimon Glass fdt_get_name(blob, src_node,
83157068a7aSSimon Glass NULL), count);
83257068a7aSSimon Glass count = MAX_PHANDLE_ARGS;
83357068a7aSSimon Glass }
83457068a7aSSimon Glass out_args->node = node;
83557068a7aSSimon Glass out_args->args_count = count;
83657068a7aSSimon Glass for (i = 0; i < count; i++) {
83757068a7aSSimon Glass out_args->args[i] =
83857068a7aSSimon Glass be32_to_cpup(list++);
83957068a7aSSimon Glass }
84057068a7aSSimon Glass }
84157068a7aSSimon Glass
84257068a7aSSimon Glass /* Found it! return success */
84357068a7aSSimon Glass return 0;
84457068a7aSSimon Glass }
84557068a7aSSimon Glass
84657068a7aSSimon Glass node = -1;
84757068a7aSSimon Glass list += count;
84857068a7aSSimon Glass cur_index++;
84957068a7aSSimon Glass }
85057068a7aSSimon Glass
85157068a7aSSimon Glass /*
85257068a7aSSimon Glass * Result will be one of:
85357068a7aSSimon Glass * -ENOENT : index is for empty phandle
85457068a7aSSimon Glass * -EINVAL : parsing error on data
85557068a7aSSimon Glass * [1..n] : Number of phandle (count mode; when index = -1)
85657068a7aSSimon Glass */
85757068a7aSSimon Glass rc = index < 0 ? cur_index : -ENOENT;
85857068a7aSSimon Glass err:
85957068a7aSSimon Glass return rc;
86057068a7aSSimon Glass }
86157068a7aSSimon Glass
fdtdec_get_child_count(const void * blob,int node)8621889a7e2SPeng Fan int fdtdec_get_child_count(const void *blob, int node)
8631889a7e2SPeng Fan {
8641889a7e2SPeng Fan int subnode;
8651889a7e2SPeng Fan int num = 0;
8661889a7e2SPeng Fan
867df87e6b1SSimon Glass fdt_for_each_subnode(subnode, blob, node)
8681889a7e2SPeng Fan num++;
8691889a7e2SPeng Fan
8701889a7e2SPeng Fan return num;
8711889a7e2SPeng Fan }
8721889a7e2SPeng Fan
fdtdec_get_byte_array(const void * blob,int node,const char * prop_name,u8 * array,int count)873bed4d892SAnton Staff int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name,
874bed4d892SAnton Staff u8 *array, int count)
875bed4d892SAnton Staff {
876bed4d892SAnton Staff const u8 *cell;
877bed4d892SAnton Staff int err;
878bed4d892SAnton Staff
879bed4d892SAnton Staff cell = get_prop_check_min_len(blob, node, prop_name, count, &err);
880bed4d892SAnton Staff if (!err)
881bed4d892SAnton Staff memcpy(array, cell, count);
882bed4d892SAnton Staff return err;
883bed4d892SAnton Staff }
884bed4d892SAnton Staff
fdtdec_locate_byte_array(const void * blob,int node,const char * prop_name,int count)885bed4d892SAnton Staff const u8 *fdtdec_locate_byte_array(const void *blob, int node,
886bed4d892SAnton Staff const char *prop_name, int count)
887bed4d892SAnton Staff {
888bed4d892SAnton Staff const u8 *cell;
889bed4d892SAnton Staff int err;
890bed4d892SAnton Staff
891bed4d892SAnton Staff cell = get_prop_check_min_len(blob, node, prop_name, count, &err);
892bed4d892SAnton Staff if (err)
893bed4d892SAnton Staff return NULL;
894bed4d892SAnton Staff return cell;
895bed4d892SAnton Staff }
89609258f1eSAbhilash Kesavan
fdtdec_get_config_int(const void * blob,const char * prop_name,int default_val)89709258f1eSAbhilash Kesavan int fdtdec_get_config_int(const void *blob, const char *prop_name,
89809258f1eSAbhilash Kesavan int default_val)
89909258f1eSAbhilash Kesavan {
90009258f1eSAbhilash Kesavan int config_node;
90109258f1eSAbhilash Kesavan
90209258f1eSAbhilash Kesavan debug("%s: %s\n", __func__, prop_name);
90309258f1eSAbhilash Kesavan config_node = fdt_path_offset(blob, "/config");
90409258f1eSAbhilash Kesavan if (config_node < 0)
90509258f1eSAbhilash Kesavan return default_val;
90609258f1eSAbhilash Kesavan return fdtdec_get_int(blob, config_node, prop_name, default_val);
90709258f1eSAbhilash Kesavan }
908332ab0d5SSimon Glass
fdtdec_get_config_bool(const void * blob,const char * prop_name)90979289c0bSGabe Black int fdtdec_get_config_bool(const void *blob, const char *prop_name)
91079289c0bSGabe Black {
91179289c0bSGabe Black int config_node;
91279289c0bSGabe Black const void *prop;
91379289c0bSGabe Black
91479289c0bSGabe Black debug("%s: %s\n", __func__, prop_name);
91579289c0bSGabe Black config_node = fdt_path_offset(blob, "/config");
91679289c0bSGabe Black if (config_node < 0)
91779289c0bSGabe Black return 0;
91879289c0bSGabe Black prop = fdt_get_property(blob, config_node, prop_name, NULL);
91979289c0bSGabe Black
92079289c0bSGabe Black return prop != NULL;
92179289c0bSGabe Black }
92279289c0bSGabe Black
fdtdec_get_config_string(const void * blob,const char * prop_name)923332ab0d5SSimon Glass char *fdtdec_get_config_string(const void *blob, const char *prop_name)
924332ab0d5SSimon Glass {
925332ab0d5SSimon Glass const char *nodep;
926332ab0d5SSimon Glass int nodeoffset;
927332ab0d5SSimon Glass int len;
928332ab0d5SSimon Glass
929332ab0d5SSimon Glass debug("%s: %s\n", __func__, prop_name);
930332ab0d5SSimon Glass nodeoffset = fdt_path_offset(blob, "/config");
931332ab0d5SSimon Glass if (nodeoffset < 0)
932332ab0d5SSimon Glass return NULL;
933332ab0d5SSimon Glass
934332ab0d5SSimon Glass nodep = fdt_getprop(blob, nodeoffset, prop_name, &len);
935332ab0d5SSimon Glass if (!nodep)
936332ab0d5SSimon Glass return NULL;
937332ab0d5SSimon Glass
938332ab0d5SSimon Glass return (char *)nodep;
939332ab0d5SSimon Glass }
940f20c4619SSimon Glass
fdtdec_get_number(const fdt32_t * ptr,unsigned int cells)9415f7bfdd6SSimon Glass u64 fdtdec_get_number(const fdt32_t *ptr, unsigned int cells)
94256f42242SThierry Reding {
94356f42242SThierry Reding u64 number = 0;
94456f42242SThierry Reding
94556f42242SThierry Reding while (cells--)
94656f42242SThierry Reding number = (number << 32) | fdt32_to_cpu(*ptr++);
94756f42242SThierry Reding
94856f42242SThierry Reding return number;
94956f42242SThierry Reding }
95056f42242SThierry Reding
fdt_get_resource(const void * fdt,int node,const char * property,unsigned int index,struct fdt_resource * res)95156f42242SThierry Reding int fdt_get_resource(const void *fdt, int node, const char *property,
95256f42242SThierry Reding unsigned int index, struct fdt_resource *res)
95356f42242SThierry Reding {
95456f42242SThierry Reding const fdt32_t *ptr, *end;
95556f42242SThierry Reding int na, ns, len, parent;
95656f42242SThierry Reding unsigned int i = 0;
95756f42242SThierry Reding
95856f42242SThierry Reding parent = fdt_parent_offset(fdt, node);
95956f42242SThierry Reding if (parent < 0)
96056f42242SThierry Reding return parent;
96156f42242SThierry Reding
96256f42242SThierry Reding na = fdt_address_cells(fdt, parent);
96356f42242SThierry Reding ns = fdt_size_cells(fdt, parent);
96456f42242SThierry Reding
96556f42242SThierry Reding ptr = fdt_getprop(fdt, node, property, &len);
96656f42242SThierry Reding if (!ptr)
96756f42242SThierry Reding return len;
96856f42242SThierry Reding
96956f42242SThierry Reding end = ptr + len / sizeof(*ptr);
97056f42242SThierry Reding
97156f42242SThierry Reding while (ptr + na + ns <= end) {
97256f42242SThierry Reding if (i == index) {
973b79221a7SMario Six res->start = fdtdec_get_number(ptr, na);
974b79221a7SMario Six res->end = res->start;
97556f42242SThierry Reding res->end += fdtdec_get_number(&ptr[na], ns) - 1;
97656f42242SThierry Reding return 0;
97756f42242SThierry Reding }
97856f42242SThierry Reding
97956f42242SThierry Reding ptr += na + ns;
98056f42242SThierry Reding i++;
98156f42242SThierry Reding }
98256f42242SThierry Reding
98356f42242SThierry Reding return -FDT_ERR_NOTFOUND;
98456f42242SThierry Reding }
98556f42242SThierry Reding
fdt_get_named_resource(const void * fdt,int node,const char * property,const char * prop_names,const char * name,struct fdt_resource * res)98656f42242SThierry Reding int fdt_get_named_resource(const void *fdt, int node, const char *property,
98756f42242SThierry Reding const char *prop_names, const char *name,
98856f42242SThierry Reding struct fdt_resource *res)
98956f42242SThierry Reding {
99056f42242SThierry Reding int index;
99156f42242SThierry Reding
992b02e4044SSimon Glass index = fdt_stringlist_search(fdt, node, prop_names, name);
99356f42242SThierry Reding if (index < 0)
99456f42242SThierry Reding return index;
99556f42242SThierry Reding
99656f42242SThierry Reding return fdt_get_resource(fdt, node, property, index, res);
99756f42242SThierry Reding }
9989f85eee7SThierry Reding
decode_timing_property(const void * blob,int node,const char * name,struct timing_entry * result)99912e67114SSimon Glass static int decode_timing_property(const void *blob, int node, const char *name,
100012e67114SSimon Glass struct timing_entry *result)
100112e67114SSimon Glass {
100212e67114SSimon Glass int length, ret = 0;
100312e67114SSimon Glass const u32 *prop;
100412e67114SSimon Glass
100512e67114SSimon Glass prop = fdt_getprop(blob, node, name, &length);
100612e67114SSimon Glass if (!prop) {
100712e67114SSimon Glass debug("%s: could not find property %s\n",
100812e67114SSimon Glass fdt_get_name(blob, node, NULL), name);
100912e67114SSimon Glass return length;
101012e67114SSimon Glass }
101112e67114SSimon Glass
101212e67114SSimon Glass if (length == sizeof(u32)) {
101312e67114SSimon Glass result->typ = fdtdec_get_int(blob, node, name, 0);
101412e67114SSimon Glass result->min = result->typ;
101512e67114SSimon Glass result->max = result->typ;
101612e67114SSimon Glass } else {
101712e67114SSimon Glass ret = fdtdec_get_int_array(blob, node, name, &result->min, 3);
101812e67114SSimon Glass }
101912e67114SSimon Glass
102012e67114SSimon Glass return ret;
102112e67114SSimon Glass }
102212e67114SSimon Glass
fdtdec_decode_display_timing(const void * blob,int parent,int index,struct display_timing * dt)102312e67114SSimon Glass int fdtdec_decode_display_timing(const void *blob, int parent, int index,
102412e67114SSimon Glass struct display_timing *dt)
102512e67114SSimon Glass {
102612e67114SSimon Glass int i, node, timings_node;
102712e67114SSimon Glass u32 val = 0;
102812e67114SSimon Glass int ret = 0;
102912e67114SSimon Glass
103012e67114SSimon Glass timings_node = fdt_subnode_offset(blob, parent, "display-timings");
103112e67114SSimon Glass if (timings_node < 0)
103212e67114SSimon Glass return timings_node;
103312e67114SSimon Glass
103412e67114SSimon Glass for (i = 0, node = fdt_first_subnode(blob, timings_node);
103512e67114SSimon Glass node > 0 && i != index;
103612e67114SSimon Glass node = fdt_next_subnode(blob, node))
103712e67114SSimon Glass i++;
103812e67114SSimon Glass
103912e67114SSimon Glass if (node < 0)
104012e67114SSimon Glass return node;
104112e67114SSimon Glass
104212e67114SSimon Glass memset(dt, 0, sizeof(*dt));
104312e67114SSimon Glass
104412e67114SSimon Glass ret |= decode_timing_property(blob, node, "hback-porch",
104512e67114SSimon Glass &dt->hback_porch);
104612e67114SSimon Glass ret |= decode_timing_property(blob, node, "hfront-porch",
104712e67114SSimon Glass &dt->hfront_porch);
104812e67114SSimon Glass ret |= decode_timing_property(blob, node, "hactive", &dt->hactive);
104912e67114SSimon Glass ret |= decode_timing_property(blob, node, "hsync-len", &dt->hsync_len);
105012e67114SSimon Glass ret |= decode_timing_property(blob, node, "vback-porch",
105112e67114SSimon Glass &dt->vback_porch);
105212e67114SSimon Glass ret |= decode_timing_property(blob, node, "vfront-porch",
105312e67114SSimon Glass &dt->vfront_porch);
105412e67114SSimon Glass ret |= decode_timing_property(blob, node, "vactive", &dt->vactive);
105512e67114SSimon Glass ret |= decode_timing_property(blob, node, "vsync-len", &dt->vsync_len);
105612e67114SSimon Glass ret |= decode_timing_property(blob, node, "clock-frequency",
105712e67114SSimon Glass &dt->pixelclock);
105812e67114SSimon Glass
105912e67114SSimon Glass dt->flags = 0;
106012e67114SSimon Glass val = fdtdec_get_int(blob, node, "vsync-active", -1);
106112e67114SSimon Glass if (val != -1) {
106212e67114SSimon Glass dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
106312e67114SSimon Glass DISPLAY_FLAGS_VSYNC_LOW;
106412e67114SSimon Glass }
106512e67114SSimon Glass val = fdtdec_get_int(blob, node, "hsync-active", -1);
106612e67114SSimon Glass if (val != -1) {
106712e67114SSimon Glass dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
106812e67114SSimon Glass DISPLAY_FLAGS_HSYNC_LOW;
106912e67114SSimon Glass }
107012e67114SSimon Glass val = fdtdec_get_int(blob, node, "de-active", -1);
107112e67114SSimon Glass if (val != -1) {
107212e67114SSimon Glass dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
107312e67114SSimon Glass DISPLAY_FLAGS_DE_LOW;
107412e67114SSimon Glass }
107512e67114SSimon Glass val = fdtdec_get_int(blob, node, "pixelclk-active", -1);
107612e67114SSimon Glass if (val != -1) {
107712e67114SSimon Glass dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
107812e67114SSimon Glass DISPLAY_FLAGS_PIXDATA_NEGEDGE;
107912e67114SSimon Glass }
108012e67114SSimon Glass
108112e67114SSimon Glass if (fdtdec_get_bool(blob, node, "interlaced"))
108212e67114SSimon Glass dt->flags |= DISPLAY_FLAGS_INTERLACED;
108312e67114SSimon Glass if (fdtdec_get_bool(blob, node, "doublescan"))
108412e67114SSimon Glass dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
108512e67114SSimon Glass if (fdtdec_get_bool(blob, node, "doubleclk"))
108612e67114SSimon Glass dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
108712e67114SSimon Glass
108804b9dd10SSimon Glass return ret;
108912e67114SSimon Glass }
109012e67114SSimon Glass
fdtdec_setup_mem_size_base(void)109112308b12SSiva Durga Prasad Paladugu int fdtdec_setup_mem_size_base(void)
1092623f6019SNathan Rossi {
1093623f6019SNathan Rossi int ret, mem;
1094623f6019SNathan Rossi struct fdt_resource res;
1095623f6019SNathan Rossi
1096623f6019SNathan Rossi mem = fdt_path_offset(gd->fdt_blob, "/memory");
1097623f6019SNathan Rossi if (mem < 0) {
1098623f6019SNathan Rossi debug("%s: Missing /memory node\n", __func__);
1099623f6019SNathan Rossi return -EINVAL;
1100623f6019SNathan Rossi }
1101623f6019SNathan Rossi
1102623f6019SNathan Rossi ret = fdt_get_resource(gd->fdt_blob, mem, "reg", 0, &res);
1103623f6019SNathan Rossi if (ret != 0) {
1104623f6019SNathan Rossi debug("%s: Unable to decode first memory bank\n", __func__);
1105623f6019SNathan Rossi return -EINVAL;
1106623f6019SNathan Rossi }
1107623f6019SNathan Rossi
1108623f6019SNathan Rossi gd->ram_size = (phys_size_t)(res.end - res.start + 1);
11091473b12aSSiva Durga Prasad Paladugu gd->ram_base = (unsigned long)res.start;
1110c69380f8SSimon Glass debug("%s: Initial DRAM size %llx\n", __func__,
1111c69380f8SSimon Glass (unsigned long long)gd->ram_size);
1112623f6019SNathan Rossi
1113623f6019SNathan Rossi return 0;
1114623f6019SNathan Rossi }
1115623f6019SNathan Rossi
1116623f6019SNathan Rossi #if defined(CONFIG_NR_DRAM_BANKS)
1117452bc121SJens Wiklander
get_next_memory_node(const void * blob,int mem)1118658954cbSMichal Simek static int get_next_memory_node(const void *blob, int mem)
1119452bc121SJens Wiklander {
1120452bc121SJens Wiklander do {
1121658954cbSMichal Simek mem = fdt_node_offset_by_prop_value(gd->fdt_blob, mem,
1122658954cbSMichal Simek "device_type", "memory", 7);
1123658954cbSMichal Simek } while (!fdtdec_get_is_enabled(blob, mem));
1124452bc121SJens Wiklander
1125452bc121SJens Wiklander return mem;
1126452bc121SJens Wiklander }
1127452bc121SJens Wiklander
fdtdec_setup_memory_banksize(void)1128623f6019SNathan Rossi int fdtdec_setup_memory_banksize(void)
1129623f6019SNathan Rossi {
1130658954cbSMichal Simek int bank, ret, mem, reg = 0;
1131658954cbSMichal Simek struct fdt_resource res;
1132623f6019SNathan Rossi
1133658954cbSMichal Simek mem = get_next_memory_node(gd->fdt_blob, -1);
1134658954cbSMichal Simek if (mem < 0) {
1135658954cbSMichal Simek debug("%s: Missing /memory node\n", __func__);
1136658954cbSMichal Simek return -EINVAL;
1137658954cbSMichal Simek }
1138623f6019SNathan Rossi
1139623f6019SNathan Rossi for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
1140658954cbSMichal Simek ret = fdt_get_resource(gd->fdt_blob, mem, "reg", reg++, &res);
1141658954cbSMichal Simek if (ret == -FDT_ERR_NOTFOUND) {
1142942ee093SMarek Vasut reg = 0;
1143658954cbSMichal Simek mem = get_next_memory_node(gd->fdt_blob, mem);
1144658954cbSMichal Simek if (mem == -FDT_ERR_NOTFOUND)
1145658954cbSMichal Simek break;
1146658954cbSMichal Simek
1147658954cbSMichal Simek ret = fdt_get_resource(gd->fdt_blob, mem, "reg", reg++, &res);
1148658954cbSMichal Simek if (ret == -FDT_ERR_NOTFOUND)
1149658954cbSMichal Simek break;
1150942ee093SMarek Vasut }
1151658954cbSMichal Simek if (ret != 0) {
1152658954cbSMichal Simek return -EINVAL;
1153942ee093SMarek Vasut }
1154623f6019SNathan Rossi
1155623f6019SNathan Rossi gd->bd->bi_dram[bank].start = (phys_addr_t)res.start;
1156623f6019SNathan Rossi gd->bd->bi_dram[bank].size =
1157623f6019SNathan Rossi (phys_size_t)(res.end - res.start + 1);
1158623f6019SNathan Rossi
1159623f6019SNathan Rossi debug("%s: DRAM Bank #%d: start = 0x%llx, size = 0x%llx\n",
1160623f6019SNathan Rossi __func__, bank,
1161623f6019SNathan Rossi (unsigned long long)gd->bd->bi_dram[bank].start,
1162623f6019SNathan Rossi (unsigned long long)gd->bd->bi_dram[bank].size);
1163623f6019SNathan Rossi }
1164623f6019SNathan Rossi
1165623f6019SNathan Rossi return 0;
1166623f6019SNathan Rossi }
1167623f6019SNathan Rossi #endif
1168623f6019SNathan Rossi
11692f57c951SJean-Jacques Hiblot #if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
11702f57c951SJean-Jacques Hiblot # if CONFIG_IS_ENABLED(MULTI_DTB_FIT_GZIP) ||\
11712f57c951SJean-Jacques Hiblot CONFIG_IS_ENABLED(MULTI_DTB_FIT_LZO)
uncompress_blob(const void * src,ulong sz_src,void ** dstp)11722f57c951SJean-Jacques Hiblot static int uncompress_blob(const void *src, ulong sz_src, void **dstp)
11732f57c951SJean-Jacques Hiblot {
11742f57c951SJean-Jacques Hiblot size_t sz_out = CONFIG_SPL_MULTI_DTB_FIT_UNCOMPRESS_SZ;
11752f57c951SJean-Jacques Hiblot ulong sz_in = sz_src;
11762f57c951SJean-Jacques Hiblot void *dst;
11772f57c951SJean-Jacques Hiblot int rc;
11782f57c951SJean-Jacques Hiblot
11792f57c951SJean-Jacques Hiblot if (CONFIG_IS_ENABLED(GZIP))
11802f57c951SJean-Jacques Hiblot if (gzip_parse_header(src, sz_in) < 0)
11812f57c951SJean-Jacques Hiblot return -1;
11822f57c951SJean-Jacques Hiblot if (CONFIG_IS_ENABLED(LZO))
11832f57c951SJean-Jacques Hiblot if (!lzop_is_valid_header(src))
11842f57c951SJean-Jacques Hiblot return -EBADMSG;
11852f57c951SJean-Jacques Hiblot
11862f57c951SJean-Jacques Hiblot if (CONFIG_IS_ENABLED(MULTI_DTB_FIT_DYN_ALLOC)) {
11872f57c951SJean-Jacques Hiblot dst = malloc(sz_out);
11882f57c951SJean-Jacques Hiblot if (!dst) {
11892f57c951SJean-Jacques Hiblot puts("uncompress_blob: Unable to allocate memory\n");
11902f57c951SJean-Jacques Hiblot return -ENOMEM;
11912f57c951SJean-Jacques Hiblot }
11922f57c951SJean-Jacques Hiblot } else {
11932f57c951SJean-Jacques Hiblot # if CONFIG_IS_ENABLED(MULTI_DTB_FIT_USER_DEFINED_AREA)
11942f57c951SJean-Jacques Hiblot dst = (void *)CONFIG_VAL(MULTI_DTB_FIT_USER_DEF_ADDR);
11952f57c951SJean-Jacques Hiblot # else
11962f57c951SJean-Jacques Hiblot return -ENOTSUPP;
11972f57c951SJean-Jacques Hiblot # endif
11982f57c951SJean-Jacques Hiblot }
11992f57c951SJean-Jacques Hiblot
12002f57c951SJean-Jacques Hiblot if (CONFIG_IS_ENABLED(GZIP))
12012f57c951SJean-Jacques Hiblot rc = gunzip(dst, sz_out, (u8 *)src, &sz_in);
12022f57c951SJean-Jacques Hiblot else if (CONFIG_IS_ENABLED(LZO))
12032f57c951SJean-Jacques Hiblot rc = lzop_decompress(src, sz_in, dst, &sz_out);
12042f57c951SJean-Jacques Hiblot
12052f57c951SJean-Jacques Hiblot if (rc < 0) {
12062f57c951SJean-Jacques Hiblot /* not a valid compressed blob */
12072f57c951SJean-Jacques Hiblot puts("uncompress_blob: Unable to uncompress\n");
12082f57c951SJean-Jacques Hiblot if (CONFIG_IS_ENABLED(MULTI_DTB_FIT_DYN_ALLOC))
12092f57c951SJean-Jacques Hiblot free(dst);
12102f57c951SJean-Jacques Hiblot return -EBADMSG;
12112f57c951SJean-Jacques Hiblot }
12122f57c951SJean-Jacques Hiblot *dstp = dst;
12132f57c951SJean-Jacques Hiblot return 0;
12142f57c951SJean-Jacques Hiblot }
12152f57c951SJean-Jacques Hiblot # else
uncompress_blob(const void * src,ulong sz_src,void ** dstp)12162f57c951SJean-Jacques Hiblot static int uncompress_blob(const void *src, ulong sz_src, void **dstp)
12172f57c951SJean-Jacques Hiblot {
1218410d9b64SMarek Vasut *dstp = (void *)src;
1219410d9b64SMarek Vasut return 0;
12202f57c951SJean-Jacques Hiblot }
12212f57c951SJean-Jacques Hiblot # endif
12222f57c951SJean-Jacques Hiblot #endif
12232f57c951SJean-Jacques Hiblot
12243b595da4SRob Clark #if defined(CONFIG_OF_BOARD) || defined(CONFIG_OF_SEPARATE)
12253b595da4SRob Clark /*
12263b595da4SRob Clark * For CONFIG_OF_SEPARATE, the board may optionally implement this to
12273b595da4SRob Clark * provide and/or fixup the fdt.
12283b595da4SRob Clark */
board_fdt_blob_setup(void)12293b595da4SRob Clark __weak void *board_fdt_blob_setup(void)
12303b595da4SRob Clark {
12313b595da4SRob Clark void *fdt_blob = NULL;
12323b595da4SRob Clark #ifdef CONFIG_SPL_BUILD
12333b595da4SRob Clark /* FDT is at end of BSS unless it is in a different memory region */
12343b595da4SRob Clark if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS))
12353b595da4SRob Clark fdt_blob = (ulong *)&_image_binary_end;
12363b595da4SRob Clark else
12373b595da4SRob Clark fdt_blob = (ulong *)&__bss_end;
12383b595da4SRob Clark #else
12393b595da4SRob Clark /* FDT is at end of image */
12403b595da4SRob Clark fdt_blob = (ulong *)&_end;
12413b595da4SRob Clark #endif
12423b595da4SRob Clark return fdt_blob;
12433b595da4SRob Clark }
12443b595da4SRob Clark #endif
12453b595da4SRob Clark
fdtdec_setup(void)12460879361fSSimon Glass int fdtdec_setup(void)
1247b45122fdSSimon Glass {
12480f925822SMasahiro Yamada #if CONFIG_IS_ENABLED(OF_CONTROL)
12492f57c951SJean-Jacques Hiblot # if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
12502f57c951SJean-Jacques Hiblot void *fdt_blob;
12512f57c951SJean-Jacques Hiblot # endif
1252b45122fdSSimon Glass # ifdef CONFIG_OF_EMBED
1253b45122fdSSimon Glass /* Get a pointer to the FDT */
12549bd76b80SGoldschmidt Simon # ifdef CONFIG_SPL_BUILD
12559bd76b80SGoldschmidt Simon gd->fdt_blob = __dtb_dt_spl_begin;
12569bd76b80SGoldschmidt Simon # else
1257b45122fdSSimon Glass gd->fdt_blob = __dtb_dt_begin;
12589bd76b80SGoldschmidt Simon # endif
12593b595da4SRob Clark # elif defined(CONFIG_OF_BOARD) || defined(CONFIG_OF_SEPARATE)
126082f766d1SAlex Deymo /* Allow the board to override the fdt address. */
126182f766d1SAlex Deymo gd->fdt_blob = board_fdt_blob_setup();
1262b45122fdSSimon Glass # elif defined(CONFIG_OF_HOSTFILE)
1263b45122fdSSimon Glass if (sandbox_read_fdt_from_file()) {
1264b45122fdSSimon Glass puts("Failed to read control FDT\n");
1265b45122fdSSimon Glass return -1;
1266b45122fdSSimon Glass }
1267b45122fdSSimon Glass # endif
1268b45122fdSSimon Glass # ifndef CONFIG_SPL_BUILD
1269b45122fdSSimon Glass /* Allow the early environment to override the fdt address */
1270894c3ad2SThomas Fitzsimmons # if CONFIG_IS_ENABLED(OF_PRIOR_STAGE)
1271894c3ad2SThomas Fitzsimmons gd->fdt_blob = (void *)prior_stage_fdt_address;
1272894c3ad2SThomas Fitzsimmons # else
1273f980c999SHeinrich Schuchardt gd->fdt_blob = map_sysmem
1274f980c999SHeinrich Schuchardt (env_get_ulong("fdtcontroladdr", 16,
1275f980c999SHeinrich Schuchardt (unsigned long)map_to_sysmem(gd->fdt_blob)), 0);
1276b45122fdSSimon Glass # endif
1277894c3ad2SThomas Fitzsimmons # endif
12782f57c951SJean-Jacques Hiblot
12792f57c951SJean-Jacques Hiblot # if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
12802f57c951SJean-Jacques Hiblot /*
12812f57c951SJean-Jacques Hiblot * Try and uncompress the blob.
12822f57c951SJean-Jacques Hiblot * Unfortunately there is no way to know how big the input blob really
12832f57c951SJean-Jacques Hiblot * is. So let us set the maximum input size arbitrarily high. 16MB
12842f57c951SJean-Jacques Hiblot * ought to be more than enough for packed DTBs.
12852f57c951SJean-Jacques Hiblot */
12862f57c951SJean-Jacques Hiblot if (uncompress_blob(gd->fdt_blob, 0x1000000, &fdt_blob) == 0)
12872f57c951SJean-Jacques Hiblot gd->fdt_blob = fdt_blob;
12882f57c951SJean-Jacques Hiblot
12892f57c951SJean-Jacques Hiblot /*
12902f57c951SJean-Jacques Hiblot * Check if blob is a FIT images containings DTBs.
12912f57c951SJean-Jacques Hiblot * If so, pick the most relevant
12922f57c951SJean-Jacques Hiblot */
12932f57c951SJean-Jacques Hiblot fdt_blob = locate_dtb_in_fit(gd->fdt_blob);
1294f1d2bc90SJean-Jacques Hiblot if (fdt_blob) {
1295f1d2bc90SJean-Jacques Hiblot gd->multi_dtb_fit = gd->fdt_blob;
12962f57c951SJean-Jacques Hiblot gd->fdt_blob = fdt_blob;
1297f1d2bc90SJean-Jacques Hiblot }
1298f1d2bc90SJean-Jacques Hiblot
1299b45122fdSSimon Glass # endif
13002f57c951SJean-Jacques Hiblot #endif
13012f57c951SJean-Jacques Hiblot
13020879361fSSimon Glass return fdtdec_prepare_fdt();
1303b45122fdSSimon Glass }
1304b45122fdSSimon Glass
1305f1d2bc90SJean-Jacques Hiblot #if CONFIG_IS_ENABLED(MULTI_DTB_FIT)
fdtdec_resetup(int * rescan)1306f1d2bc90SJean-Jacques Hiblot int fdtdec_resetup(int *rescan)
1307f1d2bc90SJean-Jacques Hiblot {
1308f1d2bc90SJean-Jacques Hiblot void *fdt_blob;
1309f1d2bc90SJean-Jacques Hiblot
1310f1d2bc90SJean-Jacques Hiblot /*
1311f1d2bc90SJean-Jacques Hiblot * If the current DTB is part of a compressed FIT image,
1312f1d2bc90SJean-Jacques Hiblot * try to locate the best match from the uncompressed
1313f1d2bc90SJean-Jacques Hiblot * FIT image stillpresent there. Save the time and space
1314f1d2bc90SJean-Jacques Hiblot * required to uncompress it again.
1315f1d2bc90SJean-Jacques Hiblot */
1316f1d2bc90SJean-Jacques Hiblot if (gd->multi_dtb_fit) {
1317f1d2bc90SJean-Jacques Hiblot fdt_blob = locate_dtb_in_fit(gd->multi_dtb_fit);
1318f1d2bc90SJean-Jacques Hiblot
1319f1d2bc90SJean-Jacques Hiblot if (fdt_blob == gd->fdt_blob) {
1320f1d2bc90SJean-Jacques Hiblot /*
1321f1d2bc90SJean-Jacques Hiblot * The best match did not change. no need to tear down
1322f1d2bc90SJean-Jacques Hiblot * the DM and rescan the fdt.
1323f1d2bc90SJean-Jacques Hiblot */
1324f1d2bc90SJean-Jacques Hiblot *rescan = 0;
1325f1d2bc90SJean-Jacques Hiblot return 0;
1326f1d2bc90SJean-Jacques Hiblot }
1327f1d2bc90SJean-Jacques Hiblot
1328f1d2bc90SJean-Jacques Hiblot *rescan = 1;
1329f1d2bc90SJean-Jacques Hiblot gd->fdt_blob = fdt_blob;
1330f1d2bc90SJean-Jacques Hiblot return fdtdec_prepare_fdt();
1331f1d2bc90SJean-Jacques Hiblot }
1332f1d2bc90SJean-Jacques Hiblot
1333f1d2bc90SJean-Jacques Hiblot /*
1334f1d2bc90SJean-Jacques Hiblot * If multi_dtb_fit is NULL, it means that blob appended to u-boot is
1335f1d2bc90SJean-Jacques Hiblot * not a FIT image containings DTB, but a single DTB. There is no need
1336f1d2bc90SJean-Jacques Hiblot * to teard down DM and rescan the DT in this case.
1337f1d2bc90SJean-Jacques Hiblot */
1338f1d2bc90SJean-Jacques Hiblot *rescan = 0;
1339f1d2bc90SJean-Jacques Hiblot return 0;
1340f1d2bc90SJean-Jacques Hiblot }
1341f1d2bc90SJean-Jacques Hiblot #endif
1342f1d2bc90SJean-Jacques Hiblot
134390c08fa0SMichael Pratt #ifdef CONFIG_NR_DRAM_BANKS
fdtdec_decode_ram_size(const void * blob,const char * area,int board_id,phys_addr_t * basep,phys_size_t * sizep,bd_t * bd)134490c08fa0SMichael Pratt int fdtdec_decode_ram_size(const void *blob, const char *area, int board_id,
134590c08fa0SMichael Pratt phys_addr_t *basep, phys_size_t *sizep, bd_t *bd)
134690c08fa0SMichael Pratt {
134790c08fa0SMichael Pratt int addr_cells, size_cells;
134890c08fa0SMichael Pratt const u32 *cell, *end;
134990c08fa0SMichael Pratt u64 total_size, size, addr;
135090c08fa0SMichael Pratt int node, child;
135190c08fa0SMichael Pratt bool auto_size;
135290c08fa0SMichael Pratt int bank;
135390c08fa0SMichael Pratt int len;
135490c08fa0SMichael Pratt
135590c08fa0SMichael Pratt debug("%s: board_id=%d\n", __func__, board_id);
135690c08fa0SMichael Pratt if (!area)
135790c08fa0SMichael Pratt area = "/memory";
135890c08fa0SMichael Pratt node = fdt_path_offset(blob, area);
135990c08fa0SMichael Pratt if (node < 0) {
136090c08fa0SMichael Pratt debug("No %s node found\n", area);
136190c08fa0SMichael Pratt return -ENOENT;
136290c08fa0SMichael Pratt }
136390c08fa0SMichael Pratt
136490c08fa0SMichael Pratt cell = fdt_getprop(blob, node, "reg", &len);
136590c08fa0SMichael Pratt if (!cell) {
136690c08fa0SMichael Pratt debug("No reg property found\n");
136790c08fa0SMichael Pratt return -ENOENT;
136890c08fa0SMichael Pratt }
136990c08fa0SMichael Pratt
137090c08fa0SMichael Pratt addr_cells = fdt_address_cells(blob, node);
137190c08fa0SMichael Pratt size_cells = fdt_size_cells(blob, node);
137290c08fa0SMichael Pratt
137390c08fa0SMichael Pratt /* Check the board id and mask */
137490c08fa0SMichael Pratt for (child = fdt_first_subnode(blob, node);
137590c08fa0SMichael Pratt child >= 0;
137690c08fa0SMichael Pratt child = fdt_next_subnode(blob, child)) {
137790c08fa0SMichael Pratt int match_mask, match_value;
137890c08fa0SMichael Pratt
137990c08fa0SMichael Pratt match_mask = fdtdec_get_int(blob, child, "match-mask", -1);
138090c08fa0SMichael Pratt match_value = fdtdec_get_int(blob, child, "match-value", -1);
138190c08fa0SMichael Pratt
138290c08fa0SMichael Pratt if (match_value >= 0 &&
138390c08fa0SMichael Pratt ((board_id & match_mask) == match_value)) {
138490c08fa0SMichael Pratt /* Found matching mask */
138590c08fa0SMichael Pratt debug("Found matching mask %d\n", match_mask);
138690c08fa0SMichael Pratt node = child;
138790c08fa0SMichael Pratt cell = fdt_getprop(blob, node, "reg", &len);
138890c08fa0SMichael Pratt if (!cell) {
138990c08fa0SMichael Pratt debug("No memory-banks property found\n");
139090c08fa0SMichael Pratt return -EINVAL;
139190c08fa0SMichael Pratt }
139290c08fa0SMichael Pratt break;
139390c08fa0SMichael Pratt }
139490c08fa0SMichael Pratt }
139590c08fa0SMichael Pratt /* Note: if no matching subnode was found we use the parent node */
139690c08fa0SMichael Pratt
139790c08fa0SMichael Pratt if (bd) {
139890c08fa0SMichael Pratt memset(bd->bi_dram, '\0', sizeof(bd->bi_dram[0]) *
139990c08fa0SMichael Pratt CONFIG_NR_DRAM_BANKS);
140090c08fa0SMichael Pratt }
140190c08fa0SMichael Pratt
140290c08fa0SMichael Pratt auto_size = fdtdec_get_bool(blob, node, "auto-size");
140390c08fa0SMichael Pratt
140490c08fa0SMichael Pratt total_size = 0;
140590c08fa0SMichael Pratt end = cell + len / 4 - addr_cells - size_cells;
140690c08fa0SMichael Pratt debug("cell at %p, end %p\n", cell, end);
140790c08fa0SMichael Pratt for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
140890c08fa0SMichael Pratt if (cell > end)
140990c08fa0SMichael Pratt break;
141090c08fa0SMichael Pratt addr = 0;
141190c08fa0SMichael Pratt if (addr_cells == 2)
141290c08fa0SMichael Pratt addr += (u64)fdt32_to_cpu(*cell++) << 32UL;
141390c08fa0SMichael Pratt addr += fdt32_to_cpu(*cell++);
141490c08fa0SMichael Pratt if (bd)
141590c08fa0SMichael Pratt bd->bi_dram[bank].start = addr;
141690c08fa0SMichael Pratt if (basep && !bank)
141790c08fa0SMichael Pratt *basep = (phys_addr_t)addr;
141890c08fa0SMichael Pratt
141990c08fa0SMichael Pratt size = 0;
142090c08fa0SMichael Pratt if (size_cells == 2)
142190c08fa0SMichael Pratt size += (u64)fdt32_to_cpu(*cell++) << 32UL;
142290c08fa0SMichael Pratt size += fdt32_to_cpu(*cell++);
142390c08fa0SMichael Pratt
142490c08fa0SMichael Pratt if (auto_size) {
142590c08fa0SMichael Pratt u64 new_size;
142690c08fa0SMichael Pratt
1427dee37fc9SMasahiro Yamada debug("Auto-sizing %llx, size %llx: ", addr, size);
142890c08fa0SMichael Pratt new_size = get_ram_size((long *)(uintptr_t)addr, size);
142990c08fa0SMichael Pratt if (new_size == size) {
143090c08fa0SMichael Pratt debug("OK\n");
143190c08fa0SMichael Pratt } else {
1432dee37fc9SMasahiro Yamada debug("sized to %llx\n", new_size);
143390c08fa0SMichael Pratt size = new_size;
143490c08fa0SMichael Pratt }
143590c08fa0SMichael Pratt }
143690c08fa0SMichael Pratt
143790c08fa0SMichael Pratt if (bd)
143890c08fa0SMichael Pratt bd->bi_dram[bank].size = size;
143990c08fa0SMichael Pratt total_size += size;
144090c08fa0SMichael Pratt }
144190c08fa0SMichael Pratt
1442dee37fc9SMasahiro Yamada debug("Memory size %llu\n", total_size);
144390c08fa0SMichael Pratt if (sizep)
144490c08fa0SMichael Pratt *sizep = (phys_size_t)total_size;
144590c08fa0SMichael Pratt
144690c08fa0SMichael Pratt return 0;
144790c08fa0SMichael Pratt }
144890c08fa0SMichael Pratt #endif /* CONFIG_NR_DRAM_BANKS */
144990c08fa0SMichael Pratt
1450b45122fdSSimon Glass #endif /* !USE_HOSTCC */
1451