xref: /freebsd/sys/dev/bhnd/bhndb/bhndb.c (revision 7fdf597e96a02165cfe22ff357b857d5fa15ed8a)

/*-
 * Copyright (c) 2015-2016 Landon Fuller <landon@landonf.org>
 * Copyright (c) 2017 The FreeBSD Foundation
 * All rights reserved.
 *
 * Portions of this software were developed by Landon Fuller
 * under sponsorship from the FreeBSD Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
 *    redistribution must be conditioned upon including a substantially
 *    similar Disclaimer requirement for further binary redistribution.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGES.
 */

#include <sys/cdefs.h>
/*
 * Abstract BHND Bridge Device Driver
 *
 * Provides generic support for bridging from a parent bus (such as PCI) to
 * a BHND-compatible bus (e.g. bcma or siba).
 */

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/module.h>
#include <sys/sbuf.h>
#include <sys/systm.h>

#include <machine/bus.h>
#include <sys/rman.h>
#include <machine/resource.h>

#include <dev/bhnd/bhndvar.h>
#include <dev/bhnd/bhndreg.h>

#include <dev/bhnd/bhnd_erom.h>

#include <dev/bhnd/cores/chipc/chipcreg.h>
#include <dev/bhnd/nvram/bhnd_nvram.h>

#include "bhnd_chipc_if.h"
#include "bhnd_nvram_if.h"

#include "bhndbvar.h"
#include "bhndb_bus_if.h"
#include "bhndb_hwdata.h"
#include "bhndb_private.h"

/* Debugging flags */
static u_long bhndb_debug = 0;
TUNABLE_ULONG("hw.bhndb.debug", &bhndb_debug);

enum {
	BHNDB_DEBUG_PRIO = 1 << 0,
};

#define	BHNDB_DEBUG(_type)	(BHNDB_DEBUG_ ## _type & bhndb_debug)

static bool			 bhndb_hw_matches(struct bhndb_softc *sc,
				     struct bhnd_core_info *cores, u_int ncores,
				     const struct bhndb_hw *hw);

static int			 bhndb_init_region_cfg(struct bhndb_softc *sc,
				     bhnd_erom_t *erom,
				     struct bhndb_resources *r,
				     struct bhnd_core_info *cores, u_int ncores,
				     const struct bhndb_hw_priority *table);

static int			 bhndb_find_hwspec(struct bhndb_softc *sc,
				     struct bhnd_core_info *cores, u_int ncores,
				     const struct bhndb_hw **hw);

bhndb_addrspace			 bhndb_get_addrspace(struct bhndb_softc *sc,
				     device_t child);

static struct rman		*bhndb_get_rman(struct bhndb_softc *sc,
				     device_t child, int type);

static int			 bhndb_init_child_resource(struct resource *r,
				     struct resource *parent,
				     bhnd_size_t offset,
				     bhnd_size_t size);

static int			 bhndb_activate_static_region(
				     struct bhndb_softc *sc,
				     struct bhndb_region *region,
				     device_t child, struct resource *r);

static int			 bhndb_try_activate_resource(
				     struct bhndb_softc *sc, device_t child,
				     struct resource *r, bool *indirect);

static inline struct bhndb_dw_alloc *bhndb_io_resource(struct bhndb_softc *sc,
					bus_addr_t addr, bus_size_t size,
					bus_size_t *offset, bool *stolen,
					bus_addr_t *restore);

/**
 * Default bhndb(4) implementation of DEVICE_PROBE().
 *
 * This function provides the default bhndb implementation of DEVICE_PROBE(),
 * and is compatible with bhndb(4) bridges attached via bhndb_attach_bridge().
 */
int
bhndb_generic_probe(device_t dev)
{
	return (BUS_PROBE_NOWILDCARD);
}

static void
bhndb_probe_nomatch(device_t dev, device_t child)
{
	const char *name;

	name = device_get_name(child);
	if (name == NULL)
		name = "unknown device";

	device_printf(dev, "<%s> (no driver attached)\n", name);
}

static int
bhndb_print_child(device_t dev, device_t child)
{
	struct resource_list	*rl;
	int			 retval = 0;

	retval += bus_print_child_header(dev, child);

	rl = BUS_GET_RESOURCE_LIST(dev, child);
	if (rl != NULL) {
		retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY,
		    "%#jx");
		retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ,
		    "%jd");
	}

	retval += bus_print_child_domain(dev, child);
	retval += bus_print_child_footer(dev, child);

	return (retval);
}

static int
bhndb_child_location(device_t dev, device_t child, struct sbuf *sb)
{
	struct bhndb_softc *sc;

	sc = device_get_softc(dev);

	sbuf_printf(sb, "base=0x%llx",
	    (unsigned long long) sc->chipid.enum_addr);
	return (0);
}

/**
 * Return true if @p cores matches the @p hw specification.
 *
 * @param sc BHNDB device state.
 * @param cores A device table to match against.
 * @param ncores The number of cores in @p cores.
 * @param hw The hardware description to be matched against.
 */
static bool
bhndb_hw_matches(struct bhndb_softc *sc, struct bhnd_core_info *cores,
    u_int ncores, const struct bhndb_hw *hw)
{
	for (u_int i = 0; i < hw->num_hw_reqs; i++) {
		const struct bhnd_core_match	*match;
		bool				 found;

		match =  &hw->hw_reqs[i];
		found = false;

		for (u_int d = 0; d < ncores; d++) {
			struct bhnd_core_info *core = &cores[d];

			if (BHNDB_IS_CORE_DISABLED(sc->dev, sc->bus_dev, core))
				continue;

			if (!bhnd_core_matches(core, match))
				continue;

			found = true;
			break;
		}

		if (!found)
			return (false);
	}

	return (true);
}

/**
 * Initialize the region maps and priority configuration in @p br using
 * the priority @p table and the set of cores enumerated by @p erom.
 *
 * @param sc The bhndb device state.
 * @param br The resource state to be configured.
 * @param erom EROM parser used to enumerate @p cores.
 * @param cores All cores enumerated on the bridged bhnd bus.
 * @param ncores The length of @p cores.
 * @param table Hardware priority table to be used to determine the relative
 * priorities of per-core port resources.
 */
static int
bhndb_init_region_cfg(struct bhndb_softc *sc, bhnd_erom_t *erom,
    struct bhndb_resources *br, struct bhnd_core_info *cores, u_int ncores,
    const struct bhndb_hw_priority *table)
{
	const struct bhndb_hw_priority	*hp;
	bhnd_addr_t			 addr;
	bhnd_size_t			 size;
	size_t				 prio_low, prio_default, prio_high;
	int				 error;

	/* The number of port regions per priority band that must be accessible
	 * via dynamic register windows */
	prio_low = 0;
	prio_default = 0;
	prio_high = 0;

	/*
	 * Register bridge regions covering all statically mapped ports.
	 */
	for (u_int i = 0; i < ncores; i++) {
		const struct bhndb_regwin	*regw;
		struct bhnd_core_info		*core;
		struct bhnd_core_match		 md;

		core = &cores[i];
		md = bhnd_core_get_match_desc(core);

		for (regw = br->cfg->register_windows;
		    regw->win_type != BHNDB_REGWIN_T_INVALID; regw++)
		{
			const struct bhndb_port_priority	*pp;
			uint32_t				 alloc_flags;

			/* Only core windows are supported */
			if (regw->win_type != BHNDB_REGWIN_T_CORE)
				continue;

			/* Skip non-matching cores. */
			if (!bhndb_regwin_match_core(regw, core))
				continue;

			/* Fetch the base address of the mapped port */
			error = bhnd_erom_lookup_core_addr(erom, &md,
			    regw->d.core.port_type,
			    regw->d.core.port,
			    regw->d.core.region,
			    NULL,
			    &addr,
			    &size);
			if (error) {
				/* Skip non-applicable register windows */
				if (error == ENOENT)
					continue;

				return (error);
			}

			/*
			 * Apply the register window's region offset, if any.
			 */
			if (regw->d.core.offset > size) {
				device_printf(sc->dev, "invalid register "
				    "window offset %#jx for region %#jx+%#jx\n",
				    regw->d.core.offset, addr, size);
				return (EINVAL);
			}

			addr += regw->d.core.offset;

			/*
			 * Always defer to the register window's size.
			 *
			 * If the port size is smaller than the window size,
			 * this ensures that we fully utilize register windows
			 * larger than the referenced port.
			 *
			 * If the port size is larger than the window size, this
			 * ensures that we do not directly map the allocations
			 * within the region to a too-small window.
			 */
			size = regw->win_size;

			/* Fetch allocation flags from the corresponding port
			 * priority entry, if any */
			pp = bhndb_hw_priorty_find_port(table, core,
			    regw->d.core.port_type, regw->d.core.port,
			    regw->d.core.region);
			if (pp != NULL) {
				alloc_flags = pp->alloc_flags;
			} else {
				alloc_flags = 0;
			}

			/*
			 * Add to the bus region list.
			 *
			 * The window priority for a statically mapped region is
			 * always HIGH.
			 */
			error = bhndb_add_resource_region(br, addr, size,
			    BHNDB_PRIORITY_HIGH, alloc_flags, regw);
			if (error)
				return (error);
		}
	}

	/*
	 * Perform priority accounting and register bridge regions for all
	 * ports defined in the priority table
	 */
	for (u_int i = 0; i < ncores; i++) {
		struct bhnd_core_info	*core;
		struct bhnd_core_match	 md;

		core = &cores[i];
		md = bhnd_core_get_match_desc(core);

		/*
		 * Skip priority accounting for cores that ...
		 */

		/* ... do not require bridge resources */
		if (BHNDB_IS_CORE_DISABLED(sc->dev, sc->bus_dev, core))
			continue;

		/* ... do not have a priority table entry */
		hp = bhndb_hw_priority_find_core(table, core);
		if (hp == NULL)
			continue;

		/* ... are explicitly disabled in the priority table. */
		if (hp->priority == BHNDB_PRIORITY_NONE)
			continue;

		/* Determine the number of dynamic windows required and
		 * register their bus_region entries. */
		for (u_int i = 0; i < hp->num_ports; i++) {
			const struct bhndb_port_priority *pp;

			pp = &hp->ports[i];

			/* Fetch the address+size of the mapped port. */
			error = bhnd_erom_lookup_core_addr(erom, &md,
			    pp->type, pp->port, pp->region,
			    NULL, &addr, &size);
			if (error) {
				/* Skip ports not defined on this device */
				if (error == ENOENT)
					continue;

				return (error);
			}

			/* Skip ports with an existing static mapping */
			if (bhndb_has_static_region_mapping(br, addr, size))
				continue;

			/* Define a dynamic region for this port */
			error = bhndb_add_resource_region(br, addr, size,
			    pp->priority, pp->alloc_flags, NULL);
			if (error)
				return (error);

			/* Update port mapping counts */
			switch (pp->priority) {
			case BHNDB_PRIORITY_NONE:
				break;
			case BHNDB_PRIORITY_LOW:
				prio_low++;
				break;
			case BHNDB_PRIORITY_DEFAULT:
				prio_default++;
				break;
			case BHNDB_PRIORITY_HIGH:
				prio_high++;
				break;
			}
		}
	}

	/* Determine the minimum priority at which we'll allocate direct
	 * register windows from our dynamic pool */
	size_t prio_total = prio_low + prio_default + prio_high;
	if (prio_total <= br->dwa_count) {
		/* low+default+high priority regions get windows */
		br->min_prio = BHNDB_PRIORITY_LOW;

	} else if (prio_default + prio_high <= br->dwa_count) {
		/* default+high priority regions get windows */
		br->min_prio = BHNDB_PRIORITY_DEFAULT;

	} else {
		/* high priority regions get windows */
		br->min_prio = BHNDB_PRIORITY_HIGH;
	}

	if (BHNDB_DEBUG(PRIO)) {
		struct bhndb_region	*region;
		const char		*direct_msg, *type_msg;
		bhndb_priority_t	 prio, prio_min;
		uint32_t		 flags;

		prio_min = br->min_prio;
		device_printf(sc->dev, "min_prio: %d\n", prio_min);

		STAILQ_FOREACH(region, &br->bus_regions, link) {
			prio = region->priority;
			flags = region->alloc_flags;

			direct_msg = prio >= prio_min ? "direct" : "indirect";
			type_msg = region->static_regwin ? "static" : "dynamic";

			device_printf(sc->dev, "region 0x%llx+0x%llx priority "
			    "%u %s/%s",
			    (unsigned long long) region->addr,
			    (unsigned long long) region->size,
			    region->priority,
			    direct_msg, type_msg);

			if (flags & BHNDB_ALLOC_FULFILL_ON_OVERCOMMIT)
				printf(" [overcommit]\n");
			else
				printf("\n");
		}
	}

	return (0);
}

