/*-
* Copyright (c) 2015-2016 Landon Fuller <landonf@FreeBSD.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$");
#include <sys/param.h>
#include <sys/endian.h>
#ifdef _KERNEL
#include <sys/systm.h>
#include <machine/_inttypes.h>
#else /* !_KERNEL */
#include <errno.h>
#include <inttypes.h>
#include <stdint.h>
#include <string.h>
#endif /* _KERNEL */
#include "bhnd_nvram_private.h"
#include "bhnd_nvram_data_spromvar.h"
static int bhnd_sprom_opcode_sort_idx(const void *lhs, const void *rhs);
static int bhnd_nvram_opcode_idx_vid_compare(const void *key,
const void *rhs);
static int bhnd_sprom_opcode_reset(bhnd_sprom_opcode_state *state);
static int bhnd_sprom_opcode_set_type(bhnd_sprom_opcode_state *state,
bhnd_nvram_type type);
static int bhnd_sprom_opcode_set_var(bhnd_sprom_opcode_state *state,
size_t vid);
static int bhnd_sprom_opcode_clear_var(bhnd_sprom_opcode_state *state);
static int bhnd_sprom_opcode_flush_bind(bhnd_sprom_opcode_state *state);
static int bhnd_sprom_opcode_read_opval32(bhnd_sprom_opcode_state *state,
uint8_t type, uint32_t *opval);
static int bhnd_sprom_opcode_step(bhnd_sprom_opcode_state *state,
uint8_t *opcode);
#define SPROM_OP_BAD(_state, _fmt, ...) \
BHND_NV_LOG("bad encoding at %td: " _fmt, \
(_state)->input - (_state)->layout->bindings, ##__VA_ARGS__)
/**
* Initialize SPROM opcode evaluation state.
*
* @param state The opcode state to be initialized.
* @param layout The SPROM layout to be parsed by this instance.
*
*
* @retval 0 success
* @retval non-zero If initialization fails, a regular unix error code will be
* returned.
*/
int
bhnd_sprom_opcode_init(bhnd_sprom_opcode_state *state,
const struct bhnd_sprom_layout *layout)
{
bhnd_sprom_opcode_idx_entry *idx;
size_t num_vars, num_idx;
int error;
idx = NULL;
state->layout = layout;
state->idx = NULL;
state->num_idx = 0;
/* Initialize interpretation state */
if ((error = bhnd_sprom_opcode_reset(state)))
return (error);
/* Allocate and populate our opcode index */
num_idx = state->layout->num_vars;
idx = bhnd_nv_calloc(num_idx, sizeof(*idx));
if (idx == NULL)
return (ENOMEM);
for (num_vars = 0; num_vars < num_idx; num_vars++) {
/* Seek to next entry */
if ((error = bhnd_sprom_opcode_next_var(state))) {
SPROM_OP_BAD(state, "error reading expected variable "
"entry: %d\n", error);
bhnd_nv_free(idx);
return (error);
}
/* Record entry state in our index */
error = bhnd_sprom_opcode_init_entry(state, &idx[num_vars]);
if (error) {
SPROM_OP_BAD(state, "error initializing index for "
"entry: %d\n", error);
bhnd_nv_free(idx);
return (error);
}
}
/* Should have reached end of binding table; next read must return
* ENOENT */
if ((error = bhnd_sprom_opcode_next_var(state)) != ENOENT) {
BHND_NV_LOG("expected EOF parsing binding table: %d\n", error);
bhnd_nv_free(idx);
return (ENXIO);
}
/* Reset interpretation state */
if ((error = bhnd_sprom_opcode_reset(state))) {
bhnd_nv_free(idx);
return (error);
}
/* Make index available to opcode state evaluation */
qsort(idx, num_idx, sizeof(idx[0]), bhnd_sprom_opcode_sort_idx);
state->idx = idx;
state->num_idx = num_idx;
return (0);
}
/**
* Reset SPROM opcode evaluation state; future evaluation will be performed
* starting at the first opcode.
*
* @param state The opcode state to be reset.
*
* @retval 0 success
* @retval non-zero If reset fails, a regular unix error code will be returned.
*/
static int
bhnd_sprom_opcode_reset(bhnd_sprom_opcode_state *state)
{
memset(&state->var, 0, sizeof(state->var));
state->input = state->layout->bindings;
state->offset = 0;
state->vid = 0;
state->var_state = SPROM_OPCODE_VAR_STATE_NONE;
bit_set(state->revs, state->layout->rev);
return (0);
}
/**
* Free any resources associated with @p state.
*
* @param state An opcode state previously successfully initialized with
* bhnd_sprom_opcode_init().
*/
void
bhnd_sprom_opcode_fini(bhnd_sprom_opcode_state *state)
{
bhnd_nv_free(state->idx);
}
/**
* Sort function used to prepare our index for querying; sorts
* bhnd_sprom_opcode_idx_entry values by variable ID, ascending.
*/
static int
bhnd_sprom_opcode_sort_idx(const void *lhs, const void *rhs)
{
const bhnd_sprom_opcode_idx_entry *l, *r;
l = lhs;
r = rhs;
if (l->vid < r->vid)
return (-1);
if (l->vid > r->vid)
return (1);
return (0);
}
/**
* Binary search comparison function used by bhnd_sprom_opcode_index_find();
* searches bhnd_sprom_opcode_idx_entry values by variable ID, ascending.
*/
static int
bhnd_nvram_opcode_idx_vid_compare(const void *key, const void *rhs)
{
const bhnd_sprom_opcode_idx_entry *entry;
size_t vid;
vid = *(const size_t *)key;
entry = rhs;
if (vid < entry->vid)
return (-1);
if (vid > entry->vid)
return (1);
return (0);
}
/**
* Locate an index entry for the variable with @p name, or NULL if not found.
*
* @param state The opcode state to be queried.
* @param name The name to search for.
*
* @retval non-NULL If @p name is found, its index entry value will be
* returned.
* @retval NULL If @p name is not found.
*/
bhnd_sprom_opcode_idx_entry *
bhnd_sprom_opcode_index_find(bhnd_sprom_opcode_state *state, const char *name)
{
const struct bhnd_nvram_vardefn *var;
size_t vid;
/* Determine the variable ID for the given name */
if ((var = bhnd_nvram_find_vardefn(name)) == NULL)
return (NULL);
vid = bhnd_nvram_get_vardefn_id(var);
/* Search our index for the variable ID */
return (bsearch(&vid, state->idx, state->num_idx, sizeof(state->idx[0]),
bhnd_nvram_opcode_idx_vid_compare));
}
/**
* Iterate over all index entries in @p state.
*
* @param state The opcode state to be iterated.
* @param[in,out] prev An entry previously returned by
* bhnd_sprom_opcode_index_next(), or a NULL value
* to begin iteration.
*
* @return Returns the next index entry name, or NULL if all entries have
* been iterated.
*/
bhnd_sprom_opcode_idx_entry *
bhnd_sprom_opcode_index_next(bhnd_sprom_opcode_state *state,
bhnd_sprom_opcode_idx_entry *prev)
{
size_t idxpos;
/* Get next index position */
if (prev == NULL) {
idxpos = 0;
} else {
/* Determine current position */
idxpos = (size_t)(prev - state->idx);
BHND_NV_ASSERT(idxpos < state->num_idx,
("invalid index %zu", idxpos));
/* Advance to next entry */
idxpos++;
}
/* Check for EOF */
if (idxpos == state->num_idx)
return (NULL);
return (&state->idx[idxpos]);
}
/**
* Initialize @p entry with the current variable's opcode state.
*
* @param state The opcode state to be saved.
* @param[out] entry The opcode index entry to be initialized from @p state.
*
* @retval 0 success
* @retval ENXIO if @p state cannot be serialized as an index entry.
*/
int
bhnd_sprom_opcode_init_entry(bhnd_sprom_opcode_state *state,
bhnd_sprom_opcode_idx_entry *entry)
{
size_t opcodes;
/* We limit the SPROM index representations to the minimal type widths
* capable of covering all known layouts */
/* Save SPROM image offset */
if (state->offset > UINT16_MAX) {
SPROM_OP_BAD(state, "cannot index large offset %u\n",
state->offset);
return (ENXIO);
}
entry->offset = state->offset;
/* Save current variable ID */
if (state->vid > UINT16_MAX) {
SPROM_OP_BAD(state, "cannot index large vid %zu\n",
state->vid);
return (ENXIO);
}
entry->vid = state->vid;
/* Save opcode position */
opcodes = (state->input - state->layout->bindings);
if (opcodes > UINT16_MAX) {
SPROM_OP_BAD(state, "cannot index large opcode offset "
"%zu\n", opcodes);
return (ENXIO);
}
entry->opcodes = opcodes;
return (0);
}
/**
* Reset SPROM opcode evaluation state and seek to the @p entry's position.
*
* @param state The opcode state to be reset.
* @param entry The indexed entry to which we'll seek the opcode state.
*/
int
bhnd_sprom_opcode_seek(bhnd_sprom_opcode_state *state,
bhnd_sprom_opcode_idx_entry *entry)
{
int error;
BHND_NV_ASSERT(entry->opcodes < state->layout->bindings_size,
("index entry references invalid opcode position"));
/* Reset state */
if ((error = bhnd_sprom_opcode_reset(state)))
return (error);
/* Seek to the indexed sprom opcode offset */
state->input = state->layout->bindings + entry->opcodes;
/* Restore the indexed sprom data offset and VID */
state->offset = entry->offset;
/* Restore the indexed sprom variable ID */
if ((error = bhnd_sprom_opcode_set_var(state, entry->vid)))
return (error);
return (0);
}
/**
* Set the current revision range for @p state. This also resets
* variable state.
*
* @param state The opcode state to update
* @param start The first revision in the range.
* @param end The last revision in the range.
*
* @retval 0 success
* @retval non-zero If updating @p state fails, a regular unix error code will
* be returned.
*/
static inline int
bhnd_sprom_opcode_set_revs(bhnd_sprom_opcode_state *state, uint8_t start,
uint8_t end)
{
int error;
/* Validate the revision range */
if (start > SPROM_OP_REV_MAX ||
end > SPROM_OP_REV_MAX ||
end < start)
{
SPROM_OP_BAD(state, "invalid revision range: %hhu-%hhu\n",
start, end);
return (EINVAL);
}
/* Clear variable state */
if ((error = bhnd_sprom_opcode_clear_var(state)))
return (error);
/* Reset revision mask */
memset(state->revs, 0x0, sizeof(state->revs));
bit_nset(state->revs, start, end);
return (0);
}
/**
* Set the current variable's value mask for @p state.
*
* @param state The opcode state to update
* @param mask The mask to be set
*
* @retval 0 success
* @retval non-zero If updating @p state fails, a regular unix error code will
* be returned.
*/
static inline int
bhnd_sprom_opcode_set_mask(bhnd_sprom_opcode_state *state, uint32_t mask)
{
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN) {
SPROM_OP_BAD(state, "no open variable definition\n");
return (EINVAL);
}
state->var.mask = mask;
return (0);
}
/**
* Set the current variable's value shift for @p state.
*
* @param state The opcode state to update
* @param shift The shift to be set
*
* @retval 0 success
* @retval non-zero If updating @p state fails, a regular unix error code will
* be returned.
*/
static inline int
bhnd_sprom_opcode_set_shift(bhnd_sprom_opcode_state *state, int8_t shift)
{
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN) {
SPROM_OP_BAD(state, "no open variable definition\n");
return (EINVAL);
}
state->var.shift = shift;
return (0);
}
/**
* Register a new BIND/BINDN operation with @p state.
*
* @param state The opcode state to update.
* @param count The number of elements to be bound.
* @param skip_in The number of input elements to skip after each bind.
* @param skip_in_negative If true, the input skip should be subtracted from
* the current offset after each bind. If false, the input skip should be
* added.
* @param skip_out The number of output elements to skip after each bind.
*
* @retval 0 success
* @retval EINVAL if a variable definition is not open.
* @retval EINVAL if @p skip_in and @p count would trigger an overflow or
* underflow when applied to the current input offset.
* @retval ERANGE if @p skip_in would overflow uint32_t when multiplied by
* @p count and the scale value.
* @retval ERANGE if @p skip_out would overflow uint32_t when multiplied by
* @p count and the scale value.
* @retval non-zero If updating @p state otherwise fails, a regular unix error
* code will be returned.
*/
static inline int
bhnd_sprom_opcode_set_bind(bhnd_sprom_opcode_state *state, uint8_t count,
uint8_t skip_in, bool skip_in_negative, uint8_t skip_out)
{
uint32_t iskip_total;
uint32_t iskip_scaled;
int error;
/* Must have an open variable */
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN) {
SPROM_OP_BAD(state, "no open variable definition\n");
SPROM_OP_BAD(state, "BIND outside of variable definition\n");
return (EINVAL);
}
/* Cannot overwite an existing bind definition */
if (state->var.have_bind) {
SPROM_OP_BAD(state, "BIND overwrites existing definition\n");
return (EINVAL);
}
/* Must have a count of at least 1 */
if (count == 0) {
SPROM_OP_BAD(state, "BIND with zero count\n");
return (EINVAL);
}
/* Scale skip_in by the current type width */
iskip_scaled = skip_in;
if ((error = bhnd_sprom_opcode_apply_scale(state, &iskip_scaled)))
return (error);
/* Calculate total input bytes skipped: iskip_scaled * count) */
if (iskip_scaled > 0 && UINT32_MAX / iskip_scaled < count) {
SPROM_OP_BAD(state, "skip_in %hhu would overflow", skip_in);
return (EINVAL);
}
iskip_total = iskip_scaled * count;
/* Verify that the skip_in value won't under/overflow the current
* input offset. */
if (skip_in_negative) {
if (iskip_total > state->offset) {
SPROM_OP_BAD(state, "skip_in %hhu would underflow "
"offset %u\n", skip_in, state->offset);
return (EINVAL);
}
} else {
if (UINT32_MAX - iskip_total < state->offset) {
SPROM_OP_BAD(state, "skip_in %hhu would overflow "
"offset %u\n", skip_in, state->offset);
return (EINVAL);
}
}
/* Set the actual count and skip values */
state->var.have_bind = true;
state->var.bind.count = count;
state->var.bind.skip_in = skip_in;
state->var.bind.skip_out = skip_out;
state->var.bind.skip_in_negative = skip_in_negative;
/* Update total bind count for the current variable */
state->var.bind_total++;
return (0);
}
/**
* Apply and clear the current opcode bind state, if any.
*
* @param state The opcode state to update.
*
* @retval 0 success
* @retval non-zero If updating @p state otherwise fails, a regular unix error
* code will be returned.
*/
static int
bhnd_sprom_opcode_flush_bind(bhnd_sprom_opcode_state *state)
{
int error;
uint32_t skip;
/* Nothing to do? */
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN ||
!state->var.have_bind)
return (0);
/* Apply SPROM offset adjustment */
if (state->var.bind.count > 0) {
skip = state->var.bind.skip_in * state->var.bind.count;
if ((error = bhnd_sprom_opcode_apply_scale(state, &skip)))
return (error);
if (state->var.bind.skip_in_negative) {
state->offset -= skip;
} else {
state->offset += skip;
}
}
/* Clear bind state */
memset(&state->var.bind, 0, sizeof(state->var.bind));
state->var.have_bind = false;
return (0);
}
/**
* Set the current type to @p type, and reset type-specific
* stream state.
*
* @param state The opcode state to update.
* @param type The new type.
*
* @retval 0 success
* @retval EINVAL if @p vid is not a valid variable ID.
*/
static int
bhnd_sprom_opcode_set_type(bhnd_sprom_opcode_state *state, bhnd_nvram_type type)
{
bhnd_nvram_type base_type;
size_t width;
uint32_t mask;
/* Must have an open variable definition */
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN) {
SPROM_OP_BAD(state, "type set outside variable definition\n");
return (EINVAL);
}
/* Fetch type width for use as our scale value */
width = bhnd_nvram_type_width(type);
if (width == 0) {
SPROM_OP_BAD(state, "unsupported variable-width type: %d\n",
type);
return (EINVAL);
} else if (width > UINT32_MAX) {
SPROM_OP_BAD(state, "invalid type width %zu for type: %d\n",
width, type);
return (EINVAL);
}
/* Determine default mask value for the element type */
base_type = bhnd_nvram_base_type(type);
switch (base_type) {
case BHND_NVRAM_TYPE_UINT8:
case BHND_NVRAM_TYPE_INT8:
case BHND_NVRAM_TYPE_CHAR:
mask = UINT8_MAX;
break;
case BHND_NVRAM_TYPE_UINT16:
case BHND_NVRAM_TYPE_INT16:
mask = UINT16_MAX;
break;
case BHND_NVRAM_TYPE_UINT32:
case BHND_NVRAM_TYPE_INT32:
mask = UINT32_MAX;
break;
case BHND_NVRAM_TYPE_STRING:
/* fallthrough (unused by SPROM) */
default:
SPROM_OP_BAD(state, "unsupported type: %d\n", type);
return (EINVAL);
}
/* Update state */
state->var.base_type = base_type;
state->var.mask = mask;
state->var.scale = (uint32_t)width;
return (0);
}
/**
* Clear current variable state, if any.
*
* @param state The opcode state to update.
*/
static int
bhnd_sprom_opcode_clear_var(bhnd_sprom_opcode_state *state)
{
if (state->var_state == SPROM_OPCODE_VAR_STATE_NONE)
return (0);
BHND_NV_ASSERT(state->var_state == SPROM_OPCODE_VAR_STATE_DONE,
("incomplete variable definition"));
BHND_NV_ASSERT(!state->var.have_bind, ("stale bind state"));
memset(&state->var, 0, sizeof(state->var));
state->var_state = SPROM_OPCODE_VAR_STATE_NONE;
return (0);
}
/**
* Set the current variable's array element count to @p nelem.
*
* @param state The opcode state to update.
* @param nelem The new array length.
*
* @retval 0 success
* @retval EINVAL if no open variable definition exists.
* @retval EINVAL if @p nelem is zero.
* @retval ENXIO if @p nelem is greater than one, and the current variable does
* not have an array type.
* @retval ENXIO if @p nelem exceeds the array length of the NVRAM variable
* definition.
*/
static int
bhnd_sprom_opcode_set_nelem(bhnd_sprom_opcode_state *state, uint8_t nelem)
{
const struct bhnd_nvram_vardefn *var;
/* Must have a defined variable */
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN) {
SPROM_OP_BAD(state, "array length set without open variable "
"state");
return (EINVAL);
}
/* Locate the actual variable definition */
if ((var = bhnd_nvram_get_vardefn(state->vid)) == NULL) {
SPROM_OP_BAD(state, "unknown variable ID: %zu\n", state->vid);
return (EINVAL);
}
/* Must be greater than zero */
if (nelem == 0) {
SPROM_OP_BAD(state, "invalid nelem: %hhu\n", nelem);
return (EINVAL);
}
/* If the variable is not an array-typed value, the array length
* must be 1 */
if (!bhnd_nvram_is_array_type(var->type) && nelem != 1) {
SPROM_OP_BAD(state, "nelem %hhu on non-array %zu\n", nelem,
state->vid);
return (ENXIO);
}
/* Cannot exceed the variable's defined array length */
if (nelem > var->nelem) {
SPROM_OP_BAD(state, "nelem %hhu exceeds %zu length %hhu\n",
nelem, state->vid, var->nelem);
return (ENXIO);
}
/* Valid length; update state */
state->var.nelem = nelem;
return (0);
}
/**
* Set the current variable ID to @p vid, and reset variable-specific
* stream state.
*
* @param state The opcode state to update.
* @param vid The new variable ID.
*
* @retval 0 success
* @retval EINVAL if @p vid is not a valid variable ID.
*/
static int
bhnd_sprom_opcode_set_var(bhnd_sprom_opcode_state *state, size_t vid)
{
const struct bhnd_nvram_vardefn *var;
int error;
BHND_NV_ASSERT(state->var_state == SPROM_OPCODE_VAR_STATE_NONE,
("overwrite of open variable definition"));
/* Locate the variable definition */
if ((var = bhnd_nvram_get_vardefn(vid)) == NULL) {
SPROM_OP_BAD(state, "unknown variable ID: %zu\n", vid);
return (EINVAL);
}
/* Update vid and var state */
state->vid = vid;
state->var_state = SPROM_OPCODE_VAR_STATE_OPEN;
/* Initialize default variable record values */
memset(&state->var, 0x0, sizeof(state->var));
/* Set initial base type */
if ((error = bhnd_sprom_opcode_set_type(state, var->type)))
return (error);
/* Set default array length */
if ((error = bhnd_sprom_opcode_set_nelem(state, var->nelem)))
return (error);
return (0);
}
/**
* Mark the currently open variable definition as complete.
*
* @param state The opcode state to update.
*
* @retval 0 success
* @retval EINVAL if no incomplete open variable definition exists.
*/
static int
bhnd_sprom_opcode_end_var(bhnd_sprom_opcode_state *state)
{
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN) {
SPROM_OP_BAD(state, "no open variable definition\n");
return (EINVAL);
}
state->var_state = SPROM_OPCODE_VAR_STATE_DONE;
return (0);
}
/**
* Apply the current scale to @p value.
*
* @param state The SPROM opcode state.
* @param[in,out] value The value to scale
*
* @retval 0 success
* @retval EINVAL if no open variable definition exists.
* @retval EINVAL if applying the current scale would overflow.
*/
int
bhnd_sprom_opcode_apply_scale(bhnd_sprom_opcode_state *state, uint32_t *value)
{
/* Must have a defined variable (and thus, scale) */
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN) {
SPROM_OP_BAD(state, "scaled value encoded without open "
"variable state");
return (EINVAL);
}
/* Applying the scale value must not overflow */
if (UINT32_MAX / state->var.scale < *value) {
SPROM_OP_BAD(state, "cannot represent %" PRIu32 " * %" PRIu32
"\n", *value, state->var.scale);
return (EINVAL);
}
*value = (*value) * state->var.scale;
return (0);
}
/**
* Read a SPROM_OP_DATA_* value from @p opcodes.
*
* @param state The SPROM opcode state.
* @param type The SROM_OP_DATA_* type to be read.
* @param opval On success, the 32bit data representation. If @p type is signed,
* the value will be appropriately sign extended and may be directly cast to
* int32_t.
*
* @retval 0 success
* @retval non-zero If reading the value otherwise fails, a regular unix error
* code will be returned.
*/
static int
bhnd_sprom_opcode_read_opval32(bhnd_sprom_opcode_state *state, uint8_t type,
uint32_t *opval)
{
const uint8_t *p;
int error;
p = state->input;
switch (type) {
case SPROM_OP_DATA_I8:
/* Convert to signed value first, then sign extend */
*opval = (int32_t)(int8_t)(*p);
p += 1;
break;
case SPROM_OP_DATA_U8:
*opval = *p;
p += 1;
break;
case SPROM_OP_DATA_U8_SCALED:
*opval = *p;
if ((error = bhnd_sprom_opcode_apply_scale(state, opval)))
return (error);
p += 1;
break;
case SPROM_OP_DATA_U16:
*opval = le16dec(p);
p += 2;
break;
case SPROM_OP_DATA_U32:
*opval = le32dec(p);
p += 4;
break;
default:
SPROM_OP_BAD(state, "unsupported data type: %hhu\n", type);
return (EINVAL);
}
/* Update read address */
state->input = p;
return (0);
}
/**
* Return true if our layout revision is currently defined by the SPROM
* opcode state.
*
* This may be used to test whether the current opcode stream state applies
* to the layout that we are actually parsing.
*
* A given opcode stream may cover multiple layout revisions, switching
* between them prior to defining a set of variables.
*/
static inline bool
bhnd_sprom_opcode_matches_layout_rev(bhnd_sprom_opcode_state *state)
{
return (bit_test(state->revs, state->layout->rev));
}
/**
* When evaluating @p state and @p opcode, rewrite @p opcode based on the
* current evaluation state.
*
* This allows the insertion of implicit opcodes into interpretation of the
* opcode stream.
*
* If @p opcode is rewritten, it should be returned from
* bhnd_sprom_opcode_step() instead of the opcode parsed from @p state's opcode
* stream.
*
* If @p opcode remains unmodified, then bhnd_sprom_opcode_step() should
* proceed to standard evaluation.
*/
static int
bhnd_sprom_opcode_rewrite_opcode(bhnd_sprom_opcode_state *state,
uint8_t *opcode)
{
uint8_t op;
int error;
op = SPROM_OPCODE_OP(*opcode);
switch (state->var_state) {
case SPROM_OPCODE_VAR_STATE_NONE:
/* No open variable definition */
return (0);
case SPROM_OPCODE_VAR_STATE_OPEN:
/* Open variable definition; check for implicit closure. */
/*
* If a variable definition contains no explicit bind
* instructions prior to closure, we must generate a DO_BIND
* instruction with count and skip values of 1.
*/
if (SPROM_OP_IS_VAR_END(op) &&
state->var.bind_total == 0)
{
uint8_t count, skip_in, skip_out;
bool skip_in_negative;
/* Create bind with skip_in/skip_out of 1, count of 1 */
count = 1;
skip_in = 1;
skip_out = 1;
skip_in_negative = false;
error = bhnd_sprom_opcode_set_bind(state, count,
skip_in, skip_in_negative, skip_out);
if (error)
return (error);
/* Return DO_BIND */
*opcode = SPROM_OPCODE_DO_BIND |
(0 << SPROM_OP_BIND_SKIP_IN_SIGN) |
(1 << SPROM_OP_BIND_SKIP_IN_SHIFT) |
(1 << SPROM_OP_BIND_SKIP_OUT_SHIFT);
return (0);
}
/*
* If a variable is implicitly closed (e.g. by a new variable
* definition), we must generate a VAR_END instruction.
*/
if (SPROM_OP_IS_IMPLICIT_VAR_END(op)) {
/* Mark as complete */
if ((error = bhnd_sprom_opcode_end_var(state)))
return (error);
/* Return VAR_END */
*opcode = SPROM_OPCODE_VAR_END;
return (0);
}
break;
case SPROM_OPCODE_VAR_STATE_DONE:
/* Previously completed variable definition. Discard variable
* state */
return (bhnd_sprom_opcode_clear_var(state));
}
/* Nothing to do */
return (0);
}
/**
* Evaluate one opcode from @p state.
*
* @param state The opcode state to be evaluated.
* @param[out] opcode On success, the evaluated opcode
*
* @retval 0 success
* @retval ENOENT if EOF is reached
* @retval non-zero if evaluation otherwise fails, a regular unix error
* code will be returned.
*/
static int
bhnd_sprom_opcode_step(bhnd_sprom_opcode_state *state, uint8_t *opcode)
{
int error;
while (*state->input != SPROM_OPCODE_EOF) {
uint32_t val;
uint8_t op, rewrite, immd;
/* Fetch opcode */
*opcode = *state->input;
op = SPROM_OPCODE_OP(*opcode);
immd = SPROM_OPCODE_IMM(*opcode);
/* Clear any existing bind state */
if ((error = bhnd_sprom_opcode_flush_bind(state)))
return (error);
/* Insert local opcode based on current state? */
rewrite = *opcode;
if ((error = bhnd_sprom_opcode_rewrite_opcode(state, &rewrite)))
return (error);
if (rewrite != *opcode) {
/* Provide rewritten opcode */
*opcode = rewrite;
/* We must keep evaluating until we hit a state
* applicable to the SPROM revision we're parsing */
if (!bhnd_sprom_opcode_matches_layout_rev(state))
continue;
return (0);
}
/* Advance input */
state->input++;
switch (op) {
case SPROM_OPCODE_VAR_IMM:
if ((error = bhnd_sprom_opcode_set_var(state, immd)))
return (error);
break;
case SPROM_OPCODE_VAR_REL_IMM:
error = bhnd_sprom_opcode_set_var(state,
state->vid + immd);
if (error)
return (error);
break;
case SPROM_OPCODE_VAR:
error = bhnd_sprom_opcode_read_opval32(state, immd,
&val);
if (error)
return (error);
if ((error = bhnd_sprom_opcode_set_var(state, val)))
return (error);
break;
case SPROM_OPCODE_VAR_END:
if ((error = bhnd_sprom_opcode_end_var(state)))
return (error);
break;
case SPROM_OPCODE_NELEM:
immd = *state->input;
if ((error = bhnd_sprom_opcode_set_nelem(state, immd)))
return (error);
state->input++;
break;
case SPROM_OPCODE_DO_BIND:
case SPROM_OPCODE_DO_BINDN: {
uint8_t count, skip_in, skip_out;
bool skip_in_negative;
/* Fetch skip arguments */
skip_in = (immd & SPROM_OP_BIND_SKIP_IN_MASK) >>
SPROM_OP_BIND_SKIP_IN_SHIFT;
skip_in_negative =
((immd & SPROM_OP_BIND_SKIP_IN_SIGN) != 0);
skip_out = (immd & SPROM_OP_BIND_SKIP_OUT_MASK) >>
SPROM_OP_BIND_SKIP_OUT_SHIFT;
/* Fetch count argument (if any) */
if (op == SPROM_OPCODE_DO_BINDN) {
/* Count is provided as trailing U8 */
count = *state->input;
state->input++;
} else {
count = 1;
}
/* Set BIND state */
error = bhnd_sprom_opcode_set_bind(state, count,
skip_in, skip_in_negative, skip_out);
if (error)
return (error);
break;
}
case SPROM_OPCODE_DO_BINDN_IMM: {
uint8_t count, skip_in, skip_out;
bool skip_in_negative;
/* Implicit skip_in/skip_out of 1, count encoded as immd
* value */
count = immd;
skip_in = 1;
skip_out = 1;
skip_in_negative = false;
error = bhnd_sprom_opcode_set_bind(state, count,
skip_in, skip_in_negative, skip_out);
if (error)
return (error);
break;
}
case SPROM_OPCODE_REV_IMM:
error = bhnd_sprom_opcode_set_revs(state, immd, immd);
if (error)
return (error);
break;
case SPROM_OPCODE_REV_RANGE: {
uint8_t range;
uint8_t rstart, rend;
/* Revision range is encoded in next byte, as
* { uint8_t start:4, uint8_t end:4 } */
range = *state->input;
rstart = (range & SPROM_OP_REV_START_MASK) >>
SPROM_OP_REV_START_SHIFT;
rend = (range & SPROM_OP_REV_END_MASK) >>
SPROM_OP_REV_END_SHIFT;
/* Update revision bitmask */
error = bhnd_sprom_opcode_set_revs(state, rstart, rend);
if (error)
return (error);
/* Advance input */
state->input++;
break;
}
case SPROM_OPCODE_MASK_IMM:
if ((error = bhnd_sprom_opcode_set_mask(state, immd)))
return (error);
break;
case SPROM_OPCODE_MASK:
error = bhnd_sprom_opcode_read_opval32(state, immd,
&val);
if (error)
return (error);
if ((error = bhnd_sprom_opcode_set_mask(state, val)))
return (error);
break;
case SPROM_OPCODE_SHIFT_IMM:
error = bhnd_sprom_opcode_set_shift(state, immd * 2);
if (error)
return (error);
break;
case SPROM_OPCODE_SHIFT: {
int8_t shift;
if (immd == SPROM_OP_DATA_I8) {
shift = (int8_t)(*state->input);
} else if (immd == SPROM_OP_DATA_U8) {
val = *state->input;
if (val > INT8_MAX) {
SPROM_OP_BAD(state, "invalid shift "
"value: %#x\n", val);
}
shift = val;
} else {
SPROM_OP_BAD(state, "unsupported shift data "
"type: %#hhx\n", immd);
return (EINVAL);
}
if ((error = bhnd_sprom_opcode_set_shift(state, shift)))
return (error);
state->input++;
break;
}
case SPROM_OPCODE_OFFSET_REL_IMM:
/* Fetch unscaled relative offset */
val = immd;
/* Apply scale */
error = bhnd_sprom_opcode_apply_scale(state, &val);
if (error)
return (error);
/* Adding val must not overflow our offset */
if (UINT32_MAX - state->offset < val) {
BHND_NV_LOG("offset out of range\n");
return (EINVAL);
}
/* Adjust offset */
state->offset += val;
break;
case SPROM_OPCODE_OFFSET:
error = bhnd_sprom_opcode_read_opval32(state, immd,
&val);
if (error)
return (error);
state->offset = val;
break;
case SPROM_OPCODE_TYPE:
/* Type follows as U8 */
immd = *state->input;
state->input++;
/* fall through */
case SPROM_OPCODE_TYPE_IMM:
switch (immd) {
case BHND_NVRAM_TYPE_UINT8:
case BHND_NVRAM_TYPE_UINT16:
case BHND_NVRAM_TYPE_UINT32:
case BHND_NVRAM_TYPE_UINT64:
case BHND_NVRAM_TYPE_INT8:
case BHND_NVRAM_TYPE_INT16:
case BHND_NVRAM_TYPE_INT32:
case BHND_NVRAM_TYPE_INT64:
case BHND_NVRAM_TYPE_CHAR:
case BHND_NVRAM_TYPE_STRING:
error = bhnd_sprom_opcode_set_type(state,
(bhnd_nvram_type)immd);
if (error)
return (error);
break;
default:
BHND_NV_LOG("unrecognized type %#hhx\n", immd);
return (EINVAL);
}
break;
default:
BHND_NV_LOG("unrecognized opcode %#hhx\n", *opcode);
return (EINVAL);
}
/* We must keep evaluating until we hit a state applicable to
* the SPROM revision we're parsing */
if (bhnd_sprom_opcode_matches_layout_rev(state))
return (0);
}
/* End of opcode stream */
return (ENOENT);
}
/**
* Reset SPROM opcode evaluation state, seek to the @p entry's position,
* and perform complete evaluation of the variable's opcodes.
*
* @param state The opcode state to be to be evaluated.
* @param entry The indexed variable location.
*
* @retval 0 success
* @retval non-zero If evaluation fails, a regular unix error code will be
* returned.
*/
int
bhnd_sprom_opcode_eval_var(bhnd_sprom_opcode_state *state,
bhnd_sprom_opcode_idx_entry *entry)
{
uint8_t opcode;
int error;
/* Seek to entry */
if ((error = bhnd_sprom_opcode_seek(state, entry)))
return (error);
/* Parse full variable definition */
while ((error = bhnd_sprom_opcode_step(state, &opcode)) == 0) {
/* Iterate until VAR_END */
if (SPROM_OPCODE_OP(opcode) != SPROM_OPCODE_VAR_END)
continue;
BHND_NV_ASSERT(state->var_state == SPROM_OPCODE_VAR_STATE_DONE,
("incomplete variable definition"));
return (0);
}
/* Error parsing definition */
return (error);
}
/**
* Evaluate @p state until the next variable definition is found.
*
* @param state The opcode state to be evaluated.
*
* @retval 0 success
* @retval ENOENT if no additional variable definitions are available.
* @retval non-zero if evaluation otherwise fails, a regular unix error
* code will be returned.
*/
int
bhnd_sprom_opcode_next_var(bhnd_sprom_opcode_state *state)
{
uint8_t opcode;
int error;
/* Step until we hit a variable opcode */
while ((error = bhnd_sprom_opcode_step(state, &opcode)) == 0) {
switch (SPROM_OPCODE_OP(opcode)) {
case SPROM_OPCODE_VAR:
case SPROM_OPCODE_VAR_IMM:
case SPROM_OPCODE_VAR_REL_IMM:
BHND_NV_ASSERT(
state->var_state == SPROM_OPCODE_VAR_STATE_OPEN,
("missing variable definition"));
return (0);
default:
continue;
}
}
/* Reached EOF, or evaluation failed */
return (error);
}
/**
* Evaluate @p state until the next binding for the current variable definition
* is found.
*
* @param state The opcode state to be evaluated.
*
* @retval 0 success
* @retval ENOENT if no additional binding opcodes are found prior to reaching
* a new variable definition, or the end of @p state's binding opcodes.
* @retval non-zero if evaluation otherwise fails, a regular unix error
* code will be returned.
*/
int
bhnd_sprom_opcode_next_binding(bhnd_sprom_opcode_state *state)
{
uint8_t opcode;
int error;
if (state->var_state != SPROM_OPCODE_VAR_STATE_OPEN)
return (EINVAL);
/* Step until we hit a bind opcode, or a new variable */
while ((error = bhnd_sprom_opcode_step(state, &opcode)) == 0) {
switch (SPROM_OPCODE_OP(opcode)) {
case SPROM_OPCODE_DO_BIND:
case SPROM_OPCODE_DO_BINDN:
case SPROM_OPCODE_DO_BINDN_IMM:
/* Found next bind */
BHND_NV_ASSERT(
state->var_state == SPROM_OPCODE_VAR_STATE_OPEN,
("missing variable definition"));
BHND_NV_ASSERT(state->var.have_bind, ("missing bind"));
return (0);
case SPROM_OPCODE_VAR_END:
/* No further binding opcodes */
BHND_NV_ASSERT(
state->var_state == SPROM_OPCODE_VAR_STATE_DONE,
("variable definition still available"));
return (ENOENT);
}
}
/* Not found, or evaluation failed */
return (error);
}
