git: 506b36c4fdde - main - Revert "acpi: Use sleep types defined in sys/power.h"
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Thu, 18 Sep 2025 09:50:00 UTC
The branch main has been updated by obiwac:
URL: https://cgit.FreeBSD.org/src/commit/?id=506b36c4fdde0b402cc730b41a9d9d20130e1bca
commit 506b36c4fdde0b402cc730b41a9d9d20130e1bca
Author: Aymeric Wibo <obiwac@FreeBSD.org>
AuthorDate: 2025-09-18 09:45:36 +0000
Commit: Aymeric Wibo <obiwac@FreeBSD.org>
CommitDate: 2025-09-18 09:49:31 +0000
Revert "acpi: Use sleep types defined in sys/power.h"
This reverts commit ce5e22b28ef6caff3ffd228ac188114b08c0da02.
PR: 289634
---
sys/dev/acpica/acpi.c | 368 +++++++++++++++++-----------------------------
sys/dev/acpica/acpi_lid.c | 4 +-
sys/dev/acpica/acpivar.h | 15 +-
sys/x86/acpica/acpi_apm.c | 25 ++--
4 files changed, 158 insertions(+), 254 deletions(-)
diff --git a/sys/dev/acpica/acpi.c b/sys/dev/acpica/acpi.c
index 8dd879a573cc..574d3aacbcde 100644
--- a/sys/dev/acpica/acpi.c
+++ b/sys/dev/acpica/acpi.c
@@ -111,9 +111,8 @@ struct callout acpi_sleep_timer;
/* Bitmap of device quirks. */
int acpi_quirks;
-/* Supported sleep states and types. */
-static bool acpi_supported_stypes[POWER_STYPE_COUNT];
-static bool acpi_supported_sstates[ACPI_S_STATE_COUNT];
+/* Supported sleep states. */
+static BOOLEAN acpi_sleep_states[ACPI_S_STATE_COUNT];
static void acpi_lookup(void *arg, const char *name, device_t *dev);
static int acpi_modevent(struct module *mod, int event, void *junk);
@@ -170,27 +169,21 @@ static ACPI_STATUS acpi_probe_child(ACPI_HANDLE handle, UINT32 level,
void *context, void **status);
static void acpi_sleep_enable(void *arg);
static ACPI_STATUS acpi_sleep_disable(struct acpi_softc *sc);
-static ACPI_STATUS acpi_EnterSleepState(struct acpi_softc *sc,
- enum power_stype stype);
+static ACPI_STATUS acpi_EnterSleepState(struct acpi_softc *sc, int state);
static void acpi_shutdown_final(void *arg, int howto);
static void acpi_enable_fixed_events(struct acpi_softc *sc);
static void acpi_resync_clock(struct acpi_softc *sc);
-static int acpi_wake_sleep_prep(ACPI_HANDLE handle,
- enum power_stype stype);
-static int acpi_wake_run_prep(ACPI_HANDLE handle, enum power_stype stype);
-static int acpi_wake_prep_walk(enum power_stype stype);
+static int acpi_wake_sleep_prep(ACPI_HANDLE handle, int sstate);
+static int acpi_wake_run_prep(ACPI_HANDLE handle, int sstate);
+static int acpi_wake_prep_walk(int sstate);
static int acpi_wake_sysctl_walk(device_t dev);
static int acpi_wake_set_sysctl(SYSCTL_HANDLER_ARGS);
+static void acpi_system_eventhandler_sleep(void *arg, int state);
+static void acpi_system_eventhandler_wakeup(void *arg, int state);
+static int acpi_sname2sstate(const char *sname);
+static const char *acpi_sstate2sname(int sstate);
static int acpi_supported_sleep_state_sysctl(SYSCTL_HANDLER_ARGS);
-static void acpi_system_eventhandler_sleep(void *arg,
- enum power_stype stype);
-static void acpi_system_eventhandler_wakeup(void *arg,
- enum power_stype stype);
-static enum power_stype acpi_sstate_to_stype(int sstate);
-static int acpi_sname_to_sstate(const char *sname);
-static const char *acpi_sstate_to_sname(int sstate);
static int acpi_sleep_state_sysctl(SYSCTL_HANDLER_ARGS);
-static int acpi_stype_sysctl(SYSCTL_HANDLER_ARGS);
static int acpi_debug_objects_sysctl(SYSCTL_HANDLER_ARGS);
static int acpi_stype_to_sstate(struct acpi_softc *sc, enum power_stype stype);
static int acpi_pm_func(u_long cmd, void *arg, enum power_stype stype);
@@ -484,7 +477,6 @@ acpi_attach(device_t dev)
UINT32 flags;
UINT8 TypeA, TypeB;
char *env;
- enum power_stype stype;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
@@ -597,30 +589,31 @@ acpi_attach(device_t dev)
SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
OID_AUTO, "power_button_state",
CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE,
- &sc->acpi_power_button_stype, 0, acpi_stype_sysctl, "A",
+ &sc->acpi_power_button_sx, 0, acpi_sleep_state_sysctl, "A",
"Power button ACPI sleep state.");
SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
OID_AUTO, "sleep_button_state",
CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE,
- &sc->acpi_sleep_button_stype, 0, acpi_stype_sysctl, "A",
+ &sc->acpi_sleep_button_sx, 0, acpi_sleep_state_sysctl, "A",
"Sleep button ACPI sleep state.");
SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
OID_AUTO, "lid_switch_state",
CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE,
- &sc->acpi_lid_switch_stype, 0, acpi_stype_sysctl, "A",
- "Lid ACPI sleep state. Set to s2idle or s2mem if you want to suspend "
- "your laptop when close the lid.");
+ &sc->acpi_lid_switch_sx, 0, acpi_sleep_state_sysctl, "A",
+ "Lid ACPI sleep state. Set to S3 if you want to suspend your laptop when close the Lid.");
SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
OID_AUTO, "standby_state",
CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE,
- &sc->acpi_standby_sx, 0, acpi_sleep_state_sysctl, "A",
- "ACPI Sx state to use when going standby (S1 or S2).");
+ &sc->acpi_standby_sx, 0, acpi_sleep_state_sysctl, "A", "");
+ SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
+ OID_AUTO, "suspend_state",
+ CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE,
+ &sc->acpi_suspend_sx, 0, acpi_sleep_state_sysctl, "A", "");
SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
OID_AUTO, "sleep_delay", CTLFLAG_RW, &sc->acpi_sleep_delay, 0,
"sleep delay in seconds");
SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
- OID_AUTO, "s4bios", CTLFLAG_RW, &sc->acpi_s4bios, 0,
- "Use S4BIOS when hibernating.");
+ OID_AUTO, "s4bios", CTLFLAG_RW, &sc->acpi_s4bios, 0, "S4BIOS mode");
SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
OID_AUTO, "verbose", CTLFLAG_RW, &sc->acpi_verbose, 0, "verbose mode");
SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
@@ -666,38 +659,31 @@ acpi_attach(device_t dev)
sc->acpi_s4bios = 1;
#endif
- /*
- * Probe all supported ACPI sleep states. Awake (S0) is always supported.
- */
- acpi_supported_sstates[ACPI_STATE_S0] = TRUE;
- acpi_supported_stypes[POWER_STYPE_AWAKE] = true;
- for (state = ACPI_STATE_S1; state <= ACPI_STATE_S5; state++)
+ /* Probe all supported sleep states. */
+ acpi_sleep_states[ACPI_STATE_S0] = TRUE;
+ for (state = ACPI_STATE_S1; state < ACPI_S_STATE_COUNT; state++)
if (ACPI_SUCCESS(AcpiEvaluateObject(ACPI_ROOT_OBJECT,
__DECONST(char *, AcpiGbl_SleepStateNames[state]), NULL, NULL)) &&
- ACPI_SUCCESS(AcpiGetSleepTypeData(state, &TypeA, &TypeB))) {
- acpi_supported_sstates[state] = TRUE;
- acpi_supported_stypes[acpi_sstate_to_stype(state)] = true;
- }
+ ACPI_SUCCESS(AcpiGetSleepTypeData(state, &TypeA, &TypeB)))
+ acpi_sleep_states[state] = TRUE;
/*
- * Dispatch the default sleep type to devices. The lid switch is set
+ * Dispatch the default sleep state to devices. The lid switch is set
* to UNKNOWN by default to avoid surprising users.
*/
- sc->acpi_power_button_stype = acpi_supported_stypes[POWER_STYPE_POWEROFF] ?
- POWER_STYPE_POWEROFF : POWER_STYPE_UNKNOWN;
- sc->acpi_lid_switch_stype = POWER_STYPE_UNKNOWN;
-
- sc->acpi_standby_sx = ACPI_STATE_UNKNOWN;
- if (acpi_supported_sstates[ACPI_STATE_S1])
- sc->acpi_standby_sx = ACPI_STATE_S1;
- else if (acpi_supported_sstates[ACPI_STATE_S2])
- sc->acpi_standby_sx = ACPI_STATE_S2;
-
- /* Pick the first valid sleep type for the sleep button default. */
- sc->acpi_sleep_button_stype = POWER_STYPE_UNKNOWN;
- for (stype = POWER_STYPE_STANDBY; stype <= POWER_STYPE_HIBERNATE; stype++)
- if (acpi_supported_stypes[stype]) {
- sc->acpi_sleep_button_stype = stype;
+ sc->acpi_power_button_sx = acpi_sleep_states[ACPI_STATE_S5] ?
+ ACPI_STATE_S5 : ACPI_STATE_UNKNOWN;
+ sc->acpi_lid_switch_sx = ACPI_STATE_UNKNOWN;
+ sc->acpi_standby_sx = acpi_sleep_states[ACPI_STATE_S1] ?
+ ACPI_STATE_S1 : ACPI_STATE_UNKNOWN;
+ sc->acpi_suspend_sx = acpi_sleep_states[ACPI_STATE_S3] ?
+ ACPI_STATE_S3 : ACPI_STATE_UNKNOWN;
+
+ /* Pick the first valid sleep state for the sleep button default. */
+ sc->acpi_sleep_button_sx = ACPI_STATE_UNKNOWN;
+ for (state = ACPI_STATE_S1; state <= ACPI_STATE_S4; state++)
+ if (acpi_sleep_states[state]) {
+ sc->acpi_sleep_button_sx = state;
break;
}
@@ -722,7 +708,7 @@ acpi_attach(device_t dev)
/* Flag our initial states. */
sc->acpi_enabled = TRUE;
- sc->acpi_stype = POWER_STYPE_AWAKE;
+ sc->acpi_sstate = ACPI_STATE_S0;
sc->acpi_sleep_disabled = TRUE;
/* Create the control device */
@@ -782,36 +768,6 @@ acpi_stype_to_sstate(struct acpi_softc *sc, enum power_stype stype)
return (ACPI_STATE_UNKNOWN);
}
-/*
- * XXX It would be nice if we didn't need this function, but we'd need
- * acpi_EnterSleepState and acpi_ReqSleepState to take in actual ACPI S-states,
- * which won't be possible at the moment because suspend-to-idle (which is not
- * an ACPI S-state nor maps to one) will be implemented here.
- *
- * In the future, we should make generic a lot of the logic in these functions
- * to enable suspend-to-idle on non-ACPI builds, and then make
- * acpi_EnterSleepState and acpi_ReqSleepState truly take in ACPI S-states
- * again.
- */
-static enum power_stype
-acpi_sstate_to_stype(int sstate)
-{
- switch (sstate) {
- case ACPI_STATE_S0:
- return (POWER_STYPE_AWAKE);
- case ACPI_STATE_S1:
- case ACPI_STATE_S2:
- return (POWER_STYPE_STANDBY);
- case ACPI_STATE_S3:
- return (POWER_STYPE_SUSPEND_TO_MEM);
- case ACPI_STATE_S4:
- return (POWER_STYPE_HIBERNATE);
- case ACPI_STATE_S5:
- return (POWER_STYPE_POWEROFF);
- }
- return (POWER_STYPE_UNKNOWN);
-}
-
static void
acpi_set_power_children(device_t dev, int state)
{
@@ -2107,7 +2063,7 @@ acpi_device_pwr_for_sleep(device_t bus, device_t dev, int *dstate)
* Note illegal _S0D is evaluated because some systems expect this.
*/
sc = device_get_softc(bus);
- snprintf(sxd, sizeof(sxd), "_S%dD", acpi_stype_to_sstate(sc, sc->acpi_stype));
+ snprintf(sxd, sizeof(sxd), "_S%dD", sc->acpi_sstate);
status = acpi_GetInteger(handle, sxd, dstate);
if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
device_printf(dev, "failed to get %s on %s: %s\n", sxd,
@@ -3205,9 +3161,9 @@ acpi_sleep_force_task(void *context)
{
struct acpi_softc *sc = (struct acpi_softc *)context;
- if (ACPI_FAILURE(acpi_EnterSleepState(sc, sc->acpi_next_stype)))
- device_printf(sc->acpi_dev, "force sleep state %s failed\n",
- power_stype_to_name(sc->acpi_next_stype));
+ if (ACPI_FAILURE(acpi_EnterSleepState(sc, sc->acpi_next_sstate)))
+ device_printf(sc->acpi_dev, "force sleep state S%d failed\n",
+ sc->acpi_next_sstate);
}
static void
@@ -3234,24 +3190,24 @@ acpi_sleep_force(void *arg)
* acks are in.
*/
int
-acpi_ReqSleepState(struct acpi_softc *sc, enum power_stype stype)
+acpi_ReqSleepState(struct acpi_softc *sc, int state)
{
#if defined(__amd64__) || defined(__i386__)
struct apm_clone_data *clone;
ACPI_STATUS status;
- if (stype < POWER_STYPE_AWAKE || stype >= POWER_STYPE_COUNT)
+ if (state < ACPI_STATE_S1 || state > ACPI_S_STATES_MAX)
return (EINVAL);
- if (!acpi_supported_stypes[stype])
+ if (!acpi_sleep_states[state])
return (EOPNOTSUPP);
/*
* If a reboot/shutdown/suspend request is already in progress or
* suspend is blocked due to an upcoming shutdown, just return.
*/
- if (rebooting || sc->acpi_next_stype != POWER_STYPE_AWAKE ||
- suspend_blocked)
+ if (rebooting || sc->acpi_next_sstate != 0 || suspend_blocked) {
return (0);
+ }
/* Wait until sleep is enabled. */
while (sc->acpi_sleep_disabled) {
@@ -3260,12 +3216,12 @@ acpi_ReqSleepState(struct acpi_softc *sc, enum power_stype stype)
ACPI_LOCK(acpi);
- sc->acpi_next_stype = stype;
+ sc->acpi_next_sstate = state;
/* S5 (soft-off) should be entered directly with no waiting. */
- if (stype == POWER_STYPE_POWEROFF) {
+ if (state == ACPI_STATE_S5) {
ACPI_UNLOCK(acpi);
- status = acpi_EnterSleepState(sc, stype);
+ status = acpi_EnterSleepState(sc, state);
return (ACPI_SUCCESS(status) ? 0 : ENXIO);
}
@@ -3281,7 +3237,7 @@ acpi_ReqSleepState(struct acpi_softc *sc, enum power_stype stype)
/* If devd(8) is not running, immediately enter the sleep state. */
if (!devctl_process_running()) {
ACPI_UNLOCK(acpi);
- status = acpi_EnterSleepState(sc, stype);
+ status = acpi_EnterSleepState(sc, state);
return (ACPI_SUCCESS(status) ? 0 : ENXIO);
}
@@ -3296,7 +3252,7 @@ acpi_ReqSleepState(struct acpi_softc *sc, enum power_stype stype)
ACPI_UNLOCK(acpi);
/* Now notify devd(8) also. */
- acpi_UserNotify("Suspend", ACPI_ROOT_OBJECT, stype);
+ acpi_UserNotify("Suspend", ACPI_ROOT_OBJECT, state);
return (0);
#else
@@ -3319,17 +3275,17 @@ acpi_AckSleepState(struct apm_clone_data *clone, int error)
struct acpi_softc *sc;
int ret, sleeping;
- /* If no pending sleep type, return an error. */
+ /* If no pending sleep state, return an error. */
ACPI_LOCK(acpi);
sc = clone->acpi_sc;
- if (sc->acpi_next_stype == POWER_STYPE_AWAKE) {
+ if (sc->acpi_next_sstate == 0) {
ACPI_UNLOCK(acpi);
return (ENXIO);
}
/* Caller wants to abort suspend process. */
if (error) {
- sc->acpi_next_stype = POWER_STYPE_AWAKE;
+ sc->acpi_next_sstate = 0;
callout_stop(&sc->susp_force_to);
device_printf(sc->acpi_dev,
"listener on %s cancelled the pending suspend\n",
@@ -3359,7 +3315,7 @@ acpi_AckSleepState(struct apm_clone_data *clone, int error)
ACPI_UNLOCK(acpi);
ret = 0;
if (sleeping) {
- if (ACPI_FAILURE(acpi_EnterSleepState(sc, sc->acpi_next_stype)))
+ if (ACPI_FAILURE(acpi_EnterSleepState(sc, sc->acpi_next_sstate)))
ret = ENODEV;
}
return (ret);
@@ -3416,7 +3372,7 @@ enum acpi_sleep_state {
* Currently we support S1-S5 but S4 is only S4BIOS
*/
static ACPI_STATUS
-acpi_EnterSleepState(struct acpi_softc *sc, enum power_stype stype)
+acpi_EnterSleepState(struct acpi_softc *sc, int state)
{
register_t intr;
ACPI_STATUS status;
@@ -3426,11 +3382,11 @@ acpi_EnterSleepState(struct acpi_softc *sc, enum power_stype stype)
ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, state);
- if (stype <= POWER_STYPE_AWAKE || stype >= POWER_STYPE_COUNT)
+ if (state < ACPI_STATE_S1 || state > ACPI_S_STATES_MAX)
return_ACPI_STATUS (AE_BAD_PARAMETER);
- if (!acpi_supported_stypes[stype]) {
- device_printf(sc->acpi_dev, "Sleep type %s not supported on this "
- "platform\n", power_stype_to_name(stype));
+ if (!acpi_sleep_states[state]) {
+ device_printf(sc->acpi_dev, "Sleep state S%d not supported by BIOS\n",
+ state);
return (AE_SUPPORT);
}
@@ -3442,7 +3398,7 @@ acpi_EnterSleepState(struct acpi_softc *sc, enum power_stype stype)
return (status);
}
- if (stype == POWER_STYPE_POWEROFF) {
+ if (state == ACPI_STATE_S5) {
/*
* Shut down cleanly and power off. This will call us back through the
* shutdown handlers.
@@ -3470,16 +3426,16 @@ acpi_EnterSleepState(struct acpi_softc *sc, enum power_stype stype)
#endif
/*
- * Be sure to hold bus topology lock across DEVICE_SUSPEND/RESUME.
+ * Be sure to hold Giant across DEVICE_SUSPEND/RESUME
*/
bus_topo_lock();
slp_state = ACPI_SS_NONE;
- sc->acpi_stype = stype;
+ sc->acpi_sstate = state;
/* Enable any GPEs as appropriate and requested by the user. */
- acpi_wake_prep_walk(stype);
+ acpi_wake_prep_walk(state);
slp_state = ACPI_SS_GPE_SET;
/*
@@ -3496,7 +3452,7 @@ acpi_EnterSleepState(struct acpi_softc *sc, enum power_stype stype)
}
slp_state = ACPI_SS_DEV_SUSPEND;
- status = AcpiEnterSleepStatePrep(stype);
+ status = AcpiEnterSleepStatePrep(state);
if (ACPI_FAILURE(status)) {
device_printf(sc->acpi_dev, "AcpiEnterSleepStatePrep failed - %s\n",
AcpiFormatException(status));
@@ -3509,9 +3465,9 @@ acpi_EnterSleepState(struct acpi_softc *sc, enum power_stype stype)
suspendclock();
intr = intr_disable();
- if (stype != POWER_STYPE_STANDBY) {
- sleep_result = acpi_sleep_machdep(sc, stype);
- acpi_wakeup_machdep(sc, stype, sleep_result, 0);
+ if (state != ACPI_STATE_S1) {
+ sleep_result = acpi_sleep_machdep(sc, state);
+ acpi_wakeup_machdep(sc, state, sleep_result, 0);
/*
* XXX According to ACPI specification SCI_EN bit should be restored
@@ -3522,10 +3478,10 @@ acpi_EnterSleepState(struct acpi_softc *sc, enum power_stype stype)
* This hack is picked up from Linux, which claims that it follows
* Windows behavior.
*/
- if (sleep_result == 1 && stype != POWER_STYPE_HIBERNATE)
+ if (sleep_result == 1 && state != ACPI_STATE_S4)
AcpiWriteBitRegister(ACPI_BITREG_SCI_ENABLE, ACPI_ENABLE_EVENT);
- if (sleep_result == 1 && stype == POWER_STYPE_SUSPEND_TO_MEM) {
+ if (sleep_result == 1 && state == ACPI_STATE_S3) {
/*
* Prevent mis-interpretation of the wakeup by power button
* as a request for power off.
@@ -3551,20 +3507,20 @@ acpi_EnterSleepState(struct acpi_softc *sc, enum power_stype stype)
intr_restore(intr);
/* call acpi_wakeup_machdep() again with interrupt enabled */
- acpi_wakeup_machdep(sc, stype, sleep_result, 1);
+ acpi_wakeup_machdep(sc, state, sleep_result, 1);
- AcpiLeaveSleepStatePrep(stype);
+ AcpiLeaveSleepStatePrep(state);
if (sleep_result == -1)
goto backout;
- /* Re-enable ACPI hardware on wakeup from hibernate. */
- if (stype == POWER_STYPE_HIBERNATE)
+ /* Re-enable ACPI hardware on wakeup from sleep state 4. */
+ if (state == ACPI_STATE_S4)
AcpiEnable();
} else {
- status = AcpiEnterSleepState(stype);
+ status = AcpiEnterSleepState(state);
intr_restore(intr);
- AcpiLeaveSleepStatePrep(stype);
+ AcpiLeaveSleepStatePrep(state);
if (ACPI_FAILURE(status)) {
device_printf(sc->acpi_dev, "AcpiEnterSleepState failed - %s\n",
AcpiFormatException(status));
@@ -3581,13 +3537,13 @@ backout:
if (slp_state >= ACPI_SS_SLP_PREP)
resumeclock();
if (slp_state >= ACPI_SS_GPE_SET) {
- acpi_wake_prep_walk(stype);
- sc->acpi_stype = POWER_STYPE_AWAKE;
+ acpi_wake_prep_walk(state);
+ sc->acpi_sstate = ACPI_STATE_S0;
}
if (slp_state >= ACPI_SS_DEV_SUSPEND)
DEVICE_RESUME(root_bus);
if (slp_state >= ACPI_SS_SLP_PREP)
- AcpiLeaveSleepState(stype);
+ AcpiLeaveSleepState(state);
if (slp_state >= ACPI_SS_SLEPT) {
#if defined(__i386__) || defined(__amd64__)
/* NB: we are still using ACPI timecounter at this point. */
@@ -3596,7 +3552,7 @@ backout:
acpi_resync_clock(sc);
acpi_enable_fixed_events(sc);
}
- sc->acpi_next_stype = POWER_STYPE_AWAKE;
+ sc->acpi_next_sstate = 0;
bus_topo_unlock();
@@ -3622,7 +3578,7 @@ backout:
/* Run /etc/rc.resume after we are back. */
if (devctl_process_running())
- acpi_UserNotify("Resume", ACPI_ROOT_OBJECT, stype);
+ acpi_UserNotify("Resume", ACPI_ROOT_OBJECT, state);
return_ACPI_STATUS (status);
}
@@ -3673,21 +3629,16 @@ acpi_wake_set_enable(device_t dev, int enable)
}
static int
-acpi_wake_sleep_prep(ACPI_HANDLE handle, enum power_stype stype)
+acpi_wake_sleep_prep(ACPI_HANDLE handle, int sstate)
{
- int sstate;
struct acpi_prw_data prw;
device_t dev;
- struct acpi_softc *sc;
/* Check that this is a wake-capable device and get its GPE. */
if (acpi_parse_prw(handle, &prw) != 0)
return (ENXIO);
dev = acpi_get_device(handle);
- sc = device_get_softc(dev);
- sstate = acpi_stype_to_sstate(sc, stype);
-
/*
* The destination sleep state must be less than (i.e., higher power)
* or equal to the value specified by _PRW. If this GPE cannot be
@@ -3698,26 +3649,24 @@ acpi_wake_sleep_prep(ACPI_HANDLE handle, enum power_stype stype)
if (sstate > prw.lowest_wake) {
AcpiSetGpeWakeMask(prw.gpe_handle, prw.gpe_bit, ACPI_GPE_DISABLE);
if (bootverbose)
- device_printf(dev, "wake_prep disabled wake for %s (%s)\n",
- acpi_name(handle), power_stype_to_name(stype));
+ device_printf(dev, "wake_prep disabled wake for %s (S%d)\n",
+ acpi_name(handle), sstate);
} else if (dev && (acpi_get_flags(dev) & ACPI_FLAG_WAKE_ENABLED) != 0) {
acpi_pwr_wake_enable(handle, 1);
acpi_SetInteger(handle, "_PSW", 1);
if (bootverbose)
- device_printf(dev, "wake_prep enabled for %s (%s)\n",
- acpi_name(handle), power_stype_to_name(stype));
+ device_printf(dev, "wake_prep enabled for %s (S%d)\n",
+ acpi_name(handle), sstate);
}
return (0);
}
static int
-acpi_wake_run_prep(ACPI_HANDLE handle, enum power_stype stype)
+acpi_wake_run_prep(ACPI_HANDLE handle, int sstate)
{
- int sstate;
struct acpi_prw_data prw;
device_t dev;
- struct acpi_softc *sc;
/*
* Check that this is a wake-capable device and get its GPE. Return
@@ -3729,9 +3678,6 @@ acpi_wake_run_prep(ACPI_HANDLE handle, enum power_stype stype)
if (dev == NULL || (acpi_get_flags(dev) & ACPI_FLAG_WAKE_ENABLED) == 0)
return (0);
- sc = device_get_softc(dev);
- sstate = acpi_stype_to_sstate(sc, stype);
-
/*
* If this GPE couldn't be enabled for the previous sleep state, it was
* disabled before going to sleep so re-enable it. If it was enabled,
@@ -3755,26 +3701,26 @@ acpi_wake_run_prep(ACPI_HANDLE handle, enum power_stype stype)
static ACPI_STATUS
acpi_wake_prep(ACPI_HANDLE handle, UINT32 level, void *context, void **status)
{
- enum power_stype stype;
+ int sstate;
/* If suspending, run the sleep prep function, otherwise wake. */
- stype = *(enum power_stype *)context;
+ sstate = *(int *)context;
if (AcpiGbl_SystemAwakeAndRunning)
- acpi_wake_sleep_prep(handle, stype);
+ acpi_wake_sleep_prep(handle, sstate);
else
- acpi_wake_run_prep(handle, stype);
+ acpi_wake_run_prep(handle, sstate);
return (AE_OK);
}
/* Walk the tree rooted at acpi0 to prep devices for suspend/resume. */
static int
-acpi_wake_prep_walk(enum power_stype stype)
+acpi_wake_prep_walk(int sstate)
{
ACPI_HANDLE sb_handle;
if (ACPI_SUCCESS(AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SB_", &sb_handle)))
AcpiWalkNamespace(ACPI_TYPE_DEVICE, sb_handle, 100,
- acpi_wake_prep, NULL, &stype, NULL);
+ acpi_wake_prep, NULL, &sstate, NULL);
return (0);
}
@@ -3933,7 +3879,7 @@ out:
/* System Event Handlers (registered by EVENTHANDLER_REGISTER) */
static void
-acpi_system_eventhandler_sleep(void *arg, enum power_stype stype)
+acpi_system_eventhandler_sleep(void *arg, int state)
{
struct acpi_softc *sc = (struct acpi_softc *)arg;
int ret;
@@ -3941,27 +3887,23 @@ acpi_system_eventhandler_sleep(void *arg, enum power_stype stype)
ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, state);
/* Check if button action is disabled or unknown. */
- if (stype == ACPI_STATE_UNKNOWN)
+ if (state == ACPI_STATE_UNKNOWN)
return;
- /*
- * Request that the system prepare to enter the given suspend state. We can
- * totally pass an ACPI S-state to an enum power_stype.
- */
- ret = acpi_ReqSleepState(sc, stype);
+ /* Request that the system prepare to enter the given suspend state. */
+ ret = acpi_ReqSleepState(sc, state);
if (ret != 0)
device_printf(sc->acpi_dev,
- "request to enter state %s failed (err %d)\n",
- power_stype_to_name(stype), ret);
+ "request to enter state S%d failed (err %d)\n", state, ret);
return_VOID;
}
static void
-acpi_system_eventhandler_wakeup(void *arg, enum power_stype stype)
+acpi_system_eventhandler_wakeup(void *arg, int state)
{
- ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, stype);
+ ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, state);
/* Currently, nothing to do for wakeup. */
@@ -3975,14 +3917,14 @@ static void
acpi_invoke_sleep_eventhandler(void *context)
{
- EVENTHANDLER_INVOKE(acpi_sleep_event, *(enum power_stype *)context);
+ EVENTHANDLER_INVOKE(acpi_sleep_event, *(int *)context);
}
static void
acpi_invoke_wake_eventhandler(void *context)
{
- EVENTHANDLER_INVOKE(acpi_wakeup_event, *(enum power_stype *)context);
+ EVENTHANDLER_INVOKE(acpi_wakeup_event, *(int *)context);
}
UINT32
@@ -3998,7 +3940,7 @@ acpi_event_power_button_sleep(void *context)
#if defined(__amd64__) || defined(__i386__)
if (ACPI_FAILURE(AcpiOsExecute(OSL_NOTIFY_HANDLER,
- acpi_invoke_sleep_eventhandler, &sc->acpi_power_button_stype)))
+ acpi_invoke_sleep_eventhandler, &sc->acpi_power_button_sx)))
return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
#else
shutdown_nice(RB_POWEROFF);
@@ -4015,7 +3957,7 @@ acpi_event_power_button_wake(void *context)
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
if (ACPI_FAILURE(AcpiOsExecute(OSL_NOTIFY_HANDLER,
- acpi_invoke_wake_eventhandler, &sc->acpi_power_button_stype)))
+ acpi_invoke_wake_eventhandler, &sc->acpi_power_button_sx)))
return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
return_VALUE (ACPI_INTERRUPT_HANDLED);
}
@@ -4028,7 +3970,7 @@ acpi_event_sleep_button_sleep(void *context)
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
if (ACPI_FAILURE(AcpiOsExecute(OSL_NOTIFY_HANDLER,
- acpi_invoke_sleep_eventhandler, &sc->acpi_sleep_button_stype)))
+ acpi_invoke_sleep_eventhandler, &sc->acpi_sleep_button_sx)))
return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
return_VALUE (ACPI_INTERRUPT_HANDLED);
}
@@ -4041,7 +3983,7 @@ acpi_event_sleep_button_wake(void *context)
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
if (ACPI_FAILURE(AcpiOsExecute(OSL_NOTIFY_HANDLER,
- acpi_invoke_wake_eventhandler, &sc->acpi_sleep_button_stype)))
+ acpi_invoke_wake_eventhandler, &sc->acpi_sleep_button_sx)))
return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
return_VALUE (ACPI_INTERRUPT_HANDLED);
}
@@ -4237,8 +4179,7 @@ acpiioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *t
{
struct acpi_softc *sc;
struct acpi_ioctl_hook *hp;
- int error;
- int sstate;
+ int error, state;
error = 0;
hp = NULL;
@@ -4268,9 +4209,9 @@ acpiioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *t
/* Core system ioctls. */
switch (cmd) {
case ACPIIO_REQSLPSTATE:
- sstate = *(int *)addr;
- if (sstate != ACPI_STATE_S5)
- return (acpi_ReqSleepState(sc, acpi_sstate_to_stype(sstate)));
+ state = *(int *)addr;
+ if (state != ACPI_STATE_S5)
+ return (acpi_ReqSleepState(sc, state));
device_printf(sc->acpi_dev, "power off via acpi ioctl not supported\n");
error = EOPNOTSUPP;
break;
@@ -4279,12 +4220,12 @@ acpiioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *t
error = acpi_AckSleepState(sc->acpi_clone, error);
break;
case ACPIIO_SETSLPSTATE: /* DEPRECATED */
- sstate = *(int *)addr;
- if (sstate < ACPI_STATE_S0 || sstate > ACPI_STATE_S5)
+ state = *(int *)addr;
+ if (state < ACPI_STATE_S0 || state > ACPI_S_STATES_MAX)
return (EINVAL);
- if (!acpi_supported_sstates[sstate])
+ if (!acpi_sleep_states[state])
return (EOPNOTSUPP);
- if (ACPI_FAILURE(acpi_SetSleepState(sc, acpi_sstate_to_stype(sstate))))
+ if (ACPI_FAILURE(acpi_SetSleepState(sc, state)))
error = ENXIO;
break;
default:
@@ -4296,7 +4237,7 @@ acpiioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *t
}
static int
-acpi_sname_to_sstate(const char *sname)
+acpi_sname2sstate(const char *sname)
{
int sstate;
@@ -4311,15 +4252,14 @@ acpi_sname_to_sstate(const char *sname)
}
static const char *
-acpi_sstate_to_sname(int state)
+acpi_sstate2sname(int sstate)
{
- static const char *snames[ACPI_S_STATE_COUNT] = {"S0", "S1", "S2", "S3",
- "S4", "S5"};
+ static const char *snames[] = { "S0", "S1", "S2", "S3", "S4", "S5" };
- if (state == ACPI_STATE_UNKNOWN)
+ if (sstate >= ACPI_STATE_S0 && sstate <= ACPI_STATE_S5)
+ return (snames[sstate]);
+ else if (sstate == ACPI_STATE_UNKNOWN)
return ("NONE");
- if (state >= ACPI_STATE_S0 && state < ACPI_S_STATE_COUNT)
- return (snames[state]);
return (NULL);
}
@@ -4332,8 +4272,8 @@ acpi_supported_sleep_state_sysctl(SYSCTL_HANDLER_ARGS)
sbuf_new(&sb, NULL, 32, SBUF_AUTOEXTEND);
for (state = ACPI_STATE_S1; state < ACPI_S_STATE_COUNT; state++)
- if (acpi_supported_sstates[state])
- sbuf_printf(&sb, "%s ", acpi_sstate_to_sname(state));
+ if (acpi_sleep_states[state])
+ sbuf_printf(&sb, "%s ", acpi_sstate2sname(state));
sbuf_trim(&sb);
sbuf_finish(&sb);
error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
@@ -4341,64 +4281,27 @@ acpi_supported_sleep_state_sysctl(SYSCTL_HANDLER_ARGS)
return (error);
}
-
static int
acpi_sleep_state_sysctl(SYSCTL_HANDLER_ARGS)
{
char sleep_state[10];
- int error;
- int new_sstate, old_sstate;
+ int error, new_state, old_state;
- old_sstate = *(int *)oidp->oid_arg1;
- strlcpy(sleep_state, acpi_sstate_to_sname(old_sstate), sizeof(sleep_state));
+ old_state = *(int *)oidp->oid_arg1;
+ strlcpy(sleep_state, acpi_sstate2sname(old_state), sizeof(sleep_state));
error = sysctl_handle_string(oidp, sleep_state, sizeof(sleep_state), req);
if (error == 0 && req->newptr != NULL) {
- new_sstate = acpi_sname_to_sstate(sleep_state);
- if (new_sstate < 0)
+ new_state = acpi_sname2sstate(sleep_state);
+ if (new_state < ACPI_STATE_S1)
return (EINVAL);
- if (new_sstate < ACPI_S_STATE_COUNT &&
- !acpi_supported_sstates[new_sstate])
+ if (new_state < ACPI_S_STATE_COUNT && !acpi_sleep_states[new_state])
return (EOPNOTSUPP);
- if (new_sstate != old_sstate)
- *(int *)oidp->oid_arg1 = new_sstate;
+ if (new_state != old_state)
+ *(int *)oidp->oid_arg1 = new_state;
}
return (error);
}
-static int
-acpi_stype_sysctl(SYSCTL_HANDLER_ARGS)
-{
- char name[10];
- int err;
- int sstate;
- enum power_stype new_stype, old_stype;
-
- old_stype = *(enum power_stype *)oidp->oid_arg1;
- strlcpy(name, power_stype_to_name(old_stype), sizeof(name));
- err = sysctl_handle_string(oidp, name, sizeof(name), req);
- if (err != 0 || req->newptr == NULL)
- return (err);
-
- new_stype = power_name_to_stype(name);
- if (new_stype == POWER_STYPE_UNKNOWN) {
- sstate = acpi_sname_to_sstate(name);
- if (sstate < 0)
- return (EINVAL);
- printf("warning: this sysctl expects a sleep type, but an ACPI S-state has "
- "been passed to it. This functionality is deprecated; see acpi(4).\n");
- MPASS(sstate < ACPI_S_STATE_COUNT);
- if (acpi_supported_sstates[sstate] == false)
- return (EOPNOTSUPP);
- new_stype = acpi_sstate_to_stype(sstate);
- }
-
- if (acpi_supported_stypes[new_stype] == false)
- return (EOPNOTSUPP);
- if (new_stype != old_stype)
- *(enum power_stype *)oidp->oid_arg1 = new_stype;
- return (0);
-}
-
/* Inform devctl(4) when we receive a Notify. */
void
acpi_UserNotify(const char *subsystem, ACPI_HANDLE h, uint8_t notify)
@@ -4747,7 +4650,7 @@ acpi_reset_interfaces(device_t dev)
static int
acpi_pm_func(u_long cmd, void *arg, enum power_stype stype)
{
- int error;
+ int error, sstate;
struct acpi_softc *sc;
error = 0;
@@ -4758,7 +4661,8 @@ acpi_pm_func(u_long cmd, void *arg, enum power_stype stype)
error = EINVAL;
goto out;
}
- if (ACPI_FAILURE(acpi_EnterSleepState(sc, stype)))
+ sstate = acpi_stype_to_sstate(sc, stype);
+ if (ACPI_FAILURE(acpi_EnterSleepState(sc, sstate)))
error = ENXIO;
break;
default:
diff --git a/sys/dev/acpica/acpi_lid.c b/sys/dev/acpica/acpi_lid.c
index fb8755d9f0fe..142791f7282a 100644
--- a/sys/dev/acpica/acpi_lid.c
+++ b/sys/dev/acpica/acpi_lid.c
@@ -235,9 +235,9 @@ acpi_lid_notify_status_changed(void *arg)
sc->lid_status ? "opened" : "closed");
if (sc->lid_status == 0)
- EVENTHANDLER_INVOKE(acpi_sleep_event, acpi_sc->acpi_lid_switch_stype);
+ EVENTHANDLER_INVOKE(acpi_sleep_event, acpi_sc->acpi_lid_switch_sx);
else
- EVENTHANDLER_INVOKE(acpi_wakeup_event, acpi_sc->acpi_lid_switch_stype);
+ EVENTHANDLER_INVOKE(acpi_wakeup_event, acpi_sc->acpi_lid_switch_sx);
out:
ACPI_SERIAL_END(lid);
diff --git a/sys/dev/acpica/acpivar.h b/sys/dev/acpica/acpivar.h
index 4c789dd3e9f2..fac32d832598 100644
--- a/sys/dev/acpica/acpivar.h
+++ b/sys/dev/acpica/acpivar.h
@@ -54,19 +54,20 @@ struct acpi_softc {
struct cdev *acpi_dev_t;
int acpi_enabled;
- enum power_stype acpi_stype;
+ int acpi_sstate;
int acpi_sleep_disabled;
struct sysctl_ctx_list acpi_sysctl_ctx;
struct sysctl_oid *acpi_sysctl_tree;
- enum power_stype acpi_power_button_stype;
- enum power_stype acpi_sleep_button_stype;
- enum power_stype acpi_lid_switch_stype;
+ int acpi_power_button_sx;
+ int acpi_sleep_button_sx;
+ int acpi_lid_switch_sx;
int acpi_standby_sx;
- int acpi_s4bios;
+ int acpi_suspend_sx;
int acpi_sleep_delay;
+ int acpi_s4bios;
int acpi_do_disable;
int acpi_verbose;
int acpi_handle_reboot;
@@ -74,7 +75,7 @@ struct acpi_softc {
vm_offset_t acpi_wakeaddr;
vm_paddr_t acpi_wakephys;
- enum power_stype acpi_next_stype; /* Next suspend sleep type. */
+ int acpi_next_sstate; /* Next suspend Sx state. */
struct apm_clone_data *acpi_clone; /* Pseudo-dev for devd(8). */
STAILQ_HEAD(,apm_clone_data) apm_cdevs; /* All apm/apmctl/acpi cdevs. */
struct callout susp_force_to; /* Force suspend if no acks. */
@@ -411,7 +412,7 @@ ACPI_STATUS acpi_EvaluateOSC(ACPI_HANDLE handle, uint8_t *uuid,
uint32_t *caps_out, bool query);
ACPI_STATUS acpi_OverrideInterruptLevel(UINT32 InterruptNumber);
ACPI_STATUS acpi_SetIntrModel(int model);
-int acpi_ReqSleepState(struct acpi_softc *sc, enum power_stype stype);
+int acpi_ReqSleepState(struct acpi_softc *sc, int state);
int acpi_AckSleepState(struct apm_clone_data *clone, int error);
ACPI_STATUS acpi_SetSleepState(struct acpi_softc *sc, int state);
int acpi_wake_set_enable(device_t dev, int enable);
diff --git a/sys/x86/acpica/acpi_apm.c b/sys/x86/acpica/acpi_apm.c
index 8e5785cf0ed6..be161cd6171b 100644
--- a/sys/x86/acpica/acpi_apm.c
+++ b/sys/x86/acpica/acpi_apm.c
@@ -235,7 +235,7 @@ apmdtor(void *data)
acpi_sc = clone->acpi_sc;
/* We are about to lose a reference so check if suspend should occur */
- if (acpi_sc->acpi_next_stype != POWER_STYPE_AWAKE &&
+ if (acpi_sc->acpi_next_sstate != 0 &&
clone->notify_status != APM_EV_ACKED)
acpi_AckSleepState(clone, 0);
@@ -283,10 +283,10 @@ apmioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td
case APMIO_SUSPEND:
if ((flag & FWRITE) == 0)
return (EPERM);
- if (acpi_sc->acpi_next_stype == POWER_STYPE_AWAKE) {
- if (power_suspend_stype != POWER_STYPE_POWEROFF) {
+ if (acpi_sc->acpi_next_sstate == 0) {
+ if (acpi_sc->acpi_suspend_sx != ACPI_STATE_S5) {
error = acpi_ReqSleepState(acpi_sc,
- power_suspend_stype);
+ acpi_sc->acpi_suspend_sx);
} else {
printf(
"power off via apm suspend not supported\n");
@@ -298,10 +298,10 @@ apmioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td
case APMIO_STANDBY:
if ((flag & FWRITE) == 0)
return (EPERM);
- if (acpi_sc->acpi_next_stype == POWER_STYPE_AWAKE) {
- if (power_standby_stype != POWER_STYPE_POWEROFF) {
+ if (acpi_sc->acpi_next_sstate == 0) {
+ if (acpi_sc->acpi_standby_sx != ACPI_STATE_S5) {
error = acpi_ReqSleepState(acpi_sc,
- power_standby_stype);
+ acpi_sc->acpi_standby_sx);
} else {
printf(
"power off via apm standby not supported\n");
@@ -313,11 +313,10 @@ apmioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td
case APMIO_NEXTEVENT:
printf("apm nextevent start\n");
ACPI_LOCK(acpi);
- if (acpi_sc->acpi_next_stype != POWER_STYPE_AWAKE &&
- clone->notify_status == APM_EV_NONE) {
+ if (acpi_sc->acpi_next_sstate != 0 && clone->notify_status ==
+ APM_EV_NONE) {
ev_info = (struct apm_event_info *)addr;
- /* XXX Check this. */
- if (acpi_sc->acpi_next_stype == POWER_STYPE_STANDBY)
+ if (acpi_sc->acpi_next_sstate <= ACPI_STATE_S3)
ev_info->type = PMEV_STANDBYREQ;
else
ev_info->type = PMEV_SUSPENDREQ;
@@ -393,7 +392,7 @@ apmpoll(struct cdev *dev, int events, struct thread *td)
revents = 0;
devfs_get_cdevpriv((void **)&clone);
ACPI_LOCK(acpi);
- if (clone->acpi_sc->acpi_next_stype != POWER_STYPE_AWAKE)
*** 13 LINES SKIPPED ***