aml: start process for initializing namespace - _STA and _INI objects

Author: IsaacWoods

aml/src/lib.rs

@@ -23,7 +23,17 @@ use bit_field::BitField;
 use core::{mem, str::FromStr};
 use log::{info, trace, warn};
 use namespace::{AmlName, Namespace, NamespaceLevelKind};
-use object::{FieldFlags, FieldUnit, FieldUnitKind, MethodFlags, Object, ObjectType, ReferenceKind};
+use object::{
+    DeviceStatus,
+    FieldFlags,
+    FieldUnit,
+    FieldUnitKind,
+    FieldUpdateRule,
+    MethodFlags,
+    Object,
+    ObjectType,
+    ReferenceKind,
+};
 use op_region::{OpRegion, RegionHandler, RegionSpace};
 use spinning_top::Spinlock;
 
@@ -109,6 +119,85 @@ where
         handlers.insert(space, Box::new(handler));
     }
 
+    /// Initialize the namespace - this should be called after all tables have been loaded and
+    /// operation region handlers registered. Specifically, it will call relevant `_STA`, `_INI`,
+    /// and `_REG` methods.
+    pub fn initialize_namespace(&self) {
+        /*
+         * This should match the initialization order of ACPICA and uACPI.
+         */
+        if let Err(err) = self.invoke_method_if_present(AmlName::from_str("\\_INI").unwrap(), vec![]) {
+            warn!("Invoking \\_INI failed: {:?}", err);
+        }
+        if let Err(err) = self.invoke_method_if_present(AmlName::from_str("\\_SB._INI").unwrap(), vec![]) {
+            warn!("Invoking \\_SB._INI failed: {:?}", err);
+        }
+
+        // TODO: run all _REGs for globally-installed handlers (this might need more bookkeeping)
+
+        /*
+         * We can now initialize each device in the namespace. For each device, we evaluate `_STA`,
+         * which indicates if the device is present and functional. If this method does not exist,
+         * we assume the device should be initialized.
+         *
+         * We then evaluate `_INI` for the device. This can dynamically populate objects such as
+         * `_ADR`, `_CID`, `_HID`, `_SUN`, and `_UID`, and so is necessary before further
+         * operation.
+         */
+        let mut num_devices_initialized = 0;
+        /*
+         * TODO
+         * We clone a copy of the namespace here to traverse while executing all the `_STA` and
+         * `_INI` objects. Avoiding this would be good, but is not easy, as we need
+         * potentially-mutable access while executing all of the methods.
+         */
+        let mut namespace = self.namespace.lock().clone();
+        let init_status = namespace.traverse(|path, level| {
+            match level.kind {
+                NamespaceLevelKind::Device
+                | NamespaceLevelKind::Processor
+                | NamespaceLevelKind::ThermalZone
+                | NamespaceLevelKind::PowerResource => {
+                    let should_initialize = match self
+                        .invoke_method_if_present(AmlName::from_str("_STA").unwrap().resolve(path)?, vec![])
+                    {
+                        Ok(Some(result)) => {
+                            let Object::Integer(result) = *result else { panic!() };
+                            let status = DeviceStatus(result);
+                            status.present() && status.functioning()
+                        }
+                        Ok(None) => true,
+                        Err(err) => {
+                            warn!("Failed to evaluate _STA for device {}: {:?}", path, err);
+                            false
+                        }
+                    };
+
+                    if should_initialize {
+                        num_devices_initialized += 1;
+                        if let Err(err) = self
+                            .invoke_method_if_present(AmlName::from_str("_INI").unwrap().resolve(path)?, vec![])
+                        {
+                            warn!("Failed to evaluate _INI for device {}: {:?}", path, err);
+                        }
+                        Ok(true)
+                    } else {
+                        /*
+                         * If this device should not be initialized, don't initialize it's children.
+                         */
+                        Ok(false)
+                    }
+                }
+                _ => Ok(true),
+            }
+        });
+        if let Err(err) = init_status {
+            warn!("Error while traversing namespace for devices: {:?}", err);
+        }
+
+        info!("Initialized {} devices", num_devices_initialized);
+    }
+
     fn do_execute_method(&self, mut context: MethodContext) -> Result<Arc<Object>, AmlError> {
         /*
          * This is the main loop that executes operations. Every op is handled at the top-level of
@@ -2529,6 +2618,7 @@ pub trait Handler: Send + Sync {
     /// without causing a deadlock.
     fn acquire(&self, mutex: Handle, timeout: u16) -> Result<(), AmlError>;
     fn release(&self, mutex: Handle);
+
     fn breakpoint(&self) {}
 
     fn handle_debug(&self, _object: &Object) {}

aml/src/namespace.rs

@@ -9,6 +9,7 @@ use alloc::{
 use bit_field::BitField;
 use core::{fmt, str, str::FromStr};
 
+#[derive(Clone)]
 pub struct Namespace {
     root: NamespaceLevel,
 }
@@ -312,6 +313,7 @@ pub enum NamespaceLevelKind {
     MethodLocals,
 }
 
+#[derive(Clone)]
 pub struct NamespaceLevel {
     pub kind: NamespaceLevelKind,
     pub values: BTreeMap<NameSeg, (ObjectFlags, Arc<Object>)>,

aml/src/object.rs

@@ -2,7 +2,7 @@ use crate::{AmlError, Handle, Operation, op_region::OpRegion};
 use alloc::{borrow::Cow, string::String, sync::Arc, vec::Vec};
 use bit_field::BitField;
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub enum Object {
     Uninitialized,
     Buffer(Vec<u8>),
@@ -183,7 +183,7 @@ impl Object {
     }
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct FieldUnit {
     pub kind: FieldUnitKind,
     pub flags: FieldFlags,
@@ -305,6 +305,33 @@ pub enum ObjectType {
     Debug,
 }
 
+/// Helper type for decoding the result of `_STA` objects.
+pub struct DeviceStatus(pub u64);
+
+impl DeviceStatus {
+    pub fn present(&self) -> bool {
+        self.0.get_bit(0)
+    }
+
+    pub fn enabled(&self) -> bool {
+        self.0.get_bit(1)
+    }
+
+    pub fn show_in_ui(&self) -> bool {
+        self.0.get_bit(2)
+    }
+
+    pub fn functioning(&self) -> bool {
+        self.0.get_bit(3)
+    }
+
+    /// This flag is only used for Battery devices (PNP0C0A), and indicates if the battery is
+    /// present.
+    pub fn battery_present(&self) -> bool {
+        self.0.get_bit(4)
+    }
+}
+
 /// 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.

aml/src/op_region.rs

@@ -1,6 +1,6 @@
 use crate::{AmlError, namespace::AmlName};
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct OpRegion {
     pub space: RegionSpace,
     pub base: u64,