fsl_pwm.h

/*
 * Copyright (c) 2015, Freescale Semiconductor, Inc.
 * Copyright 2016-2022 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef _FSL_PWM_H_
#define _FSL_PWM_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
#define FSL_PWM_DRIVER_VERSION (MAKE_VERSION(2, 5, 1)) 
 
#define PWM_SUBMODULE_SWCONTROL_WIDTH 2
#define PWM_SUBMODULE_CHANNEL 2
 
typedef enum _pwm_submodule
{
    kPWM_Module_0 = 0U, 
    kPWM_Module_1,      
    kPWM_Module_2,      
    kPWM_Module_3       
} pwm_submodule_t;
 
typedef enum _pwm_channels
{
    kPWM_PwmB = 0U,
    kPWM_PwmA,
    kPWM_PwmX
} pwm_channels_t;
 
typedef enum _pwm_value_register
{
    kPWM_ValueRegister_0 = 0U, 
    kPWM_ValueRegister_1,      
    kPWM_ValueRegister_2,      
    kPWM_ValueRegister_3,      
    kPWM_ValueRegister_4,      
    kPWM_ValueRegister_5       
} pwm_value_register_t;
 
enum _pwm_value_register_mask
{
    kPWM_ValueRegisterMask_0 = (1U << 0), 
    kPWM_ValueRegisterMask_1 = (1U << 1), 
    kPWM_ValueRegisterMask_2 = (1U << 2), 
    kPWM_ValueRegisterMask_3 = (1U << 3), 
    kPWM_ValueRegisterMask_4 = (1U << 4), 
    kPWM_ValueRegisterMask_5 = (1U << 5)  
};
 
typedef enum _pwm_clock_source
{
    kPWM_BusClock = 0U,  
    kPWM_ExternalClock,  
    kPWM_Submodule0Clock 
} pwm_clock_source_t;
 
typedef enum _pwm_clock_prescale
{
    kPWM_Prescale_Divide_1 = 0U, 
    kPWM_Prescale_Divide_2,      
    kPWM_Prescale_Divide_4,      
    kPWM_Prescale_Divide_8,      
    kPWM_Prescale_Divide_16,     
    kPWM_Prescale_Divide_32,     
    kPWM_Prescale_Divide_64,     
    kPWM_Prescale_Divide_128     
} pwm_clock_prescale_t;
 
typedef enum _pwm_force_output_trigger
{
    kPWM_Force_Local = 0U,   
    kPWM_Force_Master,       
    kPWM_Force_LocalReload,  
    kPWM_Force_MasterReload, 
    kPWM_Force_LocalSync,    
    kPWM_Force_MasterSync,   
    kPWM_Force_External,     
    kPWM_Force_ExternalSync  
} pwm_force_output_trigger_t;
 
typedef enum _pwm_output_state
{
    kPWM_HighState = 0, 
    kPWM_LowState,      
    kPWM_NormalState,   
    kPWM_InvertState,   
    kPWM_MaskState      
} pwm_output_state_t;
 
typedef enum _pwm_init_source
{
    kPWM_Initialize_LocalSync = 0U, 
    kPWM_Initialize_MasterReload,   
    kPWM_Initialize_MasterSync,     
    kPWM_Initialize_ExtSync         
} pwm_init_source_t;
 
typedef enum _pwm_load_frequency
{
    kPWM_LoadEveryOportunity = 0U, 
    kPWM_LoadEvery2Oportunity,     
    kPWM_LoadEvery3Oportunity,     
    kPWM_LoadEvery4Oportunity,     
    kPWM_LoadEvery5Oportunity,     
    kPWM_LoadEvery6Oportunity,     
    kPWM_LoadEvery7Oportunity,     
    kPWM_LoadEvery8Oportunity,     
    kPWM_LoadEvery9Oportunity,     
    kPWM_LoadEvery10Oportunity,    
    kPWM_LoadEvery11Oportunity,    
    kPWM_LoadEvery12Oportunity,    
    kPWM_LoadEvery13Oportunity,    
    kPWM_LoadEvery14Oportunity,    
    kPWM_LoadEvery15Oportunity,    
    kPWM_LoadEvery16Oportunity     
} pwm_load_frequency_t;
 
typedef enum _pwm_fault_input
{
    kPWM_Fault_0 = 0U, 
    kPWM_Fault_1,      
    kPWM_Fault_2,      
    kPWM_Fault_3       
} pwm_fault_input_t;
 
typedef enum _pwm_fault_disable
{
    kPWM_FaultDisable_0 = (1U << 0), 
    kPWM_FaultDisable_1 = (1U << 1), 
    kPWM_FaultDisable_2 = (1U << 2), 
    kPWM_FaultDisable_3 = (1U << 3)  
} pwm_fault_disable_t;
 
typedef enum _pwm_fault_channels
{
    kPWM_faultchannel_0 = 0U,
    kPWM_faultchannel_1
} pwm_fault_channels_t;
 
typedef enum _pwm_input_capture_edge
{
    kPWM_Disable = 0U,   
    kPWM_FallingEdge,    
    kPWM_RisingEdge,     
    kPWM_RiseAndFallEdge 
} pwm_input_capture_edge_t;
 
typedef enum _pwm_force_signal
{
    kPWM_UsePwm = 0U,     
    kPWM_InvertedPwm,     
    kPWM_SoftwareControl, 
    kPWM_UseExternal      
} pwm_force_signal_t;
 
typedef enum _pwm_chnl_pair_operation
{
    kPWM_Independent = 0U,  
    kPWM_ComplementaryPwmA, 
    kPWM_ComplementaryPwmB  
} pwm_chnl_pair_operation_t;
 
typedef enum _pwm_register_reload
{
    kPWM_ReloadImmediate = 0U,     
    kPWM_ReloadPwmHalfCycle,       
    kPWM_ReloadPwmFullCycle,       
    kPWM_ReloadPwmHalfAndFullCycle 
} pwm_register_reload_t;
 
typedef enum _pwm_fault_recovery_mode
{
    kPWM_NoRecovery = 0U,        
    kPWM_RecoverHalfCycle,       
    kPWM_RecoverFullCycle,       
    kPWM_RecoverHalfAndFullCycle 
} pwm_fault_recovery_mode_t;
 
typedef enum _pwm_interrupt_enable
{
    kPWM_CompareVal0InterruptEnable = (1U << 0),  
    kPWM_CompareVal1InterruptEnable = (1U << 1),  
    kPWM_CompareVal2InterruptEnable = (1U << 2),  
    kPWM_CompareVal3InterruptEnable = (1U << 3),  
    kPWM_CompareVal4InterruptEnable = (1U << 4),  
    kPWM_CompareVal5InterruptEnable = (1U << 5),  
    kPWM_CaptureX0InterruptEnable   = (1U << 6),  
    kPWM_CaptureX1InterruptEnable   = (1U << 7),  
    kPWM_CaptureB0InterruptEnable   = (1U << 8),  
    kPWM_CaptureB1InterruptEnable   = (1U << 9),  
    kPWM_CaptureA0InterruptEnable   = (1U << 10), 
    kPWM_CaptureA1InterruptEnable   = (1U << 11), 
    kPWM_ReloadInterruptEnable      = (1U << 12), 
    kPWM_ReloadErrorInterruptEnable = (1U << 13), 
    kPWM_Fault0InterruptEnable      = (1U << 16), 
    kPWM_Fault1InterruptEnable      = (1U << 17), 
    kPWM_Fault2InterruptEnable      = (1U << 18), 
    kPWM_Fault3InterruptEnable      = (1U << 19)  
} pwm_interrupt_enable_t;
 
typedef enum _pwm_status_flags
{
    kPWM_CompareVal0Flag = (1U << 0),  
    kPWM_CompareVal1Flag = (1U << 1),  
    kPWM_CompareVal2Flag = (1U << 2),  
    kPWM_CompareVal3Flag = (1U << 3),  
    kPWM_CompareVal4Flag = (1U << 4),  
    kPWM_CompareVal5Flag = (1U << 5),  
    kPWM_CaptureX0Flag   = (1U << 6),  
    kPWM_CaptureX1Flag   = (1U << 7),  
    kPWM_CaptureB0Flag   = (1U << 8),  
    kPWM_CaptureB1Flag   = (1U << 9),  
    kPWM_CaptureA0Flag   = (1U << 10), 
    kPWM_CaptureA1Flag   = (1U << 11), 
    kPWM_ReloadFlag      = (1U << 12), 
    kPWM_ReloadErrorFlag = (1U << 13), 
    kPWM_RegUpdatedFlag  = (1U << 14), 
    kPWM_Fault0Flag      = (1U << 16), 
    kPWM_Fault1Flag      = (1U << 17), 
    kPWM_Fault2Flag      = (1U << 18), 
    kPWM_Fault3Flag      = (1U << 19)  
} pwm_status_flags_t;
 
typedef enum _pwm_dma_enable
{
    kPWM_CaptureX0DMAEnable = (1U << 0), 
    kPWM_CaptureX1DMAEnable = (1U << 1), 
    kPWM_CaptureB0DMAEnable = (1U << 2), 
    kPWM_CaptureB1DMAEnable = (1U << 3), 
    kPWM_CaptureA0DMAEnable = (1U << 4), 
    kPWM_CaptureA1DMAEnable = (1U << 5)  
} pwm_dma_enable_t;
 
typedef enum _pwm_dma_source_select
{
    kPWM_DMARequestDisable = 0U, 
    kPWM_DMAWatermarksEnable,    
    kPWM_DMALocalSync,           
    kPWM_DMALocalReload          
} pwm_dma_source_select_t;
 
typedef enum _pwm_watermark_control
{
    kPWM_FIFOWatermarksOR = 0U, 
    kPWM_FIFOWatermarksAND      
} pwm_watermark_control_t;
 
typedef enum _pwm_mode
{
    kPWM_SignedCenterAligned = 0U, 
    kPWM_CenterAligned,            
    kPWM_SignedEdgeAligned,        
    kPWM_EdgeAligned               
} pwm_mode_t;
 
typedef enum _pwm_level_select
{
    kPWM_HighTrue = 0U, 
    kPWM_LowTrue        
} pwm_level_select_t;
 
typedef enum _pwm_fault_state
{
    kPWM_PwmFaultState0 =
        0U,              
    kPWM_PwmFaultState1, 
    kPWM_PwmFaultState2, 
    kPWM_PwmFaultState3  
} pwm_fault_state_t;
 
typedef enum _pwm_reload_source_select
{
    kPWM_LocalReload = 0U, 
    kPWM_MasterReload      
} pwm_reload_source_select_t;
 
typedef enum _pwm_fault_clear
{
    kPWM_Automatic = 0U, 
    kPWM_ManualNormal,   
    kPWM_ManualSafety    
} pwm_fault_clear_t;
 
typedef enum _pwm_module_control
{
    kPWM_Control_Module_0 = (1U << 0), 
    kPWM_Control_Module_1 = (1U << 1), 
    kPWM_Control_Module_2 = (1U << 2), 
    kPWM_Control_Module_3 = (1U << 3)  
} pwm_module_control_t;
 
typedef struct _pwm_signal_param
{
    pwm_channels_t pwmChannel; 
    uint8_t dutyCyclePercent;  
    pwm_level_select_t level;  
    uint16_t deadtimeValue;    
    pwm_fault_state_t faultState; 
    bool pwmchannelenable;        
} pwm_signal_param_t;
 
typedef struct _pwm_config
{
    bool enableDebugMode; 
#if !defined(FSL_FEATURE_PWM_HAS_NO_WAITEN) || (!FSL_FEATURE_PWM_HAS_NO_WAITEN)
    bool enableWait;                         
#endif                                       /* FSL_FEATURE_PWM_HAS_NO_WAITEN */
    pwm_init_source_t initializationControl; 
    pwm_clock_source_t clockSource;          
    pwm_clock_prescale_t prescale;           
    pwm_chnl_pair_operation_t pairOperation; 
    pwm_register_reload_t reloadLogic;       
    pwm_reload_source_select_t reloadSelect; 
    pwm_load_frequency_t reloadFrequency;    
    pwm_force_output_trigger_t forceTrigger; 
} pwm_config_t;
 