/**
 * Find a hardware specification for @p dev.
 *
 * @param sc The bhndb device state.
 * @param cores All cores enumerated on the bridged bhnd bus.
 * @param ncores The length of @p cores.
 * @param[out] hw On success, the matched hardware specification.
 * with @p dev.
 *
 * @retval 0 success
 * @retval non-zero if an error occurs fetching device info for comparison.
 */
static int
bhndb_find_hwspec(struct bhndb_softc *sc, struct bhnd_core_info *cores,
    u_int ncores, const struct bhndb_hw **hw)
{
	const struct bhndb_hw	*next, *hw_table;

	/* Search for the first matching hardware config. */
	hw_table = BHNDB_BUS_GET_HARDWARE_TABLE(sc->parent_dev, sc->dev);
	for (next = hw_table; next->hw_reqs != NULL; next++) {
		if (!bhndb_hw_matches(sc, cores, ncores, next))
			continue;

		/* Found */
		*hw = next;
		return (0);
	}

	return (ENOENT);
}

/**
 * Helper function that must be called by subclass bhndb(4) drivers
 * when implementing DEVICE_ATTACH() before calling any bhnd(4) or bhndb(4)
 * APIs on the bridge device.
 *
 * This function will add a bridged bhnd(4) child device with a device order of
 * BHND_PROBE_BUS. Any subclass bhndb(4) driver may use the BHND_PROBE_*
 * priority bands to add additional devices that will be attached in
 * their preferred order relative to the bridged bhnd(4) bus.
 *
 * @param dev		The bridge device to attach.
 * @param cid		The bridged device's chip identification.
 * @param cores		The bridged device's core table.
 * @param ncores	The number of cores in @p cores.
 * @param bridge_core	Core info for the bhnd(4) core serving as the host
 *			bridge.
 * @param erom_class	An erom parser class that may be used to parse
 *			the bridged device's device enumeration table.
 */
int
bhndb_attach(device_t dev, struct bhnd_chipid *cid,
    struct bhnd_core_info *cores, u_int ncores,
    struct bhnd_core_info *bridge_core, bhnd_erom_class_t *erom_class)
{
	struct bhndb_devinfo		*dinfo;
	struct bhndb_softc		*sc;
	const struct bhndb_hw		*hw;
	const struct bhndb_hwcfg	*hwcfg;
	const struct bhndb_hw_priority	*hwprio;
	struct bhnd_erom_io		*eio;
	bhnd_erom_t			*erom;
	int				 error;

	sc = device_get_softc(dev);
	sc->dev = dev;
	sc->parent_dev = device_get_parent(dev);
	sc->bridge_core = *bridge_core;
	sc->chipid = *cid;

	if ((error = bhnd_service_registry_init(&sc->services)))
		return (error);

	BHNDB_LOCK_INIT(sc);

	erom = NULL;

	/* Find a matching bridge hardware configuration */
	if ((error = bhndb_find_hwspec(sc, cores, ncores, &hw))) {
		device_printf(sc->dev, "unable to identify device, "
		    " using generic bridge resource definitions\n");

		hwcfg = BHNDB_BUS_GET_GENERIC_HWCFG(sc->parent_dev, dev);
		hw = NULL;
	} else {
		hwcfg = hw->cfg;
	}

	if (hw != NULL && (bootverbose || BHNDB_DEBUG(PRIO))) {
		device_printf(sc->dev, "%s resource configuration\n", hw->name);
	}

	/* Allocate bridge resource state using the discovered hardware
	 * configuration */
	sc->bus_res = bhndb_alloc_resources(sc->dev, sc->parent_dev, hwcfg);
	if (sc->bus_res == NULL) {
		device_printf(sc->dev, "failed to allocate bridge resource "
		    "state\n");
		error = ENOMEM;
		goto failed;
	}

	/* Add our bridged bus device */
	sc->bus_dev = BUS_ADD_CHILD(dev, BHND_PROBE_BUS, "bhnd", DEVICE_UNIT_ANY);
	if (sc->bus_dev == NULL) {
		error = ENXIO;
		goto failed;
	}

	dinfo = device_get_ivars(sc->bus_dev);
	dinfo->addrspace = BHNDB_ADDRSPACE_BRIDGED;

	/* We can now use bhndb to perform bridging of SYS_RES_MEMORY resources;
	 * we use this to instantiate an erom parser instance */
	eio = bhnd_erom_iores_new(sc->bus_dev, 0);
	if ((erom = bhnd_erom_alloc(erom_class, cid, eio)) == NULL) {
		bhnd_erom_io_fini(eio);
		error = ENXIO;
		goto failed;
	}

	/* Populate our resource priority configuration */
	hwprio = BHNDB_BUS_GET_HARDWARE_PRIO(sc->parent_dev, sc->dev);
	error = bhndb_init_region_cfg(sc, erom, sc->bus_res, cores, ncores,
	    hwprio);
	if (error) {
		device_printf(sc->dev, "failed to initialize resource "
		    "priority configuration: %d\n", error);
		goto failed;
	}

	/* Free our erom instance */
	bhnd_erom_free(erom);
	erom = NULL;

	return (0);

failed:
	BHNDB_LOCK_DESTROY(sc);

	if (sc->bus_res != NULL)
		bhndb_free_resources(sc->bus_res);

	if (erom != NULL)
		bhnd_erom_free(erom);

	bhnd_service_registry_fini(&sc->services);

	return (error);
}

/**
 * Default bhndb(4) implementation of DEVICE_DETACH().
 *
 * This function detaches any child devices, and if successful, releases all
 * resources held by the bridge device.
 */
int
bhndb_generic_detach(device_t dev)
{
	struct bhndb_softc	*sc;
	int			 error;

	sc = device_get_softc(dev);

	/* Detach children */
	if ((error = bus_generic_detach(dev)))
		return (error);

	/* Delete children */
	if ((error = device_delete_children(dev)))
		return (error);

	/* Clean up our service registry */
	if ((error = bhnd_service_registry_fini(&sc->services)))
		return (error);

	/* Clean up our driver state. */
	bhndb_free_resources(sc->bus_res);

	BHNDB_LOCK_DESTROY(sc);

	return (0);
}

