1#[doc = "Register `SEC_CPU_INT_MASK0` reader"]
2pub struct R(crate::R<SEC_CPU_INT_MASK0_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<SEC_CPU_INT_MASK0_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<SEC_CPU_INT_MASK0_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<SEC_CPU_INT_MASK0_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `SEC_CPU_INT_MASK0` writer"]
17pub struct W(crate::W<SEC_CPU_INT_MASK0_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<SEC_CPU_INT_MASK0_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<SEC_CPU_INT_MASK0_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<SEC_CPU_INT_MASK0_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Watchdog Timer, Brown Out Detectors and Flash Controller interrupts\n\nValue on reset: 1"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum SYS_IRQ_A {
40 #[doc = "0: no description available"]
41 INVISIBLE = 0,
42 #[doc = "1: no description available"]
43 VISIBLE = 1,
44}
45impl From<SYS_IRQ_A> for bool {
46 #[inline(always)]
47 fn from(variant: SYS_IRQ_A) -> Self {
48 variant as u8 != 0
49 }
50}
51#[doc = "Field `SYS_IRQ` reader - Watchdog Timer, Brown Out Detectors and Flash Controller interrupts"]
52pub struct SYS_IRQ_R(crate::FieldReader<bool, SYS_IRQ_A>);
53impl SYS_IRQ_R {
54 #[inline(always)]
55 pub(crate) fn new(bits: bool) -> Self {
56 SYS_IRQ_R(crate::FieldReader::new(bits))
57 }
58 #[doc = r"Get enumerated values variant"]
59 #[inline(always)]
60 pub fn variant(&self) -> SYS_IRQ_A {
61 match self.bits {
62 false => SYS_IRQ_A::INVISIBLE,
63 true => SYS_IRQ_A::VISIBLE,
64 }
65 }
66 #[doc = "Checks if the value of the field is `INVISIBLE`"]
67 #[inline(always)]
68 pub fn is_invisible(&self) -> bool {
69 **self == SYS_IRQ_A::INVISIBLE
70 }
71 #[doc = "Checks if the value of the field is `VISIBLE`"]
72 #[inline(always)]
73 pub fn is_visible(&self) -> bool {
74 **self == SYS_IRQ_A::VISIBLE
75 }
76}
77impl core::ops::Deref for SYS_IRQ_R {
78 type Target = crate::FieldReader<bool, SYS_IRQ_A>;
79 #[inline(always)]
80 fn deref(&self) -> &Self::Target {
81 &self.0
82 }
83}
84#[doc = "Field `SYS_IRQ` writer - Watchdog Timer, Brown Out Detectors and Flash Controller interrupts"]
85pub struct SYS_IRQ_W<'a> {
86 w: &'a mut W,
87}
88impl<'a> SYS_IRQ_W<'a> {
89 #[doc = r"Writes `variant` to the field"]
90 #[inline(always)]
91 pub fn variant(self, variant: SYS_IRQ_A) -> &'a mut W {
92 self.bit(variant.into())
93 }
94 #[doc = "no description available"]
95 #[inline(always)]
96 pub fn invisible(self) -> &'a mut W {
97 self.variant(SYS_IRQ_A::INVISIBLE)
98 }
99 #[doc = "no description available"]
100 #[inline(always)]
101 pub fn visible(self) -> &'a mut W {
102 self.variant(SYS_IRQ_A::VISIBLE)
103 }
104 #[doc = r"Sets the field bit"]
105 #[inline(always)]
106 pub fn set_bit(self) -> &'a mut W {
107 self.bit(true)
108 }
109 #[doc = r"Clears the field bit"]
110 #[inline(always)]
111 pub fn clear_bit(self) -> &'a mut W {
112 self.bit(false)
113 }
114 #[doc = r"Writes raw bits to the field"]
115 #[inline(always)]
116 pub fn bit(self, value: bool) -> &'a mut W {
117 self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
118 self.w
119 }
120}
121#[doc = "System DMA 0 (non-secure) interrupt.\n\nValue on reset: 1"]
122#[derive(Clone, Copy, Debug, PartialEq)]
123pub enum SDMA0_IRQ_A {
124 #[doc = "0: no description available"]
125 INVISIBLE = 0,
126 #[doc = "1: no description available"]
127 VISIBLE = 1,
128}
129impl From<SDMA0_IRQ_A> for bool {
130 #[inline(always)]
131 fn from(variant: SDMA0_IRQ_A) -> Self {
132 variant as u8 != 0
133 }
134}
135#[doc = "Field `SDMA0_IRQ` reader - System DMA 0 (non-secure) interrupt."]
136pub struct SDMA0_IRQ_R(crate::FieldReader<bool, SDMA0_IRQ_A>);
137impl SDMA0_IRQ_R {
138 #[inline(always)]
139 pub(crate) fn new(bits: bool) -> Self {
140 SDMA0_IRQ_R(crate::FieldReader::new(bits))
141 }
142 #[doc = r"Get enumerated values variant"]
143 #[inline(always)]
144 pub fn variant(&self) -> SDMA0_IRQ_A {
145 match self.bits {
146 false => SDMA0_IRQ_A::INVISIBLE,
147 true => SDMA0_IRQ_A::VISIBLE,
148 }
149 }
150 #[doc = "Checks if the value of the field is `INVISIBLE`"]
151 #[inline(always)]
152 pub fn is_invisible(&self) -> bool {
153 **self == SDMA0_IRQ_A::INVISIBLE
154 }
155 #[doc = "Checks if the value of the field is `VISIBLE`"]
156 #[inline(always)]
157 pub fn is_visible(&self) -> bool {
158 **self == SDMA0_IRQ_A::VISIBLE
159 }
160}
161impl core::ops::Deref for SDMA0_IRQ_R {
162 type Target = crate::FieldReader<bool, SDMA0_IRQ_A>;
163 #[inline(always)]
164 fn deref(&self) -> &Self::Target {
165 &self.0
166 }
167}
168#[doc = "Field `SDMA0_IRQ` writer - System DMA 0 (non-secure) interrupt."]
169pub struct SDMA0_IRQ_W<'a> {
170 w: &'a mut W,
171}
172impl<'a> SDMA0_IRQ_W<'a> {
173 #[doc = r"Writes `variant` to the field"]
174 #[inline(always)]
175 pub fn variant(self, variant: SDMA0_IRQ_A) -> &'a mut W {
176 self.bit(variant.into())
177 }
178 #[doc = "no description available"]
179 #[inline(always)]
180 pub fn invisible(self) -> &'a mut W {
181 self.variant(SDMA0_IRQ_A::INVISIBLE)
182 }
183 #[doc = "no description available"]
184 #[inline(always)]
185 pub fn visible(self) -> &'a mut W {
186 self.variant(SDMA0_IRQ_A::VISIBLE)
187 }
188 #[doc = r"Sets the field bit"]
189 #[inline(always)]
190 pub fn set_bit(self) -> &'a mut W {
191 self.bit(true)
192 }
193 #[doc = r"Clears the field bit"]
194 #[inline(always)]
195 pub fn clear_bit(self) -> &'a mut W {
196 self.bit(false)
197 }
198 #[doc = r"Writes raw bits to the field"]
199 #[inline(always)]
200 pub fn bit(self, value: bool) -> &'a mut W {
201 self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
202 self.w
203 }
204}
205#[doc = "GPIO Group 0 interrupt.\n\nValue on reset: 1"]
206#[derive(Clone, Copy, Debug, PartialEq)]
207pub enum GPIO_GLOBALINT0_IRQ_A {
208 #[doc = "0: no description available"]
209 INVISIBLE = 0,
210 #[doc = "1: no description available"]
211 VISIBLE = 1,
212}
213impl From<GPIO_GLOBALINT0_IRQ_A> for bool {
214 #[inline(always)]
215 fn from(variant: GPIO_GLOBALINT0_IRQ_A) -> Self {
216 variant as u8 != 0
217 }
218}
219#[doc = "Field `GPIO_GLOBALINT0_IRQ` reader - GPIO Group 0 interrupt."]
220pub struct GPIO_GLOBALINT0_IRQ_R(crate::FieldReader<bool, GPIO_GLOBALINT0_IRQ_A>);
221impl GPIO_GLOBALINT0_IRQ_R {
222 #[inline(always)]
223 pub(crate) fn new(bits: bool) -> Self {
224 GPIO_GLOBALINT0_IRQ_R(crate::FieldReader::new(bits))
225 }
226 #[doc = r"Get enumerated values variant"]
227 #[inline(always)]
228 pub fn variant(&self) -> GPIO_GLOBALINT0_IRQ_A {
229 match self.bits {
230 false => GPIO_GLOBALINT0_IRQ_A::INVISIBLE,
231 true => GPIO_GLOBALINT0_IRQ_A::VISIBLE,
232 }
233 }
234 #[doc = "Checks if the value of the field is `INVISIBLE`"]
235 #[inline(always)]
236 pub fn is_invisible(&self) -> bool {
237 **self == GPIO_GLOBALINT0_IRQ_A::INVISIBLE
238 }
239 #[doc = "Checks if the value of the field is `VISIBLE`"]
240 #[inline(always)]
241 pub fn is_visible(&self) -> bool {
242 **self == GPIO_GLOBALINT0_IRQ_A::VISIBLE
243 }
244}
245impl core::ops::Deref for GPIO_GLOBALINT0_IRQ_R {
246 type Target = crate::FieldReader<bool, GPIO_GLOBALINT0_IRQ_A>;
247 #[inline(always)]
248 fn deref(&self) -> &Self::Target {
249 &self.0
250 }
251}
252#[doc = "Field `GPIO_GLOBALINT0_IRQ` writer - GPIO Group 0 interrupt."]
253pub struct GPIO_GLOBALINT0_IRQ_W<'a> {
254 w: &'a mut W,
255}
256impl<'a> GPIO_GLOBALINT0_IRQ_W<'a> {
257 #[doc = r"Writes `variant` to the field"]
258 #[inline(always)]
259 pub fn variant(self, variant: GPIO_GLOBALINT0_IRQ_A) -> &'a mut W {
260 self.bit(variant.into())
261 }
262 #[doc = "no description available"]
263 #[inline(always)]
264 pub fn invisible(self) -> &'a mut W {
265 self.variant(GPIO_GLOBALINT0_IRQ_A::INVISIBLE)
266 }
267 #[doc = "no description available"]
268 #[inline(always)]
269 pub fn visible(self) -> &'a mut W {
270 self.variant(GPIO_GLOBALINT0_IRQ_A::VISIBLE)
271 }
272 #[doc = r"Sets the field bit"]
273 #[inline(always)]
274 pub fn set_bit(self) -> &'a mut W {
275 self.bit(true)
276 }
277 #[doc = r"Clears the field bit"]
278 #[inline(always)]
279 pub fn clear_bit(self) -> &'a mut W {
280 self.bit(false)
281 }
282 #[doc = r"Writes raw bits to the field"]
283 #[inline(always)]
284 pub fn bit(self, value: bool) -> &'a mut W {
285 self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
286 self.w
287 }
288}
289#[doc = "GPIO Group 1 interrupt.\n\nValue on reset: 1"]
290#[derive(Clone, Copy, Debug, PartialEq)]
291pub enum GPIO_GLOBALINT1_IRQ_A {
292 #[doc = "0: no description available"]
293 INVISIBLE = 0,
294 #[doc = "1: no description available"]
295 VISIBLE = 1,
296}
297impl From<GPIO_GLOBALINT1_IRQ_A> for bool {
298 #[inline(always)]
299 fn from(variant: GPIO_GLOBALINT1_IRQ_A) -> Self {
300 variant as u8 != 0
301 }
302}
303#[doc = "Field `GPIO_GLOBALINT1_IRQ` reader - GPIO Group 1 interrupt."]
304pub struct GPIO_GLOBALINT1_IRQ_R(crate::FieldReader<bool, GPIO_GLOBALINT1_IRQ_A>);
305impl GPIO_GLOBALINT1_IRQ_R {
306 #[inline(always)]
307 pub(crate) fn new(bits: bool) -> Self {
308 GPIO_GLOBALINT1_IRQ_R(crate::FieldReader::new(bits))
309 }
310 #[doc = r"Get enumerated values variant"]
311 #[inline(always)]
312 pub fn variant(&self) -> GPIO_GLOBALINT1_IRQ_A {
313 match self.bits {
314 false => GPIO_GLOBALINT1_IRQ_A::INVISIBLE,
315 true => GPIO_GLOBALINT1_IRQ_A::VISIBLE,
316 }
317 }
318 #[doc = "Checks if the value of the field is `INVISIBLE`"]
319 #[inline(always)]
320 pub fn is_invisible(&self) -> bool {
321 **self == GPIO_GLOBALINT1_IRQ_A::INVISIBLE
322 }
323 #[doc = "Checks if the value of the field is `VISIBLE`"]
324 #[inline(always)]
325 pub fn is_visible(&self) -> bool {
326 **self == GPIO_GLOBALINT1_IRQ_A::VISIBLE
327 }
328}
329impl core::ops::Deref for GPIO_GLOBALINT1_IRQ_R {
330 type Target = crate::FieldReader<bool, GPIO_GLOBALINT1_IRQ_A>;
331 #[inline(always)]
332 fn deref(&self) -> &Self::Target {
333 &self.0
334 }
335}
336#[doc = "Field `GPIO_GLOBALINT1_IRQ` writer - GPIO Group 1 interrupt."]
337pub struct GPIO_GLOBALINT1_IRQ_W<'a> {
338 w: &'a mut W,
339}
340impl<'a> GPIO_GLOBALINT1_IRQ_W<'a> {
341 #[doc = r"Writes `variant` to the field"]
342 #[inline(always)]
343 pub fn variant(self, variant: GPIO_GLOBALINT1_IRQ_A) -> &'a mut W {
344 self.bit(variant.into())
345 }
346 #[doc = "no description available"]
347 #[inline(always)]
348 pub fn invisible(self) -> &'a mut W {
349 self.variant(GPIO_GLOBALINT1_IRQ_A::INVISIBLE)
350 }
351 #[doc = "no description available"]
352 #[inline(always)]
353 pub fn visible(self) -> &'a mut W {
354 self.variant(GPIO_GLOBALINT1_IRQ_A::VISIBLE)
355 }
356 #[doc = r"Sets the field bit"]
357 #[inline(always)]
358 pub fn set_bit(self) -> &'a mut W {
359 self.bit(true)
360 }
361 #[doc = r"Clears the field bit"]
362 #[inline(always)]
363 pub fn clear_bit(self) -> &'a mut W {
364 self.bit(false)
365 }
366 #[doc = r"Writes raw bits to the field"]
367 #[inline(always)]
368 pub fn bit(self, value: bool) -> &'a mut W {
369 self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
370 self.w
371 }
372}
373#[doc = "Pin interrupt 0 or pattern match engine slice 0 interrupt.\n\nValue on reset: 1"]
374#[derive(Clone, Copy, Debug, PartialEq)]
375pub enum GPIO_INT0_IRQ0_A {
376 #[doc = "0: no description available"]
377 INVISIBLE = 0,
378 #[doc = "1: no description available"]
379 VISIBLE = 1,
380}
381impl From<GPIO_INT0_IRQ0_A> for bool {
382 #[inline(always)]
383 fn from(variant: GPIO_INT0_IRQ0_A) -> Self {
384 variant as u8 != 0
385 }
386}
387#[doc = "Field `GPIO_INT0_IRQ0` reader - Pin interrupt 0 or pattern match engine slice 0 interrupt."]
388pub struct GPIO_INT0_IRQ0_R(crate::FieldReader<bool, GPIO_INT0_IRQ0_A>);
389impl GPIO_INT0_IRQ0_R {
390 #[inline(always)]
391 pub(crate) fn new(bits: bool) -> Self {
392 GPIO_INT0_IRQ0_R(crate::FieldReader::new(bits))
393 }
394 #[doc = r"Get enumerated values variant"]
395 #[inline(always)]
396 pub fn variant(&self) -> GPIO_INT0_IRQ0_A {
397 match self.bits {
398 false => GPIO_INT0_IRQ0_A::INVISIBLE,
399 true => GPIO_INT0_IRQ0_A::VISIBLE,
400 }
401 }
402 #[doc = "Checks if the value of the field is `INVISIBLE`"]
403 #[inline(always)]
404 pub fn is_invisible(&self) -> bool {
405 **self == GPIO_INT0_IRQ0_A::INVISIBLE
406 }
407 #[doc = "Checks if the value of the field is `VISIBLE`"]
408 #[inline(always)]
409 pub fn is_visible(&self) -> bool {
410 **self == GPIO_INT0_IRQ0_A::VISIBLE
411 }
412}
413impl core::ops::Deref for GPIO_INT0_IRQ0_R {
414 type Target = crate::FieldReader<bool, GPIO_INT0_IRQ0_A>;
415 #[inline(always)]
416 fn deref(&self) -> &Self::Target {
417 &self.0
418 }
419}
420#[doc = "Field `GPIO_INT0_IRQ0` writer - Pin interrupt 0 or pattern match engine slice 0 interrupt."]
421pub struct GPIO_INT0_IRQ0_W<'a> {
422 w: &'a mut W,
423}
424impl<'a> GPIO_INT0_IRQ0_W<'a> {
425 #[doc = r"Writes `variant` to the field"]
426 #[inline(always)]
427 pub fn variant(self, variant: GPIO_INT0_IRQ0_A) -> &'a mut W {
428 self.bit(variant.into())
429 }
430 #[doc = "no description available"]
431 #[inline(always)]
432 pub fn invisible(self) -> &'a mut W {
433 self.variant(GPIO_INT0_IRQ0_A::INVISIBLE)
434 }
435 #[doc = "no description available"]
436 #[inline(always)]
437 pub fn visible(self) -> &'a mut W {
438 self.variant(GPIO_INT0_IRQ0_A::VISIBLE)
439 }
440 #[doc = r"Sets the field bit"]
441 #[inline(always)]
442 pub fn set_bit(self) -> &'a mut W {
443 self.bit(true)
444 }
445 #[doc = r"Clears the field bit"]
446 #[inline(always)]
447 pub fn clear_bit(self) -> &'a mut W {
448 self.bit(false)
449 }
450 #[doc = r"Writes raw bits to the field"]
451 #[inline(always)]
452 pub fn bit(self, value: bool) -> &'a mut W {
453 self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
454 self.w
455 }
456}
457#[doc = "Pin interrupt 1 or pattern match engine slice 1 interrupt.\n\nValue on reset: 1"]
458#[derive(Clone, Copy, Debug, PartialEq)]
459pub enum GPIO_INT0_IRQ1_A {
460 #[doc = "0: no description available"]
461 INVISIBLE = 0,
462 #[doc = "1: no description available"]
463 VISIBLE = 1,
464}
465impl From<GPIO_INT0_IRQ1_A> for bool {
466 #[inline(always)]
467 fn from(variant: GPIO_INT0_IRQ1_A) -> Self {
468 variant as u8 != 0
469 }
470}
471#[doc = "Field `GPIO_INT0_IRQ1` reader - Pin interrupt 1 or pattern match engine slice 1 interrupt."]
472pub struct GPIO_INT0_IRQ1_R(crate::FieldReader<bool, GPIO_INT0_IRQ1_A>);
473impl GPIO_INT0_IRQ1_R {
474 #[inline(always)]
475 pub(crate) fn new(bits: bool) -> Self {
476 GPIO_INT0_IRQ1_R(crate::FieldReader::new(bits))
477 }
478 #[doc = r"Get enumerated values variant"]
479 #[inline(always)]
480 pub fn variant(&self) -> GPIO_INT0_IRQ1_A {
481 match self.bits {
482 false => GPIO_INT0_IRQ1_A::INVISIBLE,
483 true => GPIO_INT0_IRQ1_A::VISIBLE,
484 }
485 }
486 #[doc = "Checks if the value of the field is `INVISIBLE`"]
487 #[inline(always)]
488 pub fn is_invisible(&self) -> bool {
489 **self == GPIO_INT0_IRQ1_A::INVISIBLE
490 }
491 #[doc = "Checks if the value of the field is `VISIBLE`"]
492 #[inline(always)]
493 pub fn is_visible(&self) -> bool {
494 **self == GPIO_INT0_IRQ1_A::VISIBLE
495 }
496}
497impl core::ops::Deref for GPIO_INT0_IRQ1_R {
498 type Target = crate::FieldReader<bool, GPIO_INT0_IRQ1_A>;
499 #[inline(always)]
500 fn deref(&self) -> &Self::Target {
501 &self.0
502 }
503}
504#[doc = "Field `GPIO_INT0_IRQ1` writer - Pin interrupt 1 or pattern match engine slice 1 interrupt."]
505pub struct GPIO_INT0_IRQ1_W<'a> {
506 w: &'a mut W,
507}
508impl<'a> GPIO_INT0_IRQ1_W<'a> {
509 #[doc = r"Writes `variant` to the field"]
510 #[inline(always)]
511 pub fn variant(self, variant: GPIO_INT0_IRQ1_A) -> &'a mut W {
512 self.bit(variant.into())
513 }
514 #[doc = "no description available"]
515 #[inline(always)]
516 pub fn invisible(self) -> &'a mut W {
517 self.variant(GPIO_INT0_IRQ1_A::INVISIBLE)
518 }
519 #[doc = "no description available"]
520 #[inline(always)]
521 pub fn visible(self) -> &'a mut W {
522 self.variant(GPIO_INT0_IRQ1_A::VISIBLE)
523 }
524 #[doc = r"Sets the field bit"]
525 #[inline(always)]
526 pub fn set_bit(self) -> &'a mut W {
527 self.bit(true)
528 }
529 #[doc = r"Clears the field bit"]
530 #[inline(always)]
531 pub fn clear_bit(self) -> &'a mut W {
532 self.bit(false)
533 }
534 #[doc = r"Writes raw bits to the field"]
535 #[inline(always)]
536 pub fn bit(self, value: bool) -> &'a mut W {
537 self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
538 self.w
539 }
540}
541#[doc = "Pin interrupt 2 or pattern match engine slice 2 interrupt.\n\nValue on reset: 1"]
542#[derive(Clone, Copy, Debug, PartialEq)]
543pub enum GPIO_INT0_IRQ2_A {
544 #[doc = "0: no description available"]
545 INVISIBLE = 0,
546 #[doc = "1: no description available"]
547 VISIBLE = 1,
548}
549impl From<GPIO_INT0_IRQ2_A> for bool {
550 #[inline(always)]
551 fn from(variant: GPIO_INT0_IRQ2_A) -> Self {
552 variant as u8 != 0
553 }
554}
555#[doc = "Field `GPIO_INT0_IRQ2` reader - Pin interrupt 2 or pattern match engine slice 2 interrupt."]
556pub struct GPIO_INT0_IRQ2_R(crate::FieldReader<bool, GPIO_INT0_IRQ2_A>);
557impl GPIO_INT0_IRQ2_R {
558 #[inline(always)]
559 pub(crate) fn new(bits: bool) -> Self {
560 GPIO_INT0_IRQ2_R(crate::FieldReader::new(bits))
561 }
562 #[doc = r"Get enumerated values variant"]
563 #[inline(always)]
564 pub fn variant(&self) -> GPIO_INT0_IRQ2_A {
565 match self.bits {
566 false => GPIO_INT0_IRQ2_A::INVISIBLE,
567 true => GPIO_INT0_IRQ2_A::VISIBLE,
568 }
569 }
570 #[doc = "Checks if the value of the field is `INVISIBLE`"]
571 #[inline(always)]
572 pub fn is_invisible(&self) -> bool {
573 **self == GPIO_INT0_IRQ2_A::INVISIBLE
574 }
575 #[doc = "Checks if the value of the field is `VISIBLE`"]
576 #[inline(always)]
577 pub fn is_visible(&self) -> bool {
578 **self == GPIO_INT0_IRQ2_A::VISIBLE
579 }
580}
581impl core::ops::Deref for GPIO_INT0_IRQ2_R {
582 type Target = crate::FieldReader<bool, GPIO_INT0_IRQ2_A>;
583 #[inline(always)]
584 fn deref(&self) -> &Self::Target {
585 &self.0
586 }
587}
588#[doc = "Field `GPIO_INT0_IRQ2` writer - Pin interrupt 2 or pattern match engine slice 2 interrupt."]
589pub struct GPIO_INT0_IRQ2_W<'a> {
590 w: &'a mut W,
591}
592impl<'a> GPIO_INT0_IRQ2_W<'a> {
593 #[doc = r"Writes `variant` to the field"]
594 #[inline(always)]
595 pub fn variant(self, variant: GPIO_INT0_IRQ2_A) -> &'a mut W {
596 self.bit(variant.into())
597 }
598 #[doc = "no description available"]
599 #[inline(always)]
600 pub fn invisible(self) -> &'a mut W {
601 self.variant(GPIO_INT0_IRQ2_A::INVISIBLE)
602 }
603 #[doc = "no description available"]
604 #[inline(always)]
605 pub fn visible(self) -> &'a mut W {
606 self.variant(GPIO_INT0_IRQ2_A::VISIBLE)
607 }
608 #[doc = r"Sets the field bit"]
609 #[inline(always)]
610 pub fn set_bit(self) -> &'a mut W {
611 self.bit(true)
612 }
613 #[doc = r"Clears the field bit"]
614 #[inline(always)]
615 pub fn clear_bit(self) -> &'a mut W {
616 self.bit(false)
617 }
618 #[doc = r"Writes raw bits to the field"]
619 #[inline(always)]
620 pub fn bit(self, value: bool) -> &'a mut W {
621 self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
622 self.w
623 }
624}
625#[doc = "Pin interrupt 3 or pattern match engine slice 3 interrupt.\n\nValue on reset: 1"]
626#[derive(Clone, Copy, Debug, PartialEq)]
627pub enum GPIO_INT0_IRQ3_A {
628 #[doc = "0: no description available"]
629 INVISIBLE = 0,
630 #[doc = "1: no description available"]
631 VISIBLE = 1,
632}
633impl From<GPIO_INT0_IRQ3_A> for bool {
634 #[inline(always)]
635 fn from(variant: GPIO_INT0_IRQ3_A) -> Self {
636 variant as u8 != 0
637 }
638}
639#[doc = "Field `GPIO_INT0_IRQ3` reader - Pin interrupt 3 or pattern match engine slice 3 interrupt."]
640pub struct GPIO_INT0_IRQ3_R(crate::FieldReader<bool, GPIO_INT0_IRQ3_A>);
641impl GPIO_INT0_IRQ3_R {
642 #[inline(always)]
643 pub(crate) fn new(bits: bool) -> Self {
644 GPIO_INT0_IRQ3_R(crate::FieldReader::new(bits))
645 }
646 #[doc = r"Get enumerated values variant"]
647 #[inline(always)]
648 pub fn variant(&self) -> GPIO_INT0_IRQ3_A {
649 match self.bits {
650 false => GPIO_INT0_IRQ3_A::INVISIBLE,
651 true => GPIO_INT0_IRQ3_A::VISIBLE,
652 }
653 }
654 #[doc = "Checks if the value of the field is `INVISIBLE`"]
655 #[inline(always)]
656 pub fn is_invisible(&self) -> bool {
657 **self == GPIO_INT0_IRQ3_A::INVISIBLE
658 }
659 #[doc = "Checks if the value of the field is `VISIBLE`"]
660 #[inline(always)]
661 pub fn is_visible(&self) -> bool {
662 **self == GPIO_INT0_IRQ3_A::VISIBLE
663 }
664}
665impl core::ops::Deref for GPIO_INT0_IRQ3_R {
666 type Target = crate::FieldReader<bool, GPIO_INT0_IRQ3_A>;
667 #[inline(always)]
668 fn deref(&self) -> &Self::Target {
669 &self.0
670 }
671}
672#[doc = "Field `GPIO_INT0_IRQ3` writer - Pin interrupt 3 or pattern match engine slice 3 interrupt."]
673pub struct GPIO_INT0_IRQ3_W<'a> {
674 w: &'a mut W,
675}
676impl<'a> GPIO_INT0_IRQ3_W<'a> {
677 #[doc = r"Writes `variant` to the field"]
678 #[inline(always)]
679 pub fn variant(self, variant: GPIO_INT0_IRQ3_A) -> &'a mut W {
680 self.bit(variant.into())
681 }
682 #[doc = "no description available"]
683 #[inline(always)]
684 pub fn invisible(self) -> &'a mut W {
685 self.variant(GPIO_INT0_IRQ3_A::INVISIBLE)
686 }
687 #[doc = "no description available"]
688 #[inline(always)]
689 pub fn visible(self) -> &'a mut W {
690 self.variant(GPIO_INT0_IRQ3_A::VISIBLE)
691 }
692 #[doc = r"Sets the field bit"]
693 #[inline(always)]
694 pub fn set_bit(self) -> &'a mut W {
695 self.bit(true)
696 }
697 #[doc = r"Clears the field bit"]
698 #[inline(always)]
699 pub fn clear_bit(self) -> &'a mut W {
700 self.bit(false)
701 }
702 #[doc = r"Writes raw bits to the field"]
703 #[inline(always)]
704 pub fn bit(self, value: bool) -> &'a mut W {
705 self.w.bits = (self.w.bits & !(0x01 << 7)) | ((value as u32 & 0x01) << 7);
706 self.w
707 }
708}
709#[doc = "Micro Tick Timer interrupt.\n\nValue on reset: 1"]
710#[derive(Clone, Copy, Debug, PartialEq)]
711pub enum UTICK_IRQ_A {
712 #[doc = "0: no description available"]
713 INVISIBLE = 0,
714 #[doc = "1: no description available"]
715 VISIBLE = 1,
716}
717impl From<UTICK_IRQ_A> for bool {
718 #[inline(always)]
719 fn from(variant: UTICK_IRQ_A) -> Self {
720 variant as u8 != 0
721 }
722}
723#[doc = "Field `UTICK_IRQ` reader - Micro Tick Timer interrupt."]
724pub struct UTICK_IRQ_R(crate::FieldReader<bool, UTICK_IRQ_A>);
725impl UTICK_IRQ_R {
726 #[inline(always)]
727 pub(crate) fn new(bits: bool) -> Self {
728 UTICK_IRQ_R(crate::FieldReader::new(bits))
729 }
730 #[doc = r"Get enumerated values variant"]
731 #[inline(always)]
732 pub fn variant(&self) -> UTICK_IRQ_A {
733 match self.bits {
734 false => UTICK_IRQ_A::INVISIBLE,
735 true => UTICK_IRQ_A::VISIBLE,
736 }
737 }
738 #[doc = "Checks if the value of the field is `INVISIBLE`"]
739 #[inline(always)]
740 pub fn is_invisible(&self) -> bool {
741 **self == UTICK_IRQ_A::INVISIBLE
742 }
743 #[doc = "Checks if the value of the field is `VISIBLE`"]
744 #[inline(always)]
745 pub fn is_visible(&self) -> bool {
746 **self == UTICK_IRQ_A::VISIBLE
747 }
748}
749impl core::ops::Deref for UTICK_IRQ_R {
750 type Target = crate::FieldReader<bool, UTICK_IRQ_A>;
751 #[inline(always)]
752 fn deref(&self) -> &Self::Target {
753 &self.0
754 }
755}
756#[doc = "Field `UTICK_IRQ` writer - Micro Tick Timer interrupt."]
757pub struct UTICK_IRQ_W<'a> {
758 w: &'a mut W,
759}
760impl<'a> UTICK_IRQ_W<'a> {
761 #[doc = r"Writes `variant` to the field"]
762 #[inline(always)]
763 pub fn variant(self, variant: UTICK_IRQ_A) -> &'a mut W {
764 self.bit(variant.into())
765 }
766 #[doc = "no description available"]
767 #[inline(always)]
768 pub fn invisible(self) -> &'a mut W {
769 self.variant(UTICK_IRQ_A::INVISIBLE)
770 }
771 #[doc = "no description available"]
772 #[inline(always)]
773 pub fn visible(self) -> &'a mut W {
774 self.variant(UTICK_IRQ_A::VISIBLE)
775 }
776 #[doc = r"Sets the field bit"]
777 #[inline(always)]
778 pub fn set_bit(self) -> &'a mut W {
779 self.bit(true)
780 }
781 #[doc = r"Clears the field bit"]
782 #[inline(always)]
783 pub fn clear_bit(self) -> &'a mut W {
784 self.bit(false)
785 }
786 #[doc = r"Writes raw bits to the field"]
787 #[inline(always)]
788 pub fn bit(self, value: bool) -> &'a mut W {
789 self.w.bits = (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
790 self.w
791 }
792}
793#[doc = "Multi-Rate Timer interrupt.\n\nValue on reset: 1"]
794#[derive(Clone, Copy, Debug, PartialEq)]
795pub enum MRT_IRQ_A {
796 #[doc = "0: no description available"]
797 INVISIBLE = 0,
798 #[doc = "1: no description available"]
799 VISIBLE = 1,
800}
801impl From<MRT_IRQ_A> for bool {
802 #[inline(always)]
803 fn from(variant: MRT_IRQ_A) -> Self {
804 variant as u8 != 0
805 }
806}
807#[doc = "Field `MRT_IRQ` reader - Multi-Rate Timer interrupt."]
808pub struct MRT_IRQ_R(crate::FieldReader<bool, MRT_IRQ_A>);
809impl MRT_IRQ_R {
810 #[inline(always)]
811 pub(crate) fn new(bits: bool) -> Self {
812 MRT_IRQ_R(crate::FieldReader::new(bits))
813 }
814 #[doc = r"Get enumerated values variant"]
815 #[inline(always)]
816 pub fn variant(&self) -> MRT_IRQ_A {
817 match self.bits {
818 false => MRT_IRQ_A::INVISIBLE,
819 true => MRT_IRQ_A::VISIBLE,
820 }
821 }
822 #[doc = "Checks if the value of the field is `INVISIBLE`"]
823 #[inline(always)]
824 pub fn is_invisible(&self) -> bool {
825 **self == MRT_IRQ_A::INVISIBLE
826 }
827 #[doc = "Checks if the value of the field is `VISIBLE`"]
828 #[inline(always)]
829 pub fn is_visible(&self) -> bool {
830 **self == MRT_IRQ_A::VISIBLE
831 }
832}
833impl core::ops::Deref for MRT_IRQ_R {
834 type Target = crate::FieldReader<bool, MRT_IRQ_A>;
835 #[inline(always)]
836 fn deref(&self) -> &Self::Target {
837 &self.0
838 }
839}
840#[doc = "Field `MRT_IRQ` writer - Multi-Rate Timer interrupt."]
841pub struct MRT_IRQ_W<'a> {
842 w: &'a mut W,
843}
844impl<'a> MRT_IRQ_W<'a> {
845 #[doc = r"Writes `variant` to the field"]
846 #[inline(always)]
847 pub fn variant(self, variant: MRT_IRQ_A) -> &'a mut W {
848 self.bit(variant.into())
849 }
850 #[doc = "no description available"]
851 #[inline(always)]
852 pub fn invisible(self) -> &'a mut W {
853 self.variant(MRT_IRQ_A::INVISIBLE)
854 }
855 #[doc = "no description available"]
856 #[inline(always)]
857 pub fn visible(self) -> &'a mut W {
858 self.variant(MRT_IRQ_A::VISIBLE)
859 }
860 #[doc = r"Sets the field bit"]
861 #[inline(always)]
862 pub fn set_bit(self) -> &'a mut W {
863 self.bit(true)
864 }
865 #[doc = r"Clears the field bit"]
866 #[inline(always)]
867 pub fn clear_bit(self) -> &'a mut W {
868 self.bit(false)
869 }
870 #[doc = r"Writes raw bits to the field"]
871 #[inline(always)]
872 pub fn bit(self, value: bool) -> &'a mut W {
873 self.w.bits = (self.w.bits & !(0x01 << 9)) | ((value as u32 & 0x01) << 9);
874 self.w
875 }
876}
877#[doc = "Standard counter/timer 0 interrupt.\n\nValue on reset: 1"]
878#[derive(Clone, Copy, Debug, PartialEq)]
879pub enum CTIMER0_IRQ_A {
880 #[doc = "0: no description available"]
881 INVISIBLE = 0,
882 #[doc = "1: no description available"]
883 VISIBLE = 1,
884}
885impl From<CTIMER0_IRQ_A> for bool {
886 #[inline(always)]
887 fn from(variant: CTIMER0_IRQ_A) -> Self {
888 variant as u8 != 0
889 }
890}
891#[doc = "Field `CTIMER0_IRQ` reader - Standard counter/timer 0 interrupt."]
892pub struct CTIMER0_IRQ_R(crate::FieldReader<bool, CTIMER0_IRQ_A>);
893impl CTIMER0_IRQ_R {
894 #[inline(always)]
895 pub(crate) fn new(bits: bool) -> Self {
896 CTIMER0_IRQ_R(crate::FieldReader::new(bits))
897 }
898 #[doc = r"Get enumerated values variant"]
899 #[inline(always)]
900 pub fn variant(&self) -> CTIMER0_IRQ_A {
901 match self.bits {
902 false => CTIMER0_IRQ_A::INVISIBLE,
903 true => CTIMER0_IRQ_A::VISIBLE,
904 }
905 }
906 #[doc = "Checks if the value of the field is `INVISIBLE`"]
907 #[inline(always)]
908 pub fn is_invisible(&self) -> bool {
909 **self == CTIMER0_IRQ_A::INVISIBLE
910 }
911 #[doc = "Checks if the value of the field is `VISIBLE`"]
912 #[inline(always)]
913 pub fn is_visible(&self) -> bool {
914 **self == CTIMER0_IRQ_A::VISIBLE
915 }
916}
917impl core::ops::Deref for CTIMER0_IRQ_R {
918 type Target = crate::FieldReader<bool, CTIMER0_IRQ_A>;
919 #[inline(always)]
920 fn deref(&self) -> &Self::Target {
921 &self.0
922 }
923}
924#[doc = "Field `CTIMER0_IRQ` writer - Standard counter/timer 0 interrupt."]
925pub struct CTIMER0_IRQ_W<'a> {
926 w: &'a mut W,
927}
928impl<'a> CTIMER0_IRQ_W<'a> {
929 #[doc = r"Writes `variant` to the field"]
930 #[inline(always)]
931 pub fn variant(self, variant: CTIMER0_IRQ_A) -> &'a mut W {
932 self.bit(variant.into())
933 }
934 #[doc = "no description available"]
935 #[inline(always)]
936 pub fn invisible(self) -> &'a mut W {
937 self.variant(CTIMER0_IRQ_A::INVISIBLE)
938 }
939 #[doc = "no description available"]
940 #[inline(always)]
941 pub fn visible(self) -> &'a mut W {
942 self.variant(CTIMER0_IRQ_A::VISIBLE)
943 }
944 #[doc = r"Sets the field bit"]
945 #[inline(always)]
946 pub fn set_bit(self) -> &'a mut W {
947 self.bit(true)
948 }
949 #[doc = r"Clears the field bit"]
950 #[inline(always)]
951 pub fn clear_bit(self) -> &'a mut W {
952 self.bit(false)
953 }
954 #[doc = r"Writes raw bits to the field"]
955 #[inline(always)]
956 pub fn bit(self, value: bool) -> &'a mut W {
957 self.w.bits = (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
958 self.w
959 }
960}
961#[doc = "Standard counter/timer 1 interrupt.\n\nValue on reset: 1"]
962#[derive(Clone, Copy, Debug, PartialEq)]
963pub enum CTIMER1_IRQ_A {
964 #[doc = "0: no description available"]
965 INVISIBLE = 0,
966 #[doc = "1: no description available"]
967 VISIBLE = 1,
968}
969impl From<CTIMER1_IRQ_A> for bool {
970 #[inline(always)]
971 fn from(variant: CTIMER1_IRQ_A) -> Self {
972 variant as u8 != 0
973 }
974}
975#[doc = "Field `CTIMER1_IRQ` reader - Standard counter/timer 1 interrupt."]
976pub struct CTIMER1_IRQ_R(crate::FieldReader<bool, CTIMER1_IRQ_A>);
977impl CTIMER1_IRQ_R {
978 #[inline(always)]
979 pub(crate) fn new(bits: bool) -> Self {
980 CTIMER1_IRQ_R(crate::FieldReader::new(bits))
981 }
982 #[doc = r"Get enumerated values variant"]
983 #[inline(always)]
984 pub fn variant(&self) -> CTIMER1_IRQ_A {
985 match self.bits {
986 false => CTIMER1_IRQ_A::INVISIBLE,
987 true => CTIMER1_IRQ_A::VISIBLE,
988 }
989 }
990 #[doc = "Checks if the value of the field is `INVISIBLE`"]
991 #[inline(always)]
992 pub fn is_invisible(&self) -> bool {
993 **self == CTIMER1_IRQ_A::INVISIBLE
994 }
995 #[doc = "Checks if the value of the field is `VISIBLE`"]
996 #[inline(always)]
997 pub fn is_visible(&self) -> bool {
998 **self == CTIMER1_IRQ_A::VISIBLE
999 }
1000}
1001impl core::ops::Deref for CTIMER1_IRQ_R {
1002 type Target = crate::FieldReader<bool, CTIMER1_IRQ_A>;
1003 #[inline(always)]
1004 fn deref(&self) -> &Self::Target {
1005 &self.0
1006 }
1007}
1008#[doc = "Field `CTIMER1_IRQ` writer - Standard counter/timer 1 interrupt."]
1009pub struct CTIMER1_IRQ_W<'a> {
1010 w: &'a mut W,
1011}
1012impl<'a> CTIMER1_IRQ_W<'a> {
1013 #[doc = r"Writes `variant` to the field"]
1014 #[inline(always)]
1015 pub fn variant(self, variant: CTIMER1_IRQ_A) -> &'a mut W {
1016 self.bit(variant.into())
1017 }
1018 #[doc = "no description available"]
1019 #[inline(always)]
1020 pub fn invisible(self) -> &'a mut W {
1021 self.variant(CTIMER1_IRQ_A::INVISIBLE)
1022 }
1023 #[doc = "no description available"]
1024 #[inline(always)]
1025 pub fn visible(self) -> &'a mut W {
1026 self.variant(CTIMER1_IRQ_A::VISIBLE)
1027 }
1028 #[doc = r"Sets the field bit"]
1029 #[inline(always)]
1030 pub fn set_bit(self) -> &'a mut W {
1031 self.bit(true)
1032 }
1033 #[doc = r"Clears the field bit"]
1034 #[inline(always)]
1035 pub fn clear_bit(self) -> &'a mut W {
1036 self.bit(false)
1037 }
1038 #[doc = r"Writes raw bits to the field"]
1039 #[inline(always)]
1040 pub fn bit(self, value: bool) -> &'a mut W {
1041 self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
1042 self.w
1043 }
1044}
1045#[doc = "SCTimer/PWM interrupt.\n\nValue on reset: 1"]
1046#[derive(Clone, Copy, Debug, PartialEq)]
1047pub enum SCT_IRQ_A {
1048 #[doc = "0: no description available"]
1049 INVISIBLE = 0,
1050 #[doc = "1: no description available"]
1051 VISIBLE = 1,
1052}
1053impl From<SCT_IRQ_A> for bool {
1054 #[inline(always)]
1055 fn from(variant: SCT_IRQ_A) -> Self {
1056 variant as u8 != 0
1057 }
1058}
1059#[doc = "Field `SCT_IRQ` reader - SCTimer/PWM interrupt."]
1060pub struct SCT_IRQ_R(crate::FieldReader<bool, SCT_IRQ_A>);
1061impl SCT_IRQ_R {
1062 #[inline(always)]
1063 pub(crate) fn new(bits: bool) -> Self {
1064 SCT_IRQ_R(crate::FieldReader::new(bits))
1065 }
1066 #[doc = r"Get enumerated values variant"]
1067 #[inline(always)]
1068 pub fn variant(&self) -> SCT_IRQ_A {
1069 match self.bits {
1070 false => SCT_IRQ_A::INVISIBLE,
1071 true => SCT_IRQ_A::VISIBLE,
1072 }
1073 }
1074 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1075 #[inline(always)]
1076 pub fn is_invisible(&self) -> bool {
1077 **self == SCT_IRQ_A::INVISIBLE
1078 }
1079 #[doc = "Checks if the value of the field is `VISIBLE`"]
1080 #[inline(always)]
1081 pub fn is_visible(&self) -> bool {
1082 **self == SCT_IRQ_A::VISIBLE
1083 }
1084}
1085impl core::ops::Deref for SCT_IRQ_R {
1086 type Target = crate::FieldReader<bool, SCT_IRQ_A>;
1087 #[inline(always)]
1088 fn deref(&self) -> &Self::Target {
1089 &self.0
1090 }
1091}
1092#[doc = "Field `SCT_IRQ` writer - SCTimer/PWM interrupt."]
1093pub struct SCT_IRQ_W<'a> {
1094 w: &'a mut W,
1095}
1096impl<'a> SCT_IRQ_W<'a> {
1097 #[doc = r"Writes `variant` to the field"]
1098 #[inline(always)]
1099 pub fn variant(self, variant: SCT_IRQ_A) -> &'a mut W {
1100 self.bit(variant.into())
1101 }
1102 #[doc = "no description available"]
1103 #[inline(always)]
1104 pub fn invisible(self) -> &'a mut W {
1105 self.variant(SCT_IRQ_A::INVISIBLE)
1106 }
1107 #[doc = "no description available"]
1108 #[inline(always)]
1109 pub fn visible(self) -> &'a mut W {
1110 self.variant(SCT_IRQ_A::VISIBLE)
1111 }
1112 #[doc = r"Sets the field bit"]
1113 #[inline(always)]
1114 pub fn set_bit(self) -> &'a mut W {
1115 self.bit(true)
1116 }
1117 #[doc = r"Clears the field bit"]
1118 #[inline(always)]
1119 pub fn clear_bit(self) -> &'a mut W {
1120 self.bit(false)
1121 }
1122 #[doc = r"Writes raw bits to the field"]
1123 #[inline(always)]
1124 pub fn bit(self, value: bool) -> &'a mut W {
1125 self.w.bits = (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
1126 self.w
1127 }
1128}
1129#[doc = "Standard counter/timer 3 interrupt.\n\nValue on reset: 1"]
1130#[derive(Clone, Copy, Debug, PartialEq)]
1131pub enum CTIMER3_IRQ_A {
1132 #[doc = "0: no description available"]
1133 INVISIBLE = 0,
1134 #[doc = "1: no description available"]
1135 VISIBLE = 1,
1136}
1137impl From<CTIMER3_IRQ_A> for bool {
1138 #[inline(always)]
1139 fn from(variant: CTIMER3_IRQ_A) -> Self {
1140 variant as u8 != 0
1141 }
1142}
1143#[doc = "Field `CTIMER3_IRQ` reader - Standard counter/timer 3 interrupt."]
1144pub struct CTIMER3_IRQ_R(crate::FieldReader<bool, CTIMER3_IRQ_A>);
1145impl CTIMER3_IRQ_R {
1146 #[inline(always)]
1147 pub(crate) fn new(bits: bool) -> Self {
1148 CTIMER3_IRQ_R(crate::FieldReader::new(bits))
1149 }
1150 #[doc = r"Get enumerated values variant"]
1151 #[inline(always)]
1152 pub fn variant(&self) -> CTIMER3_IRQ_A {
1153 match self.bits {
1154 false => CTIMER3_IRQ_A::INVISIBLE,
1155 true => CTIMER3_IRQ_A::VISIBLE,
1156 }
1157 }
1158 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1159 #[inline(always)]
1160 pub fn is_invisible(&self) -> bool {
1161 **self == CTIMER3_IRQ_A::INVISIBLE
1162 }
1163 #[doc = "Checks if the value of the field is `VISIBLE`"]
1164 #[inline(always)]
1165 pub fn is_visible(&self) -> bool {
1166 **self == CTIMER3_IRQ_A::VISIBLE
1167 }
1168}
1169impl core::ops::Deref for CTIMER3_IRQ_R {
1170 type Target = crate::FieldReader<bool, CTIMER3_IRQ_A>;
1171 #[inline(always)]
1172 fn deref(&self) -> &Self::Target {
1173 &self.0
1174 }
1175}
1176#[doc = "Field `CTIMER3_IRQ` writer - Standard counter/timer 3 interrupt."]
1177pub struct CTIMER3_IRQ_W<'a> {
1178 w: &'a mut W,
1179}
1180impl<'a> CTIMER3_IRQ_W<'a> {
1181 #[doc = r"Writes `variant` to the field"]
1182 #[inline(always)]
1183 pub fn variant(self, variant: CTIMER3_IRQ_A) -> &'a mut W {
1184 self.bit(variant.into())
1185 }
1186 #[doc = "no description available"]
1187 #[inline(always)]
1188 pub fn invisible(self) -> &'a mut W {
1189 self.variant(CTIMER3_IRQ_A::INVISIBLE)
1190 }
1191 #[doc = "no description available"]
1192 #[inline(always)]
1193 pub fn visible(self) -> &'a mut W {
1194 self.variant(CTIMER3_IRQ_A::VISIBLE)
1195 }
1196 #[doc = r"Sets the field bit"]
1197 #[inline(always)]
1198 pub fn set_bit(self) -> &'a mut W {
1199 self.bit(true)
1200 }
1201 #[doc = r"Clears the field bit"]
1202 #[inline(always)]
1203 pub fn clear_bit(self) -> &'a mut W {
1204 self.bit(false)
1205 }
1206 #[doc = r"Writes raw bits to the field"]
1207 #[inline(always)]
1208 pub fn bit(self, value: bool) -> &'a mut W {
1209 self.w.bits = (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
1210 self.w
1211 }
1212}
1213#[doc = "Flexcomm 0 interrupt (USART, SPI, I2C, I2S).\n\nValue on reset: 1"]
1214#[derive(Clone, Copy, Debug, PartialEq)]
1215pub enum FLEXCOMM0_IRQ_A {
1216 #[doc = "0: no description available"]
1217 INVISIBLE = 0,
1218 #[doc = "1: no description available"]
1219 VISIBLE = 1,
1220}
1221impl From<FLEXCOMM0_IRQ_A> for bool {
1222 #[inline(always)]
1223 fn from(variant: FLEXCOMM0_IRQ_A) -> Self {
1224 variant as u8 != 0
1225 }
1226}
1227#[doc = "Field `FLEXCOMM0_IRQ` reader - Flexcomm 0 interrupt (USART, SPI, I2C, I2S)."]
1228pub struct FLEXCOMM0_IRQ_R(crate::FieldReader<bool, FLEXCOMM0_IRQ_A>);
1229impl FLEXCOMM0_IRQ_R {
1230 #[inline(always)]
1231 pub(crate) fn new(bits: bool) -> Self {
1232 FLEXCOMM0_IRQ_R(crate::FieldReader::new(bits))
1233 }
1234 #[doc = r"Get enumerated values variant"]
1235 #[inline(always)]
1236 pub fn variant(&self) -> FLEXCOMM0_IRQ_A {
1237 match self.bits {
1238 false => FLEXCOMM0_IRQ_A::INVISIBLE,
1239 true => FLEXCOMM0_IRQ_A::VISIBLE,
1240 }
1241 }
1242 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1243 #[inline(always)]
1244 pub fn is_invisible(&self) -> bool {
1245 **self == FLEXCOMM0_IRQ_A::INVISIBLE
1246 }
1247 #[doc = "Checks if the value of the field is `VISIBLE`"]
1248 #[inline(always)]
1249 pub fn is_visible(&self) -> bool {
1250 **self == FLEXCOMM0_IRQ_A::VISIBLE
1251 }
1252}
1253impl core::ops::Deref for FLEXCOMM0_IRQ_R {
1254 type Target = crate::FieldReader<bool, FLEXCOMM0_IRQ_A>;
1255 #[inline(always)]
1256 fn deref(&self) -> &Self::Target {
1257 &self.0
1258 }
1259}
1260#[doc = "Field `FLEXCOMM0_IRQ` writer - Flexcomm 0 interrupt (USART, SPI, I2C, I2S)."]
1261pub struct FLEXCOMM0_IRQ_W<'a> {
1262 w: &'a mut W,
1263}
1264impl<'a> FLEXCOMM0_IRQ_W<'a> {
1265 #[doc = r"Writes `variant` to the field"]
1266 #[inline(always)]
1267 pub fn variant(self, variant: FLEXCOMM0_IRQ_A) -> &'a mut W {
1268 self.bit(variant.into())
1269 }
1270 #[doc = "no description available"]
1271 #[inline(always)]
1272 pub fn invisible(self) -> &'a mut W {
1273 self.variant(FLEXCOMM0_IRQ_A::INVISIBLE)
1274 }
1275 #[doc = "no description available"]
1276 #[inline(always)]
1277 pub fn visible(self) -> &'a mut W {
1278 self.variant(FLEXCOMM0_IRQ_A::VISIBLE)
1279 }
1280 #[doc = r"Sets the field bit"]
1281 #[inline(always)]
1282 pub fn set_bit(self) -> &'a mut W {
1283 self.bit(true)
1284 }
1285 #[doc = r"Clears the field bit"]
1286 #[inline(always)]
1287 pub fn clear_bit(self) -> &'a mut W {
1288 self.bit(false)
1289 }
1290 #[doc = r"Writes raw bits to the field"]
1291 #[inline(always)]
1292 pub fn bit(self, value: bool) -> &'a mut W {
1293 self.w.bits = (self.w.bits & !(0x01 << 14)) | ((value as u32 & 0x01) << 14);
1294 self.w
1295 }
1296}
1297#[doc = "Flexcomm 1 interrupt (USART, SPI, I2C, I2S).\n\nValue on reset: 1"]
1298#[derive(Clone, Copy, Debug, PartialEq)]
1299pub enum FLEXCOMM1_IRQ_A {
1300 #[doc = "0: no description available"]
1301 INVISIBLE = 0,
1302 #[doc = "1: no description available"]
1303 VISIBLE = 1,
1304}
1305impl From<FLEXCOMM1_IRQ_A> for bool {
1306 #[inline(always)]
1307 fn from(variant: FLEXCOMM1_IRQ_A) -> Self {
1308 variant as u8 != 0
1309 }
1310}
1311#[doc = "Field `FLEXCOMM1_IRQ` reader - Flexcomm 1 interrupt (USART, SPI, I2C, I2S)."]
1312pub struct FLEXCOMM1_IRQ_R(crate::FieldReader<bool, FLEXCOMM1_IRQ_A>);
1313impl FLEXCOMM1_IRQ_R {
1314 #[inline(always)]
1315 pub(crate) fn new(bits: bool) -> Self {
1316 FLEXCOMM1_IRQ_R(crate::FieldReader::new(bits))
1317 }
1318 #[doc = r"Get enumerated values variant"]
1319 #[inline(always)]
1320 pub fn variant(&self) -> FLEXCOMM1_IRQ_A {
1321 match self.bits {
1322 false => FLEXCOMM1_IRQ_A::INVISIBLE,
1323 true => FLEXCOMM1_IRQ_A::VISIBLE,
1324 }
1325 }
1326 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1327 #[inline(always)]
1328 pub fn is_invisible(&self) -> bool {
1329 **self == FLEXCOMM1_IRQ_A::INVISIBLE
1330 }
1331 #[doc = "Checks if the value of the field is `VISIBLE`"]
1332 #[inline(always)]
1333 pub fn is_visible(&self) -> bool {
1334 **self == FLEXCOMM1_IRQ_A::VISIBLE
1335 }
1336}
1337impl core::ops::Deref for FLEXCOMM1_IRQ_R {
1338 type Target = crate::FieldReader<bool, FLEXCOMM1_IRQ_A>;
1339 #[inline(always)]
1340 fn deref(&self) -> &Self::Target {
1341 &self.0
1342 }
1343}
1344#[doc = "Field `FLEXCOMM1_IRQ` writer - Flexcomm 1 interrupt (USART, SPI, I2C, I2S)."]
1345pub struct FLEXCOMM1_IRQ_W<'a> {
1346 w: &'a mut W,
1347}
1348impl<'a> FLEXCOMM1_IRQ_W<'a> {
1349 #[doc = r"Writes `variant` to the field"]
1350 #[inline(always)]
1351 pub fn variant(self, variant: FLEXCOMM1_IRQ_A) -> &'a mut W {
1352 self.bit(variant.into())
1353 }
1354 #[doc = "no description available"]
1355 #[inline(always)]
1356 pub fn invisible(self) -> &'a mut W {
1357 self.variant(FLEXCOMM1_IRQ_A::INVISIBLE)
1358 }
1359 #[doc = "no description available"]
1360 #[inline(always)]
1361 pub fn visible(self) -> &'a mut W {
1362 self.variant(FLEXCOMM1_IRQ_A::VISIBLE)
1363 }
1364 #[doc = r"Sets the field bit"]
1365 #[inline(always)]
1366 pub fn set_bit(self) -> &'a mut W {
1367 self.bit(true)
1368 }
1369 #[doc = r"Clears the field bit"]
1370 #[inline(always)]
1371 pub fn clear_bit(self) -> &'a mut W {
1372 self.bit(false)
1373 }
1374 #[doc = r"Writes raw bits to the field"]
1375 #[inline(always)]
1376 pub fn bit(self, value: bool) -> &'a mut W {
1377 self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
1378 self.w
1379 }
1380}
1381#[doc = "Flexcomm 2 interrupt (USART, SPI, I2C, I2S).\n\nValue on reset: 1"]
1382#[derive(Clone, Copy, Debug, PartialEq)]
1383pub enum FLEXCOMM2_IRQ_A {
1384 #[doc = "0: no description available"]
1385 INVISIBLE = 0,
1386 #[doc = "1: no description available"]
1387 VISIBLE = 1,
1388}
1389impl From<FLEXCOMM2_IRQ_A> for bool {
1390 #[inline(always)]
1391 fn from(variant: FLEXCOMM2_IRQ_A) -> Self {
1392 variant as u8 != 0
1393 }
1394}
1395#[doc = "Field `FLEXCOMM2_IRQ` reader - Flexcomm 2 interrupt (USART, SPI, I2C, I2S)."]
1396pub struct FLEXCOMM2_IRQ_R(crate::FieldReader<bool, FLEXCOMM2_IRQ_A>);
1397impl FLEXCOMM2_IRQ_R {
1398 #[inline(always)]
1399 pub(crate) fn new(bits: bool) -> Self {
1400 FLEXCOMM2_IRQ_R(crate::FieldReader::new(bits))
1401 }
1402 #[doc = r"Get enumerated values variant"]
1403 #[inline(always)]
1404 pub fn variant(&self) -> FLEXCOMM2_IRQ_A {
1405 match self.bits {
1406 false => FLEXCOMM2_IRQ_A::INVISIBLE,
1407 true => FLEXCOMM2_IRQ_A::VISIBLE,
1408 }
1409 }
1410 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1411 #[inline(always)]
1412 pub fn is_invisible(&self) -> bool {
1413 **self == FLEXCOMM2_IRQ_A::INVISIBLE
1414 }
1415 #[doc = "Checks if the value of the field is `VISIBLE`"]
1416 #[inline(always)]
1417 pub fn is_visible(&self) -> bool {
1418 **self == FLEXCOMM2_IRQ_A::VISIBLE
1419 }
1420}
1421impl core::ops::Deref for FLEXCOMM2_IRQ_R {
1422 type Target = crate::FieldReader<bool, FLEXCOMM2_IRQ_A>;
1423 #[inline(always)]
1424 fn deref(&self) -> &Self::Target {
1425 &self.0
1426 }
1427}
1428#[doc = "Field `FLEXCOMM2_IRQ` writer - Flexcomm 2 interrupt (USART, SPI, I2C, I2S)."]
1429pub struct FLEXCOMM2_IRQ_W<'a> {
1430 w: &'a mut W,
1431}
1432impl<'a> FLEXCOMM2_IRQ_W<'a> {
1433 #[doc = r"Writes `variant` to the field"]
1434 #[inline(always)]
1435 pub fn variant(self, variant: FLEXCOMM2_IRQ_A) -> &'a mut W {
1436 self.bit(variant.into())
1437 }
1438 #[doc = "no description available"]
1439 #[inline(always)]
1440 pub fn invisible(self) -> &'a mut W {
1441 self.variant(FLEXCOMM2_IRQ_A::INVISIBLE)
1442 }
1443 #[doc = "no description available"]
1444 #[inline(always)]
1445 pub fn visible(self) -> &'a mut W {
1446 self.variant(FLEXCOMM2_IRQ_A::VISIBLE)
1447 }
1448 #[doc = r"Sets the field bit"]
1449 #[inline(always)]
1450 pub fn set_bit(self) -> &'a mut W {
1451 self.bit(true)
1452 }
1453 #[doc = r"Clears the field bit"]
1454 #[inline(always)]
1455 pub fn clear_bit(self) -> &'a mut W {
1456 self.bit(false)
1457 }
1458 #[doc = r"Writes raw bits to the field"]
1459 #[inline(always)]
1460 pub fn bit(self, value: bool) -> &'a mut W {
1461 self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
1462 self.w
1463 }
1464}
1465#[doc = "Flexcomm 3 interrupt (USART, SPI, I2C, I2S).\n\nValue on reset: 1"]
1466#[derive(Clone, Copy, Debug, PartialEq)]
1467pub enum FLEXCOMM3_IRQ_A {
1468 #[doc = "0: no description available"]
1469 INVISIBLE = 0,
1470 #[doc = "1: no description available"]
1471 VISIBLE = 1,
1472}
1473impl From<FLEXCOMM3_IRQ_A> for bool {
1474 #[inline(always)]
1475 fn from(variant: FLEXCOMM3_IRQ_A) -> Self {
1476 variant as u8 != 0
1477 }
1478}
1479#[doc = "Field `FLEXCOMM3_IRQ` reader - Flexcomm 3 interrupt (USART, SPI, I2C, I2S)."]
1480pub struct FLEXCOMM3_IRQ_R(crate::FieldReader<bool, FLEXCOMM3_IRQ_A>);
1481impl FLEXCOMM3_IRQ_R {
1482 #[inline(always)]
1483 pub(crate) fn new(bits: bool) -> Self {
1484 FLEXCOMM3_IRQ_R(crate::FieldReader::new(bits))
1485 }
1486 #[doc = r"Get enumerated values variant"]
1487 #[inline(always)]
1488 pub fn variant(&self) -> FLEXCOMM3_IRQ_A {
1489 match self.bits {
1490 false => FLEXCOMM3_IRQ_A::INVISIBLE,
1491 true => FLEXCOMM3_IRQ_A::VISIBLE,
1492 }
1493 }
1494 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1495 #[inline(always)]
1496 pub fn is_invisible(&self) -> bool {
1497 **self == FLEXCOMM3_IRQ_A::INVISIBLE
1498 }
1499 #[doc = "Checks if the value of the field is `VISIBLE`"]
1500 #[inline(always)]
1501 pub fn is_visible(&self) -> bool {
1502 **self == FLEXCOMM3_IRQ_A::VISIBLE
1503 }
1504}
1505impl core::ops::Deref for FLEXCOMM3_IRQ_R {
1506 type Target = crate::FieldReader<bool, FLEXCOMM3_IRQ_A>;
1507 #[inline(always)]
1508 fn deref(&self) -> &Self::Target {
1509 &self.0
1510 }
1511}
1512#[doc = "Field `FLEXCOMM3_IRQ` writer - Flexcomm 3 interrupt (USART, SPI, I2C, I2S)."]
1513pub struct FLEXCOMM3_IRQ_W<'a> {
1514 w: &'a mut W,
1515}
1516impl<'a> FLEXCOMM3_IRQ_W<'a> {
1517 #[doc = r"Writes `variant` to the field"]
1518 #[inline(always)]
1519 pub fn variant(self, variant: FLEXCOMM3_IRQ_A) -> &'a mut W {
1520 self.bit(variant.into())
1521 }
1522 #[doc = "no description available"]
1523 #[inline(always)]
1524 pub fn invisible(self) -> &'a mut W {
1525 self.variant(FLEXCOMM3_IRQ_A::INVISIBLE)
1526 }
1527 #[doc = "no description available"]
1528 #[inline(always)]
1529 pub fn visible(self) -> &'a mut W {
1530 self.variant(FLEXCOMM3_IRQ_A::VISIBLE)
1531 }
1532 #[doc = r"Sets the field bit"]
1533 #[inline(always)]
1534 pub fn set_bit(self) -> &'a mut W {
1535 self.bit(true)
1536 }
1537 #[doc = r"Clears the field bit"]
1538 #[inline(always)]
1539 pub fn clear_bit(self) -> &'a mut W {
1540 self.bit(false)
1541 }
1542 #[doc = r"Writes raw bits to the field"]
1543 #[inline(always)]
1544 pub fn bit(self, value: bool) -> &'a mut W {
1545 self.w.bits = (self.w.bits & !(0x01 << 17)) | ((value as u32 & 0x01) << 17);
1546 self.w
1547 }
1548}
1549#[doc = "Flexcomm 4 interrupt (USART, SPI, I2C, I2S).\n\nValue on reset: 1"]
1550#[derive(Clone, Copy, Debug, PartialEq)]
1551pub enum FLEXCOMM4_IRQ_A {
1552 #[doc = "0: no description available"]
1553 INVISIBLE = 0,
1554 #[doc = "1: no description available"]
1555 VISIBLE = 1,
1556}
1557impl From<FLEXCOMM4_IRQ_A> for bool {
1558 #[inline(always)]
1559 fn from(variant: FLEXCOMM4_IRQ_A) -> Self {
1560 variant as u8 != 0
1561 }
1562}
1563#[doc = "Field `FLEXCOMM4_IRQ` reader - Flexcomm 4 interrupt (USART, SPI, I2C, I2S)."]
1564pub struct FLEXCOMM4_IRQ_R(crate::FieldReader<bool, FLEXCOMM4_IRQ_A>);
1565impl FLEXCOMM4_IRQ_R {
1566 #[inline(always)]
1567 pub(crate) fn new(bits: bool) -> Self {
1568 FLEXCOMM4_IRQ_R(crate::FieldReader::new(bits))
1569 }
1570 #[doc = r"Get enumerated values variant"]
1571 #[inline(always)]
1572 pub fn variant(&self) -> FLEXCOMM4_IRQ_A {
1573 match self.bits {
1574 false => FLEXCOMM4_IRQ_A::INVISIBLE,
1575 true => FLEXCOMM4_IRQ_A::VISIBLE,
1576 }
1577 }
1578 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1579 #[inline(always)]
1580 pub fn is_invisible(&self) -> bool {
1581 **self == FLEXCOMM4_IRQ_A::INVISIBLE
1582 }
1583 #[doc = "Checks if the value of the field is `VISIBLE`"]
1584 #[inline(always)]
1585 pub fn is_visible(&self) -> bool {
1586 **self == FLEXCOMM4_IRQ_A::VISIBLE
1587 }
1588}
1589impl core::ops::Deref for FLEXCOMM4_IRQ_R {
1590 type Target = crate::FieldReader<bool, FLEXCOMM4_IRQ_A>;
1591 #[inline(always)]
1592 fn deref(&self) -> &Self::Target {
1593 &self.0
1594 }
1595}
1596#[doc = "Field `FLEXCOMM4_IRQ` writer - Flexcomm 4 interrupt (USART, SPI, I2C, I2S)."]
1597pub struct FLEXCOMM4_IRQ_W<'a> {
1598 w: &'a mut W,
1599}
1600impl<'a> FLEXCOMM4_IRQ_W<'a> {
1601 #[doc = r"Writes `variant` to the field"]
1602 #[inline(always)]
1603 pub fn variant(self, variant: FLEXCOMM4_IRQ_A) -> &'a mut W {
1604 self.bit(variant.into())
1605 }
1606 #[doc = "no description available"]
1607 #[inline(always)]
1608 pub fn invisible(self) -> &'a mut W {
1609 self.variant(FLEXCOMM4_IRQ_A::INVISIBLE)
1610 }
1611 #[doc = "no description available"]
1612 #[inline(always)]
1613 pub fn visible(self) -> &'a mut W {
1614 self.variant(FLEXCOMM4_IRQ_A::VISIBLE)
1615 }
1616 #[doc = r"Sets the field bit"]
1617 #[inline(always)]
1618 pub fn set_bit(self) -> &'a mut W {
1619 self.bit(true)
1620 }
1621 #[doc = r"Clears the field bit"]
1622 #[inline(always)]
1623 pub fn clear_bit(self) -> &'a mut W {
1624 self.bit(false)
1625 }
1626 #[doc = r"Writes raw bits to the field"]
1627 #[inline(always)]
1628 pub fn bit(self, value: bool) -> &'a mut W {
1629 self.w.bits = (self.w.bits & !(0x01 << 18)) | ((value as u32 & 0x01) << 18);
1630 self.w
1631 }
1632}
1633#[doc = "Flexcomm 5 interrupt (USART, SPI, I2C, I2S).\n\nValue on reset: 1"]
1634#[derive(Clone, Copy, Debug, PartialEq)]
1635pub enum FLEXCOMM5_IRQ_A {
1636 #[doc = "0: no description available"]
1637 INVISIBLE = 0,
1638 #[doc = "1: no description available"]
1639 VISIBLE = 1,
1640}
1641impl From<FLEXCOMM5_IRQ_A> for bool {
1642 #[inline(always)]
1643 fn from(variant: FLEXCOMM5_IRQ_A) -> Self {
1644 variant as u8 != 0
1645 }
1646}
1647#[doc = "Field `FLEXCOMM5_IRQ` reader - Flexcomm 5 interrupt (USART, SPI, I2C, I2S)."]
1648pub struct FLEXCOMM5_IRQ_R(crate::FieldReader<bool, FLEXCOMM5_IRQ_A>);
1649impl FLEXCOMM5_IRQ_R {
1650 #[inline(always)]
1651 pub(crate) fn new(bits: bool) -> Self {
1652 FLEXCOMM5_IRQ_R(crate::FieldReader::new(bits))
1653 }
1654 #[doc = r"Get enumerated values variant"]
1655 #[inline(always)]
1656 pub fn variant(&self) -> FLEXCOMM5_IRQ_A {
1657 match self.bits {
1658 false => FLEXCOMM5_IRQ_A::INVISIBLE,
1659 true => FLEXCOMM5_IRQ_A::VISIBLE,
1660 }
1661 }
1662 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1663 #[inline(always)]
1664 pub fn is_invisible(&self) -> bool {
1665 **self == FLEXCOMM5_IRQ_A::INVISIBLE
1666 }
1667 #[doc = "Checks if the value of the field is `VISIBLE`"]
1668 #[inline(always)]
1669 pub fn is_visible(&self) -> bool {
1670 **self == FLEXCOMM5_IRQ_A::VISIBLE
1671 }
1672}
1673impl core::ops::Deref for FLEXCOMM5_IRQ_R {
1674 type Target = crate::FieldReader<bool, FLEXCOMM5_IRQ_A>;
1675 #[inline(always)]
1676 fn deref(&self) -> &Self::Target {
1677 &self.0
1678 }
1679}
1680#[doc = "Field `FLEXCOMM5_IRQ` writer - Flexcomm 5 interrupt (USART, SPI, I2C, I2S)."]
1681pub struct FLEXCOMM5_IRQ_W<'a> {
1682 w: &'a mut W,
1683}
1684impl<'a> FLEXCOMM5_IRQ_W<'a> {
1685 #[doc = r"Writes `variant` to the field"]
1686 #[inline(always)]
1687 pub fn variant(self, variant: FLEXCOMM5_IRQ_A) -> &'a mut W {
1688 self.bit(variant.into())
1689 }
1690 #[doc = "no description available"]
1691 #[inline(always)]
1692 pub fn invisible(self) -> &'a mut W {
1693 self.variant(FLEXCOMM5_IRQ_A::INVISIBLE)
1694 }
1695 #[doc = "no description available"]
1696 #[inline(always)]
1697 pub fn visible(self) -> &'a mut W {
1698 self.variant(FLEXCOMM5_IRQ_A::VISIBLE)
1699 }
1700 #[doc = r"Sets the field bit"]
1701 #[inline(always)]
1702 pub fn set_bit(self) -> &'a mut W {
1703 self.bit(true)
1704 }
1705 #[doc = r"Clears the field bit"]
1706 #[inline(always)]
1707 pub fn clear_bit(self) -> &'a mut W {
1708 self.bit(false)
1709 }
1710 #[doc = r"Writes raw bits to the field"]
1711 #[inline(always)]
1712 pub fn bit(self, value: bool) -> &'a mut W {
1713 self.w.bits = (self.w.bits & !(0x01 << 19)) | ((value as u32 & 0x01) << 19);
1714 self.w
1715 }
1716}
1717#[doc = "Flexcomm 6 interrupt (USART, SPI, I2C, I2S).\n\nValue on reset: 1"]
1718#[derive(Clone, Copy, Debug, PartialEq)]
1719pub enum FLEXCOMM6_IRQ_A {
1720 #[doc = "0: no description available"]
1721 INVISIBLE = 0,
1722 #[doc = "1: no description available"]
1723 VISIBLE = 1,
1724}
1725impl From<FLEXCOMM6_IRQ_A> for bool {
1726 #[inline(always)]
1727 fn from(variant: FLEXCOMM6_IRQ_A) -> Self {
1728 variant as u8 != 0
1729 }
1730}
1731#[doc = "Field `FLEXCOMM6_IRQ` reader - Flexcomm 6 interrupt (USART, SPI, I2C, I2S)."]
1732pub struct FLEXCOMM6_IRQ_R(crate::FieldReader<bool, FLEXCOMM6_IRQ_A>);
1733impl FLEXCOMM6_IRQ_R {
1734 #[inline(always)]
1735 pub(crate) fn new(bits: bool) -> Self {
1736 FLEXCOMM6_IRQ_R(crate::FieldReader::new(bits))
1737 }
1738 #[doc = r"Get enumerated values variant"]
1739 #[inline(always)]
1740 pub fn variant(&self) -> FLEXCOMM6_IRQ_A {
1741 match self.bits {
1742 false => FLEXCOMM6_IRQ_A::INVISIBLE,
1743 true => FLEXCOMM6_IRQ_A::VISIBLE,
1744 }
1745 }
1746 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1747 #[inline(always)]
1748 pub fn is_invisible(&self) -> bool {
1749 **self == FLEXCOMM6_IRQ_A::INVISIBLE
1750 }
1751 #[doc = "Checks if the value of the field is `VISIBLE`"]
1752 #[inline(always)]
1753 pub fn is_visible(&self) -> bool {
1754 **self == FLEXCOMM6_IRQ_A::VISIBLE
1755 }
1756}
1757impl core::ops::Deref for FLEXCOMM6_IRQ_R {
1758 type Target = crate::FieldReader<bool, FLEXCOMM6_IRQ_A>;
1759 #[inline(always)]
1760 fn deref(&self) -> &Self::Target {
1761 &self.0
1762 }
1763}
1764#[doc = "Field `FLEXCOMM6_IRQ` writer - Flexcomm 6 interrupt (USART, SPI, I2C, I2S)."]
1765pub struct FLEXCOMM6_IRQ_W<'a> {
1766 w: &'a mut W,
1767}
1768impl<'a> FLEXCOMM6_IRQ_W<'a> {
1769 #[doc = r"Writes `variant` to the field"]
1770 #[inline(always)]
1771 pub fn variant(self, variant: FLEXCOMM6_IRQ_A) -> &'a mut W {
1772 self.bit(variant.into())
1773 }
1774 #[doc = "no description available"]
1775 #[inline(always)]
1776 pub fn invisible(self) -> &'a mut W {
1777 self.variant(FLEXCOMM6_IRQ_A::INVISIBLE)
1778 }
1779 #[doc = "no description available"]
1780 #[inline(always)]
1781 pub fn visible(self) -> &'a mut W {
1782 self.variant(FLEXCOMM6_IRQ_A::VISIBLE)
1783 }
1784 #[doc = r"Sets the field bit"]
1785 #[inline(always)]
1786 pub fn set_bit(self) -> &'a mut W {
1787 self.bit(true)
1788 }
1789 #[doc = r"Clears the field bit"]
1790 #[inline(always)]
1791 pub fn clear_bit(self) -> &'a mut W {
1792 self.bit(false)
1793 }
1794 #[doc = r"Writes raw bits to the field"]
1795 #[inline(always)]
1796 pub fn bit(self, value: bool) -> &'a mut W {
1797 self.w.bits = (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
1798 self.w
1799 }
1800}
1801#[doc = "Flexcomm 7 interrupt (USART, SPI, I2C, I2S).\n\nValue on reset: 1"]
1802#[derive(Clone, Copy, Debug, PartialEq)]
1803pub enum FLEXCOMM7_IRQ_A {
1804 #[doc = "0: no description available"]
1805 INVISIBLE = 0,
1806 #[doc = "1: no description available"]
1807 VISIBLE = 1,
1808}
1809impl From<FLEXCOMM7_IRQ_A> for bool {
1810 #[inline(always)]
1811 fn from(variant: FLEXCOMM7_IRQ_A) -> Self {
1812 variant as u8 != 0
1813 }
1814}
1815#[doc = "Field `FLEXCOMM7_IRQ` reader - Flexcomm 7 interrupt (USART, SPI, I2C, I2S)."]
1816pub struct FLEXCOMM7_IRQ_R(crate::FieldReader<bool, FLEXCOMM7_IRQ_A>);
1817impl FLEXCOMM7_IRQ_R {
1818 #[inline(always)]
1819 pub(crate) fn new(bits: bool) -> Self {
1820 FLEXCOMM7_IRQ_R(crate::FieldReader::new(bits))
1821 }
1822 #[doc = r"Get enumerated values variant"]
1823 #[inline(always)]
1824 pub fn variant(&self) -> FLEXCOMM7_IRQ_A {
1825 match self.bits {
1826 false => FLEXCOMM7_IRQ_A::INVISIBLE,
1827 true => FLEXCOMM7_IRQ_A::VISIBLE,
1828 }
1829 }
1830 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1831 #[inline(always)]
1832 pub fn is_invisible(&self) -> bool {
1833 **self == FLEXCOMM7_IRQ_A::INVISIBLE
1834 }
1835 #[doc = "Checks if the value of the field is `VISIBLE`"]
1836 #[inline(always)]
1837 pub fn is_visible(&self) -> bool {
1838 **self == FLEXCOMM7_IRQ_A::VISIBLE
1839 }
1840}
1841impl core::ops::Deref for FLEXCOMM7_IRQ_R {
1842 type Target = crate::FieldReader<bool, FLEXCOMM7_IRQ_A>;
1843 #[inline(always)]
1844 fn deref(&self) -> &Self::Target {
1845 &self.0
1846 }
1847}
1848#[doc = "Field `FLEXCOMM7_IRQ` writer - Flexcomm 7 interrupt (USART, SPI, I2C, I2S)."]
1849pub struct FLEXCOMM7_IRQ_W<'a> {
1850 w: &'a mut W,
1851}
1852impl<'a> FLEXCOMM7_IRQ_W<'a> {
1853 #[doc = r"Writes `variant` to the field"]
1854 #[inline(always)]
1855 pub fn variant(self, variant: FLEXCOMM7_IRQ_A) -> &'a mut W {
1856 self.bit(variant.into())
1857 }
1858 #[doc = "no description available"]
1859 #[inline(always)]
1860 pub fn invisible(self) -> &'a mut W {
1861 self.variant(FLEXCOMM7_IRQ_A::INVISIBLE)
1862 }
1863 #[doc = "no description available"]
1864 #[inline(always)]
1865 pub fn visible(self) -> &'a mut W {
1866 self.variant(FLEXCOMM7_IRQ_A::VISIBLE)
1867 }
1868 #[doc = r"Sets the field bit"]
1869 #[inline(always)]
1870 pub fn set_bit(self) -> &'a mut W {
1871 self.bit(true)
1872 }
1873 #[doc = r"Clears the field bit"]
1874 #[inline(always)]
1875 pub fn clear_bit(self) -> &'a mut W {
1876 self.bit(false)
1877 }
1878 #[doc = r"Writes raw bits to the field"]
1879 #[inline(always)]
1880 pub fn bit(self, value: bool) -> &'a mut W {
1881 self.w.bits = (self.w.bits & !(0x01 << 21)) | ((value as u32 & 0x01) << 21);
1882 self.w
1883 }
1884}
1885#[doc = "General Purpose ADC interrupt.\n\nValue on reset: 1"]
1886#[derive(Clone, Copy, Debug, PartialEq)]
1887pub enum ADC_IRQ_A {
1888 #[doc = "0: no description available"]
1889 INVISIBLE = 0,
1890 #[doc = "1: no description available"]
1891 VISIBLE = 1,
1892}
1893impl From<ADC_IRQ_A> for bool {
1894 #[inline(always)]
1895 fn from(variant: ADC_IRQ_A) -> Self {
1896 variant as u8 != 0
1897 }
1898}
1899#[doc = "Field `ADC_IRQ` reader - General Purpose ADC interrupt."]
1900pub struct ADC_IRQ_R(crate::FieldReader<bool, ADC_IRQ_A>);
1901impl ADC_IRQ_R {
1902 #[inline(always)]
1903 pub(crate) fn new(bits: bool) -> Self {
1904 ADC_IRQ_R(crate::FieldReader::new(bits))
1905 }
1906 #[doc = r"Get enumerated values variant"]
1907 #[inline(always)]
1908 pub fn variant(&self) -> ADC_IRQ_A {
1909 match self.bits {
1910 false => ADC_IRQ_A::INVISIBLE,
1911 true => ADC_IRQ_A::VISIBLE,
1912 }
1913 }
1914 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1915 #[inline(always)]
1916 pub fn is_invisible(&self) -> bool {
1917 **self == ADC_IRQ_A::INVISIBLE
1918 }
1919 #[doc = "Checks if the value of the field is `VISIBLE`"]
1920 #[inline(always)]
1921 pub fn is_visible(&self) -> bool {
1922 **self == ADC_IRQ_A::VISIBLE
1923 }
1924}
1925impl core::ops::Deref for ADC_IRQ_R {
1926 type Target = crate::FieldReader<bool, ADC_IRQ_A>;
1927 #[inline(always)]
1928 fn deref(&self) -> &Self::Target {
1929 &self.0
1930 }
1931}
1932#[doc = "Field `ADC_IRQ` writer - General Purpose ADC interrupt."]
1933pub struct ADC_IRQ_W<'a> {
1934 w: &'a mut W,
1935}
1936impl<'a> ADC_IRQ_W<'a> {
1937 #[doc = r"Writes `variant` to the field"]
1938 #[inline(always)]
1939 pub fn variant(self, variant: ADC_IRQ_A) -> &'a mut W {
1940 self.bit(variant.into())
1941 }
1942 #[doc = "no description available"]
1943 #[inline(always)]
1944 pub fn invisible(self) -> &'a mut W {
1945 self.variant(ADC_IRQ_A::INVISIBLE)
1946 }
1947 #[doc = "no description available"]
1948 #[inline(always)]
1949 pub fn visible(self) -> &'a mut W {
1950 self.variant(ADC_IRQ_A::VISIBLE)
1951 }
1952 #[doc = r"Sets the field bit"]
1953 #[inline(always)]
1954 pub fn set_bit(self) -> &'a mut W {
1955 self.bit(true)
1956 }
1957 #[doc = r"Clears the field bit"]
1958 #[inline(always)]
1959 pub fn clear_bit(self) -> &'a mut W {
1960 self.bit(false)
1961 }
1962 #[doc = r"Writes raw bits to the field"]
1963 #[inline(always)]
1964 pub fn bit(self, value: bool) -> &'a mut W {
1965 self.w.bits = (self.w.bits & !(0x01 << 22)) | ((value as u32 & 0x01) << 22);
1966 self.w
1967 }
1968}
1969#[doc = "Reserved. Read value is undefined, only zero should be written.\n\nValue on reset: 1"]
1970#[derive(Clone, Copy, Debug, PartialEq)]
1971pub enum RESERVED0_A {
1972 #[doc = "0: no description available"]
1973 INVISIBLE = 0,
1974 #[doc = "1: no description available"]
1975 VISIBLE = 1,
1976}
1977impl From<RESERVED0_A> for bool {
1978 #[inline(always)]
1979 fn from(variant: RESERVED0_A) -> Self {
1980 variant as u8 != 0
1981 }
1982}
1983#[doc = "Field `RESERVED0` reader - Reserved. Read value is undefined, only zero should be written."]
1984pub struct RESERVED0_R(crate::FieldReader<bool, RESERVED0_A>);
1985impl RESERVED0_R {
1986 #[inline(always)]
1987 pub(crate) fn new(bits: bool) -> Self {
1988 RESERVED0_R(crate::FieldReader::new(bits))
1989 }
1990 #[doc = r"Get enumerated values variant"]
1991 #[inline(always)]
1992 pub fn variant(&self) -> RESERVED0_A {
1993 match self.bits {
1994 false => RESERVED0_A::INVISIBLE,
1995 true => RESERVED0_A::VISIBLE,
1996 }
1997 }
1998 #[doc = "Checks if the value of the field is `INVISIBLE`"]
1999 #[inline(always)]
2000 pub fn is_invisible(&self) -> bool {
2001 **self == RESERVED0_A::INVISIBLE
2002 }
2003 #[doc = "Checks if the value of the field is `VISIBLE`"]
2004 #[inline(always)]
2005 pub fn is_visible(&self) -> bool {
2006 **self == RESERVED0_A::VISIBLE
2007 }
2008}
2009impl core::ops::Deref for RESERVED0_R {
2010 type Target = crate::FieldReader<bool, RESERVED0_A>;
2011 #[inline(always)]
2012 fn deref(&self) -> &Self::Target {
2013 &self.0
2014 }
2015}
2016#[doc = "Field `RESERVED0` writer - Reserved. Read value is undefined, only zero should be written."]
2017pub struct RESERVED0_W<'a> {
2018 w: &'a mut W,
2019}
2020impl<'a> RESERVED0_W<'a> {
2021 #[doc = r"Writes `variant` to the field"]
2022 #[inline(always)]
2023 pub fn variant(self, variant: RESERVED0_A) -> &'a mut W {
2024 self.bit(variant.into())
2025 }
2026 #[doc = "no description available"]
2027 #[inline(always)]
2028 pub fn invisible(self) -> &'a mut W {
2029 self.variant(RESERVED0_A::INVISIBLE)
2030 }
2031 #[doc = "no description available"]
2032 #[inline(always)]
2033 pub fn visible(self) -> &'a mut W {
2034 self.variant(RESERVED0_A::VISIBLE)
2035 }
2036 #[doc = r"Sets the field bit"]
2037 #[inline(always)]
2038 pub fn set_bit(self) -> &'a mut W {
2039 self.bit(true)
2040 }
2041 #[doc = r"Clears the field bit"]
2042 #[inline(always)]
2043 pub fn clear_bit(self) -> &'a mut W {
2044 self.bit(false)
2045 }
2046 #[doc = r"Writes raw bits to the field"]
2047 #[inline(always)]
2048 pub fn bit(self, value: bool) -> &'a mut W {
2049 self.w.bits = (self.w.bits & !(0x01 << 23)) | ((value as u32 & 0x01) << 23);
2050 self.w
2051 }
2052}
2053#[doc = "Analog Comparator interrupt.\n\nValue on reset: 1"]
2054#[derive(Clone, Copy, Debug, PartialEq)]
2055pub enum ACMP_IRQ_A {
2056 #[doc = "0: no description available"]
2057 INVISIBLE = 0,
2058 #[doc = "1: no description available"]
2059 VISIBLE = 1,
2060}
2061impl From<ACMP_IRQ_A> for bool {
2062 #[inline(always)]
2063 fn from(variant: ACMP_IRQ_A) -> Self {
2064 variant as u8 != 0
2065 }
2066}
2067#[doc = "Field `ACMP_IRQ` reader - Analog Comparator interrupt."]
2068pub struct ACMP_IRQ_R(crate::FieldReader<bool, ACMP_IRQ_A>);
2069impl ACMP_IRQ_R {
2070 #[inline(always)]
2071 pub(crate) fn new(bits: bool) -> Self {
2072 ACMP_IRQ_R(crate::FieldReader::new(bits))
2073 }
2074 #[doc = r"Get enumerated values variant"]
2075 #[inline(always)]
2076 pub fn variant(&self) -> ACMP_IRQ_A {
2077 match self.bits {
2078 false => ACMP_IRQ_A::INVISIBLE,
2079 true => ACMP_IRQ_A::VISIBLE,
2080 }
2081 }
2082 #[doc = "Checks if the value of the field is `INVISIBLE`"]
2083 #[inline(always)]
2084 pub fn is_invisible(&self) -> bool {
2085 **self == ACMP_IRQ_A::INVISIBLE
2086 }
2087 #[doc = "Checks if the value of the field is `VISIBLE`"]
2088 #[inline(always)]
2089 pub fn is_visible(&self) -> bool {
2090 **self == ACMP_IRQ_A::VISIBLE
2091 }
2092}
2093impl core::ops::Deref for ACMP_IRQ_R {
2094 type Target = crate::FieldReader<bool, ACMP_IRQ_A>;
2095 #[inline(always)]
2096 fn deref(&self) -> &Self::Target {
2097 &self.0
2098 }
2099}
2100#[doc = "Field `ACMP_IRQ` writer - Analog Comparator interrupt."]
2101pub struct ACMP_IRQ_W<'a> {
2102 w: &'a mut W,
2103}
2104impl<'a> ACMP_IRQ_W<'a> {
2105 #[doc = r"Writes `variant` to the field"]
2106 #[inline(always)]
2107 pub fn variant(self, variant: ACMP_IRQ_A) -> &'a mut W {
2108 self.bit(variant.into())
2109 }
2110 #[doc = "no description available"]
2111 #[inline(always)]
2112 pub fn invisible(self) -> &'a mut W {
2113 self.variant(ACMP_IRQ_A::INVISIBLE)
2114 }
2115 #[doc = "no description available"]
2116 #[inline(always)]
2117 pub fn visible(self) -> &'a mut W {
2118 self.variant(ACMP_IRQ_A::VISIBLE)
2119 }
2120 #[doc = r"Sets the field bit"]
2121 #[inline(always)]
2122 pub fn set_bit(self) -> &'a mut W {
2123 self.bit(true)
2124 }
2125 #[doc = r"Clears the field bit"]
2126 #[inline(always)]
2127 pub fn clear_bit(self) -> &'a mut W {
2128 self.bit(false)
2129 }
2130 #[doc = r"Writes raw bits to the field"]
2131 #[inline(always)]
2132 pub fn bit(self, value: bool) -> &'a mut W {
2133 self.w.bits = (self.w.bits & !(0x01 << 24)) | ((value as u32 & 0x01) << 24);
2134 self.w
2135 }
2136}
2137#[doc = "Reserved. Read value is undefined, only zero should be written.\n\nValue on reset: 1"]
2138#[derive(Clone, Copy, Debug, PartialEq)]
2139pub enum RESERVED1_A {
2140 #[doc = "0: no description available"]
2141 INVISIBLE = 0,
2142 #[doc = "1: no description available"]
2143 VISIBLE = 1,
2144}
2145impl From<RESERVED1_A> for bool {
2146 #[inline(always)]
2147 fn from(variant: RESERVED1_A) -> Self {
2148 variant as u8 != 0
2149 }
2150}
2151#[doc = "Field `RESERVED1` reader - Reserved. Read value is undefined, only zero should be written."]
2152pub struct RESERVED1_R(crate::FieldReader<bool, RESERVED1_A>);
2153impl RESERVED1_R {
2154 #[inline(always)]
2155 pub(crate) fn new(bits: bool) -> Self {
2156 RESERVED1_R(crate::FieldReader::new(bits))
2157 }
2158 #[doc = r"Get enumerated values variant"]
2159 #[inline(always)]
2160 pub fn variant(&self) -> RESERVED1_A {
2161 match self.bits {
2162 false => RESERVED1_A::INVISIBLE,
2163 true => RESERVED1_A::VISIBLE,
2164 }
2165 }
2166 #[doc = "Checks if the value of the field is `INVISIBLE`"]
2167 #[inline(always)]
2168 pub fn is_invisible(&self) -> bool {
2169 **self == RESERVED1_A::INVISIBLE
2170 }
2171 #[doc = "Checks if the value of the field is `VISIBLE`"]
2172 #[inline(always)]
2173 pub fn is_visible(&self) -> bool {
2174 **self == RESERVED1_A::VISIBLE
2175 }
2176}
2177impl core::ops::Deref for RESERVED1_R {
2178 type Target = crate::FieldReader<bool, RESERVED1_A>;
2179 #[inline(always)]
2180 fn deref(&self) -> &Self::Target {
2181 &self.0
2182 }
2183}
2184#[doc = "Field `RESERVED1` writer - Reserved. Read value is undefined, only zero should be written."]
2185pub struct RESERVED1_W<'a> {
2186 w: &'a mut W,
2187}
2188impl<'a> RESERVED1_W<'a> {
2189 #[doc = r"Writes `variant` to the field"]
2190 #[inline(always)]
2191 pub fn variant(self, variant: RESERVED1_A) -> &'a mut W {
2192 self.bit(variant.into())
2193 }
2194 #[doc = "no description available"]
2195 #[inline(always)]
2196 pub fn invisible(self) -> &'a mut W {
2197 self.variant(RESERVED1_A::INVISIBLE)
2198 }
2199 #[doc = "no description available"]
2200 #[inline(always)]
2201 pub fn visible(self) -> &'a mut W {
2202 self.variant(RESERVED1_A::VISIBLE)
2203 }
2204 #[doc = r"Sets the field bit"]
2205 #[inline(always)]
2206 pub fn set_bit(self) -> &'a mut W {
2207 self.bit(true)
2208 }
2209 #[doc = r"Clears the field bit"]
2210 #[inline(always)]
2211 pub fn clear_bit(self) -> &'a mut W {
2212 self.bit(false)
2213 }
2214 #[doc = r"Writes raw bits to the field"]
2215 #[inline(always)]
2216 pub fn bit(self, value: bool) -> &'a mut W {
2217 self.w.bits = (self.w.bits & !(0x01 << 25)) | ((value as u32 & 0x01) << 25);
2218 self.w
2219 }
2220}
2221#[doc = "Reserved. Read value is undefined, only zero should be written.\n\nValue on reset: 1"]
2222#[derive(Clone, Copy, Debug, PartialEq)]
2223pub enum RESERVED2_A {
2224 #[doc = "0: no description available"]
2225 INVISIBLE = 0,
2226 #[doc = "1: no description available"]
2227 VISIBLE = 1,
2228}
2229impl From<RESERVED2_A> for bool {
2230 #[inline(always)]
2231 fn from(variant: RESERVED2_A) -> Self {
2232 variant as u8 != 0
2233 }
2234}
2235#[doc = "Field `RESERVED2` reader - Reserved. Read value is undefined, only zero should be written."]
2236pub struct RESERVED2_R(crate::FieldReader<bool, RESERVED2_A>);
2237impl RESERVED2_R {
2238 #[inline(always)]
2239 pub(crate) fn new(bits: bool) -> Self {
2240 RESERVED2_R(crate::FieldReader::new(bits))
2241 }
2242 #[doc = r"Get enumerated values variant"]
2243 #[inline(always)]
2244 pub fn variant(&self) -> RESERVED2_A {
2245 match self.bits {
2246 false => RESERVED2_A::INVISIBLE,
2247 true => RESERVED2_A::VISIBLE,
2248 }
2249 }
2250 #[doc = "Checks if the value of the field is `INVISIBLE`"]
2251 #[inline(always)]
2252 pub fn is_invisible(&self) -> bool {
2253 **self == RESERVED2_A::INVISIBLE
2254 }
2255 #[doc = "Checks if the value of the field is `VISIBLE`"]
2256 #[inline(always)]
2257 pub fn is_visible(&self) -> bool {
2258 **self == RESERVED2_A::VISIBLE
2259 }
2260}
2261impl core::ops::Deref for RESERVED2_R {
2262 type Target = crate::FieldReader<bool, RESERVED2_A>;
2263 #[inline(always)]
2264 fn deref(&self) -> &Self::Target {
2265 &self.0
2266 }
2267}
2268#[doc = "Field `RESERVED2` writer - Reserved. Read value is undefined, only zero should be written."]
2269pub struct RESERVED2_W<'a> {
2270 w: &'a mut W,
2271}
2272impl<'a> RESERVED2_W<'a> {
2273 #[doc = r"Writes `variant` to the field"]
2274 #[inline(always)]
2275 pub fn variant(self, variant: RESERVED2_A) -> &'a mut W {
2276 self.bit(variant.into())
2277 }
2278 #[doc = "no description available"]
2279 #[inline(always)]
2280 pub fn invisible(self) -> &'a mut W {
2281 self.variant(RESERVED2_A::INVISIBLE)
2282 }
2283 #[doc = "no description available"]
2284 #[inline(always)]
2285 pub fn visible(self) -> &'a mut W {
2286 self.variant(RESERVED2_A::VISIBLE)
2287 }
2288 #[doc = r"Sets the field bit"]
2289 #[inline(always)]
2290 pub fn set_bit(self) -> &'a mut W {
2291 self.bit(true)
2292 }
2293 #[doc = r"Clears the field bit"]
2294 #[inline(always)]
2295 pub fn clear_bit(self) -> &'a mut W {
2296 self.bit(false)
2297 }
2298 #[doc = r"Writes raw bits to the field"]
2299 #[inline(always)]
2300 pub fn bit(self, value: bool) -> &'a mut W {
2301 self.w.bits = (self.w.bits & !(0x01 << 26)) | ((value as u32 & 0x01) << 26);
2302 self.w
2303 }
2304}
2305#[doc = "USB Full Speed Controller Clock request interrupt.\n\nValue on reset: 1"]
2306#[derive(Clone, Copy, Debug, PartialEq)]
2307pub enum USB0_NEEDCLK_A {
2308 #[doc = "0: no description available"]
2309 INVISIBLE = 0,
2310 #[doc = "1: no description available"]
2311 VISIBLE = 1,
2312}
2313impl From<USB0_NEEDCLK_A> for bool {
2314 #[inline(always)]
2315 fn from(variant: USB0_NEEDCLK_A) -> Self {
2316 variant as u8 != 0
2317 }
2318}
2319#[doc = "Field `USB0_NEEDCLK` reader - USB Full Speed Controller Clock request interrupt."]
2320pub struct USB0_NEEDCLK_R(crate::FieldReader<bool, USB0_NEEDCLK_A>);
2321impl USB0_NEEDCLK_R {
2322 #[inline(always)]
2323 pub(crate) fn new(bits: bool) -> Self {
2324 USB0_NEEDCLK_R(crate::FieldReader::new(bits))
2325 }
2326 #[doc = r"Get enumerated values variant"]
2327 #[inline(always)]
2328 pub fn variant(&self) -> USB0_NEEDCLK_A {
2329 match self.bits {
2330 false => USB0_NEEDCLK_A::INVISIBLE,
2331 true => USB0_NEEDCLK_A::VISIBLE,
2332 }
2333 }
2334 #[doc = "Checks if the value of the field is `INVISIBLE`"]
2335 #[inline(always)]
2336 pub fn is_invisible(&self) -> bool {
2337 **self == USB0_NEEDCLK_A::INVISIBLE
2338 }
2339 #[doc = "Checks if the value of the field is `VISIBLE`"]
2340 #[inline(always)]
2341 pub fn is_visible(&self) -> bool {
2342 **self == USB0_NEEDCLK_A::VISIBLE
2343 }
2344}
2345impl core::ops::Deref for USB0_NEEDCLK_R {
2346 type Target = crate::FieldReader<bool, USB0_NEEDCLK_A>;
2347 #[inline(always)]
2348 fn deref(&self) -> &Self::Target {
2349 &self.0
2350 }
2351}
2352#[doc = "Field `USB0_NEEDCLK` writer - USB Full Speed Controller Clock request interrupt."]
2353pub struct USB0_NEEDCLK_W<'a> {
2354 w: &'a mut W,
2355}
2356impl<'a> USB0_NEEDCLK_W<'a> {
2357 #[doc = r"Writes `variant` to the field"]
2358 #[inline(always)]
2359 pub fn variant(self, variant: USB0_NEEDCLK_A) -> &'a mut W {
2360 self.bit(variant.into())
2361 }
2362 #[doc = "no description available"]
2363 #[inline(always)]
2364 pub fn invisible(self) -> &'a mut W {
2365 self.variant(USB0_NEEDCLK_A::INVISIBLE)
2366 }
2367 #[doc = "no description available"]
2368 #[inline(always)]
2369 pub fn visible(self) -> &'a mut W {
2370 self.variant(USB0_NEEDCLK_A::VISIBLE)
2371 }
2372 #[doc = r"Sets the field bit"]
2373 #[inline(always)]
2374 pub fn set_bit(self) -> &'a mut W {
2375 self.bit(true)
2376 }
2377 #[doc = r"Clears the field bit"]
2378 #[inline(always)]
2379 pub fn clear_bit(self) -> &'a mut W {
2380 self.bit(false)
2381 }
2382 #[doc = r"Writes raw bits to the field"]
2383 #[inline(always)]
2384 pub fn bit(self, value: bool) -> &'a mut W {
2385 self.w.bits = (self.w.bits & !(0x01 << 27)) | ((value as u32 & 0x01) << 27);
2386 self.w
2387 }
2388}
2389#[doc = "USB Full Speed Controller interrupt.\n\nValue on reset: 1"]
2390#[derive(Clone, Copy, Debug, PartialEq)]
2391pub enum USB0_IRQ_A {
2392 #[doc = "0: no description available"]
2393 INVISIBLE = 0,
2394 #[doc = "1: no description available"]
2395 VISIBLE = 1,
2396}
2397impl From<USB0_IRQ_A> for bool {
2398 #[inline(always)]
2399 fn from(variant: USB0_IRQ_A) -> Self {
2400 variant as u8 != 0
2401 }
2402}
2403#[doc = "Field `USB0_IRQ` reader - USB Full Speed Controller interrupt."]
2404pub struct USB0_IRQ_R(crate::FieldReader<bool, USB0_IRQ_A>);
2405impl USB0_IRQ_R {
2406 #[inline(always)]
2407 pub(crate) fn new(bits: bool) -> Self {
2408 USB0_IRQ_R(crate::FieldReader::new(bits))
2409 }
2410 #[doc = r"Get enumerated values variant"]
2411 #[inline(always)]
2412 pub fn variant(&self) -> USB0_IRQ_A {
2413 match self.bits {
2414 false => USB0_IRQ_A::INVISIBLE,
2415 true => USB0_IRQ_A::VISIBLE,
2416 }
2417 }
2418 #[doc = "Checks if the value of the field is `INVISIBLE`"]
2419 #[inline(always)]
2420 pub fn is_invisible(&self) -> bool {
2421 **self == USB0_IRQ_A::INVISIBLE
2422 }
2423 #[doc = "Checks if the value of the field is `VISIBLE`"]
2424 #[inline(always)]
2425 pub fn is_visible(&self) -> bool {
2426 **self == USB0_IRQ_A::VISIBLE
2427 }
2428}
2429impl core::ops::Deref for USB0_IRQ_R {
2430 type Target = crate::FieldReader<bool, USB0_IRQ_A>;
2431 #[inline(always)]
2432 fn deref(&self) -> &Self::Target {
2433 &self.0
2434 }
2435}
2436#[doc = "Field `USB0_IRQ` writer - USB Full Speed Controller interrupt."]
2437pub struct USB0_IRQ_W<'a> {
2438 w: &'a mut W,
2439}
2440impl<'a> USB0_IRQ_W<'a> {
2441 #[doc = r"Writes `variant` to the field"]
2442 #[inline(always)]
2443 pub fn variant(self, variant: USB0_IRQ_A) -> &'a mut W {
2444 self.bit(variant.into())
2445 }
2446 #[doc = "no description available"]
2447 #[inline(always)]
2448 pub fn invisible(self) -> &'a mut W {
2449 self.variant(USB0_IRQ_A::INVISIBLE)
2450 }
2451 #[doc = "no description available"]
2452 #[inline(always)]
2453 pub fn visible(self) -> &'a mut W {
2454 self.variant(USB0_IRQ_A::VISIBLE)
2455 }
2456 #[doc = r"Sets the field bit"]
2457 #[inline(always)]
2458 pub fn set_bit(self) -> &'a mut W {
2459 self.bit(true)
2460 }
2461 #[doc = r"Clears the field bit"]
2462 #[inline(always)]
2463 pub fn clear_bit(self) -> &'a mut W {
2464 self.bit(false)
2465 }
2466 #[doc = r"Writes raw bits to the field"]
2467 #[inline(always)]
2468 pub fn bit(self, value: bool) -> &'a mut W {
2469 self.w.bits = (self.w.bits & !(0x01 << 28)) | ((value as u32 & 0x01) << 28);
2470 self.w
2471 }
2472}
2473#[doc = "RTC_LITE0_ALARM_IRQ, RTC_LITE0_WAKEUP_IRQ\n\nValue on reset: 1"]
2474#[derive(Clone, Copy, Debug, PartialEq)]
2475pub enum RTC_IRQ_A {
2476 #[doc = "0: no description available"]
2477 INVISIBLE = 0,
2478 #[doc = "1: no description available"]
2479 VISIBLE = 1,
2480}
2481impl From<RTC_IRQ_A> for bool {
2482 #[inline(always)]
2483 fn from(variant: RTC_IRQ_A) -> Self {
2484 variant as u8 != 0
2485 }
2486}
2487#[doc = "Field `RTC_IRQ` reader - RTC_LITE0_ALARM_IRQ, RTC_LITE0_WAKEUP_IRQ"]
2488pub struct RTC_IRQ_R(crate::FieldReader<bool, RTC_IRQ_A>);
2489impl RTC_IRQ_R {
2490 #[inline(always)]
2491 pub(crate) fn new(bits: bool) -> Self {
2492 RTC_IRQ_R(crate::FieldReader::new(bits))
2493 }
2494 #[doc = r"Get enumerated values variant"]
2495 #[inline(always)]
2496 pub fn variant(&self) -> RTC_IRQ_A {
2497 match self.bits {
2498 false => RTC_IRQ_A::INVISIBLE,
2499 true => RTC_IRQ_A::VISIBLE,
2500 }
2501 }
2502 #[doc = "Checks if the value of the field is `INVISIBLE`"]
2503 #[inline(always)]
2504 pub fn is_invisible(&self) -> bool {
2505 **self == RTC_IRQ_A::INVISIBLE
2506 }
2507 #[doc = "Checks if the value of the field is `VISIBLE`"]
2508 #[inline(always)]
2509 pub fn is_visible(&self) -> bool {
2510 **self == RTC_IRQ_A::VISIBLE
2511 }
2512}
2513impl core::ops::Deref for RTC_IRQ_R {
2514 type Target = crate::FieldReader<bool, RTC_IRQ_A>;
2515 #[inline(always)]
2516 fn deref(&self) -> &Self::Target {
2517 &self.0
2518 }
2519}
2520#[doc = "Field `RTC_IRQ` writer - RTC_LITE0_ALARM_IRQ, RTC_LITE0_WAKEUP_IRQ"]
2521pub struct RTC_IRQ_W<'a> {
2522 w: &'a mut W,
2523}
2524impl<'a> RTC_IRQ_W<'a> {
2525 #[doc = r"Writes `variant` to the field"]
2526 #[inline(always)]
2527 pub fn variant(self, variant: RTC_IRQ_A) -> &'a mut W {
2528 self.bit(variant.into())
2529 }
2530 #[doc = "no description available"]
2531 #[inline(always)]
2532 pub fn invisible(self) -> &'a mut W {
2533 self.variant(RTC_IRQ_A::INVISIBLE)
2534 }
2535 #[doc = "no description available"]
2536 #[inline(always)]
2537 pub fn visible(self) -> &'a mut W {
2538 self.variant(RTC_IRQ_A::VISIBLE)
2539 }
2540 #[doc = r"Sets the field bit"]
2541 #[inline(always)]
2542 pub fn set_bit(self) -> &'a mut W {
2543 self.bit(true)
2544 }
2545 #[doc = r"Clears the field bit"]
2546 #[inline(always)]
2547 pub fn clear_bit(self) -> &'a mut W {
2548 self.bit(false)
2549 }
2550 #[doc = r"Writes raw bits to the field"]
2551 #[inline(always)]
2552 pub fn bit(self, value: bool) -> &'a mut W {
2553 self.w.bits = (self.w.bits & !(0x01 << 29)) | ((value as u32 & 0x01) << 29);
2554 self.w
2555 }
2556}
2557#[doc = "Reserved. Read value is undefined, only zero should be written.\n\nValue on reset: 1"]
2558#[derive(Clone, Copy, Debug, PartialEq)]
2559pub enum RESERVED3_A {
2560 #[doc = "0: no description available"]
2561 INVISIBLE = 0,
2562 #[doc = "1: no description available"]
2563 VISIBLE = 1,
2564}
2565impl From<RESERVED3_A> for bool {
2566 #[inline(always)]
2567 fn from(variant: RESERVED3_A) -> Self {
2568 variant as u8 != 0
2569 }
2570}
2571#[doc = "Field `RESERVED3` reader - Reserved. Read value is undefined, only zero should be written."]
2572pub struct RESERVED3_R(crate::FieldReader<bool, RESERVED3_A>);
2573impl RESERVED3_R {
2574 #[inline(always)]
2575 pub(crate) fn new(bits: bool) -> Self {
2576 RESERVED3_R(crate::FieldReader::new(bits))
2577 }
2578 #[doc = r"Get enumerated values variant"]
2579 #[inline(always)]
2580 pub fn variant(&self) -> RESERVED3_A {
2581 match self.bits {
2582 false => RESERVED3_A::INVISIBLE,
2583 true => RESERVED3_A::VISIBLE,
2584 }
2585 }
2586 #[doc = "Checks if the value of the field is `INVISIBLE`"]
2587 #[inline(always)]
2588 pub fn is_invisible(&self) -> bool {
2589 **self == RESERVED3_A::INVISIBLE
2590 }
2591 #[doc = "Checks if the value of the field is `VISIBLE`"]
2592 #[inline(always)]
2593 pub fn is_visible(&self) -> bool {
2594 **self == RESERVED3_A::VISIBLE
2595 }
2596}
2597impl core::ops::Deref for RESERVED3_R {
2598 type Target = crate::FieldReader<bool, RESERVED3_A>;
2599 #[inline(always)]
2600 fn deref(&self) -> &Self::Target {
2601 &self.0
2602 }
2603}
2604#[doc = "Field `RESERVED3` writer - Reserved. Read value is undefined, only zero should be written."]
2605pub struct RESERVED3_W<'a> {
2606 w: &'a mut W,
2607}
2608impl<'a> RESERVED3_W<'a> {
2609 #[doc = r"Writes `variant` to the field"]
2610 #[inline(always)]
2611 pub fn variant(self, variant: RESERVED3_A) -> &'a mut W {
2612 self.bit(variant.into())
2613 }
2614 #[doc = "no description available"]
2615 #[inline(always)]
2616 pub fn invisible(self) -> &'a mut W {
2617 self.variant(RESERVED3_A::INVISIBLE)
2618 }
2619 #[doc = "no description available"]
2620 #[inline(always)]
2621 pub fn visible(self) -> &'a mut W {
2622 self.variant(RESERVED3_A::VISIBLE)
2623 }
2624 #[doc = r"Sets the field bit"]
2625 #[inline(always)]
2626 pub fn set_bit(self) -> &'a mut W {
2627 self.bit(true)
2628 }
2629 #[doc = r"Clears the field bit"]
2630 #[inline(always)]
2631 pub fn clear_bit(self) -> &'a mut W {
2632 self.bit(false)
2633 }
2634 #[doc = r"Writes raw bits to the field"]
2635 #[inline(always)]
2636 pub fn bit(self, value: bool) -> &'a mut W {
2637 self.w.bits = (self.w.bits & !(0x01 << 30)) | ((value as u32 & 0x01) << 30);
2638 self.w
2639 }
2640}
2641#[doc = "Mailbox interrupt.\n\nValue on reset: 1"]
2642#[derive(Clone, Copy, Debug, PartialEq)]
2643pub enum MAILBOX_IRQ_A {
2644 #[doc = "0: no description available"]
2645 INVISIBLE = 0,
2646 #[doc = "1: no description available"]
2647 VISIBLE = 1,
2648}
2649impl From<MAILBOX_IRQ_A> for bool {
2650 #[inline(always)]
2651 fn from(variant: MAILBOX_IRQ_A) -> Self {
2652 variant as u8 != 0
2653 }
2654}
2655#[doc = "Field `MAILBOX_IRQ` reader - Mailbox interrupt."]
2656pub struct MAILBOX_IRQ_R(crate::FieldReader<bool, MAILBOX_IRQ_A>);
2657impl MAILBOX_IRQ_R {
2658 #[inline(always)]
2659 pub(crate) fn new(bits: bool) -> Self {
2660 MAILBOX_IRQ_R(crate::FieldReader::new(bits))
2661 }
2662 #[doc = r"Get enumerated values variant"]
2663 #[inline(always)]
2664 pub fn variant(&self) -> MAILBOX_IRQ_A {
2665 match self.bits {
2666 false => MAILBOX_IRQ_A::INVISIBLE,
2667 true => MAILBOX_IRQ_A::VISIBLE,
2668 }
2669 }
2670 #[doc = "Checks if the value of the field is `INVISIBLE`"]
2671 #[inline(always)]
2672 pub fn is_invisible(&self) -> bool {
2673 **self == MAILBOX_IRQ_A::INVISIBLE
2674 }
2675 #[doc = "Checks if the value of the field is `VISIBLE`"]
2676 #[inline(always)]
2677 pub fn is_visible(&self) -> bool {
2678 **self == MAILBOX_IRQ_A::VISIBLE
2679 }
2680}
2681impl core::ops::Deref for MAILBOX_IRQ_R {
2682 type Target = crate::FieldReader<bool, MAILBOX_IRQ_A>;
2683 #[inline(always)]
2684 fn deref(&self) -> &Self::Target {
2685 &self.0
2686 }
2687}
2688#[doc = "Field `MAILBOX_IRQ` writer - Mailbox interrupt."]
2689pub struct MAILBOX_IRQ_W<'a> {
2690 w: &'a mut W,
2691}
2692impl<'a> MAILBOX_IRQ_W<'a> {
2693 #[doc = r"Writes `variant` to the field"]
2694 #[inline(always)]
2695 pub fn variant(self, variant: MAILBOX_IRQ_A) -> &'a mut W {
2696 self.bit(variant.into())
2697 }
2698 #[doc = "no description available"]
2699 #[inline(always)]
2700 pub fn invisible(self) -> &'a mut W {
2701 self.variant(MAILBOX_IRQ_A::INVISIBLE)
2702 }
2703 #[doc = "no description available"]
2704 #[inline(always)]
2705 pub fn visible(self) -> &'a mut W {
2706 self.variant(MAILBOX_IRQ_A::VISIBLE)
2707 }
2708 #[doc = r"Sets the field bit"]
2709 #[inline(always)]
2710 pub fn set_bit(self) -> &'a mut W {
2711 self.bit(true)
2712 }
2713 #[doc = r"Clears the field bit"]
2714 #[inline(always)]
2715 pub fn clear_bit(self) -> &'a mut W {
2716 self.bit(false)
2717 }
2718 #[doc = r"Writes raw bits to the field"]
2719 #[inline(always)]
2720 pub fn bit(self, value: bool) -> &'a mut W {
2721 self.w.bits = (self.w.bits & !(0x01 << 31)) | ((value as u32 & 0x01) << 31);
2722 self.w
2723 }
2724}
2725impl R {
2726 #[doc = "Bit 0 - Watchdog Timer, Brown Out Detectors and Flash Controller interrupts"]
2727 #[inline(always)]
2728 pub fn sys_irq(&self) -> SYS_IRQ_R {
2729 SYS_IRQ_R::new((self.bits & 0x01) != 0)
2730 }
2731 #[doc = "Bit 1 - System DMA 0 (non-secure) interrupt."]
2732 #[inline(always)]
2733 pub fn sdma0_irq(&self) -> SDMA0_IRQ_R {
2734 SDMA0_IRQ_R::new(((self.bits >> 1) & 0x01) != 0)
2735 }
2736 #[doc = "Bit 2 - GPIO Group 0 interrupt."]
2737 #[inline(always)]
2738 pub fn gpio_globalint0_irq(&self) -> GPIO_GLOBALINT0_IRQ_R {
2739 GPIO_GLOBALINT0_IRQ_R::new(((self.bits >> 2) & 0x01) != 0)
2740 }
2741 #[doc = "Bit 3 - GPIO Group 1 interrupt."]
2742 #[inline(always)]
2743 pub fn gpio_globalint1_irq(&self) -> GPIO_GLOBALINT1_IRQ_R {
2744 GPIO_GLOBALINT1_IRQ_R::new(((self.bits >> 3) & 0x01) != 0)
2745 }
2746 #[doc = "Bit 4 - Pin interrupt 0 or pattern match engine slice 0 interrupt."]
2747 #[inline(always)]
2748 pub fn gpio_int0_irq0(&self) -> GPIO_INT0_IRQ0_R {
2749 GPIO_INT0_IRQ0_R::new(((self.bits >> 4) & 0x01) != 0)
2750 }
2751 #[doc = "Bit 5 - Pin interrupt 1 or pattern match engine slice 1 interrupt."]
2752 #[inline(always)]
2753 pub fn gpio_int0_irq1(&self) -> GPIO_INT0_IRQ1_R {
2754 GPIO_INT0_IRQ1_R::new(((self.bits >> 5) & 0x01) != 0)
2755 }
2756 #[doc = "Bit 6 - Pin interrupt 2 or pattern match engine slice 2 interrupt."]
2757 #[inline(always)]
2758 pub fn gpio_int0_irq2(&self) -> GPIO_INT0_IRQ2_R {
2759 GPIO_INT0_IRQ2_R::new(((self.bits >> 6) & 0x01) != 0)
2760 }
2761 #[doc = "Bit 7 - Pin interrupt 3 or pattern match engine slice 3 interrupt."]
2762 #[inline(always)]
2763 pub fn gpio_int0_irq3(&self) -> GPIO_INT0_IRQ3_R {
2764 GPIO_INT0_IRQ3_R::new(((self.bits >> 7) & 0x01) != 0)
2765 }
2766 #[doc = "Bit 8 - Micro Tick Timer interrupt."]
2767 #[inline(always)]
2768 pub fn utick_irq(&self) -> UTICK_IRQ_R {
2769 UTICK_IRQ_R::new(((self.bits >> 8) & 0x01) != 0)
2770 }
2771 #[doc = "Bit 9 - Multi-Rate Timer interrupt."]
2772 #[inline(always)]
2773 pub fn mrt_irq(&self) -> MRT_IRQ_R {
2774 MRT_IRQ_R::new(((self.bits >> 9) & 0x01) != 0)
2775 }
2776 #[doc = "Bit 10 - Standard counter/timer 0 interrupt."]
2777 #[inline(always)]
2778 pub fn ctimer0_irq(&self) -> CTIMER0_IRQ_R {
2779 CTIMER0_IRQ_R::new(((self.bits >> 10) & 0x01) != 0)
2780 }
2781 #[doc = "Bit 11 - Standard counter/timer 1 interrupt."]
2782 #[inline(always)]
2783 pub fn ctimer1_irq(&self) -> CTIMER1_IRQ_R {
2784 CTIMER1_IRQ_R::new(((self.bits >> 11) & 0x01) != 0)
2785 }
2786 #[doc = "Bit 12 - SCTimer/PWM interrupt."]
2787 #[inline(always)]
2788 pub fn sct_irq(&self) -> SCT_IRQ_R {
2789 SCT_IRQ_R::new(((self.bits >> 12) & 0x01) != 0)
2790 }
2791 #[doc = "Bit 13 - Standard counter/timer 3 interrupt."]
2792 #[inline(always)]
2793 pub fn ctimer3_irq(&self) -> CTIMER3_IRQ_R {
2794 CTIMER3_IRQ_R::new(((self.bits >> 13) & 0x01) != 0)
2795 }
2796 #[doc = "Bit 14 - Flexcomm 0 interrupt (USART, SPI, I2C, I2S)."]
2797 #[inline(always)]
2798 pub fn flexcomm0_irq(&self) -> FLEXCOMM0_IRQ_R {
2799 FLEXCOMM0_IRQ_R::new(((self.bits >> 14) & 0x01) != 0)
2800 }
2801 #[doc = "Bit 15 - Flexcomm 1 interrupt (USART, SPI, I2C, I2S)."]
2802 #[inline(always)]
2803 pub fn flexcomm1_irq(&self) -> FLEXCOMM1_IRQ_R {
2804 FLEXCOMM1_IRQ_R::new(((self.bits >> 15) & 0x01) != 0)
2805 }
2806 #[doc = "Bit 16 - Flexcomm 2 interrupt (USART, SPI, I2C, I2S)."]
2807 #[inline(always)]
2808 pub fn flexcomm2_irq(&self) -> FLEXCOMM2_IRQ_R {
2809 FLEXCOMM2_IRQ_R::new(((self.bits >> 16) & 0x01) != 0)
2810 }
2811 #[doc = "Bit 17 - Flexcomm 3 interrupt (USART, SPI, I2C, I2S)."]
2812 #[inline(always)]
2813 pub fn flexcomm3_irq(&self) -> FLEXCOMM3_IRQ_R {
2814 FLEXCOMM3_IRQ_R::new(((self.bits >> 17) & 0x01) != 0)
2815 }
2816 #[doc = "Bit 18 - Flexcomm 4 interrupt (USART, SPI, I2C, I2S)."]
2817 #[inline(always)]
2818 pub fn flexcomm4_irq(&self) -> FLEXCOMM4_IRQ_R {
2819 FLEXCOMM4_IRQ_R::new(((self.bits >> 18) & 0x01) != 0)
2820 }
2821 #[doc = "Bit 19 - Flexcomm 5 interrupt (USART, SPI, I2C, I2S)."]
2822 #[inline(always)]
2823 pub fn flexcomm5_irq(&self) -> FLEXCOMM5_IRQ_R {
2824 FLEXCOMM5_IRQ_R::new(((self.bits >> 19) & 0x01) != 0)
2825 }
2826 #[doc = "Bit 20 - Flexcomm 6 interrupt (USART, SPI, I2C, I2S)."]
2827 #[inline(always)]
2828 pub fn flexcomm6_irq(&self) -> FLEXCOMM6_IRQ_R {
2829 FLEXCOMM6_IRQ_R::new(((self.bits >> 20) & 0x01) != 0)
2830 }
2831 #[doc = "Bit 21 - Flexcomm 7 interrupt (USART, SPI, I2C, I2S)."]
2832 #[inline(always)]
2833 pub fn flexcomm7_irq(&self) -> FLEXCOMM7_IRQ_R {
2834 FLEXCOMM7_IRQ_R::new(((self.bits >> 21) & 0x01) != 0)
2835 }
2836 #[doc = "Bit 22 - General Purpose ADC interrupt."]
2837 #[inline(always)]
2838 pub fn adc_irq(&self) -> ADC_IRQ_R {
2839 ADC_IRQ_R::new(((self.bits >> 22) & 0x01) != 0)
2840 }
2841 #[doc = "Bit 23 - Reserved. Read value is undefined, only zero should be written."]
2842 #[inline(always)]
2843 pub fn reserved0(&self) -> RESERVED0_R {
2844 RESERVED0_R::new(((self.bits >> 23) & 0x01) != 0)
2845 }
2846 #[doc = "Bit 24 - Analog Comparator interrupt."]
2847 #[inline(always)]
2848 pub fn acmp_irq(&self) -> ACMP_IRQ_R {
2849 ACMP_IRQ_R::new(((self.bits >> 24) & 0x01) != 0)
2850 }
2851 #[doc = "Bit 25 - Reserved. Read value is undefined, only zero should be written."]
2852 #[inline(always)]
2853 pub fn reserved1(&self) -> RESERVED1_R {
2854 RESERVED1_R::new(((self.bits >> 25) & 0x01) != 0)
2855 }
2856 #[doc = "Bit 26 - Reserved. Read value is undefined, only zero should be written."]
2857 #[inline(always)]
2858 pub fn reserved2(&self) -> RESERVED2_R {
2859 RESERVED2_R::new(((self.bits >> 26) & 0x01) != 0)
2860 }
2861 #[doc = "Bit 27 - USB Full Speed Controller Clock request interrupt."]
2862 #[inline(always)]
2863 pub fn usb0_needclk(&self) -> USB0_NEEDCLK_R {
2864 USB0_NEEDCLK_R::new(((self.bits >> 27) & 0x01) != 0)
2865 }
2866 #[doc = "Bit 28 - USB Full Speed Controller interrupt."]
2867 #[inline(always)]
2868 pub fn usb0_irq(&self) -> USB0_IRQ_R {
2869 USB0_IRQ_R::new(((self.bits >> 28) & 0x01) != 0)
2870 }
2871 #[doc = "Bit 29 - RTC_LITE0_ALARM_IRQ, RTC_LITE0_WAKEUP_IRQ"]
2872 #[inline(always)]
2873 pub fn rtc_irq(&self) -> RTC_IRQ_R {
2874 RTC_IRQ_R::new(((self.bits >> 29) & 0x01) != 0)
2875 }
2876 #[doc = "Bit 30 - Reserved. Read value is undefined, only zero should be written."]
2877 #[inline(always)]
2878 pub fn reserved3(&self) -> RESERVED3_R {
2879 RESERVED3_R::new(((self.bits >> 30) & 0x01) != 0)
2880 }
2881 #[doc = "Bit 31 - Mailbox interrupt."]
2882 #[inline(always)]
2883 pub fn mailbox_irq(&self) -> MAILBOX_IRQ_R {
2884 MAILBOX_IRQ_R::new(((self.bits >> 31) & 0x01) != 0)
2885 }
2886}
2887impl W {
2888 #[doc = "Bit 0 - Watchdog Timer, Brown Out Detectors and Flash Controller interrupts"]
2889 #[inline(always)]
2890 pub fn sys_irq(&mut self) -> SYS_IRQ_W {
2891 SYS_IRQ_W { w: self }
2892 }
2893 #[doc = "Bit 1 - System DMA 0 (non-secure) interrupt."]
2894 #[inline(always)]
2895 pub fn sdma0_irq(&mut self) -> SDMA0_IRQ_W {
2896 SDMA0_IRQ_W { w: self }
2897 }
2898 #[doc = "Bit 2 - GPIO Group 0 interrupt."]
2899 #[inline(always)]
2900 pub fn gpio_globalint0_irq(&mut self) -> GPIO_GLOBALINT0_IRQ_W {
2901 GPIO_GLOBALINT0_IRQ_W { w: self }
2902 }
2903 #[doc = "Bit 3 - GPIO Group 1 interrupt."]
2904 #[inline(always)]
2905 pub fn gpio_globalint1_irq(&mut self) -> GPIO_GLOBALINT1_IRQ_W {
2906 GPIO_GLOBALINT1_IRQ_W { w: self }
2907 }
2908 #[doc = "Bit 4 - Pin interrupt 0 or pattern match engine slice 0 interrupt."]
2909 #[inline(always)]
2910 pub fn gpio_int0_irq0(&mut self) -> GPIO_INT0_IRQ0_W {
2911 GPIO_INT0_IRQ0_W { w: self }
2912 }
2913 #[doc = "Bit 5 - Pin interrupt 1 or pattern match engine slice 1 interrupt."]
2914 #[inline(always)]
2915 pub fn gpio_int0_irq1(&mut self) -> GPIO_INT0_IRQ1_W {
2916 GPIO_INT0_IRQ1_W { w: self }
2917 }
2918 #[doc = "Bit 6 - Pin interrupt 2 or pattern match engine slice 2 interrupt."]
2919 #[inline(always)]
2920 pub fn gpio_int0_irq2(&mut self) -> GPIO_INT0_IRQ2_W {
2921 GPIO_INT0_IRQ2_W { w: self }
2922 }
2923 #[doc = "Bit 7 - Pin interrupt 3 or pattern match engine slice 3 interrupt."]
2924 #[inline(always)]
2925 pub fn gpio_int0_irq3(&mut self) -> GPIO_INT0_IRQ3_W {
2926 GPIO_INT0_IRQ3_W { w: self }
2927 }
2928 #[doc = "Bit 8 - Micro Tick Timer interrupt."]
2929 #[inline(always)]
2930 pub fn utick_irq(&mut self) -> UTICK_IRQ_W {
2931 UTICK_IRQ_W { w: self }
2932 }
2933 #[doc = "Bit 9 - Multi-Rate Timer interrupt."]
2934 #[inline(always)]
2935 pub fn mrt_irq(&mut self) -> MRT_IRQ_W {
2936 MRT_IRQ_W { w: self }
2937 }
2938 #[doc = "Bit 10 - Standard counter/timer 0 interrupt."]
2939 #[inline(always)]
2940 pub fn ctimer0_irq(&mut self) -> CTIMER0_IRQ_W {
2941 CTIMER0_IRQ_W { w: self }
2942 }
2943 #[doc = "Bit 11 - Standard counter/timer 1 interrupt."]
2944 #[inline(always)]
2945 pub fn ctimer1_irq(&mut self) -> CTIMER1_IRQ_W {
2946 CTIMER1_IRQ_W { w: self }
2947 }
2948 #[doc = "Bit 12 - SCTimer/PWM interrupt."]
2949 #[inline(always)]
2950 pub fn sct_irq(&mut self) -> SCT_IRQ_W {
2951 SCT_IRQ_W { w: self }
2952 }
2953 #[doc = "Bit 13 - Standard counter/timer 3 interrupt."]
2954 #[inline(always)]
2955 pub fn ctimer3_irq(&mut self) -> CTIMER3_IRQ_W {
2956 CTIMER3_IRQ_W { w: self }
2957 }
2958 #[doc = "Bit 14 - Flexcomm 0 interrupt (USART, SPI, I2C, I2S)."]
2959 #[inline(always)]
2960 pub fn flexcomm0_irq(&mut self) -> FLEXCOMM0_IRQ_W {
2961 FLEXCOMM0_IRQ_W { w: self }
2962 }
2963 #[doc = "Bit 15 - Flexcomm 1 interrupt (USART, SPI, I2C, I2S)."]
2964 #[inline(always)]
2965 pub fn flexcomm1_irq(&mut self) -> FLEXCOMM1_IRQ_W {
2966 FLEXCOMM1_IRQ_W { w: self }
2967 }
2968 #[doc = "Bit 16 - Flexcomm 2 interrupt (USART, SPI, I2C, I2S)."]
2969 #[inline(always)]
2970 pub fn flexcomm2_irq(&mut self) -> FLEXCOMM2_IRQ_W {
2971 FLEXCOMM2_IRQ_W { w: self }
2972 }
2973 #[doc = "Bit 17 - Flexcomm 3 interrupt (USART, SPI, I2C, I2S)."]
2974 #[inline(always)]
2975 pub fn flexcomm3_irq(&mut self) -> FLEXCOMM3_IRQ_W {
2976 FLEXCOMM3_IRQ_W { w: self }
2977 }
2978 #[doc = "Bit 18 - Flexcomm 4 interrupt (USART, SPI, I2C, I2S)."]
2979 #[inline(always)]
2980 pub fn flexcomm4_irq(&mut self) -> FLEXCOMM4_IRQ_W {
2981 FLEXCOMM4_IRQ_W { w: self }
2982 }
2983 #[doc = "Bit 19 - Flexcomm 5 interrupt (USART, SPI, I2C, I2S)."]
2984 #[inline(always)]
2985 pub fn flexcomm5_irq(&mut self) -> FLEXCOMM5_IRQ_W {
2986 FLEXCOMM5_IRQ_W { w: self }
2987 }
2988 #[doc = "Bit 20 - Flexcomm 6 interrupt (USART, SPI, I2C, I2S)."]
2989 #[inline(always)]
2990 pub fn flexcomm6_irq(&mut self) -> FLEXCOMM6_IRQ_W {
2991 FLEXCOMM6_IRQ_W { w: self }
2992 }
2993 #[doc = "Bit 21 - Flexcomm 7 interrupt (USART, SPI, I2C, I2S)."]
2994 #[inline(always)]
2995 pub fn flexcomm7_irq(&mut self) -> FLEXCOMM7_IRQ_W {
2996 FLEXCOMM7_IRQ_W { w: self }
2997 }
2998 #[doc = "Bit 22 - General Purpose ADC interrupt."]
2999 #[inline(always)]
3000 pub fn adc_irq(&mut self) -> ADC_IRQ_W {
3001 ADC_IRQ_W { w: self }
3002 }
3003 #[doc = "Bit 23 - Reserved. Read value is undefined, only zero should be written."]
3004 #[inline(always)]
3005 pub fn reserved0(&mut self) -> RESERVED0_W {
3006 RESERVED0_W { w: self }
3007 }
3008 #[doc = "Bit 24 - Analog Comparator interrupt."]
3009 #[inline(always)]
3010 pub fn acmp_irq(&mut self) -> ACMP_IRQ_W {
3011 ACMP_IRQ_W { w: self }
3012 }
3013 #[doc = "Bit 25 - Reserved. Read value is undefined, only zero should be written."]
3014 #[inline(always)]
3015 pub fn reserved1(&mut self) -> RESERVED1_W {
3016 RESERVED1_W { w: self }
3017 }
3018 #[doc = "Bit 26 - Reserved. Read value is undefined, only zero should be written."]
3019 #[inline(always)]
3020 pub fn reserved2(&mut self) -> RESERVED2_W {
3021 RESERVED2_W { w: self }
3022 }
3023 #[doc = "Bit 27 - USB Full Speed Controller Clock request interrupt."]
3024 #[inline(always)]
3025 pub fn usb0_needclk(&mut self) -> USB0_NEEDCLK_W {
3026 USB0_NEEDCLK_W { w: self }
3027 }
3028 #[doc = "Bit 28 - USB Full Speed Controller interrupt."]
3029 #[inline(always)]
3030 pub fn usb0_irq(&mut self) -> USB0_IRQ_W {
3031 USB0_IRQ_W { w: self }
3032 }
3033 #[doc = "Bit 29 - RTC_LITE0_ALARM_IRQ, RTC_LITE0_WAKEUP_IRQ"]
3034 #[inline(always)]
3035 pub fn rtc_irq(&mut self) -> RTC_IRQ_W {
3036 RTC_IRQ_W { w: self }
3037 }
3038 #[doc = "Bit 30 - Reserved. Read value is undefined, only zero should be written."]
3039 #[inline(always)]
3040 pub fn reserved3(&mut self) -> RESERVED3_W {
3041 RESERVED3_W { w: self }
3042 }
3043 #[doc = "Bit 31 - Mailbox interrupt."]
3044 #[inline(always)]
3045 pub fn mailbox_irq(&mut self) -> MAILBOX_IRQ_W {
3046 MAILBOX_IRQ_W { w: self }
3047 }
3048 #[doc = "Writes raw bits to the register."]
3049 #[inline(always)]
3050 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
3051 self.0.bits(bits);
3052 self
3053 }
3054}
3055#[doc = "Secure Interrupt mask for CPU1\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 [sec_cpu_int_mask0](index.html) module"]
3056pub struct SEC_CPU_INT_MASK0_SPEC;
3057impl crate::RegisterSpec for SEC_CPU_INT_MASK0_SPEC {
3058 type Ux = u32;
3059}
3060#[doc = "`read()` method returns [sec_cpu_int_mask0::R](R) reader structure"]
3061impl crate::Readable for SEC_CPU_INT_MASK0_SPEC {
3062 type Reader = R;
3063}
3064#[doc = "`write(|w| ..)` method takes [sec_cpu_int_mask0::W](W) writer structure"]
3065impl crate::Writable for SEC_CPU_INT_MASK0_SPEC {
3066 type Writer = W;
3067}
3068#[doc = "`reset()` method sets SEC_CPU_INT_MASK0 to value 0xffff_ffff"]
3069impl crate::Resettable for SEC_CPU_INT_MASK0_SPEC {
3070 #[inline(always)]
3071 fn reset_value() -> Self::Ux {
3072 0xffff_ffff
3073 }
3074}