culvert 0.1.2

Typed access to the HDMI 2.1 SCDC register map
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

use hdmi_hal::scdc::ScdcTransport;

use crate::error::ScdcError;
use crate::register::UpdateFlags;
use crate::register::address;

use super::Scdc;

impl<T: ScdcTransport> Scdc<T> {
    /// Reads update flags from `Update_0` (0x10) and `Update_1` (0x11).
    pub fn read_update_flags(&mut self) -> Result<UpdateFlags, ScdcError<T::Error>> {
        let u0 = self
            .transport
            .read(address::UPDATE_0)
            .map_err(ScdcError::Transport)?;
        let u1 = self
            .transport
            .read(address::UPDATE_1)
            .map_err(ScdcError::Transport)?;
        Ok(UpdateFlags {
            status_update: u0 & 0x01 != 0,
            ced_update: u0 & 0x02 != 0,
            frl_update: u0 & 0x04 != 0,
            dsc_update: u1 & 0x01 != 0,
        })
    }

    /// Clears the specified update flags in `Update_0` (0x10) and `Update_1` (0x11).
    ///
    /// Each flag set to `true` in `flags` is cleared (write-1-to-clear). Flags
    /// set to `false` are left unchanged.
    pub fn clear_update_flags(&mut self, flags: UpdateFlags) -> Result<(), ScdcError<T::Error>> {
        let u0 = (flags.status_update as u8)
            | ((flags.ced_update as u8) << 1)
            | ((flags.frl_update as u8) << 2);
        let u1 = flags.dsc_update as u8;
        self.transport
            .write(address::UPDATE_0, u0)
            .map_err(ScdcError::Transport)?;
        self.transport
            .write(address::UPDATE_1, u1)
            .map_err(ScdcError::Transport)
    }
}

#[cfg(test)]
mod tests {
    use super::super::Scdc;
    use super::super::test_transport::TestTransport;
    use crate::register::UpdateFlags;

    #[test]
    fn update_flags_individual_bits() {
        // status_update = bit 0 of Update_0
        let mut sim = TestTransport::new();
        sim.set(0x10, 0x01);
        assert!(Scdc::new(sim).read_update_flags().unwrap().status_update);

        // ced_update = bit 1
        let mut sim = TestTransport::new();
        sim.set(0x10, 0x02);
        assert!(Scdc::new(sim).read_update_flags().unwrap().ced_update);

        // frl_update = bit 2
        let mut sim = TestTransport::new();
        sim.set(0x10, 0x04);
        assert!(Scdc::new(sim).read_update_flags().unwrap().frl_update);

        // dsc_update = bit 0 of Update_1
        let mut sim = TestTransport::new();
        sim.set(0x11, 0x01);
        assert!(Scdc::new(sim).read_update_flags().unwrap().dsc_update);
    }

    #[test]
    fn clear_update_flags_w1c() {
        let mut scdc = Scdc::new(TestTransport::new());
        scdc.clear_update_flags(UpdateFlags::new(true, true, true, true))
            .unwrap();
        let t = scdc.into_transport();
        assert_eq!(t.get(0x10), 0x07);
        assert_eq!(t.get(0x11), 0x01);
    }

    #[test]
    fn clear_update_flags_partial() {
        let mut scdc = Scdc::new(TestTransport::new());
        scdc.clear_update_flags(UpdateFlags::new(false, true, false, false))
            .unwrap();
        let t = scdc.into_transport();
        assert_eq!(t.get(0x10), 0x02); // only ced_update bit
        assert_eq!(t.get(0x11), 0x00);
    }

    #[test]
    fn transport_error_propagates() {
        // First read fails.
        assert!(
            Scdc::new(TestTransport::failing_after(0))
                .read_update_flags()
                .is_err()
        );
        // Second read (Update_1) fails.
        assert!(
            Scdc::new(TestTransport::failing_after(1))
                .read_update_flags()
                .is_err()
        );
        // First write fails.
        assert!(
            Scdc::new(TestTransport::failing_after(0))
                .clear_update_flags(UpdateFlags::new(false, false, false, false))
                .is_err()
        );
        // Second write (Update_1) fails.
        assert!(
            Scdc::new(TestTransport::failing_after(1))
                .clear_update_flags(UpdateFlags::new(false, false, false, false))
                .is_err()
        );
    }
}