aml: (WIP) basic DefIndexField implementation

alnyan · alnyan · commit 916d9215b937 · 2023-08-23T12:38:49.000+03:00
diff --git a/aml/src/expression.rs b/aml/src/expression.rs
@@ -4,7 +4,7 @@ use crate::{
     opcode::{self, opcode},
     parser::{choice, comment_scope, n_of, take, take_to_end_of_pkglength, try_with_context, Parser, Propagate},
     pkg_length::pkg_length,
-    term_object::{data_ref_object, term_arg, def_cond_ref_of},
+    term_object::{data_ref_object, def_cond_ref_of, term_arg},
     value::{AmlType, AmlValue, Args},
     AmlError,
     DebugVerbosity,
diff --git a/aml/src/lib.rs b/aml/src/lib.rs
@@ -334,8 +334,17 @@ impl AmlContext {
                 match self.namespace.get(handle).unwrap().type_of() {
                     AmlType::FieldUnit => {
                         let mut field = self.namespace.get(handle).unwrap().clone();
-                        field.write_field(value, self)?;
-                        field.read_field(self)
+                        match field {
+                            AmlValue::Field { .. } => {
+                                field.write_field(value, self)?;
+                                field.read_field(self)
+                            }
+                            AmlValue::IndexField { .. } => {
+                                field.write_index_field(value, self)?;
+                                field.read_index_field(self)
+                            }
+                            _ => unreachable!(),
+                        }
                     }
                     AmlType::BufferField => {
                         let mut buffer_field = self.namespace.get(handle).unwrap().clone();
diff --git a/aml/src/opcode.rs b/aml/src/opcode.rs
@@ -43,6 +43,7 @@ pub const EXT_DEF_DEVICE_OP: u8 = 0x82;
 pub const EXT_DEF_PROCESSOR_OP: u8 = 0x83;
 pub const EXT_DEF_POWER_RES_OP: u8 = 0x84;
 pub const EXT_DEF_THERMAL_ZONE_OP: u8 = 0x85;
+pub const EXT_DEF_INDEX_FIELD_OP: u8 = 0x86;
 
 /*
  * Type 1 opcodes
diff --git a/aml/src/term_object.rs b/aml/src/term_object.rs
@@ -17,7 +17,7 @@ use crate::{
         Parser,
         Propagate,
     },
-    pkg_length::{pkg_length, PkgLength},
+    pkg_length::{pkg_length, raw_pkg_length, PkgLength},
     statement::statement_opcode,
     value::{AmlValue, FieldFlags, MethodCode, MethodFlags, RegionSpace},
     AmlContext,
@@ -110,7 +110,8 @@ where
             def_processor(),
             def_power_res(),
             def_thermal_zone(),
-            def_mutex()
+            def_mutex(),
+            def_index_field()
         ),
     )
 }
@@ -868,7 +869,7 @@ where
                 if let Ok((_name, _handle)) = handle {
                     match target {
                         Target::Null => { /* just return the result of the check */ }
-                        _ => {return (Err(Propagate::Err(AmlError::Unimplemented)), context) },
+                        _ => return (Err(Propagate::Err(AmlError::Unimplemented)), context),
                     }
                 }
                 (Ok(result), context)
@@ -877,6 +878,98 @@ where
         .map(|((), result)| Ok(result))
 }
 
