update

Author: ZR233

Cargo.lock

@@ -12,3 +12,8 @@ version = "0.1.0"
 axconfig-macros = "0.2"
 axplat = {git = "https://github.com/arceos-org/axplat_crates"}
 pie-boot = {version = "0.2.1"}
+any-uart = "0.2.11"
+spin = "0.10"
+axcpu = { workspace = true }
+heapless = "0.8"
+fdt-parser = "0.4"

platforms/axplat-aarch64-dyn/Cargo.toml

@@ -1,18 +1,80 @@
+use core::ptr::NonNull;
+
+use any_uart::{Receiver, Sender};
 use axplat::console::ConsoleIf;
+use fdt_parser::Fdt;
+use spin::Mutex;
+
+use crate::boot_info;
+
+static TX: Mutex<Option<Sender>> = Mutex::new(None);
+static RX: Mutex<Option<Receiver>> = Mutex::new(None);
+
+pub(crate) fn setup_early() -> Option<()> {
+    let ptr = boot_info().fdt?;
+    let fdt = Fdt::from_ptr(ptr).ok()?;
+    let choson = fdt.chosen()?;
+    let node = choson.debugcon()?;
+    fn phys_to_virt(p: usize) -> *mut u8 {
+        p as _
+    }
+
+    let mut uart = any_uart::Uart::new_by_fdt_node(&node, phys_to_virt)?;
+    *TX.lock() = uart.tx.take();
+    *RX.lock() = uart.rx.take();
+
+    Some(())
+}
 
 struct ConsoleIfImpl;
 
 #[impl_plat_interface]
 impl ConsoleIf for ConsoleIfImpl {
     /// Writes given bytes to the console.
     fn write_bytes(bytes: &[u8]) {
-        todo!()
+        let mut g = TX.lock();
+        if let Some(tx) = g.as_mut() {
+            macro_rules! write_byte {
+                ($b:expr) => {
+                    let _ = any_uart::block!(tx.write($b));
+                };
+            }
+
+            for &c in bytes {
+                match c {
+                    b'\n' => {
+                        write_byte!(b'\r');
+                        write_byte!(b'\n');
+                    }
+                    c => {
+                        write_byte!(c);
+                    }
+                }
+            }
+        }
     }
 
     /// Reads bytes from the console into the given mutable slice.
     ///
     /// Returns the number of bytes read.
     fn read_bytes(bytes: &mut [u8]) -> usize {
-        todo!()
+        let mut read_len = 0;
+        while read_len < bytes.len() {
+            if let Some(c) = getchar() {
+                bytes[read_len] = c;
+            } else {
+                break;
+            }
+            read_len += 1;
+        }
+        read_len
+    }
+}
+fn getchar() -> Option<u8> {
+    let mut g = RX.lock();
+    if let Some(rx) = g.as_mut() {
+        any_uart::block!(rx.read()).ok()
+    }else{
+        None
     }
 }

platforms/axplat-aarch64-dyn/src/console.rs

@@ -1,5 +1,7 @@
 use axplat::init::InitIf;
 
+use crate::console;
+
 struct InitIfImpl;
 
 #[impl_plat_interface]
@@ -29,14 +31,15 @@ impl InitIf for InitIfImpl {
     /// * Early console is initialized.
     /// * Current monotonic time and wall time can be obtained.
     fn init_early(cpu_id: usize, arg: usize) {
-        todo!()
+        axcpu::init::init_trap();
+        console::setup_early();
     }
 
     /// Initializes the platform at the early stage for secondary cores.
     ///
     /// See [`init_early`] for details.
     fn init_early_secondary(cpu_id: usize) {
-        todo!()
+        axcpu::init::init_trap();
     }
 
     /// Initializes the platform at the later stage for the primary core.

platforms/axplat-aarch64-dyn/src/init.rs

@@ -5,6 +5,7 @@
 extern crate axplat;
 
 use pie_boot::BootInfo;
+use spin::Once;
 
 mod console;
 mod init;
@@ -17,8 +18,20 @@ mod config {
     axconfig_macros::include_configs!(path_env = "AX_CONFIG_PATH", fallback = "axconfig.toml");
 }
 
+static BOOT_INFO: Once<BootInfo> = Once::new();
+
 #[pie_boot::entry]
 fn main(args: &BootInfo) -> ! {
-    // TODO: Implement actual bootstrap logic
-    axplat::call_main(args.cpu_id, args.fdt.map(|p| p.as_ptr() as usize).unwrap_or_default());
+    BOOT_INFO.call_once(move || args.clone());
+
+    mem::setup();
+
+    axplat::call_main(
+        args.cpu_id,
+        args.fdt.map(|p| p.as_ptr() as usize).unwrap_or_default(),
+    );
+}
+
+fn boot_info() -> &'static BootInfo {
+    BOOT_INFO.wait()
 }

platforms/axplat-aarch64-dyn/src/lib.rs

@@ -1,15 +1,57 @@
 use axplat::mem::{MemIf, RawRange};
+use heapless::Vec;
+use pie_boot::MemoryRegionKind;
+use spin::{Mutex, Once};
+
+use crate::boot_info;
 
 struct MemIfImpl;
 
+static RAM_LIST: Once<Vec<RawRange, 32>> = Once::new();
+static RESERVED_LIST: Once<Vec<RawRange, 32>> = Once::new();
+static MMIO: Mutex<Vec<RawRange, 32>> = Mutex::new(Vec::new());
+
+pub fn setup() {
+    RAM_LIST.call_once(|| {
+        let mut ram_list = Vec::new();
+        for region in boot_info()
+            .memory_regions
+            .iter()
+            .filter(|one| matches!(one.kind, MemoryRegionKind::Ram))
+            .map(|one| (one.start, one.end - one.start))
+        {
+            let _ = ram_list.push(region);
+        }
+        ram_list
+    });
+
+    RESERVED_LIST.call_once(|| {
+        let mut ram_list = Vec::new();
+        for region in boot_info()
+            .memory_regions
+            .iter()
+            .filter(|one| {
+                matches!(
+                    one.kind,
+                    MemoryRegionKind::Reserved | MemoryRegionKind::Bootloader
+                )
+            })
+            .map(|one| (one.start, one.end - one.start))
+        {
+            let _ = ram_list.push(region);
+        }
+        ram_list
+    });
+}
+
 #[impl_plat_interface]
 impl MemIf for MemIfImpl {
     /// Returns all physical memory (RAM) ranges on the platform.
     ///
     /// All memory ranges except reserved ranges (including the kernel loaded
     /// range) are free for allocation.
     fn phys_ram_ranges() -> &'static [RawRange] {
-        todo!()
+        RAM_LIST.wait()
     }
 
     /// Returns all reserved physical memory ranges on the platform.
@@ -20,11 +62,11 @@ impl MemIf for MemIfImpl {
     /// Note that the ranges returned should not include the range where the
     /// kernel is loaded.
     fn reserved_phys_ram_ranges() -> &'static [RawRange] {
-        todo!()
+        RESERVED_LIST.wait()
     }
 
     /// Returns all device memory (MMIO) ranges on the platform.
     fn mmio_ranges() -> &'static [RawRange] {
-        todo!()
+        &[]
     }
 }