Feat/MDMA

.vscode/settings.json

@@ -7,8 +7,93 @@
     "C_Cpp.clang_format_sortIncludes": true,
     "C_Cpp.intelliSenseCacheSize": 0,
     "files.associations": {
-      "mem.h": "c",
-      "tinydir.h": "c",
-      "dirent.h": "c"
+      "any": "cpp",
+      "array": "cpp",
+      "atomic": "cpp",
+      "barrier": "cpp",
+      "bit": "cpp",
+      "bitset": "cpp",
+      "cctype": "cpp",
+      "cfenv": "cpp",
+      "charconv": "cpp",
+      "chrono": "cpp",
+      "cinttypes": "cpp",
+      "clocale": "cpp",
+      "cmath": "cpp",
+      "codecvt": "cpp",
+      "compare": "cpp",
+      "complex": "cpp",
+      "concepts": "cpp",
+      "condition_variable": "cpp",
+      "coroutine": "cpp",
+      "csetjmp": "cpp",
+      "csignal": "cpp",
+      "cstdarg": "cpp",
+      "cstddef": "cpp",
+      "cstdint": "cpp",
+      "cstdio": "cpp",
+      "cstdlib": "cpp",
+      "cstring": "cpp",
+      "ctime": "cpp",
+      "cuchar": "cpp",
+      "cwchar": "cpp",
+      "cwctype": "cpp",
+      "deque": "cpp",
+      "forward_list": "cpp",
+      "list": "cpp",
+      "map": "cpp",
+      "set": "cpp",
+      "string": "cpp",
+      "unordered_map": "cpp",
+      "unordered_set": "cpp",
+      "vector": "cpp",
+      "exception": "cpp",
+      "expected": "cpp",
+      "algorithm": "cpp",
+      "functional": "cpp",
+      "iterator": "cpp",
+      "memory": "cpp",
+      "memory_resource": "cpp",
+      "numeric": "cpp",
+      "optional": "cpp",
+      "random": "cpp",
+      "ratio": "cpp",
+      "regex": "cpp",
+      "source_location": "cpp",
+      "string_view": "cpp",
+      "system_error": "cpp",
+      "tuple": "cpp",
+      "type_traits": "cpp",
+      "utility": "cpp",
+      "fstream": "cpp",
+      "future": "cpp",
+      "initializer_list": "cpp",
+      "iomanip": "cpp",
+      "iosfwd": "cpp",
+      "iostream": "cpp",
+      "istream": "cpp",
+      "latch": "cpp",
+      "limits": "cpp",
+      "mutex": "cpp",
+      "new": "cpp",
+      "numbers": "cpp",
+      "ostream": "cpp",
+      "ranges": "cpp",
+      "scoped_allocator": "cpp",
+      "semaphore": "cpp",
+      "shared_mutex": "cpp",
+      "span": "cpp",
+      "spanstream": "cpp",
+      "sstream": "cpp",
+      "stacktrace": "cpp",
+      "stdexcept": "cpp",
+      "stop_token": "cpp",
+      "streambuf": "cpp",
+      "syncstream": "cpp",
+      "thread": "cpp",
+      "typeindex": "cpp",
+      "typeinfo": "cpp",
+      "valarray": "cpp",
+      "variant": "cpp"
     }
 }

CMakeLists.txt

@@ -75,6 +75,9 @@ if(CMAKE_CROSSCOMPILING)
     ${HAL_DRIVER_SRC_DIR}/stm32h7xx_hal_gpio.c
     ${HAL_DRIVER_SRC_DIR}/stm32h7xx_hal_exti.c
 
+    # MDMA
+    ${HAL_DRIVER_SRC_DIR}/stm32h7xx_hal_mdma.c
+
     # ADC
     ${HAL_DRIVER_SRC_DIR}/stm32h7xx_hal_adc.c
     ${HAL_DRIVER_SRC_DIR}/stm32h7xx_hal_adc_ex.c

Inc/C++Utilities/CppUtils.hpp

@@ -2,6 +2,7 @@
 
 #include "CppImports.hpp"
 #include "RingBuffer.hpp"
+#include "Stack.hpp"
 
 
 namespace chrono = std::chrono;

Inc/C++Utilities/Stack.hpp

