feat: support none sstc environment

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

prototyper/src/dt.rs

@@ -1,10 +1,14 @@
 use serde::Deserialize;
-use serde_device_tree::{buildin::StrSeq, Dtb, DtbPtr};
+use serde_device_tree::{
+    buildin::{NodeSeq, StrSeq},
+    Dtb, DtbPtr,
+};
 
 #[derive(Deserialize)]
 pub struct Tree<'a> {
     pub model: Option<StrSeq<'a>>,
     pub chosen: Chosen<'a>,
+    pub cpus: Cpus<'a>,
 }
 
 #[derive(Deserialize)]
@@ -13,6 +17,19 @@ pub struct Chosen<'a> {
     pub stdout_path: StrSeq<'a>,
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct Cpus<'a> {
+    pub cpu: NodeSeq<'a>,
+}
+
+#[allow(dead_code)]
+#[derive(Deserialize, Debug)]
+pub struct Cpu<'a> {
+    #[serde(rename = "riscv,isa-extensions")]
+    pub isa: StrSeq<'a>,
+}
+
 pub enum ParseDeviceTreeError {
     Format,
 }

prototyper/src/main.rs

@@ -51,31 +51,47 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
         // parse the device tree
         let dtb = dt::parse_device_tree(opaque).unwrap_or_else(fail::device_tree_format);
         let dtb = dtb.share();
-        let tree =
-            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
         // 1. Init device
         board::reset_dev_init(0x100000);
         board::console_dev_init(0x10000000);
         board::ipi_dev_init(0x2000000);
-        // 2. Init SBI
+
+        // 2. Init FDT
+        // TODO: Init logger berfore init fdt
+        let tree =
+            serde_device_tree::from_raw_mut(&dtb).unwrap_or_else(fail::device_tree_deserialize);
+        info!("cpu number: {}", tree.cpus.cpu.len());
+        let sstc_support = tree
+            .cpus
+            .cpu
+            .iter()
+            .map(|cpu_iter| {
+                use crate::dt::Cpu;
+                let cpu = cpu_iter.deserialize::<Cpu>();
+                info!("cpu@{} ext count: {:?}", cpu_iter.at(), cpu.isa);
+                cpu.isa.iter().find(|&x| x == "sstc").is_some()
+            })
+            .all(|x| x);
+        info!("sstc_support: {sstc_support}");
+        // 3. Init SBI
         unsafe {
             SBI_IMPL = MaybeUninit::new(SBI {
                 console: Some(SbiConsole::new(&UART)),
-                ipi: Some(SbiIpi::new(&SIFIVECLINT, NUM_HART_MAX)),
+                ipi: Some(SbiIpi::new(&SIFIVECLINT, NUM_HART_MAX, sstc_support)),
                 hsm: Some(SbiHsm),
                 reset: Some(SbiReset::new(&SIFIVETEST)),
                 rfence: Some(SbiRFence),
             });
         }
         SBI_READY.swap(true, Ordering::AcqRel);
-        // 3. Init Logger
+        // 4. Init Logger
         logger::Logger::init();
-
         info!("RustSBI version {}", rustsbi::VERSION);
         rustsbi::LOGO.lines().for_each(|line| info!("{}", line));
         info!("Initializing RustSBI machine-mode environment.");
+
         if let Some(model) = tree.model {
             info!("Model: {}", model.iter().next().unwrap_or("<unspecified>"));
         }
@@ -88,7 +104,6 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
                 .unwrap_or("<unspecified>")
         );
 
