2 * Copyright (c) 2001 - 2003 by Thomas Moestl <tmm@FreeBSD.org>.
3 * Copyright (c) 2005 Marius Strobl <marius@FreeBSD.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions, and the following disclaimer,
11 * without modification, immediately at the beginning of the file.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
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 FOR
21 * 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 "opt_platform.h"
34 #include <sys/param.h>
35 #include <sys/systm.h>
37 #include <sys/errno.h>
38 #include <sys/libkern.h>
40 #include <machine/resource.h>
42 #include <dev/ofw/ofw_bus.h>
43 #include <dev/ofw/ofw_bus_subr.h>
44 #include <dev/ofw/openfirm.h>
46 #include "ofw_bus_if.h"
49 ofw_bus_gen_setup_devinfo(struct ofw_bus_devinfo *obd, phandle_t node)
54 /* The 'name' property is considered mandatory. */
55 if ((OF_getprop_alloc(node, "name", 1, (void **)&obd->obd_name)) == -1)
57 OF_getprop_alloc(node, "compatible", 1, (void **)&obd->obd_compat);
58 OF_getprop_alloc(node, "device_type", 1, (void **)&obd->obd_type);
59 OF_getprop_alloc(node, "model", 1, (void **)&obd->obd_model);
60 OF_getprop_alloc(node, "status", 1, (void **)&obd->obd_status);
66 ofw_bus_gen_destroy_devinfo(struct ofw_bus_devinfo *obd)
71 if (obd->obd_compat != NULL)
72 free(obd->obd_compat, M_OFWPROP);
73 if (obd->obd_model != NULL)
74 free(obd->obd_model, M_OFWPROP);
75 if (obd->obd_name != NULL)
76 free(obd->obd_name, M_OFWPROP);
77 if (obd->obd_type != NULL)
78 free(obd->obd_type, M_OFWPROP);
79 if (obd->obd_status != NULL)
80 free(obd->obd_status, M_OFWPROP);
84 ofw_bus_gen_child_pnpinfo_str(device_t cbdev, device_t child, char *buf,
88 if (ofw_bus_get_name(child) != NULL) {
89 strlcat(buf, "name=", buflen);
90 strlcat(buf, ofw_bus_get_name(child), buflen);
93 if (ofw_bus_get_compat(child) != NULL) {
94 strlcat(buf, " compat=", buflen);
95 strlcat(buf, ofw_bus_get_compat(child), buflen);
101 ofw_bus_gen_get_compat(device_t bus, device_t dev)
103 const struct ofw_bus_devinfo *obd;
105 obd = OFW_BUS_GET_DEVINFO(bus, dev);
108 return (obd->obd_compat);
112 ofw_bus_gen_get_model(device_t bus, device_t dev)
114 const struct ofw_bus_devinfo *obd;
116 obd = OFW_BUS_GET_DEVINFO(bus, dev);
119 return (obd->obd_model);
123 ofw_bus_gen_get_name(device_t bus, device_t dev)
125 const struct ofw_bus_devinfo *obd;
127 obd = OFW_BUS_GET_DEVINFO(bus, dev);
130 return (obd->obd_name);
134 ofw_bus_gen_get_node(device_t bus, device_t dev)
136 const struct ofw_bus_devinfo *obd;
138 obd = OFW_BUS_GET_DEVINFO(bus, dev);
141 return (obd->obd_node);
145 ofw_bus_gen_get_type(device_t bus, device_t dev)
147 const struct ofw_bus_devinfo *obd;
149 obd = OFW_BUS_GET_DEVINFO(bus, dev);
152 return (obd->obd_type);
156 ofw_bus_get_status(device_t dev)
158 const struct ofw_bus_devinfo *obd;
160 obd = OFW_BUS_GET_DEVINFO(device_get_parent(dev), dev);
164 return (obd->obd_status);
168 ofw_bus_status_okay(device_t dev)
172 status = ofw_bus_get_status(dev);
173 if (status == NULL || strcmp(status, "okay") == 0 ||
174 strcmp(status, "ok") == 0)
181 ofw_bus_node_is_compatible(const char *compat, int len, const char *onecompat)
185 onelen = strlen(onecompat);
189 if (strlen(compat) == onelen &&
190 strncasecmp(compat, onecompat, onelen) == 0) {
196 /* Slide to the next sub-string. */
197 l = strlen(compat) + 1;
206 ofw_bus_is_compatible(device_t dev, const char *onecompat)
212 if ((compat = ofw_bus_get_compat(dev)) == NULL)
215 if ((node = ofw_bus_get_node(dev)) == -1)
218 /* Get total 'compatible' prop len */
219 if ((len = OF_getproplen(node, "compatible")) <= 0)
222 return (ofw_bus_node_is_compatible(compat, len, onecompat));
226 ofw_bus_is_compatible_strict(device_t dev, const char *compatible)
231 if ((compat = ofw_bus_get_compat(dev)) == NULL)
234 len = strlen(compatible);
235 if (strlen(compat) == len &&
236 strncasecmp(compat, compatible, len) == 0)
242 const struct ofw_compat_data *
243 ofw_bus_search_compatible(device_t dev, const struct ofw_compat_data *compat)
249 for (; compat->ocd_str != NULL; ++compat) {
250 if (ofw_bus_is_compatible(dev, compat->ocd_str))
258 ofw_bus_has_prop(device_t dev, const char *propname)
262 if ((node = ofw_bus_get_node(dev)) == -1)
265 return (OF_hasprop(node, propname));
269 ofw_bus_setup_iinfo(phandle_t node, struct ofw_bus_iinfo *ii, int intrsz)
274 if (OF_getencprop(node, "#address-cells", &addrc, sizeof(addrc)) == -1)
276 ii->opi_addrc = addrc * sizeof(pcell_t);
278 ii->opi_imapsz = OF_getencprop_alloc(node, "interrupt-map", 1,
279 (void **)&ii->opi_imap);
280 if (ii->opi_imapsz > 0) {
281 msksz = OF_getencprop_alloc(node, "interrupt-map-mask", 1,
282 (void **)&ii->opi_imapmsk);
284 * Failure to get the mask is ignored; a full mask is used
285 * then. We barf on bad mask sizes, however.
287 if (msksz != -1 && msksz != ii->opi_addrc + intrsz)
288 panic("ofw_bus_setup_iinfo: bad interrupt-map-mask "
294 ofw_bus_lookup_imap(phandle_t node, struct ofw_bus_iinfo *ii, void *reg,
295 int regsz, void *pintr, int pintrsz, void *mintr, int mintrsz,
298 uint8_t maskbuf[regsz + pintrsz];
301 if (ii->opi_imapsz <= 0)
303 KASSERT(regsz >= ii->opi_addrc,
304 ("ofw_bus_lookup_imap: register size too small: %d < %d",
305 regsz, ii->opi_addrc));
307 rv = OF_getencprop(node, "reg", reg, regsz);
309 panic("ofw_bus_lookup_imap: cannot get reg property");
311 return (ofw_bus_search_intrmap(pintr, pintrsz, reg, ii->opi_addrc,
312 ii->opi_imap, ii->opi_imapsz, ii->opi_imapmsk, maskbuf, mintr,
317 * Map an interrupt using the firmware reg, interrupt-map and
318 * interrupt-map-mask properties.
319 * The interrupt property to be mapped must be of size intrsz, and pointed to
320 * by intr. The regs property of the node for which the mapping is done must
321 * be passed as regs. This property is an array of register specifications;
322 * the size of the address part of such a specification must be passed as
323 * physsz. Only the first element of the property is used.
324 * imap and imapsz hold the interrupt mask and it's size.
325 * imapmsk is a pointer to the interrupt-map-mask property, which must have
326 * a size of physsz + intrsz; it may be NULL, in which case a full mask is
328 * maskbuf must point to a buffer of length physsz + intrsz.
329 * The interrupt is returned in result, which must point to a buffer of length
330 * rintrsz (which gives the expected size of the mapped interrupt).
331 * Returns number of cells in the interrupt if a mapping was found, 0 otherwise.
334 ofw_bus_search_intrmap(void *intr, int intrsz, void *regs, int physsz,
335 void *imap, int imapsz, void *imapmsk, void *maskbuf, void *result,
336 int rintrsz, phandle_t *iparent)
339 uint8_t *ref = maskbuf;
340 uint8_t *uiintr = intr;
341 uint8_t *uiregs = regs;
342 uint8_t *uiimapmsk = imapmsk;
348 if (imapmsk != NULL) {
349 for (i = 0; i < physsz; i++)
350 ref[i] = uiregs[i] & uiimapmsk[i];
351 for (i = 0; i < intrsz; i++)
352 ref[physsz + i] = uiintr[i] & uiimapmsk[physsz + i];
354 bcopy(regs, ref, physsz);
355 bcopy(intr, ref + physsz, intrsz);
361 bcopy(mptr + physsz + intrsz, &parent, sizeof(parent));
362 if (OF_searchencprop(OF_node_from_xref(parent),
363 "#interrupt-cells", &pintrsz, sizeof(pintrsz)) == -1)
364 pintrsz = 1; /* default */
365 pintrsz *= sizeof(pcell_t);
367 /* Compute the map stride size. */
368 tsz = physsz + intrsz + sizeof(phandle_t) + pintrsz;
369 KASSERT(i >= tsz, ("ofw_bus_search_intrmap: truncated map"));
371 if (bcmp(ref, mptr, physsz + intrsz) == 0) {
372 bcopy(mptr + physsz + intrsz + sizeof(parent),
373 result, MIN(rintrsz, pintrsz));
377 return (pintrsz/sizeof(pcell_t));
386 ofw_bus_reg_to_rl(device_t dev, phandle_t node, pcell_t acells, pcell_t scells,
387 struct resource_list *rl)
390 ssize_t i, j, rid, nreg, ret;
395 * This may be just redundant when having ofw_bus_devinfo
396 * but makes this routine independent of it.
398 ret = OF_getencprop_alloc(node, "name", sizeof(*name), (void **)&name);
402 ret = OF_getencprop_alloc(node, "reg", sizeof(*reg), (void **)®);
403 nreg = (ret == -1) ? 0 : ret;
405 if (nreg % (acells + scells) != 0) {
407 device_printf(dev, "Malformed reg property on <%s>\n",
408 (name == NULL) ? "unknown" : name);
412 for (i = 0, rid = 0; i < nreg; i += acells + scells, rid++) {
414 for (j = 0; j < acells; j++) {
418 for (j = 0; j < scells; j++) {
420 size |= reg[i + acells + j];
422 /* Skip the dummy reg property of glue devices like ssm(4). */
424 resource_list_add(rl, SYS_RES_MEMORY, rid,
425 phys, phys + size - 1, size);
427 free(name, M_OFWPROP);
428 free(reg, M_OFWPROP);
434 ofw_bus_intr_to_rl(device_t dev, phandle_t node,
435 struct resource_list *rl, int *rlen)
438 uint32_t icells, *intr;
439 int err, i, irqnum, nintr, rid;
442 nintr = OF_getencprop_alloc(node, "interrupts", sizeof(*intr),
445 if (OF_searchencprop(node, "interrupt-parent", &iparent,
446 sizeof(iparent)) == -1) {
447 for (iparent = node; iparent != 0;
448 iparent = OF_parent(node)) {
449 if (OF_hasprop(iparent, "interrupt-controller"))
453 device_printf(dev, "No interrupt-parent found, "
454 "assuming direct parent\n");
455 iparent = OF_parent(node);
457 iparent = OF_xref_from_node(iparent);
459 if (OF_searchencprop(OF_node_from_xref(iparent),
460 "#interrupt-cells", &icells, sizeof(icells)) == -1) {
461 device_printf(dev, "Missing #interrupt-cells "
462 "property, assuming <1>\n");
465 if (icells < 1 || icells > nintr) {
466 device_printf(dev, "Invalid #interrupt-cells property "
467 "value <%d>, assuming <1>\n", icells);
472 nintr = OF_getencprop_alloc(node, "interrupts-extended",
473 sizeof(*intr), (void **)&intr);
480 for (i = 0; i < nintr; i += icells) {
483 if (OF_searchencprop(OF_node_from_xref(iparent),
484 "#interrupt-cells", &icells, sizeof(icells)) == -1) {
485 device_printf(dev, "Missing #interrupt-cells "
490 if (icells < 1 || (i + icells) > nintr) {
491 device_printf(dev, "Invalid #interrupt-cells "
492 "property value <%d>\n", icells);
497 irqnum = ofw_bus_map_intr(dev, iparent, icells, &intr[i]);
498 resource_list_add(rl, SYS_RES_IRQ, rid++, irqnum, irqnum, 1);
502 free(intr, M_OFWPROP);
507 ofw_bus_find_child(phandle_t start, const char *child_name)
513 for (child = OF_child(start); child != 0; child = OF_peer(child)) {
514 ret = OF_getencprop_alloc(child, "name", sizeof(*name), (void **)&name);
517 if (strcmp(name, child_name) == 0) {
518 free(name, M_OFWPROP);
522 free(name, M_OFWPROP);
529 ofw_bus_find_compatible(phandle_t node, const char *onecompat)
531 phandle_t child, ret;
536 * Traverse all children of 'start' node, and find first with
537 * matching 'compatible' property.
539 for (child = OF_child(node); child != 0; child = OF_peer(child)) {
540 len = OF_getprop_alloc(child, "compatible", 1, &compat);
542 ret = ofw_bus_node_is_compatible(compat, len,
544 free(compat, M_OFWPROP);
549 ret = ofw_bus_find_compatible(child, onecompat);
557 * @brief Return child of bus whose phandle is node
559 * A direct child of @p will be returned if it its phandle in the
560 * OFW tree is @p node. Otherwise, NULL is returned.
562 * @param bus The bus to examine
563 * @param node The phandle_t to look for.
566 ofw_bus_find_child_device_by_phandle(device_t bus, phandle_t node)
568 device_t *children, retval, child;
572 * Nothing can match the flag value for no node.
578 * Search the children for a match. We microoptimize
579 * a bit by not using ofw_bus_get since we already know
580 * the parent. We do not recurse.
582 if (device_get_children(bus, &children, &nkid) != 0)
585 for (i = 0; i < nkid; i++) {
587 if (OFW_BUS_GET_NODE(bus, child) == node) {
592 free(children, M_TEMP);