sys/dev/bhnd/bhndb/bhndb.c

   1 /*-
   2  * Copyright (c) 2015 Landon Fuller <landon@landonf.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  13  *    redistribution must be conditioned upon including a substantially
  14  *    similar Disclaimer requirement for further binary redistribution.
  15  *
  16  * NO WARRANTY
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  20  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  22  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  27  * THE POSSIBILITY OF SUCH DAMAGES.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 /*
  34  * Abstract BHND Bridge Device Driver
  35  *
  36  * Provides generic support for bridging from a parent bus (such as PCI) to
  37  * a BHND-compatible bus (e.g. bcma or siba).
  38  */
  39
  40 #include <sys/param.h>
  41 #include <sys/kernel.h>
  42 #include <sys/bus.h>
  43 #include <sys/module.h>
  44 #include <sys/systm.h>
  45
  46 #include <machine/bus.h>
  47 #include <sys/rman.h>
  48 #include <machine/resource.h>
  49
  50 #include <dev/bhnd/bhndvar.h>
  51 #include <dev/bhnd/bhndreg.h>
  52
  53 #include <dev/bhnd/bhnd_erom.h>
  54
  55 #include <dev/bhnd/cores/chipc/chipcreg.h>
  56 #include <dev/bhnd/nvram/bhnd_nvram.h>
  57
  58 #include "bhnd_chipc_if.h"
  59 #include "bhnd_nvram_if.h"
  60
  61 #include "bhndbvar.h"
  62 #include "bhndb_bus_if.h"
  63 #include "bhndb_hwdata.h"
  64 #include "bhndb_private.h"
  65
  66 /* Debugging flags */
  67 static u_long bhndb_debug = 0;
  68 TUNABLE_ULONG("hw.bhndb.debug", &bhndb_debug);
  69
  70 enum {
  71         BHNDB_DEBUG_PRIO = 1 << 0,
  72 };
  73
  74 #define BHNDB_DEBUG(_type)      (BHNDB_DEBUG_ ## _type & bhndb_debug)
  75
  76 static int                       bhndb_find_hostb_core(struct bhndb_softc *sc,
  77                                      bhnd_erom_t *erom,
  78                                      struct bhnd_core_info *core);
  79
  80 static bhnd_erom_class_t        *bhndb_probe_erom_class(struct bhndb_softc *sc,
  81                                     struct bhnd_chipid *cid);
  82
  83 static int                       bhndb_init_full_config(struct bhndb_softc *sc,
  84                                      bhnd_erom_class_t *eromcls);
  85
  86 static struct bhnd_core_info    *bhndb_get_bridge_core(struct bhndb_softc *sc);
  87
  88 static bool                      bhndb_hw_matches(struct bhndb_softc *sc,
  89                                      struct bhnd_core_info *cores, u_int ncores,
  90                                      const struct bhndb_hw *hw);
  91
  92 static int                       bhndb_init_region_cfg(struct bhndb_softc *sc,
  93                                      bhnd_erom_t *erom,
  94                                      struct bhndb_resources *r,
  95                                      struct bhnd_core_info *cores, u_int ncores,
  96                                      const struct bhndb_hw_priority *table);
  97
  98 static int                       bhndb_find_hwspec(struct bhndb_softc *sc,
  99                                      struct bhnd_core_info *cores, u_int ncores,
 100                                      const struct bhndb_hw **hw);
 101
 102 bhndb_addrspace                  bhndb_get_addrspace(struct bhndb_softc *sc,
 103                                      device_t child);
 104
 105 static struct rman              *bhndb_get_rman(struct bhndb_softc *sc,
 106                                      device_t child, int type);
 107
 108 static int                       bhndb_init_child_resource(struct resource *r,
 109                                      struct resource *parent,
 110                                      bhnd_size_t offset,
 111                                      bhnd_size_t size);
 112
 113 static int                       bhndb_activate_static_region(
 114                                      struct bhndb_softc *sc,
 115                                      struct bhndb_region *region,
 116                                      device_t child, int type, int rid,
 117                                      struct resource *r);
 118
 119 static int                       bhndb_try_activate_resource(
 120                                      struct bhndb_softc *sc, device_t child,
 121                                      int type, int rid, struct resource *r,
 122                                      bool *indirect);
 123
 124 static inline struct bhndb_dw_alloc *bhndb_io_resource(struct bhndb_softc *sc,
 125                                         bus_addr_t addr, bus_size_t size,
 126                                         bus_size_t *offset);
 127
 128
 129 /**
 130  * Default bhndb(4) implementation of DEVICE_PROBE().
 131  *
 132  * This function provides the default bhndb implementation of DEVICE_PROBE(),
 133  * and is compatible with bhndb(4) bridges attached via bhndb_attach_bridge().
 134  */
 135 int
 136 bhndb_generic_probe(device_t dev)
 137 {
 138         return (BUS_PROBE_NOWILDCARD);
 139 }
 140
 141 static void
 142 bhndb_probe_nomatch(device_t dev, device_t child)
 143 {
 144         const char *name;
 145
 146         name = device_get_name(child);
 147         if (name == NULL)
 148                 name = "unknown device";
 149
 150         device_printf(dev, "<%s> (no driver attached)\n", name);
 151 }
 152
 153 static int
 154 bhndb_print_child(device_t dev, device_t child)
 155 {
 156         struct bhndb_softc      *sc;
 157         struct resource_list    *rl;
 158         int                      retval = 0;
 159
 160         sc = device_get_softc(dev);
 161
 162         retval += bus_print_child_header(dev, child);
 163
 164         rl = BUS_GET_RESOURCE_LIST(dev, child);
 165         if (rl != NULL) {
 166                 retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY,
 167                     "%#jx");
 168                 retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ,
 169                     "%jd");
 170         }
 171
 172         retval += bus_print_child_domain(dev, child);
 173         retval += bus_print_child_footer(dev, child);
 174
 175         return (retval);
 176 }
 177
 178 static int
 179 bhndb_child_pnpinfo_str(device_t bus, device_t child, char *buf,
 180     size_t buflen)
 181 {
 182         *buf = '\0';
 183         return (0);
 184 }
 185
 186 static int
 187 bhndb_child_location_str(device_t dev, device_t child, char *buf,
 188     size_t buflen)
 189 {
 190         struct bhndb_softc *sc;
 191
 192         sc = device_get_softc(dev);
 193
 194         snprintf(buf, buflen, "base=0x%llx",
 195             (unsigned long long) sc->chipid.enum_addr);
 196         return (0);
 197 }
 198
 199 /**
 200  * Return the bridge core info. Will panic if the bridge core info has not yet
 201  * been populated during full bridge configuration.
 202  *
 203  * @param sc BHNDB device state.
 204  */
 205 static struct bhnd_core_info *
 206 bhndb_get_bridge_core(struct bhndb_softc *sc)
 207 {
 208         if (!sc->have_br_core)
 209                 panic("bridge not yet fully configured; no bridge core!");
 210
 211         return (&sc->bridge_core);
 212 }
 213
 214 /**
 215  * Return true if @p cores matches the @p hw specification.
 216  *
 217  * @param sc BHNDB device state.
 218  * @param cores A device table to match against.
 219  * @param ncores The number of cores in @p cores.
 220  * @param hw The hardware description to be matched against.
 221  */
 222 static bool
 223 bhndb_hw_matches(struct bhndb_softc *sc, struct bhnd_core_info *cores,
 224     u_int ncores, const struct bhndb_hw *hw)
 225 {
 226         for (u_int i = 0; i < hw->num_hw_reqs; i++) {
 227                 const struct bhnd_core_match    *match;
 228                 bool                             found;
 229
 230                 match =  &hw->hw_reqs[i];
 231                 found = false;
 232
 233                 for (u_int d = 0; d < ncores; d++) {
 234                         struct bhnd_core_info *core = &cores[d];
 235
 236                         if (BHNDB_IS_CORE_DISABLED(sc->dev, sc->bus_dev, core))
 237                                 continue;
 238
 239                         if (!bhnd_core_matches(core, match))
 240                                 continue;
 241
 242                         found = true;
 243                         break;
 244                 }
 245
 246                 if (!found)
 247                         return (false);
 248         }
 249
 250         return (true);
 251 }
 252
 253 /**
 254  * Initialize the region maps and priority configuration in @p br using
 255  * the priority @p table and the set of cores enumerated by @p erom.
 256  *
 257  * @param sc The bhndb device state.
 258  * @param br The resource state to be configured.
 259  * @param erom EROM parser used to enumerate @p cores.
 260  * @param cores All cores enumerated on the bridged bhnd bus.
 261  * @param ncores The length of @p cores.
 262  * @param table Hardware priority table to be used to determine the relative
 263  * priorities of per-core port resources.
 264  */
 265 static int
 266 bhndb_init_region_cfg(struct bhndb_softc *sc, bhnd_erom_t *erom,
 267     struct bhndb_resources *br, struct bhnd_core_info *cores, u_int ncores,
 268     const struct bhndb_hw_priority *table)
 269 {
 270         const struct bhndb_hw_priority  *hp;
 271         bhnd_addr_t                      addr;
 272         bhnd_size_t                      size;
 273         size_t                           prio_low, prio_default, prio_high;
 274         int                              error;
 275
 276         /* The number of port regions per priority band that must be accessible
 277          * via dynamic register windows */
 278         prio_low = 0;
 279         prio_default = 0;
 280         prio_high = 0;
 281
 282         /*
 283          * Register bridge regions covering all statically mapped ports.
 284          */
 285         for (u_int i = 0; i < ncores; i++) {
 286                 const struct bhndb_regwin       *regw;
 287                 struct bhnd_core_info           *core;
 288                 struct bhnd_core_match           md;
 289
 290                 core = &cores[i];
 291                 md = bhnd_core_get_match_desc(core);
 292
 293                 for (regw = br->cfg->register_windows;
 294                     regw->win_type != BHNDB_REGWIN_T_INVALID; regw++)
 295                 {
 296                         /* Only core windows are supported */
 297                         if (regw->win_type != BHNDB_REGWIN_T_CORE)
 298                                 continue;
 299
 300                         /* Skip non-matching cores. */
 301                         if (!bhndb_regwin_match_core(regw, core))
 302                                 continue;
 303
 304                         /* Fetch the base address of the mapped port */
 305                         error = bhnd_erom_lookup_core_addr(erom, &md,
 306                             regw->d.core.port_type,
 307                             regw->d.core.port,
 308                             regw->d.core.region,
 309                             NULL,
 310                             &addr,
 311                             &size);
 312                         if (error) {
 313                                 /* Skip non-applicable register windows */
 314                                 if (error == ENOENT)
 315                                         continue;
 316
 317                                 return (error);
 318                         }
 319
 320                         /*
 321                          * Always defer to the register window's size.
 322                          *
 323                          * If the port size is smaller than the window size,
 324                          * this ensures that we fully utilize register windows
 325                          * larger than the referenced port.
 326                          *
 327                          * If the port size is larger than the window size, this
 328                          * ensures that we do not directly map the allocations
 329                          * within the region to a too-small window.
 330                          */
 331                         size = regw->win_size;
 332
 333                         /*
 334                          * Add to the bus region list.
 335                          *
 336                          * The window priority for a statically mapped
 337                          * region is always HIGH.
 338                          */
 339                         error = bhndb_add_resource_region(br, addr, size,
 340                             BHNDB_PRIORITY_HIGH, regw);
 341                         if (error)
 342                                 return (error);
 343                 }
 344         }
 345
 346         /*
 347          * Perform priority accounting and register bridge regions for all
 348          * ports defined in the priority table
 349          */
 350         for (u_int i = 0; i < ncores; i++) {
 351                 struct bhndb_region     *region;
 352                 struct bhnd_core_info   *core;
 353                 struct bhnd_core_match   md;
 354
 355                 core = &cores[i];
 356                 md = bhnd_core_get_match_desc(core);
 357
 358                 /*
 359                  * Skip priority accounting for cores that ...
 360                  */
 361
 362                 /* ... do not require bridge resources */
 363                 if (BHNDB_IS_CORE_DISABLED(sc->dev, sc->bus_dev, core))
 364                         continue;
 365
 366                 /* ... do not have a priority table entry */
 367                 hp = bhndb_hw_priority_find_core(table, core);
 368                 if (hp == NULL)
 369                         continue;
 370
 371                 /* ... are explicitly disabled in the priority table. */
 372                 if (hp->priority == BHNDB_PRIORITY_NONE)
 373                         continue;
 374
 375                 /* Determine the number of dynamic windows required and
 376                  * register their bus_region entries. */
 377                 for (u_int i = 0; i < hp->num_ports; i++) {
 378                         const struct bhndb_port_priority *pp;
 379
 380                         pp = &hp->ports[i];
 381
 382                         /* Fetch the address+size of the mapped port. */
 383                         error = bhnd_erom_lookup_core_addr(erom, &md,
 384                             pp->type, pp->port, pp->region,
 385                             NULL, &addr, &size);
 386                         if (error) {
 387                                 /* Skip ports not defined on this device */
 388                                 if (error == ENOENT)
 389                                         continue;
 390
 391                                 return (error);
 392                         }
 393
 394                         /* Skip ports with an existing static mapping */
 395                         region = bhndb_find_resource_region(br, addr, size);
 396                         if (region != NULL && region->static_regwin != NULL)
 397                                 continue;
 398
 399                         /* Define a dynamic region for this port */
 400                         error = bhndb_add_resource_region(br, addr, size,
 401                             pp->priority, NULL);
 402                         if (error)
 403                                 return (error);
 404
 405                         /* Update port mapping counts */
 406                         switch (pp->priority) {
 407                         case BHNDB_PRIORITY_NONE:
 408                                 break;
 409                         case BHNDB_PRIORITY_LOW:
 410                                 prio_low++;
 411                                 break;
 412                         case BHNDB_PRIORITY_DEFAULT:
 413                                 prio_default++;
 414                                 break;
 415                         case BHNDB_PRIORITY_HIGH:
 416                                 prio_high++;
 417                                 break;
 418                         }
 419                 }
 420         }
 421
 422         /* Determine the minimum priority at which we'll allocate direct
 423          * register windows from our dynamic pool */
 424         size_t prio_total = prio_low + prio_default + prio_high;
 425         if (prio_total <= br->dwa_count) {
 426                 /* low+default+high priority regions get windows */
 427                 br->min_prio = BHNDB_PRIORITY_LOW;
 428
 429         } else if (prio_default + prio_high <= br->dwa_count) {
 430                 /* default+high priority regions get windows */
 431                 br->min_prio = BHNDB_PRIORITY_DEFAULT;
 432
 433         } else {
 434                 /* high priority regions get windows */
 435                 br->min_prio = BHNDB_PRIORITY_HIGH;
 436         }
 437
 438         if (BHNDB_DEBUG(PRIO)) {
 439                 struct bhndb_region     *region;
 440                 const char              *direct_msg, *type_msg;
 441                 bhndb_priority_t         prio, prio_min;
 442
 443                 prio_min = br->min_prio;
 444                 device_printf(sc->dev, "min_prio: %d\n", prio_min);
 445
 446                 STAILQ_FOREACH(region, &br->bus_regions, link) {
 447                         prio = region->priority;
 448
 449                         direct_msg = prio >= prio_min ? "direct" : "indirect";
 450                         type_msg = region->static_regwin ? "static" : "dynamic";
 451
 452                         device_printf(sc->dev, "region 0x%llx+0x%llx priority "
 453                             "%u %s/%s\n",
 454                             (unsigned long long) region->addr,
 455                             (unsigned long long) region->size,
 456                             region->priority,
 457                             direct_msg, type_msg);
 458                 }
 459         }
 460
 461         return (0);
 462 }
 463
 464 /**
 465  * Find a hardware specification for @p dev.
 466  *
 467  * @param sc The bhndb device state.
 468  * @param cores All cores enumerated on the bridged bhnd bus.
 469  * @param ncores The length of @p cores.
 470  * @param[out] hw On success, the matched hardware specification.
 471  * with @p dev.
 472  *
 473  * @retval 0 success
 474  * @retval non-zero if an error occurs fetching device info for comparison.
 475  */
 476 static int
 477 bhndb_find_hwspec(struct bhndb_softc *sc, struct bhnd_core_info *cores,
 478     u_int ncores, const struct bhndb_hw **hw)
 479 {
 480         const struct bhndb_hw   *next, *hw_table;
 481
 482         /* Search for the first matching hardware config. */
 483         hw_table = BHNDB_BUS_GET_HARDWARE_TABLE(sc->parent_dev, sc->dev);
 484         for (next = hw_table; next->hw_reqs != NULL; next++) {
 485                 if (!bhndb_hw_matches(sc, cores, ncores, next))
 486                         continue;
 487
 488                 /* Found */
 489                 *hw = next;
 490                 return (0);
 491         }
 492
 493         return (ENOENT);
 494 }
 495
 496 /**
 497  * Helper function that must be called by subclass bhndb(4) drivers
 498  * when implementing DEVICE_ATTACH() before calling any bhnd(4) or bhndb(4)
 499  * APIs on the bridge device.
 500  *
 501  * This function will add a bridged bhnd(4) child device with a device order of
 502  * BHND_PROBE_BUS. Any subclass bhndb(4) driver may use the BHND_PROBE_*
 503  * priority bands to add additional devices that will be attached in
 504  * their preferred order relative to the bridged bhnd(4) bus.
 505  *
 506  * @param dev The bridge device to attach.
 507  * @param bridge_devclass The device class of the bridging core. This is used
 508  * to automatically detect the bridge core, and to disable additional bridge
 509  * cores (e.g. PCMCIA on a PCIe device).
 510  */
 511 int
 512 bhndb_attach(device_t dev, bhnd_devclass_t bridge_devclass)
 513 {
 514         struct bhndb_devinfo            *dinfo;
 515         struct bhndb_softc              *sc;
 516         const struct bhndb_hwcfg        *cfg;
 517         bhnd_erom_class_t               *eromcls;
 518         int                              error;
 519
 520         sc = device_get_softc(dev);
 521         sc->dev = dev;
 522         sc->parent_dev = device_get_parent(dev);
 523         sc->bridge_class = bridge_devclass;
 524
 525         BHNDB_LOCK_INIT(sc);
 526
 527         /* Populate generic resource allocation state. */
 528         cfg = BHNDB_BUS_GET_GENERIC_HWCFG(sc->parent_dev, sc->dev);
 529         sc->bus_res = bhndb_alloc_resources(dev, sc->parent_dev, cfg);
 530         if (sc->bus_res == NULL) {
 531                 return (ENXIO);
 532         }
 533
 534         /* Allocate our host resources */
 535         if ((error = bhndb_alloc_host_resources(sc->bus_res)))
 536                 goto failed;
 537
 538         /* Probe for a usable EROM class for our bridged bhnd(4) bus and
 539          * populate our chip identifier. */
 540         BHNDB_LOCK(sc);
 541         if ((eromcls = bhndb_probe_erom_class(sc, &sc->chipid)) == NULL) {
 542                 BHNDB_UNLOCK(sc);
 543
 544                 device_printf(sc->dev, "device enumeration unsupported; no "
 545                     "compatible driver found\n");
 546                 return (ENXIO);
 547         }
 548         BHNDB_UNLOCK(sc);
 549
 550         /* Add our bridged bus device */
 551         sc->bus_dev = BUS_ADD_CHILD(dev, BHND_PROBE_BUS, "bhnd", -1);
 552         if (sc->bus_dev == NULL) {
 553                 error = ENXIO;
 554                 goto failed;
 555         }
 556
 557         dinfo = device_get_ivars(sc->bus_dev);
 558         dinfo->addrspace = BHNDB_ADDRSPACE_BRIDGED;
 559
 560         /* Enumerate the bridged device and fully initialize our bridged
 561          * resource configuration */
 562         if ((error = bhndb_init_full_config(sc, eromcls))) {
 563                 device_printf(sc->dev, "initializing full bridge "
 564                     "configuration failed: %d\n", error);
 565                 goto failed;
 566         }
 567
 568         return (0);
 569
 570 failed:
 571         BHNDB_LOCK_DESTROY(sc);
 572
 573         if (sc->bus_res != NULL)
 574                 bhndb_free_resources(sc->bus_res);
 575
 576         return (error);
 577 }
 578
 579
 580 /**
 581  * Return a borrowed reference to the host resource mapping at least
 582  * BHND_DEFAULT_CORE_SIZE bytes at the first bus core, for use with
 583  * bhnd_erom_probe().
 584  *
 585  * This may return a borrowed reference to a bhndb_dw_alloc-managed
 586  * resource; any additional resource mapping requests may invalidate this
 587  * borrowed reference.
 588  *
 589  * @param sc BHNDB driver state.
 590  * @param[out] offset On success, the offset within the returned resource
 591  * at which the first bus core can be found.
 592  *
 593  * @retval non-NULL success.
 594  * @retval NULL If no usable mapping could be found.
 595  */
 596 static struct resource *
 597 bhndb_erom_chipc_resource(struct bhndb_softc *sc, bus_size_t *offset)
 598 {
 599         const struct bhndb_hwcfg        *cfg;
 600         struct bhndb_dw_alloc           *dwa;
 601         struct resource                 *res;
 602         const struct bhndb_regwin       *win;
 603
 604         BHNDB_LOCK_ASSERT(sc, MA_OWNED);
 605
 606         cfg = sc->bus_res->cfg;
 607
 608         /* Find a static register window mapping ChipCommon. */
 609         win = bhndb_regwin_find_core(cfg->register_windows, BHND_DEVCLASS_CC,
 610             0, BHND_PORT_DEVICE, 0, 0);
 611         if (win != NULL) {
 612                 if (win->win_size < BHND_DEFAULT_CORE_SIZE) {
 613                         device_printf(sc->dev,
 614                             "chipcommon register window too small\n");
 615                         return (NULL);
 616                 }
 617
 618                 res = bhndb_find_regwin_resource(sc->bus_res, win);
 619                 if (res == NULL) {
 620                         device_printf(sc->dev,
 621                             "chipcommon register window not allocated\n");
 622                         return (NULL);
 623                 }
 624
 625                 *offset = win->win_offset;
 626                 return (res);
 627         }
 628
 629         /* We'll need to fetch and configure a dynamic window. We can assume a
 630          * device without a static ChipCommon mapping uses the default siba(4)
 631          * base address. */
 632         dwa = bhndb_io_resource(sc, BHND_DEFAULT_CHIPC_ADDR,
 633             BHND_DEFAULT_CORE_SIZE, offset);
 634         if (dwa != NULL)
 635                 return (dwa->parent_res);
 636
 637         device_printf(sc->dev, "unable to map chipcommon registers; no usable "
 638             "register window found\n");
 639         return (NULL);
 640 }
 641
 642 /**
 643  * Probe all supported EROM classes, returning the best matching class
 644  * (or NULL if not found), writing the probed chip identifier to @p cid.
 645  *
 646  * @param sc BHNDB driver state.
 647  * @param cid On success, the bridged chipset's chip identifier.
 648  */
 649 static bhnd_erom_class_t *
 650 bhndb_probe_erom_class(struct bhndb_softc *sc, struct bhnd_chipid *cid)
 651 {
 652         devclass_t                       bhndb_devclass;
 653         const struct bhnd_chipid        *hint;
 654         struct resource                 *res;
 655         bus_size_t                       res_offset;
 656         driver_t                        **drivers;
 657         int                              drv_count;
 658         bhnd_erom_class_t               *erom_cls;
 659         int                              prio, result;
 660
 661         BHNDB_LOCK_ASSERT(sc, MA_OWNED);
 662
 663         erom_cls = NULL;
 664         prio = 0;
 665
 666         /* Let our parent device provide a chipid hint */
 667         hint = BHNDB_BUS_GET_CHIPID(sc->parent_dev, sc->dev);
 668
 669         /* Fetch a borrowed reference to the resource mapping ChipCommon. */
 670         res = bhndb_erom_chipc_resource(sc, &res_offset);
 671         if (res == NULL)
 672                 return (NULL);
 673
 674         /* Fetch all available drivers */
 675         bhndb_devclass = device_get_devclass(sc->dev);
 676         if (devclass_get_drivers(bhndb_devclass, &drivers, &drv_count) != 0)
 677                 return (NULL);
 678
 679         /* Enumerate the drivers looking for the best available EROM class */
 680         for (int i = 0; i < drv_count; i++) {
 681                 struct bhnd_chipid       pcid;
 682                 bhnd_erom_class_t       *cls;
 683
 684                 cls = bhnd_driver_get_erom_class(drivers[i]);
 685                 if (cls == NULL)
 686                         continue;
 687
 688                 kobj_class_compile(cls);
 689
 690                 /* Probe the bus */
 691                 result = bhnd_erom_probe(cls, &BHND_DIRECT_RESOURCE(res),
 692                     res_offset, hint, &pcid);
 693
 694                 /* The parser did not match if an error was returned */
 695                 if (result > 0)
 696                         continue;
 697
 698                 /* Check for a new highest priority match */
 699                 if (erom_cls == NULL || result > prio) {
 700                         prio = result;
 701
 702                         *cid = pcid;
 703                         erom_cls = cls;
 704                 }
 705
 706                 /* Terminate immediately on BUS_PROBE_SPECIFIC */
 707                 if (result == BUS_PROBE_SPECIFIC)
 708                         break;
 709         }
 710
 711         return (erom_cls);
 712 }
 713
 714 /* ascending core index comparison used by bhndb_find_hostb_core() */
 715 static int
 716 compare_core_index(const void *lhs, const void *rhs)
 717 {
 718         u_int left = ((const struct bhnd_core_info *)lhs)->core_idx;
 719         u_int right = ((const struct bhnd_core_info *)rhs)->core_idx;
 720
 721         if (left < right)
 722                 return (-1);
 723         else if (left > right)
 724                 return (1);
 725         else
 726                 return (0);
 727 }
 728
 729 /**
 730  * Search @p erom for the core serving as the bhnd host bridge.
 731  *
 732  * This function uses a heuristic valid on all known PCI/PCIe/PCMCIA-bridged
 733  * bhnd(4) devices to determine the hostb core:
 734  *
 735  * - The core must have a Broadcom vendor ID.
 736  * - The core devclass must match the bridge type.
 737  * - The core must be the first device on the bus with the bridged device
 738  *   class.
 739  *
 740  * @param sc BHNDB device state.
 741  * @param erom The device enumeration table parser to be used to fetch
 742  * core info.
 743  * @param[out] core If found, the matching core info.
 744  *
 745  * @retval 0 success
 746  * @retval ENOENT not found
 747  * @retval non-zero if an error occured fetching core info.
 748  */
 749 static int
 750 bhndb_find_hostb_core(struct bhndb_softc *sc, bhnd_erom_t *erom,
 751     struct bhnd_core_info *core)
 752 {
 753         struct bhnd_core_match   md;
 754         struct bhnd_core_info   *cores;
 755         u_int                    ncores;
 756         int                      error;
 757
 758         if ((error = bhnd_erom_get_core_table(erom, &cores, &ncores)))
 759                 return (error);
 760
 761         /* Set up a match descriptor for the required device class. */
 762         md = (struct bhnd_core_match) {
 763                 BHND_MATCH_CORE_CLASS(sc->bridge_class),
 764                 BHND_MATCH_CORE_UNIT(0)
 765         };
 766
 767         /* Ensure the table is sorted by core index value, ascending;
 768          * the host bridge must be the absolute first matching device on the
 769          * bus. */
 770         qsort(cores, ncores, sizeof(*cores), compare_core_index);
 771
 772         /* Find the hostb core */
 773         error = ENOENT;
 774         for (u_int i = 0; i < ncores; i++) {
 775                 if (bhnd_core_matches(&cores[i], &md)) {
 776                         /* Found! */
 777                         *core = cores[i];
 778                         error = 0;
 779                         break;
 780                 }
 781         }
 782
 783         /* Clean up */
 784         bhnd_erom_free_core_table(erom, cores);
 785
 786         return (error);
 787 }
 788
 789 /**
 790  * Identify the bridged device and perform final bridge resource configuration
 791  * based on capabilities of the enumerated device.
 792  *
 793  * Any bridged resources allocated using the generic brige hardware
 794  * configuration must be released prior to calling this function.
 795  */
 796 static int
 797 bhndb_init_full_config(struct bhndb_softc *sc, bhnd_erom_class_t *eromcls)
 798 {
 799         struct bhnd_core_info           *cores;
 800         struct bhndb_resources          *br;
 801         const struct bhndb_hw_priority  *hwprio;
 802         bhnd_erom_t                     *erom;
 803         const struct bhndb_hw           *hw;
 804         u_int                            ncores;
 805         int                              error;
 806
 807         erom = NULL;
 808         cores = NULL;
 809         br = NULL;
 810
 811         /* Allocate EROM parser instance */
 812         erom = bhnd_erom_alloc(eromcls, &sc->chipid, sc->bus_dev, 0);
 813         if (erom == NULL) {
 814                 device_printf(sc->dev, "failed to allocate device enumeration "
 815                     "table parser\n");
 816                 return (ENXIO);
 817         }
 818
 819         /* Look for our host bridge core */
 820         if ((error = bhndb_find_hostb_core(sc, erom, &sc->bridge_core))) {
 821                 device_printf(sc->dev, "no host bridge core found\n");
 822                 goto cleanup;
 823         } else {
 824                 sc->have_br_core = true;
 825         }
 826
 827         /* Fetch the bridged device's core table */
 828         if ((error = bhnd_erom_get_core_table(erom, &cores, &ncores))) {
 829                 device_printf(sc->dev, "error fetching core table: %d\n",
 830                     error);
 831                 goto cleanup;
 832         }
 833
 834         /* Find our full register window configuration */
 835         if ((error = bhndb_find_hwspec(sc, cores, ncores, &hw))) {
 836                 device_printf(sc->dev, "unable to identify device, "
 837                     " using generic bridge resource definitions\n");
 838                 error = 0;
 839                 goto cleanup;
 840         }
 841
 842         if (bootverbose || BHNDB_DEBUG(PRIO))
 843                 device_printf(sc->dev, "%s resource configuration\n", hw->name);
 844
 845         /* Allocate new bridge resource state using the discovered hardware
 846          * configuration */
 847         br = bhndb_alloc_resources(sc->dev, sc->parent_dev, hw->cfg);
 848         if (br == NULL) {
 849                 device_printf(sc->dev,
 850                     "failed to allocate new resource state\n");
 851                 error = ENOMEM;
 852                 goto cleanup;
 853         }
 854
 855         /* Populate our resource priority configuration */
 856         hwprio = BHNDB_BUS_GET_HARDWARE_PRIO(sc->parent_dev, sc->dev);
 857         error = bhndb_init_region_cfg(sc, erom, br, cores, ncores, hwprio);
 858         if (error) {
 859                 device_printf(sc->dev, "failed to initialize resource "
 860                     "priority configuration: %d\n", error);
 861                 goto cleanup;
 862         }
 863
 864         /* The EROM parser holds a reference to the resource state we're
 865          * about to invalidate */
 866         bhnd_erom_free_core_table(erom, cores);
 867         bhnd_erom_free(erom);
 868
 869         cores = NULL;
 870         erom = NULL;
 871
 872         /* Replace existing resource state */
 873         bhndb_free_resources(sc->bus_res);
 874         sc->bus_res = br;
 875
 876         /* Pointer is now owned by sc->bus_res */
 877         br = NULL;
 878
 879         /* Re-allocate host resources */
 880         if ((error = bhndb_alloc_host_resources(sc->bus_res))) {
 881                 device_printf(sc->dev, "failed to reallocate bridge host "
 882                     "resources: %d\n", error);
 883                 goto cleanup;
 884         }
 885
 886         return (0);
 887
 888 cleanup:
 889         if (cores != NULL)
 890                 bhnd_erom_free_core_table(erom, cores);
 891
 892         if (erom != NULL)
 893                 bhnd_erom_free(erom);
 894
 895         if (br != NULL)
 896                 bhndb_free_resources(br);
 897
 898         return (error);
 899 }
 900
 901 /**
 902  * Default bhndb(4) implementation of DEVICE_DETACH().
 903  *
 904  * This function detaches any child devices, and if successful, releases all
 905  * resources held by the bridge device.
 906  */
 907 int
 908 bhndb_generic_detach(device_t dev)
 909 {
 910         struct bhndb_softc      *sc;
 911         int                      error;
 912
 913         sc = device_get_softc(dev);
 914
 915         /* Detach children */
 916         if ((error = bus_generic_detach(dev)))
 917                 return (error);
 918
 919         /* Clean up our driver state. */
 920         bhndb_free_resources(sc->bus_res);
 921
 922         BHNDB_LOCK_DESTROY(sc);
 923
 924         return (0);
 925 }
 926
 927 /**
 928  * Default bhndb(4) implementation of DEVICE_SUSPEND().
 929  *
 930  * This function calls bus_generic_suspend() (or implements equivalent
 931  * behavior).
 932  */
 933 int
 934 bhndb_generic_suspend(device_t dev)
 935 {
 936         return (bus_generic_suspend(dev));
 937 }
 938
 939 /**
 940  * Default bhndb(4) implementation of DEVICE_RESUME().
 941  *
 942  * This function calls bus_generic_resume() (or implements equivalent
 943  * behavior).
 944  */
 945 int
 946 bhndb_generic_resume(device_t dev)
 947 {
 948         struct bhndb_softc      *sc;
 949         struct bhndb_resources  *bus_res;
 950         struct bhndb_dw_alloc   *dwa;
 951         int                      error;
 952
 953         sc = device_get_softc(dev);
 954         bus_res = sc->bus_res;
 955
 956         /* Guarantee that all in-use dynamic register windows are mapped to
 957          * their previously configured target address. */
 958         BHNDB_LOCK(sc);
 959         for (size_t i = 0; i < bus_res->dwa_count; i++) {
 960                 dwa = &bus_res->dw_alloc[i];
 961
 962                 /* Skip regions that were not previously used */
 963                 if (bhndb_dw_is_free(bus_res, dwa) && dwa->target == 0x0)
 964                         continue;
 965
 966                 /* Otherwise, ensure the register window is correct before
 967                  * any children attempt MMIO */
 968                 error = BHNDB_SET_WINDOW_ADDR(dev, dwa->win, dwa->target);
 969                 if (error)
 970                         break;
 971         }
 972         BHNDB_UNLOCK(sc);
 973
 974         /* Error restoring hardware state; children cannot be safely resumed */
 975         if (error) {
 976                 device_printf(dev, "Unable to restore hardware configuration; "
 977                     "cannot resume: %d\n", error);
 978                 return (error);
 979         }
 980
 981         return (bus_generic_resume(dev));
 982 }
 983
 984 /**
 985  * Default implementation of BHNDB_SUSPEND_RESOURCE.
 986  */
 987 static void
 988 bhndb_suspend_resource(device_t dev, device_t child, int type,
 989     struct resource *r)
 990 {
 991         struct bhndb_softc      *sc;
 992         struct bhndb_dw_alloc   *dwa;
 993
 994         sc = device_get_softc(dev);
 995
 996         /* Non-MMIO resources (e.g. IRQs) are handled solely by our parent */
 997         if (type != SYS_RES_MEMORY)
 998                 return;
 999
1000         BHNDB_LOCK(sc);
1001         dwa = bhndb_dw_find_resource(sc->bus_res, r);
1002         if (dwa == NULL) {
1003                 BHNDB_UNLOCK(sc);
1004                 return;
1005         }
1006
1007         if (BHNDB_DEBUG(PRIO))
1008                 device_printf(child, "suspend resource type=%d 0x%jx+0x%jx\n",
1009                     type, rman_get_start(r), rman_get_size(r));
1010
1011         /* Release the resource's window reference */
1012         bhndb_dw_release(sc->bus_res, dwa, r);
1013         BHNDB_UNLOCK(sc);
1014 }
1015
1016 /**
1017  * Default implementation of BHNDB_RESUME_RESOURCE.
1018  */
1019 static int
1020 bhndb_resume_resource(device_t dev, device_t child, int type,
1021     struct resource *r)
1022 {
1023         struct bhndb_softc      *sc;
1024
1025         sc = device_get_softc(dev);
1026
1027         /* Non-MMIO resources (e.g. IRQs) are handled solely by our parent */
1028         if (type != SYS_RES_MEMORY)
1029                 return (0);
1030
1031         /* Inactive resources don't require reallocation of bridge resources */
1032         if (!(rman_get_flags(r) & RF_ACTIVE))
1033                 return (0);
1034
1035         if (BHNDB_DEBUG(PRIO))
1036                 device_printf(child, "resume resource type=%d 0x%jx+0x%jx\n",
1037                     type, rman_get_start(r), rman_get_size(r));
1038
1039         return (bhndb_try_activate_resource(sc, rman_get_device(r), type,
1040             rman_get_rid(r), r, NULL));
1041 }
1042
1043 /**
1044  * Default bhndb(4) implementation of BUS_READ_IVAR().
1045  */
1046 static int
1047 bhndb_read_ivar(device_t dev, device_t child, int index,
1048     uintptr_t *result)
1049 {
1050         return (ENOENT);
1051 }
1052
1053 /**
1054  * Default bhndb(4) implementation of BUS_WRITE_IVAR().
1055  */
1056 static int
1057 bhndb_write_ivar(device_t dev, device_t child, int index,
1058     uintptr_t value)
1059 {
1060         return (ENOENT);
1061 }
1062
1063 /**
1064  * Return the address space for the given @p child device.
1065  */
1066 bhndb_addrspace
1067 bhndb_get_addrspace(struct bhndb_softc *sc, device_t child)
1068 {
1069         struct bhndb_devinfo    *dinfo;
1070         device_t                 imd_dev;
1071
1072         /* Find the directly attached parent of the requesting device */
1073         imd_dev = child;
1074         while (imd_dev != NULL && device_get_parent(imd_dev) != sc->dev)
1075                 imd_dev = device_get_parent(imd_dev);
1076
1077         if (imd_dev == NULL)
1078                 panic("bhndb address space request for non-child device %s\n",
1079                      device_get_nameunit(child));
1080
1081         dinfo = device_get_ivars(imd_dev);
1082         return (dinfo->addrspace);
1083 }
1084
1085 /**
1086  * Return the rman instance for a given resource @p type, if any.
1087  *
1088  * @param sc The bhndb device state.
1089  * @param child The requesting child.
1090  * @param type The resource type (e.g. SYS_RES_MEMORY, SYS_RES_IRQ, ...)
1091  */
1092 static struct rman *
1093 bhndb_get_rman(struct bhndb_softc *sc, device_t child, int type)
1094 {
1095         switch (bhndb_get_addrspace(sc, child)) {
1096         case BHNDB_ADDRSPACE_NATIVE:
1097                 switch (type) {
1098                 case SYS_RES_MEMORY:
1099                         return (&sc->bus_res->ht_mem_rman);
1100                 case SYS_RES_IRQ:
1101                         return (NULL);
1102                 default:
1103                         return (NULL);
1104                 }
1105
1106         case BHNDB_ADDRSPACE_BRIDGED:
1107                 switch (type) {
1108                 case SYS_RES_MEMORY:
1109                         return (&sc->bus_res->br_mem_rman);
1110                 case SYS_RES_IRQ:
1111                         return (NULL);
1112                 default:
1113                         return (NULL);
1114                 }
1115         }
1116
1117         /* Quieten gcc */
1118         return (NULL);
1119 }
1120
1121 /**
1122  * Default implementation of BUS_ADD_CHILD()
1123  */
1124 static device_t
1125 bhndb_add_child(device_t dev, u_int order, const char *name, int unit)
1126 {
1127         struct bhndb_devinfo    *dinfo;
1128         device_t                 child;
1129
1130         child = device_add_child_ordered(dev, order, name, unit);
1131         if (child == NULL)
1132                 return (NULL);
1133
1134         dinfo = malloc(sizeof(struct bhndb_devinfo), M_BHND, M_NOWAIT);
1135         if (dinfo == NULL) {
1136                 device_delete_child(dev, child);
1137                 return (NULL);
1138         }
1139
1140         dinfo->addrspace = BHNDB_ADDRSPACE_NATIVE;
1141         resource_list_init(&dinfo->resources);
1142
1143         device_set_ivars(child, dinfo);
1144
1145         return (child);
1146 }
1147
1148 /**
1149  * Default implementation of BUS_CHILD_DELETED().
1150  */
1151 static void
1152 bhndb_child_deleted(device_t dev, device_t child)
1153 {
1154         struct bhndb_devinfo *dinfo = device_get_ivars(child);
1155         if (dinfo != NULL) {
1156                 resource_list_free(&dinfo->resources);
1157                 free(dinfo, M_BHND);
1158         }
1159
1160         device_set_ivars(child, NULL);
1161 }
1162
1163 /**
1164  * Default implementation of BHNDB_GET_CHIPID().
1165  */
1166 static const struct bhnd_chipid *
1167 bhndb_get_chipid(device_t dev, device_t child)
1168 {
1169         struct bhndb_softc *sc = device_get_softc(dev);
1170         return (&sc->chipid);
1171 }
1172
1173 /**
1174  * Default implementation of BHNDB_IS_CORE_DISABLED().
1175  */
1176 static bool
1177 bhndb_is_core_disabled(device_t dev, device_t child,
1178     struct bhnd_core_info *core)
1179 {
1180         struct bhndb_softc      *sc;
1181         struct bhnd_core_info   *bridge_core;
1182
1183         sc = device_get_softc(dev);
1184
1185         /* Try to defer to the bhndb bus parent */
1186         if (BHNDB_BUS_IS_CORE_DISABLED(sc->parent_dev, dev, core))
1187                 return (true);
1188
1189         /* Otherwise, we treat bridge-capable cores as unpopulated if they're
1190          * not the configured host bridge */
1191         bridge_core = bhndb_get_bridge_core(sc);
1192         if (BHND_DEVCLASS_SUPPORTS_HOSTB(bhnd_core_class(core)))
1193                 return (!bhnd_cores_equal(core, bridge_core));
1194
1195         /* Assume the core is populated */
1196         return (false);
1197 }
1198
1199 /**
1200  * Default bhndb(4) implementation of BHNDB_GET_HOSTB_CORE().
1201  *
1202  * This function uses a heuristic valid on all known PCI/PCIe/PCMCIA-bridged
1203  * bhnd(4) devices.
1204  */
1205 static int
1206 bhndb_get_hostb_core(device_t dev, device_t child, struct bhnd_core_info *core)
1207 {
1208         struct bhndb_softc *sc = device_get_softc(dev);
1209
1210         *core = *bhndb_get_bridge_core(sc);
1211         return (0);
1212 }
1213
1214 /**
1215  * Default bhndb(4) implementation of BUS_ALLOC_RESOURCE().
1216  */
1217 static struct resource *
1218 bhndb_alloc_resource(device_t dev, device_t child, int type,
1219     int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
1220 {
1221         struct bhndb_softc              *sc;
1222         struct resource_list_entry      *rle;
1223         struct resource                 *rv;
1224         struct rman                     *rm;
1225         int                              error;
1226         bool                             passthrough, isdefault;
1227
1228         sc = device_get_softc(dev);
1229         passthrough = (device_get_parent(child) != dev);
1230         isdefault = RMAN_IS_DEFAULT_RANGE(start, end);
1231         rle = NULL;
1232
1233         /* Fetch the resource manager */
1234         rm = bhndb_get_rman(sc, child, type);
1235         if (rm == NULL) {
1236                 /* Delegate to our parent device's bus; the requested
1237                  * resource type isn't handled locally. */
1238                 return (BUS_ALLOC_RESOURCE(device_get_parent(sc->parent_dev),
1239                     child, type, rid,  start, end, count, flags));
1240         }
1241
1242         /* Populate defaults */
1243         if (!passthrough && isdefault) {
1244                 /* Fetch the resource list entry. */
1245                 rle = resource_list_find(BUS_GET_RESOURCE_LIST(dev, child),
1246                     type, *rid);
1247                 if (rle == NULL) {
1248                         device_printf(dev,
1249                             "default resource %#x type %d for child %s "
1250                             "not found\n", *rid, type,
1251                             device_get_nameunit(child));
1252
1253                         return (NULL);
1254                 }
1255
1256                 if (rle->res != NULL) {
1257                         device_printf(dev,
1258                             "resource entry %#x type %d for child %s is busy\n",
1259                             *rid, type, device_get_nameunit(child));
1260
1261                         return (NULL);
1262                 }
1263
1264                 start = rle->start;
1265                 end = rle->end;
1266                 count = ulmax(count, rle->count);
1267         }
1268
1269         /* Validate resource addresses */
1270         if (start > end || count > ((end - start) + 1))
1271                 return (NULL);
1272
1273         /* Make our reservation */
1274         rv = rman_reserve_resource(rm, start, end, count, flags & ~RF_ACTIVE,
1275             child);
1276         if (rv == NULL)
1277                 return (NULL);
1278
1279         rman_set_rid(rv, *rid);
1280
1281         /* Activate */
1282         if (flags & RF_ACTIVE) {
1283                 error = bus_activate_resource(child, type, *rid, rv);
1284                 if (error) {
1285                         device_printf(dev,
1286                             "failed to activate entry %#x type %d for "
1287                                 "child %s: %d\n",
1288                              *rid, type, device_get_nameunit(child), error);
1289
1290                         rman_release_resource(rv);
1291
1292                         return (NULL);
1293                 }
1294         }
1295
1296         /* Update child's resource list entry */
1297         if (rle != NULL) {
1298                 rle->res = rv;
1299                 rle->start = rman_get_start(rv);
1300                 rle->end = rman_get_end(rv);
1301                 rle->count = rman_get_size(rv);
1302         }
1303
1304         return (rv);
1305 }
1306
1307 /**
1308  * Default bhndb(4) implementation of BUS_RELEASE_RESOURCE().
1309  */
1310 static int
1311 bhndb_release_resource(device_t dev, device_t child, int type, int rid,
1312     struct resource *r)
1313 {
1314         struct bhndb_softc              *sc;
1315         struct resource_list_entry      *rle;
1316         bool                             passthrough;
1317         int                              error;
1318
1319         sc = device_get_softc(dev);
1320         passthrough = (device_get_parent(child) != dev);
1321
1322         /* Delegate to our parent device's bus if the requested resource type
1323          * isn't handled locally. */
1324         if (bhndb_get_rman(sc, child, type) == NULL) {
1325                 return (BUS_RELEASE_RESOURCE(device_get_parent(sc->parent_dev),
1326                     child, type, rid, r));
1327         }
1328
1329         /* Deactivate resources */
1330         if (rman_get_flags(r) & RF_ACTIVE) {
1331                 error = BUS_DEACTIVATE_RESOURCE(dev, child, type, rid, r);
1332                 if (error)
1333                         return (error);
1334         }
1335
1336         if ((error = rman_release_resource(r)))
1337                 return (error);
1338
1339         if (!passthrough) {
1340                 /* Clean resource list entry */
1341                 rle = resource_list_find(BUS_GET_RESOURCE_LIST(dev, child),
1342                     type, rid);
1343                 if (rle != NULL)
1344                         rle->res = NULL;
1345         }
1346
1347         return (0);
1348 }
1349
1350 /**
1351  * Default bhndb(4) implementation of BUS_ADJUST_RESOURCE().
1352  */
1353 static int
1354 bhndb_adjust_resource(device_t dev, device_t child, int type,
1355     struct resource *r, rman_res_t start, rman_res_t end)
1356 {
1357         struct bhndb_softc              *sc;
1358         struct rman                     *rm;
1359         rman_res_t                       mstart, mend;
1360         int                              error;
1361
1362         sc = device_get_softc(dev);
1363         error = 0;
1364
1365         /* Delegate to our parent device's bus if the requested resource type
1366          * isn't handled locally. */
1367         rm = bhndb_get_rman(sc, child, type);
1368         if (rm == NULL) {
1369                 return (BUS_ADJUST_RESOURCE(device_get_parent(sc->parent_dev),
1370                     child, type, r, start, end));
1371         }
1372
1373         /* Verify basic constraints */
1374         if (end <= start)
1375                 return (EINVAL);
1376
1377         if (!rman_is_region_manager(r, rm))
1378                 return (ENXIO);
1379
1380         BHNDB_LOCK(sc);
1381
1382         /* If not active, allow any range permitted by the resource manager */
1383         if (!(rman_get_flags(r) & RF_ACTIVE))
1384                 goto done;
1385
1386         /* Otherwise, the range is limited to the existing register window
1387          * mapping */
1388         error = bhndb_find_resource_limits(sc->bus_res, r, &mstart, &mend);
1389         if (error)
1390                 goto done;
1391
1392         if (start < mstart || end > mend) {
1393                 error = EINVAL;
1394                 goto done;
1395         }
1396
1397         /* Fall through */
1398 done:
1399         if (!error)
1400                 error = rman_adjust_resource(r, start, end);
1401
1402         BHNDB_UNLOCK(sc);
1403         return (error);
1404 }
1405
1406 /**
1407  * Initialize child resource @p r with a virtual address, tag, and handle
1408  * copied from @p parent, adjusted to contain only the range defined by
1409  * @p offsize and @p size.
1410  *
1411  * @param r The register to be initialized.
1412  * @param parent The parent bus resource that fully contains the subregion.
1413  * @param offset The subregion offset within @p parent.
1414  * @param size The subregion size.
1415  * @p r.
1416  */
1417 static int
1418 bhndb_init_child_resource(struct resource *r,
1419     struct resource *parent, bhnd_size_t offset, bhnd_size_t size)
1420 {
1421         bus_space_handle_t      bh, child_bh;
1422         bus_space_tag_t         bt;
1423         uintptr_t               vaddr;
1424         int                     error;
1425
1426         /* Fetch the parent resource's real bus values */
1427         vaddr = (uintptr_t) rman_get_virtual(parent);
1428         bt = rman_get_bustag(parent);
1429         bh = rman_get_bushandle(parent);
1430
1431         /* Configure child resource with window-adjusted real bus values */
1432         vaddr += offset;
1433         error = bus_space_subregion(bt, bh, offset, size, &child_bh);
1434         if (error)
1435                 return (error);
1436
1437         rman_set_virtual(r, (void *) vaddr);
1438         rman_set_bustag(r, bt);
1439         rman_set_bushandle(r, child_bh);
1440
1441         return (0);
1442 }
1443
1444 /**
1445  * Attempt activation of a fixed register window mapping for @p child.
1446  *
1447  * @param sc BHNDB device state.
1448  * @param region The static region definition capable of mapping @p r.
1449  * @param child A child requesting resource activation.
1450  * @param type Resource type.
1451  * @param rid Resource identifier.
1452  * @param r Resource to be activated.
1453  *
1454  * @retval 0 if @p r was activated successfully
1455  * @retval ENOENT if no fixed register window was found.
1456  * @retval non-zero if @p r could not be activated.
1457  */
1458 static int
1459 bhndb_activate_static_region(struct bhndb_softc *sc,
1460     struct bhndb_region *region, device_t child, int type, int rid,
1461     struct resource *r)
1462 {
1463         struct resource                 *bridge_res;
1464         const struct bhndb_regwin       *win;
1465         bhnd_size_t                      parent_offset;
1466         rman_res_t                       r_start, r_size;
1467         int                              error;
1468
1469         win = region->static_regwin;
1470
1471         KASSERT(win != NULL && BHNDB_REGWIN_T_IS_STATIC(win->win_type),
1472             ("can't activate non-static region"));
1473
1474         r_start = rman_get_start(r);
1475         r_size = rman_get_size(r);
1476
1477         /* Find the corresponding bridge resource */
1478         bridge_res = bhndb_find_regwin_resource(sc->bus_res, win);
1479         if (bridge_res == NULL)
1480                 return (ENXIO);
1481
1482         /* Calculate subregion offset within the parent resource */
1483         parent_offset = r_start - region->addr;
1484         parent_offset += win->win_offset;
1485
1486         /* Configure resource with its real bus values. */
1487         error = bhndb_init_child_resource(r, bridge_res, parent_offset, r_size);
1488         if (error)
1489                 return (error);
1490
1491         /* Mark active */
1492         if ((error = rman_activate_resource(r)))
1493                 return (error);
1494
1495         return (0);
1496 }
1497
1498 /**
1499  * Attempt to allocate/retain a dynamic register window for @p r, returning
1500  * the retained window.
1501  *
1502  * @param sc The bhndb driver state.
1503  * @param r The resource for which a window will be retained.
1504  */
1505 static struct bhndb_dw_alloc *
1506 bhndb_retain_dynamic_window(struct bhndb_softc *sc, struct resource *r)
1507 {
1508         struct bhndb_dw_alloc   *dwa;
1509         rman_res_t               r_start, r_size;
1510         int                      error;
1511
1512         BHNDB_LOCK_ASSERT(sc, MA_OWNED);
1513
1514         r_start = rman_get_start(r);
1515         r_size = rman_get_size(r);
1516
1517         /* Look for an existing dynamic window we can reference */
1518         dwa = bhndb_dw_find_mapping(sc->bus_res, r_start, r_size);
1519         if (dwa != NULL) {
1520                 if (bhndb_dw_retain(sc->bus_res, dwa, r) == 0)
1521                         return (dwa);
1522
1523                 return (NULL);
1524         }
1525
1526         /* Otherwise, try to reserve a free window */
1527         dwa = bhndb_dw_next_free(sc->bus_res);
1528         if (dwa == NULL) {
1529                 /* No free windows */
1530                 return (NULL);
1531         }
1532
1533         /* Window must be large enough to map the entire resource */
1534         if (dwa->win->win_size < rman_get_size(r))
1535                 return (NULL);
1536
1537         /* Set the window target */
1538         error = bhndb_dw_set_addr(sc->dev, sc->bus_res, dwa, rman_get_start(r),
1539             rman_get_size(r));
1540         if (error) {
1541                 device_printf(sc->dev, "dynamic window initialization "
1542                         "for 0x%llx-0x%llx failed: %d\n",
1543                         (unsigned long long) r_start,
1544                         (unsigned long long) r_start + r_size - 1,
1545                         error);
1546                 return (NULL);
1547         }
1548
1549         /* Add our reservation */
1550         if (bhndb_dw_retain(sc->bus_res, dwa, r))
1551                 return (NULL);
1552
1553         return (dwa);
1554 }
1555
1556 /**
1557  * Activate a resource using any viable static or dynamic register window.
1558  *
1559  * @param sc The bhndb driver state.
1560  * @param child The child holding ownership of @p r.
1561  * @param type The type of the resource to be activated.
1562  * @param rid The resource ID of @p r.
1563  * @param r The resource to be activated
1564  * @param[out] indirect On error and if not NULL, will be set to 'true' if
1565  * the caller should instead use an indirect resource mapping.
1566  *
1567  * @retval 0 success
1568  * @retval non-zero activation failed.
1569  */
1570 static int
1571 bhndb_try_activate_resource(struct bhndb_softc *sc, device_t child, int type,
1572     int rid, struct resource *r, bool *indirect)
1573 {
1574         struct bhndb_region     *region;
1575         struct bhndb_dw_alloc   *dwa;
1576         bhndb_priority_t         dw_priority;
1577         rman_res_t               r_start, r_size;
1578         rman_res_t               parent_offset;
1579         int                      error;
1580
1581         BHNDB_LOCK_ASSERT(sc, MA_NOTOWNED);
1582
1583         /* Only MMIO resources can be mapped via register windows */
1584         if (type != SYS_RES_MEMORY)
1585                 return (ENXIO);
1586
1587         if (indirect)
1588                 *indirect = false;
1589
1590         r_start = rman_get_start(r);
1591         r_size = rman_get_size(r);
1592
1593         /* Activate native addrspace resources using the host address space */
1594         if (bhndb_get_addrspace(sc, child) == BHNDB_ADDRSPACE_NATIVE) {
1595                 struct resource *parent;
1596
1597                 /* Find the bridge resource referenced by the child */
1598                 parent = bhndb_find_resource_range(sc->bus_res, r_start,
1599                     r_size);
1600                 if (parent == NULL) {
1601                         device_printf(sc->dev, "host resource not found "
1602                              "for 0x%llx-0x%llx\n",
1603                              (unsigned long long) r_start,
1604                              (unsigned long long) r_start + r_size - 1);
1605                         return (ENOENT);
1606                 }
1607
1608                 /* Initialize child resource with the real bus values */
1609                 error = bhndb_init_child_resource(r, parent,
1610                     r_start - rman_get_start(parent), r_size);
1611                 if (error)
1612                         return (error);
1613
1614                 /* Try to activate child resource */
1615                 return (rman_activate_resource(r));
1616         }
1617
1618         /* Default to low priority */
1619         dw_priority = BHNDB_PRIORITY_LOW;
1620
1621         /* Look for a bus region matching the resource's address range */
1622         region = bhndb_find_resource_region(sc->bus_res, r_start, r_size);
1623         if (region != NULL)
1624                 dw_priority = region->priority;
1625
1626         /* Prefer static mappings over consuming a dynamic windows. */
1627         if (region && region->static_regwin) {
1628                 error = bhndb_activate_static_region(sc, region, child, type,
1629                     rid, r);
1630                 if (error)
1631                         device_printf(sc->dev, "static window allocation "
1632                              "for 0x%llx-0x%llx failed\n",
1633                              (unsigned long long) r_start,
1634                              (unsigned long long) r_start + r_size - 1);
1635                 return (error);
1636         }
1637
1638         /* A dynamic window will be required; is this resource high enough
1639          * priority to be reserved a dynamic window? */
1640         if (dw_priority < sc->bus_res->min_prio) {
1641                 if (indirect)
1642                         *indirect = true;
1643
1644                 return (ENOMEM);
1645         }
1646
1647         /* Find and retain a usable window */
1648         BHNDB_LOCK(sc); {
1649                 dwa = bhndb_retain_dynamic_window(sc, r);
1650         } BHNDB_UNLOCK(sc);
1651
1652         if (dwa == NULL) {
1653                 if (indirect)
1654                         *indirect = true;
1655                 return (ENOMEM);
1656         }
1657
1658         /* Configure resource with its real bus values. */
1659         parent_offset = dwa->win->win_offset;
1660         parent_offset += r_start - dwa->target;
1661
1662         error = bhndb_init_child_resource(r, dwa->parent_res, parent_offset,
1663             dwa->win->win_size);
1664         if (error)
1665                 goto failed;
1666
1667         /* Mark active */
1668         if ((error = rman_activate_resource(r)))
1669                 goto failed;
1670
1671         return (0);
1672
1673 failed:
1674         /* Release our region allocation. */
1675         BHNDB_LOCK(sc);
1676         bhndb_dw_release(sc->bus_res, dwa, r);
1677         BHNDB_UNLOCK(sc);
1678
1679         return (error);
1680 }
1681
1682 /**
1683  * Default bhndb(4) implementation of BUS_ACTIVATE_RESOURCE().
1684  *
1685  * Maps resource activation requests to a viable static or dynamic
1686  * register window, if any.
1687  */
1688 static int
1689 bhndb_activate_resource(device_t dev, device_t child, int type, int rid,
1690     struct resource *r)
1691 {
1692         struct bhndb_softc *sc = device_get_softc(dev);
1693
1694         /* Delegate directly to our parent device's bus if the requested
1695          * resource type isn't handled locally. */
1696         if (bhndb_get_rman(sc, child, type) == NULL) {
1697                 return (BUS_ACTIVATE_RESOURCE(device_get_parent(sc->parent_dev),
1698                     child, type, rid, r));
1699         }
1700
1701         return (bhndb_try_activate_resource(sc, child, type, rid, r, NULL));
1702 }
1703
1704 /**
1705  * Default bhndb(4) implementation of BUS_DEACTIVATE_RESOURCE().
1706  */
1707 static int
1708 bhndb_deactivate_resource(device_t dev, device_t child, int type,
1709     int rid, struct resource *r)
1710 {
1711         struct bhndb_dw_alloc   *dwa;
1712         struct bhndb_softc      *sc;
1713         struct rman             *rm;
1714         int                      error;
1715
1716         sc = device_get_softc(dev);
1717
1718         /* Delegate directly to our parent device's bus if the requested
1719          * resource type isn't handled locally. */
1720         rm = bhndb_get_rman(sc, child, type);
1721         if (rm == NULL) {
1722                 return (BUS_DEACTIVATE_RESOURCE(
1723                     device_get_parent(sc->parent_dev), child, type, rid, r));
1724         }
1725
1726         /* Mark inactive */
1727         if ((error = rman_deactivate_resource(r)))
1728                 return (error);
1729
1730         /* Free any dynamic window allocation. */
1731         if (bhndb_get_addrspace(sc, child) == BHNDB_ADDRSPACE_BRIDGED) {
1732                 BHNDB_LOCK(sc);
1733                 dwa = bhndb_dw_find_resource(sc->bus_res, r);
1734                 if (dwa != NULL)
1735                         bhndb_dw_release(sc->bus_res, dwa, r);
1736                 BHNDB_UNLOCK(sc);
1737         }
1738
1739         return (0);
1740 }
1741
1742 /**
1743  * Default bhndb(4) implementation of BUS_GET_RESOURCE_LIST().
1744  */
1745 static struct resource_list *
1746 bhndb_get_resource_list(device_t dev, device_t child)
1747 {
1748         struct bhndb_devinfo *dinfo = device_get_ivars(child);
1749         return (&dinfo->resources);
1750 }
1751
1752 /**
1753  * Default bhndb(4) implementation of BHND_BUS_ACTIVATE_RESOURCE().
1754  *
1755  * For BHNDB_ADDRSPACE_NATIVE children, all resources may be assumed to
1756  * be activated by the bridge.
1757  *
1758  * For BHNDB_ADDRSPACE_BRIDGED children, attempts to activate a static register
1759  * window, a dynamic register window, or configures @p r as an indirect
1760  * resource -- in that order.
1761  */
1762 static int
1763 bhndb_activate_bhnd_resource(device_t dev, device_t child,
1764     int type, int rid, struct bhnd_resource *r)
1765 {
1766         struct bhndb_softc      *sc;
1767         struct bhndb_region     *region;
1768         rman_res_t               r_start, r_size;
1769         int                      error;
1770         bool                     indirect;
1771
1772         KASSERT(!r->direct,
1773             ("direct flag set on inactive resource"));
1774
1775         KASSERT(!(rman_get_flags(r->res) & RF_ACTIVE),
1776             ("RF_ACTIVE set on inactive resource"));
1777
1778         sc = device_get_softc(dev);
1779
1780         /* Delegate directly to BUS_ACTIVATE_RESOURCE() if the requested
1781          * resource type isn't handled locally. */
1782         if (bhndb_get_rman(sc, child, type) == NULL) {
1783                 error = BUS_ACTIVATE_RESOURCE(dev, child, type, rid, r->res);
1784                 if (error == 0)
1785                         r->direct = true;
1786                 return (error);
1787         }
1788
1789         r_start = rman_get_start(r->res);
1790         r_size = rman_get_size(r->res);
1791
1792         /* Verify bridged address range's resource priority, and skip direct
1793          * allocation if the priority is too low. */
1794         if (bhndb_get_addrspace(sc, child) == BHNDB_ADDRSPACE_BRIDGED) {
1795                 bhndb_priority_t r_prio;
1796
1797                 region = bhndb_find_resource_region(sc->bus_res, r_start,
1798                     r_size);
1799                 if (region != NULL)
1800                         r_prio = region->priority;
1801                 else
1802                         r_prio = BHNDB_PRIORITY_NONE;
1803
1804                 /* If less than the minimum dynamic window priority, this
1805                  * resource should always be indirect. */
1806                 if (r_prio < sc->bus_res->min_prio)
1807                         return (0);
1808         }
1809
1810         /* Attempt direct activation */
1811         error = bhndb_try_activate_resource(sc, child, type, rid, r->res,
1812             &indirect);
1813         if (!error) {
1814                 r->direct = true;
1815         } else if (indirect) {
1816                 /* The request was valid, but no viable register window is
1817                  * available; indirection must be employed. */
1818                 error = 0;
1819                 r->direct = false;
1820         }
1821
1822         if (BHNDB_DEBUG(PRIO) &&
1823             bhndb_get_addrspace(sc, child) == BHNDB_ADDRSPACE_BRIDGED)
1824         {
1825                 device_printf(child, "activated 0x%llx-0x%llx as %s "
1826                     "resource\n",
1827                     (unsigned long long) r_start,
1828                     (unsigned long long) r_start + r_size - 1,
1829                     r->direct ? "direct" : "indirect");
1830         }
1831
1832         return (error);
1833 }
1834
1835 /**
1836  * Default bhndb(4) implementation of BHND_BUS_DEACTIVATE_RESOURCE().
1837  */
1838 static int
1839 bhndb_deactivate_bhnd_resource(device_t dev, device_t child,
1840     int type, int rid, struct bhnd_resource *r)
1841 {
1842         int error;
1843
1844         /* Indirect resources don't require activation */
1845         if (!r->direct)
1846                 return (0);
1847
1848         KASSERT(rman_get_flags(r->res) & RF_ACTIVE,
1849             ("RF_ACTIVE not set on direct resource"));
1850
1851         /* Perform deactivation */
1852         error = BUS_DEACTIVATE_RESOURCE(dev, child, type, rid, r->res);
1853         if (!error)
1854                 r->direct = false;
1855
1856         return (error);
1857 }
1858
1859 /**
1860  * Slow path for bhndb_io_resource().
1861  *
1862  * Iterates over the existing allocated dynamic windows looking for a viable
1863  * in-use region; the first matching region is returned.
1864  */
1865 static struct bhndb_dw_alloc *
1866 bhndb_io_resource_slow(struct bhndb_softc *sc, bus_addr_t addr,
1867     bus_size_t size, bus_size_t *offset)
1868 {
1869         struct bhndb_resources  *br;
1870         struct bhndb_dw_alloc   *dwa;
1871
1872         BHNDB_LOCK_ASSERT(sc, MA_OWNED);
1873
1874         br = sc->bus_res;
1875
1876         /* Search for an existing dynamic mapping of this address range.
1877          * Static regions are not searched, as a statically mapped
1878          * region would never be allocated as an indirect resource. */
1879         for (size_t i = 0; i < br->dwa_count; i++) {
1880                 const struct bhndb_regwin *win;
1881
1882                 dwa = &br->dw_alloc[i];
1883                 win = dwa->win;
1884
1885                 KASSERT(win->win_type == BHNDB_REGWIN_T_DYN,
1886                         ("invalid register window type"));
1887
1888                 /* Verify the range */
1889                 if (addr < dwa->target)
1890                         continue;
1891
1892                 if (addr + size > dwa->target + win->win_size)
1893                         continue;
1894
1895                 /* Found */
1896                 *offset = dwa->win->win_offset;
1897                 *offset += addr - dwa->target;
1898
1899                 return (dwa);
1900         }
1901
1902         /* not found */
1903         return (NULL);
1904 }
1905
1906 /**
1907  * Return a borrowed reference to a bridge resource allocation record capable
1908  * of handling bus I/O requests of @p size at @p addr.
1909  *
1910  * This will either return a  reference to an existing allocation
1911  * record mapping the requested space, or will configure and return a free
1912  * allocation record.
1913  *
1914  * Will panic if a usable record cannot be found.
1915  *
1916  * @param sc Bridge driver state.
1917  * @param addr The I/O target address.
1918  * @param size The size of the I/O operation to be performed at @p addr.
1919  * @param[out] offset The offset within the returned resource at which
1920  * to perform the I/O request.
1921  */
1922 static inline struct bhndb_dw_alloc *
1923 bhndb_io_resource(struct bhndb_softc *sc, bus_addr_t addr, bus_size_t size,
1924     bus_size_t *offset)
1925 {
1926         struct bhndb_resources  *br;
1927         struct bhndb_dw_alloc   *dwa;
1928         int                      error;
1929
1930         BHNDB_LOCK_ASSERT(sc, MA_OWNED);
1931
1932         br = sc->bus_res;
1933
1934         /* Try to fetch a free window */
1935         dwa = bhndb_dw_next_free(br);
1936
1937         /*
1938          * If no dynamic windows are available, look for an existing
1939          * region that maps the target range.
1940          *
1941          * If none are found, this is a child driver bug -- our window
1942          * over-commit should only fail in the case where a child driver leaks
1943          * resources, or perform operations out-of-order.
1944          *
1945          * Broadcom HND chipsets are designed to not require register window
1946          * swapping during execution; as long as the child devices are
1947          * attached/detached correctly, using the hardware's required order
1948          * of operations, there should always be a window available for the
1949          * current operation.
1950          */
1951         if (dwa == NULL) {
1952                 dwa = bhndb_io_resource_slow(sc, addr, size, offset);
1953                 if (dwa == NULL) {
1954                         panic("register windows exhausted attempting to map "
1955                             "0x%llx-0x%llx\n",
1956                             (unsigned long long) addr,
1957                             (unsigned long long) addr+size-1);
1958                 }
1959
1960                 return (dwa);
1961         }
1962
1963         /* Adjust the window if the I/O request won't fit in the current
1964          * target range. */
1965         if (addr < dwa->target ||
1966             addr > dwa->target + dwa->win->win_size ||
1967             (dwa->target + dwa->win->win_size) - addr < size)
1968         {
1969                 error = bhndb_dw_set_addr(sc->dev, sc->bus_res, dwa, addr,
1970                     size);
1971                 if (error) {
1972                     panic("failed to set register window target mapping "
1973                             "0x%llx-0x%llx\n",
1974                             (unsigned long long) addr,
1975                             (unsigned long long) addr+size-1);
1976                 }
1977         }
1978
1979         /* Calculate the offset and return */
1980         *offset = (addr - dwa->target) + dwa->win->win_offset;
1981         return (dwa);
1982 }
1983
1984 /*
1985  * BHND_BUS_(READ|WRITE_* implementations
1986  */
1987
1988 /* bhndb_bus_(read|write) common implementation */
1989 #define BHNDB_IO_COMMON_SETUP(_io_size)                         \
1990         struct bhndb_softc      *sc;                            \
1991         struct bhndb_dw_alloc   *dwa;                           \
1992         struct resource         *io_res;                        \
1993         bus_size_t               io_offset;                     \
1994                                                                 \
1995         sc = device_get_softc(dev);                             \
1996                                                                 \
1997         BHNDB_LOCK(sc);                                         \
1998         dwa = bhndb_io_resource(sc, rman_get_start(r->res) +    \
1999             offset, _io_size, &io_offset);                      \
2000         io_res = dwa->parent_res;                               \
2001                                                                 \
2002         KASSERT(!r->direct,                                     \
2003             ("bhnd_bus slow path used for direct resource"));   \
2004                                                                 \
2005         KASSERT(rman_get_flags(io_res) & RF_ACTIVE,             \
2006             ("i/o resource is not active"));
2007
2008 #define BHNDB_IO_COMMON_TEARDOWN()                              \
2009         BHNDB_UNLOCK(sc);
2010
2011 /* Defines a bhndb_bus_read_* method implementation */
2012 #define BHNDB_IO_READ(_type, _name)                             \
2013 static _type                                                    \
2014 bhndb_bus_read_ ## _name (device_t dev, device_t child,         \
2015     struct bhnd_resource *r, bus_size_t offset)                 \
2016 {                                                               \
2017         _type v;                                                \
2018         BHNDB_IO_COMMON_SETUP(sizeof(_type));                   \
2019         v = bus_read_ ## _name (io_res, io_offset);             \
2020         BHNDB_IO_COMMON_TEARDOWN();                             \
2021                                                                 \
2022         return (v);                                             \
2023 }
2024
2025 /* Defines a bhndb_bus_write_* method implementation */
2026 #define BHNDB_IO_WRITE(_type, _name)                            \
2027 static void                                                     \
2028 bhndb_bus_write_ ## _name (device_t dev, device_t child,        \
2029     struct bhnd_resource *r, bus_size_t offset, _type value)    \
2030 {                                                               \
2031         BHNDB_IO_COMMON_SETUP(sizeof(_type));                   \
2032         bus_write_ ## _name (io_res, io_offset, value);         \
2033         BHNDB_IO_COMMON_TEARDOWN();                             \
2034 }
2035
2036 /* Defines a bhndb_bus_(read|write|set)_(multi|region)_* method */
2037 #define BHNDB_IO_MISC(_type, _ptr, _op, _size)                  \
2038 static void                                                     \
2039 bhndb_bus_ ## _op ## _ ## _size (device_t dev,                  \
2040     device_t child, struct bhnd_resource *r, bus_size_t offset, \
2041     _type _ptr datap, bus_size_t count)                         \
2042 {                                                               \
2043         BHNDB_IO_COMMON_SETUP(sizeof(_type) * count);           \
2044         bus_ ## _op ## _ ## _size (io_res, io_offset,           \
2045             datap, count);                                      \
2046         BHNDB_IO_COMMON_TEARDOWN();                             \
2047 }
2048
2049 /* Defines a complete set of read/write methods */
2050 #define BHNDB_IO_METHODS(_type, _size)                          \
2051         BHNDB_IO_READ(_type, _size)                             \
2052         BHNDB_IO_WRITE(_type, _size)                            \
2053                                                                 \
2054         BHNDB_IO_READ(_type, stream_ ## _size)                  \
2055         BHNDB_IO_WRITE(_type, stream_ ## _size)                 \
2056                                                                 \
2057         BHNDB_IO_MISC(_type, *, read_multi, _size)              \
2058         BHNDB_IO_MISC(_type, *, write_multi, _size)             \
2059                                                                 \
2060         BHNDB_IO_MISC(_type, *, read_multi_stream, _size)       \
2061         BHNDB_IO_MISC(_type, *, write_multi_stream, _size)      \
2062                                                                 \
2063         BHNDB_IO_MISC(_type,  , set_multi, _size)               \
2064         BHNDB_IO_MISC(_type,  , set_region, _size)              \
2065         BHNDB_IO_MISC(_type, *, read_region, _size)             \
2066         BHNDB_IO_MISC(_type, *, write_region, _size)            \
2067                                                                 \
2068         BHNDB_IO_MISC(_type, *, read_region_stream, _size)      \
2069         BHNDB_IO_MISC(_type, *, write_region_stream, _size)
2070
2071 BHNDB_IO_METHODS(uint8_t, 1);
2072 BHNDB_IO_METHODS(uint16_t, 2);
2073 BHNDB_IO_METHODS(uint32_t, 4);
2074
2075 /**
2076  * Default bhndb(4) implementation of BHND_BUS_BARRIER().
2077  */
2078 static void
2079 bhndb_bus_barrier(device_t dev, device_t child, struct bhnd_resource *r,
2080     bus_size_t offset, bus_size_t length, int flags)
2081 {
2082         BHNDB_IO_COMMON_SETUP(length);
2083
2084         bus_barrier(io_res, io_offset + offset, length, flags);
2085
2086         BHNDB_IO_COMMON_TEARDOWN();
2087 }
2088
2089 /**
2090  * Default bhndb(4) implementation of BUS_GET_DMA_TAG().
2091  */
2092 static bus_dma_tag_t
2093 bhndb_get_dma_tag(device_t dev, device_t child)
2094 {
2095         // TODO
2096         return (NULL);
2097 }
2098
2099 static device_method_t bhndb_methods[] = {
2100         /* Device interface */ \
2101         DEVMETHOD(device_probe,                 bhndb_generic_probe),
2102         DEVMETHOD(device_detach,                bhndb_generic_detach),
2103         DEVMETHOD(device_shutdown,              bus_generic_shutdown),
2104         DEVMETHOD(device_suspend,               bhndb_generic_suspend),
2105         DEVMETHOD(device_resume,                bhndb_generic_resume),
2106
2107         /* Bus interface */
2108         DEVMETHOD(bus_probe_nomatch,            bhndb_probe_nomatch),
2109         DEVMETHOD(bus_print_child,              bhndb_print_child),
2110         DEVMETHOD(bus_child_pnpinfo_str,        bhndb_child_pnpinfo_str),
2111         DEVMETHOD(bus_child_location_str,       bhndb_child_location_str),
2112         DEVMETHOD(bus_add_child,                bhndb_add_child),
2113         DEVMETHOD(bus_child_deleted,            bhndb_child_deleted),
2114
2115         DEVMETHOD(bus_alloc_resource,           bhndb_alloc_resource),
2116         DEVMETHOD(bus_release_resource,         bhndb_release_resource),
2117         DEVMETHOD(bus_activate_resource,        bhndb_activate_resource),
2118         DEVMETHOD(bus_deactivate_resource,      bhndb_deactivate_resource),
2119
2120         DEVMETHOD(bus_setup_intr,               bus_generic_setup_intr),
2121         DEVMETHOD(bus_teardown_intr,            bus_generic_teardown_intr),
2122         DEVMETHOD(bus_config_intr,              bus_generic_config_intr),
2123         DEVMETHOD(bus_bind_intr,                bus_generic_bind_intr),
2124         DEVMETHOD(bus_describe_intr,            bus_generic_describe_intr),
2125
2126         DEVMETHOD(bus_get_dma_tag,              bhndb_get_dma_tag),
2127
2128         DEVMETHOD(bus_adjust_resource,          bhndb_adjust_resource),
2129         DEVMETHOD(bus_set_resource,             bus_generic_rl_set_resource),
2130         DEVMETHOD(bus_get_resource,             bus_generic_rl_get_resource),
2131         DEVMETHOD(bus_delete_resource,          bus_generic_rl_delete_resource),
2132         DEVMETHOD(bus_get_resource_list,        bhndb_get_resource_list),
2133
2134         DEVMETHOD(bus_read_ivar,                bhndb_read_ivar),
2135         DEVMETHOD(bus_write_ivar,               bhndb_write_ivar),
2136
2137         /* BHNDB interface */
2138         DEVMETHOD(bhndb_get_chipid,             bhndb_get_chipid),
2139         DEVMETHOD(bhndb_is_core_disabled,       bhndb_is_core_disabled),
2140         DEVMETHOD(bhndb_get_hostb_core,         bhndb_get_hostb_core),
2141         DEVMETHOD(bhndb_suspend_resource,       bhndb_suspend_resource),
2142         DEVMETHOD(bhndb_resume_resource,        bhndb_resume_resource),
2143
2144         /* BHND interface */
2145         DEVMETHOD(bhnd_bus_get_chipid,          bhndb_get_chipid),
2146         DEVMETHOD(bhnd_bus_activate_resource,   bhndb_activate_bhnd_resource),
2147         DEVMETHOD(bhnd_bus_deactivate_resource, bhndb_deactivate_bhnd_resource),
2148         DEVMETHOD(bhnd_bus_get_nvram_var,       bhnd_bus_generic_get_nvram_var),
2149         DEVMETHOD(bhnd_bus_read_1,              bhndb_bus_read_1),
2150         DEVMETHOD(bhnd_bus_read_2,              bhndb_bus_read_2),
2151         DEVMETHOD(bhnd_bus_read_4,              bhndb_bus_read_4),
2152         DEVMETHOD(bhnd_bus_write_1,             bhndb_bus_write_1),
2153         DEVMETHOD(bhnd_bus_write_2,             bhndb_bus_write_2),
2154         DEVMETHOD(bhnd_bus_write_4,             bhndb_bus_write_4),
2155
2156         DEVMETHOD(bhnd_bus_read_stream_1,       bhndb_bus_read_stream_1),
2157         DEVMETHOD(bhnd_bus_read_stream_2,       bhndb_bus_read_stream_2),
2158         DEVMETHOD(bhnd_bus_read_stream_4,       bhndb_bus_read_stream_4),
2159         DEVMETHOD(bhnd_bus_write_stream_1,      bhndb_bus_write_stream_1),
2160         DEVMETHOD(bhnd_bus_write_stream_2,      bhndb_bus_write_stream_2),
2161         DEVMETHOD(bhnd_bus_write_stream_4,      bhndb_bus_write_stream_4),
2162
2163         DEVMETHOD(bhnd_bus_read_multi_1,        bhndb_bus_read_multi_1),
2164         DEVMETHOD(bhnd_bus_read_multi_2,        bhndb_bus_read_multi_2),
2165         DEVMETHOD(bhnd_bus_read_multi_4,        bhndb_bus_read_multi_4),
2166         DEVMETHOD(bhnd_bus_write_multi_1,       bhndb_bus_write_multi_1),
2167         DEVMETHOD(bhnd_bus_write_multi_2,       bhndb_bus_write_multi_2),
2168         DEVMETHOD(bhnd_bus_write_multi_4,       bhndb_bus_write_multi_4),
2169
2170         DEVMETHOD(bhnd_bus_read_multi_stream_1, bhndb_bus_read_multi_stream_1),
2171         DEVMETHOD(bhnd_bus_read_multi_stream_2, bhndb_bus_read_multi_stream_2),
2172         DEVMETHOD(bhnd_bus_read_multi_stream_4, bhndb_bus_read_multi_stream_4),
2173         DEVMETHOD(bhnd_bus_write_multi_stream_1,bhndb_bus_write_multi_stream_1),
2174         DEVMETHOD(bhnd_bus_write_multi_stream_2,bhndb_bus_write_multi_stream_2),
2175         DEVMETHOD(bhnd_bus_write_multi_stream_4,bhndb_bus_write_multi_stream_4),
2176
2177         DEVMETHOD(bhnd_bus_set_multi_1,         bhndb_bus_set_multi_1),
2178         DEVMETHOD(bhnd_bus_set_multi_2,         bhndb_bus_set_multi_2),
2179         DEVMETHOD(bhnd_bus_set_multi_4,         bhndb_bus_set_multi_4),
2180         DEVMETHOD(bhnd_bus_set_region_1,        bhndb_bus_set_region_1),
2181         DEVMETHOD(bhnd_bus_set_region_2,        bhndb_bus_set_region_2),
2182         DEVMETHOD(bhnd_bus_set_region_4,        bhndb_bus_set_region_4),
2183
2184         DEVMETHOD(bhnd_bus_read_region_1,       bhndb_bus_read_region_1),
2185         DEVMETHOD(bhnd_bus_read_region_2,       bhndb_bus_read_region_2),
2186         DEVMETHOD(bhnd_bus_read_region_4,       bhndb_bus_read_region_4),
2187         DEVMETHOD(bhnd_bus_write_region_1,      bhndb_bus_write_region_1),
2188         DEVMETHOD(bhnd_bus_write_region_2,      bhndb_bus_write_region_2),
2189         DEVMETHOD(bhnd_bus_write_region_4,      bhndb_bus_write_region_4),
2190
2191         DEVMETHOD(bhnd_bus_read_region_stream_1,bhndb_bus_read_region_stream_1),
2192         DEVMETHOD(bhnd_bus_read_region_stream_2,bhndb_bus_read_region_stream_2),
2193         DEVMETHOD(bhnd_bus_read_region_stream_4,bhndb_bus_read_region_stream_4),
2194         DEVMETHOD(bhnd_bus_write_region_stream_1,bhndb_bus_write_region_stream_1),
2195         DEVMETHOD(bhnd_bus_write_region_stream_2,bhndb_bus_write_region_stream_2),
2196         DEVMETHOD(bhnd_bus_write_region_stream_4,bhndb_bus_write_region_stream_4),
2197
2198         DEVMETHOD(bhnd_bus_barrier,             bhndb_bus_barrier),
2199
2200         DEVMETHOD_END
2201 };
2202
2203 devclass_t bhndb_devclass;
2204
2205 DEFINE_CLASS_0(bhndb, bhndb_driver, bhndb_methods, sizeof(struct bhndb_softc));
2206
2207 MODULE_VERSION(bhndb, 1);
2208 MODULE_DEPEND(bhndb, bhnd, 1, 1, 1);