typedef struct _pwm_fault_input_filter_param
{
    uint8_t faultFilterCount;  
    uint8_t faultFilterPeriod; 
    bool faultGlitchStretch;   
} pwm_fault_input_filter_param_t;
 
typedef struct _pwm_fault_param
{
    pwm_fault_clear_t faultClearingMode;   
    bool faultLevel;                       
    bool enableCombinationalPath;          
    pwm_fault_recovery_mode_t recoverMode; 
} pwm_fault_param_t;
 
typedef struct _pwm_input_capture_param
{
    bool captureInputSel;           
    uint8_t edgeCompareValue;       
    pwm_input_capture_edge_t edge0; 
    pwm_input_capture_edge_t edge1; 
    bool enableOneShotCapture;      
    uint8_t fifoWatermark;          
} pwm_input_capture_param_t;
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif
 
status_t PWM_Init(PWM_Type *base, pwm_submodule_t subModule, const pwm_config_t *config);
 
void PWM_Deinit(PWM_Type *base, pwm_submodule_t subModule);
 
void PWM_GetDefaultConfig(pwm_config_t *config);
 
status_t PWM_SetupPwm(PWM_Type *base,
                      pwm_submodule_t subModule,
                      const pwm_signal_param_t *chnlParams,
                      uint8_t numOfChnls,
                      pwm_mode_t mode,
                      uint32_t pwmFreq_Hz,
                      uint32_t srcClock_Hz);
 
