rdif-reset 0.1.0

Driver Interface reset controller definition.
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

#![no_std]

extern crate alloc;

use rdif_base::def_driver;
pub use rdif_base::{DriverGeneric, custom_type};

custom_type!(
    #[doc = "Reset signal id"],
    ResetId, u64, "{:#x}");

impl ResetId {
    pub const fn new(value: u64) -> Self {
        Self(value)
    }
}

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

impl From<usize> for ResetId {
    fn from(value: usize) -> Self {
        Self(value as u64)
    }
}

#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Eq)]
pub enum ResetError {
    #[error("invalid reset id")]
    InvalidId,
    #[error("unsupported reset operation")]
    Unsupported,
    #[error("reset controller is busy")]
    Busy,
    #[error("reset controller error")]
    Controller,
}

pub trait Interface: DriverGeneric {
    fn assert(&mut self, id: ResetId) -> Result<(), ResetError>;

    fn deassert(&mut self, id: ResetId) -> Result<(), ResetError>;

    fn reset(&mut self, id: ResetId) -> Result<(), ResetError> {
        self.assert(id)?;
        self.deassert(id)
    }
}

def_driver!(Reset, Interface);

#[cfg(test)]
mod tests {
    use super::*;

    struct RecordingReset {
        calls: alloc::vec::Vec<(&'static str, ResetId)>,
    }

    impl DriverGeneric for RecordingReset {
        fn name(&self) -> &str {
            "recording-reset"
        }
    }

    impl Interface for RecordingReset {
        fn assert(&mut self, id: ResetId) -> Result<(), ResetError> {
            self.calls.push(("assert", id));
            Ok(())
        }

        fn deassert(&mut self, id: ResetId) -> Result<(), ResetError> {
            self.calls.push(("deassert", id));
            Ok(())
        }
    }

    #[test]
    fn reset_id_conversions_preserve_raw_value() {
        assert_eq!(ResetId::new(7).raw(), 7);
        assert_eq!(ResetId::from(8_u32).raw(), 8);
        assert_eq!(ResetId::from(9_usize).raw(), 9);
        assert_eq!(ResetId::from(10_u64).raw(), 10);
    }

    #[test]
    fn reset_pulses_assert_then_deassert() {
        let mut reset = RecordingReset {
            calls: alloc::vec::Vec::new(),
        };

        reset.reset(ResetId::new(3)).unwrap();

        assert_eq!(
            reset.calls,
            alloc::vec![("assert", ResetId::new(3)), ("deassert", ResetId::new(3))]
        );
    }

    #[test]
    fn reset_wrapper_exposes_typed_driver() {
        let mut reset = Reset::new(RecordingReset {
            calls: alloc::vec::Vec::new(),
        });

        assert!(reset.typed_ref::<RecordingReset>().is_some());
        assert!(reset.typed_mut::<RecordingReset>().is_some());
    }
}