1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2009-2014 The FreeBSD Foundation
5 * All rights reserved.
6 *
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.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
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.
20 *
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
31 * SUCH DAMAGE.
32 */
33
34#include <sys/cdefs.h>
35__FBSDID("$FreeBSD$");
36
37#include <sys/param.h>
38#include <sys/systm.h>
39#include <sys/kernel.h>
40#include <sys/module.h>
41#include <sys/bus.h>
42#include <sys/limits.h>
43#include <sys/sysctl.h>
44
45#include <machine/resource.h>
46
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>
51
52#include "ofw_bus_if.h"
53
54#ifdef DEBUG
55#define debugf(fmt, args...) do { printf("%s(): ", __func__);	\
56    printf(fmt,##args); } while (0)
57#else
58#define debugf(fmt, args...)
59#endif
60
61#define FDT_COMPAT_LEN	255
62
63#define FDT_REG_CELLS	4
64#define FDT_RANGES_SIZE 48
65
66SYSCTL_NODE(_hw, OID_AUTO, fdt, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
67    "Flattened Device Tree");
68
69vm_paddr_t fdt_immr_pa;
70vm_offset_t fdt_immr_va;
71vm_offset_t fdt_immr_size;
72
73struct fdt_ic_list fdt_ic_list_head = SLIST_HEAD_INITIALIZER(fdt_ic_list_head);
74
75static int
76fdt_get_range_by_busaddr(phandle_t node, u_long addr, u_long *base,
77    u_long *size)
78{
79	pcell_t ranges[32], *rangesptr;
80	pcell_t addr_cells, size_cells, par_addr_cells;
81	u_long bus_addr, par_bus_addr, pbase, psize;
82	int err, i, len, tuple_size, tuples;
83
84	if (node == 0) {
85		*base = 0;
86		*size = ULONG_MAX;
87		return (0);
88	}
89
90	if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
91		return (ENXIO);
92	/*
93	 * Process 'ranges' property.
94	 */
95	par_addr_cells = fdt_parent_addr_cells(node);
96	if (par_addr_cells > 2) {
97		return (ERANGE);
98	}
99
100	len = OF_getproplen(node, "ranges");
101	if (len < 0)
102		return (-1);
103	if (len > sizeof(ranges))
104		return (ENOMEM);
105	if (len == 0) {
106		return (fdt_get_range_by_busaddr(OF_parent(node), addr,
107		    base, size));
108	}
109
110	if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
111		return (EINVAL);
112
113	tuple_size = addr_cells + par_addr_cells + size_cells;
114	tuples = len / (tuple_size * sizeof(cell_t));
115
116	if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2)
117		return (ERANGE);
118
119	*base = 0;
120	*size = 0;
121
122	for (i = 0; i < tuples; i++) {
123		rangesptr = &ranges[i * tuple_size];
124
125		bus_addr = fdt_data_get((void *)rangesptr, addr_cells);
126		if (bus_addr != addr)
127			continue;
128		rangesptr += addr_cells;
129
130		par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells);
131		rangesptr += par_addr_cells;
132
133		err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr,
134		    &pbase, &psize);
135		if (err > 0)
136			return (err);
137		if (err == 0)
138			*base = pbase;
139		else
140			*base = par_bus_addr;
141
142		*size = fdt_data_get((void *)rangesptr, size_cells);
143
144		return (0);
145	}
146
147	return (EINVAL);
148}
149
150int
151fdt_get_range(phandle_t node, int range_id, u_long *base, u_long *size)
152{
153	pcell_t ranges[FDT_RANGES_SIZE], *rangesptr;
154	pcell_t addr_cells, size_cells, par_addr_cells;
155	u_long par_bus_addr, pbase, psize;
156	int err, len;
157
158	if ((fdt_addrsize_cells(node, &addr_cells, &size_cells)) != 0)
159		return (ENXIO);
160	/*
161	 * Process 'ranges' property.
162	 */
163	par_addr_cells = fdt_parent_addr_cells(node);
164	if (par_addr_cells > 2)
165		return (ERANGE);
166
167	len = OF_getproplen(node, "ranges");
168	if (len > sizeof(ranges))
169		return (ENOMEM);
170	if (len == 0) {
171		*base = 0;
172		*size = ULONG_MAX;
173		return (0);
174	}
175
176	if (!(range_id < len))
177		return (ERANGE);
178
179	if (OF_getprop(node, "ranges", ranges, sizeof(ranges)) <= 0)
180		return (EINVAL);
181
182	if (par_addr_cells > 2 || addr_cells > 2 || size_cells > 2)
183		return (ERANGE);
184
185	*base = 0;
186	*size = 0;
187	rangesptr = &ranges[range_id];
188
189	*base = fdt_data_get((void *)rangesptr, addr_cells);
190	rangesptr += addr_cells;
191
192	par_bus_addr = fdt_data_get((void *)rangesptr, par_addr_cells);
193	rangesptr += par_addr_cells;
194
195	err = fdt_get_range_by_busaddr(OF_parent(node), par_bus_addr,
196	   &pbase, &psize);
197	if (err == 0)
198		*base += pbase;
199	else
200		*base += par_bus_addr;
201
202	*size = fdt_data_get((void *)rangesptr, size_cells);
203	return (0);
204}
205
206int
207fdt_immr_addr(vm_offset_t immr_va)
208{
209	phandle_t node;
210	u_long base, size;
211	int r;
212
213	/*
214	 * Try to access the SOC node directly i.e. through /aliases/.
215	 */
216	if ((node = OF_finddevice("soc")) != -1)
217		if (ofw_bus_node_is_compatible(node, "simple-bus"))
218			goto moveon;
219	/*
220	 * Find the node the long way.
221	 */
222	if ((node = OF_finddevice("/")) == -1)
223		return (ENXIO);
224
225	if ((node = fdt_find_compatible(node, "simple-bus", 0)) == 0)
226		return (ENXIO);
227
228moveon:
229	if ((r = fdt_get_range(node, 0, &base, &size)) == 0) {
230		fdt_immr_pa = base;
231		fdt_immr_va = immr_va;
232		fdt_immr_size = size;
233	}
234
235	return (r);
236}
237
238int
239fdt_is_compatible_strict(phandle_t node, const char *compatible)
240{
241	char compat[FDT_COMPAT_LEN];
242
243	if (OF_getproplen(node, "compatible") <= 0)
244		return (0);
245
246	if (OF_getprop(node, "compatible", compat, FDT_COMPAT_LEN) < 0)
247		return (0);
248
249	if (strncasecmp(compat, compatible, FDT_COMPAT_LEN) == 0)
250		/* This fits. */
251		return (1);
252
253	return (0);
254}
255
256phandle_t
257fdt_find_compatible(phandle_t start, const char *compat, int strict)
258{
259	phandle_t child;
260
261	/*
262	 * Traverse all children of 'start' node, and find first with
263	 * matching 'compatible' property.
264	 */
265	for (child = OF_child(start); child != 0; child = OF_peer(child))
266		if (ofw_bus_node_is_compatible(child, compat)) {
267			if (strict)
268				if (!fdt_is_compatible_strict(child, compat))
269					continue;
270			return (child);
271		}
272	return (0);
273}
274
275phandle_t
276fdt_depth_search_compatible(phandle_t start, const char *compat, int strict)
277{
278	phandle_t child, node;
279
280	/*
281	 * Depth-search all descendants of 'start' node, and find first with
282	 * matching 'compatible' property.
283	 */
284	for (node = OF_child(start); node != 0; node = OF_peer(node)) {
285		if (ofw_bus_node_is_compatible(node, compat) &&
286		    (strict == 0 || fdt_is_compatible_strict(node, compat))) {
287			return (node);
288		}
289		child = fdt_depth_search_compatible(node, compat, strict);
290		if (child != 0)
291			return (child);
292	}
293	return (0);
294}
295
296int
297fdt_parent_addr_cells(phandle_t node)
298{
299	pcell_t addr_cells;
300
301	/* Find out #address-cells of the superior bus. */
302	if (OF_searchprop(OF_parent(node), "#address-cells", &addr_cells,
303	    sizeof(addr_cells)) <= 0)
304		return (2);
305
306	return ((int)fdt32_to_cpu(addr_cells));
307}
308
309u_long
310fdt_data_get(void *data, int cells)
311{
312
313	if (cells == 1)
314		return (fdt32_to_cpu(*((uint32_t *)data)));
315
316	return (fdt64_to_cpu(*((uint64_t *)data)));
317}
318
319int
320fdt_addrsize_cells(phandle_t node, int *addr_cells, int *size_cells)
321{
322	pcell_t cell;
323	int cell_size;
324
325	/*
326	 * Retrieve #{address,size}-cells.
327	 */
328	cell_size = sizeof(cell);
329	if (OF_getencprop(node, "#address-cells", &cell, cell_size) < cell_size)
330		cell = 2;
331	*addr_cells = (int)cell;
332
333	if (OF_getencprop(node, "#size-cells", &cell, cell_size) < cell_size)
334		cell = 1;
335	*size_cells = (int)cell;
336
337	if (*addr_cells > 3 || *size_cells > 2)
338		return (ERANGE);
339	return (0);
340}
341
342int
343fdt_data_to_res(pcell_t *data, int addr_cells, int size_cells, u_long *start,
344    u_long *count)
345{
346
347	/* Address portion. */
348	if (addr_cells > 2)
349		return (ERANGE);
350
351	*start = fdt_data_get((void *)data, addr_cells);
352	data += addr_cells;
353
354	/* Size portion. */
355	if (size_cells > 2)
356		return (ERANGE);
357
358	*count = fdt_data_get((void *)data, size_cells);
359	return (0);
360}
361
362int
363fdt_regsize(phandle_t node, u_long *base, u_long *size)
364{
365	pcell_t reg[4];
366	int addr_cells, len, size_cells;
367
368	if (fdt_addrsize_cells(OF_parent(node), &addr_cells, &size_cells))
369		return (ENXIO);
370
371	if ((sizeof(pcell_t) * (addr_cells + size_cells)) > sizeof(reg))
372		return (ENOMEM);
373
374	len = OF_getprop(node, "reg", &reg, sizeof(reg));
375	if (len <= 0)
376		return (EINVAL);
377
378	*base = fdt_data_get(&reg[0], addr_cells);
379	*size = fdt_data_get(&reg[addr_cells], size_cells);
380	return (0);
381}
382
383int
384fdt_get_phyaddr(phandle_t node, device_t dev, int *phy_addr, void **phy_sc)
385{
386	phandle_t phy_node;
387	pcell_t phy_handle, phy_reg;
388	uint32_t i;
389	device_t parent, child;
390
391	if (OF_getencprop(node, "phy-handle", (void *)&phy_handle,
392	    sizeof(phy_handle)) <= 0)
393		return (ENXIO);
394
395	phy_node = OF_node_from_xref(phy_handle);
396
397	if (OF_getencprop(phy_node, "reg", (void *)&phy_reg,
398	    sizeof(phy_reg)) <= 0)
399		return (ENXIO);
400
401	*phy_addr = phy_reg;
402
403	if (phy_sc == NULL)
404		return (0);
405
406	/*
407	 * Search for softc used to communicate with phy.
408	 */
409
410	/*
411	 * Step 1: Search for ancestor of the phy-node with a "phy-handle"
412	 * property set.
413	 */
414	phy_node = OF_parent(phy_node);
415	while (phy_node != 0) {
416		if (OF_getprop(phy_node, "phy-handle", (void *)&phy_handle,
417		    sizeof(phy_handle)) > 0)
418			break;
419		phy_node = OF_parent(phy_node);
420	}
421	if (phy_node == 0)
422		return (ENXIO);
423
424	/*
425	 * Step 2: For each device with the same parent and name as ours
426	 * compare its node with the one found in step 1, ancestor of phy
427	 * node (stored in phy_node).
428	 */
429	parent = device_get_parent(dev);
430	i = 0;
431	child = device_find_child(parent, device_get_name(dev), i);
432	while (child != NULL) {
433		if (ofw_bus_get_node(child) == phy_node)
434			break;
435		i++;
436		child = device_find_child(parent, device_get_name(dev), i);
437	}
438	if (child == NULL)
439		return (ENXIO);
440
441	/*
442	 * Use softc of the device found.
443	 */
444	*phy_sc = (void *)device_get_softc(child);
445
446	return (0);
447}
448
449int
450fdt_get_reserved_regions(struct mem_region *mr, int *mrcnt)
451{
452	pcell_t reserve[FDT_REG_CELLS * FDT_MEM_REGIONS];
453	pcell_t *reservep;
454	phandle_t memory, root;
455	int addr_cells, size_cells;
456	int i, res_len, rv, tuple_size, tuples;
457
458	root = OF_finddevice("/");
459	memory = OF_finddevice("/memory");
460	if (memory == -1) {
461		rv = ENXIO;
462		goto out;
463	}
464
465	if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
466	    &size_cells)) != 0)
467		goto out;
468
469	if (addr_cells > 2) {
470		rv = ERANGE;
471		goto out;
472	}
473
474	tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
475
476	res_len = OF_getproplen(root, "memreserve");
477	if (res_len <= 0 || res_len > sizeof(reserve)) {
478		rv = ERANGE;
479		goto out;
480	}
481
482	if (OF_getprop(root, "memreserve", reserve, res_len) <= 0) {
483		rv = ENXIO;
484		goto out;
485	}
486
487	tuples = res_len / tuple_size;
488	reservep = (pcell_t *)&reserve;
489	for (i = 0; i < tuples; i++) {
490
491		rv = fdt_data_to_res(reservep, addr_cells, size_cells,
492			(u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
493
494		if (rv != 0)
495			goto out;
496
497		reservep += addr_cells + size_cells;
498	}
499
500	*mrcnt = i;
501	rv = 0;
502out:
503	return (rv);
504}
505
506int
507fdt_get_reserved_mem(struct mem_region *reserved, int *mreserved)
508{
509	pcell_t reg[FDT_REG_CELLS];
510	phandle_t child, root;
511	int addr_cells, size_cells;
512	int i, rv;
513
514	root = OF_finddevice("/reserved-memory");
515	if (root == -1) {
516		return (ENXIO);
517	}
518
519	if ((rv = fdt_addrsize_cells(root, &addr_cells, &size_cells)) != 0)
520		return (rv);
521
522	if (addr_cells + size_cells > FDT_REG_CELLS)
523		panic("Too many address and size cells %d %d", addr_cells,
524		    size_cells);
525
526	i = 0;
527	for (child = OF_child(root); child != 0; child = OF_peer(child)) {
528		if (!OF_hasprop(child, "no-map"))
529			continue;
530
531		rv = OF_getprop(child, "reg", reg, sizeof(reg));
532		if (rv <= 0)
533			/* XXX: Does a no-map of a dynamic range make sense? */
534			continue;
535
536		fdt_data_to_res(reg, addr_cells, size_cells,
537		    (u_long *)&reserved[i].mr_start,
538		    (u_long *)&reserved[i].mr_size);
539		i++;
540	}
541
542	*mreserved = i;
543
544	return (0);
545}
546
547int
548fdt_get_mem_regions(struct mem_region *mr, int *mrcnt, uint64_t *memsize)
549{
550	pcell_t reg[FDT_REG_CELLS * FDT_MEM_REGIONS];
551	pcell_t *regp;
552	phandle_t memory;
553	uint64_t memory_size;
554	int addr_cells, size_cells;
555	int i, reg_len, rv, tuple_size, tuples;
556
557	memory = OF_finddevice("/memory");
558	if (memory == -1) {
559		rv = ENXIO;
560		goto out;
561	}
562
563	if ((rv = fdt_addrsize_cells(OF_parent(memory), &addr_cells,
564	    &size_cells)) != 0)
565		goto out;
566
567	if (addr_cells > 2) {
568		rv = ERANGE;
569		goto out;
570	}
571
572	tuple_size = sizeof(pcell_t) * (addr_cells + size_cells);
573	reg_len = OF_getproplen(memory, "reg");
574	if (reg_len <= 0 || reg_len > sizeof(reg)) {
575		rv = ERANGE;
576		goto out;
577	}
578
579	if (OF_getprop(memory, "reg", reg, reg_len) <= 0) {
580		rv = ENXIO;
581		goto out;
582	}
583
584	memory_size = 0;
585	tuples = reg_len / tuple_size;
586	regp = (pcell_t *)&reg;
587	for (i = 0; i < tuples; i++) {
588
589		rv = fdt_data_to_res(regp, addr_cells, size_cells,
590			(u_long *)&mr[i].mr_start, (u_long *)&mr[i].mr_size);
591
592		if (rv != 0)
593			goto out;
594
595		regp += addr_cells + size_cells;
596		memory_size += mr[i].mr_size;
597	}
598
599	if (memory_size == 0) {
600		rv = ERANGE;
601		goto out;
602	}
603
604	*mrcnt = i;
605	if (memsize != NULL)
606		*memsize = memory_size;
607	rv = 0;
608out:
609	return (rv);
610}
611
612int
613fdt_get_chosen_bootargs(char *bootargs, size_t max_size)
614{
615	phandle_t chosen;
616
617	chosen = OF_finddevice("/chosen");
618	if (chosen == -1)
619		return (ENXIO);
620	if (OF_getprop(chosen, "bootargs", bootargs, max_size) == -1)
621		return (ENXIO);
622	return (0);
623}
624