registers.c File Reference

#include <uacpi/internal/registers.h>
#include <uacpi/internal/stdlib.h>
#include <uacpi/internal/context.h>
#include <uacpi/internal/io.h>
#include <uacpi/internal/log.h>
#include <uacpi/platform/atomic.h>
#include <uacpi/acpi.h>

Include dependency graph for registers.c:

Go to the source code of this file.

Classes
struct	register_spec
struct	register_mapping
struct	register_field

Enumerations
enum	register_kind { REGISTER_KIND_GAS , REGISTER_KIND_IO }
enum	register_access_kind { REGISTER_ACCESS_KIND_PRESERVE , REGISTER_ACCESS_KIND_WRITE_TO_CLEAR , REGISTER_ACCESS_KIND_NORMAL }
enum	register_mapping_state { REGISTER_MAPPING_STATE_NONE = 0 , REGISTER_MAPPING_STATE_NOT_NEEDED , REGISTER_MAPPING_STATE_MAPPED }

Functions
static uacpi_status	map_one (const struct register_spec *spec, struct register_mapping *mapping, uacpi_u8 idx)
static uacpi_status	ensure_register_mapped (const struct register_spec *spec, struct register_mapping *mapping)
static uacpi_status	get_reg (uacpi_u8 idx, const struct register_spec **out_spec, struct register_mapping **out_mapping)
static uacpi_status	do_read_one (struct register_mapping *mapping, uacpi_u8 idx, uacpi_u64 *out_value)
static uacpi_status	do_read_register (const struct register_spec *reg, struct register_mapping *mapping, uacpi_u64 *out_value)
uacpi_status	uacpi_read_register (enum uacpi_register reg_enum, uacpi_u64 *out_value)
static uacpi_status	do_write_one (struct register_mapping *mapping, uacpi_u8 idx, uacpi_u64 in_value)
static uacpi_status	do_write_register (const struct register_spec *reg, struct register_mapping *mapping, uacpi_u64 in_value)
uacpi_status	uacpi_write_register (enum uacpi_register reg_enum, uacpi_u64 in_value)
uacpi_status	uacpi_write_registers (enum uacpi_register reg_enum, uacpi_u64 in_value0, uacpi_u64 in_value1)
uacpi_status	uacpi_initialize_registers (void)
void	uacpi_deinitialize_registers (void)
uacpi_status	uacpi_read_register_field (enum uacpi_register_field field_enum, uacpi_u64 *out_value)
uacpi_status	uacpi_write_register_field (enum uacpi_register_field field_enum, uacpi_u64 in_value)

Variables
static uacpi_handle	g_reg_lock
static const struct register_spec	g_registers [UACPI_REGISTER_MAX+1]
static struct register_mapping	g_register_mappings [UACPI_REGISTER_MAX+1]
static const struct register_field	g_fields [UACPI_REGISTER_FIELD_MAX+1]

Enumeration Type Documentation

register_access_kind

enum register_access_kind

Enumerator
REGISTER_ACCESS_KIND_PRESERVE
REGISTER_ACCESS_KIND_WRITE_TO_CLEAR
REGISTER_ACCESS_KIND_NORMAL

Definition at line 18 of file registers.c.

                          {
    REGISTER_ACCESS_KIND_PRESERVE,
    REGISTER_ACCESS_KIND_WRITE_TO_CLEAR,
    REGISTER_ACCESS_KIND_NORMAL,
};

register_kind

enum register_kind

Enumerator
REGISTER_KIND_GAS
REGISTER_KIND_IO

Definition at line 13 of file registers.c.

                   {
    REGISTER_KIND_GAS,
    REGISTER_KIND_IO,
};

register_mapping_state

enum register_mapping_state

Enumerator
REGISTER_MAPPING_STATE_NONE
REGISTER_MAPPING_STATE_NOT_NEEDED
REGISTER_MAPPING_STATE_MAPPED

Definition at line 99 of file registers.c.

                            {
   REGISTER_MAPPING_STATE_NONE = 0,
   REGISTER_MAPPING_STATE_NOT_NEEDED,
   REGISTER_MAPPING_STATE_MAPPED,
};

Function Documentation

do_read_one()

