/*      $NetBSD: apei.c,v 1.9 2024/10/27 21:28:54 riastradh Exp $       */

/*-
 * Copyright (c) 2024 The NetBSD Foundation, Inc.
 * 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.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 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 DAMAGE.
 */

/*
 * APEI: ACPI Platform Error Interface
 *
 * https://uefi.org/specs/ACPI/6.5/18_Platform_Error_Interfaces.html
 *
 * XXX dtrace probes
 *
 * XXX call _OSC appropriately to announce to the platform that we, the
 * OSPM, support APEI
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: apei.c,v 1.9 2024/10/27 21:28:54 riastradh Exp $");

#include <sys/param.h>
#include <sys/types.h>

#include <sys/atomic.h>
#include <sys/endian.h>
#include <sys/device.h>
#include <sys/module.h>
#include <sys/sysctl.h>
#include <sys/uuid.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>
#include <dev/acpi/apei_bertvar.h>
#include <dev/acpi/apei_cper.h>
#include <dev/acpi/apei_einjvar.h>
#include <dev/acpi/apei_erstvar.h>
#include <dev/acpi/apei_hestvar.h>
#include <dev/acpi/apei_interp.h>
#include <dev/acpi/apeivar.h>
#include <dev/pci/pcireg.h>

#define _COMPONENT      ACPI_RESOURCE_COMPONENT
ACPI_MODULE_NAME        ("apei")

static int apei_match(device_t, cfdata_t, void *);
static void apei_attach(device_t, device_t, void *);
static int apei_detach(device_t, int);

static void apei_get_tables(struct apei_tab *);
static void apei_put_tables(struct apei_tab *);

static void apei_identify(struct apei_softc *, const char *,
    const ACPI_TABLE_HEADER *);

CFATTACH_DECL_NEW(apei, sizeof(struct apei_softc),
    apei_match, apei_attach, apei_detach, NULL);

static int
apei_match(device_t parent, cfdata_t match, void *aux)
{
        struct apei_tab tab;
        int prio = 0;

        /*
         * If we have any of the APEI tables, match.
         */
        apei_get_tables(&tab);
        if (tab.bert || tab.einj || tab.erst || tab.hest)
                prio = 1;
        apei_put_tables(&tab);

        return prio;
}

static void
apei_attach(device_t parent, device_t self, void *aux)
{
        struct apei_softc *sc = device_private(self);
        const struct sysctlnode *sysctl_hw_acpi;
        int error;

        aprint_naive("\n");
        aprint_normal(": ACPI Platform Error Interface\n");

        pmf_device_register(self, NULL, NULL);

        sc->sc_dev = self;
        apei_get_tables(&sc->sc_tab);

        /*
         * Get the sysctl hw.acpi node.  This should already be created
         * but I don't see an easy way to get at it.  If this fails,
         * something is seriously wrong, so let's stop here.
         */
        error = sysctl_createv(&sc->sc_sysctllog, 0,
            NULL, &sysctl_hw_acpi, 0,
            CTLTYPE_NODE, "acpi", NULL, NULL, 0, NULL, 0,
            CTL_HW, CTL_CREATE, CTL_EOL);
        if (error) {
                aprint_error_dev(sc->sc_dev,
                    "failed to create sysctl hw.acpi: %d\n", error);
                return;
        }

        /*
         * Create sysctl hw.acpi.apei.
         */
        error = sysctl_createv(&sc->sc_sysctllog, 0,
            &sysctl_hw_acpi, &sc->sc_sysctlroot, 0,
            CTLTYPE_NODE, "apei",
            SYSCTL_DESCR("ACPI Platform Error Interface"),
            NULL, 0, NULL, 0,
            CTL_CREATE, CTL_EOL);
        if (error) {
                aprint_error_dev(sc->sc_dev,
                    "failed to create sysctl hw.acpi.apei: %d\n", error);
                return;
        }

        /*
         * Set up BERT, EINJ, ERST, and HEST.
         */
        if (sc->sc_tab.bert) {
                apei_identify(sc, "BERT", &sc->sc_tab.bert->Header);
                apei_bert_attach(sc);
        }
        if (sc->sc_tab.einj) {
                apei_identify(sc, "EINJ", &sc->sc_tab.einj->Header);
                apei_einj_attach(sc);
        }
        if (sc->sc_tab.erst) {
                apei_identify(sc, "ERST", &sc->sc_tab.erst->Header);
                apei_erst_attach(sc);
        }
        if (sc->sc_tab.hest) {
                apei_identify(sc, "HEST", &sc->sc_tab.hest->Header);
                apei_hest_attach(sc);
        }
}

static int
apei_detach(device_t self, int flags)
{
        struct apei_softc *sc = device_private(self);
        int error;

        /*
         * Detach children.  We don't currently have any but this is
         * harmless without children and mandatory if we ever sprouted
         * them, so let's just leave it here for good measure.
         *
         * After this point, we are committed to detaching; failure is
         * forbidden.
         */
        error = config_detach_children(self, flags);
        if (error)
                return error;

        /*
         * Tear down all the sysctl nodes first, before the software
         * state backing them goes away.
         */
        sysctl_teardown(&sc->sc_sysctllog);
        sc->sc_sysctlroot = NULL;

        /*
         * Detach the software state for the APEI tables.
         */
        if (sc->sc_tab.hest)
                apei_hest_detach(sc);
        if (sc->sc_tab.erst)
                apei_erst_detach(sc);
        if (sc->sc_tab.einj)
                apei_einj_detach(sc);
        if (sc->sc_tab.bert)
                apei_bert_detach(sc);

        /*
         * Release the APEI tables and we're done.
         */
        apei_put_tables(&sc->sc_tab);
        pmf_device_deregister(self);
        return 0;
}

/*
 * apei_get_tables(tab)
 *
 *      Get references to whichever APEI-related tables -- BERT, EINJ,
 *      ERST, HEST -- are available in the system.
 */
