Prepare the ACPI tables for generation

Combine all ACPI tables into the format expected by firmware(OVMF) by
using fw_cfg's table-loader commands for address patching and checksum
computation.

Signed-off-by: Amey Narkhede <ameynarkhede03@gmail.com>

Author: glitzflitz

lib/propolis/src/hw/qemu/fwcfg.rs

@@ -1478,6 +1478,7 @@ pub mod formats {
 
     pub const ACPI_TABLE_HEADER_SIZE: usize = 36;
     const ACPI_TABLE_LENGTH_OFFSET: usize = 4;
+    pub const ACPI_TABLE_CHECKSUM_OFF: usize = 9;
 
     #[derive(Copy, Clone, IntoBytes, Immutable)]
     #[repr(C, packed)]
@@ -1551,7 +1552,7 @@ pub mod formats {
 
         pub fn add_entry(&mut self) -> u32 {
             let offset = self.data.len() as u32;
-            self.data.extend_from_slice(&[0u8; 8]);
+            self.data.extend_from_slice(&[0u8; size_of::<u64>()]);
             offset
         }
 
@@ -2004,6 +2005,238 @@ pub mod formats {
         }
     }
 
+    pub struct AcpiConfig {
+        pub num_cpus: u8,
+        pub local_apic_addr: u32,
+        pub io_apic_id: u8,
+        pub io_apic_addr: u32,
+        pub pcie_ecam_base: u64,
+        pub pcie_ecam_size: u64,
+        pub pcie_bus_start: u8,
+        pub pcie_bus_end: u8,
+        pub pcie_mmio32_base: u64,
+        pub pcie_mmio32_limit: u64,
+        pub pcie_mmio64_base: u64,
+        pub pcie_mmio64_limit: u64,
+        pub com_ports: Vec<(u16, u8)>,
+    }
+
+    impl Default for AcpiConfig {
+        fn default() -> Self {
+            Self {
+                num_cpus: 1,
+                local_apic_addr: 0xfee0_0000,
+                io_apic_id: 0,
+                io_apic_addr: 0xfec0_0000,
+                pcie_ecam_base: 0xe000_0000,
+                pcie_ecam_size: 0x1000_0000,
+                pcie_bus_start: 0,
+                pcie_bus_end: 255,
+                pcie_mmio32_base: 0xc000_0000,
+                pcie_mmio32_limit: 0xfbff_ffff,
+                pcie_mmio64_base: 0x1_0000_0000,
+                pcie_mmio64_limit: 0xf_ffff_ffff,
+                com_ports: Vec::new(),
+            }
+        }
+    }
+
+    pub struct AcpiTables {
+        pub tables: Vec<u8>,
+        pub rsdp: Vec<u8>,
+        pub loader: Vec<u8>,
+    }
+
+    pub fn build_acpi_tables(config: &AcpiConfig) -> AcpiTables {
+        use crate::firmware::acpi::{
+            build_dsdt_aml, ComPortConfig, DsdtConfig, PcieConfig,
+        };
+
+        let mut tables = Vec::new();
+        let mut loader = TableLoader::new();
+
+        let dsdt_config = DsdtConfig {
+            pcie: Some(PcieConfig {
+                ecam_base: config.pcie_ecam_base,
+                ecam_size: config.pcie_ecam_size,
+                bus_start: config.pcie_bus_start,
+                bus_end: config.pcie_bus_end,
+                mmio32_base: config.pcie_mmio32_base,
+                mmio32_limit: config.pcie_mmio32_limit,
+                mmio64_base: config.pcie_mmio64_base,
+                mmio64_limit: config.pcie_mmio64_limit,
+            }),
+            com_ports: config
+                .com_ports
+                .iter()
+                .map(|&(io_base, irq)| ComPortConfig { io_base, irq })
+                .collect(),
+        };
+        let aml = build_dsdt_aml(&dsdt_config);
+        let mut dsdt = Dsdt::new();
+        dsdt.append_aml(&aml);
+        let dsdt_offset = tables.len();
+        tables.extend_from_slice(&dsdt.finish());
+
+        let fadt = Fadt::new();
+        let fadt_offset = tables.len();
+        tables.extend_from_slice(&fadt.finish());
+
+        let mut madt = Madt::new(config.local_apic_addr);
+        for i in 0..config.num_cpus {
+            madt.add_local_apic(i, i, MADT_LAPIC_ENABLED);
+        }
+        madt.add_io_apic(config.io_apic_id, config.io_apic_addr, 0);
+        madt.add_int_src_override(ISA_BUS, ISA_IRQ_TIMER, GSI_TIMER, 0);
+        madt.add_int_src_override(
+            ISA_BUS,
+            ISA_IRQ_SCI,
+            GSI_SCI,
+            MADT_INT_LEVEL_ACTIVE_HIGH,
+        );
+        madt.add_lapic_nmi(ACPI_PROCESSOR_ALL, MADT_INT_FLAGS_DEFAULT, LINT1);
+        let madt_offset = tables.len();
+        tables.extend_from_slice(&madt.finish());
+
+        let mut mcfg = Mcfg::new();
+        mcfg.add_allocation(
+            config.pcie_ecam_base,
+            0,
+            config.pcie_bus_start,
+            config.pcie_bus_end,
+        );
+        let mcfg_offset = tables.len();
+        tables.extend_from_slice(&mcfg.finish());
+
+        let hpet = Hpet::new();
+        let hpet_offset = tables.len();
+        tables.extend_from_slice(&hpet.finish());
+
+        let mut xsdt = Xsdt::new();
+        let xsdt_fadt_off = xsdt.add_entry();
+        let xsdt_madt_off = xsdt.add_entry();
+        let xsdt_mcfg_off = xsdt.add_entry();
+        let xsdt_hpet_off = xsdt.add_entry();
+        let xsdt_offset = tables.len();
+        tables.extend_from_slice(&xsdt.finish());
+
+        let facs = Facs::new();
+        let facs_offset = tables.len();
+        tables.extend_from_slice(&facs.finish());
+
+        let rsdp_data = Rsdp::new().finish();
+
+        tables[fadt_offset + FADT_OFF_FACS32
+            ..fadt_offset + FADT_OFF_FACS32 + size_of::<u32>()]
+            .copy_from_slice(&(facs_offset as u32).to_le_bytes());
+
+        tables[fadt_offset + FADT_OFF_DSDT32
+            ..fadt_offset + FADT_OFF_DSDT32 + size_of::<u32>()]
+            .copy_from_slice(&(dsdt_offset as u32).to_le_bytes());
+        tables[fadt_offset + FADT_OFF_DSDT64
+            ..fadt_offset + FADT_OFF_DSDT64 + size_of::<u64>()]
+            .copy_from_slice(&(dsdt_offset as u64).to_le_bytes());
+
+        let xsdt_entries = [
+            (xsdt_fadt_off, fadt_offset),
+            (xsdt_madt_off, madt_offset),
+            (xsdt_mcfg_off, mcfg_offset),
+            (xsdt_hpet_off, hpet_offset),
+        ];
+        for (entry_off, table_offset) in xsdt_entries {
+            let off = xsdt_offset + entry_off as usize;
+            tables[off..off + size_of::<u64>()]
+                .copy_from_slice(&(table_offset as u64).to_le_bytes());
+        }
+
+        loader
+            .add_allocate(ACPI_TABLES_FWCFG_NAME, 64, AllocZone::High)
+            .unwrap();
+        loader.add_allocate(ACPI_RSDP_FWCFG_NAME, 16, AllocZone::FSeg).unwrap();
+
+        let table_pointers: &[(u32, u8)] = &[
+            (
+                fadt_offset as u32 + FADT_OFF_FACS32 as u32,
+                size_of::<u32>() as u8,
+            ),
+            (
+                fadt_offset as u32 + FADT_OFF_DSDT32 as u32,
+                size_of::<u32>() as u8,
+            ),
+            (
+                fadt_offset as u32 + FADT_OFF_DSDT64 as u32,
+                size_of::<u64>() as u8,
+            ),
+            (xsdt_offset as u32 + xsdt_fadt_off, size_of::<u64>() as u8),
+            (xsdt_offset as u32 + xsdt_madt_off, size_of::<u64>() as u8),
+            (xsdt_offset as u32 + xsdt_mcfg_off, size_of::<u64>() as u8),
+            (xsdt_offset as u32 + xsdt_hpet_off, size_of::<u64>() as u8),
+        ];
+        for &(offset, size) in table_pointers {
+            loader
+                .add_pointer(
+                    ACPI_TABLES_FWCFG_NAME,
+                    ACPI_TABLES_FWCFG_NAME,
+                    offset,
+                    size,
+                )
+                .unwrap();
+        }
+
+        loader
+            .add_pointer(
+                ACPI_RSDP_FWCFG_NAME,
+                ACPI_TABLES_FWCFG_NAME,
+                RSDP_XSDT_ADDR_OFFSET as u32,
+                size_of::<u64>() as u8,
+            )
+            .unwrap();
+
+        let table_offsets = [
+            dsdt_offset,
+            fadt_offset,
+            madt_offset,
+            mcfg_offset,
+            hpet_offset,
+            xsdt_offset,
+            facs_offset,
+        ];
+        for pair in table_offsets.windows(2) {
+            let (start, end) = (pair[0] as u32, pair[1] as u32);
+            loader
+                .add_checksum(
+                    ACPI_TABLES_FWCFG_NAME,
+                    start + ACPI_TABLE_CHECKSUM_OFF as u32,
+                    start,
+                    end - start,
+                )
+                .unwrap();
+        }
+
+        let rsdp_checksums = [
+            (RSDP_CHECKSUM_OFFSET, RSDP_V1_SIZE),
+            (RSDP_EXT_CHECKSUM_OFFSET, RSDP_SIZE),
+        ];
+        for (checksum_off, length) in rsdp_checksums {
+            loader
+                .add_checksum(
+                    ACPI_RSDP_FWCFG_NAME,
+                    checksum_off as u32,
+                    0,
+                    length as u32,
+                )
+                .unwrap();
+        }
+
+        let loader_entry = loader.finish();
+        let loader_bytes = match loader_entry {
+            super::Entry::Bytes(b) => b,
+            _ => unreachable!(),
+        };
+
+        AcpiTables { tables, rsdp: rsdp_data, loader: loader_bytes }
+    }
+
     #[cfg(test)]
     mod test_table_loader {
         use super::*;