stm32h7 0.16.0

Device support crates for STM32H7 devices
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

///Register `WPCCR` reader
pub type R = crate::R<WPCCRrs>;
///Register `WPCCR` writer
pub type W = crate::W<WPCCRrs>;
///Field `IMODE` reader - Instruction mode This field defines the instruction phase mode of operation. Others: reserved
pub type IMODE_R = crate::FieldReader;
///Field `IMODE` writer - Instruction mode This field defines the instruction phase mode of operation. Others: reserved
pub type IMODE_W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
///Field `IDTR` reader - Instruction double transfer rate This bit sets the DTR mode for the instruction phase.
pub type IDTR_R = crate::BitReader;
///Field `IDTR` writer - Instruction double transfer rate This bit sets the DTR mode for the instruction phase.
pub type IDTR_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `ISIZE` reader - Instruction size This field defines instruction size.
pub type ISIZE_R = crate::FieldReader;
///Field `ISIZE` writer - Instruction size This field defines instruction size.
pub type ISIZE_W<'a, REG> = crate::FieldWriter<'a, REG, 2>;
///Field `ADMODE` reader - Address mode This field defines the address phase mode of operation. Others: reserved
pub type ADMODE_R = crate::FieldReader;
///Field `ADMODE` writer - Address mode This field defines the address phase mode of operation. Others: reserved
pub type ADMODE_W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
///Field `ADDTR` reader - Address double transfer rate This bit sets the DTR mode for the address phase.
pub type ADDTR_R = crate::BitReader;
///Field `ADDTR` writer - Address double transfer rate This bit sets the DTR mode for the address phase.
pub type ADDTR_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `ADSIZE` reader - Address size This field defines address size.
pub type ADSIZE_R = crate::FieldReader;
///Field `ADSIZE` writer - Address size This field defines address size.
pub type ADSIZE_W<'a, REG> = crate::FieldWriter<'a, REG, 2>;
///Field `ABMODE` reader - Alternate-byte mode This field defines the alternate byte phase mode of operation.
pub type ABMODE_R = crate::FieldReader;
///Field `ABMODE` writer - Alternate-byte mode This field defines the alternate byte phase mode of operation.
pub type ABMODE_W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
///Field `ABDTR` reader - Alternate bytes double transfer rate This bit sets the DTR mode for the alternate bytes phase.
pub type ABDTR_R = crate::BitReader;
///Field `ABDTR` writer - Alternate bytes double transfer rate This bit sets the DTR mode for the alternate bytes phase.
pub type ABDTR_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `ABSIZE` reader - Alternate bytes size This bit defines alternate bytes size.
pub type ABSIZE_R = crate::FieldReader;
///Field `ABSIZE` writer - Alternate bytes size This bit defines alternate bytes size.
pub type ABSIZE_W<'a, REG> = crate::FieldWriter<'a, REG, 2>;
///Field `DMODE` reader - Data mode This field defines the data phase mode of operation. 101; data on 16 lines Others: reserved
pub type DMODE_R = crate::FieldReader;
///Field `DMODE` writer - Data mode This field defines the data phase mode of operation. 101; data on 16 lines Others: reserved
pub type DMODE_W<'a, REG> = crate::FieldWriter<'a, REG, 3>;
///Field `DDTR` reader - Data double transfer rate This bit sets the DTR mode for the data phase.
pub type DDTR_R = crate::BitReader;
///Field `DDTR` writer - Data double transfer rate This bit sets the DTR mode for the data phase.
pub type DDTR_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `DQSE` reader - DQS enable This bit enables the data strobe management.
pub type DQSE_R = crate::BitReader;
///Field `DQSE` writer - DQS enable This bit enables the data strobe management.
pub type DQSE_W<'a, REG> = crate::BitWriter<'a, REG>;
impl R {
    ///Bits 0:2 - Instruction mode This field defines the instruction phase mode of operation. Others: reserved
    #[inline(always)]
    pub fn imode(&self) -> IMODE_R {
        IMODE_R::new((self.bits & 7) as u8)
    }
    ///Bit 3 - Instruction double transfer rate This bit sets the DTR mode for the instruction phase.
    #[inline(always)]
    pub fn idtr(&self) -> IDTR_R {
        IDTR_R::new(((self.bits >> 3) & 1) != 0)
    }
    ///Bits 4:5 - Instruction size This field defines instruction size.
    #[inline(always)]
    pub fn isize(&self) -> ISIZE_R {
        ISIZE_R::new(((self.bits >> 4) & 3) as u8)
    }
    ///Bits 8:10 - Address mode This field defines the address phase mode of operation. Others: reserved
    #[inline(always)]
    pub fn admode(&self) -> ADMODE_R {
        ADMODE_R::new(((self.bits >> 8) & 7) as u8)
    }
    ///Bit 11 - Address double transfer rate This bit sets the DTR mode for the address phase.
    #[inline(always)]
    pub fn addtr(&self) -> ADDTR_R {
        ADDTR_R::new(((self.bits >> 11) & 1) != 0)
    }
    ///Bits 12:13 - Address size This field defines address size.
    #[inline(always)]
    pub fn adsize(&self) -> ADSIZE_R {
        ADSIZE_R::new(((self.bits >> 12) & 3) as u8)
    }
    ///Bits 16:18 - Alternate-byte mode This field defines the alternate byte phase mode of operation.
    #[inline(always)]
    pub fn abmode(&self) -> ABMODE_R {
        ABMODE_R::new(((self.bits >> 16) & 7) as u8)
    }
    ///Bit 19 - Alternate bytes double transfer rate This bit sets the DTR mode for the alternate bytes phase.
    #[inline(always)]
    pub fn abdtr(&self) -> ABDTR_R {
        ABDTR_R::new(((self.bits >> 19) & 1) != 0)
    }
    ///Bits 20:21 - Alternate bytes size This bit defines alternate bytes size.
    #[inline(always)]
    pub fn absize(&self) -> ABSIZE_R {
        ABSIZE_R::new(((self.bits >> 20) & 3) as u8)
    }
    ///Bits 24:26 - Data mode This field defines the data phase mode of operation. 101; data on 16 lines Others: reserved
    #[inline(always)]
    pub fn dmode(&self) -> DMODE_R {
        DMODE_R::new(((self.bits >> 24) & 7) as u8)
    }
    ///Bit 27 - Data double transfer rate This bit sets the DTR mode for the data phase.
    #[inline(always)]
    pub fn ddtr(&self) -> DDTR_R {
        DDTR_R::new(((self.bits >> 27) & 1) != 0)
    }
    ///Bit 29 - DQS enable This bit enables the data strobe management.
    #[inline(always)]
    pub fn dqse(&self) -> DQSE_R {
        DQSE_R::new(((self.bits >> 29) & 1) != 0)
    }
}
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("WPCCR")
            .field("imode", &self.imode())
            .field("idtr", &self.idtr())
            .field("isize", &self.isize())
            .field("admode", &self.admode())
            .field("addtr", &self.addtr())
            .field("adsize", &self.adsize())
            .field("abmode", &self.abmode())
            .field("abdtr", &self.abdtr())
            .field("absize", &self.absize())
            .field("dmode", &self.dmode())
            .field("ddtr", &self.ddtr())
            .field("dqse", &self.dqse())
            .finish()
    }
}
impl W {
    ///Bits 0:2 - Instruction mode This field defines the instruction phase mode of operation. Others: reserved
    #[inline(always)]
    pub fn imode(&mut self) -> IMODE_W<WPCCRrs> {
        IMODE_W::new(self, 0)
    }
    ///Bit 3 - Instruction double transfer rate This bit sets the DTR mode for the instruction phase.
    #[inline(always)]
    pub fn idtr(&mut self) -> IDTR_W<WPCCRrs> {
        IDTR_W::new(self, 3)
    }
    ///Bits 4:5 - Instruction size This field defines instruction size.
    #[inline(always)]
    pub fn isize(&mut self) -> ISIZE_W<WPCCRrs> {
        ISIZE_W::new(self, 4)
    }
    ///Bits 8:10 - Address mode This field defines the address phase mode of operation. Others: reserved
    #[inline(always)]
    pub fn admode(&mut self) -> ADMODE_W<WPCCRrs> {
        ADMODE_W::new(self, 8)
    }
    ///Bit 11 - Address double transfer rate This bit sets the DTR mode for the address phase.
    #[inline(always)]
    pub fn addtr(&mut self) -> ADDTR_W<WPCCRrs> {
        ADDTR_W::new(self, 11)
    }
    ///Bits 12:13 - Address size This field defines address size.
    #[inline(always)]
    pub fn adsize(&mut self) -> ADSIZE_W<WPCCRrs> {
        ADSIZE_W::new(self, 12)
    }
    ///Bits 16:18 - Alternate-byte mode This field defines the alternate byte phase mode of operation.
    #[inline(always)]
    pub fn abmode(&mut self) -> ABMODE_W<WPCCRrs> {
        ABMODE_W::new(self, 16)
    }
    ///Bit 19 - Alternate bytes double transfer rate This bit sets the DTR mode for the alternate bytes phase.
    #[inline(always)]
    pub fn abdtr(&mut self) -> ABDTR_W<WPCCRrs> {
        ABDTR_W::new(self, 19)
    }
    ///Bits 20:21 - Alternate bytes size This bit defines alternate bytes size.
    #[inline(always)]
    pub fn absize(&mut self) -> ABSIZE_W<WPCCRrs> {
        ABSIZE_W::new(self, 20)
    }
    ///Bits 24:26 - Data mode This field defines the data phase mode of operation. 101; data on 16 lines Others: reserved
    #[inline(always)]
    pub fn dmode(&mut self) -> DMODE_W<WPCCRrs> {
        DMODE_W::new(self, 24)
    }
    ///Bit 27 - Data double transfer rate This bit sets the DTR mode for the data phase.
    #[inline(always)]
    pub fn ddtr(&mut self) -> DDTR_W<WPCCRrs> {
        DDTR_W::new(self, 27)
    }
    ///Bit 29 - DQS enable This bit enables the data strobe management.
    #[inline(always)]
    pub fn dqse(&mut self) -> DQSE_W<WPCCRrs> {
        DQSE_W::new(self, 29)
    }
}
/**XSPI wrap communication configuration register

You can [`read`](crate::Reg::read) this register and get [`wpccr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`wpccr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).*/
pub struct WPCCRrs;
impl crate::RegisterSpec for WPCCRrs {
    type Ux = u32;
}
///`read()` method returns [`wpccr::R`](R) reader structure
impl crate::Readable for WPCCRrs {}
///`write(|w| ..)` method takes [`wpccr::W`](W) writer structure
impl crate::Writable for WPCCRrs {
    type Safety = crate::Unsafe;
}
///`reset()` method sets WPCCR to value 0
impl crate::Resettable for WPCCRrs {}