freebsd-skq/sys/dev/bhnd/bhndb/bhndb.c
2016-03-22 22:25:08 +00:00

1944 lines
49 KiB
C

/*-
* Copyright (c) 2015 Landon Fuller <landon@landonf.org>
* All rights reserved.
*
* 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>
__FBSDID("$FreeBSD$");
/*
* 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/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/cores/chipc/chipcreg.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(device_t *devlist,
int num_devs,
const struct bhndb_hw *hw);
static int bhndb_initialize_region_cfg(
struct bhndb_softc *sc, device_t *devs,
int ndevs,
const struct bhndb_hw_priority *table,
struct bhndb_resources *r);
static int bhndb_find_hwspec(struct bhndb_softc *sc,
device_t *devs, int ndevs,
const struct bhndb_hw **hw);
static int bhndb_read_chipid(struct bhndb_softc *sc,
const struct bhndb_hwcfg *cfg,
struct bhnd_chipid *result);
static struct rman *bhndb_get_rman(struct bhndb_softc *sc,
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, int type, int rid,
struct resource *r);
static int bhndb_try_activate_resource(
struct bhndb_softc *sc, device_t child,
int type, int rid, struct resource *r,
bool *indirect);
/**
* 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 bhndb_softc *sc;
struct resource_list *rl;
int retval = 0;
sc = device_get_softc(dev);
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_pnpinfo_str(device_t bus, device_t child, char *buf,
size_t buflen)
{
*buf = '\0';
return (0);
}
static int
bhndb_child_location_str(device_t dev, device_t child, char *buf,
size_t buflen)
{
struct bhndb_softc *sc;
sc = device_get_softc(dev);
snprintf(buf, buflen, "base=0x%llx",
(unsigned long long) sc->chipid.enum_addr);
return (0);
}
/**
* Return true if @p devlist matches the @p hw specification.
*
* @param devlist A device table to match against.
* @param num_devs The number of devices in @p devlist.
* @param hw The hardware description to be matched against.
*/
static bool
bhndb_hw_matches(device_t *devlist, int num_devs, 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 (int d = 0; d < num_devs; d++) {
if (!bhnd_device_matches(devlist[d], match))
continue;
found = true;
break;
}
if (!found)
return (false);
}
return (true);
}
/**
* Initialize the region maps and priority configuration in @p r using
* the provided priority @p table and the set of devices attached to
* the bridged @p bus_dev .
*
* @param sc The bhndb device state.
* @param devs All devices enumerated on the bridged bhnd bus.
* @param ndevs The length of @p devs.
* @param table Hardware priority table to be used to determine the relative
* priorities of per-core port resources.
* @param r The resource state to be configured.
*/
static int
bhndb_initialize_region_cfg(struct bhndb_softc *sc, device_t *devs, int ndevs,
const struct bhndb_hw_priority *table, struct bhndb_resources *r)
{
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 (int i = 0; i < ndevs; i++) {
const struct bhndb_regwin *regw;
device_t child;
child = devs[i];
for (regw = r->cfg->register_windows;
regw->win_type != BHNDB_REGWIN_T_INVALID; regw++)
{
/* Only core windows are supported */
if (regw->win_type != BHNDB_REGWIN_T_CORE)
continue;
/* Skip non-applicable register windows. */
if (!bhndb_regwin_matches_device(regw, child))
continue;
/* Fetch the base address of the mapped port. */
error = bhnd_get_region_addr(child,
regw->core.port_type, regw->core.port,
regw->core.region, &addr, &size);
if (error)
return (error);
/*
* 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;
/*
* Add to the bus region list.
*
* The window priority for a statically mapped
* region is always HIGH.
*/
error = bhndb_add_resource_region(r, addr, size,
BHNDB_PRIORITY_HIGH, regw);
if (error)
return (error);
}
}
/*
* Perform priority accounting and register bridge regions for all
* ports defined in the priority table
*/
for (int i = 0; i < ndevs; i++) {
struct bhndb_region *region;
device_t child;
child = devs[i];
/*
* Skip priority accounting for cores that ...
*/
/* ... do not require bridge resources */
if (bhnd_is_hw_disabled(child) || !device_is_enabled(child))
continue;
/* ... do not have a priority table entry */
hp = bhndb_hw_priority_find_device(table, child);
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];
/* Skip ports not defined on this device */
if (!bhnd_is_region_valid(child, pp->type, pp->port,
pp->region))
{
continue;
}
/* Fetch the address+size of the mapped port. */
error = bhnd_get_region_addr(child, pp->type, pp->port,
pp->region, &addr, &size);
if (error)
return (error);
/* Skip ports with an existing static mapping */
region = bhndb_find_resource_region(r, addr, size);
if (region != NULL && region->static_regwin != NULL)
continue;
/* Define a dynamic region for this port */
error = bhndb_add_resource_region(r, addr, size,
pp->priority, 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 <= r->dwa_count) {
/* low+default+high priority regions get windows */
r->min_prio = BHNDB_PRIORITY_LOW;
} else if (prio_default + prio_high <= r->dwa_count) {
/* default+high priority regions get windows */
r->min_prio = BHNDB_PRIORITY_DEFAULT;
} else {
/* high priority regions get windows */
r->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;
prio_min = r->min_prio;
device_printf(sc->dev, "min_prio: %d\n", prio_min);
STAILQ_FOREACH(region, &r->bus_regions, link) {
prio = region->priority;
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\n",
(unsigned long long) region->addr,
(unsigned long long) region->size,
region->priority,
direct_msg, type_msg);
}
}
return (0);
}
/**
* Find a hardware specification for @p dev.
*
* @param sc The bhndb device state.
* @param devs All devices enumerated on the bridged bhnd bus.
* @param ndevs The length of @p devs.
* @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, device_t *devs, int ndevs,
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(devs, ndevs, next))
continue;
/* Found */
*hw = next;
return (0);
}
return (ENOENT);
}
/**
* Read the ChipCommon identification data for this device.
*
* @param sc bhndb device state.
* @param cfg The hardware configuration to use when mapping the ChipCommon
* registers.
* @param[out] result the chip identification data.
*
* @retval 0 success
* @retval non-zero if the ChipCommon identification data could not be read.
*/
static int
bhndb_read_chipid(struct bhndb_softc *sc, const struct bhndb_hwcfg *cfg,
struct bhnd_chipid *result)
{
const struct bhnd_chipid *parent_cid;
const struct bhndb_regwin *cc_win;
struct resource_spec rs;
int error;
/* Let our parent device override the discovery process */
parent_cid = BHNDB_BUS_GET_CHIPID(sc->parent_dev, sc->dev);
if (parent_cid != NULL) {
*result = *parent_cid;
return (0);
}
/* Find a register window we can use to map the first CHIPC_CHIPID_SIZE
* of ChipCommon registers. */
cc_win = bhndb_regwin_find_best(cfg->register_windows,
BHND_DEVCLASS_CC, 0, BHND_PORT_DEVICE, 0, 0, CHIPC_CHIPID_SIZE);
if (cc_win == NULL) {
device_printf(sc->dev, "no chipcommon register window\n");
return (0);
}
/* We can assume a device without a static ChipCommon window uses the
* default ChipCommon address. */
if (cc_win->win_type == BHNDB_REGWIN_T_DYN) {
error = BHNDB_SET_WINDOW_ADDR(sc->dev, cc_win,
BHND_DEFAULT_CHIPC_ADDR);
if (error) {
device_printf(sc->dev, "failed to set chipcommon "
"register window\n");
return (error);
}
}
/* Let the default bhnd implemenation alloc/release the resource and
* perform the read */
rs.type = cc_win->res.type;
rs.rid = cc_win->res.rid;
rs.flags = RF_ACTIVE;
return (bhnd_read_chipid(sc->parent_dev, &rs, cc_win->win_offset,
result));
}
/**
* 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.
*
* @param dev The bridge device to attach.
* @param bridge_devclass The device class of the bridging core. This is used
* to automatically detect the bridge core, and to disable additional bridge
* cores (e.g. PCMCIA on a PCIe device).
*/
int
bhndb_attach(device_t dev, bhnd_devclass_t bridge_devclass)
{
struct bhndb_softc *sc;
const struct bhndb_hwcfg *cfg;
int error;
sc = device_get_softc(dev);
sc->dev = dev;
sc->parent_dev = device_get_parent(dev);
sc->bridge_class = bridge_devclass;
BHNDB_LOCK_INIT(sc);
/* Read our chip identification data */
cfg = BHNDB_BUS_GET_GENERIC_HWCFG(sc->parent_dev, sc->dev);
if ((error = bhndb_read_chipid(sc, cfg, &sc->chipid)))
return (error);
/* Set up a resource manager for the device's address space. */
sc->mem_rman.rm_start = 0;
sc->mem_rman.rm_end = BUS_SPACE_MAXADDR_32BIT;
sc->mem_rman.rm_type = RMAN_ARRAY;
sc->mem_rman.rm_descr = "BHND I/O memory addresses";
if ((error = rman_init(&sc->mem_rman))) {
device_printf(dev, "could not initialize mem_rman\n");
return (error);
}
error = rman_manage_region(&sc->mem_rman, 0, BUS_SPACE_MAXADDR_32BIT);
if (error) {
device_printf(dev, "could not configure mem_rman\n");
goto failed;
}
/* Initialize basic resource allocation state. */
sc->bus_res = bhndb_alloc_resources(dev, sc->parent_dev, cfg);
if (sc->bus_res == NULL) {
error = ENXIO;
goto failed;
}
/* Attach our bridged bus device */
sc->bus_dev = device_add_child(dev, devclass_get_name(bhnd_devclass),
-1);
if (sc->bus_dev == NULL) {
error = ENXIO;
goto failed;
}
return (bus_generic_attach(dev));
failed:
BHNDB_LOCK_DESTROY(sc);
rman_fini(&sc->mem_rman);
if (sc->bus_res != NULL)
bhndb_free_resources(sc->bus_res);
return (error);
}
/**
* Default bhndb(4) implementation of BHNDB_INIT_FULL_CONFIG().
*
* This function provides the default bhndb implementation of
* BHNDB_INIT_FULL_CONFIG(), and must be called by any subclass driver
* overriding BHNDB_INIT_FULL_CONFIG().
*
* As documented by BHNDB_INIT_FULL_CONFIG, this function performs final
* bridge configuration based on the hardware information enumerated by the
* child bus, and will reset all resource allocation state on the bridge.
*
* When calling this method:
* - Any bus resources previously allocated by @p child must be deallocated.
* - The @p child bus must have performed initial enumeration -- but not
* probe or attachment -- of its children.
*/
int
bhndb_generic_init_full_config(device_t dev, device_t child,
const struct bhndb_hw_priority *hw_prio_table)
{
struct bhndb_softc *sc;
const struct bhndb_hw *hw;
struct bhndb_resources *r;
device_t *devs;
device_t hostb;
int ndevs;
int error;
sc = device_get_softc(dev);
hostb = NULL;
/* Fetch the full set of attached devices */
if ((error = device_get_children(sc->bus_dev, &devs, &ndevs)))
return (error);
/* Find our host bridge device */
for (int i = 0; i < ndevs; i++) {
if (bhnd_is_hostb_device(devs[i])) {
hostb = devs[i];
break;
}
}
if (hostb == NULL) {
device_printf(sc->dev, "no host bridge core found\n");
error = ENODEV;
goto cleanup;
}
/* Find our full register window configuration */
if ((error = bhndb_find_hwspec(sc, devs, ndevs, &hw))) {
device_printf(sc->dev, "unable to identify device, "
" using generic bridge resource definitions\n");
error = 0;
goto cleanup;
}
if (bootverbose)
device_printf(sc->dev, "%s resource configuration\n", hw->name);
/* Release existing resource state */
BHNDB_LOCK(sc);
bhndb_free_resources(sc->bus_res);
sc->bus_res = NULL;
BHNDB_UNLOCK(sc);
/* Allocate new resource state */
r = bhndb_alloc_resources(dev, sc->parent_dev, hw->cfg);
if (r == NULL) {
error = ENXIO;
goto cleanup;
}
/* Initialize our resource priority configuration */
error = bhndb_initialize_region_cfg(sc, devs, ndevs, hw_prio_table, r);
if (error) {
bhndb_free_resources(r);
goto cleanup;
}
/* Update our bridge state */
BHNDB_LOCK(sc);
sc->bus_res = r;
sc->hostb_dev = hostb;
BHNDB_UNLOCK(sc);
cleanup:
free(devs, M_TEMP);
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);
/* Clean up our driver state. */
rman_fini(&sc->mem_rman);
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);
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);
// TODO: IRQs?
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%lx+0x%lx\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);
// TODO: IRQs?
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%lx+0x%lx\n",
type, rman_get_start(r), rman_get_size(r));
return (bhndb_try_activate_resource(sc, rman_get_device(r), type,
rman_get_rid(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 rman instance for a given resource @p type, if any.
*
* @param sc The bhndb device state.
* @param type The resource type (e.g. SYS_RES_MEMORY, SYS_RES_IRQ, ...)
*/
static struct rman *
bhndb_get_rman(struct bhndb_softc *sc, int type)
{
switch (type) {
case SYS_RES_MEMORY:
return &sc->mem_rman;
case SYS_RES_IRQ:
// TODO
// return &sc->irq_rman;
return (NULL);
default:
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);
}
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_HW_DISABLED().
*/
static bool
bhndb_is_hw_disabled(device_t dev, device_t child) {
struct bhndb_softc *sc;
struct bhnd_core_info core;
sc = device_get_softc(dev);
/* Requestor must be attached to the bhnd bus */
if (device_get_parent(child) != sc->bus_dev) {
return (BHND_BUS_IS_HW_DISABLED(device_get_parent(dev), child));
}
/* Fetch core info */
core = bhnd_get_core_info(child);
/* 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_BUS_IS_HOSTB_DEVICE(dev, child));
/* Otherwise, assume the core is populated */
return (false);
}
/* ascending core index comparison used by bhndb_is_hostb_device() */
static int
compare_core_index(const void *lhs, const void *rhs)
{
u_int left = bhnd_get_core_index(*(const device_t *) lhs);
u_int right = bhnd_get_core_index(*(const device_t *) rhs);
if (left < right)
return (-1);
else if (left > right)
return (1);
else
return (0);
}
/**
* Default bhndb(4) implementation of BHND_BUS_IS_HOSTB_DEVICE().
*
* This function uses a heuristic valid on all known PCI/PCIe/PCMCIA-bridged
* bhnd(4) devices to determine the hostb core:
*
* - The core must have a Broadcom vendor ID.
* - The core devclass must match the bridge type.
* - The core must be the first device on the bus with the bridged device
* class.
*
* @param sc The bridge device state.
* @param cores The table of bridge-enumerated cores.
* @param num_cores The length of @p cores.
* @param core The core to check.
*/
static bool
bhndb_is_hostb_device(device_t dev, device_t child)
{
struct bhndb_softc *sc;
struct bhnd_core_match md;
device_t hostb_dev, *devlist;
int devcnt, error;
sc = device_get_softc(dev);
/* Requestor must be attached to the bhnd bus */
if (device_get_parent(child) != sc->bus_dev)
return (BHND_BUS_IS_HOSTB_DEVICE(device_get_parent(dev),
child));
/* Determine required device class and set up a match descriptor. */
md = (struct bhnd_core_match) {
.vendor = BHND_MFGID_BCM,
.device = BHND_COREID_INVALID,
.hwrev = { BHND_HWREV_INVALID, BHND_HWREV_INVALID },
.class = sc->bridge_class,
.unit = 0
};
/* Pre-screen the device before searching over the full device list. */
if (!bhnd_device_matches(child, &md))
return (false);
/* Must be the absolute first matching device on the bus. */
if ((error = device_get_children(sc->bus_dev, &devlist, &devcnt)))
return (false);
/* Sort by core index value, ascending */
qsort(devlist, devcnt, sizeof(*devlist), compare_core_index);
/* Find the actual hostb device */
hostb_dev = NULL;
for (int i = 0; i < devcnt; i++) {
if (bhnd_device_matches(devlist[i], &md)) {
hostb_dev = devlist[i];
break;
}
}
/* Clean up */
free(devlist, M_TEMP);
return (child == hostb_dev);
}
/**
* 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 immed_child, defaults;
sc = device_get_softc(dev);
immed_child = (device_get_parent(child) == dev);
defaults = (start == 0UL && end == ~0UL);
rle = NULL;
/* Populate defaults */
if (immed_child && defaults) {
/* 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 || end < start || count > ((end - start) + 1))
return (NULL);
/* Fetch the resource manager */
rm = bhndb_get_rman(sc, type);
if (rm == NULL)
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);
/* 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\n",
*rid, type, device_get_nameunit(child));
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, int type, int rid,
struct resource *r)
{
int error;
/* Deactivate resources */
if (rman_get_flags(r) & RF_ACTIVE) {
error = BUS_DEACTIVATE_RESOURCE(dev, child, type, rid, r);
if (error)
return (error);
}
if ((error = rman_release_resource(r)))
return (error);
return (0);
}
/**
* Default bhndb(4) implementation of BUS_ADJUST_RESOURCE().
*/
static int
bhndb_adjust_resource(device_t dev, device_t child, int type,
struct resource *r, rman_res_t start, rman_res_t end)
{
struct bhndb_softc *sc;
struct rman *rm;
int error;
sc = device_get_softc(dev);
error = 0;
/* Fetch resource manager */
rm = bhndb_get_rman(sc, type);
if (rm == NULL)
return (ENXIO);
if (!rman_is_region_manager(r, rm))
return (ENXIO);
/* If active, adjustment is limited by the assigned window. */
BHNDB_LOCK(sc);
// TODO: Currently unsupported
error = ENODEV;
BHNDB_UNLOCK(sc);
if (!error)
error = rman_adjust_resource(r, start, end);
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 win.
*
* @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, int type, int rid,
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_find_regwin_resource(sc->bus_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);
}
/* 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\n",
(unsigned long long) r_start,
(unsigned long long) r_start + r_size - 1);
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 type The type of the resource to be activated.
* @param rid The resource ID 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, int type,
int rid, 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;
BHNDB_LOCK_ASSERT(sc, MA_NOTOWNED);
// TODO - IRQs
if (type != SYS_RES_MEMORY)
return (ENXIO);
if (indirect)
*indirect = false;
/* Default to low priority */
dw_priority = BHNDB_PRIORITY_LOW;
/* Look for a bus region matching the resource's address range */
r_start = rman_get_start(r);
r_size = rman_get_size(r);
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, type,
rid, 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().
*
* Maps resource activation requests to a viable static or dynamic
* register window, if any.
*/
static int
bhndb_activate_resource(device_t dev, device_t child, int type, int rid,
struct resource *r)
{
struct bhndb_softc *sc = device_get_softc(dev);
return (bhndb_try_activate_resource(sc, child, type, rid, r, NULL));
}
/**
* Default bhndb(4) implementation of BUS_DEACTIVATE_RESOURCE().
*/
static int
bhndb_deactivate_resource(device_t dev, device_t child, int type,
int rid, struct resource *r)
{
struct bhndb_dw_alloc *dwa;
struct bhndb_softc *sc;
struct rman *rm;
int error;
sc = device_get_softc(dev);
if ((rm = bhndb_get_rman(sc, type)) == NULL)
return (EINVAL);
/* Mark inactive */
if ((error = rman_deactivate_resource(r)))
return (error);
/* Free any dynamic window allocation. */
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 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_ALLOC_RESOURCE().
*/
static struct bhnd_resource *
bhndb_alloc_bhnd_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 bhnd_resource *br;
sc = device_get_softc(dev);
/* Allocate resource wrapper */
br = malloc(sizeof(struct bhnd_resource), M_BHND, M_NOWAIT|M_ZERO);
if (br == NULL)
return (NULL);
/* Configure */
br->direct = false;
br->res = bus_alloc_resource(child, type, rid, start, end, count,
flags & ~RF_ACTIVE);
if (br->res == NULL)
goto failed;
if (flags & RF_ACTIVE) {
if (bhnd_activate_resource(child, type, *rid, br))
goto failed;
}
return (br);
failed:
if (br->res != NULL)
bus_release_resource(child, type, *rid, br->res);
free(br, M_BHND);
return (NULL);
}
/**
* Default bhndb(4) implementation of BHND_BUS_RELEASE_RESOURCE().
*/
static int
bhndb_release_bhnd_resource(device_t dev, device_t child,
int type, int rid, struct bhnd_resource *r)
{
int error;
if ((error = bus_release_resource(child, type, rid, r->res)))
return (error);
free(r, M_BHND);
return (0);
}
/**
* Default bhndb(4) implementation of BHND_BUS_ACTIVATE_RESOURCE().
*
* Attempts to activate a static register window, a dynamic register window,
* or configures @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);
/* Fetch the address range's resource priority */
r_start = rman_get_start(r->res);
r_size = rman_get_size(r->res);
r_prio = BHNDB_PRIORITY_NONE;
region = bhndb_find_resource_region(sc->bus_res, r_start, r_size);
if (region != NULL)
r_prio = region->priority;
/* If less than the minimum dynamic window priority, this
* resource should always be indirect. */
if (r_prio < sc->bus_res->min_prio)
return (0);
/* Attempt direct activation */
error = bhndb_try_activate_resource(sc, child, type, rid, 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)) {
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(child, type, rid, r->res);
if (!error)
r->direct = false;
return (error);
};
/**
* Slow path for bhndb_io_resource().
*
* Iterates over the existing allocated dynamic windows looking for a viable
* in-use region; the first matching region is returned.
*/
static struct bhndb_dw_alloc *
bhndb_io_resource_slow(struct bhndb_softc *sc, bus_addr_t addr,
bus_size_t size, bus_size_t *offset)
{
struct bhndb_resources *br;
struct bhndb_dw_alloc *dwa;
BHNDB_LOCK_ASSERT(sc, MA_OWNED);
br = sc->bus_res;
/* 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 */
*offset = dwa->win->win_offset;
*offset += addr - dwa->target;
return (dwa);
}
/* not found */
return (NULL);
}
/**
* Find the bridge resource to be used for I/O requests.
*
* @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.
*/
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)
{
struct bhndb_resources *br;
struct bhndb_dw_alloc *dwa;
int error;
BHNDB_LOCK_ASSERT(sc, MA_OWNED);
br = sc->bus_res;
/* Try to fetch a free window */
dwa = bhndb_dw_next_free(br);
/*
* If no dynamic windows are available, look for an existing
* region that maps the target range.
*
* If none are found, this is a child driver bug -- our window
* over-commit should only fail in the case where a child driver leaks
* resources, or perform operations out-of-order.
*
* Broadcom HND chipsets are designed to not require register window
* swapping during execution; as long as the child devices are
* attached/detached correctly, using the hardware's required order
* of operations, there should always be a window available for the
* current operation.
*/
if (dwa == NULL) {
dwa = bhndb_io_resource_slow(sc, addr, size, offset);
if (dwa == NULL) {
panic("register windows exhausted attempting to map "
"0x%llx-0x%llx\n",
(unsigned long long) addr,
(unsigned long long) addr+size-1);
}
return (dwa);
}
/* Adjust the window if the I/O request won't fit in the current
* target range. */
if (addr < dwa->target ||
(dwa->target + dwa->win->win_size) - addr < size)
{
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; \
\
sc = device_get_softc(dev); \
\
BHNDB_LOCK(sc); \
dwa = bhndb_io_resource(sc, rman_get_start(r->res) + \
offset, _io_size, &io_offset); \
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() \
BHNDB_UNLOCK(sc);
/* Defines a bhndb_bus_read_* method implementation */
#define BHNDB_IO_READ(_type, _size) \
static _type \
bhndb_bus_read_ ## _size (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_ ## _size (io_res, io_offset); \
BHNDB_IO_COMMON_TEARDOWN(); \
\
return (v); \
}
/* Defines a bhndb_bus_write_* method implementation */
#define BHNDB_IO_WRITE(_type, _size) \
static void \
bhndb_bus_write_ ## _size (device_t dev, device_t child, \
struct bhnd_resource *r, bus_size_t offset, _type value) \
{ \
BHNDB_IO_COMMON_SETUP(sizeof(_type)); \
bus_write_ ## _size (io_res, io_offset, value); \
BHNDB_IO_COMMON_TEARDOWN(); \
}
BHNDB_IO_READ(uint8_t, 1);
BHNDB_IO_READ(uint16_t, 2);
BHNDB_IO_READ(uint32_t, 4);
BHNDB_IO_WRITE(uint8_t, 1);
BHNDB_IO_WRITE(uint16_t, 2);
BHNDB_IO_WRITE(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)
{
bus_size_t remain;
BHNDB_IO_COMMON_SETUP(length);
/* TODO: It's unclear whether we need a barrier implementation,
* and if we do, what it needs to actually do. This may need
* revisiting once we have a better idea of requirements after
* porting the core drivers. */
panic("implementation incorrect");
/* Use 4-byte reads where possible */
remain = length % sizeof(uint32_t);
for (bus_size_t i = 0; i < (length - remain); i += 4)
bus_read_4(io_res, io_offset + offset + i);
/* Use 1 byte reads for the remainder */
for (bus_size_t i = 0; i < remain; i++)
bus_read_1(io_res, io_offset + offset + length + i);
BHNDB_IO_COMMON_TEARDOWN();
}
/**
* 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)
{
// TODO
return (EOPNOTSUPP);
}
/**
* Default bhndb(4) implementation of BUS_TEARDOWN_INTR().
*/
static int
bhndb_teardown_intr(device_t dev, device_t child, struct resource *r,
void *cookie)
{
// TODO
return (EOPNOTSUPP);
}
/**
* 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)
{
// TODO
return (EOPNOTSUPP);
}
/**
* Default bhndb(4) implementation of BUS_BIND_INTR().
*/
static int
bhndb_bind_intr(device_t dev, device_t child, struct resource *r, int cpu)
{
// TODO
return (EOPNOTSUPP);
}
/**
* 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)
{
// TODO
return (EOPNOTSUPP);
}
/**
* Default bhndb(4) implementation of BUS_GET_DMA_TAG().
*/
static bus_dma_tag_t
bhndb_get_dma_tag(device_t dev, device_t child)
{
// TODO
return (NULL);
}
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_pnpinfo_str, bhndb_child_pnpinfo_str),
DEVMETHOD(bus_child_location_str, bhndb_child_location_str),
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_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_init_full_config, bhndb_generic_init_full_config),
DEVMETHOD(bhndb_suspend_resource, bhndb_suspend_resource),
DEVMETHOD(bhndb_resume_resource, bhndb_resume_resource),
/* BHND interface */
DEVMETHOD(bhnd_bus_is_hw_disabled, bhndb_is_hw_disabled),
DEVMETHOD(bhnd_bus_is_hostb_device, bhndb_is_hostb_device),
DEVMETHOD(bhnd_bus_get_chipid, bhndb_get_chipid),
DEVMETHOD(bhnd_bus_alloc_resource, bhndb_alloc_bhnd_resource),
DEVMETHOD(bhnd_bus_release_resource, bhndb_release_bhnd_resource),
DEVMETHOD(bhnd_bus_activate_resource, bhndb_activate_bhnd_resource),
DEVMETHOD(bhnd_bus_activate_resource, bhndb_deactivate_bhnd_resource),
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_barrier, bhndb_bus_barrier),
DEVMETHOD_END
};
devclass_t bhndb_devclass;
DEFINE_CLASS_0(bhndb, bhndb_driver, bhndb_methods, sizeof(struct bhndb_softc));
MODULE_VERSION(bhndb, 1);
MODULE_DEPEND(bhndb, bhnd, 1, 1, 1);
MODULE_DEPEND(bhndb, bhnd_chipc, 1, 1, 1);