static void
apei_get_tables(struct apei_tab *tab)
{
        ACPI_STATUS rv;

        /*
         * Probe the BERT -- Boot Error Record Table.
         */
        rv = AcpiGetTable(ACPI_SIG_BERT, 0, (ACPI_TABLE_HEADER **)&tab->bert);
        if (ACPI_FAILURE(rv))
                tab->bert = NULL;

        /*
         * Probe the EINJ -- Error Injection Table.
         */
        rv = AcpiGetTable(ACPI_SIG_EINJ, 0, (ACPI_TABLE_HEADER **)&tab->einj);
        if (ACPI_FAILURE(rv))
                tab->einj = NULL;

        /*
         * Probe the ERST -- Error Record Serialization Table.
         */
        rv = AcpiGetTable(ACPI_SIG_ERST, 0, (ACPI_TABLE_HEADER **)&tab->erst);
        if (ACPI_FAILURE(rv))
                tab->erst = NULL;

        /*
         * Probe the HEST -- Hardware Error Source Table.
         */
        rv = AcpiGetTable(ACPI_SIG_HEST, 0, (ACPI_TABLE_HEADER **)&tab->hest);
        if (ACPI_FAILURE(rv))
                tab->hest = NULL;
}

/*
 * apei_put_tables(tab)
 *
 *      Release the tables acquired by apei_get_tables.
 */
static void
apei_put_tables(struct apei_tab *tab)
{

        if (tab->bert != NULL) {
                AcpiPutTable(&tab->bert->Header);
                tab->bert = NULL;
        }
        if (tab->einj != NULL) {
                AcpiPutTable(&tab->einj->Header);
                tab->einj = NULL;
        }
        if (tab->erst != NULL) {
                AcpiPutTable(&tab->erst->Header);
                tab->erst = NULL;
        }
        if (tab->hest != NULL) {
                AcpiPutTable(&tab->hest->Header);
                tab->hest = NULL;
        }
}

/*
 * apei_identify(sc, name, header)
 *
 *      Identify the APEI-related table header for dmesg.
 */
static void
apei_identify(struct apei_softc *sc, const char *name,
    const ACPI_TABLE_HEADER *h)
{

        aprint_normal_dev(sc->sc_dev, "%s:"
            " OemId <%6.6s,%8.8s,%08x>"
            " AslId <%4.4s,%08x>\n",
            name,
            h->OemId, h->OemTableId, h->OemRevision,
            h->AslCompilerId, h->AslCompilerRevision);
}

/*
 * apei_cper_guid_dec(buf, uuid)
 *
 *      Decode a Common Platform Error Record UUID/GUID from an ACPI
 *      table at buf into a sys/uuid.h struct uuid.
 */
static void
apei_cper_guid_dec(const uint8_t buf[static 16], struct uuid *uuid)
{

        uuid_dec_le(buf, uuid);
}

/*
 * apei_format_guid(uuid, s)
 *
 *      Format a UUID as a string.  This uses C initializer notation,
 *      not UUID notation, in order to match the text in the UEFI
 *      specification.
 */
static void
apei_format_guid(const struct uuid *uuid, char guidstr[static 69])
{

        snprintf(guidstr, 69, "{0x%08x,0x%04x,0x%04x,"
            "{0x%02x,%02x,"
            "0x%02x,0x%02x,0x%02x,0x%02x,0x%02x,0x%02x}}",
            uuid->time_low, uuid->time_mid, uuid->time_hi_and_version,
            uuid->clock_seq_hi_and_reserved, uuid->clock_seq_low,
            uuid->node[0], uuid->node[1], uuid->node[2],
            uuid->node[3], uuid->node[4], uuid->node[5]);
}

/*
 * https://uefi.org/specs/UEFI/2.10/Apx_N_Common_Platform_Error_Record.html#memory-error-section
 */

static const char *const cper_memory_error_type[] = {
#define F(LN, SN, V)    [LN] = #SN,
        CPER_MEMORY_ERROR_TYPES(F)
#undef  F
};

/*
 * https://uefi.org/specs/ACPI/6.5/18_Platform_Error_Interfaces.html#generic-error-status-block
 *
 * The acpica names ACPI_HEST_GEN_ERROR_* appear to coincide with this
 * but are designated as being intended for Generic Error Data Entries
 * rather than Generic Error Status Blocks.
 */
static const char *const apei_gesb_severity[] = {
        [0] = "recoverable",
        [1] = "fatal",
        [2] = "corrected",
        [3] = "none",
};

/*
 * https://uefi.org/specs/ACPI/6.5/18_Platform_Error_Interfaces.html#generic-error-data-entry
 */
static const char *const apei_gede_severity[] = {
        [ACPI_HEST_GEN_ERROR_RECOVERABLE] = "recoverable",
        [ACPI_HEST_GEN_ERROR_FATAL] = "fatal",
        [ACPI_HEST_GEN_ERROR_CORRECTED] = "corrected",
        [ACPI_HEST_GEN_ERROR_NONE] = "none",
};

/*
 * N.2.5. Memory Error Section
 *
 * https://uefi.org/specs/UEFI/2.10/Apx_N_Common_Platform_Error_Record.html#memory-error-section
 */
static const struct uuid CPER_MEMORY_ERROR_SECTION =
    {0xa5bc1114,0x6f64,0x4ede,0xb8,0x63,{0x3e,0x83,0xed,0x7c,0x83,0xb1}};

