2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2009-2014 The FreeBSD Foundation
7 * This software was developed by Andrew Turner under sponsorship from
8 * the FreeBSD Foundation.
9 * This software was developed by Semihalf under sponsorship from
10 * the FreeBSD Foundation.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/kernel.h>
40 #include <sys/module.h>
42 #include <sys/limits.h>
43 #include <sys/sysctl.h>
45 #include <machine/resource.h>
47 #include <dev/fdt/fdt_common.h>
48 #include <dev/ofw/ofw_bus.h>
49 #include <dev/ofw/ofw_bus_subr.h>
50 #include <dev/ofw/openfirm.h>
52 #include "ofw_bus_if.h"
55 #define debugf(fmt, args...) do { printf("%s(): ", __func__); \
56 printf(fmt,##args); } while (0)
58 #define debugf(fmt, args...)
61 #define FDT_COMPAT_LEN 255
62 #define FDT_TYPE_LEN 64
64 #define FDT_REG_CELLS 4
65 #define FDT_RANGES_SIZE 48
67 SYSCTL_NODE(_hw, OID_AUTO, fdt, CTLFLAG_RD, 0, "Flattened Device Tree");
69 vm_paddr_t fdt_immr_pa;
70 vm_offset_t fdt_immr_va;
71 vm_offset_t fdt_immr_size;
73 struct fdt_ic_list fdt_ic_list_head = SLIST_HEAD_INITIALIZER(fdt_ic_list_head);
75 static int fdt_is_compatible(phandle_t, const char *);
78 fdt_get_range_by_busaddr(phandle_t node, u_long addr, u_long *base,
81 pcell_t ranges[32], *rangesptr;
82 pcell_t addr_cells, size_cells, par_addr_cells;
83 u_long bus_addr, par_bus_addr, pbase, psize;
84 int err, i, len, tuple_size, tuples;
92 if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
95 * Process 'ranges' property.
97 par_addr_cells = fdt_parent_addr_cells(node);
98 if (par_addr_cells > 2) {
102 len = OF_getproplen(node, "ranges");
105 if (len > sizeof(ranges))
108 return (fdt_get_range_by_busaddr(OF_parent(node), addr,
112 if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
115 tuple_size = addr_cells + par_addr_cells + size_cells;
116 tuples = len / (tuple_size * sizeof(cell_t));
118 if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2)
124 for (i = 0; i < tuples; i++) {
125 rangesptr = &ranges[i * tuple_size];
127 bus_addr = fdt_data_get((void *)rangesptr, addr_cells);
128 if (bus_addr != addr)
130 rangesptr += addr_cells;
132 par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells);
133 rangesptr += par_addr_cells;
135 err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr,
142 *base = par_bus_addr;
144 *size = fdt_data_get((void *)rangesptr, size_cells);
153 fdt_get_range(phandle_t node, int range_id, u_long *base, u_long *size)
155 pcell_t ranges[FDT_RANGES_SIZE], *rangesptr;
156 pcell_t addr_cells, size_cells, par_addr_cells;
157 u_long par_bus_addr, pbase, psize;
160 if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
163 * Process 'ranges' property.
165 par_addr_cells = fdt_parent_addr_cells(node);
166 if (par_addr_cells > 2)
169 len = OF_getproplen(node, "ranges");
170 if (len > sizeof(ranges))
178 if (!(range_id < len))
181 if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
184 if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2)
189 rangesptr = &ranges[range_id];
191 *base = fdt_data_get((void *)rangesptr, addr_cells);
192 rangesptr += addr_cells;
194 par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells);
195 rangesptr += par_addr_cells;
197 err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr,
202 *base += par_bus_addr;
204 *size = fdt_data_get((void *)rangesptr, size_cells);
209 fdt_immr_addr(vm_offset_t immr_va)
216 * Try to access the SOC node directly i.e. through /aliases/.
218 if ((node = OF_finddevice("soc")) != 0)
219 if (fdt_is_compatible(node, "simple-bus"))
222 * Find the node the long way.
224 if ((node = OF_finddevice("/")) == 0)
227 if ((node = fdt_find_compatible(node, "simple-bus", 0)) == 0)
231 if ((r = fdt_get_range(node, 0, &base, &size)) == 0) {
233 fdt_immr_va = immr_va;
234 fdt_immr_size = size;
241 * This routine is an early-usage version of the ofw_bus_is_compatible() when
242 * the ofw_bus I/F is not available (like early console routines and similar).
243 * Note the buffer has to be on the stack since malloc() is usually not
244 * available in such cases either.
247 fdt_is_compatible(phandle_t node, const char *compatstr)
249 char buf[FDT_COMPAT_LEN];
251 int len, onelen, l, rv;
253 if ((len = OF_getproplen(node, "compatible")) <= 0)
256 compat = (char *)&buf;
257 bzero(compat, FDT_COMPAT_LEN);
259 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
262 onelen = strlen(compatstr);
265 if (strncasecmp(compat, compatstr, onelen) == 0) {
270 /* Slide to the next sub-string. */
271 l = strlen(compat) + 1;
280 fdt_is_compatible_strict(phandle_t node, const char *compatible)
282 char compat[FDT_COMPAT_LEN];
284 if (OF_getproplen(node, "compatible") <= 0)
287 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
290 if (strncasecmp(compat, compatible, FDT_COMPAT_LEN) == 0)
298 fdt_find_compatible(phandle_t start, const char *compat, int strict)
303 * Traverse all children of 'start' node, and find first with
304 * matching 'compatible' property.
306 for (child = OF_child(start); child != 0; child = OF_peer(child))
307 if (fdt_is_compatible(child, compat)) {
309 if (!fdt_is_compatible_strict(child, compat))
317 fdt_depth_search_compatible(phandle_t start, const char *compat, int strict)
319 phandle_t child, node;
322 * Depth-search all descendants of 'start' node, and find first with
323 * matching 'compatible' property.
325 for (node = OF_child(start); node != 0; node = OF_peer(node)) {
326 if (fdt_is_compatible(node, compat) &&
327 (strict == 0 || fdt_is_compatible_strict(node, compat))) {
330 child = fdt_depth_search_compatible(node, compat, strict);
338 fdt_is_enabled(phandle_t node)
343 len = OF_getprop_alloc(node, "status", sizeof(char),
347 /* It is OK if no 'status' property. */
350 /* Anything other than 'okay' means disabled. */
352 if (strncmp((char *)stat, "okay", len) == 0)
360 fdt_is_type(phandle_t node, const char *typestr)
362 char type[FDT_TYPE_LEN];
364 if (OF_getproplen(node, "device_type") <= 0)
367 if (OF_getprop(node, "device_type", type, FDT_TYPE_LEN) < 0)
370 if (strncasecmp(type, typestr, FDT_TYPE_LEN) == 0)
378 fdt_parent_addr_cells(phandle_t node)
382 /* Find out #address-cells of the superior bus. */
383 if (OF_searchprop(OF_parent(node), "#address-cells", &addr_cells,
384 sizeof(addr_cells)) <= 0)
387 return ((int)fdt32_to_cpu(addr_cells));
391 fdt_pm_is_enabled(phandle_t node)
397 #if defined(SOC_MV_KIRKWOOD) || defined(SOC_MV_DISCOVERY)
404 fdt_data_get(void *data, int cells)
408 return (fdt32_to_cpu(*((uint32_t *)data)));
410 return (fdt64_to_cpu(*((uint64_t *)data)));
414 fdt_addrsize_cells(phandle_t node, int *addr_cells, int *size_cells)
420 * Retrieve #{address,size}-cells.
422 cell_size = sizeof(cell);
423 if (OF_getencprop(node, "#address-cells", &cell, cell_size) < cell_size)
425 *addr_cells = (int)cell;
427 if (OF_getencprop(node, "#size-cells", &cell, cell_size) < cell_size)
429 *size_cells = (int)cell;
431 if (*addr_cells > 3 || *size_cells > 2)
437 fdt_data_to_res(pcell_t *data, int addr_cells, int size_cells, u_long *start,
441 /* Address portion. */
445 *start = fdt_data_get((void *)data, addr_cells);
452 *count = fdt_data_get((void *)data, size_cells);
457 fdt_regsize(phandle_t node, u_long *base, u_long *size)
460 int addr_cells, len, size_cells;
462 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells))
465 if ((sizeof(pcell_t) * (addr_cells + size_cells)) > sizeof(reg))
468 len = OF_getprop(node, "reg", ®, sizeof(reg));
472 *base = fdt_data_get(®[0], addr_cells);
473 *size = fdt_data_get(®[addr_cells], size_cells);
478 fdt_reg_to_rl(phandle_t node, struct resource_list *rl)
480 u_long end, count, start;
481 pcell_t *reg, *regptr;
482 pcell_t addr_cells, size_cells;
483 int tuple_size, tuples;
485 long busaddr, bussize;
487 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells) != 0)
489 if (fdt_get_range(OF_parent(node), 0, &busaddr, &bussize)) {
494 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
495 tuples = OF_getprop_alloc(node, "reg", tuple_size, (void **)®);
496 debugf("addr_cells = %d, size_cells = %d\n", addr_cells, size_cells);
497 debugf("tuples = %d, tuple size = %d\n", tuples, tuple_size);
499 /* No 'reg' property in this node. */
503 for (i = 0; i < tuples; i++) {
505 rv = fdt_data_to_res(reg, addr_cells, size_cells, &start,
508 resource_list_free(rl);
511 reg += addr_cells + size_cells;
513 /* Calculate address range relative to base. */
515 end = start + count - 1;
517 debugf("reg addr start = %lx, end = %lx, count = %lx\n", start,
520 resource_list_add(rl, SYS_RES_MEMORY, i, start, end,
526 OF_prop_free(regptr);
531 fdt_get_phyaddr(phandle_t node, device_t dev, int *phy_addr, void **phy_sc)
534 pcell_t phy_handle, phy_reg;
536 device_t parent, child;
538 if (OF_getencprop(node, "phy-handle", (void *)&phy_handle,
539 sizeof(phy_handle)) <= 0)
542 phy_node = OF_node_from_xref(phy_handle);
544 if (OF_getencprop(phy_node, "reg", (void *)&phy_reg,
545 sizeof(phy_reg)) <= 0)
551 * Search for softc used to communicate with phy.
555 * Step 1: Search for ancestor of the phy-node with a "phy-handle"
558 phy_node = OF_parent(phy_node);
559 while (phy_node != 0) {
560 if (OF_getprop(phy_node, "phy-handle", (void *)&phy_handle,
561 sizeof(phy_handle)) > 0)
563 phy_node = OF_parent(phy_node);
569 * Step 2: For each device with the same parent and name as ours
570 * compare its node with the one found in step 1, ancestor of phy
571 * node (stored in phy_node).
573 parent = device_get_parent(dev);
575 child = device_find_child(parent, device_get_name(dev), i);
576 while (child != NULL) {
577 if (ofw_bus_get_node(child) == phy_node)
580 child = device_find_child(parent, device_get_name(dev), i);
586 * Use softc of the device found.
588 *phy_sc = (void *)device_get_softc(child);
594 fdt_get_reserved_regions(struct mem_region *mr, int *mrcnt)
596 pcell_t reserve[FDT_REG_CELLS * FDT_MEM_REGIONS];
598 phandle_t memory, root;
599 int addr_cells, size_cells;
600 int i, res_len, rv, tuple_size, tuples;
602 root = OF_finddevice("/");
603 memory = OF_finddevice("/memory");
609 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
613 if (addr_cells > 2) {
618 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
620 res_len = OF_getproplen(root, "memreserve");
621 if (res_len <= 0 || res_len > sizeof(reserve)) {
626 if (OF_getprop(root, "memreserve", reserve, res_len) <= 0) {
631 tuples = res_len / tuple_size;
632 reservep = (pcell_t *)&reserve;
633 for (i = 0; i < tuples; i++) {
635 rv = fdt_data_to_res(reservep, addr_cells, size_cells,
636 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
641 reservep += addr_cells + size_cells;
651 fdt_get_mem_regions(struct mem_region *mr, int *mrcnt, uint64_t *memsize)
653 pcell_t reg[FDT_REG_CELLS * FDT_MEM_REGIONS];
656 uint64_t memory_size;
657 int addr_cells, size_cells;
658 int i, reg_len, rv, tuple_size, tuples;
660 memory = OF_finddevice("/memory");
666 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
670 if (addr_cells > 2) {
675 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
676 reg_len = OF_getproplen(memory, "reg");
677 if (reg_len <= 0 || reg_len > sizeof(reg)) {
682 if (OF_getprop(memory, "reg", reg, reg_len) <= 0) {
688 tuples = reg_len / tuple_size;
689 regp = (pcell_t *)®
690 for (i = 0; i < tuples; i++) {
692 rv = fdt_data_to_res(regp, addr_cells, size_cells,
693 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
698 regp += addr_cells + size_cells;
699 memory_size += mr[i].mr_size;
702 if (memory_size == 0) {
709 *memsize = memory_size;
716 fdt_get_unit(device_t dev)
720 name = ofw_bus_get_name(dev);
721 name = strchr(name, '@') + 1;
723 return (strtol(name,NULL,0));
727 fdt_get_chosen_bootargs(char *bootargs, size_t max_size)
731 chosen = OF_finddevice("/chosen");
734 if (OF_getprop(chosen, "bootargs", bootargs, max_size) == -1)