Adds DMA implementation

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.5.0"
 authors = ["Andrew Straw <[email protected]>",
            "Richard Meadows <[email protected]>",
            "Henrik Böving <[email protected]>",
-           "Jan Adä <[email protected]>",
+           "Jan Adä <[email protected]>",
            "Robert Jördens <[email protected]>",
            "Florian Jung <[email protected]>"]
 edition = "2018"
@@ -29,6 +29,8 @@ stm32h7 = "0.11.0"
 void = { version = "1.0.2", default-features = false }
 cast = { version = "0.2.2", default-features = false }
 nb = "0.1.2"
+# FIXME: Change to crates.io when next version (> 0.3.2) gets released
+enum-as-inner = { git = "https://github.com/bluejekyll/enum-as-inner", rev = "9670594f29ade6feba581ee746736087e335210b" }
 paste = "0.1.10"
 
 [dependencies.bare-metal]
@@ -47,6 +49,7 @@ device-selected = []
 revision_v = []
 singlecore = []
 dualcore = []
+dma = []
 cm4 = []
 cm7 = []
 rt = ["stm32h7/rt"]

examples/adc.rs

@@ -7,19 +7,13 @@ extern crate panic_itm;
 use cortex_m;
 use cortex_m_rt::entry;
 
-use stm32h7xx_hal::{
-    adc,
-    pac,
-    delay::Delay,
-    prelude::*,
-};
+use stm32h7xx_hal::{adc, delay::Delay, pac, prelude::*};
 
 use cortex_m_log::println;
 use cortex_m_log::{
     destination::Itm, printer::itm::InterruptSync as InterruptSyncItm,
 };
 
