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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

#[doc = "Register `CCFR` writer"]
pub struct W(crate::W<CCFR_SPEC>);
impl core::ops::Deref for W {
    type Target = crate::W<CCFR_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<CCFR_SPEC>> for W {
    #[inline(always)]
    fn from(writer: crate::W<CCFR_SPEC>) -> Self {
        W(writer)
    }
}
#[doc = "CSOF13"]
pub use CSOF0_AW as CSOF13_AW;
#[doc = "CSOF12"]
pub use CSOF0_AW as CSOF12_AW;
#[doc = "CSOF11"]
pub use CSOF0_AW as CSOF11_AW;
#[doc = "CSOF10"]
pub use CSOF0_AW as CSOF10_AW;
#[doc = "CSOF9"]
pub use CSOF0_AW as CSOF9_AW;
#[doc = "CSOF8"]
pub use CSOF0_AW as CSOF8_AW;
#[doc = "CSOF7"]
pub use CSOF0_AW as CSOF7_AW;
#[doc = "CSOF6"]
pub use CSOF0_AW as CSOF6_AW;
#[doc = "CSOF5"]
pub use CSOF0_AW as CSOF5_AW;
#[doc = "CSOF4"]
pub use CSOF0_AW as CSOF4_AW;
#[doc = "CSOF3"]
pub use CSOF0_AW as CSOF3_AW;
#[doc = "CSOF2"]
pub use CSOF0_AW as CSOF2_AW;
#[doc = "CSOF1"]
pub use CSOF0_AW as CSOF1_AW;
#[doc = "Field `CSOF13` writer - CSOF13"]
pub use CSOF0_W as CSOF13_W;
#[doc = "Field `CSOF12` writer - CSOF12"]
pub use CSOF0_W as CSOF12_W;
#[doc = "Field `CSOF11` writer - CSOF11"]
pub use CSOF0_W as CSOF11_W;
#[doc = "Field `CSOF10` writer - CSOF10"]
pub use CSOF0_W as CSOF10_W;
#[doc = "Field `CSOF9` writer - CSOF9"]
pub use CSOF0_W as CSOF9_W;
#[doc = "Field `CSOF8` writer - CSOF8"]
pub use CSOF0_W as CSOF8_W;
#[doc = "Field `CSOF7` writer - CSOF7"]
pub use CSOF0_W as CSOF7_W;
#[doc = "Field `CSOF6` writer - CSOF6"]
pub use CSOF0_W as CSOF6_W;
#[doc = "Field `CSOF5` writer - CSOF5"]
pub use CSOF0_W as CSOF5_W;
#[doc = "Field `CSOF4` writer - CSOF4"]
pub use CSOF0_W as CSOF4_W;
#[doc = "Field `CSOF3` writer - CSOF3"]
pub use CSOF0_W as CSOF3_W;
#[doc = "Field `CSOF2` writer - CSOF2"]
pub use CSOF0_W as CSOF2_W;
#[doc = "Field `CSOF1` writer - CSOF1"]
pub use CSOF0_W as CSOF1_W;
#[doc = "CSOF0\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CSOF0_AW {
    #[doc = "1: Clear synchronization flag"]
    Clear = 1,
}
impl From<CSOF0_AW> for bool {
    #[inline(always)]
    fn from(variant: CSOF0_AW) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CSOF0` writer - CSOF0"]
pub type CSOF0_W<'a, const O: u8> = crate::BitWriter<'a, u32, CCFR_SPEC, CSOF0_AW, O>;
impl<'a, const O: u8> CSOF0_W<'a, O> {
    #[doc = "Clear synchronization flag"]
    #[inline(always)]
    pub fn clear(self) -> &'a mut W {
        self.variant(CSOF0_AW::Clear)
    }
}
impl W {
    #[doc = "Bit 13 - CSOF13"]
    #[inline(always)]
    pub fn csof13(&mut self) -> CSOF13_W<13> {
        CSOF13_W::new(self)
    }
    #[doc = "Bit 12 - CSOF12"]
    #[inline(always)]
    pub fn csof12(&mut self) -> CSOF12_W<12> {
        CSOF12_W::new(self)
    }
    #[doc = "Bit 11 - CSOF11"]
    #[inline(always)]
    pub fn csof11(&mut self) -> CSOF11_W<11> {
        CSOF11_W::new(self)
    }
    #[doc = "Bit 10 - CSOF10"]
    #[inline(always)]
    pub fn csof10(&mut self) -> CSOF10_W<10> {
        CSOF10_W::new(self)
    }
    #[doc = "Bit 9 - CSOF9"]
    #[inline(always)]
    pub fn csof9(&mut self) -> CSOF9_W<9> {
        CSOF9_W::new(self)
    }
    #[doc = "Bit 8 - CSOF8"]
    #[inline(always)]
    pub fn csof8(&mut self) -> CSOF8_W<8> {
        CSOF8_W::new(self)
    }
    #[doc = "Bit 7 - CSOF7"]
    #[inline(always)]
    pub fn csof7(&mut self) -> CSOF7_W<7> {
        CSOF7_W::new(self)
    }
    #[doc = "Bit 6 - CSOF6"]
    #[inline(always)]
    pub fn csof6(&mut self) -> CSOF6_W<6> {
        CSOF6_W::new(self)
    }
    #[doc = "Bit 5 - CSOF5"]
    #[inline(always)]
    pub fn csof5(&mut self) -> CSOF5_W<5> {
        CSOF5_W::new(self)
    }
    #[doc = "Bit 4 - CSOF4"]
    #[inline(always)]
    pub fn csof4(&mut self) -> CSOF4_W<4> {
        CSOF4_W::new(self)
    }
    #[doc = "Bit 3 - CSOF3"]
    #[inline(always)]
    pub fn csof3(&mut self) -> CSOF3_W<3> {
        CSOF3_W::new(self)
    }
    #[doc = "Bit 2 - CSOF2"]
    #[inline(always)]
    pub fn csof2(&mut self) -> CSOF2_W<2> {
        CSOF2_W::new(self)
    }
    #[doc = "Bit 1 - CSOF1"]
    #[inline(always)]
    pub fn csof1(&mut self) -> CSOF1_W<1> {
        CSOF1_W::new(self)
    }
    #[doc = "Bit 0 - CSOF0"]
    #[inline(always)]
    pub fn csof0(&mut self) -> CSOF0_W<0> {
        CSOF0_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 = "request line multiplexer interrupt channel clear flag register\n\nThis register you can [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [ccfr](index.html) module"]
pub struct CCFR_SPEC;
impl crate::RegisterSpec for CCFR_SPEC {
    type Ux = u32;
}
#[doc = "`write(|w| ..)` method takes [ccfr::W](W) writer structure"]
impl crate::Writable for CCFR_SPEC {
    type Writer = W;
}
#[doc = "`reset()` method sets CCFR to value 0"]
impl crate::Resettable for CCFR_SPEC {
    #[inline(always)]
    fn reset_value() -> Self::Ux {
        0
    }
}