# 1 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 387 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c" 2
# 26 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
# 1 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h" 1
# 29 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
# 1 "../../../mcal/Gpt_ZX_K14xM/Inc/Gpt_Drvw_Types.h" 1
# 29 "../../../mcal/Gpt_ZX_K14xM/Inc/Gpt_Drvw_Types.h"
# 1 "../Generated/inc\\Gpt_Drvw_Cfg.h" 1
# 29 "../Generated/inc\\Gpt_Drvw_Cfg.h"
# 1 "../Generated/inc/Gpt_Drvw_PBcfg.h" 1
# 30 "../Generated/inc\\Gpt_Drvw_Cfg.h" 2
# 30 "../../../mcal/Gpt_ZX_K14xM/Inc/Gpt_Drvw_Types.h" 2
# 1 "../../../mcal/Gpt_ZX_K14xM/Inc/Rtc_Drv_Types.h" 1
# 29 "../../../mcal/Gpt_ZX_K14xM/Inc/Rtc_Drv_Types.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc\\Std_Types.h" 1
# 30 "../../../mcal/Base_ZX_K14xM/Inc\\Std_Types.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/Platform_Types.h" 1
# 86 "../../../mcal/Base_ZX_K14xM/Inc/Platform_Types.h"
typedef unsigned char boolean;




typedef unsigned char uint8;




typedef unsigned short uint16;




typedef unsigned int uint32;





typedef unsigned long long uint64;




typedef signed char sint8;




typedef signed short sint16;




typedef signed int sint32;





typedef signed long long sint64;




typedef unsigned long uint8_least;




typedef unsigned long uint16_least;





typedef unsigned long uint32_least;




typedef signed long sint8_least;




typedef signed long sint16_least;




typedef signed long sint32_least;




typedef float float32;





typedef double float64;




typedef void *VoidPtr;




typedef const void *ConstVoidPtr;
# 31 "../../../mcal/Base_ZX_K14xM/Inc\\Std_Types.h" 2
# 1 "../../../mcal/Base_ZX_K14xM/Inc/Compiler.h" 1
# 31 "../../../mcal/Base_ZX_K14xM/Inc/Compiler.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/Compiler_Cfg.h" 1
# 32 "../../../mcal/Base_ZX_K14xM/Inc/Compiler.h" 2
# 32 "../../../mcal/Base_ZX_K14xM/Inc\\Std_Types.h" 2
# 63 "../../../mcal/Base_ZX_K14xM/Inc\\Std_Types.h"
typedef unsigned char StatusType;
# 104 "../../../mcal/Base_ZX_K14xM/Inc\\Std_Types.h"
typedef uint8 Std_ReturnType;




typedef uint8 Std_TransformerClass;




typedef uint8 Std_TransformerForwardCode;





typedef uint8 Std_MessageTypeType;





typedef uint8 Std_MessageResultType;





typedef struct
{
    uint16 vendorID;
    uint16 moduleID;
    uint8 sw_major_version;
    uint8 sw_minor_version;
    uint8 sw_patch_version;
} Std_VersionInfoType;




typedef struct
{
    uint8 errorCode;
    Std_TransformerClass transformerClass;
} Std_TransformerError;





typedef struct
{
    Std_TransformerForwardCode errorCode;
    Std_TransformerClass transformerClass;
} Std_TransformerForward;







typedef Std_ReturnType (*Std_ExtractProtocolHeaderFieldsType)(const uint8 *buffer,
                                                              uint32 bufferLength,
                                                              Std_MessageTypeType *messageType,
                                                              Std_MessageResultType *messageResult);
# 30 "../../../mcal/Gpt_ZX_K14xM/Inc/Rtc_Drv_Types.h" 2
# 1 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h" 1
# 29 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
# 1 "../../../mcal/McalLib_ZX_K14xM/Inc/McalLib_Compiler.h" 1
# 30 "../../../mcal/McalLib_ZX_K14xM/Inc/McalLib_Compiler.h"
# 1 "../Generated/inc\\McalLib_Cfg.h" 1
# 31 "../../../mcal/McalLib_ZX_K14xM/Inc/McalLib_Compiler.h" 2
# 273 "../../../mcal/McalLib_ZX_K14xM/Inc/McalLib_Compiler.h"
static inline uint32 McalLib_ReadControlReg(void)
{
    uint32 res;

    __asm("MRS %0,CONTROL" : "=r" (res));

    return res;
}
# 290 "../../../mcal/McalLib_ZX_K14xM/Inc/McalLib_Compiler.h"
static inline uint32 McalLib_ReadIpsrReg(void)
{
    uint32 res;
    __asm("MRS %0,IPSR" : "=r" (res));
    return res;
}
# 305 "../../../mcal/McalLib_ZX_K14xM/Inc/McalLib_Compiler.h"
static inline uint32 McalLib_ReadPriMaskReg(void)
{
    uint32 res;
    __asm("MRS %0,PRIMASK" : "=r" (res));
    return res;
}
# 30 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h" 2
# 184 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
typedef enum
{
    MCALLIB_COUNTER_SOFTWARE,

    MCALLIB_COUNTER_OS,




} McalLib_CounterType;




