# 1 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 387 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2
# 26 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
# 1 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h" 1
# 29 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
# 1 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Types.h" 1
# 29 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Types.h"
# 1 "../Generated/inc\\Fls_Cfg.h" 1
# 30 "../Generated/inc\\Fls_Cfg.h"
# 1 "../Generated/inc/Fls_PBcfg.h" 1
# 31 "../Generated/inc\\Fls_Cfg.h" 2
# 30 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Types.h" 2
# 1 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Drvw_Types.h" 1
# 29 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Drvw_Types.h"
# 1 "../Generated/inc\\Fls_Drvw_Cfg.h" 1
# 30 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Drvw_Types.h" 2
# 1 "../../../mcal/Fls_ZX_K14xM/Inc/Flash_Drv_Types.h" 1
# 29 "../../../mcal/Fls_ZX_K14xM/Inc/Flash_Drv_Types.h"
# 1 "../Generated/inc\\Flash_Drv_Cfg.h" 1
# 30 "../../../mcal/Fls_ZX_K14xM/Inc/Flash_Drv_Types.h" 2
# 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);
# 31 "../../../mcal/Fls_ZX_K14xM/Inc/Flash_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
# 32 "../../../mcal/Fls_ZX_K14xM/Inc/Flash_Drv_Types.h" 2
# 1 "../../../mcal/MemIf_ZX_K14xM/Inc\\MemIf.h" 1
# 46 "../../../mcal/MemIf_ZX_K14xM/Inc\\MemIf.h"
typedef enum
{
    MEMIF_UNINIT = 0U,
    MEMIF_IDLE,
    MEMIF_BUSY,
    MEMIF_BUSY_INTERNAL

}MemIf_StatusType;

typedef enum
{
    MEMIF_JOB_OK = 0U,
    MEMIF_JOB_FAILED,
    MEMIF_JOB_PENDING,
    MEMIF_JOB_CANCELED,
    MEMIF_BLOCK_INCONSISTENT,
    MEMIF_BLOCK_INVALID
}MemIf_JobResultType;

typedef enum
{
    MEMIF_MODE_SLOW = 0U,
    MEMIF_MODE_FAST
}MemIf_ModeType;
# 33 "../../../mcal/Fls_ZX_K14xM/Inc/Flash_Drv_Types.h" 2
# 87 "../../../mcal/Fls_ZX_K14xM/Inc/Flash_Drv_Types.h"
typedef void (*Flash_Drv_StartAccessNotifType)(void);




typedef void (*Flash_Drv_FinishAccessNotifType)(void);




typedef void (*Flash_Drv_AcPtrType)(void (*CallBack)(void));




typedef void (*Flash_Drv_CallBackType)(void);




typedef enum
{
    FLASH_DRV_SUCCESS = 0U,
    FLASH_DRV_BUSY = 1U,
    FLASH_DRV_CMD_ABORTED = 2U,
    FLASH_DRV_ERR = 3U,
    FLASH_DRV_ERR_TIMEOUT = 4U,
    FLASH_DRV_ERR_INPUT_PARAM = 5U,
    FLASH_DRV_ERR_BLANK_CHECK = 6U,
    FLASH_DRV_ERR_COMPARE = 7U,

    FLASH_DRV_ERR_ECC_S = 8U,
    FLASH_DRV_ERR_ECC_M = 9U,
    FLASH_DRV_ERR_HW_FAIL = 10U,
} Flash_Drv_ReturnType;




typedef enum
{
    FLASH_DRV_STATUS_FAIL = 0x00000001U,

    FLASH_DRV_STATUS_CMDABT = 0x00000004U,
    FLASH_DRV_STATUS_ACCERR = 0x00000020U,
    FLASH_DRV_STATUS_PREABT = 0x00000040U,


    FLASH_DRV_STATUS_CCIF = 0x00000080U,
    FLASH_DRV_STATUS_CMDWRF = 0x00000800U,



    FLASH_DRV_STATUS_DFDIF = 0x00010000U,

    FLASH_DRV_STATUS_SFDIF = 0x00020000U,

    FLASH_DRV_STATUS_DBG_ERSALL_DIS = 0x40000000U
}Flash_Drv_StatusType;




typedef enum
{
    FLASH_DRV_READ_IDLE = 0U,
    FLASH_DRV_READ_BUSY = 1U,
    FLASH_DRV_READ_ERROR = 2U,
} Flash_Drv_ReadStatusType;




typedef struct
{
    Flash_Drv_ReadStatusType Status;
    uint32 Address;
} Flash_Drv_ReadStateType;





typedef struct
{
    Flash_Drv_StartAccessNotifType StartNotifPtr;

    Flash_Drv_FinishAccessNotifType FinishNotifPtr;

    uint32 IgnoreBusErrStartAddr;




    uint32 IgnoreBusErrEndAddr;





} Flash_Drv_ConfigType;




typedef struct
{
    boolean AsyncFlag;


    Flash_Drv_CallBackType CallBack;







    Flash_Drv_AcPtrType AcFunc;


} Flash_Drv_CmdActionType;
# 31 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Drvw_Types.h" 2
# 86 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Drvw_Types.h"
typedef enum
{
 FLS_DRVW_JOB_ERASE = 0U,
 FLS_DRVW_JOB_WRITE,
 FLS_DRVW_JOB_READ,
 FLS_DRVW_JOB_COMPARE,

 FLS_DRVW_JOB_BLANK_CHECK

} Fls_Drvw_JobType;




typedef uint32 Fls_Drvw_AddrType;




typedef uint32 Fls_Drvw_LenType;




typedef void (*Fls_Drvw_AcPtrType)(void (*CallBack)(void));




typedef void (*Fls_Drvw_AcCallbackPtrType)(void);




typedef Flash_Drv_ConfigType Fls_Drvw_TempConfigType;




typedef struct
{
    Fls_Drvw_AcPtrType AcErasePtr;
 Fls_Drvw_AcPtrType AcWritePtr;
 Fls_Drvw_AcCallbackPtrType AcCallbackPtr;
 const Fls_Drvw_TempConfigType * DriverConfigSetPtr;

} Fls_Drvw_ConfigType;
# 31 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Types.h" 2
# 85 "../../../mcal/Fls_ZX_K14xM/Inc/Fls_Types.h"
typedef enum
{
    FLS_JOB_ERASE = 0U,
    FLS_JOB_WRITE,
    FLS_JOB_READ,
    FLS_JOB_COMPARE,

    FLS_JOB_BLANK_CHECK

} Fls_JobType;






typedef Fls_Drvw_AddrType Fls_AddressType;





typedef Fls_Drvw_LenType Fls_LengthType;




typedef uint32 Fls_SectorIndexType;





typedef void (*Fls_NotificationPtrType)(void);




