1#[doc = "Register `CFGE` reader"]
2pub struct R(crate::R<CFGE_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<CFGE_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<CFGE_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<CFGE_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `CFGE` writer"]
17pub struct W(crate::W<CFGE_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<CFGE_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<CFGE_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<CFGE_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "GPIO39 interrupt direction.\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum GPIO39INTD_A {
40 #[doc = "0: INCFG = 1 - No interrupt on GPIO transition value."]
41 INTDIS = 0,
42 #[doc = "1: INCFG = 1 - Interrupt on either low to high or high to low GPIO transition value."]
43 INTBOTH = 1,
44}
45impl From<GPIO39INTD_A> for bool {
46 #[inline(always)]
47 fn from(variant: GPIO39INTD_A) -> Self {
48 variant as u8 != 0
49 }
50}
51#[doc = "Field `GPIO39INTD` reader - GPIO39 interrupt direction."]
52pub struct GPIO39INTD_R(crate::FieldReader<bool, GPIO39INTD_A>);
53impl GPIO39INTD_R {
54 pub(crate) fn new(bits: bool) -> Self {
55 GPIO39INTD_R(crate::FieldReader::new(bits))
56 }
57 #[doc = r"Get enumerated values variant"]
58 #[inline(always)]
59 pub fn variant(&self) -> GPIO39INTD_A {
60 match self.bits {
61 false => GPIO39INTD_A::INTDIS,
62 true => GPIO39INTD_A::INTBOTH,
63 }
64 }
65 #[doc = "Checks if the value of the field is `INTDIS`"]
66 #[inline(always)]
67 pub fn is_intdis(&self) -> bool {
68 **self == GPIO39INTD_A::INTDIS
69 }
70 #[doc = "Checks if the value of the field is `INTBOTH`"]
71 #[inline(always)]
72 pub fn is_intboth(&self) -> bool {
73 **self == GPIO39INTD_A::INTBOTH
74 }
75}
76impl core::ops::Deref for GPIO39INTD_R {
77 type Target = crate::FieldReader<bool, GPIO39INTD_A>;
78 #[inline(always)]
79 fn deref(&self) -> &Self::Target {
80 &self.0
81 }
82}
83#[doc = "Field `GPIO39INTD` writer - GPIO39 interrupt direction."]
84pub struct GPIO39INTD_W<'a> {
85 w: &'a mut W,
86}
87impl<'a> GPIO39INTD_W<'a> {
88 #[doc = r"Writes `variant` to the field"]
89 #[inline(always)]
90 pub fn variant(self, variant: GPIO39INTD_A) -> &'a mut W {
91 self.bit(variant.into())
92 }
93 #[doc = "INCFG = 1 - No interrupt on GPIO transition value."]
94 #[inline(always)]
95 pub fn intdis(self) -> &'a mut W {
96 self.variant(GPIO39INTD_A::INTDIS)
97 }
98 #[doc = "INCFG = 1 - Interrupt on either low to high or high to low GPIO transition value."]
99 #[inline(always)]
100 pub fn intboth(self) -> &'a mut W {
101 self.variant(GPIO39INTD_A::INTBOTH)
102 }
103 #[doc = r"Sets the field bit"]
104 #[inline(always)]
105 pub fn set_bit(self) -> &'a mut W {
106 self.bit(true)
107 }
108 #[doc = r"Clears the field bit"]
109 #[inline(always)]
110 pub fn clear_bit(self) -> &'a mut W {
111 self.bit(false)
112 }
113 #[doc = r"Writes raw bits to the field"]
114 #[inline(always)]
115 pub fn bit(self, value: bool) -> &'a mut W {
116 self.w.bits = (self.w.bits & !(0x01 << 31)) | ((value as u32 & 0x01) << 31);
117 self.w
118 }
119}
120#[doc = "GPIO39 output configuration.\n\nValue on reset: 0"]
121#[derive(Clone, Copy, Debug, PartialEq)]
122#[repr(u8)]
123pub enum GPIO39OUTCFG_A {
124 #[doc = "0: FNCSEL = 0x3 - Output disabled value."]
125 DIS = 0,
126 #[doc = "1: FNCSEL = 0x3 - Output is push-pull value."]
127 PUSHPULL = 1,
128 #[doc = "2: FNCSEL = 0x3 - Output is open drain value."]
129 OD = 2,
130 #[doc = "3: FNCSEL = 0x3 - Output is tri-state value."]
131 TS = 3,
132}
133impl From<GPIO39OUTCFG_A> for u8 {
134 #[inline(always)]
135 fn from(variant: GPIO39OUTCFG_A) -> Self {
136 variant as _
137 }
138}
139#[doc = "Field `GPIO39OUTCFG` reader - GPIO39 output configuration."]
140pub struct GPIO39OUTCFG_R(crate::FieldReader<u8, GPIO39OUTCFG_A>);
141impl GPIO39OUTCFG_R {
142 pub(crate) fn new(bits: u8) -> Self {
143 GPIO39OUTCFG_R(crate::FieldReader::new(bits))
144 }
145 #[doc = r"Get enumerated values variant"]
146 #[inline(always)]
147 pub fn variant(&self) -> GPIO39OUTCFG_A {
148 match self.bits {
149 0 => GPIO39OUTCFG_A::DIS,
150 1 => GPIO39OUTCFG_A::PUSHPULL,
151 2 => GPIO39OUTCFG_A::OD,
152 3 => GPIO39OUTCFG_A::TS,
153 _ => unreachable!(),
154 }
155 }
156 #[doc = "Checks if the value of the field is `DIS`"]
157 #[inline(always)]
158 pub fn is_dis(&self) -> bool {
159 **self == GPIO39OUTCFG_A::DIS
160 }
161 #[doc = "Checks if the value of the field is `PUSHPULL`"]
162 #[inline(always)]
163 pub fn is_pushpull(&self) -> bool {
164 **self == GPIO39OUTCFG_A::PUSHPULL
165 }
166 #[doc = "Checks if the value of the field is `OD`"]
167 #[inline(always)]
168 pub fn is_od(&self) -> bool {
169 **self == GPIO39OUTCFG_A::OD
170 }
171 #[doc = "Checks if the value of the field is `TS`"]
172 #[inline(always)]
173 pub fn is_ts(&self) -> bool {
174 **self == GPIO39OUTCFG_A::TS
175 }
176}
177impl core::ops::Deref for GPIO39OUTCFG_R {
178 type Target = crate::FieldReader<u8, GPIO39OUTCFG_A>;
179 #[inline(always)]
180 fn deref(&self) -> &Self::Target {
181 &self.0
182 }
183}
184#[doc = "Field `GPIO39OUTCFG` writer - GPIO39 output configuration."]
185pub struct GPIO39OUTCFG_W<'a> {
186 w: &'a mut W,
187}
188impl<'a> GPIO39OUTCFG_W<'a> {
189 #[doc = r"Writes `variant` to the field"]
190 #[inline(always)]
191 pub fn variant(self, variant: GPIO39OUTCFG_A) -> &'a mut W {
192 self.bits(variant.into())
193 }
194 #[doc = "FNCSEL = 0x3 - Output disabled value."]
195 #[inline(always)]
196 pub fn dis(self) -> &'a mut W {
197 self.variant(GPIO39OUTCFG_A::DIS)
198 }
199 #[doc = "FNCSEL = 0x3 - Output is push-pull value."]
200 #[inline(always)]
201 pub fn pushpull(self) -> &'a mut W {
202 self.variant(GPIO39OUTCFG_A::PUSHPULL)
203 }
204 #[doc = "FNCSEL = 0x3 - Output is open drain value."]
205 #[inline(always)]
206 pub fn od(self) -> &'a mut W {
207 self.variant(GPIO39OUTCFG_A::OD)
208 }
209 #[doc = "FNCSEL = 0x3 - Output is tri-state value."]
210 #[inline(always)]
211 pub fn ts(self) -> &'a mut W {
212 self.variant(GPIO39OUTCFG_A::TS)
213 }
214 #[doc = r"Writes raw bits to the field"]
215 #[inline(always)]
216 pub fn bits(self, value: u8) -> &'a mut W {
217 self.w.bits = (self.w.bits & !(0x03 << 29)) | ((value as u32 & 0x03) << 29);
218 self.w
219 }
220}
221#[doc = "GPIO39 input enable.\n\nValue on reset: 0"]
222#[derive(Clone, Copy, Debug, PartialEq)]
223pub enum GPIO39INCFG_A {
224 #[doc = "0: Read the GPIO pin data value."]
225 READ = 0,
226 #[doc = "1: INTD = 0 - Readback will always be zero value."]
227 RDZERO = 1,
228}
229impl From<GPIO39INCFG_A> for bool {
230 #[inline(always)]
231 fn from(variant: GPIO39INCFG_A) -> Self {
232 variant as u8 != 0
233 }
234}
235#[doc = "Field `GPIO39INCFG` reader - GPIO39 input enable."]
236pub struct GPIO39INCFG_R(crate::FieldReader<bool, GPIO39INCFG_A>);
237impl GPIO39INCFG_R {
238 pub(crate) fn new(bits: bool) -> Self {
239 GPIO39INCFG_R(crate::FieldReader::new(bits))
240 }
241 #[doc = r"Get enumerated values variant"]
242 #[inline(always)]
243 pub fn variant(&self) -> GPIO39INCFG_A {
244 match self.bits {
245 false => GPIO39INCFG_A::READ,
246 true => GPIO39INCFG_A::RDZERO,
247 }
248 }
249 #[doc = "Checks if the value of the field is `READ`"]
250 #[inline(always)]
251 pub fn is_read(&self) -> bool {
252 **self == GPIO39INCFG_A::READ
253 }
254 #[doc = "Checks if the value of the field is `RDZERO`"]
255 #[inline(always)]
256 pub fn is_rdzero(&self) -> bool {
257 **self == GPIO39INCFG_A::RDZERO
258 }
259}
260impl core::ops::Deref for GPIO39INCFG_R {
261 type Target = crate::FieldReader<bool, GPIO39INCFG_A>;
262 #[inline(always)]
263 fn deref(&self) -> &Self::Target {
264 &self.0
265 }
266}
267#[doc = "Field `GPIO39INCFG` writer - GPIO39 input enable."]
268pub struct GPIO39INCFG_W<'a> {
269 w: &'a mut W,
270}
271impl<'a> GPIO39INCFG_W<'a> {
272 #[doc = r"Writes `variant` to the field"]
273 #[inline(always)]
274 pub fn variant(self, variant: GPIO39INCFG_A) -> &'a mut W {
275 self.bit(variant.into())
276 }
277 #[doc = "Read the GPIO pin data value."]
278 #[inline(always)]
279 pub fn read(self) -> &'a mut W {
280 self.variant(GPIO39INCFG_A::READ)
281 }
282 #[doc = "INTD = 0 - Readback will always be zero value."]
283 #[inline(always)]
284 pub fn rdzero(self) -> &'a mut W {
285 self.variant(GPIO39INCFG_A::RDZERO)
286 }
287 #[doc = r"Sets the field bit"]
288 #[inline(always)]
289 pub fn set_bit(self) -> &'a mut W {
290 self.bit(true)
291 }
292 #[doc = r"Clears the field bit"]
293 #[inline(always)]
294 pub fn clear_bit(self) -> &'a mut W {
295 self.bit(false)
296 }
297 #[doc = r"Writes raw bits to the field"]
298 #[inline(always)]
299 pub fn bit(self, value: bool) -> &'a mut W {
300 self.w.bits = (self.w.bits & !(0x01 << 28)) | ((value as u32 & 0x01) << 28);
301 self.w
302 }
303}
304#[doc = "GPIO38 interrupt direction.\n\nValue on reset: 0"]
305#[derive(Clone, Copy, Debug, PartialEq)]
306pub enum GPIO38INTD_A {
307 #[doc = "0: FNCSEL = 0x1 - nCE polarity active low value."]
308 NCELOW = 0,
309 #[doc = "1: FNCSEL = 0x1 - nCE polarity active high value."]
310 NCEHIGH = 1,
311}
312impl From<GPIO38INTD_A> for bool {
313 #[inline(always)]
314 fn from(variant: GPIO38INTD_A) -> Self {
315 variant as u8 != 0
316 }
317}
318#[doc = "Field `GPIO38INTD` reader - GPIO38 interrupt direction."]
319pub struct GPIO38INTD_R(crate::FieldReader<bool, GPIO38INTD_A>);
320impl GPIO38INTD_R {
321 pub(crate) fn new(bits: bool) -> Self {
322 GPIO38INTD_R(crate::FieldReader::new(bits))
323 }
324 #[doc = r"Get enumerated values variant"]
325 #[inline(always)]
326 pub fn variant(&self) -> GPIO38INTD_A {
327 match self.bits {
328 false => GPIO38INTD_A::NCELOW,
329 true => GPIO38INTD_A::NCEHIGH,
330 }
331 }
332 #[doc = "Checks if the value of the field is `NCELOW`"]
333 #[inline(always)]
334 pub fn is_n_celow(&self) -> bool {
335 **self == GPIO38INTD_A::NCELOW
336 }
337 #[doc = "Checks if the value of the field is `NCEHIGH`"]
338 #[inline(always)]
339 pub fn is_n_cehigh(&self) -> bool {
340 **self == GPIO38INTD_A::NCEHIGH
341 }
342}
343impl core::ops::Deref for GPIO38INTD_R {
344 type Target = crate::FieldReader<bool, GPIO38INTD_A>;
345 #[inline(always)]
346 fn deref(&self) -> &Self::Target {
347 &self.0
348 }
349}
350#[doc = "Field `GPIO38INTD` writer - GPIO38 interrupt direction."]
351pub struct GPIO38INTD_W<'a> {
352 w: &'a mut W,
353}
354impl<'a> GPIO38INTD_W<'a> {
355 #[doc = r"Writes `variant` to the field"]
356 #[inline(always)]
357 pub fn variant(self, variant: GPIO38INTD_A) -> &'a mut W {
358 self.bit(variant.into())
359 }
360 #[doc = "FNCSEL = 0x1 - nCE polarity active low value."]
361 #[inline(always)]
362 pub fn n_celow(self) -> &'a mut W {
363 self.variant(GPIO38INTD_A::NCELOW)
364 }
365 #[doc = "FNCSEL = 0x1 - nCE polarity active high value."]
366 #[inline(always)]
367 pub fn n_cehigh(self) -> &'a mut W {
368 self.variant(GPIO38INTD_A::NCEHIGH)
369 }
370 #[doc = r"Sets the field bit"]
371 #[inline(always)]
372 pub fn set_bit(self) -> &'a mut W {
373 self.bit(true)
374 }
375 #[doc = r"Clears the field bit"]
376 #[inline(always)]
377 pub fn clear_bit(self) -> &'a mut W {
378 self.bit(false)
379 }
380 #[doc = r"Writes raw bits to the field"]
381 #[inline(always)]
382 pub fn bit(self, value: bool) -> &'a mut W {
383 self.w.bits = (self.w.bits & !(0x01 << 27)) | ((value as u32 & 0x01) << 27);
384 self.w
385 }
386}
387#[doc = "GPIO38 output configuration.\n\nValue on reset: 0"]
388#[derive(Clone, Copy, Debug, PartialEq)]
389#[repr(u8)]
390pub enum GPIO38OUTCFG_A {
391 #[doc = "0: FNCSEL = 0x3 - Output disabled value."]
392 DIS = 0,
393 #[doc = "1: FNCSEL = 0x3 - Output is push-pull value."]
394 PUSHPULL = 1,
395 #[doc = "2: FNCSEL = 0x3 - Output is open drain value."]
396 OD = 2,
397 #[doc = "3: FNCSEL = 0x3 - Output is tri-state value."]
398 TS = 3,
399}
400impl From<GPIO38OUTCFG_A> for u8 {
401 #[inline(always)]
402 fn from(variant: GPIO38OUTCFG_A) -> Self {
403 variant as _
404 }
405}
406#[doc = "Field `GPIO38OUTCFG` reader - GPIO38 output configuration."]
407pub struct GPIO38OUTCFG_R(crate::FieldReader<u8, GPIO38OUTCFG_A>);
408impl GPIO38OUTCFG_R {
409 pub(crate) fn new(bits: u8) -> Self {
410 GPIO38OUTCFG_R(crate::FieldReader::new(bits))
411 }
412 #[doc = r"Get enumerated values variant"]
413 #[inline(always)]
414 pub fn variant(&self) -> GPIO38OUTCFG_A {
415 match self.bits {
416 0 => GPIO38OUTCFG_A::DIS,
417 1 => GPIO38OUTCFG_A::PUSHPULL,
418 2 => GPIO38OUTCFG_A::OD,
419 3 => GPIO38OUTCFG_A::TS,
420 _ => unreachable!(),
421 }
422 }
423 #[doc = "Checks if the value of the field is `DIS`"]
424 #[inline(always)]
425 pub fn is_dis(&self) -> bool {
426 **self == GPIO38OUTCFG_A::DIS
427 }
428 #[doc = "Checks if the value of the field is `PUSHPULL`"]
429 #[inline(always)]
430 pub fn is_pushpull(&self) -> bool {
431 **self == GPIO38OUTCFG_A::PUSHPULL
432 }
433 #[doc = "Checks if the value of the field is `OD`"]
434 #[inline(always)]
435 pub fn is_od(&self) -> bool {
436 **self == GPIO38OUTCFG_A::OD
437 }
438 #[doc = "Checks if the value of the field is `TS`"]
439 #[inline(always)]
440 pub fn is_ts(&self) -> bool {
441 **self == GPIO38OUTCFG_A::TS
442 }
443}
444impl core::ops::Deref for GPIO38OUTCFG_R {
445 type Target = crate::FieldReader<u8, GPIO38OUTCFG_A>;
446 #[inline(always)]
447 fn deref(&self) -> &Self::Target {
448 &self.0
449 }
450}
451#[doc = "Field `GPIO38OUTCFG` writer - GPIO38 output configuration."]
452pub struct GPIO38OUTCFG_W<'a> {
453 w: &'a mut W,
454}
455impl<'a> GPIO38OUTCFG_W<'a> {
456 #[doc = r"Writes `variant` to the field"]
457 #[inline(always)]
458 pub fn variant(self, variant: GPIO38OUTCFG_A) -> &'a mut W {
459 self.bits(variant.into())
460 }
461 #[doc = "FNCSEL = 0x3 - Output disabled value."]
462 #[inline(always)]
463 pub fn dis(self) -> &'a mut W {
464 self.variant(GPIO38OUTCFG_A::DIS)
465 }
466 #[doc = "FNCSEL = 0x3 - Output is push-pull value."]
467 #[inline(always)]
468 pub fn pushpull(self) -> &'a mut W {
469 self.variant(GPIO38OUTCFG_A::PUSHPULL)
470 }
471 #[doc = "FNCSEL = 0x3 - Output is open drain value."]
472 #[inline(always)]
473 pub fn od(self) -> &'a mut W {
474 self.variant(GPIO38OUTCFG_A::OD)
475 }
476 #[doc = "FNCSEL = 0x3 - Output is tri-state value."]
477 #[inline(always)]
478 pub fn ts(self) -> &'a mut W {
479 self.variant(GPIO38OUTCFG_A::TS)
480 }
481 #[doc = r"Writes raw bits to the field"]
482 #[inline(always)]
483 pub fn bits(self, value: u8) -> &'a mut W {
484 self.w.bits = (self.w.bits & !(0x03 << 25)) | ((value as u32 & 0x03) << 25);
485 self.w
486 }
487}
488#[doc = "GPIO38 input enable.\n\nValue on reset: 0"]
489#[derive(Clone, Copy, Debug, PartialEq)]
490pub enum GPIO38INCFG_A {
491 #[doc = "0: Read the GPIO pin data value."]
492 READ = 0,
493 #[doc = "1: INTD = 0 - Readback will always be zero value."]
494 RDZERO = 1,
495}
496impl From<GPIO38INCFG_A> for bool {
497 #[inline(always)]
498 fn from(variant: GPIO38INCFG_A) -> Self {
499 variant as u8 != 0
500 }
501}
502#[doc = "Field `GPIO38INCFG` reader - GPIO38 input enable."]
503pub struct GPIO38INCFG_R(crate::FieldReader<bool, GPIO38INCFG_A>);
504impl GPIO38INCFG_R {
505 pub(crate) fn new(bits: bool) -> Self {
506 GPIO38INCFG_R(crate::FieldReader::new(bits))
507 }
508 #[doc = r"Get enumerated values variant"]
509 #[inline(always)]
510 pub fn variant(&self) -> GPIO38INCFG_A {
511 match self.bits {
512 false => GPIO38INCFG_A::READ,
513 true => GPIO38INCFG_A::RDZERO,
514 }
515 }
516 #[doc = "Checks if the value of the field is `READ`"]
517 #[inline(always)]
518 pub fn is_read(&self) -> bool {
519 **self == GPIO38INCFG_A::READ
520 }
521 #[doc = "Checks if the value of the field is `RDZERO`"]
522 #[inline(always)]
523 pub fn is_rdzero(&self) -> bool {
524 **self == GPIO38INCFG_A::RDZERO
525 }
526}
527impl core::ops::Deref for GPIO38INCFG_R {
528 type Target = crate::FieldReader<bool, GPIO38INCFG_A>;
529 #[inline(always)]
530 fn deref(&self) -> &Self::Target {
531 &self.0
532 }
533}
534#[doc = "Field `GPIO38INCFG` writer - GPIO38 input enable."]
535pub struct GPIO38INCFG_W<'a> {
536 w: &'a mut W,
537}
538impl<'a> GPIO38INCFG_W<'a> {
539 #[doc = r"Writes `variant` to the field"]
540 #[inline(always)]
541 pub fn variant(self, variant: GPIO38INCFG_A) -> &'a mut W {
542 self.bit(variant.into())
543 }
544 #[doc = "Read the GPIO pin data value."]
545 #[inline(always)]
546 pub fn read(self) -> &'a mut W {
547 self.variant(GPIO38INCFG_A::READ)
548 }
549 #[doc = "INTD = 0 - Readback will always be zero value."]
550 #[inline(always)]
551 pub fn rdzero(self) -> &'a mut W {
552 self.variant(GPIO38INCFG_A::RDZERO)
553 }
554 #[doc = r"Sets the field bit"]
555 #[inline(always)]
556 pub fn set_bit(self) -> &'a mut W {
557 self.bit(true)
558 }
559 #[doc = r"Clears the field bit"]
560 #[inline(always)]
561 pub fn clear_bit(self) -> &'a mut W {
562 self.bit(false)
563 }
564 #[doc = r"Writes raw bits to the field"]
565 #[inline(always)]
566 pub fn bit(self, value: bool) -> &'a mut W {
567 self.w.bits = (self.w.bits & !(0x01 << 24)) | ((value as u32 & 0x01) << 24);
568 self.w
569 }
570}
571#[doc = "GPIO37 interrupt direction.\n\nValue on reset: 0"]
572#[derive(Clone, Copy, Debug, PartialEq)]
573pub enum GPIO37INTD_A {
574 #[doc = "0: FNCSEL = 0x1 - nCE polarity active low value."]
575 NCELOW = 0,
576 #[doc = "1: FNCSEL = 0x1 - nCE polarity active high value."]
577 NCEHIGH = 1,
578}
579impl From<GPIO37INTD_A> for bool {
580 #[inline(always)]
581 fn from(variant: GPIO37INTD_A) -> Self {
582 variant as u8 != 0
583 }
584}
585#[doc = "Field `GPIO37INTD` reader - GPIO37 interrupt direction."]
586pub struct GPIO37INTD_R(crate::FieldReader<bool, GPIO37INTD_A>);
587impl GPIO37INTD_R {
588 pub(crate) fn new(bits: bool) -> Self {
589 GPIO37INTD_R(crate::FieldReader::new(bits))
590 }
591 #[doc = r"Get enumerated values variant"]
592 #[inline(always)]
593 pub fn variant(&self) -> GPIO37INTD_A {
594 match self.bits {
595 false => GPIO37INTD_A::NCELOW,
596 true => GPIO37INTD_A::NCEHIGH,
597 }
598 }
599 #[doc = "Checks if the value of the field is `NCELOW`"]
600 #[inline(always)]
601 pub fn is_n_celow(&self) -> bool {
602 **self == GPIO37INTD_A::NCELOW
603 }
604 #[doc = "Checks if the value of the field is `NCEHIGH`"]
605 #[inline(always)]
606 pub fn is_n_cehigh(&self) -> bool {
607 **self == GPIO37INTD_A::NCEHIGH
608 }
609}
610impl core::ops::Deref for GPIO37INTD_R {
611 type Target = crate::FieldReader<bool, GPIO37INTD_A>;
612 #[inline(always)]
613 fn deref(&self) -> &Self::Target {
614 &self.0
615 }
616}
617#[doc = "Field `GPIO37INTD` writer - GPIO37 interrupt direction."]
618pub struct GPIO37INTD_W<'a> {
619 w: &'a mut W,
620}
621impl<'a> GPIO37INTD_W<'a> {
622 #[doc = r"Writes `variant` to the field"]
623 #[inline(always)]
624 pub fn variant(self, variant: GPIO37INTD_A) -> &'a mut W {
625 self.bit(variant.into())
626 }
627 #[doc = "FNCSEL = 0x1 - nCE polarity active low value."]
628 #[inline(always)]
629 pub fn n_celow(self) -> &'a mut W {
630 self.variant(GPIO37INTD_A::NCELOW)
631 }
632 #[doc = "FNCSEL = 0x1 - nCE polarity active high value."]
633 #[inline(always)]
634 pub fn n_cehigh(self) -> &'a mut W {
635 self.variant(GPIO37INTD_A::NCEHIGH)
636 }
637 #[doc = r"Sets the field bit"]
638 #[inline(always)]
639 pub fn set_bit(self) -> &'a mut W {
640 self.bit(true)
641 }
642 #[doc = r"Clears the field bit"]
643 #[inline(always)]
644 pub fn clear_bit(self) -> &'a mut W {
645 self.bit(false)
646 }
647 #[doc = r"Writes raw bits to the field"]
648 #[inline(always)]
649 pub fn bit(self, value: bool) -> &'a mut W {
650 self.w.bits = (self.w.bits & !(0x01 << 23)) | ((value as u32 & 0x01) << 23);
651 self.w
652 }
653}
654#[doc = "GPIO37 output configuration.\n\nValue on reset: 0"]
655#[derive(Clone, Copy, Debug, PartialEq)]
656#[repr(u8)]
657pub enum GPIO37OUTCFG_A {
658 #[doc = "0: FNCSEL = 0x3 - Output disabled value."]
659 DIS = 0,
660 #[doc = "1: FNCSEL = 0x3 - Output is push-pull value."]
661 PUSHPULL = 1,
662 #[doc = "2: FNCSEL = 0x3 - Output is open drain value."]
663 OD = 2,
664 #[doc = "3: FNCSEL = 0x3 - Output is tri-state value."]
665 TS = 3,
666}
667impl From<GPIO37OUTCFG_A> for u8 {
668 #[inline(always)]
669 fn from(variant: GPIO37OUTCFG_A) -> Self {
670 variant as _
671 }
672}
673#[doc = "Field `GPIO37OUTCFG` reader - GPIO37 output configuration."]
674pub struct GPIO37OUTCFG_R(crate::FieldReader<u8, GPIO37OUTCFG_A>);
675impl GPIO37OUTCFG_R {
676 pub(crate) fn new(bits: u8) -> Self {
677 GPIO37OUTCFG_R(crate::FieldReader::new(bits))
678 }
679 #[doc = r"Get enumerated values variant"]
680 #[inline(always)]
681 pub fn variant(&self) -> GPIO37OUTCFG_A {
682 match self.bits {
683 0 => GPIO37OUTCFG_A::DIS,
684 1 => GPIO37OUTCFG_A::PUSHPULL,
685 2 => GPIO37OUTCFG_A::OD,
686 3 => GPIO37OUTCFG_A::TS,
687 _ => unreachable!(),
688 }
689 }
690 #[doc = "Checks if the value of the field is `DIS`"]
691 #[inline(always)]
692 pub fn is_dis(&self) -> bool {
693 **self == GPIO37OUTCFG_A::DIS
694 }
695 #[doc = "Checks if the value of the field is `PUSHPULL`"]
696 #[inline(always)]
697 pub fn is_pushpull(&self) -> bool {
698 **self == GPIO37OUTCFG_A::PUSHPULL
699 }
700 #[doc = "Checks if the value of the field is `OD`"]
701 #[inline(always)]
702 pub fn is_od(&self) -> bool {
703 **self == GPIO37OUTCFG_A::OD
704 }
705 #[doc = "Checks if the value of the field is `TS`"]
706 #[inline(always)]
707 pub fn is_ts(&self) -> bool {
708 **self == GPIO37OUTCFG_A::TS
709 }
710}
711impl core::ops::Deref for GPIO37OUTCFG_R {
712 type Target = crate::FieldReader<u8, GPIO37OUTCFG_A>;
713 #[inline(always)]
714 fn deref(&self) -> &Self::Target {
715 &self.0
716 }
717}
718#[doc = "Field `GPIO37OUTCFG` writer - GPIO37 output configuration."]
719pub struct GPIO37OUTCFG_W<'a> {
720 w: &'a mut W,
721}
722impl<'a> GPIO37OUTCFG_W<'a> {
723 #[doc = r"Writes `variant` to the field"]
724 #[inline(always)]
725 pub fn variant(self, variant: GPIO37OUTCFG_A) -> &'a mut W {
726 self.bits(variant.into())
727 }
728 #[doc = "FNCSEL = 0x3 - Output disabled value."]
729 #[inline(always)]
730 pub fn dis(self) -> &'a mut W {
731 self.variant(GPIO37OUTCFG_A::DIS)
732 }
733 #[doc = "FNCSEL = 0x3 - Output is push-pull value."]
734 #[inline(always)]
735 pub fn pushpull(self) -> &'a mut W {
736 self.variant(GPIO37OUTCFG_A::PUSHPULL)
737 }
738 #[doc = "FNCSEL = 0x3 - Output is open drain value."]
739 #[inline(always)]
740 pub fn od(self) -> &'a mut W {
741 self.variant(GPIO37OUTCFG_A::OD)
742 }
743 #[doc = "FNCSEL = 0x3 - Output is tri-state value."]
744 #[inline(always)]
745 pub fn ts(self) -> &'a mut W {
746 self.variant(GPIO37OUTCFG_A::TS)
747 }
748 #[doc = r"Writes raw bits to the field"]
749 #[inline(always)]
750 pub fn bits(self, value: u8) -> &'a mut W {
751 self.w.bits = (self.w.bits & !(0x03 << 21)) | ((value as u32 & 0x03) << 21);
752 self.w
753 }
754}
755#[doc = "GPIO37 input enable.\n\nValue on reset: 0"]
756#[derive(Clone, Copy, Debug, PartialEq)]
757pub enum GPIO37INCFG_A {
758 #[doc = "0: Read the GPIO pin data value."]
759 READ = 0,
760 #[doc = "1: INTD = 0 - Readback will always be zero value."]
761 RDZERO = 1,
762}
763impl From<GPIO37INCFG_A> for bool {
764 #[inline(always)]
765 fn from(variant: GPIO37INCFG_A) -> Self {
766 variant as u8 != 0
767 }
768}
769#[doc = "Field `GPIO37INCFG` reader - GPIO37 input enable."]
770pub struct GPIO37INCFG_R(crate::FieldReader<bool, GPIO37INCFG_A>);
771impl GPIO37INCFG_R {
772 pub(crate) fn new(bits: bool) -> Self {
773 GPIO37INCFG_R(crate::FieldReader::new(bits))
774 }
775 #[doc = r"Get enumerated values variant"]
776 #[inline(always)]
777 pub fn variant(&self) -> GPIO37INCFG_A {
778 match self.bits {
779 false => GPIO37INCFG_A::READ,
780 true => GPIO37INCFG_A::RDZERO,
781 }
782 }
783 #[doc = "Checks if the value of the field is `READ`"]
784 #[inline(always)]
785 pub fn is_read(&self) -> bool {
786 **self == GPIO37INCFG_A::READ
787 }
788 #[doc = "Checks if the value of the field is `RDZERO`"]
789 #[inline(always)]
790 pub fn is_rdzero(&self) -> bool {
791 **self == GPIO37INCFG_A::RDZERO
792 }
793}
794impl core::ops::Deref for GPIO37INCFG_R {
795 type Target = crate::FieldReader<bool, GPIO37INCFG_A>;
796 #[inline(always)]
797 fn deref(&self) -> &Self::Target {
798 &self.0
799 }
800}
801#[doc = "Field `GPIO37INCFG` writer - GPIO37 input enable."]
802pub struct GPIO37INCFG_W<'a> {
803 w: &'a mut W,
804}
805impl<'a> GPIO37INCFG_W<'a> {
806 #[doc = r"Writes `variant` to the field"]
807 #[inline(always)]
808 pub fn variant(self, variant: GPIO37INCFG_A) -> &'a mut W {
809 self.bit(variant.into())
810 }
811 #[doc = "Read the GPIO pin data value."]
812 #[inline(always)]
813 pub fn read(self) -> &'a mut W {
814 self.variant(GPIO37INCFG_A::READ)
815 }
816 #[doc = "INTD = 0 - Readback will always be zero value."]
817 #[inline(always)]
818 pub fn rdzero(self) -> &'a mut W {
819 self.variant(GPIO37INCFG_A::RDZERO)
820 }
821 #[doc = r"Sets the field bit"]
822 #[inline(always)]
823 pub fn set_bit(self) -> &'a mut W {
824 self.bit(true)
825 }
826 #[doc = r"Clears the field bit"]
827 #[inline(always)]
828 pub fn clear_bit(self) -> &'a mut W {
829 self.bit(false)
830 }
831 #[doc = r"Writes raw bits to the field"]
832 #[inline(always)]
833 pub fn bit(self, value: bool) -> &'a mut W {
834 self.w.bits = (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
835 self.w
836 }
837}
838#[doc = "GPIO36 interrupt direction.\n\nValue on reset: 0"]
839#[derive(Clone, Copy, Debug, PartialEq)]
840pub enum GPIO36INTD_A {
841 #[doc = "0: FNCSEL = 0x1 - nCE polarity active low value."]
842 NCELOW = 0,
843 #[doc = "1: FNCSEL = 0x1 - nCE polarity active high value."]
844 NCEHIGH = 1,
845}
846impl From<GPIO36INTD_A> for bool {
847 #[inline(always)]
848 fn from(variant: GPIO36INTD_A) -> Self {
849 variant as u8 != 0
850 }
851}
852#[doc = "Field `GPIO36INTD` reader - GPIO36 interrupt direction."]
853pub struct GPIO36INTD_R(crate::FieldReader<bool, GPIO36INTD_A>);
854impl GPIO36INTD_R {
855 pub(crate) fn new(bits: bool) -> Self {
856 GPIO36INTD_R(crate::FieldReader::new(bits))
857 }
858 #[doc = r"Get enumerated values variant"]
859 #[inline(always)]
860 pub fn variant(&self) -> GPIO36INTD_A {
861 match self.bits {
862 false => GPIO36INTD_A::NCELOW,
863 true => GPIO36INTD_A::NCEHIGH,
864 }
865 }
866 #[doc = "Checks if the value of the field is `NCELOW`"]
867 #[inline(always)]
868 pub fn is_n_celow(&self) -> bool {
869 **self == GPIO36INTD_A::NCELOW
870 }
871 #[doc = "Checks if the value of the field is `NCEHIGH`"]
872 #[inline(always)]
873 pub fn is_n_cehigh(&self) -> bool {
874 **self == GPIO36INTD_A::NCEHIGH
875 }
876}
877impl core::ops::Deref for GPIO36INTD_R {
878 type Target = crate::FieldReader<bool, GPIO36INTD_A>;
879 #[inline(always)]
880 fn deref(&self) -> &Self::Target {
881 &self.0
882 }
883}
884#[doc = "Field `GPIO36INTD` writer - GPIO36 interrupt direction."]
885pub struct GPIO36INTD_W<'a> {
886 w: &'a mut W,
887}
888impl<'a> GPIO36INTD_W<'a> {
889 #[doc = r"Writes `variant` to the field"]
890 #[inline(always)]
891 pub fn variant(self, variant: GPIO36INTD_A) -> &'a mut W {
892 self.bit(variant.into())
893 }
894 #[doc = "FNCSEL = 0x1 - nCE polarity active low value."]
895 #[inline(always)]
896 pub fn n_celow(self) -> &'a mut W {
897 self.variant(GPIO36INTD_A::NCELOW)
898 }
899 #[doc = "FNCSEL = 0x1 - nCE polarity active high value."]
900 #[inline(always)]
901 pub fn n_cehigh(self) -> &'a mut W {
902 self.variant(GPIO36INTD_A::NCEHIGH)
903 }
904 #[doc = r"Sets the field bit"]
905 #[inline(always)]
906 pub fn set_bit(self) -> &'a mut W {
907 self.bit(true)
908 }
909 #[doc = r"Clears the field bit"]
910 #[inline(always)]
911 pub fn clear_bit(self) -> &'a mut W {
912 self.bit(false)
913 }
914 #[doc = r"Writes raw bits to the field"]
915 #[inline(always)]
916 pub fn bit(self, value: bool) -> &'a mut W {
917 self.w.bits = (self.w.bits & !(0x01 << 19)) | ((value as u32 & 0x01) << 19);
918 self.w
919 }
920}
921#[doc = "GPIO36 output configuration.\n\nValue on reset: 0"]
922#[derive(Clone, Copy, Debug, PartialEq)]
923#[repr(u8)]
924pub enum GPIO36OUTCFG_A {
925 #[doc = "0: FNCSEL = 0x3 - Output disabled value."]
926 DIS = 0,
927 #[doc = "1: FNCSEL = 0x3 - Output is push-pull value."]
928 PUSHPULL = 1,
929 #[doc = "2: FNCSEL = 0x3 - Output is open drain value."]
930 OD = 2,
931 #[doc = "3: FNCSEL = 0x3 - Output is tri-state value."]
932 TS = 3,
933}
934impl From<GPIO36OUTCFG_A> for u8 {
935 #[inline(always)]
936 fn from(variant: GPIO36OUTCFG_A) -> Self {
937 variant as _
938 }
939}
940#[doc = "Field `GPIO36OUTCFG` reader - GPIO36 output configuration."]
941pub struct GPIO36OUTCFG_R(crate::FieldReader<u8, GPIO36OUTCFG_A>);
942impl GPIO36OUTCFG_R {
943 pub(crate) fn new(bits: u8) -> Self {
944 GPIO36OUTCFG_R(crate::FieldReader::new(bits))
945 }
946 #[doc = r"Get enumerated values variant"]
947 #[inline(always)]
948 pub fn variant(&self) -> GPIO36OUTCFG_A {
949 match self.bits {
950 0 => GPIO36OUTCFG_A::DIS,
951 1 => GPIO36OUTCFG_A::PUSHPULL,
952 2 => GPIO36OUTCFG_A::OD,
953 3 => GPIO36OUTCFG_A::TS,
954 _ => unreachable!(),
955 }
956 }
957 #[doc = "Checks if the value of the field is `DIS`"]
958 #[inline(always)]
959 pub fn is_dis(&self) -> bool {
960 **self == GPIO36OUTCFG_A::DIS
961 }
962 #[doc = "Checks if the value of the field is `PUSHPULL`"]
963 #[inline(always)]
964 pub fn is_pushpull(&self) -> bool {
965 **self == GPIO36OUTCFG_A::PUSHPULL
966 }
967 #[doc = "Checks if the value of the field is `OD`"]
968 #[inline(always)]
969 pub fn is_od(&self) -> bool {
970 **self == GPIO36OUTCFG_A::OD
971 }
972 #[doc = "Checks if the value of the field is `TS`"]
973 #[inline(always)]
974 pub fn is_ts(&self) -> bool {
975 **self == GPIO36OUTCFG_A::TS
976 }
977}
978impl core::ops::Deref for GPIO36OUTCFG_R {
979 type Target = crate::FieldReader<u8, GPIO36OUTCFG_A>;
980 #[inline(always)]
981 fn deref(&self) -> &Self::Target {
982 &self.0
983 }
984}
985#[doc = "Field `GPIO36OUTCFG` writer - GPIO36 output configuration."]
986pub struct GPIO36OUTCFG_W<'a> {
987 w: &'a mut W,
988}
989impl<'a> GPIO36OUTCFG_W<'a> {
990 #[doc = r"Writes `variant` to the field"]
991 #[inline(always)]
992 pub fn variant(self, variant: GPIO36OUTCFG_A) -> &'a mut W {
993 self.bits(variant.into())
994 }
995 #[doc = "FNCSEL = 0x3 - Output disabled value."]
996 #[inline(always)]
997 pub fn dis(self) -> &'a mut W {
998 self.variant(GPIO36OUTCFG_A::DIS)
999 }
1000 #[doc = "FNCSEL = 0x3 - Output is push-pull value."]
1001 #[inline(always)]
1002 pub fn pushpull(self) -> &'a mut W {
1003 self.variant(GPIO36OUTCFG_A::PUSHPULL)
1004 }
1005 #[doc = "FNCSEL = 0x3 - Output is open drain value."]
1006 #[inline(always)]
1007 pub fn od(self) -> &'a mut W {
1008 self.variant(GPIO36OUTCFG_A::OD)
1009 }
1010 #[doc = "FNCSEL = 0x3 - Output is tri-state value."]
1011 #[inline(always)]
1012 pub fn ts(self) -> &'a mut W {
1013 self.variant(GPIO36OUTCFG_A::TS)
1014 }
1015 #[doc = r"Writes raw bits to the field"]
1016 #[inline(always)]
1017 pub fn bits(self, value: u8) -> &'a mut W {
1018 self.w.bits = (self.w.bits & !(0x03 << 17)) | ((value as u32 & 0x03) << 17);
1019 self.w
1020 }
1021}
1022#[doc = "GPIO36 input enable.\n\nValue on reset: 0"]
1023#[derive(Clone, Copy, Debug, PartialEq)]
1024pub enum GPIO36INCFG_A {
1025 #[doc = "0: Read the GPIO pin data value."]
1026 READ = 0,
1027 #[doc = "1: INTD = 0 - Readback will always be zero value."]
1028 RDZERO = 1,
1029}
1030impl From<GPIO36INCFG_A> for bool {
1031 #[inline(always)]
1032 fn from(variant: GPIO36INCFG_A) -> Self {
1033 variant as u8 != 0
1034 }
1035}
1036#[doc = "Field `GPIO36INCFG` reader - GPIO36 input enable."]
1037pub struct GPIO36INCFG_R(crate::FieldReader<bool, GPIO36INCFG_A>);
1038impl GPIO36INCFG_R {
1039 pub(crate) fn new(bits: bool) -> Self {
1040 GPIO36INCFG_R(crate::FieldReader::new(bits))
1041 }
1042 #[doc = r"Get enumerated values variant"]
1043 #[inline(always)]
1044 pub fn variant(&self) -> GPIO36INCFG_A {
1045 match self.bits {
1046 false => GPIO36INCFG_A::READ,
1047 true => GPIO36INCFG_A::RDZERO,
1048 }
1049 }
1050 #[doc = "Checks if the value of the field is `READ`"]
1051 #[inline(always)]
1052 pub fn is_read(&self) -> bool {
1053 **self == GPIO36INCFG_A::READ
1054 }
1055 #[doc = "Checks if the value of the field is `RDZERO`"]
1056 #[inline(always)]
1057 pub fn is_rdzero(&self) -> bool {
1058 **self == GPIO36INCFG_A::RDZERO
1059 }
1060}
1061impl core::ops::Deref for GPIO36INCFG_R {
1062 type Target = crate::FieldReader<bool, GPIO36INCFG_A>;
1063 #[inline(always)]
1064 fn deref(&self) -> &Self::Target {
1065 &self.0
1066 }
1067}
1068#[doc = "Field `GPIO36INCFG` writer - GPIO36 input enable."]
1069pub struct GPIO36INCFG_W<'a> {
1070 w: &'a mut W,
1071}
1072impl<'a> GPIO36INCFG_W<'a> {
1073 #[doc = r"Writes `variant` to the field"]
1074 #[inline(always)]
1075 pub fn variant(self, variant: GPIO36INCFG_A) -> &'a mut W {
1076 self.bit(variant.into())
1077 }
1078 #[doc = "Read the GPIO pin data value."]
1079 #[inline(always)]
1080 pub fn read(self) -> &'a mut W {
1081 self.variant(GPIO36INCFG_A::READ)
1082 }
1083 #[doc = "INTD = 0 - Readback will always be zero value."]
1084 #[inline(always)]
1085 pub fn rdzero(self) -> &'a mut W {
1086 self.variant(GPIO36INCFG_A::RDZERO)
1087 }
1088 #[doc = r"Sets the field bit"]
1089 #[inline(always)]
1090 pub fn set_bit(self) -> &'a mut W {
1091 self.bit(true)
1092 }
1093 #[doc = r"Clears the field bit"]
1094 #[inline(always)]
1095 pub fn clear_bit(self) -> &'a mut W {
1096 self.bit(false)
1097 }
1098 #[doc = r"Writes raw bits to the field"]
1099 #[inline(always)]
1100 pub fn bit(self, value: bool) -> &'a mut W {
1101 self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
1102 self.w
1103 }
1104}
1105#[doc = "GPIO35 interrupt direction.\n\nValue on reset: 0"]
1106#[derive(Clone, Copy, Debug, PartialEq)]
1107pub enum GPIO35INTD_A {
1108 #[doc = "0: FNCSEL = 0x1 - nCE polarity active low value."]
1109 NCELOW = 0,
1110 #[doc = "1: FNCSEL = 0x1 - nCE polarity active high value."]
1111 NCEHIGH = 1,
1112}
1113impl From<GPIO35INTD_A> for bool {
1114 #[inline(always)]
1115 fn from(variant: GPIO35INTD_A) -> Self {
1116 variant as u8 != 0
1117 }
1118}
1119#[doc = "Field `GPIO35INTD` reader - GPIO35 interrupt direction."]
1120pub struct GPIO35INTD_R(crate::FieldReader<bool, GPIO35INTD_A>);
1121impl GPIO35INTD_R {
1122 pub(crate) fn new(bits: bool) -> Self {
1123 GPIO35INTD_R(crate::FieldReader::new(bits))
1124 }
1125 #[doc = r"Get enumerated values variant"]
1126 #[inline(always)]
1127 pub fn variant(&self) -> GPIO35INTD_A {
1128 match self.bits {
1129 false => GPIO35INTD_A::NCELOW,
1130 true => GPIO35INTD_A::NCEHIGH,
1131 }
1132 }
1133 #[doc = "Checks if the value of the field is `NCELOW`"]
1134 #[inline(always)]
1135 pub fn is_n_celow(&self) -> bool {
1136 **self == GPIO35INTD_A::NCELOW
1137 }
1138 #[doc = "Checks if the value of the field is `NCEHIGH`"]
1139 #[inline(always)]
1140 pub fn is_n_cehigh(&self) -> bool {
1141 **self == GPIO35INTD_A::NCEHIGH
1142 }
1143}
1144impl core::ops::Deref for GPIO35INTD_R {
1145 type Target = crate::FieldReader<bool, GPIO35INTD_A>;
1146 #[inline(always)]
1147 fn deref(&self) -> &Self::Target {
1148 &self.0
1149 }
1150}
1151#[doc = "Field `GPIO35INTD` writer - GPIO35 interrupt direction."]
1152pub struct GPIO35INTD_W<'a> {
1153 w: &'a mut W,
1154}
1155impl<'a> GPIO35INTD_W<'a> {
1156 #[doc = r"Writes `variant` to the field"]
1157 #[inline(always)]
1158 pub fn variant(self, variant: GPIO35INTD_A) -> &'a mut W {
1159 self.bit(variant.into())
1160 }
1161 #[doc = "FNCSEL = 0x1 - nCE polarity active low value."]
1162 #[inline(always)]
1163 pub fn n_celow(self) -> &'a mut W {
1164 self.variant(GPIO35INTD_A::NCELOW)
1165 }
1166 #[doc = "FNCSEL = 0x1 - nCE polarity active high value."]
1167 #[inline(always)]
1168 pub fn n_cehigh(self) -> &'a mut W {
1169 self.variant(GPIO35INTD_A::NCEHIGH)
1170 }
1171 #[doc = r"Sets the field bit"]
1172 #[inline(always)]
1173 pub fn set_bit(self) -> &'a mut W {
1174 self.bit(true)
1175 }
1176 #[doc = r"Clears the field bit"]
1177 #[inline(always)]
1178 pub fn clear_bit(self) -> &'a mut W {
1179 self.bit(false)
1180 }
1181 #[doc = r"Writes raw bits to the field"]
1182 #[inline(always)]
1183 pub fn bit(self, value: bool) -> &'a mut W {
1184 self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
1185 self.w
1186 }
1187}
1188#[doc = "GPIO35 output configuration.\n\nValue on reset: 0"]
1189#[derive(Clone, Copy, Debug, PartialEq)]
1190#[repr(u8)]
1191pub enum GPIO35OUTCFG_A {
1192 #[doc = "0: FNCSEL = 0x3 - Output disabled value."]
1193 DIS = 0,
1194 #[doc = "1: FNCSEL = 0x3 - Output is push-pull value."]
1195 PUSHPULL = 1,
1196 #[doc = "2: FNCSEL = 0x3 - Output is open drain value."]
1197 OD = 2,
1198 #[doc = "3: FNCSEL = 0x3 - Output is tri-state value."]
1199 TS = 3,
1200}
1201impl From<GPIO35OUTCFG_A> for u8 {
1202 #[inline(always)]
1203 fn from(variant: GPIO35OUTCFG_A) -> Self {
1204 variant as _
1205 }
1206}
1207#[doc = "Field `GPIO35OUTCFG` reader - GPIO35 output configuration."]
1208pub struct GPIO35OUTCFG_R(crate::FieldReader<u8, GPIO35OUTCFG_A>);
1209impl GPIO35OUTCFG_R {
1210 pub(crate) fn new(bits: u8) -> Self {
1211 GPIO35OUTCFG_R(crate::FieldReader::new(bits))
1212 }
1213 #[doc = r"Get enumerated values variant"]
1214 #[inline(always)]
1215 pub fn variant(&self) -> GPIO35OUTCFG_A {
1216 match self.bits {
1217 0 => GPIO35OUTCFG_A::DIS,
1218 1 => GPIO35OUTCFG_A::PUSHPULL,
1219 2 => GPIO35OUTCFG_A::OD,
1220 3 => GPIO35OUTCFG_A::TS,
1221 _ => unreachable!(),
1222 }
1223 }
1224 #[doc = "Checks if the value of the field is `DIS`"]
1225 #[inline(always)]
1226 pub fn is_dis(&self) -> bool {
1227 **self == GPIO35OUTCFG_A::DIS
1228 }
1229 #[doc = "Checks if the value of the field is `PUSHPULL`"]
1230 #[inline(always)]
1231 pub fn is_pushpull(&self) -> bool {
1232 **self == GPIO35OUTCFG_A::PUSHPULL
1233 }
1234 #[doc = "Checks if the value of the field is `OD`"]
1235 #[inline(always)]
1236 pub fn is_od(&self) -> bool {
1237 **self == GPIO35OUTCFG_A::OD
1238 }
1239 #[doc = "Checks if the value of the field is `TS`"]
1240 #[inline(always)]
1241 pub fn is_ts(&self) -> bool {
1242 **self == GPIO35OUTCFG_A::TS
1243 }
1244}
1245impl core::ops::Deref for GPIO35OUTCFG_R {
1246 type Target = crate::FieldReader<u8, GPIO35OUTCFG_A>;
1247 #[inline(always)]
1248 fn deref(&self) -> &Self::Target {
1249 &self.0
1250 }
1251}
1252#[doc = "Field `GPIO35OUTCFG` writer - GPIO35 output configuration."]
1253pub struct GPIO35OUTCFG_W<'a> {
1254 w: &'a mut W,
1255}
1256impl<'a> GPIO35OUTCFG_W<'a> {
1257 #[doc = r"Writes `variant` to the field"]
1258 #[inline(always)]
1259 pub fn variant(self, variant: GPIO35OUTCFG_A) -> &'a mut W {
1260 self.bits(variant.into())
1261 }
1262 #[doc = "FNCSEL = 0x3 - Output disabled value."]
1263 #[inline(always)]
1264 pub fn dis(self) -> &'a mut W {
1265 self.variant(GPIO35OUTCFG_A::DIS)
1266 }
1267 #[doc = "FNCSEL = 0x3 - Output is push-pull value."]
1268 #[inline(always)]
1269 pub fn pushpull(self) -> &'a mut W {
1270 self.variant(GPIO35OUTCFG_A::PUSHPULL)
1271 }
1272 #[doc = "FNCSEL = 0x3 - Output is open drain value."]
1273 #[inline(always)]
1274 pub fn od(self) -> &'a mut W {
1275 self.variant(GPIO35OUTCFG_A::OD)
1276 }
1277 #[doc = "FNCSEL = 0x3 - Output is tri-state value."]
1278 #[inline(always)]
1279 pub fn ts(self) -> &'a mut W {
1280 self.variant(GPIO35OUTCFG_A::TS)
1281 }
1282 #[doc = r"Writes raw bits to the field"]
1283 #[inline(always)]
1284 pub fn bits(self, value: u8) -> &'a mut W {
1285 self.w.bits = (self.w.bits & !(0x03 << 13)) | ((value as u32 & 0x03) << 13);
1286 self.w
1287 }
1288}
1289#[doc = "GPIO35 input enable.\n\nValue on reset: 0"]
1290#[derive(Clone, Copy, Debug, PartialEq)]
1291pub enum GPIO35INCFG_A {
1292 #[doc = "0: Read the GPIO pin data value."]
1293 READ = 0,
1294 #[doc = "1: INTD = 0 - Readback will always be zero value."]
1295 RDZERO = 1,
1296}
1297impl From<GPIO35INCFG_A> for bool {
1298 #[inline(always)]
1299 fn from(variant: GPIO35INCFG_A) -> Self {
1300 variant as u8 != 0
1301 }
1302}
1303#[doc = "Field `GPIO35INCFG` reader - GPIO35 input enable."]
1304pub struct GPIO35INCFG_R(crate::FieldReader<bool, GPIO35INCFG_A>);
1305impl GPIO35INCFG_R {
1306 pub(crate) fn new(bits: bool) -> Self {
1307 GPIO35INCFG_R(crate::FieldReader::new(bits))
1308 }
1309 #[doc = r"Get enumerated values variant"]
1310 #[inline(always)]
1311 pub fn variant(&self) -> GPIO35INCFG_A {
1312 match self.bits {
1313 false => GPIO35INCFG_A::READ,
1314 true => GPIO35INCFG_A::RDZERO,
1315 }
1316 }
1317 #[doc = "Checks if the value of the field is `READ`"]
1318 #[inline(always)]
1319 pub fn is_read(&self) -> bool {
1320 **self == GPIO35INCFG_A::READ
1321 }
1322 #[doc = "Checks if the value of the field is `RDZERO`"]
1323 #[inline(always)]
1324 pub fn is_rdzero(&self) -> bool {
1325 **self == GPIO35INCFG_A::RDZERO
1326 }
1327}
1328impl core::ops::Deref for GPIO35INCFG_R {
1329 type Target = crate::FieldReader<bool, GPIO35INCFG_A>;
1330 #[inline(always)]
1331 fn deref(&self) -> &Self::Target {
1332 &self.0
1333 }
1334}
1335#[doc = "Field `GPIO35INCFG` writer - GPIO35 input enable."]
1336pub struct GPIO35INCFG_W<'a> {
1337 w: &'a mut W,
1338}
1339impl<'a> GPIO35INCFG_W<'a> {
1340 #[doc = r"Writes `variant` to the field"]
1341 #[inline(always)]
1342 pub fn variant(self, variant: GPIO35INCFG_A) -> &'a mut W {
1343 self.bit(variant.into())
1344 }
1345 #[doc = "Read the GPIO pin data value."]
1346 #[inline(always)]
1347 pub fn read(self) -> &'a mut W {
1348 self.variant(GPIO35INCFG_A::READ)
1349 }
1350 #[doc = "INTD = 0 - Readback will always be zero value."]
1351 #[inline(always)]
1352 pub fn rdzero(self) -> &'a mut W {
1353 self.variant(GPIO35INCFG_A::RDZERO)
1354 }
1355 #[doc = r"Sets the field bit"]
1356 #[inline(always)]
1357 pub fn set_bit(self) -> &'a mut W {
1358 self.bit(true)
1359 }
1360 #[doc = r"Clears the field bit"]
1361 #[inline(always)]
1362 pub fn clear_bit(self) -> &'a mut W {
1363 self.bit(false)
1364 }
1365 #[doc = r"Writes raw bits to the field"]
1366 #[inline(always)]
1367 pub fn bit(self, value: bool) -> &'a mut W {
1368 self.w.bits = (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
1369 self.w
1370 }
1371}
1372#[doc = "GPIO34 interrupt direction.\n\nValue on reset: 0"]
1373#[derive(Clone, Copy, Debug, PartialEq)]
1374pub enum GPIO34INTD_A {
1375 #[doc = "0: FNCSEL = 0x1 - nCE polarity active low value."]
1376 NCELOW = 0,
1377 #[doc = "1: FNCSEL = 0x1 - nCE polarity active high value."]
1378 NCEHIGH = 1,
1379}
1380impl From<GPIO34INTD_A> for bool {
1381 #[inline(always)]
1382 fn from(variant: GPIO34INTD_A) -> Self {
1383 variant as u8 != 0
1384 }
1385}
1386#[doc = "Field `GPIO34INTD` reader - GPIO34 interrupt direction."]
1387pub struct GPIO34INTD_R(crate::FieldReader<bool, GPIO34INTD_A>);
1388impl GPIO34INTD_R {
1389 pub(crate) fn new(bits: bool) -> Self {
1390 GPIO34INTD_R(crate::FieldReader::new(bits))
1391 }
1392 #[doc = r"Get enumerated values variant"]
1393 #[inline(always)]
1394 pub fn variant(&self) -> GPIO34INTD_A {
1395 match self.bits {
1396 false => GPIO34INTD_A::NCELOW,
1397 true => GPIO34INTD_A::NCEHIGH,
1398 }
1399 }
1400 #[doc = "Checks if the value of the field is `NCELOW`"]
1401 #[inline(always)]
1402 pub fn is_n_celow(&self) -> bool {
1403 **self == GPIO34INTD_A::NCELOW
1404 }
1405 #[doc = "Checks if the value of the field is `NCEHIGH`"]
1406 #[inline(always)]
1407 pub fn is_n_cehigh(&self) -> bool {
1408 **self == GPIO34INTD_A::NCEHIGH
1409 }
1410}
1411impl core::ops::Deref for GPIO34INTD_R {
1412 type Target = crate::FieldReader<bool, GPIO34INTD_A>;
1413 #[inline(always)]
1414 fn deref(&self) -> &Self::Target {
1415 &self.0
1416 }
1417}
1418#[doc = "Field `GPIO34INTD` writer - GPIO34 interrupt direction."]
1419pub struct GPIO34INTD_W<'a> {
1420 w: &'a mut W,
1421}
1422impl<'a> GPIO34INTD_W<'a> {
1423 #[doc = r"Writes `variant` to the field"]
1424 #[inline(always)]
1425 pub fn variant(self, variant: GPIO34INTD_A) -> &'a mut W {
1426 self.bit(variant.into())
1427 }
1428 #[doc = "FNCSEL = 0x1 - nCE polarity active low value."]
1429 #[inline(always)]
1430 pub fn n_celow(self) -> &'a mut W {
1431 self.variant(GPIO34INTD_A::NCELOW)
1432 }
1433 #[doc = "FNCSEL = 0x1 - nCE polarity active high value."]
1434 #[inline(always)]
1435 pub fn n_cehigh(self) -> &'a mut W {
1436 self.variant(GPIO34INTD_A::NCEHIGH)
1437 }
1438 #[doc = r"Sets the field bit"]
1439 #[inline(always)]
1440 pub fn set_bit(self) -> &'a mut W {
1441 self.bit(true)
1442 }
1443 #[doc = r"Clears the field bit"]
1444 #[inline(always)]
1445 pub fn clear_bit(self) -> &'a mut W {
1446 self.bit(false)
1447 }
1448 #[doc = r"Writes raw bits to the field"]
1449 #[inline(always)]
1450 pub fn bit(self, value: bool) -> &'a mut W {
1451 self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
1452 self.w
1453 }
1454}
1455#[doc = "GPIO34 output configuration.\n\nValue on reset: 0"]
1456#[derive(Clone, Copy, Debug, PartialEq)]
1457#[repr(u8)]
1458pub enum GPIO34OUTCFG_A {
1459 #[doc = "0: FNCSEL = 0x3 - Output disabled value."]
1460 DIS = 0,
1461 #[doc = "1: FNCSEL = 0x3 - Output is push-pull value."]
1462 PUSHPULL = 1,
1463 #[doc = "2: FNCSEL = 0x3 - Output is open drain value."]
1464 OD = 2,
1465 #[doc = "3: FNCSEL = 0x3 - Output is tri-state value."]
1466 TS = 3,
1467}
1468impl From<GPIO34OUTCFG_A> for u8 {
1469 #[inline(always)]
1470 fn from(variant: GPIO34OUTCFG_A) -> Self {
1471 variant as _
1472 }
1473}
1474#[doc = "Field `GPIO34OUTCFG` reader - GPIO34 output configuration."]
1475pub struct GPIO34OUTCFG_R(crate::FieldReader<u8, GPIO34OUTCFG_A>);
1476impl GPIO34OUTCFG_R {
1477 pub(crate) fn new(bits: u8) -> Self {
1478 GPIO34OUTCFG_R(crate::FieldReader::new(bits))
1479 }
1480 #[doc = r"Get enumerated values variant"]
1481 #[inline(always)]
1482 pub fn variant(&self) -> GPIO34OUTCFG_A {
1483 match self.bits {
1484 0 => GPIO34OUTCFG_A::DIS,
1485 1 => GPIO34OUTCFG_A::PUSHPULL,
1486 2 => GPIO34OUTCFG_A::OD,
1487 3 => GPIO34OUTCFG_A::TS,
1488 _ => unreachable!(),
1489 }
1490 }
1491 #[doc = "Checks if the value of the field is `DIS`"]
1492 #[inline(always)]
1493 pub fn is_dis(&self) -> bool {
1494 **self == GPIO34OUTCFG_A::DIS
1495 }
1496 #[doc = "Checks if the value of the field is `PUSHPULL`"]
1497 #[inline(always)]
1498 pub fn is_pushpull(&self) -> bool {
1499 **self == GPIO34OUTCFG_A::PUSHPULL
1500 }
1501 #[doc = "Checks if the value of the field is `OD`"]
1502 #[inline(always)]
1503 pub fn is_od(&self) -> bool {
1504 **self == GPIO34OUTCFG_A::OD
1505 }
1506 #[doc = "Checks if the value of the field is `TS`"]
1507 #[inline(always)]
1508 pub fn is_ts(&self) -> bool {
1509 **self == GPIO34OUTCFG_A::TS
1510 }
1511}
1512impl core::ops::Deref for GPIO34OUTCFG_R {
1513 type Target = crate::FieldReader<u8, GPIO34OUTCFG_A>;
1514 #[inline(always)]
1515 fn deref(&self) -> &Self::Target {
1516 &self.0
1517 }
1518}
1519#[doc = "Field `GPIO34OUTCFG` writer - GPIO34 output configuration."]
1520pub struct GPIO34OUTCFG_W<'a> {
1521 w: &'a mut W,
1522}
1523impl<'a> GPIO34OUTCFG_W<'a> {
1524 #[doc = r"Writes `variant` to the field"]
1525 #[inline(always)]
1526 pub fn variant(self, variant: GPIO34OUTCFG_A) -> &'a mut W {
1527 self.bits(variant.into())
1528 }
1529 #[doc = "FNCSEL = 0x3 - Output disabled value."]
1530 #[inline(always)]
1531 pub fn dis(self) -> &'a mut W {
1532 self.variant(GPIO34OUTCFG_A::DIS)
1533 }
1534 #[doc = "FNCSEL = 0x3 - Output is push-pull value."]
1535 #[inline(always)]
1536 pub fn pushpull(self) -> &'a mut W {
1537 self.variant(GPIO34OUTCFG_A::PUSHPULL)
1538 }
1539 #[doc = "FNCSEL = 0x3 - Output is open drain value."]
1540 #[inline(always)]
1541 pub fn od(self) -> &'a mut W {
1542 self.variant(GPIO34OUTCFG_A::OD)
1543 }
1544 #[doc = "FNCSEL = 0x3 - Output is tri-state value."]
1545 #[inline(always)]
1546 pub fn ts(self) -> &'a mut W {
1547 self.variant(GPIO34OUTCFG_A::TS)
1548 }
1549 #[doc = r"Writes raw bits to the field"]
1550 #[inline(always)]
1551 pub fn bits(self, value: u8) -> &'a mut W {
1552 self.w.bits = (self.w.bits & !(0x03 << 9)) | ((value as u32 & 0x03) << 9);
1553 self.w
1554 }
1555}
1556#[doc = "GPIO34 input enable.\n\nValue on reset: 0"]
1557#[derive(Clone, Copy, Debug, PartialEq)]
1558pub enum GPIO34INCFG_A {
1559 #[doc = "0: Read the GPIO pin data value."]
1560 READ = 0,
1561 #[doc = "1: INTD = 0 - Readback will always be zero value."]
1562 RDZERO = 1,
1563}
1564impl From<GPIO34INCFG_A> for bool {
1565 #[inline(always)]
1566 fn from(variant: GPIO34INCFG_A) -> Self {
1567 variant as u8 != 0
1568 }
1569}
1570#[doc = "Field `GPIO34INCFG` reader - GPIO34 input enable."]
1571pub struct GPIO34INCFG_R(crate::FieldReader<bool, GPIO34INCFG_A>);
1572impl GPIO34INCFG_R {
1573 pub(crate) fn new(bits: bool) -> Self {
1574 GPIO34INCFG_R(crate::FieldReader::new(bits))
1575 }
1576 #[doc = r"Get enumerated values variant"]
1577 #[inline(always)]
1578 pub fn variant(&self) -> GPIO34INCFG_A {
1579 match self.bits {
1580 false => GPIO34INCFG_A::READ,
1581 true => GPIO34INCFG_A::RDZERO,
1582 }
1583 }
1584 #[doc = "Checks if the value of the field is `READ`"]
1585 #[inline(always)]
1586 pub fn is_read(&self) -> bool {
1587 **self == GPIO34INCFG_A::READ
1588 }
1589 #[doc = "Checks if the value of the field is `RDZERO`"]
1590 #[inline(always)]
1591 pub fn is_rdzero(&self) -> bool {
1592 **self == GPIO34INCFG_A::RDZERO
1593 }
1594}
1595impl core::ops::Deref for GPIO34INCFG_R {
1596 type Target = crate::FieldReader<bool, GPIO34INCFG_A>;
1597 #[inline(always)]
1598 fn deref(&self) -> &Self::Target {
1599 &self.0
1600 }
1601}
1602#[doc = "Field `GPIO34INCFG` writer - GPIO34 input enable."]
1603pub struct GPIO34INCFG_W<'a> {
1604 w: &'a mut W,
1605}
1606impl<'a> GPIO34INCFG_W<'a> {
1607 #[doc = r"Writes `variant` to the field"]
1608 #[inline(always)]
1609 pub fn variant(self, variant: GPIO34INCFG_A) -> &'a mut W {
1610 self.bit(variant.into())
1611 }
1612 #[doc = "Read the GPIO pin data value."]
1613 #[inline(always)]
1614 pub fn read(self) -> &'a mut W {
1615 self.variant(GPIO34INCFG_A::READ)
1616 }
1617 #[doc = "INTD = 0 - Readback will always be zero value."]
1618 #[inline(always)]
1619 pub fn rdzero(self) -> &'a mut W {
1620 self.variant(GPIO34INCFG_A::RDZERO)
1621 }
1622 #[doc = r"Sets the field bit"]
1623 #[inline(always)]
1624 pub fn set_bit(self) -> &'a mut W {
1625 self.bit(true)
1626 }
1627 #[doc = r"Clears the field bit"]
1628 #[inline(always)]
1629 pub fn clear_bit(self) -> &'a mut W {
1630 self.bit(false)
1631 }
1632 #[doc = r"Writes raw bits to the field"]
1633 #[inline(always)]
1634 pub fn bit(self, value: bool) -> &'a mut W {
1635 self.w.bits = (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
1636 self.w
1637 }
1638}
1639#[doc = "GPIO33 interrupt direction.\n\nValue on reset: 0"]
1640#[derive(Clone, Copy, Debug, PartialEq)]
1641pub enum GPIO33INTD_A {
1642 #[doc = "0: FNCSEL = 0x1 - nCE polarity active low value."]
1643 NCELOW = 0,
1644 #[doc = "1: FNCSEL = 0x1 - nCE polarity active high value."]
1645 NCEHIGH = 1,
1646}
1647impl From<GPIO33INTD_A> for bool {
1648 #[inline(always)]
1649 fn from(variant: GPIO33INTD_A) -> Self {
1650 variant as u8 != 0
1651 }
1652}
1653#[doc = "Field `GPIO33INTD` reader - GPIO33 interrupt direction."]
1654pub struct GPIO33INTD_R(crate::FieldReader<bool, GPIO33INTD_A>);
1655impl GPIO33INTD_R {
1656 pub(crate) fn new(bits: bool) -> Self {
1657 GPIO33INTD_R(crate::FieldReader::new(bits))
1658 }
1659 #[doc = r"Get enumerated values variant"]
1660 #[inline(always)]
1661 pub fn variant(&self) -> GPIO33INTD_A {
1662 match self.bits {
1663 false => GPIO33INTD_A::NCELOW,
1664 true => GPIO33INTD_A::NCEHIGH,
1665 }
1666 }
1667 #[doc = "Checks if the value of the field is `NCELOW`"]
1668 #[inline(always)]
1669 pub fn is_n_celow(&self) -> bool {
1670 **self == GPIO33INTD_A::NCELOW
1671 }
1672 #[doc = "Checks if the value of the field is `NCEHIGH`"]
1673 #[inline(always)]
1674 pub fn is_n_cehigh(&self) -> bool {
1675 **self == GPIO33INTD_A::NCEHIGH
1676 }
1677}
1678impl core::ops::Deref for GPIO33INTD_R {
1679 type Target = crate::FieldReader<bool, GPIO33INTD_A>;
1680 #[inline(always)]
1681 fn deref(&self) -> &Self::Target {
1682 &self.0
1683 }
1684}
1685#[doc = "Field `GPIO33INTD` writer - GPIO33 interrupt direction."]
1686pub struct GPIO33INTD_W<'a> {
1687 w: &'a mut W,
1688}
1689impl<'a> GPIO33INTD_W<'a> {
1690 #[doc = r"Writes `variant` to the field"]
1691 #[inline(always)]
1692 pub fn variant(self, variant: GPIO33INTD_A) -> &'a mut W {
1693 self.bit(variant.into())
1694 }
1695 #[doc = "FNCSEL = 0x1 - nCE polarity active low value."]
1696 #[inline(always)]
1697 pub fn n_celow(self) -> &'a mut W {
1698 self.variant(GPIO33INTD_A::NCELOW)
1699 }
1700 #[doc = "FNCSEL = 0x1 - nCE polarity active high value."]
1701 #[inline(always)]
1702 pub fn n_cehigh(self) -> &'a mut W {
1703 self.variant(GPIO33INTD_A::NCEHIGH)
1704 }
1705 #[doc = r"Sets the field bit"]
1706 #[inline(always)]
1707 pub fn set_bit(self) -> &'a mut W {
1708 self.bit(true)
1709 }
1710 #[doc = r"Clears the field bit"]
1711 #[inline(always)]
1712 pub fn clear_bit(self) -> &'a mut W {
1713 self.bit(false)
1714 }
1715 #[doc = r"Writes raw bits to the field"]
1716 #[inline(always)]
1717 pub fn bit(self, value: bool) -> &'a mut W {
1718 self.w.bits = (self.w.bits & !(0x01 << 7)) | ((value as u32 & 0x01) << 7);
1719 self.w
1720 }
1721}
1722#[doc = "GPIO33 output configuration.\n\nValue on reset: 0"]
1723#[derive(Clone, Copy, Debug, PartialEq)]
1724#[repr(u8)]
1725pub enum GPIO33OUTCFG_A {
1726 #[doc = "0: FNCSEL = 0x3 - Output disabled value."]
1727 DIS = 0,
1728 #[doc = "1: FNCSEL = 0x3 - Output is push-pull value."]
1729 PUSHPULL = 1,
1730 #[doc = "2: FNCSEL = 0x3 - Output is open drain value."]
1731 OD = 2,
1732 #[doc = "3: FNCSEL = 0x3 - Output is tri-state value."]
1733 TS = 3,
1734}
1735impl From<GPIO33OUTCFG_A> for u8 {
1736 #[inline(always)]
1737 fn from(variant: GPIO33OUTCFG_A) -> Self {
1738 variant as _
1739 }
1740}
1741#[doc = "Field `GPIO33OUTCFG` reader - GPIO33 output configuration."]
1742pub struct GPIO33OUTCFG_R(crate::FieldReader<u8, GPIO33OUTCFG_A>);
1743impl GPIO33OUTCFG_R {
1744 pub(crate) fn new(bits: u8) -> Self {
1745 GPIO33OUTCFG_R(crate::FieldReader::new(bits))
1746 }
1747 #[doc = r"Get enumerated values variant"]
1748 #[inline(always)]
1749 pub fn variant(&self) -> GPIO33OUTCFG_A {
1750 match self.bits {
1751 0 => GPIO33OUTCFG_A::DIS,
1752 1 => GPIO33OUTCFG_A::PUSHPULL,
1753 2 => GPIO33OUTCFG_A::OD,
1754 3 => GPIO33OUTCFG_A::TS,
1755 _ => unreachable!(),
1756 }
1757 }
1758 #[doc = "Checks if the value of the field is `DIS`"]
1759 #[inline(always)]
1760 pub fn is_dis(&self) -> bool {
1761 **self == GPIO33OUTCFG_A::DIS
1762 }
1763 #[doc = "Checks if the value of the field is `PUSHPULL`"]
1764 #[inline(always)]
1765 pub fn is_pushpull(&self) -> bool {
1766 **self == GPIO33OUTCFG_A::PUSHPULL
1767 }
1768 #[doc = "Checks if the value of the field is `OD`"]
1769 #[inline(always)]
1770 pub fn is_od(&self) -> bool {
1771 **self == GPIO33OUTCFG_A::OD
1772 }
1773 #[doc = "Checks if the value of the field is `TS`"]
1774 #[inline(always)]
1775 pub fn is_ts(&self) -> bool {
1776 **self == GPIO33OUTCFG_A::TS
1777 }
1778}
1779impl core::ops::Deref for GPIO33OUTCFG_R {
1780 type Target = crate::FieldReader<u8, GPIO33OUTCFG_A>;
1781 #[inline(always)]
1782 fn deref(&self) -> &Self::Target {
1783 &self.0
1784 }
1785}
1786#[doc = "Field `GPIO33OUTCFG` writer - GPIO33 output configuration."]
1787pub struct GPIO33OUTCFG_W<'a> {
1788 w: &'a mut W,
1789}
1790impl<'a> GPIO33OUTCFG_W<'a> {
1791 #[doc = r"Writes `variant` to the field"]
1792 #[inline(always)]
1793 pub fn variant(self, variant: GPIO33OUTCFG_A) -> &'a mut W {
1794 self.bits(variant.into())
1795 }
1796 #[doc = "FNCSEL = 0x3 - Output disabled value."]
1797 #[inline(always)]
1798 pub fn dis(self) -> &'a mut W {
1799 self.variant(GPIO33OUTCFG_A::DIS)
1800 }
1801 #[doc = "FNCSEL = 0x3 - Output is push-pull value."]
1802 #[inline(always)]
1803 pub fn pushpull(self) -> &'a mut W {
1804 self.variant(GPIO33OUTCFG_A::PUSHPULL)
1805 }
1806 #[doc = "FNCSEL = 0x3 - Output is open drain value."]
1807 #[inline(always)]
1808 pub fn od(self) -> &'a mut W {
1809 self.variant(GPIO33OUTCFG_A::OD)
1810 }
1811 #[doc = "FNCSEL = 0x3 - Output is tri-state value."]
1812 #[inline(always)]
1813 pub fn ts(self) -> &'a mut W {
1814 self.variant(GPIO33OUTCFG_A::TS)
1815 }
1816 #[doc = r"Writes raw bits to the field"]
1817 #[inline(always)]
1818 pub fn bits(self, value: u8) -> &'a mut W {
1819 self.w.bits = (self.w.bits & !(0x03 << 5)) | ((value as u32 & 0x03) << 5);
1820 self.w
1821 }
1822}
1823#[doc = "GPIO33 input enable.\n\nValue on reset: 0"]
1824#[derive(Clone, Copy, Debug, PartialEq)]
1825pub enum GPIO33INCFG_A {
1826 #[doc = "0: Read the GPIO pin data value."]
1827 READ = 0,
1828 #[doc = "1: INTD = 0 - Readback will always be zero value."]
1829 RDZERO = 1,
1830}
1831impl From<GPIO33INCFG_A> for bool {
1832 #[inline(always)]
1833 fn from(variant: GPIO33INCFG_A) -> Self {
1834 variant as u8 != 0
1835 }
1836}
1837#[doc = "Field `GPIO33INCFG` reader - GPIO33 input enable."]
1838pub struct GPIO33INCFG_R(crate::FieldReader<bool, GPIO33INCFG_A>);
1839impl GPIO33INCFG_R {
1840 pub(crate) fn new(bits: bool) -> Self {
1841 GPIO33INCFG_R(crate::FieldReader::new(bits))
1842 }
1843 #[doc = r"Get enumerated values variant"]
1844 #[inline(always)]
1845 pub fn variant(&self) -> GPIO33INCFG_A {
1846 match self.bits {
1847 false => GPIO33INCFG_A::READ,
1848 true => GPIO33INCFG_A::RDZERO,
1849 }
1850 }
1851 #[doc = "Checks if the value of the field is `READ`"]
1852 #[inline(always)]
1853 pub fn is_read(&self) -> bool {
1854 **self == GPIO33INCFG_A::READ
1855 }
1856 #[doc = "Checks if the value of the field is `RDZERO`"]
1857 #[inline(always)]
1858 pub fn is_rdzero(&self) -> bool {
1859 **self == GPIO33INCFG_A::RDZERO
1860 }
1861}
1862impl core::ops::Deref for GPIO33INCFG_R {
1863 type Target = crate::FieldReader<bool, GPIO33INCFG_A>;
1864 #[inline(always)]
1865 fn deref(&self) -> &Self::Target {
1866 &self.0
1867 }
1868}
1869#[doc = "Field `GPIO33INCFG` writer - GPIO33 input enable."]
1870pub struct GPIO33INCFG_W<'a> {
1871 w: &'a mut W,
1872}
1873impl<'a> GPIO33INCFG_W<'a> {
1874 #[doc = r"Writes `variant` to the field"]
1875 #[inline(always)]
1876 pub fn variant(self, variant: GPIO33INCFG_A) -> &'a mut W {
1877 self.bit(variant.into())
1878 }
1879 #[doc = "Read the GPIO pin data value."]
1880 #[inline(always)]
1881 pub fn read(self) -> &'a mut W {
1882 self.variant(GPIO33INCFG_A::READ)
1883 }
1884 #[doc = "INTD = 0 - Readback will always be zero value."]
1885 #[inline(always)]
1886 pub fn rdzero(self) -> &'a mut W {
1887 self.variant(GPIO33INCFG_A::RDZERO)
1888 }
1889 #[doc = r"Sets the field bit"]
1890 #[inline(always)]
1891 pub fn set_bit(self) -> &'a mut W {
1892 self.bit(true)
1893 }
1894 #[doc = r"Clears the field bit"]
1895 #[inline(always)]
1896 pub fn clear_bit(self) -> &'a mut W {
1897 self.bit(false)
1898 }
1899 #[doc = r"Writes raw bits to the field"]
1900 #[inline(always)]
1901 pub fn bit(self, value: bool) -> &'a mut W {
1902 self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
1903 self.w
1904 }
1905}
1906#[doc = "GPIO32 interrupt direction.\n\nValue on reset: 0"]
1907#[derive(Clone, Copy, Debug, PartialEq)]
1908pub enum GPIO32INTD_A {
1909 #[doc = "0: FNCSEL = 0x1 - nCE polarity active low value."]
1910 NCELOW = 0,
1911 #[doc = "1: FNCSEL = 0x1 - nCE polarity active high value."]
1912 NCEHIGH = 1,
1913}
1914impl From<GPIO32INTD_A> for bool {
1915 #[inline(always)]
1916 fn from(variant: GPIO32INTD_A) -> Self {
1917 variant as u8 != 0
1918 }
1919}
1920#[doc = "Field `GPIO32INTD` reader - GPIO32 interrupt direction."]
1921pub struct GPIO32INTD_R(crate::FieldReader<bool, GPIO32INTD_A>);
1922impl GPIO32INTD_R {
1923 pub(crate) fn new(bits: bool) -> Self {
1924 GPIO32INTD_R(crate::FieldReader::new(bits))
1925 }
1926 #[doc = r"Get enumerated values variant"]
1927 #[inline(always)]
1928 pub fn variant(&self) -> GPIO32INTD_A {
1929 match self.bits {
1930 false => GPIO32INTD_A::NCELOW,
1931 true => GPIO32INTD_A::NCEHIGH,
1932 }
1933 }
1934 #[doc = "Checks if the value of the field is `NCELOW`"]
1935 #[inline(always)]
1936 pub fn is_n_celow(&self) -> bool {
1937 **self == GPIO32INTD_A::NCELOW
1938 }
1939 #[doc = "Checks if the value of the field is `NCEHIGH`"]
1940 #[inline(always)]
1941 pub fn is_n_cehigh(&self) -> bool {
1942 **self == GPIO32INTD_A::NCEHIGH
1943 }
1944}
1945impl core::ops::Deref for GPIO32INTD_R {
1946 type Target = crate::FieldReader<bool, GPIO32INTD_A>;
1947 #[inline(always)]
1948 fn deref(&self) -> &Self::Target {
1949 &self.0
1950 }
1951}
1952#[doc = "Field `GPIO32INTD` writer - GPIO32 interrupt direction."]
1953pub struct GPIO32INTD_W<'a> {
1954 w: &'a mut W,
1955}
1956impl<'a> GPIO32INTD_W<'a> {
1957 #[doc = r"Writes `variant` to the field"]
1958 #[inline(always)]
1959 pub fn variant(self, variant: GPIO32INTD_A) -> &'a mut W {
1960 self.bit(variant.into())
1961 }
1962 #[doc = "FNCSEL = 0x1 - nCE polarity active low value."]
1963 #[inline(always)]
1964 pub fn n_celow(self) -> &'a mut W {
1965 self.variant(GPIO32INTD_A::NCELOW)
1966 }
1967 #[doc = "FNCSEL = 0x1 - nCE polarity active high value."]
1968 #[inline(always)]
1969 pub fn n_cehigh(self) -> &'a mut W {
1970 self.variant(GPIO32INTD_A::NCEHIGH)
1971 }
1972 #[doc = r"Sets the field bit"]
1973 #[inline(always)]
1974 pub fn set_bit(self) -> &'a mut W {
1975 self.bit(true)
1976 }
1977 #[doc = r"Clears the field bit"]
1978 #[inline(always)]
1979 pub fn clear_bit(self) -> &'a mut W {
1980 self.bit(false)
1981 }
1982 #[doc = r"Writes raw bits to the field"]
1983 #[inline(always)]
1984 pub fn bit(self, value: bool) -> &'a mut W {
1985 self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
1986 self.w
1987 }
1988}
1989#[doc = "GPIO32 output configuration.\n\nValue on reset: 0"]
1990#[derive(Clone, Copy, Debug, PartialEq)]
1991#[repr(u8)]
1992pub enum GPIO32OUTCFG_A {
1993 #[doc = "0: FNCSEL = 0x3 - Output disabled value."]
1994 DIS = 0,
1995 #[doc = "1: FNCSEL = 0x3 - Output is push-pull value."]
1996 PUSHPULL = 1,
1997 #[doc = "2: FNCSEL = 0x3 - Output is open drain value."]
1998 OD = 2,
1999 #[doc = "3: FNCSEL = 0x3 - Output is tri-state value."]
2000 TS = 3,
2001}
2002impl From<GPIO32OUTCFG_A> for u8 {
2003 #[inline(always)]
2004 fn from(variant: GPIO32OUTCFG_A) -> Self {
2005 variant as _
2006 }
2007}
2008#[doc = "Field `GPIO32OUTCFG` reader - GPIO32 output configuration."]
2009pub struct GPIO32OUTCFG_R(crate::FieldReader<u8, GPIO32OUTCFG_A>);
2010impl GPIO32OUTCFG_R {
2011 pub(crate) fn new(bits: u8) -> Self {
2012 GPIO32OUTCFG_R(crate::FieldReader::new(bits))
2013 }
2014 #[doc = r"Get enumerated values variant"]
2015 #[inline(always)]
2016 pub fn variant(&self) -> GPIO32OUTCFG_A {
2017 match self.bits {
2018 0 => GPIO32OUTCFG_A::DIS,
2019 1 => GPIO32OUTCFG_A::PUSHPULL,
2020 2 => GPIO32OUTCFG_A::OD,
2021 3 => GPIO32OUTCFG_A::TS,
2022 _ => unreachable!(),
2023 }
2024 }
2025 #[doc = "Checks if the value of the field is `DIS`"]
2026 #[inline(always)]
2027 pub fn is_dis(&self) -> bool {
2028 **self == GPIO32OUTCFG_A::DIS
2029 }
2030 #[doc = "Checks if the value of the field is `PUSHPULL`"]
2031 #[inline(always)]
2032 pub fn is_pushpull(&self) -> bool {
2033 **self == GPIO32OUTCFG_A::PUSHPULL
2034 }
2035 #[doc = "Checks if the value of the field is `OD`"]
2036 #[inline(always)]
2037 pub fn is_od(&self) -> bool {
2038 **self == GPIO32OUTCFG_A::OD
2039 }
2040 #[doc = "Checks if the value of the field is `TS`"]
2041 #[inline(always)]
2042 pub fn is_ts(&self) -> bool {
2043 **self == GPIO32OUTCFG_A::TS
2044 }
2045}
2046impl core::ops::Deref for GPIO32OUTCFG_R {
2047 type Target = crate::FieldReader<u8, GPIO32OUTCFG_A>;
2048 #[inline(always)]
2049 fn deref(&self) -> &Self::Target {
2050 &self.0
2051 }
2052}
2053#[doc = "Field `GPIO32OUTCFG` writer - GPIO32 output configuration."]
2054pub struct GPIO32OUTCFG_W<'a> {
2055 w: &'a mut W,
2056}
2057impl<'a> GPIO32OUTCFG_W<'a> {
2058 #[doc = r"Writes `variant` to the field"]
2059 #[inline(always)]
2060 pub fn variant(self, variant: GPIO32OUTCFG_A) -> &'a mut W {
2061 self.bits(variant.into())
2062 }
2063 #[doc = "FNCSEL = 0x3 - Output disabled value."]
2064 #[inline(always)]
2065 pub fn dis(self) -> &'a mut W {
2066 self.variant(GPIO32OUTCFG_A::DIS)
2067 }
2068 #[doc = "FNCSEL = 0x3 - Output is push-pull value."]
2069 #[inline(always)]
2070 pub fn pushpull(self) -> &'a mut W {
2071 self.variant(GPIO32OUTCFG_A::PUSHPULL)
2072 }
2073 #[doc = "FNCSEL = 0x3 - Output is open drain value."]
2074 #[inline(always)]
2075 pub fn od(self) -> &'a mut W {
2076 self.variant(GPIO32OUTCFG_A::OD)
2077 }
2078 #[doc = "FNCSEL = 0x3 - Output is tri-state value."]
2079 #[inline(always)]
2080 pub fn ts(self) -> &'a mut W {
2081 self.variant(GPIO32OUTCFG_A::TS)
2082 }
2083 #[doc = r"Writes raw bits to the field"]
2084 #[inline(always)]
2085 pub fn bits(self, value: u8) -> &'a mut W {
2086 self.w.bits = (self.w.bits & !(0x03 << 1)) | ((value as u32 & 0x03) << 1);
2087 self.w
2088 }
2089}
2090#[doc = "GPIO32 input enable.\n\nValue on reset: 0"]
2091#[derive(Clone, Copy, Debug, PartialEq)]
2092pub enum GPIO32INCFG_A {
2093 #[doc = "0: Read the GPIO pin data value."]
2094 READ = 0,
2095 #[doc = "1: INTD = 0 - Readback will always be zero value."]
2096 RDZERO = 1,
2097}
2098impl From<GPIO32INCFG_A> for bool {
2099 #[inline(always)]
2100 fn from(variant: GPIO32INCFG_A) -> Self {
2101 variant as u8 != 0
2102 }
2103}
2104#[doc = "Field `GPIO32INCFG` reader - GPIO32 input enable."]
2105pub struct GPIO32INCFG_R(crate::FieldReader<bool, GPIO32INCFG_A>);
2106impl GPIO32INCFG_R {
2107 pub(crate) fn new(bits: bool) -> Self {
2108 GPIO32INCFG_R(crate::FieldReader::new(bits))
2109 }
2110 #[doc = r"Get enumerated values variant"]
2111 #[inline(always)]
2112 pub fn variant(&self) -> GPIO32INCFG_A {
2113 match self.bits {
2114 false => GPIO32INCFG_A::READ,
2115 true => GPIO32INCFG_A::RDZERO,
2116 }
2117 }
2118 #[doc = "Checks if the value of the field is `READ`"]
2119 #[inline(always)]
2120 pub fn is_read(&self) -> bool {
2121 **self == GPIO32INCFG_A::READ
2122 }
2123 #[doc = "Checks if the value of the field is `RDZERO`"]
2124 #[inline(always)]
2125 pub fn is_rdzero(&self) -> bool {
2126 **self == GPIO32INCFG_A::RDZERO
2127 }
2128}
2129impl core::ops::Deref for GPIO32INCFG_R {
2130 type Target = crate::FieldReader<bool, GPIO32INCFG_A>;
2131 #[inline(always)]
2132 fn deref(&self) -> &Self::Target {
2133 &self.0
2134 }
2135}
2136#[doc = "Field `GPIO32INCFG` writer - GPIO32 input enable."]
2137pub struct GPIO32INCFG_W<'a> {
2138 w: &'a mut W,
2139}
2140impl<'a> GPIO32INCFG_W<'a> {
2141 #[doc = r"Writes `variant` to the field"]
2142 #[inline(always)]
2143 pub fn variant(self, variant: GPIO32INCFG_A) -> &'a mut W {
2144 self.bit(variant.into())
2145 }
2146 #[doc = "Read the GPIO pin data value."]
2147 #[inline(always)]
2148 pub fn read(self) -> &'a mut W {
2149 self.variant(GPIO32INCFG_A::READ)
2150 }
2151 #[doc = "INTD = 0 - Readback will always be zero value."]
2152 #[inline(always)]
2153 pub fn rdzero(self) -> &'a mut W {
2154 self.variant(GPIO32INCFG_A::RDZERO)
2155 }
2156 #[doc = r"Sets the field bit"]
2157 #[inline(always)]
2158 pub fn set_bit(self) -> &'a mut W {
2159 self.bit(true)
2160 }
2161 #[doc = r"Clears the field bit"]
2162 #[inline(always)]
2163 pub fn clear_bit(self) -> &'a mut W {
2164 self.bit(false)
2165 }
2166 #[doc = r"Writes raw bits to the field"]
2167 #[inline(always)]
2168 pub fn bit(self, value: bool) -> &'a mut W {
2169 self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
2170 self.w
2171 }
2172}
2173impl R {
2174 #[doc = "Bit 31 - GPIO39 interrupt direction."]
2175 #[inline(always)]
2176 pub fn gpio39intd(&self) -> GPIO39INTD_R {
2177 GPIO39INTD_R::new(((self.bits >> 31) & 0x01) != 0)
2178 }
2179 #[doc = "Bits 29:30 - GPIO39 output configuration."]
2180 #[inline(always)]
2181 pub fn gpio39outcfg(&self) -> GPIO39OUTCFG_R {
2182 GPIO39OUTCFG_R::new(((self.bits >> 29) & 0x03) as u8)
2183 }
2184 #[doc = "Bit 28 - GPIO39 input enable."]
2185 #[inline(always)]
2186 pub fn gpio39incfg(&self) -> GPIO39INCFG_R {
2187 GPIO39INCFG_R::new(((self.bits >> 28) & 0x01) != 0)
2188 }
2189 #[doc = "Bit 27 - GPIO38 interrupt direction."]
2190 #[inline(always)]
2191 pub fn gpio38intd(&self) -> GPIO38INTD_R {
2192 GPIO38INTD_R::new(((self.bits >> 27) & 0x01) != 0)
2193 }
2194 #[doc = "Bits 25:26 - GPIO38 output configuration."]
2195 #[inline(always)]
2196 pub fn gpio38outcfg(&self) -> GPIO38OUTCFG_R {
2197 GPIO38OUTCFG_R::new(((self.bits >> 25) & 0x03) as u8)
2198 }
2199 #[doc = "Bit 24 - GPIO38 input enable."]
2200 #[inline(always)]
2201 pub fn gpio38incfg(&self) -> GPIO38INCFG_R {
2202 GPIO38INCFG_R::new(((self.bits >> 24) & 0x01) != 0)
2203 }
2204 #[doc = "Bit 23 - GPIO37 interrupt direction."]
2205 #[inline(always)]
2206 pub fn gpio37intd(&self) -> GPIO37INTD_R {
2207 GPIO37INTD_R::new(((self.bits >> 23) & 0x01) != 0)
2208 }
2209 #[doc = "Bits 21:22 - GPIO37 output configuration."]
2210 #[inline(always)]
2211 pub fn gpio37outcfg(&self) -> GPIO37OUTCFG_R {
2212 GPIO37OUTCFG_R::new(((self.bits >> 21) & 0x03) as u8)
2213 }
2214 #[doc = "Bit 20 - GPIO37 input enable."]
2215 #[inline(always)]
2216 pub fn gpio37incfg(&self) -> GPIO37INCFG_R {
2217 GPIO37INCFG_R::new(((self.bits >> 20) & 0x01) != 0)
2218 }
2219 #[doc = "Bit 19 - GPIO36 interrupt direction."]
2220 #[inline(always)]
2221 pub fn gpio36intd(&self) -> GPIO36INTD_R {
2222 GPIO36INTD_R::new(((self.bits >> 19) & 0x01) != 0)
2223 }
2224 #[doc = "Bits 17:18 - GPIO36 output configuration."]
2225 #[inline(always)]
2226 pub fn gpio36outcfg(&self) -> GPIO36OUTCFG_R {
2227 GPIO36OUTCFG_R::new(((self.bits >> 17) & 0x03) as u8)
2228 }
2229 #[doc = "Bit 16 - GPIO36 input enable."]
2230 #[inline(always)]
2231 pub fn gpio36incfg(&self) -> GPIO36INCFG_R {
2232 GPIO36INCFG_R::new(((self.bits >> 16) & 0x01) != 0)
2233 }
2234 #[doc = "Bit 15 - GPIO35 interrupt direction."]
2235 #[inline(always)]
2236 pub fn gpio35intd(&self) -> GPIO35INTD_R {
2237 GPIO35INTD_R::new(((self.bits >> 15) & 0x01) != 0)
2238 }
2239 #[doc = "Bits 13:14 - GPIO35 output configuration."]
2240 #[inline(always)]
2241 pub fn gpio35outcfg(&self) -> GPIO35OUTCFG_R {
2242 GPIO35OUTCFG_R::new(((self.bits >> 13) & 0x03) as u8)
2243 }
2244 #[doc = "Bit 12 - GPIO35 input enable."]
2245 #[inline(always)]
2246 pub fn gpio35incfg(&self) -> GPIO35INCFG_R {
2247 GPIO35INCFG_R::new(((self.bits >> 12) & 0x01) != 0)
2248 }
2249 #[doc = "Bit 11 - GPIO34 interrupt direction."]
2250 #[inline(always)]
2251 pub fn gpio34intd(&self) -> GPIO34INTD_R {
2252 GPIO34INTD_R::new(((self.bits >> 11) & 0x01) != 0)
2253 }
2254 #[doc = "Bits 9:10 - GPIO34 output configuration."]
2255 #[inline(always)]
2256 pub fn gpio34outcfg(&self) -> GPIO34OUTCFG_R {
2257 GPIO34OUTCFG_R::new(((self.bits >> 9) & 0x03) as u8)
2258 }
2259 #[doc = "Bit 8 - GPIO34 input enable."]
2260 #[inline(always)]
2261 pub fn gpio34incfg(&self) -> GPIO34INCFG_R {
2262 GPIO34INCFG_R::new(((self.bits >> 8) & 0x01) != 0)
2263 }
2264 #[doc = "Bit 7 - GPIO33 interrupt direction."]
2265 #[inline(always)]
2266 pub fn gpio33intd(&self) -> GPIO33INTD_R {
2267 GPIO33INTD_R::new(((self.bits >> 7) & 0x01) != 0)
2268 }
2269 #[doc = "Bits 5:6 - GPIO33 output configuration."]
2270 #[inline(always)]
2271 pub fn gpio33outcfg(&self) -> GPIO33OUTCFG_R {
2272 GPIO33OUTCFG_R::new(((self.bits >> 5) & 0x03) as u8)
2273 }
2274 #[doc = "Bit 4 - GPIO33 input enable."]
2275 #[inline(always)]
2276 pub fn gpio33incfg(&self) -> GPIO33INCFG_R {
2277 GPIO33INCFG_R::new(((self.bits >> 4) & 0x01) != 0)
2278 }
2279 #[doc = "Bit 3 - GPIO32 interrupt direction."]
2280 #[inline(always)]
2281 pub fn gpio32intd(&self) -> GPIO32INTD_R {
2282 GPIO32INTD_R::new(((self.bits >> 3) & 0x01) != 0)
2283 }
2284 #[doc = "Bits 1:2 - GPIO32 output configuration."]
2285 #[inline(always)]
2286 pub fn gpio32outcfg(&self) -> GPIO32OUTCFG_R {
2287 GPIO32OUTCFG_R::new(((self.bits >> 1) & 0x03) as u8)
2288 }
2289 #[doc = "Bit 0 - GPIO32 input enable."]
2290 #[inline(always)]
2291 pub fn gpio32incfg(&self) -> GPIO32INCFG_R {
2292 GPIO32INCFG_R::new((self.bits & 0x01) != 0)
2293 }
2294}
2295impl W {
2296 #[doc = "Bit 31 - GPIO39 interrupt direction."]
2297 #[inline(always)]
2298 pub fn gpio39intd(&mut self) -> GPIO39INTD_W {
2299 GPIO39INTD_W { w: self }
2300 }
2301 #[doc = "Bits 29:30 - GPIO39 output configuration."]
2302 #[inline(always)]
2303 pub fn gpio39outcfg(&mut self) -> GPIO39OUTCFG_W {
2304 GPIO39OUTCFG_W { w: self }
2305 }
2306 #[doc = "Bit 28 - GPIO39 input enable."]
2307 #[inline(always)]
2308 pub fn gpio39incfg(&mut self) -> GPIO39INCFG_W {
2309 GPIO39INCFG_W { w: self }
2310 }
2311 #[doc = "Bit 27 - GPIO38 interrupt direction."]
2312 #[inline(always)]
2313 pub fn gpio38intd(&mut self) -> GPIO38INTD_W {
2314 GPIO38INTD_W { w: self }
2315 }
2316 #[doc = "Bits 25:26 - GPIO38 output configuration."]
2317 #[inline(always)]
2318 pub fn gpio38outcfg(&mut self) -> GPIO38OUTCFG_W {
2319 GPIO38OUTCFG_W { w: self }
2320 }
2321 #[doc = "Bit 24 - GPIO38 input enable."]
2322 #[inline(always)]
2323 pub fn gpio38incfg(&mut self) -> GPIO38INCFG_W {
2324 GPIO38INCFG_W { w: self }
2325 }
2326 #[doc = "Bit 23 - GPIO37 interrupt direction."]
2327 #[inline(always)]
2328 pub fn gpio37intd(&mut self) -> GPIO37INTD_W {
2329 GPIO37INTD_W { w: self }
2330 }
2331 #[doc = "Bits 21:22 - GPIO37 output configuration."]
2332 #[inline(always)]
2333 pub fn gpio37outcfg(&mut self) -> GPIO37OUTCFG_W {
2334 GPIO37OUTCFG_W { w: self }
2335 }
2336 #[doc = "Bit 20 - GPIO37 input enable."]
2337 #[inline(always)]
2338 pub fn gpio37incfg(&mut self) -> GPIO37INCFG_W {
2339 GPIO37INCFG_W { w: self }
2340 }
2341 #[doc = "Bit 19 - GPIO36 interrupt direction."]
2342 #[inline(always)]
2343 pub fn gpio36intd(&mut self) -> GPIO36INTD_W {
2344 GPIO36INTD_W { w: self }
2345 }
2346 #[doc = "Bits 17:18 - GPIO36 output configuration."]
2347 #[inline(always)]
2348 pub fn gpio36outcfg(&mut self) -> GPIO36OUTCFG_W {
2349 GPIO36OUTCFG_W { w: self }
2350 }
2351 #[doc = "Bit 16 - GPIO36 input enable."]
2352 #[inline(always)]
2353 pub fn gpio36incfg(&mut self) -> GPIO36INCFG_W {
2354 GPIO36INCFG_W { w: self }
2355 }
2356 #[doc = "Bit 15 - GPIO35 interrupt direction."]
2357 #[inline(always)]
2358 pub fn gpio35intd(&mut self) -> GPIO35INTD_W {
2359 GPIO35INTD_W { w: self }
2360 }
2361 #[doc = "Bits 13:14 - GPIO35 output configuration."]
2362 #[inline(always)]
2363 pub fn gpio35outcfg(&mut self) -> GPIO35OUTCFG_W {
2364 GPIO35OUTCFG_W { w: self }
2365 }
2366 #[doc = "Bit 12 - GPIO35 input enable."]
2367 #[inline(always)]
2368 pub fn gpio35incfg(&mut self) -> GPIO35INCFG_W {
2369 GPIO35INCFG_W { w: self }
2370 }
2371 #[doc = "Bit 11 - GPIO34 interrupt direction."]
2372 #[inline(always)]
2373 pub fn gpio34intd(&mut self) -> GPIO34INTD_W {
2374 GPIO34INTD_W { w: self }
2375 }
2376 #[doc = "Bits 9:10 - GPIO34 output configuration."]
2377 #[inline(always)]
2378 pub fn gpio34outcfg(&mut self) -> GPIO34OUTCFG_W {
2379 GPIO34OUTCFG_W { w: self }
2380 }
2381 #[doc = "Bit 8 - GPIO34 input enable."]
2382 #[inline(always)]
2383 pub fn gpio34incfg(&mut self) -> GPIO34INCFG_W {
2384 GPIO34INCFG_W { w: self }
2385 }
2386 #[doc = "Bit 7 - GPIO33 interrupt direction."]
2387 #[inline(always)]
2388 pub fn gpio33intd(&mut self) -> GPIO33INTD_W {
2389 GPIO33INTD_W { w: self }
2390 }
2391 #[doc = "Bits 5:6 - GPIO33 output configuration."]
2392 #[inline(always)]
2393 pub fn gpio33outcfg(&mut self) -> GPIO33OUTCFG_W {
2394 GPIO33OUTCFG_W { w: self }
2395 }
2396 #[doc = "Bit 4 - GPIO33 input enable."]
2397 #[inline(always)]
2398 pub fn gpio33incfg(&mut self) -> GPIO33INCFG_W {
2399 GPIO33INCFG_W { w: self }
2400 }
2401 #[doc = "Bit 3 - GPIO32 interrupt direction."]
2402 #[inline(always)]
2403 pub fn gpio32intd(&mut self) -> GPIO32INTD_W {
2404 GPIO32INTD_W { w: self }
2405 }
2406 #[doc = "Bits 1:2 - GPIO32 output configuration."]
2407 #[inline(always)]
2408 pub fn gpio32outcfg(&mut self) -> GPIO32OUTCFG_W {
2409 GPIO32OUTCFG_W { w: self }
2410 }
2411 #[doc = "Bit 0 - GPIO32 input enable."]
2412 #[inline(always)]
2413 pub fn gpio32incfg(&mut self) -> GPIO32INCFG_W {
2414 GPIO32INCFG_W { w: self }
2415 }
2416 #[doc = "Writes raw bits to the register."]
2417 #[inline(always)]
2418 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
2419 self.0.bits(bits);
2420 self
2421 }
2422}
2423#[doc = "GPIO Configuration Register E (Pads 32-39)\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 [cfge](index.html) module"]
2424pub struct CFGE_SPEC;
2425impl crate::RegisterSpec for CFGE_SPEC {
2426 type Ux = u32;
2427}
2428#[doc = "`read()` method returns [cfge::R](R) reader structure"]
2429impl crate::Readable for CFGE_SPEC {
2430 type Reader = R;
2431}
2432#[doc = "`write(|w| ..)` method takes [cfge::W](W) writer structure"]
2433impl crate::Writable for CFGE_SPEC {
2434 type Writer = W;
2435}
2436#[doc = "`reset()` method sets CFGE to value 0"]
2437impl crate::Resettable for CFGE_SPEC {
2438 #[inline(always)]
2439 fn reset_value() -> Self::Ux {
2440 0
2441 }
2442}