airfrog-core 0.1.2

Rust native ARM debug support
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
106
107
108
109
110
111
112
113
114
115
116
117

// Copyright (C) 2025 Piers Finlayson <piers@piers.rocks>
//
// MIT License

//! ARM SWD Register Access Traits
//!
//! These are used to ensure strongly typed access to reading and writing SWD
//! registers, using
//!
//! * `airfrog_swd::interface::SwdInterface::read_dp_register`
//! * `airfrog_swd::interface::SwdInterface::read_ap_register`
//! * `airfrog_swd::interface::SwdInterface::write_dp_register`
//! * `airfrog_swd::interface::SwdInterface::write_ap_register`
//!
//! Unless you are extending the debug/SWD protocol support, it is unlikely
//! that you will need to use these traits directly.

/// Base trait for all ARM debug register descriptors
pub trait RegisterDescriptor {
    const ADDRESS: u8;
    type Value;
}

/// Registers that can be read
pub trait ReadableRegister: RegisterDescriptor {
    /// Convert raw 32-bit data to register value
    fn from_raw(data: u32) -> Self::Value
    where
        Self::Value: From<u32>,
    {
        Self::Value::from(data)
    }
}

/// Registers that can be written  
pub trait WritableRegister: RegisterDescriptor {
    /// Convert register value to raw 32-bit data
    fn to_raw(value: Self::Value) -> u32
    where
        Self::Value: Into<u32>,
    {
        value.into()
    }
}

/// Debug Port registers (accessed via DP operations)
pub trait DpRegister: RegisterDescriptor {}

/// Access Port registers (accessed via AP operations)
pub trait ApRegister: RegisterDescriptor {}

/// Generate a read-only register data type
#[macro_export]
macro_rules! register_data_r {
    ($name:ident) => {
        // Used to retrieve value
        impl From<$name> for u32 {
            fn from(value: $name) -> u32 {
                value.0
            }
        }

        impl From<u32> for $name {
            fn from(value: u32) -> Self {
                $name(value)
            }
        }

        impl fmt::Display for $name {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "0x{:08X}", self.0)
            }
        }
    };
}

/// Generate a read-write register data type
#[macro_export]
macro_rules! register_data_rw {
    ($name:ident) => {
        impl From<$name> for u32 {
            fn from(value: $name) -> u32 {
                value.0
            }
        }

        impl From<u32> for $name {
            fn from(value: u32) -> Self {
                $name(value)
            }
        }

        impl fmt::Display for $name {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "0x{:08X}", self.0)
            }
        }
    };
}

/// Generate a write-only register data type  
#[macro_export]
macro_rules! register_data_w {
    ($name:ident) => {
        impl From<$name> for u32 {
            fn from(value: $name) -> u32 {
                value.0
            }
        }

        impl fmt::Display for $name {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                write!(f, "0x{:08X}", self.0)
            }
        }
    };
}