1 /*-
2 * Copyright (c) 2009-2014 The FreeBSD Foundation
3 * All rights reserved.
4 *
5 * This software was developed by Andrew Turner under sponsorship from
6 * the FreeBSD Foundation.
7 * This software was developed by Semihalf under sponsorship from
8 * the FreeBSD Foundation.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/module.h>
39 #include <sys/bus.h>
40 #include <sys/limits.h>
41
42 #include <machine/resource.h>
43
44 #include <dev/fdt/fdt_common.h>
45 #include <dev/ofw/ofw_bus.h>
46 #include <dev/ofw/ofw_bus_subr.h>
47 #include <dev/ofw/openfirm.h>
48
49 #include "ofw_bus_if.h"
50
51 #ifdef DEBUG
52 #define debugf(fmt, args...) do { printf("%s(): ", __func__); \
53 printf(fmt,##args); } while (0)
54 #else
55 #define debugf(fmt, args...)
56 #endif
57
58 #define FDT_COMPAT_LEN 255
59 #define FDT_TYPE_LEN 64
60
61 #define FDT_REG_CELLS 4
62
63 vm_paddr_t fdt_immr_pa;
64 vm_offset_t fdt_immr_va;
65 vm_offset_t fdt_immr_size;
66
67 struct fdt_ic_list fdt_ic_list_head = SLIST_HEAD_INITIALIZER(fdt_ic_list_head);
68
69 static int
fdt_get_range_by_busaddr(phandle_t node,u_long addr,u_long * base,u_long * size)70 fdt_get_range_by_busaddr(phandle_t node, u_long addr, u_long *base,
71 u_long *size)
72 {
73 pcell_t ranges[32], *rangesptr;
74 pcell_t addr_cells, size_cells, par_addr_cells;
75 u_long bus_addr, par_bus_addr, pbase, psize;
76 int err, i, len, tuple_size, tuples;
77
78 if (node == 0) {
79 *base = 0;
80 *size = ULONG_MAX;
81 return (0);
82 }
83
84 if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
85 return (ENXIO);
86 /*
87 * Process 'ranges' property.
88 */
89 par_addr_cells = fdt_parent_addr_cells(node);
90 if (par_addr_cells > 2) {
91 return (ERANGE);
92 }
93
94 len = OF_getproplen(node, "ranges");
95 if (len < 0)
96 return (-1);
97 if (len > sizeof(ranges))
98 return (ENOMEM);
99 if (len == 0) {
100 return (fdt_get_range_by_busaddr(OF_parent(node), addr,
101 base, size));
102 }
103
104 if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
105 return (EINVAL);
106
107 tuple_size = addr_cells + par_addr_cells + size_cells;
108 tuples = len / (tuple_size * sizeof(cell_t));
109
110 if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2)
111 return (ERANGE);
112
113 *base = 0;
114 *size = 0;
115
116 for (i = 0; i < tuples; i++) {
117 rangesptr = &ranges[i * tuple_size];
118
119 bus_addr = fdt_data_get((void *)rangesptr, addr_cells);
120 if (bus_addr != addr)
121 continue;
122 rangesptr += addr_cells;
123
124 par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells);
125 rangesptr += par_addr_cells;
126
127 err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr,
128 &pbase, &psize);
129 if (err > 0)
130 return (err);
131 if (err == 0)
132 *base = pbase;
133 else
134 *base = par_bus_addr;
135
136 *size = fdt_data_get((void *)rangesptr, size_cells);
137
138 return (0);
139 }
140
141 return (EINVAL);
142 }
143
144 int
fdt_get_range(phandle_t node,int range_id,u_long * base,u_long * size)145 fdt_get_range(phandle_t node, int range_id, u_long *base, u_long *size)
146 {
147 pcell_t ranges[6], *rangesptr;
148 pcell_t addr_cells, size_cells, par_addr_cells;
149 u_long par_bus_addr, pbase, psize;
150 int err, len, tuple_size, tuples;
151
152 if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
153 return (ENXIO);
154 /*
155 * Process 'ranges' property.
156 */
157 par_addr_cells = fdt_parent_addr_cells(node);
158 if (par_addr_cells > 2)
159 return (ERANGE);
160
161 len = OF_getproplen(node, "ranges");
162 if (len > sizeof(ranges))
163 return (ENOMEM);
164 if (len == 0) {
165 *base = 0;
166 *size = ULONG_MAX;
167 return (0);
168 }
169
170 if (!(range_id < len))
171 return (ERANGE);
172
173 if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
174 return (EINVAL);
175
176 tuple_size = sizeof(pcell_t) * (addr_cells + par_addr_cells +
177 size_cells);
178 tuples = len / tuple_size;
179
180 if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2)
181 return (ERANGE);
182
183 *base = 0;
184 *size = 0;
185 rangesptr = &ranges[range_id];
186
187 *base = fdt_data_get((void *)rangesptr, addr_cells);
188 rangesptr += addr_cells;
189
190 par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells);
191 rangesptr += par_addr_cells;
192
193 err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr,
194 &pbase, &psize);
195 if (err == 0)
196 *base += pbase;
197 else
198 *base += par_bus_addr;
199
200 *size = fdt_data_get((void *)rangesptr, size_cells);
201 return (0);
202 }
203
204 int
fdt_immr_addr(vm_offset_t immr_va)205 fdt_immr_addr(vm_offset_t immr_va)
206 {
207 phandle_t node;
208 u_long base, size;
209 int r;
210
211 /*
212 * Try to access the SOC node directly i.e. through /aliases/.
213 */
214 if ((node = OF_finddevice("soc")) != 0)
215 if (fdt_is_compatible_strict(node, "simple-bus"))
216 goto moveon;
217 /*
218 * Find the node the long way.
219 */
220 if ((node = OF_finddevice("/")) == 0)
221 return (ENXIO);
222
223 if ((node = fdt_find_compatible(node, "simple-bus", 1)) == 0)
224 return (ENXIO);
225
226 moveon:
227 if ((r = fdt_get_range(node, 0, &base, &size)) == 0) {
228 fdt_immr_pa = base;
229 fdt_immr_va = immr_va;
230 fdt_immr_size = size;
231 }
232
233 return (r);
234 }
235
236 /*
237 * This routine is an early-usage version of the ofw_bus_is_compatible() when
238 * the ofw_bus I/F is not available (like early console routines and similar).
239 * Note the buffer has to be on the stack since malloc() is usually not
240 * available in such cases either.
241 */
242 int
fdt_is_compatible(phandle_t node,const char * compatstr)243 fdt_is_compatible(phandle_t node, const char *compatstr)
244 {
245 char buf[FDT_COMPAT_LEN];
246 char *compat;
247 int len, onelen, l, rv;
248
249 if ((len = OF_getproplen(node, "compatible")) <= 0)
250 return (0);
251
252 compat = (char *)&buf;
253 bzero(compat, FDT_COMPAT_LEN);
254
255 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
256 return (0);
257
258 onelen = strlen(compatstr);
259 rv = 0;
260 while (len > 0) {
261 if (strncasecmp(compat, compatstr, onelen) == 0) {
262 /* Found it. */
263 rv = 1;
264 break;
265 }
266 /* Slide to the next sub-string. */
267 l = strlen(compat) + 1;
268 compat += l;
269 len -= l;
270 }
271
272 return (rv);
273 }
274
275 int
fdt_is_compatible_strict(phandle_t node,const char * compatible)276 fdt_is_compatible_strict(phandle_t node, const char *compatible)
277 {
278 char compat[FDT_COMPAT_LEN];
279
280 if (OF_getproplen(node, "compatible") <= 0)
281 return (0);
282
283 if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
284 return (0);
285
286 if (strncasecmp(compat, compatible, FDT_COMPAT_LEN) == 0)
287 /* This fits. */
288 return (1);
289
290 return (0);
291 }
292
293 phandle_t
fdt_find_compatible(phandle_t start,const char * compat,int strict)294 fdt_find_compatible(phandle_t start, const char *compat, int strict)
295 {
296 phandle_t child;
297
298 /*
299 * Traverse all children of 'start' node, and find first with
300 * matching 'compatible' property.
301 */
302 for (child = OF_child(start); child != 0; child = OF_peer(child))
303 if (fdt_is_compatible(child, compat)) {
304 if (strict)
305 if (!fdt_is_compatible_strict(child, compat))
306 continue;
307 return (child);
308 }
309 return (0);
310 }
311
312 phandle_t
fdt_depth_search_compatible(phandle_t start,const char * compat,int strict)313 fdt_depth_search_compatible(phandle_t start, const char *compat, int strict)
314 {
315 phandle_t child, node;
316
317 /*
318 * Depth-search all descendants of 'start' node, and find first with
319 * matching 'compatible' property.
320 */
321 for (node = OF_child(start); node != 0; node = OF_peer(node)) {
322 if (fdt_is_compatible(node, compat) &&
323 (strict == 0 || fdt_is_compatible_strict(node, compat))) {
324 return (node);
325 }
326 child = fdt_depth_search_compatible(node, compat, strict);
327 if (child != 0)
328 return (child);
329 }
330 return (0);
331 }
332
333 int
fdt_is_enabled(phandle_t node)334 fdt_is_enabled(phandle_t node)
335 {
336 char *stat;
337 int ena, len;
338
339 len = OF_getprop_alloc(node, "status", sizeof(char),
340 (void **)&stat);
341
342 if (len <= 0)
343 /* It is OK if no 'status' property. */
344 return (1);
345
346 /* Anything other than 'okay' means disabled. */
347 ena = 0;
348 if (strncmp((char *)stat, "okay", len) == 0)
349 ena = 1;
350
351 free(stat, M_OFWPROP);
352 return (ena);
353 }
354
355 int
fdt_is_type(phandle_t node,const char * typestr)356 fdt_is_type(phandle_t node, const char *typestr)
357 {
358 char type[FDT_TYPE_LEN];
359
360 if (OF_getproplen(node, "device_type") <= 0)
361 return (0);
362
363 if (OF_getprop(node, "device_type", type, FDT_TYPE_LEN) < 0)
364 return (0);
365
366 if (strncasecmp(type, typestr, FDT_TYPE_LEN) == 0)
367 /* This fits. */
368 return (1);
369
370 return (0);
371 }
372
373 int
fdt_parent_addr_cells(phandle_t node)374 fdt_parent_addr_cells(phandle_t node)
375 {
376 pcell_t addr_cells;
377
378 /* Find out #address-cells of the superior bus. */
379 if (OF_searchprop(OF_parent(node), "#address-cells", &addr_cells,
380 sizeof(addr_cells)) <= 0)
381 return (2);
382
383 return ((int)fdt32_to_cpu(addr_cells));
384 }
385
386 int
fdt_pm_is_enabled(phandle_t node)387 fdt_pm_is_enabled(phandle_t node)
388 {
389 int ret;
390
391 ret = 1;
392
393 #if defined(SOC_MV_KIRKWOOD) || defined(SOC_MV_DISCOVERY)
394 ret = fdt_pm(node);
395 #endif
396 return (ret);
397 }
398
399 u_long
fdt_data_get(void * data,int cells)400 fdt_data_get(void *data, int cells)
401 {
402
403 if (cells == 1)
404 return (fdt32_to_cpu(*((uint32_t *)data)));
405
406 return (fdt64_to_cpu(*((uint64_t *)data)));
407 }
408
409 int
fdt_addrsize_cells(phandle_t node,int * addr_cells,int * size_cells)410 fdt_addrsize_cells(phandle_t node, int *addr_cells, int *size_cells)
411 {
412 pcell_t cell;
413 int cell_size;
414
415 /*
416 * Retrieve #{address,size}-cells.
417 */
418 cell_size = sizeof(cell);
419 if (OF_getprop(node, "#address-cells", &cell, cell_size) < cell_size)
420 cell = 2;
421 *addr_cells = fdt32_to_cpu((int)cell);
422
423 if (OF_getprop(node, "#size-cells", &cell, cell_size) < cell_size)
424 cell = 1;
425 *size_cells = fdt32_to_cpu((int)cell);
426
427 if (*addr_cells > 3 || *size_cells > 2)
428 return (ERANGE);
429 return (0);
430 }
431
432 int
fdt_data_to_res(pcell_t * data,int addr_cells,int size_cells,u_long * start,u_long * count)433 fdt_data_to_res(pcell_t *data, int addr_cells, int size_cells, u_long *start,
434 u_long *count)
435 {
436
437 /* Address portion. */
438 if (addr_cells > 2)
439 return (ERANGE);
440
441 *start = fdt_data_get((void *)data, addr_cells);
442 data += addr_cells;
443
444 /* Size portion. */
445 if (size_cells > 2)
446 return (ERANGE);
447
448 *count = fdt_data_get((void *)data, size_cells);
449 return (0);
450 }
451
452 int
fdt_regsize(phandle_t node,u_long * base,u_long * size)453 fdt_regsize(phandle_t node, u_long *base, u_long *size)
454 {
455 pcell_t reg[4];
456 int addr_cells, len, size_cells;
457
458 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells))
459 return (ENXIO);
460
461 if ((sizeof(pcell_t) * (addr_cells + size_cells)) > sizeof(reg))
462 return (ENOMEM);
463
464 len = OF_getprop(node, "reg", ®, sizeof(reg));
465 if (len <= 0)
466 return (EINVAL);
467
468 *base = fdt_data_get(®[0], addr_cells);
469 *size = fdt_data_get(®[addr_cells], size_cells);
470 return (0);
471 }
472
473 int
fdt_reg_to_rl(phandle_t node,struct resource_list * rl)474 fdt_reg_to_rl(phandle_t node, struct resource_list *rl)
475 {
476 u_long end, count, start;
477 pcell_t *reg, *regptr;
478 pcell_t addr_cells, size_cells;
479 int tuple_size, tuples;
480 int i, rv;
481 long busaddr, bussize;
482
483 if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells) != 0)
484 return (ENXIO);
485 if (fdt_get_range(OF_parent(node), 0, &busaddr, &bussize)) {
486 busaddr = 0;
487 bussize = 0;
488 }
489
490 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
491 tuples = OF_getprop_alloc(node, "reg", tuple_size, (void **)®);
492 debugf("addr_cells = %d, size_cells = %d\n", addr_cells, size_cells);
493 debugf("tuples = %d, tuple size = %d\n", tuples, tuple_size);
494 if (tuples <= 0)
495 /* No 'reg' property in this node. */
496 return (0);
497
498 regptr = reg;
499 for (i = 0; i < tuples; i++) {
500
501 rv = fdt_data_to_res(reg, addr_cells, size_cells, &start,
502 &count);
503 if (rv != 0) {
504 resource_list_free(rl);
505 goto out;
506 }
507 reg += addr_cells + size_cells;
508
509 /* Calculate address range relative to base. */
510 start += busaddr;
511 end = start + count - 1;
512
513 debugf("reg addr start = %lx, end = %lx, count = %lx\n", start,
514 end, count);
515
516 resource_list_add(rl, SYS_RES_MEMORY, i, start, end,
517 count);
518 }
519 rv = 0;
520
521 out:
522 free(regptr, M_OFWPROP);
523 return (rv);
524 }
525
526 int
fdt_get_phyaddr(phandle_t node,device_t dev,int * phy_addr,void ** phy_sc)527 fdt_get_phyaddr(phandle_t node, device_t dev, int *phy_addr, void **phy_sc)
528 {
529 phandle_t phy_node;
530 pcell_t phy_handle, phy_reg;
531 uint32_t i;
532 device_t parent, child;
533
534 if (OF_getencprop(node, "phy-handle", (void *)&phy_handle,
535 sizeof(phy_handle)) <= 0)
536 return (ENXIO);
537
538 phy_node = OF_node_from_xref(phy_handle);
539
540 if (OF_getprop(phy_node, "reg", (void *)&phy_reg,
541 sizeof(phy_reg)) <= 0)
542 return (ENXIO);
543
544 *phy_addr = fdt32_to_cpu(phy_reg);
545
546 /*
547 * Search for softc used to communicate with phy.
548 */
549
550 /*
551 * Step 1: Search for ancestor of the phy-node with a "phy-handle"
552 * property set.
553 */
554 phy_node = OF_parent(phy_node);
555 while (phy_node != 0) {
556 if (OF_getprop(phy_node, "phy-handle", (void *)&phy_handle,
557 sizeof(phy_handle)) > 0)
558 break;
559 phy_node = OF_parent(phy_node);
560 }
561 if (phy_node == 0)
562 return (ENXIO);
563
564 /*
565 * Step 2: For each device with the same parent and name as ours
566 * compare its node with the one found in step 1, ancestor of phy
567 * node (stored in phy_node).
568 */
569 parent = device_get_parent(dev);
570 i = 0;
571 child = device_find_child(parent, device_get_name(dev), i);
572 while (child != NULL) {
573 if (ofw_bus_get_node(child) == phy_node)
574 break;
575 i++;
576 child = device_find_child(parent, device_get_name(dev), i);
577 }
578 if (child == NULL)
579 return (ENXIO);
580
581 /*
582 * Use softc of the device found.
583 */
584 *phy_sc = (void *)device_get_softc(child);
585
586 return (0);
587 }
588
589 int
fdt_get_reserved_regions(struct mem_region * mr,int * mrcnt)590 fdt_get_reserved_regions(struct mem_region *mr, int *mrcnt)
591 {
592 pcell_t reserve[FDT_REG_CELLS * FDT_MEM_REGIONS];
593 pcell_t *reservep;
594 phandle_t memory, root;
595 uint32_t memory_size;
596 int addr_cells, size_cells;
597 int i, max_size, res_len, rv, tuple_size, tuples;
598
599 max_size = sizeof(reserve);
600 root = OF_finddevice("/");
601 memory = OF_finddevice("/memory");
602 if (memory == -1) {
603 rv = ENXIO;
604 goto out;
605 }
606
607 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
608 &size_cells)) != 0)
609 goto out;
610
611 if (addr_cells > 2) {
612 rv = ERANGE;
613 goto out;
614 }
615
616 tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
617
618 res_len = OF_getproplen(root, "memreserve");
619 if (res_len <= 0 || res_len > sizeof(reserve)) {
620 rv = ERANGE;
621 goto out;
622 }
623
624 if (OF_getprop(root, "memreserve", reserve, res_len) <= 0) {
625 rv = ENXIO;
626 goto out;
627 }
628
629 memory_size = 0;
630 tuples = res_len / tuple_size;
631 reservep = (pcell_t *)&reserve;
632 for (i = 0; i < tuples; i++) {
633
634 rv = fdt_data_to_res(reservep, addr_cells, size_cells,
635 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
636
637 if (rv != 0)
638 goto out;
639
640 reservep += addr_cells + size_cells;
641 }
642
643 *mrcnt = i;
644 rv = 0;
645 out:
646 return (rv);
647 }
648
649 int
fdt_get_mem_regions(struct mem_region * mr,int * mrcnt,uint32_t * memsize)650 fdt_get_mem_regions(struct mem_region *mr, int *mrcnt, uint32_t *memsize)
651 {
652 pcell_t reg[FDT_REG_CELLS * FDT_MEM_REGIONS];
653 pcell_t *regp;
654 phandle_t memory;
655 uint32_t memory_size;
656 int addr_cells, size_cells;
657 int i, max_size, reg_len, rv, tuple_size, tuples;
658
659 max_size = sizeof(reg);
660 memory = OF_finddevice("/memory");
661 if (memory == -1) {
662 rv = ENXIO;
663 goto out;
664 }
665
666 if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
667 &size_cells)) != 0)
668 goto out;
669
670 if (addr_cells > 2) {
671 rv = ERANGE;
672 goto out;
673 }
674
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)) {
678 rv = ERANGE;
679 goto out;
680 }
681
682 if (OF_getprop(memory, "reg", reg, reg_len) <= 0) {
683 rv = ENXIO;
684 goto out;
685 }
686
687 memory_size = 0;
688 tuples = reg_len / tuple_size;
689 regp = (pcell_t *)®
690 for (i = 0; i < tuples; i++) {
691
692 rv = fdt_data_to_res(regp, addr_cells, size_cells,
693 (u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
694
695 if (rv != 0)
696 goto out;
697
698 regp += addr_cells + size_cells;
699 memory_size += mr[i].mr_size;
700 }
701
702 if (memory_size == 0) {
703 rv = ERANGE;
704 goto out;
705 }
706
707 *mrcnt = i;
708 *memsize = memory_size;
709 rv = 0;
710 out:
711 return (rv);
712 }
713
714 int
fdt_get_unit(device_t dev)715 fdt_get_unit(device_t dev)
716 {
717 const char * name;
718
719 name = ofw_bus_get_name(dev);
720 name = strchr(name, '@') + 1;
721
722 return (strtol(name,NULL,0));
723 }
724