aml: general parsing cleanup + little bits

IsaacWoods · IsaacWoods · commit b77079b47fa3 · 2025-02-09T23:58:16.000Z
diff --git a/aml/src/lib.rs b/aml/src/lib.rs
diff --git a/aml/src/namespace.rs b/aml/src/namespace.rs
@@ -66,6 +66,51 @@ impl Namespace {
         }
     }
 
+    /// Search for an object at the given path of the namespace, applying the search rules described in §5.3 of the
+    /// ACPI specification, if they are applicable. Returns the resolved name, and the handle of the first valid
+    /// object, if found.
+    pub fn search(&self, path: &AmlName, starting_scope: &AmlName) -> Result<(AmlName, Arc<Object>), AmlError> {
+        if path.search_rules_apply() {
+            /*
+             * If search rules apply, we need to recursively look through the namespace. If the
+             * given name does not occur in the current scope, we look at the parent scope, until
+             * we either find the name, or reach the root of the namespace.
+             */
+            let mut scope = starting_scope.clone();
+            assert!(scope.is_absolute());
+            loop {
+                // Search for the name at this namespace level. If we find it, we're done.
+                let name = path.resolve(&scope)?;
+                match self.get_level_for_path(&name) {
+                    Ok((level, last_seg)) => {
+                        if let Some(object) = level.values.get(&last_seg) {
+                            return Ok((name, object.clone()));
+                        }
+                    }
+
+                    Err(err) => return Err(err),
+                }
+
+                // If we don't find it, go up a level in the namespace and search for it there recursively
+                match scope.parent() {
+                    Ok(parent) => scope = parent,
+                    Err(AmlError::RootHasNoParent) => return Err(AmlError::ObjectDoesNotExist(path.clone())),
+                    Err(err) => return Err(err),
+                }
+            }
+        } else {
+            // If search rules don't apply, simply resolve it against the starting scope
+            let name = path.resolve(starting_scope)?;
+            let (level, last_seg) = self.get_level_for_path(&path.resolve(starting_scope)?)?;
+
+            if let Some(object) = level.values.get(&last_seg) {
+                Ok((name, object.clone()))
+            } else {
+                Err(AmlError::ObjectDoesNotExist(path.clone()))
+            }
+        }
+    }
+
     /// Split an absolute path into a bunch of level segments (used to traverse the level data structure), and a
     /// last segment to index into that level. This must not be called on `\\`.
     fn get_level_for_path(&self, path: &AmlName) -> Result<(&NamespaceLevel, NameSeg), AmlError> {
@@ -342,7 +387,7 @@ impl NameSeg {
     pub fn from_str(string: &str) -> Result<NameSeg, AmlError> {
         // Each NameSeg can only have four chars, and must have at least one
         if string.is_empty() || string.len() > 4 {
-            return Err(AmlError::InvalidNameSeg);
+            return Err(AmlError::InvalidNameSeg([0xff, 0xff, 0xff, 0xff]));
         }
 
         // We pre-fill the array with '_', so it will already be correct if the length is < 4
@@ -351,14 +396,14 @@ impl NameSeg {
 
         // Manually do the first one, because we have to check it's a LeadNameChar
         if !is_lead_name_char(bytes[0]) {
-            return Err(AmlError::InvalidNameSeg);
+            return Err(AmlError::InvalidNameSeg([bytes[0], bytes[1], bytes[2], bytes[3]]));
         }
         seg[0] = bytes[0];
 
         // Copy the rest of the chars, checking that they're NameChars
         for i in 1..bytes.len() {
             if !is_name_char(bytes[i]) {
-                return Err(AmlError::InvalidNameSeg);
+                return Err(AmlError::InvalidNameSeg([bytes[0], bytes[1], bytes[2], bytes[3]]));
             }
             seg[i] = bytes[i];
         }
@@ -368,16 +413,16 @@ impl NameSeg {
 
     pub fn from_bytes(bytes: [u8; 4]) -> Result<NameSeg, AmlError> {
         if !is_lead_name_char(bytes[0]) {
-            return Err(AmlError::InvalidNameSeg);
+            return Err(AmlError::InvalidNameSeg(bytes));
         }
         if !is_name_char(bytes[1]) {
-            return Err(AmlError::InvalidNameSeg);
+            return Err(AmlError::InvalidNameSeg(bytes));
         }
         if !is_name_char(bytes[2]) {
-            return Err(AmlError::InvalidNameSeg);
+            return Err(AmlError::InvalidNameSeg(bytes));
         }
         if !is_name_char(bytes[3]) {
-            return Err(AmlError::InvalidNameSeg);
+            return Err(AmlError::InvalidNameSeg(bytes));
         }
         Ok(NameSeg(bytes))
     }
diff --git a/aml/src/object.rs b/aml/src/object.rs
@@ -9,7 +9,7 @@ pub enum Object {
     BufferField { buffer: Arc<Object>, offset: usize, length: usize },
     Device,
     Event,
-    FieldUnit,
+    FieldUnit(FieldUnit),
     Integer(u64),
     Method { code: Vec<u8>, flags: MethodFlags },
     Mutex,
@@ -44,6 +44,13 @@ impl Object {
     }
 }
 
+#[derive(Debug)]
+pub enum FieldUnit {
+    Normal { region: Arc<Object>, bit_index: usize, bit_length: usize },
+    Bank,
+    Index,
+}
+
 #[derive(Clone, Copy, Debug)]
 pub struct MethodFlags(pub u8);
 
diff --git a/aml/src/op_region.rs b/aml/src/op_region.rs
@@ -1,8 +1,8 @@
 #[derive(Debug)]
 pub struct OpRegion {
-    space: RegionSpace,
-    base: u64,
-    limit: u64,
+    pub space: RegionSpace,
+    pub base: u64,
+    pub length: u64,
     // parent_device
 }
 
diff --git a/tests/buffer_fields.asl b/tests/buffer_fields.asl
@@ -1,23 +1,23 @@
 DefinitionBlock("buffer_fields.aml", "DSDT", 1, "RSACPI", "BUFFLD", 1) {
-	Name(X, Buffer (16) { 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff })
-	CreateBitField(X, 3, BIT3)
-	CreateField(X, 0, 3, BITS)
-	CreateByteField(X, 1, BYTE)
-	CreateWordField(X, 2, WORD)
-	CreateDWordField(X, 4, DWRD)
-	CreateQWordField(X, 8, QWRD)
+    Name(X, Buffer (16) { 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff })
+    CreateBitField(X, 3, BIT3)
+    CreateField(X, 0, 3, BITS)
+    CreateByteField(X, 1, BYTE)
+    CreateWordField(X, 2, WORD)
+    CreateDWordField(X, 4, DWRD)
+    CreateQWordField(X, 8, QWRD)
 
-	// `X` should end up as [0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x00]
-	BIT3 = 1
-	BITS = 7
-	BYTE = 0x01
-	WORD = 0x0302
-	DWRD = 0x07060504
-	// Last two bytes should be cleared because of zero-extension of this store
-	// We do this as a buffer store a) to test them b) because `iasl` doesn't support 64-bit integer constants...
-	QWRD = Buffer() { 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d }
+    // `X` should end up as [0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x00]
+    BIT3 = 1
+    BITS = 7
+    BYTE = 0x01
+    WORD = 0x0302
+    DWRD = 0x07060504
+    // Last two bytes should be cleared because of zero-extension of this store
+    // We do this as a buffer store a) to test them b) because `iasl` doesn't support 64-bit integer constants...
+    QWRD = Buffer() { 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d }
 
-	// `Y` should end up as `Integer(0x07060504)` (`Integer(117835012)` in decimal)
-	Name(Y, 4)
-	Y = DWRD
+    // `Y` should end up as `Integer(0x07060504)` (`Integer(117835012)` in decimal)
+    Name(Y, 4)
+    Y = DWRD
 }
diff --git a/tests/power_res.asl b/tests/power_res.asl
@@ -1,16 +1,16 @@
 DefinitionBlock("power_res.aml", "DSDT", 1, "RSACPI", "PWRRES", 1) {
-	Scope(_SB) {
-		PowerResource(PIDE, 0, 1) {
-			Name(X, Zero)
-			Method(_STA) {
-				Return (X)
-			}
-			Method(_ON) {
-				Store(One, X)
-			}
-			Method(_OFF) {
-				Store(Zero, X)
-			}
-		}
-	}
+    Scope(_SB) {
+        PowerResource(PIDE, 0, 1) {
+            Name(X, Zero)
+            Method(_STA) {
+                Return (X)
+            }
+            Method(_ON) {
+                Store(One, X)
+            }
+            Method(_OFF) {
+                Store(Zero, X)
+            }
+        }
+    }
 }
diff --git a/tests/scopes.asl b/tests/scopes.asl
@@ -1,12 +1,14 @@
 DefinitionBlock("scopes.aml", "DSDT", 1, "RSACPI", "SCOPES", 1) {
-	Scope(_SB) {
-		Name(X, 320)
-		Device(PCI0) {
-			Name(Y, 15)
-			Name (_HID, EisaId ("PNP0A03"))
-			Scope(\) {
-				Name(Z, 413)
-			}
-		}
-	}
+    Scope(_SB) {
+        Name(X, 320)
+        Name(Y, Zero)
+
+        Device(PCI0) {
+            Name(Y, 15)
+            Name (_HID, EisaId ("PNP0A03"))
+            Scope(\) {
+                Name(Z, 413)
+            }
+        }
+    }
 }
diff --git a/tests/thermal_zone.asl b/tests/thermal_zone.asl
@@ -1,40 +1,40 @@
 DefinitionBlock("thermal_zone.aml", "DSDT", 1, "RSACPI", "THERMZ", 1) {
-	Scope(_SB) {
-		Device(EC0) {
-			Name(_HID, EISAID("PNP0C09"))
-			OperationRegion(EC0, EmbeddedControl, 0, 0xFF)
-			Field(EC0, ByteAcc, Lock, Preserve) {
-				MODE, 1, // thermal policy (quiet/perform)
-				FAN, 1, // fan power (on/off)
-				, 6, // reserved
-				TMP, 16, // current temp
-				AC0, 16, // active cooling temp (fan high)
-				, 16, // reserved
-				PSV, 16, // passive cooling temp
-				HOT, 16, // critical S4 temp
-				CRT, 16 // critical temp
-			}
-		}
+    Scope(_SB) {
+        Device(EC0) {
+            Name(_HID, EISAID("PNP0C09"))
+            OperationRegion(EC0, EmbeddedControl, 0, 0xFF)
+            Field(EC0, ByteAcc, Lock, Preserve) {
+                MODE, 1, // thermal policy (quiet/perform)
+                FAN, 1, // fan power (on/off)
+                , 6, // reserved
+                TMP, 16, // current temp
+                AC0, 16, // active cooling temp (fan high)
+                , 16, // reserved
+                PSV, 16, // passive cooling temp
+                HOT, 16, // critical S4 temp
+                CRT, 16 // critical temp
+            }
+        }
 
-		Device(CPU0) {
-			Name(_HID, "ACPI0007")
-			Name(_UID, 1) // unique number for this processor
-		}
+        Device(CPU0) {
+            Name(_HID, "ACPI0007")
+            Name(_UID, 1) // unique number for this processor
+        }
 
-		ThermalZone(TZ0) {
-			Method(_TMP) { Return (\_SB.EC0.TMP )} // get current temp
-			Method(_AC0) { Return (\_SB.EC0.AC0) } // fan high temp
-			Name(_AL0, Package(){\_SB.EC0.FAN}) // fan is act cool dev
-			Method(_PSV) { Return (\_SB.EC0.PSV) } // passive cooling temp
-			Name(_PSL, Package (){\_SB.CPU0}) // passive cooling devices
-			Method(_HOT) { Return (\_SB.EC0.HOT) } // get critical S4 temp
-			Method(_CRT) { Return (\_SB.EC0.CRT) } // get critical temp
-			Method(_SCP, 1) { Store (Arg0, \_SB.EC0.MODE) } // set cooling mode
-			Name(_TC1, 4) // bogus example constant
-			Name(_TC2, 3) // bogus example constant
-			Name(_TSP, 150) // passive sampling = 15 sec
-			Name(_TZP, 0) // polling not required
-			Name (_STR, Unicode ("System thermal zone"))
-		}
-	}
+        ThermalZone(TZ0) {
+            Method(_TMP) { Return (\_SB.EC0.TMP )} // get current temp
+            Method(_AC0) { Return (\_SB.EC0.AC0) } // fan high temp
+            Name(_AL0, Package(){\_SB.EC0.FAN}) // fan is act cool dev
+            Method(_PSV) { Return (\_SB.EC0.PSV) } // passive cooling temp
+            Name(_PSL, Package (){\_SB.CPU0}) // passive cooling devices
+            Method(_HOT) { Return (\_SB.EC0.HOT) } // get critical S4 temp
+            Method(_CRT) { Return (\_SB.EC0.CRT) } // get critical temp
+            Method(_SCP, 1) { Store (Arg0, \_SB.EC0.MODE) } // set cooling mode
+            Name(_TC1, 4) // bogus example constant
+            Name(_TC2, 3) // bogus example constant
+            Name(_TSP, 150) // passive sampling = 15 sec
+            Name(_TZP, 0) // polling not required
+            Name (_STR, Unicode ("System thermal zone"))
+        }
+    }
 }