@@ -0,0 +1,56 @@
+/*
+ * Stack.hpp
+ *
+ *  Created on: 15 nov. 2025
+ *      Author: Boris
+ */
+
+#ifndef STACK_HPP
+#define STACK_HPP
+
+#include "CppImports.hpp"
+
+/**
+ * @brief A simple fixed-size stack.
+ * @tparam T The type of elements stored in the stack.
+ * @tparam S The maximum number of elements.
+ */
+template<typename T, size_t S>
+class Stack {
+public:
+    Stack() : top_idx(0) {}
+
+    bool push(const T& value) {
+        if (top_idx < S) {
+            data[top_idx++] = value;
+            return true;
+        }
+        return false;
+    }
+
+    bool pop() {
+        if (top_idx == 0) {
+            return false;
+        }
+        top_idx--;
+        return true;
+    }
+
+    // Returns the top element without removing it. Returns default T{} if stack is empty.
+    T top() const {
+        if (top_idx == 0) {
+            return T{};
+        }
+        return data[top_idx - 1];
+    }
+
+    size_t size() const { return top_idx; }
+    size_t capacity() const { return S; }
+    bool empty() const { return top_idx == 0; }
+
+private:
+    T data[S];
+    size_t top_idx;
+};
+
+#endif // STACK_HPP

Inc/HALAL/HALAL.hpp

@@ -44,6 +44,7 @@
 
 #include "HALAL/Models/BoardID/BoardID.hpp"
 #include "HALAL/Models/Concepts/Concepts.hpp"
+#include "HALAL/Models/MDMA/MDMA.hpp"
 
 #ifdef STLIB_ETH
 #include "HALAL/Models/Packets/Packet.hpp"

Inc/HALAL/Models/MDMA/MDMA.hpp

