7c7c726bca
Previously, the address regions described by disabled admatch entries would be treated as being mapped to the given core; while incorrect, this was essentially harmless given that the entries describe unused address space on the few affected devices. We now perform parsing of per-core admatch registers and interrupt flags in siba_erom, correctly skip any disabled admatch entries, and use the siba_erom API in siba_add_children() to perform enumeration of attached cores.
734 lines
18 KiB
C
734 lines
18 KiB
C
/*-
|
|
* 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>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/limits.h>
|
|
#include <sys/systm.h>
|
|
|
|
#include <machine/bus.h>
|
|
#include <machine/resource.h>
|
|
|
|
#include <dev/bhnd/bhndvar.h>
|
|
|
|
#include "sibareg.h"
|
|
#include "sibavar.h"
|
|
|
|
static int siba_register_interrupts(device_t dev, device_t child,
|
|
struct siba_devinfo *dinfo);
|
|
static int siba_append_dinfo_region(struct siba_devinfo *dinfo,
|
|
uint8_t addridx, uint32_t base, uint32_t size,
|
|
uint32_t bus_reserved);
|
|
|
|
/**
|
|
* Map a siba(4) OCP vendor code to its corresponding JEDEC JEP-106 vendor
|
|
* code.
|
|
*
|
|
* @param ocp_vendor An OCP vendor code.
|
|
* @return The BHND_MFGID constant corresponding to @p ocp_vendor, or
|
|
* BHND_MFGID_INVALID if the OCP vendor is unknown.
|
|
*/
|
|
uint16_t
|
|
siba_get_bhnd_mfgid(uint16_t ocp_vendor)
|
|
{
|
|
switch (ocp_vendor) {
|
|
case OCP_VENDOR_BCM:
|
|
return (BHND_MFGID_BCM);
|
|
default:
|
|
return (BHND_MFGID_INVALID);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allocate and return a new empty device info structure.
|
|
*
|
|
* @param bus The requesting bus device.
|
|
*
|
|
* @retval NULL if allocation failed.
|
|
*/
|
|
struct siba_devinfo *
|
|
siba_alloc_dinfo(device_t bus)
|
|
{
|
|
struct siba_devinfo *dinfo;
|
|
|
|
dinfo = malloc(sizeof(struct siba_devinfo), M_BHND, M_NOWAIT|M_ZERO);
|
|
if (dinfo == NULL)
|
|
return NULL;
|
|
|
|
for (u_int i = 0; i < nitems(dinfo->cfg); i++) {
|
|
dinfo->cfg[i] = ((struct siba_cfg_block){
|
|
.cb_base = 0,
|
|
.cb_size = 0,
|
|
.cb_rid = -1,
|
|
});
|
|
dinfo->cfg_res[i] = NULL;
|
|
dinfo->cfg_rid[i] = -1;
|
|
}
|
|
|
|
resource_list_init(&dinfo->resources);
|
|
|
|
dinfo->pmu_state = SIBA_PMU_NONE;
|
|
|
|
dinfo->intr = (struct siba_intr) {
|
|
.mapped = false,
|
|
.rid = -1
|
|
};
|
|
|
|
return dinfo;
|
|
}
|
|
|
|
/**
|
|
* Initialize a device info structure previously allocated via
|
|
* siba_alloc_dinfo, copying the provided core id.
|
|
*
|
|
* @param dev The requesting bus device.
|
|
* @param child The siba child device.
|
|
* @param dinfo The device info instance.
|
|
* @param core Device core info.
|
|
*
|
|
* @retval 0 success
|
|
* @retval non-zero initialization failed.
|
|
*/
|
|
int
|
|
siba_init_dinfo(device_t dev, device_t child, struct siba_devinfo *dinfo,
|
|
const struct siba_core_id *core_id)
|
|
{
|
|
int error;
|
|
|
|
dinfo->core_id = *core_id;
|
|
|
|
/* Register all address space mappings */
|
|
for (uint8_t i = 0; i < core_id->num_admatch; i++) {
|
|
uint32_t bus_reserved;
|
|
|
|
/* If this is the device's core/enumeration addrespace,
|
|
* reserve the Sonics configuration register blocks for the
|
|
* use of our bus. */
|
|
bus_reserved = 0;
|
|
if (i == SIBA_CORE_ADDRSPACE)
|
|
bus_reserved = core_id->num_cfg_blocks * SIBA_CFG_SIZE;
|
|
|
|
/* Append the region info */
|
|
error = siba_append_dinfo_region(dinfo, i,
|
|
core_id->admatch[i].am_base, core_id->admatch[i].am_size,
|
|
bus_reserved);
|
|
if (error)
|
|
return (error);
|
|
}
|
|
|
|
/* Register all interrupt(s) */
|
|
if ((error = siba_register_interrupts(dev, child, dinfo)))
|
|
return (error);
|
|
|
|
return (0);
|
|
}
|
|
|
|
|
|
/**
|
|
* Register and map all interrupts for @p dinfo.
|
|
*
|
|
* @param dev The siba bus device.
|
|
* @param child The siba child device.
|
|
* @param dinfo The device info instance on which to register all interrupt
|
|
* entries.
|
|
*/
|
|
static int
|
|
siba_register_interrupts(device_t dev, device_t child,
|
|
struct siba_devinfo *dinfo)
|
|
{
|
|
int error;
|
|
|
|
/* Is backplane interrupt distribution enabled for this core? */
|
|
if (!dinfo->core_id.intr_en)
|
|
return (0);
|
|
|
|
/* Have one interrupt */
|
|
dinfo->intr.mapped = false;
|
|
dinfo->intr.irq = 0;
|
|
dinfo->intr.rid = -1;
|
|
|
|
/* Map the interrupt */
|
|
error = BHND_BUS_MAP_INTR(dev, child, 0 /* single intr is always 0 */,
|
|
&dinfo->intr.irq);
|
|
if (error) {
|
|
device_printf(dev, "failed mapping interrupt line for core %u: "
|
|
"%d\n", dinfo->core_id.core_info.core_idx, error);
|
|
return (error);
|
|
}
|
|
dinfo->intr.mapped = true;
|
|
|
|
/* Update the resource list */
|
|
dinfo->intr.rid = resource_list_add_next(&dinfo->resources, SYS_RES_IRQ,
|
|
dinfo->intr.irq, dinfo->intr.irq, 1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Map an addrspace index to its corresponding bhnd(4) BHND_PORT_DEVICE port
|
|
* number.
|
|
*
|
|
* @param addrspace Address space index.
|
|
*/
|
|
u_int
|
|
siba_addrspace_device_port(u_int addrspace)
|
|
{
|
|
/* The first addrspace is always mapped to device0; the remainder
|
|
* are mapped to device1 */
|
|
if (addrspace == 0)
|
|
return (0);
|
|
else
|
|
return (1);
|
|
}
|
|
|
|
/**
|
|
* Map an addrspace index to its corresponding bhnd(4) BHND_PORT_DEVICE port
|
|
* region number.
|
|
*
|
|
* @param addrspace Address space index.
|
|
*/
|
|
u_int
|
|
siba_addrspace_device_region(u_int addrspace)
|
|
{
|
|
/* The first addrspace is always mapped to device0.0; the remainder
|
|
* are mapped to device1.0 + (n - 1) */
|
|
if (addrspace == 0)
|
|
return (0);
|
|
else
|
|
return (addrspace - 1);
|
|
}
|
|
|
|
/**
|
|
* Map an config block index to its corresponding bhnd(4) BHND_PORT_AGENT port
|
|
* number.
|
|
*
|
|
* @param cfg Config block index.
|
|
*/
|
|
u_int
|
|
siba_cfg_agent_port(u_int cfg)
|
|
{
|
|
/* Always agent0 */
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Map an config block index to its corresponding bhnd(4) BHND_PORT_AGENT port
|
|
* region number.
|
|
*
|
|
* @param cfg Config block index.
|
|
*/
|
|
u_int
|
|
siba_cfg_agent_region(u_int cfg)
|
|
{
|
|
/* Always agent0.<idx> */
|
|
return (cfg);
|
|
}
|
|
|
|
/**
|
|
* Return the number of bhnd(4) ports to advertise for the given
|
|
* @p core_id and @p port_type.
|
|
*
|
|
* Refer to the siba_addrspace_index() and siba_cfg_index() functions for
|
|
* information on siba's mapping of bhnd(4) port and region identifiers.
|
|
*
|
|
* @param core_id The siba core info.
|
|
* @param port_type The bhnd(4) port type.
|
|
*/
|
|
u_int
|
|
siba_port_count(struct siba_core_id *core_id, bhnd_port_type port_type)
|
|
{
|
|
switch (port_type) {
|
|
case BHND_PORT_DEVICE:
|
|
/* 0, 1, or 2 ports */
|
|
return (min(core_id->num_admatch, 2));
|
|
|
|
case BHND_PORT_AGENT:
|
|
/* One agent port maps all configuration blocks */
|
|
if (core_id->num_cfg_blocks > 0)
|
|
return (1);
|
|
|
|
/* Do not advertise an agent port if there are no configuration
|
|
* register blocks */
|
|
return (0);
|
|
|
|
default:
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return true if @p port of @p port_type is defined by @p core_id, false
|
|
* otherwise.
|
|
*
|
|
* @param core_id The siba core info.
|
|
* @param port_type The bhnd(4) port type.
|
|
* @param port The bhnd(4) port number.
|
|
*/
|
|
bool
|
|
siba_is_port_valid(struct siba_core_id *core_id, bhnd_port_type port_type,
|
|
u_int port)
|
|
{
|
|
/* Verify the index against the port count */
|
|
if (siba_port_count(core_id, port_type) <= port)
|
|
return (false);
|
|
|
|
return (true);
|
|
}
|
|
|
|
/**
|
|
* Return the number of bhnd(4) regions to advertise for @p core_id on the
|
|
* @p port of @p port_type.
|
|
*
|
|
* @param core_id The siba core info.
|
|
* @param port_type The bhnd(4) port type.
|
|
*/
|
|
u_int
|
|
siba_port_region_count(struct siba_core_id *core_id, bhnd_port_type port_type,
|
|
u_int port)
|
|
{
|
|
/* The port must exist */
|
|
if (!siba_is_port_valid(core_id, port_type, port))
|
|
return (0);
|
|
|
|
switch (port_type) {
|
|
case BHND_PORT_DEVICE:
|
|
/* The first address space, if any, is mapped to device0.0 */
|
|
if (port == 0)
|
|
return (min(core_id->num_admatch, 1));
|
|
|
|
/* All remaining address spaces are mapped to device0.(n - 1) */
|
|
if (port == 1 && core_id->num_admatch >= 2)
|
|
return (core_id->num_admatch - 1);
|
|
|
|
break;
|
|
|
|
case BHND_PORT_AGENT:
|
|
/* All config blocks are mapped to a single port */
|
|
if (port == 0)
|
|
return (core_id->num_cfg_blocks);
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Validated above */
|
|
panic("siba_is_port_valid() returned true for unknown %s.%u port",
|
|
bhnd_port_type_name(port_type), port);
|
|
|
|
}
|
|
|
|
/**
|
|
* Map a bhnd(4) type/port/region triplet to its associated config block index,
|
|
* if any.
|
|
*
|
|
* We map config registers to port/region identifiers as follows:
|
|
*
|
|
* [port].[region] [cfg register block]
|
|
* agent0.0 0
|
|
* agent0.1 1
|
|
*
|
|
* @param port_type The bhnd(4) port type.
|
|
* @param port The bhnd(4) port number.
|
|
* @param region The bhnd(4) port region.
|
|
* @param addridx On success, the corresponding addrspace index.
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOENT if the given type/port/region cannot be mapped to a
|
|
* siba config register block.
|
|
*/
|
|
int
|
|
siba_cfg_index(struct siba_core_id *core_id, bhnd_port_type port_type,
|
|
u_int port, u_int region, u_int *cfgidx)
|
|
{
|
|
/* Config blocks are mapped to agent ports */
|
|
if (port_type != BHND_PORT_AGENT)
|
|
return (ENOENT);
|
|
|
|
/* Port must be valid */
|
|
if (!siba_is_port_valid(core_id, port_type, port))
|
|
return (ENOENT);
|
|
|
|
if (region >= core_id->num_cfg_blocks)
|
|
return (ENOENT);
|
|
|
|
if (region >= SIBA_MAX_CFG)
|
|
return (ENOENT);
|
|
|
|
/* Found */
|
|
*cfgidx = region;
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Map an bhnd(4) type/port/region triplet to its associated config block
|
|
* entry, if any.
|
|
*
|
|
* The only supported port type is BHND_PORT_DEVICE.
|
|
*
|
|
* @param dinfo The device info to search for a matching address space.
|
|
* @param type The bhnd(4) port type.
|
|
* @param port The bhnd(4) port number.
|
|
* @param region The bhnd(4) port region.
|
|
*/
|
|
struct siba_cfg_block *
|
|
siba_find_cfg_block(struct siba_devinfo *dinfo, bhnd_port_type type, u_int port,
|
|
u_int region)
|
|
{
|
|
u_int cfgidx;
|
|
int error;
|
|
|
|
/* Map to addrspace index */
|
|
error = siba_cfg_index(&dinfo->core_id, type, port, region, &cfgidx);
|
|
if (error)
|
|
return (NULL);
|
|
|
|
/* Found */
|
|
return (&dinfo->cfg[cfgidx]);
|
|
}
|
|
|
|
/**
|
|
* Map a bhnd(4) type/port/region triplet to its associated address space
|
|
* index, if any.
|
|
*
|
|
* For compatibility with bcma(4), we map address spaces to port/region
|
|
* identifiers as follows:
|
|
*
|
|
* [port.region] [admatch index]
|
|
* device0.0 0
|
|
* device1.0 1
|
|
* device1.1 2
|
|
* device1.2 3
|
|
*
|
|
* @param core_id The siba core info.
|
|
* @param port_type The bhnd(4) port type.
|
|
* @param port The bhnd(4) port number.
|
|
* @param region The bhnd(4) port region.
|
|
* @param addridx On success, the corresponding addrspace index.
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOENT if the given type/port/region cannot be mapped to a
|
|
* siba address space.
|
|
*/
|
|
int
|
|
siba_addrspace_index(struct siba_core_id *core_id, bhnd_port_type port_type,
|
|
u_int port, u_int region, u_int *addridx)
|
|
{
|
|
u_int idx;
|
|
|
|
/* Address spaces are always device ports */
|
|
if (port_type != BHND_PORT_DEVICE)
|
|
return (ENOENT);
|
|
|
|
/* Port must be valid */
|
|
if (!siba_is_port_valid(core_id, port_type, port))
|
|
return (ENOENT);
|
|
|
|
if (port == 0)
|
|
idx = region;
|
|
else if (port == 1)
|
|
idx = region + 1;
|
|
else
|
|
return (ENOENT);
|
|
|
|
if (idx >= core_id->num_admatch)
|
|
return (ENOENT);
|
|
|
|
/* Found */
|
|
*addridx = idx;
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Map an bhnd(4) type/port/region triplet to its associated address space
|
|
* entry, if any.
|
|
*
|
|
* The only supported port type is BHND_PORT_DEVICE.
|
|
*
|
|
* @param dinfo The device info to search for a matching address space.
|
|
* @param type The bhnd(4) port type.
|
|
* @param port The bhnd(4) port number.
|
|
* @param region The bhnd(4) port region.
|
|
*/
|
|
struct siba_addrspace *
|
|
siba_find_addrspace(struct siba_devinfo *dinfo, bhnd_port_type type, u_int port,
|
|
u_int region)
|
|
{
|
|
u_int addridx;
|
|
int error;
|
|
|
|
/* Map to addrspace index */
|
|
error = siba_addrspace_index(&dinfo->core_id, type, port, region,
|
|
&addridx);
|
|
if (error)
|
|
return (NULL);
|
|
|
|
/* Found */
|
|
if (addridx >= SIBA_MAX_ADDRSPACE)
|
|
return (NULL);
|
|
|
|
return (&dinfo->addrspace[addridx]);
|
|
}
|
|
|
|
/**
|
|
* Append an address space entry to @p dinfo.
|
|
*
|
|
* @param dinfo The device info entry to update.
|
|
* @param addridx The address space index.
|
|
* @param base The mapping's base address.
|
|
* @param size The mapping size.
|
|
* @param bus_reserved Number of bytes to reserve in @p size for bus use
|
|
* when registering the resource list entry. This is used to reserve bus
|
|
* access to the core's SIBA_CFG* register blocks.
|
|
*
|
|
* @retval 0 success
|
|
* @retval non-zero An error occurred appending the entry.
|
|
*/
|
|
static int
|
|
siba_append_dinfo_region(struct siba_devinfo *dinfo, uint8_t addridx,
|
|
uint32_t base, uint32_t size, uint32_t bus_reserved)
|
|
{
|
|
struct siba_addrspace *sa;
|
|
rman_res_t r_size;
|
|
|
|
/* Verify that base + size will not overflow */
|
|
if (size > 0 && UINT32_MAX - (size - 1) < base)
|
|
return (ERANGE);
|
|
|
|
/* Verify that size - bus_reserved will not underflow */
|
|
if (size < bus_reserved)
|
|
return (ERANGE);
|
|
|
|
/* Must not be 0-length */
|
|
if (size == 0)
|
|
return (EINVAL);
|
|
|
|
/* Must not exceed addrspace array size */
|
|
if (addridx >= nitems(dinfo->addrspace))
|
|
return (EINVAL);
|
|
|
|
/* Initialize new addrspace entry */
|
|
sa = &dinfo->addrspace[addridx];
|
|
sa->sa_base = base;
|
|
sa->sa_size = size;
|
|
sa->sa_bus_reserved = bus_reserved;
|
|
|
|
/* Populate the resource list */
|
|
r_size = size - bus_reserved;
|
|
sa->sa_rid = resource_list_add_next(&dinfo->resources, SYS_RES_MEMORY,
|
|
base, base + (r_size - 1), r_size);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Deallocate the given device info structure and any associated resources.
|
|
*
|
|
* @param dev The requesting bus device.
|
|
* @param child The siba child device.
|
|
* @param dinfo Device info associated with @p child to be deallocated.
|
|
*/
|
|
void
|
|
siba_free_dinfo(device_t dev, device_t child, struct siba_devinfo *dinfo)
|
|
{
|
|
resource_list_free(&dinfo->resources);
|
|
|
|
/* Free all mapped configuration blocks */
|
|
for (u_int i = 0; i < nitems(dinfo->cfg); i++) {
|
|
if (dinfo->cfg_res[i] == NULL)
|
|
continue;
|
|
|
|
bhnd_release_resource(dev, SYS_RES_MEMORY, dinfo->cfg_rid[i],
|
|
dinfo->cfg_res[i]);
|
|
|
|
dinfo->cfg_res[i] = NULL;
|
|
dinfo->cfg_rid[i] = -1;
|
|
}
|
|
|
|
/* Unmap the core's interrupt */
|
|
if (dinfo->core_id.intr_en && dinfo->intr.mapped) {
|
|
BHND_BUS_UNMAP_INTR(dev, child, dinfo->intr.irq);
|
|
dinfo->intr.mapped = false;
|
|
}
|
|
|
|
free(dinfo, M_BHND);
|
|
}
|
|
|
|
/**
|
|
* Return the core-enumeration-relative offset for the @p addrspace
|
|
* SIBA_R0_ADMATCH* register.
|
|
*
|
|
* @param addrspace The address space index.
|
|
*
|
|
* @retval non-zero success
|
|
* @retval 0 the given @p addrspace index is not supported.
|
|
*/
|
|
u_int
|
|
siba_admatch_offset(uint8_t addrspace)
|
|
{
|
|
switch (addrspace) {
|
|
case 0:
|
|
return SB0_REG_ABS(SIBA_CFG0_ADMATCH0);
|
|
case 1:
|
|
return SB0_REG_ABS(SIBA_CFG0_ADMATCH1);
|
|
case 2:
|
|
return SB0_REG_ABS(SIBA_CFG0_ADMATCH2);
|
|
case 3:
|
|
return SB0_REG_ABS(SIBA_CFG0_ADMATCH3);
|
|
default:
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parse a SIBA_R0_ADMATCH* register.
|
|
*
|
|
* @param addrspace The address space index.
|
|
* @param am The address match register value to be parsed.
|
|
* @param[out] admatch The parsed address match descriptor
|
|
*
|
|
* @retval 0 success
|
|
* @retval non-zero a parse error occurred.
|
|
*/
|
|
int
|
|
siba_parse_admatch(uint32_t am, struct siba_admatch *admatch)
|
|
{
|
|
u_int am_type;
|
|
|
|
/* Extract the base address and size */
|
|
am_type = SIBA_REG_GET(am, AM_TYPE);
|
|
switch (am_type) {
|
|
case 0:
|
|
/* Type 0 entries are always enabled, and do not support
|
|
* negative matching */
|
|
admatch->am_base = am & SIBA_AM_BASE0_MASK;
|
|
admatch->am_size = 1 << (SIBA_REG_GET(am, AM_ADINT0) + 1);
|
|
admatch->am_enabled = true;
|
|
admatch->am_negative = false;
|
|
break;
|
|
case 1:
|
|
admatch->am_base = am & SIBA_AM_BASE1_MASK;
|
|
admatch->am_size = 1 << (SIBA_REG_GET(am, AM_ADINT1) + 1);
|
|
admatch->am_enabled = ((am & SIBA_AM_ADEN) != 0);
|
|
admatch->am_negative = ((am & SIBA_AM_ADNEG) != 0);
|
|
break;
|
|
case 2:
|
|
admatch->am_base = am & SIBA_AM_BASE2_MASK;
|
|
admatch->am_size = 1 << (SIBA_REG_GET(am, AM_ADINT2) + 1);
|
|
admatch->am_enabled = ((am & SIBA_AM_ADEN) != 0);
|
|
admatch->am_negative = ((am & SIBA_AM_ADNEG) != 0);
|
|
break;
|
|
default:
|
|
return (EINVAL);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Write @p value to @p dev's CFG0 target/initiator state register, performing
|
|
* required read-back and waiting for completion.
|
|
*
|
|
* @param dev The siba(4) child device.
|
|
* @param reg The CFG0 state register to write (e.g. SIBA_CFG0_TMSTATELOW,
|
|
* SIBA_CFG0_IMSTATE)
|
|
* @param value The value to write to @p reg.
|
|
* @param mask The mask of bits to be included from @p value.
|
|
*/
|
|
void
|
|
siba_write_target_state(device_t dev, struct siba_devinfo *dinfo,
|
|
bus_size_t reg, uint32_t value, uint32_t mask)
|
|
{
|
|
struct bhnd_resource *r;
|
|
uint32_t rval;
|
|
|
|
r = dinfo->cfg_res[0];
|
|
|
|
KASSERT(r != NULL, ("%s missing CFG0 mapping",
|
|
device_get_nameunit(dev)));
|
|
KASSERT(reg <= SIBA_CFG_SIZE-4, ("%s invalid CFG0 register offset %#jx",
|
|
device_get_nameunit(dev), (uintmax_t)reg));
|
|
|
|
rval = bhnd_bus_read_4(r, reg);
|
|
rval &= ~mask;
|
|
rval |= (value & mask);
|
|
|
|
bhnd_bus_write_4(r, reg, rval);
|
|
bhnd_bus_read_4(r, reg); /* read-back */
|
|
DELAY(1);
|
|
}
|
|
|
|
/**
|
|
* Spin for up to @p usec waiting for @p dev's CFG0 target/initiator state
|
|
* register value to be equal to @p value after applying @p mask bits to both
|
|
* values.
|
|
*
|
|
* @param dev The siba(4) child device to wait on.
|
|
* @param dinfo The @p dev's device info
|
|
* @param reg The state register to read (e.g. SIBA_CFG0_TMSTATEHIGH,
|
|
* SIBA_CFG0_IMSTATE)
|
|
* @param value The value against which @p reg will be compared.
|
|
* @param mask The mask to be applied when comparing @p value with @p reg.
|
|
* @param usec The maximum number of microseconds to wait for completion.
|
|
*
|
|
* @retval 0 if SIBA_TMH_BUSY is cleared prior to the @p usec timeout.
|
|
* @retval ENODEV if SIBA_CFG0 is not mapped by @p dinfo.
|
|
* @retval ETIMEDOUT if a timeout occurs.
|
|
*/
|
|
int
|
|
siba_wait_target_state(device_t dev, struct siba_devinfo *dinfo, bus_size_t reg,
|
|
uint32_t value, uint32_t mask, u_int usec)
|
|
{
|
|
struct bhnd_resource *r;
|
|
uint32_t rval;
|
|
|
|
if ((r = dinfo->cfg_res[0]) == NULL)
|
|
return (ENODEV);
|
|
|
|
value &= mask;
|
|
for (int i = 0; i < usec; i += 10) {
|
|
rval = bhnd_bus_read_4(r, reg);
|
|
if ((rval & mask) == value)
|
|
return (0);
|
|
|
|
DELAY(10);
|
|
}
|
|
|
|
return (ETIMEDOUT);
|
|
}
|