nxp-enums-struct.h

/*
   Copyright (c) 2015, Freescale Semiconductor, Inc.
   Copyright 2016-2022 NXP
   All rights reserved.
 
   SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
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;
 // end of nxp_enums
 
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 debugModeEnabled; 
  #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;
 // end of nxp