feat: add struct Board and replace Board with SBI_IMPL

Signed-off-by: Woshiluo Luo <woshiluo.luo@outlook.com>

prototyper/src/board.rs

@@ -1,6 +1,6 @@
 use aclint::SifiveClint;
-use core::mem::MaybeUninit;
 use core::{
+    ops::Range,
     ptr::{null, null_mut},
     sync::atomic::{AtomicPtr, Ordering::Release},
 };
@@ -12,11 +12,38 @@ use uart_xilinx::uart_lite::uart::MmioUartAxiLite;
 use crate::sbi::console::ConsoleDevice;
 use crate::sbi::ipi::IpiDevice;
 use crate::sbi::reset::ResetDevice;
-use crate::sbi::SBI;
+use crate::sbi::Sbi;
 
-pub(crate) static mut SBI_IMPL: MaybeUninit<
-    SBI<'static, MachineConsole, SifiveClint, SifiveTestDevice>,
-> = MaybeUninit::uninit();
+pub struct Device {
+    pub memory_range: Option<Range<usize>>,
+    pub uart: Mutex<MachineConsole>,
+    pub sifive_test: AtomicPtr<SifiveTestDevice>,
+    pub sifive_clint: AtomicPtr<SifiveClint>,
+}
+
+pub struct Board<'a> {
+    pub sbi: Sbi<'a, MachineConsole, SifiveClint, SifiveTestDevice>,
+    pub device: Device,
+}
+
+pub(crate) static mut BOARD: Board<'static> = Board {
+    device: Device {
+        memory_range: None,
+        #[cfg(feature = "nemu")]
+        uart: Mutex::new(MachineConsole::UartAxiLite(MmioUartAxiLite::new(0))),
+        #[cfg(not(feature = "nemu"))]
+        uart: Mutex::new(MachineConsole::Uart16550(null())),
+        sifive_test: AtomicPtr::new(null_mut()),
+        sifive_clint: AtomicPtr::new(null_mut()),
+    },
+    sbi: Sbi {
+        console: None,
+        ipi: None,
+        reset: None,
+        hsm: None,
+        rfence: None,
+    },
+};
 
 /// Console Device: Uart16550
 #[doc(hidden)]
@@ -48,17 +75,12 @@ impl ConsoleDevice for MachineConsole {
 // TODO: select driver follow fdt
 
 #[doc(hidden)]
-#[cfg(feature = "nemu")]
-pub(crate) static UART: Mutex<MachineConsole> =
-    Mutex::new(MachineConsole::UartAxiLite(MmioUartAxiLite::new(0)));
-#[cfg(not(feature = "nemu"))]
-pub(crate) static UART: Mutex<MachineConsole> = Mutex::new(MachineConsole::Uart16550(null()));
 pub(crate) fn console_dev_init(base: usize) {
-    let new_console = match *UART.lock() {
+    let new_console = match *unsafe { BOARD.device.uart.lock() } {
         MachineConsole::Uart16550(_) => MachineConsole::Uart16550(base as _),
         MachineConsole::UartAxiLite(_) => MachineConsole::UartAxiLite(MmioUartAxiLite::new(base)),
     };
-    *UART.lock() = new_console;
+    *unsafe { BOARD.device.uart.lock() } = new_console;
 }
 
 /// Ipi Device: Sifive Clint
@@ -100,9 +122,10 @@ impl IpiDevice for SifiveClint {
 }
 
 #[doc(hidden)]
-pub(crate) static SIFIVECLINT: AtomicPtr<SifiveClint> = AtomicPtr::new(null_mut());
 pub(crate) fn ipi_dev_init(base: usize) {
-    SIFIVECLINT.store(base as _, Release);
+    unsafe {
+        BOARD.device.sifive_clint.store(base as _, Release);
+    }
 }
 
 /// Reset Device: SifiveTestDevice
@@ -124,7 +147,8 @@ impl ResetDevice for SifiveTestDevice {
 }
 
 #[doc(hidden)]
-pub(crate) static SIFIVETEST: AtomicPtr<SifiveTestDevice> = AtomicPtr::new(null_mut());
 pub fn reset_dev_init(base: usize) {
-    SIFIVETEST.store(base as _, Release);
+    unsafe {
+        BOARD.device.sifive_test.store(base as _, Release);
+    }
 }

prototyper/src/macros.rs

@@ -4,7 +4,7 @@
 macro_rules! print {
     ($($arg:tt)*) => {
         use core::fmt::Write;
-        let console = unsafe { $crate::board::SBI_IMPL.assume_init_mut() }.console.as_mut().unwrap();
+        let console = unsafe { $crate::board::BOARD.sbi.console.as_mut().unwrap() };
         console.write_fmt(core::format_args!($($arg)*)).unwrap();
         drop(console);
     }
@@ -15,7 +15,7 @@ macro_rules! println {
     () => ($crate::print!("\n"));
     ($($arg:tt)*) => {{
         use core::fmt::Write;
-        let console = unsafe { $crate::board::SBI_IMPL.assume_init_mut() }.console.as_mut().unwrap();
+        let console = unsafe { $crate::board::BOARD.sbi.console.as_mut().unwrap() };
         console.write_fmt(core::format_args!($($arg)*)).unwrap();
         console.write_char('\n').unwrap();
     }}

prototyper/src/main.rs

@@ -15,12 +15,12 @@ mod platform;
 mod riscv_spec;
 mod sbi;
 
+use core::arch::asm;
 use core::sync::atomic::{AtomicBool, Ordering};
-use core::{arch::asm, mem::MaybeUninit};
 
 use sbi::extensions;
 
-use crate::board::{SBI_IMPL, SIFIVECLINT, SIFIVETEST, UART};
+use crate::board::BOARD;
 use crate::riscv_spec::{current_hartid, menvcfg};
 use crate::sbi::console::SbiConsole;
 use crate::sbi::extensions::{hart_extension_probe, Extension};
@@ -32,7 +32,7 @@ use crate::sbi::reset::SbiReset;
 use crate::sbi::rfence::SbiRFence;
 use crate::sbi::trap::{self, trap_vec};
 use crate::sbi::trap_stack;
-use crate::sbi::SBI;
+use crate::sbi::Sbi;
 
 pub const START_ADDRESS: usize = 0x80000000;
 pub const R_RISCV_RELATIVE: usize = 3;
@@ -87,14 +87,14 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
 
         // 3. Init SBI
         unsafe {
-            SBI_IMPL = MaybeUninit::new(SBI {
-                console: Some(SbiConsole::new(&UART)),
-                ipi: Some(SbiIpi::new(&SIFIVECLINT, cpu_num)),
+            BOARD.device.memory_range = Some(memory_range);
+            BOARD.sbi = Sbi {
+                console: Some(SbiConsole::new(&BOARD.device.uart)),
+                ipi: Some(SbiIpi::new(&BOARD.device.sifive_clint, cpu_num)),
                 hsm: Some(SbiHsm),
-                reset: Some(SbiReset::new(&SIFIVETEST)),
+                reset: Some(SbiReset::new(&BOARD.device.sifive_test)),
                 rfence: Some(SbiRFence),
-                memory_range,
-            });
+            };
         }
 
         // Setup trap handling.
@@ -124,7 +124,7 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
                 .unwrap_or("<unspecified>")
         );
 
-        platform::set_pmp(&unsafe { SBI_IMPL.assume_init_ref() }.memory_range);
+        platform::set_pmp(unsafe { BOARD.device.memory_range.as_ref().unwrap() });
 
         // Get boot information and prepare for kernel entry.
         let boot_info = platform::get_boot_info(nonstandard_a2);
@@ -152,7 +152,7 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
             core::hint::spin_loop()
         }
 
-        platform::set_pmp(&unsafe { SBI_IMPL.assume_init_ref() }.memory_range);
+        platform::set_pmp(unsafe { BOARD.device.memory_range.as_ref().unwrap() });
     }
 
     // Clear all pending IPIs.

prototyper/src/sbi/console.rs

@@ -1,4 +1,4 @@
-use crate::board::SBI_IMPL;
+use crate::board::BOARD;
 use core::fmt::{self, Write};
 use rustsbi::{Console, Physical, SbiRet};
 use spin::Mutex;
@@ -114,19 +114,11 @@ impl<'a, T: ConsoleDevice> fmt::Write for SbiConsole<'a, T> {
 /// Global function to write a character to the console.
 #[inline]
 pub fn putchar(c: usize) -> usize {
-    unsafe { SBI_IMPL.assume_init_mut() }
-        .console
-        .as_mut()
-        .unwrap()
-        .putchar(c)
+    unsafe { BOARD.sbi.console.as_mut().unwrap().putchar(c) }
 }
 
 /// Global function to read a character from the console.
 #[inline]
 pub fn getchar() -> usize {
-    unsafe { SBI_IMPL.assume_init_mut() }
-        .console
-        .as_mut()
-        .unwrap()
-        .getchar()
+    unsafe { BOARD.sbi.console.as_mut().unwrap().getchar() }
 }

prototyper/src/sbi/hsm.rs

@@ -6,7 +6,7 @@ use core::{
 use riscv::register::mstatus::MPP;
 use rustsbi::{spec::hsm::hart_state, SbiRet};
 
-use crate::board::SBI_IMPL;
+use crate::board::BOARD;
 use crate::riscv_spec::current_hartid;
 use crate::sbi::hart_context::NextStage;
 use crate::sbi::trap_stack::ROOT_STACK;
@@ -195,11 +195,9 @@ impl rustsbi::Hsm for SbiHsm {
                     opaque,
                     next_mode: MPP::Supervisor,
                 }) {
-                    unsafe { SBI_IMPL.assume_init_ref() }
-                        .ipi
-                        .as_ref()
-                        .unwrap()
-                        .set_msip(hartid);
+                    unsafe {
+                        BOARD.sbi.ipi.as_ref().unwrap().set_msip(hartid);
+                    }
                     SbiRet::success(0)
                 } else {
                     SbiRet::already_started()
@@ -213,11 +211,9 @@ impl rustsbi::Hsm for SbiHsm {
     #[inline]
     fn hart_stop(&self) -> SbiRet {
         local_hsm().stop();
-        unsafe { SBI_IMPL.assume_init_ref() }
-            .ipi
-            .as_ref()
-            .unwrap()
-            .clear_msip(current_hartid());
+        unsafe {
+            BOARD.sbi.ipi.as_ref().unwrap().clear_msip(current_hartid());
+        }
         unsafe {
             riscv::register::mie::clear_msoft();
         }
@@ -239,11 +235,9 @@ impl rustsbi::Hsm for SbiHsm {
         use rustsbi::spec::hsm::suspend_type::{NON_RETENTIVE, RETENTIVE};
         if matches!(suspend_type, NON_RETENTIVE | RETENTIVE) {
             local_hsm().suspend();
-            unsafe { SBI_IMPL.assume_init_ref() }
-                .ipi
-                .as_ref()
-                .unwrap()
-                .clear_msip(current_hartid());
+            unsafe {
+                BOARD.sbi.ipi.as_ref().unwrap().clear_msip(current_hartid());
+            }
             unsafe {
                 riscv::register::mie::set_msoft();
             }

prototyper/src/sbi/ipi.rs

@@ -1,7 +1,7 @@
 use core::sync::atomic::{AtomicPtr, Ordering::Relaxed};
 use rustsbi::SbiRet;
 
-use crate::board::SBI_IMPL;
+use crate::board::BOARD;
 use crate::riscv_spec::{current_hartid, stimecmp};
 use crate::sbi::extensions::{hart_extension_probe, Extension};
 use crate::sbi::hsm::remote_hsm;
@@ -213,7 +213,7 @@ pub fn get_and_reset_ipi_type() -> u8 {
 /// Clear machine software interrupt pending for current hart.
 #[inline]
 pub fn clear_msip() {
-    match unsafe { SBI_IMPL.as_ptr().as_ref().and_then(|sbi| sbi.ipi.as_ref()) } {
+    match unsafe { BOARD.sbi.ipi.as_ref() } {
         Some(ipi) => ipi.clear_msip(current_hartid()),
         None => error!("SBI or IPI device not initialized"),
     }
@@ -222,7 +222,7 @@ pub fn clear_msip() {
 /// Clear machine timer interrupt for current hart.
 #[inline]
 pub fn clear_mtime() {
-    match unsafe { SBI_IMPL.as_ptr().as_ref().and_then(|sbi| sbi.ipi.as_ref()) } {
+    match unsafe { BOARD.sbi.ipi.as_ref() } {
         Some(ipi) => ipi.write_mtimecmp(current_hartid(), u64::MAX),
         None => error!("SBI or IPI device not initialized"),
     }
@@ -231,7 +231,7 @@ pub fn clear_mtime() {
 /// Clear all pending interrupts for current hart.
 #[inline]
 pub fn clear_all() {
-    match unsafe { SBI_IMPL.as_ptr().as_ref().and_then(|sbi| sbi.ipi.as_ref()) } {
+    match unsafe { BOARD.sbi.ipi.as_ref() } {
         Some(ipi) => ipi.clear(),
         None => error!("SBI or IPI device not initialized"),
     }

prototyper/src/sbi/mod.rs

@@ -14,7 +14,6 @@ pub mod trap;
 pub mod trap_stack;
 
 use console::{ConsoleDevice, SbiConsole};
-use core::ops::Range;
 use hsm::SbiHsm;
 use ipi::{IpiDevice, SbiIpi};
 use reset::{ResetDevice, SbiReset};
@@ -22,7 +21,7 @@ use rfence::SbiRFence;
 
 #[derive(RustSBI, Default)]
 #[rustsbi(dynamic)]
-pub struct SBI<'a, C: ConsoleDevice, I: IpiDevice, R: ResetDevice> {
+pub struct Sbi<'a, C: ConsoleDevice, I: IpiDevice, R: ResetDevice> {
     #[rustsbi(console)]
     pub console: Option<SbiConsole<'a, C>>,
     #[rustsbi(ipi, timer)]
@@ -33,5 +32,4 @@ pub struct SBI<'a, C: ConsoleDevice, I: IpiDevice, R: ResetDevice> {
     pub reset: Option<SbiReset<'a, R>>,
     #[rustsbi(fence)]
     pub rfence: Option<SbiRFence>,
-    pub memory_range: Range<usize>,
 }

prototyper/src/sbi/reset.rs

@@ -1,7 +1,7 @@
 use core::sync::atomic::{AtomicPtr, Ordering::Relaxed};
 use rustsbi::SbiRet;
 
-use crate::board::SBI_IMPL;
+use crate::board::BOARD;
 
 pub trait ResetDevice {
     fn fail(&self, code: u16) -> !;
@@ -61,9 +61,5 @@ impl<'a, T: ResetDevice> rustsbi::Reset for SbiReset<'a, T> {
 }
 
 pub fn fail() -> ! {
-    unsafe { SBI_IMPL.assume_init_ref() }
-        .reset
-        .as_ref()
-        .unwrap()
-        .fail()
+    unsafe { BOARD.sbi.reset.as_ref().unwrap().fail() }
 }

prototyper/src/sbi/rfence.rs

@@ -1,7 +1,7 @@
 use rustsbi::{HartMask, SbiRet};
 use spin::Mutex;
 
-use crate::board::SBI_IMPL;
+use crate::board::BOARD;
 use crate::riscv_spec::current_hartid;
 use crate::sbi::fifo::{Fifo, FifoError};
 use crate::sbi::trap;
@@ -192,9 +192,7 @@ fn validate_address_range(start_addr: usize, size: usize) -> Result<usize, SbiRe
 
 /// Processes a remote fence operation by sending IPI to target harts.
 fn remote_fence_process(rfence_ctx: RFenceContext, hart_mask: HartMask) -> SbiRet {
-    let sbi_ret = unsafe { SBI_IMPL.assume_init_mut() }
-        .ipi
-        .as_ref()
+    let sbi_ret = unsafe { BOARD.sbi.ipi.as_ref() }
         .unwrap()
         .send_ipi_by_fence(hart_mask, rfence_ctx);
 

prototyper/src/sbi/trap.rs

@@ -6,7 +6,7 @@ use riscv::register::{
 };
 use rustsbi::RustSBI;
 
-use crate::board::SBI_IMPL;
+use crate::board::BOARD;
 use crate::riscv_spec::{current_hartid, CSR_TIME, CSR_TIMEH};
 use crate::sbi::console;
 use crate::sbi::hsm::local_hsm;
@@ -381,11 +381,11 @@ pub extern "C" fn fast_handler(
         // Handle SBI calls
         T::Exception(E::SupervisorEnvCall) => {
             use sbi_spec::{base, hsm, legacy};
-            let mut ret = unsafe { SBI_IMPL.assume_init_ref() }.handle_ecall(
-                a7,
-                a6,
-                [ctx.a0(), a1, a2, a3, a4, a5],
-            );
+            let mut ret = unsafe {
+                BOARD
+                    .sbi
+                    .handle_ecall(a7, a6, [ctx.a0(), a1, a2, a3, a4, a5])
+            };
             if ret.is_ok() {
                 match (a7, a6) {
                     // Handle non-retentive suspend
@@ -487,11 +487,8 @@ fn illegal_instruction_handler(ctx: &mut FastContext) -> bool {
                     "Unsupported CSR rd: {}",
                     csr.rd()
                 );
-                ctx.regs().a[(csr.rd() - 10) as usize] = unsafe { SBI_IMPL.assume_init_ref() }
-                    .ipi
-                    .as_ref()
-                    .unwrap()
-                    .get_time();
+                ctx.regs().a[(csr.rd() - 10) as usize] =
+                    unsafe { BOARD.sbi.ipi.as_ref() }.unwrap().get_time();
             }
             CSR_TIMEH => {
                 assert!(
@@ -499,11 +496,8 @@ fn illegal_instruction_handler(ctx: &mut FastContext) -> bool {
                     "Unsupported CSR rd: {}",
                     csr.rd()
                 );
-                ctx.regs().a[(csr.rd() - 10) as usize] = unsafe { SBI_IMPL.assume_init_ref() }
-                    .ipi
-                    .as_ref()
-                    .unwrap()
-                    .get_timeh();
+                ctx.regs().a[(csr.rd() - 10) as usize] =
+                    unsafe { BOARD.sbi.ipi.as_ref() }.unwrap().get_timeh();
             }
             _ => return false,
         },