use core::ffi::c_void;
use cortex_m::peripheral::{DCB, DWT, SCB, SYST};
use crate::arch::platform::{
ContextSwitchPort, CriticalSectionPort, CycleCounterPort, InitialThreadContext,
SchedulerTimerPort, ThreadStackPort,
};
use crate::clock::ticks_per_ms;
use crate::thread::{ThreadEntry, ThreadHandle};
pub struct CortexMPlatform;
const SCHEDULER_TIMER_RELOAD_BITS: u32 = 24;
const SCHEDULER_TIMER_RELOAD_MIN: u32 = 1;
const SCHEDULER_TIMER_RELOAD_MAX: u32 = (1 << SCHEDULER_TIMER_RELOAD_BITS) - 1;
const THREAD_STACK_ALIGNMENT: usize = 8;
const THREAD_INITIAL_FRAME_WORDS: usize = 16;
const INITIAL_XPSR_THUMB_STATE: u32 = 0x0100_0000;
const EXC_RETURN_THREAD_MODE_PSP: u32 = 0xFFFF_FFFD;
static mut DWT_ELAPSE_START_CYCLE: u32 = 0;
impl ThreadStackPort for CortexMPlatform {
const STACK_ALIGNMENT: usize = THREAD_STACK_ALIGNMENT;
const INITIAL_FRAME_WORDS: usize = THREAD_INITIAL_FRAME_WORDS;
unsafe fn init_thread_stack(
sp: *mut u32,
entry: ThreadEntry,
arg: *mut c_void,
) -> InitialThreadContext {
unsafe { init_cortex_m_thread_stack(sp, entry, arg) }
}
}
unsafe fn init_cortex_m_thread_stack(
mut sp: *mut u32,
entry: ThreadEntry,
arg: *mut c_void,
) -> InitialThreadContext {
unsafe {
sp = ((sp as usize) & !(THREAD_STACK_ALIGNMENT - 1)) as *mut u32;
sp = sp.sub(1);
*sp = INITIAL_XPSR_THUMB_STATE;
sp = sp.sub(1);
*sp = entry as usize as u32;
sp = sp.sub(1);
*sp = EXC_RETURN_THREAD_MODE_PSP;
sp = sp.sub(1);
*sp = 0;
for _ in 0..3 {
sp = sp.sub(1);
*sp = 0;
}
sp = sp.sub(1);
*sp = arg as usize as u32;
for _ in 0..8 {
sp = sp.sub(1);
*sp = 0;
}
InitialThreadContext {
sp: sp as u32,
exc_return: EXC_RETURN_THREAD_MODE_PSP,
}
}
}
impl CriticalSectionPort for CortexMPlatform {
fn critical_section<R, F>(f: F) -> R
where
F: FnOnce() -> R,
{
cortex_m::interrupt::free(|_| f())
}
}
impl ContextSwitchPort for CortexMPlatform {
fn request_context_switch() {
SCB::set_pendsv();
}
unsafe fn spawn_main_thread(thread: ThreadHandle) -> ! {
unsafe { super::ctx_switch::spawn_main_thread(thread) }
}
}
impl SchedulerTimerPort for CortexMPlatform {
const RELOAD_BITS: u32 = SCHEDULER_TIMER_RELOAD_BITS;
const RELOAD_MIN: u32 = SCHEDULER_TIMER_RELOAD_MIN;
const RELOAD_MAX: u32 = SCHEDULER_TIMER_RELOAD_MAX;
fn reload() -> Option<u32> {
Some(SYST::get_reload())
}
fn current() -> Option<u32> {
Some(SYST::get_current())
}
fn program_reload(reload: u32) -> bool {
unsafe {
(*SYST::PTR).rvr.write(reload);
(*SYST::PTR).cvr.write(0);
}
true
}
}
fn dwt_elapse_start_cycle() -> u32 {
unsafe { core::ptr::read_volatile(&raw const DWT_ELAPSE_START_CYCLE) }
}
fn msec_from_cycles(cycles: u32) -> u32 {
let ticks = ticks_per_ms();
if ticks == 0 {
return 0;
}
cycles / ticks
}
impl CycleCounterPort for CortexMPlatform {
fn init_dwt_cycle_counter(dcb: &mut DCB, dwt: &mut DWT) -> bool {
<Self as CriticalSectionPort>::critical_section(|| unsafe {
if !DWT::has_cycle_counter() {
return false;
}
dcb.enable_trace();
dwt.set_cycle_count(0);
dwt.enable_cycle_counter();
if !DWT::cycle_counter_enabled() {
return false;
}
core::ptr::write_volatile(&raw mut DWT_ELAPSE_START_CYCLE, DWT::cycle_count());
true
})
}
fn cycle_count() -> u32 {
DWT::cycle_count()
}
fn reset_elapse_counter() {
<Self as CriticalSectionPort>::critical_section(|| unsafe {
core::ptr::write_volatile(&raw mut DWT_ELAPSE_START_CYCLE, DWT::cycle_count());
});
}
fn elapse_cycles() -> u32 {
DWT::cycle_count().wrapping_sub(dwt_elapse_start_cycle())
}
fn elapse_msec() -> u32 {
msec_from_cycles(Self::elapse_cycles())
}
fn elapse_msec_since(start_cycle: u32) -> u32 {
msec_from_cycles(DWT::cycle_count().wrapping_sub(start_cycle))
}
}
pub(crate) fn blocking_context_available() -> bool {
let enabled = SCB::vect_active() == cortex_m::peripheral::scb::VectActive::ThreadMode
&& cortex_m::register::primask::read().is_active();
#[cfg(target_has_atomic = "ptr")]
let enabled = enabled
&& cortex_m::register::basepri::read() == 0
&& cortex_m::register::faultmask::read().is_active();
enabled
}