-
 #[entry]
 fn main() -> ! {
     let cp = cortex_m::Peripherals::take().unwrap();
@@ -36,9 +30,12 @@ fn main() -> ! {
     let rcc = dp.RCC.constrain();
 
     // setting this per_ck to 4 Mhz here (which is gonna choose the CSI that runs at exactly 4 Mhz) as the adc requires per_ck as its
-    // own kernel clock and wouldn't work at all if per_ck wouldnt be enabled or loose a few bits if it was too fast 
+    // own kernel clock and wouldn't work at all if per_ck wouldnt be enabled or loose a few bits if it was too fast
     // (the maximum for this is 36 Mhz)
-    let mut ccdr = rcc.sys_ck(100.mhz()).per_ck(4.mhz()).freeze(vos, &dp.SYSCFG);
+    let mut ccdr = rcc
+        .sys_ck(100.mhz())
+        .per_ck(4.mhz())
+        .freeze(vos, &dp.SYSCFG);
 
     println!(log, "");
     println!(log, "stm32h7xx-hal example - ADC");
@@ -59,6 +56,11 @@ fn main() -> ! {
     loop {
         let data: u32 = adc3.read(&mut channel).unwrap();
         // voltage = reading * (vref/resolution)
-        println!(log, "ADC reading: {}, voltage for nucleo: {}", data, data as f32 * (3.3/adc3.max_sample() as f32));
+        println!(
+            log,
+            "ADC reading: {}, voltage for nucleo: {}",
+            data,
+            data as f32 * (3.3 / adc3.max_sample() as f32)
+        );
     }
 }

memory.x

@@ -3,10 +3,9 @@ MEMORY
   /* FLASH and RAM are mandatory memory regions */
   FLASH  : ORIGIN = 0x08000000, LENGTH = 1024K
   FLASH1 : ORIGIN = 0x08100000, LENGTH = 1024K
-  RAM    : ORIGIN = 0x20000000, LENGTH = 128K
 
-  /* AXISRAM */
-  AXISRAM : ORIGIN = 0x24000000, LENGTH = 512K
+  /* AXISRAM = RAM */
+  RAM : ORIGIN = 0x24000000, LENGTH = 512K
 
   /* SRAM */
   SRAM1 : ORIGIN = 0x30000000, LENGTH = 128K
@@ -19,6 +18,9 @@ MEMORY
 
   /* Instruction TCM */
   ITCM  : ORIGIN = 0x00000000, LENGTH = 64K
+
+  /* Data TCM */
+  DTCM    : ORIGIN = 0x20000000, LENGTH = 128K
 }
 
 /* The location of the stack can be overridden using the

src/dma/macros.rs

@@ -0,0 +1,244 @@
+//! Macros
+
+macro_rules! type_state {
+    ($trait:ident $({$($item_def:item),*})?, $($type_state:ident $({$($item_impl:item),*})?),*) => {
+        pub trait $trait: Copy + Clone + PartialEq + Eq + core::fmt::Debug + crate::private::Sealed {
+            $(
+                $(
+                    $item_def
+                )*
+            )?
+        }
+
+        $(
+            #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+            pub struct $type_state {
+                _private: (),
+            }
+
+            impl crate::private::Sealed for $type_state {}
+
+            impl $trait for $type_state {
+                $(
+                    $(
+                        $item_impl
+                    )*
+                )?
+            }
+        )*
+    };
+}
+
+/// Macro for generating enums that map one-to-one to bool values.
+///
+/// To set the default variant, write `(D)` after it.
+macro_rules! bool_enum {
+    ($name:ident, $doc:tt, $v_false:ident $((D $($_syntax_false:ident)?))?, $v_true:ident $((D $($_syntax_true:ident)?))?) => {
+        #[doc=$doc]
+        #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+        pub enum $name {
+            $v_false,
+            $v_true,
+        }
+
+        impl From<$name> for bool {
+            fn from(val: $name) -> bool {
+                val == $name::$v_true
+            }
+        }
+
+        impl From<bool> for $name {
+            fn from(val: bool) -> Self {
+                if val {
+                    $name::$v_true
+                } else {
+                    $name::$v_false
+                }
+            }
+        }
+
+        $(
+            impl Default for $name {
+                fn default() -> Self {
+                    $name::$v_false
+                }
+            }
+            // Needed because otherwise the macro would lack a syntax variable being matched to
+            $(
+                type $_syntax_false = __INVALID__;
+            )?
+        )?
+
+        $(
+            impl Default for $name {
+                fn default() -> Self {
+                    $name::$v_true
+                }
+            }
+            // Needed because otherwise the macro would lack a syntax variable being matched to
+            $(
+                type $_syntax_true = __INVALID__;
+            )?
+        )?
+    };
+}
+
+/// Macro for generating enums that map one-to-one to int values of type `$ty`.
+///
+/// To set the default variant, write `(D)` after it.
+macro_rules! int_enum {
+    ($name:ident <=> $ty:ty, $doc:tt, $($variant:ident <=> $num:tt $((D $($_syntax:ident)?))?),*) => {
+        #[doc=$doc]
+        #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+        pub enum $name {
+            $(
+                $variant,
+            )*
+        }
+
+        impl From<$name> for $ty {
+            fn from(val: $name) -> $ty {
+                match val {
+                    $(
+                        $name::$variant => $num,
+                    )*
+                }
+            }
+        }
+
+        impl core::convert::TryFrom<$ty> for $name {
+            type Error = &'static str;
+
+            fn try_from(val: $ty) -> Result<Self, &'static str> {
+                match val {
+                    $(
+                        $num => Ok($name::$variant),
+                    )*
+                    _ => Err("Conversion failed"),
+                }
+            }
+        }
+
+        $(
+            $(
+                impl Default for $name {
+                    fn default() -> Self {
+                        $name::$variant
+                    }
+                }
+                // Needed because otherwise the macro would lack a syntax variable being matched to
+                $(
+                    type $_syntax = __INVALID__;
+                )?
+            )?
+        )*
+    };
+}
+
+/// Macro for generating structs closely related to integers.
+///
+/// Attention: If you don't want to limit the length of the stored value,
+/// set `$len = 0`.
+macro_rules! int_struct {
+    ($name:ident, $int_type:ident, $len:tt, $doc:tt $(, $default:tt)?) => {
+        int_struct! { @INNER $name, $doc, $int_type, $len $(, $default)? }
+    };
+    (@INNER $name:ident, $doc:tt, $int_type:ident, 0 $(, $default:tt)?) => {
+        #[doc=$doc]
+        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        pub struct $name(pub $int_type);
+
+        impl $name {
+            pub fn new(val: $int_type) -> Self {
+                $name(val)
+            }
+
+            pub fn set_value(&mut self, val: $int_type) {
+                self.0 = val;
+            }
+
+            pub fn value(self) -> $int_type {
+                self.0
+            }
+        }
+
+        impl From<$int_type> for $name {
+            fn from(val: $int_type) -> Self {
+                $name::new(val)
+            }
+        }
+
+        impl From<$name> for $int_type {
+            fn from(val: $name) -> $int_type {
+                val.value()
+            }
+        }
+
+        $(
+            impl Default for $name {
+                fn default() -> $name {
+                    $name($default)
+                }
+            }
+        )?
+    };
+    (@INNER $name:ident, $doc:tt, $int_type:ident, $len:tt $(, $default:tt)?) => {
+        #[doc=$doc]
+        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        pub struct $name($int_type);
+
+        impl $name {
+            pub fn new(val: $int_type) -> Self {
+                if !$name::is_val_valid(val) {
+                    // Expression `(1 << $len) - 1` overflows if $len = len of $int_type
+                    panic!("The given value is incompatible with this type (max_value={}, got={})", (1 << $len) - 1, val);
+                }
+
+                $name(val)
+            }
+
+            pub fn value(self) -> $int_type {
+                self.0
+            }
+
+            pub fn set_value(&mut self, val: $int_type) {
+                if !$name::is_val_valid(val) {
+                    panic!("The given value is incompatible with this type (max_value={}, got={})", (1 << $len) - 1, val);
+                }
+
+                self.0 = val;
+            }
+
+            fn is_val_valid(val: $int_type) -> bool {
+                val >> ($len - 1) <= 0b1
+            }
+        }
+
+        impl From<$name> for $int_type {
+            fn from(val: $name) -> $int_type {
+                val.value()
+            }
+        }
+
+        impl core::convert::TryFrom<$int_type> for $name {
+            // FIXME
+            type Error = &'static str;
+
+            fn try_from(val: $int_type) -> Result<Self, &'static str> {
+                if $name::is_val_valid(val) {
+                    Ok($name::new(val))
+                } else {
+                    Err("Conversion failed.")
+                }
+            }
+        }
+
+        $(
+            impl Default for $name {
+                fn default() -> $name {
+                    $name($default)
+                }
+            }
+        )?
+    };
+}