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                 return (1);
 175
 176         return (0);
 177 }
 178
 179 int
 180 ofw_bus_is_compatible(device_t dev, const char *onecompat)
 181 {
 182         phandle_t node;
 183         const char *compat;
 184         int len, onelen, l;
 185
 186         if ((compat = ofw_bus_get_compat(dev)) == NULL)
 187                 return (0);
 188
 189         if ((node = ofw_bus_get_node(dev)) == -1)
 190                 return (0);
 191
 192         /* Get total 'compatible' prop len */
 193         if ((len = OF_getproplen(node, "compatible")) <= 0)
 194                 return (0);
 195
 196         onelen = strlen(onecompat);
 197
 198         while (len > 0) {
 199                 if (strlen(compat) == onelen &&
 200                     strncasecmp(compat, onecompat, onelen) == 0)
 201                         /* Found it. */
 202                         return (1);
 203
 204                 /* Slide to the next sub-string. */
 205                 l = strlen(compat) + 1;
 206                 compat += l;
 207                 len -= l;
 208         }
 209         return (0);
 210 }
 211
 212 int
 213 ofw_bus_is_compatible_strict(device_t dev, const char *compatible)
 214 {
 215         const char *compat;
 216         size_t len;
 217
 218         if ((compat = ofw_bus_get_compat(dev)) == NULL)
 219                 return (0);
 220
 221         len = strlen(compatible);
 222         if (strlen(compat) == len &&
 223             strncasecmp(compat, compatible, len) == 0)
 224                 return (1);
 225
 226         return (0);
 227 }
 228
 229 const struct ofw_compat_data *
 230 ofw_bus_search_compatible(device_t dev, const struct ofw_compat_data *compat)
 231 {
 232
 233         if (compat == NULL)
 234                 return NULL;
 235
 236         for (; compat->ocd_str != NULL; ++compat) {
 237                 if (ofw_bus_is_compatible(dev, compat->ocd_str))
 238                         break;
 239         }
 240
 241         return (compat);
 242 }
 243
 244 int
 245 ofw_bus_has_prop(device_t dev, const char *propname)
 246 {
 247         phandle_t node;
 248
 249         if ((node = ofw_bus_get_node(dev)) == -1)
 250                 return (0);
 251
 252         return (OF_hasprop(node, propname));
 253 }
 254
 255 void
 256 ofw_bus_setup_iinfo(phandle_t node, struct ofw_bus_iinfo *ii, int intrsz)
 257 {
 258         pcell_t addrc;
 259         int msksz;
 260
 261         if (OF_getencprop(node, "#address-cells", &addrc, sizeof(addrc)) == -1)
 262                 addrc = 2;
 263         ii->opi_addrc = addrc * sizeof(pcell_t);
 264
 265         ii->opi_imapsz = OF_getencprop_alloc(node, "interrupt-map", 1,
 266             (void **)&ii->opi_imap);
 267         if (ii->opi_imapsz > 0) {
 268                 msksz = OF_getencprop_alloc(node, "interrupt-map-mask", 1,
 269                     (void **)&ii->opi_imapmsk);
 270                 /*
 271                  * Failure to get the mask is ignored; a full mask is used
 272                  * then.  We barf on bad mask sizes, however.
 273                  */
 274                 if (msksz != -1 && msksz != ii->opi_addrc + intrsz)
 275                         panic("ofw_bus_setup_iinfo: bad interrupt-map-mask "
 276                             "property!");
 277         }
 278 }
 279
 280 int
 281 ofw_bus_lookup_imap(phandle_t node, struct ofw_bus_iinfo *ii, void *reg,
 282     int regsz, void *pintr, int pintrsz, void *mintr, int mintrsz,
 283     phandle_t *iparent)
 284 {
 285         uint8_t maskbuf[regsz + pintrsz];
 286         int rv;
 287
 288         if (ii->opi_imapsz <= 0)
 289                 return (0);
 290         KASSERT(regsz >= ii->opi_addrc,
 291             ("ofw_bus_lookup_imap: register size too small: %d < %d",
 292                 regsz, ii->opi_addrc));
 293         if (node != -1) {
 294                 rv = OF_getencprop(node, "reg", reg, regsz);
 295                 if (rv < regsz)
 296                         panic("ofw_bus_lookup_imap: cannot get reg property");
 297         }
 298         return (ofw_bus_search_intrmap(pintr, pintrsz, reg, ii->opi_addrc,
 299             ii->opi_imap, ii->opi_imapsz, ii->opi_imapmsk, maskbuf, mintr,
 300             mintrsz, iparent));
 301 }
 302
 303 /*
 304  * Map an interrupt using the firmware reg, interrupt-map and
 305  * interrupt-map-mask properties.
 306  * The interrupt property to be mapped must be of size intrsz, and pointed to
 307  * by intr.  The regs property of the node for which the mapping is done must
 308  * be passed as regs. This property is an array of register specifications;
 309  * the size of the address part of such a specification must be passed as
 310  * physsz.  Only the first element of the property is used.
 311  * imap and imapsz hold the interrupt mask and it's size.
 312  * imapmsk is a pointer to the interrupt-map-mask property, which must have
 313  * a size of physsz + intrsz; it may be NULL, in which case a full mask is
 314  * assumed.
 315  * maskbuf must point to a buffer of length physsz + intrsz.
 316  * The interrupt is returned in result, which must point to a buffer of length
 317  * rintrsz (which gives the expected size of the mapped interrupt).
 318  * Returns number of cells in the interrupt if a mapping was found, 0 otherwise.
 319  */
 320 int
 321 ofw_bus_search_intrmap(void *intr, int intrsz, void *regs, int physsz,
 322     void *imap, int imapsz, void *imapmsk, void *maskbuf, void *result,
 323     int rintrsz, phandle_t *iparent)
 324 {
 325         phandle_t parent;
 326         uint8_t *ref = maskbuf;
 327         uint8_t *uiintr = intr;
 328         uint8_t *uiregs = regs;
 329         uint8_t *uiimapmsk = imapmsk;
 330         uint8_t *mptr;
 331         pcell_t pintrsz;
 332         int i, rsz, tsz;
 333
 334         rsz = -1;
 335         if (imapmsk != NULL) {
 336                 for (i = 0; i < physsz; i++)
 337                         ref[i] = uiregs[i] & uiimapmsk[i];
 338                 for (i = 0; i < intrsz; i++)
 339                         ref[physsz + i] = uiintr[i] & uiimapmsk[physsz + i];
 340         } else {
 341                 bcopy(regs, ref, physsz);
 342                 bcopy(intr, ref + physsz, intrsz);
 343         }
 344
 345         mptr = imap;
 346         i = imapsz;
 347         while (i > 0) {
 348                 bcopy(mptr + physsz + intrsz, &parent, sizeof(parent));
 349                 if (OF_searchencprop(OF_node_from_xref(parent),
 350                     "#interrupt-cells", &pintrsz, sizeof(pintrsz)) == -1)
 351                         pintrsz = 1;    /* default */
 352                 pintrsz *= sizeof(pcell_t);
 353
 354                 /* Compute the map stride size. */
 355                 tsz = physsz + intrsz + sizeof(phandle_t) + pintrsz;
 356                 KASSERT(i >= tsz, ("ofw_bus_search_intrmap: truncated map"));
 357
 358                 if (bcmp(ref, mptr, physsz + intrsz) == 0) {
 359                         bcopy(mptr + physsz + intrsz + sizeof(parent),
 360                             result, MIN(rintrsz, pintrsz));
 361
 362                         if (iparent != NULL)
 363                                 *iparent = parent;
 364                         return (pintrsz/sizeof(pcell_t));
 365                 }
 366                 mptr += tsz;
 367                 i -= tsz;
 368         }
 369         return (0);
 370 }
 371
 372 int
 373 ofw_bus_reg_to_rl(device_t dev, phandle_t node, pcell_t acells, pcell_t scells,
 374     struct resource_list *rl)
 375 {
 376         uint64_t phys, size;
 377         ssize_t i, j, rid, nreg, ret;
 378         uint32_t *reg;
 379         char *name;
 380
 381         /*
 382          * This may be just redundant when having ofw_bus_devinfo
 383          * but makes this routine independent of it.
 384          */
 385         ret = OF_getencprop_alloc(node, "name", sizeof(*name), (void **)&name);
 386         if (ret == -1)
 387                 name = NULL;
 388
 389         ret = OF_getencprop_alloc(node, "reg", sizeof(*reg), (void **)&reg);
 390         nreg = (ret == -1) ? 0 : ret;
 391
 392         if (nreg % (acells + scells) != 0) {
 393                 if (bootverbose)
 394                         device_printf(dev, "Malformed reg property on <%s>\n",
 395                             (name == NULL) ? "unknown" : name);
 396                 nreg = 0;
 397         }
 398
 399         for (i = 0, rid = 0; i < nreg; i += acells + scells, rid++) {
 400                 phys = size = 0;
 401                 for (j = 0; j < acells; j++) {
 402                         phys <<= 32;
 403                         phys |= reg[i + j];
 404                 }
 405                 for (j = 0; j < scells; j++) {
 406                         size <<= 32;
 407                         size |= reg[i + acells + j];
 408                 }
 409                 /* Skip the dummy reg property of glue devices like ssm(4). */
 410                 if (size != 0)
 411                         resource_list_add(rl, SYS_RES_MEMORY, rid,
 412                             phys, phys + size - 1, size);
 413         }
 414         free(name, M_OFWPROP);
 415         free(reg, M_OFWPROP);
 416
 417         return (0);
 418 }
 419
 420 int
 421 ofw_bus_intr_to_rl(device_t dev, phandle_t node, struct resource_list *rl)
 422 {
 423         phandle_t iparent;
 424         uint32_t icells, *intr;
 425         int err, i, irqnum, nintr, rid;
 426         boolean_t extended;
 427
 428         nintr = OF_getencprop_alloc(node, "interrupts",  sizeof(*intr),
 429             (void **)&intr);
 430         if (nintr > 0) {
 431                 if (OF_searchencprop(node, "interrupt-parent", &iparent,
 432                     sizeof(iparent)) == -1) {
 433                         device_printf(dev, "No interrupt-parent found, "
 434                             "assuming direct parent\n");
 435                         iparent = OF_parent(node);
 436                 }
 437                 if (OF_searchencprop(OF_node_from_xref(iparent),
 438                     "#interrupt-cells", &icells, sizeof(icells)) == -1) {
 439                         device_printf(dev, "Missing #interrupt-cells "
 440                             "property, assuming <1>\n");
 441                         icells = 1;
 442                 }
 443                 if (icells < 1 || icells > nintr) {
 444                         device_printf(dev, "Invalid #interrupt-cells property "
 445                             "value <%d>, assuming <1>\n", icells);
 446                         icells = 1;
 447                 }
 448                 extended = false;
 449         } else {
 450                 nintr = OF_getencprop_alloc(node, "interrupts-extended",
 451                     sizeof(*intr), (void **)&intr);
 452                 if (nintr <= 0)
 453                         return (0);
 454                 extended = true;
 455         }
 456         err = 0;
 457         rid = 0;
 458         for (i = 0; i < nintr; i += icells) {
 459                 if (extended) {
 460                         iparent = intr[i++];
 461                         if (OF_searchencprop(OF_node_from_xref(iparent),
 462                             "#interrupt-cells", &icells, sizeof(icells)) == -1) {
 463                                 device_printf(dev, "Missing #interrupt-cells "
 464                                     "property\n");
 465                                 err = ENOENT;
 466                                 break;
 467                         }
 468                         if (icells < 1 || (i + icells) > nintr) {
 469                                 device_printf(dev, "Invalid #interrupt-cells "
 470                                     "property value <%d>\n", icells);
 471                                 err = ERANGE;
 472                                 break;
 473                         }
 474                 }
 475                 irqnum = ofw_bus_map_intr(dev, iparent, icells, &intr[i]);
 476                 resource_list_add(rl, SYS_RES_IRQ, rid++, irqnum, irqnum, 1);
 477         }
 478         free(intr, M_OFWPROP);
 479         return (err);
 480 }