status_t PWM_SetupPwmPhaseShift(PWM_Type *base,
                                pwm_submodule_t subModule,
                                pwm_channels_t pwmChannel,
                                uint32_t pwmFreq_Hz,
                                uint32_t srcClock_Hz,
                                uint8_t shiftvalue,
                                bool doSync);
 
void PWM_UpdatePwmDutycycle(PWM_Type *base,
                            pwm_submodule_t subModule,
                            pwm_channels_t pwmSignal,
                            pwm_mode_t currPwmMode,
                            uint8_t dutyCyclePercent);
 
void PWM_UpdatePwmDutycycleHighAccuracy(
    PWM_Type *base, pwm_submodule_t subModule, pwm_channels_t pwmSignal, pwm_mode_t currPwmMode, uint16_t dutyCycle);
 
void PWM_SetupInputCapture(PWM_Type *base,
                           pwm_submodule_t subModule,
                           pwm_channels_t pwmChannel,
                           const pwm_input_capture_param_t *inputCaptureParams);
 
void PWM_SetupFaultInputFilter(PWM_Type *base, const pwm_fault_input_filter_param_t *faultInputFilterParams);
 
void PWM_SetupFaults(PWM_Type *base, pwm_fault_input_t faultNum, const pwm_fault_param_t *faultParams);
 
