2 * Copyright (c) 2009-2010 The FreeBSD Foundation
5 * This software was developed by Semihalf under sponsorship from
6 * the FreeBSD Foundation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/module.h>
38 #include <sys/limits.h>
40 #include <machine/resource.h>
42 #include <dev/fdt/fdt_common.h>
43 #include <dev/ofw/ofw_bus.h>
44 #include <dev/ofw/ofw_bus_subr.h>
45 #include <dev/ofw/openfirm.h>
47 #include "ofw_bus_if.h"
50 #define debugf(fmt, args...) do { printf("%s(): ", __func__); \
51 printf(fmt,##args); } while (0)
53 #define debugf(fmt, args...)
56 #define FDT_COMPAT_LEN 255
57 #define FDT_TYPE_LEN 64
59 #define FDT_REG_CELLS 4
61 vm_paddr_t fdt_immr_pa;
62 vm_offset_t fdt_immr_va;
63 vm_offset_t fdt_immr_size;
65 struct fdt_ic_list fdt_ic_list_head = SLIST_HEAD_INITIALIZER(fdt_ic_list_head);
68 fdt_get_range(phandle_t node, int range_id, u_long *base, u_long *size)
70 pcell_t ranges[6], *rangesptr;
71 pcell_t addr_cells, size_cells, par_addr_cells;
72 int len, tuple_size, tuples;
74 if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
77 * Process 'ranges' property.
79 par_addr_cells = fdt_parent_addr_cells(node);
80 if (par_addr_cells > 2)
83 len = OF_getproplen(node, "ranges");
84 if (len > sizeof(ranges))
92 if (!(range_id < len))
95 if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
98 tuple_size = sizeof(pcell_t) * (addr_cells + par_addr_cells +
100 tuples = len / tuple_size;
102 if (fdt_ranges_verify(ranges, tuples, par_addr_cells,
103 addr_cells, size_cells)) {
108 rangesptr = &ranges[range_id];
110 *base = fdt_data_get((void *)rangesptr, addr_cells);
111 rangesptr += addr_cells;
112 *base += fdt_data_get((void *)rangesptr, par_addr_cells);
113 rangesptr += par_addr_cells;
114 *size = fdt_data_get((void *)rangesptr, size_cells);
119 fdt_immr_addr(vm_offset_t immr_va)
126 * Try to access the SOC node directly i.e. through /aliases/.
128 if ((node = OF_finddevice("soc")) != 0)
129 if (fdt_is_compatible_strict(node, "simple-bus"))
132 * Find the node the long way.
134 if ((node = OF_finddevice("/")) == 0)
137 if ((node = fdt_find_compatible(node, "simple-bus", 1)) == 0)
141 if ((r = fdt_get_range(node, 0, &base, &size)) == 0) {
143 fdt_immr_va = immr_va;
144 fdt_immr_size = size;
151 * This routine is an early-usage version of the ofw_bus_is_compatible() when
152 * the ofw_bus I/F is not available (like early console routines and similar).
153 * Note the buffer has to be on the stack since malloc() is usually not
154 * available in such cases either.
157 fdt_is_compatible(phandle_t node, const char *compatstr)
159 char buf[FDT_COMPAT_LEN];
161 int len, onelen, l, rv;
163 if ((len = OF_getproplen(node, "compatible")) <= 0)
166 compat = (char *)&buf;
167 bzero(compat, FDT_COMPAT_LEN);
169 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
172 onelen = strlen(compatstr);
175 if (strncasecmp(compat, compatstr, onelen) == 0) {
180 /* Slide to the next sub-string. */
181 l = strlen(compat) + 1;
190 fdt_is_compatible_strict(phandle_t node, const char *compatible)
192 char compat[FDT_COMPAT_LEN];
194 if (OF_getproplen(node, "compatible") <= 0)
197 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
200 if (strncasecmp(compat, compatible, FDT_COMPAT_LEN) == 0)
208 fdt_find_compatible(phandle_t start, const char *compat, int strict)
213 * Traverse all children of 'start' node, and find first with
214 * matching 'compatible' property.
216 for (child = OF_child(start); child != 0; child = OF_peer(child))
217 if (fdt_is_compatible(child, compat)) {
219 if (!fdt_is_compatible_strict(child, compat))
227 fdt_depth_search_compatible(phandle_t start, const char *compat, int strict)
229 phandle_t child, node;
232 * Depth-search all descendants of 'start' node, and find first with
233 * matching 'compatible' property.
235 for (node = OF_child(start); node != 0; node = OF_peer(node)) {
236 if (fdt_is_compatible(node, compat) &&
237 (strict == 0 || fdt_is_compatible_strict(node, compat))) {
240 child = fdt_depth_search_compatible(node, compat, strict);
248 fdt_is_enabled(phandle_t node)
253 len = OF_getprop_alloc(node, "status", sizeof(char),
257 /* It is OK if no 'status' property. */
260 /* Anything other than 'okay' means disabled. */
262 if (strncmp((char *)stat, "okay", len) == 0)
265 free(stat, M_OFWPROP);
270 fdt_is_type(phandle_t node, const char *typestr)
272 char type[FDT_TYPE_LEN];
274 if (OF_getproplen(node, "device_type") <= 0)
277 if (OF_getprop(node, "device_type", type, FDT_TYPE_LEN) < 0)
280 if (strncasecmp(type, typestr, FDT_TYPE_LEN) == 0)
288 fdt_parent_addr_cells(phandle_t node)
292 /* Find out #address-cells of the superior bus. */
293 if (OF_searchprop(OF_parent(node), "#address-cells", &addr_cells,
294 sizeof(addr_cells)) <= 0)
297 return ((int)fdt32_to_cpu(addr_cells));
301 fdt_data_verify(void *data, int cells)
306 d64 = fdt64_to_cpu(*((uint64_t *)data));
307 if (((d64 >> 32) & 0xffffffffull) != 0 || cells > 2)
315 fdt_pm_is_enabled(phandle_t node)
321 #if defined(SOC_MV_KIRKWOOD) || defined(SOC_MV_DISCOVERY)
328 fdt_data_get(void *data, int cells)
332 return (fdt32_to_cpu(*((uint32_t *)data)));
334 return (fdt64_to_cpu(*((uint64_t *)data)));
338 fdt_addrsize_cells(phandle_t node, int *addr_cells, int *size_cells)
344 * Retrieve #{address,size}-cells.
346 cell_size = sizeof(cell);
347 if (OF_getprop(node, "#address-cells", &cell, cell_size) < cell_size)
349 *addr_cells = fdt32_to_cpu((int)cell);
351 if (OF_getprop(node, "#size-cells", &cell, cell_size) < cell_size)
353 *size_cells = fdt32_to_cpu((int)cell);
355 if (*addr_cells > 3 || *size_cells > 2)
361 fdt_ranges_verify(pcell_t *ranges, int tuples, int par_addr_cells,
362 int this_addr_cells, int this_size_cells)
366 if (par_addr_cells > 2 || this_addr_cells > 2 || this_size_cells > 2)
370 * This is the max size the resource manager can handle for addresses
373 ulsz = sizeof(u_long);
374 if (par_addr_cells <= ulsz && this_addr_cells <= ulsz &&
375 this_size_cells <= ulsz)
376 /* We can handle everything */
380 for (i = 0; i < tuples; i++) {
382 if (fdt_data_verify((void *)ranges, par_addr_cells))
384 ranges += par_addr_cells;
386 if (fdt_data_verify((void *)ranges, this_addr_cells))
388 ranges += this_addr_cells;
390 if (fdt_data_verify((void *)ranges, this_size_cells))
392 ranges += this_size_cells;
398 debugf("using address range >%d-bit not supported\n", ulsz * 8);
403 fdt_data_to_res(pcell_t *data, int addr_cells, int size_cells, u_long *start,
407 /* Address portion. */
408 if (fdt_data_verify((void *)data, addr_cells))
411 *start = fdt_data_get((void *)data, addr_cells);
415 if (fdt_data_verify((void *)data, size_cells))
418 *count = fdt_data_get((void *)data, size_cells);
423 fdt_regsize(phandle_t node, u_long *base, u_long *size)
426 int addr_cells, len, size_cells;
428 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells))
431 if ((sizeof(pcell_t) * (addr_cells + size_cells)) > sizeof(reg))
434 len = OF_getprop(node, "reg", ®, sizeof(reg));
438 *base = fdt_data_get(®[0], addr_cells);
439 *size = fdt_data_get(®[addr_cells], size_cells);
444 fdt_reg_to_rl(phandle_t node, struct resource_list *rl)
446 u_long end, count, start;
447 pcell_t *reg, *regptr;
448 pcell_t addr_cells, size_cells;
449 int tuple_size, tuples;
451 long busaddr, bussize;
453 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells) != 0)
455 if (fdt_get_range(OF_parent(node), 0, &busaddr, &bussize)) {
460 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
461 tuples = OF_getprop_alloc(node, "reg", tuple_size, (void **)®);
462 debugf("addr_cells = %d, size_cells = %d\n", addr_cells, size_cells);
463 debugf("tuples = %d, tuple size = %d\n", tuples, tuple_size);
465 /* No 'reg' property in this node. */
469 for (i = 0; i < tuples; i++) {
471 rv = fdt_data_to_res(reg, addr_cells, size_cells, &start,
474 resource_list_free(rl);
477 reg += addr_cells + size_cells;
479 /* Calculate address range relative to base. */
481 end = start + count - 1;
483 debugf("reg addr start = %lx, end = %lx, count = %lx\n", start,
486 resource_list_add(rl, SYS_RES_MEMORY, i, start, end,
492 free(regptr, M_OFWPROP);
497 fdt_get_phyaddr(phandle_t node, device_t dev, int *phy_addr, void **phy_sc)
500 pcell_t phy_handle, phy_reg;
502 device_t parent, child;
504 if (OF_getencprop(node, "phy-handle", (void *)&phy_handle,
505 sizeof(phy_handle)) <= 0)
508 phy_node = OF_node_from_xref(phy_handle);
510 if (OF_getprop(phy_node, "reg", (void *)&phy_reg,
511 sizeof(phy_reg)) <= 0)
514 *phy_addr = fdt32_to_cpu(phy_reg);
517 * Search for softc used to communicate with phy.
521 * Step 1: Search for ancestor of the phy-node with a "phy-handle"
524 phy_node = OF_parent(phy_node);
525 while (phy_node != 0) {
526 if (OF_getprop(phy_node, "phy-handle", (void *)&phy_handle,
527 sizeof(phy_handle)) > 0)
529 phy_node = OF_parent(phy_node);
535 * Step 2: For each device with the same parent and name as ours
536 * compare its node with the one found in step 1, ancestor of phy
537 * node (stored in phy_node).
539 parent = device_get_parent(dev);
541 child = device_find_child(parent, device_get_name(dev), i);
542 while (child != NULL) {
543 if (ofw_bus_get_node(child) == phy_node)
546 child = device_find_child(parent, device_get_name(dev), i);
552 * Use softc of the device found.
554 *phy_sc = (void *)device_get_softc(child);
560 fdt_get_reserved_regions(struct mem_region *mr, int *mrcnt)
562 pcell_t reserve[FDT_REG_CELLS * FDT_MEM_REGIONS];
564 phandle_t memory, root;
565 uint32_t memory_size;
566 int addr_cells, size_cells;
567 int i, max_size, res_len, rv, tuple_size, tuples;
569 max_size = sizeof(reserve);
570 root = OF_finddevice("/");
571 memory = OF_finddevice("/memory");
577 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
581 if (addr_cells > 2) {
586 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
588 res_len = OF_getproplen(root, "memreserve");
589 if (res_len <= 0 || res_len > sizeof(reserve)) {
594 if (OF_getprop(root, "memreserve", reserve, res_len) <= 0) {
600 tuples = res_len / tuple_size;
601 reservep = (pcell_t *)&reserve;
602 for (i = 0; i < tuples; i++) {
604 rv = fdt_data_to_res(reservep, addr_cells, size_cells,
605 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
610 reservep += addr_cells + size_cells;
620 fdt_get_mem_regions(struct mem_region *mr, int *mrcnt, uint32_t *memsize)
622 pcell_t reg[FDT_REG_CELLS * FDT_MEM_REGIONS];
625 uint32_t memory_size;
626 int addr_cells, size_cells;
627 int i, max_size, reg_len, rv, tuple_size, tuples;
629 max_size = sizeof(reg);
630 memory = OF_finddevice("/memory");
636 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
640 if (addr_cells > 2) {
645 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
646 reg_len = OF_getproplen(memory, "reg");
647 if (reg_len <= 0 || reg_len > sizeof(reg)) {
652 if (OF_getprop(memory, "reg", reg, reg_len) <= 0) {
658 tuples = reg_len / tuple_size;
659 regp = (pcell_t *)®
660 for (i = 0; i < tuples; i++) {
662 rv = fdt_data_to_res(regp, addr_cells, size_cells,
663 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
668 regp += addr_cells + size_cells;
669 memory_size += mr[i].mr_size;
672 if (memory_size == 0) {
678 *memsize = memory_size;
685 fdt_get_unit(device_t dev)
689 name = ofw_bus_get_name(dev);
690 name = strchr(name, '@') + 1;
692 return (strtol(name,NULL,0));