# 1 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 387 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2
# 26 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
# 1 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h" 1
# 29 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
# 1 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Types.h" 1
# 28 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Types.h"
# 1 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drvw_Types.h" 1
# 28 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drvw_Types.h"
# 1 "../Generated/inc\\Spi_Drvw_Cfg.h" 1
# 28 "../Generated/inc\\Spi_Drvw_Cfg.h"
# 1 "../Generated/inc/Spi_Drvw_PBcfg.h" 1
# 29 "../Generated/inc\\Spi_Drvw_Cfg.h" 2
# 29 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drvw_Types.h" 2
# 1 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drv_Types.h" 1
# 28 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_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);
# 29 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_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
# 30 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drv_Types.h" 2
# 1 "../Generated/inc\\Spi_Drv_Cfg.h" 1
# 28 "../Generated/inc\\Spi_Drv_Cfg.h"
# 1 "../Generated/inc/Spi_Drv_PBcfg.h" 1
# 29 "../Generated/inc\\Spi_Drv_Cfg.h" 2
# 31 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drv_Types.h" 2
# 84 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drv_Types.h"
typedef enum
{
    SPI_DRV_EVENT_SUCCESS = 0U,
    SPI_DRV_EVENT_FAULT
} Spi_Drv_EventType;




typedef void (*Spi_Drv_CallbackType)(uint8 Instance, Spi_Drv_EventType Event);




typedef enum
{
    SPI_DRV_POLLING = 0U,
    SPI_DRV_INTERRUPT
} Spi_Drv_AsyncModeType;




typedef enum
{
    SPI_DRV_UNINIT = 0U,
    SPI_DRV_IDLE,
    SPI_DRV_BUSY,
    SPI_DRV_FAULT
} Spi_Drv_StatusType;




typedef struct
{
    uint8 FrameSize;
    boolean Lsb;
    uint32 DefaultData;
} Spi_Drv_DeviceParamType;




typedef struct
{
    uint8 Instance;
    uint8 CsIdentifier;
    uint8 ClockPhase;
    uint8 ClockPolarity;
    uint32 ClockDivider;
    Spi_Drv_DeviceParamType *DeviceParamPtr;

} Spi_Drv_ExternalDeviceType;




typedef struct
{
    uint8 Instance;




    boolean DmaUsed;
    uint8 TxDmaChannel;
    uint8 RxDmaChannel;

    Spi_Drv_AsyncModeType AsyncMode;
} Spi_Drv_PhyUnitConfigType;




typedef struct
{
    Spi_Drv_AsyncModeType AsyncMode;
    Spi_Drv_StatusType Status;
    uint8 *RxBuffer;
    uint8 *TxBuffer;
    Spi_Drv_CallbackType Callback;
    uint16 RxIndex;
    uint16 TxIndex;
    uint16 ExpectReadNum;
    uint16 ExpectWriteNum;
    boolean ContinueTransferFlag;
    boolean FirstTransferFlag;
    const Spi_Drv_PhyUnitConfigType *PhyUnitConfig;
    const Spi_Drv_ExternalDeviceType
           *ExternalDevice;
    uint8 FrameSize;
    boolean TxLsb;
    boolean
        NextTransferConfigAvailable;
    uint8 CurrentTxFifoSlot;
    boolean TxDoneFlag;
} Spi_Drv_TransferConfigType;
# 30 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drvw_Types.h" 2
# 88 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Drvw_Types.h"
typedef enum
{
    IB = 0,
    EB
} Spi_Drvw_BufferType;






typedef enum
{
    SPI_DRVW_POLLING_MODE = 0,

    SPI_DRVW_INTERRUPT_MODE

} Spi_Drvw_AsyncModeType;





typedef uint8 Spi_Drvw_HWUnitType;






typedef uint16 Spi_Drvw_NumberOfDataType;





typedef uint8 Spi_Drvw_DataBufferType;





typedef struct
{
    uint8 Instance;
    uint32 IsSync;
    uint32 SpiCoreUse;
    const Spi_Drv_PhyUnitConfigType *PhyUnitConfigPtr;
} Spi_Drvw_HWUnitConfigType;




typedef struct
{
    const Spi_Drvw_HWUnitConfigType *DrvwHWUnitConfig;
} Spi_Drvw_HWUnitConfigListType;




typedef struct
{
    uint8 Instance;
    uint32 SpiCoreUse;
    const Spi_Drv_ExternalDeviceType *DrvExternalDeviceConfigPtr;
} Spi_Drvw_ExternalDeviceConfigType;




typedef struct
{

    const Spi_Drvw_ExternalDeviceConfigType *DrvwExternalDeviceConfigPtr;
} Spi_Drvw_ExternalDeviceListType;




typedef struct
{
    Spi_Drvw_DataBufferType *TxBuffer;
    Spi_Drvw_DataBufferType *RxBuffer;
} Spi_Drvw_BufferDescriptorType;




typedef struct
{
    uint8 Flags;
    Spi_Drvw_NumberOfDataType Length;
} Spi_Drvw_ChannelStateType;




typedef struct
{
    Spi_Drvw_BufferType BufferType;
    uint8 FrameSize;
    boolean Lsb;
    uint32 DefaultTransmitValue;
    Spi_Drvw_NumberOfDataType Length;
    Spi_Drvw_BufferDescriptorType *BufferDescriptor;
    uint32 SpiCoreUse;
    Spi_Drvw_ChannelStateType *ChannelState;
} Spi_Drvw_ChannelConfigType;
# 29 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Types.h" 2
# 1 "../Generated/inc\\Spi_Cfg.h" 1
# 28 "../Generated/inc\\Spi_Cfg.h"
# 1 "../Generated/inc/Spi_PBcfg.h" 1
# 66 "../Generated/inc/Spi_PBcfg.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ".mcal_code"
# 67 "../Generated/inc/Spi_PBcfg.h" 2





extern void Ex_Spi_StpJobStartNotification(void);




extern void Ex_Spi_SbcJobStartNotification(void);




extern void Ex_Spi_BuckJobStartNotification(void);




extern void Ex_Spi_BoostJobStartNotification(void);




extern void Ex_Spi_StpJobEndNotification(void);




extern void Ex_Spi_SbcJobEndNotification(void);




extern void Ex_Spi_BuckJobEndNotification(void);




extern void Ex_Spi_BoostJobEndNotification(void);




extern void Ex_Spi_StpSequenceEndNotification(void);




extern void Ex_Spi_SbcSequenceEndNotification(void);




extern void Ex_Spi_BuckSequenceEndNotification(void);




extern void Ex_Spi_BoostSequenceEndNotification(void);



# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ""
# 132 "../Generated/inc/Spi_PBcfg.h" 2
# 29 "../Generated/inc\\Spi_Cfg.h" 2
# 30 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Types.h" 2
# 99 "../../../mcal/Spi_ZX_K14xM/Inc/Spi_Types.h"
typedef enum
{
    SPI_UNINIT = 0,
    SPI_IDLE,
    SPI_BUSY
} Spi_StatusType;





typedef enum
{
    SPI_JOB_OK = 0,
    SPI_JOB_PENDING,
    SPI_JOB_FAILED,
    SPI_JOB_QUEUED

} Spi_JobResultType;




typedef enum
{
    SPI_SEQ_OK = 0,
    SPI_SEQ_PENDING,

    SPI_SEQ_FAILED,
    SPI_SEQ_CANCELLED
} Spi_SeqResultType;






typedef enum
{
    SPI_POLLING_MODE = 0,

    SPI_INTERRUPT_MODE

} Spi_AsyncModeType;





typedef Spi_Drvw_DataBufferType Spi_DataBufferType;






typedef Spi_Drvw_NumberOfDataType Spi_NumberOfDataType;




typedef uint8 Spi_ChannelType;




typedef uint16 Spi_JobType;




typedef uint8 Spi_SequenceType;





typedef Spi_Drvw_HWUnitType Spi_HWUnitType;






typedef uint8 Spi_ExternalDeviceType;

typedef void(Spi_NotifyType)(void);




typedef struct
{
    Spi_JobType JobNum;
    uint32 SpiCoreUse;
    const Spi_JobType *JobIndexList;
    Spi_NotifyType(*EndNotification);
    uint8 Interruptible;
} Spi_SequenceConfigType;




typedef struct
{
    const Spi_SequenceConfigType *SeqConfig;
} Spi_SequenceConfigListType;




typedef struct
{
    Spi_SeqResultType Result;

    const Spi_SequenceConfigType *Sequence;
    const Spi_JobType *CurrentJobIndexPointer;

    Spi_JobType
        RemainingJobs;

} Spi_SequenceStateType;




typedef struct
{
    Spi_JobResultType Result;

    Spi_SequenceStateType
               *AsyncSequenceState;
    Spi_JobType AsyncNextJob;

} Spi_JobStateType;




