io.c File Reference

#include <uacpi/internal/io.h>
#include <uacpi/internal/stdlib.h>
#include <uacpi/internal/log.h>
#include <uacpi/internal/opregion.h>
#include <uacpi/internal/utilities.h>
#include <uacpi/internal/mutex.h>
#include <uacpi/internal/namespace.h>

Include dependency graph for io.c:

Go to the source code of this file.

Classes
struct	bit_span
union	integer_data

Macros
#define	SERIAL_HEADER_SIZE   2
#define	IPMI_DATA_SIZE   64

Functions
uacpi_size	uacpi_round_up_bits_to_bytes (uacpi_size bit_length)
static void	cut_misaligned_tail (uacpi_u8 *data, uacpi_size offset, uacpi_u32 bit_length)
static uacpi_size	bit_span_offset (struct bit_span *span, uacpi_size bits)
static void	bit_copy (struct bit_span *dst, struct bit_span *src)
static void	do_misaligned_buffer_read (const uacpi_buffer_field *field, uacpi_u8 *dst)
void	uacpi_read_buffer_field (const uacpi_buffer_field *field, void *dst)
static void	do_write_misaligned_buffer_field (uacpi_buffer_field *field, const void *src, uacpi_size size)
void	uacpi_write_buffer_field (uacpi_buffer_field *field, const void *src, uacpi_size size)
static uacpi_bool	field_unit_needs_global_lock (uacpi_field_unit *field)
static uacpi_status	lock_field_unit_transaction (uacpi_field_unit *field)
static void	unlock_field_unit_transaction (uacpi_field_unit *field)
static uacpi_bool	field_fits (uacpi_field_unit *field, uacpi_u64 value)
static uacpi_status	access_field_unit (uacpi_field_unit *field, uacpi_u32 offset, uacpi_region_op op, union uacpi_opregion_io_data data)
static uacpi_status	wtr_buffer_size (uacpi_field_unit *field, uacpi_address_space space, uacpi_size *out_size)
static uacpi_status	handle_special_field (uacpi_field_unit *field, uacpi_data_view buf, uacpi_region_op op, uacpi_data_view *wtr_response, uacpi_bool *did_handle)
static uacpi_status	do_read_misaligned_field_unit (uacpi_field_unit *field, uacpi_u8 *dst, uacpi_size size)
uacpi_status	uacpi_read_field_unit (uacpi_field_unit *field, void *dst, uacpi_size size, uacpi_data_view *wtr_response)
static uacpi_status	write_generic_field_unit (uacpi_field_unit *field, const void *src, uacpi_size size)
static uacpi_status	write_field_unit (uacpi_field_unit *field, const void *src, uacpi_size size, uacpi_size chunk_size, uacpi_data_view *wtr_response)
uacpi_status	uacpi_write_field_unit (uacpi_field_unit *field, const void *src, uacpi_size size, uacpi_data_view *wtr_response)
uacpi_status	uacpi_write_field_unit_in_chunks (uacpi_field_unit *field, const void *src, uacpi_size size, uacpi_data_view *wtr_response)
uacpi_status	uacpi_field_unit_get_read_type (struct uacpi_field_unit *field, uacpi_object_type *out_type)
uacpi_status	uacpi_field_unit_get_bit_length (struct uacpi_field_unit *field, uacpi_size *out_length)
static uacpi_u8	gas_get_access_bit_width (const struct acpi_gas *gas)
static uacpi_status	gas_validate (const struct acpi_gas *gas, uacpi_u8 *access_bit_width, uacpi_u8 *bit_width)
uacpi_status	uacpi_gas_read_mapped (const uacpi_mapped_gas *gas, uacpi_u64 *out_value)
uacpi_status	uacpi_gas_write_mapped (const uacpi_mapped_gas *gas, uacpi_u64 in_value)
static void	unmap_gas_io (uacpi_handle io_handle, uacpi_size size)
uacpi_status	uacpi_map_gas_noalloc (const struct acpi_gas *gas, uacpi_mapped_gas *out_mapped)
uacpi_status	uacpi_map_gas (const struct acpi_gas *gas, uacpi_mapped_gas **out_mapped)
void	uacpi_unmap_gas_nofree (uacpi_mapped_gas *gas)
void	uacpi_unmap_gas (uacpi_mapped_gas *gas)
uacpi_status	uacpi_gas_read (const struct acpi_gas *gas, uacpi_u64 *out_value)
uacpi_status	uacpi_gas_write (const struct acpi_gas *gas, uacpi_u64 in_value)
uacpi_u8	uacpi_builtin_mmio_read8 (void *ptr)
uacpi_u16	uacpi_builtin_mmio_read16 (void *ptr)
uacpi_u32	uacpi_builtin_mmio_read32 (void *ptr)
uacpi_u64	uacpi_builtin_mmio_read64 (void *ptr)
void	uacpi_builtin_mmio_write8 (void *ptr, uacpi_u8 data)
void	uacpi_builtin_mmio_write16 (void *ptr, uacpi_u16 data)
void	uacpi_builtin_mmio_write32 (void *ptr, uacpi_u32 data)
void	uacpi_builtin_mmio_write64 (void *ptr, uacpi_u64 data)
uacpi_status	uacpi_system_memory_read (void *ptr, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out)
uacpi_status	uacpi_system_memory_write (void *ptr, uacpi_size offset, uacpi_u8 width, uacpi_u64 in)
uacpi_status	uacpi_system_io_read (uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out)
uacpi_status	uacpi_system_io_write (uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in)
uacpi_status	uacpi_pci_read (uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out)
uacpi_status	uacpi_pci_write (uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in)

Macro Definition Documentation

IPMI_DATA_SIZE

#define IPMI_DATA_SIZE   64

Definition at line 343 of file io.c.

SERIAL_HEADER_SIZE

#define SERIAL_HEADER_SIZE   2

Definition at line 342 of file io.c.

Function Documentation

access_field_unit()

static uacpi_status access_field_unit ( uacpi_field_unit *  field, uacpi_u32  offset, uacpi_region_op  op, union uacpi_opregion_io_data  data  )

static

Definition at line 274 of file io.c.

