/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2024-2026 The FreeBSD Foundation
 *
 * This software was developed by Aymeric Wibo <obiwac@freebsd.org>
 * under sponsorship from the FreeBSD Foundation.
 *
 * Portions of this software were developed by Olivier Certner
 * <olce@FreeBSD.org> at Kumacom SARL under sponsorship from the FreeBSD
 * Foundation.
 */

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/eventhandler.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/uuid.h>

#include <machine/_inttypes.h>

#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>

#include <dev/acpica/acpivar.h>


/* Hooks for the ACPI CA debugging infrastructure */
#define _COMPONENT      ACPI_SPMC
ACPI_MODULE_NAME("SPMC")

static char *spmc_ids[] = {
        "PNP0D80",
        NULL
};

/* sysctl(8) knobs */
static SYSCTL_NODE(_debug_acpi, OID_AUTO, spmc, CTLFLAG_RD | CTLFLAG_MPSAFE,
    NULL, "SPMC debugging");

int8_t dsm_intel_revision = -15;
SYSCTL_S8(_debug_acpi_spmc, OID_AUTO, intel_dsm_revision, CTLFLAG_RW,
    &dsm_intel_revision, 0,
    "Revision to use with the Intel DSM "
    "(negative: auto, try from 0 to minus the value)");

int8_t dsm_amd_revision = -15;
SYSCTL_S8(_debug_acpi_spmc, OID_AUTO, amd_dsm_revision, CTLFLAG_RW,
    &dsm_amd_revision, 0,
    "Revision to use with the AMD DSM "
    "(negative: auto, try from 0 to minus the value)");

int8_t dsm_ms_revision = -15;
SYSCTL_S8(_debug_acpi_spmc, OID_AUTO, ms_dsm_revision, CTLFLAG_RW,
    &dsm_ms_revision, 0,
    "Revision to use with the Microsoft DSM "
    "(negative: auto, try from 0 to minus the value)");

static int verbose;
SYSCTL_INT(_debug_acpi_spmc, OID_AUTO, verbose, CTLFLAG_RW,
    &verbose, 0, "acpi_spmc(4) verbosity");

#define VERBOSE()       (verbose || bootverbose)

static bool force_call_expected_functions;
SYSCTL_BOOL(_debug_acpi_spmc, OID_AUTO, always_call_expected_functions,
    CTLFLAG_RW, &force_call_expected_functions, 0,
    "Call all expected functions on a present DSM, even those not enumerated.");

/* Conversion of an index to a mask. */
#define IDX_TO_BIT(idx)         (1ull << (idx))

/* List of supported DSMs. */
#define DSM_INTEL                       0
#define DSM_MS                          1
#define DSM_AMD                         2

/* List of DSM function indices. */
#define DSM_ENUM_FUNCTIONS              0       /* Common to all DSMs */
#define DSM_GET_DEVICE_CONSTRAINTS      1       /* AMD and Intel, MS N/A */

#define DSM_GET_CRASH_DUMP_DEVICE       2       /* Intel, MS N/A */
#define DSM_INTEL_MS_DISPLAY_OFF_NOTIF  3
#define DSM_INTEL_MS_DISPLAY_ON_NOTIF   4
#define DSM_INTEL_MS_LPI_ENTRY_NOTIF    5
#define DSM_INTEL_MS_LPI_EXIT_NOTIF     6

#define DSM_MS_SLEEP_ENTRY_NOTIF        7
#define DSM_MS_SLEEP_EXIT_NOTIF         8
#define DSM_MS_TURN_ON_DISPLAY          9

#define DSM_AMD_LPI_ENTRY_NOTIF         2
#define DSM_AMD_LPI_EXIT_NOTIF          3
#define DSM_AMD_DISPLAY_OFF_NOTIF       4
#define DSM_AMD_DISPLAY_ON_NOTIF        5


/* Descriptors for the DSMs we support. */

struct dsm_desc {
        const char              *name;
        struct uuid              uuid;
        /*
         * Points to an integer which, if negative, indicates to auto-detect the
         * revision by trying all revisions between 0 and minus the value, else
         * is the sole revision to try.
         */
        const int8_t            *revision_spec;
        uint64_t                 expected_functions;
        uint64_t                 extra_functions;
        /* Human-friendly names of known functions. */
        const char *const       *function_names;
        int                      function_names_nb;
        /* Index in the dsms[] array below. */
        int                      index;
};

