1#[doc = "Register `MPRA` reader"]
2pub struct R(crate::R<MPRA_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<MPRA_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<MPRA_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<MPRA_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `MPRA` writer"]
17pub struct W(crate::W<MPRA_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<MPRA_SPEC>;
20 #[inline(always)]
21 fn deref(&self) -> &Self::Target {
22 &self.0
23 }
24}
25impl core::ops::DerefMut for W {
26 #[inline(always)]
27 fn deref_mut(&mut self) -> &mut Self::Target {
28 &mut self.0
29 }
30}
31impl From<crate::W<MPRA_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<MPRA_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Master 2 Privilege Level\n\nValue on reset: 1"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum MPL2_A {
40 #[doc = "0: Accesses from this master are forced to user-mode."]
41 _0 = 0,
42 #[doc = "1: Accesses from this master are not forced to user-mode."]
43 _1 = 1,
44}
45impl From<MPL2_A> for bool {
46 #[inline(always)]
47 fn from(variant: MPL2_A) -> Self {
48 variant as u8 != 0
49 }
50}
51#[doc = "Field `MPL2` reader - Master 2 Privilege Level"]
52pub struct MPL2_R(crate::FieldReader<bool, MPL2_A>);
53impl MPL2_R {
54 #[inline(always)]
55 pub(crate) fn new(bits: bool) -> Self {
56 MPL2_R(crate::FieldReader::new(bits))
57 }
58 #[doc = r"Get enumerated values variant"]
59 #[inline(always)]
60 pub fn variant(&self) -> MPL2_A {
61 match self.bits {
62 false => MPL2_A::_0,
63 true => MPL2_A::_1,
64 }
65 }
66 #[doc = "Checks if the value of the field is `_0`"]
67 #[inline(always)]
68 pub fn is_0(&self) -> bool {
69 **self == MPL2_A::_0
70 }
71 #[doc = "Checks if the value of the field is `_1`"]
72 #[inline(always)]
73 pub fn is_1(&self) -> bool {
74 **self == MPL2_A::_1
75 }
76}
77impl core::ops::Deref for MPL2_R {
78 type Target = crate::FieldReader<bool, MPL2_A>;
79 #[inline(always)]
80 fn deref(&self) -> &Self::Target {
81 &self.0
82 }
83}
84#[doc = "Field `MPL2` writer - Master 2 Privilege Level"]
85pub struct MPL2_W<'a> {
86 w: &'a mut W,
87}
88impl<'a> MPL2_W<'a> {
89 #[doc = r"Writes `variant` to the field"]
90 #[inline(always)]
91 pub fn variant(self, variant: MPL2_A) -> &'a mut W {
92 self.bit(variant.into())
93 }
94 #[doc = "Accesses from this master are forced to user-mode."]
95 #[inline(always)]
96 pub fn _0(self) -> &'a mut W {
97 self.variant(MPL2_A::_0)
98 }
99 #[doc = "Accesses from this master are not forced to user-mode."]
100 #[inline(always)]
101 pub fn _1(self) -> &'a mut W {
102 self.variant(MPL2_A::_1)
103 }
104 #[doc = r"Sets the field bit"]
105 #[inline(always)]
106 pub fn set_bit(self) -> &'a mut W {
107 self.bit(true)
108 }
109 #[doc = r"Clears the field bit"]
110 #[inline(always)]
111 pub fn clear_bit(self) -> &'a mut W {
112 self.bit(false)
113 }
114 #[doc = r"Writes raw bits to the field"]
115 #[inline(always)]
116 pub fn bit(self, value: bool) -> &'a mut W {
117 self.w.bits = (self.w.bits & !(0x01 << 20)) | ((value as u32 & 0x01) << 20);
118 self.w
119 }
120}
121#[doc = "Master 2 Trusted For Writes\n\nValue on reset: 1"]
122#[derive(Clone, Copy, Debug, PartialEq)]
123pub enum MTW2_A {
124 #[doc = "0: This master is not trusted for write accesses."]
125 _0 = 0,
126 #[doc = "1: This master is trusted for write accesses."]
127 _1 = 1,
128}
129impl From<MTW2_A> for bool {
130 #[inline(always)]
131 fn from(variant: MTW2_A) -> Self {
132 variant as u8 != 0
133 }
134}
135#[doc = "Field `MTW2` reader - Master 2 Trusted For Writes"]
136pub struct MTW2_R(crate::FieldReader<bool, MTW2_A>);
137impl MTW2_R {
138 #[inline(always)]
139 pub(crate) fn new(bits: bool) -> Self {
140 MTW2_R(crate::FieldReader::new(bits))
141 }
142 #[doc = r"Get enumerated values variant"]
143 #[inline(always)]
144 pub fn variant(&self) -> MTW2_A {
145 match self.bits {
146 false => MTW2_A::_0,
147 true => MTW2_A::_1,
148 }
149 }
150 #[doc = "Checks if the value of the field is `_0`"]
151 #[inline(always)]
152 pub fn is_0(&self) -> bool {
153 **self == MTW2_A::_0
154 }
155 #[doc = "Checks if the value of the field is `_1`"]
156 #[inline(always)]
157 pub fn is_1(&self) -> bool {
158 **self == MTW2_A::_1
159 }
160}
161impl core::ops::Deref for MTW2_R {
162 type Target = crate::FieldReader<bool, MTW2_A>;
163 #[inline(always)]
164 fn deref(&self) -> &Self::Target {
165 &self.0
166 }
167}
168#[doc = "Field `MTW2` writer - Master 2 Trusted For Writes"]
169pub struct MTW2_W<'a> {
170 w: &'a mut W,
171}
172impl<'a> MTW2_W<'a> {
173 #[doc = r"Writes `variant` to the field"]
174 #[inline(always)]
175 pub fn variant(self, variant: MTW2_A) -> &'a mut W {
176 self.bit(variant.into())
177 }
178 #[doc = "This master is not trusted for write accesses."]
179 #[inline(always)]
180 pub fn _0(self) -> &'a mut W {
181 self.variant(MTW2_A::_0)
182 }
183 #[doc = "This master is trusted for write accesses."]
184 #[inline(always)]
185 pub fn _1(self) -> &'a mut W {
186 self.variant(MTW2_A::_1)
187 }
188 #[doc = r"Sets the field bit"]
189 #[inline(always)]
190 pub fn set_bit(self) -> &'a mut W {
191 self.bit(true)
192 }
193 #[doc = r"Clears the field bit"]
194 #[inline(always)]
195 pub fn clear_bit(self) -> &'a mut W {
196 self.bit(false)
197 }
198 #[doc = r"Writes raw bits to the field"]
199 #[inline(always)]
200 pub fn bit(self, value: bool) -> &'a mut W {
201 self.w.bits = (self.w.bits & !(0x01 << 21)) | ((value as u32 & 0x01) << 21);
202 self.w
203 }
204}
205#[doc = "Master 2 Trusted For Read\n\nValue on reset: 1"]
206#[derive(Clone, Copy, Debug, PartialEq)]
207pub enum MTR2_A {
208 #[doc = "0: This master is not trusted for read accesses."]
209 _0 = 0,
210 #[doc = "1: This master is trusted for read accesses."]
211 _1 = 1,
212}
213impl From<MTR2_A> for bool {
214 #[inline(always)]
215 fn from(variant: MTR2_A) -> Self {
216 variant as u8 != 0
217 }
218}
219#[doc = "Field `MTR2` reader - Master 2 Trusted For Read"]
220pub struct MTR2_R(crate::FieldReader<bool, MTR2_A>);
221impl MTR2_R {
222 #[inline(always)]
223 pub(crate) fn new(bits: bool) -> Self {
224 MTR2_R(crate::FieldReader::new(bits))
225 }
226 #[doc = r"Get enumerated values variant"]
227 #[inline(always)]
228 pub fn variant(&self) -> MTR2_A {
229 match self.bits {
230 false => MTR2_A::_0,
231 true => MTR2_A::_1,
232 }
233 }
234 #[doc = "Checks if the value of the field is `_0`"]
235 #[inline(always)]
236 pub fn is_0(&self) -> bool {
237 **self == MTR2_A::_0
238 }
239 #[doc = "Checks if the value of the field is `_1`"]
240 #[inline(always)]
241 pub fn is_1(&self) -> bool {
242 **self == MTR2_A::_1
243 }
244}
245impl core::ops::Deref for MTR2_R {
246 type Target = crate::FieldReader<bool, MTR2_A>;
247 #[inline(always)]
248 fn deref(&self) -> &Self::Target {
249 &self.0
250 }
251}
252#[doc = "Field `MTR2` writer - Master 2 Trusted For Read"]
253pub struct MTR2_W<'a> {
254 w: &'a mut W,
255}
256impl<'a> MTR2_W<'a> {
257 #[doc = r"Writes `variant` to the field"]
258 #[inline(always)]
259 pub fn variant(self, variant: MTR2_A) -> &'a mut W {
260 self.bit(variant.into())
261 }
262 #[doc = "This master is not trusted for read accesses."]
263 #[inline(always)]
264 pub fn _0(self) -> &'a mut W {
265 self.variant(MTR2_A::_0)
266 }
267 #[doc = "This master is trusted for read accesses."]
268 #[inline(always)]
269 pub fn _1(self) -> &'a mut W {
270 self.variant(MTR2_A::_1)
271 }
272 #[doc = r"Sets the field bit"]
273 #[inline(always)]
274 pub fn set_bit(self) -> &'a mut W {
275 self.bit(true)
276 }
277 #[doc = r"Clears the field bit"]
278 #[inline(always)]
279 pub fn clear_bit(self) -> &'a mut W {
280 self.bit(false)
281 }
282 #[doc = r"Writes raw bits to the field"]
283 #[inline(always)]
284 pub fn bit(self, value: bool) -> &'a mut W {
285 self.w.bits = (self.w.bits & !(0x01 << 22)) | ((value as u32 & 0x01) << 22);
286 self.w
287 }
288}
289#[doc = "Master 1 Privilege Level\n\nValue on reset: 1"]
290#[derive(Clone, Copy, Debug, PartialEq)]
291pub enum MPL1_A {
292 #[doc = "0: Accesses from this master are forced to user-mode."]
293 _0 = 0,
294 #[doc = "1: Accesses from this master are not forced to user-mode."]
295 _1 = 1,
296}
297impl From<MPL1_A> for bool {
298 #[inline(always)]
299 fn from(variant: MPL1_A) -> Self {
300 variant as u8 != 0
301 }
302}
303#[doc = "Field `MPL1` reader - Master 1 Privilege Level"]
304pub struct MPL1_R(crate::FieldReader<bool, MPL1_A>);
305impl MPL1_R {
306 #[inline(always)]
307 pub(crate) fn new(bits: bool) -> Self {
308 MPL1_R(crate::FieldReader::new(bits))
309 }
310 #[doc = r"Get enumerated values variant"]
311 #[inline(always)]
312 pub fn variant(&self) -> MPL1_A {
313 match self.bits {
314 false => MPL1_A::_0,
315 true => MPL1_A::_1,
316 }
317 }
318 #[doc = "Checks if the value of the field is `_0`"]
319 #[inline(always)]
320 pub fn is_0(&self) -> bool {
321 **self == MPL1_A::_0
322 }
323 #[doc = "Checks if the value of the field is `_1`"]
324 #[inline(always)]
325 pub fn is_1(&self) -> bool {
326 **self == MPL1_A::_1
327 }
328}
329impl core::ops::Deref for MPL1_R {
330 type Target = crate::FieldReader<bool, MPL1_A>;
331 #[inline(always)]
332 fn deref(&self) -> &Self::Target {
333 &self.0
334 }
335}
336#[doc = "Field `MPL1` writer - Master 1 Privilege Level"]
337pub struct MPL1_W<'a> {
338 w: &'a mut W,
339}
340impl<'a> MPL1_W<'a> {
341 #[doc = r"Writes `variant` to the field"]
342 #[inline(always)]
343 pub fn variant(self, variant: MPL1_A) -> &'a mut W {
344 self.bit(variant.into())
345 }
346 #[doc = "Accesses from this master are forced to user-mode."]
347 #[inline(always)]
348 pub fn _0(self) -> &'a mut W {
349 self.variant(MPL1_A::_0)
350 }
351 #[doc = "Accesses from this master are not forced to user-mode."]
352 #[inline(always)]
353 pub fn _1(self) -> &'a mut W {
354 self.variant(MPL1_A::_1)
355 }
356 #[doc = r"Sets the field bit"]
357 #[inline(always)]
358 pub fn set_bit(self) -> &'a mut W {
359 self.bit(true)
360 }
361 #[doc = r"Clears the field bit"]
362 #[inline(always)]
363 pub fn clear_bit(self) -> &'a mut W {
364 self.bit(false)
365 }
366 #[doc = r"Writes raw bits to the field"]
367 #[inline(always)]
368 pub fn bit(self, value: bool) -> &'a mut W {
369 self.w.bits = (self.w.bits & !(0x01 << 24)) | ((value as u32 & 0x01) << 24);
370 self.w
371 }
372}
373#[doc = "Master 1 Trusted for Writes\n\nValue on reset: 1"]
374#[derive(Clone, Copy, Debug, PartialEq)]
375pub enum MTW1_A {
376 #[doc = "0: This master is not trusted for write accesses."]
377 _0 = 0,
378 #[doc = "1: This master is trusted for write accesses."]
379 _1 = 1,
380}
381impl From<MTW1_A> for bool {
382 #[inline(always)]
383 fn from(variant: MTW1_A) -> Self {
384 variant as u8 != 0
385 }
386}
387#[doc = "Field `MTW1` reader - Master 1 Trusted for Writes"]
388pub struct MTW1_R(crate::FieldReader<bool, MTW1_A>);
389impl MTW1_R {
390 #[inline(always)]
391 pub(crate) fn new(bits: bool) -> Self {
392 MTW1_R(crate::FieldReader::new(bits))
393 }
394 #[doc = r"Get enumerated values variant"]
395 #[inline(always)]
396 pub fn variant(&self) -> MTW1_A {
397 match self.bits {
398 false => MTW1_A::_0,
399 true => MTW1_A::_1,
400 }
401 }
402 #[doc = "Checks if the value of the field is `_0`"]
403 #[inline(always)]
404 pub fn is_0(&self) -> bool {
405 **self == MTW1_A::_0
406 }
407 #[doc = "Checks if the value of the field is `_1`"]
408 #[inline(always)]
409 pub fn is_1(&self) -> bool {
410 **self == MTW1_A::_1
411 }
412}
413impl core::ops::Deref for MTW1_R {
414 type Target = crate::FieldReader<bool, MTW1_A>;
415 #[inline(always)]
416 fn deref(&self) -> &Self::Target {
417 &self.0
418 }
419}
420#[doc = "Field `MTW1` writer - Master 1 Trusted for Writes"]
421pub struct MTW1_W<'a> {
422 w: &'a mut W,
423}
424impl<'a> MTW1_W<'a> {
425 #[doc = r"Writes `variant` to the field"]
426 #[inline(always)]
427 pub fn variant(self, variant: MTW1_A) -> &'a mut W {
428 self.bit(variant.into())
429 }
430 #[doc = "This master is not trusted for write accesses."]
431 #[inline(always)]
432 pub fn _0(self) -> &'a mut W {
433 self.variant(MTW1_A::_0)
434 }
435 #[doc = "This master is trusted for write accesses."]
436 #[inline(always)]
437 pub fn _1(self) -> &'a mut W {
438 self.variant(MTW1_A::_1)
439 }
440 #[doc = r"Sets the field bit"]
441 #[inline(always)]
442 pub fn set_bit(self) -> &'a mut W {
443 self.bit(true)
444 }
445 #[doc = r"Clears the field bit"]
446 #[inline(always)]
447 pub fn clear_bit(self) -> &'a mut W {
448 self.bit(false)
449 }
450 #[doc = r"Writes raw bits to the field"]
451 #[inline(always)]
452 pub fn bit(self, value: bool) -> &'a mut W {
453 self.w.bits = (self.w.bits & !(0x01 << 25)) | ((value as u32 & 0x01) << 25);
454 self.w
455 }
456}
457#[doc = "Master 1 Trusted for Read\n\nValue on reset: 1"]
458#[derive(Clone, Copy, Debug, PartialEq)]
459pub enum MTR1_A {
460 #[doc = "0: This master is not trusted for read accesses."]
461 _0 = 0,
462 #[doc = "1: This master is trusted for read accesses."]
463 _1 = 1,
464}
465impl From<MTR1_A> for bool {
466 #[inline(always)]
467 fn from(variant: MTR1_A) -> Self {
468 variant as u8 != 0
469 }
470}
471#[doc = "Field `MTR1` reader - Master 1 Trusted for Read"]
472pub struct MTR1_R(crate::FieldReader<bool, MTR1_A>);
473impl MTR1_R {
474 #[inline(always)]
475 pub(crate) fn new(bits: bool) -> Self {
476 MTR1_R(crate::FieldReader::new(bits))
477 }
478 #[doc = r"Get enumerated values variant"]
479 #[inline(always)]
480 pub fn variant(&self) -> MTR1_A {
481 match self.bits {
482 false => MTR1_A::_0,
483 true => MTR1_A::_1,
484 }
485 }
486 #[doc = "Checks if the value of the field is `_0`"]
487 #[inline(always)]
488 pub fn is_0(&self) -> bool {
489 **self == MTR1_A::_0
490 }
491 #[doc = "Checks if the value of the field is `_1`"]
492 #[inline(always)]
493 pub fn is_1(&self) -> bool {
494 **self == MTR1_A::_1
495 }
496}
497impl core::ops::Deref for MTR1_R {
498 type Target = crate::FieldReader<bool, MTR1_A>;
499 #[inline(always)]
500 fn deref(&self) -> &Self::Target {
501 &self.0
502 }
503}
504#[doc = "Field `MTR1` writer - Master 1 Trusted for Read"]
505pub struct MTR1_W<'a> {
506 w: &'a mut W,
507}
508impl<'a> MTR1_W<'a> {
509 #[doc = r"Writes `variant` to the field"]
510 #[inline(always)]
511 pub fn variant(self, variant: MTR1_A) -> &'a mut W {
512 self.bit(variant.into())
513 }
514 #[doc = "This master is not trusted for read accesses."]
515 #[inline(always)]
516 pub fn _0(self) -> &'a mut W {
517 self.variant(MTR1_A::_0)
518 }
519 #[doc = "This master is trusted for read accesses."]
520 #[inline(always)]
521 pub fn _1(self) -> &'a mut W {
522 self.variant(MTR1_A::_1)
523 }
524 #[doc = r"Sets the field bit"]
525 #[inline(always)]
526 pub fn set_bit(self) -> &'a mut W {
527 self.bit(true)
528 }
529 #[doc = r"Clears the field bit"]
530 #[inline(always)]
531 pub fn clear_bit(self) -> &'a mut W {
532 self.bit(false)
533 }
534 #[doc = r"Writes raw bits to the field"]
535 #[inline(always)]
536 pub fn bit(self, value: bool) -> &'a mut W {
537 self.w.bits = (self.w.bits & !(0x01 << 26)) | ((value as u32 & 0x01) << 26);
538 self.w
539 }
540}
541#[doc = "Master 0 Privilege Level\n\nValue on reset: 1"]
542#[derive(Clone, Copy, Debug, PartialEq)]
543pub enum MPL0_A {
544 #[doc = "0: Accesses from this master are forced to user-mode."]
545 _0 = 0,
546 #[doc = "1: Accesses from this master are not forced to user-mode."]
547 _1 = 1,
548}
549impl From<MPL0_A> for bool {
550 #[inline(always)]
551 fn from(variant: MPL0_A) -> Self {
552 variant as u8 != 0
553 }
554}
555#[doc = "Field `MPL0` reader - Master 0 Privilege Level"]
556pub struct MPL0_R(crate::FieldReader<bool, MPL0_A>);
557impl MPL0_R {
558 #[inline(always)]
559 pub(crate) fn new(bits: bool) -> Self {
560 MPL0_R(crate::FieldReader::new(bits))
561 }
562 #[doc = r"Get enumerated values variant"]
563 #[inline(always)]
564 pub fn variant(&self) -> MPL0_A {
565 match self.bits {
566 false => MPL0_A::_0,
567 true => MPL0_A::_1,
568 }
569 }
570 #[doc = "Checks if the value of the field is `_0`"]
571 #[inline(always)]
572 pub fn is_0(&self) -> bool {
573 **self == MPL0_A::_0
574 }
575 #[doc = "Checks if the value of the field is `_1`"]
576 #[inline(always)]
577 pub fn is_1(&self) -> bool {
578 **self == MPL0_A::_1
579 }
580}
581impl core::ops::Deref for MPL0_R {
582 type Target = crate::FieldReader<bool, MPL0_A>;
583 #[inline(always)]
584 fn deref(&self) -> &Self::Target {
585 &self.0
586 }
587}
588#[doc = "Field `MPL0` writer - Master 0 Privilege Level"]
589pub struct MPL0_W<'a> {
590 w: &'a mut W,
591}
592impl<'a> MPL0_W<'a> {
593 #[doc = r"Writes `variant` to the field"]
594 #[inline(always)]
595 pub fn variant(self, variant: MPL0_A) -> &'a mut W {
596 self.bit(variant.into())
597 }
598 #[doc = "Accesses from this master are forced to user-mode."]
599 #[inline(always)]
600 pub fn _0(self) -> &'a mut W {
601 self.variant(MPL0_A::_0)
602 }
603 #[doc = "Accesses from this master are not forced to user-mode."]
604 #[inline(always)]
605 pub fn _1(self) -> &'a mut W {
606 self.variant(MPL0_A::_1)
607 }
608 #[doc = r"Sets the field bit"]
609 #[inline(always)]
610 pub fn set_bit(self) -> &'a mut W {
611 self.bit(true)
612 }
613 #[doc = r"Clears the field bit"]
614 #[inline(always)]
615 pub fn clear_bit(self) -> &'a mut W {
616 self.bit(false)
617 }
618 #[doc = r"Writes raw bits to the field"]
619 #[inline(always)]
620 pub fn bit(self, value: bool) -> &'a mut W {
621 self.w.bits = (self.w.bits & !(0x01 << 28)) | ((value as u32 & 0x01) << 28);
622 self.w
623 }
624}
625#[doc = "Master 0 Trusted For Writes\n\nValue on reset: 1"]
626#[derive(Clone, Copy, Debug, PartialEq)]
627pub enum MTW0_A {
628 #[doc = "0: This master is not trusted for write accesses."]
629 _0 = 0,
630 #[doc = "1: This master is trusted for write accesses."]
631 _1 = 1,
632}
633impl From<MTW0_A> for bool {
634 #[inline(always)]
635 fn from(variant: MTW0_A) -> Self {
636 variant as u8 != 0
637 }
638}
639#[doc = "Field `MTW0` reader - Master 0 Trusted For Writes"]
640pub struct MTW0_R(crate::FieldReader<bool, MTW0_A>);
641impl MTW0_R {
642 #[inline(always)]
643 pub(crate) fn new(bits: bool) -> Self {
644 MTW0_R(crate::FieldReader::new(bits))
645 }
646 #[doc = r"Get enumerated values variant"]
647 #[inline(always)]
648 pub fn variant(&self) -> MTW0_A {
649 match self.bits {
650 false => MTW0_A::_0,
651 true => MTW0_A::_1,
652 }
653 }
654 #[doc = "Checks if the value of the field is `_0`"]
655 #[inline(always)]
656 pub fn is_0(&self) -> bool {
657 **self == MTW0_A::_0
658 }
659 #[doc = "Checks if the value of the field is `_1`"]
660 #[inline(always)]
661 pub fn is_1(&self) -> bool {
662 **self == MTW0_A::_1
663 }
664}
665impl core::ops::Deref for MTW0_R {
666 type Target = crate::FieldReader<bool, MTW0_A>;
667 #[inline(always)]
668 fn deref(&self) -> &Self::Target {
669 &self.0
670 }
671}
672#[doc = "Field `MTW0` writer - Master 0 Trusted For Writes"]
673pub struct MTW0_W<'a> {
674 w: &'a mut W,
675}
676impl<'a> MTW0_W<'a> {
677 #[doc = r"Writes `variant` to the field"]
678 #[inline(always)]
679 pub fn variant(self, variant: MTW0_A) -> &'a mut W {
680 self.bit(variant.into())
681 }
682 #[doc = "This master is not trusted for write accesses."]
683 #[inline(always)]
684 pub fn _0(self) -> &'a mut W {
685 self.variant(MTW0_A::_0)
686 }
687 #[doc = "This master is trusted for write accesses."]
688 #[inline(always)]
689 pub fn _1(self) -> &'a mut W {
690 self.variant(MTW0_A::_1)
691 }
692 #[doc = r"Sets the field bit"]
693 #[inline(always)]
694 pub fn set_bit(self) -> &'a mut W {
695 self.bit(true)
696 }
697 #[doc = r"Clears the field bit"]
698 #[inline(always)]
699 pub fn clear_bit(self) -> &'a mut W {
700 self.bit(false)
701 }
702 #[doc = r"Writes raw bits to the field"]
703 #[inline(always)]
704 pub fn bit(self, value: bool) -> &'a mut W {
705 self.w.bits = (self.w.bits & !(0x01 << 29)) | ((value as u32 & 0x01) << 29);
706 self.w
707 }
708}
709#[doc = "Master 0 Trusted For Read\n\nValue on reset: 1"]
710#[derive(Clone, Copy, Debug, PartialEq)]
711pub enum MTR0_A {
712 #[doc = "0: This master is not trusted for read accesses."]
713 _0 = 0,
714 #[doc = "1: This master is trusted for read accesses."]
715 _1 = 1,
716}
717impl From<MTR0_A> for bool {
718 #[inline(always)]
719 fn from(variant: MTR0_A) -> Self {
720 variant as u8 != 0
721 }
722}
723#[doc = "Field `MTR0` reader - Master 0 Trusted For Read"]
724pub struct MTR0_R(crate::FieldReader<bool, MTR0_A>);
725impl MTR0_R {
726 #[inline(always)]
727 pub(crate) fn new(bits: bool) -> Self {
728 MTR0_R(crate::FieldReader::new(bits))
729 }
730 #[doc = r"Get enumerated values variant"]
731 #[inline(always)]
732 pub fn variant(&self) -> MTR0_A {
733 match self.bits {
734 false => MTR0_A::_0,
735 true => MTR0_A::_1,
736 }
737 }
738 #[doc = "Checks if the value of the field is `_0`"]
739 #[inline(always)]
740 pub fn is_0(&self) -> bool {
741 **self == MTR0_A::_0
742 }
743 #[doc = "Checks if the value of the field is `_1`"]
744 #[inline(always)]
745 pub fn is_1(&self) -> bool {
746 **self == MTR0_A::_1
747 }
748}
749impl core::ops::Deref for MTR0_R {
750 type Target = crate::FieldReader<bool, MTR0_A>;
751 #[inline(always)]
752 fn deref(&self) -> &Self::Target {
753 &self.0
754 }
755}
756#[doc = "Field `MTR0` writer - Master 0 Trusted For Read"]
757pub struct MTR0_W<'a> {
758 w: &'a mut W,
759}
760impl<'a> MTR0_W<'a> {
761 #[doc = r"Writes `variant` to the field"]
762 #[inline(always)]
763 pub fn variant(self, variant: MTR0_A) -> &'a mut W {
764 self.bit(variant.into())
765 }
766 #[doc = "This master is not trusted for read accesses."]
767 #[inline(always)]
768 pub fn _0(self) -> &'a mut W {
769 self.variant(MTR0_A::_0)
770 }
771 #[doc = "This master is trusted for read accesses."]
772 #[inline(always)]
773 pub fn _1(self) -> &'a mut W {
774 self.variant(MTR0_A::_1)
775 }
776 #[doc = r"Sets the field bit"]
777 #[inline(always)]
778 pub fn set_bit(self) -> &'a mut W {
779 self.bit(true)
780 }
781 #[doc = r"Clears the field bit"]
782 #[inline(always)]
783 pub fn clear_bit(self) -> &'a mut W {
784 self.bit(false)
785 }
786 #[doc = r"Writes raw bits to the field"]
787 #[inline(always)]
788 pub fn bit(self, value: bool) -> &'a mut W {
789 self.w.bits = (self.w.bits & !(0x01 << 30)) | ((value as u32 & 0x01) << 30);
790 self.w
791 }
792}
793impl R {
794 #[doc = "Bit 20 - Master 2 Privilege Level"]
795 #[inline(always)]
796 pub fn mpl2(&self) -> MPL2_R {
797 MPL2_R::new(((self.bits >> 20) & 0x01) != 0)
798 }
799 #[doc = "Bit 21 - Master 2 Trusted For Writes"]
800 #[inline(always)]
801 pub fn mtw2(&self) -> MTW2_R {
802 MTW2_R::new(((self.bits >> 21) & 0x01) != 0)
803 }
804 #[doc = "Bit 22 - Master 2 Trusted For Read"]
805 #[inline(always)]
806 pub fn mtr2(&self) -> MTR2_R {
807 MTR2_R::new(((self.bits >> 22) & 0x01) != 0)
808 }
809 #[doc = "Bit 24 - Master 1 Privilege Level"]
810 #[inline(always)]
811 pub fn mpl1(&self) -> MPL1_R {
812 MPL1_R::new(((self.bits >> 24) & 0x01) != 0)
813 }
814 #[doc = "Bit 25 - Master 1 Trusted for Writes"]
815 #[inline(always)]
816 pub fn mtw1(&self) -> MTW1_R {
817 MTW1_R::new(((self.bits >> 25) & 0x01) != 0)
818 }
819 #[doc = "Bit 26 - Master 1 Trusted for Read"]
820 #[inline(always)]
821 pub fn mtr1(&self) -> MTR1_R {
822 MTR1_R::new(((self.bits >> 26) & 0x01) != 0)
823 }
824 #[doc = "Bit 28 - Master 0 Privilege Level"]
825 #[inline(always)]
826 pub fn mpl0(&self) -> MPL0_R {
827 MPL0_R::new(((self.bits >> 28) & 0x01) != 0)
828 }
829 #[doc = "Bit 29 - Master 0 Trusted For Writes"]
830 #[inline(always)]
831 pub fn mtw0(&self) -> MTW0_R {
832 MTW0_R::new(((self.bits >> 29) & 0x01) != 0)
833 }
834 #[doc = "Bit 30 - Master 0 Trusted For Read"]
835 #[inline(always)]
836 pub fn mtr0(&self) -> MTR0_R {
837 MTR0_R::new(((self.bits >> 30) & 0x01) != 0)
838 }
839}
840impl W {
841 #[doc = "Bit 20 - Master 2 Privilege Level"]
842 #[inline(always)]
843 pub fn mpl2(&mut self) -> MPL2_W {
844 MPL2_W { w: self }
845 }
846 #[doc = "Bit 21 - Master 2 Trusted For Writes"]
847 #[inline(always)]
848 pub fn mtw2(&mut self) -> MTW2_W {
849 MTW2_W { w: self }
850 }
851 #[doc = "Bit 22 - Master 2 Trusted For Read"]
852 #[inline(always)]
853 pub fn mtr2(&mut self) -> MTR2_W {
854 MTR2_W { w: self }
855 }
856 #[doc = "Bit 24 - Master 1 Privilege Level"]
857 #[inline(always)]
858 pub fn mpl1(&mut self) -> MPL1_W {
859 MPL1_W { w: self }
860 }
861 #[doc = "Bit 25 - Master 1 Trusted for Writes"]
862 #[inline(always)]
863 pub fn mtw1(&mut self) -> MTW1_W {
864 MTW1_W { w: self }
865 }
866 #[doc = "Bit 26 - Master 1 Trusted for Read"]
867 #[inline(always)]
868 pub fn mtr1(&mut self) -> MTR1_W {
869 MTR1_W { w: self }
870 }
871 #[doc = "Bit 28 - Master 0 Privilege Level"]
872 #[inline(always)]
873 pub fn mpl0(&mut self) -> MPL0_W {
874 MPL0_W { w: self }
875 }
876 #[doc = "Bit 29 - Master 0 Trusted For Writes"]
877 #[inline(always)]
878 pub fn mtw0(&mut self) -> MTW0_W {
879 MTW0_W { w: self }
880 }
881 #[doc = "Bit 30 - Master 0 Trusted For Read"]
882 #[inline(always)]
883 pub fn mtr0(&mut self) -> MTR0_W {
884 MTR0_W { w: self }
885 }
886 #[doc = "Writes raw bits to the register."]
887 #[inline(always)]
888 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
889 self.0.bits(bits);
890 self
891 }
892}
893#[doc = "Master Privilege Register A\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [mpra](index.html) module"]
894pub struct MPRA_SPEC;
895impl crate::RegisterSpec for MPRA_SPEC {
896 type Ux = u32;
897}
898#[doc = "`read()` method returns [mpra::R](R) reader structure"]
899impl crate::Readable for MPRA_SPEC {
900 type Reader = R;
901}
902#[doc = "`write(|w| ..)` method takes [mpra::W](W) writer structure"]
903impl crate::Writable for MPRA_SPEC {
904 type Writer = W;
905}
906#[doc = "`reset()` method sets MPRA to value 0x7770_0000"]
907impl crate::Resettable for MPRA_SPEC {
908 #[inline(always)]
909 fn reset_value() -> Self::Ux {
910 0x7770_0000
911 }
912}