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 **)®); 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