static const char *const dsm_intel_function_names[] = {
        [DSM_GET_DEVICE_CONSTRAINTS] = "DEVICE_CONSTRAINTS",
        [DSM_GET_CRASH_DUMP_DEVICE] = "CRASH_DUMP_DEVICE",
        [DSM_INTEL_MS_DISPLAY_OFF_NOTIF] = "DISPLAY_OFF",
        [DSM_INTEL_MS_DISPLAY_ON_NOTIF] = "DISPLAY_ON",
        [DSM_INTEL_MS_LPI_ENTRY_NOTIF] = "LPI_ENTRY",
        [DSM_INTEL_MS_LPI_EXIT_NOTIF] = "LPI_EXIT",
};

static const struct dsm_desc dsm_intel = {
        .index = DSM_INTEL,
        .name = "Intel",
        .uuid = { /* c4eb40a0-6cd2-11e2-bcfd-0800200c9a66 */
                0xc4eb40a0, 0x6cd2, 0x11e2, 0xbc, 0xfd,
                {0x08, 0x00, 0x20, 0x0c, 0x9a, 0x66}
        },
        .revision_spec = &dsm_intel_revision,
        .expected_functions =
            IDX_TO_BIT(DSM_GET_DEVICE_CONSTRAINTS) |
            IDX_TO_BIT(DSM_INTEL_MS_DISPLAY_OFF_NOTIF) |
            IDX_TO_BIT(DSM_INTEL_MS_DISPLAY_ON_NOTIF) |
            IDX_TO_BIT(DSM_INTEL_MS_LPI_ENTRY_NOTIF) |
            IDX_TO_BIT(DSM_INTEL_MS_LPI_EXIT_NOTIF),
        .extra_functions =
            IDX_TO_BIT(DSM_GET_CRASH_DUMP_DEVICE), /* Not used. */
        .function_names = dsm_intel_function_names,
        .function_names_nb = nitems(dsm_intel_function_names),
};

static const char *const dsm_ms_function_names[] = {
        [DSM_INTEL_MS_DISPLAY_OFF_NOTIF] = "DISPLAY_OFF",
        [DSM_INTEL_MS_DISPLAY_ON_NOTIF] = "DISPLAY_ON",
        [DSM_INTEL_MS_LPI_ENTRY_NOTIF] = "LPI_ENTRY",
        [DSM_INTEL_MS_LPI_EXIT_NOTIF] = "LPI_EXIT",
        [DSM_MS_SLEEP_ENTRY_NOTIF] = "SLEEP_ENTRY",
        [DSM_MS_SLEEP_EXIT_NOTIF] = "SLEEP_EXIT",
        [DSM_MS_TURN_ON_DISPLAY] = "TURN_ON",
};

static const struct dsm_desc dsm_ms = {
        .index = DSM_MS,
        .name = "Microsoft",
        .uuid = { /* 11e00d56-ce64-47ce-837b-1f898f9aa461 */
                0x11e00d56, 0xce64, 0x47ce, 0x83, 0x7b,
                {0x1f, 0x89, 0x8f, 0x9a, 0xa4, 0x61}
        },
        .revision_spec = &dsm_ms_revision,
        .expected_functions =
            IDX_TO_BIT(DSM_INTEL_MS_DISPLAY_OFF_NOTIF) |
            IDX_TO_BIT(DSM_INTEL_MS_DISPLAY_ON_NOTIF) |
            IDX_TO_BIT(DSM_INTEL_MS_LPI_ENTRY_NOTIF) |
            IDX_TO_BIT(DSM_INTEL_MS_LPI_EXIT_NOTIF) |
            IDX_TO_BIT(DSM_MS_SLEEP_ENTRY_NOTIF) |
            IDX_TO_BIT(DSM_MS_SLEEP_EXIT_NOTIF),
        .extra_functions =
            IDX_TO_BIT(DSM_MS_TURN_ON_DISPLAY),
        .function_names = dsm_ms_function_names,
        .function_names_nb = nitems(dsm_ms_function_names),
};

static const char *const dsm_amd_function_names[] = {
        [DSM_GET_DEVICE_CONSTRAINTS] = "DEVICE_CONSTRAINTS",
        [DSM_AMD_DISPLAY_OFF_NOTIF] = "DISPLAY_OFF",
        [DSM_AMD_DISPLAY_ON_NOTIF] = "DISPLAY_ON",
        [DSM_AMD_LPI_ENTRY_NOTIF] = "LPI_ENTRY",
        [DSM_AMD_LPI_EXIT_NOTIF] = "LPI_EXIT",
};

