1bba6f0a9SMarius Strobl /*- 2718cf2ccSPedro F. Giffuni * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3718cf2ccSPedro F. Giffuni * 494b4a038SNathan Whitehorn * Copyright (c) 2001 - 2003 by Thomas Moestl <tmm@FreeBSD.org>. 5bba6f0a9SMarius Strobl * Copyright (c) 2005 Marius Strobl <marius@FreeBSD.org> 6bba6f0a9SMarius Strobl * All rights reserved. 7bba6f0a9SMarius Strobl * 8bba6f0a9SMarius Strobl * Redistribution and use in source and binary forms, with or without 9bba6f0a9SMarius Strobl * modification, are permitted provided that the following conditions 10bba6f0a9SMarius Strobl * are met: 11bba6f0a9SMarius Strobl * 1. Redistributions of source code must retain the above copyright 12bba6f0a9SMarius Strobl * notice, this list of conditions, and the following disclaimer, 13bba6f0a9SMarius Strobl * without modification, immediately at the beginning of the file. 14bba6f0a9SMarius Strobl * 2. Redistributions in binary form must reproduce the above copyright 15bba6f0a9SMarius Strobl * notice, this list of conditions and the following disclaimer in 16bba6f0a9SMarius Strobl * the documentation and/or other materials provided with the 17bba6f0a9SMarius Strobl * distribution. 18bba6f0a9SMarius Strobl * 19bba6f0a9SMarius Strobl * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20bba6f0a9SMarius Strobl * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21bba6f0a9SMarius Strobl * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22bba6f0a9SMarius Strobl * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 23bba6f0a9SMarius Strobl * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24bba6f0a9SMarius Strobl * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25bba6f0a9SMarius Strobl * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26bba6f0a9SMarius Strobl * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27bba6f0a9SMarius Strobl * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28bba6f0a9SMarius Strobl * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29bba6f0a9SMarius Strobl * SUCH DAMAGE. 30bba6f0a9SMarius Strobl */ 31bba6f0a9SMarius Strobl 32bba6f0a9SMarius Strobl #include <sys/cdefs.h> 33bba6f0a9SMarius Strobl __FBSDID("$FreeBSD$"); 34bba6f0a9SMarius Strobl 358297758aSRafal Jaworowski #include "opt_platform.h" 36bba6f0a9SMarius Strobl #include <sys/param.h> 37bba6f0a9SMarius Strobl #include <sys/systm.h> 38bba6f0a9SMarius Strobl #include <sys/bus.h> 39bba6f0a9SMarius Strobl #include <sys/errno.h> 4094b4a038SNathan Whitehorn #include <sys/libkern.h> 41bba6f0a9SMarius Strobl 42c47d4cdeSIan Lepore #include <machine/resource.h> 43c47d4cdeSIan Lepore 4494b4a038SNathan Whitehorn #include <dev/ofw/ofw_bus.h> 45bba6f0a9SMarius Strobl #include <dev/ofw/ofw_bus_subr.h> 46bba6f0a9SMarius Strobl #include <dev/ofw/openfirm.h> 47bba6f0a9SMarius Strobl 48bba6f0a9SMarius Strobl #include "ofw_bus_if.h" 49bba6f0a9SMarius Strobl 5024f4202dSJustin Hibbits #define OFW_COMPAT_LEN 255 51e5e94d2dSWojciech Macek #define OFW_STATUS_LEN 16 5224f4202dSJustin Hibbits 53bba6f0a9SMarius Strobl int 54bba6f0a9SMarius Strobl ofw_bus_gen_setup_devinfo(struct ofw_bus_devinfo *obd, phandle_t node) 55bba6f0a9SMarius Strobl { 56bba6f0a9SMarius Strobl 57bba6f0a9SMarius Strobl if (obd == NULL) 58bba6f0a9SMarius Strobl return (ENOMEM); 59bba6f0a9SMarius Strobl /* The 'name' property is considered mandatory. */ 60bba6f0a9SMarius Strobl if ((OF_getprop_alloc(node, "name", 1, (void **)&obd->obd_name)) == -1) 61bba6f0a9SMarius Strobl return (EINVAL); 62bba6f0a9SMarius Strobl OF_getprop_alloc(node, "compatible", 1, (void **)&obd->obd_compat); 63bba6f0a9SMarius Strobl OF_getprop_alloc(node, "device_type", 1, (void **)&obd->obd_type); 64bba6f0a9SMarius Strobl OF_getprop_alloc(node, "model", 1, (void **)&obd->obd_model); 65e4be5a16SNathan Whitehorn OF_getprop_alloc(node, "status", 1, (void **)&obd->obd_status); 66bba6f0a9SMarius Strobl obd->obd_node = node; 67bba6f0a9SMarius Strobl return (0); 68bba6f0a9SMarius Strobl } 69bba6f0a9SMarius Strobl 70bba6f0a9SMarius Strobl void 71bba6f0a9SMarius Strobl ofw_bus_gen_destroy_devinfo(struct ofw_bus_devinfo *obd) 72bba6f0a9SMarius Strobl { 73bba6f0a9SMarius Strobl 74bba6f0a9SMarius Strobl if (obd == NULL) 75bba6f0a9SMarius Strobl return; 76bba6f0a9SMarius Strobl if (obd->obd_compat != NULL) 77bba6f0a9SMarius Strobl free(obd->obd_compat, M_OFWPROP); 78bba6f0a9SMarius Strobl if (obd->obd_model != NULL) 79bba6f0a9SMarius Strobl free(obd->obd_model, M_OFWPROP); 80bba6f0a9SMarius Strobl if (obd->obd_name != NULL) 81bba6f0a9SMarius Strobl free(obd->obd_name, M_OFWPROP); 82bba6f0a9SMarius Strobl if (obd->obd_type != NULL) 83bba6f0a9SMarius Strobl free(obd->obd_type, M_OFWPROP); 84e4be5a16SNathan Whitehorn if (obd->obd_status != NULL) 85e4be5a16SNathan Whitehorn free(obd->obd_status, M_OFWPROP); 86bba6f0a9SMarius Strobl } 87bba6f0a9SMarius Strobl 8894b4a038SNathan Whitehorn int 8994b4a038SNathan Whitehorn ofw_bus_gen_child_pnpinfo_str(device_t cbdev, device_t child, char *buf, 9094b4a038SNathan Whitehorn size_t buflen) 9194b4a038SNathan Whitehorn { 92481d6b54SMarius Strobl 938cc3cfa8SWarner Losh *buf = '\0'; 9494b4a038SNathan Whitehorn if (ofw_bus_get_name(child) != NULL) { 9594b4a038SNathan Whitehorn strlcat(buf, "name=", buflen); 9694b4a038SNathan Whitehorn strlcat(buf, ofw_bus_get_name(child), buflen); 9794b4a038SNathan Whitehorn } 9894b4a038SNathan Whitehorn 9994b4a038SNathan Whitehorn if (ofw_bus_get_compat(child) != NULL) { 10094b4a038SNathan Whitehorn strlcat(buf, " compat=", buflen); 10194b4a038SNathan Whitehorn strlcat(buf, ofw_bus_get_compat(child), buflen); 10294b4a038SNathan Whitehorn } 10394b4a038SNathan Whitehorn return (0); 10494b4a038SNathan Whitehorn }; 105bba6f0a9SMarius Strobl 106bba6f0a9SMarius Strobl const char * 107bba6f0a9SMarius Strobl ofw_bus_gen_get_compat(device_t bus, device_t dev) 108bba6f0a9SMarius Strobl { 109bba6f0a9SMarius Strobl const struct ofw_bus_devinfo *obd; 110bba6f0a9SMarius Strobl 111bba6f0a9SMarius Strobl obd = OFW_BUS_GET_DEVINFO(bus, dev); 112bba6f0a9SMarius Strobl if (obd == NULL) 113bba6f0a9SMarius Strobl return (NULL); 114bba6f0a9SMarius Strobl return (obd->obd_compat); 115bba6f0a9SMarius Strobl } 116bba6f0a9SMarius Strobl 117bba6f0a9SMarius Strobl const char * 118bba6f0a9SMarius Strobl ofw_bus_gen_get_model(device_t bus, device_t dev) 119bba6f0a9SMarius Strobl { 120bba6f0a9SMarius Strobl const struct ofw_bus_devinfo *obd; 121bba6f0a9SMarius Strobl 122bba6f0a9SMarius Strobl obd = OFW_BUS_GET_DEVINFO(bus, dev); 123bba6f0a9SMarius Strobl if (obd == NULL) 124bba6f0a9SMarius Strobl return (NULL); 125bba6f0a9SMarius Strobl return (obd->obd_model); 126bba6f0a9SMarius Strobl } 127bba6f0a9SMarius Strobl 128bba6f0a9SMarius Strobl const char * 129bba6f0a9SMarius Strobl ofw_bus_gen_get_name(device_t bus, device_t dev) 130bba6f0a9SMarius Strobl { 131bba6f0a9SMarius Strobl const struct ofw_bus_devinfo *obd; 132bba6f0a9SMarius Strobl 133bba6f0a9SMarius Strobl obd = OFW_BUS_GET_DEVINFO(bus, dev); 134bba6f0a9SMarius Strobl if (obd == NULL) 135bba6f0a9SMarius Strobl return (NULL); 136bba6f0a9SMarius Strobl return (obd->obd_name); 137bba6f0a9SMarius Strobl } 138bba6f0a9SMarius Strobl 139bba6f0a9SMarius Strobl phandle_t 140bba6f0a9SMarius Strobl ofw_bus_gen_get_node(device_t bus, device_t dev) 141bba6f0a9SMarius Strobl { 142bba6f0a9SMarius Strobl const struct ofw_bus_devinfo *obd; 143bba6f0a9SMarius Strobl 144bba6f0a9SMarius Strobl obd = OFW_BUS_GET_DEVINFO(bus, dev); 145bba6f0a9SMarius Strobl if (obd == NULL) 146bba6f0a9SMarius Strobl return (0); 147bba6f0a9SMarius Strobl return (obd->obd_node); 148bba6f0a9SMarius Strobl } 149bba6f0a9SMarius Strobl 150bba6f0a9SMarius Strobl const char * 151bba6f0a9SMarius Strobl ofw_bus_gen_get_type(device_t bus, device_t dev) 152bba6f0a9SMarius Strobl { 153bba6f0a9SMarius Strobl const struct ofw_bus_devinfo *obd; 154bba6f0a9SMarius Strobl 155bba6f0a9SMarius Strobl obd = OFW_BUS_GET_DEVINFO(bus, dev); 156bba6f0a9SMarius Strobl if (obd == NULL) 157bba6f0a9SMarius Strobl return (NULL); 158bba6f0a9SMarius Strobl return (obd->obd_type); 159bba6f0a9SMarius Strobl } 16094b4a038SNathan Whitehorn 161e4be5a16SNathan Whitehorn const char * 162e4be5a16SNathan Whitehorn ofw_bus_get_status(device_t dev) 163e4be5a16SNathan Whitehorn { 164e4be5a16SNathan Whitehorn const struct ofw_bus_devinfo *obd; 165e4be5a16SNathan Whitehorn 166e4be5a16SNathan Whitehorn obd = OFW_BUS_GET_DEVINFO(device_get_parent(dev), dev); 167e4be5a16SNathan Whitehorn if (obd == NULL) 168e4be5a16SNathan Whitehorn return (NULL); 169e4be5a16SNathan Whitehorn 170e4be5a16SNathan Whitehorn return (obd->obd_status); 171e4be5a16SNathan Whitehorn } 172e4be5a16SNathan Whitehorn 173e4be5a16SNathan Whitehorn int 174e4be5a16SNathan Whitehorn ofw_bus_status_okay(device_t dev) 175e4be5a16SNathan Whitehorn { 176e4be5a16SNathan Whitehorn const char *status; 177e4be5a16SNathan Whitehorn 178e4be5a16SNathan Whitehorn status = ofw_bus_get_status(dev); 179f3856d8fSAndrew Turner if (status == NULL || strcmp(status, "okay") == 0 || 180f3856d8fSAndrew Turner strcmp(status, "ok") == 0) 181e4be5a16SNathan Whitehorn return (1); 182e4be5a16SNathan Whitehorn 183e4be5a16SNathan Whitehorn return (0); 184e4be5a16SNathan Whitehorn } 185e4be5a16SNathan Whitehorn 186e5e94d2dSWojciech Macek int 187e5e94d2dSWojciech Macek ofw_bus_node_status_okay(phandle_t node) 188e5e94d2dSWojciech Macek { 189e5e94d2dSWojciech Macek char status[OFW_STATUS_LEN]; 190e5e94d2dSWojciech Macek int len; 191e5e94d2dSWojciech Macek 192e5e94d2dSWojciech Macek len = OF_getproplen(node, "status"); 193e5e94d2dSWojciech Macek if (len <= 0) 194e5e94d2dSWojciech Macek return (1); 195e5e94d2dSWojciech Macek 196e5e94d2dSWojciech Macek OF_getprop(node, "status", status, OFW_STATUS_LEN); 197e5e94d2dSWojciech Macek if ((len == 5 && (bcmp(status, "okay", len) == 0)) || 198e5e94d2dSWojciech Macek (len == 3 && (bcmp(status, "ok", len)))) 199e5e94d2dSWojciech Macek return (1); 200e5e94d2dSWojciech Macek 201e5e94d2dSWojciech Macek return (0); 202e5e94d2dSWojciech Macek } 203e5e94d2dSWojciech Macek 20472a638c7SAndrew Turner static int 20524f4202dSJustin Hibbits ofw_bus_node_is_compatible_int(const char *compat, int len, 20624f4202dSJustin Hibbits const char *onecompat) 20772a638c7SAndrew Turner { 20872a638c7SAndrew Turner int onelen, l, ret; 20972a638c7SAndrew Turner 21072a638c7SAndrew Turner onelen = strlen(onecompat); 21172a638c7SAndrew Turner 21272a638c7SAndrew Turner ret = 0; 21372a638c7SAndrew Turner while (len > 0) { 21472a638c7SAndrew Turner if (strlen(compat) == onelen && 21572a638c7SAndrew Turner strncasecmp(compat, onecompat, onelen) == 0) { 21672a638c7SAndrew Turner /* Found it. */ 21772a638c7SAndrew Turner ret = 1; 21872a638c7SAndrew Turner break; 21972a638c7SAndrew Turner } 22072a638c7SAndrew Turner 22172a638c7SAndrew Turner /* Slide to the next sub-string. */ 22272a638c7SAndrew Turner l = strlen(compat) + 1; 22372a638c7SAndrew Turner compat += l; 22472a638c7SAndrew Turner len -= l; 22572a638c7SAndrew Turner } 22672a638c7SAndrew Turner 22772a638c7SAndrew Turner return (ret); 22872a638c7SAndrew Turner } 22972a638c7SAndrew Turner 2308297758aSRafal Jaworowski int 23124f4202dSJustin Hibbits ofw_bus_node_is_compatible(phandle_t node, const char *compatstr) 23224f4202dSJustin Hibbits { 23324f4202dSJustin Hibbits char compat[OFW_COMPAT_LEN]; 23424f4202dSJustin Hibbits int len, rv; 23524f4202dSJustin Hibbits 23624f4202dSJustin Hibbits if ((len = OF_getproplen(node, "compatible")) <= 0) 23724f4202dSJustin Hibbits return (0); 23824f4202dSJustin Hibbits 23924f4202dSJustin Hibbits bzero(compat, OFW_COMPAT_LEN); 24024f4202dSJustin Hibbits 24124f4202dSJustin Hibbits if (OF_getprop(node, "compatible", compat, OFW_COMPAT_LEN) < 0) 24224f4202dSJustin Hibbits return (0); 24324f4202dSJustin Hibbits 24424f4202dSJustin Hibbits rv = ofw_bus_node_is_compatible_int(compat, len, compatstr); 24524f4202dSJustin Hibbits 24624f4202dSJustin Hibbits return (rv); 24724f4202dSJustin Hibbits } 24824f4202dSJustin Hibbits 24924f4202dSJustin Hibbits int 2508297758aSRafal Jaworowski ofw_bus_is_compatible(device_t dev, const char *onecompat) 2518297758aSRafal Jaworowski { 2528297758aSRafal Jaworowski phandle_t node; 2538297758aSRafal Jaworowski const char *compat; 25472a638c7SAndrew Turner int len; 2558297758aSRafal Jaworowski 2568297758aSRafal Jaworowski if ((compat = ofw_bus_get_compat(dev)) == NULL) 2578297758aSRafal Jaworowski return (0); 2588297758aSRafal Jaworowski 2590d8d9edaSNathan Whitehorn if ((node = ofw_bus_get_node(dev)) == -1) 2608297758aSRafal Jaworowski return (0); 2618297758aSRafal Jaworowski 2628297758aSRafal Jaworowski /* Get total 'compatible' prop len */ 2638297758aSRafal Jaworowski if ((len = OF_getproplen(node, "compatible")) <= 0) 2648297758aSRafal Jaworowski return (0); 2658297758aSRafal Jaworowski 26624f4202dSJustin Hibbits return (ofw_bus_node_is_compatible_int(compat, len, onecompat)); 2678297758aSRafal Jaworowski } 2688297758aSRafal Jaworowski 2698297758aSRafal Jaworowski int 2708297758aSRafal Jaworowski ofw_bus_is_compatible_strict(device_t dev, const char *compatible) 2718297758aSRafal Jaworowski { 2728297758aSRafal Jaworowski const char *compat; 27326ca4965SHiroki Sato size_t len; 2748297758aSRafal Jaworowski 2758297758aSRafal Jaworowski if ((compat = ofw_bus_get_compat(dev)) == NULL) 2768297758aSRafal Jaworowski return (0); 2778297758aSRafal Jaworowski 27826ca4965SHiroki Sato len = strlen(compatible); 27926ca4965SHiroki Sato if (strlen(compat) == len && 28026ca4965SHiroki Sato strncasecmp(compat, compatible, len) == 0) 2818297758aSRafal Jaworowski return (1); 2828297758aSRafal Jaworowski 2838297758aSRafal Jaworowski return (0); 2848297758aSRafal Jaworowski } 2858297758aSRafal Jaworowski 286498fa7c1SIan Lepore const struct ofw_compat_data * 287498fa7c1SIan Lepore ofw_bus_search_compatible(device_t dev, const struct ofw_compat_data *compat) 288498fa7c1SIan Lepore { 289498fa7c1SIan Lepore 290498fa7c1SIan Lepore if (compat == NULL) 291498fa7c1SIan Lepore return NULL; 292498fa7c1SIan Lepore 293498fa7c1SIan Lepore for (; compat->ocd_str != NULL; ++compat) { 294498fa7c1SIan Lepore if (ofw_bus_is_compatible(dev, compat->ocd_str)) 295498fa7c1SIan Lepore break; 296498fa7c1SIan Lepore } 297498fa7c1SIan Lepore 298498fa7c1SIan Lepore return (compat); 299498fa7c1SIan Lepore } 300498fa7c1SIan Lepore 30126ca4965SHiroki Sato int 30226ca4965SHiroki Sato ofw_bus_has_prop(device_t dev, const char *propname) 30326ca4965SHiroki Sato { 30426ca4965SHiroki Sato phandle_t node; 30526ca4965SHiroki Sato 30626ca4965SHiroki Sato if ((node = ofw_bus_get_node(dev)) == -1) 30726ca4965SHiroki Sato return (0); 30826ca4965SHiroki Sato 30926ca4965SHiroki Sato return (OF_hasprop(node, propname)); 31026ca4965SHiroki Sato } 31126ca4965SHiroki Sato 31294b4a038SNathan Whitehorn void 31394b4a038SNathan Whitehorn ofw_bus_setup_iinfo(phandle_t node, struct ofw_bus_iinfo *ii, int intrsz) 31494b4a038SNathan Whitehorn { 31594b4a038SNathan Whitehorn pcell_t addrc; 31694b4a038SNathan Whitehorn int msksz; 31794b4a038SNathan Whitehorn 318d3a0a0f3SNathan Whitehorn if (OF_getencprop(node, "#address-cells", &addrc, sizeof(addrc)) == -1) 31994b4a038SNathan Whitehorn addrc = 2; 32094b4a038SNathan Whitehorn ii->opi_addrc = addrc * sizeof(pcell_t); 32194b4a038SNathan Whitehorn 322d3a0a0f3SNathan Whitehorn ii->opi_imapsz = OF_getencprop_alloc(node, "interrupt-map", 1, 32394b4a038SNathan Whitehorn (void **)&ii->opi_imap); 32494b4a038SNathan Whitehorn if (ii->opi_imapsz > 0) { 325d3a0a0f3SNathan Whitehorn msksz = OF_getencprop_alloc(node, "interrupt-map-mask", 1, 32694b4a038SNathan Whitehorn (void **)&ii->opi_imapmsk); 32794b4a038SNathan Whitehorn /* 328481d6b54SMarius Strobl * Failure to get the mask is ignored; a full mask is used 329481d6b54SMarius Strobl * then. We barf on bad mask sizes, however. 33094b4a038SNathan Whitehorn */ 331481d6b54SMarius Strobl if (msksz != -1 && msksz != ii->opi_addrc + intrsz) 33294b4a038SNathan Whitehorn panic("ofw_bus_setup_iinfo: bad interrupt-map-mask " 33394b4a038SNathan Whitehorn "property!"); 33494b4a038SNathan Whitehorn } 33594b4a038SNathan Whitehorn } 33694b4a038SNathan Whitehorn 33794b4a038SNathan Whitehorn int 33894b4a038SNathan Whitehorn ofw_bus_lookup_imap(phandle_t node, struct ofw_bus_iinfo *ii, void *reg, 33994b4a038SNathan Whitehorn int regsz, void *pintr, int pintrsz, void *mintr, int mintrsz, 34095e3bfe8SNathan Whitehorn phandle_t *iparent) 34194b4a038SNathan Whitehorn { 34295e3bfe8SNathan Whitehorn uint8_t maskbuf[regsz + pintrsz]; 34394b4a038SNathan Whitehorn int rv; 34494b4a038SNathan Whitehorn 34594b4a038SNathan Whitehorn if (ii->opi_imapsz <= 0) 34694b4a038SNathan Whitehorn return (0); 34794b4a038SNathan Whitehorn KASSERT(regsz >= ii->opi_addrc, 34894b4a038SNathan Whitehorn ("ofw_bus_lookup_imap: register size too small: %d < %d", 34994b4a038SNathan Whitehorn regsz, ii->opi_addrc)); 3506064b6acSNathan Whitehorn if (node != -1) { 351d3a0a0f3SNathan Whitehorn rv = OF_getencprop(node, "reg", reg, regsz); 35294b4a038SNathan Whitehorn if (rv < regsz) 3536064b6acSNathan Whitehorn panic("ofw_bus_lookup_imap: cannot get reg property"); 3546064b6acSNathan Whitehorn } 35594b4a038SNathan Whitehorn return (ofw_bus_search_intrmap(pintr, pintrsz, reg, ii->opi_addrc, 35694b4a038SNathan Whitehorn ii->opi_imap, ii->opi_imapsz, ii->opi_imapmsk, maskbuf, mintr, 357eaef5f0aSNathan Whitehorn mintrsz, iparent)); 35894b4a038SNathan Whitehorn } 35994b4a038SNathan Whitehorn 36094b4a038SNathan Whitehorn /* 36194b4a038SNathan Whitehorn * Map an interrupt using the firmware reg, interrupt-map and 36294b4a038SNathan Whitehorn * interrupt-map-mask properties. 36394b4a038SNathan Whitehorn * The interrupt property to be mapped must be of size intrsz, and pointed to 36494b4a038SNathan Whitehorn * by intr. The regs property of the node for which the mapping is done must 36594b4a038SNathan Whitehorn * be passed as regs. This property is an array of register specifications; 36694b4a038SNathan Whitehorn * the size of the address part of such a specification must be passed as 36794b4a038SNathan Whitehorn * physsz. Only the first element of the property is used. 36894b4a038SNathan Whitehorn * imap and imapsz hold the interrupt mask and it's size. 36994b4a038SNathan Whitehorn * imapmsk is a pointer to the interrupt-map-mask property, which must have 37094b4a038SNathan Whitehorn * a size of physsz + intrsz; it may be NULL, in which case a full mask is 37194b4a038SNathan Whitehorn * assumed. 37294b4a038SNathan Whitehorn * maskbuf must point to a buffer of length physsz + intrsz. 37394b4a038SNathan Whitehorn * The interrupt is returned in result, which must point to a buffer of length 37494b4a038SNathan Whitehorn * rintrsz (which gives the expected size of the mapped interrupt). 375cb6d9d6cSNathan Whitehorn * Returns number of cells in the interrupt if a mapping was found, 0 otherwise. 37694b4a038SNathan Whitehorn */ 37794b4a038SNathan Whitehorn int 37894b4a038SNathan Whitehorn ofw_bus_search_intrmap(void *intr, int intrsz, void *regs, int physsz, 37994b4a038SNathan Whitehorn void *imap, int imapsz, void *imapmsk, void *maskbuf, void *result, 380eaef5f0aSNathan Whitehorn int rintrsz, phandle_t *iparent) 38194b4a038SNathan Whitehorn { 38294b4a038SNathan Whitehorn phandle_t parent; 383481d6b54SMarius Strobl uint8_t *ref = maskbuf; 384481d6b54SMarius Strobl uint8_t *uiintr = intr; 385481d6b54SMarius Strobl uint8_t *uiregs = regs; 386481d6b54SMarius Strobl uint8_t *uiimapmsk = imapmsk; 387481d6b54SMarius Strobl uint8_t *mptr; 388122493cfSAndrew Turner pcell_t paddrsz; 38994b4a038SNathan Whitehorn pcell_t pintrsz; 390151ba793SAlexander Kabaev int i, tsz; 39194b4a038SNathan Whitehorn 39294b4a038SNathan Whitehorn if (imapmsk != NULL) { 39394b4a038SNathan Whitehorn for (i = 0; i < physsz; i++) 39494b4a038SNathan Whitehorn ref[i] = uiregs[i] & uiimapmsk[i]; 39594b4a038SNathan Whitehorn for (i = 0; i < intrsz; i++) 39694b4a038SNathan Whitehorn ref[physsz + i] = uiintr[i] & uiimapmsk[physsz + i]; 39794b4a038SNathan Whitehorn } else { 39894b4a038SNathan Whitehorn bcopy(regs, ref, physsz); 39994b4a038SNathan Whitehorn bcopy(intr, ref + physsz, intrsz); 40094b4a038SNathan Whitehorn } 40194b4a038SNathan Whitehorn 40294b4a038SNathan Whitehorn mptr = imap; 40394b4a038SNathan Whitehorn i = imapsz; 404122493cfSAndrew Turner paddrsz = 0; 40594b4a038SNathan Whitehorn while (i > 0) { 40694b4a038SNathan Whitehorn bcopy(mptr + physsz + intrsz, &parent, sizeof(parent)); 4079f4a7eaeSNathan Whitehorn #ifndef OFW_IMAP_NO_IPARENT_ADDR_CELLS 408122493cfSAndrew Turner /* 4099f4a7eaeSNathan Whitehorn * Find if we need to read the parent address data. 4109f4a7eaeSNathan Whitehorn * CHRP-derived OF bindings, including ePAPR-compliant FDTs, 4119f4a7eaeSNathan Whitehorn * use this as an optional part of the specifier. 412122493cfSAndrew Turner */ 413122493cfSAndrew Turner if (OF_getencprop(OF_node_from_xref(parent), 414122493cfSAndrew Turner "#address-cells", &paddrsz, sizeof(paddrsz)) == -1) 415122493cfSAndrew Turner paddrsz = 0; /* default */ 416122493cfSAndrew Turner paddrsz *= sizeof(pcell_t); 417122493cfSAndrew Turner #endif 418122493cfSAndrew Turner 419752ba930SIan Lepore if (OF_searchencprop(OF_node_from_xref(parent), 420d3a0a0f3SNathan Whitehorn "#interrupt-cells", &pintrsz, sizeof(pintrsz)) == -1) 42194b4a038SNathan Whitehorn pintrsz = 1; /* default */ 42294b4a038SNathan Whitehorn pintrsz *= sizeof(pcell_t); 423acb97117SNathan Whitehorn 424481d6b54SMarius Strobl /* Compute the map stride size. */ 425122493cfSAndrew Turner tsz = physsz + intrsz + sizeof(phandle_t) + paddrsz + pintrsz; 426acb97117SNathan Whitehorn KASSERT(i >= tsz, ("ofw_bus_search_intrmap: truncated map")); 42794b4a038SNathan Whitehorn 42894b4a038SNathan Whitehorn if (bcmp(ref, mptr, physsz + intrsz) == 0) { 429122493cfSAndrew Turner bcopy(mptr + physsz + intrsz + sizeof(parent) + paddrsz, 430cb6d9d6cSNathan Whitehorn result, MIN(rintrsz, pintrsz)); 431eaef5f0aSNathan Whitehorn 432eaef5f0aSNathan Whitehorn if (iparent != NULL) 433eaef5f0aSNathan Whitehorn *iparent = parent; 434cb6d9d6cSNathan Whitehorn return (pintrsz/sizeof(pcell_t)); 43594b4a038SNathan Whitehorn } 43694b4a038SNathan Whitehorn mptr += tsz; 43794b4a038SNathan Whitehorn i -= tsz; 43894b4a038SNathan Whitehorn } 43994b4a038SNathan Whitehorn return (0); 44094b4a038SNathan Whitehorn } 4416064b6acSNathan Whitehorn 442c47d4cdeSIan Lepore int 4431e43b18cSAndrew Turner ofw_bus_msimap(phandle_t node, uint16_t pci_rid, phandle_t *msi_parent, 4441e43b18cSAndrew Turner uint32_t *msi_rid) 4451e43b18cSAndrew Turner { 4461e43b18cSAndrew Turner pcell_t *map, mask, msi_base, rid_base, rid_length; 4471e43b18cSAndrew Turner ssize_t len; 448151ba793SAlexander Kabaev uint32_t masked_rid; 4491e43b18cSAndrew Turner int err, i; 4501e43b18cSAndrew Turner 4511e43b18cSAndrew Turner /* TODO: This should be OF_searchprop_alloc if we had it */ 4521e43b18cSAndrew Turner len = OF_getencprop_alloc(node, "msi-map", sizeof(*map), (void **)&map); 4531e43b18cSAndrew Turner if (len < 0) { 4541e43b18cSAndrew Turner if (msi_parent != NULL) { 4551e43b18cSAndrew Turner *msi_parent = 0; 4561e43b18cSAndrew Turner OF_getencprop(node, "msi-parent", msi_parent, 4571e43b18cSAndrew Turner sizeof(*msi_parent)); 4581e43b18cSAndrew Turner } 4591e43b18cSAndrew Turner if (msi_rid != NULL) 4601e43b18cSAndrew Turner *msi_rid = pci_rid; 4611e43b18cSAndrew Turner return (0); 4621e43b18cSAndrew Turner } 4631e43b18cSAndrew Turner 4641e43b18cSAndrew Turner err = ENOENT; 4651e43b18cSAndrew Turner mask = 0xffffffff; 4661e43b18cSAndrew Turner OF_getencprop(node, "msi-map-mask", &mask, sizeof(mask)); 4671e43b18cSAndrew Turner 4681e43b18cSAndrew Turner masked_rid = pci_rid & mask; 4691e43b18cSAndrew Turner for (i = 0; i < len; i += 4) { 4701e43b18cSAndrew Turner rid_base = map[i + 0]; 4711e43b18cSAndrew Turner rid_length = map[i + 3]; 4721e43b18cSAndrew Turner 4731e43b18cSAndrew Turner if (masked_rid < rid_base || 4741e43b18cSAndrew Turner masked_rid >= (rid_base + rid_length)) 4751e43b18cSAndrew Turner continue; 4761e43b18cSAndrew Turner 4771e43b18cSAndrew Turner msi_base = map[i + 2]; 4781e43b18cSAndrew Turner 4791e43b18cSAndrew Turner if (msi_parent != NULL) 4801e43b18cSAndrew Turner *msi_parent = map[i + 1]; 4811e43b18cSAndrew Turner if (msi_rid != NULL) 4821e43b18cSAndrew Turner *msi_rid = masked_rid - rid_base + msi_base; 4831e43b18cSAndrew Turner err = 0; 4841e43b18cSAndrew Turner break; 4851e43b18cSAndrew Turner } 4861e43b18cSAndrew Turner 4871e43b18cSAndrew Turner free(map, M_OFWPROP); 4881e43b18cSAndrew Turner 4891e43b18cSAndrew Turner return (err); 4901e43b18cSAndrew Turner } 4911e43b18cSAndrew Turner 492d310c9e0SMarcin Wojtas static int 493d310c9e0SMarcin Wojtas ofw_bus_reg_to_rl_helper(device_t dev, phandle_t node, pcell_t acells, pcell_t scells, 494d310c9e0SMarcin Wojtas struct resource_list *rl, const char *reg_source) 4954b3d9160SZbigniew Bodek { 4964b3d9160SZbigniew Bodek uint64_t phys, size; 4974b3d9160SZbigniew Bodek ssize_t i, j, rid, nreg, ret; 4984b3d9160SZbigniew Bodek uint32_t *reg; 4994b3d9160SZbigniew Bodek char *name; 5004b3d9160SZbigniew Bodek 5014b3d9160SZbigniew Bodek /* 5024b3d9160SZbigniew Bodek * This may be just redundant when having ofw_bus_devinfo 5034b3d9160SZbigniew Bodek * but makes this routine independent of it. 5044b3d9160SZbigniew Bodek */ 5057339f782SOleksandr Tymoshenko ret = OF_getprop_alloc(node, "name", sizeof(*name), (void **)&name); 5064b3d9160SZbigniew Bodek if (ret == -1) 5074b3d9160SZbigniew Bodek name = NULL; 5084b3d9160SZbigniew Bodek 509d310c9e0SMarcin Wojtas ret = OF_getencprop_alloc(node, reg_source, sizeof(*reg), (void **)®); 5104b3d9160SZbigniew Bodek nreg = (ret == -1) ? 0 : ret; 5114b3d9160SZbigniew Bodek 5124b3d9160SZbigniew Bodek if (nreg % (acells + scells) != 0) { 5134b3d9160SZbigniew Bodek if (bootverbose) 5144b3d9160SZbigniew Bodek device_printf(dev, "Malformed reg property on <%s>\n", 5154b3d9160SZbigniew Bodek (name == NULL) ? "unknown" : name); 5164b3d9160SZbigniew Bodek nreg = 0; 5174b3d9160SZbigniew Bodek } 5184b3d9160SZbigniew Bodek 5194b3d9160SZbigniew Bodek for (i = 0, rid = 0; i < nreg; i += acells + scells, rid++) { 5204b3d9160SZbigniew Bodek phys = size = 0; 5214b3d9160SZbigniew Bodek for (j = 0; j < acells; j++) { 5224b3d9160SZbigniew Bodek phys <<= 32; 5234b3d9160SZbigniew Bodek phys |= reg[i + j]; 5244b3d9160SZbigniew Bodek } 5254b3d9160SZbigniew Bodek for (j = 0; j < scells; j++) { 5264b3d9160SZbigniew Bodek size <<= 32; 5274b3d9160SZbigniew Bodek size |= reg[i + acells + j]; 5284b3d9160SZbigniew Bodek } 5294b3d9160SZbigniew Bodek /* Skip the dummy reg property of glue devices like ssm(4). */ 5304b3d9160SZbigniew Bodek if (size != 0) 5314b3d9160SZbigniew Bodek resource_list_add(rl, SYS_RES_MEMORY, rid, 5324b3d9160SZbigniew Bodek phys, phys + size - 1, size); 5334b3d9160SZbigniew Bodek } 5344b3d9160SZbigniew Bodek free(name, M_OFWPROP); 5354b3d9160SZbigniew Bodek free(reg, M_OFWPROP); 5364b3d9160SZbigniew Bodek 5374b3d9160SZbigniew Bodek return (0); 5384b3d9160SZbigniew Bodek } 5394b3d9160SZbigniew Bodek 540d310c9e0SMarcin Wojtas int 541d310c9e0SMarcin Wojtas ofw_bus_reg_to_rl(device_t dev, phandle_t node, pcell_t acells, pcell_t scells, 542d310c9e0SMarcin Wojtas struct resource_list *rl) 543d310c9e0SMarcin Wojtas { 544d310c9e0SMarcin Wojtas 545d310c9e0SMarcin Wojtas return (ofw_bus_reg_to_rl_helper(dev, node, acells, scells, rl, "reg")); 546d310c9e0SMarcin Wojtas } 547d310c9e0SMarcin Wojtas 548d310c9e0SMarcin Wojtas int 549d310c9e0SMarcin Wojtas ofw_bus_assigned_addresses_to_rl(device_t dev, phandle_t node, pcell_t acells, 550d310c9e0SMarcin Wojtas pcell_t scells, struct resource_list *rl) 551d310c9e0SMarcin Wojtas { 552d310c9e0SMarcin Wojtas 553d310c9e0SMarcin Wojtas return (ofw_bus_reg_to_rl_helper(dev, node, acells, scells, 554d310c9e0SMarcin Wojtas rl, "assigned-addresses")); 555d310c9e0SMarcin Wojtas } 556d310c9e0SMarcin Wojtas 557821a61efSMichal Meloun /* 558821a61efSMichal Meloun * Get interrupt parent for given node. 559821a61efSMichal Meloun * Returns 0 if interrupt parent doesn't exist. 560821a61efSMichal Meloun */ 561821a61efSMichal Meloun phandle_t 562821a61efSMichal Meloun ofw_bus_find_iparent(phandle_t node) 563821a61efSMichal Meloun { 564821a61efSMichal Meloun phandle_t iparent; 565821a61efSMichal Meloun 566821a61efSMichal Meloun if (OF_searchencprop(node, "interrupt-parent", &iparent, 567821a61efSMichal Meloun sizeof(iparent)) == -1) { 568821a61efSMichal Meloun for (iparent = node; iparent != 0; 569821a61efSMichal Meloun iparent = OF_parent(iparent)) { 570821a61efSMichal Meloun if (OF_hasprop(iparent, "interrupt-controller")) 571821a61efSMichal Meloun break; 572821a61efSMichal Meloun } 573821a61efSMichal Meloun iparent = OF_xref_from_node(iparent); 574821a61efSMichal Meloun } 575821a61efSMichal Meloun return (iparent); 576821a61efSMichal Meloun } 577821a61efSMichal Meloun 5784b3d9160SZbigniew Bodek int 579a8c5ea04SRuslan Bukin ofw_bus_intr_to_rl(device_t dev, phandle_t node, 580a8c5ea04SRuslan Bukin struct resource_list *rl, int *rlen) 581c47d4cdeSIan Lepore { 582c47d4cdeSIan Lepore phandle_t iparent; 583c47d4cdeSIan Lepore uint32_t icells, *intr; 584c47d4cdeSIan Lepore int err, i, irqnum, nintr, rid; 585c47d4cdeSIan Lepore boolean_t extended; 586c47d4cdeSIan Lepore 587c47d4cdeSIan Lepore nintr = OF_getencprop_alloc(node, "interrupts", sizeof(*intr), 588c47d4cdeSIan Lepore (void **)&intr); 589c47d4cdeSIan Lepore if (nintr > 0) { 590821a61efSMichal Meloun iparent = ofw_bus_find_iparent(node); 59108b96b9fSNathan Whitehorn if (iparent == 0) { 592c47d4cdeSIan Lepore device_printf(dev, "No interrupt-parent found, " 593c47d4cdeSIan Lepore "assuming direct parent\n"); 594c47d4cdeSIan Lepore iparent = OF_parent(node); 59508b96b9fSNathan Whitehorn iparent = OF_xref_from_node(iparent); 59608b96b9fSNathan Whitehorn } 597c47d4cdeSIan Lepore if (OF_searchencprop(OF_node_from_xref(iparent), 598c47d4cdeSIan Lepore "#interrupt-cells", &icells, sizeof(icells)) == -1) { 599c47d4cdeSIan Lepore device_printf(dev, "Missing #interrupt-cells " 600c47d4cdeSIan Lepore "property, assuming <1>\n"); 601c47d4cdeSIan Lepore icells = 1; 602c47d4cdeSIan Lepore } 603c47d4cdeSIan Lepore if (icells < 1 || icells > nintr) { 604c47d4cdeSIan Lepore device_printf(dev, "Invalid #interrupt-cells property " 605c47d4cdeSIan Lepore "value <%d>, assuming <1>\n", icells); 606c47d4cdeSIan Lepore icells = 1; 607c47d4cdeSIan Lepore } 608c47d4cdeSIan Lepore extended = false; 609c47d4cdeSIan Lepore } else { 610c47d4cdeSIan Lepore nintr = OF_getencprop_alloc(node, "interrupts-extended", 611c47d4cdeSIan Lepore sizeof(*intr), (void **)&intr); 612c47d4cdeSIan Lepore if (nintr <= 0) 613c47d4cdeSIan Lepore return (0); 614c47d4cdeSIan Lepore extended = true; 615c47d4cdeSIan Lepore } 616c47d4cdeSIan Lepore err = 0; 617c47d4cdeSIan Lepore rid = 0; 618c47d4cdeSIan Lepore for (i = 0; i < nintr; i += icells) { 619c47d4cdeSIan Lepore if (extended) { 620c47d4cdeSIan Lepore iparent = intr[i++]; 621c47d4cdeSIan Lepore if (OF_searchencprop(OF_node_from_xref(iparent), 622c47d4cdeSIan Lepore "#interrupt-cells", &icells, sizeof(icells)) == -1) { 623c47d4cdeSIan Lepore device_printf(dev, "Missing #interrupt-cells " 624c47d4cdeSIan Lepore "property\n"); 625c47d4cdeSIan Lepore err = ENOENT; 626c47d4cdeSIan Lepore break; 627c47d4cdeSIan Lepore } 628c47d4cdeSIan Lepore if (icells < 1 || (i + icells) > nintr) { 629c47d4cdeSIan Lepore device_printf(dev, "Invalid #interrupt-cells " 630c47d4cdeSIan Lepore "property value <%d>\n", icells); 631c47d4cdeSIan Lepore err = ERANGE; 632c47d4cdeSIan Lepore break; 633c47d4cdeSIan Lepore } 634c47d4cdeSIan Lepore } 635c47d4cdeSIan Lepore irqnum = ofw_bus_map_intr(dev, iparent, icells, &intr[i]); 636c47d4cdeSIan Lepore resource_list_add(rl, SYS_RES_IRQ, rid++, irqnum, irqnum, 1); 637c47d4cdeSIan Lepore } 638a8c5ea04SRuslan Bukin if (rlen != NULL) 639a8c5ea04SRuslan Bukin *rlen = rid; 640c47d4cdeSIan Lepore free(intr, M_OFWPROP); 641c47d4cdeSIan Lepore return (err); 642c47d4cdeSIan Lepore } 643ad5244ecSSvatopluk Kraus 644ad5244ecSSvatopluk Kraus int 645ad5244ecSSvatopluk Kraus ofw_bus_intr_by_rid(device_t dev, phandle_t node, int wanted_rid, 646ad5244ecSSvatopluk Kraus phandle_t *producer, int *ncells, pcell_t **cells) 647ad5244ecSSvatopluk Kraus { 648ad5244ecSSvatopluk Kraus phandle_t iparent; 649ad5244ecSSvatopluk Kraus uint32_t icells, *intr; 650ad5244ecSSvatopluk Kraus int err, i, nintr, rid; 651ad5244ecSSvatopluk Kraus boolean_t extended; 652ad5244ecSSvatopluk Kraus 653ad5244ecSSvatopluk Kraus nintr = OF_getencprop_alloc(node, "interrupts", sizeof(*intr), 654ad5244ecSSvatopluk Kraus (void **)&intr); 655ad5244ecSSvatopluk Kraus if (nintr > 0) { 656ad5244ecSSvatopluk Kraus iparent = ofw_bus_find_iparent(node); 657ad5244ecSSvatopluk Kraus if (iparent == 0) { 658ad5244ecSSvatopluk Kraus device_printf(dev, "No interrupt-parent found, " 659ad5244ecSSvatopluk Kraus "assuming direct parent\n"); 660ad5244ecSSvatopluk Kraus iparent = OF_parent(node); 661ad5244ecSSvatopluk Kraus iparent = OF_xref_from_node(iparent); 662ad5244ecSSvatopluk Kraus } 663ad5244ecSSvatopluk Kraus if (OF_searchencprop(OF_node_from_xref(iparent), 664ad5244ecSSvatopluk Kraus "#interrupt-cells", &icells, sizeof(icells)) == -1) { 665ad5244ecSSvatopluk Kraus device_printf(dev, "Missing #interrupt-cells " 666ad5244ecSSvatopluk Kraus "property, assuming <1>\n"); 667ad5244ecSSvatopluk Kraus icells = 1; 668ad5244ecSSvatopluk Kraus } 669ad5244ecSSvatopluk Kraus if (icells < 1 || icells > nintr) { 670ad5244ecSSvatopluk Kraus device_printf(dev, "Invalid #interrupt-cells property " 671ad5244ecSSvatopluk Kraus "value <%d>, assuming <1>\n", icells); 672ad5244ecSSvatopluk Kraus icells = 1; 673ad5244ecSSvatopluk Kraus } 674ad5244ecSSvatopluk Kraus extended = false; 675ad5244ecSSvatopluk Kraus } else { 676ad5244ecSSvatopluk Kraus nintr = OF_getencprop_alloc(node, "interrupts-extended", 677ad5244ecSSvatopluk Kraus sizeof(*intr), (void **)&intr); 678ad5244ecSSvatopluk Kraus if (nintr <= 0) 679ad5244ecSSvatopluk Kraus return (ESRCH); 680ad5244ecSSvatopluk Kraus extended = true; 681ad5244ecSSvatopluk Kraus } 682ad5244ecSSvatopluk Kraus err = ESRCH; 683ad5244ecSSvatopluk Kraus rid = 0; 684ad5244ecSSvatopluk Kraus for (i = 0; i < nintr; i += icells, rid++) { 685ad5244ecSSvatopluk Kraus if (extended) { 686ad5244ecSSvatopluk Kraus iparent = intr[i++]; 687ad5244ecSSvatopluk Kraus if (OF_searchencprop(OF_node_from_xref(iparent), 688ad5244ecSSvatopluk Kraus "#interrupt-cells", &icells, sizeof(icells)) == -1) { 689ad5244ecSSvatopluk Kraus device_printf(dev, "Missing #interrupt-cells " 690ad5244ecSSvatopluk Kraus "property\n"); 691ad5244ecSSvatopluk Kraus err = ENOENT; 692ad5244ecSSvatopluk Kraus break; 693ad5244ecSSvatopluk Kraus } 694ad5244ecSSvatopluk Kraus if (icells < 1 || (i + icells) > nintr) { 695ad5244ecSSvatopluk Kraus device_printf(dev, "Invalid #interrupt-cells " 696ad5244ecSSvatopluk Kraus "property value <%d>\n", icells); 697ad5244ecSSvatopluk Kraus err = ERANGE; 698ad5244ecSSvatopluk Kraus break; 699ad5244ecSSvatopluk Kraus } 700ad5244ecSSvatopluk Kraus } 701ad5244ecSSvatopluk Kraus if (rid == wanted_rid) { 702ad5244ecSSvatopluk Kraus *cells = malloc(icells * sizeof(**cells), M_OFWPROP, 703ad5244ecSSvatopluk Kraus M_WAITOK); 704ad5244ecSSvatopluk Kraus *producer = iparent; 705ad5244ecSSvatopluk Kraus *ncells= icells; 706ad5244ecSSvatopluk Kraus memcpy(*cells, intr + i, icells * sizeof(**cells)); 707ad5244ecSSvatopluk Kraus err = 0; 708ad5244ecSSvatopluk Kraus break; 709ad5244ecSSvatopluk Kraus } 710ad5244ecSSvatopluk Kraus } 711ad5244ecSSvatopluk Kraus free(intr, M_OFWPROP); 712ad5244ecSSvatopluk Kraus return (err); 713ad5244ecSSvatopluk Kraus } 71408b96b9fSNathan Whitehorn 71572a638c7SAndrew Turner phandle_t 71637c1967cSOleksandr Tymoshenko ofw_bus_find_child(phandle_t start, const char *child_name) 71737c1967cSOleksandr Tymoshenko { 71837c1967cSOleksandr Tymoshenko char *name; 71937c1967cSOleksandr Tymoshenko int ret; 72037c1967cSOleksandr Tymoshenko phandle_t child; 72137c1967cSOleksandr Tymoshenko 72237c1967cSOleksandr Tymoshenko for (child = OF_child(start); child != 0; child = OF_peer(child)) { 7237339f782SOleksandr Tymoshenko ret = OF_getprop_alloc(child, "name", sizeof(*name), (void **)&name); 72437c1967cSOleksandr Tymoshenko if (ret == -1) 72537c1967cSOleksandr Tymoshenko continue; 72637c1967cSOleksandr Tymoshenko if (strcmp(name, child_name) == 0) { 72737c1967cSOleksandr Tymoshenko free(name, M_OFWPROP); 72837c1967cSOleksandr Tymoshenko return (child); 72937c1967cSOleksandr Tymoshenko } 73037c1967cSOleksandr Tymoshenko 73137c1967cSOleksandr Tymoshenko free(name, M_OFWPROP); 73237c1967cSOleksandr Tymoshenko } 73337c1967cSOleksandr Tymoshenko 73437c1967cSOleksandr Tymoshenko return (0); 73537c1967cSOleksandr Tymoshenko } 73637c1967cSOleksandr Tymoshenko 73737c1967cSOleksandr Tymoshenko phandle_t 73872a638c7SAndrew Turner ofw_bus_find_compatible(phandle_t node, const char *onecompat) 73972a638c7SAndrew Turner { 74072a638c7SAndrew Turner phandle_t child, ret; 74172a638c7SAndrew Turner 74272a638c7SAndrew Turner /* 74372a638c7SAndrew Turner * Traverse all children of 'start' node, and find first with 74472a638c7SAndrew Turner * matching 'compatible' property. 74572a638c7SAndrew Turner */ 74672a638c7SAndrew Turner for (child = OF_child(node); child != 0; child = OF_peer(child)) { 747edf3dd3bSMarcin Wojtas if (ofw_bus_node_is_compatible(child, onecompat) != 0) 74872a638c7SAndrew Turner return (child); 74972a638c7SAndrew Turner 75072a638c7SAndrew Turner ret = ofw_bus_find_compatible(child, onecompat); 75172a638c7SAndrew Turner if (ret != 0) 75272a638c7SAndrew Turner return (ret); 75372a638c7SAndrew Turner } 75472a638c7SAndrew Turner return (0); 75572a638c7SAndrew Turner } 756bb39ff4cSWarner Losh 757bb39ff4cSWarner Losh /** 758bb39ff4cSWarner Losh * @brief Return child of bus whose phandle is node 759bb39ff4cSWarner Losh * 760bb39ff4cSWarner Losh * A direct child of @p will be returned if it its phandle in the 761bb39ff4cSWarner Losh * OFW tree is @p node. Otherwise, NULL is returned. 762bb39ff4cSWarner Losh * 763bb39ff4cSWarner Losh * @param bus The bus to examine 764bb39ff4cSWarner Losh * @param node The phandle_t to look for. 765bb39ff4cSWarner Losh */ 766bb39ff4cSWarner Losh device_t 767bb39ff4cSWarner Losh ofw_bus_find_child_device_by_phandle(device_t bus, phandle_t node) 768bb39ff4cSWarner Losh { 769bb39ff4cSWarner Losh device_t *children, retval, child; 770bb39ff4cSWarner Losh int nkid, i; 771bb39ff4cSWarner Losh 772bb39ff4cSWarner Losh /* 773bb39ff4cSWarner Losh * Nothing can match the flag value for no node. 774bb39ff4cSWarner Losh */ 775bb39ff4cSWarner Losh if (node == -1) 776bb39ff4cSWarner Losh return (NULL); 777bb39ff4cSWarner Losh 778bb39ff4cSWarner Losh /* 779bb39ff4cSWarner Losh * Search the children for a match. We microoptimize 780bb39ff4cSWarner Losh * a bit by not using ofw_bus_get since we already know 781bb39ff4cSWarner Losh * the parent. We do not recurse. 782bb39ff4cSWarner Losh */ 783bb39ff4cSWarner Losh if (device_get_children(bus, &children, &nkid) != 0) 784bb39ff4cSWarner Losh return (NULL); 785bb39ff4cSWarner Losh retval = NULL; 786bb39ff4cSWarner Losh for (i = 0; i < nkid; i++) { 787bb39ff4cSWarner Losh child = children[i]; 788bb39ff4cSWarner Losh if (OFW_BUS_GET_NODE(bus, child) == node) { 789bb39ff4cSWarner Losh retval = child; 790bb39ff4cSWarner Losh break; 791bb39ff4cSWarner Losh } 792bb39ff4cSWarner Losh } 793bb39ff4cSWarner Losh free(children, M_TEMP); 794bb39ff4cSWarner Losh 795bb39ff4cSWarner Losh return (retval); 796bb39ff4cSWarner Losh } 7970b757c47SMichal Meloun 7980b757c47SMichal Meloun /* 7990b757c47SMichal Meloun * Parse property that contain list of xrefs and values 8000b757c47SMichal Meloun * (like standard "clocks" and "resets" properties) 8010b757c47SMichal Meloun * Input arguments: 8020b757c47SMichal Meloun * node - consumers device node 8030b757c47SMichal Meloun * list_name - name of parsed list - "clocks" 8040b757c47SMichal Meloun * cells_name - name of size property - "#clock-cells" 80591ef8da0SAdrian Chadd * idx - the index of the requested list entry, or, if -1, an indication 80691ef8da0SAdrian Chadd * to return the number of entries in the parsed list. 8070b757c47SMichal Meloun * Output arguments: 8080b757c47SMichal Meloun * producer - handle of producer 80991ef8da0SAdrian Chadd * ncells - number of cells in result or the number of items in the list when 81091ef8da0SAdrian Chadd * idx == -1. 8110b757c47SMichal Meloun * cells - array of decoded cells 8120b757c47SMichal Meloun */ 81391ef8da0SAdrian Chadd static int 81491ef8da0SAdrian Chadd ofw_bus_parse_xref_list_internal(phandle_t node, const char *list_name, 8150b757c47SMichal Meloun const char *cells_name, int idx, phandle_t *producer, int *ncells, 8160b757c47SMichal Meloun pcell_t **cells) 8170b757c47SMichal Meloun { 8180b757c47SMichal Meloun phandle_t pnode; 8190b757c47SMichal Meloun phandle_t *elems; 8200b757c47SMichal Meloun uint32_t pcells; 8210b757c47SMichal Meloun int rv, i, j, nelems, cnt; 8220b757c47SMichal Meloun 8230b757c47SMichal Meloun elems = NULL; 8240b757c47SMichal Meloun nelems = OF_getencprop_alloc(node, list_name, sizeof(*elems), 8250b757c47SMichal Meloun (void **)&elems); 8260b757c47SMichal Meloun if (nelems <= 0) 8270b757c47SMichal Meloun return (ENOENT); 82891ef8da0SAdrian Chadd rv = (idx == -1) ? 0 : ENOENT; 8290b757c47SMichal Meloun for (i = 0, cnt = 0; i < nelems; i += pcells, cnt++) { 8300b757c47SMichal Meloun pnode = elems[i++]; 8310b757c47SMichal Meloun if (OF_getencprop(OF_node_from_xref(pnode), 8320b757c47SMichal Meloun cells_name, &pcells, sizeof(pcells)) == -1) { 8330b757c47SMichal Meloun printf("Missing %s property\n", cells_name); 8340b757c47SMichal Meloun rv = ENOENT; 8350b757c47SMichal Meloun break; 8360b757c47SMichal Meloun } 8370b757c47SMichal Meloun 8380b757c47SMichal Meloun if ((i + pcells) > nelems) { 8390b757c47SMichal Meloun printf("Invalid %s property value <%d>\n", cells_name, 8400b757c47SMichal Meloun pcells); 8410b757c47SMichal Meloun rv = ERANGE; 8420b757c47SMichal Meloun break; 8430b757c47SMichal Meloun } 8440b757c47SMichal Meloun if (cnt == idx) { 8450b757c47SMichal Meloun *cells= malloc(pcells * sizeof(**cells), M_OFWPROP, 8460b757c47SMichal Meloun M_WAITOK); 8470b757c47SMichal Meloun *producer = pnode; 8480b757c47SMichal Meloun *ncells = pcells; 8490b757c47SMichal Meloun for (j = 0; j < pcells; j++) 8500b757c47SMichal Meloun (*cells)[j] = elems[i + j]; 8510b757c47SMichal Meloun rv = 0; 8520b757c47SMichal Meloun break; 8530b757c47SMichal Meloun } 8540b757c47SMichal Meloun } 8550b757c47SMichal Meloun if (elems != NULL) 8560b757c47SMichal Meloun free(elems, M_OFWPROP); 85791ef8da0SAdrian Chadd if (idx == -1 && rv == 0) 85891ef8da0SAdrian Chadd *ncells = cnt; 8590b757c47SMichal Meloun return (rv); 8600b757c47SMichal Meloun } 8610b757c47SMichal Meloun 8620b757c47SMichal Meloun /* 86391ef8da0SAdrian Chadd * Parse property that contain list of xrefs and values 86491ef8da0SAdrian Chadd * (like standard "clocks" and "resets" properties) 86591ef8da0SAdrian Chadd * Input arguments: 86691ef8da0SAdrian Chadd * node - consumers device node 86791ef8da0SAdrian Chadd * list_name - name of parsed list - "clocks" 86891ef8da0SAdrian Chadd * cells_name - name of size property - "#clock-cells" 86991ef8da0SAdrian Chadd * idx - the index of the requested list entry (>= 0) 87091ef8da0SAdrian Chadd * Output arguments: 87191ef8da0SAdrian Chadd * producer - handle of producer 87291ef8da0SAdrian Chadd * ncells - number of cells in result 87391ef8da0SAdrian Chadd * cells - array of decoded cells 87491ef8da0SAdrian Chadd */ 87591ef8da0SAdrian Chadd int 87691ef8da0SAdrian Chadd ofw_bus_parse_xref_list_alloc(phandle_t node, const char *list_name, 87791ef8da0SAdrian Chadd const char *cells_name, int idx, phandle_t *producer, int *ncells, 87891ef8da0SAdrian Chadd pcell_t **cells) 87991ef8da0SAdrian Chadd { 88091ef8da0SAdrian Chadd 88191ef8da0SAdrian Chadd KASSERT(idx >= 0, 88291ef8da0SAdrian Chadd ("ofw_bus_parse_xref_list_alloc: negative index supplied")); 88391ef8da0SAdrian Chadd 88491ef8da0SAdrian Chadd return (ofw_bus_parse_xref_list_internal(node, list_name, cells_name, 88591ef8da0SAdrian Chadd idx, producer, ncells, cells)); 88691ef8da0SAdrian Chadd } 88791ef8da0SAdrian Chadd 88891ef8da0SAdrian Chadd /* 88991ef8da0SAdrian Chadd * Parse property that contain list of xrefs and values 89091ef8da0SAdrian Chadd * (like standard "clocks" and "resets" properties) 89191ef8da0SAdrian Chadd * and determine the number of items in the list 89291ef8da0SAdrian Chadd * Input arguments: 89391ef8da0SAdrian Chadd * node - consumers device node 89491ef8da0SAdrian Chadd * list_name - name of parsed list - "clocks" 89591ef8da0SAdrian Chadd * cells_name - name of size property - "#clock-cells" 89691ef8da0SAdrian Chadd * Output arguments: 89791ef8da0SAdrian Chadd * count - number of items in list 89891ef8da0SAdrian Chadd */ 89991ef8da0SAdrian Chadd int 90091ef8da0SAdrian Chadd ofw_bus_parse_xref_list_get_length(phandle_t node, const char *list_name, 90191ef8da0SAdrian Chadd const char *cells_name, int *count) 90291ef8da0SAdrian Chadd { 90391ef8da0SAdrian Chadd 90491ef8da0SAdrian Chadd return (ofw_bus_parse_xref_list_internal(node, list_name, cells_name, 90591ef8da0SAdrian Chadd -1, NULL, count, NULL)); 90691ef8da0SAdrian Chadd } 90791ef8da0SAdrian Chadd 90891ef8da0SAdrian Chadd /* 9090b757c47SMichal Meloun * Find index of string in string list property (case sensitive). 9100b757c47SMichal Meloun */ 9110b757c47SMichal Meloun int 9120b757c47SMichal Meloun ofw_bus_find_string_index(phandle_t node, const char *list_name, 9130b757c47SMichal Meloun const char *name, int *idx) 9140b757c47SMichal Meloun { 9150b757c47SMichal Meloun char *elems; 9160b757c47SMichal Meloun int rv, i, cnt, nelems; 9170b757c47SMichal Meloun 9180b757c47SMichal Meloun elems = NULL; 9190b757c47SMichal Meloun nelems = OF_getprop_alloc(node, list_name, 1, (void **)&elems); 9200b757c47SMichal Meloun if (nelems <= 0) 9210b757c47SMichal Meloun return (ENOENT); 9220b757c47SMichal Meloun 9230b757c47SMichal Meloun rv = ENOENT; 9240b757c47SMichal Meloun for (i = 0, cnt = 0; i < nelems; cnt++) { 9250b757c47SMichal Meloun if (strcmp(elems + i, name) == 0) { 9260b757c47SMichal Meloun *idx = cnt; 9270b757c47SMichal Meloun rv = 0; 9280b757c47SMichal Meloun break; 9290b757c47SMichal Meloun } 9300b757c47SMichal Meloun i += strlen(elems + i) + 1; 9310b757c47SMichal Meloun } 9320b757c47SMichal Meloun 9330b757c47SMichal Meloun if (elems != NULL) 9340b757c47SMichal Meloun free(elems, M_OFWPROP); 9350b757c47SMichal Meloun return (rv); 9360b757c47SMichal Meloun } 9370b757c47SMichal Meloun 9380b757c47SMichal Meloun /* 9390b757c47SMichal Meloun * Create zero terminated array of strings from string list property. 9400b757c47SMichal Meloun */ 9410b757c47SMichal Meloun int 9420b757c47SMichal Meloun ofw_bus_string_list_to_array(phandle_t node, const char *list_name, 943086a6314SMichal Meloun const char ***out_array) 9440b757c47SMichal Meloun { 9450b757c47SMichal Meloun char *elems, *tptr; 946086a6314SMichal Meloun const char **array; 9470b757c47SMichal Meloun int i, cnt, nelems, len; 9480b757c47SMichal Meloun 9490b757c47SMichal Meloun elems = NULL; 9500b757c47SMichal Meloun nelems = OF_getprop_alloc(node, list_name, 1, (void **)&elems); 9510b757c47SMichal Meloun if (nelems <= 0) 9520b757c47SMichal Meloun return (nelems); 9530b757c47SMichal Meloun 9540b757c47SMichal Meloun /* Count number of strings. */ 9550b757c47SMichal Meloun for (i = 0, cnt = 0; i < nelems; cnt++) 9560b757c47SMichal Meloun i += strlen(elems + i) + 1; 9570b757c47SMichal Meloun 9580b757c47SMichal Meloun /* Allocate space for arrays and all strings. */ 959086a6314SMichal Meloun array = malloc((cnt + 1) * sizeof(char *) + nelems, M_OFWPROP, 9600b757c47SMichal Meloun M_WAITOK); 9610b757c47SMichal Meloun 9620b757c47SMichal Meloun /* Get address of first string. */ 963086a6314SMichal Meloun tptr = (char *)(array + cnt + 1); 9640b757c47SMichal Meloun 9650b757c47SMichal Meloun /* Copy strings. */ 9660b757c47SMichal Meloun memcpy(tptr, elems, nelems); 9670b757c47SMichal Meloun free(elems, M_OFWPROP); 9680b757c47SMichal Meloun 9690b757c47SMichal Meloun /* Fill string pointers. */ 9700b757c47SMichal Meloun for (i = 0, cnt = 0; i < nelems; cnt++) { 971086a6314SMichal Meloun len = strlen(tptr) + 1; 972086a6314SMichal Meloun array[cnt] = tptr; 9730b757c47SMichal Meloun i += len; 9740b757c47SMichal Meloun tptr += len; 9750b757c47SMichal Meloun } 9764d24901aSPedro F. Giffuni array[cnt] = NULL; 977086a6314SMichal Meloun *out_array = array; 9780b757c47SMichal Meloun 9790b757c47SMichal Meloun return (cnt); 9800b757c47SMichal Meloun } 981