/**
 * Default bhndb(4) implementation of DEVICE_SUSPEND().
 *
 * This function calls bus_generic_suspend() (or implements equivalent
 * behavior).
 */
int
bhndb_generic_suspend(device_t dev)
{
	return (bus_generic_suspend(dev));
}

/**
 * Default bhndb(4) implementation of DEVICE_RESUME().
 *
 * This function calls bus_generic_resume() (or implements equivalent
 * behavior).
 */
int
bhndb_generic_resume(device_t dev)
{
	struct bhndb_softc	*sc;
	struct bhndb_resources	*bus_res;
	struct bhndb_dw_alloc	*dwa;
	int			 error;

	sc = device_get_softc(dev);
	bus_res = sc->bus_res;

	/* Guarantee that all in-use dynamic register windows are mapped to
	 * their previously configured target address. */
	BHNDB_LOCK(sc);
	error = 0;
	for (size_t i = 0; i < bus_res->dwa_count; i++) {
		dwa = &bus_res->dw_alloc[i];

		/* Skip regions that were not previously used */
		if (bhndb_dw_is_free(bus_res, dwa) && dwa->target == 0x0)
			continue;

		/* Otherwise, ensure the register window is correct before
		 * any children attempt MMIO */
		error = BHNDB_SET_WINDOW_ADDR(dev, dwa->win, dwa->target);
		if (error)
			break;
	}
	BHNDB_UNLOCK(sc);

	/* Error restoring hardware state; children cannot be safely resumed */
	if (error) {
		device_printf(dev, "Unable to restore hardware configuration; "
		    "cannot resume: %d\n", error);
		return (error);
	}

	return (bus_generic_resume(dev));
}

/**
 * Default implementation of BHNDB_SUSPEND_RESOURCE.
 */
static void
bhndb_suspend_resource(device_t dev, device_t child, int type,
    struct resource *r)
{
	struct bhndb_softc	*sc;
	struct bhndb_dw_alloc	*dwa;

	sc = device_get_softc(dev);

	/* Non-MMIO resources (e.g. IRQs) are handled solely by our parent */
	if (type != SYS_RES_MEMORY)
		return;

	BHNDB_LOCK(sc);
	dwa = bhndb_dw_find_resource(sc->bus_res, r);
	if (dwa == NULL) {
		BHNDB_UNLOCK(sc);
		return;
	}

	if (BHNDB_DEBUG(PRIO))
		device_printf(child, "suspend resource type=%d 0x%jx+0x%jx\n",
		    type, rman_get_start(r), rman_get_size(r));

	/* Release the resource's window reference */
	bhndb_dw_release(sc->bus_res, dwa, r);
	BHNDB_UNLOCK(sc);
}

/**
 * Default implementation of BHNDB_RESUME_RESOURCE.
 */
static int
bhndb_resume_resource(device_t dev, device_t child, int type,
    struct resource *r)
{
	struct bhndb_softc	*sc;

	sc = device_get_softc(dev);

	/* Non-MMIO resources (e.g. IRQs) are handled solely by our parent */
	if (type != SYS_RES_MEMORY)
		return (0);

	/* Inactive resources don't require reallocation of bridge resources */
	if (!(rman_get_flags(r) & RF_ACTIVE))
		return (0);

	if (BHNDB_DEBUG(PRIO))
		device_printf(child, "resume resource type=%d 0x%jx+0x%jx\n",
		    type, rman_get_start(r), rman_get_size(r));

	return (bhndb_try_activate_resource(sc, rman_get_device(r), r, NULL));
}

/**
 * Default bhndb(4) implementation of BUS_READ_IVAR().
 */
static int
bhndb_read_ivar(device_t dev, device_t child, int index,
    uintptr_t *result)
{
	return (ENOENT);
}

/**
 * Default bhndb(4) implementation of BUS_WRITE_IVAR().
 */
static int
bhndb_write_ivar(device_t dev, device_t child, int index,
    uintptr_t value)
{
	return (ENOENT);
}

/**
 * Return the address space for the given @p child device.
 */
bhndb_addrspace
bhndb_get_addrspace(struct bhndb_softc *sc, device_t child)
{
	struct bhndb_devinfo	*dinfo;
	device_t		 imd_dev;

	/* Find the directly attached parent of the requesting device */
	imd_dev = child;
	while (imd_dev != NULL && device_get_parent(imd_dev) != sc->dev)
		imd_dev = device_get_parent(imd_dev);

	if (imd_dev == NULL)
		panic("bhndb address space request for non-child device %s\n",
		     device_get_nameunit(child));

	dinfo = device_get_ivars(imd_dev);
	return (dinfo->addrspace);
}

/**
 * Return the rman instance for a given resource @p type, if any.
 *
 * @param sc The bhndb device state.
 * @param child The requesting child.
 * @param type The resource type (e.g. SYS_RES_MEMORY, SYS_RES_IRQ, ...)
 */
static struct rman *
bhndb_get_rman(struct bhndb_softc *sc, device_t child, int type)
{
	switch (bhndb_get_addrspace(sc, child)) {
	case BHNDB_ADDRSPACE_NATIVE:
		switch (type) {
		case SYS_RES_MEMORY:
			return (&sc->bus_res->ht_mem_rman);
		case SYS_RES_IRQ:
			return (NULL);
		default:
			return (NULL);
		}

	case BHNDB_ADDRSPACE_BRIDGED:
		switch (type) {
		case SYS_RES_MEMORY:
			return (&sc->bus_res->br_mem_rman);
		case SYS_RES_IRQ:
			return (&sc->bus_res->br_irq_rman);
		default:
			return (NULL);
		}
	}

	/* Quieten gcc */
	return (NULL);
}

/**
 * Default implementation of BUS_ADD_CHILD()
 */
static device_t
bhndb_add_child(device_t dev, u_int order, const char *name, int unit)
{
	struct bhndb_devinfo	*dinfo;
	device_t		 child;

	child = device_add_child_ordered(dev, order, name, unit);
	if (child == NULL)
		return (NULL);

	dinfo = malloc(sizeof(struct bhndb_devinfo), M_BHND, M_NOWAIT);
	if (dinfo == NULL) {
		device_delete_child(dev, child);
		return (NULL);
	}

	dinfo->addrspace = BHNDB_ADDRSPACE_NATIVE;
	resource_list_init(&dinfo->resources);

	device_set_ivars(child, dinfo);

	return (child);
}

/**
 * Default implementation of BUS_CHILD_DELETED().
 */
static void
bhndb_child_deleted(device_t dev, device_t child)
{
	struct bhndb_devinfo *dinfo = device_get_ivars(child);
	if (dinfo != NULL) {
		resource_list_free(&dinfo->resources);
		free(dinfo, M_BHND);
	}

	device_set_ivars(child, NULL);
}

/**
 * Default implementation of BHNDB_GET_CHIPID().
 */
static const struct bhnd_chipid *
bhndb_get_chipid(device_t dev, device_t child)
{
	struct bhndb_softc *sc = device_get_softc(dev);
	return (&sc->chipid);
}

/**
 * Default implementation of BHNDB_IS_CORE_DISABLED().
 */
static bool
bhndb_is_core_disabled(device_t dev, device_t child,
    struct bhnd_core_info *core)
{
	struct bhndb_softc	*sc;

	sc = device_get_softc(dev);

	/* Try to defer to the bhndb bus parent */
	if (BHNDB_BUS_IS_CORE_DISABLED(sc->parent_dev, dev, core))
		return (true);

	/* Otherwise, we treat bridge-capable cores as unpopulated if they're
	 * not the configured host bridge */
	if (BHND_DEVCLASS_SUPPORTS_HOSTB(bhnd_core_class(core)))
		return (!bhnd_cores_equal(core, &sc->bridge_core));

	/* Assume the core is populated */
	return (false);
}

/**
 * Default bhndb(4) implementation of BHNDB_GET_HOSTB_CORE().
 *
 * This function uses a heuristic valid on all known PCI/PCIe/PCMCIA-bridged
 * bhnd(4) devices.
 */
static int
bhndb_get_hostb_core(device_t dev, device_t child, struct bhnd_core_info *core)
{
	struct bhndb_softc *sc = device_get_softc(dev);

	*core = sc->bridge_core;
	return (0);
}

/**
 * Default bhndb(4) implementation of BHND_BUS_GET_SERVICE_REGISTRY().
 */
static struct bhnd_service_registry *
bhndb_get_service_registry(device_t dev, device_t child)
{
	struct bhndb_softc *sc = device_get_softc(dev);

	return (&sc->services);
}

/**
 * Default bhndb(4) implementation of BUS_ALLOC_RESOURCE().
 */