static const struct dsm_desc dsm_amd = {
        .index = DSM_AMD,
        .name = "AMD",
        .uuid = { /* e3f32452-febc-43ce-9039-932122d37721 */
                0xe3f32452, 0xfebc, 0x43ce, 0x90, 0x39,
                {0x93, 0x21, 0x22, 0xd3, 0x77, 0x21}
        },
        .revision_spec = &dsm_amd_revision,
        .expected_functions =
            IDX_TO_BIT(DSM_GET_DEVICE_CONSTRAINTS) |
            IDX_TO_BIT(DSM_AMD_DISPLAY_OFF_NOTIF) |
            IDX_TO_BIT(DSM_AMD_DISPLAY_ON_NOTIF) |
            IDX_TO_BIT(DSM_AMD_LPI_ENTRY_NOTIF) |
            IDX_TO_BIT(DSM_AMD_LPI_EXIT_NOTIF),
        .function_names = dsm_amd_function_names,
        .function_names_nb = nitems(dsm_amd_function_names),
};

static const struct dsm_desc *const dsms[] = {
        [DSM_INTEL] = &dsm_intel,
        [DSM_MS] = &dsm_ms,
        [DSM_AMD] = &dsm_amd,
};

/* Per DSM probed information. */
struct dsm_info {
        uint64_t        supported_functions;
        /*
         * Revisions are zero or a positive number.  Strictly speaking, next
         * field should be a 'uint64_t' as per the ACPI spec, but our ACPI DSM
         * interface takes an 'int' and anyway actual revision numbers never
         * even exceed the limits of a 'uint8_t'.
         */
        uint8_t         revision;
};

struct acpi_spmc_constraint {
        bool            enabled;
        char            *name;
        int             min_d_state;
        ACPI_HANDLE     handle;

        /* Intel only.  Currently filled but unused. */
        uint64_t        lpi_uid;
        uint64_t        min_dev_specific_state;

        /* AMD only.  Currently filled but unused. */
        uint64_t        function_states;
};

struct acpi_spmc_softc {
        device_t                dev;
        ACPI_HANDLE             handle;
        struct dsm_info         dsms_info[nitems(dsms)];

        struct eventhandler_entry       *eh_suspend;
        struct eventhandler_entry       *eh_resume;

#ifdef INVARIANTS
        bool                            get_constraints_succeeded;
#endif
        size_t                          constraint_count;
        struct acpi_spmc_constraint     *constraints;
};


static const struct dsm_desc *
resolve_dsm(int dsm_index)
{
        MPASS(0 <= dsm_index && dsm_index < nitems(dsms));
        return (dsms[dsm_index]);
}

static struct dsm_info *
get_dsm_info(struct acpi_spmc_softc *const sc, const int dsm_index)
{
        MPASS(0 <= dsm_index && dsm_index < nitems(dsms));
        return (&sc->dsms_info[dsm_index]);
}

static const struct dsm_info *
get_const_dsm_info(const struct acpi_spmc_softc *const sc, const int dsm_index)
{
        MPASS(0 <= dsm_index && dsm_index < nitems(dsms));
        return (&sc->dsms_info[dsm_index]);
}

static const uint64_t
get_supported_functions(const struct acpi_spmc_softc *const sc,
    const int dsm_index)
{
        return (get_const_dsm_info(sc, dsm_index)->supported_functions);
}

static const uint8_t
get_revision(const struct acpi_spmc_softc *const sc, const int dsm_index)
{
        return (get_const_dsm_info(sc, dsm_index)->revision);
}

static bool
supports_function_bitset(const uint64_t supported_functions,
    const int function_index)
{
        return ((supported_functions & IDX_TO_BIT(function_index)) != 0);
}

static bool
supports_function(const struct acpi_spmc_softc *const sc, const int dsm_index,
    const int function_index)
{
        return (supports_function_bitset(get_supported_functions(sc, dsm_index),
            function_index));
}

static bool
has_dsm_bitset(const uint64_t supported_functions)
{
        /* DSM is supported if bit DSM_ENUM_FUNCTIONS (0) is set. */
        return (supports_function_bitset(supported_functions,
            DSM_ENUM_FUNCTIONS));
}

static bool
has_dsm(const struct acpi_spmc_softc *const sc, const int dsm_index)
{
        return (has_dsm_bitset(get_supported_functions(sc, dsm_index)));
}

typedef const char *pbf_get_name_t(const int, const void *const);

static const char *
pbf_dsm_name(const int dsm_index, const void *const opaque __unused)
{
        return (resolve_dsm(dsm_index)->name);
}

static const char *
dsm_function_name(const struct dsm_desc *const dsm, const int function_index)
{
        MPASS(function_index >= 0);
        if (function_index >= dsm->function_names_nb)
                return (NULL);
        /* May be NULL. */
        return (dsm->function_names[function_index]);
}

static const char *
pbf_function_name(const int function_index, const void *const opaque)
{
        return (dsm_function_name(opaque, function_index));
}

