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::BCR1 {
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 MBKENR {
47 bits: bool,
48}
49impl MBKENR {
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 MUXENR {
68 bits: bool,
69}
70impl MUXENR {
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 MTYPR {
89 bits: u8,
90}
91impl MTYPR {
92 #[doc = r" Value of the field as raw bits"]
93 #[inline]
94 pub fn bits(&self) -> u8 {
95 self.bits
96 }
97}
98#[doc = r" Value of the field"]
99pub struct MWIDR {
100 bits: u8,
101}
102impl MWIDR {
103 #[doc = r" Value of the field as raw bits"]
104 #[inline]
105 pub fn bits(&self) -> u8 {
106 self.bits
107 }
108}
109#[doc = r" Value of the field"]
110pub struct FACCENR {
111 bits: bool,
112}
113impl FACCENR {
114 #[doc = r" Value of the field as raw bits"]
115 #[inline]
116 pub fn bit(&self) -> bool {
117 self.bits
118 }
119 #[doc = r" Returns `true` if the bit is clear (0)"]
120 #[inline]
121 pub fn bit_is_clear(&self) -> bool {
122 !self.bit()
123 }
124 #[doc = r" Returns `true` if the bit is set (1)"]
125 #[inline]
126 pub fn bit_is_set(&self) -> bool {
127 self.bit()
128 }
129}
130#[doc = r" Value of the field"]
131pub struct BURSTENR {
132 bits: bool,
133}
134impl BURSTENR {
135 #[doc = r" Value of the field as raw bits"]
136 #[inline]
137 pub fn bit(&self) -> bool {
138 self.bits
139 }
140 #[doc = r" Returns `true` if the bit is clear (0)"]
141 #[inline]
142 pub fn bit_is_clear(&self) -> bool {
143 !self.bit()
144 }
145 #[doc = r" Returns `true` if the bit is set (1)"]
146 #[inline]
147 pub fn bit_is_set(&self) -> bool {
148 self.bit()
149 }
150}
151#[doc = r" Value of the field"]
152pub struct WAITPOLR {
153 bits: bool,
154}
155impl WAITPOLR {
156 #[doc = r" Value of the field as raw bits"]
157 #[inline]
158 pub fn bit(&self) -> bool {
159 self.bits
160 }
161 #[doc = r" Returns `true` if the bit is clear (0)"]
162 #[inline]
163 pub fn bit_is_clear(&self) -> bool {
164 !self.bit()
165 }
166 #[doc = r" Returns `true` if the bit is set (1)"]
167 #[inline]
168 pub fn bit_is_set(&self) -> bool {
169 self.bit()
170 }
171}
172#[doc = r" Value of the field"]
173pub struct WAITCFGR {
174 bits: bool,
175}
176impl WAITCFGR {
177 #[doc = r" Value of the field as raw bits"]
178 #[inline]
179 pub fn bit(&self) -> bool {
180 self.bits
181 }
182 #[doc = r" Returns `true` if the bit is clear (0)"]
183 #[inline]
184 pub fn bit_is_clear(&self) -> bool {
185 !self.bit()
186 }
187 #[doc = r" Returns `true` if the bit is set (1)"]
188 #[inline]
189 pub fn bit_is_set(&self) -> bool {
190 self.bit()
191 }
192}
193#[doc = r" Value of the field"]
194pub struct WRENR {
195 bits: bool,
196}
197impl WRENR {
198 #[doc = r" Value of the field as raw bits"]
199 #[inline]
200 pub fn bit(&self) -> bool {
201 self.bits
202 }
203 #[doc = r" Returns `true` if the bit is clear (0)"]
204 #[inline]
205 pub fn bit_is_clear(&self) -> bool {
206 !self.bit()
207 }
208 #[doc = r" Returns `true` if the bit is set (1)"]
209 #[inline]
210 pub fn bit_is_set(&self) -> bool {
211 self.bit()
212 }
213}
214#[doc = r" Value of the field"]
215pub struct WAITENR {
216 bits: bool,
217}
218impl WAITENR {
219 #[doc = r" Value of the field as raw bits"]
220 #[inline]
221 pub fn bit(&self) -> bool {
222 self.bits
223 }
224 #[doc = r" Returns `true` if the bit is clear (0)"]
225 #[inline]
226 pub fn bit_is_clear(&self) -> bool {
227 !self.bit()
228 }
229 #[doc = r" Returns `true` if the bit is set (1)"]
230 #[inline]
231 pub fn bit_is_set(&self) -> bool {
232 self.bit()
233 }
234}
235#[doc = r" Value of the field"]
236pub struct EXTMODR {
237 bits: bool,
238}
239impl EXTMODR {
240 #[doc = r" Value of the field as raw bits"]
241 #[inline]
242 pub fn bit(&self) -> bool {
243 self.bits
244 }
245 #[doc = r" Returns `true` if the bit is clear (0)"]
246 #[inline]
247 pub fn bit_is_clear(&self) -> bool {
248 !self.bit()
249 }
250 #[doc = r" Returns `true` if the bit is set (1)"]
251 #[inline]
252 pub fn bit_is_set(&self) -> bool {
253 self.bit()
254 }
255}
256#[doc = r" Value of the field"]
257pub struct ASYNCWAITR {
258 bits: bool,
259}
260impl ASYNCWAITR {
261 #[doc = r" Value of the field as raw bits"]
262 #[inline]
263 pub fn bit(&self) -> bool {
264 self.bits
265 }
266 #[doc = r" Returns `true` if the bit is clear (0)"]
267 #[inline]
268 pub fn bit_is_clear(&self) -> bool {
269 !self.bit()
270 }
271 #[doc = r" Returns `true` if the bit is set (1)"]
272 #[inline]
273 pub fn bit_is_set(&self) -> bool {
274 self.bit()
275 }
276}
277#[doc = r" Value of the field"]
278pub struct CBURSTRWR {
279 bits: bool,
280}
281impl CBURSTRWR {
282 #[doc = r" Value of the field as raw bits"]
283 #[inline]
284 pub fn bit(&self) -> bool {
285 self.bits
286 }
287 #[doc = r" Returns `true` if the bit is clear (0)"]
288 #[inline]
289 pub fn bit_is_clear(&self) -> bool {
290 !self.bit()
291 }
292 #[doc = r" Returns `true` if the bit is set (1)"]
293 #[inline]
294 pub fn bit_is_set(&self) -> bool {
295 self.bit()
296 }
297}
298#[doc = r" Value of the field"]
299pub struct CCLKENR {
300 bits: bool,
301}
302impl CCLKENR {
303 #[doc = r" Value of the field as raw bits"]
304 #[inline]
305 pub fn bit(&self) -> bool {
306 self.bits
307 }
308 #[doc = r" Returns `true` if the bit is clear (0)"]
309 #[inline]
310 pub fn bit_is_clear(&self) -> bool {
311 !self.bit()
312 }
313 #[doc = r" Returns `true` if the bit is set (1)"]
314 #[inline]
315 pub fn bit_is_set(&self) -> bool {
316 self.bit()
317 }
318}
319#[doc = r" Value of the field"]
320pub struct WFDISR {
321 bits: bool,
322}
323impl WFDISR {
324 #[doc = r" Value of the field as raw bits"]
325 #[inline]
326 pub fn bit(&self) -> bool {
327 self.bits
328 }
329 #[doc = r" Returns `true` if the bit is clear (0)"]
330 #[inline]
331 pub fn bit_is_clear(&self) -> bool {
332 !self.bit()
333 }
334 #[doc = r" Returns `true` if the bit is set (1)"]
335 #[inline]
336 pub fn bit_is_set(&self) -> bool {
337 self.bit()
338 }
339}
340#[doc = r" Proxy"]
341pub struct _MBKENW<'a> {
342 w: &'a mut W,
343}
344impl<'a> _MBKENW<'a> {
345 #[doc = r" Sets the field bit"]
346 pub fn set_bit(self) -> &'a mut W {
347 self.bit(true)
348 }
349 #[doc = r" Clears the field bit"]
350 pub fn clear_bit(self) -> &'a mut W {
351 self.bit(false)
352 }
353 #[doc = r" Writes raw bits to the field"]
354 #[inline]
355 pub fn bit(self, value: bool) -> &'a mut W {
356 const MASK: bool = true;
357 const OFFSET: u8 = 0;
358 self.w.bits &= !((MASK as u32) << OFFSET);
359 self.w.bits |= ((value & MASK) as u32) << OFFSET;
360 self.w
361 }
362}
363#[doc = r" Proxy"]
364pub struct _MUXENW<'a> {
365 w: &'a mut W,
366}
367impl<'a> _MUXENW<'a> {
368 #[doc = r" Sets the field bit"]
369 pub fn set_bit(self) -> &'a mut W {
370 self.bit(true)
371 }
372 #[doc = r" Clears the field bit"]
373 pub fn clear_bit(self) -> &'a mut W {
374 self.bit(false)
375 }
376 #[doc = r" Writes raw bits to the field"]
377 #[inline]
378 pub fn bit(self, value: bool) -> &'a mut W {
379 const MASK: bool = true;
380 const OFFSET: u8 = 1;
381 self.w.bits &= !((MASK as u32) << OFFSET);
382 self.w.bits |= ((value & MASK) as u32) << OFFSET;
383 self.w
384 }
385}
386#[doc = r" Proxy"]
387pub struct _MTYPW<'a> {
388 w: &'a mut W,
389}
390impl<'a> _MTYPW<'a> {
391 #[doc = r" Writes raw bits to the field"]
392 #[inline]
393 pub unsafe fn bits(self, value: u8) -> &'a mut W {
394 const MASK: u8 = 3;
395 const OFFSET: u8 = 2;
396 self.w.bits &= !((MASK as u32) << OFFSET);
397 self.w.bits |= ((value & MASK) as u32) << OFFSET;
398 self.w
399 }
400}
401#[doc = r" Proxy"]
402pub struct _MWIDW<'a> {
403 w: &'a mut W,
404}
405impl<'a> _MWIDW<'a> {
406 #[doc = r" Writes raw bits to the field"]
407 #[inline]
408 pub unsafe fn bits(self, value: u8) -> &'a mut W {
409 const MASK: u8 = 3;
410 const OFFSET: u8 = 4;
411 self.w.bits &= !((MASK as u32) << OFFSET);
412 self.w.bits |= ((value & MASK) as u32) << OFFSET;
413 self.w
414 }
415}
416#[doc = r" Proxy"]
417pub struct _FACCENW<'a> {
418 w: &'a mut W,
419}
420impl<'a> _FACCENW<'a> {
421 #[doc = r" Sets the field bit"]
422 pub fn set_bit(self) -> &'a mut W {
423 self.bit(true)
424 }
425 #[doc = r" Clears the field bit"]
426 pub fn clear_bit(self) -> &'a mut W {
427 self.bit(false)
428 }
429 #[doc = r" Writes raw bits to the field"]
430 #[inline]
431 pub fn bit(self, value: bool) -> &'a mut W {
432 const MASK: bool = true;
433 const OFFSET: u8 = 6;
434 self.w.bits &= !((MASK as u32) << OFFSET);
435 self.w.bits |= ((value & MASK) as u32) << OFFSET;
436 self.w
437 }
438}
439#[doc = r" Proxy"]
440pub struct _BURSTENW<'a> {
441 w: &'a mut W,
442}
443impl<'a> _BURSTENW<'a> {
444 #[doc = r" Sets the field bit"]
445 pub fn set_bit(self) -> &'a mut W {
446 self.bit(true)
447 }
448 #[doc = r" Clears the field bit"]
449 pub fn clear_bit(self) -> &'a mut W {
450 self.bit(false)
451 }
452 #[doc = r" Writes raw bits to the field"]
453 #[inline]
454 pub fn bit(self, value: bool) -> &'a mut W {
455 const MASK: bool = true;
456 const OFFSET: u8 = 8;
457 self.w.bits &= !((MASK as u32) << OFFSET);
458 self.w.bits |= ((value & MASK) as u32) << OFFSET;
459 self.w
460 }
461}
462#[doc = r" Proxy"]
463pub struct _WAITPOLW<'a> {
464 w: &'a mut W,
465}
466impl<'a> _WAITPOLW<'a> {
467 #[doc = r" Sets the field bit"]
468 pub fn set_bit(self) -> &'a mut W {
469 self.bit(true)
470 }
471 #[doc = r" Clears the field bit"]
472 pub fn clear_bit(self) -> &'a mut W {
473 self.bit(false)
474 }
475 #[doc = r" Writes raw bits to the field"]
476 #[inline]
477 pub fn bit(self, value: bool) -> &'a mut W {
478 const MASK: bool = true;
479 const OFFSET: u8 = 9;
480 self.w.bits &= !((MASK as u32) << OFFSET);
481 self.w.bits |= ((value & MASK) as u32) << OFFSET;
482 self.w
483 }
484}
485#[doc = r" Proxy"]
486pub struct _WAITCFGW<'a> {
487 w: &'a mut W,
488}
489impl<'a> _WAITCFGW<'a> {
490 #[doc = r" Sets the field bit"]
491 pub fn set_bit(self) -> &'a mut W {
492 self.bit(true)
493 }
494 #[doc = r" Clears the field bit"]
495 pub fn clear_bit(self) -> &'a mut W {
496 self.bit(false)
497 }
498 #[doc = r" Writes raw bits to the field"]
499 #[inline]
500 pub fn bit(self, value: bool) -> &'a mut W {
501 const MASK: bool = true;
502 const OFFSET: u8 = 11;
503 self.w.bits &= !((MASK as u32) << OFFSET);
504 self.w.bits |= ((value & MASK) as u32) << OFFSET;
505 self.w
506 }
507}
508#[doc = r" Proxy"]
509pub struct _WRENW<'a> {
510 w: &'a mut W,
511}
512impl<'a> _WRENW<'a> {
513 #[doc = r" Sets the field bit"]
514 pub fn set_bit(self) -> &'a mut W {
515 self.bit(true)
516 }
517 #[doc = r" Clears the field bit"]
518 pub fn clear_bit(self) -> &'a mut W {
519 self.bit(false)
520 }
521 #[doc = r" Writes raw bits to the field"]
522 #[inline]
523 pub fn bit(self, value: bool) -> &'a mut W {
524 const MASK: bool = true;
525 const OFFSET: u8 = 12;
526 self.w.bits &= !((MASK as u32) << OFFSET);
527 self.w.bits |= ((value & MASK) as u32) << OFFSET;
528 self.w
529 }
530}
531#[doc = r" Proxy"]
532pub struct _WAITENW<'a> {
533 w: &'a mut W,
534}
535impl<'a> _WAITENW<'a> {
536 #[doc = r" Sets the field bit"]
537 pub fn set_bit(self) -> &'a mut W {
538 self.bit(true)
539 }
540 #[doc = r" Clears the field bit"]
541 pub fn clear_bit(self) -> &'a mut W {
542 self.bit(false)
543 }
544 #[doc = r" Writes raw bits to the field"]
545 #[inline]
546 pub fn bit(self, value: bool) -> &'a mut W {
547 const MASK: bool = true;
548 const OFFSET: u8 = 13;
549 self.w.bits &= !((MASK as u32) << OFFSET);
550 self.w.bits |= ((value & MASK) as u32) << OFFSET;
551 self.w
552 }
553}
554#[doc = r" Proxy"]
555pub struct _EXTMODW<'a> {
556 w: &'a mut W,
557}
558impl<'a> _EXTMODW<'a> {
559 #[doc = r" Sets the field bit"]
560 pub fn set_bit(self) -> &'a mut W {
561 self.bit(true)
562 }
563 #[doc = r" Clears the field bit"]
564 pub fn clear_bit(self) -> &'a mut W {
565 self.bit(false)
566 }
567 #[doc = r" Writes raw bits to the field"]
568 #[inline]
569 pub fn bit(self, value: bool) -> &'a mut W {
570 const MASK: bool = true;
571 const OFFSET: u8 = 14;
572 self.w.bits &= !((MASK as u32) << OFFSET);
573 self.w.bits |= ((value & MASK) as u32) << OFFSET;
574 self.w
575 }
576}
577#[doc = r" Proxy"]
578pub struct _ASYNCWAITW<'a> {
579 w: &'a mut W,
580}
581impl<'a> _ASYNCWAITW<'a> {
582 #[doc = r" Sets the field bit"]
583 pub fn set_bit(self) -> &'a mut W {
584 self.bit(true)
585 }
586 #[doc = r" Clears the field bit"]
587 pub fn clear_bit(self) -> &'a mut W {
588 self.bit(false)
589 }
590 #[doc = r" Writes raw bits to the field"]
591 #[inline]
592 pub fn bit(self, value: bool) -> &'a mut W {
593 const MASK: bool = true;
594 const OFFSET: u8 = 15;
595 self.w.bits &= !((MASK as u32) << OFFSET);
596 self.w.bits |= ((value & MASK) as u32) << OFFSET;
597 self.w
598 }
599}
600#[doc = r" Proxy"]
601pub struct _CBURSTRWW<'a> {
602 w: &'a mut W,
603}
604impl<'a> _CBURSTRWW<'a> {
605 #[doc = r" Sets the field bit"]
606 pub fn set_bit(self) -> &'a mut W {
607 self.bit(true)
608 }
609 #[doc = r" Clears the field bit"]
610 pub fn clear_bit(self) -> &'a mut W {
611 self.bit(false)
612 }
613 #[doc = r" Writes raw bits to the field"]
614 #[inline]
615 pub fn bit(self, value: bool) -> &'a mut W {
616 const MASK: bool = true;
617 const OFFSET: u8 = 19;
618 self.w.bits &= !((MASK as u32) << OFFSET);
619 self.w.bits |= ((value & MASK) as u32) << OFFSET;
620 self.w
621 }
622}
623#[doc = r" Proxy"]
624pub struct _CCLKENW<'a> {
625 w: &'a mut W,
626}
627impl<'a> _CCLKENW<'a> {
628 #[doc = r" Sets the field bit"]
629 pub fn set_bit(self) -> &'a mut W {
630 self.bit(true)
631 }
632 #[doc = r" Clears the field bit"]
633 pub fn clear_bit(self) -> &'a mut W {
634 self.bit(false)
635 }
636 #[doc = r" Writes raw bits to the field"]
637 #[inline]
638 pub fn bit(self, value: bool) -> &'a mut W {
639 const MASK: bool = true;
640 const OFFSET: u8 = 20;
641 self.w.bits &= !((MASK as u32) << OFFSET);
642 self.w.bits |= ((value & MASK) as u32) << OFFSET;
643 self.w
644 }
645}
646#[doc = r" Proxy"]
647pub struct _WFDISW<'a> {
648 w: &'a mut W,
649}
650impl<'a> _WFDISW<'a> {
651 #[doc = r" Sets the field bit"]
652 pub fn set_bit(self) -> &'a mut W {
653 self.bit(true)
654 }
655 #[doc = r" Clears the field bit"]
656 pub fn clear_bit(self) -> &'a mut W {
657 self.bit(false)
658 }
659 #[doc = r" Writes raw bits to the field"]
660 #[inline]
661 pub fn bit(self, value: bool) -> &'a mut W {
662 const MASK: bool = true;
663 const OFFSET: u8 = 21;
664 self.w.bits &= !((MASK as u32) << OFFSET);
665 self.w.bits |= ((value & MASK) as u32) << OFFSET;
666 self.w
667 }
668}
669impl R {
670 #[doc = r" Value of the register as raw bits"]
671 #[inline]
672 pub fn bits(&self) -> u32 {
673 self.bits
674 }
675 #[doc = "Bit 0 - MBKEN"]
676 #[inline]
677 pub fn mbken(&self) -> MBKENR {
678 let bits = {
679 const MASK: bool = true;
680 const OFFSET: u8 = 0;
681 ((self.bits >> OFFSET) & MASK as u32) != 0
682 };
683 MBKENR { bits }
684 }
685 #[doc = "Bit 1 - MUXEN"]
686 #[inline]
687 pub fn muxen(&self) -> MUXENR {
688 let bits = {
689 const MASK: bool = true;
690 const OFFSET: u8 = 1;
691 ((self.bits >> OFFSET) & MASK as u32) != 0
692 };
693 MUXENR { bits }
694 }
695 #[doc = "Bits 2:3 - MTYP"]
696 #[inline]
697 pub fn mtyp(&self) -> MTYPR {
698 let bits = {
699 const MASK: u8 = 3;
700 const OFFSET: u8 = 2;
701 ((self.bits >> OFFSET) & MASK as u32) as u8
702 };
703 MTYPR { bits }
704 }
705 #[doc = "Bits 4:5 - MWID"]
706 #[inline]
707 pub fn mwid(&self) -> MWIDR {
708 let bits = {
709 const MASK: u8 = 3;
710 const OFFSET: u8 = 4;
711 ((self.bits >> OFFSET) & MASK as u32) as u8
712 };
713 MWIDR { bits }
714 }
715 #[doc = "Bit 6 - FACCEN"]
716 #[inline]
717 pub fn faccen(&self) -> FACCENR {
718 let bits = {
719 const MASK: bool = true;
720 const OFFSET: u8 = 6;
721 ((self.bits >> OFFSET) & MASK as u32) != 0
722 };
723 FACCENR { bits }
724 }
725 #[doc = "Bit 8 - BURSTEN"]
726 #[inline]
727 pub fn bursten(&self) -> BURSTENR {
728 let bits = {
729 const MASK: bool = true;
730 const OFFSET: u8 = 8;
731 ((self.bits >> OFFSET) & MASK as u32) != 0
732 };
733 BURSTENR { bits }
734 }
735 #[doc = "Bit 9 - WAITPOL"]
736 #[inline]
737 pub fn waitpol(&self) -> WAITPOLR {
738 let bits = {
739 const MASK: bool = true;
740 const OFFSET: u8 = 9;
741 ((self.bits >> OFFSET) & MASK as u32) != 0
742 };
743 WAITPOLR { bits }
744 }
745 #[doc = "Bit 11 - WAITCFG"]
746 #[inline]
747 pub fn waitcfg(&self) -> WAITCFGR {
748 let bits = {
749 const MASK: bool = true;
750 const OFFSET: u8 = 11;
751 ((self.bits >> OFFSET) & MASK as u32) != 0
752 };
753 WAITCFGR { bits }
754 }
755 #[doc = "Bit 12 - WREN"]
756 #[inline]
757 pub fn wren(&self) -> WRENR {
758 let bits = {
759 const MASK: bool = true;
760 const OFFSET: u8 = 12;
761 ((self.bits >> OFFSET) & MASK as u32) != 0
762 };
763 WRENR { bits }
764 }
765 #[doc = "Bit 13 - WAITEN"]
766 #[inline]
767 pub fn waiten(&self) -> WAITENR {
768 let bits = {
769 const MASK: bool = true;
770 const OFFSET: u8 = 13;
771 ((self.bits >> OFFSET) & MASK as u32) != 0
772 };
773 WAITENR { bits }
774 }
775 #[doc = "Bit 14 - EXTMOD"]
776 #[inline]
777 pub fn extmod(&self) -> EXTMODR {
778 let bits = {
779 const MASK: bool = true;
780 const OFFSET: u8 = 14;
781 ((self.bits >> OFFSET) & MASK as u32) != 0
782 };
783 EXTMODR { bits }
784 }
785 #[doc = "Bit 15 - ASYNCWAIT"]
786 #[inline]
787 pub fn asyncwait(&self) -> ASYNCWAITR {
788 let bits = {
789 const MASK: bool = true;
790 const OFFSET: u8 = 15;
791 ((self.bits >> OFFSET) & MASK as u32) != 0
792 };
793 ASYNCWAITR { bits }
794 }
795 #[doc = "Bit 19 - CBURSTRW"]
796 #[inline]
797 pub fn cburstrw(&self) -> CBURSTRWR {
798 let bits = {
799 const MASK: bool = true;
800 const OFFSET: u8 = 19;
801 ((self.bits >> OFFSET) & MASK as u32) != 0
802 };
803 CBURSTRWR { bits }
804 }
805 #[doc = "Bit 20 - CCLKEN"]
806 #[inline]
807 pub fn cclken(&self) -> CCLKENR {
808 let bits = {
809 const MASK: bool = true;
810 const OFFSET: u8 = 20;
811 ((self.bits >> OFFSET) & MASK as u32) != 0
812 };
813 CCLKENR { bits }
814 }
815 #[doc = "Bit 21 - Write FIFO Disable"]
816 #[inline]
817 pub fn wfdis(&self) -> WFDISR {
818 let bits = {
819 const MASK: bool = true;
820 const OFFSET: u8 = 21;
821 ((self.bits >> OFFSET) & MASK as u32) != 0
822 };
823 WFDISR { bits }
824 }
825}
826impl W {
827 #[doc = r" Reset value of the register"]
828 #[inline]
829 pub fn reset_value() -> W {
830 W { bits: 12496 }
831 }
832 #[doc = r" Writes raw bits to the register"]
833 #[inline]
834 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
835 self.bits = bits;
836 self
837 }
838 #[doc = "Bit 0 - MBKEN"]
839 #[inline]
840 pub fn mbken(&mut self) -> _MBKENW {
841 _MBKENW { w: self }
842 }
843 #[doc = "Bit 1 - MUXEN"]
844 #[inline]
845 pub fn muxen(&mut self) -> _MUXENW {
846 _MUXENW { w: self }
847 }
848 #[doc = "Bits 2:3 - MTYP"]
849 #[inline]
850 pub fn mtyp(&mut self) -> _MTYPW {
851 _MTYPW { w: self }
852 }
853 #[doc = "Bits 4:5 - MWID"]
854 #[inline]
855 pub fn mwid(&mut self) -> _MWIDW {
856 _MWIDW { w: self }
857 }
858 #[doc = "Bit 6 - FACCEN"]
859 #[inline]
860 pub fn faccen(&mut self) -> _FACCENW {
861 _FACCENW { w: self }
862 }
863 #[doc = "Bit 8 - BURSTEN"]
864 #[inline]
865 pub fn bursten(&mut self) -> _BURSTENW {
866 _BURSTENW { w: self }
867 }
868 #[doc = "Bit 9 - WAITPOL"]
869 #[inline]
870 pub fn waitpol(&mut self) -> _WAITPOLW {
871 _WAITPOLW { w: self }
872 }
873 #[doc = "Bit 11 - WAITCFG"]
874 #[inline]
875 pub fn waitcfg(&mut self) -> _WAITCFGW {
876 _WAITCFGW { w: self }
877 }
878 #[doc = "Bit 12 - WREN"]
879 #[inline]
880 pub fn wren(&mut self) -> _WRENW {
881 _WRENW { w: self }
882 }
883 #[doc = "Bit 13 - WAITEN"]
884 #[inline]
885 pub fn waiten(&mut self) -> _WAITENW {
886 _WAITENW { w: self }
887 }
888 #[doc = "Bit 14 - EXTMOD"]
889 #[inline]
890 pub fn extmod(&mut self) -> _EXTMODW {
891 _EXTMODW { w: self }
892 }
893 #[doc = "Bit 15 - ASYNCWAIT"]
894 #[inline]
895 pub fn asyncwait(&mut self) -> _ASYNCWAITW {
896 _ASYNCWAITW { w: self }
897 }
898 #[doc = "Bit 19 - CBURSTRW"]
899 #[inline]
900 pub fn cburstrw(&mut self) -> _CBURSTRWW {
901 _CBURSTRWW { w: self }
902 }
903 #[doc = "Bit 20 - CCLKEN"]
904 #[inline]
905 pub fn cclken(&mut self) -> _CCLKENW {
906 _CCLKENW { w: self }
907 }
908 #[doc = "Bit 21 - Write FIFO Disable"]
909 #[inline]
910 pub fn wfdis(&mut self) -> _WFDISW {
911 _WFDISW { w: self }
912 }
913}