feat: implemented reset extension

src/board.rs

@@ -1,8 +1,9 @@
 //! Board support, including peripheral and core drivers.
 use core::mem::MaybeUninit;
-use rustsbi::{RustSBI, SbiRet};
+use rustsbi::RustSBI;
 
 use crate::clint::ClintDevice;
+use crate::reset::TestDevice;
 use crate::console::ConsoleDevice;
 use crate::hsm::Hsm;
 use crate::rfence::RFence;
@@ -19,32 +20,7 @@ pub struct Board<'a> {
     #[rustsbi(hsm)]
     pub hsm: Option<Hsm>,
     #[rustsbi(reset)]
-    pub sifive_test: Option<SifiveTestDevice<'a>>,
+    pub sifive_test: Option<TestDevice<'a>>,
     #[rustsbi(fence)]
     pub rfence: Option<RFence>
 }
-
-pub struct SifiveTestDevice<'a> {
-    pub sifive_test: &'a sifive_test_device::SifiveTestDevice,
-}
-
-impl<'a> rustsbi::Reset for SifiveTestDevice<'a> {
-    #[inline]
-    fn system_reset(&self, reset_type: u32, reset_reason: u32) -> SbiRet {
-        use rustsbi::spec::srst::{
-            RESET_REASON_NO_REASON, RESET_REASON_SYSTEM_FAILURE, RESET_TYPE_COLD_REBOOT,
-            RESET_TYPE_SHUTDOWN, RESET_TYPE_WARM_REBOOT,
-        };
-        match reset_type {
-            RESET_TYPE_SHUTDOWN => match reset_reason {
-                RESET_REASON_NO_REASON => self.sifive_test.pass(),
-                RESET_REASON_SYSTEM_FAILURE => self.sifive_test.fail(-1 as _),
-                value => self.sifive_test.fail(value as _),
-            },
-            RESET_TYPE_COLD_REBOOT | RESET_TYPE_WARM_REBOOT => {
-                self.sifive_test.reset();
-            }
-            _ => SbiRet::invalid_param(),
-        }
-    }
-}

src/main.rs

@@ -7,31 +7,33 @@ extern crate log;
 #[macro_use]
 mod macros;
 
+mod board;
 mod clint;
 mod console;
-mod hsm;
-mod reset;
-mod rfence;
-mod board;
 mod dt;
 mod dynamic;
 mod fail;
+mod hart_context;
+mod hsm;
+mod reset;
+mod rfence;
 mod riscv_spec;
 mod trap;
 mod trap_stack;
-mod hart_context;
 
 use clint::ClintDevice;
 use core::sync::atomic::{AtomicBool, Ordering};
 use core::{arch::asm, mem::MaybeUninit};
+use reset::TestDevice;
 use riscv::register::mstatus;
 
 use crate::board::{Board, SBI};
 use crate::clint::SIFIVECLINT;
 use crate::console::{ConsoleDevice, CONSOLE};
 use crate::hsm::{local_remote_hsm, Hsm};
+use crate::reset::RESET;
 use crate::rfence::RFence;
-use crate::riscv_spec::{menvcfg,current_hartid};
+use crate::riscv_spec::{current_hartid, menvcfg};
 use crate::trap::trap_vec;
 use crate::trap_stack::NUM_HART_MAX;
 
@@ -58,6 +60,7 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
             serde_device_tree::from_raw_mut(&dtb).unwrap_or_else(fail::device_tree_deserialize);
 
         // TODO: The device base address needs to be parsed from FDT
+        reset::init(0x100000);
         console::init(0x10000000);
         clint::init(0x2000000);
 
@@ -82,8 +85,8 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
                 uart16550: Some(ConsoleDevice::new(&CONSOLE)),
                 clint: Some(ClintDevice::new(&SIFIVECLINT, NUM_HART_MAX)),
                 hsm: Some(Hsm),
-                sifive_test: None,
-                rfence: Some(RFence)
+                sifive_test: Some(TestDevice::new(&RESET)),
+                rfence: Some(RFence),
             });
         }
 