static int
print_bit_field(char *const buf, const size_t buf_size,
    const uint64_t bit_field, const char *const fallback_prefix,
    pbf_get_name_t get_name, const void *const opaque)
{
        uint64_t bf = bit_field;
        char *const buf_end = buf + buf_size;
        char *p = buf;
        int ret = 0;
        bool one_set = false;

#define PBF_PRINT(...)                                                  \
        do {                                                            \
                const __ptrdiff_t rem = MAX(buf_end - p, 0);            \
                const int lret = snprintf(p, rem, __VA_ARGS__);         \
                                                                        \
                MPASS(lret >= 0);                                       \
                p += MIN(lret, rem);                                    \
                ret += lret;                                            \
        } while (0)

        if (bf == 0) {
                PBF_PRINT("");
                return (ret);
        }

        do {
                const int b_idx = ffsll(bf) - 1;
                const char *const name = get_name(b_idx, opaque);

                PBF_PRINT(one_set ? "," : "<");
                one_set = true;
                if (name != NULL)
                        PBF_PRINT("%s", name);
                else
                        PBF_PRINT("%s_%d", fallback_prefix, b_idx);

                bf &= ~IDX_TO_BIT(b_idx);
        } while (bf != 0);
        PBF_PRINT(">");
#undef PBF_PRINT

        return (ret);
}

static void
failed_to_call_dsm(const struct acpi_spmc_softc *const sc,
    const struct dsm_desc *const dsm, const int function_index)
{
        (void)device_printf(sc->dev,
            "Failed to call DSM %s (rev %u) function %s\n",
            dsm->name, get_revision(sc, dsm->index),
            dsm_function_name(dsm, function_index));
}

static void     acpi_spmc_probe_dsm(struct acpi_spmc_softc *const sc,
                    const struct dsm_desc *const dsm);
static void     acpi_spmc_dsm_print(
                    const struct acpi_spmc_softc *const sc,
                    const struct dsm_desc *const dsm);
static int      acpi_spmc_get_constraints(struct acpi_spmc_softc *const sc);
static void     acpi_spmc_free_constraints(struct acpi_spmc_softc *const sc);

static void     acpi_spmc_suspend(device_t dev, enum power_stype stype);
static void     acpi_spmc_resume(device_t dev, enum power_stype stype);

static int
acpi_spmc_probe(device_t dev)
{
        char *name;

        /* Check that this is an enabled device. */
        if (acpi_get_type(dev) != ACPI_TYPE_DEVICE || acpi_disabled("spmc"))
                return (ENXIO);

        if (ACPI_ID_PROBE(device_get_parent(dev), dev, spmc_ids, &name) > 0)
                return (ENXIO);

        device_set_desc(dev, "System Power Management Controller");

        return (BUS_PROBE_DEFAULT);
}

static int
acpi_spmc_attach(device_t dev)
{
        struct acpi_spmc_softc *const sc = device_get_softc(dev);
        const ACPI_HANDLE handle = acpi_get_handle(dev);
        int supported_dsms;
        char buf[32];
        int error;

        /*
         * ACPI_ID_PROBE() in acpi_spmc_probe() cannot succeed without a handle.
         */
        MPASS(handle != NULL);

        sc->dev = dev;
        sc->handle = handle;

        supported_dsms = 0;
        for (int i = 0; i < nitems(dsms); ++i) {
                KASSERT(dsms[i] != NULL, ("%s: Sparse dsms[]!", __func__));
                KASSERT(dsms[i]->index == i,
                    ("%s: Inconsistent indices for DSM %s", __func__,
                    dsms[i]->name));

                acpi_spmc_probe_dsm(sc, dsms[i]);
                if (has_dsm(sc, i))
                        supported_dsms |= IDX_TO_BIT(i);
        }

        if (supported_dsms == 0) {
                device_printf(dev, "No DSM supported!");
                return (ENXIO);
        }

        print_bit_field(buf, sizeof(buf), supported_dsms, "DSM",
            pbf_dsm_name, NULL);
        device_printf(dev, "DSMs supported: %s\n", buf);

        /* Print supported functions of usable DSMs. */
        for (int i = 0; i < nitems(dsms); ++i)
                if (has_dsm(sc, i))
                        acpi_spmc_dsm_print(sc, dsms[i]);

        /* Get device constraints. We can only call this once so do this now. */
        error = acpi_spmc_get_constraints(sc);
        if (error != 0)
                /* acpi_spmc_get_constraints() takes care of cleaning up. */
                device_printf(dev,
                    "Could not parse power state constraints (%d), "
                    "will not check for them before suspend\n", error);

        sc->eh_suspend = EVENTHANDLER_REGISTER(acpi_post_dev_suspend,
            acpi_spmc_suspend, dev, EVENTHANDLER_PRI_ANY);
        sc->eh_resume = EVENTHANDLER_REGISTER(acpi_pre_dev_resume,
            acpi_spmc_resume, dev, EVENTHANDLER_PRI_ANY);

        return (0);
}

