mimxrt595s/sysctl0/
pdsleepcfg1.rs

1#[doc = "Register `PDSLEEPCFG1` reader"]
2pub struct R(crate::R<PDSLEEPCFG1_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<PDSLEEPCFG1_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<PDSLEEPCFG1_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<PDSLEEPCFG1_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `PDSLEEPCFG1` writer"]
17pub struct W(crate::W<PDSLEEPCFG1_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<PDSLEEPCFG1_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<PDSLEEPCFG1_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<PDSLEEPCFG1_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `PQ_SRAM_PPD` reader - Periphery power for PowerQuad RAM"]
38pub type PQ_SRAM_PPD_R = crate::BitReader<PQ_SRAM_PPD_A>;
39#[doc = "Periphery power for PowerQuad RAM\n\nValue on reset: 1"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum PQ_SRAM_PPD_A {
42    #[doc = "0: Power down disabled or Powered ON"]
43    PQ_SRAM_PPD_0 = 0,
44    #[doc = "1: Power down enabled or Powered OFF"]
45    PQ_SRAM_PPD_1 = 1,
46}
47impl From<PQ_SRAM_PPD_A> for bool {
48    #[inline(always)]
49    fn from(variant: PQ_SRAM_PPD_A) -> Self {
50        variant as u8 != 0
51    }
52}
53impl PQ_SRAM_PPD_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> PQ_SRAM_PPD_A {
57        match self.bits {
58            false => PQ_SRAM_PPD_A::PQ_SRAM_PPD_0,
59            true => PQ_SRAM_PPD_A::PQ_SRAM_PPD_1,
60        }
61    }
62    #[doc = "Checks if the value of the field is `PQ_SRAM_PPD_0`"]
63    #[inline(always)]
64    pub fn is_pq_sram_ppd_0(&self) -> bool {
65        *self == PQ_SRAM_PPD_A::PQ_SRAM_PPD_0
66    }
67    #[doc = "Checks if the value of the field is `PQ_SRAM_PPD_1`"]
68    #[inline(always)]
69    pub fn is_pq_sram_ppd_1(&self) -> bool {
70        *self == PQ_SRAM_PPD_A::PQ_SRAM_PPD_1
71    }
72}
73#[doc = "Field `PQ_SRAM_PPD` writer - Periphery power for PowerQuad RAM"]
74pub type PQ_SRAM_PPD_W<'a, const O: u8> =
75    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, PQ_SRAM_PPD_A, O>;
76impl<'a, const O: u8> PQ_SRAM_PPD_W<'a, O> {
77    #[doc = "Power down disabled or Powered ON"]
78    #[inline(always)]
79    pub fn pq_sram_ppd_0(self) -> &'a mut W {
80        self.variant(PQ_SRAM_PPD_A::PQ_SRAM_PPD_0)
81    }
82    #[doc = "Power down enabled or Powered OFF"]
83    #[inline(always)]
84    pub fn pq_sram_ppd_1(self) -> &'a mut W {
85        self.variant(PQ_SRAM_PPD_A::PQ_SRAM_PPD_1)
86    }
87}
88#[doc = "Field `FLEXSPI0_SRAM_APD` reader - Array power for FLEXSPI0 RAM"]
89pub type FLEXSPI0_SRAM_APD_R = crate::BitReader<FLEXSPI0_SRAM_APD_A>;
90#[doc = "Array power for FLEXSPI0 RAM\n\nValue on reset: 1"]
91#[derive(Clone, Copy, Debug, PartialEq, Eq)]
92pub enum FLEXSPI0_SRAM_APD_A {
93    #[doc = "0: Power down disabled or Powered ON"]
94    FLEXSPI0_SRAM_APD_0 = 0,
95    #[doc = "1: Power down enabled or Powered OFF"]
96    FLEXSPI0_SRAM_APD_1 = 1,
97}
98impl From<FLEXSPI0_SRAM_APD_A> for bool {
99    #[inline(always)]
100    fn from(variant: FLEXSPI0_SRAM_APD_A) -> Self {
101        variant as u8 != 0
102    }
103}
104impl FLEXSPI0_SRAM_APD_R {
105    #[doc = "Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> FLEXSPI0_SRAM_APD_A {
108        match self.bits {
109            false => FLEXSPI0_SRAM_APD_A::FLEXSPI0_SRAM_APD_0,
110            true => FLEXSPI0_SRAM_APD_A::FLEXSPI0_SRAM_APD_1,
111        }
112    }
113    #[doc = "Checks if the value of the field is `FLEXSPI0_SRAM_APD_0`"]
114    #[inline(always)]
115    pub fn is_flexspi0_sram_apd_0(&self) -> bool {
116        *self == FLEXSPI0_SRAM_APD_A::FLEXSPI0_SRAM_APD_0
117    }
118    #[doc = "Checks if the value of the field is `FLEXSPI0_SRAM_APD_1`"]
119    #[inline(always)]
120    pub fn is_flexspi0_sram_apd_1(&self) -> bool {
121        *self == FLEXSPI0_SRAM_APD_A::FLEXSPI0_SRAM_APD_1
122    }
123}
124#[doc = "Field `FLEXSPI0_SRAM_APD` writer - Array power for FLEXSPI0 RAM"]
125pub type FLEXSPI0_SRAM_APD_W<'a, const O: u8> =
126    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, FLEXSPI0_SRAM_APD_A, O>;
127impl<'a, const O: u8> FLEXSPI0_SRAM_APD_W<'a, O> {
128    #[doc = "Power down disabled or Powered ON"]
129    #[inline(always)]
130    pub fn flexspi0_sram_apd_0(self) -> &'a mut W {
131        self.variant(FLEXSPI0_SRAM_APD_A::FLEXSPI0_SRAM_APD_0)
132    }
133    #[doc = "Power down enabled or Powered OFF"]
134    #[inline(always)]
135    pub fn flexspi0_sram_apd_1(self) -> &'a mut W {
136        self.variant(FLEXSPI0_SRAM_APD_A::FLEXSPI0_SRAM_APD_1)
137    }
138}
139#[doc = "Field `FLEXSPI0_SRAM_PPD` reader - Periphery power for FLEXSPI0 RAM"]
140pub type FLEXSPI0_SRAM_PPD_R = crate::BitReader<FLEXSPI0_SRAM_PPD_A>;
141#[doc = "Periphery power for FLEXSPI0 RAM\n\nValue on reset: 1"]
142#[derive(Clone, Copy, Debug, PartialEq, Eq)]
143pub enum FLEXSPI0_SRAM_PPD_A {
144    #[doc = "0: Power down disabled or Powered ON"]
145    FLEXSPI0_SRAM_PPD_0 = 0,
146    #[doc = "1: Power down enabled or Powered OFF"]
147    FLEXSPI0_SRAM_PPD_1 = 1,
148}
149impl From<FLEXSPI0_SRAM_PPD_A> for bool {
150    #[inline(always)]
151    fn from(variant: FLEXSPI0_SRAM_PPD_A) -> Self {
152        variant as u8 != 0
153    }
154}
155impl FLEXSPI0_SRAM_PPD_R {
156    #[doc = "Get enumerated values variant"]
157    #[inline(always)]
158    pub fn variant(&self) -> FLEXSPI0_SRAM_PPD_A {
159        match self.bits {
160            false => FLEXSPI0_SRAM_PPD_A::FLEXSPI0_SRAM_PPD_0,
161            true => FLEXSPI0_SRAM_PPD_A::FLEXSPI0_SRAM_PPD_1,
162        }
163    }
164    #[doc = "Checks if the value of the field is `FLEXSPI0_SRAM_PPD_0`"]
165    #[inline(always)]
166    pub fn is_flexspi0_sram_ppd_0(&self) -> bool {
167        *self == FLEXSPI0_SRAM_PPD_A::FLEXSPI0_SRAM_PPD_0
168    }
169    #[doc = "Checks if the value of the field is `FLEXSPI0_SRAM_PPD_1`"]
170    #[inline(always)]
171    pub fn is_flexspi0_sram_ppd_1(&self) -> bool {
172        *self == FLEXSPI0_SRAM_PPD_A::FLEXSPI0_SRAM_PPD_1
173    }
174}
175#[doc = "Field `FLEXSPI0_SRAM_PPD` writer - Periphery power for FLEXSPI0 RAM"]
176pub type FLEXSPI0_SRAM_PPD_W<'a, const O: u8> =
177    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, FLEXSPI0_SRAM_PPD_A, O>;
178impl<'a, const O: u8> FLEXSPI0_SRAM_PPD_W<'a, O> {
179    #[doc = "Power down disabled or Powered ON"]
180    #[inline(always)]
181    pub fn flexspi0_sram_ppd_0(self) -> &'a mut W {
182        self.variant(FLEXSPI0_SRAM_PPD_A::FLEXSPI0_SRAM_PPD_0)
183    }
184    #[doc = "Power down enabled or Powered OFF"]
185    #[inline(always)]
186    pub fn flexspi0_sram_ppd_1(self) -> &'a mut W {
187        self.variant(FLEXSPI0_SRAM_PPD_A::FLEXSPI0_SRAM_PPD_1)
188    }
189}
190#[doc = "Field `FLEXSPI1_SRAM_APD` reader - Array power for FLEXSPI1 RAM"]
191pub type FLEXSPI1_SRAM_APD_R = crate::BitReader<FLEXSPI1_SRAM_APD_A>;
192#[doc = "Array power for FLEXSPI1 RAM\n\nValue on reset: 1"]
193#[derive(Clone, Copy, Debug, PartialEq, Eq)]
194pub enum FLEXSPI1_SRAM_APD_A {
195    #[doc = "0: Power down disabled or Powered ON"]
196    FLEXSPI1_SRAM_APD_0 = 0,
197    #[doc = "1: Power down enabled or Powered OFF"]
198    FLEXSPI1_SRAM_APD_1 = 1,
199}
200impl From<FLEXSPI1_SRAM_APD_A> for bool {
201    #[inline(always)]
202    fn from(variant: FLEXSPI1_SRAM_APD_A) -> Self {
203        variant as u8 != 0
204    }
205}
206impl FLEXSPI1_SRAM_APD_R {
207    #[doc = "Get enumerated values variant"]
208    #[inline(always)]
209    pub fn variant(&self) -> FLEXSPI1_SRAM_APD_A {
210        match self.bits {
211            false => FLEXSPI1_SRAM_APD_A::FLEXSPI1_SRAM_APD_0,
212            true => FLEXSPI1_SRAM_APD_A::FLEXSPI1_SRAM_APD_1,
213        }
214    }
215    #[doc = "Checks if the value of the field is `FLEXSPI1_SRAM_APD_0`"]
216    #[inline(always)]
217    pub fn is_flexspi1_sram_apd_0(&self) -> bool {
218        *self == FLEXSPI1_SRAM_APD_A::FLEXSPI1_SRAM_APD_0
219    }
220    #[doc = "Checks if the value of the field is `FLEXSPI1_SRAM_APD_1`"]
221    #[inline(always)]
222    pub fn is_flexspi1_sram_apd_1(&self) -> bool {
223        *self == FLEXSPI1_SRAM_APD_A::FLEXSPI1_SRAM_APD_1
224    }
225}
226#[doc = "Field `FLEXSPI1_SRAM_APD` writer - Array power for FLEXSPI1 RAM"]
227pub type FLEXSPI1_SRAM_APD_W<'a, const O: u8> =
228    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, FLEXSPI1_SRAM_APD_A, O>;
229impl<'a, const O: u8> FLEXSPI1_SRAM_APD_W<'a, O> {
230    #[doc = "Power down disabled or Powered ON"]
231    #[inline(always)]
232    pub fn flexspi1_sram_apd_0(self) -> &'a mut W {
233        self.variant(FLEXSPI1_SRAM_APD_A::FLEXSPI1_SRAM_APD_0)
234    }
235    #[doc = "Power down enabled or Powered OFF"]
236    #[inline(always)]
237    pub fn flexspi1_sram_apd_1(self) -> &'a mut W {
238        self.variant(FLEXSPI1_SRAM_APD_A::FLEXSPI1_SRAM_APD_1)
239    }
240}
241#[doc = "Field `FLEXSPI1_SRAM_PPD` reader - Periphery power for FLEXSPI1 RAM"]
242pub type FLEXSPI1_SRAM_PPD_R = crate::BitReader<FLEXSPI1_SRAM_PPD_A>;
243#[doc = "Periphery power for FLEXSPI1 RAM\n\nValue on reset: 1"]
244#[derive(Clone, Copy, Debug, PartialEq, Eq)]
245pub enum FLEXSPI1_SRAM_PPD_A {
246    #[doc = "0: Power down disabled or Powered ON"]
247    FLEXSPI1_SRAM_PPD_0 = 0,
248    #[doc = "1: Power down enabled or Powered OFF"]
249    FLEXSPI1_SRAM_PPD_1 = 1,
250}
251impl From<FLEXSPI1_SRAM_PPD_A> for bool {
252    #[inline(always)]
253    fn from(variant: FLEXSPI1_SRAM_PPD_A) -> Self {
254        variant as u8 != 0
255    }
256}
257impl FLEXSPI1_SRAM_PPD_R {
258    #[doc = "Get enumerated values variant"]
259    #[inline(always)]
260    pub fn variant(&self) -> FLEXSPI1_SRAM_PPD_A {
261        match self.bits {
262            false => FLEXSPI1_SRAM_PPD_A::FLEXSPI1_SRAM_PPD_0,
263            true => FLEXSPI1_SRAM_PPD_A::FLEXSPI1_SRAM_PPD_1,
264        }
265    }
266    #[doc = "Checks if the value of the field is `FLEXSPI1_SRAM_PPD_0`"]
267    #[inline(always)]
268    pub fn is_flexspi1_sram_ppd_0(&self) -> bool {
269        *self == FLEXSPI1_SRAM_PPD_A::FLEXSPI1_SRAM_PPD_0
270    }
271    #[doc = "Checks if the value of the field is `FLEXSPI1_SRAM_PPD_1`"]
272    #[inline(always)]
273    pub fn is_flexspi1_sram_ppd_1(&self) -> bool {
274        *self == FLEXSPI1_SRAM_PPD_A::FLEXSPI1_SRAM_PPD_1
275    }
276}
277#[doc = "Field `FLEXSPI1_SRAM_PPD` writer - Periphery power for FLEXSPI1 RAM"]
278pub type FLEXSPI1_SRAM_PPD_W<'a, const O: u8> =
279    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, FLEXSPI1_SRAM_PPD_A, O>;
280impl<'a, const O: u8> FLEXSPI1_SRAM_PPD_W<'a, O> {
281    #[doc = "Power down disabled or Powered ON"]
282    #[inline(always)]
283    pub fn flexspi1_sram_ppd_0(self) -> &'a mut W {
284        self.variant(FLEXSPI1_SRAM_PPD_A::FLEXSPI1_SRAM_PPD_0)
285    }
286    #[doc = "Power down enabled or Powered OFF"]
287    #[inline(always)]
288    pub fn flexspi1_sram_ppd_1(self) -> &'a mut W {
289        self.variant(FLEXSPI1_SRAM_PPD_A::FLEXSPI1_SRAM_PPD_1)
290    }
291}
292#[doc = "Field `USBHS_SRAM_APD` reader - Array power for USB RAM"]
293pub type USBHS_SRAM_APD_R = crate::BitReader<USBHS_SRAM_APD_A>;
294#[doc = "Array power for USB RAM\n\nValue on reset: 1"]
295#[derive(Clone, Copy, Debug, PartialEq, Eq)]
296pub enum USBHS_SRAM_APD_A {
297    #[doc = "0: Power down disabled or Powered ON"]
298    USBHS_SRAM_APD_0 = 0,
299    #[doc = "1: Power down enabled or Powered OFF"]
300    USBHS_SRAM_APD_1 = 1,
301}
302impl From<USBHS_SRAM_APD_A> for bool {
303    #[inline(always)]
304    fn from(variant: USBHS_SRAM_APD_A) -> Self {
305        variant as u8 != 0
306    }
307}
308impl USBHS_SRAM_APD_R {
309    #[doc = "Get enumerated values variant"]
310    #[inline(always)]
311    pub fn variant(&self) -> USBHS_SRAM_APD_A {
312        match self.bits {
313            false => USBHS_SRAM_APD_A::USBHS_SRAM_APD_0,
314            true => USBHS_SRAM_APD_A::USBHS_SRAM_APD_1,
315        }
316    }
317    #[doc = "Checks if the value of the field is `USBHS_SRAM_APD_0`"]
318    #[inline(always)]
319    pub fn is_usbhs_sram_apd_0(&self) -> bool {
320        *self == USBHS_SRAM_APD_A::USBHS_SRAM_APD_0
321    }
322    #[doc = "Checks if the value of the field is `USBHS_SRAM_APD_1`"]
323    #[inline(always)]
324    pub fn is_usbhs_sram_apd_1(&self) -> bool {
325        *self == USBHS_SRAM_APD_A::USBHS_SRAM_APD_1
326    }
327}
328#[doc = "Field `USBHS_SRAM_APD` writer - Array power for USB RAM"]
329pub type USBHS_SRAM_APD_W<'a, const O: u8> =
330    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, USBHS_SRAM_APD_A, O>;
331impl<'a, const O: u8> USBHS_SRAM_APD_W<'a, O> {
332    #[doc = "Power down disabled or Powered ON"]
333    #[inline(always)]
334    pub fn usbhs_sram_apd_0(self) -> &'a mut W {
335        self.variant(USBHS_SRAM_APD_A::USBHS_SRAM_APD_0)
336    }
337    #[doc = "Power down enabled or Powered OFF"]
338    #[inline(always)]
339    pub fn usbhs_sram_apd_1(self) -> &'a mut W {
340        self.variant(USBHS_SRAM_APD_A::USBHS_SRAM_APD_1)
341    }
342}
343#[doc = "Field `USBHS_SRAM_PPD` reader - Periphery power for USB RAM"]
344pub type USBHS_SRAM_PPD_R = crate::BitReader<USBHS_SRAM_PPD_A>;
345#[doc = "Periphery power for USB RAM\n\nValue on reset: 1"]
346#[derive(Clone, Copy, Debug, PartialEq, Eq)]
347pub enum USBHS_SRAM_PPD_A {
348    #[doc = "0: Power down disabled or Powered ON"]
349    USBHS_SRAM_PPD_0 = 0,
350    #[doc = "1: Power down enabled or Powered OFF"]
351    USBHS_SRAM_PPD_1 = 1,
352}
353impl From<USBHS_SRAM_PPD_A> for bool {
354    #[inline(always)]
355    fn from(variant: USBHS_SRAM_PPD_A) -> Self {
356        variant as u8 != 0
357    }
358}
359impl USBHS_SRAM_PPD_R {
360    #[doc = "Get enumerated values variant"]
361    #[inline(always)]
362    pub fn variant(&self) -> USBHS_SRAM_PPD_A {
363        match self.bits {
364            false => USBHS_SRAM_PPD_A::USBHS_SRAM_PPD_0,
365            true => USBHS_SRAM_PPD_A::USBHS_SRAM_PPD_1,
366        }
367    }
368    #[doc = "Checks if the value of the field is `USBHS_SRAM_PPD_0`"]
369    #[inline(always)]
370    pub fn is_usbhs_sram_ppd_0(&self) -> bool {
371        *self == USBHS_SRAM_PPD_A::USBHS_SRAM_PPD_0
372    }
373    #[doc = "Checks if the value of the field is `USBHS_SRAM_PPD_1`"]
374    #[inline(always)]
375    pub fn is_usbhs_sram_ppd_1(&self) -> bool {
376        *self == USBHS_SRAM_PPD_A::USBHS_SRAM_PPD_1
377    }
378}
379#[doc = "Field `USBHS_SRAM_PPD` writer - Periphery power for USB RAM"]
380pub type USBHS_SRAM_PPD_W<'a, const O: u8> =
381    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, USBHS_SRAM_PPD_A, O>;
382impl<'a, const O: u8> USBHS_SRAM_PPD_W<'a, O> {
383    #[doc = "Power down disabled or Powered ON"]
384    #[inline(always)]
385    pub fn usbhs_sram_ppd_0(self) -> &'a mut W {
386        self.variant(USBHS_SRAM_PPD_A::USBHS_SRAM_PPD_0)
387    }
388    #[doc = "Power down enabled or Powered OFF"]
389    #[inline(always)]
390    pub fn usbhs_sram_ppd_1(self) -> &'a mut W {
391        self.variant(USBHS_SRAM_PPD_A::USBHS_SRAM_PPD_1)
392    }
393}
394#[doc = "Field `USDHC0_SRAM_APD` reader - Array power for uSDHC0 (SD/MMC/SDIO interface) RAM"]
395pub type USDHC0_SRAM_APD_R = crate::BitReader<USDHC0_SRAM_APD_A>;
396#[doc = "Array power for uSDHC0 (SD/MMC/SDIO interface) RAM\n\nValue on reset: 1"]
397#[derive(Clone, Copy, Debug, PartialEq, Eq)]
398pub enum USDHC0_SRAM_APD_A {
399    #[doc = "0: Power down disabled or Powered ON"]
400    USDHC0_SRAM_APD_0 = 0,
401    #[doc = "1: Power down enabled or Powered OFF"]
402    USDHC0_SRAM_APD_1 = 1,
403}
404impl From<USDHC0_SRAM_APD_A> for bool {
405    #[inline(always)]
406    fn from(variant: USDHC0_SRAM_APD_A) -> Self {
407        variant as u8 != 0
408    }
409}
410impl USDHC0_SRAM_APD_R {
411    #[doc = "Get enumerated values variant"]
412    #[inline(always)]
413    pub fn variant(&self) -> USDHC0_SRAM_APD_A {
414        match self.bits {
415            false => USDHC0_SRAM_APD_A::USDHC0_SRAM_APD_0,
416            true => USDHC0_SRAM_APD_A::USDHC0_SRAM_APD_1,
417        }
418    }
419    #[doc = "Checks if the value of the field is `USDHC0_SRAM_APD_0`"]
420    #[inline(always)]
421    pub fn is_usdhc0_sram_apd_0(&self) -> bool {
422        *self == USDHC0_SRAM_APD_A::USDHC0_SRAM_APD_0
423    }
424    #[doc = "Checks if the value of the field is `USDHC0_SRAM_APD_1`"]
425    #[inline(always)]
426    pub fn is_usdhc0_sram_apd_1(&self) -> bool {
427        *self == USDHC0_SRAM_APD_A::USDHC0_SRAM_APD_1
428    }
429}
430#[doc = "Field `USDHC0_SRAM_APD` writer - Array power for uSDHC0 (SD/MMC/SDIO interface) RAM"]
431pub type USDHC0_SRAM_APD_W<'a, const O: u8> =
432    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, USDHC0_SRAM_APD_A, O>;
433impl<'a, const O: u8> USDHC0_SRAM_APD_W<'a, O> {
434    #[doc = "Power down disabled or Powered ON"]
435    #[inline(always)]
436    pub fn usdhc0_sram_apd_0(self) -> &'a mut W {
437        self.variant(USDHC0_SRAM_APD_A::USDHC0_SRAM_APD_0)
438    }
439    #[doc = "Power down enabled or Powered OFF"]
440    #[inline(always)]
441    pub fn usdhc0_sram_apd_1(self) -> &'a mut W {
442        self.variant(USDHC0_SRAM_APD_A::USDHC0_SRAM_APD_1)
443    }
444}
445#[doc = "Field `USDHC0_SRAM_PPD` reader - Periphery power for uSDHC0 (SD/MMC/SDIO interface) RAM"]
446pub type USDHC0_SRAM_PPD_R = crate::BitReader<USDHC0_SRAM_PPD_A>;
447#[doc = "Periphery power for uSDHC0 (SD/MMC/SDIO interface) RAM\n\nValue on reset: 1"]
448#[derive(Clone, Copy, Debug, PartialEq, Eq)]
449pub enum USDHC0_SRAM_PPD_A {
450    #[doc = "0: Power down disabled or Powered ON"]
451    USDHC0_SRAM_PPD_0 = 0,
452    #[doc = "1: Power down enabled or Powered OFF"]
453    USDHC0_SRAM_PPD_1 = 1,
454}
455impl From<USDHC0_SRAM_PPD_A> for bool {
456    #[inline(always)]
457    fn from(variant: USDHC0_SRAM_PPD_A) -> Self {
458        variant as u8 != 0
459    }
460}
461impl USDHC0_SRAM_PPD_R {
462    #[doc = "Get enumerated values variant"]
463    #[inline(always)]
464    pub fn variant(&self) -> USDHC0_SRAM_PPD_A {
465        match self.bits {
466            false => USDHC0_SRAM_PPD_A::USDHC0_SRAM_PPD_0,
467            true => USDHC0_SRAM_PPD_A::USDHC0_SRAM_PPD_1,
468        }
469    }
470    #[doc = "Checks if the value of the field is `USDHC0_SRAM_PPD_0`"]
471    #[inline(always)]
472    pub fn is_usdhc0_sram_ppd_0(&self) -> bool {
473        *self == USDHC0_SRAM_PPD_A::USDHC0_SRAM_PPD_0
474    }
475    #[doc = "Checks if the value of the field is `USDHC0_SRAM_PPD_1`"]
476    #[inline(always)]
477    pub fn is_usdhc0_sram_ppd_1(&self) -> bool {
478        *self == USDHC0_SRAM_PPD_A::USDHC0_SRAM_PPD_1
479    }
480}
481#[doc = "Field `USDHC0_SRAM_PPD` writer - Periphery power for uSDHC0 (SD/MMC/SDIO interface) RAM"]
482pub type USDHC0_SRAM_PPD_W<'a, const O: u8> =
483    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, USDHC0_SRAM_PPD_A, O>;
484impl<'a, const O: u8> USDHC0_SRAM_PPD_W<'a, O> {
485    #[doc = "Power down disabled or Powered ON"]
486    #[inline(always)]
487    pub fn usdhc0_sram_ppd_0(self) -> &'a mut W {
488        self.variant(USDHC0_SRAM_PPD_A::USDHC0_SRAM_PPD_0)
489    }
490    #[doc = "Power down enabled or Powered OFF"]
491    #[inline(always)]
492    pub fn usdhc0_sram_ppd_1(self) -> &'a mut W {
493        self.variant(USDHC0_SRAM_PPD_A::USDHC0_SRAM_PPD_1)
494    }
495}
496#[doc = "Field `USDHC1_SRAM_APD` reader - Array power for Casper RAM"]
497pub type USDHC1_SRAM_APD_R = crate::BitReader<USDHC1_SRAM_APD_A>;
498#[doc = "Array power for Casper RAM\n\nValue on reset: 1"]
499#[derive(Clone, Copy, Debug, PartialEq, Eq)]
500pub enum USDHC1_SRAM_APD_A {
501    #[doc = "0: Power down disabled or Powered ON"]
502    USDHC1_SRAM_APD_0 = 0,
503    #[doc = "1: Power down enabled or Powered OFF"]
504    USDHC1_SRAM_APD_1 = 1,
505}
506impl From<USDHC1_SRAM_APD_A> for bool {
507    #[inline(always)]
508    fn from(variant: USDHC1_SRAM_APD_A) -> Self {
509        variant as u8 != 0
510    }
511}
512impl USDHC1_SRAM_APD_R {
513    #[doc = "Get enumerated values variant"]
514    #[inline(always)]
515    pub fn variant(&self) -> USDHC1_SRAM_APD_A {
516        match self.bits {
517            false => USDHC1_SRAM_APD_A::USDHC1_SRAM_APD_0,
518            true => USDHC1_SRAM_APD_A::USDHC1_SRAM_APD_1,
519        }
520    }
521    #[doc = "Checks if the value of the field is `USDHC1_SRAM_APD_0`"]
522    #[inline(always)]
523    pub fn is_usdhc1_sram_apd_0(&self) -> bool {
524        *self == USDHC1_SRAM_APD_A::USDHC1_SRAM_APD_0
525    }
526    #[doc = "Checks if the value of the field is `USDHC1_SRAM_APD_1`"]
527    #[inline(always)]
528    pub fn is_usdhc1_sram_apd_1(&self) -> bool {
529        *self == USDHC1_SRAM_APD_A::USDHC1_SRAM_APD_1
530    }
531}
532#[doc = "Field `USDHC1_SRAM_APD` writer - Array power for Casper RAM"]
533pub type USDHC1_SRAM_APD_W<'a, const O: u8> =
534    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, USDHC1_SRAM_APD_A, O>;
535impl<'a, const O: u8> USDHC1_SRAM_APD_W<'a, O> {
536    #[doc = "Power down disabled or Powered ON"]
537    #[inline(always)]
538    pub fn usdhc1_sram_apd_0(self) -> &'a mut W {
539        self.variant(USDHC1_SRAM_APD_A::USDHC1_SRAM_APD_0)
540    }
541    #[doc = "Power down enabled or Powered OFF"]
542    #[inline(always)]
543    pub fn usdhc1_sram_apd_1(self) -> &'a mut W {
544        self.variant(USDHC1_SRAM_APD_A::USDHC1_SRAM_APD_1)
545    }
546}
547#[doc = "Field `USDHC1_SRAM_PPD` reader - Periphery power for uSDHC1 (SD/MMC/SDIO interface) RAM"]
548pub type USDHC1_SRAM_PPD_R = crate::BitReader<USDHC1_SRAM_PPD_A>;
549#[doc = "Periphery power for uSDHC1 (SD/MMC/SDIO interface) RAM\n\nValue on reset: 1"]
550#[derive(Clone, Copy, Debug, PartialEq, Eq)]
551pub enum USDHC1_SRAM_PPD_A {
552    #[doc = "0: Power down disabled or Powered ON"]
553    USDHC1_SRAM_PPD_0 = 0,
554    #[doc = "1: Power down enabled or Powered OFF"]
555    USDHC1_SRAM_PPD_1 = 1,
556}
557impl From<USDHC1_SRAM_PPD_A> for bool {
558    #[inline(always)]
559    fn from(variant: USDHC1_SRAM_PPD_A) -> Self {
560        variant as u8 != 0
561    }
562}
563impl USDHC1_SRAM_PPD_R {
564    #[doc = "Get enumerated values variant"]
565    #[inline(always)]
566    pub fn variant(&self) -> USDHC1_SRAM_PPD_A {
567        match self.bits {
568            false => USDHC1_SRAM_PPD_A::USDHC1_SRAM_PPD_0,
569            true => USDHC1_SRAM_PPD_A::USDHC1_SRAM_PPD_1,
570        }
571    }
572    #[doc = "Checks if the value of the field is `USDHC1_SRAM_PPD_0`"]
573    #[inline(always)]
574    pub fn is_usdhc1_sram_ppd_0(&self) -> bool {
575        *self == USDHC1_SRAM_PPD_A::USDHC1_SRAM_PPD_0
576    }
577    #[doc = "Checks if the value of the field is `USDHC1_SRAM_PPD_1`"]
578    #[inline(always)]
579    pub fn is_usdhc1_sram_ppd_1(&self) -> bool {
580        *self == USDHC1_SRAM_PPD_A::USDHC1_SRAM_PPD_1
581    }
582}
583#[doc = "Field `USDHC1_SRAM_PPD` writer - Periphery power for uSDHC1 (SD/MMC/SDIO interface) RAM"]
584pub type USDHC1_SRAM_PPD_W<'a, const O: u8> =
585    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, USDHC1_SRAM_PPD_A, O>;
586impl<'a, const O: u8> USDHC1_SRAM_PPD_W<'a, O> {
587    #[doc = "Power down disabled or Powered ON"]
588    #[inline(always)]
589    pub fn usdhc1_sram_ppd_0(self) -> &'a mut W {
590        self.variant(USDHC1_SRAM_PPD_A::USDHC1_SRAM_PPD_0)
591    }
592    #[doc = "Power down enabled or Powered OFF"]
593    #[inline(always)]
594    pub fn usdhc1_sram_ppd_1(self) -> &'a mut W {
595        self.variant(USDHC1_SRAM_PPD_A::USDHC1_SRAM_PPD_1)
596    }
597}
598#[doc = "Field `CASPER_SRAM_PPD` reader - Periphery power for Casper RAM"]
599pub type CASPER_SRAM_PPD_R = crate::BitReader<CASPER_SRAM_PPD_A>;
600#[doc = "Periphery power for Casper RAM\n\nValue on reset: 1"]
601#[derive(Clone, Copy, Debug, PartialEq, Eq)]
602pub enum CASPER_SRAM_PPD_A {
603    #[doc = "0: Power down disabled or Powered ON"]
604    CASPER_SRAM_PPD_0 = 0,
605    #[doc = "1: Power down enabled or Powered OFF"]
606    CASPER_SRAM_PPD_1 = 1,
607}
608impl From<CASPER_SRAM_PPD_A> for bool {
609    #[inline(always)]
610    fn from(variant: CASPER_SRAM_PPD_A) -> Self {
611        variant as u8 != 0
612    }
613}
614impl CASPER_SRAM_PPD_R {
615    #[doc = "Get enumerated values variant"]
616    #[inline(always)]
617    pub fn variant(&self) -> CASPER_SRAM_PPD_A {
618        match self.bits {
619            false => CASPER_SRAM_PPD_A::CASPER_SRAM_PPD_0,
620            true => CASPER_SRAM_PPD_A::CASPER_SRAM_PPD_1,
621        }
622    }
623    #[doc = "Checks if the value of the field is `CASPER_SRAM_PPD_0`"]
624    #[inline(always)]
625    pub fn is_casper_sram_ppd_0(&self) -> bool {
626        *self == CASPER_SRAM_PPD_A::CASPER_SRAM_PPD_0
627    }
628    #[doc = "Checks if the value of the field is `CASPER_SRAM_PPD_1`"]
629    #[inline(always)]
630    pub fn is_casper_sram_ppd_1(&self) -> bool {
631        *self == CASPER_SRAM_PPD_A::CASPER_SRAM_PPD_1
632    }
633}
634#[doc = "Field `CASPER_SRAM_PPD` writer - Periphery power for Casper RAM"]
635pub type CASPER_SRAM_PPD_W<'a, const O: u8> =
636    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, CASPER_SRAM_PPD_A, O>;
637impl<'a, const O: u8> CASPER_SRAM_PPD_W<'a, O> {
638    #[doc = "Power down disabled or Powered ON"]
639    #[inline(always)]
640    pub fn casper_sram_ppd_0(self) -> &'a mut W {
641        self.variant(CASPER_SRAM_PPD_A::CASPER_SRAM_PPD_0)
642    }
643    #[doc = "Power down enabled or Powered OFF"]
644    #[inline(always)]
645    pub fn casper_sram_ppd_1(self) -> &'a mut W {
646        self.variant(CASPER_SRAM_PPD_A::CASPER_SRAM_PPD_1)
647    }
648}
649#[doc = "Field `GPU_SRAM_APD` reader - Array Power for GPU SRAM"]
650pub type GPU_SRAM_APD_R = crate::BitReader<GPU_SRAM_APD_A>;
651#[doc = "Array Power for GPU SRAM\n\nValue on reset: 1"]
652#[derive(Clone, Copy, Debug, PartialEq, Eq)]
653pub enum GPU_SRAM_APD_A {
654    #[doc = "0: Power down disabled or Powered ON"]
655    GPU_SRAM_APD_0 = 0,
656    #[doc = "1: Power down enabled or Powered OFF"]
657    GPU_SRAM_APD_1 = 1,
658}
659impl From<GPU_SRAM_APD_A> for bool {
660    #[inline(always)]
661    fn from(variant: GPU_SRAM_APD_A) -> Self {
662        variant as u8 != 0
663    }
664}
665impl GPU_SRAM_APD_R {
666    #[doc = "Get enumerated values variant"]
667    #[inline(always)]
668    pub fn variant(&self) -> GPU_SRAM_APD_A {
669        match self.bits {
670            false => GPU_SRAM_APD_A::GPU_SRAM_APD_0,
671            true => GPU_SRAM_APD_A::GPU_SRAM_APD_1,
672        }
673    }
674    #[doc = "Checks if the value of the field is `GPU_SRAM_APD_0`"]
675    #[inline(always)]
676    pub fn is_gpu_sram_apd_0(&self) -> bool {
677        *self == GPU_SRAM_APD_A::GPU_SRAM_APD_0
678    }
679    #[doc = "Checks if the value of the field is `GPU_SRAM_APD_1`"]
680    #[inline(always)]
681    pub fn is_gpu_sram_apd_1(&self) -> bool {
682        *self == GPU_SRAM_APD_A::GPU_SRAM_APD_1
683    }
684}
685#[doc = "Field `GPU_SRAM_APD` writer - Array Power for GPU SRAM"]
686pub type GPU_SRAM_APD_W<'a, const O: u8> =
687    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, GPU_SRAM_APD_A, O>;
688impl<'a, const O: u8> GPU_SRAM_APD_W<'a, O> {
689    #[doc = "Power down disabled or Powered ON"]
690    #[inline(always)]
691    pub fn gpu_sram_apd_0(self) -> &'a mut W {
692        self.variant(GPU_SRAM_APD_A::GPU_SRAM_APD_0)
693    }
694    #[doc = "Power down enabled or Powered OFF"]
695    #[inline(always)]
696    pub fn gpu_sram_apd_1(self) -> &'a mut W {
697        self.variant(GPU_SRAM_APD_A::GPU_SRAM_APD_1)
698    }
699}
700#[doc = "Field `GPU_SRAM_PPD` reader - Periphery Power for GPU SRAM"]
701pub type GPU_SRAM_PPD_R = crate::BitReader<GPU_SRAM_PPD_A>;
702#[doc = "Periphery Power for GPU SRAM\n\nValue on reset: 1"]
703#[derive(Clone, Copy, Debug, PartialEq, Eq)]
704pub enum GPU_SRAM_PPD_A {
705    #[doc = "0: Enable"]
706    GPU_SRAM_PPD0 = 0,
707    #[doc = "1: Powerdown"]
708    GPU_SRAM_PPD1 = 1,
709}
710impl From<GPU_SRAM_PPD_A> for bool {
711    #[inline(always)]
712    fn from(variant: GPU_SRAM_PPD_A) -> Self {
713        variant as u8 != 0
714    }
715}
716impl GPU_SRAM_PPD_R {
717    #[doc = "Get enumerated values variant"]
718    #[inline(always)]
719    pub fn variant(&self) -> GPU_SRAM_PPD_A {
720        match self.bits {
721            false => GPU_SRAM_PPD_A::GPU_SRAM_PPD0,
722            true => GPU_SRAM_PPD_A::GPU_SRAM_PPD1,
723        }
724    }
725    #[doc = "Checks if the value of the field is `GPU_SRAM_PPD0`"]
726    #[inline(always)]
727    pub fn is_gpu_sram_ppd0(&self) -> bool {
728        *self == GPU_SRAM_PPD_A::GPU_SRAM_PPD0
729    }
730    #[doc = "Checks if the value of the field is `GPU_SRAM_PPD1`"]
731    #[inline(always)]
732    pub fn is_gpu_sram_ppd1(&self) -> bool {
733        *self == GPU_SRAM_PPD_A::GPU_SRAM_PPD1
734    }
735}
736#[doc = "Field `GPU_SRAM_PPD` writer - Periphery Power for GPU SRAM"]
737pub type GPU_SRAM_PPD_W<'a, const O: u8> =
738    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, GPU_SRAM_PPD_A, O>;
739impl<'a, const O: u8> GPU_SRAM_PPD_W<'a, O> {
740    #[doc = "Enable"]
741    #[inline(always)]
742    pub fn gpu_sram_ppd0(self) -> &'a mut W {
743        self.variant(GPU_SRAM_PPD_A::GPU_SRAM_PPD0)
744    }
745    #[doc = "Powerdown"]
746    #[inline(always)]
747    pub fn gpu_sram_ppd1(self) -> &'a mut W {
748        self.variant(GPU_SRAM_PPD_A::GPU_SRAM_PPD1)
749    }
750}
751#[doc = "Field `SMARTDMA_SRAM_APD` reader - Array Power for SMARTDMA SRAM"]
752pub type SMARTDMA_SRAM_APD_R = crate::BitReader<SMARTDMA_SRAM_APD_A>;
753#[doc = "Array Power for SMARTDMA SRAM\n\nValue on reset: 1"]
754#[derive(Clone, Copy, Debug, PartialEq, Eq)]
755pub enum SMARTDMA_SRAM_APD_A {
756    #[doc = "0: Power down disabled or Powered ON"]
757    SMARTDMA_SRAM_APD_0 = 0,
758    #[doc = "1: Power down enabled or Powered OFF"]
759    SMARTDMA_SRAM_APD_1 = 1,
760}
761impl From<SMARTDMA_SRAM_APD_A> for bool {
762    #[inline(always)]
763    fn from(variant: SMARTDMA_SRAM_APD_A) -> Self {
764        variant as u8 != 0
765    }
766}
767impl SMARTDMA_SRAM_APD_R {
768    #[doc = "Get enumerated values variant"]
769    #[inline(always)]
770    pub fn variant(&self) -> SMARTDMA_SRAM_APD_A {
771        match self.bits {
772            false => SMARTDMA_SRAM_APD_A::SMARTDMA_SRAM_APD_0,
773            true => SMARTDMA_SRAM_APD_A::SMARTDMA_SRAM_APD_1,
774        }
775    }
776    #[doc = "Checks if the value of the field is `SMARTDMA_SRAM_APD_0`"]
777    #[inline(always)]
778    pub fn is_smartdma_sram_apd_0(&self) -> bool {
779        *self == SMARTDMA_SRAM_APD_A::SMARTDMA_SRAM_APD_0
780    }
781    #[doc = "Checks if the value of the field is `SMARTDMA_SRAM_APD_1`"]
782    #[inline(always)]
783    pub fn is_smartdma_sram_apd_1(&self) -> bool {
784        *self == SMARTDMA_SRAM_APD_A::SMARTDMA_SRAM_APD_1
785    }
786}
787#[doc = "Field `SMARTDMA_SRAM_APD` writer - Array Power for SMARTDMA SRAM"]
788pub type SMARTDMA_SRAM_APD_W<'a, const O: u8> =
789    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, SMARTDMA_SRAM_APD_A, O>;
790impl<'a, const O: u8> SMARTDMA_SRAM_APD_W<'a, O> {
791    #[doc = "Power down disabled or Powered ON"]
792    #[inline(always)]
793    pub fn smartdma_sram_apd_0(self) -> &'a mut W {
794        self.variant(SMARTDMA_SRAM_APD_A::SMARTDMA_SRAM_APD_0)
795    }
796    #[doc = "Power down enabled or Powered OFF"]
797    #[inline(always)]
798    pub fn smartdma_sram_apd_1(self) -> &'a mut W {
799        self.variant(SMARTDMA_SRAM_APD_A::SMARTDMA_SRAM_APD_1)
800    }
801}
802#[doc = "Field `SMARTDMA_SRAM_PPD` reader - Periphery Power for SMARTDMA SRAM"]
803pub type SMARTDMA_SRAM_PPD_R = crate::BitReader<SMARTDMA_SRAM_PPD_A>;
804#[doc = "Periphery Power for SMARTDMA SRAM\n\nValue on reset: 1"]
805#[derive(Clone, Copy, Debug, PartialEq, Eq)]
806pub enum SMARTDMA_SRAM_PPD_A {
807    #[doc = "0: Enable"]
808    SMARTDMA_SRAM_PPD0 = 0,
809    #[doc = "1: Powerdown"]
810    SMARTDMA_SRAM_PPD1 = 1,
811}
812impl From<SMARTDMA_SRAM_PPD_A> for bool {
813    #[inline(always)]
814    fn from(variant: SMARTDMA_SRAM_PPD_A) -> Self {
815        variant as u8 != 0
816    }
817}
818impl SMARTDMA_SRAM_PPD_R {
819    #[doc = "Get enumerated values variant"]
820    #[inline(always)]
821    pub fn variant(&self) -> SMARTDMA_SRAM_PPD_A {
822        match self.bits {
823            false => SMARTDMA_SRAM_PPD_A::SMARTDMA_SRAM_PPD0,
824            true => SMARTDMA_SRAM_PPD_A::SMARTDMA_SRAM_PPD1,
825        }
826    }
827    #[doc = "Checks if the value of the field is `SMARTDMA_SRAM_PPD0`"]
828    #[inline(always)]
829    pub fn is_smartdma_sram_ppd0(&self) -> bool {
830        *self == SMARTDMA_SRAM_PPD_A::SMARTDMA_SRAM_PPD0
831    }
832    #[doc = "Checks if the value of the field is `SMARTDMA_SRAM_PPD1`"]
833    #[inline(always)]
834    pub fn is_smartdma_sram_ppd1(&self) -> bool {
835        *self == SMARTDMA_SRAM_PPD_A::SMARTDMA_SRAM_PPD1
836    }
837}
838#[doc = "Field `SMARTDMA_SRAM_PPD` writer - Periphery Power for SMARTDMA SRAM"]
839pub type SMARTDMA_SRAM_PPD_W<'a, const O: u8> =
840    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, SMARTDMA_SRAM_PPD_A, O>;
841impl<'a, const O: u8> SMARTDMA_SRAM_PPD_W<'a, O> {
842    #[doc = "Enable"]
843    #[inline(always)]
844    pub fn smartdma_sram_ppd0(self) -> &'a mut W {
845        self.variant(SMARTDMA_SRAM_PPD_A::SMARTDMA_SRAM_PPD0)
846    }
847    #[doc = "Powerdown"]
848    #[inline(always)]
849    pub fn smartdma_sram_ppd1(self) -> &'a mut W {
850        self.variant(SMARTDMA_SRAM_PPD_A::SMARTDMA_SRAM_PPD1)
851    }
852}
853#[doc = "Field `MIPIDSI_SRAM_APD` reader - Array Power for MIPIDSI SRAM"]
854pub type MIPIDSI_SRAM_APD_R = crate::BitReader<MIPIDSI_SRAM_APD_A>;
855#[doc = "Array Power for MIPIDSI SRAM\n\nValue on reset: 1"]
856#[derive(Clone, Copy, Debug, PartialEq, Eq)]
857pub enum MIPIDSI_SRAM_APD_A {
858    #[doc = "0: Power down disabled or Powered ON"]
859    MIPIDSI_SRAM_APD_0 = 0,
860    #[doc = "1: Power down enabled or Powered OFF"]
861    MIPIDSI_SRAM_APD_1 = 1,
862}
863impl From<MIPIDSI_SRAM_APD_A> for bool {
864    #[inline(always)]
865    fn from(variant: MIPIDSI_SRAM_APD_A) -> Self {
866        variant as u8 != 0
867    }
868}
869impl MIPIDSI_SRAM_APD_R {
870    #[doc = "Get enumerated values variant"]
871    #[inline(always)]
872    pub fn variant(&self) -> MIPIDSI_SRAM_APD_A {
873        match self.bits {
874            false => MIPIDSI_SRAM_APD_A::MIPIDSI_SRAM_APD_0,
875            true => MIPIDSI_SRAM_APD_A::MIPIDSI_SRAM_APD_1,
876        }
877    }
878    #[doc = "Checks if the value of the field is `MIPIDSI_SRAM_APD_0`"]
879    #[inline(always)]
880    pub fn is_mipidsi_sram_apd_0(&self) -> bool {
881        *self == MIPIDSI_SRAM_APD_A::MIPIDSI_SRAM_APD_0
882    }
883    #[doc = "Checks if the value of the field is `MIPIDSI_SRAM_APD_1`"]
884    #[inline(always)]
885    pub fn is_mipidsi_sram_apd_1(&self) -> bool {
886        *self == MIPIDSI_SRAM_APD_A::MIPIDSI_SRAM_APD_1
887    }
888}
889#[doc = "Field `MIPIDSI_SRAM_APD` writer - Array Power for MIPIDSI SRAM"]
890pub type MIPIDSI_SRAM_APD_W<'a, const O: u8> =
891    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, MIPIDSI_SRAM_APD_A, O>;
892impl<'a, const O: u8> MIPIDSI_SRAM_APD_W<'a, O> {
893    #[doc = "Power down disabled or Powered ON"]
894    #[inline(always)]
895    pub fn mipidsi_sram_apd_0(self) -> &'a mut W {
896        self.variant(MIPIDSI_SRAM_APD_A::MIPIDSI_SRAM_APD_0)
897    }
898    #[doc = "Power down enabled or Powered OFF"]
899    #[inline(always)]
900    pub fn mipidsi_sram_apd_1(self) -> &'a mut W {
901        self.variant(MIPIDSI_SRAM_APD_A::MIPIDSI_SRAM_APD_1)
902    }
903}
904#[doc = "Field `MIPIDSI_SRAM_PPD` reader - Periphery Power for MIPIDSI SRAM"]
905pub type MIPIDSI_SRAM_PPD_R = crate::BitReader<MIPIDSI_SRAM_PPD_A>;
906#[doc = "Periphery Power for MIPIDSI SRAM\n\nValue on reset: 1"]
907#[derive(Clone, Copy, Debug, PartialEq, Eq)]
908pub enum MIPIDSI_SRAM_PPD_A {
909    #[doc = "0: Power down disabled or Powered ON"]
910    MIPIDSI_SRAM_PPD_0 = 0,
911    #[doc = "1: Power down enabled or Powered OFF"]
912    MIPIDSI_SRAM_PPD_1 = 1,
913}
914impl From<MIPIDSI_SRAM_PPD_A> for bool {
915    #[inline(always)]
916    fn from(variant: MIPIDSI_SRAM_PPD_A) -> Self {
917        variant as u8 != 0
918    }
919}
920impl MIPIDSI_SRAM_PPD_R {
921    #[doc = "Get enumerated values variant"]
922    #[inline(always)]
923    pub fn variant(&self) -> MIPIDSI_SRAM_PPD_A {
924        match self.bits {
925            false => MIPIDSI_SRAM_PPD_A::MIPIDSI_SRAM_PPD_0,
926            true => MIPIDSI_SRAM_PPD_A::MIPIDSI_SRAM_PPD_1,
927        }
928    }
929    #[doc = "Checks if the value of the field is `MIPIDSI_SRAM_PPD_0`"]
930    #[inline(always)]
931    pub fn is_mipidsi_sram_ppd_0(&self) -> bool {
932        *self == MIPIDSI_SRAM_PPD_A::MIPIDSI_SRAM_PPD_0
933    }
934    #[doc = "Checks if the value of the field is `MIPIDSI_SRAM_PPD_1`"]
935    #[inline(always)]
936    pub fn is_mipidsi_sram_ppd_1(&self) -> bool {
937        *self == MIPIDSI_SRAM_PPD_A::MIPIDSI_SRAM_PPD_1
938    }
939}
940#[doc = "Field `MIPIDSI_SRAM_PPD` writer - Periphery Power for MIPIDSI SRAM"]
941pub type MIPIDSI_SRAM_PPD_W<'a, const O: u8> =
942    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, MIPIDSI_SRAM_PPD_A, O>;
943impl<'a, const O: u8> MIPIDSI_SRAM_PPD_W<'a, O> {
944    #[doc = "Power down disabled or Powered ON"]
945    #[inline(always)]
946    pub fn mipidsi_sram_ppd_0(self) -> &'a mut W {
947        self.variant(MIPIDSI_SRAM_PPD_A::MIPIDSI_SRAM_PPD_0)
948    }
949    #[doc = "Power down enabled or Powered OFF"]
950    #[inline(always)]
951    pub fn mipidsi_sram_ppd_1(self) -> &'a mut W {
952        self.variant(MIPIDSI_SRAM_PPD_A::MIPIDSI_SRAM_PPD_1)
953    }
954}
955#[doc = "Field `LCDIF_SRAM_APD` reader - Array Power for LCDIF SRAM"]
956pub type LCDIF_SRAM_APD_R = crate::BitReader<LCDIF_SRAM_APD_A>;
957#[doc = "Array Power for LCDIF SRAM\n\nValue on reset: 1"]
958#[derive(Clone, Copy, Debug, PartialEq, Eq)]
959pub enum LCDIF_SRAM_APD_A {
960    #[doc = "0: Power down disabled or Powered ON"]
961    LCDIF_SRAM_APD_0 = 0,
962    #[doc = "1: Power down enabled or Powered OFF"]
963    LCDIF_SRAM_APD_1 = 1,
964}
965impl From<LCDIF_SRAM_APD_A> for bool {
966    #[inline(always)]
967    fn from(variant: LCDIF_SRAM_APD_A) -> Self {
968        variant as u8 != 0
969    }
970}
971impl LCDIF_SRAM_APD_R {
972    #[doc = "Get enumerated values variant"]
973    #[inline(always)]
974    pub fn variant(&self) -> LCDIF_SRAM_APD_A {
975        match self.bits {
976            false => LCDIF_SRAM_APD_A::LCDIF_SRAM_APD_0,
977            true => LCDIF_SRAM_APD_A::LCDIF_SRAM_APD_1,
978        }
979    }
980    #[doc = "Checks if the value of the field is `LCDIF_SRAM_APD_0`"]
981    #[inline(always)]
982    pub fn is_lcdif_sram_apd_0(&self) -> bool {
983        *self == LCDIF_SRAM_APD_A::LCDIF_SRAM_APD_0
984    }
985    #[doc = "Checks if the value of the field is `LCDIF_SRAM_APD_1`"]
986    #[inline(always)]
987    pub fn is_lcdif_sram_apd_1(&self) -> bool {
988        *self == LCDIF_SRAM_APD_A::LCDIF_SRAM_APD_1
989    }
990}
991#[doc = "Field `LCDIF_SRAM_APD` writer - Array Power for LCDIF SRAM"]
992pub type LCDIF_SRAM_APD_W<'a, const O: u8> =
993    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, LCDIF_SRAM_APD_A, O>;
994impl<'a, const O: u8> LCDIF_SRAM_APD_W<'a, O> {
995    #[doc = "Power down disabled or Powered ON"]
996    #[inline(always)]
997    pub fn lcdif_sram_apd_0(self) -> &'a mut W {
998        self.variant(LCDIF_SRAM_APD_A::LCDIF_SRAM_APD_0)
999    }
1000    #[doc = "Power down enabled or Powered OFF"]
1001    #[inline(always)]
1002    pub fn lcdif_sram_apd_1(self) -> &'a mut W {
1003        self.variant(LCDIF_SRAM_APD_A::LCDIF_SRAM_APD_1)
1004    }
1005}
1006#[doc = "Field `LCDIF_SRAM_PPD` reader - Periphery Power for LCDIF SRAM"]
1007pub type LCDIF_SRAM_PPD_R = crate::BitReader<LCDIF_SRAM_PPD_A>;
1008#[doc = "Periphery Power for LCDIF SRAM\n\nValue on reset: 1"]
1009#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1010pub enum LCDIF_SRAM_PPD_A {
1011    #[doc = "0: Power down disabled or Powered ON"]
1012    LCDIF_SRAM_PPD_0 = 0,
1013    #[doc = "1: Powerdown"]
1014    _LCDIF_SRAM_PPD1_1 = 1,
1015}
1016impl From<LCDIF_SRAM_PPD_A> for bool {
1017    #[inline(always)]
1018    fn from(variant: LCDIF_SRAM_PPD_A) -> Self {
1019        variant as u8 != 0
1020    }
1021}
1022impl LCDIF_SRAM_PPD_R {
1023    #[doc = "Get enumerated values variant"]
1024    #[inline(always)]
1025    pub fn variant(&self) -> LCDIF_SRAM_PPD_A {
1026        match self.bits {
1027            false => LCDIF_SRAM_PPD_A::LCDIF_SRAM_PPD_0,
1028            true => LCDIF_SRAM_PPD_A::_LCDIF_SRAM_PPD1_1,
1029        }
1030    }
1031    #[doc = "Checks if the value of the field is `LCDIF_SRAM_PPD_0`"]
1032    #[inline(always)]
1033    pub fn is_lcdif_sram_ppd_0(&self) -> bool {
1034        *self == LCDIF_SRAM_PPD_A::LCDIF_SRAM_PPD_0
1035    }
1036    #[doc = "Checks if the value of the field is `_LCDIF_SRAM_PPD1_1`"]
1037    #[inline(always)]
1038    pub fn is_lcdif_sram_ppd1_1(&self) -> bool {
1039        *self == LCDIF_SRAM_PPD_A::_LCDIF_SRAM_PPD1_1
1040    }
1041}
1042#[doc = "Field `LCDIF_SRAM_PPD` writer - Periphery Power for LCDIF SRAM"]
1043pub type LCDIF_SRAM_PPD_W<'a, const O: u8> =
1044    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, LCDIF_SRAM_PPD_A, O>;
1045impl<'a, const O: u8> LCDIF_SRAM_PPD_W<'a, O> {
1046    #[doc = "Power down disabled or Powered ON"]
1047    #[inline(always)]
1048    pub fn lcdif_sram_ppd_0(self) -> &'a mut W {
1049        self.variant(LCDIF_SRAM_PPD_A::LCDIF_SRAM_PPD_0)
1050    }
1051    #[doc = "Powerdown"]
1052    #[inline(always)]
1053    pub fn _lcdif_sram_ppd1_1(self) -> &'a mut W {
1054        self.variant(LCDIF_SRAM_PPD_A::_LCDIF_SRAM_PPD1_1)
1055    }
1056}
1057#[doc = "Field `DSP_PD` reader - DSP"]
1058pub type DSP_PD_R = crate::BitReader<DSP_PD_A>;
1059#[doc = "DSP\n\nValue on reset: 1"]
1060#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1061pub enum DSP_PD_A {
1062    #[doc = "0: DSP not power gated"]
1063    DSP_PD_0 = 0,
1064    #[doc = "1: DSP power gated"]
1065    DSP_PD_1 = 1,
1066}
1067impl From<DSP_PD_A> for bool {
1068    #[inline(always)]
1069    fn from(variant: DSP_PD_A) -> Self {
1070        variant as u8 != 0
1071    }
1072}
1073impl DSP_PD_R {
1074    #[doc = "Get enumerated values variant"]
1075    #[inline(always)]
1076    pub fn variant(&self) -> DSP_PD_A {
1077        match self.bits {
1078            false => DSP_PD_A::DSP_PD_0,
1079            true => DSP_PD_A::DSP_PD_1,
1080        }
1081    }
1082    #[doc = "Checks if the value of the field is `DSP_PD_0`"]
1083    #[inline(always)]
1084    pub fn is_dsp_pd_0(&self) -> bool {
1085        *self == DSP_PD_A::DSP_PD_0
1086    }
1087    #[doc = "Checks if the value of the field is `DSP_PD_1`"]
1088    #[inline(always)]
1089    pub fn is_dsp_pd_1(&self) -> bool {
1090        *self == DSP_PD_A::DSP_PD_1
1091    }
1092}
1093#[doc = "Field `DSP_PD` writer - DSP"]
1094pub type DSP_PD_W<'a, const O: u8> = crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, DSP_PD_A, O>;
1095impl<'a, const O: u8> DSP_PD_W<'a, O> {
1096    #[doc = "DSP not power gated"]
1097    #[inline(always)]
1098    pub fn dsp_pd_0(self) -> &'a mut W {
1099        self.variant(DSP_PD_A::DSP_PD_0)
1100    }
1101    #[doc = "DSP power gated"]
1102    #[inline(always)]
1103    pub fn dsp_pd_1(self) -> &'a mut W {
1104        self.variant(DSP_PD_A::DSP_PD_1)
1105    }
1106}
1107#[doc = "Field `MIPIDSI_PD` reader - MIPIDSI"]
1108pub type MIPIDSI_PD_R = crate::BitReader<MIPIDSI_PD_A>;
1109#[doc = "MIPIDSI\n\nValue on reset: 1"]
1110#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1111pub enum MIPIDSI_PD_A {
1112    #[doc = "0: MIPI DSI not power gated"]
1113    MIPIDSI_PD_0 = 0,
1114    #[doc = "1: MIPI DSI power gated"]
1115    MIPIDSI_PD_1 = 1,
1116}
1117impl From<MIPIDSI_PD_A> for bool {
1118    #[inline(always)]
1119    fn from(variant: MIPIDSI_PD_A) -> Self {
1120        variant as u8 != 0
1121    }
1122}
1123impl MIPIDSI_PD_R {
1124    #[doc = "Get enumerated values variant"]
1125    #[inline(always)]
1126    pub fn variant(&self) -> MIPIDSI_PD_A {
1127        match self.bits {
1128            false => MIPIDSI_PD_A::MIPIDSI_PD_0,
1129            true => MIPIDSI_PD_A::MIPIDSI_PD_1,
1130        }
1131    }
1132    #[doc = "Checks if the value of the field is `MIPIDSI_PD_0`"]
1133    #[inline(always)]
1134    pub fn is_mipidsi_pd_0(&self) -> bool {
1135        *self == MIPIDSI_PD_A::MIPIDSI_PD_0
1136    }
1137    #[doc = "Checks if the value of the field is `MIPIDSI_PD_1`"]
1138    #[inline(always)]
1139    pub fn is_mipidsi_pd_1(&self) -> bool {
1140        *self == MIPIDSI_PD_A::MIPIDSI_PD_1
1141    }
1142}
1143#[doc = "Field `MIPIDSI_PD` writer - MIPIDSI"]
1144pub type MIPIDSI_PD_W<'a, const O: u8> =
1145    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, MIPIDSI_PD_A, O>;
1146impl<'a, const O: u8> MIPIDSI_PD_W<'a, O> {
1147    #[doc = "MIPI DSI not power gated"]
1148    #[inline(always)]
1149    pub fn mipidsi_pd_0(self) -> &'a mut W {
1150        self.variant(MIPIDSI_PD_A::MIPIDSI_PD_0)
1151    }
1152    #[doc = "MIPI DSI power gated"]
1153    #[inline(always)]
1154    pub fn mipidsi_pd_1(self) -> &'a mut W {
1155        self.variant(MIPIDSI_PD_A::MIPIDSI_PD_1)
1156    }
1157}
1158#[doc = "Field `OTP_PD` reader - OTP"]
1159pub type OTP_PD_R = crate::BitReader<OTP_PD_A>;
1160#[doc = "OTP\n\nValue on reset: 0"]
1161#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1162pub enum OTP_PD_A {
1163    #[doc = "0: Powered"]
1164    OTP_PD_0 = 0,
1165    #[doc = "1: Not Powered"]
1166    OTP_PD_1 = 1,
1167}
1168impl From<OTP_PD_A> for bool {
1169    #[inline(always)]
1170    fn from(variant: OTP_PD_A) -> Self {
1171        variant as u8 != 0
1172    }
1173}
1174impl OTP_PD_R {
1175    #[doc = "Get enumerated values variant"]
1176    #[inline(always)]
1177    pub fn variant(&self) -> OTP_PD_A {
1178        match self.bits {
1179            false => OTP_PD_A::OTP_PD_0,
1180            true => OTP_PD_A::OTP_PD_1,
1181        }
1182    }
1183    #[doc = "Checks if the value of the field is `OTP_PD_0`"]
1184    #[inline(always)]
1185    pub fn is_otp_pd_0(&self) -> bool {
1186        *self == OTP_PD_A::OTP_PD_0
1187    }
1188    #[doc = "Checks if the value of the field is `OTP_PD_1`"]
1189    #[inline(always)]
1190    pub fn is_otp_pd_1(&self) -> bool {
1191        *self == OTP_PD_A::OTP_PD_1
1192    }
1193}
1194#[doc = "Field `OTP_PD` writer - OTP"]
1195pub type OTP_PD_W<'a, const O: u8> = crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, OTP_PD_A, O>;
1196impl<'a, const O: u8> OTP_PD_W<'a, O> {
1197    #[doc = "Powered"]
1198    #[inline(always)]
1199    pub fn otp_pd_0(self) -> &'a mut W {
1200        self.variant(OTP_PD_A::OTP_PD_0)
1201    }
1202    #[doc = "Not Powered"]
1203    #[inline(always)]
1204    pub fn otp_pd_1(self) -> &'a mut W {
1205        self.variant(OTP_PD_A::OTP_PD_1)
1206    }
1207}
1208#[doc = "Field `ROM_PD` reader - ROM"]
1209pub type ROM_PD_R = crate::BitReader<ROM_PD_A>;
1210#[doc = "ROM\n\nValue on reset: 0"]
1211#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1212pub enum ROM_PD_A {
1213    #[doc = "0: ROM Powered"]
1214    ROM_PD_0 = 0,
1215    #[doc = "1: ROM not Powered"]
1216    ROM_PD_1 = 1,
1217}
1218impl From<ROM_PD_A> for bool {
1219    #[inline(always)]
1220    fn from(variant: ROM_PD_A) -> Self {
1221        variant as u8 != 0
1222    }
1223}
1224impl ROM_PD_R {
1225    #[doc = "Get enumerated values variant"]
1226    #[inline(always)]
1227    pub fn variant(&self) -> ROM_PD_A {
1228        match self.bits {
1229            false => ROM_PD_A::ROM_PD_0,
1230            true => ROM_PD_A::ROM_PD_1,
1231        }
1232    }
1233    #[doc = "Checks if the value of the field is `ROM_PD_0`"]
1234    #[inline(always)]
1235    pub fn is_rom_pd_0(&self) -> bool {
1236        *self == ROM_PD_A::ROM_PD_0
1237    }
1238    #[doc = "Checks if the value of the field is `ROM_PD_1`"]
1239    #[inline(always)]
1240    pub fn is_rom_pd_1(&self) -> bool {
1241        *self == ROM_PD_A::ROM_PD_1
1242    }
1243}
1244#[doc = "Field `ROM_PD` writer - ROM"]
1245pub type ROM_PD_W<'a, const O: u8> = crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, ROM_PD_A, O>;
1246impl<'a, const O: u8> ROM_PD_W<'a, O> {
1247    #[doc = "ROM Powered"]
1248    #[inline(always)]
1249    pub fn rom_pd_0(self) -> &'a mut W {
1250        self.variant(ROM_PD_A::ROM_PD_0)
1251    }
1252    #[doc = "ROM not Powered"]
1253    #[inline(always)]
1254    pub fn rom_pd_1(self) -> &'a mut W {
1255        self.variant(ROM_PD_A::ROM_PD_1)
1256    }
1257}
1258#[doc = "Field `SRAM_SLEEP` reader - SRAM sleep mode"]
1259pub type SRAM_SLEEP_R = crate::BitReader<SRAM_SLEEP_A>;
1260#[doc = "SRAM sleep mode\n\nValue on reset: 0"]
1261#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1262pub enum SRAM_SLEEP_A {
1263    #[doc = "0: RAM Normal mode"]
1264    SRAM_SLEEP_0 = 0,
1265    #[doc = "1: RAM Sleep mode. Needed when vddcore can be < 0.6V to ensure contents retained. Memories not accessible in this mode."]
1266    SRAM_SLEEP_1 = 1,
1267}
1268impl From<SRAM_SLEEP_A> for bool {
1269    #[inline(always)]
1270    fn from(variant: SRAM_SLEEP_A) -> Self {
1271        variant as u8 != 0
1272    }
1273}
1274impl SRAM_SLEEP_R {
1275    #[doc = "Get enumerated values variant"]
1276    #[inline(always)]
1277    pub fn variant(&self) -> SRAM_SLEEP_A {
1278        match self.bits {
1279            false => SRAM_SLEEP_A::SRAM_SLEEP_0,
1280            true => SRAM_SLEEP_A::SRAM_SLEEP_1,
1281        }
1282    }
1283    #[doc = "Checks if the value of the field is `SRAM_SLEEP_0`"]
1284    #[inline(always)]
1285    pub fn is_sram_sleep_0(&self) -> bool {
1286        *self == SRAM_SLEEP_A::SRAM_SLEEP_0
1287    }
1288    #[doc = "Checks if the value of the field is `SRAM_SLEEP_1`"]
1289    #[inline(always)]
1290    pub fn is_sram_sleep_1(&self) -> bool {
1291        *self == SRAM_SLEEP_A::SRAM_SLEEP_1
1292    }
1293}
1294#[doc = "Field `SRAM_SLEEP` writer - SRAM sleep mode"]
1295pub type SRAM_SLEEP_W<'a, const O: u8> =
1296    crate::BitWriter<'a, u32, PDSLEEPCFG1_SPEC, SRAM_SLEEP_A, O>;
1297impl<'a, const O: u8> SRAM_SLEEP_W<'a, O> {
1298    #[doc = "RAM Normal mode"]
1299    #[inline(always)]
1300    pub fn sram_sleep_0(self) -> &'a mut W {
1301        self.variant(SRAM_SLEEP_A::SRAM_SLEEP_0)
1302    }
1303    #[doc = "RAM Sleep mode. Needed when vddcore can be < 0.6V to ensure contents retained. Memories not accessible in this mode."]
1304    #[inline(always)]
1305    pub fn sram_sleep_1(self) -> &'a mut W {
1306        self.variant(SRAM_SLEEP_A::SRAM_SLEEP_1)
1307    }
1308}
1309impl R {
1310    #[doc = "Bit 1 - Periphery power for PowerQuad RAM"]
1311    #[inline(always)]
1312    pub fn pq_sram_ppd(&self) -> PQ_SRAM_PPD_R {
1313        PQ_SRAM_PPD_R::new(((self.bits >> 1) & 1) != 0)
1314    }
1315    #[doc = "Bit 2 - Array power for FLEXSPI0 RAM"]
1316    #[inline(always)]
1317    pub fn flexspi0_sram_apd(&self) -> FLEXSPI0_SRAM_APD_R {
1318        FLEXSPI0_SRAM_APD_R::new(((self.bits >> 2) & 1) != 0)
1319    }
1320    #[doc = "Bit 3 - Periphery power for FLEXSPI0 RAM"]
1321    #[inline(always)]
1322    pub fn flexspi0_sram_ppd(&self) -> FLEXSPI0_SRAM_PPD_R {
1323        FLEXSPI0_SRAM_PPD_R::new(((self.bits >> 3) & 1) != 0)
1324    }
1325    #[doc = "Bit 4 - Array power for FLEXSPI1 RAM"]
1326    #[inline(always)]
1327    pub fn flexspi1_sram_apd(&self) -> FLEXSPI1_SRAM_APD_R {
1328        FLEXSPI1_SRAM_APD_R::new(((self.bits >> 4) & 1) != 0)
1329    }
1330    #[doc = "Bit 5 - Periphery power for FLEXSPI1 RAM"]
1331    #[inline(always)]
1332    pub fn flexspi1_sram_ppd(&self) -> FLEXSPI1_SRAM_PPD_R {
1333        FLEXSPI1_SRAM_PPD_R::new(((self.bits >> 5) & 1) != 0)
1334    }
1335    #[doc = "Bit 6 - Array power for USB RAM"]
1336    #[inline(always)]
1337    pub fn usbhs_sram_apd(&self) -> USBHS_SRAM_APD_R {
1338        USBHS_SRAM_APD_R::new(((self.bits >> 6) & 1) != 0)
1339    }
1340    #[doc = "Bit 7 - Periphery power for USB RAM"]
1341    #[inline(always)]
1342    pub fn usbhs_sram_ppd(&self) -> USBHS_SRAM_PPD_R {
1343        USBHS_SRAM_PPD_R::new(((self.bits >> 7) & 1) != 0)
1344    }
1345    #[doc = "Bit 8 - Array power for uSDHC0 (SD/MMC/SDIO interface) RAM"]
1346    #[inline(always)]
1347    pub fn usdhc0_sram_apd(&self) -> USDHC0_SRAM_APD_R {
1348        USDHC0_SRAM_APD_R::new(((self.bits >> 8) & 1) != 0)
1349    }
1350    #[doc = "Bit 9 - Periphery power for uSDHC0 (SD/MMC/SDIO interface) RAM"]
1351    #[inline(always)]
1352    pub fn usdhc0_sram_ppd(&self) -> USDHC0_SRAM_PPD_R {
1353        USDHC0_SRAM_PPD_R::new(((self.bits >> 9) & 1) != 0)
1354    }
1355    #[doc = "Bit 10 - Array power for Casper RAM"]
1356    #[inline(always)]
1357    pub fn usdhc1_sram_apd(&self) -> USDHC1_SRAM_APD_R {
1358        USDHC1_SRAM_APD_R::new(((self.bits >> 10) & 1) != 0)
1359    }
1360    #[doc = "Bit 11 - Periphery power for uSDHC1 (SD/MMC/SDIO interface) RAM"]
1361    #[inline(always)]
1362    pub fn usdhc1_sram_ppd(&self) -> USDHC1_SRAM_PPD_R {
1363        USDHC1_SRAM_PPD_R::new(((self.bits >> 11) & 1) != 0)
1364    }
1365    #[doc = "Bit 13 - Periphery power for Casper RAM"]
1366    #[inline(always)]
1367    pub fn casper_sram_ppd(&self) -> CASPER_SRAM_PPD_R {
1368        CASPER_SRAM_PPD_R::new(((self.bits >> 13) & 1) != 0)
1369    }
1370    #[doc = "Bit 14 - Array Power for GPU SRAM"]
1371    #[inline(always)]
1372    pub fn gpu_sram_apd(&self) -> GPU_SRAM_APD_R {
1373        GPU_SRAM_APD_R::new(((self.bits >> 14) & 1) != 0)
1374    }
1375    #[doc = "Bit 15 - Periphery Power for GPU SRAM"]
1376    #[inline(always)]
1377    pub fn gpu_sram_ppd(&self) -> GPU_SRAM_PPD_R {
1378        GPU_SRAM_PPD_R::new(((self.bits >> 15) & 1) != 0)
1379    }
1380    #[doc = "Bit 16 - Array Power for SMARTDMA SRAM"]
1381    #[inline(always)]
1382    pub fn smartdma_sram_apd(&self) -> SMARTDMA_SRAM_APD_R {
1383        SMARTDMA_SRAM_APD_R::new(((self.bits >> 16) & 1) != 0)
1384    }
1385    #[doc = "Bit 17 - Periphery Power for SMARTDMA SRAM"]
1386    #[inline(always)]
1387    pub fn smartdma_sram_ppd(&self) -> SMARTDMA_SRAM_PPD_R {
1388        SMARTDMA_SRAM_PPD_R::new(((self.bits >> 17) & 1) != 0)
1389    }
1390    #[doc = "Bit 18 - Array Power for MIPIDSI SRAM"]
1391    #[inline(always)]
1392    pub fn mipidsi_sram_apd(&self) -> MIPIDSI_SRAM_APD_R {
1393        MIPIDSI_SRAM_APD_R::new(((self.bits >> 18) & 1) != 0)
1394    }
1395    #[doc = "Bit 19 - Periphery Power for MIPIDSI SRAM"]
1396    #[inline(always)]
1397    pub fn mipidsi_sram_ppd(&self) -> MIPIDSI_SRAM_PPD_R {
1398        MIPIDSI_SRAM_PPD_R::new(((self.bits >> 19) & 1) != 0)
1399    }
1400    #[doc = "Bit 20 - Array Power for LCDIF SRAM"]
1401    #[inline(always)]
1402    pub fn lcdif_sram_apd(&self) -> LCDIF_SRAM_APD_R {
1403        LCDIF_SRAM_APD_R::new(((self.bits >> 20) & 1) != 0)
1404    }
1405    #[doc = "Bit 21 - Periphery Power for LCDIF SRAM"]
1406    #[inline(always)]
1407    pub fn lcdif_sram_ppd(&self) -> LCDIF_SRAM_PPD_R {
1408        LCDIF_SRAM_PPD_R::new(((self.bits >> 21) & 1) != 0)
1409    }
1410    #[doc = "Bit 25 - DSP"]
1411    #[inline(always)]
1412    pub fn dsp_pd(&self) -> DSP_PD_R {
1413        DSP_PD_R::new(((self.bits >> 25) & 1) != 0)
1414    }
1415    #[doc = "Bit 26 - MIPIDSI"]
1416    #[inline(always)]
1417    pub fn mipidsi_pd(&self) -> MIPIDSI_PD_R {
1418        MIPIDSI_PD_R::new(((self.bits >> 26) & 1) != 0)
1419    }
1420    #[doc = "Bit 27 - OTP"]
1421    #[inline(always)]
1422    pub fn otp_pd(&self) -> OTP_PD_R {
1423        OTP_PD_R::new(((self.bits >> 27) & 1) != 0)
1424    }
1425    #[doc = "Bit 28 - ROM"]
1426    #[inline(always)]
1427    pub fn rom_pd(&self) -> ROM_PD_R {
1428        ROM_PD_R::new(((self.bits >> 28) & 1) != 0)
1429    }
1430    #[doc = "Bit 31 - SRAM sleep mode"]
1431    #[inline(always)]
1432    pub fn sram_sleep(&self) -> SRAM_SLEEP_R {
1433        SRAM_SLEEP_R::new(((self.bits >> 31) & 1) != 0)
1434    }
1435}
1436impl W {
1437    #[doc = "Bit 1 - Periphery power for PowerQuad RAM"]
1438    #[inline(always)]
1439    #[must_use]
1440    pub fn pq_sram_ppd(&mut self) -> PQ_SRAM_PPD_W<1> {
1441        PQ_SRAM_PPD_W::new(self)
1442    }
1443    #[doc = "Bit 2 - Array power for FLEXSPI0 RAM"]
1444    #[inline(always)]
1445    #[must_use]
1446    pub fn flexspi0_sram_apd(&mut self) -> FLEXSPI0_SRAM_APD_W<2> {
1447        FLEXSPI0_SRAM_APD_W::new(self)
1448    }
1449    #[doc = "Bit 3 - Periphery power for FLEXSPI0 RAM"]
1450    #[inline(always)]
1451    #[must_use]
1452    pub fn flexspi0_sram_ppd(&mut self) -> FLEXSPI0_SRAM_PPD_W<3> {
1453        FLEXSPI0_SRAM_PPD_W::new(self)
1454    }
1455    #[doc = "Bit 4 - Array power for FLEXSPI1 RAM"]
1456    #[inline(always)]
1457    #[must_use]
1458    pub fn flexspi1_sram_apd(&mut self) -> FLEXSPI1_SRAM_APD_W<4> {
1459        FLEXSPI1_SRAM_APD_W::new(self)
1460    }
1461    #[doc = "Bit 5 - Periphery power for FLEXSPI1 RAM"]
1462    #[inline(always)]
1463    #[must_use]
1464    pub fn flexspi1_sram_ppd(&mut self) -> FLEXSPI1_SRAM_PPD_W<5> {
1465        FLEXSPI1_SRAM_PPD_W::new(self)
1466    }
1467    #[doc = "Bit 6 - Array power for USB RAM"]
1468    #[inline(always)]
1469    #[must_use]
1470    pub fn usbhs_sram_apd(&mut self) -> USBHS_SRAM_APD_W<6> {
1471        USBHS_SRAM_APD_W::new(self)
1472    }
1473    #[doc = "Bit 7 - Periphery power for USB RAM"]
1474    #[inline(always)]
1475    #[must_use]
1476    pub fn usbhs_sram_ppd(&mut self) -> USBHS_SRAM_PPD_W<7> {
1477        USBHS_SRAM_PPD_W::new(self)
1478    }
1479    #[doc = "Bit 8 - Array power for uSDHC0 (SD/MMC/SDIO interface) RAM"]
1480    #[inline(always)]
1481    #[must_use]
1482    pub fn usdhc0_sram_apd(&mut self) -> USDHC0_SRAM_APD_W<8> {
1483        USDHC0_SRAM_APD_W::new(self)
1484    }
1485    #[doc = "Bit 9 - Periphery power for uSDHC0 (SD/MMC/SDIO interface) RAM"]
1486    #[inline(always)]
1487    #[must_use]
1488    pub fn usdhc0_sram_ppd(&mut self) -> USDHC0_SRAM_PPD_W<9> {
1489        USDHC0_SRAM_PPD_W::new(self)
1490    }
1491    #[doc = "Bit 10 - Array power for Casper RAM"]
1492    #[inline(always)]
1493    #[must_use]
1494    pub fn usdhc1_sram_apd(&mut self) -> USDHC1_SRAM_APD_W<10> {
1495        USDHC1_SRAM_APD_W::new(self)
1496    }
1497    #[doc = "Bit 11 - Periphery power for uSDHC1 (SD/MMC/SDIO interface) RAM"]
1498    #[inline(always)]
1499    #[must_use]
1500    pub fn usdhc1_sram_ppd(&mut self) -> USDHC1_SRAM_PPD_W<11> {
1501        USDHC1_SRAM_PPD_W::new(self)
1502    }
1503    #[doc = "Bit 13 - Periphery power for Casper RAM"]
1504    #[inline(always)]
1505    #[must_use]
1506    pub fn casper_sram_ppd(&mut self) -> CASPER_SRAM_PPD_W<13> {
1507        CASPER_SRAM_PPD_W::new(self)
1508    }
1509    #[doc = "Bit 14 - Array Power for GPU SRAM"]
1510    #[inline(always)]
1511    #[must_use]
1512    pub fn gpu_sram_apd(&mut self) -> GPU_SRAM_APD_W<14> {
1513        GPU_SRAM_APD_W::new(self)
1514    }
1515    #[doc = "Bit 15 - Periphery Power for GPU SRAM"]
1516    #[inline(always)]
1517    #[must_use]
1518    pub fn gpu_sram_ppd(&mut self) -> GPU_SRAM_PPD_W<15> {
1519        GPU_SRAM_PPD_W::new(self)
1520    }
1521    #[doc = "Bit 16 - Array Power for SMARTDMA SRAM"]
1522    #[inline(always)]
1523    #[must_use]
1524    pub fn smartdma_sram_apd(&mut self) -> SMARTDMA_SRAM_APD_W<16> {
1525        SMARTDMA_SRAM_APD_W::new(self)
1526    }
1527    #[doc = "Bit 17 - Periphery Power for SMARTDMA SRAM"]
1528    #[inline(always)]
1529    #[must_use]
1530    pub fn smartdma_sram_ppd(&mut self) -> SMARTDMA_SRAM_PPD_W<17> {
1531        SMARTDMA_SRAM_PPD_W::new(self)
1532    }
1533    #[doc = "Bit 18 - Array Power for MIPIDSI SRAM"]
1534    #[inline(always)]
1535    #[must_use]
1536    pub fn mipidsi_sram_apd(&mut self) -> MIPIDSI_SRAM_APD_W<18> {
1537        MIPIDSI_SRAM_APD_W::new(self)
1538    }
1539    #[doc = "Bit 19 - Periphery Power for MIPIDSI SRAM"]
1540    #[inline(always)]
1541    #[must_use]
1542    pub fn mipidsi_sram_ppd(&mut self) -> MIPIDSI_SRAM_PPD_W<19> {
1543        MIPIDSI_SRAM_PPD_W::new(self)
1544    }
1545    #[doc = "Bit 20 - Array Power for LCDIF SRAM"]
1546    #[inline(always)]
1547    #[must_use]
1548    pub fn lcdif_sram_apd(&mut self) -> LCDIF_SRAM_APD_W<20> {
1549        LCDIF_SRAM_APD_W::new(self)
1550    }
1551    #[doc = "Bit 21 - Periphery Power for LCDIF SRAM"]
1552    #[inline(always)]
1553    #[must_use]
1554    pub fn lcdif_sram_ppd(&mut self) -> LCDIF_SRAM_PPD_W<21> {
1555        LCDIF_SRAM_PPD_W::new(self)
1556    }
1557    #[doc = "Bit 25 - DSP"]
1558    #[inline(always)]
1559    #[must_use]
1560    pub fn dsp_pd(&mut self) -> DSP_PD_W<25> {
1561        DSP_PD_W::new(self)
1562    }
1563    #[doc = "Bit 26 - MIPIDSI"]
1564    #[inline(always)]
1565    #[must_use]
1566    pub fn mipidsi_pd(&mut self) -> MIPIDSI_PD_W<26> {
1567        MIPIDSI_PD_W::new(self)
1568    }
1569    #[doc = "Bit 27 - OTP"]
1570    #[inline(always)]
1571    #[must_use]
1572    pub fn otp_pd(&mut self) -> OTP_PD_W<27> {
1573        OTP_PD_W::new(self)
1574    }
1575    #[doc = "Bit 28 - ROM"]
1576    #[inline(always)]
1577    #[must_use]
1578    pub fn rom_pd(&mut self) -> ROM_PD_W<28> {
1579        ROM_PD_W::new(self)
1580    }
1581    #[doc = "Bit 31 - SRAM sleep mode"]
1582    #[inline(always)]
1583    #[must_use]
1584    pub fn sram_sleep(&mut self) -> SRAM_SLEEP_W<31> {
1585        SRAM_SLEEP_W::new(self)
1586    }
1587    #[doc = "Writes raw bits to the register."]
1588    #[inline(always)]
1589    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1590        self.0.bits(bits);
1591        self
1592    }
1593}
1594#[doc = "Sleep configuration 1\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 [pdsleepcfg1](index.html) module"]
1595pub struct PDSLEEPCFG1_SPEC;
1596impl crate::RegisterSpec for PDSLEEPCFG1_SPEC {
1597    type Ux = u32;
1598}
1599#[doc = "`read()` method returns [pdsleepcfg1::R](R) reader structure"]
1600impl crate::Readable for PDSLEEPCFG1_SPEC {
1601    type Reader = R;
1602}
1603#[doc = "`write(|w| ..)` method takes [pdsleepcfg1::W](W) writer structure"]
1604impl crate::Writable for PDSLEEPCFG1_SPEC {
1605    type Writer = W;
1606    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1607    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1608}
1609#[doc = "`reset()` method sets PDSLEEPCFG1 to value 0x067f_ffff"]
1610impl crate::Resettable for PDSLEEPCFG1_SPEC {
1611    const RESET_VALUE: Self::Ux = 0x067f_ffff;
1612}
mimxrt595s/sysctl0/pdsleepcfg1.rs

mimxrt595s/sysctl0/
pdsleepcfg1.rs