static uacpi_status do_read_one ( struct register_mapping *  mapping, uacpi_u8  idx, uacpi_u64 *  out_value  )

static

Definition at line 194 of file registers.c.

{
    if (mapping->states[idx] != REGISTER_MAPPING_STATE_MAPPED)
        return UACPI_STATUS_OK;
 
    return uacpi_gas_read_mapped(&mapping->mappings[idx], out_value);
}

Referenced by do_read_register().

do_read_register()

static uacpi_status do_read_register ( const struct register_spec *  reg, struct register_mapping *  mapping, uacpi_u64 *  out_value  )

static

Definition at line 204 of file registers.c.

{
    uacpi_status ret;
    uacpi_u64 value0 = 0, value1 = 0;
 
    ret = do_read_one(mapping, 0, &value0);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = do_read_one(mapping, 1, &value1);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    *out_value = value0 | value1;
    if (reg->write_only_mask)
        *out_value &= ~reg->write_only_mask;
 
    return UACPI_STATUS_OK;
}

Referenced by do_write_register(), uacpi_read_register(), uacpi_read_register_field(), and uacpi_write_register_field().

do_write_one()

static uacpi_status do_write_one ( struct register_mapping *  mapping, uacpi_u8  idx, uacpi_u64  in_value  )

static

Definition at line 248 of file registers.c.

{
    if (mapping->states[idx] != REGISTER_MAPPING_STATE_MAPPED)
        return UACPI_STATUS_OK;
 
    return uacpi_gas_write_mapped(&mapping->mappings[idx], in_value);
}

Referenced by do_write_register(), and uacpi_write_registers().

do_write_register()

static uacpi_status do_write_register ( const struct register_spec *  reg, struct register_mapping *  mapping, uacpi_u64  in_value  )

static

Definition at line 258 of file registers.c.

{
    uacpi_status ret;
 
    if (reg->preserve_mask) {
        in_value &= ~reg->preserve_mask;
 
        if (reg->access_kind == REGISTER_ACCESS_KIND_PRESERVE) {
            uacpi_u64 data;
 
            ret = do_read_register(reg, mapping, &data);
            if (uacpi_unlikely_error(ret))
                return ret;
 
            in_value |= data & reg->preserve_mask;
        }
    }
 
    ret = do_write_one(mapping, 0, in_value);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return do_write_one(mapping, 1, in_value);
}

Referenced by uacpi_write_register(), and uacpi_write_register_field().

ensure_register_mapped()

static uacpi_status ensure_register_mapped ( const struct register_spec *  spec, struct register_mapping *  mapping  )

static

Definition at line 151 of file registers.c.

{
    uacpi_status ret;
    uacpi_bool needs_mapping = UACPI_FALSE;
    uacpi_u8 state;
    uacpi_cpu_flags flags;
 
    state = uacpi_atomic_load8(&mapping->states[0]);
    needs_mapping |= state == REGISTER_MAPPING_STATE_NONE;
 
    state = uacpi_atomic_load8(&mapping->states[1]);
    needs_mapping |= state == REGISTER_MAPPING_STATE_NONE;
 
    if (!needs_mapping)
        return UACPI_STATUS_OK;
 
    flags = uacpi_kernel_lock_spinlock(g_reg_lock);
 
    ret = map_one(spec, mapping, 0);
    if (uacpi_unlikely_error(ret))
        goto out;
 
    ret = map_one(spec, mapping, 1);
out:
    uacpi_kernel_unlock_spinlock(g_reg_lock, flags);
    return ret;
}

Referenced by uacpi_read_register(), uacpi_read_register_field(), uacpi_write_register(), uacpi_write_register_field(), and uacpi_write_registers().

get_reg()

static uacpi_status get_reg ( uacpi_u8  idx, const struct register_spec **  out_spec, struct register_mapping **  out_mapping  )

static

Definition at line 181 of file registers.c.

{
    if (idx > UACPI_REGISTER_MAX)
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    *out_spec = &g_registers[idx];
    *out_mapping = &g_register_mappings[idx];
    return UACPI_STATUS_OK;
}

Referenced by uacpi_read_register(), uacpi_write_register(), and uacpi_write_registers().

map_one()

static uacpi_status map_one ( const struct register_spec *  spec, struct register_mapping *  mapping, uacpi_u8  idx  )

