cc13x2_cc26x2_pac/cpu_scs/
fpccr.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::FPCCR {
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 {
26            bits: self.register.get(),
27        }
28    }
29    #[doc = r" Writes to the register"]
30    #[inline]
31    pub fn write<F>(&self, f: F)
32    where
33        F: FnOnce(&mut W) -> &mut W,
34    {
35        let mut w = W::reset_value();
36        f(&mut w);
37        self.register.set(w.bits);
38    }
39    #[doc = r" Writes the reset value to the register"]
40    #[inline]
41    pub fn reset(&self) {
42        self.write(|w| w)
43    }
44}
45#[doc = r" Value of the field"]
46pub struct ASPENR {
47    bits: bool,
48}
49impl ASPENR {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bit(&self) -> bool {
53        self.bits
54    }
55    #[doc = r" Returns `true` if the bit is clear (0)"]
56    #[inline]
57    pub fn bit_is_clear(&self) -> bool {
58        !self.bit()
59    }
60    #[doc = r" Returns `true` if the bit is set (1)"]
61    #[inline]
62    pub fn bit_is_set(&self) -> bool {
63        self.bit()
64    }
65}
66#[doc = r" Value of the field"]
67pub struct LSPENR {
68    bits: bool,
69}
70impl LSPENR {
71    #[doc = r" Value of the field as raw bits"]
72    #[inline]
73    pub fn bit(&self) -> bool {
74        self.bits
75    }
76    #[doc = r" Returns `true` if the bit is clear (0)"]
77    #[inline]
78    pub fn bit_is_clear(&self) -> bool {
79        !self.bit()
80    }
81    #[doc = r" Returns `true` if the bit is set (1)"]
82    #[inline]
83    pub fn bit_is_set(&self) -> bool {
84        self.bit()
85    }
86}
87#[doc = r" Value of the field"]
88pub struct RESERVED9R {
89    bits: u32,
90}
91impl RESERVED9R {
92    #[doc = r" Value of the field as raw bits"]
93    #[inline]
94    pub fn bits(&self) -> u32 {
95        self.bits
96    }
97}
98#[doc = r" Value of the field"]
99pub struct MONRDYR {
100    bits: bool,
101}
102impl MONRDYR {
103    #[doc = r" Value of the field as raw bits"]
104    #[inline]
105    pub fn bit(&self) -> bool {
106        self.bits
107    }
108    #[doc = r" Returns `true` if the bit is clear (0)"]
109    #[inline]
110    pub fn bit_is_clear(&self) -> bool {
111        !self.bit()
112    }
113    #[doc = r" Returns `true` if the bit is set (1)"]
114    #[inline]
115    pub fn bit_is_set(&self) -> bool {
116        self.bit()
117    }
118}
119#[doc = r" Value of the field"]
120pub struct RESERVED7R {
121    bits: bool,
122}
123impl RESERVED7R {
124    #[doc = r" Value of the field as raw bits"]
125    #[inline]
126    pub fn bit(&self) -> bool {
127        self.bits
128    }
129    #[doc = r" Returns `true` if the bit is clear (0)"]
130    #[inline]
131    pub fn bit_is_clear(&self) -> bool {
132        !self.bit()
133    }
134    #[doc = r" Returns `true` if the bit is set (1)"]
135    #[inline]
136    pub fn bit_is_set(&self) -> bool {
137        self.bit()
138    }
139}
140#[doc = r" Value of the field"]
141pub struct BFRDYR {
142    bits: bool,
143}
144impl BFRDYR {
145    #[doc = r" Value of the field as raw bits"]
146    #[inline]
147    pub fn bit(&self) -> bool {
148        self.bits
149    }
150    #[doc = r" Returns `true` if the bit is clear (0)"]
151    #[inline]
152    pub fn bit_is_clear(&self) -> bool {
153        !self.bit()
154    }
155    #[doc = r" Returns `true` if the bit is set (1)"]
156    #[inline]
157    pub fn bit_is_set(&self) -> bool {
158        self.bit()
159    }
160}
161#[doc = r" Value of the field"]
162pub struct MMRDYR {
163    bits: bool,
164}
165impl MMRDYR {
166    #[doc = r" Value of the field as raw bits"]
167    #[inline]
168    pub fn bit(&self) -> bool {
169        self.bits
170    }
171    #[doc = r" Returns `true` if the bit is clear (0)"]
172    #[inline]
173    pub fn bit_is_clear(&self) -> bool {
174        !self.bit()
175    }
176    #[doc = r" Returns `true` if the bit is set (1)"]
177    #[inline]
178    pub fn bit_is_set(&self) -> bool {
179        self.bit()
180    }
181}
182#[doc = r" Value of the field"]
183pub struct HFRDYR {
184    bits: bool,
185}
186impl HFRDYR {
187    #[doc = r" Value of the field as raw bits"]
188    #[inline]
189    pub fn bit(&self) -> bool {
190        self.bits
191    }
192    #[doc = r" Returns `true` if the bit is clear (0)"]
193    #[inline]
194    pub fn bit_is_clear(&self) -> bool {
195        !self.bit()
196    }
197    #[doc = r" Returns `true` if the bit is set (1)"]
198    #[inline]
199    pub fn bit_is_set(&self) -> bool {
200        self.bit()
201    }
202}
203#[doc = r" Value of the field"]
204pub struct THREADR {
205    bits: bool,
206}
207impl THREADR {
208    #[doc = r" Value of the field as raw bits"]
209    #[inline]
210    pub fn bit(&self) -> bool {
211        self.bits
212    }
213    #[doc = r" Returns `true` if the bit is clear (0)"]
214    #[inline]
215    pub fn bit_is_clear(&self) -> bool {
216        !self.bit()
217    }
218    #[doc = r" Returns `true` if the bit is set (1)"]
219    #[inline]
220    pub fn bit_is_set(&self) -> bool {
221        self.bit()
222    }
223}
224#[doc = r" Value of the field"]
225pub struct RESERVED2R {
226    bits: bool,
227}
228impl RESERVED2R {
229    #[doc = r" Value of the field as raw bits"]
230    #[inline]
231    pub fn bit(&self) -> bool {
232        self.bits
233    }
234    #[doc = r" Returns `true` if the bit is clear (0)"]
235    #[inline]
236    pub fn bit_is_clear(&self) -> bool {
237        !self.bit()
238    }
239    #[doc = r" Returns `true` if the bit is set (1)"]
240    #[inline]
241    pub fn bit_is_set(&self) -> bool {
242        self.bit()
243    }
244}
245#[doc = r" Value of the field"]
246pub struct USERR {
247    bits: bool,
248}
249impl USERR {
250    #[doc = r" Value of the field as raw bits"]
251    #[inline]
252    pub fn bit(&self) -> bool {
253        self.bits
254    }
255    #[doc = r" Returns `true` if the bit is clear (0)"]
256    #[inline]
257    pub fn bit_is_clear(&self) -> bool {
258        !self.bit()
259    }
260    #[doc = r" Returns `true` if the bit is set (1)"]
261    #[inline]
262    pub fn bit_is_set(&self) -> bool {
263        self.bit()
264    }
265}
266#[doc = r" Value of the field"]
267pub struct LSPACTR {
268    bits: bool,
269}
270impl LSPACTR {
271    #[doc = r" Value of the field as raw bits"]
272    #[inline]
273    pub fn bit(&self) -> bool {
274        self.bits
275    }
276    #[doc = r" Returns `true` if the bit is clear (0)"]
277    #[inline]
278    pub fn bit_is_clear(&self) -> bool {
279        !self.bit()
280    }
281    #[doc = r" Returns `true` if the bit is set (1)"]
282    #[inline]
283    pub fn bit_is_set(&self) -> bool {
284        self.bit()
285    }
286}
287#[doc = r" Proxy"]
288pub struct _ASPENW<'a> {
289    w: &'a mut W,
290}
291impl<'a> _ASPENW<'a> {
292    #[doc = r" Sets the field bit"]
293    pub fn set_bit(self) -> &'a mut W {
294        self.bit(true)
295    }
296    #[doc = r" Clears the field bit"]
297    pub fn clear_bit(self) -> &'a mut W {
298        self.bit(false)
299    }
300    #[doc = r" Writes raw bits to the field"]
301    #[inline]
302    pub fn bit(self, value: bool) -> &'a mut W {
303        const MASK: bool = true;
304        const OFFSET: u8 = 31;
305        self.w.bits &= !((MASK as u32) << OFFSET);
306        self.w.bits |= ((value & MASK) as u32) << OFFSET;
307        self.w
308    }
309}
310#[doc = r" Proxy"]
311pub struct _LSPENW<'a> {
312    w: &'a mut W,
313}
314impl<'a> _LSPENW<'a> {
315    #[doc = r" Sets the field bit"]
316    pub fn set_bit(self) -> &'a mut W {
317        self.bit(true)
318    }
319    #[doc = r" Clears the field bit"]
320    pub fn clear_bit(self) -> &'a mut W {
321        self.bit(false)
322    }
323    #[doc = r" Writes raw bits to the field"]
324    #[inline]
325    pub fn bit(self, value: bool) -> &'a mut W {
326        const MASK: bool = true;
327        const OFFSET: u8 = 30;
328        self.w.bits &= !((MASK as u32) << OFFSET);
329        self.w.bits |= ((value & MASK) as u32) << OFFSET;
330        self.w
331    }
332}
333#[doc = r" Proxy"]
334pub struct _RESERVED9W<'a> {
335    w: &'a mut W,
336}
337impl<'a> _RESERVED9W<'a> {
338    #[doc = r" Writes raw bits to the field"]
339    #[inline]
340    pub unsafe fn bits(self, value: u32) -> &'a mut W {
341        const MASK: u32 = 2097151;
342        const OFFSET: u8 = 9;
343        self.w.bits &= !((MASK as u32) << OFFSET);
344        self.w.bits |= ((value & MASK) as u32) << OFFSET;
345        self.w
346    }
347}
348#[doc = r" Proxy"]
349pub struct _MONRDYW<'a> {
350    w: &'a mut W,
351}
352impl<'a> _MONRDYW<'a> {
353    #[doc = r" Sets the field bit"]
354    pub fn set_bit(self) -> &'a mut W {
355        self.bit(true)
356    }
357    #[doc = r" Clears the field bit"]
358    pub fn clear_bit(self) -> &'a mut W {
359        self.bit(false)
360    }
361    #[doc = r" Writes raw bits to the field"]
362    #[inline]
363    pub fn bit(self, value: bool) -> &'a mut W {
364        const MASK: bool = true;
365        const OFFSET: u8 = 8;
366        self.w.bits &= !((MASK as u32) << OFFSET);
367        self.w.bits |= ((value & MASK) as u32) << OFFSET;
368        self.w
369    }
370}
371#[doc = r" Proxy"]
372pub struct _RESERVED7W<'a> {
373    w: &'a mut W,
374}
375impl<'a> _RESERVED7W<'a> {
376    #[doc = r" Sets the field bit"]
377    pub fn set_bit(self) -> &'a mut W {
378        self.bit(true)
379    }
380    #[doc = r" Clears the field bit"]
381    pub fn clear_bit(self) -> &'a mut W {
382        self.bit(false)
383    }
384    #[doc = r" Writes raw bits to the field"]
385    #[inline]
386    pub fn bit(self, value: bool) -> &'a mut W {
387        const MASK: bool = true;
388        const OFFSET: u8 = 7;
389        self.w.bits &= !((MASK as u32) << OFFSET);
390        self.w.bits |= ((value & MASK) as u32) << OFFSET;
391        self.w
392    }
393}
394#[doc = r" Proxy"]
395pub struct _BFRDYW<'a> {
396    w: &'a mut W,
397}
398impl<'a> _BFRDYW<'a> {
399    #[doc = r" Sets the field bit"]
400    pub fn set_bit(self) -> &'a mut W {
401        self.bit(true)
402    }
403    #[doc = r" Clears the field bit"]
404    pub fn clear_bit(self) -> &'a mut W {
405        self.bit(false)
406    }
407    #[doc = r" Writes raw bits to the field"]
408    #[inline]
409    pub fn bit(self, value: bool) -> &'a mut W {
410        const MASK: bool = true;
411        const OFFSET: u8 = 6;
412        self.w.bits &= !((MASK as u32) << OFFSET);
413        self.w.bits |= ((value & MASK) as u32) << OFFSET;
414        self.w
415    }
416}
417#[doc = r" Proxy"]
418pub struct _MMRDYW<'a> {
419    w: &'a mut W,
420}
421impl<'a> _MMRDYW<'a> {
422    #[doc = r" Sets the field bit"]
423    pub fn set_bit(self) -> &'a mut W {
424        self.bit(true)
425    }
426    #[doc = r" Clears the field bit"]
427    pub fn clear_bit(self) -> &'a mut W {
428        self.bit(false)
429    }
430    #[doc = r" Writes raw bits to the field"]
431    #[inline]
432    pub fn bit(self, value: bool) -> &'a mut W {
433        const MASK: bool = true;
434        const OFFSET: u8 = 5;
435        self.w.bits &= !((MASK as u32) << OFFSET);
436        self.w.bits |= ((value & MASK) as u32) << OFFSET;
437        self.w
438    }
439}
440#[doc = r" Proxy"]
441pub struct _HFRDYW<'a> {
442    w: &'a mut W,
443}
444impl<'a> _HFRDYW<'a> {
445    #[doc = r" Sets the field bit"]
446    pub fn set_bit(self) -> &'a mut W {
447        self.bit(true)
448    }
449    #[doc = r" Clears the field bit"]
450    pub fn clear_bit(self) -> &'a mut W {
451        self.bit(false)
452    }
453    #[doc = r" Writes raw bits to the field"]
454    #[inline]
455    pub fn bit(self, value: bool) -> &'a mut W {
456        const MASK: bool = true;
457        const OFFSET: u8 = 4;
458        self.w.bits &= !((MASK as u32) << OFFSET);
459        self.w.bits |= ((value & MASK) as u32) << OFFSET;
460        self.w
461    }
462}
463#[doc = r" Proxy"]
464pub struct _THREADW<'a> {
465    w: &'a mut W,
466}
467impl<'a> _THREADW<'a> {
468    #[doc = r" Sets the field bit"]
469    pub fn set_bit(self) -> &'a mut W {
470        self.bit(true)
471    }
472    #[doc = r" Clears the field bit"]
473    pub fn clear_bit(self) -> &'a mut W {
474        self.bit(false)
475    }
476    #[doc = r" Writes raw bits to the field"]
477    #[inline]
478    pub fn bit(self, value: bool) -> &'a mut W {
479        const MASK: bool = true;
480        const OFFSET: u8 = 3;
481        self.w.bits &= !((MASK as u32) << OFFSET);
482        self.w.bits |= ((value & MASK) as u32) << OFFSET;
483        self.w
484    }
485}
486#[doc = r" Proxy"]
487pub struct _RESERVED2W<'a> {
488    w: &'a mut W,
489}
490impl<'a> _RESERVED2W<'a> {
491    #[doc = r" Sets the field bit"]
492    pub fn set_bit(self) -> &'a mut W {
493        self.bit(true)
494    }
495    #[doc = r" Clears the field bit"]
496    pub fn clear_bit(self) -> &'a mut W {
497        self.bit(false)
498    }
499    #[doc = r" Writes raw bits to the field"]
500    #[inline]
501    pub fn bit(self, value: bool) -> &'a mut W {
502        const MASK: bool = true;
503        const OFFSET: u8 = 2;
504        self.w.bits &= !((MASK as u32) << OFFSET);
505        self.w.bits |= ((value & MASK) as u32) << OFFSET;
506        self.w
507    }
508}
509#[doc = r" Proxy"]
510pub struct _USERW<'a> {
511    w: &'a mut W,
512}
513impl<'a> _USERW<'a> {
514    #[doc = r" Sets the field bit"]
515    pub fn set_bit(self) -> &'a mut W {
516        self.bit(true)
517    }
518    #[doc = r" Clears the field bit"]
519    pub fn clear_bit(self) -> &'a mut W {
520        self.bit(false)
521    }
522    #[doc = r" Writes raw bits to the field"]
523    #[inline]
524    pub fn bit(self, value: bool) -> &'a mut W {
525        const MASK: bool = true;
526        const OFFSET: u8 = 1;
527        self.w.bits &= !((MASK as u32) << OFFSET);
528        self.w.bits |= ((value & MASK) as u32) << OFFSET;
529        self.w
530    }
531}
532#[doc = r" Proxy"]
533pub struct _LSPACTW<'a> {
534    w: &'a mut W,
535}
536impl<'a> _LSPACTW<'a> {
537    #[doc = r" Sets the field bit"]
538    pub fn set_bit(self) -> &'a mut W {
539        self.bit(true)
540    }
541    #[doc = r" Clears the field bit"]
542    pub fn clear_bit(self) -> &'a mut W {
543        self.bit(false)
544    }
545    #[doc = r" Writes raw bits to the field"]
546    #[inline]
547    pub fn bit(self, value: bool) -> &'a mut W {
548        const MASK: bool = true;
549        const OFFSET: u8 = 0;
550        self.w.bits &= !((MASK as u32) << OFFSET);
551        self.w.bits |= ((value & MASK) as u32) << OFFSET;
552        self.w
553    }
554}
555impl R {
556    #[doc = r" Value of the register as raw bits"]
557    #[inline]
558    pub fn bits(&self) -> u32 {
559        self.bits
560    }
561    #[doc = "Bit 31 - 31:31\\] Automatic State Preservation enable. When this bit is set is will cause bit \\[2\\] of the Special CONTROL register to be set (FPCA) on execution of a floating point instruction which results in the floating point state automatically being preserved on exception entry."]
562    #[inline]
563    pub fn aspen(&self) -> ASPENR {
564        let bits = {
565            const MASK: bool = true;
566            const OFFSET: u8 = 31;
567            ((self.bits >> OFFSET) & MASK as u32) != 0
568        };
569        ASPENR { bits }
570    }
571    #[doc = "Bit 30 - 30:30\\] Lazy State Preservation enable. Lazy state preservation is when the processor performs a context save, space on the stack is reserved for the floating point state but it is not stacked until the new context performs a floating point operation. 0: Disable automatic lazy state preservation for floating-point context. 1: Enable automatic lazy state preservation for floating-point context."]
572    #[inline]
573    pub fn lspen(&self) -> LSPENR {
574        let bits = {
575            const MASK: bool = true;
576            const OFFSET: u8 = 30;
577            ((self.bits >> OFFSET) & MASK as u32) != 0
578        };
579        LSPENR { bits }
580    }
581    #[doc = "Bits 9:29 - 29:9\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
582    #[inline]
583    pub fn reserved9(&self) -> RESERVED9R {
584        let bits = {
585            const MASK: u32 = 2097151;
586            const OFFSET: u8 = 9;
587            ((self.bits >> OFFSET) & MASK as u32) as u32
588        };
589        RESERVED9R { bits }
590    }
591    #[doc = "Bit 8 - 8:8\\] Indicates whether the the software executing when the processor allocated the FP stack frame was able to set the DebugMonitor exception to pending. 0: DebugMonitor is disabled or priority did not permit setting DEMCR.MON_PEND when the floating-point stack frame was allocated. 1: DebugMonitor is enabled and priority permits setting DEMCR.MON_PEND when the floating-point stack frame was allocated."]
592    #[inline]
593    pub fn monrdy(&self) -> MONRDYR {
594        let bits = {
595            const MASK: bool = true;
596            const OFFSET: u8 = 8;
597            ((self.bits >> OFFSET) & MASK as u32) != 0
598        };
599        MONRDYR { bits }
600    }
601    #[doc = "Bit 7 - 7:7\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
602    #[inline]
603    pub fn reserved7(&self) -> RESERVED7R {
604        let bits = {
605            const MASK: bool = true;
606            const OFFSET: u8 = 7;
607            ((self.bits >> OFFSET) & MASK as u32) != 0
608        };
609        RESERVED7R { bits }
610    }
611    #[doc = "Bit 6 - 6:6\\] Indicates whether the software executing when the processor allocated the FP stack frame was able to set the BusFault exception to pending. 0: BusFault is disabled or priority did not permit setting the BusFault handler to the pending state when the floating-point stack frame was allocated. 1: BusFault is enabled and priority permitted setting the BusFault handler to the pending state when the floating-point stack frame was allocated."]
612    #[inline]
613    pub fn bfrdy(&self) -> BFRDYR {
614        let bits = {
615            const MASK: bool = true;
616            const OFFSET: u8 = 6;
617            ((self.bits >> OFFSET) & MASK as u32) != 0
618        };
619        BFRDYR { bits }
620    }
621    #[doc = "Bit 5 - 5:5\\] Indicates whether the software executing when the processor allocated the FP stack frame was able to set the MemManage exception to pending. 0: MemManage is disabled or priority did not permit setting the MemManage handler to the pending state when the floating-point stack frame was allocated. 1: MemManage is enabled and priority permitted setting the MemManage handler to the pending state when the floating-point stack frame was allocated."]
622    #[inline]
623    pub fn mmrdy(&self) -> MMRDYR {
624        let bits = {
625            const MASK: bool = true;
626            const OFFSET: u8 = 5;
627            ((self.bits >> OFFSET) & MASK as u32) != 0
628        };
629        MMRDYR { bits }
630    }
631    #[doc = "Bit 4 - 4:4\\] Indicates whether the software executing when the processor allocated the FP stack frame was able to set the HardFault exception to pending. 0: Priority did not permit setting the HardFault handler to the pending state when the floating-point stack frame was allocated. 1: Priority permitted setting the HardFault handler to the pending state when the floating-point stack frame was allocated."]
632    #[inline]
633    pub fn hfrdy(&self) -> HFRDYR {
634        let bits = {
635            const MASK: bool = true;
636            const OFFSET: u8 = 4;
637            ((self.bits >> OFFSET) & MASK as u32) != 0
638        };
639        HFRDYR { bits }
640    }
641    #[doc = "Bit 3 - 3:3\\] Indicates the processor mode was Thread when it allocated the FP stack frame. 0: Mode was not Thread Mode when the floating-point stack frame was allocated. 1: Mode was Thread Mode when the floating-point stack frame was allocated."]
642    #[inline]
643    pub fn thread(&self) -> THREADR {
644        let bits = {
645            const MASK: bool = true;
646            const OFFSET: u8 = 3;
647            ((self.bits >> OFFSET) & MASK as u32) != 0
648        };
649        THREADR { bits }
650    }
651    #[doc = "Bit 2 - 2:2\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
652    #[inline]
653    pub fn reserved2(&self) -> RESERVED2R {
654        let bits = {
655            const MASK: bool = true;
656            const OFFSET: u8 = 2;
657            ((self.bits >> OFFSET) & MASK as u32) != 0
658        };
659        RESERVED2R { bits }
660    }
661    #[doc = "Bit 1 - 1:1\\] Indicates the privilege level of the software executing was User (Unpriviledged) when the processor allocated the FP stack frame: 0: Privilege level was not user when the floating-point stack frame was allocated. 1: Privilege level was user when the floating-point stack frame was allocated."]
662    #[inline]
663    pub fn user(&self) -> USERR {
664        let bits = {
665            const MASK: bool = true;
666            const OFFSET: u8 = 1;
667            ((self.bits >> OFFSET) & MASK as u32) != 0
668        };
669        USERR { bits }
670    }
671    #[doc = "Bit 0 - 0:0\\] Indicates whether Lazy preservation of the FP state is active: 0: Lazy state preservation is not active. 1: Lazy state preservation is active. floating-point stack frame has been allocated but saving state to it has been deferred."]
672    #[inline]
673    pub fn lspact(&self) -> LSPACTR {
674        let bits = {
675            const MASK: bool = true;
676            const OFFSET: u8 = 0;
677            ((self.bits >> OFFSET) & MASK as u32) != 0
678        };
679        LSPACTR { bits }
680    }
681}
682impl W {
683    #[doc = r" Reset value of the register"]
684    #[inline]
685    pub fn reset_value() -> W {
686        W { bits: 3221225472 }
687    }
688    #[doc = r" Writes raw bits to the register"]
689    #[inline]
690    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
691        self.bits = bits;
692        self
693    }
694    #[doc = "Bit 31 - 31:31\\] Automatic State Preservation enable. When this bit is set is will cause bit \\[2\\] of the Special CONTROL register to be set (FPCA) on execution of a floating point instruction which results in the floating point state automatically being preserved on exception entry."]
695    #[inline]
696    pub fn aspen(&mut self) -> _ASPENW {
697        _ASPENW { w: self }
698    }
699    #[doc = "Bit 30 - 30:30\\] Lazy State Preservation enable. Lazy state preservation is when the processor performs a context save, space on the stack is reserved for the floating point state but it is not stacked until the new context performs a floating point operation. 0: Disable automatic lazy state preservation for floating-point context. 1: Enable automatic lazy state preservation for floating-point context."]
700    #[inline]
701    pub fn lspen(&mut self) -> _LSPENW {
702        _LSPENW { w: self }
703    }
704    #[doc = "Bits 9:29 - 29:9\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
705    #[inline]
706    pub fn reserved9(&mut self) -> _RESERVED9W {
707        _RESERVED9W { w: self }
708    }
709    #[doc = "Bit 8 - 8:8\\] Indicates whether the the software executing when the processor allocated the FP stack frame was able to set the DebugMonitor exception to pending. 0: DebugMonitor is disabled or priority did not permit setting DEMCR.MON_PEND when the floating-point stack frame was allocated. 1: DebugMonitor is enabled and priority permits setting DEMCR.MON_PEND when the floating-point stack frame was allocated."]
710    #[inline]
711    pub fn monrdy(&mut self) -> _MONRDYW {
712        _MONRDYW { w: self }
713    }
714    #[doc = "Bit 7 - 7:7\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
715    #[inline]
716    pub fn reserved7(&mut self) -> _RESERVED7W {
717        _RESERVED7W { w: self }
718    }
719    #[doc = "Bit 6 - 6:6\\] Indicates whether the software executing when the processor allocated the FP stack frame was able to set the BusFault exception to pending. 0: BusFault is disabled or priority did not permit setting the BusFault handler to the pending state when the floating-point stack frame was allocated. 1: BusFault is enabled and priority permitted setting the BusFault handler to the pending state when the floating-point stack frame was allocated."]
720    #[inline]
721    pub fn bfrdy(&mut self) -> _BFRDYW {
722        _BFRDYW { w: self }
723    }
724    #[doc = "Bit 5 - 5:5\\] Indicates whether the software executing when the processor allocated the FP stack frame was able to set the MemManage exception to pending. 0: MemManage is disabled or priority did not permit setting the MemManage handler to the pending state when the floating-point stack frame was allocated. 1: MemManage is enabled and priority permitted setting the MemManage handler to the pending state when the floating-point stack frame was allocated."]
725    #[inline]
726    pub fn mmrdy(&mut self) -> _MMRDYW {
727        _MMRDYW { w: self }
728    }
729    #[doc = "Bit 4 - 4:4\\] Indicates whether the software executing when the processor allocated the FP stack frame was able to set the HardFault exception to pending. 0: Priority did not permit setting the HardFault handler to the pending state when the floating-point stack frame was allocated. 1: Priority permitted setting the HardFault handler to the pending state when the floating-point stack frame was allocated."]
730    #[inline]
731    pub fn hfrdy(&mut self) -> _HFRDYW {
732        _HFRDYW { w: self }
733    }
734    #[doc = "Bit 3 - 3:3\\] Indicates the processor mode was Thread when it allocated the FP stack frame. 0: Mode was not Thread Mode when the floating-point stack frame was allocated. 1: Mode was Thread Mode when the floating-point stack frame was allocated."]
735    #[inline]
736    pub fn thread(&mut self) -> _THREADW {
737        _THREADW { w: self }
738    }
739    #[doc = "Bit 2 - 2:2\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
740    #[inline]
741    pub fn reserved2(&mut self) -> _RESERVED2W {
742        _RESERVED2W { w: self }
743    }
744    #[doc = "Bit 1 - 1:1\\] Indicates the privilege level of the software executing was User (Unpriviledged) when the processor allocated the FP stack frame: 0: Privilege level was not user when the floating-point stack frame was allocated. 1: Privilege level was user when the floating-point stack frame was allocated."]
745    #[inline]
746    pub fn user(&mut self) -> _USERW {
747        _USERW { w: self }
748    }
749    #[doc = "Bit 0 - 0:0\\] Indicates whether Lazy preservation of the FP state is active: 0: Lazy state preservation is not active. 1: Lazy state preservation is active. floating-point stack frame has been allocated but saving state to it has been deferred."]
750    #[inline]
751    pub fn lspact(&mut self) -> _LSPACTW {
752        _LSPACTW { w: self }
753    }
754}
cc13x2_cc26x2_pac/cpu_scs/fpccr.rs

cc13x2_cc26x2_pac/cpu_scs/
fpccr.rs
