Add PCIe _OSC method for OS capability negotiation

The OS calls _OSC on the PCIe host bridge to negotiate control of native
PCIe features like hotplug, AER and PME. Without _OSC, Linux logs
warning about missing capability negotiation(_OSC: platform retains
control of PCIe features (AE_NOT_FOUND).
Since as of now we don't have support for any PCIe handling, no
capabilities are exposed. In future when PCIe handling is implemented
the supported bits can be simply unmasked to expose them to the guest.

Also to simplify the aml generation of _OSC itself introduce some high
level wrappers around aml generation.

[1]: https://learn.microsoft.com/en-us/windows-hardware/drivers/pci/enabling-pci-express-native-control

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

Author: glitzflitz

lib/propolis/src/firmware/acpi/aml.rs

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-use super::names::{encode_name_string, EisaId};
+use super::names::{encode_name_string, EisaId, UUID_SIZE};
 use super::opcodes::*;
 
 pub trait AmlWriter {
@@ -441,9 +441,86 @@ impl<'a> MethodGuard<'a> {
         encode_name_string(name, &mut self.builder.buf);
     }
 
+    pub fn return_arg(&mut self, n: u8) {
+        assert!(n <= 6);
+        self.builder.buf.push(RETURN_OP);
+        self.builder.buf.push(ARG0_OP + n);
+    }
+
     pub fn raw(&mut self, bytes: &[u8]) {
         self.builder.raw(bytes);
     }
+
+    pub fn create_dword_field(&mut self, source: u8, offset: u8, name: &str) {
+        self.builder.buf.push(CREATE_DWORD_FIELD_OP);
+        self.builder.buf.push(source);
+        if offset == 0 {
+            self.builder.buf.push(ZERO_OP);
+        } else {
+            self.builder.buf.push(BYTE_PREFIX);
+            self.builder.buf.push(offset);
+        }
+        encode_name_string(name, &mut self.builder.buf);
+    }
+
+    pub fn if_uuid_equal(
+        &mut self,
+        uuid: &[u8; 16],
+        body: impl FnOnce(&mut Self),
+    ) {
+        self.builder.buf.push(IF_OP);
+        let start = self.builder.buf.len();
+        self.builder.buf.extend_from_slice(&[0; MAX_PKG_LENGTH_BYTES]);
+
+        self.builder.buf.push(LEQUAL_OP);
+        self.builder.buf.push(ARG0_OP);
+
+        self.builder.buf.push(BUFFER_OP);
+        let buffer_start = self.builder.buf.len();
+        self.builder.buf.extend_from_slice(&[0; MAX_PKG_LENGTH_BYTES]);
+        self.builder.buf.push(BYTE_PREFIX);
+        self.builder.buf.push(UUID_SIZE as u8);
+        let buffer_content_start = self.builder.buf.len();
+        self.builder.buf.extend_from_slice(uuid);
+        finalize_pkg_length(
+            &mut self.builder.buf,
+            buffer_start,
+            buffer_content_start,
+        );
+
+        let content_start = self.builder.buf.len();
+        body(self);
+        finalize_pkg_length(&mut self.builder.buf, start, content_start);
+    }
+
+    pub fn else_block(&mut self, body: impl FnOnce(&mut Self)) {
+        self.builder.buf.push(ELSE_OP);
+        let start = self.builder.buf.len();
+        self.builder.buf.extend_from_slice(&[0; MAX_PKG_LENGTH_BYTES]);
+        let content_start = self.builder.buf.len();
+        body(self);
+        finalize_pkg_length(&mut self.builder.buf, start, content_start);
+    }
+
+    pub fn and_to(&mut self, name: &str, mask: u32) {
+        self.builder.buf.push(AND_OP);
+        encode_name_string(name, &mut self.builder.buf);
+        mask.write_aml(&mut self.builder.buf);
+        encode_name_string(name, &mut self.builder.buf);
+    }
+
+    pub fn or_to(&mut self, name: &str, value: u32) {
+        self.builder.buf.push(OR_OP);
+        encode_name_string(name, &mut self.builder.buf);
+        value.write_aml(&mut self.builder.buf);
+        encode_name_string(name, &mut self.builder.buf);
+    }
+
+    pub fn store(&mut self, source: &str, dest: &str) {
+        self.builder.buf.push(STORE_OP);
+        encode_name_string(source, &mut self.builder.buf);
+        encode_name_string(dest, &mut self.builder.buf);
+    }
 }
 
 impl Drop for MethodGuard<'_> {

lib/propolis/src/firmware/acpi/dsdt.rs

@@ -189,6 +189,46 @@ fn build_pcie_host_bridge(
         }
     }
     pci0.name_package("_PRT", &prt_entries);
