mcxa-pac 0.3.0

Peripheral Access Crate for MCXA256 devices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

#[doc = "Register `PKC_VERSION` reader"]
pub type R = crate::R<PkcVersionSpec>;
#[doc = "Native multiplier size and operand granularity\n\nValue on reset: 2"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum Mulsize {
    #[doc = "2: 64-bit multiplier"]
    Bit64 = 2,
}
impl From<Mulsize> for u8 {
    #[inline(always)]
    fn from(variant: Mulsize) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for Mulsize {
    type Ux = u8;
}
impl crate::IsEnum for Mulsize {}
#[doc = "Field `MULSIZE` reader - Native multiplier size and operand granularity"]
pub type MulsizeR = crate::FieldReader<Mulsize>;
impl MulsizeR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<Mulsize> {
        match self.bits {
            2 => Some(Mulsize::Bit64),
            _ => None,
        }
    }
    #[doc = "64-bit multiplier"]
    #[inline(always)]
    pub fn is_bit64(&self) -> bool {
        *self == Mulsize::Bit64
    }
}
#[doc = "Field `MCAVAIL` reader - MC feature (layer1 calculation) is available"]
pub type McavailR = crate::BitReader;
#[doc = "Field `UPAVAIL` reader - UP feature (layer2 calculation) is available"]
pub type UpavailR = crate::BitReader;
#[doc = "Field `UPCACHEAVAIL` reader - UP cache is available"]
pub type UpcacheavailR = crate::BitReader;
#[doc = "Field `GF2AVAIL` reader - GF2 calculation modes are available"]
pub type Gf2availR = crate::BitReader;
#[doc = "Field `PARAMNUM` reader - Number of parameter sets for real calculation"]
pub type ParamnumR = crate::FieldReader;
#[doc = "Field `SBX0AVAIL` reader - SBX0 operation is available"]
pub type Sbx0availR = crate::BitReader;
#[doc = "Field `SBX1AVAIL` reader - SBX1 operation is available"]
pub type Sbx1availR = crate::BitReader;
#[doc = "Field `SBX2AVAIL` reader - SBX2 operation is available"]
pub type Sbx2availR = crate::BitReader;
#[doc = "Field `SBX3AVAIL` reader - SBX3 operation is available"]
pub type Sbx3availR = crate::BitReader;
#[doc = "Field `MCRECONF_SIZE` reader - Size of reconfigurable MC table in bytes."]
pub type McreconfSizeR = crate::FieldReader;
impl R {
    #[doc = "Bits 0:1 - Native multiplier size and operand granularity"]
    #[inline(always)]
    pub fn mulsize(&self) -> MulsizeR {
        MulsizeR::new((self.bits & 3) as u8)
    }
    #[doc = "Bit 2 - MC feature (layer1 calculation) is available"]
    #[inline(always)]
    pub fn mcavail(&self) -> McavailR {
        McavailR::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - UP feature (layer2 calculation) is available"]
    #[inline(always)]
    pub fn upavail(&self) -> UpavailR {
        UpavailR::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 4 - UP cache is available"]
    #[inline(always)]
    pub fn upcacheavail(&self) -> UpcacheavailR {
        UpcacheavailR::new(((self.bits >> 4) & 1) != 0)
    }
    #[doc = "Bit 5 - GF2 calculation modes are available"]
    #[inline(always)]
    pub fn gf2avail(&self) -> Gf2availR {
        Gf2availR::new(((self.bits >> 5) & 1) != 0)
    }
    #[doc = "Bits 6:7 - Number of parameter sets for real calculation"]
    #[inline(always)]
    pub fn paramnum(&self) -> ParamnumR {
        ParamnumR::new(((self.bits >> 6) & 3) as u8)
    }
    #[doc = "Bit 8 - SBX0 operation is available"]
    #[inline(always)]
    pub fn sbx0avail(&self) -> Sbx0availR {
        Sbx0availR::new(((self.bits >> 8) & 1) != 0)
    }
    #[doc = "Bit 9 - SBX1 operation is available"]
    #[inline(always)]
    pub fn sbx1avail(&self) -> Sbx1availR {
        Sbx1availR::new(((self.bits >> 9) & 1) != 0)
    }
    #[doc = "Bit 10 - SBX2 operation is available"]
    #[inline(always)]
    pub fn sbx2avail(&self) -> Sbx2availR {
        Sbx2availR::new(((self.bits >> 10) & 1) != 0)
    }
    #[doc = "Bit 11 - SBX3 operation is available"]
    #[inline(always)]
    pub fn sbx3avail(&self) -> Sbx3availR {
        Sbx3availR::new(((self.bits >> 11) & 1) != 0)
    }
    #[doc = "Bits 12:19 - Size of reconfigurable MC table in bytes."]
    #[inline(always)]
    pub fn mcreconf_size(&self) -> McreconfSizeR {
        McreconfSizeR::new(((self.bits >> 12) & 0xff) as u8)
    }
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("PKC_VERSION")
            .field("mulsize", &self.mulsize())
            .field("mcavail", &self.mcavail())
            .field("upavail", &self.upavail())
            .field("upcacheavail", &self.upcacheavail())
            .field("gf2avail", &self.gf2avail())
            .field("paramnum", &self.paramnum())
            .field("sbx0avail", &self.sbx0avail())
            .field("sbx1avail", &self.sbx1avail())
            .field("sbx2avail", &self.sbx2avail())
            .field("sbx3avail", &self.sbx3avail())
            .field("mcreconf_size", &self.mcreconf_size())
            .finish()
    }
}
#[doc = "PKC version register\n\nYou can [`read`](crate::Reg::read) this register and get [`pkc_version::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct PkcVersionSpec;
impl crate::RegisterSpec for PkcVersionSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`pkc_version::R`](R) reader structure"]
impl crate::Readable for PkcVersionSpec {}
#[doc = "`reset()` method sets PKC_VERSION to value 0xbe"]
impl crate::Resettable for PkcVersionSpec {
    const RESET_VALUE: u32 = 0xbe;
}