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::BCR2 {
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 CBURSTRWR {
47 bits: bool,
48}
49impl CBURSTRWR {
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 ASYNCWAITR {
68 bits: bool,
69}
70impl ASYNCWAITR {
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 EXTMODR {
89 bits: bool,
90}
91impl EXTMODR {
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 WAITENR {
110 bits: bool,
111}
112impl WAITENR {
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 WRENR {
131 bits: bool,
132}
133impl WRENR {
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 WAITCFGR {
152 bits: bool,
153}
154impl WAITCFGR {
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 WRAPMODR {
173 bits: bool,
174}
175impl WRAPMODR {
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 WAITPOLR {
194 bits: bool,
195}
196impl WAITPOLR {
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 BURSTENR {
215 bits: bool,
216}
217impl BURSTENR {
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 FACCENR {
236 bits: bool,
237}
238impl FACCENR {
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 MWIDR {
257 bits: u8,
258}
259impl MWIDR {
260 #[doc = r" Value of the field as raw bits"]
261 #[inline]
262 pub fn bits(&self) -> u8 {
263 self.bits
264 }
265}
266#[doc = r" Value of the field"]
267pub struct MTYPR {
268 bits: u8,
269}
270impl MTYPR {
271 #[doc = r" Value of the field as raw bits"]
272 #[inline]
273 pub fn bits(&self) -> u8 {
274 self.bits
275 }
276}
277#[doc = r" Value of the field"]
278pub struct MUXENR {
279 bits: bool,
280}
281impl MUXENR {
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 MBKENR {
300 bits: bool,
301}
302impl MBKENR {
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" Proxy"]
320pub struct _CBURSTRWW<'a> {
321 w: &'a mut W,
322}
323impl<'a> _CBURSTRWW<'a> {
324 #[doc = r" Sets the field bit"]
325 pub fn set_bit(self) -> &'a mut W {
326 self.bit(true)
327 }
328 #[doc = r" Clears the field bit"]
329 pub fn clear_bit(self) -> &'a mut W {
330 self.bit(false)
331 }
332 #[doc = r" Writes raw bits to the field"]
333 #[inline]
334 pub fn bit(self, value: bool) -> &'a mut W {
335 const MASK: bool = true;
336 const OFFSET: u8 = 19;
337 self.w.bits &= !((MASK as u32) << OFFSET);
338 self.w.bits |= ((value & MASK) as u32) << OFFSET;
339 self.w
340 }
341}
342#[doc = r" Proxy"]
343pub struct _ASYNCWAITW<'a> {
344 w: &'a mut W,
345}
346impl<'a> _ASYNCWAITW<'a> {
347 #[doc = r" Sets the field bit"]
348 pub fn set_bit(self) -> &'a mut W {
349 self.bit(true)
350 }
351 #[doc = r" Clears the field bit"]
352 pub fn clear_bit(self) -> &'a mut W {
353 self.bit(false)
354 }
355 #[doc = r" Writes raw bits to the field"]
356 #[inline]
357 pub fn bit(self, value: bool) -> &'a mut W {
358 const MASK: bool = true;
359 const OFFSET: u8 = 15;
360 self.w.bits &= !((MASK as u32) << OFFSET);
361 self.w.bits |= ((value & MASK) as u32) << OFFSET;
362 self.w
363 }
364}
365#[doc = r" Proxy"]
366pub struct _EXTMODW<'a> {
367 w: &'a mut W,
368}
369impl<'a> _EXTMODW<'a> {
370 #[doc = r" Sets the field bit"]
371 pub fn set_bit(self) -> &'a mut W {
372 self.bit(true)
373 }
374 #[doc = r" Clears the field bit"]
375 pub fn clear_bit(self) -> &'a mut W {
376 self.bit(false)
377 }
378 #[doc = r" Writes raw bits to the field"]
379 #[inline]
380 pub fn bit(self, value: bool) -> &'a mut W {
381 const MASK: bool = true;
382 const OFFSET: u8 = 14;
383 self.w.bits &= !((MASK as u32) << OFFSET);
384 self.w.bits |= ((value & MASK) as u32) << OFFSET;
385 self.w
386 }
387}
388#[doc = r" Proxy"]
389pub struct _WAITENW<'a> {
390 w: &'a mut W,
391}
392impl<'a> _WAITENW<'a> {
393 #[doc = r" Sets the field bit"]
394 pub fn set_bit(self) -> &'a mut W {
395 self.bit(true)
396 }
397 #[doc = r" Clears the field bit"]
398 pub fn clear_bit(self) -> &'a mut W {
399 self.bit(false)
400 }
401 #[doc = r" Writes raw bits to the field"]
402 #[inline]
403 pub fn bit(self, value: bool) -> &'a mut W {
404 const MASK: bool = true;
405 const OFFSET: u8 = 13;
406 self.w.bits &= !((MASK as u32) << OFFSET);
407 self.w.bits |= ((value & MASK) as u32) << OFFSET;
408 self.w
409 }
410}
411#[doc = r" Proxy"]
412pub struct _WRENW<'a> {
413 w: &'a mut W,
414}
415impl<'a> _WRENW<'a> {
416 #[doc = r" Sets the field bit"]
417 pub fn set_bit(self) -> &'a mut W {
418 self.bit(true)
419 }
420 #[doc = r" Clears the field bit"]
421 pub fn clear_bit(self) -> &'a mut W {
422 self.bit(false)
423 }
424 #[doc = r" Writes raw bits to the field"]
425 #[inline]
426 pub fn bit(self, value: bool) -> &'a mut W {
427 const MASK: bool = true;
428 const OFFSET: u8 = 12;
429 self.w.bits &= !((MASK as u32) << OFFSET);
430 self.w.bits |= ((value & MASK) as u32) << OFFSET;
431 self.w
432 }
433}
434#[doc = r" Proxy"]
435pub struct _WAITCFGW<'a> {
436 w: &'a mut W,
437}
438impl<'a> _WAITCFGW<'a> {
439 #[doc = r" Sets the field bit"]
440 pub fn set_bit(self) -> &'a mut W {
441 self.bit(true)
442 }
443 #[doc = r" Clears the field bit"]
444 pub fn clear_bit(self) -> &'a mut W {
445 self.bit(false)
446 }
447 #[doc = r" Writes raw bits to the field"]
448 #[inline]
449 pub fn bit(self, value: bool) -> &'a mut W {
450 const MASK: bool = true;
451 const OFFSET: u8 = 11;
452 self.w.bits &= !((MASK as u32) << OFFSET);
453 self.w.bits |= ((value & MASK) as u32) << OFFSET;
454 self.w
455 }
456}
457#[doc = r" Proxy"]
458pub struct _WRAPMODW<'a> {
459 w: &'a mut W,
460}
461impl<'a> _WRAPMODW<'a> {
462 #[doc = r" Sets the field bit"]
463 pub fn set_bit(self) -> &'a mut W {
464 self.bit(true)
465 }
466 #[doc = r" Clears the field bit"]
467 pub fn clear_bit(self) -> &'a mut W {
468 self.bit(false)
469 }
470 #[doc = r" Writes raw bits to the field"]
471 #[inline]
472 pub fn bit(self, value: bool) -> &'a mut W {
473 const MASK: bool = true;
474 const OFFSET: u8 = 10;
475 self.w.bits &= !((MASK as u32) << OFFSET);
476 self.w.bits |= ((value & MASK) as u32) << OFFSET;
477 self.w
478 }
479}
480#[doc = r" Proxy"]
481pub struct _WAITPOLW<'a> {
482 w: &'a mut W,
483}
484impl<'a> _WAITPOLW<'a> {
485 #[doc = r" Sets the field bit"]
486 pub fn set_bit(self) -> &'a mut W {
487 self.bit(true)
488 }
489 #[doc = r" Clears the field bit"]
490 pub fn clear_bit(self) -> &'a mut W {
491 self.bit(false)
492 }
493 #[doc = r" Writes raw bits to the field"]
494 #[inline]
495 pub fn bit(self, value: bool) -> &'a mut W {
496 const MASK: bool = true;
497 const OFFSET: u8 = 9;
498 self.w.bits &= !((MASK as u32) << OFFSET);
499 self.w.bits |= ((value & MASK) as u32) << OFFSET;
500 self.w
501 }
502}
503#[doc = r" Proxy"]
504pub struct _BURSTENW<'a> {
505 w: &'a mut W,
506}
507impl<'a> _BURSTENW<'a> {
508 #[doc = r" Sets the field bit"]
509 pub fn set_bit(self) -> &'a mut W {
510 self.bit(true)
511 }
512 #[doc = r" Clears the field bit"]
513 pub fn clear_bit(self) -> &'a mut W {
514 self.bit(false)
515 }
516 #[doc = r" Writes raw bits to the field"]
517 #[inline]
518 pub fn bit(self, value: bool) -> &'a mut W {
519 const MASK: bool = true;
520 const OFFSET: u8 = 8;
521 self.w.bits &= !((MASK as u32) << OFFSET);
522 self.w.bits |= ((value & MASK) as u32) << OFFSET;
523 self.w
524 }
525}
526#[doc = r" Proxy"]
527pub struct _FACCENW<'a> {
528 w: &'a mut W,
529}
530impl<'a> _FACCENW<'a> {
531 #[doc = r" Sets the field bit"]
532 pub fn set_bit(self) -> &'a mut W {
533 self.bit(true)
534 }
535 #[doc = r" Clears the field bit"]
536 pub fn clear_bit(self) -> &'a mut W {
537 self.bit(false)
538 }
539 #[doc = r" Writes raw bits to the field"]
540 #[inline]
541 pub fn bit(self, value: bool) -> &'a mut W {
542 const MASK: bool = true;
543 const OFFSET: u8 = 6;
544 self.w.bits &= !((MASK as u32) << OFFSET);
545 self.w.bits |= ((value & MASK) as u32) << OFFSET;
546 self.w
547 }
548}
549#[doc = r" Proxy"]
550pub struct _MWIDW<'a> {
551 w: &'a mut W,
552}
553impl<'a> _MWIDW<'a> {
554 #[doc = r" Writes raw bits to the field"]
555 #[inline]
556 pub unsafe fn bits(self, value: u8) -> &'a mut W {
557 const MASK: u8 = 3;
558 const OFFSET: u8 = 4;
559 self.w.bits &= !((MASK as u32) << OFFSET);
560 self.w.bits |= ((value & MASK) as u32) << OFFSET;
561 self.w
562 }
563}
564#[doc = r" Proxy"]
565pub struct _MTYPW<'a> {
566 w: &'a mut W,
567}
568impl<'a> _MTYPW<'a> {
569 #[doc = r" Writes raw bits to the field"]
570 #[inline]
571 pub unsafe fn bits(self, value: u8) -> &'a mut W {
572 const MASK: u8 = 3;
573 const OFFSET: u8 = 2;
574 self.w.bits &= !((MASK as u32) << OFFSET);
575 self.w.bits |= ((value & MASK) as u32) << OFFSET;
576 self.w
577 }
578}
579#[doc = r" Proxy"]
580pub struct _MUXENW<'a> {
581 w: &'a mut W,
582}
583impl<'a> _MUXENW<'a> {
584 #[doc = r" Sets the field bit"]
585 pub fn set_bit(self) -> &'a mut W {
586 self.bit(true)
587 }
588 #[doc = r" Clears the field bit"]
589 pub fn clear_bit(self) -> &'a mut W {
590 self.bit(false)
591 }
592 #[doc = r" Writes raw bits to the field"]
593 #[inline]
594 pub fn bit(self, value: bool) -> &'a mut W {
595 const MASK: bool = true;
596 const OFFSET: u8 = 1;
597 self.w.bits &= !((MASK as u32) << OFFSET);
598 self.w.bits |= ((value & MASK) as u32) << OFFSET;
599 self.w
600 }
601}
602#[doc = r" Proxy"]
603pub struct _MBKENW<'a> {
604 w: &'a mut W,
605}
606impl<'a> _MBKENW<'a> {
607 #[doc = r" Sets the field bit"]
608 pub fn set_bit(self) -> &'a mut W {
609 self.bit(true)
610 }
611 #[doc = r" Clears the field bit"]
612 pub fn clear_bit(self) -> &'a mut W {
613 self.bit(false)
614 }
615 #[doc = r" Writes raw bits to the field"]
616 #[inline]
617 pub fn bit(self, value: bool) -> &'a mut W {
618 const MASK: bool = true;
619 const OFFSET: u8 = 0;
620 self.w.bits &= !((MASK as u32) << OFFSET);
621 self.w.bits |= ((value & MASK) as u32) << OFFSET;
622 self.w
623 }
624}
625impl R {
626 #[doc = r" Value of the register as raw bits"]
627 #[inline]
628 pub fn bits(&self) -> u32 {
629 self.bits
630 }
631 #[doc = "Bit 19 - CBURSTRW"]
632 #[inline]
633 pub fn cburstrw(&self) -> CBURSTRWR {
634 let bits = {
635 const MASK: bool = true;
636 const OFFSET: u8 = 19;
637 ((self.bits >> OFFSET) & MASK as u32) != 0
638 };
639 CBURSTRWR { bits }
640 }
641 #[doc = "Bit 15 - ASYNCWAIT"]
642 #[inline]
643 pub fn asyncwait(&self) -> ASYNCWAITR {
644 let bits = {
645 const MASK: bool = true;
646 const OFFSET: u8 = 15;
647 ((self.bits >> OFFSET) & MASK as u32) != 0
648 };
649 ASYNCWAITR { bits }
650 }
651 #[doc = "Bit 14 - EXTMOD"]
652 #[inline]
653 pub fn extmod(&self) -> EXTMODR {
654 let bits = {
655 const MASK: bool = true;
656 const OFFSET: u8 = 14;
657 ((self.bits >> OFFSET) & MASK as u32) != 0
658 };
659 EXTMODR { bits }
660 }
661 #[doc = "Bit 13 - WAITEN"]
662 #[inline]
663 pub fn waiten(&self) -> WAITENR {
664 let bits = {
665 const MASK: bool = true;
666 const OFFSET: u8 = 13;
667 ((self.bits >> OFFSET) & MASK as u32) != 0
668 };
669 WAITENR { bits }
670 }
671 #[doc = "Bit 12 - WREN"]
672 #[inline]
673 pub fn wren(&self) -> WRENR {
674 let bits = {
675 const MASK: bool = true;
676 const OFFSET: u8 = 12;
677 ((self.bits >> OFFSET) & MASK as u32) != 0
678 };
679 WRENR { bits }
680 }
681 #[doc = "Bit 11 - WAITCFG"]
682 #[inline]
683 pub fn waitcfg(&self) -> WAITCFGR {
684 let bits = {
685 const MASK: bool = true;
686 const OFFSET: u8 = 11;
687 ((self.bits >> OFFSET) & MASK as u32) != 0
688 };
689 WAITCFGR { bits }
690 }
691 #[doc = "Bit 10 - WRAPMOD"]
692 #[inline]
693 pub fn wrapmod(&self) -> WRAPMODR {
694 let bits = {
695 const MASK: bool = true;
696 const OFFSET: u8 = 10;
697 ((self.bits >> OFFSET) & MASK as u32) != 0
698 };
699 WRAPMODR { bits }
700 }
701 #[doc = "Bit 9 - WAITPOL"]
702 #[inline]
703 pub fn waitpol(&self) -> WAITPOLR {
704 let bits = {
705 const MASK: bool = true;
706 const OFFSET: u8 = 9;
707 ((self.bits >> OFFSET) & MASK as u32) != 0
708 };
709 WAITPOLR { bits }
710 }
711 #[doc = "Bit 8 - BURSTEN"]
712 #[inline]
713 pub fn bursten(&self) -> BURSTENR {
714 let bits = {
715 const MASK: bool = true;
716 const OFFSET: u8 = 8;
717 ((self.bits >> OFFSET) & MASK as u32) != 0
718 };
719 BURSTENR { bits }
720 }
721 #[doc = "Bit 6 - FACCEN"]
722 #[inline]
723 pub fn faccen(&self) -> FACCENR {
724 let bits = {
725 const MASK: bool = true;
726 const OFFSET: u8 = 6;
727 ((self.bits >> OFFSET) & MASK as u32) != 0
728 };
729 FACCENR { bits }
730 }
731 #[doc = "Bits 4:5 - MWID"]
732 #[inline]
733 pub fn mwid(&self) -> MWIDR {
734 let bits = {
735 const MASK: u8 = 3;
736 const OFFSET: u8 = 4;
737 ((self.bits >> OFFSET) & MASK as u32) as u8
738 };
739 MWIDR { bits }
740 }
741 #[doc = "Bits 2:3 - MTYP"]
742 #[inline]
743 pub fn mtyp(&self) -> MTYPR {
744 let bits = {
745 const MASK: u8 = 3;
746 const OFFSET: u8 = 2;
747 ((self.bits >> OFFSET) & MASK as u32) as u8
748 };
749 MTYPR { bits }
750 }
751 #[doc = "Bit 1 - MUXEN"]
752 #[inline]
753 pub fn muxen(&self) -> MUXENR {
754 let bits = {
755 const MASK: bool = true;
756 const OFFSET: u8 = 1;
757 ((self.bits >> OFFSET) & MASK as u32) != 0
758 };
759 MUXENR { bits }
760 }
761 #[doc = "Bit 0 - MBKEN"]
762 #[inline]
763 pub fn mbken(&self) -> MBKENR {
764 let bits = {
765 const MASK: bool = true;
766 const OFFSET: u8 = 0;
767 ((self.bits >> OFFSET) & MASK as u32) != 0
768 };
769 MBKENR { bits }
770 }
771}
772impl W {
773 #[doc = r" Reset value of the register"]
774 #[inline]
775 pub fn reset_value() -> W {
776 W { bits: 12496 }
777 }
778 #[doc = r" Writes raw bits to the register"]
779 #[inline]
780 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
781 self.bits = bits;
782 self
783 }
784 #[doc = "Bit 19 - CBURSTRW"]
785 #[inline]
786 pub fn cburstrw(&mut self) -> _CBURSTRWW {
787 _CBURSTRWW { w: self }
788 }
789 #[doc = "Bit 15 - ASYNCWAIT"]
790 #[inline]
791 pub fn asyncwait(&mut self) -> _ASYNCWAITW {
792 _ASYNCWAITW { w: self }
793 }
794 #[doc = "Bit 14 - EXTMOD"]
795 #[inline]
796 pub fn extmod(&mut self) -> _EXTMODW {
797 _EXTMODW { w: self }
798 }
799 #[doc = "Bit 13 - WAITEN"]
800 #[inline]
801 pub fn waiten(&mut self) -> _WAITENW {
802 _WAITENW { w: self }
803 }
804 #[doc = "Bit 12 - WREN"]
805 #[inline]
806 pub fn wren(&mut self) -> _WRENW {
807 _WRENW { w: self }
808 }
809 #[doc = "Bit 11 - WAITCFG"]
810 #[inline]
811 pub fn waitcfg(&mut self) -> _WAITCFGW {
812 _WAITCFGW { w: self }
813 }
814 #[doc = "Bit 10 - WRAPMOD"]
815 #[inline]
816 pub fn wrapmod(&mut self) -> _WRAPMODW {
817 _WRAPMODW { w: self }
818 }
819 #[doc = "Bit 9 - WAITPOL"]
820 #[inline]
821 pub fn waitpol(&mut self) -> _WAITPOLW {
822 _WAITPOLW { w: self }
823 }
824 #[doc = "Bit 8 - BURSTEN"]
825 #[inline]
826 pub fn bursten(&mut self) -> _BURSTENW {
827 _BURSTENW { w: self }
828 }
829 #[doc = "Bit 6 - FACCEN"]
830 #[inline]
831 pub fn faccen(&mut self) -> _FACCENW {
832 _FACCENW { w: self }
833 }
834 #[doc = "Bits 4:5 - MWID"]
835 #[inline]
836 pub fn mwid(&mut self) -> _MWIDW {
837 _MWIDW { w: self }
838 }
839 #[doc = "Bits 2:3 - MTYP"]
840 #[inline]
841 pub fn mtyp(&mut self) -> _MTYPW {
842 _MTYPW { w: self }
843 }
844 #[doc = "Bit 1 - MUXEN"]
845 #[inline]
846 pub fn muxen(&mut self) -> _MUXENW {
847 _MUXENW { w: self }
848 }
849 #[doc = "Bit 0 - MBKEN"]
850 #[inline]
851 pub fn mbken(&mut self) -> _MBKENW {
852 _MBKENW { w: self }
853 }
854}