xref: /freebsd/sys/dev/ofw/ofw_bus_subr.c (revision 24f4202df8ba19c09c248f190a6c1a94a26a74d4)
1bba6f0a9SMarius Strobl /*-
294b4a038SNathan Whitehorn  * Copyright (c) 2001 - 2003 by Thomas Moestl <tmm@FreeBSD.org>.
3bba6f0a9SMarius Strobl  * Copyright (c) 2005 Marius Strobl <marius@FreeBSD.org>
4bba6f0a9SMarius Strobl  * All rights reserved.
5bba6f0a9SMarius Strobl  *
6bba6f0a9SMarius Strobl  * Redistribution and use in source and binary forms, with or without
7bba6f0a9SMarius Strobl  * modification, are permitted provided that the following conditions
8bba6f0a9SMarius Strobl  * are met:
9bba6f0a9SMarius Strobl  * 1. Redistributions of source code must retain the above copyright
10bba6f0a9SMarius Strobl  *    notice, this list of conditions, and the following disclaimer,
11bba6f0a9SMarius Strobl  *    without modification, immediately at the beginning of the file.
12bba6f0a9SMarius Strobl  * 2. Redistributions in binary form must reproduce the above copyright
13bba6f0a9SMarius Strobl  *    notice, this list of conditions and the following disclaimer in
14bba6f0a9SMarius Strobl  *    the documentation and/or other materials provided with the
15bba6f0a9SMarius Strobl  *    distribution.
16bba6f0a9SMarius Strobl  *
17bba6f0a9SMarius Strobl  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18bba6f0a9SMarius Strobl  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19bba6f0a9SMarius Strobl  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20bba6f0a9SMarius Strobl  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
21bba6f0a9SMarius Strobl  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22bba6f0a9SMarius Strobl  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23bba6f0a9SMarius Strobl  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24bba6f0a9SMarius Strobl  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25bba6f0a9SMarius Strobl  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26bba6f0a9SMarius Strobl  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27bba6f0a9SMarius Strobl  * SUCH DAMAGE.
28bba6f0a9SMarius Strobl  */
29bba6f0a9SMarius Strobl 
30bba6f0a9SMarius Strobl #include <sys/cdefs.h>
31bba6f0a9SMarius Strobl __FBSDID("$FreeBSD$");
32bba6f0a9SMarius Strobl 
338297758aSRafal Jaworowski #include "opt_platform.h"
34bba6f0a9SMarius Strobl #include <sys/param.h>
35bba6f0a9SMarius Strobl #include <sys/systm.h>
36bba6f0a9SMarius Strobl #include <sys/bus.h>
37bba6f0a9SMarius Strobl #include <sys/errno.h>
3894b4a038SNathan Whitehorn #include <sys/libkern.h>
39bba6f0a9SMarius Strobl 
40c47d4cdeSIan Lepore #include <machine/resource.h>
41c47d4cdeSIan Lepore 
4294b4a038SNathan Whitehorn #include <dev/ofw/ofw_bus.h>
43bba6f0a9SMarius Strobl #include <dev/ofw/ofw_bus_subr.h>
44bba6f0a9SMarius Strobl #include <dev/ofw/openfirm.h>
45bba6f0a9SMarius Strobl 
46bba6f0a9SMarius Strobl #include "ofw_bus_if.h"
47bba6f0a9SMarius Strobl 
48*24f4202dSJustin Hibbits #define	OFW_COMPAT_LEN	255
49*24f4202dSJustin Hibbits 
50bba6f0a9SMarius Strobl int
51bba6f0a9SMarius Strobl ofw_bus_gen_setup_devinfo(struct ofw_bus_devinfo *obd, phandle_t node)
52bba6f0a9SMarius Strobl {
53bba6f0a9SMarius Strobl 
54bba6f0a9SMarius Strobl 	if (obd == NULL)
55bba6f0a9SMarius Strobl 		return (ENOMEM);
56bba6f0a9SMarius Strobl 	/* The 'name' property is considered mandatory. */
57bba6f0a9SMarius Strobl 	if ((OF_getprop_alloc(node, "name", 1, (void **)&obd->obd_name)) == -1)
58bba6f0a9SMarius Strobl 		return (EINVAL);
59bba6f0a9SMarius Strobl 	OF_getprop_alloc(node, "compatible", 1, (void **)&obd->obd_compat);
60bba6f0a9SMarius Strobl 	OF_getprop_alloc(node, "device_type", 1, (void **)&obd->obd_type);
61bba6f0a9SMarius Strobl 	OF_getprop_alloc(node, "model", 1, (void **)&obd->obd_model);
62e4be5a16SNathan Whitehorn 	OF_getprop_alloc(node, "status", 1, (void **)&obd->obd_status);
63bba6f0a9SMarius Strobl 	obd->obd_node = node;
64bba6f0a9SMarius Strobl 	return (0);
65bba6f0a9SMarius Strobl }
66bba6f0a9SMarius Strobl 
67bba6f0a9SMarius Strobl void
68bba6f0a9SMarius Strobl ofw_bus_gen_destroy_devinfo(struct ofw_bus_devinfo *obd)
69bba6f0a9SMarius Strobl {
70bba6f0a9SMarius Strobl 
71bba6f0a9SMarius Strobl 	if (obd == NULL)
72bba6f0a9SMarius Strobl 		return;
73bba6f0a9SMarius Strobl 	if (obd->obd_compat != NULL)
74bba6f0a9SMarius Strobl 		free(obd->obd_compat, M_OFWPROP);
75bba6f0a9SMarius Strobl 	if (obd->obd_model != NULL)
76bba6f0a9SMarius Strobl 		free(obd->obd_model, M_OFWPROP);
77bba6f0a9SMarius Strobl 	if (obd->obd_name != NULL)
78bba6f0a9SMarius Strobl 		free(obd->obd_name, M_OFWPROP);
79bba6f0a9SMarius Strobl 	if (obd->obd_type != NULL)
80bba6f0a9SMarius Strobl 		free(obd->obd_type, M_OFWPROP);
81e4be5a16SNathan Whitehorn 	if (obd->obd_status != NULL)
82e4be5a16SNathan Whitehorn 		free(obd->obd_status, M_OFWPROP);
83bba6f0a9SMarius Strobl }
84bba6f0a9SMarius Strobl 
8594b4a038SNathan Whitehorn int
8694b4a038SNathan Whitehorn ofw_bus_gen_child_pnpinfo_str(device_t cbdev, device_t child, char *buf,
8794b4a038SNathan Whitehorn     size_t buflen)
8894b4a038SNathan Whitehorn {
89481d6b54SMarius Strobl 
9094b4a038SNathan Whitehorn 	if (ofw_bus_get_name(child) != NULL) {
9194b4a038SNathan Whitehorn 		strlcat(buf, "name=", buflen);
9294b4a038SNathan Whitehorn 		strlcat(buf, ofw_bus_get_name(child), buflen);
9394b4a038SNathan Whitehorn 	}
9494b4a038SNathan Whitehorn 
9594b4a038SNathan Whitehorn 	if (ofw_bus_get_compat(child) != NULL) {
9694b4a038SNathan Whitehorn 		strlcat(buf, " compat=", buflen);
9794b4a038SNathan Whitehorn 		strlcat(buf, ofw_bus_get_compat(child), buflen);
9894b4a038SNathan Whitehorn 	}
9994b4a038SNathan Whitehorn 	return (0);
10094b4a038SNathan Whitehorn };
101bba6f0a9SMarius Strobl 
102bba6f0a9SMarius Strobl const char *
103bba6f0a9SMarius Strobl ofw_bus_gen_get_compat(device_t bus, device_t dev)
104bba6f0a9SMarius Strobl {
105bba6f0a9SMarius Strobl 	const struct ofw_bus_devinfo *obd;
106bba6f0a9SMarius Strobl 
107bba6f0a9SMarius Strobl 	obd = OFW_BUS_GET_DEVINFO(bus, dev);
108bba6f0a9SMarius Strobl 	if (obd == NULL)
109bba6f0a9SMarius Strobl 		return (NULL);
110bba6f0a9SMarius Strobl 	return (obd->obd_compat);
111bba6f0a9SMarius Strobl }
112bba6f0a9SMarius Strobl 
113bba6f0a9SMarius Strobl const char *
114bba6f0a9SMarius Strobl ofw_bus_gen_get_model(device_t bus, device_t dev)
115bba6f0a9SMarius Strobl {
116bba6f0a9SMarius Strobl 	const struct ofw_bus_devinfo *obd;
117bba6f0a9SMarius Strobl 
118bba6f0a9SMarius Strobl 	obd = OFW_BUS_GET_DEVINFO(bus, dev);
119bba6f0a9SMarius Strobl 	if (obd == NULL)
120bba6f0a9SMarius Strobl 		return (NULL);
121bba6f0a9SMarius Strobl 	return (obd->obd_model);
122bba6f0a9SMarius Strobl }
123bba6f0a9SMarius Strobl 
124bba6f0a9SMarius Strobl const char *
125bba6f0a9SMarius Strobl ofw_bus_gen_get_name(device_t bus, device_t dev)
126bba6f0a9SMarius Strobl {
127bba6f0a9SMarius Strobl 	const struct ofw_bus_devinfo *obd;
128bba6f0a9SMarius Strobl 
129bba6f0a9SMarius Strobl 	obd = OFW_BUS_GET_DEVINFO(bus, dev);
130bba6f0a9SMarius Strobl 	if (obd == NULL)
131bba6f0a9SMarius Strobl 		return (NULL);
132bba6f0a9SMarius Strobl 	return (obd->obd_name);
133bba6f0a9SMarius Strobl }
134bba6f0a9SMarius Strobl 
135bba6f0a9SMarius Strobl phandle_t
136bba6f0a9SMarius Strobl ofw_bus_gen_get_node(device_t bus, device_t dev)
137bba6f0a9SMarius Strobl {
138bba6f0a9SMarius Strobl 	const struct ofw_bus_devinfo *obd;
139bba6f0a9SMarius Strobl 
140bba6f0a9SMarius Strobl 	obd = OFW_BUS_GET_DEVINFO(bus, dev);
141bba6f0a9SMarius Strobl 	if (obd == NULL)
142bba6f0a9SMarius Strobl 		return (0);
143bba6f0a9SMarius Strobl 	return (obd->obd_node);
144bba6f0a9SMarius Strobl }
145bba6f0a9SMarius Strobl 
146bba6f0a9SMarius Strobl const char *
147bba6f0a9SMarius Strobl ofw_bus_gen_get_type(device_t bus, device_t dev)
148bba6f0a9SMarius Strobl {
149bba6f0a9SMarius Strobl 	const struct ofw_bus_devinfo *obd;
150bba6f0a9SMarius Strobl 
151bba6f0a9SMarius Strobl 	obd = OFW_BUS_GET_DEVINFO(bus, dev);
152bba6f0a9SMarius Strobl 	if (obd == NULL)
153bba6f0a9SMarius Strobl 		return (NULL);
154bba6f0a9SMarius Strobl 	return (obd->obd_type);
155bba6f0a9SMarius Strobl }
15694b4a038SNathan Whitehorn 
157e4be5a16SNathan Whitehorn const char *
158e4be5a16SNathan Whitehorn ofw_bus_get_status(device_t dev)
159e4be5a16SNathan Whitehorn {
160e4be5a16SNathan Whitehorn 	const struct ofw_bus_devinfo *obd;
161e4be5a16SNathan Whitehorn 
162e4be5a16SNathan Whitehorn 	obd = OFW_BUS_GET_DEVINFO(device_get_parent(dev), dev);
163e4be5a16SNathan Whitehorn 	if (obd == NULL)
164e4be5a16SNathan Whitehorn 		return (NULL);
165e4be5a16SNathan Whitehorn 
166e4be5a16SNathan Whitehorn 	return (obd->obd_status);
167e4be5a16SNathan Whitehorn }
168e4be5a16SNathan Whitehorn 
169e4be5a16SNathan Whitehorn int
170e4be5a16SNathan Whitehorn ofw_bus_status_okay(device_t dev)
171e4be5a16SNathan Whitehorn {
172e4be5a16SNathan Whitehorn 	const char *status;
173e4be5a16SNathan Whitehorn 
174e4be5a16SNathan Whitehorn 	status = ofw_bus_get_status(dev);
175f3856d8fSAndrew Turner 	if (status == NULL || strcmp(status, "okay") == 0 ||
176f3856d8fSAndrew Turner 	    strcmp(status, "ok") == 0)
177e4be5a16SNathan Whitehorn 		return (1);
178e4be5a16SNathan Whitehorn 
179e4be5a16SNathan Whitehorn 	return (0);
180e4be5a16SNathan Whitehorn }
181e4be5a16SNathan Whitehorn 
18272a638c7SAndrew Turner static int
183*24f4202dSJustin Hibbits ofw_bus_node_is_compatible_int(const char *compat, int len,
184*24f4202dSJustin Hibbits     const char *onecompat)
18572a638c7SAndrew Turner {
18672a638c7SAndrew Turner 	int onelen, l, ret;
18772a638c7SAndrew Turner 
18872a638c7SAndrew Turner 	onelen = strlen(onecompat);
18972a638c7SAndrew Turner 
19072a638c7SAndrew Turner 	ret = 0;
19172a638c7SAndrew Turner 	while (len > 0) {
19272a638c7SAndrew Turner 		if (strlen(compat) == onelen &&
19372a638c7SAndrew Turner 		    strncasecmp(compat, onecompat, onelen) == 0) {
19472a638c7SAndrew Turner 			/* Found it. */
19572a638c7SAndrew Turner 			ret = 1;
19672a638c7SAndrew Turner 			break;
19772a638c7SAndrew Turner 		}
19872a638c7SAndrew Turner 
19972a638c7SAndrew Turner 		/* Slide to the next sub-string. */
20072a638c7SAndrew Turner 		l = strlen(compat) + 1;
20172a638c7SAndrew Turner 		compat += l;
20272a638c7SAndrew Turner 		len -= l;
20372a638c7SAndrew Turner 	}
20472a638c7SAndrew Turner 
20572a638c7SAndrew Turner 	return (ret);
20672a638c7SAndrew Turner }
20772a638c7SAndrew Turner 
2088297758aSRafal Jaworowski int
209*24f4202dSJustin Hibbits ofw_bus_node_is_compatible(phandle_t node, const char *compatstr)
210*24f4202dSJustin Hibbits {
211*24f4202dSJustin Hibbits 	char compat[OFW_COMPAT_LEN];
212*24f4202dSJustin Hibbits 	int len, rv;
213*24f4202dSJustin Hibbits 
214*24f4202dSJustin Hibbits 	if ((len = OF_getproplen(node, "compatible")) <= 0)
215*24f4202dSJustin Hibbits 		return (0);
216*24f4202dSJustin Hibbits 
217*24f4202dSJustin Hibbits 	bzero(compat, OFW_COMPAT_LEN);
218*24f4202dSJustin Hibbits 
219*24f4202dSJustin Hibbits 	if (OF_getprop(node, "compatible", compat, OFW_COMPAT_LEN) < 0)
220*24f4202dSJustin Hibbits 		return (0);
221*24f4202dSJustin Hibbits 
222*24f4202dSJustin Hibbits 	rv = ofw_bus_node_is_compatible_int(compat, len, compatstr);
223*24f4202dSJustin Hibbits 
224*24f4202dSJustin Hibbits 	return (rv);
225*24f4202dSJustin Hibbits }
226*24f4202dSJustin Hibbits 
227*24f4202dSJustin Hibbits int
2288297758aSRafal Jaworowski ofw_bus_is_compatible(device_t dev, const char *onecompat)
2298297758aSRafal Jaworowski {
2308297758aSRafal Jaworowski 	phandle_t node;
2318297758aSRafal Jaworowski 	const char *compat;
23272a638c7SAndrew Turner 	int len;
2338297758aSRafal Jaworowski 
2348297758aSRafal Jaworowski 	if ((compat = ofw_bus_get_compat(dev)) == NULL)
2358297758aSRafal Jaworowski 		return (0);
2368297758aSRafal Jaworowski 
2370d8d9edaSNathan Whitehorn 	if ((node = ofw_bus_get_node(dev)) == -1)
2388297758aSRafal Jaworowski 		return (0);
2398297758aSRafal Jaworowski 
2408297758aSRafal Jaworowski 	/* Get total 'compatible' prop len */
2418297758aSRafal Jaworowski 	if ((len = OF_getproplen(node, "compatible")) <= 0)
2428297758aSRafal Jaworowski 		return (0);
2438297758aSRafal Jaworowski 
244*24f4202dSJustin Hibbits 	return (ofw_bus_node_is_compatible_int(compat, len, onecompat));
2458297758aSRafal Jaworowski }
2468297758aSRafal Jaworowski 
2478297758aSRafal Jaworowski int
2488297758aSRafal Jaworowski ofw_bus_is_compatible_strict(device_t dev, const char *compatible)
2498297758aSRafal Jaworowski {
2508297758aSRafal Jaworowski 	const char *compat;
25126ca4965SHiroki Sato 	size_t len;
2528297758aSRafal Jaworowski 
2538297758aSRafal Jaworowski 	if ((compat = ofw_bus_get_compat(dev)) == NULL)
2548297758aSRafal Jaworowski 		return (0);
2558297758aSRafal Jaworowski 
25626ca4965SHiroki Sato 	len = strlen(compatible);
25726ca4965SHiroki Sato 	if (strlen(compat) == len &&
25826ca4965SHiroki Sato 	    strncasecmp(compat, compatible, len) == 0)
2598297758aSRafal Jaworowski 		return (1);
2608297758aSRafal Jaworowski 
2618297758aSRafal Jaworowski 	return (0);
2628297758aSRafal Jaworowski }
2638297758aSRafal Jaworowski 
264498fa7c1SIan Lepore const struct ofw_compat_data *
265498fa7c1SIan Lepore ofw_bus_search_compatible(device_t dev, const struct ofw_compat_data *compat)
266498fa7c1SIan Lepore {
267498fa7c1SIan Lepore 
268498fa7c1SIan Lepore 	if (compat == NULL)
269498fa7c1SIan Lepore 		return NULL;
270498fa7c1SIan Lepore 
271498fa7c1SIan Lepore 	for (; compat->ocd_str != NULL; ++compat) {
272498fa7c1SIan Lepore 		if (ofw_bus_is_compatible(dev, compat->ocd_str))
273498fa7c1SIan Lepore 			break;
274498fa7c1SIan Lepore 	}
275498fa7c1SIan Lepore 
276498fa7c1SIan Lepore 	return (compat);
277498fa7c1SIan Lepore }
278498fa7c1SIan Lepore 
27926ca4965SHiroki Sato int
28026ca4965SHiroki Sato ofw_bus_has_prop(device_t dev, const char *propname)
28126ca4965SHiroki Sato {
28226ca4965SHiroki Sato 	phandle_t node;
28326ca4965SHiroki Sato 
28426ca4965SHiroki Sato 	if ((node = ofw_bus_get_node(dev)) == -1)
28526ca4965SHiroki Sato 		return (0);
28626ca4965SHiroki Sato 
28726ca4965SHiroki Sato 	return (OF_hasprop(node, propname));
28826ca4965SHiroki Sato }
28926ca4965SHiroki Sato 
29094b4a038SNathan Whitehorn void
29194b4a038SNathan Whitehorn ofw_bus_setup_iinfo(phandle_t node, struct ofw_bus_iinfo *ii, int intrsz)
29294b4a038SNathan Whitehorn {
29394b4a038SNathan Whitehorn 	pcell_t addrc;
29494b4a038SNathan Whitehorn 	int msksz;
29594b4a038SNathan Whitehorn 
296d3a0a0f3SNathan Whitehorn 	if (OF_getencprop(node, "#address-cells", &addrc, sizeof(addrc)) == -1)
29794b4a038SNathan Whitehorn 		addrc = 2;
29894b4a038SNathan Whitehorn 	ii->opi_addrc = addrc * sizeof(pcell_t);
29994b4a038SNathan Whitehorn 
300d3a0a0f3SNathan Whitehorn 	ii->opi_imapsz = OF_getencprop_alloc(node, "interrupt-map", 1,
30194b4a038SNathan Whitehorn 	    (void **)&ii->opi_imap);
30294b4a038SNathan Whitehorn 	if (ii->opi_imapsz > 0) {
303d3a0a0f3SNathan Whitehorn 		msksz = OF_getencprop_alloc(node, "interrupt-map-mask", 1,
30494b4a038SNathan Whitehorn 		    (void **)&ii->opi_imapmsk);
30594b4a038SNathan Whitehorn 		/*
306481d6b54SMarius Strobl 		 * Failure to get the mask is ignored; a full mask is used
307481d6b54SMarius Strobl 		 * then.  We barf on bad mask sizes, however.
30894b4a038SNathan Whitehorn 		 */
309481d6b54SMarius Strobl 		if (msksz != -1 && msksz != ii->opi_addrc + intrsz)
31094b4a038SNathan Whitehorn 			panic("ofw_bus_setup_iinfo: bad interrupt-map-mask "
31194b4a038SNathan Whitehorn 			    "property!");
31294b4a038SNathan Whitehorn 	}
31394b4a038SNathan Whitehorn }
31494b4a038SNathan Whitehorn 
31594b4a038SNathan Whitehorn int
31694b4a038SNathan Whitehorn ofw_bus_lookup_imap(phandle_t node, struct ofw_bus_iinfo *ii, void *reg,
31794b4a038SNathan Whitehorn     int regsz, void *pintr, int pintrsz, void *mintr, int mintrsz,
31895e3bfe8SNathan Whitehorn     phandle_t *iparent)
31994b4a038SNathan Whitehorn {
32095e3bfe8SNathan Whitehorn 	uint8_t maskbuf[regsz + pintrsz];
32194b4a038SNathan Whitehorn 	int rv;
32294b4a038SNathan Whitehorn 
32394b4a038SNathan Whitehorn 	if (ii->opi_imapsz <= 0)
32494b4a038SNathan Whitehorn 		return (0);
32594b4a038SNathan Whitehorn 	KASSERT(regsz >= ii->opi_addrc,
32694b4a038SNathan Whitehorn 	    ("ofw_bus_lookup_imap: register size too small: %d < %d",
32794b4a038SNathan Whitehorn 		regsz, ii->opi_addrc));
3286064b6acSNathan Whitehorn 	if (node != -1) {
329d3a0a0f3SNathan Whitehorn 		rv = OF_getencprop(node, "reg", reg, regsz);
33094b4a038SNathan Whitehorn 		if (rv < regsz)
3316064b6acSNathan Whitehorn 			panic("ofw_bus_lookup_imap: cannot get reg property");
3326064b6acSNathan Whitehorn 	}
33394b4a038SNathan Whitehorn 	return (ofw_bus_search_intrmap(pintr, pintrsz, reg, ii->opi_addrc,
33494b4a038SNathan Whitehorn 	    ii->opi_imap, ii->opi_imapsz, ii->opi_imapmsk, maskbuf, mintr,
335eaef5f0aSNathan Whitehorn 	    mintrsz, iparent));
33694b4a038SNathan Whitehorn }
33794b4a038SNathan Whitehorn 
33894b4a038SNathan Whitehorn /*
33994b4a038SNathan Whitehorn  * Map an interrupt using the firmware reg, interrupt-map and
34094b4a038SNathan Whitehorn  * interrupt-map-mask properties.
34194b4a038SNathan Whitehorn  * The interrupt property to be mapped must be of size intrsz, and pointed to
34294b4a038SNathan Whitehorn  * by intr.  The regs property of the node for which the mapping is done must
34394b4a038SNathan Whitehorn  * be passed as regs. This property is an array of register specifications;
34494b4a038SNathan Whitehorn  * the size of the address part of such a specification must be passed as
34594b4a038SNathan Whitehorn  * physsz.  Only the first element of the property is used.
34694b4a038SNathan Whitehorn  * imap and imapsz hold the interrupt mask and it's size.
34794b4a038SNathan Whitehorn  * imapmsk is a pointer to the interrupt-map-mask property, which must have
34894b4a038SNathan Whitehorn  * a size of physsz + intrsz; it may be NULL, in which case a full mask is
34994b4a038SNathan Whitehorn  * assumed.
35094b4a038SNathan Whitehorn  * maskbuf must point to a buffer of length physsz + intrsz.
35194b4a038SNathan Whitehorn  * The interrupt is returned in result, which must point to a buffer of length
35294b4a038SNathan Whitehorn  * rintrsz (which gives the expected size of the mapped interrupt).
353cb6d9d6cSNathan Whitehorn  * Returns number of cells in the interrupt if a mapping was found, 0 otherwise.
35494b4a038SNathan Whitehorn  */
35594b4a038SNathan Whitehorn int
35694b4a038SNathan Whitehorn ofw_bus_search_intrmap(void *intr, int intrsz, void *regs, int physsz,
35794b4a038SNathan Whitehorn     void *imap, int imapsz, void *imapmsk, void *maskbuf, void *result,
358eaef5f0aSNathan Whitehorn     int rintrsz, phandle_t *iparent)
35994b4a038SNathan Whitehorn {
36094b4a038SNathan Whitehorn 	phandle_t parent;
361481d6b54SMarius Strobl 	uint8_t *ref = maskbuf;
362481d6b54SMarius Strobl 	uint8_t *uiintr = intr;
363481d6b54SMarius Strobl 	uint8_t *uiregs = regs;
364481d6b54SMarius Strobl 	uint8_t *uiimapmsk = imapmsk;
365481d6b54SMarius Strobl 	uint8_t *mptr;
366122493cfSAndrew Turner 	pcell_t paddrsz;
36794b4a038SNathan Whitehorn 	pcell_t pintrsz;
36894b4a038SNathan Whitehorn 	int i, rsz, tsz;
36994b4a038SNathan Whitehorn 
37094b4a038SNathan Whitehorn 	rsz = -1;
37194b4a038SNathan Whitehorn 	if (imapmsk != NULL) {
37294b4a038SNathan Whitehorn 		for (i = 0; i < physsz; i++)
37394b4a038SNathan Whitehorn 			ref[i] = uiregs[i] & uiimapmsk[i];
37494b4a038SNathan Whitehorn 		for (i = 0; i < intrsz; i++)
37594b4a038SNathan Whitehorn 			ref[physsz + i] = uiintr[i] & uiimapmsk[physsz + i];
37694b4a038SNathan Whitehorn 	} else {
37794b4a038SNathan Whitehorn 		bcopy(regs, ref, physsz);
37894b4a038SNathan Whitehorn 		bcopy(intr, ref + physsz, intrsz);
37994b4a038SNathan Whitehorn 	}
38094b4a038SNathan Whitehorn 
38194b4a038SNathan Whitehorn 	mptr = imap;
38294b4a038SNathan Whitehorn 	i = imapsz;
383122493cfSAndrew Turner 	paddrsz = 0;
38494b4a038SNathan Whitehorn 	while (i > 0) {
38594b4a038SNathan Whitehorn 		bcopy(mptr + physsz + intrsz, &parent, sizeof(parent));
3869f4a7eaeSNathan Whitehorn #ifndef OFW_IMAP_NO_IPARENT_ADDR_CELLS
387122493cfSAndrew Turner 		/*
3889f4a7eaeSNathan Whitehorn 		 * Find if we need to read the parent address data.
3899f4a7eaeSNathan Whitehorn 		 * CHRP-derived OF bindings, including ePAPR-compliant FDTs,
3909f4a7eaeSNathan Whitehorn 		 * use this as an optional part of the specifier.
391122493cfSAndrew Turner 		 */
392122493cfSAndrew Turner 		if (OF_getencprop(OF_node_from_xref(parent),
393122493cfSAndrew Turner 		    "#address-cells", &paddrsz, sizeof(paddrsz)) == -1)
394122493cfSAndrew Turner 			paddrsz = 0;	/* default */
395122493cfSAndrew Turner 		paddrsz *= sizeof(pcell_t);
396122493cfSAndrew Turner #endif
397122493cfSAndrew Turner 
398752ba930SIan Lepore 		if (OF_searchencprop(OF_node_from_xref(parent),
399d3a0a0f3SNathan Whitehorn 		    "#interrupt-cells", &pintrsz, sizeof(pintrsz)) == -1)
40094b4a038SNathan Whitehorn 			pintrsz = 1;	/* default */
40194b4a038SNathan Whitehorn 		pintrsz *= sizeof(pcell_t);
402acb97117SNathan Whitehorn 
403481d6b54SMarius Strobl 		/* Compute the map stride size. */
404122493cfSAndrew Turner 		tsz = physsz + intrsz + sizeof(phandle_t) + paddrsz + pintrsz;
405acb97117SNathan Whitehorn 		KASSERT(i >= tsz, ("ofw_bus_search_intrmap: truncated map"));
40694b4a038SNathan Whitehorn 
40794b4a038SNathan Whitehorn 		if (bcmp(ref, mptr, physsz + intrsz) == 0) {
408122493cfSAndrew Turner 			bcopy(mptr + physsz + intrsz + sizeof(parent) + paddrsz,
409cb6d9d6cSNathan Whitehorn 			    result, MIN(rintrsz, pintrsz));
410eaef5f0aSNathan Whitehorn 
411eaef5f0aSNathan Whitehorn 			if (iparent != NULL)
412eaef5f0aSNathan Whitehorn 				*iparent = parent;
413cb6d9d6cSNathan Whitehorn 			return (pintrsz/sizeof(pcell_t));
41494b4a038SNathan Whitehorn 		}
41594b4a038SNathan Whitehorn 		mptr += tsz;
41694b4a038SNathan Whitehorn 		i -= tsz;
41794b4a038SNathan Whitehorn 	}
41894b4a038SNathan Whitehorn 	return (0);
41994b4a038SNathan Whitehorn }
4206064b6acSNathan Whitehorn 
421c47d4cdeSIan Lepore int
4221e43b18cSAndrew Turner ofw_bus_msimap(phandle_t node, uint16_t pci_rid, phandle_t *msi_parent,
4231e43b18cSAndrew Turner     uint32_t *msi_rid)
4241e43b18cSAndrew Turner {
4251e43b18cSAndrew Turner 	pcell_t *map, mask, msi_base, rid_base, rid_length;
4261e43b18cSAndrew Turner 	ssize_t len;
4271e43b18cSAndrew Turner 	uint32_t masked_rid, rid;
4281e43b18cSAndrew Turner 	int err, i;
4291e43b18cSAndrew Turner 
4301e43b18cSAndrew Turner 	/* TODO: This should be OF_searchprop_alloc if we had it */
4311e43b18cSAndrew Turner 	len = OF_getencprop_alloc(node, "msi-map", sizeof(*map), (void **)&map);
4321e43b18cSAndrew Turner 	if (len < 0) {
4331e43b18cSAndrew Turner 		if (msi_parent != NULL) {
4341e43b18cSAndrew Turner 			*msi_parent = 0;
4351e43b18cSAndrew Turner 			OF_getencprop(node, "msi-parent", msi_parent,
4361e43b18cSAndrew Turner 			    sizeof(*msi_parent));
4371e43b18cSAndrew Turner 		}
4381e43b18cSAndrew Turner 		if (msi_rid != NULL)
4391e43b18cSAndrew Turner 			*msi_rid = pci_rid;
4401e43b18cSAndrew Turner 		return (0);
4411e43b18cSAndrew Turner 	}
4421e43b18cSAndrew Turner 
4431e43b18cSAndrew Turner 	err = ENOENT;
4441e43b18cSAndrew Turner 	rid = 0;
4451e43b18cSAndrew Turner 	mask = 0xffffffff;
4461e43b18cSAndrew Turner 	OF_getencprop(node, "msi-map-mask", &mask, sizeof(mask));
4471e43b18cSAndrew Turner 
4481e43b18cSAndrew Turner 	masked_rid = pci_rid & mask;
4491e43b18cSAndrew Turner 	for (i = 0; i < len; i += 4) {
4501e43b18cSAndrew Turner 		rid_base = map[i + 0];
4511e43b18cSAndrew Turner 		rid_length = map[i + 3];
4521e43b18cSAndrew Turner 
4531e43b18cSAndrew Turner 		if (masked_rid < rid_base ||
4541e43b18cSAndrew Turner 		    masked_rid >= (rid_base + rid_length))
4551e43b18cSAndrew Turner 			continue;
4561e43b18cSAndrew Turner 
4571e43b18cSAndrew Turner 		msi_base = map[i + 2];
4581e43b18cSAndrew Turner 
4591e43b18cSAndrew Turner 		if (msi_parent != NULL)
4601e43b18cSAndrew Turner 			*msi_parent = map[i + 1];
4611e43b18cSAndrew Turner 		if (msi_rid != NULL)
4621e43b18cSAndrew Turner 			*msi_rid = masked_rid - rid_base + msi_base;
4631e43b18cSAndrew Turner 		err = 0;
4641e43b18cSAndrew Turner 		break;
4651e43b18cSAndrew Turner 	}
4661e43b18cSAndrew Turner 
4671e43b18cSAndrew Turner 	free(map, M_OFWPROP);
4681e43b18cSAndrew Turner 
4691e43b18cSAndrew Turner 	return (err);
4701e43b18cSAndrew Turner }
4711e43b18cSAndrew Turner 
4721e43b18cSAndrew Turner int
4734b3d9160SZbigniew Bodek ofw_bus_reg_to_rl(device_t dev, phandle_t node, pcell_t acells, pcell_t scells,
4744b3d9160SZbigniew Bodek     struct resource_list *rl)
4754b3d9160SZbigniew Bodek {
4764b3d9160SZbigniew Bodek 	uint64_t phys, size;
4774b3d9160SZbigniew Bodek 	ssize_t i, j, rid, nreg, ret;
4784b3d9160SZbigniew Bodek 	uint32_t *reg;
4794b3d9160SZbigniew Bodek 	char *name;
4804b3d9160SZbigniew Bodek 
4814b3d9160SZbigniew Bodek 	/*
4824b3d9160SZbigniew Bodek 	 * This may be just redundant when having ofw_bus_devinfo
4834b3d9160SZbigniew Bodek 	 * but makes this routine independent of it.
4844b3d9160SZbigniew Bodek 	 */
4857339f782SOleksandr Tymoshenko 	ret = OF_getprop_alloc(node, "name", sizeof(*name), (void **)&name);
4864b3d9160SZbigniew Bodek 	if (ret == -1)
4874b3d9160SZbigniew Bodek 		name = NULL;
4884b3d9160SZbigniew Bodek 
4894b3d9160SZbigniew Bodek 	ret = OF_getencprop_alloc(node, "reg", sizeof(*reg), (void **)&reg);
4904b3d9160SZbigniew Bodek 	nreg = (ret == -1) ? 0 : ret;
4914b3d9160SZbigniew Bodek 
4924b3d9160SZbigniew Bodek 	if (nreg % (acells + scells) != 0) {
4934b3d9160SZbigniew Bodek 		if (bootverbose)
4944b3d9160SZbigniew Bodek 			device_printf(dev, "Malformed reg property on <%s>\n",
4954b3d9160SZbigniew Bodek 			    (name == NULL) ? "unknown" : name);
4964b3d9160SZbigniew Bodek 		nreg = 0;
4974b3d9160SZbigniew Bodek 	}
4984b3d9160SZbigniew Bodek 
4994b3d9160SZbigniew Bodek 	for (i = 0, rid = 0; i < nreg; i += acells + scells, rid++) {
5004b3d9160SZbigniew Bodek 		phys = size = 0;
5014b3d9160SZbigniew Bodek 		for (j = 0; j < acells; j++) {
5024b3d9160SZbigniew Bodek 			phys <<= 32;
5034b3d9160SZbigniew Bodek 			phys |= reg[i + j];
5044b3d9160SZbigniew Bodek 		}
5054b3d9160SZbigniew Bodek 		for (j = 0; j < scells; j++) {
5064b3d9160SZbigniew Bodek 			size <<= 32;
5074b3d9160SZbigniew Bodek 			size |= reg[i + acells + j];
5084b3d9160SZbigniew Bodek 		}
5094b3d9160SZbigniew Bodek 		/* Skip the dummy reg property of glue devices like ssm(4). */
5104b3d9160SZbigniew Bodek 		if (size != 0)
5114b3d9160SZbigniew Bodek 			resource_list_add(rl, SYS_RES_MEMORY, rid,
5124b3d9160SZbigniew Bodek 			    phys, phys + size - 1, size);
5134b3d9160SZbigniew Bodek 	}
5144b3d9160SZbigniew Bodek 	free(name, M_OFWPROP);
5154b3d9160SZbigniew Bodek 	free(reg, M_OFWPROP);
5164b3d9160SZbigniew Bodek 
5174b3d9160SZbigniew Bodek 	return (0);
5184b3d9160SZbigniew Bodek }
5194b3d9160SZbigniew Bodek 
520821a61efSMichal Meloun /*
521821a61efSMichal Meloun  * Get interrupt parent for given node.
522821a61efSMichal Meloun  * Returns 0 if interrupt parent doesn't exist.
523821a61efSMichal Meloun  */
524821a61efSMichal Meloun phandle_t
525821a61efSMichal Meloun ofw_bus_find_iparent(phandle_t node)
526821a61efSMichal Meloun {
527821a61efSMichal Meloun 	phandle_t iparent;
528821a61efSMichal Meloun 
529821a61efSMichal Meloun 	if (OF_searchencprop(node, "interrupt-parent", &iparent,
530821a61efSMichal Meloun 		    sizeof(iparent)) == -1) {
531821a61efSMichal Meloun 		for (iparent = node; iparent != 0;
532821a61efSMichal Meloun 		    iparent = OF_parent(iparent)) {
533821a61efSMichal Meloun 			if (OF_hasprop(iparent, "interrupt-controller"))
534821a61efSMichal Meloun 				break;
535821a61efSMichal Meloun 		}
536821a61efSMichal Meloun 		iparent = OF_xref_from_node(iparent);
537821a61efSMichal Meloun 	}
538821a61efSMichal Meloun 	return (iparent);
539821a61efSMichal Meloun }
540821a61efSMichal Meloun 
5414b3d9160SZbigniew Bodek int
542a8c5ea04SRuslan Bukin ofw_bus_intr_to_rl(device_t dev, phandle_t node,
543a8c5ea04SRuslan Bukin     struct resource_list *rl, int *rlen)
544c47d4cdeSIan Lepore {
545c47d4cdeSIan Lepore 	phandle_t iparent;
546c47d4cdeSIan Lepore 	uint32_t icells, *intr;
547c47d4cdeSIan Lepore 	int err, i, irqnum, nintr, rid;
548c47d4cdeSIan Lepore 	boolean_t extended;
549c47d4cdeSIan Lepore 
550c47d4cdeSIan Lepore 	nintr = OF_getencprop_alloc(node, "interrupts",  sizeof(*intr),
551c47d4cdeSIan Lepore 	    (void **)&intr);
552c47d4cdeSIan Lepore 	if (nintr > 0) {
553821a61efSMichal Meloun 		iparent = ofw_bus_find_iparent(node);
55408b96b9fSNathan Whitehorn 		if (iparent == 0) {
555c47d4cdeSIan Lepore 			device_printf(dev, "No interrupt-parent found, "
556c47d4cdeSIan Lepore 			    "assuming direct parent\n");
557c47d4cdeSIan Lepore 			iparent = OF_parent(node);
55808b96b9fSNathan Whitehorn 			iparent = OF_xref_from_node(iparent);
55908b96b9fSNathan Whitehorn 		}
560c47d4cdeSIan Lepore 		if (OF_searchencprop(OF_node_from_xref(iparent),
561c47d4cdeSIan Lepore 		    "#interrupt-cells", &icells, sizeof(icells)) == -1) {
562c47d4cdeSIan Lepore 			device_printf(dev, "Missing #interrupt-cells "
563c47d4cdeSIan Lepore 			    "property, assuming <1>\n");
564c47d4cdeSIan Lepore 			icells = 1;
565c47d4cdeSIan Lepore 		}
566c47d4cdeSIan Lepore 		if (icells < 1 || icells > nintr) {
567c47d4cdeSIan Lepore 			device_printf(dev, "Invalid #interrupt-cells property "
568c47d4cdeSIan Lepore 			    "value <%d>, assuming <1>\n", icells);
569c47d4cdeSIan Lepore 			icells = 1;
570c47d4cdeSIan Lepore 		}
571c47d4cdeSIan Lepore 		extended = false;
572c47d4cdeSIan Lepore 	} else {
573c47d4cdeSIan Lepore 		nintr = OF_getencprop_alloc(node, "interrupts-extended",
574c47d4cdeSIan Lepore 		    sizeof(*intr), (void **)&intr);
575c47d4cdeSIan Lepore 		if (nintr <= 0)
576c47d4cdeSIan Lepore 			return (0);
577c47d4cdeSIan Lepore 		extended = true;
578c47d4cdeSIan Lepore 	}
579c47d4cdeSIan Lepore 	err = 0;
580c47d4cdeSIan Lepore 	rid = 0;
581c47d4cdeSIan Lepore 	for (i = 0; i < nintr; i += icells) {
582c47d4cdeSIan Lepore 		if (extended) {
583c47d4cdeSIan Lepore 			iparent = intr[i++];
584c47d4cdeSIan Lepore 			if (OF_searchencprop(OF_node_from_xref(iparent),
585c47d4cdeSIan Lepore 			    "#interrupt-cells", &icells, sizeof(icells)) == -1) {
586c47d4cdeSIan Lepore 				device_printf(dev, "Missing #interrupt-cells "
587c47d4cdeSIan Lepore 				    "property\n");
588c47d4cdeSIan Lepore 				err = ENOENT;
589c47d4cdeSIan Lepore 				break;
590c47d4cdeSIan Lepore 			}
591c47d4cdeSIan Lepore 			if (icells < 1 || (i + icells) > nintr) {
592c47d4cdeSIan Lepore 				device_printf(dev, "Invalid #interrupt-cells "
593c47d4cdeSIan Lepore 				    "property value <%d>\n", icells);
594c47d4cdeSIan Lepore 				err = ERANGE;
595c47d4cdeSIan Lepore 				break;
596c47d4cdeSIan Lepore 			}
597c47d4cdeSIan Lepore 		}
598c47d4cdeSIan Lepore 		irqnum = ofw_bus_map_intr(dev, iparent, icells, &intr[i]);
599c47d4cdeSIan Lepore 		resource_list_add(rl, SYS_RES_IRQ, rid++, irqnum, irqnum, 1);
600c47d4cdeSIan Lepore 	}
601a8c5ea04SRuslan Bukin 	if (rlen != NULL)
602a8c5ea04SRuslan Bukin 		*rlen = rid;
603c47d4cdeSIan Lepore 	free(intr, M_OFWPROP);
604c47d4cdeSIan Lepore 	return (err);
605c47d4cdeSIan Lepore }
606ad5244ecSSvatopluk Kraus 
607ad5244ecSSvatopluk Kraus int
608ad5244ecSSvatopluk Kraus ofw_bus_intr_by_rid(device_t dev, phandle_t node, int wanted_rid,
609ad5244ecSSvatopluk Kraus     phandle_t *producer, int *ncells, pcell_t **cells)
610ad5244ecSSvatopluk Kraus {
611ad5244ecSSvatopluk Kraus 	phandle_t iparent;
612ad5244ecSSvatopluk Kraus 	uint32_t icells, *intr;
613ad5244ecSSvatopluk Kraus 	int err, i, nintr, rid;
614ad5244ecSSvatopluk Kraus 	boolean_t extended;
615ad5244ecSSvatopluk Kraus 
616ad5244ecSSvatopluk Kraus 	nintr = OF_getencprop_alloc(node, "interrupts",  sizeof(*intr),
617ad5244ecSSvatopluk Kraus 	    (void **)&intr);
618ad5244ecSSvatopluk Kraus 	if (nintr > 0) {
619ad5244ecSSvatopluk Kraus 		iparent = ofw_bus_find_iparent(node);
620ad5244ecSSvatopluk Kraus 		if (iparent == 0) {
621ad5244ecSSvatopluk Kraus 			device_printf(dev, "No interrupt-parent found, "
622ad5244ecSSvatopluk Kraus 			    "assuming direct parent\n");
623ad5244ecSSvatopluk Kraus 			iparent = OF_parent(node);
624ad5244ecSSvatopluk Kraus 			iparent = OF_xref_from_node(iparent);
625ad5244ecSSvatopluk Kraus 		}
626ad5244ecSSvatopluk Kraus 		if (OF_searchencprop(OF_node_from_xref(iparent),
627ad5244ecSSvatopluk Kraus 		    "#interrupt-cells", &icells, sizeof(icells)) == -1) {
628ad5244ecSSvatopluk Kraus 			device_printf(dev, "Missing #interrupt-cells "
629ad5244ecSSvatopluk Kraus 			    "property, assuming <1>\n");
630ad5244ecSSvatopluk Kraus 			icells = 1;
631ad5244ecSSvatopluk Kraus 		}
632ad5244ecSSvatopluk Kraus 		if (icells < 1 || icells > nintr) {
633ad5244ecSSvatopluk Kraus 			device_printf(dev, "Invalid #interrupt-cells property "
634ad5244ecSSvatopluk Kraus 			    "value <%d>, assuming <1>\n", icells);
635ad5244ecSSvatopluk Kraus 			icells = 1;
636ad5244ecSSvatopluk Kraus 		}
637ad5244ecSSvatopluk Kraus 		extended = false;
638ad5244ecSSvatopluk Kraus 	} else {
639ad5244ecSSvatopluk Kraus 		nintr = OF_getencprop_alloc(node, "interrupts-extended",
640ad5244ecSSvatopluk Kraus 		    sizeof(*intr), (void **)&intr);
641ad5244ecSSvatopluk Kraus 		if (nintr <= 0)
642ad5244ecSSvatopluk Kraus 			return (ESRCH);
643ad5244ecSSvatopluk Kraus 		extended = true;
644ad5244ecSSvatopluk Kraus 	}
645ad5244ecSSvatopluk Kraus 	err = ESRCH;
646ad5244ecSSvatopluk Kraus 	rid = 0;
647ad5244ecSSvatopluk Kraus 	for (i = 0; i < nintr; i += icells, rid++) {
648ad5244ecSSvatopluk Kraus 		if (extended) {
649ad5244ecSSvatopluk Kraus 			iparent = intr[i++];
650ad5244ecSSvatopluk Kraus 			if (OF_searchencprop(OF_node_from_xref(iparent),
651ad5244ecSSvatopluk Kraus 			    "#interrupt-cells", &icells, sizeof(icells)) == -1) {
652ad5244ecSSvatopluk Kraus 				device_printf(dev, "Missing #interrupt-cells "
653ad5244ecSSvatopluk Kraus 				    "property\n");
654ad5244ecSSvatopluk Kraus 				err = ENOENT;
655ad5244ecSSvatopluk Kraus 				break;
656ad5244ecSSvatopluk Kraus 			}
657ad5244ecSSvatopluk Kraus 			if (icells < 1 || (i + icells) > nintr) {
658ad5244ecSSvatopluk Kraus 				device_printf(dev, "Invalid #interrupt-cells "
659ad5244ecSSvatopluk Kraus 				    "property value <%d>\n", icells);
660ad5244ecSSvatopluk Kraus 				err = ERANGE;
661ad5244ecSSvatopluk Kraus 				break;
662ad5244ecSSvatopluk Kraus 			}
663ad5244ecSSvatopluk Kraus 		}
664ad5244ecSSvatopluk Kraus 		if (rid == wanted_rid) {
665ad5244ecSSvatopluk Kraus 			*cells = malloc(icells * sizeof(**cells), M_OFWPROP,
666ad5244ecSSvatopluk Kraus 			    M_WAITOK);
667ad5244ecSSvatopluk Kraus 			*producer = iparent;
668ad5244ecSSvatopluk Kraus 			*ncells= icells;
669ad5244ecSSvatopluk Kraus 			memcpy(*cells, intr + i, icells * sizeof(**cells));
670ad5244ecSSvatopluk Kraus 			err = 0;
671ad5244ecSSvatopluk Kraus 			break;
672ad5244ecSSvatopluk Kraus 		}
673ad5244ecSSvatopluk Kraus 	}
674ad5244ecSSvatopluk Kraus 	free(intr, M_OFWPROP);
675ad5244ecSSvatopluk Kraus 	return (err);
676ad5244ecSSvatopluk Kraus }
67708b96b9fSNathan Whitehorn 
67872a638c7SAndrew Turner phandle_t
67937c1967cSOleksandr Tymoshenko ofw_bus_find_child(phandle_t start, const char *child_name)
68037c1967cSOleksandr Tymoshenko {
68137c1967cSOleksandr Tymoshenko 	char *name;
68237c1967cSOleksandr Tymoshenko 	int ret;
68337c1967cSOleksandr Tymoshenko 	phandle_t child;
68437c1967cSOleksandr Tymoshenko 
68537c1967cSOleksandr Tymoshenko 	for (child = OF_child(start); child != 0; child = OF_peer(child)) {
6867339f782SOleksandr Tymoshenko 		ret = OF_getprop_alloc(child, "name", sizeof(*name), (void **)&name);
68737c1967cSOleksandr Tymoshenko 		if (ret == -1)
68837c1967cSOleksandr Tymoshenko 			continue;
68937c1967cSOleksandr Tymoshenko 		if (strcmp(name, child_name) == 0) {
69037c1967cSOleksandr Tymoshenko 			free(name, M_OFWPROP);
69137c1967cSOleksandr Tymoshenko 			return (child);
69237c1967cSOleksandr Tymoshenko 		}
69337c1967cSOleksandr Tymoshenko 
69437c1967cSOleksandr Tymoshenko 		free(name, M_OFWPROP);
69537c1967cSOleksandr Tymoshenko 	}
69637c1967cSOleksandr Tymoshenko 
69737c1967cSOleksandr Tymoshenko 	return (0);
69837c1967cSOleksandr Tymoshenko }
69937c1967cSOleksandr Tymoshenko 
70037c1967cSOleksandr Tymoshenko phandle_t
70172a638c7SAndrew Turner ofw_bus_find_compatible(phandle_t node, const char *onecompat)
70272a638c7SAndrew Turner {
70372a638c7SAndrew Turner 	phandle_t child, ret;
70472a638c7SAndrew Turner 	void *compat;
70572a638c7SAndrew Turner 	int len;
70672a638c7SAndrew Turner 
70772a638c7SAndrew Turner 	/*
70872a638c7SAndrew Turner 	 * Traverse all children of 'start' node, and find first with
70972a638c7SAndrew Turner 	 * matching 'compatible' property.
71072a638c7SAndrew Turner 	 */
71172a638c7SAndrew Turner 	for (child = OF_child(node); child != 0; child = OF_peer(child)) {
712a5b53ce4SAndrew Turner 		len = OF_getprop_alloc(child, "compatible", 1, &compat);
71372a638c7SAndrew Turner 		if (len >= 0) {
714*24f4202dSJustin Hibbits 			ret = ofw_bus_node_is_compatible_int(compat, len,
71572a638c7SAndrew Turner 			    onecompat);
71672a638c7SAndrew Turner 			free(compat, M_OFWPROP);
71772a638c7SAndrew Turner 			if (ret != 0)
71872a638c7SAndrew Turner 				return (child);
71972a638c7SAndrew Turner 		}
72072a638c7SAndrew Turner 
72172a638c7SAndrew Turner 		ret = ofw_bus_find_compatible(child, onecompat);
72272a638c7SAndrew Turner 		if (ret != 0)
72372a638c7SAndrew Turner 			return (ret);
72472a638c7SAndrew Turner 	}
72572a638c7SAndrew Turner 	return (0);
72672a638c7SAndrew Turner }
727bb39ff4cSWarner Losh 
728bb39ff4cSWarner Losh /**
729bb39ff4cSWarner Losh  * @brief Return child of bus whose phandle is node
730bb39ff4cSWarner Losh  *
731bb39ff4cSWarner Losh  * A direct child of @p will be returned if it its phandle in the
732bb39ff4cSWarner Losh  * OFW tree is @p node. Otherwise, NULL is returned.
733bb39ff4cSWarner Losh  *
734bb39ff4cSWarner Losh  * @param bus		The bus to examine
735bb39ff4cSWarner Losh  * @param node		The phandle_t to look for.
736bb39ff4cSWarner Losh  */
737bb39ff4cSWarner Losh device_t
738bb39ff4cSWarner Losh ofw_bus_find_child_device_by_phandle(device_t bus, phandle_t node)
739bb39ff4cSWarner Losh {
740bb39ff4cSWarner Losh 	device_t *children, retval, child;
741bb39ff4cSWarner Losh 	int nkid, i;
742bb39ff4cSWarner Losh 
743bb39ff4cSWarner Losh 	/*
744bb39ff4cSWarner Losh 	 * Nothing can match the flag value for no node.
745bb39ff4cSWarner Losh 	 */
746bb39ff4cSWarner Losh 	if (node == -1)
747bb39ff4cSWarner Losh 		return (NULL);
748bb39ff4cSWarner Losh 
749bb39ff4cSWarner Losh 	/*
750bb39ff4cSWarner Losh 	 * Search the children for a match. We microoptimize
751bb39ff4cSWarner Losh 	 * a bit by not using ofw_bus_get since we already know
752bb39ff4cSWarner Losh 	 * the parent. We do not recurse.
753bb39ff4cSWarner Losh 	 */
754bb39ff4cSWarner Losh 	if (device_get_children(bus, &children, &nkid) != 0)
755bb39ff4cSWarner Losh 		return (NULL);
756bb39ff4cSWarner Losh 	retval = NULL;
757bb39ff4cSWarner Losh 	for (i = 0; i < nkid; i++) {
758bb39ff4cSWarner Losh 		child = children[i];
759bb39ff4cSWarner Losh 		if (OFW_BUS_GET_NODE(bus, child) == node) {
760bb39ff4cSWarner Losh 			retval = child;
761bb39ff4cSWarner Losh 			break;
762bb39ff4cSWarner Losh 		}
763bb39ff4cSWarner Losh 	}
764bb39ff4cSWarner Losh 	free(children, M_TEMP);
765bb39ff4cSWarner Losh 
766bb39ff4cSWarner Losh 	return (retval);
767bb39ff4cSWarner Losh }
7680b757c47SMichal Meloun 
7690b757c47SMichal Meloun /*
7700b757c47SMichal Meloun  * Parse property that contain list of xrefs and values
7710b757c47SMichal Meloun  * (like standard "clocks" and "resets" properties)
7720b757c47SMichal Meloun  * Input arguments:
7730b757c47SMichal Meloun  *  node - consumers device node
7740b757c47SMichal Meloun  *  list_name  - name of parsed list - "clocks"
7750b757c47SMichal Meloun  *  cells_name - name of size property - "#clock-cells"
77691ef8da0SAdrian Chadd  *  idx - the index of the requested list entry, or, if -1, an indication
77791ef8da0SAdrian Chadd  *        to return the number of entries in the parsed list.
7780b757c47SMichal Meloun  * Output arguments:
7790b757c47SMichal Meloun  *  producer - handle of producer
78091ef8da0SAdrian Chadd  *  ncells   - number of cells in result or the number of items in the list when
78191ef8da0SAdrian Chadd  *             idx == -1.
7820b757c47SMichal Meloun  *  cells    - array of decoded cells
7830b757c47SMichal Meloun  */
78491ef8da0SAdrian Chadd static int
78591ef8da0SAdrian Chadd ofw_bus_parse_xref_list_internal(phandle_t node, const char *list_name,
7860b757c47SMichal Meloun     const char *cells_name, int idx, phandle_t *producer, int *ncells,
7870b757c47SMichal Meloun     pcell_t **cells)
7880b757c47SMichal Meloun {
7890b757c47SMichal Meloun 	phandle_t pnode;
7900b757c47SMichal Meloun 	phandle_t *elems;
7910b757c47SMichal Meloun 	uint32_t  pcells;
7920b757c47SMichal Meloun 	int rv, i, j, nelems, cnt;
7930b757c47SMichal Meloun 
7940b757c47SMichal Meloun 	elems = NULL;
7950b757c47SMichal Meloun 	nelems = OF_getencprop_alloc(node, list_name,  sizeof(*elems),
7960b757c47SMichal Meloun 	    (void **)&elems);
7970b757c47SMichal Meloun 	if (nelems <= 0)
7980b757c47SMichal Meloun 		return (ENOENT);
79991ef8da0SAdrian Chadd 	rv = (idx == -1) ? 0 : ENOENT;
8000b757c47SMichal Meloun 	for (i = 0, cnt = 0; i < nelems; i += pcells, cnt++) {
8010b757c47SMichal Meloun 		pnode = elems[i++];
8020b757c47SMichal Meloun 		if (OF_getencprop(OF_node_from_xref(pnode),
8030b757c47SMichal Meloun 		    cells_name, &pcells, sizeof(pcells)) == -1) {
8040b757c47SMichal Meloun 			printf("Missing %s property\n", cells_name);
8050b757c47SMichal Meloun 			rv = ENOENT;
8060b757c47SMichal Meloun 			break;
8070b757c47SMichal Meloun 		}
8080b757c47SMichal Meloun 
8090b757c47SMichal Meloun 		if ((i + pcells) > nelems) {
8100b757c47SMichal Meloun 			printf("Invalid %s property value <%d>\n", cells_name,
8110b757c47SMichal Meloun 			    pcells);
8120b757c47SMichal Meloun 			rv = ERANGE;
8130b757c47SMichal Meloun 			break;
8140b757c47SMichal Meloun 		}
8150b757c47SMichal Meloun 		if (cnt == idx) {
8160b757c47SMichal Meloun 			*cells= malloc(pcells * sizeof(**cells), M_OFWPROP,
8170b757c47SMichal Meloun 			    M_WAITOK);
8180b757c47SMichal Meloun 			*producer = pnode;
8190b757c47SMichal Meloun 			*ncells = pcells;
8200b757c47SMichal Meloun 			for (j = 0; j < pcells; j++)
8210b757c47SMichal Meloun 				(*cells)[j] = elems[i + j];
8220b757c47SMichal Meloun 			rv = 0;
8230b757c47SMichal Meloun 			break;
8240b757c47SMichal Meloun 		}
8250b757c47SMichal Meloun 	}
8260b757c47SMichal Meloun 	if (elems != NULL)
8270b757c47SMichal Meloun 		free(elems, M_OFWPROP);
82891ef8da0SAdrian Chadd 	if (idx == -1 && rv == 0)
82991ef8da0SAdrian Chadd 		*ncells = cnt;
8300b757c47SMichal Meloun 	return (rv);
8310b757c47SMichal Meloun }
8320b757c47SMichal Meloun 
8330b757c47SMichal Meloun /*
83491ef8da0SAdrian Chadd  * Parse property that contain list of xrefs and values
83591ef8da0SAdrian Chadd  * (like standard "clocks" and "resets" properties)
83691ef8da0SAdrian Chadd  * Input arguments:
83791ef8da0SAdrian Chadd  *  node - consumers device node
83891ef8da0SAdrian Chadd  *  list_name  - name of parsed list - "clocks"
83991ef8da0SAdrian Chadd  *  cells_name - name of size property - "#clock-cells"
84091ef8da0SAdrian Chadd  *  idx - the index of the requested list entry (>= 0)
84191ef8da0SAdrian Chadd  * Output arguments:
84291ef8da0SAdrian Chadd  *  producer - handle of producer
84391ef8da0SAdrian Chadd  *  ncells   - number of cells in result
84491ef8da0SAdrian Chadd  *  cells    - array of decoded cells
84591ef8da0SAdrian Chadd  */
84691ef8da0SAdrian Chadd int
84791ef8da0SAdrian Chadd ofw_bus_parse_xref_list_alloc(phandle_t node, const char *list_name,
84891ef8da0SAdrian Chadd     const char *cells_name, int idx, phandle_t *producer, int *ncells,
84991ef8da0SAdrian Chadd     pcell_t **cells)
85091ef8da0SAdrian Chadd {
85191ef8da0SAdrian Chadd 
85291ef8da0SAdrian Chadd 	KASSERT(idx >= 0,
85391ef8da0SAdrian Chadd 	    ("ofw_bus_parse_xref_list_alloc: negative index supplied"));
85491ef8da0SAdrian Chadd 
85591ef8da0SAdrian Chadd 	return (ofw_bus_parse_xref_list_internal(node, list_name, cells_name,
85691ef8da0SAdrian Chadd 		    idx, producer, ncells, cells));
85791ef8da0SAdrian Chadd }
85891ef8da0SAdrian Chadd 
85991ef8da0SAdrian Chadd /*
86091ef8da0SAdrian Chadd  * Parse property that contain list of xrefs and values
86191ef8da0SAdrian Chadd  * (like standard "clocks" and "resets" properties)
86291ef8da0SAdrian Chadd  * and determine the number of items in the list
86391ef8da0SAdrian Chadd  * Input arguments:
86491ef8da0SAdrian Chadd  *  node - consumers device node
86591ef8da0SAdrian Chadd  *  list_name  - name of parsed list - "clocks"
86691ef8da0SAdrian Chadd  *  cells_name - name of size property - "#clock-cells"
86791ef8da0SAdrian Chadd  * Output arguments:
86891ef8da0SAdrian Chadd  *  count - number of items in list
86991ef8da0SAdrian Chadd  */
87091ef8da0SAdrian Chadd int
87191ef8da0SAdrian Chadd ofw_bus_parse_xref_list_get_length(phandle_t node, const char *list_name,
87291ef8da0SAdrian Chadd     const char *cells_name, int *count)
87391ef8da0SAdrian Chadd {
87491ef8da0SAdrian Chadd 
87591ef8da0SAdrian Chadd 	return (ofw_bus_parse_xref_list_internal(node, list_name, cells_name,
87691ef8da0SAdrian Chadd 		    -1, NULL, count, NULL));
87791ef8da0SAdrian Chadd }
87891ef8da0SAdrian Chadd 
87991ef8da0SAdrian Chadd /*
8800b757c47SMichal Meloun  * Find index of string in string list property (case sensitive).
8810b757c47SMichal Meloun  */
8820b757c47SMichal Meloun int
8830b757c47SMichal Meloun ofw_bus_find_string_index(phandle_t node, const char *list_name,
8840b757c47SMichal Meloun     const char *name, int *idx)
8850b757c47SMichal Meloun {
8860b757c47SMichal Meloun 	char *elems;
8870b757c47SMichal Meloun 	int rv, i, cnt, nelems;
8880b757c47SMichal Meloun 
8890b757c47SMichal Meloun 	elems = NULL;
8900b757c47SMichal Meloun 	nelems = OF_getprop_alloc(node, list_name, 1, (void **)&elems);
8910b757c47SMichal Meloun 	if (nelems <= 0)
8920b757c47SMichal Meloun 		return (ENOENT);
8930b757c47SMichal Meloun 
8940b757c47SMichal Meloun 	rv = ENOENT;
8950b757c47SMichal Meloun 	for (i = 0, cnt = 0; i < nelems; cnt++) {
8960b757c47SMichal Meloun 		if (strcmp(elems + i, name) == 0) {
8970b757c47SMichal Meloun 			*idx = cnt;
8980b757c47SMichal Meloun 			rv = 0;
8990b757c47SMichal Meloun 			break;
9000b757c47SMichal Meloun 		}
9010b757c47SMichal Meloun 		i += strlen(elems + i) + 1;
9020b757c47SMichal Meloun 	}
9030b757c47SMichal Meloun 
9040b757c47SMichal Meloun 	if (elems != NULL)
9050b757c47SMichal Meloun 		free(elems, M_OFWPROP);
9060b757c47SMichal Meloun 	return (rv);
9070b757c47SMichal Meloun }
9080b757c47SMichal Meloun 
9090b757c47SMichal Meloun /*
9100b757c47SMichal Meloun  * Create zero terminated array of strings from string list property.
9110b757c47SMichal Meloun  */
9120b757c47SMichal Meloun int
9130b757c47SMichal Meloun ofw_bus_string_list_to_array(phandle_t node, const char *list_name,
914086a6314SMichal Meloun    const char ***out_array)
9150b757c47SMichal Meloun {
9160b757c47SMichal Meloun 	char *elems, *tptr;
917086a6314SMichal Meloun 	const char **array;
9180b757c47SMichal Meloun 	int i, cnt, nelems, len;
9190b757c47SMichal Meloun 
9200b757c47SMichal Meloun 	elems = NULL;
9210b757c47SMichal Meloun 	nelems = OF_getprop_alloc(node, list_name, 1, (void **)&elems);
9220b757c47SMichal Meloun 	if (nelems <= 0)
9230b757c47SMichal Meloun 		return (nelems);
9240b757c47SMichal Meloun 
9250b757c47SMichal Meloun 	/* Count number of strings. */
9260b757c47SMichal Meloun 	for (i = 0, cnt = 0; i < nelems; cnt++)
9270b757c47SMichal Meloun 		i += strlen(elems + i) + 1;
9280b757c47SMichal Meloun 
9290b757c47SMichal Meloun 	/* Allocate space for arrays and all strings. */
930086a6314SMichal Meloun 	array = malloc((cnt + 1) * sizeof(char *) + nelems, M_OFWPROP,
9310b757c47SMichal Meloun 	    M_WAITOK);
9320b757c47SMichal Meloun 
9330b757c47SMichal Meloun 	/* Get address of first string. */
934086a6314SMichal Meloun 	tptr = (char *)(array + cnt + 1);
9350b757c47SMichal Meloun 
9360b757c47SMichal Meloun 	/* Copy strings. */
9370b757c47SMichal Meloun 	memcpy(tptr, elems, nelems);
9380b757c47SMichal Meloun 	free(elems, M_OFWPROP);
9390b757c47SMichal Meloun 
9400b757c47SMichal Meloun 	/* Fill string pointers. */
9410b757c47SMichal Meloun 	for (i = 0, cnt = 0; i < nelems; cnt++) {
942086a6314SMichal Meloun 		len = strlen(tptr) + 1;
943086a6314SMichal Meloun 		array[cnt] = tptr;
9440b757c47SMichal Meloun 		i += len;
9450b757c47SMichal Meloun 		tptr += len;
9460b757c47SMichal Meloun 	}
947086a6314SMichal Meloun 	array[cnt] = 0;
948086a6314SMichal Meloun 	*out_array = array;
9490b757c47SMichal Meloun 
9500b757c47SMichal Meloun 	return (cnt);
9510b757c47SMichal Meloun }
952