Rename PlatformInfo to AcpiPlatform, bring wake_aps under it

Author: IsaacWoods

src/platform/mod.rs

@@ -19,6 +19,91 @@ use crate::{
 use alloc::{alloc::Global, vec::Vec};
 use core::{alloc::Allocator, mem, ptr};
 
+/// `AcpiPlatform` is a higher-level view of the ACPI tables that makes it easier to perform common
+/// tasks with ACPI. It requires allocator support.
+pub struct AcpiPlatform<H: AcpiHandler, A: Allocator = Global> {
+    pub tables: AcpiTables<H>,
+    pub power_profile: PowerProfile,
+    pub interrupt_model: InterruptModel<A>,
+    /// On `x86_64` platforms that support the APIC, the processor topology must also be inferred from the
+    /// interrupt model. That information is stored here, if present.
+    pub processor_info: Option<ProcessorInfo<A>>,
+    pub pm_timer: Option<PmTimer>,
+}
+
+impl<H: AcpiHandler> AcpiPlatform<H, Global> {
+    pub fn new(tables: AcpiTables<H>) -> Result<Self, AcpiError> {
+        Self::new_in(tables, alloc::alloc::Global)
+    }
+}
+
+impl<H: AcpiHandler, A: Allocator + Clone> AcpiPlatform<H, A> {
+    pub fn new_in(tables: AcpiTables<H>, allocator: A) -> Result<Self, AcpiError> {
+        let Some(fadt) = tables.find_table::<Fadt>() else { Err(AcpiError::TableNotFound(Signature::FADT))? };
+        let power_profile = fadt.power_profile();
+
+        let (interrupt_model, processor_info) = InterruptModel::new_in(&tables, allocator)?;
+        let pm_timer = PmTimer::new(&fadt)?;
+
+        Ok(AcpiPlatform { tables, power_profile, interrupt_model, processor_info, pm_timer})
+    }
+
+    /// Wake up all Application Processors (APs) using the Multiprocessor Wakeup Mailbox Mechanism.
+    /// This may not be available on the platform you're running on.
+    ///
+    /// On Intel processors, this will start the AP in long-mode, with interrupts disabled and a
+    /// single page with the supplied waking vector identity-mapped (it is therefore advisable to
+    /// align your waking vector to start at a page boundary and fit within one page).
+    pub unsafe fn wake_aps(
+        &self,
+        apic_id: u32,
+        wakeup_vector: u64,
+        timeout_loops: u64,
+        handler: H,
+    ) -> Result<(), AcpiError> {
+        let Some(madt) = self.tables.find_table::<Madt>() else { Err(AcpiError::TableNotFound(Signature::MADT))? };
+        let mailbox_addr = madt.get().get_mpwk_mailbox_addr()?;
+        let mut mpwk_mapping = unsafe {
+            handler.map_physical_region::<MultiprocessorWakeupMailbox>(
+                mailbox_addr as usize,
+                mem::size_of::<MultiprocessorWakeupMailbox>(),
+            )
+        };
+
+        // Reset command
+        unsafe {
+            ptr::write_volatile(&mut mpwk_mapping.command, MpProtectedModeWakeupCommand::Noop as u16);
+        }
+
+        // Fill the mailbox
+        mpwk_mapping.apic_id = apic_id;
+        mpwk_mapping.wakeup_vector = wakeup_vector;
+        unsafe {
+            ptr::write_volatile(&mut mpwk_mapping.command, MpProtectedModeWakeupCommand::Wakeup as u16);
+        }
+
+        // Wait to join
+        // TODO: if we merge the handlers into one, we could use `stall` here.
+        let mut loops = 0;
+        let mut command = MpProtectedModeWakeupCommand::Wakeup;
+        while command != MpProtectedModeWakeupCommand::Noop {
+            if loops >= timeout_loops {
+                return Err(AcpiError::InvalidMadt(MadtError::WakeupApsTimeout));
+            }
+            // SAFETY: The caller must ensure that the provided `handler` correctly handles these
+            // operations and that the specified `mailbox_addr` is valid.
+            unsafe {
+                command = ptr::read_volatile(&mpwk_mapping.command).into();
+            }
+            core::hint::spin_loop();
+            loops += 1;
+        }
+        drop(mpwk_mapping);
+
+        Ok(())
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ProcessorState {
     /// A processor in this state is unusable, and you must not attempt to bring it up.
@@ -80,103 +165,3 @@ impl PmTimer {
         }
     }
 }
-
-/// `PlatformInfo` allows the collection of some basic information about the platform from some of the fixed-size
-/// tables in a nice way. It requires access to the `FADT` and `MADT`. It is the easiest way to get information
-/// about the processors and interrupt controllers on a platform.
-#[derive(Debug, Clone)]
-pub struct PlatformInfo<A: Allocator = Global> {
-    pub power_profile: PowerProfile,
-    pub interrupt_model: InterruptModel<A>,
-    /// On `x86_64` platforms that support the APIC, the processor topology must also be inferred from the
-    /// interrupt model. That information is stored here, if present.
-    pub processor_info: Option<ProcessorInfo<A>>,
-    pub pm_timer: Option<PmTimer>,
-    /*
-     * TODO: we could provide a nice view of the hardware register blocks in the FADT here.
-     */
-}
-
-impl PlatformInfo<Global> {
-    pub fn new<H>(tables: &AcpiTables<H>) -> Result<Self, AcpiError>
-    where
-        H: AcpiHandler,
-    {
-        Self::new_in(tables, alloc::alloc::Global)
-    }
-}
-
-impl<A: Allocator + Clone> PlatformInfo<A> {
-    pub fn new_in<H>(tables: &AcpiTables<H>, allocator: A) -> Result<Self, AcpiError>
-    where
-        H: AcpiHandler,
-    {
-        let Some(fadt) = tables.find_table::<Fadt>() else { Err(AcpiError::TableNotFound(Signature::FADT))? };
-        let power_profile = fadt.power_profile();
-
-        let (interrupt_model, processor_info) = InterruptModel::new_in(&tables, allocator)?;
-        let pm_timer = PmTimer::new(&fadt)?;
-
-        Ok(PlatformInfo { power_profile, interrupt_model, processor_info, pm_timer })
-    }
-}
-
-/// Wakes up Application Processors (APs) using the Multiprocessor Wakeup Mailbox mechanism.
-///
-/// For Intel processors, the execution environment is:
-/// - Interrupts must be disabled.
-/// - RFLAGES.IF set to 0.
-/// - Long mode enabled.
-/// - Paging mode is enabled and physical memory for waking vector is identity mapped (virtual address equals physical address).
-/// - Waking vector must be contained within one physical page.
-/// - Selectors are set to flat and otherwise not used.
-pub unsafe fn wakeup_aps<H>(
-    tables: &AcpiTables<H>,
-    handler: H,
-    apic_id: u32,
-    wakeup_vector: u64,
-    timeout_loops: u64,
-) -> Result<(), AcpiError>
-where
-    H: AcpiHandler,
-{
-    let Some(madt) = tables.find_table::<Madt>() else { Err(AcpiError::TableNotFound(Signature::MADT))? };
-    let mailbox_addr = madt.get().get_mpwk_mailbox_addr()?;
-    let mut mpwk_mapping = unsafe {
-        handler.map_physical_region::<MultiprocessorWakeupMailbox>(
-            mailbox_addr as usize,
-            mem::size_of::<MultiprocessorWakeupMailbox>(),
-        )
-    };
-
-    // Reset command
-    unsafe {
-        ptr::write_volatile(&mut mpwk_mapping.command, MpProtectedModeWakeupCommand::Noop as u16);
-    }
-
-    // Fill the mailbox
-    mpwk_mapping.apic_id = apic_id;
-    mpwk_mapping.wakeup_vector = wakeup_vector;
-    unsafe {
-        ptr::write_volatile(&mut mpwk_mapping.command, MpProtectedModeWakeupCommand::Wakeup as u16);
-    }
-
-    // Wait to join
-    let mut loops = 0;
-    let mut command = MpProtectedModeWakeupCommand::Wakeup;
-    while command != MpProtectedModeWakeupCommand::Noop {
-        if loops >= timeout_loops {
-            return Err(AcpiError::InvalidMadt(MadtError::WakeupApsTimeout));
-        }
-        // SAFETY: The caller must ensure that the provided `handler` correctly handles these
-        // operations and that the specified `mailbox_addr` is valid.
-        unsafe {
-            command = ptr::read_volatile(&mpwk_mapping.command).into();
-        }
-        core::hint::spin_loop();
-        loops += 1;
-    }
-    drop(mpwk_mapping);
-
-    Ok(())
-}