mimxrt685s_pac/puf/
keylock.rs

1#[doc = "Register `KEYLOCK` reader"]
2pub type R = crate::R<KeylockSpec>;
3#[doc = "Register `KEYLOCK` writer"]
4pub type W = crate::W<KeylockSpec>;
5#[doc = "Key 0\n\nValue on reset: 2"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8#[repr(u8)]
9pub enum Key0 {
10    #[doc = "0: Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
11and KEYRESET\\[KEY0\\]
12is NOT allowed."]
13    Key0lock0 = 0,
14    #[doc = "1: Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
15and KEYRESET\\[KEY0\\]
16is NOT allowed."]
17    Key0lock1 = 1,
18    #[doc = "2: Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
19and KEYRESET\\[KEY0\\]
20is allowed."]
21    Key0unlock = 2,
22    #[doc = "3: Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
23and KEYRESET\\[KEY0\\]
24is NOT allowed."]
25    Key0lock3 = 3,
26}
27impl From<Key0> for u8 {
28    #[inline(always)]
29    fn from(variant: Key0) -> Self {
30        variant as _
31    }
32}
33impl crate::FieldSpec for Key0 {
34    type Ux = u8;
35}
36impl crate::IsEnum for Key0 {}
37#[doc = "Field `KEY0` reader - Key 0"]
38pub type Key0R = crate::FieldReader<Key0>;
39impl Key0R {
40    #[doc = "Get enumerated values variant"]
41    #[inline(always)]
42    pub const fn variant(&self) -> Key0 {
43        match self.bits {
44            0 => Key0::Key0lock0,
45            1 => Key0::Key0lock1,
46            2 => Key0::Key0unlock,
47            3 => Key0::Key0lock3,
48            _ => unreachable!(),
49        }
50    }
51    #[doc = "Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
52and KEYRESET\\[KEY0\\]
53is NOT allowed."]
54    #[inline(always)]
55    pub fn is_key0lock_0(&self) -> bool {
56        *self == Key0::Key0lock0
57    }
58    #[doc = "Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
59and KEYRESET\\[KEY0\\]
60is NOT allowed."]
61    #[inline(always)]
62    pub fn is_key0lock_1(&self) -> bool {
63        *self == Key0::Key0lock1
64    }
65    #[doc = "Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
66and KEYRESET\\[KEY0\\]
67is allowed."]
68    #[inline(always)]
69    pub fn is_key0unlock(&self) -> bool {
70        *self == Key0::Key0unlock
71    }
72    #[doc = "Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
73and KEYRESET\\[KEY0\\]
74is NOT allowed."]
75    #[inline(always)]
76    pub fn is_key0lock_3(&self) -> bool {
77        *self == Key0::Key0lock3
78    }
79}
80#[doc = "Field `KEY0` writer - Key 0"]
81pub type Key0W<'a, REG> = crate::FieldWriter<'a, REG, 2, Key0, crate::Safe>;
82impl<'a, REG> Key0W<'a, REG>
83where
84    REG: crate::Writable + crate::RegisterSpec,
85    REG::Ux: From<u8>,
86{
87    #[doc = "Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
88and KEYRESET\\[KEY0\\]
89is NOT allowed."]
90    #[inline(always)]
91    pub fn key0lock_0(self) -> &'a mut crate::W<REG> {
92        self.variant(Key0::Key0lock0)
93    }
94    #[doc = "Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
95and KEYRESET\\[KEY0\\]
96is NOT allowed."]
97    #[inline(always)]
98    pub fn key0lock_1(self) -> &'a mut crate::W<REG> {
99        self.variant(Key0::Key0lock1)
100    }
101    #[doc = "Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
102and KEYRESET\\[KEY0\\]
103is allowed."]
104    #[inline(always)]
105    pub fn key0unlock(self) -> &'a mut crate::W<REG> {
106        self.variant(Key0::Key0unlock)
107    }
108    #[doc = "Write access to KEY0MASK, KEYENABLE\\[KEY0\\]
109and KEYRESET\\[KEY0\\]
110is NOT allowed."]
111    #[inline(always)]
112    pub fn key0lock_3(self) -> &'a mut crate::W<REG> {
113        self.variant(Key0::Key0lock3)
114    }
115}
116#[doc = "Key 1\n\nValue on reset: 2"]
117#[cfg_attr(feature = "defmt", derive(defmt::Format))]
118#[derive(Clone, Copy, Debug, PartialEq, Eq)]
119#[repr(u8)]
120pub enum Key1 {
121    #[doc = "0: Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
122and KEYRESET\\[KEY1\\]
123is NOT allowed."]
124    Key1lock0 = 0,
125    #[doc = "1: Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
126and KEYRESET\\[KEY1\\]
127is NOT allowed."]
128    Key1lock1 = 1,
129    #[doc = "2: Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
130and KEYRESET\\[KEY1\\]
131is allowed."]
132    Key1unlock = 2,
133    #[doc = "3: Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
134and KEYRESET\\[KEY1\\]
135is NOT allowed."]
136    Key1lock3 = 3,
137}
138impl From<Key1> for u8 {
139    #[inline(always)]
140    fn from(variant: Key1) -> Self {
141        variant as _
142    }
143}
144impl crate::FieldSpec for Key1 {
145    type Ux = u8;
146}
147impl crate::IsEnum for Key1 {}
148#[doc = "Field `KEY1` reader - Key 1"]
149pub type Key1R = crate::FieldReader<Key1>;
150impl Key1R {
151    #[doc = "Get enumerated values variant"]
152    #[inline(always)]
153    pub const fn variant(&self) -> Key1 {
154        match self.bits {
155            0 => Key1::Key1lock0,
156            1 => Key1::Key1lock1,
157            2 => Key1::Key1unlock,
158            3 => Key1::Key1lock3,
159            _ => unreachable!(),
160        }
161    }
162    #[doc = "Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
163and KEYRESET\\[KEY1\\]
164is NOT allowed."]
165    #[inline(always)]
166    pub fn is_key1lock_0(&self) -> bool {
167        *self == Key1::Key1lock0
168    }
169    #[doc = "Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
170and KEYRESET\\[KEY1\\]
171is NOT allowed."]
172    #[inline(always)]
173    pub fn is_key1lock_1(&self) -> bool {
174        *self == Key1::Key1lock1
175    }
176    #[doc = "Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
177and KEYRESET\\[KEY1\\]
178is allowed."]
179    #[inline(always)]
180    pub fn is_key1unlock(&self) -> bool {
181        *self == Key1::Key1unlock
182    }
183    #[doc = "Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
184and KEYRESET\\[KEY1\\]
185is NOT allowed."]
186    #[inline(always)]
187    pub fn is_key1lock_3(&self) -> bool {
188        *self == Key1::Key1lock3
189    }
190}
191#[doc = "Field `KEY1` writer - Key 1"]
192pub type Key1W<'a, REG> = crate::FieldWriter<'a, REG, 2, Key1, crate::Safe>;
193impl<'a, REG> Key1W<'a, REG>
194where
195    REG: crate::Writable + crate::RegisterSpec,
196    REG::Ux: From<u8>,
197{
198    #[doc = "Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
199and KEYRESET\\[KEY1\\]
200is NOT allowed."]
201    #[inline(always)]
202    pub fn key1lock_0(self) -> &'a mut crate::W<REG> {
203        self.variant(Key1::Key1lock0)
204    }
205    #[doc = "Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
206and KEYRESET\\[KEY1\\]
207is NOT allowed."]
208    #[inline(always)]
209    pub fn key1lock_1(self) -> &'a mut crate::W<REG> {
210        self.variant(Key1::Key1lock1)
211    }
212    #[doc = "Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
213and KEYRESET\\[KEY1\\]
214is allowed."]
215    #[inline(always)]
216    pub fn key1unlock(self) -> &'a mut crate::W<REG> {
217        self.variant(Key1::Key1unlock)
218    }
219    #[doc = "Write access to KEY1MASK, KEYENABLE\\[KEY1\\]
220and KEYRESET\\[KEY1\\]
221is NOT allowed."]
222    #[inline(always)]
223    pub fn key1lock_3(self) -> &'a mut crate::W<REG> {
224        self.variant(Key1::Key1lock3)
225    }
226}
227#[doc = "Key 2\n\nValue on reset: 2"]
228#[cfg_attr(feature = "defmt", derive(defmt::Format))]
229#[derive(Clone, Copy, Debug, PartialEq, Eq)]
230#[repr(u8)]
231pub enum Key2 {
232    #[doc = "0: Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
233and KEYRESET\\[KEY2\\]
234is NOT allowed."]
235    Key2lock0 = 0,
236    #[doc = "1: Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
237and KEYRESET\\[KEY2\\]
238is NOT allowed."]
239    Key2lock1 = 1,
240    #[doc = "2: Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
241and KEYRESET\\[KEY2\\]
242is allowed."]
243    Key2unlock = 2,
244    #[doc = "3: Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
245and KEYRESET\\[KEY2\\]
246is NOT allowed."]
247    Key2lock3 = 3,
248}
249impl From<Key2> for u8 {
250    #[inline(always)]
251    fn from(variant: Key2) -> Self {
252        variant as _
253    }
254}
255impl crate::FieldSpec for Key2 {
256    type Ux = u8;
257}
258impl crate::IsEnum for Key2 {}
259#[doc = "Field `KEY2` reader - Key 2"]
260pub type Key2R = crate::FieldReader<Key2>;
261impl Key2R {
262    #[doc = "Get enumerated values variant"]
263    #[inline(always)]
264    pub const fn variant(&self) -> Key2 {
265        match self.bits {
266            0 => Key2::Key2lock0,
267            1 => Key2::Key2lock1,
268            2 => Key2::Key2unlock,
269            3 => Key2::Key2lock3,
270            _ => unreachable!(),
271        }
272    }
273    #[doc = "Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
274and KEYRESET\\[KEY2\\]
275is NOT allowed."]
276    #[inline(always)]
277    pub fn is_key2lock_0(&self) -> bool {
278        *self == Key2::Key2lock0
279    }
280    #[doc = "Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
281and KEYRESET\\[KEY2\\]
282is NOT allowed."]
283    #[inline(always)]
284    pub fn is_key2lock_1(&self) -> bool {
285        *self == Key2::Key2lock1
286    }
287    #[doc = "Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
288and KEYRESET\\[KEY2\\]
289is allowed."]
290    #[inline(always)]
291    pub fn is_key2unlock(&self) -> bool {
292        *self == Key2::Key2unlock
293    }
294    #[doc = "Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
295and KEYRESET\\[KEY2\\]
296is NOT allowed."]
297    #[inline(always)]
298    pub fn is_key2lock_3(&self) -> bool {
299        *self == Key2::Key2lock3
300    }
301}
302#[doc = "Field `KEY2` writer - Key 2"]
303pub type Key2W<'a, REG> = crate::FieldWriter<'a, REG, 2, Key2, crate::Safe>;
304impl<'a, REG> Key2W<'a, REG>
305where
306    REG: crate::Writable + crate::RegisterSpec,
307    REG::Ux: From<u8>,
308{
309    #[doc = "Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
310and KEYRESET\\[KEY2\\]
311is NOT allowed."]
312    #[inline(always)]
313    pub fn key2lock_0(self) -> &'a mut crate::W<REG> {
314        self.variant(Key2::Key2lock0)
315    }
316    #[doc = "Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
317and KEYRESET\\[KEY2\\]
318is NOT allowed."]
319    #[inline(always)]
320    pub fn key2lock_1(self) -> &'a mut crate::W<REG> {
321        self.variant(Key2::Key2lock1)
322    }
323    #[doc = "Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
324and KEYRESET\\[KEY2\\]
325is allowed."]
326    #[inline(always)]
327    pub fn key2unlock(self) -> &'a mut crate::W<REG> {
328        self.variant(Key2::Key2unlock)
329    }
330    #[doc = "Write access to KEY2MASK, KEYENABLE\\[KEY2\\]
331and KEYRESET\\[KEY2\\]
332is NOT allowed."]
333    #[inline(always)]
334    pub fn key2lock_3(self) -> &'a mut crate::W<REG> {
335        self.variant(Key2::Key2lock3)
336    }
337}
338#[doc = "Key 3\n\nValue on reset: 2"]
339#[cfg_attr(feature = "defmt", derive(defmt::Format))]
340#[derive(Clone, Copy, Debug, PartialEq, Eq)]
341#[repr(u8)]
342pub enum Key3 {
343    #[doc = "0: Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
344and KEYRESET\\[KEY3\\]
345is NOT allowed."]
346    Key3lock0 = 0,
347    #[doc = "1: Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
348and KEYRESET\\[KEY3\\]
349is NOT allowed."]
350    Key3lock1 = 1,
351    #[doc = "2: Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
352and KEYRESET\\[KEY3\\]
353is allowed."]
354    Key3unlock = 2,
355    #[doc = "3: Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
356and KEYRESET\\[KEY3\\]
357is NOT allowed."]
358    Key3lock3 = 3,
359}
360impl From<Key3> for u8 {
361    #[inline(always)]
362    fn from(variant: Key3) -> Self {
363        variant as _
364    }
365}
366impl crate::FieldSpec for Key3 {
367    type Ux = u8;
368}
369impl crate::IsEnum for Key3 {}
370#[doc = "Field `KEY3` reader - Key 3"]
371pub type Key3R = crate::FieldReader<Key3>;
372impl Key3R {
373    #[doc = "Get enumerated values variant"]
374    #[inline(always)]
375    pub const fn variant(&self) -> Key3 {
376        match self.bits {
377            0 => Key3::Key3lock0,
378            1 => Key3::Key3lock1,
379            2 => Key3::Key3unlock,
380            3 => Key3::Key3lock3,
381            _ => unreachable!(),
382        }
383    }
384    #[doc = "Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
385and KEYRESET\\[KEY3\\]
386is NOT allowed."]
387    #[inline(always)]
388    pub fn is_key3lock_0(&self) -> bool {
389        *self == Key3::Key3lock0
390    }
391    #[doc = "Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
392and KEYRESET\\[KEY3\\]
393is NOT allowed."]
394    #[inline(always)]
395    pub fn is_key3lock_1(&self) -> bool {
396        *self == Key3::Key3lock1
397    }
398    #[doc = "Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
399and KEYRESET\\[KEY3\\]
400is allowed."]
401    #[inline(always)]
402    pub fn is_key3unlock(&self) -> bool {
403        *self == Key3::Key3unlock
404    }
405    #[doc = "Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
406and KEYRESET\\[KEY3\\]
407is NOT allowed."]
408    #[inline(always)]
409    pub fn is_key3lock_3(&self) -> bool {
410        *self == Key3::Key3lock3
411    }
412}
413#[doc = "Field `KEY3` writer - Key 3"]
414pub type Key3W<'a, REG> = crate::FieldWriter<'a, REG, 2, Key3, crate::Safe>;
415impl<'a, REG> Key3W<'a, REG>
416where
417    REG: crate::Writable + crate::RegisterSpec,
418    REG::Ux: From<u8>,
419{
420    #[doc = "Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
421and KEYRESET\\[KEY3\\]
422is NOT allowed."]
423    #[inline(always)]
424    pub fn key3lock_0(self) -> &'a mut crate::W<REG> {
425        self.variant(Key3::Key3lock0)
426    }
427    #[doc = "Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
428and KEYRESET\\[KEY3\\]
429is NOT allowed."]
430    #[inline(always)]
431    pub fn key3lock_1(self) -> &'a mut crate::W<REG> {
432        self.variant(Key3::Key3lock1)
433    }
434    #[doc = "Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
435and KEYRESET\\[KEY3\\]
436is allowed."]
437    #[inline(always)]
438    pub fn key3unlock(self) -> &'a mut crate::W<REG> {
439        self.variant(Key3::Key3unlock)
440    }
441    #[doc = "Write access to KEY3MASK, KEYENABLE\\[KEY3\\]
442and KEYRESET\\[KEY3\\]
443is NOT allowed."]
444    #[inline(always)]
445    pub fn key3lock_3(self) -> &'a mut crate::W<REG> {
446        self.variant(Key3::Key3lock3)
447    }
448}
449impl R {
450    #[doc = "Bits 0:1 - Key 0"]
451    #[inline(always)]
452    pub fn key0(&self) -> Key0R {
453        Key0R::new((self.bits & 3) as u8)
454    }
455    #[doc = "Bits 2:3 - Key 1"]
456    #[inline(always)]
457    pub fn key1(&self) -> Key1R {
458        Key1R::new(((self.bits >> 2) & 3) as u8)
459    }
460    #[doc = "Bits 4:5 - Key 2"]
461    #[inline(always)]
462    pub fn key2(&self) -> Key2R {
463        Key2R::new(((self.bits >> 4) & 3) as u8)
464    }
465    #[doc = "Bits 6:7 - Key 3"]
466    #[inline(always)]
467    pub fn key3(&self) -> Key3R {
468        Key3R::new(((self.bits >> 6) & 3) as u8)
469    }
470}
471#[cfg(feature = "debug")]
472impl core::fmt::Debug for R {
473    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
474        f.debug_struct("KEYLOCK")
475            .field("key0", &self.key0())
476            .field("key1", &self.key1())
477            .field("key2", &self.key2())
478            .field("key3", &self.key3())
479            .finish()
480    }
481}
482impl W {
483    #[doc = "Bits 0:1 - Key 0"]
484    #[inline(always)]
485    pub fn key0(&mut self) -> Key0W<KeylockSpec> {
486        Key0W::new(self, 0)
487    }
488    #[doc = "Bits 2:3 - Key 1"]
489    #[inline(always)]
490    pub fn key1(&mut self) -> Key1W<KeylockSpec> {
491        Key1W::new(self, 2)
492    }
493    #[doc = "Bits 4:5 - Key 2"]
494    #[inline(always)]
495    pub fn key2(&mut self) -> Key2W<KeylockSpec> {
496        Key2W::new(self, 4)
497    }
498    #[doc = "Bits 6:7 - Key 3"]
499    #[inline(always)]
500    pub fn key3(&mut self) -> Key3W<KeylockSpec> {
501        Key3W::new(self, 6)
502    }
503}
504#[doc = "Key Lock\n\nYou can [`read`](crate::Reg::read) this register and get [`keylock::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`keylock::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
505pub struct KeylockSpec;
506impl crate::RegisterSpec for KeylockSpec {
507    type Ux = u32;
508}
509#[doc = "`read()` method returns [`keylock::R`](R) reader structure"]
510impl crate::Readable for KeylockSpec {}
511#[doc = "`write(|w| ..)` method takes [`keylock::W`](W) writer structure"]
512impl crate::Writable for KeylockSpec {
513    type Safety = crate::Unsafe;
514    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
515    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
516}
517#[doc = "`reset()` method sets KEYLOCK to value 0xaa"]
518impl crate::Resettable for KeylockSpec {
519    const RESET_VALUE: u32 = 0xaa;
520}
mimxrt685s_pac/puf/keylock.rs

mimxrt685s_pac/puf/
keylock.rs
