fsl_qtmr.h

/*
 * Copyright 2017-2022 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef _FSL_QTMR_H_
#define _FSL_QTMR_H_
 
#include "fsl_common.h"
#ifdef __rtems__
#include <rtems.h>
#endif /* __rtems__ */
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
#ifndef TMR_CSCTRL_OFLAG_MASK
#define TMR_CSCTRL_OFLAG_MASK (0x100UL)
#endif
 
#ifndef TMR_CSCTRL_OFLAG_SHIFT
#define TMR_CSCTRL_OFLAG_SHIFT (8UL)
#endif
 
#define FSL_QTMR_DRIVER_VERSION (MAKE_VERSION(2, 2, 1)) 
 
typedef enum _qtmr_primary_count_source
{
    kQTMR_ClockCounter0InputPin = 0, 
    kQTMR_ClockCounter1InputPin,     
    kQTMR_ClockCounter2InputPin,     
    kQTMR_ClockCounter3InputPin,     
    kQTMR_ClockCounter0Output,       
    kQTMR_ClockCounter1Output,       
    kQTMR_ClockCounter2Output,       
    kQTMR_ClockCounter3Output,       
    kQTMR_ClockDivide_1,             
    kQTMR_ClockDivide_2,             
    kQTMR_ClockDivide_4,             
    kQTMR_ClockDivide_8,             
    kQTMR_ClockDivide_16,            
    kQTMR_ClockDivide_32,            
    kQTMR_ClockDivide_64,            
    kQTMR_ClockDivide_128            
} qtmr_primary_count_source_t;
 
typedef enum _qtmr_input_source
{
    kQTMR_Counter0InputPin = 0, 
    kQTMR_Counter1InputPin,     
    kQTMR_Counter2InputPin,     
    kQTMR_Counter3InputPin      
} qtmr_input_source_t;
 
typedef enum _qtmr_counting_mode
{
    kQTMR_NoOperation = 0,          
    kQTMR_PriSrcRiseEdge,           
    kQTMR_PriSrcRiseAndFallEdge,    
    kQTMR_PriSrcRiseEdgeSecInpHigh, 
    kQTMR_QuadCountMode,            
    kQTMR_PriSrcRiseEdgeSecDir,     
    kQTMR_SecSrcTrigPriCnt,         
    kQTMR_CascadeCount              
} qtmr_counting_mode_t;
 
typedef enum _qtmr_pwm_out_state
{
    kQTMR_PwmLow = 0, 
    kQTMR_PwmHigh,    
} qtmr_pwm_out_state_t;
 
typedef enum _qtmr_output_mode
{
    kQTMR_AssertWhenCountActive = 0,    
    kQTMR_ClearOnCompare,               
    kQTMR_SetOnCompare,                 
    kQTMR_ToggleOnCompare,              
    kQTMR_ToggleOnAltCompareReg,        
    kQTMR_SetOnCompareClearOnSecSrcInp, 
    kQTMR_SetOnCompareClearOnCountRoll, 
    kQTMR_EnableGateClock               
} qtmr_output_mode_t;
 
typedef enum _qtmr_input_capture_edge
{
    kQTMR_NoCapture = 0,       
    kQTMR_RisingEdge,          
    kQTMR_FallingEdge,         
    kQTMR_RisingAndFallingEdge 
} qtmr_input_capture_edge_t;
 
typedef enum _qtmr_preload_control
{
    kQTMR_NoPreload = 0, 
    kQTMR_LoadOnComp1,   
    kQTMR_LoadOnComp2    
} qtmr_preload_control_t;
 
typedef enum _qtmr_debug_action
{
    kQTMR_RunNormalInDebug = 0U, 
    kQTMR_HaltCounter,           
    kQTMR_ForceOutToZero,        
    kQTMR_HaltCountForceOutZero  
} qtmr_debug_action_t;
 
// typedef enum _qtmr_interrupt_enable
typedef enum _qtmr_interrupt_enable
{
    kQTMR_CompareInterruptEnable  = (1U << 0), 
    kQTMR_Compare1InterruptEnable = (1U << 1), 
    kQTMR_Compare2InterruptEnable = (1U << 2), 
    kQTMR_OverflowInterruptEnable = (1U << 3), 
    kQTMR_EdgeInterruptEnable     = (1U << 4)  
} qtmr_interrupt_enable_t;
 
typedef enum _qtmr_status_flags
{
    kQTMR_CompareFlag  = (1U << 0), 
    kQTMR_Compare1Flag = (1U << 1), 
    kQTMR_Compare2Flag = (1U << 2), 
    kQTMR_OverflowFlag = (1U << 3), 
    kQTMR_EdgeFlag     = (1U << 4)  
} qtmr_status_flags_t;
 
typedef enum _qtmr_channel_selection
{
    kQTMR_Channel_0 = 0U, 
    kQTMR_Channel_1,      
    kQTMR_Channel_2,      
    kQTMR_Channel_3,      
} qtmr_channel_selection_t;
 
