Add methods for adding SSDT

Author: volcaxiao

acpi/src/handler.rs

@@ -76,6 +76,20 @@ where
     pub fn handler(&self) -> &H {
         &self.handler
     }
+
+    pub fn write<V>(&mut self, offset: usize, value: V) {
+        unsafe {
+            let ptr = (self.virtual_start.as_ptr() as *mut u8).add(offset) as *mut V;
+            ptr.write(value);
+        }
+    }
+
+    pub fn read<V>(&self, offset: usize) -> V {
+        unsafe {
+            let ptr = (self.virtual_start.as_ptr() as *mut u8).add(offset) as *mut V;
+            ptr.read()
+        }
+    }
 }
 
 unsafe impl<H: AcpiHandler + Send, T: Send> Send for PhysicalMapping<H, T> {}

acpi/src/iort.rs

@@ -43,7 +43,7 @@ impl fmt::Display for Iort {
 impl Iort {
     pub fn nodes(&self) -> IortNodeIter {
         let node_offset = self.node_array_offset as usize;
-        let pointer = unsafe { (self as *const Iort as *const u8).add(node_offset)};
+        let pointer = unsafe { (self as *const Iort as *const u8).add(node_offset) };
         let remaining_length = self.header.length as u32 - node_offset as u32;
 
         IortNodeIter { pointer, remaining_length, _phantom: PhantomData }

acpi/src/lib.rs

@@ -367,6 +367,43 @@ where
         SsdtIterator { tables_phys_ptrs: self.tables_phys_ptrs(), handler: self.handler.clone() }
     }
 
+    /// Add a new SSDT to the list of tables.
+    /// Sould edit the XSDT or RSDT to include the new table.
+    /// Safety: The address must be valid for reading as an SSDT. And must match the revision of the tables.
+    /// The address must be 8-byte aligned and the 8-byte after xsdt must be not used.
+    pub unsafe fn add_ssdt(&mut self, address: usize) -> AcpiResult<()> {
+        #[repr(transparent)]
+        struct Xsdt {
+            header: SdtHeader,
+        }
+
+        unsafe impl AcpiTable for Xsdt {
+            const SIGNATURE: Signature = Signature::XSDT;
+
+            fn header(&self) -> &SdtHeader {
+                &self.header
+            }
+        }
+
+        let mut xsdt =
+            unsafe { read_table::<H, Xsdt>(self.handler.clone(), self.mapping.physical_start()).unwrap() };
+
+        xsdt.write::<u64>(xsdt.header.length as usize, address as u64);
+
+        xsdt.write::<u32>(4, xsdt.header.length + 8); // length of the table
+        xsdt.write::<u8>(9, 0); // checksum
+        let mut sum = 0u8;
+        for i in 0..xsdt.header.length as usize {
+            sum = sum.wrapping_add(xsdt.read::<u8>(i));
+        }
+        xsdt.write::<u8>(9, (!sum).wrapping_add(1)); // checksum
+
+        let address = xsdt.physical_start();
+        let handler = xsdt.handler().clone();
+        self.mapping = read_root_table!(XSDT, address, handler);
+        Ok(())
+    }
+
     /// Convenience method for contructing a [`PlatformInfo`](crate::platform::PlatformInfo). This is one of the
     /// first things you should usually do with an `AcpiTables`, and allows to collect helpful information about
     /// the platform from the ACPI tables.

acpi/src/rsdp.rs

@@ -1,4 +1,8 @@
-use uefi::table::{cfg::ACPI2_GUID, Boot, SystemTable};
+use uefi::table::{
+    cfg::{ACPI2_GUID, ACPI_GUID},
+    Boot,
+    SystemTable,
+};
 
 use crate::{AcpiError, AcpiHandler, AcpiResult, PhysicalMapping};
 use core::{ffi::c_void, mem, ops::Range, slice, str};
@@ -112,9 +116,11 @@ impl Rsdp {
     where
         H: AcpiHandler,
     {
+        // SAFETY: `system_table` is a valid pointer to a `SystemTable<Boot>`.
         let system_table = unsafe { SystemTable::<Boot>::from_ptr(system_table as *mut c_void).unwrap() };
-
         let config_table = system_table.config_table();
+
+        // Search the configuration table for the RSDP, using GUIDs to identify the correct entry
         let rsdp = config_table.iter().find_map(|entry| {
             if entry.guid == ACPI2_GUID {
                 let rsdp_mapping =
@@ -127,10 +133,22 @@ impl Rsdp {
                         None
                     }
                 }
+            } else if entry.guid == ACPI_GUID {
+                let rsdp_mapping =
+                    unsafe { handler.map_physical_region::<Rsdp>(entry.address as usize, mem::size_of::<Rsdp>()) };
+                match rsdp_mapping.validate() {
+                    Ok(()) => Some(rsdp_mapping),
+                    Err(AcpiError::RsdpIncorrectSignature) => None,
+                    Err(err) => {
+                        log::warn!("Invalid RSDP found at {:#x}: {:?}", system_table.as_ptr() as usize, err);
+                        None
+                    }
+                }
             } else {
                 None
             }
         });
+        // Return the first valid RSDP found, or an error if none were found
         rsdp.ok_or(AcpiError::NoValidRsdp)
     }