saml10e15a/nvmctrl/
addr.rs

1#[doc = "Reader of register ADDR"]
2pub type R = crate::R<u32, super::ADDR>;
3#[doc = "Writer for register ADDR"]
4pub type W = crate::W<u32, super::ADDR>;
5#[doc = "Register ADDR `reset()`'s with value 0"]
6impl crate::ResetValue for super::ADDR {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0
11    }
12}
13#[doc = "Reader of field `AOFFSET`"]
14pub type AOFFSET_R = crate::R<u16, u16>;
15#[doc = "Write proxy for field `AOFFSET`"]
16pub struct AOFFSET_W<'a> {
17    w: &'a mut W,
18}
19impl<'a> AOFFSET_W<'a> {
20    #[doc = r"Writes raw bits to the field"]
21    #[inline(always)]
22    pub unsafe fn bits(self, value: u16) -> &'a mut W {
23        self.w.bits = (self.w.bits & !0xffff) | ((value as u32) & 0xffff);
24        self.w
25    }
26}
27#[doc = "Possible values of the field `ARRAY`"]
28#[derive(Clone, Copy, Debug, PartialEq)]
29pub enum ARRAY_A {
30    #[doc = "FLASH Array"]
31    FLASH,
32    #[doc = "DATA FLASH Array"]
33    DATAFLASH,
34    #[doc = "Auxilliary Space"]
35    AUX,
36}
37impl crate::ToBits<u8> for ARRAY_A {
38    #[inline(always)]
39    fn _bits(&self) -> u8 {
40        match *self {
41            ARRAY_A::FLASH => 0,
42            ARRAY_A::DATAFLASH => 1,
43            ARRAY_A::AUX => 2,
44        }
45    }
46}
47#[doc = "Reader of field `ARRAY`"]
48pub type ARRAY_R = crate::R<u8, ARRAY_A>;
49impl ARRAY_R {
50    #[doc = r"Get enumerated values variant"]
51    #[inline(always)]
52    pub fn variant(&self) -> crate::Variant<u8, ARRAY_A> {
53        use crate::Variant::*;
54        match self.bits {
55            0 => Val(ARRAY_A::FLASH),
56            1 => Val(ARRAY_A::DATAFLASH),
57            2 => Val(ARRAY_A::AUX),
58            i => Res(i),
59        }
60    }
61    #[doc = "Checks if the value of the field is `FLASH`"]
62    #[inline(always)]
63    pub fn is_flash(&self) -> bool {
64        *self == ARRAY_A::FLASH
65    }
66    #[doc = "Checks if the value of the field is `DATAFLASH`"]
67    #[inline(always)]
68    pub fn is_dataflash(&self) -> bool {
69        *self == ARRAY_A::DATAFLASH
70    }
71    #[doc = "Checks if the value of the field is `AUX`"]
72    #[inline(always)]
73    pub fn is_aux(&self) -> bool {
74        *self == ARRAY_A::AUX
75    }
76}
77#[doc = "Write proxy for field `ARRAY`"]
78pub struct ARRAY_W<'a> {
79    w: &'a mut W,
80}
81impl<'a> ARRAY_W<'a> {
82    #[doc = r"Writes `variant` to the field"]
83    #[inline(always)]
84    pub fn variant(self, variant: ARRAY_A) -> &'a mut W {
85        use crate::ToBits;
86        unsafe { self.bits(variant._bits()) }
87    }
88    #[doc = "FLASH Array"]
89    #[inline(always)]
90    pub fn flash(self) -> &'a mut W {
91        self.variant(ARRAY_A::FLASH)
92    }
93    #[doc = "DATA FLASH Array"]
94    #[inline(always)]
95    pub fn dataflash(self) -> &'a mut W {
96        self.variant(ARRAY_A::DATAFLASH)
97    }
98    #[doc = "Auxilliary Space"]
99    #[inline(always)]
100    pub fn aux(self) -> &'a mut W {
101        self.variant(ARRAY_A::AUX)
102    }
103    #[doc = r"Writes raw bits to the field"]
104    #[inline(always)]
105    pub unsafe fn bits(self, value: u8) -> &'a mut W {
106        self.w.bits = (self.w.bits & !(0x03 << 22)) | (((value as u32) & 0x03) << 22);
107        self.w
108    }
109}
110impl R {
111    #[doc = "Bits 0:15 - NVM Address Offset In The Selected Array"]
112    #[inline(always)]
113    pub fn aoffset(&self) -> AOFFSET_R {
114        AOFFSET_R::new((self.bits & 0xffff) as u16)
115    }
116    #[doc = "Bits 22:23 - Array Select"]
117    #[inline(always)]
118    pub fn array(&self) -> ARRAY_R {
119        ARRAY_R::new(((self.bits >> 22) & 0x03) as u8)
120    }
121}
122impl W {
123    #[doc = "Bits 0:15 - NVM Address Offset In The Selected Array"]
124    #[inline(always)]
125    pub fn aoffset(&mut self) -> AOFFSET_W {
126        AOFFSET_W { w: self }
127    }
128    #[doc = "Bits 22:23 - Array Select"]
129    #[inline(always)]
130    pub fn array(&mut self) -> ARRAY_W {
131        ARRAY_W { w: self }
132    }
133}