static void
apei_cper_memory_error_report(struct apei_softc *sc, const void *buf,
    size_t len, const char *ctx, bool ratelimitok)
{
        const struct cper_memory_error *ME = buf;
        char bitbuf[1024];

        /*
         * If we've hit the rate limit, skip printing the error.
         */
        if (!ratelimitok)
                goto out;

        snprintb(bitbuf, sizeof(bitbuf),
            CPER_MEMORY_ERROR_VALIDATION_BITS_FMT, ME->ValidationBits);
        aprint_debug_dev(sc->sc_dev, "%s: ValidationBits=%s\n", ctx, bitbuf);
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_ERROR_STATUS) {
                /*
                 * https://uefi.org/specs/UEFI/2.10/Apx_N_Common_Platform_Error_Record.html#error-status
                 */
                /* XXX define this format somewhere */
                snprintb(bitbuf, sizeof(bitbuf), "\177\020"
                    "f\010\010" "ErrorType\0"
                        "=\001"         "ERR_INTERNAL\0"
                        "=\004"         "ERR_MEM\0"
                        "=\005"         "ERR_TLB\0"
                        "=\006"         "ERR_CACHE\0"
                        "=\007"         "ERR_FUNCTION\0"
                        "=\010"         "ERR_SELFTEST\0"
                        "=\011"         "ERR_FLOW\0"
                        "=\020"         "ERR_BUS\0"
                        "=\021"         "ERR_MAP\0"
                        "=\022"         "ERR_IMPROPER\0"
                        "=\023"         "ERR_UNIMPL\0"
                        "=\024"         "ERR_LOL\0"
                        "=\025"         "ERR_RESPONSE\0"
                        "=\026"         "ERR_PARITY\0"
                        "=\027"         "ERR_PROTOCOL\0"
                        "=\030"         "ERR_ERROR\0"
                        "=\031"         "ERR_TIMEOUT\0"
                        "=\032"         "ERR_POISONED\0"
                    "b\020"     "AddressError\0"
                    "b\021"     "ControlError\0"
                    "b\022"     "DataError\0"
                    "b\023"     "ResponderDetected\0"
                    "b\024"     "RequesterDetected\0"
                    "b\025"     "FirstError\0"
                    "b\026"     "Overflow\0"
                    "\0", ME->ErrorStatus);
                device_printf(sc->sc_dev, "%s: ErrorStatus=%s\n", ctx, bitbuf);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_PHYSICAL_ADDRESS) {
                device_printf(sc->sc_dev, "%s: PhysicalAddress=0x%"PRIx64"\n",
                    ctx, ME->PhysicalAddress);
        }
        if (ME->ValidationBits &
            CPER_MEMORY_ERROR_VALID_PHYSICAL_ADDRESS_MASK) {
                device_printf(sc->sc_dev, "%s: PhysicalAddressMask=0x%"PRIx64
                    "\n", ctx, ME->PhysicalAddressMask);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_NODE) {
                device_printf(sc->sc_dev, "%s: Node=0x%"PRIx16"\n", ctx,
                    ME->Node);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_CARD) {
                device_printf(sc->sc_dev, "%s: Card=0x%"PRIx16"\n", ctx,
                    ME->Card);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_MODULE) {
                device_printf(sc->sc_dev, "%s: Module=0x%"PRIx16"\n", ctx,
                    ME->Module);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_BANK) {
                device_printf(sc->sc_dev, "%s: Bank=0x%"PRIx16"\n", ctx,
                    ME->Bank);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_DEVICE) {
                device_printf(sc->sc_dev, "%s: Device=0x%"PRIx16"\n", ctx,
                    ME->Device);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_ROW) {
                device_printf(sc->sc_dev, "%s: Row=0x%"PRIx16"\n", ctx,
                    ME->Row);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_COLUMN) {
                device_printf(sc->sc_dev, "%s: Column=0x%"PRIx16"\n", ctx,
                    ME->Column);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_BIT_POSITION) {
                device_printf(sc->sc_dev, "%s: BitPosition=0x%"PRIx16"\n",
                    ctx, ME->BitPosition);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_REQUESTOR_ID) {
                device_printf(sc->sc_dev, "%s: RequestorId=0x%"PRIx64"\n",
                    ctx, ME->RequestorId);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_RESPONDER_ID) {
                device_printf(sc->sc_dev, "%s: ResponderId=0x%"PRIx64"\n",
                    ctx, ME->ResponderId);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_TARGET_ID) {
                device_printf(sc->sc_dev, "%s: TargetId=0x%"PRIx64"\n",
                    ctx, ME->TargetId);
        }
        if (ME->ValidationBits & CPER_MEMORY_ERROR_VALID_MEMORY_ERROR_TYPE) {
                const uint8_t t = ME->MemoryErrorType;
                const char *n = t < __arraycount(cper_memory_error_type)
                    ? cper_memory_error_type[t] : NULL;

                if (n) {
                        device_printf(sc->sc_dev, "%s: MemoryErrorType=%d"
                            " (%s)\n", ctx, t, n);
                } else {
                        device_printf(sc->sc_dev, "%s: MemoryErrorType=%d\n",
                            ctx, t);
                }
        }

out:    /*
         * XXX pass this through to uvm(9) or userland for decisions
         * like page retirement
         */
        return;
}

/*
 * N.2.7. PCI Express Error Section
 *
 * https://uefi.org/specs/UEFI/2.10/Apx_N_Common_Platform_Error_Record.html#pci-express-error-section
 */
static const struct uuid CPER_PCIE_ERROR_SECTION =
    {0xd995e954,0xbbc1,0x430f,0xad,0x91,{0xb4,0x4d,0xcb,0x3c,0x6f,0x35}};

static const char *const cper_pcie_error_port_type[] = {
#define F(LN, SN, V)    [LN] = #SN,
        CPER_PCIE_ERROR_PORT_TYPES(F)
#undef  F
};

