1#![allow(clippy::missing_safety_doc)]
2#![allow(clippy::identity_op)]
3#![allow(clippy::unnecessary_cast)]
4#![allow(clippy::erasing_op)]
5
6#[doc = "External interrupt/event controller"]
7#[derive(Copy, Clone, Eq, PartialEq)]
8pub struct Exti {
9 ptr: *mut u8,
10}
11unsafe impl Send for Exti {}
12unsafe impl Sync for Exti {}
13impl Exti {
14 #[inline(always)]
15 pub const unsafe fn from_ptr(ptr: *mut ()) -> Self {
16 Self { ptr: ptr as _ }
17 }
18 #[inline(always)]
19 pub const fn as_ptr(&self) -> *mut () {
20 self.ptr as _
21 }
22 #[doc = "Rising Trigger selection register"]
23 #[inline(always)]
24 pub const fn rtsr(self, n: usize) -> crate::common::Reg<regs::Lines, crate::common::RW> {
25 assert!(n < 2usize);
26 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0usize + n * 32usize) as _) }
27 }
28 #[doc = "Falling Trigger selection register"]
29 #[inline(always)]
30 pub const fn ftsr(self, n: usize) -> crate::common::Reg<regs::Lines, crate::common::RW> {
31 assert!(n < 2usize);
32 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04usize + n * 32usize) as _) }
33 }
34 #[doc = "Software interrupt event register"]
35 #[inline(always)]
36 pub const fn swier(self, n: usize) -> crate::common::Reg<regs::Lines, crate::common::RW> {
37 assert!(n < 2usize);
38 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x08usize + n * 32usize) as _) }
39 }
40 #[doc = "Rising pending register"]
41 #[inline(always)]
42 pub const fn rpr(self, n: usize) -> crate::common::Reg<regs::Lines, crate::common::RW> {
43 assert!(n < 2usize);
44 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0cusize + n * 32usize) as _) }
45 }
46 #[doc = "Falling pending register"]
47 #[inline(always)]
48 pub const fn fpr(self, n: usize) -> crate::common::Reg<regs::Lines, crate::common::RW> {
49 assert!(n < 2usize);
50 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x10usize + n * 32usize) as _) }
51 }
52 #[doc = "Security configuration register"]
53 #[inline(always)]
54 pub const fn seccfgr(self, n: usize) -> crate::common::Reg<regs::Seccfgr, crate::common::RW> {
55 assert!(n < 2usize);
56 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x14usize + n * 36usize) as _) }
57 }
58 #[doc = "Privilege configuration register"]
59 #[inline(always)]
60 pub const fn privcfgr(self, n: usize) -> crate::common::Reg<regs::Privcfgr, crate::common::RW> {
61 assert!(n < 2usize);
62 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x18usize + n * 28usize) as _) }
63 }
64 #[doc = "Configuration register"]
65 #[inline(always)]
66 pub const fn exticr(self, n: usize) -> crate::common::Reg<regs::Exticr, crate::common::RW> {
67 assert!(n < 4usize);
68 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x60usize + n * 4usize) as _) }
69 }
70 #[doc = "EXTI lock register"]
71 #[inline(always)]
72 pub const fn lockrg(self) -> crate::common::Reg<regs::Lockrg, crate::common::RW> {
73 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x70usize) as _) }
74 }
75 #[doc = "Interrupt mask register"]
76 #[inline(always)]
77 pub const fn imr(self, n: usize) -> crate::common::Reg<regs::Lines, crate::common::RW> {
78 assert!(n < 2usize);
79 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x80usize + n * 16usize) as _) }
80 }
81 #[doc = "Event mask register"]
82 #[inline(always)]
83 pub const fn emr(self, n: usize) -> crate::common::Reg<regs::Lines, crate::common::RW> {
84 assert!(n < 2usize);
85 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x84usize + n * 16usize) as _) }
86 }
87}
88pub mod regs {
89 #[doc = "external interrupt configuration register 1"]
90 #[repr(transparent)]
91 #[derive(Copy, Clone, Eq, PartialEq)]
92 pub struct Exticr(pub u32);
93 impl Exticr {
94 #[doc = "EXTI configuration bits"]
95 #[inline(always)]
96 pub const fn exti(&self, n: usize) -> u8 {
97 assert!(n < 4usize);
98 let offs = 0usize + n * 8usize;
99 let val = (self.0 >> offs) & 0xff;
100 val as u8
101 }
102 #[doc = "EXTI configuration bits"]
103 #[inline(always)]
104 pub fn set_exti(&mut self, n: usize, val: u8) {
105 assert!(n < 4usize);
106 let offs = 0usize + n * 8usize;
107 self.0 = (self.0 & !(0xff << offs)) | (((val as u32) & 0xff) << offs);
108 }
109 }
110 impl Default for Exticr {
111 #[inline(always)]
112 fn default() -> Exticr {
113 Exticr(0)
114 }
115 }
116 impl core::fmt::Debug for Exticr {
117 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
118 f.debug_struct("Exticr")
119 .field(
120 "exti",
121 &[
122 self.exti(0usize),
123 self.exti(1usize),
124 self.exti(2usize),
125 self.exti(3usize),
126 ],
127 )
128 .finish()
129 }
130 }
131 #[cfg(feature = "defmt")]
132 impl defmt::Format for Exticr {
133 fn format(&self, f: defmt::Formatter) {
134 #[derive(defmt :: Format)]
135 struct Exticr {
136 exti: [u8; 4usize],
137 }
138 let proxy = Exticr {
139 exti: [
140 self.exti(0usize),
141 self.exti(1usize),
142 self.exti(2usize),
143 self.exti(3usize),
144 ],
145 };
146 defmt::write!(f, "{}", proxy)
147 }
148 }
149 #[doc = "EXTI lines register, 1 bit per line"]
150 #[repr(transparent)]
151 #[derive(Copy, Clone, Eq, PartialEq)]
152 pub struct Lines(pub u32);
153 impl Lines {
154 #[doc = "EXTI line"]
155 #[inline(always)]
156 pub const fn line(&self, n: usize) -> bool {
157 assert!(n < 32usize);
158 let offs = 0usize + n * 1usize;
159 let val = (self.0 >> offs) & 0x01;
160 val != 0
161 }
162 #[doc = "EXTI line"]
163 #[inline(always)]
164 pub fn set_line(&mut self, n: usize, val: bool) {
165 assert!(n < 32usize);
166 let offs = 0usize + n * 1usize;
167 self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
168 }
169 }
170 impl Default for Lines {
171 #[inline(always)]
172 fn default() -> Lines {
173 Lines(0)
174 }
175 }
176 impl core::fmt::Debug for Lines {
177 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
178 f.debug_struct("Lines")
179 .field(
180 "line",
181 &[
182 self.line(0usize),
183 self.line(1usize),
184 self.line(2usize),
185 self.line(3usize),
186 self.line(4usize),
187 self.line(5usize),
188 self.line(6usize),
189 self.line(7usize),
190 self.line(8usize),
191 self.line(9usize),
192 self.line(10usize),
193 self.line(11usize),
194 self.line(12usize),
195 self.line(13usize),
196 self.line(14usize),
197 self.line(15usize),
198 self.line(16usize),
199 self.line(17usize),
200 self.line(18usize),
201 self.line(19usize),
202 self.line(20usize),
203 self.line(21usize),
204 self.line(22usize),
205 self.line(23usize),
206 self.line(24usize),
207 self.line(25usize),
208 self.line(26usize),
209 self.line(27usize),
210 self.line(28usize),
211 self.line(29usize),
212 self.line(30usize),
213 self.line(31usize),
214 ],
215 )
216 .finish()
217 }
218 }
219 #[cfg(feature = "defmt")]
220 impl defmt::Format for Lines {
221 fn format(&self, f: defmt::Formatter) {
222 #[derive(defmt :: Format)]
223 struct Lines {
224 line: [bool; 32usize],
225 }
226 let proxy = Lines {
227 line: [
228 self.line(0usize),
229 self.line(1usize),
230 self.line(2usize),
231 self.line(3usize),
232 self.line(4usize),
233 self.line(5usize),
234 self.line(6usize),
235 self.line(7usize),
236 self.line(8usize),
237 self.line(9usize),
238 self.line(10usize),
239 self.line(11usize),
240 self.line(12usize),
241 self.line(13usize),
242 self.line(14usize),
243 self.line(15usize),
244 self.line(16usize),
245 self.line(17usize),
246 self.line(18usize),
247 self.line(19usize),
248 self.line(20usize),
249 self.line(21usize),
250 self.line(22usize),
251 self.line(23usize),
252 self.line(24usize),
253 self.line(25usize),
254 self.line(26usize),
255 self.line(27usize),
256 self.line(28usize),
257 self.line(29usize),
258 self.line(30usize),
259 self.line(31usize),
260 ],
261 };
262 defmt::write!(f, "{}", proxy)
263 }
264 }
265 #[doc = "EXTI lock register"]
266 #[repr(transparent)]
267 #[derive(Copy, Clone, Eq, PartialEq)]
268 pub struct Lockrg(pub u32);
269 impl Lockrg {
270 #[doc = "LOCK"]
271 #[inline(always)]
272 pub const fn lock(&self) -> bool {
273 let val = (self.0 >> 0usize) & 0x01;
274 val != 0
275 }
276 #[doc = "LOCK"]
277 #[inline(always)]
278 pub fn set_lock(&mut self, val: bool) {
279 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
280 }
281 }
282 impl Default for Lockrg {
283 #[inline(always)]
284 fn default() -> Lockrg {
285 Lockrg(0)
286 }
287 }
288 impl core::fmt::Debug for Lockrg {
289 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
290 f.debug_struct("Lockrg").field("lock", &self.lock()).finish()
291 }
292 }
293 #[cfg(feature = "defmt")]
294 impl defmt::Format for Lockrg {
295 fn format(&self, f: defmt::Formatter) {
296 #[derive(defmt :: Format)]
297 struct Lockrg {
298 lock: bool,
299 }
300 let proxy = Lockrg { lock: self.lock() };
301 defmt::write!(f, "{}", proxy)
302 }
303 }
304 #[doc = "Privilege configuration register"]
305 #[repr(transparent)]
306 #[derive(Copy, Clone, Eq, PartialEq)]
307 pub struct Privcfgr(pub u32);
308 impl Privcfgr {
309 #[doc = "Security enable on event input x"]
310 #[inline(always)]
311 pub const fn priv_(&self, n: usize) -> bool {
312 assert!(n < 32usize);
313 let offs = 0usize + n * 1usize;
314 let val = (self.0 >> offs) & 0x01;
315 val != 0
316 }
317 #[doc = "Security enable on event input x"]
318 #[inline(always)]
319 pub fn set_priv_(&mut self, n: usize, val: bool) {
320 assert!(n < 32usize);
321 let offs = 0usize + n * 1usize;
322 self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
323 }
324 }
325 impl Default for Privcfgr {
326 #[inline(always)]
327 fn default() -> Privcfgr {
328 Privcfgr(0)
329 }
330 }
331 impl core::fmt::Debug for Privcfgr {
332 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
333 f.debug_struct("Privcfgr")
334 .field(
335 "priv_",
336 &[
337 self.priv_(0usize),
338 self.priv_(1usize),
339 self.priv_(2usize),
340 self.priv_(3usize),
341 self.priv_(4usize),
342 self.priv_(5usize),
343 self.priv_(6usize),
344 self.priv_(7usize),
345 self.priv_(8usize),
346 self.priv_(9usize),
347 self.priv_(10usize),
348 self.priv_(11usize),
349 self.priv_(12usize),
350 self.priv_(13usize),
351 self.priv_(14usize),
352 self.priv_(15usize),
353 self.priv_(16usize),
354 self.priv_(17usize),
355 self.priv_(18usize),
356 self.priv_(19usize),
357 self.priv_(20usize),
358 self.priv_(21usize),
359 self.priv_(22usize),
360 self.priv_(23usize),
361 self.priv_(24usize),
362 self.priv_(25usize),
363 self.priv_(26usize),
364 self.priv_(27usize),
365 self.priv_(28usize),
366 self.priv_(29usize),
367 self.priv_(30usize),
368 self.priv_(31usize),
369 ],
370 )
371 .finish()
372 }
373 }
374 #[cfg(feature = "defmt")]
375 impl defmt::Format for Privcfgr {
376 fn format(&self, f: defmt::Formatter) {
377 #[derive(defmt :: Format)]
378 struct Privcfgr {
379 priv_: [bool; 32usize],
380 }
381 let proxy = Privcfgr {
382 priv_: [
383 self.priv_(0usize),
384 self.priv_(1usize),
385 self.priv_(2usize),
386 self.priv_(3usize),
387 self.priv_(4usize),
388 self.priv_(5usize),
389 self.priv_(6usize),
390 self.priv_(7usize),
391 self.priv_(8usize),
392 self.priv_(9usize),
393 self.priv_(10usize),
394 self.priv_(11usize),
395 self.priv_(12usize),
396 self.priv_(13usize),
397 self.priv_(14usize),
398 self.priv_(15usize),
399 self.priv_(16usize),
400 self.priv_(17usize),
401 self.priv_(18usize),
402 self.priv_(19usize),
403 self.priv_(20usize),
404 self.priv_(21usize),
405 self.priv_(22usize),
406 self.priv_(23usize),
407 self.priv_(24usize),
408 self.priv_(25usize),
409 self.priv_(26usize),
410 self.priv_(27usize),
411 self.priv_(28usize),
412 self.priv_(29usize),
413 self.priv_(30usize),
414 self.priv_(31usize),
415 ],
416 };
417 defmt::write!(f, "{}", proxy)
418 }
419 }
420 #[doc = "Security configuration register"]
421 #[repr(transparent)]
422 #[derive(Copy, Clone, Eq, PartialEq)]
423 pub struct Seccfgr(pub u32);
424 impl Seccfgr {
425 #[doc = "Security enable on event input x"]
426 #[inline(always)]
427 pub const fn sec(&self, n: usize) -> bool {
428 assert!(n < 32usize);
429 let offs = 0usize + n * 1usize;
430 let val = (self.0 >> offs) & 0x01;
431 val != 0
432 }
433 #[doc = "Security enable on event input x"]
434 #[inline(always)]
435 pub fn set_sec(&mut self, n: usize, val: bool) {
436 assert!(n < 32usize);
437 let offs = 0usize + n * 1usize;
438 self.0 = (self.0 & !(0x01 << offs)) | (((val as u32) & 0x01) << offs);
439 }
440 }
441 impl Default for Seccfgr {
442 #[inline(always)]
443 fn default() -> Seccfgr {
444 Seccfgr(0)
445 }
446 }
447 impl core::fmt::Debug for Seccfgr {
448 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
449 f.debug_struct("Seccfgr")
450 .field(
451 "sec",
452 &[
453 self.sec(0usize),
454 self.sec(1usize),
455 self.sec(2usize),
456 self.sec(3usize),
457 self.sec(4usize),
458 self.sec(5usize),
459 self.sec(6usize),
460 self.sec(7usize),
461 self.sec(8usize),
462 self.sec(9usize),
463 self.sec(10usize),
464 self.sec(11usize),
465 self.sec(12usize),
466 self.sec(13usize),
467 self.sec(14usize),
468 self.sec(15usize),
469 self.sec(16usize),
470 self.sec(17usize),
471 self.sec(18usize),
472 self.sec(19usize),
473 self.sec(20usize),
474 self.sec(21usize),
475 self.sec(22usize),
476 self.sec(23usize),
477 self.sec(24usize),
478 self.sec(25usize),
479 self.sec(26usize),
480 self.sec(27usize),
481 self.sec(28usize),
482 self.sec(29usize),
483 self.sec(30usize),
484 self.sec(31usize),
485 ],
486 )
487 .finish()
488 }
489 }
490 #[cfg(feature = "defmt")]
491 impl defmt::Format for Seccfgr {
492 fn format(&self, f: defmt::Formatter) {
493 #[derive(defmt :: Format)]
494 struct Seccfgr {
495 sec: [bool; 32usize],
496 }
497 let proxy = Seccfgr {
498 sec: [
499 self.sec(0usize),
500 self.sec(1usize),
501 self.sec(2usize),
502 self.sec(3usize),
503 self.sec(4usize),
504 self.sec(5usize),
505 self.sec(6usize),
506 self.sec(7usize),
507 self.sec(8usize),
508 self.sec(9usize),
509 self.sec(10usize),
510 self.sec(11usize),
511 self.sec(12usize),
512 self.sec(13usize),
513 self.sec(14usize),
514 self.sec(15usize),
515 self.sec(16usize),
516 self.sec(17usize),
517 self.sec(18usize),
518 self.sec(19usize),
519 self.sec(20usize),
520 self.sec(21usize),
521 self.sec(22usize),
522 self.sec(23usize),
523 self.sec(24usize),
524 self.sec(25usize),
525 self.sec(26usize),
526 self.sec(27usize),
527 self.sec(28usize),
528 self.sec(29usize),
529 self.sec(30usize),
530 self.sec(31usize),
531 ],
532 };
533 defmt::write!(f, "{}", proxy)
534 }
535 }
536}
537