git subrepo clone ssh://git@codeberg.org/abody/f4ll.git components/f4ll

subrepo:
  subdir:   "components/f4ll"
  merged:   "a4df325"
upstream:
  origin:   "ssh://git@codeberg.org/abody/f4ll.git"
  branch:   "master"
  commit:   "a4df325"
git-subrepo:
  version:  "0.4.9"
  origin:   "???"
  commit:   "???"

components/f4ll/inc/f4ll/console_handler.h

@@ -0,0 +1,44 @@
+/*
+ * ll_consolehandler.h
+ *
+ *  Created on: Nov 7, 2019
+ *      Author: abody
+ */
+
+#pragma once
+
+#include <f4ll/packet_usart.h>
+#include <f4ll/ringbuffer.h>
+#include <f4ll/singleton.h>
+
+namespace f4ll {
+
+class console_handler : public usart_core, public singleton<console_handler>
+{
+    friend class singleton<console_handler>;
+
+public:
+    void print(char const *s);
+    void flush();
+    size_t append(char const *s);
+
+private:
+    console_handler(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx);
+
+    // LL_UsartCore pure virtual function implementations
+    virtual void receiver_idle(void) override;
+    virtual void transmission_complete(void) override;
+    virtual void framing_error(void) override;
+    virtual void overrun(void) override;
+    virtual void rx_dma_transfer_complete(void) override;
+    virtual void rx_dma_half_transfer(void) override;
+    virtual void rx_dma_error(dma_helper::dma_error_type reason) override;
+    virtual void tx_dma_transfer_complete(void) override;
+    virtual void tx_dma_half_transfer(void) override;
+    virtual void tx_dma_error(dma_helper::dma_error_type reason) override;
+
+    ringbuffer<128> m_tx_buffer;
+    iringbuffer::size_type m_in_flight_size = 0;
+};
+
+} /* namespace f4ll */

components/f4ll/inc/f4ll/crc_handler.h

@@ -0,0 +1,90 @@
+/*
+ * ll_crc_handler.h
+ *
+ *  Created on: Oct 26, 2019
+ *      Author: compi
+ */
+#pragma once
+
+#include <f4ll/dma_helper.h>
+#include <f4ll/singleton.h>
+#include <inttypes.h>
+#include <platform/dma_ll.h>
+
+namespace f4ll {
+
+class crc_handler : public singleton<crc_handler>
+{
+    friend class singleton<crc_handler>;
+
+public:
+    struct icallback
+    {
+        virtual void crc_succeeded(uintptr_t callback_param, uint32_t crc, uint8_t task) = 0;
+        virtual void crc_failed(uintptr_t callback_param, uint32_t crc, uint8_t task) = 0;
+    };
+
+    class slot_base
+    {
+        friend class crc_handler;
+
+    public:
+        struct crc_task
+        {
+            void const *m_address; // changed to nullptr when execution starts
+            uint16_t m_word_count;
+            icallback *m_callback;
+            uintptr_t m_callback_param;
+        };
+
+    private:
+        slot_base volatile *m_next = nullptr;
+        uint8_t m_task_count;
+
+        virtual crc_task volatile &operator[](int index) volatile = 0;
+
+    protected:
+        slot_base(unsigned int task_count)
+            : m_task_count(task_count)
+        {
+        }
+        slot_base() = delete;
+        slot_base(slot_base const &other) = delete;
+    };
+
+    template <uint8_t n> class slot : public slot_base
+    {
+    public:
+        slot()
+            : slot_base(n)
+        {
+        }
+        virtual crc_task volatile &operator[](int index) volatile { return m_tasks[index]; }
+
+    private:
+        slot::crc_task m_tasks[n];
+    };
+
+    void attach_slot(slot_base &slot);
+    bool enqueue(slot_base &slot, uint8_t task, void const *address, uint16_t len, icallback *cb, uintptr_t cb_param);
+    uint32_t compute(slot_base &slot, uint8_t task, void const *address, uint16_t len);
+
+    bool is_active(slot_base &slot, uint8_t task) const;
+    bool is_queued(slot_base &slot, uint8_t task) const;
+    bool is_running(slot_base &slot, uint8_t task) const;
+
+    void dma_transfer_completed(void);
+
+private:
+    crc_handler(DMA_TypeDef *dma, uint32_t stream);
+
+    void start_next_task(void);
+    void wait_results(slot_base &slot, uint8_t task) const;
+
+    dma_helper m_dma;
+    slot_base volatile *m_first_slot = nullptr;
+    slot_base volatile *m_active_slot = nullptr;
+    int volatile m_active_task;
+};
+
+} //	namespace f4ll