typedef struct
{
    Spi_ChannelType ChannelNum;
    const Spi_ChannelType *ChannelIndexList;
    Spi_NotifyType(*EndNotification);
    Spi_NotifyType(*StartNotification);
    sint8 Priority;
    uint32 SpiCoreUse;
    Spi_JobStateType *JobState;
    Spi_HWUnitType HWUnit;
    Spi_ExternalDeviceType ExternalDevice;
    const Spi_Drvw_ExternalDeviceListType
        *ExternalDeviceConfig;
} Spi_JobConfigType;




typedef struct
{
    const Spi_JobConfigType *JobConfig;
} Spi_JobConfigListType;






typedef struct
{

    Spi_JobType ScheduledJobsListHead[(4U)];
    Spi_JobType ScheduledJobsListTail[(4U)];
    sint8 MaxScheduledPriority;

    Spi_StatusType Status;
    Spi_ChannelType Channel;
    Spi_JobType Job;
} Spi_HWUnitQueue;




typedef struct
{

    const Spi_Drvw_ChannelConfigType *ChannelConfig;
} Spi_ChannelConfigListType;





typedef struct
{
    uint16 MaxExternalDevice;
    Spi_ChannelType SpiMaxChannel;
    Spi_JobType SpiMaxJob;
    Spi_SequenceType SpiMaxSequence;
    uint32 SpiCoreUse;
    const Spi_ChannelConfigListType
                                *ChannelConfigList;
    const Spi_JobConfigListType *JobConfigList;
    const Spi_SequenceConfigListType
        *SequenceConfigList;
    const Spi_Drvw_ExternalDeviceListType
        *ExternalDeviceConfigList;
    const Spi_Drvw_HWUnitConfigListType
        *HWUnitConfigList;
} Spi_ConfigType;
# 30 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h" 2
# 296 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 876 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section rodata = ".mcal_config_data"
# 297 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h" 2



extern const Spi_ConfigType Spi_Config;


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 892 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section rodata = ""
# 304 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h" 2



# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1436 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ".mcal_bss"
# 308 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h" 2



extern Spi_JobStateType Spi_JobStateArray[(4U)];
extern Spi_Drvw_ChannelStateType Spi_ChannelStateArray[(4U)];

# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1452 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ""
# 315 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h" 2








# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ".mcal_code"
# 324 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h" 2
# 335 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
void Spi_Init(const Spi_ConfigType *ConfigPtr);
# 348 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Std_ReturnType Spi_DeInit(void);
# 368 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Std_ReturnType Spi_WriteIB(Spi_ChannelType Channel, const Spi_DataBufferType *DataBufferPtr);
# 385 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Std_ReturnType Spi_AsyncTransmit(Spi_SequenceType Sequence);
# 408 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Std_ReturnType Spi_ReadIB(Spi_ChannelType Channel, Spi_DataBufferType *DataBufferPtr);
# 431 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Std_ReturnType Spi_SetupEB(Spi_ChannelType Channel, Spi_DataBufferType *SrcDataBufferPtr,
                           Spi_DataBufferType *DesDataBufferPtr, Spi_NumberOfDataType Length);
# 448 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Spi_StatusType Spi_GetStatus(void);
# 464 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Spi_JobResultType Spi_GetJobResult(Spi_JobType Job);
# 480 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Spi_SeqResultType Spi_GetSequenceResult(Spi_SequenceType Sequence);
# 494 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
void Spi_GetVersionInfo(Std_VersionInfoType *versioninfo);
# 511 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Std_ReturnType Spi_SyncTransmit(Spi_SequenceType Sequence);
# 530 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Spi_StatusType Spi_GetHWUnitStatus(Spi_HWUnitType HWUnit);
# 547 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
void Spi_Cancel(Spi_SequenceType Sequence);
# 564 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Std_ReturnType Spi_SetAsyncMode(Spi_AsyncModeType Mode);
# 579 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h"
Std_ReturnType Spi_SetHWUnitAsyncMode(Spi_HWUnitType HWUnit, Spi_AsyncModeType Mode);



# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ""
# 584 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi.h" 2
# 27 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2
# 1 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h" 1
# 92 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 876 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section rodata = ".mcal_config_data"
# 93 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h" 2



extern const Spi_Drvw_ExternalDeviceListType Spi_ExternalDeviceConfigList[4U]; extern const Spi_Drvw_HWUnitConfigListType Spi_HwUnitConfigList[(2U)];


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 892 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section rodata = ""
# 100 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ".mcal_code"
# 107 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h" 2
# 117 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h"
void Spi_Drvw_Init(const Spi_Drvw_HWUnitType HWUnit, const Spi_Drvw_HWUnitConfigType *HWUnitCfgPtr);
# 127 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h"
void Spi_Drvw_DeInit(Spi_Drvw_HWUnitType HWUnit);
# 143 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h"
Std_ReturnType
Spi_Drvw_TransmitChannel(const Spi_Drvw_ChannelConfigType *ChannelCfgPtr,
                         const Spi_Drvw_ExternalDeviceConfigType *ExternalDeviceCfgPtr,
                         const boolean IsFirstChannel, const boolean IsLastChannel,
                         const boolean IsSync);
# 158 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h"
void Spi_Drvw_PollAsyncTransmit(Spi_Drvw_HWUnitType HWUnit);
# 169 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h"
void Spi_Drvw_SetAsyncMode(Spi_Drvw_HWUnitType HWUnit, Spi_Drvw_AsyncModeType Mode);
# 186 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ""
# 187 "../../../mcal/Spi_ZX_K14xM/Inc\\Spi_Drvw.h" 2
# 28 "../../../mcal/Spi_ZX_K14xM/Src/Spi.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/Spi_ZX_K14xM/Src/Spi.c" 2
# 1 "../../../mcal/Rte_ZX_K14xM/Inc\\SchM_Spi.h" 1
# 59 "../../../mcal/Rte_ZX_K14xM/Inc\\SchM_Spi.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"
# 60 "../../../mcal/Rte_ZX_K14xM/Inc\\SchM_Spi.h" 2

extern void SchM_Enter_Spi_UpdateTransferStatus(void);

extern void SchM_Exit_Spi_UpdateTransferStatus(void);

extern void SchM_Enter_Spi_UpdateAsyncHWUnitQueue(void);

extern void SchM_Exit_Spi_UpdateAsyncHWUnitQueue(void);

extern void SchM_Enter_Spi_UpdateSyncHWUnitStatus(void);

extern void SchM_Exit_Spi_UpdateSyncHWUnitStatus(void);

extern void SchM_Enter_Spi_UpdateChannelState(void);

extern void SchM_Exit_Spi_UpdateChannelState(void);

extern void SchM_Enter_Spi_UpdateJobState(void);

extern void SchM_Exit_Spi_UpdateJobState(void);

extern void SchM_Enter_Spi_InitTxTransfer(void);

extern void SchM_Exit_Spi_InitTxTransfer(void);

extern void SchM_Enter_Spi_WriteInterruptMaskReg(void);

extern void SchM_Exit_Spi_WriteInterruptMaskReg(void);

