cc2650/crypto/
keywrittenarea.rs

1#[doc = r" Value read from the register"]
2pub struct R {
3    bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7    bits: u32,
8}
9impl super::KEYWRITTENAREA {
10    #[doc = r" Modifies the contents of the register"]
11    #[inline]
12    pub fn modify<F>(&self, f: F)
13    where
14        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15    {
16        let bits = self.register.get();
17        let r = R { bits: bits };
18        let mut w = W { bits: bits };
19        f(&r, &mut w);
20        self.register.set(w.bits);
21    }
22    #[doc = r" Reads the contents of the register"]
23    #[inline]
24    pub fn read(&self) -> R {
25        R { bits: self.register.get() }
26    }
27    #[doc = r" Writes to the register"]
28    #[inline]
29    pub fn write<F>(&self, f: F)
30    where
31        F: FnOnce(&mut W) -> &mut W,
32    {
33        let mut w = W::reset_value();
34        f(&mut w);
35        self.register.set(w.bits);
36    }
37    #[doc = r" Writes the reset value to the register"]
38    #[inline]
39    pub fn reset(&self) {
40        self.write(|w| w)
41    }
42}
43#[doc = r" Value of the field"]
44pub struct RESERVED8R {
45    bits: u32,
46}
47impl RESERVED8R {
48    #[doc = r" Value of the field as raw bits"]
49    #[inline]
50    pub fn bits(&self) -> u32 {
51        self.bits
52    }
53}
54#[doc = "Possible values of the field `RAM_AREA_WRITTEN7`"]
55#[derive(Clone, Copy, Debug, PartialEq)]
56pub enum RAM_AREA_WRITTEN7R {
57    #[doc = "This RAM area is written with valid key information"]
58    WRITTEN,
59    #[doc = "This RAM area is not written with valid key information"]
60    NOT_WRITTEN,
61}
62impl RAM_AREA_WRITTEN7R {
63    #[doc = r" Returns `true` if the bit is clear (0)"]
64    #[inline]
65    pub fn bit_is_clear(&self) -> bool {
66        !self.bit()
67    }
68    #[doc = r" Returns `true` if the bit is set (1)"]
69    #[inline]
70    pub fn bit_is_set(&self) -> bool {
71        self.bit()
72    }
73    #[doc = r" Value of the field as raw bits"]
74    #[inline]
75    pub fn bit(&self) -> bool {
76        match *self {
77            RAM_AREA_WRITTEN7R::WRITTEN => true,
78            RAM_AREA_WRITTEN7R::NOT_WRITTEN => false,
79        }
80    }
81    #[allow(missing_docs)]
82    #[doc(hidden)]
83    #[inline]
84    pub fn _from(value: bool) -> RAM_AREA_WRITTEN7R {
85        match value {
86            true => RAM_AREA_WRITTEN7R::WRITTEN,
87            false => RAM_AREA_WRITTEN7R::NOT_WRITTEN,
88        }
89    }
90    #[doc = "Checks if the value of the field is `WRITTEN`"]
91    #[inline]
92    pub fn is_written(&self) -> bool {
93        *self == RAM_AREA_WRITTEN7R::WRITTEN
94    }
95    #[doc = "Checks if the value of the field is `NOT_WRITTEN`"]
96    #[inline]
97    pub fn is_not_written(&self) -> bool {
98        *self == RAM_AREA_WRITTEN7R::NOT_WRITTEN
99    }
100}
101#[doc = "Possible values of the field `RAM_AREA_WRITTEN6`"]
102#[derive(Clone, Copy, Debug, PartialEq)]
103pub enum RAM_AREA_WRITTEN6R {
104    #[doc = "This RAM area is written with valid key information"]
105    WRITTEN,
106    #[doc = "This RAM area is not written with valid key information"]
107    NOT_WRITTEN,
108}
109impl RAM_AREA_WRITTEN6R {
110    #[doc = r" Returns `true` if the bit is clear (0)"]
111    #[inline]
112    pub fn bit_is_clear(&self) -> bool {
113        !self.bit()
114    }
115    #[doc = r" Returns `true` if the bit is set (1)"]
116    #[inline]
117    pub fn bit_is_set(&self) -> bool {
118        self.bit()
119    }
120    #[doc = r" Value of the field as raw bits"]
121    #[inline]
122    pub fn bit(&self) -> bool {
123        match *self {
124            RAM_AREA_WRITTEN6R::WRITTEN => true,
125            RAM_AREA_WRITTEN6R::NOT_WRITTEN => false,
126        }
127    }
128    #[allow(missing_docs)]
129    #[doc(hidden)]
130    #[inline]
131    pub fn _from(value: bool) -> RAM_AREA_WRITTEN6R {
132        match value {
133            true => RAM_AREA_WRITTEN6R::WRITTEN,
134            false => RAM_AREA_WRITTEN6R::NOT_WRITTEN,
135        }
136    }
137    #[doc = "Checks if the value of the field is `WRITTEN`"]
138    #[inline]
139    pub fn is_written(&self) -> bool {
140        *self == RAM_AREA_WRITTEN6R::WRITTEN
141    }
142    #[doc = "Checks if the value of the field is `NOT_WRITTEN`"]
143    #[inline]
144    pub fn is_not_written(&self) -> bool {
145        *self == RAM_AREA_WRITTEN6R::NOT_WRITTEN
146    }
147}
148#[doc = "Possible values of the field `RAM_AREA_WRITTEN5`"]
149#[derive(Clone, Copy, Debug, PartialEq)]
150pub enum RAM_AREA_WRITTEN5R {
151    #[doc = "This RAM area is written with valid key information"]
152    WRITTEN,
153    #[doc = "This RAM area is not written with valid key information"]
154    NOT_WRITTEN,
155}
156impl RAM_AREA_WRITTEN5R {
157    #[doc = r" Returns `true` if the bit is clear (0)"]
158    #[inline]
159    pub fn bit_is_clear(&self) -> bool {
160        !self.bit()
161    }
162    #[doc = r" Returns `true` if the bit is set (1)"]
163    #[inline]
164    pub fn bit_is_set(&self) -> bool {
165        self.bit()
166    }
167    #[doc = r" Value of the field as raw bits"]
168    #[inline]
169    pub fn bit(&self) -> bool {
170        match *self {
171            RAM_AREA_WRITTEN5R::WRITTEN => true,
172            RAM_AREA_WRITTEN5R::NOT_WRITTEN => false,
173        }
174    }
175    #[allow(missing_docs)]
176    #[doc(hidden)]
177    #[inline]
178    pub fn _from(value: bool) -> RAM_AREA_WRITTEN5R {
179        match value {
180            true => RAM_AREA_WRITTEN5R::WRITTEN,
181            false => RAM_AREA_WRITTEN5R::NOT_WRITTEN,
182        }
183    }
184    #[doc = "Checks if the value of the field is `WRITTEN`"]
185    #[inline]
186    pub fn is_written(&self) -> bool {
187        *self == RAM_AREA_WRITTEN5R::WRITTEN
188    }
189    #[doc = "Checks if the value of the field is `NOT_WRITTEN`"]
190    #[inline]
191    pub fn is_not_written(&self) -> bool {
192        *self == RAM_AREA_WRITTEN5R::NOT_WRITTEN
193    }
194}
195#[doc = "Possible values of the field `RAM_AREA_WRITTEN4`"]
196#[derive(Clone, Copy, Debug, PartialEq)]
197pub enum RAM_AREA_WRITTEN4R {
198    #[doc = "This RAM area is written with valid key information"]
199    WRITTEN,
200    #[doc = "This RAM area is not written with valid key information"]
201    NOT_WRITTEN,
202}
203impl RAM_AREA_WRITTEN4R {
204    #[doc = r" Returns `true` if the bit is clear (0)"]
205    #[inline]
206    pub fn bit_is_clear(&self) -> bool {
207        !self.bit()
208    }
209    #[doc = r" Returns `true` if the bit is set (1)"]
210    #[inline]
211    pub fn bit_is_set(&self) -> bool {
212        self.bit()
213    }
214    #[doc = r" Value of the field as raw bits"]
215    #[inline]
216    pub fn bit(&self) -> bool {
217        match *self {
218            RAM_AREA_WRITTEN4R::WRITTEN => true,
219            RAM_AREA_WRITTEN4R::NOT_WRITTEN => false,
220        }
221    }
222    #[allow(missing_docs)]
223    #[doc(hidden)]
224    #[inline]
225    pub fn _from(value: bool) -> RAM_AREA_WRITTEN4R {
226        match value {
227            true => RAM_AREA_WRITTEN4R::WRITTEN,
228            false => RAM_AREA_WRITTEN4R::NOT_WRITTEN,
229        }
230    }
231    #[doc = "Checks if the value of the field is `WRITTEN`"]
232    #[inline]
233    pub fn is_written(&self) -> bool {
234        *self == RAM_AREA_WRITTEN4R::WRITTEN
235    }
236    #[doc = "Checks if the value of the field is `NOT_WRITTEN`"]
237    #[inline]
238    pub fn is_not_written(&self) -> bool {
239        *self == RAM_AREA_WRITTEN4R::NOT_WRITTEN
240    }
241}
242#[doc = "Possible values of the field `RAM_AREA_WRITTEN3`"]
243#[derive(Clone, Copy, Debug, PartialEq)]
244pub enum RAM_AREA_WRITTEN3R {
245    #[doc = "This RAM area is written with valid key information"]
246    WRITTEN,
247    #[doc = "This RAM area is not written with valid key information"]
248    NOT_WRITTEN,
249}
250impl RAM_AREA_WRITTEN3R {
251    #[doc = r" Returns `true` if the bit is clear (0)"]
252    #[inline]
253    pub fn bit_is_clear(&self) -> bool {
254        !self.bit()
255    }
256    #[doc = r" Returns `true` if the bit is set (1)"]
257    #[inline]
258    pub fn bit_is_set(&self) -> bool {
259        self.bit()
260    }
261    #[doc = r" Value of the field as raw bits"]
262    #[inline]
263    pub fn bit(&self) -> bool {
264        match *self {
265            RAM_AREA_WRITTEN3R::WRITTEN => true,
266            RAM_AREA_WRITTEN3R::NOT_WRITTEN => false,
267        }
268    }
269    #[allow(missing_docs)]
270    #[doc(hidden)]
271    #[inline]
272    pub fn _from(value: bool) -> RAM_AREA_WRITTEN3R {
273        match value {
274            true => RAM_AREA_WRITTEN3R::WRITTEN,
275            false => RAM_AREA_WRITTEN3R::NOT_WRITTEN,
276        }
277    }
278    #[doc = "Checks if the value of the field is `WRITTEN`"]
279    #[inline]
280    pub fn is_written(&self) -> bool {
281        *self == RAM_AREA_WRITTEN3R::WRITTEN
282    }
283    #[doc = "Checks if the value of the field is `NOT_WRITTEN`"]
284    #[inline]
285    pub fn is_not_written(&self) -> bool {
286        *self == RAM_AREA_WRITTEN3R::NOT_WRITTEN
287    }
288}
289#[doc = "Possible values of the field `RAM_AREA_WRITTEN2`"]
290#[derive(Clone, Copy, Debug, PartialEq)]
291pub enum RAM_AREA_WRITTEN2R {
292    #[doc = "This RAM area is written with valid key information"]
293    WRITTEN,
294    #[doc = "This RAM area is not written with valid key information"]
295    NOT_WRITTEN,
296}
297impl RAM_AREA_WRITTEN2R {
298    #[doc = r" Returns `true` if the bit is clear (0)"]
299    #[inline]
300    pub fn bit_is_clear(&self) -> bool {
301        !self.bit()
302    }
303    #[doc = r" Returns `true` if the bit is set (1)"]
304    #[inline]
305    pub fn bit_is_set(&self) -> bool {
306        self.bit()
307    }
308    #[doc = r" Value of the field as raw bits"]
309    #[inline]
310    pub fn bit(&self) -> bool {
311        match *self {
312            RAM_AREA_WRITTEN2R::WRITTEN => true,
313            RAM_AREA_WRITTEN2R::NOT_WRITTEN => false,
314        }
315    }
316    #[allow(missing_docs)]
317    #[doc(hidden)]
318    #[inline]
319    pub fn _from(value: bool) -> RAM_AREA_WRITTEN2R {
320        match value {
321            true => RAM_AREA_WRITTEN2R::WRITTEN,
322            false => RAM_AREA_WRITTEN2R::NOT_WRITTEN,
323        }
324    }
325    #[doc = "Checks if the value of the field is `WRITTEN`"]
326    #[inline]
327    pub fn is_written(&self) -> bool {
328        *self == RAM_AREA_WRITTEN2R::WRITTEN
329    }
330    #[doc = "Checks if the value of the field is `NOT_WRITTEN`"]
331    #[inline]
332    pub fn is_not_written(&self) -> bool {
333        *self == RAM_AREA_WRITTEN2R::NOT_WRITTEN
334    }
335}
336#[doc = "Possible values of the field `RAM_AREA_WRITTEN1`"]
337#[derive(Clone, Copy, Debug, PartialEq)]
338pub enum RAM_AREA_WRITTEN1R {
339    #[doc = "This RAM area is written with valid key information"]
340    WRITTEN,
341    #[doc = "This RAM area is not written with valid key information"]
342    NOT_WRITTEN,
343}
344impl RAM_AREA_WRITTEN1R {
345    #[doc = r" Returns `true` if the bit is clear (0)"]
346    #[inline]
347    pub fn bit_is_clear(&self) -> bool {
348        !self.bit()
349    }
350    #[doc = r" Returns `true` if the bit is set (1)"]
351    #[inline]
352    pub fn bit_is_set(&self) -> bool {
353        self.bit()
354    }
355    #[doc = r" Value of the field as raw bits"]
356    #[inline]
357    pub fn bit(&self) -> bool {
358        match *self {
359            RAM_AREA_WRITTEN1R::WRITTEN => true,
360            RAM_AREA_WRITTEN1R::NOT_WRITTEN => false,
361        }
362    }
363    #[allow(missing_docs)]
364    #[doc(hidden)]
365    #[inline]
366    pub fn _from(value: bool) -> RAM_AREA_WRITTEN1R {
367        match value {
368            true => RAM_AREA_WRITTEN1R::WRITTEN,
369            false => RAM_AREA_WRITTEN1R::NOT_WRITTEN,
370        }
371    }
372    #[doc = "Checks if the value of the field is `WRITTEN`"]
373    #[inline]
374    pub fn is_written(&self) -> bool {
375        *self == RAM_AREA_WRITTEN1R::WRITTEN
376    }
377    #[doc = "Checks if the value of the field is `NOT_WRITTEN`"]
378    #[inline]
379    pub fn is_not_written(&self) -> bool {
380        *self == RAM_AREA_WRITTEN1R::NOT_WRITTEN
381    }
382}
383#[doc = "Possible values of the field `RAM_AREA_WRITTEN0`"]
384#[derive(Clone, Copy, Debug, PartialEq)]
385pub enum RAM_AREA_WRITTEN0R {
386    #[doc = "This RAM area is written with valid key information"]
387    WRITTEN,
388    #[doc = "This RAM area is not written with valid key information"]
389    NOT_WRITTEN,
390}
391impl RAM_AREA_WRITTEN0R {
392    #[doc = r" Returns `true` if the bit is clear (0)"]
393    #[inline]
394    pub fn bit_is_clear(&self) -> bool {
395        !self.bit()
396    }
397    #[doc = r" Returns `true` if the bit is set (1)"]
398    #[inline]
399    pub fn bit_is_set(&self) -> bool {
400        self.bit()
401    }
402    #[doc = r" Value of the field as raw bits"]
403    #[inline]
404    pub fn bit(&self) -> bool {
405        match *self {
406            RAM_AREA_WRITTEN0R::WRITTEN => true,
407            RAM_AREA_WRITTEN0R::NOT_WRITTEN => false,
408        }
409    }
410    #[allow(missing_docs)]
411    #[doc(hidden)]
412    #[inline]
413    pub fn _from(value: bool) -> RAM_AREA_WRITTEN0R {
414        match value {
415            true => RAM_AREA_WRITTEN0R::WRITTEN,
416            false => RAM_AREA_WRITTEN0R::NOT_WRITTEN,
417        }
418    }
419    #[doc = "Checks if the value of the field is `WRITTEN`"]
420    #[inline]
421    pub fn is_written(&self) -> bool {
422        *self == RAM_AREA_WRITTEN0R::WRITTEN
423    }
424    #[doc = "Checks if the value of the field is `NOT_WRITTEN`"]
425    #[inline]
426    pub fn is_not_written(&self) -> bool {
427        *self == RAM_AREA_WRITTEN0R::NOT_WRITTEN
428    }
429}
430#[doc = r" Proxy"]
431pub struct _RESERVED8W<'a> {
432    w: &'a mut W,
433}
434impl<'a> _RESERVED8W<'a> {
435    #[doc = r" Writes raw bits to the field"]
436    #[inline]
437    pub unsafe fn bits(self, value: u32) -> &'a mut W {
438        const MASK: u32 = 16777215;
439        const OFFSET: u8 = 8;
440        self.w.bits &= !((MASK as u32) << OFFSET);
441        self.w.bits |= ((value & MASK) as u32) << OFFSET;
442        self.w
443    }
444}
445#[doc = "Values that can be written to the field `RAM_AREA_WRITTEN7`"]
446#[derive(Clone, Copy, Debug, PartialEq)]
447pub enum RAM_AREA_WRITTEN7W {
448    #[doc = "This RAM area is written with valid key information"]
449    WRITTEN,
450    #[doc = "This RAM area is not written with valid key information"]
451    NOT_WRITTEN,
452}
453impl RAM_AREA_WRITTEN7W {
454    #[allow(missing_docs)]
455    #[doc(hidden)]
456    #[inline]
457    pub fn _bits(&self) -> bool {
458        match *self {
459            RAM_AREA_WRITTEN7W::WRITTEN => true,
460            RAM_AREA_WRITTEN7W::NOT_WRITTEN => false,
461        }
462    }
463}
464#[doc = r" Proxy"]
465pub struct _RAM_AREA_WRITTEN7W<'a> {
466    w: &'a mut W,
467}
468impl<'a> _RAM_AREA_WRITTEN7W<'a> {
469    #[doc = r" Writes `variant` to the field"]
470    #[inline]
471    pub fn variant(self, variant: RAM_AREA_WRITTEN7W) -> &'a mut W {
472        {
473            self.bit(variant._bits())
474        }
475    }
476    #[doc = "This RAM area is written with valid key information"]
477    #[inline]
478    pub fn written(self) -> &'a mut W {
479        self.variant(RAM_AREA_WRITTEN7W::WRITTEN)
480    }
481    #[doc = "This RAM area is not written with valid key information"]
482    #[inline]
483    pub fn not_written(self) -> &'a mut W {
484        self.variant(RAM_AREA_WRITTEN7W::NOT_WRITTEN)
485    }
486    #[doc = r" Sets the field bit"]
487    pub fn set_bit(self) -> &'a mut W {
488        self.bit(true)
489    }
490    #[doc = r" Clears the field bit"]
491    pub fn clear_bit(self) -> &'a mut W {
492        self.bit(false)
493    }
494    #[doc = r" Writes raw bits to the field"]
495    #[inline]
496    pub fn bit(self, value: bool) -> &'a mut W {
497        const MASK: bool = true;
498        const OFFSET: u8 = 7;
499        self.w.bits &= !((MASK as u32) << OFFSET);
500        self.w.bits |= ((value & MASK) as u32) << OFFSET;
501        self.w
502    }
503}
504#[doc = "Values that can be written to the field `RAM_AREA_WRITTEN6`"]
505#[derive(Clone, Copy, Debug, PartialEq)]
506pub enum RAM_AREA_WRITTEN6W {
507    #[doc = "This RAM area is written with valid key information"]
508    WRITTEN,
509    #[doc = "This RAM area is not written with valid key information"]
510    NOT_WRITTEN,
511}
512impl RAM_AREA_WRITTEN6W {
513    #[allow(missing_docs)]
514    #[doc(hidden)]
515    #[inline]
516    pub fn _bits(&self) -> bool {
517        match *self {
518            RAM_AREA_WRITTEN6W::WRITTEN => true,
519            RAM_AREA_WRITTEN6W::NOT_WRITTEN => false,
520        }
521    }
522}
523#[doc = r" Proxy"]
524pub struct _RAM_AREA_WRITTEN6W<'a> {
525    w: &'a mut W,
526}
527impl<'a> _RAM_AREA_WRITTEN6W<'a> {
528    #[doc = r" Writes `variant` to the field"]
529    #[inline]
530    pub fn variant(self, variant: RAM_AREA_WRITTEN6W) -> &'a mut W {
531        {
532            self.bit(variant._bits())
533        }
534    }
535    #[doc = "This RAM area is written with valid key information"]
536    #[inline]
537    pub fn written(self) -> &'a mut W {
538        self.variant(RAM_AREA_WRITTEN6W::WRITTEN)
539    }
540    #[doc = "This RAM area is not written with valid key information"]
541    #[inline]
542    pub fn not_written(self) -> &'a mut W {
543        self.variant(RAM_AREA_WRITTEN6W::NOT_WRITTEN)
544    }
545    #[doc = r" Sets the field bit"]
546    pub fn set_bit(self) -> &'a mut W {
547        self.bit(true)
548    }
549    #[doc = r" Clears the field bit"]
550    pub fn clear_bit(self) -> &'a mut W {
551        self.bit(false)
552    }
553    #[doc = r" Writes raw bits to the field"]
554    #[inline]
555    pub fn bit(self, value: bool) -> &'a mut W {
556        const MASK: bool = true;
557        const OFFSET: u8 = 6;
558        self.w.bits &= !((MASK as u32) << OFFSET);
559        self.w.bits |= ((value & MASK) as u32) << OFFSET;
560        self.w
561    }
562}
563#[doc = "Values that can be written to the field `RAM_AREA_WRITTEN5`"]
564#[derive(Clone, Copy, Debug, PartialEq)]
565pub enum RAM_AREA_WRITTEN5W {
566    #[doc = "This RAM area is written with valid key information"]
567    WRITTEN,
568    #[doc = "This RAM area is not written with valid key information"]
569    NOT_WRITTEN,
570}
571impl RAM_AREA_WRITTEN5W {
572    #[allow(missing_docs)]
573    #[doc(hidden)]
574    #[inline]
575    pub fn _bits(&self) -> bool {
576        match *self {
577            RAM_AREA_WRITTEN5W::WRITTEN => true,
578            RAM_AREA_WRITTEN5W::NOT_WRITTEN => false,
579        }
580    }
581}
582#[doc = r" Proxy"]
583pub struct _RAM_AREA_WRITTEN5W<'a> {
584    w: &'a mut W,
585}
586impl<'a> _RAM_AREA_WRITTEN5W<'a> {
587    #[doc = r" Writes `variant` to the field"]
588    #[inline]
589    pub fn variant(self, variant: RAM_AREA_WRITTEN5W) -> &'a mut W {
590        {
591            self.bit(variant._bits())
592        }
593    }
594    #[doc = "This RAM area is written with valid key information"]
595    #[inline]
596    pub fn written(self) -> &'a mut W {
597        self.variant(RAM_AREA_WRITTEN5W::WRITTEN)
598    }
599    #[doc = "This RAM area is not written with valid key information"]
600    #[inline]
601    pub fn not_written(self) -> &'a mut W {
602        self.variant(RAM_AREA_WRITTEN5W::NOT_WRITTEN)
603    }
604    #[doc = r" Sets the field bit"]
605    pub fn set_bit(self) -> &'a mut W {
606        self.bit(true)
607    }
608    #[doc = r" Clears the field bit"]
609    pub fn clear_bit(self) -> &'a mut W {
610        self.bit(false)
611    }
612    #[doc = r" Writes raw bits to the field"]
613    #[inline]
614    pub fn bit(self, value: bool) -> &'a mut W {
615        const MASK: bool = true;
616        const OFFSET: u8 = 5;
617        self.w.bits &= !((MASK as u32) << OFFSET);
618        self.w.bits |= ((value & MASK) as u32) << OFFSET;
619        self.w
620    }
621}
622#[doc = "Values that can be written to the field `RAM_AREA_WRITTEN4`"]
623#[derive(Clone, Copy, Debug, PartialEq)]
624pub enum RAM_AREA_WRITTEN4W {
625    #[doc = "This RAM area is written with valid key information"]
626    WRITTEN,
627    #[doc = "This RAM area is not written with valid key information"]
628    NOT_WRITTEN,
629}
630impl RAM_AREA_WRITTEN4W {
631    #[allow(missing_docs)]
632    #[doc(hidden)]
633    #[inline]
634    pub fn _bits(&self) -> bool {
635        match *self {
636            RAM_AREA_WRITTEN4W::WRITTEN => true,
637            RAM_AREA_WRITTEN4W::NOT_WRITTEN => false,
638        }
639    }
640}
641#[doc = r" Proxy"]
642pub struct _RAM_AREA_WRITTEN4W<'a> {
643    w: &'a mut W,
644}
645impl<'a> _RAM_AREA_WRITTEN4W<'a> {
646    #[doc = r" Writes `variant` to the field"]
647    #[inline]
648    pub fn variant(self, variant: RAM_AREA_WRITTEN4W) -> &'a mut W {
649        {
650            self.bit(variant._bits())
651        }
652    }
653    #[doc = "This RAM area is written with valid key information"]
654    #[inline]
655    pub fn written(self) -> &'a mut W {
656        self.variant(RAM_AREA_WRITTEN4W::WRITTEN)
657    }
658    #[doc = "This RAM area is not written with valid key information"]
659    #[inline]
660    pub fn not_written(self) -> &'a mut W {
661        self.variant(RAM_AREA_WRITTEN4W::NOT_WRITTEN)
662    }
663    #[doc = r" Sets the field bit"]
664    pub fn set_bit(self) -> &'a mut W {
665        self.bit(true)
666    }
667    #[doc = r" Clears the field bit"]
668    pub fn clear_bit(self) -> &'a mut W {
669        self.bit(false)
670    }
671    #[doc = r" Writes raw bits to the field"]
672    #[inline]
673    pub fn bit(self, value: bool) -> &'a mut W {
674        const MASK: bool = true;
675        const OFFSET: u8 = 4;
676        self.w.bits &= !((MASK as u32) << OFFSET);
677        self.w.bits |= ((value & MASK) as u32) << OFFSET;
678        self.w
679    }
680}
681#[doc = "Values that can be written to the field `RAM_AREA_WRITTEN3`"]
682#[derive(Clone, Copy, Debug, PartialEq)]
683pub enum RAM_AREA_WRITTEN3W {
684    #[doc = "This RAM area is written with valid key information"]
685    WRITTEN,
686    #[doc = "This RAM area is not written with valid key information"]
687    NOT_WRITTEN,
688}
689impl RAM_AREA_WRITTEN3W {
690    #[allow(missing_docs)]
691    #[doc(hidden)]
692    #[inline]
693    pub fn _bits(&self) -> bool {
694        match *self {
695            RAM_AREA_WRITTEN3W::WRITTEN => true,
696            RAM_AREA_WRITTEN3W::NOT_WRITTEN => false,
697        }
698    }
699}
700#[doc = r" Proxy"]
701pub struct _RAM_AREA_WRITTEN3W<'a> {
702    w: &'a mut W,
703}
704impl<'a> _RAM_AREA_WRITTEN3W<'a> {
705    #[doc = r" Writes `variant` to the field"]
706    #[inline]
707    pub fn variant(self, variant: RAM_AREA_WRITTEN3W) -> &'a mut W {
708        {
709            self.bit(variant._bits())
710        }
711    }
712    #[doc = "This RAM area is written with valid key information"]
713    #[inline]
714    pub fn written(self) -> &'a mut W {
715        self.variant(RAM_AREA_WRITTEN3W::WRITTEN)
716    }
717    #[doc = "This RAM area is not written with valid key information"]
718    #[inline]
719    pub fn not_written(self) -> &'a mut W {
720        self.variant(RAM_AREA_WRITTEN3W::NOT_WRITTEN)
721    }
722    #[doc = r" Sets the field bit"]
723    pub fn set_bit(self) -> &'a mut W {
724        self.bit(true)
725    }
726    #[doc = r" Clears the field bit"]
727    pub fn clear_bit(self) -> &'a mut W {
728        self.bit(false)
729    }
730    #[doc = r" Writes raw bits to the field"]
731    #[inline]
732    pub fn bit(self, value: bool) -> &'a mut W {
733        const MASK: bool = true;
734        const OFFSET: u8 = 3;
735        self.w.bits &= !((MASK as u32) << OFFSET);
736        self.w.bits |= ((value & MASK) as u32) << OFFSET;
737        self.w
738    }
739}
740#[doc = "Values that can be written to the field `RAM_AREA_WRITTEN2`"]
741#[derive(Clone, Copy, Debug, PartialEq)]
742pub enum RAM_AREA_WRITTEN2W {
743    #[doc = "This RAM area is written with valid key information"]
744    WRITTEN,
745    #[doc = "This RAM area is not written with valid key information"]
746    NOT_WRITTEN,
747}
748impl RAM_AREA_WRITTEN2W {
749    #[allow(missing_docs)]
750    #[doc(hidden)]
751    #[inline]
752    pub fn _bits(&self) -> bool {
753        match *self {
754            RAM_AREA_WRITTEN2W::WRITTEN => true,
755            RAM_AREA_WRITTEN2W::NOT_WRITTEN => false,
756        }
757    }
758}
759#[doc = r" Proxy"]
760pub struct _RAM_AREA_WRITTEN2W<'a> {
761    w: &'a mut W,
762}
763impl<'a> _RAM_AREA_WRITTEN2W<'a> {
764    #[doc = r" Writes `variant` to the field"]
765    #[inline]
766    pub fn variant(self, variant: RAM_AREA_WRITTEN2W) -> &'a mut W {
767        {
768            self.bit(variant._bits())
769        }
770    }
771    #[doc = "This RAM area is written with valid key information"]
772    #[inline]
773    pub fn written(self) -> &'a mut W {
774        self.variant(RAM_AREA_WRITTEN2W::WRITTEN)
775    }
776    #[doc = "This RAM area is not written with valid key information"]
777    #[inline]
778    pub fn not_written(self) -> &'a mut W {
779        self.variant(RAM_AREA_WRITTEN2W::NOT_WRITTEN)
780    }
781    #[doc = r" Sets the field bit"]
782    pub fn set_bit(self) -> &'a mut W {
783        self.bit(true)
784    }
785    #[doc = r" Clears the field bit"]
786    pub fn clear_bit(self) -> &'a mut W {
787        self.bit(false)
788    }
789    #[doc = r" Writes raw bits to the field"]
790    #[inline]
791    pub fn bit(self, value: bool) -> &'a mut W {
792        const MASK: bool = true;
793        const OFFSET: u8 = 2;
794        self.w.bits &= !((MASK as u32) << OFFSET);
795        self.w.bits |= ((value & MASK) as u32) << OFFSET;
796        self.w
797    }
798}
799#[doc = "Values that can be written to the field `RAM_AREA_WRITTEN1`"]
800#[derive(Clone, Copy, Debug, PartialEq)]
801pub enum RAM_AREA_WRITTEN1W {
802    #[doc = "This RAM area is written with valid key information"]
803    WRITTEN,
804    #[doc = "This RAM area is not written with valid key information"]
805    NOT_WRITTEN,
806}
807impl RAM_AREA_WRITTEN1W {
808    #[allow(missing_docs)]
809    #[doc(hidden)]
810    #[inline]
811    pub fn _bits(&self) -> bool {
812        match *self {
813            RAM_AREA_WRITTEN1W::WRITTEN => true,
814            RAM_AREA_WRITTEN1W::NOT_WRITTEN => false,
815        }
816    }
817}
818#[doc = r" Proxy"]
819pub struct _RAM_AREA_WRITTEN1W<'a> {
820    w: &'a mut W,
821}
822impl<'a> _RAM_AREA_WRITTEN1W<'a> {
823    #[doc = r" Writes `variant` to the field"]
824    #[inline]
825    pub fn variant(self, variant: RAM_AREA_WRITTEN1W) -> &'a mut W {
826        {
827            self.bit(variant._bits())
828        }
829    }
830    #[doc = "This RAM area is written with valid key information"]
831    #[inline]
832    pub fn written(self) -> &'a mut W {
833        self.variant(RAM_AREA_WRITTEN1W::WRITTEN)
834    }
835    #[doc = "This RAM area is not written with valid key information"]
836    #[inline]
837    pub fn not_written(self) -> &'a mut W {
838        self.variant(RAM_AREA_WRITTEN1W::NOT_WRITTEN)
839    }
840    #[doc = r" Sets the field bit"]
841    pub fn set_bit(self) -> &'a mut W {
842        self.bit(true)
843    }
844    #[doc = r" Clears the field bit"]
845    pub fn clear_bit(self) -> &'a mut W {
846        self.bit(false)
847    }
848    #[doc = r" Writes raw bits to the field"]
849    #[inline]
850    pub fn bit(self, value: bool) -> &'a mut W {
851        const MASK: bool = true;
852        const OFFSET: u8 = 1;
853        self.w.bits &= !((MASK as u32) << OFFSET);
854        self.w.bits |= ((value & MASK) as u32) << OFFSET;
855        self.w
856    }
857}
858#[doc = "Values that can be written to the field `RAM_AREA_WRITTEN0`"]
859#[derive(Clone, Copy, Debug, PartialEq)]
860pub enum RAM_AREA_WRITTEN0W {
861    #[doc = "This RAM area is written with valid key information"]
862    WRITTEN,
863    #[doc = "This RAM area is not written with valid key information"]
864    NOT_WRITTEN,
865}
866impl RAM_AREA_WRITTEN0W {
867    #[allow(missing_docs)]
868    #[doc(hidden)]
869    #[inline]
870    pub fn _bits(&self) -> bool {
871        match *self {
872            RAM_AREA_WRITTEN0W::WRITTEN => true,
873            RAM_AREA_WRITTEN0W::NOT_WRITTEN => false,
874        }
875    }
876}
877#[doc = r" Proxy"]
878pub struct _RAM_AREA_WRITTEN0W<'a> {
879    w: &'a mut W,
880}
881impl<'a> _RAM_AREA_WRITTEN0W<'a> {
882    #[doc = r" Writes `variant` to the field"]
883    #[inline]
884    pub fn variant(self, variant: RAM_AREA_WRITTEN0W) -> &'a mut W {
885        {
886            self.bit(variant._bits())
887        }
888    }
889    #[doc = "This RAM area is written with valid key information"]
890    #[inline]
891    pub fn written(self) -> &'a mut W {
892        self.variant(RAM_AREA_WRITTEN0W::WRITTEN)
893    }
894    #[doc = "This RAM area is not written with valid key information"]
895    #[inline]
896    pub fn not_written(self) -> &'a mut W {
897        self.variant(RAM_AREA_WRITTEN0W::NOT_WRITTEN)
898    }
899    #[doc = r" Sets the field bit"]
900    pub fn set_bit(self) -> &'a mut W {
901        self.bit(true)
902    }
903    #[doc = r" Clears the field bit"]
904    pub fn clear_bit(self) -> &'a mut W {
905        self.bit(false)
906    }
907    #[doc = r" Writes raw bits to the field"]
908    #[inline]
909    pub fn bit(self, value: bool) -> &'a mut W {
910        const MASK: bool = true;
911        const OFFSET: u8 = 0;
912        self.w.bits &= !((MASK as u32) << OFFSET);
913        self.w.bits |= ((value & MASK) as u32) << OFFSET;
914        self.w
915    }
916}
917impl R {
918    #[doc = r" Value of the register as raw bits"]
919    #[inline]
920    pub fn bits(&self) -> u32 {
921        self.bits
922    }
923    #[doc = "Bits 8:31 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
924    #[inline]
925    pub fn reserved8(&self) -> RESERVED8R {
926        let bits = {
927            const MASK: u32 = 16777215;
928            const OFFSET: u8 = 8;
929            ((self.bits >> OFFSET) & MASK as u32) as u32
930        };
931        RESERVED8R { bits }
932    }
933    #[doc = "Bit 7 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
934    #[inline]
935    pub fn ram_area_written7(&self) -> RAM_AREA_WRITTEN7R {
936        RAM_AREA_WRITTEN7R::_from({
937            const MASK: bool = true;
938            const OFFSET: u8 = 7;
939            ((self.bits >> OFFSET) & MASK as u32) != 0
940        })
941    }
942    #[doc = "Bit 6 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
943    #[inline]
944    pub fn ram_area_written6(&self) -> RAM_AREA_WRITTEN6R {
945        RAM_AREA_WRITTEN6R::_from({
946            const MASK: bool = true;
947            const OFFSET: u8 = 6;
948            ((self.bits >> OFFSET) & MASK as u32) != 0
949        })
950    }
951    #[doc = "Bit 5 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
952    #[inline]
953    pub fn ram_area_written5(&self) -> RAM_AREA_WRITTEN5R {
954        RAM_AREA_WRITTEN5R::_from({
955            const MASK: bool = true;
956            const OFFSET: u8 = 5;
957            ((self.bits >> OFFSET) & MASK as u32) != 0
958        })
959    }
960    #[doc = "Bit 4 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
961    #[inline]
962    pub fn ram_area_written4(&self) -> RAM_AREA_WRITTEN4R {
963        RAM_AREA_WRITTEN4R::_from({
964            const MASK: bool = true;
965            const OFFSET: u8 = 4;
966            ((self.bits >> OFFSET) & MASK as u32) != 0
967        })
968    }
969    #[doc = "Bit 3 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
970    #[inline]
971    pub fn ram_area_written3(&self) -> RAM_AREA_WRITTEN3R {
972        RAM_AREA_WRITTEN3R::_from({
973            const MASK: bool = true;
974            const OFFSET: u8 = 3;
975            ((self.bits >> OFFSET) & MASK as u32) != 0
976        })
977    }
978    #[doc = "Bit 2 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
979    #[inline]
980    pub fn ram_area_written2(&self) -> RAM_AREA_WRITTEN2R {
981        RAM_AREA_WRITTEN2R::_from({
982            const MASK: bool = true;
983            const OFFSET: u8 = 2;
984            ((self.bits >> OFFSET) & MASK as u32) != 0
985        })
986    }
987    #[doc = "Bit 1 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
988    #[inline]
989    pub fn ram_area_written1(&self) -> RAM_AREA_WRITTEN1R {
990        RAM_AREA_WRITTEN1R::_from({
991            const MASK: bool = true;
992            const OFFSET: u8 = 1;
993            ((self.bits >> OFFSET) & MASK as u32) != 0
994        })
995    }
996    #[doc = "Bit 0 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
997    #[inline]
998    pub fn ram_area_written0(&self) -> RAM_AREA_WRITTEN0R {
999        RAM_AREA_WRITTEN0R::_from({
1000            const MASK: bool = true;
1001            const OFFSET: u8 = 0;
1002            ((self.bits >> OFFSET) & MASK as u32) != 0
1003        })
1004    }
1005}
1006impl W {
1007    #[doc = r" Reset value of the register"]
1008    #[inline]
1009    pub fn reset_value() -> W {
1010        W { bits: 0 }
1011    }
1012    #[doc = r" Writes raw bits to the register"]
1013    #[inline]
1014    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1015        self.bits = bits;
1016        self
1017    }
1018    #[doc = "Bits 8:31 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
1019    #[inline]
1020    pub fn reserved8(&mut self) -> _RESERVED8W {
1021        _RESERVED8W { w: self }
1022    }
1023    #[doc = "Bit 7 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
1024    #[inline]
1025    pub fn ram_area_written7(&mut self) -> _RAM_AREA_WRITTEN7W {
1026        _RAM_AREA_WRITTEN7W { w: self }
1027    }
1028    #[doc = "Bit 6 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
1029    #[inline]
1030    pub fn ram_area_written6(&mut self) -> _RAM_AREA_WRITTEN6W {
1031        _RAM_AREA_WRITTEN6W { w: self }
1032    }
1033    #[doc = "Bit 5 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
1034    #[inline]
1035    pub fn ram_area_written5(&mut self) -> _RAM_AREA_WRITTEN5W {
1036        _RAM_AREA_WRITTEN5W { w: self }
1037    }
1038    #[doc = "Bit 4 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
1039    #[inline]
1040    pub fn ram_area_written4(&mut self) -> _RAM_AREA_WRITTEN4W {
1041        _RAM_AREA_WRITTEN4W { w: self }
1042    }
1043    #[doc = "Bit 3 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
1044    #[inline]
1045    pub fn ram_area_written3(&mut self) -> _RAM_AREA_WRITTEN3W {
1046        _RAM_AREA_WRITTEN3W { w: self }
1047    }
1048    #[doc = "Bit 2 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
1049    #[inline]
1050    pub fn ram_area_written2(&mut self) -> _RAM_AREA_WRITTEN2W {
1051        _RAM_AREA_WRITTEN2W { w: self }
1052    }
1053    #[doc = "Bit 1 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
1054    #[inline]
1055    pub fn ram_area_written1(&mut self) -> _RAM_AREA_WRITTEN1W {
1056        _RAM_AREA_WRITTEN1W { w: self }
1057    }
1058    #[doc = "Bit 0 - On read this bit returns the key area written status. This bit can be reset by writing a 1. Note: This register will be reset on a soft reset initiated by writing to DMASWRESET.RESET. After a soft reset, all keys must be rewritten to the key store memory."]
1059    #[inline]
1060    pub fn ram_area_written0(&mut self) -> _RAM_AREA_WRITTEN0W {
1061        _RAM_AREA_WRITTEN0W { w: self }
1062    }
1063}
cc2650/crypto/keywrittenarea.rs

cc2650/crypto/
keywrittenarea.rs
