k510_pac/sysctl/
sys_ctl_int0_raw.rs

1#[doc = "Register `SYS_CTL_INT0_RAW` reader"]
2pub struct R(crate::R<SYS_CTL_INT0_RAW_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<SYS_CTL_INT0_RAW_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<SYS_CTL_INT0_RAW_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<SYS_CTL_INT0_RAW_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `SYS_CTL_INT0_RAW` writer"]
17pub struct W(crate::W<SYS_CTL_INT0_RAW_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<SYS_CTL_INT0_RAW_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<SYS_CTL_INT0_RAW_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<SYS_CTL_INT0_RAW_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "USB power domain go power-off interrupt status bit\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum PD_USB_PD_RAW_A {
40    #[doc = "0: No interrupt happens"]
41    NO_INTERRUPT = 0,
42    #[doc = "1: PD_USB enter Power-Off state"]
43    PENDING = 1,
44}
45impl From<PD_USB_PD_RAW_A> for bool {
46    #[inline(always)]
47    fn from(variant: PD_USB_PD_RAW_A) -> Self {
48        variant as u8 != 0
49    }
50}
51#[doc = "Field `pd_usb_pd_raw` reader - USB power domain go power-off interrupt status bit"]
52pub type PD_USB_PD_RAW_R = crate::BitReader<PD_USB_PD_RAW_A>;
53impl PD_USB_PD_RAW_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> PD_USB_PD_RAW_A {
57        match self.bits {
58            false => PD_USB_PD_RAW_A::NO_INTERRUPT,
59            true => PD_USB_PD_RAW_A::PENDING,
60        }
61    }
62    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
63    #[inline(always)]
64    pub fn is_no_interrupt(&self) -> bool {
65        *self == PD_USB_PD_RAW_A::NO_INTERRUPT
66    }
67    #[doc = "Checks if the value of the field is `PENDING`"]
68    #[inline(always)]
69    pub fn is_pending(&self) -> bool {
70        *self == PD_USB_PD_RAW_A::PENDING
71    }
72}
73#[doc = "Field `pd_usb_pd_raw` writer - USB power domain go power-off interrupt status bit"]
74pub type PD_USB_PD_RAW_W<'a> =
75    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_USB_PD_RAW_A, 17>;
76impl<'a> PD_USB_PD_RAW_W<'a> {
77    #[doc = "No interrupt happens"]
78    #[inline(always)]
79    pub fn no_interrupt(self) -> &'a mut W {
80        self.variant(PD_USB_PD_RAW_A::NO_INTERRUPT)
81    }
82    #[doc = "PD_USB enter Power-Off state"]
83    #[inline(always)]
84    pub fn pending(self) -> &'a mut W {
85        self.variant(PD_USB_PD_RAW_A::PENDING)
86    }
87}
88#[doc = "H264 power domain go power-off interrupt status bit\n\nValue on reset: 0"]
89#[derive(Clone, Copy, Debug, PartialEq)]
90pub enum PD_H264_PD_RAW_A {
91    #[doc = "0: No interrupt happens"]
92    NO_INTERRUPT = 0,
93    #[doc = "1: PD_H264 enter Power-Off state"]
94    PENDING = 1,
95}
96impl From<PD_H264_PD_RAW_A> for bool {
97    #[inline(always)]
98    fn from(variant: PD_H264_PD_RAW_A) -> Self {
99        variant as u8 != 0
100    }
101}
102#[doc = "Field `pd_h264_pd_raw` reader - H264 power domain go power-off interrupt status bit"]
103pub type PD_H264_PD_RAW_R = crate::BitReader<PD_H264_PD_RAW_A>;
104impl PD_H264_PD_RAW_R {
105    #[doc = "Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> PD_H264_PD_RAW_A {
108        match self.bits {
109            false => PD_H264_PD_RAW_A::NO_INTERRUPT,
110            true => PD_H264_PD_RAW_A::PENDING,
111        }
112    }
113    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
114    #[inline(always)]
115    pub fn is_no_interrupt(&self) -> bool {
116        *self == PD_H264_PD_RAW_A::NO_INTERRUPT
117    }
118    #[doc = "Checks if the value of the field is `PENDING`"]
119    #[inline(always)]
120    pub fn is_pending(&self) -> bool {
121        *self == PD_H264_PD_RAW_A::PENDING
122    }
123}
124#[doc = "Field `pd_h264_pd_raw` writer - H264 power domain go power-off interrupt status bit"]
125pub type PD_H264_PD_RAW_W<'a> =
126    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_H264_PD_RAW_A, 16>;
127impl<'a> PD_H264_PD_RAW_W<'a> {
128    #[doc = "No interrupt happens"]
129    #[inline(always)]
130    pub fn no_interrupt(self) -> &'a mut W {
131        self.variant(PD_H264_PD_RAW_A::NO_INTERRUPT)
132    }
133    #[doc = "PD_H264 enter Power-Off state"]
134    #[inline(always)]
135    pub fn pending(self) -> &'a mut W {
136        self.variant(PD_H264_PD_RAW_A::PENDING)
137    }
138}
139#[doc = "DISP power domain go power-off interrupt status bit\n\nValue on reset: 0"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum PD_DISP_PD_RAW_A {
142    #[doc = "0: No interrupt happens"]
143    NO_INTERRUPT = 0,
144    #[doc = "1: PD_DISP enter Power-Off state"]
145    PENDING = 1,
146}
147impl From<PD_DISP_PD_RAW_A> for bool {
148    #[inline(always)]
149    fn from(variant: PD_DISP_PD_RAW_A) -> Self {
150        variant as u8 != 0
151    }
152}
153#[doc = "Field `pd_disp_pd_raw` reader - DISP power domain go power-off interrupt status bit"]
154pub type PD_DISP_PD_RAW_R = crate::BitReader<PD_DISP_PD_RAW_A>;
155impl PD_DISP_PD_RAW_R {
156    #[doc = "Get enumerated values variant"]
157    #[inline(always)]
158    pub fn variant(&self) -> PD_DISP_PD_RAW_A {
159        match self.bits {
160            false => PD_DISP_PD_RAW_A::NO_INTERRUPT,
161            true => PD_DISP_PD_RAW_A::PENDING,
162        }
163    }
164    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
165    #[inline(always)]
166    pub fn is_no_interrupt(&self) -> bool {
167        *self == PD_DISP_PD_RAW_A::NO_INTERRUPT
168    }
169    #[doc = "Checks if the value of the field is `PENDING`"]
170    #[inline(always)]
171    pub fn is_pending(&self) -> bool {
172        *self == PD_DISP_PD_RAW_A::PENDING
173    }
174}
175#[doc = "Field `pd_disp_pd_raw` writer - DISP power domain go power-off interrupt status bit"]
176pub type PD_DISP_PD_RAW_W<'a> =
177    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_DISP_PD_RAW_A, 15>;
178impl<'a> PD_DISP_PD_RAW_W<'a> {
179    #[doc = "No interrupt happens"]
180    #[inline(always)]
181    pub fn no_interrupt(self) -> &'a mut W {
182        self.variant(PD_DISP_PD_RAW_A::NO_INTERRUPT)
183    }
184    #[doc = "PD_DISP enter Power-Off state"]
185    #[inline(always)]
186    pub fn pending(self) -> &'a mut W {
187        self.variant(PD_DISP_PD_RAW_A::PENDING)
188    }
189}
190#[doc = "ISP power domain go power-off interrupt status bit\n\nValue on reset: 0"]
191#[derive(Clone, Copy, Debug, PartialEq)]
192pub enum PD_ISP_PD_RAW_A {
193    #[doc = "0: No interrupt happens"]
194    NO_INTERRUPT = 0,
195    #[doc = "1: PD_ISP enter Power-Off state"]
196    PENDING = 1,
197}
198impl From<PD_ISP_PD_RAW_A> for bool {
199    #[inline(always)]
200    fn from(variant: PD_ISP_PD_RAW_A) -> Self {
201        variant as u8 != 0
202    }
203}
204#[doc = "Field `pd_isp_pd_raw` reader - ISP power domain go power-off interrupt status bit"]
205pub type PD_ISP_PD_RAW_R = crate::BitReader<PD_ISP_PD_RAW_A>;
206impl PD_ISP_PD_RAW_R {
207    #[doc = "Get enumerated values variant"]
208    #[inline(always)]
209    pub fn variant(&self) -> PD_ISP_PD_RAW_A {
210        match self.bits {
211            false => PD_ISP_PD_RAW_A::NO_INTERRUPT,
212            true => PD_ISP_PD_RAW_A::PENDING,
213        }
214    }
215    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
216    #[inline(always)]
217    pub fn is_no_interrupt(&self) -> bool {
218        *self == PD_ISP_PD_RAW_A::NO_INTERRUPT
219    }
220    #[doc = "Checks if the value of the field is `PENDING`"]
221    #[inline(always)]
222    pub fn is_pending(&self) -> bool {
223        *self == PD_ISP_PD_RAW_A::PENDING
224    }
225}
226#[doc = "Field `pd_isp_pd_raw` writer - ISP power domain go power-off interrupt status bit"]
227pub type PD_ISP_PD_RAW_W<'a> =
228    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_ISP_PD_RAW_A, 10>;
229impl<'a> PD_ISP_PD_RAW_W<'a> {
230    #[doc = "No interrupt happens"]
231    #[inline(always)]
232    pub fn no_interrupt(self) -> &'a mut W {
233        self.variant(PD_ISP_PD_RAW_A::NO_INTERRUPT)
234    }
235    #[doc = "PD_ISP enter Power-Off state"]
236    #[inline(always)]
237    pub fn pending(self) -> &'a mut W {
238        self.variant(PD_ISP_PD_RAW_A::PENDING)
239    }
240}
241#[doc = "Memory Controller power domain go power-off interrupt status bit\n\nValue on reset: 0"]
242#[derive(Clone, Copy, Debug, PartialEq)]
243pub enum PD_MCTL_PD_RAW_A {
244    #[doc = "0: No interrupt happens"]
245    NO_INTERRUPT = 0,
246    #[doc = "1: PD_MCTL enter Power-Off state"]
247    PENDING = 1,
248}
249impl From<PD_MCTL_PD_RAW_A> for bool {
250    #[inline(always)]
251    fn from(variant: PD_MCTL_PD_RAW_A) -> Self {
252        variant as u8 != 0
253    }
254}
255#[doc = "Field `pd_mctl_pd_raw` reader - Memory Controller power domain go power-off interrupt status bit"]
256pub type PD_MCTL_PD_RAW_R = crate::BitReader<PD_MCTL_PD_RAW_A>;
257impl PD_MCTL_PD_RAW_R {
258    #[doc = "Get enumerated values variant"]
259    #[inline(always)]
260    pub fn variant(&self) -> PD_MCTL_PD_RAW_A {
261        match self.bits {
262            false => PD_MCTL_PD_RAW_A::NO_INTERRUPT,
263            true => PD_MCTL_PD_RAW_A::PENDING,
264        }
265    }
266    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
267    #[inline(always)]
268    pub fn is_no_interrupt(&self) -> bool {
269        *self == PD_MCTL_PD_RAW_A::NO_INTERRUPT
270    }
271    #[doc = "Checks if the value of the field is `PENDING`"]
272    #[inline(always)]
273    pub fn is_pending(&self) -> bool {
274        *self == PD_MCTL_PD_RAW_A::PENDING
275    }
276}
277#[doc = "Field `pd_mctl_pd_raw` writer - Memory Controller power domain go power-off interrupt status bit"]
278pub type PD_MCTL_PD_RAW_W<'a> =
279    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_MCTL_PD_RAW_A, 9>;
280impl<'a> PD_MCTL_PD_RAW_W<'a> {
281    #[doc = "No interrupt happens"]
282    #[inline(always)]
283    pub fn no_interrupt(self) -> &'a mut W {
284        self.variant(PD_MCTL_PD_RAW_A::NO_INTERRUPT)
285    }
286    #[doc = "PD_MCTL enter Power-Off state"]
287    #[inline(always)]
288    pub fn pending(self) -> &'a mut W {
289        self.variant(PD_MCTL_PD_RAW_A::PENDING)
290    }
291}
292#[doc = "SRAM1 power domain go power-off interrupt status bit\n\nValue on reset: 0"]
293#[derive(Clone, Copy, Debug, PartialEq)]
294pub enum PD_RAM1_PD_RAW_A {
295    #[doc = "0: No interrupt happens"]
296    NO_INTERRUPT = 0,
297    #[doc = "1: PD_RAM1 enter Power-Off state"]
298    PENDING = 1,
299}
300impl From<PD_RAM1_PD_RAW_A> for bool {
301    #[inline(always)]
302    fn from(variant: PD_RAM1_PD_RAW_A) -> Self {
303        variant as u8 != 0
304    }
305}
306#[doc = "Field `pd_ram1_pd_raw` reader - SRAM1 power domain go power-off interrupt status bit"]
307pub type PD_RAM1_PD_RAW_R = crate::BitReader<PD_RAM1_PD_RAW_A>;
308impl PD_RAM1_PD_RAW_R {
309    #[doc = "Get enumerated values variant"]
310    #[inline(always)]
311    pub fn variant(&self) -> PD_RAM1_PD_RAW_A {
312        match self.bits {
313            false => PD_RAM1_PD_RAW_A::NO_INTERRUPT,
314            true => PD_RAM1_PD_RAW_A::PENDING,
315        }
316    }
317    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
318    #[inline(always)]
319    pub fn is_no_interrupt(&self) -> bool {
320        *self == PD_RAM1_PD_RAW_A::NO_INTERRUPT
321    }
322    #[doc = "Checks if the value of the field is `PENDING`"]
323    #[inline(always)]
324    pub fn is_pending(&self) -> bool {
325        *self == PD_RAM1_PD_RAW_A::PENDING
326    }
327}
328#[doc = "Field `pd_ram1_pd_raw` writer - SRAM1 power domain go power-off interrupt status bit"]
329pub type PD_RAM1_PD_RAW_W<'a> =
330    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_RAM1_PD_RAW_A, 8>;
331impl<'a> PD_RAM1_PD_RAW_W<'a> {
332    #[doc = "No interrupt happens"]
333    #[inline(always)]
334    pub fn no_interrupt(self) -> &'a mut W {
335        self.variant(PD_RAM1_PD_RAW_A::NO_INTERRUPT)
336    }
337    #[doc = "PD_RAM1 enter Power-Off state"]
338    #[inline(always)]
339    pub fn pending(self) -> &'a mut W {
340        self.variant(PD_RAM1_PD_RAW_A::PENDING)
341    }
342}
343#[doc = "SRAM0 power domain go power-off interrupt status bit\n\nValue on reset: 0"]
344#[derive(Clone, Copy, Debug, PartialEq)]
345pub enum PD_RAM0_PD_RAW_A {
346    #[doc = "0: No interrupt happens"]
347    NO_INTERRUPT = 0,
348    #[doc = "1: PD_RAM0 enter Power-Off state"]
349    PENDING = 1,
350}
351impl From<PD_RAM0_PD_RAW_A> for bool {
352    #[inline(always)]
353    fn from(variant: PD_RAM0_PD_RAW_A) -> Self {
354        variant as u8 != 0
355    }
356}
357#[doc = "Field `pd_ram0_pd_raw` reader - SRAM0 power domain go power-off interrupt status bit"]
358pub type PD_RAM0_PD_RAW_R = crate::BitReader<PD_RAM0_PD_RAW_A>;
359impl PD_RAM0_PD_RAW_R {
360    #[doc = "Get enumerated values variant"]
361    #[inline(always)]
362    pub fn variant(&self) -> PD_RAM0_PD_RAW_A {
363        match self.bits {
364            false => PD_RAM0_PD_RAW_A::NO_INTERRUPT,
365            true => PD_RAM0_PD_RAW_A::PENDING,
366        }
367    }
368    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
369    #[inline(always)]
370    pub fn is_no_interrupt(&self) -> bool {
371        *self == PD_RAM0_PD_RAW_A::NO_INTERRUPT
372    }
373    #[doc = "Checks if the value of the field is `PENDING`"]
374    #[inline(always)]
375    pub fn is_pending(&self) -> bool {
376        *self == PD_RAM0_PD_RAW_A::PENDING
377    }
378}
379#[doc = "Field `pd_ram0_pd_raw` writer - SRAM0 power domain go power-off interrupt status bit"]
380pub type PD_RAM0_PD_RAW_W<'a> =
381    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_RAM0_PD_RAW_A, 7>;
382impl<'a> PD_RAM0_PD_RAW_W<'a> {
383    #[doc = "No interrupt happens"]
384    #[inline(always)]
385    pub fn no_interrupt(self) -> &'a mut W {
386        self.variant(PD_RAM0_PD_RAW_A::NO_INTERRUPT)
387    }
388    #[doc = "PD_RAM0 enter Power-Off state"]
389    #[inline(always)]
390    pub fn pending(self) -> &'a mut W {
391        self.variant(PD_RAM0_PD_RAW_A::PENDING)
392    }
393}
394#[doc = "Storage power domain go power-off interrupt status bit\n\nValue on reset: 0"]
395#[derive(Clone, Copy, Debug, PartialEq)]
396pub enum PD_STOR_PD_RAW_A {
397    #[doc = "0: No interrupt happens"]
398    NO_INTERRUPT = 0,
399    #[doc = "1: PD_STOR enter Power-Off state"]
400    PENDING = 1,
401}
402impl From<PD_STOR_PD_RAW_A> for bool {
403    #[inline(always)]
404    fn from(variant: PD_STOR_PD_RAW_A) -> Self {
405        variant as u8 != 0
406    }
407}
408#[doc = "Field `pd_stor_pd_raw` reader - Storage power domain go power-off interrupt status bit"]
409pub type PD_STOR_PD_RAW_R = crate::BitReader<PD_STOR_PD_RAW_A>;
410impl PD_STOR_PD_RAW_R {
411    #[doc = "Get enumerated values variant"]
412    #[inline(always)]
413    pub fn variant(&self) -> PD_STOR_PD_RAW_A {
414        match self.bits {
415            false => PD_STOR_PD_RAW_A::NO_INTERRUPT,
416            true => PD_STOR_PD_RAW_A::PENDING,
417        }
418    }
419    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
420    #[inline(always)]
421    pub fn is_no_interrupt(&self) -> bool {
422        *self == PD_STOR_PD_RAW_A::NO_INTERRUPT
423    }
424    #[doc = "Checks if the value of the field is `PENDING`"]
425    #[inline(always)]
426    pub fn is_pending(&self) -> bool {
427        *self == PD_STOR_PD_RAW_A::PENDING
428    }
429}
430#[doc = "Field `pd_stor_pd_raw` writer - Storage power domain go power-off interrupt status bit"]
431pub type PD_STOR_PD_RAW_W<'a> =
432    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_STOR_PD_RAW_A, 6>;
433impl<'a> PD_STOR_PD_RAW_W<'a> {
434    #[doc = "No interrupt happens"]
435    #[inline(always)]
436    pub fn no_interrupt(self) -> &'a mut W {
437        self.variant(PD_STOR_PD_RAW_A::NO_INTERRUPT)
438    }
439    #[doc = "PD_STOR enter Power-Off state"]
440    #[inline(always)]
441    pub fn pending(self) -> &'a mut W {
442        self.variant(PD_STOR_PD_RAW_A::PENDING)
443    }
444}
445#[doc = "Peripheral power domain go power-off interrupt status bit\n\nValue on reset: 0"]
446#[derive(Clone, Copy, Debug, PartialEq)]
447pub enum PD_PERI_PD_RAW_A {
448    #[doc = "0: No interrupt happens"]
449    NO_INTERRUPT = 0,
450    #[doc = "1: PD_PERI enter Power-Off state"]
451    PENDING = 1,
452}
453impl From<PD_PERI_PD_RAW_A> for bool {
454    #[inline(always)]
455    fn from(variant: PD_PERI_PD_RAW_A) -> Self {
456        variant as u8 != 0
457    }
458}
459#[doc = "Field `pd_peri_pd_raw` reader - Peripheral power domain go power-off interrupt status bit"]
460pub type PD_PERI_PD_RAW_R = crate::BitReader<PD_PERI_PD_RAW_A>;
461impl PD_PERI_PD_RAW_R {
462    #[doc = "Get enumerated values variant"]
463    #[inline(always)]
464    pub fn variant(&self) -> PD_PERI_PD_RAW_A {
465        match self.bits {
466            false => PD_PERI_PD_RAW_A::NO_INTERRUPT,
467            true => PD_PERI_PD_RAW_A::PENDING,
468        }
469    }
470    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
471    #[inline(always)]
472    pub fn is_no_interrupt(&self) -> bool {
473        *self == PD_PERI_PD_RAW_A::NO_INTERRUPT
474    }
475    #[doc = "Checks if the value of the field is `PENDING`"]
476    #[inline(always)]
477    pub fn is_pending(&self) -> bool {
478        *self == PD_PERI_PD_RAW_A::PENDING
479    }
480}
481#[doc = "Field `pd_peri_pd_raw` writer - Peripheral power domain go power-off interrupt status bit"]
482pub type PD_PERI_PD_RAW_W<'a> =
483    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_PERI_PD_RAW_A, 5>;
484impl<'a> PD_PERI_PD_RAW_W<'a> {
485    #[doc = "No interrupt happens"]
486    #[inline(always)]
487    pub fn no_interrupt(self) -> &'a mut W {
488        self.variant(PD_PERI_PD_RAW_A::NO_INTERRUPT)
489    }
490    #[doc = "PD_PERI enter Power-Off state"]
491    #[inline(always)]
492    pub fn pending(self) -> &'a mut W {
493        self.variant(PD_PERI_PD_RAW_A::PENDING)
494    }
495}
496#[doc = "Security power domain go power-off interrupt status bit\n\nValue on reset: 0"]
497#[derive(Clone, Copy, Debug, PartialEq)]
498pub enum PD_SEC_PD_RAW_A {
499    #[doc = "0: No interrupt happens"]
500    NO_INTERRUPT = 0,
501    #[doc = "1: PD_SEC enter Power-Off state"]
502    PENDING = 1,
503}
504impl From<PD_SEC_PD_RAW_A> for bool {
505    #[inline(always)]
506    fn from(variant: PD_SEC_PD_RAW_A) -> Self {
507        variant as u8 != 0
508    }
509}
510#[doc = "Field `pd_sec_pd_raw` reader - Security power domain go power-off interrupt status bit"]
511pub type PD_SEC_PD_RAW_R = crate::BitReader<PD_SEC_PD_RAW_A>;
512impl PD_SEC_PD_RAW_R {
513    #[doc = "Get enumerated values variant"]
514    #[inline(always)]
515    pub fn variant(&self) -> PD_SEC_PD_RAW_A {
516        match self.bits {
517            false => PD_SEC_PD_RAW_A::NO_INTERRUPT,
518            true => PD_SEC_PD_RAW_A::PENDING,
519        }
520    }
521    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
522    #[inline(always)]
523    pub fn is_no_interrupt(&self) -> bool {
524        *self == PD_SEC_PD_RAW_A::NO_INTERRUPT
525    }
526    #[doc = "Checks if the value of the field is `PENDING`"]
527    #[inline(always)]
528    pub fn is_pending(&self) -> bool {
529        *self == PD_SEC_PD_RAW_A::PENDING
530    }
531}
532#[doc = "Field `pd_sec_pd_raw` writer - Security power domain go power-off interrupt status bit"]
533pub type PD_SEC_PD_RAW_W<'a> =
534    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_SEC_PD_RAW_A, 4>;
535impl<'a> PD_SEC_PD_RAW_W<'a> {
536    #[doc = "No interrupt happens"]
537    #[inline(always)]
538    pub fn no_interrupt(self) -> &'a mut W {
539        self.variant(PD_SEC_PD_RAW_A::NO_INTERRUPT)
540    }
541    #[doc = "PD_SEC enter Power-Off state"]
542    #[inline(always)]
543    pub fn pending(self) -> &'a mut W {
544        self.variant(PD_SEC_PD_RAW_A::PENDING)
545    }
546}
547#[doc = "GNNE power domain go power-off interrupt status bit\n\nValue on reset: 0"]
548#[derive(Clone, Copy, Debug, PartialEq)]
549pub enum PD_GNNE_PD_RAW_A {
550    #[doc = "0: No interrupt happens"]
551    NO_INTERRUPT = 0,
552    #[doc = "1: PD_GNNE enter Power-Off state"]
553    PENDING = 1,
554}
555impl From<PD_GNNE_PD_RAW_A> for bool {
556    #[inline(always)]
557    fn from(variant: PD_GNNE_PD_RAW_A) -> Self {
558        variant as u8 != 0
559    }
560}
561#[doc = "Field `pd_gnne_pd_raw` reader - GNNE power domain go power-off interrupt status bit"]
562pub type PD_GNNE_PD_RAW_R = crate::BitReader<PD_GNNE_PD_RAW_A>;
563impl PD_GNNE_PD_RAW_R {
564    #[doc = "Get enumerated values variant"]
565    #[inline(always)]
566    pub fn variant(&self) -> PD_GNNE_PD_RAW_A {
567        match self.bits {
568            false => PD_GNNE_PD_RAW_A::NO_INTERRUPT,
569            true => PD_GNNE_PD_RAW_A::PENDING,
570        }
571    }
572    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
573    #[inline(always)]
574    pub fn is_no_interrupt(&self) -> bool {
575        *self == PD_GNNE_PD_RAW_A::NO_INTERRUPT
576    }
577    #[doc = "Checks if the value of the field is `PENDING`"]
578    #[inline(always)]
579    pub fn is_pending(&self) -> bool {
580        *self == PD_GNNE_PD_RAW_A::PENDING
581    }
582}
583#[doc = "Field `pd_gnne_pd_raw` writer - GNNE power domain go power-off interrupt status bit"]
584pub type PD_GNNE_PD_RAW_W<'a> =
585    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_GNNE_PD_RAW_A, 3>;
586impl<'a> PD_GNNE_PD_RAW_W<'a> {
587    #[doc = "No interrupt happens"]
588    #[inline(always)]
589    pub fn no_interrupt(self) -> &'a mut W {
590        self.variant(PD_GNNE_PD_RAW_A::NO_INTERRUPT)
591    }
592    #[doc = "PD_GNNE enter Power-Off state"]
593    #[inline(always)]
594    pub fn pending(self) -> &'a mut W {
595        self.variant(PD_GNNE_PD_RAW_A::PENDING)
596    }
597}
598#[doc = "CPUp (AX25P) power domain go power-off interrupt status bit\n\nValue on reset: 0"]
599#[derive(Clone, Copy, Debug, PartialEq)]
600pub enum PD_CPUP_PD_RAW_A {
601    #[doc = "0: No interrupt happens"]
602    NO_INTERRUPT = 0,
603    #[doc = "1: PD_CPUp enter Power-Off state"]
604    PENDING = 1,
605}
606impl From<PD_CPUP_PD_RAW_A> for bool {
607    #[inline(always)]
608    fn from(variant: PD_CPUP_PD_RAW_A) -> Self {
609        variant as u8 != 0
610    }
611}
612#[doc = "Field `pd_cpup_pd_raw` reader - CPUp (AX25P) power domain go power-off interrupt status bit"]
613pub type PD_CPUP_PD_RAW_R = crate::BitReader<PD_CPUP_PD_RAW_A>;
614impl PD_CPUP_PD_RAW_R {
615    #[doc = "Get enumerated values variant"]
616    #[inline(always)]
617    pub fn variant(&self) -> PD_CPUP_PD_RAW_A {
618        match self.bits {
619            false => PD_CPUP_PD_RAW_A::NO_INTERRUPT,
620            true => PD_CPUP_PD_RAW_A::PENDING,
621        }
622    }
623    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
624    #[inline(always)]
625    pub fn is_no_interrupt(&self) -> bool {
626        *self == PD_CPUP_PD_RAW_A::NO_INTERRUPT
627    }
628    #[doc = "Checks if the value of the field is `PENDING`"]
629    #[inline(always)]
630    pub fn is_pending(&self) -> bool {
631        *self == PD_CPUP_PD_RAW_A::PENDING
632    }
633}
634#[doc = "Field `pd_cpup_pd_raw` writer - CPUp (AX25P) power domain go power-off interrupt status bit"]
635pub type PD_CPUP_PD_RAW_W<'a> =
636    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_CPUP_PD_RAW_A, 1>;
637impl<'a> PD_CPUP_PD_RAW_W<'a> {
638    #[doc = "No interrupt happens"]
639    #[inline(always)]
640    pub fn no_interrupt(self) -> &'a mut W {
641        self.variant(PD_CPUP_PD_RAW_A::NO_INTERRUPT)
642    }
643    #[doc = "PD_CPUp enter Power-Off state"]
644    #[inline(always)]
645    pub fn pending(self) -> &'a mut W {
646        self.variant(PD_CPUP_PD_RAW_A::PENDING)
647    }
648}
649#[doc = "CPUM (AX25M) power domain go power-off interrupt status bit\n\nValue on reset: 0"]
650#[derive(Clone, Copy, Debug, PartialEq)]
651pub enum PD_CPUM_PD_RAW_A {
652    #[doc = "0: No interrupt happens"]
653    NO_INTERRUPT = 0,
654    #[doc = "1: PD_CPUM enter Power-Off state"]
655    PENDING = 1,
656}
657impl From<PD_CPUM_PD_RAW_A> for bool {
658    #[inline(always)]
659    fn from(variant: PD_CPUM_PD_RAW_A) -> Self {
660        variant as u8 != 0
661    }
662}
663#[doc = "Field `pd_cpum_pd_raw` reader - CPUM (AX25M) power domain go power-off interrupt status bit"]
664pub type PD_CPUM_PD_RAW_R = crate::BitReader<PD_CPUM_PD_RAW_A>;
665impl PD_CPUM_PD_RAW_R {
666    #[doc = "Get enumerated values variant"]
667    #[inline(always)]
668    pub fn variant(&self) -> PD_CPUM_PD_RAW_A {
669        match self.bits {
670            false => PD_CPUM_PD_RAW_A::NO_INTERRUPT,
671            true => PD_CPUM_PD_RAW_A::PENDING,
672        }
673    }
674    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
675    #[inline(always)]
676    pub fn is_no_interrupt(&self) -> bool {
677        *self == PD_CPUM_PD_RAW_A::NO_INTERRUPT
678    }
679    #[doc = "Checks if the value of the field is `PENDING`"]
680    #[inline(always)]
681    pub fn is_pending(&self) -> bool {
682        *self == PD_CPUM_PD_RAW_A::PENDING
683    }
684}
685#[doc = "Field `pd_cpum_pd_raw` writer - CPUM (AX25M) power domain go power-off interrupt status bit"]
686pub type PD_CPUM_PD_RAW_W<'a> =
687    crate::BitWriter1C<'a, u32, SYS_CTL_INT0_RAW_SPEC, PD_CPUM_PD_RAW_A, 0>;
688impl<'a> PD_CPUM_PD_RAW_W<'a> {
689    #[doc = "No interrupt happens"]
690    #[inline(always)]
691    pub fn no_interrupt(self) -> &'a mut W {
692        self.variant(PD_CPUM_PD_RAW_A::NO_INTERRUPT)
693    }
694    #[doc = "PD_CPUM enter Power-Off state"]
695    #[inline(always)]
696    pub fn pending(self) -> &'a mut W {
697        self.variant(PD_CPUM_PD_RAW_A::PENDING)
698    }
699}
700impl R {
701    #[doc = "Bit 17 - USB power domain go power-off interrupt status bit"]
702    #[inline(always)]
703    pub fn pd_usb_pd_raw(&self) -> PD_USB_PD_RAW_R {
704        PD_USB_PD_RAW_R::new(((self.bits >> 17) & 1) != 0)
705    }
706    #[doc = "Bit 16 - H264 power domain go power-off interrupt status bit"]
707    #[inline(always)]
708    pub fn pd_h264_pd_raw(&self) -> PD_H264_PD_RAW_R {
709        PD_H264_PD_RAW_R::new(((self.bits >> 16) & 1) != 0)
710    }
711    #[doc = "Bit 15 - DISP power domain go power-off interrupt status bit"]
712    #[inline(always)]
713    pub fn pd_disp_pd_raw(&self) -> PD_DISP_PD_RAW_R {
714        PD_DISP_PD_RAW_R::new(((self.bits >> 15) & 1) != 0)
715    }
716    #[doc = "Bit 10 - ISP power domain go power-off interrupt status bit"]
717    #[inline(always)]
718    pub fn pd_isp_pd_raw(&self) -> PD_ISP_PD_RAW_R {
719        PD_ISP_PD_RAW_R::new(((self.bits >> 10) & 1) != 0)
720    }
721    #[doc = "Bit 9 - Memory Controller power domain go power-off interrupt status bit"]
722    #[inline(always)]
723    pub fn pd_mctl_pd_raw(&self) -> PD_MCTL_PD_RAW_R {
724        PD_MCTL_PD_RAW_R::new(((self.bits >> 9) & 1) != 0)
725    }
726    #[doc = "Bit 8 - SRAM1 power domain go power-off interrupt status bit"]
727    #[inline(always)]
728    pub fn pd_ram1_pd_raw(&self) -> PD_RAM1_PD_RAW_R {
729        PD_RAM1_PD_RAW_R::new(((self.bits >> 8) & 1) != 0)
730    }
731    #[doc = "Bit 7 - SRAM0 power domain go power-off interrupt status bit"]
732    #[inline(always)]
733    pub fn pd_ram0_pd_raw(&self) -> PD_RAM0_PD_RAW_R {
734        PD_RAM0_PD_RAW_R::new(((self.bits >> 7) & 1) != 0)
735    }
736    #[doc = "Bit 6 - Storage power domain go power-off interrupt status bit"]
737    #[inline(always)]
738    pub fn pd_stor_pd_raw(&self) -> PD_STOR_PD_RAW_R {
739        PD_STOR_PD_RAW_R::new(((self.bits >> 6) & 1) != 0)
740    }
741    #[doc = "Bit 5 - Peripheral power domain go power-off interrupt status bit"]
742    #[inline(always)]
743    pub fn pd_peri_pd_raw(&self) -> PD_PERI_PD_RAW_R {
744        PD_PERI_PD_RAW_R::new(((self.bits >> 5) & 1) != 0)
745    }
746    #[doc = "Bit 4 - Security power domain go power-off interrupt status bit"]
747    #[inline(always)]
748    pub fn pd_sec_pd_raw(&self) -> PD_SEC_PD_RAW_R {
749        PD_SEC_PD_RAW_R::new(((self.bits >> 4) & 1) != 0)
750    }
751    #[doc = "Bit 3 - GNNE power domain go power-off interrupt status bit"]
752    #[inline(always)]
753    pub fn pd_gnne_pd_raw(&self) -> PD_GNNE_PD_RAW_R {
754        PD_GNNE_PD_RAW_R::new(((self.bits >> 3) & 1) != 0)
755    }
756    #[doc = "Bit 1 - CPUp (AX25P) power domain go power-off interrupt status bit"]
757    #[inline(always)]
758    pub fn pd_cpup_pd_raw(&self) -> PD_CPUP_PD_RAW_R {
759        PD_CPUP_PD_RAW_R::new(((self.bits >> 1) & 1) != 0)
760    }
761    #[doc = "Bit 0 - CPUM (AX25M) power domain go power-off interrupt status bit"]
762    #[inline(always)]
763    pub fn pd_cpum_pd_raw(&self) -> PD_CPUM_PD_RAW_R {
764        PD_CPUM_PD_RAW_R::new((self.bits & 1) != 0)
765    }
766}
767impl W {
768    #[doc = "Bit 17 - USB power domain go power-off interrupt status bit"]
769    #[inline(always)]
770    pub fn pd_usb_pd_raw(&mut self) -> PD_USB_PD_RAW_W {
771        PD_USB_PD_RAW_W::new(self)
772    }
773    #[doc = "Bit 16 - H264 power domain go power-off interrupt status bit"]
774    #[inline(always)]
775    pub fn pd_h264_pd_raw(&mut self) -> PD_H264_PD_RAW_W {
776        PD_H264_PD_RAW_W::new(self)
777    }
778    #[doc = "Bit 15 - DISP power domain go power-off interrupt status bit"]
779    #[inline(always)]
780    pub fn pd_disp_pd_raw(&mut self) -> PD_DISP_PD_RAW_W {
781        PD_DISP_PD_RAW_W::new(self)
782    }
783    #[doc = "Bit 10 - ISP power domain go power-off interrupt status bit"]
784    #[inline(always)]
785    pub fn pd_isp_pd_raw(&mut self) -> PD_ISP_PD_RAW_W {
786        PD_ISP_PD_RAW_W::new(self)
787    }
788    #[doc = "Bit 9 - Memory Controller power domain go power-off interrupt status bit"]
789    #[inline(always)]
790    pub fn pd_mctl_pd_raw(&mut self) -> PD_MCTL_PD_RAW_W {
791        PD_MCTL_PD_RAW_W::new(self)
792    }
793    #[doc = "Bit 8 - SRAM1 power domain go power-off interrupt status bit"]
794    #[inline(always)]
795    pub fn pd_ram1_pd_raw(&mut self) -> PD_RAM1_PD_RAW_W {
796        PD_RAM1_PD_RAW_W::new(self)
797    }
798    #[doc = "Bit 7 - SRAM0 power domain go power-off interrupt status bit"]
799    #[inline(always)]
800    pub fn pd_ram0_pd_raw(&mut self) -> PD_RAM0_PD_RAW_W {
801        PD_RAM0_PD_RAW_W::new(self)
802    }
803    #[doc = "Bit 6 - Storage power domain go power-off interrupt status bit"]
804    #[inline(always)]
805    pub fn pd_stor_pd_raw(&mut self) -> PD_STOR_PD_RAW_W {
806        PD_STOR_PD_RAW_W::new(self)
807    }
808    #[doc = "Bit 5 - Peripheral power domain go power-off interrupt status bit"]
809    #[inline(always)]
810    pub fn pd_peri_pd_raw(&mut self) -> PD_PERI_PD_RAW_W {
811        PD_PERI_PD_RAW_W::new(self)
812    }
813    #[doc = "Bit 4 - Security power domain go power-off interrupt status bit"]
814    #[inline(always)]
815    pub fn pd_sec_pd_raw(&mut self) -> PD_SEC_PD_RAW_W {
816        PD_SEC_PD_RAW_W::new(self)
817    }
818    #[doc = "Bit 3 - GNNE power domain go power-off interrupt status bit"]
819    #[inline(always)]
820    pub fn pd_gnne_pd_raw(&mut self) -> PD_GNNE_PD_RAW_W {
821        PD_GNNE_PD_RAW_W::new(self)
822    }
823    #[doc = "Bit 1 - CPUp (AX25P) power domain go power-off interrupt status bit"]
824    #[inline(always)]
825    pub fn pd_cpup_pd_raw(&mut self) -> PD_CPUP_PD_RAW_W {
826        PD_CPUP_PD_RAW_W::new(self)
827    }
828    #[doc = "Bit 0 - CPUM (AX25M) power domain go power-off interrupt status bit"]
829    #[inline(always)]
830    pub fn pd_cpum_pd_raw(&mut self) -> PD_CPUM_PD_RAW_W {
831        PD_CPUM_PD_RAW_W::new(self)
832    }
833    #[doc = "Writes raw bits to the register."]
834    #[inline(always)]
835    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
836        self.0.bits(bits);
837        self
838    }
839}
840#[doc = "Sysctl module interrupt 0 raw status register\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 [sys_ctl_int0_raw](index.html) module"]
841pub struct SYS_CTL_INT0_RAW_SPEC;
842impl crate::RegisterSpec for SYS_CTL_INT0_RAW_SPEC {
843    type Ux = u32;
844}
845#[doc = "`read()` method returns [sys_ctl_int0_raw::R](R) reader structure"]
846impl crate::Readable for SYS_CTL_INT0_RAW_SPEC {
847    type Reader = R;
848}
849#[doc = "`write(|w| ..)` method takes [sys_ctl_int0_raw::W](W) writer structure"]
850impl crate::Writable for SYS_CTL_INT0_RAW_SPEC {
851    type Writer = W;
852}
853#[doc = "`reset()` method sets SYS_CTL_INT0_RAW to value 0"]
854impl crate::Resettable for SYS_CTL_INT0_RAW_SPEC {
855    #[inline(always)]
856    fn reset_value() -> Self::Ux {
857        0
858    }
859}
k510_pac/sysctl/sys_ctl_int0_raw.rs

k510_pac/sysctl/
sys_ctl_int0_raw.rs