static

Definition at line 111 of file registers.c.

{
    uacpi_status ret = UACPI_STATUS_OK;
 
    if (mapping->states[idx] != REGISTER_MAPPING_STATE_NONE)
        return ret;
 
    if (spec->kind == REGISTER_KIND_GAS) {
        struct acpi_gas *gas = spec->accessors[idx];
 
        if (gas == UACPI_NULL || gas->address == 0) {
            mapping->states[idx] = REGISTER_MAPPING_STATE_NOT_NEEDED;
            return ret;
        }
 
        ret = uacpi_map_gas_noalloc(gas, &mapping->mappings[idx]);
    } else {
        if (idx != 0) {
            mapping->states[idx] = REGISTER_MAPPING_STATE_NOT_NEEDED;
            return ret;
        }
 
        struct acpi_gas temp_gas = {
            .address_space_id = UACPI_ADDRESS_SPACE_SYSTEM_IO,
            .address = *(uacpi_u32*)spec->accessors[0],
            .register_bit_width = spec->access_width * 8,
        };
 
        ret = uacpi_map_gas_noalloc(&temp_gas, &mapping->mappings[idx]);
    }
 
    if (uacpi_likely_success(ret))
        mapping->states[idx] = REGISTER_MAPPING_STATE_MAPPED;
 
    return ret;
}

Referenced by ensure_register_mapped().

uacpi_deinitialize_registers()

void uacpi_deinitialize_registers

(

void

)

Definition at line 465 of file registers.c.

{
    uacpi_u8 i;
    struct register_mapping *mapping;
 
    if (g_reg_lock != UACPI_NULL) {
        uacpi_kernel_free_spinlock(g_reg_lock);
        g_reg_lock = UACPI_NULL;
    }
 
    for (i = 0; i <= UACPI_REGISTER_MAX; ++i) {
        mapping = &g_register_mappings[i];
 
        if (mapping->states[0] == REGISTER_MAPPING_STATE_MAPPED)
            uacpi_unmap_gas_nofree(&mapping->mappings[0]);
        if (mapping->states[1] == REGISTER_MAPPING_STATE_MAPPED)
            uacpi_unmap_gas_nofree(&mapping->mappings[1]);
    }
 
    uacpi_memzero(&g_register_mappings, sizeof(g_register_mappings));
}

Referenced by uacpi_state_reset().

uacpi_initialize_registers()

uacpi_status uacpi_initialize_registers

(

void

)

Definition at line 456 of file registers.c.

