Skip to main content

esp_riscv_rt/
lib.rs

1//! Minimal startup/runtime for RISC-V CPUs from Espressif.
2//!
3//! ## Features
4//!
5//! This crate provides:
6//!
7//! - Before main initialization of the `.bss` and `.data` sections controlled by features
8//! - `#[entry]` to declare the entry point of the program
9//!
10//! ## Feature Flags
11#![doc = document_features::document_features!(feature_label = r#"<span class="stab portability"><code>{feature}</code></span>"#)]
12#![doc(html_logo_url = "https://docs.espressif.com/projects/rust/esp-rs-grey-bg.svg")]
13#![deny(missing_docs)]
14#![no_std]
15
16use core::arch::global_asm;
17
18pub use riscv;
19pub use riscv_rt::{TrapFrame, entry};
20
21#[doc(hidden)]
22#[unsafe(no_mangle)]
23pub unsafe extern "C" fn _dispatch_exception(trap_frame: &TrapFrame, _code: usize) {
24    unsafe extern "C" {
25        fn _start_trap_rust_hal(trap_frame: &TrapFrame);
26    }
27
28    unsafe {
29        _start_trap_rust_hal(trap_frame);
30    }
31}
32
33/// Parse cfg attributes inside a global_asm call.
34macro_rules! cfg_global_asm {
35    {@inner, [$($x:tt)*], } => {
36        global_asm!{$($x)*}
37    };
38    (@inner, [$($x:tt)*], #[cfg($meta:meta)] $asm:literal, $($rest:tt)*) => {
39        #[cfg($meta)]
40        cfg_global_asm!{@inner, [$($x)* $asm,], $($rest)*}
41        #[cfg(not($meta))]
42        cfg_global_asm!{@inner, [$($x)*], $($rest)*}
43    };
44    {@inner, [$($x:tt)*], $asm:literal, $($rest:tt)*} => {
45        cfg_global_asm!{@inner, [$($x)* $asm,], $($rest)*}
46    };
47    {$($asms:tt)*} => {
48        cfg_global_asm!{@inner, [], $($asms)*}
49    };
50}
51
52cfg_global_asm! {
53    r#"
54.section .init, "ax"
55.weak __pre_init
56__pre_init:"#,
57    // Zero .rtc_fast.bss
58#[cfg(feature = "rtc-ram")]
59    r#"
60    la a0, _rtc_fast_bss_start
61    la a1, _rtc_fast_bss_end
62    bge a0, a1, 2f
63    mv a3, x0
64    1:
65    sw a3, 0(a0)
66    addi a0, a0, 4
67    blt a0, a1, 1b
68    2:
69"#,
70     // Zero .rtc_fast.persistent if the chip just powered on
71 #[cfg(feature = "rtc-ram")]
72    r#"
73    mv a0, zero
74    mv t0, ra
75    call rtc_get_reset_reason
76    mv ra, t0
77    addi a1, zero, 1
78    bne a0, a1, 2f
79    la a0, _rtc_fast_persistent_start
80    la a1, _rtc_fast_persistent_end
81    bge a0, a1, 2f
82    mv a3, x0
83    1:
84    sw a3, 0(a0)
85    addi a0, a0, 4
86    blt a0, a1, 1b
87    2:
88"#,
89    // Zero .dram2_uninit.bss
90    r#"
91    la a0, _dram2_uninit_bss_start
92    la a1, _dram2_uninit_bss_end
93    bge a0, a1, 2f
94    mv a3, x0
95    1:
96    sw a3, 0(a0)
97    addi a0, a0, 4
98    blt a0, a1, 1b
99    2:
100"#,
101    // Zero .uncached.bss
102#[cfg(feature = "uncached-ram")]
103    r#"
104    la a0, _uncached_bss_start
105    la a1, _uncached_bss_end
106    bge a0, a1, 2f
107    mv a3, x0
108    1:
109    sw a3, 0(a0)
110    addi a0, a0, 4
111    blt a0, a1, 1b
112    2:
113"#,
114r#"
115    ret
116
117/*
118    Move SP to a valid memory region if needed.
119*/
120
121.section .trap.start, "ax"
122.extern _pre_default_start_trap_ret
123.global _pre_default_start_trap
124_pre_default_start_trap:
125    // move SP to some safe place if it's pointing below the RAM
126    // or into .trap / .rwtext.
127    //
128    // Otherwise we won't be able to do anything reasonable
129    // (since we don't have a working stack)
130    //
131    // most probably we will just print something and halt in this case
132    // we actually can't do anything else
133    csrw mscratch, t0
134    la t0, _dram_data_start
135    bge sp, t0, 1f
136
137    // use the reserved exception cause 14 to signal we detected a stack overflow
138    li t0, 14
139    csrw mcause, t0
140
141    // set SP to the start of the stack
142    la sp, _stack_start
143    li t0, 4 // make sure stack start is in RAM
144    sub sp, sp, t0
145    andi sp, sp, -16 // Force 16-byte alignment
146
147    1:
148    csrr t0, mscratch
149
150    j _pre_default_start_trap_ret
151
152/*
153    Interrupt vector table (_vector_table)
154*/
155
156.section .trap, "ax"
157.weak _vector_table
158.type _vector_table, @function
159
160.option push
161.balign 0x100
162.option norelax
163.option norvc
164
165_vector_table:
166    j _start_trap
167    j _start_Trap1_trap
168    j _start_Trap2_trap
169    j _start_Trap3_trap
170    j _start_Trap4_trap
171    j _start_Trap5_trap
172    j _start_Trap6_trap
173    j _start_Trap7_trap
174    j _start_Trap8_trap
175    j _start_Trap9_trap
176    j _start_Trap10_trap
177    j _start_Trap11_trap
178    j _start_Trap12_trap
179    j _start_Trap13_trap
180    j _start_Trap14_trap
181    j _start_Trap15_trap
182    j _start_Trap16_trap
183    j _start_Trap17_trap
184    j _start_Trap18_trap
185    j _start_Trap19_trap
186    j _start_Trap20_trap
187    j _start_Trap21_trap
188    j _start_Trap22_trap
189    j _start_Trap23_trap
190    j _start_Trap24_trap
191    j _start_Trap25_trap
192    j _start_Trap26_trap
193    j _start_Trap27_trap
194    j _start_Trap28_trap
195    j _start_Trap29_trap
196    j _start_Trap30_trap
197    j _start_Trap31_trap
198"#,
199 #[cfg(feature = "clic-48")]
200r#"
201    j _start_Trap32_trap
202    j _start_Trap33_trap
203    j _start_Trap34_trap
204    j _start_Trap35_trap
205    j _start_Trap36_trap
206    j _start_Trap37_trap
207    j _start_Trap38_trap
208    j _start_Trap39_trap
209    j _start_Trap40_trap
210    j _start_Trap41_trap
211    j _start_Trap42_trap
212    j _start_Trap43_trap
213    j _start_Trap44_trap
214    j _start_Trap45_trap
215    j _start_Trap46_trap
216    j _start_Trap47_trap
217"#,
218r#"
219    .option pop
220"#,
221}
222
223#[cfg(not(riscv_has_f))]
224macro_rules! interrupt_handler {
225    () => {
226        "handle_interrupts"
227    };
228}
229
230#[cfg(all(riscv_has_f, not(feature = "float-save-restore")))]
231macro_rules! interrupt_handler {
232    () => {
233        "handle_interrupts_disable_fpu"
234    };
235}
236
237#[cfg(all(riscv_has_f, feature = "float-save-restore"))]
238macro_rules! interrupt_handler {
239    () => {
240        "handle_interrupts_save_fpu"
241    };
242}
243
244/// Calls `handle_interrupts` and keeps `fcsr` and the caller-saved FPU registers.
245///
246/// The `riscv-rt` trap handler saves the integer registers and executes `mret`. Return to the
247/// trap handler with `ret`. Keep `sp` 16-byte aligned.
248#[cfg(all(riscv_has_f, feature = "float-save-restore"))]
249#[unsafe(naked)]
250#[unsafe(no_mangle)]
251#[unsafe(link_section = ".trap.start")]
252extern "C" fn handle_interrupts_save_fpu() {
253    core::arch::naked_asm! {
254        "
255        .option push
256        .option arch, +f
257        addi sp, sp, -96
258        sw ra, 0(sp)
259        frcsr t0
260        sw t0, 4(sp)
261
262        fsw ft0, 8(sp)
263        fsw ft1, 12(sp)
264        fsw ft2, 16(sp)
265        fsw ft3, 20(sp)
266        fsw ft4, 24(sp)
267        fsw ft5, 28(sp)
268        fsw ft6, 32(sp)
269        fsw ft7, 36(sp)
270        fsw ft8, 40(sp)
271        fsw ft9, 44(sp)
272        fsw ft10, 48(sp)
273        fsw ft11, 52(sp)
274        fsw fa0, 56(sp)
275        fsw fa1, 60(sp)
276        fsw fa2, 64(sp)
277        fsw fa3, 68(sp)
278        fsw fa4, 72(sp)
279        fsw fa5, 76(sp)
280        fsw fa6, 80(sp)
281        fsw fa7, 84(sp)
282
283        jal ra, handle_interrupts
284
285        flw ft0, 8(sp)
286        flw ft1, 12(sp)
287        flw ft2, 16(sp)
288        flw ft3, 20(sp)
289        flw ft4, 24(sp)
290        flw ft5, 28(sp)
291        flw ft6, 32(sp)
292        flw ft7, 36(sp)
293        flw ft8, 40(sp)
294        flw ft9, 44(sp)
295        flw ft10, 48(sp)
296        flw ft11, 52(sp)
297        flw fa0, 56(sp)
298        flw fa1, 60(sp)
299        flw fa2, 64(sp)
300        flw fa3, 68(sp)
301        flw fa4, 72(sp)
302        flw fa5, 76(sp)
303        flw fa6, 80(sp)
304        flw fa7, 84(sp)
305
306        lw t0, 4(sp)
307        fscsr t0
308        lw ra, 0(sp)
309        addi sp, sp, 96
310        ret
311        .option pop
312        "
313    }
314}
315
316/// Calls `handle_interrupts` with `mstatus.FS` set to Off.
317///
318/// An FPU instruction in an interrupt handler then causes an illegal instruction exception. The
319/// hardware does not change `mstatus.FS` on a trap or on `mret`, so this routine restores the
320/// previous value.
321#[cfg(all(riscv_has_f, not(feature = "float-save-restore")))]
322#[unsafe(naked)]
323#[unsafe(no_mangle)]
324#[unsafe(link_section = ".trap.start")]
325extern "C" fn handle_interrupts_disable_fpu() {
326    core::arch::naked_asm! {
327        "
328        addi sp, sp, -16
329        sw ra, 0(sp)
330        li t0, 0x6000
331        csrrc t0, mstatus, t0
332        sw t0, 4(sp)
333
334        jal ra, handle_interrupts
335
336        li t1, 0x6000
337        csrc mstatus, t1
338        lw t0, 4(sp)
339        and t0, t0, t1
340        csrs mstatus, t0
341        lw ra, 0(sp)
342        addi sp, sp, 16
343        ret
344        "
345    }
346}
347
348macro_rules! define_interrupt {
349    ($num:literal, $name:ident, $fname:ident) => {
350        #[derive(Copy, Clone)]
351        struct $name;
352
353        unsafe impl riscv_rt::InterruptNumber for $name {
354            const MAX_INTERRUPT_NUMBER: usize = if cfg!(feature = "clic-48") { 47 } else { 31 };
355
356            fn number(self) -> usize {
357                $num
358            }
359
360            fn from_number(_value: usize) -> riscv_rt::result::Result<Self> {
361                Ok($name)
362            }
363        }
364
365        unsafe impl riscv_rt::CoreInterruptNumber for $name {}
366
367        #[unsafe(naked)]
368        #[unsafe(link_section = ".trap.start")]
369        #[riscv_rt::core_interrupt($name)]
370        extern "C" fn $fname() {
371            core::arch::naked_asm! {
372                concat!(
373                "
374                li a0,",$num,"
375                j ", interrupt_handler!(), "
376                "
377                )
378            }
379        }
380    };
381}
382
383define_interrupt!(1, Trap1, trap1);
384define_interrupt!(2, Trap2, trap2);
385define_interrupt!(3, Trap3, trap3);
386define_interrupt!(4, Trap4, trap4);
387define_interrupt!(5, Trap5, trap5);
388define_interrupt!(6, Trap6, trap6);
389define_interrupt!(7, Trap7, trap7);
390define_interrupt!(8, Trap8, trap8);
391define_interrupt!(9, Trap9, trap9);
392define_interrupt!(10, Trap10, trap10);
393define_interrupt!(11, Trap11, trap11);
394define_interrupt!(12, Trap12, trap12);
395define_interrupt!(13, Trap13, trap13);
396define_interrupt!(14, Trap14, trap14);
397define_interrupt!(15, Trap15, trap15);
398define_interrupt!(16, Trap16, trap16);
399define_interrupt!(17, Trap17, trap17);
400define_interrupt!(18, Trap18, trap18);
401define_interrupt!(19, Trap19, trap19);
402define_interrupt!(20, Trap20, trap20);
403define_interrupt!(21, Trap21, trap21);
404define_interrupt!(22, Trap22, trap22);
405define_interrupt!(23, Trap23, trap23);
406define_interrupt!(24, Trap24, trap24);
407define_interrupt!(25, Trap25, trap25);
408define_interrupt!(26, Trap26, trap26);
409define_interrupt!(27, Trap27, trap27);
410define_interrupt!(28, Trap28, trap28);
411define_interrupt!(29, Trap29, trap29);
412define_interrupt!(30, Trap30, trap30);
413define_interrupt!(31, Trap31, trap31);
414
415#[cfg(feature = "clic-48")]
416mod clic {
417    define_interrupt!(32, Trap32, trap32);
418    define_interrupt!(33, Trap33, trap33);
419    define_interrupt!(34, Trap34, trap34);
420    define_interrupt!(35, Trap35, trap35);
421    define_interrupt!(36, Trap36, trap36);
422    define_interrupt!(37, Trap37, trap37);
423    define_interrupt!(38, Trap38, trap38);
424    define_interrupt!(39, Trap39, trap39);
425    define_interrupt!(40, Trap40, trap40);
426    define_interrupt!(41, Trap41, trap41);
427    define_interrupt!(42, Trap42, trap42);
428    define_interrupt!(43, Trap43, trap43);
429    define_interrupt!(44, Trap44, trap44);
430    define_interrupt!(45, Trap45, trap45);
431    define_interrupt!(46, Trap46, trap46);
432    define_interrupt!(47, Trap47, trap47);
433}