#[doc = "Reader of register CLIDR"]
pub type R = crate::R<u32, super::CLIDR>;
#[doc = "Indicate the type of cache implemented at level 1.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum CL1_A {
#[doc = "0: No cache"]
CL1_0 = 0,
#[doc = "1: Instruction cache only"]
CL1_1 = 1,
#[doc = "2: Data cache only"]
CL1_2 = 2,
#[doc = "3: Separate instruction and data caches"]
CL1_3 = 3,
#[doc = "4: Unified cache"]
CL1_4 = 4,
}
impl From<CL1_A> for u8 {
#[inline(always)]
fn from(variant: CL1_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `CL1`"]
pub type CL1_R = crate::R<u8, CL1_A>;
impl CL1_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CL1_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CL1_A::CL1_0),
1 => Val(CL1_A::CL1_1),
2 => Val(CL1_A::CL1_2),
3 => Val(CL1_A::CL1_3),
4 => Val(CL1_A::CL1_4),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CL1_0`"]
#[inline(always)]
pub fn is_cl1_0(&self) -> bool {
*self == CL1_A::CL1_0
}
#[doc = "Checks if the value of the field is `CL1_1`"]
#[inline(always)]
pub fn is_cl1_1(&self) -> bool {
*self == CL1_A::CL1_1
}
#[doc = "Checks if the value of the field is `CL1_2`"]
#[inline(always)]
pub fn is_cl1_2(&self) -> bool {
*self == CL1_A::CL1_2
}
#[doc = "Checks if the value of the field is `CL1_3`"]
#[inline(always)]
pub fn is_cl1_3(&self) -> bool {
*self == CL1_A::CL1_3
}
#[doc = "Checks if the value of the field is `CL1_4`"]
#[inline(always)]
pub fn is_cl1_4(&self) -> bool {
*self == CL1_A::CL1_4
}
}
#[doc = "Indicate the type of cache implemented at level 2.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum CL2_A {
#[doc = "0: No cache"]
CL2_0 = 0,
#[doc = "1: Instruction cache only"]
CL2_1 = 1,
#[doc = "2: Data cache only"]
CL2_2 = 2,
#[doc = "3: Separate instruction and data caches"]
CL2_3 = 3,
#[doc = "4: Unified cache"]
CL2_4 = 4,
}
impl From<CL2_A> for u8 {
#[inline(always)]
fn from(variant: CL2_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `CL2`"]
pub type CL2_R = crate::R<u8, CL2_A>;
impl CL2_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CL2_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CL2_A::CL2_0),
1 => Val(CL2_A::CL2_1),
2 => Val(CL2_A::CL2_2),
3 => Val(CL2_A::CL2_3),
4 => Val(CL2_A::CL2_4),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CL2_0`"]
#[inline(always)]
pub fn is_cl2_0(&self) -> bool {
*self == CL2_A::CL2_0
}
#[doc = "Checks if the value of the field is `CL2_1`"]
#[inline(always)]
pub fn is_cl2_1(&self) -> bool {
*self == CL2_A::CL2_1
}
#[doc = "Checks if the value of the field is `CL2_2`"]
#[inline(always)]
pub fn is_cl2_2(&self) -> bool {
*self == CL2_A::CL2_2
}
#[doc = "Checks if the value of the field is `CL2_3`"]
#[inline(always)]
pub fn is_cl2_3(&self) -> bool {
*self == CL2_A::CL2_3
}
#[doc = "Checks if the value of the field is `CL2_4`"]
#[inline(always)]
pub fn is_cl2_4(&self) -> bool {
*self == CL2_A::CL2_4
}
}
#[doc = "Indicate the type of cache implemented at level 3.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum CL3_A {
#[doc = "0: No cache"]
CL3_0 = 0,
#[doc = "1: Instruction cache only"]
CL3_1 = 1,
#[doc = "2: Data cache only"]
CL3_2 = 2,
#[doc = "3: Separate instruction and data caches"]
CL3_3 = 3,
#[doc = "4: Unified cache"]
CL3_4 = 4,
}
impl From<CL3_A> for u8 {
#[inline(always)]
fn from(variant: CL3_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `CL3`"]
pub type CL3_R = crate::R<u8, CL3_A>;
impl CL3_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CL3_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CL3_A::CL3_0),
1 => Val(CL3_A::CL3_1),
2 => Val(CL3_A::CL3_2),
3 => Val(CL3_A::CL3_3),
4 => Val(CL3_A::CL3_4),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CL3_0`"]
#[inline(always)]
pub fn is_cl3_0(&self) -> bool {
*self == CL3_A::CL3_0
}
#[doc = "Checks if the value of the field is `CL3_1`"]
#[inline(always)]
pub fn is_cl3_1(&self) -> bool {
*self == CL3_A::CL3_1
}
#[doc = "Checks if the value of the field is `CL3_2`"]
#[inline(always)]
pub fn is_cl3_2(&self) -> bool {
*self == CL3_A::CL3_2
}
#[doc = "Checks if the value of the field is `CL3_3`"]
#[inline(always)]
pub fn is_cl3_3(&self) -> bool {
*self == CL3_A::CL3_3
}
#[doc = "Checks if the value of the field is `CL3_4`"]
#[inline(always)]
pub fn is_cl3_4(&self) -> bool {
*self == CL3_A::CL3_4
}
}
#[doc = "Indicate the type of cache implemented at level 4.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum CL4_A {
#[doc = "0: No cache"]
CL4_0 = 0,
#[doc = "1: Instruction cache only"]
CL4_1 = 1,
#[doc = "2: Data cache only"]
CL4_2 = 2,
#[doc = "3: Separate instruction and data caches"]
CL4_3 = 3,
#[doc = "4: Unified cache"]
CL4_4 = 4,
}
impl From<CL4_A> for u8 {
#[inline(always)]
fn from(variant: CL4_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `CL4`"]
pub type CL4_R = crate::R<u8, CL4_A>;
impl CL4_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CL4_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CL4_A::CL4_0),
1 => Val(CL4_A::CL4_1),
2 => Val(CL4_A::CL4_2),
3 => Val(CL4_A::CL4_3),
4 => Val(CL4_A::CL4_4),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CL4_0`"]
#[inline(always)]
pub fn is_cl4_0(&self) -> bool {
*self == CL4_A::CL4_0
}
#[doc = "Checks if the value of the field is `CL4_1`"]
#[inline(always)]
pub fn is_cl4_1(&self) -> bool {
*self == CL4_A::CL4_1
}
#[doc = "Checks if the value of the field is `CL4_2`"]
#[inline(always)]
pub fn is_cl4_2(&self) -> bool {
*self == CL4_A::CL4_2
}
#[doc = "Checks if the value of the field is `CL4_3`"]
#[inline(always)]
pub fn is_cl4_3(&self) -> bool {
*self == CL4_A::CL4_3
}
#[doc = "Checks if the value of the field is `CL4_4`"]
#[inline(always)]
pub fn is_cl4_4(&self) -> bool {
*self == CL4_A::CL4_4
}
}
#[doc = "Indicate the type of cache implemented at level 5.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum CL5_A {
#[doc = "0: No cache"]
CL5_0 = 0,
#[doc = "1: Instruction cache only"]
CL5_1 = 1,
#[doc = "2: Data cache only"]
CL5_2 = 2,
#[doc = "3: Separate instruction and data caches"]
CL5_3 = 3,
#[doc = "4: Unified cache"]
CL5_4 = 4,
}
impl From<CL5_A> for u8 {
#[inline(always)]
fn from(variant: CL5_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `CL5`"]
pub type CL5_R = crate::R<u8, CL5_A>;
impl CL5_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CL5_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CL5_A::CL5_0),
1 => Val(CL5_A::CL5_1),
2 => Val(CL5_A::CL5_2),
3 => Val(CL5_A::CL5_3),
4 => Val(CL5_A::CL5_4),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CL5_0`"]
#[inline(always)]
pub fn is_cl5_0(&self) -> bool {
*self == CL5_A::CL5_0
}
#[doc = "Checks if the value of the field is `CL5_1`"]
#[inline(always)]
pub fn is_cl5_1(&self) -> bool {
*self == CL5_A::CL5_1
}
#[doc = "Checks if the value of the field is `CL5_2`"]
#[inline(always)]
pub fn is_cl5_2(&self) -> bool {
*self == CL5_A::CL5_2
}
#[doc = "Checks if the value of the field is `CL5_3`"]
#[inline(always)]
pub fn is_cl5_3(&self) -> bool {
*self == CL5_A::CL5_3
}
#[doc = "Checks if the value of the field is `CL5_4`"]
#[inline(always)]
pub fn is_cl5_4(&self) -> bool {
*self == CL5_A::CL5_4
}
}
#[doc = "Indicate the type of cache implemented at level 6.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum CL6_A {
#[doc = "0: No cache"]
CL6_0 = 0,
#[doc = "1: Instruction cache only"]
CL6_1 = 1,
#[doc = "2: Data cache only"]
CL6_2 = 2,
#[doc = "3: Separate instruction and data caches"]
CL6_3 = 3,
#[doc = "4: Unified cache"]
CL6_4 = 4,
}
impl From<CL6_A> for u8 {
#[inline(always)]
fn from(variant: CL6_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `CL6`"]
pub type CL6_R = crate::R<u8, CL6_A>;
impl CL6_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CL6_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CL6_A::CL6_0),
1 => Val(CL6_A::CL6_1),
2 => Val(CL6_A::CL6_2),
3 => Val(CL6_A::CL6_3),
4 => Val(CL6_A::CL6_4),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CL6_0`"]
#[inline(always)]
pub fn is_cl6_0(&self) -> bool {
*self == CL6_A::CL6_0
}
#[doc = "Checks if the value of the field is `CL6_1`"]
#[inline(always)]
pub fn is_cl6_1(&self) -> bool {
*self == CL6_A::CL6_1
}
#[doc = "Checks if the value of the field is `CL6_2`"]
#[inline(always)]
pub fn is_cl6_2(&self) -> bool {
*self == CL6_A::CL6_2
}
#[doc = "Checks if the value of the field is `CL6_3`"]
#[inline(always)]
pub fn is_cl6_3(&self) -> bool {
*self == CL6_A::CL6_3
}
#[doc = "Checks if the value of the field is `CL6_4`"]
#[inline(always)]
pub fn is_cl6_4(&self) -> bool {
*self == CL6_A::CL6_4
}
}
#[doc = "Indicate the type of cache implemented at level 7.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum CL7_A {
#[doc = "0: No cache"]
CL7_0 = 0,
#[doc = "1: Instruction cache only"]
CL7_1 = 1,
#[doc = "2: Data cache only"]
CL7_2 = 2,
#[doc = "3: Separate instruction and data caches"]
CL7_3 = 3,
#[doc = "4: Unified cache"]
CL7_4 = 4,
}
impl From<CL7_A> for u8 {
#[inline(always)]
fn from(variant: CL7_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `CL7`"]
pub type CL7_R = crate::R<u8, CL7_A>;
impl CL7_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, CL7_A> {
use crate::Variant::*;
match self.bits {
0 => Val(CL7_A::CL7_0),
1 => Val(CL7_A::CL7_1),
2 => Val(CL7_A::CL7_2),
3 => Val(CL7_A::CL7_3),
4 => Val(CL7_A::CL7_4),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `CL7_0`"]
#[inline(always)]
pub fn is_cl7_0(&self) -> bool {
*self == CL7_A::CL7_0
}
#[doc = "Checks if the value of the field is `CL7_1`"]
#[inline(always)]
pub fn is_cl7_1(&self) -> bool {
*self == CL7_A::CL7_1
}
#[doc = "Checks if the value of the field is `CL7_2`"]
#[inline(always)]
pub fn is_cl7_2(&self) -> bool {
*self == CL7_A::CL7_2
}
#[doc = "Checks if the value of the field is `CL7_3`"]
#[inline(always)]
pub fn is_cl7_3(&self) -> bool {
*self == CL7_A::CL7_3
}
#[doc = "Checks if the value of the field is `CL7_4`"]
#[inline(always)]
pub fn is_cl7_4(&self) -> bool {
*self == CL7_A::CL7_4
}
}
#[doc = "Level of Unification Inner Shareable for the cache hierarchy. This field is RAZ.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum LOUIS_A {
#[doc = "0: 0"]
LOUIS_0 = 0,
#[doc = "1: 1"]
LOUIS_1 = 1,
#[doc = "2: 2"]
LOUIS_2 = 2,
#[doc = "3: 3"]
LOUIS_3 = 3,
#[doc = "4: 4"]
LOUIS_4 = 4,
#[doc = "5: 5"]
LOUIS_5 = 5,
#[doc = "6: 6"]
LOUIS_6 = 6,
#[doc = "7: 7"]
LOUIS_7 = 7,
}
impl From<LOUIS_A> for u8 {
#[inline(always)]
fn from(variant: LOUIS_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `LOUIS`"]
pub type LOUIS_R = crate::R<u8, LOUIS_A>;
impl LOUIS_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LOUIS_A {
match self.bits {
0 => LOUIS_A::LOUIS_0,
1 => LOUIS_A::LOUIS_1,
2 => LOUIS_A::LOUIS_2,
3 => LOUIS_A::LOUIS_3,
4 => LOUIS_A::LOUIS_4,
5 => LOUIS_A::LOUIS_5,
6 => LOUIS_A::LOUIS_6,
7 => LOUIS_A::LOUIS_7,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `LOUIS_0`"]
#[inline(always)]
pub fn is_louis_0(&self) -> bool {
*self == LOUIS_A::LOUIS_0
}
#[doc = "Checks if the value of the field is `LOUIS_1`"]
#[inline(always)]
pub fn is_louis_1(&self) -> bool {
*self == LOUIS_A::LOUIS_1
}
#[doc = "Checks if the value of the field is `LOUIS_2`"]
#[inline(always)]
pub fn is_louis_2(&self) -> bool {
*self == LOUIS_A::LOUIS_2
}
#[doc = "Checks if the value of the field is `LOUIS_3`"]
#[inline(always)]
pub fn is_louis_3(&self) -> bool {
*self == LOUIS_A::LOUIS_3
}
#[doc = "Checks if the value of the field is `LOUIS_4`"]
#[inline(always)]
pub fn is_louis_4(&self) -> bool {
*self == LOUIS_A::LOUIS_4
}
#[doc = "Checks if the value of the field is `LOUIS_5`"]
#[inline(always)]
pub fn is_louis_5(&self) -> bool {
*self == LOUIS_A::LOUIS_5
}
#[doc = "Checks if the value of the field is `LOUIS_6`"]
#[inline(always)]
pub fn is_louis_6(&self) -> bool {
*self == LOUIS_A::LOUIS_6
}
#[doc = "Checks if the value of the field is `LOUIS_7`"]
#[inline(always)]
pub fn is_louis_7(&self) -> bool {
*self == LOUIS_A::LOUIS_7
}
}
#[doc = "Level of Coherency for the cache hierarchy\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum LOC_A {
#[doc = "0: 0"]
LOC_0 = 0,
#[doc = "1: 1"]
LOC_1 = 1,
#[doc = "2: 2"]
LOC_2 = 2,
#[doc = "3: 3"]
LOC_3 = 3,
#[doc = "4: 4"]
LOC_4 = 4,
#[doc = "5: 5"]
LOC_5 = 5,
#[doc = "6: 6"]
LOC_6 = 6,
#[doc = "7: 7"]
LOC_7 = 7,
}
impl From<LOC_A> for u8 {
#[inline(always)]
fn from(variant: LOC_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `LOC`"]
pub type LOC_R = crate::R<u8, LOC_A>;
impl LOC_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LOC_A {
match self.bits {
0 => LOC_A::LOC_0,
1 => LOC_A::LOC_1,
2 => LOC_A::LOC_2,
3 => LOC_A::LOC_3,
4 => LOC_A::LOC_4,
5 => LOC_A::LOC_5,
6 => LOC_A::LOC_6,
7 => LOC_A::LOC_7,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `LOC_0`"]
#[inline(always)]
pub fn is_loc_0(&self) -> bool {
*self == LOC_A::LOC_0
}
#[doc = "Checks if the value of the field is `LOC_1`"]
#[inline(always)]
pub fn is_loc_1(&self) -> bool {
*self == LOC_A::LOC_1
}
#[doc = "Checks if the value of the field is `LOC_2`"]
#[inline(always)]
pub fn is_loc_2(&self) -> bool {
*self == LOC_A::LOC_2
}
#[doc = "Checks if the value of the field is `LOC_3`"]
#[inline(always)]
pub fn is_loc_3(&self) -> bool {
*self == LOC_A::LOC_3
}
#[doc = "Checks if the value of the field is `LOC_4`"]
#[inline(always)]
pub fn is_loc_4(&self) -> bool {
*self == LOC_A::LOC_4
}
#[doc = "Checks if the value of the field is `LOC_5`"]
#[inline(always)]
pub fn is_loc_5(&self) -> bool {
*self == LOC_A::LOC_5
}
#[doc = "Checks if the value of the field is `LOC_6`"]
#[inline(always)]
pub fn is_loc_6(&self) -> bool {
*self == LOC_A::LOC_6
}
#[doc = "Checks if the value of the field is `LOC_7`"]
#[inline(always)]
pub fn is_loc_7(&self) -> bool {
*self == LOC_A::LOC_7
}
}
#[doc = "Level of Unification for the cache hierarchy\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum LOU_A {
#[doc = "0: 0"]
LOU_0 = 0,
#[doc = "1: 1"]
LOU_1 = 1,
#[doc = "2: 2"]
LOU_2 = 2,
#[doc = "3: 3"]
LOU_3 = 3,
#[doc = "4: 4"]
LOU_4 = 4,
#[doc = "5: 5"]
LOU_5 = 5,
#[doc = "6: 6"]
LOU_6 = 6,
#[doc = "7: 7"]
LOU_7 = 7,
}
impl From<LOU_A> for u8 {
#[inline(always)]
fn from(variant: LOU_A) -> Self {
variant as _
}
}
#[doc = "Reader of field `LOU`"]
pub type LOU_R = crate::R<u8, LOU_A>;
impl LOU_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LOU_A {
match self.bits {
0 => LOU_A::LOU_0,
1 => LOU_A::LOU_1,
2 => LOU_A::LOU_2,
3 => LOU_A::LOU_3,
4 => LOU_A::LOU_4,
5 => LOU_A::LOU_5,
6 => LOU_A::LOU_6,
7 => LOU_A::LOU_7,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `LOU_0`"]
#[inline(always)]
pub fn is_lou_0(&self) -> bool {
*self == LOU_A::LOU_0
}
#[doc = "Checks if the value of the field is `LOU_1`"]
#[inline(always)]
pub fn is_lou_1(&self) -> bool {
*self == LOU_A::LOU_1
}
#[doc = "Checks if the value of the field is `LOU_2`"]
#[inline(always)]
pub fn is_lou_2(&self) -> bool {
*self == LOU_A::LOU_2
}
#[doc = "Checks if the value of the field is `LOU_3`"]
#[inline(always)]
pub fn is_lou_3(&self) -> bool {
*self == LOU_A::LOU_3
}
#[doc = "Checks if the value of the field is `LOU_4`"]
#[inline(always)]
pub fn is_lou_4(&self) -> bool {
*self == LOU_A::LOU_4
}
#[doc = "Checks if the value of the field is `LOU_5`"]
#[inline(always)]
pub fn is_lou_5(&self) -> bool {
*self == LOU_A::LOU_5
}
#[doc = "Checks if the value of the field is `LOU_6`"]
#[inline(always)]
pub fn is_lou_6(&self) -> bool {
*self == LOU_A::LOU_6
}
#[doc = "Checks if the value of the field is `LOU_7`"]
#[inline(always)]
pub fn is_lou_7(&self) -> bool {
*self == LOU_A::LOU_7
}
}
impl R {
#[doc = "Bits 0:2 - Indicate the type of cache implemented at level 1."]
#[inline(always)]
pub fn cl1(&self) -> CL1_R {
CL1_R::new((self.bits & 0x07) as u8)
}
#[doc = "Bits 3:5 - Indicate the type of cache implemented at level 2."]
#[inline(always)]
pub fn cl2(&self) -> CL2_R {
CL2_R::new(((self.bits >> 3) & 0x07) as u8)
}
#[doc = "Bits 6:8 - Indicate the type of cache implemented at level 3."]
#[inline(always)]
pub fn cl3(&self) -> CL3_R {
CL3_R::new(((self.bits >> 6) & 0x07) as u8)
}
#[doc = "Bits 9:11 - Indicate the type of cache implemented at level 4."]
#[inline(always)]
pub fn cl4(&self) -> CL4_R {
CL4_R::new(((self.bits >> 9) & 0x07) as u8)
}
#[doc = "Bits 12:14 - Indicate the type of cache implemented at level 5."]
#[inline(always)]
pub fn cl5(&self) -> CL5_R {
CL5_R::new(((self.bits >> 12) & 0x07) as u8)
}
#[doc = "Bits 15:17 - Indicate the type of cache implemented at level 6."]
#[inline(always)]
pub fn cl6(&self) -> CL6_R {
CL6_R::new(((self.bits >> 15) & 0x07) as u8)
}
#[doc = "Bits 18:20 - Indicate the type of cache implemented at level 7."]
#[inline(always)]
pub fn cl7(&self) -> CL7_R {
CL7_R::new(((self.bits >> 18) & 0x07) as u8)
}
#[doc = "Bits 21:23 - Level of Unification Inner Shareable for the cache hierarchy. This field is RAZ."]
#[inline(always)]
pub fn louis(&self) -> LOUIS_R {
LOUIS_R::new(((self.bits >> 21) & 0x07) as u8)
}
#[doc = "Bits 24:26 - Level of Coherency for the cache hierarchy"]
#[inline(always)]
pub fn loc(&self) -> LOC_R {
LOC_R::new(((self.bits >> 24) & 0x07) as u8)
}
#[doc = "Bits 27:29 - Level of Unification for the cache hierarchy"]
#[inline(always)]
pub fn lou(&self) -> LOU_R {
LOU_R::new(((self.bits >> 27) & 0x07) as u8)
}
}