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::AFRL {
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 = "Possible values of the field `AFRL7`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum AFRL7R {
48 #[doc = "AF0"]
49 AF0,
50 #[doc = "AF1"]
51 AF1,
52 #[doc = "AF2"]
53 AF2,
54 #[doc = "AF3"]
55 AF3,
56 #[doc = "AF4"]
57 AF4,
58 #[doc = "AF5"]
59 AF5,
60 #[doc = "AF6"]
61 AF6,
62 #[doc = "AF7"]
63 AF7,
64 #[doc = "AF8"]
65 AF8,
66 #[doc = "AF9"]
67 AF9,
68 #[doc = "AF10"]
69 AF10,
70 #[doc = "AF11"]
71 AF11,
72 #[doc = "AF12"]
73 AF12,
74 #[doc = "AF13"]
75 AF13,
76 #[doc = "AF14"]
77 AF14,
78 #[doc = "AF15"]
79 AF15,
80}
81impl AFRL7R {
82 #[doc = r" Value of the field as raw bits"]
83 #[inline]
84 pub fn bits(&self) -> u8 {
85 match *self {
86 AFRL7R::AF0 => 0,
87 AFRL7R::AF1 => 1,
88 AFRL7R::AF2 => 2,
89 AFRL7R::AF3 => 3,
90 AFRL7R::AF4 => 4,
91 AFRL7R::AF5 => 5,
92 AFRL7R::AF6 => 6,
93 AFRL7R::AF7 => 7,
94 AFRL7R::AF8 => 8,
95 AFRL7R::AF9 => 9,
96 AFRL7R::AF10 => 10,
97 AFRL7R::AF11 => 11,
98 AFRL7R::AF12 => 12,
99 AFRL7R::AF13 => 13,
100 AFRL7R::AF14 => 14,
101 AFRL7R::AF15 => 15,
102 }
103 }
104 #[allow(missing_docs)]
105 #[doc(hidden)]
106 #[inline]
107 pub fn _from(value: u8) -> AFRL7R {
108 match value {
109 0 => AFRL7R::AF0,
110 1 => AFRL7R::AF1,
111 2 => AFRL7R::AF2,
112 3 => AFRL7R::AF3,
113 4 => AFRL7R::AF4,
114 5 => AFRL7R::AF5,
115 6 => AFRL7R::AF6,
116 7 => AFRL7R::AF7,
117 8 => AFRL7R::AF8,
118 9 => AFRL7R::AF9,
119 10 => AFRL7R::AF10,
120 11 => AFRL7R::AF11,
121 12 => AFRL7R::AF12,
122 13 => AFRL7R::AF13,
123 14 => AFRL7R::AF14,
124 15 => AFRL7R::AF15,
125 _ => unreachable!(),
126 }
127 }
128 #[doc = "Checks if the value of the field is `AF0`"]
129 #[inline]
130 pub fn is_af0(&self) -> bool {
131 *self == AFRL7R::AF0
132 }
133 #[doc = "Checks if the value of the field is `AF1`"]
134 #[inline]
135 pub fn is_af1(&self) -> bool {
136 *self == AFRL7R::AF1
137 }
138 #[doc = "Checks if the value of the field is `AF2`"]
139 #[inline]
140 pub fn is_af2(&self) -> bool {
141 *self == AFRL7R::AF2
142 }
143 #[doc = "Checks if the value of the field is `AF3`"]
144 #[inline]
145 pub fn is_af3(&self) -> bool {
146 *self == AFRL7R::AF3
147 }
148 #[doc = "Checks if the value of the field is `AF4`"]
149 #[inline]
150 pub fn is_af4(&self) -> bool {
151 *self == AFRL7R::AF4
152 }
153 #[doc = "Checks if the value of the field is `AF5`"]
154 #[inline]
155 pub fn is_af5(&self) -> bool {
156 *self == AFRL7R::AF5
157 }
158 #[doc = "Checks if the value of the field is `AF6`"]
159 #[inline]
160 pub fn is_af6(&self) -> bool {
161 *self == AFRL7R::AF6
162 }
163 #[doc = "Checks if the value of the field is `AF7`"]
164 #[inline]
165 pub fn is_af7(&self) -> bool {
166 *self == AFRL7R::AF7
167 }
168 #[doc = "Checks if the value of the field is `AF8`"]
169 #[inline]
170 pub fn is_af8(&self) -> bool {
171 *self == AFRL7R::AF8
172 }
173 #[doc = "Checks if the value of the field is `AF9`"]
174 #[inline]
175 pub fn is_af9(&self) -> bool {
176 *self == AFRL7R::AF9
177 }
178 #[doc = "Checks if the value of the field is `AF10`"]
179 #[inline]
180 pub fn is_af10(&self) -> bool {
181 *self == AFRL7R::AF10
182 }
183 #[doc = "Checks if the value of the field is `AF11`"]
184 #[inline]
185 pub fn is_af11(&self) -> bool {
186 *self == AFRL7R::AF11
187 }
188 #[doc = "Checks if the value of the field is `AF12`"]
189 #[inline]
190 pub fn is_af12(&self) -> bool {
191 *self == AFRL7R::AF12
192 }
193 #[doc = "Checks if the value of the field is `AF13`"]
194 #[inline]
195 pub fn is_af13(&self) -> bool {
196 *self == AFRL7R::AF13
197 }
198 #[doc = "Checks if the value of the field is `AF14`"]
199 #[inline]
200 pub fn is_af14(&self) -> bool {
201 *self == AFRL7R::AF14
202 }
203 #[doc = "Checks if the value of the field is `AF15`"]
204 #[inline]
205 pub fn is_af15(&self) -> bool {
206 *self == AFRL7R::AF15
207 }
208}
209#[doc = "Possible values of the field `AFRL6`"]
210pub type AFRL6R = AFRL7R;
211#[doc = "Possible values of the field `AFRL5`"]
212pub type AFRL5R = AFRL7R;
213#[doc = "Possible values of the field `AFRL4`"]
214pub type AFRL4R = AFRL7R;
215#[doc = "Possible values of the field `AFRL3`"]
216pub type AFRL3R = AFRL7R;
217#[doc = "Possible values of the field `AFRL2`"]
218pub type AFRL2R = AFRL7R;
219#[doc = "Possible values of the field `AFRL1`"]
220pub type AFRL1R = AFRL7R;
221#[doc = "Possible values of the field `AFRL0`"]
222pub type AFRL0R = AFRL7R;
223#[doc = "Values that can be written to the field `AFRL7`"]
224pub enum AFRL7W {
225 #[doc = "AF0"]
226 AF0,
227 #[doc = "AF1"]
228 AF1,
229 #[doc = "AF2"]
230 AF2,
231 #[doc = "AF3"]
232 AF3,
233 #[doc = "AF4"]
234 AF4,
235 #[doc = "AF5"]
236 AF5,
237 #[doc = "AF6"]
238 AF6,
239 #[doc = "AF7"]
240 AF7,
241 #[doc = "AF8"]
242 AF8,
243 #[doc = "AF9"]
244 AF9,
245 #[doc = "AF10"]
246 AF10,
247 #[doc = "AF11"]
248 AF11,
249 #[doc = "AF12"]
250 AF12,
251 #[doc = "AF13"]
252 AF13,
253 #[doc = "AF14"]
254 AF14,
255 #[doc = "AF15"]
256 AF15,
257}
258impl AFRL7W {
259 #[allow(missing_docs)]
260 #[doc(hidden)]
261 #[inline]
262 pub fn _bits(&self) -> u8 {
263 match *self {
264 AFRL7W::AF0 => 0,
265 AFRL7W::AF1 => 1,
266 AFRL7W::AF2 => 2,
267 AFRL7W::AF3 => 3,
268 AFRL7W::AF4 => 4,
269 AFRL7W::AF5 => 5,
270 AFRL7W::AF6 => 6,
271 AFRL7W::AF7 => 7,
272 AFRL7W::AF8 => 8,
273 AFRL7W::AF9 => 9,
274 AFRL7W::AF10 => 10,
275 AFRL7W::AF11 => 11,
276 AFRL7W::AF12 => 12,
277 AFRL7W::AF13 => 13,
278 AFRL7W::AF14 => 14,
279 AFRL7W::AF15 => 15,
280 }
281 }
282}
283#[doc = r" Proxy"]
284pub struct _AFRL7W<'a> {
285 w: &'a mut W,
286}
287impl<'a> _AFRL7W<'a> {
288 #[doc = r" Writes `variant` to the field"]
289 #[inline]
290 pub fn variant(self, variant: AFRL7W) -> &'a mut W {
291 {
292 self.bits(variant._bits())
293 }
294 }
295 #[doc = "AF0"]
296 #[inline]
297 pub fn af0(self) -> &'a mut W {
298 self.variant(AFRL7W::AF0)
299 }
300 #[doc = "AF1"]
301 #[inline]
302 pub fn af1(self) -> &'a mut W {
303 self.variant(AFRL7W::AF1)
304 }
305 #[doc = "AF2"]
306 #[inline]
307 pub fn af2(self) -> &'a mut W {
308 self.variant(AFRL7W::AF2)
309 }
310 #[doc = "AF3"]
311 #[inline]
312 pub fn af3(self) -> &'a mut W {
313 self.variant(AFRL7W::AF3)
314 }
315 #[doc = "AF4"]
316 #[inline]
317 pub fn af4(self) -> &'a mut W {
318 self.variant(AFRL7W::AF4)
319 }
320 #[doc = "AF5"]
321 #[inline]
322 pub fn af5(self) -> &'a mut W {
323 self.variant(AFRL7W::AF5)
324 }
325 #[doc = "AF6"]
326 #[inline]
327 pub fn af6(self) -> &'a mut W {
328 self.variant(AFRL7W::AF6)
329 }
330 #[doc = "AF7"]
331 #[inline]
332 pub fn af7(self) -> &'a mut W {
333 self.variant(AFRL7W::AF7)
334 }
335 #[doc = "AF8"]
336 #[inline]
337 pub fn af8(self) -> &'a mut W {
338 self.variant(AFRL7W::AF8)
339 }
340 #[doc = "AF9"]
341 #[inline]
342 pub fn af9(self) -> &'a mut W {
343 self.variant(AFRL7W::AF9)
344 }
345 #[doc = "AF10"]
346 #[inline]
347 pub fn af10(self) -> &'a mut W {
348 self.variant(AFRL7W::AF10)
349 }
350 #[doc = "AF11"]
351 #[inline]
352 pub fn af11(self) -> &'a mut W {
353 self.variant(AFRL7W::AF11)
354 }
355 #[doc = "AF12"]
356 #[inline]
357 pub fn af12(self) -> &'a mut W {
358 self.variant(AFRL7W::AF12)
359 }
360 #[doc = "AF13"]
361 #[inline]
362 pub fn af13(self) -> &'a mut W {
363 self.variant(AFRL7W::AF13)
364 }
365 #[doc = "AF14"]
366 #[inline]
367 pub fn af14(self) -> &'a mut W {
368 self.variant(AFRL7W::AF14)
369 }
370 #[doc = "AF15"]
371 #[inline]
372 pub fn af15(self) -> &'a mut W {
373 self.variant(AFRL7W::AF15)
374 }
375 #[doc = r" Writes raw bits to the field"]
376 #[inline]
377 pub fn bits(self, value: u8) -> &'a mut W {
378 const MASK: u8 = 15;
379 const OFFSET: u8 = 28;
380 self.w.bits &= !((MASK as u32) << OFFSET);
381 self.w.bits |= ((value & MASK) as u32) << OFFSET;
382 self.w
383 }
384}
385#[doc = "Values that can be written to the field `AFRL6`"]
386pub type AFRL6W = AFRL7W;
387#[doc = r" Proxy"]
388pub struct _AFRL6W<'a> {
389 w: &'a mut W,
390}
391impl<'a> _AFRL6W<'a> {
392 #[doc = r" Writes `variant` to the field"]
393 #[inline]
394 pub fn variant(self, variant: AFRL6W) -> &'a mut W {
395 {
396 self.bits(variant._bits())
397 }
398 }
399 #[doc = "AF0"]
400 #[inline]
401 pub fn af0(self) -> &'a mut W {
402 self.variant(AFRL7W::AF0)
403 }
404 #[doc = "AF1"]
405 #[inline]
406 pub fn af1(self) -> &'a mut W {
407 self.variant(AFRL7W::AF1)
408 }
409 #[doc = "AF2"]
410 #[inline]
411 pub fn af2(self) -> &'a mut W {
412 self.variant(AFRL7W::AF2)
413 }
414 #[doc = "AF3"]
415 #[inline]
416 pub fn af3(self) -> &'a mut W {
417 self.variant(AFRL7W::AF3)
418 }
419 #[doc = "AF4"]
420 #[inline]
421 pub fn af4(self) -> &'a mut W {
422 self.variant(AFRL7W::AF4)
423 }
424 #[doc = "AF5"]
425 #[inline]
426 pub fn af5(self) -> &'a mut W {
427 self.variant(AFRL7W::AF5)
428 }
429 #[doc = "AF6"]
430 #[inline]
431 pub fn af6(self) -> &'a mut W {
432 self.variant(AFRL7W::AF6)
433 }
434 #[doc = "AF7"]
435 #[inline]
436 pub fn af7(self) -> &'a mut W {
437 self.variant(AFRL7W::AF7)
438 }
439 #[doc = "AF8"]
440 #[inline]
441 pub fn af8(self) -> &'a mut W {
442 self.variant(AFRL7W::AF8)
443 }
444 #[doc = "AF9"]
445 #[inline]
446 pub fn af9(self) -> &'a mut W {
447 self.variant(AFRL7W::AF9)
448 }
449 #[doc = "AF10"]
450 #[inline]
451 pub fn af10(self) -> &'a mut W {
452 self.variant(AFRL7W::AF10)
453 }
454 #[doc = "AF11"]
455 #[inline]
456 pub fn af11(self) -> &'a mut W {
457 self.variant(AFRL7W::AF11)
458 }
459 #[doc = "AF12"]
460 #[inline]
461 pub fn af12(self) -> &'a mut W {
462 self.variant(AFRL7W::AF12)
463 }
464 #[doc = "AF13"]
465 #[inline]
466 pub fn af13(self) -> &'a mut W {
467 self.variant(AFRL7W::AF13)
468 }
469 #[doc = "AF14"]
470 #[inline]
471 pub fn af14(self) -> &'a mut W {
472 self.variant(AFRL7W::AF14)
473 }
474 #[doc = "AF15"]
475 #[inline]
476 pub fn af15(self) -> &'a mut W {
477 self.variant(AFRL7W::AF15)
478 }
479 #[doc = r" Writes raw bits to the field"]
480 #[inline]
481 pub fn bits(self, value: u8) -> &'a mut W {
482 const MASK: u8 = 15;
483 const OFFSET: u8 = 24;
484 self.w.bits &= !((MASK as u32) << OFFSET);
485 self.w.bits |= ((value & MASK) as u32) << OFFSET;
486 self.w
487 }
488}
489#[doc = "Values that can be written to the field `AFRL5`"]
490pub type AFRL5W = AFRL7W;
491#[doc = r" Proxy"]
492pub struct _AFRL5W<'a> {
493 w: &'a mut W,
494}
495impl<'a> _AFRL5W<'a> {
496 #[doc = r" Writes `variant` to the field"]
497 #[inline]
498 pub fn variant(self, variant: AFRL5W) -> &'a mut W {
499 {
500 self.bits(variant._bits())
501 }
502 }
503 #[doc = "AF0"]
504 #[inline]
505 pub fn af0(self) -> &'a mut W {
506 self.variant(AFRL7W::AF0)
507 }
508 #[doc = "AF1"]
509 #[inline]
510 pub fn af1(self) -> &'a mut W {
511 self.variant(AFRL7W::AF1)
512 }
513 #[doc = "AF2"]
514 #[inline]
515 pub fn af2(self) -> &'a mut W {
516 self.variant(AFRL7W::AF2)
517 }
518 #[doc = "AF3"]
519 #[inline]
520 pub fn af3(self) -> &'a mut W {
521 self.variant(AFRL7W::AF3)
522 }
523 #[doc = "AF4"]
524 #[inline]
525 pub fn af4(self) -> &'a mut W {
526 self.variant(AFRL7W::AF4)
527 }
528 #[doc = "AF5"]
529 #[inline]
530 pub fn af5(self) -> &'a mut W {
531 self.variant(AFRL7W::AF5)
532 }
533 #[doc = "AF6"]
534 #[inline]
535 pub fn af6(self) -> &'a mut W {
536 self.variant(AFRL7W::AF6)
537 }
538 #[doc = "AF7"]
539 #[inline]
540 pub fn af7(self) -> &'a mut W {
541 self.variant(AFRL7W::AF7)
542 }
543 #[doc = "AF8"]
544 #[inline]
545 pub fn af8(self) -> &'a mut W {
546 self.variant(AFRL7W::AF8)
547 }
548 #[doc = "AF9"]
549 #[inline]
550 pub fn af9(self) -> &'a mut W {
551 self.variant(AFRL7W::AF9)
552 }
553 #[doc = "AF10"]
554 #[inline]
555 pub fn af10(self) -> &'a mut W {
556 self.variant(AFRL7W::AF10)
557 }
558 #[doc = "AF11"]
559 #[inline]
560 pub fn af11(self) -> &'a mut W {
561 self.variant(AFRL7W::AF11)
562 }
563 #[doc = "AF12"]
564 #[inline]
565 pub fn af12(self) -> &'a mut W {
566 self.variant(AFRL7W::AF12)
567 }
568 #[doc = "AF13"]
569 #[inline]
570 pub fn af13(self) -> &'a mut W {
571 self.variant(AFRL7W::AF13)
572 }
573 #[doc = "AF14"]
574 #[inline]
575 pub fn af14(self) -> &'a mut W {
576 self.variant(AFRL7W::AF14)
577 }
578 #[doc = "AF15"]
579 #[inline]
580 pub fn af15(self) -> &'a mut W {
581 self.variant(AFRL7W::AF15)
582 }
583 #[doc = r" Writes raw bits to the field"]
584 #[inline]
585 pub fn bits(self, value: u8) -> &'a mut W {
586 const MASK: u8 = 15;
587 const OFFSET: u8 = 20;
588 self.w.bits &= !((MASK as u32) << OFFSET);
589 self.w.bits |= ((value & MASK) as u32) << OFFSET;
590 self.w
591 }
592}
593#[doc = "Values that can be written to the field `AFRL4`"]
594pub type AFRL4W = AFRL7W;
595#[doc = r" Proxy"]
596pub struct _AFRL4W<'a> {
597 w: &'a mut W,
598}
599impl<'a> _AFRL4W<'a> {
600 #[doc = r" Writes `variant` to the field"]
601 #[inline]
602 pub fn variant(self, variant: AFRL4W) -> &'a mut W {
603 {
604 self.bits(variant._bits())
605 }
606 }
607 #[doc = "AF0"]
608 #[inline]
609 pub fn af0(self) -> &'a mut W {
610 self.variant(AFRL7W::AF0)
611 }
612 #[doc = "AF1"]
613 #[inline]
614 pub fn af1(self) -> &'a mut W {
615 self.variant(AFRL7W::AF1)
616 }
617 #[doc = "AF2"]
618 #[inline]
619 pub fn af2(self) -> &'a mut W {
620 self.variant(AFRL7W::AF2)
621 }
622 #[doc = "AF3"]
623 #[inline]
624 pub fn af3(self) -> &'a mut W {
625 self.variant(AFRL7W::AF3)
626 }
627 #[doc = "AF4"]
628 #[inline]
629 pub fn af4(self) -> &'a mut W {
630 self.variant(AFRL7W::AF4)
631 }
632 #[doc = "AF5"]
633 #[inline]
634 pub fn af5(self) -> &'a mut W {
635 self.variant(AFRL7W::AF5)
636 }
637 #[doc = "AF6"]
638 #[inline]
639 pub fn af6(self) -> &'a mut W {
640 self.variant(AFRL7W::AF6)
641 }
642 #[doc = "AF7"]
643 #[inline]
644 pub fn af7(self) -> &'a mut W {
645 self.variant(AFRL7W::AF7)
646 }
647 #[doc = "AF8"]
648 #[inline]
649 pub fn af8(self) -> &'a mut W {
650 self.variant(AFRL7W::AF8)
651 }
652 #[doc = "AF9"]
653 #[inline]
654 pub fn af9(self) -> &'a mut W {
655 self.variant(AFRL7W::AF9)
656 }
657 #[doc = "AF10"]
658 #[inline]
659 pub fn af10(self) -> &'a mut W {
660 self.variant(AFRL7W::AF10)
661 }
662 #[doc = "AF11"]
663 #[inline]
664 pub fn af11(self) -> &'a mut W {
665 self.variant(AFRL7W::AF11)
666 }
667 #[doc = "AF12"]
668 #[inline]
669 pub fn af12(self) -> &'a mut W {
670 self.variant(AFRL7W::AF12)
671 }
672 #[doc = "AF13"]
673 #[inline]
674 pub fn af13(self) -> &'a mut W {
675 self.variant(AFRL7W::AF13)
676 }
677 #[doc = "AF14"]
678 #[inline]
679 pub fn af14(self) -> &'a mut W {
680 self.variant(AFRL7W::AF14)
681 }
682 #[doc = "AF15"]
683 #[inline]
684 pub fn af15(self) -> &'a mut W {
685 self.variant(AFRL7W::AF15)
686 }
687 #[doc = r" Writes raw bits to the field"]
688 #[inline]
689 pub fn bits(self, value: u8) -> &'a mut W {
690 const MASK: u8 = 15;
691 const OFFSET: u8 = 16;
692 self.w.bits &= !((MASK as u32) << OFFSET);
693 self.w.bits |= ((value & MASK) as u32) << OFFSET;
694 self.w
695 }
696}
697#[doc = "Values that can be written to the field `AFRL3`"]
698pub type AFRL3W = AFRL7W;
699#[doc = r" Proxy"]
700pub struct _AFRL3W<'a> {
701 w: &'a mut W,
702}
703impl<'a> _AFRL3W<'a> {
704 #[doc = r" Writes `variant` to the field"]
705 #[inline]
706 pub fn variant(self, variant: AFRL3W) -> &'a mut W {
707 {
708 self.bits(variant._bits())
709 }
710 }
711 #[doc = "AF0"]
712 #[inline]
713 pub fn af0(self) -> &'a mut W {
714 self.variant(AFRL7W::AF0)
715 }
716 #[doc = "AF1"]
717 #[inline]
718 pub fn af1(self) -> &'a mut W {
719 self.variant(AFRL7W::AF1)
720 }
721 #[doc = "AF2"]
722 #[inline]
723 pub fn af2(self) -> &'a mut W {
724 self.variant(AFRL7W::AF2)
725 }
726 #[doc = "AF3"]
727 #[inline]
728 pub fn af3(self) -> &'a mut W {
729 self.variant(AFRL7W::AF3)
730 }
731 #[doc = "AF4"]
732 #[inline]
733 pub fn af4(self) -> &'a mut W {
734 self.variant(AFRL7W::AF4)
735 }
736 #[doc = "AF5"]
737 #[inline]
738 pub fn af5(self) -> &'a mut W {
739 self.variant(AFRL7W::AF5)
740 }
741 #[doc = "AF6"]
742 #[inline]
743 pub fn af6(self) -> &'a mut W {
744 self.variant(AFRL7W::AF6)
745 }
746 #[doc = "AF7"]
747 #[inline]
748 pub fn af7(self) -> &'a mut W {
749 self.variant(AFRL7W::AF7)
750 }
751 #[doc = "AF8"]
752 #[inline]
753 pub fn af8(self) -> &'a mut W {
754 self.variant(AFRL7W::AF8)
755 }
756 #[doc = "AF9"]
757 #[inline]
758 pub fn af9(self) -> &'a mut W {
759 self.variant(AFRL7W::AF9)
760 }
761 #[doc = "AF10"]
762 #[inline]
763 pub fn af10(self) -> &'a mut W {
764 self.variant(AFRL7W::AF10)
765 }
766 #[doc = "AF11"]
767 #[inline]
768 pub fn af11(self) -> &'a mut W {
769 self.variant(AFRL7W::AF11)
770 }
771 #[doc = "AF12"]
772 #[inline]
773 pub fn af12(self) -> &'a mut W {
774 self.variant(AFRL7W::AF12)
775 }
776 #[doc = "AF13"]
777 #[inline]
778 pub fn af13(self) -> &'a mut W {
779 self.variant(AFRL7W::AF13)
780 }
781 #[doc = "AF14"]
782 #[inline]
783 pub fn af14(self) -> &'a mut W {
784 self.variant(AFRL7W::AF14)
785 }
786 #[doc = "AF15"]
787 #[inline]
788 pub fn af15(self) -> &'a mut W {
789 self.variant(AFRL7W::AF15)
790 }
791 #[doc = r" Writes raw bits to the field"]
792 #[inline]
793 pub fn bits(self, value: u8) -> &'a mut W {
794 const MASK: u8 = 15;
795 const OFFSET: u8 = 12;
796 self.w.bits &= !((MASK as u32) << OFFSET);
797 self.w.bits |= ((value & MASK) as u32) << OFFSET;
798 self.w
799 }
800}
801#[doc = "Values that can be written to the field `AFRL2`"]
802pub type AFRL2W = AFRL7W;
803#[doc = r" Proxy"]
804pub struct _AFRL2W<'a> {
805 w: &'a mut W,
806}
807impl<'a> _AFRL2W<'a> {
808 #[doc = r" Writes `variant` to the field"]
809 #[inline]
810 pub fn variant(self, variant: AFRL2W) -> &'a mut W {
811 {
812 self.bits(variant._bits())
813 }
814 }
815 #[doc = "AF0"]
816 #[inline]
817 pub fn af0(self) -> &'a mut W {
818 self.variant(AFRL7W::AF0)
819 }
820 #[doc = "AF1"]
821 #[inline]
822 pub fn af1(self) -> &'a mut W {
823 self.variant(AFRL7W::AF1)
824 }
825 #[doc = "AF2"]
826 #[inline]
827 pub fn af2(self) -> &'a mut W {
828 self.variant(AFRL7W::AF2)
829 }
830 #[doc = "AF3"]
831 #[inline]
832 pub fn af3(self) -> &'a mut W {
833 self.variant(AFRL7W::AF3)
834 }
835 #[doc = "AF4"]
836 #[inline]
837 pub fn af4(self) -> &'a mut W {
838 self.variant(AFRL7W::AF4)
839 }
840 #[doc = "AF5"]
841 #[inline]
842 pub fn af5(self) -> &'a mut W {
843 self.variant(AFRL7W::AF5)
844 }
845 #[doc = "AF6"]
846 #[inline]
847 pub fn af6(self) -> &'a mut W {
848 self.variant(AFRL7W::AF6)
849 }
850 #[doc = "AF7"]
851 #[inline]
852 pub fn af7(self) -> &'a mut W {
853 self.variant(AFRL7W::AF7)
854 }
855 #[doc = "AF8"]
856 #[inline]
857 pub fn af8(self) -> &'a mut W {
858 self.variant(AFRL7W::AF8)
859 }
860 #[doc = "AF9"]
861 #[inline]
862 pub fn af9(self) -> &'a mut W {
863 self.variant(AFRL7W::AF9)
864 }
865 #[doc = "AF10"]
866 #[inline]
867 pub fn af10(self) -> &'a mut W {
868 self.variant(AFRL7W::AF10)
869 }
870 #[doc = "AF11"]
871 #[inline]
872 pub fn af11(self) -> &'a mut W {
873 self.variant(AFRL7W::AF11)
874 }
875 #[doc = "AF12"]
876 #[inline]
877 pub fn af12(self) -> &'a mut W {
878 self.variant(AFRL7W::AF12)
879 }
880 #[doc = "AF13"]
881 #[inline]
882 pub fn af13(self) -> &'a mut W {
883 self.variant(AFRL7W::AF13)
884 }
885 #[doc = "AF14"]
886 #[inline]
887 pub fn af14(self) -> &'a mut W {
888 self.variant(AFRL7W::AF14)
889 }
890 #[doc = "AF15"]
891 #[inline]
892 pub fn af15(self) -> &'a mut W {
893 self.variant(AFRL7W::AF15)
894 }
895 #[doc = r" Writes raw bits to the field"]
896 #[inline]
897 pub fn bits(self, value: u8) -> &'a mut W {
898 const MASK: u8 = 15;
899 const OFFSET: u8 = 8;
900 self.w.bits &= !((MASK as u32) << OFFSET);
901 self.w.bits |= ((value & MASK) as u32) << OFFSET;
902 self.w
903 }
904}
905#[doc = "Values that can be written to the field `AFRL1`"]
906pub type AFRL1W = AFRL7W;
907#[doc = r" Proxy"]
908pub struct _AFRL1W<'a> {
909 w: &'a mut W,
910}
911impl<'a> _AFRL1W<'a> {
912 #[doc = r" Writes `variant` to the field"]
913 #[inline]
914 pub fn variant(self, variant: AFRL1W) -> &'a mut W {
915 {
916 self.bits(variant._bits())
917 }
918 }
919 #[doc = "AF0"]
920 #[inline]
921 pub fn af0(self) -> &'a mut W {
922 self.variant(AFRL7W::AF0)
923 }
924 #[doc = "AF1"]
925 #[inline]
926 pub fn af1(self) -> &'a mut W {
927 self.variant(AFRL7W::AF1)
928 }
929 #[doc = "AF2"]
930 #[inline]
931 pub fn af2(self) -> &'a mut W {
932 self.variant(AFRL7W::AF2)
933 }
934 #[doc = "AF3"]
935 #[inline]
936 pub fn af3(self) -> &'a mut W {
937 self.variant(AFRL7W::AF3)
938 }
939 #[doc = "AF4"]
940 #[inline]
941 pub fn af4(self) -> &'a mut W {
942 self.variant(AFRL7W::AF4)
943 }
944 #[doc = "AF5"]
945 #[inline]
946 pub fn af5(self) -> &'a mut W {
947 self.variant(AFRL7W::AF5)
948 }
949 #[doc = "AF6"]
950 #[inline]
951 pub fn af6(self) -> &'a mut W {
952 self.variant(AFRL7W::AF6)
953 }
954 #[doc = "AF7"]
955 #[inline]
956 pub fn af7(self) -> &'a mut W {
957 self.variant(AFRL7W::AF7)
958 }
959 #[doc = "AF8"]
960 #[inline]
961 pub fn af8(self) -> &'a mut W {
962 self.variant(AFRL7W::AF8)
963 }
964 #[doc = "AF9"]
965 #[inline]
966 pub fn af9(self) -> &'a mut W {
967 self.variant(AFRL7W::AF9)
968 }
969 #[doc = "AF10"]
970 #[inline]
971 pub fn af10(self) -> &'a mut W {
972 self.variant(AFRL7W::AF10)
973 }
974 #[doc = "AF11"]
975 #[inline]
976 pub fn af11(self) -> &'a mut W {
977 self.variant(AFRL7W::AF11)
978 }
979 #[doc = "AF12"]
980 #[inline]
981 pub fn af12(self) -> &'a mut W {
982 self.variant(AFRL7W::AF12)
983 }
984 #[doc = "AF13"]
985 #[inline]
986 pub fn af13(self) -> &'a mut W {
987 self.variant(AFRL7W::AF13)
988 }
989 #[doc = "AF14"]
990 #[inline]
991 pub fn af14(self) -> &'a mut W {
992 self.variant(AFRL7W::AF14)
993 }
994 #[doc = "AF15"]
995 #[inline]
996 pub fn af15(self) -> &'a mut W {
997 self.variant(AFRL7W::AF15)
998 }
999 #[doc = r" Writes raw bits to the field"]
1000 #[inline]
1001 pub fn bits(self, value: u8) -> &'a mut W {
1002 const MASK: u8 = 15;
1003 const OFFSET: u8 = 4;
1004 self.w.bits &= !((MASK as u32) << OFFSET);
1005 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1006 self.w
1007 }
1008}
1009#[doc = "Values that can be written to the field `AFRL0`"]
1010pub type AFRL0W = AFRL7W;
1011#[doc = r" Proxy"]
1012pub struct _AFRL0W<'a> {
1013 w: &'a mut W,
1014}
1015impl<'a> _AFRL0W<'a> {
1016 #[doc = r" Writes `variant` to the field"]
1017 #[inline]
1018 pub fn variant(self, variant: AFRL0W) -> &'a mut W {
1019 {
1020 self.bits(variant._bits())
1021 }
1022 }
1023 #[doc = "AF0"]
1024 #[inline]
1025 pub fn af0(self) -> &'a mut W {
1026 self.variant(AFRL7W::AF0)
1027 }
1028 #[doc = "AF1"]
1029 #[inline]
1030 pub fn af1(self) -> &'a mut W {
1031 self.variant(AFRL7W::AF1)
1032 }
1033 #[doc = "AF2"]
1034 #[inline]
1035 pub fn af2(self) -> &'a mut W {
1036 self.variant(AFRL7W::AF2)
1037 }
1038 #[doc = "AF3"]
1039 #[inline]
1040 pub fn af3(self) -> &'a mut W {
1041 self.variant(AFRL7W::AF3)
1042 }
1043 #[doc = "AF4"]
1044 #[inline]
1045 pub fn af4(self) -> &'a mut W {
1046 self.variant(AFRL7W::AF4)
1047 }
1048 #[doc = "AF5"]
1049 #[inline]
1050 pub fn af5(self) -> &'a mut W {
1051 self.variant(AFRL7W::AF5)
1052 }
1053 #[doc = "AF6"]
1054 #[inline]
1055 pub fn af6(self) -> &'a mut W {
1056 self.variant(AFRL7W::AF6)
1057 }
1058 #[doc = "AF7"]
1059 #[inline]
1060 pub fn af7(self) -> &'a mut W {
1061 self.variant(AFRL7W::AF7)
1062 }
1063 #[doc = "AF8"]
1064 #[inline]
1065 pub fn af8(self) -> &'a mut W {
1066 self.variant(AFRL7W::AF8)
1067 }
1068 #[doc = "AF9"]
1069 #[inline]
1070 pub fn af9(self) -> &'a mut W {
1071 self.variant(AFRL7W::AF9)
1072 }
1073 #[doc = "AF10"]
1074 #[inline]
1075 pub fn af10(self) -> &'a mut W {
1076 self.variant(AFRL7W::AF10)
1077 }
1078 #[doc = "AF11"]
1079 #[inline]
1080 pub fn af11(self) -> &'a mut W {
1081 self.variant(AFRL7W::AF11)
1082 }
1083 #[doc = "AF12"]
1084 #[inline]
1085 pub fn af12(self) -> &'a mut W {
1086 self.variant(AFRL7W::AF12)
1087 }
1088 #[doc = "AF13"]
1089 #[inline]
1090 pub fn af13(self) -> &'a mut W {
1091 self.variant(AFRL7W::AF13)
1092 }
1093 #[doc = "AF14"]
1094 #[inline]
1095 pub fn af14(self) -> &'a mut W {
1096 self.variant(AFRL7W::AF14)
1097 }
1098 #[doc = "AF15"]
1099 #[inline]
1100 pub fn af15(self) -> &'a mut W {
1101 self.variant(AFRL7W::AF15)
1102 }
1103 #[doc = r" Writes raw bits to the field"]
1104 #[inline]
1105 pub fn bits(self, value: u8) -> &'a mut W {
1106 const MASK: u8 = 15;
1107 const OFFSET: u8 = 0;
1108 self.w.bits &= !((MASK as u32) << OFFSET);
1109 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1110 self.w
1111 }
1112}
1113impl R {
1114 #[doc = r" Value of the register as raw bits"]
1115 #[inline]
1116 pub fn bits(&self) -> u32 {
1117 self.bits
1118 }
1119 #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"]
1120 #[inline]
1121 pub fn afrl7(&self) -> AFRL7R {
1122 AFRL7R::_from({
1123 const MASK: u8 = 15;
1124 const OFFSET: u8 = 28;
1125 ((self.bits >> OFFSET) & MASK as u32) as u8
1126 })
1127 }
1128 #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"]
1129 #[inline]
1130 pub fn afrl6(&self) -> AFRL6R {
1131 AFRL6R::_from({
1132 const MASK: u8 = 15;
1133 const OFFSET: u8 = 24;
1134 ((self.bits >> OFFSET) & MASK as u32) as u8
1135 })
1136 }
1137 #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"]
1138 #[inline]
1139 pub fn afrl5(&self) -> AFRL5R {
1140 AFRL5R::_from({
1141 const MASK: u8 = 15;
1142 const OFFSET: u8 = 20;
1143 ((self.bits >> OFFSET) & MASK as u32) as u8
1144 })
1145 }
1146 #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"]
1147 #[inline]
1148 pub fn afrl4(&self) -> AFRL4R {
1149 AFRL4R::_from({
1150 const MASK: u8 = 15;
1151 const OFFSET: u8 = 16;
1152 ((self.bits >> OFFSET) & MASK as u32) as u8
1153 })
1154 }
1155 #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"]
1156 #[inline]
1157 pub fn afrl3(&self) -> AFRL3R {
1158 AFRL3R::_from({
1159 const MASK: u8 = 15;
1160 const OFFSET: u8 = 12;
1161 ((self.bits >> OFFSET) & MASK as u32) as u8
1162 })
1163 }
1164 #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"]
1165 #[inline]
1166 pub fn afrl2(&self) -> AFRL2R {
1167 AFRL2R::_from({
1168 const MASK: u8 = 15;
1169 const OFFSET: u8 = 8;
1170 ((self.bits >> OFFSET) & MASK as u32) as u8
1171 })
1172 }
1173 #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"]
1174 #[inline]
1175 pub fn afrl1(&self) -> AFRL1R {
1176 AFRL1R::_from({
1177 const MASK: u8 = 15;
1178 const OFFSET: u8 = 4;
1179 ((self.bits >> OFFSET) & MASK as u32) as u8
1180 })
1181 }
1182 #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"]
1183 #[inline]
1184 pub fn afrl0(&self) -> AFRL0R {
1185 AFRL0R::_from({
1186 const MASK: u8 = 15;
1187 const OFFSET: u8 = 0;
1188 ((self.bits >> OFFSET) & MASK as u32) as u8
1189 })
1190 }
1191}
1192impl W {
1193 #[doc = r" Reset value of the register"]
1194 #[inline]
1195 pub fn reset_value() -> W {
1196 W { bits: 0 }
1197 }
1198 #[doc = r" Writes raw bits to the register"]
1199 #[inline]
1200 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1201 self.bits = bits;
1202 self
1203 }
1204 #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"]
1205 #[inline]
1206 pub fn afrl7(&mut self) -> _AFRL7W {
1207 _AFRL7W { w: self }
1208 }
1209 #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"]
1210 #[inline]
1211 pub fn afrl6(&mut self) -> _AFRL6W {
1212 _AFRL6W { w: self }
1213 }
1214 #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"]
1215 #[inline]
1216 pub fn afrl5(&mut self) -> _AFRL5W {
1217 _AFRL5W { w: self }
1218 }
1219 #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"]
1220 #[inline]
1221 pub fn afrl4(&mut self) -> _AFRL4W {
1222 _AFRL4W { w: self }
1223 }
1224 #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"]
1225 #[inline]
1226 pub fn afrl3(&mut self) -> _AFRL3W {
1227 _AFRL3W { w: self }
1228 }
1229 #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"]
1230 #[inline]
1231 pub fn afrl2(&mut self) -> _AFRL2W {
1232 _AFRL2W { w: self }
1233 }
1234 #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"]
1235 #[inline]
1236 pub fn afrl1(&mut self) -> _AFRL1W {
1237 _AFRL1W { w: self }
1238 }
1239 #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"]
1240 #[inline]
1241 pub fn afrl0(&mut self) -> _AFRL0W {
1242 _AFRL0W { w: self }
1243 }
1244}