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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

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

//! airfrog-core - Raspberry Pi (RPxxxx) specific objects

use core::fmt;

use crate::arm::Cortex;
use crate::arm::ap::{IDR_AHB_AP_CORTEX_M0, IDR_AHB_AP_CORTEX_M33, Idr};
use crate::arm::dp::IdCode;

// RP2040 Flash base addresses
const RP2040_FLASH_BASE: u32 = 0x1000_0000;

// RP2040 RAM base addresses
const RP2040_RAM_BASE: u32 = 0x2000_0000;

// RP2350 Flash base addresses
const RP2350_FLASH_BASE: u32 = 0x1000_0000;

// RP2350 RAM base addresses
const RP2350_RAM_BASE: u32 = 0x2000_0000;

// RP2040 chip ID
pub const RP2040_CHIP_ID: u32 = 0x10002927;
pub const RP2040_CHIP_ID_ADDR: u32 = 0x40000000;

// RP2040 CPU ID
pub const RP2040_CPU_ID: u32 = 0x410CC601;
pub const RP2040_CPU_ID_ADDR: u32 = 0xE000ED00;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RpLine {
    Rp2040,
    Rp2350,
    Unknown,
}

impl RpLine {
    /// Whether this `airfrog-core` is familiar with this RP family
    pub fn known(&self) -> bool {
        !matches!(self, RpLine::Unknown)
    }

    /// Returns the RAM size in bytes
    pub fn ram_size_bytes(&self) -> Option<u32> {
        self.ram_size_kb().map(|size| size * 1024)
    }

    /// Returns the RAM size in KB
    pub fn ram_size_kb(&self) -> Option<u32> {
        match self {
            RpLine::Rp2040 => Some(264),
            RpLine::Rp2350 => Some(512),
            RpLine::Unknown => None,
        }
    }

    /// Returns the expected IDR value for this RP line.
    pub fn expected_idr(&self) -> Option<Idr> {
        match self {
            RpLine::Rp2040 => Some(IDR_AHB_AP_CORTEX_M0),
            RpLine::Rp2350 => Some(IDR_AHB_AP_CORTEX_M33),
            RpLine::Unknown => None,
        }
    }
}

impl fmt::Display for RpLine {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            RpLine::Rp2040 => write!(f, "RP2040"),
            RpLine::Rp2350 => write!(f, "RP2350"),
            RpLine::Unknown => write!(f, "Unknown"),
        }
    }
}

/// RP device details
#[derive(Debug, Clone, Copy)]
pub struct RpDetails {
    line: RpLine,
}

impl RpDetails {
    /// Create a new `RpDetails` instance from a specific RP line
    pub fn from_line(line: RpLine) -> Self {
        Self { line }
    }

    /// Get the family of this RP device
    pub fn line(&self) -> RpLine {
        self.line
    }

    /// Create a new `RpDetails` instance from IdCode
    pub fn from_idcode(idcode: IdCode) -> Option<Self> {
        match idcode {
            Cortex::IDCODE_M0 => Some(RpDetails {
                line: RpLine::Rp2040,
            }),
            Cortex::IDCODE_M33 => Some(RpDetails {
                line: RpLine::Rp2350,
            }),
            _ => None,
        }
    }

    /// Get the base flash address for this MCU
    pub fn flash_base(&self) -> Option<u32> {
        match self.line {
            RpLine::Rp2040 => Some(RP2040_FLASH_BASE),
            RpLine::Rp2350 => Some(RP2350_FLASH_BASE),
            RpLine::Unknown => None,
        }
    }

    /// Get the base RAM address for this MCU
    pub fn ram_base(&self) -> Option<u32> {
        match self.line {
            RpLine::Rp2040 => Some(RP2040_RAM_BASE),
            RpLine::Rp2350 => Some(RP2350_RAM_BASE),
            RpLine::Unknown => None,
        }
    }

    /// Returns the expected IDR value for this device.
    ///
    /// Returns:
    /// - `Some(Idr)`: If the RP line is known.
    /// - `None`: If the RP line is unknown.
    pub fn expected_idr(&self) -> Option<Idr> {
        self.line.expected_idr()
    }
}

impl fmt::Display for RpDetails {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.line)
    }
}