{
    g_reg_lock = uacpi_kernel_create_spinlock();
    if (uacpi_unlikely(g_reg_lock == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    return UACPI_STATUS_OK;
}

Referenced by uacpi_initialize().

uacpi_read_register()

uacpi_status uacpi_read_register	(	enum uacpi_register	reg_enum,
		uacpi_u64 *	out_value
	)

Definition at line 227 of file registers.c.

{
    uacpi_status ret;
    const struct register_spec *reg;
    struct register_mapping *mapping;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
 
    ret = get_reg(reg_enum, &reg, &mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = ensure_register_mapped(reg, mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return do_read_register(reg, mapping, out_value);
}

Referenced by enter_sleep_state_hw_full(), handle_fixed_events(), and prepare_for_wake_from_sleep_state_hw_full().

uacpi_read_register_field()

uacpi_status uacpi_read_register_field	(	enum uacpi_register_field	field_enum,
		uacpi_u64 *	out_value
	)

Definition at line 487 of file registers.c.

{
    uacpi_status ret;
    uacpi_u8 field_idx = field_enum;
    const struct register_field *field;
    const struct register_spec *reg;
    struct register_mapping *mapping;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
 
    if (uacpi_unlikely(field_idx > UACPI_REGISTER_FIELD_MAX))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    field = &g_fields[field_idx];
    reg = &g_registers[field->reg];
    mapping = &g_register_mappings[field->reg];
 
    ret = ensure_register_mapped(reg, mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = do_read_register(reg, mapping, out_value);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    *out_value = (*out_value & field->mask) >> field->offset;
    return UACPI_STATUS_OK;
}

Referenced by enter_sleep_state_hw_full(), enter_sleep_state_hw_reduced(), read_mode(), set_event(), and uacpi_fixed_event_info().

uacpi_write_register()

uacpi_status uacpi_write_register	(	enum uacpi_register	reg_enum,
		uacpi_u64	in_value
	)

Definition at line 286 of file registers.c.

{
    uacpi_status ret;
    const struct register_spec *reg;
    struct register_mapping *mapping;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
 
    ret = get_reg(reg_enum, &reg, &mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = ensure_register_mapped(reg, mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return do_write_register(reg, mapping, in_value);
}

Referenced by enter_sleep_state_hw_reduced(), prepare_for_wake_from_sleep_state_hw_reduced(), set_mode(), uacpi_clear_all_events(), and uacpi_reboot().

uacpi_write_register_field()

uacpi_status uacpi_write_register_field	(	enum uacpi_register_field	field_enum,
		uacpi_u64	in_value
	)

Definition at line 518 of file registers.c.

{
    uacpi_status ret;
    uacpi_u8 field_idx = field_enum;
    const struct register_field *field;
    const struct register_spec *reg;
    struct register_mapping *mapping;
 
    uacpi_u64 data;
    uacpi_cpu_flags flags;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
 
    if (uacpi_unlikely(field_idx > UACPI_REGISTER_FIELD_MAX))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    field = &g_fields[field_idx];
    reg = &g_registers[field->reg];
    mapping = &g_register_mappings[field->reg];
 
    ret = ensure_register_mapped(reg, mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    in_value = (in_value << field->offset) & field->mask;
 
    flags = uacpi_kernel_lock_spinlock(g_reg_lock);
 
    if (reg->kind == REGISTER_ACCESS_KIND_WRITE_TO_CLEAR) {
        if (in_value == 0) {
            ret = UACPI_STATUS_OK;
            goto out;
        }
 
        ret = do_write_register(reg, mapping, in_value);
        goto out;
    }
 
    ret = do_read_register(reg, mapping, &data);
    if (uacpi_unlikely_error(ret))
        goto out;
 
    data &= ~field->mask;
    data |= in_value;
 
    ret = do_write_register(reg, mapping, data);
 
out:
    uacpi_kernel_unlock_spinlock(g_reg_lock, flags);
    return ret;
}

Referenced by dispatch_fixed_event(), enter_sleep_state_hw_full(), enter_sleep_state_hw_reduced(), initialize_fixed_events(), set_event(), uacpi_clear_fixed_event(), uacpi_release_global_lock_to_firmware(), wake_from_sleep_state_hw_full(), and wake_from_sleep_state_hw_reduced().

uacpi_write_registers()

uacpi_status uacpi_write_registers	(	enum uacpi_register	reg_enum,
		uacpi_u64	in_value0,
		uacpi_u64	in_value1
	)

Definition at line 307 of file registers.c.

{
    uacpi_status ret;
    const struct register_spec *reg;
    struct register_mapping *mapping;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
 
    ret = get_reg(reg_enum, &reg, &mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = ensure_register_mapped(reg, mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = do_write_one(mapping, 0, in_value0);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return do_write_one(mapping, 1, in_value1);
}

Referenced by enter_sleep_state_hw_full(), and prepare_for_wake_from_sleep_state_hw_full().

Variable Documentation

g_fields

const struct register_field g_fields[UACPI_REGISTER_FIELD_MAX+1]

static

Definition at line 338 of file registers.c.

Referenced by uacpi_read_register_field(), and uacpi_write_register_field().

g_reg_lock

uacpi_handle g_reg_lock

static

Definition at line 11 of file registers.c.

Referenced by ensure_register_mapped(), uacpi_deinitialize_registers(), uacpi_initialize_registers(), and uacpi_write_register_field().

g_register_mappings

struct register_mapping g_register_mappings[UACPI_REGISTER_MAX+1]

static

Definition at line 109 of file registers.c.

Referenced by get_reg(), uacpi_deinitialize_registers(), uacpi_read_register_field(), and uacpi_write_register_field().

g_registers

const struct register_spec g_registers[UACPI_REGISTER_MAX+1]

static

Definition at line 33 of file registers.c.

Referenced by get_reg(), uacpi_read_register_field(), and uacpi_write_register_field().