fix!: Use volatile for all non-cached memory accesses

FoniksFox · FoniksFox · commit 0178974e2e12 · 2026-04-29T23:14:29.000+02:00
diff --git a/Inc/HALAL/Models/MDMA/MDMA.hpp b/Inc/HALAL/Models/MDMA/MDMA.hpp
@@ -32,11 +32,10 @@ class MDMA {
         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) {
+        void set_next(volatile MDMA_LinkNodeTypeDef* next_node) volatile {
             node.CLAR = reinterpret_cast<uint32_t>(next_node);
         }
-        void set_destination(void* destination) {
+        void set_destination(void* destination) volatile {
             uint32_t destination_address = reinterpret_cast<uint32_t>(destination);
             node.CDAR = destination_address;
 
@@ -49,7 +48,7 @@ class MDMA {
             }
             reconfigure_ctcr();
         }
-        void set_source(void* source) {
+        void set_source(void* source) volatile {
             uint32_t source_address = reinterpret_cast<uint32_t>(source);
             node.CSAR = source_address;
 
@@ -62,19 +61,19 @@ class MDMA {
             }
             reconfigure_ctcr();
         }
-        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);
+        auto get_node() volatile -> volatile MDMA_LinkNodeTypeDef* { return &node; }
+        auto get_size() const volatile -> uint32_t { return node.CBNDTR; }
+        auto get_destination() const volatile -> uint32_t { return node.CDAR; }
+        auto get_source() const volatile -> uint32_t { return node.CSAR; }
+        auto get_next() const volatile -> volatile MDMA_LinkNodeTypeDef* {
+            return reinterpret_cast<volatile MDMA_LinkNodeTypeDef*>(node.CLAR);
         }
 
     private:
         alignas(8) MDMA_LinkNodeTypeDef node;
         size_t transfer_size{0};
 
-        void reconfigure_ctcr() {
+        void reconfigure_ctcr() volatile {
             const uintptr_t src = node.CSAR;
             const uintptr_t dst = node.CDAR;
             const size_t size = transfer_size;
@@ -240,27 +239,27 @@ class MDMA {
         MDMA_HandleTypeDef handle;
         uint8_t id;
         volatile bool* done;
-        MDMA_LinkNodeTypeDef* transfer_node;
+        volatile MDMA_LinkNodeTypeDef* transfer_node;
 
         Instance() : handle{}, id(0U), done(nullptr), transfer_node(nullptr) {}
-
+        
         Instance(
             MDMA_HandleTypeDef handle_,
             uint8_t id_,
             volatile bool* done_,
-            MDMA_LinkNodeTypeDef* transfer_node_
+            volatile 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 void prepare_transfer(Instance& instance, volatile MDMA::LinkedListNode* first_node);
+    static void prepare_transfer(Instance& instance, volatile MDMA_LinkNodeTypeDef* first_node);
     static Instance& get_instance(uint8_t id);
     static MDMA_Channel_TypeDef* get_channel(uint8_t id);
     static uint8_t get_instance_id(MDMA_Channel_TypeDef* channel);
 
     inline static std::array<Instance, 8> instances{};
     static std::bitset<8> instance_free_map;
-    inline static Stack<std::pair<MDMA::LinkedListNode*, volatile bool*>, 50> transfer_queue{};
+    inline static Stack<std::pair<volatile MDMA::LinkedListNode*, volatile bool*>, 50> transfer_queue{};
 
     static void TransferCompleteCallback(MDMA_HandleTypeDef* hmdma);
     static void TransferErrorCallback(MDMA_HandleTypeDef* hmdma);
@@ -303,5 +302,5 @@ class MDMA {
      * @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, volatile bool* check = nullptr);
+    static void transfer_list(volatile MDMA::LinkedListNode* first_node, volatile bool* check = nullptr);
 };
diff --git a/Inc/HALAL/Models/MPU.hpp b/Inc/HALAL/Models/MPU.hpp
@@ -44,16 +44,30 @@
 // Defines for attributes
 // Note1: Variables declared with these attributes will likely not be initialized by the startup
 // Note2: These attributes can only be used for static/global variables
-#define D1_NC __attribute__((section(".mpu_ram_d1_nc.user")))
-#define D2_NC __attribute__((section(".mpu_ram_d2_nc.user")))
-#define D3_NC __attribute__((section(".mpu_ram_d3_nc.user")))
-#define D1_C __attribute__((section(".ram_d1.user")))
-#define D2_C __attribute__((section(".ram_d2.user")))
-#define D3_C __attribute__((section(".ram_d3.user")))
-
-// Define for RAM code
+#ifdef SIM_ON
+#define D1_NC
+#define D2_NC
+#define D3_NC
+#define D1_C
+#define D2_C
+#define D3_C
+#define RAM_CODE
+#else
+/*
+ * Use C++ attribute syntax when compiled as C++, otherwise fall back to GCC-style
+ * `__attribute__` so the header is safe to include from both C and C++ translation
+ * units (some build units may be plain C and would reject the [[...]] syntax).
+ */
 #define RAM_CODE __attribute__((section(".ram_code")))
 
+#define D1_NC __attribute__((section(".mpu_ram_d1_nc.user"), used)) volatile
+#define D2_NC __attribute__((section(".mpu_ram_d2_nc.user"), used)) volatile
+#define D3_NC __attribute__((section(".mpu_ram_d3_nc.user"), used)) volatile
+#define D1_C  __attribute__((section(".ram_d1.user"), used))
+#define D2_C  __attribute__((section(".ram_d2.user"), used))
+#define D3_C  __attribute__((section(".ram_d3.user"), used))
+#endif
+
 // Memory Bank Symbols from Linker
 extern "C" const char __itcm_base;
 extern "C" const char __itcm_size;
@@ -260,14 +274,21 @@ struct MPUDomain {
         void* ptr;
         std::size_t size;
 
-        template <mpu_buffer_request auto& Target, typename... Args>
-        auto& construct(Args&&... args) {
-            using T = typename std::remove_cvref_t<decltype(Target)>::buffer_type;
+        template <auto& Target, typename... Args> auto& construct(Args&&... args) {
+            using Request = std::remove_cvref_t<decltype(Target)>;
+            static_assert(mpu_buffer_request<Request>, "Target must be a valid MPUDomain buffer");
+            constexpr bool is_nc = Request::e.memory_type == MemoryType::NonCached;
+            static_assert(is_nc && std::is_volatile_v<typename Request::buffer_type>, "Non cached buffers must be volatile to work as intended");
+            using T = typename Request::buffer_type;
             return *new (ptr) T(std::forward<Args>(args)...);
         }
 
-        template <mpu_buffer_request auto& Target> auto* as() {
-            using T = typename std::remove_cvref_t<decltype(Target)>::buffer_type;
+        template <auto& Target> auto* as() {
+            using Request = std::remove_cvref_t<decltype(Target)>;
+            static_assert(mpu_buffer_request<Request>, "Target must be a valid MPUDomain buffer");
+            constexpr bool is_nc = Request::e.memory_type == MemoryType::NonCached;
+            static_assert(is_nc && std::is_volatile_v<typename Request::buffer_type>, "Non cached buffers must be volatile to work as intended"); 
+            using T = typename Request::buffer_type;
             return static_cast<T*>(ptr);
         }
     };
@@ -290,17 +311,17 @@ struct MPUDomain {
 
         // Sections defined in Linker Script (aligned to 32 bytes just in case)
         __attribute__((section(".mpu_ram_d1_nc.buffer"))) alignas(32
-        ) static inline uint8_t d1_nc_buffer[Sizes.d1_nc_total > 0 ? Sizes.d1_nc_total : 1];
+        ) static inline volatile uint8_t d1_nc_buffer[Sizes.d1_nc_total > 0 ? Sizes.d1_nc_total : 1];
         __attribute__((section(".ram_d1.buffer"))) alignas(32
         ) static inline uint8_t d1_c_buffer[Sizes.d1_c_total > 0 ? Sizes.d1_c_total : 1];
 
         __attribute__((section(".mpu_ram_d2_nc.buffer"))) alignas(32
-        ) static inline uint8_t d2_nc_buffer[Sizes.d2_nc_total > 0 ? Sizes.d2_nc_total : 1];
+        ) static inline volatile uint8_t d2_nc_buffer[Sizes.d2_nc_total > 0 ? Sizes.d2_nc_total : 1];
         __attribute__((section(".ram_d2.buffer"))) alignas(32
         ) static inline uint8_t d2_c_buffer[Sizes.d2_c_total > 0 ? Sizes.d2_c_total : 1];
 
         __attribute__((section(".mpu_ram_d3_nc.buffer"))) alignas(32
-        ) static inline uint8_t d3_nc_buffer[Sizes.d3_nc_total > 0 ? Sizes.d3_nc_total : 1];
+        ) static inline volatile uint8_t d3_nc_buffer[Sizes.d3_nc_total > 0 ? Sizes.d3_nc_total : 1];
         __attribute__((section(".ram_d3.buffer"))) alignas(32
         ) static inline uint8_t d3_c_buffer[Sizes.d3_c_total > 0 ? Sizes.d3_c_total : 1];
 
@@ -326,7 +347,7 @@ struct MPUDomain {
             );
 
             // Assign pointers
-            uint8_t* bases_nc[3] = {&d1_nc_buffer[0], &d2_nc_buffer[0], &d3_nc_buffer[0]};
+            volatile uint8_t* bases_nc[3] = {&d1_nc_buffer[0], &d2_nc_buffer[0], &d3_nc_buffer[0]};
             uint8_t* bases_c[3] = {&d1_c_buffer[0], &d2_c_buffer[0], &d3_c_buffer[0]};
 
             for (std::size_t i = 0; i < N; i++) {
@@ -338,7 +359,7 @@ struct MPUDomain {
                     size_t d_idx = static_cast<size_t>(cfg.domain) - 1;
 
                     if (cfg.type == MemoryType::NonCached) {
-                        inst.ptr = bases_nc[d_idx] + cfg.offset;
+                        inst.ptr = const_cast<uint8_t*>(bases_nc[d_idx] + cfg.offset);
                     } else {
                         inst.ptr = bases_c[d_idx] + cfg.offset;
                     }
diff --git a/Inc/HALAL/Models/SPI/SPI2.hpp b/Inc/HALAL/Models/SPI/SPI2.hpp
@@ -1240,8 +1240,8 @@ struct SPIDomain {
             }
             auto error_code = HAL_SPI_TransmitReceive_DMA(
                 &spi_instance.hspi,
-                reinterpret_cast<const uint8_t*>(&tx_data),
-                reinterpret_cast<uint8_t*>(&rx_data),
+                const_cast<uint8_t*>(reinterpret_cast<const volatile uint8_t*>(&tx_data)),
+                const_cast<uint8_t*>(reinterpret_cast<volatile uint8_t*>(&rx_data)),
                 size / frame_size
             );
             return check_error_code(error_code);
diff --git a/Inc/HALAL/Services/ADC/ADC.hpp b/Inc/HALAL/Services/ADC/ADC.hpp
@@ -828,7 +828,7 @@ struct ADCDomain {
             }
             return 0;
         }
-        static uint16_t* get_dma_buffer(Peripheral peripheral) {
+        static volatile uint16_t* get_dma_buffer(Peripheral peripheral) {
             const auto buffer_size = buffer_size_for(peripheral);
             const auto buffer_offset = buffer_offset_for(peripheral);
             if (buffer_size == 0U) {
@@ -840,12 +840,12 @@ struct ADCDomain {
                 return nullptr;
             }
 
-            uint16_t* buffer = &dma_buffer_pool[buffer_offset];
+            volatile uint16_t* buffer = &dma_buffer_pool[buffer_offset];
             std::fill_n(buffer, buffer_size, uint16_t{0});
             return buffer;
         }
 
-        static uint16_t* get_dma_slot(Peripheral peripheral, uint8_t index) {
+        static volatile uint16_t* get_dma_slot(Peripheral peripheral, uint8_t index) {
             if (index >= buffer_size_for(peripheral)) {
                 return nullptr;
             }
@@ -945,7 +945,7 @@ struct ADCDomain {
                     ErrorHandler("ADC DMA instance unavailable");
                     continue;
                 }
-                uint16_t* buffer = get_dma_buffer(peripheral);
+                volatile uint16_t* buffer = get_dma_buffer(peripheral);
                 if (buffer == nullptr) {
                     continue;
                 }
@@ -989,8 +989,13 @@ struct ADCDomain {
                     continue;
                 }
 
-                if (HAL_ADC_Start_DMA(hadc, reinterpret_cast<uint32_t*>(buffer), channel_count) !=
-                    HAL_OK) {
+                if (HAL_ADC_Start_DMA(
+                        hadc,
+                        reinterpret_cast<uint32_t*>(
+                            const_cast<std::remove_volatile_t<std::remove_pointer_t<decltype(buffer)>>*>(buffer)
+                        ),
+                        channel_count
+                    ) != HAL_OK) {
                     ErrorHandler("ADC DMA start failed");
                     continue;
                 }
diff --git a/Inc/HALAL/Services/DFSDM/DFSDM.hpp b/Inc/HALAL/Services/DFSDM/DFSDM.hpp
@@ -1017,7 +1017,7 @@ struct DFSDM_CHANNEL_DOMAIN {
             ErrorHandler("Filter cannot be bigger than 3");
             return 0;
         }
-        static int32_t* get_buffer_filter(uint8_t filter) {
+        static volatile int32_t* get_buffer_filter(uint8_t filter) {
             switch (filter) {
             case 0:
                 return Buffer_Filter0;
@@ -1032,7 +1032,7 @@ struct DFSDM_CHANNEL_DOMAIN {
             return 0;
         }
 
-        static int32_t* get_buffer_pointer(const Config cfg) {
+        static volatile int32_t* get_buffer_pointer(const Config cfg) {
             return get_buffer_filter(cfg.filter) + cfg.buffer_pos_ini;
         }
 
diff --git a/Src/HALAL/Models/MDMA/MDMA.cpp b/Src/HALAL/Models/MDMA/MDMA.cpp
@@ -18,7 +18,7 @@ uint8_t MDMA::get_instance_id(MDMA_Channel_TypeDef* channel) {
     return static_cast<uint8_t>((address - (MDMA_BASE + 0x40UL)) / 0x40UL);
 }
 
-void MDMA::prepare_transfer(Instance& instance, MDMA_LinkNodeTypeDef* first_node) {
+void MDMA::prepare_transfer(Instance& instance, volatile MDMA_LinkNodeTypeDef* first_node) {
     if (instance.handle.State == HAL_MDMA_STATE_BUSY) {
         ErrorHandler("MDMA transfer already in progress");
         return;
@@ -27,7 +27,7 @@ void MDMA::prepare_transfer(Instance& instance, MDMA_LinkNodeTypeDef* first_node
 
     instance.handle.State = HAL_MDMA_STATE_BUSY;
     instance.handle.ErrorCode = HAL_MDMA_ERROR_NONE;
-    instance.handle.FirstLinkedListNodeAddress = first_node;
+    instance.handle.FirstLinkedListNodeAddress = const_cast<MDMA_LinkNodeTypeDef*>(first_node);
 
     MDMA_Channel_TypeDef* channel = instance.handle.Instance;
 
@@ -56,7 +56,7 @@ void MDMA::prepare_transfer(Instance& instance, MDMA_LinkNodeTypeDef* first_node
     }
 }
 
-void MDMA::prepare_transfer(Instance& instance, LinkedListNode* first_node) {
+void MDMA::prepare_transfer(Instance& instance, volatile LinkedListNode* first_node) {
     MDMA::prepare_transfer(instance, first_node->get_node());
 }
 
@@ -91,7 +91,7 @@ void MDMA::inscribe(Instance& instance, uint8_t id) {
     mdma_handle.Init.DestBlockAddressOffset = 0;
 
     MDMA_LinkNodeConfTypeDef nodeConfig{};
-    MDMA_LinkNodeTypeDef* transfer_node = &internal_nodes[id];
+    auto transfer_node = &internal_nodes[id];
 
     nodeConfig.Init.DataAlignment = MDMA_DATAALIGN_PACKENABLE;
     nodeConfig.Init.SourceBurst = MDMA_SOURCE_BURST_SINGLE;
@@ -112,7 +112,7 @@ void MDMA::inscribe(Instance& instance, uint8_t id) {
     nodeConfig.SrcAddress = reinterpret_cast<uint32_t>(nullptr);
     nodeConfig.DstAddress = reinterpret_cast<uint32_t>(nullptr);
 
-    const HAL_StatusTypeDef status = HAL_MDMA_LinkedList_CreateNode(transfer_node, &nodeConfig);
+    const HAL_StatusTypeDef status = HAL_MDMA_LinkedList_CreateNode(const_cast<MDMA_LinkNodeTypeDef*>(transfer_node), &nodeConfig);
     if (status != HAL_OK) {
         ErrorHandler("Error creating linked list in MDMA");
     }
@@ -182,7 +182,7 @@ void MDMA::irq_handler() {
     }
 }
 
-void MDMA::transfer_list(MDMA::LinkedListNode* first_node, volatile bool* done) {
+void MDMA::transfer_list(volatile MDMA::LinkedListNode* first_node, volatile bool* done) {
     if (transfer_queue.size() >= TRANSFER_QUEUE_MAX_SIZE) {
         ErrorHandler("MDMA transfer queue full");
         return;

Original file line number	Diff line number	Diff line change
`@@ -828,7 +828,7 @@ struct ADCDomain {`
`828`	`828`	`}`
`829`	`829`	`return 0;`
`830`	`830`	`}`
`831`		`- static uint16_t* get_dma_buffer(Peripheral peripheral) {`
	`831`	`+ static volatile uint16_t* get_dma_buffer(Peripheral peripheral) {`
`832`	`832`	`const auto buffer_size = buffer_size_for(peripheral);`
`833`	`833`	`const auto buffer_offset = buffer_offset_for(peripheral);`
`834`	`834`	`if (buffer_size == 0U) {`
`@@ -840,12 +840,12 @@ struct ADCDomain {`
`840`	`840`	`return nullptr;`
`841`	`841`	`}`
`842`	`842`
`843`		`- uint16_t* buffer = &dma_buffer_pool[buffer_offset];`
	`843`	`+ volatile uint16_t* buffer = &dma_buffer_pool[buffer_offset];`
`844`	`844`	`std::fill_n(buffer, buffer_size, uint16_t{0});`
`845`	`845`	`return buffer;`
`846`	`846`	`}`
`847`	`847`
`848`		`- static uint16_t* get_dma_slot(Peripheral peripheral, uint8_t index) {`
	`848`	`+ static volatile uint16_t* get_dma_slot(Peripheral peripheral, uint8_t index) {`
`849`	`849`	`if (index >= buffer_size_for(peripheral)) {`
`850`	`850`	`return nullptr;`
`851`	`851`	`}`
`@@ -945,7 +945,7 @@ struct ADCDomain {`
`945`	`945`	`ErrorHandler("ADC DMA instance unavailable");`
`946`	`946`	`continue;`
`947`	`947`	`}`
`948`		`- uint16_t* buffer = get_dma_buffer(peripheral);`
	`948`	`+ volatile uint16_t* buffer = get_dma_buffer(peripheral);`
`949`	`949`	`if (buffer == nullptr) {`
`950`	`950`	`continue;`
`951`	`951`	`}`
`@@ -989,8 +989,13 @@ struct ADCDomain {`
`989`	`989`	`continue;`
`990`	`990`	`}`
`991`	`991`
`992`		`- if (HAL_ADC_Start_DMA(hadc, reinterpret_cast<uint32_t*>(buffer), channel_count) !=`
`993`		`- HAL_OK) {`
	`992`	`+ if (HAL_ADC_Start_DMA(`
	`993`	`+ hadc,`
	`994`	`+ reinterpret_cast<uint32_t*>(`
	`995`	`+ const_cast<std::remove_volatile_t<std::remove_pointer_t<decltype(buffer)>>*>(buffer)`
	`996`	`+ ),`
	`997`	`+ channel_count`
	`998`	`+ ) != HAL_OK) {`
`994`	`999`	`ErrorHandler("ADC DMA start failed");`
`995`	`1000`	`continue;`
`996`	`1001`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1017,7 +1017,7 @@ struct DFSDM_CHANNEL_DOMAIN {`
`1017`	`1017`	`ErrorHandler("Filter cannot be bigger than 3");`
`1018`	`1018`	`return 0;`
`1019`	`1019`	`}`
`1020`		`- static int32_t* get_buffer_filter(uint8_t filter) {`
	`1020`	`+ static volatile int32_t* get_buffer_filter(uint8_t filter) {`
`1021`	`1021`	`switch (filter) {`
`1022`	`1022`	`case 0:`
`1023`	`1023`	`return Buffer_Filter0;`
`@@ -1032,7 +1032,7 @@ struct DFSDM_CHANNEL_DOMAIN {`
`1032`	`1032`	`return 0;`
`1033`	`1033`	`}`
`1034`	`1034`
`1035`		`- static int32_t* get_buffer_pointer(const Config cfg) {`
	`1035`	`+ static volatile int32_t* get_buffer_pointer(const Config cfg) {`
`1036`	`1036`	`return get_buffer_filter(cfg.filter) + cfg.buffer_pos_ini;`
`1037`	`1037`	`}`
`1038`	`1038`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ uint8_t MDMA::get_instance_id(MDMA_Channel_TypeDef* channel) {`
`18`	`18`	`return static_cast<uint8_t>((address - (MDMA_BASE + 0x40UL)) / 0x40UL);`
`19`	`19`	`}`
`20`	`20`
`21`		`-void MDMA::prepare_transfer(Instance& instance, MDMA_LinkNodeTypeDef* first_node) {`
	`21`	`+void MDMA::prepare_transfer(Instance& instance, volatile MDMA_LinkNodeTypeDef* first_node) {`
`22`	`22`	`if (instance.handle.State == HAL_MDMA_STATE_BUSY) {`
`23`	`23`	`ErrorHandler("MDMA transfer already in progress");`
`24`	`24`	`return;`
`@@ -27,7 +27,7 @@ void MDMA::prepare_transfer(Instance& instance, MDMA_LinkNodeTypeDef* first_node`
`27`	`27`
`28`	`28`	`instance.handle.State = HAL_MDMA_STATE_BUSY;`
`29`	`29`	`instance.handle.ErrorCode = HAL_MDMA_ERROR_NONE;`
`30`		`- instance.handle.FirstLinkedListNodeAddress = first_node;`
	`30`	`+ instance.handle.FirstLinkedListNodeAddress = const_cast<MDMA_LinkNodeTypeDef*>(first_node);`
`31`	`31`
`32`	`32`	`MDMA_Channel_TypeDef* channel = instance.handle.Instance;`
`33`	`33`
`@@ -56,7 +56,7 @@ void MDMA::prepare_transfer(Instance& instance, MDMA_LinkNodeTypeDef* first_node`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`-void MDMA::prepare_transfer(Instance& instance, LinkedListNode* first_node) {`
	`59`	`+void MDMA::prepare_transfer(Instance& instance, volatile LinkedListNode* first_node) {`
`60`	`60`	`MDMA::prepare_transfer(instance, first_node->get_node());`
`61`	`61`	`}`
`62`	`62`
`@@ -91,7 +91,7 @@ void MDMA::inscribe(Instance& instance, uint8_t id) {`
`91`	`91`	`mdma_handle.Init.DestBlockAddressOffset = 0;`
`92`	`92`
`93`	`93`	`MDMA_LinkNodeConfTypeDef nodeConfig{};`
`94`		`- MDMA_LinkNodeTypeDef* transfer_node = &internal_nodes[id];`
	`94`	`+ auto transfer_node = &internal_nodes[id];`
`95`	`95`
`96`	`96`	`nodeConfig.Init.DataAlignment = MDMA_DATAALIGN_PACKENABLE;`
`97`	`97`	`nodeConfig.Init.SourceBurst = MDMA_SOURCE_BURST_SINGLE;`
`@@ -112,7 +112,7 @@ void MDMA::inscribe(Instance& instance, uint8_t id) {`
`112`	`112`	`nodeConfig.SrcAddress = reinterpret_cast<uint32_t>(nullptr);`
`113`	`113`	`nodeConfig.DstAddress = reinterpret_cast<uint32_t>(nullptr);`
`114`	`114`
`115`		`- const HAL_StatusTypeDef status = HAL_MDMA_LinkedList_CreateNode(transfer_node, &nodeConfig);`
	`115`	`+ const HAL_StatusTypeDef status = HAL_MDMA_LinkedList_CreateNode(const_cast<MDMA_LinkNodeTypeDef*>(transfer_node), &nodeConfig);`
`116`	`116`	`if (status != HAL_OK) {`
`117`	`117`	`ErrorHandler("Error creating linked list in MDMA");`
`118`	`118`	`}`
`@@ -182,7 +182,7 @@ void MDMA::irq_handler() {`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`
`185`		`-void MDMA::transfer_list(MDMA::LinkedListNode* first_node, volatile bool* done) {`
	`185`	`+void MDMA::transfer_list(volatile MDMA::LinkedListNode* first_node, volatile bool* done) {`
`186`	`186`	`if (transfer_queue.size() >= TRANSFER_QUEUE_MAX_SIZE) {`
`187`	`187`	`ErrorHandler("MDMA transfer queue full");`
`188`	`188`	`return;`