1#[doc = "Register `SERRWARN` reader"]
2pub type R = crate::R<SerrwarnSpec>;
3#[doc = "Register `SERRWARN` writer"]
4pub type W = crate::W<SerrwarnSpec>;
5#[doc = "Overrun Error Flag\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Orun {
9 #[doc = "0: No overrun error"]
10 NoError = 0,
11 #[doc = "1: Overrun error"]
12 Error = 1,
13}
14impl From<Orun> for bool {
15 #[inline(always)]
16 fn from(variant: Orun) -> Self {
17 variant as u8 != 0
18 }
19}
20#[doc = "Field `ORUN` reader - Overrun Error Flag"]
21pub type OrunR = crate::BitReader<Orun>;
22impl OrunR {
23 #[doc = "Get enumerated values variant"]
24 #[inline(always)]
25 pub const fn variant(&self) -> Orun {
26 match self.bits {
27 false => Orun::NoError,
28 true => Orun::Error,
29 }
30 }
31 #[doc = "No overrun error"]
32 #[inline(always)]
33 pub fn is_no_error(&self) -> bool {
34 *self == Orun::NoError
35 }
36 #[doc = "Overrun error"]
37 #[inline(always)]
38 pub fn is_error(&self) -> bool {
39 *self == Orun::Error
40 }
41}
42#[doc = "Field `ORUN` writer - Overrun Error Flag"]
43pub type OrunW<'a, REG> = crate::BitWriter1C<'a, REG, Orun>;
44impl<'a, REG> OrunW<'a, REG>
45where
46 REG: crate::Writable + crate::RegisterSpec,
47{
48 #[doc = "No overrun error"]
49 #[inline(always)]
50 pub fn no_error(self) -> &'a mut crate::W<REG> {
51 self.variant(Orun::NoError)
52 }
53 #[doc = "Overrun error"]
54 #[inline(always)]
55 pub fn error(self) -> &'a mut crate::W<REG> {
56 self.variant(Orun::Error)
57 }
58}
59#[doc = "Underrun Error Flag\n\nValue on reset: 0"]
60#[cfg_attr(feature = "defmt", derive(defmt::Format))]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum Urun {
63 #[doc = "0: No underrun error"]
64 NoError = 0,
65 #[doc = "1: Underrun error"]
66 Error = 1,
67}
68impl From<Urun> for bool {
69 #[inline(always)]
70 fn from(variant: Urun) -> Self {
71 variant as u8 != 0
72 }
73}
74#[doc = "Field `URUN` reader - Underrun Error Flag"]
75pub type UrunR = crate::BitReader<Urun>;
76impl UrunR {
77 #[doc = "Get enumerated values variant"]
78 #[inline(always)]
79 pub const fn variant(&self) -> Urun {
80 match self.bits {
81 false => Urun::NoError,
82 true => Urun::Error,
83 }
84 }
85 #[doc = "No underrun error"]
86 #[inline(always)]
87 pub fn is_no_error(&self) -> bool {
88 *self == Urun::NoError
89 }
90 #[doc = "Underrun error"]
91 #[inline(always)]
92 pub fn is_error(&self) -> bool {
93 *self == Urun::Error
94 }
95}
96#[doc = "Field `URUN` writer - Underrun Error Flag"]
97pub type UrunW<'a, REG> = crate::BitWriter1C<'a, REG, Urun>;
98impl<'a, REG> UrunW<'a, REG>
99where
100 REG: crate::Writable + crate::RegisterSpec,
101{
102 #[doc = "No underrun error"]
103 #[inline(always)]
104 pub fn no_error(self) -> &'a mut crate::W<REG> {
105 self.variant(Urun::NoError)
106 }
107 #[doc = "Underrun error"]
108 #[inline(always)]
109 pub fn error(self) -> &'a mut crate::W<REG> {
110 self.variant(Urun::Error)
111 }
112}
113#[doc = "Underrun and Not Acknowledged (NACKed) Error Flag\n\nValue on reset: 0"]
114#[cfg_attr(feature = "defmt", derive(defmt::Format))]
115#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum Urunnack {
117 #[doc = "0: No underrun; not acknowledged error"]
118 NoError = 0,
119 #[doc = "1: Underrun; not acknowledged error"]
120 Error = 1,
121}
122impl From<Urunnack> for bool {
123 #[inline(always)]
124 fn from(variant: Urunnack) -> Self {
125 variant as u8 != 0
126 }
127}
128#[doc = "Field `URUNNACK` reader - Underrun and Not Acknowledged (NACKed) Error Flag"]
129pub type UrunnackR = crate::BitReader<Urunnack>;
130impl UrunnackR {
131 #[doc = "Get enumerated values variant"]
132 #[inline(always)]
133 pub const fn variant(&self) -> Urunnack {
134 match self.bits {
135 false => Urunnack::NoError,
136 true => Urunnack::Error,
137 }
138 }
139 #[doc = "No underrun; not acknowledged error"]
140 #[inline(always)]
141 pub fn is_no_error(&self) -> bool {
142 *self == Urunnack::NoError
143 }
144 #[doc = "Underrun; not acknowledged error"]
145 #[inline(always)]
146 pub fn is_error(&self) -> bool {
147 *self == Urunnack::Error
148 }
149}
150#[doc = "Field `URUNNACK` writer - Underrun and Not Acknowledged (NACKed) Error Flag"]
151pub type UrunnackW<'a, REG> = crate::BitWriter1C<'a, REG, Urunnack>;
152impl<'a, REG> UrunnackW<'a, REG>
153where
154 REG: crate::Writable + crate::RegisterSpec,
155{
156 #[doc = "No underrun; not acknowledged error"]
157 #[inline(always)]
158 pub fn no_error(self) -> &'a mut crate::W<REG> {
159 self.variant(Urunnack::NoError)
160 }
161 #[doc = "Underrun; not acknowledged error"]
162 #[inline(always)]
163 pub fn error(self) -> &'a mut crate::W<REG> {
164 self.variant(Urunnack::Error)
165 }
166}
167#[doc = "Terminated Error Flag\n\nValue on reset: 0"]
168#[cfg_attr(feature = "defmt", derive(defmt::Format))]
169#[derive(Clone, Copy, Debug, PartialEq, Eq)]
170pub enum Term {
171 #[doc = "0: No terminated error"]
172 NoError = 0,
173 #[doc = "1: Terminated error"]
174 Error = 1,
175}
176impl From<Term> for bool {
177 #[inline(always)]
178 fn from(variant: Term) -> Self {
179 variant as u8 != 0
180 }
181}
182#[doc = "Field `TERM` reader - Terminated Error Flag"]
183pub type TermR = crate::BitReader<Term>;
184impl TermR {
185 #[doc = "Get enumerated values variant"]
186 #[inline(always)]
187 pub const fn variant(&self) -> Term {
188 match self.bits {
189 false => Term::NoError,
190 true => Term::Error,
191 }
192 }
193 #[doc = "No terminated error"]
194 #[inline(always)]
195 pub fn is_no_error(&self) -> bool {
196 *self == Term::NoError
197 }
198 #[doc = "Terminated error"]
199 #[inline(always)]
200 pub fn is_error(&self) -> bool {
201 *self == Term::Error
202 }
203}
204#[doc = "Field `TERM` writer - Terminated Error Flag"]
205pub type TermW<'a, REG> = crate::BitWriter1C<'a, REG, Term>;
206impl<'a, REG> TermW<'a, REG>
207where
208 REG: crate::Writable + crate::RegisterSpec,
209{
210 #[doc = "No terminated error"]
211 #[inline(always)]
212 pub fn no_error(self) -> &'a mut crate::W<REG> {
213 self.variant(Term::NoError)
214 }
215 #[doc = "Terminated error"]
216 #[inline(always)]
217 pub fn error(self) -> &'a mut crate::W<REG> {
218 self.variant(Term::Error)
219 }
220}
221#[doc = "Invalid Start Error Flag\n\nValue on reset: 0"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum Invstart {
225 #[doc = "0: No invalid start error"]
226 NoError = 0,
227 #[doc = "1: Invalid start error"]
228 Error = 1,
229}
230impl From<Invstart> for bool {
231 #[inline(always)]
232 fn from(variant: Invstart) -> Self {
233 variant as u8 != 0
234 }
235}
236#[doc = "Field `INVSTART` reader - Invalid Start Error Flag"]
237pub type InvstartR = crate::BitReader<Invstart>;
238impl InvstartR {
239 #[doc = "Get enumerated values variant"]
240 #[inline(always)]
241 pub const fn variant(&self) -> Invstart {
242 match self.bits {
243 false => Invstart::NoError,
244 true => Invstart::Error,
245 }
246 }
247 #[doc = "No invalid start error"]
248 #[inline(always)]
249 pub fn is_no_error(&self) -> bool {
250 *self == Invstart::NoError
251 }
252 #[doc = "Invalid start error"]
253 #[inline(always)]
254 pub fn is_error(&self) -> bool {
255 *self == Invstart::Error
256 }
257}
258#[doc = "Field `INVSTART` writer - Invalid Start Error Flag"]
259pub type InvstartW<'a, REG> = crate::BitWriter1C<'a, REG, Invstart>;
260impl<'a, REG> InvstartW<'a, REG>
261where
262 REG: crate::Writable + crate::RegisterSpec,
263{
264 #[doc = "No invalid start error"]
265 #[inline(always)]
266 pub fn no_error(self) -> &'a mut crate::W<REG> {
267 self.variant(Invstart::NoError)
268 }
269 #[doc = "Invalid start error"]
270 #[inline(always)]
271 pub fn error(self) -> &'a mut crate::W<REG> {
272 self.variant(Invstart::Error)
273 }
274}
275#[doc = "SDR Parity Error Flag\n\nValue on reset: 0"]
276#[cfg_attr(feature = "defmt", derive(defmt::Format))]
277#[derive(Clone, Copy, Debug, PartialEq, Eq)]
278pub enum Spar {
279 #[doc = "0: No SDR parity error"]
280 NoError = 0,
281 #[doc = "1: SDR parity error"]
282 Error = 1,
283}
284impl From<Spar> for bool {
285 #[inline(always)]
286 fn from(variant: Spar) -> Self {
287 variant as u8 != 0
288 }
289}
290#[doc = "Field `SPAR` reader - SDR Parity Error Flag"]
291pub type SparR = crate::BitReader<Spar>;
292impl SparR {
293 #[doc = "Get enumerated values variant"]
294 #[inline(always)]
295 pub const fn variant(&self) -> Spar {
296 match self.bits {
297 false => Spar::NoError,
298 true => Spar::Error,
299 }
300 }
301 #[doc = "No SDR parity error"]
302 #[inline(always)]
303 pub fn is_no_error(&self) -> bool {
304 *self == Spar::NoError
305 }
306 #[doc = "SDR parity error"]
307 #[inline(always)]
308 pub fn is_error(&self) -> bool {
309 *self == Spar::Error
310 }
311}
312#[doc = "Field `SPAR` writer - SDR Parity Error Flag"]
313pub type SparW<'a, REG> = crate::BitWriter1C<'a, REG, Spar>;
314impl<'a, REG> SparW<'a, REG>
315where
316 REG: crate::Writable + crate::RegisterSpec,
317{
318 #[doc = "No SDR parity error"]
319 #[inline(always)]
320 pub fn no_error(self) -> &'a mut crate::W<REG> {
321 self.variant(Spar::NoError)
322 }
323 #[doc = "SDR parity error"]
324 #[inline(always)]
325 pub fn error(self) -> &'a mut crate::W<REG> {
326 self.variant(Spar::Error)
327 }
328}
329#[doc = "HDR Parity Error Flag\n\nValue on reset: 0"]
330#[cfg_attr(feature = "defmt", derive(defmt::Format))]
331#[derive(Clone, Copy, Debug, PartialEq, Eq)]
332pub enum Hpar {
333 #[doc = "0: No HDR parity error"]
334 NoError = 0,
335 #[doc = "1: HDR parity error"]
336 Error = 1,
337}
338impl From<Hpar> for bool {
339 #[inline(always)]
340 fn from(variant: Hpar) -> Self {
341 variant as u8 != 0
342 }
343}
344#[doc = "Field `HPAR` reader - HDR Parity Error Flag"]
345pub type HparR = crate::BitReader<Hpar>;
346impl HparR {
347 #[doc = "Get enumerated values variant"]
348 #[inline(always)]
349 pub const fn variant(&self) -> Hpar {
350 match self.bits {
351 false => Hpar::NoError,
352 true => Hpar::Error,
353 }
354 }
355 #[doc = "No HDR parity error"]
356 #[inline(always)]
357 pub fn is_no_error(&self) -> bool {
358 *self == Hpar::NoError
359 }
360 #[doc = "HDR parity error"]
361 #[inline(always)]
362 pub fn is_error(&self) -> bool {
363 *self == Hpar::Error
364 }
365}
366#[doc = "Field `HPAR` writer - HDR Parity Error Flag"]
367pub type HparW<'a, REG> = crate::BitWriter1C<'a, REG, Hpar>;
368impl<'a, REG> HparW<'a, REG>
369where
370 REG: crate::Writable + crate::RegisterSpec,
371{
372 #[doc = "No HDR parity error"]
373 #[inline(always)]
374 pub fn no_error(self) -> &'a mut crate::W<REG> {
375 self.variant(Hpar::NoError)
376 }
377 #[doc = "HDR parity error"]
378 #[inline(always)]
379 pub fn error(self) -> &'a mut crate::W<REG> {
380 self.variant(Hpar::Error)
381 }
382}
383#[doc = "HDR-DDR CRC Error Flag\n\nValue on reset: 0"]
384#[cfg_attr(feature = "defmt", derive(defmt::Format))]
385#[derive(Clone, Copy, Debug, PartialEq, Eq)]
386pub enum Hcrc {
387 #[doc = "0: No HDR-DDR CRC error occurred"]
388 NoError = 0,
389 #[doc = "1: HDR-DDR CRC error occurred"]
390 Error = 1,
391}
392impl From<Hcrc> for bool {
393 #[inline(always)]
394 fn from(variant: Hcrc) -> Self {
395 variant as u8 != 0
396 }
397}
398#[doc = "Field `HCRC` reader - HDR-DDR CRC Error Flag"]
399pub type HcrcR = crate::BitReader<Hcrc>;
400impl HcrcR {
401 #[doc = "Get enumerated values variant"]
402 #[inline(always)]
403 pub const fn variant(&self) -> Hcrc {
404 match self.bits {
405 false => Hcrc::NoError,
406 true => Hcrc::Error,
407 }
408 }
409 #[doc = "No HDR-DDR CRC error occurred"]
410 #[inline(always)]
411 pub fn is_no_error(&self) -> bool {
412 *self == Hcrc::NoError
413 }
414 #[doc = "HDR-DDR CRC error occurred"]
415 #[inline(always)]
416 pub fn is_error(&self) -> bool {
417 *self == Hcrc::Error
418 }
419}
420#[doc = "Field `HCRC` writer - HDR-DDR CRC Error Flag"]
421pub type HcrcW<'a, REG> = crate::BitWriter1C<'a, REG, Hcrc>;
422impl<'a, REG> HcrcW<'a, REG>
423where
424 REG: crate::Writable + crate::RegisterSpec,
425{
426 #[doc = "No HDR-DDR CRC error occurred"]
427 #[inline(always)]
428 pub fn no_error(self) -> &'a mut crate::W<REG> {
429 self.variant(Hcrc::NoError)
430 }
431 #[doc = "HDR-DDR CRC error occurred"]
432 #[inline(always)]
433 pub fn error(self) -> &'a mut crate::W<REG> {
434 self.variant(Hcrc::Error)
435 }
436}
437#[doc = "TE0 or TE1 Error Flag\n\nValue on reset: 0"]
438#[cfg_attr(feature = "defmt", derive(defmt::Format))]
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
440pub enum S0s1 {
441 #[doc = "0: No TE0 or TE1 error occurred"]
442 NoError = 0,
443 #[doc = "1: TE0 or TE1 error occurred"]
444 Error = 1,
445}
446impl From<S0s1> for bool {
447 #[inline(always)]
448 fn from(variant: S0s1) -> Self {
449 variant as u8 != 0
450 }
451}
452#[doc = "Field `S0S1` reader - TE0 or TE1 Error Flag"]
453pub type S0s1R = crate::BitReader<S0s1>;
454impl S0s1R {
455 #[doc = "Get enumerated values variant"]
456 #[inline(always)]
457 pub const fn variant(&self) -> S0s1 {
458 match self.bits {
459 false => S0s1::NoError,
460 true => S0s1::Error,
461 }
462 }
463 #[doc = "No TE0 or TE1 error occurred"]
464 #[inline(always)]
465 pub fn is_no_error(&self) -> bool {
466 *self == S0s1::NoError
467 }
468 #[doc = "TE0 or TE1 error occurred"]
469 #[inline(always)]
470 pub fn is_error(&self) -> bool {
471 *self == S0s1::Error
472 }
473}
474#[doc = "Field `S0S1` writer - TE0 or TE1 Error Flag"]
475pub type S0s1W<'a, REG> = crate::BitWriter1C<'a, REG, S0s1>;
476impl<'a, REG> S0s1W<'a, REG>
477where
478 REG: crate::Writable + crate::RegisterSpec,
479{
480 #[doc = "No TE0 or TE1 error occurred"]
481 #[inline(always)]
482 pub fn no_error(self) -> &'a mut crate::W<REG> {
483 self.variant(S0s1::NoError)
484 }
485 #[doc = "TE0 or TE1 error occurred"]
486 #[inline(always)]
487 pub fn error(self) -> &'a mut crate::W<REG> {
488 self.variant(S0s1::Error)
489 }
490}
491#[doc = "Over-Read Error Flag\n\nValue on reset: 0"]
492#[cfg_attr(feature = "defmt", derive(defmt::Format))]
493#[derive(Clone, Copy, Debug, PartialEq, Eq)]
494pub enum Oread {
495 #[doc = "0: No over-read error"]
496 NoError = 0,
497 #[doc = "1: Over-read error"]
498 Error = 1,
499}
500impl From<Oread> for bool {
501 #[inline(always)]
502 fn from(variant: Oread) -> Self {
503 variant as u8 != 0
504 }
505}
506#[doc = "Field `OREAD` reader - Over-Read Error Flag"]
507pub type OreadR = crate::BitReader<Oread>;
508impl OreadR {
509 #[doc = "Get enumerated values variant"]
510 #[inline(always)]
511 pub const fn variant(&self) -> Oread {
512 match self.bits {
513 false => Oread::NoError,
514 true => Oread::Error,
515 }
516 }
517 #[doc = "No over-read error"]
518 #[inline(always)]
519 pub fn is_no_error(&self) -> bool {
520 *self == Oread::NoError
521 }
522 #[doc = "Over-read error"]
523 #[inline(always)]
524 pub fn is_error(&self) -> bool {
525 *self == Oread::Error
526 }
527}
528#[doc = "Field `OREAD` writer - Over-Read Error Flag"]
529pub type OreadW<'a, REG> = crate::BitWriter1C<'a, REG, Oread>;
530impl<'a, REG> OreadW<'a, REG>
531where
532 REG: crate::Writable + crate::RegisterSpec,
533{
534 #[doc = "No over-read error"]
535 #[inline(always)]
536 pub fn no_error(self) -> &'a mut crate::W<REG> {
537 self.variant(Oread::NoError)
538 }
539 #[doc = "Over-read error"]
540 #[inline(always)]
541 pub fn error(self) -> &'a mut crate::W<REG> {
542 self.variant(Oread::Error)
543 }
544}
545#[doc = "Over-Write Error Flag\n\nValue on reset: 0"]
546#[cfg_attr(feature = "defmt", derive(defmt::Format))]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548pub enum Owrite {
549 #[doc = "0: No overwrite error"]
550 NoError = 0,
551 #[doc = "1: Overwrite error"]
552 Error = 1,
553}
554impl From<Owrite> for bool {
555 #[inline(always)]
556 fn from(variant: Owrite) -> Self {
557 variant as u8 != 0
558 }
559}
560#[doc = "Field `OWRITE` reader - Over-Write Error Flag"]
561pub type OwriteR = crate::BitReader<Owrite>;
562impl OwriteR {
563 #[doc = "Get enumerated values variant"]
564 #[inline(always)]
565 pub const fn variant(&self) -> Owrite {
566 match self.bits {
567 false => Owrite::NoError,
568 true => Owrite::Error,
569 }
570 }
571 #[doc = "No overwrite error"]
572 #[inline(always)]
573 pub fn is_no_error(&self) -> bool {
574 *self == Owrite::NoError
575 }
576 #[doc = "Overwrite error"]
577 #[inline(always)]
578 pub fn is_error(&self) -> bool {
579 *self == Owrite::Error
580 }
581}
582#[doc = "Field `OWRITE` writer - Over-Write Error Flag"]
583pub type OwriteW<'a, REG> = crate::BitWriter1C<'a, REG, Owrite>;
584impl<'a, REG> OwriteW<'a, REG>
585where
586 REG: crate::Writable + crate::RegisterSpec,
587{
588 #[doc = "No overwrite error"]
589 #[inline(always)]
590 pub fn no_error(self) -> &'a mut crate::W<REG> {
591 self.variant(Owrite::NoError)
592 }
593 #[doc = "Overwrite error"]
594 #[inline(always)]
595 pub fn error(self) -> &'a mut crate::W<REG> {
596 self.variant(Owrite::Error)
597 }
598}
599impl R {
600 #[doc = "Bit 0 - Overrun Error Flag"]
601 #[inline(always)]
602 pub fn orun(&self) -> OrunR {
603 OrunR::new((self.bits & 1) != 0)
604 }
605 #[doc = "Bit 1 - Underrun Error Flag"]
606 #[inline(always)]
607 pub fn urun(&self) -> UrunR {
608 UrunR::new(((self.bits >> 1) & 1) != 0)
609 }
610 #[doc = "Bit 2 - Underrun and Not Acknowledged (NACKed) Error Flag"]
611 #[inline(always)]
612 pub fn urunnack(&self) -> UrunnackR {
613 UrunnackR::new(((self.bits >> 2) & 1) != 0)
614 }
615 #[doc = "Bit 3 - Terminated Error Flag"]
616 #[inline(always)]
617 pub fn term(&self) -> TermR {
618 TermR::new(((self.bits >> 3) & 1) != 0)
619 }
620 #[doc = "Bit 4 - Invalid Start Error Flag"]
621 #[inline(always)]
622 pub fn invstart(&self) -> InvstartR {
623 InvstartR::new(((self.bits >> 4) & 1) != 0)
624 }
625 #[doc = "Bit 8 - SDR Parity Error Flag"]
626 #[inline(always)]
627 pub fn spar(&self) -> SparR {
628 SparR::new(((self.bits >> 8) & 1) != 0)
629 }
630 #[doc = "Bit 9 - HDR Parity Error Flag"]
631 #[inline(always)]
632 pub fn hpar(&self) -> HparR {
633 HparR::new(((self.bits >> 9) & 1) != 0)
634 }
635 #[doc = "Bit 10 - HDR-DDR CRC Error Flag"]
636 #[inline(always)]
637 pub fn hcrc(&self) -> HcrcR {
638 HcrcR::new(((self.bits >> 10) & 1) != 0)
639 }
640 #[doc = "Bit 11 - TE0 or TE1 Error Flag"]
641 #[inline(always)]
642 pub fn s0s1(&self) -> S0s1R {
643 S0s1R::new(((self.bits >> 11) & 1) != 0)
644 }
645 #[doc = "Bit 16 - Over-Read Error Flag"]
646 #[inline(always)]
647 pub fn oread(&self) -> OreadR {
648 OreadR::new(((self.bits >> 16) & 1) != 0)
649 }
650 #[doc = "Bit 17 - Over-Write Error Flag"]
651 #[inline(always)]
652 pub fn owrite(&self) -> OwriteR {
653 OwriteR::new(((self.bits >> 17) & 1) != 0)
654 }
655}
656#[cfg(feature = "debug")]
657impl core::fmt::Debug for R {
658 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
659 f.debug_struct("SERRWARN")
660 .field("orun", &self.orun())
661 .field("urun", &self.urun())
662 .field("urunnack", &self.urunnack())
663 .field("term", &self.term())
664 .field("invstart", &self.invstart())
665 .field("spar", &self.spar())
666 .field("hpar", &self.hpar())
667 .field("hcrc", &self.hcrc())
668 .field("s0s1", &self.s0s1())
669 .field("oread", &self.oread())
670 .field("owrite", &self.owrite())
671 .finish()
672 }
673}
674impl W {
675 #[doc = "Bit 0 - Overrun Error Flag"]
676 #[inline(always)]
677 pub fn orun(&mut self) -> OrunW<'_, SerrwarnSpec> {
678 OrunW::new(self, 0)
679 }
680 #[doc = "Bit 1 - Underrun Error Flag"]
681 #[inline(always)]
682 pub fn urun(&mut self) -> UrunW<'_, SerrwarnSpec> {
683 UrunW::new(self, 1)
684 }
685 #[doc = "Bit 2 - Underrun and Not Acknowledged (NACKed) Error Flag"]
686 #[inline(always)]
687 pub fn urunnack(&mut self) -> UrunnackW<'_, SerrwarnSpec> {
688 UrunnackW::new(self, 2)
689 }
690 #[doc = "Bit 3 - Terminated Error Flag"]
691 #[inline(always)]
692 pub fn term(&mut self) -> TermW<'_, SerrwarnSpec> {
693 TermW::new(self, 3)
694 }
695 #[doc = "Bit 4 - Invalid Start Error Flag"]
696 #[inline(always)]
697 pub fn invstart(&mut self) -> InvstartW<'_, SerrwarnSpec> {
698 InvstartW::new(self, 4)
699 }
700 #[doc = "Bit 8 - SDR Parity Error Flag"]
701 #[inline(always)]
702 pub fn spar(&mut self) -> SparW<'_, SerrwarnSpec> {
703 SparW::new(self, 8)
704 }
705 #[doc = "Bit 9 - HDR Parity Error Flag"]
706 #[inline(always)]
707 pub fn hpar(&mut self) -> HparW<'_, SerrwarnSpec> {
708 HparW::new(self, 9)
709 }
710 #[doc = "Bit 10 - HDR-DDR CRC Error Flag"]
711 #[inline(always)]
712 pub fn hcrc(&mut self) -> HcrcW<'_, SerrwarnSpec> {
713 HcrcW::new(self, 10)
714 }
715 #[doc = "Bit 11 - TE0 or TE1 Error Flag"]
716 #[inline(always)]
717 pub fn s0s1(&mut self) -> S0s1W<'_, SerrwarnSpec> {
718 S0s1W::new(self, 11)
719 }
720 #[doc = "Bit 16 - Over-Read Error Flag"]
721 #[inline(always)]
722 pub fn oread(&mut self) -> OreadW<'_, SerrwarnSpec> {
723 OreadW::new(self, 16)
724 }
725 #[doc = "Bit 17 - Over-Write Error Flag"]
726 #[inline(always)]
727 pub fn owrite(&mut self) -> OwriteW<'_, SerrwarnSpec> {
728 OwriteW::new(self, 17)
729 }
730}
731#[doc = "Target Errors and Warnings\n\nYou can [`read`](crate::Reg::read) this register and get [`serrwarn::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`serrwarn::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
732pub struct SerrwarnSpec;
733impl crate::RegisterSpec for SerrwarnSpec {
734 type Ux = u32;
735}
736#[doc = "`read()` method returns [`serrwarn::R`](R) reader structure"]
737impl crate::Readable for SerrwarnSpec {}
738#[doc = "`write(|w| ..)` method takes [`serrwarn::W`](W) writer structure"]
739impl crate::Writable for SerrwarnSpec {
740 type Safety = crate::Unsafe;
741 const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0x0003_0f1f;
742}
743#[doc = "`reset()` method sets SERRWARN to value 0"]
744impl crate::Resettable for SerrwarnSpec {}