void PWM_FaultDefaultConfig(pwm_fault_param_t *config);
 
void PWM_SetupForceSignal(PWM_Type *base,
                          pwm_submodule_t subModule,
                          pwm_channels_t pwmChannel,
                          pwm_force_signal_t mode);
 
void PWM_EnableInterrupts(PWM_Type *base, pwm_submodule_t subModule, uint32_t mask);
 
void PWM_DisableInterrupts(PWM_Type *base, pwm_submodule_t subModule, uint32_t mask);
 
uint32_t PWM_GetEnabledInterrupts(PWM_Type *base, pwm_submodule_t subModule);
 
static inline void PWM_DMAFIFOWatermarkControl(PWM_Type *base,
                                               pwm_submodule_t subModule,
                                               pwm_watermark_control_t pwm_watermark_control)
{
    uint16_t reg = base->SM[subModule].DMAEN;
    if (pwm_watermark_control == kPWM_FIFOWatermarksOR)
    {
        reg &= ~((uint16_t)PWM_DMAEN_FAND_MASK);
    }
    else
    {
        reg |= ((uint16_t)PWM_DMAEN_FAND_MASK);
    }
    base->SM[subModule].DMAEN = reg;
}
 
static inline void PWM_DMACaptureSourceSelect(PWM_Type *base,
                                              pwm_submodule_t subModule,
                                              pwm_dma_source_select_t pwm_dma_source_select)
{
    uint16_t reg = base->SM[subModule].DMAEN;
 
    reg &= ~((uint16_t)PWM_DMAEN_CAPTDE_MASK);
    reg |= (((uint16_t)pwm_dma_source_select << (uint16_t)PWM_DMAEN_CAPTDE_SHIFT) & (uint16_t)PWM_DMAEN_CAPTDE_MASK);
 
    base->SM[subModule].DMAEN = reg;
}
 
