aml: support reads from and writes to buffer fields

Author: IsaacWoods

aml/src/lib.rs

@@ -744,8 +744,35 @@ impl Interpreter {
         // TODO: write the object to the destination, including e.g. field writes that then lead to
         // literally god knows what.
         match target {
-            Argument::Object(_) => {}
+            Argument::Object(target) => match target.gain_mut() {
+                Object::Integer(target) => match object.gain_mut() {
+                    Object::Integer(value) => {
+                        *target = *value;
+                    }
+                    Object::BufferField { .. } => {
+                        let mut buffer = [0u8; 8];
+                        object.gain_mut().read_buffer_field(&mut buffer)?;
+                        let value = u64::from_le_bytes(buffer);
+                        *target = value;
+                    }
+                    _ => panic!(),
+                },
+                Object::BufferField { .. } => match object.gain_mut() {
+                    Object::Integer(value) => {
+                        target.gain_mut().write_buffer_field(&value.to_le_bytes())?;
+                    }
+                    Object::Buffer(value) => {
+                        target.gain_mut().write_buffer_field(&value.as_slice())?;
+                    }
+                    _ => panic!(),
+                },
+                _ => panic!("Stores to objects like {:?} are not yet supported", target),
+            },
             Argument::Namestring(_) => {}
+            Argument::UnresolvedObjectPath(_) => {
+                // TODO: do we need to attempt to allow this somehow??
+                todo!("Is this allowed here?");
+            }
 
             Argument::ByteData(_) | Argument::TrackedPc(_) | Argument::PkgLength(_) => panic!(),
         }
@@ -804,7 +831,7 @@ impl Block {
     }
 }
 
-#[derive(Debug)]
+#[derive(PartialEq, Debug)]
 pub enum BlockKind {
     Table,
     Method,
@@ -1284,6 +1311,8 @@ pub enum AmlError {
     NoCurrentOp,
 
     MethodArgCountIncorrect,
+
+    InvalidOperationOnObject,
 }
 
 /// This trait represents the interface from the `Interpreter` to the hosting kernel, and allows

aml/src/object.rs

@@ -1,4 +1,4 @@
-use crate::op_region::OpRegion;
+use crate::{AmlError, op_region::OpRegion};
 use alloc::{sync::Arc, vec::Vec};
 use bit_field::BitField;
 
@@ -43,6 +43,27 @@ impl Object {
         }
     }
 
+    pub fn read_buffer_field(&self, dst: &mut [u8]) -> Result<(), AmlError> {
+        if let Self::BufferField { buffer, offset, length } = self {
+            let Object::Buffer(ref buffer) = **buffer else { panic!() };
+            // TODO: assert length of buffer is sufficient
+            copy_bits(buffer.as_slice(), *offset, dst, 0, *length);
+            Ok(())
+        } else {
+            Err(AmlError::InvalidOperationOnObject)
+        }
+    }
+
+    pub fn write_buffer_field(&mut self, value: &[u8]) -> Result<(), AmlError> {
+        if let Self::BufferField { buffer, offset, length } = self {
+            let Object::Buffer(buffer) = buffer.gain_mut() else { panic!() };
+            copy_bits(value, 0, buffer.as_mut_slice(), *offset, *length);
+            Ok(())
+        } else {
+            Err(AmlError::InvalidOperationOnObject)
+        }
+    }
+
     /// Returns the `ObjectType` of this object. Returns the type of the referenced object in the
     /// case of `Object::Reference`.
     pub fn typ(&self) -> ObjectType {
@@ -112,3 +133,56 @@ pub enum ObjectType {
     String,
     ThermalZone,
 }
+
+/// Copy an arbitrary bit range of `src` to an arbitrary bit range of `dst`. This is used for
+/// buffer fields. Data is zero-extended if `src` does not cover `length` bits, matching the
+/// expected behaviour for buffer fields.
+fn copy_bits(src: &[u8], mut src_index: usize, dst: &mut [u8], mut dst_index: usize, mut length: usize) {
+    while length > 0 {
+        let src_shift = src_index & 7;
+        let mut src_bits = src.get(src_index / 8).unwrap_or(&0x00) >> src_shift;
+        if src_shift > 0 && length > (8 - src_shift) {
+            src_bits |= src.get(src_index / 8 + 1).unwrap_or(&0x00) << (8 - src_shift);
+        }
+
+        if length < 8 {
+            src_bits &= (1 << length) - 1;
+        }
+
+        let dst_shift = dst_index & 7;
+        let mut dst_mask: u16 = if length < 8 { ((1 << length) - 1) as u16 } else { 0xff as u16 } << dst_shift;
+        dst[dst_index / 8] =
+            (dst[dst_index / 8] & !(dst_mask as u8)) | ((src_bits << dst_shift) & (dst_mask as u8));
+
+        if dst_shift > 0 && length > (8 - dst_shift) {
+            dst_mask >>= 8;
+            dst[dst_index / 8 + 1] &= !(dst_mask as u8);
+            dst[dst_index / 8 + 1] |= (src_bits >> (8 - dst_shift)) & (dst_mask as u8);
+        }
+
+        if length < 8 {
+            length = 0;
+        } else {
+            length -= 8;
+            src_index += 8;
+            dst_index += 8;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_copy_bits() {
+        let src = [0b1011_1111, 0b1111_0111, 0b1111_1111, 0b1111_1111, 0b1111_1111];
+        let mut dst = [0b1110_0001, 0, 0, 0, 0];
+
+        copy_bits(&src, 0, &mut dst, 2, 15);
+        for i in 0..dst.len() {
+            print!("{:08b} ", dst[i]);
+        }
+        assert_eq!(dst, [0b1111_1101, 0b1101_1110, 0b0000_0001, 0b0000_0000, 0b0000_0000]);
+    }
+}