sys/dev/bhnd/bhnd_subr.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2015-2016 Landon Fuller <landon@landonf.org>
   5  * Copyright (c) 2017 The FreeBSD Foundation
   6  * All rights reserved.
   7  *
   8  * Portions of this software were developed by Landon Fuller
   9  * under sponsorship from the FreeBSD Foundation.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  19  *    redistribution must be conditioned upon including a substantially
  20  *    similar Disclaimer requirement for further binary redistribution.
  21  *
  22  * NO WARRANTY
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  26  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  27  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  28  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  31  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  33  * THE POSSIBILITY OF SUCH DAMAGES.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include <sys/param.h>
  40 #include <sys/bus.h>
  41 #include <sys/refcount.h>
  42 #include <sys/systm.h>
  43
  44 #include <machine/bus.h>
  45 #include <sys/rman.h>
  46 #include <machine/resource.h>
  47
  48 #include <dev/bhnd/siba/sibareg.h>
  49
  50 #include <dev/bhnd/cores/chipc/chipcreg.h>
  51
  52 #include "nvram/bhnd_nvram.h"
  53
  54 #include "bhnd_chipc_if.h"
  55
  56 #include "bhnd_nvram_if.h"
  57 #include "bhnd_nvram_map.h"
  58
  59 #include "bhndreg.h"
  60 #include "bhndvar.h"
  61 #include "bhnd_private.h"
  62
  63 static void     bhnd_service_registry_free_entry(
  64                     struct bhnd_service_entry *entry);
  65
  66 static int      compare_ascending_probe_order(const void *lhs, const void *rhs);
  67 static int      compare_descending_probe_order(const void *lhs,
  68                     const void *rhs);
  69
  70 /* BHND core device description table. */
  71 static const struct bhnd_core_desc {
  72         uint16_t         vendor;
  73         uint16_t         device;
  74         bhnd_devclass_t  class;
  75         const char      *desc;
  76 } bhnd_core_descs[] = {
  77         #define BHND_CDESC(_mfg, _cid, _cls, _desc)             \
  78             { BHND_MFGID_ ## _mfg, BHND_COREID_ ## _cid,        \
  79                 BHND_DEVCLASS_ ## _cls, _desc }
  80
  81         BHND_CDESC(BCM, CC,             CC,             "ChipCommon I/O Controller"),
  82         BHND_CDESC(BCM, ILINE20,        OTHER,          "iLine20 HPNA"),
  83         BHND_CDESC(BCM, SRAM,           RAM,            "SRAM"),
  84         BHND_CDESC(BCM, SDRAM,          RAM,            "SDRAM"),
  85         BHND_CDESC(BCM, PCI,            PCI,            "PCI Bridge"),
  86         BHND_CDESC(BCM, MIPS,           CPU,            "BMIPS CPU"),
  87         BHND_CDESC(BCM, ENET,           ENET_MAC,       "Fast Ethernet MAC"),
  88         BHND_CDESC(BCM, V90_CODEC,      SOFTMODEM,      "V.90 SoftModem Codec"),
  89         BHND_CDESC(BCM, USB,            USB_DUAL,       "USB 1.1 Device/Host Controller"),
  90         BHND_CDESC(BCM, ADSL,           OTHER,          "ADSL Core"),
  91         BHND_CDESC(BCM, ILINE100,       OTHER,          "iLine100 HPNA"),
  92         BHND_CDESC(BCM, IPSEC,          OTHER,          "IPsec Accelerator"),
  93         BHND_CDESC(BCM, UTOPIA,         OTHER,          "UTOPIA ATM Core"),
  94         BHND_CDESC(BCM, PCMCIA,         PCCARD,         "PCMCIA Bridge"),
  95         BHND_CDESC(BCM, SOCRAM,         RAM,            "Internal Memory"),
  96         BHND_CDESC(BCM, MEMC,           MEMC,           "MEMC SDRAM Controller"),
  97         BHND_CDESC(BCM, OFDM,           OTHER,          "OFDM PHY"),
  98         BHND_CDESC(BCM, EXTIF,          OTHER,          "External Interface"),
  99         BHND_CDESC(BCM, D11,            WLAN,           "802.11 MAC/PHY/Radio"),
 100         BHND_CDESC(BCM, APHY,           WLAN_PHY,       "802.11a PHY"),
 101         BHND_CDESC(BCM, BPHY,           WLAN_PHY,       "802.11b PHY"),
 102         BHND_CDESC(BCM, GPHY,           WLAN_PHY,       "802.11g PHY"),
 103         BHND_CDESC(BCM, MIPS33,         CPU,            "BMIPS33 CPU"),
 104         BHND_CDESC(BCM, USB11H,         USB_HOST,       "USB 1.1 Host Controller"),
 105         BHND_CDESC(BCM, USB11D,         USB_DEV,        "USB 1.1 Device Controller"),
 106         BHND_CDESC(BCM, USB20H,         USB_HOST,       "USB 2.0 Host Controller"),
 107         BHND_CDESC(BCM, USB20D,         USB_DEV,        "USB 2.0 Device Controller"),
 108         BHND_CDESC(BCM, SDIOH,          OTHER,          "SDIO Host Controller"),
 109         BHND_CDESC(BCM, ROBO,           OTHER,          "RoboSwitch"),
 110         BHND_CDESC(BCM, ATA100,         OTHER,          "Parallel ATA Controller"),
 111         BHND_CDESC(BCM, SATAXOR,        OTHER,          "SATA DMA/XOR Controller"),
 112         BHND_CDESC(BCM, GIGETH,         ENET_MAC,       "Gigabit Ethernet MAC"),
 113         BHND_CDESC(BCM, PCIE,           PCIE,           "PCIe Bridge"),
 114         BHND_CDESC(BCM, NPHY,           WLAN_PHY,       "802.11n 2x2 PHY"),
 115         BHND_CDESC(BCM, SRAMC,          MEMC,           "SRAM Controller"),
 116         BHND_CDESC(BCM, MINIMAC,        OTHER,          "MINI MAC/PHY"),
 117         BHND_CDESC(BCM, ARM11,          CPU,            "ARM1176 CPU"),
 118         BHND_CDESC(BCM, ARM7S,          CPU,            "ARM7TDMI-S CPU"),
 119         BHND_CDESC(BCM, LPPHY,          WLAN_PHY,       "802.11a/b/g PHY"),
 120         BHND_CDESC(BCM, PMU,            PMU,            "PMU"),
 121         BHND_CDESC(BCM, SSNPHY,         WLAN_PHY,       "802.11n Single-Stream PHY"),
 122         BHND_CDESC(BCM, SDIOD,          OTHER,          "SDIO Device Core"),
 123         BHND_CDESC(BCM, ARMCM3,         CPU,            "ARM Cortex-M3 CPU"),
 124         BHND_CDESC(BCM, HTPHY,          WLAN_PHY,       "802.11n 4x4 PHY"),
 125         BHND_CDESC(MIPS,MIPS74K,        CPU,            "MIPS74k CPU"),
 126         BHND_CDESC(BCM, GMAC,           ENET_MAC,       "Gigabit MAC core"),
 127         BHND_CDESC(BCM, DMEMC,          MEMC,           "DDR1/DDR2 Memory Controller"),
 128         BHND_CDESC(BCM, PCIERC,         OTHER,          "PCIe Root Complex"),
 129         BHND_CDESC(BCM, OCP,            SOC_BRIDGE,     "OCP to OCP Bridge"),
 130         BHND_CDESC(BCM, SC,             OTHER,          "Shared Common Core"),
 131         BHND_CDESC(BCM, AHB,            SOC_BRIDGE,     "OCP to AHB Bridge"),
 132         BHND_CDESC(BCM, SPIH,           OTHER,          "SPI Host Controller"),
 133         BHND_CDESC(BCM, I2S,            OTHER,          "I2S Digital Audio Interface"),
 134         BHND_CDESC(BCM, DMEMS,          MEMC,           "SDR/DDR1 Memory Controller"),
 135         BHND_CDESC(BCM, UBUS_SHIM,      OTHER,          "BCM6362/UBUS WLAN SHIM"),
 136         BHND_CDESC(BCM, PCIE2,          PCIE,           "PCIe Bridge (Gen2)"),
 137
 138         BHND_CDESC(ARM, APB_BRIDGE,     SOC_BRIDGE,     "BP135 AMBA3 AXI to APB Bridge"),
 139         BHND_CDESC(ARM, PL301,          SOC_ROUTER,     "PL301 AMBA3 Interconnect"),
 140         BHND_CDESC(ARM, EROM,           EROM,           "PL366 Device Enumeration ROM"),
 141         BHND_CDESC(ARM, OOB_ROUTER,     OTHER,          "PL367 OOB Interrupt Router"),
 142         BHND_CDESC(ARM, AXI_UNMAPPED,   OTHER,          "Unmapped Address Ranges"),
 143
 144         BHND_CDESC(BCM, 4706_CC,        CC,             "ChipCommon I/O Controller"),
 145         BHND_CDESC(BCM, NS_PCIE2,       PCIE,           "PCIe Bridge (Gen2)"),
 146         BHND_CDESC(BCM, NS_DMA,         OTHER,          "DMA engine"),
 147         BHND_CDESC(BCM, NS_SDIO,        OTHER,          "SDIO 3.0 Host Controller"),
 148         BHND_CDESC(BCM, NS_USB20H,      USB_HOST,       "USB 2.0 Host Controller"),
 149         BHND_CDESC(BCM, NS_USB30H,      USB_HOST,       "USB 3.0 Host Controller"),
 150         BHND_CDESC(BCM, NS_A9JTAG,      OTHER,          "ARM Cortex A9 JTAG Interface"),
 151         BHND_CDESC(BCM, NS_DDR23_MEMC,  MEMC,           "Denali DDR2/DD3 Memory Controller"),
 152         BHND_CDESC(BCM, NS_ROM,         NVRAM,          "System ROM"),
 153         BHND_CDESC(BCM, NS_NAND,        NVRAM,          "NAND Flash Controller"),
 154         BHND_CDESC(BCM, NS_QSPI,        NVRAM,          "QSPI Flash Controller"),
 155         BHND_CDESC(BCM, NS_CC_B,        CC_B,           "ChipCommon B Auxiliary I/O Controller"),
 156         BHND_CDESC(BCM, 4706_SOCRAM,    RAM,            "Internal Memory"),
 157         BHND_CDESC(BCM, IHOST_ARMCA9,   CPU,            "ARM Cortex A9 CPU"),
 158         BHND_CDESC(BCM, 4706_GMAC_CMN,  ENET,           "Gigabit MAC (Common)"),
 159         BHND_CDESC(BCM, 4706_GMAC,      ENET_MAC,       "Gigabit MAC"),
 160         BHND_CDESC(BCM, AMEMC,          MEMC,           "Denali DDR1/DDR2 Memory Controller"),
 161 #undef  BHND_CDESC
 162
 163         /* Derived from inspection of the BCM4331 cores that provide PrimeCell
 164          * IDs. Due to lack of documentation, the surmised device name/purpose
 165          * provided here may be incorrect. */
 166         { BHND_MFGID_ARM,       BHND_PRIMEID_EROM,      BHND_DEVCLASS_OTHER,
 167             "PL364 Device Enumeration ROM" },
 168         { BHND_MFGID_ARM,       BHND_PRIMEID_SWRAP,     BHND_DEVCLASS_OTHER,
 169             "PL368 Device Management Interface" },
 170         { BHND_MFGID_ARM,       BHND_PRIMEID_MWRAP,     BHND_DEVCLASS_OTHER,
 171             "PL369 Device Management Interface" },
 172
 173         { 0, 0, 0, NULL }
 174 };
 175
 176 static const struct bhnd_device_quirk bhnd_chipc_clkctl_quirks[];
 177 static const struct bhnd_device_quirk bhnd_pcmcia_clkctl_quirks[];
 178
 179 /**
 180  * Device table entries for core-specific CLKCTL quirk lookup.
 181  */
 182 static const struct bhnd_device bhnd_clkctl_devices[] = {
 183         BHND_DEVICE(BCM, CC,            NULL,   bhnd_chipc_clkctl_quirks),
 184         BHND_DEVICE(BCM, PCMCIA,        NULL,   bhnd_pcmcia_clkctl_quirks),
 185         BHND_DEVICE_END,
 186 };
 187
 188 /** ChipCommon CLKCTL quirks */
 189 static const struct bhnd_device_quirk bhnd_chipc_clkctl_quirks[] = {
 190         /* HTAVAIL/ALPAVAIL are bitswapped in chipc's CLKCTL */
 191         BHND_CHIP_QUIRK(4328,   HWREV_ANY,      BHND_CLKCTL_QUIRK_CCS0),
 192         BHND_CHIP_QUIRK(5354,   HWREV_ANY,      BHND_CLKCTL_QUIRK_CCS0),
 193         BHND_DEVICE_QUIRK_END
 194 };
 195
 196 /** PCMCIA CLKCTL quirks */
 197 static const struct bhnd_device_quirk bhnd_pcmcia_clkctl_quirks[] = {
 198         /* HTAVAIL/ALPAVAIL are bitswapped in pcmcia's CLKCTL */
 199         BHND_CHIP_QUIRK(4328,   HWREV_ANY,      BHND_CLKCTL_QUIRK_CCS0),
 200         BHND_CHIP_QUIRK(5354,   HWREV_ANY,      BHND_CLKCTL_QUIRK_CCS0),
 201         BHND_DEVICE_QUIRK_END
 202 };
 203
 204 /**
 205  * Return the name for a given JEP106 manufacturer ID.
 206  *
 207  * @param vendor A JEP106 Manufacturer ID, including the non-standard ARM 4-bit
 208  * JEP106 continuation code.
 209  */
 210 const char *
 211 bhnd_vendor_name(uint16_t vendor)
 212 {
 213         switch (vendor) {
 214         case BHND_MFGID_ARM:
 215                 return "ARM";
 216         case BHND_MFGID_BCM:
 217                 return "Broadcom";
 218         case BHND_MFGID_MIPS:
 219                 return "MIPS";
 220         default:
 221                 return "unknown";
 222         }
 223 }
 224
 225 /**
 226  * Return the name of a port type.
 227  *
 228  * @param port_type The port type to look up.
 229  */
 230 const char *
 231 bhnd_port_type_name(bhnd_port_type port_type)
 232 {
 233         switch (port_type) {
 234         case BHND_PORT_DEVICE:
 235                 return ("device");
 236         case BHND_PORT_BRIDGE:
 237                 return ("bridge");
 238         case BHND_PORT_AGENT:
 239                 return ("agent");
 240         default:
 241                 return "unknown";
 242         }
 243 }
 244
 245 /**
 246  * Return the name of an NVRAM source.
 247  *
 248  * @param nvram_src The NVRAM source type to look up.
 249  */
 250 const char *
 251 bhnd_nvram_src_name(bhnd_nvram_src nvram_src)
 252 {
 253         switch (nvram_src) {
 254         case BHND_NVRAM_SRC_FLASH:
 255                 return ("flash");
 256         case BHND_NVRAM_SRC_OTP:
 257                 return ("OTP");
 258         case BHND_NVRAM_SRC_SPROM:
 259                 return ("SPROM");
 260         case BHND_NVRAM_SRC_UNKNOWN:
 261                 return ("none");
 262         default:
 263                 return ("unknown");
 264         }
 265 }
 266
 267 static const struct bhnd_core_desc *
 268 bhnd_find_core_desc(uint16_t vendor, uint16_t device)
 269 {
 270         for (u_int i = 0; bhnd_core_descs[i].desc != NULL; i++) {
 271                 if (bhnd_core_descs[i].vendor != vendor)
 272                         continue;
 273
 274                 if (bhnd_core_descs[i].device != device)
 275                         continue;
 276
 277                 return (&bhnd_core_descs[i]);
 278         }
 279
 280         return (NULL);
 281 }
 282
 283 /**
 284  * Return a human-readable name for a BHND core.
 285  *
 286  * @param vendor The core designer's JEDEC-106 Manufacturer ID.
 287  * @param device The core identifier.
 288  */
 289 const char *
 290 bhnd_find_core_name(uint16_t vendor, uint16_t device)
 291 {
 292         const struct bhnd_core_desc *desc;
 293
 294         if ((desc = bhnd_find_core_desc(vendor, device)) == NULL)
 295                 return ("unknown");
 296
 297         return desc->desc;
 298 }
 299
 300 /**
 301  * Return the device class for a BHND core.
 302  *
 303  * @param vendor The core designer's JEDEC-106 Manufacturer ID.
 304  * @param device The core identifier.
 305  */
 306 bhnd_devclass_t
 307 bhnd_find_core_class(uint16_t vendor, uint16_t device)
 308 {
 309         const struct bhnd_core_desc *desc;
 310
 311         if ((desc = bhnd_find_core_desc(vendor, device)) == NULL)
 312                 return (BHND_DEVCLASS_OTHER);
 313
 314         return desc->class;
 315 }
 316
 317 /**
 318  * Return a human-readable name for a BHND core.
 319  *
 320  * @param ci The core's info record.
 321  */
 322 const char *
 323 bhnd_core_name(const struct bhnd_core_info *ci)
 324 {
 325         return bhnd_find_core_name(ci->vendor, ci->device);
 326 }
 327
 328 /**
 329  * Return the device class for a BHND core.
 330  *
 331  * @param ci The core's info record.
 332  */
 333 bhnd_devclass_t
 334 bhnd_core_class(const struct bhnd_core_info *ci)
 335 {
 336         return bhnd_find_core_class(ci->vendor, ci->device);
 337 }
 338
 339 /**
 340  * Write a human readable name representation of the given
 341  * BHND_CHIPID_* constant to @p buffer.
 342  *
 343  * @param buffer Output buffer, or NULL to compute the required size.
 344  * @param size Capacity of @p buffer, in bytes.
 345  * @param chip_id Chip ID to be formatted.
 346  *
 347  * @return The required number of bytes on success, or a negative integer on
 348  * failure. No more than @p size-1 characters be written, with the @p size'th
 349  * set to '\0'.
 350  *
 351  * @sa BHND_CHIPID_MAX_NAMELEN
 352  */
 353 int
 354 bhnd_format_chip_id(char *buffer, size_t size, uint16_t chip_id)
 355 {
 356         /* All hex formatted IDs are within the range of 0x4000-0x9C3F (40000-1) */
 357         if (chip_id >= 0x4000 && chip_id <= 0x9C3F)
 358                 return (snprintf(buffer, size, "BCM%hX", chip_id));
 359         else
 360                 return (snprintf(buffer, size, "BCM%hu", chip_id));
 361 }
 362
 363 /**
 364  * Return a core info record populated from a bhnd-attached @p dev.
 365  *
 366  * @param dev A bhnd device.
 367  *
 368  * @return A core info record for @p dev.
 369  */
 370 struct bhnd_core_info
 371 bhnd_get_core_info(device_t dev) {
 372         return (struct bhnd_core_info) {
 373                 .vendor         = bhnd_get_vendor(dev),
 374                 .device         = bhnd_get_device(dev),
 375                 .hwrev          = bhnd_get_hwrev(dev),
 376                 .core_idx       = bhnd_get_core_index(dev),
 377                 .unit           = bhnd_get_core_unit(dev)
 378         };
 379 }
 380
 381 /**
 382  * Find a @p class child device with @p unit on @p bus.
 383  *
 384  * @param bus The bhnd-compatible bus to be searched.
 385  * @param class The device class to match on.
 386  * @param unit The core unit number; specify -1 to return the first match
 387  * regardless of unit number.
 388  *
 389  * @retval device_t if a matching child device is found.
 390  * @retval NULL if no matching child device is found.
 391  */
 392 device_t
 393 bhnd_bus_find_child(device_t bus, bhnd_devclass_t class, int unit)
 394 {
 395         struct bhnd_core_match md = {
 396                 BHND_MATCH_CORE_CLASS(class),
 397                 BHND_MATCH_CORE_UNIT(unit)
 398         };
 399
 400         if (unit == -1)
 401                 md.m.match.core_unit = 0;
 402
 403         return bhnd_bus_match_child(bus, &md);
 404 }
 405
 406 /**
 407  * Find the first child device on @p bus that matches @p desc.
 408  *
 409  * @param bus The bhnd-compatible bus to be searched.
 410  * @param desc A match descriptor.
 411  *
 412  * @retval device_t if a matching child device is found.
 413  * @retval NULL if no matching child device is found.
 414  */
 415 device_t
 416 bhnd_bus_match_child(device_t bus, const struct bhnd_core_match *desc)
 417 {
 418         device_t        *devlistp;
 419         device_t         match;
 420         int              devcnt;
 421         int              error;
 422
 423         error = device_get_children(bus, &devlistp, &devcnt);
 424         if (error != 0)
 425                 return (NULL);
 426
 427         match = NULL;
 428         for (int i = 0; i < devcnt; i++) {
 429                 struct bhnd_core_info ci = bhnd_get_core_info(devlistp[i]);
 430
 431                 if (bhnd_core_matches(&ci, desc)) {
 432                         match = devlistp[i];
 433                         goto done;
 434                 }
 435         }
 436
 437 done:
 438         free(devlistp, M_TEMP);
 439         return match;
 440 }
 441
 442 /**
 443  * Retrieve an ordered list of all device instances currently connected to
 444  * @p bus, returning a pointer to the array in @p devlistp and the count
 445  * in @p ndevs.
 446  *
 447  * The memory allocated for the table must be freed via
 448  * bhnd_bus_free_children().
 449  *
 450  * @param       bus             The bhnd-compatible bus to be queried.
 451  * @param[out]  devlist         The array of devices.
 452  * @param[out]  devcount        The number of devices in @p devlistp
 453  * @param       order           The order in which devices will be returned
 454  *                              in @p devlist.
 455  *
 456  * @retval 0            success
 457  * @retval non-zero     if an error occurs, a regular unix error code will
 458  *                      be returned.
 459  */
 460 int
 461 bhnd_bus_get_children(device_t bus, device_t **devlist, int *devcount,
 462     bhnd_device_order order)
 463 {
 464         int error;
 465
 466         /* Fetch device array */
 467         if ((error = device_get_children(bus, devlist, devcount)))
 468                 return (error);
 469
 470         /* Perform requested sorting */
 471         if ((error = bhnd_sort_devices(*devlist, *devcount, order))) {
 472                 bhnd_bus_free_children(*devlist);
 473                 return (error);
 474         }
 475
 476         return (0);
 477 }
 478
 479 /**
 480  * Free any memory allocated in a previous call to bhnd_bus_get_children().
 481  *
 482  * @param devlist The device array returned by bhnd_bus_get_children().
 483  */
 484 void
 485 bhnd_bus_free_children(device_t *devlist)
 486 {
 487         free(devlist, M_TEMP);
 488 }
 489
 490 /**
 491  * Perform in-place sorting of an array of bhnd device instances.
 492  *
 493  * @param devlist       An array of bhnd devices.
 494  * @param devcount      The number of devices in @p devs.
 495  * @param order         The sort order to be used.
 496  *
 497  * @retval 0            success
 498  * @retval EINVAL       if the sort order is unknown.
 499  */
 500 int
 501 bhnd_sort_devices(device_t *devlist, size_t devcount, bhnd_device_order order)
 502 {
 503         int (*compare)(const void *, const void *);
 504
 505         switch (order) {
 506         case BHND_DEVICE_ORDER_ATTACH:
 507                 compare = compare_ascending_probe_order;
 508                 break;
 509         case BHND_DEVICE_ORDER_DETACH:
 510                 compare = compare_descending_probe_order;
 511                 break;
 512         default:
 513                 printf("unknown sort order: %d\n", order);
 514                 return (EINVAL);
 515         }
 516
 517         qsort(devlist, devcount, sizeof(*devlist), compare);
 518         return (0);
 519 }
 520
 521 /*
 522  * Ascending comparison of bhnd device's probe order.
 523  */
 524 static int
 525 compare_ascending_probe_order(const void *lhs, const void *rhs)
 526 {
 527         device_t        ldev, rdev;
 528         int             lorder, rorder;
 529
 530         ldev = (*(const device_t *) lhs);
 531         rdev = (*(const device_t *) rhs);
 532
 533         lorder = BHND_BUS_GET_PROBE_ORDER(device_get_parent(ldev), ldev);
 534         rorder = BHND_BUS_GET_PROBE_ORDER(device_get_parent(rdev), rdev);
 535
 536         if (lorder < rorder) {
 537                 return (-1);
 538         } else if (lorder > rorder) {
 539                 return (1);
 540         } else {
 541                 return (0);
 542         }
 543 }
 544
 545 /*
 546  * Descending comparison of bhnd device's probe order.
 547  */
 548 static int
 549 compare_descending_probe_order(const void *lhs, const void *rhs)
 550 {
 551         return (compare_ascending_probe_order(rhs, lhs));
 552 }
 553
 554 /**
 555  * Call device_probe_and_attach() for each of the bhnd bus device's
 556  * children, in bhnd attach order.
 557  *
 558  * @param bus The bhnd-compatible bus for which all children should be probed
 559  * and attached.
 560  */
 561 int
 562 bhnd_bus_probe_children(device_t bus)
 563 {
 564         device_t        *devs;
 565         int              ndevs;
 566         int              error;
 567
 568         /* Fetch children in attach order */
 569         error = bhnd_bus_get_children(bus, &devs, &ndevs,
 570             BHND_DEVICE_ORDER_ATTACH);
 571         if (error)
 572                 return (error);
 573
 574         /* Probe and attach all children */
 575         for (int i = 0; i < ndevs; i++) {
 576                 device_t child = devs[i];
 577                 device_probe_and_attach(child);
 578         }
 579
 580         bhnd_bus_free_children(devs);
 581
 582         return (0);
 583 }
 584
 585 /**
 586  * Walk up the bhnd device hierarchy to locate the root device
 587  * to which the bhndb bridge is attached.
 588  *
 589  * This can be used from within bhnd host bridge drivers to locate the
 590  * actual upstream host device.
 591  *
 592  * @param dev A bhnd device.
 593  * @param bus_class The expected bus (e.g. "pci") to which the bridge root
 594  * should be attached.
 595  *
 596  * @retval device_t if a matching parent device is found.
 597  * @retval NULL if @p dev is not attached via a bhndb bus.
 598  * @retval NULL if no parent device is attached via @p bus_class.
 599  */
 600 device_t
 601 bhnd_find_bridge_root(device_t dev, devclass_t bus_class)
 602 {
 603         devclass_t      bhndb_class;
 604         device_t        parent;
 605
 606         KASSERT(device_get_devclass(device_get_parent(dev)) == bhnd_devclass,
 607            ("%s not a bhnd device", device_get_nameunit(dev)));
 608
 609         bhndb_class = devclass_find("bhndb");
 610
 611         /* Walk the device tree until we hit a bridge */
 612         parent = dev;
 613         while ((parent = device_get_parent(parent)) != NULL) {
 614                 if (device_get_devclass(parent) == bhndb_class)
 615                         break;
 616         }
 617
 618         /* No bridge? */
 619         if (parent == NULL)
 620                 return (NULL);
 621
 622         /* Search for a parent attached to the expected bus class */
 623         while ((parent = device_get_parent(parent)) != NULL) {
 624                 device_t bus;
 625
 626                 bus = device_get_parent(parent);
 627                 if (bus != NULL && device_get_devclass(bus) == bus_class)
 628                         return (parent);
 629         }
 630
 631         /* Not found */
 632         return (NULL);
 633 }
 634
 635 /**
 636  * Find the first core in @p cores that matches @p desc.
 637  *
 638  * @param cores The table to search.
 639  * @param num_cores The length of @p cores.
 640  * @param desc A match descriptor.
 641  *
 642  * @retval bhnd_core_info if a matching core is found.
 643  * @retval NULL if no matching core is found.
 644  */
 645 const struct bhnd_core_info *
 646 bhnd_match_core(const struct bhnd_core_info *cores, u_int num_cores,
 647     const struct bhnd_core_match *desc)
 648 {
 649         for (u_int i = 0; i < num_cores; i++) {
 650                 if (bhnd_core_matches(&cores[i], desc))
 651                         return &cores[i];
 652         }
 653
 654         return (NULL);
 655 }
 656
 657
 658 /**
 659  * Find the first core in @p cores with the given @p class.
 660  *
 661  * @param cores The table to search.
 662  * @param num_cores The length of @p cores.
 663  * @param class The device class to match on.
 664  *
 665  * @retval non-NULL if a matching core is found.
 666  * @retval NULL if no matching core is found.
 667  */
 668 const struct bhnd_core_info *
 669 bhnd_find_core(const struct bhnd_core_info *cores, u_int num_cores,
 670     bhnd_devclass_t class)
 671 {
 672         struct bhnd_core_match md = {
 673                 BHND_MATCH_CORE_CLASS(class)
 674         };
 675
 676         return bhnd_match_core(cores, num_cores, &md);
 677 }
 678
 679
 680 /**
 681  * Create an equality match descriptor for @p core.
 682  *
 683  * @param core The core info to be matched on.
 684  *
 685  * @return an equality match descriptor for @p core.
 686  */
 687 struct bhnd_core_match
 688 bhnd_core_get_match_desc(const struct bhnd_core_info *core)
 689 {
 690         return ((struct bhnd_core_match) {
 691                 BHND_MATCH_CORE_VENDOR(core->vendor),
 692                 BHND_MATCH_CORE_ID(core->device),
 693                 BHND_MATCH_CORE_REV(HWREV_EQ(core->hwrev)),
 694                 BHND_MATCH_CORE_CLASS(bhnd_core_class(core)),
 695                 BHND_MATCH_CORE_IDX(core->core_idx),
 696                 BHND_MATCH_CORE_UNIT(core->unit)
 697         });
 698 }
 699
 700
 701 /**
 702  * Return true if the @p lhs is equal to @p rhs.
 703  *
 704  * @param lhs The first bhnd core descriptor to compare.
 705  * @param rhs The second bhnd core descriptor to compare.
 706  *
 707  * @retval true if @p lhs is equal to @p rhs
 708  * @retval false if @p lhs is not equal to @p rhs
 709  */
 710 bool
 711 bhnd_cores_equal(const struct bhnd_core_info *lhs,
 712     const struct bhnd_core_info *rhs)
 713 {
 714         struct bhnd_core_match md;
 715
 716         /* Use an equality match descriptor to perform the comparison */
 717         md = bhnd_core_get_match_desc(rhs);
 718         return (bhnd_core_matches(lhs, &md));
 719 }
 720
 721 /**
 722  * Return true if the @p core matches @p desc.
 723  *
 724  * @param core A bhnd core descriptor.
 725  * @param desc A match descriptor to compare against @p core.
 726  *
 727  * @retval true if @p core matches @p match.
 728  * @retval false if @p core does not match @p match.
 729  */
 730 bool
 731 bhnd_core_matches(const struct bhnd_core_info *core,
 732     const struct bhnd_core_match *desc)
 733 {
 734         if (desc->m.match.core_vendor && desc->core_vendor != core->vendor)
 735                 return (false);
 736
 737         if (desc->m.match.core_id && desc->core_id != core->device)
 738                 return (false);
 739
 740         if (desc->m.match.core_unit && desc->core_unit != core->unit)
 741                 return (false);
 742
 743         if (desc->m.match.core_rev &&
 744             !bhnd_hwrev_matches(core->hwrev, &desc->core_rev))
 745                 return (false);
 746
 747         if (desc->m.match.core_idx && desc->core_idx != core->core_idx)
 748                 return (false);
 749
 750         if (desc->m.match.core_class &&
 751             desc->core_class != bhnd_core_class(core))
 752                 return (false);
 753
 754         return true;
 755 }
 756
 757 /**
 758  * Return true if the @p chip matches @p desc.
 759  *
 760  * @param chip A bhnd chip identifier.
 761  * @param desc A match descriptor to compare against @p chip.
 762  *
 763  * @retval true if @p chip matches @p match.
 764  * @retval false if @p chip does not match @p match.
 765  */
 766 bool
 767 bhnd_chip_matches(const struct bhnd_chipid *chip,
 768     const struct bhnd_chip_match *desc)
 769 {
 770         if (desc->m.match.chip_id && chip->chip_id != desc->chip_id)
 771                 return (false);
 772
 773         if (desc->m.match.chip_pkg && chip->chip_pkg != desc->chip_pkg)
 774                 return (false);
 775
 776         if (desc->m.match.chip_rev &&
 777             !bhnd_hwrev_matches(chip->chip_rev, &desc->chip_rev))
 778                 return (false);
 779
 780         if (desc->m.match.chip_type && chip->chip_type != desc->chip_type)
 781                 return (false);
 782
 783         return (true);
 784 }
 785
 786 /**
 787  * Return true if the @p board matches @p desc.
 788  *
 789  * @param board The bhnd board info.
 790  * @param desc A match descriptor to compare against @p board.
 791  *
 792  * @retval true if @p chip matches @p match.
 793  * @retval false if @p chip does not match @p match.
 794  */
 795 bool
 796 bhnd_board_matches(const struct bhnd_board_info *board,
 797     const struct bhnd_board_match *desc)
 798 {
 799         if (desc->m.match.board_srom_rev &&
 800             !bhnd_hwrev_matches(board->board_srom_rev, &desc->board_srom_rev))
 801                 return (false);
 802
 803         if (desc->m.match.board_vendor &&
 804             board->board_vendor != desc->board_vendor)
 805                 return (false);
 806
 807         if (desc->m.match.board_type && board->board_type != desc->board_type)
 808                 return (false);
 809
 810         if (desc->m.match.board_devid &&
 811             board->board_devid != desc->board_devid)
 812                 return (false);
 813
 814         if (desc->m.match.board_rev &&
 815             !bhnd_hwrev_matches(board->board_rev, &desc->board_rev))
 816                 return (false);
 817
 818         return (true);
 819 }
 820
 821 /**
 822  * Return true if the @p hwrev matches @p desc.
 823  *
 824  * @param hwrev A bhnd hardware revision.
 825  * @param desc A match descriptor to compare against @p core.
 826  *
 827  * @retval true if @p hwrev matches @p match.
 828  * @retval false if @p hwrev does not match @p match.
 829  */
 830 bool
 831 bhnd_hwrev_matches(uint16_t hwrev, const struct bhnd_hwrev_match *desc)
 832 {
 833         if (desc->start != BHND_HWREV_INVALID &&
 834             desc->start > hwrev)
 835                 return false;
 836
 837         if (desc->end != BHND_HWREV_INVALID &&
 838             desc->end < hwrev)
 839                 return false;
 840
 841         return true;
 842 }
 843
 844 /**
 845  * Return true if the @p dev matches @p desc.
 846  *
 847  * @param dev A bhnd device.
 848  * @param desc A match descriptor to compare against @p dev.
 849  *
 850  * @retval true if @p dev matches @p match.
 851  * @retval false if @p dev does not match @p match.
 852  */
 853 bool
 854 bhnd_device_matches(device_t dev, const struct bhnd_device_match *desc)
 855 {
 856         struct bhnd_core_info            core;
 857         const struct bhnd_chipid        *chip;
 858         struct bhnd_board_info           board;
 859         device_t                         parent;
 860         int                              error;
 861
 862         /* Construct individual match descriptors */
 863         struct bhnd_core_match  m_core  = { _BHND_CORE_MATCH_COPY(desc) };
 864         struct bhnd_chip_match  m_chip  = { _BHND_CHIP_MATCH_COPY(desc) };
 865         struct bhnd_board_match m_board = { _BHND_BOARD_MATCH_COPY(desc) };
 866
 867         /* Fetch and match core info */
 868         if (m_core.m.match_flags) {
 869                 /* Only applicable to bhnd-attached cores */
 870                 parent = device_get_parent(dev);
 871                 if (device_get_devclass(parent) != bhnd_devclass) {
 872                         device_printf(dev, "attempting to match core "
 873                             "attributes against non-core device\n");
 874                         return (false);
 875                 }
 876
 877                 core = bhnd_get_core_info(dev);
 878                 if (!bhnd_core_matches(&core, &m_core))
 879                         return (false);
 880         }
 881
 882         /* Fetch and match chip info */
 883         if (m_chip.m.match_flags) {
 884                 chip = bhnd_get_chipid(dev);
 885
 886                 if (!bhnd_chip_matches(chip, &m_chip))
 887                         return (false);
 888         }
 889
 890         /* Fetch and match board info.
 891          *
 892          * This is not available until  after NVRAM is up; earlier device
 893          * matches should not include board requirements */
 894         if (m_board.m.match_flags) {
 895                 if ((error = bhnd_read_board_info(dev, &board))) {
 896                         device_printf(dev, "failed to read required board info "
 897                             "during device matching: %d\n", error);
 898                         return (false);
 899                 }
 900
 901                 if (!bhnd_board_matches(&board, &m_board))
 902                         return (false);
 903         }
 904
 905         /* All matched */
 906         return (true);
 907 }
 908
 909 /**
 910  * Search @p table for an entry matching @p dev.
 911  *
 912  * @param dev A bhnd device to match against @p table.
 913  * @param table The device table to search.
 914  * @param entry_size The @p table entry size, in bytes.
 915  *
 916  * @retval non-NULL the first matching device, if any.
 917  * @retval NULL if no matching device is found in @p table.
 918  */
 919 const struct bhnd_device *
 920 bhnd_device_lookup(device_t dev, const struct bhnd_device *table,
 921     size_t entry_size)
 922 {
 923         const struct bhnd_device        *entry;
 924         device_t                         hostb, parent;
 925         bhnd_attach_type                 attach_type;
 926         uint32_t                         dflags;
 927
 928         parent = device_get_parent(dev);
 929         hostb = bhnd_bus_find_hostb_device(parent);
 930         attach_type = bhnd_get_attach_type(dev);
 931
 932         for (entry = table; !BHND_DEVICE_IS_END(entry); entry =
 933             (const struct bhnd_device *) ((const char *) entry + entry_size))
 934         {
 935                 /* match core info */
 936                 if (!bhnd_device_matches(dev, &entry->core))
 937                         continue;
 938
 939                 /* match device flags */
 940                 dflags = entry->device_flags;
 941
 942                 /* hostb implies BHND_ATTACH_ADAPTER requirement */
 943                 if (dflags & BHND_DF_HOSTB)
 944                         dflags |= BHND_DF_ADAPTER;
 945
 946                 if (dflags & BHND_DF_ADAPTER)
 947                         if (attach_type != BHND_ATTACH_ADAPTER)
 948                                 continue;
 949
 950                 if (dflags & BHND_DF_HOSTB)
 951                         if (dev != hostb)
 952                                 continue;
 953
 954                 if (dflags & BHND_DF_SOC)
 955                         if (attach_type != BHND_ATTACH_NATIVE)
 956                                 continue;
 957
 958                 /* device found */
 959                 return (entry);
 960         }
 961
 962         /* not found */
 963         return (NULL);
 964 }
 965
 966 /**
 967  * Scan the device @p table for all quirk flags applicable to @p dev.
 968  *
 969  * @param dev A bhnd device to match against @p table.
 970  * @param table The device table to search.
 971  * @param entry_size The @p table entry size, in bytes.
 972  *
 973  * @return all matching quirk flags.
 974  */
 975 uint32_t
 976 bhnd_device_quirks(device_t dev, const struct bhnd_device *table,
 977     size_t entry_size)
 978 {
 979         const struct bhnd_device        *dent;
 980         const struct bhnd_device_quirk  *qent, *qtable;
 981         uint32_t                         quirks;
 982
 983         /* Locate the device entry */
 984         if ((dent = bhnd_device_lookup(dev, table, entry_size)) == NULL)
 985                 return (0);
 986
 987         /* Quirks table is optional */
 988         qtable = dent->quirks_table;
 989         if (qtable == NULL)
 990                 return (0);
 991
 992         /* Collect matching device quirk entries */
 993         quirks = 0;
 994         for (qent = qtable; !BHND_DEVICE_QUIRK_IS_END(qent); qent++) {
 995                 if (bhnd_device_matches(dev, &qent->desc))
 996                         quirks |= qent->quirks;
 997         }
 998
 999         return (quirks);
1000 }
1001
1002
1003 /**
1004  * Allocate bhnd(4) resources defined in @p rs from a parent bus.
1005  *
1006  * @param dev The device requesting ownership of the resources.
1007  * @param rs A standard bus resource specification. This will be updated
1008  * with the allocated resource's RIDs.
1009  * @param res On success, the allocated bhnd resources.
1010  *
1011  * @retval 0 success
1012  * @retval non-zero if allocation of any non-RF_OPTIONAL resource fails,
1013  *                  all allocated resources will be released and a regular
1014  *                  unix error code will be returned.
1015  */
1016 int
1017 bhnd_alloc_resources(device_t dev, struct resource_spec *rs,
1018     struct bhnd_resource **res)
1019 {
1020         /* Initialize output array */
1021         for (u_int i = 0; rs[i].type != -1; i++)
1022                 res[i] = NULL;
1023
1024         for (u_int i = 0; rs[i].type != -1; i++) {
1025                 res[i] = bhnd_alloc_resource_any(dev, rs[i].type, &rs[i].rid,
1026                     rs[i].flags);
1027
1028                 /* Clean up all allocations on failure */
1029                 if (res[i] == NULL && !(rs[i].flags & RF_OPTIONAL)) {
1030                         bhnd_release_resources(dev, rs, res);
1031                         return (ENXIO);
1032                 }
1033         }
1034
1035         return (0);
1036 }
1037
1038 /**
1039  * Release bhnd(4) resources defined in @p rs from a parent bus.
1040  *
1041  * @param dev The device that owns the resources.
1042  * @param rs A standard bus resource specification previously initialized
1043  * by @p bhnd_alloc_resources.
1044  * @param res The bhnd resources to be released.
1045  */
1046 void
1047 bhnd_release_resources(device_t dev, const struct resource_spec *rs,
1048     struct bhnd_resource **res)
1049 {
1050         for (u_int i = 0; rs[i].type != -1; i++) {
1051                 if (res[i] == NULL)
1052                         continue;
1053
1054                 bhnd_release_resource(dev, rs[i].type, rs[i].rid, res[i]);
1055                 res[i] = NULL;
1056         }
1057 }
1058
1059 /**
1060  * Parse the CHIPC_ID_* fields from the ChipCommon CHIPC_ID
1061  * register, returning its bhnd_chipid representation.
1062  *
1063  * @param idreg The CHIPC_ID register value.
1064  * @param enum_addr The enumeration address to include in the result.
1065  *
1066  * @warning
1067  * On early siba(4) devices, the ChipCommon core does not provide
1068  * a valid CHIPC_ID_NUMCORE field. On these ChipCommon revisions
1069  * (see CHIPC_NCORES_MIN_HWREV()), this function will parse and return
1070  * an invalid `ncores` value.
1071  */
1072 struct bhnd_chipid
1073 bhnd_parse_chipid(uint32_t idreg, bhnd_addr_t enum_addr)
1074 {
1075         struct bhnd_chipid result;
1076
1077         /* Fetch the basic chip info */
1078         result.chip_id = CHIPC_GET_BITS(idreg, CHIPC_ID_CHIP);
1079         result.chip_pkg = CHIPC_GET_BITS(idreg, CHIPC_ID_PKG);
1080         result.chip_rev = CHIPC_GET_BITS(idreg, CHIPC_ID_REV);
1081         result.chip_type = CHIPC_GET_BITS(idreg, CHIPC_ID_BUS);
1082         result.ncores = CHIPC_GET_BITS(idreg, CHIPC_ID_NUMCORE);
1083
1084         result.enum_addr = enum_addr;
1085
1086         return (result);
1087 }
1088
1089
1090 /**
1091  * Determine the correct core count for a chip identification value that
1092  * may contain an invalid core count.
1093  *
1094  * On some early siba(4) devices (see CHIPC_NCORES_MIN_HWREV()), the ChipCommon
1095  * core does not provide a valid CHIPC_ID_NUMCORE field.
1096  *
1097  * @param cid The chip identification to be queried.
1098  * @param chipc_hwrev The hardware revision of the ChipCommon core from which
1099  * @p cid was parsed.
1100  * @param[out] ncores On success, will be set to the correct core count.
1101  *
1102  * @retval 0 If the core count is already correct, or was mapped to a
1103  * a correct value.
1104  * @retval EINVAL If the core count is incorrect, but the chip was not
1105  * recognized.
1106  */
1107 int
1108 bhnd_chipid_fixed_ncores(const struct bhnd_chipid *cid, uint16_t chipc_hwrev,
1109     uint8_t *ncores)
1110 {
1111         /* bcma(4), and most siba(4) devices */
1112         if (CHIPC_NCORES_MIN_HWREV(chipc_hwrev)) {
1113                 *ncores = cid->ncores;
1114                 return (0);
1115         }
1116
1117         /* broken siba(4) chipsets */
1118         switch (cid->chip_id) {
1119         case BHND_CHIPID_BCM4306:
1120                 *ncores = 6;
1121                 break;
1122         case BHND_CHIPID_BCM4704:
1123                 *ncores = 9;
1124                 break;
1125         case BHND_CHIPID_BCM5365:
1126                 /*
1127                 * BCM5365 does support ID_NUMCORE in at least
1128                 * some of its revisions, but for unknown
1129                 * reasons, Broadcom's drivers always exclude
1130                 * the ChipCommon revision (0x5) used by BCM5365
1131                 * from the set of revisions supporting
1132                 * ID_NUMCORE, and instead supply a fixed value.
1133                 *
1134                 * Presumably, at least some of these devices
1135                 * shipped with a broken ID_NUMCORE value.
1136                 */
1137                 *ncores = 7;
1138                 break;
1139         default:
1140                 return (EINVAL);
1141         }
1142
1143         return (0);
1144 }
1145
1146 /**
1147  * Allocate the resource defined by @p rs via @p dev, use it
1148  * to read the ChipCommon ID register relative to @p chipc_offset,
1149  * then release the resource.
1150  *
1151  * @param dev The device owning @p rs.
1152  * @param rs A resource spec that encompasses the ChipCommon register block.
1153  * @param chipc_offset The offset of the ChipCommon registers within @p rs.
1154  * @param[out] result The chip identification data.
1155  *
1156  * @retval 0 success
1157  * @retval non-zero if the ChipCommon identification data could not be read.
1158  */
1159 int
1160 bhnd_read_chipid(device_t dev, struct resource_spec *rs,
1161     bus_size_t chipc_offset, struct bhnd_chipid *result)
1162 {
1163         struct resource                 *res;
1164         bhnd_addr_t                      enum_addr;
1165         uint32_t                         reg;
1166         uint8_t                          chip_type;
1167         int                              error, rid, rtype;
1168
1169         rid = rs->rid;
1170         rtype = rs->type;
1171         error = 0;
1172
1173         /* Allocate the ChipCommon window resource and fetch the chipid data */
1174         res = bus_alloc_resource_any(dev, rtype, &rid, RF_ACTIVE);
1175         if (res == NULL) {
1176                 device_printf(dev,
1177                     "failed to allocate bhnd chipc resource\n");
1178                 return (ENXIO);
1179         }
1180
1181         /* Fetch the basic chip info */
1182         reg = bus_read_4(res, chipc_offset + CHIPC_ID);
1183         chip_type = CHIPC_GET_BITS(reg, CHIPC_ID_BUS);
1184
1185         /* Fetch the EROMPTR */
1186         if (BHND_CHIPTYPE_HAS_EROM(chip_type)) {
1187                 enum_addr = bus_read_4(res, chipc_offset + CHIPC_EROMPTR);
1188         } else if (chip_type == BHND_CHIPTYPE_SIBA) {
1189                 /* siba(4) uses the ChipCommon base address as the enumeration
1190                  * address */
1191                 enum_addr = BHND_DEFAULT_CHIPC_ADDR;
1192         } else {
1193                 device_printf(dev, "unknown chip type %hhu\n", chip_type);
1194                 error = ENODEV;
1195                 goto cleanup;
1196         }
1197
1198         *result = bhnd_parse_chipid(reg, enum_addr);
1199
1200         /* Fix the core count on early siba(4) devices */
1201         if (chip_type == BHND_CHIPTYPE_SIBA) {
1202                 uint32_t        idh;
1203                 uint16_t        chipc_hwrev;
1204
1205                 /*
1206                  * We need the ChipCommon revision to determine whether
1207                  * the ncore field is valid.
1208                  *
1209                  * We can safely assume the siba IDHIGH register is mapped
1210                  * within the chipc register block.
1211                  */
1212                 idh = bus_read_4(res, SB0_REG_ABS(SIBA_CFG0_IDHIGH));
1213                 chipc_hwrev = SIBA_IDH_CORE_REV(idh);
1214
1215                 error = bhnd_chipid_fixed_ncores(result, chipc_hwrev,
1216                     &result->ncores);
1217                 if (error)
1218                         goto cleanup;
1219         }
1220
1221 cleanup:
1222         /* Clean up */
1223         bus_release_resource(dev, rtype, rid, res);
1224         return (error);
1225 }
1226
1227 /**
1228  * Allocate and return a new per-core PMU clock control/status (clkctl)
1229  * instance for @p dev.
1230  *
1231  * @param dev           The bhnd(4) core device mapped by @p r.
1232  * @param pmu_dev       The bhnd(4) PMU device, implmenting the bhnd_pmu_if
1233  *                      interface. The caller is responsible for ensuring that
1234  *                      this reference remains valid for the lifetime of the
1235  *                      returned clkctl instance.
1236  * @param r             A resource mapping the core's clock control register
1237  *                      (see BHND_CLK_CTL_ST). The caller is responsible for
1238  *                      ensuring that this resource remains valid for the
1239  *                      lifetime of the returned clkctl instance.
1240  * @param offset        The offset to the clock control register within @p r.
1241  * @param max_latency   The PMU's maximum state transition latency in
1242  *                      microseconds; this upper bound will be used to busy-wait
1243  *                      on PMU state transitions.
1244  *
1245  * @retval non-NULL     success
1246  * @retval NULL         if allocation fails.
1247  *
1248  */
1249 struct bhnd_core_clkctl *
1250 bhnd_alloc_core_clkctl(device_t dev, device_t pmu_dev, struct bhnd_resource *r,
1251     bus_size_t offset, u_int max_latency)
1252 {
1253         struct bhnd_core_clkctl *clkctl;
1254
1255         clkctl = malloc(sizeof(*clkctl), M_BHND, M_ZERO | M_NOWAIT);
1256         if (clkctl == NULL)
1257                 return (NULL);
1258
1259         clkctl->cc_dev = dev;
1260         clkctl->cc_pmu_dev = pmu_dev;
1261         clkctl->cc_res = r;
1262         clkctl->cc_res_offset = offset;
1263         clkctl->cc_max_latency = max_latency;
1264         clkctl->cc_quirks = bhnd_device_quirks(dev, bhnd_clkctl_devices,
1265             sizeof(bhnd_clkctl_devices[0]));
1266
1267         BHND_CLKCTL_LOCK_INIT(clkctl);
1268
1269         return (clkctl);
1270 }
1271
1272 /**
1273  * Free a clkctl instance previously allocated via bhnd_alloc_core_clkctl().
1274  *
1275  * @param clkctl        The clkctl instance to be freed.
1276  */
1277 void
1278 bhnd_free_core_clkctl(struct bhnd_core_clkctl *clkctl)
1279 {
1280         BHND_CLKCTL_LOCK_DESTROY(clkctl);
1281
1282         free(clkctl, M_BHND);
1283 }
1284
1285 /**
1286  * Wait for the per-core clock status to be equal to @p value after
1287  * applying @p mask, timing out after the maximum transition latency is reached.
1288  *
1289  * @param clkctl        Per-core clkctl state to be queryied.
1290  * @param value         Value to wait for.
1291  * @param mask          Mask to apply prior to value comparison.
1292  *
1293  * @retval 0            success
1294  * @retval ETIMEDOUT    if the PMU's maximum transition delay is reached before
1295  *                      the clock status matches @p value and @p mask.
1296  */
1297 int
1298 bhnd_core_clkctl_wait(struct bhnd_core_clkctl *clkctl, uint32_t value,
1299     uint32_t mask)
1300 {
1301         uint32_t        clkst;
1302
1303         BHND_CLKCTL_LOCK_ASSERT(clkctl, MA_OWNED);
1304
1305         /* Bitswapped HTAVAIL/ALPAVAIL work-around */
1306         if (clkctl->cc_quirks & BHND_CLKCTL_QUIRK_CCS0) {
1307                 uint32_t fmask, fval;
1308
1309                 fmask = mask & ~(BHND_CCS_HTAVAIL | BHND_CCS_ALPAVAIL);
1310                 fval = value & ~(BHND_CCS_HTAVAIL | BHND_CCS_ALPAVAIL);
1311
1312                 if (mask & BHND_CCS_HTAVAIL)
1313                         fmask |= BHND_CCS0_HTAVAIL;
1314                 if (value & BHND_CCS_HTAVAIL)
1315                         fval |= BHND_CCS0_HTAVAIL;
1316
1317                 if (mask & BHND_CCS_ALPAVAIL)
1318                         fmask |= BHND_CCS0_ALPAVAIL;
1319                 if (value & BHND_CCS_ALPAVAIL)
1320                         fval |= BHND_CCS0_ALPAVAIL;
1321
1322                 mask = fmask;
1323                 value = fval;
1324         }
1325
1326         for (u_int i = 0; i < clkctl->cc_max_latency; i += 10) {
1327                 clkst = bhnd_bus_read_4(clkctl->cc_res, clkctl->cc_res_offset);
1328                 if ((clkst & mask) == (value & mask))
1329                         return (0);
1330
1331                 DELAY(10);
1332         }
1333
1334         device_printf(clkctl->cc_dev, "clkst wait timeout (value=%#x, "
1335             "mask=%#x)\n", value, mask);
1336
1337         return (ETIMEDOUT);
1338 }
1339
1340 /**
1341  * Read an NVRAM variable's NUL-terminated string value.
1342  *
1343  * @param       dev     A bhnd bus child device.
1344  * @param       name    The NVRAM variable name.
1345  * @param[out]  buf     A buffer large enough to hold @p len bytes. On
1346  *                      success, the NUL-terminated string value will be
1347  *                      written to this buffer. This argment may be NULL if
1348  *                      the value is not desired.
1349  * @param       len     The maximum capacity of @p buf.
1350  * @param[out]  rlen    On success, will be set to the actual size of
1351  *                      the requested value (including NUL termination). This
1352  *                      argment may be NULL if the size is not desired.
1353  *
1354  * @retval 0            success
1355  * @retval ENOENT       The requested variable was not found.
1356  * @retval ENODEV       No valid NVRAM source could be found.
1357  * @retval ENOMEM       If @p buf is non-NULL and a buffer of @p len is too
1358  *                      small to hold the requested value.
1359  * @retval EFTYPE       If the variable data cannot be coerced to a valid
1360  *                      string representation.
1361  * @retval ERANGE       If value coercion would overflow @p type.
1362  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1363  *                      error code will be returned.
1364  */
1365 int
1366 bhnd_nvram_getvar_str(device_t dev, const char *name, char *buf, size_t len,
1367     size_t *rlen)
1368 {
1369         size_t  larg;
1370         int     error;
1371
1372         larg = len;
1373         error = bhnd_nvram_getvar(dev, name, buf, &larg,
1374             BHND_NVRAM_TYPE_STRING);
1375         if (rlen != NULL)
1376                 *rlen = larg;
1377
1378         return (error);
1379 }
1380
1381 /**
1382  * Read an NVRAM variable's unsigned integer value.
1383  *
1384  * @param               dev     A bhnd bus child device.
1385  * @param               name    The NVRAM variable name.
1386  * @param[out]          value   On success, the requested value will be written
1387  *                              to this pointer.
1388  * @param               width   The output integer type width (1, 2, or
1389  *                              4 bytes).
1390  *
1391  * @retval 0            success
1392  * @retval ENOENT       The requested variable was not found.
1393  * @retval ENODEV       No valid NVRAM source could be found.
1394  * @retval EFTYPE       If the variable data cannot be coerced to a
1395  *                      a valid unsigned integer representation.
1396  * @retval ERANGE       If value coercion would overflow (or underflow) an
1397  *                      unsigned representation of the given @p width.
1398  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1399  *                      error code will be returned.
1400  */
1401 int
1402 bhnd_nvram_getvar_uint(device_t dev, const char *name, void *value, int width)
1403 {
1404         bhnd_nvram_type type;
1405         size_t          len;
1406
1407         switch (width) {
1408         case 1:
1409                 type = BHND_NVRAM_TYPE_UINT8;
1410                 break;
1411         case 2:
1412                 type = BHND_NVRAM_TYPE_UINT16;
1413                 break;
1414         case 4:
1415                 type = BHND_NVRAM_TYPE_UINT32;
1416                 break;
1417         default:
1418                 device_printf(dev, "unsupported NVRAM integer width: %d\n",
1419                     width);
1420                 return (EINVAL);
1421         }
1422
1423         len = width;
1424         return (bhnd_nvram_getvar(dev, name, value, &len, type));
1425 }
1426
1427 /**
1428  * Read an NVRAM variable's unsigned 8-bit integer value.
1429  *
1430  * @param               dev     A bhnd bus child device.
1431  * @param               name    The NVRAM variable name.
1432  * @param[out]          value   On success, the requested value will be written
1433  *                              to this pointer.
1434  *
1435  * @retval 0            success
1436  * @retval ENOENT       The requested variable was not found.
1437  * @retval ENODEV       No valid NVRAM source could be found.
1438  * @retval EFTYPE       If the variable data cannot be coerced to a
1439  *                      a valid unsigned integer representation.
1440  * @retval ERANGE       If value coercion would overflow (or underflow) uint8_t.
1441  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1442  *                      error code will be returned.
1443  */
1444 int
1445 bhnd_nvram_getvar_uint8(device_t dev, const char *name, uint8_t *value)
1446 {
1447         return (bhnd_nvram_getvar_uint(dev, name, value, sizeof(*value)));
1448 }
1449
1450 /**
1451  * Read an NVRAM variable's unsigned 16-bit integer value.
1452  *
1453  * @param               dev     A bhnd bus child device.
1454  * @param               name    The NVRAM variable name.
1455  * @param[out]          value   On success, the requested value will be written
1456  *                              to this pointer.
1457  *
1458  * @retval 0            success
1459  * @retval ENOENT       The requested variable was not found.
1460  * @retval ENODEV       No valid NVRAM source could be found.
1461  * @retval EFTYPE       If the variable data cannot be coerced to a
1462  *                      a valid unsigned integer representation.
1463  * @retval ERANGE       If value coercion would overflow (or underflow)
1464  *                      uint16_t.
1465  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1466  *                      error code will be returned.
1467  */
1468 int
1469 bhnd_nvram_getvar_uint16(device_t dev, const char *name, uint16_t *value)
1470 {
1471         return (bhnd_nvram_getvar_uint(dev, name, value, sizeof(*value)));
1472 }
1473
1474 /**
1475  * Read an NVRAM variable's unsigned 32-bit integer value.
1476  *
1477  * @param               dev     A bhnd bus child device.
1478  * @param               name    The NVRAM variable name.
1479  * @param[out]          value   On success, the requested value will be written
1480  *                              to this pointer.
1481  *
1482  * @retval 0            success
1483  * @retval ENOENT       The requested variable was not found.
1484  * @retval ENODEV       No valid NVRAM source could be found.
1485  * @retval EFTYPE       If the variable data cannot be coerced to a
1486  *                      a valid unsigned integer representation.
1487  * @retval ERANGE       If value coercion would overflow (or underflow)
1488  *                      uint32_t.
1489  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1490  *                      error code will be returned.
1491  */
1492 int
1493 bhnd_nvram_getvar_uint32(device_t dev, const char *name, uint32_t *value)
1494 {
1495         return (bhnd_nvram_getvar_uint(dev, name, value, sizeof(*value)));
1496 }
1497
1498 /**
1499  * Read an NVRAM variable's signed integer value.
1500  *
1501  * @param               dev     A bhnd bus child device.
1502  * @param               name    The NVRAM variable name.
1503  * @param[out]          value   On success, the requested value will be written
1504  *                              to this pointer.
1505  * @param               width   The output integer type width (1, 2, or
1506  *                              4 bytes).
1507  *
1508  * @retval 0            success
1509  * @retval ENOENT       The requested variable was not found.
1510  * @retval ENODEV       No valid NVRAM source could be found.
1511  * @retval EFTYPE       If the variable data cannot be coerced to a
1512  *                      a valid integer representation.
1513  * @retval ERANGE       If value coercion would overflow (or underflow) an
1514  *                      signed representation of the given @p width.
1515  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1516  *                      error code will be returned.
1517  */
1518 int
1519 bhnd_nvram_getvar_int(device_t dev, const char *name, void *value, int width)
1520 {
1521         bhnd_nvram_type type;
1522         size_t          len;
1523
1524         switch (width) {
1525         case 1:
1526                 type = BHND_NVRAM_TYPE_INT8;
1527                 break;
1528         case 2:
1529                 type = BHND_NVRAM_TYPE_INT16;
1530                 break;
1531         case 4:
1532                 type = BHND_NVRAM_TYPE_INT32;
1533                 break;
1534         default:
1535                 device_printf(dev, "unsupported NVRAM integer width: %d\n",
1536                     width);
1537                 return (EINVAL);
1538         }
1539
1540         len = width;
1541         return (bhnd_nvram_getvar(dev, name, value, &len, type));
1542 }
1543
1544 /**
1545  * Read an NVRAM variable's signed 8-bit integer value.
1546  *
1547  * @param               dev     A bhnd bus child device.
1548  * @param               name    The NVRAM variable name.
1549  * @param[out]          value   On success, the requested value will be written
1550  *                              to this pointer.
1551  *
1552  * @retval 0            success
1553  * @retval ENOENT       The requested variable was not found.
1554  * @retval ENODEV       No valid NVRAM source could be found.
1555  * @retval EFTYPE       If the variable data cannot be coerced to a
1556  *                      a valid integer representation.
1557  * @retval ERANGE       If value coercion would overflow (or underflow) int8_t.
1558  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1559  *                      error code will be returned.
1560  */
1561 int
1562 bhnd_nvram_getvar_int8(device_t dev, const char *name, int8_t *value)
1563 {
1564         return (bhnd_nvram_getvar_int(dev, name, value, sizeof(*value)));
1565 }
1566
1567 /**
1568  * Read an NVRAM variable's signed 16-bit integer value.
1569  *
1570  * @param               dev     A bhnd bus child device.
1571  * @param               name    The NVRAM variable name.
1572  * @param[out]          value   On success, the requested value will be written
1573  *                              to this pointer.
1574  *
1575  * @retval 0            success
1576  * @retval ENOENT       The requested variable was not found.
1577  * @retval ENODEV       No valid NVRAM source could be found.
1578  * @retval EFTYPE       If the variable data cannot be coerced to a
1579  *                      a valid integer representation.
1580  * @retval ERANGE       If value coercion would overflow (or underflow)
1581  *                      int16_t.
1582  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1583  *                      error code will be returned.
1584  */
1585 int
1586 bhnd_nvram_getvar_int16(device_t dev, const char *name, int16_t *value)
1587 {
1588         return (bhnd_nvram_getvar_int(dev, name, value, sizeof(*value)));
1589 }
1590
1591 /**
1592  * Read an NVRAM variable's signed 32-bit integer value.
1593  *
1594  * @param               dev     A bhnd bus child device.
1595  * @param               name    The NVRAM variable name.
1596  * @param[out]          value   On success, the requested value will be written
1597  *                              to this pointer.
1598  *
1599  * @retval 0            success
1600  * @retval ENOENT       The requested variable was not found.
1601  * @retval ENODEV       No valid NVRAM source could be found.
1602  * @retval EFTYPE       If the variable data cannot be coerced to a
1603  *                      a valid integer representation.
1604  * @retval ERANGE       If value coercion would overflow (or underflow)
1605  *                      int32_t.
1606  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1607  *                      error code will be returned.
1608  */
1609 int
1610 bhnd_nvram_getvar_int32(device_t dev, const char *name, int32_t *value)
1611 {
1612         return (bhnd_nvram_getvar_int(dev, name, value, sizeof(*value)));
1613 }
1614
1615
1616 /**
1617  * Read an NVRAM variable's array value.
1618  *
1619  * @param               dev     A bhnd bus child device.
1620  * @param               name    The NVRAM variable name.
1621  * @param[out]          buf     A buffer large enough to hold @p size bytes.
1622  *                              On success, the requested value will be written
1623  *                              to this buffer.
1624  * @param[in,out]       size    The required number of bytes to write to
1625  *                              @p buf.
1626  * @param               type    The desired array element data representation.
1627  *
1628  * @retval 0            success
1629  * @retval ENOENT       The requested variable was not found.
1630  * @retval ENODEV       No valid NVRAM source could be found.
1631  * @retval ENXIO        If less than @p size bytes are available.
1632  * @retval ENOMEM       If a buffer of @p size is too small to hold the
1633  *                      requested value.
1634  * @retval EFTYPE       If the variable data cannot be coerced to a
1635  *                      a valid instance of @p type.
1636  * @retval ERANGE       If value coercion would overflow (or underflow) a
1637  *                      representation of @p type.
1638  * @retval non-zero     If reading @p name otherwise fails, a regular unix
1639  *                      error code will be returned.
1640  */
1641 int
1642 bhnd_nvram_getvar_array(device_t dev, const char *name, void *buf, size_t size,
1643     bhnd_nvram_type type)
1644 {
1645         size_t  nbytes;
1646         int     error;
1647
1648         /* Attempt read */
1649         nbytes = size;
1650         if ((error = bhnd_nvram_getvar(dev, name, buf, &nbytes, type)))
1651                 return (error);
1652
1653         /* Verify that the expected number of bytes were fetched */
1654         if (nbytes < size)
1655                 return (ENXIO);
1656
1657         return (0);
1658 }
1659
1660 /**
1661  * Initialize a service provider registry.
1662  *
1663  * @param bsr           The service registry to initialize.
1664  *
1665  * @retval 0            success
1666  * @retval non-zero     if an error occurs initializing the service registry,
1667  *                      a regular unix error code will be returned.
1668
1669  */
1670 int
1671 bhnd_service_registry_init(struct bhnd_service_registry *bsr)
1672 {
1673         STAILQ_INIT(&bsr->entries);
1674         mtx_init(&bsr->lock, "bhnd_service_registry lock", NULL, MTX_DEF);
1675
1676         return (0);
1677 }
1678
1679 /**
1680  * Release all resources held by @p bsr.
1681  *
1682  * @param bsr           A service registry instance previously successfully
1683  *                      initialized via bhnd_service_registry_init().
1684  *
1685  * @retval 0            success
1686  * @retval EBUSY        if active references to service providers registered
1687  *                      with @p bsr exist.
1688  */
1689 int
1690 bhnd_service_registry_fini(struct bhnd_service_registry *bsr)
1691 {
1692         struct bhnd_service_entry *entry, *enext;
1693
1694         /* Remove everthing we can */
1695         mtx_lock(&bsr->lock);
1696         STAILQ_FOREACH_SAFE(entry, &bsr->entries, link, enext) {
1697                 if (entry->refs > 0)
1698                         continue;
1699
1700                 STAILQ_REMOVE(&bsr->entries, entry, bhnd_service_entry, link);
1701                 free(entry, M_BHND);
1702         }
1703
1704         if (!STAILQ_EMPTY(&bsr->entries)) {
1705                 mtx_unlock(&bsr->lock);
1706                 return (EBUSY);
1707         }
1708         mtx_unlock(&bsr->lock);
1709
1710         mtx_destroy(&bsr->lock);
1711         return (0);
1712 }
1713
1714 /**
1715  * Register a @p provider for the given @p service.
1716  *
1717  * @param bsr           Service registry to be modified.
1718  * @param provider      Service provider to register.
1719  * @param service       Service for which @p provider will be registered.
1720  * @param flags         Service provider flags (see BHND_SPF_*).
1721  *
1722  * @retval 0            success
1723  * @retval EEXIST       if an entry for @p service already exists.
1724  * @retval EINVAL       if @p service is BHND_SERVICE_ANY.
1725  * @retval non-zero     if registering @p provider otherwise fails, a regular
1726  *                      unix error code will be returned.
1727  */
1728 int
1729 bhnd_service_registry_add(struct bhnd_service_registry *bsr, device_t provider,
1730     bhnd_service_t service, uint32_t flags)
1731 {
1732         struct bhnd_service_entry *entry;
1733
1734         if (service == BHND_SERVICE_ANY)
1735                 return (EINVAL);
1736
1737         mtx_lock(&bsr->lock);
1738
1739         /* Is a service provider already registered? */
1740         STAILQ_FOREACH(entry, &bsr->entries, link) {
1741                 if (entry->service == service) {
1742                         mtx_unlock(&bsr->lock);
1743                         return (EEXIST);
1744                 }
1745         }
1746
1747         /* Initialize and insert our new entry */
1748         entry = malloc(sizeof(*entry), M_BHND, M_NOWAIT);
1749         if (entry == NULL) {
1750                 mtx_unlock(&bsr->lock);
1751                 return (ENOMEM);
1752         }
1753
1754         entry->provider = provider;
1755         entry->service = service;
1756         entry->flags = flags;
1757         refcount_init(&entry->refs, 0);
1758
1759         STAILQ_INSERT_HEAD(&bsr->entries, entry, link);
1760
1761         mtx_unlock(&bsr->lock);
1762         return (0);
1763 }
1764
1765 /**
1766  * Free an unreferenced registry entry.
1767  *
1768  * @param entry The entry to be deallocated.
1769  */
1770 static void
1771 bhnd_service_registry_free_entry(struct bhnd_service_entry *entry)
1772 {
1773         KASSERT(entry->refs == 0, ("provider has active references"));
1774         free(entry, M_BHND);
1775 }
1776
1777 /**
1778  * Attempt to remove the @p service provider registration for @p provider.
1779  *
1780  * @param bsr           The service registry to be modified.
1781  * @param provider      The service provider to be deregistered.
1782  * @param service       The service for which @p provider will be deregistered,
1783  *                      or BHND_SERVICE_ANY to remove all service
1784  *                      registrations for @p provider.
1785  *
1786  * @retval 0            success
1787  * @retval EBUSY        if active references to @p provider exist; see
1788  *                      bhnd_service_registry_retain() and
1789  *                      bhnd_service_registry_release().
1790  */
1791 int
1792 bhnd_service_registry_remove(struct bhnd_service_registry *bsr,
1793     device_t provider, bhnd_service_t service)
1794 {
1795         struct bhnd_service_entry *entry, *enext;
1796
1797         mtx_lock(&bsr->lock);
1798
1799 #define BHND_PROV_MATCH(_e)     \
1800         ((_e)->provider == provider &&  \
1801          (service == BHND_SERVICE_ANY || (_e)->service == service))
1802
1803         /* Validate matching provider entries before making any
1804          * modifications */
1805         STAILQ_FOREACH(entry, &bsr->entries, link) {
1806                 /* Skip non-matching entries */
1807                 if (!BHND_PROV_MATCH(entry))
1808                         continue;
1809
1810                 /* Entry is in use? */
1811                 if (entry->refs > 0) {
1812                         mtx_unlock(&bsr->lock);
1813                         return (EBUSY);
1814                 }
1815         }
1816
1817         /* We can now safely remove matching entries */
1818         STAILQ_FOREACH_SAFE(entry, &bsr->entries, link, enext) {
1819                 /* Skip non-matching entries */
1820                 if (!BHND_PROV_MATCH(entry))
1821                         continue;
1822
1823                 /* Remove from list */
1824                 STAILQ_REMOVE(&bsr->entries, entry, bhnd_service_entry, link);
1825
1826                 /* Free provider entry */
1827                 bhnd_service_registry_free_entry(entry);
1828         }
1829 #undef  BHND_PROV_MATCH
1830
1831         mtx_unlock(&bsr->lock);
1832         return (0);
1833 }
1834
1835 /**
1836  * Retain and return a reference to a registered @p service provider, if any.
1837  *
1838  * @param bsr           The service registry to be queried.
1839  * @param service       The service for which a provider should be returned.
1840  *
1841  * On success, the caller assumes ownership the returned provider, and
1842  * is responsible for releasing this reference via
1843  * bhnd_service_registry_release().
1844  *
1845  * @retval device_t     success
1846  * @retval NULL         if no provider is registered for @p service.
1847  */
1848 device_t
1849 bhnd_service_registry_retain(struct bhnd_service_registry *bsr,
1850     bhnd_service_t service)
1851 {
1852         struct bhnd_service_entry *entry;
1853
1854         mtx_lock(&bsr->lock);
1855         STAILQ_FOREACH(entry, &bsr->entries, link) {
1856                 if (entry->service != service)
1857                         continue;
1858
1859                 /* With a live refcount, entry is gauranteed to remain alive
1860                  * after we release our lock */
1861                 refcount_acquire(&entry->refs);
1862
1863                 mtx_unlock(&bsr->lock);
1864                 return (entry->provider);
1865         }
1866         mtx_unlock(&bsr->lock);
1867
1868         /* Not found */
1869         return (NULL);
1870 }
1871
1872 /**
1873  * Release a reference to a service provider previously returned by
1874  * bhnd_service_registry_retain().
1875  *
1876  * If this is the last reference to an inherited service provider registration
1877  * (see BHND_SPF_INHERITED), the registration will also be removed, and
1878  * true will be returned.
1879  *
1880  * @param bsr           The service registry from which @p provider
1881  *                      was returned.
1882  * @param provider      The provider to be released.
1883  * @param service       The service for which @p provider was previously
1884  *                      retained.
1885  * @retval true         The inherited service provider registration was removed;
1886  *                      the caller should release its own reference to the
1887  *                      provider.
1888  * @retval false        The service provider was not inherited, or active
1889  *                      references to the provider remain.
1890  *
1891  * @see BHND_SPF_INHERITED
1892  */
1893 bool
1894 bhnd_service_registry_release(struct bhnd_service_registry *bsr,
1895     device_t provider, bhnd_service_t service)
1896 {
1897         struct bhnd_service_entry *entry;
1898
1899         /* Exclusive lock, as we need to prevent any new references to the
1900          * entry from being taken if it's to be removed */
1901         mtx_lock(&bsr->lock);
1902         STAILQ_FOREACH(entry, &bsr->entries, link) {
1903                 bool removed;
1904
1905                 if (entry->provider != provider)
1906                         continue;
1907
1908                 if (entry->service != service)
1909                         continue;
1910
1911                 if (refcount_release(&entry->refs) &&
1912                     (entry->flags & BHND_SPF_INHERITED))
1913                 {
1914                         /* If an inherited entry is no longer actively
1915                          * referenced, remove the local registration and inform
1916                          * the caller. */
1917                         STAILQ_REMOVE(&bsr->entries, entry, bhnd_service_entry,
1918                             link);
1919                         bhnd_service_registry_free_entry(entry);
1920                         removed = true;
1921                 } else {
1922                         removed = false;
1923                 }
1924
1925                 mtx_unlock(&bsr->lock);
1926                 return (removed);
1927         }
1928
1929         /* Caller owns a reference, but no such provider is registered? */
1930         panic("invalid service provider reference");
1931 }
1932
1933 /**
1934  * Using the bhnd(4) bus-level core information and a custom core name,
1935  * populate @p dev's device description.
1936  *
1937  * @param dev A bhnd-bus attached device.
1938  * @param dev_name The core's name (e.g. "SDIO Device Core").
1939  */
1940 void
1941 bhnd_set_custom_core_desc(device_t dev, const char *dev_name)
1942 {
1943         const char *vendor_name;
1944         char *desc;
1945
1946         vendor_name = bhnd_get_vendor_name(dev);
1947         asprintf(&desc, M_BHND, "%s %s, rev %hhu", vendor_name, dev_name,
1948             bhnd_get_hwrev(dev));
1949
1950         if (desc != NULL) {
1951                 device_set_desc_copy(dev, desc);
1952                 free(desc, M_BHND);
1953         } else {
1954                 device_set_desc(dev, dev_name);
1955         }
1956 }
1957
1958 /**
1959  * Using the bhnd(4) bus-level core information, populate @p dev's device
1960  * description.
1961  *
1962  * @param dev A bhnd-bus attached device.
1963  */
1964 void
1965 bhnd_set_default_core_desc(device_t dev)
1966 {
1967         bhnd_set_custom_core_desc(dev, bhnd_get_device_name(dev));
1968 }
1969
1970
1971 /**
1972  * Using the bhnd @p chip_id, populate the bhnd(4) bus @p dev's device
1973  * description.
1974  *
1975  * @param dev A bhnd-bus attached device.
1976  * @param chip_id The chip identification.
1977  */
1978 void
1979 bhnd_set_default_bus_desc(device_t dev, const struct bhnd_chipid *chip_id)
1980 {
1981         const char      *bus_name;
1982         char            *desc;
1983         char             chip_name[BHND_CHIPID_MAX_NAMELEN];
1984
1985         /* Determine chip type's bus name */
1986         switch (chip_id->chip_type) {
1987         case BHND_CHIPTYPE_SIBA:
1988                 bus_name = "SIBA bus";
1989                 break;
1990         case BHND_CHIPTYPE_BCMA:
1991         case BHND_CHIPTYPE_BCMA_ALT:
1992                 bus_name = "BCMA bus";
1993                 break;
1994         case BHND_CHIPTYPE_UBUS:
1995                 bus_name = "UBUS bus";
1996                 break;
1997         default:
1998                 bus_name = "Unknown Type";
1999                 break;
2000         }
2001
2002         /* Format chip name */
2003         bhnd_format_chip_id(chip_name, sizeof(chip_name),
2004              chip_id->chip_id);
2005
2006         /* Format and set device description */
2007         asprintf(&desc, M_BHND, "%s %s", chip_name, bus_name);
2008         if (desc != NULL) {
2009                 device_set_desc_copy(dev, desc);
2010                 free(desc, M_BHND);
2011         } else {
2012                 device_set_desc(dev, bus_name);
2013         }
2014
2015 }
2016
2017 /**
2018  * Helper function for implementing BHND_BUS_REGISTER_PROVIDER().
2019  *
2020  * This implementation delegates the request to the BHND_BUS_REGISTER_PROVIDER()
2021  * method on the parent of @p dev. If no parent exists, the implementation
2022  * will return an error.
2023  */
2024 int
2025 bhnd_bus_generic_register_provider(device_t dev, device_t child,
2026     device_t provider, bhnd_service_t service)
2027 {
2028         device_t parent = device_get_parent(dev);
2029
2030         if (parent != NULL) {
2031                 return (BHND_BUS_REGISTER_PROVIDER(parent, child,
2032                     provider, service));
2033         }
2034
2035         return (ENXIO);
2036 }
2037
2038 /**
2039  * Helper function for implementing BHND_BUS_DEREGISTER_PROVIDER().
2040  *
2041  * This implementation delegates the request to the
2042  * BHND_BUS_DEREGISTER_PROVIDER() method on the parent of @p dev. If no parent
2043  * exists, the implementation will panic.
2044  */
2045 int
2046 bhnd_bus_generic_deregister_provider(device_t dev, device_t child,
2047     device_t provider, bhnd_service_t service)
2048 {
2049         device_t parent = device_get_parent(dev);
2050
2051         if (parent != NULL) {
2052                 return (BHND_BUS_DEREGISTER_PROVIDER(parent, child,
2053                     provider, service));
2054         }
2055
2056         panic("missing BHND_BUS_DEREGISTER_PROVIDER()");
2057 }
2058
2059 /**
2060  * Helper function for implementing BHND_BUS_RETAIN_PROVIDER().
2061  *
2062  * This implementation delegates the request to the
2063  * BHND_BUS_DEREGISTER_PROVIDER() method on the parent of @p dev. If no parent
2064  * exists, the implementation will return NULL.
2065  */
2066 device_t
2067 bhnd_bus_generic_retain_provider(device_t dev, device_t child,
2068     bhnd_service_t service)
2069 {
2070         device_t parent = device_get_parent(dev);
2071
2072         if (parent != NULL) {
2073                 return (BHND_BUS_RETAIN_PROVIDER(parent, child,
2074                     service));
2075         }
2076
2077         return (NULL);
2078 }
2079
2080 /**
2081  * Helper function for implementing BHND_BUS_RELEASE_PROVIDER().
2082  *
2083  * This implementation delegates the request to the
2084  * BHND_BUS_DEREGISTER_PROVIDER() method on the parent of @p dev. If no parent
2085  * exists, the implementation will panic.
2086  */
2087 void
2088 bhnd_bus_generic_release_provider(device_t dev, device_t child,
2089     device_t provider, bhnd_service_t service)
2090 {
2091         device_t parent = device_get_parent(dev);
2092
2093         if (parent != NULL) {
2094                 return (BHND_BUS_RELEASE_PROVIDER(parent, child,
2095                     provider, service));
2096         }
2097
2098         panic("missing BHND_BUS_RELEASE_PROVIDER()");
2099 }
2100
2101 /**
2102  * Helper function for implementing BHND_BUS_REGISTER_PROVIDER().
2103  *
2104  * This implementation uses the bhnd_service_registry_add() function to
2105  * do most of the work. It calls BHND_BUS_GET_SERVICE_REGISTRY() to find
2106  * a suitable service registry to edit.
2107  */
2108 int
2109 bhnd_bus_generic_sr_register_provider(device_t dev, device_t child,
2110     device_t provider, bhnd_service_t service)
2111 {
2112         struct bhnd_service_registry *bsr;
2113
2114         bsr = BHND_BUS_GET_SERVICE_REGISTRY(dev, child);
2115
2116         KASSERT(bsr != NULL, ("NULL service registry"));
2117
2118         return (bhnd_service_registry_add(bsr, provider, service, 0));
2119 }
2120
2121 /**
2122  * Helper function for implementing BHND_BUS_DEREGISTER_PROVIDER().
2123  *
2124  * This implementation uses the bhnd_service_registry_remove() function to
2125  * do most of the work. It calls BHND_BUS_GET_SERVICE_REGISTRY() to find
2126  * a suitable service registry to edit.
2127  */
2128 int
2129 bhnd_bus_generic_sr_deregister_provider(device_t dev, device_t child,
2130     device_t provider, bhnd_service_t service)
2131 {
2132         struct bhnd_service_registry *bsr;
2133
2134         bsr = BHND_BUS_GET_SERVICE_REGISTRY(dev, child);
2135
2136         KASSERT(bsr != NULL, ("NULL service registry"));
2137
2138         return (bhnd_service_registry_remove(bsr, provider, service));
2139 }
2140
2141 /**
2142  * Helper function for implementing BHND_BUS_RETAIN_PROVIDER().
2143  *
2144  * This implementation uses the bhnd_service_registry_retain() function to
2145  * do most of the work. It calls BHND_BUS_GET_SERVICE_REGISTRY() to find
2146  * a suitable service registry.
2147  *
2148  * If a local provider for the service is not available, and a parent device is
2149  * available, this implementation will attempt to fetch and locally register
2150  * a service provider reference from the parent of @p dev.
2151  */
2152 device_t
2153 bhnd_bus_generic_sr_retain_provider(device_t dev, device_t child,
2154     bhnd_service_t service)
2155 {
2156         struct bhnd_service_registry    *bsr;
2157         device_t                         parent, provider;
2158         int                              error;
2159
2160         bsr = BHND_BUS_GET_SERVICE_REGISTRY(dev, child);
2161         KASSERT(bsr != NULL, ("NULL service registry"));
2162
2163         /*
2164          * Attempt to fetch a service provider reference from either the local
2165          * service registry, or if not found, from our parent.
2166          *
2167          * If we fetch a provider from our parent, we register the provider
2168          * with the local service registry to prevent conflicting local
2169          * registrations from being added.
2170          */
2171         while (1) {
2172                 /* Check the local service registry first */
2173                 provider = bhnd_service_registry_retain(bsr, service);
2174                 if (provider != NULL)
2175                         return (provider);
2176
2177                 /* Otherwise, try to delegate to our parent (if any) */
2178                 if ((parent = device_get_parent(dev)) == NULL)
2179                         return (NULL);
2180
2181                 provider = BHND_BUS_RETAIN_PROVIDER(parent, dev, service);
2182                 if (provider == NULL)
2183                         return (NULL);
2184
2185                 /* Register the inherited service registration with the local
2186                  * registry */
2187                 error = bhnd_service_registry_add(bsr, provider, service,
2188                     BHND_SPF_INHERITED);
2189                 if (error) {
2190                         BHND_BUS_RELEASE_PROVIDER(parent, dev, provider,
2191                             service);
2192                         if (error == EEXIST) {
2193                                 /* A valid service provider was registered
2194                                  * concurrently; retry fetching from the local
2195                                  * registry */
2196                                 continue;
2197                         }
2198
2199                         device_printf(dev, "failed to register service "
2200                             "provider: %d\n", error);
2201                         return (NULL);
2202                 }
2203         }
2204 }
2205
2206 /**
2207  * Helper function for implementing BHND_BUS_RELEASE_PROVIDER().
2208  *
2209  * This implementation uses the bhnd_service_registry_release() function to
2210  * do most of the work. It calls BHND_BUS_GET_SERVICE_REGISTRY() to find
2211  * a suitable service registry.
2212  */
2213 void
2214 bhnd_bus_generic_sr_release_provider(device_t dev, device_t child,
2215     device_t provider, bhnd_service_t service)
2216 {
2217         struct bhnd_service_registry    *bsr;
2218
2219         bsr = BHND_BUS_GET_SERVICE_REGISTRY(dev, child);
2220         KASSERT(bsr != NULL, ("NULL service registry"));
2221
2222         /* Release the provider reference; if the refcount hits zero on an
2223          * inherited reference, true will be returned, and we need to drop
2224          * our own bus reference to the provider */
2225         if (!bhnd_service_registry_release(bsr, provider, service))
2226                 return;
2227
2228         /* Drop our reference to the borrowed provider */
2229         BHND_BUS_RELEASE_PROVIDER(device_get_parent(dev), dev, provider,
2230             service);
2231 }
2232
2233 /**
2234  * Helper function for implementing BHND_BUS_IS_HW_DISABLED().
2235  *
2236  * If a parent device is available, this implementation delegates the
2237  * request to the BHND_BUS_IS_HW_DISABLED() method on the parent of @p dev.
2238  *
2239  * If no parent device is available (i.e. on a the bus root), the hardware
2240  * is assumed to be usable and false is returned.
2241  */
2242 bool
2243 bhnd_bus_generic_is_hw_disabled(device_t dev, device_t child)
2244 {
2245         if (device_get_parent(dev) != NULL)
2246                 return (BHND_BUS_IS_HW_DISABLED(device_get_parent(dev), child));
2247
2248         return (false);
2249 }
2250
2251 /**
2252  * Helper function for implementing BHND_BUS_GET_CHIPID().
2253  *
2254  * This implementation delegates the request to the BHND_BUS_GET_CHIPID()
2255  * method on the parent of @p dev. If no parent exists, the implementation
2256  * will panic.
2257  */
2258 const struct bhnd_chipid *
2259 bhnd_bus_generic_get_chipid(device_t dev, device_t child)
2260 {
2261         if (device_get_parent(dev) != NULL)
2262                 return (BHND_BUS_GET_CHIPID(device_get_parent(dev), child));
2263
2264         panic("missing BHND_BUS_GET_CHIPID()");
2265 }
2266
2267 /**
2268  * Helper function for implementing BHND_BUS_GET_DMA_TRANSLATION().
2269  *
2270  * If a parent device is available, this implementation delegates the
2271  * request to the BHND_BUS_GET_DMA_TRANSLATION() method on the parent of @p dev.
2272  *
2273  * If no parent device is available, this implementation will panic.
2274  */
2275 int
2276 bhnd_bus_generic_get_dma_translation(device_t dev, device_t child, u_int width,
2277     uint32_t flags, bus_dma_tag_t *dmat,
2278     struct bhnd_dma_translation *translation)
2279 {
2280         if (device_get_parent(dev) != NULL) {
2281                 return (BHND_BUS_GET_DMA_TRANSLATION(device_get_parent(dev),
2282                     child, width, flags, dmat, translation));
2283         }
2284
2285         panic("missing BHND_BUS_GET_DMA_TRANSLATION()");
2286 }
2287
2288 /* nvram board_info population macros for bhnd_bus_generic_read_board_info() */
2289 #define BHND_GV(_dest, _name)   \
2290         bhnd_nvram_getvar_uint(child, BHND_NVAR_ ## _name, &_dest,      \
2291             sizeof(_dest))
2292
2293 #define REQ_BHND_GV(_dest, _name)               do {                    \
2294         if ((error = BHND_GV(_dest, _name))) {                          \
2295                 device_printf(dev,                                      \
2296                     "error reading " __STRING(_name) ": %d\n", error);  \
2297                 return (error);                                         \
2298         }                                                               \
2299 } while(0)
2300
2301 #define OPT_BHND_GV(_dest, _name, _default)     do {                    \
2302         if ((error = BHND_GV(_dest, _name))) {                          \
2303                 if (error != ENOENT) {                                  \
2304                         device_printf(dev,                              \
2305                             "error reading "                            \
2306                                __STRING(_name) ": %d\n", error);        \
2307                         return (error);                                 \
2308                 }                                                       \
2309                 _dest = _default;                                       \
2310         }                                                               \
2311 } while(0)
2312
2313 /**
2314  * Helper function for implementing BHND_BUS_READ_BOARDINFO().
2315  *
2316  * This implementation populates @p info with information from NVRAM,
2317  * defaulting board_vendor and board_type fields to 0 if the
2318  * requested variables cannot be found.
2319  *
2320  * This behavior is correct for most SoCs, but must be overridden on
2321  * bridged (PCI, PCMCIA, etc) devices to produce a complete bhnd_board_info
2322  * result.
2323  */
2324 int
2325 bhnd_bus_generic_read_board_info(device_t dev, device_t child,
2326     struct bhnd_board_info *info)
2327 {
2328         int     error;
2329
2330         OPT_BHND_GV(info->board_vendor, BOARDVENDOR,    0);
2331         OPT_BHND_GV(info->board_type,   BOARDTYPE,      0);     /* srom >= 2 */
2332         OPT_BHND_GV(info->board_devid,  DEVID,          0);     /* srom >= 8 */
2333         REQ_BHND_GV(info->board_rev,    BOARDREV);
2334         OPT_BHND_GV(info->board_srom_rev,SROMREV,       0);     /* missing in
2335                                                                    some SoC
2336                                                                    NVRAM */
2337         REQ_BHND_GV(info->board_flags,  BOARDFLAGS);
2338         OPT_BHND_GV(info->board_flags2, BOARDFLAGS2,    0);     /* srom >= 4 */
2339         OPT_BHND_GV(info->board_flags3, BOARDFLAGS3,    0);     /* srom >= 11 */
2340
2341         return (0);
2342 }
2343
2344 #undef  BHND_GV
2345 #undef  BHND_GV_REQ
2346 #undef  BHND_GV_OPT
2347
2348 /**
2349  * Helper function for implementing BHND_BUS_GET_NVRAM_VAR().
2350  *
2351  * This implementation searches @p dev for a usable NVRAM child device.
2352  *
2353  * If no usable child device is found on @p dev, the request is delegated to
2354  * the BHND_BUS_GET_NVRAM_VAR() method on the parent of @p dev.
2355  */
2356 int
2357 bhnd_bus_generic_get_nvram_var(device_t dev, device_t child, const char *name,
2358     void *buf, size_t *size, bhnd_nvram_type type)
2359 {
2360         device_t        nvram;
2361         device_t        parent;
2362
2363         /* Make sure we're holding Giant for newbus */
2364         GIANT_REQUIRED;
2365
2366         /* Look for a directly-attached NVRAM child */
2367         if ((nvram = device_find_child(dev, "bhnd_nvram", -1)) != NULL)
2368                 return BHND_NVRAM_GETVAR(nvram, name, buf, size, type);
2369
2370         /* Try to delegate to parent */
2371         if ((parent = device_get_parent(dev)) == NULL)
2372                 return (ENODEV);
2373
2374         return (BHND_BUS_GET_NVRAM_VAR(device_get_parent(dev), child,
2375             name, buf, size, type));
2376 }
2377
2378 /**
2379  * Helper function for implementing BHND_BUS_ALLOC_RESOURCE().
2380  *
2381  * This implementation of BHND_BUS_ALLOC_RESOURCE() delegates allocation
2382  * of the underlying resource to BUS_ALLOC_RESOURCE(), and activation
2383  * to @p dev's BHND_BUS_ACTIVATE_RESOURCE().
2384  */
2385 struct bhnd_resource *
2386 bhnd_bus_generic_alloc_resource(device_t dev, device_t child, int type,
2387         int *rid, rman_res_t start, rman_res_t end, rman_res_t count,
2388         u_int flags)
2389 {
2390         struct bhnd_resource    *br;
2391         struct resource         *res;
2392         int                      error;
2393
2394         br = NULL;
2395         res = NULL;
2396
2397         /* Allocate the real bus resource (without activating it) */
2398         res = BUS_ALLOC_RESOURCE(dev, child, type, rid, start, end, count,
2399             (flags & ~RF_ACTIVE));
2400         if (res == NULL)
2401                 return (NULL);
2402
2403         /* Allocate our bhnd resource wrapper. */
2404         br = malloc(sizeof(struct bhnd_resource), M_BHND, M_NOWAIT);
2405         if (br == NULL)
2406                 goto failed;
2407
2408         br->direct = false;
2409         br->res = res;
2410
2411         /* Attempt activation */
2412         if (flags & RF_ACTIVE) {
2413                 error = BHND_BUS_ACTIVATE_RESOURCE(dev, child, type, *rid, br);
2414                 if (error)
2415                         goto failed;
2416         }
2417
2418         return (br);
2419
2420 failed:
2421         if (res != NULL)
2422                 BUS_RELEASE_RESOURCE(dev, child, type, *rid, res);
2423
2424         free(br, M_BHND);
2425         return (NULL);
2426 }
2427
2428 /**
2429  * Helper function for implementing BHND_BUS_RELEASE_RESOURCE().
2430  *
2431  * This implementation of BHND_BUS_RELEASE_RESOURCE() delegates release of
2432  * the backing resource to BUS_RELEASE_RESOURCE().
2433  */
2434 int
2435 bhnd_bus_generic_release_resource(device_t dev, device_t child, int type,
2436     int rid, struct bhnd_resource *r)
2437 {
2438         int error;
2439
2440         if ((error = BUS_RELEASE_RESOURCE(dev, child, type, rid, r->res)))
2441                 return (error);
2442
2443         free(r, M_BHND);
2444         return (0);
2445 }
2446
2447
2448 /**
2449  * Helper function for implementing BHND_BUS_ACTIVATE_RESOURCE().
2450  *
2451  * This implementation of BHND_BUS_ACTIVATE_RESOURCE() first calls the
2452  * BHND_BUS_ACTIVATE_RESOURCE() method of the parent of @p dev.
2453  *
2454  * If this fails, and if @p dev is the direct parent of @p child, standard
2455  * resource activation is attempted via bus_activate_resource(). This enables
2456  * direct use of the bhnd(4) resource APIs on devices that may not be attached
2457  * to a parent bhnd bus or bridge.
2458  */
2459 int
2460 bhnd_bus_generic_activate_resource(device_t dev, device_t child, int type,
2461     int rid, struct bhnd_resource *r)
2462 {
2463         int     error;
2464         bool    passthrough;
2465
2466         passthrough = (device_get_parent(child) != dev);
2467
2468         /* Try to delegate to the parent */
2469         if (device_get_parent(dev) != NULL) {
2470                 error = BHND_BUS_ACTIVATE_RESOURCE(device_get_parent(dev),
2471                     child, type, rid, r);
2472         } else {
2473                 error = ENODEV;
2474         }
2475
2476         /* If bhnd(4) activation has failed and we're the child's direct
2477          * parent, try falling back on standard resource activation.
2478          */
2479         if (error && !passthrough) {
2480                 error = bus_activate_resource(child, type, rid, r->res);
2481                 if (!error)
2482                         r->direct = true;
2483         }
2484
2485         return (error);
2486 }
2487
2488 /**
2489  * Helper function for implementing BHND_BUS_DEACTIVATE_RESOURCE().
2490  *
2491  * This implementation of BHND_BUS_ACTIVATE_RESOURCE() simply calls the
2492  * BHND_BUS_ACTIVATE_RESOURCE() method of the parent of @p dev.
2493  */
2494 int
2495 bhnd_bus_generic_deactivate_resource(device_t dev, device_t child,
2496     int type, int rid, struct bhnd_resource *r)
2497 {
2498         if (device_get_parent(dev) != NULL)
2499                 return (BHND_BUS_DEACTIVATE_RESOURCE(device_get_parent(dev),
2500                     child, type, rid, r));
2501
2502         return (EINVAL);
2503 }
2504
2505 /**
2506  * Helper function for implementing BHND_BUS_GET_INTR_DOMAIN().
2507  *
2508  * This implementation simply returns the address of nearest bhnd(4) bus,
2509  * which may be @p dev; this behavior may be incompatible with FDT/OFW targets.
2510  */
2511 uintptr_t
2512 bhnd_bus_generic_get_intr_domain(device_t dev, device_t child, bool self)
2513 {
2514         return ((uintptr_t)dev);
2515 }