@@ -0,0 +1,180 @@
+#pragma once
+
+#include "C++Utilities/CppUtils.hpp"
+#include "stm32h7xx_hal.h"
+#include "ErrorHandler/ErrorHandler.hpp"
+#include "HALAL/Models/MPUManager/MPUManager.hpp"
+#include <array>
+#include <tuple>
+#include <vector>
+#include <unordered_map>
+#include <type_traits>
+#include <utility>
+
+#ifdef MDMA
+#undef MDMA
+#endif
+
+#ifndef TRANSFER_QUEUE_MAX_SIZE
+#define TRANSFER_QUEUE_MAX_SIZE 50
+#endif
+class MDMA{
+    public:
+    /**
+     * @brief A helper struct to create and manage MDMA linked list nodes.
+     */
+    struct LinkedListNode {
+    template<typename T>
+    LinkedListNode(T* source_ptr, void* dest_ptr) 
+    {
+        init_node(source_ptr, dest_ptr, sizeof(T));
+    }
+
+    template<typename T>
+    LinkedListNode(T* source_ptr, void* dest_ptr, size_t size) 
+    {
+        init_node(source_ptr, dest_ptr, size);
+    }
+
+    void set_next(MDMA_LinkNodeTypeDef* next_node) { node.CLAR = reinterpret_cast<uint32_t>(next_node); }
+    void set_destination(void* destination) 
+    { 
+        uint32_t destination_adress = reinterpret_cast<uint32_t>(destination);
+        node.CDAR = destination_adress;
+        node.CTBR &= ~MDMA_CTBR_DBUS;
+        if (destination_adress < 0x00010000) 
+        {
+            node.CTBR |= MDMA_CTBR_DBUS;
+        }
+        else if (destination_adress >= 0x20000000 && destination_adress < 0x20020000)
+        {
+            node.CTBR |= MDMA_CTBR_DBUS;
+        } 
+    }
+    void set_source(void* source) { 
+        uint32_t source_adress = reinterpret_cast<uint32_t>(source); 
+        node.CSAR = source_adress;
+
+        node.CTBR &= ~MDMA_CTBR_SBUS; 
+
+        if ((source_adress < 0x00010000) || (source_adress >= 0x20000000 && source_adress < 0x20020000)) {
+            node.CTBR |= MDMA_CTBR_SBUS;
+        }
+    }
+    auto get_node() -> MDMA_LinkNodeTypeDef* { return &node; }
+    auto get_size() -> uint32_t { return node.CBNDTR; }
+    auto get_destination() -> uint32_t { return node.CDAR; }
+    auto get_source() -> uint32_t { return node.CSAR; }
+    auto get_next() -> MDMA_LinkNodeTypeDef* { return reinterpret_cast<MDMA_LinkNodeTypeDef*>(node.CLAR); }
+
+private:
+    alignas(8) MDMA_LinkNodeTypeDef node;
+
+    void init_node(void* src, void* dst, size_t size) 
+    {
+        MDMA_LinkNodeConfTypeDef nodeConfig{};
+        nodeConfig.Init.DataAlignment = MDMA_DATAALIGN_RIGHT; 
+        nodeConfig.Init.SourceBurst = MDMA_SOURCE_BURST_SINGLE;
+        nodeConfig.Init.DestBurst = MDMA_DEST_BURST_SINGLE;
+        nodeConfig.Init.BufferTransferLength = 128;
+        nodeConfig.Init.TransferTriggerMode = MDMA_FULL_TRANSFER;
+        nodeConfig.Init.SourceBlockAddressOffset = 0;
+        nodeConfig.Init.DestBlockAddressOffset = 0;
+        nodeConfig.BlockCount = 1;
+        nodeConfig.Init.Priority = MDMA_PRIORITY_VERY_HIGH;
+        nodeConfig.Init.Endianness = MDMA_LITTLE_ENDIANNESS_PRESERVE;
+        nodeConfig.Init.Request = MDMA_REQUEST_SW;
+
+        this->node = {};
+        nodeConfig.SrcAddress = reinterpret_cast<uint32_t>(src);
+        nodeConfig.DstAddress = reinterpret_cast<uint32_t>(dst);
+        nodeConfig.BlockDataLength = static_cast<uint32_t>(size);
+        nodeConfig.Init.SourceDataSize = MDMA_SRC_DATASIZE_BYTE;
+        nodeConfig.Init.DestDataSize = MDMA_DEST_DATASIZE_BYTE;
+        nodeConfig.Init.SourceInc = MDMA_SRC_INC_BYTE;
+        nodeConfig.Init.DestinationInc = MDMA_DEST_INC_BYTE;
+
+        if (HAL_MDMA_LinkedList_CreateNode(&node, &nodeConfig) != HAL_OK) {
+            ErrorHandler("Error creating linked list in MDMA");
+        }
+    }
+};
+
+    private:
+    struct Instance{
+    public:
+        MDMA_HandleTypeDef handle;
+        uint8_t id;
+        bool* done;
+        MDMA_LinkNodeTypeDef transfer_node;
+
+        Instance()
+            : handle{}
+            , id(0U)
+            , done(nullptr)
+            , transfer_node{}
+        {}
+
+        Instance(MDMA_HandleTypeDef handle_,
+                 uint8_t id_,
+                 bool* done_,
+                 MDMA_LinkNodeTypeDef transfer_node_)
+            : handle(handle_)
+            , id(id_)
+            , done(done_)
+            , transfer_node(transfer_node_)
+        {}
+
+
+    };
+    static void prepare_transfer(Instance& instance, MDMA::LinkedListNode* first_node);
+    static void prepare_transfer(Instance& instance, MDMA_LinkNodeTypeDef* first_node);
+    static Instance& get_instance(uint8_t id);
+
+    inline static std::array<Instance,8> instances{};
+    static std::unordered_map<uint8_t, MDMA_Channel_TypeDef*> instance_to_channel;
+    static std::unordered_map<MDMA_Channel_TypeDef*, uint8_t> channel_to_instance;
+    static std::bitset<8> instance_free_map;
+    inline static Stack<std::pair<MDMA::LinkedListNode*,bool*>,50> transfer_queue{};
+
+    static void TransferCompleteCallback(MDMA_HandleTypeDef *hmdma);
+    static void TransferErrorCallback(MDMA_HandleTypeDef *hmdma);
+
+    /**
+	 * @brief A method to add MDMA channels in linked list mode.
+
+	 * This method will be called internally for each channel during the MDMA::start() process.
+	 *
+     * @param instance	The reference to the MDMA instance to be initialised	 
+	 */
+
+    static void inscribe(Instance& instance,uint8_t id);
+
+    public:
+
+    static void start();
+    static void irq_handler();
+    static void update();
+
+
+
+
+    /**
+     * @brief A method to start a transfer from source to destination using MDMA linked list
+     *  
+     * @param source_address The source address for the transfer.
+     * @param destination_address The destination address for the transfer.
+     * @param data_length The length of data to be transferred.
+     * @param check A reference boolean that will be set to true if the transfer was successfully done, false otherwise.
+     */
+    static void transfer_data(uint8_t* source_address, uint8_t* destination_address, const uint32_t data_length, bool* done=nullptr);
+
+    /**
+     * @brief A method to transfer using MDMA linked 
+     *  
+     * @param first_node The linked list node representing the first node in the linked list.
+     * @param check A reference boolean that will be set to true if the transfer was successfully done, false otherwise.
+     */
+    static void transfer_list(MDMA::LinkedListNode* first_node,bool* check=nullptr);
+
+};

Src/HALAL/HALAL.cpp

@@ -37,6 +37,10 @@ static void common_start(UART::Peripheral &printf_peripheral) {
   DMA::start();
 #endif
 
+#ifdef HAL_MDMA_MODULE_ENABLED
+    MDMA::start();
+#endif
+
 #ifdef HAL_FMAC_MODULE_ENABLED
   MultiplierAccelerator::start();
 #endif