+fn index_field_element<'a, 'c>(
+    index_handle: AmlHandle,
+    data_handle: AmlHandle,
+    flags: FieldFlags,
+    current_offset: u64,
+) -> impl Parser<'a, 'c, u64>
+where
+    'c: 'a,
+{
+    /*
+     * Reserved fields shouldn't actually be added to the namespace; they seem to show gaps in
+     * the operation region that aren't used for anything.
+     *
+     * NOTE: had to use raw_pkg_length() instead of pkg_length() here because pkg_length() performs
+     *       checks against aml code slice, and in this specific context the check should be
+     *       performed against the parent field's size
+     */
+    let reserved_field =
+        opcode(opcode::RESERVED_FIELD).then(raw_pkg_length()).map(|((), length)| Ok(length as u64));
+
+    let named_field = name_seg().then(pkg_length()).map_with_context(move |(name_seg, length), context| {
+        try_with_context!(
+            context,
+            context.namespace.add_value_at_resolved_path(
+                AmlName::from_name_seg(name_seg),
+                &context.current_scope,
+                AmlValue::IndexField {
+                    index: index_handle,
+                    data: data_handle,
+                    flags,
+                    offset: current_offset,
+                    length: length.raw_length as u64,
+                }
+            )
+        );
+
+        (Ok(length.raw_length as u64), context)
+    });
+
+    choice!(reserved_field, named_field)
+}
+
+pub fn def_index_field<'a, 'c>() -> impl Parser<'a, 'c, ()>
+where
+    'c: 'a,
+{
+    /*
+     * DefIndexField    := IndexFieldOp PkgLength NameString NameString FieldFlags FieldList
+     * IndexFieldOp     := ExtOpPrefix 0x86
+     */
+    // Declare a group of field that must be accessed by writing to an index
+    // register and then reading/writing from a data register.
+    ext_opcode(opcode::EXT_DEF_INDEX_FIELD_OP)
+        .then(comment_scope(
+            DebugVerbosity::Scopes,
+            "DefIndexField",
+            pkg_length()
+                .then(name_string())
+                .then(name_string())
+                .then(take())
+                .map_with_context(|(((list_length, index_name), data_name), flags), context| {
+                    let (_, index_handle) =
+                        try_with_context!(context, context.namespace.search(&index_name, &context.current_scope));
+                    let (_, data_handle) =
+                        try_with_context!(context, context.namespace.search(&data_name, &context.current_scope));
+
+                    (Ok((list_length, index_handle, data_handle, flags)), context)
+                })
+                .feed(|(list_length, index_handle, data_handle, flags)| {
+                    move |mut input: &'a [u8], mut context: &'c mut AmlContext| -> ParseResult<'a, 'c, ()> {
+                        let mut current_offset = 0;
+                        while list_length.still_parsing(input) {
+                            let (new_input, new_context, field_length) = index_field_element(
+                                index_handle,
+                                data_handle,
+                                FieldFlags::new(flags),
+                                current_offset,
+                            )
+                            .parse(input, context)?;
+
+                            input = new_input;
+                            context = new_context;
+                            current_offset += field_length;
+                        }
+
+                        Ok((input, context, ()))
+                    }
+                }),
+        ))
+        .discard_result()
+}
+
 pub fn term_arg<'a, 'c>() -> impl Parser<'a, 'c, AmlValue>
 where
     'c: 'a,
diff --git a/aml/src/value.rs b/aml/src/value.rs
@@ -193,6 +193,13 @@ pub enum AmlValue {
         offset: u64,
         length: u64,
     },
