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

#[doc = "Register `CRYP_CSGCMCCM2R` reader"]
pub struct R(crate::R<CRYP_CSGCMCCM2R_SPEC>);
impl core::ops::Deref for R {
    type Target = crate::R<CRYP_CSGCMCCM2R_SPEC>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl From<crate::R<CRYP_CSGCMCCM2R_SPEC>> for R {
    #[inline(always)]
    fn from(reader: crate::R<CRYP_CSGCMCCM2R_SPEC>) -> Self {
        R(reader)
    }
}
#[doc = "Register `CRYP_CSGCMCCM2R` writer"]
pub struct W(crate::W<CRYP_CSGCMCCM2R_SPEC>);
impl core::ops::Deref for W {
    type Target = crate::W<CRYP_CSGCMCCM2R_SPEC>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl core::ops::DerefMut for W {
    #[inline(always)]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
impl From<crate::W<CRYP_CSGCMCCM2R_SPEC>> for W {
    #[inline(always)]
    fn from(writer: crate::W<CRYP_CSGCMCCM2R_SPEC>) -> Self {
        W(writer)
    }
}
#[doc = "Field `CSGCMCCM2` reader - CSGCMCCM2"]
pub type CSGCMCCM2_R = crate::FieldReader<u32, u32>;
#[doc = "Field `CSGCMCCM2` writer - CSGCMCCM2"]
pub type CSGCMCCM2_W<'a, const O: u8> =
    crate::FieldWriter<'a, u32, CRYP_CSGCMCCM2R_SPEC, u32, u32, 32, O>;
impl R {
    #[doc = "Bits 0:31 - CSGCMCCM2"]
    #[inline(always)]
    pub fn csgcmccm2(&self) -> CSGCMCCM2_R {
        CSGCMCCM2_R::new(self.bits)
    }
}
impl W {
    #[doc = "Bits 0:31 - CSGCMCCM2"]
    #[inline(always)]
    pub fn csgcmccm2(&mut self) -> CSGCMCCM2_W<0> {
        CSGCMCCM2_W::new(self)
    }
    #[doc = "Writes raw bits to the register."]
    #[inline(always)]
    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
        self.0.bits(bits);
        self
    }
}
#[doc = "These registers contain the complete internal register states of the CRYP processor when the GCM/GMAC or CCM algorithm is selected. They are useful when a context swap has to be performed because a high-priority task needs the cryptographic processor while it is already in use by another task. When such an event occurs, the CRYP_CSGCMCCM0..7R and CRYP_CSGCM0..7R (in GCM/GMAC mode) or CRYP_CSGCMCCM0..7R (in CCM mode) registers have to be read and the values retrieved have to be saved in the system memory space. The cryptographic processor can then be used by the preemptive task. Then when the cryptographic computation is complete, the saved context can be read from memory and written back into the corresponding context swap registers.\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 [cryp_csgcmccm2r](index.html) module"]
pub struct CRYP_CSGCMCCM2R_SPEC;
impl crate::RegisterSpec for CRYP_CSGCMCCM2R_SPEC {
    type Ux = u32;
}
#[doc = "`read()` method returns [cryp_csgcmccm2r::R](R) reader structure"]
impl crate::Readable for CRYP_CSGCMCCM2R_SPEC {
    type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [cryp_csgcmccm2r::W](W) writer structure"]
impl crate::Writable for CRYP_CSGCMCCM2R_SPEC {
    type Writer = W;
}
#[doc = "`reset()` method sets CRYP_CSGCMCCM2R to value 0"]
impl crate::Resettable for CRYP_CSGCMCCM2R_SPEC {
    #[inline(always)]
    fn reset_value() -> Self::Ux {
        0
    }
}