/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 Oxide Computer Company
 */

/*
 * This is the common file or parsing out SPD data of different generations. Our
 * general goal is to create a single nvlist_t that has a few different sections
 * present in it:
 *
 *   o Metadata (e.g. DRAM type, Revision, overlay type, etc.)
 *   o Manufacturing Information
 *   o Common parameters: these are ultimately specific to a DDR type.
 *   o Overlay parameters: these are specific to both the DDR type and the
 *     module type.
 *
 * We try to only fail top-level parsing if we really can't understand anything
 * or don't have enough information. We assume that we'll get relatively
 * complete data. Errors are listed as keys for a given entry and will be
 * skipped otherwise. For an overview of the actual fields and structures, see
 * libjedec.h.
 *
 * Currently we support all of DDR4, DDD5, and LPDDR5/x based SPD information
 * with the exception of some NVDIMM properties.
 */

#include <string.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <ctype.h>
#include <stdarg.h>
#include <errno.h>
#include <stdbool.h>

#include "libjedec_spd.h"

void
spd_nvl_err(spd_info_t *si, const char *key, spd_error_kind_t err,
    const char *fmt, ...)
{
        int ret;
        nvlist_t *nvl;
        char msg[1024];
        va_list ap;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }

        ret = nvlist_add_uint32(nvl, SPD_KEY_ERRS_CODE, err);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                nvlist_free(nvl);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }

        /*
         * We cast this snprintf to void so we can try to get someone something
         * at least in the face of it somehow being too large.
         */
        va_start(ap, fmt);
        (void) vsnprintf(msg, sizeof (msg), fmt, ap);
        va_end(ap);

        ret = nvlist_add_string(nvl, SPD_KEY_ERRS_MSG, msg);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                nvlist_free(nvl);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }

        ret = nvlist_add_nvlist(si->si_errs, key, nvl);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                nvlist_free(nvl);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }

        nvlist_free(nvl);
}

void
spd_nvl_insert_str(spd_info_t *si, const char *key, const char *data)
{
        int ret;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_add_string(si->si_nvl, key, data);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }
}

void
spd_nvl_insert_u32(spd_info_t *si, const char *key, uint32_t data)
{
        int ret;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_add_uint32(si->si_nvl, key, data);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }
}

void
spd_nvl_insert_u64(spd_info_t *si, const char *key, uint64_t data)
{
        int ret;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_add_uint64(si->si_nvl, key, data);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }
}

void
spd_nvl_insert_u8_array(spd_info_t *si, const char *key,
    uint8_t *data, uint_t nent)
{
        int ret;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_add_uint8_array(si->si_nvl, key, data, nent);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }
}

void
spd_nvl_insert_u32_array(spd_info_t *si, const char *key,
    uint32_t *data, uint_t nent)
{
        int ret;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_add_uint32_array(si->si_nvl, key, data, nent);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }
}

void
spd_nvl_insert_u64_array(spd_info_t *si, const char *key,
    uint64_t *data, uint_t nent)
{
        int ret;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_add_uint64_array(si->si_nvl, key, data, nent);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }
}

void
spd_nvl_insert_boolean_array(spd_info_t *si, const char *key,
    boolean_t *data, uint_t nent)
{
        int ret;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_add_boolean_array(si->si_nvl, key, data, nent);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }
}

void
spd_nvl_insert_key(spd_info_t *si, const char *key)
{
        int ret;

        if (si->si_error != LIBJEDEC_SPD_OK)
                return;

        ret = nvlist_add_boolean(si->si_nvl, key);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }
}

void
spd_insert_map(spd_info_t *si, const char *key, uint8_t spd_val,
    const spd_value_map_t *maps, size_t nmaps)
{
        for (size_t i = 0; i < nmaps; i++) {
                if (maps[i].svm_spd != spd_val)
                        continue;
                if (maps[i].svm_skip)
                        return;

                spd_nvl_insert_u32(si, key, maps[i].svm_use);
                return;
        }

        spd_nvl_err(si, key, SPD_ERROR_NO_XLATE, "encountered unknown "
            "value: 0x%x", spd_val);
}

void
spd_insert_map64(spd_info_t *si, const char *key, uint8_t spd_val,
    const spd_value_map64_t *maps, size_t nmaps)
{
        for (size_t i = 0; i < nmaps; i++) {
                if (maps[i].svm_spd != spd_val)
                        continue;
                if (maps[i].svm_skip)
                        return;

                spd_nvl_insert_u64(si, key, maps[i].svm_use);
                return;
        }

        spd_nvl_err(si, key, SPD_ERROR_NO_XLATE, "encountered unknown "
            "value: 0x%x", spd_val);
}

