sys/dev/ofw/ofw_bus_subr.c

   1 /*-
   2  * Copyright (c) 2001 - 2003 by Thomas Moestl <tmm@FreeBSD.org>.
   3  * Copyright (c) 2005 Marius Strobl <marius@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions, and the following disclaimer,
  11  *    without modification, immediately at the beginning of the file.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include "opt_platform.h"
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/bus.h>
  37 #include <sys/errno.h>
  38 #include <sys/libkern.h>
  39
  40 #include <machine/resource.h>
  41
  42 #include <dev/ofw/ofw_bus.h>
  43 #include <dev/ofw/ofw_bus_subr.h>
  44 #include <dev/ofw/openfirm.h>
  45
  46 #include "ofw_bus_if.h"
  47
  48 int
  49 ofw_bus_gen_setup_devinfo(struct ofw_bus_devinfo *obd, phandle_t node)
  50 {
  51
  52         if (obd == NULL)
  53                 return (ENOMEM);
  54         /* The 'name' property is considered mandatory. */
  55         if ((OF_getprop_alloc(node, "name", 1, (void **)&obd->obd_name)) == -1)
  56                 return (EINVAL);
  57         OF_getprop_alloc(node, "compatible", 1, (void **)&obd->obd_compat);
  58         OF_getprop_alloc(node, "device_type", 1, (void **)&obd->obd_type);
  59         OF_getprop_alloc(node, "model", 1, (void **)&obd->obd_model);
  60         OF_getprop_alloc(node, "status", 1, (void **)&obd->obd_status);
  61         obd->obd_node = node;
  62         return (0);
  63 }
  64
  65 void
  66 ofw_bus_gen_destroy_devinfo(struct ofw_bus_devinfo *obd)
  67 {
  68
  69         if (obd == NULL)
  70                 return;
  71         if (obd->obd_compat != NULL)
  72                 free(obd->obd_compat, M_OFWPROP);
  73         if (obd->obd_model != NULL)
  74                 free(obd->obd_model, M_OFWPROP);
  75         if (obd->obd_name != NULL)
  76                 free(obd->obd_name, M_OFWPROP);
  77         if (obd->obd_type != NULL)
  78                 free(obd->obd_type, M_OFWPROP);
  79         if (obd->obd_status != NULL)
  80                 free(obd->obd_status, M_OFWPROP);
  81 }
  82
  83 int
  84 ofw_bus_gen_child_pnpinfo_str(device_t cbdev, device_t child, char *buf,
  85     size_t buflen)
  86 {
  87
  88         if (ofw_bus_get_name(child) != NULL) {
  89                 strlcat(buf, "name=", buflen);
  90                 strlcat(buf, ofw_bus_get_name(child), buflen);
  91         }
  92
  93         if (ofw_bus_get_compat(child) != NULL) {
  94                 strlcat(buf, " compat=", buflen);
  95                 strlcat(buf, ofw_bus_get_compat(child), buflen);
  96         }
  97         return (0);
  98 };
  99
 100 const char *
 101 ofw_bus_gen_get_compat(device_t bus, device_t dev)
 102 {
 103         const struct ofw_bus_devinfo *obd;
 104
 105         obd = OFW_BUS_GET_DEVINFO(bus, dev);
 106         if (obd == NULL)
 107                 return (NULL);
 108         return (obd->obd_compat);
 109 }
 110
 111 const char *
 112 ofw_bus_gen_get_model(device_t bus, device_t dev)
 113 {
 114         const struct ofw_bus_devinfo *obd;
 115
 116         obd = OFW_BUS_GET_DEVINFO(bus, dev);
 117         if (obd == NULL)
 118                 return (NULL);
 119         return (obd->obd_model);
 120 }
 121
 122 const char *
 123 ofw_bus_gen_get_name(device_t bus, device_t dev)
 124 {
 125         const struct ofw_bus_devinfo *obd;
 126
 127         obd = OFW_BUS_GET_DEVINFO(bus, dev);
 128         if (obd == NULL)
 129                 return (NULL);
 130         return (obd->obd_name);
 131 }
 132
 133 phandle_t
 134 ofw_bus_gen_get_node(device_t bus, device_t dev)
 135 {
 136         const struct ofw_bus_devinfo *obd;
 137
 138         obd = OFW_BUS_GET_DEVINFO(bus, dev);
 139         if (obd == NULL)
 140                 return (0);
 141         return (obd->obd_node);
 142 }
 143
 144 const char *
 145 ofw_bus_gen_get_type(device_t bus, device_t dev)
 146 {
 147         const struct ofw_bus_devinfo *obd;
 148
 149         obd = OFW_BUS_GET_DEVINFO(bus, dev);
 150         if (obd == NULL)
 151                 return (NULL);
 152         return (obd->obd_type);
 153 }
 154
 155 const char *
 156 ofw_bus_get_status(device_t dev)
 157 {
 158         const struct ofw_bus_devinfo *obd;
 159
 160         obd = OFW_BUS_GET_DEVINFO(device_get_parent(dev), dev);
 161         if (obd == NULL)
 162                 return (NULL);
 163
 164         return (obd->obd_status);
 165 }
 166
 167 int
 168 ofw_bus_status_okay(device_t dev)
 169 {
 170         const char *status;
 171
 172         status = ofw_bus_get_status(dev);
 173         if (status == NULL || strcmp(status, "okay") == 0 ||
 174             strcmp(status, "ok") == 0)
 175                 return (1);
 176
 177         return (0);
 178 }
 179
 180 static int
 181 ofw_bus_node_is_compatible(const char *compat, int len, const char *onecompat)
 182 {
 183         int onelen, l, ret;
 184
 185         onelen = strlen(onecompat);
 186
 187         ret = 0;
 188         while (len > 0) {
 189                 if (strlen(compat) == onelen &&
 190                     strncasecmp(compat, onecompat, onelen) == 0) {
 191                         /* Found it. */
 192                         ret = 1;
 193                         break;
 194                 }
 195
 196                 /* Slide to the next sub-string. */
 197                 l = strlen(compat) + 1;
 198                 compat += l;
 199                 len -= l;
 200         }
 201
 202         return (ret);
 203 }
 204
 205 int
 206 ofw_bus_is_compatible(device_t dev, const char *onecompat)
 207 {
 208         phandle_t node;
 209         const char *compat;
 210         int len;
 211
 212         if ((compat = ofw_bus_get_compat(dev)) == NULL)
 213                 return (0);
 214
 215         if ((node = ofw_bus_get_node(dev)) == -1)
 216                 return (0);
 217
 218         /* Get total 'compatible' prop len */
 219         if ((len = OF_getproplen(node, "compatible")) <= 0)
 220                 return (0);
 221
 222         return (ofw_bus_node_is_compatible(compat, len, onecompat));
 223 }
 224
 225 int
 226 ofw_bus_is_compatible_strict(device_t dev, const char *compatible)
 227 {
 228         const char *compat;
 229         size_t len;
 230
 231         if ((compat = ofw_bus_get_compat(dev)) == NULL)
 232                 return (0);
 233
 234         len = strlen(compatible);
 235         if (strlen(compat) == len &&
 236             strncasecmp(compat, compatible, len) == 0)
 237                 return (1);
 238
 239         return (0);
 240 }
 241
 242 const struct ofw_compat_data *
 243 ofw_bus_search_compatible(device_t dev, const struct ofw_compat_data *compat)
 244 {
 245
 246         if (compat == NULL)
 247                 return NULL;
 248
 249         for (; compat->ocd_str != NULL; ++compat) {
 250                 if (ofw_bus_is_compatible(dev, compat->ocd_str))
 251                         break;
 252         }
 253
 254         return (compat);
 255 }
 256
 257 int
 258 ofw_bus_has_prop(device_t dev, const char *propname)
 259 {
 260         phandle_t node;
 261
 262         if ((node = ofw_bus_get_node(dev)) == -1)
 263                 return (0);
 264
 265         return (OF_hasprop(node, propname));
 266 }
 267
 268 void
 269 ofw_bus_setup_iinfo(phandle_t node, struct ofw_bus_iinfo *ii, int intrsz)
 270 {
 271         pcell_t addrc;
 272         int msksz;
 273
 274         if (OF_getencprop(node, "#address-cells", &addrc, sizeof(addrc)) == -1)
 275                 addrc = 2;
 276         ii->opi_addrc = addrc * sizeof(pcell_t);
 277
 278         ii->opi_imapsz = OF_getencprop_alloc(node, "interrupt-map", 1,
 279             (void **)&ii->opi_imap);
 280         if (ii->opi_imapsz > 0) {
 281                 msksz = OF_getencprop_alloc(node, "interrupt-map-mask", 1,
 282                     (void **)&ii->opi_imapmsk);
 283                 /*
 284                  * Failure to get the mask is ignored; a full mask is used
 285                  * then.  We barf on bad mask sizes, however.
 286                  */
 287                 if (msksz != -1 && msksz != ii->opi_addrc + intrsz)
 288                         panic("ofw_bus_setup_iinfo: bad interrupt-map-mask "
 289                             "property!");
 290         }
 291 }
 292
 293 int
 294 ofw_bus_lookup_imap(phandle_t node, struct ofw_bus_iinfo *ii, void *reg,
 295     int regsz, void *pintr, int pintrsz, void *mintr, int mintrsz,
 296     phandle_t *iparent)
 297 {
 298         uint8_t maskbuf[regsz + pintrsz];
 299         int rv;
 300
 301         if (ii->opi_imapsz <= 0)
 302                 return (0);
 303         KASSERT(regsz >= ii->opi_addrc,
 304             ("ofw_bus_lookup_imap: register size too small: %d < %d",
 305                 regsz, ii->opi_addrc));
 306         if (node != -1) {
 307                 rv = OF_getencprop(node, "reg", reg, regsz);
 308                 if (rv < regsz)
 309                         panic("ofw_bus_lookup_imap: cannot get reg property");
 310         }
 311         return (ofw_bus_search_intrmap(pintr, pintrsz, reg, ii->opi_addrc,
 312             ii->opi_imap, ii->opi_imapsz, ii->opi_imapmsk, maskbuf, mintr,
 313             mintrsz, iparent));
 314 }
 315
 316 /*
 317  * Map an interrupt using the firmware reg, interrupt-map and
 318  * interrupt-map-mask properties.
 319  * The interrupt property to be mapped must be of size intrsz, and pointed to
 320  * by intr.  The regs property of the node for which the mapping is done must
 321  * be passed as regs. This property is an array of register specifications;
 322  * the size of the address part of such a specification must be passed as
 323  * physsz.  Only the first element of the property is used.
 324  * imap and imapsz hold the interrupt mask and it's size.
 325  * imapmsk is a pointer to the interrupt-map-mask property, which must have
 326  * a size of physsz + intrsz; it may be NULL, in which case a full mask is
 327  * assumed.
 328  * maskbuf must point to a buffer of length physsz + intrsz.
 329  * The interrupt is returned in result, which must point to a buffer of length
 330  * rintrsz (which gives the expected size of the mapped interrupt).
 331  * Returns number of cells in the interrupt if a mapping was found, 0 otherwise.
 332  */
 333 int
 334 ofw_bus_search_intrmap(void *intr, int intrsz, void *regs, int physsz,
 335     void *imap, int imapsz, void *imapmsk, void *maskbuf, void *result,
 336     int rintrsz, phandle_t *iparent)
 337 {
 338         phandle_t parent;
 339         uint8_t *ref = maskbuf;
 340         uint8_t *uiintr = intr;
 341         uint8_t *uiregs = regs;
 342         uint8_t *uiimapmsk = imapmsk;
 343         uint8_t *mptr;
 344         pcell_t paddrsz;
 345         pcell_t pintrsz;
 346         int i, rsz, tsz;
 347
 348         rsz = -1;
 349         if (imapmsk != NULL) {
 350                 for (i = 0; i < physsz; i++)
 351                         ref[i] = uiregs[i] & uiimapmsk[i];
 352                 for (i = 0; i < intrsz; i++)
 353                         ref[physsz + i] = uiintr[i] & uiimapmsk[physsz + i];
 354         } else {
 355                 bcopy(regs, ref, physsz);
 356                 bcopy(intr, ref + physsz, intrsz);
 357         }
 358
 359         mptr = imap;
 360         i = imapsz;
 361         paddrsz = 0;
 362         while (i > 0) {
 363                 bcopy(mptr + physsz + intrsz, &parent, sizeof(parent));
 364 #ifndef OFW_IMAP_NO_IPARENT_ADDR_CELLS
 365                 /*
 366                  * Find if we need to read the parent address data.
 367                  * CHRP-derived OF bindings, including ePAPR-compliant FDTs,
 368                  * use this as an optional part of the specifier.
 369                  */
 370                 if (OF_getencprop(OF_node_from_xref(parent),
 371                     "#address-cells", &paddrsz, sizeof(paddrsz)) == -1)
 372                         paddrsz = 0;    /* default */
 373                 paddrsz *= sizeof(pcell_t);
 374 #endif
 375
 376                 if (OF_searchencprop(OF_node_from_xref(parent),
 377                     "#interrupt-cells", &pintrsz, sizeof(pintrsz)) == -1)
 378                         pintrsz = 1;    /* default */
 379                 pintrsz *= sizeof(pcell_t);
 380
 381                 /* Compute the map stride size. */
 382                 tsz = physsz + intrsz + sizeof(phandle_t) + paddrsz + pintrsz;
 383                 KASSERT(i >= tsz, ("ofw_bus_search_intrmap: truncated map"));
 384
 385                 if (bcmp(ref, mptr, physsz + intrsz) == 0) {
 386                         bcopy(mptr + physsz + intrsz + sizeof(parent) + paddrsz,
 387                             result, MIN(rintrsz, pintrsz));
 388
 389                         if (iparent != NULL)
 390                                 *iparent = parent;
 391                         return (pintrsz/sizeof(pcell_t));
 392                 }
 393                 mptr += tsz;
 394                 i -= tsz;
 395         }
 396         return (0);
 397 }
 398
 399 int
 400 ofw_bus_msimap(phandle_t node, uint16_t pci_rid, phandle_t *msi_parent,
 401     uint32_t *msi_rid)
 402 {
 403         pcell_t *map, mask, msi_base, rid_base, rid_length;
 404         ssize_t len;
 405         uint32_t masked_rid, rid;
 406         int err, i;
 407
 408         /* TODO: This should be OF_searchprop_alloc if we had it */
 409         len = OF_getencprop_alloc(node, "msi-map", sizeof(*map), (void **)&map);
 410         if (len < 0) {
 411                 if (msi_parent != NULL) {
 412                         *msi_parent = 0;
 413                         OF_getencprop(node, "msi-parent", msi_parent,
 414                             sizeof(*msi_parent));
 415                 }
 416                 if (msi_rid != NULL)
 417                         *msi_rid = pci_rid;
 418                 return (0);
 419         }
 420
 421         err = ENOENT;
 422         rid = 0;
 423         mask = 0xffffffff;
 424         OF_getencprop(node, "msi-map-mask", &mask, sizeof(mask));
 425
 426         masked_rid = pci_rid & mask;
 427         for (i = 0; i < len; i += 4) {
 428                 rid_base = map[i + 0];
 429                 rid_length = map[i + 3];
 430
 431                 if (masked_rid < rid_base ||
 432                     masked_rid >= (rid_base + rid_length))
 433                         continue;
 434
 435                 msi_base = map[i + 2];
 436
 437                 if (msi_parent != NULL)
 438                         *msi_parent = map[i + 1];
 439                 if (msi_rid != NULL)
 440                         *msi_rid = masked_rid - rid_base + msi_base;
 441                 err = 0;
 442                 break;
 443         }
 444
 445         free(map, M_OFWPROP);
 446
 447         return (err);
 448 }
 449
 450 int
 451 ofw_bus_reg_to_rl(device_t dev, phandle_t node, pcell_t acells, pcell_t scells,
 452     struct resource_list *rl)
 453 {
 454         uint64_t phys, size;
 455         ssize_t i, j, rid, nreg, ret;
 456         uint32_t *reg;
 457         char *name;
 458
 459         /*
 460          * This may be just redundant when having ofw_bus_devinfo
 461          * but makes this routine independent of it.
 462          */
 463         ret = OF_getprop_alloc(node, "name", sizeof(*name), (void **)&name);
 464         if (ret == -1)
 465                 name = NULL;
 466
 467         ret = OF_getencprop_alloc(node, "reg", sizeof(*reg), (void **)&reg);
 468         nreg = (ret == -1) ? 0 : ret;
 469
 470         if (nreg % (acells + scells) != 0) {
 471                 if (bootverbose)
 472                         device_printf(dev, "Malformed reg property on <%s>\n",
 473                             (name == NULL) ? "unknown" : name);
 474                 nreg = 0;
 475         }
 476
 477         for (i = 0, rid = 0; i < nreg; i += acells + scells, rid++) {
 478                 phys = size = 0;
 479                 for (j = 0; j < acells; j++) {
 480                         phys <<= 32;
 481                         phys |= reg[i + j];
 482                 }
 483                 for (j = 0; j < scells; j++) {
 484                         size <<= 32;
 485                         size |= reg[i + acells + j];
 486                 }
 487                 /* Skip the dummy reg property of glue devices like ssm(4). */
 488                 if (size != 0)
 489                         resource_list_add(rl, SYS_RES_MEMORY, rid,
 490                             phys, phys + size - 1, size);
 491         }
 492         free(name, M_OFWPROP);
 493         free(reg, M_OFWPROP);
 494
 495         return (0);
 496 }
 497
 498 /*
 499  * Get interrupt parent for given node.
 500  * Returns 0 if interrupt parent doesn't exist.
 501  */
 502 phandle_t
 503 ofw_bus_find_iparent(phandle_t node)
 504 {
 505         phandle_t iparent;
 506
 507         if (OF_searchencprop(node, "interrupt-parent", &iparent,
 508                     sizeof(iparent)) == -1) {
 509                 for (iparent = node; iparent != 0;
 510                     iparent = OF_parent(iparent)) {
 511                         if (OF_hasprop(iparent, "interrupt-controller"))
 512                                 break;
 513                 }
 514                 iparent = OF_xref_from_node(iparent);
 515         }
 516         return (iparent);
 517 }
 518
 519 #ifndef INTRNG
 520 int
 521 ofw_bus_intr_to_rl(device_t dev, phandle_t node,
 522     struct resource_list *rl, int *rlen)
 523 {
 524         phandle_t iparent;
 525         uint32_t icells, *intr;
 526         int err, i, irqnum, nintr, rid;
 527         boolean_t extended;
 528
 529         nintr = OF_getencprop_alloc(node, "interrupts",  sizeof(*intr),
 530             (void **)&intr);
 531         if (nintr > 0) {
 532                 iparent = ofw_bus_find_iparent(node);
 533                 if (iparent == 0) {
 534                         device_printf(dev, "No interrupt-parent found, "
 535                             "assuming direct parent\n");
 536                         iparent = OF_parent(node);
 537                         iparent = OF_xref_from_node(iparent);
 538                 }
 539                 if (OF_searchencprop(OF_node_from_xref(iparent),
 540                     "#interrupt-cells", &icells, sizeof(icells)) == -1) {
 541                         device_printf(dev, "Missing #interrupt-cells "
 542                             "property, assuming <1>\n");
 543                         icells = 1;
 544                 }
 545                 if (icells < 1 || icells > nintr) {
 546                         device_printf(dev, "Invalid #interrupt-cells property "
 547                             "value <%d>, assuming <1>\n", icells);
 548                         icells = 1;
 549                 }
 550                 extended = false;
 551         } else {
 552                 nintr = OF_getencprop_alloc(node, "interrupts-extended",
 553                     sizeof(*intr), (void **)&intr);
 554                 if (nintr <= 0)
 555                         return (0);
 556                 extended = true;
 557         }
 558         err = 0;
 559         rid = 0;
 560         for (i = 0; i < nintr; i += icells) {
 561                 if (extended) {
 562                         iparent = intr[i++];
 563                         if (OF_searchencprop(OF_node_from_xref(iparent),
 564                             "#interrupt-cells", &icells, sizeof(icells)) == -1) {
 565                                 device_printf(dev, "Missing #interrupt-cells "
 566                                     "property\n");
 567                                 err = ENOENT;
 568                                 break;
 569                         }
 570                         if (icells < 1 || (i + icells) > nintr) {
 571                                 device_printf(dev, "Invalid #interrupt-cells "
 572                                     "property value <%d>\n", icells);
 573                                 err = ERANGE;
 574                                 break;
 575                         }
 576                 }
 577                 irqnum = ofw_bus_map_intr(dev, iparent, icells, &intr[i]);
 578                 resource_list_add(rl, SYS_RES_IRQ, rid++, irqnum, irqnum, 1);
 579         }
 580         if (rlen != NULL)
 581                 *rlen = rid;
 582         free(intr, M_OFWPROP);
 583         return (err);
 584 }
 585 #endif
 586
 587 int
 588 ofw_bus_intr_by_rid(device_t dev, phandle_t node, int wanted_rid,
 589     phandle_t *producer, int *ncells, pcell_t **cells)
 590 {
 591         phandle_t iparent;
 592         uint32_t icells, *intr;
 593         int err, i, nintr, rid;
 594         boolean_t extended;
 595
 596         nintr = OF_getencprop_alloc(node, "interrupts",  sizeof(*intr),
 597             (void **)&intr);
 598         if (nintr > 0) {
 599                 iparent = ofw_bus_find_iparent(node);
 600                 if (iparent == 0) {
 601                         device_printf(dev, "No interrupt-parent found, "
 602                             "assuming direct parent\n");
 603                         iparent = OF_parent(node);
 604                         iparent = OF_xref_from_node(iparent);
 605                 }
 606                 if (OF_searchencprop(OF_node_from_xref(iparent),
 607                     "#interrupt-cells", &icells, sizeof(icells)) == -1) {
 608                         device_printf(dev, "Missing #interrupt-cells "
 609                             "property, assuming <1>\n");
 610                         icells = 1;
 611                 }
 612                 if (icells < 1 || icells > nintr) {
 613                         device_printf(dev, "Invalid #interrupt-cells property "
 614                             "value <%d>, assuming <1>\n", icells);
 615                         icells = 1;
 616                 }
 617                 extended = false;
 618         } else {
 619                 nintr = OF_getencprop_alloc(node, "interrupts-extended",
 620                     sizeof(*intr), (void **)&intr);
 621                 if (nintr <= 0)
 622                         return (ESRCH);
 623                 extended = true;
 624         }
 625         err = ESRCH;
 626         rid = 0;
 627         for (i = 0; i < nintr; i += icells, rid++) {
 628                 if (extended) {
 629                         iparent = intr[i++];
 630                         if (OF_searchencprop(OF_node_from_xref(iparent),
 631                             "#interrupt-cells", &icells, sizeof(icells)) == -1) {
 632                                 device_printf(dev, "Missing #interrupt-cells "
 633                                     "property\n");
 634                                 err = ENOENT;
 635                                 break;
 636                         }
 637                         if (icells < 1 || (i + icells) > nintr) {
 638                                 device_printf(dev, "Invalid #interrupt-cells "
 639                                     "property value <%d>\n", icells);
 640                                 err = ERANGE;
 641                                 break;
 642                         }
 643                 }
 644                 if (rid == wanted_rid) {
 645                         *cells = malloc(icells * sizeof(**cells), M_OFWPROP,
 646                             M_WAITOK);
 647                         *producer = iparent;
 648                         *ncells= icells;
 649                         memcpy(*cells, intr + i, icells * sizeof(**cells));
 650                         err = 0;
 651                         break;
 652                 }
 653         }
 654         free(intr, M_OFWPROP);
 655         return (err);
 656 }
 657
 658 phandle_t
 659 ofw_bus_find_child(phandle_t start, const char *child_name)
 660 {
 661         char *name;
 662         int ret;
 663         phandle_t child;
 664
 665         for (child = OF_child(start); child != 0; child = OF_peer(child)) {
 666                 ret = OF_getprop_alloc(child, "name", sizeof(*name), (void **)&name);
 667                 if (ret == -1)
 668                         continue;
 669                 if (strcmp(name, child_name) == 0) {
 670                         free(name, M_OFWPROP);
 671                         return (child);
 672                 }
 673
 674                 free(name, M_OFWPROP);
 675         }
 676
 677         return (0);
 678 }
 679
 680 phandle_t
 681 ofw_bus_find_compatible(phandle_t node, const char *onecompat)
 682 {
 683         phandle_t child, ret;
 684         void *compat;
 685         int len;
 686
 687         /*
 688          * Traverse all children of 'start' node, and find first with
 689          * matching 'compatible' property.
 690          */
 691         for (child = OF_child(node); child != 0; child = OF_peer(child)) {
 692                 len = OF_getprop_alloc(child, "compatible", 1, &compat);
 693                 if (len >= 0) {
 694                         ret = ofw_bus_node_is_compatible(compat, len,
 695                             onecompat);
 696                         free(compat, M_OFWPROP);
 697                         if (ret != 0)
 698                                 return (child);
 699                 }
 700
 701                 ret = ofw_bus_find_compatible(child, onecompat);
 702                 if (ret != 0)
 703                         return (ret);
 704         }
 705         return (0);
 706 }
 707
 708 /**
 709  * @brief Return child of bus whose phandle is node
 710  *
 711  * A direct child of @p will be returned if it its phandle in the
 712  * OFW tree is @p node. Otherwise, NULL is returned.
 713  *
 714  * @param bus           The bus to examine
 715  * @param node          The phandle_t to look for.
 716  */
 717 device_t
 718 ofw_bus_find_child_device_by_phandle(device_t bus, phandle_t node)
 719 {
 720         device_t *children, retval, child;
 721         int nkid, i;
 722
 723         /*
 724          * Nothing can match the flag value for no node.
 725          */
 726         if (node == -1)
 727                 return (NULL);
 728
 729         /*
 730          * Search the children for a match. We microoptimize
 731          * a bit by not using ofw_bus_get since we already know
 732          * the parent. We do not recurse.
 733          */
 734         if (device_get_children(bus, &children, &nkid) != 0)
 735                 return (NULL);
 736         retval = NULL;
 737         for (i = 0; i < nkid; i++) {
 738                 child = children[i];
 739                 if (OFW_BUS_GET_NODE(bus, child) == node) {
 740                         retval = child;
 741                         break;
 742                 }
 743         }
 744         free(children, M_TEMP);
 745
 746         return (retval);
 747 }
 748
 749 /*
 750  * Parse property that contain list of xrefs and values
 751  * (like standard "clocks" and "resets" properties)
 752  * Input arguments:
 753  *  node - consumers device node
 754  *  list_name  - name of parsed list - "clocks"
 755  *  cells_name - name of size property - "#clock-cells"
 756  *  idx - the index of the requested list entry, or, if -1, an indication
 757  *        to return the number of entries in the parsed list.
 758  * Output arguments:
 759  *  producer - handle of producer
 760  *  ncells   - number of cells in result or the number of items in the list when
 761  *             idx == -1.
 762  *  cells    - array of decoded cells
 763  */
 764 static int
 765 ofw_bus_parse_xref_list_internal(phandle_t node, const char *list_name,
 766     const char *cells_name, int idx, phandle_t *producer, int *ncells,
 767     pcell_t **cells)
 768 {
 769         phandle_t pnode;
 770         phandle_t *elems;
 771         uint32_t  pcells;
 772         int rv, i, j, nelems, cnt;
 773
 774         elems = NULL;
 775         nelems = OF_getencprop_alloc(node, list_name,  sizeof(*elems),
 776             (void **)&elems);
 777         if (nelems <= 0)
 778                 return (ENOENT);
 779         rv = (idx == -1) ? 0 : ENOENT;
 780         for (i = 0, cnt = 0; i < nelems; i += pcells, cnt++) {
 781                 pnode = elems[i++];
 782                 if (OF_getencprop(OF_node_from_xref(pnode),
 783                     cells_name, &pcells, sizeof(pcells)) == -1) {
 784                         printf("Missing %s property\n", cells_name);
 785                         rv = ENOENT;
 786                         break;
 787                 }
 788
 789                 if ((i + pcells) > nelems) {
 790                         printf("Invalid %s property value <%d>\n", cells_name,
 791                             pcells);
 792                         rv = ERANGE;
 793                         break;
 794                 }
 795                 if (cnt == idx) {
 796                         *cells= malloc(pcells * sizeof(**cells), M_OFWPROP,
 797                             M_WAITOK);
 798                         *producer = pnode;
 799                         *ncells = pcells;
 800                         for (j = 0; j < pcells; j++)
 801                                 (*cells)[j] = elems[i + j];
 802                         rv = 0;
 803                         break;
 804                 }
 805         }
 806         if (elems != NULL)
 807                 free(elems, M_OFWPROP);
 808         if (idx == -1 && rv == 0)
 809                 *ncells = cnt;
 810         return (rv);
 811 }
 812
 813 /*
 814  * Parse property that contain list of xrefs and values
 815  * (like standard "clocks" and "resets" properties)
 816  * Input arguments:
 817  *  node - consumers device node
 818  *  list_name  - name of parsed list - "clocks"
 819  *  cells_name - name of size property - "#clock-cells"
 820  *  idx - the index of the requested list entry (>= 0)
 821  * Output arguments:
 822  *  producer - handle of producer
 823  *  ncells   - number of cells in result
 824  *  cells    - array of decoded cells
 825  */
 826 int
 827 ofw_bus_parse_xref_list_alloc(phandle_t node, const char *list_name,
 828     const char *cells_name, int idx, phandle_t *producer, int *ncells,
 829     pcell_t **cells)
 830 {
 831
 832         KASSERT(idx >= 0,
 833             ("ofw_bus_parse_xref_list_alloc: negative index supplied"));
 834
 835         return (ofw_bus_parse_xref_list_internal(node, list_name, cells_name,
 836                     idx, producer, ncells, cells));
 837 }
 838
 839 /*
 840  * Parse property that contain list of xrefs and values
 841  * (like standard "clocks" and "resets" properties)
 842  * and determine the number of items in the list
 843  * Input arguments:
 844  *  node - consumers device node
 845  *  list_name  - name of parsed list - "clocks"
 846  *  cells_name - name of size property - "#clock-cells"
 847  * Output arguments:
 848  *  count - number of items in list
 849  */
 850 int
 851 ofw_bus_parse_xref_list_get_length(phandle_t node, const char *list_name,
 852     const char *cells_name, int *count)
 853 {
 854
 855         return (ofw_bus_parse_xref_list_internal(node, list_name, cells_name,
 856                     -1, NULL, count, NULL));
 857 }
 858
 859 /*
 860  * Find index of string in string list property (case sensitive).
 861  */
 862 int
 863 ofw_bus_find_string_index(phandle_t node, const char *list_name,
 864     const char *name, int *idx)
 865 {
 866         char *elems;
 867         int rv, i, cnt, nelems;
 868
 869         elems = NULL;
 870         nelems = OF_getprop_alloc(node, list_name, 1, (void **)&elems);
 871         if (nelems <= 0)
 872                 return (ENOENT);
 873
 874         rv = ENOENT;
 875         for (i = 0, cnt = 0; i < nelems; cnt++) {
 876                 if (strcmp(elems + i, name) == 0) {
 877                         *idx = cnt;
 878                         rv = 0;
 879                         break;
 880                 }
 881                 i += strlen(elems + i) + 1;
 882         }
 883
 884         if (elems != NULL)
 885                 free(elems, M_OFWPROP);
 886         return (rv);
 887 }
 888
 889 /*
 890  * Create zero terminated array of strings from string list property.
 891  */
 892 int
 893 ofw_bus_string_list_to_array(phandle_t node, const char *list_name,
 894    const char ***out_array)
 895 {
 896         char *elems, *tptr;
 897         const char **array;
 898         int i, cnt, nelems, len;
 899
 900         elems = NULL;
 901         nelems = OF_getprop_alloc(node, list_name, 1, (void **)&elems);
 902         if (nelems <= 0)
 903                 return (nelems);
 904
 905         /* Count number of strings. */
 906         for (i = 0, cnt = 0; i < nelems; cnt++)
 907                 i += strlen(elems + i) + 1;
 908
 909         /* Allocate space for arrays and all strings. */
 910         array = malloc((cnt + 1) * sizeof(char *) + nelems, M_OFWPROP,
 911             M_WAITOK);
 912
 913         /* Get address of first string. */
 914         tptr = (char *)(array + cnt + 1);
 915
 916         /* Copy strings. */
 917         memcpy(tptr, elems, nelems);
 918         free(elems, M_OFWPROP);
 919
 920         /* Fill string pointers. */
 921         for (i = 0, cnt = 0; i < nelems; cnt++) {
 922                 len = strlen(tptr) + 1;
 923                 array[cnt] = tptr;
 924                 i += len;
 925                 tptr += len;
 926         }
 927         array[cnt] = 0;
 928         *out_array = array;
 929
 930         return (cnt);
 931 }