static inline void PWM_EnableDMACapture(PWM_Type *base, pwm_submodule_t subModule, uint16_t mask, bool activate)
{
    uint16_t reg = base->SM[subModule].DMAEN;
    if (activate)
    {
        reg |= (uint16_t)(mask);
    }
    else
    {
        reg &= ~((uint16_t)(mask));
    }
    base->SM[subModule].DMAEN = reg;
}
 
static inline void PWM_EnableDMAWrite(PWM_Type *base, pwm_submodule_t subModule, bool activate)
{
    uint16_t reg = base->SM[subModule].DMAEN;
    if (activate)
    {
        reg |= ((uint16_t)PWM_DMAEN_VALDE_MASK);
    }
    else
    {
        reg &= ~((uint16_t)PWM_DMAEN_VALDE_MASK);
    }
    base->SM[subModule].DMAEN = reg;
}
 
uint32_t PWM_GetStatusFlags(PWM_Type *base, pwm_submodule_t subModule);
 
void PWM_ClearStatusFlags(PWM_Type *base, pwm_submodule_t subModule, uint32_t mask);
 
static inline void PWM_StartTimer(PWM_Type *base, uint8_t subModulesToStart)
{
    base->MCTRL |= PWM_MCTRL_RUN(subModulesToStart);
}
 
static inline void PWM_StopTimer(PWM_Type *base, uint8_t subModulesToStop)
{
    base->MCTRL &= ~(PWM_MCTRL_RUN(subModulesToStop));
}
 
static inline void PWM_SetVALxValue(PWM_Type *base,
                                    pwm_submodule_t subModule,
                                    pwm_value_register_t valueRegister,
                                    uint16_t value)
{
    switch (valueRegister)
    {
        case kPWM_ValueRegister_0:
            base->SM[subModule].VAL0 = value;
            break;
        case kPWM_ValueRegister_1:
            base->SM[subModule].VAL1 = value;
            break;
        case kPWM_ValueRegister_2:
            base->SM[subModule].VAL2 = value;
            break;
        case kPWM_ValueRegister_3:
            base->SM[subModule].VAL3 = value;
            break;
        case kPWM_ValueRegister_4:
            base->SM[subModule].VAL4 = value;
            break;
        case kPWM_ValueRegister_5:
            base->SM[subModule].VAL5 = value;
            break;
        default:
            assert(false);
            break;
    }
}
 
static inline uint16_t PWM_GetVALxValue(PWM_Type *base, pwm_submodule_t subModule, pwm_value_register_t valueRegister)
{
    uint16_t temp = 0U;
 
    switch (valueRegister)
    {
        case kPWM_ValueRegister_0:
            temp = base->SM[subModule].VAL0;
            break;
        case kPWM_ValueRegister_1:
            temp = base->SM[subModule].VAL1;
            break;
        case kPWM_ValueRegister_2:
            temp = base->SM[subModule].VAL2;
            break;
        case kPWM_ValueRegister_3:
            temp = base->SM[subModule].VAL3;
            break;
        case kPWM_ValueRegister_4:
            temp = base->SM[subModule].VAL4;
            break;
        case kPWM_ValueRegister_5:
            temp = base->SM[subModule].VAL5;
            break;
        default:
            assert(false);
            break;
    }
 
    return temp;
}
 