static struct resource *
bhndb_alloc_resource(device_t dev, device_t child, int type,
    int *rid, rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
{
	struct bhndb_softc		*sc;
	struct resource_list_entry	*rle;
	struct resource			*rv;
	struct rman			*rm;
	int				 error;
	bool				 passthrough, isdefault;

	sc = device_get_softc(dev);
	passthrough = (device_get_parent(child) != dev);
	isdefault = RMAN_IS_DEFAULT_RANGE(start, end);
	rle = NULL;

	/* Fetch the resource manager */
	rm = bhndb_get_rman(sc, child, type);
	if (rm == NULL) {
		/* Delegate to our parent device's bus; the requested
		 * resource type isn't handled locally. */
		return (BUS_ALLOC_RESOURCE(device_get_parent(sc->parent_dev),
		    child, type, rid,  start, end, count, flags));
	}

	/* Populate defaults */
	if (!passthrough && isdefault) {
		/* Fetch the resource list entry. */
		rle = resource_list_find(BUS_GET_RESOURCE_LIST(dev, child),
		    type, *rid);
		if (rle == NULL) {
			device_printf(dev,
			    "default resource %#x type %d for child %s "
			    "not found\n", *rid, type,
			    device_get_nameunit(child));

			return (NULL);
		}

		if (rle->res != NULL) {
			device_printf(dev,
			    "resource entry %#x type %d for child %s is busy\n",
			    *rid, type, device_get_nameunit(child));

			return (NULL);
		}

		start = rle->start;
		end = rle->end;
		count = ulmax(count, rle->count);
	}

	/* Validate resource addresses */
	if (start > end || count > ((end - start) + 1))
		return (NULL);

	/* Make our reservation */
	rv = rman_reserve_resource(rm, start, end, count, flags & ~RF_ACTIVE,
	    child);
	if (rv == NULL)
		return (NULL);

	rman_set_rid(rv, *rid);
	rman_set_type(rv, type);

	/* Activate */
	if (flags & RF_ACTIVE) {
		error = bus_activate_resource(child, type, *rid, rv);
		if (error) {
			device_printf(dev,
			    "failed to activate entry %#x type %d for "
				"child %s: %d\n",
			     *rid, type, device_get_nameunit(child), error);

			rman_release_resource(rv);

			return (NULL);
		}
	}

	/* Update child's resource list entry */
	if (rle != NULL) {
		rle->res = rv;
		rle->start = rman_get_start(rv);
		rle->end = rman_get_end(rv);
		rle->count = rman_get_size(rv);
	}

	return (rv);
}

/**
 * Default bhndb(4) implementation of BUS_RELEASE_RESOURCE().
 */
static int
bhndb_release_resource(device_t dev, device_t child, struct resource *r)
{
	struct bhndb_softc		*sc;
	struct resource_list_entry	*rle;
	bool				 passthrough;
	int				 error;

	sc = device_get_softc(dev);
	passthrough = (device_get_parent(child) != dev);

	/* Delegate to our parent device's bus if the requested resource type
	 * isn't handled locally. */
	if (bhndb_get_rman(sc, child, rman_get_type(r)) == NULL) {
		return (BUS_RELEASE_RESOURCE(device_get_parent(sc->parent_dev),
		    child, r));
	}

	/* Deactivate resources */
	if (rman_get_flags(r) & RF_ACTIVE) {
		error = BUS_DEACTIVATE_RESOURCE(dev, child, r);
		if (error)
			return (error);
	}

	if ((error = rman_release_resource(r)))
		return (error);

	if (!passthrough) {
		/* Clean resource list entry */
		rle = resource_list_find(BUS_GET_RESOURCE_LIST(dev, child),
		    rman_get_type(r), rman_get_rid(r));
		if (rle != NULL)
			rle->res = NULL;
	}

	return (0);
}

/**
 * Default bhndb(4) implementation of BUS_ADJUST_RESOURCE().
 */
static int
bhndb_adjust_resource(device_t dev, device_t child,
    struct resource *r, rman_res_t start, rman_res_t end)
{
	struct bhndb_softc		*sc;
	struct rman			*rm;
	rman_res_t			 mstart, mend;
	int				 error;

	sc = device_get_softc(dev);
	error = 0;

	/* Delegate to our parent device's bus if the requested resource type
	 * isn't handled locally. */
	rm = bhndb_get_rman(sc, child, rman_get_type(r));
	if (rm == NULL) {
		return (BUS_ADJUST_RESOURCE(device_get_parent(sc->parent_dev),
		    child, r, start, end));
	}

	/* Verify basic constraints */
	if (end <= start)
		return (EINVAL);

	if (!rman_is_region_manager(r, rm))
		return (ENXIO);

	BHNDB_LOCK(sc);

	/* If not active, allow any range permitted by the resource manager */
	if (!(rman_get_flags(r) & RF_ACTIVE))
		goto done;

	/* Otherwise, the range is limited by the bridged resource mapping */
	error = bhndb_find_resource_limits(sc->bus_res, r, &mstart,
	    &mend);
	if (error)
		goto done;

	if (start < mstart || end > mend) {
		error = EINVAL;
		goto done;
	}

	/* Fall through */
done:
	if (!error)
		error = rman_adjust_resource(r, start, end);

	BHNDB_UNLOCK(sc);
	return (error);
}

/**
 * Initialize child resource @p r with a virtual address, tag, and handle
 * copied from @p parent, adjusted to contain only the range defined by
 * @p offsize and @p size.
 *
 * @param r The register to be initialized.
 * @param parent The parent bus resource that fully contains the subregion.
 * @param offset The subregion offset within @p parent.
 * @param size The subregion size.
 * @p r.
 */
static int
bhndb_init_child_resource(struct resource *r,
    struct resource *parent, bhnd_size_t offset, bhnd_size_t size)
{
	bus_space_handle_t	bh, child_bh;
	bus_space_tag_t		bt;
	uintptr_t		vaddr;
	int			error;

	/* Fetch the parent resource's real bus values */
	vaddr = (uintptr_t) rman_get_virtual(parent);
	bt = rman_get_bustag(parent);
	bh = rman_get_bushandle(parent);

	/* Configure child resource with window-adjusted real bus values */
	vaddr += offset;
	error = bus_space_subregion(bt, bh, offset, size, &child_bh);
	if (error)
		return (error);

	rman_set_virtual(r, (void *) vaddr);
	rman_set_bustag(r, bt);
	rman_set_bushandle(r, child_bh);

	return (0);
}

/**
 * Attempt activation of a fixed register window mapping for @p child.
 *
 * @param sc BHNDB device state.
 * @param region The static region definition capable of mapping @p r.
 * @param child A child requesting resource activation.
 * @param type Resource type.
 * @param rid Resource identifier.
 * @param r Resource to be activated.
 *
 * @retval 0 if @p r was activated successfully
 * @retval ENOENT if no fixed register window was found.
 * @retval non-zero if @p r could not be activated.
 */
static int
bhndb_activate_static_region(struct bhndb_softc *sc,
    struct bhndb_region *region, device_t child, struct resource *r)
{
	struct resource			*bridge_res;
	const struct bhndb_regwin	*win;
	bhnd_size_t			 parent_offset;
	rman_res_t			 r_start, r_size;
	int				 error;

	win = region->static_regwin;

	KASSERT(win != NULL && BHNDB_REGWIN_T_IS_STATIC(win->win_type),
	    ("can't activate non-static region"));

	r_start = rman_get_start(r);
	r_size = rman_get_size(r);

	/* Find the corresponding bridge resource */
	bridge_res = bhndb_host_resource_for_regwin(sc->bus_res->res, win);
	if (bridge_res == NULL)
		return (ENXIO);

	/* Calculate subregion offset within the parent resource */
	parent_offset = r_start - region->addr;
	parent_offset += win->win_offset;

	/* Configure resource with its real bus values. */
	error = bhndb_init_child_resource(r, bridge_res, parent_offset, r_size);
	if (error)
		return (error);

	/* Mark active */
	if ((error = rman_activate_resource(r)))
		return (error);

	return (0);
}

/**
 * Attempt to allocate/retain a dynamic register window for @p r, returning
 * the retained window.
 *
 * @param sc The bhndb driver state.
 * @param r The resource for which a window will be retained.
 */
static struct bhndb_dw_alloc *
bhndb_retain_dynamic_window(struct bhndb_softc *sc, struct resource *r)
{
	struct bhndb_dw_alloc	*dwa;
	rman_res_t		 r_start, r_size;
	int			 error;

	BHNDB_LOCK_ASSERT(sc, MA_OWNED);

	r_start = rman_get_start(r);
	r_size = rman_get_size(r);

	/* Look for an existing dynamic window we can reference */
	dwa = bhndb_dw_find_mapping(sc->bus_res, r_start, r_size);
	if (dwa != NULL) {
		if (bhndb_dw_retain(sc->bus_res, dwa, r) == 0)
			return (dwa);

		return (NULL);
	}

	/* Otherwise, try to reserve a free window */
	dwa = bhndb_dw_next_free(sc->bus_res);
	if (dwa == NULL) {
		/* No free windows */
		return (NULL);
	}

	/* Window must be large enough to map the entire resource */
	if (dwa->win->win_size < rman_get_size(r))
		return (NULL);

	/* Set the window target */
	error = bhndb_dw_set_addr(sc->dev, sc->bus_res, dwa, rman_get_start(r),
	    rman_get_size(r));
	if (error) {
		device_printf(sc->dev, "dynamic window initialization "
			"for 0x%llx-0x%llx failed: %d\n",
			(unsigned long long) r_start,
			(unsigned long long) r_start + r_size - 1,
			error);
		return (NULL);
	}

	/* Add our reservation */
	if (bhndb_dw_retain(sc->bus_res, dwa, r))
		return (NULL);

	return (dwa);
}

/**
 * Activate a resource using any viable static or dynamic register window.
 *
 * @param sc The bhndb driver state.
 * @param child The child holding ownership of @p r.
 * @param r The resource to be activated
 * @param[out] indirect On error and if not NULL, will be set to 'true' if
 * the caller should instead use an indirect resource mapping.
 *
 * @retval 0 success
 * @retval non-zero activation failed.
 */
static int
bhndb_try_activate_resource(struct bhndb_softc *sc, device_t child,
    struct resource *r, bool *indirect)
{
	struct bhndb_region	*region;
	struct bhndb_dw_alloc	*dwa;
	bhndb_priority_t	 dw_priority;
	rman_res_t		 r_start, r_size;
	rman_res_t		 parent_offset;
	int			 error, type;

	BHNDB_LOCK_ASSERT(sc, MA_NOTOWNED);

	if (indirect != NULL)
		*indirect = false;

	type = rman_get_type(r);
	switch (type) {
	case SYS_RES_IRQ:
		/* IRQ resources are always directly mapped */
		return (rman_activate_resource(r));

	case SYS_RES_MEMORY:
		/* Handled below */
		break;

	default:
		device_printf(sc->dev, "unsupported resource type %d\n", type);
		return (ENXIO);
	}

	/* Only MMIO resources can be mapped via register windows */
	KASSERT(type == SYS_RES_MEMORY, ("invalid type: %d", type));

	r_start = rman_get_start(r);
	r_size = rman_get_size(r);

	/* Activate native addrspace resources using the host address space */
	if (bhndb_get_addrspace(sc, child) == BHNDB_ADDRSPACE_NATIVE) {
		struct resource *parent;

		/* Find the bridge resource referenced by the child */
		parent = bhndb_host_resource_for_range(sc->bus_res->res,
		    type, r_start, r_size);
		if (parent == NULL) {
			device_printf(sc->dev, "host resource not found "
			     "for 0x%llx-0x%llx\n",
			     (unsigned long long) r_start,
			     (unsigned long long) r_start + r_size - 1);
			return (ENOENT);
		}

		/* Initialize child resource with the real bus values */
		error = bhndb_init_child_resource(r, parent,
		    r_start - rman_get_start(parent), r_size);
		if (error)
			return (error);

		/* Try to activate child resource */
		return (rman_activate_resource(r));
	}

	/* Default to low priority */
	dw_priority = BHNDB_PRIORITY_LOW;

	/* Look for a bus region matching the resource's address range */
	region = bhndb_find_resource_region(sc->bus_res, r_start, r_size);
	if (region != NULL)
		dw_priority = region->priority;

	/* Prefer static mappings over consuming a dynamic windows. */
	if (region && region->static_regwin) {
		error = bhndb_activate_static_region(sc, region, child, r);
		if (error)
			device_printf(sc->dev, "static window allocation "
			     "for 0x%llx-0x%llx failed\n",
			     (unsigned long long) r_start,
			     (unsigned long long) r_start + r_size - 1);
		return (error);
	}

	/* A dynamic window will be required; is this resource high enough
	 * priority to be reserved a dynamic window? */
	if (dw_priority < sc->bus_res->min_prio) {
		if (indirect)
			*indirect = true;

		return (ENOMEM);
	}

	/* Find and retain a usable window */
	BHNDB_LOCK(sc); {
		dwa = bhndb_retain_dynamic_window(sc, r);
	} BHNDB_UNLOCK(sc);

	if (dwa == NULL) {
		if (indirect)
			*indirect = true;
		return (ENOMEM);
	}

	/* Configure resource with its real bus values. */
	parent_offset = dwa->win->win_offset;
	parent_offset += r_start - dwa->target;

	error = bhndb_init_child_resource(r, dwa->parent_res, parent_offset,
	    dwa->win->win_size);
	if (error)
		goto failed;

	/* Mark active */
	if ((error = rman_activate_resource(r)))
		goto failed;

	return (0);

failed:
	/* Release our region allocation. */
	BHNDB_LOCK(sc);
	bhndb_dw_release(sc->bus_res, dwa, r);
	BHNDB_UNLOCK(sc);

	return (error);
}

/**
 * Default bhndb(4) implementation of BUS_ACTIVATE_RESOURCE().
 */
static int
bhndb_activate_resource(device_t dev, device_t child, struct resource *r)
{
	struct bhndb_softc *sc = device_get_softc(dev);

	/* Delegate directly to our parent device's bus if the requested
	 * resource type isn't handled locally. */
	if (bhndb_get_rman(sc, child, rman_get_type(r)) == NULL) {
		return (BUS_ACTIVATE_RESOURCE(device_get_parent(sc->parent_dev),
		    child, r));
	}

	return (bhndb_try_activate_resource(sc, child, r, NULL));
}

/**
 * Default bhndb(4) implementation of BUS_DEACTIVATE_RESOURCE().
 */
static int
bhndb_deactivate_resource(device_t dev, device_t child, struct resource *r)
{
	struct bhndb_dw_alloc	*dwa;
	struct bhndb_softc	*sc;
	struct rman		*rm;
	int			 error, type;

	sc = device_get_softc(dev);
	type = rman_get_type(r);

	/* Delegate directly to our parent device's bus if the requested
	 * resource type isn't handled locally. */
	rm = bhndb_get_rman(sc, child, type);
	if (rm == NULL) {
		return (BUS_DEACTIVATE_RESOURCE(
		    device_get_parent(sc->parent_dev), child, r));
	}

	/* Mark inactive */
	if ((error = rman_deactivate_resource(r)))
		return (error);

	switch (type) {
	case SYS_RES_IRQ:
		/* No bridge-level state to be freed */
		return (0);

	case SYS_RES_MEMORY:
		/* Free any dynamic window allocation. */
		if (bhndb_get_addrspace(sc, child) == BHNDB_ADDRSPACE_BRIDGED) {
			BHNDB_LOCK(sc);
			dwa = bhndb_dw_find_resource(sc->bus_res, r);
			if (dwa != NULL)
				bhndb_dw_release(sc->bus_res, dwa, r);
			BHNDB_UNLOCK(sc);
		}

		return (0);

	default:
		device_printf(dev, "unsupported resource type %d\n", type);
		return (ENXIO);
	}
}

/**
 * Default bhndb(4) implementation of BUS_GET_RESOURCE_LIST().
 */
static struct resource_list *
bhndb_get_resource_list(device_t dev, device_t child)
{
	struct bhndb_devinfo *dinfo = device_get_ivars(child);
	return (&dinfo->resources);
}

/**
 * Default bhndb(4) implementation of BHND_BUS_ACTIVATE_RESOURCE().
 *
 * For BHNDB_ADDRSPACE_NATIVE children, all resources are activated as direct
 * resources via BUS_ACTIVATE_RESOURCE().
 *
 * For BHNDB_ADDRSPACE_BRIDGED children, the resource priority is determined,
 * and if possible, the resource is activated as a direct resource. For example,
 * depending on resource priority and bridge resource availability, this
 * function will attempt to activate SYS_RES_MEMORY resources using either a
 * static register window, a dynamic register window, or it will configure @p r
 * as an indirect resource -- in that order.
 */
static int
bhndb_activate_bhnd_resource(device_t dev, device_t child,
    int type, int rid, struct bhnd_resource *r)
{
	struct bhndb_softc	*sc;
	struct bhndb_region	*region;
	bhndb_priority_t	 r_prio;
	rman_res_t		 r_start, r_size;
	int 			 error;
	bool			 indirect;

	KASSERT(!r->direct,
	    ("direct flag set on inactive resource"));

	KASSERT(!(rman_get_flags(r->res) & RF_ACTIVE),
	    ("RF_ACTIVE set on inactive resource"));

	sc = device_get_softc(dev);

	/* Delegate directly to BUS_ACTIVATE_RESOURCE() if the requested
	 * resource type isn't handled locally. */
	if (bhndb_get_rman(sc, child, type) == NULL) {
		error = BUS_ACTIVATE_RESOURCE(dev, child, r->res);
		if (error == 0)
			r->direct = true;
		return (error);
	}

	r_start = rman_get_start(r->res);
	r_size = rman_get_size(r->res);

	/* Determine the resource priority of bridged resources, and skip direct
	 * allocation if the priority is too low. */
	if (bhndb_get_addrspace(sc, child) == BHNDB_ADDRSPACE_BRIDGED) {
		switch (type) {
		case SYS_RES_IRQ:
			/* IRQ resources are always direct */
			break;

		case SYS_RES_MEMORY:
			region = bhndb_find_resource_region(sc->bus_res,
				r_start, r_size);
			if (region != NULL)
				r_prio = region->priority;
			else
				r_prio = BHNDB_PRIORITY_NONE;

			/* If less than the minimum dynamic window priority,
			 * this resource should always be indirect. */
			if (r_prio < sc->bus_res->min_prio)
				return (0);

			break;

		default:
			device_printf(dev, "unsupported resource type %d\n",
			    type);
			return (ENXIO);
		}
	}

	/* Attempt direct activation */
	error = bhndb_try_activate_resource(sc, child, r->res, &indirect);
	if (!error) {
		r->direct = true;
	} else if (indirect) {
		/* The request was valid, but no viable register window is
		 * available; indirection must be employed. */
		error = 0;
		r->direct = false;
	}

	if (BHNDB_DEBUG(PRIO) &&
	    bhndb_get_addrspace(sc, child) == BHNDB_ADDRSPACE_BRIDGED)
	{
		device_printf(child, "activated 0x%llx-0x%llx as %s "
		    "resource\n",
		    (unsigned long long) r_start,
		    (unsigned long long) r_start + r_size - 1,
		    r->direct ? "direct" : "indirect");
	}

	return (error);
}

/**
 * Default bhndb(4) implementation of BHND_BUS_DEACTIVATE_RESOURCE().
 */
static int
bhndb_deactivate_bhnd_resource(device_t dev, device_t child,
    int type, int rid, struct bhnd_resource *r)
{
	int error;

	/* Indirect resources don't require activation */
	if (!r->direct)
		return (0);

	KASSERT(rman_get_flags(r->res) & RF_ACTIVE,
	    ("RF_ACTIVE not set on direct resource"));

	/* Perform deactivation */
	error = BUS_DEACTIVATE_RESOURCE(dev, child, r->res);
	if (!error)
		r->direct = false;

	return (error);
}

/**
 * Find the best available bridge resource allocation record capable of handling
 * bus I/O requests of @p size at @p addr.
 *
 * In order of preference, this function will either:
 *
 * - Configure and return a free allocation record
 * - Return an existing allocation record mapping the requested space, or
 * - Steal, configure, and return an in-use allocation record.
 *
 * Will panic if a usable record cannot be found.
 *
 * @param sc Bridge driver state.
 * @param addr The I/O target address.
 * @param size The size of the I/O operation to be performed at @p addr.
 * @param[out] borrowed Set to true if the allocation record was borrowed to
 * fulfill this request; the borrowed record maps the target address range,
 * and must not be modified.
 * @param[out] stolen Set to true if the allocation record was stolen to fulfill
 * this request. If a stolen allocation record is returned,
 * bhndb_io_resource_restore() must be called upon completion of the bus I/O
 * request.
 * @param[out] restore If the allocation record was stolen, this will be set
 * to the target that must be restored.
 */
static struct bhndb_dw_alloc *
bhndb_io_resource_get_window(struct bhndb_softc *sc, bus_addr_t addr,
    bus_size_t size, bool *borrowed, bool *stolen, bus_addr_t *restore)
{
	struct bhndb_resources	*br;
	struct bhndb_dw_alloc	*dwa;
	struct bhndb_region	*region;

	BHNDB_LOCK_ASSERT(sc, MA_OWNED);

	br = sc->bus_res;
	*borrowed = false;
	*stolen = false;

	/* Try to fetch a free window */
	if ((dwa = bhndb_dw_next_free(br)) != NULL)
		return (dwa);

	/* Search for an existing dynamic mapping of this address range.
	 * Static regions are not searched, as a statically mapped
	 * region would never be allocated as an indirect resource. */
	for (size_t i = 0; i < br->dwa_count; i++) {
		const struct bhndb_regwin *win;

		dwa = &br->dw_alloc[i];
		win = dwa->win;

		KASSERT(win->win_type == BHNDB_REGWIN_T_DYN,
			("invalid register window type"));

		/* Verify the range */
		if (addr < dwa->target)
			continue;

		if (addr + size > dwa->target + win->win_size)
			continue;

		/* Found */
		*borrowed = true;
		return (dwa);
	}

	/* Try to steal a window; this should only be required on very early
	 * PCI_V0 (BCM4318, etc) Wi-Fi chipsets */
	region = bhndb_find_resource_region(br, addr, size);
	if (region == NULL)
		return (NULL);

	if ((region->alloc_flags & BHNDB_ALLOC_FULFILL_ON_OVERCOMMIT) == 0)
		return (NULL);

	/* Steal a window. This acquires our backing spinlock, disabling
	 * interrupts; the spinlock will be released by
	 * bhndb_dw_return_stolen() */
	if ((dwa = bhndb_dw_steal(br, restore)) != NULL) {
		*stolen = true;
		return (dwa);
	}

	panic("register windows exhausted attempting to map 0x%llx-0x%llx\n",
	    (unsigned long long) addr, (unsigned long long) addr+size-1);
}

/**
 * Return a borrowed reference to a bridge resource allocation record capable
 * of handling bus I/O requests of @p size at @p addr.
 *
 * This will either return a reference to an existing allocation record mapping
 * the requested space, or will configure and return a free allocation record.
 *
 * Will panic if a usable record cannot be found.
 *
 * @param sc Bridge driver state.
 * @param addr The I/O target address.
 * @param size The size of the I/O operation to be performed at @p addr.
 * @param[out] offset The offset within the returned resource at which
 * to perform the I/O request.
 * @param[out] stolen Set to true if the allocation record was stolen to fulfill
 * this request. If a stolen allocation record is returned,
 * bhndb_io_resource_restore() must be called upon completion of the bus I/O
 * request.
 * @param[out] restore If the allocation record was stolen, this will be set
 * to the target that must be restored.
 */
static inline struct bhndb_dw_alloc *
bhndb_io_resource(struct bhndb_softc *sc, bus_addr_t addr, bus_size_t size,
    bus_size_t *offset, bool *stolen, bus_addr_t *restore)
{
	struct bhndb_dw_alloc	*dwa;
	bool			 borrowed;
	int			 error;

	BHNDB_LOCK_ASSERT(sc, MA_OWNED);

	dwa = bhndb_io_resource_get_window(sc, addr, size, &borrowed, stolen,
	    restore);

	/* Adjust the window if the I/O request won't fit in the current
	 * target range. */
	if (addr < dwa->target ||
	    addr > dwa->target + dwa->win->win_size ||
	    (dwa->target + dwa->win->win_size) - addr < size)
	{
		/* Cannot modify target of borrowed windows */
		if (borrowed) {
			panic("borrowed register window does not map expected "
			    "range 0x%llx-0x%llx\n",
			    (unsigned long long) addr,
			    (unsigned long long) addr+size-1);
		}

		error = bhndb_dw_set_addr(sc->dev, sc->bus_res, dwa, addr,
		    size);
		if (error) {
		    panic("failed to set register window target mapping "
			    "0x%llx-0x%llx\n",
			    (unsigned long long) addr,
			    (unsigned long long) addr+size-1);
		}
	}

	/* Calculate the offset and return */
	*offset = (addr - dwa->target) + dwa->win->win_offset;
	return (dwa);
}

/*
 * BHND_BUS_(READ|WRITE_* implementations
 */

/* bhndb_bus_(read|write) common implementation */
#define	BHNDB_IO_COMMON_SETUP(_io_size)				\
	struct bhndb_softc	*sc;				\
	struct bhndb_dw_alloc	*dwa;				\
	struct resource		*io_res;			\
	bus_size_t		 io_offset;			\
	bus_addr_t		 restore;		\
	bool			 stolen;			\
								\
	sc = device_get_softc(dev);				\
								\
	BHNDB_LOCK(sc);						\
	dwa = bhndb_io_resource(sc, rman_get_start(r->res) +	\
	    offset, _io_size, &io_offset, &stolen, &restore);	\
	io_res = dwa->parent_res;				\
								\
	KASSERT(!r->direct,					\
	    ("bhnd_bus slow path used for direct resource"));	\
								\
	KASSERT(rman_get_flags(io_res) & RF_ACTIVE,		\
	    ("i/o resource is not active"));

#define	BHNDB_IO_COMMON_TEARDOWN()				\
	if (stolen) {						\
		bhndb_dw_return_stolen(sc->dev, sc->bus_res,	\
		    dwa, restore);				\
	}							\
	BHNDB_UNLOCK(sc);

/* Defines a bhndb_bus_read_* method implementation */
#define	BHNDB_IO_READ(_type, _name)				\
static _type							\
bhndb_bus_read_ ## _name (device_t dev, device_t child,		\
    struct bhnd_resource *r, bus_size_t offset)			\
{								\
	_type v;						\
	BHNDB_IO_COMMON_SETUP(sizeof(_type));			\
	v = bus_read_ ## _name (io_res, io_offset);		\
	BHNDB_IO_COMMON_TEARDOWN();				\
								\
	return (v);						\
}

