#include <uacpi/types.h>
#include <uacpi/status.h>
#include <uacpi/uacpi.h>

Include dependency graph for sleep.h:

This graph shows which files directly or indirectly include this file:

Variables
	uacpi_sleep_state

Function Documentation

◆ UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE()

UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE ( uacpi_status uacpi_set_waking_vector uacpi_phys_addr addr32, uacpi_phys_addr addr64 )

Set the firmware waking vector in FACS.

'addr32' is the real mode entry-point address 'addr64' is the protected mode entry-point address

Definition at line 19 of file sleep.h.

                               {
    UACPI_SLEEP_STATE_S0 = 0,
    UACPI_SLEEP_STATE_S1,
    UACPI_SLEEP_STATE_S2,
    UACPI_SLEEP_STATE_S3,
    UACPI_SLEEP_STATE_S4,
    UACPI_SLEEP_STATE_S5,
    UACPI_SLEEP_STATE_MAX = UACPI_SLEEP_STATE_S5,
} uacpi_sleep_state;

◆ uacpi_enter_sleep_state()

uacpi_status uacpi_enter_sleep_state ( uacpi_sleep_state state_enum )

Enter the given sleep state after preparation.

Definition at line 499 of file sleep.c.

{
    uacpi_u8 state = state_enum;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
 
    if (uacpi_unlikely(state > UACPI_SLEEP_STATE_MAX))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    if (uacpi_unlikely(g_uacpi_rt_ctx.last_sleep_typ_a > ACPI_SLP_TYP_MAX ||
                       g_uacpi_rt_ctx.last_sleep_typ_b > ACPI_SLP_TYP_MAX)) {
        uacpi_error("invalid SLP_TYP values: 0x%02X:0x%02X",
                    g_uacpi_rt_ctx.last_sleep_typ_a,
                    g_uacpi_rt_ctx.last_sleep_typ_b);
        return UACPI_STATUS_AML_BAD_ENCODING;
    }
 
    return CALL_SLEEP_FN(enter_sleep_state, state);
}

Referenced by uacpi_enter_sleep_state_simple().

◆ uacpi_enter_sleep_state_simple()

uacpi_status uacpi_enter_sleep_state_simple ( uacpi_sleep_state state )

Prepare & enter a given sleep state May be used as a shortcut if the kernel doesn't have any other work to do inbetween calling the two separate helpers

Definition at line 519 of file sleep.c.

{
    uacpi_status ret;
 
    ret = uacpi_prepare_for_sleep_state(state);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return uacpi_enter_sleep_state(state);
}

◆ uacpi_prepare_for_sleep_state()

uacpi_status uacpi_prepare_for_sleep_state ( uacpi_sleep_state state_enum )

Prepare for a given sleep state.

Definition at line 364 of file sleep.c.

{
    uacpi_u8 state = state_enum;
    uacpi_status ret;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
 
    if (uacpi_unlikely(state > UACPI_SLEEP_STATE_S5))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    ret = get_slp_type_for_state(
        state,
        &g_uacpi_rt_ctx.last_sleep_typ_a,
        &g_uacpi_rt_ctx.last_sleep_typ_b
    );
    if (ret != UACPI_STATUS_OK)
        return ret;
 
    ret = get_slp_type_for_state(
        0,
        &g_uacpi_rt_ctx.s0_sleep_typ_a,
        &g_uacpi_rt_ctx.s0_sleep_typ_b
    );
 
    ret = eval_pts(state);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    eval_sst_for_state(state);
    return UACPI_STATUS_OK;
}

Referenced by uacpi_enter_sleep_state_simple().

◆ uacpi_prepare_for_wake_from_sleep_state()

uacpi_status uacpi_prepare_for_wake_from_sleep_state ( uacpi_sleep_state state_enum )

Prepare to leave the given sleep state.

Definition at line 530 of file sleep.c.

{
    uacpi_u8 state = state_enum;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
 
    if (uacpi_unlikely(state > UACPI_SLEEP_STATE_MAX))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    return CALL_SLEEP_FN(prepare_for_wake_from_sleep_state, state);
}

◆ uacpi_reboot()

uacpi_status uacpi_reboot ( void )

Attempt reset via the FADT reset register.

Definition at line 558 of file sleep.c.

