ambiq_apollo3_pac2/gpio/
padregf.rs

1#[doc = "Register `PADREGF` reader"]
2pub struct R(crate::R<PADREGF_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<PADREGF_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<PADREGF_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<PADREGF_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `PADREGF` writer"]
17pub struct W(crate::W<PADREGF_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<PADREGF_SPEC>;
20    #[inline(always)]
21    fn deref(&self) -> &Self::Target {
22        &self.0
23    }
24}
25impl core::ops::DerefMut for W {
26    #[inline(always)]
27    fn deref_mut(&mut self) -> &mut Self::Target {
28        &mut self.0
29    }
30}
31impl From<crate::W<PADREGF_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<PADREGF_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Pad 23 function select\n\nValue on reset: 3"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39#[repr(u8)]
40pub enum PAD23FNCSEL_A {
41    #[doc = "0: Configure as the UART0 RX signal value."]
42    UART0RX = 0,
43    #[doc = "1: IOM/MSPI nCE group 23 value."]
44    NCE23 = 1,
45    #[doc = "2: CTIMER connection 14 value."]
46    CT14 = 2,
47    #[doc = "3: Configure as GPIO23 value."]
48    GPIO23 = 3,
49    #[doc = "4: I2S word clock input value."]
50    I2SWCLK = 4,
51    #[doc = "5: Configure as voltage comparitor output value."]
52    CMPOUT = 5,
53    #[doc = "6: MSPI data connection 3 value."]
54    MSPI3 = 6,
55    #[doc = "7: External XTAL osacillatgor input value."]
56    EXTXT = 7,
57}
58impl From<PAD23FNCSEL_A> for u8 {
59    #[inline(always)]
60    fn from(variant: PAD23FNCSEL_A) -> Self {
61        variant as _
62    }
63}
64#[doc = "Field `PAD23FNCSEL` reader - Pad 23 function select"]
65pub struct PAD23FNCSEL_R(crate::FieldReader<u8, PAD23FNCSEL_A>);
66impl PAD23FNCSEL_R {
67    pub(crate) fn new(bits: u8) -> Self {
68        PAD23FNCSEL_R(crate::FieldReader::new(bits))
69    }
70    #[doc = r"Get enumerated values variant"]
71    #[inline(always)]
72    pub fn variant(&self) -> PAD23FNCSEL_A {
73        match self.bits {
74            0 => PAD23FNCSEL_A::UART0RX,
75            1 => PAD23FNCSEL_A::NCE23,
76            2 => PAD23FNCSEL_A::CT14,
77            3 => PAD23FNCSEL_A::GPIO23,
78            4 => PAD23FNCSEL_A::I2SWCLK,
79            5 => PAD23FNCSEL_A::CMPOUT,
80            6 => PAD23FNCSEL_A::MSPI3,
81            7 => PAD23FNCSEL_A::EXTXT,
82            _ => unreachable!(),
83        }
84    }
85    #[doc = "Checks if the value of the field is `UART0RX`"]
86    #[inline(always)]
87    pub fn is_uart0rx(&self) -> bool {
88        **self == PAD23FNCSEL_A::UART0RX
89    }
90    #[doc = "Checks if the value of the field is `NCE23`"]
91    #[inline(always)]
92    pub fn is_nce23(&self) -> bool {
93        **self == PAD23FNCSEL_A::NCE23
94    }
95    #[doc = "Checks if the value of the field is `CT14`"]
96    #[inline(always)]
97    pub fn is_ct14(&self) -> bool {
98        **self == PAD23FNCSEL_A::CT14
99    }
100    #[doc = "Checks if the value of the field is `GPIO23`"]
101    #[inline(always)]
102    pub fn is_gpio23(&self) -> bool {
103        **self == PAD23FNCSEL_A::GPIO23
104    }
105    #[doc = "Checks if the value of the field is `I2SWCLK`"]
106    #[inline(always)]
107    pub fn is_i2swclk(&self) -> bool {
108        **self == PAD23FNCSEL_A::I2SWCLK
109    }
110    #[doc = "Checks if the value of the field is `CMPOUT`"]
111    #[inline(always)]
112    pub fn is_cmpout(&self) -> bool {
113        **self == PAD23FNCSEL_A::CMPOUT
114    }
115    #[doc = "Checks if the value of the field is `MSPI3`"]
116    #[inline(always)]
117    pub fn is_mspi3(&self) -> bool {
118        **self == PAD23FNCSEL_A::MSPI3
119    }
120    #[doc = "Checks if the value of the field is `EXTXT`"]
121    #[inline(always)]
122    pub fn is_extxt(&self) -> bool {
123        **self == PAD23FNCSEL_A::EXTXT
124    }
125}
126impl core::ops::Deref for PAD23FNCSEL_R {
127    type Target = crate::FieldReader<u8, PAD23FNCSEL_A>;
128    #[inline(always)]
129    fn deref(&self) -> &Self::Target {
130        &self.0
131    }
132}
133#[doc = "Field `PAD23FNCSEL` writer - Pad 23 function select"]
134pub struct PAD23FNCSEL_W<'a> {
135    w: &'a mut W,
136}
137impl<'a> PAD23FNCSEL_W<'a> {
138    #[doc = r"Writes `variant` to the field"]
139    #[inline(always)]
140    pub fn variant(self, variant: PAD23FNCSEL_A) -> &'a mut W {
141        self.bits(variant.into())
142    }
143    #[doc = "Configure as the UART0 RX signal value."]
144    #[inline(always)]
145    pub fn uart0rx(self) -> &'a mut W {
146        self.variant(PAD23FNCSEL_A::UART0RX)
147    }
148    #[doc = "IOM/MSPI nCE group 23 value."]
149    #[inline(always)]
150    pub fn nce23(self) -> &'a mut W {
151        self.variant(PAD23FNCSEL_A::NCE23)
152    }
153    #[doc = "CTIMER connection 14 value."]
154    #[inline(always)]
155    pub fn ct14(self) -> &'a mut W {
156        self.variant(PAD23FNCSEL_A::CT14)
157    }
158    #[doc = "Configure as GPIO23 value."]
159    #[inline(always)]
160    pub fn gpio23(self) -> &'a mut W {
161        self.variant(PAD23FNCSEL_A::GPIO23)
162    }
163    #[doc = "I2S word clock input value."]
164    #[inline(always)]
165    pub fn i2swclk(self) -> &'a mut W {
166        self.variant(PAD23FNCSEL_A::I2SWCLK)
167    }
168    #[doc = "Configure as voltage comparitor output value."]
169    #[inline(always)]
170    pub fn cmpout(self) -> &'a mut W {
171        self.variant(PAD23FNCSEL_A::CMPOUT)
172    }
173    #[doc = "MSPI data connection 3 value."]
174    #[inline(always)]
175    pub fn mspi3(self) -> &'a mut W {
176        self.variant(PAD23FNCSEL_A::MSPI3)
177    }
178    #[doc = "External XTAL osacillatgor input value."]
179    #[inline(always)]
180    pub fn extxt(self) -> &'a mut W {
181        self.variant(PAD23FNCSEL_A::EXTXT)
182    }
183    #[doc = r"Writes raw bits to the field"]
184    #[inline(always)]
185    pub fn bits(self, value: u8) -> &'a mut W {
186        self.w.bits = (self.w.bits & !(0x07 << 27)) | ((value as u32 & 0x07) << 27);
187        self.w
188    }
189}
190#[doc = "Pad 23 drive strength\n\nValue on reset: 0"]
191#[derive(Clone, Copy, Debug, PartialEq)]
192pub enum PAD23STRNG_A {
193    #[doc = "0: Low drive strength value."]
194    LOW = 0,
195    #[doc = "1: High drive strength value."]
196    HIGH = 1,
197}
198impl From<PAD23STRNG_A> for bool {
199    #[inline(always)]
200    fn from(variant: PAD23STRNG_A) -> Self {
201        variant as u8 != 0
202    }
203}
204#[doc = "Field `PAD23STRNG` reader - Pad 23 drive strength"]
205pub struct PAD23STRNG_R(crate::FieldReader<bool, PAD23STRNG_A>);
206impl PAD23STRNG_R {
207    pub(crate) fn new(bits: bool) -> Self {
208        PAD23STRNG_R(crate::FieldReader::new(bits))
209    }
210    #[doc = r"Get enumerated values variant"]
211    #[inline(always)]
212    pub fn variant(&self) -> PAD23STRNG_A {
213        match self.bits {
214            false => PAD23STRNG_A::LOW,
215            true => PAD23STRNG_A::HIGH,
216        }
217    }
218    #[doc = "Checks if the value of the field is `LOW`"]
219    #[inline(always)]
220    pub fn is_low(&self) -> bool {
221        **self == PAD23STRNG_A::LOW
222    }
223    #[doc = "Checks if the value of the field is `HIGH`"]
224    #[inline(always)]
225    pub fn is_high(&self) -> bool {
226        **self == PAD23STRNG_A::HIGH
227    }
228}
229impl core::ops::Deref for PAD23STRNG_R {
230    type Target = crate::FieldReader<bool, PAD23STRNG_A>;
231    #[inline(always)]
232    fn deref(&self) -> &Self::Target {
233        &self.0
234    }
235}
236#[doc = "Field `PAD23STRNG` writer - Pad 23 drive strength"]
237pub struct PAD23STRNG_W<'a> {
238    w: &'a mut W,
239}
240impl<'a> PAD23STRNG_W<'a> {
241    #[doc = r"Writes `variant` to the field"]
242    #[inline(always)]
243    pub fn variant(self, variant: PAD23STRNG_A) -> &'a mut W {
244        self.bit(variant.into())
245    }
246    #[doc = "Low drive strength value."]
247    #[inline(always)]
248    pub fn low(self) -> &'a mut W {
249        self.variant(PAD23STRNG_A::LOW)
250    }
251    #[doc = "High drive strength value."]
252    #[inline(always)]
253    pub fn high(self) -> &'a mut W {
254        self.variant(PAD23STRNG_A::HIGH)
255    }
256    #[doc = r"Sets the field bit"]
257    #[inline(always)]
258    pub fn set_bit(self) -> &'a mut W {
259        self.bit(true)
260    }
261    #[doc = r"Clears the field bit"]
262    #[inline(always)]
263    pub fn clear_bit(self) -> &'a mut W {
264        self.bit(false)
265    }
266    #[doc = r"Writes raw bits to the field"]
267    #[inline(always)]
268    pub fn bit(self, value: bool) -> &'a mut W {
269        self.w.bits = (self.w.bits & !(0x01 << 26)) | ((value as u32 & 0x01) << 26);
270        self.w
271    }
272}
273#[doc = "Pad 23 input enable\n\nValue on reset: 0"]
274#[derive(Clone, Copy, Debug, PartialEq)]
275pub enum PAD23INPEN_A {
276    #[doc = "0: Pad input disabled value."]
277    DIS = 0,
278    #[doc = "1: Pad input enabled value."]
279    EN = 1,
280}
281impl From<PAD23INPEN_A> for bool {
282    #[inline(always)]
283    fn from(variant: PAD23INPEN_A) -> Self {
284        variant as u8 != 0
285    }
286}
287#[doc = "Field `PAD23INPEN` reader - Pad 23 input enable"]
288pub struct PAD23INPEN_R(crate::FieldReader<bool, PAD23INPEN_A>);
289impl PAD23INPEN_R {
290    pub(crate) fn new(bits: bool) -> Self {
291        PAD23INPEN_R(crate::FieldReader::new(bits))
292    }
293    #[doc = r"Get enumerated values variant"]
294    #[inline(always)]
295    pub fn variant(&self) -> PAD23INPEN_A {
296        match self.bits {
297            false => PAD23INPEN_A::DIS,
298            true => PAD23INPEN_A::EN,
299        }
300    }
301    #[doc = "Checks if the value of the field is `DIS`"]
302    #[inline(always)]
303    pub fn is_dis(&self) -> bool {
304        **self == PAD23INPEN_A::DIS
305    }
306    #[doc = "Checks if the value of the field is `EN`"]
307    #[inline(always)]
308    pub fn is_en(&self) -> bool {
309        **self == PAD23INPEN_A::EN
310    }
311}
312impl core::ops::Deref for PAD23INPEN_R {
313    type Target = crate::FieldReader<bool, PAD23INPEN_A>;
314    #[inline(always)]
315    fn deref(&self) -> &Self::Target {
316        &self.0
317    }
318}
319#[doc = "Field `PAD23INPEN` writer - Pad 23 input enable"]
320pub struct PAD23INPEN_W<'a> {
321    w: &'a mut W,
322}
323impl<'a> PAD23INPEN_W<'a> {
324    #[doc = r"Writes `variant` to the field"]
325    #[inline(always)]
326    pub fn variant(self, variant: PAD23INPEN_A) -> &'a mut W {
327        self.bit(variant.into())
328    }
329    #[doc = "Pad input disabled value."]
330    #[inline(always)]
331    pub fn dis(self) -> &'a mut W {
332        self.variant(PAD23INPEN_A::DIS)
333    }
334    #[doc = "Pad input enabled value."]
335    #[inline(always)]
336    pub fn en(self) -> &'a mut W {
337        self.variant(PAD23INPEN_A::EN)
338    }
339    #[doc = r"Sets the field bit"]
340    #[inline(always)]
341    pub fn set_bit(self) -> &'a mut W {
342        self.bit(true)
343    }
344    #[doc = r"Clears the field bit"]
345    #[inline(always)]
346    pub fn clear_bit(self) -> &'a mut W {
347        self.bit(false)
348    }
349    #[doc = r"Writes raw bits to the field"]
350    #[inline(always)]
351    pub fn bit(self, value: bool) -> &'a mut W {
352        self.w.bits = (self.w.bits & !(0x01 << 25)) | ((value as u32 & 0x01) << 25);
353        self.w
354    }
355}
356#[doc = "Pad 23 pullup enable\n\nValue on reset: 0"]
357#[derive(Clone, Copy, Debug, PartialEq)]
358pub enum PAD23PULL_A {
359    #[doc = "0: Pullup disabled value."]
360    DIS = 0,
361    #[doc = "1: Pullup enabled value."]
362    EN = 1,
363}
364impl From<PAD23PULL_A> for bool {
365    #[inline(always)]
366    fn from(variant: PAD23PULL_A) -> Self {
367        variant as u8 != 0
368    }
369}
370#[doc = "Field `PAD23PULL` reader - Pad 23 pullup enable"]
371pub struct PAD23PULL_R(crate::FieldReader<bool, PAD23PULL_A>);
372impl PAD23PULL_R {
373    pub(crate) fn new(bits: bool) -> Self {
374        PAD23PULL_R(crate::FieldReader::new(bits))
375    }
376    #[doc = r"Get enumerated values variant"]
377    #[inline(always)]
378    pub fn variant(&self) -> PAD23PULL_A {
379        match self.bits {
380            false => PAD23PULL_A::DIS,
381            true => PAD23PULL_A::EN,
382        }
383    }
384    #[doc = "Checks if the value of the field is `DIS`"]
385    #[inline(always)]
386    pub fn is_dis(&self) -> bool {
387        **self == PAD23PULL_A::DIS
388    }
389    #[doc = "Checks if the value of the field is `EN`"]
390    #[inline(always)]
391    pub fn is_en(&self) -> bool {
392        **self == PAD23PULL_A::EN
393    }
394}
395impl core::ops::Deref for PAD23PULL_R {
396    type Target = crate::FieldReader<bool, PAD23PULL_A>;
397    #[inline(always)]
398    fn deref(&self) -> &Self::Target {
399        &self.0
400    }
401}
402#[doc = "Field `PAD23PULL` writer - Pad 23 pullup enable"]
403pub struct PAD23PULL_W<'a> {
404    w: &'a mut W,
405}
406impl<'a> PAD23PULL_W<'a> {
407    #[doc = r"Writes `variant` to the field"]
408    #[inline(always)]
409    pub fn variant(self, variant: PAD23PULL_A) -> &'a mut W {
410        self.bit(variant.into())
411    }
412    #[doc = "Pullup disabled value."]
413    #[inline(always)]
414    pub fn dis(self) -> &'a mut W {
415        self.variant(PAD23PULL_A::DIS)
416    }
417    #[doc = "Pullup enabled value."]
418    #[inline(always)]
419    pub fn en(self) -> &'a mut W {
420        self.variant(PAD23PULL_A::EN)
421    }
422    #[doc = r"Sets the field bit"]
423    #[inline(always)]
424    pub fn set_bit(self) -> &'a mut W {
425        self.bit(true)
426    }
427    #[doc = r"Clears the field bit"]
428    #[inline(always)]
429    pub fn clear_bit(self) -> &'a mut W {
430        self.bit(false)
431    }
432    #[doc = r"Writes raw bits to the field"]
433    #[inline(always)]
434    pub fn bit(self, value: bool) -> &'a mut W {
435        self.w.bits = (self.w.bits & !(0x01 << 24)) | ((value as u32 & 0x01) << 24);
436        self.w
437    }
438}
439#[doc = "Pad 22 function select\n\nValue on reset: 3"]
440#[derive(Clone, Copy, Debug, PartialEq)]
441#[repr(u8)]
442pub enum PAD22FNCSEL_A {
443    #[doc = "0: Configure as the UART0 TX signal value."]
444    UART0TX = 0,
445    #[doc = "1: IOM/MSPI nCE group 22 value."]
446    NCE22 = 1,
447    #[doc = "2: CTIMER connection 12 value."]
448    CT12 = 2,
449    #[doc = "3: Configure as GPIO22 value."]
450    GPIO22 = 3,
451    #[doc = "4: Configure as the PDM CLK output value."]
452    PDM_CLK = 4,
453    #[doc = "5: External LFRC input value."]
454    EXTLF = 5,
455    #[doc = "6: MSPI data connection 0 value."]
456    MSPI0 = 6,
457    #[doc = "7: Configure as the serial trace data output signal value."]
458    SWO = 7,
459}
460impl From<PAD22FNCSEL_A> for u8 {
461    #[inline(always)]
462    fn from(variant: PAD22FNCSEL_A) -> Self {
463        variant as _
464    }
465}
466#[doc = "Field `PAD22FNCSEL` reader - Pad 22 function select"]
467pub struct PAD22FNCSEL_R(crate::FieldReader<u8, PAD22FNCSEL_A>);
468impl PAD22FNCSEL_R {
469    pub(crate) fn new(bits: u8) -> Self {
470        PAD22FNCSEL_R(crate::FieldReader::new(bits))
471    }
472    #[doc = r"Get enumerated values variant"]
473    #[inline(always)]
474    pub fn variant(&self) -> PAD22FNCSEL_A {
475        match self.bits {
476            0 => PAD22FNCSEL_A::UART0TX,
477            1 => PAD22FNCSEL_A::NCE22,
478            2 => PAD22FNCSEL_A::CT12,
479            3 => PAD22FNCSEL_A::GPIO22,
480            4 => PAD22FNCSEL_A::PDM_CLK,
481            5 => PAD22FNCSEL_A::EXTLF,
482            6 => PAD22FNCSEL_A::MSPI0,
483            7 => PAD22FNCSEL_A::SWO,
484            _ => unreachable!(),
485        }
486    }
487    #[doc = "Checks if the value of the field is `UART0TX`"]
488    #[inline(always)]
489    pub fn is_uart0tx(&self) -> bool {
490        **self == PAD22FNCSEL_A::UART0TX
491    }
492    #[doc = "Checks if the value of the field is `NCE22`"]
493    #[inline(always)]
494    pub fn is_nce22(&self) -> bool {
495        **self == PAD22FNCSEL_A::NCE22
496    }
497    #[doc = "Checks if the value of the field is `CT12`"]
498    #[inline(always)]
499    pub fn is_ct12(&self) -> bool {
500        **self == PAD22FNCSEL_A::CT12
501    }
502    #[doc = "Checks if the value of the field is `GPIO22`"]
503    #[inline(always)]
504    pub fn is_gpio22(&self) -> bool {
505        **self == PAD22FNCSEL_A::GPIO22
506    }
507    #[doc = "Checks if the value of the field is `PDM_CLK`"]
508    #[inline(always)]
509    pub fn is_pdm_clk(&self) -> bool {
510        **self == PAD22FNCSEL_A::PDM_CLK
511    }
512    #[doc = "Checks if the value of the field is `EXTLF`"]
513    #[inline(always)]
514    pub fn is_extlf(&self) -> bool {
515        **self == PAD22FNCSEL_A::EXTLF
516    }
517    #[doc = "Checks if the value of the field is `MSPI0`"]
518    #[inline(always)]
519    pub fn is_mspi0(&self) -> bool {
520        **self == PAD22FNCSEL_A::MSPI0
521    }
522    #[doc = "Checks if the value of the field is `SWO`"]
523    #[inline(always)]
524    pub fn is_swo(&self) -> bool {
525        **self == PAD22FNCSEL_A::SWO
526    }
527}
528impl core::ops::Deref for PAD22FNCSEL_R {
529    type Target = crate::FieldReader<u8, PAD22FNCSEL_A>;
530    #[inline(always)]
531    fn deref(&self) -> &Self::Target {
532        &self.0
533    }
534}
535#[doc = "Field `PAD22FNCSEL` writer - Pad 22 function select"]
536pub struct PAD22FNCSEL_W<'a> {
537    w: &'a mut W,
538}
539impl<'a> PAD22FNCSEL_W<'a> {
540    #[doc = r"Writes `variant` to the field"]
541    #[inline(always)]
542    pub fn variant(self, variant: PAD22FNCSEL_A) -> &'a mut W {
543        self.bits(variant.into())
544    }
545    #[doc = "Configure as the UART0 TX signal value."]
546    #[inline(always)]
547    pub fn uart0tx(self) -> &'a mut W {
548        self.variant(PAD22FNCSEL_A::UART0TX)
549    }
550    #[doc = "IOM/MSPI nCE group 22 value."]
551    #[inline(always)]
552    pub fn nce22(self) -> &'a mut W {
553        self.variant(PAD22FNCSEL_A::NCE22)
554    }
555    #[doc = "CTIMER connection 12 value."]
556    #[inline(always)]
557    pub fn ct12(self) -> &'a mut W {
558        self.variant(PAD22FNCSEL_A::CT12)
559    }
560    #[doc = "Configure as GPIO22 value."]
561    #[inline(always)]
562    pub fn gpio22(self) -> &'a mut W {
563        self.variant(PAD22FNCSEL_A::GPIO22)
564    }
565    #[doc = "Configure as the PDM CLK output value."]
566    #[inline(always)]
567    pub fn pdm_clk(self) -> &'a mut W {
568        self.variant(PAD22FNCSEL_A::PDM_CLK)
569    }
570    #[doc = "External LFRC input value."]
571    #[inline(always)]
572    pub fn extlf(self) -> &'a mut W {
573        self.variant(PAD22FNCSEL_A::EXTLF)
574    }
575    #[doc = "MSPI data connection 0 value."]
576    #[inline(always)]
577    pub fn mspi0(self) -> &'a mut W {
578        self.variant(PAD22FNCSEL_A::MSPI0)
579    }
580    #[doc = "Configure as the serial trace data output signal value."]
581    #[inline(always)]
582    pub fn swo(self) -> &'a mut W {
583        self.variant(PAD22FNCSEL_A::SWO)
584    }
585    #[doc = r"Writes raw bits to the field"]
586    #[inline(always)]
587    pub fn bits(self, value: u8) -> &'a mut W {
588        self.w.bits = (self.w.bits & !(0x07 << 19)) | ((value as u32 & 0x07) << 19);
589        self.w
590    }
591}
592#[doc = "Pad 22 drive strength\n\nValue on reset: 0"]
593#[derive(Clone, Copy, Debug, PartialEq)]
594pub enum PAD22STRNG_A {
595    #[doc = "0: Low drive strength value."]
596    LOW = 0,
597    #[doc = "1: High drive strength value."]
598    HIGH = 1,
599}
600impl From<PAD22STRNG_A> for bool {
601    #[inline(always)]
602    fn from(variant: PAD22STRNG_A) -> Self {
603        variant as u8 != 0
604    }
605}
606#[doc = "Field `PAD22STRNG` reader - Pad 22 drive strength"]
607pub struct PAD22STRNG_R(crate::FieldReader<bool, PAD22STRNG_A>);
608impl PAD22STRNG_R {
609    pub(crate) fn new(bits: bool) -> Self {
610        PAD22STRNG_R(crate::FieldReader::new(bits))
611    }
612    #[doc = r"Get enumerated values variant"]
613    #[inline(always)]
614    pub fn variant(&self) -> PAD22STRNG_A {
615        match self.bits {
616            false => PAD22STRNG_A::LOW,
617            true => PAD22STRNG_A::HIGH,
618        }
619    }
620    #[doc = "Checks if the value of the field is `LOW`"]
621    #[inline(always)]
622    pub fn is_low(&self) -> bool {
623        **self == PAD22STRNG_A::LOW
624    }
625    #[doc = "Checks if the value of the field is `HIGH`"]
626    #[inline(always)]
627    pub fn is_high(&self) -> bool {
628        **self == PAD22STRNG_A::HIGH
629    }
630}
631impl core::ops::Deref for PAD22STRNG_R {
632    type Target = crate::FieldReader<bool, PAD22STRNG_A>;
633    #[inline(always)]
634    fn deref(&self) -> &Self::Target {
635        &self.0
636    }
637}
638#[doc = "Field `PAD22STRNG` writer - Pad 22 drive strength"]
639pub struct PAD22STRNG_W<'a> {
640    w: &'a mut W,
641}
642impl<'a> PAD22STRNG_W<'a> {
643    #[doc = r"Writes `variant` to the field"]
644    #[inline(always)]
645    pub fn variant(self, variant: PAD22STRNG_A) -> &'a mut W {
646        self.bit(variant.into())
647    }
648    #[doc = "Low drive strength value."]
649    #[inline(always)]
650    pub fn low(self) -> &'a mut W {
651        self.variant(PAD22STRNG_A::LOW)
652    }
653    #[doc = "High drive strength value."]
654    #[inline(always)]
655    pub fn high(self) -> &'a mut W {
656        self.variant(PAD22STRNG_A::HIGH)
657    }
658    #[doc = r"Sets the field bit"]
659    #[inline(always)]
660    pub fn set_bit(self) -> &'a mut W {
661        self.bit(true)
662    }
663    #[doc = r"Clears the field bit"]
664    #[inline(always)]
665    pub fn clear_bit(self) -> &'a mut W {
666        self.bit(false)
667    }
668    #[doc = r"Writes raw bits to the field"]
669    #[inline(always)]
670    pub fn bit(self, value: bool) -> &'a mut W {
671        self.w.bits = (self.w.bits & !(0x01 << 18)) | ((value as u32 & 0x01) << 18);
672        self.w
673    }
674}
675#[doc = "Pad 22 input enable\n\nValue on reset: 0"]
676#[derive(Clone, Copy, Debug, PartialEq)]
677pub enum PAD22INPEN_A {
678    #[doc = "0: Pad input disabled value."]
679    DIS = 0,
680    #[doc = "1: Pad input enabled value."]
681    EN = 1,
682}
683impl From<PAD22INPEN_A> for bool {
684    #[inline(always)]
685    fn from(variant: PAD22INPEN_A) -> Self {
686        variant as u8 != 0
687    }
688}
689#[doc = "Field `PAD22INPEN` reader - Pad 22 input enable"]
690pub struct PAD22INPEN_R(crate::FieldReader<bool, PAD22INPEN_A>);
691impl PAD22INPEN_R {
692    pub(crate) fn new(bits: bool) -> Self {
693        PAD22INPEN_R(crate::FieldReader::new(bits))
694    }
695    #[doc = r"Get enumerated values variant"]
696    #[inline(always)]
697    pub fn variant(&self) -> PAD22INPEN_A {
698        match self.bits {
699            false => PAD22INPEN_A::DIS,
700            true => PAD22INPEN_A::EN,
701        }
702    }
703    #[doc = "Checks if the value of the field is `DIS`"]
704    #[inline(always)]
705    pub fn is_dis(&self) -> bool {
706        **self == PAD22INPEN_A::DIS
707    }
708    #[doc = "Checks if the value of the field is `EN`"]
709    #[inline(always)]
710    pub fn is_en(&self) -> bool {
711        **self == PAD22INPEN_A::EN
712    }
713}
714impl core::ops::Deref for PAD22INPEN_R {
715    type Target = crate::FieldReader<bool, PAD22INPEN_A>;
716    #[inline(always)]
717    fn deref(&self) -> &Self::Target {
718        &self.0
719    }
720}
721#[doc = "Field `PAD22INPEN` writer - Pad 22 input enable"]
722pub struct PAD22INPEN_W<'a> {
723    w: &'a mut W,
724}
725impl<'a> PAD22INPEN_W<'a> {
726    #[doc = r"Writes `variant` to the field"]
727    #[inline(always)]
728    pub fn variant(self, variant: PAD22INPEN_A) -> &'a mut W {
729        self.bit(variant.into())
730    }
731    #[doc = "Pad input disabled value."]
732    #[inline(always)]
733    pub fn dis(self) -> &'a mut W {
734        self.variant(PAD22INPEN_A::DIS)
735    }
736    #[doc = "Pad input enabled value."]
737    #[inline(always)]
738    pub fn en(self) -> &'a mut W {
739        self.variant(PAD22INPEN_A::EN)
740    }
741    #[doc = r"Sets the field bit"]
742    #[inline(always)]
743    pub fn set_bit(self) -> &'a mut W {
744        self.bit(true)
745    }
746    #[doc = r"Clears the field bit"]
747    #[inline(always)]
748    pub fn clear_bit(self) -> &'a mut W {
749        self.bit(false)
750    }
751    #[doc = r"Writes raw bits to the field"]
752    #[inline(always)]
753    pub fn bit(self, value: bool) -> &'a mut W {
754        self.w.bits = (self.w.bits & !(0x01 << 17)) | ((value as u32 & 0x01) << 17);
755        self.w
756    }
757}
758#[doc = "Pad 22 pullup enable\n\nValue on reset: 0"]
759#[derive(Clone, Copy, Debug, PartialEq)]
760pub enum PAD22PULL_A {
761    #[doc = "0: Pullup disabled value."]
762    DIS = 0,
763    #[doc = "1: Pullup enabled value."]
764    EN = 1,
765}
766impl From<PAD22PULL_A> for bool {
767    #[inline(always)]
768    fn from(variant: PAD22PULL_A) -> Self {
769        variant as u8 != 0
770    }
771}
772#[doc = "Field `PAD22PULL` reader - Pad 22 pullup enable"]
773pub struct PAD22PULL_R(crate::FieldReader<bool, PAD22PULL_A>);
774impl PAD22PULL_R {
775    pub(crate) fn new(bits: bool) -> Self {
776        PAD22PULL_R(crate::FieldReader::new(bits))
777    }
778    #[doc = r"Get enumerated values variant"]
779    #[inline(always)]
780    pub fn variant(&self) -> PAD22PULL_A {
781        match self.bits {
782            false => PAD22PULL_A::DIS,
783            true => PAD22PULL_A::EN,
784        }
785    }
786    #[doc = "Checks if the value of the field is `DIS`"]
787    #[inline(always)]
788    pub fn is_dis(&self) -> bool {
789        **self == PAD22PULL_A::DIS
790    }
791    #[doc = "Checks if the value of the field is `EN`"]
792    #[inline(always)]
793    pub fn is_en(&self) -> bool {
794        **self == PAD22PULL_A::EN
795    }
796}
797impl core::ops::Deref for PAD22PULL_R {
798    type Target = crate::FieldReader<bool, PAD22PULL_A>;
799    #[inline(always)]
800    fn deref(&self) -> &Self::Target {
801        &self.0
802    }
803}
804#[doc = "Field `PAD22PULL` writer - Pad 22 pullup enable"]
805pub struct PAD22PULL_W<'a> {
806    w: &'a mut W,
807}
808impl<'a> PAD22PULL_W<'a> {
809    #[doc = r"Writes `variant` to the field"]
810    #[inline(always)]
811    pub fn variant(self, variant: PAD22PULL_A) -> &'a mut W {
812        self.bit(variant.into())
813    }
814    #[doc = "Pullup disabled value."]
815    #[inline(always)]
816    pub fn dis(self) -> &'a mut W {
817        self.variant(PAD22PULL_A::DIS)
818    }
819    #[doc = "Pullup enabled value."]
820    #[inline(always)]
821    pub fn en(self) -> &'a mut W {
822        self.variant(PAD22PULL_A::EN)
823    }
824    #[doc = r"Sets the field bit"]
825    #[inline(always)]
826    pub fn set_bit(self) -> &'a mut W {
827        self.bit(true)
828    }
829    #[doc = r"Clears the field bit"]
830    #[inline(always)]
831    pub fn clear_bit(self) -> &'a mut W {
832        self.bit(false)
833    }
834    #[doc = r"Writes raw bits to the field"]
835    #[inline(always)]
836    pub fn bit(self, value: bool) -> &'a mut W {
837        self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
838        self.w
839    }
840}
841#[doc = "Pad 21 function select\n\nValue on reset: 0"]
842#[derive(Clone, Copy, Debug, PartialEq)]
843#[repr(u8)]
844pub enum PAD21FNCSEL_A {
845    #[doc = "0: Configure as the serial wire debug data signal value."]
846    SWDIO = 0,
847    #[doc = "1: IOM/MSPI nCE group 21 value."]
848    NCE21 = 1,
849    #[doc = "3: Configure as GPIO21 value."]
850    GPIO21 = 3,
851    #[doc = "4: Configure as UART0 RX input signal value."]
852    UART0RX = 4,
853    #[doc = "5: Configure as UART1 RX input signal value."]
854    UART1RX = 5,
855    #[doc = "6: I2S byte clock input value."]
856    I2SBCLK = 6,
857    #[doc = "7: Configure as UART1 CTS input signal value."]
858    UA1CTS = 7,
859}
860impl From<PAD21FNCSEL_A> for u8 {
861    #[inline(always)]
862    fn from(variant: PAD21FNCSEL_A) -> Self {
863        variant as _
864    }
865}
866#[doc = "Field `PAD21FNCSEL` reader - Pad 21 function select"]
867pub struct PAD21FNCSEL_R(crate::FieldReader<u8, PAD21FNCSEL_A>);
868impl PAD21FNCSEL_R {
869    pub(crate) fn new(bits: u8) -> Self {
870        PAD21FNCSEL_R(crate::FieldReader::new(bits))
871    }
872    #[doc = r"Get enumerated values variant"]
873    #[inline(always)]
874    pub fn variant(&self) -> Option<PAD21FNCSEL_A> {
875        match self.bits {
876            0 => Some(PAD21FNCSEL_A::SWDIO),
877            1 => Some(PAD21FNCSEL_A::NCE21),
878            3 => Some(PAD21FNCSEL_A::GPIO21),
879            4 => Some(PAD21FNCSEL_A::UART0RX),
880            5 => Some(PAD21FNCSEL_A::UART1RX),
881            6 => Some(PAD21FNCSEL_A::I2SBCLK),
882            7 => Some(PAD21FNCSEL_A::UA1CTS),
883            _ => None,
884        }
885    }
886    #[doc = "Checks if the value of the field is `SWDIO`"]
887    #[inline(always)]
888    pub fn is_swdio(&self) -> bool {
889        **self == PAD21FNCSEL_A::SWDIO
890    }
891    #[doc = "Checks if the value of the field is `NCE21`"]
892    #[inline(always)]
893    pub fn is_nce21(&self) -> bool {
894        **self == PAD21FNCSEL_A::NCE21
895    }
896    #[doc = "Checks if the value of the field is `GPIO21`"]
897    #[inline(always)]
898    pub fn is_gpio21(&self) -> bool {
899        **self == PAD21FNCSEL_A::GPIO21
900    }
901    #[doc = "Checks if the value of the field is `UART0RX`"]
902    #[inline(always)]
903    pub fn is_uart0rx(&self) -> bool {
904        **self == PAD21FNCSEL_A::UART0RX
905    }
906    #[doc = "Checks if the value of the field is `UART1RX`"]
907    #[inline(always)]
908    pub fn is_uart1rx(&self) -> bool {
909        **self == PAD21FNCSEL_A::UART1RX
910    }
911    #[doc = "Checks if the value of the field is `I2SBCLK`"]
912    #[inline(always)]
913    pub fn is_i2sbclk(&self) -> bool {
914        **self == PAD21FNCSEL_A::I2SBCLK
915    }
916    #[doc = "Checks if the value of the field is `UA1CTS`"]
917    #[inline(always)]
918    pub fn is_ua1cts(&self) -> bool {
919        **self == PAD21FNCSEL_A::UA1CTS
920    }
921}
922impl core::ops::Deref for PAD21FNCSEL_R {
923    type Target = crate::FieldReader<u8, PAD21FNCSEL_A>;
924    #[inline(always)]
925    fn deref(&self) -> &Self::Target {
926        &self.0
927    }
928}
929#[doc = "Field `PAD21FNCSEL` writer - Pad 21 function select"]
930pub struct PAD21FNCSEL_W<'a> {
931    w: &'a mut W,
932}
933impl<'a> PAD21FNCSEL_W<'a> {
934    #[doc = r"Writes `variant` to the field"]
935    #[inline(always)]
936    pub fn variant(self, variant: PAD21FNCSEL_A) -> &'a mut W {
937        unsafe { self.bits(variant.into()) }
938    }
939    #[doc = "Configure as the serial wire debug data signal value."]
940    #[inline(always)]
941    pub fn swdio(self) -> &'a mut W {
942        self.variant(PAD21FNCSEL_A::SWDIO)
943    }
944    #[doc = "IOM/MSPI nCE group 21 value."]
945    #[inline(always)]
946    pub fn nce21(self) -> &'a mut W {
947        self.variant(PAD21FNCSEL_A::NCE21)
948    }
949    #[doc = "Configure as GPIO21 value."]
950    #[inline(always)]
951    pub fn gpio21(self) -> &'a mut W {
952        self.variant(PAD21FNCSEL_A::GPIO21)
953    }
954    #[doc = "Configure as UART0 RX input signal value."]
955    #[inline(always)]
956    pub fn uart0rx(self) -> &'a mut W {
957        self.variant(PAD21FNCSEL_A::UART0RX)
958    }
959    #[doc = "Configure as UART1 RX input signal value."]
960    #[inline(always)]
961    pub fn uart1rx(self) -> &'a mut W {
962        self.variant(PAD21FNCSEL_A::UART1RX)
963    }
964    #[doc = "I2S byte clock input value."]
965    #[inline(always)]
966    pub fn i2sbclk(self) -> &'a mut W {
967        self.variant(PAD21FNCSEL_A::I2SBCLK)
968    }
969    #[doc = "Configure as UART1 CTS input signal value."]
970    #[inline(always)]
971    pub fn ua1cts(self) -> &'a mut W {
972        self.variant(PAD21FNCSEL_A::UA1CTS)
973    }
974    #[doc = r"Writes raw bits to the field"]
975    #[inline(always)]
976    pub unsafe fn bits(self, value: u8) -> &'a mut W {
977        self.w.bits = (self.w.bits & !(0x07 << 11)) | ((value as u32 & 0x07) << 11);
978        self.w
979    }
980}
981#[doc = "Pad 21 drive strength\n\nValue on reset: 0"]
982#[derive(Clone, Copy, Debug, PartialEq)]
983pub enum PAD21STRNG_A {
984    #[doc = "0: Low drive strength value."]
985    LOW = 0,
986    #[doc = "1: High drive strength value."]
987    HIGH = 1,
988}
989impl From<PAD21STRNG_A> for bool {
990    #[inline(always)]
991    fn from(variant: PAD21STRNG_A) -> Self {
992        variant as u8 != 0
993    }
994}
995#[doc = "Field `PAD21STRNG` reader - Pad 21 drive strength"]
996pub struct PAD21STRNG_R(crate::FieldReader<bool, PAD21STRNG_A>);
997impl PAD21STRNG_R {
998    pub(crate) fn new(bits: bool) -> Self {
999        PAD21STRNG_R(crate::FieldReader::new(bits))
1000    }
1001    #[doc = r"Get enumerated values variant"]
1002    #[inline(always)]
1003    pub fn variant(&self) -> PAD21STRNG_A {
1004        match self.bits {
1005            false => PAD21STRNG_A::LOW,
1006            true => PAD21STRNG_A::HIGH,
1007        }
1008    }
1009    #[doc = "Checks if the value of the field is `LOW`"]
1010    #[inline(always)]
1011    pub fn is_low(&self) -> bool {
1012        **self == PAD21STRNG_A::LOW
1013    }
1014    #[doc = "Checks if the value of the field is `HIGH`"]
1015    #[inline(always)]
1016    pub fn is_high(&self) -> bool {
1017        **self == PAD21STRNG_A::HIGH
1018    }
1019}
1020impl core::ops::Deref for PAD21STRNG_R {
1021    type Target = crate::FieldReader<bool, PAD21STRNG_A>;
1022    #[inline(always)]
1023    fn deref(&self) -> &Self::Target {
1024        &self.0
1025    }
1026}
1027#[doc = "Field `PAD21STRNG` writer - Pad 21 drive strength"]
1028pub struct PAD21STRNG_W<'a> {
1029    w: &'a mut W,
1030}
1031impl<'a> PAD21STRNG_W<'a> {
1032    #[doc = r"Writes `variant` to the field"]
1033    #[inline(always)]
1034    pub fn variant(self, variant: PAD21STRNG_A) -> &'a mut W {
1035        self.bit(variant.into())
1036    }
1037    #[doc = "Low drive strength value."]
1038    #[inline(always)]
1039    pub fn low(self) -> &'a mut W {
1040        self.variant(PAD21STRNG_A::LOW)
1041    }
1042    #[doc = "High drive strength value."]
1043    #[inline(always)]
1044    pub fn high(self) -> &'a mut W {
1045        self.variant(PAD21STRNG_A::HIGH)
1046    }
1047    #[doc = r"Sets the field bit"]
1048    #[inline(always)]
1049    pub fn set_bit(self) -> &'a mut W {
1050        self.bit(true)
1051    }
1052    #[doc = r"Clears the field bit"]
1053    #[inline(always)]
1054    pub fn clear_bit(self) -> &'a mut W {
1055        self.bit(false)
1056    }
1057    #[doc = r"Writes raw bits to the field"]
1058    #[inline(always)]
1059    pub fn bit(self, value: bool) -> &'a mut W {
1060        self.w.bits = (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
1061        self.w
1062    }
1063}
1064#[doc = "Pad 21 input enable\n\nValue on reset: 1"]
1065#[derive(Clone, Copy, Debug, PartialEq)]
1066pub enum PAD21INPEN_A {
1067    #[doc = "0: Pad input disabled value."]
1068    DIS = 0,
1069    #[doc = "1: Pad input enabled value."]
1070    EN = 1,
1071}
1072impl From<PAD21INPEN_A> for bool {
1073    #[inline(always)]
1074    fn from(variant: PAD21INPEN_A) -> Self {
1075        variant as u8 != 0
1076    }
1077}
1078#[doc = "Field `PAD21INPEN` reader - Pad 21 input enable"]
1079pub struct PAD21INPEN_R(crate::FieldReader<bool, PAD21INPEN_A>);
1080impl PAD21INPEN_R {
1081    pub(crate) fn new(bits: bool) -> Self {
1082        PAD21INPEN_R(crate::FieldReader::new(bits))
1083    }
1084    #[doc = r"Get enumerated values variant"]
1085    #[inline(always)]
1086    pub fn variant(&self) -> PAD21INPEN_A {
1087        match self.bits {
1088            false => PAD21INPEN_A::DIS,
1089            true => PAD21INPEN_A::EN,
1090        }
1091    }
1092    #[doc = "Checks if the value of the field is `DIS`"]
1093    #[inline(always)]
1094    pub fn is_dis(&self) -> bool {
1095        **self == PAD21INPEN_A::DIS
1096    }
1097    #[doc = "Checks if the value of the field is `EN`"]
1098    #[inline(always)]
1099    pub fn is_en(&self) -> bool {
1100        **self == PAD21INPEN_A::EN
1101    }
1102}
1103impl core::ops::Deref for PAD21INPEN_R {
1104    type Target = crate::FieldReader<bool, PAD21INPEN_A>;
1105    #[inline(always)]
1106    fn deref(&self) -> &Self::Target {
1107        &self.0
1108    }
1109}
1110#[doc = "Field `PAD21INPEN` writer - Pad 21 input enable"]
1111pub struct PAD21INPEN_W<'a> {
1112    w: &'a mut W,
1113}
1114impl<'a> PAD21INPEN_W<'a> {
1115    #[doc = r"Writes `variant` to the field"]
1116    #[inline(always)]
1117    pub fn variant(self, variant: PAD21INPEN_A) -> &'a mut W {
1118        self.bit(variant.into())
1119    }
1120    #[doc = "Pad input disabled value."]
1121    #[inline(always)]
1122    pub fn dis(self) -> &'a mut W {
1123        self.variant(PAD21INPEN_A::DIS)
1124    }
1125    #[doc = "Pad input enabled value."]
1126    #[inline(always)]
1127    pub fn en(self) -> &'a mut W {
1128        self.variant(PAD21INPEN_A::EN)
1129    }
1130    #[doc = r"Sets the field bit"]
1131    #[inline(always)]
1132    pub fn set_bit(self) -> &'a mut W {
1133        self.bit(true)
1134    }
1135    #[doc = r"Clears the field bit"]
1136    #[inline(always)]
1137    pub fn clear_bit(self) -> &'a mut W {
1138        self.bit(false)
1139    }
1140    #[doc = r"Writes raw bits to the field"]
1141    #[inline(always)]
1142    pub fn bit(self, value: bool) -> &'a mut W {
1143        self.w.bits = (self.w.bits & !(0x01 << 9)) | ((value as u32 & 0x01) << 9);
1144        self.w
1145    }
1146}
1147#[doc = "Pad 21 pullup enable\n\nValue on reset: 0"]
1148#[derive(Clone, Copy, Debug, PartialEq)]
1149pub enum PAD21PULL_A {
1150    #[doc = "0: Pullup disabled value."]
1151    DIS = 0,
1152    #[doc = "1: Pullup enabled value."]
1153    EN = 1,
1154}
1155impl From<PAD21PULL_A> for bool {
1156    #[inline(always)]
1157    fn from(variant: PAD21PULL_A) -> Self {
1158        variant as u8 != 0
1159    }
1160}
1161#[doc = "Field `PAD21PULL` reader - Pad 21 pullup enable"]
1162pub struct PAD21PULL_R(crate::FieldReader<bool, PAD21PULL_A>);
1163impl PAD21PULL_R {
1164    pub(crate) fn new(bits: bool) -> Self {
1165        PAD21PULL_R(crate::FieldReader::new(bits))
1166    }
1167    #[doc = r"Get enumerated values variant"]
1168    #[inline(always)]
1169    pub fn variant(&self) -> PAD21PULL_A {
1170        match self.bits {
1171            false => PAD21PULL_A::DIS,
1172            true => PAD21PULL_A::EN,
1173        }
1174    }
1175    #[doc = "Checks if the value of the field is `DIS`"]
1176    #[inline(always)]
1177    pub fn is_dis(&self) -> bool {
1178        **self == PAD21PULL_A::DIS
1179    }
1180    #[doc = "Checks if the value of the field is `EN`"]
1181    #[inline(always)]
1182    pub fn is_en(&self) -> bool {
1183        **self == PAD21PULL_A::EN
1184    }
1185}
1186impl core::ops::Deref for PAD21PULL_R {
1187    type Target = crate::FieldReader<bool, PAD21PULL_A>;
1188    #[inline(always)]
1189    fn deref(&self) -> &Self::Target {
1190        &self.0
1191    }
1192}
1193#[doc = "Field `PAD21PULL` writer - Pad 21 pullup enable"]
1194pub struct PAD21PULL_W<'a> {
1195    w: &'a mut W,
1196}
1197impl<'a> PAD21PULL_W<'a> {
1198    #[doc = r"Writes `variant` to the field"]
1199    #[inline(always)]
1200    pub fn variant(self, variant: PAD21PULL_A) -> &'a mut W {
1201        self.bit(variant.into())
1202    }
1203    #[doc = "Pullup disabled value."]
1204    #[inline(always)]
1205    pub fn dis(self) -> &'a mut W {
1206        self.variant(PAD21PULL_A::DIS)
1207    }
1208    #[doc = "Pullup enabled value."]
1209    #[inline(always)]
1210    pub fn en(self) -> &'a mut W {
1211        self.variant(PAD21PULL_A::EN)
1212    }
1213    #[doc = r"Sets the field bit"]
1214    #[inline(always)]
1215    pub fn set_bit(self) -> &'a mut W {
1216        self.bit(true)
1217    }
1218    #[doc = r"Clears the field bit"]
1219    #[inline(always)]
1220    pub fn clear_bit(self) -> &'a mut W {
1221        self.bit(false)
1222    }
1223    #[doc = r"Writes raw bits to the field"]
1224    #[inline(always)]
1225    pub fn bit(self, value: bool) -> &'a mut W {
1226        self.w.bits = (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
1227        self.w
1228    }
1229}
1230#[doc = "Pad 20 function select\n\nValue on reset: 0"]
1231#[derive(Clone, Copy, Debug, PartialEq)]
1232#[repr(u8)]
1233pub enum PAD20FNCSEL_A {
1234    #[doc = "0: Configure as the serial wire debug clock signal value."]
1235    SWDCK = 0,
1236    #[doc = "1: IOM/MSPI nCE group 20 value."]
1237    NCE20 = 1,
1238    #[doc = "3: Configure as GPIO20 value."]
1239    GPIO20 = 3,
1240    #[doc = "4: Configure as UART0 TX output signal value."]
1241    UART0TX = 4,
1242    #[doc = "5: Configure as UART1 TX output signal value."]
1243    UART1TX = 5,
1244    #[doc = "6: I2S byte clock input value."]
1245    I2SBCLK = 6,
1246    #[doc = "7: Configure as UART1 RTS output signal value."]
1247    UA1RTS = 7,
1248}
1249impl From<PAD20FNCSEL_A> for u8 {
1250    #[inline(always)]
1251    fn from(variant: PAD20FNCSEL_A) -> Self {
1252        variant as _
1253    }
1254}
1255#[doc = "Field `PAD20FNCSEL` reader - Pad 20 function select"]
1256pub struct PAD20FNCSEL_R(crate::FieldReader<u8, PAD20FNCSEL_A>);
1257impl PAD20FNCSEL_R {
1258    pub(crate) fn new(bits: u8) -> Self {
1259        PAD20FNCSEL_R(crate::FieldReader::new(bits))
1260    }
1261    #[doc = r"Get enumerated values variant"]
1262    #[inline(always)]
1263    pub fn variant(&self) -> Option<PAD20FNCSEL_A> {
1264        match self.bits {
1265            0 => Some(PAD20FNCSEL_A::SWDCK),
1266            1 => Some(PAD20FNCSEL_A::NCE20),
1267            3 => Some(PAD20FNCSEL_A::GPIO20),
1268            4 => Some(PAD20FNCSEL_A::UART0TX),
1269            5 => Some(PAD20FNCSEL_A::UART1TX),
1270            6 => Some(PAD20FNCSEL_A::I2SBCLK),
1271            7 => Some(PAD20FNCSEL_A::UA1RTS),
1272            _ => None,
1273        }
1274    }
1275    #[doc = "Checks if the value of the field is `SWDCK`"]
1276    #[inline(always)]
1277    pub fn is_swdck(&self) -> bool {
1278        **self == PAD20FNCSEL_A::SWDCK
1279    }
1280    #[doc = "Checks if the value of the field is `NCE20`"]
1281    #[inline(always)]
1282    pub fn is_nce20(&self) -> bool {
1283        **self == PAD20FNCSEL_A::NCE20
1284    }
1285    #[doc = "Checks if the value of the field is `GPIO20`"]
1286    #[inline(always)]
1287    pub fn is_gpio20(&self) -> bool {
1288        **self == PAD20FNCSEL_A::GPIO20
1289    }
1290    #[doc = "Checks if the value of the field is `UART0TX`"]
1291    #[inline(always)]
1292    pub fn is_uart0tx(&self) -> bool {
1293        **self == PAD20FNCSEL_A::UART0TX
1294    }
1295    #[doc = "Checks if the value of the field is `UART1TX`"]
1296    #[inline(always)]
1297    pub fn is_uart1tx(&self) -> bool {
1298        **self == PAD20FNCSEL_A::UART1TX
1299    }
1300    #[doc = "Checks if the value of the field is `I2SBCLK`"]
1301    #[inline(always)]
1302    pub fn is_i2sbclk(&self) -> bool {
1303        **self == PAD20FNCSEL_A::I2SBCLK
1304    }
1305    #[doc = "Checks if the value of the field is `UA1RTS`"]
1306    #[inline(always)]
1307    pub fn is_ua1rts(&self) -> bool {
1308        **self == PAD20FNCSEL_A::UA1RTS
1309    }
1310}
1311impl core::ops::Deref for PAD20FNCSEL_R {
1312    type Target = crate::FieldReader<u8, PAD20FNCSEL_A>;
1313    #[inline(always)]
1314    fn deref(&self) -> &Self::Target {
1315        &self.0
1316    }
1317}
1318#[doc = "Field `PAD20FNCSEL` writer - Pad 20 function select"]
1319pub struct PAD20FNCSEL_W<'a> {
1320    w: &'a mut W,
1321}
1322impl<'a> PAD20FNCSEL_W<'a> {
1323    #[doc = r"Writes `variant` to the field"]
1324    #[inline(always)]
1325    pub fn variant(self, variant: PAD20FNCSEL_A) -> &'a mut W {
1326        unsafe { self.bits(variant.into()) }
1327    }
1328    #[doc = "Configure as the serial wire debug clock signal value."]
1329    #[inline(always)]
1330    pub fn swdck(self) -> &'a mut W {
1331        self.variant(PAD20FNCSEL_A::SWDCK)
1332    }
1333    #[doc = "IOM/MSPI nCE group 20 value."]
1334    #[inline(always)]
1335    pub fn nce20(self) -> &'a mut W {
1336        self.variant(PAD20FNCSEL_A::NCE20)
1337    }
1338    #[doc = "Configure as GPIO20 value."]
1339    #[inline(always)]
1340    pub fn gpio20(self) -> &'a mut W {
1341        self.variant(PAD20FNCSEL_A::GPIO20)
1342    }
1343    #[doc = "Configure as UART0 TX output signal value."]
1344    #[inline(always)]
1345    pub fn uart0tx(self) -> &'a mut W {
1346        self.variant(PAD20FNCSEL_A::UART0TX)
1347    }
1348    #[doc = "Configure as UART1 TX output signal value."]
1349    #[inline(always)]
1350    pub fn uart1tx(self) -> &'a mut W {
1351        self.variant(PAD20FNCSEL_A::UART1TX)
1352    }
1353    #[doc = "I2S byte clock input value."]
1354    #[inline(always)]
1355    pub fn i2sbclk(self) -> &'a mut W {
1356        self.variant(PAD20FNCSEL_A::I2SBCLK)
1357    }
1358    #[doc = "Configure as UART1 RTS output signal value."]
1359    #[inline(always)]
1360    pub fn ua1rts(self) -> &'a mut W {
1361        self.variant(PAD20FNCSEL_A::UA1RTS)
1362    }
1363    #[doc = r"Writes raw bits to the field"]
1364    #[inline(always)]
1365    pub unsafe fn bits(self, value: u8) -> &'a mut W {
1366        self.w.bits = (self.w.bits & !(0x07 << 3)) | ((value as u32 & 0x07) << 3);
1367        self.w
1368    }
1369}
1370#[doc = "Pad 20 drive strength\n\nValue on reset: 0"]
1371#[derive(Clone, Copy, Debug, PartialEq)]
1372pub enum PAD20STRNG_A {
1373    #[doc = "0: Low drive strength value."]
1374    LOW = 0,
1375    #[doc = "1: High drive strength value."]
1376    HIGH = 1,
1377}
1378impl From<PAD20STRNG_A> for bool {
1379    #[inline(always)]
1380    fn from(variant: PAD20STRNG_A) -> Self {
1381        variant as u8 != 0
1382    }
1383}
1384#[doc = "Field `PAD20STRNG` reader - Pad 20 drive strength"]
1385pub struct PAD20STRNG_R(crate::FieldReader<bool, PAD20STRNG_A>);
1386impl PAD20STRNG_R {
1387    pub(crate) fn new(bits: bool) -> Self {
1388        PAD20STRNG_R(crate::FieldReader::new(bits))
1389    }
1390    #[doc = r"Get enumerated values variant"]
1391    #[inline(always)]
1392    pub fn variant(&self) -> PAD20STRNG_A {
1393        match self.bits {
1394            false => PAD20STRNG_A::LOW,
1395            true => PAD20STRNG_A::HIGH,
1396        }
1397    }
1398    #[doc = "Checks if the value of the field is `LOW`"]
1399    #[inline(always)]
1400    pub fn is_low(&self) -> bool {
1401        **self == PAD20STRNG_A::LOW
1402    }
1403    #[doc = "Checks if the value of the field is `HIGH`"]
1404    #[inline(always)]
1405    pub fn is_high(&self) -> bool {
1406        **self == PAD20STRNG_A::HIGH
1407    }
1408}
1409impl core::ops::Deref for PAD20STRNG_R {
1410    type Target = crate::FieldReader<bool, PAD20STRNG_A>;
1411    #[inline(always)]
1412    fn deref(&self) -> &Self::Target {
1413        &self.0
1414    }
1415}
1416#[doc = "Field `PAD20STRNG` writer - Pad 20 drive strength"]
1417pub struct PAD20STRNG_W<'a> {
1418    w: &'a mut W,
1419}
1420impl<'a> PAD20STRNG_W<'a> {
1421    #[doc = r"Writes `variant` to the field"]
1422    #[inline(always)]
1423    pub fn variant(self, variant: PAD20STRNG_A) -> &'a mut W {
1424        self.bit(variant.into())
1425    }
1426    #[doc = "Low drive strength value."]
1427    #[inline(always)]
1428    pub fn low(self) -> &'a mut W {
1429        self.variant(PAD20STRNG_A::LOW)
1430    }
1431    #[doc = "High drive strength value."]
1432    #[inline(always)]
1433    pub fn high(self) -> &'a mut W {
1434        self.variant(PAD20STRNG_A::HIGH)
1435    }
1436    #[doc = r"Sets the field bit"]
1437    #[inline(always)]
1438    pub fn set_bit(self) -> &'a mut W {
1439        self.bit(true)
1440    }
1441    #[doc = r"Clears the field bit"]
1442    #[inline(always)]
1443    pub fn clear_bit(self) -> &'a mut W {
1444        self.bit(false)
1445    }
1446    #[doc = r"Writes raw bits to the field"]
1447    #[inline(always)]
1448    pub fn bit(self, value: bool) -> &'a mut W {
1449        self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
1450        self.w
1451    }
1452}
1453#[doc = "Pad 20 input enable\n\nValue on reset: 1"]
1454#[derive(Clone, Copy, Debug, PartialEq)]
1455pub enum PAD20INPEN_A {
1456    #[doc = "0: Pad input disabled value."]
1457    DIS = 0,
1458    #[doc = "1: Pad input enabled value."]
1459    EN = 1,
1460}
1461impl From<PAD20INPEN_A> for bool {
1462    #[inline(always)]
1463    fn from(variant: PAD20INPEN_A) -> Self {
1464        variant as u8 != 0
1465    }
1466}
1467#[doc = "Field `PAD20INPEN` reader - Pad 20 input enable"]
1468pub struct PAD20INPEN_R(crate::FieldReader<bool, PAD20INPEN_A>);
1469impl PAD20INPEN_R {
1470    pub(crate) fn new(bits: bool) -> Self {
1471        PAD20INPEN_R(crate::FieldReader::new(bits))
1472    }
1473    #[doc = r"Get enumerated values variant"]
1474    #[inline(always)]
1475    pub fn variant(&self) -> PAD20INPEN_A {
1476        match self.bits {
1477            false => PAD20INPEN_A::DIS,
1478            true => PAD20INPEN_A::EN,
1479        }
1480    }
1481    #[doc = "Checks if the value of the field is `DIS`"]
1482    #[inline(always)]
1483    pub fn is_dis(&self) -> bool {
1484        **self == PAD20INPEN_A::DIS
1485    }
1486    #[doc = "Checks if the value of the field is `EN`"]
1487    #[inline(always)]
1488    pub fn is_en(&self) -> bool {
1489        **self == PAD20INPEN_A::EN
1490    }
1491}
1492impl core::ops::Deref for PAD20INPEN_R {
1493    type Target = crate::FieldReader<bool, PAD20INPEN_A>;
1494    #[inline(always)]
1495    fn deref(&self) -> &Self::Target {
1496        &self.0
1497    }
1498}
1499#[doc = "Field `PAD20INPEN` writer - Pad 20 input enable"]
1500pub struct PAD20INPEN_W<'a> {
1501    w: &'a mut W,
1502}
1503impl<'a> PAD20INPEN_W<'a> {
1504    #[doc = r"Writes `variant` to the field"]
1505    #[inline(always)]
1506    pub fn variant(self, variant: PAD20INPEN_A) -> &'a mut W {
1507        self.bit(variant.into())
1508    }
1509    #[doc = "Pad input disabled value."]
1510    #[inline(always)]
1511    pub fn dis(self) -> &'a mut W {
1512        self.variant(PAD20INPEN_A::DIS)
1513    }
1514    #[doc = "Pad input enabled value."]
1515    #[inline(always)]
1516    pub fn en(self) -> &'a mut W {
1517        self.variant(PAD20INPEN_A::EN)
1518    }
1519    #[doc = r"Sets the field bit"]
1520    #[inline(always)]
1521    pub fn set_bit(self) -> &'a mut W {
1522        self.bit(true)
1523    }
1524    #[doc = r"Clears the field bit"]
1525    #[inline(always)]
1526    pub fn clear_bit(self) -> &'a mut W {
1527        self.bit(false)
1528    }
1529    #[doc = r"Writes raw bits to the field"]
1530    #[inline(always)]
1531    pub fn bit(self, value: bool) -> &'a mut W {
1532        self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
1533        self.w
1534    }
1535}
1536#[doc = "Pad 20 pulldown enable\n\nValue on reset: 0"]
1537#[derive(Clone, Copy, Debug, PartialEq)]
1538pub enum PAD20PULL_A {
1539    #[doc = "0: Pulldown disabled value."]
1540    DIS = 0,
1541    #[doc = "1: Pulldown enabled value."]
1542    EN = 1,
1543}
1544impl From<PAD20PULL_A> for bool {
1545    #[inline(always)]
1546    fn from(variant: PAD20PULL_A) -> Self {
1547        variant as u8 != 0
1548    }
1549}
1550#[doc = "Field `PAD20PULL` reader - Pad 20 pulldown enable"]
1551pub struct PAD20PULL_R(crate::FieldReader<bool, PAD20PULL_A>);
1552impl PAD20PULL_R {
1553    pub(crate) fn new(bits: bool) -> Self {
1554        PAD20PULL_R(crate::FieldReader::new(bits))
1555    }
1556    #[doc = r"Get enumerated values variant"]
1557    #[inline(always)]
1558    pub fn variant(&self) -> PAD20PULL_A {
1559        match self.bits {
1560            false => PAD20PULL_A::DIS,
1561            true => PAD20PULL_A::EN,
1562        }
1563    }
1564    #[doc = "Checks if the value of the field is `DIS`"]
1565    #[inline(always)]
1566    pub fn is_dis(&self) -> bool {
1567        **self == PAD20PULL_A::DIS
1568    }
1569    #[doc = "Checks if the value of the field is `EN`"]
1570    #[inline(always)]
1571    pub fn is_en(&self) -> bool {
1572        **self == PAD20PULL_A::EN
1573    }
1574}
1575impl core::ops::Deref for PAD20PULL_R {
1576    type Target = crate::FieldReader<bool, PAD20PULL_A>;
1577    #[inline(always)]
1578    fn deref(&self) -> &Self::Target {
1579        &self.0
1580    }
1581}
1582#[doc = "Field `PAD20PULL` writer - Pad 20 pulldown enable"]
1583pub struct PAD20PULL_W<'a> {
1584    w: &'a mut W,
1585}
1586impl<'a> PAD20PULL_W<'a> {
1587    #[doc = r"Writes `variant` to the field"]
1588    #[inline(always)]
1589    pub fn variant(self, variant: PAD20PULL_A) -> &'a mut W {
1590        self.bit(variant.into())
1591    }
1592    #[doc = "Pulldown disabled value."]
1593    #[inline(always)]
1594    pub fn dis(self) -> &'a mut W {
1595        self.variant(PAD20PULL_A::DIS)
1596    }
1597    #[doc = "Pulldown enabled value."]
1598    #[inline(always)]
1599    pub fn en(self) -> &'a mut W {
1600        self.variant(PAD20PULL_A::EN)
1601    }
1602    #[doc = r"Sets the field bit"]
1603    #[inline(always)]
1604    pub fn set_bit(self) -> &'a mut W {
1605        self.bit(true)
1606    }
1607    #[doc = r"Clears the field bit"]
1608    #[inline(always)]
1609    pub fn clear_bit(self) -> &'a mut W {
1610        self.bit(false)
1611    }
1612    #[doc = r"Writes raw bits to the field"]
1613    #[inline(always)]
1614    pub fn bit(self, value: bool) -> &'a mut W {
1615        self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
1616        self.w
1617    }
1618}
1619impl R {
1620    #[doc = "Bits 27:29 - Pad 23 function select"]
1621    #[inline(always)]
1622    pub fn pad23fncsel(&self) -> PAD23FNCSEL_R {
1623        PAD23FNCSEL_R::new(((self.bits >> 27) & 0x07) as u8)
1624    }
1625    #[doc = "Bit 26 - Pad 23 drive strength"]
1626    #[inline(always)]
1627    pub fn pad23strng(&self) -> PAD23STRNG_R {
1628        PAD23STRNG_R::new(((self.bits >> 26) & 0x01) != 0)
1629    }
1630    #[doc = "Bit 25 - Pad 23 input enable"]
1631    #[inline(always)]
1632    pub fn pad23inpen(&self) -> PAD23INPEN_R {
1633        PAD23INPEN_R::new(((self.bits >> 25) & 0x01) != 0)
1634    }
1635    #[doc = "Bit 24 - Pad 23 pullup enable"]
1636    #[inline(always)]
1637    pub fn pad23pull(&self) -> PAD23PULL_R {
1638        PAD23PULL_R::new(((self.bits >> 24) & 0x01) != 0)
1639    }
1640    #[doc = "Bits 19:21 - Pad 22 function select"]
1641    #[inline(always)]
1642    pub fn pad22fncsel(&self) -> PAD22FNCSEL_R {
1643        PAD22FNCSEL_R::new(((self.bits >> 19) & 0x07) as u8)
1644    }
1645    #[doc = "Bit 18 - Pad 22 drive strength"]
1646    #[inline(always)]
1647    pub fn pad22strng(&self) -> PAD22STRNG_R {
1648        PAD22STRNG_R::new(((self.bits >> 18) & 0x01) != 0)
1649    }
1650    #[doc = "Bit 17 - Pad 22 input enable"]
1651    #[inline(always)]
1652    pub fn pad22inpen(&self) -> PAD22INPEN_R {
1653        PAD22INPEN_R::new(((self.bits >> 17) & 0x01) != 0)
1654    }
1655    #[doc = "Bit 16 - Pad 22 pullup enable"]
1656    #[inline(always)]
1657    pub fn pad22pull(&self) -> PAD22PULL_R {
1658        PAD22PULL_R::new(((self.bits >> 16) & 0x01) != 0)
1659    }
1660    #[doc = "Bits 11:13 - Pad 21 function select"]
1661    #[inline(always)]
1662    pub fn pad21fncsel(&self) -> PAD21FNCSEL_R {
1663        PAD21FNCSEL_R::new(((self.bits >> 11) & 0x07) as u8)
1664    }
1665    #[doc = "Bit 10 - Pad 21 drive strength"]
1666    #[inline(always)]
1667    pub fn pad21strng(&self) -> PAD21STRNG_R {
1668        PAD21STRNG_R::new(((self.bits >> 10) & 0x01) != 0)
1669    }
1670    #[doc = "Bit 9 - Pad 21 input enable"]
1671    #[inline(always)]
1672    pub fn pad21inpen(&self) -> PAD21INPEN_R {
1673        PAD21INPEN_R::new(((self.bits >> 9) & 0x01) != 0)
1674    }
1675    #[doc = "Bit 8 - Pad 21 pullup enable"]
1676    #[inline(always)]
1677    pub fn pad21pull(&self) -> PAD21PULL_R {
1678        PAD21PULL_R::new(((self.bits >> 8) & 0x01) != 0)
1679    }
1680    #[doc = "Bits 3:5 - Pad 20 function select"]
1681    #[inline(always)]
1682    pub fn pad20fncsel(&self) -> PAD20FNCSEL_R {
1683        PAD20FNCSEL_R::new(((self.bits >> 3) & 0x07) as u8)
1684    }
1685    #[doc = "Bit 2 - Pad 20 drive strength"]
1686    #[inline(always)]
1687    pub fn pad20strng(&self) -> PAD20STRNG_R {
1688        PAD20STRNG_R::new(((self.bits >> 2) & 0x01) != 0)
1689    }
1690    #[doc = "Bit 1 - Pad 20 input enable"]
1691    #[inline(always)]
1692    pub fn pad20inpen(&self) -> PAD20INPEN_R {
1693        PAD20INPEN_R::new(((self.bits >> 1) & 0x01) != 0)
1694    }
1695    #[doc = "Bit 0 - Pad 20 pulldown enable"]
1696    #[inline(always)]
1697    pub fn pad20pull(&self) -> PAD20PULL_R {
1698        PAD20PULL_R::new((self.bits & 0x01) != 0)
1699    }
1700}
1701impl W {
1702    #[doc = "Bits 27:29 - Pad 23 function select"]
1703    #[inline(always)]
1704    pub fn pad23fncsel(&mut self) -> PAD23FNCSEL_W {
1705        PAD23FNCSEL_W { w: self }
1706    }
1707    #[doc = "Bit 26 - Pad 23 drive strength"]
1708    #[inline(always)]
1709    pub fn pad23strng(&mut self) -> PAD23STRNG_W {
1710        PAD23STRNG_W { w: self }
1711    }
1712    #[doc = "Bit 25 - Pad 23 input enable"]
1713    #[inline(always)]
1714    pub fn pad23inpen(&mut self) -> PAD23INPEN_W {
1715        PAD23INPEN_W { w: self }
1716    }
1717    #[doc = "Bit 24 - Pad 23 pullup enable"]
1718    #[inline(always)]
1719    pub fn pad23pull(&mut self) -> PAD23PULL_W {
1720        PAD23PULL_W { w: self }
1721    }
1722    #[doc = "Bits 19:21 - Pad 22 function select"]
1723    #[inline(always)]
1724    pub fn pad22fncsel(&mut self) -> PAD22FNCSEL_W {
1725        PAD22FNCSEL_W { w: self }
1726    }
1727    #[doc = "Bit 18 - Pad 22 drive strength"]
1728    #[inline(always)]
1729    pub fn pad22strng(&mut self) -> PAD22STRNG_W {
1730        PAD22STRNG_W { w: self }
1731    }
1732    #[doc = "Bit 17 - Pad 22 input enable"]
1733    #[inline(always)]
1734    pub fn pad22inpen(&mut self) -> PAD22INPEN_W {
1735        PAD22INPEN_W { w: self }
1736    }
1737    #[doc = "Bit 16 - Pad 22 pullup enable"]
1738    #[inline(always)]
1739    pub fn pad22pull(&mut self) -> PAD22PULL_W {
1740        PAD22PULL_W { w: self }
1741    }
1742    #[doc = "Bits 11:13 - Pad 21 function select"]
1743    #[inline(always)]
1744    pub fn pad21fncsel(&mut self) -> PAD21FNCSEL_W {
1745        PAD21FNCSEL_W { w: self }
1746    }
1747    #[doc = "Bit 10 - Pad 21 drive strength"]
1748    #[inline(always)]
1749    pub fn pad21strng(&mut self) -> PAD21STRNG_W {
1750        PAD21STRNG_W { w: self }
1751    }
1752    #[doc = "Bit 9 - Pad 21 input enable"]
1753    #[inline(always)]
1754    pub fn pad21inpen(&mut self) -> PAD21INPEN_W {
1755        PAD21INPEN_W { w: self }
1756    }
1757    #[doc = "Bit 8 - Pad 21 pullup enable"]
1758    #[inline(always)]
1759    pub fn pad21pull(&mut self) -> PAD21PULL_W {
1760        PAD21PULL_W { w: self }
1761    }
1762    #[doc = "Bits 3:5 - Pad 20 function select"]
1763    #[inline(always)]
1764    pub fn pad20fncsel(&mut self) -> PAD20FNCSEL_W {
1765        PAD20FNCSEL_W { w: self }
1766    }
1767    #[doc = "Bit 2 - Pad 20 drive strength"]
1768    #[inline(always)]
1769    pub fn pad20strng(&mut self) -> PAD20STRNG_W {
1770        PAD20STRNG_W { w: self }
1771    }
1772    #[doc = "Bit 1 - Pad 20 input enable"]
1773    #[inline(always)]
1774    pub fn pad20inpen(&mut self) -> PAD20INPEN_W {
1775        PAD20INPEN_W { w: self }
1776    }
1777    #[doc = "Bit 0 - Pad 20 pulldown enable"]
1778    #[inline(always)]
1779    pub fn pad20pull(&mut self) -> PAD20PULL_W {
1780        PAD20PULL_W { w: self }
1781    }
1782    #[doc = "Writes raw bits to the register."]
1783    #[inline(always)]
1784    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1785        self.0.bits(bits);
1786        self
1787    }
1788}
1789#[doc = "Pad Configuration Register F (Pads 20-23)\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [padregf](index.html) module"]
1790pub struct PADREGF_SPEC;
1791impl crate::RegisterSpec for PADREGF_SPEC {
1792    type Ux = u32;
1793}
1794#[doc = "`read()` method returns [padregf::R](R) reader structure"]
1795impl crate::Readable for PADREGF_SPEC {
1796    type Reader = R;
1797}
1798#[doc = "`write(|w| ..)` method takes [padregf::W](W) writer structure"]
1799impl crate::Writable for PADREGF_SPEC {
1800    type Writer = W;
1801}
1802#[doc = "`reset()` method sets PADREGF to value 0x1818_0202"]
1803impl crate::Resettable for PADREGF_SPEC {
1804    #[inline(always)]
1805    fn reset_value() -> Self::Ux {
1806        0x1818_0202
1807    }
1808}
ambiq_apollo3_pac2/gpio/padregf.rs

ambiq_apollo3_pac2/gpio/
padregf.rs