static void
apei_cper_pcie_error_report(struct apei_softc *sc, const void *buf, size_t len,
    const char *ctx, bool ratelimitok)
{
        const struct cper_pcie_error *PE = buf;
        char bitbuf[1024];

        /*
         * If we've hit the rate limit, skip printing the error.
         */
        if (!ratelimitok)
                goto out;

        snprintb(bitbuf, sizeof(bitbuf),
            CPER_PCIE_ERROR_VALIDATION_BITS_FMT, PE->ValidationBits);
        aprint_debug_dev(sc->sc_dev, "%s: ValidationBits=%s\n", ctx, bitbuf);
        if (PE->ValidationBits & CPER_PCIE_ERROR_VALID_PORT_TYPE) {
                const uint32_t t = PE->PortType;
                const char *n = t < __arraycount(cper_pcie_error_port_type)
                    ? cper_pcie_error_port_type[t] : NULL;

                if (n) {
                        device_printf(sc->sc_dev, "%s: PortType=%"PRIu32
                            " (%s)\n", ctx, t, n);
                } else {
                        device_printf(sc->sc_dev, "%s: PortType=%"PRIu32"\n",
                            ctx, t);
                }
        }
        if (PE->ValidationBits & CPER_PCIE_ERROR_VALID_VERSION) {
                /* XXX BCD */
                device_printf(sc->sc_dev, "%s: Version=0x08%"PRIx32"\n",
                    ctx, PE->Version);
        }
        if (PE->ValidationBits & CPER_PCIE_ERROR_VALID_COMMAND_STATUS) {
                /* XXX move me to pcireg.h */
                snprintb(bitbuf, sizeof(bitbuf), "\177\020"
                        /* command */
                    "b\000"     "IO_ENABLE\0"
                    "b\001"     "MEM_ENABLE\0"
                    "b\002"     "MASTER_ENABLE\0"
                    "b\003"     "SPECIAL_ENABLE\0"
                    "b\004"     "INVALIDATE_ENABLE\0"
                    "b\005"     "PALETTE_ENABLE\0"
                    "b\006"     "PARITY_ENABLE\0"
                    "b\007"     "STEPPING_ENABLE\0"
                    "b\010"     "SERR_ENABLE\0"
                    "b\011"     "BACKTOBACK_ENABLE\0"
                    "b\012"     "INTERRUPT_DISABLE\0"
                        /* status */
                    "b\023"     "INT_STATUS\0"
                    "b\024"     "CAPLIST_SUPPORT\0"
                    "b\025"     "66MHZ_SUPPORT\0"
                    "b\026"     "UDF_SUPPORT\0"
                    "b\027"     "BACKTOBACK_SUPPORT\0"
                    "b\030"     "PARITY_ERROR\0"
                    "f\031\002" "DEVSEL\0"
                        "=\000"         "FAST\0"
                        "=\001"         "MEDIUM\0"
                        "=\002"         "SLOW\0"
                    "b\033"     "TARGET_TARGET_ABORT\0"
                    "b\034"     "MASTER_TARGET_ABORT\0"
                    "b\035"     "MASTER_ABORT\0"
                    "b\036"     "SPECIAL_ERROR\0"
                    "b\037"     "PARITY_DETECT\0"
                    "\0", PE->CommandStatus);
                device_printf(sc->sc_dev, "%s: CommandStatus=%s\n",
                    ctx, bitbuf);
        }
        if (PE->ValidationBits & CPER_PCIE_ERROR_VALID_DEVICE_ID) {
                device_printf(sc->sc_dev, "%s: DeviceID:"
                    " VendorID=0x%04"PRIx16
                    " DeviceID=0x%04"PRIx16
                    " ClassCode=0x%06"PRIx32
                    " Function=%"PRIu8
                    " Device=%"PRIu8
                    " Segment=%"PRIu16
                    " Bus=%"PRIu8
                    " SecondaryBus=%"PRIu8
                    " Slot=0x%04"PRIx16
                    " Reserved0=0x%02"PRIx8
                    "\n",
                    ctx,
                    le16dec(PE->DeviceID.VendorID),
                    le16dec(PE->DeviceID.DeviceID),
                    (PE->DeviceID.ClassCode[0] |        /* le24dec */
                        ((uint32_t)PE->DeviceID.ClassCode[1] << 8) |
                        ((uint32_t)PE->DeviceID.ClassCode[2] << 16)),
                    PE->DeviceID.Function, PE->DeviceID.Device,
                    le16dec(PE->DeviceID.Segment), PE->DeviceID.Bus,
                    PE->DeviceID.SecondaryBus, le16dec(PE->DeviceID.Slot),
                    PE->DeviceID.Reserved0);
        }
        if (PE->ValidationBits & CPER_PCIE_ERROR_VALID_DEVICE_SERIAL) {
                device_printf(sc->sc_dev, "%s: DeviceSerial={%016"PRIx64"}\n",
                    ctx, PE->DeviceSerial);
        }
        if (PE->ValidationBits & CPER_PCIE_ERROR_VALID_BRIDGE_CONTROL_STATUS) {
                /* XXX snprintb */
                device_printf(sc->sc_dev, "%s: BridgeControlStatus=%"PRIx32
                    "\n", ctx, PE->BridgeControlStatus);
        }
        if (PE->ValidationBits & CPER_PCIE_ERROR_VALID_CAPABILITY_STRUCTURE) {
                uint32_t dcsr, dsr;
                char hex[9*sizeof(PE->CapabilityStructure)/4];
                unsigned i;

                /*
                 * Display a hex dump of each 32-bit register in the
                 * PCIe capability structure.
                 */
                __CTASSERT(sizeof(PE->CapabilityStructure) % 4 == 0);
                for (i = 0; i < sizeof(PE->CapabilityStructure)/4; i++) {
                        snprintf(hex + 9*i, sizeof(hex) - 9*i, "%08"PRIx32" ",
                            le32dec(&PE->CapabilityStructure[4*i]));
                }
                hex[sizeof(hex) - 1] = '\0';
                device_printf(sc->sc_dev, "%s: CapabilityStructure={%s}\n",
                    ctx, hex);

                /*
                 * If the Device Status Register has any bits set,
                 * highlight it in particular -- these are probably
                 * error bits.
                 */
                dcsr = le32dec(&PE->CapabilityStructure[PCIE_DCSR]);
                dsr = __SHIFTOUT(dcsr, __BITS(31,16));
                if (dsr != 0) {
                        /*
                         * XXX move me to pcireg.h; note: high
                         * half of DCSR
                         */
                        snprintb(bitbuf, sizeof(bitbuf), "\177\020"
                            "b\000"     "CORRECTABLE_ERROR\0"
                            "b\001"     "NONFATAL_UNCORRECTABLE_ERROR\0"
                            "b\002"     "FATAL_ERROR\0"
                            "b\003"     "UNSUPPORTED_REQUEST\0"
                            "b\004"     "AUX_POWER\0"
                            "b\005"     "TRANSACTIONS_PENDING\0"
                            "\0", dsr);
                        device_printf(sc->sc_dev, "%s: PCIe Device Status:"
                            " %s\n",
                            ctx, bitbuf);
                }
        }
        if (PE->ValidationBits & CPER_PCIE_ERROR_VALID_AER_INFO) {
                uint32_t uc_status, uc_sev;
                uint32_t cor_status;
                uint32_t control;
                char hex[9*sizeof(PE->AERInfo)/4];
                unsigned i;

                /*
                 * Display a hex dump of each 32-bit register in the
                 * PCIe Advanced Error Reporting extended capability
                 * structure.
                 */
                __CTASSERT(sizeof(PE->AERInfo) % 4 == 0);
                for (i = 0; i < sizeof(PE->AERInfo)/4; i++) {
                        snprintf(hex + 9*i, sizeof(hex) - 9*i, "%08"PRIx32" ",
                            le32dec(&PE->AERInfo[4*i]));
                }
                hex[sizeof(hex) - 1] = '\0';
                device_printf(sc->sc_dev, "%s: AERInfo={%s}\n", ctx, hex);

                        /* XXX move me to pcireg.h */
#define PCI_AER_UC_STATUS_FMT   "\177\020"                                    \
        "b\000" "UNDEFINED\0"                                                 \
        "b\004" "DL_PROTOCOL_ERROR\0"                                         \
        "b\005" "SURPRISE_DOWN_ERROR\0"                                       \
        "b\014" "POISONED_TLP\0"                                              \
        "b\015" "FC_PROTOCOL_ERROR\0"                                         \
        "b\016" "COMPLETION_TIMEOUT\0"                                        \
        "b\017" "COMPLETION_ABORT\0"                                          \
        "b\020" "UNEXPECTED_COMPLETION\0"                                     \
        "b\021" "RECEIVER_OVERFLOW\0"                                         \
        "b\022" "MALFORMED_TLP\0"                                             \
        "b\023" "ECRC_ERROR\0"                                                \
        "b\024" "UNSUPPORTED_REQUEST_ERROR\0"                                 \
        "b\025" "ACS_VIOLATION\0"                                             \
        "b\026" "INTERNAL_ERROR\0"                                            \
        "b\027" "MC_BLOCKED_TLP\0"                                            \
        "b\030" "ATOMIC_OP_EGRESS_BLOCKED\0"                                  \
        "b\031" "TLP_PREFIX_BLOCKED_ERROR\0"                                  \
        "b\032" "POISONTLP_EGRESS_BLOCKED\0"                                  \
        "\0"

                /*
                 * If there are any hardware error status bits set,
                 * highlight them in particular, in three groups:
                 *
                 * - uncorrectable fatal (UC_STATUS and UC_SEVERITY)
                 * - uncorrectable nonfatal (UC_STATUS but not UC_SEVERITY)
                 * - corrected (COR_STATUS)
                 *
                 * And if there are any uncorrectable errors, show
                 * which one was reported first, according to
                 * CAP_CONTROL.
                 */
                uc_status = le32dec(&PE->AERInfo[PCI_AER_UC_STATUS]);
                uc_sev = le32dec(&PE->AERInfo[PCI_AER_UC_SEVERITY]);
                cor_status = le32dec(&PE->AERInfo[PCI_AER_COR_STATUS]);
                control = le32dec(&PE->AERInfo[PCI_AER_CAP_CONTROL]);

                if (uc_status & uc_sev) {
                        snprintb(bitbuf, sizeof(bitbuf), PCI_AER_UC_STATUS_FMT,
                            uc_status & uc_sev);
                        device_printf(sc->sc_dev, "%s:"
                            " AER hardware fatal uncorrectable errors: %s\n",
                            ctx, bitbuf);
                }
                if (uc_status & ~uc_sev) {
                        snprintb(bitbuf, sizeof(bitbuf), PCI_AER_UC_STATUS_FMT,
                            uc_status & ~uc_sev);
                        device_printf(sc->sc_dev, "%s:"
                            " AER hardware non-fatal uncorrectable errors:"
                            " %s\n",
                            ctx, bitbuf);
                }
                if (uc_status) {
                        unsigned first = __SHIFTOUT(control,
                            PCI_AER_FIRST_ERROR_PTR);
                        snprintb(bitbuf, sizeof(bitbuf), PCI_AER_UC_STATUS_FMT,
                            (uint32_t)1 << first);
                        device_printf(sc->sc_dev, "%s:"
                            " AER hardware first uncorrectable error: %s\n",
                            ctx, bitbuf);
                }
                if (cor_status) {
                        /* XXX move me to pcireg.h */
                        snprintb(bitbuf, sizeof(bitbuf), "\177\020"
                            "b\000"     "RECEIVER_ERROR\0"
                            "b\006"     "BAD_TLP\0"
                            "b\007"     "BAD_DLLP\0"
                            "b\010"     "REPLAY_NUM_ROLLOVER\0"
                            "b\014"     "REPLAY_TIMER_TIMEOUT\0"
                            "b\015"     "ADVISORY_NF_ERROR\0"
                            "b\016"     "INTERNAL_ERROR\0"
                            "b\017"     "HEADER_LOG_OVERFLOW\0"
                            "\0", cor_status);
                        device_printf(sc->sc_dev, "%s:"
                            " AER hardware corrected error: %s\n",
                            ctx, bitbuf);
                }
        }

out:    /*
         * XXX pass this on to the PCI subsystem to handle
         */
        return;
}