static int
acpi_spmc_detach(device_t dev)
{
        struct acpi_spmc_softc *sc = device_get_softc(dev);

        EVENTHANDLER_DEREGISTER(acpi_post_dev_suspend, sc->eh_suspend);
        EVENTHANDLER_DEREGISTER(acpi_pre_dev_resume, sc->eh_resume);
        acpi_spmc_free_constraints(sc);
        return (0);
}

static uint64_t
dsm_missing_functions(const struct dsm_desc *const dsm,
    uint64_t supported_functions)
{
        return (dsm->expected_functions & ~supported_functions);
}

static void
acpi_spmc_dsm_print(const struct acpi_spmc_softc *const sc,
    const struct dsm_desc *const dsm)
{
        /*
         * Remove the enumeration function bit, which we do not care about when
         * printing which functions are supported and which we do not want to
         * report as unknown.
         */
        const uint64_t supported_functions = ~IDX_TO_BIT(DSM_ENUM_FUNCTIONS) &
            get_supported_functions(sc, dsm->index);
        const uint64_t missing = dsm_missing_functions(dsm, supported_functions);
        const uint64_t unknown = supported_functions &
            ~(dsm->expected_functions | dsm->extra_functions);
        char buf[128];

        print_bit_field(buf, sizeof(buf), supported_functions,
            "FUNC", pbf_function_name, dsm);
        device_printf(sc->dev,
            "DSM %s, revision %d: Supported functions: %#" PRIx64 "%s\n",
            dsm->name, get_revision(sc, dsm->index), supported_functions, buf);

        if (VERBOSE() && missing != 0) {
                print_bit_field(buf, sizeof(buf), missing, "FUNC",
                    pbf_function_name, dsm);
                device_printf(sc->dev, "DSM %s: Does not enumerate expected "
                    "functions %#" PRIx64 "%s.  Will skip calling them.\n",
                    dsm->name, missing, buf);
        }

        if (VERBOSE() && unknown != 0) {
                print_bit_field(buf, sizeof(buf), unknown, "FUNC",
                    pbf_function_name, dsm);
                device_printf(sc->dev, "DSM %s: Supports more functions than "
                    "used (%#" PRIx64 "%s), driver might need an upgrade.\n",
                    dsm->name, unknown, buf);
        }
}

/* Returns whether the DSM is supported (enumeration succeeds). */
static bool
probe_dsm_revision(const struct acpi_spmc_softc *const sc,
    const struct dsm_desc *const dsm, const uint8_t revision,
    uint64_t *const supported_functions)
{
        *supported_functions = acpi_DSMQuery(sc->handle,
            (const uint8_t *)&dsm->uuid, revision);
        return (has_dsm_bitset(*supported_functions));
}

static void
set_dsm_revision(struct acpi_spmc_softc *const sc,
    const struct dsm_desc *const dsm, const uint8_t revision,
    uint64_t supported_functions)
{
        struct dsm_info *const dsm_info = get_dsm_info(sc, dsm->index);

        MPASS(has_dsm_bitset(supported_functions));
        dsm_info->supported_functions = supported_functions;
        dsm_info->revision = revision;
}

static void
acpi_spmc_probe_dsm(struct acpi_spmc_softc *const sc,
    const struct dsm_desc *const dsm)
{
        const int8_t revision_spec = *dsm->revision_spec;
        uint64_t supported_functions;

        if (revision_spec >= 0) {
                /* Specific revision specified. */
                if (probe_dsm_revision(sc, dsm, revision_spec,
                    &supported_functions))
                        set_dsm_revision(sc, dsm, revision_spec,
                            supported_functions);
                return;
        }

        /*
         * Auto-detect.  We try revisions in ascending order, selecting the
         * first that has all the functions we expect in the hope to avoid potential
         * backwards-compatibility problems, else continuing with higher ones
         * but adopting them only if they actually add new functions (it seems
         * common that firmwares do not care about the revision, or will return
         * the same supported functions after a revision limit).
         */
        for (uint8_t revision = 0; revision <= -revision_spec; ++revision) {
                if (!probe_dsm_revision(sc, dsm, revision,
                    &supported_functions))
                        continue;
                if ((~get_supported_functions(sc, dsm->index) &
                    supported_functions) == 0)
                        /* This revision adds no new function, skip it. */
                        continue;

                set_dsm_revision(sc, dsm, revision, supported_functions);

                if (dsm_missing_functions(dsm, ~IDX_TO_BIT(DSM_ENUM_FUNCTIONS) &
                    supported_functions) == 0)
                        /* We have all expected functions, bail out. */
                        break;
        }
}

