xref: /openbmc/u-boot/lib/fdtdec.c (revision 797d1b9de118d4d3f6d918e7412c3ff9b7883bf0)
1 /*
2  * Copyright (c) 2011 The Chromium OS Authors.
3  * SPDX-License-Identifier:	GPL-2.0+
4  */
5 
6 #ifndef USE_HOSTCC
7 #include <common.h>
8 #include <dm.h>
9 #include <errno.h>
10 #include <serial.h>
11 #include <libfdt.h>
12 #include <fdtdec.h>
13 #include <asm/sections.h>
14 #include <linux/ctype.h>
15 
16 DECLARE_GLOBAL_DATA_PTR;
17 
18 /*
19  * Here are the type we know about. One day we might allow drivers to
20  * register. For now we just put them here. The COMPAT macro allows us to
21  * turn this into a sparse list later, and keeps the ID with the name.
22  */
23 #define COMPAT(id, name) name
24 static const char * const compat_names[COMPAT_COUNT] = {
25 	COMPAT(UNKNOWN, "<none>"),
26 	COMPAT(NVIDIA_TEGRA20_EMC, "nvidia,tegra20-emc"),
27 	COMPAT(NVIDIA_TEGRA20_EMC_TABLE, "nvidia,tegra20-emc-table"),
28 	COMPAT(NVIDIA_TEGRA20_NAND, "nvidia,tegra20-nand"),
29 	COMPAT(NVIDIA_TEGRA124_PMC, "nvidia,tegra124-pmc"),
30 	COMPAT(NVIDIA_TEGRA186_SDMMC, "nvidia,tegra186-sdhci"),
31 	COMPAT(NVIDIA_TEGRA210_SDMMC, "nvidia,tegra210-sdhci"),
32 	COMPAT(NVIDIA_TEGRA124_SDMMC, "nvidia,tegra124-sdhci"),
33 	COMPAT(NVIDIA_TEGRA30_SDMMC, "nvidia,tegra30-sdhci"),
34 	COMPAT(NVIDIA_TEGRA20_SDMMC, "nvidia,tegra20-sdhci"),
35 	COMPAT(NVIDIA_TEGRA124_XUSB_PADCTL, "nvidia,tegra124-xusb-padctl"),
36 	COMPAT(NVIDIA_TEGRA210_XUSB_PADCTL, "nvidia,tegra210-xusb-padctl"),
37 	COMPAT(SMSC_LAN9215, "smsc,lan9215"),
38 	COMPAT(SAMSUNG_EXYNOS5_SROMC, "samsung,exynos-sromc"),
39 	COMPAT(SAMSUNG_S3C2440_I2C, "samsung,s3c2440-i2c"),
40 	COMPAT(SAMSUNG_EXYNOS5_SOUND, "samsung,exynos-sound"),
41 	COMPAT(WOLFSON_WM8994_CODEC, "wolfson,wm8994-codec"),
42 	COMPAT(GOOGLE_CROS_EC_KEYB, "google,cros-ec-keyb"),
43 	COMPAT(SAMSUNG_EXYNOS_USB_PHY, "samsung,exynos-usb-phy"),
44 	COMPAT(SAMSUNG_EXYNOS5_USB3_PHY, "samsung,exynos5250-usb3-phy"),
45 	COMPAT(SAMSUNG_EXYNOS_TMU, "samsung,exynos-tmu"),
46 	COMPAT(SAMSUNG_EXYNOS_FIMD, "samsung,exynos-fimd"),
47 	COMPAT(SAMSUNG_EXYNOS_MIPI_DSI, "samsung,exynos-mipi-dsi"),
48 	COMPAT(SAMSUNG_EXYNOS5_DP, "samsung,exynos5-dp"),
49 	COMPAT(SAMSUNG_EXYNOS_DWMMC, "samsung,exynos-dwmmc"),
50 	COMPAT(SAMSUNG_EXYNOS_MMC, "samsung,exynos-mmc"),
51 	COMPAT(MAXIM_MAX77686_PMIC, "maxim,max77686"),
52 	COMPAT(GENERIC_SPI_FLASH, "spi-flash"),
53 	COMPAT(MAXIM_98095_CODEC, "maxim,max98095-codec"),
54 	COMPAT(SAMSUNG_EXYNOS5_I2C, "samsung,exynos5-hsi2c"),
55 	COMPAT(SAMSUNG_EXYNOS_SYSMMU, "samsung,sysmmu-v3.3"),
56 	COMPAT(INTEL_MICROCODE, "intel,microcode"),
57 	COMPAT(INTEL_PANTHERPOINT_AHCI, "intel,pantherpoint-ahci"),
58 	COMPAT(INTEL_MODEL_206AX, "intel,model-206ax"),
59 	COMPAT(INTEL_GMA, "intel,gma"),
60 	COMPAT(AMS_AS3722, "ams,as3722"),
61 	COMPAT(INTEL_ICH_SPI, "intel,ich-spi"),
62 	COMPAT(INTEL_QRK_MRC, "intel,quark-mrc"),
63 	COMPAT(SOCIONEXT_XHCI, "socionext,uniphier-xhci"),
64 	COMPAT(COMPAT_INTEL_PCH, "intel,bd82x6x"),
65 	COMPAT(ALTERA_SOCFPGA_DWMAC, "altr,socfpga-stmmac"),
66 	COMPAT(ALTERA_SOCFPGA_DWMMC, "altr,socfpga-dw-mshc"),
67 	COMPAT(ALTERA_SOCFPGA_DWC2USB, "snps,dwc2"),
68 	COMPAT(COMPAT_INTEL_BAYTRAIL_FSP, "intel,baytrail-fsp"),
69 	COMPAT(COMPAT_INTEL_BAYTRAIL_FSP_MDP, "intel,baytrail-fsp-mdp"),
70 	COMPAT(COMPAT_INTEL_IVYBRIDGE_FSP, "intel,ivybridge-fsp"),
71 };
72 
73 const char *fdtdec_get_compatible(enum fdt_compat_id id)
74 {
75 	/* We allow reading of the 'unknown' ID for testing purposes */
76 	assert(id >= 0 && id < COMPAT_COUNT);
77 	return compat_names[id];
78 }
79 
80 fdt_addr_t fdtdec_get_addr_size_fixed(const void *blob, int node,
81 		const char *prop_name, int index, int na, int ns,
82 		fdt_size_t *sizep)
83 {
84 	const fdt32_t *prop, *prop_end;
85 	const fdt32_t *prop_addr, *prop_size, *prop_after_size;
86 	int len;
87 	fdt_addr_t addr;
88 
89 	debug("%s: %s: ", __func__, prop_name);
90 
91 	if (na > (sizeof(fdt_addr_t) / sizeof(fdt32_t))) {
92 		debug("(na too large for fdt_addr_t type)\n");
93 		return FDT_ADDR_T_NONE;
94 	}
95 
96 	if (ns > (sizeof(fdt_size_t) / sizeof(fdt32_t))) {
97 		debug("(ns too large for fdt_size_t type)\n");
98 		return FDT_ADDR_T_NONE;
99 	}
100 
101 	prop = fdt_getprop(blob, node, prop_name, &len);
102 	if (!prop) {
103 		debug("(not found)\n");
104 		return FDT_ADDR_T_NONE;
105 	}
106 	prop_end = prop + (len / sizeof(*prop));
107 
108 	prop_addr = prop + (index * (na + ns));
109 	prop_size = prop_addr + na;
110 	prop_after_size = prop_size + ns;
111 	if (prop_after_size > prop_end) {
112 		debug("(not enough data: expected >= %d cells, got %d cells)\n",
113 		      (u32)(prop_after_size - prop), ((u32)(prop_end - prop)));
114 		return FDT_ADDR_T_NONE;
115 	}
116 
117 	addr = fdtdec_get_number(prop_addr, na);
118 
119 	if (sizep) {
120 		*sizep = fdtdec_get_number(prop_size, ns);
121 		debug("addr=%08llx, size=%llx\n", (unsigned long long)addr,
122 		      (unsigned long long)*sizep);
123 	} else {
124 		debug("addr=%08llx\n", (unsigned long long)addr);
125 	}
126 
127 	return addr;
128 }
129 
130 fdt_addr_t fdtdec_get_addr_size_auto_parent(const void *blob, int parent,
131 		int node, const char *prop_name, int index, fdt_size_t *sizep)
132 {
133 	int na, ns;
134 
135 	debug("%s: ", __func__);
136 
137 	na = fdt_address_cells(blob, parent);
138 	if (na < 1) {
139 		debug("(bad #address-cells)\n");
140 		return FDT_ADDR_T_NONE;
141 	}
142 
143 	ns = fdt_size_cells(blob, parent);
144 	if (ns < 0) {
145 		debug("(bad #size-cells)\n");
146 		return FDT_ADDR_T_NONE;
147 	}
148 
149 	debug("na=%d, ns=%d, ", na, ns);
150 
151 	return fdtdec_get_addr_size_fixed(blob, node, prop_name, index, na,
152 					  ns, sizep);
153 }
154 
155 fdt_addr_t fdtdec_get_addr_size_auto_noparent(const void *blob, int node,
156 		const char *prop_name, int index, fdt_size_t *sizep)
157 {
158 	int parent;
159 
160 	debug("%s: ", __func__);
161 
162 	parent = fdt_parent_offset(blob, node);
163 	if (parent < 0) {
164 		debug("(no parent found)\n");
165 		return FDT_ADDR_T_NONE;
166 	}
167 
168 	return fdtdec_get_addr_size_auto_parent(blob, parent, node, prop_name,
169 						index, sizep);
170 }
171 
172 fdt_addr_t fdtdec_get_addr_size(const void *blob, int node,
173 		const char *prop_name, fdt_size_t *sizep)
174 {
175 	int ns = sizep ? (sizeof(fdt_size_t) / sizeof(fdt32_t)) : 0;
176 
177 	return fdtdec_get_addr_size_fixed(blob, node, prop_name, 0,
178 					  sizeof(fdt_addr_t) / sizeof(fdt32_t),
179 					  ns, sizep);
180 }
181 
182 fdt_addr_t fdtdec_get_addr(const void *blob, int node,
183 		const char *prop_name)
184 {
185 	return fdtdec_get_addr_size(blob, node, prop_name, NULL);
186 }
187 
188 #if defined(CONFIG_PCI) && defined(CONFIG_DM_PCI)
189 int fdtdec_get_pci_addr(const void *blob, int node, enum fdt_pci_space type,
190 		const char *prop_name, struct fdt_pci_addr *addr)
191 {
192 	const u32 *cell;
193 	int len;
194 	int ret = -ENOENT;
195 
196 	debug("%s: %s: ", __func__, prop_name);
197 
198 	/*
199 	 * If we follow the pci bus bindings strictly, we should check
200 	 * the value of the node's parent node's #address-cells and
201 	 * #size-cells. They need to be 3 and 2 accordingly. However,
202 	 * for simplicity we skip the check here.
203 	 */
204 	cell = fdt_getprop(blob, node, prop_name, &len);
205 	if (!cell)
206 		goto fail;
207 
208 	if ((len % FDT_PCI_REG_SIZE) == 0) {
209 		int num = len / FDT_PCI_REG_SIZE;
210 		int i;
211 
212 		for (i = 0; i < num; i++) {
213 			debug("pci address #%d: %08lx %08lx %08lx\n", i,
214 			      (ulong)fdt32_to_cpu(cell[0]),
215 			      (ulong)fdt32_to_cpu(cell[1]),
216 			      (ulong)fdt32_to_cpu(cell[2]));
217 			if ((fdt32_to_cpu(*cell) & type) == type) {
218 				addr->phys_hi = fdt32_to_cpu(cell[0]);
219 				addr->phys_mid = fdt32_to_cpu(cell[1]);
220 				addr->phys_lo = fdt32_to_cpu(cell[1]);
221 				break;
222 			} else {
223 				cell += (FDT_PCI_ADDR_CELLS +
224 					 FDT_PCI_SIZE_CELLS);
225 			}
226 		}
227 
228 		if (i == num) {
229 			ret = -ENXIO;
230 			goto fail;
231 		}
232 
233 		return 0;
234 	} else {
235 		ret = -EINVAL;
236 	}
237 
238 fail:
239 	debug("(not found)\n");
240 	return ret;
241 }
242 
243 int fdtdec_get_pci_vendev(const void *blob, int node, u16 *vendor, u16 *device)
244 {
245 	const char *list, *end;
246 	int len;
247 
248 	list = fdt_getprop(blob, node, "compatible", &len);
249 	if (!list)
250 		return -ENOENT;
251 
252 	end = list + len;
253 	while (list < end) {
254 		char *s;
255 
256 		len = strlen(list);
257 		if (len >= strlen("pciVVVV,DDDD")) {
258 			s = strstr(list, "pci");
259 
260 			/*
261 			 * check if the string is something like pciVVVV,DDDD.RR
262 			 * or just pciVVVV,DDDD
263 			 */
264 			if (s && s[7] == ',' &&
265 			    (s[12] == '.' || s[12] == 0)) {
266 				s += 3;
267 				*vendor = simple_strtol(s, NULL, 16);
268 
269 				s += 5;
270 				*device = simple_strtol(s, NULL, 16);
271 
272 				return 0;
273 			}
274 		}
275 		list += (len + 1);
276 	}
277 
278 	return -ENOENT;
279 }
280 
281 int fdtdec_get_pci_bar32(struct udevice *dev, struct fdt_pci_addr *addr,
282 			 u32 *bar)
283 {
284 	int barnum;
285 
286 	/* extract the bar number from fdt_pci_addr */
287 	barnum = addr->phys_hi & 0xff;
288 	if ((barnum < PCI_BASE_ADDRESS_0) || (barnum > PCI_CARDBUS_CIS))
289 		return -EINVAL;
290 
291 	barnum = (barnum - PCI_BASE_ADDRESS_0) / 4;
292 	*bar = dm_pci_read_bar32(dev, barnum);
293 
294 	return 0;
295 }
296 #endif
297 
298 uint64_t fdtdec_get_uint64(const void *blob, int node, const char *prop_name,
299 		uint64_t default_val)
300 {
301 	const uint64_t *cell64;
302 	int length;
303 
304 	cell64 = fdt_getprop(blob, node, prop_name, &length);
305 	if (!cell64 || length < sizeof(*cell64))
306 		return default_val;
307 
308 	return fdt64_to_cpu(*cell64);
309 }
310 
311 int fdtdec_get_is_enabled(const void *blob, int node)
312 {
313 	const char *cell;
314 
315 	/*
316 	 * It should say "okay", so only allow that. Some fdts use "ok" but
317 	 * this is a bug. Please fix your device tree source file. See here
318 	 * for discussion:
319 	 *
320 	 * http://www.mail-archive.com/u-boot@lists.denx.de/msg71598.html
321 	 */
322 	cell = fdt_getprop(blob, node, "status", NULL);
323 	if (cell)
324 		return 0 == strcmp(cell, "okay");
325 	return 1;
326 }
327 
328 enum fdt_compat_id fdtdec_lookup(const void *blob, int node)
329 {
330 	enum fdt_compat_id id;
331 
332 	/* Search our drivers */
333 	for (id = COMPAT_UNKNOWN; id < COMPAT_COUNT; id++)
334 		if (0 == fdt_node_check_compatible(blob, node,
335 				compat_names[id]))
336 			return id;
337 	return COMPAT_UNKNOWN;
338 }
339 
340 int fdtdec_next_compatible(const void *blob, int node,
341 		enum fdt_compat_id id)
342 {
343 	return fdt_node_offset_by_compatible(blob, node, compat_names[id]);
344 }
345 
346 int fdtdec_next_compatible_subnode(const void *blob, int node,
347 		enum fdt_compat_id id, int *depthp)
348 {
349 	do {
350 		node = fdt_next_node(blob, node, depthp);
351 	} while (*depthp > 1);
352 
353 	/* If this is a direct subnode, and compatible, return it */
354 	if (*depthp == 1 && 0 == fdt_node_check_compatible(
355 						blob, node, compat_names[id]))
356 		return node;
357 
358 	return -FDT_ERR_NOTFOUND;
359 }
360 
361 int fdtdec_next_alias(const void *blob, const char *name,
362 		enum fdt_compat_id id, int *upto)
363 {
364 #define MAX_STR_LEN 20
365 	char str[MAX_STR_LEN + 20];
366 	int node, err;
367 
368 	/* snprintf() is not available */
369 	assert(strlen(name) < MAX_STR_LEN);
370 	sprintf(str, "%.*s%d", MAX_STR_LEN, name, *upto);
371 	node = fdt_path_offset(blob, str);
372 	if (node < 0)
373 		return node;
374 	err = fdt_node_check_compatible(blob, node, compat_names[id]);
375 	if (err < 0)
376 		return err;
377 	if (err)
378 		return -FDT_ERR_NOTFOUND;
379 	(*upto)++;
380 	return node;
381 }
382 
383 int fdtdec_find_aliases_for_id(const void *blob, const char *name,
384 			enum fdt_compat_id id, int *node_list, int maxcount)
385 {
386 	memset(node_list, '\0', sizeof(*node_list) * maxcount);
387 
388 	return fdtdec_add_aliases_for_id(blob, name, id, node_list, maxcount);
389 }
390 
391 /* TODO: Can we tighten this code up a little? */
392 int fdtdec_add_aliases_for_id(const void *blob, const char *name,
393 			enum fdt_compat_id id, int *node_list, int maxcount)
394 {
395 	int name_len = strlen(name);
396 	int nodes[maxcount];
397 	int num_found = 0;
398 	int offset, node;
399 	int alias_node;
400 	int count;
401 	int i, j;
402 
403 	/* find the alias node if present */
404 	alias_node = fdt_path_offset(blob, "/aliases");
405 
406 	/*
407 	 * start with nothing, and we can assume that the root node can't
408 	 * match
409 	 */
410 	memset(nodes, '\0', sizeof(nodes));
411 
412 	/* First find all the compatible nodes */
413 	for (node = count = 0; node >= 0 && count < maxcount;) {
414 		node = fdtdec_next_compatible(blob, node, id);
415 		if (node >= 0)
416 			nodes[count++] = node;
417 	}
418 	if (node >= 0)
419 		debug("%s: warning: maxcount exceeded with alias '%s'\n",
420 		       __func__, name);
421 
422 	/* Now find all the aliases */
423 	for (offset = fdt_first_property_offset(blob, alias_node);
424 			offset > 0;
425 			offset = fdt_next_property_offset(blob, offset)) {
426 		const struct fdt_property *prop;
427 		const char *path;
428 		int number;
429 		int found;
430 
431 		node = 0;
432 		prop = fdt_get_property_by_offset(blob, offset, NULL);
433 		path = fdt_string(blob, fdt32_to_cpu(prop->nameoff));
434 		if (prop->len && 0 == strncmp(path, name, name_len))
435 			node = fdt_path_offset(blob, prop->data);
436 		if (node <= 0)
437 			continue;
438 
439 		/* Get the alias number */
440 		number = simple_strtoul(path + name_len, NULL, 10);
441 		if (number < 0 || number >= maxcount) {
442 			debug("%s: warning: alias '%s' is out of range\n",
443 			       __func__, path);
444 			continue;
445 		}
446 
447 		/* Make sure the node we found is actually in our list! */
448 		found = -1;
449 		for (j = 0; j < count; j++)
450 			if (nodes[j] == node) {
451 				found = j;
452 				break;
453 			}
454 
455 		if (found == -1) {
456 			debug("%s: warning: alias '%s' points to a node "
457 				"'%s' that is missing or is not compatible "
458 				" with '%s'\n", __func__, path,
459 				fdt_get_name(blob, node, NULL),
460 			       compat_names[id]);
461 			continue;
462 		}
463 
464 		/*
465 		 * Add this node to our list in the right place, and mark
466 		 * it as done.
467 		 */
468 		if (fdtdec_get_is_enabled(blob, node)) {
469 			if (node_list[number]) {
470 				debug("%s: warning: alias '%s' requires that "
471 				      "a node be placed in the list in a "
472 				      "position which is already filled by "
473 				      "node '%s'\n", __func__, path,
474 				      fdt_get_name(blob, node, NULL));
475 				continue;
476 			}
477 			node_list[number] = node;
478 			if (number >= num_found)
479 				num_found = number + 1;
480 		}
481 		nodes[found] = 0;
482 	}
483 
484 	/* Add any nodes not mentioned by an alias */
485 	for (i = j = 0; i < maxcount; i++) {
486 		if (!node_list[i]) {
487 			for (; j < maxcount; j++)
488 				if (nodes[j] &&
489 					fdtdec_get_is_enabled(blob, nodes[j]))
490 					break;
491 
492 			/* Have we run out of nodes to add? */
493 			if (j == maxcount)
494 				break;
495 
496 			assert(!node_list[i]);
497 			node_list[i] = nodes[j++];
498 			if (i >= num_found)
499 				num_found = i + 1;
500 		}
501 	}
502 
503 	return num_found;
504 }
505 
506 int fdtdec_get_alias_seq(const void *blob, const char *base, int offset,
507 			 int *seqp)
508 {
509 	int base_len = strlen(base);
510 	const char *find_name;
511 	int find_namelen;
512 	int prop_offset;
513 	int aliases;
514 
515 	find_name = fdt_get_name(blob, offset, &find_namelen);
516 	debug("Looking for '%s' at %d, name %s\n", base, offset, find_name);
517 
518 	aliases = fdt_path_offset(blob, "/aliases");
519 	for (prop_offset = fdt_first_property_offset(blob, aliases);
520 	     prop_offset > 0;
521 	     prop_offset = fdt_next_property_offset(blob, prop_offset)) {
522 		const char *prop;
523 		const char *name;
524 		const char *slash;
525 		int len, val;
526 
527 		prop = fdt_getprop_by_offset(blob, prop_offset, &name, &len);
528 		debug("   - %s, %s\n", name, prop);
529 		if (len < find_namelen || *prop != '/' || prop[len - 1] ||
530 		    strncmp(name, base, base_len))
531 			continue;
532 
533 		slash = strrchr(prop, '/');
534 		if (strcmp(slash + 1, find_name))
535 			continue;
536 		val = trailing_strtol(name);
537 		if (val != -1) {
538 			*seqp = val;
539 			debug("Found seq %d\n", *seqp);
540 			return 0;
541 		}
542 	}
543 
544 	debug("Not found\n");
545 	return -ENOENT;
546 }
547 
548 const char *fdtdec_get_chosen_prop(const void *blob, const char *name)
549 {
550 	int chosen_node;
551 
552 	if (!blob)
553 		return NULL;
554 	chosen_node = fdt_path_offset(blob, "/chosen");
555 	return fdt_getprop(blob, chosen_node, name, NULL);
556 }
557 
558 int fdtdec_get_chosen_node(const void *blob, const char *name)
559 {
560 	const char *prop;
561 
562 	prop = fdtdec_get_chosen_prop(blob, name);
563 	if (!prop)
564 		return -FDT_ERR_NOTFOUND;
565 	return fdt_path_offset(blob, prop);
566 }
567 
568 int fdtdec_check_fdt(void)
569 {
570 	/*
571 	 * We must have an FDT, but we cannot panic() yet since the console
572 	 * is not ready. So for now, just assert(). Boards which need an early
573 	 * FDT (prior to console ready) will need to make their own
574 	 * arrangements and do their own checks.
575 	 */
576 	assert(!fdtdec_prepare_fdt());
577 	return 0;
578 }
579 
580 /*
581  * This function is a little odd in that it accesses global data. At some
582  * point if the architecture board.c files merge this will make more sense.
583  * Even now, it is common code.
584  */
585 int fdtdec_prepare_fdt(void)
586 {
587 	if (!gd->fdt_blob || ((uintptr_t)gd->fdt_blob & 3) ||
588 	    fdt_check_header(gd->fdt_blob)) {
589 #ifdef CONFIG_SPL_BUILD
590 		puts("Missing DTB\n");
591 #else
592 		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");
593 # ifdef DEBUG
594 		if (gd->fdt_blob) {
595 			printf("fdt_blob=%p\n", gd->fdt_blob);
596 			print_buffer((ulong)gd->fdt_blob, gd->fdt_blob, 4,
597 				     32, 0);
598 		}
599 # endif
600 #endif
601 		return -1;
602 	}
603 	return 0;
604 }
605 
606 int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name)
607 {
608 	const u32 *phandle;
609 	int lookup;
610 
611 	debug("%s: %s\n", __func__, prop_name);
612 	phandle = fdt_getprop(blob, node, prop_name, NULL);
613 	if (!phandle)
614 		return -FDT_ERR_NOTFOUND;
615 
616 	lookup = fdt_node_offset_by_phandle(blob, fdt32_to_cpu(*phandle));
617 	return lookup;
618 }
619 
620 /**
621  * Look up a property in a node and check that it has a minimum length.
622  *
623  * @param blob		FDT blob
624  * @param node		node to examine
625  * @param prop_name	name of property to find
626  * @param min_len	minimum property length in bytes
627  * @param err		0 if ok, or -FDT_ERR_NOTFOUND if the property is not
628 			found, or -FDT_ERR_BADLAYOUT if not enough data
629  * @return pointer to cell, which is only valid if err == 0
630  */
631 static const void *get_prop_check_min_len(const void *blob, int node,
632 		const char *prop_name, int min_len, int *err)
633 {
634 	const void *cell;
635 	int len;
636 
637 	debug("%s: %s\n", __func__, prop_name);
638 	cell = fdt_getprop(blob, node, prop_name, &len);
639 	if (!cell)
640 		*err = -FDT_ERR_NOTFOUND;
641 	else if (len < min_len)
642 		*err = -FDT_ERR_BADLAYOUT;
643 	else
644 		*err = 0;
645 	return cell;
646 }
647 
648 int fdtdec_get_int_array(const void *blob, int node, const char *prop_name,
649 		u32 *array, int count)
650 {
651 	const u32 *cell;
652 	int i, err = 0;
653 
654 	debug("%s: %s\n", __func__, prop_name);
655 	cell = get_prop_check_min_len(blob, node, prop_name,
656 				      sizeof(u32) * count, &err);
657 	if (!err) {
658 		for (i = 0; i < count; i++)
659 			array[i] = fdt32_to_cpu(cell[i]);
660 	}
661 	return err;
662 }
663 
664 int fdtdec_get_int_array_count(const void *blob, int node,
665 			       const char *prop_name, u32 *array, int count)
666 {
667 	const u32 *cell;
668 	int len, elems;
669 	int i;
670 
671 	debug("%s: %s\n", __func__, prop_name);
672 	cell = fdt_getprop(blob, node, prop_name, &len);
673 	if (!cell)
674 		return -FDT_ERR_NOTFOUND;
675 	elems = len / sizeof(u32);
676 	if (count > elems)
677 		count = elems;
678 	for (i = 0; i < count; i++)
679 		array[i] = fdt32_to_cpu(cell[i]);
680 
681 	return count;
682 }
683 
684 const u32 *fdtdec_locate_array(const void *blob, int node,
685 			       const char *prop_name, int count)
686 {
687 	const u32 *cell;
688 	int err;
689 
690 	cell = get_prop_check_min_len(blob, node, prop_name,
691 				      sizeof(u32) * count, &err);
692 	return err ? NULL : cell;
693 }
694 
695 int fdtdec_get_bool(const void *blob, int node, const char *prop_name)
696 {
697 	const s32 *cell;
698 	int len;
699 
700 	debug("%s: %s\n", __func__, prop_name);
701 	cell = fdt_getprop(blob, node, prop_name, &len);
702 	return cell != NULL;
703 }
704 
705 int fdtdec_parse_phandle_with_args(const void *blob, int src_node,
706 				   const char *list_name,
707 				   const char *cells_name,
708 				   int cell_count, int index,
709 				   struct fdtdec_phandle_args *out_args)
710 {
711 	const __be32 *list, *list_end;
712 	int rc = 0, size, cur_index = 0;
713 	uint32_t count = 0;
714 	int node = -1;
715 	int phandle;
716 
717 	/* Retrieve the phandle list property */
718 	list = fdt_getprop(blob, src_node, list_name, &size);
719 	if (!list)
720 		return -ENOENT;
721 	list_end = list + size / sizeof(*list);
722 
723 	/* Loop over the phandles until all the requested entry is found */
724 	while (list < list_end) {
725 		rc = -EINVAL;
726 		count = 0;
727 
728 		/*
729 		 * If phandle is 0, then it is an empty entry with no
730 		 * arguments.  Skip forward to the next entry.
731 		 */
732 		phandle = be32_to_cpup(list++);
733 		if (phandle) {
734 			/*
735 			 * Find the provider node and parse the #*-cells
736 			 * property to determine the argument length.
737 			 *
738 			 * This is not needed if the cell count is hard-coded
739 			 * (i.e. cells_name not set, but cell_count is set),
740 			 * except when we're going to return the found node
741 			 * below.
742 			 */
743 			if (cells_name || cur_index == index) {
744 				node = fdt_node_offset_by_phandle(blob,
745 								  phandle);
746 				if (!node) {
747 					debug("%s: could not find phandle\n",
748 					      fdt_get_name(blob, src_node,
749 							   NULL));
750 					goto err;
751 				}
752 			}
753 
754 			if (cells_name) {
755 				count = fdtdec_get_int(blob, node, cells_name,
756 						       -1);
757 				if (count == -1) {
758 					debug("%s: could not get %s for %s\n",
759 					      fdt_get_name(blob, src_node,
760 							   NULL),
761 					      cells_name,
762 					      fdt_get_name(blob, node,
763 							   NULL));
764 					goto err;
765 				}
766 			} else {
767 				count = cell_count;
768 			}
769 
770 			/*
771 			 * Make sure that the arguments actually fit in the
772 			 * remaining property data length
773 			 */
774 			if (list + count > list_end) {
775 				debug("%s: arguments longer than property\n",
776 				      fdt_get_name(blob, src_node, NULL));
777 				goto err;
778 			}
779 		}
780 
781 		/*
782 		 * All of the error cases above bail out of the loop, so at
783 		 * this point, the parsing is successful. If the requested
784 		 * index matches, then fill the out_args structure and return,
785 		 * or return -ENOENT for an empty entry.
786 		 */
787 		rc = -ENOENT;
788 		if (cur_index == index) {
789 			if (!phandle)
790 				goto err;
791 
792 			if (out_args) {
793 				int i;
794 
795 				if (count > MAX_PHANDLE_ARGS) {
796 					debug("%s: too many arguments %d\n",
797 					      fdt_get_name(blob, src_node,
798 							   NULL), count);
799 					count = MAX_PHANDLE_ARGS;
800 				}
801 				out_args->node = node;
802 				out_args->args_count = count;
803 				for (i = 0; i < count; i++) {
804 					out_args->args[i] =
805 							be32_to_cpup(list++);
806 				}
807 			}
808 
809 			/* Found it! return success */
810 			return 0;
811 		}
812 
813 		node = -1;
814 		list += count;
815 		cur_index++;
816 	}
817 
818 	/*
819 	 * Result will be one of:
820 	 * -ENOENT : index is for empty phandle
821 	 * -EINVAL : parsing error on data
822 	 * [1..n]  : Number of phandle (count mode; when index = -1)
823 	 */
824 	rc = index < 0 ? cur_index : -ENOENT;
825  err:
826 	return rc;
827 }
828 
829 int fdtdec_get_child_count(const void *blob, int node)
830 {
831 	int subnode;
832 	int num = 0;
833 
834 	fdt_for_each_subnode(blob, subnode, node)
835 		num++;
836 
837 	return num;
838 }
839 
840 int fdtdec_get_byte_array(const void *blob, int node, const char *prop_name,
841 		u8 *array, int count)
842 {
843 	const u8 *cell;
844 	int err;
845 
846 	cell = get_prop_check_min_len(blob, node, prop_name, count, &err);
847 	if (!err)
848 		memcpy(array, cell, count);
849 	return err;
850 }
851 
852 const u8 *fdtdec_locate_byte_array(const void *blob, int node,
853 			     const char *prop_name, int count)
854 {
855 	const u8 *cell;
856 	int err;
857 
858 	cell = get_prop_check_min_len(blob, node, prop_name, count, &err);
859 	if (err)
860 		return NULL;
861 	return cell;
862 }
863 
864 int fdtdec_get_config_int(const void *blob, const char *prop_name,
865 		int default_val)
866 {
867 	int config_node;
868 
869 	debug("%s: %s\n", __func__, prop_name);
870 	config_node = fdt_path_offset(blob, "/config");
871 	if (config_node < 0)
872 		return default_val;
873 	return fdtdec_get_int(blob, config_node, prop_name, default_val);
874 }
875 
876 int fdtdec_get_config_bool(const void *blob, const char *prop_name)
877 {
878 	int config_node;
879 	const void *prop;
880 
881 	debug("%s: %s\n", __func__, prop_name);
882 	config_node = fdt_path_offset(blob, "/config");
883 	if (config_node < 0)
884 		return 0;
885 	prop = fdt_get_property(blob, config_node, prop_name, NULL);
886 
887 	return prop != NULL;
888 }
889 
890 char *fdtdec_get_config_string(const void *blob, const char *prop_name)
891 {
892 	const char *nodep;
893 	int nodeoffset;
894 	int len;
895 
896 	debug("%s: %s\n", __func__, prop_name);
897 	nodeoffset = fdt_path_offset(blob, "/config");
898 	if (nodeoffset < 0)
899 		return NULL;
900 
901 	nodep = fdt_getprop(blob, nodeoffset, prop_name, &len);
902 	if (!nodep)
903 		return NULL;
904 
905 	return (char *)nodep;
906 }
907 
908 int fdtdec_decode_region(const void *blob, int node, const char *prop_name,
909 			 fdt_addr_t *basep, fdt_size_t *sizep)
910 {
911 	const fdt_addr_t *cell;
912 	int len;
913 
914 	debug("%s: %s: %s\n", __func__, fdt_get_name(blob, node, NULL),
915 	      prop_name);
916 	cell = fdt_getprop(blob, node, prop_name, &len);
917 	if (!cell || (len < sizeof(fdt_addr_t) * 2)) {
918 		debug("cell=%p, len=%d\n", cell, len);
919 		return -1;
920 	}
921 
922 	*basep = fdt_addr_to_cpu(*cell);
923 	*sizep = fdt_size_to_cpu(cell[1]);
924 	debug("%s: base=%08lx, size=%lx\n", __func__, (ulong)*basep,
925 	      (ulong)*sizep);
926 
927 	return 0;
928 }
929 
930 /**
931  * Read a flash entry from the fdt
932  *
933  * @param blob		FDT blob
934  * @param node		Offset of node to read
935  * @param name		Name of node being read
936  * @param entry		Place to put offset and size of this node
937  * @return 0 if ok, -ve on error
938  */
939 int fdtdec_read_fmap_entry(const void *blob, int node, const char *name,
940 			   struct fmap_entry *entry)
941 {
942 	const char *prop;
943 	u32 reg[2];
944 
945 	if (fdtdec_get_int_array(blob, node, "reg", reg, 2)) {
946 		debug("Node '%s' has bad/missing 'reg' property\n", name);
947 		return -FDT_ERR_NOTFOUND;
948 	}
949 	entry->offset = reg[0];
950 	entry->length = reg[1];
951 	entry->used = fdtdec_get_int(blob, node, "used", entry->length);
952 	prop = fdt_getprop(blob, node, "compress", NULL);
953 	entry->compress_algo = prop && !strcmp(prop, "lzo") ?
954 		FMAP_COMPRESS_LZO : FMAP_COMPRESS_NONE;
955 	prop = fdt_getprop(blob, node, "hash", &entry->hash_size);
956 	entry->hash_algo = prop ? FMAP_HASH_SHA256 : FMAP_HASH_NONE;
957 	entry->hash = (uint8_t *)prop;
958 
959 	return 0;
960 }
961 
962 u64 fdtdec_get_number(const fdt32_t *ptr, unsigned int cells)
963 {
964 	u64 number = 0;
965 
966 	while (cells--)
967 		number = (number << 32) | fdt32_to_cpu(*ptr++);
968 
969 	return number;
970 }
971 
972 int fdt_get_resource(const void *fdt, int node, const char *property,
973 		     unsigned int index, struct fdt_resource *res)
974 {
975 	const fdt32_t *ptr, *end;
976 	int na, ns, len, parent;
977 	unsigned int i = 0;
978 
979 	parent = fdt_parent_offset(fdt, node);
980 	if (parent < 0)
981 		return parent;
982 
983 	na = fdt_address_cells(fdt, parent);
984 	ns = fdt_size_cells(fdt, parent);
985 
986 	ptr = fdt_getprop(fdt, node, property, &len);
987 	if (!ptr)
988 		return len;
989 
990 	end = ptr + len / sizeof(*ptr);
991 
992 	while (ptr + na + ns <= end) {
993 		if (i == index) {
994 			res->start = res->end = fdtdec_get_number(ptr, na);
995 			res->end += fdtdec_get_number(&ptr[na], ns) - 1;
996 			return 0;
997 		}
998 
999 		ptr += na + ns;
1000 		i++;
1001 	}
1002 
1003 	return -FDT_ERR_NOTFOUND;
1004 }
1005 
1006 int fdt_get_named_resource(const void *fdt, int node, const char *property,
1007 			   const char *prop_names, const char *name,
1008 			   struct fdt_resource *res)
1009 {
1010 	int index;
1011 
1012 	index = fdt_find_string(fdt, node, prop_names, name);
1013 	if (index < 0)
1014 		return index;
1015 
1016 	return fdt_get_resource(fdt, node, property, index, res);
1017 }
1018 
1019 int fdtdec_decode_memory_region(const void *blob, int config_node,
1020 				const char *mem_type, const char *suffix,
1021 				fdt_addr_t *basep, fdt_size_t *sizep)
1022 {
1023 	char prop_name[50];
1024 	const char *mem;
1025 	fdt_size_t size, offset_size;
1026 	fdt_addr_t base, offset;
1027 	int node;
1028 
1029 	if (config_node == -1) {
1030 		config_node = fdt_path_offset(blob, "/config");
1031 		if (config_node < 0) {
1032 			debug("%s: Cannot find /config node\n", __func__);
1033 			return -ENOENT;
1034 		}
1035 	}
1036 	if (!suffix)
1037 		suffix = "";
1038 
1039 	snprintf(prop_name, sizeof(prop_name), "%s-memory%s", mem_type,
1040 		 suffix);
1041 	mem = fdt_getprop(blob, config_node, prop_name, NULL);
1042 	if (!mem) {
1043 		debug("%s: No memory type for '%s', using /memory\n", __func__,
1044 		      prop_name);
1045 		mem = "/memory";
1046 	}
1047 
1048 	node = fdt_path_offset(blob, mem);
1049 	if (node < 0) {
1050 		debug("%s: Failed to find node '%s': %s\n", __func__, mem,
1051 		      fdt_strerror(node));
1052 		return -ENOENT;
1053 	}
1054 
1055 	/*
1056 	 * Not strictly correct - the memory may have multiple banks. We just
1057 	 * use the first
1058 	 */
1059 	if (fdtdec_decode_region(blob, node, "reg", &base, &size)) {
1060 		debug("%s: Failed to decode memory region %s\n", __func__,
1061 		      mem);
1062 		return -EINVAL;
1063 	}
1064 
1065 	snprintf(prop_name, sizeof(prop_name), "%s-offset%s", mem_type,
1066 		 suffix);
1067 	if (fdtdec_decode_region(blob, config_node, prop_name, &offset,
1068 				 &offset_size)) {
1069 		debug("%s: Failed to decode memory region '%s'\n", __func__,
1070 		      prop_name);
1071 		return -EINVAL;
1072 	}
1073 
1074 	*basep = base + offset;
1075 	*sizep = offset_size;
1076 
1077 	return 0;
1078 }
1079 
1080 static int decode_timing_property(const void *blob, int node, const char *name,
1081 				  struct timing_entry *result)
1082 {
1083 	int length, ret = 0;
1084 	const u32 *prop;
1085 
1086 	prop = fdt_getprop(blob, node, name, &length);
1087 	if (!prop) {
1088 		debug("%s: could not find property %s\n",
1089 		      fdt_get_name(blob, node, NULL), name);
1090 		return length;
1091 	}
1092 
1093 	if (length == sizeof(u32)) {
1094 		result->typ = fdtdec_get_int(blob, node, name, 0);
1095 		result->min = result->typ;
1096 		result->max = result->typ;
1097 	} else {
1098 		ret = fdtdec_get_int_array(blob, node, name, &result->min, 3);
1099 	}
1100 
1101 	return ret;
1102 }
1103 
1104 int fdtdec_decode_display_timing(const void *blob, int parent, int index,
1105 				 struct display_timing *dt)
1106 {
1107 	int i, node, timings_node;
1108 	u32 val = 0;
1109 	int ret = 0;
1110 
1111 	timings_node = fdt_subnode_offset(blob, parent, "display-timings");
1112 	if (timings_node < 0)
1113 		return timings_node;
1114 
1115 	for (i = 0, node = fdt_first_subnode(blob, timings_node);
1116 	     node > 0 && i != index;
1117 	     node = fdt_next_subnode(blob, node))
1118 		i++;
1119 
1120 	if (node < 0)
1121 		return node;
1122 
1123 	memset(dt, 0, sizeof(*dt));
1124 
1125 	ret |= decode_timing_property(blob, node, "hback-porch",
1126 				      &dt->hback_porch);
1127 	ret |= decode_timing_property(blob, node, "hfront-porch",
1128 				      &dt->hfront_porch);
1129 	ret |= decode_timing_property(blob, node, "hactive", &dt->hactive);
1130 	ret |= decode_timing_property(blob, node, "hsync-len", &dt->hsync_len);
1131 	ret |= decode_timing_property(blob, node, "vback-porch",
1132 				      &dt->vback_porch);
1133 	ret |= decode_timing_property(blob, node, "vfront-porch",
1134 				      &dt->vfront_porch);
1135 	ret |= decode_timing_property(blob, node, "vactive", &dt->vactive);
1136 	ret |= decode_timing_property(blob, node, "vsync-len", &dt->vsync_len);
1137 	ret |= decode_timing_property(blob, node, "clock-frequency",
1138 				      &dt->pixelclock);
1139 
1140 	dt->flags = 0;
1141 	val = fdtdec_get_int(blob, node, "vsync-active", -1);
1142 	if (val != -1) {
1143 		dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
1144 				DISPLAY_FLAGS_VSYNC_LOW;
1145 	}
1146 	val = fdtdec_get_int(blob, node, "hsync-active", -1);
1147 	if (val != -1) {
1148 		dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
1149 				DISPLAY_FLAGS_HSYNC_LOW;
1150 	}
1151 	val = fdtdec_get_int(blob, node, "de-active", -1);
1152 	if (val != -1) {
1153 		dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
1154 				DISPLAY_FLAGS_DE_LOW;
1155 	}
1156 	val = fdtdec_get_int(blob, node, "pixelclk-active", -1);
1157 	if (val != -1) {
1158 		dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
1159 				DISPLAY_FLAGS_PIXDATA_NEGEDGE;
1160 	}
1161 
1162 	if (fdtdec_get_bool(blob, node, "interlaced"))
1163 		dt->flags |= DISPLAY_FLAGS_INTERLACED;
1164 	if (fdtdec_get_bool(blob, node, "doublescan"))
1165 		dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
1166 	if (fdtdec_get_bool(blob, node, "doubleclk"))
1167 		dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
1168 
1169 	return ret;
1170 }
1171 
1172 int fdtdec_setup(void)
1173 {
1174 #if CONFIG_IS_ENABLED(OF_CONTROL)
1175 # ifdef CONFIG_OF_EMBED
1176 	/* Get a pointer to the FDT */
1177 	gd->fdt_blob = __dtb_dt_begin;
1178 # elif defined CONFIG_OF_SEPARATE
1179 #  ifdef CONFIG_SPL_BUILD
1180 	/* FDT is at end of BSS unless it is in a different memory region */
1181 	if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS))
1182 		gd->fdt_blob = (ulong *)&_image_binary_end;
1183 	else
1184 		gd->fdt_blob = (ulong *)&__bss_end;
1185 #  else
1186 	/* FDT is at end of image */
1187 	gd->fdt_blob = (ulong *)&_end;
1188 #  endif
1189 # elif defined(CONFIG_OF_HOSTFILE)
1190 	if (sandbox_read_fdt_from_file()) {
1191 		puts("Failed to read control FDT\n");
1192 		return -1;
1193 	}
1194 # endif
1195 # ifndef CONFIG_SPL_BUILD
1196 	/* Allow the early environment to override the fdt address */
1197 	gd->fdt_blob = (void *)getenv_ulong("fdtcontroladdr", 16,
1198 						(uintptr_t)gd->fdt_blob);
1199 # endif
1200 #endif
1201 	return fdtdec_prepare_fdt();
1202 }
1203 
1204 #endif /* !USE_HOSTCC */
1205