typedef struct
{
    uint32 CounterId;
    uint32 CounterFreq;
} McalLib_ConfigType;







# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\McalLib_MemMap.h" 1
# 876 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\McalLib_MemMap.h"
#pragma clang section rodata = ".mcal_config_data"
# 211 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h" 2

extern const McalLib_ConfigType *const McalLib_PreDefinedConfigPtr[(1U)];


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\McalLib_MemMap.h" 1
# 892 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\McalLib_MemMap.h"
#pragma clang section rodata = ""
# 216 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h" 2
# 230 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
extern void Sys_SystemReset(void);


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\McalLib_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\McalLib_MemMap.h"
#pragma clang section text = ".mcal_code"
# 234 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h" 2







void McalLib_Init(void);
# 254 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
Std_ReturnType McalLib_GetCounterValue(McalLib_CounterType Counter, uint32 *Value);
# 270 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
Std_ReturnType McalLib_GetElapsedValue(McalLib_CounterType Counter, uint32 *const CounterValue,
                                       uint32 *ElapsedValue);
# 282 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
uint32 McalLib_MicroSecToTicks(McalLib_CounterType Counter, uint32 MicroSecond);
# 296 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
void McalLib_SetCounterFreq(McalLib_CounterType Counter, uint32 Freq);
# 309 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
static inline void McalLib_Assert(const uint8 *File, uint32 Line)
{
    (void)File;
    (void)Line;

    for (;;)
    {
    }
}
# 327 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h"
void McalLib_SuspendAllInterrupts(void);







void McalLib_ResumeAllInterrupts(void);


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\McalLib_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\McalLib_MemMap.h"
#pragma clang section text = ""
# 339 "../../../mcal/McalLib_ZX_K14xM/Inc\\McalLib.h" 2
# 31 "../../../mcal/Gpt_ZX_K14xM/Inc/Rtc_Drv_Types.h" 2
# 1 "../Generated/inc\\Rtc_Drv_Cfg.h" 1
# 28 "../Generated/inc\\Rtc_Drv_Cfg.h"
# 1 "../Generated/inc/Rtc_Drv_PBcfg.h" 1
# 29 "../Generated/inc\\Rtc_Drv_Cfg.h" 2
# 32 "../../../mcal/Gpt_ZX_K14xM/Inc/Rtc_Drv_Types.h" 2
# 104 "../../../mcal/Gpt_ZX_K14xM/Inc/Rtc_Drv_Types.h"
typedef void (*Rtc_Drv_CallbackType)(uint8 CallbackParam);




typedef enum
{
    RTC_DRV_SECONDS = 0U,
    RTC_DRV_32K_CLK
} Rtc_Drv_ClockOutType;




typedef enum
{
    RTC_DRV_CLK_OSC32K_INT = 0U,
    RTC_DRV_CLK_OSC32K_EXT,
    RTC_DRV_CLK_LPO32K
} Rtc_Drv_ClockSourceType;




typedef enum
{
    RTC_DRV_INT_OVERFLOW = 0U,
    RTC_DRV_INT_ALARM,
    RTC_DRV_INT_SECOND,
    RTC_DRV_INT_PERIODIC,
    RTC_DRV_INT_ALL
} Rtc_Drv_InterruptType;



typedef enum
{
    RTC_DRV_SUCCESS = 0x00U,
    RTC_DRV_ERROR = 0x01U
} Rtc_Drv_StatusType;




