Tidy peripheral_target_address macro, implement for I2C123

Author: richardeoin

src/dma/bdma.rs

@@ -672,10 +672,8 @@ peripheral_target_address!(
         DMAReq::SPI6_RX_DMA,
         DMAReq::SPI6_TX_DMA
     ),
-    (pac::I2C4, rxdr, u8, P2M, DMAReq::I2C4_RX_DMA),
-    (pac::I2C4, txdr, u8, M2P, DMAReq::I2C4_TX_DMA),
-    (INNER: I2c<pac::I2C4>, rxdr, u8, P2M, DMAReq::I2C4_RX_DMA),
-    (INNER: I2c<pac::I2C4>, txdr, u8, M2P, DMAReq::I2C4_TX_DMA),
+    (HAL: I2c<pac::I2C4>, rxdr, u8, P2M, DMAReq::I2C4_RX_DMA),
+    (HAL: I2c<pac::I2C4>, txdr, u8, M2P, DMAReq::I2C4_TX_DMA),
 );
 
 #[cfg(not(feature = "rm0455"))]

src/dma/dma.rs

@@ -10,6 +10,7 @@ use super::{
 use core::marker::PhantomData;
 
 use crate::{
+    i2c::I2c,
     pac::{self, DMA1, DMA2, DMAMUX1},
     rcc::{rec, rec::ResetEnable},
     serial, spi,
@@ -923,6 +924,15 @@ peripheral_target_address!(
     ),
 );
 
+peripheral_target_address!(
+    (HAL: I2c<pac::I2C1>, rxdr, u8, P2M, DMAReq::I2C1_RX_DMA),
+    (HAL: I2c<pac::I2C1>, txdr, u8, M2P, DMAReq::I2C1_TX_DMA),
+    (HAL: I2c<pac::I2C2>, rxdr, u8, P2M, DMAReq::I2C2_RX_DMA),
+    (HAL: I2c<pac::I2C2>, txdr, u8, M2P, DMAReq::I2C2_TX_DMA),
+    (HAL: I2c<pac::I2C3>, rxdr, u8, P2M, DMAReq::I2C3_RX_DMA),
+    (HAL: I2c<pac::I2C3>, txdr, u8, M2P, DMAReq::I2C3_TX_DMA),
+);
+
 peripheral_target_address!(
     (pac::SAI1, cha.dr, u32, M2P, DMAReq::SAI1A_DMA),
     (pac::SAI1, chb.dr, u32, P2M, DMAReq::SAI1B_DMA),

src/dma/macros.rs

@@ -11,6 +11,7 @@ macro_rules! peripheral_target_address {
     };
 }
 macro_rules! peripheral_target_instance {
+    // PAC target
     (($peripheral:ty, $register:ident, $size:ty,
       $dir:ty $(, $mux:expr)*)) => {
         unsafe impl TargetAddress<$dir> for $peripheral {
@@ -26,8 +27,59 @@ macro_rules! peripheral_target_instance {
         }
     };
 
-    ((SPI: $peripheral:ty, $rxreg:ident, $txreg:ident, [$($size:ty),+], $rxmux:expr, $txmux:expr)) => {
-        // Access via PAC peripheral structures implies u8 sizing, as the sizing is unknown.
+    // PAC target where register is within a channel
+    (($peripheral:ty, $channel:ident.$register:ident, $size:ty,
+      $dir:ty $(, $mux:expr)*)) => {
+        unsafe impl TargetAddress<$dir> for $peripheral {
+            #[inline(always)]
+            fn address(&self) -> usize {
+                &self.$channel.$register as *const _ as usize
+            }
+
+            type MemSize = $size;
+            $(
+                const REQUEST_LINE: Option<u8> = Some($mux as u8);
+            )*
+        }
+    };
+
+    // PAC and HAL targets, generic
+    ((HAL: $hal:ident<$peripheral:ty>, $register:ident, $size:ty,
+      $dir:ty $(, $mux:expr)*)) => {
+
+        // PAC implementation
+        unsafe impl TargetAddress<$dir> for $peripheral {
+            #[inline(always)]
+            fn address(&self) -> usize {
+                &self.$register as *const _ as usize
+            }
+
+            type MemSize = $size;
+            $(
+                const REQUEST_LINE: Option<u8> = Some($mux as u8);
+            )*
+        }
+
+        // HAL implementation
+        unsafe impl TargetAddress<$dir> for $hal<$peripheral> {
+            #[inline(always)]
+            fn address(&self) -> usize {
+                &self.inner().$register as *const _ as usize
+            }
+
+            type MemSize = $size;
+            $(
+                const REQUEST_LINE: Option<u8> = Some($mux as u8);
+            )*
+        }
+    };
+
+    // PAC and HAL targets for SPI peripheral
+    ((SPI: $peripheral:ty, $rxreg:ident, $txreg:ident, [$($size:ty),+],
+      $rxmux:expr, $txmux:expr)) => {
+
+        // Access via PAC peripheral structures implies u8 sizing, as the sizing
+        // is unknown.
         unsafe impl TargetAddress<M2P> for $peripheral {
             #[inline(always)]
             fn address(&self) -> usize {
@@ -76,6 +128,7 @@ macro_rules! peripheral_target_instance {
         )+
     };
 
+    // PAC and HAL targets for Serial Peripherals
     ((SERIAL: $peripheral:ty, $rxreg:ident, $txreg:ident, $rxmux:expr, $txmux:expr)) => {
         unsafe impl TargetAddress<M2P> for $peripheral {
             #[inline(always)]
@@ -151,37 +204,4 @@ macro_rules! peripheral_target_instance {
             const TRBUFF: bool = true;
         }
     };
-
-    ((INNER: $peripheral:ty, $register:ident $(($TRBUFF:ident))*, $size:ty,
-      $dir:ty $(, $mux:expr)*)) => {
-        unsafe impl TargetAddress<$dir> for $peripheral {
-            #[inline(always)]
-            fn address(&self) -> usize {
-                &self.inner().$register as *const _ as usize
-            }
-
-            type MemSize = $size;
-            $(
-                const REQUEST_LINE: Option<u8> = Some($mux as u8);
-            )*
-                $(
-                    const $TRBUFF: bool = true;
-                )*
-        }
-    };
-
-    (($peripheral:ty, $channel:ident.$register:ident, $size:ty,
-      $dir:ty $(, $mux:expr)*)) => {
-        unsafe impl TargetAddress<$dir> for $peripheral {
-            #[inline(always)]
-            fn address(&self) -> usize {
-                &self.$channel.$register as *const _ as usize
-            }
-
-            type MemSize = $size;
-            $(
-                const REQUEST_LINE: Option<u8> = Some($mux as u8);
-            )*
-        }
-    };
 }