async-embedded-sdmmc 0.3.1

Embedded sdmmc driver with async support
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

use bitfield::Bit;
use displaydoc::Display;

#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub struct R1(pub u8);

impl Default for R1 {
    fn default() -> Self {
        Self(0x80)
    }
}

#[derive(Copy, Clone, Debug, Display)]
#[repr(u8)]
pub enum R1Status {
    /// in idle state
    InIdleState = 0,
    /// illegal command
    IllegalCommand,
    /// command CRC error
    CommandCRCError,
    /// erase sequence error
    EraseSequenceError,
    /// address error
    AddressError,
    /// parameter error
    ParameterError,
}

impl core::error::Error for R1Status {}

impl R1 {
    pub fn valid(self) -> bool {
        !self.0.bit(7)
    }

    pub fn has(self, status: R1Status) -> bool {
        self.0.bit(status as usize)
    }

    pub fn error(self) -> Option<R1Status> {
        let value = (self.0 >> 3) & 0b1111;
        let error_bit = value ^ ((value.wrapping_sub(1)) & value);
        let error = match error_bit {
            0b0001 => R1Status::CommandCRCError,
            0b0010 => R1Status::EraseSequenceError,
            0b0100 => R1Status::AddressError,
            0b1000 => R1Status::ParameterError,
            _ => return None,
        };
        Some(error)
    }
}

#[derive(Copy, Clone, Default, Debug)]
#[repr(C)]
pub struct R3(pub u32);

impl R3 {
    pub fn card_capacity_status(self) -> bool {
        self.0.bit(30)
    }
}

#[derive(Copy, Clone, Default, Debug)]
pub struct R7(pub u32);

impl R7 {
    pub fn voltage_accepted(self) -> bool {
        self.0.bit(8) // only bit 8 meaningful, for now
    }

    pub fn echo_back_check_pattern(self) -> u8 {
        self.0 as u8
    }
}

#[derive(Copy, Clone, Default)]
pub struct Response {
    pub r1: R1,
    pub ex: u32,
}