void Spi_MainFunction_Handling(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 = ""
# 93 "../../../mcal/Rte_ZX_K14xM/Inc\\SchM_Spi.h" 2
# 30 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2
# 141 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1436 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ".mcal_bss"
# 142 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2




Spi_JobStateType Spi_JobStateArray[(4U)];




Spi_Drvw_ChannelStateType Spi_ChannelStateArray[(4U)];


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1452 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ""
# 155 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1408 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ".mcal_bss"
# 162 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2



static const Spi_ConfigType *Spi_ConfigPtr[(1U)];


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1424 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ""
# 169 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1436 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ".mcal_bss"
# 172 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2




static Spi_SequenceStateType Spi_SequenceStateArray[(4U)];




static Spi_HWUnitQueue Spi_HWUnitQueueArray[((2U))];


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1452 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ""
# 185 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1380 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ".mcal_bss"
# 188 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2





static uint32 Spi_SeqUsedHWUnits[(4U)];





static volatile uint32 Spi_SyncHWUnitsBusyStatus[((2U))];


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1396 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section bss = ""
# 203 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2
# 214 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ".mcal_code"
# 215 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2


extern void Spi_ChannelEndCallback(Spi_Drvw_HWUnitType HwUnit, boolean JobResultOK);



# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ""
# 222 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ".mcal_code"
# 229 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2


static inline Std_ReturnType Spi_GetHWUnitsBusyStatus(uint32 CoreId);


static inline void Spi_ScheduleNewJob(Spi_HWUnitQueue *HWUnitQueue, Spi_JobType Job,
                                     const Spi_JobConfigType *JobCfgPtr);
static inline void Spi_UnlockRemainingJobsOfSeq(Spi_JobType RemainingJobs,
                                               const Spi_SequenceConfigType *Sequence);



static Std_ReturnType Spi_CheckInit(uint32 CoreId, const Spi_ConfigType *ConfigPtr);
static Std_ReturnType Spi_CheckSequence(uint32 CoreId, const Spi_SequenceType Sequence,
                                        const uint8 ServiceId);
static Std_ReturnType Spi_CheckChannel(uint32 CoreId, const Spi_ChannelType Channel,
                                       const uint8 ServiceId);

static Std_ReturnType Spi_CheckSyncTransmit(uint32 CoreId, Spi_SequenceType Sequence);


static Std_ReturnType Spi_CheckAsyncTransmit(uint32 CoreId, Spi_SequenceType Sequence);



static Std_ReturnType Spi_CheckSetupEB(uint32 CoreId, Spi_ChannelType Channel,
                                       Spi_NumberOfDataType Length);
static Std_ReturnType Spi_CheckChannelLength(uint32 CoreId, const Spi_ChannelType Channel,
                                             Spi_NumberOfDataType Length, const uint8 ServiceId);


static Std_ReturnType Spi_CheckWriteIB(uint32 CoreId, Spi_ChannelType Channel);


static Std_ReturnType Spi_CheckReadIB(uint32 CoreId, Spi_ChannelType Channel,
                                      const Spi_DataBufferType *DataBufferPtr);

static Spi_JobResultType Spi_CheckGetJobResult(uint32 CoreId, Spi_JobType Job);
static Spi_SeqResultType Spi_CheckGetSequenceResult(uint32 CoreId, Spi_SequenceType Sequence);


static Std_ReturnType Spi_CheckHWUnit(uint32 CoreId, const Spi_HWUnitType HWUnit,
                                      const uint8 ServiceId);


static Std_ReturnType Spi_CheckCancel(uint32 CoreId, Spi_SequenceType Sequence);




static void Spi_InitChannelsState(uint32 CoreId);
static void Spi_InitJobsState(uint32 CoreId);
static void Spi_InitSequencesState(uint32 CoreId);



static Std_ReturnType Spi_SyncTransmitSequence(const Spi_SequenceConfigType *SeqCfgPtr,
                                               uint32 CoreId);
static Std_ReturnType Spi_SyncTransmitJob(const Spi_JobConfigType *JobCfgPtr, uint32 CoreId);



static void Spi_InitAsyncJobsList(uint32 HWUnit);
static void Spi_TransferAsyncJob(const Spi_JobConfigType *JobCfgPtr);
static Std_ReturnType Spi_LockAsyncSequence(Spi_SequenceType SequenceId,
                                            const Spi_SequenceConfigType *Sequence);
static void Spi_StartNextJob(Spi_HWUnitQueue *HWUnitQueue, uint32 CoreId);
static void Spi_JobTransferFinished(const Spi_JobConfigType *JobCfgPtr,
                                              Spi_JobResultType JobResult);



# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ""
# 302 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ".mcal_code"
# 309 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2
# 321 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static inline Std_ReturnType Spi_GetHWUnitsBusyStatus(uint32 CoreId)
{
    Spi_StatusType Status = SPI_IDLE;
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    Spi_HWUnitType HWUnit;

    for (HWUnit = 0U; HWUnit < (Spi_HWUnitType)((2U)); HWUnit++)
    {
        if ((((void *)0) != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)) &&
            (CoreId == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->SpiCoreUse))
        {
            if ((SPI_BUSY == Spi_HWUnitQueueArray[HWUnit].Status) &&
                ((0U) == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->IsSync))
            {
                Status = SPI_BUSY;
                break;
            }
        }
    }
    if (SPI_BUSY == Status)
    {
        Ret = 0x01U;
    }
    return Ret;
}
# 357 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static inline void Spi_UnlockRemainingJobsOfSeq(Spi_JobType RemainingJobs,
                                               const Spi_SequenceConfigType *Sequence)
{
    Spi_JobType TotalJobs = Sequence->JobNum;
    Spi_JobType Index;

    for (Index = TotalJobs - RemainingJobs; Index < TotalJobs; Index++)
    {
        Spi_JobStateArray[Sequence->JobIndexList[Index]].AsyncSequenceState = ((void *)0);
    }
}
# 379 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static inline void Spi_ScheduleNewJob(Spi_HWUnitQueue *HWUnitQueue, Spi_JobType Job,
                                     const Spi_JobConfigType *JobCfgPtr)
{
    sint8 Priority;
    Spi_JobType *JobListTail;

    SchM_Enter_Spi_UpdateAsyncHWUnitQueue();
    if (SPI_IDLE != HWUnitQueue->Status)
    {
        Priority = JobCfgPtr->Priority;
        JobListTail = &HWUnitQueue->ScheduledJobsListTail[Priority];

        if (((Spi_JobType)(0xFFFF)) == *JobListTail)
        {
            HWUnitQueue->ScheduledJobsListHead[Priority] = Job;
        }
        else
        {
            Spi_JobStateArray[*JobListTail].AsyncNextJob = Job;
        }

        *JobListTail = Job;

        Spi_JobStateArray[Job].AsyncNextJob = ((Spi_JobType)(0xFFFF));

        if (HWUnitQueue->MaxScheduledPriority < Priority)
        {
            HWUnitQueue->MaxScheduledPriority = Priority;
        }
        SchM_Exit_Spi_UpdateAsyncHWUnitQueue();
    }
    else
    {
        HWUnitQueue->Status = SPI_BUSY;
        Spi_JobStateArray[Job].Result = SPI_JOB_PENDING;
        HWUnitQueue->Channel = 0;
        HWUnitQueue->Job = Job;
        SchM_Exit_Spi_UpdateAsyncHWUnitQueue();

        Spi_TransferAsyncJob(JobCfgPtr);
    }
}
# 434 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckInit(uint32 CoreId, const Spi_ConfigType *ConfigPtr)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Spi_ChannelType Channel;
    Spi_JobType Job;
    Spi_SequenceType Sequence;


    if (((void *)0) != (Spi_ConfigPtr[(CoreId)]))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x00U)), (((uint8)0x4AU)));
    }

    else if (((void *)0) == ConfigPtr)
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x00U)), (((uint8)0x6AU)));
    }







    else
    {

        Channel = (uint32)(ConfigPtr->SpiMaxChannel);
        Job = (uint32)(ConfigPtr->SpiMaxJob);
        Sequence = (uint32)(ConfigPtr->SpiMaxSequence);

        if (((4U) <= Channel) || ((4U) <= Job) ||
            ((4U) <= Sequence))
        {
            Ret = (Std_ReturnType)0x01U;

            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x00U)), (((uint8)0x5AU)));

        }
        else if (CoreId != ConfigPtr->SpiCoreUse)
        {
            Ret = (Std_ReturnType)0x01U;
            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x00U)), (((uint8)0x0FU)));
        }







        else
        {

        }
    }
    return Ret;
}
# 507 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckSequence(uint32 CoreId, const Spi_SequenceType Sequence,
                                        const uint8 ServiceId)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x1AU)));
    }
    else if (Sequence > ((Spi_ConfigPtr[(CoreId)])->SpiMaxSequence))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0CU)));
    }
    else if (((void *)0) == (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0FU)));
    }
    else if (CoreId != (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig)->SpiCoreUse)
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0FU)));
    }
    else if (0U == (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig)->JobNum)
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x5CU)));
    }
    else
    {

    }
    return Ret;
}
# 557 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckChannelLength(uint32 CoreId, const Spi_ChannelType Channel,
                                             Spi_NumberOfDataType Length, const uint8 ServiceId)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    if ((Length > (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig)->Length) || (0U == Length))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0DU)));
    }
    else
    {
        if (((Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig)->FrameSize > 8U) &&
            ((Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig)->FrameSize < 17U))
        {

            if (0U != ((uint32)Length & 1U))
            {
                Ret = (Std_ReturnType)0x01U;
                (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0DU)));
            }
        }
        else if (((Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig)->FrameSize > 16U) &&
                 ((Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig)->FrameSize < 33U))
        {

            if (0U != ((uint32)Length & 3U))
            {
                Ret = (Std_ReturnType)0x01U;
                (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0DU)));
            }
        }
        else
        {

        }
    }
    return Ret;
}
# 608 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckChannel(uint32 CoreId, const Spi_ChannelType Channel,
                                       const uint8 ServiceId)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x1AU)));
    }
    else if (Channel > (Spi_ConfigPtr[(CoreId)])->SpiMaxChannel)
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0AU)));
    }
    else if (((void *)0) == (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0FU)));
    }
    else if (CoreId != (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig)->SpiCoreUse)
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0FU)));
    }
    else
    {

    }

    return Ret;
}
# 653 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckSyncTransmit(uint32 CoreId, Spi_SequenceType Sequence)
{
    Spi_JobType NumJobsInSequence;
    Spi_JobType Job;
    Spi_JobType JobIndex;
    uint32 IsSync;

    Spi_ChannelType ChannelID;
    Spi_ChannelType ChannelIndex;
    Spi_ChannelType ChannelNum;

    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Ret = Spi_CheckSequence(CoreId, Sequence, ((uint8)0x0AU));
    if ((Std_ReturnType)0x01U != Ret)
    {
        NumJobsInSequence = (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig)->JobNum;
        for (JobIndex = 0U; JobIndex < NumJobsInSequence; JobIndex++)
        {
            Job = (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig)->JobIndexList[JobIndex];
            IsSync = (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[((Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig)->HWUnit)].DrvwHWUnitConfig)->IsSync;
            if ((uint32)((0U)) == (IsSync))
            {
                Ret = (Std_ReturnType)0x01U;
                (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x0AU)), (((uint8)0x0EU)));
            }

            if ((Std_ReturnType)0x00U == Ret)
            {
                ChannelNum = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig)->ChannelNum;
                for (ChannelIndex = (Spi_ChannelType)0; ChannelIndex < ChannelNum; ChannelIndex++)
                {
                    ChannelID = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig)->ChannelIndexList[ChannelIndex];
                    if (EB == (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(ChannelID)].ChannelConfig)->BufferType)
                    {
                        if (0U == Spi_ChannelStateArray[ChannelID].Length)
                        {
                            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x0AU)), (((uint8)0x5BU)));
                            Ret = (Std_ReturnType)0x01U;
                            break;
                        }
                    }
                }
            }


            if ((Std_ReturnType)0x00U != Ret)
            {
                break;
            }
        }
    }
    return Ret;
}
# 720 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckAsyncTransmit(uint32 CoreId, Spi_SequenceType Sequence)
{
    const Spi_SequenceConfigType *SeqCfgPtr;
    const Spi_JobConfigType *JobCfgPtr;
    Spi_JobType NumJobsInSequence;
    Spi_JobType JobIndex;
    Spi_JobType JobId;

    Spi_ChannelType ChannelID;
    Spi_ChannelType NumChannelsInJob;
    Spi_ChannelType ChannelIndex;

    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Ret = Spi_CheckSequence(CoreId, Sequence, ((uint8)0x03U));
    if ((Std_ReturnType)0x01U != Ret)
    {
        SeqCfgPtr = (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig);
        NumJobsInSequence = SeqCfgPtr->JobNum;

        JobIndex = 0U;
        while (JobIndex < NumJobsInSequence)
        {
            JobId = SeqCfgPtr->JobIndexList[JobIndex];
            JobCfgPtr = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(JobId)].JobConfig);


            if (0U == JobCfgPtr->ChannelNum)
            {
                Ret = (Std_ReturnType)0x01U;
                (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x03U)), (((uint8)0x5DU)));
            }

            if ((0U) != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(JobCfgPtr->HWUnit)].DrvwHWUnitConfig)->IsSync)
            {
                Ret = (Std_ReturnType)0x01U;
                (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x03U)), (((uint8)0x0EU)));
            }


            if ((Std_ReturnType)0x00U == Ret)
            {
                NumChannelsInJob = JobCfgPtr->ChannelNum;
                for (ChannelIndex = (Spi_ChannelType)0; ChannelIndex < NumChannelsInJob;
                     ChannelIndex++)
                {
                    ChannelID = JobCfgPtr->ChannelIndexList[ChannelIndex];
                    if (EB == (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(ChannelID)].ChannelConfig)->BufferType)
                    {
                        if (0U == Spi_ChannelStateArray[ChannelID].Length)
                        {
                            Ret = (Std_ReturnType)0x01U;
                            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x03U)), (((uint8)0x5BU)));
                            break;
                        }
                    }
                }
            }


            if ((Std_ReturnType)0x00U != Ret)
            {
                break;
            }
            JobIndex++;
        }
    }
    return Ret;
}
# 803 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckSetupEB(uint32 CoreId, Spi_ChannelType Channel,
                                       Spi_NumberOfDataType Length)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Ret = Spi_CheckChannel(CoreId, Channel, ((uint8)0x05U));

    if ((Std_ReturnType)0x01U != Ret)
    {
        if (IB == (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig)->BufferType)
        {
            Ret = (Std_ReturnType)0x01U;
            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x05U)), (((uint8)0x0AU)));
        }
        else
        {
            Ret = Spi_CheckChannelLength(CoreId, Channel, Length, ((uint8)0x05U));
        }
    }
    return Ret;
}
# 839 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckReadIB(uint32 CoreId, Spi_ChannelType Channel,
                                      const Spi_DataBufferType *DataBufferPtr)
{
    const Spi_Drvw_ChannelConfigType *ChannelCfgPtr;
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Ret = Spi_CheckChannel(CoreId, Channel, ((uint8)0x04U));
    if ((Std_ReturnType)0x01U != Ret)
    {
        ChannelCfgPtr = (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig);
        if (EB == ChannelCfgPtr->BufferType)
        {
            Ret = (Std_ReturnType)0x01U;
            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x04U)), (((uint8)0x0AU)));
        }
        else if (((void *)0) == DataBufferPtr)
        {
            Ret = (Std_ReturnType)0x01U;
            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x04U)), (((uint8)0x0AU)));
        }
        else
        {

        }
    }
    return Ret;
}
# 880 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckWriteIB(uint32 CoreId, Spi_ChannelType Channel)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Ret = Spi_CheckChannel(CoreId, Channel, ((uint8)0x02U));
    if ((Std_ReturnType)0x01U != Ret)
    {
        if (EB == (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig)->BufferType)
        {
            Ret = (Std_ReturnType)0x01U;
            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x02U)), (((uint8)0x0AU)));
        }
    }
    return Ret;
}
# 908 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Spi_JobResultType Spi_CheckGetJobResult(uint32 CoreId, Spi_JobType Job)
{
    Spi_JobResultType JobResult = SPI_JOB_FAILED;

    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x07U)), (((uint8)0x1AU)));
    }
    else if (Job > (Spi_ConfigPtr[(CoreId)])->SpiMaxJob)
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x07U)), (((uint8)0x0BU)));
    }
    else if (((void *)0) == (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig))
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x07U)), (((uint8)0x0FU)));
    }
    else if (CoreId != (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig)->SpiCoreUse)
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x07U)), (((uint8)0x0FU)));
    }
    else
    {
        JobResult = SPI_JOB_OK;
    }
    return JobResult;
}
# 945 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Spi_SeqResultType Spi_CheckGetSequenceResult(uint32 CoreId, Spi_SequenceType Sequence)
{
    Spi_SeqResultType SequenceResult = SPI_SEQ_FAILED;

    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x08U)), (((uint8)0x1AU)));
    }
    else if (Sequence > (Spi_ConfigPtr[(CoreId)])->SpiMaxSequence)
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x08U)), (((uint8)0x0CU)));
    }
    else if (((void *)0) == (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig))
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x08U)), (((uint8)0x0FU)));
    }
    else if (CoreId != (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig)->SpiCoreUse)
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x08U)), (((uint8)0x0FU)));
    }
    else
    {
        SequenceResult = SPI_SEQ_OK;
    }
    return SequenceResult;
}
# 984 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckHWUnit(uint32 CoreId, const Spi_HWUnitType HWUnit,
                                      const uint8 ServiceId)
{
    Std_ReturnType Ret = (Std_ReturnType)0x01U;

    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x1AU)));
    }
    else if (((2U)) <= HWUnit)
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x61U)));
    }
    else if (((void *)0) == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig))
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0FU)));
    }
    else if (CoreId != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->SpiCoreUse)
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (ServiceId), (((uint8)0x0FU)));
    }
    else
    {
        Ret = (Std_ReturnType)0x00U;
    }

    return Ret;
}
# 1026 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_CheckCancel(uint32 CoreId, Spi_SequenceType Sequence)
{
    Std_ReturnType Ret = (Std_ReturnType)0x01U;
    const Spi_SequenceConfigType *SeqCfgPtr;

    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x0CU)), (((uint8)0x1AU)));
    }
    else if (Sequence > (Spi_ConfigPtr[(CoreId)])->SpiMaxSequence)
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x0CU)), (((uint8)0x0CU)));
    }
    else
    {
        SeqCfgPtr = (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig);
        if (((void *)0) == SeqCfgPtr)
        {
            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x0CU)), (((uint8)0x0FU)));
        }
        else if (CoreId != SeqCfgPtr->SpiCoreUse)
        {
            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x0CU)), (((uint8)0x0FU)));
        }
        else
        {
            Ret = (Std_ReturnType)0x00U;
        }
    }
    return Ret;
}
# 1073 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_SyncTransmitJob(const Spi_JobConfigType *JobCfgPtr, uint32 CoreId)
{
    Spi_ChannelType ChannelID;
    Spi_ChannelType NumChannelsInJob;
    Spi_ChannelType ChannelIndex;
    const Spi_Drvw_ChannelConfigType *ChannelCfgPtr;
    const Spi_Drvw_ExternalDeviceConfigType *ExternalDeviceConfig;
    boolean IsFirstChannel;
    boolean IsLastChannel;
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    ExternalDeviceConfig = JobCfgPtr->ExternalDeviceConfig->DrvwExternalDeviceConfigPtr;

    if (((void *)0) != JobCfgPtr->StartNotification)
    {
        JobCfgPtr->StartNotification();
    }

    NumChannelsInJob = JobCfgPtr->ChannelNum;
    for (ChannelIndex = (Spi_ChannelType)0; ChannelIndex < NumChannelsInJob; ChannelIndex++)
    {
        ChannelID = JobCfgPtr->ChannelIndexList[ChannelIndex];
        ChannelCfgPtr = (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(ChannelID)].ChannelConfig);

        if (0U == ChannelIndex)
        {
            IsFirstChannel = (boolean)1U;
        }
        else
        {
            IsFirstChannel = (boolean)0U;
        }
        if (ChannelIndex == (NumChannelsInJob - 1U))
        {
            IsLastChannel = (boolean)1U;
        }
        else
        {
            IsLastChannel = (boolean)0U;
        }
        Ret = Spi_Drvw_TransmitChannel(ChannelCfgPtr, ExternalDeviceConfig, IsFirstChannel,
                                       IsLastChannel, (boolean)1U);
        if ((Std_ReturnType)0x00U != Ret)
        {
            break;
        }
    }

    return Ret;
}
# 1135 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_SyncTransmitSequence(const Spi_SequenceConfigType *SeqCfgPtr,
                                               uint32 CoreId)
{
    Spi_JobType JobsCount;
    const Spi_JobType *JobIndexList;
    Spi_JobType Job;
    Spi_JobStateType *JobState;
    const Spi_JobConfigType *JobCfgPtr;
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    JobsCount = SeqCfgPtr->JobNum;
    JobIndexList = SeqCfgPtr->JobIndexList;
    while (0U < JobsCount)
    {
        Job = *JobIndexList;
        JobCfgPtr = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig);

        JobState = &Spi_JobStateArray[Job];
        JobState->Result = SPI_JOB_PENDING;
        Spi_HWUnitQueueArray[JobCfgPtr->HWUnit].Status = SPI_BUSY;

        Ret = Spi_SyncTransmitJob(JobCfgPtr, CoreId);
        Spi_HWUnitQueueArray[JobCfgPtr->HWUnit].Status = SPI_IDLE;

        if ((Std_ReturnType)0x00U == Ret)
        {
            JobState->Result = SPI_JOB_OK;
            if (((void *)0) != JobCfgPtr->EndNotification)
            {
                JobCfgPtr->EndNotification();
            }
        }
        else
        {
            do
            {
                Spi_JobStateArray[*JobIndexList].Result = SPI_JOB_FAILED;
                JobCfgPtr = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(*JobIndexList)].JobConfig);
                if (((void *)0) != JobCfgPtr->EndNotification)
                {
                    JobCfgPtr->EndNotification();
                }
                JobIndexList++;
                JobsCount--;
            }
            while (0U < JobsCount);
            JobsCount = 1U;
        }
        JobIndexList++;
        JobsCount--;
    }
    return Ret;
}
# 1198 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static void Spi_InitAsyncJobsList(uint32 HWUnit)
{
    sint8 Priority;

    for (Priority = 0; Priority < (sint8)(4U); Priority++)
    {
        Spi_HWUnitQueueArray[HWUnit].ScheduledJobsListHead[Priority] = ((Spi_JobType)(0xFFFF));
        Spi_HWUnitQueueArray[HWUnit].ScheduledJobsListTail[Priority] = ((Spi_JobType)(0xFFFF));
    }
    Spi_HWUnitQueueArray[HWUnit].MaxScheduledPriority = (-1);
}
# 1220 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static Std_ReturnType Spi_LockAsyncSequence(Spi_SequenceType SequenceId,
                                            const Spi_SequenceConfigType *Sequence)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    Spi_JobType JobCount = Sequence->JobNum;
    Spi_JobStateType *JobState;
    const Spi_JobType *JobPtr = Sequence->JobIndexList;
    Spi_SequenceStateType *SequenceState = &Spi_SequenceStateArray[SequenceId];

    SchM_Enter_Spi_UpdateJobState();
    while (0U < JobCount)
    {
        JobState = &Spi_JobStateArray[*JobPtr];
        if (((void *)0) != JobState->AsyncSequenceState)
        {
            if (JobCount < Sequence->JobNum)
            {
                do
                {
                    JobCount++;
                    JobPtr--;
                    Spi_JobStateArray[*JobPtr].AsyncSequenceState = ((void *)0);
                }
                while (JobCount < Sequence->JobNum);
            }
            Ret = (Std_ReturnType)0x01U;
            break;
        }
        else
        {
            JobState->AsyncSequenceState = SequenceState;
        }
        JobCount--;
        JobPtr++;
    }
    SchM_Exit_Spi_UpdateJobState();

    return Ret;
}
# 1268 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static void Spi_JobTransferFinished(const Spi_JobConfigType *JobCfgPtr, Spi_JobResultType JobResult)
{
    Spi_HWUnitType HWUnit = JobCfgPtr->HWUnit;
    Spi_HWUnitQueue *HWUnitQueue = &Spi_HWUnitQueueArray[HWUnit];
    Spi_JobStateType *JobState = JobCfgPtr->JobState;
    Spi_SequenceStateType *SequenceState;
    const Spi_SequenceConfigType *SeqCfgPtr;
    const Spi_JobType *Job;
    const Spi_JobConfigType *CurrentJobCfg;
    Spi_JobType JobId;
    uint32 CoreId;

    SchM_Enter_Spi_UpdateJobState();
    if ((SPI_JOB_OK != JobState->Result) && (((void *)0) != JobState->AsyncSequenceState))
    {
        JobState->Result = JobResult;
        CoreId = JobCfgPtr->SpiCoreUse;
        SequenceState = JobState->AsyncSequenceState;
        SeqCfgPtr = SequenceState->Sequence;
        JobState->AsyncSequenceState = ((void *)0);
        SchM_Exit_Spi_UpdateJobState();

        if (((void *)0) != JobCfgPtr->EndNotification)
        {
            JobCfgPtr->EndNotification();
        }
        else
        {

        }
        if ((SPI_JOB_FAILED == JobState->Result) && (SequenceState->Result != SPI_SEQ_CANCELLED))
        {
            SequenceState->Result = SPI_SEQ_FAILED;
        }
        else
        {

        }

        if ((SPI_SEQ_CANCELLED == SequenceState->Result) ||
            (SPI_SEQ_FAILED == SequenceState->Result))



        {
            Spi_UnlockRemainingJobsOfSeq(SequenceState->RemainingJobs, SeqCfgPtr);
# 1326 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
            if (((void *)0) != SeqCfgPtr->EndNotification)
            {
                SeqCfgPtr->EndNotification();
            }

            Spi_StartNextJob(HWUnitQueue, CoreId);
        }
        else
        {
            if (0U < SequenceState->RemainingJobs)
            {
                SequenceState->CurrentJobIndexPointer++;
                Job = SequenceState->CurrentJobIndexPointer;
                JobId = *Job;
                SequenceState->RemainingJobs--;
                CurrentJobCfg = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(JobId)].JobConfig);
                if (HWUnit != CurrentJobCfg->HWUnit)
                {
                    Spi_ScheduleNewJob(&Spi_HWUnitQueueArray[CurrentJobCfg->HWUnit], JobId,
                                       CurrentJobCfg);
                    Spi_StartNextJob(HWUnitQueue, CoreId);
                }
                else
                {


                    if (1U == SeqCfgPtr->Interruptible)
                    {
                        Spi_ScheduleNewJob(HWUnitQueue, JobId, CurrentJobCfg);
                        Spi_StartNextJob(HWUnitQueue, CoreId);
                    }
                    else

                    {
                        Spi_JobStateArray[JobId].Result = SPI_JOB_PENDING;
                        HWUnitQueue->Channel = 0;
                        HWUnitQueue->Job = JobId;
                        Spi_TransferAsyncJob(CurrentJobCfg);
                    }
                }
            }
            else
            {
                SequenceState->Result = SPI_SEQ_OK;




                if (((void *)0) != SeqCfgPtr->EndNotification)
                {
                    SeqCfgPtr->EndNotification();
                }
                Spi_StartNextJob(HWUnitQueue, CoreId);
            }
        }
    }
    else
    {
        SchM_Exit_Spi_UpdateJobState();
    }
}
# 1397 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static void Spi_StartNextJob(Spi_HWUnitQueue *HWUnitQueue, uint32 CoreId)
{
    Spi_JobType Job;
    Spi_JobType *JobListHead;
    sint8 Priority;
    sint8 MaxScheduledPriority;

    SchM_Enter_Spi_UpdateAsyncHWUnitQueue();
    MaxScheduledPriority = HWUnitQueue->MaxScheduledPriority;
    if (0 <= MaxScheduledPriority)
    {
        JobListHead = &HWUnitQueue->ScheduledJobsListHead[MaxScheduledPriority];
        Job = *JobListHead;

        *JobListHead = Spi_JobStateArray[Job].AsyncNextJob;

        if (((Spi_JobType)(0xFFFF)) == *JobListHead)
        {
            HWUnitQueue->ScheduledJobsListTail[MaxScheduledPriority] = ((Spi_JobType)(0xFFFF));

            for (Priority = MaxScheduledPriority - 1; Priority >= 0; Priority--)
            {
                if (((Spi_JobType)(0xFFFF)) != HWUnitQueue->ScheduledJobsListHead[Priority])
                {
                    break;
                }
            }
            HWUnitQueue->MaxScheduledPriority = Priority;
        }
        SchM_Exit_Spi_UpdateAsyncHWUnitQueue();

        Spi_JobStateArray[Job].Result = SPI_JOB_PENDING;
        HWUnitQueue->Channel = 0U;
        HWUnitQueue->Job = Job;
        Spi_TransferAsyncJob((Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig));
    }
    else
    {
        HWUnitQueue->Status = SPI_IDLE;
        SchM_Exit_Spi_UpdateAsyncHWUnitQueue();
    }
}
# 1448 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static void Spi_TransferAsyncJob(const Spi_JobConfigType *JobCfgPtr)
{
    const Spi_Drvw_ExternalDeviceConfigType *ExternalDeviceConfig;
    const Spi_Drvw_ChannelConfigType *ChannelCfgPtr;
    uint32 CoreId;
    boolean IsLastChannel;

    CoreId = ((uint32)(0U));
    if (((void *)0) != JobCfgPtr->StartNotification)
    {
        JobCfgPtr->StartNotification();
    }

    if (1U < JobCfgPtr->ChannelNum)
    {
        IsLastChannel = (boolean)0U;
    }
    else
    {
        IsLastChannel = (boolean)1U;
    }

    ChannelCfgPtr = (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(JobCfgPtr->ChannelIndexList[0U])].ChannelConfig);
    ExternalDeviceConfig = JobCfgPtr->ExternalDeviceConfig->DrvwExternalDeviceConfigPtr;

    (void)Spi_Drvw_TransmitChannel(ChannelCfgPtr, ExternalDeviceConfig, (boolean)1U,
                                   IsLastChannel, (boolean)0U);
}
# 1485 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static void Spi_InitChannelsState(uint32 CoreId)
{
    uint32 Channel;
    const Spi_Drvw_ChannelConfigType *ChannelCfgPtr;

    for (Channel = 0U; Channel <= (uint32)((Spi_ConfigPtr[(CoreId)])->SpiMaxChannel); Channel++)
    {
        ChannelCfgPtr = (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig);
        if ((((void *)0) != ChannelCfgPtr) && (CoreId == ChannelCfgPtr->SpiCoreUse))
        {
            Spi_ChannelStateArray[Channel].Flags = ((uint8)0x01U);
            if (IB == ChannelCfgPtr->BufferType)
            {
                Spi_ChannelStateArray[Channel].Length = ChannelCfgPtr->Length;
            }
            else
            {
                ChannelCfgPtr->BufferDescriptor->TxBuffer = ((void *)0);
                ChannelCfgPtr->BufferDescriptor->RxBuffer = ((void *)0);
                Spi_ChannelStateArray[Channel].Length = (Spi_NumberOfDataType)0U;
            }
        }
    }
}
# 1517 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static void Spi_InitJobsState(uint32 CoreId)
{
    uint32 Job;
    const Spi_JobConfigType *JobCfgPtr;


    for (Job = 0U; Job <= (uint32)((Spi_ConfigPtr[(CoreId)])->SpiMaxJob); Job++)
    {
        JobCfgPtr = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig);
        if ((((void *)0) != JobCfgPtr) && (CoreId == JobCfgPtr->SpiCoreUse))
        {
            Spi_JobStateArray[Job].Result = SPI_JOB_OK;

            Spi_JobStateArray[Job].AsyncSequenceState = ((void *)0);

        }
    }
}
# 1543 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
static void Spi_InitSequencesState(uint32 CoreId)
{
    uint32 Sequence;
    const Spi_SequenceConfigType *SeqCfgPtr;


    Spi_HWUnitType HWUnit;
    uint32 Job;



    for (Sequence = 0U; Sequence <= (uint32)((Spi_ConfigPtr[(CoreId)])->SpiMaxSequence); Sequence++)
    {
        SeqCfgPtr = (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig);
        if ((((void *)0) != SeqCfgPtr) && (CoreId == SeqCfgPtr->SpiCoreUse))
        {

            Spi_SequenceStateArray[Sequence].Sequence = SeqCfgPtr;

            Spi_SequenceStateArray[Sequence].Result = SPI_SEQ_OK;



            Spi_SeqUsedHWUnits[Sequence] = (uint32)0;

            for (Job = 0U; Job < SeqCfgPtr->JobNum; Job++)
            {
                HWUnit = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(SeqCfgPtr->JobIndexList[Job])].JobConfig)->HWUnit;

                Spi_SeqUsedHWUnits[Sequence] |= (uint32)((uint32)1 << (HWUnit));
            }




        }
        else
        {

        }
    }
}


# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ""
# 1588 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2






# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1072 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ".mcal_code"
# 1595 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2
# 1606 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
void Spi_Init(const Spi_ConfigType *ConfigPtr)
{
    Spi_HWUnitType HWUnit;
    uint32 CoreId = ((uint32)(0U));

    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Ret = Spi_CheckInit(CoreId, ConfigPtr);
    if ((Std_ReturnType)0x01U != Ret)
    {



        (Spi_ConfigPtr[(CoreId)]) = ConfigPtr;




        Spi_InitChannelsState(CoreId);
        Spi_InitJobsState(CoreId);
        Spi_InitSequencesState(CoreId);


        for (HWUnit = (Spi_HWUnitType)0; HWUnit < (Spi_HWUnitType)((2U)); HWUnit++)
        {
            if ((((void *)0) != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)) &&
                (CoreId == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->SpiCoreUse))
            {
                Spi_Drvw_Init(HWUnit, (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig));





                Spi_Drvw_SetAsyncMode(HWUnit, SPI_DRVW_POLLING_MODE);


                Spi_InitAsyncJobsList(HWUnit);

                Spi_HWUnitQueueArray[HWUnit].Status = SPI_IDLE;
            }
        }

    }

}
# 1664 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Std_ReturnType Spi_DeInit(void)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    Spi_HWUnitType HWUnit;
    uint32 CoreId;

    CoreId = ((uint32)(0U));


    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x01U)), (((uint8)0x1AU)));
    }
    else
    {

        if (SPI_IDLE == Spi_GetStatus())
        {
            for (HWUnit = (Spi_HWUnitType)0; HWUnit < (Spi_HWUnitType)((2U)); HWUnit++)
            {
                if ((((void *)0) != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)) &&
                    (CoreId == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->SpiCoreUse))
                {
                    Spi_Drvw_DeInit(HWUnit);

                    Spi_HWUnitQueueArray[HWUnit].Status = SPI_UNINIT;
                }
                else
                {

                }
            }

            (Spi_ConfigPtr[(CoreId)]) = ((void *)0);
        }
        else
        {
            Ret = 0x01U;
        }

    }


    return Ret;
}
# 1729 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Std_ReturnType Spi_WriteIB(Spi_ChannelType Channel, const Spi_DataBufferType *DataBufferPtr)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    uint16 Index;
    Spi_Drvw_ChannelStateType *ChannelState;
    const Spi_Drvw_ChannelConfigType *ChannelCfgPtr;
    Spi_DataBufferType *DataBufferDes;
    const Spi_DataBufferType *DataBufferSrc;
    uint32 CoreId;

    CoreId = ((uint32)(0U));


    Ret = Spi_CheckWriteIB(CoreId, Channel);
    if ((Std_ReturnType)0x01U != Ret)
    {

        ChannelState = &Spi_ChannelStateArray[Channel];
        ChannelCfgPtr = (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig);

        SchM_Enter_Spi_UpdateChannelState();
        if (((void *)0) != DataBufferPtr)
        {
            DataBufferDes = ChannelCfgPtr->BufferDescriptor->TxBuffer;
            DataBufferSrc = DataBufferPtr;
            for (Index = 0U; Index < ChannelCfgPtr->Length; Index++)
            {
                *DataBufferDes = *DataBufferSrc;
                DataBufferDes++;
                DataBufferSrc++;
            }
            ChannelState->Flags =
                (uint8)(ChannelState->Flags & ((uint8)(~((uint8)0x01U))));
        }
        else
        {
            ChannelState->Flags |= ((uint8)0x01U);
        }
        SchM_Exit_Spi_UpdateChannelState();

    }


    return Ret;
}
# 1790 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Std_ReturnType Spi_AsyncTransmit(Spi_SequenceType Sequence)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    Spi_JobType JobNum;
    Spi_JobType JobIndex;
    const Spi_SequenceConfigType *SeqCfgPtr;
    Spi_SequenceStateType *SequenceState;
    const Spi_JobConfigType *JobCfgPtr;
    const Spi_JobType *Job;
    const Spi_JobType *JobCount;
    uint32 CoreId;

    CoreId = ((uint32)(0U));


    Ret = Spi_CheckAsyncTransmit(CoreId, Sequence);
    if ((Std_ReturnType)0x00U == Ret)
    {

        SeqCfgPtr = (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig);
        JobNum = SeqCfgPtr->JobNum;

        Ret = Spi_LockAsyncSequence(Sequence, SeqCfgPtr);
        if ((Std_ReturnType)0x00U != Ret)
        {
            (void)Det_ReportRuntimeError((uint16)83U, (uint8)0, ((uint8)0x03U),
                                         ((uint8)0x2AU));
        }
        else
        {
            SequenceState = &Spi_SequenceStateArray[Sequence];
            SequenceState->Result = SPI_SEQ_PENDING;

            SequenceState->RemainingJobs = SeqCfgPtr->JobNum - 1U;
            Job = &SeqCfgPtr->JobIndexList[0];
            SequenceState->CurrentJobIndexPointer = Job;
            for (JobIndex = 0U; JobIndex < JobNum; JobIndex++)
            {
                JobCount = &SeqCfgPtr->JobIndexList[JobIndex];
                Spi_JobStateArray[*JobCount].Result = SPI_JOB_QUEUED;
            }
            JobCfgPtr = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(*Job)].JobConfig);
            Spi_ScheduleNewJob(&Spi_HWUnitQueueArray[JobCfgPtr->HWUnit], *Job, JobCfgPtr);
        }

    }


    return Ret;
}
# 1858 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Std_ReturnType Spi_ReadIB(Spi_ChannelType Channel, Spi_DataBufferType *DataBufferPtr)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    Spi_NumberOfDataType Index;
    const Spi_Drvw_ChannelConfigType *ChannelCfgPtr;
    const Spi_DataBufferType *DataBufferSrc;
    Spi_DataBufferType *DataBufferDes;
    uint32 CoreId;

    CoreId = ((uint32)(0U));


    Ret = Spi_CheckReadIB(CoreId, Channel, DataBufferPtr);
    if ((Std_ReturnType)0x01U != Ret)
    {

        ChannelCfgPtr = (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig);
        DataBufferSrc = ChannelCfgPtr->BufferDescriptor->RxBuffer;
        DataBufferDes = DataBufferPtr;
        for (Index = 0U; Index < ChannelCfgPtr->Length; Index++)
        {
            *DataBufferDes = *DataBufferSrc;
            DataBufferDes++;
            DataBufferSrc++;
        }

    }


    return Ret;
}
# 1911 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Std_ReturnType Spi_SetupEB(Spi_ChannelType Channel, Spi_DataBufferType *SrcDataBufferPtr,
                           Spi_DataBufferType *DesDataBufferPtr, Spi_NumberOfDataType Length)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    Spi_Drvw_ChannelStateType *ChannelState;
    const Spi_Drvw_ChannelConfigType *ChannelCfgPtr;
    uint32 CoreId;

    CoreId = ((uint32)(0U));

    Ret = Spi_CheckSetupEB(CoreId, Channel, Length);
    if ((Std_ReturnType)0x01U != Ret)
    {

        ChannelState = &Spi_ChannelStateArray[Channel];
        ChannelCfgPtr = (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(Channel)].ChannelConfig);
        ChannelCfgPtr->BufferDescriptor->TxBuffer = SrcDataBufferPtr;
        ChannelCfgPtr->BufferDescriptor->RxBuffer = DesDataBufferPtr;

        ChannelState->Length = Length;
        SchM_Enter_Spi_UpdateChannelState();
        if (((void *)0) != SrcDataBufferPtr)
        {
            ChannelState->Flags &= (uint8)(~((uint8)0x01U));
        }
        else
        {
            ChannelState->Flags |= ((uint8)0x01U);
        }

        if (((void *)0) != DesDataBufferPtr)
        {
            ChannelState->Flags &= (uint8)(~((uint8)0x02U));
        }
        else
        {
            ChannelState->Flags |= ((uint8)0x02U);
        }
        SchM_Exit_Spi_UpdateChannelState();

    }

    return Ret;
}
# 1970 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Spi_StatusType Spi_GetStatus(void)
{
    Spi_StatusType Status = SPI_IDLE;
    Spi_HWUnitType HWUnit;
    uint32 CoreId;

    CoreId = ((uint32)(0U));

    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        Status = SPI_UNINIT;

        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x06U)), (((uint8)0x1AU)));

    }
    else
    {

        for (HWUnit = 0U; HWUnit < (Spi_HWUnitType)((2U)); HWUnit++)
        {
            if ((((void *)0) != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)) &&
                (CoreId == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->SpiCoreUse))
            {
                if ((1U == Spi_SyncHWUnitsBusyStatus[HWUnit]) ||
                    (SPI_BUSY == Spi_HWUnitQueueArray[HWUnit].Status))
                {
                    Status = SPI_BUSY;
                    break;
                }
            }
        }
    }
    return Status;
}
# 2019 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Spi_JobResultType Spi_GetJobResult(Spi_JobType Job)
{
    Spi_JobResultType JobResult;


    uint32 CoreId;
    CoreId = ((uint32)(0U));
    JobResult = Spi_CheckGetJobResult(CoreId, Job);
    if (SPI_JOB_FAILED != JobResult)
    {

        JobResult = Spi_JobStateArray[Job].Result;

    }


    return JobResult;
}
# 2052 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Spi_SeqResultType Spi_GetSequenceResult(Spi_SequenceType Sequence)
{
    Spi_SeqResultType SequenceResult;

    uint32 CoreId;
    CoreId = ((uint32)(0U));

    SequenceResult = Spi_CheckGetSequenceResult(CoreId, Sequence);
    if (SPI_SEQ_FAILED != SequenceResult)
    {

        SequenceResult = Spi_SequenceStateArray[Sequence].Result;

    }


    return SequenceResult;
}
# 2083 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
void Spi_GetVersionInfo(Std_VersionInfoType *versioninfo)
{

    if (((void *)0) == versioninfo)
    {
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x09U)), (((uint8)0x10U)));
    }
    else
    {

        versioninfo->vendorID = (uint16)0x00B3U;
        versioninfo->moduleID = (uint16)83U;
        versioninfo->sw_major_version = (uint8)1U;
        versioninfo->sw_minor_version = (uint8)2U;
        versioninfo->sw_patch_version = (uint8)0U;

    }

}
# 2118 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Std_ReturnType Spi_SyncTransmit(Spi_SequenceType Sequence)
{
    Spi_SequenceStateType *SequenceState;
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    Spi_HWUnitType HWUnit;
    Spi_JobType JobIndex;
    const Spi_SequenceConfigType *SeqCfgPtr;
    Spi_JobType JobNum;
    Spi_JobType Job;
    const Spi_JobConfigType *JobCfgPtr;
    uint32 CoreId;

    CoreId = ((uint32)(0U));


    Ret = Spi_CheckSyncTransmit(CoreId, Sequence);
    if ((Std_ReturnType)0x01U != Ret)
    {

        SeqCfgPtr = (Spi_ConfigPtr[(CoreId)]->SequenceConfigList[(Sequence)].SeqConfig);
        JobNum = SeqCfgPtr->JobNum;

        SchM_Enter_Spi_UpdateSyncHWUnitStatus();
        for (HWUnit = 0U; HWUnit < (Spi_HWUnitType)((2U)); HWUnit++)
        {
            if (0U !=
                ((Spi_SyncHWUnitsBusyStatus[HWUnit] << HWUnit) & Spi_SeqUsedHWUnits[Sequence]))
            {
                Ret = (Std_ReturnType)0x01U;
            }
        }

        if ((Std_ReturnType)0x01U != Ret)
        {
            SequenceState = &Spi_SequenceStateArray[Sequence];
            SequenceState->Result = SPI_SEQ_PENDING;

            for (JobIndex = 0U; JobIndex < JobNum; JobIndex++)
            {
                Job = SeqCfgPtr->JobIndexList[JobIndex];
                JobCfgPtr = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig);
                HWUnit = JobCfgPtr->HWUnit;
                Spi_SyncHWUnitsBusyStatus[HWUnit] = 1U;
            }
            SchM_Exit_Spi_UpdateSyncHWUnitStatus();
            Ret = Spi_SyncTransmitSequence(SeqCfgPtr, CoreId);

            if ((Std_ReturnType)0x00U == Ret)
            {
                SequenceState->Result = SPI_SEQ_OK;




            }
            else
            {
                SequenceState->Result = SPI_SEQ_FAILED;




            }

            SchM_Enter_Spi_UpdateSyncHWUnitStatus();
            for (JobIndex = 0U; JobIndex < JobNum; JobIndex++)
            {
                Job = SeqCfgPtr->JobIndexList[JobIndex];
                JobCfgPtr = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig);
                HWUnit = JobCfgPtr->HWUnit;
                Spi_SyncHWUnitsBusyStatus[HWUnit] = 0U;
            }
            SchM_Exit_Spi_UpdateSyncHWUnitStatus();

            if (((void *)0) != SeqCfgPtr->EndNotification)
            {
                SeqCfgPtr->EndNotification();
            }
            else
            {

            }
        }
        else
        {
            SchM_Exit_Spi_UpdateSyncHWUnitStatus();

            (void)Det_ReportRuntimeError((uint16)83U, (uint8)0, ((uint8)0x0AU),
                                         ((uint8)0x3AU));

        }

    }


    return Ret;
}
# 2233 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Spi_StatusType Spi_GetHWUnitStatus(Spi_HWUnitType HWUnit)
{
    Spi_StatusType Status = SPI_UNINIT;

    uint32 CoreId = ((uint32)(0U));
    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Ret = Spi_CheckHWUnit(CoreId, HWUnit, ((uint8)0x0BU));
    if ((Std_ReturnType)0x01U != Ret)
    {

        Status = Spi_HWUnitQueueArray[HWUnit].Status;

    }

    return Status;
}
# 2266 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
void Spi_Cancel(Spi_SequenceType Sequence)
{


    uint32 CoreId = ((uint32)(0U));







    Std_ReturnType Ret = (Std_ReturnType)0x00U;

    Ret = Spi_CheckCancel(CoreId, Sequence);
    if ((Std_ReturnType)0x01U != Ret)
    {


        Spi_SequenceStateArray[Sequence].Result = SPI_SEQ_CANCELLED;
# 2297 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
    }

}
# 2316 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Std_ReturnType Spi_SetAsyncMode(Spi_AsyncModeType Mode)
{
    Spi_HWUnitType HWUnit;
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    uint32 CoreId;


    CoreId = ((uint32)(0U));


    if (((void *)0) == (Spi_ConfigPtr[(CoreId)]))
    {
        Ret = (Std_ReturnType)0x01U;
        (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x0DU)), (((uint8)0x1AU)));
    }
    else
    {


        Ret = Spi_GetHWUnitsBusyStatus(CoreId);
        if ((Std_ReturnType)0x01U != Ret)
        {
            for (HWUnit = 0U; HWUnit < (Spi_HWUnitType)((2U)); HWUnit++)
            {
                if ((((void *)0) != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)) &&
                    (CoreId == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->SpiCoreUse) &&
                    ((0U) == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->IsSync))
                {
                    if (SPI_POLLING_MODE == Mode)
                    {
                        Spi_Drvw_SetAsyncMode(HWUnit, SPI_DRVW_POLLING_MODE);
                    }
                    else
                    {
                        Spi_Drvw_SetAsyncMode(HWUnit, SPI_DRVW_INTERRUPT_MODE);
                    }
                }
            }
        }

    }


    return Ret;
}
# 2375 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
Std_ReturnType Spi_SetHWUnitAsyncMode(Spi_HWUnitType HWUnit, Spi_AsyncModeType Mode)
{
    Std_ReturnType Ret = (Std_ReturnType)0x00U;
    uint32 CoreId = ((uint32)(0U));


    Ret = Spi_CheckHWUnit(CoreId, HWUnit, ((uint8)0x60U));

    if ((Std_ReturnType)0x01U != Ret)
    {

        if ((0U) != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->IsSync)
        {
            Ret = (Std_ReturnType)0x01U;

            (void)Det_ReportError((uint16)83U, (uint8)0, (((uint8)0x60U)), (((uint8)0x1AU)));

        }
        else if (SPI_BUSY == Spi_HWUnitQueueArray[HWUnit].Status)
        {
            Ret = (Std_ReturnType)0x01U;
        }
        else
        {
            if (SPI_POLLING_MODE == Mode)
            {
                Spi_Drvw_SetAsyncMode(HWUnit, SPI_DRVW_POLLING_MODE);
            }
            else
            {
                Spi_Drvw_SetAsyncMode(HWUnit, SPI_DRVW_INTERRUPT_MODE);
            }
        }

    }


    return Ret;
}
# 2423 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
void Spi_MainFunction_Handling(void)
{

    Spi_HWUnitType HWUnit;
    uint32 CoreId;

    CoreId = ((uint32)(0U));

    if (((void *)0) != (Spi_ConfigPtr[(CoreId)]))
    {
        for (HWUnit = 0U; HWUnit < (Spi_HWUnitType)((2U)); HWUnit++)
        {
            if ((((void *)0) != (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)) &&
                (CoreId == (Spi_ConfigPtr[(CoreId)]->HWUnitConfigList[(HWUnit)].DrvwHWUnitConfig)->SpiCoreUse))
            {
                if (SPI_BUSY == Spi_HWUnitQueueArray[HWUnit].Status)
                {
                    Spi_Drvw_PollAsyncTransmit(HWUnit);
                }
            }
        }
    }

}
# 2458 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c"
void Spi_ChannelEndCallback(Spi_Drvw_HWUnitType HwUnit, boolean JobResultOK)
{
    uint32 CoreId;
    Spi_ChannelType ChannelIndex;
    Spi_ChannelType NumberOfChannels;
    Spi_ChannelType ChannelNumber;
    Spi_JobType Job;
    const Spi_Drvw_ChannelConfigType *ChannelCfgPtr;
    boolean IsLastChannel;
    const Spi_Drvw_ExternalDeviceConfigType *ExternalDeviceConfig;
    const Spi_JobConfigType *JobCfg;
    Spi_JobResultType JobResult;
    CoreId = ((uint32)(0U));

    ChannelIndex = Spi_HWUnitQueueArray[HwUnit].Channel;
    Job = Spi_HWUnitQueueArray[HwUnit].Job;
    JobCfg = (Spi_ConfigPtr[(CoreId)]->JobConfigList[(Job)].JobConfig);
    NumberOfChannels = JobCfg->ChannelNum;

    if (1U == JobResultOK)
    {
        JobResult = SPI_JOB_OK;
    }
    else
    {
        JobResult = SPI_JOB_FAILED;
    }
    if (((ChannelIndex + 1U) < NumberOfChannels) && (SPI_JOB_OK == JobResult))
    {
        Spi_HWUnitQueueArray[HwUnit].Channel++;
        ChannelIndex++;

        if (ChannelIndex == (NumberOfChannels - 1U))
        {
            IsLastChannel = (boolean)1U;
        }
        else
        {
            IsLastChannel = (boolean)0U;
        }
        ChannelNumber = JobCfg->ChannelIndexList[ChannelIndex];
        ChannelCfgPtr = (Spi_ConfigPtr[(CoreId)]->ChannelConfigList[(ChannelNumber)].ChannelConfig);
        ExternalDeviceConfig = JobCfg->ExternalDeviceConfig->DrvwExternalDeviceConfigPtr;
        (void)Spi_Drvw_TransmitChannel(ChannelCfgPtr, ExternalDeviceConfig, (boolean)0U,
                                       IsLastChannel, (boolean)0U);
    }
    else
    {
        Spi_JobTransferFinished(JobCfg, JobResult);
    }
}



# 1 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h" 1
# 1088 "../../../mcal/Base_ZX_K14xM/Inc/MemMap\\Spi_MemMap.h"
#pragma clang section text = ""
# 2513 "../../../mcal/Spi_ZX_K14xM/Src/Spi.c" 2