/*
 * 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 2026 Oxide Computer Company
 */

/*
 * Deal with Micron-specific logs.
 */

#include <err.h>
#include <string.h>
#include <sys/stddef.h>
#include <sys/sysmacros.h>
#include <sys/nvme/micron.h>

#include "nvmeadm.h"

/*
 * Synthetic identifiers for these logs to deal with the changes that we have
 * found in here over time. See micron_vul_ext_smart_getvers() for more.
 */
#define MICRON_GEN_73XX 1
#define MICRON_GEN_74XX 2

#define MICRON_F_SMART(f)       \
        .nf_off = offsetof(micron_vul_ext_smart_t, mes_##f), \
        .nf_len = sizeof (((micron_vul_ext_smart_t *)NULL)->mes_##f)

static const nvmeadm_field_bit_t micron_vul_ext_smart_wpr_bits[] = { {
        .nfb_lowbit = 0, .nfb_hibit = 0,
        .nfb_short = "dramue",
        .nfb_desc = "DRAM Double Bit Error",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "did not occur", "occurred" }
}, {
        .nfb_lowbit = 1, .nfb_hibit = 1,
        .nfb_short = "spare",
        .nfb_desc = "Low Remaining Spare Block Count",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "did not occur", "occurred" }
}, {
        .nfb_lowbit = 2, .nfb_hibit = 2,
        .nfb_short = "cap",
        .nfb_desc = "Power Holdup Capacitor Failure",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "did not occur", "occurred" }
}, {
        .nfb_lowbit = 3, .nfb_hibit = 3,
        .nfb_short = "nvram",
        .nfb_desc = "NVRAM Checksum Failure",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "did not occur", "occurred" }
}, {
        .nfb_lowbit = 4, .nfb_hibit = 4,
        .nfb_short = "daor",
        .nfb_desc = "DRAM Address Out of Range",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "did not occur", "occurred" }
}, {
        .nfb_lowbit = 5, .nfb_hibit = 5,
        .nfb_short = "temp",
        .nfb_desc = "Overtemp Shutdown",
        .nfb_type = NVMEADM_FT_STRMAP,
        .nfb_strs = { "did not occur", "occurred" }
} };

static const nvmeadm_field_t micron_vul_ext_smart_fields[] = { {
        MICRON_F_SMART(gbb),
        .nf_short = "gbb",
        .nf_desc = "Grown Bad Block Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(max_erase),
        .nf_short = "mec",
        .nf_desc = "Per-Block Max Erase Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(power_on),
        .nf_short = "pon",
        .nf_desc = "Power-on",
        .nf_type = NVMEADM_FT_UNIT,
        .nf_addend = { .nfa_unit = "min" }
}, {
        MICRON_F_SMART(wp_reason),
        .nf_short = "wpr",
        .nf_desc = "Write Protect Reason",
        NVMEADM_F_BITS(micron_vul_ext_smart_wpr_bits)
}, {
        MICRON_F_SMART(cap),
        .nf_short = "cap",
        .nf_desc = "Device Capacity",
        .nf_type = NVMEADM_FT_BYTES
}, {
        MICRON_F_SMART(erase_count),
        .nf_short = "tec",
        .nf_desc = "Total Erase Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(use_rate),
        .nf_short = "use",
        .nf_desc = "Lifetime Use Rate",
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(erase_fail),
        .nf_short = "efc",
        .nf_desc = "Erase Fail Count",
        .nf_rev = MICRON_GEN_74XX,
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(uecc),
        .nf_short = "uecc",
        .nf_desc = "Reported Uncorrectable ECC Errors",
        .nf_rev = MICRON_GEN_74XX,
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(prog_fail),
        .nf_short = "pfc",
        .nf_desc = "Program Fail Count",
        .nf_rev = MICRON_GEN_74XX,
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(read_bytes),
        .nf_short = "read",
        .nf_desc = "Total Bytes Read",
        .nf_rev = MICRON_GEN_74XX,
        .nf_type = NVMEADM_FT_BYTES
}, {
        MICRON_F_SMART(write_bytes),
        .nf_short = "write",
        .nf_desc = "Total Bytes Written",
        .nf_rev = MICRON_GEN_74XX,
        .nf_type = NVMEADM_FT_BYTES
}, {
        MICRON_F_SMART(trans_size),
        .nf_short = "tus",
        .nf_desc = "Translation Unit Size",
        .nf_type = NVMEADM_FT_BYTES
}, {
        MICRON_F_SMART(bs_total),
        .nf_short = "tbs",
        .nf_desc = "Total Block Stripe Count for User Data",
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(bs_free),
        .nf_short = "fbs",
        .nf_desc = "Free Block Stripe Count for User Data",
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(bs_cap),
        .nf_short = "bss",
        .nf_desc = "Block Stripe Size",
        .nf_type = NVMEADM_FT_BYTES
}, {
        MICRON_F_SMART(user_erase_min),
        .nf_short = "ubemin",
        .nf_desc = "Minimum User Block Erase Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(user_erase_avg),
        .nf_short = "ubeavg",
        .nf_desc = "Average User Block Erase Count",
        .nf_type = NVMEADM_FT_HEX
}, {
        MICRON_F_SMART(user_erase_max),
        .nf_short = "ubemax",
        .nf_desc = "Maximum User Block Erase Count",
        .nf_type = NVMEADM_FT_HEX
} };

/*
 * The 73xx series and 74xx series have some different entries in these log
 * pages. There is no good way to determine this in the log. Instead we use a
 * crude but reasonable heuristic. The 74xx series added a pair of counters for
 * total bytes read and written. If these are zero, then we know we're on the
 * 73xx assuming it's playing by its reserved rules. We've also seen some cases
 * where the 73xx parts will return all 1s for the reserved fields, so we check
 * that too.
 */
static uint32_t
micron_vul_ext_smart_getvers(const void *data, size_t len)
{
        const uint8_t zero[16] = { 0 };
        uint8_t ones[16];

        if (len < sizeof (micron_vul_ext_smart_t)) {
                errx(-1, "cannot parse revision information, found 0x%zx "
                    "bytes, need at least 0x%zx", len,
                    sizeof (micron_vul_ext_smart_t));
        }

        (void) memset(ones, 0xff, sizeof (ones));
        const micron_vul_ext_smart_t *log = data;
        if (memcmp(zero, log->mes_read_bytes, sizeof (zero)) == 0 &&
            memcmp(zero, log->mes_write_bytes, sizeof (zero)) == 0) {
                return (MICRON_GEN_73XX);
        }

        if (memcmp(ones, log->mes_read_bytes, sizeof (ones)) == 0 &&
            memcmp(ones, log->mes_write_bytes, sizeof (ones)) == 0) {
                return (MICRON_GEN_73XX);
        }

        return (MICRON_GEN_74XX);
}

const nvmeadm_log_field_info_t micron_vul_extsmart_field_info = {
        .nlfi_log = "micron/extsmart",
        .nlfi_fields = micron_vul_ext_smart_fields,
        .nlfi_nfields = ARRAY_SIZE(micron_vul_ext_smart_fields),
        .nlfi_min = sizeof (micron_vul_ext_smart_t),
        .nlfi_getrev = micron_vul_ext_smart_getvers
};