void
spd_insert_str_map(spd_info_t *si, const char *key, uint8_t spd_val,
    const spd_str_map_t *maps, size_t nmaps)
{
        for (size_t i = 0; i < nmaps; i++) {
                if (maps[i].ssm_spd != spd_val)
                        continue;
                if (maps[i].ssm_skip)
                        return;

                spd_nvl_insert_str(si, key, maps[i].ssm_str);
                return;
        }

        spd_nvl_err(si, key, SPD_ERROR_NO_XLATE, "encountered unknown "
            "value: 0x%x", spd_val);
}

/*
 * Map an array in its entirety to a corresponding set of values. If any one
 * value cannot be translated, then we fail the whole item.
 */
void
spd_insert_map_array(spd_info_t *si, const char *key, const uint8_t *raw,
    size_t nraw, const spd_value_map_t *maps, size_t nmaps)
{
        uint32_t *trans;

        trans = calloc(nraw, sizeof (uint32_t));
        if (trans == NULL) {
                si->si_error = LIBJEDEC_SPD_NOMEM;
                return;
        }

        for (size_t i = 0; i < nraw; i++) {
                bool found = false;
                for (size_t map = 0; map < nmaps; map++) {
                        if (maps[map].svm_spd != raw[i])
                                continue;
                        ASSERT3U(maps[map].svm_skip, ==, false);
                        found = true;
                        trans[i] = maps[map].svm_use;
                        break;
                }

                if (!found) {
                        spd_nvl_err(si, key, SPD_ERROR_NO_XLATE, "encountered "
                            "unknown array value: [%zu]=0x%x", i, raw[i]);
                        goto done;
                }
        }

        spd_nvl_insert_u32_array(si, key, trans, nraw);
done:
        free(trans);
}

/*
 * We've been given a value which attempts to fit within a range. This range has
 * an optional upper and lower bound. The value can be transformed in one of
 * three ways which are honored in the following order:
 *
 * 1) If there is a multiple, we apply that to the raw value first.
 * 2) There can be a base value which we then add to any adjusted value.
 * 3) The final value can be treated as an exponent resulting in a bit-shift.
 *
 * After this is done we can check against the minimum and maximum values. A
 * specified min or max of zero is ignored.
 */
void
spd_insert_range(spd_info_t *si, const char *key, uint8_t raw_val,
    const spd_value_range_t *range)
{
        uint32_t min = 0, max = UINT32_MAX;
        uint32_t act = raw_val;

        if (range->svr_mult != 0) {
                act *= range->svr_mult;
        }

        act += range->svr_base;

        if (range->svr_exp) {
                act = 1 << act;
        }

        if (range->svr_max != 0) {
                max = range->svr_max;
        }

        if (range->svr_min != 0) {
                min = range->svr_min;
        } else if (range->svr_base != 0) {
                min = range->svr_base;
        }

        if (act > max || act < min) {
                spd_nvl_err(si, key, SPD_ERROR_NO_XLATE, "found value "
                    "0x%x (raw 0x%x) outside range [0x%x, 0x%x]", act, raw_val,
                    min, max);
        } else {
                spd_nvl_insert_u32(si, key, act);
        }
}

/*
 * Either insert the given flag for a key or OR it in if it already exists.
 */
void
spd_upsert_flag(spd_info_t *si, const char *key, uint32_t flag)
{
        int ret;
        uint32_t val;

        ret = nvlist_lookup_uint32(si->si_nvl, key, &val);
        if (ret != 0) {
                VERIFY3S(ret, ==, ENOENT);
                spd_nvl_insert_u32(si, key, flag);
                return;
        }

        VERIFY0(val & flag);
        val |= flag;
        spd_nvl_insert_u32(si, key, val);
}

void
spd_parse_rev(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        const uint8_t data = si->si_data[off];
        const uint8_t enc = SPD_DDR4_SPD_REV_ENC(data);
        const uint8_t add = SPD_DDR4_SPD_REV_ADD(data);

        spd_nvl_insert_u32(si, SPD_KEY_REV_ENC, enc);
        spd_nvl_insert_u32(si, SPD_KEY_REV_ADD, add);
}