components/f4ll/inc/f4ll/dma_helper.h

@@ -0,0 +1,60 @@
+/*
+ * ll_dmahelper.h
+ *
+ *  Created on: Oct 25, 2019
+ *      Author: abody
+ */
+
+#ifndef LL_DMAHELPER_H_
+#define LL_DMAHELPER_H_
+
+#include <inttypes.h>
+#include <platform/dma_ll.h>
+
+namespace f4ll {
+
+class dma_helper
+{
+public:
+    dma_helper(DMA_TypeDef *dma, uint32_t stream);
+    dma_helper(dma_helper const &base) = default;
+
+    inline DMA_TypeDef *get_dma() const { return m_dma; }
+    inline uint32_t get_stream() const { return m_stream; }
+    inline volatile uint32_t *get_is_reg() const { return m_is_reg; }
+    inline volatile uint32_t *get_ifc_reg() const { return m_ifc_reg; }
+    inline uint32_t get_fe_mask() const { return m_fe_masks[m_stream]; }
+    inline uint32_t get_dme_mask() const { return m_dme_masks[m_stream]; }
+    inline uint32_t get_te_mask() const { return m_te_masks[m_stream]; }
+    inline uint32_t get_ht_mask() const { return m_ht_masks[m_stream]; }
+    inline uint32_t get_tc_mask() const { return m_tc_masks[m_stream]; }
+
+    inline bool is_enabled_it_ht() const { return LL_DMA_IsEnabledIT_HT(m_dma, m_stream) != 0; }
+    inline bool is_enabled_it_te() const { return LL_DMA_IsEnabledIT_TE(m_dma, m_stream) != 0; }
+    inline bool is_enabled_it_tc() const { return LL_DMA_IsEnabledIT_TC(m_dma, m_stream) != 0; }
+    inline bool is_enabled_it_dme() const { return LL_DMA_IsEnabledIT_DME(m_dma, m_stream) != 0; }
+    inline bool is_enabled_it_fe() const { return LL_DMA_IsEnabledIT_FE(m_dma, m_stream) != 0; }
+
+    enum class dma_error_type { transfer, direct_mode, fifo };
+
+private:
+    DMA_TypeDef *m_dma;
+    uint32_t m_stream;
+    volatile uint32_t *m_is_reg;
+    volatile uint32_t *m_ifc_reg;
+
+    static constexpr uint32_t const m_fe_masks[8] = {DMA_LISR_FEIF0, DMA_LISR_FEIF1, DMA_LISR_FEIF2, DMA_LISR_FEIF3,
+                                                     DMA_HISR_FEIF4, DMA_HISR_FEIF5, DMA_HISR_FEIF6, DMA_HISR_FEIF7};
+    static constexpr uint32_t const m_dme_masks[8] = {DMA_LISR_DMEIF0, DMA_LISR_DMEIF1, DMA_LISR_DMEIF2, DMA_LISR_DMEIF3,
+                                                      DMA_HISR_DMEIF4, DMA_HISR_DMEIF5, DMA_HISR_DMEIF6, DMA_HISR_DMEIF7};
+    static constexpr uint32_t const m_te_masks[8] = {DMA_LISR_TEIF0, DMA_LISR_TEIF1, DMA_LISR_TEIF2, DMA_LISR_TEIF3,
+                                                     DMA_HISR_TEIF4, DMA_HISR_TEIF5, DMA_HISR_TEIF6, DMA_HISR_TEIF7};
+    static constexpr uint32_t const m_ht_masks[8] = {DMA_LISR_HTIF0, DMA_LISR_HTIF1, DMA_LISR_HTIF2, DMA_LISR_HTIF3,
+                                                     DMA_HISR_HTIF4, DMA_HISR_HTIF5, DMA_HISR_HTIF6, DMA_HISR_HTIF7};
+    static constexpr uint32_t const m_tc_masks[8] = {DMA_LISR_TCIF0, DMA_LISR_TCIF1, DMA_LISR_TCIF2, DMA_LISR_TCIF3,
+                                                     DMA_HISR_TCIF4, DMA_HISR_TCIF5, DMA_HISR_TCIF6, DMA_HISR_TCIF7};
+};
+
+} /* namespace f4ll */
+
+#endif /* LL_DMAHELPER_H_ */

