1# ! [ doc = "General-purpose I/Os" ]
2# [ doc = r" Register block" ]
3# [ repr ( C ) ]
4pub struct Gpio {
5 # [ doc = "0x00 - GPIO port mode register" ]
6 pub moder: Moder,
7 # [ doc = "0x04 - GPIO port output type register" ]
8 pub otyper: Otyper,
9 # [ doc = "0x08 - GPIO port output speed register" ]
10 pub ospeedr: Ospeedr,
11 # [ doc = "0x0c - GPIO port pull-up/pull-down register" ]
12 pub pupdr: Pupdr,
13 # [ doc = "0x10 - GPIO port input data register" ]
14 pub idr: Idr,
15 # [ doc = "0x14 - GPIO port output data register" ]
16 pub odr: Odr,
17 # [ doc = "0x18 - GPIO port bit set/reset register" ]
18 pub bsrr: Bsrr,
19 # [ doc = "0x1c - GPIO port configuration lock register" ]
20 pub lckr: Lckr,
21 # [ doc = "0x20 - GPIO alternate function low register" ]
22 pub afrl: Afrl,
23 # [ doc = "0x24 - GPIO alternate function high register" ]
24 pub afrh: Afrh,
25 # [ doc = "0x28 - Port bit reset register" ]
26 pub brr: Brr,
27}
28
29# [ doc = "GPIO port mode register" ]
30# [ repr ( C ) ]
31pub struct Moder {
32 register: ::volatile_register::RW<u32>,
33}
34
35# [ doc = "GPIO port mode register" ]
36pub mod moder {
37 # [ doc = r" Value read from the register" ]
38 pub struct R {
39 bits: u32,
40 }
41 # [ doc = r" Value to write to the register" ]
42 pub struct W {
43 bits: u32,
44 }
45 impl super::Moder {
46 # [ doc = r" Modifies the contents of the register" ]
47 pub fn modify<F>(&mut self, f: F)
48 where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W
49 {
50 let bits = self.register.read();
51 let r = R { bits: bits };
52 let mut w = W { bits: bits };
53 f(&r, &mut w);
54 self.register.write(w.bits);
55 }
56 # [ doc = r" Reads the contents of the register" ]
57 pub fn read(&self) -> R {
58 R { bits: self.register.read() }
59 }
60 # [ doc = r" Writes to the register" ]
61 pub fn write<F>(&mut self, f: F)
62 where F: FnOnce(&mut W) -> &mut W
63 {
64 let mut w = W::reset_value();
65 f(&mut w);
66 self.register.write(w.bits);
67 }
68 }
69 # [ doc = "Value of the field MODER15" ]
70 pub struct Moder15R {
71 bits: u8,
72 }
73 impl Moder15R {
74 # [ doc = r" Value of the field as raw bits" ]
75 pub fn bits(&self) -> u8 {
76 self.bits
77 }
78 }
79 # [ doc = "Value of the field MODER14" ]
80 pub struct Moder14R {
81 bits: u8,
82 }
83 impl Moder14R {
84 # [ doc = r" Value of the field as raw bits" ]
85 pub fn bits(&self) -> u8 {
86 self.bits
87 }
88 }
89 # [ doc = "Value of the field MODER13" ]
90 pub struct Moder13R {
91 bits: u8,
92 }
93 impl Moder13R {
94 # [ doc = r" Value of the field as raw bits" ]
95 pub fn bits(&self) -> u8 {
96 self.bits
97 }
98 }
99 # [ doc = "Value of the field MODER12" ]
100 pub struct Moder12R {
101 bits: u8,
102 }
103 impl Moder12R {
104 # [ doc = r" Value of the field as raw bits" ]
105 pub fn bits(&self) -> u8 {
106 self.bits
107 }
108 }
109 # [ doc = "Value of the field MODER11" ]
110 pub struct Moder11R {
111 bits: u8,
112 }
113 impl Moder11R {
114 # [ doc = r" Value of the field as raw bits" ]
115 pub fn bits(&self) -> u8 {
116 self.bits
117 }
118 }
119 # [ doc = "Value of the field MODER10" ]
120 pub struct Moder10R {
121 bits: u8,
122 }
123 impl Moder10R {
124 # [ doc = r" Value of the field as raw bits" ]
125 pub fn bits(&self) -> u8 {
126 self.bits
127 }
128 }
129 # [ doc = "Value of the field MODER9" ]
130 pub struct Moder9R {
131 bits: u8,
132 }
133 impl Moder9R {
134 # [ doc = r" Value of the field as raw bits" ]
135 pub fn bits(&self) -> u8 {
136 self.bits
137 }
138 }
139 # [ doc = "Value of the field MODER8" ]
140 pub struct Moder8R {
141 bits: u8,
142 }
143 impl Moder8R {
144 # [ doc = r" Value of the field as raw bits" ]
145 pub fn bits(&self) -> u8 {
146 self.bits
147 }
148 }
149 # [ doc = "Value of the field MODER7" ]
150 pub struct Moder7R {
151 bits: u8,
152 }
153 impl Moder7R {
154 # [ doc = r" Value of the field as raw bits" ]
155 pub fn bits(&self) -> u8 {
156 self.bits
157 }
158 }
159 # [ doc = "Value of the field MODER6" ]
160 pub struct Moder6R {
161 bits: u8,
162 }
163 impl Moder6R {
164 # [ doc = r" Value of the field as raw bits" ]
165 pub fn bits(&self) -> u8 {
166 self.bits
167 }
168 }
169 # [ doc = "Value of the field MODER5" ]
170 pub struct Moder5R {
171 bits: u8,
172 }
173 impl Moder5R {
174 # [ doc = r" Value of the field as raw bits" ]
175 pub fn bits(&self) -> u8 {
176 self.bits
177 }
178 }
179 # [ doc = "Value of the field MODER4" ]
180 pub struct Moder4R {
181 bits: u8,
182 }
183 impl Moder4R {
184 # [ doc = r" Value of the field as raw bits" ]
185 pub fn bits(&self) -> u8 {
186 self.bits
187 }
188 }
189 # [ doc = "Value of the field MODER3" ]
190 pub struct Moder3R {
191 bits: u8,
192 }
193 impl Moder3R {
194 # [ doc = r" Value of the field as raw bits" ]
195 pub fn bits(&self) -> u8 {
196 self.bits
197 }
198 }
199 # [ doc = "Value of the field MODER2" ]
200 pub struct Moder2R {
201 bits: u8,
202 }
203 impl Moder2R {
204 # [ doc = r" Value of the field as raw bits" ]
205 pub fn bits(&self) -> u8 {
206 self.bits
207 }
208 }
209 # [ doc = "Value of the field MODER1" ]
210 pub struct Moder1R {
211 bits: u8,
212 }
213 impl Moder1R {
214 # [ doc = r" Value of the field as raw bits" ]
215 pub fn bits(&self) -> u8 {
216 self.bits
217 }
218 }
219 # [ doc = "Value of the field MODER0" ]
220 pub struct Moder0R {
221 bits: u8,
222 }
223 impl Moder0R {
224 # [ doc = r" Value of the field as raw bits" ]
225 pub fn bits(&self) -> u8 {
226 self.bits
227 }
228 }
229 # [ doc = r" Proxy" ]
230 pub struct _Moder15W<'a> {
231 register: &'a mut W,
232 }
233 impl<'a> _Moder15W<'a> {
234 # [ doc = r" Writes raw `bits` to the field" ]
235 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
236 const MASK: u8 = 3;
237 const OFFSET: u8 = 30;
238 self.register.bits &= !((MASK as u32) << OFFSET);
239 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
240 self.register
241 }
242 }
243 # [ doc = r" Proxy" ]
244 pub struct _Moder14W<'a> {
245 register: &'a mut W,
246 }
247 impl<'a> _Moder14W<'a> {
248 # [ doc = r" Writes raw `bits` to the field" ]
249 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
250 const MASK: u8 = 3;
251 const OFFSET: u8 = 28;
252 self.register.bits &= !((MASK as u32) << OFFSET);
253 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
254 self.register
255 }
256 }
257 # [ doc = r" Proxy" ]
258 pub struct _Moder13W<'a> {
259 register: &'a mut W,
260 }
261 impl<'a> _Moder13W<'a> {
262 # [ doc = r" Writes raw `bits` to the field" ]
263 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
264 const MASK: u8 = 3;
265 const OFFSET: u8 = 26;
266 self.register.bits &= !((MASK as u32) << OFFSET);
267 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
268 self.register
269 }
270 }
271 # [ doc = r" Proxy" ]
272 pub struct _Moder12W<'a> {
273 register: &'a mut W,
274 }
275 impl<'a> _Moder12W<'a> {
276 # [ doc = r" Writes raw `bits` to the field" ]
277 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
278 const MASK: u8 = 3;
279 const OFFSET: u8 = 24;
280 self.register.bits &= !((MASK as u32) << OFFSET);
281 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
282 self.register
283 }
284 }
285 # [ doc = r" Proxy" ]
286 pub struct _Moder11W<'a> {
287 register: &'a mut W,
288 }
289 impl<'a> _Moder11W<'a> {
290 # [ doc = r" Writes raw `bits` to the field" ]
291 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
292 const MASK: u8 = 3;
293 const OFFSET: u8 = 22;
294 self.register.bits &= !((MASK as u32) << OFFSET);
295 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
296 self.register
297 }
298 }
299 # [ doc = r" Proxy" ]
300 pub struct _Moder10W<'a> {
301 register: &'a mut W,
302 }
303 impl<'a> _Moder10W<'a> {
304 # [ doc = r" Writes raw `bits` to the field" ]
305 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
306 const MASK: u8 = 3;
307 const OFFSET: u8 = 20;
308 self.register.bits &= !((MASK as u32) << OFFSET);
309 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
310 self.register
311 }
312 }
313 # [ doc = r" Proxy" ]
314 pub struct _Moder9W<'a> {
315 register: &'a mut W,
316 }
317 impl<'a> _Moder9W<'a> {
318 # [ doc = r" Writes raw `bits` to the field" ]
319 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
320 const MASK: u8 = 3;
321 const OFFSET: u8 = 18;
322 self.register.bits &= !((MASK as u32) << OFFSET);
323 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
324 self.register
325 }
326 }
327 # [ doc = r" Proxy" ]
328 pub struct _Moder8W<'a> {
329 register: &'a mut W,
330 }
331 impl<'a> _Moder8W<'a> {
332 # [ doc = r" Writes raw `bits` to the field" ]
333 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
334 const MASK: u8 = 3;
335 const OFFSET: u8 = 16;
336 self.register.bits &= !((MASK as u32) << OFFSET);
337 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
338 self.register
339 }
340 }
341 # [ doc = r" Proxy" ]
342 pub struct _Moder7W<'a> {
343 register: &'a mut W,
344 }
345 impl<'a> _Moder7W<'a> {
346 # [ doc = r" Writes raw `bits` to the field" ]
347 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
348 const MASK: u8 = 3;
349 const OFFSET: u8 = 14;
350 self.register.bits &= !((MASK as u32) << OFFSET);
351 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
352 self.register
353 }
354 }
355 # [ doc = r" Proxy" ]
356 pub struct _Moder6W<'a> {
357 register: &'a mut W,
358 }
359 impl<'a> _Moder6W<'a> {
360 # [ doc = r" Writes raw `bits` to the field" ]
361 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
362 const MASK: u8 = 3;
363 const OFFSET: u8 = 12;
364 self.register.bits &= !((MASK as u32) << OFFSET);
365 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
366 self.register
367 }
368 }
369 # [ doc = r" Proxy" ]
370 pub struct _Moder5W<'a> {
371 register: &'a mut W,
372 }
373 impl<'a> _Moder5W<'a> {
374 # [ doc = r" Writes raw `bits` to the field" ]
375 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
376 const MASK: u8 = 3;
377 const OFFSET: u8 = 10;
378 self.register.bits &= !((MASK as u32) << OFFSET);
379 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
380 self.register
381 }
382 }
383 # [ doc = r" Proxy" ]
384 pub struct _Moder4W<'a> {
385 register: &'a mut W,
386 }
387 impl<'a> _Moder4W<'a> {
388 # [ doc = r" Writes raw `bits` to the field" ]
389 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
390 const MASK: u8 = 3;
391 const OFFSET: u8 = 8;
392 self.register.bits &= !((MASK as u32) << OFFSET);
393 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
394 self.register
395 }
396 }
397 # [ doc = r" Proxy" ]
398 pub struct _Moder3W<'a> {
399 register: &'a mut W,
400 }
401 impl<'a> _Moder3W<'a> {
402 # [ doc = r" Writes raw `bits` to the field" ]
403 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
404 const MASK: u8 = 3;
405 const OFFSET: u8 = 6;
406 self.register.bits &= !((MASK as u32) << OFFSET);
407 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
408 self.register
409 }
410 }
411 # [ doc = r" Proxy" ]
412 pub struct _Moder2W<'a> {
413 register: &'a mut W,
414 }
415 impl<'a> _Moder2W<'a> {
416 # [ doc = r" Writes raw `bits` to the field" ]
417 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
418 const MASK: u8 = 3;
419 const OFFSET: u8 = 4;
420 self.register.bits &= !((MASK as u32) << OFFSET);
421 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
422 self.register
423 }
424 }
425 # [ doc = r" Proxy" ]
426 pub struct _Moder1W<'a> {
427 register: &'a mut W,
428 }
429 impl<'a> _Moder1W<'a> {
430 # [ doc = r" Writes raw `bits` to the field" ]
431 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
432 const MASK: u8 = 3;
433 const OFFSET: u8 = 2;
434 self.register.bits &= !((MASK as u32) << OFFSET);
435 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
436 self.register
437 }
438 }
439 # [ doc = r" Proxy" ]
440 pub struct _Moder0W<'a> {
441 register: &'a mut W,
442 }
443 impl<'a> _Moder0W<'a> {
444 # [ doc = r" Writes raw `bits` to the field" ]
445 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
446 const MASK: u8 = 3;
447 const OFFSET: u8 = 0;
448 self.register.bits &= !((MASK as u32) << OFFSET);
449 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
450 self.register
451 }
452 }
453 impl R {
454 # [ doc = r" Value of the register as raw bits" ]
455 pub fn bits(&self) -> u32 {
456 self.bits
457 }
458 fn _moder15(&self) -> u8 {
459 const MASK: u8 = 3;
460 const OFFSET: u8 = 30;
461 ((self.bits >> OFFSET) & MASK as u32) as u8
462 }
463 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
464 pub fn moder15(&self) -> Moder15R {
465 Moder15R { bits: self._moder15() }
466 }
467 fn _moder14(&self) -> u8 {
468 const MASK: u8 = 3;
469 const OFFSET: u8 = 28;
470 ((self.bits >> OFFSET) & MASK as u32) as u8
471 }
472 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
473 pub fn moder14(&self) -> Moder14R {
474 Moder14R { bits: self._moder14() }
475 }
476 fn _moder13(&self) -> u8 {
477 const MASK: u8 = 3;
478 const OFFSET: u8 = 26;
479 ((self.bits >> OFFSET) & MASK as u32) as u8
480 }
481 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
482 pub fn moder13(&self) -> Moder13R {
483 Moder13R { bits: self._moder13() }
484 }
485 fn _moder12(&self) -> u8 {
486 const MASK: u8 = 3;
487 const OFFSET: u8 = 24;
488 ((self.bits >> OFFSET) & MASK as u32) as u8
489 }
490 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
491 pub fn moder12(&self) -> Moder12R {
492 Moder12R { bits: self._moder12() }
493 }
494 fn _moder11(&self) -> u8 {
495 const MASK: u8 = 3;
496 const OFFSET: u8 = 22;
497 ((self.bits >> OFFSET) & MASK as u32) as u8
498 }
499 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
500 pub fn moder11(&self) -> Moder11R {
501 Moder11R { bits: self._moder11() }
502 }
503 fn _moder10(&self) -> u8 {
504 const MASK: u8 = 3;
505 const OFFSET: u8 = 20;
506 ((self.bits >> OFFSET) & MASK as u32) as u8
507 }
508 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
509 pub fn moder10(&self) -> Moder10R {
510 Moder10R { bits: self._moder10() }
511 }
512 fn _moder9(&self) -> u8 {
513 const MASK: u8 = 3;
514 const OFFSET: u8 = 18;
515 ((self.bits >> OFFSET) & MASK as u32) as u8
516 }
517 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
518 pub fn moder9(&self) -> Moder9R {
519 Moder9R { bits: self._moder9() }
520 }
521 fn _moder8(&self) -> u8 {
522 const MASK: u8 = 3;
523 const OFFSET: u8 = 16;
524 ((self.bits >> OFFSET) & MASK as u32) as u8
525 }
526 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
527 pub fn moder8(&self) -> Moder8R {
528 Moder8R { bits: self._moder8() }
529 }
530 fn _moder7(&self) -> u8 {
531 const MASK: u8 = 3;
532 const OFFSET: u8 = 14;
533 ((self.bits >> OFFSET) & MASK as u32) as u8
534 }
535 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
536 pub fn moder7(&self) -> Moder7R {
537 Moder7R { bits: self._moder7() }
538 }
539 fn _moder6(&self) -> u8 {
540 const MASK: u8 = 3;
541 const OFFSET: u8 = 12;
542 ((self.bits >> OFFSET) & MASK as u32) as u8
543 }
544 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
545 pub fn moder6(&self) -> Moder6R {
546 Moder6R { bits: self._moder6() }
547 }
548 fn _moder5(&self) -> u8 {
549 const MASK: u8 = 3;
550 const OFFSET: u8 = 10;
551 ((self.bits >> OFFSET) & MASK as u32) as u8
552 }
553 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
554 pub fn moder5(&self) -> Moder5R {
555 Moder5R { bits: self._moder5() }
556 }
557 fn _moder4(&self) -> u8 {
558 const MASK: u8 = 3;
559 const OFFSET: u8 = 8;
560 ((self.bits >> OFFSET) & MASK as u32) as u8
561 }
562 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
563 pub fn moder4(&self) -> Moder4R {
564 Moder4R { bits: self._moder4() }
565 }
566 fn _moder3(&self) -> u8 {
567 const MASK: u8 = 3;
568 const OFFSET: u8 = 6;
569 ((self.bits >> OFFSET) & MASK as u32) as u8
570 }
571 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
572 pub fn moder3(&self) -> Moder3R {
573 Moder3R { bits: self._moder3() }
574 }
575 fn _moder2(&self) -> u8 {
576 const MASK: u8 = 3;
577 const OFFSET: u8 = 4;
578 ((self.bits >> OFFSET) & MASK as u32) as u8
579 }
580 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
581 pub fn moder2(&self) -> Moder2R {
582 Moder2R { bits: self._moder2() }
583 }
584 fn _moder1(&self) -> u8 {
585 const MASK: u8 = 3;
586 const OFFSET: u8 = 2;
587 ((self.bits >> OFFSET) & MASK as u32) as u8
588 }
589 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
590 pub fn moder1(&self) -> Moder1R {
591 Moder1R { bits: self._moder1() }
592 }
593 fn _moder0(&self) -> u8 {
594 const MASK: u8 = 3;
595 const OFFSET: u8 = 0;
596 ((self.bits >> OFFSET) & MASK as u32) as u8
597 }
598 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
599 pub fn moder0(&self) -> Moder0R {
600 Moder0R { bits: self._moder0() }
601 }
602 }
603 impl W {
604 # [ doc = r" Reset value of the register" ]
605 pub fn reset_value() -> W {
606 W { bits: 671088640 }
607 }
608 # [ doc = r" Writes raw `bits` to the register" ]
609 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
610 self.bits = bits;
611 self
612 }
613 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
614 pub fn moder15(&mut self) -> _Moder15W {
615 _Moder15W { register: self }
616 }
617 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
618 pub fn moder14(&mut self) -> _Moder14W {
619 _Moder14W { register: self }
620 }
621 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
622 pub fn moder13(&mut self) -> _Moder13W {
623 _Moder13W { register: self }
624 }
625 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
626 pub fn moder12(&mut self) -> _Moder12W {
627 _Moder12W { register: self }
628 }
629 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
630 pub fn moder11(&mut self) -> _Moder11W {
631 _Moder11W { register: self }
632 }
633 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
634 pub fn moder10(&mut self) -> _Moder10W {
635 _Moder10W { register: self }
636 }
637 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
638 pub fn moder9(&mut self) -> _Moder9W {
639 _Moder9W { register: self }
640 }
641 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
642 pub fn moder8(&mut self) -> _Moder8W {
643 _Moder8W { register: self }
644 }
645 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
646 pub fn moder7(&mut self) -> _Moder7W {
647 _Moder7W { register: self }
648 }
649 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
650 pub fn moder6(&mut self) -> _Moder6W {
651 _Moder6W { register: self }
652 }
653 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
654 pub fn moder5(&mut self) -> _Moder5W {
655 _Moder5W { register: self }
656 }
657 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
658 pub fn moder4(&mut self) -> _Moder4W {
659 _Moder4W { register: self }
660 }
661 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
662 pub fn moder3(&mut self) -> _Moder3W {
663 _Moder3W { register: self }
664 }
665 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
666 pub fn moder2(&mut self) -> _Moder2W {
667 _Moder2W { register: self }
668 }
669 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
670 pub fn moder1(&mut self) -> _Moder1W {
671 _Moder1W { register: self }
672 }
673 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
674 pub fn moder0(&mut self) -> _Moder0W {
675 _Moder0W { register: self }
676 }
677 }
678}
679
680# [ doc = "GPIO port output type register" ]
681# [ repr ( C ) ]
682pub struct Otyper {
683 register: ::volatile_register::RW<u32>,
684}
685
686# [ doc = "GPIO port output type register" ]
687pub mod otyper {
688 # [ doc = r" Value read from the register" ]
689 pub struct R {
690 bits: u32,
691 }
692 # [ doc = r" Value to write to the register" ]
693 pub struct W {
694 bits: u32,
695 }
696 impl super::Otyper {
697 # [ doc = r" Modifies the contents of the register" ]
698 pub fn modify<F>(&mut self, f: F)
699 where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W
700 {
701 let bits = self.register.read();
702 let r = R { bits: bits };
703 let mut w = W { bits: bits };
704 f(&r, &mut w);
705 self.register.write(w.bits);
706 }
707 # [ doc = r" Reads the contents of the register" ]
708 pub fn read(&self) -> R {
709 R { bits: self.register.read() }
710 }
711 # [ doc = r" Writes to the register" ]
712 pub fn write<F>(&mut self, f: F)
713 where F: FnOnce(&mut W) -> &mut W
714 {
715 let mut w = W::reset_value();
716 f(&mut w);
717 self.register.write(w.bits);
718 }
719 }
720 # [ doc = "Value of the field OT15" ]
721 pub struct Ot15R {
722 bits: u8,
723 }
724 impl Ot15R {
725 # [ doc = r" Value of the field as raw bits" ]
726 pub fn bits(&self) -> u8 {
727 self.bits
728 }
729 }
730 # [ doc = "Value of the field OT14" ]
731 pub struct Ot14R {
732 bits: u8,
733 }
734 impl Ot14R {
735 # [ doc = r" Value of the field as raw bits" ]
736 pub fn bits(&self) -> u8 {
737 self.bits
738 }
739 }
740 # [ doc = "Value of the field OT13" ]
741 pub struct Ot13R {
742 bits: u8,
743 }
744 impl Ot13R {
745 # [ doc = r" Value of the field as raw bits" ]
746 pub fn bits(&self) -> u8 {
747 self.bits
748 }
749 }
750 # [ doc = "Value of the field OT12" ]
751 pub struct Ot12R {
752 bits: u8,
753 }
754 impl Ot12R {
755 # [ doc = r" Value of the field as raw bits" ]
756 pub fn bits(&self) -> u8 {
757 self.bits
758 }
759 }
760 # [ doc = "Value of the field OT11" ]
761 pub struct Ot11R {
762 bits: u8,
763 }
764 impl Ot11R {
765 # [ doc = r" Value of the field as raw bits" ]
766 pub fn bits(&self) -> u8 {
767 self.bits
768 }
769 }
770 # [ doc = "Value of the field OT10" ]
771 pub struct Ot10R {
772 bits: u8,
773 }
774 impl Ot10R {
775 # [ doc = r" Value of the field as raw bits" ]
776 pub fn bits(&self) -> u8 {
777 self.bits
778 }
779 }
780 # [ doc = "Value of the field OT9" ]
781 pub struct Ot9R {
782 bits: u8,
783 }
784 impl Ot9R {
785 # [ doc = r" Value of the field as raw bits" ]
786 pub fn bits(&self) -> u8 {
787 self.bits
788 }
789 }
790 # [ doc = "Value of the field OT8" ]
791 pub struct Ot8R {
792 bits: u8,
793 }
794 impl Ot8R {
795 # [ doc = r" Value of the field as raw bits" ]
796 pub fn bits(&self) -> u8 {
797 self.bits
798 }
799 }
800 # [ doc = "Value of the field OT7" ]
801 pub struct Ot7R {
802 bits: u8,
803 }
804 impl Ot7R {
805 # [ doc = r" Value of the field as raw bits" ]
806 pub fn bits(&self) -> u8 {
807 self.bits
808 }
809 }
810 # [ doc = "Value of the field OT6" ]
811 pub struct Ot6R {
812 bits: u8,
813 }
814 impl Ot6R {
815 # [ doc = r" Value of the field as raw bits" ]
816 pub fn bits(&self) -> u8 {
817 self.bits
818 }
819 }
820 # [ doc = "Value of the field OT5" ]
821 pub struct Ot5R {
822 bits: u8,
823 }
824 impl Ot5R {
825 # [ doc = r" Value of the field as raw bits" ]
826 pub fn bits(&self) -> u8 {
827 self.bits
828 }
829 }
830 # [ doc = "Value of the field OT4" ]
831 pub struct Ot4R {
832 bits: u8,
833 }
834 impl Ot4R {
835 # [ doc = r" Value of the field as raw bits" ]
836 pub fn bits(&self) -> u8 {
837 self.bits
838 }
839 }
840 # [ doc = "Value of the field OT3" ]
841 pub struct Ot3R {
842 bits: u8,
843 }
844 impl Ot3R {
845 # [ doc = r" Value of the field as raw bits" ]
846 pub fn bits(&self) -> u8 {
847 self.bits
848 }
849 }
850 # [ doc = "Value of the field OT2" ]
851 pub struct Ot2R {
852 bits: u8,
853 }
854 impl Ot2R {
855 # [ doc = r" Value of the field as raw bits" ]
856 pub fn bits(&self) -> u8 {
857 self.bits
858 }
859 }
860 # [ doc = "Value of the field OT1" ]
861 pub struct Ot1R {
862 bits: u8,
863 }
864 impl Ot1R {
865 # [ doc = r" Value of the field as raw bits" ]
866 pub fn bits(&self) -> u8 {
867 self.bits
868 }
869 }
870 # [ doc = "Value of the field OT0" ]
871 pub struct Ot0R {
872 bits: u8,
873 }
874 impl Ot0R {
875 # [ doc = r" Value of the field as raw bits" ]
876 pub fn bits(&self) -> u8 {
877 self.bits
878 }
879 }
880 # [ doc = r" Proxy" ]
881 pub struct _Ot15W<'a> {
882 register: &'a mut W,
883 }
884 impl<'a> _Ot15W<'a> {
885 # [ doc = r" Writes raw `bits` to the field" ]
886 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
887 const MASK: u8 = 1;
888 const OFFSET: u8 = 15;
889 self.register.bits &= !((MASK as u32) << OFFSET);
890 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
891 self.register
892 }
893 }
894 # [ doc = r" Proxy" ]
895 pub struct _Ot14W<'a> {
896 register: &'a mut W,
897 }
898 impl<'a> _Ot14W<'a> {
899 # [ doc = r" Writes raw `bits` to the field" ]
900 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
901 const MASK: u8 = 1;
902 const OFFSET: u8 = 14;
903 self.register.bits &= !((MASK as u32) << OFFSET);
904 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
905 self.register
906 }
907 }
908 # [ doc = r" Proxy" ]
909 pub struct _Ot13W<'a> {
910 register: &'a mut W,
911 }
912 impl<'a> _Ot13W<'a> {
913 # [ doc = r" Writes raw `bits` to the field" ]
914 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
915 const MASK: u8 = 1;
916 const OFFSET: u8 = 13;
917 self.register.bits &= !((MASK as u32) << OFFSET);
918 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
919 self.register
920 }
921 }
922 # [ doc = r" Proxy" ]
923 pub struct _Ot12W<'a> {
924 register: &'a mut W,
925 }
926 impl<'a> _Ot12W<'a> {
927 # [ doc = r" Writes raw `bits` to the field" ]
928 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
929 const MASK: u8 = 1;
930 const OFFSET: u8 = 12;
931 self.register.bits &= !((MASK as u32) << OFFSET);
932 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
933 self.register
934 }
935 }
936 # [ doc = r" Proxy" ]
937 pub struct _Ot11W<'a> {
938 register: &'a mut W,
939 }
940 impl<'a> _Ot11W<'a> {
941 # [ doc = r" Writes raw `bits` to the field" ]
942 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
943 const MASK: u8 = 1;
944 const OFFSET: u8 = 11;
945 self.register.bits &= !((MASK as u32) << OFFSET);
946 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
947 self.register
948 }
949 }
950 # [ doc = r" Proxy" ]
951 pub struct _Ot10W<'a> {
952 register: &'a mut W,
953 }
954 impl<'a> _Ot10W<'a> {
955 # [ doc = r" Writes raw `bits` to the field" ]
956 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
957 const MASK: u8 = 1;
958 const OFFSET: u8 = 10;
959 self.register.bits &= !((MASK as u32) << OFFSET);
960 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
961 self.register
962 }
963 }
964 # [ doc = r" Proxy" ]
965 pub struct _Ot9W<'a> {
966 register: &'a mut W,
967 }
968 impl<'a> _Ot9W<'a> {
969 # [ doc = r" Writes raw `bits` to the field" ]
970 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
971 const MASK: u8 = 1;
972 const OFFSET: u8 = 9;
973 self.register.bits &= !((MASK as u32) << OFFSET);
974 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
975 self.register
976 }
977 }
978 # [ doc = r" Proxy" ]
979 pub struct _Ot8W<'a> {
980 register: &'a mut W,
981 }
982 impl<'a> _Ot8W<'a> {
983 # [ doc = r" Writes raw `bits` to the field" ]
984 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
985 const MASK: u8 = 1;
986 const OFFSET: u8 = 8;
987 self.register.bits &= !((MASK as u32) << OFFSET);
988 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
989 self.register
990 }
991 }
992 # [ doc = r" Proxy" ]
993 pub struct _Ot7W<'a> {
994 register: &'a mut W,
995 }
996 impl<'a> _Ot7W<'a> {
997 # [ doc = r" Writes raw `bits` to the field" ]
998 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
999 const MASK: u8 = 1;
1000 const OFFSET: u8 = 7;
1001 self.register.bits &= !((MASK as u32) << OFFSET);
1002 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1003 self.register
1004 }
1005 }
1006 # [ doc = r" Proxy" ]
1007 pub struct _Ot6W<'a> {
1008 register: &'a mut W,
1009 }
1010 impl<'a> _Ot6W<'a> {
1011 # [ doc = r" Writes raw `bits` to the field" ]
1012 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1013 const MASK: u8 = 1;
1014 const OFFSET: u8 = 6;
1015 self.register.bits &= !((MASK as u32) << OFFSET);
1016 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1017 self.register
1018 }
1019 }
1020 # [ doc = r" Proxy" ]
1021 pub struct _Ot5W<'a> {
1022 register: &'a mut W,
1023 }
1024 impl<'a> _Ot5W<'a> {
1025 # [ doc = r" Writes raw `bits` to the field" ]
1026 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1027 const MASK: u8 = 1;
1028 const OFFSET: u8 = 5;
1029 self.register.bits &= !((MASK as u32) << OFFSET);
1030 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1031 self.register
1032 }
1033 }
1034 # [ doc = r" Proxy" ]
1035 pub struct _Ot4W<'a> {
1036 register: &'a mut W,
1037 }
1038 impl<'a> _Ot4W<'a> {
1039 # [ doc = r" Writes raw `bits` to the field" ]
1040 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1041 const MASK: u8 = 1;
1042 const OFFSET: u8 = 4;
1043 self.register.bits &= !((MASK as u32) << OFFSET);
1044 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1045 self.register
1046 }
1047 }
1048 # [ doc = r" Proxy" ]
1049 pub struct _Ot3W<'a> {
1050 register: &'a mut W,
1051 }
1052 impl<'a> _Ot3W<'a> {
1053 # [ doc = r" Writes raw `bits` to the field" ]
1054 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1055 const MASK: u8 = 1;
1056 const OFFSET: u8 = 3;
1057 self.register.bits &= !((MASK as u32) << OFFSET);
1058 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1059 self.register
1060 }
1061 }
1062 # [ doc = r" Proxy" ]
1063 pub struct _Ot2W<'a> {
1064 register: &'a mut W,
1065 }
1066 impl<'a> _Ot2W<'a> {
1067 # [ doc = r" Writes raw `bits` to the field" ]
1068 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1069 const MASK: u8 = 1;
1070 const OFFSET: u8 = 2;
1071 self.register.bits &= !((MASK as u32) << OFFSET);
1072 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1073 self.register
1074 }
1075 }
1076 # [ doc = r" Proxy" ]
1077 pub struct _Ot1W<'a> {
1078 register: &'a mut W,
1079 }
1080 impl<'a> _Ot1W<'a> {
1081 # [ doc = r" Writes raw `bits` to the field" ]
1082 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1083 const MASK: u8 = 1;
1084 const OFFSET: u8 = 1;
1085 self.register.bits &= !((MASK as u32) << OFFSET);
1086 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1087 self.register
1088 }
1089 }
1090 # [ doc = r" Proxy" ]
1091 pub struct _Ot0W<'a> {
1092 register: &'a mut W,
1093 }
1094 impl<'a> _Ot0W<'a> {
1095 # [ doc = r" Writes raw `bits` to the field" ]
1096 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1097 const MASK: u8 = 1;
1098 const OFFSET: u8 = 0;
1099 self.register.bits &= !((MASK as u32) << OFFSET);
1100 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1101 self.register
1102 }
1103 }
1104 impl R {
1105 # [ doc = r" Value of the register as raw bits" ]
1106 pub fn bits(&self) -> u32 {
1107 self.bits
1108 }
1109 fn _ot15(&self) -> u8 {
1110 const MASK: u8 = 1;
1111 const OFFSET: u8 = 15;
1112 ((self.bits >> OFFSET) & MASK as u32) as u8
1113 }
1114 # [ doc = "Bit 15 - Port x configuration bits (y = 0..15)" ]
1115 pub fn ot15(&self) -> Ot15R {
1116 Ot15R { bits: self._ot15() }
1117 }
1118 fn _ot14(&self) -> u8 {
1119 const MASK: u8 = 1;
1120 const OFFSET: u8 = 14;
1121 ((self.bits >> OFFSET) & MASK as u32) as u8
1122 }
1123 # [ doc = "Bit 14 - Port x configuration bits (y = 0..15)" ]
1124 pub fn ot14(&self) -> Ot14R {
1125 Ot14R { bits: self._ot14() }
1126 }
1127 fn _ot13(&self) -> u8 {
1128 const MASK: u8 = 1;
1129 const OFFSET: u8 = 13;
1130 ((self.bits >> OFFSET) & MASK as u32) as u8
1131 }
1132 # [ doc = "Bit 13 - Port x configuration bits (y = 0..15)" ]
1133 pub fn ot13(&self) -> Ot13R {
1134 Ot13R { bits: self._ot13() }
1135 }
1136 fn _ot12(&self) -> u8 {
1137 const MASK: u8 = 1;
1138 const OFFSET: u8 = 12;
1139 ((self.bits >> OFFSET) & MASK as u32) as u8
1140 }
1141 # [ doc = "Bit 12 - Port x configuration bits (y = 0..15)" ]
1142 pub fn ot12(&self) -> Ot12R {
1143 Ot12R { bits: self._ot12() }
1144 }
1145 fn _ot11(&self) -> u8 {
1146 const MASK: u8 = 1;
1147 const OFFSET: u8 = 11;
1148 ((self.bits >> OFFSET) & MASK as u32) as u8
1149 }
1150 # [ doc = "Bit 11 - Port x configuration bits (y = 0..15)" ]
1151 pub fn ot11(&self) -> Ot11R {
1152 Ot11R { bits: self._ot11() }
1153 }
1154 fn _ot10(&self) -> u8 {
1155 const MASK: u8 = 1;
1156 const OFFSET: u8 = 10;
1157 ((self.bits >> OFFSET) & MASK as u32) as u8
1158 }
1159 # [ doc = "Bit 10 - Port x configuration bits (y = 0..15)" ]
1160 pub fn ot10(&self) -> Ot10R {
1161 Ot10R { bits: self._ot10() }
1162 }
1163 fn _ot9(&self) -> u8 {
1164 const MASK: u8 = 1;
1165 const OFFSET: u8 = 9;
1166 ((self.bits >> OFFSET) & MASK as u32) as u8
1167 }
1168 # [ doc = "Bit 9 - Port x configuration bits (y = 0..15)" ]
1169 pub fn ot9(&self) -> Ot9R {
1170 Ot9R { bits: self._ot9() }
1171 }
1172 fn _ot8(&self) -> u8 {
1173 const MASK: u8 = 1;
1174 const OFFSET: u8 = 8;
1175 ((self.bits >> OFFSET) & MASK as u32) as u8
1176 }
1177 # [ doc = "Bit 8 - Port x configuration bits (y = 0..15)" ]
1178 pub fn ot8(&self) -> Ot8R {
1179 Ot8R { bits: self._ot8() }
1180 }
1181 fn _ot7(&self) -> u8 {
1182 const MASK: u8 = 1;
1183 const OFFSET: u8 = 7;
1184 ((self.bits >> OFFSET) & MASK as u32) as u8
1185 }
1186 # [ doc = "Bit 7 - Port x configuration bits (y = 0..15)" ]
1187 pub fn ot7(&self) -> Ot7R {
1188 Ot7R { bits: self._ot7() }
1189 }
1190 fn _ot6(&self) -> u8 {
1191 const MASK: u8 = 1;
1192 const OFFSET: u8 = 6;
1193 ((self.bits >> OFFSET) & MASK as u32) as u8
1194 }
1195 # [ doc = "Bit 6 - Port x configuration bits (y = 0..15)" ]
1196 pub fn ot6(&self) -> Ot6R {
1197 Ot6R { bits: self._ot6() }
1198 }
1199 fn _ot5(&self) -> u8 {
1200 const MASK: u8 = 1;
1201 const OFFSET: u8 = 5;
1202 ((self.bits >> OFFSET) & MASK as u32) as u8
1203 }
1204 # [ doc = "Bit 5 - Port x configuration bits (y = 0..15)" ]
1205 pub fn ot5(&self) -> Ot5R {
1206 Ot5R { bits: self._ot5() }
1207 }
1208 fn _ot4(&self) -> u8 {
1209 const MASK: u8 = 1;
1210 const OFFSET: u8 = 4;
1211 ((self.bits >> OFFSET) & MASK as u32) as u8
1212 }
1213 # [ doc = "Bit 4 - Port x configuration bits (y = 0..15)" ]
1214 pub fn ot4(&self) -> Ot4R {
1215 Ot4R { bits: self._ot4() }
1216 }
1217 fn _ot3(&self) -> u8 {
1218 const MASK: u8 = 1;
1219 const OFFSET: u8 = 3;
1220 ((self.bits >> OFFSET) & MASK as u32) as u8
1221 }
1222 # [ doc = "Bit 3 - Port x configuration bits (y = 0..15)" ]
1223 pub fn ot3(&self) -> Ot3R {
1224 Ot3R { bits: self._ot3() }
1225 }
1226 fn _ot2(&self) -> u8 {
1227 const MASK: u8 = 1;
1228 const OFFSET: u8 = 2;
1229 ((self.bits >> OFFSET) & MASK as u32) as u8
1230 }
1231 # [ doc = "Bit 2 - Port x configuration bits (y = 0..15)" ]
1232 pub fn ot2(&self) -> Ot2R {
1233 Ot2R { bits: self._ot2() }
1234 }
1235 fn _ot1(&self) -> u8 {
1236 const MASK: u8 = 1;
1237 const OFFSET: u8 = 1;
1238 ((self.bits >> OFFSET) & MASK as u32) as u8
1239 }
1240 # [ doc = "Bit 1 - Port x configuration bits (y = 0..15)" ]
1241 pub fn ot1(&self) -> Ot1R {
1242 Ot1R { bits: self._ot1() }
1243 }
1244 fn _ot0(&self) -> u8 {
1245 const MASK: u8 = 1;
1246 const OFFSET: u8 = 0;
1247 ((self.bits >> OFFSET) & MASK as u32) as u8
1248 }
1249 # [ doc = "Bit 0 - Port x configuration bits (y = 0..15)" ]
1250 pub fn ot0(&self) -> Ot0R {
1251 Ot0R { bits: self._ot0() }
1252 }
1253 }
1254 impl W {
1255 # [ doc = r" Reset value of the register" ]
1256 pub fn reset_value() -> W {
1257 W { bits: 0 }
1258 }
1259 # [ doc = r" Writes raw `bits` to the register" ]
1260 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1261 self.bits = bits;
1262 self
1263 }
1264 # [ doc = "Bit 15 - Port x configuration bits (y = 0..15)" ]
1265 pub fn ot15(&mut self) -> _Ot15W {
1266 _Ot15W { register: self }
1267 }
1268 # [ doc = "Bit 14 - Port x configuration bits (y = 0..15)" ]
1269 pub fn ot14(&mut self) -> _Ot14W {
1270 _Ot14W { register: self }
1271 }
1272 # [ doc = "Bit 13 - Port x configuration bits (y = 0..15)" ]
1273 pub fn ot13(&mut self) -> _Ot13W {
1274 _Ot13W { register: self }
1275 }
1276 # [ doc = "Bit 12 - Port x configuration bits (y = 0..15)" ]
1277 pub fn ot12(&mut self) -> _Ot12W {
1278 _Ot12W { register: self }
1279 }
1280 # [ doc = "Bit 11 - Port x configuration bits (y = 0..15)" ]
1281 pub fn ot11(&mut self) -> _Ot11W {
1282 _Ot11W { register: self }
1283 }
1284 # [ doc = "Bit 10 - Port x configuration bits (y = 0..15)" ]
1285 pub fn ot10(&mut self) -> _Ot10W {
1286 _Ot10W { register: self }
1287 }
1288 # [ doc = "Bit 9 - Port x configuration bits (y = 0..15)" ]
1289 pub fn ot9(&mut self) -> _Ot9W {
1290 _Ot9W { register: self }
1291 }
1292 # [ doc = "Bit 8 - Port x configuration bits (y = 0..15)" ]
1293 pub fn ot8(&mut self) -> _Ot8W {
1294 _Ot8W { register: self }
1295 }
1296 # [ doc = "Bit 7 - Port x configuration bits (y = 0..15)" ]
1297 pub fn ot7(&mut self) -> _Ot7W {
1298 _Ot7W { register: self }
1299 }
1300 # [ doc = "Bit 6 - Port x configuration bits (y = 0..15)" ]
1301 pub fn ot6(&mut self) -> _Ot6W {
1302 _Ot6W { register: self }
1303 }
1304 # [ doc = "Bit 5 - Port x configuration bits (y = 0..15)" ]
1305 pub fn ot5(&mut self) -> _Ot5W {
1306 _Ot5W { register: self }
1307 }
1308 # [ doc = "Bit 4 - Port x configuration bits (y = 0..15)" ]
1309 pub fn ot4(&mut self) -> _Ot4W {
1310 _Ot4W { register: self }
1311 }
1312 # [ doc = "Bit 3 - Port x configuration bits (y = 0..15)" ]
1313 pub fn ot3(&mut self) -> _Ot3W {
1314 _Ot3W { register: self }
1315 }
1316 # [ doc = "Bit 2 - Port x configuration bits (y = 0..15)" ]
1317 pub fn ot2(&mut self) -> _Ot2W {
1318 _Ot2W { register: self }
1319 }
1320 # [ doc = "Bit 1 - Port x configuration bits (y = 0..15)" ]
1321 pub fn ot1(&mut self) -> _Ot1W {
1322 _Ot1W { register: self }
1323 }
1324 # [ doc = "Bit 0 - Port x configuration bits (y = 0..15)" ]
1325 pub fn ot0(&mut self) -> _Ot0W {
1326 _Ot0W { register: self }
1327 }
1328 }
1329}
1330
1331# [ doc = "GPIO port output speed register" ]
1332# [ repr ( C ) ]
1333pub struct Ospeedr {
1334 register: ::volatile_register::RW<u32>,
1335}
1336
1337# [ doc = "GPIO port output speed register" ]
1338pub mod ospeedr {
1339 # [ doc = r" Value read from the register" ]
1340 pub struct R {
1341 bits: u32,
1342 }
1343 # [ doc = r" Value to write to the register" ]
1344 pub struct W {
1345 bits: u32,
1346 }
1347 impl super::Ospeedr {
1348 # [ doc = r" Modifies the contents of the register" ]
1349 pub fn modify<F>(&mut self, f: F)
1350 where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W
1351 {
1352 let bits = self.register.read();
1353 let r = R { bits: bits };
1354 let mut w = W { bits: bits };
1355 f(&r, &mut w);
1356 self.register.write(w.bits);
1357 }
1358 # [ doc = r" Reads the contents of the register" ]
1359 pub fn read(&self) -> R {
1360 R { bits: self.register.read() }
1361 }
1362 # [ doc = r" Writes to the register" ]
1363 pub fn write<F>(&mut self, f: F)
1364 where F: FnOnce(&mut W) -> &mut W
1365 {
1366 let mut w = W::reset_value();
1367 f(&mut w);
1368 self.register.write(w.bits);
1369 }
1370 }
1371 # [ doc = "Value of the field OSPEEDR15" ]
1372 pub struct Ospeedr15R {
1373 bits: u8,
1374 }
1375 impl Ospeedr15R {
1376 # [ doc = r" Value of the field as raw bits" ]
1377 pub fn bits(&self) -> u8 {
1378 self.bits
1379 }
1380 }
1381 # [ doc = "Value of the field OSPEEDR14" ]
1382 pub struct Ospeedr14R {
1383 bits: u8,
1384 }
1385 impl Ospeedr14R {
1386 # [ doc = r" Value of the field as raw bits" ]
1387 pub fn bits(&self) -> u8 {
1388 self.bits
1389 }
1390 }
1391 # [ doc = "Value of the field OSPEEDR13" ]
1392 pub struct Ospeedr13R {
1393 bits: u8,
1394 }
1395 impl Ospeedr13R {
1396 # [ doc = r" Value of the field as raw bits" ]
1397 pub fn bits(&self) -> u8 {
1398 self.bits
1399 }
1400 }
1401 # [ doc = "Value of the field OSPEEDR12" ]
1402 pub struct Ospeedr12R {
1403 bits: u8,
1404 }
1405 impl Ospeedr12R {
1406 # [ doc = r" Value of the field as raw bits" ]
1407 pub fn bits(&self) -> u8 {
1408 self.bits
1409 }
1410 }
1411 # [ doc = "Value of the field OSPEEDR11" ]
1412 pub struct Ospeedr11R {
1413 bits: u8,
1414 }
1415 impl Ospeedr11R {
1416 # [ doc = r" Value of the field as raw bits" ]
1417 pub fn bits(&self) -> u8 {
1418 self.bits
1419 }
1420 }
1421 # [ doc = "Value of the field OSPEEDR10" ]
1422 pub struct Ospeedr10R {
1423 bits: u8,
1424 }
1425 impl Ospeedr10R {
1426 # [ doc = r" Value of the field as raw bits" ]
1427 pub fn bits(&self) -> u8 {
1428 self.bits
1429 }
1430 }
1431 # [ doc = "Value of the field OSPEEDR9" ]
1432 pub struct Ospeedr9R {
1433 bits: u8,
1434 }
1435 impl Ospeedr9R {
1436 # [ doc = r" Value of the field as raw bits" ]
1437 pub fn bits(&self) -> u8 {
1438 self.bits
1439 }
1440 }
1441 # [ doc = "Value of the field OSPEEDR8" ]
1442 pub struct Ospeedr8R {
1443 bits: u8,
1444 }
1445 impl Ospeedr8R {
1446 # [ doc = r" Value of the field as raw bits" ]
1447 pub fn bits(&self) -> u8 {
1448 self.bits
1449 }
1450 }
1451 # [ doc = "Value of the field OSPEEDR7" ]
1452 pub struct Ospeedr7R {
1453 bits: u8,
1454 }
1455 impl Ospeedr7R {
1456 # [ doc = r" Value of the field as raw bits" ]
1457 pub fn bits(&self) -> u8 {
1458 self.bits
1459 }
1460 }
1461 # [ doc = "Value of the field OSPEEDR6" ]
1462 pub struct Ospeedr6R {
1463 bits: u8,
1464 }
1465 impl Ospeedr6R {
1466 # [ doc = r" Value of the field as raw bits" ]
1467 pub fn bits(&self) -> u8 {
1468 self.bits
1469 }
1470 }
1471 # [ doc = "Value of the field OSPEEDR5" ]
1472 pub struct Ospeedr5R {
1473 bits: u8,
1474 }
1475 impl Ospeedr5R {
1476 # [ doc = r" Value of the field as raw bits" ]
1477 pub fn bits(&self) -> u8 {
1478 self.bits
1479 }
1480 }
1481 # [ doc = "Value of the field OSPEEDR4" ]
1482 pub struct Ospeedr4R {
1483 bits: u8,
1484 }
1485 impl Ospeedr4R {
1486 # [ doc = r" Value of the field as raw bits" ]
1487 pub fn bits(&self) -> u8 {
1488 self.bits
1489 }
1490 }
1491 # [ doc = "Value of the field OSPEEDR3" ]
1492 pub struct Ospeedr3R {
1493 bits: u8,
1494 }
1495 impl Ospeedr3R {
1496 # [ doc = r" Value of the field as raw bits" ]
1497 pub fn bits(&self) -> u8 {
1498 self.bits
1499 }
1500 }
1501 # [ doc = "Value of the field OSPEEDR2" ]
1502 pub struct Ospeedr2R {
1503 bits: u8,
1504 }
1505 impl Ospeedr2R {
1506 # [ doc = r" Value of the field as raw bits" ]
1507 pub fn bits(&self) -> u8 {
1508 self.bits
1509 }
1510 }
1511 # [ doc = "Value of the field OSPEEDR1" ]
1512 pub struct Ospeedr1R {
1513 bits: u8,
1514 }
1515 impl Ospeedr1R {
1516 # [ doc = r" Value of the field as raw bits" ]
1517 pub fn bits(&self) -> u8 {
1518 self.bits
1519 }
1520 }
1521 # [ doc = "Value of the field OSPEEDR0" ]
1522 pub struct Ospeedr0R {
1523 bits: u8,
1524 }
1525 impl Ospeedr0R {
1526 # [ doc = r" Value of the field as raw bits" ]
1527 pub fn bits(&self) -> u8 {
1528 self.bits
1529 }
1530 }
1531 # [ doc = r" Proxy" ]
1532 pub struct _Ospeedr15W<'a> {
1533 register: &'a mut W,
1534 }
1535 impl<'a> _Ospeedr15W<'a> {
1536 # [ doc = r" Writes raw `bits` to the field" ]
1537 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1538 const MASK: u8 = 3;
1539 const OFFSET: u8 = 30;
1540 self.register.bits &= !((MASK as u32) << OFFSET);
1541 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1542 self.register
1543 }
1544 }
1545 # [ doc = r" Proxy" ]
1546 pub struct _Ospeedr14W<'a> {
1547 register: &'a mut W,
1548 }
1549 impl<'a> _Ospeedr14W<'a> {
1550 # [ doc = r" Writes raw `bits` to the field" ]
1551 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1552 const MASK: u8 = 3;
1553 const OFFSET: u8 = 28;
1554 self.register.bits &= !((MASK as u32) << OFFSET);
1555 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1556 self.register
1557 }
1558 }
1559 # [ doc = r" Proxy" ]
1560 pub struct _Ospeedr13W<'a> {
1561 register: &'a mut W,
1562 }
1563 impl<'a> _Ospeedr13W<'a> {
1564 # [ doc = r" Writes raw `bits` to the field" ]
1565 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1566 const MASK: u8 = 3;
1567 const OFFSET: u8 = 26;
1568 self.register.bits &= !((MASK as u32) << OFFSET);
1569 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1570 self.register
1571 }
1572 }
1573 # [ doc = r" Proxy" ]
1574 pub struct _Ospeedr12W<'a> {
1575 register: &'a mut W,
1576 }
1577 impl<'a> _Ospeedr12W<'a> {
1578 # [ doc = r" Writes raw `bits` to the field" ]
1579 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1580 const MASK: u8 = 3;
1581 const OFFSET: u8 = 24;
1582 self.register.bits &= !((MASK as u32) << OFFSET);
1583 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1584 self.register
1585 }
1586 }
1587 # [ doc = r" Proxy" ]
1588 pub struct _Ospeedr11W<'a> {
1589 register: &'a mut W,
1590 }
1591 impl<'a> _Ospeedr11W<'a> {
1592 # [ doc = r" Writes raw `bits` to the field" ]
1593 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1594 const MASK: u8 = 3;
1595 const OFFSET: u8 = 22;
1596 self.register.bits &= !((MASK as u32) << OFFSET);
1597 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1598 self.register
1599 }
1600 }
1601 # [ doc = r" Proxy" ]
1602 pub struct _Ospeedr10W<'a> {
1603 register: &'a mut W,
1604 }
1605 impl<'a> _Ospeedr10W<'a> {
1606 # [ doc = r" Writes raw `bits` to the field" ]
1607 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1608 const MASK: u8 = 3;
1609 const OFFSET: u8 = 20;
1610 self.register.bits &= !((MASK as u32) << OFFSET);
1611 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1612 self.register
1613 }
1614 }
1615 # [ doc = r" Proxy" ]
1616 pub struct _Ospeedr9W<'a> {
1617 register: &'a mut W,
1618 }
1619 impl<'a> _Ospeedr9W<'a> {
1620 # [ doc = r" Writes raw `bits` to the field" ]
1621 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1622 const MASK: u8 = 3;
1623 const OFFSET: u8 = 18;
1624 self.register.bits &= !((MASK as u32) << OFFSET);
1625 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1626 self.register
1627 }
1628 }
1629 # [ doc = r" Proxy" ]
1630 pub struct _Ospeedr8W<'a> {
1631 register: &'a mut W,
1632 }
1633 impl<'a> _Ospeedr8W<'a> {
1634 # [ doc = r" Writes raw `bits` to the field" ]
1635 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1636 const MASK: u8 = 3;
1637 const OFFSET: u8 = 16;
1638 self.register.bits &= !((MASK as u32) << OFFSET);
1639 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1640 self.register
1641 }
1642 }
1643 # [ doc = r" Proxy" ]
1644 pub struct _Ospeedr7W<'a> {
1645 register: &'a mut W,
1646 }
1647 impl<'a> _Ospeedr7W<'a> {
1648 # [ doc = r" Writes raw `bits` to the field" ]
1649 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1650 const MASK: u8 = 3;
1651 const OFFSET: u8 = 14;
1652 self.register.bits &= !((MASK as u32) << OFFSET);
1653 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1654 self.register
1655 }
1656 }
1657 # [ doc = r" Proxy" ]
1658 pub struct _Ospeedr6W<'a> {
1659 register: &'a mut W,
1660 }
1661 impl<'a> _Ospeedr6W<'a> {
1662 # [ doc = r" Writes raw `bits` to the field" ]
1663 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1664 const MASK: u8 = 3;
1665 const OFFSET: u8 = 12;
1666 self.register.bits &= !((MASK as u32) << OFFSET);
1667 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1668 self.register
1669 }
1670 }
1671 # [ doc = r" Proxy" ]
1672 pub struct _Ospeedr5W<'a> {
1673 register: &'a mut W,
1674 }
1675 impl<'a> _Ospeedr5W<'a> {
1676 # [ doc = r" Writes raw `bits` to the field" ]
1677 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1678 const MASK: u8 = 3;
1679 const OFFSET: u8 = 10;
1680 self.register.bits &= !((MASK as u32) << OFFSET);
1681 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1682 self.register
1683 }
1684 }
1685 # [ doc = r" Proxy" ]
1686 pub struct _Ospeedr4W<'a> {
1687 register: &'a mut W,
1688 }
1689 impl<'a> _Ospeedr4W<'a> {
1690 # [ doc = r" Writes raw `bits` to the field" ]
1691 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1692 const MASK: u8 = 3;
1693 const OFFSET: u8 = 8;
1694 self.register.bits &= !((MASK as u32) << OFFSET);
1695 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1696 self.register
1697 }
1698 }
1699 # [ doc = r" Proxy" ]
1700 pub struct _Ospeedr3W<'a> {
1701 register: &'a mut W,
1702 }
1703 impl<'a> _Ospeedr3W<'a> {
1704 # [ doc = r" Writes raw `bits` to the field" ]
1705 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1706 const MASK: u8 = 3;
1707 const OFFSET: u8 = 6;
1708 self.register.bits &= !((MASK as u32) << OFFSET);
1709 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1710 self.register
1711 }
1712 }
1713 # [ doc = r" Proxy" ]
1714 pub struct _Ospeedr2W<'a> {
1715 register: &'a mut W,
1716 }
1717 impl<'a> _Ospeedr2W<'a> {
1718 # [ doc = r" Writes raw `bits` to the field" ]
1719 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1720 const MASK: u8 = 3;
1721 const OFFSET: u8 = 4;
1722 self.register.bits &= !((MASK as u32) << OFFSET);
1723 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1724 self.register
1725 }
1726 }
1727 # [ doc = r" Proxy" ]
1728 pub struct _Ospeedr1W<'a> {
1729 register: &'a mut W,
1730 }
1731 impl<'a> _Ospeedr1W<'a> {
1732 # [ doc = r" Writes raw `bits` to the field" ]
1733 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1734 const MASK: u8 = 3;
1735 const OFFSET: u8 = 2;
1736 self.register.bits &= !((MASK as u32) << OFFSET);
1737 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1738 self.register
1739 }
1740 }
1741 # [ doc = r" Proxy" ]
1742 pub struct _Ospeedr0W<'a> {
1743 register: &'a mut W,
1744 }
1745 impl<'a> _Ospeedr0W<'a> {
1746 # [ doc = r" Writes raw `bits` to the field" ]
1747 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
1748 const MASK: u8 = 3;
1749 const OFFSET: u8 = 0;
1750 self.register.bits &= !((MASK as u32) << OFFSET);
1751 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
1752 self.register
1753 }
1754 }
1755 impl R {
1756 # [ doc = r" Value of the register as raw bits" ]
1757 pub fn bits(&self) -> u32 {
1758 self.bits
1759 }
1760 fn _ospeedr15(&self) -> u8 {
1761 const MASK: u8 = 3;
1762 const OFFSET: u8 = 30;
1763 ((self.bits >> OFFSET) & MASK as u32) as u8
1764 }
1765 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
1766 pub fn ospeedr15(&self) -> Ospeedr15R {
1767 Ospeedr15R { bits: self._ospeedr15() }
1768 }
1769 fn _ospeedr14(&self) -> u8 {
1770 const MASK: u8 = 3;
1771 const OFFSET: u8 = 28;
1772 ((self.bits >> OFFSET) & MASK as u32) as u8
1773 }
1774 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
1775 pub fn ospeedr14(&self) -> Ospeedr14R {
1776 Ospeedr14R { bits: self._ospeedr14() }
1777 }
1778 fn _ospeedr13(&self) -> u8 {
1779 const MASK: u8 = 3;
1780 const OFFSET: u8 = 26;
1781 ((self.bits >> OFFSET) & MASK as u32) as u8
1782 }
1783 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
1784 pub fn ospeedr13(&self) -> Ospeedr13R {
1785 Ospeedr13R { bits: self._ospeedr13() }
1786 }
1787 fn _ospeedr12(&self) -> u8 {
1788 const MASK: u8 = 3;
1789 const OFFSET: u8 = 24;
1790 ((self.bits >> OFFSET) & MASK as u32) as u8
1791 }
1792 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
1793 pub fn ospeedr12(&self) -> Ospeedr12R {
1794 Ospeedr12R { bits: self._ospeedr12() }
1795 }
1796 fn _ospeedr11(&self) -> u8 {
1797 const MASK: u8 = 3;
1798 const OFFSET: u8 = 22;
1799 ((self.bits >> OFFSET) & MASK as u32) as u8
1800 }
1801 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
1802 pub fn ospeedr11(&self) -> Ospeedr11R {
1803 Ospeedr11R { bits: self._ospeedr11() }
1804 }
1805 fn _ospeedr10(&self) -> u8 {
1806 const MASK: u8 = 3;
1807 const OFFSET: u8 = 20;
1808 ((self.bits >> OFFSET) & MASK as u32) as u8
1809 }
1810 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
1811 pub fn ospeedr10(&self) -> Ospeedr10R {
1812 Ospeedr10R { bits: self._ospeedr10() }
1813 }
1814 fn _ospeedr9(&self) -> u8 {
1815 const MASK: u8 = 3;
1816 const OFFSET: u8 = 18;
1817 ((self.bits >> OFFSET) & MASK as u32) as u8
1818 }
1819 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
1820 pub fn ospeedr9(&self) -> Ospeedr9R {
1821 Ospeedr9R { bits: self._ospeedr9() }
1822 }
1823 fn _ospeedr8(&self) -> u8 {
1824 const MASK: u8 = 3;
1825 const OFFSET: u8 = 16;
1826 ((self.bits >> OFFSET) & MASK as u32) as u8
1827 }
1828 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
1829 pub fn ospeedr8(&self) -> Ospeedr8R {
1830 Ospeedr8R { bits: self._ospeedr8() }
1831 }
1832 fn _ospeedr7(&self) -> u8 {
1833 const MASK: u8 = 3;
1834 const OFFSET: u8 = 14;
1835 ((self.bits >> OFFSET) & MASK as u32) as u8
1836 }
1837 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
1838 pub fn ospeedr7(&self) -> Ospeedr7R {
1839 Ospeedr7R { bits: self._ospeedr7() }
1840 }
1841 fn _ospeedr6(&self) -> u8 {
1842 const MASK: u8 = 3;
1843 const OFFSET: u8 = 12;
1844 ((self.bits >> OFFSET) & MASK as u32) as u8
1845 }
1846 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
1847 pub fn ospeedr6(&self) -> Ospeedr6R {
1848 Ospeedr6R { bits: self._ospeedr6() }
1849 }
1850 fn _ospeedr5(&self) -> u8 {
1851 const MASK: u8 = 3;
1852 const OFFSET: u8 = 10;
1853 ((self.bits >> OFFSET) & MASK as u32) as u8
1854 }
1855 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
1856 pub fn ospeedr5(&self) -> Ospeedr5R {
1857 Ospeedr5R { bits: self._ospeedr5() }
1858 }
1859 fn _ospeedr4(&self) -> u8 {
1860 const MASK: u8 = 3;
1861 const OFFSET: u8 = 8;
1862 ((self.bits >> OFFSET) & MASK as u32) as u8
1863 }
1864 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
1865 pub fn ospeedr4(&self) -> Ospeedr4R {
1866 Ospeedr4R { bits: self._ospeedr4() }
1867 }
1868 fn _ospeedr3(&self) -> u8 {
1869 const MASK: u8 = 3;
1870 const OFFSET: u8 = 6;
1871 ((self.bits >> OFFSET) & MASK as u32) as u8
1872 }
1873 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
1874 pub fn ospeedr3(&self) -> Ospeedr3R {
1875 Ospeedr3R { bits: self._ospeedr3() }
1876 }
1877 fn _ospeedr2(&self) -> u8 {
1878 const MASK: u8 = 3;
1879 const OFFSET: u8 = 4;
1880 ((self.bits >> OFFSET) & MASK as u32) as u8
1881 }
1882 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
1883 pub fn ospeedr2(&self) -> Ospeedr2R {
1884 Ospeedr2R { bits: self._ospeedr2() }
1885 }
1886 fn _ospeedr1(&self) -> u8 {
1887 const MASK: u8 = 3;
1888 const OFFSET: u8 = 2;
1889 ((self.bits >> OFFSET) & MASK as u32) as u8
1890 }
1891 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
1892 pub fn ospeedr1(&self) -> Ospeedr1R {
1893 Ospeedr1R { bits: self._ospeedr1() }
1894 }
1895 fn _ospeedr0(&self) -> u8 {
1896 const MASK: u8 = 3;
1897 const OFFSET: u8 = 0;
1898 ((self.bits >> OFFSET) & MASK as u32) as u8
1899 }
1900 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
1901 pub fn ospeedr0(&self) -> Ospeedr0R {
1902 Ospeedr0R { bits: self._ospeedr0() }
1903 }
1904 }
1905 impl W {
1906 # [ doc = r" Reset value of the register" ]
1907 pub fn reset_value() -> W {
1908 W { bits: 0 }
1909 }
1910 # [ doc = r" Writes raw `bits` to the register" ]
1911 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1912 self.bits = bits;
1913 self
1914 }
1915 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
1916 pub fn ospeedr15(&mut self) -> _Ospeedr15W {
1917 _Ospeedr15W { register: self }
1918 }
1919 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
1920 pub fn ospeedr14(&mut self) -> _Ospeedr14W {
1921 _Ospeedr14W { register: self }
1922 }
1923 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
1924 pub fn ospeedr13(&mut self) -> _Ospeedr13W {
1925 _Ospeedr13W { register: self }
1926 }
1927 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
1928 pub fn ospeedr12(&mut self) -> _Ospeedr12W {
1929 _Ospeedr12W { register: self }
1930 }
1931 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
1932 pub fn ospeedr11(&mut self) -> _Ospeedr11W {
1933 _Ospeedr11W { register: self }
1934 }
1935 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
1936 pub fn ospeedr10(&mut self) -> _Ospeedr10W {
1937 _Ospeedr10W { register: self }
1938 }
1939 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
1940 pub fn ospeedr9(&mut self) -> _Ospeedr9W {
1941 _Ospeedr9W { register: self }
1942 }
1943 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
1944 pub fn ospeedr8(&mut self) -> _Ospeedr8W {
1945 _Ospeedr8W { register: self }
1946 }
1947 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
1948 pub fn ospeedr7(&mut self) -> _Ospeedr7W {
1949 _Ospeedr7W { register: self }
1950 }
1951 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
1952 pub fn ospeedr6(&mut self) -> _Ospeedr6W {
1953 _Ospeedr6W { register: self }
1954 }
1955 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
1956 pub fn ospeedr5(&mut self) -> _Ospeedr5W {
1957 _Ospeedr5W { register: self }
1958 }
1959 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
1960 pub fn ospeedr4(&mut self) -> _Ospeedr4W {
1961 _Ospeedr4W { register: self }
1962 }
1963 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
1964 pub fn ospeedr3(&mut self) -> _Ospeedr3W {
1965 _Ospeedr3W { register: self }
1966 }
1967 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
1968 pub fn ospeedr2(&mut self) -> _Ospeedr2W {
1969 _Ospeedr2W { register: self }
1970 }
1971 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
1972 pub fn ospeedr1(&mut self) -> _Ospeedr1W {
1973 _Ospeedr1W { register: self }
1974 }
1975 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
1976 pub fn ospeedr0(&mut self) -> _Ospeedr0W {
1977 _Ospeedr0W { register: self }
1978 }
1979 }
1980}
1981
1982# [ doc = "GPIO port pull-up/pull-down register" ]
1983# [ repr ( C ) ]
1984pub struct Pupdr {
1985 register: ::volatile_register::RW<u32>,
1986}
1987
1988# [ doc = "GPIO port pull-up/pull-down register" ]
1989pub mod pupdr {
1990 # [ doc = r" Value read from the register" ]
1991 pub struct R {
1992 bits: u32,
1993 }
1994 # [ doc = r" Value to write to the register" ]
1995 pub struct W {
1996 bits: u32,
1997 }
1998 impl super::Pupdr {
1999 # [ doc = r" Modifies the contents of the register" ]
2000 pub fn modify<F>(&mut self, f: F)
2001 where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W
2002 {
2003 let bits = self.register.read();
2004 let r = R { bits: bits };
2005 let mut w = W { bits: bits };
2006 f(&r, &mut w);
2007 self.register.write(w.bits);
2008 }
2009 # [ doc = r" Reads the contents of the register" ]
2010 pub fn read(&self) -> R {
2011 R { bits: self.register.read() }
2012 }
2013 # [ doc = r" Writes to the register" ]
2014 pub fn write<F>(&mut self, f: F)
2015 where F: FnOnce(&mut W) -> &mut W
2016 {
2017 let mut w = W::reset_value();
2018 f(&mut w);
2019 self.register.write(w.bits);
2020 }
2021 }
2022 # [ doc = "Value of the field PUPDR15" ]
2023 pub struct Pupdr15R {
2024 bits: u8,
2025 }
2026 impl Pupdr15R {
2027 # [ doc = r" Value of the field as raw bits" ]
2028 pub fn bits(&self) -> u8 {
2029 self.bits
2030 }
2031 }
2032 # [ doc = "Value of the field PUPDR14" ]
2033 pub struct Pupdr14R {
2034 bits: u8,
2035 }
2036 impl Pupdr14R {
2037 # [ doc = r" Value of the field as raw bits" ]
2038 pub fn bits(&self) -> u8 {
2039 self.bits
2040 }
2041 }
2042 # [ doc = "Value of the field PUPDR13" ]
2043 pub struct Pupdr13R {
2044 bits: u8,
2045 }
2046 impl Pupdr13R {
2047 # [ doc = r" Value of the field as raw bits" ]
2048 pub fn bits(&self) -> u8 {
2049 self.bits
2050 }
2051 }
2052 # [ doc = "Value of the field PUPDR12" ]
2053 pub struct Pupdr12R {
2054 bits: u8,
2055 }
2056 impl Pupdr12R {
2057 # [ doc = r" Value of the field as raw bits" ]
2058 pub fn bits(&self) -> u8 {
2059 self.bits
2060 }
2061 }
2062 # [ doc = "Value of the field PUPDR11" ]
2063 pub struct Pupdr11R {
2064 bits: u8,
2065 }
2066 impl Pupdr11R {
2067 # [ doc = r" Value of the field as raw bits" ]
2068 pub fn bits(&self) -> u8 {
2069 self.bits
2070 }
2071 }
2072 # [ doc = "Value of the field PUPDR10" ]
2073 pub struct Pupdr10R {
2074 bits: u8,
2075 }
2076 impl Pupdr10R {
2077 # [ doc = r" Value of the field as raw bits" ]
2078 pub fn bits(&self) -> u8 {
2079 self.bits
2080 }
2081 }
2082 # [ doc = "Value of the field PUPDR9" ]
2083 pub struct Pupdr9R {
2084 bits: u8,
2085 }
2086 impl Pupdr9R {
2087 # [ doc = r" Value of the field as raw bits" ]
2088 pub fn bits(&self) -> u8 {
2089 self.bits
2090 }
2091 }
2092 # [ doc = "Value of the field PUPDR8" ]
2093 pub struct Pupdr8R {
2094 bits: u8,
2095 }
2096 impl Pupdr8R {
2097 # [ doc = r" Value of the field as raw bits" ]
2098 pub fn bits(&self) -> u8 {
2099 self.bits
2100 }
2101 }
2102 # [ doc = "Value of the field PUPDR7" ]
2103 pub struct Pupdr7R {
2104 bits: u8,
2105 }
2106 impl Pupdr7R {
2107 # [ doc = r" Value of the field as raw bits" ]
2108 pub fn bits(&self) -> u8 {
2109 self.bits
2110 }
2111 }
2112 # [ doc = "Value of the field PUPDR6" ]
2113 pub struct Pupdr6R {
2114 bits: u8,
2115 }
2116 impl Pupdr6R {
2117 # [ doc = r" Value of the field as raw bits" ]
2118 pub fn bits(&self) -> u8 {
2119 self.bits
2120 }
2121 }
2122 # [ doc = "Value of the field PUPDR5" ]
2123 pub struct Pupdr5R {
2124 bits: u8,
2125 }
2126 impl Pupdr5R {
2127 # [ doc = r" Value of the field as raw bits" ]
2128 pub fn bits(&self) -> u8 {
2129 self.bits
2130 }
2131 }
2132 # [ doc = "Value of the field PUPDR4" ]
2133 pub struct Pupdr4R {
2134 bits: u8,
2135 }
2136 impl Pupdr4R {
2137 # [ doc = r" Value of the field as raw bits" ]
2138 pub fn bits(&self) -> u8 {
2139 self.bits
2140 }
2141 }
2142 # [ doc = "Value of the field PUPDR3" ]
2143 pub struct Pupdr3R {
2144 bits: u8,
2145 }
2146 impl Pupdr3R {
2147 # [ doc = r" Value of the field as raw bits" ]
2148 pub fn bits(&self) -> u8 {
2149 self.bits
2150 }
2151 }
2152 # [ doc = "Value of the field PUPDR2" ]
2153 pub struct Pupdr2R {
2154 bits: u8,
2155 }
2156 impl Pupdr2R {
2157 # [ doc = r" Value of the field as raw bits" ]
2158 pub fn bits(&self) -> u8 {
2159 self.bits
2160 }
2161 }
2162 # [ doc = "Value of the field PUPDR1" ]
2163 pub struct Pupdr1R {
2164 bits: u8,
2165 }
2166 impl Pupdr1R {
2167 # [ doc = r" Value of the field as raw bits" ]
2168 pub fn bits(&self) -> u8 {
2169 self.bits
2170 }
2171 }
2172 # [ doc = "Value of the field PUPDR0" ]
2173 pub struct Pupdr0R {
2174 bits: u8,
2175 }
2176 impl Pupdr0R {
2177 # [ doc = r" Value of the field as raw bits" ]
2178 pub fn bits(&self) -> u8 {
2179 self.bits
2180 }
2181 }
2182 # [ doc = r" Proxy" ]
2183 pub struct _Pupdr15W<'a> {
2184 register: &'a mut W,
2185 }
2186 impl<'a> _Pupdr15W<'a> {
2187 # [ doc = r" Writes raw `bits` to the field" ]
2188 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2189 const MASK: u8 = 3;
2190 const OFFSET: u8 = 30;
2191 self.register.bits &= !((MASK as u32) << OFFSET);
2192 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2193 self.register
2194 }
2195 }
2196 # [ doc = r" Proxy" ]
2197 pub struct _Pupdr14W<'a> {
2198 register: &'a mut W,
2199 }
2200 impl<'a> _Pupdr14W<'a> {
2201 # [ doc = r" Writes raw `bits` to the field" ]
2202 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2203 const MASK: u8 = 3;
2204 const OFFSET: u8 = 28;
2205 self.register.bits &= !((MASK as u32) << OFFSET);
2206 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2207 self.register
2208 }
2209 }
2210 # [ doc = r" Proxy" ]
2211 pub struct _Pupdr13W<'a> {
2212 register: &'a mut W,
2213 }
2214 impl<'a> _Pupdr13W<'a> {
2215 # [ doc = r" Writes raw `bits` to the field" ]
2216 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2217 const MASK: u8 = 3;
2218 const OFFSET: u8 = 26;
2219 self.register.bits &= !((MASK as u32) << OFFSET);
2220 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2221 self.register
2222 }
2223 }
2224 # [ doc = r" Proxy" ]
2225 pub struct _Pupdr12W<'a> {
2226 register: &'a mut W,
2227 }
2228 impl<'a> _Pupdr12W<'a> {
2229 # [ doc = r" Writes raw `bits` to the field" ]
2230 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2231 const MASK: u8 = 3;
2232 const OFFSET: u8 = 24;
2233 self.register.bits &= !((MASK as u32) << OFFSET);
2234 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2235 self.register
2236 }
2237 }
2238 # [ doc = r" Proxy" ]
2239 pub struct _Pupdr11W<'a> {
2240 register: &'a mut W,
2241 }
2242 impl<'a> _Pupdr11W<'a> {
2243 # [ doc = r" Writes raw `bits` to the field" ]
2244 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2245 const MASK: u8 = 3;
2246 const OFFSET: u8 = 22;
2247 self.register.bits &= !((MASK as u32) << OFFSET);
2248 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2249 self.register
2250 }
2251 }
2252 # [ doc = r" Proxy" ]
2253 pub struct _Pupdr10W<'a> {
2254 register: &'a mut W,
2255 }
2256 impl<'a> _Pupdr10W<'a> {
2257 # [ doc = r" Writes raw `bits` to the field" ]
2258 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2259 const MASK: u8 = 3;
2260 const OFFSET: u8 = 20;
2261 self.register.bits &= !((MASK as u32) << OFFSET);
2262 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2263 self.register
2264 }
2265 }
2266 # [ doc = r" Proxy" ]
2267 pub struct _Pupdr9W<'a> {
2268 register: &'a mut W,
2269 }
2270 impl<'a> _Pupdr9W<'a> {
2271 # [ doc = r" Writes raw `bits` to the field" ]
2272 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2273 const MASK: u8 = 3;
2274 const OFFSET: u8 = 18;
2275 self.register.bits &= !((MASK as u32) << OFFSET);
2276 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2277 self.register
2278 }
2279 }
2280 # [ doc = r" Proxy" ]
2281 pub struct _Pupdr8W<'a> {
2282 register: &'a mut W,
2283 }
2284 impl<'a> _Pupdr8W<'a> {
2285 # [ doc = r" Writes raw `bits` to the field" ]
2286 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2287 const MASK: u8 = 3;
2288 const OFFSET: u8 = 16;
2289 self.register.bits &= !((MASK as u32) << OFFSET);
2290 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2291 self.register
2292 }
2293 }
2294 # [ doc = r" Proxy" ]
2295 pub struct _Pupdr7W<'a> {
2296 register: &'a mut W,
2297 }
2298 impl<'a> _Pupdr7W<'a> {
2299 # [ doc = r" Writes raw `bits` to the field" ]
2300 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2301 const MASK: u8 = 3;
2302 const OFFSET: u8 = 14;
2303 self.register.bits &= !((MASK as u32) << OFFSET);
2304 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2305 self.register
2306 }
2307 }
2308 # [ doc = r" Proxy" ]
2309 pub struct _Pupdr6W<'a> {
2310 register: &'a mut W,
2311 }
2312 impl<'a> _Pupdr6W<'a> {
2313 # [ doc = r" Writes raw `bits` to the field" ]
2314 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2315 const MASK: u8 = 3;
2316 const OFFSET: u8 = 12;
2317 self.register.bits &= !((MASK as u32) << OFFSET);
2318 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2319 self.register
2320 }
2321 }
2322 # [ doc = r" Proxy" ]
2323 pub struct _Pupdr5W<'a> {
2324 register: &'a mut W,
2325 }
2326 impl<'a> _Pupdr5W<'a> {
2327 # [ doc = r" Writes raw `bits` to the field" ]
2328 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2329 const MASK: u8 = 3;
2330 const OFFSET: u8 = 10;
2331 self.register.bits &= !((MASK as u32) << OFFSET);
2332 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2333 self.register
2334 }
2335 }
2336 # [ doc = r" Proxy" ]
2337 pub struct _Pupdr4W<'a> {
2338 register: &'a mut W,
2339 }
2340 impl<'a> _Pupdr4W<'a> {
2341 # [ doc = r" Writes raw `bits` to the field" ]
2342 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2343 const MASK: u8 = 3;
2344 const OFFSET: u8 = 8;
2345 self.register.bits &= !((MASK as u32) << OFFSET);
2346 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2347 self.register
2348 }
2349 }
2350 # [ doc = r" Proxy" ]
2351 pub struct _Pupdr3W<'a> {
2352 register: &'a mut W,
2353 }
2354 impl<'a> _Pupdr3W<'a> {
2355 # [ doc = r" Writes raw `bits` to the field" ]
2356 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2357 const MASK: u8 = 3;
2358 const OFFSET: u8 = 6;
2359 self.register.bits &= !((MASK as u32) << OFFSET);
2360 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2361 self.register
2362 }
2363 }
2364 # [ doc = r" Proxy" ]
2365 pub struct _Pupdr2W<'a> {
2366 register: &'a mut W,
2367 }
2368 impl<'a> _Pupdr2W<'a> {
2369 # [ doc = r" Writes raw `bits` to the field" ]
2370 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2371 const MASK: u8 = 3;
2372 const OFFSET: u8 = 4;
2373 self.register.bits &= !((MASK as u32) << OFFSET);
2374 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2375 self.register
2376 }
2377 }
2378 # [ doc = r" Proxy" ]
2379 pub struct _Pupdr1W<'a> {
2380 register: &'a mut W,
2381 }
2382 impl<'a> _Pupdr1W<'a> {
2383 # [ doc = r" Writes raw `bits` to the field" ]
2384 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2385 const MASK: u8 = 3;
2386 const OFFSET: u8 = 2;
2387 self.register.bits &= !((MASK as u32) << OFFSET);
2388 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2389 self.register
2390 }
2391 }
2392 # [ doc = r" Proxy" ]
2393 pub struct _Pupdr0W<'a> {
2394 register: &'a mut W,
2395 }
2396 impl<'a> _Pupdr0W<'a> {
2397 # [ doc = r" Writes raw `bits` to the field" ]
2398 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
2399 const MASK: u8 = 3;
2400 const OFFSET: u8 = 0;
2401 self.register.bits &= !((MASK as u32) << OFFSET);
2402 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
2403 self.register
2404 }
2405 }
2406 impl R {
2407 # [ doc = r" Value of the register as raw bits" ]
2408 pub fn bits(&self) -> u32 {
2409 self.bits
2410 }
2411 fn _pupdr15(&self) -> u8 {
2412 const MASK: u8 = 3;
2413 const OFFSET: u8 = 30;
2414 ((self.bits >> OFFSET) & MASK as u32) as u8
2415 }
2416 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
2417 pub fn pupdr15(&self) -> Pupdr15R {
2418 Pupdr15R { bits: self._pupdr15() }
2419 }
2420 fn _pupdr14(&self) -> u8 {
2421 const MASK: u8 = 3;
2422 const OFFSET: u8 = 28;
2423 ((self.bits >> OFFSET) & MASK as u32) as u8
2424 }
2425 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
2426 pub fn pupdr14(&self) -> Pupdr14R {
2427 Pupdr14R { bits: self._pupdr14() }
2428 }
2429 fn _pupdr13(&self) -> u8 {
2430 const MASK: u8 = 3;
2431 const OFFSET: u8 = 26;
2432 ((self.bits >> OFFSET) & MASK as u32) as u8
2433 }
2434 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
2435 pub fn pupdr13(&self) -> Pupdr13R {
2436 Pupdr13R { bits: self._pupdr13() }
2437 }
2438 fn _pupdr12(&self) -> u8 {
2439 const MASK: u8 = 3;
2440 const OFFSET: u8 = 24;
2441 ((self.bits >> OFFSET) & MASK as u32) as u8
2442 }
2443 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
2444 pub fn pupdr12(&self) -> Pupdr12R {
2445 Pupdr12R { bits: self._pupdr12() }
2446 }
2447 fn _pupdr11(&self) -> u8 {
2448 const MASK: u8 = 3;
2449 const OFFSET: u8 = 22;
2450 ((self.bits >> OFFSET) & MASK as u32) as u8
2451 }
2452 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
2453 pub fn pupdr11(&self) -> Pupdr11R {
2454 Pupdr11R { bits: self._pupdr11() }
2455 }
2456 fn _pupdr10(&self) -> u8 {
2457 const MASK: u8 = 3;
2458 const OFFSET: u8 = 20;
2459 ((self.bits >> OFFSET) & MASK as u32) as u8
2460 }
2461 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
2462 pub fn pupdr10(&self) -> Pupdr10R {
2463 Pupdr10R { bits: self._pupdr10() }
2464 }
2465 fn _pupdr9(&self) -> u8 {
2466 const MASK: u8 = 3;
2467 const OFFSET: u8 = 18;
2468 ((self.bits >> OFFSET) & MASK as u32) as u8
2469 }
2470 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
2471 pub fn pupdr9(&self) -> Pupdr9R {
2472 Pupdr9R { bits: self._pupdr9() }
2473 }
2474 fn _pupdr8(&self) -> u8 {
2475 const MASK: u8 = 3;
2476 const OFFSET: u8 = 16;
2477 ((self.bits >> OFFSET) & MASK as u32) as u8
2478 }
2479 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
2480 pub fn pupdr8(&self) -> Pupdr8R {
2481 Pupdr8R { bits: self._pupdr8() }
2482 }
2483 fn _pupdr7(&self) -> u8 {
2484 const MASK: u8 = 3;
2485 const OFFSET: u8 = 14;
2486 ((self.bits >> OFFSET) & MASK as u32) as u8
2487 }
2488 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
2489 pub fn pupdr7(&self) -> Pupdr7R {
2490 Pupdr7R { bits: self._pupdr7() }
2491 }
2492 fn _pupdr6(&self) -> u8 {
2493 const MASK: u8 = 3;
2494 const OFFSET: u8 = 12;
2495 ((self.bits >> OFFSET) & MASK as u32) as u8
2496 }
2497 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
2498 pub fn pupdr6(&self) -> Pupdr6R {
2499 Pupdr6R { bits: self._pupdr6() }
2500 }
2501 fn _pupdr5(&self) -> u8 {
2502 const MASK: u8 = 3;
2503 const OFFSET: u8 = 10;
2504 ((self.bits >> OFFSET) & MASK as u32) as u8
2505 }
2506 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
2507 pub fn pupdr5(&self) -> Pupdr5R {
2508 Pupdr5R { bits: self._pupdr5() }
2509 }
2510 fn _pupdr4(&self) -> u8 {
2511 const MASK: u8 = 3;
2512 const OFFSET: u8 = 8;
2513 ((self.bits >> OFFSET) & MASK as u32) as u8
2514 }
2515 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
2516 pub fn pupdr4(&self) -> Pupdr4R {
2517 Pupdr4R { bits: self._pupdr4() }
2518 }
2519 fn _pupdr3(&self) -> u8 {
2520 const MASK: u8 = 3;
2521 const OFFSET: u8 = 6;
2522 ((self.bits >> OFFSET) & MASK as u32) as u8
2523 }
2524 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
2525 pub fn pupdr3(&self) -> Pupdr3R {
2526 Pupdr3R { bits: self._pupdr3() }
2527 }
2528 fn _pupdr2(&self) -> u8 {
2529 const MASK: u8 = 3;
2530 const OFFSET: u8 = 4;
2531 ((self.bits >> OFFSET) & MASK as u32) as u8
2532 }
2533 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
2534 pub fn pupdr2(&self) -> Pupdr2R {
2535 Pupdr2R { bits: self._pupdr2() }
2536 }
2537 fn _pupdr1(&self) -> u8 {
2538 const MASK: u8 = 3;
2539 const OFFSET: u8 = 2;
2540 ((self.bits >> OFFSET) & MASK as u32) as u8
2541 }
2542 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
2543 pub fn pupdr1(&self) -> Pupdr1R {
2544 Pupdr1R { bits: self._pupdr1() }
2545 }
2546 fn _pupdr0(&self) -> u8 {
2547 const MASK: u8 = 3;
2548 const OFFSET: u8 = 0;
2549 ((self.bits >> OFFSET) & MASK as u32) as u8
2550 }
2551 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
2552 pub fn pupdr0(&self) -> Pupdr0R {
2553 Pupdr0R { bits: self._pupdr0() }
2554 }
2555 }
2556 impl W {
2557 # [ doc = r" Reset value of the register" ]
2558 pub fn reset_value() -> W {
2559 W { bits: 603979776 }
2560 }
2561 # [ doc = r" Writes raw `bits` to the register" ]
2562 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
2563 self.bits = bits;
2564 self
2565 }
2566 # [ doc = "Bits 30:31 - Port x configuration bits (y = 0..15)" ]
2567 pub fn pupdr15(&mut self) -> _Pupdr15W {
2568 _Pupdr15W { register: self }
2569 }
2570 # [ doc = "Bits 28:29 - Port x configuration bits (y = 0..15)" ]
2571 pub fn pupdr14(&mut self) -> _Pupdr14W {
2572 _Pupdr14W { register: self }
2573 }
2574 # [ doc = "Bits 26:27 - Port x configuration bits (y = 0..15)" ]
2575 pub fn pupdr13(&mut self) -> _Pupdr13W {
2576 _Pupdr13W { register: self }
2577 }
2578 # [ doc = "Bits 24:25 - Port x configuration bits (y = 0..15)" ]
2579 pub fn pupdr12(&mut self) -> _Pupdr12W {
2580 _Pupdr12W { register: self }
2581 }
2582 # [ doc = "Bits 22:23 - Port x configuration bits (y = 0..15)" ]
2583 pub fn pupdr11(&mut self) -> _Pupdr11W {
2584 _Pupdr11W { register: self }
2585 }
2586 # [ doc = "Bits 20:21 - Port x configuration bits (y = 0..15)" ]
2587 pub fn pupdr10(&mut self) -> _Pupdr10W {
2588 _Pupdr10W { register: self }
2589 }
2590 # [ doc = "Bits 18:19 - Port x configuration bits (y = 0..15)" ]
2591 pub fn pupdr9(&mut self) -> _Pupdr9W {
2592 _Pupdr9W { register: self }
2593 }
2594 # [ doc = "Bits 16:17 - Port x configuration bits (y = 0..15)" ]
2595 pub fn pupdr8(&mut self) -> _Pupdr8W {
2596 _Pupdr8W { register: self }
2597 }
2598 # [ doc = "Bits 14:15 - Port x configuration bits (y = 0..15)" ]
2599 pub fn pupdr7(&mut self) -> _Pupdr7W {
2600 _Pupdr7W { register: self }
2601 }
2602 # [ doc = "Bits 12:13 - Port x configuration bits (y = 0..15)" ]
2603 pub fn pupdr6(&mut self) -> _Pupdr6W {
2604 _Pupdr6W { register: self }
2605 }
2606 # [ doc = "Bits 10:11 - Port x configuration bits (y = 0..15)" ]
2607 pub fn pupdr5(&mut self) -> _Pupdr5W {
2608 _Pupdr5W { register: self }
2609 }
2610 # [ doc = "Bits 8:9 - Port x configuration bits (y = 0..15)" ]
2611 pub fn pupdr4(&mut self) -> _Pupdr4W {
2612 _Pupdr4W { register: self }
2613 }
2614 # [ doc = "Bits 6:7 - Port x configuration bits (y = 0..15)" ]
2615 pub fn pupdr3(&mut self) -> _Pupdr3W {
2616 _Pupdr3W { register: self }
2617 }
2618 # [ doc = "Bits 4:5 - Port x configuration bits (y = 0..15)" ]
2619 pub fn pupdr2(&mut self) -> _Pupdr2W {
2620 _Pupdr2W { register: self }
2621 }
2622 # [ doc = "Bits 2:3 - Port x configuration bits (y = 0..15)" ]
2623 pub fn pupdr1(&mut self) -> _Pupdr1W {
2624 _Pupdr1W { register: self }
2625 }
2626 # [ doc = "Bits 0:1 - Port x configuration bits (y = 0..15)" ]
2627 pub fn pupdr0(&mut self) -> _Pupdr0W {
2628 _Pupdr0W { register: self }
2629 }
2630 }
2631}
2632
2633# [ doc = "GPIO port input data register" ]
2634# [ repr ( C ) ]
2635pub struct Idr {
2636 register: ::volatile_register::RO<u32>,
2637}
2638
2639# [ doc = "GPIO port input data register" ]
2640pub mod idr {
2641 # [ doc = r" Value read from the register" ]
2642 pub struct R {
2643 bits: u32,
2644 }
2645 impl super::Idr {
2646 # [ doc = r" Reads the contents of the register" ]
2647 pub fn read(&self) -> R {
2648 R { bits: self.register.read() }
2649 }
2650 }
2651 # [ doc = "Value of the field IDR15" ]
2652 pub struct Idr15R {
2653 bits: u8,
2654 }
2655 impl Idr15R {
2656 # [ doc = r" Value of the field as raw bits" ]
2657 pub fn bits(&self) -> u8 {
2658 self.bits
2659 }
2660 }
2661 # [ doc = "Value of the field IDR14" ]
2662 pub struct Idr14R {
2663 bits: u8,
2664 }
2665 impl Idr14R {
2666 # [ doc = r" Value of the field as raw bits" ]
2667 pub fn bits(&self) -> u8 {
2668 self.bits
2669 }
2670 }
2671 # [ doc = "Value of the field IDR13" ]
2672 pub struct Idr13R {
2673 bits: u8,
2674 }
2675 impl Idr13R {
2676 # [ doc = r" Value of the field as raw bits" ]
2677 pub fn bits(&self) -> u8 {
2678 self.bits
2679 }
2680 }
2681 # [ doc = "Value of the field IDR12" ]
2682 pub struct Idr12R {
2683 bits: u8,
2684 }
2685 impl Idr12R {
2686 # [ doc = r" Value of the field as raw bits" ]
2687 pub fn bits(&self) -> u8 {
2688 self.bits
2689 }
2690 }
2691 # [ doc = "Value of the field IDR11" ]
2692 pub struct Idr11R {
2693 bits: u8,
2694 }
2695 impl Idr11R {
2696 # [ doc = r" Value of the field as raw bits" ]
2697 pub fn bits(&self) -> u8 {
2698 self.bits
2699 }
2700 }
2701 # [ doc = "Value of the field IDR10" ]
2702 pub struct Idr10R {
2703 bits: u8,
2704 }
2705 impl Idr10R {
2706 # [ doc = r" Value of the field as raw bits" ]
2707 pub fn bits(&self) -> u8 {
2708 self.bits
2709 }
2710 }
2711 # [ doc = "Value of the field IDR9" ]
2712 pub struct Idr9R {
2713 bits: u8,
2714 }
2715 impl Idr9R {
2716 # [ doc = r" Value of the field as raw bits" ]
2717 pub fn bits(&self) -> u8 {
2718 self.bits
2719 }
2720 }
2721 # [ doc = "Value of the field IDR8" ]
2722 pub struct Idr8R {
2723 bits: u8,
2724 }
2725 impl Idr8R {
2726 # [ doc = r" Value of the field as raw bits" ]
2727 pub fn bits(&self) -> u8 {
2728 self.bits
2729 }
2730 }
2731 # [ doc = "Value of the field IDR7" ]
2732 pub struct Idr7R {
2733 bits: u8,
2734 }
2735 impl Idr7R {
2736 # [ doc = r" Value of the field as raw bits" ]
2737 pub fn bits(&self) -> u8 {
2738 self.bits
2739 }
2740 }
2741 # [ doc = "Value of the field IDR6" ]
2742 pub struct Idr6R {
2743 bits: u8,
2744 }
2745 impl Idr6R {
2746 # [ doc = r" Value of the field as raw bits" ]
2747 pub fn bits(&self) -> u8 {
2748 self.bits
2749 }
2750 }
2751 # [ doc = "Value of the field IDR5" ]
2752 pub struct Idr5R {
2753 bits: u8,
2754 }
2755 impl Idr5R {
2756 # [ doc = r" Value of the field as raw bits" ]
2757 pub fn bits(&self) -> u8 {
2758 self.bits
2759 }
2760 }
2761 # [ doc = "Value of the field IDR4" ]
2762 pub struct Idr4R {
2763 bits: u8,
2764 }
2765 impl Idr4R {
2766 # [ doc = r" Value of the field as raw bits" ]
2767 pub fn bits(&self) -> u8 {
2768 self.bits
2769 }
2770 }
2771 # [ doc = "Value of the field IDR3" ]
2772 pub struct Idr3R {
2773 bits: u8,
2774 }
2775 impl Idr3R {
2776 # [ doc = r" Value of the field as raw bits" ]
2777 pub fn bits(&self) -> u8 {
2778 self.bits
2779 }
2780 }
2781 # [ doc = "Value of the field IDR2" ]
2782 pub struct Idr2R {
2783 bits: u8,
2784 }
2785 impl Idr2R {
2786 # [ doc = r" Value of the field as raw bits" ]
2787 pub fn bits(&self) -> u8 {
2788 self.bits
2789 }
2790 }
2791 # [ doc = "Value of the field IDR1" ]
2792 pub struct Idr1R {
2793 bits: u8,
2794 }
2795 impl Idr1R {
2796 # [ doc = r" Value of the field as raw bits" ]
2797 pub fn bits(&self) -> u8 {
2798 self.bits
2799 }
2800 }
2801 # [ doc = "Value of the field IDR0" ]
2802 pub struct Idr0R {
2803 bits: u8,
2804 }
2805 impl Idr0R {
2806 # [ doc = r" Value of the field as raw bits" ]
2807 pub fn bits(&self) -> u8 {
2808 self.bits
2809 }
2810 }
2811 impl R {
2812 # [ doc = r" Value of the register as raw bits" ]
2813 pub fn bits(&self) -> u32 {
2814 self.bits
2815 }
2816 fn _idr15(&self) -> u8 {
2817 const MASK: u8 = 1;
2818 const OFFSET: u8 = 15;
2819 ((self.bits >> OFFSET) & MASK as u32) as u8
2820 }
2821 # [ doc = "Bit 15 - Port input data (y = 0..15)" ]
2822 pub fn idr15(&self) -> Idr15R {
2823 Idr15R { bits: self._idr15() }
2824 }
2825 fn _idr14(&self) -> u8 {
2826 const MASK: u8 = 1;
2827 const OFFSET: u8 = 14;
2828 ((self.bits >> OFFSET) & MASK as u32) as u8
2829 }
2830 # [ doc = "Bit 14 - Port input data (y = 0..15)" ]
2831 pub fn idr14(&self) -> Idr14R {
2832 Idr14R { bits: self._idr14() }
2833 }
2834 fn _idr13(&self) -> u8 {
2835 const MASK: u8 = 1;
2836 const OFFSET: u8 = 13;
2837 ((self.bits >> OFFSET) & MASK as u32) as u8
2838 }
2839 # [ doc = "Bit 13 - Port input data (y = 0..15)" ]
2840 pub fn idr13(&self) -> Idr13R {
2841 Idr13R { bits: self._idr13() }
2842 }
2843 fn _idr12(&self) -> u8 {
2844 const MASK: u8 = 1;
2845 const OFFSET: u8 = 12;
2846 ((self.bits >> OFFSET) & MASK as u32) as u8
2847 }
2848 # [ doc = "Bit 12 - Port input data (y = 0..15)" ]
2849 pub fn idr12(&self) -> Idr12R {
2850 Idr12R { bits: self._idr12() }
2851 }
2852 fn _idr11(&self) -> u8 {
2853 const MASK: u8 = 1;
2854 const OFFSET: u8 = 11;
2855 ((self.bits >> OFFSET) & MASK as u32) as u8
2856 }
2857 # [ doc = "Bit 11 - Port input data (y = 0..15)" ]
2858 pub fn idr11(&self) -> Idr11R {
2859 Idr11R { bits: self._idr11() }
2860 }
2861 fn _idr10(&self) -> u8 {
2862 const MASK: u8 = 1;
2863 const OFFSET: u8 = 10;
2864 ((self.bits >> OFFSET) & MASK as u32) as u8
2865 }
2866 # [ doc = "Bit 10 - Port input data (y = 0..15)" ]
2867 pub fn idr10(&self) -> Idr10R {
2868 Idr10R { bits: self._idr10() }
2869 }
2870 fn _idr9(&self) -> u8 {
2871 const MASK: u8 = 1;
2872 const OFFSET: u8 = 9;
2873 ((self.bits >> OFFSET) & MASK as u32) as u8
2874 }
2875 # [ doc = "Bit 9 - Port input data (y = 0..15)" ]
2876 pub fn idr9(&self) -> Idr9R {
2877 Idr9R { bits: self._idr9() }
2878 }
2879 fn _idr8(&self) -> u8 {
2880 const MASK: u8 = 1;
2881 const OFFSET: u8 = 8;
2882 ((self.bits >> OFFSET) & MASK as u32) as u8
2883 }
2884 # [ doc = "Bit 8 - Port input data (y = 0..15)" ]
2885 pub fn idr8(&self) -> Idr8R {
2886 Idr8R { bits: self._idr8() }
2887 }
2888 fn _idr7(&self) -> u8 {
2889 const MASK: u8 = 1;
2890 const OFFSET: u8 = 7;
2891 ((self.bits >> OFFSET) & MASK as u32) as u8
2892 }
2893 # [ doc = "Bit 7 - Port input data (y = 0..15)" ]
2894 pub fn idr7(&self) -> Idr7R {
2895 Idr7R { bits: self._idr7() }
2896 }
2897 fn _idr6(&self) -> u8 {
2898 const MASK: u8 = 1;
2899 const OFFSET: u8 = 6;
2900 ((self.bits >> OFFSET) & MASK as u32) as u8
2901 }
2902 # [ doc = "Bit 6 - Port input data (y = 0..15)" ]
2903 pub fn idr6(&self) -> Idr6R {
2904 Idr6R { bits: self._idr6() }
2905 }
2906 fn _idr5(&self) -> u8 {
2907 const MASK: u8 = 1;
2908 const OFFSET: u8 = 5;
2909 ((self.bits >> OFFSET) & MASK as u32) as u8
2910 }
2911 # [ doc = "Bit 5 - Port input data (y = 0..15)" ]
2912 pub fn idr5(&self) -> Idr5R {
2913 Idr5R { bits: self._idr5() }
2914 }
2915 fn _idr4(&self) -> u8 {
2916 const MASK: u8 = 1;
2917 const OFFSET: u8 = 4;
2918 ((self.bits >> OFFSET) & MASK as u32) as u8
2919 }
2920 # [ doc = "Bit 4 - Port input data (y = 0..15)" ]
2921 pub fn idr4(&self) -> Idr4R {
2922 Idr4R { bits: self._idr4() }
2923 }
2924 fn _idr3(&self) -> u8 {
2925 const MASK: u8 = 1;
2926 const OFFSET: u8 = 3;
2927 ((self.bits >> OFFSET) & MASK as u32) as u8
2928 }
2929 # [ doc = "Bit 3 - Port input data (y = 0..15)" ]
2930 pub fn idr3(&self) -> Idr3R {
2931 Idr3R { bits: self._idr3() }
2932 }
2933 fn _idr2(&self) -> u8 {
2934 const MASK: u8 = 1;
2935 const OFFSET: u8 = 2;
2936 ((self.bits >> OFFSET) & MASK as u32) as u8
2937 }
2938 # [ doc = "Bit 2 - Port input data (y = 0..15)" ]
2939 pub fn idr2(&self) -> Idr2R {
2940 Idr2R { bits: self._idr2() }
2941 }
2942 fn _idr1(&self) -> u8 {
2943 const MASK: u8 = 1;
2944 const OFFSET: u8 = 1;
2945 ((self.bits >> OFFSET) & MASK as u32) as u8
2946 }
2947 # [ doc = "Bit 1 - Port input data (y = 0..15)" ]
2948 pub fn idr1(&self) -> Idr1R {
2949 Idr1R { bits: self._idr1() }
2950 }
2951 fn _idr0(&self) -> u8 {
2952 const MASK: u8 = 1;
2953 const OFFSET: u8 = 0;
2954 ((self.bits >> OFFSET) & MASK as u32) as u8
2955 }
2956 # [ doc = "Bit 0 - Port input data (y = 0..15)" ]
2957 pub fn idr0(&self) -> Idr0R {
2958 Idr0R { bits: self._idr0() }
2959 }
2960 }
2961}
2962
2963# [ doc = "GPIO port output data register" ]
2964# [ repr ( C ) ]
2965pub struct Odr {
2966 register: ::volatile_register::RW<u32>,
2967}
2968
2969# [ doc = "GPIO port output data register" ]
2970pub mod odr {
2971 # [ doc = r" Value read from the register" ]
2972 pub struct R {
2973 bits: u32,
2974 }
2975 # [ doc = r" Value to write to the register" ]
2976 pub struct W {
2977 bits: u32,
2978 }
2979 impl super::Odr {
2980 # [ doc = r" Modifies the contents of the register" ]
2981 pub fn modify<F>(&mut self, f: F)
2982 where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W
2983 {
2984 let bits = self.register.read();
2985 let r = R { bits: bits };
2986 let mut w = W { bits: bits };
2987 f(&r, &mut w);
2988 self.register.write(w.bits);
2989 }
2990 # [ doc = r" Reads the contents of the register" ]
2991 pub fn read(&self) -> R {
2992 R { bits: self.register.read() }
2993 }
2994 # [ doc = r" Writes to the register" ]
2995 pub fn write<F>(&mut self, f: F)
2996 where F: FnOnce(&mut W) -> &mut W
2997 {
2998 let mut w = W::reset_value();
2999 f(&mut w);
3000 self.register.write(w.bits);
3001 }
3002 }
3003 # [ doc = "Value of the field ODR15" ]
3004 pub struct Odr15R {
3005 bits: u8,
3006 }
3007 impl Odr15R {
3008 # [ doc = r" Value of the field as raw bits" ]
3009 pub fn bits(&self) -> u8 {
3010 self.bits
3011 }
3012 }
3013 # [ doc = "Value of the field ODR14" ]
3014 pub struct Odr14R {
3015 bits: u8,
3016 }
3017 impl Odr14R {
3018 # [ doc = r" Value of the field as raw bits" ]
3019 pub fn bits(&self) -> u8 {
3020 self.bits
3021 }
3022 }
3023 # [ doc = "Value of the field ODR13" ]
3024 pub struct Odr13R {
3025 bits: u8,
3026 }
3027 impl Odr13R {
3028 # [ doc = r" Value of the field as raw bits" ]
3029 pub fn bits(&self) -> u8 {
3030 self.bits
3031 }
3032 }
3033 # [ doc = "Value of the field ODR12" ]
3034 pub struct Odr12R {
3035 bits: u8,
3036 }
3037 impl Odr12R {
3038 # [ doc = r" Value of the field as raw bits" ]
3039 pub fn bits(&self) -> u8 {
3040 self.bits
3041 }
3042 }
3043 # [ doc = "Value of the field ODR11" ]
3044 pub struct Odr11R {
3045 bits: u8,
3046 }
3047 impl Odr11R {
3048 # [ doc = r" Value of the field as raw bits" ]
3049 pub fn bits(&self) -> u8 {
3050 self.bits
3051 }
3052 }
3053 # [ doc = "Value of the field ODR10" ]
3054 pub struct Odr10R {
3055 bits: u8,
3056 }
3057 impl Odr10R {
3058 # [ doc = r" Value of the field as raw bits" ]
3059 pub fn bits(&self) -> u8 {
3060 self.bits
3061 }
3062 }
3063 # [ doc = "Value of the field ODR9" ]
3064 pub struct Odr9R {
3065 bits: u8,
3066 }
3067 impl Odr9R {
3068 # [ doc = r" Value of the field as raw bits" ]
3069 pub fn bits(&self) -> u8 {
3070 self.bits
3071 }
3072 }
3073 # [ doc = "Value of the field ODR8" ]
3074 pub struct Odr8R {
3075 bits: u8,
3076 }
3077 impl Odr8R {
3078 # [ doc = r" Value of the field as raw bits" ]
3079 pub fn bits(&self) -> u8 {
3080 self.bits
3081 }
3082 }
3083 # [ doc = "Value of the field ODR7" ]
3084 pub struct Odr7R {
3085 bits: u8,
3086 }
3087 impl Odr7R {
3088 # [ doc = r" Value of the field as raw bits" ]
3089 pub fn bits(&self) -> u8 {
3090 self.bits
3091 }
3092 }
3093 # [ doc = "Value of the field ODR6" ]
3094 pub struct Odr6R {
3095 bits: u8,
3096 }
3097 impl Odr6R {
3098 # [ doc = r" Value of the field as raw bits" ]
3099 pub fn bits(&self) -> u8 {
3100 self.bits
3101 }
3102 }
3103 # [ doc = "Value of the field ODR5" ]
3104 pub struct Odr5R {
3105 bits: u8,
3106 }
3107 impl Odr5R {
3108 # [ doc = r" Value of the field as raw bits" ]
3109 pub fn bits(&self) -> u8 {
3110 self.bits
3111 }
3112 }
3113 # [ doc = "Value of the field ODR4" ]
3114 pub struct Odr4R {
3115 bits: u8,
3116 }
3117 impl Odr4R {
3118 # [ doc = r" Value of the field as raw bits" ]
3119 pub fn bits(&self) -> u8 {
3120 self.bits
3121 }
3122 }
3123 # [ doc = "Value of the field ODR3" ]
3124 pub struct Odr3R {
3125 bits: u8,
3126 }
3127 impl Odr3R {
3128 # [ doc = r" Value of the field as raw bits" ]
3129 pub fn bits(&self) -> u8 {
3130 self.bits
3131 }
3132 }
3133 # [ doc = "Value of the field ODR2" ]
3134 pub struct Odr2R {
3135 bits: u8,
3136 }
3137 impl Odr2R {
3138 # [ doc = r" Value of the field as raw bits" ]
3139 pub fn bits(&self) -> u8 {
3140 self.bits
3141 }
3142 }
3143 # [ doc = "Value of the field ODR1" ]
3144 pub struct Odr1R {
3145 bits: u8,
3146 }
3147 impl Odr1R {
3148 # [ doc = r" Value of the field as raw bits" ]
3149 pub fn bits(&self) -> u8 {
3150 self.bits
3151 }
3152 }
3153 # [ doc = "Value of the field ODR0" ]
3154 pub struct Odr0R {
3155 bits: u8,
3156 }
3157 impl Odr0R {
3158 # [ doc = r" Value of the field as raw bits" ]
3159 pub fn bits(&self) -> u8 {
3160 self.bits
3161 }
3162 }
3163 # [ doc = r" Proxy" ]
3164 pub struct _Odr15W<'a> {
3165 register: &'a mut W,
3166 }
3167 impl<'a> _Odr15W<'a> {
3168 # [ doc = r" Writes raw `bits` to the field" ]
3169 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3170 const MASK: u8 = 1;
3171 const OFFSET: u8 = 15;
3172 self.register.bits &= !((MASK as u32) << OFFSET);
3173 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3174 self.register
3175 }
3176 }
3177 # [ doc = r" Proxy" ]
3178 pub struct _Odr14W<'a> {
3179 register: &'a mut W,
3180 }
3181 impl<'a> _Odr14W<'a> {
3182 # [ doc = r" Writes raw `bits` to the field" ]
3183 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3184 const MASK: u8 = 1;
3185 const OFFSET: u8 = 14;
3186 self.register.bits &= !((MASK as u32) << OFFSET);
3187 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3188 self.register
3189 }
3190 }
3191 # [ doc = r" Proxy" ]
3192 pub struct _Odr13W<'a> {
3193 register: &'a mut W,
3194 }
3195 impl<'a> _Odr13W<'a> {
3196 # [ doc = r" Writes raw `bits` to the field" ]
3197 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3198 const MASK: u8 = 1;
3199 const OFFSET: u8 = 13;
3200 self.register.bits &= !((MASK as u32) << OFFSET);
3201 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3202 self.register
3203 }
3204 }
3205 # [ doc = r" Proxy" ]
3206 pub struct _Odr12W<'a> {
3207 register: &'a mut W,
3208 }
3209 impl<'a> _Odr12W<'a> {
3210 # [ doc = r" Writes raw `bits` to the field" ]
3211 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3212 const MASK: u8 = 1;
3213 const OFFSET: u8 = 12;
3214 self.register.bits &= !((MASK as u32) << OFFSET);
3215 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3216 self.register
3217 }
3218 }
3219 # [ doc = r" Proxy" ]
3220 pub struct _Odr11W<'a> {
3221 register: &'a mut W,
3222 }
3223 impl<'a> _Odr11W<'a> {
3224 # [ doc = r" Writes raw `bits` to the field" ]
3225 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3226 const MASK: u8 = 1;
3227 const OFFSET: u8 = 11;
3228 self.register.bits &= !((MASK as u32) << OFFSET);
3229 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3230 self.register
3231 }
3232 }
3233 # [ doc = r" Proxy" ]
3234 pub struct _Odr10W<'a> {
3235 register: &'a mut W,
3236 }
3237 impl<'a> _Odr10W<'a> {
3238 # [ doc = r" Writes raw `bits` to the field" ]
3239 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3240 const MASK: u8 = 1;
3241 const OFFSET: u8 = 10;
3242 self.register.bits &= !((MASK as u32) << OFFSET);
3243 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3244 self.register
3245 }
3246 }
3247 # [ doc = r" Proxy" ]
3248 pub struct _Odr9W<'a> {
3249 register: &'a mut W,
3250 }
3251 impl<'a> _Odr9W<'a> {
3252 # [ doc = r" Writes raw `bits` to the field" ]
3253 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3254 const MASK: u8 = 1;
3255 const OFFSET: u8 = 9;
3256 self.register.bits &= !((MASK as u32) << OFFSET);
3257 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3258 self.register
3259 }
3260 }
3261 # [ doc = r" Proxy" ]
3262 pub struct _Odr8W<'a> {
3263 register: &'a mut W,
3264 }
3265 impl<'a> _Odr8W<'a> {
3266 # [ doc = r" Writes raw `bits` to the field" ]
3267 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3268 const MASK: u8 = 1;
3269 const OFFSET: u8 = 8;
3270 self.register.bits &= !((MASK as u32) << OFFSET);
3271 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3272 self.register
3273 }
3274 }
3275 # [ doc = r" Proxy" ]
3276 pub struct _Odr7W<'a> {
3277 register: &'a mut W,
3278 }
3279 impl<'a> _Odr7W<'a> {
3280 # [ doc = r" Writes raw `bits` to the field" ]
3281 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3282 const MASK: u8 = 1;
3283 const OFFSET: u8 = 7;
3284 self.register.bits &= !((MASK as u32) << OFFSET);
3285 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3286 self.register
3287 }
3288 }
3289 # [ doc = r" Proxy" ]
3290 pub struct _Odr6W<'a> {
3291 register: &'a mut W,
3292 }
3293 impl<'a> _Odr6W<'a> {
3294 # [ doc = r" Writes raw `bits` to the field" ]
3295 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3296 const MASK: u8 = 1;
3297 const OFFSET: u8 = 6;
3298 self.register.bits &= !((MASK as u32) << OFFSET);
3299 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3300 self.register
3301 }
3302 }
3303 # [ doc = r" Proxy" ]
3304 pub struct _Odr5W<'a> {
3305 register: &'a mut W,
3306 }
3307 impl<'a> _Odr5W<'a> {
3308 # [ doc = r" Writes raw `bits` to the field" ]
3309 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3310 const MASK: u8 = 1;
3311 const OFFSET: u8 = 5;
3312 self.register.bits &= !((MASK as u32) << OFFSET);
3313 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3314 self.register
3315 }
3316 }
3317 # [ doc = r" Proxy" ]
3318 pub struct _Odr4W<'a> {
3319 register: &'a mut W,
3320 }
3321 impl<'a> _Odr4W<'a> {
3322 # [ doc = r" Writes raw `bits` to the field" ]
3323 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3324 const MASK: u8 = 1;
3325 const OFFSET: u8 = 4;
3326 self.register.bits &= !((MASK as u32) << OFFSET);
3327 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3328 self.register
3329 }
3330 }
3331 # [ doc = r" Proxy" ]
3332 pub struct _Odr3W<'a> {
3333 register: &'a mut W,
3334 }
3335 impl<'a> _Odr3W<'a> {
3336 # [ doc = r" Writes raw `bits` to the field" ]
3337 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3338 const MASK: u8 = 1;
3339 const OFFSET: u8 = 3;
3340 self.register.bits &= !((MASK as u32) << OFFSET);
3341 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3342 self.register
3343 }
3344 }
3345 # [ doc = r" Proxy" ]
3346 pub struct _Odr2W<'a> {
3347 register: &'a mut W,
3348 }
3349 impl<'a> _Odr2W<'a> {
3350 # [ doc = r" Writes raw `bits` to the field" ]
3351 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3352 const MASK: u8 = 1;
3353 const OFFSET: u8 = 2;
3354 self.register.bits &= !((MASK as u32) << OFFSET);
3355 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3356 self.register
3357 }
3358 }
3359 # [ doc = r" Proxy" ]
3360 pub struct _Odr1W<'a> {
3361 register: &'a mut W,
3362 }
3363 impl<'a> _Odr1W<'a> {
3364 # [ doc = r" Writes raw `bits` to the field" ]
3365 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3366 const MASK: u8 = 1;
3367 const OFFSET: u8 = 1;
3368 self.register.bits &= !((MASK as u32) << OFFSET);
3369 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3370 self.register
3371 }
3372 }
3373 # [ doc = r" Proxy" ]
3374 pub struct _Odr0W<'a> {
3375 register: &'a mut W,
3376 }
3377 impl<'a> _Odr0W<'a> {
3378 # [ doc = r" Writes raw `bits` to the field" ]
3379 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3380 const MASK: u8 = 1;
3381 const OFFSET: u8 = 0;
3382 self.register.bits &= !((MASK as u32) << OFFSET);
3383 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3384 self.register
3385 }
3386 }
3387 impl R {
3388 # [ doc = r" Value of the register as raw bits" ]
3389 pub fn bits(&self) -> u32 {
3390 self.bits
3391 }
3392 fn _odr15(&self) -> u8 {
3393 const MASK: u8 = 1;
3394 const OFFSET: u8 = 15;
3395 ((self.bits >> OFFSET) & MASK as u32) as u8
3396 }
3397 # [ doc = "Bit 15 - Port output data (y = 0..15)" ]
3398 pub fn odr15(&self) -> Odr15R {
3399 Odr15R { bits: self._odr15() }
3400 }
3401 fn _odr14(&self) -> u8 {
3402 const MASK: u8 = 1;
3403 const OFFSET: u8 = 14;
3404 ((self.bits >> OFFSET) & MASK as u32) as u8
3405 }
3406 # [ doc = "Bit 14 - Port output data (y = 0..15)" ]
3407 pub fn odr14(&self) -> Odr14R {
3408 Odr14R { bits: self._odr14() }
3409 }
3410 fn _odr13(&self) -> u8 {
3411 const MASK: u8 = 1;
3412 const OFFSET: u8 = 13;
3413 ((self.bits >> OFFSET) & MASK as u32) as u8
3414 }
3415 # [ doc = "Bit 13 - Port output data (y = 0..15)" ]
3416 pub fn odr13(&self) -> Odr13R {
3417 Odr13R { bits: self._odr13() }
3418 }
3419 fn _odr12(&self) -> u8 {
3420 const MASK: u8 = 1;
3421 const OFFSET: u8 = 12;
3422 ((self.bits >> OFFSET) & MASK as u32) as u8
3423 }
3424 # [ doc = "Bit 12 - Port output data (y = 0..15)" ]
3425 pub fn odr12(&self) -> Odr12R {
3426 Odr12R { bits: self._odr12() }
3427 }
3428 fn _odr11(&self) -> u8 {
3429 const MASK: u8 = 1;
3430 const OFFSET: u8 = 11;
3431 ((self.bits >> OFFSET) & MASK as u32) as u8
3432 }
3433 # [ doc = "Bit 11 - Port output data (y = 0..15)" ]
3434 pub fn odr11(&self) -> Odr11R {
3435 Odr11R { bits: self._odr11() }
3436 }
3437 fn _odr10(&self) -> u8 {
3438 const MASK: u8 = 1;
3439 const OFFSET: u8 = 10;
3440 ((self.bits >> OFFSET) & MASK as u32) as u8
3441 }
3442 # [ doc = "Bit 10 - Port output data (y = 0..15)" ]
3443 pub fn odr10(&self) -> Odr10R {
3444 Odr10R { bits: self._odr10() }
3445 }
3446 fn _odr9(&self) -> u8 {
3447 const MASK: u8 = 1;
3448 const OFFSET: u8 = 9;
3449 ((self.bits >> OFFSET) & MASK as u32) as u8
3450 }
3451 # [ doc = "Bit 9 - Port output data (y = 0..15)" ]
3452 pub fn odr9(&self) -> Odr9R {
3453 Odr9R { bits: self._odr9() }
3454 }
3455 fn _odr8(&self) -> u8 {
3456 const MASK: u8 = 1;
3457 const OFFSET: u8 = 8;
3458 ((self.bits >> OFFSET) & MASK as u32) as u8
3459 }
3460 # [ doc = "Bit 8 - Port output data (y = 0..15)" ]
3461 pub fn odr8(&self) -> Odr8R {
3462 Odr8R { bits: self._odr8() }
3463 }
3464 fn _odr7(&self) -> u8 {
3465 const MASK: u8 = 1;
3466 const OFFSET: u8 = 7;
3467 ((self.bits >> OFFSET) & MASK as u32) as u8
3468 }
3469 # [ doc = "Bit 7 - Port output data (y = 0..15)" ]
3470 pub fn odr7(&self) -> Odr7R {
3471 Odr7R { bits: self._odr7() }
3472 }
3473 fn _odr6(&self) -> u8 {
3474 const MASK: u8 = 1;
3475 const OFFSET: u8 = 6;
3476 ((self.bits >> OFFSET) & MASK as u32) as u8
3477 }
3478 # [ doc = "Bit 6 - Port output data (y = 0..15)" ]
3479 pub fn odr6(&self) -> Odr6R {
3480 Odr6R { bits: self._odr6() }
3481 }
3482 fn _odr5(&self) -> u8 {
3483 const MASK: u8 = 1;
3484 const OFFSET: u8 = 5;
3485 ((self.bits >> OFFSET) & MASK as u32) as u8
3486 }
3487 # [ doc = "Bit 5 - Port output data (y = 0..15)" ]
3488 pub fn odr5(&self) -> Odr5R {
3489 Odr5R { bits: self._odr5() }
3490 }
3491 fn _odr4(&self) -> u8 {
3492 const MASK: u8 = 1;
3493 const OFFSET: u8 = 4;
3494 ((self.bits >> OFFSET) & MASK as u32) as u8
3495 }
3496 # [ doc = "Bit 4 - Port output data (y = 0..15)" ]
3497 pub fn odr4(&self) -> Odr4R {
3498 Odr4R { bits: self._odr4() }
3499 }
3500 fn _odr3(&self) -> u8 {
3501 const MASK: u8 = 1;
3502 const OFFSET: u8 = 3;
3503 ((self.bits >> OFFSET) & MASK as u32) as u8
3504 }
3505 # [ doc = "Bit 3 - Port output data (y = 0..15)" ]
3506 pub fn odr3(&self) -> Odr3R {
3507 Odr3R { bits: self._odr3() }
3508 }
3509 fn _odr2(&self) -> u8 {
3510 const MASK: u8 = 1;
3511 const OFFSET: u8 = 2;
3512 ((self.bits >> OFFSET) & MASK as u32) as u8
3513 }
3514 # [ doc = "Bit 2 - Port output data (y = 0..15)" ]
3515 pub fn odr2(&self) -> Odr2R {
3516 Odr2R { bits: self._odr2() }
3517 }
3518 fn _odr1(&self) -> u8 {
3519 const MASK: u8 = 1;
3520 const OFFSET: u8 = 1;
3521 ((self.bits >> OFFSET) & MASK as u32) as u8
3522 }
3523 # [ doc = "Bit 1 - Port output data (y = 0..15)" ]
3524 pub fn odr1(&self) -> Odr1R {
3525 Odr1R { bits: self._odr1() }
3526 }
3527 fn _odr0(&self) -> u8 {
3528 const MASK: u8 = 1;
3529 const OFFSET: u8 = 0;
3530 ((self.bits >> OFFSET) & MASK as u32) as u8
3531 }
3532 # [ doc = "Bit 0 - Port output data (y = 0..15)" ]
3533 pub fn odr0(&self) -> Odr0R {
3534 Odr0R { bits: self._odr0() }
3535 }
3536 }
3537 impl W {
3538 # [ doc = r" Reset value of the register" ]
3539 pub fn reset_value() -> W {
3540 W { bits: 0 }
3541 }
3542 # [ doc = r" Writes raw `bits` to the register" ]
3543 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
3544 self.bits = bits;
3545 self
3546 }
3547 # [ doc = "Bit 15 - Port output data (y = 0..15)" ]
3548 pub fn odr15(&mut self) -> _Odr15W {
3549 _Odr15W { register: self }
3550 }
3551 # [ doc = "Bit 14 - Port output data (y = 0..15)" ]
3552 pub fn odr14(&mut self) -> _Odr14W {
3553 _Odr14W { register: self }
3554 }
3555 # [ doc = "Bit 13 - Port output data (y = 0..15)" ]
3556 pub fn odr13(&mut self) -> _Odr13W {
3557 _Odr13W { register: self }
3558 }
3559 # [ doc = "Bit 12 - Port output data (y = 0..15)" ]
3560 pub fn odr12(&mut self) -> _Odr12W {
3561 _Odr12W { register: self }
3562 }
3563 # [ doc = "Bit 11 - Port output data (y = 0..15)" ]
3564 pub fn odr11(&mut self) -> _Odr11W {
3565 _Odr11W { register: self }
3566 }
3567 # [ doc = "Bit 10 - Port output data (y = 0..15)" ]
3568 pub fn odr10(&mut self) -> _Odr10W {
3569 _Odr10W { register: self }
3570 }
3571 # [ doc = "Bit 9 - Port output data (y = 0..15)" ]
3572 pub fn odr9(&mut self) -> _Odr9W {
3573 _Odr9W { register: self }
3574 }
3575 # [ doc = "Bit 8 - Port output data (y = 0..15)" ]
3576 pub fn odr8(&mut self) -> _Odr8W {
3577 _Odr8W { register: self }
3578 }
3579 # [ doc = "Bit 7 - Port output data (y = 0..15)" ]
3580 pub fn odr7(&mut self) -> _Odr7W {
3581 _Odr7W { register: self }
3582 }
3583 # [ doc = "Bit 6 - Port output data (y = 0..15)" ]
3584 pub fn odr6(&mut self) -> _Odr6W {
3585 _Odr6W { register: self }
3586 }
3587 # [ doc = "Bit 5 - Port output data (y = 0..15)" ]
3588 pub fn odr5(&mut self) -> _Odr5W {
3589 _Odr5W { register: self }
3590 }
3591 # [ doc = "Bit 4 - Port output data (y = 0..15)" ]
3592 pub fn odr4(&mut self) -> _Odr4W {
3593 _Odr4W { register: self }
3594 }
3595 # [ doc = "Bit 3 - Port output data (y = 0..15)" ]
3596 pub fn odr3(&mut self) -> _Odr3W {
3597 _Odr3W { register: self }
3598 }
3599 # [ doc = "Bit 2 - Port output data (y = 0..15)" ]
3600 pub fn odr2(&mut self) -> _Odr2W {
3601 _Odr2W { register: self }
3602 }
3603 # [ doc = "Bit 1 - Port output data (y = 0..15)" ]
3604 pub fn odr1(&mut self) -> _Odr1W {
3605 _Odr1W { register: self }
3606 }
3607 # [ doc = "Bit 0 - Port output data (y = 0..15)" ]
3608 pub fn odr0(&mut self) -> _Odr0W {
3609 _Odr0W { register: self }
3610 }
3611 }
3612}
3613
3614# [ doc = "GPIO port bit set/reset register" ]
3615# [ repr ( C ) ]
3616pub struct Bsrr {
3617 register: ::volatile_register::WO<u32>,
3618}
3619
3620# [ doc = "GPIO port bit set/reset register" ]
3621pub mod bsrr {
3622 # [ doc = r" Value to write to the register" ]
3623 pub struct W {
3624 bits: u32,
3625 }
3626 impl super::Bsrr {
3627 # [ doc = r" Writes to the register" ]
3628 pub fn write<F>(&mut self, f: F)
3629 where F: FnOnce(&mut W) -> &mut W
3630 {
3631 let mut w = W::reset_value();
3632 f(&mut w);
3633 self.register.write(w.bits);
3634 }
3635 }
3636 # [ doc = r" Proxy" ]
3637 pub struct _Br15W<'a> {
3638 register: &'a mut W,
3639 }
3640 impl<'a> _Br15W<'a> {
3641 # [ doc = r" Writes raw `bits` to the field" ]
3642 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3643 const MASK: u8 = 1;
3644 const OFFSET: u8 = 31;
3645 self.register.bits &= !((MASK as u32) << OFFSET);
3646 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3647 self.register
3648 }
3649 }
3650 # [ doc = r" Proxy" ]
3651 pub struct _Br14W<'a> {
3652 register: &'a mut W,
3653 }
3654 impl<'a> _Br14W<'a> {
3655 # [ doc = r" Writes raw `bits` to the field" ]
3656 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3657 const MASK: u8 = 1;
3658 const OFFSET: u8 = 30;
3659 self.register.bits &= !((MASK as u32) << OFFSET);
3660 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3661 self.register
3662 }
3663 }
3664 # [ doc = r" Proxy" ]
3665 pub struct _Br13W<'a> {
3666 register: &'a mut W,
3667 }
3668 impl<'a> _Br13W<'a> {
3669 # [ doc = r" Writes raw `bits` to the field" ]
3670 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3671 const MASK: u8 = 1;
3672 const OFFSET: u8 = 29;
3673 self.register.bits &= !((MASK as u32) << OFFSET);
3674 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3675 self.register
3676 }
3677 }
3678 # [ doc = r" Proxy" ]
3679 pub struct _Br12W<'a> {
3680 register: &'a mut W,
3681 }
3682 impl<'a> _Br12W<'a> {
3683 # [ doc = r" Writes raw `bits` to the field" ]
3684 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3685 const MASK: u8 = 1;
3686 const OFFSET: u8 = 28;
3687 self.register.bits &= !((MASK as u32) << OFFSET);
3688 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3689 self.register
3690 }
3691 }
3692 # [ doc = r" Proxy" ]
3693 pub struct _Br11W<'a> {
3694 register: &'a mut W,
3695 }
3696 impl<'a> _Br11W<'a> {
3697 # [ doc = r" Writes raw `bits` to the field" ]
3698 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3699 const MASK: u8 = 1;
3700 const OFFSET: u8 = 27;
3701 self.register.bits &= !((MASK as u32) << OFFSET);
3702 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3703 self.register
3704 }
3705 }
3706 # [ doc = r" Proxy" ]
3707 pub struct _Br10W<'a> {
3708 register: &'a mut W,
3709 }
3710 impl<'a> _Br10W<'a> {
3711 # [ doc = r" Writes raw `bits` to the field" ]
3712 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3713 const MASK: u8 = 1;
3714 const OFFSET: u8 = 26;
3715 self.register.bits &= !((MASK as u32) << OFFSET);
3716 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3717 self.register
3718 }
3719 }
3720 # [ doc = r" Proxy" ]
3721 pub struct _Br9W<'a> {
3722 register: &'a mut W,
3723 }
3724 impl<'a> _Br9W<'a> {
3725 # [ doc = r" Writes raw `bits` to the field" ]
3726 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3727 const MASK: u8 = 1;
3728 const OFFSET: u8 = 25;
3729 self.register.bits &= !((MASK as u32) << OFFSET);
3730 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3731 self.register
3732 }
3733 }
3734 # [ doc = r" Proxy" ]
3735 pub struct _Br8W<'a> {
3736 register: &'a mut W,
3737 }
3738 impl<'a> _Br8W<'a> {
3739 # [ doc = r" Writes raw `bits` to the field" ]
3740 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3741 const MASK: u8 = 1;
3742 const OFFSET: u8 = 24;
3743 self.register.bits &= !((MASK as u32) << OFFSET);
3744 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3745 self.register
3746 }
3747 }
3748 # [ doc = r" Proxy" ]
3749 pub struct _Br7W<'a> {
3750 register: &'a mut W,
3751 }
3752 impl<'a> _Br7W<'a> {
3753 # [ doc = r" Writes raw `bits` to the field" ]
3754 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3755 const MASK: u8 = 1;
3756 const OFFSET: u8 = 23;
3757 self.register.bits &= !((MASK as u32) << OFFSET);
3758 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3759 self.register
3760 }
3761 }
3762 # [ doc = r" Proxy" ]
3763 pub struct _Br6W<'a> {
3764 register: &'a mut W,
3765 }
3766 impl<'a> _Br6W<'a> {
3767 # [ doc = r" Writes raw `bits` to the field" ]
3768 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3769 const MASK: u8 = 1;
3770 const OFFSET: u8 = 22;
3771 self.register.bits &= !((MASK as u32) << OFFSET);
3772 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3773 self.register
3774 }
3775 }
3776 # [ doc = r" Proxy" ]
3777 pub struct _Br5W<'a> {
3778 register: &'a mut W,
3779 }
3780 impl<'a> _Br5W<'a> {
3781 # [ doc = r" Writes raw `bits` to the field" ]
3782 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3783 const MASK: u8 = 1;
3784 const OFFSET: u8 = 21;
3785 self.register.bits &= !((MASK as u32) << OFFSET);
3786 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3787 self.register
3788 }
3789 }
3790 # [ doc = r" Proxy" ]
3791 pub struct _Br4W<'a> {
3792 register: &'a mut W,
3793 }
3794 impl<'a> _Br4W<'a> {
3795 # [ doc = r" Writes raw `bits` to the field" ]
3796 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3797 const MASK: u8 = 1;
3798 const OFFSET: u8 = 20;
3799 self.register.bits &= !((MASK as u32) << OFFSET);
3800 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3801 self.register
3802 }
3803 }
3804 # [ doc = r" Proxy" ]
3805 pub struct _Br3W<'a> {
3806 register: &'a mut W,
3807 }
3808 impl<'a> _Br3W<'a> {
3809 # [ doc = r" Writes raw `bits` to the field" ]
3810 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3811 const MASK: u8 = 1;
3812 const OFFSET: u8 = 19;
3813 self.register.bits &= !((MASK as u32) << OFFSET);
3814 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3815 self.register
3816 }
3817 }
3818 # [ doc = r" Proxy" ]
3819 pub struct _Br2W<'a> {
3820 register: &'a mut W,
3821 }
3822 impl<'a> _Br2W<'a> {
3823 # [ doc = r" Writes raw `bits` to the field" ]
3824 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3825 const MASK: u8 = 1;
3826 const OFFSET: u8 = 18;
3827 self.register.bits &= !((MASK as u32) << OFFSET);
3828 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3829 self.register
3830 }
3831 }
3832 # [ doc = r" Proxy" ]
3833 pub struct _Br1W<'a> {
3834 register: &'a mut W,
3835 }
3836 impl<'a> _Br1W<'a> {
3837 # [ doc = r" Writes raw `bits` to the field" ]
3838 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3839 const MASK: u8 = 1;
3840 const OFFSET: u8 = 17;
3841 self.register.bits &= !((MASK as u32) << OFFSET);
3842 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3843 self.register
3844 }
3845 }
3846 # [ doc = r" Proxy" ]
3847 pub struct _Br0W<'a> {
3848 register: &'a mut W,
3849 }
3850 impl<'a> _Br0W<'a> {
3851 # [ doc = r" Writes raw `bits` to the field" ]
3852 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3853 const MASK: u8 = 1;
3854 const OFFSET: u8 = 16;
3855 self.register.bits &= !((MASK as u32) << OFFSET);
3856 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3857 self.register
3858 }
3859 }
3860 # [ doc = r" Proxy" ]
3861 pub struct _Bs15W<'a> {
3862 register: &'a mut W,
3863 }
3864 impl<'a> _Bs15W<'a> {
3865 # [ doc = r" Writes raw `bits` to the field" ]
3866 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3867 const MASK: u8 = 1;
3868 const OFFSET: u8 = 15;
3869 self.register.bits &= !((MASK as u32) << OFFSET);
3870 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3871 self.register
3872 }
3873 }
3874 # [ doc = r" Proxy" ]
3875 pub struct _Bs14W<'a> {
3876 register: &'a mut W,
3877 }
3878 impl<'a> _Bs14W<'a> {
3879 # [ doc = r" Writes raw `bits` to the field" ]
3880 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3881 const MASK: u8 = 1;
3882 const OFFSET: u8 = 14;
3883 self.register.bits &= !((MASK as u32) << OFFSET);
3884 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3885 self.register
3886 }
3887 }
3888 # [ doc = r" Proxy" ]
3889 pub struct _Bs13W<'a> {
3890 register: &'a mut W,
3891 }
3892 impl<'a> _Bs13W<'a> {
3893 # [ doc = r" Writes raw `bits` to the field" ]
3894 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3895 const MASK: u8 = 1;
3896 const OFFSET: u8 = 13;
3897 self.register.bits &= !((MASK as u32) << OFFSET);
3898 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3899 self.register
3900 }
3901 }
3902 # [ doc = r" Proxy" ]
3903 pub struct _Bs12W<'a> {
3904 register: &'a mut W,
3905 }
3906 impl<'a> _Bs12W<'a> {
3907 # [ doc = r" Writes raw `bits` to the field" ]
3908 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3909 const MASK: u8 = 1;
3910 const OFFSET: u8 = 12;
3911 self.register.bits &= !((MASK as u32) << OFFSET);
3912 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3913 self.register
3914 }
3915 }
3916 # [ doc = r" Proxy" ]
3917 pub struct _Bs11W<'a> {
3918 register: &'a mut W,
3919 }
3920 impl<'a> _Bs11W<'a> {
3921 # [ doc = r" Writes raw `bits` to the field" ]
3922 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3923 const MASK: u8 = 1;
3924 const OFFSET: u8 = 11;
3925 self.register.bits &= !((MASK as u32) << OFFSET);
3926 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3927 self.register
3928 }
3929 }
3930 # [ doc = r" Proxy" ]
3931 pub struct _Bs10W<'a> {
3932 register: &'a mut W,
3933 }
3934 impl<'a> _Bs10W<'a> {
3935 # [ doc = r" Writes raw `bits` to the field" ]
3936 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3937 const MASK: u8 = 1;
3938 const OFFSET: u8 = 10;
3939 self.register.bits &= !((MASK as u32) << OFFSET);
3940 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3941 self.register
3942 }
3943 }
3944 # [ doc = r" Proxy" ]
3945 pub struct _Bs9W<'a> {
3946 register: &'a mut W,
3947 }
3948 impl<'a> _Bs9W<'a> {
3949 # [ doc = r" Writes raw `bits` to the field" ]
3950 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3951 const MASK: u8 = 1;
3952 const OFFSET: u8 = 9;
3953 self.register.bits &= !((MASK as u32) << OFFSET);
3954 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3955 self.register
3956 }
3957 }
3958 # [ doc = r" Proxy" ]
3959 pub struct _Bs8W<'a> {
3960 register: &'a mut W,
3961 }
3962 impl<'a> _Bs8W<'a> {
3963 # [ doc = r" Writes raw `bits` to the field" ]
3964 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3965 const MASK: u8 = 1;
3966 const OFFSET: u8 = 8;
3967 self.register.bits &= !((MASK as u32) << OFFSET);
3968 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3969 self.register
3970 }
3971 }
3972 # [ doc = r" Proxy" ]
3973 pub struct _Bs7W<'a> {
3974 register: &'a mut W,
3975 }
3976 impl<'a> _Bs7W<'a> {
3977 # [ doc = r" Writes raw `bits` to the field" ]
3978 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3979 const MASK: u8 = 1;
3980 const OFFSET: u8 = 7;
3981 self.register.bits &= !((MASK as u32) << OFFSET);
3982 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3983 self.register
3984 }
3985 }
3986 # [ doc = r" Proxy" ]
3987 pub struct _Bs6W<'a> {
3988 register: &'a mut W,
3989 }
3990 impl<'a> _Bs6W<'a> {
3991 # [ doc = r" Writes raw `bits` to the field" ]
3992 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
3993 const MASK: u8 = 1;
3994 const OFFSET: u8 = 6;
3995 self.register.bits &= !((MASK as u32) << OFFSET);
3996 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
3997 self.register
3998 }
3999 }
4000 # [ doc = r" Proxy" ]
4001 pub struct _Bs5W<'a> {
4002 register: &'a mut W,
4003 }
4004 impl<'a> _Bs5W<'a> {
4005 # [ doc = r" Writes raw `bits` to the field" ]
4006 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4007 const MASK: u8 = 1;
4008 const OFFSET: u8 = 5;
4009 self.register.bits &= !((MASK as u32) << OFFSET);
4010 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4011 self.register
4012 }
4013 }
4014 # [ doc = r" Proxy" ]
4015 pub struct _Bs4W<'a> {
4016 register: &'a mut W,
4017 }
4018 impl<'a> _Bs4W<'a> {
4019 # [ doc = r" Writes raw `bits` to the field" ]
4020 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4021 const MASK: u8 = 1;
4022 const OFFSET: u8 = 4;
4023 self.register.bits &= !((MASK as u32) << OFFSET);
4024 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4025 self.register
4026 }
4027 }
4028 # [ doc = r" Proxy" ]
4029 pub struct _Bs3W<'a> {
4030 register: &'a mut W,
4031 }
4032 impl<'a> _Bs3W<'a> {
4033 # [ doc = r" Writes raw `bits` to the field" ]
4034 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4035 const MASK: u8 = 1;
4036 const OFFSET: u8 = 3;
4037 self.register.bits &= !((MASK as u32) << OFFSET);
4038 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4039 self.register
4040 }
4041 }
4042 # [ doc = r" Proxy" ]
4043 pub struct _Bs2W<'a> {
4044 register: &'a mut W,
4045 }
4046 impl<'a> _Bs2W<'a> {
4047 # [ doc = r" Writes raw `bits` to the field" ]
4048 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4049 const MASK: u8 = 1;
4050 const OFFSET: u8 = 2;
4051 self.register.bits &= !((MASK as u32) << OFFSET);
4052 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4053 self.register
4054 }
4055 }
4056 # [ doc = r" Proxy" ]
4057 pub struct _Bs1W<'a> {
4058 register: &'a mut W,
4059 }
4060 impl<'a> _Bs1W<'a> {
4061 # [ doc = r" Writes raw `bits` to the field" ]
4062 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4063 const MASK: u8 = 1;
4064 const OFFSET: u8 = 1;
4065 self.register.bits &= !((MASK as u32) << OFFSET);
4066 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4067 self.register
4068 }
4069 }
4070 # [ doc = r" Proxy" ]
4071 pub struct _Bs0W<'a> {
4072 register: &'a mut W,
4073 }
4074 impl<'a> _Bs0W<'a> {
4075 # [ doc = r" Writes raw `bits` to the field" ]
4076 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4077 const MASK: u8 = 1;
4078 const OFFSET: u8 = 0;
4079 self.register.bits &= !((MASK as u32) << OFFSET);
4080 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4081 self.register
4082 }
4083 }
4084 impl W {
4085 # [ doc = r" Reset value of the register" ]
4086 pub fn reset_value() -> W {
4087 W { bits: 0 }
4088 }
4089 # [ doc = r" Writes raw `bits` to the register" ]
4090 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
4091 self.bits = bits;
4092 self
4093 }
4094 # [ doc = "Bit 31 - Port x reset bit y (y = 0..15)" ]
4095 pub fn br15(&mut self) -> _Br15W {
4096 _Br15W { register: self }
4097 }
4098 # [ doc = "Bit 30 - Port x reset bit y (y = 0..15)" ]
4099 pub fn br14(&mut self) -> _Br14W {
4100 _Br14W { register: self }
4101 }
4102 # [ doc = "Bit 29 - Port x reset bit y (y = 0..15)" ]
4103 pub fn br13(&mut self) -> _Br13W {
4104 _Br13W { register: self }
4105 }
4106 # [ doc = "Bit 28 - Port x reset bit y (y = 0..15)" ]
4107 pub fn br12(&mut self) -> _Br12W {
4108 _Br12W { register: self }
4109 }
4110 # [ doc = "Bit 27 - Port x reset bit y (y = 0..15)" ]
4111 pub fn br11(&mut self) -> _Br11W {
4112 _Br11W { register: self }
4113 }
4114 # [ doc = "Bit 26 - Port x reset bit y (y = 0..15)" ]
4115 pub fn br10(&mut self) -> _Br10W {
4116 _Br10W { register: self }
4117 }
4118 # [ doc = "Bit 25 - Port x reset bit y (y = 0..15)" ]
4119 pub fn br9(&mut self) -> _Br9W {
4120 _Br9W { register: self }
4121 }
4122 # [ doc = "Bit 24 - Port x reset bit y (y = 0..15)" ]
4123 pub fn br8(&mut self) -> _Br8W {
4124 _Br8W { register: self }
4125 }
4126 # [ doc = "Bit 23 - Port x reset bit y (y = 0..15)" ]
4127 pub fn br7(&mut self) -> _Br7W {
4128 _Br7W { register: self }
4129 }
4130 # [ doc = "Bit 22 - Port x reset bit y (y = 0..15)" ]
4131 pub fn br6(&mut self) -> _Br6W {
4132 _Br6W { register: self }
4133 }
4134 # [ doc = "Bit 21 - Port x reset bit y (y = 0..15)" ]
4135 pub fn br5(&mut self) -> _Br5W {
4136 _Br5W { register: self }
4137 }
4138 # [ doc = "Bit 20 - Port x reset bit y (y = 0..15)" ]
4139 pub fn br4(&mut self) -> _Br4W {
4140 _Br4W { register: self }
4141 }
4142 # [ doc = "Bit 19 - Port x reset bit y (y = 0..15)" ]
4143 pub fn br3(&mut self) -> _Br3W {
4144 _Br3W { register: self }
4145 }
4146 # [ doc = "Bit 18 - Port x reset bit y (y = 0..15)" ]
4147 pub fn br2(&mut self) -> _Br2W {
4148 _Br2W { register: self }
4149 }
4150 # [ doc = "Bit 17 - Port x reset bit y (y = 0..15)" ]
4151 pub fn br1(&mut self) -> _Br1W {
4152 _Br1W { register: self }
4153 }
4154 # [ doc = "Bit 16 - Port x set bit y (y= 0..15)" ]
4155 pub fn br0(&mut self) -> _Br0W {
4156 _Br0W { register: self }
4157 }
4158 # [ doc = "Bit 15 - Port x set bit y (y= 0..15)" ]
4159 pub fn bs15(&mut self) -> _Bs15W {
4160 _Bs15W { register: self }
4161 }
4162 # [ doc = "Bit 14 - Port x set bit y (y= 0..15)" ]
4163 pub fn bs14(&mut self) -> _Bs14W {
4164 _Bs14W { register: self }
4165 }
4166 # [ doc = "Bit 13 - Port x set bit y (y= 0..15)" ]
4167 pub fn bs13(&mut self) -> _Bs13W {
4168 _Bs13W { register: self }
4169 }
4170 # [ doc = "Bit 12 - Port x set bit y (y= 0..15)" ]
4171 pub fn bs12(&mut self) -> _Bs12W {
4172 _Bs12W { register: self }
4173 }
4174 # [ doc = "Bit 11 - Port x set bit y (y= 0..15)" ]
4175 pub fn bs11(&mut self) -> _Bs11W {
4176 _Bs11W { register: self }
4177 }
4178 # [ doc = "Bit 10 - Port x set bit y (y= 0..15)" ]
4179 pub fn bs10(&mut self) -> _Bs10W {
4180 _Bs10W { register: self }
4181 }
4182 # [ doc = "Bit 9 - Port x set bit y (y= 0..15)" ]
4183 pub fn bs9(&mut self) -> _Bs9W {
4184 _Bs9W { register: self }
4185 }
4186 # [ doc = "Bit 8 - Port x set bit y (y= 0..15)" ]
4187 pub fn bs8(&mut self) -> _Bs8W {
4188 _Bs8W { register: self }
4189 }
4190 # [ doc = "Bit 7 - Port x set bit y (y= 0..15)" ]
4191 pub fn bs7(&mut self) -> _Bs7W {
4192 _Bs7W { register: self }
4193 }
4194 # [ doc = "Bit 6 - Port x set bit y (y= 0..15)" ]
4195 pub fn bs6(&mut self) -> _Bs6W {
4196 _Bs6W { register: self }
4197 }
4198 # [ doc = "Bit 5 - Port x set bit y (y= 0..15)" ]
4199 pub fn bs5(&mut self) -> _Bs5W {
4200 _Bs5W { register: self }
4201 }
4202 # [ doc = "Bit 4 - Port x set bit y (y= 0..15)" ]
4203 pub fn bs4(&mut self) -> _Bs4W {
4204 _Bs4W { register: self }
4205 }
4206 # [ doc = "Bit 3 - Port x set bit y (y= 0..15)" ]
4207 pub fn bs3(&mut self) -> _Bs3W {
4208 _Bs3W { register: self }
4209 }
4210 # [ doc = "Bit 2 - Port x set bit y (y= 0..15)" ]
4211 pub fn bs2(&mut self) -> _Bs2W {
4212 _Bs2W { register: self }
4213 }
4214 # [ doc = "Bit 1 - Port x set bit y (y= 0..15)" ]
4215 pub fn bs1(&mut self) -> _Bs1W {
4216 _Bs1W { register: self }
4217 }
4218 # [ doc = "Bit 0 - Port x set bit y (y= 0..15)" ]
4219 pub fn bs0(&mut self) -> _Bs0W {
4220 _Bs0W { register: self }
4221 }
4222 }
4223}
4224
4225# [ doc = "GPIO port configuration lock register" ]
4226# [ repr ( C ) ]
4227pub struct Lckr {
4228 register: ::volatile_register::RW<u32>,
4229}
4230
4231# [ doc = "GPIO port configuration lock register" ]
4232pub mod lckr {
4233 # [ doc = r" Value read from the register" ]
4234 pub struct R {
4235 bits: u32,
4236 }
4237 # [ doc = r" Value to write to the register" ]
4238 pub struct W {
4239 bits: u32,
4240 }
4241 impl super::Lckr {
4242 # [ doc = r" Modifies the contents of the register" ]
4243 pub fn modify<F>(&mut self, f: F)
4244 where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W
4245 {
4246 let bits = self.register.read();
4247 let r = R { bits: bits };
4248 let mut w = W { bits: bits };
4249 f(&r, &mut w);
4250 self.register.write(w.bits);
4251 }
4252 # [ doc = r" Reads the contents of the register" ]
4253 pub fn read(&self) -> R {
4254 R { bits: self.register.read() }
4255 }
4256 # [ doc = r" Writes to the register" ]
4257 pub fn write<F>(&mut self, f: F)
4258 where F: FnOnce(&mut W) -> &mut W
4259 {
4260 let mut w = W::reset_value();
4261 f(&mut w);
4262 self.register.write(w.bits);
4263 }
4264 }
4265 # [ doc = "Value of the field LCKK" ]
4266 pub struct LckkR {
4267 bits: u8,
4268 }
4269 impl LckkR {
4270 # [ doc = r" Value of the field as raw bits" ]
4271 pub fn bits(&self) -> u8 {
4272 self.bits
4273 }
4274 }
4275 # [ doc = "Value of the field LCK15" ]
4276 pub struct Lck15R {
4277 bits: u8,
4278 }
4279 impl Lck15R {
4280 # [ doc = r" Value of the field as raw bits" ]
4281 pub fn bits(&self) -> u8 {
4282 self.bits
4283 }
4284 }
4285 # [ doc = "Value of the field LCK14" ]
4286 pub struct Lck14R {
4287 bits: u8,
4288 }
4289 impl Lck14R {
4290 # [ doc = r" Value of the field as raw bits" ]
4291 pub fn bits(&self) -> u8 {
4292 self.bits
4293 }
4294 }
4295 # [ doc = "Value of the field LCK13" ]
4296 pub struct Lck13R {
4297 bits: u8,
4298 }
4299 impl Lck13R {
4300 # [ doc = r" Value of the field as raw bits" ]
4301 pub fn bits(&self) -> u8 {
4302 self.bits
4303 }
4304 }
4305 # [ doc = "Value of the field LCK12" ]
4306 pub struct Lck12R {
4307 bits: u8,
4308 }
4309 impl Lck12R {
4310 # [ doc = r" Value of the field as raw bits" ]
4311 pub fn bits(&self) -> u8 {
4312 self.bits
4313 }
4314 }
4315 # [ doc = "Value of the field LCK11" ]
4316 pub struct Lck11R {
4317 bits: u8,
4318 }
4319 impl Lck11R {
4320 # [ doc = r" Value of the field as raw bits" ]
4321 pub fn bits(&self) -> u8 {
4322 self.bits
4323 }
4324 }
4325 # [ doc = "Value of the field LCK10" ]
4326 pub struct Lck10R {
4327 bits: u8,
4328 }
4329 impl Lck10R {
4330 # [ doc = r" Value of the field as raw bits" ]
4331 pub fn bits(&self) -> u8 {
4332 self.bits
4333 }
4334 }
4335 # [ doc = "Value of the field LCK9" ]
4336 pub struct Lck9R {
4337 bits: u8,
4338 }
4339 impl Lck9R {
4340 # [ doc = r" Value of the field as raw bits" ]
4341 pub fn bits(&self) -> u8 {
4342 self.bits
4343 }
4344 }
4345 # [ doc = "Value of the field LCK8" ]
4346 pub struct Lck8R {
4347 bits: u8,
4348 }
4349 impl Lck8R {
4350 # [ doc = r" Value of the field as raw bits" ]
4351 pub fn bits(&self) -> u8 {
4352 self.bits
4353 }
4354 }
4355 # [ doc = "Value of the field LCK7" ]
4356 pub struct Lck7R {
4357 bits: u8,
4358 }
4359 impl Lck7R {
4360 # [ doc = r" Value of the field as raw bits" ]
4361 pub fn bits(&self) -> u8 {
4362 self.bits
4363 }
4364 }
4365 # [ doc = "Value of the field LCK6" ]
4366 pub struct Lck6R {
4367 bits: u8,
4368 }
4369 impl Lck6R {
4370 # [ doc = r" Value of the field as raw bits" ]
4371 pub fn bits(&self) -> u8 {
4372 self.bits
4373 }
4374 }
4375 # [ doc = "Value of the field LCK5" ]
4376 pub struct Lck5R {
4377 bits: u8,
4378 }
4379 impl Lck5R {
4380 # [ doc = r" Value of the field as raw bits" ]
4381 pub fn bits(&self) -> u8 {
4382 self.bits
4383 }
4384 }
4385 # [ doc = "Value of the field LCK4" ]
4386 pub struct Lck4R {
4387 bits: u8,
4388 }
4389 impl Lck4R {
4390 # [ doc = r" Value of the field as raw bits" ]
4391 pub fn bits(&self) -> u8 {
4392 self.bits
4393 }
4394 }
4395 # [ doc = "Value of the field LCK3" ]
4396 pub struct Lck3R {
4397 bits: u8,
4398 }
4399 impl Lck3R {
4400 # [ doc = r" Value of the field as raw bits" ]
4401 pub fn bits(&self) -> u8 {
4402 self.bits
4403 }
4404 }
4405 # [ doc = "Value of the field LCK2" ]
4406 pub struct Lck2R {
4407 bits: u8,
4408 }
4409 impl Lck2R {
4410 # [ doc = r" Value of the field as raw bits" ]
4411 pub fn bits(&self) -> u8 {
4412 self.bits
4413 }
4414 }
4415 # [ doc = "Value of the field LCK1" ]
4416 pub struct Lck1R {
4417 bits: u8,
4418 }
4419 impl Lck1R {
4420 # [ doc = r" Value of the field as raw bits" ]
4421 pub fn bits(&self) -> u8 {
4422 self.bits
4423 }
4424 }
4425 # [ doc = "Value of the field LCK0" ]
4426 pub struct Lck0R {
4427 bits: u8,
4428 }
4429 impl Lck0R {
4430 # [ doc = r" Value of the field as raw bits" ]
4431 pub fn bits(&self) -> u8 {
4432 self.bits
4433 }
4434 }
4435 # [ doc = r" Proxy" ]
4436 pub struct _LckkW<'a> {
4437 register: &'a mut W,
4438 }
4439 impl<'a> _LckkW<'a> {
4440 # [ doc = r" Writes raw `bits` to the field" ]
4441 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4442 const MASK: u8 = 1;
4443 const OFFSET: u8 = 16;
4444 self.register.bits &= !((MASK as u32) << OFFSET);
4445 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4446 self.register
4447 }
4448 }
4449 # [ doc = r" Proxy" ]
4450 pub struct _Lck15W<'a> {
4451 register: &'a mut W,
4452 }
4453 impl<'a> _Lck15W<'a> {
4454 # [ doc = r" Writes raw `bits` to the field" ]
4455 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4456 const MASK: u8 = 1;
4457 const OFFSET: u8 = 15;
4458 self.register.bits &= !((MASK as u32) << OFFSET);
4459 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4460 self.register
4461 }
4462 }
4463 # [ doc = r" Proxy" ]
4464 pub struct _Lck14W<'a> {
4465 register: &'a mut W,
4466 }
4467 impl<'a> _Lck14W<'a> {
4468 # [ doc = r" Writes raw `bits` to the field" ]
4469 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4470 const MASK: u8 = 1;
4471 const OFFSET: u8 = 14;
4472 self.register.bits &= !((MASK as u32) << OFFSET);
4473 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4474 self.register
4475 }
4476 }
4477 # [ doc = r" Proxy" ]
4478 pub struct _Lck13W<'a> {
4479 register: &'a mut W,
4480 }
4481 impl<'a> _Lck13W<'a> {
4482 # [ doc = r" Writes raw `bits` to the field" ]
4483 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4484 const MASK: u8 = 1;
4485 const OFFSET: u8 = 13;
4486 self.register.bits &= !((MASK as u32) << OFFSET);
4487 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4488 self.register
4489 }
4490 }
4491 # [ doc = r" Proxy" ]
4492 pub struct _Lck12W<'a> {
4493 register: &'a mut W,
4494 }
4495 impl<'a> _Lck12W<'a> {
4496 # [ doc = r" Writes raw `bits` to the field" ]
4497 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4498 const MASK: u8 = 1;
4499 const OFFSET: u8 = 12;
4500 self.register.bits &= !((MASK as u32) << OFFSET);
4501 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4502 self.register
4503 }
4504 }
4505 # [ doc = r" Proxy" ]
4506 pub struct _Lck11W<'a> {
4507 register: &'a mut W,
4508 }
4509 impl<'a> _Lck11W<'a> {
4510 # [ doc = r" Writes raw `bits` to the field" ]
4511 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4512 const MASK: u8 = 1;
4513 const OFFSET: u8 = 11;
4514 self.register.bits &= !((MASK as u32) << OFFSET);
4515 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4516 self.register
4517 }
4518 }
4519 # [ doc = r" Proxy" ]
4520 pub struct _Lck10W<'a> {
4521 register: &'a mut W,
4522 }
4523 impl<'a> _Lck10W<'a> {
4524 # [ doc = r" Writes raw `bits` to the field" ]
4525 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4526 const MASK: u8 = 1;
4527 const OFFSET: u8 = 10;
4528 self.register.bits &= !((MASK as u32) << OFFSET);
4529 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4530 self.register
4531 }
4532 }
4533 # [ doc = r" Proxy" ]
4534 pub struct _Lck9W<'a> {
4535 register: &'a mut W,
4536 }
4537 impl<'a> _Lck9W<'a> {
4538 # [ doc = r" Writes raw `bits` to the field" ]
4539 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4540 const MASK: u8 = 1;
4541 const OFFSET: u8 = 9;
4542 self.register.bits &= !((MASK as u32) << OFFSET);
4543 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4544 self.register
4545 }
4546 }
4547 # [ doc = r" Proxy" ]
4548 pub struct _Lck8W<'a> {
4549 register: &'a mut W,
4550 }
4551 impl<'a> _Lck8W<'a> {
4552 # [ doc = r" Writes raw `bits` to the field" ]
4553 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4554 const MASK: u8 = 1;
4555 const OFFSET: u8 = 8;
4556 self.register.bits &= !((MASK as u32) << OFFSET);
4557 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4558 self.register
4559 }
4560 }
4561 # [ doc = r" Proxy" ]
4562 pub struct _Lck7W<'a> {
4563 register: &'a mut W,
4564 }
4565 impl<'a> _Lck7W<'a> {
4566 # [ doc = r" Writes raw `bits` to the field" ]
4567 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4568 const MASK: u8 = 1;
4569 const OFFSET: u8 = 7;
4570 self.register.bits &= !((MASK as u32) << OFFSET);
4571 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4572 self.register
4573 }
4574 }
4575 # [ doc = r" Proxy" ]
4576 pub struct _Lck6W<'a> {
4577 register: &'a mut W,
4578 }
4579 impl<'a> _Lck6W<'a> {
4580 # [ doc = r" Writes raw `bits` to the field" ]
4581 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4582 const MASK: u8 = 1;
4583 const OFFSET: u8 = 6;
4584 self.register.bits &= !((MASK as u32) << OFFSET);
4585 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4586 self.register
4587 }
4588 }
4589 # [ doc = r" Proxy" ]
4590 pub struct _Lck5W<'a> {
4591 register: &'a mut W,
4592 }
4593 impl<'a> _Lck5W<'a> {
4594 # [ doc = r" Writes raw `bits` to the field" ]
4595 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4596 const MASK: u8 = 1;
4597 const OFFSET: u8 = 5;
4598 self.register.bits &= !((MASK as u32) << OFFSET);
4599 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4600 self.register
4601 }
4602 }
4603 # [ doc = r" Proxy" ]
4604 pub struct _Lck4W<'a> {
4605 register: &'a mut W,
4606 }
4607 impl<'a> _Lck4W<'a> {
4608 # [ doc = r" Writes raw `bits` to the field" ]
4609 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4610 const MASK: u8 = 1;
4611 const OFFSET: u8 = 4;
4612 self.register.bits &= !((MASK as u32) << OFFSET);
4613 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4614 self.register
4615 }
4616 }
4617 # [ doc = r" Proxy" ]
4618 pub struct _Lck3W<'a> {
4619 register: &'a mut W,
4620 }
4621 impl<'a> _Lck3W<'a> {
4622 # [ doc = r" Writes raw `bits` to the field" ]
4623 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4624 const MASK: u8 = 1;
4625 const OFFSET: u8 = 3;
4626 self.register.bits &= !((MASK as u32) << OFFSET);
4627 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4628 self.register
4629 }
4630 }
4631 # [ doc = r" Proxy" ]
4632 pub struct _Lck2W<'a> {
4633 register: &'a mut W,
4634 }
4635 impl<'a> _Lck2W<'a> {
4636 # [ doc = r" Writes raw `bits` to the field" ]
4637 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4638 const MASK: u8 = 1;
4639 const OFFSET: u8 = 2;
4640 self.register.bits &= !((MASK as u32) << OFFSET);
4641 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4642 self.register
4643 }
4644 }
4645 # [ doc = r" Proxy" ]
4646 pub struct _Lck1W<'a> {
4647 register: &'a mut W,
4648 }
4649 impl<'a> _Lck1W<'a> {
4650 # [ doc = r" Writes raw `bits` to the field" ]
4651 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4652 const MASK: u8 = 1;
4653 const OFFSET: u8 = 1;
4654 self.register.bits &= !((MASK as u32) << OFFSET);
4655 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4656 self.register
4657 }
4658 }
4659 # [ doc = r" Proxy" ]
4660 pub struct _Lck0W<'a> {
4661 register: &'a mut W,
4662 }
4663 impl<'a> _Lck0W<'a> {
4664 # [ doc = r" Writes raw `bits` to the field" ]
4665 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
4666 const MASK: u8 = 1;
4667 const OFFSET: u8 = 0;
4668 self.register.bits &= !((MASK as u32) << OFFSET);
4669 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
4670 self.register
4671 }
4672 }
4673 impl R {
4674 # [ doc = r" Value of the register as raw bits" ]
4675 pub fn bits(&self) -> u32 {
4676 self.bits
4677 }
4678 fn _lckk(&self) -> u8 {
4679 const MASK: u8 = 1;
4680 const OFFSET: u8 = 16;
4681 ((self.bits >> OFFSET) & MASK as u32) as u8
4682 }
4683 # [ doc = "Bit 16 - Port x lock bit y (y= 0..15)" ]
4684 pub fn lckk(&self) -> LckkR {
4685 LckkR { bits: self._lckk() }
4686 }
4687 fn _lck15(&self) -> u8 {
4688 const MASK: u8 = 1;
4689 const OFFSET: u8 = 15;
4690 ((self.bits >> OFFSET) & MASK as u32) as u8
4691 }
4692 # [ doc = "Bit 15 - Port x lock bit y (y= 0..15)" ]
4693 pub fn lck15(&self) -> Lck15R {
4694 Lck15R { bits: self._lck15() }
4695 }
4696 fn _lck14(&self) -> u8 {
4697 const MASK: u8 = 1;
4698 const OFFSET: u8 = 14;
4699 ((self.bits >> OFFSET) & MASK as u32) as u8
4700 }
4701 # [ doc = "Bit 14 - Port x lock bit y (y= 0..15)" ]
4702 pub fn lck14(&self) -> Lck14R {
4703 Lck14R { bits: self._lck14() }
4704 }
4705 fn _lck13(&self) -> u8 {
4706 const MASK: u8 = 1;
4707 const OFFSET: u8 = 13;
4708 ((self.bits >> OFFSET) & MASK as u32) as u8
4709 }
4710 # [ doc = "Bit 13 - Port x lock bit y (y= 0..15)" ]
4711 pub fn lck13(&self) -> Lck13R {
4712 Lck13R { bits: self._lck13() }
4713 }
4714 fn _lck12(&self) -> u8 {
4715 const MASK: u8 = 1;
4716 const OFFSET: u8 = 12;
4717 ((self.bits >> OFFSET) & MASK as u32) as u8
4718 }
4719 # [ doc = "Bit 12 - Port x lock bit y (y= 0..15)" ]
4720 pub fn lck12(&self) -> Lck12R {
4721 Lck12R { bits: self._lck12() }
4722 }
4723 fn _lck11(&self) -> u8 {
4724 const MASK: u8 = 1;
4725 const OFFSET: u8 = 11;
4726 ((self.bits >> OFFSET) & MASK as u32) as u8
4727 }
4728 # [ doc = "Bit 11 - Port x lock bit y (y= 0..15)" ]
4729 pub fn lck11(&self) -> Lck11R {
4730 Lck11R { bits: self._lck11() }
4731 }
4732 fn _lck10(&self) -> u8 {
4733 const MASK: u8 = 1;
4734 const OFFSET: u8 = 10;
4735 ((self.bits >> OFFSET) & MASK as u32) as u8
4736 }
4737 # [ doc = "Bit 10 - Port x lock bit y (y= 0..15)" ]
4738 pub fn lck10(&self) -> Lck10R {
4739 Lck10R { bits: self._lck10() }
4740 }
4741 fn _lck9(&self) -> u8 {
4742 const MASK: u8 = 1;
4743 const OFFSET: u8 = 9;
4744 ((self.bits >> OFFSET) & MASK as u32) as u8
4745 }
4746 # [ doc = "Bit 9 - Port x lock bit y (y= 0..15)" ]
4747 pub fn lck9(&self) -> Lck9R {
4748 Lck9R { bits: self._lck9() }
4749 }
4750 fn _lck8(&self) -> u8 {
4751 const MASK: u8 = 1;
4752 const OFFSET: u8 = 8;
4753 ((self.bits >> OFFSET) & MASK as u32) as u8
4754 }
4755 # [ doc = "Bit 8 - Port x lock bit y (y= 0..15)" ]
4756 pub fn lck8(&self) -> Lck8R {
4757 Lck8R { bits: self._lck8() }
4758 }
4759 fn _lck7(&self) -> u8 {
4760 const MASK: u8 = 1;
4761 const OFFSET: u8 = 7;
4762 ((self.bits >> OFFSET) & MASK as u32) as u8
4763 }
4764 # [ doc = "Bit 7 - Port x lock bit y (y= 0..15)" ]
4765 pub fn lck7(&self) -> Lck7R {
4766 Lck7R { bits: self._lck7() }
4767 }
4768 fn _lck6(&self) -> u8 {
4769 const MASK: u8 = 1;
4770 const OFFSET: u8 = 6;
4771 ((self.bits >> OFFSET) & MASK as u32) as u8
4772 }
4773 # [ doc = "Bit 6 - Port x lock bit y (y= 0..15)" ]
4774 pub fn lck6(&self) -> Lck6R {
4775 Lck6R { bits: self._lck6() }
4776 }
4777 fn _lck5(&self) -> u8 {
4778 const MASK: u8 = 1;
4779 const OFFSET: u8 = 5;
4780 ((self.bits >> OFFSET) & MASK as u32) as u8
4781 }
4782 # [ doc = "Bit 5 - Port x lock bit y (y= 0..15)" ]
4783 pub fn lck5(&self) -> Lck5R {
4784 Lck5R { bits: self._lck5() }
4785 }
4786 fn _lck4(&self) -> u8 {
4787 const MASK: u8 = 1;
4788 const OFFSET: u8 = 4;
4789 ((self.bits >> OFFSET) & MASK as u32) as u8
4790 }
4791 # [ doc = "Bit 4 - Port x lock bit y (y= 0..15)" ]
4792 pub fn lck4(&self) -> Lck4R {
4793 Lck4R { bits: self._lck4() }
4794 }
4795 fn _lck3(&self) -> u8 {
4796 const MASK: u8 = 1;
4797 const OFFSET: u8 = 3;
4798 ((self.bits >> OFFSET) & MASK as u32) as u8
4799 }
4800 # [ doc = "Bit 3 - Port x lock bit y (y= 0..15)" ]
4801 pub fn lck3(&self) -> Lck3R {
4802 Lck3R { bits: self._lck3() }
4803 }
4804 fn _lck2(&self) -> u8 {
4805 const MASK: u8 = 1;
4806 const OFFSET: u8 = 2;
4807 ((self.bits >> OFFSET) & MASK as u32) as u8
4808 }
4809 # [ doc = "Bit 2 - Port x lock bit y (y= 0..15)" ]
4810 pub fn lck2(&self) -> Lck2R {
4811 Lck2R { bits: self._lck2() }
4812 }
4813 fn _lck1(&self) -> u8 {
4814 const MASK: u8 = 1;
4815 const OFFSET: u8 = 1;
4816 ((self.bits >> OFFSET) & MASK as u32) as u8
4817 }
4818 # [ doc = "Bit 1 - Port x lock bit y (y= 0..15)" ]
4819 pub fn lck1(&self) -> Lck1R {
4820 Lck1R { bits: self._lck1() }
4821 }
4822 fn _lck0(&self) -> u8 {
4823 const MASK: u8 = 1;
4824 const OFFSET: u8 = 0;
4825 ((self.bits >> OFFSET) & MASK as u32) as u8
4826 }
4827 # [ doc = "Bit 0 - Port x lock bit y (y= 0..15)" ]
4828 pub fn lck0(&self) -> Lck0R {
4829 Lck0R { bits: self._lck0() }
4830 }
4831 }
4832 impl W {
4833 # [ doc = r" Reset value of the register" ]
4834 pub fn reset_value() -> W {
4835 W { bits: 0 }
4836 }
4837 # [ doc = r" Writes raw `bits` to the register" ]
4838 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
4839 self.bits = bits;
4840 self
4841 }
4842 # [ doc = "Bit 16 - Port x lock bit y (y= 0..15)" ]
4843 pub fn lckk(&mut self) -> _LckkW {
4844 _LckkW { register: self }
4845 }
4846 # [ doc = "Bit 15 - Port x lock bit y (y= 0..15)" ]
4847 pub fn lck15(&mut self) -> _Lck15W {
4848 _Lck15W { register: self }
4849 }
4850 # [ doc = "Bit 14 - Port x lock bit y (y= 0..15)" ]
4851 pub fn lck14(&mut self) -> _Lck14W {
4852 _Lck14W { register: self }
4853 }
4854 # [ doc = "Bit 13 - Port x lock bit y (y= 0..15)" ]
4855 pub fn lck13(&mut self) -> _Lck13W {
4856 _Lck13W { register: self }
4857 }
4858 # [ doc = "Bit 12 - Port x lock bit y (y= 0..15)" ]
4859 pub fn lck12(&mut self) -> _Lck12W {
4860 _Lck12W { register: self }
4861 }
4862 # [ doc = "Bit 11 - Port x lock bit y (y= 0..15)" ]
4863 pub fn lck11(&mut self) -> _Lck11W {
4864 _Lck11W { register: self }
4865 }
4866 # [ doc = "Bit 10 - Port x lock bit y (y= 0..15)" ]
4867 pub fn lck10(&mut self) -> _Lck10W {
4868 _Lck10W { register: self }
4869 }
4870 # [ doc = "Bit 9 - Port x lock bit y (y= 0..15)" ]
4871 pub fn lck9(&mut self) -> _Lck9W {
4872 _Lck9W { register: self }
4873 }
4874 # [ doc = "Bit 8 - Port x lock bit y (y= 0..15)" ]
4875 pub fn lck8(&mut self) -> _Lck8W {
4876 _Lck8W { register: self }
4877 }
4878 # [ doc = "Bit 7 - Port x lock bit y (y= 0..15)" ]
4879 pub fn lck7(&mut self) -> _Lck7W {
4880 _Lck7W { register: self }
4881 }
4882 # [ doc = "Bit 6 - Port x lock bit y (y= 0..15)" ]
4883 pub fn lck6(&mut self) -> _Lck6W {
4884 _Lck6W { register: self }
4885 }
4886 # [ doc = "Bit 5 - Port x lock bit y (y= 0..15)" ]
4887 pub fn lck5(&mut self) -> _Lck5W {
4888 _Lck5W { register: self }
4889 }
4890 # [ doc = "Bit 4 - Port x lock bit y (y= 0..15)" ]
4891 pub fn lck4(&mut self) -> _Lck4W {
4892 _Lck4W { register: self }
4893 }
4894 # [ doc = "Bit 3 - Port x lock bit y (y= 0..15)" ]
4895 pub fn lck3(&mut self) -> _Lck3W {
4896 _Lck3W { register: self }
4897 }
4898 # [ doc = "Bit 2 - Port x lock bit y (y= 0..15)" ]
4899 pub fn lck2(&mut self) -> _Lck2W {
4900 _Lck2W { register: self }
4901 }
4902 # [ doc = "Bit 1 - Port x lock bit y (y= 0..15)" ]
4903 pub fn lck1(&mut self) -> _Lck1W {
4904 _Lck1W { register: self }
4905 }
4906 # [ doc = "Bit 0 - Port x lock bit y (y= 0..15)" ]
4907 pub fn lck0(&mut self) -> _Lck0W {
4908 _Lck0W { register: self }
4909 }
4910 }
4911}
4912
4913# [ doc = "GPIO alternate function low register" ]
4914# [ repr ( C ) ]
4915pub struct Afrl {
4916 register: ::volatile_register::RW<u32>,
4917}
4918
4919# [ doc = "GPIO alternate function low register" ]
4920pub mod afrl {
4921 # [ doc = r" Value read from the register" ]
4922 pub struct R {
4923 bits: u32,
4924 }
4925 # [ doc = r" Value to write to the register" ]
4926 pub struct W {
4927 bits: u32,
4928 }
4929 impl super::Afrl {
4930 # [ doc = r" Modifies the contents of the register" ]
4931 pub fn modify<F>(&mut self, f: F)
4932 where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W
4933 {
4934 let bits = self.register.read();
4935 let r = R { bits: bits };
4936 let mut w = W { bits: bits };
4937 f(&r, &mut w);
4938 self.register.write(w.bits);
4939 }
4940 # [ doc = r" Reads the contents of the register" ]
4941 pub fn read(&self) -> R {
4942 R { bits: self.register.read() }
4943 }
4944 # [ doc = r" Writes to the register" ]
4945 pub fn write<F>(&mut self, f: F)
4946 where F: FnOnce(&mut W) -> &mut W
4947 {
4948 let mut w = W::reset_value();
4949 f(&mut w);
4950 self.register.write(w.bits);
4951 }
4952 }
4953 # [ doc = "Value of the field AFRL7" ]
4954 pub struct Afrl7R {
4955 bits: u8,
4956 }
4957 impl Afrl7R {
4958 # [ doc = r" Value of the field as raw bits" ]
4959 pub fn bits(&self) -> u8 {
4960 self.bits
4961 }
4962 }
4963 # [ doc = "Value of the field AFRL6" ]
4964 pub struct Afrl6R {
4965 bits: u8,
4966 }
4967 impl Afrl6R {
4968 # [ doc = r" Value of the field as raw bits" ]
4969 pub fn bits(&self) -> u8 {
4970 self.bits
4971 }
4972 }
4973 # [ doc = "Value of the field AFRL5" ]
4974 pub struct Afrl5R {
4975 bits: u8,
4976 }
4977 impl Afrl5R {
4978 # [ doc = r" Value of the field as raw bits" ]
4979 pub fn bits(&self) -> u8 {
4980 self.bits
4981 }
4982 }
4983 # [ doc = "Value of the field AFRL4" ]
4984 pub struct Afrl4R {
4985 bits: u8,
4986 }
4987 impl Afrl4R {
4988 # [ doc = r" Value of the field as raw bits" ]
4989 pub fn bits(&self) -> u8 {
4990 self.bits
4991 }
4992 }
4993 # [ doc = "Value of the field AFRL3" ]
4994 pub struct Afrl3R {
4995 bits: u8,
4996 }
4997 impl Afrl3R {
4998 # [ doc = r" Value of the field as raw bits" ]
4999 pub fn bits(&self) -> u8 {
5000 self.bits
5001 }
5002 }
5003 # [ doc = "Value of the field AFRL2" ]
5004 pub struct Afrl2R {
5005 bits: u8,
5006 }
5007 impl Afrl2R {
5008 # [ doc = r" Value of the field as raw bits" ]
5009 pub fn bits(&self) -> u8 {
5010 self.bits
5011 }
5012 }
5013 # [ doc = "Value of the field AFRL1" ]
5014 pub struct Afrl1R {
5015 bits: u8,
5016 }
5017 impl Afrl1R {
5018 # [ doc = r" Value of the field as raw bits" ]
5019 pub fn bits(&self) -> u8 {
5020 self.bits
5021 }
5022 }
5023 # [ doc = "Value of the field AFRL0" ]
5024 pub struct Afrl0R {
5025 bits: u8,
5026 }
5027 impl Afrl0R {
5028 # [ doc = r" Value of the field as raw bits" ]
5029 pub fn bits(&self) -> u8 {
5030 self.bits
5031 }
5032 }
5033 # [ doc = r" Proxy" ]
5034 pub struct _Afrl7W<'a> {
5035 register: &'a mut W,
5036 }
5037 impl<'a> _Afrl7W<'a> {
5038 # [ doc = r" Writes raw `bits` to the field" ]
5039 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5040 const MASK: u8 = 15;
5041 const OFFSET: u8 = 28;
5042 self.register.bits &= !((MASK as u32) << OFFSET);
5043 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5044 self.register
5045 }
5046 }
5047 # [ doc = r" Proxy" ]
5048 pub struct _Afrl6W<'a> {
5049 register: &'a mut W,
5050 }
5051 impl<'a> _Afrl6W<'a> {
5052 # [ doc = r" Writes raw `bits` to the field" ]
5053 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5054 const MASK: u8 = 15;
5055 const OFFSET: u8 = 24;
5056 self.register.bits &= !((MASK as u32) << OFFSET);
5057 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5058 self.register
5059 }
5060 }
5061 # [ doc = r" Proxy" ]
5062 pub struct _Afrl5W<'a> {
5063 register: &'a mut W,
5064 }
5065 impl<'a> _Afrl5W<'a> {
5066 # [ doc = r" Writes raw `bits` to the field" ]
5067 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5068 const MASK: u8 = 15;
5069 const OFFSET: u8 = 20;
5070 self.register.bits &= !((MASK as u32) << OFFSET);
5071 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5072 self.register
5073 }
5074 }
5075 # [ doc = r" Proxy" ]
5076 pub struct _Afrl4W<'a> {
5077 register: &'a mut W,
5078 }
5079 impl<'a> _Afrl4W<'a> {
5080 # [ doc = r" Writes raw `bits` to the field" ]
5081 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5082 const MASK: u8 = 15;
5083 const OFFSET: u8 = 16;
5084 self.register.bits &= !((MASK as u32) << OFFSET);
5085 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5086 self.register
5087 }
5088 }
5089 # [ doc = r" Proxy" ]
5090 pub struct _Afrl3W<'a> {
5091 register: &'a mut W,
5092 }
5093 impl<'a> _Afrl3W<'a> {
5094 # [ doc = r" Writes raw `bits` to the field" ]
5095 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5096 const MASK: u8 = 15;
5097 const OFFSET: u8 = 12;
5098 self.register.bits &= !((MASK as u32) << OFFSET);
5099 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5100 self.register
5101 }
5102 }
5103 # [ doc = r" Proxy" ]
5104 pub struct _Afrl2W<'a> {
5105 register: &'a mut W,
5106 }
5107 impl<'a> _Afrl2W<'a> {
5108 # [ doc = r" Writes raw `bits` to the field" ]
5109 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5110 const MASK: u8 = 15;
5111 const OFFSET: u8 = 8;
5112 self.register.bits &= !((MASK as u32) << OFFSET);
5113 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5114 self.register
5115 }
5116 }
5117 # [ doc = r" Proxy" ]
5118 pub struct _Afrl1W<'a> {
5119 register: &'a mut W,
5120 }
5121 impl<'a> _Afrl1W<'a> {
5122 # [ doc = r" Writes raw `bits` to the field" ]
5123 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5124 const MASK: u8 = 15;
5125 const OFFSET: u8 = 4;
5126 self.register.bits &= !((MASK as u32) << OFFSET);
5127 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5128 self.register
5129 }
5130 }
5131 # [ doc = r" Proxy" ]
5132 pub struct _Afrl0W<'a> {
5133 register: &'a mut W,
5134 }
5135 impl<'a> _Afrl0W<'a> {
5136 # [ doc = r" Writes raw `bits` to the field" ]
5137 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5138 const MASK: u8 = 15;
5139 const OFFSET: u8 = 0;
5140 self.register.bits &= !((MASK as u32) << OFFSET);
5141 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5142 self.register
5143 }
5144 }
5145 impl R {
5146 # [ doc = r" Value of the register as raw bits" ]
5147 pub fn bits(&self) -> u32 {
5148 self.bits
5149 }
5150 fn _afrl7(&self) -> u8 {
5151 const MASK: u8 = 15;
5152 const OFFSET: u8 = 28;
5153 ((self.bits >> OFFSET) & MASK as u32) as u8
5154 }
5155 # [ doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)" ]
5156 pub fn afrl7(&self) -> Afrl7R {
5157 Afrl7R { bits: self._afrl7() }
5158 }
5159 fn _afrl6(&self) -> u8 {
5160 const MASK: u8 = 15;
5161 const OFFSET: u8 = 24;
5162 ((self.bits >> OFFSET) & MASK as u32) as u8
5163 }
5164 # [ doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)" ]
5165 pub fn afrl6(&self) -> Afrl6R {
5166 Afrl6R { bits: self._afrl6() }
5167 }
5168 fn _afrl5(&self) -> u8 {
5169 const MASK: u8 = 15;
5170 const OFFSET: u8 = 20;
5171 ((self.bits >> OFFSET) & MASK as u32) as u8
5172 }
5173 # [ doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)" ]
5174 pub fn afrl5(&self) -> Afrl5R {
5175 Afrl5R { bits: self._afrl5() }
5176 }
5177 fn _afrl4(&self) -> u8 {
5178 const MASK: u8 = 15;
5179 const OFFSET: u8 = 16;
5180 ((self.bits >> OFFSET) & MASK as u32) as u8
5181 }
5182 # [ doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)" ]
5183 pub fn afrl4(&self) -> Afrl4R {
5184 Afrl4R { bits: self._afrl4() }
5185 }
5186 fn _afrl3(&self) -> u8 {
5187 const MASK: u8 = 15;
5188 const OFFSET: u8 = 12;
5189 ((self.bits >> OFFSET) & MASK as u32) as u8
5190 }
5191 # [ doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)" ]
5192 pub fn afrl3(&self) -> Afrl3R {
5193 Afrl3R { bits: self._afrl3() }
5194 }
5195 fn _afrl2(&self) -> u8 {
5196 const MASK: u8 = 15;
5197 const OFFSET: u8 = 8;
5198 ((self.bits >> OFFSET) & MASK as u32) as u8
5199 }
5200 # [ doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)" ]
5201 pub fn afrl2(&self) -> Afrl2R {
5202 Afrl2R { bits: self._afrl2() }
5203 }
5204 fn _afrl1(&self) -> u8 {
5205 const MASK: u8 = 15;
5206 const OFFSET: u8 = 4;
5207 ((self.bits >> OFFSET) & MASK as u32) as u8
5208 }
5209 # [ doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)" ]
5210 pub fn afrl1(&self) -> Afrl1R {
5211 Afrl1R { bits: self._afrl1() }
5212 }
5213 fn _afrl0(&self) -> u8 {
5214 const MASK: u8 = 15;
5215 const OFFSET: u8 = 0;
5216 ((self.bits >> OFFSET) & MASK as u32) as u8
5217 }
5218 # [ doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)" ]
5219 pub fn afrl0(&self) -> Afrl0R {
5220 Afrl0R { bits: self._afrl0() }
5221 }
5222 }
5223 impl W {
5224 # [ doc = r" Reset value of the register" ]
5225 pub fn reset_value() -> W {
5226 W { bits: 0 }
5227 }
5228 # [ doc = r" Writes raw `bits` to the register" ]
5229 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
5230 self.bits = bits;
5231 self
5232 }
5233 # [ doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)" ]
5234 pub fn afrl7(&mut self) -> _Afrl7W {
5235 _Afrl7W { register: self }
5236 }
5237 # [ doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)" ]
5238 pub fn afrl6(&mut self) -> _Afrl6W {
5239 _Afrl6W { register: self }
5240 }
5241 # [ doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)" ]
5242 pub fn afrl5(&mut self) -> _Afrl5W {
5243 _Afrl5W { register: self }
5244 }
5245 # [ doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)" ]
5246 pub fn afrl4(&mut self) -> _Afrl4W {
5247 _Afrl4W { register: self }
5248 }
5249 # [ doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)" ]
5250 pub fn afrl3(&mut self) -> _Afrl3W {
5251 _Afrl3W { register: self }
5252 }
5253 # [ doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)" ]
5254 pub fn afrl2(&mut self) -> _Afrl2W {
5255 _Afrl2W { register: self }
5256 }
5257 # [ doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)" ]
5258 pub fn afrl1(&mut self) -> _Afrl1W {
5259 _Afrl1W { register: self }
5260 }
5261 # [ doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)" ]
5262 pub fn afrl0(&mut self) -> _Afrl0W {
5263 _Afrl0W { register: self }
5264 }
5265 }
5266}
5267
5268# [ doc = "GPIO alternate function high register" ]
5269# [ repr ( C ) ]
5270pub struct Afrh {
5271 register: ::volatile_register::RW<u32>,
5272}
5273
5274# [ doc = "GPIO alternate function high register" ]
5275pub mod afrh {
5276 # [ doc = r" Value read from the register" ]
5277 pub struct R {
5278 bits: u32,
5279 }
5280 # [ doc = r" Value to write to the register" ]
5281 pub struct W {
5282 bits: u32,
5283 }
5284 impl super::Afrh {
5285 # [ doc = r" Modifies the contents of the register" ]
5286 pub fn modify<F>(&mut self, f: F)
5287 where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W
5288 {
5289 let bits = self.register.read();
5290 let r = R { bits: bits };
5291 let mut w = W { bits: bits };
5292 f(&r, &mut w);
5293 self.register.write(w.bits);
5294 }
5295 # [ doc = r" Reads the contents of the register" ]
5296 pub fn read(&self) -> R {
5297 R { bits: self.register.read() }
5298 }
5299 # [ doc = r" Writes to the register" ]
5300 pub fn write<F>(&mut self, f: F)
5301 where F: FnOnce(&mut W) -> &mut W
5302 {
5303 let mut w = W::reset_value();
5304 f(&mut w);
5305 self.register.write(w.bits);
5306 }
5307 }
5308 # [ doc = "Value of the field AFRH15" ]
5309 pub struct Afrh15R {
5310 bits: u8,
5311 }
5312 impl Afrh15R {
5313 # [ doc = r" Value of the field as raw bits" ]
5314 pub fn bits(&self) -> u8 {
5315 self.bits
5316 }
5317 }
5318 # [ doc = "Value of the field AFRH14" ]
5319 pub struct Afrh14R {
5320 bits: u8,
5321 }
5322 impl Afrh14R {
5323 # [ doc = r" Value of the field as raw bits" ]
5324 pub fn bits(&self) -> u8 {
5325 self.bits
5326 }
5327 }
5328 # [ doc = "Value of the field AFRH13" ]
5329 pub struct Afrh13R {
5330 bits: u8,
5331 }
5332 impl Afrh13R {
5333 # [ doc = r" Value of the field as raw bits" ]
5334 pub fn bits(&self) -> u8 {
5335 self.bits
5336 }
5337 }
5338 # [ doc = "Value of the field AFRH12" ]
5339 pub struct Afrh12R {
5340 bits: u8,
5341 }
5342 impl Afrh12R {
5343 # [ doc = r" Value of the field as raw bits" ]
5344 pub fn bits(&self) -> u8 {
5345 self.bits
5346 }
5347 }
5348 # [ doc = "Value of the field AFRH11" ]
5349 pub struct Afrh11R {
5350 bits: u8,
5351 }
5352 impl Afrh11R {
5353 # [ doc = r" Value of the field as raw bits" ]
5354 pub fn bits(&self) -> u8 {
5355 self.bits
5356 }
5357 }
5358 # [ doc = "Value of the field AFRH10" ]
5359 pub struct Afrh10R {
5360 bits: u8,
5361 }
5362 impl Afrh10R {
5363 # [ doc = r" Value of the field as raw bits" ]
5364 pub fn bits(&self) -> u8 {
5365 self.bits
5366 }
5367 }
5368 # [ doc = "Value of the field AFRH9" ]
5369 pub struct Afrh9R {
5370 bits: u8,
5371 }
5372 impl Afrh9R {
5373 # [ doc = r" Value of the field as raw bits" ]
5374 pub fn bits(&self) -> u8 {
5375 self.bits
5376 }
5377 }
5378 # [ doc = "Value of the field AFRH8" ]
5379 pub struct Afrh8R {
5380 bits: u8,
5381 }
5382 impl Afrh8R {
5383 # [ doc = r" Value of the field as raw bits" ]
5384 pub fn bits(&self) -> u8 {
5385 self.bits
5386 }
5387 }
5388 # [ doc = r" Proxy" ]
5389 pub struct _Afrh15W<'a> {
5390 register: &'a mut W,
5391 }
5392 impl<'a> _Afrh15W<'a> {
5393 # [ doc = r" Writes raw `bits` to the field" ]
5394 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5395 const MASK: u8 = 15;
5396 const OFFSET: u8 = 28;
5397 self.register.bits &= !((MASK as u32) << OFFSET);
5398 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5399 self.register
5400 }
5401 }
5402 # [ doc = r" Proxy" ]
5403 pub struct _Afrh14W<'a> {
5404 register: &'a mut W,
5405 }
5406 impl<'a> _Afrh14W<'a> {
5407 # [ doc = r" Writes raw `bits` to the field" ]
5408 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5409 const MASK: u8 = 15;
5410 const OFFSET: u8 = 24;
5411 self.register.bits &= !((MASK as u32) << OFFSET);
5412 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5413 self.register
5414 }
5415 }
5416 # [ doc = r" Proxy" ]
5417 pub struct _Afrh13W<'a> {
5418 register: &'a mut W,
5419 }
5420 impl<'a> _Afrh13W<'a> {
5421 # [ doc = r" Writes raw `bits` to the field" ]
5422 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5423 const MASK: u8 = 15;
5424 const OFFSET: u8 = 20;
5425 self.register.bits &= !((MASK as u32) << OFFSET);
5426 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5427 self.register
5428 }
5429 }
5430 # [ doc = r" Proxy" ]
5431 pub struct _Afrh12W<'a> {
5432 register: &'a mut W,
5433 }
5434 impl<'a> _Afrh12W<'a> {
5435 # [ doc = r" Writes raw `bits` to the field" ]
5436 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5437 const MASK: u8 = 15;
5438 const OFFSET: u8 = 16;
5439 self.register.bits &= !((MASK as u32) << OFFSET);
5440 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5441 self.register
5442 }
5443 }
5444 # [ doc = r" Proxy" ]
5445 pub struct _Afrh11W<'a> {
5446 register: &'a mut W,
5447 }
5448 impl<'a> _Afrh11W<'a> {
5449 # [ doc = r" Writes raw `bits` to the field" ]
5450 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5451 const MASK: u8 = 15;
5452 const OFFSET: u8 = 12;
5453 self.register.bits &= !((MASK as u32) << OFFSET);
5454 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5455 self.register
5456 }
5457 }
5458 # [ doc = r" Proxy" ]
5459 pub struct _Afrh10W<'a> {
5460 register: &'a mut W,
5461 }
5462 impl<'a> _Afrh10W<'a> {
5463 # [ doc = r" Writes raw `bits` to the field" ]
5464 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5465 const MASK: u8 = 15;
5466 const OFFSET: u8 = 8;
5467 self.register.bits &= !((MASK as u32) << OFFSET);
5468 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5469 self.register
5470 }
5471 }
5472 # [ doc = r" Proxy" ]
5473 pub struct _Afrh9W<'a> {
5474 register: &'a mut W,
5475 }
5476 impl<'a> _Afrh9W<'a> {
5477 # [ doc = r" Writes raw `bits` to the field" ]
5478 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5479 const MASK: u8 = 15;
5480 const OFFSET: u8 = 4;
5481 self.register.bits &= !((MASK as u32) << OFFSET);
5482 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5483 self.register
5484 }
5485 }
5486 # [ doc = r" Proxy" ]
5487 pub struct _Afrh8W<'a> {
5488 register: &'a mut W,
5489 }
5490 impl<'a> _Afrh8W<'a> {
5491 # [ doc = r" Writes raw `bits` to the field" ]
5492 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5493 const MASK: u8 = 15;
5494 const OFFSET: u8 = 0;
5495 self.register.bits &= !((MASK as u32) << OFFSET);
5496 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5497 self.register
5498 }
5499 }
5500 impl R {
5501 # [ doc = r" Value of the register as raw bits" ]
5502 pub fn bits(&self) -> u32 {
5503 self.bits
5504 }
5505 fn _afrh15(&self) -> u8 {
5506 const MASK: u8 = 15;
5507 const OFFSET: u8 = 28;
5508 ((self.bits >> OFFSET) & MASK as u32) as u8
5509 }
5510 # [ doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)" ]
5511 pub fn afrh15(&self) -> Afrh15R {
5512 Afrh15R { bits: self._afrh15() }
5513 }
5514 fn _afrh14(&self) -> u8 {
5515 const MASK: u8 = 15;
5516 const OFFSET: u8 = 24;
5517 ((self.bits >> OFFSET) & MASK as u32) as u8
5518 }
5519 # [ doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)" ]
5520 pub fn afrh14(&self) -> Afrh14R {
5521 Afrh14R { bits: self._afrh14() }
5522 }
5523 fn _afrh13(&self) -> u8 {
5524 const MASK: u8 = 15;
5525 const OFFSET: u8 = 20;
5526 ((self.bits >> OFFSET) & MASK as u32) as u8
5527 }
5528 # [ doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)" ]
5529 pub fn afrh13(&self) -> Afrh13R {
5530 Afrh13R { bits: self._afrh13() }
5531 }
5532 fn _afrh12(&self) -> u8 {
5533 const MASK: u8 = 15;
5534 const OFFSET: u8 = 16;
5535 ((self.bits >> OFFSET) & MASK as u32) as u8
5536 }
5537 # [ doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)" ]
5538 pub fn afrh12(&self) -> Afrh12R {
5539 Afrh12R { bits: self._afrh12() }
5540 }
5541 fn _afrh11(&self) -> u8 {
5542 const MASK: u8 = 15;
5543 const OFFSET: u8 = 12;
5544 ((self.bits >> OFFSET) & MASK as u32) as u8
5545 }
5546 # [ doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)" ]
5547 pub fn afrh11(&self) -> Afrh11R {
5548 Afrh11R { bits: self._afrh11() }
5549 }
5550 fn _afrh10(&self) -> u8 {
5551 const MASK: u8 = 15;
5552 const OFFSET: u8 = 8;
5553 ((self.bits >> OFFSET) & MASK as u32) as u8
5554 }
5555 # [ doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)" ]
5556 pub fn afrh10(&self) -> Afrh10R {
5557 Afrh10R { bits: self._afrh10() }
5558 }
5559 fn _afrh9(&self) -> u8 {
5560 const MASK: u8 = 15;
5561 const OFFSET: u8 = 4;
5562 ((self.bits >> OFFSET) & MASK as u32) as u8
5563 }
5564 # [ doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)" ]
5565 pub fn afrh9(&self) -> Afrh9R {
5566 Afrh9R { bits: self._afrh9() }
5567 }
5568 fn _afrh8(&self) -> u8 {
5569 const MASK: u8 = 15;
5570 const OFFSET: u8 = 0;
5571 ((self.bits >> OFFSET) & MASK as u32) as u8
5572 }
5573 # [ doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)" ]
5574 pub fn afrh8(&self) -> Afrh8R {
5575 Afrh8R { bits: self._afrh8() }
5576 }
5577 }
5578 impl W {
5579 # [ doc = r" Reset value of the register" ]
5580 pub fn reset_value() -> W {
5581 W { bits: 0 }
5582 }
5583 # [ doc = r" Writes raw `bits` to the register" ]
5584 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
5585 self.bits = bits;
5586 self
5587 }
5588 # [ doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)" ]
5589 pub fn afrh15(&mut self) -> _Afrh15W {
5590 _Afrh15W { register: self }
5591 }
5592 # [ doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)" ]
5593 pub fn afrh14(&mut self) -> _Afrh14W {
5594 _Afrh14W { register: self }
5595 }
5596 # [ doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)" ]
5597 pub fn afrh13(&mut self) -> _Afrh13W {
5598 _Afrh13W { register: self }
5599 }
5600 # [ doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)" ]
5601 pub fn afrh12(&mut self) -> _Afrh12W {
5602 _Afrh12W { register: self }
5603 }
5604 # [ doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)" ]
5605 pub fn afrh11(&mut self) -> _Afrh11W {
5606 _Afrh11W { register: self }
5607 }
5608 # [ doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)" ]
5609 pub fn afrh10(&mut self) -> _Afrh10W {
5610 _Afrh10W { register: self }
5611 }
5612 # [ doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)" ]
5613 pub fn afrh9(&mut self) -> _Afrh9W {
5614 _Afrh9W { register: self }
5615 }
5616 # [ doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)" ]
5617 pub fn afrh8(&mut self) -> _Afrh8W {
5618 _Afrh8W { register: self }
5619 }
5620 }
5621}
5622
5623# [ doc = "Port bit reset register" ]
5624# [ repr ( C ) ]
5625pub struct Brr {
5626 register: ::volatile_register::WO<u32>,
5627}
5628
5629# [ doc = "Port bit reset register" ]
5630pub mod brr {
5631 # [ doc = r" Value to write to the register" ]
5632 pub struct W {
5633 bits: u32,
5634 }
5635 impl super::Brr {
5636 # [ doc = r" Writes to the register" ]
5637 pub fn write<F>(&mut self, f: F)
5638 where F: FnOnce(&mut W) -> &mut W
5639 {
5640 let mut w = W::reset_value();
5641 f(&mut w);
5642 self.register.write(w.bits);
5643 }
5644 }
5645 # [ doc = r" Proxy" ]
5646 pub struct _Br0W<'a> {
5647 register: &'a mut W,
5648 }
5649 impl<'a> _Br0W<'a> {
5650 # [ doc = r" Writes raw `bits` to the field" ]
5651 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5652 const MASK: u8 = 1;
5653 const OFFSET: u8 = 0;
5654 self.register.bits &= !((MASK as u32) << OFFSET);
5655 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5656 self.register
5657 }
5658 }
5659 # [ doc = r" Proxy" ]
5660 pub struct _Br1W<'a> {
5661 register: &'a mut W,
5662 }
5663 impl<'a> _Br1W<'a> {
5664 # [ doc = r" Writes raw `bits` to the field" ]
5665 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5666 const MASK: u8 = 1;
5667 const OFFSET: u8 = 1;
5668 self.register.bits &= !((MASK as u32) << OFFSET);
5669 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5670 self.register
5671 }
5672 }
5673 # [ doc = r" Proxy" ]
5674 pub struct _Br2W<'a> {
5675 register: &'a mut W,
5676 }
5677 impl<'a> _Br2W<'a> {
5678 # [ doc = r" Writes raw `bits` to the field" ]
5679 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5680 const MASK: u8 = 1;
5681 const OFFSET: u8 = 2;
5682 self.register.bits &= !((MASK as u32) << OFFSET);
5683 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5684 self.register
5685 }
5686 }
5687 # [ doc = r" Proxy" ]
5688 pub struct _Br3W<'a> {
5689 register: &'a mut W,
5690 }
5691 impl<'a> _Br3W<'a> {
5692 # [ doc = r" Writes raw `bits` to the field" ]
5693 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5694 const MASK: u8 = 1;
5695 const OFFSET: u8 = 3;
5696 self.register.bits &= !((MASK as u32) << OFFSET);
5697 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5698 self.register
5699 }
5700 }
5701 # [ doc = r" Proxy" ]
5702 pub struct _Br4W<'a> {
5703 register: &'a mut W,
5704 }
5705 impl<'a> _Br4W<'a> {
5706 # [ doc = r" Writes raw `bits` to the field" ]
5707 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5708 const MASK: u8 = 1;
5709 const OFFSET: u8 = 4;
5710 self.register.bits &= !((MASK as u32) << OFFSET);
5711 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5712 self.register
5713 }
5714 }
5715 # [ doc = r" Proxy" ]
5716 pub struct _Br5W<'a> {
5717 register: &'a mut W,
5718 }
5719 impl<'a> _Br5W<'a> {
5720 # [ doc = r" Writes raw `bits` to the field" ]
5721 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5722 const MASK: u8 = 1;
5723 const OFFSET: u8 = 5;
5724 self.register.bits &= !((MASK as u32) << OFFSET);
5725 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5726 self.register
5727 }
5728 }
5729 # [ doc = r" Proxy" ]
5730 pub struct _Br6W<'a> {
5731 register: &'a mut W,
5732 }
5733 impl<'a> _Br6W<'a> {
5734 # [ doc = r" Writes raw `bits` to the field" ]
5735 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5736 const MASK: u8 = 1;
5737 const OFFSET: u8 = 6;
5738 self.register.bits &= !((MASK as u32) << OFFSET);
5739 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5740 self.register
5741 }
5742 }
5743 # [ doc = r" Proxy" ]
5744 pub struct _Br7W<'a> {
5745 register: &'a mut W,
5746 }
5747 impl<'a> _Br7W<'a> {
5748 # [ doc = r" Writes raw `bits` to the field" ]
5749 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5750 const MASK: u8 = 1;
5751 const OFFSET: u8 = 7;
5752 self.register.bits &= !((MASK as u32) << OFFSET);
5753 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5754 self.register
5755 }
5756 }
5757 # [ doc = r" Proxy" ]
5758 pub struct _Br8W<'a> {
5759 register: &'a mut W,
5760 }
5761 impl<'a> _Br8W<'a> {
5762 # [ doc = r" Writes raw `bits` to the field" ]
5763 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5764 const MASK: u8 = 1;
5765 const OFFSET: u8 = 8;
5766 self.register.bits &= !((MASK as u32) << OFFSET);
5767 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5768 self.register
5769 }
5770 }
5771 # [ doc = r" Proxy" ]
5772 pub struct _Br9W<'a> {
5773 register: &'a mut W,
5774 }
5775 impl<'a> _Br9W<'a> {
5776 # [ doc = r" Writes raw `bits` to the field" ]
5777 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5778 const MASK: u8 = 1;
5779 const OFFSET: u8 = 9;
5780 self.register.bits &= !((MASK as u32) << OFFSET);
5781 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5782 self.register
5783 }
5784 }
5785 # [ doc = r" Proxy" ]
5786 pub struct _Br10W<'a> {
5787 register: &'a mut W,
5788 }
5789 impl<'a> _Br10W<'a> {
5790 # [ doc = r" Writes raw `bits` to the field" ]
5791 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5792 const MASK: u8 = 1;
5793 const OFFSET: u8 = 10;
5794 self.register.bits &= !((MASK as u32) << OFFSET);
5795 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5796 self.register
5797 }
5798 }
5799 # [ doc = r" Proxy" ]
5800 pub struct _Br11W<'a> {
5801 register: &'a mut W,
5802 }
5803 impl<'a> _Br11W<'a> {
5804 # [ doc = r" Writes raw `bits` to the field" ]
5805 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5806 const MASK: u8 = 1;
5807 const OFFSET: u8 = 11;
5808 self.register.bits &= !((MASK as u32) << OFFSET);
5809 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5810 self.register
5811 }
5812 }
5813 # [ doc = r" Proxy" ]
5814 pub struct _Br12W<'a> {
5815 register: &'a mut W,
5816 }
5817 impl<'a> _Br12W<'a> {
5818 # [ doc = r" Writes raw `bits` to the field" ]
5819 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5820 const MASK: u8 = 1;
5821 const OFFSET: u8 = 12;
5822 self.register.bits &= !((MASK as u32) << OFFSET);
5823 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5824 self.register
5825 }
5826 }
5827 # [ doc = r" Proxy" ]
5828 pub struct _Br13W<'a> {
5829 register: &'a mut W,
5830 }
5831 impl<'a> _Br13W<'a> {
5832 # [ doc = r" Writes raw `bits` to the field" ]
5833 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5834 const MASK: u8 = 1;
5835 const OFFSET: u8 = 13;
5836 self.register.bits &= !((MASK as u32) << OFFSET);
5837 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5838 self.register
5839 }
5840 }
5841 # [ doc = r" Proxy" ]
5842 pub struct _Br14W<'a> {
5843 register: &'a mut W,
5844 }
5845 impl<'a> _Br14W<'a> {
5846 # [ doc = r" Writes raw `bits` to the field" ]
5847 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5848 const MASK: u8 = 1;
5849 const OFFSET: u8 = 14;
5850 self.register.bits &= !((MASK as u32) << OFFSET);
5851 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5852 self.register
5853 }
5854 }
5855 # [ doc = r" Proxy" ]
5856 pub struct _Br15W<'a> {
5857 register: &'a mut W,
5858 }
5859 impl<'a> _Br15W<'a> {
5860 # [ doc = r" Writes raw `bits` to the field" ]
5861 pub unsafe fn bits(self, bits: u8) -> &'a mut W {
5862 const MASK: u8 = 1;
5863 const OFFSET: u8 = 15;
5864 self.register.bits &= !((MASK as u32) << OFFSET);
5865 self.register.bits |= ((bits & MASK) as u32) << OFFSET;
5866 self.register
5867 }
5868 }
5869 impl W {
5870 # [ doc = r" Reset value of the register" ]
5871 pub fn reset_value() -> W {
5872 W { bits: 0 }
5873 }
5874 # [ doc = r" Writes raw `bits` to the register" ]
5875 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
5876 self.bits = bits;
5877 self
5878 }
5879 # [ doc = "Bit 0 - Port x Reset bit y" ]
5880 pub fn br0(&mut self) -> _Br0W {
5881 _Br0W { register: self }
5882 }
5883 # [ doc = "Bit 1 - Port x Reset bit y" ]
5884 pub fn br1(&mut self) -> _Br1W {
5885 _Br1W { register: self }
5886 }
5887 # [ doc = "Bit 2 - Port x Reset bit y" ]
5888 pub fn br2(&mut self) -> _Br2W {
5889 _Br2W { register: self }
5890 }
5891 # [ doc = "Bit 3 - Port x Reset bit y" ]
5892 pub fn br3(&mut self) -> _Br3W {
5893 _Br3W { register: self }
5894 }
5895 # [ doc = "Bit 4 - Port x Reset bit y" ]
5896 pub fn br4(&mut self) -> _Br4W {
5897 _Br4W { register: self }
5898 }
5899 # [ doc = "Bit 5 - Port x Reset bit y" ]
5900 pub fn br5(&mut self) -> _Br5W {
5901 _Br5W { register: self }
5902 }
5903 # [ doc = "Bit 6 - Port x Reset bit y" ]
5904 pub fn br6(&mut self) -> _Br6W {
5905 _Br6W { register: self }
5906 }
5907 # [ doc = "Bit 7 - Port x Reset bit y" ]
5908 pub fn br7(&mut self) -> _Br7W {
5909 _Br7W { register: self }
5910 }
5911 # [ doc = "Bit 8 - Port x Reset bit y" ]
5912 pub fn br8(&mut self) -> _Br8W {
5913 _Br8W { register: self }
5914 }
5915 # [ doc = "Bit 9 - Port x Reset bit y" ]
5916 pub fn br9(&mut self) -> _Br9W {
5917 _Br9W { register: self }
5918 }
5919 # [ doc = "Bit 10 - Port x Reset bit y" ]
5920 pub fn br10(&mut self) -> _Br10W {
5921 _Br10W { register: self }
5922 }
5923 # [ doc = "Bit 11 - Port x Reset bit y" ]
5924 pub fn br11(&mut self) -> _Br11W {
5925 _Br11W { register: self }
5926 }
5927 # [ doc = "Bit 12 - Port x Reset bit y" ]
5928 pub fn br12(&mut self) -> _Br12W {
5929 _Br12W { register: self }
5930 }
5931 # [ doc = "Bit 13 - Port x Reset bit y" ]
5932 pub fn br13(&mut self) -> _Br13W {
5933 _Br13W { register: self }
5934 }
5935 # [ doc = "Bit 14 - Port x Reset bit y" ]
5936 pub fn br14(&mut self) -> _Br14W {
5937 _Br14W { register: self }
5938 }
5939 # [ doc = "Bit 15 - Port x Reset bit y" ]
5940 pub fn br15(&mut self) -> _Br15W {
5941 _Br15W { register: self }
5942 }
5943 }
5944}