static void
acpi_spmc_free_constraints(struct acpi_spmc_softc *const sc)
{
        for (size_t i = 0; i < sc->constraint_count; i++)
                free(sc->constraints[i].name, M_TEMP);
        sc->constraint_count = 0;

        free(sc->constraints, M_TEMP);
        sc->constraints = NULL;
}

static int
acpi_spmc_parse_constraints_intel(struct acpi_spmc_softc *sc, ACPI_OBJECT *object)
{
        struct acpi_spmc_constraint *constraint;
        int             revision;
        ACPI_OBJECT     *constraint_obj;
        ACPI_OBJECT     *name_obj;
        ACPI_OBJECT     *detail;
        ACPI_OBJECT     *constraint_package;

        sc->constraint_count = object->Package.Count;
        sc->constraints = malloc(sc->constraint_count * sizeof *sc->constraints,
            M_TEMP, M_WAITOK | M_ZERO);

        /*
         * The value of sc->constraint_count can change during the loop, so
         * iterate until object->Package.Count so we actually go over all
         * elements in the package.
         */
        for (size_t i = 0; i < object->Package.Count; i++) {
                constraint_obj = &object->Package.Elements[i];
                constraint = &sc->constraints[i];

                constraint->enabled =
                    constraint_obj->Package.Elements[1].Integer.Value;

                name_obj = &constraint_obj->Package.Elements[0];
                constraint->name = strdup(name_obj->String.Pointer, M_TEMP);

                detail = &constraint_obj->Package.Elements[2];
                /*
                 * The first element in the device constraint detail package is
                 * the revision, and should always be zero.
                 */
                revision = detail->Package.Elements[0].Integer.Value;
                if (revision != 0) {
                        /* Only print this error message once if not verbose. */
                        if (VERBOSE() || sc->constraint_count ==
                            object->Package.Count)
                                device_printf(sc->dev,
                                    "Intel: Unknown revision %d for "
                                    "constraint %zu's detail package\n",
                                    revision, i);
                        sc->constraint_count--;
                        continue;
                }

                constraint_package = &detail->Package.Elements[1];

                constraint->lpi_uid =
                    constraint_package->Package.Elements[0].Integer.Value;
                constraint->min_d_state =
                    constraint_package->Package.Elements[1].Integer.Value;
                constraint->min_dev_specific_state =
                    constraint_package->Package.Elements[2].Integer.Value;
        }

        return (0);
}

static int
acpi_spmc_parse_constraints_amd(struct acpi_spmc_softc *sc, ACPI_OBJECT *object)
{
        size_t          constraint_count;
        ACPI_OBJECT     *constraint_obj;
        ACPI_OBJECT     *constraints;
        struct acpi_spmc_constraint *constraint;
        ACPI_OBJECT     *name_obj;

        /*
         * First element in the package is unknown.
         * Second element is the number of device constraints.
         * Third element is the list of device constraints itself.
         */
        constraint_count = object->Package.Elements[1].Integer.Value;
        constraints = &object->Package.Elements[2];

        if (constraints->Package.Count != constraint_count) {
                device_printf(sc->dev,
                    "AMD: Constraints: Count mismatch (%d to %zu)\n",
                    constraints->Package.Count, constraint_count);
                return (ENXIO);
        }

        sc->constraint_count = constraint_count;
        sc->constraints = malloc(constraint_count * sizeof *sc->constraints,
            M_TEMP, M_WAITOK | M_ZERO);

        for (size_t i = 0; i < constraint_count; i++) {
                /* Parse the constraint package. */
                constraint_obj = &constraints->Package.Elements[i];
                if (constraint_obj->Package.Count != 4) {
                        device_printf(sc->dev,
                            "AMD: Constraint %zu has %d elements, not 4\n",
                            i, constraint_obj->Package.Count);
                        acpi_spmc_free_constraints(sc);
                        return (ENXIO);
                }

                constraint = &sc->constraints[i];
                constraint->enabled =
                    constraint_obj->Package.Elements[0].Integer.Value;

                name_obj = &constraint_obj->Package.Elements[1];
                constraint->name = strdup(name_obj->String.Pointer, M_TEMP);

                constraint->function_states =
                    constraint_obj->Package.Elements[2].Integer.Value;
                constraint->min_d_state =
                    constraint_obj->Package.Elements[3].Integer.Value;
        }

        return (0);
}