components/f4ll/inc/f4ll/fault.h

@@ -0,0 +1,47 @@
+#ifndef __FAULT_H
+#define __FAULT_H
+
+#define FAULT_REASON_HARD_FAULT       1
+#define FAULT_REASON_MEMMANAGE_FAULT  2
+#define FAULT_REASON_BUS_FAULT        3
+#define FAULT_REASON_USAGE_FAULT      4
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+    uint32_t R0;
+    uint32_t R1;
+    uint32_t R2;
+    uint32_t R3;
+    uint32_t R4;
+    uint32_t R5;
+    uint32_t R6;
+    uint32_t R7;
+    uint32_t R8;
+    uint32_t R9;
+    uint32_t R10;
+    uint32_t R11;
+    uint32_t R12;
+    uint32_t SP;
+    uint32_t LR;
+    uint32_t PC;
+    uint32_t xPSR;
+    uint32_t PSP;
+    uint32_t MSP;
+    uint32_t EXC_RETURN;
+    uint32_t CONTROL;
+} fault_context_t;
+
+extern fault_context_t g_fault_context;
+
+void app_fault_callback(uint32_t reason);
+__attribute__((noreturn)) void fault_handler(uint32_t type, fault_context_t *context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* __FAULT_H */

components/f4ll/inc/f4ll/irq_lock.h

@@ -0,0 +1,26 @@
+#ifndef _IRQLOCK_H_INCLUDED
+#define _IRQLOCK_H_INCLUDED
+
+#include <inttypes.h>
+#include <stm32f4xx.h>
+
+namespace f4ll {
+
+class irq_lock
+{
+public:
+    inline irq_lock()
+        : m_primask(__get_PRIMASK())
+    {
+        __disable_irq();
+    }
+    inline void release() { __set_PRIMASK(m_primask); }
+
+    inline ~irq_lock() { __set_PRIMASK(m_primask); }
+
+private:
+	uint32_t m_primask;
+};
+}
+
+#endif	//	_IRQLOCK_H_INCLUDED

components/f4ll/inc/f4ll/memcpy_dma.h

@@ -0,0 +1,27 @@
+/*
+ * llmemcpydma.h
+ *
+ *  Created on: Nov 4, 2019
+ *      Author: abody
+ */
+#pragma once
+
+#include <f4ll/dma_helper.h>
+#include <f4ll/singleton.h>
+
+namespace f4ll {
+
+class memcpy_dma : public singleton<memcpy_dma>, private dma_helper
+{
+    friend class singleton<memcpy_dma>;
+
+public:
+    void *copy(void *dst, void const *src, uint16_t length);
+    void dma_transfer_completed();
+
+private:
+    memcpy_dma(DMA_TypeDef *dma, uint32_t stream);
+    bool volatile m_busy = false;
+};
+
+} /* namespace f4ll */

components/f4ll/inc/f4ll/packet_usart.h

@@ -0,0 +1,122 @@
+/*
+ * ll_HsUsart.h
+ *
+ *  Created on: Oct 29, 2019
+ *      Author: abody
+ */
+
+#ifndef LL_HSUSART_H_
+#define LL_HSUSART_H_
+#include <f4ll/crc_handler.h>
+#include <f4ll/usart_core.h>
+#include <platform/usart_ll.h>
+
+namespace f4ll {
+
+struct DMAINFO;
+
+class packet_usart : public crc_handler::icallback, public usart_core
+{
+    //	friend class UsartCore;
+public:
+    packet_usart(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx);
+
+    struct packet_header
+    { // !!! size should be multiple of 4 !!!
+        uint8_t start_byte;
+        uint8_t serial;
+        uint8_t payload_length;
+        uint8_t hash;
+    };
+
+    struct packet
+    {
+        packet_header header;
+        uint8_t payload[256 + sizeof(uint32_t)]; // extra room for crc32
+    } __attribute__((aligned));
+
+    struct stats
+    {
+        uint32_t overrun = 0;
+        uint32_t hdr_error = 0;
+        uint32_t payload_errror = 0;
+        uint32_t pep1 = 0;
+        uint32_t pep2 = 0;
+        uint32_t rx_dma_error = 0;
+        uint32_t tx_dma_error = 0;
+        uint32_t rcvd = 0;
+        uint32_t premature_hdr = 0;
+        uint32_t premature_payload = 0;
+        uint32_t sent = 0;
+        uint32_t skiped = 0;
+    };
+
+    struct ihs_usart_callback
+    {
+        virtual bool packet_received(packet_usart *caller, uintptr_t user_param, packet const &packet) = 0;
+    };
+
+    // crc_handler::ICallback interface functions
+    virtual void crc_succeeded(uintptr_t callback_param, uint32_t crc, uint8_t task) override;
+    virtual void crc_failed(uintptr_t callback_param, uint32_t crc, uint8_t task) override;
+
+    void post_packet(uint8_t const *payload, uint8_t length, bool wait_for_crc_queue = true);
+    void setup_receive(void);
+
+    void rx_processed(bool second);
+
+    // Getters
+    uint8_t *get_tx_packet_buffer(void) { return m_tx_buffer.pkt.payload; }
+    uint8_t const *get_rx_packet_buffer(bool second) { return m_rx_buffers[second].pkt.payload; }
+    USART_TypeDef *get_usart(void) const { return m_usart; }
+    stats const &get_stats(void) const { return m_stats; }
+    inline bool is_tx_busy(void) const { return m_tx_buffer.busy; }
+    inline bool is_tx_failed(void) const { return m_tx_buffer.error; }
+    inline bool is_rx_busy(bool second) const { return m_rx_buffers[second].busy; }
+    inline bool is_rx_failed(bool second) const { return m_rx_buffers[second].error; }
+
+    void set_callback(ihs_usart_callback *callback, uintptr_t callback_param);
+
+private:
+    void build_header(packet &packet, uint8_t serial_nr, uint8_t length);
+    bool check_header(packet_header &header);
+    void switch_rx_buffers(void);
+
+    // UsartCore pure virtual function implementations
+    virtual void receiver_idle(void) override;
+    virtual void transmission_complete(void) override;
+    virtual void framing_error(void) override;
+    virtual void overrun(void) override;
+    virtual void rx_dma_transfer_complete(void) override;
+    virtual void rx_dma_half_transfer(void) override;
+    virtual void rx_dma_error(dma_helper::dma_error_type reason) override;
+    virtual void tx_dma_transfer_complete(void) override;
+    virtual void tx_dma_half_transfer(void) override;
+    virtual void tx_dma_error(dma_helper::dma_error_type reason) override;
+
+    struct Buffer
+    {
+        packet pkt;
+        // transfer area ends here
+        bool volatile busy = 0;
+        bool volatile error = 0;
+        uint16_t requested_length = 0;
+        uint32_t error_info = 0;
+    };
+
+    static const uint8_t STARTMARKER = 0x95;
+
+    uint8_t m_rx_serial_nr = -1;
+    uint8_t m_tx_serial_nr = -1;
+    stats m_stats;
+    bool m_rx_buffer_selector = false;
+
+    crc_handler::slot<2> m_crc_slot;
+    ihs_usart_callback *m_user_callback = nullptr;
+    uintptr_t m_user_callback_param = 0;
+    Buffer m_tx_buffer;
+    Buffer m_rx_buffers[2];
+};
+
+}
+#endif /* LL_HSUSART_H_ */

components/f4ll/inc/f4ll/ringbuffer.h

@@ -0,0 +1,218 @@
+/*
+ * ringbuffer.h
+ *
+ *  Created on: May 31, 2025
+ *      Author: Attila Body
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+namespace f4ll {
+
+class iringbuffer
+{
+public:
+    using size_type = size_t;
+
+    /// @brief Copies data to the ring buffer (without committing it)
+    /// @param data Pointer to the data to copy
+    /// @param len Length of the data to copy
+    /// @retval Length of the data copied (differs when not all data can fit)
+    virtual size_type put(uint8_t const *data, size_type len) = 0;
+
+    /// @brief Commits the data already placed into the buffer and notifies the
+    /// consumer about it's availability
+    virtual void commit() = 0;
+
+    /// @brief Waits until all the data from the ring buffer gets consumed.
+    // void flush();
+
+    /// @brief Gets a pointer to the next chunk of committed data in the buffer
+    /// without registering the consumption.
+    ///        The caller should also call report_consumption using the returned
+    ///        chunk length after it finished processing the data.
+    /// @param[in]  len_requested Length of the data requested from the buffer.
+    /// The length of the actual data provided
+    ///             might be actually smaller (because either reaching the end of
+    ///             the buffer or not enough data in the buffer).
+    /// @param[out] data Receives a pointer to the first byte of the available
+    /// data in the buffer
+    /// @param[out] len Receives the length of the chunk available in the buffer.
+    /// Will not exceed len_requested.
+    /// @retval true if the buffer has more available data, false otherwise.
+    virtual bool get_chunk(size_type len_requested, uint8_t const *&data, size_type &len) const = 0;
+
+    /// @brief Marks the chunk returned by ringbuffer_GetChunk as available.
+    /// @param consumed The length of the chunk as returned by
+    /// ringbuffer_GetChunk(..., len)
+    virtual void consumed(size_type len) = 0;
+
+    /// @brief Returns the number of uncommited bytes in the ring buffer.
+    virtual size_type uncommited() const = 0;
+
+    /// @brief Returns the number of commited bytes in the ring buffer.
+    virtual size_type commited() const = 0;
+
+    /// @brief Discards the uncommited data in the ring buffer.
+    virtual void discard() = 0;
+
+    /// @brief Returns the size of the internal buffer.
+    ///        One byte in the buffer is always reserved as separator
+    virtual size_type size() const = 0;
+
+    /// @brief Returns the size of the used place in the buffer
+    //        (including non-commited data)
+    virtual size_type used() const = 0;
+
+    /// @brief Returns the free storage capacity of the buffer
+    virtual size_type unused() const = 0;
+};
+
+template <iringbuffer::size_type SZ> class ringbuffer : public iringbuffer
+{
+public:
+    ringbuffer() = default;
+
+    size_type put(uint8_t const *data, size_type len) override;
+    void commit() override;
+    bool get_chunk(size_type len_requested, uint8_t const *&data, size_type &len) const override;
+    void consumed(size_type len) override;
+    size_type uncommited() const override;
+    size_type commited() const override;
+    void discard() override;
+    size_type size() const override;
+    size_type used() const override;
+    size_type unused() const override;
+
+private:
+    uint8_t m_buffer[SZ];        //!< Data bufer
+    size_type m_head = 0;        //!< Write position
+    size_type m_head_shadow = 0; //!< Shadowed write position for collecting data
+                                 //!< before committing it
+    size_type m_tail = 0;        //!< Read position
+
+    size_type marker_diff(size_type m1, size_type m2) const;
+};
+
+//
+template <iringbuffer::size_type SZ> iringbuffer::size_type ringbuffer<SZ>::put(uint8_t const *data, size_type len)
+{
+    size_type chunk1 = 0;
+    size_type chunk2 = 0;
+
+    if (!data || !len) {
+        return 0;
+    }
+
+    size_type max_len = unused();
+    len = len < max_len ? len : max_len;
+
+    chunk1 = sizeof(m_buffer) - m_head_shadow;
+    if (chunk1 >= len) {
+        chunk1 = len;
+    } else {
+        chunk2 = len - chunk1;
+    }
+
+    std::memcpy(m_buffer + m_head_shadow, data, chunk1);
+    m_head_shadow += chunk1;
+    if (m_head_shadow == sizeof(m_buffer)) {
+        m_head_shadow = 0;
+    }
+
+    if (chunk2) {
+        std::memcpy(m_buffer, data + chunk1, chunk2);
+        m_head_shadow += chunk2;
+        if (m_head_shadow == sizeof(m_buffer)) {
+            m_head_shadow = 0;
+        }
+    }
+
+    return len;
+}
+
+template <iringbuffer::size_type SZ> void ringbuffer<SZ>::commit()
+{
+    m_head = m_head_shadow;
+};
+
+template <iringbuffer::size_type SZ> bool ringbuffer<SZ>::get_chunk(size_type len_requested, uint8_t const *&data, size_type &len) const
+{
+    if (!len_requested) {
+        return false;
+    }
+
+    size_type head = m_head;
+    size_type tail = m_tail;
+    size_type chunk_size = head >= tail ? head - tail : sizeof(m_buffer) - tail;
+
+    if (!chunk_size) {
+        len = 0;
+        return false;
+    }
+
+    if (chunk_size > len_requested) {
+        chunk_size = len_requested;
+    }
+    data = m_buffer + tail;
+    len = chunk_size;
+
+    tail += chunk_size;
+    if (tail == sizeof(m_buffer)) {
+        tail = 0;
+    }
+
+    return tail != head;
+}
+
+template <iringbuffer::size_type SZ> void ringbuffer<SZ>::consumed(size_type len)
+{
+    if (!len) {
+        return;
+    }
+    m_tail += len;
+    if (m_tail == sizeof(m_buffer)) {
+        m_tail = 0;
+    }
+}
+
+template <iringbuffer::size_type SZ> iringbuffer::size_type ringbuffer<SZ>::uncommited() const
+{
+    return marker_diff(m_head_shadow, m_head);
+}
+
+template <iringbuffer::size_type SZ> iringbuffer::size_type ringbuffer<SZ>::commited() const
+{
+    return marker_diff(m_head, m_tail);
+}
+
+template <iringbuffer::size_type SZ> void ringbuffer<SZ>::discard()
+{
+    m_head_shadow = m_head;
+}
+
+template <iringbuffer::size_type SZ> iringbuffer::size_type ringbuffer<SZ>::size() const
+{
+    return SZ;
+}
+
+template <iringbuffer::size_type SZ> iringbuffer::size_type ringbuffer<SZ>::used() const
+{
+    return marker_diff(m_head_shadow, m_tail);
+}
+
+template <iringbuffer::size_type SZ> iringbuffer::size_type ringbuffer<SZ>::unused() const
+{
+    return SZ - used() - 1;
+}
+
+template <iringbuffer::size_type SZ> iringbuffer::size_type ringbuffer<SZ>::marker_diff(size_type m1, size_type m2) const
+{
+    return (m1 >= m2) ? (m1 - m2) : (SZ - m2 + m1);
+}
+
+} // namespace f1ll

components/f4ll/inc/f4ll/singleton.h

@@ -0,0 +1,33 @@
+#ifndef SINGLETON_H_
+#define SINGLETON_H_
+
+#include <utility>
+
+namespace f4ll {
+
+template <typename T> class singleton
+{
+public:
+    static T &instance()
+    {
+        return *m_instance;
+    }
+    template <typename... args_t> static T &init(args_t &&...args)
+    {
+        static T instance{std::forward<args_t>(args)...};
+        m_instance = &instance;
+        return instance;
+    }
+
+protected:
+    singleton() = default;
+    singleton(const singleton &) = delete;
+    singleton &operator=(const singleton &) = delete;
+    static T *m_instance;
+};
+
+template <typename T> T *singleton<T>::m_instance = nullptr;
+
+} //  namespace f1ll {
+
+#endif /* SINGLETON_H_ */

components/f4ll/inc/f4ll/str_util.h

@@ -0,0 +1,31 @@
+/*
+ * strutil.h
+ *
+ *  Created on: Feb 11, 2017
+ *      Author: compi
+ */
+
+#ifndef _STM32PLUS_STRUTIL_H_
+#define _STM32PLUS_STRUTIL_H_
+
+#include <stddef.h>
+#include <inttypes.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+size_t strcpy_ex(char *dst, char const *src);
+size_t uitodec(char* buffer, uint32_t data);
+size_t uitohex(char* buffer, uint32_t data, uint8_t chars);
+size_t itodec(char* buffer, int data);
+size_t itohex(char* buffer, int data);
+void strrev(char *first, char *last);
+char tochr(const uint8_t in, const uint8_t upper);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _STM32PLUS_STRUTIL_H_ */

components/f4ll/inc/f4ll/usart_core.h

@@ -0,0 +1,54 @@
+/*
+ * ll_dmadrivenusartcore.h
+ *
+ *  Created on: Nov 4, 2019
+ *      Author: abody
+ */
+
+#ifndef LL_USARTCORE_H_
+#define LL_USARTCORE_H_
+#include <platform/usart_ll.h>
+
+#include <f4ll/dma_helper.h>
+
+namespace f4ll {
+
+class usart_core
+{
+public:
+    static inline void usart_isr(usart_core *_this) { _this->usart_isr(); }
+    static inline void rx_dma_isr(usart_core *_this) { _this->rx_dma_isr(); }
+    static inline void tx_dma_isr(usart_core *_this) { _this->tx_dma_isr(); }
+
+    void setup_transmit(void const *buffer, uint16_t length);
+    void setup_receive(void *buffer, uint16_t length);
+
+protected:
+    usart_core(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx);
+
+    USART_TypeDef *m_usart;
+    dma_helper m_rx_dma;
+    dma_helper m_tx_dma;
+
+private:
+    virtual void receiver_idle(void) = 0;
+    virtual void transmission_complete(void) = 0;
+    virtual void framing_error(void) = 0;
+    virtual void overrun(void) = 0;
+
+    virtual void rx_dma_transfer_complete(void) = 0;
+    virtual void rx_dma_half_transfer(void) = 0;
+    virtual void rx_dma_error(dma_helper::dma_error_type reason) = 0;
+
+    virtual void tx_dma_transfer_complete(void) = 0;
+    virtual void tx_dma_half_transfer(void) = 0;
+    virtual void tx_dma_error(dma_helper::dma_error_type reason) = 0;
+
+    void usart_isr();
+    void rx_dma_isr();
+    void tx_dma_isr();
+};
+
+} /* namespace f4ll */
+
+#endif /* LL_USARTCORE_H_ */