typedef Fls_Drvw_ConfigType Fls_TempConfigType;




typedef void (*Fls_AcCallbackPtrType)(void);




typedef void (*Fls_AcPtrType)(void (*CallBack)(void));




typedef struct
{
    Fls_LengthType SectorSize;
    Fls_LengthType PageSize;
    Fls_AddressType EndAddr;
    Fls_AddressType PhysicalStartAddr;

    boolean EraseAsyncFlag;

    boolean WriteAsyncFlag;


} Fls_SectorConfigType;





typedef struct
{
    Fls_NotificationPtrType JobEndNotificationPtr;

    Fls_NotificationPtrType JobErrorNotificationPtr;

    MemIf_ModeType DefaultMode;

    Fls_LengthType MaxReadFastMode;

    Fls_LengthType MaxReadNormalMode;

    Fls_LengthType MaxWriteFastMode;

    Fls_LengthType MaxWriteNormalMode;

    uint32 SectorNum;
    const Fls_SectorConfigType * const *SectorList;
 const Fls_TempConfigType * WrapperConfigSetPtr;

} Fls_ConfigType;




typedef struct
{
    Fls_JobType Job;
    MemIf_JobResultType JobResult;
    Fls_SectorIndexType SectorCur;
    Fls_SectorIndexType SectorEnd;
    Fls_AddressType AddrCur;
    Fls_AddressType AddrEnd;
    const uint8 * DataSrcPtr;
    uint8 * DataDestPtr;
    boolean AsyncExecutingFlag;
} Fls_JobParamType;
# 30 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h" 2
# 120 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 876 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section rodata = ".mcal_config_data"
# 121 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h" 2
extern const Fls_ConfigType * const Fls_PreDefinedConfigPtr;

# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 892 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section rodata = ""
# 124 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h" 2
# 140 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1100 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ".mcal_code"
# 141 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h" 2








void Fls_Init(const Fls_ConfigType* ConfigPtr);
# 163 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length);
# 177 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
Std_ReturnType Fls_Write(Fls_AddressType TargetAddress, const uint8* SourceAddressPtr,
                         Fls_LengthType Length );
# 189 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
void Fls_Cancel(void);
# 204 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
MemIf_StatusType Fls_GetStatus(void);
# 224 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
MemIf_JobResultType Fls_GetJobResult(void);
# 238 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
Std_ReturnType Fls_Read(Fls_AddressType SourceAddress, uint8* TargetAddressPtr,
                        Fls_LengthType Length);
# 255 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
Std_ReturnType Fls_Compare(Fls_AddressType SourceAddress, const uint8* TargetAddressPtr,
                           Fls_LengthType Length );
# 269 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
void Fls_SetMode(MemIf_ModeType Mode);
# 299 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
Std_ReturnType Fls_BlankCheck(Fls_AddressType TargetAddress, Fls_LengthType Length);
# 310 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h"
void Fls_MainFunction(void);





# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1116 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ""
# 317 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls.h" 2
# 27 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2
# 1 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h" 1
# 31 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
# 1 "../../../mcal/Platform_ZX_K14xM/StartUp/Inc\\System.h" 1
# 72 "../../../mcal/Platform_ZX_K14xM/StartUp/Inc\\System.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Platform_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Platform_MemMap.h"
#pragma clang section text = ".mcal_code"
# 73 "../../../mcal/Platform_ZX_K14xM/StartUp/Inc\\System.h" 2
# 96 "../../../mcal/Platform_ZX_K14xM/StartUp/Inc\\System.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Platform_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Platform_MemMap.h"
#pragma clang section text = ""
# 97 "../../../mcal/Platform_ZX_K14xM/StartUp/Inc\\System.h" 2
# 32 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h" 2
# 80 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
typedef enum
{
    FLS_DRVW_E_OK = 0U,
    FLS_DRVW_E_FAILED,

    FLS_DRVW_E_BLANK_CHECK,
    FLS_DRVW_E_COMPARE,
    FLS_DRVW_E_PENDING,
    FLS_DRVW_E_TIMEOUT,
    FLS_DRVW_E_BUSY,
    FLS_DRVW_E_HW_FAIL,
    FLS_DRVW_E_CMD_ABORTED,
    FLS_DRVW_E_PARAM_DATA,
} Fls_Drvw_ResultType;






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1016 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section rodata = ".mcal_const"
# 101 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h" 2

extern const uint32 (Image$$ER_IROM3$$Base);
extern const uint32 (Image$$ER_IROM3$$Length);

extern const uint32 (Image$$ER_IROM3$$Base);
extern const uint32 (Image$$ER_IROM3$$Length);

# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1032 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section rodata = ""
# 109 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h" 2


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 904 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section rodata = ".mcal_config_data"
# 112 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h" 2
extern const Fls_Drvw_ConfigType Fls_DrvwConfig;

# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 920 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section rodata = ""
# 115 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1100 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ".mcal_code"
# 122 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h" 2
# 134 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_Init(const Fls_Drvw_ConfigType * ConfigPtr);
# 148 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_Cancel(Fls_Drvw_JobType Job);
# 166 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_HandleAsyncEraseJob(Fls_Drvw_AddrType PhyAddr,
                                                 Fls_Drvw_LenType Length);
# 184 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_HandleAsyncWriteJob(Fls_Drvw_AddrType PhyAddr,
                                                 const uint8 * DataSrcPtr,
                                                 Fls_Drvw_LenType Length);
# 200 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_ReadSector(Fls_Drvw_AddrType PhyAddr,
                                        const Fls_Drvw_LenType Len,
                                        uint8 const * DataDestPtr);
# 218 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_CompareSector(Fls_Drvw_AddrType PhyAddr,
                                           const Fls_Drvw_LenType Len,
                                           const uint8 * DataSrcPtr);
# 236 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_BlankCheckSector(Fls_Drvw_AddrType PhyAddr,
                                              const Fls_Drvw_LenType Len);
# 255 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_EraseSector(Fls_Drvw_AddrType PhyAddr, const boolean AsyncFlag);
# 275 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h"
Fls_Drvw_ResultType Fls_Drvw_WriteSector(Fls_Drvw_AddrType PhyAddr,
                                                  Fls_Drvw_LenType Len,
                                                  const uint8 * DataSrcPtr,
                                                  const boolean AsyncFlag);


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1116 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ""
# 282 "../../../mcal/Fls_ZX_K14xM/Inc\\Fls_Drvw.h" 2
# 28 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2
# 1 "../../../mcal/Det_ZX_K14xM/Inc\\Det.h" 1
# 61 "../../../mcal/Det_ZX_K14xM/Inc\\Det.h"
void Det_Init(void);

Std_ReturnType Det_ReportError(uint16 ModuleId, uint8 InstanceId, uint8 ApiId, uint8 ErrorId);

