1#[doc = "Reader of register LR"]
2pub type R = crate::R<u32, super::LR>;
3#[doc = "Writer for register LR"]
4pub type W = crate::W<u32, super::LR>;
5#[doc = "Register LR `reset()`'s with value 0xffff"]
6impl crate::ResetValue for super::LR {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0xffff
11 }
12}
13#[doc = "Time Compensation Lock\n\nValue on reset: 1"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum TCL_A {
16 #[doc = "0: Time Compensation Register is locked and writes are ignored."]
17 _0,
18 #[doc = "1: Time Compensation Register is not locked and writes complete as normal."]
19 _1,
20}
21impl From<TCL_A> for bool {
22 #[inline(always)]
23 fn from(variant: TCL_A) -> Self {
24 match variant {
25 TCL_A::_0 => false,
26 TCL_A::_1 => true,
27 }
28 }
29}
30#[doc = "Reader of field `TCL`"]
31pub type TCL_R = crate::R<bool, TCL_A>;
32impl TCL_R {
33 #[doc = r"Get enumerated values variant"]
34 #[inline(always)]
35 pub fn variant(&self) -> TCL_A {
36 match self.bits {
37 false => TCL_A::_0,
38 true => TCL_A::_1,
39 }
40 }
41 #[doc = "Checks if the value of the field is `_0`"]
42 #[inline(always)]
43 pub fn is_0(&self) -> bool {
44 *self == TCL_A::_0
45 }
46 #[doc = "Checks if the value of the field is `_1`"]
47 #[inline(always)]
48 pub fn is_1(&self) -> bool {
49 *self == TCL_A::_1
50 }
51}
52#[doc = "Write proxy for field `TCL`"]
53pub struct TCL_W<'a> {
54 w: &'a mut W,
55}
56impl<'a> TCL_W<'a> {
57 #[doc = r"Writes `variant` to the field"]
58 #[inline(always)]
59 pub fn variant(self, variant: TCL_A) -> &'a mut W {
60 {
61 self.bit(variant.into())
62 }
63 }
64 #[doc = "Time Compensation Register is locked and writes are ignored."]
65 #[inline(always)]
66 pub fn _0(self) -> &'a mut W {
67 self.variant(TCL_A::_0)
68 }
69 #[doc = "Time Compensation Register is not locked and writes complete as normal."]
70 #[inline(always)]
71 pub fn _1(self) -> &'a mut W {
72 self.variant(TCL_A::_1)
73 }
74 #[doc = r"Sets the field bit"]
75 #[inline(always)]
76 pub fn set_bit(self) -> &'a mut W {
77 self.bit(true)
78 }
79 #[doc = r"Clears the field bit"]
80 #[inline(always)]
81 pub fn clear_bit(self) -> &'a mut W {
82 self.bit(false)
83 }
84 #[doc = r"Writes raw bits to the field"]
85 #[inline(always)]
86 pub fn bit(self, value: bool) -> &'a mut W {
87 self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
88 self.w
89 }
90}
91#[doc = "Control Register Lock\n\nValue on reset: 1"]
92#[derive(Clone, Copy, Debug, PartialEq)]
93pub enum CRL_A {
94 #[doc = "0: Control Register is locked and writes are ignored."]
95 _0,
96 #[doc = "1: Control Register is not locked and writes complete as normal."]
97 _1,
98}
99impl From<CRL_A> for bool {
100 #[inline(always)]
101 fn from(variant: CRL_A) -> Self {
102 match variant {
103 CRL_A::_0 => false,
104 CRL_A::_1 => true,
105 }
106 }
107}
108#[doc = "Reader of field `CRL`"]
109pub type CRL_R = crate::R<bool, CRL_A>;
110impl CRL_R {
111 #[doc = r"Get enumerated values variant"]
112 #[inline(always)]
113 pub fn variant(&self) -> CRL_A {
114 match self.bits {
115 false => CRL_A::_0,
116 true => CRL_A::_1,
117 }
118 }
119 #[doc = "Checks if the value of the field is `_0`"]
120 #[inline(always)]
121 pub fn is_0(&self) -> bool {
122 *self == CRL_A::_0
123 }
124 #[doc = "Checks if the value of the field is `_1`"]
125 #[inline(always)]
126 pub fn is_1(&self) -> bool {
127 *self == CRL_A::_1
128 }
129}
130#[doc = "Write proxy for field `CRL`"]
131pub struct CRL_W<'a> {
132 w: &'a mut W,
133}
134impl<'a> CRL_W<'a> {
135 #[doc = r"Writes `variant` to the field"]
136 #[inline(always)]
137 pub fn variant(self, variant: CRL_A) -> &'a mut W {
138 {
139 self.bit(variant.into())
140 }
141 }
142 #[doc = "Control Register is locked and writes are ignored."]
143 #[inline(always)]
144 pub fn _0(self) -> &'a mut W {
145 self.variant(CRL_A::_0)
146 }
147 #[doc = "Control Register is not locked and writes complete as normal."]
148 #[inline(always)]
149 pub fn _1(self) -> &'a mut W {
150 self.variant(CRL_A::_1)
151 }
152 #[doc = r"Sets the field bit"]
153 #[inline(always)]
154 pub fn set_bit(self) -> &'a mut W {
155 self.bit(true)
156 }
157 #[doc = r"Clears the field bit"]
158 #[inline(always)]
159 pub fn clear_bit(self) -> &'a mut W {
160 self.bit(false)
161 }
162 #[doc = r"Writes raw bits to the field"]
163 #[inline(always)]
164 pub fn bit(self, value: bool) -> &'a mut W {
165 self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
166 self.w
167 }
168}
169#[doc = "Status Register Lock\n\nValue on reset: 1"]
170#[derive(Clone, Copy, Debug, PartialEq)]
171pub enum SRL_A {
172 #[doc = "0: Status Register is locked and writes are ignored."]
173 _0,
174 #[doc = "1: Status Register is not locked and writes complete as normal."]
175 _1,
176}
177impl From<SRL_A> for bool {
178 #[inline(always)]
179 fn from(variant: SRL_A) -> Self {
180 match variant {
181 SRL_A::_0 => false,
182 SRL_A::_1 => true,
183 }
184 }
185}
186#[doc = "Reader of field `SRL`"]
187pub type SRL_R = crate::R<bool, SRL_A>;
188impl SRL_R {
189 #[doc = r"Get enumerated values variant"]
190 #[inline(always)]
191 pub fn variant(&self) -> SRL_A {
192 match self.bits {
193 false => SRL_A::_0,
194 true => SRL_A::_1,
195 }
196 }
197 #[doc = "Checks if the value of the field is `_0`"]
198 #[inline(always)]
199 pub fn is_0(&self) -> bool {
200 *self == SRL_A::_0
201 }
202 #[doc = "Checks if the value of the field is `_1`"]
203 #[inline(always)]
204 pub fn is_1(&self) -> bool {
205 *self == SRL_A::_1
206 }
207}
208#[doc = "Write proxy for field `SRL`"]
209pub struct SRL_W<'a> {
210 w: &'a mut W,
211}
212impl<'a> SRL_W<'a> {
213 #[doc = r"Writes `variant` to the field"]
214 #[inline(always)]
215 pub fn variant(self, variant: SRL_A) -> &'a mut W {
216 {
217 self.bit(variant.into())
218 }
219 }
220 #[doc = "Status Register is locked and writes are ignored."]
221 #[inline(always)]
222 pub fn _0(self) -> &'a mut W {
223 self.variant(SRL_A::_0)
224 }
225 #[doc = "Status Register is not locked and writes complete as normal."]
226 #[inline(always)]
227 pub fn _1(self) -> &'a mut W {
228 self.variant(SRL_A::_1)
229 }
230 #[doc = r"Sets the field bit"]
231 #[inline(always)]
232 pub fn set_bit(self) -> &'a mut W {
233 self.bit(true)
234 }
235 #[doc = r"Clears the field bit"]
236 #[inline(always)]
237 pub fn clear_bit(self) -> &'a mut W {
238 self.bit(false)
239 }
240 #[doc = r"Writes raw bits to the field"]
241 #[inline(always)]
242 pub fn bit(self, value: bool) -> &'a mut W {
243 self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
244 self.w
245 }
246}
247#[doc = "Lock Register Lock\n\nValue on reset: 1"]
248#[derive(Clone, Copy, Debug, PartialEq)]
249pub enum LRL_A {
250 #[doc = "0: Lock Register is locked and writes are ignored."]
251 _0,
252 #[doc = "1: Lock Register is not locked and writes complete as normal."]
253 _1,
254}
255impl From<LRL_A> for bool {
256 #[inline(always)]
257 fn from(variant: LRL_A) -> Self {
258 match variant {
259 LRL_A::_0 => false,
260 LRL_A::_1 => true,
261 }
262 }
263}
264#[doc = "Reader of field `LRL`"]
265pub type LRL_R = crate::R<bool, LRL_A>;
266impl LRL_R {
267 #[doc = r"Get enumerated values variant"]
268 #[inline(always)]
269 pub fn variant(&self) -> LRL_A {
270 match self.bits {
271 false => LRL_A::_0,
272 true => LRL_A::_1,
273 }
274 }
275 #[doc = "Checks if the value of the field is `_0`"]
276 #[inline(always)]
277 pub fn is_0(&self) -> bool {
278 *self == LRL_A::_0
279 }
280 #[doc = "Checks if the value of the field is `_1`"]
281 #[inline(always)]
282 pub fn is_1(&self) -> bool {
283 *self == LRL_A::_1
284 }
285}
286#[doc = "Write proxy for field `LRL`"]
287pub struct LRL_W<'a> {
288 w: &'a mut W,
289}
290impl<'a> LRL_W<'a> {
291 #[doc = r"Writes `variant` to the field"]
292 #[inline(always)]
293 pub fn variant(self, variant: LRL_A) -> &'a mut W {
294 {
295 self.bit(variant.into())
296 }
297 }
298 #[doc = "Lock Register is locked and writes are ignored."]
299 #[inline(always)]
300 pub fn _0(self) -> &'a mut W {
301 self.variant(LRL_A::_0)
302 }
303 #[doc = "Lock Register is not locked and writes complete as normal."]
304 #[inline(always)]
305 pub fn _1(self) -> &'a mut W {
306 self.variant(LRL_A::_1)
307 }
308 #[doc = r"Sets the field bit"]
309 #[inline(always)]
310 pub fn set_bit(self) -> &'a mut W {
311 self.bit(true)
312 }
313 #[doc = r"Clears the field bit"]
314 #[inline(always)]
315 pub fn clear_bit(self) -> &'a mut W {
316 self.bit(false)
317 }
318 #[doc = r"Writes raw bits to the field"]
319 #[inline(always)]
320 pub fn bit(self, value: bool) -> &'a mut W {
321 self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
322 self.w
323 }
324}
325#[doc = "Tamper Time Seconds Lock\n\nValue on reset: 1"]
326#[derive(Clone, Copy, Debug, PartialEq)]
327pub enum TTSL_A {
328 #[doc = "0: Tamper Time Seconds Register is locked and writes are ignored."]
329 _0,
330 #[doc = "1: Tamper Time Seconds Register is not locked and writes complete as normal."]
331 _1,
332}
333impl From<TTSL_A> for bool {
334 #[inline(always)]
335 fn from(variant: TTSL_A) -> Self {
336 match variant {
337 TTSL_A::_0 => false,
338 TTSL_A::_1 => true,
339 }
340 }
341}
342#[doc = "Reader of field `TTSL`"]
343pub type TTSL_R = crate::R<bool, TTSL_A>;
344impl TTSL_R {
345 #[doc = r"Get enumerated values variant"]
346 #[inline(always)]
347 pub fn variant(&self) -> TTSL_A {
348 match self.bits {
349 false => TTSL_A::_0,
350 true => TTSL_A::_1,
351 }
352 }
353 #[doc = "Checks if the value of the field is `_0`"]
354 #[inline(always)]
355 pub fn is_0(&self) -> bool {
356 *self == TTSL_A::_0
357 }
358 #[doc = "Checks if the value of the field is `_1`"]
359 #[inline(always)]
360 pub fn is_1(&self) -> bool {
361 *self == TTSL_A::_1
362 }
363}
364#[doc = "Write proxy for field `TTSL`"]
365pub struct TTSL_W<'a> {
366 w: &'a mut W,
367}
368impl<'a> TTSL_W<'a> {
369 #[doc = r"Writes `variant` to the field"]
370 #[inline(always)]
371 pub fn variant(self, variant: TTSL_A) -> &'a mut W {
372 {
373 self.bit(variant.into())
374 }
375 }
376 #[doc = "Tamper Time Seconds Register is locked and writes are ignored."]
377 #[inline(always)]
378 pub fn _0(self) -> &'a mut W {
379 self.variant(TTSL_A::_0)
380 }
381 #[doc = "Tamper Time Seconds Register is not locked and writes complete as normal."]
382 #[inline(always)]
383 pub fn _1(self) -> &'a mut W {
384 self.variant(TTSL_A::_1)
385 }
386 #[doc = r"Sets the field bit"]
387 #[inline(always)]
388 pub fn set_bit(self) -> &'a mut W {
389 self.bit(true)
390 }
391 #[doc = r"Clears the field bit"]
392 #[inline(always)]
393 pub fn clear_bit(self) -> &'a mut W {
394 self.bit(false)
395 }
396 #[doc = r"Writes raw bits to the field"]
397 #[inline(always)]
398 pub fn bit(self, value: bool) -> &'a mut W {
399 self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
400 self.w
401 }
402}
403#[doc = "Monotonic Enable Lock\n\nValue on reset: 1"]
404#[derive(Clone, Copy, Debug, PartialEq)]
405pub enum MEL_A {
406 #[doc = "0: Monotonic Enable Register is locked and writes are ignored."]
407 _0,
408 #[doc = "1: Monotonic Enable Register is not locked and writes complete as normal."]
409 _1,
410}
411impl From<MEL_A> for bool {
412 #[inline(always)]
413 fn from(variant: MEL_A) -> Self {
414 match variant {
415 MEL_A::_0 => false,
416 MEL_A::_1 => true,
417 }
418 }
419}
420#[doc = "Reader of field `MEL`"]
421pub type MEL_R = crate::R<bool, MEL_A>;
422impl MEL_R {
423 #[doc = r"Get enumerated values variant"]
424 #[inline(always)]
425 pub fn variant(&self) -> MEL_A {
426 match self.bits {
427 false => MEL_A::_0,
428 true => MEL_A::_1,
429 }
430 }
431 #[doc = "Checks if the value of the field is `_0`"]
432 #[inline(always)]
433 pub fn is_0(&self) -> bool {
434 *self == MEL_A::_0
435 }
436 #[doc = "Checks if the value of the field is `_1`"]
437 #[inline(always)]
438 pub fn is_1(&self) -> bool {
439 *self == MEL_A::_1
440 }
441}
442#[doc = "Write proxy for field `MEL`"]
443pub struct MEL_W<'a> {
444 w: &'a mut W,
445}
446impl<'a> MEL_W<'a> {
447 #[doc = r"Writes `variant` to the field"]
448 #[inline(always)]
449 pub fn variant(self, variant: MEL_A) -> &'a mut W {
450 {
451 self.bit(variant.into())
452 }
453 }
454 #[doc = "Monotonic Enable Register is locked and writes are ignored."]
455 #[inline(always)]
456 pub fn _0(self) -> &'a mut W {
457 self.variant(MEL_A::_0)
458 }
459 #[doc = "Monotonic Enable Register is not locked and writes complete as normal."]
460 #[inline(always)]
461 pub fn _1(self) -> &'a mut W {
462 self.variant(MEL_A::_1)
463 }
464 #[doc = r"Sets the field bit"]
465 #[inline(always)]
466 pub fn set_bit(self) -> &'a mut W {
467 self.bit(true)
468 }
469 #[doc = r"Clears the field bit"]
470 #[inline(always)]
471 pub fn clear_bit(self) -> &'a mut W {
472 self.bit(false)
473 }
474 #[doc = r"Writes raw bits to the field"]
475 #[inline(always)]
476 pub fn bit(self, value: bool) -> &'a mut W {
477 self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
478 self.w
479 }
480}
481#[doc = "Monotonic Counter Low Lock\n\nValue on reset: 1"]
482#[derive(Clone, Copy, Debug, PartialEq)]
483pub enum MCLL_A {
484 #[doc = "0: Monotonic Counter Low Register is locked and writes are ignored."]
485 _0,
486 #[doc = "1: Monotonic Counter Low Register is not locked and writes complete as normal."]
487 _1,
488}
489impl From<MCLL_A> for bool {
490 #[inline(always)]
491 fn from(variant: MCLL_A) -> Self {
492 match variant {
493 MCLL_A::_0 => false,
494 MCLL_A::_1 => true,
495 }
496 }
497}
498#[doc = "Reader of field `MCLL`"]
499pub type MCLL_R = crate::R<bool, MCLL_A>;
500impl MCLL_R {
501 #[doc = r"Get enumerated values variant"]
502 #[inline(always)]
503 pub fn variant(&self) -> MCLL_A {
504 match self.bits {
505 false => MCLL_A::_0,
506 true => MCLL_A::_1,
507 }
508 }
509 #[doc = "Checks if the value of the field is `_0`"]
510 #[inline(always)]
511 pub fn is_0(&self) -> bool {
512 *self == MCLL_A::_0
513 }
514 #[doc = "Checks if the value of the field is `_1`"]
515 #[inline(always)]
516 pub fn is_1(&self) -> bool {
517 *self == MCLL_A::_1
518 }
519}
520#[doc = "Write proxy for field `MCLL`"]
521pub struct MCLL_W<'a> {
522 w: &'a mut W,
523}
524impl<'a> MCLL_W<'a> {
525 #[doc = r"Writes `variant` to the field"]
526 #[inline(always)]
527 pub fn variant(self, variant: MCLL_A) -> &'a mut W {
528 {
529 self.bit(variant.into())
530 }
531 }
532 #[doc = "Monotonic Counter Low Register is locked and writes are ignored."]
533 #[inline(always)]
534 pub fn _0(self) -> &'a mut W {
535 self.variant(MCLL_A::_0)
536 }
537 #[doc = "Monotonic Counter Low Register is not locked and writes complete as normal."]
538 #[inline(always)]
539 pub fn _1(self) -> &'a mut W {
540 self.variant(MCLL_A::_1)
541 }
542 #[doc = r"Sets the field bit"]
543 #[inline(always)]
544 pub fn set_bit(self) -> &'a mut W {
545 self.bit(true)
546 }
547 #[doc = r"Clears the field bit"]
548 #[inline(always)]
549 pub fn clear_bit(self) -> &'a mut W {
550 self.bit(false)
551 }
552 #[doc = r"Writes raw bits to the field"]
553 #[inline(always)]
554 pub fn bit(self, value: bool) -> &'a mut W {
555 self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
556 self.w
557 }
558}
559#[doc = "Monotonic Counter High Lock\n\nValue on reset: 1"]
560#[derive(Clone, Copy, Debug, PartialEq)]
561pub enum MCHL_A {
562 #[doc = "0: Monotonic Counter High Register is locked and writes are ignored."]
563 _0,
564 #[doc = "1: Monotonic Counter High Register is not locked and writes complete as normal."]
565 _1,
566}
567impl From<MCHL_A> for bool {
568 #[inline(always)]
569 fn from(variant: MCHL_A) -> Self {
570 match variant {
571 MCHL_A::_0 => false,
572 MCHL_A::_1 => true,
573 }
574 }
575}
576#[doc = "Reader of field `MCHL`"]
577pub type MCHL_R = crate::R<bool, MCHL_A>;
578impl MCHL_R {
579 #[doc = r"Get enumerated values variant"]
580 #[inline(always)]
581 pub fn variant(&self) -> MCHL_A {
582 match self.bits {
583 false => MCHL_A::_0,
584 true => MCHL_A::_1,
585 }
586 }
587 #[doc = "Checks if the value of the field is `_0`"]
588 #[inline(always)]
589 pub fn is_0(&self) -> bool {
590 *self == MCHL_A::_0
591 }
592 #[doc = "Checks if the value of the field is `_1`"]
593 #[inline(always)]
594 pub fn is_1(&self) -> bool {
595 *self == MCHL_A::_1
596 }
597}
598#[doc = "Write proxy for field `MCHL`"]
599pub struct MCHL_W<'a> {
600 w: &'a mut W,
601}
602impl<'a> MCHL_W<'a> {
603 #[doc = r"Writes `variant` to the field"]
604 #[inline(always)]
605 pub fn variant(self, variant: MCHL_A) -> &'a mut W {
606 {
607 self.bit(variant.into())
608 }
609 }
610 #[doc = "Monotonic Counter High Register is locked and writes are ignored."]
611 #[inline(always)]
612 pub fn _0(self) -> &'a mut W {
613 self.variant(MCHL_A::_0)
614 }
615 #[doc = "Monotonic Counter High Register is not locked and writes complete as normal."]
616 #[inline(always)]
617 pub fn _1(self) -> &'a mut W {
618 self.variant(MCHL_A::_1)
619 }
620 #[doc = r"Sets the field bit"]
621 #[inline(always)]
622 pub fn set_bit(self) -> &'a mut W {
623 self.bit(true)
624 }
625 #[doc = r"Clears the field bit"]
626 #[inline(always)]
627 pub fn clear_bit(self) -> &'a mut W {
628 self.bit(false)
629 }
630 #[doc = r"Writes raw bits to the field"]
631 #[inline(always)]
632 pub fn bit(self, value: bool) -> &'a mut W {
633 self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
634 self.w
635 }
636}
637impl R {
638 #[doc = "Bit 3 - Time Compensation Lock"]
639 #[inline(always)]
640 pub fn tcl(&self) -> TCL_R {
641 TCL_R::new(((self.bits >> 3) & 0x01) != 0)
642 }
643 #[doc = "Bit 4 - Control Register Lock"]
644 #[inline(always)]
645 pub fn crl(&self) -> CRL_R {
646 CRL_R::new(((self.bits >> 4) & 0x01) != 0)
647 }
648 #[doc = "Bit 5 - Status Register Lock"]
649 #[inline(always)]
650 pub fn srl(&self) -> SRL_R {
651 SRL_R::new(((self.bits >> 5) & 0x01) != 0)
652 }
653 #[doc = "Bit 6 - Lock Register Lock"]
654 #[inline(always)]
655 pub fn lrl(&self) -> LRL_R {
656 LRL_R::new(((self.bits >> 6) & 0x01) != 0)
657 }
658 #[doc = "Bit 8 - Tamper Time Seconds Lock"]
659 #[inline(always)]
660 pub fn ttsl(&self) -> TTSL_R {
661 TTSL_R::new(((self.bits >> 8) & 0x01) != 0)
662 }
663 #[doc = "Bit 9 - Monotonic Enable Lock"]
664 #[inline(always)]
665 pub fn mel(&self) -> MEL_R {
666 MEL_R::new(((self.bits >> 9) & 0x01) != 0)
667 }
668 #[doc = "Bit 10 - Monotonic Counter Low Lock"]
669 #[inline(always)]
670 pub fn mcll(&self) -> MCLL_R {
671 MCLL_R::new(((self.bits >> 10) & 0x01) != 0)
672 }
673 #[doc = "Bit 11 - Monotonic Counter High Lock"]
674 #[inline(always)]
675 pub fn mchl(&self) -> MCHL_R {
676 MCHL_R::new(((self.bits >> 11) & 0x01) != 0)
677 }
678}
679impl W {
680 #[doc = "Bit 3 - Time Compensation Lock"]
681 #[inline(always)]
682 pub fn tcl(&mut self) -> TCL_W {
683 TCL_W { w: self }
684 }
685 #[doc = "Bit 4 - Control Register Lock"]
686 #[inline(always)]
687 pub fn crl(&mut self) -> CRL_W {
688 CRL_W { w: self }
689 }
690 #[doc = "Bit 5 - Status Register Lock"]
691 #[inline(always)]
692 pub fn srl(&mut self) -> SRL_W {
693 SRL_W { w: self }
694 }
695 #[doc = "Bit 6 - Lock Register Lock"]
696 #[inline(always)]
697 pub fn lrl(&mut self) -> LRL_W {
698 LRL_W { w: self }
699 }
700 #[doc = "Bit 8 - Tamper Time Seconds Lock"]
701 #[inline(always)]
702 pub fn ttsl(&mut self) -> TTSL_W {
703 TTSL_W { w: self }
704 }
705 #[doc = "Bit 9 - Monotonic Enable Lock"]
706 #[inline(always)]
707 pub fn mel(&mut self) -> MEL_W {
708 MEL_W { w: self }
709 }
710 #[doc = "Bit 10 - Monotonic Counter Low Lock"]
711 #[inline(always)]
712 pub fn mcll(&mut self) -> MCLL_W {
713 MCLL_W { w: self }
714 }
715 #[doc = "Bit 11 - Monotonic Counter High Lock"]
716 #[inline(always)]
717 pub fn mchl(&mut self) -> MCHL_W {
718 MCHL_W { w: self }
719 }
720}