dwt.h

#pragma once
#include <stdint.h>
#include <stdbool.h>
 
#if !defined(CoreDebug)
#    error \
        "CoreDebug not defined. Include dwt.h AFTER core_cmX.h (typically after including device-specific header)"
#endif
 
#if !defined(DWT)
#    error \
        "DWT not defined. Include dwt.h AFTER core_cmX.h (typically after including device-specific header)"
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
    typedef enum
    {
        DWTSyncTapDisabled = 0,
        DWTSyncTap24 = 1,
        DWTSyncTap26 = 2,
 
        DWTSyncTap28 = 3,
    } DWTSyncTap;
 
    typedef enum
    {
        DWTCycleTap6 = 0,
        DWTCycleTap10 = 1,
    } DWTCycleTap;
 
    typedef struct
    {
        bool FoldedInstructionCounterEvent;
        bool LSUCounterEvent;
        bool SleepCounterEvent;
        bool ExceptionOverheadCounterEvent;
        bool CPICounterEvent;
        bool ExceptionTrace;
        bool PCSampling;
        DWTSyncTap SyncTap;
        DWTCycleTap CycleTap;
        uint8_t SamplingPrescaler;
    } DWTOptions;
 
    static inline void DWTSetup(const DWTOptions* options);
 
    static inline void
        DWTEnableComparator(uint8_t comparator, uintptr_t address, uint8_t ignoreBits, bool emitRange, uint8_t function);
 
    static inline void DWTDisableComparator(uint8_t comparator);
 
    void DWTSetup(const DWTOptions* options)
    {
        CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk; // Enable ITM and DWT
 
        uint32_t ctrl = 0;
        ctrl |= (options->FoldedInstructionCounterEvent ? 1 : 0) << DWT_CTRL_FOLDEVTENA_Pos;
        ctrl |= (options->LSUCounterEvent ? 1 : 0) << DWT_CTRL_LSUEVTENA_Pos;
        ctrl |= (options->SleepCounterEvent ? 1 : 0) << DWT_CTRL_SLEEPEVTENA_Pos;
        ctrl |= (options->ExceptionOverheadCounterEvent ? 1 : 0) << DWT_CTRL_EXCEVTENA_Pos;
        ctrl |= (options->CPICounterEvent ? 1 : 0) << DWT_CTRL_CPIEVTENA_Pos;
        ctrl |= (options->ExceptionTrace ? 1 : 0) << DWT_CTRL_EXCTRCENA_Pos;
        ctrl |= (options->PCSampling ? 1 : 0) << DWT_CTRL_PCSAMPLENA_Pos;
        ctrl |= (((int)options->SyncTap) & 3) << DWT_CTRL_SYNCTAP_Pos;
        ctrl |= (((int)options->CycleTap) & 3) << DWT_CTRL_CYCTAP_Pos;
        ctrl |= (options->SamplingPrescaler - 1) << DWT_CTRL_POSTPRESET_Pos;
        ctrl |= DWT_CTRL_CYCCNTENA_Msk;
 
        DWT->CTRL = ctrl;
    }
 
    void DWTEnableComparator(uint8_t comparator, uintptr_t address, uint8_t ignoreBits, bool emitRange, uint8_t function)
    {
        uint32_t funcRaw = ((function << DWT_FUNCTION_FUNCTION_Pos) & DWT_FUNCTION_FUNCTION_Msk) |
            ((emitRange ? 1 : 0) << DWT_FUNCTION_EMITRANGE_Pos);
 
        switch(comparator)
        {
            case 0:
                DWT->COMP0 = address;
                DWT->MASK0 = ignoreBits;
                DWT->FUNCTION0 = funcRaw;
                break;
            case 1:
                DWT->COMP1 = address;
                DWT->MASK1 = ignoreBits;
                DWT->FUNCTION1 = funcRaw;
                break;
            case 2:
                DWT->COMP2 = address;
                DWT->MASK2 = ignoreBits;
                DWT->FUNCTION2 = funcRaw;
                break;
            case 3:
                DWT->COMP3 = address;
                DWT->MASK3 = ignoreBits;
                DWT->FUNCTION3 = funcRaw;
                break;
        }
    }
 
    void DWTDisableComparator(uint8_t comparator)
    {
        switch(comparator)
        {
            case 0:
                DWT->FUNCTION0 = 0;
                break;
            case 1:
                DWT->FUNCTION1 = 0;
                break;
            case 2:
                DWT->FUNCTION2 = 0;
                break;
            case 3:
                DWT->FUNCTION3 = 0;
                break;
        }
    }
 
#ifdef __cplusplus
}
#endif