🎨 Addressed Comments

demos/platforms/stm32f411re.cpp

@@ -17,6 +17,7 @@
 #include <libhal-arm-mcu/startup.hpp>
 #include <libhal-arm-mcu/stm32f411/clock.hpp>
 #include <libhal-arm-mcu/stm32f411/constants.hpp>
+#include <libhal-arm-mcu/stm32f411/dma.hpp>
 #include <libhal-arm-mcu/stm32f411/input_pin.hpp>
 #include <libhal-arm-mcu/stm32f411/output_pin.hpp>
 #include <libhal-arm-mcu/stm32f411/pin.hpp>
@@ -51,7 +52,6 @@ void initialize_platform(resource_list& p_resources)
   static hal::stm32f411::uart uart2(
     hal::port<2>, hal::buffer<128>, { .baud_rate = 115200 });
   p_resources.console = &uart2;
-
   p_resources.reset = []() { hal::cortex_m::reset(); };
   p_resources.status_led = &led;
   p_resources.clock = &steady_clock;

include/libhal-arm-mcu/stm32_generic/uart.hpp

@@ -47,7 +47,7 @@ class uart
    * @param p_frequency Bus frequency
    */
   void configure(serial::settings const& p_settings, hertz p_frequency);
-  uint32_t volatile* data();
+  uint32_t volatile* data_register();
   void flush(std::uint32_t p_dma_cursor_position);
   std::uint32_t buffer_size();
 

include/libhal-arm-mcu/stm32f411/dma.hpp

@@ -16,8 +16,30 @@
 
 #include <cstdint>
 
+#include <libhal/units.hpp>
+
+#include "constants.hpp"
+
 namespace hal::stm32f411 {
-/// Maximum length of a buffer that the stm32f1xxx series dma controller can
+struct dma_channel_stream_t
+{
+  uint8_t stream;
+  uint8_t channel;
+};
+/**
+ * @brief Sets up the DMA memory to memory transfer mode
+ *
+ * @param p_dma Select DMA
+ * @param p_stream_channel loops through the listed streams until an available
+ * stream is found. Will spinlock until spare channel is found
+ * @param p_source source address
+ * @param p_destination destination address
+ */
+void set_dma_memory_transfer(peripheral p_dma,
+                             std::span<dma_channel_stream_t> p_stream_channel,
+                             std::span<hal::byte> p_source,
+                             std::span<byte> p_destination);
+/// Maximum length of a buffer that the stm32f411 series dma controller can
 /// handle.
 constexpr std::uint32_t max_dma_length = 65'535;
 }  // namespace hal::stm32f411

include/libhal-arm-mcu/stm32f411/uart.hpp

@@ -16,12 +16,12 @@
 
 #include <cstdint>
 
+#include <libhal-arm-mcu/stm32_generic/uart.hpp>
 #include <libhal/initializers.hpp>
 #include <libhal/serial.hpp>
 
 #include "constants.hpp"
 #include "dma.hpp"
-#include "libhal-arm-mcu/stm32_generic/uart.hpp"
 
 namespace hal::stm32f411 {
 class uart final : public hal::serial

src/stm32_generic/uart.cpp

@@ -147,7 +147,7 @@ void uart::configure(serial::settings const& p_settings, hertz p_frequency)
   configure_baud_rate(p_frequency, p_settings);
   configure_format(p_settings);
 }
-
+// TODO(#86) Add DMA write support to stm32_generic/uart.cpp
 serial::write_t uart::uart_write(std::span<hal::byte const> p_data)
 {
   auto& uart_reg = *to_usart(m_uart);
@@ -185,7 +185,7 @@ serial::read_t uart::uart_read(std::span<hal::byte>& p_data,
     .capacity = m_receive_buffer.size(),
   };
 }
-uint32_t volatile* uart::data()
+uint32_t volatile* uart::data_register()
 {
   return &to_usart(m_uart)->data;
 }

src/stm32f411/dma.cpp

@@ -21,6 +21,7 @@
 #include <span>
 
 #include <libhal-arm-mcu/stm32f411/constants.hpp>
+#include <libhal-arm-mcu/stm32f411/dma.hpp>
 #include <libhal-arm-mcu/stm32f411/interrupt.hpp>
 #include <libhal-util/atomic_spin_lock.hpp>
 #include <libhal-util/bit.hpp>
@@ -29,6 +30,7 @@
 
 #include "dma.hpp"
 #include "power.hpp"
