1#[doc = "Register `INT_FORCE1` reader"]
2pub type R = crate::R<INT_FORCE1_SPEC>;
3#[doc = "Register `INT_FORCE1` writer"]
4pub type W = crate::W<INT_FORCE1_SPEC>;
5#[doc = "Field `FORCE_TO_HS_TX` reader - NA"]
6pub type FORCE_TO_HS_TX_R = crate::BitReader;
7#[doc = "Field `FORCE_TO_HS_TX` writer - NA"]
8pub type FORCE_TO_HS_TX_W<'a, REG> = crate::BitWriter<'a, REG>;
9#[doc = "Field `FORCE_TO_LP_RX` reader - NA"]
10pub type FORCE_TO_LP_RX_R = crate::BitReader;
11#[doc = "Field `FORCE_TO_LP_RX` writer - NA"]
12pub type FORCE_TO_LP_RX_W<'a, REG> = crate::BitWriter<'a, REG>;
13#[doc = "Field `FORCE_ECC_SINGLE_ERR` reader - NA"]
14pub type FORCE_ECC_SINGLE_ERR_R = crate::BitReader;
15#[doc = "Field `FORCE_ECC_SINGLE_ERR` writer - NA"]
16pub type FORCE_ECC_SINGLE_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
17#[doc = "Field `FORCE_ECC_MILTI_ERR` reader - NA"]
18pub type FORCE_ECC_MILTI_ERR_R = crate::BitReader;
19#[doc = "Field `FORCE_ECC_MILTI_ERR` writer - NA"]
20pub type FORCE_ECC_MILTI_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
21#[doc = "Field `FORCE_CRC_ERR` reader - NA"]
22pub type FORCE_CRC_ERR_R = crate::BitReader;
23#[doc = "Field `FORCE_CRC_ERR` writer - NA"]
24pub type FORCE_CRC_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
25#[doc = "Field `FORCE_PKT_SIZE_ERR` reader - NA"]
26pub type FORCE_PKT_SIZE_ERR_R = crate::BitReader;
27#[doc = "Field `FORCE_PKT_SIZE_ERR` writer - NA"]
28pub type FORCE_PKT_SIZE_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
29#[doc = "Field `FORCE_EOPT_ERR` reader - NA"]
30pub type FORCE_EOPT_ERR_R = crate::BitReader;
31#[doc = "Field `FORCE_EOPT_ERR` writer - NA"]
32pub type FORCE_EOPT_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
33#[doc = "Field `FORCE_DPI_PLD_WR_ERR` reader - NA"]
34pub type FORCE_DPI_PLD_WR_ERR_R = crate::BitReader;
35#[doc = "Field `FORCE_DPI_PLD_WR_ERR` writer - NA"]
36pub type FORCE_DPI_PLD_WR_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
37#[doc = "Field `FORCE_GEN_CMD_WR_ERR` reader - NA"]
38pub type FORCE_GEN_CMD_WR_ERR_R = crate::BitReader;
39#[doc = "Field `FORCE_GEN_CMD_WR_ERR` writer - NA"]
40pub type FORCE_GEN_CMD_WR_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
41#[doc = "Field `FORCE_GEN_PLD_WR_ERR` reader - NA"]
42pub type FORCE_GEN_PLD_WR_ERR_R = crate::BitReader;
43#[doc = "Field `FORCE_GEN_PLD_WR_ERR` writer - NA"]
44pub type FORCE_GEN_PLD_WR_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
45#[doc = "Field `FORCE_GEN_PLD_SEND_ERR` reader - NA"]
46pub type FORCE_GEN_PLD_SEND_ERR_R = crate::BitReader;
47#[doc = "Field `FORCE_GEN_PLD_SEND_ERR` writer - NA"]
48pub type FORCE_GEN_PLD_SEND_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
49#[doc = "Field `FORCE_GEN_PLD_RD_ERR` reader - NA"]
50pub type FORCE_GEN_PLD_RD_ERR_R = crate::BitReader;
51#[doc = "Field `FORCE_GEN_PLD_RD_ERR` writer - NA"]
52pub type FORCE_GEN_PLD_RD_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
53#[doc = "Field `FORCE_GEN_PLD_RECEV_ERR` reader - NA"]
54pub type FORCE_GEN_PLD_RECEV_ERR_R = crate::BitReader;
55#[doc = "Field `FORCE_GEN_PLD_RECEV_ERR` writer - NA"]
56pub type FORCE_GEN_PLD_RECEV_ERR_W<'a, REG> = crate::BitWriter<'a, REG>;
57#[doc = "Field `FORCE_DPI_BUFF_PLD_UNDER` reader - NA"]
58pub type FORCE_DPI_BUFF_PLD_UNDER_R = crate::BitReader;
59#[doc = "Field `FORCE_DPI_BUFF_PLD_UNDER` writer - NA"]
60pub type FORCE_DPI_BUFF_PLD_UNDER_W<'a, REG> = crate::BitWriter<'a, REG>;
61impl R {
62 #[doc = "Bit 0 - NA"]
63 #[inline(always)]
64 pub fn force_to_hs_tx(&self) -> FORCE_TO_HS_TX_R {
65 FORCE_TO_HS_TX_R::new((self.bits & 1) != 0)
66 }
67 #[doc = "Bit 1 - NA"]
68 #[inline(always)]
69 pub fn force_to_lp_rx(&self) -> FORCE_TO_LP_RX_R {
70 FORCE_TO_LP_RX_R::new(((self.bits >> 1) & 1) != 0)
71 }
72 #[doc = "Bit 2 - NA"]
73 #[inline(always)]
74 pub fn force_ecc_single_err(&self) -> FORCE_ECC_SINGLE_ERR_R {
75 FORCE_ECC_SINGLE_ERR_R::new(((self.bits >> 2) & 1) != 0)
76 }
77 #[doc = "Bit 3 - NA"]
78 #[inline(always)]
79 pub fn force_ecc_milti_err(&self) -> FORCE_ECC_MILTI_ERR_R {
80 FORCE_ECC_MILTI_ERR_R::new(((self.bits >> 3) & 1) != 0)
81 }
82 #[doc = "Bit 4 - NA"]
83 #[inline(always)]
84 pub fn force_crc_err(&self) -> FORCE_CRC_ERR_R {
85 FORCE_CRC_ERR_R::new(((self.bits >> 4) & 1) != 0)
86 }
87 #[doc = "Bit 5 - NA"]
88 #[inline(always)]
89 pub fn force_pkt_size_err(&self) -> FORCE_PKT_SIZE_ERR_R {
90 FORCE_PKT_SIZE_ERR_R::new(((self.bits >> 5) & 1) != 0)
91 }
92 #[doc = "Bit 6 - NA"]
93 #[inline(always)]
94 pub fn force_eopt_err(&self) -> FORCE_EOPT_ERR_R {
95 FORCE_EOPT_ERR_R::new(((self.bits >> 6) & 1) != 0)
96 }
97 #[doc = "Bit 7 - NA"]
98 #[inline(always)]
99 pub fn force_dpi_pld_wr_err(&self) -> FORCE_DPI_PLD_WR_ERR_R {
100 FORCE_DPI_PLD_WR_ERR_R::new(((self.bits >> 7) & 1) != 0)
101 }
102 #[doc = "Bit 8 - NA"]
103 #[inline(always)]
104 pub fn force_gen_cmd_wr_err(&self) -> FORCE_GEN_CMD_WR_ERR_R {
105 FORCE_GEN_CMD_WR_ERR_R::new(((self.bits >> 8) & 1) != 0)
106 }
107 #[doc = "Bit 9 - NA"]
108 #[inline(always)]
109 pub fn force_gen_pld_wr_err(&self) -> FORCE_GEN_PLD_WR_ERR_R {
110 FORCE_GEN_PLD_WR_ERR_R::new(((self.bits >> 9) & 1) != 0)
111 }
112 #[doc = "Bit 10 - NA"]
113 #[inline(always)]
114 pub fn force_gen_pld_send_err(&self) -> FORCE_GEN_PLD_SEND_ERR_R {
115 FORCE_GEN_PLD_SEND_ERR_R::new(((self.bits >> 10) & 1) != 0)
116 }
117 #[doc = "Bit 11 - NA"]
118 #[inline(always)]
119 pub fn force_gen_pld_rd_err(&self) -> FORCE_GEN_PLD_RD_ERR_R {
120 FORCE_GEN_PLD_RD_ERR_R::new(((self.bits >> 11) & 1) != 0)
121 }
122 #[doc = "Bit 12 - NA"]
123 #[inline(always)]
124 pub fn force_gen_pld_recev_err(&self) -> FORCE_GEN_PLD_RECEV_ERR_R {
125 FORCE_GEN_PLD_RECEV_ERR_R::new(((self.bits >> 12) & 1) != 0)
126 }
127 #[doc = "Bit 19 - NA"]
128 #[inline(always)]
129 pub fn force_dpi_buff_pld_under(&self) -> FORCE_DPI_BUFF_PLD_UNDER_R {
130 FORCE_DPI_BUFF_PLD_UNDER_R::new(((self.bits >> 19) & 1) != 0)
131 }
132}
133#[cfg(feature = "impl-register-debug")]
134impl core::fmt::Debug for R {
135 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
136 f.debug_struct("INT_FORCE1")
137 .field(
138 "force_to_hs_tx",
139 &format_args!("{}", self.force_to_hs_tx().bit()),
140 )
141 .field(
142 "force_to_lp_rx",
143 &format_args!("{}", self.force_to_lp_rx().bit()),
144 )
145 .field(
146 "force_ecc_single_err",
147 &format_args!("{}", self.force_ecc_single_err().bit()),
148 )
149 .field(
150 "force_ecc_milti_err",
151 &format_args!("{}", self.force_ecc_milti_err().bit()),
152 )
153 .field(
154 "force_crc_err",
155 &format_args!("{}", self.force_crc_err().bit()),
156 )
157 .field(
158 "force_pkt_size_err",
159 &format_args!("{}", self.force_pkt_size_err().bit()),
160 )
161 .field(
162 "force_eopt_err",
163 &format_args!("{}", self.force_eopt_err().bit()),
164 )
165 .field(
166 "force_dpi_pld_wr_err",
167 &format_args!("{}", self.force_dpi_pld_wr_err().bit()),
168 )
169 .field(
170 "force_gen_cmd_wr_err",
171 &format_args!("{}", self.force_gen_cmd_wr_err().bit()),
172 )
173 .field(
174 "force_gen_pld_wr_err",
175 &format_args!("{}", self.force_gen_pld_wr_err().bit()),
176 )
177 .field(
178 "force_gen_pld_send_err",
179 &format_args!("{}", self.force_gen_pld_send_err().bit()),
180 )
181 .field(
182 "force_gen_pld_rd_err",
183 &format_args!("{}", self.force_gen_pld_rd_err().bit()),
184 )
185 .field(
186 "force_gen_pld_recev_err",
187 &format_args!("{}", self.force_gen_pld_recev_err().bit()),
188 )
189 .field(
190 "force_dpi_buff_pld_under",
191 &format_args!("{}", self.force_dpi_buff_pld_under().bit()),
192 )
193 .finish()
194 }
195}
196#[cfg(feature = "impl-register-debug")]
197impl core::fmt::Debug for crate::generic::Reg<INT_FORCE1_SPEC> {
198 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
199 core::fmt::Debug::fmt(&self.read(), f)
200 }
201}
202impl W {
203 #[doc = "Bit 0 - NA"]
204 #[inline(always)]
205 #[must_use]
206 pub fn force_to_hs_tx(&mut self) -> FORCE_TO_HS_TX_W<INT_FORCE1_SPEC> {
207 FORCE_TO_HS_TX_W::new(self, 0)
208 }
209 #[doc = "Bit 1 - NA"]
210 #[inline(always)]
211 #[must_use]
212 pub fn force_to_lp_rx(&mut self) -> FORCE_TO_LP_RX_W<INT_FORCE1_SPEC> {
213 FORCE_TO_LP_RX_W::new(self, 1)
214 }
215 #[doc = "Bit 2 - NA"]
216 #[inline(always)]
217 #[must_use]
218 pub fn force_ecc_single_err(&mut self) -> FORCE_ECC_SINGLE_ERR_W<INT_FORCE1_SPEC> {
219 FORCE_ECC_SINGLE_ERR_W::new(self, 2)
220 }
221 #[doc = "Bit 3 - NA"]
222 #[inline(always)]
223 #[must_use]
224 pub fn force_ecc_milti_err(&mut self) -> FORCE_ECC_MILTI_ERR_W<INT_FORCE1_SPEC> {
225 FORCE_ECC_MILTI_ERR_W::new(self, 3)
226 }
227 #[doc = "Bit 4 - NA"]
228 #[inline(always)]
229 #[must_use]
230 pub fn force_crc_err(&mut self) -> FORCE_CRC_ERR_W<INT_FORCE1_SPEC> {
231 FORCE_CRC_ERR_W::new(self, 4)
232 }
233 #[doc = "Bit 5 - NA"]
234 #[inline(always)]
235 #[must_use]
236 pub fn force_pkt_size_err(&mut self) -> FORCE_PKT_SIZE_ERR_W<INT_FORCE1_SPEC> {
237 FORCE_PKT_SIZE_ERR_W::new(self, 5)
238 }
239 #[doc = "Bit 6 - NA"]
240 #[inline(always)]
241 #[must_use]
242 pub fn force_eopt_err(&mut self) -> FORCE_EOPT_ERR_W<INT_FORCE1_SPEC> {
243 FORCE_EOPT_ERR_W::new(self, 6)
244 }
245 #[doc = "Bit 7 - NA"]
246 #[inline(always)]
247 #[must_use]
248 pub fn force_dpi_pld_wr_err(&mut self) -> FORCE_DPI_PLD_WR_ERR_W<INT_FORCE1_SPEC> {
249 FORCE_DPI_PLD_WR_ERR_W::new(self, 7)
250 }
251 #[doc = "Bit 8 - NA"]
252 #[inline(always)]
253 #[must_use]
254 pub fn force_gen_cmd_wr_err(&mut self) -> FORCE_GEN_CMD_WR_ERR_W<INT_FORCE1_SPEC> {
255 FORCE_GEN_CMD_WR_ERR_W::new(self, 8)
256 }
257 #[doc = "Bit 9 - NA"]
258 #[inline(always)]
259 #[must_use]
260 pub fn force_gen_pld_wr_err(&mut self) -> FORCE_GEN_PLD_WR_ERR_W<INT_FORCE1_SPEC> {
261 FORCE_GEN_PLD_WR_ERR_W::new(self, 9)
262 }
263 #[doc = "Bit 10 - NA"]
264 #[inline(always)]
265 #[must_use]
266 pub fn force_gen_pld_send_err(&mut self) -> FORCE_GEN_PLD_SEND_ERR_W<INT_FORCE1_SPEC> {
267 FORCE_GEN_PLD_SEND_ERR_W::new(self, 10)
268 }
269 #[doc = "Bit 11 - NA"]
270 #[inline(always)]
271 #[must_use]
272 pub fn force_gen_pld_rd_err(&mut self) -> FORCE_GEN_PLD_RD_ERR_W<INT_FORCE1_SPEC> {
273 FORCE_GEN_PLD_RD_ERR_W::new(self, 11)
274 }
275 #[doc = "Bit 12 - NA"]
276 #[inline(always)]
277 #[must_use]
278 pub fn force_gen_pld_recev_err(&mut self) -> FORCE_GEN_PLD_RECEV_ERR_W<INT_FORCE1_SPEC> {
279 FORCE_GEN_PLD_RECEV_ERR_W::new(self, 12)
280 }
281 #[doc = "Bit 19 - NA"]
282 #[inline(always)]
283 #[must_use]
284 pub fn force_dpi_buff_pld_under(&mut self) -> FORCE_DPI_BUFF_PLD_UNDER_W<INT_FORCE1_SPEC> {
285 FORCE_DPI_BUFF_PLD_UNDER_W::new(self, 19)
286 }
287}
288#[doc = "NA\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`int_force1::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`int_force1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
289pub struct INT_FORCE1_SPEC;
290impl crate::RegisterSpec for INT_FORCE1_SPEC {
291 type Ux = u32;
292}
293#[doc = "`read()` method returns [`int_force1::R`](R) reader structure"]
294impl crate::Readable for INT_FORCE1_SPEC {}
295#[doc = "`write(|w| ..)` method takes [`int_force1::W`](W) writer structure"]
296impl crate::Writable for INT_FORCE1_SPEC {
297 type Safety = crate::Unsafe;
298 const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
299 const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
300}
301#[doc = "`reset()` method sets INT_FORCE1 to value 0"]
302impl crate::Resettable for INT_FORCE1_SPEC {
303 const RESET_VALUE: u32 = 0;
304}