+    IndexField {
+        index: AmlHandle,
+        data: AmlHandle,
+        flags: FieldFlags,
+        offset: u64,
+        length: u64,
+    },
     Device,
     Method {
         flags: MethodFlags,
@@ -250,7 +257,7 @@ impl AmlValue {
             AmlValue::Integer(_) => AmlType::Integer,
             AmlValue::String(_) => AmlType::String,
             AmlValue::OpRegion { .. } => AmlType::OpRegion,
-            AmlValue::Field { .. } => AmlType::FieldUnit,
+            AmlValue::Field { .. } | AmlValue::IndexField { .. } => AmlType::FieldUnit,
             AmlValue::Device => AmlType::Device,
             AmlValue::Method { .. } => AmlType::Method,
             AmlValue::Buffer(_) => AmlType::Buffer,
@@ -297,6 +304,8 @@ impl AmlValue {
              * `as_integer` on the result.
              */
             AmlValue::Field { .. } => self.read_field(context)?.as_integer(context),
+            // TODO: IndexField cannot be accessed through an immutable &AmlContext
+            AmlValue::IndexField { .. } => todo!(),
             AmlValue::BufferField { .. } => self.read_buffer_field(context)?.as_integer(context),
 
             _ => Err(AmlError::IncompatibleValueConversion { current: self.type_of(), target: AmlType::Integer }),
@@ -308,6 +317,8 @@ impl AmlValue {
             AmlValue::Buffer(ref bytes) => Ok(bytes.clone()),
             // TODO: implement conversion of String and Integer to Buffer
             AmlValue::Field { .. } => self.read_field(context)?.as_buffer(context),
+            // TODO: IndexField cannot be accessed through an immutable &AmlContext
+            AmlValue::IndexField { .. } => todo!(),
             AmlValue::BufferField { .. } => self.read_buffer_field(context)?.as_buffer(context),
             _ => Err(AmlError::IncompatibleValueConversion { current: self.type_of(), target: AmlType::Buffer }),
         }
@@ -318,6 +329,8 @@ impl AmlValue {
             AmlValue::String(ref string) => Ok(string.clone()),
             // TODO: implement conversion of Buffer to String
             AmlValue::Field { .. } => self.read_field(context)?.as_string(context),
+            // TODO: IndexField cannot be accessed through an immutable &AmlContext
+            AmlValue::IndexField { .. } => todo!(),
             _ => Err(AmlError::IncompatibleValueConversion { current: self.type_of(), target: AmlType::String }),
         }
     }
@@ -404,6 +417,101 @@ impl AmlValue {
         }
     }
 
+    /// Stores an IndexField's index (as specified by its offset) and returns the bit offset within
+    /// the Data part of the field
+    fn write_index(
+        &mut self,
+        index_flags: &FieldFlags,
+        offset: u64,
+        length: u64,
+        context: &mut AmlContext,
+    ) -> Result<usize, AmlError> {
+        let index_align = match index_flags.access_type()? {
+            FieldAccessType::Any => 8,
+            FieldAccessType::Byte => 8,
+            FieldAccessType::Word => 16,
+            FieldAccessType::DWord => 32,
+            FieldAccessType::QWord => 64,
+            FieldAccessType::Buffer => 8,
+        };
+
+        // Value to write to the Index part of the field
+        let length = length as usize;
+        let index_value = (offset / 8) & !((index_align >> 3) - 1);
+        let bit_offset = (offset - index_value * 8) as usize;
+
+        // TODO handle cases when access_type/offset/length combinations lead to crossing of index
+        // boundary
+        if (bit_offset + length - 1) / index_align as usize != 0 {
+            todo!(
+                "IndexField access crosses the index boundary (range: {:#x?}, access type: {} bits)",
+                bit_offset..(bit_offset + length),
+                index_align
+            );
+        }
+
+        // Write the desired index
+        // NOTE not sure if the spec says the index field can only be an integer one, but I can't
+        //      think of any reason for it to be anything else
+        self.write_field(AmlValue::Integer(index_value), context)?;
+
+        Ok(bit_offset)
+    }
+
+    /// Reads from an IndexField, returning either an `Integer` or a `Buffer` depending on the
+    /// field size
+    pub fn read_index_field(&self, context: &mut AmlContext) -> Result<AmlValue, AmlError> {
+        let AmlValue::IndexField { index, data, flags, offset, length } = self else {
+            return Err(AmlError::IncompatibleValueConversion {
+                current: self.type_of(),
+                target: AmlType::FieldUnit,
+            });
+        };
+
+        let mut index_field = context.namespace.get_mut(*index)?.clone();
+        let data_field = context.namespace.get_mut(*data)?.clone();
+
+        // Write the Index part of the field
+        let bit_offset = index_field.write_index(flags, *offset, *length, context)?;
+
+        // TODO buffer field accesses
+
+        // Read the value of the Data field
+        let field_value = data_field.read_field(context)?.as_integer(context)?;
+        let value = field_value.get_bits(bit_offset..(bit_offset + *length as usize));
+
+        Ok(AmlValue::Integer(value))
+    }
+
+    pub fn write_index_field(&self, value: AmlValue, context: &mut AmlContext) -> Result<(), AmlError> {
+        let AmlValue::IndexField { index, data, flags, offset, length } = self else {
+            return Err(AmlError::IncompatibleValueConversion {
+                current: self.type_of(),
+                target: AmlType::FieldUnit,
+            });
+        };
+
+        let mut index_field = context.namespace.get_mut(*index)?.clone();
+        let mut data_field = context.namespace.get_mut(*data)?.clone();
+
+        // Write the Index part of the field
+        let bit_offset = index_field.write_index(flags, *offset, *length, context)?;
+
+        // TODO handle field update rule properly
+        // TODO buffer field accesses
+
+        // Read the old value of the Data field (to preserve bits we're not interested in)
+        let mut field_value = data_field.read_field(context)?.as_integer(context)?;
+
+        // Modify the bits
+        field_value.set_bits(bit_offset..(bit_offset + *length as usize), value.as_integer(context)?);
+
+        // Write the Data field back
+        data_field.write_field(AmlValue::Integer(field_value), context)?;
+
+        Ok(())
+    }
+
     /// 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 read_field(&self, context: &AmlContext) -> Result<AmlValue, AmlError> {
