Use dt to get physical memory, fix some FDT code

Signed-off-by: Graham MacDonald <[email protected]>

Author: gmacd

aarch64/src/mailbox.rs

@@ -194,6 +194,7 @@ pub struct MemoryInfo {
     pub end: u32,
 }
 
+#[allow(dead_code)]
 pub fn get_arm_memory() -> PhysRange {
     let tags = Tag::<EmptyRequest> {
         tag_id0: TagId::GetArmMemory,
@@ -210,6 +211,7 @@ pub fn get_arm_memory() -> PhysRange {
     PhysRange::new(PhysAddr::new(start as u64), PhysAddr::new(end as u64))
 }
 
+#[allow(dead_code)]
 pub fn get_vc_memory() -> PhysRange {
     let tags = Tag::<EmptyRequest> {
         tag_id0: TagId::GetVcMemory,

aarch64/src/main.rs

@@ -57,14 +57,6 @@ fn print_binary_sections() {
     }
 }
 
-fn print_physical_memory_info() {
-    println!("Physical memory map:");
-    let arm_mem = mailbox::get_arm_memory();
-    println!("  Memory:\t{arm_mem} ({:#x})", arm_mem.size());
-    let vc_mem = mailbox::get_vc_memory();
-    println!("  Video:\t{vc_mem} ({:#x})", vc_mem.size());
-}
-
 fn print_memory_info() {
     println!("Memory usage:");
     let (used, total) = pagealloc::usage_bytes();
@@ -118,19 +110,14 @@ pub extern "C" fn main9(dtb_va: usize) {
     println!("midr_el1: {:?}", registers::MidrEl1::read());
 
     print_binary_sections();
-    print_physical_memory_info();
     print_board_info();
 
     pagealloc::init_page_allocator();
 
     // Map address space accurately using rust VM code to manage page tables
     unsafe {
         let dtb_range = PhysRange::with_len(from_virt_to_physaddr(dtb_va).addr(), dt.size());
-        vm::init_kernel_page_tables(
-            &mut *ptr::addr_of_mut!(KERNEL_PAGETABLE),
-            dtb_range,
-            mailbox::get_arm_memory(),
-        );
+        vm::init_kernel_page_tables(&dt, &mut *ptr::addr_of_mut!(KERNEL_PAGETABLE), dtb_range);
         vm::switch(&*ptr::addr_of!(KERNEL_PAGETABLE), RootPageTableType::Kernel);
 
         vm::init_user_page_tables(&mut *ptr::addr_of_mut!(USER_PAGETABLE));

aarch64/src/vm.rs

@@ -17,6 +17,7 @@ use core::fmt;
 use core::ptr::write_volatile;
 use num_enum::{FromPrimitive, IntoPrimitive};
 use port::{
+    fdt::DeviceTree,
     mem::{PAGE_SIZE_1G, PAGE_SIZE_2M, PAGE_SIZE_4K, PhysAddr, PhysRange},
     pagealloc::PageAllocError,
 };
@@ -509,9 +510,9 @@ pub fn root_page_table(pgtype: RootPageTableType) -> &'static mut RootPageTable
 }
 
 pub unsafe fn init_kernel_page_tables(
+    dt: &DeviceTree,
     new_kernel_root_page_table: &mut RootPageTable,
     dtb_range: PhysRange,
-    available_mem: PhysRange,
 ) {
     // We use recursive page tables, but we have to be careful in the init call,
     // since the kpage_table is not currently pointed to by ttbr1_el1.  Any
@@ -520,6 +521,17 @@ pub unsafe fn init_kernel_page_tables(
     // because kpage_table hasn't been switched to yet.
     unsafe { init_empty_root_page_table(new_kernel_root_page_table) };
 
+    // We only use the first memory range for now.
+    // TODO Handle multiple memory ranges
+    let available_mem = dt
+        .find_device_type("memory")
+        .flat_map(|memory| dt.property_translated_reg_iter(memory).flat_map(|r| r.regblock()))
+        .map(|memory| PhysRange::from(&memory))
+        .next()
+        .expect("No memory range found in device tree");
+    println!("Physical Memory:");
+    println!("  {}", &available_mem);
+
     // TODO leave the first page unmapped to catch null pointer dereferences in unsafe code
     let custom_map = {
         // The DTB range might not end on a page boundary, so round up.

port/src/fdt.rs

@@ -104,15 +104,19 @@ impl<'a> DeviceTree<'a> {
         self.node_from_index(0, 0)
     }
 
-    pub fn children(&self, parent: &Node) -> impl Iterator<Item = Node> + '_ {
+    pub fn children<'b>(&'b self, parent: &'b Node) -> impl Iterator<Item = Node> + 'b {
         // Start searching linearly after node.start (which points to the start of the parent)
         let mut i = parent.next_token_start;
         let child_depth = parent.depth + 1;
 
         core::iter::from_fn(move || {
             let child = self.node_from_index(i, child_depth)?;
-            i = child.start + child.total_len;
-            Some(child)
+            if parent.encloses(&child) {
+                i = child.start + child.total_len;
+                Some(child)
+            } else {
+                None
+            }
         })
     }
 
@@ -394,6 +398,16 @@ impl<'a> DeviceTree<'a> {
         })
     }
 
+    /// Return iterator of nodes matching the device_type string 'device_type'
+    pub fn find_device_type(&'a self, device_type: &'a str) -> impl Iterator<Item = Node> + 'a {
+        self.nodes().filter(|n| {
+            if let Some(prop) = self.property(n, "device_type") {
+                return self.property_value_contains(&prop, device_type);
+            }
+            false
+        })
+    }
+
     fn inline_str(bytes: &[mem::MaybeUninit<u8>], start: usize) -> Option<&str> {
         let maybe_uninit_bytes = bytes.get(start..)?;
         let init_bytes = unsafe { maybe_uninit_bytes.assume_init_ref() };

port/src/mem.rs

@@ -39,6 +39,12 @@ impl From<&RegBlock> for VirtRange {
     }
 }
 
+impl fmt::Display for VirtRange {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:#018x}..{:#018x}", self.0.start, self.0.end)
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord)]
 #[repr(transparent)]
 pub struct PhysAddr(pub u64);
@@ -154,7 +160,7 @@ impl PhysRange {
 
 impl fmt::Display for PhysRange {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:#016x}..{:#016x}", self.0.start.addr(), self.0.end.addr())
+        write!(f, "{:#018x}..{:#018x}", self.0.start.addr(), self.0.end.addr())
     }
 }
 

port/tests/fdt_test.rs

@@ -75,18 +75,14 @@ fn find_compatible() {
     );
 
     // Doesn't find substrings
-    assert!(dt
-        .find_compatible("arm")
-        .flat_map(|n| dt.node_name(&n))
-        .collect::<Vec<&str>>()
-        .is_empty());
+    assert!(
+        dt.find_compatible("arm").flat_map(|n| dt.node_name(&n)).collect::<Vec<&str>>().is_empty()
+    );
 
     // No match
-    assert!(dt
-        .find_compatible("xxxx")
-        .flat_map(|n| dt.node_name(&n))
-        .collect::<Vec<&str>>()
-        .is_empty());
+    assert!(
+        dt.find_compatible("xxxx").flat_map(|n| dt.node_name(&n)).collect::<Vec<&str>>().is_empty()
+    );
 }
 
 #[test]
@@ -114,6 +110,28 @@ fn get_cells() {
     );
 }
 
+#[test]
+fn iterate_over_children() {
+    let dt = DeviceTree::new(TEST1_DTB).unwrap();
+
+    let children = dt
+        .find_by_path("/thermal-zones")
+        .iter()
+        .flat_map(|resmem| dt.children(resmem))
+        .flat_map(|n| dt.node_name(&n))
+        .collect::<Vec<&str>>();
+
+    assert_eq!(children, vec!["cpu-thermal"]);
+}
+
+#[test]
+fn iterate_over_device_types() {
+    let dt = DeviceTree::new(TEST1_DTB).unwrap();
+
+    let cpus = dt.find_device_type("cpu").flat_map(|n| dt.node_name(&n)).collect::<Vec<&str>>();
+    assert_eq!(cpus, vec!["cpu@0", "cpu@1", "cpu@2", "cpu@3"]);
+}
+
 #[test]
 fn get_reg() {
     let dt = DeviceTree::new(TEST1_DTB).unwrap();