xref: /openbmc/u-boot/drivers/core/ofnode.c (revision 6bfe3fff)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2017 Google, Inc
4  * Written by Simon Glass <sjg@chromium.org>
5  */
6 
7 #include <common.h>
8 #include <dm.h>
9 #include <fdtdec.h>
10 #include <fdt_support.h>
11 #include <linux/libfdt.h>
12 #include <dm/of_access.h>
13 #include <dm/of_addr.h>
14 #include <dm/ofnode.h>
15 #include <linux/err.h>
16 #include <linux/ioport.h>
17 
18 int ofnode_read_u32(ofnode node, const char *propname, u32 *outp)
19 {
20 	assert(ofnode_valid(node));
21 	debug("%s: %s: ", __func__, propname);
22 
23 	if (ofnode_is_np(node)) {
24 		return of_read_u32(ofnode_to_np(node), propname, outp);
25 	} else {
26 		const fdt32_t *cell;
27 		int len;
28 
29 		cell = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
30 				   propname, &len);
31 		if (!cell || len < sizeof(int)) {
32 			debug("(not found)\n");
33 			return -EINVAL;
34 		}
35 		*outp = fdt32_to_cpu(cell[0]);
36 	}
37 	debug("%#x (%d)\n", *outp, *outp);
38 
39 	return 0;
40 }
41 
42 int ofnode_read_u32_default(ofnode node, const char *propname, u32 def)
43 {
44 	assert(ofnode_valid(node));
45 	ofnode_read_u32(node, propname, &def);
46 
47 	return def;
48 }
49 
50 int ofnode_read_s32_default(ofnode node, const char *propname, s32 def)
51 {
52 	assert(ofnode_valid(node));
53 	ofnode_read_u32(node, propname, (u32 *)&def);
54 
55 	return def;
56 }
57 
58 int ofnode_read_u64(ofnode node, const char *propname, u64 *outp)
59 {
60 	const fdt64_t *cell;
61 	int len;
62 
63 	assert(ofnode_valid(node));
64 	debug("%s: %s: ", __func__, propname);
65 
66 	if (ofnode_is_np(node))
67 		return of_read_u64(ofnode_to_np(node), propname, outp);
68 
69 	cell = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
70 			   &len);
71 	if (!cell || len < sizeof(*cell)) {
72 		debug("(not found)\n");
73 		return -EINVAL;
74 	}
75 	*outp = fdt64_to_cpu(cell[0]);
76 	debug("%#llx (%lld)\n", (unsigned long long)*outp,
77 	      (unsigned long long)*outp);
78 
79 	return 0;
80 }
81 
82 int ofnode_read_u64_default(ofnode node, const char *propname, u64 def)
83 {
84 	assert(ofnode_valid(node));
85 	ofnode_read_u64(node, propname, &def);
86 
87 	return def;
88 }
89 
90 bool ofnode_read_bool(ofnode node, const char *propname)
91 {
92 	const void *prop;
93 
94 	assert(ofnode_valid(node));
95 	debug("%s: %s: ", __func__, propname);
96 
97 	prop = ofnode_get_property(node, propname, NULL);
98 
99 	debug("%s\n", prop ? "true" : "false");
100 
101 	return prop ? true : false;
102 }
103 
104 const char *ofnode_read_string(ofnode node, const char *propname)
105 {
106 	const char *str = NULL;
107 	int len = -1;
108 
109 	assert(ofnode_valid(node));
110 	debug("%s: %s: ", __func__, propname);
111 
112 	if (ofnode_is_np(node)) {
113 		struct property *prop = of_find_property(
114 				ofnode_to_np(node), propname, NULL);
115 
116 		if (prop) {
117 			str = prop->value;
118 			len = prop->length;
119 		}
120 	} else {
121 		str = fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
122 				  propname, &len);
123 	}
124 	if (!str) {
125 		debug("<not found>\n");
126 		return NULL;
127 	}
128 	if (strnlen(str, len) >= len) {
129 		debug("<invalid>\n");
130 		return NULL;
131 	}
132 	debug("%s\n", str);
133 
134 	return str;
135 }
136 
137 ofnode ofnode_find_subnode(ofnode node, const char *subnode_name)
138 {
139 	ofnode subnode;
140 
141 	assert(ofnode_valid(node));
142 	debug("%s: %s: ", __func__, subnode_name);
143 
144 	if (ofnode_is_np(node)) {
145 		const struct device_node *np = ofnode_to_np(node);
146 
147 		for (np = np->child; np; np = np->sibling) {
148 			if (!strcmp(subnode_name, np->name))
149 				break;
150 		}
151 		subnode = np_to_ofnode(np);
152 	} else {
153 		int ooffset = fdt_subnode_offset(gd->fdt_blob,
154 				ofnode_to_offset(node), subnode_name);
155 		subnode = offset_to_ofnode(ooffset);
156 	}
157 	debug("%s\n", ofnode_valid(subnode) ?
158 	      ofnode_get_name(subnode) : "<none>");
159 
160 	return subnode;
161 }
162 
163 int ofnode_read_u32_array(ofnode node, const char *propname,
164 			  u32 *out_values, size_t sz)
165 {
166 	assert(ofnode_valid(node));
167 	debug("%s: %s: ", __func__, propname);
168 
169 	if (ofnode_is_np(node)) {
170 		return of_read_u32_array(ofnode_to_np(node), propname,
171 					 out_values, sz);
172 	} else {
173 		return fdtdec_get_int_array(gd->fdt_blob,
174 					    ofnode_to_offset(node), propname,
175 					    out_values, sz);
176 	}
177 }
178 
179 ofnode ofnode_first_subnode(ofnode node)
180 {
181 	assert(ofnode_valid(node));
182 	if (ofnode_is_np(node))
183 		return np_to_ofnode(node.np->child);
184 
185 	return offset_to_ofnode(
186 		fdt_first_subnode(gd->fdt_blob, ofnode_to_offset(node)));
187 }
188 
189 ofnode ofnode_next_subnode(ofnode node)
190 {
191 	assert(ofnode_valid(node));
192 	if (ofnode_is_np(node))
193 		return np_to_ofnode(node.np->sibling);
194 
195 	return offset_to_ofnode(
196 		fdt_next_subnode(gd->fdt_blob, ofnode_to_offset(node)));
197 }
198 
199 ofnode ofnode_get_parent(ofnode node)
200 {
201 	ofnode parent;
202 
203 	assert(ofnode_valid(node));
204 	if (ofnode_is_np(node))
205 		parent = np_to_ofnode(of_get_parent(ofnode_to_np(node)));
206 	else
207 		parent.of_offset = fdt_parent_offset(gd->fdt_blob,
208 						     ofnode_to_offset(node));
209 
210 	return parent;
211 }
212 
213 const char *ofnode_get_name(ofnode node)
214 {
215 	assert(ofnode_valid(node));
216 	if (ofnode_is_np(node))
217 		return strrchr(node.np->full_name, '/') + 1;
218 
219 	return fdt_get_name(gd->fdt_blob, ofnode_to_offset(node), NULL);
220 }
221 
222 ofnode ofnode_get_by_phandle(uint phandle)
223 {
224 	ofnode node;
225 
226 	if (of_live_active())
227 		node = np_to_ofnode(of_find_node_by_phandle(phandle));
228 	else
229 		node.of_offset = fdt_node_offset_by_phandle(gd->fdt_blob,
230 							    phandle);
231 
232 	return node;
233 }
234 
235 int ofnode_read_size(ofnode node, const char *propname)
236 {
237 	int len;
238 
239 	if (ofnode_is_np(node)) {
240 		struct property *prop = of_find_property(
241 				ofnode_to_np(node), propname, NULL);
242 
243 		if (prop)
244 			return prop->length;
245 	} else {
246 		if (fdt_getprop(gd->fdt_blob, ofnode_to_offset(node), propname,
247 				&len))
248 			return len;
249 	}
250 
251 	return -EINVAL;
252 }
253 
254 fdt_addr_t ofnode_get_addr_index(ofnode node, int index)
255 {
256 	if (ofnode_is_np(node)) {
257 		const __be32 *prop_val;
258 		uint flags;
259 		u64 size;
260 		int na;
261 		int ns;
262 
263 		prop_val = of_get_address(ofnode_to_np(node), index, &size,
264 					  &flags);
265 		if (!prop_val)
266 			return FDT_ADDR_T_NONE;
267 
268 		ns = of_n_size_cells(ofnode_to_np(node));
269 
270 		if (IS_ENABLED(CONFIG_OF_TRANSLATE) && ns > 0) {
271 			return of_translate_address(ofnode_to_np(node), prop_val);
272 		} else {
273 			na = of_n_addr_cells(ofnode_to_np(node));
274 			return of_read_number(prop_val, na);
275 		}
276 	} else {
277 		return fdt_get_base_address(gd->fdt_blob,
278 					    ofnode_to_offset(node));
279 	}
280 
281 	return FDT_ADDR_T_NONE;
282 }
283 
284 fdt_addr_t ofnode_get_addr(ofnode node)
285 {
286 	return ofnode_get_addr_index(node, 0);
287 }
288 
289 int ofnode_stringlist_search(ofnode node, const char *property,
290 			     const char *string)
291 {
292 	if (ofnode_is_np(node)) {
293 		return of_property_match_string(ofnode_to_np(node),
294 						property, string);
295 	} else {
296 		int ret;
297 
298 		ret = fdt_stringlist_search(gd->fdt_blob,
299 					    ofnode_to_offset(node), property,
300 					    string);
301 		if (ret == -FDT_ERR_NOTFOUND)
302 			return -ENODATA;
303 		else if (ret < 0)
304 			return -EINVAL;
305 
306 		return ret;
307 	}
308 }
309 
310 int ofnode_read_string_index(ofnode node, const char *property, int index,
311 			     const char **outp)
312 {
313 	if (ofnode_is_np(node)) {
314 		return of_property_read_string_index(ofnode_to_np(node),
315 						     property, index, outp);
316 	} else {
317 		int len;
318 
319 		*outp = fdt_stringlist_get(gd->fdt_blob, ofnode_to_offset(node),
320 					   property, index, &len);
321 		if (len < 0)
322 			return -EINVAL;
323 		return 0;
324 	}
325 }
326 
327 int ofnode_read_string_count(ofnode node, const char *property)
328 {
329 	if (ofnode_is_np(node)) {
330 		return of_property_count_strings(ofnode_to_np(node), property);
331 	} else {
332 		return fdt_stringlist_count(gd->fdt_blob,
333 					    ofnode_to_offset(node), property);
334 	}
335 }
336 
337 static void ofnode_from_fdtdec_phandle_args(struct fdtdec_phandle_args *in,
338 					    struct ofnode_phandle_args *out)
339 {
340 	assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
341 	out->node = offset_to_ofnode(in->node);
342 	out->args_count = in->args_count;
343 	memcpy(out->args, in->args, sizeof(out->args));
344 }
345 
346 static void ofnode_from_of_phandle_args(struct of_phandle_args *in,
347 					struct ofnode_phandle_args *out)
348 {
349 	assert(OF_MAX_PHANDLE_ARGS == MAX_PHANDLE_ARGS);
350 	out->node = np_to_ofnode(in->np);
351 	out->args_count = in->args_count;
352 	memcpy(out->args, in->args, sizeof(out->args));
353 }
354 
355 int ofnode_parse_phandle_with_args(ofnode node, const char *list_name,
356 				   const char *cells_name, int cell_count,
357 				   int index,
358 				   struct ofnode_phandle_args *out_args)
359 {
360 	if (ofnode_is_np(node)) {
361 		struct of_phandle_args args;
362 		int ret;
363 
364 		ret = of_parse_phandle_with_args(ofnode_to_np(node),
365 						 list_name, cells_name, index,
366 						 &args);
367 		if (ret)
368 			return ret;
369 		ofnode_from_of_phandle_args(&args, out_args);
370 	} else {
371 		struct fdtdec_phandle_args args;
372 		int ret;
373 
374 		ret = fdtdec_parse_phandle_with_args(gd->fdt_blob,
375 						     ofnode_to_offset(node),
376 						     list_name, cells_name,
377 						     cell_count, index, &args);
378 		if (ret)
379 			return ret;
380 		ofnode_from_fdtdec_phandle_args(&args, out_args);
381 	}
382 
383 	return 0;
384 }
385 
386 int ofnode_count_phandle_with_args(ofnode node, const char *list_name,
387 				   const char *cells_name)
388 {
389 	if (ofnode_is_np(node))
390 		return of_count_phandle_with_args(ofnode_to_np(node),
391 				list_name, cells_name);
392 	else
393 		return fdtdec_parse_phandle_with_args(gd->fdt_blob,
394 				ofnode_to_offset(node), list_name, cells_name,
395 				0, -1, NULL);
396 }
397 
398 ofnode ofnode_path(const char *path)
399 {
400 	if (of_live_active())
401 		return np_to_ofnode(of_find_node_by_path(path));
402 	else
403 		return offset_to_ofnode(fdt_path_offset(gd->fdt_blob, path));
404 }
405 
406 const char *ofnode_get_chosen_prop(const char *name)
407 {
408 	ofnode chosen_node;
409 
410 	chosen_node = ofnode_path("/chosen");
411 
412 	return ofnode_read_string(chosen_node, name);
413 }
414 
415 ofnode ofnode_get_chosen_node(const char *name)
416 {
417 	const char *prop;
418 
419 	prop = ofnode_get_chosen_prop(name);
420 	if (!prop)
421 		return ofnode_null();
422 
423 	return ofnode_path(prop);
424 }
425 
426 static int decode_timing_property(ofnode node, const char *name,
427 				  struct timing_entry *result)
428 {
429 	int length, ret = 0;
430 
431 	length = ofnode_read_size(node, name);
432 	if (length < 0) {
433 		debug("%s: could not find property %s\n",
434 		      ofnode_get_name(node), name);
435 		return length;
436 	}
437 
438 	if (length == sizeof(u32)) {
439 		result->typ = ofnode_read_u32_default(node, name, 0);
440 		result->min = result->typ;
441 		result->max = result->typ;
442 	} else {
443 		ret = ofnode_read_u32_array(node, name, &result->min, 3);
444 	}
445 
446 	return ret;
447 }
448 
449 int ofnode_decode_display_timing(ofnode parent, int index,
450 				 struct display_timing *dt)
451 {
452 	int i;
453 	ofnode timings, node;
454 	u32 val = 0;
455 	int ret = 0;
456 
457 	timings = ofnode_find_subnode(parent, "display-timings");
458 	if (!ofnode_valid(timings))
459 		return -EINVAL;
460 
461 	i = 0;
462 	ofnode_for_each_subnode(node, timings) {
463 		if (i++ == index)
464 			break;
465 	}
466 
467 	if (!ofnode_valid(node))
468 		return -EINVAL;
469 
470 	memset(dt, 0, sizeof(*dt));
471 
472 	ret |= decode_timing_property(node, "hback-porch", &dt->hback_porch);
473 	ret |= decode_timing_property(node, "hfront-porch", &dt->hfront_porch);
474 	ret |= decode_timing_property(node, "hactive", &dt->hactive);
475 	ret |= decode_timing_property(node, "hsync-len", &dt->hsync_len);
476 	ret |= decode_timing_property(node, "vback-porch", &dt->vback_porch);
477 	ret |= decode_timing_property(node, "vfront-porch", &dt->vfront_porch);
478 	ret |= decode_timing_property(node, "vactive", &dt->vactive);
479 	ret |= decode_timing_property(node, "vsync-len", &dt->vsync_len);
480 	ret |= decode_timing_property(node, "clock-frequency", &dt->pixelclock);
481 
482 	dt->flags = 0;
483 	val = ofnode_read_u32_default(node, "vsync-active", -1);
484 	if (val != -1) {
485 		dt->flags |= val ? DISPLAY_FLAGS_VSYNC_HIGH :
486 				DISPLAY_FLAGS_VSYNC_LOW;
487 	}
488 	val = ofnode_read_u32_default(node, "hsync-active", -1);
489 	if (val != -1) {
490 		dt->flags |= val ? DISPLAY_FLAGS_HSYNC_HIGH :
491 				DISPLAY_FLAGS_HSYNC_LOW;
492 	}
493 	val = ofnode_read_u32_default(node, "de-active", -1);
494 	if (val != -1) {
495 		dt->flags |= val ? DISPLAY_FLAGS_DE_HIGH :
496 				DISPLAY_FLAGS_DE_LOW;
497 	}
498 	val = ofnode_read_u32_default(node, "pixelclk-active", -1);
499 	if (val != -1) {
500 		dt->flags |= val ? DISPLAY_FLAGS_PIXDATA_POSEDGE :
501 				DISPLAY_FLAGS_PIXDATA_NEGEDGE;
502 	}
503 
504 	if (ofnode_read_bool(node, "interlaced"))
505 		dt->flags |= DISPLAY_FLAGS_INTERLACED;
506 	if (ofnode_read_bool(node, "doublescan"))
507 		dt->flags |= DISPLAY_FLAGS_DOUBLESCAN;
508 	if (ofnode_read_bool(node, "doubleclk"))
509 		dt->flags |= DISPLAY_FLAGS_DOUBLECLK;
510 
511 	return ret;
512 }
513 
514 const void *ofnode_get_property(ofnode node, const char *propname, int *lenp)
515 {
516 	if (ofnode_is_np(node))
517 		return of_get_property(ofnode_to_np(node), propname, lenp);
518 	else
519 		return fdt_getprop(gd->fdt_blob, ofnode_to_offset(node),
520 				   propname, lenp);
521 }
522 
523 bool ofnode_is_available(ofnode node)
524 {
525 	if (ofnode_is_np(node))
526 		return of_device_is_available(ofnode_to_np(node));
527 	else
528 		return fdtdec_get_is_enabled(gd->fdt_blob,
529 					     ofnode_to_offset(node));
530 }
531 
532 fdt_addr_t ofnode_get_addr_size(ofnode node, const char *property,
533 				fdt_size_t *sizep)
534 {
535 	if (ofnode_is_np(node)) {
536 		int na, ns;
537 		int psize;
538 		const struct device_node *np = ofnode_to_np(node);
539 		const __be32 *prop = of_get_property(np, property, &psize);
540 
541 		if (!prop)
542 			return FDT_ADDR_T_NONE;
543 		na = of_n_addr_cells(np);
544 		ns = of_n_size_cells(np);
545 		*sizep = of_read_number(prop + na, ns);
546 
547 		if (IS_ENABLED(CONFIG_OF_TRANSLATE) && ns > 0)
548 			return of_translate_address(np, prop);
549 		else
550 			return of_read_number(prop, na);
551 	} else {
552 		return fdtdec_get_addr_size(gd->fdt_blob,
553 					    ofnode_to_offset(node), property,
554 					    sizep);
555 	}
556 }
557 
558 const uint8_t *ofnode_read_u8_array_ptr(ofnode node, const char *propname,
559 					size_t sz)
560 {
561 	if (ofnode_is_np(node)) {
562 		const struct device_node *np = ofnode_to_np(node);
563 		int psize;
564 		const __be32 *prop = of_get_property(np, propname, &psize);
565 
566 		if (!prop || sz != psize)
567 			return NULL;
568 		return (uint8_t *)prop;
569 
570 	} else {
571 		return fdtdec_locate_byte_array(gd->fdt_blob,
572 				ofnode_to_offset(node), propname, sz);
573 	}
574 }
575 
576 int ofnode_read_pci_addr(ofnode node, enum fdt_pci_space type,
577 			 const char *propname, struct fdt_pci_addr *addr)
578 {
579 	const fdt32_t *cell;
580 	int len;
581 	int ret = -ENOENT;
582 
583 	debug("%s: %s: ", __func__, propname);
584 
585 	/*
586 	 * If we follow the pci bus bindings strictly, we should check
587 	 * the value of the node's parent node's #address-cells and
588 	 * #size-cells. They need to be 3 and 2 accordingly. However,
589 	 * for simplicity we skip the check here.
590 	 */
591 	cell = ofnode_get_property(node, propname, &len);
592 	if (!cell)
593 		goto fail;
594 
595 	if ((len % FDT_PCI_REG_SIZE) == 0) {
596 		int num = len / FDT_PCI_REG_SIZE;
597 		int i;
598 
599 		for (i = 0; i < num; i++) {
600 			debug("pci address #%d: %08lx %08lx %08lx\n", i,
601 			      (ulong)fdt32_to_cpu(cell[0]),
602 			      (ulong)fdt32_to_cpu(cell[1]),
603 			      (ulong)fdt32_to_cpu(cell[2]));
604 			if ((fdt32_to_cpu(*cell) & type) == type) {
605 				addr->phys_hi = fdt32_to_cpu(cell[0]);
606 				addr->phys_mid = fdt32_to_cpu(cell[1]);
607 				addr->phys_lo = fdt32_to_cpu(cell[1]);
608 				break;
609 			}
610 
611 			cell += (FDT_PCI_ADDR_CELLS +
612 				 FDT_PCI_SIZE_CELLS);
613 		}
614 
615 		if (i == num) {
616 			ret = -ENXIO;
617 			goto fail;
618 		}
619 
620 		return 0;
621 	}
622 
623 	ret = -EINVAL;
624 
625 fail:
626 	debug("(not found)\n");
627 	return ret;
628 }
629 
630 int ofnode_read_pci_vendev(ofnode node, u16 *vendor, u16 *device)
631 {
632 	const char *list, *end;
633 	int len;
634 
635 	list = ofnode_get_property(node, "compatible", &len);
636 	if (!list)
637 		return -ENOENT;
638 
639 	end = list + len;
640 	while (list < end) {
641 		len = strlen(list);
642 		if (len >= strlen("pciVVVV,DDDD")) {
643 			char *s = strstr(list, "pci");
644 
645 			/*
646 			 * check if the string is something like pciVVVV,DDDD.RR
647 			 * or just pciVVVV,DDDD
648 			 */
649 			if (s && s[7] == ',' &&
650 			    (s[12] == '.' || s[12] == 0)) {
651 				s += 3;
652 				*vendor = simple_strtol(s, NULL, 16);
653 
654 				s += 5;
655 				*device = simple_strtol(s, NULL, 16);
656 
657 				return 0;
658 			}
659 		}
660 		list += (len + 1);
661 	}
662 
663 	return -ENOENT;
664 }
665 
666 int ofnode_read_addr_cells(ofnode node)
667 {
668 	if (ofnode_is_np(node))
669 		return of_n_addr_cells(ofnode_to_np(node));
670 	else  /* NOTE: this call should walk up the parent stack */
671 		return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
672 }
673 
674 int ofnode_read_size_cells(ofnode node)
675 {
676 	if (ofnode_is_np(node))
677 		return of_n_size_cells(ofnode_to_np(node));
678 	else  /* NOTE: this call should walk up the parent stack */
679 		return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
680 }
681 
682 int ofnode_read_simple_addr_cells(ofnode node)
683 {
684 	if (ofnode_is_np(node))
685 		return of_simple_addr_cells(ofnode_to_np(node));
686 	else
687 		return fdt_address_cells(gd->fdt_blob, ofnode_to_offset(node));
688 }
689 
690 int ofnode_read_simple_size_cells(ofnode node)
691 {
692 	if (ofnode_is_np(node))
693 		return of_simple_size_cells(ofnode_to_np(node));
694 	else
695 		return fdt_size_cells(gd->fdt_blob, ofnode_to_offset(node));
696 }
697 
698 bool ofnode_pre_reloc(ofnode node)
699 {
700 	if (ofnode_read_bool(node, "u-boot,dm-pre-reloc"))
701 		return true;
702 	if (ofnode_read_bool(node, "u-boot,dm-pre-proper"))
703 		return true;
704 
705 #ifdef CONFIG_TPL_BUILD
706 	if (ofnode_read_bool(node, "u-boot,dm-tpl"))
707 		return true;
708 #elif defined(CONFIG_SPL_BUILD)
709 	if (ofnode_read_bool(node, "u-boot,dm-spl"))
710 		return true;
711 #else
712 	/*
713 	 * In regular builds individual spl and tpl handling both
714 	 * count as handled pre-relocation for later second init.
715 	 */
716 	if (ofnode_read_bool(node, "u-boot,dm-spl") ||
717 	    ofnode_read_bool(node, "u-boot,dm-tpl"))
718 		return true;
719 #endif
720 
721 	return false;
722 }
723 
724 int ofnode_read_resource(ofnode node, uint index, struct resource *res)
725 {
726 	if (ofnode_is_np(node)) {
727 		return of_address_to_resource(ofnode_to_np(node), index, res);
728 	} else {
729 		struct fdt_resource fres;
730 		int ret;
731 
732 		ret = fdt_get_resource(gd->fdt_blob, ofnode_to_offset(node),
733 				       "reg", index, &fres);
734 		if (ret < 0)
735 			return -EINVAL;
736 		memset(res, '\0', sizeof(*res));
737 		res->start = fres.start;
738 		res->end = fres.end;
739 
740 		return 0;
741 	}
742 }
743 
744 int ofnode_read_resource_byname(ofnode node, const char *name,
745 				struct resource *res)
746 {
747 	int index;
748 
749 	index = ofnode_stringlist_search(node, "reg-names", name);
750 	if (index < 0)
751 		return index;
752 
753 	return ofnode_read_resource(node, index, res);
754 }
755 
756 u64 ofnode_translate_address(ofnode node, const fdt32_t *in_addr)
757 {
758 	if (ofnode_is_np(node))
759 		return of_translate_address(ofnode_to_np(node), in_addr);
760 	else
761 		return fdt_translate_address(gd->fdt_blob, ofnode_to_offset(node), in_addr);
762 }
763 
764 int ofnode_device_is_compatible(ofnode node, const char *compat)
765 {
766 	if (ofnode_is_np(node))
767 		return of_device_is_compatible(ofnode_to_np(node), compat,
768 					       NULL, NULL);
769 	else
770 		return !fdt_node_check_compatible(gd->fdt_blob,
771 						  ofnode_to_offset(node),
772 						  compat);
773 }
774 
775 ofnode ofnode_by_compatible(ofnode from, const char *compat)
776 {
777 	if (of_live_active()) {
778 		return np_to_ofnode(of_find_compatible_node(
779 			(struct device_node *)ofnode_to_np(from), NULL,
780 			compat));
781 	} else {
782 		return offset_to_ofnode(fdt_node_offset_by_compatible(
783 				gd->fdt_blob, ofnode_to_offset(from), compat));
784 	}
785 }
786 
787 ofnode ofnode_by_prop_value(ofnode from, const char *propname,
788 			    const void *propval, int proplen)
789 {
790 	if (of_live_active()) {
791 		return np_to_ofnode(of_find_node_by_prop_value(
792 			(struct device_node *)ofnode_to_np(from), propname,
793 			propval, proplen));
794 	} else {
795 		return offset_to_ofnode(fdt_node_offset_by_prop_value(
796 				gd->fdt_blob, ofnode_to_offset(from),
797 				propname, propval, proplen));
798 	}
799 }
800 
801 int ofnode_write_prop(ofnode node, const char *propname, int len,
802 		      const void *value)
803 {
804 	const struct device_node *np = ofnode_to_np(node);
805 	struct property *pp;
806 	struct property *pp_last = NULL;
807 	struct property *new;
808 
809 	if (!of_live_active())
810 		return -ENOSYS;
811 
812 	if (!np)
813 		return -EINVAL;
814 
815 	for (pp = np->properties; pp; pp = pp->next) {
816 		if (strcmp(pp->name, propname) == 0) {
817 			/* Property exists -> change value */
818 			pp->value = (void *)value;
819 			pp->length = len;
820 			return 0;
821 		}
822 		pp_last = pp;
823 	}
824 
825 	if (!pp_last)
826 		return -ENOENT;
827 
828 	/* Property does not exist -> append new property */
829 	new = malloc(sizeof(struct property));
830 	if (!new)
831 		return -ENOMEM;
832 
833 	new->name = strdup(propname);
834 	if (!new->name)
835 		return -ENOMEM;
836 
837 	new->value = (void *)value;
838 	new->length = len;
839 	new->next = NULL;
840 
841 	pp_last->next = new;
842 
843 	return 0;
844 }
845 
846 int ofnode_write_string(ofnode node, const char *propname, const char *value)
847 {
848 	if (!of_live_active())
849 		return -ENOSYS;
850 
851 	assert(ofnode_valid(node));
852 
853 	debug("%s: %s = %s", __func__, propname, value);
854 
855 	return ofnode_write_prop(node, propname, strlen(value) + 1, value);
856 }
857 
858 int ofnode_set_enabled(ofnode node, bool value)
859 {
860 	if (!of_live_active())
861 		return -ENOSYS;
862 
863 	assert(ofnode_valid(node));
864 
865 	if (value)
866 		return ofnode_write_string(node, "status", "okay");
867 	else
868 		return ofnode_write_string(node, "status", "disable");
869 }
870