itm.h

Go to the documentation of this file.

 
#pragma once
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
 
#if !defined(ITM)
#    error \
        "ITM not defined. Include itm.h AFTER core_cmX.h (typically after including device-specific header)"
#endif
 
#if !defined(CoreDebug)
#    error \
        "CoreDebug not defined. Include itm.h AFTER core_cmX.h (typically after including device-specific header)"
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define ITM_ENABLE_STIMULUS_PORTS_ALL 0xFFFFFFFF
 
    typedef enum
    {
        ITMGlobalTimestampFrequencyDisabled = 0,
        ITMGlobalTimestampFrequencyPosition7 = 1,
        ITMGlobalTimestampFrequencyPosition13 = 2,
        ITMGlobalTimestampFrequencyIfOutputFIFOEmpty = 3
    } ITMGlobalTimestampFrequency;
 
    typedef enum
    {
        ITMLocalTimestampPrescalerNoPrescaling = 0,
        ITMLocalTimestampPrescalerDivideBy4 = 1,
        ITMLocalTimestampPrescalerDivideBy10 = 2,
        ITMLocalTimestampPrescalerDivideBy64 = 3,
    } ITMLocalTimestampPrescaler;
 
    typedef struct
    {
        int TraceBusID;
 
        ITMGlobalTimestampFrequency GlobalTimestampFrequency;
 
        ITMLocalTimestampPrescaler LocalTimestampPrescaler;
 
        bool EnableLocalTimestamp;
 
        bool ForwardDWT;
 
        bool EnableSyncPacket;
 
        uint32_t EnabledStimulusPorts;
    } ITMOptions;
 
    static inline void ITMSetup(const ITMOptions* options);
 
    static inline bool ITMIsPortEnabled(uint8_t port);
 
    static inline void ITMWrite8(uint8_t port, uint8_t c);
 
    static inline void ITMWrite16(uint8_t port, uint16_t value);
 
    static inline void ITMWrite32(uint8_t port, uint32_t value);
 
    static inline void ITMWriteBuffer(uint8_t port, const void* buffer, size_t size);
 
    void ITMSetup(const ITMOptions* options)
    {
        CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk; // Enable ITM and DWT
        ITM->LAR = 0xC5ACCE55;                          // unlock ITM access (magic number)
 
        uint32_t tcr = 0;
 
        tcr |= options->TraceBusID << ITM_TCR_TraceBusID_Pos;
        tcr |= ((int)options->GlobalTimestampFrequency) << ITM_TCR_GTSFREQ_Pos;
        tcr |= ((int)options->LocalTimestampPrescaler) << ITM_TCR_TSPrescale_Pos;
        tcr |= (options->ForwardDWT ? 1 : 0) << ITM_TCR_DWTENA_Pos;
        tcr |= (options->EnableSyncPacket ? 1 : 0) << ITM_TCR_SYNCENA_Pos;
        tcr |= (options->EnableLocalTimestamp ? 1 : 0) << ITM_TCR_TSENA_Pos;
        tcr |= ITM_TCR_ITMENA_Msk;
 
        ITM->TCR = tcr;
 
        ITM->TER = 0xFFFFFFFF; // Enable all stimulus ports
    }
 
    bool ITMIsPortEnabled(uint8_t port)
    {
        return ((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */
            ((ITM->TER & (1 << port)) != 0UL);             /* ITM Port enabled */
    }
 
    void ITMWrite8(uint8_t port, uint8_t value)
    {
        if(!ITMIsPortEnabled(port))
        {
            return;
        }
 
        while(ITM->PORT[port].u32 == 0UL)
        {
            __NOP();
        }
        ITM->PORT[port].u8 = value;
    }
 
    void ITMWrite16(uint8_t port, uint16_t value)
    {
        if(!ITMIsPortEnabled(port))
        {
            return;
        }
 
        while(ITM->PORT[port].u32 == 0UL)
        {
            __NOP();
        }
        ITM->PORT[port].u16 = value;
    }
 
    void ITMWrite32(uint8_t port, uint32_t value)
    {
        if(!ITMIsPortEnabled(port))
        {
            return;
        }
 
        while(ITM->PORT[port].u32 == 0UL)
        {
            __NOP();
        }
        ITM->PORT[port].u32 = value;
    }
 
    void ITMWriteBuffer(uint8_t port, const void* buffer, size_t size)
    {
        if(!ITMIsPortEnabled(port))
        {
            return;
        }
 
        const uint8_t* buf8 = (const uint8_t*)buffer;
        while(size >= 4)
        {
            uint32_t v;
            memcpy(&v, buf8, sizeof(v));
            while(ITM->PORT[port].u32 == 0UL)
            {
                __NOP();
            }
            ITM->PORT[port].u32 = v;
 
            buf8 += sizeof(v);
            size -= sizeof(v);
        }
 
        while(size >= 2)
        {
            uint16_t v;
            memcpy(&v, buf8, sizeof(v));
            memcpy(&v, buf8, sizeof(v));
            while(ITM->PORT[port].u32 == 0UL)
            {
                __NOP();
            }
            ITM->PORT[port].u16 = v;
 
            buf8 += sizeof(v);
            size -= sizeof(v);
        }
 
        while(size > 0)
        {
            while(ITM->PORT[port].u32 == 0UL)
            {
                __NOP();
            }
            ITM->PORT[port].u8 = *(buf8++);
 
            size--;
        }
    }
 
#ifdef __cplusplus
}
#endif