@@ -106,7 +109,12 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
             opaque,
         });
 
-        info!("Redirecting hart {} to 0x{:0>16x} in {:?} mode.", current_hartid(), next_addr, mpp);
+        info!(
+            "Redirecting hart {} to 0x{:0>16x} in {:?} mode.",
+            current_hartid(),
+            next_addr,
+            mpp
+        );
     } else {
         // TODO: PMP configuration needs to be obtained through the memory range in the device tree
         use riscv::register::*;
@@ -185,7 +193,6 @@ unsafe extern "C" fn start() -> ! {
     )
 }
 
-
 #[derive(Debug)]
 pub struct NextStage {
     start_addr: usize,

src/reset.rs

@@ -1,29 +1,67 @@
+use core::{
+    ptr::null_mut,
+    sync::atomic::{
+        AtomicPtr,
+        Ordering::{Relaxed, Release},
+    },
+};
+use rustsbi::SbiRet;
 use sifive_test_device::SifiveTestDevice;
-use spin::Mutex;
 
-static RESET: Mutex<MachineReset> = Mutex::new(MachineReset::DeadLoop);
+pub(crate) static RESET: AtomicPtr<SifiveTestDevice> = AtomicPtr::new(null_mut());
+
+pub fn init(base: usize) {
+    RESET.store(base as _, Release);
+}
 
 pub fn fail() -> ! {
-    let lock = RESET.lock();
-    match *lock {
-        MachineReset::DeadLoop => {
-            trace!("test fail, begin dead loop");
-            loop {
-                core::hint::spin_loop()
-            }
-        }
-        MachineReset::SifiveTest(test) => {
-            trace!("test fail, invoke process exit procedure on SiFive Test device");
-            unsafe { &*test }.fail(0)
+    let sifive_test = RESET.load(Relaxed);
+    if sifive_test.is_null() {
+        trace!("test fail, begin dead loop");
+        loop {
+            core::hint::spin_loop()
         }
+    } else {
+        trace!("test fail, invoke process exit procedure on SiFive Test device");
+        unsafe { (*sifive_test).fail(0) }
     }
 }
 
-enum MachineReset {
-    DeadLoop,
-    #[allow(unused)] // TODO use on FDT parsing
-    SifiveTest(*const SifiveTestDevice),
+
+pub struct TestDevice<'a> {
+    pub sifive_test: &'a AtomicPtr<SifiveTestDevice>,
 }
 
-unsafe impl Send for MachineReset {}
-unsafe impl Sync for MachineReset {}
+impl<'a> TestDevice<'a> {
+    pub fn new(sifive_test: &'a AtomicPtr<SifiveTestDevice>) -> Self {
+        Self { sifive_test }
+    }
+}
+
+impl<'a> rustsbi::Reset for TestDevice<'a> {
+    #[inline]
+    fn system_reset(&self, reset_type: u32, reset_reason: u32) -> SbiRet {
+        use rustsbi::spec::srst::{
+            RESET_REASON_NO_REASON, RESET_REASON_SYSTEM_FAILURE, RESET_TYPE_COLD_REBOOT,
+            RESET_TYPE_SHUTDOWN, RESET_TYPE_WARM_REBOOT,
+        };
+        match reset_type {
+            RESET_TYPE_SHUTDOWN => match reset_reason {
+                RESET_REASON_NO_REASON => unsafe {
+                    (*self.sifive_test.load(Relaxed)).pass();
+                },
+                RESET_REASON_SYSTEM_FAILURE => unsafe {
+                    (*self.sifive_test.load(Relaxed)).fail(u16::MAX);
+                },
+                value => unsafe {
+                    (*self.sifive_test.load(Relaxed)).fail(value as _);
+                },
+            },
+            RESET_TYPE_COLD_REBOOT | RESET_TYPE_WARM_REBOOT => unsafe {
+                (*self.sifive_test.load(Relaxed)).reset();
+            },
+
+            _ => SbiRet::invalid_param(),
+        }
+    }
+}