1#[doc = "Reader of register SR"]
2pub type R = crate::R<u32, super::SR>;
3#[doc = "Writer for register SR"]
4pub type W = crate::W<u32, super::SR>;
5#[doc = "Register SR `reset()`'s with value 0"]
6impl crate::ResetValue for super::SR {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0
11 }
12}
13#[doc = "Reader of field `EOP`"]
14pub type EOP_R = crate::R<bool, bool>;
15#[doc = "Write proxy for field `EOP`"]
16pub struct EOP_W<'a> {
17 w: &'a mut W,
18}
19impl<'a> EOP_W<'a> {
20 #[doc = r"Sets the field bit"]
21 #[inline(always)]
22 pub fn set_bit(self) -> &'a mut W {
23 self.bit(true)
24 }
25 #[doc = r"Clears the field bit"]
26 #[inline(always)]
27 pub fn clear_bit(self) -> &'a mut W {
28 self.bit(false)
29 }
30 #[doc = r"Writes raw bits to the field"]
31 #[inline(always)]
32 pub fn bit(self, value: bool) -> &'a mut W {
33 self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
34 self.w
35 }
36}
37#[doc = "Reader of field `OPERR`"]
38pub type OPERR_R = crate::R<bool, bool>;
39#[doc = "Write proxy for field `OPERR`"]
40pub struct OPERR_W<'a> {
41 w: &'a mut W,
42}
43impl<'a> OPERR_W<'a> {
44 #[doc = r"Sets the field bit"]
45 #[inline(always)]
46 pub fn set_bit(self) -> &'a mut W {
47 self.bit(true)
48 }
49 #[doc = r"Clears the field bit"]
50 #[inline(always)]
51 pub fn clear_bit(self) -> &'a mut W {
52 self.bit(false)
53 }
54 #[doc = r"Writes raw bits to the field"]
55 #[inline(always)]
56 pub fn bit(self, value: bool) -> &'a mut W {
57 self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
58 self.w
59 }
60}
61#[doc = "Reader of field `PROGERR`"]
62pub type PROGERR_R = crate::R<bool, bool>;
63#[doc = "Write proxy for field `PROGERR`"]
64pub struct PROGERR_W<'a> {
65 w: &'a mut W,
66}
67impl<'a> PROGERR_W<'a> {
68 #[doc = r"Sets the field bit"]
69 #[inline(always)]
70 pub fn set_bit(self) -> &'a mut W {
71 self.bit(true)
72 }
73 #[doc = r"Clears the field bit"]
74 #[inline(always)]
75 pub fn clear_bit(self) -> &'a mut W {
76 self.bit(false)
77 }
78 #[doc = r"Writes raw bits to the field"]
79 #[inline(always)]
80 pub fn bit(self, value: bool) -> &'a mut W {
81 self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
82 self.w
83 }
84}
85#[doc = "Reader of field `WRPERR`"]
86pub type WRPERR_R = crate::R<bool, bool>;
87#[doc = "Write proxy for field `WRPERR`"]
88pub struct WRPERR_W<'a> {
89 w: &'a mut W,
90}
91impl<'a> WRPERR_W<'a> {
92 #[doc = r"Sets the field bit"]
93 #[inline(always)]
94 pub fn set_bit(self) -> &'a mut W {
95 self.bit(true)
96 }
97 #[doc = r"Clears the field bit"]
98 #[inline(always)]
99 pub fn clear_bit(self) -> &'a mut W {
100 self.bit(false)
101 }
102 #[doc = r"Writes raw bits to the field"]
103 #[inline(always)]
104 pub fn bit(self, value: bool) -> &'a mut W {
105 self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
106 self.w
107 }
108}
109#[doc = "Reader of field `PGAERR`"]
110pub type PGAERR_R = crate::R<bool, bool>;
111#[doc = "Write proxy for field `PGAERR`"]
112pub struct PGAERR_W<'a> {
113 w: &'a mut W,
114}
115impl<'a> PGAERR_W<'a> {
116 #[doc = r"Sets the field bit"]
117 #[inline(always)]
118 pub fn set_bit(self) -> &'a mut W {
119 self.bit(true)
120 }
121 #[doc = r"Clears the field bit"]
122 #[inline(always)]
123 pub fn clear_bit(self) -> &'a mut W {
124 self.bit(false)
125 }
126 #[doc = r"Writes raw bits to the field"]
127 #[inline(always)]
128 pub fn bit(self, value: bool) -> &'a mut W {
129 self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
130 self.w
131 }
132}
133#[doc = "Reader of field `SIZERR`"]
134pub type SIZERR_R = crate::R<bool, bool>;
135#[doc = "Write proxy for field `SIZERR`"]
136pub struct SIZERR_W<'a> {
137 w: &'a mut W,
138}
139impl<'a> SIZERR_W<'a> {
140 #[doc = r"Sets the field bit"]
141 #[inline(always)]
142 pub fn set_bit(self) -> &'a mut W {
143 self.bit(true)
144 }
145 #[doc = r"Clears the field bit"]
146 #[inline(always)]
147 pub fn clear_bit(self) -> &'a mut W {
148 self.bit(false)
149 }
150 #[doc = r"Writes raw bits to the field"]
151 #[inline(always)]
152 pub fn bit(self, value: bool) -> &'a mut W {
153 self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
154 self.w
155 }
156}
157#[doc = "Reader of field `PGSERR`"]
158pub type PGSERR_R = crate::R<bool, bool>;
159#[doc = "Write proxy for field `PGSERR`"]
160pub struct PGSERR_W<'a> {
161 w: &'a mut W,
162}
163impl<'a> PGSERR_W<'a> {
164 #[doc = r"Sets the field bit"]
165 #[inline(always)]
166 pub fn set_bit(self) -> &'a mut W {
167 self.bit(true)
168 }
169 #[doc = r"Clears the field bit"]
170 #[inline(always)]
171 pub fn clear_bit(self) -> &'a mut W {
172 self.bit(false)
173 }
174 #[doc = r"Writes raw bits to the field"]
175 #[inline(always)]
176 pub fn bit(self, value: bool) -> &'a mut W {
177 self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
178 self.w
179 }
180}
181#[doc = "Reader of field `MISERR`"]
182pub type MISERR_R = crate::R<bool, bool>;
183#[doc = "Write proxy for field `MISERR`"]
184pub struct MISERR_W<'a> {
185 w: &'a mut W,
186}
187impl<'a> MISERR_W<'a> {
188 #[doc = r"Sets the field bit"]
189 #[inline(always)]
190 pub fn set_bit(self) -> &'a mut W {
191 self.bit(true)
192 }
193 #[doc = r"Clears the field bit"]
194 #[inline(always)]
195 pub fn clear_bit(self) -> &'a mut W {
196 self.bit(false)
197 }
198 #[doc = r"Writes raw bits to the field"]
199 #[inline(always)]
200 pub fn bit(self, value: bool) -> &'a mut W {
201 self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
202 self.w
203 }
204}
205#[doc = "Reader of field `FASTERR`"]
206pub type FASTERR_R = crate::R<bool, bool>;
207#[doc = "Write proxy for field `FASTERR`"]
208pub struct FASTERR_W<'a> {
209 w: &'a mut W,
210}
211impl<'a> FASTERR_W<'a> {
212 #[doc = r"Sets the field bit"]
213 #[inline(always)]
214 pub fn set_bit(self) -> &'a mut W {
215 self.bit(true)
216 }
217 #[doc = r"Clears the field bit"]
218 #[inline(always)]
219 pub fn clear_bit(self) -> &'a mut W {
220 self.bit(false)
221 }
222 #[doc = r"Writes raw bits to the field"]
223 #[inline(always)]
224 pub fn bit(self, value: bool) -> &'a mut W {
225 self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
226 self.w
227 }
228}
229#[doc = "Reader of field `OPTNV`"]
230pub type OPTNV_R = crate::R<bool, bool>;
231#[doc = "Reader of field `RDERR`"]
232pub type RDERR_R = crate::R<bool, bool>;
233#[doc = "Write proxy for field `RDERR`"]
234pub struct RDERR_W<'a> {
235 w: &'a mut W,
236}
237impl<'a> RDERR_W<'a> {
238 #[doc = r"Sets the field bit"]
239 #[inline(always)]
240 pub fn set_bit(self) -> &'a mut W {
241 self.bit(true)
242 }
243 #[doc = r"Clears the field bit"]
244 #[inline(always)]
245 pub fn clear_bit(self) -> &'a mut W {
246 self.bit(false)
247 }
248 #[doc = r"Writes raw bits to the field"]
249 #[inline(always)]
250 pub fn bit(self, value: bool) -> &'a mut W {
251 self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
252 self.w
253 }
254}
255#[doc = "Reader of field `OPTVERR`"]
256pub type OPTVERR_R = crate::R<bool, bool>;
257#[doc = "Write proxy for field `OPTVERR`"]
258pub struct OPTVERR_W<'a> {
259 w: &'a mut W,
260}
261impl<'a> OPTVERR_W<'a> {
262 #[doc = r"Sets the field bit"]
263 #[inline(always)]
264 pub fn set_bit(self) -> &'a mut W {
265 self.bit(true)
266 }
267 #[doc = r"Clears the field bit"]
268 #[inline(always)]
269 pub fn clear_bit(self) -> &'a mut W {
270 self.bit(false)
271 }
272 #[doc = r"Writes raw bits to the field"]
273 #[inline(always)]
274 pub fn bit(self, value: bool) -> &'a mut W {
275 self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
276 self.w
277 }
278}
279#[doc = "Reader of field `BSY`"]
280pub type BSY_R = crate::R<bool, bool>;
281#[doc = "Reader of field `CFGBSY`"]
282pub type CFGBSY_R = crate::R<bool, bool>;
283#[doc = "Reader of field `PESD`"]
284pub type PESD_R = crate::R<bool, bool>;
285impl R {
286 #[doc = "Bit 0 - End of operation"]
287 #[inline(always)]
288 pub fn eop(&self) -> EOP_R {
289 EOP_R::new((self.bits & 0x01) != 0)
290 }
291 #[doc = "Bit 1 - Operation error"]
292 #[inline(always)]
293 pub fn operr(&self) -> OPERR_R {
294 OPERR_R::new(((self.bits >> 1) & 0x01) != 0)
295 }
296 #[doc = "Bit 3 - Programming error"]
297 #[inline(always)]
298 pub fn progerr(&self) -> PROGERR_R {
299 PROGERR_R::new(((self.bits >> 3) & 0x01) != 0)
300 }
301 #[doc = "Bit 4 - Write protected error"]
302 #[inline(always)]
303 pub fn wrperr(&self) -> WRPERR_R {
304 WRPERR_R::new(((self.bits >> 4) & 0x01) != 0)
305 }
306 #[doc = "Bit 5 - Programming alignment error"]
307 #[inline(always)]
308 pub fn pgaerr(&self) -> PGAERR_R {
309 PGAERR_R::new(((self.bits >> 5) & 0x01) != 0)
310 }
311 #[doc = "Bit 6 - Size error"]
312 #[inline(always)]
313 pub fn sizerr(&self) -> SIZERR_R {
314 SIZERR_R::new(((self.bits >> 6) & 0x01) != 0)
315 }
316 #[doc = "Bit 7 - Programming sequence error"]
317 #[inline(always)]
318 pub fn pgserr(&self) -> PGSERR_R {
319 PGSERR_R::new(((self.bits >> 7) & 0x01) != 0)
320 }
321 #[doc = "Bit 8 - Fast programming data miss error"]
322 #[inline(always)]
323 pub fn miserr(&self) -> MISERR_R {
324 MISERR_R::new(((self.bits >> 8) & 0x01) != 0)
325 }
326 #[doc = "Bit 9 - Fast programming error"]
327 #[inline(always)]
328 pub fn fasterr(&self) -> FASTERR_R {
329 FASTERR_R::new(((self.bits >> 9) & 0x01) != 0)
330 }
331 #[doc = "Bit 13 - User Option OPTVAL indication"]
332 #[inline(always)]
333 pub fn optnv(&self) -> OPTNV_R {
334 OPTNV_R::new(((self.bits >> 13) & 0x01) != 0)
335 }
336 #[doc = "Bit 14 - PCROP read error"]
337 #[inline(always)]
338 pub fn rderr(&self) -> RDERR_R {
339 RDERR_R::new(((self.bits >> 14) & 0x01) != 0)
340 }
341 #[doc = "Bit 15 - Option validity error"]
342 #[inline(always)]
343 pub fn optverr(&self) -> OPTVERR_R {
344 OPTVERR_R::new(((self.bits >> 15) & 0x01) != 0)
345 }
346 #[doc = "Bit 16 - Busy"]
347 #[inline(always)]
348 pub fn bsy(&self) -> BSY_R {
349 BSY_R::new(((self.bits >> 16) & 0x01) != 0)
350 }
351 #[doc = "Bit 18 - Programming or erase configuration busy"]
352 #[inline(always)]
353 pub fn cfgbsy(&self) -> CFGBSY_R {
354 CFGBSY_R::new(((self.bits >> 18) & 0x01) != 0)
355 }
356 #[doc = "Bit 19 - Programming or erase operation suspended"]
357 #[inline(always)]
358 pub fn pesd(&self) -> PESD_R {
359 PESD_R::new(((self.bits >> 19) & 0x01) != 0)
360 }
361}
362impl W {
363 #[doc = "Bit 0 - End of operation"]
364 #[inline(always)]
365 pub fn eop(&mut self) -> EOP_W {
366 EOP_W { w: self }
367 }
368 #[doc = "Bit 1 - Operation error"]
369 #[inline(always)]
370 pub fn operr(&mut self) -> OPERR_W {
371 OPERR_W { w: self }
372 }
373 #[doc = "Bit 3 - Programming error"]
374 #[inline(always)]
375 pub fn progerr(&mut self) -> PROGERR_W {
376 PROGERR_W { w: self }
377 }
378 #[doc = "Bit 4 - Write protected error"]
379 #[inline(always)]
380 pub fn wrperr(&mut self) -> WRPERR_W {
381 WRPERR_W { w: self }
382 }
383 #[doc = "Bit 5 - Programming alignment error"]
384 #[inline(always)]
385 pub fn pgaerr(&mut self) -> PGAERR_W {
386 PGAERR_W { w: self }
387 }
388 #[doc = "Bit 6 - Size error"]
389 #[inline(always)]
390 pub fn sizerr(&mut self) -> SIZERR_W {
391 SIZERR_W { w: self }
392 }
393 #[doc = "Bit 7 - Programming sequence error"]
394 #[inline(always)]
395 pub fn pgserr(&mut self) -> PGSERR_W {
396 PGSERR_W { w: self }
397 }
398 #[doc = "Bit 8 - Fast programming data miss error"]
399 #[inline(always)]
400 pub fn miserr(&mut self) -> MISERR_W {
401 MISERR_W { w: self }
402 }
403 #[doc = "Bit 9 - Fast programming error"]
404 #[inline(always)]
405 pub fn fasterr(&mut self) -> FASTERR_W {
406 FASTERR_W { w: self }
407 }
408 #[doc = "Bit 14 - PCROP read error"]
409 #[inline(always)]
410 pub fn rderr(&mut self) -> RDERR_W {
411 RDERR_W { w: self }
412 }
413 #[doc = "Bit 15 - Option validity error"]
414 #[inline(always)]
415 pub fn optverr(&mut self) -> OPTVERR_W {
416 OPTVERR_W { w: self }
417 }
418}