eos_s3/intr_ctrl/
other_intr_en_ap.rs

1#[doc = "Register `OTHER_INTR_EN_AP` reader"]
2pub struct R(crate::R<OTHER_INTR_EN_AP_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<OTHER_INTR_EN_AP_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<OTHER_INTR_EN_AP_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<OTHER_INTR_EN_AP_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `OTHER_INTR_EN_AP` writer"]
17pub struct W(crate::W<OTHER_INTR_EN_AP_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<OTHER_INTR_EN_AP_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<OTHER_INTR_EN_AP_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<OTHER_INTR_EN_AP_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "M4 SRAM (access during low power) interrupt enable for AP\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum M4_SRAM_INTR_EN_AP_A {
40    #[doc = "0: Disable the interrupt for the power domain"]
41    ENABLE = 0,
42    #[doc = "1: Enable the interrupt for the power domain"]
43    DISABLE = 1,
44}
45impl From<M4_SRAM_INTR_EN_AP_A> for bool {
46    #[inline(always)]
47    fn from(variant: M4_SRAM_INTR_EN_AP_A) -> Self {
48        variant as u8 != 0
49    }
50}
51#[doc = "Field `M4_SRAM_INTR_EN_AP` reader - M4 SRAM (access during low power) interrupt enable for AP"]
52pub struct M4_SRAM_INTR_EN_AP_R(crate::FieldReader<bool, M4_SRAM_INTR_EN_AP_A>);
53impl M4_SRAM_INTR_EN_AP_R {
54    #[inline(always)]
55    pub(crate) fn new(bits: bool) -> Self {
56        M4_SRAM_INTR_EN_AP_R(crate::FieldReader::new(bits))
57    }
58    #[doc = r"Get enumerated values variant"]
59    #[inline(always)]
60    pub fn variant(&self) -> M4_SRAM_INTR_EN_AP_A {
61        match self.bits {
62            false => M4_SRAM_INTR_EN_AP_A::ENABLE,
63            true => M4_SRAM_INTR_EN_AP_A::DISABLE,
64        }
65    }
66    #[doc = "Checks if the value of the field is `ENABLE`"]
67    #[inline(always)]
68    pub fn is_enable(&self) -> bool {
69        **self == M4_SRAM_INTR_EN_AP_A::ENABLE
70    }
71    #[doc = "Checks if the value of the field is `DISABLE`"]
72    #[inline(always)]
73    pub fn is_disable(&self) -> bool {
74        **self == M4_SRAM_INTR_EN_AP_A::DISABLE
75    }
76}
77impl core::ops::Deref for M4_SRAM_INTR_EN_AP_R {
78    type Target = crate::FieldReader<bool, M4_SRAM_INTR_EN_AP_A>;
79    #[inline(always)]
80    fn deref(&self) -> &Self::Target {
81        &self.0
82    }
83}
84#[doc = "Field `M4_SRAM_INTR_EN_AP` writer - M4 SRAM (access during low power) interrupt enable for AP"]
85pub struct M4_SRAM_INTR_EN_AP_W<'a> {
86    w: &'a mut W,
87}
88impl<'a> M4_SRAM_INTR_EN_AP_W<'a> {
89    #[doc = r"Writes `variant` to the field"]
90    #[inline(always)]
91    pub fn variant(self, variant: M4_SRAM_INTR_EN_AP_A) -> &'a mut W {
92        self.bit(variant.into())
93    }
94    #[doc = "Disable the interrupt for the power domain"]
95    #[inline(always)]
96    pub fn enable(self) -> &'a mut W {
97        self.variant(M4_SRAM_INTR_EN_AP_A::ENABLE)
98    }
99    #[doc = "Enable the interrupt for the power domain"]
100    #[inline(always)]
101    pub fn disable(self) -> &'a mut W {
102        self.variant(M4_SRAM_INTR_EN_AP_A::DISABLE)
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 = "UART interrupt enable for AP"]
122pub type UART_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
123#[doc = "Field `UART_INTR_EN_AP` reader - UART interrupt enable for AP"]
124pub type UART_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
125#[doc = "Field `UART_INTR_EN_AP` writer - UART interrupt enable for AP"]
126pub struct UART_INTR_EN_AP_W<'a> {
127    w: &'a mut W,
128}
129impl<'a> UART_INTR_EN_AP_W<'a> {
130    #[doc = r"Writes `variant` to the field"]
131    #[inline(always)]
132    pub fn variant(self, variant: UART_INTR_EN_AP_A) -> &'a mut W {
133        self.bit(variant.into())
134    }
135    #[doc = "Disable the interrupt for the power domain"]
136    #[inline(always)]
137    pub fn enable(self) -> &'a mut W {
138        self.variant(UART_INTR_EN_AP_A::ENABLE)
139    }
140    #[doc = "Enable the interrupt for the power domain"]
141    #[inline(always)]
142    pub fn disable(self) -> &'a mut W {
143        self.variant(UART_INTR_EN_AP_A::DISABLE)
144    }
145    #[doc = r"Sets the field bit"]
146    #[inline(always)]
147    pub fn set_bit(self) -> &'a mut W {
148        self.bit(true)
149    }
150    #[doc = r"Clears the field bit"]
151    #[inline(always)]
152    pub fn clear_bit(self) -> &'a mut W {
153        self.bit(false)
154    }
155    #[doc = r"Writes raw bits to the field"]
156    #[inline(always)]
157    pub fn bit(self, value: bool) -> &'a mut W {
158        self.w.bits =
159            (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
160        self.w
161    }
162}
163#[doc = "Timer interrupt enable for AP"]
164pub type TIMER_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
165#[doc = "Field `TIMER_INTR_EN_AP` reader - Timer interrupt enable for AP"]
166pub type TIMER_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
167#[doc = "Field `TIMER_INTR_EN_AP` writer - Timer interrupt enable for AP"]
168pub struct TIMER_INTR_EN_AP_W<'a> {
169    w: &'a mut W,
170}
171impl<'a> TIMER_INTR_EN_AP_W<'a> {
172    #[doc = r"Writes `variant` to the field"]
173    #[inline(always)]
174    pub fn variant(self, variant: TIMER_INTR_EN_AP_A) -> &'a mut W {
175        self.bit(variant.into())
176    }
177    #[doc = "Disable the interrupt for the power domain"]
178    #[inline(always)]
179    pub fn enable(self) -> &'a mut W {
180        self.variant(TIMER_INTR_EN_AP_A::ENABLE)
181    }
182    #[doc = "Enable the interrupt for the power domain"]
183    #[inline(always)]
184    pub fn disable(self) -> &'a mut W {
185        self.variant(TIMER_INTR_EN_AP_A::DISABLE)
186    }
187    #[doc = r"Sets the field bit"]
188    #[inline(always)]
189    pub fn set_bit(self) -> &'a mut W {
190        self.bit(true)
191    }
192    #[doc = r"Clears the field bit"]
193    #[inline(always)]
194    pub fn clear_bit(self) -> &'a mut W {
195        self.bit(false)
196    }
197    #[doc = r"Writes raw bits to the field"]
198    #[inline(always)]
199    pub fn bit(self, value: bool) -> &'a mut W {
200        self.w.bits =
201            (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
202        self.w
203    }
204}
205#[doc = "WDT M4 interrupt enable for AP"]
206pub type WDOG_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
207#[doc = "Field `WDOG_INTR_EN_AP` reader - WDT M4 interrupt enable for AP"]
208pub type WDOG_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
209#[doc = "Field `WDOG_INTR_EN_AP` writer - WDT M4 interrupt enable for AP"]
210pub struct WDOG_INTR_EN_AP_W<'a> {
211    w: &'a mut W,
212}
213impl<'a> WDOG_INTR_EN_AP_W<'a> {
214    #[doc = r"Writes `variant` to the field"]
215    #[inline(always)]
216    pub fn variant(self, variant: WDOG_INTR_EN_AP_A) -> &'a mut W {
217        self.bit(variant.into())
218    }
219    #[doc = "Disable the interrupt for the power domain"]
220    #[inline(always)]
221    pub fn enable(self) -> &'a mut W {
222        self.variant(WDOG_INTR_EN_AP_A::ENABLE)
223    }
224    #[doc = "Enable the interrupt for the power domain"]
225    #[inline(always)]
226    pub fn disable(self) -> &'a mut W {
227        self.variant(WDOG_INTR_EN_AP_A::DISABLE)
228    }
229    #[doc = r"Sets the field bit"]
230    #[inline(always)]
231    pub fn set_bit(self) -> &'a mut W {
232        self.bit(true)
233    }
234    #[doc = r"Clears the field bit"]
235    #[inline(always)]
236    pub fn clear_bit(self) -> &'a mut W {
237        self.bit(false)
238    }
239    #[doc = r"Writes raw bits to the field"]
240    #[inline(always)]
241    pub fn bit(self, value: bool) -> &'a mut W {
242        self.w.bits =
243            (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
244        self.w
245    }
246}
247#[doc = "WDT M4 Reset interrupt enable for AP"]
248pub type WDOG_RST_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
249#[doc = "Field `WDOG_RST_EN_AP` reader - WDT M4 Reset interrupt enable for AP"]
250pub type WDOG_RST_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
251#[doc = "Field `WDOG_RST_EN_AP` writer - WDT M4 Reset interrupt enable for AP"]
252pub struct WDOG_RST_EN_AP_W<'a> {
253    w: &'a mut W,
254}
255impl<'a> WDOG_RST_EN_AP_W<'a> {
256    #[doc = r"Writes `variant` to the field"]
257    #[inline(always)]
258    pub fn variant(self, variant: WDOG_RST_EN_AP_A) -> &'a mut W {
259        self.bit(variant.into())
260    }
261    #[doc = "Disable the interrupt for the power domain"]
262    #[inline(always)]
263    pub fn enable(self) -> &'a mut W {
264        self.variant(WDOG_RST_EN_AP_A::ENABLE)
265    }
266    #[doc = "Enable the interrupt for the power domain"]
267    #[inline(always)]
268    pub fn disable(self) -> &'a mut W {
269        self.variant(WDOG_RST_EN_AP_A::DISABLE)
270    }
271    #[doc = r"Sets the field bit"]
272    #[inline(always)]
273    pub fn set_bit(self) -> &'a mut W {
274        self.bit(true)
275    }
276    #[doc = r"Clears the field bit"]
277    #[inline(always)]
278    pub fn clear_bit(self) -> &'a mut W {
279        self.bit(false)
280    }
281    #[doc = r"Writes raw bits to the field"]
282    #[inline(always)]
283    pub fn bit(self, value: bool) -> &'a mut W {
284        self.w.bits =
285            (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
286        self.w
287    }
288}
289#[doc = "Bus Timeout interrupt enable for AP"]
290pub type TIMEOUT_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
291#[doc = "Field `TIMEOUT_INTR_EN_AP` reader - Bus Timeout interrupt enable for AP"]
292pub type TIMEOUT_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
293#[doc = "Field `TIMEOUT_INTR_EN_AP` writer - Bus Timeout interrupt enable for AP"]
294pub struct TIMEOUT_INTR_EN_AP_W<'a> {
295    w: &'a mut W,
296}
297impl<'a> TIMEOUT_INTR_EN_AP_W<'a> {
298    #[doc = r"Writes `variant` to the field"]
299    #[inline(always)]
300    pub fn variant(self, variant: TIMEOUT_INTR_EN_AP_A) -> &'a mut W {
301        self.bit(variant.into())
302    }
303    #[doc = "Disable the interrupt for the power domain"]
304    #[inline(always)]
305    pub fn enable(self) -> &'a mut W {
306        self.variant(TIMEOUT_INTR_EN_AP_A::ENABLE)
307    }
308    #[doc = "Enable the interrupt for the power domain"]
309    #[inline(always)]
310    pub fn disable(self) -> &'a mut W {
311        self.variant(TIMEOUT_INTR_EN_AP_A::DISABLE)
312    }
313    #[doc = r"Sets the field bit"]
314    #[inline(always)]
315    pub fn set_bit(self) -> &'a mut W {
316        self.bit(true)
317    }
318    #[doc = r"Clears the field bit"]
319    #[inline(always)]
320    pub fn clear_bit(self) -> &'a mut W {
321        self.bit(false)
322    }
323    #[doc = r"Writes raw bits to the field"]
324    #[inline(always)]
325    pub fn bit(self, value: bool) -> &'a mut W {
326        self.w.bits =
327            (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
328        self.w
329    }
330}
331#[doc = "M4 FPU interrupt enable for AP"]
332pub type FPU_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
333#[doc = "Field `FPU_INTR_EN_AP` reader - M4 FPU interrupt enable for AP"]
334pub type FPU_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
335#[doc = "Field `FPU_INTR_EN_AP` writer - M4 FPU interrupt enable for AP"]
336pub struct FPU_INTR_EN_AP_W<'a> {
337    w: &'a mut W,
338}
339impl<'a> FPU_INTR_EN_AP_W<'a> {
340    #[doc = r"Writes `variant` to the field"]
341    #[inline(always)]
342    pub fn variant(self, variant: FPU_INTR_EN_AP_A) -> &'a mut W {
343        self.bit(variant.into())
344    }
345    #[doc = "Disable the interrupt for the power domain"]
346    #[inline(always)]
347    pub fn enable(self) -> &'a mut W {
348        self.variant(FPU_INTR_EN_AP_A::ENABLE)
349    }
350    #[doc = "Enable the interrupt for the power domain"]
351    #[inline(always)]
352    pub fn disable(self) -> &'a mut W {
353        self.variant(FPU_INTR_EN_AP_A::DISABLE)
354    }
355    #[doc = r"Sets the field bit"]
356    #[inline(always)]
357    pub fn set_bit(self) -> &'a mut W {
358        self.bit(true)
359    }
360    #[doc = r"Clears the field bit"]
361    #[inline(always)]
362    pub fn clear_bit(self) -> &'a mut W {
363        self.bit(false)
364    }
365    #[doc = r"Writes raw bits to the field"]
366    #[inline(always)]
367    pub fn bit(self, value: bool) -> &'a mut W {
368        self.w.bits =
369            (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
370        self.w
371    }
372}
373#[doc = "Packet FIFO Bank interrupt enable for AP"]
374pub type PKFB_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
375#[doc = "Field `PKFB_INTR_EN_AP` reader - Packet FIFO Bank interrupt enable for AP"]
376pub type PKFB_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
377#[doc = "Field `PKFB_INTR_EN_AP` writer - Packet FIFO Bank interrupt enable for AP"]
378pub struct PKFB_INTR_EN_AP_W<'a> {
379    w: &'a mut W,
380}
381impl<'a> PKFB_INTR_EN_AP_W<'a> {
382    #[doc = r"Writes `variant` to the field"]
383    #[inline(always)]
384    pub fn variant(self, variant: PKFB_INTR_EN_AP_A) -> &'a mut W {
385        self.bit(variant.into())
386    }
387    #[doc = "Disable the interrupt for the power domain"]
388    #[inline(always)]
389    pub fn enable(self) -> &'a mut W {
390        self.variant(PKFB_INTR_EN_AP_A::ENABLE)
391    }
392    #[doc = "Enable the interrupt for the power domain"]
393    #[inline(always)]
394    pub fn disable(self) -> &'a mut W {
395        self.variant(PKFB_INTR_EN_AP_A::DISABLE)
396    }
397    #[doc = r"Sets the field bit"]
398    #[inline(always)]
399    pub fn set_bit(self) -> &'a mut W {
400        self.bit(true)
401    }
402    #[doc = r"Clears the field bit"]
403    #[inline(always)]
404    pub fn clear_bit(self) -> &'a mut W {
405        self.bit(false)
406    }
407    #[doc = r"Writes raw bits to the field"]
408    #[inline(always)]
409    pub fn bit(self, value: bool) -> &'a mut W {
410        self.w.bits =
411            (self.w.bits & !(0x01 << 7)) | ((value as u32 & 0x01) << 7);
412        self.w
413    }
414}
415#[doc = "SPI Master interrupt enable for AP"]
416pub type SPI_MS_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
417#[doc = "Field `SPI_MS_INTR_EN_AP` reader - SPI Master interrupt enable for AP"]
418pub type SPI_MS_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
419#[doc = "Field `SPI_MS_INTR_EN_AP` writer - SPI Master interrupt enable for AP"]
420pub struct SPI_MS_INTR_EN_AP_W<'a> {
421    w: &'a mut W,
422}
423impl<'a> SPI_MS_INTR_EN_AP_W<'a> {
424    #[doc = r"Writes `variant` to the field"]
425    #[inline(always)]
426    pub fn variant(self, variant: SPI_MS_INTR_EN_AP_A) -> &'a mut W {
427        self.bit(variant.into())
428    }
429    #[doc = "Disable the interrupt for the power domain"]
430    #[inline(always)]
431    pub fn enable(self) -> &'a mut W {
432        self.variant(SPI_MS_INTR_EN_AP_A::ENABLE)
433    }
434    #[doc = "Enable the interrupt for the power domain"]
435    #[inline(always)]
436    pub fn disable(self) -> &'a mut W {
437        self.variant(SPI_MS_INTR_EN_AP_A::DISABLE)
438    }
439    #[doc = r"Sets the field bit"]
440    #[inline(always)]
441    pub fn set_bit(self) -> &'a mut W {
442        self.bit(true)
443    }
444    #[doc = r"Clears the field bit"]
445    #[inline(always)]
446    pub fn clear_bit(self) -> &'a mut W {
447        self.bit(false)
448    }
449    #[doc = r"Writes raw bits to the field"]
450    #[inline(always)]
451    pub fn bit(self, value: bool) -> &'a mut W {
452        self.w.bits =
453            (self.w.bits & !(0x01 << 10)) | ((value as u32 & 0x01) << 10);
454        self.w
455    }
456}
457#[doc = "Config DMA interrupt enable for AP"]
458pub type CFG_DMA_DONE_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
459#[doc = "Field `CFG_DMA_DONE_INTR_EN_AP` reader - Config DMA interrupt enable for AP"]
460pub type CFG_DMA_DONE_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
461#[doc = "Field `CFG_DMA_DONE_INTR_EN_AP` writer - Config DMA interrupt enable for AP"]
462pub struct CFG_DMA_DONE_INTR_EN_AP_W<'a> {
463    w: &'a mut W,
464}
465impl<'a> CFG_DMA_DONE_INTR_EN_AP_W<'a> {
466    #[doc = r"Writes `variant` to the field"]
467    #[inline(always)]
468    pub fn variant(self, variant: CFG_DMA_DONE_INTR_EN_AP_A) -> &'a mut W {
469        self.bit(variant.into())
470    }
471    #[doc = "Disable the interrupt for the power domain"]
472    #[inline(always)]
473    pub fn enable(self) -> &'a mut W {
474        self.variant(CFG_DMA_DONE_INTR_EN_AP_A::ENABLE)
475    }
476    #[doc = "Enable the interrupt for the power domain"]
477    #[inline(always)]
478    pub fn disable(self) -> &'a mut W {
479        self.variant(CFG_DMA_DONE_INTR_EN_AP_A::DISABLE)
480    }
481    #[doc = r"Sets the field bit"]
482    #[inline(always)]
483    pub fn set_bit(self) -> &'a mut W {
484        self.bit(true)
485    }
486    #[doc = r"Clears the field bit"]
487    #[inline(always)]
488    pub fn clear_bit(self) -> &'a mut W {
489        self.bit(false)
490    }
491    #[doc = r"Writes raw bits to the field"]
492    #[inline(always)]
493    pub fn bit(self, value: bool) -> &'a mut W {
494        self.w.bits =
495            (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
496        self.w
497    }
498}
499#[doc = "PMU Timer interrupt enable for AP"]
500pub type PMU_TMR_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
501#[doc = "Field `PMU_TMR_INTR_EN_AP` reader - PMU Timer interrupt enable for AP"]
502pub type PMU_TMR_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
503#[doc = "Field `PMU_TMR_INTR_EN_AP` writer - PMU Timer interrupt enable for AP"]
504pub struct PMU_TMR_INTR_EN_AP_W<'a> {
505    w: &'a mut W,
506}
507impl<'a> PMU_TMR_INTR_EN_AP_W<'a> {
508    #[doc = r"Writes `variant` to the field"]
509    #[inline(always)]
510    pub fn variant(self, variant: PMU_TMR_INTR_EN_AP_A) -> &'a mut W {
511        self.bit(variant.into())
512    }
513    #[doc = "Disable the interrupt for the power domain"]
514    #[inline(always)]
515    pub fn enable(self) -> &'a mut W {
516        self.variant(PMU_TMR_INTR_EN_AP_A::ENABLE)
517    }
518    #[doc = "Enable the interrupt for the power domain"]
519    #[inline(always)]
520    pub fn disable(self) -> &'a mut W {
521        self.variant(PMU_TMR_INTR_EN_AP_A::DISABLE)
522    }
523    #[doc = r"Sets the field bit"]
524    #[inline(always)]
525    pub fn set_bit(self) -> &'a mut W {
526        self.bit(true)
527    }
528    #[doc = r"Clears the field bit"]
529    #[inline(always)]
530    pub fn clear_bit(self) -> &'a mut W {
531        self.bit(false)
532    }
533    #[doc = r"Writes raw bits to the field"]
534    #[inline(always)]
535    pub fn bit(self, value: bool) -> &'a mut W {
536        self.w.bits =
537            (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
538        self.w
539    }
540}
541#[doc = "ADC interrupt enable for AP"]
542pub type ADC_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
543#[doc = "Field `ADC_INTR_EN_AP` reader - ADC interrupt enable for AP"]
544pub type ADC_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
545#[doc = "Field `ADC_INTR_EN_AP` writer - ADC interrupt enable for AP"]
546pub struct ADC_INTR_EN_AP_W<'a> {
547    w: &'a mut W,
548}
549impl<'a> ADC_INTR_EN_AP_W<'a> {
550    #[doc = r"Writes `variant` to the field"]
551    #[inline(always)]
552    pub fn variant(self, variant: ADC_INTR_EN_AP_A) -> &'a mut W {
553        self.bit(variant.into())
554    }
555    #[doc = "Disable the interrupt for the power domain"]
556    #[inline(always)]
557    pub fn enable(self) -> &'a mut W {
558        self.variant(ADC_INTR_EN_AP_A::ENABLE)
559    }
560    #[doc = "Enable the interrupt for the power domain"]
561    #[inline(always)]
562    pub fn disable(self) -> &'a mut W {
563        self.variant(ADC_INTR_EN_AP_A::DISABLE)
564    }
565    #[doc = r"Sets the field bit"]
566    #[inline(always)]
567    pub fn set_bit(self) -> &'a mut W {
568        self.bit(true)
569    }
570    #[doc = r"Clears the field bit"]
571    #[inline(always)]
572    pub fn clear_bit(self) -> &'a mut W {
573        self.bit(false)
574    }
575    #[doc = r"Writes raw bits to the field"]
576    #[inline(always)]
577    pub fn bit(self, value: bool) -> &'a mut W {
578        self.w.bits =
579            (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
580        self.w
581    }
582}
583#[doc = "RTC interrupt enable for AP"]
584pub type RTC_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
585#[doc = "Field `RTC_INTR_EN_AP` reader - RTC interrupt enable for AP"]
586pub type RTC_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
587#[doc = "Field `RTC_INTR_EN_AP` writer - RTC interrupt enable for AP"]
588pub struct RTC_INTR_EN_AP_W<'a> {
589    w: &'a mut W,
590}
591impl<'a> RTC_INTR_EN_AP_W<'a> {
592    #[doc = r"Writes `variant` to the field"]
593    #[inline(always)]
594    pub fn variant(self, variant: RTC_INTR_EN_AP_A) -> &'a mut W {
595        self.bit(variant.into())
596    }
597    #[doc = "Disable the interrupt for the power domain"]
598    #[inline(always)]
599    pub fn enable(self) -> &'a mut W {
600        self.variant(RTC_INTR_EN_AP_A::ENABLE)
601    }
602    #[doc = "Enable the interrupt for the power domain"]
603    #[inline(always)]
604    pub fn disable(self) -> &'a mut W {
605        self.variant(RTC_INTR_EN_AP_A::DISABLE)
606    }
607    #[doc = r"Sets the field bit"]
608    #[inline(always)]
609    pub fn set_bit(self) -> &'a mut W {
610        self.bit(true)
611    }
612    #[doc = r"Clears the field bit"]
613    #[inline(always)]
614    pub fn clear_bit(self) -> &'a mut W {
615        self.bit(false)
616    }
617    #[doc = r"Writes raw bits to the field"]
618    #[inline(always)]
619    pub fn bit(self, value: bool) -> &'a mut W {
620        self.w.bits =
621            (self.w.bits & !(0x01 << 14)) | ((value as u32 & 0x01) << 14);
622        self.w
623    }
624}
625#[doc = "Reset interrupt enable for AP"]
626pub type RST_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
627#[doc = "Field `RST_INTR_EN_AP` reader - Reset interrupt enable for AP"]
628pub type RST_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
629#[doc = "Field `RST_INTR_EN_AP` writer - Reset interrupt enable for AP"]
630pub struct RST_INTR_EN_AP_W<'a> {
631    w: &'a mut W,
632}
633impl<'a> RST_INTR_EN_AP_W<'a> {
634    #[doc = r"Writes `variant` to the field"]
635    #[inline(always)]
636    pub fn variant(self, variant: RST_INTR_EN_AP_A) -> &'a mut W {
637        self.bit(variant.into())
638    }
639    #[doc = "Disable the interrupt for the power domain"]
640    #[inline(always)]
641    pub fn enable(self) -> &'a mut W {
642        self.variant(RST_INTR_EN_AP_A::ENABLE)
643    }
644    #[doc = "Enable the interrupt for the power domain"]
645    #[inline(always)]
646    pub fn disable(self) -> &'a mut W {
647        self.variant(RST_INTR_EN_AP_A::DISABLE)
648    }
649    #[doc = r"Sets the field bit"]
650    #[inline(always)]
651    pub fn set_bit(self) -> &'a mut W {
652        self.bit(true)
653    }
654    #[doc = r"Clears the field bit"]
655    #[inline(always)]
656    pub fn clear_bit(self) -> &'a mut W {
657        self.bit(false)
658    }
659    #[doc = r"Writes raw bits to the field"]
660    #[inline(always)]
661    pub fn bit(self, value: bool) -> &'a mut W {
662        self.w.bits =
663            (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
664        self.w
665    }
666}
667#[doc = "FFE0 Other interrupt enable for AP"]
668pub type FFE0_INTR_OTHERS_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
669#[doc = "Field `FFE0_INTR_OTHERS_EN_AP` reader - FFE0 Other interrupt enable for AP"]
670pub type FFE0_INTR_OTHERS_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
671#[doc = "Field `FFE0_INTR_OTHERS_EN_AP` writer - FFE0 Other interrupt enable for AP"]
672pub struct FFE0_INTR_OTHERS_EN_AP_W<'a> {
673    w: &'a mut W,
674}
675impl<'a> FFE0_INTR_OTHERS_EN_AP_W<'a> {
676    #[doc = r"Writes `variant` to the field"]
677    #[inline(always)]
678    pub fn variant(self, variant: FFE0_INTR_OTHERS_EN_AP_A) -> &'a mut W {
679        self.bit(variant.into())
680    }
681    #[doc = "Disable the interrupt for the power domain"]
682    #[inline(always)]
683    pub fn enable(self) -> &'a mut W {
684        self.variant(FFE0_INTR_OTHERS_EN_AP_A::ENABLE)
685    }
686    #[doc = "Enable the interrupt for the power domain"]
687    #[inline(always)]
688    pub fn disable(self) -> &'a mut W {
689        self.variant(FFE0_INTR_OTHERS_EN_AP_A::DISABLE)
690    }
691    #[doc = r"Sets the field bit"]
692    #[inline(always)]
693    pub fn set_bit(self) -> &'a mut W {
694        self.bit(true)
695    }
696    #[doc = r"Clears the field bit"]
697    #[inline(always)]
698    pub fn clear_bit(self) -> &'a mut W {
699        self.bit(false)
700    }
701    #[doc = r"Writes raw bits to the field"]
702    #[inline(always)]
703    pub fn bit(self, value: bool) -> &'a mut W {
704        self.w.bits =
705            (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
706        self.w
707    }
708}
709#[doc = "AP Boot interrupt enable for AP"]
710pub type APBOOT_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
711#[doc = "Field `APBOOT_EN_AP` reader - AP Boot interrupt enable for AP"]
712pub type APBOOT_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
713#[doc = "Field `APBOOT_EN_AP` writer - AP Boot interrupt enable for AP"]
714pub struct APBOOT_EN_AP_W<'a> {
715    w: &'a mut W,
716}
717impl<'a> APBOOT_EN_AP_W<'a> {
718    #[doc = r"Writes `variant` to the field"]
719    #[inline(always)]
720    pub fn variant(self, variant: APBOOT_EN_AP_A) -> &'a mut W {
721        self.bit(variant.into())
722    }
723    #[doc = "Disable the interrupt for the power domain"]
724    #[inline(always)]
725    pub fn enable(self) -> &'a mut W {
726        self.variant(APBOOT_EN_AP_A::ENABLE)
727    }
728    #[doc = "Enable the interrupt for the power domain"]
729    #[inline(always)]
730    pub fn disable(self) -> &'a mut W {
731        self.variant(APBOOT_EN_AP_A::DISABLE)
732    }
733    #[doc = r"Sets the field bit"]
734    #[inline(always)]
735    pub fn set_bit(self) -> &'a mut W {
736        self.bit(true)
737    }
738    #[doc = r"Clears the field bit"]
739    #[inline(always)]
740    pub fn clear_bit(self) -> &'a mut W {
741        self.bit(false)
742    }
743    #[doc = r"Writes raw bits to the field"]
744    #[inline(always)]
745    pub fn bit(self, value: bool) -> &'a mut W {
746        self.w.bits =
747            (self.w.bits & !(0x01 << 18)) | ((value as u32 & 0x01) << 18);
748        self.w
749    }
750}
751#[doc = "LDO30 absence of power good interrupt enable for AP"]
752pub type LDO30_PG_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
753#[doc = "Field `LDO30_PG_INTR_EN_AP` reader - LDO30 absence of power good interrupt enable for AP"]
754pub type LDO30_PG_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
755#[doc = "Field `LDO30_PG_INTR_EN_AP` writer - LDO30 absence of power good interrupt enable for AP"]
756pub struct LDO30_PG_INTR_EN_AP_W<'a> {
757    w: &'a mut W,
758}
759impl<'a> LDO30_PG_INTR_EN_AP_W<'a> {
760    #[doc = r"Writes `variant` to the field"]
761    #[inline(always)]
762    pub fn variant(self, variant: LDO30_PG_INTR_EN_AP_A) -> &'a mut W {
763        self.bit(variant.into())
764    }
765    #[doc = "Disable the interrupt for the power domain"]
766    #[inline(always)]
767    pub fn enable(self) -> &'a mut W {
768        self.variant(LDO30_PG_INTR_EN_AP_A::ENABLE)
769    }
770    #[doc = "Enable the interrupt for the power domain"]
771    #[inline(always)]
772    pub fn disable(self) -> &'a mut W {
773        self.variant(LDO30_PG_INTR_EN_AP_A::DISABLE)
774    }
775    #[doc = r"Sets the field bit"]
776    #[inline(always)]
777    pub fn set_bit(self) -> &'a mut W {
778        self.bit(true)
779    }
780    #[doc = r"Clears the field bit"]
781    #[inline(always)]
782    pub fn clear_bit(self) -> &'a mut W {
783        self.bit(false)
784    }
785    #[doc = r"Writes raw bits to the field"]
786    #[inline(always)]
787    pub fn bit(self, value: bool) -> &'a mut W {
788        self.w.bits =
789            (self.w.bits & !(0x01 << 19)) | ((value as u32 & 0x01) << 19);
790        self.w
791    }
792}
793#[doc = "LDO50 absence of power good interrupt enable for AP"]
794pub type LDO50_PG_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
795#[doc = "Field `LDO50_PG_INTR_EN_AP` reader - LDO50 absence of power good interrupt enable for AP"]
796pub type LDO50_PG_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
797#[doc = "Field `LDO50_PG_INTR_EN_AP` writer - LDO50 absence of power good interrupt enable for AP"]
798pub struct LDO50_PG_INTR_EN_AP_W<'a> {
799    w: &'a mut W,
800}
801impl<'a> LDO50_PG_INTR_EN_AP_W<'a> {
802    #[doc = r"Writes `variant` to the field"]
803    #[inline(always)]
804    pub fn variant(self, variant: LDO50_PG_INTR_EN_AP_A) -> &'a mut W {
805        self.bit(variant.into())
806    }
807    #[doc = "Disable the interrupt for the power domain"]
808    #[inline(always)]
809    pub fn enable(self) -> &'a mut W {
810        self.variant(LDO50_PG_INTR_EN_AP_A::ENABLE)
811    }
812    #[doc = "Enable the interrupt for the power domain"]
813    #[inline(always)]
814    pub fn disable(self) -> &'a mut W {
815        self.variant(LDO50_PG_INTR_EN_AP_A::DISABLE)
816    }
817    #[doc = r"Sets the field bit"]
818    #[inline(always)]
819    pub fn set_bit(self) -> &'a mut W {
820        self.bit(true)
821    }
822    #[doc = r"Clears the field bit"]
823    #[inline(always)]
824    pub fn clear_bit(self) -> &'a mut W {
825        self.bit(false)
826    }
827    #[doc = r"Writes raw bits to the field"]
828    #[inline(always)]
829    pub fn bit(self, value: bool) -> &'a mut W {
830        self.w.bits =
831            (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
832        self.w
833    }
834}
835#[doc = "SRAM_128KB_TIMEOUT interrupt enable for AP"]
836pub type SRAM_128KB_TIMEOUT_INTR_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
837#[doc = "Field `SRAM_128KB_TIMEOUT_INTR_EN_AP` reader - SRAM_128KB_TIMEOUT interrupt enable for AP"]
838pub type SRAM_128KB_TIMEOUT_INTR_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
839#[doc = "Field `SRAM_128KB_TIMEOUT_INTR_EN_AP` writer - SRAM_128KB_TIMEOUT interrupt enable for AP"]
840pub struct SRAM_128KB_TIMEOUT_INTR_EN_AP_W<'a> {
841    w: &'a mut W,
842}
843impl<'a> SRAM_128KB_TIMEOUT_INTR_EN_AP_W<'a> {
844    #[doc = r"Writes `variant` to the field"]
845    #[inline(always)]
846    pub fn variant(
847        self,
848        variant: SRAM_128KB_TIMEOUT_INTR_EN_AP_A,
849    ) -> &'a mut W {
850        self.bit(variant.into())
851    }
852    #[doc = "Disable the interrupt for the power domain"]
853    #[inline(always)]
854    pub fn enable(self) -> &'a mut W {
855        self.variant(SRAM_128KB_TIMEOUT_INTR_EN_AP_A::ENABLE)
856    }
857    #[doc = "Enable the interrupt for the power domain"]
858    #[inline(always)]
859    pub fn disable(self) -> &'a mut W {
860        self.variant(SRAM_128KB_TIMEOUT_INTR_EN_AP_A::DISABLE)
861    }
862    #[doc = r"Sets the field bit"]
863    #[inline(always)]
864    pub fn set_bit(self) -> &'a mut W {
865        self.bit(true)
866    }
867    #[doc = r"Clears the field bit"]
868    #[inline(always)]
869    pub fn clear_bit(self) -> &'a mut W {
870        self.bit(false)
871    }
872    #[doc = r"Writes raw bits to the field"]
873    #[inline(always)]
874    pub fn bit(self, value: bool) -> &'a mut W {
875        self.w.bits =
876            (self.w.bits & !(0x01 << 21)) | ((value as u32 & 0x01) << 21);
877        self.w
878    }
879}
880#[doc = "LPSD Voice detected interrupt enable for AP"]
881pub type LPSD_VOICE_DET_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
882#[doc = "Field `LPSD_VOICE_DET_EN_AP` reader - LPSD Voice detected interrupt enable for AP"]
883pub type LPSD_VOICE_DET_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
884#[doc = "Field `LPSD_VOICE_DET_EN_AP` writer - LPSD Voice detected interrupt enable for AP"]
885pub struct LPSD_VOICE_DET_EN_AP_W<'a> {
886    w: &'a mut W,
887}
888impl<'a> LPSD_VOICE_DET_EN_AP_W<'a> {
889    #[doc = r"Writes `variant` to the field"]
890    #[inline(always)]
891    pub fn variant(self, variant: LPSD_VOICE_DET_EN_AP_A) -> &'a mut W {
892        self.bit(variant.into())
893    }
894    #[doc = "Disable the interrupt for the power domain"]
895    #[inline(always)]
896    pub fn enable(self) -> &'a mut W {
897        self.variant(LPSD_VOICE_DET_EN_AP_A::ENABLE)
898    }
899    #[doc = "Enable the interrupt for the power domain"]
900    #[inline(always)]
901    pub fn disable(self) -> &'a mut W {
902        self.variant(LPSD_VOICE_DET_EN_AP_A::DISABLE)
903    }
904    #[doc = r"Sets the field bit"]
905    #[inline(always)]
906    pub fn set_bit(self) -> &'a mut W {
907        self.bit(true)
908    }
909    #[doc = r"Clears the field bit"]
910    #[inline(always)]
911    pub fn clear_bit(self) -> &'a mut W {
912        self.bit(false)
913    }
914    #[doc = r"Writes raw bits to the field"]
915    #[inline(always)]
916    pub fn bit(self, value: bool) -> &'a mut W {
917        self.w.bits =
918            (self.w.bits & !(0x01 << 22)) | ((value as u32 & 0x01) << 22);
919        self.w
920    }
921}
922#[doc = "Digital Mic interrupt enable for AP"]
923pub type DMIC_VOICE_DET_EN_AP_A = M4_SRAM_INTR_EN_AP_A;
924#[doc = "Field `DMIC_VOICE_DET_EN_AP` reader - Digital Mic interrupt enable for AP"]
925pub type DMIC_VOICE_DET_EN_AP_R = M4_SRAM_INTR_EN_AP_R;
926#[doc = "Field `DMIC_VOICE_DET_EN_AP` writer - Digital Mic interrupt enable for AP"]
927pub struct DMIC_VOICE_DET_EN_AP_W<'a> {
928    w: &'a mut W,
929}
930impl<'a> DMIC_VOICE_DET_EN_AP_W<'a> {
931    #[doc = r"Writes `variant` to the field"]
932    #[inline(always)]
933    pub fn variant(self, variant: DMIC_VOICE_DET_EN_AP_A) -> &'a mut W {
934        self.bit(variant.into())
935    }
936    #[doc = "Disable the interrupt for the power domain"]
937    #[inline(always)]
938    pub fn enable(self) -> &'a mut W {
939        self.variant(DMIC_VOICE_DET_EN_AP_A::ENABLE)
940    }
941    #[doc = "Enable the interrupt for the power domain"]
942    #[inline(always)]
943    pub fn disable(self) -> &'a mut W {
944        self.variant(DMIC_VOICE_DET_EN_AP_A::DISABLE)
945    }
946    #[doc = r"Sets the field bit"]
947    #[inline(always)]
948    pub fn set_bit(self) -> &'a mut W {
949        self.bit(true)
950    }
951    #[doc = r"Clears the field bit"]
952    #[inline(always)]
953    pub fn clear_bit(self) -> &'a mut W {
954        self.bit(false)
955    }
956    #[doc = r"Writes raw bits to the field"]
957    #[inline(always)]
958    pub fn bit(self, value: bool) -> &'a mut W {
959        self.w.bits =
960            (self.w.bits & !(0x01 << 23)) | ((value as u32 & 0x01) << 23);
961        self.w
962    }
963}
964impl R {
965    #[doc = "Bit 0 - M4 SRAM (access during low power) interrupt enable for AP"]
966    #[inline(always)]
967    pub fn m4_sram_intr_en_ap(&self) -> M4_SRAM_INTR_EN_AP_R {
968        M4_SRAM_INTR_EN_AP_R::new((self.bits & 0x01) != 0)
969    }
970    #[doc = "Bit 1 - UART interrupt enable for AP"]
971    #[inline(always)]
972    pub fn uart_intr_en_ap(&self) -> UART_INTR_EN_AP_R {
973        UART_INTR_EN_AP_R::new(((self.bits >> 1) & 0x01) != 0)
974    }
975    #[doc = "Bit 2 - Timer interrupt enable for AP"]
976    #[inline(always)]
977    pub fn timer_intr_en_ap(&self) -> TIMER_INTR_EN_AP_R {
978        TIMER_INTR_EN_AP_R::new(((self.bits >> 2) & 0x01) != 0)
979    }
980    #[doc = "Bit 3 - WDT M4 interrupt enable for AP"]
981    #[inline(always)]
982    pub fn wdog_intr_en_ap(&self) -> WDOG_INTR_EN_AP_R {
983        WDOG_INTR_EN_AP_R::new(((self.bits >> 3) & 0x01) != 0)
984    }
985    #[doc = "Bit 4 - WDT M4 Reset interrupt enable for AP"]
986    #[inline(always)]
987    pub fn wdog_rst_en_ap(&self) -> WDOG_RST_EN_AP_R {
988        WDOG_RST_EN_AP_R::new(((self.bits >> 4) & 0x01) != 0)
989    }
990    #[doc = "Bit 5 - Bus Timeout interrupt enable for AP"]
991    #[inline(always)]
992    pub fn timeout_intr_en_ap(&self) -> TIMEOUT_INTR_EN_AP_R {
993        TIMEOUT_INTR_EN_AP_R::new(((self.bits >> 5) & 0x01) != 0)
994    }
995    #[doc = "Bit 6 - M4 FPU interrupt enable for AP"]
996    #[inline(always)]
997    pub fn fpu_intr_en_ap(&self) -> FPU_INTR_EN_AP_R {
998        FPU_INTR_EN_AP_R::new(((self.bits >> 6) & 0x01) != 0)
999    }
1000    #[doc = "Bit 7 - Packet FIFO Bank interrupt enable for AP"]
1001    #[inline(always)]
1002    pub fn pkfb_intr_en_ap(&self) -> PKFB_INTR_EN_AP_R {
1003        PKFB_INTR_EN_AP_R::new(((self.bits >> 7) & 0x01) != 0)
1004    }
1005    #[doc = "Bit 10 - SPI Master interrupt enable for AP"]
1006    #[inline(always)]
1007    pub fn spi_ms_intr_en_ap(&self) -> SPI_MS_INTR_EN_AP_R {
1008        SPI_MS_INTR_EN_AP_R::new(((self.bits >> 10) & 0x01) != 0)
1009    }
1010    #[doc = "Bit 11 - Config DMA interrupt enable for AP"]
1011    #[inline(always)]
1012    pub fn cfg_dma_done_intr_en_ap(&self) -> CFG_DMA_DONE_INTR_EN_AP_R {
1013        CFG_DMA_DONE_INTR_EN_AP_R::new(((self.bits >> 11) & 0x01) != 0)
1014    }
1015    #[doc = "Bit 12 - PMU Timer interrupt enable for AP"]
1016    #[inline(always)]
1017    pub fn pmu_tmr_intr_en_ap(&self) -> PMU_TMR_INTR_EN_AP_R {
1018        PMU_TMR_INTR_EN_AP_R::new(((self.bits >> 12) & 0x01) != 0)
1019    }
1020    #[doc = "Bit 13 - ADC interrupt enable for AP"]
1021    #[inline(always)]
1022    pub fn adc_intr_en_ap(&self) -> ADC_INTR_EN_AP_R {
1023        ADC_INTR_EN_AP_R::new(((self.bits >> 13) & 0x01) != 0)
1024    }
1025    #[doc = "Bit 14 - RTC interrupt enable for AP"]
1026    #[inline(always)]
1027    pub fn rtc_intr_en_ap(&self) -> RTC_INTR_EN_AP_R {
1028        RTC_INTR_EN_AP_R::new(((self.bits >> 14) & 0x01) != 0)
1029    }
1030    #[doc = "Bit 15 - Reset interrupt enable for AP"]
1031    #[inline(always)]
1032    pub fn rst_intr_en_ap(&self) -> RST_INTR_EN_AP_R {
1033        RST_INTR_EN_AP_R::new(((self.bits >> 15) & 0x01) != 0)
1034    }
1035    #[doc = "Bit 16 - FFE0 Other interrupt enable for AP"]
1036    #[inline(always)]
1037    pub fn ffe0_intr_others_en_ap(&self) -> FFE0_INTR_OTHERS_EN_AP_R {
1038        FFE0_INTR_OTHERS_EN_AP_R::new(((self.bits >> 16) & 0x01) != 0)
1039    }
1040    #[doc = "Bit 18 - AP Boot interrupt enable for AP"]
1041    #[inline(always)]
1042    pub fn apboot_en_ap(&self) -> APBOOT_EN_AP_R {
1043        APBOOT_EN_AP_R::new(((self.bits >> 18) & 0x01) != 0)
1044    }
1045    #[doc = "Bit 19 - LDO30 absence of power good interrupt enable for AP"]
1046    #[inline(always)]
1047    pub fn ldo30_pg_intr_en_ap(&self) -> LDO30_PG_INTR_EN_AP_R {
1048        LDO30_PG_INTR_EN_AP_R::new(((self.bits >> 19) & 0x01) != 0)
1049    }
1050    #[doc = "Bit 20 - LDO50 absence of power good interrupt enable for AP"]
1051    #[inline(always)]
1052    pub fn ldo50_pg_intr_en_ap(&self) -> LDO50_PG_INTR_EN_AP_R {
1053        LDO50_PG_INTR_EN_AP_R::new(((self.bits >> 20) & 0x01) != 0)
1054    }
1055    #[doc = "Bit 21 - SRAM_128KB_TIMEOUT interrupt enable for AP"]
1056    #[inline(always)]
1057    pub fn sram_128kb_timeout_intr_en_ap(
1058        &self,
1059    ) -> SRAM_128KB_TIMEOUT_INTR_EN_AP_R {
1060        SRAM_128KB_TIMEOUT_INTR_EN_AP_R::new(((self.bits >> 21) & 0x01) != 0)
1061    }
1062    #[doc = "Bit 22 - LPSD Voice detected interrupt enable for AP"]
1063    #[inline(always)]
1064    pub fn lpsd_voice_det_en_ap(&self) -> LPSD_VOICE_DET_EN_AP_R {
1065        LPSD_VOICE_DET_EN_AP_R::new(((self.bits >> 22) & 0x01) != 0)
1066    }
1067    #[doc = "Bit 23 - Digital Mic interrupt enable for AP"]
1068    #[inline(always)]
1069    pub fn dmic_voice_det_en_ap(&self) -> DMIC_VOICE_DET_EN_AP_R {
1070        DMIC_VOICE_DET_EN_AP_R::new(((self.bits >> 23) & 0x01) != 0)
1071    }
1072}
1073impl W {
1074    #[doc = "Bit 0 - M4 SRAM (access during low power) interrupt enable for AP"]
1075    #[inline(always)]
1076    pub fn m4_sram_intr_en_ap(&mut self) -> M4_SRAM_INTR_EN_AP_W {
1077        M4_SRAM_INTR_EN_AP_W { w: self }
1078    }
1079    #[doc = "Bit 1 - UART interrupt enable for AP"]
1080    #[inline(always)]
1081    pub fn uart_intr_en_ap(&mut self) -> UART_INTR_EN_AP_W {
1082        UART_INTR_EN_AP_W { w: self }
1083    }
1084    #[doc = "Bit 2 - Timer interrupt enable for AP"]
1085    #[inline(always)]
1086    pub fn timer_intr_en_ap(&mut self) -> TIMER_INTR_EN_AP_W {
1087        TIMER_INTR_EN_AP_W { w: self }
1088    }
1089    #[doc = "Bit 3 - WDT M4 interrupt enable for AP"]
1090    #[inline(always)]
1091    pub fn wdog_intr_en_ap(&mut self) -> WDOG_INTR_EN_AP_W {
1092        WDOG_INTR_EN_AP_W { w: self }
1093    }
1094    #[doc = "Bit 4 - WDT M4 Reset interrupt enable for AP"]
1095    #[inline(always)]
1096    pub fn wdog_rst_en_ap(&mut self) -> WDOG_RST_EN_AP_W {
1097        WDOG_RST_EN_AP_W { w: self }
1098    }
1099    #[doc = "Bit 5 - Bus Timeout interrupt enable for AP"]
1100    #[inline(always)]
1101    pub fn timeout_intr_en_ap(&mut self) -> TIMEOUT_INTR_EN_AP_W {
1102        TIMEOUT_INTR_EN_AP_W { w: self }
1103    }
1104    #[doc = "Bit 6 - M4 FPU interrupt enable for AP"]
1105    #[inline(always)]
1106    pub fn fpu_intr_en_ap(&mut self) -> FPU_INTR_EN_AP_W {
1107        FPU_INTR_EN_AP_W { w: self }
1108    }
1109    #[doc = "Bit 7 - Packet FIFO Bank interrupt enable for AP"]
1110    #[inline(always)]
1111    pub fn pkfb_intr_en_ap(&mut self) -> PKFB_INTR_EN_AP_W {
1112        PKFB_INTR_EN_AP_W { w: self }
1113    }
1114    #[doc = "Bit 10 - SPI Master interrupt enable for AP"]
1115    #[inline(always)]
1116    pub fn spi_ms_intr_en_ap(&mut self) -> SPI_MS_INTR_EN_AP_W {
1117        SPI_MS_INTR_EN_AP_W { w: self }
1118    }
1119    #[doc = "Bit 11 - Config DMA interrupt enable for AP"]
1120    #[inline(always)]
1121    pub fn cfg_dma_done_intr_en_ap(&mut self) -> CFG_DMA_DONE_INTR_EN_AP_W {
1122        CFG_DMA_DONE_INTR_EN_AP_W { w: self }
1123    }
1124    #[doc = "Bit 12 - PMU Timer interrupt enable for AP"]
1125    #[inline(always)]
1126    pub fn pmu_tmr_intr_en_ap(&mut self) -> PMU_TMR_INTR_EN_AP_W {
1127        PMU_TMR_INTR_EN_AP_W { w: self }
1128    }
1129    #[doc = "Bit 13 - ADC interrupt enable for AP"]
1130    #[inline(always)]
1131    pub fn adc_intr_en_ap(&mut self) -> ADC_INTR_EN_AP_W {
1132        ADC_INTR_EN_AP_W { w: self }
1133    }
1134    #[doc = "Bit 14 - RTC interrupt enable for AP"]
1135    #[inline(always)]
1136    pub fn rtc_intr_en_ap(&mut self) -> RTC_INTR_EN_AP_W {
1137        RTC_INTR_EN_AP_W { w: self }
1138    }
1139    #[doc = "Bit 15 - Reset interrupt enable for AP"]
1140    #[inline(always)]
1141    pub fn rst_intr_en_ap(&mut self) -> RST_INTR_EN_AP_W {
1142        RST_INTR_EN_AP_W { w: self }
1143    }
1144    #[doc = "Bit 16 - FFE0 Other interrupt enable for AP"]
1145    #[inline(always)]
1146    pub fn ffe0_intr_others_en_ap(&mut self) -> FFE0_INTR_OTHERS_EN_AP_W {
1147        FFE0_INTR_OTHERS_EN_AP_W { w: self }
1148    }
1149    #[doc = "Bit 18 - AP Boot interrupt enable for AP"]
1150    #[inline(always)]
1151    pub fn apboot_en_ap(&mut self) -> APBOOT_EN_AP_W {
1152        APBOOT_EN_AP_W { w: self }
1153    }
1154    #[doc = "Bit 19 - LDO30 absence of power good interrupt enable for AP"]
1155    #[inline(always)]
1156    pub fn ldo30_pg_intr_en_ap(&mut self) -> LDO30_PG_INTR_EN_AP_W {
1157        LDO30_PG_INTR_EN_AP_W { w: self }
1158    }
1159    #[doc = "Bit 20 - LDO50 absence of power good interrupt enable for AP"]
1160    #[inline(always)]
1161    pub fn ldo50_pg_intr_en_ap(&mut self) -> LDO50_PG_INTR_EN_AP_W {
1162        LDO50_PG_INTR_EN_AP_W { w: self }
1163    }
1164    #[doc = "Bit 21 - SRAM_128KB_TIMEOUT interrupt enable for AP"]
1165    #[inline(always)]
1166    pub fn sram_128kb_timeout_intr_en_ap(
1167        &mut self,
1168    ) -> SRAM_128KB_TIMEOUT_INTR_EN_AP_W {
1169        SRAM_128KB_TIMEOUT_INTR_EN_AP_W { w: self }
1170    }
1171    #[doc = "Bit 22 - LPSD Voice detected interrupt enable for AP"]
1172    #[inline(always)]
1173    pub fn lpsd_voice_det_en_ap(&mut self) -> LPSD_VOICE_DET_EN_AP_W {
1174        LPSD_VOICE_DET_EN_AP_W { w: self }
1175    }
1176    #[doc = "Bit 23 - Digital Mic interrupt enable for AP"]
1177    #[inline(always)]
1178    pub fn dmic_voice_det_en_ap(&mut self) -> DMIC_VOICE_DET_EN_AP_W {
1179        DMIC_VOICE_DET_EN_AP_W { w: self }
1180    }
1181    #[doc = "Writes raw bits to the register."]
1182    #[inline(always)]
1183    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1184        self.0.bits(bits);
1185        self
1186    }
1187}
1188#[doc = "Various interrupt enable for AP\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 [other_intr_en_ap](index.html) module"]
1189pub struct OTHER_INTR_EN_AP_SPEC;
1190impl crate::RegisterSpec for OTHER_INTR_EN_AP_SPEC {
1191    type Ux = u32;
1192}
1193#[doc = "`read()` method returns [other_intr_en_ap::R](R) reader structure"]
1194impl crate::Readable for OTHER_INTR_EN_AP_SPEC {
1195    type Reader = R;
1196}
1197#[doc = "`write(|w| ..)` method takes [other_intr_en_ap::W](W) writer structure"]
1198impl crate::Writable for OTHER_INTR_EN_AP_SPEC {
1199    type Writer = W;
1200}
1201#[doc = "`reset()` method sets OTHER_INTR_EN_AP to value 0"]
1202impl crate::Resettable for OTHER_INTR_EN_AP_SPEC {
1203    #[inline(always)]
1204    fn reset_value() -> Self::Ux {
1205        0
1206    }
1207}
eos_s3/intr_ctrl/other_intr_en_ap.rs

eos_s3/intr_ctrl/
other_intr_en_ap.rs
