aml: support DefObjectType

Author: IsaacWoods

aml/src/lib.rs

@@ -14,7 +14,7 @@ use alloc::{boxed::Box, sync::Arc, vec, vec::Vec};
 use bit_field::BitField;
 use core::{mem, str};
 use namespace::{AmlName, Namespace, NamespaceLevelKind};
-use object::{MethodFlags, Object};
+use object::{MethodFlags, Object, ObjectType};
 use op_region::{OpRegion, RegionSpace};
 use spinning_top::Spinlock;
 
@@ -290,6 +290,38 @@ impl Interpreter {
                             }
                         }
                     }
+                    Opcode::ObjectType => {
+                        let [Argument::Object(object)] = &op.arguments[..] else { panic!() };
+                        // TODO: this should technically support scopes as well - this is less easy
+                        // (they should return `0`)
+                        // TODO: calling this on the debug object should should return `16`
+                        let typ = match object.typ() {
+                            ObjectType::Uninitialized => 0,
+                            ObjectType::Integer => 1,
+                            ObjectType::String => 2,
+                            ObjectType::Buffer => 3,
+                            ObjectType::Package => 4,
+                            ObjectType::FieldUnit => 5,
+                            ObjectType::Device => 6,
+                            ObjectType::Event => 7,
+                            ObjectType::Method => 8,
+                            ObjectType::Mutex => 9,
+                            ObjectType::OpRegion => 10,
+                            ObjectType::PowerResource => 11,
+                            ObjectType::Processor => 12,
+                            ObjectType::ThermalZone => 13,
+                            ObjectType::BufferField => 14,
+                            // XXX: 15 is reserved
+                            ObjectType::Reference => panic!(),
+                            ObjectType::RawDataBuffer => todo!(),
+                        };
+
+                        if let Some(prev_op) = context.in_flight.last_mut() {
+                            if prev_op.arguments.len() < prev_op.expected_arguments {
+                                prev_op.arguments.push(Argument::Object(Arc::new(Object::Integer(typ))));
+                            }
+                        }
+                    }
                     _ => panic!("Unexpected operation has created in-flight op!"),
                 }
             }
@@ -673,7 +705,7 @@ impl Interpreter {
                 | Opcode::ToInteger
                 | Opcode::ToString => context.start_in_flight_op(OpInFlight::new(opcode, 2)),
 
-                Opcode::ObjectType => todo!(),
+                Opcode::ObjectType => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
                 Opcode::CopyObject => todo!(),
                 Opcode::Mid => context.start_in_flight_op(OpInFlight::new(Opcode::Mid, 4)),
                 Opcode::Continue => todo!(),

aml/src/object.rs

@@ -42,6 +42,30 @@ impl Object {
             &mut *(self as *const Self as *mut Self)
         }
     }
+
+    /// Returns the `ObjectType` of this object. Returns the type of the referenced object in the
+    /// case of `Object::Reference`.
+    pub fn typ(&self) -> ObjectType {
+        match self {
+            Object::Uninitialized => ObjectType::Uninitialized,
+            Object::Buffer(_) => ObjectType::Buffer,
+            Object::BufferField { .. } => ObjectType::BufferField,
+            Object::Device => ObjectType::Device,
+            Object::Event => ObjectType::Event,
+            Object::FieldUnit(_) => ObjectType::FieldUnit,
+            Object::Integer(_) => ObjectType::Integer,
+            Object::Method { .. } => ObjectType::Method,
+            Object::Mutex => ObjectType::Mutex,
+            Object::Reference(object) => object.typ(),
+            Object::OpRegion(_) => ObjectType::OpRegion,
+            Object::Package(_) => ObjectType::Package,
+            Object::PowerResource => ObjectType::PowerResource,
+            Object::Processor => ObjectType::Processor,
+            Object::RawDataBuffer => ObjectType::RawDataBuffer,
+            Object::String(_) => ObjectType::String,
+            Object::ThermalZone => ObjectType::ThermalZone,
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -67,3 +91,24 @@ impl MethodFlags {
         self.0.get_bits(4..8)
     }
 }
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum ObjectType {
+    Uninitialized,
+    Buffer,
+    BufferField,
+    Device,
+    Event,
+    FieldUnit,
+    Integer,
+    Method,
+    Mutex,
+    Reference,
+    OpRegion,
+    Package,
+    PowerResource,
+    Processor,
+    RawDataBuffer,
+    String,
+    ThermalZone,
+}

tests/object_type.asl

@@ -1,19 +1,19 @@
 DefinitionBlock("object_type.aml", "DSDT", 1, "RSACPI", "OBJTYP", 1) {
-	Name(INT, 723)
-	Name(STR, "Hello, World!")
-	Name(BUFF, Buffer { 7, 2, 3, 5, 92, 6 })
-	// TODO: more types
+    Name(INT, 723)
+    Name(STR, "Hello, World!")
+    Name(BUFF, Buffer { 7, 2, 3, 5, 92, 6 })
+    // TODO: more types
 
-	Device(TYPS) {
-		// This is just so it compiles
-		Name (_HID, EisaId ("PNP0A03"))
+    Device(TYPS) {
+        // This is just so it compiles
+        Name (_HID, EisaId ("PNP0A03"))
 
-		Name(INT, 0)	// Should be `1`
-		Name(STR, 0)	// Should be `2`
-		Name(BUFF, 0)	// Should be `3`
+        Name(INT, 0)    // Should be `1`
+        Name(STR, 0)    // Should be `2`
+        Name(BUFF, 0)   // Should be `3`
 
-		INT = ObjectType(\INT)
-		STR = ObjectType(\STR)
-		BUFF = ObjectType(\BUFF)
-	}
+        INT = ObjectType(\INT)
+        STR = ObjectType(\STR)
+        BUFF = ObjectType(\BUFF)
+    }
 }

tests/pc-bios_acpi-dsdt.asl

@@ -1896,4 +1896,4 @@
      }
  }
 
- 
+