Merge #647

647: into_mode for ErasedPin and PartiallyErasedPin r=therealprof a=burrbull



Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

CHANGELOG.md

@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
+
  - Integrate new version of stm32_i2s (v0.5) to enable full-duplex operation
  - Add a rtic example to show how to do full-duplex i2s
 
@@ -16,6 +17,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 
+ - `into_mode` for `ErasedPin` and `PartiallyErasedPin`
  - Extended 64-bit monotonic timer [#640]
  - Basic blocking QSPI interface [#645]
  - Rtc: add subsecond reading, add interrupts [#446]

src/gpio/convert.rs

@@ -204,45 +204,84 @@ impl<const P: char, const N: u8, MODE: PinMode> Pin<P, N, MODE> {
     /// ensure they use this properly.
     #[inline(always)]
     pub(super) fn mode<M: PinMode>(&mut self) {
-        let offset = 2 * N;
+        change_mode!((*Gpio::<P>::ptr()), N);
+    }
+
+    #[inline(always)]
+    /// Converts pin into specified mode
+    pub fn into_mode<M: PinMode>(mut self) -> Pin<P, N, M> {
+        self.mode::<M>();
+        Pin::new()
+    }
+}
+
+macro_rules! change_mode {
+    ($block:expr, $N:ident) => {
+        let offset = 2 * $N;
         unsafe {
             if MODE::OTYPER != M::OTYPER {
                 if let Some(otyper) = M::OTYPER {
-                    (*Gpio::<P>::ptr())
+                    $block
                         .otyper
-                        .modify(|r, w| w.bits(r.bits() & !(0b1 << N) | (otyper << N)));
+                        .modify(|r, w| w.bits(r.bits() & !(0b1 << $N) | (otyper << $N)));
                 }
             }
 
             if MODE::AFR != M::AFR {
                 if let Some(afr) = M::AFR {
-                    if N < 8 {
-                        let offset2 = 4 * { N };
-                        (*Gpio::<P>::ptr()).afrl.modify(|r, w| {
+                    if $N < 8 {
+                        let offset2 = 4 * { $N };
+                        $block.afrl.modify(|r, w| {
                             w.bits((r.bits() & !(0b1111 << offset2)) | (afr << offset2))
                         });
                     } else {
-                        let offset2 = 4 * { N - 8 };
-                        (*Gpio::<P>::ptr()).afrh.modify(|r, w| {
+                        let offset2 = 4 * { $N - 8 };
+                        $block.afrh.modify(|r, w| {
                             w.bits((r.bits() & !(0b1111 << offset2)) | (afr << offset2))
                         });
                     }
                 }
             }
 
             if MODE::MODER != M::MODER {
-                (*Gpio::<P>::ptr())
+                $block
                     .moder
                     .modify(|r, w| w.bits((r.bits() & !(0b11 << offset)) | (M::MODER << offset)));
             }
         }
+    };
+}
+use change_mode;
+
+use super::ErasedPin;
+impl<MODE: PinMode> ErasedPin<MODE> {
+    #[inline(always)]
+    pub(super) fn mode<M: PinMode>(&mut self) {
+        let n = self.pin_id();
+        change_mode!(self.block(), n);
     }
 
     #[inline(always)]
     /// Converts pin into specified mode
-    pub fn into_mode<M: PinMode>(mut self) -> Pin<P, N, M> {
+    pub fn into_mode<M: PinMode>(mut self) -> ErasedPin<M> {
         self.mode::<M>();
-        Pin::new()
+        ErasedPin::from_pin_port(self.into_pin_port())
+    }
+}
+
+use super::PartiallyErasedPin;
+impl<const P: char, MODE: PinMode> PartiallyErasedPin<P, MODE> {
+    #[inline(always)]
+    pub(super) fn mode<M: PinMode>(&mut self) {
+        let n = self.pin_id();
+        change_mode!((*Gpio::<P>::ptr()), n);
+    }
+
+    #[inline(always)]
+    /// Converts pin into specified mode
+    pub fn into_mode<M: PinMode>(mut self) -> PartiallyErasedPin<P, M> {
+        self.mode::<M>();
+        PartiallyErasedPin::new(self.i)
     }
 }
 

src/gpio/erased.rs

@@ -49,6 +49,15 @@ impl<MODE> PinExt for ErasedPin<MODE> {
 }
 
 impl<MODE> ErasedPin<MODE> {
+    pub(crate) fn from_pin_port(pin_port: u8) -> Self {
+        Self {
+            pin_port,
+            _mode: PhantomData,
+        }
+    }
+    pub(crate) fn into_pin_port(self) -> u8 {
+        self.pin_port
+    }
     pub(crate) fn new(port: u8, pin: u8) -> Self {
         Self {
             pin_port: port << 4 | pin,
@@ -64,7 +73,7 @@ impl<MODE> ErasedPin<MODE> {
     }
 
     #[inline]
-    fn block(&self) -> &crate::pac::gpioa::RegisterBlock {
+    pub(crate) fn block(&self) -> &crate::pac::gpioa::RegisterBlock {
         // This function uses pointer arithmetic instead of branching to be more efficient
 
         // The logic relies on the following assumptions: