1#[doc = r" Value read from the register"]
2pub struct R {
3 bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7 bits: u32,
8}
9impl super::CR3 {
10 #[doc = r" Modifies the contents of the register"]
11 #[inline]
12 pub fn modify<F>(&self, f: F)
13 where
14 for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15 {
16 let bits = self.register.get();
17 let r = R { bits: bits };
18 let mut w = W { bits: bits };
19 f(&r, &mut w);
20 self.register.set(w.bits);
21 }
22 #[doc = r" Reads the contents of the register"]
23 #[inline]
24 pub fn read(&self) -> R {
25 R {
26 bits: self.register.get(),
27 }
28 }
29 #[doc = r" Writes to the register"]
30 #[inline]
31 pub fn write<F>(&self, f: F)
32 where
33 F: FnOnce(&mut W) -> &mut W,
34 {
35 let mut w = W::reset_value();
36 f(&mut w);
37 self.register.set(w.bits);
38 }
39 #[doc = r" Writes the reset value to the register"]
40 #[inline]
41 pub fn reset(&self) {
42 self.write(|w| w)
43 }
44}
45#[doc = r" Value of the field"]
46pub struct ONEBITR {
47 bits: bool,
48}
49impl ONEBITR {
50 #[doc = r" Value of the field as raw bits"]
51 #[inline]
52 pub fn bit(&self) -> bool {
53 self.bits
54 }
55 #[doc = r" Returns `true` if the bit is clear (0)"]
56 #[inline]
57 pub fn bit_is_clear(&self) -> bool {
58 !self.bit()
59 }
60 #[doc = r" Returns `true` if the bit is set (1)"]
61 #[inline]
62 pub fn bit_is_set(&self) -> bool {
63 self.bit()
64 }
65}
66#[doc = r" Value of the field"]
67pub struct CTSIER {
68 bits: bool,
69}
70impl CTSIER {
71 #[doc = r" Value of the field as raw bits"]
72 #[inline]
73 pub fn bit(&self) -> bool {
74 self.bits
75 }
76 #[doc = r" Returns `true` if the bit is clear (0)"]
77 #[inline]
78 pub fn bit_is_clear(&self) -> bool {
79 !self.bit()
80 }
81 #[doc = r" Returns `true` if the bit is set (1)"]
82 #[inline]
83 pub fn bit_is_set(&self) -> bool {
84 self.bit()
85 }
86}
87#[doc = r" Value of the field"]
88pub struct CTSER {
89 bits: bool,
90}
91impl CTSER {
92 #[doc = r" Value of the field as raw bits"]
93 #[inline]
94 pub fn bit(&self) -> bool {
95 self.bits
96 }
97 #[doc = r" Returns `true` if the bit is clear (0)"]
98 #[inline]
99 pub fn bit_is_clear(&self) -> bool {
100 !self.bit()
101 }
102 #[doc = r" Returns `true` if the bit is set (1)"]
103 #[inline]
104 pub fn bit_is_set(&self) -> bool {
105 self.bit()
106 }
107}
108#[doc = r" Value of the field"]
109pub struct RTSER {
110 bits: bool,
111}
112impl RTSER {
113 #[doc = r" Value of the field as raw bits"]
114 #[inline]
115 pub fn bit(&self) -> bool {
116 self.bits
117 }
118 #[doc = r" Returns `true` if the bit is clear (0)"]
119 #[inline]
120 pub fn bit_is_clear(&self) -> bool {
121 !self.bit()
122 }
123 #[doc = r" Returns `true` if the bit is set (1)"]
124 #[inline]
125 pub fn bit_is_set(&self) -> bool {
126 self.bit()
127 }
128}
129#[doc = r" Value of the field"]
130pub struct DMATR {
131 bits: bool,
132}
133impl DMATR {
134 #[doc = r" Value of the field as raw bits"]
135 #[inline]
136 pub fn bit(&self) -> bool {
137 self.bits
138 }
139 #[doc = r" Returns `true` if the bit is clear (0)"]
140 #[inline]
141 pub fn bit_is_clear(&self) -> bool {
142 !self.bit()
143 }
144 #[doc = r" Returns `true` if the bit is set (1)"]
145 #[inline]
146 pub fn bit_is_set(&self) -> bool {
147 self.bit()
148 }
149}
150#[doc = r" Value of the field"]
151pub struct DMARR {
152 bits: bool,
153}
154impl DMARR {
155 #[doc = r" Value of the field as raw bits"]
156 #[inline]
157 pub fn bit(&self) -> bool {
158 self.bits
159 }
160 #[doc = r" Returns `true` if the bit is clear (0)"]
161 #[inline]
162 pub fn bit_is_clear(&self) -> bool {
163 !self.bit()
164 }
165 #[doc = r" Returns `true` if the bit is set (1)"]
166 #[inline]
167 pub fn bit_is_set(&self) -> bool {
168 self.bit()
169 }
170}
171#[doc = r" Value of the field"]
172pub struct SCENR {
173 bits: bool,
174}
175impl SCENR {
176 #[doc = r" Value of the field as raw bits"]
177 #[inline]
178 pub fn bit(&self) -> bool {
179 self.bits
180 }
181 #[doc = r" Returns `true` if the bit is clear (0)"]
182 #[inline]
183 pub fn bit_is_clear(&self) -> bool {
184 !self.bit()
185 }
186 #[doc = r" Returns `true` if the bit is set (1)"]
187 #[inline]
188 pub fn bit_is_set(&self) -> bool {
189 self.bit()
190 }
191}
192#[doc = r" Value of the field"]
193pub struct NACKR {
194 bits: bool,
195}
196impl NACKR {
197 #[doc = r" Value of the field as raw bits"]
198 #[inline]
199 pub fn bit(&self) -> bool {
200 self.bits
201 }
202 #[doc = r" Returns `true` if the bit is clear (0)"]
203 #[inline]
204 pub fn bit_is_clear(&self) -> bool {
205 !self.bit()
206 }
207 #[doc = r" Returns `true` if the bit is set (1)"]
208 #[inline]
209 pub fn bit_is_set(&self) -> bool {
210 self.bit()
211 }
212}
213#[doc = r" Value of the field"]
214pub struct HDSELR {
215 bits: bool,
216}
217impl HDSELR {
218 #[doc = r" Value of the field as raw bits"]
219 #[inline]
220 pub fn bit(&self) -> bool {
221 self.bits
222 }
223 #[doc = r" Returns `true` if the bit is clear (0)"]
224 #[inline]
225 pub fn bit_is_clear(&self) -> bool {
226 !self.bit()
227 }
228 #[doc = r" Returns `true` if the bit is set (1)"]
229 #[inline]
230 pub fn bit_is_set(&self) -> bool {
231 self.bit()
232 }
233}
234#[doc = r" Value of the field"]
235pub struct IRLPR {
236 bits: bool,
237}
238impl IRLPR {
239 #[doc = r" Value of the field as raw bits"]
240 #[inline]
241 pub fn bit(&self) -> bool {
242 self.bits
243 }
244 #[doc = r" Returns `true` if the bit is clear (0)"]
245 #[inline]
246 pub fn bit_is_clear(&self) -> bool {
247 !self.bit()
248 }
249 #[doc = r" Returns `true` if the bit is set (1)"]
250 #[inline]
251 pub fn bit_is_set(&self) -> bool {
252 self.bit()
253 }
254}
255#[doc = r" Value of the field"]
256pub struct IRENR {
257 bits: bool,
258}
259impl IRENR {
260 #[doc = r" Value of the field as raw bits"]
261 #[inline]
262 pub fn bit(&self) -> bool {
263 self.bits
264 }
265 #[doc = r" Returns `true` if the bit is clear (0)"]
266 #[inline]
267 pub fn bit_is_clear(&self) -> bool {
268 !self.bit()
269 }
270 #[doc = r" Returns `true` if the bit is set (1)"]
271 #[inline]
272 pub fn bit_is_set(&self) -> bool {
273 self.bit()
274 }
275}
276#[doc = r" Value of the field"]
277pub struct EIER {
278 bits: bool,
279}
280impl EIER {
281 #[doc = r" Value of the field as raw bits"]
282 #[inline]
283 pub fn bit(&self) -> bool {
284 self.bits
285 }
286 #[doc = r" Returns `true` if the bit is clear (0)"]
287 #[inline]
288 pub fn bit_is_clear(&self) -> bool {
289 !self.bit()
290 }
291 #[doc = r" Returns `true` if the bit is set (1)"]
292 #[inline]
293 pub fn bit_is_set(&self) -> bool {
294 self.bit()
295 }
296}
297#[doc = r" Proxy"]
298pub struct _ONEBITW<'a> {
299 w: &'a mut W,
300}
301impl<'a> _ONEBITW<'a> {
302 #[doc = r" Sets the field bit"]
303 pub fn set_bit(self) -> &'a mut W {
304 self.bit(true)
305 }
306 #[doc = r" Clears the field bit"]
307 pub fn clear_bit(self) -> &'a mut W {
308 self.bit(false)
309 }
310 #[doc = r" Writes raw bits to the field"]
311 #[inline]
312 pub fn bit(self, value: bool) -> &'a mut W {
313 const MASK: bool = true;
314 const OFFSET: u8 = 11;
315 self.w.bits &= !((MASK as u32) << OFFSET);
316 self.w.bits |= ((value & MASK) as u32) << OFFSET;
317 self.w
318 }
319}
320#[doc = r" Proxy"]
321pub struct _CTSIEW<'a> {
322 w: &'a mut W,
323}
324impl<'a> _CTSIEW<'a> {
325 #[doc = r" Sets the field bit"]
326 pub fn set_bit(self) -> &'a mut W {
327 self.bit(true)
328 }
329 #[doc = r" Clears the field bit"]
330 pub fn clear_bit(self) -> &'a mut W {
331 self.bit(false)
332 }
333 #[doc = r" Writes raw bits to the field"]
334 #[inline]
335 pub fn bit(self, value: bool) -> &'a mut W {
336 const MASK: bool = true;
337 const OFFSET: u8 = 10;
338 self.w.bits &= !((MASK as u32) << OFFSET);
339 self.w.bits |= ((value & MASK) as u32) << OFFSET;
340 self.w
341 }
342}
343#[doc = r" Proxy"]
344pub struct _CTSEW<'a> {
345 w: &'a mut W,
346}
347impl<'a> _CTSEW<'a> {
348 #[doc = r" Sets the field bit"]
349 pub fn set_bit(self) -> &'a mut W {
350 self.bit(true)
351 }
352 #[doc = r" Clears the field bit"]
353 pub fn clear_bit(self) -> &'a mut W {
354 self.bit(false)
355 }
356 #[doc = r" Writes raw bits to the field"]
357 #[inline]
358 pub fn bit(self, value: bool) -> &'a mut W {
359 const MASK: bool = true;
360 const OFFSET: u8 = 9;
361 self.w.bits &= !((MASK as u32) << OFFSET);
362 self.w.bits |= ((value & MASK) as u32) << OFFSET;
363 self.w
364 }
365}
366#[doc = r" Proxy"]
367pub struct _RTSEW<'a> {
368 w: &'a mut W,
369}
370impl<'a> _RTSEW<'a> {
371 #[doc = r" Sets the field bit"]
372 pub fn set_bit(self) -> &'a mut W {
373 self.bit(true)
374 }
375 #[doc = r" Clears the field bit"]
376 pub fn clear_bit(self) -> &'a mut W {
377 self.bit(false)
378 }
379 #[doc = r" Writes raw bits to the field"]
380 #[inline]
381 pub fn bit(self, value: bool) -> &'a mut W {
382 const MASK: bool = true;
383 const OFFSET: u8 = 8;
384 self.w.bits &= !((MASK as u32) << OFFSET);
385 self.w.bits |= ((value & MASK) as u32) << OFFSET;
386 self.w
387 }
388}
389#[doc = r" Proxy"]
390pub struct _DMATW<'a> {
391 w: &'a mut W,
392}
393impl<'a> _DMATW<'a> {
394 #[doc = r" Sets the field bit"]
395 pub fn set_bit(self) -> &'a mut W {
396 self.bit(true)
397 }
398 #[doc = r" Clears the field bit"]
399 pub fn clear_bit(self) -> &'a mut W {
400 self.bit(false)
401 }
402 #[doc = r" Writes raw bits to the field"]
403 #[inline]
404 pub fn bit(self, value: bool) -> &'a mut W {
405 const MASK: bool = true;
406 const OFFSET: u8 = 7;
407 self.w.bits &= !((MASK as u32) << OFFSET);
408 self.w.bits |= ((value & MASK) as u32) << OFFSET;
409 self.w
410 }
411}
412#[doc = r" Proxy"]
413pub struct _DMARW<'a> {
414 w: &'a mut W,
415}
416impl<'a> _DMARW<'a> {
417 #[doc = r" Sets the field bit"]
418 pub fn set_bit(self) -> &'a mut W {
419 self.bit(true)
420 }
421 #[doc = r" Clears the field bit"]
422 pub fn clear_bit(self) -> &'a mut W {
423 self.bit(false)
424 }
425 #[doc = r" Writes raw bits to the field"]
426 #[inline]
427 pub fn bit(self, value: bool) -> &'a mut W {
428 const MASK: bool = true;
429 const OFFSET: u8 = 6;
430 self.w.bits &= !((MASK as u32) << OFFSET);
431 self.w.bits |= ((value & MASK) as u32) << OFFSET;
432 self.w
433 }
434}
435#[doc = r" Proxy"]
436pub struct _SCENW<'a> {
437 w: &'a mut W,
438}
439impl<'a> _SCENW<'a> {
440 #[doc = r" Sets the field bit"]
441 pub fn set_bit(self) -> &'a mut W {
442 self.bit(true)
443 }
444 #[doc = r" Clears the field bit"]
445 pub fn clear_bit(self) -> &'a mut W {
446 self.bit(false)
447 }
448 #[doc = r" Writes raw bits to the field"]
449 #[inline]
450 pub fn bit(self, value: bool) -> &'a mut W {
451 const MASK: bool = true;
452 const OFFSET: u8 = 5;
453 self.w.bits &= !((MASK as u32) << OFFSET);
454 self.w.bits |= ((value & MASK) as u32) << OFFSET;
455 self.w
456 }
457}
458#[doc = r" Proxy"]
459pub struct _NACKW<'a> {
460 w: &'a mut W,
461}
462impl<'a> _NACKW<'a> {
463 #[doc = r" Sets the field bit"]
464 pub fn set_bit(self) -> &'a mut W {
465 self.bit(true)
466 }
467 #[doc = r" Clears the field bit"]
468 pub fn clear_bit(self) -> &'a mut W {
469 self.bit(false)
470 }
471 #[doc = r" Writes raw bits to the field"]
472 #[inline]
473 pub fn bit(self, value: bool) -> &'a mut W {
474 const MASK: bool = true;
475 const OFFSET: u8 = 4;
476 self.w.bits &= !((MASK as u32) << OFFSET);
477 self.w.bits |= ((value & MASK) as u32) << OFFSET;
478 self.w
479 }
480}
481#[doc = r" Proxy"]
482pub struct _HDSELW<'a> {
483 w: &'a mut W,
484}
485impl<'a> _HDSELW<'a> {
486 #[doc = r" Sets the field bit"]
487 pub fn set_bit(self) -> &'a mut W {
488 self.bit(true)
489 }
490 #[doc = r" Clears the field bit"]
491 pub fn clear_bit(self) -> &'a mut W {
492 self.bit(false)
493 }
494 #[doc = r" Writes raw bits to the field"]
495 #[inline]
496 pub fn bit(self, value: bool) -> &'a mut W {
497 const MASK: bool = true;
498 const OFFSET: u8 = 3;
499 self.w.bits &= !((MASK as u32) << OFFSET);
500 self.w.bits |= ((value & MASK) as u32) << OFFSET;
501 self.w
502 }
503}
504#[doc = r" Proxy"]
505pub struct _IRLPW<'a> {
506 w: &'a mut W,
507}
508impl<'a> _IRLPW<'a> {
509 #[doc = r" Sets the field bit"]
510 pub fn set_bit(self) -> &'a mut W {
511 self.bit(true)
512 }
513 #[doc = r" Clears the field bit"]
514 pub fn clear_bit(self) -> &'a mut W {
515 self.bit(false)
516 }
517 #[doc = r" Writes raw bits to the field"]
518 #[inline]
519 pub fn bit(self, value: bool) -> &'a mut W {
520 const MASK: bool = true;
521 const OFFSET: u8 = 2;
522 self.w.bits &= !((MASK as u32) << OFFSET);
523 self.w.bits |= ((value & MASK) as u32) << OFFSET;
524 self.w
525 }
526}
527#[doc = r" Proxy"]
528pub struct _IRENW<'a> {
529 w: &'a mut W,
530}
531impl<'a> _IRENW<'a> {
532 #[doc = r" Sets the field bit"]
533 pub fn set_bit(self) -> &'a mut W {
534 self.bit(true)
535 }
536 #[doc = r" Clears the field bit"]
537 pub fn clear_bit(self) -> &'a mut W {
538 self.bit(false)
539 }
540 #[doc = r" Writes raw bits to the field"]
541 #[inline]
542 pub fn bit(self, value: bool) -> &'a mut W {
543 const MASK: bool = true;
544 const OFFSET: u8 = 1;
545 self.w.bits &= !((MASK as u32) << OFFSET);
546 self.w.bits |= ((value & MASK) as u32) << OFFSET;
547 self.w
548 }
549}
550#[doc = r" Proxy"]
551pub struct _EIEW<'a> {
552 w: &'a mut W,
553}
554impl<'a> _EIEW<'a> {
555 #[doc = r" Sets the field bit"]
556 pub fn set_bit(self) -> &'a mut W {
557 self.bit(true)
558 }
559 #[doc = r" Clears the field bit"]
560 pub fn clear_bit(self) -> &'a mut W {
561 self.bit(false)
562 }
563 #[doc = r" Writes raw bits to the field"]
564 #[inline]
565 pub fn bit(self, value: bool) -> &'a mut W {
566 const MASK: bool = true;
567 const OFFSET: u8 = 0;
568 self.w.bits &= !((MASK as u32) << OFFSET);
569 self.w.bits |= ((value & MASK) as u32) << OFFSET;
570 self.w
571 }
572}
573impl R {
574 #[doc = r" Value of the register as raw bits"]
575 #[inline]
576 pub fn bits(&self) -> u32 {
577 self.bits
578 }
579 #[doc = "Bit 11 - One sample bit method enable"]
580 #[inline]
581 pub fn onebit(&self) -> ONEBITR {
582 let bits = {
583 const MASK: bool = true;
584 const OFFSET: u8 = 11;
585 ((self.bits >> OFFSET) & MASK as u32) != 0
586 };
587 ONEBITR { bits }
588 }
589 #[doc = "Bit 10 - CTS interrupt enable"]
590 #[inline]
591 pub fn ctsie(&self) -> CTSIER {
592 let bits = {
593 const MASK: bool = true;
594 const OFFSET: u8 = 10;
595 ((self.bits >> OFFSET) & MASK as u32) != 0
596 };
597 CTSIER { bits }
598 }
599 #[doc = "Bit 9 - CTS enable"]
600 #[inline]
601 pub fn ctse(&self) -> CTSER {
602 let bits = {
603 const MASK: bool = true;
604 const OFFSET: u8 = 9;
605 ((self.bits >> OFFSET) & MASK as u32) != 0
606 };
607 CTSER { bits }
608 }
609 #[doc = "Bit 8 - RTS enable"]
610 #[inline]
611 pub fn rtse(&self) -> RTSER {
612 let bits = {
613 const MASK: bool = true;
614 const OFFSET: u8 = 8;
615 ((self.bits >> OFFSET) & MASK as u32) != 0
616 };
617 RTSER { bits }
618 }
619 #[doc = "Bit 7 - DMA enable transmitter"]
620 #[inline]
621 pub fn dmat(&self) -> DMATR {
622 let bits = {
623 const MASK: bool = true;
624 const OFFSET: u8 = 7;
625 ((self.bits >> OFFSET) & MASK as u32) != 0
626 };
627 DMATR { bits }
628 }
629 #[doc = "Bit 6 - DMA enable receiver"]
630 #[inline]
631 pub fn dmar(&self) -> DMARR {
632 let bits = {
633 const MASK: bool = true;
634 const OFFSET: u8 = 6;
635 ((self.bits >> OFFSET) & MASK as u32) != 0
636 };
637 DMARR { bits }
638 }
639 #[doc = "Bit 5 - Smartcard mode enable"]
640 #[inline]
641 pub fn scen(&self) -> SCENR {
642 let bits = {
643 const MASK: bool = true;
644 const OFFSET: u8 = 5;
645 ((self.bits >> OFFSET) & MASK as u32) != 0
646 };
647 SCENR { bits }
648 }
649 #[doc = "Bit 4 - Smartcard NACK enable"]
650 #[inline]
651 pub fn nack(&self) -> NACKR {
652 let bits = {
653 const MASK: bool = true;
654 const OFFSET: u8 = 4;
655 ((self.bits >> OFFSET) & MASK as u32) != 0
656 };
657 NACKR { bits }
658 }
659 #[doc = "Bit 3 - Half-duplex selection"]
660 #[inline]
661 pub fn hdsel(&self) -> HDSELR {
662 let bits = {
663 const MASK: bool = true;
664 const OFFSET: u8 = 3;
665 ((self.bits >> OFFSET) & MASK as u32) != 0
666 };
667 HDSELR { bits }
668 }
669 #[doc = "Bit 2 - IrDA low-power"]
670 #[inline]
671 pub fn irlp(&self) -> IRLPR {
672 let bits = {
673 const MASK: bool = true;
674 const OFFSET: u8 = 2;
675 ((self.bits >> OFFSET) & MASK as u32) != 0
676 };
677 IRLPR { bits }
678 }
679 #[doc = "Bit 1 - IrDA mode enable"]
680 #[inline]
681 pub fn iren(&self) -> IRENR {
682 let bits = {
683 const MASK: bool = true;
684 const OFFSET: u8 = 1;
685 ((self.bits >> OFFSET) & MASK as u32) != 0
686 };
687 IRENR { bits }
688 }
689 #[doc = "Bit 0 - Error interrupt enable"]
690 #[inline]
691 pub fn eie(&self) -> EIER {
692 let bits = {
693 const MASK: bool = true;
694 const OFFSET: u8 = 0;
695 ((self.bits >> OFFSET) & MASK as u32) != 0
696 };
697 EIER { bits }
698 }
699}
700impl W {
701 #[doc = r" Reset value of the register"]
702 #[inline]
703 pub fn reset_value() -> W {
704 W { bits: 0 }
705 }
706 #[doc = r" Writes raw bits to the register"]
707 #[inline]
708 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
709 self.bits = bits;
710 self
711 }
712 #[doc = "Bit 11 - One sample bit method enable"]
713 #[inline]
714 pub fn onebit(&mut self) -> _ONEBITW {
715 _ONEBITW { w: self }
716 }
717 #[doc = "Bit 10 - CTS interrupt enable"]
718 #[inline]
719 pub fn ctsie(&mut self) -> _CTSIEW {
720 _CTSIEW { w: self }
721 }
722 #[doc = "Bit 9 - CTS enable"]
723 #[inline]
724 pub fn ctse(&mut self) -> _CTSEW {
725 _CTSEW { w: self }
726 }
727 #[doc = "Bit 8 - RTS enable"]
728 #[inline]
729 pub fn rtse(&mut self) -> _RTSEW {
730 _RTSEW { w: self }
731 }
732 #[doc = "Bit 7 - DMA enable transmitter"]
733 #[inline]
734 pub fn dmat(&mut self) -> _DMATW {
735 _DMATW { w: self }
736 }
737 #[doc = "Bit 6 - DMA enable receiver"]
738 #[inline]
739 pub fn dmar(&mut self) -> _DMARW {
740 _DMARW { w: self }
741 }
742 #[doc = "Bit 5 - Smartcard mode enable"]
743 #[inline]
744 pub fn scen(&mut self) -> _SCENW {
745 _SCENW { w: self }
746 }
747 #[doc = "Bit 4 - Smartcard NACK enable"]
748 #[inline]
749 pub fn nack(&mut self) -> _NACKW {
750 _NACKW { w: self }
751 }
752 #[doc = "Bit 3 - Half-duplex selection"]
753 #[inline]
754 pub fn hdsel(&mut self) -> _HDSELW {
755 _HDSELW { w: self }
756 }
757 #[doc = "Bit 2 - IrDA low-power"]
758 #[inline]
759 pub fn irlp(&mut self) -> _IRLPW {
760 _IRLPW { w: self }
761 }
762 #[doc = "Bit 1 - IrDA mode enable"]
763 #[inline]
764 pub fn iren(&mut self) -> _IRENW {
765 _IRENW { w: self }
766 }
767 #[doc = "Bit 0 - Error interrupt enable"]
768 #[inline]
769 pub fn eie(&mut self) -> _EIEW {
770 _EIEW { w: self }
771 }
772}