/*
 * apei_cper_reports
 *
 *      Table of known Common Platform Error Record types, symbolic
 *      names, minimum data lengths, and functions to report them.
 *
 *      The section types and corresponding section layouts are listed
 *      at:
 *
 *      https://uefi.org/specs/UEFI/2.10/Apx_N_Common_Platform_Error_Record.html
 */
static const struct apei_cper_report {
        const char *name;
        const struct uuid *type;
        size_t minlength;
        void (*func)(struct apei_softc *, const void *, size_t, const char *,
            bool);
} apei_cper_reports[] = {
        { "memory", &CPER_MEMORY_ERROR_SECTION,
          sizeof(struct cper_memory_error),
          apei_cper_memory_error_report },
        { "PCIe", &CPER_PCIE_ERROR_SECTION,
          sizeof(struct cper_pcie_error),
          apei_cper_pcie_error_report },
};

/*
 * apei_gede_report_header(sc, gede, ctx, ratelimitok, &headerlen, &report)
 *
 *      Report the header of the ith Generic Error Data Entry in the
 *      given context, if ratelimitok is true.
 *
 *      Return the actual length of the header in headerlen, or 0 if
 *      not known because the revision isn't recognized.
 *
 *      Return the report type in report, or NULL if not known because
 *      the section type isn't recognized.
 */