static inline void PWM_OutputTriggerEnable(PWM_Type *base,
                                           pwm_submodule_t subModule,
                                           pwm_value_register_t valueRegister,
                                           bool activate)
{
    if (activate)
    {
        base->SM[subModule].TCTRL |= ((uint16_t)1U << (uint16_t)valueRegister);
    }
    else
    {
        base->SM[subModule].TCTRL &= ~((uint16_t)1U << (uint16_t)valueRegister);
    }
}
 
static inline void PWM_ActivateOutputTrigger(PWM_Type *base, pwm_submodule_t subModule, uint16_t valueRegisterMask)
{
    base->SM[subModule].TCTRL |= (PWM_TCTRL_OUT_TRIG_EN_MASK & (valueRegisterMask));
}
 
static inline void PWM_DeactivateOutputTrigger(PWM_Type *base, pwm_submodule_t subModule, uint16_t valueRegisterMask)
{
    base->SM[subModule].TCTRL &= ~(PWM_TCTRL_OUT_TRIG_EN_MASK & (valueRegisterMask));
}
 
static inline void PWM_SetupSwCtrlOut(PWM_Type *base, pwm_submodule_t subModule, pwm_channels_t pwmChannel, bool value)
{
    if (value)
    {
        base->SWCOUT |=
            ((uint16_t)1U << (((uint16_t)subModule * (uint16_t)PWM_SUBMODULE_SWCONTROL_WIDTH) + (uint16_t)pwmChannel));
    }
    else
    {
        base->SWCOUT &=
            ~((uint16_t)1U << (((uint16_t)subModule * (uint16_t)PWM_SUBMODULE_SWCONTROL_WIDTH) + (uint16_t)pwmChannel));
    }
}
 
static inline void PWM_SetPwmLdok(PWM_Type *base, uint8_t subModulesToUpdate, bool value)
{
    if (value)
    {
        base->MCTRL |= PWM_MCTRL_LDOK(subModulesToUpdate);
    }
    else
    {
        base->MCTRL |= PWM_MCTRL_CLDOK(subModulesToUpdate);
    }
}
 
static inline void PWM_SetPwmFaultState(PWM_Type *base,
                                        pwm_submodule_t subModule,
                                        pwm_channels_t pwmChannel,
                                        pwm_fault_state_t faultState)
{
    uint16_t reg = base->SM[subModule].OCTRL;
    switch (pwmChannel)
    {
        case kPWM_PwmA:
            reg &= ~((uint16_t)PWM_OCTRL_PWMAFS_MASK);
            reg |= (((uint16_t)faultState << (uint16_t)PWM_OCTRL_PWMAFS_SHIFT) & (uint16_t)PWM_OCTRL_PWMAFS_MASK);
            break;
        case kPWM_PwmB:
            reg &= ~((uint16_t)PWM_OCTRL_PWMBFS_MASK);
            reg |= (((uint16_t)faultState << (uint16_t)PWM_OCTRL_PWMBFS_SHIFT) & (uint16_t)PWM_OCTRL_PWMBFS_MASK);
            break;
        case kPWM_PwmX:
            reg &= ~((uint16_t)PWM_OCTRL_PWMXFS_MASK);
            reg |= (((uint16_t)faultState << (uint16_t)PWM_OCTRL_PWMXFS_SHIFT) & (uint16_t)PWM_OCTRL_PWMXFS_MASK);
            break;
        default:
            assert(false);
            break;
    }
    base->SM[subModule].OCTRL = reg;
}
 