{
    uacpi_status ret = UACPI_STATUS_OK;
 
    switch (field->kind) {
    case UACPI_FIELD_UNIT_KIND_BANK:
        if (uacpi_unlikely(!field_fits(field->bank_selection,
                                       field->bank_value))) {
            uacpi_error(
                "bank value 0x%"UACPI_PRIX64" doesn't fit in the %u-bit "
                "bank register", UACPI_FMT64(field->bank_value),
                field->bank_selection->bit_length
            );
            return UACPI_STATUS_AML_OUT_OF_BOUNDS_INDEX;
        }
 
        ret = uacpi_write_field_unit(
            field->bank_selection, &field->bank_value, sizeof(field->bank_value),
            UACPI_NULL
        );
        break;
    case UACPI_FIELD_UNIT_KIND_NORMAL:
        break;
    case UACPI_FIELD_UNIT_KIND_INDEX:
        if (uacpi_unlikely(!field_fits(field->index, offset))) {
            uacpi_error(
                "offset 0x%X doesn't fit in the %u-bit index register",
                offset, field->index->bit_length
            );
            return UACPI_STATUS_AML_OUT_OF_BOUNDS_INDEX;
        }
 
        ret = uacpi_write_field_unit(
            field->index, &offset, sizeof(offset),
            UACPI_NULL
        );
        if (uacpi_unlikely_error(ret))
            return ret;
 
        switch (op) {
        case UACPI_REGION_OP_READ:
            return uacpi_read_field_unit(
                field->data, data.integer, field->access_width_bytes,
                UACPI_NULL
            );
        case UACPI_REGION_OP_WRITE:
            return uacpi_write_field_unit(
                field->data, data.integer, field->access_width_bytes,
                UACPI_NULL
            );
        default:
            return UACPI_STATUS_INVALID_ARGUMENT;
        }
 
    default:
        uacpi_error("invalid field unit kind %d", field->kind);
        ret = UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return uacpi_dispatch_opregion_io(field, offset, op, data);
}

Referenced by do_read_misaligned_field_unit(), handle_special_field(), uacpi_read_field_unit(), and write_generic_field_unit().

bit_copy()

static void bit_copy ( struct bit_span *  dst, struct bit_span *  src  )

static

Definition at line 48 of file io.c.

{
    uacpi_u8 src_shift, dst_shift, bits = 0;
    uacpi_u16 dst_mask;
    uacpi_u8 *dst_ptr, *src_ptr;
    uacpi_u64 dst_count, src_count;
 
    dst_ptr = dst->data + (dst->index / 8);
    src_ptr = src->data + (src->index / 8);
 
    dst_count = dst->length;
    dst_shift = dst->index & 7;
 
    src_count = src->length;
    src_shift = src->index & 7;
 
    while (dst_count)
    {
        bits = 0;
 
        if (src_count) {
            bits = *src_ptr >> src_shift;
 
            if (src_shift && src_count > (uacpi_u32)(8 - src_shift))
                bits |= *(src_ptr + 1) << (8 - src_shift);
 
            if (src_count < 8) {
                bits &= (1 << src_count) - 1;
                src_count = 0;
            } else {
                src_count -= 8;
                src_ptr++;
            }
        }
 
        dst_mask = (dst_count < 8 ? (1 << dst_count) - 1 : 0xFF) << dst_shift;
        *dst_ptr = (*dst_ptr & ~dst_mask) | ((bits << dst_shift) & dst_mask);
 
        if (dst_shift && dst_count > (uacpi_u32)(8 - dst_shift)) {
            dst_mask >>= 8;
            *(dst_ptr + 1) &= ~dst_mask;
            *(dst_ptr + 1) |= (bits >> (8 - dst_shift)) & dst_mask;
        }
 
        dst_count = dst_count > 8 ? dst_count - 8 : 0;
        ++dst_ptr;
    }
}

Referenced by do_misaligned_buffer_read(), do_read_misaligned_field_unit(), do_write_misaligned_buffer_field(), and write_generic_field_unit().

bit_span_offset()

static uacpi_size bit_span_offset ( struct bit_span *  span, uacpi_size  bits  )

static

Definition at line 38 of file io.c.

{
    uacpi_size delta = UACPI_MIN(span->length, bits);
 
    span->index += delta;
    span->length -= delta;
 
    return delta;
}

Referenced by do_read_misaligned_field_unit(), and write_generic_field_unit().

cut_misaligned_tail()

static void cut_misaligned_tail ( uacpi_u8 *  data, uacpi_size  offset, uacpi_u32  bit_length  )

static

Definition at line 16 of file io.c.

{
    uacpi_u8 remainder = bit_length & 7;
 
    if (remainder == 0)
        return;
 
    data[offset] &= ((1ull << remainder) - 1);
}

Referenced by uacpi_read_buffer_field(), and uacpi_read_field_unit().

do_misaligned_buffer_read()

static void do_misaligned_buffer_read ( const uacpi_buffer_field *  field, uacpi_u8 *  dst  )

static

Definition at line 97 of file io.c.

{
    struct bit_span src_span = { 0 };
    struct bit_span dst_span = { 0 };
 
    src_span.index = field->bit_index;
    src_span.length = field->bit_length;
    src_span.const_data = field->backing->data;
 
    dst_span.data = dst;
    dst_span.length = uacpi_round_up_bits_to_bytes(field->bit_length) * 8;
    bit_copy(&dst_span, &src_span);
}

Referenced by uacpi_read_buffer_field().

do_read_misaligned_field_unit()

static uacpi_status do_read_misaligned_field_unit ( uacpi_field_unit *  field, uacpi_u8 *  dst, uacpi_size  size  )

static

Definition at line 504 of file io.c.

{
    uacpi_status ret;
    uacpi_size reads_to_do;
    uacpi_u64 out;
    uacpi_u32 byte_offset = field->byte_offset;
    uacpi_u32 bits_left = field->bit_length;
    uacpi_u8 width_access_bits = field->access_width_bytes * 8;
 
    struct bit_span src_span = { 0 };
    struct bit_span dst_span = { 0 };
 
    src_span.data = (uacpi_u8*)&out;
    src_span.index = field->bit_offset_within_first_byte;
 
    dst_span.data = dst;
    dst_span.index = 0;
    dst_span.length = size * 8;
 
    reads_to_do = UACPI_ALIGN_UP(
        field->bit_offset_within_first_byte + field->bit_length,
        width_access_bits,
        uacpi_u32
    );
    reads_to_do /= width_access_bits;
 
    while (reads_to_do-- > 0) {
        union uacpi_opregion_io_data data;
 
        src_span.length = UACPI_MIN(
            bits_left, width_access_bits - src_span.index
        );
 
        data.integer = &out;
        ret = access_field_unit(
            field, byte_offset, UACPI_REGION_OP_READ,
            data
        );
        if (uacpi_unlikely_error(ret))
            return ret;
 
        bit_copy(&dst_span, &src_span);
        bits_left -= src_span.length;
        src_span.index = 0;
 
        bit_span_offset(&dst_span, src_span.length);
        byte_offset += field->access_width_bytes;
    }
 
    return UACPI_STATUS_OK;
}

Referenced by uacpi_read_field_unit().

do_write_misaligned_buffer_field()

static void do_write_misaligned_buffer_field ( uacpi_buffer_field *  field, const void *  src, uacpi_size  size  )

static

Definition at line 134 of file io.c.

{
    struct bit_span src_span = { 0 };
    struct bit_span dst_span = { 0 };
 
    src_span.length = size * 8;
    src_span.const_data = src;
 
    dst_span.index = field->bit_index;
    dst_span.length = field->bit_length;
    dst_span.data = field->backing->data;
 
    bit_copy(&dst_span, &src_span);
}

Referenced by uacpi_write_buffer_field().

field_fits()

static uacpi_bool field_fits ( uacpi_field_unit *  field, uacpi_u64  value  )

static

Definition at line 266 of file io.c.

{
    if (field->bit_length >= 64)
        return UACPI_TRUE;
 
    return value < ((uacpi_u64)1 << field->bit_length);
}

Referenced by access_field_unit().

field_unit_needs_global_lock()

static uacpi_bool field_unit_needs_global_lock ( uacpi_field_unit *  field )

static

Definition at line 186 of file io.c.

{
    if (field->lock_rule)
        return UACPI_TRUE;
 
    /*
     * The global lock must be acquired before the opregion lock, however,
     * the subfields of an index/bank field are only accessed once the
     * opregion lock is already held, so their lock rules have to be
     * considered upfront to keep the ordering consistent.
     */
    switch (field->kind) {
    case UACPI_FIELD_UNIT_KIND_INDEX:
        return field_unit_needs_global_lock(field->index) ||
               field_unit_needs_global_lock(field->data);
    case UACPI_FIELD_UNIT_KIND_BANK:
        return field_unit_needs_global_lock(field->bank_selection);
    default:
        return UACPI_FALSE;
    }
}

Referenced by field_unit_needs_global_lock(), lock_field_unit_transaction(), and unlock_field_unit_transaction().

gas_get_access_bit_width()

static uacpi_u8 gas_get_access_bit_width ( const struct acpi_gas *  gas )

static

Definition at line 815 of file io.c.

{
    /*
     * Same algorithm as ACPICA.
     *
     * The reason we do this is apparently GAS bit offset being non-zero means
     * that it's an APEI register, as opposed to FADT, which needs special
     * handling. In the case of a FADT register we want to ignore the specified
     * access size.
     */
    uacpi_u8 access_bit_width;
 
    if (gas->register_bit_offset == 0 &&
        UACPI_IS_POWER_OF_TWO(gas->register_bit_width, uacpi_u8) &&
        UACPI_IS_ALIGNED(gas->register_bit_width, 8, uacpi_u8)) {
        access_bit_width = gas->register_bit_width;
    } else if (gas->access_size) {
        access_bit_width = gas->access_size * 8;
    } else {
        uacpi_u8 msb;
 
        msb = uacpi_bit_scan_backward(
            (gas->register_bit_offset + gas->register_bit_width) - 1
        );
        access_bit_width = 1 << msb;
 
        if (access_bit_width <= 8) {
            access_bit_width = 8;
        } else {
            /*
             * Keep backing off to previous power of two until we find one
             * that is aligned to the address specified in GAS.
             */
            while (!UACPI_IS_ALIGNED(
                gas->address, access_bit_width / 8, uacpi_u64
            ))
                access_bit_width /= 2;
        }
    }
 
    return UACPI_MIN(
        access_bit_width,
        gas->address_space_id == UACPI_ADDRESS_SPACE_SYSTEM_IO ? 32 : 64
    );
}

Referenced by gas_validate().

gas_validate()

static uacpi_status gas_validate ( const struct acpi_gas *  gas, uacpi_u8 *  access_bit_width, uacpi_u8 *  bit_width  )

static

Definition at line 861 of file io.c.

{
    uacpi_size total_width, aligned_width;
 
    if (uacpi_unlikely(gas == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    if (!gas->address)
        return UACPI_STATUS_NOT_FOUND;
 
    if (gas->address_space_id != UACPI_ADDRESS_SPACE_SYSTEM_IO &&
        gas->address_space_id != UACPI_ADDRESS_SPACE_SYSTEM_MEMORY) {
        uacpi_warn("unsupported GAS address space '%s' (%d)",
                   uacpi_address_space_to_string(gas->address_space_id),
                   gas->address_space_id);
        return UACPI_STATUS_UNIMPLEMENTED;
    }
 
    if (gas->access_size > 4) {
        uacpi_warn("unsupported GAS access size %d",
                   gas->access_size);
        return UACPI_STATUS_UNIMPLEMENTED;
    }
 
    *access_bit_width = gas_get_access_bit_width(gas);
 
    total_width = gas->register_bit_offset + gas->register_bit_width;
    aligned_width = UACPI_ALIGN_UP(total_width, *access_bit_width, uacpi_size);
 
    if (uacpi_unlikely(aligned_width > 64)) {
        uacpi_warn(
            "GAS register total width is too large: %zu", total_width
        );
        return UACPI_STATUS_UNIMPLEMENTED;
    }
 
    *bit_width = total_width;
    return UACPI_STATUS_OK;
}

Referenced by uacpi_map_gas_noalloc().

handle_special_field()

static uacpi_status handle_special_field ( uacpi_field_unit *  field, uacpi_data_view  buf, uacpi_region_op  op, uacpi_data_view *  wtr_response, uacpi_bool *  did_handle  )

static

Definition at line 406 of file io.c.

{
    uacpi_status ret = UACPI_STATUS_OK;
    uacpi_object *obj;
    uacpi_operation_region *region;
    uacpi_u64 in_out;
    uacpi_data_view wtr_buffer;
    union uacpi_opregion_io_data data;
 
    *did_handle = UACPI_FALSE;
 
    if (field->kind == UACPI_FIELD_UNIT_KIND_INDEX)
        return ret;
 
    obj = uacpi_namespace_node_get_object_typed(
        field->region, UACPI_OBJECT_OPERATION_REGION_BIT
    );
    if (uacpi_unlikely(obj == UACPI_NULL)) {
        ret = UACPI_STATUS_INVALID_ARGUMENT;
        uacpi_trace_region_error(
            field->region, "attempted access to deleted", ret
        );
        goto out_handled;
    }
    region = obj->op_region;
 
    switch (region->space) {
    case UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO:
        if (op == UACPI_REGION_OP_WRITE) {
            uacpi_memcpy_zerout(
                &in_out, buf.const_data, sizeof(in_out), buf.length
            );
        }
 
        data.integer = &in_out;
        ret = access_field_unit(field, 0, op, data);
        if (uacpi_unlikely_error(ret))
            goto out_handled;
 
        if (op == UACPI_REGION_OP_READ)
            uacpi_memcpy_zerout(buf.data, &in_out, buf.length, sizeof(in_out));
        goto out_handled;
    case UACPI_ADDRESS_SPACE_IPMI:
    case UACPI_ADDRESS_SPACE_PRM:
        if (uacpi_unlikely(op == UACPI_REGION_OP_READ)) {
            ret = UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
            uacpi_trace_region_error(
                field->region, "attempted to read from a write-only", ret
            );
            goto out_handled;
        }
        UACPI_FALLTHROUGH;
    case UACPI_ADDRESS_SPACE_FFIXEDHW:
    case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
    case UACPI_ADDRESS_SPACE_SMBUS:
        goto do_wtr;
    default:
        return ret;
    }
 
do_wtr:
    ret = wtr_buffer_size(field, region->space, &wtr_buffer.length);
    if (uacpi_unlikely_error(ret))
        goto out_handled;
 
    wtr_buffer.data = uacpi_kernel_alloc(wtr_buffer.length);
    if (uacpi_unlikely(wtr_buffer.data == UACPI_NULL)) {
        ret = UACPI_STATUS_OUT_OF_MEMORY;
        goto out_handled;
    }
 
    uacpi_memcpy_zerout(
        wtr_buffer.data, buf.const_data, wtr_buffer.length, buf.length
    );
    data.buffer = wtr_buffer;
    ret = access_field_unit(
        field, field->byte_offset,
        op, data
    );
    if (uacpi_unlikely_error(ret)) {
        uacpi_free(wtr_buffer.data, wtr_buffer.length);
        goto out_handled;
    }
 
    if (wtr_response != UACPI_NULL)
        *wtr_response = wtr_buffer;
    else
        uacpi_free(wtr_buffer.data, wtr_buffer.length);
 
out_handled:
    *did_handle = UACPI_TRUE;
    return ret;
}

Referenced by uacpi_read_field_unit(), and write_field_unit().

lock_field_unit_transaction()

static uacpi_status lock_field_unit_transaction ( uacpi_field_unit *  field )

static

Definition at line 219 of file io.c.

{
    uacpi_status ret;
 
    /*
     * The namespace is unlocked more than once before we're done: while we
     * wait for the locks below, and around every invocation of the address
     * space handler. This makes it possible for someone else to get rid of
     * the field in the meantime, e.g. by overwriting it via CopyObject. All
     * of the references that our caller has to it are gone if that happens,
     * so take one that is ours alone.
     */
    uacpi_shareable_ref(field);
 
    if (field_unit_needs_global_lock(field)) {
        ret = uacpi_acquire_aml_mutex(
            g_uacpi_rt_ctx.global_lock_mutex, 0xFFFF
        );
        if (uacpi_unlikely_error(ret))
            goto out_unref;
    }
 
    ret = uacpi_upgrade_to_opregion_lock();
    if (uacpi_unlikely_error(ret)) {
        if (field_unit_needs_global_lock(field))
            uacpi_release_aml_mutex(g_uacpi_rt_ctx.global_lock_mutex);
 
        goto out_unref;
    }
 
    return ret;
 
out_unref:
    uacpi_field_unit_unref(field);
    return ret;
}

Referenced by uacpi_read_field_unit(), and write_field_unit().

uacpi_builtin_mmio_read16()

uacpi_u16 uacpi_builtin_mmio_read16

(

void *

ptr

)

Definition at line 1096 of file io.c.

{
    return *(volatile uacpi_u16*)ptr;
}

uacpi_builtin_mmio_read32()

uacpi_u32 uacpi_builtin_mmio_read32

(

void *

ptr

)

Definition at line 1101 of file io.c.

{
    return *(volatile uacpi_u32*)ptr;
}

uacpi_builtin_mmio_read64()

uacpi_u64 uacpi_builtin_mmio_read64

(

void *

ptr

)

Definition at line 1106 of file io.c.

{
    return *(volatile uacpi_u64*)ptr;
}

uacpi_builtin_mmio_read8()

uacpi_u8 uacpi_builtin_mmio_read8

(

void *

ptr

)

Definition at line 1091 of file io.c.

{
    return *(volatile uacpi_u8*)ptr;
}

uacpi_builtin_mmio_write16()

void uacpi_builtin_mmio_write16	(	void *	ptr,
		uacpi_u16	data
	)

Definition at line 1116 of file io.c.

{
    *(volatile uacpi_u16*)ptr = data;
}

uacpi_builtin_mmio_write32()

void uacpi_builtin_mmio_write32	(	void *	ptr,
		uacpi_u32	data
	)

Definition at line 1121 of file io.c.

{
    *(volatile uacpi_u32*)ptr = data;
}

uacpi_builtin_mmio_write64()

void uacpi_builtin_mmio_write64	(	void *	ptr,
		uacpi_u64	data
	)

Definition at line 1126 of file io.c.

{
    *(volatile uacpi_u64*)ptr = data;
}

uacpi_builtin_mmio_write8()

void uacpi_builtin_mmio_write8	(	void *	ptr,
		uacpi_u8	data
	)

Definition at line 1111 of file io.c.

{
    *(volatile uacpi_u8*)ptr = data;
}

uacpi_field_unit_get_bit_length()

uacpi_status uacpi_field_unit_get_bit_length	(	struct uacpi_field_unit *	field,
		uacpi_size *	out_length
	)

Definition at line 786 of file io.c.

{
    uacpi_object *obj;
 
    if (field->kind == UACPI_FIELD_UNIT_KIND_INDEX)
        goto out_basic_field;
 
    obj = uacpi_namespace_node_get_object_typed(
        field->region, UACPI_OBJECT_OPERATION_REGION_BIT
    );
    if (uacpi_unlikely(obj == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    if (uacpi_is_buffer_access_address_space(obj->op_region->space)) {
        /*
         * Bit length is protocol specific, the data will be returned
         * via the write-then-read response buffer.
         */
        *out_length = 0;
        return UACPI_STATUS_OK;
    }
 
out_basic_field:
    *out_length = field->bit_length;
    return UACPI_STATUS_OK;
}

Referenced by field_byte_size().

uacpi_field_unit_get_read_type()

uacpi_status uacpi_field_unit_get_read_type	(	struct uacpi_field_unit *	field,
		uacpi_object_type *	out_type
	)

Definition at line 757 of file io.c.

{
    uacpi_object *obj;
 
    if (field->kind == UACPI_FIELD_UNIT_KIND_INDEX)
        goto out_basic_field;
 
    obj = uacpi_namespace_node_get_object_typed(
        field->region, UACPI_OBJECT_OPERATION_REGION_BIT
    );
    if (uacpi_unlikely(obj == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    if (uacpi_is_buffer_access_address_space(obj->op_region->space)) {
        *out_type = UACPI_OBJECT_BUFFER;
        return UACPI_STATUS_OK;
    }
 
out_basic_field:
    if (field->bit_length > (g_uacpi_rt_ctx.is_rev1 ? 32u : 64u))
        *out_type = UACPI_OBJECT_BUFFER;
    else
        *out_type = UACPI_OBJECT_INTEGER;
 
    return UACPI_STATUS_OK;
}

Referenced by field_get_read_type().

uacpi_gas_read()

uacpi_status uacpi_gas_read	(	const struct acpi_gas *	gas,
		uacpi_u64 *	out_value
	)

Definition at line 1060 of file io.c.

{
    uacpi_status ret;
    uacpi_mapped_gas mapping;
 
    ret = uacpi_map_gas_noalloc(gas, &mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = uacpi_gas_read_mapped(&mapping, out_value);
    uacpi_unmap_gas_nofree(&mapping);
 
    return ret;
}

uacpi_gas_read_mapped()

uacpi_status uacpi_gas_read_mapped	(	const uacpi_mapped_gas *	gas,
		uacpi_u64 *	value
	)

Same as uacpi_gas_{read,write} but operates on a pre-mapped handle for faster access and/or ability to use in critical sections/irq contexts.

Definition at line 911 of file io.c.

{
    uacpi_status ret;
    uacpi_u8 access_byte_width;
    uacpi_u8 bit_offset, bits_left, index = 0;
    uacpi_u64 data, mask = 0xFFFFFFFFFFFFFFFF;
    uacpi_size offset = 0;
 
    bit_offset = gas->bit_offset;
    bits_left = gas->total_bit_width;
 
    access_byte_width = gas->access_bit_width / 8;
 
    if (access_byte_width < 8)
        mask = ~(mask << gas->access_bit_width);
 
    *out_value = 0;
 
    while (bits_left) {
        if (bit_offset >= gas->access_bit_width) {
            data = 0;
            bit_offset -= gas->access_bit_width;
        } else {
            ret = gas->read(gas->mapping, offset, access_byte_width, &data);
            if (uacpi_unlikely_error(ret))
                return ret;
        }
 
        *out_value |= (data & mask) << (index * gas->access_bit_width);
        bits_left -= UACPI_MIN(bits_left, gas->access_bit_width);
        ++index;
        offset += access_byte_width;
    }
 
    return UACPI_STATUS_OK;
}

Referenced by detect_gpes(), do_read_one(), gpe_try_claim(), maybe_dispatch_gpe(), set_gpe_state_unlocked(), uacpi_gas_read(), and uacpi_gpe_info().

uacpi_gas_write()

uacpi_status uacpi_gas_write	(	const struct acpi_gas *	gas,
		uacpi_u64	in_value
	)

Definition at line 1075 of file io.c.

{
    uacpi_status ret;
    uacpi_mapped_gas mapping;
 
    ret = uacpi_map_gas_noalloc(gas, &mapping);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = uacpi_gas_write_mapped(&mapping, in_value);
    uacpi_unmap_gas_nofree(&mapping);
 
    return ret;
}

uacpi_gas_write_mapped()

uacpi_status uacpi_gas_write_mapped	(	const uacpi_mapped_gas *	gas,
		uacpi_u64	in_value
	)

Definition at line 950 of file io.c.

{
    uacpi_status ret;
    uacpi_u8 access_byte_width;
    uacpi_u8 bit_offset, bits_left, index = 0;
    uacpi_u64 data, mask = 0xFFFFFFFFFFFFFFFF;
    uacpi_size offset = 0;
 
    bit_offset = gas->bit_offset;
    bits_left = gas->total_bit_width;
    access_byte_width = gas->access_bit_width / 8;
 
    if (access_byte_width < 8)
        mask = ~(mask << gas->access_bit_width);
 
    while (bits_left) {
        data = (in_value >> (index * gas->access_bit_width)) & mask;
 
        if (bit_offset >= gas->access_bit_width) {
            bit_offset -= gas->access_bit_width;
        } else {
            ret = gas->write(gas->mapping, offset, access_byte_width, data);
            if (uacpi_unlikely_error(ret))
                return ret;
        }
 
        bits_left -= UACPI_MIN(bits_left, gas->access_bit_width);
        ++index;
        offset += access_byte_width;
    }
 
    return UACPI_STATUS_OK;
}

Referenced by clear_gpe(), create_gpe_block(), do_write_one(), gpe_block_apply_action(), gpe_try_claim(), set_gpe_state_unlocked(), uacpi_gas_write(), and uninstall_gpe_block().

uacpi_map_gas()

uacpi_status uacpi_map_gas	(	const struct acpi_gas *	gas,
		uacpi_mapped_gas **	out_mapped
	)

Map a GAS for faster access in the future. The handle returned via 'out_mapped' must be freed & unmapped using uacpi_unmap_gas() when no longer needed.

Definition at line 1028 of file io.c.

{
    uacpi_status ret;
    uacpi_mapped_gas *mapping;
 
    mapping = uacpi_kernel_alloc(sizeof(*mapping));
    if (uacpi_unlikely(mapping == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    ret = uacpi_map_gas_noalloc(gas, mapping);
    if (uacpi_unlikely_error(ret)) {
        uacpi_free(mapping, sizeof(*mapping));
        return ret;
    }
 
    *out_mapped = mapping;
    return ret;
}

uacpi_map_gas_noalloc()

uacpi_status uacpi_map_gas_noalloc	(	const struct acpi_gas *	gas,
		uacpi_mapped_gas *	out_mapped
	)

Definition at line 992 of file io.c.

{
    uacpi_status ret;
    uacpi_u8 access_bit_width, total_width;
 
    ret = gas_validate(gas, &access_bit_width, &total_width);
    if (ret != UACPI_STATUS_OK)
        return ret;
 
    if (gas->address_space_id == UACPI_ADDRESS_SPACE_SYSTEM_MEMORY) {
        out_mapped->mapping = uacpi_kernel_map(gas->address, total_width / 8);
        if (uacpi_unlikely(out_mapped->mapping == UACPI_MAP_FAILED))
            return UACPI_STATUS_MAPPING_FAILED;
 
        out_mapped->read = uacpi_system_memory_read;
        out_mapped->write = uacpi_system_memory_write;
        out_mapped->unmap = uacpi_kernel_unmap;
    } else { // IO, validated by gas_validate above
        ret = uacpi_kernel_io_map(gas->address, total_width / 8, &out_mapped->mapping);
        if (uacpi_unlikely_error(ret))
            return ret;
 
        out_mapped->read = uacpi_system_io_read;
        out_mapped->write = uacpi_system_io_write;
        out_mapped->unmap = unmap_gas_io;
    }
 
    out_mapped->access_bit_width = access_bit_width;
    out_mapped->total_bit_width = total_width;
    out_mapped->bit_offset = gas->register_bit_offset;
 
    return UACPI_STATUS_OK;
}

Referenced by create_gpe_block(), map_one(), uacpi_gas_read(), uacpi_gas_write(), and uacpi_map_gas().

uacpi_pci_read()

uacpi_status uacpi_pci_read	(	uacpi_handle	handle,
		uacpi_size	offset,
		uacpi_u8	width,
		uacpi_u64 *	out
	)

Definition at line 1250 of file io.c.

{
    uacpi_status ret;
    union integer_data data = {
        .qword = 0,
    };
 
    switch (width) {
    case 1:
        ret = uacpi_kernel_pci_read8(handle, offset, &data.byte);
        break;
    case 2:
        ret = uacpi_kernel_pci_read16(handle, offset, &data.word);
        break;
    case 4:
        ret = uacpi_kernel_pci_read32(handle, offset, &data.dword);
        break;
    default:
        uacpi_error(
            "invalid PCI_Config read %p@%zu width=%d",
            handle, offset, width
        );
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    if (uacpi_likely_success(ret))
        *out = data.qword;
    return ret;
}

Referenced by pci_region_do_rw().

uacpi_pci_write()

uacpi_status uacpi_pci_write	(	uacpi_handle	handle,
		uacpi_size	offset,
		uacpi_u8	width,
		uacpi_u64	in
	)

Definition at line 1282 of file io.c.

{
    uacpi_status ret;
 
    switch (width) {
    case 1:
        ret = uacpi_kernel_pci_write8(handle, offset, in);
        break;
    case 2:
        ret = uacpi_kernel_pci_write16(handle, offset, in);
        break;
    case 4:
        ret = uacpi_kernel_pci_write32(handle, offset, in);
        break;
    default:
        uacpi_error(
            "invalid PCI_Config write %p@%zu width=%d",
            handle, offset, width
        );
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    return ret;
}

Referenced by pci_region_do_rw().

uacpi_read_buffer_field()

void uacpi_read_buffer_field	(	const uacpi_buffer_field *	field,
		void *	dst
	)

Definition at line 113 of file io.c.

{
    // There's nothing to read from a buffer field that's empty
    if (uacpi_unlikely(field->bit_length == 0))
        return;
 
    if (!(field->bit_index & 7)) {
        uacpi_u8 *src = field->backing->data;
        uacpi_size count;
 
        count = uacpi_round_up_bits_to_bytes(field->bit_length);
        uacpi_memcpy(dst, src + (field->bit_index / 8), count);
        cut_misaligned_tail(dst, count - 1, field->bit_length);
        return;
    }
 
    do_misaligned_buffer_read(field, dst);
}

Referenced by handle_field_read(), and handle_inc_dec().

uacpi_read_field_unit()

uacpi_status uacpi_read_field_unit	(	uacpi_field_unit *	field,
		void *	dst,
		uacpi_size	size,
		uacpi_data_view *	wtr_response
	)

Definition at line 558 of file io.c.

{
    uacpi_status ret;
    uacpi_u32 field_byte_length;
    uacpi_bool did_handle;
    uacpi_data_view data_view = { 0 };
 
    data_view.data = dst;
    data_view.length = size;
 
    ret = lock_field_unit_transaction(field);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = handle_special_field(
        field, data_view, UACPI_REGION_OP_READ,
        wtr_response, &did_handle
    );
    if (did_handle)
        goto out;
 
    // There's nothing to read from a field that the AML declared as empty
    if (uacpi_unlikely(field->bit_length == 0)) {
        uacpi_memzero(dst, size);
        goto out;
    }
 
    field_byte_length = uacpi_round_up_bits_to_bytes(field->bit_length);
 
    /*
     * Very simple fast case:
     * - Bit offset within first byte is 0
     * AND
     * - Field size is <= access width
     */
    if (field->bit_offset_within_first_byte == 0 &&
        field_byte_length <= field->access_width_bytes)
    {
        uacpi_u64 out;
        union uacpi_opregion_io_data data;
 
        data.integer = &out;
        ret = access_field_unit(
            field, field->byte_offset, UACPI_REGION_OP_READ,
            data
        );
        if (uacpi_unlikely_error(ret))
            goto out;
 
        uacpi_memcpy_zerout(dst, &out, size, field_byte_length);
        if (size >= field_byte_length)
            cut_misaligned_tail(dst, field_byte_length - 1, field->bit_length);
 
        goto out;
    }
 
    // Slow case
    ret = do_read_misaligned_field_unit(field, dst, size);
 
out:
    unlock_field_unit_transaction(field);
    return ret;
}

Referenced by access_field_unit(), handle_field_read(), and handle_inc_dec().

uacpi_round_up_bits_to_bytes()

uacpi_size uacpi_round_up_bits_to_bytes

(

uacpi_size

bit_length

)

Definition at line 11 of file io.c.

{
    return UACPI_ALIGN_UP(bit_length, 8, uacpi_size) / 8;
}

Referenced by do_misaligned_buffer_read(), field_byte_size(), object_assign_with_implicit_cast(), uacpi_read_buffer_field(), uacpi_read_field_unit(), uacpi_write_buffer_field(), and uacpi_write_field_unit_in_chunks().

uacpi_system_io_read()

uacpi_status uacpi_system_io_read	(	uacpi_handle	handle,
		uacpi_size	offset,
		uacpi_u8	width,
		uacpi_u64 *	out
	)

Definition at line 1191 of file io.c.

{
    uacpi_status ret;
    union integer_data data = {
        .qword = 0,
    };
 
    switch (width) {
    case 1:
        ret = uacpi_kernel_io_read8(handle, offset, &data.byte);
        break;
    case 2:
        ret = uacpi_kernel_io_read16(handle, offset, &data.word);
        break;
    case 4:
        ret = uacpi_kernel_io_read32(handle, offset, &data.dword);
        break;
    default:
        uacpi_error(
            "invalid SystemIO read %p@%zu width=%d",
            handle, offset, width
        );
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    if (uacpi_likely_success(ret))
        *out = data.qword;
    return ret;
}

Referenced by io_region_do_rw(), and uacpi_map_gas_noalloc().

uacpi_system_io_write()

uacpi_status uacpi_system_io_write	(	uacpi_handle	handle,
		uacpi_size	offset,
		uacpi_u8	width,
		uacpi_u64	in
	)

Definition at line 1223 of file io.c.

{
    uacpi_status ret;
 
    switch (width) {
    case 1:
        ret = uacpi_kernel_io_write8(handle, offset, in);
        break;
    case 2:
        ret = uacpi_kernel_io_write16(handle, offset, in);
        break;
    case 4:
        ret = uacpi_kernel_io_write32(handle, offset, in);
        break;
    default:
        uacpi_error(
            "invalid SystemIO write %p@%zu width=%d",
            handle, offset, width
        );
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    return ret;
}

Referenced by io_region_do_rw(), and uacpi_map_gas_noalloc().

uacpi_system_memory_read()

uacpi_status uacpi_system_memory_read	(	void *	ptr,
		uacpi_size	offset,
		uacpi_u8	width,
		uacpi_u64 *	out
	)

Definition at line 1132 of file io.c.

{
    ptr = UACPI_PTR_ADD(ptr, offset);
 
    switch (width) {
    case 1:
        *out = uacpi_mmio_read8(ptr);
        break;
    case 2:
        *out = uacpi_mmio_read16(ptr);
        break;
    case 4:
        *out = uacpi_mmio_read32(ptr);
        break;
    case 8:
        *out = uacpi_mmio_read64(ptr);
        break;
    default:
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    return UACPI_STATUS_OK;
}

Referenced by memory_region_do_rw(), table_data_region_do_rw(), and uacpi_map_gas_noalloc().

uacpi_system_memory_write()

uacpi_status uacpi_system_memory_write	(	void *	ptr,
		uacpi_size	offset,
		uacpi_u8	width,
		uacpi_u64	in
	)

Definition at line 1158 of file io.c.

{
    ptr = UACPI_PTR_ADD(ptr, offset);
 
    switch (width) {
    case 1:
        uacpi_mmio_write8(ptr, in);
        break;
    case 2:
        uacpi_mmio_write16(ptr, in);
        break;
    case 4:
        uacpi_mmio_write32(ptr, in);
        break;
    case 8:
        uacpi_mmio_write64(ptr, in);
        break;
    default:
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    return UACPI_STATUS_OK;
}

Referenced by memory_region_do_rw(), table_data_region_do_rw(), and uacpi_map_gas_noalloc().

uacpi_unmap_gas()

void uacpi_unmap_gas

(

uacpi_mapped_gas *

gas

)

Definition at line 1054 of file io.c.

{
    uacpi_unmap_gas_nofree(gas);
    uacpi_free(gas, sizeof(*gas));
}

uacpi_unmap_gas_nofree()

void uacpi_unmap_gas_nofree

(

uacpi_mapped_gas *

gas

)

Definition at line 1049 of file io.c.

{
    gas->unmap(gas->mapping, gas->access_bit_width / 8);
}

Referenced by free_gpe_block(), uacpi_deinitialize_registers(), uacpi_gas_read(), uacpi_gas_write(), and uacpi_unmap_gas().

uacpi_write_buffer_field()

void uacpi_write_buffer_field	(	uacpi_buffer_field *	field,
		const void *	src,
		uacpi_size	size
	)

Definition at line 152 of file io.c.

{
    // There's nothing to write to a buffer field that's empty
    if (uacpi_unlikely(field->bit_length == 0))
        return;
 
    if (!(field->bit_index & 7)) {
        uacpi_u8 *dst, last_byte, tail_shift;
        uacpi_size count;
 
        dst = field->backing->data;
        dst += field->bit_index / 8;
        count = uacpi_round_up_bits_to_bytes(field->bit_length);
 
        last_byte = dst[count - 1];
        tail_shift = field->bit_length & 7;
 
        uacpi_memcpy_zerout(dst, src, count, size);
        if (tail_shift) {
            uacpi_u8 last_shift = 8 - tail_shift;
            dst[count - 1] = dst[count - 1] << last_shift;
            dst[count - 1] >>= last_shift;
            dst[count - 1] |= (last_byte >> tail_shift) << tail_shift;
        }
 
        return;
    }
 
    do_write_misaligned_buffer_field(field, src, size);
}

Referenced by object_assign_with_implicit_cast().

uacpi_write_field_unit()

uacpi_status uacpi_write_field_unit	(	uacpi_field_unit *	field,
		const void *	src,
		uacpi_size	size,
		uacpi_data_view *	wtr_response
	)

Definition at line 738 of file io.c.

{
    return write_field_unit(field, src, size, size, wtr_response);
}

Referenced by access_field_unit(), and store_to_field_unit().

uacpi_write_field_unit_in_chunks()

uacpi_status uacpi_write_field_unit_in_chunks	(	uacpi_field_unit *	field,
		const void *	src,
		uacpi_size	size,
		uacpi_data_view *	wtr_response
	)

Definition at line 746 of file io.c.

{
    return write_field_unit(
        field, src, size, uacpi_round_up_bits_to_bytes(field->bit_length),
        wtr_response
    );
}

Referenced by store_to_field_unit().

unlock_field_unit_transaction()

static void unlock_field_unit_transaction ( uacpi_field_unit *  field )

static

Definition at line 256 of file io.c.

{
    uacpi_release_opregion_lock();
 
    if (field_unit_needs_global_lock(field))
        uacpi_release_aml_mutex(g_uacpi_rt_ctx.global_lock_mutex);
 
    uacpi_field_unit_unref(field);
}

Referenced by uacpi_read_field_unit(), and write_field_unit().

unmap_gas_io()

static void unmap_gas_io ( uacpi_handle  io_handle, uacpi_size  size  )

static

Definition at line 986 of file io.c.

{
    UACPI_UNUSED(size);
    uacpi_kernel_io_unmap(io_handle);
}

Referenced by uacpi_map_gas_noalloc().

write_field_unit()

static uacpi_status write_field_unit ( uacpi_field_unit *  field, const void *  src, uacpi_size  size, uacpi_size  chunk_size, uacpi_data_view *  wtr_response  )

static

Definition at line 696 of file io.c.

{
    uacpi_status ret;
    uacpi_bool did_handle;
    uacpi_data_view data_view = { 0 };
    const uacpi_u8 *bytes = src;
    uacpi_size offset;
 
    data_view.const_data = src;
    data_view.length = size;
 
    ret = lock_field_unit_transaction(field);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = handle_special_field(
        field, data_view, UACPI_REGION_OP_WRITE,
        wtr_response, &did_handle
    );
    if (did_handle)
        goto out;
 
    // There's nothing to write to a field that the AML declared as empty
    if (uacpi_unlikely(field->bit_length == 0))
        goto out;
 
    for (offset = 0; offset < size; offset += chunk_size) {
        ret = write_generic_field_unit(
            field, bytes + offset, UACPI_MIN(chunk_size, size - offset)
        );
        if (uacpi_unlikely_error(ret))
            break;
    }
 
out:
    unlock_field_unit_transaction(field);
    return ret;
}

Referenced by uacpi_write_field_unit(), and uacpi_write_field_unit_in_chunks().

write_generic_field_unit()

static uacpi_status write_generic_field_unit ( uacpi_field_unit *  field, const void *  src, uacpi_size  size  )

static

Definition at line 625 of file io.c.

{
    uacpi_status ret;
    uacpi_u32 bits_left, byte_offset = field->byte_offset;
    uacpi_u8 width_access_bits = field->access_width_bytes * 8;
    uacpi_u64 in;
    struct bit_span src_span = { 0 };
    struct bit_span dst_span = { 0 };
 
    src_span.const_data = src;
    src_span.index = 0;
    src_span.length = size * 8;
 
    dst_span.data = (uacpi_u8 *)∈
    dst_span.index = field->bit_offset_within_first_byte;
 
    bits_left = field->bit_length;
 
    while (bits_left) {
        union uacpi_opregion_io_data data;
 
        in = 0;
        dst_span.length = UACPI_MIN(
            width_access_bits - dst_span.index, bits_left
        );
 
        if (dst_span.index != 0 || dst_span.length < width_access_bits) {
            switch (field->update_rule) {
            case UACPI_UPDATE_RULE_PRESERVE:
                data.integer = &in;
                ret = access_field_unit(
                    field, byte_offset, UACPI_REGION_OP_READ,
                    data
                );
                if (uacpi_unlikely_error(ret))
                    return ret;
                break;
            case UACPI_UPDATE_RULE_WRITE_AS_ONES:
                in = ~in;
                break;
            case UACPI_UPDATE_RULE_WRITE_AS_ZEROES:
                break;
            default:
                uacpi_error("invalid field@%p update rule %d",
                            field, field->update_rule);
                return UACPI_STATUS_INVALID_ARGUMENT;
            }
        }
 
        bit_copy(&dst_span, &src_span);
        bit_span_offset(&src_span, dst_span.length);
 
        data.integer = &in;
 
        ret = access_field_unit(
            field, byte_offset, UACPI_REGION_OP_WRITE,
            data
        );
        if (uacpi_unlikely_error(ret))
            return ret;
 
        bits_left -= dst_span.length;
        dst_span.index = 0;
        byte_offset += field->access_width_bytes;
    }
 
    return UACPI_STATUS_OK;
}

Referenced by write_field_unit().

wtr_buffer_size()

static uacpi_status wtr_buffer_size ( uacpi_field_unit *  field, uacpi_address_space  space, uacpi_size *  out_size  )

static

Definition at line 345 of file io.c.

{
    switch (space) {
    case UACPI_ADDRESS_SPACE_IPMI:
        *out_size = SERIAL_HEADER_SIZE + IPMI_DATA_SIZE;
        break;
    case UACPI_ADDRESS_SPACE_PRM:
        *out_size = 26;
        break;
    case UACPI_ADDRESS_SPACE_FFIXEDHW:
        *out_size = 256;
        break;
    case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
    case UACPI_ADDRESS_SPACE_SMBUS: {
        uacpi_size size_for_protocol = SERIAL_HEADER_SIZE;
 
        switch (field->attributes) {
        case UACPI_ACCESS_ATTRIBUTE_QUICK:
            break; // + 0
        case UACPI_ACCESS_ATTRIBUTE_SEND_RECEIVE:
        case UACPI_ACCESS_ATTRIBUTE_BYTE:
            size_for_protocol += 1;
            break;
 
        case UACPI_ACCESS_ATTRIBUTE_WORD:
        case UACPI_ACCESS_ATTRIBUTE_PROCESS_CALL:
            size_for_protocol += 2;
            break;
 
        case UACPI_ACCESS_ATTRIBUTE_BYTES:
            size_for_protocol += field->access_length;
            break;
 
        case UACPI_ACCESS_ATTRIBUTE_BLOCK:
        case UACPI_ACCESS_ATTRIBUTE_BLOCK_PROCESS_CALL:
        case UACPI_ACCESS_ATTRIBUTE_RAW_BYTES:
        case UACPI_ACCESS_ATTRIBUTE_RAW_PROCESS_BYTES:
            size_for_protocol += 255;
            break;
 
        default:
            uacpi_error(
                "unsupported field@%p access attribute %d",
                field, field->attributes
            );
            return UACPI_STATUS_UNIMPLEMENTED;
        }
 
        *out_size = size_for_protocol;
        break;
    }
    default:
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
 
    return UACPI_STATUS_OK;
}

Referenced by handle_special_field().