typedef enum
{
    RTC_DRV_SECOND_1 = 0U,
    RTC_DRV_SECOND_64,
    RTC_DRV_SECOND_32,
    RTC_DRV_SECOND_16,
    RTC_DRV_SECOND_8,
    RTC_DRV_SECOND_4,
    RTC_DRV_SECOND_2,
    RTC_DRV_SECOND_128
} Rtc_Drv_SecondIntMuxSelType;
# 175 "../../../mcal/Gpt_ZX_K14xM/Inc/Rtc_Drv_Types.h"
typedef struct
{
    Rtc_Drv_ClockSourceType ClockSource;
    Rtc_Drv_ClockOutType ClockOutSelect;
    Rtc_Drv_InterruptType ModeSelect;






    Rtc_Drv_CallbackType Callback;
    uint8 CallbackParam;
} Rtc_Drv_ConfigType;




typedef struct
{
    uint16 Year;
    uint16 Month;
    uint16 Day;
    uint16 Hour;
    uint16 Minutes;
    uint8 Seconds;
} Rtc_Drv_TimedateType;




typedef struct
{
    Rtc_Drv_TimedateType AlarmTime;
    uint32 AlarmRepetitionInterval;
    uint32 AlarmRepeatsNumber;
    boolean RepeatForever;

    boolean AlarmIntEnable;
    Rtc_Drv_CallbackType AlarmCallback;
    uint8 AlarmCallbackParams;
} Rtc_Drv_AlarmConfigType;




typedef struct
{
    Rtc_Drv_InterruptType ModeSelect;
    boolean AlarmInit;
    uint32 AlarmRepetitionInterval;
    volatile uint32 AlarmRepeatsNumber;
    boolean RepeatForever;

    boolean AlarmIntEnable;
    Rtc_Drv_CallbackType AlarmCallback;
    uint8 AlarmCallbackParams;
    volatile boolean IsAlarmMatchTimeNew;
    boolean ChannelInit;
    Rtc_Drv_CallbackType Callback;
    uint8 CallbackParam;
} Rtc_Drv_StateType;
# 31 "../../../mcal/Gpt_ZX_K14xM/Inc/Gpt_Drvw_Types.h" 2
# 1 "../../../mcal/Gpt_ZX_K14xM/Inc/Stim_Drv_Types.h" 1
# 32 "../../../mcal/Gpt_ZX_K14xM/Inc/Stim_Drv_Types.h"
# 1 "../Generated/inc\\Stim_Drv_Cfg.h" 1
# 28 "../Generated/inc\\Stim_Drv_Cfg.h"
# 1 "../Generated/inc/Stim_Drv_PBcfg.h" 1
# 29 "../Generated/inc\\Stim_Drv_Cfg.h" 2
# 33 "../../../mcal/Gpt_ZX_K14xM/Inc/Stim_Drv_Types.h" 2
# 104 "../../../mcal/Gpt_ZX_K14xM/Inc/Stim_Drv_Types.h"
typedef enum
{
    STIM_DRV_FUNCTION_CLOCK = 0U,
    STIM_DRV_BUS_CLOCK,
    STIM_DRV_OSC40M,
    STIM_DRV_LPO32K
} Stim_Drv_ClockSourceType;




typedef enum
{
    STIM_DRV_SUCCESS = 0x00U,
    STIM_DRV_ERROR = 0x01U,
    STIM_DRV_TIMEOUT = 0x03
} Stim_Drv_StatusType;




typedef enum
{
    STIM_DRV_DIV_2 = 0U,
    STIM_DRV_DIV_4,
    STIM_DRV_DIV_8,
    STIM_DRV_DIV_16,
    STIM_DRV_DIV_32,
    STIM_DRV_DIV_64,
    STIM_DRV_DIV_128,
    STIM_DRV_DIV_256,
    STIM_DRV_DIV_512,
    STIM_DRV_DIV_1024,
    STIM_DRV_DIV_2048,
    STIM_DRV_DIV_4096,
    STIM_DRV_DIV_8192,
    STIM_DRV_DIV_16384,
    STIM_DRV_DIV_32768,
    STIM_DRV_DIV_65536
} Stim_Drv_PrescalerType;
# 159 "../../../mcal/Gpt_ZX_K14xM/Inc/Stim_Drv_Types.h"
typedef void (*Stim_Drv_CallbackType)(uint8 CallbackParam);





typedef struct
{
    uint8 HwChannel;
    boolean PrescalerEnable;




    Stim_Drv_PrescalerType ClockPrescaler;
    Stim_Drv_ClockSourceType ClockSource;
    Stim_Drv_CallbackType Callback;
    uint8 CallbackParam;
} Stim_Drv_ChannelConfigType;