void
spd_parse_jedec_id(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        uint32_t id[2];

        VERIFY3U(len, ==, 2);
        id[0] = SPD_MFG_ID0_CONT(si->si_data[off]);
        id[1] = si->si_data[off + 1];

        spd_nvl_insert_u32_array(si, key, id, ARRAY_SIZE(id));
}

void
spd_parse_jedec_id_str(spd_info_t *si, uint32_t off, uint32_t len,
    const char *key)
{
        uint8_t cont = SPD_MFG_ID0_CONT(si->si_data[off]);
        const char *str;

        VERIFY3U(len, ==, 2);
        str = libjedec_vendor_string(cont, si->si_data[off + 1]);
        if (str != NULL) {
                spd_nvl_insert_str(si, key, str);
        } else {
                spd_nvl_err(si, key, SPD_ERROR_NO_XLATE, "no matching "
                    "libjedec vendor string for 0x%x,0x%x", cont,
                    si->si_data[off + 1]);
        }
}

/*
 * Parse a string that is at most len bytes wide and is padded with spaces. If
 * the string contains an unprintable, then we will not pull this off and set an
 * error for the string's key. 128 bytes should be larger than any ascii string
 * that we encounter as that is the size of most regions in SPD data.
 */
void
spd_parse_string(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        uint32_t nbytes = len;
        char buf[128];

        VERIFY3U(sizeof (buf), >, len);
        for (uint32_t i = 0; i < len; i++) {
                if (si->si_data[off + i] == ' ') {
                        nbytes = i;
                        break;
                }

                if (isascii(si->si_data[off + i]) == 0 ||
                    isprint(si->si_data[off + i]) == 0) {
                        spd_nvl_err(si, key, SPD_ERROR_UNPRINT,
                            "byte %u for key %s (off: 0x%x, val: 0x%x) is not "
                            "printable", i, key, off + 1,
                            si->si_data[off + i]);
                        return;
                }
        }

        if (nbytes == 0) {
                spd_nvl_err(si, key, SPD_ERROR_NO_DATA, "key %s has "
                    "no valid bytes in the string", key);
                return;
        }

        (void) memcpy(buf, &si->si_data[off], nbytes);
        buf[nbytes] = '\0';
        spd_nvl_insert_str(si, key, buf);
}

/*
 * Turn an array of bytes into a hex string. We need to allocate up to two bytes
 * per length that we have. We always zero pad such strings. We statically size
 * our buffer because the largest such string we have right now is a 4-byte
 * serial number. With the 128 byte buffer below, we could deal with a length up
 * to 63 (far beyond what we expect to ever see).
 */
void
spd_parse_hex_string(spd_info_t *si, uint32_t off, uint32_t len,
    const char *key)
{
        char buf[128];
        size_t nwrite = 0;

        VERIFY3U(sizeof (buf), >=, len * 2 + 1);

        for (uint32_t i = 0; i < len; i++) {
                int ret = snprintf(buf + nwrite, sizeof (buf) - nwrite,
                    "%02X", si->si_data[off + i]);
                if (ret < 0) {
                        spd_nvl_err(si, key, SPD_ERROR_INTERNAL,
                            "snprintf failed unexpectedly for key %s: %s",
                            key, strerror(errno));
                        return;
                }

                VERIFY3U(ret, ==, 2);
                nwrite += ret;
        }

        spd_nvl_insert_str(si, key, buf);
}

/*
 * Several SPD keys are explicit BCD major and minor versions in a given nibble.
 * This is most common in DDR5, but otherwise one should probably use
 * spd_parse_hex_string().
 */
void
spd_parse_hex_vers(spd_info_t *si, uint32_t off, uint32_t len,
    const char *key)
{
        const uint8_t data = si->si_data[off];
        const uint8_t maj = bitx8(data, 7, 4);
        const uint8_t min = bitx8(data, 3, 0);
        char buf[128];

        VERIFY3U(len, ==, 1);

        int ret = snprintf(buf, sizeof (buf), "%X.%X", maj, min);
        if (ret < 0) {
                spd_nvl_err(si, key, SPD_ERROR_INTERNAL,
                    "snprintf failed unexpectedly for key %s: %s",
                    key, strerror(errno));
                return;
        }

        spd_nvl_insert_str(si, key, buf);
}

void
spd_parse_raw_u8(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        VERIFY3U(len, ==, 1);
        spd_nvl_insert_u32(si, key, si->si_data[off]);
}

void
spd_parse_u8_array(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        uint8_t *data = (uint8_t *)si->si_data + off;

        spd_nvl_insert_u8_array(si, key, data, len);
}