typedef enum _qtmr_dma_enable
{
    kQTMR_InputEdgeFlagDmaEnable      = (1U << 0), 
    kQTMR_ComparatorPreload1DmaEnable = (1U << 1), 
    kQTMR_ComparatorPreload2DmaEnable = (1U << 2), 
} qtmr_dma_enable_t;
 
typedef struct _qtmr_config
{
    qtmr_primary_count_source_t primarySource; 
    qtmr_input_source_t secondarySource;       
    bool enableMasterMode;                     
    bool enableExternalForce;                  
    uint8_t faultFilterCount;                  
    uint8_t faultFilterPeriod;                 
    qtmr_debug_action_t debugMode;             
} qtmr_config_t;
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#ifdef __rtems__
TMR_Type *QTMR_get_regs_from_fdt(const void *fdt, int node);
 
rtems_vector_number QTMR_get_IRQ_from_fdt(const void *fdt, int node);
 
uint32_t QTMR_get_src_clk(TMR_Type *base);
#endif /* __rtems__ */
 
void QTMR_Init(TMR_Type *base, qtmr_channel_selection_t channel, const qtmr_config_t *config);
 
void QTMR_Deinit(TMR_Type *base, qtmr_channel_selection_t channel);
 
void QTMR_GetDefaultConfig(qtmr_config_t *config);
 
status_t QTMR_SetupPwm(TMR_Type *base,
                       qtmr_channel_selection_t channel,
                       uint32_t pwmFreqHz,
                       uint8_t dutyCyclePercent,
                       bool outputPolarity,
                       uint32_t srcClock_Hz);
 
void QTMR_SetupInputCapture(TMR_Type *base,
                            qtmr_channel_selection_t channel,
                            qtmr_input_source_t capturePin,
                            bool inputPolarity,
                            bool reloadOnCapture,
                            qtmr_input_capture_edge_t captureMode);
 
void QTMR_EnableInterrupts(TMR_Type *base, qtmr_channel_selection_t channel, uint32_t mask);
 
void QTMR_DisableInterrupts(TMR_Type *base, qtmr_channel_selection_t channel, uint32_t mask);
 
uint32_t QTMR_GetEnabledInterrupts(TMR_Type *base, qtmr_channel_selection_t channel);
 
uint32_t QTMR_GetStatus(TMR_Type *base, qtmr_channel_selection_t channel);
 
void QTMR_ClearStatusFlags(TMR_Type *base, qtmr_channel_selection_t channel, uint32_t mask);
 
void QTMR_SetTimerPeriod(TMR_Type *base, qtmr_channel_selection_t channel, uint16_t ticks);
 
void QTMR_SetCompareValue(TMR_Type *base, qtmr_channel_selection_t channel, uint16_t ticks);
 
static inline void QTMR_SetLoadValue(TMR_Type *base, qtmr_channel_selection_t channel, uint16_t value)
{
    base->CHANNEL[channel].LOAD &= (uint16_t)(~TMR_LOAD_LOAD_MASK);
    base->CHANNEL[channel].LOAD = value;
}
 
static inline uint16_t QTMR_GetCurrentTimerCount(TMR_Type *base, qtmr_channel_selection_t channel)
{
    return base->CHANNEL[channel].CNTR;
}
 
static inline void QTMR_StartTimer(TMR_Type *base, qtmr_channel_selection_t channel, qtmr_counting_mode_t clockSource)
{
    uint16_t reg = base->CHANNEL[channel].CTRL;
 
    reg &= (uint16_t)(~(TMR_CTRL_CM_MASK));
    reg |= TMR_CTRL_CM(clockSource);
    base->CHANNEL[channel].CTRL = reg;
}
 
static inline void QTMR_StopTimer(TMR_Type *base, qtmr_channel_selection_t channel)
{
    base->CHANNEL[channel].CTRL &= (uint16_t)(~TMR_CTRL_CM_MASK);
}
 
void QTMR_EnableDma(TMR_Type *base, qtmr_channel_selection_t channel, uint32_t mask);
 
void QTMR_DisableDma(TMR_Type *base, qtmr_channel_selection_t channel, uint32_t mask);
 
void QTMR_SetPwmOutputToIdle(TMR_Type *base, qtmr_channel_selection_t channel, bool idleStatus);
 
static inline qtmr_pwm_out_state_t QTMR_GetPwmOutputStatus(TMR_Type *base, qtmr_channel_selection_t channel)
{
    if (0U != ((base->CHANNEL[channel].CSCTRL) & TMR_CSCTRL_OFLAG_MASK))
    {
        return kQTMR_PwmHigh;
    }
    else
    {
        return kQTMR_PwmLow;
    }
}
 
uint8_t QTMR_GetPwmChannelStatus(TMR_Type *base, qtmr_channel_selection_t channel);
 
void QTMR_SetPwmClockMode(TMR_Type *base, qtmr_channel_selection_t channel, qtmr_primary_count_source_t prescaler);
 
#if defined(__cplusplus)
}
#endif
 
#endif /* _FSL_QTMR_H_ */