typedef struct
{
    boolean ChannelInit;
    Stim_Drv_CallbackType Callback;
    uint8 CallbackParam;
} Stim_Drv_StateType;




typedef struct
{
    Stim_Drv_PrescalerType ClockPrescaler;
    Stim_Drv_PrescalerType ClockAlternatePrescaler;
} Stim_Drv_ClockStateType;
# 32 "../../../mcal/Gpt_ZX_K14xM/Inc/Gpt_Drvw_Types.h" 2
# 1 "../../../mcal/Gpt_ZX_K14xM/Inc/Tim_Drv_Types.h" 1
# 32 "../../../mcal/Gpt_ZX_K14xM/Inc/Tim_Drv_Types.h"
# 1 "../Generated/inc\\Tim_Drv_Cfg.h" 1
# 28 "../Generated/inc\\Tim_Drv_Cfg.h"
# 1 "../Generated/inc/Tim_Drv_PBcfg.h" 1
# 29 "../Generated/inc\\Tim_Drv_Cfg.h" 2
# 33 "../../../mcal/Gpt_ZX_K14xM/Inc/Tim_Drv_Types.h" 2
# 100 "../../../mcal/Gpt_ZX_K14xM/Inc/Tim_Drv_Types.h"
typedef enum
{
    TIM_DRV_CLK_SOURCE_DISABLED = 0U,
    TIM_DRV_CLK_SOURCE_SYSTEM,
    TIM_DRV_CLK_SOURCE_FUNCTION,
    TIM_DRV_CLK_SOURCE_EXTERNAL
} Tim_Drv_ClockSourceType;




typedef enum
{
    TIM_DRV_CLK_DIV_1 = 0U,
    TIM_DRV_CLK_DIV_2,
    TIM_DRV_CLK_DIV_4,
    TIM_DRV_CLK_DIV_8,
    TIM_DRV_CLK_DIV_16,
    TIM_DRV_CLK_DIV_32,
    TIM_DRV_CLK_DIV_64,
    TIM_DRV_CLK_DIV_128
} Tim_Drv_PrescalerType;




typedef enum
{
    TIM_DRV_COUNTING_UP = 0U,
    TIM_DRV_COUNTING_UP_DOWN
} Tim_Drv_CountingModeType;
# 146 "../../../mcal/Gpt_ZX_K14xM/Inc/Tim_Drv_Types.h"
typedef enum
{
    TIM_DRV_IDLE = 0U,
    TIM_DRV_BUSY
} Tim_Drv_StatusType;




typedef void (*Tim_Drv_CallbackType)(uint8 CallbackParam);





typedef struct
{
    boolean FreezeBit;
    Tim_Drv_ClockSourceType ClockSource;



    Tim_Drv_PrescalerType ClockPrescaler;
    Tim_Drv_CountingModeType Mode;
} Tim_Drv_InstanceConfigType;





typedef struct
{
    uint8 HwChannel;
    Tim_Drv_ClockSourceType ClockSource;
    Tim_Drv_CallbackType Callback;
    uint8 CallbackParam;
} Tim_Drv_ChannelConfigType;




typedef struct
{
    Tim_Drv_StatusType ChannelStatus;
    Tim_Drv_CallbackType Callback;
    uint8 CallbackParam;
} Tim_Drv_ChannelStateType;




typedef struct
{
    Tim_Drv_PrescalerType ClockPrescaler;
    Tim_Drv_PrescalerType ClockAlternatePrescaler;
} Tim_Drv_InstanceStateType;
# 33 "../../../mcal/Gpt_ZX_K14xM/Inc/Gpt_Drvw_Types.h" 2
# 126 "../../../mcal/Gpt_ZX_K14xM/Inc/Gpt_Drvw_Types.h"
typedef uint8 Gpt_Drvw_PrescalerType;




typedef uint8 Gpt_Drvw_ClockSourceType;




typedef enum
{
    GPT_DRVW_TIM_MODULE= 0,
    GPT_DRVW_RTC_MODULE,
    GPT_DRVW_STIM_MODULE,
} Gpt_Drvw_ModuleType;





typedef struct
{
    const Tim_Drv_InstanceConfigType * Tim_Drv_InstanceConfig;
} Gpt_Drvw_InstanceConfigType;




