ambiq_apollo1_pac/gpio/
padregc.rs

1#[doc = "Reader of register PADREGC"]
2pub type R = crate::R<u32, super::PADREGC>;
3#[doc = "Writer for register PADREGC"]
4pub type W = crate::W<u32, super::PADREGC>;
5#[doc = "Register PADREGC `reset()`'s with value 0x1818_1818"]
6impl crate::ResetValue for super::PADREGC {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0x1818_1818
11    }
12}
13#[doc = "Pad 11 lower power switch enable\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum PAD11PWRDN_A {
16    #[doc = "0: Power switch disabled"]
17    DIS = 0,
18    #[doc = "1: Power switch enabled"]
19    EN = 1,
20}
21impl From<PAD11PWRDN_A> for bool {
22    #[inline(always)]
23    fn from(variant: PAD11PWRDN_A) -> Self {
24        variant as u8 != 0
25    }
26}
27#[doc = "Reader of field `PAD11PWRDN`"]
28pub type PAD11PWRDN_R = crate::R<bool, PAD11PWRDN_A>;
29impl PAD11PWRDN_R {
30    #[doc = r"Get enumerated values variant"]
31    #[inline(always)]
32    pub fn variant(&self) -> PAD11PWRDN_A {
33        match self.bits {
34            false => PAD11PWRDN_A::DIS,
35            true => PAD11PWRDN_A::EN,
36        }
37    }
38    #[doc = "Checks if the value of the field is `DIS`"]
39    #[inline(always)]
40    pub fn is_dis(&self) -> bool {
41        *self == PAD11PWRDN_A::DIS
42    }
43    #[doc = "Checks if the value of the field is `EN`"]
44    #[inline(always)]
45    pub fn is_en(&self) -> bool {
46        *self == PAD11PWRDN_A::EN
47    }
48}
49#[doc = "Write proxy for field `PAD11PWRDN`"]
50pub struct PAD11PWRDN_W<'a> {
51    w: &'a mut W,
52}
53impl<'a> PAD11PWRDN_W<'a> {
54    #[doc = r"Writes `variant` to the field"]
55    #[inline(always)]
56    pub fn variant(self, variant: PAD11PWRDN_A) -> &'a mut W {
57        {
58            self.bit(variant.into())
59        }
60    }
61    #[doc = "Power switch disabled"]
62    #[inline(always)]
63    pub fn dis(self) -> &'a mut W {
64        self.variant(PAD11PWRDN_A::DIS)
65    }
66    #[doc = "Power switch enabled"]
67    #[inline(always)]
68    pub fn en(self) -> &'a mut W {
69        self.variant(PAD11PWRDN_A::EN)
70    }
71    #[doc = r"Sets the field bit"]
72    #[inline(always)]
73    pub fn set_bit(self) -> &'a mut W {
74        self.bit(true)
75    }
76    #[doc = r"Clears the field bit"]
77    #[inline(always)]
78    pub fn clear_bit(self) -> &'a mut W {
79        self.bit(false)
80    }
81    #[doc = r"Writes raw bits to the field"]
82    #[inline(always)]
83    pub fn bit(self, value: bool) -> &'a mut W {
84        self.w.bits = (self.w.bits & !(0x01 << 30)) | (((value as u32) & 0x01) << 30);
85        self.w
86    }
87}
88#[doc = "Pad 11 function select\n\nValue on reset: 3"]
89#[derive(Clone, Copy, Debug, PartialEq)]
90#[repr(u8)]
91pub enum PAD11FNCSEL_A {
92    #[doc = "0: Configure as the analog test output signal"]
93    ANATST = 0,
94    #[doc = "1: Configure as the SPI channel 0 nCE signal from IOMSTR0"]
95    M0NCE0 = 1,
96    #[doc = "2: Configure as the CLKOUT signal"]
97    CLKOUT = 2,
98    #[doc = "3: Configure as GPIO11"]
99    GPIO11 = 3,
100}
101impl From<PAD11FNCSEL_A> for u8 {
102    #[inline(always)]
103    fn from(variant: PAD11FNCSEL_A) -> Self {
104        variant as _
105    }
106}
107#[doc = "Reader of field `PAD11FNCSEL`"]
108pub type PAD11FNCSEL_R = crate::R<u8, PAD11FNCSEL_A>;
109impl PAD11FNCSEL_R {
110    #[doc = r"Get enumerated values variant"]
111    #[inline(always)]
112    pub fn variant(&self) -> PAD11FNCSEL_A {
113        match self.bits {
114            0 => PAD11FNCSEL_A::ANATST,
115            1 => PAD11FNCSEL_A::M0NCE0,
116            2 => PAD11FNCSEL_A::CLKOUT,
117            3 => PAD11FNCSEL_A::GPIO11,
118            _ => unreachable!(),
119        }
120    }
121    #[doc = "Checks if the value of the field is `ANATST`"]
122    #[inline(always)]
123    pub fn is_anatst(&self) -> bool {
124        *self == PAD11FNCSEL_A::ANATST
125    }
126    #[doc = "Checks if the value of the field is `M0NCE0`"]
127    #[inline(always)]
128    pub fn is_m0n_ce0(&self) -> bool {
129        *self == PAD11FNCSEL_A::M0NCE0
130    }
131    #[doc = "Checks if the value of the field is `CLKOUT`"]
132    #[inline(always)]
133    pub fn is_clkout(&self) -> bool {
134        *self == PAD11FNCSEL_A::CLKOUT
135    }
136    #[doc = "Checks if the value of the field is `GPIO11`"]
137    #[inline(always)]
138    pub fn is_gpio11(&self) -> bool {
139        *self == PAD11FNCSEL_A::GPIO11
140    }
141}
142#[doc = "Write proxy for field `PAD11FNCSEL`"]
143pub struct PAD11FNCSEL_W<'a> {
144    w: &'a mut W,
145}
146impl<'a> PAD11FNCSEL_W<'a> {
147    #[doc = r"Writes `variant` to the field"]
148    #[inline(always)]
149    pub fn variant(self, variant: PAD11FNCSEL_A) -> &'a mut W {
150        {
151            self.bits(variant.into())
152        }
153    }
154    #[doc = "Configure as the analog test output signal"]
155    #[inline(always)]
156    pub fn anatst(self) -> &'a mut W {
157        self.variant(PAD11FNCSEL_A::ANATST)
158    }
159    #[doc = "Configure as the SPI channel 0 nCE signal from IOMSTR0"]
160    #[inline(always)]
161    pub fn m0n_ce0(self) -> &'a mut W {
162        self.variant(PAD11FNCSEL_A::M0NCE0)
163    }
164    #[doc = "Configure as the CLKOUT signal"]
165    #[inline(always)]
166    pub fn clkout(self) -> &'a mut W {
167        self.variant(PAD11FNCSEL_A::CLKOUT)
168    }
169    #[doc = "Configure as GPIO11"]
170    #[inline(always)]
171    pub fn gpio11(self) -> &'a mut W {
172        self.variant(PAD11FNCSEL_A::GPIO11)
173    }
174    #[doc = r"Writes raw bits to the field"]
175    #[inline(always)]
176    pub fn bits(self, value: u8) -> &'a mut W {
177        self.w.bits = (self.w.bits & !(0x03 << 27)) | (((value as u32) & 0x03) << 27);
178        self.w
179    }
180}
181#[doc = "Pad 11 drive strentgh\n\nValue on reset: 0"]
182#[derive(Clone, Copy, Debug, PartialEq)]
183pub enum PAD11STRNG_A {
184    #[doc = "0: Low drive strength"]
185    LOW = 0,
186    #[doc = "1: High drive strength"]
187    HIGH = 1,
188}
189impl From<PAD11STRNG_A> for bool {
190    #[inline(always)]
191    fn from(variant: PAD11STRNG_A) -> Self {
192        variant as u8 != 0
193    }
194}
195#[doc = "Reader of field `PAD11STRNG`"]
196pub type PAD11STRNG_R = crate::R<bool, PAD11STRNG_A>;
197impl PAD11STRNG_R {
198    #[doc = r"Get enumerated values variant"]
199    #[inline(always)]
200    pub fn variant(&self) -> PAD11STRNG_A {
201        match self.bits {
202            false => PAD11STRNG_A::LOW,
203            true => PAD11STRNG_A::HIGH,
204        }
205    }
206    #[doc = "Checks if the value of the field is `LOW`"]
207    #[inline(always)]
208    pub fn is_low(&self) -> bool {
209        *self == PAD11STRNG_A::LOW
210    }
211    #[doc = "Checks if the value of the field is `HIGH`"]
212    #[inline(always)]
213    pub fn is_high(&self) -> bool {
214        *self == PAD11STRNG_A::HIGH
215    }
216}
217#[doc = "Write proxy for field `PAD11STRNG`"]
218pub struct PAD11STRNG_W<'a> {
219    w: &'a mut W,
220}
221impl<'a> PAD11STRNG_W<'a> {
222    #[doc = r"Writes `variant` to the field"]
223    #[inline(always)]
224    pub fn variant(self, variant: PAD11STRNG_A) -> &'a mut W {
225        {
226            self.bit(variant.into())
227        }
228    }
229    #[doc = "Low drive strength"]
230    #[inline(always)]
231    pub fn low(self) -> &'a mut W {
232        self.variant(PAD11STRNG_A::LOW)
233    }
234    #[doc = "High drive strength"]
235    #[inline(always)]
236    pub fn high(self) -> &'a mut W {
237        self.variant(PAD11STRNG_A::HIGH)
238    }
239    #[doc = r"Sets the field bit"]
240    #[inline(always)]
241    pub fn set_bit(self) -> &'a mut W {
242        self.bit(true)
243    }
244    #[doc = r"Clears the field bit"]
245    #[inline(always)]
246    pub fn clear_bit(self) -> &'a mut W {
247        self.bit(false)
248    }
249    #[doc = r"Writes raw bits to the field"]
250    #[inline(always)]
251    pub fn bit(self, value: bool) -> &'a mut W {
252        self.w.bits = (self.w.bits & !(0x01 << 26)) | (((value as u32) & 0x01) << 26);
253        self.w
254    }
255}
256#[doc = "Pad 11 input enable\n\nValue on reset: 0"]
257#[derive(Clone, Copy, Debug, PartialEq)]
258pub enum PAD11INPEN_A {
259    #[doc = "0: Pad input disabled"]
260    DIS = 0,
261    #[doc = "1: Pad input enabled"]
262    EN = 1,
263}
264impl From<PAD11INPEN_A> for bool {
265    #[inline(always)]
266    fn from(variant: PAD11INPEN_A) -> Self {
267        variant as u8 != 0
268    }
269}
270#[doc = "Reader of field `PAD11INPEN`"]
271pub type PAD11INPEN_R = crate::R<bool, PAD11INPEN_A>;
272impl PAD11INPEN_R {
273    #[doc = r"Get enumerated values variant"]
274    #[inline(always)]
275    pub fn variant(&self) -> PAD11INPEN_A {
276        match self.bits {
277            false => PAD11INPEN_A::DIS,
278            true => PAD11INPEN_A::EN,
279        }
280    }
281    #[doc = "Checks if the value of the field is `DIS`"]
282    #[inline(always)]
283    pub fn is_dis(&self) -> bool {
284        *self == PAD11INPEN_A::DIS
285    }
286    #[doc = "Checks if the value of the field is `EN`"]
287    #[inline(always)]
288    pub fn is_en(&self) -> bool {
289        *self == PAD11INPEN_A::EN
290    }
291}
292#[doc = "Write proxy for field `PAD11INPEN`"]
293pub struct PAD11INPEN_W<'a> {
294    w: &'a mut W,
295}
296impl<'a> PAD11INPEN_W<'a> {
297    #[doc = r"Writes `variant` to the field"]
298    #[inline(always)]
299    pub fn variant(self, variant: PAD11INPEN_A) -> &'a mut W {
300        {
301            self.bit(variant.into())
302        }
303    }
304    #[doc = "Pad input disabled"]
305    #[inline(always)]
306    pub fn dis(self) -> &'a mut W {
307        self.variant(PAD11INPEN_A::DIS)
308    }
309    #[doc = "Pad input enabled"]
310    #[inline(always)]
311    pub fn en(self) -> &'a mut W {
312        self.variant(PAD11INPEN_A::EN)
313    }
314    #[doc = r"Sets the field bit"]
315    #[inline(always)]
316    pub fn set_bit(self) -> &'a mut W {
317        self.bit(true)
318    }
319    #[doc = r"Clears the field bit"]
320    #[inline(always)]
321    pub fn clear_bit(self) -> &'a mut W {
322        self.bit(false)
323    }
324    #[doc = r"Writes raw bits to the field"]
325    #[inline(always)]
326    pub fn bit(self, value: bool) -> &'a mut W {
327        self.w.bits = (self.w.bits & !(0x01 << 25)) | (((value as u32) & 0x01) << 25);
328        self.w
329    }
330}
331#[doc = "Pad 11 pullup enable\n\nValue on reset: 0"]
332#[derive(Clone, Copy, Debug, PartialEq)]
333pub enum PAD11PULL_A {
334    #[doc = "0: Pullup disabled"]
335    DIS = 0,
336    #[doc = "1: Pullup enabled"]
337    EN = 1,
338}
339impl From<PAD11PULL_A> for bool {
340    #[inline(always)]
341    fn from(variant: PAD11PULL_A) -> Self {
342        variant as u8 != 0
343    }
344}
345#[doc = "Reader of field `PAD11PULL`"]
346pub type PAD11PULL_R = crate::R<bool, PAD11PULL_A>;
347impl PAD11PULL_R {
348    #[doc = r"Get enumerated values variant"]
349    #[inline(always)]
350    pub fn variant(&self) -> PAD11PULL_A {
351        match self.bits {
352            false => PAD11PULL_A::DIS,
353            true => PAD11PULL_A::EN,
354        }
355    }
356    #[doc = "Checks if the value of the field is `DIS`"]
357    #[inline(always)]
358    pub fn is_dis(&self) -> bool {
359        *self == PAD11PULL_A::DIS
360    }
361    #[doc = "Checks if the value of the field is `EN`"]
362    #[inline(always)]
363    pub fn is_en(&self) -> bool {
364        *self == PAD11PULL_A::EN
365    }
366}
367#[doc = "Write proxy for field `PAD11PULL`"]
368pub struct PAD11PULL_W<'a> {
369    w: &'a mut W,
370}
371impl<'a> PAD11PULL_W<'a> {
372    #[doc = r"Writes `variant` to the field"]
373    #[inline(always)]
374    pub fn variant(self, variant: PAD11PULL_A) -> &'a mut W {
375        {
376            self.bit(variant.into())
377        }
378    }
379    #[doc = "Pullup disabled"]
380    #[inline(always)]
381    pub fn dis(self) -> &'a mut W {
382        self.variant(PAD11PULL_A::DIS)
383    }
384    #[doc = "Pullup enabled"]
385    #[inline(always)]
386    pub fn en(self) -> &'a mut W {
387        self.variant(PAD11PULL_A::EN)
388    }
389    #[doc = r"Sets the field bit"]
390    #[inline(always)]
391    pub fn set_bit(self) -> &'a mut W {
392        self.bit(true)
393    }
394    #[doc = r"Clears the field bit"]
395    #[inline(always)]
396    pub fn clear_bit(self) -> &'a mut W {
397        self.bit(false)
398    }
399    #[doc = r"Writes raw bits to the field"]
400    #[inline(always)]
401    pub fn bit(self, value: bool) -> &'a mut W {
402        self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
403        self.w
404    }
405}
406#[doc = "Pad 10 function select\n\nValue on reset: 3"]
407#[derive(Clone, Copy, Debug, PartialEq)]
408#[repr(u8)]
409pub enum PAD10FNCSEL_A {
410    #[doc = "0: Configure as the IOMSTR1 SPI 3-wire MOSI/MISO signal"]
411    M1WIR3 = 0,
412    #[doc = "1: Configure as the IOMSTR1 SPI MOSI signal"]
413    M1MOSI = 1,
414    #[doc = "2: Configure as the SPI channel 6 nCE signal from IOMSTR0"]
415    M0NCE6 = 2,
416    #[doc = "3: Configure as GPIO10"]
417    GPIO10 = 3,
418    #[doc = "5: Configure as the external HFRC A clock signal"]
419    EXTHFA = 5,
420    #[doc = "6: Pad disabled"]
421    DIS = 6,
422    #[doc = "7: Configure as the IOMSTR1 SPI 3-wire MOSI/MISO loopback signal from IOSLAVE"]
423    SLWIR3 = 7,
424}
425impl From<PAD10FNCSEL_A> for u8 {
426    #[inline(always)]
427    fn from(variant: PAD10FNCSEL_A) -> Self {
428        variant as _
429    }
430}
431#[doc = "Reader of field `PAD10FNCSEL`"]
432pub type PAD10FNCSEL_R = crate::R<u8, PAD10FNCSEL_A>;
433impl PAD10FNCSEL_R {
434    #[doc = r"Get enumerated values variant"]
435    #[inline(always)]
436    pub fn variant(&self) -> crate::Variant<u8, PAD10FNCSEL_A> {
437        use crate::Variant::*;
438        match self.bits {
439            0 => Val(PAD10FNCSEL_A::M1WIR3),
440            1 => Val(PAD10FNCSEL_A::M1MOSI),
441            2 => Val(PAD10FNCSEL_A::M0NCE6),
442            3 => Val(PAD10FNCSEL_A::GPIO10),
443            5 => Val(PAD10FNCSEL_A::EXTHFA),
444            6 => Val(PAD10FNCSEL_A::DIS),
445            7 => Val(PAD10FNCSEL_A::SLWIR3),
446            i => Res(i),
447        }
448    }
449    #[doc = "Checks if the value of the field is `M1WIR3`"]
450    #[inline(always)]
451    pub fn is_m1wir3(&self) -> bool {
452        *self == PAD10FNCSEL_A::M1WIR3
453    }
454    #[doc = "Checks if the value of the field is `M1MOSI`"]
455    #[inline(always)]
456    pub fn is_m1mosi(&self) -> bool {
457        *self == PAD10FNCSEL_A::M1MOSI
458    }
459    #[doc = "Checks if the value of the field is `M0NCE6`"]
460    #[inline(always)]
461    pub fn is_m0n_ce6(&self) -> bool {
462        *self == PAD10FNCSEL_A::M0NCE6
463    }
464    #[doc = "Checks if the value of the field is `GPIO10`"]
465    #[inline(always)]
466    pub fn is_gpio10(&self) -> bool {
467        *self == PAD10FNCSEL_A::GPIO10
468    }
469    #[doc = "Checks if the value of the field is `EXTHFA`"]
470    #[inline(always)]
471    pub fn is_exthfa(&self) -> bool {
472        *self == PAD10FNCSEL_A::EXTHFA
473    }
474    #[doc = "Checks if the value of the field is `DIS`"]
475    #[inline(always)]
476    pub fn is_dis(&self) -> bool {
477        *self == PAD10FNCSEL_A::DIS
478    }
479    #[doc = "Checks if the value of the field is `SLWIR3`"]
480    #[inline(always)]
481    pub fn is_slwir3(&self) -> bool {
482        *self == PAD10FNCSEL_A::SLWIR3
483    }
484}
485#[doc = "Write proxy for field `PAD10FNCSEL`"]
486pub struct PAD10FNCSEL_W<'a> {
487    w: &'a mut W,
488}
489impl<'a> PAD10FNCSEL_W<'a> {
490    #[doc = r"Writes `variant` to the field"]
491    #[inline(always)]
492    pub fn variant(self, variant: PAD10FNCSEL_A) -> &'a mut W {
493        unsafe { self.bits(variant.into()) }
494    }
495    #[doc = "Configure as the IOMSTR1 SPI 3-wire MOSI/MISO signal"]
496    #[inline(always)]
497    pub fn m1wir3(self) -> &'a mut W {
498        self.variant(PAD10FNCSEL_A::M1WIR3)
499    }
500    #[doc = "Configure as the IOMSTR1 SPI MOSI signal"]
501    #[inline(always)]
502    pub fn m1mosi(self) -> &'a mut W {
503        self.variant(PAD10FNCSEL_A::M1MOSI)
504    }
505    #[doc = "Configure as the SPI channel 6 nCE signal from IOMSTR0"]
506    #[inline(always)]
507    pub fn m0n_ce6(self) -> &'a mut W {
508        self.variant(PAD10FNCSEL_A::M0NCE6)
509    }
510    #[doc = "Configure as GPIO10"]
511    #[inline(always)]
512    pub fn gpio10(self) -> &'a mut W {
513        self.variant(PAD10FNCSEL_A::GPIO10)
514    }
515    #[doc = "Configure as the external HFRC A clock signal"]
516    #[inline(always)]
517    pub fn exthfa(self) -> &'a mut W {
518        self.variant(PAD10FNCSEL_A::EXTHFA)
519    }
520    #[doc = "Pad disabled"]
521    #[inline(always)]
522    pub fn dis(self) -> &'a mut W {
523        self.variant(PAD10FNCSEL_A::DIS)
524    }
525    #[doc = "Configure as the IOMSTR1 SPI 3-wire MOSI/MISO loopback signal from IOSLAVE"]
526    #[inline(always)]
527    pub fn slwir3(self) -> &'a mut W {
528        self.variant(PAD10FNCSEL_A::SLWIR3)
529    }
530    #[doc = r"Writes raw bits to the field"]
531    #[inline(always)]
532    pub unsafe fn bits(self, value: u8) -> &'a mut W {
533        self.w.bits = (self.w.bits & !(0x07 << 19)) | (((value as u32) & 0x07) << 19);
534        self.w
535    }
536}
537#[doc = "Pad 10 drive strength\n\nValue on reset: 0"]
538#[derive(Clone, Copy, Debug, PartialEq)]
539pub enum PAD10STRNG_A {
540    #[doc = "0: Low drive strength"]
541    LOW = 0,
542    #[doc = "1: High drive strength"]
543    HIGH = 1,
544}
545impl From<PAD10STRNG_A> for bool {
546    #[inline(always)]
547    fn from(variant: PAD10STRNG_A) -> Self {
548        variant as u8 != 0
549    }
550}
551#[doc = "Reader of field `PAD10STRNG`"]
552pub type PAD10STRNG_R = crate::R<bool, PAD10STRNG_A>;
553impl PAD10STRNG_R {
554    #[doc = r"Get enumerated values variant"]
555    #[inline(always)]
556    pub fn variant(&self) -> PAD10STRNG_A {
557        match self.bits {
558            false => PAD10STRNG_A::LOW,
559            true => PAD10STRNG_A::HIGH,
560        }
561    }
562    #[doc = "Checks if the value of the field is `LOW`"]
563    #[inline(always)]
564    pub fn is_low(&self) -> bool {
565        *self == PAD10STRNG_A::LOW
566    }
567    #[doc = "Checks if the value of the field is `HIGH`"]
568    #[inline(always)]
569    pub fn is_high(&self) -> bool {
570        *self == PAD10STRNG_A::HIGH
571    }
572}
573#[doc = "Write proxy for field `PAD10STRNG`"]
574pub struct PAD10STRNG_W<'a> {
575    w: &'a mut W,
576}
577impl<'a> PAD10STRNG_W<'a> {
578    #[doc = r"Writes `variant` to the field"]
579    #[inline(always)]
580    pub fn variant(self, variant: PAD10STRNG_A) -> &'a mut W {
581        {
582            self.bit(variant.into())
583        }
584    }
585    #[doc = "Low drive strength"]
586    #[inline(always)]
587    pub fn low(self) -> &'a mut W {
588        self.variant(PAD10STRNG_A::LOW)
589    }
590    #[doc = "High drive strength"]
591    #[inline(always)]
592    pub fn high(self) -> &'a mut W {
593        self.variant(PAD10STRNG_A::HIGH)
594    }
595    #[doc = r"Sets the field bit"]
596    #[inline(always)]
597    pub fn set_bit(self) -> &'a mut W {
598        self.bit(true)
599    }
600    #[doc = r"Clears the field bit"]
601    #[inline(always)]
602    pub fn clear_bit(self) -> &'a mut W {
603        self.bit(false)
604    }
605    #[doc = r"Writes raw bits to the field"]
606    #[inline(always)]
607    pub fn bit(self, value: bool) -> &'a mut W {
608        self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
609        self.w
610    }
611}
612#[doc = "Pad 10 input enable\n\nValue on reset: 0"]
613#[derive(Clone, Copy, Debug, PartialEq)]
614pub enum PAD10INPEN_A {
615    #[doc = "0: Pad input disabled"]
616    DIS = 0,
617    #[doc = "1: Pad input enabled"]
618    EN = 1,
619}
620impl From<PAD10INPEN_A> for bool {
621    #[inline(always)]
622    fn from(variant: PAD10INPEN_A) -> Self {
623        variant as u8 != 0
624    }
625}
626#[doc = "Reader of field `PAD10INPEN`"]
627pub type PAD10INPEN_R = crate::R<bool, PAD10INPEN_A>;
628impl PAD10INPEN_R {
629    #[doc = r"Get enumerated values variant"]
630    #[inline(always)]
631    pub fn variant(&self) -> PAD10INPEN_A {
632        match self.bits {
633            false => PAD10INPEN_A::DIS,
634            true => PAD10INPEN_A::EN,
635        }
636    }
637    #[doc = "Checks if the value of the field is `DIS`"]
638    #[inline(always)]
639    pub fn is_dis(&self) -> bool {
640        *self == PAD10INPEN_A::DIS
641    }
642    #[doc = "Checks if the value of the field is `EN`"]
643    #[inline(always)]
644    pub fn is_en(&self) -> bool {
645        *self == PAD10INPEN_A::EN
646    }
647}
648#[doc = "Write proxy for field `PAD10INPEN`"]
649pub struct PAD10INPEN_W<'a> {
650    w: &'a mut W,
651}
652impl<'a> PAD10INPEN_W<'a> {
653    #[doc = r"Writes `variant` to the field"]
654    #[inline(always)]
655    pub fn variant(self, variant: PAD10INPEN_A) -> &'a mut W {
656        {
657            self.bit(variant.into())
658        }
659    }
660    #[doc = "Pad input disabled"]
661    #[inline(always)]
662    pub fn dis(self) -> &'a mut W {
663        self.variant(PAD10INPEN_A::DIS)
664    }
665    #[doc = "Pad input enabled"]
666    #[inline(always)]
667    pub fn en(self) -> &'a mut W {
668        self.variant(PAD10INPEN_A::EN)
669    }
670    #[doc = r"Sets the field bit"]
671    #[inline(always)]
672    pub fn set_bit(self) -> &'a mut W {
673        self.bit(true)
674    }
675    #[doc = r"Clears the field bit"]
676    #[inline(always)]
677    pub fn clear_bit(self) -> &'a mut W {
678        self.bit(false)
679    }
680    #[doc = r"Writes raw bits to the field"]
681    #[inline(always)]
682    pub fn bit(self, value: bool) -> &'a mut W {
683        self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
684        self.w
685    }
686}
687#[doc = "Pad 10 pullup enable\n\nValue on reset: 0"]
688#[derive(Clone, Copy, Debug, PartialEq)]
689pub enum PAD10PULL_A {
690    #[doc = "0: Pullup disabled"]
691    DIS = 0,
692    #[doc = "1: Pullup enabled"]
693    EN = 1,
694}
695impl From<PAD10PULL_A> for bool {
696    #[inline(always)]
697    fn from(variant: PAD10PULL_A) -> Self {
698        variant as u8 != 0
699    }
700}
701#[doc = "Reader of field `PAD10PULL`"]
702pub type PAD10PULL_R = crate::R<bool, PAD10PULL_A>;
703impl PAD10PULL_R {
704    #[doc = r"Get enumerated values variant"]
705    #[inline(always)]
706    pub fn variant(&self) -> PAD10PULL_A {
707        match self.bits {
708            false => PAD10PULL_A::DIS,
709            true => PAD10PULL_A::EN,
710        }
711    }
712    #[doc = "Checks if the value of the field is `DIS`"]
713    #[inline(always)]
714    pub fn is_dis(&self) -> bool {
715        *self == PAD10PULL_A::DIS
716    }
717    #[doc = "Checks if the value of the field is `EN`"]
718    #[inline(always)]
719    pub fn is_en(&self) -> bool {
720        *self == PAD10PULL_A::EN
721    }
722}
723#[doc = "Write proxy for field `PAD10PULL`"]
724pub struct PAD10PULL_W<'a> {
725    w: &'a mut W,
726}
727impl<'a> PAD10PULL_W<'a> {
728    #[doc = r"Writes `variant` to the field"]
729    #[inline(always)]
730    pub fn variant(self, variant: PAD10PULL_A) -> &'a mut W {
731        {
732            self.bit(variant.into())
733        }
734    }
735    #[doc = "Pullup disabled"]
736    #[inline(always)]
737    pub fn dis(self) -> &'a mut W {
738        self.variant(PAD10PULL_A::DIS)
739    }
740    #[doc = "Pullup enabled"]
741    #[inline(always)]
742    pub fn en(self) -> &'a mut W {
743        self.variant(PAD10PULL_A::EN)
744    }
745    #[doc = r"Sets the field bit"]
746    #[inline(always)]
747    pub fn set_bit(self) -> &'a mut W {
748        self.bit(true)
749    }
750    #[doc = r"Clears the field bit"]
751    #[inline(always)]
752    pub fn clear_bit(self) -> &'a mut W {
753        self.bit(false)
754    }
755    #[doc = r"Writes raw bits to the field"]
756    #[inline(always)]
757    pub fn bit(self, value: bool) -> &'a mut W {
758        self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
759        self.w
760    }
761}
762#[doc = "Pad 9 pullup resistor selection\n\nValue on reset: 0"]
763#[derive(Clone, Copy, Debug, PartialEq)]
764#[repr(u8)]
765pub enum PAD9RSEL_A {
766    #[doc = "0: Pullup is ~1.5 KOhms"]
767    PULL1_5K = 0,
768    #[doc = "1: Pullup is ~6 KOhms"]
769    PULL6K = 1,
770    #[doc = "2: Pullup is ~12 KOhms"]
771    PULL12K = 2,
772    #[doc = "3: Pullup is ~24 KOhms"]
773    PULL24K = 3,
774}
775impl From<PAD9RSEL_A> for u8 {
776    #[inline(always)]
777    fn from(variant: PAD9RSEL_A) -> Self {
778        variant as _
779    }
780}
781#[doc = "Reader of field `PAD9RSEL`"]
782pub type PAD9RSEL_R = crate::R<u8, PAD9RSEL_A>;
783impl PAD9RSEL_R {
784    #[doc = r"Get enumerated values variant"]
785    #[inline(always)]
786    pub fn variant(&self) -> PAD9RSEL_A {
787        match self.bits {
788            0 => PAD9RSEL_A::PULL1_5K,
789            1 => PAD9RSEL_A::PULL6K,
790            2 => PAD9RSEL_A::PULL12K,
791            3 => PAD9RSEL_A::PULL24K,
792            _ => unreachable!(),
793        }
794    }
795    #[doc = "Checks if the value of the field is `PULL1_5K`"]
796    #[inline(always)]
797    pub fn is_pull1_5k(&self) -> bool {
798        *self == PAD9RSEL_A::PULL1_5K
799    }
800    #[doc = "Checks if the value of the field is `PULL6K`"]
801    #[inline(always)]
802    pub fn is_pull6k(&self) -> bool {
803        *self == PAD9RSEL_A::PULL6K
804    }
805    #[doc = "Checks if the value of the field is `PULL12K`"]
806    #[inline(always)]
807    pub fn is_pull12k(&self) -> bool {
808        *self == PAD9RSEL_A::PULL12K
809    }
810    #[doc = "Checks if the value of the field is `PULL24K`"]
811    #[inline(always)]
812    pub fn is_pull24k(&self) -> bool {
813        *self == PAD9RSEL_A::PULL24K
814    }
815}
816#[doc = "Write proxy for field `PAD9RSEL`"]
817pub struct PAD9RSEL_W<'a> {
818    w: &'a mut W,
819}
820impl<'a> PAD9RSEL_W<'a> {
821    #[doc = r"Writes `variant` to the field"]
822    #[inline(always)]
823    pub fn variant(self, variant: PAD9RSEL_A) -> &'a mut W {
824        {
825            self.bits(variant.into())
826        }
827    }
828    #[doc = "Pullup is ~1.5 KOhms"]
829    #[inline(always)]
830    pub fn pull1_5k(self) -> &'a mut W {
831        self.variant(PAD9RSEL_A::PULL1_5K)
832    }
833    #[doc = "Pullup is ~6 KOhms"]
834    #[inline(always)]
835    pub fn pull6k(self) -> &'a mut W {
836        self.variant(PAD9RSEL_A::PULL6K)
837    }
838    #[doc = "Pullup is ~12 KOhms"]
839    #[inline(always)]
840    pub fn pull12k(self) -> &'a mut W {
841        self.variant(PAD9RSEL_A::PULL12K)
842    }
843    #[doc = "Pullup is ~24 KOhms"]
844    #[inline(always)]
845    pub fn pull24k(self) -> &'a mut W {
846        self.variant(PAD9RSEL_A::PULL24K)
847    }
848    #[doc = r"Writes raw bits to the field"]
849    #[inline(always)]
850    pub fn bits(self, value: u8) -> &'a mut W {
851        self.w.bits = (self.w.bits & !(0x03 << 14)) | (((value as u32) & 0x03) << 14);
852        self.w
853    }
854}
855#[doc = "Pad 9 function select\n\nValue on reset: 3"]
856#[derive(Clone, Copy, Debug, PartialEq)]
857#[repr(u8)]
858pub enum PAD9FNCSEL_A {
859    #[doc = "0: Configure as the IOMSTR1 I2C SDA signal"]
860    M1SDA = 0,
861    #[doc = "1: Configure as the IOMSTR1 SPI MISO signal"]
862    M1MISO = 1,
863    #[doc = "2: Configure as the SPI channel 5 nCE signal from IOMSTR0"]
864    M0NCE5 = 2,
865    #[doc = "3: Configure as GPIO9"]
866    GPIO9 = 3,
867    #[doc = "5: Configure as the IOMSTR1 SPI MISO loopback signal from IOSLAVE"]
868    SLMISO = 5,
869    #[doc = "6: Pad disabled"]
870    DIS = 6,
871    #[doc = "7: Configure as the IOMSTR1 I2C SDA loopback signal from IOSLAVE"]
872    SLSDA = 7,
873}
874impl From<PAD9FNCSEL_A> for u8 {
875    #[inline(always)]
876    fn from(variant: PAD9FNCSEL_A) -> Self {
877        variant as _
878    }
879}
880#[doc = "Reader of field `PAD9FNCSEL`"]
881pub type PAD9FNCSEL_R = crate::R<u8, PAD9FNCSEL_A>;
882impl PAD9FNCSEL_R {
883    #[doc = r"Get enumerated values variant"]
884    #[inline(always)]
885    pub fn variant(&self) -> crate::Variant<u8, PAD9FNCSEL_A> {
886        use crate::Variant::*;
887        match self.bits {
888            0 => Val(PAD9FNCSEL_A::M1SDA),
889            1 => Val(PAD9FNCSEL_A::M1MISO),
890            2 => Val(PAD9FNCSEL_A::M0NCE5),
891            3 => Val(PAD9FNCSEL_A::GPIO9),
892            5 => Val(PAD9FNCSEL_A::SLMISO),
893            6 => Val(PAD9FNCSEL_A::DIS),
894            7 => Val(PAD9FNCSEL_A::SLSDA),
895            i => Res(i),
896        }
897    }
898    #[doc = "Checks if the value of the field is `M1SDA`"]
899    #[inline(always)]
900    pub fn is_m1sda(&self) -> bool {
901        *self == PAD9FNCSEL_A::M1SDA
902    }
903    #[doc = "Checks if the value of the field is `M1MISO`"]
904    #[inline(always)]
905    pub fn is_m1miso(&self) -> bool {
906        *self == PAD9FNCSEL_A::M1MISO
907    }
908    #[doc = "Checks if the value of the field is `M0NCE5`"]
909    #[inline(always)]
910    pub fn is_m0n_ce5(&self) -> bool {
911        *self == PAD9FNCSEL_A::M0NCE5
912    }
913    #[doc = "Checks if the value of the field is `GPIO9`"]
914    #[inline(always)]
915    pub fn is_gpio9(&self) -> bool {
916        *self == PAD9FNCSEL_A::GPIO9
917    }
918    #[doc = "Checks if the value of the field is `SLMISO`"]
919    #[inline(always)]
920    pub fn is_slmiso(&self) -> bool {
921        *self == PAD9FNCSEL_A::SLMISO
922    }
923    #[doc = "Checks if the value of the field is `DIS`"]
924    #[inline(always)]
925    pub fn is_dis(&self) -> bool {
926        *self == PAD9FNCSEL_A::DIS
927    }
928    #[doc = "Checks if the value of the field is `SLSDA`"]
929    #[inline(always)]
930    pub fn is_slsda(&self) -> bool {
931        *self == PAD9FNCSEL_A::SLSDA
932    }
933}
934#[doc = "Write proxy for field `PAD9FNCSEL`"]
935pub struct PAD9FNCSEL_W<'a> {
936    w: &'a mut W,
937}
938impl<'a> PAD9FNCSEL_W<'a> {
939    #[doc = r"Writes `variant` to the field"]
940    #[inline(always)]
941    pub fn variant(self, variant: PAD9FNCSEL_A) -> &'a mut W {
942        unsafe { self.bits(variant.into()) }
943    }
944    #[doc = "Configure as the IOMSTR1 I2C SDA signal"]
945    #[inline(always)]
946    pub fn m1sda(self) -> &'a mut W {
947        self.variant(PAD9FNCSEL_A::M1SDA)
948    }
949    #[doc = "Configure as the IOMSTR1 SPI MISO signal"]
950    #[inline(always)]
951    pub fn m1miso(self) -> &'a mut W {
952        self.variant(PAD9FNCSEL_A::M1MISO)
953    }
954    #[doc = "Configure as the SPI channel 5 nCE signal from IOMSTR0"]
955    #[inline(always)]
956    pub fn m0n_ce5(self) -> &'a mut W {
957        self.variant(PAD9FNCSEL_A::M0NCE5)
958    }
959    #[doc = "Configure as GPIO9"]
960    #[inline(always)]
961    pub fn gpio9(self) -> &'a mut W {
962        self.variant(PAD9FNCSEL_A::GPIO9)
963    }
964    #[doc = "Configure as the IOMSTR1 SPI MISO loopback signal from IOSLAVE"]
965    #[inline(always)]
966    pub fn slmiso(self) -> &'a mut W {
967        self.variant(PAD9FNCSEL_A::SLMISO)
968    }
969    #[doc = "Pad disabled"]
970    #[inline(always)]
971    pub fn dis(self) -> &'a mut W {
972        self.variant(PAD9FNCSEL_A::DIS)
973    }
974    #[doc = "Configure as the IOMSTR1 I2C SDA loopback signal from IOSLAVE"]
975    #[inline(always)]
976    pub fn slsda(self) -> &'a mut W {
977        self.variant(PAD9FNCSEL_A::SLSDA)
978    }
979    #[doc = r"Writes raw bits to the field"]
980    #[inline(always)]
981    pub unsafe fn bits(self, value: u8) -> &'a mut W {
982        self.w.bits = (self.w.bits & !(0x07 << 11)) | (((value as u32) & 0x07) << 11);
983        self.w
984    }
985}
986#[doc = "Pad 9 drive strength\n\nValue on reset: 0"]
987#[derive(Clone, Copy, Debug, PartialEq)]
988pub enum PAD9STRNG_A {
989    #[doc = "0: Low drive strength"]
990    LOW = 0,
991    #[doc = "1: High drive strength"]
992    HIGH = 1,
993}
994impl From<PAD9STRNG_A> for bool {
995    #[inline(always)]
996    fn from(variant: PAD9STRNG_A) -> Self {
997        variant as u8 != 0
998    }
999}
1000#[doc = "Reader of field `PAD9STRNG`"]
1001pub type PAD9STRNG_R = crate::R<bool, PAD9STRNG_A>;
1002impl PAD9STRNG_R {
1003    #[doc = r"Get enumerated values variant"]
1004    #[inline(always)]
1005    pub fn variant(&self) -> PAD9STRNG_A {
1006        match self.bits {
1007            false => PAD9STRNG_A::LOW,
1008            true => PAD9STRNG_A::HIGH,
1009        }
1010    }
1011    #[doc = "Checks if the value of the field is `LOW`"]
1012    #[inline(always)]
1013    pub fn is_low(&self) -> bool {
1014        *self == PAD9STRNG_A::LOW
1015    }
1016    #[doc = "Checks if the value of the field is `HIGH`"]
1017    #[inline(always)]
1018    pub fn is_high(&self) -> bool {
1019        *self == PAD9STRNG_A::HIGH
1020    }
1021}
1022#[doc = "Write proxy for field `PAD9STRNG`"]
1023pub struct PAD9STRNG_W<'a> {
1024    w: &'a mut W,
1025}
1026impl<'a> PAD9STRNG_W<'a> {
1027    #[doc = r"Writes `variant` to the field"]
1028    #[inline(always)]
1029    pub fn variant(self, variant: PAD9STRNG_A) -> &'a mut W {
1030        {
1031            self.bit(variant.into())
1032        }
1033    }
1034    #[doc = "Low drive strength"]
1035    #[inline(always)]
1036    pub fn low(self) -> &'a mut W {
1037        self.variant(PAD9STRNG_A::LOW)
1038    }
1039    #[doc = "High drive strength"]
1040    #[inline(always)]
1041    pub fn high(self) -> &'a mut W {
1042        self.variant(PAD9STRNG_A::HIGH)
1043    }
1044    #[doc = r"Sets the field bit"]
1045    #[inline(always)]
1046    pub fn set_bit(self) -> &'a mut W {
1047        self.bit(true)
1048    }
1049    #[doc = r"Clears the field bit"]
1050    #[inline(always)]
1051    pub fn clear_bit(self) -> &'a mut W {
1052        self.bit(false)
1053    }
1054    #[doc = r"Writes raw bits to the field"]
1055    #[inline(always)]
1056    pub fn bit(self, value: bool) -> &'a mut W {
1057        self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
1058        self.w
1059    }
1060}
1061#[doc = "Pad 9 input enable\n\nValue on reset: 0"]
1062#[derive(Clone, Copy, Debug, PartialEq)]
1063pub enum PAD9INPEN_A {
1064    #[doc = "0: Pad input disabled"]
1065    DIS = 0,
1066    #[doc = "1: Pad input enabled"]
1067    EN = 1,
1068}
1069impl From<PAD9INPEN_A> for bool {
1070    #[inline(always)]
1071    fn from(variant: PAD9INPEN_A) -> Self {
1072        variant as u8 != 0
1073    }
1074}
1075#[doc = "Reader of field `PAD9INPEN`"]
1076pub type PAD9INPEN_R = crate::R<bool, PAD9INPEN_A>;
1077impl PAD9INPEN_R {
1078    #[doc = r"Get enumerated values variant"]
1079    #[inline(always)]
1080    pub fn variant(&self) -> PAD9INPEN_A {
1081        match self.bits {
1082            false => PAD9INPEN_A::DIS,
1083            true => PAD9INPEN_A::EN,
1084        }
1085    }
1086    #[doc = "Checks if the value of the field is `DIS`"]
1087    #[inline(always)]
1088    pub fn is_dis(&self) -> bool {
1089        *self == PAD9INPEN_A::DIS
1090    }
1091    #[doc = "Checks if the value of the field is `EN`"]
1092    #[inline(always)]
1093    pub fn is_en(&self) -> bool {
1094        *self == PAD9INPEN_A::EN
1095    }
1096}
1097#[doc = "Write proxy for field `PAD9INPEN`"]
1098pub struct PAD9INPEN_W<'a> {
1099    w: &'a mut W,
1100}
1101impl<'a> PAD9INPEN_W<'a> {
1102    #[doc = r"Writes `variant` to the field"]
1103    #[inline(always)]
1104    pub fn variant(self, variant: PAD9INPEN_A) -> &'a mut W {
1105        {
1106            self.bit(variant.into())
1107        }
1108    }
1109    #[doc = "Pad input disabled"]
1110    #[inline(always)]
1111    pub fn dis(self) -> &'a mut W {
1112        self.variant(PAD9INPEN_A::DIS)
1113    }
1114    #[doc = "Pad input enabled"]
1115    #[inline(always)]
1116    pub fn en(self) -> &'a mut W {
1117        self.variant(PAD9INPEN_A::EN)
1118    }
1119    #[doc = r"Sets the field bit"]
1120    #[inline(always)]
1121    pub fn set_bit(self) -> &'a mut W {
1122        self.bit(true)
1123    }
1124    #[doc = r"Clears the field bit"]
1125    #[inline(always)]
1126    pub fn clear_bit(self) -> &'a mut W {
1127        self.bit(false)
1128    }
1129    #[doc = r"Writes raw bits to the field"]
1130    #[inline(always)]
1131    pub fn bit(self, value: bool) -> &'a mut W {
1132        self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
1133        self.w
1134    }
1135}
1136#[doc = "Pad 9 pullup enable\n\nValue on reset: 0"]
1137#[derive(Clone, Copy, Debug, PartialEq)]
1138pub enum PAD9PULL_A {
1139    #[doc = "0: Pullup disabled"]
1140    DIS = 0,
1141    #[doc = "1: Pullup enabled"]
1142    EN = 1,
1143}
1144impl From<PAD9PULL_A> for bool {
1145    #[inline(always)]
1146    fn from(variant: PAD9PULL_A) -> Self {
1147        variant as u8 != 0
1148    }
1149}
1150#[doc = "Reader of field `PAD9PULL`"]
1151pub type PAD9PULL_R = crate::R<bool, PAD9PULL_A>;
1152impl PAD9PULL_R {
1153    #[doc = r"Get enumerated values variant"]
1154    #[inline(always)]
1155    pub fn variant(&self) -> PAD9PULL_A {
1156        match self.bits {
1157            false => PAD9PULL_A::DIS,
1158            true => PAD9PULL_A::EN,
1159        }
1160    }
1161    #[doc = "Checks if the value of the field is `DIS`"]
1162    #[inline(always)]
1163    pub fn is_dis(&self) -> bool {
1164        *self == PAD9PULL_A::DIS
1165    }
1166    #[doc = "Checks if the value of the field is `EN`"]
1167    #[inline(always)]
1168    pub fn is_en(&self) -> bool {
1169        *self == PAD9PULL_A::EN
1170    }
1171}
1172#[doc = "Write proxy for field `PAD9PULL`"]
1173pub struct PAD9PULL_W<'a> {
1174    w: &'a mut W,
1175}
1176impl<'a> PAD9PULL_W<'a> {
1177    #[doc = r"Writes `variant` to the field"]
1178    #[inline(always)]
1179    pub fn variant(self, variant: PAD9PULL_A) -> &'a mut W {
1180        {
1181            self.bit(variant.into())
1182        }
1183    }
1184    #[doc = "Pullup disabled"]
1185    #[inline(always)]
1186    pub fn dis(self) -> &'a mut W {
1187        self.variant(PAD9PULL_A::DIS)
1188    }
1189    #[doc = "Pullup enabled"]
1190    #[inline(always)]
1191    pub fn en(self) -> &'a mut W {
1192        self.variant(PAD9PULL_A::EN)
1193    }
1194    #[doc = r"Sets the field bit"]
1195    #[inline(always)]
1196    pub fn set_bit(self) -> &'a mut W {
1197        self.bit(true)
1198    }
1199    #[doc = r"Clears the field bit"]
1200    #[inline(always)]
1201    pub fn clear_bit(self) -> &'a mut W {
1202        self.bit(false)
1203    }
1204    #[doc = r"Writes raw bits to the field"]
1205    #[inline(always)]
1206    pub fn bit(self, value: bool) -> &'a mut W {
1207        self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
1208        self.w
1209    }
1210}
1211#[doc = "Pad 8 pullup resistor selection.\n\nValue on reset: 0"]
1212#[derive(Clone, Copy, Debug, PartialEq)]
1213#[repr(u8)]
1214pub enum PAD8RSEL_A {
1215    #[doc = "0: Pullup is ~1.5 KOhms"]
1216    PULL1_5K = 0,
1217    #[doc = "1: Pullup is ~6 KOhms"]
1218    PULL6K = 1,
1219    #[doc = "2: Pullup is ~12 KOhms"]
1220    PULL12K = 2,
1221    #[doc = "3: Pullup is ~24 KOhms"]
1222    PULL24K = 3,
1223}
1224impl From<PAD8RSEL_A> for u8 {
1225    #[inline(always)]
1226    fn from(variant: PAD8RSEL_A) -> Self {
1227        variant as _
1228    }
1229}
1230#[doc = "Reader of field `PAD8RSEL`"]
1231pub type PAD8RSEL_R = crate::R<u8, PAD8RSEL_A>;
1232impl PAD8RSEL_R {
1233    #[doc = r"Get enumerated values variant"]
1234    #[inline(always)]
1235    pub fn variant(&self) -> PAD8RSEL_A {
1236        match self.bits {
1237            0 => PAD8RSEL_A::PULL1_5K,
1238            1 => PAD8RSEL_A::PULL6K,
1239            2 => PAD8RSEL_A::PULL12K,
1240            3 => PAD8RSEL_A::PULL24K,
1241            _ => unreachable!(),
1242        }
1243    }
1244    #[doc = "Checks if the value of the field is `PULL1_5K`"]
1245    #[inline(always)]
1246    pub fn is_pull1_5k(&self) -> bool {
1247        *self == PAD8RSEL_A::PULL1_5K
1248    }
1249    #[doc = "Checks if the value of the field is `PULL6K`"]
1250    #[inline(always)]
1251    pub fn is_pull6k(&self) -> bool {
1252        *self == PAD8RSEL_A::PULL6K
1253    }
1254    #[doc = "Checks if the value of the field is `PULL12K`"]
1255    #[inline(always)]
1256    pub fn is_pull12k(&self) -> bool {
1257        *self == PAD8RSEL_A::PULL12K
1258    }
1259    #[doc = "Checks if the value of the field is `PULL24K`"]
1260    #[inline(always)]
1261    pub fn is_pull24k(&self) -> bool {
1262        *self == PAD8RSEL_A::PULL24K
1263    }
1264}
1265#[doc = "Write proxy for field `PAD8RSEL`"]
1266pub struct PAD8RSEL_W<'a> {
1267    w: &'a mut W,
1268}
1269impl<'a> PAD8RSEL_W<'a> {
1270    #[doc = r"Writes `variant` to the field"]
1271    #[inline(always)]
1272    pub fn variant(self, variant: PAD8RSEL_A) -> &'a mut W {
1273        {
1274            self.bits(variant.into())
1275        }
1276    }
1277    #[doc = "Pullup is ~1.5 KOhms"]
1278    #[inline(always)]
1279    pub fn pull1_5k(self) -> &'a mut W {
1280        self.variant(PAD8RSEL_A::PULL1_5K)
1281    }
1282    #[doc = "Pullup is ~6 KOhms"]
1283    #[inline(always)]
1284    pub fn pull6k(self) -> &'a mut W {
1285        self.variant(PAD8RSEL_A::PULL6K)
1286    }
1287    #[doc = "Pullup is ~12 KOhms"]
1288    #[inline(always)]
1289    pub fn pull12k(self) -> &'a mut W {
1290        self.variant(PAD8RSEL_A::PULL12K)
1291    }
1292    #[doc = "Pullup is ~24 KOhms"]
1293    #[inline(always)]
1294    pub fn pull24k(self) -> &'a mut W {
1295        self.variant(PAD8RSEL_A::PULL24K)
1296    }
1297    #[doc = r"Writes raw bits to the field"]
1298    #[inline(always)]
1299    pub fn bits(self, value: u8) -> &'a mut W {
1300        self.w.bits = (self.w.bits & !(0x03 << 6)) | (((value as u32) & 0x03) << 6);
1301        self.w
1302    }
1303}
1304#[doc = "Pad 8 function select\n\nValue on reset: 3"]
1305#[derive(Clone, Copy, Debug, PartialEq)]
1306#[repr(u8)]
1307pub enum PAD8FNCSEL_A {
1308    #[doc = "0: Configure as the IOMSTR1 I2C SCL signal"]
1309    M1SCL = 0,
1310    #[doc = "1: Configure as the IOMSTR1 SPI SCK signal"]
1311    M1SCK = 1,
1312    #[doc = "2: Configure as the SPI channel 4 nCE signal from IOMSTR0"]
1313    M0NCE4 = 2,
1314    #[doc = "3: Configure as GPIO8"]
1315    GPIO8 = 3,
1316    #[doc = "5: Configure as the IOMSTR1 SPI SCK loopback signal from IOSLAVE"]
1317    SLSCK = 5,
1318    #[doc = "6: Pad disabled"]
1319    DIS = 6,
1320    #[doc = "7: Configure as the IOMSTR1 I2C SCL loopback signal from IOSLAVE"]
1321    SLSCL = 7,
1322}
1323impl From<PAD8FNCSEL_A> for u8 {
1324    #[inline(always)]
1325    fn from(variant: PAD8FNCSEL_A) -> Self {
1326        variant as _
1327    }
1328}
1329#[doc = "Reader of field `PAD8FNCSEL`"]
1330pub type PAD8FNCSEL_R = crate::R<u8, PAD8FNCSEL_A>;
1331impl PAD8FNCSEL_R {
1332    #[doc = r"Get enumerated values variant"]
1333    #[inline(always)]
1334    pub fn variant(&self) -> crate::Variant<u8, PAD8FNCSEL_A> {
1335        use crate::Variant::*;
1336        match self.bits {
1337            0 => Val(PAD8FNCSEL_A::M1SCL),
1338            1 => Val(PAD8FNCSEL_A::M1SCK),
1339            2 => Val(PAD8FNCSEL_A::M0NCE4),
1340            3 => Val(PAD8FNCSEL_A::GPIO8),
1341            5 => Val(PAD8FNCSEL_A::SLSCK),
1342            6 => Val(PAD8FNCSEL_A::DIS),
1343            7 => Val(PAD8FNCSEL_A::SLSCL),
1344            i => Res(i),
1345        }
1346    }
1347    #[doc = "Checks if the value of the field is `M1SCL`"]
1348    #[inline(always)]
1349    pub fn is_m1scl(&self) -> bool {
1350        *self == PAD8FNCSEL_A::M1SCL
1351    }
1352    #[doc = "Checks if the value of the field is `M1SCK`"]
1353    #[inline(always)]
1354    pub fn is_m1sck(&self) -> bool {
1355        *self == PAD8FNCSEL_A::M1SCK
1356    }
1357    #[doc = "Checks if the value of the field is `M0NCE4`"]
1358    #[inline(always)]
1359    pub fn is_m0n_ce4(&self) -> bool {
1360        *self == PAD8FNCSEL_A::M0NCE4
1361    }
1362    #[doc = "Checks if the value of the field is `GPIO8`"]
1363    #[inline(always)]
1364    pub fn is_gpio8(&self) -> bool {
1365        *self == PAD8FNCSEL_A::GPIO8
1366    }
1367    #[doc = "Checks if the value of the field is `SLSCK`"]
1368    #[inline(always)]
1369    pub fn is_slsck(&self) -> bool {
1370        *self == PAD8FNCSEL_A::SLSCK
1371    }
1372    #[doc = "Checks if the value of the field is `DIS`"]
1373    #[inline(always)]
1374    pub fn is_dis(&self) -> bool {
1375        *self == PAD8FNCSEL_A::DIS
1376    }
1377    #[doc = "Checks if the value of the field is `SLSCL`"]
1378    #[inline(always)]
1379    pub fn is_slscl(&self) -> bool {
1380        *self == PAD8FNCSEL_A::SLSCL
1381    }
1382}
1383#[doc = "Write proxy for field `PAD8FNCSEL`"]
1384pub struct PAD8FNCSEL_W<'a> {
1385    w: &'a mut W,
1386}
1387impl<'a> PAD8FNCSEL_W<'a> {
1388    #[doc = r"Writes `variant` to the field"]
1389    #[inline(always)]
1390    pub fn variant(self, variant: PAD8FNCSEL_A) -> &'a mut W {
1391        unsafe { self.bits(variant.into()) }
1392    }
1393    #[doc = "Configure as the IOMSTR1 I2C SCL signal"]
1394    #[inline(always)]
1395    pub fn m1scl(self) -> &'a mut W {
1396        self.variant(PAD8FNCSEL_A::M1SCL)
1397    }
1398    #[doc = "Configure as the IOMSTR1 SPI SCK signal"]
1399    #[inline(always)]
1400    pub fn m1sck(self) -> &'a mut W {
1401        self.variant(PAD8FNCSEL_A::M1SCK)
1402    }
1403    #[doc = "Configure as the SPI channel 4 nCE signal from IOMSTR0"]
1404    #[inline(always)]
1405    pub fn m0n_ce4(self) -> &'a mut W {
1406        self.variant(PAD8FNCSEL_A::M0NCE4)
1407    }
1408    #[doc = "Configure as GPIO8"]
1409    #[inline(always)]
1410    pub fn gpio8(self) -> &'a mut W {
1411        self.variant(PAD8FNCSEL_A::GPIO8)
1412    }
1413    #[doc = "Configure as the IOMSTR1 SPI SCK loopback signal from IOSLAVE"]
1414    #[inline(always)]
1415    pub fn slsck(self) -> &'a mut W {
1416        self.variant(PAD8FNCSEL_A::SLSCK)
1417    }
1418    #[doc = "Pad disabled"]
1419    #[inline(always)]
1420    pub fn dis(self) -> &'a mut W {
1421        self.variant(PAD8FNCSEL_A::DIS)
1422    }
1423    #[doc = "Configure as the IOMSTR1 I2C SCL loopback signal from IOSLAVE"]
1424    #[inline(always)]
1425    pub fn slscl(self) -> &'a mut W {
1426        self.variant(PAD8FNCSEL_A::SLSCL)
1427    }
1428    #[doc = r"Writes raw bits to the field"]
1429    #[inline(always)]
1430    pub unsafe fn bits(self, value: u8) -> &'a mut W {
1431        self.w.bits = (self.w.bits & !(0x07 << 3)) | (((value as u32) & 0x07) << 3);
1432        self.w
1433    }
1434}
1435#[doc = "Pad 8 drive strength\n\nValue on reset: 0"]
1436#[derive(Clone, Copy, Debug, PartialEq)]
1437pub enum PAD8STRNG_A {
1438    #[doc = "0: Low drive strength"]
1439    LOW = 0,
1440    #[doc = "1: High drive strength"]
1441    HIGH = 1,
1442}
1443impl From<PAD8STRNG_A> for bool {
1444    #[inline(always)]
1445    fn from(variant: PAD8STRNG_A) -> Self {
1446        variant as u8 != 0
1447    }
1448}
1449#[doc = "Reader of field `PAD8STRNG`"]
1450pub type PAD8STRNG_R = crate::R<bool, PAD8STRNG_A>;
1451impl PAD8STRNG_R {
1452    #[doc = r"Get enumerated values variant"]
1453    #[inline(always)]
1454    pub fn variant(&self) -> PAD8STRNG_A {
1455        match self.bits {
1456            false => PAD8STRNG_A::LOW,
1457            true => PAD8STRNG_A::HIGH,
1458        }
1459    }
1460    #[doc = "Checks if the value of the field is `LOW`"]
1461    #[inline(always)]
1462    pub fn is_low(&self) -> bool {
1463        *self == PAD8STRNG_A::LOW
1464    }
1465    #[doc = "Checks if the value of the field is `HIGH`"]
1466    #[inline(always)]
1467    pub fn is_high(&self) -> bool {
1468        *self == PAD8STRNG_A::HIGH
1469    }
1470}
1471#[doc = "Write proxy for field `PAD8STRNG`"]
1472pub struct PAD8STRNG_W<'a> {
1473    w: &'a mut W,
1474}
1475impl<'a> PAD8STRNG_W<'a> {
1476    #[doc = r"Writes `variant` to the field"]
1477    #[inline(always)]
1478    pub fn variant(self, variant: PAD8STRNG_A) -> &'a mut W {
1479        {
1480            self.bit(variant.into())
1481        }
1482    }
1483    #[doc = "Low drive strength"]
1484    #[inline(always)]
1485    pub fn low(self) -> &'a mut W {
1486        self.variant(PAD8STRNG_A::LOW)
1487    }
1488    #[doc = "High drive strength"]
1489    #[inline(always)]
1490    pub fn high(self) -> &'a mut W {
1491        self.variant(PAD8STRNG_A::HIGH)
1492    }
1493    #[doc = r"Sets the field bit"]
1494    #[inline(always)]
1495    pub fn set_bit(self) -> &'a mut W {
1496        self.bit(true)
1497    }
1498    #[doc = r"Clears the field bit"]
1499    #[inline(always)]
1500    pub fn clear_bit(self) -> &'a mut W {
1501        self.bit(false)
1502    }
1503    #[doc = r"Writes raw bits to the field"]
1504    #[inline(always)]
1505    pub fn bit(self, value: bool) -> &'a mut W {
1506        self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
1507        self.w
1508    }
1509}
1510#[doc = "Pad 8 input enable\n\nValue on reset: 0"]
1511#[derive(Clone, Copy, Debug, PartialEq)]
1512pub enum PAD8INPEN_A {
1513    #[doc = "0: Pad input disabled"]
1514    DIS = 0,
1515    #[doc = "1: Pad input enabled"]
1516    EN = 1,
1517}
1518impl From<PAD8INPEN_A> for bool {
1519    #[inline(always)]
1520    fn from(variant: PAD8INPEN_A) -> Self {
1521        variant as u8 != 0
1522    }
1523}
1524#[doc = "Reader of field `PAD8INPEN`"]
1525pub type PAD8INPEN_R = crate::R<bool, PAD8INPEN_A>;
1526impl PAD8INPEN_R {
1527    #[doc = r"Get enumerated values variant"]
1528    #[inline(always)]
1529    pub fn variant(&self) -> PAD8INPEN_A {
1530        match self.bits {
1531            false => PAD8INPEN_A::DIS,
1532            true => PAD8INPEN_A::EN,
1533        }
1534    }
1535    #[doc = "Checks if the value of the field is `DIS`"]
1536    #[inline(always)]
1537    pub fn is_dis(&self) -> bool {
1538        *self == PAD8INPEN_A::DIS
1539    }
1540    #[doc = "Checks if the value of the field is `EN`"]
1541    #[inline(always)]
1542    pub fn is_en(&self) -> bool {
1543        *self == PAD8INPEN_A::EN
1544    }
1545}
1546#[doc = "Write proxy for field `PAD8INPEN`"]
1547pub struct PAD8INPEN_W<'a> {
1548    w: &'a mut W,
1549}
1550impl<'a> PAD8INPEN_W<'a> {
1551    #[doc = r"Writes `variant` to the field"]
1552    #[inline(always)]
1553    pub fn variant(self, variant: PAD8INPEN_A) -> &'a mut W {
1554        {
1555            self.bit(variant.into())
1556        }
1557    }
1558    #[doc = "Pad input disabled"]
1559    #[inline(always)]
1560    pub fn dis(self) -> &'a mut W {
1561        self.variant(PAD8INPEN_A::DIS)
1562    }
1563    #[doc = "Pad input enabled"]
1564    #[inline(always)]
1565    pub fn en(self) -> &'a mut W {
1566        self.variant(PAD8INPEN_A::EN)
1567    }
1568    #[doc = r"Sets the field bit"]
1569    #[inline(always)]
1570    pub fn set_bit(self) -> &'a mut W {
1571        self.bit(true)
1572    }
1573    #[doc = r"Clears the field bit"]
1574    #[inline(always)]
1575    pub fn clear_bit(self) -> &'a mut W {
1576        self.bit(false)
1577    }
1578    #[doc = r"Writes raw bits to the field"]
1579    #[inline(always)]
1580    pub fn bit(self, value: bool) -> &'a mut W {
1581        self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
1582        self.w
1583    }
1584}
1585#[doc = "Pad 8 pullup enable\n\nValue on reset: 0"]
1586#[derive(Clone, Copy, Debug, PartialEq)]
1587pub enum PAD8PULL_A {
1588    #[doc = "0: Pullup disabled"]
1589    DIS = 0,
1590    #[doc = "1: Pullup enabled"]
1591    EN = 1,
1592}
1593impl From<PAD8PULL_A> for bool {
1594    #[inline(always)]
1595    fn from(variant: PAD8PULL_A) -> Self {
1596        variant as u8 != 0
1597    }
1598}
1599#[doc = "Reader of field `PAD8PULL`"]
1600pub type PAD8PULL_R = crate::R<bool, PAD8PULL_A>;
1601impl PAD8PULL_R {
1602    #[doc = r"Get enumerated values variant"]
1603    #[inline(always)]
1604    pub fn variant(&self) -> PAD8PULL_A {
1605        match self.bits {
1606            false => PAD8PULL_A::DIS,
1607            true => PAD8PULL_A::EN,
1608        }
1609    }
1610    #[doc = "Checks if the value of the field is `DIS`"]
1611    #[inline(always)]
1612    pub fn is_dis(&self) -> bool {
1613        *self == PAD8PULL_A::DIS
1614    }
1615    #[doc = "Checks if the value of the field is `EN`"]
1616    #[inline(always)]
1617    pub fn is_en(&self) -> bool {
1618        *self == PAD8PULL_A::EN
1619    }
1620}
1621#[doc = "Write proxy for field `PAD8PULL`"]
1622pub struct PAD8PULL_W<'a> {
1623    w: &'a mut W,
1624}
1625impl<'a> PAD8PULL_W<'a> {
1626    #[doc = r"Writes `variant` to the field"]
1627    #[inline(always)]
1628    pub fn variant(self, variant: PAD8PULL_A) -> &'a mut W {
1629        {
1630            self.bit(variant.into())
1631        }
1632    }
1633    #[doc = "Pullup disabled"]
1634    #[inline(always)]
1635    pub fn dis(self) -> &'a mut W {
1636        self.variant(PAD8PULL_A::DIS)
1637    }
1638    #[doc = "Pullup enabled"]
1639    #[inline(always)]
1640    pub fn en(self) -> &'a mut W {
1641        self.variant(PAD8PULL_A::EN)
1642    }
1643    #[doc = r"Sets the field bit"]
1644    #[inline(always)]
1645    pub fn set_bit(self) -> &'a mut W {
1646        self.bit(true)
1647    }
1648    #[doc = r"Clears the field bit"]
1649    #[inline(always)]
1650    pub fn clear_bit(self) -> &'a mut W {
1651        self.bit(false)
1652    }
1653    #[doc = r"Writes raw bits to the field"]
1654    #[inline(always)]
1655    pub fn bit(self, value: bool) -> &'a mut W {
1656        self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
1657        self.w
1658    }
1659}
1660impl R {
1661    #[doc = "Bit 30 - Pad 11 lower power switch enable"]
1662    #[inline(always)]
1663    pub fn pad11pwrdn(&self) -> PAD11PWRDN_R {
1664        PAD11PWRDN_R::new(((self.bits >> 30) & 0x01) != 0)
1665    }
1666    #[doc = "Bits 27:28 - Pad 11 function select"]
1667    #[inline(always)]
1668    pub fn pad11fncsel(&self) -> PAD11FNCSEL_R {
1669        PAD11FNCSEL_R::new(((self.bits >> 27) & 0x03) as u8)
1670    }
1671    #[doc = "Bit 26 - Pad 11 drive strentgh"]
1672    #[inline(always)]
1673    pub fn pad11strng(&self) -> PAD11STRNG_R {
1674        PAD11STRNG_R::new(((self.bits >> 26) & 0x01) != 0)
1675    }
1676    #[doc = "Bit 25 - Pad 11 input enable"]
1677    #[inline(always)]
1678    pub fn pad11inpen(&self) -> PAD11INPEN_R {
1679        PAD11INPEN_R::new(((self.bits >> 25) & 0x01) != 0)
1680    }
1681    #[doc = "Bit 24 - Pad 11 pullup enable"]
1682    #[inline(always)]
1683    pub fn pad11pull(&self) -> PAD11PULL_R {
1684        PAD11PULL_R::new(((self.bits >> 24) & 0x01) != 0)
1685    }
1686    #[doc = "Bits 19:21 - Pad 10 function select"]
1687    #[inline(always)]
1688    pub fn pad10fncsel(&self) -> PAD10FNCSEL_R {
1689        PAD10FNCSEL_R::new(((self.bits >> 19) & 0x07) as u8)
1690    }
1691    #[doc = "Bit 18 - Pad 10 drive strength"]
1692    #[inline(always)]
1693    pub fn pad10strng(&self) -> PAD10STRNG_R {
1694        PAD10STRNG_R::new(((self.bits >> 18) & 0x01) != 0)
1695    }
1696    #[doc = "Bit 17 - Pad 10 input enable"]
1697    #[inline(always)]
1698    pub fn pad10inpen(&self) -> PAD10INPEN_R {
1699        PAD10INPEN_R::new(((self.bits >> 17) & 0x01) != 0)
1700    }
1701    #[doc = "Bit 16 - Pad 10 pullup enable"]
1702    #[inline(always)]
1703    pub fn pad10pull(&self) -> PAD10PULL_R {
1704        PAD10PULL_R::new(((self.bits >> 16) & 0x01) != 0)
1705    }
1706    #[doc = "Bits 14:15 - Pad 9 pullup resistor selection"]
1707    #[inline(always)]
1708    pub fn pad9rsel(&self) -> PAD9RSEL_R {
1709        PAD9RSEL_R::new(((self.bits >> 14) & 0x03) as u8)
1710    }
1711    #[doc = "Bits 11:13 - Pad 9 function select"]
1712    #[inline(always)]
1713    pub fn pad9fncsel(&self) -> PAD9FNCSEL_R {
1714        PAD9FNCSEL_R::new(((self.bits >> 11) & 0x07) as u8)
1715    }
1716    #[doc = "Bit 10 - Pad 9 drive strength"]
1717    #[inline(always)]
1718    pub fn pad9strng(&self) -> PAD9STRNG_R {
1719        PAD9STRNG_R::new(((self.bits >> 10) & 0x01) != 0)
1720    }
1721    #[doc = "Bit 9 - Pad 9 input enable"]
1722    #[inline(always)]
1723    pub fn pad9inpen(&self) -> PAD9INPEN_R {
1724        PAD9INPEN_R::new(((self.bits >> 9) & 0x01) != 0)
1725    }
1726    #[doc = "Bit 8 - Pad 9 pullup enable"]
1727    #[inline(always)]
1728    pub fn pad9pull(&self) -> PAD9PULL_R {
1729        PAD9PULL_R::new(((self.bits >> 8) & 0x01) != 0)
1730    }
1731    #[doc = "Bits 6:7 - Pad 8 pullup resistor selection."]
1732    #[inline(always)]
1733    pub fn pad8rsel(&self) -> PAD8RSEL_R {
1734        PAD8RSEL_R::new(((self.bits >> 6) & 0x03) as u8)
1735    }
1736    #[doc = "Bits 3:5 - Pad 8 function select"]
1737    #[inline(always)]
1738    pub fn pad8fncsel(&self) -> PAD8FNCSEL_R {
1739        PAD8FNCSEL_R::new(((self.bits >> 3) & 0x07) as u8)
1740    }
1741    #[doc = "Bit 2 - Pad 8 drive strength"]
1742    #[inline(always)]
1743    pub fn pad8strng(&self) -> PAD8STRNG_R {
1744        PAD8STRNG_R::new(((self.bits >> 2) & 0x01) != 0)
1745    }
1746    #[doc = "Bit 1 - Pad 8 input enable"]
1747    #[inline(always)]
1748    pub fn pad8inpen(&self) -> PAD8INPEN_R {
1749        PAD8INPEN_R::new(((self.bits >> 1) & 0x01) != 0)
1750    }
1751    #[doc = "Bit 0 - Pad 8 pullup enable"]
1752    #[inline(always)]
1753    pub fn pad8pull(&self) -> PAD8PULL_R {
1754        PAD8PULL_R::new((self.bits & 0x01) != 0)
1755    }
1756}
1757impl W {
1758    #[doc = "Bit 30 - Pad 11 lower power switch enable"]
1759    #[inline(always)]
1760    pub fn pad11pwrdn(&mut self) -> PAD11PWRDN_W {
1761        PAD11PWRDN_W { w: self }
1762    }
1763    #[doc = "Bits 27:28 - Pad 11 function select"]
1764    #[inline(always)]
1765    pub fn pad11fncsel(&mut self) -> PAD11FNCSEL_W {
1766        PAD11FNCSEL_W { w: self }
1767    }
1768    #[doc = "Bit 26 - Pad 11 drive strentgh"]
1769    #[inline(always)]
1770    pub fn pad11strng(&mut self) -> PAD11STRNG_W {
1771        PAD11STRNG_W { w: self }
1772    }
1773    #[doc = "Bit 25 - Pad 11 input enable"]
1774    #[inline(always)]
1775    pub fn pad11inpen(&mut self) -> PAD11INPEN_W {
1776        PAD11INPEN_W { w: self }
1777    }
1778    #[doc = "Bit 24 - Pad 11 pullup enable"]
1779    #[inline(always)]
1780    pub fn pad11pull(&mut self) -> PAD11PULL_W {
1781        PAD11PULL_W { w: self }
1782    }
1783    #[doc = "Bits 19:21 - Pad 10 function select"]
1784    #[inline(always)]
1785    pub fn pad10fncsel(&mut self) -> PAD10FNCSEL_W {
1786        PAD10FNCSEL_W { w: self }
1787    }
1788    #[doc = "Bit 18 - Pad 10 drive strength"]
1789    #[inline(always)]
1790    pub fn pad10strng(&mut self) -> PAD10STRNG_W {
1791        PAD10STRNG_W { w: self }
1792    }
1793    #[doc = "Bit 17 - Pad 10 input enable"]
1794    #[inline(always)]
1795    pub fn pad10inpen(&mut self) -> PAD10INPEN_W {
1796        PAD10INPEN_W { w: self }
1797    }
1798    #[doc = "Bit 16 - Pad 10 pullup enable"]
1799    #[inline(always)]
1800    pub fn pad10pull(&mut self) -> PAD10PULL_W {
1801        PAD10PULL_W { w: self }
1802    }
1803    #[doc = "Bits 14:15 - Pad 9 pullup resistor selection"]
1804    #[inline(always)]
1805    pub fn pad9rsel(&mut self) -> PAD9RSEL_W {
1806        PAD9RSEL_W { w: self }
1807    }
1808    #[doc = "Bits 11:13 - Pad 9 function select"]
1809    #[inline(always)]
1810    pub fn pad9fncsel(&mut self) -> PAD9FNCSEL_W {
1811        PAD9FNCSEL_W { w: self }
1812    }
1813    #[doc = "Bit 10 - Pad 9 drive strength"]
1814    #[inline(always)]
1815    pub fn pad9strng(&mut self) -> PAD9STRNG_W {
1816        PAD9STRNG_W { w: self }
1817    }
1818    #[doc = "Bit 9 - Pad 9 input enable"]
1819    #[inline(always)]
1820    pub fn pad9inpen(&mut self) -> PAD9INPEN_W {
1821        PAD9INPEN_W { w: self }
1822    }
1823    #[doc = "Bit 8 - Pad 9 pullup enable"]
1824    #[inline(always)]
1825    pub fn pad9pull(&mut self) -> PAD9PULL_W {
1826        PAD9PULL_W { w: self }
1827    }
1828    #[doc = "Bits 6:7 - Pad 8 pullup resistor selection."]
1829    #[inline(always)]
1830    pub fn pad8rsel(&mut self) -> PAD8RSEL_W {
1831        PAD8RSEL_W { w: self }
1832    }
1833    #[doc = "Bits 3:5 - Pad 8 function select"]
1834    #[inline(always)]
1835    pub fn pad8fncsel(&mut self) -> PAD8FNCSEL_W {
1836        PAD8FNCSEL_W { w: self }
1837    }
1838    #[doc = "Bit 2 - Pad 8 drive strength"]
1839    #[inline(always)]
1840    pub fn pad8strng(&mut self) -> PAD8STRNG_W {
1841        PAD8STRNG_W { w: self }
1842    }
1843    #[doc = "Bit 1 - Pad 8 input enable"]
1844    #[inline(always)]
1845    pub fn pad8inpen(&mut self) -> PAD8INPEN_W {
1846        PAD8INPEN_W { w: self }
1847    }
1848    #[doc = "Bit 0 - Pad 8 pullup enable"]
1849    #[inline(always)]
1850    pub fn pad8pull(&mut self) -> PAD8PULL_W {
1851        PAD8PULL_W { w: self }
1852    }
1853}
ambiq_apollo1_pac/gpio/padregc.rs

ambiq_apollo1_pac/gpio/
padregc.rs
