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
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

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

lib_enum! {
    /// Represents the time value for the [Taac](super::TimeAsyncAccessCycles) field.
    AccessTimeValue: u8 {
        default: Value10,
        error: Error,
        /// Time value: 1.0.
        Value10 = 0x1,
        /// Time value: 1.2.
        Value12 = 0x2,
        /// Time value: 1.3.
        Value13 = 0x3,
        /// Time value: 1.5.
        Value15 = 0x4,
        /// Time value: 2.0.
        Value20 = 0x5,
        /// Time value: 2.5.
        Value25 = 0x6,
        /// Time value: 3.0.
        Value30 = 0x7,
        /// Time value: 3.5.
        Value35 = 0x8,
        /// Time value: 4.0.
        Value40 = 0x9,
        /// Time value: 4.5.
        Value45 = 0xa,
        /// Time value: 5.0.
        Value50 = 0xb,
        /// Time value: 5.5.
        Value55 = 0xc,
        /// Time value: 6.0.
        Value60 = 0xd,
        /// Time value: 7.0.
        Value70 = 0xe,
        /// Time value: 8.0.
        Value80 = 0xf,
    }
}

impl AccessTimeValue {
    /// Gets the time value multiplier for [AccessTimeValue].
    ///
    /// ## Example
    ///
    /// ```rust
    /// # use sdmmc_core::register::csd::v1::taac::{AccessTimeUnit, AccessTimeValue};
    /// // To get the actual time value:
    /// let time = (AccessTimeValue::Value13.value() * (AccessTimeUnit::Ms10.ns() as f32)) as u32;
    /// assert_eq!(time, 13_000_000);
    /// ```
    pub const fn value(&self) -> f32 {
        match self {
            Self::Value10 => 1.0,
            Self::Value12 => 1.2,
            Self::Value13 => 1.3,
            Self::Value15 => 1.5,
            Self::Value20 => 2.0,
            Self::Value25 => 2.5,
            Self::Value30 => 3.0,
            Self::Value35 => 3.5,
            Self::Value40 => 4.0,
            Self::Value45 => 4.5,
            Self::Value50 => 5.0,
            Self::Value55 => 5.5,
            Self::Value60 => 6.0,
            Self::Value70 => 7.0,
            Self::Value80 => 8.0,
        }
    }

    /// Gets the integer time value multiplier for [AccessTimeValue].
    ///
    /// The integer is the float value multiplied by 10.
    ///
    /// ## Example
    ///
    /// ```rust
    /// # use sdmmc_core::register::csd::v1::taac::{AccessTimeUnit, AccessTimeValue};
    /// // To get the actual time value:
    /// let time = (AccessTimeValue::Value80.value_int() * AccessTimeUnit::Ms10.ns()) / 10;
    /// assert_eq!(time, 80_000_000);
    /// ```
    pub const fn value_int(&self) -> u32 {
        match self {
            Self::Value10 => 10,
            Self::Value12 => 12,
            Self::Value13 => 13,
            Self::Value15 => 15,
            Self::Value20 => 20,
            Self::Value25 => 25,
            Self::Value30 => 30,
            Self::Value35 => 35,
            Self::Value40 => 40,
            Self::Value45 => 45,
            Self::Value50 => 50,
            Self::Value55 => 55,
            Self::Value60 => 60,
            Self::Value70 => 70,
            Self::Value80 => 80,
        }
    }

    /// Attempts to convert a byte array into a [AccessTimeValue].
    pub const fn try_from_inner(val: u8) -> Result<Self> {
        Self::from_raw(val)
    }

    /// Converts a [AccessTimeValue] into an byte array.
    pub const fn into_inner(self) -> u8 {
        self.into_raw()
    }
}