static int
acpi_spmc_get_constraints(struct acpi_spmc_softc *const sc)
{
        const struct dsm_desc *dsm;
        ACPI_STATUS status;
        ACPI_BUFFER result;
        ACPI_OBJECT *object;
        int rv;
        struct acpi_spmc_constraint *constraint;


        MPASS(!sc->get_constraints_succeeded);
        /*
         * Constraints are not supported by the Microsoft DSM.  Since we do not
         * expect both Intel and AMD DSMs to be present at once, we only have
         * a single storage for common information ('min_d_state').  In case
         * some day both happen to be present, warn the user so that he can
         * report that condition to us, and somewhat arbitrarily favor the Intel
         * one because it at least has a written specification.
         */
        if (supports_function(sc, DSM_INTEL, DSM_GET_DEVICE_CONSTRAINTS)) {
                dsm = &dsm_intel;

                if (supports_function(sc, DSM_AMD, DSM_GET_DEVICE_CONSTRAINTS))
                        device_printf(sc->dev, "Constraints: Both Intel and "
                            "AMD DSMs support getting them!\n"
                            "Using constraints from Intel.\nPlease report.\n");
        } else if (supports_function(sc, DSM_AMD, DSM_GET_DEVICE_CONSTRAINTS))
                dsm = &dsm_amd;
        else
                return (0);

        /* It seems like this DSM can fail if called more than once. */
        status = acpi_EvaluateDSMTyped(sc->handle, (const uint8_t *)&dsm->uuid,
            get_revision(sc, dsm->index), DSM_GET_DEVICE_CONSTRAINTS, NULL,
            &result, ACPI_TYPE_PACKAGE);
        if (ACPI_FAILURE(status)) {
                failed_to_call_dsm(sc, dsm, DSM_GET_DEVICE_CONSTRAINTS);
                return (ENXIO);
        } else if (VERBOSE())
                device_printf(sc->dev, "Constraints: Retrieved successfully\n");

        object = (ACPI_OBJECT *)result.Pointer;
        if (dsm == &dsm_intel)
                rv = acpi_spmc_parse_constraints_intel(sc, object);
        else {
                MPASS(dsm == &dsm_amd);
                rv = acpi_spmc_parse_constraints_amd(sc, object);
        }
        AcpiOsFree(object);
        if (rv != 0)
                return (rv);

        /* Get handles for each constraint device. */
        for (size_t i = 0; i < sc->constraint_count; i++) {
                constraint = &sc->constraints[i];

                status = acpi_GetHandleInScope(sc->handle, constraint->name,
                    &constraint->handle);
                if (ACPI_FAILURE(status)) {
                        if (VERBOSE())
                                device_printf(sc->dev,
                                    "Constraints: Cannot get handle for %s, "
                                    "ignoring\n",
                                    constraint->name);
                        constraint->handle = NULL;
                }
        }

#ifdef INVARIANTS
        sc->get_constraints_succeeded = true;
#endif
        return (0);
}

static void
acpi_spmc_check_constraints(device_t dev)
{
        const struct acpi_spmc_softc *const sc = device_get_softc(dev);
#ifdef notyet
        bool violation = false;
#endif

        /*
         * Avoid printing that constraints are respected when there are no
         * constraints at all.
         */
        if (sc->constraint_count == 0)
                return;
        for (size_t i = 0; i < sc->constraint_count; i++) {
                const struct acpi_spmc_constraint *constraint =
                    &sc->constraints[i];

                if (!constraint->enabled)
                        continue;
                if (constraint->handle == NULL)
                        continue;

#ifdef notyet
                int d_state;
                if (ACPI_FAILURE(acpi_pwr_get_state(constraint->handle, &d_state)))
                        continue;
                if (d_state < constraint->min_d_state) {
                        device_printf(sc->dev, "Constraint for device %s"
                            " violated (current D-state: %s, "
                            "required minimum D-state: %s).\n"
                            constraint->name,
                            acpi_d_state_to_str(d_state),
                            acpi_d_state_to_str(constraint->min_d_state));
                        violation = true;
                }
#endif
        }
#ifdef notyet
        if (violation)
                device_printf(sc->dev, "Some constraints violated, "
                    "might fail to enter a Low-Power Idle state\n");
        else
                device_printf(sc->dev,
                    "All device power constraints respected!\n");
#endif
}

/*
 * Run a single DSM function.
 *
 * Only runs the function if it was reported present during enumeration.
 * Discards the result, but prints a message on error.
 */