typedef struct
{
    const Tim_Drv_ChannelConfigType *TimChannelConfig;
    const Rtc_Drv_ConfigType *RtcChannelConfig;
    const Stim_Drv_ChannelConfigType *StimChannelConfig;
} Gpt_Drvw_ChannelConfigType;




typedef struct
{
    Gpt_Drvw_ModuleType InstanceType;
    uint8 Instance;
    const Gpt_Drvw_InstanceConfigType InstanceConfig;
} Gpt_Drvw_HwInstanceConfigType;




typedef struct
{
    Gpt_Drvw_ModuleType InstanceType;
    uint8 Instance;
    uint8 Channel;
    const Gpt_Drvw_ChannelConfigType ChannelConfig;
} Gpt_Drvw_HwChannelConfigType;
# 198 "../../../mcal/Gpt_ZX_K14xM/Inc/Gpt_Drvw_Types.h"
typedef struct
{
    Gpt_Drvw_ModuleType InstanceType;
    uint8 Instance;
    uint8 Channel;
    Gpt_Drvw_PrescalerType Prescaler;
    Gpt_Drvw_ClockSourceType ClockSource;
} Gpt_Drvw_HwPredefChannelConfigType;





typedef struct
{
    boolean ChannelRollover;
    uint32 TargetTime;
} Gpt_Drvw_HwChannelInfoType;






typedef enum
{
    GPT_DRVW_PREDEF_TIMER_1US_16BIT = 0U,

    GPT_DRVW_PREDEF_TIMER_1US_24BIT,
    GPT_DRVW_PREDEF_TIMER_1US_32BIT,
    GPT_DRVW_PREDEF_TIMER_100US_32BIT

} Gpt_Drvw_PredefTimerType;
# 30 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h" 2
# 65 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 876 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section rodata = ".mcal_config_data"
# 66 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h" 2




extern const Gpt_Drvw_HwInstanceConfigType Gpt_Drvw_InstanceConfig[1U]; extern const Gpt_Drvw_HwChannelConfigType Gpt_Drvw_ChannelConfig[4U];


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 892 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section rodata = ""
# 74 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h" 2







# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section text = ".mcal_code"
# 82 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h" 2








void Gpt_Drvw_InitInstances(const Gpt_Drvw_HwInstanceConfigType *HwInstanceConfigPtr);
# 99 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
void Gpt_Drvw_Init(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr);
# 109 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
void Gpt_Drvw_DeInit(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr);
# 122 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
Std_ReturnType Gpt_Drvw_StartTimer(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr,
                                   uint32 Value);







void Gpt_Drvw_StopTimer(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr);
# 140 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
void Gpt_Drvw_EnableInterrupt(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr);
# 151 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
void Gpt_Drvw_DisableInterrupt(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr);
# 163 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
uint32 Gpt_Drvw_GetTimeElapsed(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr,
                               Gpt_Drvw_HwChannelInfoType *ReturnHwChannelInfoPtr);
# 175 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
void Gpt_Drvw_StartPredefTimer(const Gpt_Drvw_HwPredefChannelConfigType *HwPredefChannelConfigPtr,
                               Gpt_Drvw_PredefTimerType PrdefTimerType);
# 186 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
void Gpt_Drvw_GetPredefTimerValue
(
    const Gpt_Drvw_HwPredefChannelConfigType *HwPredefChannelConfigPtr,
    Gpt_Drvw_PredefTimerType PredefTimer, uint32 *TimeValuePtr
);







void Gpt_Drvw_StopPredefTimer(const Gpt_Drvw_HwPredefChannelConfigType *HwPredefChannelConfigPtr);
# 226 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section text = ""
# 227 "../../../mcal/Gpt_ZX_K14xM/Inc\\Gpt_Drvw.h" 2
# 27 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c" 2
# 1 "../../../mcal/Gpt_ZX_K14xM/Inc\\Rtc_Drv.h" 1
# 28 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c" 2
# 1 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h" 1
# 67 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 876 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section rodata = ".mcal_config_data"
# 68 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h" 2



extern const Stim_Drv_ChannelConfigType Stim_Drv_ChannelConfig[4U];


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 892 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section rodata = ""
# 75 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h" 2







# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section text = ".mcal_code"
# 83 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h" 2
# 92 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
uint32 Stim_Drv_GetCompareValue(uint8 Instance, uint8 Channel);
# 102 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
uint32 Stim_Drv_GetCurrentCounterValue(uint8 Instance, uint8 Channel);
# 115 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
boolean Stim_Drv_GetStatus(uint8 Instance, uint8 Channel);
# 125 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
void Stim_Drv_InitChannel(uint8 Instance, const Stim_Drv_ChannelConfigType *ConfigChannelPtr);
# 134 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
void Stim_Drv_DeInit(uint8 Instance);
# 145 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
void Stim_Drv_StartTimer(uint8 Instance, uint8 Channel, uint32 Value);
# 155 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
void Stim_Drv_StopTimer(uint8 Instance, uint8 Channel);
# 165 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
void Stim_Drv_EnableInterrupt(uint8 Instance, uint8 Channel);
# 175 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
void Stim_Drv_DisableInterrupt(uint8 Instance, uint8 Channel);
# 204 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
void Stim_Drv_StartPredefTimer(uint8 Instance, uint8 Channel, uint32 CompareValue, uint8 Prescaler,
                               uint8 ClockSource);
# 216 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h"
void Stim_Drv_StopPredefTimer(uint8 Instance, uint8 Channel);


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section text = ""
# 220 "../../../mcal/Gpt_ZX_K14xM/Inc\\Stim_Drv.h" 2
# 29 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c" 2
# 1 "../../../mcal/Gpt_ZX_K14xM/Inc\\Tim_Drv.h" 1
# 30 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c" 2
# 1 "../../../mcal/Rte_ZX_K14xM/Inc\\SchM_Gpt.h" 1
# 58 "../../../mcal/Rte_ZX_K14xM/Inc\\SchM_Gpt.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Rte_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Rte_MemMap.h"
#pragma clang section text = ".mcal_code"
# 59 "../../../mcal/Rte_ZX_K14xM/Inc\\SchM_Gpt.h" 2

extern void SchM_Enter_Gpt_TimGetValue(void);
extern void SchM_Exit_Gpt_TimGetValue(void);

extern void SchM_Enter_Gpt_TimBaseReg(void);
extern void SchM_Exit_Gpt_TimBaseReg(void);

extern void SchM_Enter_Gpt_TimEnableOutputCompare(void);
extern void SchM_Exit_Gpt_TimEnableOutputCompare(void);

extern void SchM_Enter_Gpt_TimChannelConfigurationReg(void);
extern void SchM_Exit_Gpt_TimChannelConfigurationReg(void);

extern void SchM_Enter_Gpt_StimControlAndStatusReg(void);
extern void SchM_Exit_Gpt_StimControlAndStatusReg(void);

extern void SchM_Enter_Gpt_RtcEnableInt(void);
extern void SchM_Exit_Gpt_RtcEnableInt(void);

extern void SchM_Enter_Gpt_RtcClearIntStatus(void);
extern void SchM_Exit_Gpt_RtcClearIntStatus(void);

extern void SchM_Enter_Gpt_RtcEnableCounter(void);
extern void SchM_Exit_Gpt_RtcEnableCounter(void);

extern void SchM_Enter_Gpt_RtcSelectClockOut(void);
extern void SchM_Exit_Gpt_RtcSelectClockOut(void);

extern void SchM_Enter_Gpt_RtcSetCompDelayValue(void);
extern void SchM_Exit_Gpt_RtcSetCompDelayValue(void);

extern void SchM_Enter_Gpt_RtcSetCompensationValue(void);
extern void SchM_Exit_Gpt_RtcSetCompensationValue(void);

extern void SchM_Enter_Gpt_RtcSetCompDirection(void);
extern void SchM_Exit_Gpt_RtcSetCompDirection(void);

extern void SchM_Enter_Gpt_RtcConfigSecondIntMux(void);
extern void SchM_Exit_Gpt_RtcConfigSecondIntMux(void);


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Rte_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Rte_MemMap.h"
#pragma clang section text = ""
# 101 "../../../mcal/Rte_ZX_K14xM/Inc\\SchM_Gpt.h" 2
# 31 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c" 2
# 97 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section text = ".mcal_code"
# 98 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c" 2
# 109 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
static inline uint32
Gpt_Drvw_StimGetTimeElapsed(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr,
                            Gpt_Drvw_HwChannelInfoType *ReturnHwChannelInfoPtr);
