1# [ doc = "General-purpose I/Os" ]
2# [ repr ( C ) ]
3pub struct Gpio {
4 # [ doc = "0x00 - GPIO port mode register" ]
5 pub moder: Moder,
6 # [ doc = "0x04 - GPIO port output type register" ]
7 pub otyper: Otyper,
8 # [ doc = "0x08 - GPIO port output speed register" ]
9 pub ospeedr: Ospeedr,
10 # [ doc = "0x0c - GPIO port pull-up/pull-down register" ]
11 pub pupdr: Pupdr,
12 # [ doc = "0x10 - GPIO port input data register" ]
13 pub idr: Idr,
14 # [ doc = "0x14 - GPIO port output data register" ]
15 pub odr: Odr,
16 # [ doc = "0x18 - GPIO port bit set/reset register" ]
17 pub bsrr: Bsrr,
18 # [ doc = "0x1c - GPIO port configuration lock register" ]
19 pub lckr: Lckr,
20 # [ doc = "0x20 - GPIO alternate function low register" ]
21 pub afrl: Afrl,
22 # [ doc = "0x24 - GPIO alternate function high register" ]
23 pub afrh: Afrh,
24 # [ doc = "0x28 - Port bit reset register" ]
25 pub brr: Brr,
26}
27
28# [ repr ( C ) ]
29pub struct Moder {
30 register: ::volatile_register::RW<u32>,
31}
32
33impl Moder {
34 pub fn read_bits(&self) -> u32 {
35 self.register.read()
36 }
37 pub unsafe fn modify_bits<F>(&mut self, f: F)
38 where F: FnOnce(&mut u32)
39 {
40 let mut bits = self.register.read();
41 f(&mut bits);
42 self.register.write(bits);
43 }
44 pub unsafe fn write_bits(&mut self, bits: u32) {
45 self.register.write(bits);
46 }
47 pub fn modify<F>(&mut self, f: F)
48 where for<'w> F: FnOnce(&ModerR, &'w mut ModerW) -> &'w mut ModerW
49 {
50 let bits = self.register.read();
51 let r = ModerR { bits: bits };
52 let mut w = ModerW { bits: bits };
53 f(&r, &mut w);
54 self.register.write(w.bits);
55 }
56 pub fn read(&self) -> ModerR {
57 ModerR { bits: self.register.read() }
58 }
59 pub fn write<F>(&mut self, f: F)
60 where F: FnOnce(&mut ModerW) -> &mut ModerW
61 {
62 let mut w = ModerW::reset_value();
63 f(&mut w);
64 self.register.write(w.bits);
65 }
66}
67
68# [ derive ( Clone , Copy ) ]
69# [ repr ( C ) ]
70pub struct ModerR {
71 bits: u32,
72}
73
74impl ModerR {
75 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
76 pub fn moder15(&self) -> u8 {
77 const MASK: u32 = 3;
78 const OFFSET: u8 = 30u8;
79 ((self.bits >> OFFSET) & MASK) as u8
80 }
81 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
82 pub fn moder14(&self) -> u8 {
83 const MASK: u32 = 3;
84 const OFFSET: u8 = 28u8;
85 ((self.bits >> OFFSET) & MASK) as u8
86 }
87 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
88 pub fn moder13(&self) -> u8 {
89 const MASK: u32 = 3;
90 const OFFSET: u8 = 26u8;
91 ((self.bits >> OFFSET) & MASK) as u8
92 }
93 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
94 pub fn moder12(&self) -> u8 {
95 const MASK: u32 = 3;
96 const OFFSET: u8 = 24u8;
97 ((self.bits >> OFFSET) & MASK) as u8
98 }
99 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
100 pub fn moder11(&self) -> u8 {
101 const MASK: u32 = 3;
102 const OFFSET: u8 = 22u8;
103 ((self.bits >> OFFSET) & MASK) as u8
104 }
105 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
106 pub fn moder10(&self) -> u8 {
107 const MASK: u32 = 3;
108 const OFFSET: u8 = 20u8;
109 ((self.bits >> OFFSET) & MASK) as u8
110 }
111 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
112 pub fn moder9(&self) -> u8 {
113 const MASK: u32 = 3;
114 const OFFSET: u8 = 18u8;
115 ((self.bits >> OFFSET) & MASK) as u8
116 }
117 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
118 pub fn moder8(&self) -> u8 {
119 const MASK: u32 = 3;
120 const OFFSET: u8 = 16u8;
121 ((self.bits >> OFFSET) & MASK) as u8
122 }
123 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
124 pub fn moder7(&self) -> u8 {
125 const MASK: u32 = 3;
126 const OFFSET: u8 = 14u8;
127 ((self.bits >> OFFSET) & MASK) as u8
128 }
129 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
130 pub fn moder6(&self) -> u8 {
131 const MASK: u32 = 3;
132 const OFFSET: u8 = 12u8;
133 ((self.bits >> OFFSET) & MASK) as u8
134 }
135 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
136 pub fn moder5(&self) -> u8 {
137 const MASK: u32 = 3;
138 const OFFSET: u8 = 10u8;
139 ((self.bits >> OFFSET) & MASK) as u8
140 }
141 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
142 pub fn moder4(&self) -> u8 {
143 const MASK: u32 = 3;
144 const OFFSET: u8 = 8u8;
145 ((self.bits >> OFFSET) & MASK) as u8
146 }
147 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
148 pub fn moder3(&self) -> u8 {
149 const MASK: u32 = 3;
150 const OFFSET: u8 = 6u8;
151 ((self.bits >> OFFSET) & MASK) as u8
152 }
153 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
154 pub fn moder2(&self) -> u8 {
155 const MASK: u32 = 3;
156 const OFFSET: u8 = 4u8;
157 ((self.bits >> OFFSET) & MASK) as u8
158 }
159 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
160 pub fn moder1(&self) -> u8 {
161 const MASK: u32 = 3;
162 const OFFSET: u8 = 2u8;
163 ((self.bits >> OFFSET) & MASK) as u8
164 }
165 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
166 pub fn moder0(&self) -> u8 {
167 const MASK: u32 = 3;
168 const OFFSET: u8 = 0u8;
169 ((self.bits >> OFFSET) & MASK) as u8
170 }
171}
172
173# [ derive ( Clone , Copy ) ]
174# [ repr ( C ) ]
175pub struct ModerW {
176 bits: u32,
177}
178
179impl ModerW {
180 # [ doc = r" Reset value" ]
181 pub fn reset_value() -> Self {
182 ModerW { bits: 671088640 }
183 }
184 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
185 pub fn moder15(&mut self, value: u8) -> &mut Self {
186 const OFFSET: u8 = 30u8;
187 const MASK: u8 = 3;
188 self.bits &= !((MASK as u32) << OFFSET);
189 self.bits |= ((value & MASK) as u32) << OFFSET;
190 self
191 }
192 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
193 pub fn moder14(&mut self, value: u8) -> &mut Self {
194 const OFFSET: u8 = 28u8;
195 const MASK: u8 = 3;
196 self.bits &= !((MASK as u32) << OFFSET);
197 self.bits |= ((value & MASK) as u32) << OFFSET;
198 self
199 }
200 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
201 pub fn moder13(&mut self, value: u8) -> &mut Self {
202 const OFFSET: u8 = 26u8;
203 const MASK: u8 = 3;
204 self.bits &= !((MASK as u32) << OFFSET);
205 self.bits |= ((value & MASK) as u32) << OFFSET;
206 self
207 }
208 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
209 pub fn moder12(&mut self, value: u8) -> &mut Self {
210 const OFFSET: u8 = 24u8;
211 const MASK: u8 = 3;
212 self.bits &= !((MASK as u32) << OFFSET);
213 self.bits |= ((value & MASK) as u32) << OFFSET;
214 self
215 }
216 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
217 pub fn moder11(&mut self, value: u8) -> &mut Self {
218 const OFFSET: u8 = 22u8;
219 const MASK: u8 = 3;
220 self.bits &= !((MASK as u32) << OFFSET);
221 self.bits |= ((value & MASK) as u32) << OFFSET;
222 self
223 }
224 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
225 pub fn moder10(&mut self, value: u8) -> &mut Self {
226 const OFFSET: u8 = 20u8;
227 const MASK: u8 = 3;
228 self.bits &= !((MASK as u32) << OFFSET);
229 self.bits |= ((value & MASK) as u32) << OFFSET;
230 self
231 }
232 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
233 pub fn moder9(&mut self, value: u8) -> &mut Self {
234 const OFFSET: u8 = 18u8;
235 const MASK: u8 = 3;
236 self.bits &= !((MASK as u32) << OFFSET);
237 self.bits |= ((value & MASK) as u32) << OFFSET;
238 self
239 }
240 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
241 pub fn moder8(&mut self, value: u8) -> &mut Self {
242 const OFFSET: u8 = 16u8;
243 const MASK: u8 = 3;
244 self.bits &= !((MASK as u32) << OFFSET);
245 self.bits |= ((value & MASK) as u32) << OFFSET;
246 self
247 }
248 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
249 pub fn moder7(&mut self, value: u8) -> &mut Self {
250 const OFFSET: u8 = 14u8;
251 const MASK: u8 = 3;
252 self.bits &= !((MASK as u32) << OFFSET);
253 self.bits |= ((value & MASK) as u32) << OFFSET;
254 self
255 }
256 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
257 pub fn moder6(&mut self, value: u8) -> &mut Self {
258 const OFFSET: u8 = 12u8;
259 const MASK: u8 = 3;
260 self.bits &= !((MASK as u32) << OFFSET);
261 self.bits |= ((value & MASK) as u32) << OFFSET;
262 self
263 }
264 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
265 pub fn moder5(&mut self, value: u8) -> &mut Self {
266 const OFFSET: u8 = 10u8;
267 const MASK: u8 = 3;
268 self.bits &= !((MASK as u32) << OFFSET);
269 self.bits |= ((value & MASK) as u32) << OFFSET;
270 self
271 }
272 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
273 pub fn moder4(&mut self, value: u8) -> &mut Self {
274 const OFFSET: u8 = 8u8;
275 const MASK: u8 = 3;
276 self.bits &= !((MASK as u32) << OFFSET);
277 self.bits |= ((value & MASK) as u32) << OFFSET;
278 self
279 }
280 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
281 pub fn moder3(&mut self, value: u8) -> &mut Self {
282 const OFFSET: u8 = 6u8;
283 const MASK: u8 = 3;
284 self.bits &= !((MASK as u32) << OFFSET);
285 self.bits |= ((value & MASK) as u32) << OFFSET;
286 self
287 }
288 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
289 pub fn moder2(&mut self, value: u8) -> &mut Self {
290 const OFFSET: u8 = 4u8;
291 const MASK: u8 = 3;
292 self.bits &= !((MASK as u32) << OFFSET);
293 self.bits |= ((value & MASK) as u32) << OFFSET;
294 self
295 }
296 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
297 pub fn moder1(&mut self, value: u8) -> &mut Self {
298 const OFFSET: u8 = 2u8;
299 const MASK: u8 = 3;
300 self.bits &= !((MASK as u32) << OFFSET);
301 self.bits |= ((value & MASK) as u32) << OFFSET;
302 self
303 }
304 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
305 pub fn moder0(&mut self, value: u8) -> &mut Self {
306 const OFFSET: u8 = 0u8;
307 const MASK: u8 = 3;
308 self.bits &= !((MASK as u32) << OFFSET);
309 self.bits |= ((value & MASK) as u32) << OFFSET;
310 self
311 }
312}
313
314# [ repr ( C ) ]
315pub struct Otyper {
316 register: ::volatile_register::RW<u32>,
317}
318
319impl Otyper {
320 pub fn read_bits(&self) -> u32 {
321 self.register.read()
322 }
323 pub unsafe fn modify_bits<F>(&mut self, f: F)
324 where F: FnOnce(&mut u32)
325 {
326 let mut bits = self.register.read();
327 f(&mut bits);
328 self.register.write(bits);
329 }
330 pub unsafe fn write_bits(&mut self, bits: u32) {
331 self.register.write(bits);
332 }
333 pub fn modify<F>(&mut self, f: F)
334 where for<'w> F: FnOnce(&OtyperR, &'w mut OtyperW) -> &'w mut OtyperW
335 {
336 let bits = self.register.read();
337 let r = OtyperR { bits: bits };
338 let mut w = OtyperW { bits: bits };
339 f(&r, &mut w);
340 self.register.write(w.bits);
341 }
342 pub fn read(&self) -> OtyperR {
343 OtyperR { bits: self.register.read() }
344 }
345 pub fn write<F>(&mut self, f: F)
346 where F: FnOnce(&mut OtyperW) -> &mut OtyperW
347 {
348 let mut w = OtyperW::reset_value();
349 f(&mut w);
350 self.register.write(w.bits);
351 }
352}
353
354# [ derive ( Clone , Copy ) ]
355# [ repr ( C ) ]
356pub struct OtyperR {
357 bits: u32,
358}
359
360impl OtyperR {
361 # [ doc = "Bit 15 - Port x configuration bits (y = 0..15)" ]
362 pub fn ot15(&self) -> bool {
363 const OFFSET: u8 = 15u8;
364 self.bits & (1 << OFFSET) != 0
365 }
366 # [ doc = "Bit 14 - Port x configuration bits (y = 0..15)" ]
367 pub fn ot14(&self) -> bool {
368 const OFFSET: u8 = 14u8;
369 self.bits & (1 << OFFSET) != 0
370 }
371 # [ doc = "Bit 13 - Port x configuration bits (y = 0..15)" ]
372 pub fn ot13(&self) -> bool {
373 const OFFSET: u8 = 13u8;
374 self.bits & (1 << OFFSET) != 0
375 }
376 # [ doc = "Bit 12 - Port x configuration bits (y = 0..15)" ]
377 pub fn ot12(&self) -> bool {
378 const OFFSET: u8 = 12u8;
379 self.bits & (1 << OFFSET) != 0
380 }
381 # [ doc = "Bit 11 - Port x configuration bits (y = 0..15)" ]
382 pub fn ot11(&self) -> bool {
383 const OFFSET: u8 = 11u8;
384 self.bits & (1 << OFFSET) != 0
385 }
386 # [ doc = "Bit 10 - Port x configuration bits (y = 0..15)" ]
387 pub fn ot10(&self) -> bool {
388 const OFFSET: u8 = 10u8;
389 self.bits & (1 << OFFSET) != 0
390 }
391 # [ doc = "Bit 9 - Port x configuration bits (y = 0..15)" ]
392 pub fn ot9(&self) -> bool {
393 const OFFSET: u8 = 9u8;
394 self.bits & (1 << OFFSET) != 0
395 }
396 # [ doc = "Bit 8 - Port x configuration bits (y = 0..15)" ]
397 pub fn ot8(&self) -> bool {
398 const OFFSET: u8 = 8u8;
399 self.bits & (1 << OFFSET) != 0
400 }
401 # [ doc = "Bit 7 - Port x configuration bits (y = 0..15)" ]
402 pub fn ot7(&self) -> bool {
403 const OFFSET: u8 = 7u8;
404 self.bits & (1 << OFFSET) != 0
405 }
406 # [ doc = "Bit 6 - Port x configuration bits (y = 0..15)" ]
407 pub fn ot6(&self) -> bool {
408 const OFFSET: u8 = 6u8;
409 self.bits & (1 << OFFSET) != 0
410 }
411 # [ doc = "Bit 5 - Port x configuration bits (y = 0..15)" ]
412 pub fn ot5(&self) -> bool {
413 const OFFSET: u8 = 5u8;
414 self.bits & (1 << OFFSET) != 0
415 }
416 # [ doc = "Bit 4 - Port x configuration bits (y = 0..15)" ]
417 pub fn ot4(&self) -> bool {
418 const OFFSET: u8 = 4u8;
419 self.bits & (1 << OFFSET) != 0
420 }
421 # [ doc = "Bit 3 - Port x configuration bits (y = 0..15)" ]
422 pub fn ot3(&self) -> bool {
423 const OFFSET: u8 = 3u8;
424 self.bits & (1 << OFFSET) != 0
425 }
426 # [ doc = "Bit 2 - Port x configuration bits (y = 0..15)" ]
427 pub fn ot2(&self) -> bool {
428 const OFFSET: u8 = 2u8;
429 self.bits & (1 << OFFSET) != 0
430 }
431 # [ doc = "Bit 1 - Port x configuration bits (y = 0..15)" ]
432 pub fn ot1(&self) -> bool {
433 const OFFSET: u8 = 1u8;
434 self.bits & (1 << OFFSET) != 0
435 }
436 # [ doc = "Bit 0 - Port x configuration bits (y = 0..15)" ]
437 pub fn ot0(&self) -> bool {
438 const OFFSET: u8 = 0u8;
439 self.bits & (1 << OFFSET) != 0
440 }
441}
442
443# [ derive ( Clone , Copy ) ]
444# [ repr ( C ) ]
445pub struct OtyperW {
446 bits: u32,
447}
448
449impl OtyperW {
450 # [ doc = r" Reset value" ]
451 pub fn reset_value() -> Self {
452 OtyperW { bits: 0 }
453 }
454 # [ doc = "Bit 15 - Port x configuration bits (y = 0..15)" ]
455 pub fn ot15(&mut self, value: bool) -> &mut Self {
456 const OFFSET: u8 = 15u8;
457 if value {
458 self.bits |= 1 << OFFSET;
459 } else {
460 self.bits &= !(1 << OFFSET);
461 }
462 self
463 }
464 # [ doc = "Bit 14 - Port x configuration bits (y = 0..15)" ]
465 pub fn ot14(&mut self, value: bool) -> &mut Self {
466 const OFFSET: u8 = 14u8;
467 if value {
468 self.bits |= 1 << OFFSET;
469 } else {
470 self.bits &= !(1 << OFFSET);
471 }
472 self
473 }
474 # [ doc = "Bit 13 - Port x configuration bits (y = 0..15)" ]
475 pub fn ot13(&mut self, value: bool) -> &mut Self {
476 const OFFSET: u8 = 13u8;
477 if value {
478 self.bits |= 1 << OFFSET;
479 } else {
480 self.bits &= !(1 << OFFSET);
481 }
482 self
483 }
484 # [ doc = "Bit 12 - Port x configuration bits (y = 0..15)" ]
485 pub fn ot12(&mut self, value: bool) -> &mut Self {
486 const OFFSET: u8 = 12u8;
487 if value {
488 self.bits |= 1 << OFFSET;
489 } else {
490 self.bits &= !(1 << OFFSET);
491 }
492 self
493 }
494 # [ doc = "Bit 11 - Port x configuration bits (y = 0..15)" ]
495 pub fn ot11(&mut self, value: bool) -> &mut Self {
496 const OFFSET: u8 = 11u8;
497 if value {
498 self.bits |= 1 << OFFSET;
499 } else {
500 self.bits &= !(1 << OFFSET);
501 }
502 self
503 }
504 # [ doc = "Bit 10 - Port x configuration bits (y = 0..15)" ]
505 pub fn ot10(&mut self, value: bool) -> &mut Self {
506 const OFFSET: u8 = 10u8;
507 if value {
508 self.bits |= 1 << OFFSET;
509 } else {
510 self.bits &= !(1 << OFFSET);
511 }
512 self
513 }
514 # [ doc = "Bit 9 - Port x configuration bits (y = 0..15)" ]
515 pub fn ot9(&mut self, value: bool) -> &mut Self {
516 const OFFSET: u8 = 9u8;
517 if value {
518 self.bits |= 1 << OFFSET;
519 } else {
520 self.bits &= !(1 << OFFSET);
521 }
522 self
523 }
524 # [ doc = "Bit 8 - Port x configuration bits (y = 0..15)" ]
525 pub fn ot8(&mut self, value: bool) -> &mut Self {
526 const OFFSET: u8 = 8u8;
527 if value {
528 self.bits |= 1 << OFFSET;
529 } else {
530 self.bits &= !(1 << OFFSET);
531 }
532 self
533 }
534 # [ doc = "Bit 7 - Port x configuration bits (y = 0..15)" ]
535 pub fn ot7(&mut self, value: bool) -> &mut Self {
536 const OFFSET: u8 = 7u8;
537 if value {
538 self.bits |= 1 << OFFSET;
539 } else {
540 self.bits &= !(1 << OFFSET);
541 }
542 self
543 }
544 # [ doc = "Bit 6 - Port x configuration bits (y = 0..15)" ]
545 pub fn ot6(&mut self, value: bool) -> &mut Self {
546 const OFFSET: u8 = 6u8;
547 if value {
548 self.bits |= 1 << OFFSET;
549 } else {
550 self.bits &= !(1 << OFFSET);
551 }
552 self
553 }
554 # [ doc = "Bit 5 - Port x configuration bits (y = 0..15)" ]
555 pub fn ot5(&mut self, value: bool) -> &mut Self {
556 const OFFSET: u8 = 5u8;
557 if value {
558 self.bits |= 1 << OFFSET;
559 } else {
560 self.bits &= !(1 << OFFSET);
561 }
562 self
563 }
564 # [ doc = "Bit 4 - Port x configuration bits (y = 0..15)" ]
565 pub fn ot4(&mut self, value: bool) -> &mut Self {
566 const OFFSET: u8 = 4u8;
567 if value {
568 self.bits |= 1 << OFFSET;
569 } else {
570 self.bits &= !(1 << OFFSET);
571 }
572 self
573 }
574 # [ doc = "Bit 3 - Port x configuration bits (y = 0..15)" ]
575 pub fn ot3(&mut self, value: bool) -> &mut Self {
576 const OFFSET: u8 = 3u8;
577 if value {
578 self.bits |= 1 << OFFSET;
579 } else {
580 self.bits &= !(1 << OFFSET);
581 }
582 self
583 }
584 # [ doc = "Bit 2 - Port x configuration bits (y = 0..15)" ]
585 pub fn ot2(&mut self, value: bool) -> &mut Self {
586 const OFFSET: u8 = 2u8;
587 if value {
588 self.bits |= 1 << OFFSET;
589 } else {
590 self.bits &= !(1 << OFFSET);
591 }
592 self
593 }
594 # [ doc = "Bit 1 - Port x configuration bits (y = 0..15)" ]
595 pub fn ot1(&mut self, value: bool) -> &mut Self {
596 const OFFSET: u8 = 1u8;
597 if value {
598 self.bits |= 1 << OFFSET;
599 } else {
600 self.bits &= !(1 << OFFSET);
601 }
602 self
603 }
604 # [ doc = "Bit 0 - Port x configuration bits (y = 0..15)" ]
605 pub fn ot0(&mut self, value: bool) -> &mut Self {
606 const OFFSET: u8 = 0u8;
607 if value {
608 self.bits |= 1 << OFFSET;
609 } else {
610 self.bits &= !(1 << OFFSET);
611 }
612 self
613 }
614}
615
616# [ repr ( C ) ]
617pub struct Ospeedr {
618 register: ::volatile_register::RW<u32>,
619}
620
621impl Ospeedr {
622 pub fn read_bits(&self) -> u32 {
623 self.register.read()
624 }
625 pub unsafe fn modify_bits<F>(&mut self, f: F)
626 where F: FnOnce(&mut u32)
627 {
628 let mut bits = self.register.read();
629 f(&mut bits);
630 self.register.write(bits);
631 }
632 pub unsafe fn write_bits(&mut self, bits: u32) {
633 self.register.write(bits);
634 }
635 pub fn modify<F>(&mut self, f: F)
636 where for<'w> F: FnOnce(&OspeedrR, &'w mut OspeedrW) -> &'w mut OspeedrW
637 {
638 let bits = self.register.read();
639 let r = OspeedrR { bits: bits };
640 let mut w = OspeedrW { bits: bits };
641 f(&r, &mut w);
642 self.register.write(w.bits);
643 }
644 pub fn read(&self) -> OspeedrR {
645 OspeedrR { bits: self.register.read() }
646 }
647 pub fn write<F>(&mut self, f: F)
648 where F: FnOnce(&mut OspeedrW) -> &mut OspeedrW
649 {
650 let mut w = OspeedrW::reset_value();
651 f(&mut w);
652 self.register.write(w.bits);
653 }
654}
655
656# [ derive ( Clone , Copy ) ]
657# [ repr ( C ) ]
658pub struct OspeedrR {
659 bits: u32,
660}
661
662impl OspeedrR {
663 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
664 pub fn ospeedr15(&self) -> u8 {
665 const MASK: u32 = 3;
666 const OFFSET: u8 = 30u8;
667 ((self.bits >> OFFSET) & MASK) as u8
668 }
669 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
670 pub fn ospeedr14(&self) -> u8 {
671 const MASK: u32 = 3;
672 const OFFSET: u8 = 28u8;
673 ((self.bits >> OFFSET) & MASK) as u8
674 }
675 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
676 pub fn ospeedr13(&self) -> u8 {
677 const MASK: u32 = 3;
678 const OFFSET: u8 = 26u8;
679 ((self.bits >> OFFSET) & MASK) as u8
680 }
681 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
682 pub fn ospeedr12(&self) -> u8 {
683 const MASK: u32 = 3;
684 const OFFSET: u8 = 24u8;
685 ((self.bits >> OFFSET) & MASK) as u8
686 }
687 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
688 pub fn ospeedr11(&self) -> u8 {
689 const MASK: u32 = 3;
690 const OFFSET: u8 = 22u8;
691 ((self.bits >> OFFSET) & MASK) as u8
692 }
693 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
694 pub fn ospeedr10(&self) -> u8 {
695 const MASK: u32 = 3;
696 const OFFSET: u8 = 20u8;
697 ((self.bits >> OFFSET) & MASK) as u8
698 }
699 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
700 pub fn ospeedr9(&self) -> u8 {
701 const MASK: u32 = 3;
702 const OFFSET: u8 = 18u8;
703 ((self.bits >> OFFSET) & MASK) as u8
704 }
705 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
706 pub fn ospeedr8(&self) -> u8 {
707 const MASK: u32 = 3;
708 const OFFSET: u8 = 16u8;
709 ((self.bits >> OFFSET) & MASK) as u8
710 }
711 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
712 pub fn ospeedr7(&self) -> u8 {
713 const MASK: u32 = 3;
714 const OFFSET: u8 = 14u8;
715 ((self.bits >> OFFSET) & MASK) as u8
716 }
717 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
718 pub fn ospeedr6(&self) -> u8 {
719 const MASK: u32 = 3;
720 const OFFSET: u8 = 12u8;
721 ((self.bits >> OFFSET) & MASK) as u8
722 }
723 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
724 pub fn ospeedr5(&self) -> u8 {
725 const MASK: u32 = 3;
726 const OFFSET: u8 = 10u8;
727 ((self.bits >> OFFSET) & MASK) as u8
728 }
729 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
730 pub fn ospeedr4(&self) -> u8 {
731 const MASK: u32 = 3;
732 const OFFSET: u8 = 8u8;
733 ((self.bits >> OFFSET) & MASK) as u8
734 }
735 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
736 pub fn ospeedr3(&self) -> u8 {
737 const MASK: u32 = 3;
738 const OFFSET: u8 = 6u8;
739 ((self.bits >> OFFSET) & MASK) as u8
740 }
741 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
742 pub fn ospeedr2(&self) -> u8 {
743 const MASK: u32 = 3;
744 const OFFSET: u8 = 4u8;
745 ((self.bits >> OFFSET) & MASK) as u8
746 }
747 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
748 pub fn ospeedr1(&self) -> u8 {
749 const MASK: u32 = 3;
750 const OFFSET: u8 = 2u8;
751 ((self.bits >> OFFSET) & MASK) as u8
752 }
753 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
754 pub fn ospeedr0(&self) -> u8 {
755 const MASK: u32 = 3;
756 const OFFSET: u8 = 0u8;
757 ((self.bits >> OFFSET) & MASK) as u8
758 }
759}
760
761# [ derive ( Clone , Copy ) ]
762# [ repr ( C ) ]
763pub struct OspeedrW {
764 bits: u32,
765}
766
767impl OspeedrW {
768 # [ doc = r" Reset value" ]
769 pub fn reset_value() -> Self {
770 OspeedrW { bits: 0 }
771 }
772 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
773 pub fn ospeedr15(&mut self, value: u8) -> &mut Self {
774 const OFFSET: u8 = 30u8;
775 const MASK: u8 = 3;
776 self.bits &= !((MASK as u32) << OFFSET);
777 self.bits |= ((value & MASK) as u32) << OFFSET;
778 self
779 }
780 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
781 pub fn ospeedr14(&mut self, value: u8) -> &mut Self {
782 const OFFSET: u8 = 28u8;
783 const MASK: u8 = 3;
784 self.bits &= !((MASK as u32) << OFFSET);
785 self.bits |= ((value & MASK) as u32) << OFFSET;
786 self
787 }
788 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
789 pub fn ospeedr13(&mut self, value: u8) -> &mut Self {
790 const OFFSET: u8 = 26u8;
791 const MASK: u8 = 3;
792 self.bits &= !((MASK as u32) << OFFSET);
793 self.bits |= ((value & MASK) as u32) << OFFSET;
794 self
795 }
796 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
797 pub fn ospeedr12(&mut self, value: u8) -> &mut Self {
798 const OFFSET: u8 = 24u8;
799 const MASK: u8 = 3;
800 self.bits &= !((MASK as u32) << OFFSET);
801 self.bits |= ((value & MASK) as u32) << OFFSET;
802 self
803 }
804 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
805 pub fn ospeedr11(&mut self, value: u8) -> &mut Self {
806 const OFFSET: u8 = 22u8;
807 const MASK: u8 = 3;
808 self.bits &= !((MASK as u32) << OFFSET);
809 self.bits |= ((value & MASK) as u32) << OFFSET;
810 self
811 }
812 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
813 pub fn ospeedr10(&mut self, value: u8) -> &mut Self {
814 const OFFSET: u8 = 20u8;
815 const MASK: u8 = 3;
816 self.bits &= !((MASK as u32) << OFFSET);
817 self.bits |= ((value & MASK) as u32) << OFFSET;
818 self
819 }
820 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
821 pub fn ospeedr9(&mut self, value: u8) -> &mut Self {
822 const OFFSET: u8 = 18u8;
823 const MASK: u8 = 3;
824 self.bits &= !((MASK as u32) << OFFSET);
825 self.bits |= ((value & MASK) as u32) << OFFSET;
826 self
827 }
828 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
829 pub fn ospeedr8(&mut self, value: u8) -> &mut Self {
830 const OFFSET: u8 = 16u8;
831 const MASK: u8 = 3;
832 self.bits &= !((MASK as u32) << OFFSET);
833 self.bits |= ((value & MASK) as u32) << OFFSET;
834 self
835 }
836 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
837 pub fn ospeedr7(&mut self, value: u8) -> &mut Self {
838 const OFFSET: u8 = 14u8;
839 const MASK: u8 = 3;
840 self.bits &= !((MASK as u32) << OFFSET);
841 self.bits |= ((value & MASK) as u32) << OFFSET;
842 self
843 }
844 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
845 pub fn ospeedr6(&mut self, value: u8) -> &mut Self {
846 const OFFSET: u8 = 12u8;
847 const MASK: u8 = 3;
848 self.bits &= !((MASK as u32) << OFFSET);
849 self.bits |= ((value & MASK) as u32) << OFFSET;
850 self
851 }
852 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
853 pub fn ospeedr5(&mut self, value: u8) -> &mut Self {
854 const OFFSET: u8 = 10u8;
855 const MASK: u8 = 3;
856 self.bits &= !((MASK as u32) << OFFSET);
857 self.bits |= ((value & MASK) as u32) << OFFSET;
858 self
859 }
860 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
861 pub fn ospeedr4(&mut self, value: u8) -> &mut Self {
862 const OFFSET: u8 = 8u8;
863 const MASK: u8 = 3;
864 self.bits &= !((MASK as u32) << OFFSET);
865 self.bits |= ((value & MASK) as u32) << OFFSET;
866 self
867 }
868 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
869 pub fn ospeedr3(&mut self, value: u8) -> &mut Self {
870 const OFFSET: u8 = 6u8;
871 const MASK: u8 = 3;
872 self.bits &= !((MASK as u32) << OFFSET);
873 self.bits |= ((value & MASK) as u32) << OFFSET;
874 self
875 }
876 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
877 pub fn ospeedr2(&mut self, value: u8) -> &mut Self {
878 const OFFSET: u8 = 4u8;
879 const MASK: u8 = 3;
880 self.bits &= !((MASK as u32) << OFFSET);
881 self.bits |= ((value & MASK) as u32) << OFFSET;
882 self
883 }
884 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
885 pub fn ospeedr1(&mut self, value: u8) -> &mut Self {
886 const OFFSET: u8 = 2u8;
887 const MASK: u8 = 3;
888 self.bits &= !((MASK as u32) << OFFSET);
889 self.bits |= ((value & MASK) as u32) << OFFSET;
890 self
891 }
892 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
893 pub fn ospeedr0(&mut self, value: u8) -> &mut Self {
894 const OFFSET: u8 = 0u8;
895 const MASK: u8 = 3;
896 self.bits &= !((MASK as u32) << OFFSET);
897 self.bits |= ((value & MASK) as u32) << OFFSET;
898 self
899 }
900}
901
902# [ repr ( C ) ]
903pub struct Pupdr {
904 register: ::volatile_register::RW<u32>,
905}
906
907impl Pupdr {
908 pub fn read_bits(&self) -> u32 {
909 self.register.read()
910 }
911 pub unsafe fn modify_bits<F>(&mut self, f: F)
912 where F: FnOnce(&mut u32)
913 {
914 let mut bits = self.register.read();
915 f(&mut bits);
916 self.register.write(bits);
917 }
918 pub unsafe fn write_bits(&mut self, bits: u32) {
919 self.register.write(bits);
920 }
921 pub fn modify<F>(&mut self, f: F)
922 where for<'w> F: FnOnce(&PupdrR, &'w mut PupdrW) -> &'w mut PupdrW
923 {
924 let bits = self.register.read();
925 let r = PupdrR { bits: bits };
926 let mut w = PupdrW { bits: bits };
927 f(&r, &mut w);
928 self.register.write(w.bits);
929 }
930 pub fn read(&self) -> PupdrR {
931 PupdrR { bits: self.register.read() }
932 }
933 pub fn write<F>(&mut self, f: F)
934 where F: FnOnce(&mut PupdrW) -> &mut PupdrW
935 {
936 let mut w = PupdrW::reset_value();
937 f(&mut w);
938 self.register.write(w.bits);
939 }
940}
941
942# [ derive ( Clone , Copy ) ]
943# [ repr ( C ) ]
944pub struct PupdrR {
945 bits: u32,
946}
947
948impl PupdrR {
949 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
950 pub fn pupdr15(&self) -> u8 {
951 const MASK: u32 = 3;
952 const OFFSET: u8 = 30u8;
953 ((self.bits >> OFFSET) & MASK) as u8
954 }
955 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
956 pub fn pupdr14(&self) -> u8 {
957 const MASK: u32 = 3;
958 const OFFSET: u8 = 28u8;
959 ((self.bits >> OFFSET) & MASK) as u8
960 }
961 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
962 pub fn pupdr13(&self) -> u8 {
963 const MASK: u32 = 3;
964 const OFFSET: u8 = 26u8;
965 ((self.bits >> OFFSET) & MASK) as u8
966 }
967 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
968 pub fn pupdr12(&self) -> u8 {
969 const MASK: u32 = 3;
970 const OFFSET: u8 = 24u8;
971 ((self.bits >> OFFSET) & MASK) as u8
972 }
973 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
974 pub fn pupdr11(&self) -> u8 {
975 const MASK: u32 = 3;
976 const OFFSET: u8 = 22u8;
977 ((self.bits >> OFFSET) & MASK) as u8
978 }
979 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
980 pub fn pupdr10(&self) -> u8 {
981 const MASK: u32 = 3;
982 const OFFSET: u8 = 20u8;
983 ((self.bits >> OFFSET) & MASK) as u8
984 }
985 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
986 pub fn pupdr9(&self) -> u8 {
987 const MASK: u32 = 3;
988 const OFFSET: u8 = 18u8;
989 ((self.bits >> OFFSET) & MASK) as u8
990 }
991 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
992 pub fn pupdr8(&self) -> u8 {
993 const MASK: u32 = 3;
994 const OFFSET: u8 = 16u8;
995 ((self.bits >> OFFSET) & MASK) as u8
996 }
997 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
998 pub fn pupdr7(&self) -> u8 {
999 const MASK: u32 = 3;
1000 const OFFSET: u8 = 14u8;
1001 ((self.bits >> OFFSET) & MASK) as u8
1002 }
1003 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
1004 pub fn pupdr6(&self) -> u8 {
1005 const MASK: u32 = 3;
1006 const OFFSET: u8 = 12u8;
1007 ((self.bits >> OFFSET) & MASK) as u8
1008 }
1009 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
1010 pub fn pupdr5(&self) -> u8 {
1011 const MASK: u32 = 3;
1012 const OFFSET: u8 = 10u8;
1013 ((self.bits >> OFFSET) & MASK) as u8
1014 }
1015 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
1016 pub fn pupdr4(&self) -> u8 {
1017 const MASK: u32 = 3;
1018 const OFFSET: u8 = 8u8;
1019 ((self.bits >> OFFSET) & MASK) as u8
1020 }
1021 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
1022 pub fn pupdr3(&self) -> u8 {
1023 const MASK: u32 = 3;
1024 const OFFSET: u8 = 6u8;
1025 ((self.bits >> OFFSET) & MASK) as u8
1026 }
1027 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
1028 pub fn pupdr2(&self) -> u8 {
1029 const MASK: u32 = 3;
1030 const OFFSET: u8 = 4u8;
1031 ((self.bits >> OFFSET) & MASK) as u8
1032 }
1033 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
1034 pub fn pupdr1(&self) -> u8 {
1035 const MASK: u32 = 3;
1036 const OFFSET: u8 = 2u8;
1037 ((self.bits >> OFFSET) & MASK) as u8
1038 }
1039 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
1040 pub fn pupdr0(&self) -> u8 {
1041 const MASK: u32 = 3;
1042 const OFFSET: u8 = 0u8;
1043 ((self.bits >> OFFSET) & MASK) as u8
1044 }
1045}
1046
1047# [ derive ( Clone , Copy ) ]
1048# [ repr ( C ) ]
1049pub struct PupdrW {
1050 bits: u32,
1051}
1052
1053impl PupdrW {
1054 # [ doc = r" Reset value" ]
1055 pub fn reset_value() -> Self {
1056 PupdrW { bits: 603979776 }
1057 }
1058 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
1059 pub fn pupdr15(&mut self, value: u8) -> &mut Self {
1060 const OFFSET: u8 = 30u8;
1061 const MASK: u8 = 3;
1062 self.bits &= !((MASK as u32) << OFFSET);
1063 self.bits |= ((value & MASK) as u32) << OFFSET;
1064 self
1065 }
1066 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
1067 pub fn pupdr14(&mut self, value: u8) -> &mut Self {
1068 const OFFSET: u8 = 28u8;
1069 const MASK: u8 = 3;
1070 self.bits &= !((MASK as u32) << OFFSET);
1071 self.bits |= ((value & MASK) as u32) << OFFSET;
1072 self
1073 }
1074 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
1075 pub fn pupdr13(&mut self, value: u8) -> &mut Self {
1076 const OFFSET: u8 = 26u8;
1077 const MASK: u8 = 3;
1078 self.bits &= !((MASK as u32) << OFFSET);
1079 self.bits |= ((value & MASK) as u32) << OFFSET;
1080 self
1081 }
1082 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
1083 pub fn pupdr12(&mut self, value: u8) -> &mut Self {
1084 const OFFSET: u8 = 24u8;
1085 const MASK: u8 = 3;
1086 self.bits &= !((MASK as u32) << OFFSET);
1087 self.bits |= ((value & MASK) as u32) << OFFSET;
1088 self
1089 }
1090 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
1091 pub fn pupdr11(&mut self, value: u8) -> &mut Self {
1092 const OFFSET: u8 = 22u8;
1093 const MASK: u8 = 3;
1094 self.bits &= !((MASK as u32) << OFFSET);
1095 self.bits |= ((value & MASK) as u32) << OFFSET;
1096 self
1097 }
1098 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
1099 pub fn pupdr10(&mut self, value: u8) -> &mut Self {
1100 const OFFSET: u8 = 20u8;
1101 const MASK: u8 = 3;
1102 self.bits &= !((MASK as u32) << OFFSET);
1103 self.bits |= ((value & MASK) as u32) << OFFSET;
1104 self
1105 }
1106 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
1107 pub fn pupdr9(&mut self, value: u8) -> &mut Self {
1108 const OFFSET: u8 = 18u8;
1109 const MASK: u8 = 3;
1110 self.bits &= !((MASK as u32) << OFFSET);
1111 self.bits |= ((value & MASK) as u32) << OFFSET;
1112 self
1113 }
1114 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
1115 pub fn pupdr8(&mut self, value: u8) -> &mut Self {
1116 const OFFSET: u8 = 16u8;
1117 const MASK: u8 = 3;
1118 self.bits &= !((MASK as u32) << OFFSET);
1119 self.bits |= ((value & MASK) as u32) << OFFSET;
1120 self
1121 }
1122 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
1123 pub fn pupdr7(&mut self, value: u8) -> &mut Self {
1124 const OFFSET: u8 = 14u8;
1125 const MASK: u8 = 3;
1126 self.bits &= !((MASK as u32) << OFFSET);
1127 self.bits |= ((value & MASK) as u32) << OFFSET;
1128 self
1129 }
1130 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
1131 pub fn pupdr6(&mut self, value: u8) -> &mut Self {
1132 const OFFSET: u8 = 12u8;
1133 const MASK: u8 = 3;
1134 self.bits &= !((MASK as u32) << OFFSET);
1135 self.bits |= ((value & MASK) as u32) << OFFSET;
1136 self
1137 }
1138 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
1139 pub fn pupdr5(&mut self, value: u8) -> &mut Self {
1140 const OFFSET: u8 = 10u8;
1141 const MASK: u8 = 3;
1142 self.bits &= !((MASK as u32) << OFFSET);
1143 self.bits |= ((value & MASK) as u32) << OFFSET;
1144 self
1145 }
1146 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
1147 pub fn pupdr4(&mut self, value: u8) -> &mut Self {
1148 const OFFSET: u8 = 8u8;
1149 const MASK: u8 = 3;
1150 self.bits &= !((MASK as u32) << OFFSET);
1151 self.bits |= ((value & MASK) as u32) << OFFSET;
1152 self
1153 }
1154 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
1155 pub fn pupdr3(&mut self, value: u8) -> &mut Self {
1156 const OFFSET: u8 = 6u8;
1157 const MASK: u8 = 3;
1158 self.bits &= !((MASK as u32) << OFFSET);
1159 self.bits |= ((value & MASK) as u32) << OFFSET;
1160 self
1161 }
1162 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
1163 pub fn pupdr2(&mut self, value: u8) -> &mut Self {
1164 const OFFSET: u8 = 4u8;
1165 const MASK: u8 = 3;
1166 self.bits &= !((MASK as u32) << OFFSET);
1167 self.bits |= ((value & MASK) as u32) << OFFSET;
1168 self
1169 }
1170 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
1171 pub fn pupdr1(&mut self, value: u8) -> &mut Self {
1172 const OFFSET: u8 = 2u8;
1173 const MASK: u8 = 3;
1174 self.bits &= !((MASK as u32) << OFFSET);
1175 self.bits |= ((value & MASK) as u32) << OFFSET;
1176 self
1177 }
1178 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
1179 pub fn pupdr0(&mut self, value: u8) -> &mut Self {
1180 const OFFSET: u8 = 0u8;
1181 const MASK: u8 = 3;
1182 self.bits &= !((MASK as u32) << OFFSET);
1183 self.bits |= ((value & MASK) as u32) << OFFSET;
1184 self
1185 }
1186}
1187
1188# [ repr ( C ) ]
1189pub struct Idr {
1190 register: ::volatile_register::RO<u32>,
1191}
1192
1193impl Idr {
1194 pub fn read_bits(&self) -> u32 {
1195 self.register.read()
1196 }
1197 pub fn read(&self) -> IdrR {
1198 IdrR { bits: self.register.read() }
1199 }
1200}
1201
1202# [ derive ( Clone , Copy ) ]
1203# [ repr ( C ) ]
1204pub struct IdrR {
1205 bits: u32,
1206}
1207
1208impl IdrR {
1209 # [ doc = "Bit 15 - Port input data (y = 0..15)" ]
1210 pub fn idr15(&self) -> bool {
1211 const OFFSET: u8 = 15u8;
1212 self.bits & (1 << OFFSET) != 0
1213 }
1214 # [ doc = "Bit 14 - Port input data (y = 0..15)" ]
1215 pub fn idr14(&self) -> bool {
1216 const OFFSET: u8 = 14u8;
1217 self.bits & (1 << OFFSET) != 0
1218 }
1219 # [ doc = "Bit 13 - Port input data (y = 0..15)" ]
1220 pub fn idr13(&self) -> bool {
1221 const OFFSET: u8 = 13u8;
1222 self.bits & (1 << OFFSET) != 0
1223 }
1224 # [ doc = "Bit 12 - Port input data (y = 0..15)" ]
1225 pub fn idr12(&self) -> bool {
1226 const OFFSET: u8 = 12u8;
1227 self.bits & (1 << OFFSET) != 0
1228 }
1229 # [ doc = "Bit 11 - Port input data (y = 0..15)" ]
1230 pub fn idr11(&self) -> bool {
1231 const OFFSET: u8 = 11u8;
1232 self.bits & (1 << OFFSET) != 0
1233 }
1234 # [ doc = "Bit 10 - Port input data (y = 0..15)" ]
1235 pub fn idr10(&self) -> bool {
1236 const OFFSET: u8 = 10u8;
1237 self.bits & (1 << OFFSET) != 0
1238 }
1239 # [ doc = "Bit 9 - Port input data (y = 0..15)" ]
1240 pub fn idr9(&self) -> bool {
1241 const OFFSET: u8 = 9u8;
1242 self.bits & (1 << OFFSET) != 0
1243 }
1244 # [ doc = "Bit 8 - Port input data (y = 0..15)" ]
1245 pub fn idr8(&self) -> bool {
1246 const OFFSET: u8 = 8u8;
1247 self.bits & (1 << OFFSET) != 0
1248 }
1249 # [ doc = "Bit 7 - Port input data (y = 0..15)" ]
1250 pub fn idr7(&self) -> bool {
1251 const OFFSET: u8 = 7u8;
1252 self.bits & (1 << OFFSET) != 0
1253 }
1254 # [ doc = "Bit 6 - Port input data (y = 0..15)" ]
1255 pub fn idr6(&self) -> bool {
1256 const OFFSET: u8 = 6u8;
1257 self.bits & (1 << OFFSET) != 0
1258 }
1259 # [ doc = "Bit 5 - Port input data (y = 0..15)" ]
1260 pub fn idr5(&self) -> bool {
1261 const OFFSET: u8 = 5u8;
1262 self.bits & (1 << OFFSET) != 0
1263 }
1264 # [ doc = "Bit 4 - Port input data (y = 0..15)" ]
1265 pub fn idr4(&self) -> bool {
1266 const OFFSET: u8 = 4u8;
1267 self.bits & (1 << OFFSET) != 0
1268 }
1269 # [ doc = "Bit 3 - Port input data (y = 0..15)" ]
1270 pub fn idr3(&self) -> bool {
1271 const OFFSET: u8 = 3u8;
1272 self.bits & (1 << OFFSET) != 0
1273 }
1274 # [ doc = "Bit 2 - Port input data (y = 0..15)" ]
1275 pub fn idr2(&self) -> bool {
1276 const OFFSET: u8 = 2u8;
1277 self.bits & (1 << OFFSET) != 0
1278 }
1279 # [ doc = "Bit 1 - Port input data (y = 0..15)" ]
1280 pub fn idr1(&self) -> bool {
1281 const OFFSET: u8 = 1u8;
1282 self.bits & (1 << OFFSET) != 0
1283 }
1284 # [ doc = "Bit 0 - Port input data (y = 0..15)" ]
1285 pub fn idr0(&self) -> bool {
1286 const OFFSET: u8 = 0u8;
1287 self.bits & (1 << OFFSET) != 0
1288 }
1289}
1290
1291# [ repr ( C ) ]
1292pub struct Odr {
1293 register: ::volatile_register::RW<u32>,
1294}
1295
1296impl Odr {
1297 pub fn read_bits(&self) -> u32 {
1298 self.register.read()
1299 }
1300 pub unsafe fn modify_bits<F>(&mut self, f: F)
1301 where F: FnOnce(&mut u32)
1302 {
1303 let mut bits = self.register.read();
1304 f(&mut bits);
1305 self.register.write(bits);
1306 }
1307 pub unsafe fn write_bits(&mut self, bits: u32) {
1308 self.register.write(bits);
1309 }
1310 pub fn modify<F>(&mut self, f: F)
1311 where for<'w> F: FnOnce(&OdrR, &'w mut OdrW) -> &'w mut OdrW
1312 {
1313 let bits = self.register.read();
1314 let r = OdrR { bits: bits };
1315 let mut w = OdrW { bits: bits };
1316 f(&r, &mut w);
1317 self.register.write(w.bits);
1318 }
1319 pub fn read(&self) -> OdrR {
1320 OdrR { bits: self.register.read() }
1321 }
1322 pub fn write<F>(&mut self, f: F)
1323 where F: FnOnce(&mut OdrW) -> &mut OdrW
1324 {
1325 let mut w = OdrW::reset_value();
1326 f(&mut w);
1327 self.register.write(w.bits);
1328 }
1329}
1330
1331# [ derive ( Clone , Copy ) ]
1332# [ repr ( C ) ]
1333pub struct OdrR {
1334 bits: u32,
1335}
1336
1337impl OdrR {
1338 # [ doc = "Bit 15 - Port output data (y = 0..15)" ]
1339 pub fn odr15(&self) -> bool {
1340 const OFFSET: u8 = 15u8;
1341 self.bits & (1 << OFFSET) != 0
1342 }
1343 # [ doc = "Bit 14 - Port output data (y = 0..15)" ]
1344 pub fn odr14(&self) -> bool {
1345 const OFFSET: u8 = 14u8;
1346 self.bits & (1 << OFFSET) != 0
1347 }
1348 # [ doc = "Bit 13 - Port output data (y = 0..15)" ]
1349 pub fn odr13(&self) -> bool {
1350 const OFFSET: u8 = 13u8;
1351 self.bits & (1 << OFFSET) != 0
1352 }
1353 # [ doc = "Bit 12 - Port output data (y = 0..15)" ]
1354 pub fn odr12(&self) -> bool {
1355 const OFFSET: u8 = 12u8;
1356 self.bits & (1 << OFFSET) != 0
1357 }
1358 # [ doc = "Bit 11 - Port output data (y = 0..15)" ]
1359 pub fn odr11(&self) -> bool {
1360 const OFFSET: u8 = 11u8;
1361 self.bits & (1 << OFFSET) != 0
1362 }
1363 # [ doc = "Bit 10 - Port output data (y = 0..15)" ]
1364 pub fn odr10(&self) -> bool {
1365 const OFFSET: u8 = 10u8;
1366 self.bits & (1 << OFFSET) != 0
1367 }
1368 # [ doc = "Bit 9 - Port output data (y = 0..15)" ]
1369 pub fn odr9(&self) -> bool {
1370 const OFFSET: u8 = 9u8;
1371 self.bits & (1 << OFFSET) != 0
1372 }
1373 # [ doc = "Bit 8 - Port output data (y = 0..15)" ]
1374 pub fn odr8(&self) -> bool {
1375 const OFFSET: u8 = 8u8;
1376 self.bits & (1 << OFFSET) != 0
1377 }
1378 # [ doc = "Bit 7 - Port output data (y = 0..15)" ]
1379 pub fn odr7(&self) -> bool {
1380 const OFFSET: u8 = 7u8;
1381 self.bits & (1 << OFFSET) != 0
1382 }
1383 # [ doc = "Bit 6 - Port output data (y = 0..15)" ]
1384 pub fn odr6(&self) -> bool {
1385 const OFFSET: u8 = 6u8;
1386 self.bits & (1 << OFFSET) != 0
1387 }
1388 # [ doc = "Bit 5 - Port output data (y = 0..15)" ]
1389 pub fn odr5(&self) -> bool {
1390 const OFFSET: u8 = 5u8;
1391 self.bits & (1 << OFFSET) != 0
1392 }
1393 # [ doc = "Bit 4 - Port output data (y = 0..15)" ]
1394 pub fn odr4(&self) -> bool {
1395 const OFFSET: u8 = 4u8;
1396 self.bits & (1 << OFFSET) != 0
1397 }
1398 # [ doc = "Bit 3 - Port output data (y = 0..15)" ]
1399 pub fn odr3(&self) -> bool {
1400 const OFFSET: u8 = 3u8;
1401 self.bits & (1 << OFFSET) != 0
1402 }
1403 # [ doc = "Bit 2 - Port output data (y = 0..15)" ]
1404 pub fn odr2(&self) -> bool {
1405 const OFFSET: u8 = 2u8;
1406 self.bits & (1 << OFFSET) != 0
1407 }
1408 # [ doc = "Bit 1 - Port output data (y = 0..15)" ]
1409 pub fn odr1(&self) -> bool {
1410 const OFFSET: u8 = 1u8;
1411 self.bits & (1 << OFFSET) != 0
1412 }
1413 # [ doc = "Bit 0 - Port output data (y = 0..15)" ]
1414 pub fn odr0(&self) -> bool {
1415 const OFFSET: u8 = 0u8;
1416 self.bits & (1 << OFFSET) != 0
1417 }
1418}
1419
1420# [ derive ( Clone , Copy ) ]
1421# [ repr ( C ) ]
1422pub struct OdrW {
1423 bits: u32,
1424}
1425
1426impl OdrW {
1427 # [ doc = r" Reset value" ]
1428 pub fn reset_value() -> Self {
1429 OdrW { bits: 0 }
1430 }
1431 # [ doc = "Bit 15 - Port output data (y = 0..15)" ]
1432 pub fn odr15(&mut self, value: bool) -> &mut Self {
1433 const OFFSET: u8 = 15u8;
1434 if value {
1435 self.bits |= 1 << OFFSET;
1436 } else {
1437 self.bits &= !(1 << OFFSET);
1438 }
1439 self
1440 }
1441 # [ doc = "Bit 14 - Port output data (y = 0..15)" ]
1442 pub fn odr14(&mut self, value: bool) -> &mut Self {
1443 const OFFSET: u8 = 14u8;
1444 if value {
1445 self.bits |= 1 << OFFSET;
1446 } else {
1447 self.bits &= !(1 << OFFSET);
1448 }
1449 self
1450 }
1451 # [ doc = "Bit 13 - Port output data (y = 0..15)" ]
1452 pub fn odr13(&mut self, value: bool) -> &mut Self {
1453 const OFFSET: u8 = 13u8;
1454 if value {
1455 self.bits |= 1 << OFFSET;
1456 } else {
1457 self.bits &= !(1 << OFFSET);
1458 }
1459 self
1460 }
1461 # [ doc = "Bit 12 - Port output data (y = 0..15)" ]
1462 pub fn odr12(&mut self, value: bool) -> &mut Self {
1463 const OFFSET: u8 = 12u8;
1464 if value {
1465 self.bits |= 1 << OFFSET;
1466 } else {
1467 self.bits &= !(1 << OFFSET);
1468 }
1469 self
1470 }
1471 # [ doc = "Bit 11 - Port output data (y = 0..15)" ]
1472 pub fn odr11(&mut self, value: bool) -> &mut Self {
1473 const OFFSET: u8 = 11u8;
1474 if value {
1475 self.bits |= 1 << OFFSET;
1476 } else {
1477 self.bits &= !(1 << OFFSET);
1478 }
1479 self
1480 }
1481 # [ doc = "Bit 10 - Port output data (y = 0..15)" ]
1482 pub fn odr10(&mut self, value: bool) -> &mut Self {
1483 const OFFSET: u8 = 10u8;
1484 if value {
1485 self.bits |= 1 << OFFSET;
1486 } else {
1487 self.bits &= !(1 << OFFSET);
1488 }
1489 self
1490 }
1491 # [ doc = "Bit 9 - Port output data (y = 0..15)" ]
1492 pub fn odr9(&mut self, value: bool) -> &mut Self {
1493 const OFFSET: u8 = 9u8;
1494 if value {
1495 self.bits |= 1 << OFFSET;
1496 } else {
1497 self.bits &= !(1 << OFFSET);
1498 }
1499 self
1500 }
1501 # [ doc = "Bit 8 - Port output data (y = 0..15)" ]
1502 pub fn odr8(&mut self, value: bool) -> &mut Self {
1503 const OFFSET: u8 = 8u8;
1504 if value {
1505 self.bits |= 1 << OFFSET;
1506 } else {
1507 self.bits &= !(1 << OFFSET);
1508 }
1509 self
1510 }
1511 # [ doc = "Bit 7 - Port output data (y = 0..15)" ]
1512 pub fn odr7(&mut self, value: bool) -> &mut Self {
1513 const OFFSET: u8 = 7u8;
1514 if value {
1515 self.bits |= 1 << OFFSET;
1516 } else {
1517 self.bits &= !(1 << OFFSET);
1518 }
1519 self
1520 }
1521 # [ doc = "Bit 6 - Port output data (y = 0..15)" ]
1522 pub fn odr6(&mut self, value: bool) -> &mut Self {
1523 const OFFSET: u8 = 6u8;
1524 if value {
1525 self.bits |= 1 << OFFSET;
1526 } else {
1527 self.bits &= !(1 << OFFSET);
1528 }
1529 self
1530 }
1531 # [ doc = "Bit 5 - Port output data (y = 0..15)" ]
1532 pub fn odr5(&mut self, value: bool) -> &mut Self {
1533 const OFFSET: u8 = 5u8;
1534 if value {
1535 self.bits |= 1 << OFFSET;
1536 } else {
1537 self.bits &= !(1 << OFFSET);
1538 }
1539 self
1540 }
1541 # [ doc = "Bit 4 - Port output data (y = 0..15)" ]
1542 pub fn odr4(&mut self, value: bool) -> &mut Self {
1543 const OFFSET: u8 = 4u8;
1544 if value {
1545 self.bits |= 1 << OFFSET;
1546 } else {
1547 self.bits &= !(1 << OFFSET);
1548 }
1549 self
1550 }
1551 # [ doc = "Bit 3 - Port output data (y = 0..15)" ]
1552 pub fn odr3(&mut self, value: bool) -> &mut Self {
1553 const OFFSET: u8 = 3u8;
1554 if value {
1555 self.bits |= 1 << OFFSET;
1556 } else {
1557 self.bits &= !(1 << OFFSET);
1558 }
1559 self
1560 }
1561 # [ doc = "Bit 2 - Port output data (y = 0..15)" ]
1562 pub fn odr2(&mut self, value: bool) -> &mut Self {
1563 const OFFSET: u8 = 2u8;
1564 if value {
1565 self.bits |= 1 << OFFSET;
1566 } else {
1567 self.bits &= !(1 << OFFSET);
1568 }
1569 self
1570 }
1571 # [ doc = "Bit 1 - Port output data (y = 0..15)" ]
1572 pub fn odr1(&mut self, value: bool) -> &mut Self {
1573 const OFFSET: u8 = 1u8;
1574 if value {
1575 self.bits |= 1 << OFFSET;
1576 } else {
1577 self.bits &= !(1 << OFFSET);
1578 }
1579 self
1580 }
1581 # [ doc = "Bit 0 - Port output data (y = 0..15)" ]
1582 pub fn odr0(&mut self, value: bool) -> &mut Self {
1583 const OFFSET: u8 = 0u8;
1584 if value {
1585 self.bits |= 1 << OFFSET;
1586 } else {
1587 self.bits &= !(1 << OFFSET);
1588 }
1589 self
1590 }
1591}
1592
1593# [ repr ( C ) ]
1594pub struct Bsrr {
1595 register: ::volatile_register::WO<u32>,
1596}
1597
1598impl Bsrr {
1599 pub unsafe fn write_bits(&mut self, bits: u32) {
1600 self.register.write(bits);
1601 }
1602 pub fn write<F>(&self, f: F)
1603 where F: FnOnce(&mut BsrrW) -> &mut BsrrW
1604 {
1605 let mut w = BsrrW::reset_value();
1606 f(&mut w);
1607 self.register.write(w.bits);
1608 }
1609}
1610
1611# [ derive ( Clone , Copy ) ]
1612# [ repr ( C ) ]
1613pub struct BsrrW {
1614 bits: u32,
1615}
1616
1617impl BsrrW {
1618 # [ doc = r" Reset value" ]
1619 pub fn reset_value() -> Self {
1620 BsrrW { bits: 0 }
1621 }
1622 # [ doc = "Bit 31 - Port x reset bit y (y = 0..15)" ]
1623 pub fn br15(&mut self, value: bool) -> &mut Self {
1624 const OFFSET: u8 = 31u8;
1625 if value {
1626 self.bits |= 1 << OFFSET;
1627 } else {
1628 self.bits &= !(1 << OFFSET);
1629 }
1630 self
1631 }
1632 # [ doc = "Bit 30 - Port x reset bit y (y = 0..15)" ]
1633 pub fn br14(&mut self, value: bool) -> &mut Self {
1634 const OFFSET: u8 = 30u8;
1635 if value {
1636 self.bits |= 1 << OFFSET;
1637 } else {
1638 self.bits &= !(1 << OFFSET);
1639 }
1640 self
1641 }
1642 # [ doc = "Bit 29 - Port x reset bit y (y = 0..15)" ]
1643 pub fn br13(&mut self, value: bool) -> &mut Self {
1644 const OFFSET: u8 = 29u8;
1645 if value {
1646 self.bits |= 1 << OFFSET;
1647 } else {
1648 self.bits &= !(1 << OFFSET);
1649 }
1650 self
1651 }
1652 # [ doc = "Bit 28 - Port x reset bit y (y = 0..15)" ]
1653 pub fn br12(&mut self, value: bool) -> &mut Self {
1654 const OFFSET: u8 = 28u8;
1655 if value {
1656 self.bits |= 1 << OFFSET;
1657 } else {
1658 self.bits &= !(1 << OFFSET);
1659 }
1660 self
1661 }
1662 # [ doc = "Bit 27 - Port x reset bit y (y = 0..15)" ]
1663 pub fn br11(&mut self, value: bool) -> &mut Self {
1664 const OFFSET: u8 = 27u8;
1665 if value {
1666 self.bits |= 1 << OFFSET;
1667 } else {
1668 self.bits &= !(1 << OFFSET);
1669 }
1670 self
1671 }
1672 # [ doc = "Bit 26 - Port x reset bit y (y = 0..15)" ]
1673 pub fn br10(&mut self, value: bool) -> &mut Self {
1674 const OFFSET: u8 = 26u8;
1675 if value {
1676 self.bits |= 1 << OFFSET;
1677 } else {
1678 self.bits &= !(1 << OFFSET);
1679 }
1680 self
1681 }
1682 # [ doc = "Bit 25 - Port x reset bit y (y = 0..15)" ]
1683 pub fn br9(&mut self, value: bool) -> &mut Self {
1684 const OFFSET: u8 = 25u8;
1685 if value {
1686 self.bits |= 1 << OFFSET;
1687 } else {
1688 self.bits &= !(1 << OFFSET);
1689 }
1690 self
1691 }
1692 # [ doc = "Bit 24 - Port x reset bit y (y = 0..15)" ]
1693 pub fn br8(&mut self, value: bool) -> &mut Self {
1694 const OFFSET: u8 = 24u8;
1695 if value {
1696 self.bits |= 1 << OFFSET;
1697 } else {
1698 self.bits &= !(1 << OFFSET);
1699 }
1700 self
1701 }
1702 # [ doc = "Bit 23 - Port x reset bit y (y = 0..15)" ]
1703 pub fn br7(&mut self, value: bool) -> &mut Self {
1704 const OFFSET: u8 = 23u8;
1705 if value {
1706 self.bits |= 1 << OFFSET;
1707 } else {
1708 self.bits &= !(1 << OFFSET);
1709 }
1710 self
1711 }
1712 # [ doc = "Bit 22 - Port x reset bit y (y = 0..15)" ]
1713 pub fn br6(&mut self, value: bool) -> &mut Self {
1714 const OFFSET: u8 = 22u8;
1715 if value {
1716 self.bits |= 1 << OFFSET;
1717 } else {
1718 self.bits &= !(1 << OFFSET);
1719 }
1720 self
1721 }
1722 # [ doc = "Bit 21 - Port x reset bit y (y = 0..15)" ]
1723 pub fn br5(&mut self, value: bool) -> &mut Self {
1724 const OFFSET: u8 = 21u8;
1725 if value {
1726 self.bits |= 1 << OFFSET;
1727 } else {
1728 self.bits &= !(1 << OFFSET);
1729 }
1730 self
1731 }
1732 # [ doc = "Bit 20 - Port x reset bit y (y = 0..15)" ]
1733 pub fn br4(&mut self, value: bool) -> &mut Self {
1734 const OFFSET: u8 = 20u8;
1735 if value {
1736 self.bits |= 1 << OFFSET;
1737 } else {
1738 self.bits &= !(1 << OFFSET);
1739 }
1740 self
1741 }
1742 # [ doc = "Bit 19 - Port x reset bit y (y = 0..15)" ]
1743 pub fn br3(&mut self, value: bool) -> &mut Self {
1744 const OFFSET: u8 = 19u8;
1745 if value {
1746 self.bits |= 1 << OFFSET;
1747 } else {
1748 self.bits &= !(1 << OFFSET);
1749 }
1750 self
1751 }
1752 # [ doc = "Bit 18 - Port x reset bit y (y = 0..15)" ]
1753 pub fn br2(&mut self, value: bool) -> &mut Self {
1754 const OFFSET: u8 = 18u8;
1755 if value {
1756 self.bits |= 1 << OFFSET;
1757 } else {
1758 self.bits &= !(1 << OFFSET);
1759 }
1760 self
1761 }
1762 # [ doc = "Bit 17 - Port x reset bit y (y = 0..15)" ]
1763 pub fn br1(&mut self, value: bool) -> &mut Self {
1764 const OFFSET: u8 = 17u8;
1765 if value {
1766 self.bits |= 1 << OFFSET;
1767 } else {
1768 self.bits &= !(1 << OFFSET);
1769 }
1770 self
1771 }
1772 # [ doc = "Bit 16 - Port x set bit y (y= 0..15)" ]
1773 pub fn br0(&mut self, value: bool) -> &mut Self {
1774 const OFFSET: u8 = 16u8;
1775 if value {
1776 self.bits |= 1 << OFFSET;
1777 } else {
1778 self.bits &= !(1 << OFFSET);
1779 }
1780 self
1781 }
1782 # [ doc = "Bit 15 - Port x set bit y (y= 0..15)" ]
1783 pub fn bs15(&mut self, value: bool) -> &mut Self {
1784 const OFFSET: u8 = 15u8;
1785 if value {
1786 self.bits |= 1 << OFFSET;
1787 } else {
1788 self.bits &= !(1 << OFFSET);
1789 }
1790 self
1791 }
1792 # [ doc = "Bit 14 - Port x set bit y (y= 0..15)" ]
1793 pub fn bs14(&mut self, value: bool) -> &mut Self {
1794 const OFFSET: u8 = 14u8;
1795 if value {
1796 self.bits |= 1 << OFFSET;
1797 } else {
1798 self.bits &= !(1 << OFFSET);
1799 }
1800 self
1801 }
1802 # [ doc = "Bit 13 - Port x set bit y (y= 0..15)" ]
1803 pub fn bs13(&mut self, value: bool) -> &mut Self {
1804 const OFFSET: u8 = 13u8;
1805 if value {
1806 self.bits |= 1 << OFFSET;
1807 } else {
1808 self.bits &= !(1 << OFFSET);
1809 }
1810 self
1811 }
1812 # [ doc = "Bit 12 - Port x set bit y (y= 0..15)" ]
1813 pub fn bs12(&mut self, value: bool) -> &mut Self {
1814 const OFFSET: u8 = 12u8;
1815 if value {
1816 self.bits |= 1 << OFFSET;
1817 } else {
1818 self.bits &= !(1 << OFFSET);
1819 }
1820 self
1821 }
1822 # [ doc = "Bit 11 - Port x set bit y (y= 0..15)" ]
1823 pub fn bs11(&mut self, value: bool) -> &mut Self {
1824 const OFFSET: u8 = 11u8;
1825 if value {
1826 self.bits |= 1 << OFFSET;
1827 } else {
1828 self.bits &= !(1 << OFFSET);
1829 }
1830 self
1831 }
1832 # [ doc = "Bit 10 - Port x set bit y (y= 0..15)" ]
1833 pub fn bs10(&mut self, value: bool) -> &mut Self {
1834 const OFFSET: u8 = 10u8;
1835 if value {
1836 self.bits |= 1 << OFFSET;
1837 } else {
1838 self.bits &= !(1 << OFFSET);
1839 }
1840 self
1841 }
1842 # [ doc = "Bit 9 - Port x set bit y (y= 0..15)" ]
1843 pub fn bs9(&mut self, value: bool) -> &mut Self {
1844 const OFFSET: u8 = 9u8;
1845 if value {
1846 self.bits |= 1 << OFFSET;
1847 } else {
1848 self.bits &= !(1 << OFFSET);
1849 }
1850 self
1851 }
1852 # [ doc = "Bit 8 - Port x set bit y (y= 0..15)" ]
1853 pub fn bs8(&mut self, value: bool) -> &mut Self {
1854 const OFFSET: u8 = 8u8;
1855 if value {
1856 self.bits |= 1 << OFFSET;
1857 } else {
1858 self.bits &= !(1 << OFFSET);
1859 }
1860 self
1861 }
1862 # [ doc = "Bit 7 - Port x set bit y (y= 0..15)" ]
1863 pub fn bs7(&mut self, value: bool) -> &mut Self {
1864 const OFFSET: u8 = 7u8;
1865 if value {
1866 self.bits |= 1 << OFFSET;
1867 } else {
1868 self.bits &= !(1 << OFFSET);
1869 }
1870 self
1871 }
1872 # [ doc = "Bit 6 - Port x set bit y (y= 0..15)" ]
1873 pub fn bs6(&mut self, value: bool) -> &mut Self {
1874 const OFFSET: u8 = 6u8;
1875 if value {
1876 self.bits |= 1 << OFFSET;
1877 } else {
1878 self.bits &= !(1 << OFFSET);
1879 }
1880 self
1881 }
1882 # [ doc = "Bit 5 - Port x set bit y (y= 0..15)" ]
1883 pub fn bs5(&mut self, value: bool) -> &mut Self {
1884 const OFFSET: u8 = 5u8;
1885 if value {
1886 self.bits |= 1 << OFFSET;
1887 } else {
1888 self.bits &= !(1 << OFFSET);
1889 }
1890 self
1891 }
1892 # [ doc = "Bit 4 - Port x set bit y (y= 0..15)" ]
1893 pub fn bs4(&mut self, value: bool) -> &mut Self {
1894 const OFFSET: u8 = 4u8;
1895 if value {
1896 self.bits |= 1 << OFFSET;
1897 } else {
1898 self.bits &= !(1 << OFFSET);
1899 }
1900 self
1901 }
1902 # [ doc = "Bit 3 - Port x set bit y (y= 0..15)" ]
1903 pub fn bs3(&mut self, value: bool) -> &mut Self {
1904 const OFFSET: u8 = 3u8;
1905 if value {
1906 self.bits |= 1 << OFFSET;
1907 } else {
1908 self.bits &= !(1 << OFFSET);
1909 }
1910 self
1911 }
1912 # [ doc = "Bit 2 - Port x set bit y (y= 0..15)" ]
1913 pub fn bs2(&mut self, value: bool) -> &mut Self {
1914 const OFFSET: u8 = 2u8;
1915 if value {
1916 self.bits |= 1 << OFFSET;
1917 } else {
1918 self.bits &= !(1 << OFFSET);
1919 }
1920 self
1921 }
1922 # [ doc = "Bit 1 - Port x set bit y (y= 0..15)" ]
1923 pub fn bs1(&mut self, value: bool) -> &mut Self {
1924 const OFFSET: u8 = 1u8;
1925 if value {
1926 self.bits |= 1 << OFFSET;
1927 } else {
1928 self.bits &= !(1 << OFFSET);
1929 }
1930 self
1931 }
1932 # [ doc = "Bit 0 - Port x set bit y (y= 0..15)" ]
1933 pub fn bs0(&mut self, value: bool) -> &mut Self {
1934 const OFFSET: u8 = 0u8;
1935 if value {
1936 self.bits |= 1 << OFFSET;
1937 } else {
1938 self.bits &= !(1 << OFFSET);
1939 }
1940 self
1941 }
1942}
1943
1944# [ repr ( C ) ]
1945pub struct Lckr {
1946 register: ::volatile_register::RW<u32>,
1947}
1948
1949impl Lckr {
1950 pub fn read_bits(&self) -> u32 {
1951 self.register.read()
1952 }
1953 pub unsafe fn modify_bits<F>(&mut self, f: F)
1954 where F: FnOnce(&mut u32)
1955 {
1956 let mut bits = self.register.read();
1957 f(&mut bits);
1958 self.register.write(bits);
1959 }
1960 pub unsafe fn write_bits(&mut self, bits: u32) {
1961 self.register.write(bits);
1962 }
1963 pub fn modify<F>(&mut self, f: F)
1964 where for<'w> F: FnOnce(&LckrR, &'w mut LckrW) -> &'w mut LckrW
1965 {
1966 let bits = self.register.read();
1967 let r = LckrR { bits: bits };
1968 let mut w = LckrW { bits: bits };
1969 f(&r, &mut w);
1970 self.register.write(w.bits);
1971 }
1972 pub fn read(&self) -> LckrR {
1973 LckrR { bits: self.register.read() }
1974 }
1975 pub fn write<F>(&mut self, f: F)
1976 where F: FnOnce(&mut LckrW) -> &mut LckrW
1977 {
1978 let mut w = LckrW::reset_value();
1979 f(&mut w);
1980 self.register.write(w.bits);
1981 }
1982}
1983
1984# [ derive ( Clone , Copy ) ]
1985# [ repr ( C ) ]
1986pub struct LckrR {
1987 bits: u32,
1988}
1989
1990impl LckrR {
1991 # [ doc = "Bit 16 - Lok Key" ]
1992 pub fn lckk(&self) -> bool {
1993 const OFFSET: u8 = 16u8;
1994 self.bits & (1 << OFFSET) != 0
1995 }
1996 # [ doc = "Bit 15 - Port x lock bit y (y= 0..15)" ]
1997 pub fn lck15(&self) -> bool {
1998 const OFFSET: u8 = 15u8;
1999 self.bits & (1 << OFFSET) != 0
2000 }
2001 # [ doc = "Bit 14 - Port x lock bit y (y= 0..15)" ]
2002 pub fn lck14(&self) -> bool {
2003 const OFFSET: u8 = 14u8;
2004 self.bits & (1 << OFFSET) != 0
2005 }
2006 # [ doc = "Bit 13 - Port x lock bit y (y= 0..15)" ]
2007 pub fn lck13(&self) -> bool {
2008 const OFFSET: u8 = 13u8;
2009 self.bits & (1 << OFFSET) != 0
2010 }
2011 # [ doc = "Bit 12 - Port x lock bit y (y= 0..15)" ]
2012 pub fn lck12(&self) -> bool {
2013 const OFFSET: u8 = 12u8;
2014 self.bits & (1 << OFFSET) != 0
2015 }
2016 # [ doc = "Bit 11 - Port x lock bit y (y= 0..15)" ]
2017 pub fn lck11(&self) -> bool {
2018 const OFFSET: u8 = 11u8;
2019 self.bits & (1 << OFFSET) != 0
2020 }
2021 # [ doc = "Bit 10 - Port x lock bit y (y= 0..15)" ]
2022 pub fn lck10(&self) -> bool {
2023 const OFFSET: u8 = 10u8;
2024 self.bits & (1 << OFFSET) != 0
2025 }
2026 # [ doc = "Bit 9 - Port x lock bit y (y= 0..15)" ]
2027 pub fn lck9(&self) -> bool {
2028 const OFFSET: u8 = 9u8;
2029 self.bits & (1 << OFFSET) != 0
2030 }
2031 # [ doc = "Bit 8 - Port x lock bit y (y= 0..15)" ]
2032 pub fn lck8(&self) -> bool {
2033 const OFFSET: u8 = 8u8;
2034 self.bits & (1 << OFFSET) != 0
2035 }
2036 # [ doc = "Bit 7 - Port x lock bit y (y= 0..15)" ]
2037 pub fn lck7(&self) -> bool {
2038 const OFFSET: u8 = 7u8;
2039 self.bits & (1 << OFFSET) != 0
2040 }
2041 # [ doc = "Bit 6 - Port x lock bit y (y= 0..15)" ]
2042 pub fn lck6(&self) -> bool {
2043 const OFFSET: u8 = 6u8;
2044 self.bits & (1 << OFFSET) != 0
2045 }
2046 # [ doc = "Bit 5 - Port x lock bit y (y= 0..15)" ]
2047 pub fn lck5(&self) -> bool {
2048 const OFFSET: u8 = 5u8;
2049 self.bits & (1 << OFFSET) != 0
2050 }
2051 # [ doc = "Bit 4 - Port x lock bit y (y= 0..15)" ]
2052 pub fn lck4(&self) -> bool {
2053 const OFFSET: u8 = 4u8;
2054 self.bits & (1 << OFFSET) != 0
2055 }
2056 # [ doc = "Bit 3 - Port x lock bit y (y= 0..15)" ]
2057 pub fn lck3(&self) -> bool {
2058 const OFFSET: u8 = 3u8;
2059 self.bits & (1 << OFFSET) != 0
2060 }
2061 # [ doc = "Bit 2 - Port x lock bit y (y= 0..15)" ]
2062 pub fn lck2(&self) -> bool {
2063 const OFFSET: u8 = 2u8;
2064 self.bits & (1 << OFFSET) != 0
2065 }
2066 # [ doc = "Bit 1 - Port x lock bit y (y= 0..15)" ]
2067 pub fn lck1(&self) -> bool {
2068 const OFFSET: u8 = 1u8;
2069 self.bits & (1 << OFFSET) != 0
2070 }
2071 # [ doc = "Bit 0 - Port x lock bit y (y= 0..15)" ]
2072 pub fn lck0(&self) -> bool {
2073 const OFFSET: u8 = 0u8;
2074 self.bits & (1 << OFFSET) != 0
2075 }
2076}
2077
2078# [ derive ( Clone , Copy ) ]
2079# [ repr ( C ) ]
2080pub struct LckrW {
2081 bits: u32,
2082}
2083
2084impl LckrW {
2085 # [ doc = r" Reset value" ]
2086 pub fn reset_value() -> Self {
2087 LckrW { bits: 0 }
2088 }
2089 # [ doc = "Bit 16 - Lok Key" ]
2090 pub fn lckk(&mut self, value: bool) -> &mut Self {
2091 const OFFSET: u8 = 16u8;
2092 if value {
2093 self.bits |= 1 << OFFSET;
2094 } else {
2095 self.bits &= !(1 << OFFSET);
2096 }
2097 self
2098 }
2099 # [ doc = "Bit 15 - Port x lock bit y (y= 0..15)" ]
2100 pub fn lck15(&mut self, value: bool) -> &mut Self {
2101 const OFFSET: u8 = 15u8;
2102 if value {
2103 self.bits |= 1 << OFFSET;
2104 } else {
2105 self.bits &= !(1 << OFFSET);
2106 }
2107 self
2108 }
2109 # [ doc = "Bit 14 - Port x lock bit y (y= 0..15)" ]
2110 pub fn lck14(&mut self, value: bool) -> &mut Self {
2111 const OFFSET: u8 = 14u8;
2112 if value {
2113 self.bits |= 1 << OFFSET;
2114 } else {
2115 self.bits &= !(1 << OFFSET);
2116 }
2117 self
2118 }
2119 # [ doc = "Bit 13 - Port x lock bit y (y= 0..15)" ]
2120 pub fn lck13(&mut self, value: bool) -> &mut Self {
2121 const OFFSET: u8 = 13u8;
2122 if value {
2123 self.bits |= 1 << OFFSET;
2124 } else {
2125 self.bits &= !(1 << OFFSET);
2126 }
2127 self
2128 }
2129 # [ doc = "Bit 12 - Port x lock bit y (y= 0..15)" ]
2130 pub fn lck12(&mut self, value: bool) -> &mut Self {
2131 const OFFSET: u8 = 12u8;
2132 if value {
2133 self.bits |= 1 << OFFSET;
2134 } else {
2135 self.bits &= !(1 << OFFSET);
2136 }
2137 self
2138 }
2139 # [ doc = "Bit 11 - Port x lock bit y (y= 0..15)" ]
2140 pub fn lck11(&mut self, value: bool) -> &mut Self {
2141 const OFFSET: u8 = 11u8;
2142 if value {
2143 self.bits |= 1 << OFFSET;
2144 } else {
2145 self.bits &= !(1 << OFFSET);
2146 }
2147 self
2148 }
2149 # [ doc = "Bit 10 - Port x lock bit y (y= 0..15)" ]
2150 pub fn lck10(&mut self, value: bool) -> &mut Self {
2151 const OFFSET: u8 = 10u8;
2152 if value {
2153 self.bits |= 1 << OFFSET;
2154 } else {
2155 self.bits &= !(1 << OFFSET);
2156 }
2157 self
2158 }
2159 # [ doc = "Bit 9 - Port x lock bit y (y= 0..15)" ]
2160 pub fn lck9(&mut self, value: bool) -> &mut Self {
2161 const OFFSET: u8 = 9u8;
2162 if value {
2163 self.bits |= 1 << OFFSET;
2164 } else {
2165 self.bits &= !(1 << OFFSET);
2166 }
2167 self
2168 }
2169 # [ doc = "Bit 8 - Port x lock bit y (y= 0..15)" ]
2170 pub fn lck8(&mut self, value: bool) -> &mut Self {
2171 const OFFSET: u8 = 8u8;
2172 if value {
2173 self.bits |= 1 << OFFSET;
2174 } else {
2175 self.bits &= !(1 << OFFSET);
2176 }
2177 self
2178 }
2179 # [ doc = "Bit 7 - Port x lock bit y (y= 0..15)" ]
2180 pub fn lck7(&mut self, value: bool) -> &mut Self {
2181 const OFFSET: u8 = 7u8;
2182 if value {
2183 self.bits |= 1 << OFFSET;
2184 } else {
2185 self.bits &= !(1 << OFFSET);
2186 }
2187 self
2188 }
2189 # [ doc = "Bit 6 - Port x lock bit y (y= 0..15)" ]
2190 pub fn lck6(&mut self, value: bool) -> &mut Self {
2191 const OFFSET: u8 = 6u8;
2192 if value {
2193 self.bits |= 1 << OFFSET;
2194 } else {
2195 self.bits &= !(1 << OFFSET);
2196 }
2197 self
2198 }
2199 # [ doc = "Bit 5 - Port x lock bit y (y= 0..15)" ]
2200 pub fn lck5(&mut self, value: bool) -> &mut Self {
2201 const OFFSET: u8 = 5u8;
2202 if value {
2203 self.bits |= 1 << OFFSET;
2204 } else {
2205 self.bits &= !(1 << OFFSET);
2206 }
2207 self
2208 }
2209 # [ doc = "Bit 4 - Port x lock bit y (y= 0..15)" ]
2210 pub fn lck4(&mut self, value: bool) -> &mut Self {
2211 const OFFSET: u8 = 4u8;
2212 if value {
2213 self.bits |= 1 << OFFSET;
2214 } else {
2215 self.bits &= !(1 << OFFSET);
2216 }
2217 self
2218 }
2219 # [ doc = "Bit 3 - Port x lock bit y (y= 0..15)" ]
2220 pub fn lck3(&mut self, value: bool) -> &mut Self {
2221 const OFFSET: u8 = 3u8;
2222 if value {
2223 self.bits |= 1 << OFFSET;
2224 } else {
2225 self.bits &= !(1 << OFFSET);
2226 }
2227 self
2228 }
2229 # [ doc = "Bit 2 - Port x lock bit y (y= 0..15)" ]
2230 pub fn lck2(&mut self, value: bool) -> &mut Self {
2231 const OFFSET: u8 = 2u8;
2232 if value {
2233 self.bits |= 1 << OFFSET;
2234 } else {
2235 self.bits &= !(1 << OFFSET);
2236 }
2237 self
2238 }
2239 # [ doc = "Bit 1 - Port x lock bit y (y= 0..15)" ]
2240 pub fn lck1(&mut self, value: bool) -> &mut Self {
2241 const OFFSET: u8 = 1u8;
2242 if value {
2243 self.bits |= 1 << OFFSET;
2244 } else {
2245 self.bits &= !(1 << OFFSET);
2246 }
2247 self
2248 }
2249 # [ doc = "Bit 0 - Port x lock bit y (y= 0..15)" ]
2250 pub fn lck0(&mut self, value: bool) -> &mut Self {
2251 const OFFSET: u8 = 0u8;
2252 if value {
2253 self.bits |= 1 << OFFSET;
2254 } else {
2255 self.bits &= !(1 << OFFSET);
2256 }
2257 self
2258 }
2259}
2260
2261# [ repr ( C ) ]
2262pub struct Afrl {
2263 register: ::volatile_register::RW<u32>,
2264}
2265
2266impl Afrl {
2267 pub fn read_bits(&self) -> u32 {
2268 self.register.read()
2269 }
2270 pub unsafe fn modify_bits<F>(&mut self, f: F)
2271 where F: FnOnce(&mut u32)
2272 {
2273 let mut bits = self.register.read();
2274 f(&mut bits);
2275 self.register.write(bits);
2276 }
2277 pub unsafe fn write_bits(&mut self, bits: u32) {
2278 self.register.write(bits);
2279 }
2280 pub fn modify<F>(&mut self, f: F)
2281 where for<'w> F: FnOnce(&AfrlR, &'w mut AfrlW) -> &'w mut AfrlW
2282 {
2283 let bits = self.register.read();
2284 let r = AfrlR { bits: bits };
2285 let mut w = AfrlW { bits: bits };
2286 f(&r, &mut w);
2287 self.register.write(w.bits);
2288 }
2289 pub fn read(&self) -> AfrlR {
2290 AfrlR { bits: self.register.read() }
2291 }
2292 pub fn write<F>(&mut self, f: F)
2293 where F: FnOnce(&mut AfrlW) -> &mut AfrlW
2294 {
2295 let mut w = AfrlW::reset_value();
2296 f(&mut w);
2297 self.register.write(w.bits);
2298 }
2299}
2300
2301# [ derive ( Clone , Copy ) ]
2302# [ repr ( C ) ]
2303pub struct AfrlR {
2304 bits: u32,
2305}
2306
2307impl AfrlR {
2308 # [ doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)" ]
2309 pub fn afrl7(&self) -> u8 {
2310 const MASK: u32 = 15;
2311 const OFFSET: u8 = 28u8;
2312 ((self.bits >> OFFSET) & MASK) as u8
2313 }
2314 # [ doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)" ]
2315 pub fn afrl6(&self) -> u8 {
2316 const MASK: u32 = 15;
2317 const OFFSET: u8 = 24u8;
2318 ((self.bits >> OFFSET) & MASK) as u8
2319 }
2320 # [ doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)" ]
2321 pub fn afrl5(&self) -> u8 {
2322 const MASK: u32 = 15;
2323 const OFFSET: u8 = 20u8;
2324 ((self.bits >> OFFSET) & MASK) as u8
2325 }
2326 # [ doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)" ]
2327 pub fn afrl4(&self) -> u8 {
2328 const MASK: u32 = 15;
2329 const OFFSET: u8 = 16u8;
2330 ((self.bits >> OFFSET) & MASK) as u8
2331 }
2332 # [ doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)" ]
2333 pub fn afrl3(&self) -> u8 {
2334 const MASK: u32 = 15;
2335 const OFFSET: u8 = 12u8;
2336 ((self.bits >> OFFSET) & MASK) as u8
2337 }
2338 # [ doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)" ]
2339 pub fn afrl2(&self) -> u8 {
2340 const MASK: u32 = 15;
2341 const OFFSET: u8 = 8u8;
2342 ((self.bits >> OFFSET) & MASK) as u8
2343 }
2344 # [ doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)" ]
2345 pub fn afrl1(&self) -> u8 {
2346 const MASK: u32 = 15;
2347 const OFFSET: u8 = 4u8;
2348 ((self.bits >> OFFSET) & MASK) as u8
2349 }
2350 # [ doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)" ]
2351 pub fn afrl0(&self) -> u8 {
2352 const MASK: u32 = 15;
2353 const OFFSET: u8 = 0u8;
2354 ((self.bits >> OFFSET) & MASK) as u8
2355 }
2356}
2357
2358# [ derive ( Clone , Copy ) ]
2359# [ repr ( C ) ]
2360pub struct AfrlW {
2361 bits: u32,
2362}
2363
2364impl AfrlW {
2365 # [ doc = r" Reset value" ]
2366 pub fn reset_value() -> Self {
2367 AfrlW { bits: 0 }
2368 }
2369 # [ doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)" ]
2370 pub fn afrl7(&mut self, value: u8) -> &mut Self {
2371 const OFFSET: u8 = 28u8;
2372 const MASK: u8 = 15;
2373 self.bits &= !((MASK as u32) << OFFSET);
2374 self.bits |= ((value & MASK) as u32) << OFFSET;
2375 self
2376 }
2377 # [ doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)" ]
2378 pub fn afrl6(&mut self, value: u8) -> &mut Self {
2379 const OFFSET: u8 = 24u8;
2380 const MASK: u8 = 15;
2381 self.bits &= !((MASK as u32) << OFFSET);
2382 self.bits |= ((value & MASK) as u32) << OFFSET;
2383 self
2384 }
2385 # [ doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)" ]
2386 pub fn afrl5(&mut self, value: u8) -> &mut Self {
2387 const OFFSET: u8 = 20u8;
2388 const MASK: u8 = 15;
2389 self.bits &= !((MASK as u32) << OFFSET);
2390 self.bits |= ((value & MASK) as u32) << OFFSET;
2391 self
2392 }
2393 # [ doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)" ]
2394 pub fn afrl4(&mut self, value: u8) -> &mut Self {
2395 const OFFSET: u8 = 16u8;
2396 const MASK: u8 = 15;
2397 self.bits &= !((MASK as u32) << OFFSET);
2398 self.bits |= ((value & MASK) as u32) << OFFSET;
2399 self
2400 }
2401 # [ doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)" ]
2402 pub fn afrl3(&mut self, value: u8) -> &mut Self {
2403 const OFFSET: u8 = 12u8;
2404 const MASK: u8 = 15;
2405 self.bits &= !((MASK as u32) << OFFSET);
2406 self.bits |= ((value & MASK) as u32) << OFFSET;
2407 self
2408 }
2409 # [ doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)" ]
2410 pub fn afrl2(&mut self, value: u8) -> &mut Self {
2411 const OFFSET: u8 = 8u8;
2412 const MASK: u8 = 15;
2413 self.bits &= !((MASK as u32) << OFFSET);
2414 self.bits |= ((value & MASK) as u32) << OFFSET;
2415 self
2416 }
2417 # [ doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)" ]
2418 pub fn afrl1(&mut self, value: u8) -> &mut Self {
2419 const OFFSET: u8 = 4u8;
2420 const MASK: u8 = 15;
2421 self.bits &= !((MASK as u32) << OFFSET);
2422 self.bits |= ((value & MASK) as u32) << OFFSET;
2423 self
2424 }
2425 # [ doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)" ]
2426 pub fn afrl0(&mut self, value: u8) -> &mut Self {
2427 const OFFSET: u8 = 0u8;
2428 const MASK: u8 = 15;
2429 self.bits &= !((MASK as u32) << OFFSET);
2430 self.bits |= ((value & MASK) as u32) << OFFSET;
2431 self
2432 }
2433}
2434
2435# [ repr ( C ) ]
2436pub struct Afrh {
2437 register: ::volatile_register::RW<u32>,
2438}
2439
2440impl Afrh {
2441 pub fn read_bits(&self) -> u32 {
2442 self.register.read()
2443 }
2444 pub unsafe fn modify_bits<F>(&mut self, f: F)
2445 where F: FnOnce(&mut u32)
2446 {
2447 let mut bits = self.register.read();
2448 f(&mut bits);
2449 self.register.write(bits);
2450 }
2451 pub unsafe fn write_bits(&mut self, bits: u32) {
2452 self.register.write(bits);
2453 }
2454 pub fn modify<F>(&mut self, f: F)
2455 where for<'w> F: FnOnce(&AfrhR, &'w mut AfrhW) -> &'w mut AfrhW
2456 {
2457 let bits = self.register.read();
2458 let r = AfrhR { bits: bits };
2459 let mut w = AfrhW { bits: bits };
2460 f(&r, &mut w);
2461 self.register.write(w.bits);
2462 }
2463 pub fn read(&self) -> AfrhR {
2464 AfrhR { bits: self.register.read() }
2465 }
2466 pub fn write<F>(&mut self, f: F)
2467 where F: FnOnce(&mut AfrhW) -> &mut AfrhW
2468 {
2469 let mut w = AfrhW::reset_value();
2470 f(&mut w);
2471 self.register.write(w.bits);
2472 }
2473}
2474
2475# [ derive ( Clone , Copy ) ]
2476# [ repr ( C ) ]
2477pub struct AfrhR {
2478 bits: u32,
2479}
2480
2481impl AfrhR {
2482 # [ doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)" ]
2483 pub fn afrh15(&self) -> u8 {
2484 const MASK: u32 = 15;
2485 const OFFSET: u8 = 28u8;
2486 ((self.bits >> OFFSET) & MASK) as u8
2487 }
2488 # [ doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)" ]
2489 pub fn afrh14(&self) -> u8 {
2490 const MASK: u32 = 15;
2491 const OFFSET: u8 = 24u8;
2492 ((self.bits >> OFFSET) & MASK) as u8
2493 }
2494 # [ doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)" ]
2495 pub fn afrh13(&self) -> u8 {
2496 const MASK: u32 = 15;
2497 const OFFSET: u8 = 20u8;
2498 ((self.bits >> OFFSET) & MASK) as u8
2499 }
2500 # [ doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)" ]
2501 pub fn afrh12(&self) -> u8 {
2502 const MASK: u32 = 15;
2503 const OFFSET: u8 = 16u8;
2504 ((self.bits >> OFFSET) & MASK) as u8
2505 }
2506 # [ doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)" ]
2507 pub fn afrh11(&self) -> u8 {
2508 const MASK: u32 = 15;
2509 const OFFSET: u8 = 12u8;
2510 ((self.bits >> OFFSET) & MASK) as u8
2511 }
2512 # [ doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)" ]
2513 pub fn afrh10(&self) -> u8 {
2514 const MASK: u32 = 15;
2515 const OFFSET: u8 = 8u8;
2516 ((self.bits >> OFFSET) & MASK) as u8
2517 }
2518 # [ doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)" ]
2519 pub fn afrh9(&self) -> u8 {
2520 const MASK: u32 = 15;
2521 const OFFSET: u8 = 4u8;
2522 ((self.bits >> OFFSET) & MASK) as u8
2523 }
2524 # [ doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)" ]
2525 pub fn afrh8(&self) -> u8 {
2526 const MASK: u32 = 15;
2527 const OFFSET: u8 = 0u8;
2528 ((self.bits >> OFFSET) & MASK) as u8
2529 }
2530}
2531
2532# [ derive ( Clone , Copy ) ]
2533# [ repr ( C ) ]
2534pub struct AfrhW {
2535 bits: u32,
2536}
2537
2538impl AfrhW {
2539 # [ doc = r" Reset value" ]
2540 pub fn reset_value() -> Self {
2541 AfrhW { bits: 0 }
2542 }
2543 # [ doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)" ]
2544 pub fn afrh15(&mut self, value: u8) -> &mut Self {
2545 const OFFSET: u8 = 28u8;
2546 const MASK: u8 = 15;
2547 self.bits &= !((MASK as u32) << OFFSET);
2548 self.bits |= ((value & MASK) as u32) << OFFSET;
2549 self
2550 }
2551 # [ doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)" ]
2552 pub fn afrh14(&mut self, value: u8) -> &mut Self {
2553 const OFFSET: u8 = 24u8;
2554 const MASK: u8 = 15;
2555 self.bits &= !((MASK as u32) << OFFSET);
2556 self.bits |= ((value & MASK) as u32) << OFFSET;
2557 self
2558 }
2559 # [ doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)" ]
2560 pub fn afrh13(&mut self, value: u8) -> &mut Self {
2561 const OFFSET: u8 = 20u8;
2562 const MASK: u8 = 15;
2563 self.bits &= !((MASK as u32) << OFFSET);
2564 self.bits |= ((value & MASK) as u32) << OFFSET;
2565 self
2566 }
2567 # [ doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)" ]
2568 pub fn afrh12(&mut self, value: u8) -> &mut Self {
2569 const OFFSET: u8 = 16u8;
2570 const MASK: u8 = 15;
2571 self.bits &= !((MASK as u32) << OFFSET);
2572 self.bits |= ((value & MASK) as u32) << OFFSET;
2573 self
2574 }
2575 # [ doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)" ]
2576 pub fn afrh11(&mut self, value: u8) -> &mut Self {
2577 const OFFSET: u8 = 12u8;
2578 const MASK: u8 = 15;
2579 self.bits &= !((MASK as u32) << OFFSET);
2580 self.bits |= ((value & MASK) as u32) << OFFSET;
2581 self
2582 }
2583 # [ doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)" ]
2584 pub fn afrh10(&mut self, value: u8) -> &mut Self {
2585 const OFFSET: u8 = 8u8;
2586 const MASK: u8 = 15;
2587 self.bits &= !((MASK as u32) << OFFSET);
2588 self.bits |= ((value & MASK) as u32) << OFFSET;
2589 self
2590 }
2591 # [ doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)" ]
2592 pub fn afrh9(&mut self, value: u8) -> &mut Self {
2593 const OFFSET: u8 = 4u8;
2594 const MASK: u8 = 15;
2595 self.bits &= !((MASK as u32) << OFFSET);
2596 self.bits |= ((value & MASK) as u32) << OFFSET;
2597 self
2598 }
2599 # [ doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)" ]
2600 pub fn afrh8(&mut self, value: u8) -> &mut Self {
2601 const OFFSET: u8 = 0u8;
2602 const MASK: u8 = 15;
2603 self.bits &= !((MASK as u32) << OFFSET);
2604 self.bits |= ((value & MASK) as u32) << OFFSET;
2605 self
2606 }
2607}
2608
2609# [ repr ( C ) ]
2610pub struct Brr {
2611 register: ::volatile_register::WO<u32>,
2612}
2613
2614impl Brr {
2615 pub unsafe fn write_bits(&mut self, bits: u32) {
2616 self.register.write(bits);
2617 }
2618 pub fn write<F>(&self, f: F)
2619 where F: FnOnce(&mut BrrW) -> &mut BrrW
2620 {
2621 let mut w = BrrW::reset_value();
2622 f(&mut w);
2623 self.register.write(w.bits);
2624 }
2625}
2626
2627# [ derive ( Clone , Copy ) ]
2628# [ repr ( C ) ]
2629pub struct BrrW {
2630 bits: u32,
2631}
2632
2633impl BrrW {
2634 # [ doc = r" Reset value" ]
2635 pub fn reset_value() -> Self {
2636 BrrW { bits: 0 }
2637 }
2638 # [ doc = "Bit 0 - Port x Reset bit y" ]
2639 pub fn br0(&mut self, value: bool) -> &mut Self {
2640 const OFFSET: u8 = 0u8;
2641 if value {
2642 self.bits |= 1 << OFFSET;
2643 } else {
2644 self.bits &= !(1 << OFFSET);
2645 }
2646 self
2647 }
2648 # [ doc = "Bit 1 - Port x Reset bit y" ]
2649 pub fn br1(&mut self, value: bool) -> &mut Self {
2650 const OFFSET: u8 = 1u8;
2651 if value {
2652 self.bits |= 1 << OFFSET;
2653 } else {
2654 self.bits &= !(1 << OFFSET);
2655 }
2656 self
2657 }
2658 # [ doc = "Bit 2 - Port x Reset bit y" ]
2659 pub fn br2(&mut self, value: bool) -> &mut Self {
2660 const OFFSET: u8 = 2u8;
2661 if value {
2662 self.bits |= 1 << OFFSET;
2663 } else {
2664 self.bits &= !(1 << OFFSET);
2665 }
2666 self
2667 }
2668 # [ doc = "Bit 3 - Port x Reset bit y" ]
2669 pub fn br3(&mut self, value: bool) -> &mut Self {
2670 const OFFSET: u8 = 3u8;
2671 if value {
2672 self.bits |= 1 << OFFSET;
2673 } else {
2674 self.bits &= !(1 << OFFSET);
2675 }
2676 self
2677 }
2678 # [ doc = "Bit 4 - Port x Reset bit y" ]
2679 pub fn br4(&mut self, value: bool) -> &mut Self {
2680 const OFFSET: u8 = 4u8;
2681 if value {
2682 self.bits |= 1 << OFFSET;
2683 } else {
2684 self.bits &= !(1 << OFFSET);
2685 }
2686 self
2687 }
2688 # [ doc = "Bit 5 - Port x Reset bit y" ]
2689 pub fn br5(&mut self, value: bool) -> &mut Self {
2690 const OFFSET: u8 = 5u8;
2691 if value {
2692 self.bits |= 1 << OFFSET;
2693 } else {
2694 self.bits &= !(1 << OFFSET);
2695 }
2696 self
2697 }
2698 # [ doc = "Bit 6 - Port x Reset bit y" ]
2699 pub fn br6(&mut self, value: bool) -> &mut Self {
2700 const OFFSET: u8 = 6u8;
2701 if value {
2702 self.bits |= 1 << OFFSET;
2703 } else {
2704 self.bits &= !(1 << OFFSET);
2705 }
2706 self
2707 }
2708 # [ doc = "Bit 7 - Port x Reset bit y" ]
2709 pub fn br7(&mut self, value: bool) -> &mut Self {
2710 const OFFSET: u8 = 7u8;
2711 if value {
2712 self.bits |= 1 << OFFSET;
2713 } else {
2714 self.bits &= !(1 << OFFSET);
2715 }
2716 self
2717 }
2718 # [ doc = "Bit 8 - Port x Reset bit y" ]
2719 pub fn br8(&mut self, value: bool) -> &mut Self {
2720 const OFFSET: u8 = 8u8;
2721 if value {
2722 self.bits |= 1 << OFFSET;
2723 } else {
2724 self.bits &= !(1 << OFFSET);
2725 }
2726 self
2727 }
2728 # [ doc = "Bit 9 - Port x Reset bit y" ]
2729 pub fn br9(&mut self, value: bool) -> &mut Self {
2730 const OFFSET: u8 = 9u8;
2731 if value {
2732 self.bits |= 1 << OFFSET;
2733 } else {
2734 self.bits &= !(1 << OFFSET);
2735 }
2736 self
2737 }
2738 # [ doc = "Bit 10 - Port x Reset bit y" ]
2739 pub fn br10(&mut self, value: bool) -> &mut Self {
2740 const OFFSET: u8 = 10u8;
2741 if value {
2742 self.bits |= 1 << OFFSET;
2743 } else {
2744 self.bits &= !(1 << OFFSET);
2745 }
2746 self
2747 }
2748 # [ doc = "Bit 11 - Port x Reset bit y" ]
2749 pub fn br11(&mut self, value: bool) -> &mut Self {
2750 const OFFSET: u8 = 11u8;
2751 if value {
2752 self.bits |= 1 << OFFSET;
2753 } else {
2754 self.bits &= !(1 << OFFSET);
2755 }
2756 self
2757 }
2758 # [ doc = "Bit 12 - Port x Reset bit y" ]
2759 pub fn br12(&mut self, value: bool) -> &mut Self {
2760 const OFFSET: u8 = 12u8;
2761 if value {
2762 self.bits |= 1 << OFFSET;
2763 } else {
2764 self.bits &= !(1 << OFFSET);
2765 }
2766 self
2767 }
2768 # [ doc = "Bit 13 - Port x Reset bit y" ]
2769 pub fn br13(&mut self, value: bool) -> &mut Self {
2770 const OFFSET: u8 = 13u8;
2771 if value {
2772 self.bits |= 1 << OFFSET;
2773 } else {
2774 self.bits &= !(1 << OFFSET);
2775 }
2776 self
2777 }
2778 # [ doc = "Bit 14 - Port x Reset bit y" ]
2779 pub fn br14(&mut self, value: bool) -> &mut Self {
2780 const OFFSET: u8 = 14u8;
2781 if value {
2782 self.bits |= 1 << OFFSET;
2783 } else {
2784 self.bits &= !(1 << OFFSET);
2785 }
2786 self
2787 }
2788 # [ doc = "Bit 15 - Port x Reset bit y" ]
2789 pub fn br15(&mut self, value: bool) -> &mut Self {
2790 const OFFSET: u8 = 15u8;
2791 if value {
2792 self.bits |= 1 << OFFSET;
2793 } else {
2794 self.bits &= !(1 << OFFSET);
2795 }
2796 self
2797 }
2798}