static inline void PWM_SetupFaultDisableMap(PWM_Type *base,
                                            pwm_submodule_t subModule,
                                            pwm_channels_t pwmChannel,
                                            pwm_fault_channels_t pwm_fault_channels,
                                            uint16_t value)
{
    uint16_t reg = base->SM[subModule].DISMAP[pwm_fault_channels];
    switch (pwmChannel)
    {
        case kPWM_PwmA:
            reg &= ~((uint16_t)PWM_DISMAP_DIS0A_MASK);
            reg |= (((uint16_t)(value) << (uint16_t)PWM_DISMAP_DIS0A_SHIFT) & (uint16_t)PWM_DISMAP_DIS0A_MASK);
            break;
        case kPWM_PwmB:
            reg &= ~((uint16_t)PWM_DISMAP_DIS0B_MASK);
            reg |= (((uint16_t)(value) << (uint16_t)PWM_DISMAP_DIS0B_SHIFT) & (uint16_t)PWM_DISMAP_DIS0B_MASK);
            break;
        case kPWM_PwmX:
            reg &= ~((uint16_t)PWM_DISMAP_DIS0X_MASK);
            reg |= (((uint16_t)(value) << (uint16_t)PWM_DISMAP_DIS0X_SHIFT) & (uint16_t)PWM_DISMAP_DIS0X_MASK);
            break;
        default:
            assert(false);
            break;
    }
    base->SM[subModule].DISMAP[pwm_fault_channels] = reg;
}
 
static inline void PWM_OutputEnable(PWM_Type *base, pwm_channels_t pwmChannel, pwm_submodule_t subModule)
{
    /* Set PWM output */
    switch (pwmChannel)
    {
        case kPWM_PwmA:
            base->OUTEN |= ((uint16_t)1U << ((uint16_t)PWM_OUTEN_PWMA_EN_SHIFT + (uint16_t)subModule));
            break;
        case kPWM_PwmB:
            base->OUTEN |= ((uint16_t)1U << ((uint16_t)PWM_OUTEN_PWMB_EN_SHIFT + (uint16_t)subModule));
            break;
        case kPWM_PwmX:
            base->OUTEN |= ((uint16_t)1U << ((uint16_t)PWM_OUTEN_PWMX_EN_SHIFT + (uint16_t)subModule));
            break;
        default:
            assert(false);
            break;
    }
}
 
static inline void PWM_OutputDisable(PWM_Type *base, pwm_channels_t pwmChannel, pwm_submodule_t subModule)
{
    switch (pwmChannel)
    {
        case kPWM_PwmA:
            base->OUTEN &= ~((uint16_t)1U << ((uint16_t)PWM_OUTEN_PWMA_EN_SHIFT + (uint16_t)subModule));
            break;
        case kPWM_PwmB:
            base->OUTEN &= ~((uint16_t)1U << ((uint16_t)PWM_OUTEN_PWMB_EN_SHIFT + (uint16_t)subModule));
            break;
        case kPWM_PwmX:
            base->OUTEN &= ~((uint16_t)1U << ((uint16_t)PWM_OUTEN_PWMX_EN_SHIFT + (uint16_t)subModule));
            break;
        default:
            assert(false);
            break;
    }
}
 
uint8_t PWM_GetPwmChannelState(PWM_Type *base, pwm_submodule_t subModule, pwm_channels_t pwmChannel);
 
status_t PWM_SetOutputToIdle(PWM_Type *base, pwm_channels_t pwmChannel, pwm_submodule_t subModule, bool idleStatus);
 
void PWM_SetClockMode(PWM_Type *base, pwm_submodule_t subModule, pwm_clock_prescale_t prescaler);
 
void PWM_SetPwmForceOutputToZero(PWM_Type *base,
                                 pwm_submodule_t subModule,
                                 pwm_channels_t pwmChannel,
                                 bool forcetozero);
 
void PWM_SetChannelOutput(PWM_Type *base,
                          pwm_submodule_t subModule,
                          pwm_channels_t pwmChannel,
                          pwm_output_state_t outputstate);
 
#if defined(__cplusplus)
}
#endif
 
#endif /* _FSL_PWM_H_ */