# 132 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
static inline uint32
Gpt_Drvw_StimGetTimeElapsed(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr,
                            Gpt_Drvw_HwChannelInfoType *ReturnHwChannelInfoPtr)
{
    uint32 ReturnValue = 0U;

    ReturnHwChannelInfoPtr->TargetTime =
        Stim_Drv_GetCompareValue(HwChannelConfigPtr->Instance, HwChannelConfigPtr->Channel);

    ReturnValue =
        Stim_Drv_GetCurrentCounterValue(HwChannelConfigPtr->Instance, HwChannelConfigPtr->Channel);

    if (1U == Stim_Drv_GetStatus(HwChannelConfigPtr->Instance, HwChannelConfigPtr->Channel))
    {
        ReturnHwChannelInfoPtr->ChannelRollover = 1U;
    }
    else
    {
        ReturnHwChannelInfoPtr->ChannelRollover = 0U;
    }

    return ((uint32)ReturnValue);
}
# 307 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_InitInstances(const Gpt_Drvw_HwInstanceConfigType *HwInstanceConfigPtr)
{

    if (GPT_DRVW_TIM_MODULE == HwInstanceConfigPtr->InstanceType)
    {




    }
    else
    {

    }
    return;
}
# 331 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_Init(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr)
{

    if (GPT_DRVW_TIM_MODULE == HwChannelConfigPtr->InstanceType)
    {




    }
    else if (GPT_DRVW_RTC_MODULE == HwChannelConfigPtr->InstanceType)
    {




    }
    else if (GPT_DRVW_STIM_MODULE == HwChannelConfigPtr->InstanceType)
    {

        Stim_Drv_InitChannel(HwChannelConfigPtr->Instance,
                             HwChannelConfigPtr->ChannelConfig.StimChannelConfig);

    }
    else
    {

    }
}
# 369 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_DeInit(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr)
{
    if (GPT_DRVW_TIM_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
    else if (GPT_DRVW_RTC_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
    else if (GPT_DRVW_STIM_MODULE == HwChannelConfigPtr->InstanceType)
    {

        Stim_Drv_DeInit(HwChannelConfigPtr->Instance);

    }
    else
    {

    }
    return;
}
# 406 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
uint32 Gpt_Drvw_GetTimeElapsed(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr,
                               Gpt_Drvw_HwChannelInfoType *ReturnHwChannelInfoPtr)
{
    uint32 ReturnValue = 0U;

    if (GPT_DRVW_TIM_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
    else if (GPT_DRVW_RTC_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
    else if (GPT_DRVW_STIM_MODULE == HwChannelConfigPtr->InstanceType)
    {

        ReturnValue = Gpt_Drvw_StimGetTimeElapsed(HwChannelConfigPtr, ReturnHwChannelInfoPtr);

    }
    else
    {

    }
    return ReturnValue;
}
# 446 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
Std_ReturnType Gpt_Drvw_StartTimer(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr,
                                   uint32 Value)
{

    Std_ReturnType ReturnValue = (Std_ReturnType)0x01U;

    if (GPT_DRVW_TIM_MODULE == HwChannelConfigPtr->InstanceType)
    {





    }
    else if (GPT_DRVW_RTC_MODULE == HwChannelConfigPtr->InstanceType)
    {




    }
    else if (GPT_DRVW_STIM_MODULE == HwChannelConfigPtr->InstanceType)
    {

        Stim_Drv_StartTimer(HwChannelConfigPtr->Instance, HwChannelConfigPtr->Channel, Value);
        ReturnValue = (Std_ReturnType)0x00U;

    }
    else
    {

    }

    return ReturnValue;
}
# 489 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_StopTimer(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr)
{
    if (GPT_DRVW_TIM_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
    else if (GPT_DRVW_RTC_MODULE == HwChannelConfigPtr->InstanceType)
    {




    }
    else if (GPT_DRVW_STIM_MODULE == HwChannelConfigPtr->InstanceType)
    {

        Stim_Drv_StopTimer(HwChannelConfigPtr->Instance, HwChannelConfigPtr->Channel);

    }
    else
    {

    }
}
# 523 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_EnableInterrupt(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr)
{
    if (GPT_DRVW_TIM_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
    else if (GPT_DRVW_RTC_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
    else if (GPT_DRVW_STIM_MODULE == HwChannelConfigPtr->InstanceType)
    {

        Stim_Drv_EnableInterrupt(HwChannelConfigPtr->Instance, HwChannelConfigPtr->Channel);

    }
    else
    {

    }
    return;
}
# 559 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_DisableInterrupt(const Gpt_Drvw_HwChannelConfigType *HwChannelConfigPtr)
{
    if (GPT_DRVW_TIM_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
else if (GPT_DRVW_RTC_MODULE == HwChannelConfigPtr->InstanceType)
    {



    }
else if (GPT_DRVW_STIM_MODULE == HwChannelConfigPtr->InstanceType)
    {

        Stim_Drv_DisableInterrupt(HwChannelConfigPtr->Instance, HwChannelConfigPtr->Channel);

    }
    else
    {

    }
}
# 660 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_StartPredefTimer(const Gpt_Drvw_HwPredefChannelConfigType *HwPredefChannelConfigPtr,
                               Gpt_Drvw_PredefTimerType PrdefTimerType)
{
    if (((void *)0) != HwPredefChannelConfigPtr)
    {
        switch (HwPredefChannelConfigPtr->InstanceType)
        {
            case GPT_DRVW_STIM_MODULE:

                switch (PrdefTimerType)
                {
                    case GPT_DRVW_PREDEF_TIMER_1US_16BIT:
                        Stim_Drv_StartPredefTimer(HwPredefChannelConfigPtr->Instance,
                                                  HwPredefChannelConfigPtr->Channel, 0xFFFFU,
                                                  HwPredefChannelConfigPtr->Prescaler,
                                                  HwPredefChannelConfigPtr->ClockSource);
                        break;
                    case GPT_DRVW_PREDEF_TIMER_1US_24BIT:
                        Stim_Drv_StartPredefTimer(HwPredefChannelConfigPtr->Instance,
                                                  HwPredefChannelConfigPtr->Channel, 0xFFFFFFU,
                                                  HwPredefChannelConfigPtr->Prescaler,
                                                  HwPredefChannelConfigPtr->ClockSource);
                        break;
                    case GPT_DRVW_PREDEF_TIMER_1US_32BIT:
                        Stim_Drv_StartPredefTimer(HwPredefChannelConfigPtr->Instance,
                                                  HwPredefChannelConfigPtr->Channel, 0xFFFFFFFFU,
                                                  HwPredefChannelConfigPtr->Prescaler,
                                                  HwPredefChannelConfigPtr->ClockSource);
                        break;
                    case GPT_DRVW_PREDEF_TIMER_100US_32BIT:

                        break;
                    default:

                        break;
                }

                break;
            default:

                break;
        }
    }
}
# 713 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_GetPredefTimerValue
(
    const Gpt_Drvw_HwPredefChannelConfigType *HwPredefChannelConfigPtr,
    Gpt_Drvw_PredefTimerType PredefTimer, uint32 *TimeValuePtr
)
{
    uint32 ReturnValue = 0U;
    switch (HwPredefChannelConfigPtr->InstanceType)
    {
        case GPT_DRVW_STIM_MODULE:

            ReturnValue = Stim_Drv_GetCurrentCounterValue(HwPredefChannelConfigPtr->Instance,
                                                          HwPredefChannelConfigPtr->Channel);

            break;
        default:

            break;
    }
    switch (PredefTimer)
    {
        case GPT_DRVW_PREDEF_TIMER_1US_16BIT:
            *TimeValuePtr = (0x0000FFFFU & ReturnValue);
            break;
        case GPT_DRVW_PREDEF_TIMER_1US_24BIT:
            *TimeValuePtr = (0x00FFFFFFU & ReturnValue);
            break;
        case GPT_DRVW_PREDEF_TIMER_1US_32BIT:
            *TimeValuePtr = ReturnValue;
            break;
        case GPT_DRVW_PREDEF_TIMER_100US_32BIT:
            *TimeValuePtr = ReturnValue;
            break;
        default:

            break;
    }
}
# 759 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c"
void Gpt_Drvw_StopPredefTimer(const Gpt_Drvw_HwPredefChannelConfigType *HwPredefChannelConfigPtr)
{
    if (((void *)0) != HwPredefChannelConfigPtr)
    {
        switch (HwPredefChannelConfigPtr->InstanceType)
        {
            case GPT_DRVW_STIM_MODULE:

                Stim_Drv_StopPredefTimer(HwPredefChannelConfigPtr->Instance,
                                         HwPredefChannelConfigPtr->Channel);

                break;
            default:

                break;
        }
    }
    return;
}



# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Gpt_MemMap.h"
#pragma clang section text = ""
# 782 "../../../mcal/Gpt_ZX_K14xM/Src/Gpt_Drvw.c" 2