probe-rs 0.4.0

A collection of on chip debugging tools to comminicate with ARM chips.
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

use crate::config::target::Target;
use crate::probe::{DebugProbeError, MasterProbe};

pub struct Session {
    pub target: Target,
    pub probe: MasterProbe,

    hw_breakpoint_enabled: bool,
    active_breakpoints: Vec<Breakpoint>,
}

impl Session {
    /// Open a new session with a given debug target
    pub fn new(target: Target, probe: MasterProbe) -> Self {
        Self {
            target,
            probe,
            hw_breakpoint_enabled: false,
            active_breakpoints: Vec::new(),
        }
    }

    /// Set a hardware breakpoint
    pub fn set_hw_breakpoint(&mut self, address: u32) -> Result<(), DebugProbeError> {
        log::debug!("Trying to set HW breakpoint at address {:#08x}", address);

        // Get the number of HW breakpoints available
        let num_hw_breakpoints =
            self.target
                .core
                .get_available_breakpoint_units(&mut self.probe)? as usize;

        log::debug!("{} HW breakpoints are supported.", num_hw_breakpoints);

        if num_hw_breakpoints <= self.active_breakpoints.len() {
            // We cannot set additional breakpoints
            log::warn!("Maximum number of breakpoints ({}) reached, unable to set additional HW breakpoint.", num_hw_breakpoints);

            // TODO: Better error here
            return Err(DebugProbeError::UnknownError);
        }

        if !self.hw_breakpoint_enabled {
            self.target.core.enable_breakpoints(&mut self.probe, true)?;
            self.hw_breakpoint_enabled = true;
        }

        let bp_unit = self.find_free_breakpoint_unit();

        log::debug!("Using comparator {} of breakpoint unit", bp_unit);
        // actually set the breakpoint
        self.target
            .core
            .set_breakpoint(&mut self.probe, bp_unit, address)?;

        self.active_breakpoints.push(Breakpoint {
            address,
            register_hw: bp_unit,
        });

        Ok(())
    }

    pub fn clear_hw_breakpoint(&mut self, address: u32) -> Result<(), DebugProbeError> {
        let bp_position = self
            .active_breakpoints
            .iter()
            .position(|bp| bp.address == address);

        match bp_position {
            Some(bp_position) => {
                let bp = &self.active_breakpoints[bp_position];
                self.target
                    .core
                    .clear_breakpoint(&mut self.probe, bp.register_hw)?;

                // We only remove the breakpoint if we have actually managed to clear it.
                self.active_breakpoints.swap_remove(bp_position);
                Ok(())
            }
            None => Err(DebugProbeError::UnknownError),
        }
    }

    fn find_free_breakpoint_unit(&self) -> usize {
        let mut used_bp: Vec<_> = self
            .active_breakpoints
            .iter()
            .map(|bp| bp.register_hw)
            .collect();
        used_bp.sort();

        let mut free_bp = 0;

        for bp in used_bp {
            if bp == free_bp {
                free_bp += 1;
            } else {
                return free_bp;
            }
        }

        free_bp
    }
}

#[derive(Debug, Copy, Clone, PartialEq)]
pub struct BreakpointId(usize);

impl BreakpointId {
    pub fn new(id: usize) -> Self {
        BreakpointId(id)
    }
}

struct Breakpoint {
    address: u32,
    register_hw: usize,
}

unsafe impl Send for Session {}