stm32l4x2_pac/tsc/
ioscr.rs

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::IOSCR {
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 G8_IO4R {
47    bits: bool,
48}
49impl G8_IO4R {
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 G8_IO3R {
68    bits: bool,
69}
70impl G8_IO3R {
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 G8_IO2R {
89    bits: bool,
90}
91impl G8_IO2R {
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 G8_IO1R {
110    bits: bool,
111}
112impl G8_IO1R {
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 G7_IO4R {
131    bits: bool,
132}
133impl G7_IO4R {
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 G7_IO3R {
152    bits: bool,
153}
154impl G7_IO3R {
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 G7_IO2R {
173    bits: bool,
174}
175impl G7_IO2R {
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 G7_IO1R {
194    bits: bool,
195}
196impl G7_IO1R {
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 G6_IO4R {
215    bits: bool,
216}
217impl G6_IO4R {
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 G6_IO3R {
236    bits: bool,
237}
238impl G6_IO3R {
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 G6_IO2R {
257    bits: bool,
258}
259impl G6_IO2R {
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 G6_IO1R {
278    bits: bool,
279}
280impl G6_IO1R {
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" Value of the field"]
298pub struct G5_IO4R {
299    bits: bool,
300}
301impl G5_IO4R {
302    #[doc = r" Value of the field as raw bits"]
303    #[inline]
304    pub fn bit(&self) -> bool {
305        self.bits
306    }
307    #[doc = r" Returns `true` if the bit is clear (0)"]
308    #[inline]
309    pub fn bit_is_clear(&self) -> bool {
310        !self.bit()
311    }
312    #[doc = r" Returns `true` if the bit is set (1)"]
313    #[inline]
314    pub fn bit_is_set(&self) -> bool {
315        self.bit()
316    }
317}
318#[doc = r" Value of the field"]
319pub struct G5_IO3R {
320    bits: bool,
321}
322impl G5_IO3R {
323    #[doc = r" Value of the field as raw bits"]
324    #[inline]
325    pub fn bit(&self) -> bool {
326        self.bits
327    }
328    #[doc = r" Returns `true` if the bit is clear (0)"]
329    #[inline]
330    pub fn bit_is_clear(&self) -> bool {
331        !self.bit()
332    }
333    #[doc = r" Returns `true` if the bit is set (1)"]
334    #[inline]
335    pub fn bit_is_set(&self) -> bool {
336        self.bit()
337    }
338}
339#[doc = r" Value of the field"]
340pub struct G5_IO2R {
341    bits: bool,
342}
343impl G5_IO2R {
344    #[doc = r" Value of the field as raw bits"]
345    #[inline]
346    pub fn bit(&self) -> bool {
347        self.bits
348    }
349    #[doc = r" Returns `true` if the bit is clear (0)"]
350    #[inline]
351    pub fn bit_is_clear(&self) -> bool {
352        !self.bit()
353    }
354    #[doc = r" Returns `true` if the bit is set (1)"]
355    #[inline]
356    pub fn bit_is_set(&self) -> bool {
357        self.bit()
358    }
359}
360#[doc = r" Value of the field"]
361pub struct G5_IO1R {
362    bits: bool,
363}
364impl G5_IO1R {
365    #[doc = r" Value of the field as raw bits"]
366    #[inline]
367    pub fn bit(&self) -> bool {
368        self.bits
369    }
370    #[doc = r" Returns `true` if the bit is clear (0)"]
371    #[inline]
372    pub fn bit_is_clear(&self) -> bool {
373        !self.bit()
374    }
375    #[doc = r" Returns `true` if the bit is set (1)"]
376    #[inline]
377    pub fn bit_is_set(&self) -> bool {
378        self.bit()
379    }
380}
381#[doc = r" Value of the field"]
382pub struct G4_IO4R {
383    bits: bool,
384}
385impl G4_IO4R {
386    #[doc = r" Value of the field as raw bits"]
387    #[inline]
388    pub fn bit(&self) -> bool {
389        self.bits
390    }
391    #[doc = r" Returns `true` if the bit is clear (0)"]
392    #[inline]
393    pub fn bit_is_clear(&self) -> bool {
394        !self.bit()
395    }
396    #[doc = r" Returns `true` if the bit is set (1)"]
397    #[inline]
398    pub fn bit_is_set(&self) -> bool {
399        self.bit()
400    }
401}
402#[doc = r" Value of the field"]
403pub struct G4_IO3R {
404    bits: bool,
405}
406impl G4_IO3R {
407    #[doc = r" Value of the field as raw bits"]
408    #[inline]
409    pub fn bit(&self) -> bool {
410        self.bits
411    }
412    #[doc = r" Returns `true` if the bit is clear (0)"]
413    #[inline]
414    pub fn bit_is_clear(&self) -> bool {
415        !self.bit()
416    }
417    #[doc = r" Returns `true` if the bit is set (1)"]
418    #[inline]
419    pub fn bit_is_set(&self) -> bool {
420        self.bit()
421    }
422}
423#[doc = r" Value of the field"]
424pub struct G4_IO2R {
425    bits: bool,
426}
427impl G4_IO2R {
428    #[doc = r" Value of the field as raw bits"]
429    #[inline]
430    pub fn bit(&self) -> bool {
431        self.bits
432    }
433    #[doc = r" Returns `true` if the bit is clear (0)"]
434    #[inline]
435    pub fn bit_is_clear(&self) -> bool {
436        !self.bit()
437    }
438    #[doc = r" Returns `true` if the bit is set (1)"]
439    #[inline]
440    pub fn bit_is_set(&self) -> bool {
441        self.bit()
442    }
443}
444#[doc = r" Value of the field"]
445pub struct G4_IO1R {
446    bits: bool,
447}
448impl G4_IO1R {
449    #[doc = r" Value of the field as raw bits"]
450    #[inline]
451    pub fn bit(&self) -> bool {
452        self.bits
453    }
454    #[doc = r" Returns `true` if the bit is clear (0)"]
455    #[inline]
456    pub fn bit_is_clear(&self) -> bool {
457        !self.bit()
458    }
459    #[doc = r" Returns `true` if the bit is set (1)"]
460    #[inline]
461    pub fn bit_is_set(&self) -> bool {
462        self.bit()
463    }
464}
465#[doc = r" Value of the field"]
466pub struct G3_IO4R {
467    bits: bool,
468}
469impl G3_IO4R {
470    #[doc = r" Value of the field as raw bits"]
471    #[inline]
472    pub fn bit(&self) -> bool {
473        self.bits
474    }
475    #[doc = r" Returns `true` if the bit is clear (0)"]
476    #[inline]
477    pub fn bit_is_clear(&self) -> bool {
478        !self.bit()
479    }
480    #[doc = r" Returns `true` if the bit is set (1)"]
481    #[inline]
482    pub fn bit_is_set(&self) -> bool {
483        self.bit()
484    }
485}
486#[doc = r" Value of the field"]
487pub struct G3_IO3R {
488    bits: bool,
489}
490impl G3_IO3R {
491    #[doc = r" Value of the field as raw bits"]
492    #[inline]
493    pub fn bit(&self) -> bool {
494        self.bits
495    }
496    #[doc = r" Returns `true` if the bit is clear (0)"]
497    #[inline]
498    pub fn bit_is_clear(&self) -> bool {
499        !self.bit()
500    }
501    #[doc = r" Returns `true` if the bit is set (1)"]
502    #[inline]
503    pub fn bit_is_set(&self) -> bool {
504        self.bit()
505    }
506}
507#[doc = r" Value of the field"]
508pub struct G3_IO2R {
509    bits: bool,
510}
511impl G3_IO2R {
512    #[doc = r" Value of the field as raw bits"]
513    #[inline]
514    pub fn bit(&self) -> bool {
515        self.bits
516    }
517    #[doc = r" Returns `true` if the bit is clear (0)"]
518    #[inline]
519    pub fn bit_is_clear(&self) -> bool {
520        !self.bit()
521    }
522    #[doc = r" Returns `true` if the bit is set (1)"]
523    #[inline]
524    pub fn bit_is_set(&self) -> bool {
525        self.bit()
526    }
527}
528#[doc = r" Value of the field"]
529pub struct G3_IO1R {
530    bits: bool,
531}
532impl G3_IO1R {
533    #[doc = r" Value of the field as raw bits"]
534    #[inline]
535    pub fn bit(&self) -> bool {
536        self.bits
537    }
538    #[doc = r" Returns `true` if the bit is clear (0)"]
539    #[inline]
540    pub fn bit_is_clear(&self) -> bool {
541        !self.bit()
542    }
543    #[doc = r" Returns `true` if the bit is set (1)"]
544    #[inline]
545    pub fn bit_is_set(&self) -> bool {
546        self.bit()
547    }
548}
549#[doc = r" Value of the field"]
550pub struct G2_IO4R {
551    bits: bool,
552}
553impl G2_IO4R {
554    #[doc = r" Value of the field as raw bits"]
555    #[inline]
556    pub fn bit(&self) -> bool {
557        self.bits
558    }
559    #[doc = r" Returns `true` if the bit is clear (0)"]
560    #[inline]
561    pub fn bit_is_clear(&self) -> bool {
562        !self.bit()
563    }
564    #[doc = r" Returns `true` if the bit is set (1)"]
565    #[inline]
566    pub fn bit_is_set(&self) -> bool {
567        self.bit()
568    }
569}
570#[doc = r" Value of the field"]
571pub struct G2_IO3R {
572    bits: bool,
573}
574impl G2_IO3R {
575    #[doc = r" Value of the field as raw bits"]
576    #[inline]
577    pub fn bit(&self) -> bool {
578        self.bits
579    }
580    #[doc = r" Returns `true` if the bit is clear (0)"]
581    #[inline]
582    pub fn bit_is_clear(&self) -> bool {
583        !self.bit()
584    }
585    #[doc = r" Returns `true` if the bit is set (1)"]
586    #[inline]
587    pub fn bit_is_set(&self) -> bool {
588        self.bit()
589    }
590}
591#[doc = r" Value of the field"]
592pub struct G2_IO2R {
593    bits: bool,
594}
595impl G2_IO2R {
596    #[doc = r" Value of the field as raw bits"]
597    #[inline]
598    pub fn bit(&self) -> bool {
599        self.bits
600    }
601    #[doc = r" Returns `true` if the bit is clear (0)"]
602    #[inline]
603    pub fn bit_is_clear(&self) -> bool {
604        !self.bit()
605    }
606    #[doc = r" Returns `true` if the bit is set (1)"]
607    #[inline]
608    pub fn bit_is_set(&self) -> bool {
609        self.bit()
610    }
611}
612#[doc = r" Value of the field"]
613pub struct G2_IO1R {
614    bits: bool,
615}
616impl G2_IO1R {
617    #[doc = r" Value of the field as raw bits"]
618    #[inline]
619    pub fn bit(&self) -> bool {
620        self.bits
621    }
622    #[doc = r" Returns `true` if the bit is clear (0)"]
623    #[inline]
624    pub fn bit_is_clear(&self) -> bool {
625        !self.bit()
626    }
627    #[doc = r" Returns `true` if the bit is set (1)"]
628    #[inline]
629    pub fn bit_is_set(&self) -> bool {
630        self.bit()
631    }
632}
633#[doc = r" Value of the field"]
634pub struct G1_IO4R {
635    bits: bool,
636}
637impl G1_IO4R {
638    #[doc = r" Value of the field as raw bits"]
639    #[inline]
640    pub fn bit(&self) -> bool {
641        self.bits
642    }
643    #[doc = r" Returns `true` if the bit is clear (0)"]
644    #[inline]
645    pub fn bit_is_clear(&self) -> bool {
646        !self.bit()
647    }
648    #[doc = r" Returns `true` if the bit is set (1)"]
649    #[inline]
650    pub fn bit_is_set(&self) -> bool {
651        self.bit()
652    }
653}
654#[doc = r" Value of the field"]
655pub struct G1_IO3R {
656    bits: bool,
657}
658impl G1_IO3R {
659    #[doc = r" Value of the field as raw bits"]
660    #[inline]
661    pub fn bit(&self) -> bool {
662        self.bits
663    }
664    #[doc = r" Returns `true` if the bit is clear (0)"]
665    #[inline]
666    pub fn bit_is_clear(&self) -> bool {
667        !self.bit()
668    }
669    #[doc = r" Returns `true` if the bit is set (1)"]
670    #[inline]
671    pub fn bit_is_set(&self) -> bool {
672        self.bit()
673    }
674}
675#[doc = r" Value of the field"]
676pub struct G1_IO2R {
677    bits: bool,
678}
679impl G1_IO2R {
680    #[doc = r" Value of the field as raw bits"]
681    #[inline]
682    pub fn bit(&self) -> bool {
683        self.bits
684    }
685    #[doc = r" Returns `true` if the bit is clear (0)"]
686    #[inline]
687    pub fn bit_is_clear(&self) -> bool {
688        !self.bit()
689    }
690    #[doc = r" Returns `true` if the bit is set (1)"]
691    #[inline]
692    pub fn bit_is_set(&self) -> bool {
693        self.bit()
694    }
695}
696#[doc = r" Value of the field"]
697pub struct G1_IO1R {
698    bits: bool,
699}
700impl G1_IO1R {
701    #[doc = r" Value of the field as raw bits"]
702    #[inline]
703    pub fn bit(&self) -> bool {
704        self.bits
705    }
706    #[doc = r" Returns `true` if the bit is clear (0)"]
707    #[inline]
708    pub fn bit_is_clear(&self) -> bool {
709        !self.bit()
710    }
711    #[doc = r" Returns `true` if the bit is set (1)"]
712    #[inline]
713    pub fn bit_is_set(&self) -> bool {
714        self.bit()
715    }
716}
717#[doc = r" Proxy"]
718pub struct _G8_IO4W<'a> {
719    w: &'a mut W,
720}
721impl<'a> _G8_IO4W<'a> {
722    #[doc = r" Sets the field bit"]
723    pub fn set_bit(self) -> &'a mut W {
724        self.bit(true)
725    }
726    #[doc = r" Clears the field bit"]
727    pub fn clear_bit(self) -> &'a mut W {
728        self.bit(false)
729    }
730    #[doc = r" Writes raw bits to the field"]
731    #[inline]
732    pub fn bit(self, value: bool) -> &'a mut W {
733        const MASK: bool = true;
734        const OFFSET: u8 = 31;
735        self.w.bits &= !((MASK as u32) << OFFSET);
736        self.w.bits |= ((value & MASK) as u32) << OFFSET;
737        self.w
738    }
739}
740#[doc = r" Proxy"]
741pub struct _G8_IO3W<'a> {
742    w: &'a mut W,
743}
744impl<'a> _G8_IO3W<'a> {
745    #[doc = r" Sets the field bit"]
746    pub fn set_bit(self) -> &'a mut W {
747        self.bit(true)
748    }
749    #[doc = r" Clears the field bit"]
750    pub fn clear_bit(self) -> &'a mut W {
751        self.bit(false)
752    }
753    #[doc = r" Writes raw bits to the field"]
754    #[inline]
755    pub fn bit(self, value: bool) -> &'a mut W {
756        const MASK: bool = true;
757        const OFFSET: u8 = 30;
758        self.w.bits &= !((MASK as u32) << OFFSET);
759        self.w.bits |= ((value & MASK) as u32) << OFFSET;
760        self.w
761    }
762}
763#[doc = r" Proxy"]
764pub struct _G8_IO2W<'a> {
765    w: &'a mut W,
766}
767impl<'a> _G8_IO2W<'a> {
768    #[doc = r" Sets the field bit"]
769    pub fn set_bit(self) -> &'a mut W {
770        self.bit(true)
771    }
772    #[doc = r" Clears the field bit"]
773    pub fn clear_bit(self) -> &'a mut W {
774        self.bit(false)
775    }
776    #[doc = r" Writes raw bits to the field"]
777    #[inline]
778    pub fn bit(self, value: bool) -> &'a mut W {
779        const MASK: bool = true;
780        const OFFSET: u8 = 29;
781        self.w.bits &= !((MASK as u32) << OFFSET);
782        self.w.bits |= ((value & MASK) as u32) << OFFSET;
783        self.w
784    }
785}
786#[doc = r" Proxy"]
787pub struct _G8_IO1W<'a> {
788    w: &'a mut W,
789}
790impl<'a> _G8_IO1W<'a> {
791    #[doc = r" Sets the field bit"]
792    pub fn set_bit(self) -> &'a mut W {
793        self.bit(true)
794    }
795    #[doc = r" Clears the field bit"]
796    pub fn clear_bit(self) -> &'a mut W {
797        self.bit(false)
798    }
799    #[doc = r" Writes raw bits to the field"]
800    #[inline]
801    pub fn bit(self, value: bool) -> &'a mut W {
802        const MASK: bool = true;
803        const OFFSET: u8 = 28;
804        self.w.bits &= !((MASK as u32) << OFFSET);
805        self.w.bits |= ((value & MASK) as u32) << OFFSET;
806        self.w
807    }
808}
809#[doc = r" Proxy"]
810pub struct _G7_IO4W<'a> {
811    w: &'a mut W,
812}
813impl<'a> _G7_IO4W<'a> {
814    #[doc = r" Sets the field bit"]
815    pub fn set_bit(self) -> &'a mut W {
816        self.bit(true)
817    }
818    #[doc = r" Clears the field bit"]
819    pub fn clear_bit(self) -> &'a mut W {
820        self.bit(false)
821    }
822    #[doc = r" Writes raw bits to the field"]
823    #[inline]
824    pub fn bit(self, value: bool) -> &'a mut W {
825        const MASK: bool = true;
826        const OFFSET: u8 = 27;
827        self.w.bits &= !((MASK as u32) << OFFSET);
828        self.w.bits |= ((value & MASK) as u32) << OFFSET;
829        self.w
830    }
831}
832#[doc = r" Proxy"]
833pub struct _G7_IO3W<'a> {
834    w: &'a mut W,
835}
836impl<'a> _G7_IO3W<'a> {
837    #[doc = r" Sets the field bit"]
838    pub fn set_bit(self) -> &'a mut W {
839        self.bit(true)
840    }
841    #[doc = r" Clears the field bit"]
842    pub fn clear_bit(self) -> &'a mut W {
843        self.bit(false)
844    }
845    #[doc = r" Writes raw bits to the field"]
846    #[inline]
847    pub fn bit(self, value: bool) -> &'a mut W {
848        const MASK: bool = true;
849        const OFFSET: u8 = 26;
850        self.w.bits &= !((MASK as u32) << OFFSET);
851        self.w.bits |= ((value & MASK) as u32) << OFFSET;
852        self.w
853    }
854}
855#[doc = r" Proxy"]
856pub struct _G7_IO2W<'a> {
857    w: &'a mut W,
858}
859impl<'a> _G7_IO2W<'a> {
860    #[doc = r" Sets the field bit"]
861    pub fn set_bit(self) -> &'a mut W {
862        self.bit(true)
863    }
864    #[doc = r" Clears the field bit"]
865    pub fn clear_bit(self) -> &'a mut W {
866        self.bit(false)
867    }
868    #[doc = r" Writes raw bits to the field"]
869    #[inline]
870    pub fn bit(self, value: bool) -> &'a mut W {
871        const MASK: bool = true;
872        const OFFSET: u8 = 25;
873        self.w.bits &= !((MASK as u32) << OFFSET);
874        self.w.bits |= ((value & MASK) as u32) << OFFSET;
875        self.w
876    }
877}
878#[doc = r" Proxy"]
879pub struct _G7_IO1W<'a> {
880    w: &'a mut W,
881}
882impl<'a> _G7_IO1W<'a> {
883    #[doc = r" Sets the field bit"]
884    pub fn set_bit(self) -> &'a mut W {
885        self.bit(true)
886    }
887    #[doc = r" Clears the field bit"]
888    pub fn clear_bit(self) -> &'a mut W {
889        self.bit(false)
890    }
891    #[doc = r" Writes raw bits to the field"]
892    #[inline]
893    pub fn bit(self, value: bool) -> &'a mut W {
894        const MASK: bool = true;
895        const OFFSET: u8 = 24;
896        self.w.bits &= !((MASK as u32) << OFFSET);
897        self.w.bits |= ((value & MASK) as u32) << OFFSET;
898        self.w
899    }
900}
901#[doc = r" Proxy"]
902pub struct _G6_IO4W<'a> {
903    w: &'a mut W,
904}
905impl<'a> _G6_IO4W<'a> {
906    #[doc = r" Sets the field bit"]
907    pub fn set_bit(self) -> &'a mut W {
908        self.bit(true)
909    }
910    #[doc = r" Clears the field bit"]
911    pub fn clear_bit(self) -> &'a mut W {
912        self.bit(false)
913    }
914    #[doc = r" Writes raw bits to the field"]
915    #[inline]
916    pub fn bit(self, value: bool) -> &'a mut W {
917        const MASK: bool = true;
918        const OFFSET: u8 = 23;
919        self.w.bits &= !((MASK as u32) << OFFSET);
920        self.w.bits |= ((value & MASK) as u32) << OFFSET;
921        self.w
922    }
923}
924#[doc = r" Proxy"]
925pub struct _G6_IO3W<'a> {
926    w: &'a mut W,
927}
928impl<'a> _G6_IO3W<'a> {
929    #[doc = r" Sets the field bit"]
930    pub fn set_bit(self) -> &'a mut W {
931        self.bit(true)
932    }
933    #[doc = r" Clears the field bit"]
934    pub fn clear_bit(self) -> &'a mut W {
935        self.bit(false)
936    }
937    #[doc = r" Writes raw bits to the field"]
938    #[inline]
939    pub fn bit(self, value: bool) -> &'a mut W {
940        const MASK: bool = true;
941        const OFFSET: u8 = 22;
942        self.w.bits &= !((MASK as u32) << OFFSET);
943        self.w.bits |= ((value & MASK) as u32) << OFFSET;
944        self.w
945    }
946}
947#[doc = r" Proxy"]
948pub struct _G6_IO2W<'a> {
949    w: &'a mut W,
950}
951impl<'a> _G6_IO2W<'a> {
952    #[doc = r" Sets the field bit"]
953    pub fn set_bit(self) -> &'a mut W {
954        self.bit(true)
955    }
956    #[doc = r" Clears the field bit"]
957    pub fn clear_bit(self) -> &'a mut W {
958        self.bit(false)
959    }
960    #[doc = r" Writes raw bits to the field"]
961    #[inline]
962    pub fn bit(self, value: bool) -> &'a mut W {
963        const MASK: bool = true;
964        const OFFSET: u8 = 21;
965        self.w.bits &= !((MASK as u32) << OFFSET);
966        self.w.bits |= ((value & MASK) as u32) << OFFSET;
967        self.w
968    }
969}
970#[doc = r" Proxy"]
971pub struct _G6_IO1W<'a> {
972    w: &'a mut W,
973}
974impl<'a> _G6_IO1W<'a> {
975    #[doc = r" Sets the field bit"]
976    pub fn set_bit(self) -> &'a mut W {
977        self.bit(true)
978    }
979    #[doc = r" Clears the field bit"]
980    pub fn clear_bit(self) -> &'a mut W {
981        self.bit(false)
982    }
983    #[doc = r" Writes raw bits to the field"]
984    #[inline]
985    pub fn bit(self, value: bool) -> &'a mut W {
986        const MASK: bool = true;
987        const OFFSET: u8 = 20;
988        self.w.bits &= !((MASK as u32) << OFFSET);
989        self.w.bits |= ((value & MASK) as u32) << OFFSET;
990        self.w
991    }
992}
993#[doc = r" Proxy"]
994pub struct _G5_IO4W<'a> {
995    w: &'a mut W,
996}
997impl<'a> _G5_IO4W<'a> {
998    #[doc = r" Sets the field bit"]
999    pub fn set_bit(self) -> &'a mut W {
1000        self.bit(true)
1001    }
1002    #[doc = r" Clears the field bit"]
1003    pub fn clear_bit(self) -> &'a mut W {
1004        self.bit(false)
1005    }
1006    #[doc = r" Writes raw bits to the field"]
1007    #[inline]
1008    pub fn bit(self, value: bool) -> &'a mut W {
1009        const MASK: bool = true;
1010        const OFFSET: u8 = 19;
1011        self.w.bits &= !((MASK as u32) << OFFSET);
1012        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1013        self.w
1014    }
1015}
1016#[doc = r" Proxy"]
1017pub struct _G5_IO3W<'a> {
1018    w: &'a mut W,
1019}
1020impl<'a> _G5_IO3W<'a> {
1021    #[doc = r" Sets the field bit"]
1022    pub fn set_bit(self) -> &'a mut W {
1023        self.bit(true)
1024    }
1025    #[doc = r" Clears the field bit"]
1026    pub fn clear_bit(self) -> &'a mut W {
1027        self.bit(false)
1028    }
1029    #[doc = r" Writes raw bits to the field"]
1030    #[inline]
1031    pub fn bit(self, value: bool) -> &'a mut W {
1032        const MASK: bool = true;
1033        const OFFSET: u8 = 18;
1034        self.w.bits &= !((MASK as u32) << OFFSET);
1035        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1036        self.w
1037    }
1038}
1039#[doc = r" Proxy"]
1040pub struct _G5_IO2W<'a> {
1041    w: &'a mut W,
1042}
1043impl<'a> _G5_IO2W<'a> {
1044    #[doc = r" Sets the field bit"]
1045    pub fn set_bit(self) -> &'a mut W {
1046        self.bit(true)
1047    }
1048    #[doc = r" Clears the field bit"]
1049    pub fn clear_bit(self) -> &'a mut W {
1050        self.bit(false)
1051    }
1052    #[doc = r" Writes raw bits to the field"]
1053    #[inline]
1054    pub fn bit(self, value: bool) -> &'a mut W {
1055        const MASK: bool = true;
1056        const OFFSET: u8 = 17;
1057        self.w.bits &= !((MASK as u32) << OFFSET);
1058        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1059        self.w
1060    }
1061}
1062#[doc = r" Proxy"]
1063pub struct _G5_IO1W<'a> {
1064    w: &'a mut W,
1065}
1066impl<'a> _G5_IO1W<'a> {
1067    #[doc = r" Sets the field bit"]
1068    pub fn set_bit(self) -> &'a mut W {
1069        self.bit(true)
1070    }
1071    #[doc = r" Clears the field bit"]
1072    pub fn clear_bit(self) -> &'a mut W {
1073        self.bit(false)
1074    }
1075    #[doc = r" Writes raw bits to the field"]
1076    #[inline]
1077    pub fn bit(self, value: bool) -> &'a mut W {
1078        const MASK: bool = true;
1079        const OFFSET: u8 = 16;
1080        self.w.bits &= !((MASK as u32) << OFFSET);
1081        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1082        self.w
1083    }
1084}
1085#[doc = r" Proxy"]
1086pub struct _G4_IO4W<'a> {
1087    w: &'a mut W,
1088}
1089impl<'a> _G4_IO4W<'a> {
1090    #[doc = r" Sets the field bit"]
1091    pub fn set_bit(self) -> &'a mut W {
1092        self.bit(true)
1093    }
1094    #[doc = r" Clears the field bit"]
1095    pub fn clear_bit(self) -> &'a mut W {
1096        self.bit(false)
1097    }
1098    #[doc = r" Writes raw bits to the field"]
1099    #[inline]
1100    pub fn bit(self, value: bool) -> &'a mut W {
1101        const MASK: bool = true;
1102        const OFFSET: u8 = 15;
1103        self.w.bits &= !((MASK as u32) << OFFSET);
1104        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1105        self.w
1106    }
1107}
1108#[doc = r" Proxy"]
1109pub struct _G4_IO3W<'a> {
1110    w: &'a mut W,
1111}
1112impl<'a> _G4_IO3W<'a> {
1113    #[doc = r" Sets the field bit"]
1114    pub fn set_bit(self) -> &'a mut W {
1115        self.bit(true)
1116    }
1117    #[doc = r" Clears the field bit"]
1118    pub fn clear_bit(self) -> &'a mut W {
1119        self.bit(false)
1120    }
1121    #[doc = r" Writes raw bits to the field"]
1122    #[inline]
1123    pub fn bit(self, value: bool) -> &'a mut W {
1124        const MASK: bool = true;
1125        const OFFSET: u8 = 14;
1126        self.w.bits &= !((MASK as u32) << OFFSET);
1127        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1128        self.w
1129    }
1130}
1131#[doc = r" Proxy"]
1132pub struct _G4_IO2W<'a> {
1133    w: &'a mut W,
1134}
1135impl<'a> _G4_IO2W<'a> {
1136    #[doc = r" Sets the field bit"]
1137    pub fn set_bit(self) -> &'a mut W {
1138        self.bit(true)
1139    }
1140    #[doc = r" Clears the field bit"]
1141    pub fn clear_bit(self) -> &'a mut W {
1142        self.bit(false)
1143    }
1144    #[doc = r" Writes raw bits to the field"]
1145    #[inline]
1146    pub fn bit(self, value: bool) -> &'a mut W {
1147        const MASK: bool = true;
1148        const OFFSET: u8 = 13;
1149        self.w.bits &= !((MASK as u32) << OFFSET);
1150        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1151        self.w
1152    }
1153}
1154#[doc = r" Proxy"]
1155pub struct _G4_IO1W<'a> {
1156    w: &'a mut W,
1157}
1158impl<'a> _G4_IO1W<'a> {
1159    #[doc = r" Sets the field bit"]
1160    pub fn set_bit(self) -> &'a mut W {
1161        self.bit(true)
1162    }
1163    #[doc = r" Clears the field bit"]
1164    pub fn clear_bit(self) -> &'a mut W {
1165        self.bit(false)
1166    }
1167    #[doc = r" Writes raw bits to the field"]
1168    #[inline]
1169    pub fn bit(self, value: bool) -> &'a mut W {
1170        const MASK: bool = true;
1171        const OFFSET: u8 = 12;
1172        self.w.bits &= !((MASK as u32) << OFFSET);
1173        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1174        self.w
1175    }
1176}
1177#[doc = r" Proxy"]
1178pub struct _G3_IO4W<'a> {
1179    w: &'a mut W,
1180}
1181impl<'a> _G3_IO4W<'a> {
1182    #[doc = r" Sets the field bit"]
1183    pub fn set_bit(self) -> &'a mut W {
1184        self.bit(true)
1185    }
1186    #[doc = r" Clears the field bit"]
1187    pub fn clear_bit(self) -> &'a mut W {
1188        self.bit(false)
1189    }
1190    #[doc = r" Writes raw bits to the field"]
1191    #[inline]
1192    pub fn bit(self, value: bool) -> &'a mut W {
1193        const MASK: bool = true;
1194        const OFFSET: u8 = 11;
1195        self.w.bits &= !((MASK as u32) << OFFSET);
1196        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1197        self.w
1198    }
1199}
1200#[doc = r" Proxy"]
1201pub struct _G3_IO3W<'a> {
1202    w: &'a mut W,
1203}
1204impl<'a> _G3_IO3W<'a> {
1205    #[doc = r" Sets the field bit"]
1206    pub fn set_bit(self) -> &'a mut W {
1207        self.bit(true)
1208    }
1209    #[doc = r" Clears the field bit"]
1210    pub fn clear_bit(self) -> &'a mut W {
1211        self.bit(false)
1212    }
1213    #[doc = r" Writes raw bits to the field"]
1214    #[inline]
1215    pub fn bit(self, value: bool) -> &'a mut W {
1216        const MASK: bool = true;
1217        const OFFSET: u8 = 10;
1218        self.w.bits &= !((MASK as u32) << OFFSET);
1219        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1220        self.w
1221    }
1222}
1223#[doc = r" Proxy"]
1224pub struct _G3_IO2W<'a> {
1225    w: &'a mut W,
1226}
1227impl<'a> _G3_IO2W<'a> {
1228    #[doc = r" Sets the field bit"]
1229    pub fn set_bit(self) -> &'a mut W {
1230        self.bit(true)
1231    }
1232    #[doc = r" Clears the field bit"]
1233    pub fn clear_bit(self) -> &'a mut W {
1234        self.bit(false)
1235    }
1236    #[doc = r" Writes raw bits to the field"]
1237    #[inline]
1238    pub fn bit(self, value: bool) -> &'a mut W {
1239        const MASK: bool = true;
1240        const OFFSET: u8 = 9;
1241        self.w.bits &= !((MASK as u32) << OFFSET);
1242        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1243        self.w
1244    }
1245}
1246#[doc = r" Proxy"]
1247pub struct _G3_IO1W<'a> {
1248    w: &'a mut W,
1249}
1250impl<'a> _G3_IO1W<'a> {
1251    #[doc = r" Sets the field bit"]
1252    pub fn set_bit(self) -> &'a mut W {
1253        self.bit(true)
1254    }
1255    #[doc = r" Clears the field bit"]
1256    pub fn clear_bit(self) -> &'a mut W {
1257        self.bit(false)
1258    }
1259    #[doc = r" Writes raw bits to the field"]
1260    #[inline]
1261    pub fn bit(self, value: bool) -> &'a mut W {
1262        const MASK: bool = true;
1263        const OFFSET: u8 = 8;
1264        self.w.bits &= !((MASK as u32) << OFFSET);
1265        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1266        self.w
1267    }
1268}
1269#[doc = r" Proxy"]
1270pub struct _G2_IO4W<'a> {
1271    w: &'a mut W,
1272}
1273impl<'a> _G2_IO4W<'a> {
1274    #[doc = r" Sets the field bit"]
1275    pub fn set_bit(self) -> &'a mut W {
1276        self.bit(true)
1277    }
1278    #[doc = r" Clears the field bit"]
1279    pub fn clear_bit(self) -> &'a mut W {
1280        self.bit(false)
1281    }
1282    #[doc = r" Writes raw bits to the field"]
1283    #[inline]
1284    pub fn bit(self, value: bool) -> &'a mut W {
1285        const MASK: bool = true;
1286        const OFFSET: u8 = 7;
1287        self.w.bits &= !((MASK as u32) << OFFSET);
1288        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1289        self.w
1290    }
1291}
1292#[doc = r" Proxy"]
1293pub struct _G2_IO3W<'a> {
1294    w: &'a mut W,
1295}
1296impl<'a> _G2_IO3W<'a> {
1297    #[doc = r" Sets the field bit"]
1298    pub fn set_bit(self) -> &'a mut W {
1299        self.bit(true)
1300    }
1301    #[doc = r" Clears the field bit"]
1302    pub fn clear_bit(self) -> &'a mut W {
1303        self.bit(false)
1304    }
1305    #[doc = r" Writes raw bits to the field"]
1306    #[inline]
1307    pub fn bit(self, value: bool) -> &'a mut W {
1308        const MASK: bool = true;
1309        const OFFSET: u8 = 6;
1310        self.w.bits &= !((MASK as u32) << OFFSET);
1311        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1312        self.w
1313    }
1314}
1315#[doc = r" Proxy"]
1316pub struct _G2_IO2W<'a> {
1317    w: &'a mut W,
1318}
1319impl<'a> _G2_IO2W<'a> {
1320    #[doc = r" Sets the field bit"]
1321    pub fn set_bit(self) -> &'a mut W {
1322        self.bit(true)
1323    }
1324    #[doc = r" Clears the field bit"]
1325    pub fn clear_bit(self) -> &'a mut W {
1326        self.bit(false)
1327    }
1328    #[doc = r" Writes raw bits to the field"]
1329    #[inline]
1330    pub fn bit(self, value: bool) -> &'a mut W {
1331        const MASK: bool = true;
1332        const OFFSET: u8 = 5;
1333        self.w.bits &= !((MASK as u32) << OFFSET);
1334        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1335        self.w
1336    }
1337}
1338#[doc = r" Proxy"]
1339pub struct _G2_IO1W<'a> {
1340    w: &'a mut W,
1341}
1342impl<'a> _G2_IO1W<'a> {
1343    #[doc = r" Sets the field bit"]
1344    pub fn set_bit(self) -> &'a mut W {
1345        self.bit(true)
1346    }
1347    #[doc = r" Clears the field bit"]
1348    pub fn clear_bit(self) -> &'a mut W {
1349        self.bit(false)
1350    }
1351    #[doc = r" Writes raw bits to the field"]
1352    #[inline]
1353    pub fn bit(self, value: bool) -> &'a mut W {
1354        const MASK: bool = true;
1355        const OFFSET: u8 = 4;
1356        self.w.bits &= !((MASK as u32) << OFFSET);
1357        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1358        self.w
1359    }
1360}
1361#[doc = r" Proxy"]
1362pub struct _G1_IO4W<'a> {
1363    w: &'a mut W,
1364}
1365impl<'a> _G1_IO4W<'a> {
1366    #[doc = r" Sets the field bit"]
1367    pub fn set_bit(self) -> &'a mut W {
1368        self.bit(true)
1369    }
1370    #[doc = r" Clears the field bit"]
1371    pub fn clear_bit(self) -> &'a mut W {
1372        self.bit(false)
1373    }
1374    #[doc = r" Writes raw bits to the field"]
1375    #[inline]
1376    pub fn bit(self, value: bool) -> &'a mut W {
1377        const MASK: bool = true;
1378        const OFFSET: u8 = 3;
1379        self.w.bits &= !((MASK as u32) << OFFSET);
1380        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1381        self.w
1382    }
1383}
1384#[doc = r" Proxy"]
1385pub struct _G1_IO3W<'a> {
1386    w: &'a mut W,
1387}
1388impl<'a> _G1_IO3W<'a> {
1389    #[doc = r" Sets the field bit"]
1390    pub fn set_bit(self) -> &'a mut W {
1391        self.bit(true)
1392    }
1393    #[doc = r" Clears the field bit"]
1394    pub fn clear_bit(self) -> &'a mut W {
1395        self.bit(false)
1396    }
1397    #[doc = r" Writes raw bits to the field"]
1398    #[inline]
1399    pub fn bit(self, value: bool) -> &'a mut W {
1400        const MASK: bool = true;
1401        const OFFSET: u8 = 2;
1402        self.w.bits &= !((MASK as u32) << OFFSET);
1403        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1404        self.w
1405    }
1406}
1407#[doc = r" Proxy"]
1408pub struct _G1_IO2W<'a> {
1409    w: &'a mut W,
1410}
1411impl<'a> _G1_IO2W<'a> {
1412    #[doc = r" Sets the field bit"]
1413    pub fn set_bit(self) -> &'a mut W {
1414        self.bit(true)
1415    }
1416    #[doc = r" Clears the field bit"]
1417    pub fn clear_bit(self) -> &'a mut W {
1418        self.bit(false)
1419    }
1420    #[doc = r" Writes raw bits to the field"]
1421    #[inline]
1422    pub fn bit(self, value: bool) -> &'a mut W {
1423        const MASK: bool = true;
1424        const OFFSET: u8 = 1;
1425        self.w.bits &= !((MASK as u32) << OFFSET);
1426        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1427        self.w
1428    }
1429}
1430#[doc = r" Proxy"]
1431pub struct _G1_IO1W<'a> {
1432    w: &'a mut W,
1433}
1434impl<'a> _G1_IO1W<'a> {
1435    #[doc = r" Sets the field bit"]
1436    pub fn set_bit(self) -> &'a mut W {
1437        self.bit(true)
1438    }
1439    #[doc = r" Clears the field bit"]
1440    pub fn clear_bit(self) -> &'a mut W {
1441        self.bit(false)
1442    }
1443    #[doc = r" Writes raw bits to the field"]
1444    #[inline]
1445    pub fn bit(self, value: bool) -> &'a mut W {
1446        const MASK: bool = true;
1447        const OFFSET: u8 = 0;
1448        self.w.bits &= !((MASK as u32) << OFFSET);
1449        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1450        self.w
1451    }
1452}
1453impl R {
1454    #[doc = r" Value of the register as raw bits"]
1455    #[inline]
1456    pub fn bits(&self) -> u32 {
1457        self.bits
1458    }
1459    #[doc = "Bit 31 - G8_IO4"]
1460    #[inline]
1461    pub fn g8_io4(&self) -> G8_IO4R {
1462        let bits = {
1463            const MASK: bool = true;
1464            const OFFSET: u8 = 31;
1465            ((self.bits >> OFFSET) & MASK as u32) != 0
1466        };
1467        G8_IO4R { bits }
1468    }
1469    #[doc = "Bit 30 - G8_IO3"]
1470    #[inline]
1471    pub fn g8_io3(&self) -> G8_IO3R {
1472        let bits = {
1473            const MASK: bool = true;
1474            const OFFSET: u8 = 30;
1475            ((self.bits >> OFFSET) & MASK as u32) != 0
1476        };
1477        G8_IO3R { bits }
1478    }
1479    #[doc = "Bit 29 - G8_IO2"]
1480    #[inline]
1481    pub fn g8_io2(&self) -> G8_IO2R {
1482        let bits = {
1483            const MASK: bool = true;
1484            const OFFSET: u8 = 29;
1485            ((self.bits >> OFFSET) & MASK as u32) != 0
1486        };
1487        G8_IO2R { bits }
1488    }
1489    #[doc = "Bit 28 - G8_IO1"]
1490    #[inline]
1491    pub fn g8_io1(&self) -> G8_IO1R {
1492        let bits = {
1493            const MASK: bool = true;
1494            const OFFSET: u8 = 28;
1495            ((self.bits >> OFFSET) & MASK as u32) != 0
1496        };
1497        G8_IO1R { bits }
1498    }
1499    #[doc = "Bit 27 - G7_IO4"]
1500    #[inline]
1501    pub fn g7_io4(&self) -> G7_IO4R {
1502        let bits = {
1503            const MASK: bool = true;
1504            const OFFSET: u8 = 27;
1505            ((self.bits >> OFFSET) & MASK as u32) != 0
1506        };
1507        G7_IO4R { bits }
1508    }
1509    #[doc = "Bit 26 - G7_IO3"]
1510    #[inline]
1511    pub fn g7_io3(&self) -> G7_IO3R {
1512        let bits = {
1513            const MASK: bool = true;
1514            const OFFSET: u8 = 26;
1515            ((self.bits >> OFFSET) & MASK as u32) != 0
1516        };
1517        G7_IO3R { bits }
1518    }
1519    #[doc = "Bit 25 - G7_IO2"]
1520    #[inline]
1521    pub fn g7_io2(&self) -> G7_IO2R {
1522        let bits = {
1523            const MASK: bool = true;
1524            const OFFSET: u8 = 25;
1525            ((self.bits >> OFFSET) & MASK as u32) != 0
1526        };
1527        G7_IO2R { bits }
1528    }
1529    #[doc = "Bit 24 - G7_IO1"]
1530    #[inline]
1531    pub fn g7_io1(&self) -> G7_IO1R {
1532        let bits = {
1533            const MASK: bool = true;
1534            const OFFSET: u8 = 24;
1535            ((self.bits >> OFFSET) & MASK as u32) != 0
1536        };
1537        G7_IO1R { bits }
1538    }
1539    #[doc = "Bit 23 - G6_IO4"]
1540    #[inline]
1541    pub fn g6_io4(&self) -> G6_IO4R {
1542        let bits = {
1543            const MASK: bool = true;
1544            const OFFSET: u8 = 23;
1545            ((self.bits >> OFFSET) & MASK as u32) != 0
1546        };
1547        G6_IO4R { bits }
1548    }
1549    #[doc = "Bit 22 - G6_IO3"]
1550    #[inline]
1551    pub fn g6_io3(&self) -> G6_IO3R {
1552        let bits = {
1553            const MASK: bool = true;
1554            const OFFSET: u8 = 22;
1555            ((self.bits >> OFFSET) & MASK as u32) != 0
1556        };
1557        G6_IO3R { bits }
1558    }
1559    #[doc = "Bit 21 - G6_IO2"]
1560    #[inline]
1561    pub fn g6_io2(&self) -> G6_IO2R {
1562        let bits = {
1563            const MASK: bool = true;
1564            const OFFSET: u8 = 21;
1565            ((self.bits >> OFFSET) & MASK as u32) != 0
1566        };
1567        G6_IO2R { bits }
1568    }
1569    #[doc = "Bit 20 - G6_IO1"]
1570    #[inline]
1571    pub fn g6_io1(&self) -> G6_IO1R {
1572        let bits = {
1573            const MASK: bool = true;
1574            const OFFSET: u8 = 20;
1575            ((self.bits >> OFFSET) & MASK as u32) != 0
1576        };
1577        G6_IO1R { bits }
1578    }
1579    #[doc = "Bit 19 - G5_IO4"]
1580    #[inline]
1581    pub fn g5_io4(&self) -> G5_IO4R {
1582        let bits = {
1583            const MASK: bool = true;
1584            const OFFSET: u8 = 19;
1585            ((self.bits >> OFFSET) & MASK as u32) != 0
1586        };
1587        G5_IO4R { bits }
1588    }
1589    #[doc = "Bit 18 - G5_IO3"]
1590    #[inline]
1591    pub fn g5_io3(&self) -> G5_IO3R {
1592        let bits = {
1593            const MASK: bool = true;
1594            const OFFSET: u8 = 18;
1595            ((self.bits >> OFFSET) & MASK as u32) != 0
1596        };
1597        G5_IO3R { bits }
1598    }
1599    #[doc = "Bit 17 - G5_IO2"]
1600    #[inline]
1601    pub fn g5_io2(&self) -> G5_IO2R {
1602        let bits = {
1603            const MASK: bool = true;
1604            const OFFSET: u8 = 17;
1605            ((self.bits >> OFFSET) & MASK as u32) != 0
1606        };
1607        G5_IO2R { bits }
1608    }
1609    #[doc = "Bit 16 - G5_IO1"]
1610    #[inline]
1611    pub fn g5_io1(&self) -> G5_IO1R {
1612        let bits = {
1613            const MASK: bool = true;
1614            const OFFSET: u8 = 16;
1615            ((self.bits >> OFFSET) & MASK as u32) != 0
1616        };
1617        G5_IO1R { bits }
1618    }
1619    #[doc = "Bit 15 - G4_IO4"]
1620    #[inline]
1621    pub fn g4_io4(&self) -> G4_IO4R {
1622        let bits = {
1623            const MASK: bool = true;
1624            const OFFSET: u8 = 15;
1625            ((self.bits >> OFFSET) & MASK as u32) != 0
1626        };
1627        G4_IO4R { bits }
1628    }
1629    #[doc = "Bit 14 - G4_IO3"]
1630    #[inline]
1631    pub fn g4_io3(&self) -> G4_IO3R {
1632        let bits = {
1633            const MASK: bool = true;
1634            const OFFSET: u8 = 14;
1635            ((self.bits >> OFFSET) & MASK as u32) != 0
1636        };
1637        G4_IO3R { bits }
1638    }
1639    #[doc = "Bit 13 - G4_IO2"]
1640    #[inline]
1641    pub fn g4_io2(&self) -> G4_IO2R {
1642        let bits = {
1643            const MASK: bool = true;
1644            const OFFSET: u8 = 13;
1645            ((self.bits >> OFFSET) & MASK as u32) != 0
1646        };
1647        G4_IO2R { bits }
1648    }
1649    #[doc = "Bit 12 - G4_IO1"]
1650    #[inline]
1651    pub fn g4_io1(&self) -> G4_IO1R {
1652        let bits = {
1653            const MASK: bool = true;
1654            const OFFSET: u8 = 12;
1655            ((self.bits >> OFFSET) & MASK as u32) != 0
1656        };
1657        G4_IO1R { bits }
1658    }
1659    #[doc = "Bit 11 - G3_IO4"]
1660    #[inline]
1661    pub fn g3_io4(&self) -> G3_IO4R {
1662        let bits = {
1663            const MASK: bool = true;
1664            const OFFSET: u8 = 11;
1665            ((self.bits >> OFFSET) & MASK as u32) != 0
1666        };
1667        G3_IO4R { bits }
1668    }
1669    #[doc = "Bit 10 - G3_IO3"]
1670    #[inline]
1671    pub fn g3_io3(&self) -> G3_IO3R {
1672        let bits = {
1673            const MASK: bool = true;
1674            const OFFSET: u8 = 10;
1675            ((self.bits >> OFFSET) & MASK as u32) != 0
1676        };
1677        G3_IO3R { bits }
1678    }
1679    #[doc = "Bit 9 - G3_IO2"]
1680    #[inline]
1681    pub fn g3_io2(&self) -> G3_IO2R {
1682        let bits = {
1683            const MASK: bool = true;
1684            const OFFSET: u8 = 9;
1685            ((self.bits >> OFFSET) & MASK as u32) != 0
1686        };
1687        G3_IO2R { bits }
1688    }
1689    #[doc = "Bit 8 - G3_IO1"]
1690    #[inline]
1691    pub fn g3_io1(&self) -> G3_IO1R {
1692        let bits = {
1693            const MASK: bool = true;
1694            const OFFSET: u8 = 8;
1695            ((self.bits >> OFFSET) & MASK as u32) != 0
1696        };
1697        G3_IO1R { bits }
1698    }
1699    #[doc = "Bit 7 - G2_IO4"]
1700    #[inline]
1701    pub fn g2_io4(&self) -> G2_IO4R {
1702        let bits = {
1703            const MASK: bool = true;
1704            const OFFSET: u8 = 7;
1705            ((self.bits >> OFFSET) & MASK as u32) != 0
1706        };
1707        G2_IO4R { bits }
1708    }
1709    #[doc = "Bit 6 - G2_IO3"]
1710    #[inline]
1711    pub fn g2_io3(&self) -> G2_IO3R {
1712        let bits = {
1713            const MASK: bool = true;
1714            const OFFSET: u8 = 6;
1715            ((self.bits >> OFFSET) & MASK as u32) != 0
1716        };
1717        G2_IO3R { bits }
1718    }
1719    #[doc = "Bit 5 - G2_IO2"]
1720    #[inline]
1721    pub fn g2_io2(&self) -> G2_IO2R {
1722        let bits = {
1723            const MASK: bool = true;
1724            const OFFSET: u8 = 5;
1725            ((self.bits >> OFFSET) & MASK as u32) != 0
1726        };
1727        G2_IO2R { bits }
1728    }
1729    #[doc = "Bit 4 - G2_IO1"]
1730    #[inline]
1731    pub fn g2_io1(&self) -> G2_IO1R {
1732        let bits = {
1733            const MASK: bool = true;
1734            const OFFSET: u8 = 4;
1735            ((self.bits >> OFFSET) & MASK as u32) != 0
1736        };
1737        G2_IO1R { bits }
1738    }
1739    #[doc = "Bit 3 - G1_IO4"]
1740    #[inline]
1741    pub fn g1_io4(&self) -> G1_IO4R {
1742        let bits = {
1743            const MASK: bool = true;
1744            const OFFSET: u8 = 3;
1745            ((self.bits >> OFFSET) & MASK as u32) != 0
1746        };
1747        G1_IO4R { bits }
1748    }
1749    #[doc = "Bit 2 - G1_IO3"]
1750    #[inline]
1751    pub fn g1_io3(&self) -> G1_IO3R {
1752        let bits = {
1753            const MASK: bool = true;
1754            const OFFSET: u8 = 2;
1755            ((self.bits >> OFFSET) & MASK as u32) != 0
1756        };
1757        G1_IO3R { bits }
1758    }
1759    #[doc = "Bit 1 - G1_IO2"]
1760    #[inline]
1761    pub fn g1_io2(&self) -> G1_IO2R {
1762        let bits = {
1763            const MASK: bool = true;
1764            const OFFSET: u8 = 1;
1765            ((self.bits >> OFFSET) & MASK as u32) != 0
1766        };
1767        G1_IO2R { bits }
1768    }
1769    #[doc = "Bit 0 - G1_IO1"]
1770    #[inline]
1771    pub fn g1_io1(&self) -> G1_IO1R {
1772        let bits = {
1773            const MASK: bool = true;
1774            const OFFSET: u8 = 0;
1775            ((self.bits >> OFFSET) & MASK as u32) != 0
1776        };
1777        G1_IO1R { bits }
1778    }
1779}
1780impl W {
1781    #[doc = r" Reset value of the register"]
1782    #[inline]
1783    pub fn reset_value() -> W {
1784        W { bits: 0 }
1785    }
1786    #[doc = r" Writes raw bits to the register"]
1787    #[inline]
1788    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1789        self.bits = bits;
1790        self
1791    }
1792    #[doc = "Bit 31 - G8_IO4"]
1793    #[inline]
1794    pub fn g8_io4(&mut self) -> _G8_IO4W {
1795        _G8_IO4W { w: self }
1796    }
1797    #[doc = "Bit 30 - G8_IO3"]
1798    #[inline]
1799    pub fn g8_io3(&mut self) -> _G8_IO3W {
1800        _G8_IO3W { w: self }
1801    }
1802    #[doc = "Bit 29 - G8_IO2"]
1803    #[inline]
1804    pub fn g8_io2(&mut self) -> _G8_IO2W {
1805        _G8_IO2W { w: self }
1806    }
1807    #[doc = "Bit 28 - G8_IO1"]
1808    #[inline]
1809    pub fn g8_io1(&mut self) -> _G8_IO1W {
1810        _G8_IO1W { w: self }
1811    }
1812    #[doc = "Bit 27 - G7_IO4"]
1813    #[inline]
1814    pub fn g7_io4(&mut self) -> _G7_IO4W {
1815        _G7_IO4W { w: self }
1816    }
1817    #[doc = "Bit 26 - G7_IO3"]
1818    #[inline]
1819    pub fn g7_io3(&mut self) -> _G7_IO3W {
1820        _G7_IO3W { w: self }
1821    }
1822    #[doc = "Bit 25 - G7_IO2"]
1823    #[inline]
1824    pub fn g7_io2(&mut self) -> _G7_IO2W {
1825        _G7_IO2W { w: self }
1826    }
1827    #[doc = "Bit 24 - G7_IO1"]
1828    #[inline]
1829    pub fn g7_io1(&mut self) -> _G7_IO1W {
1830        _G7_IO1W { w: self }
1831    }
1832    #[doc = "Bit 23 - G6_IO4"]
1833    #[inline]
1834    pub fn g6_io4(&mut self) -> _G6_IO4W {
1835        _G6_IO4W { w: self }
1836    }
1837    #[doc = "Bit 22 - G6_IO3"]
1838    #[inline]
1839    pub fn g6_io3(&mut self) -> _G6_IO3W {
1840        _G6_IO3W { w: self }
1841    }
1842    #[doc = "Bit 21 - G6_IO2"]
1843    #[inline]
1844    pub fn g6_io2(&mut self) -> _G6_IO2W {
1845        _G6_IO2W { w: self }
1846    }
1847    #[doc = "Bit 20 - G6_IO1"]
1848    #[inline]
1849    pub fn g6_io1(&mut self) -> _G6_IO1W {
1850        _G6_IO1W { w: self }
1851    }
1852    #[doc = "Bit 19 - G5_IO4"]
1853    #[inline]
1854    pub fn g5_io4(&mut self) -> _G5_IO4W {
1855        _G5_IO4W { w: self }
1856    }
1857    #[doc = "Bit 18 - G5_IO3"]
1858    #[inline]
1859    pub fn g5_io3(&mut self) -> _G5_IO3W {
1860        _G5_IO3W { w: self }
1861    }
1862    #[doc = "Bit 17 - G5_IO2"]
1863    #[inline]
1864    pub fn g5_io2(&mut self) -> _G5_IO2W {
1865        _G5_IO2W { w: self }
1866    }
1867    #[doc = "Bit 16 - G5_IO1"]
1868    #[inline]
1869    pub fn g5_io1(&mut self) -> _G5_IO1W {
1870        _G5_IO1W { w: self }
1871    }
1872    #[doc = "Bit 15 - G4_IO4"]
1873    #[inline]
1874    pub fn g4_io4(&mut self) -> _G4_IO4W {
1875        _G4_IO4W { w: self }
1876    }
1877    #[doc = "Bit 14 - G4_IO3"]
1878    #[inline]
1879    pub fn g4_io3(&mut self) -> _G4_IO3W {
1880        _G4_IO3W { w: self }
1881    }
1882    #[doc = "Bit 13 - G4_IO2"]
1883    #[inline]
1884    pub fn g4_io2(&mut self) -> _G4_IO2W {
1885        _G4_IO2W { w: self }
1886    }
1887    #[doc = "Bit 12 - G4_IO1"]
1888    #[inline]
1889    pub fn g4_io1(&mut self) -> _G4_IO1W {
1890        _G4_IO1W { w: self }
1891    }
1892    #[doc = "Bit 11 - G3_IO4"]
1893    #[inline]
1894    pub fn g3_io4(&mut self) -> _G3_IO4W {
1895        _G3_IO4W { w: self }
1896    }
1897    #[doc = "Bit 10 - G3_IO3"]
1898    #[inline]
1899    pub fn g3_io3(&mut self) -> _G3_IO3W {
1900        _G3_IO3W { w: self }
1901    }
1902    #[doc = "Bit 9 - G3_IO2"]
1903    #[inline]
1904    pub fn g3_io2(&mut self) -> _G3_IO2W {
1905        _G3_IO2W { w: self }
1906    }
1907    #[doc = "Bit 8 - G3_IO1"]
1908    #[inline]
1909    pub fn g3_io1(&mut self) -> _G3_IO1W {
1910        _G3_IO1W { w: self }
1911    }
1912    #[doc = "Bit 7 - G2_IO4"]
1913    #[inline]
1914    pub fn g2_io4(&mut self) -> _G2_IO4W {
1915        _G2_IO4W { w: self }
1916    }
1917    #[doc = "Bit 6 - G2_IO3"]
1918    #[inline]
1919    pub fn g2_io3(&mut self) -> _G2_IO3W {
1920        _G2_IO3W { w: self }
1921    }
1922    #[doc = "Bit 5 - G2_IO2"]
1923    #[inline]
1924    pub fn g2_io2(&mut self) -> _G2_IO2W {
1925        _G2_IO2W { w: self }
1926    }
1927    #[doc = "Bit 4 - G2_IO1"]
1928    #[inline]
1929    pub fn g2_io1(&mut self) -> _G2_IO1W {
1930        _G2_IO1W { w: self }
1931    }
1932    #[doc = "Bit 3 - G1_IO4"]
1933    #[inline]
1934    pub fn g1_io4(&mut self) -> _G1_IO4W {
1935        _G1_IO4W { w: self }
1936    }
1937    #[doc = "Bit 2 - G1_IO3"]
1938    #[inline]
1939    pub fn g1_io3(&mut self) -> _G1_IO3W {
1940        _G1_IO3W { w: self }
1941    }
1942    #[doc = "Bit 1 - G1_IO2"]
1943    #[inline]
1944    pub fn g1_io2(&mut self) -> _G1_IO2W {
1945        _G1_IO2W { w: self }
1946    }
1947    #[doc = "Bit 0 - G1_IO1"]
1948    #[inline]
1949    pub fn g1_io1(&mut self) -> _G1_IO1W {
1950        _G1_IO1W { w: self }
1951    }
1952}
stm32l4x2_pac/tsc/ioscr.rs

stm32l4x2_pac/tsc/
ioscr.rs