void
spd_parse_dram_step(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        VERIFY3U(len, ==, 1);

        if (si->si_data[off] == SPD_DRAM_STEP_NOINFO)
                return;

        spd_parse_hex_string(si, off, len, key);
}

/*
 * Height and thickness have the same meaning across DDR3-DDR5.
 */
static const spd_value_range_t spd_height_range = {
        .svr_base = SPD_DDR5_COM_HEIGHT_BASE
};

static const spd_value_range_t spd_thick_range = {
        .svr_base = SPD_DDR5_COM_THICK_BASE
};

void
spd_parse_height(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        const uint8_t data = si->si_data[off];
        const uint8_t height = SPD_DDR5_COM_HEIGHT_MM(data);
        spd_insert_range(si, key, height, &spd_height_range);
}

void
spd_parse_thickness(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        const uint8_t data = si->si_data[off];
        const uint8_t front = SPD_DDR5_COM_THICK_FRONT(data);
        const uint8_t back = SPD_DDR5_COM_THICK_BACK(data);

        spd_insert_range(si, SPD_KEY_MOD_FRONT_THICK, front, &spd_thick_range);
        spd_insert_range(si, SPD_KEY_MOD_BACK_THICK, back, &spd_thick_range);
}

/*
 * Common timestamp calculation logic for DDR3-4, LPDDR3-5 that assumes 1 ps FT
 * and 125ps MTB. The MTB may either be an 8-bit, 12-bit, or 16-bit value. The
 * FTB value is actually a signed two's complement value that we use to adjust
 * things. We need to check for two illegal values:
 *
 * 1. That the value as a whole after adjustment is non-zero.
 * 2. That the fine adjustment does not cause us to underflow (i.e. unit values
 *    for the MTB of 1 and the FTB of -126).
 */
void
spd_parse_ddr_time(spd_info_t *si, const char *key, uint8_t upper_mtb,
    uint8_t mtb, uint8_t ftb)
{
        uint64_t ps = ((upper_mtb << 8) | mtb) * SPD_DDR4_MTB_PS;
        int8_t adj = (int8_t)ftb * SPD_DDR4_FTB_PS;

        if (ps == 125 && adj <= -125) {
                spd_nvl_err(si, key, SPD_ERROR_BAD_DATA,
                    "MTB (%" PRIu64 "ps) and FTB (%dps) would cause underflow",
                    ps, adj);
                return;
        }

        ps += adj;
        if (ps == 0) {
                spd_nvl_err(si, key, SPD_ERROR_NO_XLATE,
                    "encountered unexpected zero time value");
                return;
        }
        spd_nvl_insert_u64(si, key, ps);
}

/*
 * Combine two values into a picosecond value that is split between the MTB and
 * FTB. The MTB and FTB are split amongst a large number of bytes and are not
 * contiguous. The MTB is at data[off], and the FTB is at data[off + len - 1].
 *
 * This is shared by LPDDR3-5 which all use the same time base parameters. DDR3
 * also uses it for a number of items based on our assumptions.
 */
void
spd_parse_mtb_ftb_time_pair(spd_info_t *si, uint32_t off, uint32_t len,
    const char *key)
{
        const uint8_t mtb = si->si_data[off];
        const uint8_t ftb = si->si_data[off + len - 1];

        return (spd_parse_ddr_time(si, key, 0, mtb, ftb));
}

/*
 * Parse a pair of values where the MTB is split across two uint8_t's. The LSB
 * is in off and the MSB is in off+1.
 */
void
spd_parse_mtb_pair(spd_info_t *si, uint32_t off, uint32_t len,
    const char *key)
{
        ASSERT3U(len, ==, 2);
        return (spd_parse_ddr_time(si, key, si->si_data[off + 1],
            si->si_data[off], 0));
}

static const spd_str_map_t spd_ddr_design_map0[32] = {
        { 0, "A", false },
        { 1, "B", false },
        { 2, "C", false },
        { 3, "D", false },
        { 4, "E", false },
        { 5, "F", false },
        { 6, "G", false },
        { 7, "H", false },
        { 8, "J", false },
        { 9, "K", false },
        { 10, "L", false },
        { 11, "M", false },
        { 12, "N", false },
        { 13, "P", false },
        { 14, "R", false },
        { 15, "T", false },
        { 16, "U", false },
        { 17, "V", false },
        { 18, "W", false },
        { 19, "Y", false },
        { 20, "AA", false },
        { 21, "AB", false },
        { 22, "AC", false },
        { 23, "AD", false },
        { 24, "AE", false },
        { 25, "AF", false },
        { 26, "AG", false },
        { 27, "AH", false },
        { 28, "AJ", false },
        { 29, "AK", false },
        { 30, "AL", false },
        { 31, "ZZ", false }
};

