cortex_m/
itm.rs

1//! Instrumentation Trace Macrocell
2//!
3//! **NOTE** This module is only available on ARMv7-M and newer.
4
5use core::{fmt, ptr, slice};
6
7use crate::peripheral::itm::Stim;
8
9// NOTE assumes that `bytes` is 32-bit aligned
10unsafe fn write_words(stim: &mut Stim, bytes: &[u32]) {
11    let mut p = bytes.as_ptr();
12    for _ in 0..bytes.len() {
13        while !stim.is_fifo_ready() {}
14        stim.write_u32(ptr::read(p));
15        p = p.offset(1);
16    }
17}
18
19/// Writes an aligned byte slice to the ITM.
20///
21/// `buffer` must be 4-byte aligned.
22unsafe fn write_aligned_impl(port: &mut Stim, buffer: &[u8]) {
23    let len = buffer.len();
24
25    if len == 0 {
26        return;
27    }
28
29    let split = len & !0b11;
30    #[allow(clippy::cast_ptr_alignment)]
31    write_words(
32        port,
33        slice::from_raw_parts(buffer.as_ptr() as *const u32, split >> 2),
34    );
35
36    // 3 bytes or less left
37    let mut left = len & 0b11;
38    let mut ptr = buffer.as_ptr().add(split);
39
40    // at least 2 bytes left
41    if left > 1 {
42        while !port.is_fifo_ready() {}
43
44        #[allow(clippy::cast_ptr_alignment)]
45        port.write_u16(ptr::read(ptr as *const u16));
46
47        ptr = ptr.offset(2);
48        left -= 2;
49    }
50
51    // final byte
52    if left == 1 {
53        while !port.is_fifo_ready() {}
54        port.write_u8(*ptr);
55    }
56}
57
58struct Port<'p>(&'p mut Stim);
59
60impl<'p> fmt::Write for Port<'p> {
61    #[inline]
62    fn write_str(&mut self, s: &str) -> fmt::Result {
63        write_all(self.0, s.as_bytes());
64        Ok(())
65    }
66}
67
68/// A wrapper type that aligns its contents on a 4-Byte boundary.
69///
70/// ITM transfers are most efficient when the data is 4-Byte-aligned. This type provides an easy
71/// way to accomplish and enforce such an alignment.
72#[repr(align(4))]
73pub struct Aligned<T: ?Sized>(pub T);
74
75/// Writes `buffer` to an ITM port.
76#[allow(clippy::missing_inline_in_public_items)]
77pub fn write_all(port: &mut Stim, buffer: &[u8]) {
78    unsafe {
79        let mut len = buffer.len();
80        let mut ptr = buffer.as_ptr();
81
82        if len == 0 {
83            return;
84        }
85
86        // 0x01 OR 0x03
87        if ptr as usize % 2 == 1 {
88            while !port.is_fifo_ready() {}
89            port.write_u8(*ptr);
90
91            // 0x02 OR 0x04
92            ptr = ptr.offset(1);
93            len -= 1;
94        }
95
96        // 0x02
97        if ptr as usize % 4 == 2 {
98            if len > 1 {
99                // at least 2 bytes
100                while !port.is_fifo_ready() {}
101
102                // We checked the alignment above, so this is safe
103                #[allow(clippy::cast_ptr_alignment)]
104                port.write_u16(ptr::read(ptr as *const u16));
105
106                // 0x04
107                ptr = ptr.offset(2);
108                len -= 2;
109            } else {
110                if len == 1 {
111                    // last byte
112                    while !port.is_fifo_ready() {}
113                    port.write_u8(*ptr);
114                }
115
116                return;
117            }
118        }
119
120        // The remaining data is 4-byte aligned, but might not be a multiple of 4 bytes
121        write_aligned_impl(port, slice::from_raw_parts(ptr, len));
122    }
123}
124
125/// Writes a 4-byte aligned `buffer` to an ITM port.
126///
127/// # Examples
128///
129/// ```no_run
130/// # use cortex_m::{itm::{self, Aligned}, peripheral::ITM};
131/// # let port = unsafe { &mut (*ITM::PTR).stim[0] };
132/// let mut buffer = Aligned([0; 14]);
133///
134/// buffer.0.copy_from_slice(b"Hello, world!\n");
135///
136/// itm::write_aligned(port, &buffer);
137///
138/// // Or equivalently
139/// itm::write_aligned(port, &Aligned(*b"Hello, world!\n"));
140/// ```
141#[allow(clippy::missing_inline_in_public_items)]
142pub fn write_aligned(port: &mut Stim, buffer: &Aligned<[u8]>) {
143    unsafe { write_aligned_impl(port, &buffer.0) }
144}
145
146/// Writes `fmt::Arguments` to the ITM `port`
147#[inline]
148pub fn write_fmt(port: &mut Stim, args: fmt::Arguments) {
149    use core::fmt::Write;
150
151    Port(port).write_fmt(args).ok();
152}
153
154/// Writes a string to the ITM `port`
155#[inline]
156pub fn write_str(port: &mut Stim, string: &str) {
157    write_all(port, string.as_bytes())
158}
cortex_m/itm.rs

cortex_m/
itm.rs