+
 namespace hal::stm32f411 {
 namespace {
 std::array<hal::callback<void()>, 16> dma_callbacks{};
@@ -138,29 +140,28 @@ dma_channel_stream_t setup_dma_transfer(
   initialize_dma(p_dma);
 
   auto selected_config = set_available_stream(p_dma, p_possible_streams);
-
+  auto& stream = dma_addr->stream[selected_config.stream];
   switch (p_configuration.transfer_type) {
     case dma_transfer_type::peripheral_to_memory:
-      dma_addr->stream[selected_config.stream].peripheral_address =
+      stream.peripheral_address =
         std::bit_cast<std::uintptr_t>(p_configuration.source);
-      dma_addr->stream[selected_config.stream].memory_0_address =
+      stream.memory_0_address =
         std::bit_cast<std::uintptr_t>(p_configuration.destination);
       break;
     case dma_transfer_type::memory_to_peripheral:
-      dma_addr->stream[selected_config.stream].peripheral_address =
+      stream.peripheral_address =
         std::bit_cast<std::uintptr_t>(p_configuration.destination);
-      dma_addr->stream[selected_config.stream].memory_0_address =
+      stream.memory_0_address =
         std::bit_cast<std::uintptr_t>(p_configuration.source);
       break;
     default:
-      dma_addr->stream[selected_config.stream].peripheral_address =
+      stream.peripheral_address =
         std::bit_cast<std::uintptr_t>(p_configuration.source);
-      dma_addr->stream[selected_config.stream].memory_0_address =
+      stream.memory_0_address =
         std::bit_cast<std::uintptr_t>(p_configuration.destination);
   }
 
-  dma_addr->stream[selected_config.stream].transfer_count =
-    p_configuration.transfer_length;
+  stream.transfer_count = p_configuration.transfer_length;
 
   bit_modify(dma_addr->stream[selected_config.stream].configure)
     .insert(dma_stream_config::peripheral_flow_controller,
@@ -222,10 +223,10 @@ dma_channel_stream_t setup_dma_transfer(
   return selected_config;
 };
 
-void set_mem_to_mem(peripheral p_dma,
-                    std::span<dma_channel_stream_t> p_stream_channel,
-                    std::span<hal::byte> p_source,
-                    std::span<byte> p_destination)
+void set_dma_memory_transfer(peripheral p_dma,
+                             std::span<dma_channel_stream_t> p_stream_channel,
+                             std::span<hal::byte> p_source,
+                             std::span<byte> p_destination)
 {
   dma_settings_t dma_setting = {
     .source = &p_source,

src/stm32f411/dma.hpp

@@ -21,16 +21,11 @@
 #include <span>
 
 #include <libhal-arm-mcu/stm32f411/constants.hpp>
+#include <libhal-arm-mcu/stm32f411/dma.hpp>
 #include <libhal-util/bit.hpp>
 #include <libhal/functional.hpp>
 
 namespace hal::stm32f411 {
-struct dma_channel_stream_t
-{
-  uint8_t stream;
-  uint8_t channel;
-};
-
 enum class dma_transfer_type : std::uint8_t
 {
   peripheral_to_memory = 0b00U,

src/stm32f411/uart.cpp

@@ -13,21 +13,22 @@
 // limitations under the License.
 
 #include <array>
+
+#include <libhal-arm-mcu/stm32_generic/uart.hpp>
+#include <libhal-arm-mcu/stm32f411/clock.hpp>
+#include <libhal-arm-mcu/stm32f411/constants.hpp>
 #include <libhal-arm-mcu/stm32f411/pin.hpp>
 #include <libhal-arm-mcu/stm32f411/uart.hpp>
 #include <libhal/units.hpp>
 
 #include "dma.hpp"
-#include "libhal-arm-mcu/stm32_generic/uart.hpp"
-#include "libhal-arm-mcu/stm32f411/clock.hpp"
-#include "libhal-arm-mcu/stm32f411/constants.hpp"
 #include "power.hpp"
 
 namespace hal::stm32f411 {
 namespace {
-inline void* usart1 = (void*)0x4001'1000;
-inline void* usart2 = (void*)0x4000'4400;
-inline void* usart6 = (void*)0x4001'1400;
+inline auto usart1 = reinterpret_cast<void*>(0x4001'1000);
+inline auto usart2 = reinterpret_cast<void*>(0x4000'4400);
+inline auto usart6 = reinterpret_cast<void*>(0x4001'1400);
 }  // namespace
 uart::uart(hal::runtime,
            std::uint8_t p_port,
@@ -108,7 +109,7 @@ uart::uart(std::uint8_t p_port,
 
   /// configure dma here
   dma_settings_t dma_setting = {
-    .source = m_stm32_uart.data(),
+    .source = m_stm32_uart.data_register(),
     .destination = p_buffer.data(),
 
     .transfer_length = p_buffer.size(),
@@ -125,7 +126,6 @@ uart::uart(std::uint8_t p_port,
     .peripheral_burst_size = dma_burst_size::single_transfer,
     .memory_burst_size = dma_burst_size::single_transfer
   };
-  // p *(hal::stm32f411::stream_config_t*)(0x40026088)
 
   m_dma_stream =
     setup_dma_transfer(m_dma, possible_streams, dma_setting, []() {}).stream;