1use core::marker;
2#[doc = " Raw register type (`u8`, `u16`, `u32`, ...)"]
3pub trait RawReg:
4 Copy
5 + Default
6 + From<bool>
7 + core::ops::BitOr<Output = Self>
8 + core::ops::BitAnd<Output = Self>
9 + core::ops::BitOrAssign
10 + core::ops::BitAndAssign
11 + core::ops::Not<Output = Self>
12 + core::ops::Shl<u8, Output = Self>
13{
14 #[doc = " Mask for bits of width `WI`"]
15 fn mask<const WI: u8>() -> Self;
16 #[doc = " Mask for bits of width 1"]
17 fn one() -> Self;
18}
19macro_rules! raw_reg {
20 ($ U : ty , $ size : literal , $ mask : ident) => {
21 impl RawReg for $U {
22 #[inline(always)]
23 fn mask<const WI: u8>() -> Self {
24 $mask::<WI>()
25 }
26 #[inline(always)]
27 fn one() -> Self {
28 1
29 }
30 }
31 const fn $mask<const WI: u8>() -> $U {
32 <$U>::MAX >> ($size - WI)
33 }
34 impl FieldSpec for $U {
35 type Ux = $U;
36 }
37 };
38}
39raw_reg!(u8, 8, mask_u8);
40raw_reg!(u16, 16, mask_u16);
41raw_reg!(u32, 32, mask_u32);
42raw_reg!(u64, 64, mask_u64);
43#[doc = " Raw register type"]
44pub trait RegisterSpec {
45 #[doc = " Raw register type (`u8`, `u16`, `u32`, ...)."]
46 type Ux: RawReg;
47}
48#[doc = " Raw field type"]
49pub trait FieldSpec: Sized {
50 #[doc = " Raw field type (`u8`, `u16`, `u32`, ...)."]
51 type Ux: Copy + core::fmt::Debug + PartialEq + From<Self>;
52}
53#[doc = " Marker for fields with fixed values"]
54pub trait IsEnum: FieldSpec {}
55#[doc = " Trait implemented by readable registers to enable the `read` method."]
56#[doc = ""]
57#[doc = " Registers marked with `Writable` can be also be `modify`'ed."]
58pub trait Readable: RegisterSpec {}
59#[doc = " Trait implemented by writeable registers."]
60#[doc = ""]
61#[doc = " This enables the `write`, `write_with_zero` and `reset` methods."]
62#[doc = ""]
63#[doc = " Registers marked with `Readable` can be also be `modify`'ed."]
64pub trait Writable: RegisterSpec {
65 #[doc = " Is it safe to write any bits to register"]
66 type Safety;
67 #[doc = " Specifies the register bits that are not changed if you pass `1` and are changed if you pass `0`"]
68 const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux;
69 #[doc = " Specifies the register bits that are not changed if you pass `0` and are changed if you pass `1`"]
70 const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux;
71}
72#[doc = " Reset value of the register."]
73#[doc = ""]
74#[doc = " This value is the initial value for the `write` method. It can also be directly written to the"]
75#[doc = " register by using the `reset` method."]
76pub trait Resettable: RegisterSpec {
77 #[doc = " Reset value of the register."]
78 const RESET_VALUE: Self::Ux;
79 #[doc = " Reset value of the register."]
80 #[inline(always)]
81 fn reset_value() -> Self::Ux {
82 Self::RESET_VALUE
83 }
84}
85#[doc(hidden)]
86pub mod raw;
87#[doc = " Register reader."]
88#[doc = ""]
89#[doc = " Result of the `read` methods of registers. Also used as a closure argument in the `modify`"]
90#[doc = " method."]
91pub type R<REG> = raw::R<REG>;
92impl<REG: RegisterSpec> R<REG> {
93 #[doc = " Reads raw bits from register."]
94 #[inline(always)]
95 pub const fn bits(&self) -> REG::Ux {
96 self.bits
97 }
98}
99impl<REG: RegisterSpec, FI> PartialEq<FI> for R<REG>
100where
101 REG::Ux: PartialEq,
102 FI: Copy,
103 REG::Ux: From<FI>,
104{
105 #[inline(always)]
106 fn eq(&self, other: &FI) -> bool {
107 self.bits.eq(®::Ux::from(*other))
108 }
109}
110#[doc = " Register writer."]
111#[doc = ""]
112#[doc = " Used as an argument to the closures in the `write` and `modify` methods of the register."]
113pub type W<REG> = raw::W<REG>;
114impl<REG: Writable> W<REG> {
115 #[doc = " Writes raw bits to the register."]
116 #[doc = ""]
117 #[doc = " # Safety"]
118 #[doc = ""]
119 #[doc = " Passing incorrect value can cause undefined behaviour. See reference manual"]
120 #[inline(always)]
121 pub unsafe fn bits(&mut self, bits: REG::Ux) -> &mut Self {
122 self.bits = bits;
123 self
124 }
125}
126impl<REG> W<REG>
127where
128 REG: Writable<Safety = Safe>,
129{
130 #[doc = " Writes raw bits to the register."]
131 #[inline(always)]
132 pub fn set(&mut self, bits: REG::Ux) -> &mut Self {
133 self.bits = bits;
134 self
135 }
136}
137#[doc = " Field reader."]
138#[doc = ""]
139#[doc = " Result of the `read` methods of fields."]
140pub type FieldReader<FI = u8> = raw::FieldReader<FI>;
141#[doc = " Bit-wise field reader"]
142pub type BitReader<FI = bool> = raw::BitReader<FI>;
143impl<FI: FieldSpec> FieldReader<FI> {
144 #[doc = " Reads raw bits from field."]
145 #[inline(always)]
146 pub const fn bits(&self) -> FI::Ux {
147 self.bits
148 }
149}
150impl<FI: FieldSpec> core::fmt::Debug for FieldReader<FI> {
151 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
152 core::fmt::Debug::fmt(&self.bits, f)
153 }
154}
155impl<FI> PartialEq<FI> for FieldReader<FI>
156where
157 FI: FieldSpec + Copy,
158{
159 #[inline(always)]
160 fn eq(&self, other: &FI) -> bool {
161 self.bits.eq(&FI::Ux::from(*other))
162 }
163}
164impl<FI> PartialEq<FI> for BitReader<FI>
165where
166 FI: Copy,
167 bool: From<FI>,
168{
169 #[inline(always)]
170 fn eq(&self, other: &FI) -> bool {
171 self.bits.eq(&bool::from(*other))
172 }
173}
174impl<FI> BitReader<FI> {
175 #[doc = " Value of the field as raw bits."]
176 #[inline(always)]
177 pub const fn bit(&self) -> bool {
178 self.bits
179 }
180 #[doc = " Returns `true` if the bit is clear (0)."]
181 #[inline(always)]
182 pub const fn bit_is_clear(&self) -> bool {
183 !self.bit()
184 }
185 #[doc = " Returns `true` if the bit is set (1)."]
186 #[inline(always)]
187 pub const fn bit_is_set(&self) -> bool {
188 self.bit()
189 }
190}
191impl<FI> core::fmt::Debug for BitReader<FI> {
192 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
193 core::fmt::Debug::fmt(&self.bits, f)
194 }
195}
196#[doc = " Marker for register/field writers which can take any value of specified width"]
197pub struct Safe;
198#[doc = " You should check that value is allowed to pass to register/field writer marked with this"]
199pub struct Unsafe;
200#[doc = " Marker for field writers are safe to write in specified inclusive range"]
201pub struct Range<const MIN: u64, const MAX: u64>;
202#[doc = " Marker for field writers are safe to write in specified inclusive range"]
203pub struct RangeFrom<const MIN: u64>;
204#[doc = " Marker for field writers are safe to write in specified inclusive range"]
205pub struct RangeTo<const MAX: u64>;
206#[doc = " Write field Proxy"]
207pub type FieldWriter<'a, REG, const WI: u8, FI = u8, Safety = Unsafe> =
208 raw::FieldWriter<'a, REG, WI, FI, Safety>;
209impl<'a, REG, const WI: u8, FI, Safety> FieldWriter<'a, REG, WI, FI, Safety>
210where
211 REG: Writable + RegisterSpec,
212 FI: FieldSpec,
213{
214 #[doc = " Field width"]
215 pub const WIDTH: u8 = WI;
216 #[doc = " Field width"]
217 #[inline(always)]
218 pub const fn width(&self) -> u8 {
219 WI
220 }
221 #[doc = " Field offset"]
222 #[inline(always)]
223 pub const fn offset(&self) -> u8 {
224 self.o
225 }
226}
227impl<'a, REG, const WI: u8, FI, Safety> FieldWriter<'a, REG, WI, FI, Safety>
228where
229 REG: Writable + RegisterSpec,
230 FI: FieldSpec,
231 REG::Ux: From<FI::Ux>,
232{
233 #[doc = " Writes raw bits to the field"]
234 #[doc = ""]
235 #[doc = " # Safety"]
236 #[doc = ""]
237 #[doc = " Passing incorrect value can cause undefined behaviour. See reference manual"]
238 #[inline(always)]
239 pub unsafe fn bits(self, value: FI::Ux) -> &'a mut W<REG> {
240 self.w.bits &= !(REG::Ux::mask::<WI>() << self.o);
241 self.w.bits |= (REG::Ux::from(value) & REG::Ux::mask::<WI>()) << self.o;
242 self.w
243 }
244}
245impl<'a, REG, const WI: u8, FI> FieldWriter<'a, REG, WI, FI, Safe>
246where
247 REG: Writable + RegisterSpec,
248 FI: FieldSpec,
249 REG::Ux: From<FI::Ux>,
250{
251 #[doc = " Writes raw bits to the field"]
252 #[inline(always)]
253 pub fn set(self, value: FI::Ux) -> &'a mut W<REG> {
254 unsafe { self.bits(value) }
255 }
256}
257impl<'a, REG, const WI: u8, FI, const MIN: u64, const MAX: u64>
258 FieldWriter<'a, REG, WI, FI, Range<MIN, MAX>>
259where
260 REG: Writable + RegisterSpec,
261 FI: FieldSpec,
262 REG::Ux: From<FI::Ux>,
263 u64: From<FI::Ux>,
264{
265 #[doc = " Writes raw bits to the field"]
266 #[inline(always)]
267 pub fn set(self, value: FI::Ux) -> &'a mut W<REG> {
268 {
269 let value = u64::from(value);
270 assert!(value >= MIN && value <= MAX);
271 }
272 unsafe { self.bits(value) }
273 }
274}
275impl<'a, REG, const WI: u8, FI, const MIN: u64> FieldWriter<'a, REG, WI, FI, RangeFrom<MIN>>
276where
277 REG: Writable + RegisterSpec,
278 FI: FieldSpec,
279 REG::Ux: From<FI::Ux>,
280 u64: From<FI::Ux>,
281{
282 #[doc = " Writes raw bits to the field"]
283 #[inline(always)]
284 pub fn set(self, value: FI::Ux) -> &'a mut W<REG> {
285 {
286 let value = u64::from(value);
287 assert!(value >= MIN);
288 }
289 unsafe { self.bits(value) }
290 }
291}
292impl<'a, REG, const WI: u8, FI, const MAX: u64> FieldWriter<'a, REG, WI, FI, RangeTo<MAX>>
293where
294 REG: Writable + RegisterSpec,
295 FI: FieldSpec,
296 REG::Ux: From<FI::Ux>,
297 u64: From<FI::Ux>,
298{
299 #[doc = " Writes raw bits to the field"]
300 #[inline(always)]
301 pub fn set(self, value: FI::Ux) -> &'a mut W<REG> {
302 {
303 let value = u64::from(value);
304 assert!(value <= MAX);
305 }
306 unsafe { self.bits(value) }
307 }
308}
309impl<'a, REG, const WI: u8, FI, Safety> FieldWriter<'a, REG, WI, FI, Safety>
310where
311 REG: Writable + RegisterSpec,
312 FI: IsEnum,
313 REG::Ux: From<FI::Ux>,
314{
315 #[doc = " Writes `variant` to the field"]
316 #[inline(always)]
317 pub fn variant(self, variant: FI) -> &'a mut W<REG> {
318 unsafe { self.bits(FI::Ux::from(variant)) }
319 }
320}
321macro_rules! bit_proxy {
322 ($ writer : ident , $ mwv : ident) => {
323 #[doc(hidden)]
324 pub struct $mwv;
325 #[doc = " Bit-wise write field proxy"]
326 pub type $writer<'a, REG, FI = bool> = raw::BitWriter<'a, REG, FI, $mwv>;
327 impl<'a, REG, FI> $writer<'a, REG, FI>
328 where
329 REG: Writable + RegisterSpec,
330 bool: From<FI>,
331 {
332 #[doc = " Field width"]
333 pub const WIDTH: u8 = 1;
334 #[doc = " Field width"]
335 #[inline(always)]
336 pub const fn width(&self) -> u8 {
337 Self::WIDTH
338 }
339 #[doc = " Field offset"]
340 #[inline(always)]
341 pub const fn offset(&self) -> u8 {
342 self.o
343 }
344 #[doc = " Writes bit to the field"]
345 #[inline(always)]
346 pub fn bit(self, value: bool) -> &'a mut W<REG> {
347 self.w.bits &= !(REG::Ux::one() << self.o);
348 self.w.bits |= (REG::Ux::from(value) & REG::Ux::one()) << self.o;
349 self.w
350 }
351 #[doc = " Writes `variant` to the field"]
352 #[inline(always)]
353 pub fn variant(self, variant: FI) -> &'a mut W<REG> {
354 self.bit(bool::from(variant))
355 }
356 }
357 };
358}
359bit_proxy!(BitWriter, BitM);
360bit_proxy!(BitWriter1S, Bit1S);
361bit_proxy!(BitWriter0C, Bit0C);
362bit_proxy!(BitWriter1C, Bit1C);
363bit_proxy!(BitWriter0S, Bit0S);
364bit_proxy!(BitWriter1T, Bit1T);
365bit_proxy!(BitWriter0T, Bit0T);
366impl<'a, REG, FI> BitWriter<'a, REG, FI>
367where
368 REG: Writable + RegisterSpec,
369 bool: From<FI>,
370{
371 #[doc = " Sets the field bit"]
372 #[inline(always)]
373 pub fn set_bit(self) -> &'a mut W<REG> {
374 self.w.bits |= REG::Ux::one() << self.o;
375 self.w
376 }
377 #[doc = " Clears the field bit"]
378 #[inline(always)]
379 pub fn clear_bit(self) -> &'a mut W<REG> {
380 self.w.bits &= !(REG::Ux::one() << self.o);
381 self.w
382 }
383}
384impl<'a, REG, FI> BitWriter1S<'a, REG, FI>
385where
386 REG: Writable + RegisterSpec,
387 bool: From<FI>,
388{
389 #[doc = " Sets the field bit"]
390 #[inline(always)]
391 pub fn set_bit(self) -> &'a mut W<REG> {
392 self.w.bits |= REG::Ux::one() << self.o;
393 self.w
394 }
395}
396impl<'a, REG, FI> BitWriter0C<'a, REG, FI>
397where
398 REG: Writable + RegisterSpec,
399 bool: From<FI>,
400{
401 #[doc = " Clears the field bit"]
402 #[inline(always)]
403 pub fn clear_bit(self) -> &'a mut W<REG> {
404 self.w.bits &= !(REG::Ux::one() << self.o);
405 self.w
406 }
407}
408impl<'a, REG, FI> BitWriter1C<'a, REG, FI>
409where
410 REG: Writable + RegisterSpec,
411 bool: From<FI>,
412{
413 #[doc = "Clears the field bit by passing one"]
414 #[inline(always)]
415 pub fn clear_bit_by_one(self) -> &'a mut W<REG> {
416 self.w.bits |= REG::Ux::one() << self.o;
417 self.w
418 }
419}
420impl<'a, REG, FI> BitWriter0S<'a, REG, FI>
421where
422 REG: Writable + RegisterSpec,
423 bool: From<FI>,
424{
425 #[doc = "Sets the field bit by passing zero"]
426 #[inline(always)]
427 pub fn set_bit_by_zero(self) -> &'a mut W<REG> {
428 self.w.bits &= !(REG::Ux::one() << self.o);
429 self.w
430 }
431}
432impl<'a, REG, FI> BitWriter1T<'a, REG, FI>
433where
434 REG: Writable + RegisterSpec,
435 bool: From<FI>,
436{
437 #[doc = "Toggle the field bit by passing one"]
438 #[inline(always)]
439 pub fn toggle_bit(self) -> &'a mut W<REG> {
440 self.w.bits |= REG::Ux::one() << self.o;
441 self.w
442 }
443}
444impl<'a, REG, FI> BitWriter0T<'a, REG, FI>
445where
446 REG: Writable + RegisterSpec,
447 bool: From<FI>,
448{
449 #[doc = "Toggle the field bit by passing zero"]
450 #[inline(always)]
451 pub fn toggle_bit(self) -> &'a mut W<REG> {
452 self.w.bits &= !(REG::Ux::one() << self.o);
453 self.w
454 }
455}
456#[doc = " This structure provides volatile access to registers."]
457#[repr(transparent)]
458pub struct Reg<REG: RegisterSpec> {
459 register: vcell::VolatileCell<REG::Ux>,
460 _marker: marker::PhantomData<REG>,
461}
462unsafe impl<REG: RegisterSpec> Send for Reg<REG> where REG::Ux: Send {}
463impl<REG: RegisterSpec> Reg<REG> {
464 #[doc = " Returns the underlying memory address of register."]
465 #[doc = ""]
466 #[doc = " ```ignore"]
467 #[doc = " let reg_ptr = periph.reg.as_ptr();"]
468 #[doc = " ```"]
469 #[inline(always)]
470 pub fn as_ptr(&self) -> *mut REG::Ux {
471 self.register.as_ptr()
472 }
473}
474impl<REG: Readable> Reg<REG> {
475 #[doc = " Reads the contents of a `Readable` register."]
476 #[doc = ""]
477 #[doc = " You can read the raw contents of a register by using `bits`:"]
478 #[doc = " ```ignore"]
479 #[doc = " let bits = periph.reg.read().bits();"]
480 #[doc = " ```"]
481 #[doc = " or get the content of a particular field of a register:"]
482 #[doc = " ```ignore"]
483 #[doc = " let reader = periph.reg.read();"]
484 #[doc = " let bits = reader.field1().bits();"]
485 #[doc = " let flag = reader.field2().bit_is_set();"]
486 #[doc = " ```"]
487 #[inline(always)]
488 pub fn read(&self) -> R<REG> {
489 R {
490 bits: self.register.get(),
491 _reg: marker::PhantomData,
492 }
493 }
494}
495impl<REG: Resettable + Writable> Reg<REG> {
496 #[doc = " Writes the reset value to `Writable` register."]
497 #[doc = ""]
498 #[doc = " Resets the register to its initial state."]
499 #[inline(always)]
500 pub fn reset(&self) {
501 self.register.set(REG::RESET_VALUE)
502 }
503 #[doc = " Writes bits to a `Writable` register."]
504 #[doc = ""]
505 #[doc = " You can write raw bits into a register:"]
506 #[doc = " ```ignore"]
507 #[doc = " periph.reg.write(|w| unsafe { w.bits(rawbits) });"]
508 #[doc = " ```"]
509 #[doc = " or write only the fields you need:"]
510 #[doc = " ```ignore"]
511 #[doc = " periph.reg.write(|w| w"]
512 #[doc = " .field1().bits(newfield1bits)"]
513 #[doc = " .field2().set_bit()"]
514 #[doc = " .field3().variant(VARIANT)"]
515 #[doc = " );"]
516 #[doc = " ```"]
517 #[doc = " or an alternative way of saying the same:"]
518 #[doc = " ```ignore"]
519 #[doc = " periph.reg.write(|w| {"]
520 #[doc = " w.field1().bits(newfield1bits);"]
521 #[doc = " w.field2().set_bit();"]
522 #[doc = " w.field3().variant(VARIANT)"]
523 #[doc = " });"]
524 #[doc = " ```"]
525 #[doc = " In the latter case, other fields will be set to their reset value."]
526 #[inline(always)]
527 pub fn write<F>(&self, f: F) -> REG::Ux
528 where
529 F: FnOnce(&mut W<REG>) -> &mut W<REG>,
530 {
531 let value = f(&mut W {
532 bits: REG::RESET_VALUE & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
533 | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
534 _reg: marker::PhantomData,
535 })
536 .bits;
537 self.register.set(value);
538 value
539 }
540 #[doc = " Writes bits to a `Writable` register and produce a value."]
541 #[doc = ""]
542 #[doc = " You can write raw bits into a register:"]
543 #[doc = " ```ignore"]
544 #[doc = " periph.reg.write_and(|w| unsafe { w.bits(rawbits); });"]
545 #[doc = " ```"]
546 #[doc = " or write only the fields you need:"]
547 #[doc = " ```ignore"]
548 #[doc = " periph.reg.write_and(|w| {"]
549 #[doc = " w.field1().bits(newfield1bits)"]
550 #[doc = " .field2().set_bit()"]
551 #[doc = " .field3().variant(VARIANT);"]
552 #[doc = " });"]
553 #[doc = " ```"]
554 #[doc = " or an alternative way of saying the same:"]
555 #[doc = " ```ignore"]
556 #[doc = " periph.reg.write_and(|w| {"]
557 #[doc = " w.field1().bits(newfield1bits);"]
558 #[doc = " w.field2().set_bit();"]
559 #[doc = " w.field3().variant(VARIANT);"]
560 #[doc = " });"]
561 #[doc = " ```"]
562 #[doc = " In the latter case, other fields will be set to their reset value."]
563 #[doc = ""]
564 #[doc = " Values can be returned from the closure:"]
565 #[doc = " ```ignore"]
566 #[doc = " let state = periph.reg.write_and(|w| State::set(w.field1()));"]
567 #[doc = " ```"]
568 #[inline(always)]
569 pub fn from_write<F, T>(&self, f: F) -> T
570 where
571 F: FnOnce(&mut W<REG>) -> T,
572 {
573 let mut writer = W {
574 bits: REG::RESET_VALUE & !REG::ONE_TO_MODIFY_FIELDS_BITMAP
575 | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
576 _reg: marker::PhantomData,
577 };
578 let result = f(&mut writer);
579 self.register.set(writer.bits);
580 result
581 }
582}
583impl<REG: Writable> Reg<REG> {
584 #[doc = " Writes 0 to a `Writable` register."]
585 #[doc = ""]
586 #[doc = " Similar to `write`, but unused bits will contain 0."]
587 #[doc = ""]
588 #[doc = " # Safety"]
589 #[doc = ""]
590 #[doc = " Unsafe to use with registers which don't allow to write 0."]
591 #[inline(always)]
592 pub unsafe fn write_with_zero<F>(&self, f: F) -> REG::Ux
593 where
594 F: FnOnce(&mut W<REG>) -> &mut W<REG>,
595 {
596 let value = f(&mut W {
597 bits: REG::Ux::default(),
598 _reg: marker::PhantomData,
599 })
600 .bits;
601 self.register.set(value);
602 value
603 }
604 #[doc = " Writes 0 to a `Writable` register and produces a value."]
605 #[doc = ""]
606 #[doc = " Similar to `write`, but unused bits will contain 0."]
607 #[doc = ""]
608 #[doc = " # Safety"]
609 #[doc = ""]
610 #[doc = " Unsafe to use with registers which don't allow to write 0."]
611 #[inline(always)]
612 pub unsafe fn from_write_with_zero<F, T>(&self, f: F) -> T
613 where
614 F: FnOnce(&mut W<REG>) -> T,
615 {
616 let mut writer = W {
617 bits: REG::Ux::default(),
618 _reg: marker::PhantomData,
619 };
620 let result = f(&mut writer);
621 self.register.set(writer.bits);
622 result
623 }
624}
625impl<REG: Readable + Writable> Reg<REG> {
626 #[doc = " Modifies the contents of the register by reading and then writing it."]
627 #[doc = ""]
628 #[doc = " E.g. to do a read-modify-write sequence to change parts of a register:"]
629 #[doc = " ```ignore"]
630 #[doc = " periph.reg.modify(|r, w| unsafe { w.bits("]
631 #[doc = " r.bits() | 3"]
632 #[doc = " ) });"]
633 #[doc = " ```"]
634 #[doc = " or"]
635 #[doc = " ```ignore"]
636 #[doc = " periph.reg.modify(|_, w| w"]
637 #[doc = " .field1().bits(newfield1bits)"]
638 #[doc = " .field2().set_bit()"]
639 #[doc = " .field3().variant(VARIANT)"]
640 #[doc = " );"]
641 #[doc = " ```"]
642 #[doc = " or an alternative way of saying the same:"]
643 #[doc = " ```ignore"]
644 #[doc = " periph.reg.modify(|_, w| {"]
645 #[doc = " w.field1().bits(newfield1bits);"]
646 #[doc = " w.field2().set_bit();"]
647 #[doc = " w.field3().variant(VARIANT)"]
648 #[doc = " });"]
649 #[doc = " ```"]
650 #[doc = " Other fields will have the value they had before the call to `modify`."]
651 #[inline(always)]
652 pub fn modify<F>(&self, f: F) -> REG::Ux
653 where
654 for<'w> F: FnOnce(&R<REG>, &'w mut W<REG>) -> &'w mut W<REG>,
655 {
656 let bits = self.register.get();
657 let value = f(
658 &R {
659 bits,
660 _reg: marker::PhantomData,
661 },
662 &mut W {
663 bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
664 _reg: marker::PhantomData,
665 },
666 )
667 .bits;
668 self.register.set(value);
669 value
670 }
671 #[doc = " Modifies the contents of the register by reading and then writing it"]
672 #[doc = " and produces a value."]
673 #[doc = ""]
674 #[doc = " E.g. to do a read-modify-write sequence to change parts of a register:"]
675 #[doc = " ```ignore"]
676 #[doc = " let bits = periph.reg.modify(|r, w| {"]
677 #[doc = " let new_bits = r.bits() | 3;"]
678 #[doc = " unsafe {"]
679 #[doc = " w.bits(new_bits);"]
680 #[doc = " }"]
681 #[doc = ""]
682 #[doc = " new_bits"]
683 #[doc = " });"]
684 #[doc = " ```"]
685 #[doc = " or"]
686 #[doc = " ```ignore"]
687 #[doc = " periph.reg.modify(|_, w| {"]
688 #[doc = " w.field1().bits(newfield1bits)"]
689 #[doc = " .field2().set_bit()"]
690 #[doc = " .field3().variant(VARIANT);"]
691 #[doc = " });"]
692 #[doc = " ```"]
693 #[doc = " or an alternative way of saying the same:"]
694 #[doc = " ```ignore"]
695 #[doc = " periph.reg.modify(|_, w| {"]
696 #[doc = " w.field1().bits(newfield1bits);"]
697 #[doc = " w.field2().set_bit();"]
698 #[doc = " w.field3().variant(VARIANT);"]
699 #[doc = " });"]
700 #[doc = " ```"]
701 #[doc = " Other fields will have the value they had before the call to `modify`."]
702 #[inline(always)]
703 pub fn from_modify<F, T>(&self, f: F) -> T
704 where
705 for<'w> F: FnOnce(&R<REG>, &'w mut W<REG>) -> T,
706 {
707 let bits = self.register.get();
708 let mut writer = W {
709 bits: bits & !REG::ONE_TO_MODIFY_FIELDS_BITMAP | REG::ZERO_TO_MODIFY_FIELDS_BITMAP,
710 _reg: marker::PhantomData,
711 };
712 let result = f(
713 &R {
714 bits,
715 _reg: marker::PhantomData,
716 },
717 &mut writer,
718 );
719 self.register.set(writer.bits);
720 result
721 }
722}
723impl<REG: Readable> core::fmt::Debug for crate::generic::Reg<REG>
724where
725 R<REG>: core::fmt::Debug,
726{
727 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
728 core::fmt::Debug::fmt(&self.read(), f)
729 }
730}