Std_ReturnType Det_ReportRuntimeError(uint16 ModuleId, uint8 InstanceId, uint8 ApiId,
                                      uint8 ErrorId);

Std_ReturnType Det_ReportTransientFault(uint16 ModuleId, uint8 InstanceId, uint8 ApiId,
                                        uint8 FaultId);

void Det_Start(void);
# 29 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2
# 95 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1492 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section bss = ".mcal_bss"
# 96 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2



static Fls_JobParamType Fls_Job;

# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1508 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section bss = ""
# 102 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1464 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section bss = ".mcal_bss"
# 105 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2



static const Fls_ConfigType * Fls_ConfigPtr;

# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1480 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section bss = ""
# 111 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1436 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section bss = ".mcal_bss"
# 118 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2



static Fls_LengthType Fls_MaxRead;



static Fls_LengthType Fls_MaxWrite;

# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1452 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section bss = ""
# 128 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1100 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ".mcal_code"
# 135 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2

static Fls_AddressType Fls_GetLogicStartAddr(const uint32 SectorIndex);
static Fls_AddressType Fls_ConvertJobLogicAddrToPhyAddr(void);
static Fls_SectorIndexType Fls_GetSectorIndex(const Fls_AddressType TargetAddr);

static boolean Fls_CheckAddrAlignedSectorStart(const Fls_AddressType TargetAddr);
static boolean Fls_CheckAddrAlignedSectorEnd(const Fls_AddressType TargetAddr);
static boolean Fls_CheckAddrAlignedPageStart(const Fls_AddressType TargetAddr);
static boolean Fls_CheckAddrAlignedPageEnd(const Fls_AddressType TargetAddr);

static Fls_AddressType Fls_ObtainRWEndAddr(const Fls_LengthType MaxTransferSize);
static Fls_LengthType Fls_ObtainWriteLength(const Fls_AddressType MaxWriteEndAddr);
static Fls_LengthType Fls_ObtainReadLength(const Fls_AddressType MaxReadEndAddr);
static void Fls_HandleEraseFault(Fls_Drvw_ResultType EraseJobRes);
static MemIf_JobResultType Fls_ProcessJobErase(void);
static void Fls_HandleWriteFault(Fls_Drvw_ResultType WriteJobRes);
static MemIf_JobResultType Fls_ProcessJobWrite(void);
static Fls_Drvw_ResultType Fls_DoJobRead(Fls_LengthType Len);
static MemIf_JobResultType Fls_HandleReadFault(Fls_Drvw_ResultType ReadJobRes);
static MemIf_JobResultType Fls_ProcessJobRead(void);
static MemIf_JobResultType Fls_ProcessJobs(void);
static MemIf_JobResultType Fls_HandleAsyncEraseJob(void);
static MemIf_JobResultType Fls_HandleAsyncWriteJob(void);
static MemIf_JobResultType Fls_HandleAsyncJob(void);
static void Fls_CheckJobResult(MemIf_JobResultType Result);

# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1116 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ""
# 162 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1100 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ".mcal_code"
# 169 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2








