Enum AmlValue 

pub enum AmlValue {
    Boolean(bool),
    Integer(u64),
    String(String),
    OpRegion {
        region: RegionSpace,
        offset: u64,
        length: u64,
        parent_device: Option<AmlName>,
    },
    Field {
        region: AmlHandle,
        flags: FieldFlags,
        offset: u64,
        length: u64,
    },
    Device,
    Method {
        flags: MethodFlags,
        code: MethodCode,
    },
    Buffer(Arc<Spinlock<Vec<u8>>>),
    BufferField {
        buffer_data: Arc<Spinlock<Vec<u8>>>,
        offset: u64,
        length: u64,
    },
    Processor {
        id: u8,
        pblk_address: u32,
        pblk_len: u8,
    },
    Mutex {
        sync_level: u8,
    },
    Package(Vec<AmlValue>),
    PowerResource {
        system_level: u8,
        resource_order: u16,
    },
    ThermalZone,
}

Variants

Boolean(bool)

Integer(u64)

String(String)

OpRegion

Describes an operation region. Some regions require other objects to be declared under their parent device (e.g. an _ADR object for a PciConfig region), in which case an absolute path to the object is stored in parent_device.

Fields

region: RegionSpace

offset: u64

length: u64

parent_device: Option<AmlName>

Field

Describes a field unit within an operation region.

Fields

region: AmlHandle

flags: FieldFlags

offset: u64

length: u64

Device

Method

Fields

flags: MethodFlags

code: MethodCode

Buffer(Arc<Spinlock<Vec<u8>>>)

BufferField

Fields

buffer_data: Arc<Spinlock<Vec<u8>>>

offset: u64

In bits.

length: u64

In bits.

Processor

Fields

id: u8

pblk_address: u32

pblk_len: u8

Mutex

Fields

sync_level: u8

Package(Vec<AmlValue>)

PowerResource

Fields

system_level: u8

resource_order: u16

ThermalZone

Implementations

impl AmlValue

pub fn zero() -> AmlValue

pub fn one() -> AmlValue

pub fn ones() -> AmlValue

pub fn native_method<F>( arg_count: u8, serialize: bool, sync_level: u8, f: F, ) -> AmlValue

where F: Fn(&mut AmlContext) -> Result<AmlValue, AmlError> + 'static + Send + Sync,

pub fn type_of(&self) -> AmlType

pub fn as_bool(&self) -> Result<bool, AmlError>

pub fn as_integer(&self, context: &AmlContext) -> Result<u64, AmlError>

pub fn as_buffer( &self, context: &AmlContext, ) -> Result<Arc<Spinlock<Vec<u8>>>, AmlError>

pub fn as_string(&self, context: &AmlContext) -> Result<String, AmlError>

pub fn as_concat_type(&self) -> AmlValue

Converts an AmlValue to the representation that should be used when concatenating it with other values, primarily by the DefConcat opcode. This will always produce a AmlValue::Integer, AmlValue::String, or AmlValue::Buffer, with other types being converted to strings containing the name of their type.

pub fn as_status(&self) -> Result<StatusObject, AmlError>

Turns an AmlValue returned from a _STA method into a StatusObject. Should only be called for values returned from _STA. If you need a StatusObject, but the device does not have a _STA method, use StatusObject::default().

pub fn as_type( &self, desired_type: AmlType, context: &AmlContext, ) -> Result<AmlValue, AmlError>

Convert this value to a value of the same data, but with the given AML type, if possible, by converting the implicit conversions described in §19.3.5 of the spec.

The implicit conversions applied are: Buffer from: Integer, String, Debug BufferField from: Integer, Buffer, String, Debug DdbHandle from: Integer, Debug FieldUnit from: Integer,Buffer, String, Debug Integer from: Buffer, BufferField, DdbHandle, FieldUnit, String, Debug Package from: Debug String from: Integer, Buffer, Debug

pub fn read_field(&self, context: &AmlContext) -> Result<AmlValue, AmlError>

Reads from a field of an opregion, returning either a AmlValue::Integer or an AmlValue::Buffer, depending on the size of the field.

pub fn write_field( &mut self, value: AmlValue, context: &mut AmlContext, ) -> Result<(), AmlError>

pub fn read_buffer_field( &self, _context: &AmlContext, ) -> Result<AmlValue, AmlError>

pub fn write_buffer_field( &mut self, value: AmlValue, _context: &mut AmlContext, ) -> Result<(), AmlError>

pub fn cmp( &self, other: AmlValue, context: &mut AmlContext, ) -> Result<Ordering, AmlError>

Logically compare two AmlValues, according to the rules that govern opcodes like DefLEqual, DefLLess, etc. The type of self dictates the type that other will be converted to, and the method by which the values will be compared:

• Integers are simply compared by numeric comparison
• Strings and Buffers are compared lexicographically - other is compared byte-wise until a byte is discovered that is either less or greater than the corresponding byte of self. If the bytes are identical, the lengths are compared. Luckily, the Rust standard library implements lexicographic comparison of strings and [u8] for us already.

Trait Implementations

impl Clone for AmlValue

fn clone(&self) -> AmlValue

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AmlValue

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.