-
         // TODO: PMP configuration needs to be obtained through the memory range in the device tree
         use riscv::register::*;
         unsafe {
@@ -139,11 +154,14 @@ extern "C" fn rust_main(_hart_id: usize, opaque: usize, nonstandard_a2: usize) {
         use riscv::register::{medeleg, mtvec};
         medeleg::clear_supervisor_env_call();
         medeleg::clear_illegal_instruction();
-        menvcfg::set_bits(
-            menvcfg::STCE | menvcfg::CBIE_INVALIDATE | menvcfg::CBCFE | menvcfg::CBZE,
-        );
+        if ipi::has_sstc() {
+            menvcfg::set_bits(
+                menvcfg::STCE | menvcfg::CBIE_INVALIDATE | menvcfg::CBCFE | menvcfg::CBZE,
+            );
+        } else {
+            menvcfg::set_bits(menvcfg::CBIE_INVALIDATE | menvcfg::CBCFE | menvcfg::CBZE);
+        }
         mtvec::write(trap_vec as _, mtvec::TrapMode::Vectored);
-        
     }
 }
 

prototyper/src/sbi/ipi.rs

@@ -25,15 +25,23 @@ pub trait IpiDevice {
 pub struct SbiIpi<'a, T: IpiDevice> {
     pub ipi_dev: &'a AtomicPtr<T>,
     pub max_hart_id: usize,
+    pub sstc_support: bool,
 }
 
 impl<'a, T: IpiDevice> rustsbi::Timer for SbiIpi<'a, T> {
     #[inline]
     fn set_timer(&self, stime_value: u64) {
-        unsafe {
-            // TODO: 添加CPU拓展探测机制，补充无Sstc拓展时的定时器设置
+        if self.sstc_support {
             stimecmp::set(stime_value);
-            riscv::register::mie::set_mtimer();
+            unsafe {
+                riscv::register::mie::set_mtimer();
+            }
+        } else {
+            self.write_mtimecmp(current_hartid(), stime_value);
+            unsafe {
+                riscv::register::mip::clear_stimer();
+                riscv::register::mie::set_mtimer();
+            }
         }
     }
 }
@@ -56,10 +64,11 @@ impl<'a, T: IpiDevice> rustsbi::Ipi for SbiIpi<'a, T> {
 }
 
 impl<'a, T: IpiDevice> SbiIpi<'a, T> {
-    pub fn new(ipi_dev: &'a AtomicPtr<T>, max_hart_id: usize) -> Self {
+    pub fn new(ipi_dev: &'a AtomicPtr<T>, max_hart_id: usize, sstc_support: bool) -> Self {
         Self {
             ipi_dev,
             max_hart_id,
+            sstc_support,
         }
     }
 
@@ -167,3 +176,11 @@ pub fn clear_all() {
         .unwrap()
         .clear();
 }
+
+pub fn has_sstc() -> bool {
+    unsafe { SBI_IMPL.assume_init_ref() }
+        .ipi
+        .as_ref()
+        .unwrap()
+        .sstc_support
+}

prototyper/src/sbi/trap.rs

@@ -8,10 +8,10 @@ use rustsbi::RustSBI;
 
 use crate::board::SBI_IMPL;
 use crate::riscv_spec::{current_hartid, CSR_TIME, CSR_TIMEH};
-use crate::sbi::rfence::{self, local_rfence, RFenceType};
+use crate::sbi::console;
 use crate::sbi::hsm::local_hsm;
 use crate::sbi::ipi;
-use crate::sbi::console;
+use crate::sbi::rfence::{self, local_rfence, RFenceType};
 
 const PAGE_SIZE: usize = 4096;
 // TODO: `TLB_FLUSH_LIMIT` is a platform-dependent parameter
@@ -56,17 +56,37 @@ unsafe extern "C" fn mtimer() {
         // mscratch: S sp
         "   csrrw sp, mscratch, sp",
         // 保护
-        "   addi  sp, sp, -9*8
-            sd    ra, 0*8(sp)
-            sd    a0, 1*8(sp)
-            sd    a1, 2*8(sp)
-            sd    a2, 3*8(sp)
-            sd    a3, 4*8(sp)
-            sd    a4, 5*8(sp)
-            sd    a5, 6*8(sp)
-            sd    a6, 7*8(sp)
-            sd    a7, 8*8(sp)
-        ",
+        "   addi   sp, sp, -30*8",
+        "   sd     ra, 0*8(sp)
+            sd      gp, 2*8(sp)
+            sd      tp, 3*8(sp)
+            sd      t0, 4*8(sp)
+            sd      t1, 5*8(sp)
+            sd      t2, 6*8(sp)
+            sd      s0, 7*8(sp)
+            sd      s1, 8*8(sp)
+            sd      a0, 9*8(sp)
+            sd      a1, 10*8(sp)
+            sd      a2, 11*8(sp)
+            sd      a3, 12*8(sp)
+            sd      a4, 13*8(sp)
+            sd      a5, 14*8(sp)
+            sd      a6, 15*8(sp)
+            sd      a7, 16*8(sp)
+            sd      s2, 17*8(sp)
+            sd      s3, 18*8(sp)
+            sd      s4, 19*8(sp)
+            sd      s5, 20*8(sp)
+            sd      s6, 21*8(sp)
+            sd      s7, 22*8(sp)
+            sd      s8, 23*8(sp)
+            sd      s9, 24*8(sp)
+            sd     s10, 25*8(sp)
+            sd     s11, 26*8(sp)
+            sd      t3, 27*8(sp)
+            sd      t4, 28*8(sp)
+            sd      t5, 29*8(sp)
+            sd      t6, 1*8(sp)",
         // 清除 mtimecmp
         "    call  {clear_mtime}",
         // 设置 stip
@@ -74,17 +94,37 @@ unsafe extern "C" fn mtimer() {
             csrrs zero, mip, a0
         ",
         // 恢复
-        "   ld    ra, 0*8(sp)
-            ld    a0, 1*8(sp)
-            ld    a1, 2*8(sp)
-            ld    a2, 3*8(sp)
-            ld    a3, 4*8(sp)
-            ld    a4, 5*8(sp)
-            ld    a5, 6*8(sp)
-            ld    a6, 7*8(sp)
-            ld    a7, 8*8(sp)
-            addi  sp, sp,  9*8
-        ",
+        "   ld     ra, 0*8(sp)
+            ld      gp, 2*8(sp)
+            ld      tp, 3*8(sp)
+            ld      t0, 4*8(sp)
+            ld      t1, 5*8(sp)
+            ld      t2, 6*8(sp)
+            ld      s0, 7*8(sp)
+            ld      s1, 8*8(sp)
+            ld      a0, 9*8(sp)
+            ld      a1, 10*8(sp)
+            ld      a2, 11*8(sp)
+            ld      a3, 12*8(sp)
+            ld      a4, 13*8(sp)
+            ld      a5, 14*8(sp)
+            ld      a6, 15*8(sp)
+            ld      a7, 16*8(sp)
+            ld      s2, 17*8(sp)
+            ld      s3, 18*8(sp)
+            ld      s4, 19*8(sp)
+            ld      s5, 20*8(sp)
+            ld      s6, 21*8(sp)
+            ld      s7, 22*8(sp)
+            ld      s8, 23*8(sp)
+            ld      s9, 24*8(sp)
+            ld     s10, 25*8(sp)
+            ld     s11, 26*8(sp)
+            ld      t3, 27*8(sp)
+            ld      t4, 28*8(sp)
+            ld      t5, 29*8(sp)
+            ld      t6, 1*8(sp)",
+        "   addi   sp, sp, 30*8",
         // 换栈：
         // sp      : S sp
         // mscratch: M sp
@@ -221,7 +261,8 @@ pub extern "C" fn msoft_hanlder(ctx: &mut SupervisorContext) {
 
 pub fn rfence_signle_handler() {
     let rfence_context = local_rfence().unwrap().get();
-        if let Some((ctx, id)) = rfence_context { match ctx.op {
+    if let Some((ctx, id)) = rfence_context {
+        match ctx.op {
             RFenceType::FenceI => unsafe {
                 asm!("fence.i");
                 rfence::remote_rfence(id).unwrap().sub();