static Fls_AddressType Fls_GetLogicStartAddr(const uint32 SectorIndex)
{
    Fls_AddressType Address = 0U;

    if (0U != SectorIndex)
    {
        Address = (Fls_ConfigPtr->SectorList)[SectorIndex - 1U]->EndAddr + 1U;
    }
    else
    {
        Address = 0U;
    }

    return Address;
}
# 200 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static Fls_AddressType Fls_ConvertJobLogicAddrToPhyAddr(void)
{
    Fls_AddressType SectorLogicStartAddr;
    Fls_AddressType SectorPhyStartAddr;


    SectorLogicStartAddr = Fls_GetLogicStartAddr(Fls_Job.SectorCur);

    SectorPhyStartAddr = ((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->PhysicalStartAddr;

    return (Fls_Job.AddrCur - SectorLogicStartAddr + SectorPhyStartAddr);
}
# 221 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static Fls_SectorIndexType Fls_GetSectorIndex(const Fls_AddressType TargetAddr)
{
    Fls_SectorIndexType SectorIndex = 0U;

    for (SectorIndex = 0U; SectorIndex < Fls_ConfigPtr->SectorNum; SectorIndex++)
    {
        if(TargetAddr <= (((Fls_ConfigPtr->SectorList)[SectorIndex])->EndAddr))
        {
           break;
        }
    }

    return SectorIndex;
}
# 244 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline uint32 Fls_GetFlashEndAddr(void)
{
    return ((Fls_ConfigPtr->SectorList)[Fls_ConfigPtr->SectorNum - 1U]->EndAddr);
}
# 258 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static boolean Fls_CheckAddrAlignedSectorStart(const Fls_AddressType TargetAddr)
{
    boolean RetVal = (boolean)0U;
    Fls_SectorIndexType SecIndex;
    Fls_LengthType SectorSize;
    Fls_AddressType StartAddr;

    if (TargetAddr <= Fls_GetFlashEndAddr())
    {
        SecIndex = Fls_GetSectorIndex(TargetAddr);
        SectorSize = (Fls_ConfigPtr->SectorList)[SecIndex]->SectorSize;
        StartAddr = Fls_GetLogicStartAddr(SecIndex);
        if(SectorSize != 0U)
        {
            if(0U == ((TargetAddr - StartAddr) % SectorSize))
            {
                RetVal = (boolean)1U;
            }
        }
    }

    return RetVal;
}
# 291 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static boolean Fls_CheckAddrAlignedSectorEnd(const Fls_AddressType TargetAddr)
{
    boolean RetVal = (boolean)0U;
    Fls_SectorIndexType SecIndex;
    Fls_LengthType SecSize;
    Fls_AddressType StartAddr;

    if (TargetAddr <= Fls_GetFlashEndAddr())
    {
        SecIndex = Fls_GetSectorIndex(TargetAddr);
        SecSize = (Fls_ConfigPtr->SectorList)[SecIndex]->SectorSize;
        StartAddr = Fls_GetLogicStartAddr(SecIndex);
        if(SecSize != 0U)
        {
            if(0U == ((TargetAddr + 1U - StartAddr) % SecSize))
            {
                RetVal = (boolean)1U;
            }
        }
    }

    return RetVal;
}
# 324 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static boolean Fls_CheckAddrAlignedPageStart(const Fls_AddressType TargetAddr)
{
    boolean RetVal = (boolean)0U;
    Fls_SectorIndexType SecIndex;
    Fls_LengthType PageSize;
    Fls_AddressType StartAddr;

    if (TargetAddr <= Fls_GetFlashEndAddr())
    {
        SecIndex = Fls_GetSectorIndex(TargetAddr);
        StartAddr = Fls_GetLogicStartAddr(SecIndex);
        PageSize = (Fls_ConfigPtr->SectorList)[SecIndex]->PageSize;
        if(PageSize != 0U)
        {
            if(0U == ((TargetAddr - StartAddr) % PageSize))
            {
                RetVal = (boolean)1U;
            }
        }
    }

    return RetVal;
}
# 357 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static boolean Fls_CheckAddrAlignedPageEnd(const Fls_AddressType TargetAddr)
{
    boolean RetVal = (boolean)0U;
    Fls_SectorIndexType SecIndex;
    Fls_LengthType PageSize;
    Fls_AddressType StartAddr;

    if (TargetAddr <= Fls_GetFlashEndAddr())
    {
        SecIndex = Fls_GetSectorIndex(TargetAddr);
        PageSize = (Fls_ConfigPtr->SectorList)[SecIndex]->PageSize;
        StartAddr = Fls_GetLogicStartAddr(SecIndex);
        if(PageSize != 0U)
        {
            if(0U == ((TargetAddr + 1U - StartAddr) % PageSize))
            {
                RetVal = (boolean)1U;
            }
        }
    }

    return RetVal;
}
# 389 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static Fls_AddressType Fls_ObtainRWEndAddr(const Fls_LengthType MaxTransferSize)
{
    Fls_AddressType TransferEndAddr = Fls_Job.AddrCur + MaxTransferSize - 1U;

    if(Fls_Job.AddrEnd < TransferEndAddr)
    {
        TransferEndAddr = Fls_Job.AddrEnd;
    }

    return TransferEndAddr;
}
# 409 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static Fls_LengthType Fls_ObtainWriteLength(const Fls_AddressType MaxWriteEndAddr)
{
    boolean AsyncFlag =((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->WriteAsyncFlag;
    Fls_LengthType PageSize = ((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->PageSize;
    Fls_AddressType SectorEndAddr = ((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->EndAddr;
    Fls_LengthType WriteLen = (MaxWriteEndAddr < SectorEndAddr) ? (MaxWriteEndAddr - Fls_Job.AddrCur
                               + 1U):(SectorEndAddr - Fls_Job.AddrCur + 1U);

    if(AsyncFlag == 1U)
    {

        WriteLen = (WriteLen > PageSize) ? PageSize : WriteLen;
    }

    return WriteLen;
}
# 434 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static Fls_LengthType Fls_ObtainReadLength(const Fls_AddressType MaxReadEndAddr)
{
    Fls_AddressType SectorEndAddr = ((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->EndAddr;
    Fls_LengthType ReadLen = (MaxReadEndAddr < SectorEndAddr) ? (MaxReadEndAddr - Fls_Job.AddrCur
                              + 1U):(SectorEndAddr - Fls_Job.AddrCur + 1U);

    return ReadLen;
}
# 450 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static void Fls_HandleEraseFault(Fls_Drvw_ResultType EraseJobRes)
{
    (void)Det_ReportTransientFault((uint16)92U, (0U),
                                0x0BU, 0x01U);

 if (FLS_DRVW_E_BLANK_CHECK == EraseJobRes)
 {
  (void)Det_ReportRuntimeError((uint16)92U, (0U),
                             0x0BU, 0x07U);
 }
 else if (FLS_DRVW_E_TIMEOUT == EraseJobRes)
 {
  (void)Det_ReportRuntimeError((uint16)92U, (0U),
                             0x0BU, 0x09U);
 }
 else
 {

 }
}
# 482 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static MemIf_JobResultType Fls_ProcessJobErase(void)
{
    MemIf_JobResultType Res = MEMIF_JOB_PENDING;
    boolean AsyncFlag;
    Fls_LengthType PhysicalSectorSize;
    Fls_Drvw_ResultType LowLevelRes;
 Fls_AddressType PhyAddr = Fls_ConvertJobLogicAddrToPhyAddr();

    if(Fls_Job.AddrCur > Fls_Job.AddrEnd)
    {
        Res = MEMIF_JOB_OK;
    }
    else
    {
        AsyncFlag = (Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur]->EraseAsyncFlag;

        PhysicalSectorSize = ((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->SectorSize;

        LowLevelRes = Fls_Drvw_EraseSector(PhyAddr, AsyncFlag);

  if (FLS_DRVW_E_PENDING == LowLevelRes)
  {
   Fls_Job.AsyncExecutingFlag = (boolean)1U;
  }
        else if (FLS_DRVW_E_OK != LowLevelRes)
        {
   Res = MEMIF_JOB_FAILED;
   Fls_HandleEraseFault(LowLevelRes);
        }
        else if (AsyncFlag == 0U)
        {
            Fls_Job.AddrCur += PhysicalSectorSize;

            if(Fls_Job.AddrCur > Fls_Job.AddrEnd)
            {
                Res = MEMIF_JOB_OK;
            }
            else if(Fls_Job.AddrCur > (((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->EndAddr))
            {
                Fls_Job.SectorCur++;
            }
   else
   {

   }
        }
     else
  {

  }
    }

    return Res;
}
# 544 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static void Fls_HandleWriteFault(Fls_Drvw_ResultType WriteJobRes)
{
    (void)Det_ReportTransientFault((uint16)92U, (0U),
                                    0x0BU, 0x02U);

 if (FLS_DRVW_E_BLANK_CHECK == WriteJobRes)
 {
  (void)Det_ReportRuntimeError((uint16)92U, (0U),
                                    0x0BU, 0x07U);
 }
 else if (FLS_DRVW_E_COMPARE == WriteJobRes)
 {
  (void)Det_ReportRuntimeError((uint16)92U, (0U),
                                    0x0BU, 0x08U);
 }
 else if (FLS_DRVW_E_TIMEOUT == WriteJobRes)
 {
  (void)Det_ReportRuntimeError((uint16)92U, (0U),
                                     0x0BU, 0x09U);
 }
 else
 {

 }
}
# 581 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static MemIf_JobResultType Fls_ProcessJobWrite(void)
{
    MemIf_JobResultType Res = MEMIF_JOB_PENDING;
    Fls_AddressType WriteEndAddr;
    Fls_Drvw_ResultType LowLevelRes = FLS_DRVW_E_OK;
    Fls_LengthType WriteLen;
    boolean AsyncFlag;
 Fls_AddressType PhyAddr;

    if(Fls_Job.AddrCur > Fls_Job.AddrEnd)
    {
        Res = MEMIF_JOB_OK;
    }
    else
    {
        WriteEndAddr = Fls_ObtainRWEndAddr(Fls_MaxWrite);

        while((Fls_Job.AddrCur <= WriteEndAddr) && (FLS_DRVW_E_OK == LowLevelRes))
        {
            WriteLen = Fls_ObtainWriteLength(WriteEndAddr);

            AsyncFlag = (Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur]->WriteAsyncFlag;

   PhyAddr = Fls_ConvertJobLogicAddrToPhyAddr();

   LowLevelRes = Fls_Drvw_WriteSector(PhyAddr, WriteLen, Fls_Job.DataSrcPtr,AsyncFlag);

            if(FLS_DRVW_E_OK == LowLevelRes)
            {

                Fls_Job.AddrCur += WriteLen;
                Fls_Job.DataSrcPtr = &(Fls_Job.DataSrcPtr[WriteLen]);


                if(Fls_Job.AddrCur > (((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->EndAddr))
                {
                    Fls_Job.SectorCur++;
                }
            }
        }

  if (FLS_DRVW_E_PENDING == LowLevelRes)
  {
   Fls_Job.AsyncExecutingFlag = (boolean)1U;
  }
        else if (FLS_DRVW_E_OK != LowLevelRes)
        {
   Res = MEMIF_JOB_FAILED;
   Fls_HandleWriteFault(LowLevelRes);
        }
        else if (Fls_Job.AddrCur > Fls_Job.AddrEnd)
        {

            Res = MEMIF_JOB_OK;
        }
  else
  {

  }
    }

    return Res;
}
# 656 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static Fls_Drvw_ResultType Fls_DoJobRead(Fls_LengthType Len)
{
    Fls_Drvw_ResultType Res = FLS_DRVW_E_FAILED;
 Fls_AddressType PhyAddr = Fls_ConvertJobLogicAddrToPhyAddr();

    switch (Fls_Job.Job)
    {
        case FLS_JOB_READ:
            Res = Fls_Drvw_ReadSector(PhyAddr, Len, Fls_Job.DataDestPtr);
            if (FLS_DRVW_E_OK != Res)
            {
                (void)Det_ReportTransientFault((uint16)92U, (0U),
                                                0x0BU, 0x03U);
            }

            Fls_Job.DataDestPtr = &((Fls_Job.DataDestPtr)[Len]);
            break;


        case FLS_JOB_COMPARE:
            Res = Fls_Drvw_CompareSector(PhyAddr, Len, Fls_Job.DataSrcPtr);
            if (FLS_DRVW_E_OK != Res)
            {
                (void)Det_ReportTransientFault((uint16)92U, (0U),
                                                0x0BU, 0x04U);
    if (FLS_DRVW_E_COMPARE == Res)
    {
                 (void)Det_ReportRuntimeError((uint16)92U, (0U),
                                                 0x0BU, 0x08U);
    }
            }

            Fls_Job.DataSrcPtr = &((Fls_Job.DataSrcPtr)[Len]);
            break;



        case FLS_JOB_BLANK_CHECK:
            Res = Fls_Drvw_BlankCheckSector(PhyAddr, Len);
            if (FLS_DRVW_E_OK != Res)
            {
                (void)Det_ReportTransientFault((uint16)92U, (0U),
                                                0x0BU, 0x04U);
    if (FLS_DRVW_E_BLANK_CHECK == Res)
    {
                 (void)Det_ReportRuntimeError((uint16)92U, (0U),
                                                 0x0BU, 0x07U);
    }
            }
            break;


        default:

            break;
    }

    return Res;
}
# 726 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static MemIf_JobResultType Fls_HandleReadFault(Fls_Drvw_ResultType ReadJobRes)
{
    MemIf_JobResultType Res = MEMIF_JOB_PENDING;

 if((FLS_DRVW_E_FAILED == ReadJobRes) || (FLS_DRVW_E_BLANK_CHECK == ReadJobRes))
 {
  Res = MEMIF_JOB_FAILED;
 }
 else if(FLS_DRVW_E_COMPARE == ReadJobRes)
 {
  Res = MEMIF_BLOCK_INCONSISTENT;
 }
 else
 {

 }

 return Res;
}
# 756 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static MemIf_JobResultType Fls_ProcessJobRead(void)
{
    MemIf_JobResultType Res = MEMIF_JOB_PENDING;
    Fls_AddressType ReadEndAddr;
    Fls_Drvw_ResultType LowLevelRes = FLS_DRVW_E_OK;
    Fls_LengthType ReadLen;

    if(Fls_Job.AddrCur > Fls_Job.AddrEnd)
    {
        Res = MEMIF_JOB_OK;
    }
    else
    {
        ReadEndAddr = Fls_ObtainRWEndAddr(Fls_MaxRead);

        while((Fls_Job.AddrCur <= ReadEndAddr) && (FLS_DRVW_E_OK == LowLevelRes))
        {
            ReadLen = Fls_ObtainReadLength(ReadEndAddr);

            LowLevelRes = Fls_DoJobRead(ReadLen);


            Fls_Job.AddrCur += ReadLen;

            if(FLS_DRVW_E_OK == LowLevelRes)
            {

                if(Fls_Job.AddrCur > (((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->EndAddr))
                {
                    Fls_Job.SectorCur++;
                }
            }
        }

  if (FLS_DRVW_E_OK != LowLevelRes)
  {
   Res = Fls_HandleReadFault(LowLevelRes);
  }
        else if (Fls_Job.AddrCur > Fls_Job.AddrEnd)
        {

            Res = MEMIF_JOB_OK;
        }
  else
  {

  }
    }

    return Res;
}
# 819 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static MemIf_JobResultType Fls_ProcessJobs(void)
{
    MemIf_JobResultType JobResult;

    if(Fls_Job.Job == FLS_JOB_ERASE)
    {
        JobResult = Fls_ProcessJobErase();
    }
    else if(Fls_Job.Job == FLS_JOB_WRITE)
    {
        JobResult = Fls_ProcessJobWrite();
    }
    else
    {
        JobResult = Fls_ProcessJobRead();
    }

    return JobResult;
}
# 850 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static void Fls_CheckJobResult(MemIf_JobResultType Result)
{
    Fls_Job.JobResult = Result;

    if (MEMIF_JOB_OK == Result)
    {
        if(((void *)0) != Fls_ConfigPtr->JobEndNotificationPtr)
        {
            Fls_ConfigPtr->JobEndNotificationPtr();
        }
    }
    else if((MEMIF_JOB_FAILED == Result) || (MEMIF_JOB_CANCELED == Result) ||
            (MEMIF_BLOCK_INCONSISTENT == Result))
    {
        if (((void *)0) != Fls_ConfigPtr->JobErrorNotificationPtr)
        {
            Fls_ConfigPtr->JobErrorNotificationPtr();
        }
    }
    else
    {

    }
}
# 886 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static MemIf_JobResultType Fls_HandleAsyncEraseJob(void)
{
 Fls_Drvw_ResultType Ret;
 MemIf_JobResultType Res = MEMIF_JOB_PENDING;
 Fls_AddressType PhyAddr = Fls_ConvertJobLogicAddrToPhyAddr();
 Fls_LengthType PhySectorSize = ((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->SectorSize;

 Ret = Fls_Drvw_HandleAsyncEraseJob(PhyAddr,PhySectorSize);

 if (Ret != FLS_DRVW_E_BUSY)
 {
  Fls_Job.AsyncExecutingFlag = (boolean)0U;

  if (Ret != FLS_DRVW_E_OK)
  {
   Res = MEMIF_JOB_FAILED;

   (void)Det_ReportTransientFault((uint16)92U, (0U),
         0x0BU, 0x01U);

   if(Ret == FLS_DRVW_E_BLANK_CHECK)
   {
    (void)Det_ReportRuntimeError((uint16)92U, (0U),
              0x0BU, 0x07U);
   }
   else if(Ret == FLS_DRVW_E_TIMEOUT)
   {
    (void)Det_ReportRuntimeError((uint16)92U, (0U),
              0x0BU, 0x09U);
   }
   else
   {

   }
  }
  else
  {
   Fls_Job.AddrCur += PhySectorSize;
   if(Fls_Job.AddrCur > (((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->EndAddr))
   {
    Fls_Job.SectorCur++;
   }

   Res = MEMIF_JOB_OK;
  }
 }

 return Res;
}
# 947 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static MemIf_JobResultType Fls_HandleAsyncWriteJob(void)
{
 Fls_Drvw_ResultType Ret;
 MemIf_JobResultType Res = MEMIF_JOB_PENDING;
 Fls_AddressType PhyAddr = Fls_ConvertJobLogicAddrToPhyAddr();
 Fls_LengthType PageSize = ((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->PageSize;

 Ret = Fls_Drvw_HandleAsyncWriteJob(PhyAddr, Fls_Job.DataSrcPtr, PageSize);

 if(Ret != FLS_DRVW_E_BUSY)
 {
  Fls_Job.AsyncExecutingFlag = (boolean)0U;

  if (Ret != FLS_DRVW_E_OK)
  {
   Res = MEMIF_JOB_FAILED;

   (void)Det_ReportTransientFault((uint16)92U, (0U),
       0x0BU, 0x02U);

   if(Ret == FLS_DRVW_E_COMPARE)
   {
    (void)Det_ReportRuntimeError((uint16)92U, (0U),
              0x0BU, 0x08U);
   }
   else if(Ret == FLS_DRVW_E_TIMEOUT)
   {
    (void)Det_ReportRuntimeError((uint16)92U, (0U),
              0x0BU, 0x09U);
   }
   else
   {

   }
  }
  else
  {
   Fls_Job.AddrCur += PageSize;
   Fls_Job.DataSrcPtr = &(Fls_Job.DataSrcPtr[PageSize]);
   if(Fls_Job.AddrCur > (((Fls_ConfigPtr->SectorList)[Fls_Job.SectorCur])->EndAddr))
   {
    Fls_Job.SectorCur++;
   }

   Res = MEMIF_JOB_OK;
  }
 }

 return Res;
}
# 1009 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static MemIf_JobResultType Fls_HandleAsyncJob(void)
{
 MemIf_JobResultType Res = MEMIF_JOB_FAILED;

 if(FLS_JOB_ERASE == Fls_Job.Job)
 {
  Res = Fls_HandleAsyncEraseJob();
 }
 else if(FLS_JOB_WRITE == Fls_Job.Job)
 {
  Res = Fls_HandleAsyncWriteJob();
 }
 else
 {

 }

 return Res;
}
# 1040 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckEraseWriteConfigPtr(uint8 ServiceId)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

 if(((void *)0) == Fls_ConfigPtr)
    {
        (void)Det_ReportError((uint16)92U, (0U), ServiceId, 0x05U);
        RetVal = (Std_ReturnType)0x01U;
    }

 return RetVal;
}
# 1063 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckEraseStartAddrAlign(Fls_AddressType StartAddr)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

 if ((boolean)0U == Fls_CheckAddrAlignedSectorStart(StartAddr))
    {
        (void)Det_ReportError((uint16)92U, (0U),
                              0x01U, 0x02U);
        RetVal = (Std_ReturnType)0x01U;
    }

 return RetVal;
}
# 1088 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckEraseEndAddrAlign(Fls_AddressType EndAddr, Fls_LengthType Len)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

 if(((boolean)0U == Fls_CheckAddrAlignedSectorEnd(EndAddr)) || (0U == Len))
 {
  (void)Det_ReportError((uint16)92U, (0U),
                              0x01U, 0x03U);
  RetVal = (Std_ReturnType)0x01U;
 }

 return RetVal;
}
# 1112 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckWriteStartAddrAlign(Fls_AddressType StartAddr)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

 if((boolean)0U == Fls_CheckAddrAlignedPageStart(StartAddr))
    {
        (void)Det_ReportError((uint16)92U, (0U),
                              0x02U, 0x02U);
        RetVal = (Std_ReturnType)0x01U;
    }

 return RetVal;
}
# 1137 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckWriteEndAddrAlign(Fls_AddressType EndAddr, Fls_LengthType Len)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

    if(((boolean)0U == Fls_CheckAddrAlignedPageEnd(EndAddr)) || (0U == Len))
    {
        (void)Det_ReportError((uint16)92U, (0U),
                              0x02U, 0x03U);
        RetVal = (Std_ReturnType)0x01U;
    }

 return RetVal;
}
# 1161 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckModuleState(uint8 ServiceId)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

    if(((void *)0) == Fls_ConfigPtr)
    {
        (void)Det_ReportError((uint16)92U, (0U), ServiceId, 0x05U);
        RetVal = (Std_ReturnType)0x01U;
    }

 return RetVal;
}
# 1185 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckStartAddr(uint8 ServiceId, Fls_AddressType StartAddr)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

    if(StartAddr > Fls_GetFlashEndAddr())
    {
        (void)Det_ReportError((uint16)92U, (0U), ServiceId, 0x02U);
        RetVal = (Std_ReturnType)0x01U;
    }

 return RetVal;
}
# 1210 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckEndAddr(uint8 ServiceId,
                                             Fls_AddressType EndAddr,
                                             Fls_LengthType Len)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

    if((0U == Len) || (EndAddr > Fls_GetFlashEndAddr()))
    {
        (void)Det_ReportError((uint16)92U, (0U), ServiceId, 0x03U);
        RetVal = (Std_ReturnType)0x01U;
    }

 return RetVal;
}
# 1236 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
static inline Std_ReturnType Fls_CheckDataBufferPtr(uint8 ServiceId, const uint8* DateBufferPtr)
{
 Std_ReturnType RetVal = (Std_ReturnType)0x00U;

 if(((void *)0) == DateBufferPtr)
 {
  (void)Det_ReportError((uint16)92U, (0U), ServiceId, 0x04U);
  RetVal = (Std_ReturnType)0x01U;
 }

 return RetVal;
}



# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1116 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ""
# 1252 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1100 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ".mcal_code"
# 1259 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2
# 1269 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
void Fls_Init(const Fls_ConfigType* ConfigPtr)
{
 Fls_Drvw_ResultType Ret;



    if(ConfigPtr != ((void *)0))



    {
        (void)Det_ReportError((uint16)92U, (0U),
                              0x00U, 0x01U);
    }
    else if(MEMIF_JOB_PENDING == Fls_Job.JobResult)
    {
        (void)Det_ReportError((uint16)92U, (0U), 0x00U, 0x06U);
    }
    else

    {

        Fls_ConfigPtr = Fls_PreDefinedConfigPtr;
        (void)ConfigPtr;




        if (MEMIF_MODE_FAST == Fls_ConfigPtr->DefaultMode)
        {
            Fls_MaxRead = Fls_ConfigPtr->MaxReadFastMode;
            Fls_MaxWrite = Fls_ConfigPtr->MaxWriteFastMode;
        }
        else
        {
            Fls_MaxRead = Fls_ConfigPtr->MaxReadNormalMode;
            Fls_MaxWrite = Fls_ConfigPtr->MaxWriteNormalMode;
        }

  Ret = Fls_Drvw_Init(Fls_ConfigPtr->WrapperConfigSetPtr);
  if(Ret == FLS_DRVW_E_BUSY)
     {

         (void)Det_ReportError((uint16)92U, (0U), 0x00U, 0x06U);
     }
     else if(Ret == FLS_DRVW_E_HW_FAIL)
     {

         (void)Det_ReportTransientFault((uint16)92U, (0U),
                                        0x00U, 0x06U);
     }

  else if (Ret == FLS_DRVW_E_PARAM_DATA)
  {
   (void)Det_ReportError((uint16)92U, (0U),
                                  0x00U, 0x04U);
  }

  else
  {

  }

        Fls_Job.JobResult = MEMIF_JOB_OK;
        Fls_Job.AsyncExecutingFlag = 0U;
    }
}
# 1349 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length)
{
    Std_ReturnType RetVal = (Std_ReturnType)0x00U;
    Fls_AddressType EndAddr = TargetAddress + Length - 1U;


 RetVal = Fls_CheckEraseWriteConfigPtr(0x01U);
 if (0x00U == RetVal)
 {
  RetVal = Fls_CheckEraseStartAddrAlign(TargetAddress);
  RetVal |= Fls_CheckEraseEndAddrAlign(EndAddr, Length);
 }

    if (0x00U == RetVal)

    {
        if(MEMIF_JOB_PENDING == Fls_Job.JobResult)
        {

            (void)Det_ReportError((uint16)92U, (0U), 0x01U, 0x06U);

            RetVal = (Std_ReturnType)0x01U;
        }
        else
        {
            Fls_Job.SectorCur = Fls_GetSectorIndex(TargetAddress);
            Fls_Job.SectorEnd = Fls_GetSectorIndex(EndAddr);
            Fls_Job.AddrCur = TargetAddress;
            Fls_Job.AddrEnd = EndAddr;
            Fls_Job.Job = FLS_JOB_ERASE;
            Fls_Job.JobResult = MEMIF_JOB_PENDING;
            Fls_Job.AsyncExecutingFlag = (boolean)0U;
        }
    }

    return RetVal;
}
# 1400 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
Std_ReturnType Fls_Write(Fls_AddressType TargetAddress, const uint8* SourceAddressPtr,
                         Fls_LengthType Length )
{
    Std_ReturnType RetVal = (Std_ReturnType)0x00U;
    Fls_AddressType EndAddr = TargetAddress + Length - 1U;


 RetVal = Fls_CheckEraseWriteConfigPtr(0x02U);
 if (0x00U == RetVal)
 {
  RetVal = Fls_CheckWriteStartAddrAlign(TargetAddress);
  RetVal |= Fls_CheckWriteEndAddrAlign(EndAddr, Length);
 }
 RetVal |= Fls_CheckDataBufferPtr(0x02U, SourceAddressPtr);

 if (0x00U == RetVal)

 {
        if(MEMIF_JOB_PENDING == Fls_Job.JobResult)
        {

            (void)Det_ReportError((uint16)92U, (0U), 0x02U, 0x06U);

            RetVal = (Std_ReturnType)0x01U;
        }
        else
        {
            Fls_Job.SectorCur = Fls_GetSectorIndex(TargetAddress);
            Fls_Job.SectorEnd = Fls_GetSectorIndex(EndAddr);
            Fls_Job.AddrCur = TargetAddress;
            Fls_Job.AddrEnd = EndAddr;
            Fls_Job.DataSrcPtr = SourceAddressPtr;
            Fls_Job.Job = FLS_JOB_WRITE;
            Fls_Job.JobResult = MEMIF_JOB_PENDING;
            Fls_Job.AsyncExecutingFlag = (boolean)0U;
        }
    }

    return RetVal;
}
# 1451 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
void Fls_Cancel(void)
{
 Fls_Drvw_ResultType Ret;


    if(((void *)0) == Fls_ConfigPtr)
    {
        (void)Det_ReportError((uint16)92U, (0U), 0x03U, 0x05U);
    }
    else

    {
        if(MEMIF_JOB_PENDING == Fls_Job.JobResult)
        {
            Ret = Fls_Drvw_Cancel((Fls_Drvw_JobType)Fls_Job.Job);

   if((Ret == FLS_DRVW_E_OK) || (Ret == FLS_DRVW_E_CMD_ABORTED))
      {

      }
      else
      {

          (void)Det_ReportRuntimeError((uint16)92U, (0U), 0x03U,
                                        0x09U);
      }

            Fls_Job.JobResult = MEMIF_JOB_CANCELED;
            Fls_Job.AsyncExecutingFlag = 0U;

            if (((void *)0) != Fls_ConfigPtr->JobErrorNotificationPtr)
            {
                Fls_ConfigPtr->JobErrorNotificationPtr();
            }
            else
            {

            }
        }
        else
        {
            Fls_Job.AsyncExecutingFlag = 0U;
        }
    }
}
# 1511 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
MemIf_StatusType Fls_GetStatus(void)
{
    MemIf_StatusType RetVal;

    if (((void *)0) == Fls_ConfigPtr)
    {
        RetVal = MEMIF_UNINIT;
    }
    else if (MEMIF_JOB_PENDING == Fls_Job.JobResult)
    {
        RetVal = MEMIF_BUSY;
    }
    else
    {
        RetVal = MEMIF_IDLE;
    }

    return RetVal;
}
# 1550 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
MemIf_JobResultType Fls_GetJobResult ( void )
{
    MemIf_JobResultType RetVal;


    if(((void *)0) == Fls_ConfigPtr)
    {
        (void)Det_ReportError((uint16)92U, (0U), 0x05U,
                               0x05U);
        RetVal = MEMIF_JOB_FAILED;
    }
    else

    {
        RetVal = Fls_Job.JobResult;
    }
    return RetVal;
}
# 1583 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
Std_ReturnType Fls_Read(Fls_AddressType SourceAddress, uint8* TargetAddressPtr,
                        Fls_LengthType Length)
{
    Std_ReturnType RetVal = (Std_ReturnType)0x00U;
    Fls_AddressType EndAddr = SourceAddress + Length - 1U;


 RetVal = Fls_CheckModuleState(0x06U);
 if (0x00U == RetVal)
 {
  RetVal = Fls_CheckStartAddr(0x06U, SourceAddress);
  RetVal |= Fls_CheckEndAddr(0x06U, EndAddr, Length);
 }
 RetVal |= Fls_CheckDataBufferPtr(0x06U, TargetAddressPtr);

 if (0x00U == RetVal)

    {
        if(MEMIF_JOB_PENDING == Fls_Job.JobResult)
        {

            (void)Det_ReportError((uint16)92U, (0U), 0x06U, 0x06U);

            RetVal = (Std_ReturnType)0x01U;
        }
        else
        {
            Fls_Job.SectorCur = Fls_GetSectorIndex(SourceAddress);
            Fls_Job.SectorEnd = Fls_GetSectorIndex(EndAddr);
            Fls_Job.AddrCur = SourceAddress;
            Fls_Job.AddrEnd = EndAddr;
            Fls_Job.DataDestPtr = TargetAddressPtr;
            Fls_Job.Job = FLS_JOB_READ;
            Fls_Job.JobResult = MEMIF_JOB_PENDING;
            Fls_Job.AsyncExecutingFlag = (boolean)0U;
        }
    }

    return RetVal;
}
# 1639 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
Std_ReturnType Fls_Compare(Fls_AddressType SourceAddress, const uint8* TargetAddressPtr,
                           Fls_LengthType Length )
{
    Std_ReturnType RetVal = (Std_ReturnType)0x00U;
    Fls_AddressType EndAddr = SourceAddress + Length - 1U;


 RetVal = Fls_CheckModuleState(0x07U);
 if (0x00U == RetVal)
 {
  RetVal = Fls_CheckStartAddr(0x07U, SourceAddress);
  RetVal |= Fls_CheckEndAddr(0x07U, EndAddr, Length);
 }
 RetVal |= Fls_CheckDataBufferPtr(0x07U, TargetAddressPtr);

 if (0x00U == RetVal)

    {
        if(MEMIF_JOB_PENDING == Fls_Job.JobResult)
        {

            (void)Det_ReportError((uint16)92U, (0U), 0x07U, 0x06U);

            RetVal = (Std_ReturnType)0x01U;
        }
        else
        {
            Fls_Job.SectorCur = Fls_GetSectorIndex(SourceAddress);
            Fls_Job.SectorEnd = Fls_GetSectorIndex(EndAddr);
            Fls_Job.AddrCur = SourceAddress;
            Fls_Job.AddrEnd = EndAddr;
            Fls_Job.DataSrcPtr = TargetAddressPtr;
            Fls_Job.Job = FLS_JOB_COMPARE;
            Fls_Job.JobResult = MEMIF_JOB_PENDING;
            Fls_Job.AsyncExecutingFlag = (boolean)0U;
        }
    }

    return RetVal;
}
# 1692 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
void Fls_SetMode(MemIf_ModeType Mode)
{

    if (((void *)0) == Fls_ConfigPtr)
    {
        (void)Det_ReportError((uint16)92U, (0U), 0x08U, 0x05U);
    }
    else if (MEMIF_JOB_PENDING == Fls_Job.JobResult)
    {
        (void)Det_ReportError((uint16)92U, (0U), 0x08U, 0x06U);
    }
    else

    {
        switch (Mode)
        {
            case MEMIF_MODE_FAST:
                Fls_MaxRead = Fls_ConfigPtr->MaxReadFastMode;
                Fls_MaxWrite = Fls_ConfigPtr->MaxWriteFastMode;
                break;

            case MEMIF_MODE_SLOW:
                Fls_MaxRead = Fls_ConfigPtr->MaxReadNormalMode;
                Fls_MaxWrite = Fls_ConfigPtr->MaxWriteNormalMode;
                break;

            default:

                break;
        }
    }
}
# 1774 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
Std_ReturnType Fls_BlankCheck(Fls_AddressType TargetAddress, Fls_LengthType Length)
{
    Std_ReturnType RetVal = (Std_ReturnType)0x00U;
    Fls_AddressType EndAddr = TargetAddress + Length - 1U;


 RetVal = Fls_CheckModuleState(0x0AU);
 if (0x00U == RetVal)
 {
  RetVal = Fls_CheckStartAddr(0x0AU, TargetAddress);
  RetVal |= Fls_CheckEndAddr(0x0AU, EndAddr, Length);
 }

 if (0x00U == RetVal)

 {
        if(MEMIF_JOB_PENDING == Fls_Job.JobResult)
        {

            (void)Det_ReportError((uint16)92U, (0U),
                                  0x0AU, 0x06U);

            RetVal = (Std_ReturnType)0x01U;
        }
        else
        {
            Fls_Job.SectorCur = Fls_GetSectorIndex(TargetAddress);
            Fls_Job.SectorEnd = Fls_GetSectorIndex(EndAddr);
            Fls_Job.AddrCur = TargetAddress;
            Fls_Job.AddrEnd = EndAddr;
            Fls_Job.Job = FLS_JOB_BLANK_CHECK;
            Fls_Job.JobResult = MEMIF_JOB_PENDING;
            Fls_Job.AsyncExecutingFlag = (boolean)0U;
        }
    }

    return RetVal;
}
# 1823 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c"
void Fls_MainFunction(void)
{
    MemIf_JobResultType Result = MEMIF_JOB_OK;

    if(((void *)0) != Fls_ConfigPtr)
    {
        if(MEMIF_JOB_PENDING == Fls_Job.JobResult)
        {
            if(1U == Fls_Job.AsyncExecutingFlag)
            {
                Result = Fls_HandleAsyncJob();
            }

            if(Result == MEMIF_JOB_OK)
            {
                Result = Fls_ProcessJobs();
            }

            Fls_CheckJobResult(Result);
        }
    }
}


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h" 1
# 1116 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Fls_MemMap.h"
#pragma clang section text = ""
# 1848 "../../../mcal/Fls_ZX_K14xM/Src/Fls.c" 2