cortex-m 0.7.8

Low level access to Cortex-M processors
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Process Stack Pointer support

// This is a useful lint for functions like 'asm::wfi()' but it's not a useful
// lint here.
#![allow(clippy::missing_inline_in_public_items)]

use core::{
    cell::UnsafeCell,
    sync::atomic::{AtomicBool, Ordering},
};

/// Represents access to a [`Stack`]
pub struct StackHandle(*mut u32, usize);

impl StackHandle {
    /// Get the pointer to the top of the stack
    pub fn top(&mut self) -> *mut u32 {
        // SAFETY: The stack was this big when we constructed the handle
        unsafe { self.0.add(self.1) }
    }

    /// Get the pointer to the bottom of the stack
    pub fn bottom(&mut self) -> *mut u32 {
        self.0
    }
}

/// A stack you can use as your Process Stack (PSP)
///
/// The const-param N is the size **in 32-bit words**
#[repr(align(8), C)]
pub struct Stack<const N: usize> {
    space: UnsafeCell<[u32; N]>,
    taken: AtomicBool,
}

impl<const N: usize> Stack<N> {
    /// Const-initialise a Stack
    ///
    /// Use a turbofish to specify the size, like:
    ///
    /// ```rust
    /// # use cortex_m::psp::Stack;
    /// static PSP_STACK: Stack::<4096> = Stack::new();
    /// fn example() {
    ///    let handle = PSP_STACK.take_handle();
    ///    // ...
    /// }
    /// ```
    pub const fn new() -> Stack<N> {
        Stack {
            space: UnsafeCell::new([0; N]),
            taken: AtomicBool::new(false),
        }
    }

    /// Return the top of the stack
    pub fn take_handle(&self) -> StackHandle {
        if self.taken.load(Ordering::Acquire) {
            panic!("Cannot get two handles to one stack!");
        }
        self.taken.store(true, Ordering::Release);

        let start = self.space.get() as *mut u32;
        StackHandle(start, N)
    }
}

unsafe impl<const N: usize> Sync for Stack<N> {}

impl<const N: usize> core::default::Default for Stack<N> {
    fn default() -> Self {
        Stack::new()
    }
}

/// Switch to unprivileged mode running on the Process Stack Pointer (PSP)
///
/// In Unprivileged Mode, code can no longer perform privileged operations,
/// such as disabling interrupts.
///
pub fn switch_to_unprivileged_psp(mut psp_stack: StackHandle, function: extern "C" fn() -> !) -> ! {
    // set the stack limit
    #[cfg(armv8m_main)]
    unsafe {
        crate::register::psplim::write(psp_stack.bottom() as u32);
    }
    // do the switch
    unsafe {
        crate::asm::enter_unprivileged_psp(psp_stack.top(), function);
    }
}

/// Switch to running on the Process Stack Pointer (PSP), but remain in privileged mode
pub fn switch_to_privileged_psp(mut psp_stack: StackHandle, function: extern "C" fn() -> !) -> ! {
    // set the stack limit
    #[cfg(armv8m_main)]
    unsafe {
        crate::register::psplim::write(psp_stack.bottom() as u32);
    }
    // do the switch
    unsafe {
        crate::asm::enter_privileged_psp(psp_stack.top(), function);
    }
}