static const spd_str_map_t spd_ddr_design_map1[32] = {
        { 0, "AM", false },
        { 1, "AN", false },
        { 2, "AP", false },
        { 3, "AR", false },
        { 4, "AT", false },
        { 5, "AU", false },
        { 6, "AV", false },
        { 7, "AW", false },
        { 8, "AY", false },
        { 9, "BA", false },
        { 10, "BB", false },
        { 11, "BC", false },
        { 12, "BD", false },
        { 13, "BE", false },
        { 14, "BF", false },
        { 15, "BG", false },
        { 16, "BH", false },
        { 17, "BJ", false },
        { 18, "BK", false },
        { 19, "BL", false },
        { 20, "BM", false },
        { 21, "BN", false },
        { 22, "BP", false },
        { 23, "BR", false },
        { 24, "BT", false },
        { 25, "BU", false },
        { 26, "BV", false },
        { 27, "BW", false },
        { 28, "BY", false },
        { 29, "CA", false },
        { 30, "CB", false },
        { 31, "ZZ", false }
};

/*
 * In DDR3/4 and LPDDR3-5 the design information contains both a reference raw
 * card and a revision of the card. The card revision is split between two
 * bytes, the design and the height field. This is common logic that'll check
 * both. We use the DDR4 constants for the fields, but they are the same across
 * all versions.
 */
void
spd_parse_design(spd_info_t *si, uint32_t design, uint32_t height)
{
        const uint8_t data = si->si_data[design];
        const uint8_t rev = SPD_DDR4_RDIMM_REF_REV(data);
        const uint8_t card = SPD_DDR4_RDIMM_REF_CARD(data);

        if (SPD_DDR4_RDIMM_REF_EXT(data) != 0) {
                spd_insert_str_map(si, SPD_KEY_MOD_REF_DESIGN, card,
                    spd_ddr_design_map1, ARRAY_SIZE(spd_ddr_design_map1));
        } else {
                spd_insert_str_map(si, SPD_KEY_MOD_REF_DESIGN, card,
                    spd_ddr_design_map0, ARRAY_SIZE(spd_ddr_design_map0));
        }

        /*
         * The design rev is split between here and the height field. If we
         * have the value of three, then we must also add in the height's value
         * to this.
         */
        if (rev == SPD_DDR4_RDIMM_REV_USE_HEIGHT) {
                const uint8_t hdata = si->si_data[height];
                const uint8_t hrev = SPD_DDR4_RDIMM_HEIGHT_REV(hdata);
                spd_nvl_insert_u32(si, SPD_KEY_MOD_DESIGN_REV, rev + hrev);
        } else {
                spd_nvl_insert_u32(si, SPD_KEY_MOD_DESIGN_REV, rev);
        }
}

/*
 * Calculate the DRAM CRC16. The crc calculation covers [ off, off + len ). The
 * expected CRC is in expect. The JEDEC specs describe the algorithm (e.g. 21-C
 * Annex L, 8.1.53).
 */
void
spd_parse_crc_expect(spd_info_t *si, uint32_t off, uint32_t len,
    uint16_t expect, const char *key)
{
        uint32_t crc = 0;

        for (uint32_t i = 0; i < len; i++) {
                crc = crc ^ (uint32_t)si->si_data[off + i] << 8;
                for (uint32_t c = 0; c < 8; c++) {
                        if (crc & 0x8000) {
                                crc = crc << 1 ^ 0x1021;
                        } else {
                                crc = crc << 1;
                        }
                }
        }

        crc &= 0xffff;
        if (crc == expect) {
                spd_nvl_insert_u32(si, key, crc);
        } else {
                spd_nvl_err(si, key, SPD_ERROR_BAD_DATA, "crc mismatch: "
                    "expected 0x%x, found 0x%x", expect, crc);
        }
}

/*
 * Calculate the DRAM CRC16. The crc ranges over [ off, off + len - 2). The crc
 * lsb is at off + len - 2, and the msb is at off + len - 1.
 */