static void
apei_gede_report_header(struct apei_softc *sc,
    const ACPI_HEST_GENERIC_DATA *gede, const char *ctx, bool ratelimitok,
    size_t *headerlenp, const struct apei_cper_report **reportp)
{
        const ACPI_HEST_GENERIC_DATA_V300 *const gede_v3 = (const void *)gede;
        struct uuid sectype;
        char guidstr[69];
        char buf[128];
        unsigned i;

        /*
         * Print the section type as a C initializer.  It would be
         * prettier to use standard hyphenated UUID notation, but that
         * notation is slightly ambiguous here (two octets could be
         * written either way, depending on Microsoft convention --
         * which influenced ACPI and UEFI -- or internet convention),
         * and the UEFI spec writes the C initializer notation, so this
         * makes it easier to search for.
         *
         * Also print out a symbolic name, if we know it.
         */
        apei_cper_guid_dec(gede->SectionType, &sectype);
        apei_format_guid(&sectype, guidstr);
        for (i = 0; i < __arraycount(apei_cper_reports); i++) {
                const struct apei_cper_report *const report =
                    &apei_cper_reports[i];

                if (memcmp(&sectype, report->type, sizeof(sectype)) != 0)
                        continue;
                if (ratelimitok) {
                        device_printf(sc->sc_dev, "%s:"
                            " SectionType=%s (%s error)\n",
                            ctx, guidstr, report->name);
                }
                *reportp = report;
                break;
        }
        if (i == __arraycount(apei_cper_reports)) {
                if (ratelimitok) {
                        device_printf(sc->sc_dev, "%s: SectionType=%s\n", ctx,
                            guidstr);
                }
                *reportp = NULL;
        }

        /*
         * Print the numeric severity and, if we have it, a symbolic
         * name for it.
         */
        if (ratelimitok) {
                device_printf(sc->sc_dev, "%s: ErrorSeverity=%"PRIu32" (%s)\n",
                    ctx,
                    gede->ErrorSeverity,
                    (gede->ErrorSeverity < __arraycount(apei_gede_severity)
                        ? apei_gede_severity[gede->ErrorSeverity]
                        : "unknown"));
        }

        /*
         * The Revision may not often be useful, but this is only ever
         * shown at the time of a hardware error report, not something
         * you can glean at your convenience with acpidump.  So print
         * it anyway.
         */
        if (ratelimitok) {
                device_printf(sc->sc_dev, "%s: Revision=0x%"PRIx16"\n", ctx,
                    gede->Revision);
        }

        /*
         * Don't touch anything past the Revision until we've
         * determined we understand it.  Return the header length to
         * the caller, or return zero -- and stop here -- if we don't
         * know what the actual header length is.
         */
        if (gede->Revision < 0x0300) {
                *headerlenp = sizeof(*gede);
        } else if (gede->Revision < 0x0400) {
                *headerlenp = sizeof(*gede_v3);
        } else {
                *headerlenp = 0;
                return;
        }

        /*
         * Print the validation bits at debug level.  Only really
         * helpful if there are bits we _don't_ know about.
         */
        if (ratelimitok) {
                /* XXX define this format somewhere */
                snprintb(buf, sizeof(buf), "\177\020"
                    "b\000"     "FRU_ID\0"
                    "b\001"     "FRU_TEXT\0" /* `FRU string', sometimes */
                    "b\002"     "TIMESTAMP\0"
                    "\0", gede->ValidationBits);
                aprint_debug_dev(sc->sc_dev, "%s: ValidationBits=%s\n", ctx,
                    buf);
        }

        /*
         * Print the CPER section flags.
         */
        if (ratelimitok) {
                snprintb(buf, sizeof(buf), CPER_SECTION_FLAGS_FMT,
                    gede->Flags);
                device_printf(sc->sc_dev, "%s: Flags=%s\n", ctx, buf);
        }

        /*
         * The ErrorDataLength is unlikely to be useful for the log, so
         * print it at debug level only.
         */
        if (ratelimitok) {
                aprint_debug_dev(sc->sc_dev, "%s:"
                    " ErrorDataLength=0x%"PRIu32"\n",
                    ctx, gede->ErrorDataLength);
        }

        /*
         * Print the FRU Id and text, if available.
         */
        if (ratelimitok &&
            (gede->ValidationBits & ACPI_HEST_GEN_VALID_FRU_ID) != 0) {
                struct uuid fruid;

                apei_cper_guid_dec(gede->FruId, &fruid);
                apei_format_guid(&fruid, guidstr);
                device_printf(sc->sc_dev, "%s: FruId=%s\n", ctx, guidstr);
        }
        if (ratelimitok &&
            (gede->ValidationBits & ACPI_HEST_GEN_VALID_FRU_STRING) != 0) {
                device_printf(sc->sc_dev, "%s: FruText=%.20s\n",
                    ctx, gede->FruText);
        }

        /*
         * Print the timestamp, if available by the revision number and
         * the validation bits.
         */
        if (ratelimitok &&
            gede->Revision >= 0x0300 && gede->Revision < 0x0400 &&
            gede->ValidationBits & ACPI_HEST_GEN_VALID_TIMESTAMP) {
                const uint8_t *const t = (const uint8_t *)&gede_v3->TimeStamp;
                const uint8_t s = t[0];
                const uint8_t m = t[1];
                const uint8_t h = t[2];
                const uint8_t f = t[3];
                const uint8_t D = t[4];
                const uint8_t M = t[5];
                const uint8_t Y = t[6];
                const uint8_t C = t[7];

                device_printf(sc->sc_dev, "%s: Timestamp=0x%"PRIx64
                    " (%02d%02d-%02d-%02dT%02d:%02d:%02d%s)\n",
                    ctx, gede_v3->TimeStamp,
                    C,Y, M, D, h,m,s,
                    f & __BIT(0) ? " (event time)" : " (collect time)");
        }
}

/*
 * apei_gesb_ratelimit
 *
 *      State to limit the rate of console log messages about hardware
 *      errors.  For each of the four severity levels in a Generic
 *      Error Status Block,
 *
 *      0 - Recoverable (uncorrectable),
 *      1 - Fatal (uncorrectable),
 *      2 - Corrected, and
 *      3 - None (including ill-formed errors),
 *
 *      we record the last time it happened, protected by a CPU simple
 *      lock that we only try-acquire so it is safe to use in any
 *      context, including non-maskable interrupt context.
 */

static struct {
        __cpu_simple_lock_t     lock;
        struct timeval          lasttime;
        volatile uint32_t       suppressed;
} __aligned(COHERENCY_UNIT) apei_gesb_ratelimit[4] __cacheline_aligned = {
        [ACPI_HEST_GEN_ERROR_RECOVERABLE] = { .lock = __SIMPLELOCK_UNLOCKED },
        [ACPI_HEST_GEN_ERROR_FATAL] = { .lock = __SIMPLELOCK_UNLOCKED },
        [ACPI_HEST_GEN_ERROR_CORRECTED] = { .lock = __SIMPLELOCK_UNLOCKED },
        [ACPI_HEST_GEN_ERROR_NONE] = { .lock = __SIMPLELOCK_UNLOCKED },
};

