Changeset View
Changeset View
Standalone View
Standalone View
sys/dev/bhnd/bhnd.c
Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines | |||||
#include <sys/bus.h> | #include <sys/bus.h> | ||||
#include <sys/module.h> | #include <sys/module.h> | ||||
#include <sys/systm.h> | #include <sys/systm.h> | ||||
#include <machine/bus.h> | #include <machine/bus.h> | ||||
#include <sys/rman.h> | #include <sys/rman.h> | ||||
#include <machine/resource.h> | #include <machine/resource.h> | ||||
#include <dev/bhnd/cores/chipc/chipcvar.h> | |||||
#include <dev/bhnd/cores/pmu/bhnd_pmu.h> | #include <dev/bhnd/cores/pmu/bhnd_pmu.h> | ||||
#include <dev/bhnd/cores/pmu/bhnd_pmureg.h> | |||||
#include "bhnd_chipc_if.h" | #include "bhnd_chipc_if.h" | ||||
#include "bhnd_nvram_if.h" | #include "bhnd_nvram_if.h" | ||||
#include "bhnd.h" | #include "bhnd.h" | ||||
#include "bhndreg.h" | |||||
#include "bhndvar.h" | #include "bhndvar.h" | ||||
#include "bhnd_private.h" | #include "bhnd_private.h" | ||||
MALLOC_DEFINE(M_BHND, "bhnd", "bhnd bus data structures"); | MALLOC_DEFINE(M_BHND, "bhnd", "bhnd bus data structures"); | ||||
/** | /** | ||||
* bhnd_generic_probe_nomatch() reporting configuration. | * bhnd_generic_probe_nomatch() reporting configuration. | ||||
▲ Show 20 Lines • Show All 276 Lines • ▼ Show 20 Lines | |||||
/** | /** | ||||
* Default bhnd(4) bus driver implementation of BHND_BUS_ALLOC_PMU(). | * Default bhnd(4) bus driver implementation of BHND_BUS_ALLOC_PMU(). | ||||
*/ | */ | ||||
int | int | ||||
bhnd_generic_alloc_pmu(device_t dev, device_t child) | bhnd_generic_alloc_pmu(device_t dev, device_t child) | ||||
{ | { | ||||
struct bhnd_softc *sc; | struct bhnd_softc *sc; | ||||
struct bhnd_resource *br; | struct bhnd_resource *r; | ||||
struct bhnd_core_pmu_info *pm; | struct bhnd_core_clkctl *clkctl; | ||||
struct resource_list *rl; | struct resource_list *rl; | ||||
struct resource_list_entry *rle; | struct resource_list_entry *rle; | ||||
device_t pmu_dev; | device_t pmu_dev; | ||||
bhnd_addr_t r_addr; | bhnd_addr_t r_addr; | ||||
bhnd_size_t r_size; | bhnd_size_t r_size; | ||||
bus_size_t pmu_regs; | bus_size_t pmu_regs; | ||||
u_int max_latency; | |||||
int error; | int error; | ||||
GIANT_REQUIRED; /* for newbus */ | GIANT_REQUIRED; /* for newbus */ | ||||
if (device_get_parent(child) != dev) | |||||
return (EINVAL); | |||||
sc = device_get_softc(dev); | sc = device_get_softc(dev); | ||||
pm = bhnd_get_pmu_info(child); | clkctl = bhnd_get_pmu_info(child); | ||||
pmu_regs = BHND_CLK_CTL_ST; | pmu_regs = BHND_CLK_CTL_ST; | ||||
/* already allocated? */ | /* already allocated? */ | ||||
if (pm != NULL) { | if (clkctl != NULL) { | ||||
panic("duplicate PMU allocation for %s", | panic("duplicate PMU allocation for %s", | ||||
device_get_nameunit(child)); | device_get_nameunit(child)); | ||||
} | } | ||||
/* Determine address+size of the core's PMU register block */ | /* Determine address+size of the core's PMU register block */ | ||||
error = bhnd_get_region_addr(child, BHND_PORT_DEVICE, 0, 0, &r_addr, | error = bhnd_get_region_addr(child, BHND_PORT_DEVICE, 0, 0, &r_addr, | ||||
&r_size); | &r_size); | ||||
if (error) { | if (error) { | ||||
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines | bhnd_generic_alloc_pmu(device_t dev, device_t child) | ||||
* XXX: The saved offset will be invalid if bus_adjust_resource is | * XXX: The saved offset will be invalid if bus_adjust_resource is | ||||
* used to modify the resource's start address. | * used to modify the resource's start address. | ||||
*/ | */ | ||||
if (rman_get_start(rle->res) > r_addr) | if (rman_get_start(rle->res) > r_addr) | ||||
pmu_regs -= rman_get_start(rle->res) - r_addr; | pmu_regs -= rman_get_start(rle->res) - r_addr; | ||||
else | else | ||||
pmu_regs -= r_addr - rman_get_start(rle->res); | pmu_regs -= r_addr - rman_get_start(rle->res); | ||||
/* Retain PMU reference on behalf of our caller */ | /* Retain a PMU reference for the clkctl instance state */ | ||||
pmu_dev = bhnd_retain_provider(child, BHND_SERVICE_PMU); | pmu_dev = bhnd_retain_provider(child, BHND_SERVICE_PMU); | ||||
if (pmu_dev == NULL) { | if (pmu_dev == NULL) { | ||||
device_printf(sc->dev, | device_printf(sc->dev, "PMU not found\n"); | ||||
"pmu unavailable; cannot allocate request state\n"); | |||||
return (ENXIO); | return (ENXIO); | ||||
} | } | ||||
/* Allocate and initialize PMU info */ | /* Fetch the maximum transition latency from our PMU */ | ||||
br = malloc(sizeof(struct bhnd_resource), M_BHND, M_NOWAIT); | max_latency = bhnd_pmu_get_max_transition_latency(pmu_dev); | ||||
if (br == NULL) { | |||||
/* Allocate a new bhnd_resource wrapping the standard resource we | |||||
* fetched from the resource list; we'll free this in | |||||
* bhnd_generic_release_pmu() */ | |||||
r = malloc(sizeof(struct bhnd_resource), M_BHND, M_NOWAIT); | |||||
if (r == NULL) { | |||||
bhnd_release_provider(child, pmu_dev, BHND_SERVICE_PMU); | bhnd_release_provider(child, pmu_dev, BHND_SERVICE_PMU); | ||||
return (ENOMEM); | return (ENOMEM); | ||||
} | } | ||||
br->res = rle->res; | r->res = rle->res; | ||||
br->direct = ((rman_get_flags(rle->res) & RF_ACTIVE) != 0); | r->direct = ((rman_get_flags(rle->res) & RF_ACTIVE) != 0); | ||||
pm = malloc(sizeof(*pm), M_BHND, M_NOWAIT); | /* Allocate the clkctl instance */ | ||||
if (pm == NULL) { | clkctl = bhnd_alloc_core_clkctl(child, pmu_dev, r, pmu_regs, | ||||
max_latency); | |||||
if (clkctl == NULL) { | |||||
free(r, M_BHND); | |||||
bhnd_release_provider(child, pmu_dev, BHND_SERVICE_PMU); | bhnd_release_provider(child, pmu_dev, BHND_SERVICE_PMU); | ||||
free(br, M_BHND); | |||||
return (ENOMEM); | return (ENOMEM); | ||||
} | } | ||||
pm->pm_dev = child; | |||||
pm->pm_res = br; | |||||
pm->pm_regs = pmu_regs; | |||||
pm->pm_pmu = pmu_dev; | |||||
bhnd_set_pmu_info(child, pm); | bhnd_set_pmu_info(child, clkctl); | ||||
return (0); | return (0); | ||||
} | } | ||||
/** | /** | ||||
* Default bhnd(4) bus driver implementation of BHND_BUS_RELEASE_PMU(). | * Default bhnd(4) bus driver implementation of BHND_BUS_RELEASE_PMU(). | ||||
*/ | */ | ||||
int | int | ||||
bhnd_generic_release_pmu(device_t dev, device_t child) | bhnd_generic_release_pmu(device_t dev, device_t child) | ||||
{ | { | ||||
struct bhnd_softc *sc; | struct bhnd_softc *sc; | ||||
struct bhnd_core_pmu_info *pm; | struct bhnd_core_clkctl *clkctl; | ||||
int error; | struct bhnd_resource *r; | ||||
device_t pmu_dev; | |||||
GIANT_REQUIRED; /* for newbus */ | GIANT_REQUIRED; /* for newbus */ | ||||
sc = device_get_softc(dev); | sc = device_get_softc(dev); | ||||
/* dispatch release request */ | if (device_get_parent(child) != dev) | ||||
pm = bhnd_get_pmu_info(child); | return (EINVAL); | ||||
if (pm == NULL) | |||||
clkctl = bhnd_get_pmu_info(child); | |||||
if (clkctl == NULL) | |||||
panic("pmu over-release for %s", device_get_nameunit(child)); | panic("pmu over-release for %s", device_get_nameunit(child)); | ||||
if ((error = BHND_PMU_CORE_RELEASE(pm->pm_pmu, pm))) | /* Clear all FORCE, AREQ, and ERSRC flags, unless we're already in | ||||
return (error); | * RESET. Suspending a core clears clkctl automatically (and attempting | ||||
* to access the PMU registers in a suspended core will trigger a | |||||
* system livelock). */ | |||||
if (!bhnd_is_hw_suspended(clkctl->cc_dev)) { | |||||
BHND_CLKCTL_LOCK(clkctl); | |||||
/* free PMU info */ | /* Clear all FORCE, AREQ, and ERSRC flags */ | ||||
BHND_CLKCTL_SET_4(clkctl, 0x0, BHND_CCS_FORCE_MASK | | |||||
BHND_CCS_AREQ_MASK | BHND_CCS_ERSRC_REQ_MASK); | |||||
BHND_CLKCTL_UNLOCK(clkctl); | |||||
} | |||||
/* Clear child's PMU info reference */ | |||||
bhnd_set_pmu_info(child, NULL); | bhnd_set_pmu_info(child, NULL); | ||||
bhnd_release_provider(pm->pm_dev, pm->pm_pmu, BHND_SERVICE_PMU); | /* Before freeing the clkctl instance, save a pointer to resources we | ||||
free(pm->pm_res, M_BHND); | * need to clean up manually */ | ||||
free(pm, M_BHND); | r = clkctl->cc_res; | ||||
pmu_dev = clkctl->cc_pmu_dev; | |||||
/* Free the clkctl instance */ | |||||
bhnd_free_core_clkctl(clkctl); | |||||
/* Free the child's bhnd resource wrapper */ | |||||
free(r, M_BHND); | |||||
/* Release the child's PMU provider reference */ | |||||
bhnd_release_provider(child, pmu_dev, BHND_SERVICE_PMU); | |||||
return (0); | return (0); | ||||
} | } | ||||
/** | /** | ||||
* Default bhnd(4) bus driver implementation of BHND_BUS_GET_CLOCK_LATENCY(). | |||||
*/ | |||||
int | |||||
bhnd_generic_get_clock_latency(device_t dev, device_t child, bhnd_clock clock, | |||||
u_int *latency) | |||||
{ | |||||
struct bhnd_core_clkctl *clkctl; | |||||
if (device_get_parent(child) != dev) | |||||
return (EINVAL); | |||||
if ((clkctl = bhnd_get_pmu_info(child)) == NULL) | |||||
panic("no active PMU allocation"); | |||||
return (bhnd_pmu_get_clock_latency(clkctl->cc_pmu_dev, clock, latency)); | |||||
} | |||||
/** | |||||
* Default bhnd(4) bus driver implementation of BHND_BUS_GET_CLOCK_FREQ(). | |||||
*/ | |||||
int | |||||
bhnd_generic_get_clock_freq(device_t dev, device_t child, bhnd_clock clock, | |||||
u_int *freq) | |||||
{ | |||||
struct bhnd_core_clkctl *clkctl; | |||||
if (device_get_parent(child) != dev) | |||||
return (EINVAL); | |||||
if ((clkctl = bhnd_get_pmu_info(child)) == NULL) | |||||
panic("no active PMU allocation"); | |||||
return (bhnd_pmu_get_clock_freq(clkctl->cc_pmu_dev, clock, freq)); | |||||
} | |||||
/** | |||||
* Default bhnd(4) bus driver implementation of BHND_BUS_REQUEST_CLOCK(). | * Default bhnd(4) bus driver implementation of BHND_BUS_REQUEST_CLOCK(). | ||||
*/ | */ | ||||
int | int | ||||
bhnd_generic_request_clock(device_t dev, device_t child, bhnd_clock clock) | bhnd_generic_request_clock(device_t dev, device_t child, bhnd_clock clock) | ||||
{ | { | ||||
struct bhnd_softc *sc; | struct bhnd_softc *sc; | ||||
struct bhnd_core_pmu_info *pm; | struct bhnd_core_clkctl *clkctl; | ||||
uint32_t avail; | |||||
uint32_t req; | |||||
int error; | |||||
sc = device_get_softc(dev); | sc = device_get_softc(dev); | ||||
if ((pm = bhnd_get_pmu_info(child)) == NULL) | if (device_get_parent(child) != dev) | ||||
panic("no active PMU request state"); | return (EINVAL); | ||||
/* dispatch request to PMU */ | if ((clkctl = bhnd_get_pmu_info(child)) == NULL) | ||||
return (BHND_PMU_CORE_REQ_CLOCK(pm->pm_pmu, pm, clock)); | panic("no active PMU allocation"); | ||||
BHND_ASSERT_CLKCTL_AVAIL(clkctl); | |||||
avail = 0x0; | |||||
req = 0x0; | |||||
switch (clock) { | |||||
case BHND_CLOCK_DYN: | |||||
break; | |||||
case BHND_CLOCK_ILP: | |||||
req |= BHND_CCS_FORCEILP; | |||||
break; | |||||
case BHND_CLOCK_ALP: | |||||
req |= BHND_CCS_FORCEALP; | |||||
avail |= BHND_CCS_ALPAVAIL; | |||||
break; | |||||
case BHND_CLOCK_HT: | |||||
req |= BHND_CCS_FORCEHT; | |||||
avail |= BHND_CCS_HTAVAIL; | |||||
break; | |||||
default: | |||||
device_printf(dev, "%s requested unknown clock: %#x\n", | |||||
device_get_nameunit(clkctl->cc_dev), clock); | |||||
return (ENODEV); | |||||
} | } | ||||
BHND_CLKCTL_LOCK(clkctl); | |||||
/* Issue request */ | |||||
BHND_CLKCTL_SET_4(clkctl, req, BHND_CCS_FORCE_MASK); | |||||
/* Wait for clock availability */ | |||||
error = bhnd_core_clkctl_wait(clkctl, avail, avail); | |||||
BHND_CLKCTL_UNLOCK(clkctl); | |||||
return (error); | |||||
} | |||||
/** | /** | ||||
* Default bhnd(4) bus driver implementation of BHND_BUS_ENABLE_CLOCKS(). | * Default bhnd(4) bus driver implementation of BHND_BUS_ENABLE_CLOCKS(). | ||||
*/ | */ | ||||
int | int | ||||
bhnd_generic_enable_clocks(device_t dev, device_t child, uint32_t clocks) | bhnd_generic_enable_clocks(device_t dev, device_t child, uint32_t clocks) | ||||
{ | { | ||||
struct bhnd_softc *sc; | struct bhnd_softc *sc; | ||||
struct bhnd_core_pmu_info *pm; | struct bhnd_core_clkctl *clkctl; | ||||
uint32_t avail; | |||||
uint32_t req; | |||||
int error; | |||||
sc = device_get_softc(dev); | sc = device_get_softc(dev); | ||||
if ((pm = bhnd_get_pmu_info(child)) == NULL) | if (device_get_parent(child) != dev) | ||||
panic("no active PMU request state"); | return (EINVAL); | ||||
/* dispatch request to PMU */ | if ((clkctl = bhnd_get_pmu_info(child)) == NULL) | ||||
return (BHND_PMU_CORE_EN_CLOCKS(pm->pm_pmu, pm, clocks)); | panic("no active PMU allocation"); | ||||
BHND_ASSERT_CLKCTL_AVAIL(clkctl); | |||||
sc = device_get_softc(dev); | |||||
avail = 0x0; | |||||
req = 0x0; | |||||
/* Build clock request flags */ | |||||
if (clocks & BHND_CLOCK_DYN) /* nothing to enable */ | |||||
clocks &= ~BHND_CLOCK_DYN; | |||||
if (clocks & BHND_CLOCK_ILP) /* nothing to enable */ | |||||
clocks &= ~BHND_CLOCK_ILP; | |||||
if (clocks & BHND_CLOCK_ALP) { | |||||
req |= BHND_CCS_ALPAREQ; | |||||
avail |= BHND_CCS_ALPAVAIL; | |||||
clocks &= ~BHND_CLOCK_ALP; | |||||
} | } | ||||
if (clocks & BHND_CLOCK_HT) { | |||||
req |= BHND_CCS_HTAREQ; | |||||
avail |= BHND_CCS_HTAVAIL; | |||||
clocks &= ~BHND_CLOCK_HT; | |||||
} | |||||
/* Check for unknown clock values */ | |||||
if (clocks != 0x0) { | |||||
device_printf(dev, "%s requested unknown clocks: %#x\n", | |||||
device_get_nameunit(clkctl->cc_dev), clocks); | |||||
return (ENODEV); | |||||
} | |||||
BHND_CLKCTL_LOCK(clkctl); | |||||
/* Issue request */ | |||||
BHND_CLKCTL_SET_4(clkctl, req, BHND_CCS_AREQ_MASK); | |||||
/* Wait for clock availability */ | |||||
error = bhnd_core_clkctl_wait(clkctl, avail, avail); | |||||
BHND_CLKCTL_UNLOCK(clkctl); | |||||
return (error); | |||||
} | |||||
/** | /** | ||||
* Default bhnd(4) bus driver implementation of BHND_BUS_REQUEST_EXT_RSRC(). | * Default bhnd(4) bus driver implementation of BHND_BUS_REQUEST_EXT_RSRC(). | ||||
*/ | */ | ||||
int | int | ||||
bhnd_generic_request_ext_rsrc(device_t dev, device_t child, u_int rsrc) | bhnd_generic_request_ext_rsrc(device_t dev, device_t child, u_int rsrc) | ||||
{ | { | ||||
struct bhnd_softc *sc; | struct bhnd_softc *sc; | ||||
struct bhnd_core_pmu_info *pm; | struct bhnd_core_clkctl *clkctl; | ||||
uint32_t req; | |||||
uint32_t avail; | |||||
int error; | |||||
sc = device_get_softc(dev); | sc = device_get_softc(dev); | ||||
if ((pm = bhnd_get_pmu_info(child)) == NULL) | if (device_get_parent(child) != dev) | ||||
panic("no active PMU request state"); | return (EINVAL); | ||||
/* dispatch request to PMU */ | if ((clkctl = bhnd_get_pmu_info(child)) == NULL) | ||||
return (BHND_PMU_CORE_REQ_EXT_RSRC(pm->pm_pmu, pm, rsrc)); | panic("no active PMU allocation"); | ||||
BHND_ASSERT_CLKCTL_AVAIL(clkctl); | |||||
sc = device_get_softc(dev); | |||||
if (rsrc > BHND_CCS_ERSRC_MAX) | |||||
return (EINVAL); | |||||
req = BHND_CCS_SET_BITS((1<<rsrc), BHND_CCS_ERSRC_REQ); | |||||
avail = BHND_CCS_SET_BITS((1<<rsrc), BHND_CCS_ERSRC_STS); | |||||
BHND_CLKCTL_LOCK(clkctl); | |||||
/* Write request */ | |||||
BHND_CLKCTL_SET_4(clkctl, req, req); | |||||
/* Wait for resource availability */ | |||||
error = bhnd_core_clkctl_wait(clkctl, avail, avail); | |||||
BHND_CLKCTL_UNLOCK(clkctl); | |||||
return (error); | |||||
} | } | ||||
/** | /** | ||||
* Default bhnd(4) bus driver implementation of BHND_BUS_RELEASE_EXT_RSRC(). | * Default bhnd(4) bus driver implementation of BHND_BUS_RELEASE_EXT_RSRC(). | ||||
*/ | */ | ||||
int | int | ||||
bhnd_generic_release_ext_rsrc(device_t dev, device_t child, u_int rsrc) | bhnd_generic_release_ext_rsrc(device_t dev, device_t child, u_int rsrc) | ||||
{ | { | ||||
struct bhnd_softc *sc; | struct bhnd_softc *sc; | ||||
struct bhnd_core_pmu_info *pm; | struct bhnd_core_clkctl *clkctl; | ||||
uint32_t mask; | |||||
sc = device_get_softc(dev); | sc = device_get_softc(dev); | ||||
if ((pm = bhnd_get_pmu_info(child)) == NULL) | if (device_get_parent(child) != dev) | ||||
panic("no active PMU request state"); | return (EINVAL); | ||||
/* dispatch request to PMU */ | if ((clkctl = bhnd_get_pmu_info(child)) == NULL) | ||||
return (BHND_PMU_CORE_RELEASE_EXT_RSRC(pm->pm_pmu, pm, rsrc)); | panic("no active PMU allocation"); | ||||
} | |||||
BHND_ASSERT_CLKCTL_AVAIL(clkctl); | |||||
sc = device_get_softc(dev); | |||||
if (rsrc > BHND_CCS_ERSRC_MAX) | |||||
return (EINVAL); | |||||
mask = BHND_CCS_SET_BITS((1<<rsrc), BHND_CCS_ERSRC_REQ); | |||||
/* Clear request */ | |||||
BHND_CLKCTL_LOCK(clkctl); | |||||
BHND_CLKCTL_SET_4(clkctl, 0x0, mask); | |||||
BHND_CLKCTL_UNLOCK(clkctl); | |||||
return (0); | |||||
} | |||||
/** | /** | ||||
* Default bhnd(4) bus driver implementation of BHND_BUS_IS_REGION_VALID(). | * Default bhnd(4) bus driver implementation of BHND_BUS_IS_REGION_VALID(). | ||||
* | * | ||||
* This implementation assumes that port and region numbers are 0-indexed and | * This implementation assumes that port and region numbers are 0-indexed and | ||||
* are allocated non-sparsely, using BHND_BUS_GET_PORT_COUNT() and | * are allocated non-sparsely, using BHND_BUS_GET_PORT_COUNT() and | ||||
* BHND_BUS_GET_REGION_COUNT() to determine if @p port and @p region fall | * BHND_BUS_GET_REGION_COUNT() to determine if @p port and @p region fall | ||||
* within the defined range. | * within the defined range. | ||||
*/ | */ | ||||
▲ Show 20 Lines • Show All 360 Lines • ▼ Show 20 Lines | static device_method_t bhnd_methods[] = { | ||||
DEVMETHOD(bhnd_bus_get_probe_order, bhnd_generic_get_probe_order), | DEVMETHOD(bhnd_bus_get_probe_order, bhnd_generic_get_probe_order), | ||||
DEVMETHOD(bhnd_bus_alloc_pmu, bhnd_generic_alloc_pmu), | DEVMETHOD(bhnd_bus_alloc_pmu, bhnd_generic_alloc_pmu), | ||||
DEVMETHOD(bhnd_bus_release_pmu, bhnd_generic_release_pmu), | DEVMETHOD(bhnd_bus_release_pmu, bhnd_generic_release_pmu), | ||||
DEVMETHOD(bhnd_bus_request_clock, bhnd_generic_request_clock), | DEVMETHOD(bhnd_bus_request_clock, bhnd_generic_request_clock), | ||||
DEVMETHOD(bhnd_bus_enable_clocks, bhnd_generic_enable_clocks), | DEVMETHOD(bhnd_bus_enable_clocks, bhnd_generic_enable_clocks), | ||||
DEVMETHOD(bhnd_bus_request_ext_rsrc, bhnd_generic_request_ext_rsrc), | DEVMETHOD(bhnd_bus_request_ext_rsrc, bhnd_generic_request_ext_rsrc), | ||||
DEVMETHOD(bhnd_bus_release_ext_rsrc, bhnd_generic_release_ext_rsrc), | DEVMETHOD(bhnd_bus_release_ext_rsrc, bhnd_generic_release_ext_rsrc), | ||||
DEVMETHOD(bhnd_bus_get_clock_latency, bhnd_generic_get_clock_latency), | |||||
DEVMETHOD(bhnd_bus_get_clock_freq, bhnd_generic_get_clock_freq), | |||||
DEVMETHOD(bhnd_bus_is_region_valid, bhnd_generic_is_region_valid), | DEVMETHOD(bhnd_bus_is_region_valid, bhnd_generic_is_region_valid), | ||||
DEVMETHOD(bhnd_bus_get_nvram_var, bhnd_generic_get_nvram_var), | DEVMETHOD(bhnd_bus_get_nvram_var, bhnd_generic_get_nvram_var), | ||||
/* BHND interface (bus I/O) */ | /* BHND interface (bus I/O) */ | ||||
DEVMETHOD(bhnd_bus_read_1, bhnd_read_1), | DEVMETHOD(bhnd_bus_read_1, bhnd_read_1), | ||||
DEVMETHOD(bhnd_bus_read_2, bhnd_read_2), | DEVMETHOD(bhnd_bus_read_2, bhnd_read_2), | ||||
DEVMETHOD(bhnd_bus_read_4, bhnd_read_4), | DEVMETHOD(bhnd_bus_read_4, bhnd_read_4), | ||||
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines |