mx25r 1.0.0

Platform-agnostic Rust driver for the macronix MX25R NOR flash.
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

use bit::BitIndex;

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct ManufacturerId(pub u8);

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct MemoryType(pub u8);

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct MemoryDensity(pub u8);

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct ElectronicId(pub u8);

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct DeviceId(pub u8);

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Clone, Copy)]
pub struct StatusRegister {
    pub write_protect_disable: bool,
    pub quad_enable: bool,
    pub protected_block: u8,
    pub write_enable_latch: bool,
    pub wip_bit: bool,
}

impl From<u8> for StatusRegister {
    fn from(val: u8) -> StatusRegister {
        StatusRegister {
            write_protect_disable: val.bit(7),
            quad_enable: val.bit(6),
            protected_block: val.bit_range(2..6),
            write_enable_latch: val.bit(1),
            wip_bit: val.bit(0),
        }
    }
}

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Clone, Copy)]
pub enum ProtectedArea {
    Top,
    Bottom,
}
impl From<bool> for ProtectedArea {
    fn from(val: bool) -> Self {
        if val {
            ProtectedArea::Bottom
        } else {
            ProtectedArea::Top
        }
    }
}
impl From<ProtectedArea> for bool {
    fn from(val: ProtectedArea) -> Self {
        match val {
            ProtectedArea::Bottom => true,
            ProtectedArea::Top => false,
        }
    }
}

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Clone, Copy)]
pub enum PowerMode {
    UltraLowPower,
    HighPerformance,
}
impl From<bool> for PowerMode {
    fn from(val: bool) -> Self {
        if val {
            PowerMode::HighPerformance
        } else {
            PowerMode::UltraLowPower
        }
    }
}
impl From<PowerMode> for bool {
    fn from(val: PowerMode) -> Self {
        match val {
            PowerMode::HighPerformance => true,
            PowerMode::UltraLowPower => false,
        }
    }
}

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Clone, Copy)]
pub struct ConfigurationRegister {
    pub dummmy_cycle: bool,
    pub protected_section: ProtectedArea,
    pub power_mode: PowerMode,
}

#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Debug, Clone, Copy)]
pub struct SecurityRegister {
    pub erase_failed: bool,
    pub program_failed: bool,
    pub erase_suspended: bool,
    pub program_suspended: bool,
    pub locked_down: bool,
    pub secured_otp: bool,
}