sdmmc-core 0.5.0

SD/MMC core data structures and algorithms
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

use crate::lib_bitfield;
use crate::result::{Error, Result};

mod time_unit;
mod time_value;

pub use time_unit::AccessTimeUnit;
pub use time_value::AccessTimeValue;

lib_bitfield! {
    /// Represents the asynchronous part of the data access time.
    ///
    /// This structure is used for the `TAAC` field in `CSD` V2, V3, and future fixed value variants.
    TimeAsyncAccessCycles: u8,
    mask: 0x7f,
    default: 0xe,
    {
        /// Represents the [AccessTimeValue] for the [TimeAsyncAccessCycles].
        time_value: AccessTimeValue, 6, 3;
        /// Represents the [AccessTimeUnit] for the [TimeAsyncAccessCycles].
        time_unit: AccessTimeUnit, 2, 0;
    }
}

impl TimeAsyncAccessCycles {
    /// Represents the bitmask for the `time_unit` sub-field.
    pub const UNIT_MASK: u8 = 0x7;
    /// Represents the bitmask for the `time_value` sub-field.
    pub const VALUE_MASK: u8 = 0x78;
    /// Represents the bitshift for the `time_value` sub-field.
    pub const VALUE_SHIFT: usize = 3;

    /// Gets the total time (in nanoseconds) for the [TimeAsyncAccessCycles].
    pub const fn time_ns(&self) -> u32 {
        match (self.time_value(), self.time_unit()) {
            (Ok(time_value), Ok(time_unit)) => (time_value.value_int() * time_unit.ns()) / 10,
            _ => 0,
        }
    }
}

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

    type Taac = TimeAsyncAccessCycles;

    #[test]
    fn test_valid() {
        let taac = Taac::new();

        assert_eq!(taac.time_unit(), Ok(AccessTimeUnit::Ms1));
        assert_eq!(taac.time_value(), Ok(AccessTimeValue::Value10));

        let raw = Taac::DEFAULT;
        let exp_taac = Taac::try_from_inner(raw & Taac::MASK).unwrap();
        let exp_unit = AccessTimeUnit::Ms1;
        let exp_value = AccessTimeValue::Value10;
        let exp_ns = (exp_value.value_int() * exp_unit.ns()) / 10;

        assert_eq!(Taac::try_from_inner(raw), Ok(exp_taac));
        assert_eq!(Taac::try_from(raw), Ok(exp_taac));

        assert_eq!(exp_taac.bits(), raw & Taac::MASK);
        assert_eq!(u8::from(exp_taac), raw & Taac::MASK);

        assert_eq!(exp_taac.time_unit(), Ok(exp_unit));
        assert_eq!(exp_taac.time_value(), Ok(exp_value));
        assert_eq!(exp_taac.time_ns(), exp_ns);
    }

    #[test]
    fn test_invalid() {
        (0..=u8::MAX)
            .filter(|b| (b & Taac::MASK) != Taac::DEFAULT)
            .for_each(|raw| {
                assert!(Taac::try_from_inner(raw).is_err());
                assert!(Taac::try_from(raw).is_err());
            });
    }
}