static void
atomic_incsat_32(volatile uint32_t *p)
{
        uint32_t o, n;

        do {
                o = atomic_load_relaxed(p);
                if (__predict_false(o == UINT_MAX))
                        return;
                n = o + 1;
        } while (__predict_false(atomic_cas_32(p, o, n) != o));
}

/*
 * apei_gesb_ratecheck(sc, severity, suppressed)
 *
 *      Check for a rate limit on errors of the specified severity.
 *
 *      => Return true if the error should be printed, and format into
 *         the buffer suppressed a message saying how many errors were
 *         previously suppressed.
 *
 *      => Return false if the error should be suppressed because the
 *         last one printed was too recent.
 */
static bool
apei_gesb_ratecheck(struct apei_softc *sc, uint32_t severity,
    char suppressed[static sizeof(" (4294967295 or more errors suppressed)")])
{
        /* one of each type per minute (XXX worth making configurable?) */
        const struct timeval mininterval = {60, 0};
        unsigned i = MIN(severity, ACPI_HEST_GEN_ERROR_NONE); /* paranoia */
        bool ok = false;

        /*
         * If the lock is contended, the rate limit is probably
         * exceeded, so it's not OK to print.
         *
         * Otherwise, with the lock held, ask ratecheck(9) whether it's
         * OK to print.
         */
        if (!__cpu_simple_lock_try(&apei_gesb_ratelimit[i].lock))
                goto out;
        ok = ratecheck(&apei_gesb_ratelimit[i].lasttime, &mininterval);
        __cpu_simple_unlock(&apei_gesb_ratelimit[i].lock);

out:    /*
         * If it's OK to print, report the number of errors that were
         * suppressed.  If it's not OK to print, count a suppressed
         * error.
         */
        if (ok) {
                const uint32_t n =
                    atomic_swap_32(&apei_gesb_ratelimit[i].suppressed, 0);

                if (n == 0) {
                        suppressed[0] = '\0';
                } else {
                        snprintf(suppressed,
                            sizeof(" (4294967295 or more errors suppressed)"),
                            " (%u%s error%s suppressed)",
                            n,
                            n == UINT32_MAX ? " or more" : "",
                            n == 1 ? "" : "s");
                }
        } else {
                atomic_incsat_32(&apei_gesb_ratelimit[i].suppressed);
                suppressed[0] = '\0';
        }
        return ok;
}

/*
 * apei_gesb_report(sc, gesb, size, ctx)
 *
 *      Check a Generic Error Status Block, of at most the specified
 *      size in bytes, and report any errors in it.  Return the 32-bit
 *      Block Status in case the caller needs it to acknowledge the
 *      report to firmware.
 */
