gpt.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef  __GPT_H
#define  __GPT_H
 
#include <predef.h>
#include <stdint.h>
#include <stddef.h>
#include <sim.h>
 
enum GPT_Clk
{
    GPT_CLK_OFF     = 0u,
    GPT_CLK_PERIPH  = 1u,
    GPT_CLK_HF_REF  = 2u,
    GPT_CLK_EXT     = 3u,
    GPT_CLK_LF_REF  = 4u,
    GPT_CLK_XO      = 5u,
};
 
enum GPT_CapCh
{
    GPT_CAP_CH1 = 0u,
    GPT_CAP_CH2 = 1u
};
 
enum GPT_CapEdge
{
    GPT_CAP_NONE    = 0u,
    GPT_CAP_RISING  = 1u,
    GPT_CAP_FALLING = 2u,
    GPT_CAP_BOTH    = 3u,
};
 
enum GPT_CompCh
{
    GPT_COMP_CH1 = 0u,
    GPT_COMP_CH2 = 1u,
    GPT_COMP_CH3 = 2u,
};
 
enum GPT_OutMode
{
    GPT_OUT_NONE        = 0u,
    GPT_OUT_TGL         = 1u,
    GPT_OUT_CLR         = 2u,
    GPT_OUT_SET         = 3u,
    GPT_OUT_LOW_PULSE   = 4u,
};
 
class GPTimer : private GPT_Type
{
    struct ctx_t
    {
        void (*irqCB)(GPTimer *);
        uint32_t irqCount;
    };
    static ctx_t sCtxs[2];
    static ctx_t *sGetCtx(GPTimer *timer)
    {
        switch ((uint32_t)timer) {
            case GPT1_BASE: return sCtxs + 0;
            case GPT2_BASE: return sCtxs + 1;
        }
        return NULL;
    }
 
    GPTimer();
    void isr();
 
    friend void irq_gpt1();
    friend void irq_gpt2();
public:
    static inline GPTimer *GPT(GPT_Type *gpt);
 
    void Init(uint32_t div, bool freeRun, bool restartFromZero, GPT_Clk clk = GPT_CLK_PERIPH);
 
    inline void     Reset();
           void     ResetCount();
    inline void     SetClkSrc(GPT_Clk clk);
    inline GPT_Clk  GetClkSrc();
    inline void     SetClkDiv(uint32_t div);
    inline uint32_t GetClkDiv();
    inline void     SetOscClkDiv(uint32_t divider);
    inline uint32_t GetOscClkDiv();
    inline void     Start();
    inline void     Stop();
    inline uint32_t GetCurCount();
    inline void     SetCapEdge(GPT_CapCh ch, GPT_CapEdge edge);
    inline GPT_CapEdge GetCapEdge(GPT_CapCh ch);
    inline uint32_t GetCapVal(GPT_CapCh ch);
    inline void     SetOutMode(GPT_CompCh ch, GPT_OutMode mode);
    inline GPT_OutMode GetOutMode(GPT_CompCh ch);
    inline void     SetCompVal(GPT_CompCh ch, uint32_t val);
    inline uint32_t GetCompVal(GPT_CompCh ch);
    inline void     ForceOutput(GPT_CompCh ch);
    inline void     EnableIRQ(uint32_t mask);
    inline void     DisableIRQ(uint32_t mask);
    inline uint32_t GetEnabledIRQ();
    inline uint32_t GetStatus(uint32_t flags = 0xFFFFFFFF);
    inline void     ClrIRQ(uint32_t flags);
 
    inline void     SetIRQFn( void (*fn)(GPTimer *) );
    inline uint32_t GetIRQCount();
};
 
inline GPTimer *GPTimer::
GPT(GPT_Type *gpt)
{
    return (GPTimer*)(gpt);
}
 
inline void GPTimer::
Reset()
{
    CR |= GPT_CR_SWR_MASK; while((CR & GPT_CR_SWR_MASK));
}
 
inline void GPTimer::
SetClkSrc(GPT_Clk clk)
{
    CR = (CR & ~(GPT_CR_CLKSRC_MASK | GPT_CR_EN_24M_MASK))
        | GPT_CR_CLKSRC(clk)
        | ((clk == GPT_CLK_XO) ? GPT_CR_EN_24M_MASK : 0);
}
 
