1#![allow(clippy::identity_op)]
21#![allow(clippy::module_inception)]
22#![allow(clippy::derivable_impls)]
23#[allow(unused_imports)]
24use crate::common::sealed;
25#[allow(unused_imports)]
26use crate::common::*;
27#[doc = r"CACHE"]
28unsafe impl ::core::marker::Send for super::Cache {}
29unsafe impl ::core::marker::Sync for super::Cache {}
30impl super::Cache {
31 #[allow(unused)]
32 #[inline(always)]
33 pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
34 self.ptr
35 }
36
37 #[doc = "C-Cache Control Register"]
38 #[inline(always)]
39 pub const fn ccactl(
40 &self,
41 ) -> &'static crate::common::Reg<self::Ccactl_SPEC, crate::common::RW> {
42 unsafe {
43 crate::common::Reg::<self::Ccactl_SPEC, crate::common::RW>::from_ptr(
44 self._svd2pac_as_ptr().add(0usize),
45 )
46 }
47 }
48
49 #[doc = "C-Cache Flush Control Register"]
50 #[inline(always)]
51 pub const fn ccafct(
52 &self,
53 ) -> &'static crate::common::Reg<self::Ccafct_SPEC, crate::common::RW> {
54 unsafe {
55 crate::common::Reg::<self::Ccafct_SPEC, crate::common::RW>::from_ptr(
56 self._svd2pac_as_ptr().add(4usize),
57 )
58 }
59 }
60
61 #[doc = "C-Cache Write Attribute"]
62 #[inline(always)]
63 pub const fn ccawta(
64 &self,
65 ) -> &'static crate::common::Reg<self::Ccawta_SPEC, crate::common::RW> {
66 unsafe {
67 crate::common::Reg::<self::Ccawta_SPEC, crate::common::RW>::from_ptr(
68 self._svd2pac_as_ptr().add(12usize),
69 )
70 }
71 }
72
73 #[doc = "C-Cache Error Detection Status"]
74 #[inline(always)]
75 pub const fn ccaedst(
76 &self,
77 ) -> &'static crate::common::Reg<self::Ccaedst_SPEC, crate::common::RW> {
78 unsafe {
79 crate::common::Reg::<self::Ccaedst_SPEC, crate::common::RW>::from_ptr(
80 self._svd2pac_as_ptr().add(16usize),
81 )
82 }
83 }
84
85 #[doc = "C-Cache Test Access Address"]
86 #[inline(always)]
87 pub const fn ccataa(
88 &self,
89 ) -> &'static crate::common::Reg<self::Ccataa_SPEC, crate::common::RW> {
90 unsafe {
91 crate::common::Reg::<self::Ccataa_SPEC, crate::common::RW>::from_ptr(
92 self._svd2pac_as_ptr().add(20usize),
93 )
94 }
95 }
96
97 #[doc = "C-Cache Test Access Data (DATA)"]
98 #[inline(always)]
99 pub const fn ccatad_data(
100 &self,
101 ) -> &'static crate::common::Reg<self::CcatadData_SPEC, crate::common::RW> {
102 unsafe {
103 crate::common::Reg::<self::CcatadData_SPEC, crate::common::RW>::from_ptr(
104 self._svd2pac_as_ptr().add(24usize),
105 )
106 }
107 }
108
109 #[doc = "C-Cache Test Access Data (ECC)"]
110 #[inline(always)]
111 pub const fn ccatad_ecc(
112 &self,
113 ) -> &'static crate::common::Reg<self::CcatadEcc_SPEC, crate::common::RW> {
114 unsafe {
115 crate::common::Reg::<self::CcatadEcc_SPEC, crate::common::RW>::from_ptr(
116 self._svd2pac_as_ptr().add(24usize),
117 )
118 }
119 }
120
121 #[doc = "C-Cache Test Access Data (LRU)"]
122 #[inline(always)]
123 pub const fn ccatad_lru(
124 &self,
125 ) -> &'static crate::common::Reg<self::CcatadLru_SPEC, crate::common::RW> {
126 unsafe {
127 crate::common::Reg::<self::CcatadLru_SPEC, crate::common::RW>::from_ptr(
128 self._svd2pac_as_ptr().add(24usize),
129 )
130 }
131 }
132
133 #[doc = "C-Cache Test Access Data (TAG)"]
134 #[inline(always)]
135 pub const fn ccatad_tag(
136 &self,
137 ) -> &'static crate::common::Reg<self::CcatadTag_SPEC, crate::common::RW> {
138 unsafe {
139 crate::common::Reg::<self::CcatadTag_SPEC, crate::common::RW>::from_ptr(
140 self._svd2pac_as_ptr().add(24usize),
141 )
142 }
143 }
144
145 #[doc = "C-Cache Test Access Data (TAGECC)"]
146 #[inline(always)]
147 pub const fn ccatad_tagecc(
148 &self,
149 ) -> &'static crate::common::Reg<self::CcatadTagecc_SPEC, crate::common::RW> {
150 unsafe {
151 crate::common::Reg::<self::CcatadTagecc_SPEC, crate::common::RW>::from_ptr(
152 self._svd2pac_as_ptr().add(24usize),
153 )
154 }
155 }
156
157 #[doc = "S-Cache Control Register"]
158 #[inline(always)]
159 pub const fn scactl(
160 &self,
161 ) -> &'static crate::common::Reg<self::Scactl_SPEC, crate::common::RW> {
162 unsafe {
163 crate::common::Reg::<self::Scactl_SPEC, crate::common::RW>::from_ptr(
164 self._svd2pac_as_ptr().add(64usize),
165 )
166 }
167 }
168
169 #[doc = "S-Cache Flush Control Register"]
170 #[inline(always)]
171 pub const fn scafct(
172 &self,
173 ) -> &'static crate::common::Reg<self::Scafct_SPEC, crate::common::RW> {
174 unsafe {
175 crate::common::Reg::<self::Scafct_SPEC, crate::common::RW>::from_ptr(
176 self._svd2pac_as_ptr().add(68usize),
177 )
178 }
179 }
180
181 #[doc = "S-Cache Write Attribute"]
182 #[inline(always)]
183 pub const fn scawta(
184 &self,
185 ) -> &'static crate::common::Reg<self::Scawta_SPEC, crate::common::RW> {
186 unsafe {
187 crate::common::Reg::<self::Scawta_SPEC, crate::common::RW>::from_ptr(
188 self._svd2pac_as_ptr().add(76usize),
189 )
190 }
191 }
192
193 #[doc = "S-Cache Error Detection Status"]
194 #[inline(always)]
195 pub const fn scaedst(
196 &self,
197 ) -> &'static crate::common::Reg<self::Scaedst_SPEC, crate::common::RW> {
198 unsafe {
199 crate::common::Reg::<self::Scaedst_SPEC, crate::common::RW>::from_ptr(
200 self._svd2pac_as_ptr().add(80usize),
201 )
202 }
203 }
204
205 #[doc = "S-Cache Test Access Address"]
206 #[inline(always)]
207 pub const fn scataa(
208 &self,
209 ) -> &'static crate::common::Reg<self::Scataa_SPEC, crate::common::RW> {
210 unsafe {
211 crate::common::Reg::<self::Scataa_SPEC, crate::common::RW>::from_ptr(
212 self._svd2pac_as_ptr().add(84usize),
213 )
214 }
215 }
216
217 #[doc = "S-Cache Test Access Data (DATA)"]
218 #[inline(always)]
219 pub const fn scatad_data(
220 &self,
221 ) -> &'static crate::common::Reg<self::ScatadData_SPEC, crate::common::RW> {
222 unsafe {
223 crate::common::Reg::<self::ScatadData_SPEC, crate::common::RW>::from_ptr(
224 self._svd2pac_as_ptr().add(88usize),
225 )
226 }
227 }
228
229 #[doc = "S-Cache Test Access Data (ECC)"]
230 #[inline(always)]
231 pub const fn scatad_ecc(
232 &self,
233 ) -> &'static crate::common::Reg<self::ScatadEcc_SPEC, crate::common::RW> {
234 unsafe {
235 crate::common::Reg::<self::ScatadEcc_SPEC, crate::common::RW>::from_ptr(
236 self._svd2pac_as_ptr().add(88usize),
237 )
238 }
239 }
240
241 #[doc = "S-Cache Test Access Data (LRU)"]
242 #[inline(always)]
243 pub const fn scatad_lru(
244 &self,
245 ) -> &'static crate::common::Reg<self::ScatadLru_SPEC, crate::common::RW> {
246 unsafe {
247 crate::common::Reg::<self::ScatadLru_SPEC, crate::common::RW>::from_ptr(
248 self._svd2pac_as_ptr().add(88usize),
249 )
250 }
251 }
252
253 #[doc = "S-Cache Test Access Data (TAG)"]
254 #[inline(always)]
255 pub const fn scatad_tag(
256 &self,
257 ) -> &'static crate::common::Reg<self::ScatadTag_SPEC, crate::common::RW> {
258 unsafe {
259 crate::common::Reg::<self::ScatadTag_SPEC, crate::common::RW>::from_ptr(
260 self._svd2pac_as_ptr().add(88usize),
261 )
262 }
263 }
264
265 #[doc = "Cache Parity Error Operation After Detection Register"]
266 #[inline(always)]
267 pub const fn capoad(
268 &self,
269 ) -> &'static crate::common::Reg<self::Capoad_SPEC, crate::common::RW> {
270 unsafe {
271 crate::common::Reg::<self::Capoad_SPEC, crate::common::RW>::from_ptr(
272 self._svd2pac_as_ptr().add(512usize),
273 )
274 }
275 }
276
277 #[doc = "Cache Protection Register"]
278 #[inline(always)]
279 pub const fn caprcr(
280 &self,
281 ) -> &'static crate::common::Reg<self::Caprcr_SPEC, crate::common::RW> {
282 unsafe {
283 crate::common::Reg::<self::Caprcr_SPEC, crate::common::RW>::from_ptr(
284 self._svd2pac_as_ptr().add(516usize),
285 )
286 }
287 }
288}
289#[doc(hidden)]
290#[derive(Copy, Clone, Eq, PartialEq)]
291pub struct Ccactl_SPEC;
292impl crate::sealed::RegSpec for Ccactl_SPEC {
293 type DataType = u32;
294}
295
296#[doc = "C-Cache Control Register"]
297pub type Ccactl = crate::RegValueT<Ccactl_SPEC>;
298
299impl Ccactl {
300 #[doc = "C-cache enable bit"]
301 #[inline(always)]
302 pub fn enc(
303 self,
304 ) -> crate::common::RegisterField<
305 0,
306 0x1,
307 1,
308 0,
309 ccactl::Enc,
310 ccactl::Enc,
311 Ccactl_SPEC,
312 crate::common::RW,
313 > {
314 crate::common::RegisterField::<
315 0,
316 0x1,
317 1,
318 0,
319 ccactl::Enc,
320 ccactl::Enc,
321 Ccactl_SPEC,
322 crate::common::RW,
323 >::from_register(self, 0)
324 }
325
326 #[doc = "C-Cache flush bit"]
327 #[inline(always)]
328 pub fn fc(
329 self,
330 ) -> crate::common::RegisterField<
331 8,
332 0x1,
333 1,
334 0,
335 ccactl::Fc,
336 ccactl::Fc,
337 Ccactl_SPEC,
338 crate::common::RW,
339 > {
340 crate::common::RegisterField::<
341 8,
342 0x1,
343 1,
344 0,
345 ccactl::Fc,
346 ccactl::Fc,
347 Ccactl_SPEC,
348 crate::common::RW,
349 >::from_register(self, 0)
350 }
351
352 #[doc = "C-cache write-back"]
353 #[inline(always)]
354 pub fn wb(
355 self,
356 ) -> crate::common::RegisterField<
357 9,
358 0x1,
359 1,
360 0,
361 ccactl::Wb,
362 ccactl::Wb,
363 Ccactl_SPEC,
364 crate::common::RW,
365 > {
366 crate::common::RegisterField::<
367 9,
368 0x1,
369 1,
370 0,
371 ccactl::Wb,
372 ccactl::Wb,
373 Ccactl_SPEC,
374 crate::common::RW,
375 >::from_register(self, 0)
376 }
377}
378impl ::core::default::Default for Ccactl {
379 #[inline(always)]
380 fn default() -> Ccactl {
381 <crate::RegValueT<Ccactl_SPEC> as RegisterValue<_>>::new(0)
382 }
383}
384pub mod ccactl {
385
386 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
387 pub struct Enc_SPEC;
388 pub type Enc = crate::EnumBitfieldStruct<u8, Enc_SPEC>;
389 impl Enc {
390 #[doc = "C-Cache disable"]
391 pub const _0: Self = Self::new(0);
392
393 #[doc = "C-Cache enable"]
394 pub const _1: Self = Self::new(1);
395 }
396 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
397 pub struct Fc_SPEC;
398 pub type Fc = crate::EnumBitfieldStruct<u8, Fc_SPEC>;
399 impl Fc {
400 #[doc = "No action"]
401 pub const _0: Self = Self::new(0);
402
403 #[doc = "C-Cache line flush (all lines invalidate)"]
404 pub const _1: Self = Self::new(1);
405 }
406 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
407 pub struct Wb_SPEC;
408 pub type Wb = crate::EnumBitfieldStruct<u8, Wb_SPEC>;
409 impl Wb {
410 #[doc = "No action"]
411 pub const _0: Self = Self::new(0);
412
413 #[doc = "C-Cache write-back"]
414 pub const _1: Self = Self::new(1);
415 }
416}
417#[doc(hidden)]
418#[derive(Copy, Clone, Eq, PartialEq)]
419pub struct Ccafct_SPEC;
420impl crate::sealed::RegSpec for Ccafct_SPEC {
421 type DataType = u32;
422}
423
424#[doc = "C-Cache Flush Control Register"]
425pub type Ccafct = crate::RegValueT<Ccafct_SPEC>;
426
427impl Ccafct {
428 #[doc = "C-Cache flush bit"]
429 #[inline(always)]
430 pub fn fc(
431 self,
432 ) -> crate::common::RegisterField<
433 0,
434 0x1,
435 1,
436 0,
437 ccafct::Fc,
438 ccafct::Fc,
439 Ccafct_SPEC,
440 crate::common::RW,
441 > {
442 crate::common::RegisterField::<
443 0,
444 0x1,
445 1,
446 0,
447 ccafct::Fc,
448 ccafct::Fc,
449 Ccafct_SPEC,
450 crate::common::RW,
451 >::from_register(self, 0)
452 }
453
454 #[doc = "C-Cache write-back"]
455 #[inline(always)]
456 pub fn wb(
457 self,
458 ) -> crate::common::RegisterField<
459 1,
460 0x1,
461 1,
462 0,
463 ccafct::Wb,
464 ccafct::Wb,
465 Ccafct_SPEC,
466 crate::common::RW,
467 > {
468 crate::common::RegisterField::<
469 1,
470 0x1,
471 1,
472 0,
473 ccafct::Wb,
474 ccafct::Wb,
475 Ccafct_SPEC,
476 crate::common::RW,
477 >::from_register(self, 0)
478 }
479}
480impl ::core::default::Default for Ccafct {
481 #[inline(always)]
482 fn default() -> Ccafct {
483 <crate::RegValueT<Ccafct_SPEC> as RegisterValue<_>>::new(0)
484 }
485}
486pub mod ccafct {
487
488 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
489 pub struct Fc_SPEC;
490 pub type Fc = crate::EnumBitfieldStruct<u8, Fc_SPEC>;
491 impl Fc {
492 #[doc = "No action"]
493 pub const _0: Self = Self::new(0);
494
495 #[doc = "C-Cache line flush (all lines invalidate)"]
496 pub const _1: Self = Self::new(1);
497 }
498 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
499 pub struct Wb_SPEC;
500 pub type Wb = crate::EnumBitfieldStruct<u8, Wb_SPEC>;
501 impl Wb {
502 #[doc = "No action"]
503 pub const _0: Self = Self::new(0);
504
505 #[doc = "C-Cache write-back"]
506 pub const _1: Self = Self::new(1);
507 }
508}
509#[doc(hidden)]
510#[derive(Copy, Clone, Eq, PartialEq)]
511pub struct Ccawta_SPEC;
512impl crate::sealed::RegSpec for Ccawta_SPEC {
513 type DataType = u32;
514}
515
516#[doc = "C-Cache Write Attribute"]
517pub type Ccawta = crate::RegValueT<Ccawta_SPEC>;
518
519impl Ccawta {
520 #[doc = "C-Cache write-through"]
521 #[inline(always)]
522 pub fn wt(
523 self,
524 ) -> crate::common::RegisterField<
525 0,
526 0x1,
527 1,
528 0,
529 ccawta::Wt,
530 ccawta::Wt,
531 Ccawta_SPEC,
532 crate::common::RW,
533 > {
534 crate::common::RegisterField::<
535 0,
536 0x1,
537 1,
538 0,
539 ccawta::Wt,
540 ccawta::Wt,
541 Ccawta_SPEC,
542 crate::common::RW,
543 >::from_register(self, 0)
544 }
545
546 #[doc = "C-Cache write-allocation"]
547 #[inline(always)]
548 pub fn wa(
549 self,
550 ) -> crate::common::RegisterField<
551 1,
552 0x1,
553 1,
554 0,
555 ccawta::Wa,
556 ccawta::Wa,
557 Ccawta_SPEC,
558 crate::common::RW,
559 > {
560 crate::common::RegisterField::<
561 1,
562 0x1,
563 1,
564 0,
565 ccawta::Wa,
566 ccawta::Wa,
567 Ccawta_SPEC,
568 crate::common::RW,
569 >::from_register(self, 0)
570 }
571}
572impl ::core::default::Default for Ccawta {
573 #[inline(always)]
574 fn default() -> Ccawta {
575 <crate::RegValueT<Ccawta_SPEC> as RegisterValue<_>>::new(1)
576 }
577}
578pub mod ccawta {
579
580 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
581 pub struct Wt_SPEC;
582 pub type Wt = crate::EnumBitfieldStruct<u8, Wt_SPEC>;
583 impl Wt {
584 #[doc = "Write-through or write-back depends on the cache attribute of the area"]
585 pub const _0: Self = Self::new(0);
586
587 #[doc = "Always write-through mode"]
588 pub const _1: Self = Self::new(1);
589 }
590 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
591 pub struct Wa_SPEC;
592 pub type Wa = crate::EnumBitfieldStruct<u8, Wa_SPEC>;
593 impl Wa {
594 #[doc = "Always disable write-allocation"]
595 pub const _0: Self = Self::new(0);
596
597 #[doc = "Write-allocation enable depends on the cache attribute of the area"]
598 pub const _1: Self = Self::new(1);
599 }
600}
601#[doc(hidden)]
602#[derive(Copy, Clone, Eq, PartialEq)]
603pub struct Ccaedst_SPEC;
604impl crate::sealed::RegSpec for Ccaedst_SPEC {
605 type DataType = u32;
606}
607
608#[doc = "C-Cache Error Detection Status"]
609pub type Ccaedst = crate::RegValueT<Ccaedst_SPEC>;
610
611impl Ccaedst {
612 #[doc = "C-Cache data error status 0"]
613 #[inline(always)]
614 pub fn esd0(
615 self,
616 ) -> crate::common::RegisterField<
617 0,
618 0x1,
619 1,
620 0,
621 ccaedst::Esd0,
622 ccaedst::Esd0,
623 Ccaedst_SPEC,
624 crate::common::RW,
625 > {
626 crate::common::RegisterField::<
627 0,
628 0x1,
629 1,
630 0,
631 ccaedst::Esd0,
632 ccaedst::Esd0,
633 Ccaedst_SPEC,
634 crate::common::RW,
635 >::from_register(self, 0)
636 }
637
638 #[doc = "C-Cache data error status 1"]
639 #[inline(always)]
640 pub fn esd1(
641 self,
642 ) -> crate::common::RegisterField<
643 1,
644 0x1,
645 1,
646 0,
647 ccaedst::Esd1,
648 ccaedst::Esd1,
649 Ccaedst_SPEC,
650 crate::common::RW,
651 > {
652 crate::common::RegisterField::<
653 1,
654 0x1,
655 1,
656 0,
657 ccaedst::Esd1,
658 ccaedst::Esd1,
659 Ccaedst_SPEC,
660 crate::common::RW,
661 >::from_register(self, 0)
662 }
663
664 #[doc = "C-Cache tag clean line invalidate status"]
665 #[inline(always)]
666 pub fn estc(
667 self,
668 ) -> crate::common::RegisterField<
669 2,
670 0x1,
671 1,
672 0,
673 ccaedst::Estc,
674 ccaedst::Estc,
675 Ccaedst_SPEC,
676 crate::common::RW,
677 > {
678 crate::common::RegisterField::<
679 2,
680 0x1,
681 1,
682 0,
683 ccaedst::Estc,
684 ccaedst::Estc,
685 Ccaedst_SPEC,
686 crate::common::RW,
687 >::from_register(self, 0)
688 }
689
690 #[doc = "C-Cache tag dirty line invalidate status"]
691 #[inline(always)]
692 pub fn estd(
693 self,
694 ) -> crate::common::RegisterField<
695 3,
696 0x1,
697 1,
698 0,
699 ccaedst::Estd,
700 ccaedst::Estd,
701 Ccaedst_SPEC,
702 crate::common::RW,
703 > {
704 crate::common::RegisterField::<
705 3,
706 0x1,
707 1,
708 0,
709 ccaedst::Estd,
710 ccaedst::Estd,
711 Ccaedst_SPEC,
712 crate::common::RW,
713 >::from_register(self, 0)
714 }
715
716 #[doc = "C-Cache tag 2-bit error status"]
717 #[inline(always)]
718 pub fn est2(
719 self,
720 ) -> crate::common::RegisterField<
721 4,
722 0x1,
723 1,
724 0,
725 ccaedst::Est2,
726 ccaedst::Est2,
727 Ccaedst_SPEC,
728 crate::common::RW,
729 > {
730 crate::common::RegisterField::<
731 4,
732 0x1,
733 1,
734 0,
735 ccaedst::Est2,
736 ccaedst::Est2,
737 Ccaedst_SPEC,
738 crate::common::RW,
739 >::from_register(self, 0)
740 }
741}
742impl ::core::default::Default for Ccaedst {
743 #[inline(always)]
744 fn default() -> Ccaedst {
745 <crate::RegValueT<Ccaedst_SPEC> as RegisterValue<_>>::new(0)
746 }
747}
748pub mod ccaedst {
749
750 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
751 pub struct Esd0_SPEC;
752 pub type Esd0 = crate::EnumBitfieldStruct<u8, Esd0_SPEC>;
753 impl Esd0 {
754 #[doc = "ECC 1-bit error was not detected"]
755 pub const _0: Self = Self::new(0);
756
757 #[doc = "ECC 1-bit error was detected and corrected"]
758 pub const _1: Self = Self::new(1);
759 }
760 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
761 pub struct Esd1_SPEC;
762 pub type Esd1 = crate::EnumBitfieldStruct<u8, Esd1_SPEC>;
763 impl Esd1 {
764 #[doc = "ECC 2-bit error was not detected"]
765 pub const _0: Self = Self::new(0);
766
767 #[doc = "ECC 2-bit error was detected"]
768 pub const _1: Self = Self::new(1);
769 }
770 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
771 pub struct Estc_SPEC;
772 pub type Estc = crate::EnumBitfieldStruct<u8, Estc_SPEC>;
773 impl Estc {
774 #[doc = "Clean line was not invalidated"]
775 pub const _0: Self = Self::new(0);
776
777 #[doc = "Clean line was invalidated"]
778 pub const _1: Self = Self::new(1);
779 }
780 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
781 pub struct Estd_SPEC;
782 pub type Estd = crate::EnumBitfieldStruct<u8, Estd_SPEC>;
783 impl Estd {
784 #[doc = "Dirty line was not invalidated"]
785 pub const _0: Self = Self::new(0);
786
787 #[doc = "Dirty line was invalidated"]
788 pub const _1: Self = Self::new(1);
789 }
790 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
791 pub struct Est2_SPEC;
792 pub type Est2 = crate::EnumBitfieldStruct<u8, Est2_SPEC>;
793 impl Est2 {
794 #[doc = "ECC 2-bit error was not detected"]
795 pub const _0: Self = Self::new(0);
796
797 #[doc = "ECC 2-bit error was detected"]
798 pub const _1: Self = Self::new(1);
799 }
800}
801#[doc(hidden)]
802#[derive(Copy, Clone, Eq, PartialEq)]
803pub struct Ccataa_SPEC;
804impl crate::sealed::RegSpec for Ccataa_SPEC {
805 type DataType = u32;
806}
807
808#[doc = "C-Cache Test Access Address"]
809pub type Ccataa = crate::RegValueT<Ccataa_SPEC>;
810
811impl Ccataa {
812 #[doc = "Address offset"]
813 #[inline(always)]
814 pub fn offset(
815 self,
816 ) -> crate::common::RegisterField<2, 0x7, 1, 0, u8, u8, Ccataa_SPEC, crate::common::RW> {
817 crate::common::RegisterField::<2,0x7,1,0,u8,u8,Ccataa_SPEC,crate::common::RW>::from_register(self,0)
818 }
819
820 #[doc = "Address entry"]
821 #[inline(always)]
822 pub fn entry(
823 self,
824 ) -> crate::common::RegisterField<5, 0x7f, 1, 0, u8, u8, Ccataa_SPEC, crate::common::RW> {
825 crate::common::RegisterField::<5,0x7f,1,0,u8,u8,Ccataa_SPEC,crate::common::RW>::from_register(self,0)
826 }
827
828 #[doc = "Access target"]
829 #[inline(always)]
830 pub fn target(
831 self,
832 ) -> crate::common::RegisterField<
833 16,
834 0x7,
835 1,
836 0,
837 ccataa::Target,
838 ccataa::Target,
839 Ccataa_SPEC,
840 crate::common::RW,
841 > {
842 crate::common::RegisterField::<
843 16,
844 0x7,
845 1,
846 0,
847 ccataa::Target,
848 ccataa::Target,
849 Ccataa_SPEC,
850 crate::common::RW,
851 >::from_register(self, 0)
852 }
853
854 #[doc = "Read write"]
855 #[inline(always)]
856 pub fn rw(
857 self,
858 ) -> crate::common::RegisterField<
859 23,
860 0x1,
861 1,
862 0,
863 ccataa::Rw,
864 ccataa::Rw,
865 Ccataa_SPEC,
866 crate::common::RW,
867 > {
868 crate::common::RegisterField::<
869 23,
870 0x1,
871 1,
872 0,
873 ccataa::Rw,
874 ccataa::Rw,
875 Ccataa_SPEC,
876 crate::common::RW,
877 >::from_register(self, 0)
878 }
879
880 #[doc = "Address way"]
881 #[inline(always)]
882 pub fn way(
883 self,
884 ) -> crate::common::RegisterField<30, 0x3, 1, 0, u8, u8, Ccataa_SPEC, crate::common::RW> {
885 crate::common::RegisterField::<30,0x3,1,0,u8,u8,Ccataa_SPEC,crate::common::RW>::from_register(self,0)
886 }
887}
888impl ::core::default::Default for Ccataa {
889 #[inline(always)]
890 fn default() -> Ccataa {
891 <crate::RegValueT<Ccataa_SPEC> as RegisterValue<_>>::new(0)
892 }
893}
894pub mod ccataa {
895
896 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
897 pub struct Target_SPEC;
898 pub type Target = crate::EnumBitfieldStruct<u8, Target_SPEC>;
899 impl Target {
900 #[doc = "Cache data read or write"]
901 pub const _000: Self = Self::new(0);
902
903 #[doc = "Data ECC code read or write"]
904 pub const _001: Self = Self::new(1);
905
906 #[doc = "Tag, V, D read or write"]
907 pub const _010: Self = Self::new(2);
908
909 #[doc = "LRU read or write"]
910 pub const _011: Self = Self::new(3);
911
912 #[doc = "Tag ECC code read or write"]
913 pub const _100: Self = Self::new(4);
914
915 #[doc = "Setting prohibited"]
916 pub const OTHERS: Self = Self::new(0);
917 }
918 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
919 pub struct Rw_SPEC;
920 pub type Rw = crate::EnumBitfieldStruct<u8, Rw_SPEC>;
921 impl Rw {
922 #[doc = "Read"]
923 pub const _0: Self = Self::new(0);
924
925 #[doc = "Write"]
926 pub const _1: Self = Self::new(1);
927 }
928}
929#[doc(hidden)]
930#[derive(Copy, Clone, Eq, PartialEq)]
931pub struct CcatadData_SPEC;
932impl crate::sealed::RegSpec for CcatadData_SPEC {
933 type DataType = u32;
934}
935
936#[doc = "C-Cache Test Access Data (DATA)"]
937pub type CcatadData = crate::RegValueT<CcatadData_SPEC>;
938
939impl CcatadData {
940 #[doc = "C-Cache test access data"]
941 #[inline(always)]
942 pub fn data(
943 self,
944 ) -> crate::common::RegisterField<
945 0,
946 0xffffffff,
947 1,
948 0,
949 u32,
950 u32,
951 CcatadData_SPEC,
952 crate::common::RW,
953 > {
954 crate::common::RegisterField::<
955 0,
956 0xffffffff,
957 1,
958 0,
959 u32,
960 u32,
961 CcatadData_SPEC,
962 crate::common::RW,
963 >::from_register(self, 0)
964 }
965}
966impl ::core::default::Default for CcatadData {
967 #[inline(always)]
968 fn default() -> CcatadData {
969 <crate::RegValueT<CcatadData_SPEC> as RegisterValue<_>>::new(0)
970 }
971}
972
973#[doc(hidden)]
974#[derive(Copy, Clone, Eq, PartialEq)]
975pub struct CcatadEcc_SPEC;
976impl crate::sealed::RegSpec for CcatadEcc_SPEC {
977 type DataType = u32;
978}
979
980#[doc = "C-Cache Test Access Data (ECC)"]
981pub type CcatadEcc = crate::RegValueT<CcatadEcc_SPEC>;
982
983impl CcatadEcc {
984 #[doc = "C-Cache test access ECC code"]
985 #[inline(always)]
986 pub fn ecc(
987 self,
988 ) -> crate::common::RegisterField<0, 0x7f, 1, 0, u8, u8, CcatadEcc_SPEC, crate::common::RW>
989 {
990 crate::common::RegisterField::<0,0x7f,1,0,u8,u8,CcatadEcc_SPEC,crate::common::RW>::from_register(self,0)
991 }
992}
993impl ::core::default::Default for CcatadEcc {
994 #[inline(always)]
995 fn default() -> CcatadEcc {
996 <crate::RegValueT<CcatadEcc_SPEC> as RegisterValue<_>>::new(0)
997 }
998}
999
1000#[doc(hidden)]
1001#[derive(Copy, Clone, Eq, PartialEq)]
1002pub struct CcatadLru_SPEC;
1003impl crate::sealed::RegSpec for CcatadLru_SPEC {
1004 type DataType = u32;
1005}
1006
1007#[doc = "C-Cache Test Access Data (LRU)"]
1008pub type CcatadLru = crate::RegValueT<CcatadLru_SPEC>;
1009
1010impl CcatadLru {
1011 #[doc = "C-Cache test access LRU data"]
1012 #[inline(always)]
1013 pub fn lru(
1014 self,
1015 ) -> crate::common::RegisterField<0, 0x1f, 1, 0, u8, u8, CcatadLru_SPEC, crate::common::RW>
1016 {
1017 crate::common::RegisterField::<0,0x1f,1,0,u8,u8,CcatadLru_SPEC,crate::common::RW>::from_register(self,0)
1018 }
1019}
1020impl ::core::default::Default for CcatadLru {
1021 #[inline(always)]
1022 fn default() -> CcatadLru {
1023 <crate::RegValueT<CcatadLru_SPEC> as RegisterValue<_>>::new(0)
1024 }
1025}
1026
1027#[doc(hidden)]
1028#[derive(Copy, Clone, Eq, PartialEq)]
1029pub struct CcatadTag_SPEC;
1030impl crate::sealed::RegSpec for CcatadTag_SPEC {
1031 type DataType = u32;
1032}
1033
1034#[doc = "C-Cache Test Access Data (TAG)"]
1035pub type CcatadTag = crate::RegValueT<CcatadTag_SPEC>;
1036
1037impl CcatadTag {
1038 #[doc = "C-Cache test access Dirty"]
1039 #[inline(always)]
1040 pub fn d(self) -> crate::common::RegisterFieldBool<0, 1, 0, CcatadTag_SPEC, crate::common::RW> {
1041 crate::common::RegisterFieldBool::<0,1,0,CcatadTag_SPEC,crate::common::RW>::from_register(self,0)
1042 }
1043
1044 #[doc = "C-Cache test access Valid"]
1045 #[inline(always)]
1046 pub fn v(self) -> crate::common::RegisterFieldBool<1, 1, 0, CcatadTag_SPEC, crate::common::RW> {
1047 crate::common::RegisterFieldBool::<1,1,0,CcatadTag_SPEC,crate::common::RW>::from_register(self,0)
1048 }
1049
1050 #[doc = "C-Cache test access Tag data"]
1051 #[inline(always)]
1052 pub fn tag(
1053 self,
1054 ) -> crate::common::RegisterField<12, 0xfffff, 1, 0, u32, u32, CcatadTag_SPEC, crate::common::RW>
1055 {
1056 crate::common::RegisterField::<12,0xfffff,1,0,u32,u32,CcatadTag_SPEC,crate::common::RW>::from_register(self,0)
1057 }
1058}
1059impl ::core::default::Default for CcatadTag {
1060 #[inline(always)]
1061 fn default() -> CcatadTag {
1062 <crate::RegValueT<CcatadTag_SPEC> as RegisterValue<_>>::new(0)
1063 }
1064}
1065
1066#[doc(hidden)]
1067#[derive(Copy, Clone, Eq, PartialEq)]
1068pub struct CcatadTagecc_SPEC;
1069impl crate::sealed::RegSpec for CcatadTagecc_SPEC {
1070 type DataType = u32;
1071}
1072
1073#[doc = "C-Cache Test Access Data (TAGECC)"]
1074pub type CcatadTagecc = crate::RegValueT<CcatadTagecc_SPEC>;
1075
1076impl CcatadTagecc {
1077 #[doc = "C-Cache test access Tag ECC code"]
1078 #[inline(always)]
1079 pub fn tagecc(
1080 self,
1081 ) -> crate::common::RegisterField<0, 0x7f, 1, 0, u8, u8, CcatadTagecc_SPEC, crate::common::RW>
1082 {
1083 crate::common::RegisterField::<0,0x7f,1,0,u8,u8,CcatadTagecc_SPEC,crate::common::RW>::from_register(self,0)
1084 }
1085}
1086impl ::core::default::Default for CcatadTagecc {
1087 #[inline(always)]
1088 fn default() -> CcatadTagecc {
1089 <crate::RegValueT<CcatadTagecc_SPEC> as RegisterValue<_>>::new(0)
1090 }
1091}
1092
1093#[doc(hidden)]
1094#[derive(Copy, Clone, Eq, PartialEq)]
1095pub struct Scactl_SPEC;
1096impl crate::sealed::RegSpec for Scactl_SPEC {
1097 type DataType = u32;
1098}
1099
1100#[doc = "S-Cache Control Register"]
1101pub type Scactl = crate::RegValueT<Scactl_SPEC>;
1102
1103impl Scactl {
1104 #[doc = "S-Cache enable bit"]
1105 #[inline(always)]
1106 pub fn ens(
1107 self,
1108 ) -> crate::common::RegisterField<
1109 0,
1110 0x1,
1111 1,
1112 0,
1113 scactl::Ens,
1114 scactl::Ens,
1115 Scactl_SPEC,
1116 crate::common::RW,
1117 > {
1118 crate::common::RegisterField::<
1119 0,
1120 0x1,
1121 1,
1122 0,
1123 scactl::Ens,
1124 scactl::Ens,
1125 Scactl_SPEC,
1126 crate::common::RW,
1127 >::from_register(self, 0)
1128 }
1129
1130 #[doc = "S-Cache flush bit"]
1131 #[inline(always)]
1132 pub fn fs(
1133 self,
1134 ) -> crate::common::RegisterField<
1135 8,
1136 0x1,
1137 1,
1138 0,
1139 scactl::Fs,
1140 scactl::Fs,
1141 Scactl_SPEC,
1142 crate::common::RW,
1143 > {
1144 crate::common::RegisterField::<
1145 8,
1146 0x1,
1147 1,
1148 0,
1149 scactl::Fs,
1150 scactl::Fs,
1151 Scactl_SPEC,
1152 crate::common::RW,
1153 >::from_register(self, 0)
1154 }
1155
1156 #[doc = "S-Cache write-back"]
1157 #[inline(always)]
1158 pub fn wb(
1159 self,
1160 ) -> crate::common::RegisterField<
1161 9,
1162 0x1,
1163 1,
1164 0,
1165 scactl::Wb,
1166 scactl::Wb,
1167 Scactl_SPEC,
1168 crate::common::RW,
1169 > {
1170 crate::common::RegisterField::<
1171 9,
1172 0x1,
1173 1,
1174 0,
1175 scactl::Wb,
1176 scactl::Wb,
1177 Scactl_SPEC,
1178 crate::common::RW,
1179 >::from_register(self, 0)
1180 }
1181}
1182impl ::core::default::Default for Scactl {
1183 #[inline(always)]
1184 fn default() -> Scactl {
1185 <crate::RegValueT<Scactl_SPEC> as RegisterValue<_>>::new(0)
1186 }
1187}
1188pub mod scactl {
1189
1190 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1191 pub struct Ens_SPEC;
1192 pub type Ens = crate::EnumBitfieldStruct<u8, Ens_SPEC>;
1193 impl Ens {
1194 #[doc = "S-Cache disable"]
1195 pub const _0: Self = Self::new(0);
1196
1197 #[doc = "S-Cache enable"]
1198 pub const _1: Self = Self::new(1);
1199 }
1200 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1201 pub struct Fs_SPEC;
1202 pub type Fs = crate::EnumBitfieldStruct<u8, Fs_SPEC>;
1203 impl Fs {
1204 #[doc = "No action"]
1205 pub const _0: Self = Self::new(0);
1206
1207 #[doc = "S-Cache line flush (all lines invalidate)"]
1208 pub const _1: Self = Self::new(1);
1209 }
1210 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1211 pub struct Wb_SPEC;
1212 pub type Wb = crate::EnumBitfieldStruct<u8, Wb_SPEC>;
1213 impl Wb {
1214 #[doc = "No action"]
1215 pub const _0: Self = Self::new(0);
1216
1217 #[doc = "S-Cache write-back"]
1218 pub const _1: Self = Self::new(1);
1219 }
1220}
1221#[doc(hidden)]
1222#[derive(Copy, Clone, Eq, PartialEq)]
1223pub struct Scafct_SPEC;
1224impl crate::sealed::RegSpec for Scafct_SPEC {
1225 type DataType = u32;
1226}
1227
1228#[doc = "S-Cache Flush Control Register"]
1229pub type Scafct = crate::RegValueT<Scafct_SPEC>;
1230
1231impl Scafct {
1232 #[doc = "S-Cache flush bit"]
1233 #[inline(always)]
1234 pub fn fs(
1235 self,
1236 ) -> crate::common::RegisterField<
1237 0,
1238 0x1,
1239 1,
1240 0,
1241 scafct::Fs,
1242 scafct::Fs,
1243 Scafct_SPEC,
1244 crate::common::RW,
1245 > {
1246 crate::common::RegisterField::<
1247 0,
1248 0x1,
1249 1,
1250 0,
1251 scafct::Fs,
1252 scafct::Fs,
1253 Scafct_SPEC,
1254 crate::common::RW,
1255 >::from_register(self, 0)
1256 }
1257
1258 #[doc = "S-Cache write-back"]
1259 #[inline(always)]
1260 pub fn wb(
1261 self,
1262 ) -> crate::common::RegisterField<
1263 1,
1264 0x1,
1265 1,
1266 0,
1267 scafct::Wb,
1268 scafct::Wb,
1269 Scafct_SPEC,
1270 crate::common::RW,
1271 > {
1272 crate::common::RegisterField::<
1273 1,
1274 0x1,
1275 1,
1276 0,
1277 scafct::Wb,
1278 scafct::Wb,
1279 Scafct_SPEC,
1280 crate::common::RW,
1281 >::from_register(self, 0)
1282 }
1283}
1284impl ::core::default::Default for Scafct {
1285 #[inline(always)]
1286 fn default() -> Scafct {
1287 <crate::RegValueT<Scafct_SPEC> as RegisterValue<_>>::new(0)
1288 }
1289}
1290pub mod scafct {
1291
1292 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1293 pub struct Fs_SPEC;
1294 pub type Fs = crate::EnumBitfieldStruct<u8, Fs_SPEC>;
1295 impl Fs {
1296 #[doc = "No action"]
1297 pub const _0: Self = Self::new(0);
1298
1299 #[doc = "S-Cache line flush (all lines invalidate)"]
1300 pub const _1: Self = Self::new(1);
1301 }
1302 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1303 pub struct Wb_SPEC;
1304 pub type Wb = crate::EnumBitfieldStruct<u8, Wb_SPEC>;
1305 impl Wb {
1306 #[doc = "No action"]
1307 pub const _0: Self = Self::new(0);
1308
1309 #[doc = "S-Cache write-back"]
1310 pub const _1: Self = Self::new(1);
1311 }
1312}
1313#[doc(hidden)]
1314#[derive(Copy, Clone, Eq, PartialEq)]
1315pub struct Scawta_SPEC;
1316impl crate::sealed::RegSpec for Scawta_SPEC {
1317 type DataType = u32;
1318}
1319
1320#[doc = "S-Cache Write Attribute"]
1321pub type Scawta = crate::RegValueT<Scawta_SPEC>;
1322
1323impl Scawta {
1324 #[doc = "S-Cache write-through"]
1325 #[inline(always)]
1326 pub fn wt(
1327 self,
1328 ) -> crate::common::RegisterField<
1329 0,
1330 0x1,
1331 1,
1332 0,
1333 scawta::Wt,
1334 scawta::Wt,
1335 Scawta_SPEC,
1336 crate::common::RW,
1337 > {
1338 crate::common::RegisterField::<
1339 0,
1340 0x1,
1341 1,
1342 0,
1343 scawta::Wt,
1344 scawta::Wt,
1345 Scawta_SPEC,
1346 crate::common::RW,
1347 >::from_register(self, 0)
1348 }
1349
1350 #[doc = "S-Cache write-allocation"]
1351 #[inline(always)]
1352 pub fn wa(
1353 self,
1354 ) -> crate::common::RegisterField<
1355 1,
1356 0x1,
1357 1,
1358 0,
1359 scawta::Wa,
1360 scawta::Wa,
1361 Scawta_SPEC,
1362 crate::common::RW,
1363 > {
1364 crate::common::RegisterField::<
1365 1,
1366 0x1,
1367 1,
1368 0,
1369 scawta::Wa,
1370 scawta::Wa,
1371 Scawta_SPEC,
1372 crate::common::RW,
1373 >::from_register(self, 0)
1374 }
1375}
1376impl ::core::default::Default for Scawta {
1377 #[inline(always)]
1378 fn default() -> Scawta {
1379 <crate::RegValueT<Scawta_SPEC> as RegisterValue<_>>::new(1)
1380 }
1381}
1382pub mod scawta {
1383
1384 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1385 pub struct Wt_SPEC;
1386 pub type Wt = crate::EnumBitfieldStruct<u8, Wt_SPEC>;
1387 impl Wt {
1388 #[doc = "Write-through or write-back depends on the cache attribute of the area"]
1389 pub const _0: Self = Self::new(0);
1390
1391 #[doc = "Always write-through mode"]
1392 pub const _1: Self = Self::new(1);
1393 }
1394 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1395 pub struct Wa_SPEC;
1396 pub type Wa = crate::EnumBitfieldStruct<u8, Wa_SPEC>;
1397 impl Wa {
1398 #[doc = "Always disable write-allocation"]
1399 pub const _0: Self = Self::new(0);
1400
1401 #[doc = "Write-allocation enable depends on the cache attribute of the area"]
1402 pub const _1: Self = Self::new(1);
1403 }
1404}
1405#[doc(hidden)]
1406#[derive(Copy, Clone, Eq, PartialEq)]
1407pub struct Scaedst_SPEC;
1408impl crate::sealed::RegSpec for Scaedst_SPEC {
1409 type DataType = u32;
1410}
1411
1412#[doc = "S-Cache Error Detection Status"]
1413pub type Scaedst = crate::RegValueT<Scaedst_SPEC>;
1414
1415impl Scaedst {
1416 #[doc = "S-Cache data error status 0"]
1417 #[inline(always)]
1418 pub fn esd0(
1419 self,
1420 ) -> crate::common::RegisterField<
1421 0,
1422 0x1,
1423 1,
1424 0,
1425 scaedst::Esd0,
1426 scaedst::Esd0,
1427 Scaedst_SPEC,
1428 crate::common::RW,
1429 > {
1430 crate::common::RegisterField::<
1431 0,
1432 0x1,
1433 1,
1434 0,
1435 scaedst::Esd0,
1436 scaedst::Esd0,
1437 Scaedst_SPEC,
1438 crate::common::RW,
1439 >::from_register(self, 0)
1440 }
1441
1442 #[doc = "S-Cache data error status 1"]
1443 #[inline(always)]
1444 pub fn esd1(
1445 self,
1446 ) -> crate::common::RegisterField<
1447 1,
1448 0x1,
1449 1,
1450 0,
1451 scaedst::Esd1,
1452 scaedst::Esd1,
1453 Scaedst_SPEC,
1454 crate::common::RW,
1455 > {
1456 crate::common::RegisterField::<
1457 1,
1458 0x1,
1459 1,
1460 0,
1461 scaedst::Esd1,
1462 scaedst::Esd1,
1463 Scaedst_SPEC,
1464 crate::common::RW,
1465 >::from_register(self, 0)
1466 }
1467
1468 #[doc = "S-Cache Tag clean line invalidate status"]
1469 #[inline(always)]
1470 pub fn estc(
1471 self,
1472 ) -> crate::common::RegisterField<
1473 2,
1474 0x1,
1475 1,
1476 0,
1477 scaedst::Estc,
1478 scaedst::Estc,
1479 Scaedst_SPEC,
1480 crate::common::RW,
1481 > {
1482 crate::common::RegisterField::<
1483 2,
1484 0x1,
1485 1,
1486 0,
1487 scaedst::Estc,
1488 scaedst::Estc,
1489 Scaedst_SPEC,
1490 crate::common::RW,
1491 >::from_register(self, 0)
1492 }
1493
1494 #[doc = "S-Cache Tag dirty line invalidate status"]
1495 #[inline(always)]
1496 pub fn estd(
1497 self,
1498 ) -> crate::common::RegisterField<
1499 3,
1500 0x1,
1501 1,
1502 0,
1503 scaedst::Estd,
1504 scaedst::Estd,
1505 Scaedst_SPEC,
1506 crate::common::RW,
1507 > {
1508 crate::common::RegisterField::<
1509 3,
1510 0x1,
1511 1,
1512 0,
1513 scaedst::Estd,
1514 scaedst::Estd,
1515 Scaedst_SPEC,
1516 crate::common::RW,
1517 >::from_register(self, 0)
1518 }
1519
1520 #[doc = "S-Cache Tag 2-bit error status"]
1521 #[inline(always)]
1522 pub fn est2(
1523 self,
1524 ) -> crate::common::RegisterField<
1525 4,
1526 0x1,
1527 1,
1528 0,
1529 scaedst::Est2,
1530 scaedst::Est2,
1531 Scaedst_SPEC,
1532 crate::common::RW,
1533 > {
1534 crate::common::RegisterField::<
1535 4,
1536 0x1,
1537 1,
1538 0,
1539 scaedst::Est2,
1540 scaedst::Est2,
1541 Scaedst_SPEC,
1542 crate::common::RW,
1543 >::from_register(self, 0)
1544 }
1545}
1546impl ::core::default::Default for Scaedst {
1547 #[inline(always)]
1548 fn default() -> Scaedst {
1549 <crate::RegValueT<Scaedst_SPEC> as RegisterValue<_>>::new(0)
1550 }
1551}
1552pub mod scaedst {
1553
1554 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1555 pub struct Esd0_SPEC;
1556 pub type Esd0 = crate::EnumBitfieldStruct<u8, Esd0_SPEC>;
1557 impl Esd0 {
1558 #[doc = "ECC 1-bit error was not detected"]
1559 pub const _0: Self = Self::new(0);
1560
1561 #[doc = "ECC 1-bit error was detected, and corrected"]
1562 pub const _1: Self = Self::new(1);
1563 }
1564 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1565 pub struct Esd1_SPEC;
1566 pub type Esd1 = crate::EnumBitfieldStruct<u8, Esd1_SPEC>;
1567 impl Esd1 {
1568 #[doc = "ECC 2-bit error was not detected"]
1569 pub const _0: Self = Self::new(0);
1570
1571 #[doc = "ECC 2-bit error was detected"]
1572 pub const _1: Self = Self::new(1);
1573 }
1574 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1575 pub struct Estc_SPEC;
1576 pub type Estc = crate::EnumBitfieldStruct<u8, Estc_SPEC>;
1577 impl Estc {
1578 #[doc = "Clean line was not invalidated"]
1579 pub const _0: Self = Self::new(0);
1580
1581 #[doc = "Clean line was invalidated"]
1582 pub const _1: Self = Self::new(1);
1583 }
1584 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1585 pub struct Estd_SPEC;
1586 pub type Estd = crate::EnumBitfieldStruct<u8, Estd_SPEC>;
1587 impl Estd {
1588 #[doc = "Dirty line was not invalidated"]
1589 pub const _0: Self = Self::new(0);
1590
1591 #[doc = "Dirty line was invalidated"]
1592 pub const _1: Self = Self::new(1);
1593 }
1594 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1595 pub struct Est2_SPEC;
1596 pub type Est2 = crate::EnumBitfieldStruct<u8, Est2_SPEC>;
1597 impl Est2 {
1598 #[doc = "ECC 2-bit error was not detected"]
1599 pub const _0: Self = Self::new(0);
1600
1601 #[doc = "ECC 2-bit error was detected"]
1602 pub const _1: Self = Self::new(1);
1603 }
1604}
1605#[doc(hidden)]
1606#[derive(Copy, Clone, Eq, PartialEq)]
1607pub struct Scataa_SPEC;
1608impl crate::sealed::RegSpec for Scataa_SPEC {
1609 type DataType = u32;
1610}
1611
1612#[doc = "S-Cache Test Access Address"]
1613pub type Scataa = crate::RegValueT<Scataa_SPEC>;
1614
1615impl Scataa {
1616 #[doc = "Address offset"]
1617 #[inline(always)]
1618 pub fn offset(
1619 self,
1620 ) -> crate::common::RegisterField<2, 0x7, 1, 0, u8, u8, Scataa_SPEC, crate::common::RW> {
1621 crate::common::RegisterField::<2,0x7,1,0,u8,u8,Scataa_SPEC,crate::common::RW>::from_register(self,0)
1622 }
1623
1624 #[doc = "Address entry"]
1625 #[inline(always)]
1626 pub fn entry(
1627 self,
1628 ) -> crate::common::RegisterField<5, 0x7f, 1, 0, u8, u8, Scataa_SPEC, crate::common::RW> {
1629 crate::common::RegisterField::<5,0x7f,1,0,u8,u8,Scataa_SPEC,crate::common::RW>::from_register(self,0)
1630 }
1631
1632 #[doc = "Access target"]
1633 #[inline(always)]
1634 pub fn target(
1635 self,
1636 ) -> crate::common::RegisterField<
1637 16,
1638 0x7,
1639 1,
1640 0,
1641 scataa::Target,
1642 scataa::Target,
1643 Scataa_SPEC,
1644 crate::common::RW,
1645 > {
1646 crate::common::RegisterField::<
1647 16,
1648 0x7,
1649 1,
1650 0,
1651 scataa::Target,
1652 scataa::Target,
1653 Scataa_SPEC,
1654 crate::common::RW,
1655 >::from_register(self, 0)
1656 }
1657
1658 #[doc = "Read write"]
1659 #[inline(always)]
1660 pub fn rw(
1661 self,
1662 ) -> crate::common::RegisterField<
1663 23,
1664 0x1,
1665 1,
1666 0,
1667 scataa::Rw,
1668 scataa::Rw,
1669 Scataa_SPEC,
1670 crate::common::RW,
1671 > {
1672 crate::common::RegisterField::<
1673 23,
1674 0x1,
1675 1,
1676 0,
1677 scataa::Rw,
1678 scataa::Rw,
1679 Scataa_SPEC,
1680 crate::common::RW,
1681 >::from_register(self, 0)
1682 }
1683
1684 #[doc = "Address way"]
1685 #[inline(always)]
1686 pub fn way(
1687 self,
1688 ) -> crate::common::RegisterField<30, 0x3, 1, 0, u8, u8, Scataa_SPEC, crate::common::RW> {
1689 crate::common::RegisterField::<30,0x3,1,0,u8,u8,Scataa_SPEC,crate::common::RW>::from_register(self,0)
1690 }
1691}
1692impl ::core::default::Default for Scataa {
1693 #[inline(always)]
1694 fn default() -> Scataa {
1695 <crate::RegValueT<Scataa_SPEC> as RegisterValue<_>>::new(0)
1696 }
1697}
1698pub mod scataa {
1699
1700 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1701 pub struct Target_SPEC;
1702 pub type Target = crate::EnumBitfieldStruct<u8, Target_SPEC>;
1703 impl Target {
1704 #[doc = "Cache data read or write"]
1705 pub const _000: Self = Self::new(0);
1706
1707 #[doc = "Data ECC code read or write"]
1708 pub const _001: Self = Self::new(1);
1709
1710 #[doc = "Tag, V, D read or write"]
1711 pub const _010: Self = Self::new(2);
1712
1713 #[doc = "LRU read or write"]
1714 pub const _011: Self = Self::new(3);
1715
1716 #[doc = "Tag ECC code read or write"]
1717 pub const _100: Self = Self::new(4);
1718
1719 #[doc = "Setting prohibited"]
1720 pub const OTHERS: Self = Self::new(0);
1721 }
1722 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1723 pub struct Rw_SPEC;
1724 pub type Rw = crate::EnumBitfieldStruct<u8, Rw_SPEC>;
1725 impl Rw {
1726 #[doc = "read"]
1727 pub const _0: Self = Self::new(0);
1728
1729 #[doc = "write"]
1730 pub const _1: Self = Self::new(1);
1731 }
1732}
1733#[doc(hidden)]
1734#[derive(Copy, Clone, Eq, PartialEq)]
1735pub struct ScatadData_SPEC;
1736impl crate::sealed::RegSpec for ScatadData_SPEC {
1737 type DataType = u32;
1738}
1739
1740#[doc = "S-Cache Test Access Data (DATA)"]
1741pub type ScatadData = crate::RegValueT<ScatadData_SPEC>;
1742
1743impl ScatadData {
1744 #[doc = "S-Cache test access data"]
1745 #[inline(always)]
1746 pub fn data(
1747 self,
1748 ) -> crate::common::RegisterField<
1749 0,
1750 0xffffffff,
1751 1,
1752 0,
1753 u32,
1754 u32,
1755 ScatadData_SPEC,
1756 crate::common::RW,
1757 > {
1758 crate::common::RegisterField::<
1759 0,
1760 0xffffffff,
1761 1,
1762 0,
1763 u32,
1764 u32,
1765 ScatadData_SPEC,
1766 crate::common::RW,
1767 >::from_register(self, 0)
1768 }
1769}
1770impl ::core::default::Default for ScatadData {
1771 #[inline(always)]
1772 fn default() -> ScatadData {
1773 <crate::RegValueT<ScatadData_SPEC> as RegisterValue<_>>::new(0)
1774 }
1775}
1776
1777#[doc(hidden)]
1778#[derive(Copy, Clone, Eq, PartialEq)]
1779pub struct ScatadEcc_SPEC;
1780impl crate::sealed::RegSpec for ScatadEcc_SPEC {
1781 type DataType = u32;
1782}
1783
1784#[doc = "S-Cache Test Access Data (ECC)"]
1785pub type ScatadEcc = crate::RegValueT<ScatadEcc_SPEC>;
1786
1787impl ScatadEcc {
1788 #[doc = "S-Cache test access ECC code"]
1789 #[inline(always)]
1790 pub fn ecc(
1791 self,
1792 ) -> crate::common::RegisterField<0, 0x7f, 1, 0, u8, u8, ScatadEcc_SPEC, crate::common::RW>
1793 {
1794 crate::common::RegisterField::<0,0x7f,1,0,u8,u8,ScatadEcc_SPEC,crate::common::RW>::from_register(self,0)
1795 }
1796}
1797impl ::core::default::Default for ScatadEcc {
1798 #[inline(always)]
1799 fn default() -> ScatadEcc {
1800 <crate::RegValueT<ScatadEcc_SPEC> as RegisterValue<_>>::new(0)
1801 }
1802}
1803
1804#[doc(hidden)]
1805#[derive(Copy, Clone, Eq, PartialEq)]
1806pub struct ScatadLru_SPEC;
1807impl crate::sealed::RegSpec for ScatadLru_SPEC {
1808 type DataType = u32;
1809}
1810
1811#[doc = "S-Cache Test Access Data (LRU)"]
1812pub type ScatadLru = crate::RegValueT<ScatadLru_SPEC>;
1813
1814impl ScatadLru {
1815 #[doc = "S-Cache test access LRU data"]
1816 #[inline(always)]
1817 pub fn lru(
1818 self,
1819 ) -> crate::common::RegisterField<0, 0x1f, 1, 0, u8, u8, ScatadLru_SPEC, crate::common::RW>
1820 {
1821 crate::common::RegisterField::<0,0x1f,1,0,u8,u8,ScatadLru_SPEC,crate::common::RW>::from_register(self,0)
1822 }
1823}
1824impl ::core::default::Default for ScatadLru {
1825 #[inline(always)]
1826 fn default() -> ScatadLru {
1827 <crate::RegValueT<ScatadLru_SPEC> as RegisterValue<_>>::new(0)
1828 }
1829}
1830
1831#[doc(hidden)]
1832#[derive(Copy, Clone, Eq, PartialEq)]
1833pub struct ScatadTag_SPEC;
1834impl crate::sealed::RegSpec for ScatadTag_SPEC {
1835 type DataType = u32;
1836}
1837
1838#[doc = "S-Cache Test Access Data (TAG)"]
1839pub type ScatadTag = crate::RegValueT<ScatadTag_SPEC>;
1840
1841impl ScatadTag {
1842 #[doc = "S-Cache test access Dirty"]
1843 #[inline(always)]
1844 pub fn d(self) -> crate::common::RegisterFieldBool<0, 1, 0, ScatadTag_SPEC, crate::common::RW> {
1845 crate::common::RegisterFieldBool::<0,1,0,ScatadTag_SPEC,crate::common::RW>::from_register(self,0)
1846 }
1847
1848 #[doc = "S-Cache test access Valid"]
1849 #[inline(always)]
1850 pub fn v(self) -> crate::common::RegisterFieldBool<1, 1, 0, ScatadTag_SPEC, crate::common::RW> {
1851 crate::common::RegisterFieldBool::<1,1,0,ScatadTag_SPEC,crate::common::RW>::from_register(self,0)
1852 }
1853
1854 #[doc = "S-Cache test access Tag data"]
1855 #[inline(always)]
1856 pub fn tag(
1857 self,
1858 ) -> crate::common::RegisterField<12, 0xfffff, 1, 0, u32, u32, ScatadTag_SPEC, crate::common::RW>
1859 {
1860 crate::common::RegisterField::<12,0xfffff,1,0,u32,u32,ScatadTag_SPEC,crate::common::RW>::from_register(self,0)
1861 }
1862}
1863impl ::core::default::Default for ScatadTag {
1864 #[inline(always)]
1865 fn default() -> ScatadTag {
1866 <crate::RegValueT<ScatadTag_SPEC> as RegisterValue<_>>::new(0)
1867 }
1868}
1869
1870#[doc(hidden)]
1871#[derive(Copy, Clone, Eq, PartialEq)]
1872pub struct Capoad_SPEC;
1873impl crate::sealed::RegSpec for Capoad_SPEC {
1874 type DataType = u32;
1875}
1876
1877#[doc = "Cache Parity Error Operation After Detection Register"]
1878pub type Capoad = crate::RegValueT<Capoad_SPEC>;
1879
1880impl Capoad {
1881 #[doc = "Operation after detection bit"]
1882 #[inline(always)]
1883 pub fn oad(
1884 self,
1885 ) -> crate::common::RegisterField<
1886 0,
1887 0x1,
1888 1,
1889 0,
1890 capoad::Oad,
1891 capoad::Oad,
1892 Capoad_SPEC,
1893 crate::common::RW,
1894 > {
1895 crate::common::RegisterField::<
1896 0,
1897 0x1,
1898 1,
1899 0,
1900 capoad::Oad,
1901 capoad::Oad,
1902 Capoad_SPEC,
1903 crate::common::RW,
1904 >::from_register(self, 0)
1905 }
1906
1907 #[doc = "ECC enable"]
1908 #[inline(always)]
1909 pub fn eccmod1(
1910 self,
1911 ) -> crate::common::RegisterField<
1912 3,
1913 0x1,
1914 1,
1915 0,
1916 capoad::Eccmod1,
1917 capoad::Eccmod1,
1918 Capoad_SPEC,
1919 crate::common::RW,
1920 > {
1921 crate::common::RegisterField::<
1922 3,
1923 0x1,
1924 1,
1925 0,
1926 capoad::Eccmod1,
1927 capoad::Eccmod1,
1928 Capoad_SPEC,
1929 crate::common::RW,
1930 >::from_register(self, 0)
1931 }
1932
1933 #[doc = "ECC correctable error information update enable"]
1934 #[inline(always)]
1935 pub fn e1stsen(
1936 self,
1937 ) -> crate::common::RegisterField<
1938 4,
1939 0x1,
1940 1,
1941 0,
1942 capoad::E1Stsen,
1943 capoad::E1Stsen,
1944 Capoad_SPEC,
1945 crate::common::RW,
1946 > {
1947 crate::common::RegisterField::<
1948 4,
1949 0x1,
1950 1,
1951 0,
1952 capoad::E1Stsen,
1953 capoad::E1Stsen,
1954 Capoad_SPEC,
1955 crate::common::RW,
1956 >::from_register(self, 0)
1957 }
1958}
1959impl ::core::default::Default for Capoad {
1960 #[inline(always)]
1961 fn default() -> Capoad {
1962 <crate::RegValueT<Capoad_SPEC> as RegisterValue<_>>::new(0)
1963 }
1964}
1965pub mod capoad {
1966
1967 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1968 pub struct Oad_SPEC;
1969 pub type Oad = crate::EnumBitfieldStruct<u8, Oad_SPEC>;
1970 impl Oad {
1971 #[doc = "Interrupt"]
1972 pub const _0: Self = Self::new(0);
1973
1974 #[doc = "Reset"]
1975 pub const _1: Self = Self::new(1);
1976 }
1977 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1978 pub struct Eccmod1_SPEC;
1979 pub type Eccmod1 = crate::EnumBitfieldStruct<u8, Eccmod1_SPEC>;
1980 impl Eccmod1 {
1981 #[doc = "Disable ECC"]
1982 pub const _0: Self = Self::new(0);
1983
1984 #[doc = "Enable ECC"]
1985 pub const _1: Self = Self::new(1);
1986 }
1987 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1988 pub struct E1Stsen_SPEC;
1989 pub type E1Stsen = crate::EnumBitfieldStruct<u8, E1Stsen_SPEC>;
1990 impl E1Stsen {
1991 #[doc = "Disable updating of correctable ECC error information"]
1992 pub const _0: Self = Self::new(0);
1993
1994 #[doc = "Enable updating of correctable ECC error information"]
1995 pub const _1: Self = Self::new(1);
1996 }
1997}
1998#[doc(hidden)]
1999#[derive(Copy, Clone, Eq, PartialEq)]
2000pub struct Caprcr_SPEC;
2001impl crate::sealed::RegSpec for Caprcr_SPEC {
2002 type DataType = u32;
2003}
2004
2005#[doc = "Cache Protection Register"]
2006pub type Caprcr = crate::RegValueT<Caprcr_SPEC>;
2007
2008impl Caprcr {
2009 #[doc = "Register Write Control bit"]
2010 #[inline(always)]
2011 pub fn prcr(
2012 self,
2013 ) -> crate::common::RegisterField<
2014 0,
2015 0x1,
2016 1,
2017 0,
2018 caprcr::Prcr,
2019 caprcr::Prcr,
2020 Caprcr_SPEC,
2021 crate::common::RW,
2022 > {
2023 crate::common::RegisterField::<
2024 0,
2025 0x1,
2026 1,
2027 0,
2028 caprcr::Prcr,
2029 caprcr::Prcr,
2030 Caprcr_SPEC,
2031 crate::common::RW,
2032 >::from_register(self, 0)
2033 }
2034
2035 #[doc = "Write Key Code bit"]
2036 #[inline(always)]
2037 pub fn kw(
2038 self,
2039 ) -> crate::common::RegisterField<1, 0x7f, 1, 0, u8, u8, Caprcr_SPEC, crate::common::RW> {
2040 crate::common::RegisterField::<1,0x7f,1,0,u8,u8,Caprcr_SPEC,crate::common::RW>::from_register(self,0)
2041 }
2042}
2043impl ::core::default::Default for Caprcr {
2044 #[inline(always)]
2045 fn default() -> Caprcr {
2046 <crate::RegValueT<Caprcr_SPEC> as RegisterValue<_>>::new(0)
2047 }
2048}
2049pub mod caprcr {
2050
2051 #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2052 pub struct Prcr_SPEC;
2053 pub type Prcr = crate::EnumBitfieldStruct<u8, Prcr_SPEC>;
2054 impl Prcr {
2055 #[doc = "Writing to the protected register is disabled"]
2056 pub const _0: Self = Self::new(0);
2057
2058 #[doc = "Writing to the protected register is enabled"]
2059 pub const _1: Self = Self::new(1);
2060 }
2061}