Merge pull request #64 from woshiluo/bump-riscv

feat: bump `riscv` to 1.12.1

Author: guttatus

Cargo.lock

@@ -12,7 +12,7 @@ forced-target = "riscv64imac-unknown-none-elf"
 aclint = "=0.1.0"
 log = "0.4"
 panic-halt = "1.0.0"
-riscv = "0.11.1"
+riscv = "0.12.1"
 sifive-test-device = "0.0.0"
 spin = "0.9.8"
 uart16550 = "0.0.1"

prototyper/Cargo.toml

@@ -3,6 +3,9 @@ use serde_device_tree::Dtb;
 
 use crate::devicetree;
 
+use riscv::interrupt::machine::{Exception, Interrupt};
+use riscv::register::{mcause::Trap, mepc, mtval};
+
 #[cfg(all(feature = "payload", feature = "jump"))]
 compile_error!("feature \"payload\" and feature \"jump\" cannot be enabled at the same time");
 
@@ -19,6 +22,15 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
     loop {}
 }
 
+pub fn unsupported_trap(trap: Option<Trap<Interrupt, Exception>>) -> ! {
+    error!("-----------------------------");
+    error!("trap:    {trap:?}");
+    error!("mepc:    {:#018x}", mepc::read());
+    error!("mtval:   {:#018x}", mtval::read());
+    error!("-----------------------------");
+    panic!("Stopped with unsupported trap")
+}
+
 /// Handles device tree format parsing errors by logging and resetting.
 #[cold]
 pub fn device_tree_format(_err: devicetree::ParseDeviceTreeError) -> Dtb {

prototyper/src/fail.rs

@@ -1,10 +1,13 @@
 pub mod boot;
 pub mod handler;
 
+use crate::fail::unsupported_trap;
+
 use fast_trap::{FastContext, FastResult};
+use riscv::interrupt::machine::{Exception, Interrupt};
 use riscv::register::{
-    mcause::{self, Exception as E, Interrupt, Trap as T},
-    mepc, mip, mstatus, mtval,
+    mcause::{self, Trap},
+    mepc, mip, mstatus,
 };
 
 /// Fast trap handler for all trap.
@@ -25,47 +28,48 @@ pub extern "C" fn fast_handler(
         ctx.regs().a = [ctx.a0(), a1, a2, a3, a4, a5, a6, a7];
     };
 
-    match mcause::read().cause() {
-        // Handle Msoft
-        T::Interrupt(Interrupt::MachineSoft) => {
-            save_regs(&mut ctx);
-            handler::msoft_handler(ctx)
-        }
-        // Handle MTimer
-        T::Interrupt(Interrupt::MachineTimer) => {
-            use crate::sbi::ipi;
+    match mcause::read().cause().try_into() {
+        Ok(cause) => {
+            match cause {
+                // Handle Msoft
+                Trap::Interrupt(Interrupt::MachineSoft) => {
+                    save_regs(&mut ctx);
+                    handler::msoft_handler(ctx)
+                }
+                // Handle MTimer
+                Trap::Interrupt(Interrupt::MachineTimer) => {
+                    use crate::sbi::ipi;
 
-            ipi::clear_mtime();
-            unsafe {
-                mip::clear_stimer();
-            }
-            save_regs(&mut ctx);
-            ctx.restore()
-        }
-        // Handle SBI calls
-        T::Exception(E::SupervisorEnvCall) => {
-            handler::sbi_call_handler(ctx, a1, a2, a3, a4, a5, a6, a7)
-        }
-        // Handle illegal instructions
-        T::Exception(E::IllegalInstruction) => {
-            if mstatus::read().mpp() == mstatus::MPP::Machine {
-                panic!("Cannot handle illegal instruction exception from M-MODE");
-            }
+                    ipi::clear_mtime();
+                    unsafe {
+                        mip::clear_stimer();
+                    }
+                    save_regs(&mut ctx);
+                    ctx.restore()
+                }
+                // Handle SBI calls
+                Trap::Exception(Exception::SupervisorEnvCall) => {
+                    handler::sbi_call_handler(ctx, a1, a2, a3, a4, a5, a6, a7)
+                }
+                // Handle illegal instructions
+                Trap::Exception(Exception::IllegalInstruction) => {
+                    if mstatus::read().mpp() == mstatus::MPP::Machine {
+                        panic!("Cannot handle illegal instruction exception from M-MODE");
+                    }
 
-            save_regs(&mut ctx);
-            if !handler::illegal_instruction_handler(&mut ctx) {
-                handler::delegate(&mut ctx);
+                    save_regs(&mut ctx);
+                    if !handler::illegal_instruction_handler(&mut ctx) {
+                        handler::delegate(&mut ctx);
+                    }
+                    ctx.restore()
+                }
+                // Handle other traps
+                trap => unsupported_trap(Some(trap)),
             }
-            ctx.restore()
         }
-        // Handle other traps
-        trap => {
-            error!("-----------------------------");
-            error!("trap:    {trap:?}");
-            error!("mepc:    {:#018x}", mepc::read());
-            error!("mtval:   {:#018x}", mtval::read());
-            error!("-----------------------------");
-            panic!("Stopped with unsupported trap")
+        Err(err) => {
+            error!("Failed to parse mcause: {:?}", err);
+            unsupported_trap(None);
         }
     }
 }