svn commit: r315866 - in head/sys: dev/bhnd/nvram mips/broadcom
Landon J. Fuller
landonf at FreeBSD.org
Thu Mar 23 19:29:15 UTC 2017
Author: landonf
Date: Thu Mar 23 19:29:12 2017
New Revision: 315866
URL: https://svnweb.freebsd.org/changeset/base/315866
Log:
[mips/broadcom]: Early boot NVRAM support
Add support for early boot access to NVRAM variables, using a new
bhnd_nvram_data_getvar_direct() API to support zero-allocation direct
reading of NVRAM variables from a bhnd_nvram_io instance backed by the
CFE NVRAM device.
Approved by: adrian (mentor)
Differential Revision: https://reviews.freebsd.org/D9913
Modified:
head/sys/dev/bhnd/nvram/bhnd_nvram_data.c
head/sys/dev/bhnd/nvram/bhnd_nvram_data.h
head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcm.c
head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcmraw.c
head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcmvar.h
head/sys/dev/bhnd/nvram/bhnd_nvram_data_btxt.c
head/sys/dev/bhnd/nvram/bhnd_nvram_data_sprom.c
head/sys/dev/bhnd/nvram/bhnd_nvram_data_sprom_subr.c
head/sys/dev/bhnd/nvram/bhnd_nvram_data_spromvar.h
head/sys/dev/bhnd/nvram/bhnd_nvram_data_tlv.c
head/sys/dev/bhnd/nvram/bhnd_nvram_datavar.h
head/sys/dev/bhnd/nvram/bhnd_sprom.c
head/sys/mips/broadcom/bcm_machdep.c
head/sys/mips/broadcom/bcm_machdep.h
head/sys/mips/broadcom/bcm_nvram_cfe.c
head/sys/mips/broadcom/bcm_nvram_cfevar.h
Modified: head/sys/dev/bhnd/nvram/bhnd_nvram_data.c
==============================================================================
--- head/sys/dev/bhnd/nvram/bhnd_nvram_data.c Thu Mar 23 17:11:34 2017 (r315865)
+++ head/sys/dev/bhnd/nvram/bhnd_nvram_data.c Thu Mar 23 19:29:12 2017 (r315866)
@@ -228,6 +228,41 @@ bhnd_nvram_data_probe_classes(struct bhn
}
/**
+ * Read a variable directly from @p io and decode as @p type.
+ *
+ * This may be used to perform reading of NVRAM variables during the very
+ * early boot process, prior to the availability of the kernel allocator.
+ *
+ * @param cls An NVRAM class capable of parsing @p io.
+ * @param io NVRAM data to be parsed.
+ * @param name The raw name of the variable to be fetched,
+ * including any device path (/pci/1/1/varname) or
+ * alias prefix (0:varname).
+ * @param[out] buf On success, the requested value will be written
+ * to this buffer. This argment may be NULL if
+ * the value is not desired.
+ * @param[in,out] len The capacity of @p buf. On success, will be set
+ * to the actual size of the requested value.
+ * @param type The data type to be written to @p buf.
+ *
+ * @retval 0 success
+ * @retval ENOMEM If @p buf is non-NULL and a buffer of @p len is too
+ * small to hold the requested value.
+ * @retval ENOENT If @p name is not found in @p io.
+ * @retval EFTYPE If the variable data cannot be coerced to @p type.
+ * @retval ERANGE If value coercion would overflow @p type.
+ * @retval non-zero If parsing @p io otherwise fails, a regular unix error
+ * code will be returned.
+ */
+int
+bhnd_nvram_data_getvar_direct(bhnd_nvram_data_class *cls,
+ struct bhnd_nvram_io *io, const char *name, void *buf, size_t *len,
+ bhnd_nvram_type type)
+{
+ return (cls->op_getvar_direct(io, name, buf, len, type));
+}
+
+/**
* Allocate and initialize a new instance of data class @p cls, copying and
* parsing NVRAM data from @p io.
*
Modified: head/sys/dev/bhnd/nvram/bhnd_nvram_data.h
==============================================================================
--- head/sys/dev/bhnd/nvram/bhnd_nvram_data.h Thu Mar 23 17:11:34 2017 (r315865)
+++ head/sys/dev/bhnd/nvram/bhnd_nvram_data.h Thu Mar 23 19:29:12 2017 (r315866)
@@ -105,6 +105,11 @@ int bhnd_nvram_data_probe_classes(
bhnd_nvram_data_class *classes[],
size_t num_classes);
+int bhnd_nvram_data_getvar_direct(
+ bhnd_nvram_data_class *cls,
+ struct bhnd_nvram_io *io, const char *name,
+ void *buf, size_t *len, bhnd_nvram_type type);
+
int bhnd_nvram_data_new(bhnd_nvram_data_class *cls,
struct bhnd_nvram_data **nv,
struct bhnd_nvram_io *io);
Modified: head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcm.c
==============================================================================
--- head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcm.c Thu Mar 23 17:11:34 2017 (r315865)
+++ head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcm.c Thu Mar 23 19:29:12 2017 (r315866)
@@ -144,9 +144,229 @@ bhnd_nvram_bcm_probe(struct bhnd_nvram_i
if (le32toh(hdr.magic) != BCM_NVRAM_MAGIC)
return (ENXIO);
+ if (le32toh(hdr.size) > bhnd_nvram_io_getsize(io))
+ return (ENXIO);
+
return (BHND_NVRAM_DATA_PROBE_DEFAULT);
}
+/**
+ * Parser states for bhnd_nvram_bcm_getvar_direct_common().
+ */
+typedef enum {
+ BCM_PARSE_KEY_START,
+ BCM_PARSE_KEY_CONT,
+ BCM_PARSE_KEY,
+ BCM_PARSE_NEXT_KEY,
+ BCM_PARSE_VALUE_START,
+ BCM_PARSE_VALUE
+} bcm_parse_state;
+
+static int
+bhnd_nvram_bcm_getvar_direct(struct bhnd_nvram_io *io, const char *name,
+ void *outp, size_t *olen, bhnd_nvram_type otype)
+{
+ return (bhnd_nvram_bcm_getvar_direct_common(io, name, outp, olen, otype,
+ true));
+}
+
+/**
+ * Common BCM/BCMRAW implementation of bhnd_nvram_getvar_direct().
+ */
+int
+bhnd_nvram_bcm_getvar_direct_common(struct bhnd_nvram_io *io, const char *name,
+ void *outp, size_t *olen, bhnd_nvram_type otype, bool have_header)
+{
+ struct bhnd_nvram_bcmhdr hdr;
+ char buf[512];
+ bcm_parse_state pstate;
+ size_t limit, offset;
+ size_t buflen, bufpos;
+ size_t namelen, namepos;
+ size_t vlen;
+ int error;
+
+ limit = bhnd_nvram_io_getsize(io);
+ offset = 0;
+
+ /* Fetch and validate the header */
+ if (have_header) {
+ if ((error = bhnd_nvram_io_read(io, offset, &hdr, sizeof(hdr))))
+ return (error);
+
+ if (le32toh(hdr.magic) != BCM_NVRAM_MAGIC)
+ return (ENXIO);
+
+ offset += sizeof(hdr);
+ limit = bhnd_nv_ummin(le32toh(hdr.size), limit);
+ }
+
+ /* Loop our parser until we find the requested variable, or hit EOF */
+ pstate = BCM_PARSE_KEY_START;
+ buflen = 0;
+ bufpos = 0;
+ namelen = strlen(name);
+ namepos = 0;
+ vlen = 0;
+
+ while ((offset - bufpos) < limit) {
+ BHND_NV_ASSERT(bufpos <= buflen,
+ ("buf position invalid (%zu > %zu)", bufpos, buflen));
+ BHND_NV_ASSERT(buflen <= sizeof(buf),
+ ("buf length invalid (%zu > %zu", buflen, sizeof(buf)));
+
+ /* Repopulate our parse buffer? */
+ if (buflen - bufpos == 0) {
+ BHND_NV_ASSERT(offset < limit, ("offset overrun"));
+
+ buflen = bhnd_nv_ummin(sizeof(buf), limit - offset);
+ bufpos = 0;
+
+ error = bhnd_nvram_io_read(io, offset, buf, buflen);
+ if (error)
+ return (error);
+
+ offset += buflen;
+ }
+
+ switch (pstate) {
+ case BCM_PARSE_KEY_START:
+ BHND_NV_ASSERT(buflen - bufpos > 0, ("empty buffer!"));
+
+ /* An extra '\0' denotes NVRAM EOF */
+ if (buf[bufpos] == '\0')
+ return (ENOENT);
+
+ /* Reset name matching position */
+ namepos = 0;
+
+ /* Start name matching */
+ pstate = BCM_PARSE_KEY_CONT;
+ break;
+
+ case BCM_PARSE_KEY_CONT: {
+ size_t navail, nleft;
+
+ nleft = namelen - namepos;
+ navail = bhnd_nv_ummin(buflen - bufpos, nleft);
+
+ if (strncmp(name+namepos, buf+bufpos, navail) == 0) {
+ /* Matched */
+ namepos += navail;
+ bufpos += navail;
+
+ /* If we've matched the full variable name,
+ * look for its trailing delimiter */
+ if (namepos == namelen)
+ pstate = BCM_PARSE_KEY;
+ } else {
+ /* No match; advance to next entry and restart
+ * name matching */
+ pstate = BCM_PARSE_NEXT_KEY;
+ }
+
+ break;
+ }
+
+ case BCM_PARSE_KEY:
+ BHND_NV_ASSERT(buflen - bufpos > 0, ("empty buffer!"));
+
+ if (buf[bufpos] == '=') {
+ /* Key fully matched; advance past '=' and
+ * parse the value */
+ bufpos++;
+ pstate = BCM_PARSE_VALUE_START;
+ } else {
+ /* No match; advance to next entry and restart
+ * name matching */
+ pstate = BCM_PARSE_NEXT_KEY;
+ }
+
+ break;
+
+ case BCM_PARSE_NEXT_KEY: {
+ const char *p;
+
+ /* Scan for a '\0' terminator */
+ p = memchr(buf+bufpos, '\0', buflen - bufpos);
+
+ if (p != NULL) {
+ /* Found entry terminator; restart name
+ * matching at next entry */
+ pstate = BCM_PARSE_KEY_START;
+ bufpos = (p - buf) + 1 /* skip '\0' */;
+ } else {
+ /* Consumed full buffer looking for '\0';
+ * force repopulation of the buffer and
+ * retry */
+ bufpos = buflen;
+ }
+
+ break;
+ }
+
+ case BCM_PARSE_VALUE_START: {
+ const char *p;
+
+ /* Scan for a '\0' terminator */
+ p = memchr(buf+bufpos, '\0', buflen - bufpos);
+
+ if (p != NULL) {
+ /* Found entry terminator; parse the value */
+ vlen = p - &buf[bufpos];
+ pstate = BCM_PARSE_VALUE;
+
+ } else if (p == NULL && offset == limit) {
+ /* Hit EOF without a terminating '\0';
+ * treat the entry as implicitly terminated */
+ vlen = buflen - bufpos;
+ pstate = BCM_PARSE_VALUE;
+
+ } else if (p == NULL && bufpos > 0) {
+ size_t nread;
+
+ /* Move existing value data to start of
+ * buffer */
+ memmove(buf, buf+bufpos, buflen - bufpos);
+ buflen = bufpos;
+ bufpos = 0;
+
+ /* Populate full buffer to allow retry of
+ * value parsing */
+ nread = bhnd_nv_ummin(sizeof(buf) - buflen,
+ limit - offset);
+
+ error = bhnd_nvram_io_read(io, offset,
+ buf+buflen, nread);
+ if (error)
+ return (error);
+
+ offset += nread;
+ buflen += nread;
+ } else {
+ /* Value exceeds our buffer capacity */
+ BHND_NV_LOG("cannot parse value for '%s' "
+ "(exceeds %zu byte limit)\n", name,
+ sizeof(buf));
+
+ return (ENXIO);
+ }
+
+ break;
+ }
+
+ case BCM_PARSE_VALUE:
+ BHND_NV_ASSERT(vlen <= buflen, ("value buf overrun"));
+
+ return (bhnd_nvram_value_coerce(buf+bufpos, vlen,
+ BHND_NVRAM_TYPE_STRING, outp, olen, otype));
+ }
+ }
+
+ /* Variable not found */
+ return (ENOENT);
+}
+
static int
bhnd_nvram_bcm_serialize(bhnd_nvram_data_class *cls, bhnd_nvram_plist *props,
bhnd_nvram_plist *options, void *outp, size_t *olen)
Modified: head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcmraw.c
==============================================================================
--- head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcmraw.c Thu Mar 23 17:11:34 2017 (r315865)
+++ head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcmraw.c Thu Mar 23 19:29:12 2017 (r315866)
@@ -50,6 +50,7 @@ __FBSDID("$FreeBSD$");
#include "bhnd_nvram_private.h"
#include "bhnd_nvram_datavar.h"
+#include "bhnd_nvram_data_bcmvar.h"
/*
* Broadcom-RAW NVRAM data class.
@@ -133,6 +134,14 @@ bhnd_nvram_bcmraw_probe(struct bhnd_nvra
}
static int
+bhnd_nvram_bcmraw_getvar_direct(struct bhnd_nvram_io *io, const char *name,
+ void *buf, size_t *len, bhnd_nvram_type type)
+{
+ return (bhnd_nvram_bcm_getvar_direct_common(io, name, buf, len, type,
+ false));
+}
+
+static int
bhnd_nvram_bcmraw_serialize(bhnd_nvram_data_class *cls, bhnd_nvram_plist *props,
bhnd_nvram_plist *options, void *outp, size_t *olen)
{
Modified: head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcmvar.h
==============================================================================
--- head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcmvar.h Thu Mar 23 17:11:34 2017 (r315865)
+++ head/sys/dev/bhnd/nvram/bhnd_nvram_data_bcmvar.h Thu Mar 23 19:29:12 2017 (r315866)
@@ -69,4 +69,8 @@ struct bhnd_nvram_bcmhdr {
uint32_t sdram_ncdl; /**< sdram_ncdl */
} __packed;
+int bhnd_nvram_bcm_getvar_direct_common(struct bhnd_nvram_io *io,
+ const char *name, void *outp, size_t *olen, bhnd_nvram_type otype,
+ bool have_header);
+
#endif /* _BHND_NVRAM_BHND_NVRAM_BCMVAR_H_ */
Modified: head/sys/dev/bhnd/nvram/bhnd_nvram_data_btxt.c
==============================================================================
--- head/sys/dev/bhnd/nvram/bhnd_nvram_data_btxt.c Thu Mar 23 17:11:34 2017 (r315865)
+++ head/sys/dev/bhnd/nvram/bhnd_nvram_data_btxt.c Thu Mar 23 19:29:12 2017 (r315866)
@@ -124,6 +124,226 @@ bhnd_nvram_btxt_probe(struct bhnd_nvram_
return (BHND_NVRAM_DATA_PROBE_MAYBE);
}
+
+/**
+ * Parser states for bhnd_nvram_bcm_getvar_direct_common().
+ */
+typedef enum {
+ BTXT_PARSE_LINE_START,
+ BTXT_PARSE_KEY,
+ BTXT_PARSE_KEY_END,
+ BTXT_PARSE_NEXT_LINE,
+ BTXT_PARSE_VALUE_START,
+ BTXT_PARSE_VALUE
+} btxt_parse_state;
+
+static int
+bhnd_nvram_btxt_getvar_direct(struct bhnd_nvram_io *io, const char *name,
+ void *outp, size_t *olen, bhnd_nvram_type otype)
+{
+ char buf[512];
+ btxt_parse_state pstate;
+ size_t limit, offset;
+ size_t buflen, bufpos;
+ size_t namelen, namepos;
+ size_t vlen;
+ int error;
+
+ limit = bhnd_nvram_io_getsize(io);
+ offset = 0;
+
+ /* Loop our parser until we find the requested variable, or hit EOF */
+ pstate = BTXT_PARSE_LINE_START;
+ buflen = 0;
+ bufpos = 0;
+ namelen = strlen(name);
+ namepos = 0;
+ vlen = 0;
+
+ while ((offset - bufpos) < limit) {
+ BHND_NV_ASSERT(bufpos <= buflen,
+ ("buf position invalid (%zu > %zu)", bufpos, buflen));
+ BHND_NV_ASSERT(buflen <= sizeof(buf),
+ ("buf length invalid (%zu > %zu", buflen, sizeof(buf)));
+
+ /* Repopulate our parse buffer? */
+ if (buflen - bufpos == 0) {
+ BHND_NV_ASSERT(offset < limit, ("offset overrun"));
+
+ buflen = bhnd_nv_ummin(sizeof(buf), limit - offset);
+ bufpos = 0;
+
+ error = bhnd_nvram_io_read(io, offset, buf, buflen);
+ if (error)
+ return (error);
+
+ offset += buflen;
+ }
+
+ switch (pstate) {
+ case BTXT_PARSE_LINE_START:
+ BHND_NV_ASSERT(bufpos < buflen, ("empty buffer!"));
+
+ /* Reset name matching position */
+ namepos = 0;
+
+ /* Trim any leading whitespace */
+ while (bufpos < buflen && bhnd_nv_isspace(buf[bufpos]))
+ {
+ bufpos++;
+ }
+
+ if (bufpos == buflen) {
+ /* Continue parsing the line */
+ pstate = BTXT_PARSE_LINE_START;
+ } else if (bufpos < buflen && buf[bufpos] == '#') {
+ /* Comment; skip to next line */
+ pstate = BTXT_PARSE_NEXT_LINE;
+ } else {
+ /* Start name matching */
+ pstate = BTXT_PARSE_KEY;
+ }
+
+
+ break;
+
+ case BTXT_PARSE_KEY: {
+ size_t navail, nleft;
+
+ nleft = namelen - namepos;
+ navail = bhnd_nv_ummin(buflen - bufpos, nleft);
+
+ if (strncmp(name+namepos, buf+bufpos, navail) == 0) {
+ /* Matched */
+ namepos += navail;
+ bufpos += navail;
+
+ if (namepos == namelen) {
+ /* Matched the full variable; look for
+ * its trailing delimiter */
+ pstate = BTXT_PARSE_KEY_END;
+ } else {
+ /* Continue matching the name */
+ pstate = BTXT_PARSE_KEY;
+ }
+ } else {
+ /* No match; advance to next entry and restart
+ * name matching */
+ pstate = BTXT_PARSE_NEXT_LINE;
+ }
+
+ break;
+ }
+
+ case BTXT_PARSE_KEY_END:
+ BHND_NV_ASSERT(bufpos < buflen, ("empty buffer!"));
+
+ if (buf[bufpos] == '=') {
+ /* Key fully matched; advance past '=' and
+ * parse the value */
+ bufpos++;
+ pstate = BTXT_PARSE_VALUE_START;
+ } else {
+ /* No match; advance to next line and restart
+ * name matching */
+ pstate = BTXT_PARSE_NEXT_LINE;
+ }
+
+ break;
+
+ case BTXT_PARSE_NEXT_LINE: {
+ const char *p;
+
+ /* Scan for a '\r', '\n', or '\r\n' terminator */
+ p = memchr(buf+bufpos, '\n', buflen - bufpos);
+ if (p == NULL)
+ p = memchr(buf+bufpos, '\r', buflen - bufpos);
+
+ if (p != NULL) {
+ /* Found entry terminator; restart name
+ * matching at next line */
+ pstate = BTXT_PARSE_LINE_START;
+ bufpos = (p - buf);
+ } else {
+ /* Consumed full buffer looking for newline;
+ * force repopulation of the buffer and
+ * retry */
+ pstate = BTXT_PARSE_NEXT_LINE;
+ bufpos = buflen;
+ }
+
+ break;
+ }
+
+ case BTXT_PARSE_VALUE_START: {
+ const char *p;
+
+ /* Scan for a terminating newline */
+ p = memchr(buf+bufpos, '\n', buflen - bufpos);
+ if (p == NULL)
+ p = memchr(buf+bufpos, '\r', buflen - bufpos);
+
+ if (p != NULL) {
+ /* Found entry terminator; parse the value */
+ vlen = p - &buf[bufpos];
+ pstate = BTXT_PARSE_VALUE;
+
+ } else if (p == NULL && offset == limit) {
+ /* Hit EOF without a terminating newline;
+ * treat the entry as implicitly terminated */
+ vlen = buflen - bufpos;
+ pstate = BTXT_PARSE_VALUE;
+
+ } else if (p == NULL && bufpos > 0) {
+ size_t nread;
+
+ /* Move existing value data to start of
+ * buffer */
+ memmove(buf, buf+bufpos, buflen - bufpos);
+ buflen = bufpos;
+ bufpos = 0;
+
+ /* Populate full buffer to allow retry of
+ * value parsing */
+ nread = bhnd_nv_ummin(sizeof(buf) - buflen,
+ limit - offset);
+
+ error = bhnd_nvram_io_read(io, offset,
+ buf+buflen, nread);
+ if (error)
+ return (error);
+
+ offset += nread;
+ buflen += nread;
+ } else {
+ /* Value exceeds our buffer capacity */
+ BHND_NV_LOG("cannot parse value for '%s' "
+ "(exceeds %zu byte limit)\n", name,
+ sizeof(buf));
+
+ return (ENXIO);
+ }
+
+ break;
+ }
+
+ case BTXT_PARSE_VALUE:
+ BHND_NV_ASSERT(vlen <= buflen, ("value buf overrun"));
+
+ /* Trim any trailing whitespace */
+ while (vlen > 0 && bhnd_nv_isspace(buf[bufpos+vlen-1]))
+ vlen--;
+
+ /* Write the value to the caller's buffer */
+ return (bhnd_nvram_value_coerce(buf+bufpos, vlen,
+ BHND_NVRAM_TYPE_STRING, outp, olen, otype));
+ }
+ }
+
+ /* Variable not found */
+ return (ENOENT);
+}
+
static int
bhnd_nvram_btxt_serialize(bhnd_nvram_data_class *cls, bhnd_nvram_plist *props,
bhnd_nvram_plist *options, void *outp, size_t *olen)
Modified: head/sys/dev/bhnd/nvram/bhnd_nvram_data_sprom.c
==============================================================================
--- head/sys/dev/bhnd/nvram/bhnd_nvram_data_sprom.c Thu Mar 23 17:11:34 2017 (r315865)
+++ head/sys/dev/bhnd/nvram/bhnd_nvram_data_sprom.c Thu Mar 23 19:29:12 2017 (r315866)
@@ -68,8 +68,7 @@ static const bhnd_sprom_layout *bhnd_nv
static int bhnd_nvram_sprom_ident(
struct bhnd_nvram_io *io,
- const bhnd_sprom_layout **ident,
- struct bhnd_nvram_io **shadow);
+ const bhnd_sprom_layout **ident);
static int bhnd_nvram_sprom_write_var(
bhnd_sprom_opcode_state *state,
@@ -77,6 +76,13 @@ static int bhnd_nvram_sprom_write_var
bhnd_nvram_val *value,
struct bhnd_nvram_io *io);
+static int bhnd_nvram_sprom_read_var(
+ struct bhnd_sprom_opcode_state *state,
+ struct bhnd_sprom_opcode_idx_entry *entry,
+ struct bhnd_nvram_io *io,
+ union bhnd_nvram_sprom_storage *storage,
+ bhnd_nvram_val *val);
+
static int bhnd_nvram_sprom_write_offset(
const struct bhnd_nvram_vardefn *var,
struct bhnd_nvram_io *data,
@@ -153,10 +159,6 @@ bhnd_nvram_sprom_check_magic(struct bhnd
*
* @param io An I/O context mapping the SPROM data to be identified.
* @param[out] ident On success, the identified SPROM layout.
- * @param[out] shadow On success, a correctly sized iobuf instance mapping
- * a copy of the identified SPROM image. The caller is
- * responsible for deallocating this instance via
- * bhnd_nvram_io_free()
*
* @retval 0 success
* @retval non-zero If identifying @p io otherwise fails, a regular unix
@@ -164,77 +166,69 @@ bhnd_nvram_sprom_check_magic(struct bhnd
*/
static int
bhnd_nvram_sprom_ident(struct bhnd_nvram_io *io,
- const bhnd_sprom_layout **ident, struct bhnd_nvram_io **shadow)
+ const bhnd_sprom_layout **ident)
{
- struct bhnd_nvram_io *buf;
- uint8_t crc;
- size_t crc_errors;
- size_t sprom_sz_max;
- int error;
+ uint8_t crc;
+ size_t crc_errors;
+ size_t nbytes;
+ int error;
- /* Find the largest SPROM layout size */
- sprom_sz_max = 0;
- for (size_t i = 0; i < bhnd_sprom_num_layouts; i++) {
- sprom_sz_max = bhnd_nv_ummax(sprom_sz_max,
- bhnd_sprom_layouts[i].size);
- }
-
- /* Allocate backing buffer and initialize CRC state */
- buf = bhnd_nvram_iobuf_empty(0, sprom_sz_max);
crc = BHND_NVRAM_CRC8_INITIAL;
crc_errors = 0;
+ nbytes = 0;
/* We iterate the SPROM layouts smallest to largest, allowing us to
* perform incremental checksum calculation */
for (size_t i = 0; i < bhnd_sprom_num_layouts; i++) {
const bhnd_sprom_layout *layout;
- void *ptr;
- size_t nbytes, nr;
+ u_char buf[512];
+ size_t nread;
uint16_t magic;
uint8_t srev;
bool crc_valid;
bool have_magic;
layout = &bhnd_sprom_layouts[i];
- nbytes = bhnd_nvram_io_getsize(buf);
- if ((layout->flags & SPROM_LAYOUT_MAGIC_NONE)) {
+ have_magic = true;
+ if ((layout->flags & SPROM_LAYOUT_MAGIC_NONE))
have_magic = false;
- } else {
- have_magic = true;
- }
- /* Layout instances must be ordered from smallest to largest by
- * the nvram_map compiler */
+ /*
+ * Read image data and update CRC (errors are reported
+ * after the signature check)
+ *
+ * Layout instances must be ordered from smallest to largest by
+ * the nvram_map compiler, allowing us to incrementally update
+ * our CRC.
+ */
if (nbytes > layout->size)
- BHND_NV_PANIC("SPROM layout is defined out-of-order");
+ BHND_NV_PANIC("SPROM layout defined out-of-order");
- /* Calculate number of additional bytes to be read */
- nr = layout->size - nbytes;
+ nread = layout->size - nbytes;
- /* Adjust the buffer size and fetch a write pointer */
- if ((error = bhnd_nvram_io_setsize(buf, layout->size)))
- goto failed;
+ while (nread > 0) {
+ size_t nr;
- error = bhnd_nvram_io_write_ptr(buf, nbytes, &ptr, nr, NULL);
- if (error)
- goto failed;
+ nr = bhnd_nv_ummin(nread, sizeof(buf));
+
+ if ((error = bhnd_nvram_io_read(io, nbytes, buf, nr)))
+ return (error);
+
+ crc = bhnd_nvram_crc8(buf, nr, crc);
+ crc_valid = (crc == BHND_NVRAM_CRC8_VALID);
+ if (!crc_valid)
+ crc_errors++;
- /* Read image data and update CRC (errors are reported
- * after the signature check) */
- if ((error = bhnd_nvram_io_read(io, nbytes, ptr, nr)))
- goto failed;
-
- crc = bhnd_nvram_crc8(ptr, nr, crc);
- crc_valid = (crc == BHND_NVRAM_CRC8_VALID);
- if (!crc_valid)
- crc_errors++;
+ nread -= nr;
+ nbytes += nr;
+ }
- /* Fetch SPROM revision */
- error = bhnd_nvram_io_read(buf, layout->srev_offset, &srev,
+ /* Read SPROM revision */
+ error = bhnd_nvram_io_read(io, layout->srev_offset, &srev,
sizeof(srev));
if (error)
- goto failed;
+ return (error);
/* Early sromrev 1 devices (specifically some BCM440x enet
* cards) are reported to have been incorrectly programmed
@@ -248,7 +242,7 @@ bhnd_nvram_sprom_ident(struct bhnd_nvram
/* Check the magic value, skipping to the next layout on
* failure. */
- error = bhnd_nvram_sprom_check_magic(buf, layout, &magic);
+ error = bhnd_nvram_sprom_check_magic(io, layout, &magic);
if (error) {
/* If the CRC is was valid, log the mismatch */
if (crc_valid || BHND_NV_VERBOSE) {
@@ -256,8 +250,7 @@ bhnd_nvram_sprom_ident(struct bhnd_nvram
"0x%hx (expected 0x%hx)\n", srev,
magic, layout->magic_value);
- error = ENXIO;
- goto failed;
+ return (ENXIO);
}
continue;
@@ -277,40 +270,93 @@ bhnd_nvram_sprom_ident(struct bhnd_nvram
}
/* Identified */
- *shadow = buf;
*ident = layout;
return (0);
}
- /* No match -- set error and fallthrough */
- error = ENXIO;
+ /* No match */
if (crc_errors > 0 && BHND_NV_VERBOSE) {
BHND_NV_LOG("sprom parsing failed with %zu CRC errors\n",
crc_errors);
}
-failed:
- bhnd_nvram_io_free(buf);
- return (error);
+ return (ENXIO);
}
static int
bhnd_nvram_sprom_probe(struct bhnd_nvram_io *io)
{
const bhnd_sprom_layout *layout;
- struct bhnd_nvram_io *shadow;
int error;
/* Try to parse the input */
- if ((error = bhnd_nvram_sprom_ident(io, &layout, &shadow)))
+ if ((error = bhnd_nvram_sprom_ident(io, &layout)))
return (error);
- /* Clean up the shadow iobuf */
- bhnd_nvram_io_free(shadow);
-
return (BHND_NVRAM_DATA_PROBE_DEFAULT);
}
+static int
+bhnd_nvram_sprom_getvar_direct(struct bhnd_nvram_io *io, const char *name,
+ void *buf, size_t *len, bhnd_nvram_type type)
+{
+ const bhnd_sprom_layout *layout;
+ bhnd_sprom_opcode_state state;
+ const struct bhnd_nvram_vardefn *var;
+ size_t vid;
+ int error;
+
+ /* Look up the variable definition and ID */
+ if ((var = bhnd_nvram_find_vardefn(name)) == NULL)
+ return (ENOENT);
+
+ vid = bhnd_nvram_get_vardefn_id(var);
+
+ /* Identify the SPROM image layout */
+ if ((error = bhnd_nvram_sprom_ident(io, &layout)))
+ return (error);
+
+ /* Initialize SPROM layout interpreter */
+ if ((error = bhnd_sprom_opcode_init(&state, layout))) {
+ BHND_NV_LOG("error initializing opcode state: %d\n", error);
+ return (ENXIO);
+ }
+
+ /* Find SPROM layout entry for the requested variable */
+ while ((error = bhnd_sprom_opcode_next_var(&state)) == 0) {
+ bhnd_sprom_opcode_idx_entry entry;
+ union bhnd_nvram_sprom_storage storage;
+ bhnd_nvram_val val;
+
+ /* Fetch the variable's entry state */
+ if ((error = bhnd_sprom_opcode_init_entry(&state, &entry)))
+ return (error);
+
+ /* Match against expected VID */
+ if (entry.vid != vid)
+ continue;
+
+ /* Decode variable to a new value instance */
+ error = bhnd_nvram_sprom_read_var(&state, &entry, io, &storage,
+ &val);
+ if (error)
+ return (error);
+
+ /* Perform value coercion */
+ error = bhnd_nvram_val_encode(&val, buf, len, type);
+
+ /* Clean up */
+ bhnd_nvram_val_release(&val);
+ return (error);
+ }
+
+ /* Hit EOF without matching the requested variable? */
+ if (error == ENOENT)
+ return (ENOENT);
+
+ /* Some other parse error occured */
+ return (error);
+}
/**
* Return the SPROM layout definition for the given @p sromrev, or NULL if
@@ -365,7 +411,7 @@ bhnd_nvram_sprom_write_var(bhnd_sprom_op
var_base_type = bhnd_nvram_base_type(var->type);
/* Fetch the element count from the SPROM variable layout definition */
- if ((error = bhnd_sprom_opcode_parse_var(state, entry)))
+ if ((error = bhnd_sprom_opcode_eval_var(state, entry)))
return (error);
nelem = state->var.nelem;
@@ -717,7 +763,12 @@ bhnd_nvram_sprom_new(struct bhnd_nvram_d
sp = (struct bhnd_nvram_sprom *)nv;
/* Identify the SPROM input data */
- if ((error = bhnd_nvram_sprom_ident(io, &sp->layout, &sp->data)))
+ if ((error = bhnd_nvram_sprom_ident(io, &sp->layout)))
+ return (error);
+
+ /* Copy SPROM image to our shadow buffer */
+ sp->data = bhnd_nvram_iobuf_copy_range(io, 0, sp->layout->size);
+ if (sp->data == NULL)
goto failed;
/* Initialize SPROM binding eval state */
@@ -989,9 +1040,15 @@ bhnd_nvram_sprom_read_offset(const struc
}
/**
- * Common variable decoding; fetches and decodes variable to @p val,
- * using @p storage for actual data storage.
+ * Read a SPROM variable value from @p io.
*
+ * @param state The SPROM opcode state describing the layout of @p io.
+ * @param entry The variable's SPROM opcode index entry.
+ * @param io The input I/O context.
+ * @param storage Storage to be used with @p val.
+ * @param[out] val Value instance to be initialized with the
+ * parsed variable data.
+ *
* The returned @p val instance will hold a borrowed reference to @p storage,
* and must be copied via bhnd_nvram_val_copy() if it will be referenced beyond
* the lifetime of @p storage.
@@ -1000,13 +1057,12 @@ bhnd_nvram_sprom_read_offset(const struc
* via bhnd_nvram_val_release().
*/
static int
-bhnd_nvram_sprom_getvar_common(struct bhnd_nvram_data *nv, void *cookiep,
+bhnd_nvram_sprom_read_var(struct bhnd_sprom_opcode_state *state,
+ struct bhnd_sprom_opcode_idx_entry *entry, struct bhnd_nvram_io *io,
union bhnd_nvram_sprom_storage *storage, bhnd_nvram_val *val)
{
- struct bhnd_nvram_sprom *sp;
- bhnd_sprom_opcode_idx_entry *entry;
- const struct bhnd_nvram_vardefn *var;
union bhnd_nvram_sprom_storage *inp;
+ const struct bhnd_nvram_vardefn *var;
bhnd_nvram_type var_btype;
uint32_t intv;
size_t ilen, ipos, iwidth;
@@ -1014,14 +1070,9 @@ bhnd_nvram_sprom_getvar_common(struct bh
bool all_bits_set;
int error;
- sp = (struct bhnd_nvram_sprom *)nv;
- entry = cookiep;
-
- BHND_NV_ASSERT(cookiep != NULL, ("NULL variable cookiep"));
-
/* Fetch canonical variable definition */
- var = SPROM_COOKIE_TO_NVRAM_VAR(cookiep);
- BHND_NV_ASSERT(var != NULL, ("invalid cookiep %p", cookiep));
+ var = bhnd_nvram_get_vardefn(entry->vid);
+ BHND_NV_ASSERT(var != NULL, ("invalid entry"));
/*
* Fetch the array length from the SPROM variable definition.
@@ -1030,12 +1081,12 @@ bhnd_nvram_sprom_getvar_common(struct bh
* canonical NVRAM variable definition, but some SPROM layouts may
* define a smaller element count.
*/
- if ((error = bhnd_sprom_opcode_parse_var(&sp->state, entry))) {
+ if ((error = bhnd_sprom_opcode_eval_var(state, entry))) {
BHND_NV_LOG("variable evaluation failed: %d\n", error);
return (error);
}
- nelem = sp->state.var.nelem;
+ nelem = state->var.nelem;
if (nelem > var->nelem) {
BHND_NV_LOG("SPROM array element count %zu cannot be "
"represented by '%s' element count of %hhu\n", nelem,
@@ -1070,7 +1121,7 @@ bhnd_nvram_sprom_getvar_common(struct bh
/*
* Decode the SPROM data, iteratively decoding up to nelem values.
*/
- if ((error = bhnd_sprom_opcode_seek(&sp->state, entry))) {
+ if ((error = bhnd_sprom_opcode_seek(state, entry))) {
BHND_NV_LOG("variable seek failed: %d\n", error);
return (error);
}
@@ -1081,7 +1132,7 @@ bhnd_nvram_sprom_getvar_common(struct bh
all_bits_set = true;
else
all_bits_set = false;
- while ((error = bhnd_sprom_opcode_next_binding(&sp->state)) == 0) {
+ while ((error = bhnd_sprom_opcode_next_binding(state)) == 0) {
bhnd_sprom_opcode_bind *binding;
bhnd_sprom_opcode_var *binding_var;
bhnd_nvram_type intv_type;
@@ -1091,12 +1142,12 @@ bhnd_nvram_sprom_getvar_common(struct bh
void *ptr;
BHND_NV_ASSERT(
- sp->state.var_state >= SPROM_OPCODE_VAR_STATE_OPEN,
+ state->var_state >= SPROM_OPCODE_VAR_STATE_OPEN,
("invalid var state"));
- BHND_NV_ASSERT(sp->state.var.have_bind, ("invalid bind state"));
+ BHND_NV_ASSERT(state->var.have_bind, ("invalid bind state"));
- binding_var = &sp->state.var;
- binding = &sp->state.var.bind;
+ binding_var = &state->var;
+ binding = &state->var.bind;
if (ipos >= nelem) {
BHND_NV_LOG("output skip %u positioned "
@@ -1107,17 +1158,16 @@ bhnd_nvram_sprom_getvar_common(struct bh
/* Calculate input skip bytes for this binding */
skip_in_bytes = binding->skip_in;
- error = bhnd_sprom_opcode_apply_scale(&sp->state,
- &skip_in_bytes);
+ error = bhnd_sprom_opcode_apply_scale(state, &skip_in_bytes);
if (error)
return (error);
/* Bind */
- offset = sp->state.offset;
+ offset = state->offset;
for (size_t i = 0; i < binding->count; i++) {
/* Read the offset value, OR'ing with the current
* value of intv */
- error = bhnd_nvram_sprom_read_offset(var, sp->data,
+ error = bhnd_nvram_sprom_read_offset(var, io,
binding_var->base_type,
offset,
binding_var->mask,
@@ -1209,6 +1259,39 @@ bhnd_nvram_sprom_getvar_common(struct bh
return (error);
}
+
+/**
+ * Common variable decoding; fetches and decodes variable to @p val,
+ * using @p storage for actual data storage.
+ *
+ * The returned @p val instance will hold a borrowed reference to @p storage,
+ * and must be copied via bhnd_nvram_val_copy() if it will be referenced beyond
+ * the lifetime of @p storage.
+ *
+ * The caller is responsible for releasing any allocated value state
+ * via bhnd_nvram_val_release().
+ */
+static int
+bhnd_nvram_sprom_getvar_common(struct bhnd_nvram_data *nv, void *cookiep,
+ union bhnd_nvram_sprom_storage *storage, bhnd_nvram_val *val)
+{
+ struct bhnd_nvram_sprom *sp;
+ bhnd_sprom_opcode_idx_entry *entry;
+ const struct bhnd_nvram_vardefn *var;
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-src-head
mailing list