mcxa_pac/scn_scb/
cppwr.rs

1#[doc = "Register `CPPWR` reader"]
2pub type R = crate::R<CppwrSpec>;
3#[doc = "Register `CPPWR` writer"]
4pub type W = crate::W<CppwrSpec>;
5#[doc = "State UNKNOWN 0.\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Su0 {
9    #[doc = "0: The coprocessor state is not permitted to become UNKNOWN."]
10    UnknownNotPermitted = 0,
11    #[doc = "1: The coprocessor state is permitted to become UNKNOWN."]
12    UnknownPermitted = 1,
13}
14impl From<Su0> for bool {
15    #[inline(always)]
16    fn from(variant: Su0) -> Self {
17        variant as u8 != 0
18    }
19}
20#[doc = "Field `SU0` reader - State UNKNOWN 0."]
21pub type Su0R = crate::BitReader<Su0>;
22impl Su0R {
23    #[doc = "Get enumerated values variant"]
24    #[inline(always)]
25    pub const fn variant(&self) -> Su0 {
26        match self.bits {
27            false => Su0::UnknownNotPermitted,
28            true => Su0::UnknownPermitted,
29        }
30    }
31    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
32    #[inline(always)]
33    pub fn is_unknown_not_permitted(&self) -> bool {
34        *self == Su0::UnknownNotPermitted
35    }
36    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
37    #[inline(always)]
38    pub fn is_unknown_permitted(&self) -> bool {
39        *self == Su0::UnknownPermitted
40    }
41}
42#[doc = "Field `SU0` writer - State UNKNOWN 0."]
43pub type Su0W<'a, REG> = crate::BitWriter<'a, REG, Su0>;
44impl<'a, REG> Su0W<'a, REG>
45where
46    REG: crate::Writable + crate::RegisterSpec,
47{
48    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
49    #[inline(always)]
50    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
51        self.variant(Su0::UnknownNotPermitted)
52    }
53    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
54    #[inline(always)]
55    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
56        self.variant(Su0::UnknownPermitted)
57    }
58}
59#[doc = "State UNKNOWN Secure only 0.\n\nValue on reset: 0"]
60#[cfg_attr(feature = "defmt", derive(defmt::Format))]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum Sus0 {
63    #[doc = "0: The SU0 field is accessible from both Security states."]
64    SecureAndNonSecure = 0,
65    #[doc = "1: The SU0 field is only accessible from the Secure state."]
66    SecureOnly = 1,
67}
68impl From<Sus0> for bool {
69    #[inline(always)]
70    fn from(variant: Sus0) -> Self {
71        variant as u8 != 0
72    }
73}
74#[doc = "Field `SUS0` reader - State UNKNOWN Secure only 0."]
75pub type Sus0R = crate::BitReader<Sus0>;
76impl Sus0R {
77    #[doc = "Get enumerated values variant"]
78    #[inline(always)]
79    pub const fn variant(&self) -> Sus0 {
80        match self.bits {
81            false => Sus0::SecureAndNonSecure,
82            true => Sus0::SecureOnly,
83        }
84    }
85    #[doc = "The SU0 field is accessible from both Security states."]
86    #[inline(always)]
87    pub fn is_secure_and_non_secure(&self) -> bool {
88        *self == Sus0::SecureAndNonSecure
89    }
90    #[doc = "The SU0 field is only accessible from the Secure state."]
91    #[inline(always)]
92    pub fn is_secure_only(&self) -> bool {
93        *self == Sus0::SecureOnly
94    }
95}
96#[doc = "Field `SUS0` writer - State UNKNOWN Secure only 0."]
97pub type Sus0W<'a, REG> = crate::BitWriter<'a, REG, Sus0>;
98impl<'a, REG> Sus0W<'a, REG>
99where
100    REG: crate::Writable + crate::RegisterSpec,
101{
102    #[doc = "The SU0 field is accessible from both Security states."]
103    #[inline(always)]
104    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
105        self.variant(Sus0::SecureAndNonSecure)
106    }
107    #[doc = "The SU0 field is only accessible from the Secure state."]
108    #[inline(always)]
109    pub fn secure_only(self) -> &'a mut crate::W<REG> {
110        self.variant(Sus0::SecureOnly)
111    }
112}
113#[doc = "State UNKNOWN 1.\n\nValue on reset: 0"]
114#[cfg_attr(feature = "defmt", derive(defmt::Format))]
115#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum Su1 {
117    #[doc = "0: The coprocessor state is not permitted to become UNKNOWN."]
118    UnknownNotPermitted = 0,
119    #[doc = "1: The coprocessor state is permitted to become UNKNOWN."]
120    UnknownPermitted = 1,
121}
122impl From<Su1> for bool {
123    #[inline(always)]
124    fn from(variant: Su1) -> Self {
125        variant as u8 != 0
126    }
127}
128#[doc = "Field `SU1` reader - State UNKNOWN 1."]
129pub type Su1R = crate::BitReader<Su1>;
130impl Su1R {
131    #[doc = "Get enumerated values variant"]
132    #[inline(always)]
133    pub const fn variant(&self) -> Su1 {
134        match self.bits {
135            false => Su1::UnknownNotPermitted,
136            true => Su1::UnknownPermitted,
137        }
138    }
139    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
140    #[inline(always)]
141    pub fn is_unknown_not_permitted(&self) -> bool {
142        *self == Su1::UnknownNotPermitted
143    }
144    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
145    #[inline(always)]
146    pub fn is_unknown_permitted(&self) -> bool {
147        *self == Su1::UnknownPermitted
148    }
149}
150#[doc = "Field `SU1` writer - State UNKNOWN 1."]
151pub type Su1W<'a, REG> = crate::BitWriter<'a, REG, Su1>;
152impl<'a, REG> Su1W<'a, REG>
153where
154    REG: crate::Writable + crate::RegisterSpec,
155{
156    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
157    #[inline(always)]
158    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
159        self.variant(Su1::UnknownNotPermitted)
160    }
161    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
162    #[inline(always)]
163    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
164        self.variant(Su1::UnknownPermitted)
165    }
166}
167#[doc = "State UNKNOWN Secure only 1.\n\nValue on reset: 0"]
168#[cfg_attr(feature = "defmt", derive(defmt::Format))]
169#[derive(Clone, Copy, Debug, PartialEq, Eq)]
170pub enum Sus1 {
171    #[doc = "0: The SU7 field is accessible from both Security states."]
172    SecureAndNonSecure = 0,
173    #[doc = "1: The SU7 field is only accessible from the Secure state."]
174    SecureOnly = 1,
175}
176impl From<Sus1> for bool {
177    #[inline(always)]
178    fn from(variant: Sus1) -> Self {
179        variant as u8 != 0
180    }
181}
182#[doc = "Field `SUS1` reader - State UNKNOWN Secure only 1."]
183pub type Sus1R = crate::BitReader<Sus1>;
184impl Sus1R {
185    #[doc = "Get enumerated values variant"]
186    #[inline(always)]
187    pub const fn variant(&self) -> Sus1 {
188        match self.bits {
189            false => Sus1::SecureAndNonSecure,
190            true => Sus1::SecureOnly,
191        }
192    }
193    #[doc = "The SU7 field is accessible from both Security states."]
194    #[inline(always)]
195    pub fn is_secure_and_non_secure(&self) -> bool {
196        *self == Sus1::SecureAndNonSecure
197    }
198    #[doc = "The SU7 field is only accessible from the Secure state."]
199    #[inline(always)]
200    pub fn is_secure_only(&self) -> bool {
201        *self == Sus1::SecureOnly
202    }
203}
204#[doc = "Field `SUS1` writer - State UNKNOWN Secure only 1."]
205pub type Sus1W<'a, REG> = crate::BitWriter<'a, REG, Sus1>;
206impl<'a, REG> Sus1W<'a, REG>
207where
208    REG: crate::Writable + crate::RegisterSpec,
209{
210    #[doc = "The SU7 field is accessible from both Security states."]
211    #[inline(always)]
212    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
213        self.variant(Sus1::SecureAndNonSecure)
214    }
215    #[doc = "The SU7 field is only accessible from the Secure state."]
216    #[inline(always)]
217    pub fn secure_only(self) -> &'a mut crate::W<REG> {
218        self.variant(Sus1::SecureOnly)
219    }
220}
221#[doc = "State UNKNOWN 2.\n\nValue on reset: 0"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum Su2 {
225    #[doc = "0: The coprocessor state is not permitted to become UNKNOWN."]
226    UnknownNotPermitted = 0,
227    #[doc = "1: The coprocessor state is permitted to become UNKNOWN."]
228    UnknownPermitted = 1,
229}
230impl From<Su2> for bool {
231    #[inline(always)]
232    fn from(variant: Su2) -> Self {
233        variant as u8 != 0
234    }
235}
236#[doc = "Field `SU2` reader - State UNKNOWN 2."]
237pub type Su2R = crate::BitReader<Su2>;
238impl Su2R {
239    #[doc = "Get enumerated values variant"]
240    #[inline(always)]
241    pub const fn variant(&self) -> Su2 {
242        match self.bits {
243            false => Su2::UnknownNotPermitted,
244            true => Su2::UnknownPermitted,
245        }
246    }
247    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
248    #[inline(always)]
249    pub fn is_unknown_not_permitted(&self) -> bool {
250        *self == Su2::UnknownNotPermitted
251    }
252    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
253    #[inline(always)]
254    pub fn is_unknown_permitted(&self) -> bool {
255        *self == Su2::UnknownPermitted
256    }
257}
258#[doc = "Field `SU2` writer - State UNKNOWN 2."]
259pub type Su2W<'a, REG> = crate::BitWriter<'a, REG, Su2>;
260impl<'a, REG> Su2W<'a, REG>
261where
262    REG: crate::Writable + crate::RegisterSpec,
263{
264    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
265    #[inline(always)]
266    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
267        self.variant(Su2::UnknownNotPermitted)
268    }
269    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
270    #[inline(always)]
271    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
272        self.variant(Su2::UnknownPermitted)
273    }
274}
275#[doc = "State UNKNOWN Secure only 2.\n\nValue on reset: 0"]
276#[cfg_attr(feature = "defmt", derive(defmt::Format))]
277#[derive(Clone, Copy, Debug, PartialEq, Eq)]
278pub enum Sus2 {
279    #[doc = "0: The SU2 field is accessible from both Security states."]
280    SecureAndNonSecure = 0,
281    #[doc = "1: The SU2 field is only accessible from the Secure state."]
282    SecureOnly = 1,
283}
284impl From<Sus2> for bool {
285    #[inline(always)]
286    fn from(variant: Sus2) -> Self {
287        variant as u8 != 0
288    }
289}
290#[doc = "Field `SUS2` reader - State UNKNOWN Secure only 2."]
291pub type Sus2R = crate::BitReader<Sus2>;
292impl Sus2R {
293    #[doc = "Get enumerated values variant"]
294    #[inline(always)]
295    pub const fn variant(&self) -> Sus2 {
296        match self.bits {
297            false => Sus2::SecureAndNonSecure,
298            true => Sus2::SecureOnly,
299        }
300    }
301    #[doc = "The SU2 field is accessible from both Security states."]
302    #[inline(always)]
303    pub fn is_secure_and_non_secure(&self) -> bool {
304        *self == Sus2::SecureAndNonSecure
305    }
306    #[doc = "The SU2 field is only accessible from the Secure state."]
307    #[inline(always)]
308    pub fn is_secure_only(&self) -> bool {
309        *self == Sus2::SecureOnly
310    }
311}
312#[doc = "Field `SUS2` writer - State UNKNOWN Secure only 2."]
313pub type Sus2W<'a, REG> = crate::BitWriter<'a, REG, Sus2>;
314impl<'a, REG> Sus2W<'a, REG>
315where
316    REG: crate::Writable + crate::RegisterSpec,
317{
318    #[doc = "The SU2 field is accessible from both Security states."]
319    #[inline(always)]
320    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
321        self.variant(Sus2::SecureAndNonSecure)
322    }
323    #[doc = "The SU2 field is only accessible from the Secure state."]
324    #[inline(always)]
325    pub fn secure_only(self) -> &'a mut crate::W<REG> {
326        self.variant(Sus2::SecureOnly)
327    }
328}
329#[doc = "State UNKNOWN 3.\n\nValue on reset: 0"]
330#[cfg_attr(feature = "defmt", derive(defmt::Format))]
331#[derive(Clone, Copy, Debug, PartialEq, Eq)]
332pub enum Su3 {
333    #[doc = "0: The coprocessor state is not permitted to become UNKNOWN."]
334    UnknownNotPermitted = 0,
335    #[doc = "1: The coprocessor state is permitted to become UNKNOWN."]
336    UnknownPermitted = 1,
337}
338impl From<Su3> for bool {
339    #[inline(always)]
340    fn from(variant: Su3) -> Self {
341        variant as u8 != 0
342    }
343}
344#[doc = "Field `SU3` reader - State UNKNOWN 3."]
345pub type Su3R = crate::BitReader<Su3>;
346impl Su3R {
347    #[doc = "Get enumerated values variant"]
348    #[inline(always)]
349    pub const fn variant(&self) -> Su3 {
350        match self.bits {
351            false => Su3::UnknownNotPermitted,
352            true => Su3::UnknownPermitted,
353        }
354    }
355    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
356    #[inline(always)]
357    pub fn is_unknown_not_permitted(&self) -> bool {
358        *self == Su3::UnknownNotPermitted
359    }
360    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
361    #[inline(always)]
362    pub fn is_unknown_permitted(&self) -> bool {
363        *self == Su3::UnknownPermitted
364    }
365}
366#[doc = "Field `SU3` writer - State UNKNOWN 3."]
367pub type Su3W<'a, REG> = crate::BitWriter<'a, REG, Su3>;
368impl<'a, REG> Su3W<'a, REG>
369where
370    REG: crate::Writable + crate::RegisterSpec,
371{
372    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
373    #[inline(always)]
374    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
375        self.variant(Su3::UnknownNotPermitted)
376    }
377    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
378    #[inline(always)]
379    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
380        self.variant(Su3::UnknownPermitted)
381    }
382}
383#[doc = "State UNKNOWN Secure only 3.\n\nValue on reset: 0"]
384#[cfg_attr(feature = "defmt", derive(defmt::Format))]
385#[derive(Clone, Copy, Debug, PartialEq, Eq)]
386pub enum Sus3 {
387    #[doc = "0: The SU3 field is accessible from both Security states."]
388    SecureAndNonSecure = 0,
389    #[doc = "1: The SU3 field is only accessible from the Secure state."]
390    SecureOnly = 1,
391}
392impl From<Sus3> for bool {
393    #[inline(always)]
394    fn from(variant: Sus3) -> Self {
395        variant as u8 != 0
396    }
397}
398#[doc = "Field `SUS3` reader - State UNKNOWN Secure only 3."]
399pub type Sus3R = crate::BitReader<Sus3>;
400impl Sus3R {
401    #[doc = "Get enumerated values variant"]
402    #[inline(always)]
403    pub const fn variant(&self) -> Sus3 {
404        match self.bits {
405            false => Sus3::SecureAndNonSecure,
406            true => Sus3::SecureOnly,
407        }
408    }
409    #[doc = "The SU3 field is accessible from both Security states."]
410    #[inline(always)]
411    pub fn is_secure_and_non_secure(&self) -> bool {
412        *self == Sus3::SecureAndNonSecure
413    }
414    #[doc = "The SU3 field is only accessible from the Secure state."]
415    #[inline(always)]
416    pub fn is_secure_only(&self) -> bool {
417        *self == Sus3::SecureOnly
418    }
419}
420#[doc = "Field `SUS3` writer - State UNKNOWN Secure only 3."]
421pub type Sus3W<'a, REG> = crate::BitWriter<'a, REG, Sus3>;
422impl<'a, REG> Sus3W<'a, REG>
423where
424    REG: crate::Writable + crate::RegisterSpec,
425{
426    #[doc = "The SU3 field is accessible from both Security states."]
427    #[inline(always)]
428    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
429        self.variant(Sus3::SecureAndNonSecure)
430    }
431    #[doc = "The SU3 field is only accessible from the Secure state."]
432    #[inline(always)]
433    pub fn secure_only(self) -> &'a mut crate::W<REG> {
434        self.variant(Sus3::SecureOnly)
435    }
436}
437#[doc = "State UNKNOWN 4.\n\nValue on reset: 0"]
438#[cfg_attr(feature = "defmt", derive(defmt::Format))]
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
440pub enum Su4 {
441    #[doc = "0: The coprocessor state is not permitted to become UNKNOWN."]
442    UnknownNotPermitted = 0,
443    #[doc = "1: The coprocessor state is permitted to become UNKNOWN."]
444    UnknownPermitted = 1,
445}
446impl From<Su4> for bool {
447    #[inline(always)]
448    fn from(variant: Su4) -> Self {
449        variant as u8 != 0
450    }
451}
452#[doc = "Field `SU4` reader - State UNKNOWN 4."]
453pub type Su4R = crate::BitReader<Su4>;
454impl Su4R {
455    #[doc = "Get enumerated values variant"]
456    #[inline(always)]
457    pub const fn variant(&self) -> Su4 {
458        match self.bits {
459            false => Su4::UnknownNotPermitted,
460            true => Su4::UnknownPermitted,
461        }
462    }
463    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
464    #[inline(always)]
465    pub fn is_unknown_not_permitted(&self) -> bool {
466        *self == Su4::UnknownNotPermitted
467    }
468    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
469    #[inline(always)]
470    pub fn is_unknown_permitted(&self) -> bool {
471        *self == Su4::UnknownPermitted
472    }
473}
474#[doc = "Field `SU4` writer - State UNKNOWN 4."]
475pub type Su4W<'a, REG> = crate::BitWriter<'a, REG, Su4>;
476impl<'a, REG> Su4W<'a, REG>
477where
478    REG: crate::Writable + crate::RegisterSpec,
479{
480    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
481    #[inline(always)]
482    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
483        self.variant(Su4::UnknownNotPermitted)
484    }
485    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
486    #[inline(always)]
487    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
488        self.variant(Su4::UnknownPermitted)
489    }
490}
491#[doc = "State UNKNOWN Secure only 4.\n\nValue on reset: 0"]
492#[cfg_attr(feature = "defmt", derive(defmt::Format))]
493#[derive(Clone, Copy, Debug, PartialEq, Eq)]
494pub enum Sus4 {
495    #[doc = "0: The SU4 field is accessible from both Security states."]
496    SecureAndNonSecure = 0,
497    #[doc = "1: The SU4 field is only accessible from the Secure state."]
498    SecureOnly = 1,
499}
500impl From<Sus4> for bool {
501    #[inline(always)]
502    fn from(variant: Sus4) -> Self {
503        variant as u8 != 0
504    }
505}
506#[doc = "Field `SUS4` reader - State UNKNOWN Secure only 4."]
507pub type Sus4R = crate::BitReader<Sus4>;
508impl Sus4R {
509    #[doc = "Get enumerated values variant"]
510    #[inline(always)]
511    pub const fn variant(&self) -> Sus4 {
512        match self.bits {
513            false => Sus4::SecureAndNonSecure,
514            true => Sus4::SecureOnly,
515        }
516    }
517    #[doc = "The SU4 field is accessible from both Security states."]
518    #[inline(always)]
519    pub fn is_secure_and_non_secure(&self) -> bool {
520        *self == Sus4::SecureAndNonSecure
521    }
522    #[doc = "The SU4 field is only accessible from the Secure state."]
523    #[inline(always)]
524    pub fn is_secure_only(&self) -> bool {
525        *self == Sus4::SecureOnly
526    }
527}
528#[doc = "Field `SUS4` writer - State UNKNOWN Secure only 4."]
529pub type Sus4W<'a, REG> = crate::BitWriter<'a, REG, Sus4>;
530impl<'a, REG> Sus4W<'a, REG>
531where
532    REG: crate::Writable + crate::RegisterSpec,
533{
534    #[doc = "The SU4 field is accessible from both Security states."]
535    #[inline(always)]
536    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
537        self.variant(Sus4::SecureAndNonSecure)
538    }
539    #[doc = "The SU4 field is only accessible from the Secure state."]
540    #[inline(always)]
541    pub fn secure_only(self) -> &'a mut crate::W<REG> {
542        self.variant(Sus4::SecureOnly)
543    }
544}
545#[doc = "State UNKNOWN 5.\n\nValue on reset: 0"]
546#[cfg_attr(feature = "defmt", derive(defmt::Format))]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548pub enum Su5 {
549    #[doc = "0: The coprocessor state is not permitted to become UNKNOWN."]
550    UnknownNotPermitted = 0,
551    #[doc = "1: The coprocessor state is permitted to become UNKNOWN."]
552    UnknownPermitted = 1,
553}
554impl From<Su5> for bool {
555    #[inline(always)]
556    fn from(variant: Su5) -> Self {
557        variant as u8 != 0
558    }
559}
560#[doc = "Field `SU5` reader - State UNKNOWN 5."]
561pub type Su5R = crate::BitReader<Su5>;
562impl Su5R {
563    #[doc = "Get enumerated values variant"]
564    #[inline(always)]
565    pub const fn variant(&self) -> Su5 {
566        match self.bits {
567            false => Su5::UnknownNotPermitted,
568            true => Su5::UnknownPermitted,
569        }
570    }
571    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
572    #[inline(always)]
573    pub fn is_unknown_not_permitted(&self) -> bool {
574        *self == Su5::UnknownNotPermitted
575    }
576    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
577    #[inline(always)]
578    pub fn is_unknown_permitted(&self) -> bool {
579        *self == Su5::UnknownPermitted
580    }
581}
582#[doc = "Field `SU5` writer - State UNKNOWN 5."]
583pub type Su5W<'a, REG> = crate::BitWriter<'a, REG, Su5>;
584impl<'a, REG> Su5W<'a, REG>
585where
586    REG: crate::Writable + crate::RegisterSpec,
587{
588    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
589    #[inline(always)]
590    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
591        self.variant(Su5::UnknownNotPermitted)
592    }
593    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
594    #[inline(always)]
595    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
596        self.variant(Su5::UnknownPermitted)
597    }
598}
599#[doc = "State UNKNOWN Secure only 5.\n\nValue on reset: 0"]
600#[cfg_attr(feature = "defmt", derive(defmt::Format))]
601#[derive(Clone, Copy, Debug, PartialEq, Eq)]
602pub enum Sus5 {
603    #[doc = "0: The SU5 field is accessible from both Security states."]
604    SecureAndNonSecure = 0,
605    #[doc = "1: The SU5 field is only accessible from the Secure state."]
606    SecureOnly = 1,
607}
608impl From<Sus5> for bool {
609    #[inline(always)]
610    fn from(variant: Sus5) -> Self {
611        variant as u8 != 0
612    }
613}
614#[doc = "Field `SUS5` reader - State UNKNOWN Secure only 5."]
615pub type Sus5R = crate::BitReader<Sus5>;
616impl Sus5R {
617    #[doc = "Get enumerated values variant"]
618    #[inline(always)]
619    pub const fn variant(&self) -> Sus5 {
620        match self.bits {
621            false => Sus5::SecureAndNonSecure,
622            true => Sus5::SecureOnly,
623        }
624    }
625    #[doc = "The SU5 field is accessible from both Security states."]
626    #[inline(always)]
627    pub fn is_secure_and_non_secure(&self) -> bool {
628        *self == Sus5::SecureAndNonSecure
629    }
630    #[doc = "The SU5 field is only accessible from the Secure state."]
631    #[inline(always)]
632    pub fn is_secure_only(&self) -> bool {
633        *self == Sus5::SecureOnly
634    }
635}
636#[doc = "Field `SUS5` writer - State UNKNOWN Secure only 5."]
637pub type Sus5W<'a, REG> = crate::BitWriter<'a, REG, Sus5>;
638impl<'a, REG> Sus5W<'a, REG>
639where
640    REG: crate::Writable + crate::RegisterSpec,
641{
642    #[doc = "The SU5 field is accessible from both Security states."]
643    #[inline(always)]
644    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
645        self.variant(Sus5::SecureAndNonSecure)
646    }
647    #[doc = "The SU5 field is only accessible from the Secure state."]
648    #[inline(always)]
649    pub fn secure_only(self) -> &'a mut crate::W<REG> {
650        self.variant(Sus5::SecureOnly)
651    }
652}
653#[doc = "State UNKNOWN 6.\n\nValue on reset: 0"]
654#[cfg_attr(feature = "defmt", derive(defmt::Format))]
655#[derive(Clone, Copy, Debug, PartialEq, Eq)]
656pub enum Su6 {
657    #[doc = "0: The coprocessor state is not permitted to become UNKNOWN."]
658    UnknownNotPermitted = 0,
659    #[doc = "1: The coprocessor state is permitted to become UNKNOWN."]
660    UnknownPermitted = 1,
661}
662impl From<Su6> for bool {
663    #[inline(always)]
664    fn from(variant: Su6) -> Self {
665        variant as u8 != 0
666    }
667}
668#[doc = "Field `SU6` reader - State UNKNOWN 6."]
669pub type Su6R = crate::BitReader<Su6>;
670impl Su6R {
671    #[doc = "Get enumerated values variant"]
672    #[inline(always)]
673    pub const fn variant(&self) -> Su6 {
674        match self.bits {
675            false => Su6::UnknownNotPermitted,
676            true => Su6::UnknownPermitted,
677        }
678    }
679    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
680    #[inline(always)]
681    pub fn is_unknown_not_permitted(&self) -> bool {
682        *self == Su6::UnknownNotPermitted
683    }
684    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
685    #[inline(always)]
686    pub fn is_unknown_permitted(&self) -> bool {
687        *self == Su6::UnknownPermitted
688    }
689}
690#[doc = "Field `SU6` writer - State UNKNOWN 6."]
691pub type Su6W<'a, REG> = crate::BitWriter<'a, REG, Su6>;
692impl<'a, REG> Su6W<'a, REG>
693where
694    REG: crate::Writable + crate::RegisterSpec,
695{
696    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
697    #[inline(always)]
698    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
699        self.variant(Su6::UnknownNotPermitted)
700    }
701    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
702    #[inline(always)]
703    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
704        self.variant(Su6::UnknownPermitted)
705    }
706}
707#[doc = "State UNKNOWN Secure only 6.\n\nValue on reset: 0"]
708#[cfg_attr(feature = "defmt", derive(defmt::Format))]
709#[derive(Clone, Copy, Debug, PartialEq, Eq)]
710pub enum Sus6 {
711    #[doc = "0: The SU6 field is accessible from both Security states."]
712    SecureAndNonSecure = 0,
713    #[doc = "1: The SU6 field is only accessible from the Secure state."]
714    SecureOnly = 1,
715}
716impl From<Sus6> for bool {
717    #[inline(always)]
718    fn from(variant: Sus6) -> Self {
719        variant as u8 != 0
720    }
721}
722#[doc = "Field `SUS6` reader - State UNKNOWN Secure only 6."]
723pub type Sus6R = crate::BitReader<Sus6>;
724impl Sus6R {
725    #[doc = "Get enumerated values variant"]
726    #[inline(always)]
727    pub const fn variant(&self) -> Sus6 {
728        match self.bits {
729            false => Sus6::SecureAndNonSecure,
730            true => Sus6::SecureOnly,
731        }
732    }
733    #[doc = "The SU6 field is accessible from both Security states."]
734    #[inline(always)]
735    pub fn is_secure_and_non_secure(&self) -> bool {
736        *self == Sus6::SecureAndNonSecure
737    }
738    #[doc = "The SU6 field is only accessible from the Secure state."]
739    #[inline(always)]
740    pub fn is_secure_only(&self) -> bool {
741        *self == Sus6::SecureOnly
742    }
743}
744#[doc = "Field `SUS6` writer - State UNKNOWN Secure only 6."]
745pub type Sus6W<'a, REG> = crate::BitWriter<'a, REG, Sus6>;
746impl<'a, REG> Sus6W<'a, REG>
747where
748    REG: crate::Writable + crate::RegisterSpec,
749{
750    #[doc = "The SU6 field is accessible from both Security states."]
751    #[inline(always)]
752    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
753        self.variant(Sus6::SecureAndNonSecure)
754    }
755    #[doc = "The SU6 field is only accessible from the Secure state."]
756    #[inline(always)]
757    pub fn secure_only(self) -> &'a mut crate::W<REG> {
758        self.variant(Sus6::SecureOnly)
759    }
760}
761#[doc = "State UNKNOWN 7.\n\nValue on reset: 0"]
762#[cfg_attr(feature = "defmt", derive(defmt::Format))]
763#[derive(Clone, Copy, Debug, PartialEq, Eq)]
764pub enum Su7 {
765    #[doc = "0: The coprocessor state is not permitted to become UNKNOWN."]
766    UnknownNotPermitted = 0,
767    #[doc = "1: The coprocessor state is permitted to become UNKNOWN."]
768    UnknownPermitted = 1,
769}
770impl From<Su7> for bool {
771    #[inline(always)]
772    fn from(variant: Su7) -> Self {
773        variant as u8 != 0
774    }
775}
776#[doc = "Field `SU7` reader - State UNKNOWN 7."]
777pub type Su7R = crate::BitReader<Su7>;
778impl Su7R {
779    #[doc = "Get enumerated values variant"]
780    #[inline(always)]
781    pub const fn variant(&self) -> Su7 {
782        match self.bits {
783            false => Su7::UnknownNotPermitted,
784            true => Su7::UnknownPermitted,
785        }
786    }
787    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
788    #[inline(always)]
789    pub fn is_unknown_not_permitted(&self) -> bool {
790        *self == Su7::UnknownNotPermitted
791    }
792    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
793    #[inline(always)]
794    pub fn is_unknown_permitted(&self) -> bool {
795        *self == Su7::UnknownPermitted
796    }
797}
798#[doc = "Field `SU7` writer - State UNKNOWN 7."]
799pub type Su7W<'a, REG> = crate::BitWriter<'a, REG, Su7>;
800impl<'a, REG> Su7W<'a, REG>
801where
802    REG: crate::Writable + crate::RegisterSpec,
803{
804    #[doc = "The coprocessor state is not permitted to become UNKNOWN."]
805    #[inline(always)]
806    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
807        self.variant(Su7::UnknownNotPermitted)
808    }
809    #[doc = "The coprocessor state is permitted to become UNKNOWN."]
810    #[inline(always)]
811    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
812        self.variant(Su7::UnknownPermitted)
813    }
814}
815#[doc = "State UNKNOWN Secure only 7.\n\nValue on reset: 0"]
816#[cfg_attr(feature = "defmt", derive(defmt::Format))]
817#[derive(Clone, Copy, Debug, PartialEq, Eq)]
818pub enum Sus7 {
819    #[doc = "0: The SU7 field is accessible from both Security states."]
820    SecureAndNonSecure = 0,
821    #[doc = "1: The SU7 field is only accessible from the Secure state."]
822    SecureOnly = 1,
823}
824impl From<Sus7> for bool {
825    #[inline(always)]
826    fn from(variant: Sus7) -> Self {
827        variant as u8 != 0
828    }
829}
830#[doc = "Field `SUS7` reader - State UNKNOWN Secure only 7."]
831pub type Sus7R = crate::BitReader<Sus7>;
832impl Sus7R {
833    #[doc = "Get enumerated values variant"]
834    #[inline(always)]
835    pub const fn variant(&self) -> Sus7 {
836        match self.bits {
837            false => Sus7::SecureAndNonSecure,
838            true => Sus7::SecureOnly,
839        }
840    }
841    #[doc = "The SU7 field is accessible from both Security states."]
842    #[inline(always)]
843    pub fn is_secure_and_non_secure(&self) -> bool {
844        *self == Sus7::SecureAndNonSecure
845    }
846    #[doc = "The SU7 field is only accessible from the Secure state."]
847    #[inline(always)]
848    pub fn is_secure_only(&self) -> bool {
849        *self == Sus7::SecureOnly
850    }
851}
852#[doc = "Field `SUS7` writer - State UNKNOWN Secure only 7."]
853pub type Sus7W<'a, REG> = crate::BitWriter<'a, REG, Sus7>;
854impl<'a, REG> Sus7W<'a, REG>
855where
856    REG: crate::Writable + crate::RegisterSpec,
857{
858    #[doc = "The SU7 field is accessible from both Security states."]
859    #[inline(always)]
860    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
861        self.variant(Sus7::SecureAndNonSecure)
862    }
863    #[doc = "The SU7 field is only accessible from the Secure state."]
864    #[inline(always)]
865    pub fn secure_only(self) -> &'a mut crate::W<REG> {
866        self.variant(Sus7::SecureOnly)
867    }
868}
869#[doc = "State UNKNOWN 10.\n\nValue on reset: 0"]
870#[cfg_attr(feature = "defmt", derive(defmt::Format))]
871#[derive(Clone, Copy, Debug, PartialEq, Eq)]
872pub enum Su10 {
873    #[doc = "0: The floating-point state is not permitted to become UNKNOWN."]
874    UnknownNotPermitted = 0,
875    #[doc = "1: The floating-point state is permitted to become UNKNOWN"]
876    UnknownPermitted = 1,
877}
878impl From<Su10> for bool {
879    #[inline(always)]
880    fn from(variant: Su10) -> Self {
881        variant as u8 != 0
882    }
883}
884#[doc = "Field `SU10` reader - State UNKNOWN 10."]
885pub type Su10R = crate::BitReader<Su10>;
886impl Su10R {
887    #[doc = "Get enumerated values variant"]
888    #[inline(always)]
889    pub const fn variant(&self) -> Su10 {
890        match self.bits {
891            false => Su10::UnknownNotPermitted,
892            true => Su10::UnknownPermitted,
893        }
894    }
895    #[doc = "The floating-point state is not permitted to become UNKNOWN."]
896    #[inline(always)]
897    pub fn is_unknown_not_permitted(&self) -> bool {
898        *self == Su10::UnknownNotPermitted
899    }
900    #[doc = "The floating-point state is permitted to become UNKNOWN"]
901    #[inline(always)]
902    pub fn is_unknown_permitted(&self) -> bool {
903        *self == Su10::UnknownPermitted
904    }
905}
906#[doc = "Field `SU10` writer - State UNKNOWN 10."]
907pub type Su10W<'a, REG> = crate::BitWriter<'a, REG, Su10>;
908impl<'a, REG> Su10W<'a, REG>
909where
910    REG: crate::Writable + crate::RegisterSpec,
911{
912    #[doc = "The floating-point state is not permitted to become UNKNOWN."]
913    #[inline(always)]
914    pub fn unknown_not_permitted(self) -> &'a mut crate::W<REG> {
915        self.variant(Su10::UnknownNotPermitted)
916    }
917    #[doc = "The floating-point state is permitted to become UNKNOWN"]
918    #[inline(always)]
919    pub fn unknown_permitted(self) -> &'a mut crate::W<REG> {
920        self.variant(Su10::UnknownPermitted)
921    }
922}
923#[doc = "State UNKNOWN Secure only 10.\n\nValue on reset: 0"]
924#[cfg_attr(feature = "defmt", derive(defmt::Format))]
925#[derive(Clone, Copy, Debug, PartialEq, Eq)]
926pub enum Sus10 {
927    #[doc = "0: The SU10 field is accessible from both Security states."]
928    SecureAndNonSecure = 0,
929    #[doc = "1: The SU10 field is only accessible from the Secure state."]
930    SecureOnly = 1,
931}
932impl From<Sus10> for bool {
933    #[inline(always)]
934    fn from(variant: Sus10) -> Self {
935        variant as u8 != 0
936    }
937}
938#[doc = "Field `SUS10` reader - State UNKNOWN Secure only 10."]
939pub type Sus10R = crate::BitReader<Sus10>;
940impl Sus10R {
941    #[doc = "Get enumerated values variant"]
942    #[inline(always)]
943    pub const fn variant(&self) -> Sus10 {
944        match self.bits {
945            false => Sus10::SecureAndNonSecure,
946            true => Sus10::SecureOnly,
947        }
948    }
949    #[doc = "The SU10 field is accessible from both Security states."]
950    #[inline(always)]
951    pub fn is_secure_and_non_secure(&self) -> bool {
952        *self == Sus10::SecureAndNonSecure
953    }
954    #[doc = "The SU10 field is only accessible from the Secure state."]
955    #[inline(always)]
956    pub fn is_secure_only(&self) -> bool {
957        *self == Sus10::SecureOnly
958    }
959}
960#[doc = "Field `SUS10` writer - State UNKNOWN Secure only 10."]
961pub type Sus10W<'a, REG> = crate::BitWriter<'a, REG, Sus10>;
962impl<'a, REG> Sus10W<'a, REG>
963where
964    REG: crate::Writable + crate::RegisterSpec,
965{
966    #[doc = "The SU10 field is accessible from both Security states."]
967    #[inline(always)]
968    pub fn secure_and_non_secure(self) -> &'a mut crate::W<REG> {
969        self.variant(Sus10::SecureAndNonSecure)
970    }
971    #[doc = "The SU10 field is only accessible from the Secure state."]
972    #[inline(always)]
973    pub fn secure_only(self) -> &'a mut crate::W<REG> {
974        self.variant(Sus10::SecureOnly)
975    }
976}
977#[doc = "Field `SU11` reader - State UNKNOWN 11."]
978pub type Su11R = crate::BitReader;
979#[doc = "Field `SU11` writer - State UNKNOWN 11."]
980pub type Su11W<'a, REG> = crate::BitWriter<'a, REG>;
981#[doc = "Field `SUS11` reader - State UNKNOWN Secure only 11."]
982pub type Sus11R = crate::BitReader;
983#[doc = "Field `SUS11` writer - State UNKNOWN Secure only 11."]
984pub type Sus11W<'a, REG> = crate::BitWriter<'a, REG>;
985impl R {
986    #[doc = "Bit 0 - State UNKNOWN 0."]
987    #[inline(always)]
988    pub fn su0(&self) -> Su0R {
989        Su0R::new((self.bits & 1) != 0)
990    }
991    #[doc = "Bit 1 - State UNKNOWN Secure only 0."]
992    #[inline(always)]
993    pub fn sus0(&self) -> Sus0R {
994        Sus0R::new(((self.bits >> 1) & 1) != 0)
995    }
996    #[doc = "Bit 2 - State UNKNOWN 1."]
997    #[inline(always)]
998    pub fn su1(&self) -> Su1R {
999        Su1R::new(((self.bits >> 2) & 1) != 0)
1000    }
1001    #[doc = "Bit 3 - State UNKNOWN Secure only 1."]
1002    #[inline(always)]
1003    pub fn sus1(&self) -> Sus1R {
1004        Sus1R::new(((self.bits >> 3) & 1) != 0)
1005    }
1006    #[doc = "Bit 4 - State UNKNOWN 2."]
1007    #[inline(always)]
1008    pub fn su2(&self) -> Su2R {
1009        Su2R::new(((self.bits >> 4) & 1) != 0)
1010    }
1011    #[doc = "Bit 5 - State UNKNOWN Secure only 2."]
1012    #[inline(always)]
1013    pub fn sus2(&self) -> Sus2R {
1014        Sus2R::new(((self.bits >> 5) & 1) != 0)
1015    }
1016    #[doc = "Bit 6 - State UNKNOWN 3."]
1017    #[inline(always)]
1018    pub fn su3(&self) -> Su3R {
1019        Su3R::new(((self.bits >> 6) & 1) != 0)
1020    }
1021    #[doc = "Bit 7 - State UNKNOWN Secure only 3."]
1022    #[inline(always)]
1023    pub fn sus3(&self) -> Sus3R {
1024        Sus3R::new(((self.bits >> 7) & 1) != 0)
1025    }
1026    #[doc = "Bit 8 - State UNKNOWN 4."]
1027    #[inline(always)]
1028    pub fn su4(&self) -> Su4R {
1029        Su4R::new(((self.bits >> 8) & 1) != 0)
1030    }
1031    #[doc = "Bit 9 - State UNKNOWN Secure only 4."]
1032    #[inline(always)]
1033    pub fn sus4(&self) -> Sus4R {
1034        Sus4R::new(((self.bits >> 9) & 1) != 0)
1035    }
1036    #[doc = "Bit 10 - State UNKNOWN 5."]
1037    #[inline(always)]
1038    pub fn su5(&self) -> Su5R {
1039        Su5R::new(((self.bits >> 10) & 1) != 0)
1040    }
1041    #[doc = "Bit 11 - State UNKNOWN Secure only 5."]
1042    #[inline(always)]
1043    pub fn sus5(&self) -> Sus5R {
1044        Sus5R::new(((self.bits >> 11) & 1) != 0)
1045    }
1046    #[doc = "Bit 12 - State UNKNOWN 6."]
1047    #[inline(always)]
1048    pub fn su6(&self) -> Su6R {
1049        Su6R::new(((self.bits >> 12) & 1) != 0)
1050    }
1051    #[doc = "Bit 13 - State UNKNOWN Secure only 6."]
1052    #[inline(always)]
1053    pub fn sus6(&self) -> Sus6R {
1054        Sus6R::new(((self.bits >> 13) & 1) != 0)
1055    }
1056    #[doc = "Bit 14 - State UNKNOWN 7."]
1057    #[inline(always)]
1058    pub fn su7(&self) -> Su7R {
1059        Su7R::new(((self.bits >> 14) & 1) != 0)
1060    }
1061    #[doc = "Bit 15 - State UNKNOWN Secure only 7."]
1062    #[inline(always)]
1063    pub fn sus7(&self) -> Sus7R {
1064        Sus7R::new(((self.bits >> 15) & 1) != 0)
1065    }
1066    #[doc = "Bit 20 - State UNKNOWN 10."]
1067    #[inline(always)]
1068    pub fn su10(&self) -> Su10R {
1069        Su10R::new(((self.bits >> 20) & 1) != 0)
1070    }
1071    #[doc = "Bit 21 - State UNKNOWN Secure only 10."]
1072    #[inline(always)]
1073    pub fn sus10(&self) -> Sus10R {
1074        Sus10R::new(((self.bits >> 21) & 1) != 0)
1075    }
1076    #[doc = "Bit 22 - State UNKNOWN 11."]
1077    #[inline(always)]
1078    pub fn su11(&self) -> Su11R {
1079        Su11R::new(((self.bits >> 22) & 1) != 0)
1080    }
1081    #[doc = "Bit 23 - State UNKNOWN Secure only 11."]
1082    #[inline(always)]
1083    pub fn sus11(&self) -> Sus11R {
1084        Sus11R::new(((self.bits >> 23) & 1) != 0)
1085    }
1086}
1087#[cfg(feature = "debug")]
1088impl core::fmt::Debug for R {
1089    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1090        f.debug_struct("CPPWR")
1091            .field("su0", &self.su0())
1092            .field("sus0", &self.sus0())
1093            .field("su1", &self.su1())
1094            .field("sus1", &self.sus1())
1095            .field("su2", &self.su2())
1096            .field("sus2", &self.sus2())
1097            .field("su3", &self.su3())
1098            .field("sus3", &self.sus3())
1099            .field("su4", &self.su4())
1100            .field("sus4", &self.sus4())
1101            .field("su5", &self.su5())
1102            .field("sus5", &self.sus5())
1103            .field("su6", &self.su6())
1104            .field("sus6", &self.sus6())
1105            .field("su7", &self.su7())
1106            .field("sus7", &self.sus7())
1107            .field("su10", &self.su10())
1108            .field("sus10", &self.sus10())
1109            .field("su11", &self.su11())
1110            .field("sus11", &self.sus11())
1111            .finish()
1112    }
1113}
1114impl W {
1115    #[doc = "Bit 0 - State UNKNOWN 0."]
1116    #[inline(always)]
1117    pub fn su0(&mut self) -> Su0W<'_, CppwrSpec> {
1118        Su0W::new(self, 0)
1119    }
1120    #[doc = "Bit 1 - State UNKNOWN Secure only 0."]
1121    #[inline(always)]
1122    pub fn sus0(&mut self) -> Sus0W<'_, CppwrSpec> {
1123        Sus0W::new(self, 1)
1124    }
1125    #[doc = "Bit 2 - State UNKNOWN 1."]
1126    #[inline(always)]
1127    pub fn su1(&mut self) -> Su1W<'_, CppwrSpec> {
1128        Su1W::new(self, 2)
1129    }
1130    #[doc = "Bit 3 - State UNKNOWN Secure only 1."]
1131    #[inline(always)]
1132    pub fn sus1(&mut self) -> Sus1W<'_, CppwrSpec> {
1133        Sus1W::new(self, 3)
1134    }
1135    #[doc = "Bit 4 - State UNKNOWN 2."]
1136    #[inline(always)]
1137    pub fn su2(&mut self) -> Su2W<'_, CppwrSpec> {
1138        Su2W::new(self, 4)
1139    }
1140    #[doc = "Bit 5 - State UNKNOWN Secure only 2."]
1141    #[inline(always)]
1142    pub fn sus2(&mut self) -> Sus2W<'_, CppwrSpec> {
1143        Sus2W::new(self, 5)
1144    }
1145    #[doc = "Bit 6 - State UNKNOWN 3."]
1146    #[inline(always)]
1147    pub fn su3(&mut self) -> Su3W<'_, CppwrSpec> {
1148        Su3W::new(self, 6)
1149    }
1150    #[doc = "Bit 7 - State UNKNOWN Secure only 3."]
1151    #[inline(always)]
1152    pub fn sus3(&mut self) -> Sus3W<'_, CppwrSpec> {
1153        Sus3W::new(self, 7)
1154    }
1155    #[doc = "Bit 8 - State UNKNOWN 4."]
1156    #[inline(always)]
1157    pub fn su4(&mut self) -> Su4W<'_, CppwrSpec> {
1158        Su4W::new(self, 8)
1159    }
1160    #[doc = "Bit 9 - State UNKNOWN Secure only 4."]
1161    #[inline(always)]
1162    pub fn sus4(&mut self) -> Sus4W<'_, CppwrSpec> {
1163        Sus4W::new(self, 9)
1164    }
1165    #[doc = "Bit 10 - State UNKNOWN 5."]
1166    #[inline(always)]
1167    pub fn su5(&mut self) -> Su5W<'_, CppwrSpec> {
1168        Su5W::new(self, 10)
1169    }
1170    #[doc = "Bit 11 - State UNKNOWN Secure only 5."]
1171    #[inline(always)]
1172    pub fn sus5(&mut self) -> Sus5W<'_, CppwrSpec> {
1173        Sus5W::new(self, 11)
1174    }
1175    #[doc = "Bit 12 - State UNKNOWN 6."]
1176    #[inline(always)]
1177    pub fn su6(&mut self) -> Su6W<'_, CppwrSpec> {
1178        Su6W::new(self, 12)
1179    }
1180    #[doc = "Bit 13 - State UNKNOWN Secure only 6."]
1181    #[inline(always)]
1182    pub fn sus6(&mut self) -> Sus6W<'_, CppwrSpec> {
1183        Sus6W::new(self, 13)
1184    }
1185    #[doc = "Bit 14 - State UNKNOWN 7."]
1186    #[inline(always)]
1187    pub fn su7(&mut self) -> Su7W<'_, CppwrSpec> {
1188        Su7W::new(self, 14)
1189    }
1190    #[doc = "Bit 15 - State UNKNOWN Secure only 7."]
1191    #[inline(always)]
1192    pub fn sus7(&mut self) -> Sus7W<'_, CppwrSpec> {
1193        Sus7W::new(self, 15)
1194    }
1195    #[doc = "Bit 20 - State UNKNOWN 10."]
1196    #[inline(always)]
1197    pub fn su10(&mut self) -> Su10W<'_, CppwrSpec> {
1198        Su10W::new(self, 20)
1199    }
1200    #[doc = "Bit 21 - State UNKNOWN Secure only 10."]
1201    #[inline(always)]
1202    pub fn sus10(&mut self) -> Sus10W<'_, CppwrSpec> {
1203        Sus10W::new(self, 21)
1204    }
1205    #[doc = "Bit 22 - State UNKNOWN 11."]
1206    #[inline(always)]
1207    pub fn su11(&mut self) -> Su11W<'_, CppwrSpec> {
1208        Su11W::new(self, 22)
1209    }
1210    #[doc = "Bit 23 - State UNKNOWN Secure only 11."]
1211    #[inline(always)]
1212    pub fn sus11(&mut self) -> Sus11W<'_, CppwrSpec> {
1213        Sus11W::new(self, 23)
1214    }
1215}
1216#[doc = "Coprocessor Power Control Register\n\nYou can [`read`](crate::Reg::read) this register and get [`cppwr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`cppwr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1217pub struct CppwrSpec;
1218impl crate::RegisterSpec for CppwrSpec {
1219    type Ux = u32;
1220}
1221#[doc = "`read()` method returns [`cppwr::R`](R) reader structure"]
1222impl crate::Readable for CppwrSpec {}
1223#[doc = "`write(|w| ..)` method takes [`cppwr::W`](W) writer structure"]
1224impl crate::Writable for CppwrSpec {
1225    type Safety = crate::Unsafe;
1226}
1227#[doc = "`reset()` method sets CPPWR to value 0"]
1228impl crate::Resettable for CppwrSpec {}
mcxa_pac/scn_scb/cppwr.rs

mcxa_pac/scn_scb/
cppwr.rs