uint32_t
apei_gesb_report(struct apei_softc *sc, const ACPI_HEST_GENERIC_STATUS *gesb,
    size_t size, const char *ctx, bool *fatalp)
{
        uint32_t status, unknownstatus, severity, nentries, i;
        uint32_t datalen, rawdatalen;
        const ACPI_HEST_GENERIC_DATA *gede0, *gede;
        const unsigned char *rawdata;
        bool ratelimitok = false;
        char suppressed[sizeof(" (4294967295 or more errors suppressed)")];
        bool fatal = false;

        /*
         * Verify the buffer is large enough for a Generic Error Status
         * Block before we try to touch anything in it.
         */
        if (size < sizeof(*gesb)) {
                ratelimitok = apei_gesb_ratecheck(sc, ACPI_HEST_GEN_ERROR_NONE,
                    suppressed);
                if (ratelimitok) {
                        device_printf(sc->sc_dev,
                            "%s: truncated GESB, %zu < %zu%s\n",
                            ctx, size, sizeof(*gesb), suppressed);
                }
                status = 0;
                goto out;
        }
        size -= sizeof(*gesb);

        /*
         * Load the status.  Access ordering rules are unclear in the
         * ACPI specification; I'm guessing that load-acquire of the
         * block status is a good idea before any other access to the
         * GESB.
         */
        status = atomic_load_acquire(&gesb->BlockStatus);

        /*
         * If there are no status bits set, the rest of the GESB is
         * garbage, so stop here.
         */
        if (status == 0) {
                /* XXX dtrace */
                /* XXX DPRINTF */
                goto out;
        }

        /*
         * Read out the severity and get the number of entries in this
         * status block.
         */
        severity = gesb->ErrorSeverity;
        nentries = __SHIFTOUT(status, ACPI_HEST_ERROR_ENTRY_COUNT);

        /*
         * Print a message to the console and dmesg about the severity
         * of the error.
         */
        ratelimitok = apei_gesb_ratecheck(sc, severity, suppressed);
        if (ratelimitok) {
                char statusbuf[128];

                /* XXX define this format somewhere */
                snprintb(statusbuf, sizeof(statusbuf), "\177\020"
                    "b\000"     "UE\0"
                    "b\001"     "CE\0"
                    "b\002"     "MULTI_UE\0"
                    "b\003"     "MULTI_CE\0"
                    "f\004\010" "GEDE_COUNT\0"
                    "\0", status);

                if (severity < __arraycount(apei_gesb_severity)) {
                        device_printf(sc->sc_dev, "%s"
                            " reported hardware error%s:"
                            " severity=%s nentries=%u status=%s\n",
                            ctx, suppressed,
                            apei_gesb_severity[severity], nentries, statusbuf);
                } else {
                        device_printf(sc->sc_dev, "%s reported error%s:"
                            " severity=%"PRIu32" nentries=%u status=%s\n",
                            ctx, suppressed,
                            severity, nentries, statusbuf);
                }
        }

        /*
         * Make a determination about whether the error is fatal.
         *
         * XXX Currently we don't have any mechanism to recover from
         * uncorrectable but recoverable errors, so we treat those --
         * and anything else we don't recognize -- as fatal.
         */
        switch (severity) {
        case ACPI_HEST_GEN_ERROR_CORRECTED:
        case ACPI_HEST_GEN_ERROR_NONE:
                fatal = false;
                break;
        case ACPI_HEST_GEN_ERROR_FATAL:
        case ACPI_HEST_GEN_ERROR_RECOVERABLE: /* XXX */
        default:
                fatal = true;
                break;
        }

        /*
         * Clear the bits we know about to warn if there's anything
         * left we don't understand.
         */
        unknownstatus = status;
        unknownstatus &= ~ACPI_HEST_UNCORRECTABLE;
        unknownstatus &= ~ACPI_HEST_MULTIPLE_UNCORRECTABLE;
        unknownstatus &= ~ACPI_HEST_CORRECTABLE;
        unknownstatus &= ~ACPI_HEST_MULTIPLE_CORRECTABLE;
        unknownstatus &= ~ACPI_HEST_ERROR_ENTRY_COUNT;
        if (ratelimitok && unknownstatus != 0) {
                /* XXX dtrace */
                device_printf(sc->sc_dev, "%s: unknown BlockStatus bits:"
                    " 0x%"PRIx32"\n", ctx, unknownstatus);
        }

        /*
         * Advance past the Generic Error Status Block (GESB) header to
         * the Generic Error Data Entries (GEDEs).
         */
        gede0 = gede = (const ACPI_HEST_GENERIC_DATA *)(gesb + 1);

        /*
         * Verify that the data length (GEDEs) fits within the size.
         * If not, truncate the GEDEs.
         */
        datalen = gesb->DataLength;
        if (size < datalen) {
                if (ratelimitok) {
                        device_printf(sc->sc_dev, "%s:"
                            " GESB DataLength exceeds bounds:"
                            " %zu < %"PRIu32"\n",
                            ctx, size, datalen);
                }
                datalen = size;
        }
        size -= datalen;

        /*
         * Report each of the Generic Error Data Entries.
         */
        for (i = 0; i < nentries; i++) {
                size_t headerlen;
                const struct apei_cper_report *report;
                char subctx[128];

                /*
                 * Format a subcontext to show this numbered entry of
                 * the GESB.
                 */
                snprintf(subctx, sizeof(subctx), "%s entry %"PRIu32, ctx, i);

                /*
                 * If the remaining GESB data length isn't enough for a
                 * GEDE header, stop here.
                 */
                if (datalen < sizeof(*gede)) {
                        if (ratelimitok) {
                                device_printf(sc->sc_dev, "%s:"
                                    " truncated GEDE: %"PRIu32" < %zu bytes\n",
                                    subctx, datalen, sizeof(*gede));
                        }
                        break;
                }

                /*
                 * Print the GEDE header and get the full length (may
                 * vary from revision to revision of the GEDE) and the
                 * CPER report function if possible.
                 */
                apei_gede_report_header(sc, gede, subctx, ratelimitok,
                    &headerlen, &report);

                /*
                 * If we don't know the header length because of an
                 * unfamiliar revision, stop here.
                 */
                if (headerlen == 0) {
                        if (ratelimitok) {
                                device_printf(sc->sc_dev, "%s:"
                                    " unknown revision: 0x%"PRIx16"\n",
                                    subctx, gede->Revision);
                        }
                        break;
                }

                /*
                 * Stop here if what we mapped is too small for the
                 * error data length.
                 */
                datalen -= headerlen;
                if (datalen < gede->ErrorDataLength) {
                        if (ratelimitok) {
                                device_printf(sc->sc_dev, "%s:"
                                    " truncated GEDE payload:"
                                    " %"PRIu32" < %"PRIu32" bytes\n",
                                    subctx, datalen, gede->ErrorDataLength);
                        }
                        break;
                }

                /*
                 * Report the Common Platform Error Record appendix to
                 * this Generic Error Data Entry.
                 */
                if (report == NULL) {
                        if (ratelimitok) {
                                device_printf(sc->sc_dev, "%s:"
                                    " [unknown type]\n", ctx);
                        }
                } else {
                        /* XXX pass ratelimit through */
                        (*report->func)(sc, (const char *)gede + headerlen,
                            gede->ErrorDataLength, subctx, ratelimitok);
                }

                /*
                 * Advance past the GEDE header and CPER data to the
                 * next GEDE.
                 */
                gede = (const ACPI_HEST_GENERIC_DATA *)((const char *)gede +
                    + headerlen + gede->ErrorDataLength);
        }

        /*
         * Advance past the Generic Error Data Entries (GEDEs) to the
         * raw error data.
         *
         * XXX Provide Max Raw Data Length as a parameter, as found in
         * various HEST entry types.
         */
        rawdata = (const unsigned char *)gede0 + datalen;

        /*
         * Verify that the raw data length fits within the size.  If
         * not, truncate the raw data.
         */
        rawdatalen = gesb->RawDataLength;
        if (size < rawdatalen) {
                if (ratelimitok) {
                        device_printf(sc->sc_dev, "%s:"
                            " GESB RawDataLength exceeds bounds:"
                            " %zu < %"PRIu32"\n",
                            ctx, size, rawdatalen);
                }
                rawdatalen = size;
        }
        size -= rawdatalen;

        /*
         * Hexdump the raw data, if any.
         */
        if (ratelimitok && rawdatalen > 0) {
                char devctx[128];

                snprintf(devctx, sizeof(devctx), "%s: %s: raw data",
                    device_xname(sc->sc_dev), ctx);
                hexdump(printf, devctx, rawdata, rawdatalen);
        }

        /*
         * If there's anything left after the raw data, warn.
         */
        if (ratelimitok && size > 0) {
                device_printf(sc->sc_dev, "%s: excess data: %zu bytes\n",
                    ctx, size);
        }

        /*
         * Return the status so the caller can ack it, and tell the
         * caller whether this error is fatal.
         */
out:    *fatalp = fatal;
        return status;
}

MODULE(MODULE_CLASS_DRIVER, apei, NULL);

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
apei_modcmd(modcmd_t cmd, void *opaque)
{
        int error = 0;

        switch (cmd) {
        case MODULE_CMD_INIT:
#ifdef _MODULE
                error = config_init_component(cfdriver_ioconf_apei,
                    cfattach_ioconf_apei, cfdata_ioconf_apei);
#endif
                return error;
        case MODULE_CMD_FINI:
#ifdef _MODULE
                error = config_fini_component(cfdriver_ioconf_apei,
                    cfattach_ioconf_apei, cfdata_ioconf_apei);
#endif
                return error;
        default:
                return ENOTTY;
        }
}