lancer / kernel / src / acpi / dmar.rs

use crate::static_vec::StaticVec;

const DMAR_HEADER_SIZE: usize = 48;

const DRHD_TYPE: u16 = 0;
const RMRR_TYPE: u16 = 1;

#[repr(C, packed)]
struct DmarHeader {
    _sdt_header: [u8; 36],
    host_address_width: u8,
    flags: u8,
    _reserved: [u8; 10],
}

#[repr(C, packed)]
struct RemappingStructHeader {
    structure_type: u16,
    length: u16,
}

#[repr(C, packed)]
struct DrhdEntry {
    _header: RemappingStructHeader,
    flags: u8,
    _reserved: u8,
    segment: u16,
    register_base: u64,
}

#[repr(C, packed)]
struct RmrrEntry {
    _header: RemappingStructHeader,
    _reserved: u16,
    segment: u16,
    base_address: u64,
    limit_address: u64,
}

#[repr(C, packed)]
struct DeviceScopeEntry {
    scope_type: u8,
    length: u8,
    _reserved: u16,
    enumeration_id: u8,
    start_bus: u8,
}

#[repr(C, packed)]
struct DeviceScopePath {
    device: u8,
    function: u8,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub struct DeviceScopeInfo {
    pub scope_type: u8,
    pub enumeration_id: u8,
    pub start_bus: u8,
    pub path: StaticVec<(u8, u8), 4>,
}

#[derive(Debug, Clone)]
pub struct DrhdInfo {
    pub register_base: u64,
    pub segment: u16,
    pub flags: u8,
    #[allow(dead_code)]
    pub device_scopes: StaticVec<DeviceScopeInfo, 8>,
}

#[derive(Debug, Clone)]
pub struct RmrrInfo {
    #[allow(dead_code)]
    pub segment: u16,
    pub base_address: u64,
    pub limit_address: u64,
    pub device_scopes: StaticVec<DeviceScopeInfo, 8>,
}

#[derive(Debug, Clone)]
pub struct DmarInfo {
    #[allow(dead_code)]
    pub host_address_width: u8,
    #[allow(dead_code)]
    pub flags: u8,
    pub drhd_units: StaticVec<DrhdInfo, 4>,
    pub rmrr_regions: StaticVec<RmrrInfo, 8>,
}

fn parse_device_scopes(
    base: *const u8,
    entry_len: usize,
    fixed_header_size: usize,
) -> StaticVec<DeviceScopeInfo, 8> {
    let scope_start = fixed_header_size;
    let min_scope = core::mem::size_of::<DeviceScopeEntry>();
    core::iter::successors(Some(scope_start), move |&offset| {
        if offset + min_scope > entry_len {
            return None;
        }
        let scope_ptr = unsafe { base.add(offset) } as *const DeviceScopeEntry;
        let scope_len =
            unsafe { core::ptr::addr_of!((*scope_ptr).length).read_unaligned() } as usize;
        if scope_len < min_scope {
            None
        } else {
            Some(offset + scope_len)
        }
    })
    .take_while(|&offset| offset + min_scope <= entry_len)
    .fold(StaticVec::new(), |mut scopes, offset| {
        let scope_ptr = unsafe { base.add(offset) } as *const DeviceScopeEntry;
        let raw_scope_len =
            unsafe { core::ptr::addr_of!((*scope_ptr).length).read_unaligned() } as usize;
        let scope_len = raw_scope_len.min(entry_len.saturating_sub(offset));
        let scope_type = unsafe { core::ptr::addr_of!((*scope_ptr).scope_type).read_unaligned() };
        let enumeration_id =
            unsafe { core::ptr::addr_of!((*scope_ptr).enumeration_id).read_unaligned() };
        let start_bus = unsafe { core::ptr::addr_of!((*scope_ptr).start_bus).read_unaligned() };

        let path_offset = core::mem::size_of::<DeviceScopeEntry>();
        let path_bytes = scope_len.saturating_sub(path_offset);
        let path_count = path_bytes / core::mem::size_of::<DeviceScopePath>();

        let path = (0..path_count).fold(StaticVec::new(), |mut p, i| {
            let path_ptr =
                unsafe { base.add(offset + path_offset + i * 2) } as *const DeviceScopePath;
            let device = unsafe { core::ptr::addr_of!((*path_ptr).device).read_unaligned() };
            let function = unsafe { core::ptr::addr_of!((*path_ptr).function).read_unaligned() };
            let _ = p.push((device, function));
            p
        });

        let _ = scopes.push(DeviceScopeInfo {
            scope_type,
            enumeration_id,
            start_bus,
            path,
        });
        scopes
    })
}

pub fn parse_dmar(virt_addr: u64, length: u32) -> DmarInfo {
    let base = virt_addr as *const u8;
    let hdr_ptr = base as *const DmarHeader;
    let host_address_width =
        unsafe { core::ptr::addr_of!((*hdr_ptr).host_address_width).read_unaligned() };
    let flags = unsafe { core::ptr::addr_of!((*hdr_ptr).flags).read_unaligned() };

    crate::kprintln!(
        "  DMAR: host address width {}, flags {:#x}",
        host_address_width,
        flags
    );

    let min_entry = core::mem::size_of::<RemappingStructHeader>();
    let entries = core::iter::successors(Some(DMAR_HEADER_SIZE), move |&offset| {
        if offset + min_entry > length as usize {
            return None;
        }
        let header_ptr = unsafe { base.add(offset) } as *const RemappingStructHeader;
        let entry_len =
            unsafe { core::ptr::addr_of!((*header_ptr).length).read_unaligned() } as usize;
        if entry_len < min_entry {
            None
        } else {
            Some(offset + entry_len)
        }
    });

    let (drhd_units, rmrr_regions) = entries
        .take_while(|&offset| offset + min_entry <= length as usize)
        .fold(
            (StaticVec::new(), StaticVec::new()),
            |(mut units, mut rmrrs), offset| {
                let header_ptr = unsafe { base.add(offset) } as *const RemappingStructHeader;
                let structure_type =
                    unsafe { core::ptr::addr_of!((*header_ptr).structure_type).read_unaligned() };
                let entry_len =
                    unsafe { core::ptr::addr_of!((*header_ptr).length).read_unaligned() } as usize;

                match structure_type {
                    DRHD_TYPE if entry_len >= core::mem::size_of::<DrhdEntry>() => {
                        let drhd_ptr = unsafe { base.add(offset) } as *const DrhdEntry;
                        let drhd_flags =
                            unsafe { core::ptr::addr_of!((*drhd_ptr).flags).read_unaligned() };
                        let segment =
                            unsafe { core::ptr::addr_of!((*drhd_ptr).segment).read_unaligned() };
                        let register_base = unsafe {
                            core::ptr::addr_of!((*drhd_ptr).register_base).read_unaligned()
                        };

                        let device_scopes = parse_device_scopes(
                            unsafe { base.add(offset) },
                            entry_len,
                            core::mem::size_of::<DrhdEntry>(),
                        );

                        crate::kprintln!(
                            "  DMAR: DRHD at {:#x}, segment {}, flags {:#x}, {} device scope(s)",
                            register_base,
                            segment,
                            drhd_flags,
                            device_scopes.len()
                        );

                        let _ = units.push(DrhdInfo {
                            register_base,
                            segment,
                            flags: drhd_flags,
                            device_scopes,
                        });
                    }
                    RMRR_TYPE if entry_len >= core::mem::size_of::<RmrrEntry>() => {
                        let rmrr_ptr = unsafe { base.add(offset) } as *const RmrrEntry;
                        let segment =
                            unsafe { core::ptr::addr_of!((*rmrr_ptr).segment).read_unaligned() };
                        let base_address = unsafe {
                            core::ptr::addr_of!((*rmrr_ptr).base_address).read_unaligned()
                        };
                        let limit_address = unsafe {
                            core::ptr::addr_of!((*rmrr_ptr).limit_address).read_unaligned()
                        };

                        let device_scopes = parse_device_scopes(
                            unsafe { base.add(offset) },
                            entry_len,
                            core::mem::size_of::<RmrrEntry>(),
                        );

                        crate::kprintln!(
                            "  DMAR: RMRR {:#x}-{:#x}, segment {}, {} device scope(s)",
                            base_address,
                            limit_address,
                            segment,
                            device_scopes.len()
                        );

                        let _ = rmrrs.push(RmrrInfo {
                            segment,
                            base_address,
                            limit_address,
                            device_scopes,
                        });
                    }
                    _ => {}
                }

                (units, rmrrs)
            },
        );

    DmarInfo {
        host_address_width,
        flags,
        drhd_units,
        rmrr_regions,
    }
}