1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232

#[doc = "Reader of register SECURE_BOOT_CFG"]
pub type R = crate::R<u32, super::SECURE_BOOT_CFG>;
#[doc = "Writer for register SECURE_BOOT_CFG"]
pub type W = crate::W<u32, super::SECURE_BOOT_CFG>;
#[doc = "Register SECURE_BOOT_CFG `reset()`'s with value 0"]
impl crate::ResetValue for super::SECURE_BOOT_CFG {
    type Type = u32;
    #[inline(always)]
    fn reset_value() -> Self::Type {
        0
    }
}
#[doc = "Reader of field `RSA4K`"]
pub type RSA4K_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `RSA4K`"]
pub struct RSA4K_W<'a> {
    w: &'a mut W,
}
impl<'a> RSA4K_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !0x03) | ((value as u32) & 0x03);
        self.w
    }
}
#[doc = "Reader of field `DICE_ENC_NXP_CFG`"]
pub type DICE_ENC_NXP_CFG_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `DICE_ENC_NXP_CFG`"]
pub struct DICE_ENC_NXP_CFG_W<'a> {
    w: &'a mut W,
}
impl<'a> DICE_ENC_NXP_CFG_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 2)) | (((value as u32) & 0x03) << 2);
        self.w
    }
}
#[doc = "Reader of field `DICE_CUST_CFG`"]
pub type DICE_CUST_CFG_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `DICE_CUST_CFG`"]
pub struct DICE_CUST_CFG_W<'a> {
    w: &'a mut W,
}
impl<'a> DICE_CUST_CFG_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 4)) | (((value as u32) & 0x03) << 4);
        self.w
    }
}
#[doc = "Reader of field `SKIP_DICE`"]
pub type SKIP_DICE_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `SKIP_DICE`"]
pub struct SKIP_DICE_W<'a> {
    w: &'a mut W,
}
impl<'a> SKIP_DICE_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 6)) | (((value as u32) & 0x03) << 6);
        self.w
    }
}
#[doc = "Reader of field `TZM_IMAGE_TYPE`"]
pub type TZM_IMAGE_TYPE_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `TZM_IMAGE_TYPE`"]
pub struct TZM_IMAGE_TYPE_W<'a> {
    w: &'a mut W,
}
impl<'a> TZM_IMAGE_TYPE_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 8)) | (((value as u32) & 0x03) << 8);
        self.w
    }
}
#[doc = "Reader of field `BLOCK_SET_KEY`"]
pub type BLOCK_SET_KEY_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `BLOCK_SET_KEY`"]
pub struct BLOCK_SET_KEY_W<'a> {
    w: &'a mut W,
}
impl<'a> BLOCK_SET_KEY_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 10)) | (((value as u32) & 0x03) << 10);
        self.w
    }
}
#[doc = "Reader of field `BLOCK_ENROLL`"]
pub type BLOCK_ENROLL_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `BLOCK_ENROLL`"]
pub struct BLOCK_ENROLL_W<'a> {
    w: &'a mut W,
}
impl<'a> BLOCK_ENROLL_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 12)) | (((value as u32) & 0x03) << 12);
        self.w
    }
}
#[doc = "Reader of field `DICE_INC_SEC_EPOCH`"]
pub type DICE_INC_SEC_EPOCH_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `DICE_INC_SEC_EPOCH`"]
pub struct DICE_INC_SEC_EPOCH_W<'a> {
    w: &'a mut W,
}
impl<'a> DICE_INC_SEC_EPOCH_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 14)) | (((value as u32) & 0x03) << 14);
        self.w
    }
}
#[doc = "Reader of field `SEC_BOOT_EN`"]
pub type SEC_BOOT_EN_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `SEC_BOOT_EN`"]
pub struct SEC_BOOT_EN_W<'a> {
    w: &'a mut W,
}
impl<'a> SEC_BOOT_EN_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x03 << 30)) | (((value as u32) & 0x03) << 30);
        self.w
    }
}
impl R {
    #[doc = "Bits 0:1 - Use RSA4096 keys only. 00- RSA2048 keys 01, 10, 11 - RSA4096 keys"]
    #[inline(always)]
    pub fn rsa4k(&self) -> RSA4K_R {
        RSA4K_R::new((self.bits & 0x03) as u8)
    }
    #[doc = "Bits 2:3 - Include NXP area in DICE computation. 00 - not included 01, 10, 11 - included"]
    #[inline(always)]
    pub fn dice_enc_nxp_cfg(&self) -> DICE_ENC_NXP_CFG_R {
        DICE_ENC_NXP_CFG_R::new(((self.bits >> 2) & 0x03) as u8)
    }
    #[doc = "Bits 4:5 - Include Customer factory area (including keys) in DICE computation. 00 - not included 01, 10, 11 - included"]
    #[inline(always)]
    pub fn dice_cust_cfg(&self) -> DICE_CUST_CFG_R {
        DICE_CUST_CFG_R::new(((self.bits >> 4) & 0x03) as u8)
    }
    #[doc = "Bits 6:7 - Skip DICE computation. 00 - Enable DICE 01,10,11 - Disable DICE"]
    #[inline(always)]
    pub fn skip_dice(&self) -> SKIP_DICE_R {
        SKIP_DICE_R::new(((self.bits >> 6) & 0x03) as u8)
    }
    #[doc = "Bits 8:9 - TrustZone-M mode. 00 - TZM mode in image header. 01 - Disable TZ-M. Boots to NonSecure. 10 - TZ-M enable boots to secure mode. 11 - Preset TZM checker from image header."]
    #[inline(always)]
    pub fn tzm_image_type(&self) -> TZM_IMAGE_TYPE_R {
        TZM_IMAGE_TYPE_R::new(((self.bits >> 8) & 0x03) as u8)
    }
    #[doc = "Bits 10:11 - Block PUF key code generation. 00 - Enable Key code generation 01, 10, 11 - Disable key code generation"]
    #[inline(always)]
    pub fn block_set_key(&self) -> BLOCK_SET_KEY_R {
        BLOCK_SET_KEY_R::new(((self.bits >> 10) & 0x03) as u8)
    }
    #[doc = "Bits 12:13 - Block PUF enrollement. 00 - Enable enrollment mode 01, 10, 11 - Disable further enrollmnet"]
    #[inline(always)]
    pub fn block_enroll(&self) -> BLOCK_ENROLL_R {
        BLOCK_ENROLL_R::new(((self.bits >> 12) & 0x03) as u8)
    }
    #[doc = "Bits 14:15 - Include security EPOCH in DICE"]
    #[inline(always)]
    pub fn dice_inc_sec_epoch(&self) -> DICE_INC_SEC_EPOCH_R {
        DICE_INC_SEC_EPOCH_R::new(((self.bits >> 14) & 0x03) as u8)
    }
    #[doc = "Bits 30:31 - Secure boot enable. 00 - Plain image (internal flash with or without CRC) 01, 10, 11 - Boot signed images. (internal flash, RSA signed)"]
    #[inline(always)]
    pub fn sec_boot_en(&self) -> SEC_BOOT_EN_R {
        SEC_BOOT_EN_R::new(((self.bits >> 30) & 0x03) as u8)
    }
}
impl W {
    #[doc = "Bits 0:1 - Use RSA4096 keys only. 00- RSA2048 keys 01, 10, 11 - RSA4096 keys"]
    #[inline(always)]
    pub fn rsa4k(&mut self) -> RSA4K_W {
        RSA4K_W { w: self }
    }
    #[doc = "Bits 2:3 - Include NXP area in DICE computation. 00 - not included 01, 10, 11 - included"]
    #[inline(always)]
    pub fn dice_enc_nxp_cfg(&mut self) -> DICE_ENC_NXP_CFG_W {
        DICE_ENC_NXP_CFG_W { w: self }
    }
    #[doc = "Bits 4:5 - Include Customer factory area (including keys) in DICE computation. 00 - not included 01, 10, 11 - included"]
    #[inline(always)]
    pub fn dice_cust_cfg(&mut self) -> DICE_CUST_CFG_W {
        DICE_CUST_CFG_W { w: self }
    }
    #[doc = "Bits 6:7 - Skip DICE computation. 00 - Enable DICE 01,10,11 - Disable DICE"]
    #[inline(always)]
    pub fn skip_dice(&mut self) -> SKIP_DICE_W {
        SKIP_DICE_W { w: self }
    }
    #[doc = "Bits 8:9 - TrustZone-M mode. 00 - TZM mode in image header. 01 - Disable TZ-M. Boots to NonSecure. 10 - TZ-M enable boots to secure mode. 11 - Preset TZM checker from image header."]
    #[inline(always)]
    pub fn tzm_image_type(&mut self) -> TZM_IMAGE_TYPE_W {
        TZM_IMAGE_TYPE_W { w: self }
    }
    #[doc = "Bits 10:11 - Block PUF key code generation. 00 - Enable Key code generation 01, 10, 11 - Disable key code generation"]
    #[inline(always)]
    pub fn block_set_key(&mut self) -> BLOCK_SET_KEY_W {
        BLOCK_SET_KEY_W { w: self }
    }
    #[doc = "Bits 12:13 - Block PUF enrollement. 00 - Enable enrollment mode 01, 10, 11 - Disable further enrollmnet"]
    #[inline(always)]
    pub fn block_enroll(&mut self) -> BLOCK_ENROLL_W {
        BLOCK_ENROLL_W { w: self }
    }
    #[doc = "Bits 14:15 - Include security EPOCH in DICE"]
    #[inline(always)]
    pub fn dice_inc_sec_epoch(&mut self) -> DICE_INC_SEC_EPOCH_W {
        DICE_INC_SEC_EPOCH_W { w: self }
    }
    #[doc = "Bits 30:31 - Secure boot enable. 00 - Plain image (internal flash with or without CRC) 01, 10, 11 - Boot signed images. (internal flash, RSA signed)"]
    #[inline(always)]
    pub fn sec_boot_en(&mut self) -> SEC_BOOT_EN_W {
        SEC_BOOT_EN_W { w: self }
    }
}