+    pci0.name("SUPP", &0u32);
+
+    build_pcie_osc_method(&mut pci0);
+}
+
+fn build_pcie_osc_method(dev: &mut super::aml::DeviceGuard<'_>) {
+    use super::names::{encode_uuid, UUID_SIZE};
+    use super::opcodes::*;
+
+    const PCIE_UUID: [u8; UUID_SIZE] =
+        encode_uuid("33DB4D5B-1FF7-401C-9657-7441C03DD766");
+    const OSC_STATUS_UNSUPPORT_UUID: u32 = 1 << 2;
+    const OSC_CTRL_PCIE_HP: u32 = 1 << 0;
+    const OSC_CTRL_SHPC_HP: u32 = 1 << 1;
+    const OSC_CTRL_PCIE_PME: u32 = 1 << 2;
+    const OSC_CTRL_PCIE_AER: u32 = 1 << 3;
+    const OSC_CTRL_PCIE_CAP: u32 = 1 << 4;
+
+    let unsupported_mask = !(OSC_CTRL_PCIE_HP
+        | OSC_CTRL_SHPC_HP
+        | OSC_CTRL_PCIE_PME
+        | OSC_CTRL_PCIE_AER
+        | OSC_CTRL_PCIE_CAP);
+
+    let mut osc = dev.method("_OSC", 4, false);
+
+    osc.create_dword_field(ARG3_OP, 0, "CDW1");
+    osc.create_dword_field(ARG3_OP, 4, "CDW2");
+    osc.create_dword_field(ARG3_OP, 8, "CDW3");
+
+    osc.if_uuid_equal(&PCIE_UUID, |osc| {
+        osc.store("CDW2", "SUPP");
+        osc.and_to("CDW3", unsupported_mask);
+    });
+
+    osc.else_block(|osc| {
+        osc.or_to("CDW1", OSC_STATUS_UNSUPPORT_UUID);
+    });
+
+    osc.return_arg(3);
 }
 
 /// Build a PNP0C02 motherboard resources device to reserve ECAM space.

lib/propolis/src/firmware/acpi/mod.rs

@@ -13,6 +13,6 @@ pub mod tables;
 
 pub use aml::{AmlBuilder, AmlWriter, DeviceGuard, MethodGuard, ScopeGuard};
 pub use dsdt::{build_dsdt_aml, DsdtConfig, DsdtGenerator, DsdtScope, PcieConfig};
-pub use names::EisaId;
+pub use names::{encode_uuid, EisaId};
 pub use resources::ResourceTemplateBuilder;
 pub use tables::{Dsdt, Facs, Fadt, Hpet, Madt, Mcfg, Rsdt, Rsdp, Xsdt};

lib/propolis/src/firmware/acpi/names.rs

@@ -133,6 +133,57 @@ impl EisaId {
     }
 }
 
+/// UUID byte size.
+pub const UUID_SIZE: usize = 16;
+
+/// Encode a UUID string into ACPI ToUUID format at compile time.
+///
+/// UUID format: "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
+///
+/// ACPI ToUUID uses mixed-endian encoding:
+/// - First 3 groups (8-4-4 hex digits): little-endian
+/// - Last 2 groups (4-12 hex digits): big-endian
+pub const fn encode_uuid(uuid: &str) -> [u8; UUID_SIZE] {
+    let b = uuid.as_bytes();
+    assert!(b.len() == 36, "UUID must be 36 characters");
+    assert!(
+        b[8] == b'-' && b[13] == b'-' && b[18] == b'-' && b[23] == b'-',
+        "UUID must have dashes at positions 8, 13, 18, 23"
+    );
+
+    const fn hex(c: u8) -> u8 {
+        match c {
+            b'0'..=b'9' => c - b'0',
+            b'A'..=b'F' => c - b'A' + 10,
+            b'a'..=b'f' => c - b'a' + 10,
+            _ => panic!("invalid hex"),
+        }
+    }
+
+    const fn byte(b: &[u8], i: usize) -> u8 {
+        (hex(b[i]) << 4) | hex(b[i + 1])
+    }
+
+    [
+        byte(b, 6),
+        byte(b, 4),
+        byte(b, 2),
+        byte(b, 0),
+        byte(b, 11),
+        byte(b, 9),
+        byte(b, 16),
+        byte(b, 14),
+        byte(b, 19),
+        byte(b, 21),
+        byte(b, 24),
+        byte(b, 26),
+        byte(b, 28),
+        byte(b, 30),
+        byte(b, 32),
+        byte(b, 34),
+    ]
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -190,4 +241,16 @@ mod tests {
     fn eisaid_rejects_lowercase() {
         encode_eisaid("pnp0A08");
     }
+
+    #[test]
+    fn uuid_encoding() {
+        let uuid = encode_uuid("33DB4D5B-1FF7-401C-9657-7441C03DD766");
+        assert_eq!(
+            uuid,
+            [
+                0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40, 0x96, 0x57,
+                0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66,
+            ]
+        );
+    }
 }

lib/propolis/src/firmware/acpi/opcodes.rs

@@ -94,6 +94,7 @@ pub const SIZEOF_OP: u8 = 0x87;
 pub const INDEX_OP: u8 = 0x88;
 pub const DEREF_OF_OP: u8 = 0x83;
 pub const REF_OF_OP: u8 = 0x71;
+pub const CREATE_DWORD_FIELD_OP: u8 = 0x8A;
 
 // Resource template end tag
 pub const END_TAG: u8 = 0x79;