inline GPT_Clk GPTimer::
GetClkSrc()
{
    return (GPT_Clk)((CR & GPT_CR_CLKSRC_MASK) >> GPT_CR_CLKSRC_SHIFT);
}
 
inline void GPTimer::
SetClkDiv(uint32_t div)
{
    PR = (PR & ~GPT_PR_PRESCALER_MASK) | GPT_PR_PRESCALER(div - 1U);
}
 
inline uint32_t GPTimer::
GetClkDiv()
{
    return ((PR & GPT_PR_PRESCALER_MASK) >> GPT_PR_PRESCALER_SHIFT) + 1U;
}
 
inline void GPTimer::
SetOscClkDiv(uint32_t divider)
{
    PR = (PR & ~GPT_PR_PRESCALER24M_MASK) | GPT_PR_PRESCALER24M(divider - 1U);
}
 
inline uint32_t GPTimer::
GetOscClkDiv()
{
    return ((PR & GPT_PR_PRESCALER24M_MASK) >> GPT_PR_PRESCALER24M_SHIFT) + 1U;
}
 
inline void GPTimer::
Start()
{
    CR |= GPT_CR_EN_MASK;
}
 
inline void GPTimer::
Stop()
{
    CR &= ~GPT_CR_EN_MASK;
}
 
inline uint32_t GPTimer::
GetCurCount()
{
    return CNT;
}
 
inline void GPTimer::
SetCapEdge(GPT_CapCh ch, GPT_CapEdge edge)
{
    CR = (CR & ~(GPT_CR_IM1_MASK << ((uint32_t)ch * 2UL)))
            | (GPT_CR_IM1(edge) << ((uint32_t)ch * 2UL));
}
 
inline GPT_CapEdge GPTimer::
GetCapEdge(GPT_CapCh ch)
{
    return (GPT_CapEdge)(uint8_t)
        ((CR >> (GPT_CR_IM1_SHIFT + (uint32_t)ch * 2UL))
         & (GPT_CR_IM1_MASK >> GPT_CR_IM1_SHIFT));
}
 
inline uint32_t GPTimer::
GetCapVal(GPT_CapCh ch)
{
    return ICR[ch];
}
 
inline void GPTimer::
SetOutMode(GPT_CompCh ch, GPT_OutMode mode)
{
    CR = (CR & ~(GPT_CR_OM1_MASK << ((uint32_t)ch * 3UL)))
            | (GPT_CR_OM1(mode) << ((uint32_t)ch * 3UL));
}
 
inline GPT_OutMode GPTimer::
GetOutMode(GPT_CompCh ch)
{
    return (GPT_OutMode)(uint8_t)
        ((CR >> (GPT_CR_OM1_SHIFT + (uint32_t)ch * 3UL))
         & (GPT_CR_OM1_MASK >> GPT_CR_OM1_SHIFT));
}
 
inline void GPTimer::
SetCompVal(GPT_CompCh ch, uint32_t val)
{
    OCR[ch] = val;
}
 
inline uint32_t GPTimer::
GetCompVal(GPT_CompCh ch)
{
    return OCR[ch];
}
 
inline void GPTimer::
ForceOutput(GPT_CompCh ch)
{
    CR |= (GPT_CR_FO1_MASK << (uint32_t)ch);
}
 
inline void GPTimer::
EnableIRQ(uint32_t mask)
{
    IR |= mask;
}
 
inline void GPTimer::
DisableIRQ(uint32_t mask)
{
    IR &= ~mask;
}
 
inline uint32_t GPTimer::
GetEnabledIRQ()
{
    return IR;
}
 
inline uint32_t GPTimer::
GetStatus(uint32_t flags)
{
    return SR & flags;
}
 
inline void GPTimer::
ClrIRQ(uint32_t flags)
{
    SR = flags;
    asm("dsb");
}
 
inline void GPTimer::
SetIRQFn( void (*fn)(GPTimer *) )
{
    GPTimer::ctx_t *ctx = sGetCtx(this);
    if (ctx) { ctx->irqCB = fn; }
}
 
inline uint32_t GPTimer::
GetIRQCount()
{
    GPTimer::ctx_t *ctx = sGetCtx(this);
    if (ctx) { return ctx->irqCount; }
    return 0;
}
 
 
 
#endif   /* ----- #ifndef __GPT_H  ----- */