static void
acpi_spmc_run(device_t dev, const struct dsm_desc *const dsm,
    const int function_index)
{
        const struct acpi_spmc_softc *const sc = device_get_softc(dev);
        ACPI_STATUS status;
        ACPI_BUFFER result;

        if (!(supports_function(sc, dsm->index, function_index) ||
            (force_call_expected_functions && has_dsm(sc, dsm->index))))
                return;

        if (VERBOSE())
                device_printf(dev, "DSM %s: Calling function %s\n",
                    dsm->name, dsm_function_name(dsm, function_index));
        status = acpi_EvaluateDSMTyped(sc->handle, (const uint8_t *)&dsm->uuid,
            get_revision(sc, dsm->index), function_index, NULL,
            &result, ACPI_TYPE_ANY);

        if (ACPI_FAILURE(status))
                failed_to_call_dsm(sc, dsm, function_index);
        else {
                if (VERBOSE())
                        device_printf(dev, "DSM %s: Function %s successful\n",
                            dsm->name, dsm_function_name(dsm, function_index));
                AcpiOsFree(result.Pointer);
        }
}

/*
 * Try running the functions from all the DSMs we have, as them failing costs us
 * nothing, and it seems like on AMD platforms, both the AMD entry and Microsoft
 * "modern" functions are required for it to enter modern standby.
 *
 * This is what Linux does too.
 */
static void
acpi_spmc_display_off_notif(device_t dev)
{
        acpi_spmc_run(dev, &dsm_intel, DSM_INTEL_MS_DISPLAY_OFF_NOTIF);
        acpi_spmc_run(dev, &dsm_ms, DSM_INTEL_MS_DISPLAY_OFF_NOTIF);
        acpi_spmc_run(dev, &dsm_amd, DSM_AMD_DISPLAY_OFF_NOTIF);
}

static void
acpi_spmc_display_on_notif(device_t dev)
{
        acpi_spmc_run(dev, &dsm_intel, DSM_INTEL_MS_DISPLAY_ON_NOTIF);
        acpi_spmc_run(dev, &dsm_ms, DSM_INTEL_MS_DISPLAY_ON_NOTIF);
        acpi_spmc_run(dev, &dsm_amd, DSM_AMD_DISPLAY_ON_NOTIF);
}

static void
acpi_spmc_entry_notif(device_t dev)
{
        /* XXX - No real check currently. Check return code when it does. */
        acpi_spmc_check_constraints(dev);

        acpi_spmc_run(dev, &dsm_amd, DSM_AMD_LPI_ENTRY_NOTIF);
        acpi_spmc_run(dev, &dsm_ms, DSM_MS_SLEEP_ENTRY_NOTIF);
        acpi_spmc_run(dev, &dsm_ms, DSM_INTEL_MS_LPI_ENTRY_NOTIF);
        acpi_spmc_run(dev, &dsm_intel, DSM_INTEL_MS_LPI_ENTRY_NOTIF);
}

static void
acpi_spmc_exit_notif(device_t dev)
{
        acpi_spmc_run(dev, &dsm_intel, DSM_INTEL_MS_LPI_EXIT_NOTIF);
        acpi_spmc_run(dev, &dsm_amd, DSM_AMD_LPI_EXIT_NOTIF);
        acpi_spmc_run(dev, &dsm_ms, DSM_INTEL_MS_LPI_EXIT_NOTIF);
        /* Hint to the platform we are soon going to turn on the display. */
        acpi_spmc_run(dev, &dsm_ms, DSM_MS_TURN_ON_DISPLAY);
        acpi_spmc_run(dev, &dsm_ms, DSM_MS_SLEEP_EXIT_NOTIF);
}

static void
acpi_spmc_suspend(device_t dev, enum power_stype stype)
{
        if (stype != POWER_STYPE_SUSPEND_TO_IDLE)
                return;

        acpi_spmc_display_off_notif(dev);
        acpi_spmc_entry_notif(dev);
}

static void
acpi_spmc_resume(device_t dev, enum power_stype stype)
{
        if (stype != POWER_STYPE_SUSPEND_TO_IDLE)
                return;

        acpi_spmc_exit_notif(dev);
        acpi_spmc_display_on_notif(dev);
}

static device_method_t acpi_spmc_methods[] = {
        DEVMETHOD(device_probe,         acpi_spmc_probe),
        DEVMETHOD(device_attach,        acpi_spmc_attach),
        DEVMETHOD(device_detach,        acpi_spmc_detach),
        DEVMETHOD_END
};

static driver_t acpi_spmc_driver = {
        "acpi_spmc",
        acpi_spmc_methods,
        sizeof(struct acpi_spmc_softc),
};

DRIVER_MODULE_ORDERED(acpi_spmc, acpi, acpi_spmc_driver, NULL, NULL, SI_ORDER_ANY);
MODULE_DEPEND(acpi_spmc, acpi, 1, 1, 1);