void
spd_parse_crc(spd_info_t *si, uint32_t off, uint32_t len, const char *key)
{
        const uint16_t expect = si->si_data[off + len - 2] |
            (si->si_data[off + len - 1] << 8);

        spd_parse_crc_expect(si, off, len - 2, expect, key);
}

void
spd_parse(spd_info_t *sip, const spd_parse_t *parse, size_t nparse)
{
        for (size_t i = 0; i < nparse; i++) {
                uint32_t len;

                if (parse[i].sp_len != 0) {
                        len = parse[i].sp_len;
                } else {
                        len = 1;
                }

                if (len + parse[i].sp_off >= sip->si_nbytes) {
                        if ((sip->si_flags & SPD_INFO_F_INCOMPLETE) != 0)
                                continue;
                        sip->si_flags |= SPD_INFO_F_INCOMPLETE;
                        ASSERT3U(parse[i].sp_off, <, UINT32_MAX);
                        spd_nvl_insert_u32(sip, SPD_KEY_INCOMPLETE,
                            (uint32_t)parse[i].sp_off);
                } else {
                        parse[i].sp_parse(sip, parse[i].sp_off, len,
                            parse[i].sp_key);
                }

                if (sip->si_error != LIBJEDEC_SPD_OK) {
                        return;
                }
        }
}

static spd_error_t
spd_init_info(spd_info_t *sip)
{
        int ret;

        if ((ret = nvlist_alloc(&sip->si_nvl, NV_UNIQUE_NAME, 0)) != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                return (LIBJEDEC_SPD_NOMEM);
        }

        if ((ret = nvlist_alloc(&sip->si_errs, NV_UNIQUE_NAME, 0)) != 0) {
                VERIFY3S(ret, ==, ENOMEM);
                return (LIBJEDEC_SPD_NOMEM);
        }

        return (LIBJEDEC_SPD_OK);
}

static void
spd_fini_info(spd_info_t *sip)
{
        nvlist_free(sip->si_nvl);
        nvlist_free(sip->si_errs);
}

nvlist_t *
libjedec_spd(const uint8_t *buf, size_t nbytes, spd_error_t *err)
{
        int ret;
        spd_error_t set;
        spd_info_t si;

        if (err == NULL) {
                err = &set;
        }

        (void) memset(&si, 0, sizeof (spd_info_t));
        si.si_data = buf;
        si.si_nbytes = nbytes;

        *err = spd_init_info(&si);
        if (si.si_error != LIBJEDEC_SPD_OK) {
                goto fatal;
        }

        /*
         * To begin parsing the SPD, we must first look at byte 2, which appears
         * to almost always be the Key Byte / Host Bus Command Protocol Type
         * which then tells us how the rest of the data is formatted.
         */
        if (si.si_nbytes <= SPD_DRAM_TYPE) {
                *err = LIBJEDEC_SPD_TOOSHORT;
                goto fatal;
        }

        si.si_error = LIBJEDEC_SPD_OK;
        si.si_dram = buf[SPD_DRAM_TYPE];
        switch (si.si_dram) {
        case SPD_DT_DDR3_SDRAM:
                spd_parse_ddr3(&si);
                break;
        case SPD_DT_DDR4_SDRAM:
                spd_parse_ddr4(&si);
                break;
        case SPD_DT_LPDDR3_SDRAM:
        case SPD_DT_LPDDR4_SDRAM:
        case SPD_DT_LPDDR4X_SDRAM:
                spd_parse_lp4(&si);
                break;
        case SPD_DT_DDR5_SDRAM:
                spd_parse_ddr5(&si);
                break;
        case SPD_DT_LPDDR5_SDRAM:
        case SPD_DT_LPDDR5X_SDRAM:
                spd_parse_lp5(&si);
                break;
        default:
                *err = LIBJEDEC_SPD_UNSUP_TYPE;
                goto fatal;
        }

        /*
         * We got everything, at this point add the error nvlist here.
         */
        if (si.si_error == LIBJEDEC_SPD_OK) {
                if (!nvlist_empty(si.si_errs) &&
                    (ret = nvlist_add_nvlist(si.si_nvl, "errors",
                    si.si_errs)) != 0) {
                        VERIFY3S(ret, ==, ENOMEM);
                        *err = LIBJEDEC_SPD_NOMEM;
                        goto fatal;
                }
                nvlist_free(si.si_errs);
                return (si.si_nvl);
        }

        *err = si.si_error;
fatal:
        spd_fini_info(&si);
        return (NULL);
}