{
    uacpi_status ret;
    uacpi_handle pci_dev = UACPI_NULL, io_handle = UACPI_NULL;
    struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
    struct acpi_gas *reset_reg = &fadt->reset_reg;
 
    /*
     * Allow restarting earlier than namespace load so that the kernel can
     * use this in case of some initialization error.
     */
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
 
    if (!(fadt->flags & ACPI_RESET_REG_SUP) || !reset_reg->address)
        return UACPI_STATUS_NOT_FOUND;
 
    switch (reset_reg->address_space_id) {
    case UACPI_ADDRESS_SPACE_SYSTEM_IO:
        /*
         * For SystemIO we don't do any checking, and we ignore bit width
         * because that's what NT does.
         */
        ret = uacpi_kernel_io_map(reset_reg->address, 1, &io_handle);
        if (uacpi_unlikely_error(ret))
            return ret;
 
        ret = uacpi_kernel_io_write8(io_handle, 0, fadt->reset_value);
        break;
    case UACPI_ADDRESS_SPACE_SYSTEM_MEMORY:
        ret = uacpi_write_register(UACPI_REGISTER_RESET, fadt->reset_value);
        break;
    case UACPI_ADDRESS_SPACE_PCI_CONFIG: {
        uacpi_pci_address address = { 0 };
 
        // Bus is assumed to be 0 here
        address.segment = 0;
        address.bus = 0;
        address.device = (reset_reg->address >> 32) & 0xFF;
        address.function = (reset_reg->address >> 16) & 0xFF;
 
        ret = uacpi_kernel_pci_device_open(address, &pci_dev);
        if (uacpi_unlikely_error(ret))
            break;
 
        ret = uacpi_kernel_pci_write8(
            pci_dev, reset_reg->address & 0xFFFF, fadt->reset_value
        );
        break;
    }
    default:
        uacpi_warn(
            "unable to perform a reset: unsupported address space '%s' (%d)",
            uacpi_address_space_to_string(reset_reg->address_space_id),
            reset_reg->address_space_id
        );
        ret = UACPI_STATUS_UNIMPLEMENTED;
    }
 
    if (ret == UACPI_STATUS_OK) {
        /*
         * This should've worked but we're still here.
         * Spin for a bit then give up.
         */
        uacpi_u64 stalled_time = 0;
 
        while (stalled_time < (1000 * 1000)) {
            uacpi_kernel_stall(100);
            stalled_time += 100;
        }
 
        uacpi_error("reset timeout");
        ret = UACPI_STATUS_HARDWARE_TIMEOUT;
    }
 
    if (pci_dev != UACPI_NULL)
        uacpi_kernel_pci_device_close(pci_dev);
    if (io_handle != UACPI_NULL)
        uacpi_kernel_io_unmap(io_handle);
 
    return ret;
}

◆ uacpi_wake_from_sleep_state()

uacpi_status uacpi_wake_from_sleep_state ( uacpi_sleep_state state_enum )

Wake from the given sleep state.

Note that this discards a pending press of the power & sleep buttons, as that is most likely what has woken the system up, and enables the fixed event of either one if it has a handler installed. The latter is the case even if the event was disabled via uacpi_disable_fixed_event prior to going to sleep.

Definition at line 544 of file sleep.c.

{
    uacpi_u8 state = state_enum;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
 
    if (uacpi_unlikely(state > UACPI_SLEEP_STATE_MAX))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    return CALL_SLEEP_FN(wake_from_sleep_state, state);
}

Variable Documentation

◆ uacpi_sleep_state

uacpi_sleep_state

Definition at line 32 of file sleep.h.

Functions
	UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE (uacpi_status uacpi_set_waking_vector(uacpi_phys_addr addr32, uacpi_phys_addr addr64)) typedef enum uacpi_sleep_state

uacpi_status	uacpi_prepare_for_sleep_state (uacpi_sleep_state)

uacpi_status	uacpi_enter_sleep_state (uacpi_sleep_state)

uacpi_status	uacpi_enter_sleep_state_simple (uacpi_sleep_state)

uacpi_status	uacpi_prepare_for_wake_from_sleep_state (uacpi_sleep_state)

uacpi_status	uacpi_wake_from_sleep_state (uacpi_sleep_state)

uacpi_status	uacpi_reboot (void)

Functions

Variables