/* Defines a bhndb_bus_write_* method implementation */
#define	BHNDB_IO_WRITE(_type, _name)				\
static void							\
bhndb_bus_write_ ## _name (device_t dev, device_t child,	\
    struct bhnd_resource *r, bus_size_t offset, _type value)	\
{								\
	BHNDB_IO_COMMON_SETUP(sizeof(_type));			\
	bus_write_ ## _name (io_res, io_offset, value);		\
	BHNDB_IO_COMMON_TEARDOWN();				\
}

/* Defines a bhndb_bus_(read|write|set)_(multi|region)_* method */
#define	BHNDB_IO_MISC(_type, _ptr, _op, _size)			\
static void							\
bhndb_bus_ ## _op ## _ ## _size (device_t dev,			\
    device_t child, struct bhnd_resource *r, bus_size_t offset,	\
    _type _ptr datap, bus_size_t count)				\
{								\
	BHNDB_IO_COMMON_SETUP(sizeof(_type) * count);		\
	bus_ ## _op ## _ ## _size (io_res, io_offset,		\
	    datap, count);					\
	BHNDB_IO_COMMON_TEARDOWN();				\
}

/* Defines a complete set of read/write methods */
#define	BHNDB_IO_METHODS(_type, _size)				\
	BHNDB_IO_READ(_type, _size)				\
	BHNDB_IO_WRITE(_type, _size)				\
								\
	BHNDB_IO_READ(_type, stream_ ## _size)			\
	BHNDB_IO_WRITE(_type, stream_ ## _size)			\
								\
	BHNDB_IO_MISC(_type, *, read_multi, _size)		\
	BHNDB_IO_MISC(_type, *, write_multi, _size)		\
								\
	BHNDB_IO_MISC(_type, *, read_multi_stream, _size)	\
	BHNDB_IO_MISC(_type, *, write_multi_stream, _size)	\
								\
	BHNDB_IO_MISC(_type,  , set_multi, _size)		\
	BHNDB_IO_MISC(_type,  , set_region, _size)		\
	BHNDB_IO_MISC(_type, *, read_region, _size)		\
	BHNDB_IO_MISC(_type, *, write_region, _size)		\
								\
	BHNDB_IO_MISC(_type, *, read_region_stream, _size)	\
	BHNDB_IO_MISC(_type, *, write_region_stream, _size)

BHNDB_IO_METHODS(uint8_t, 1);
BHNDB_IO_METHODS(uint16_t, 2);
BHNDB_IO_METHODS(uint32_t, 4);

/**
 * Default bhndb(4) implementation of BHND_BUS_BARRIER().
 */
static void
bhndb_bus_barrier(device_t dev, device_t child, struct bhnd_resource *r,
    bus_size_t offset, bus_size_t length, int flags)
{
	BHNDB_IO_COMMON_SETUP(length);

	bus_barrier(io_res, io_offset + offset, length, flags);

	BHNDB_IO_COMMON_TEARDOWN();
}

/**
 * Default bhndb(4) implementation of BHND_MAP_INTR().
 */
static int
bhndb_bhnd_map_intr(device_t dev, device_t child, u_int intr, rman_res_t *irq)
{
	u_int			 ivec;
	int			 error;

	/* Is the intr valid? */
	if (intr >= bhnd_get_intr_count(child))
		return (EINVAL);

	/* Fetch the interrupt vector */
	if ((error = bhnd_get_intr_ivec(child, intr, &ivec)))
		return (error);

	/* Map directly to the actual backplane interrupt vector */
	*irq = ivec;

	return (0);
}

/**
 * Default bhndb(4) implementation of BHND_UNMAP_INTR().
 */
static void
bhndb_bhnd_unmap_intr(device_t dev, device_t child, rman_res_t irq)
{
	/* No state to clean up */
}

/**
 * Default bhndb(4) implementation of BUS_SETUP_INTR().
 */
static int
bhndb_setup_intr(device_t dev, device_t child, struct resource *r,
    int flags, driver_filter_t filter, driver_intr_t handler, void *arg,
    void **cookiep)
{
	struct bhndb_softc		*sc;
	struct bhndb_intr_isrc		*isrc;
	struct bhndb_intr_handler	*ih;
	int				 error;

	sc = device_get_softc(dev);

	/* Fetch the isrc */
	if ((error = BHNDB_MAP_INTR_ISRC(dev, r, &isrc))) {
		device_printf(dev, "failed to fetch isrc: %d\n", error);
		return (error);
	}

	/* Allocate new ihandler entry  */
	ih = bhndb_alloc_intr_handler(child, r, isrc);
	if (ih == NULL)
		return (ENOMEM);

	/* Perform actual interrupt setup via the host isrc */
	error = bus_setup_intr(isrc->is_owner, isrc->is_res, flags, filter,
	    handler, arg, &ih->ih_cookiep);
	if (error) {
		bhndb_free_intr_handler(ih);
		return (error);
	}

	/* Add to our interrupt handler list */
	BHNDB_LOCK(sc);
	bhndb_register_intr_handler(sc->bus_res, ih);
	BHNDB_UNLOCK(sc);

	/* Provide the interrupt handler entry as our cookiep value */
	*cookiep = ih;
	return (0);
}

/**
 * Default bhndb(4) implementation of BUS_TEARDOWN_INTR().
 */
static int
bhndb_teardown_intr(device_t dev, device_t child, struct resource *r,
    void *cookiep)
{
	struct bhndb_softc		*sc;
	struct bhndb_intr_handler	*ih;
	struct bhndb_intr_isrc		*isrc;
	int				 error;

	sc = device_get_softc(dev);

	/* Locate and claim ownership of the interrupt handler entry */
	BHNDB_LOCK(sc);

	ih = bhndb_find_intr_handler(sc->bus_res, cookiep);
	if (ih == NULL) {
		panic("%s requested teardown of invalid cookiep %p",
		    device_get_nameunit(child), cookiep);
	}

	bhndb_deregister_intr_handler(sc->bus_res, ih);

	BHNDB_UNLOCK(sc);

	/* Perform actual interrupt teardown via the host isrc */
	isrc = ih->ih_isrc;
	error = bus_teardown_intr(isrc->is_owner, isrc->is_res, ih->ih_cookiep);
	if (error) {
		/* If teardown fails, we need to reinsert the handler entry
		 * to allow later teardown */
		BHNDB_LOCK(sc);
		bhndb_register_intr_handler(sc->bus_res, ih);
		BHNDB_UNLOCK(sc);

		return (error);
	}

	/* Free the entry */
	bhndb_free_intr_handler(ih);
	return (0);
}

/**
 * Default bhndb(4) implementation of BUS_BIND_INTR().
 */
static int
bhndb_bind_intr(device_t dev, device_t child, struct resource *irq, int cpu)
{
	struct bhndb_softc		*sc;
	struct bhndb_intr_handler	*ih;
	struct bhndb_intr_isrc		*isrc;

	sc = device_get_softc(dev);
	isrc = NULL;

	/* Fetch the isrc corresponding to the child IRQ resource */
	BHNDB_LOCK(sc);
	STAILQ_FOREACH(ih, &sc->bus_res->bus_intrs, ih_link) {
		if (ih->ih_res == irq) {
			isrc = ih->ih_isrc;
			break;
		}
	}
	BHNDB_UNLOCK(sc);

	if (isrc == NULL) {
		panic("%s requested bind of invalid irq %#jx-%#jx",
		    device_get_nameunit(child), rman_get_start(irq),
		    rman_get_end(irq));
	}

	/* Perform actual bind via the host isrc */
	return (bus_bind_intr(isrc->is_owner, isrc->is_res, cpu));
}

/**
 * Default bhndb(4) implementation of BUS_DESCRIBE_INTR().
 */
static int
bhndb_describe_intr(device_t dev, device_t child, struct resource *irq,
    void *cookie, const char *descr)
{
	struct bhndb_softc		*sc;
	struct bhndb_intr_handler	*ih;
	struct bhndb_intr_isrc		*isrc;

	sc = device_get_softc(dev);

	/* Locate the interrupt handler entry; the caller owns the handler
	 * reference, and thus our entry is guaranteed to remain valid after
	 * we drop out lock below. */
	BHNDB_LOCK(sc);

	ih = bhndb_find_intr_handler(sc->bus_res, cookie);
	if (ih == NULL) {
		panic("%s requested invalid cookiep %p",
		    device_get_nameunit(child), cookie);
	}

	isrc = ih->ih_isrc;

	BHNDB_UNLOCK(sc);

	/* Perform the actual request via the host isrc */
	return (BUS_DESCRIBE_INTR(device_get_parent(isrc->is_owner),
	    isrc->is_owner, isrc->is_res, ih->ih_cookiep, descr));
}

/**
 * Default bhndb(4) implementation of BUS_CONFIG_INTR().
 */
static int
bhndb_config_intr(device_t dev, int irq, enum intr_trigger trig,
    enum intr_polarity pol)
{
	/* Unsupported */
	return (ENXIO);
}

/**
 * Default bhndb(4) implementation of BUS_REMAP_INTR().
 */
static int
bhndb_remap_intr(device_t dev, device_t child, u_int irq)
{
	/* Unsupported */
	return (ENXIO);
}

/**
 * Default bhndb(4) implementation of BHND_BUS_GET_DMA_TRANSLATION().
 */
static inline int
bhndb_get_dma_translation(device_t dev, device_t child, u_int width,
    uint32_t flags, bus_dma_tag_t *dmat,
    struct bhnd_dma_translation *translation)
{
	struct bhndb_softc			*sc;
	const struct bhndb_hwcfg		*hwcfg;
	const struct bhnd_dma_translation	*match;
	bus_dma_tag_t				 match_dmat;
	bhnd_addr_t				 addr_mask, match_addr_mask;

	sc = device_get_softc(dev);
	hwcfg = sc->bus_res->cfg;

	/* Is DMA supported? */
	if (sc->bus_res->res->dma_tags == NULL)
		return (ENODEV);

	/* Is the requested width supported? */
	if (width > BHND_DMA_ADDR_32BIT) {
		/* Backplane must support 64-bit addressing */
		if (!(sc->chipid.chip_caps & BHND_CAP_BP64))
			width = BHND_DMA_ADDR_32BIT;
	}

	/* Find the best matching descriptor for the requested width */
	addr_mask = BHND_DMA_ADDR_BITMASK(width);

	match = NULL;
	match_addr_mask = 0x0;
	match_dmat = NULL;

	for (size_t i = 0; i < sc->bus_res->res->num_dma_tags; i++) {
		const struct bhnd_dma_translation	*dwin;
		bhnd_addr_t				 masked;

		dwin = &hwcfg->dma_translations[i];

		/* The base address must be device addressable */
		if ((dwin->base_addr & addr_mask) != dwin->base_addr)
			continue;

		/* The flags must match */
		if ((dwin->flags & flags) != flags)
			continue;

		/* The window must cover at least part of our addressable
		 * range */
		masked = (dwin->addr_mask | dwin->addrext_mask) & addr_mask;
		if (masked == 0)
			continue;

		/* Is this a better match? */
		if (match == NULL || masked > match_addr_mask) {
			match = dwin;
			match_addr_mask = masked;
			match_dmat = sc->bus_res->res->dma_tags[i];
		}
	}

	if (match == NULL || match_addr_mask == 0)
		return (ENOENT);

	if (dmat != NULL)
		*dmat = match_dmat;

	if (translation != NULL)
		*translation = *match;

	return (0);
}

/**
 * Default bhndb(4) implementation of BUS_GET_DMA_TAG().
 */
static bus_dma_tag_t
bhndb_get_dma_tag(device_t dev, device_t child)
{
	struct bhndb_softc *sc = device_get_softc(dev);

	/*
	 * A bridge may have multiple DMA translation descriptors, each with
	 * their own incompatible restrictions; drivers should in general call
	 * BHND_BUS_GET_DMA_TRANSLATION() to fetch both the best available DMA
	 * translation, and its corresponding DMA tag.
	 *
	 * Child drivers that do not use BHND_BUS_GET_DMA_TRANSLATION() are
	 * responsible for creating their own restricted DMA tag; since we
	 * cannot do this for them in BUS_GET_DMA_TAG(), we simply return the
	 * bridge parent's DMA tag directly;
	 */
	return (bus_get_dma_tag(sc->parent_dev));
}

static device_method_t bhndb_methods[] = {
	/* Device interface */ \
	DEVMETHOD(device_probe,			bhndb_generic_probe),
	DEVMETHOD(device_detach,		bhndb_generic_detach),
	DEVMETHOD(device_shutdown,		bus_generic_shutdown),
	DEVMETHOD(device_suspend,		bhndb_generic_suspend),
	DEVMETHOD(device_resume,		bhndb_generic_resume),

	/* Bus interface */
	DEVMETHOD(bus_probe_nomatch,		bhndb_probe_nomatch),
	DEVMETHOD(bus_print_child,		bhndb_print_child),
	DEVMETHOD(bus_child_location,		bhndb_child_location),
	DEVMETHOD(bus_add_child,		bhndb_add_child),
	DEVMETHOD(bus_child_deleted,		bhndb_child_deleted),

	DEVMETHOD(bus_alloc_resource,		bhndb_alloc_resource),
	DEVMETHOD(bus_release_resource,		bhndb_release_resource),
	DEVMETHOD(bus_activate_resource,	bhndb_activate_resource),
	DEVMETHOD(bus_deactivate_resource,	bhndb_deactivate_resource),

	DEVMETHOD(bus_setup_intr,		bhndb_setup_intr),
	DEVMETHOD(bus_teardown_intr,		bhndb_teardown_intr),
	DEVMETHOD(bus_config_intr,		bhndb_config_intr),
	DEVMETHOD(bus_bind_intr,		bhndb_bind_intr),
	DEVMETHOD(bus_describe_intr,		bhndb_describe_intr),
	DEVMETHOD(bus_remap_intr,		bhndb_remap_intr),

	DEVMETHOD(bus_get_dma_tag,		bhndb_get_dma_tag),

	DEVMETHOD(bus_adjust_resource,		bhndb_adjust_resource),
	DEVMETHOD(bus_set_resource,		bus_generic_rl_set_resource),
	DEVMETHOD(bus_get_resource,		bus_generic_rl_get_resource),
	DEVMETHOD(bus_delete_resource,		bus_generic_rl_delete_resource),
	DEVMETHOD(bus_get_resource_list,	bhndb_get_resource_list),

	DEVMETHOD(bus_read_ivar,		bhndb_read_ivar),
	DEVMETHOD(bus_write_ivar,		bhndb_write_ivar),

	/* BHNDB interface */
	DEVMETHOD(bhndb_get_chipid,		bhndb_get_chipid),
	DEVMETHOD(bhndb_is_core_disabled,	bhndb_is_core_disabled),
	DEVMETHOD(bhndb_get_hostb_core,		bhndb_get_hostb_core),
	DEVMETHOD(bhndb_suspend_resource,	bhndb_suspend_resource),
	DEVMETHOD(bhndb_resume_resource,	bhndb_resume_resource),

	/* BHND interface */
	DEVMETHOD(bhnd_bus_get_chipid,		bhndb_get_chipid),
	DEVMETHOD(bhnd_bus_activate_resource,	bhndb_activate_bhnd_resource),
	DEVMETHOD(bhnd_bus_deactivate_resource,	bhndb_deactivate_bhnd_resource),
	DEVMETHOD(bhnd_bus_get_nvram_var,	bhnd_bus_generic_get_nvram_var),
	DEVMETHOD(bhnd_bus_map_intr,		bhndb_bhnd_map_intr),
	DEVMETHOD(bhnd_bus_unmap_intr,		bhndb_bhnd_unmap_intr),
	DEVMETHOD(bhnd_bus_get_dma_translation,	bhndb_get_dma_translation),

	DEVMETHOD(bhnd_bus_get_service_registry,bhndb_get_service_registry),
	DEVMETHOD(bhnd_bus_register_provider,	bhnd_bus_generic_sr_register_provider),
	DEVMETHOD(bhnd_bus_deregister_provider,	bhnd_bus_generic_sr_deregister_provider),
	DEVMETHOD(bhnd_bus_retain_provider,	bhnd_bus_generic_sr_retain_provider),
	DEVMETHOD(bhnd_bus_release_provider,	bhnd_bus_generic_sr_release_provider),

	DEVMETHOD(bhnd_bus_read_1,		bhndb_bus_read_1),
	DEVMETHOD(bhnd_bus_read_2,		bhndb_bus_read_2),
	DEVMETHOD(bhnd_bus_read_4,		bhndb_bus_read_4),
	DEVMETHOD(bhnd_bus_write_1,		bhndb_bus_write_1),
	DEVMETHOD(bhnd_bus_write_2,		bhndb_bus_write_2),
	DEVMETHOD(bhnd_bus_write_4,		bhndb_bus_write_4),

	DEVMETHOD(bhnd_bus_read_stream_1,	bhndb_bus_read_stream_1),
	DEVMETHOD(bhnd_bus_read_stream_2,	bhndb_bus_read_stream_2),
	DEVMETHOD(bhnd_bus_read_stream_4,	bhndb_bus_read_stream_4),
	DEVMETHOD(bhnd_bus_write_stream_1,	bhndb_bus_write_stream_1),
	DEVMETHOD(bhnd_bus_write_stream_2,	bhndb_bus_write_stream_2),
	DEVMETHOD(bhnd_bus_write_stream_4,	bhndb_bus_write_stream_4),

	DEVMETHOD(bhnd_bus_read_multi_1,	bhndb_bus_read_multi_1),
	DEVMETHOD(bhnd_bus_read_multi_2,	bhndb_bus_read_multi_2),
	DEVMETHOD(bhnd_bus_read_multi_4,	bhndb_bus_read_multi_4),
	DEVMETHOD(bhnd_bus_write_multi_1,	bhndb_bus_write_multi_1),
	DEVMETHOD(bhnd_bus_write_multi_2,	bhndb_bus_write_multi_2),
	DEVMETHOD(bhnd_bus_write_multi_4,	bhndb_bus_write_multi_4),

	DEVMETHOD(bhnd_bus_read_multi_stream_1,	bhndb_bus_read_multi_stream_1),
	DEVMETHOD(bhnd_bus_read_multi_stream_2,	bhndb_bus_read_multi_stream_2),
	DEVMETHOD(bhnd_bus_read_multi_stream_4,	bhndb_bus_read_multi_stream_4),
	DEVMETHOD(bhnd_bus_write_multi_stream_1,bhndb_bus_write_multi_stream_1),
	DEVMETHOD(bhnd_bus_write_multi_stream_2,bhndb_bus_write_multi_stream_2),
	DEVMETHOD(bhnd_bus_write_multi_stream_4,bhndb_bus_write_multi_stream_4),

	DEVMETHOD(bhnd_bus_set_multi_1,		bhndb_bus_set_multi_1),
	DEVMETHOD(bhnd_bus_set_multi_2,		bhndb_bus_set_multi_2),
	DEVMETHOD(bhnd_bus_set_multi_4,		bhndb_bus_set_multi_4),
	DEVMETHOD(bhnd_bus_set_region_1,	bhndb_bus_set_region_1),
	DEVMETHOD(bhnd_bus_set_region_2,	bhndb_bus_set_region_2),
	DEVMETHOD(bhnd_bus_set_region_4,	bhndb_bus_set_region_4),

	DEVMETHOD(bhnd_bus_read_region_1,	bhndb_bus_read_region_1),
	DEVMETHOD(bhnd_bus_read_region_2,	bhndb_bus_read_region_2),
	DEVMETHOD(bhnd_bus_read_region_4,	bhndb_bus_read_region_4),
	DEVMETHOD(bhnd_bus_write_region_1,	bhndb_bus_write_region_1),
	DEVMETHOD(bhnd_bus_write_region_2,	bhndb_bus_write_region_2),
	DEVMETHOD(bhnd_bus_write_region_4,	bhndb_bus_write_region_4),

	DEVMETHOD(bhnd_bus_read_region_stream_1,bhndb_bus_read_region_stream_1),
	DEVMETHOD(bhnd_bus_read_region_stream_2,bhndb_bus_read_region_stream_2),
	DEVMETHOD(bhnd_bus_read_region_stream_4,bhndb_bus_read_region_stream_4),
	DEVMETHOD(bhnd_bus_write_region_stream_1,bhndb_bus_write_region_stream_1),
	DEVMETHOD(bhnd_bus_write_region_stream_2,bhndb_bus_write_region_stream_2),
	DEVMETHOD(bhnd_bus_write_region_stream_4,bhndb_bus_write_region_stream_4),

	DEVMETHOD(bhnd_bus_barrier,		bhndb_bus_barrier),

	DEVMETHOD_END
};

DEFINE_CLASS_0(bhndb, bhndb_driver, bhndb_methods, sizeof(struct bhndb_softc));

MODULE_VERSION(bhndb, 1);
MODULE_DEPEND(bhndb, bhnd, 1, 1, 1);