//*****************************************************************************
// (C) Automotive Lighting Reutlingen GmbH
//     Tuebinger Strasse 123, 72762 Reutlingen, Germany
//
// Automotive Lighting Reutlingen GmbH owns all the rights to this work.
// This work shall not be copied, reproduced, used, modified, transferred
// or its information shall not be disclosed without the prior written
// authorization of Automotive Lighting Reutlingen GmbH.
//*****************************************************************************

//-----------------------------------------------------------------------------
/// \file  CddMlcNxp.c
///
/// \brief CddMlcNxp functions APIs implementation.
///
/// \descr 
///
//-----------------------------------------------------------------------------

//=============================================================================
// Includes
//=============================================================================
#include <AL_Helper.h>
#include <CddMlcNxp.h>
#include <CddMlcNxp_Reg.h>
#include <CddMlcNxp_Cfg.h>
#include <CddMlcCan.h>
#include <CddMlcCan_Types.h>
#include <CddMlcGen_Coding.h>
#include <CddMlcGen_Cfg.h>
#include "Rte_ctadCddMlc.h"

//=============================================================================
// Coding
//=============================================================================
extern sCddMlcGenCodingData CddMlcGenCodingDataValue;

#define CDD_MLC_CODING_DATA_CONNECTED_DEVICES        (CddMlcGenCodingDataValue.ucMlcMatrixCount)
#define CDD_MLC_CODING_DATA_ACTIVE_CAN_BUS           (CddMlcGenCodingDataValue.ucMlcCanUartInterface)
#ifndef UNIT_TEST
#define CDD_MLC_PHY_CHIP_ID                          ((uint8*)&(CddMlcGenCodingDataValue.ucMlcCanUartAddress))
#endif
#define CDD_MLC_NXP_DEFAULT_PWM                       0U

//=============================================================================
// Defines
//=============================================================================
#define CDD_MLC_NXP_MAX_SUPPORTED_DEVICES                8U
#define CDD_MLC_NXP_RESP_FRAME_WAITING                0x44U
#define CDD_MLC_NXP_RESP_FRAME_RECEIVED               0x55U

//=============================================================================
// Types definition
//=============================================================================
typedef enum
{
	CDD_MLC_NXP_SM_INIT = 0,
	CDD_MLC_NXP_SM_STARTUP_SEQ,
	CDD_MLC_NXP_SM_SEND_PWM_VALUES,
	CDD_MLC_NXP_SM_RECEIVE,
	CDD_MLC_NXP_SM_REFRESH_WD,
	CDD_MLC_NXP_SM_SEND_PWM,
	CDD_MLC_NXP_SM_SEND_DIAG_ADC_TRIGGER,
	CDD_MLC_NXP_SM_SEND_DIAG_REQUEST,
	CDD_MLC_NXP_SM_COLLECT_DIAG_INFO,
	CDD_MLC_NXP_SM_EVAL,
	CDD_MLC_NXP_SM_NORMAL_MODE,
	CDD_MLC_NXP_SM_WRITE_REGISTER_REQUEST,
	CDD_MLC_NXP_SM_READ_REGISTER_REQUEST,
	CDD_MLC_NXP_SM_COLLECT_READ_REGISTER,
	CDD_MLC_NXP_SM_STOP,
	CDD_MLC_NXP_SM_MAX
}eCddMlcNxp_State;

typedef struct
{
	uint8  status;
	uint8  chip;
	uint8  cmd;
	uint8  dlc;
	uint8  data[8];
}CddMlcNxpMsg;

typedef enum
{
	CDD_MLC_NXP_SEG_01 = 0,
	CDD_MLC_NXP_SEG_02,
	CDD_MLC_NXP_SEG_03,
	CDD_MLC_NXP_SEG_04,
	CDD_MLC_NXP_SEG_05,
	CDD_MLC_NXP_SEG_06,
	CDD_MLC_NXP_SEG_07,
	CDD_MLC_NXP_SEG_08,
	CDD_MLC_NXP_SEG_09,
	CDD_MLC_NXP_SEG_10,
	CDD_MLC_NXP_SEG_11,
	CDD_MLC_NXP_SEG_12
}eCddMlcNxp_SegmentId;

typedef struct tsCddMlcNxpReadRegReq
{
	uint8   ucDev;
	uint8   ucReg;
	uint8   ucVal;
	boolean boPerformed;
}tsCddMlcNxpReadRegReq;

typedef struct tsCddMlcNxpWriteRegReq
{
	uint8   ucDev;
	uint8   ucReg;
	uint8   ucVal;
}tsCddMlcNxpWriteRegReq;

typedef uint16 tCddMlcNxp_TargetPwmValues[CDDMLC_MAX_SEGMENT_PER_DEVICE];

typedef void(*pSmFunc)(void);

//=============================================================================
// Private functions declaration
//=============================================================================
STATIC_AL void    CddMlcNxp_BroadcastDummyTrimCmd(void);
STATIC_AL void    CddMlcNxp_BroadcastLHMExitCmd(void);
STATIC_AL void    CddMlcNxp_BroadcastLHMRefreshTimeoutCmd(void);
STATIC_AL void    CddMlcNxp_BroadcastOffCmd(void);
STATIC_AL void    CddMlcNxp_BroadcastPokReadCmd(void);
STATIC_AL void    CddMlcNxp_BroadcastStartCmd(void);
STATIC_AL void    CddMlcNxp_BroadCastClearOcScFlagsCmd(void);
STATIC_AL void    CddMlcNxp_ClearFlagsCmd(uint8 chip);
STATIC_AL void    CddMlcNxp_CollectDiagInformation(void);
STATIC_AL void    CddMlcNxp_Cycle_StartupSequence(void);
STATIC_AL void    CddMlcNxp_DiagnosisReadCmd(void);
STATIC_AL void    CddMlcNxp_EvalDiagInformation(void);
STATIC_AL uint8   CddMlcNxp_GetMlcIndexNumber(uint8 address);
STATIC_AL uint8   CddMlcNxp_GetMlcPhysicalAddress(uint8 deviceIdx);
STATIC_AL void    CddMlcNxp_ReadRegCmd(uint8 chip, uint8 address);
STATIC_AL void    CddMlcNxp_WriteRegCmd(uint8 chip, uint8 address, uint8 ucVal);
STATIC_AL void    CddMlcNxp_ReadGlobalStatusRegsCmd(uint8 chip) ;
STATIC_AL void    CddMlcNxp_SendCommand(CddMlcNxpMsg* pNxpMsg, boolean hasRespFrame);
STATIC_AL void    CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxpMsg* pBuffer, uint8 cmd);
STATIC_AL boolean CddMlcNxp_SetPwmValues(uint8* chip, tCddMlcNxp_TargetPwmValues* pTargetPwmValues);
STATIC_AL void    CddMlcNxp_SetSmState(eCddMlcNxp_State state);
STATIC_AL void    CddMlcNxp_WriteDirectPwmCh1ToCh4Cmd(uint8 chip, uint16 pwm1, uint16 pwm2, uint16 pwm3, uint16 pwm4);
STATIC_AL void    CddMlcNxp_WriteDirectPwmCh5ToCh8Cmd(uint8 chip, uint16 pwm5, uint16 pwm6, uint16 pwm7, uint16 pwm8);
STATIC_AL void    CddMlcNxp_WriteDirectPwmCh9ToCh12Cmd(uint8 chip, uint16 pwm9, uint16 pwm10, uint16 pwm11, uint16 pwm12);
STATIC_AL void    CddMlcNxp_FsmEntryInit(void);
STATIC_AL void    CddMlcNxp_FsmEntryStartupSeq(void);
STATIC_AL void    CddMlcNxp_FsmEntrySendPwmValues(void);
STATIC_AL void    CddMlcNxp_FsmEntrySendDiagReq(void);
STATIC_AL void    CddMlcNxp_FsmEntrySendDiagAdcTrig(void);
STATIC_AL void    CddMlcNxp_FsmEntryCollectDiagReq(void);
STATIC_AL void    CddMlcNxp_FsmEntryEval(void);
STATIC_AL void    CddMlcNxp_FsmEntryWriteRegReq(void);
STATIC_AL void    CddMlcNxp_FsmEntryReadRegReq(void);
STATIC_AL void    CddMlcNxp_FsmEntryCollectReadReg(void);
STATIC_AL void    CddMlcNxp_DiagnosisAdcTrigger(void);
STATIC_AL void    CddMlcNxp_CollectReadReg(void);

//=============================================================================
// Private Variables
//=============================================================================
/* used to store Tx buffers for each MLC chip */
STATIC_AL CddMlcNxpMsg CddMlcNxp_TxBuffer[CDD_MLC_NXP_MAX_SUPPORTED_DEVICES] = { 0 };

/* used to store Rx buffers for each MLC chip */
STATIC_AL CddMlcNxpMsg CddMlcNxp_RxBuffer[CDD_MLC_NXP_MAX_SUPPORTED_DEVICES] = { 0 };

/* used to store the mapping between virtual and physical MLC address */
STATIC_AL uint8 CddMlcNxp_HwDeviceMapping[CDD_MLC_NXP_MAX_SUPPORTED_DEVICES] = { 0 };

/* used to store the collected diag information */
STATIC_AL uCddMlcNxp_DiagReadType CddMlcNxp_DiagRead[CDD_MLC_NXP_MAX_SUPPORTED_DEVICES] = { 0 };

/* used to store the state of the driver state machine */
STATIC_AL eCddMlcNxp_State CddMlcNxp_SmState = CDD_MLC_NXP_SM_INIT;

/* used to store the state of the driver state machine */
STATIC_AL uint8 CddMlcNxp_CurrentVirtualMlcChannel = 0;

/* used to store the target pwm values */
STATIC_AL tCddMlcNxp_TargetPwmValues CddMlcNxp_TargetPwmValues[CDD_MLC_NXP_MAX_SUPPORTED_DEVICES] = { 0 };

/* used to store the state of the MLC's startup sequence */
STATIC_AL boolean CddMlcNxp_boStartupSequencePerformed = FALSE;

/* used to call the state manager of the MLC driver */
/* SEND PWM VALUES EVENT has to be triggered with a period of 50 ms*/
STATIC_AL const pSmFunc* CddMlcNxp_FsmEntries[] =
{
  (const pSmFunc *)&CddMlcNxp_FsmEntryInit,             /* 0  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_INIT                   |  TRIGGERS EVENT: CDD_MLC_NXP_SM_STARTUP_SEQ           */
  (const pSmFunc *)&CddMlcNxp_FsmEntryStartupSeq,       /* 1  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_STARTUP_SEQ            |  TRIGGERS EVENT: CDD_MLC_NXP_SM_SEND_PWM_VALUES       */
  (const pSmFunc *)&CddMlcNxp_FsmEntrySendPwmValues,    /* 2  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_SEND_PWM_VALUES        |  TRIGGERS EVENT: CDD_MLC_NXP_SM_SEND_DIAG_ADC_TRIGGER */
  (const pSmFunc *)NULL,                                /* 3  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_RECEIVE                |  TRIGGERS EVENT:                                      */
  (const pSmFunc *)NULL,                                /* 4  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_REFRESH_WD             |  TRIGGERS EVENT:                                      */
  (const pSmFunc *)NULL,                                /* 5  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_SEND_PWM               |  TRIGGERS EVENT:                                      */
  (const pSmFunc *)&CddMlcNxp_FsmEntrySendDiagAdcTrig,  /* 6  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_SEND_DIAG_ADC_TRIGGER  |  TRIGGERS EVENT: CDD_MLC_NXP_SM_SEND_DIAG_REQUEST     */
  (const pSmFunc *)&CddMlcNxp_FsmEntrySendDiagReq,      /* 7  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_SEND_DIAG_REQUEST      |  TRIGGERS EVENT: CDD_MLC_NXP_SM_COLLECT_DIAG_INFO)    */
  (const pSmFunc *)&CddMlcNxp_FsmEntryCollectDiagReq,   /* 8  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_COLLECT_DIAG_INFO      |  TRIGGERS EVENT: CDD_MLC_NXP_SM_EVAL                  */
  (const pSmFunc *)&CddMlcNxp_FsmEntryEval,             /* 9  TRIGGERED BY EVENT: CDD_MLC_NXP_SM_EVAL                   |  TRIGGERS EVENT: CDD_MLC_NXP_SM_SEND_PWM_VALUES       */
  (const pSmFunc *)NULL,                                /* 10 TRIGGERED BY EVENT: CDD_MLC_NXP_SM_NORMAL_MODE            |  TRIGGERS EVENT:                                      */
  (const pSmFunc *)CddMlcNxp_FsmEntryWriteRegReq,       /* 11 TRIGGERED BY EVENT: CDD_MLC_NXP_SM_WRITE_REGISTER_REQUEST |  TRIGGERS EVENT: CDD_MLC_NXP_SM_SEND_PWM_VALUES       */
  (const pSmFunc *)CddMlcNxp_FsmEntryReadRegReq,        /* 12 TRIGGERED BY EVENT: CDD_MLC_NXP_SM_READ_REGISTER_REQUEST  |  TRIGGERS EVENT: CDD_MLC_NXP_SM_COLELCT_READ_REG      */
  (const pSmFunc *)CddMlcNxp_FsmEntryCollectReadReg,    /* 13 TRIGGERED BY EVENT: CDD_MLC_NXP_SM_COLLECT_READ_REG       |  TRIGGERS EVENT: CDD_MLC_NXP_SM_SEND_PWM_VALUES       */
  (const pSmFunc *)NULL,                                /* 14 TRIGGERED BY EVENT: CDD_MLC_NXP_SM_STOP                   |  TRIGGERS EVENT:                                      */
};

STATIC_AL can_config_type         CddMlcNxp_CanChannelCfg = { 0, 0, 0, 0 };
STATIC_AL boolean                 CddMlcNxp_aboDevComError[CFG_MAX_NO_OF_MLC] = { FALSE };
STATIC_AL boolean                 CddMlcNxp_boBusComError = FALSE;
STATIC_AL tsCddMlcNxpReadRegReq   CddMlcNxp_sReadRegReq;
STATIC_AL tsCddMlcNxpWriteRegReq  CddMlcNxp_sWriteRegReq;
#if (CDDMLC_DEBUG_CODE_INSTRUMENTATION == STD_ON)
STATIC_AL volatile uCddMlcNxp_DiagReadType CddMlcNxp_Diag_Debug_Mirror[CFG_MAX_NO_OF_MLC];
#endif

//=============================================================================
// Macros
//=============================================================================

//-----------------------------------------------------------------------------
/// \brief
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void CddMlcNxp_Init(void)
{
	uint32 CddMlcNxp_UsedPrivateCanChannelCnt = 0U;
	uint32 CddMlcNxp_UsedSatelliteCanChannelCnt = 0U;
	uint8  ucDeviceConnected = 0U;

	/* setup the MLC driver (get config data) */
	for (uint32 device = 0; device < CFG_MAX_NO_OF_MLC; device++)
	{
		if ((uint8)CDD_MLC_PHY_CHIP_ID[device] != MLC_DEV_ADDR_NOT_CONNECTED)
		{
			CddMlcNxp_HwDeviceMapping[ucDeviceConnected] = (uint8)CDD_MLC_PHY_CHIP_ID[device];
			ucDeviceConnected++;
		}
		else
		{
			//Do notghing
		}
	}

	/* check the coding data for the used CAN channels */
	CddMlcNxp_CanChannelCfg.ActiveChannels = CDD_MLC_CODING_DATA_ACTIVE_CAN_BUS;

	/* check for multi-bus CAN communication */
	for (uint32 chip = 0U; chip < 8U; chip++)
	{
		CddMlcNxp_UsedPrivateCanChannelCnt += ((0U == ((CddMlcNxp_CanChannelCfg.ActiveChannels & (1U << chip)) >> chip)) ? 1U : 0U);
		CddMlcNxp_UsedSatelliteCanChannelCnt += ((1U == ((CddMlcNxp_CanChannelCfg.ActiveChannels & (1U << chip)) >> chip)) ? 1U : 0U);
	}

	if ((CddMlcNxp_UsedPrivateCanChannelCnt > 0U) && (CddMlcNxp_UsedSatelliteCanChannelCnt > 0U))
	{
		/* Private and Satellite CAN buses are used at the same time */
		CddMlcNxp_CanChannelCfg.UsedBuses = 2U;
	}
	else if ((CddMlcNxp_UsedPrivateCanChannelCnt > 0U) || (CddMlcNxp_UsedSatelliteCanChannelCnt > 0U))
	{
		/* either Private or Satellite CAN bus is used */
		CddMlcNxp_CanChannelCfg.UsedBuses = 1U;
	}
	else
	{
		/* nothing to do */
	}

	/* init the private can driver */
	CddMlcCan_Init(&CddMlcNxp_CanChannelCfg);
}

//-----------------------------------------------------------------------------
/// \brief
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntryInit(void)
{
	for (uint8 device = 0U; device < CDD_MLC_CODING_DATA_CONNECTED_DEVICES; device++)
	{

		for (uint8 segment = 0U; segment < CDDMLC_MAX_SEGMENT_PER_DEVICE; segment++)
		{
			CddMlcNxp_TargetPwmValues[device][segment] = CDD_MLC_NXP_DEFAULT_PWM;
		}
		//Error with one device on the bus
		CddMlcNxp_aboDevComError[device] = FALSE;
	}
	//Error Bus
	CddMlcNxp_boBusComError = FALSE;
	CddMlcNxp_boStartupSequencePerformed = FALSE;
	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_STARTUP_SEQ);
}

//-----------------------------------------------------------------------------
/// \brief
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntryStartupSeq(void)
{
	CddMlcNxp_Cycle_StartupSequence();
	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_SEND_PWM_VALUES);
}

//-----------------------------------------------------------------------------
/// \brief
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntrySendPwmValues(void)
{
	while (FALSE == CddMlcNxp_SetPwmValues(&CddMlcNxp_CurrentVirtualMlcChannel, (tCddMlcNxp_TargetPwmValues*)CddMlcNxp_TargetPwmValues));
	//{
	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_SEND_DIAG_ADC_TRIGGER);
	((pSmFunc)(CddMlcNxp_FsmEntries[CddMlcNxp_SmState]))();
	//}
}

//-----------------------------------------------------------------------------
/// \brief
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntrySendDiagReq(void)
{
	CddMlcNxp_DiagnosisReadCmd();
	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_COLLECT_DIAG_INFO);
	((pSmFunc)(CddMlcNxp_FsmEntries[CddMlcNxp_SmState]))();
}

//-----------------------------------------------------------------------------
/// \brief
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntrySendDiagAdcTrig(void)
{
	CddMlcNxp_DiagnosisAdcTrigger();
	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_SEND_DIAG_REQUEST);
	((pSmFunc)(CddMlcNxp_FsmEntries[CddMlcNxp_SmState]))();
}

//-----------------------------------------------------------------------------
/// \brief
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntryCollectDiagReq(void)
{
	CddMlcNxp_CollectDiagInformation();
	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_EVAL);
	((pSmFunc)(CddMlcNxp_FsmEntries[CddMlcNxp_SmState]))();
}

//-----------------------------------------------------------------------------
/// \brief
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntryEval(void)
{
	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_SEND_PWM_VALUES);
	CddMlcNxp_EvalDiagInformation();
}
//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_FsmEntryReadRegReq
///
/// \descr
///
/// \param  -
///
/// \return STATIC_AL void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntryReadRegReq(void)
{

	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_COLLECT_READ_REGISTER);
	CddMlcNxp_ReadRegCmd(CddMlcNxp_sReadRegReq.ucDev, CddMlcNxp_sReadRegReq.ucReg);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_FsmEntryWriteRegReq
///
/// \descr
///
/// \param  -
///
/// \return STATIC_AL void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntryWriteRegReq(void)
{
	CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_SEND_PWM_VALUES);
	CddMlcNxp_WriteRegCmd(CddMlcNxp_sWriteRegReq.ucDev, CddMlcNxp_sWriteRegReq.ucReg, CddMlcNxp_sWriteRegReq.ucVal);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_FsmEntryCollectReadReg
///
/// \descr
///
/// \param  -
///
/// \return STATIC_AL void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_FsmEntryCollectReadReg(void)
{
	//static uint8 ucTimeGuardCnt = 0;  //Additional cycle needed, but it should not be needed.
									  //ToDo: Check why additional cycle is needed to get the proper
									  //data from Rx_Buffer
	STATIC_UT(uint8, ucTimeGuardCnt, 0);
	if (ucTimeGuardCnt >= 2U)
	{
		ucTimeGuardCnt = 0U;
		CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_SEND_PWM_VALUES);
		CddMlcNxp_CollectReadReg();
		CddMlcNxp_sReadRegReq.boPerformed = TRUE;
	}
	ucTimeGuardCnt++;
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_Cycle
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void CddMlcNxp_Cycle(void)  // PRQA S 5324 ++ // needed for better understanding of the state machine
{
	if (CddMlcNxp_SmState < CDD_MLC_NXP_SM_MAX && CddMlcNxp_FsmEntries[CddMlcNxp_SmState] != NULL)
	{
		((pSmFunc)(CddMlcNxp_FsmEntries[CddMlcNxp_SmState]))();
	}

	if ((CDD_MLC_NXP_SM_STOP != CddMlcNxp_SmState) && (CDD_MLC_NXP_SM_INIT != CddMlcNxp_SmState))
	{
		/* The driver is in active state */
		if (TRUE == CddMlcNxp_boStartupSequencePerformed)
		{
			/* refresh all MLCs LHM timeout */
			CddMlcNxp_BroadcastLHMRefreshTimeoutCmd();
		}

		/* check can rx buffers */
		CddMlcCan_ReceiveMsg();
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_SetBroadcastCommandIdForAllChips
///
/// \descr
///
/// \param  pBuffer
/// \param  cmd
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxpMsg* pBuffer, uint8 cmd)
{
	for (uint32 chip = 0; chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES; chip++)
	{
		pBuffer[chip].cmd = cmd;
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_GetMlcPhysicalAddress
///
/// \descr
///
/// \param  address
///
/// \return uint8
//-----------------------------------------------------------------------------
STATIC_AL uint8 CddMlcNxp_GetMlcPhysicalAddress(uint8 deviceIdx)
{
	return(CddMlcNxp_HwDeviceMapping[deviceIdx]);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_GetMlcIndexNumber
///
/// \descr
///
/// \param  address
///
/// \return uint8
//-----------------------------------------------------------------------------
STATIC_AL uint8 CddMlcNxp_GetMlcIndexNumber(uint8 address)
{
	uint8 deviceIdx = 0;

	for (deviceIdx = 0; deviceIdx < CDD_MLC_CODING_DATA_CONNECTED_DEVICES; deviceIdx++)
	{
		if (address == CddMlcNxp_HwDeviceMapping[deviceIdx])
		{
			break;
		}
	}
	return(deviceIdx);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_CollectDiagInformation
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_CollectDiagInformation(void)
{
	/* collect diag information */
	for (uint8 chip = 0U; chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES; chip++)
	{
		for (uint8 ucDataIdx = 0U; ucDataIdx < 8U; ucDataIdx++)
		{
			CddMlcNxp_DiagRead[chip].aucRaw[ucDataIdx] = CddMlcNxp_RxBuffer[chip].data[ucDataIdx];
		}
#if (CDDMLC_DEBUG_CODE_INSTRUMENTATION == STD_ON)
		CddMlcNxp_DiagRead[chip] = CddMlcNxp_Diag_Debug_Mirror[chip];
		CddMlcNxp_DiagRead[chip].sReg.Bin.u1LHM_STATUS = 0U;         //Avoid Fail safe reaction
		CddMlcNxp_DiagRead[chip].sReg.Clear.u1POR = 1U;         //
#endif
	}
	//Clear SC OC Flags to be evaluated next cycle
	CddMlcNxp_BroadCastClearOcScFlagsCmd();
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_EvalDiagInformation
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_EvalDiagInformation(void) // PRQA S 5334 ++ // not yet implemented
{
	/* eval diag information and reporting */
  //  static uint8 ucComErrorDebouncing[CFG_MAX_NO_OF_MLC] = {0U}; 
	STATIC_UT(uint8, ucComErrorDebouncing[CFG_MAX_NO_OF_MLC], 0U);
	CddMlcNxp_boBusComError = FALSE;

	for (uint8 ucIdx = 0U; ucIdx < CDD_MLC_CODING_DATA_CONNECTED_DEVICES; ucIdx++)
	{
		/* check the communication status */
		if (((CddMlcNxp_DiagRead[ucIdx].sReg.Bin.u1LHM_STATUS == 1U) || (CddMlcNxp_DiagRead[ucIdx].sReg.Clear.u1POR == 0U))
			&& (CddMlcNxp_aboDevComError[ucIdx] == FALSE)
			&& (CddMlcNxp_boStartupSequencePerformed == TRUE))
		{
			/* communication error detected:
			   - The MLC chip is not supposed to be in the Fail save mode at this state.
			   - The MLC chip bit POR from register CLEAR is not supposed to be 0 at this state.
			   This senario happend when no CAN communication is on going between
			   the ECU and the MLC device */
			ucComErrorDebouncing[ucIdx]++;
			if (ucComErrorDebouncing[ucIdx] >= CDDMLC_DEVCOM_DEBOUNCE) // debounce value has been handled
			{
				CddMlcNxp_aboDevComError[ucIdx] = TRUE;
			}
		}
	}

	uint8 ucDevComErrCnt = 0U;
	for (uint8 ucIdx = 0U; ucIdx < CDD_MLC_CODING_DATA_CONNECTED_DEVICES; ucIdx++)
	{
		if (CddMlcNxp_aboDevComError[ucIdx] == TRUE)
		{
			ucDevComErrCnt++;
		}
	}

	if (ucDevComErrCnt == CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		CddMlcNxp_boBusComError = TRUE;
#if (CDDMLC_DEBUG_REITERATIVE_MODE == STD_OFF)
		CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_STOP);
#else
		CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_INIT);
#endif
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_CollectReadReg
///
/// \descr
///
/// \param  -
///
/// \return STATIC_AL void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_CollectReadReg(void)
{
	//Read first data register which content the reg value requested
	CddMlcNxp_sReadRegReq.ucVal = CddMlcNxp_RxBuffer[CddMlcNxp_sReadRegReq.ucDev].data[0U];
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_SetSmState
///
/// \descr
///
/// \param
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_SetSmState(eCddMlcNxp_State state)
{
	CddMlcNxp_SmState = state;
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_SendCommand
///
/// \descr
///
/// \param  chipAdd
/// \param  cmd
/// \param  data
/// \param  dlc
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_SendCommand(CddMlcNxpMsg* pNxpMsg, boolean hasRespFrame)
{
	const uint32 CddMlcNxp_CanExtendedId = (((uint32)(pNxpMsg->cmd & 0x3FUL) << 5U) | (pNxpMsg->chip & 0x1FUL));
	const uint8 CddMlcNxp_CanBusChannel = (uint8)((CddMlcNxp_CanChannelCfg.ActiveChannels & (1u << pNxpMsg->chip)) >> (pNxpMsg->chip));

	if (TRUE == hasRespFrame)
	{
		CddMlcNxp_RxBuffer[pNxpMsg->chip].status = CDD_MLC_NXP_RESP_FRAME_WAITING;
	}

	if ((CddMlcNxp_CanChannelCfg.UsedBuses == 2U) && (pNxpMsg->cmd >= CDD_MLC_NXP_CMD_BRD_MTP_READ))
	{
		/* brodcast message on both CAN buses */
		(void)CddMlcCan_SendMsg(0U, CAN_TX_MLC_MSG, CddMlcNxp_CanExtendedId, pNxpMsg->dlc, pNxpMsg->data);
		(void)CddMlcCan_SendMsg(1U, CAN_TX_MLC_MSG, CddMlcNxp_CanExtendedId, pNxpMsg->dlc, pNxpMsg->data);
	}
	else
	{
		(void)CddMlcCan_SendMsg(CddMlcNxp_CanBusChannel, CAN_TX_MLC_MSG, CddMlcNxp_CanExtendedId, pNxpMsg->dlc, pNxpMsg->data);
	}
}


//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_ReceivedResponse
///
/// \descr
///
/// \param  chipAdd
/// \param  cmd
/// \param  data
/// \param  dlc
///
/// \return void
//-----------------------------------------------------------------------------
void CddMlcNxp_ReceivedResponse(uint32 canRxch, uint8* data, uint8 dlc)
{
	const uint8 phyChipAdd = (uint8)(canRxch & 0x1FUL);
	const uint8 chip = (uint8)CddMlcNxp_GetMlcIndexNumber(phyChipAdd);

	CddMlcNxp_RxBuffer[chip].status = CDD_MLC_NXP_RESP_FRAME_RECEIVED;
	CddMlcNxp_RxBuffer[chip].chip = phyChipAdd;
	CddMlcNxp_RxBuffer[chip].cmd = CddMlcNxp_TxBuffer[chip].cmd;
	CddMlcNxp_RxBuffer[chip].dlc = dlc;

	for (uint32 cpt = 0U; cpt < 8U; cpt++)
	{
		if (cpt < dlc)
		{
			CddMlcNxp_RxBuffer[chip].data[cpt] = data[cpt];
		}
		else
		{
			CddMlcNxp_RxBuffer[chip].data[cpt] = 0;
		}
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_BroadcastDummyTrimCmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_BroadcastDummyTrimCmd(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 0U;
	CddMlcNxp_TxBuffer[0].data[0] = 0;
	CddMlcNxp_TxBuffer[0].data[1] = 0;
	CddMlcNxp_TxBuffer[0].data[2] = 0;
	CddMlcNxp_TxBuffer[0].data[3] = 0;
	CddMlcNxp_TxBuffer[0].data[4] = 0;
	CddMlcNxp_TxBuffer[0].data[5] = 0;
	CddMlcNxp_TxBuffer[0].data[6] = 0;
	CddMlcNxp_TxBuffer[0].data[7] = 0;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_DUMMY_TRIMMING);

	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0], FALSE);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_BroadcastLHMExitCmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_BroadcastLHMExitCmd(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 3U;
	CddMlcNxp_TxBuffer[0].data[0] = CDD_MLC_NXP_LHM_EXIT_STEP_1;
	CddMlcNxp_TxBuffer[0].data[1] = CDD_MLC_NXP_LHM_EXIT_STEP_2;
	CddMlcNxp_TxBuffer[0].data[2] = CDD_MLC_NXP_LHM_EXIT_STEP_3;
	CddMlcNxp_TxBuffer[0].data[3] = 0;
	CddMlcNxp_TxBuffer[0].data[4] = 0;
	CddMlcNxp_TxBuffer[0].data[5] = 0;
	CddMlcNxp_TxBuffer[0].data[6] = 0;
	CddMlcNxp_TxBuffer[0].data[7] = 0;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_LHM_EXIT);

	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0], FALSE);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_BroadcastLHMRefreshTimeoutCmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_BroadcastLHMRefreshTimeoutCmd(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 1U;
	CddMlcNxp_TxBuffer[0].data[0] = CDD_MLC_NXP_WD_CONFIG;
	CddMlcNxp_TxBuffer[0].data[1] = 0;
	CddMlcNxp_TxBuffer[0].data[2] = 0;
	CddMlcNxp_TxBuffer[0].data[3] = 0;
	CddMlcNxp_TxBuffer[0].data[4] = 0;
	CddMlcNxp_TxBuffer[0].data[5] = 0;
	CddMlcNxp_TxBuffer[0].data[6] = 0;
	CddMlcNxp_TxBuffer[0].data[7] = 0;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_LHM_REFRESH);

	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0], FALSE);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_BroadcastPokReadCmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_BroadcastPokReadCmd(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 0U;
	CddMlcNxp_TxBuffer[0].data[0] = 0U;
	CddMlcNxp_TxBuffer[0].data[1] = 0U;
	CddMlcNxp_TxBuffer[0].data[2] = 0U;
	CddMlcNxp_TxBuffer[0].data[3] = 0U;
	CddMlcNxp_TxBuffer[0].data[4] = 0U;
	CddMlcNxp_TxBuffer[0].data[5] = 0U;
	CddMlcNxp_TxBuffer[0].data[6] = 0U;
	CddMlcNxp_TxBuffer[0].data[7] = 0U;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_POK_REGISTER_READ);

	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0U], FALSE);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_BroadCastClearOcScFlagsCmd
///
/// \descr
///
/// \param  
///
/// \return STATIC_AL void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_BroadCastClearOcScFlagsCmd(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 0U;
	CddMlcNxp_TxBuffer[0].data[0] = 0U;
	CddMlcNxp_TxBuffer[0].data[1] = 0U;
	CddMlcNxp_TxBuffer[0].data[2] = 0U;
	CddMlcNxp_TxBuffer[0].data[3] = 0U;
	CddMlcNxp_TxBuffer[0].data[4] = 0U;
	CddMlcNxp_TxBuffer[0].data[5] = 0U;
	CddMlcNxp_TxBuffer[0].data[6] = 0U;
	CddMlcNxp_TxBuffer[0].data[7] = 0U;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_CLEAR_ALL_OC_SC_FLAGS);
	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0], FALSE);

}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_WriteDirectPwmCh1ToCh4Cmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_WriteDirectPwmCh1ToCh4Cmd(uint8 chip, uint16 pwm1, uint16 pwm2, uint16 pwm3, uint16 pwm4)
{
	if (chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		CddMlcNxp_TxBuffer[chip].chip = (uint8)CddMlcNxp_GetMlcPhysicalAddress(chip);
		CddMlcNxp_TxBuffer[chip].cmd = CDD_MLC_NXP_CMD_SEL_WRITE_DIRECT_PWM_CH_1_2_3_4;
		CddMlcNxp_TxBuffer[chip].dlc = 8U;
		CddMlcNxp_TxBuffer[chip].data[0] = (uint8)(pwm1 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[1] = (uint8)((pwm1 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[2] = (uint8)(pwm2 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[3] = (uint8)((pwm2 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[4] = (uint8)(pwm3 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[5] = (uint8)((pwm3 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[6] = (uint8)(pwm4 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[7] = (uint8)((pwm4 & 0x0F00UL) >> 8U);

		CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[chip], FALSE);
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_WriteDirectPwmCh5ToCh8Cmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_WriteDirectPwmCh5ToCh8Cmd(uint8 chip, uint16 pwm5, uint16 pwm6, uint16 pwm7, uint16 pwm8)
{
	if (chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		CddMlcNxp_TxBuffer[chip].chip = (uint8)CddMlcNxp_GetMlcPhysicalAddress(chip);
		CddMlcNxp_TxBuffer[chip].cmd = CDD_MLC_NXP_CMD_SEL_WRITE_DIRECT_PWM_CH_5_6_7_8;
		CddMlcNxp_TxBuffer[chip].dlc = 8U;
		CddMlcNxp_TxBuffer[chip].data[0] = (uint8)(pwm5 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[1] = (uint8)((pwm5 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[2] = (uint8)(pwm6 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[3] = (uint8)((pwm6 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[4] = (uint8)(pwm7 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[5] = (uint8)((pwm7 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[6] = (uint8)(pwm8 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[7] = (uint8)((pwm8 & 0x0F00UL) >> 8U);

		CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[chip], FALSE);
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_WriteDirectPwmCh9ToCh12Cmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_WriteDirectPwmCh9ToCh12Cmd(uint8 chip, uint16 pwm9, uint16 pwm10, uint16 pwm11, uint16 pwm12)
{
	if (chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		CddMlcNxp_TxBuffer[chip].chip = (uint8)CddMlcNxp_GetMlcPhysicalAddress(chip);
		CddMlcNxp_TxBuffer[chip].cmd = CDD_MLC_NXP_CMD_SEL_WRITE_DIRECT_PWM_CH_9_10_11_12;
		CddMlcNxp_TxBuffer[chip].dlc = 8U;
		CddMlcNxp_TxBuffer[chip].data[0] = (uint8)(pwm9 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[1] = (uint8)((pwm9 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[2] = (uint8)(pwm10 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[3] = (uint8)((pwm10 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[4] = (uint8)(pwm11 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[5] = (uint8)((pwm11 & 0x0F00UL) >> 8U);
		CddMlcNxp_TxBuffer[chip].data[6] = (uint8)(pwm12 & 0x00FFUL);
		CddMlcNxp_TxBuffer[chip].data[7] = (uint8)((pwm12 & 0x0F00UL) >> 8U);

		CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[chip], FALSE);
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_ClearFlagsCmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_ClearFlagsCmd(uint8 chip)
{
	if (chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		CddMlcNxp_TxBuffer[chip].chip = (uint8)CddMlcNxp_GetMlcPhysicalAddress(chip);
		CddMlcNxp_TxBuffer[chip].cmd = CDD_MLC_NXP_CMD_SEL_SELECTIVE_REGISTER_WRITE;
		CddMlcNxp_TxBuffer[chip].dlc = 2U;
		CddMlcNxp_TxBuffer[chip].data[0] = CDD_MLC_NXP_REG_CLEAR;
		CddMlcNxp_TxBuffer[chip].data[1] = CDD_MLC_NXP_CLEAR_FLAG_MASK;
		CddMlcNxp_TxBuffer[chip].data[2] = 0;
		CddMlcNxp_TxBuffer[chip].data[3] = 0;
		CddMlcNxp_TxBuffer[chip].data[4] = 0;
		CddMlcNxp_TxBuffer[chip].data[5] = 0;
		CddMlcNxp_TxBuffer[chip].data[6] = 0;
		CddMlcNxp_TxBuffer[chip].data[7] = 0;

		CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[chip], FALSE);
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_BroadcastStartCmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_BroadcastStartCmd(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 2U;
	CddMlcNxp_TxBuffer[0].data[0] = 0xFF;
	CddMlcNxp_TxBuffer[0].data[1] = 0x0F;
	CddMlcNxp_TxBuffer[0].data[2] = 0;
	CddMlcNxp_TxBuffer[0].data[3] = 0;
	CddMlcNxp_TxBuffer[0].data[4] = 0;
	CddMlcNxp_TxBuffer[0].data[5] = 0;
	CddMlcNxp_TxBuffer[0].data[6] = 0;
	CddMlcNxp_TxBuffer[0].data[7] = 0;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_MLC_CHANNEL_START);

	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0], FALSE);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_BroadcastOffCmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_BroadcastOffCmd(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 2U;
	CddMlcNxp_TxBuffer[0].data[0] = 0xFF;
	CddMlcNxp_TxBuffer[0].data[1] = 0x0F;
	CddMlcNxp_TxBuffer[0].data[2] = 0;
	CddMlcNxp_TxBuffer[0].data[3] = 0;
	CddMlcNxp_TxBuffer[0].data[4] = 0;
	CddMlcNxp_TxBuffer[0].data[5] = 0;
	CddMlcNxp_TxBuffer[0].data[6] = 0;
	CddMlcNxp_TxBuffer[0].data[7] = 0;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_MLC_CHANNEL_IMMEDIATE_OFF);

	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0], FALSE);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_ReadRegCmd
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_ReadRegCmd(uint8 chip, uint8 address) // PRQA S 3219 ++ // needed for future usage
{
	if (chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		CddMlcNxp_TxBuffer[chip].chip = (uint8)CddMlcNxp_GetMlcPhysicalAddress(chip);
		CddMlcNxp_TxBuffer[chip].cmd = CDD_MLC_NXP_CMD_SEL_SELECTIVE_REGISTER_READ;
		CddMlcNxp_TxBuffer[chip].dlc = 1U;
		CddMlcNxp_TxBuffer[chip].data[0] = (uint8)address;
		CddMlcNxp_TxBuffer[chip].data[1] = 0;
		CddMlcNxp_TxBuffer[chip].data[2] = 0;
		CddMlcNxp_TxBuffer[chip].data[3] = 0;
		CddMlcNxp_TxBuffer[chip].data[4] = 0;
		CddMlcNxp_TxBuffer[chip].data[5] = 0;
		CddMlcNxp_TxBuffer[chip].data[6] = 0;
		CddMlcNxp_TxBuffer[chip].data[7] = 0;

		CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[chip], TRUE);
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_WriteRegCmd
///
/// \descr
///
/// \param  chip
/// \param  address
/// \param  val
///
/// \return STATIC_AL void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_WriteRegCmd(uint8 chip, uint8 address, uint8 val) // PRQA S 3219 ++ // needed for future usage
{
	if (chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		CddMlcNxp_TxBuffer[chip].chip = (uint8)CddMlcNxp_GetMlcPhysicalAddress(chip);
		CddMlcNxp_TxBuffer[chip].cmd = CDD_MLC_NXP_CMD_SEL_SELECTIVE_REGISTER_WRITE;
		CddMlcNxp_TxBuffer[chip].dlc = 2U;
		CddMlcNxp_TxBuffer[chip].data[0] = (uint8)address;
		CddMlcNxp_TxBuffer[chip].data[1] = (uint8)val;
		CddMlcNxp_TxBuffer[chip].data[2] = 0;
		CddMlcNxp_TxBuffer[chip].data[3] = 0;
		CddMlcNxp_TxBuffer[chip].data[4] = 0;
		CddMlcNxp_TxBuffer[chip].data[5] = 0;
		CddMlcNxp_TxBuffer[chip].data[6] = 0;
		CddMlcNxp_TxBuffer[chip].data[7] = 0;

		CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[chip], FALSE);
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_ReadGlobalStatusRegsCmd
///
/// \descr
///
/// \param  chip
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_ReadGlobalStatusRegsCmd(uint8 chip)
{
	if (chip < CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		CddMlcNxp_TxBuffer[chip].chip = (uint8)CddMlcNxp_GetMlcPhysicalAddress(chip);
		CddMlcNxp_TxBuffer[chip].cmd = CDD_MLC_NXP_CMD_SEL_SELECTIVE_REGISTER_READ;
		CddMlcNxp_TxBuffer[chip].dlc = 4U;
		CddMlcNxp_TxBuffer[chip].data[0] = CDD_MLC_NXP_REG_CLEAR;
		CddMlcNxp_TxBuffer[chip].data[1] = CDD_MLC_NXP_REG_BIN;
		CddMlcNxp_TxBuffer[chip].data[2] = CDD_MLC_NXP_REG_LHM;
		CddMlcNxp_TxBuffer[chip].data[3] = CDD_MLC_NXP_REG_INTERNAL_STATUS;
		CddMlcNxp_TxBuffer[chip].data[4] = 0;
		CddMlcNxp_TxBuffer[chip].data[5] = 0;
		CddMlcNxp_TxBuffer[chip].data[6] = 0;
		CddMlcNxp_TxBuffer[chip].data[7] = 0;

		CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[chip], TRUE);
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_DiagnosisReadCmd
///
/// \descr
///
/// \param  chip
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_DiagnosisReadCmd(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 0U;
	CddMlcNxp_TxBuffer[0].data[0] = 0;
	CddMlcNxp_TxBuffer[0].data[1] = 0;
	CddMlcNxp_TxBuffer[0].data[2] = 0;
	CddMlcNxp_TxBuffer[0].data[3] = 0;
	CddMlcNxp_TxBuffer[0].data[4] = 0;
	CddMlcNxp_TxBuffer[0].data[5] = 0;
	CddMlcNxp_TxBuffer[0].data[6] = 0;
	CddMlcNxp_TxBuffer[0].data[7] = 0;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_DIAGNOSIS_READ);

	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0], TRUE);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_DiagnosisAdcTrigger
///
/// \descr Send a broadcast command to 
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_DiagnosisAdcTrigger(void)
{
	CddMlcNxp_TxBuffer[0].chip = CDD_MLC_NXP_BROADCAST_ADDRESS;
	CddMlcNxp_TxBuffer[0].dlc = 0U;
	CddMlcNxp_TxBuffer[0].data[0] = 0;
	CddMlcNxp_TxBuffer[0].data[1] = 0;
	CddMlcNxp_TxBuffer[0].data[2] = 0;
	CddMlcNxp_TxBuffer[0].data[3] = 0;
	CddMlcNxp_TxBuffer[0].data[4] = 0;
	CddMlcNxp_TxBuffer[0].data[5] = 0;
	CddMlcNxp_TxBuffer[0].data[6] = 0;
	CddMlcNxp_TxBuffer[0].data[7] = 0;

	CddMlcNxp_SetBroadcastCommandIdForAllChips(CddMlcNxp_TxBuffer, CDD_MLC_NXP_CMD_BRD_DIAGNOSIS_ADC_TRIGGER);

	CddMlcNxp_SendCommand(&CddMlcNxp_TxBuffer[0], TRUE);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_Cycle_StartupSequence
///
/// \descr
///
/// \param  -
///
/// \return int
//-----------------------------------------------------------------------------
STATIC_AL void CddMlcNxp_Cycle_StartupSequence(void)
{
	if (FALSE == CddMlcNxp_boStartupSequencePerformed)
	{

		/* send 3 dummy trimming requests */
		CddMlcNxp_BroadcastDummyTrimCmd();
		CddMlcNxp_BroadcastDummyTrimCmd();
		CddMlcNxp_BroadcastDummyTrimCmd();

		/* exit the limp home mode */
		CddMlcNxp_BroadcastLHMExitCmd();

		/* configure and refresh the internal watchdog */
		CddMlcNxp_BroadcastLHMRefreshTimeoutCmd();
		CddMlcNxp_BroadcastPokReadCmd();

		/* clear the internal flags */
		for (uint32 device = 0; device < CDD_MLC_CODING_DATA_CONNECTED_DEVICES; device++)
		{
			CddMlcNxp_ClearFlagsCmd(device);
		}

		/* turn all channels off */
		CddMlcNxp_BroadcastOffCmd();

		/* set default PWMs to 0% */
		CddMlcNxp_WriteDirectPwmCh1ToCh4Cmd(0, 0U, 0U, 0U, 0U);
		CddMlcNxp_WriteDirectPwmCh5ToCh8Cmd(0, 0U, 0U, 0U, 0U);
		CddMlcNxp_WriteDirectPwmCh9ToCh12Cmd(0, 0U, 0U, 0U, 0U);

		/* turn all channels on */
		CddMlcNxp_BroadcastStartCmd();

		/* read internal registers */
		CddMlcNxp_DiagnosisReadCmd();

		/* set the flag */
		CddMlcNxp_boStartupSequencePerformed = TRUE;
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_SetPwmValues
///
/// \descr
///
/// \param  chip
/// \param  pTargetPwmValues
///
/// \return void
//-----------------------------------------------------------------------------
//ToDo: Function needs rework 
STATIC_AL boolean CddMlcNxp_SetPwmValues(uint8* chip, tCddMlcNxp_TargetPwmValues* pTargetPwmValues)
{
	boolean boIsDone = FALSE;
	//If no communication with device after debouncing, do not send request to device
	if (CddMlcNxp_aboDevComError[*chip] == FALSE)
	{
		CddMlcNxp_WriteDirectPwmCh1ToCh4Cmd(*chip, pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_01],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_02],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_03],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_04]);

		CddMlcNxp_WriteDirectPwmCh5ToCh8Cmd(*chip, pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_05],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_06],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_07],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_08]);

		CddMlcNxp_WriteDirectPwmCh9ToCh12Cmd(*chip, pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_09],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_10],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_11],
			pTargetPwmValues[*chip][CDD_MLC_NXP_SEG_12]);
	}

	/* increment the virtual device address */
	if (++(*chip) >= CDD_MLC_CODING_DATA_CONNECTED_DEVICES)
	{
		*chip = 0;
		boIsDone = TRUE;
	}

	return(boIsDone);
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_GetTargetBufAddress
///
/// \descr
///
/// \param  -
///
/// \return uint16 *
//-----------------------------------------------------------------------------
uint16* CddMlcNxp_GetTargetBufAddress(void)
{
	return((uint16*)CddMlcNxp_TargetPwmValues); // PRQA S 310 1 // object is aligned to 16 bit
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_SetTransmissionToInactive
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void CddMlcNxp_SetTransmissionToInactive(void)
{
	// Set the driver System Mode to inactive
	CddMlcNxp_SmState = CDD_MLC_NXP_SM_STOP;
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_SetTransmissionToNormal
///
/// \descr
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void CddMlcNxp_SetTransmissionToNormal(void)
{
	// Set the driver System Mode to normal (initialization is needed for NXP chip)
	CddMlcNxp_SmState = CDD_MLC_NXP_SM_INIT;
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_GetSensorInfo
///
/// \descr
///
/// \param  ucExtResistor
/// \param  ucDevCnt
///
/// \return void
//-----------------------------------------------------------------------------
void CddMlcNxp_GetSensorInfo(tisMlcSensorInput* pucExtResistor, uint8 ucDevCnt)
{
  if (ucDevCnt <= CFG_MAX_NO_OF_MLC)
  {
    for (uint8 ucIdx = 0U; ucIdx < ucDevCnt; ucIdx++)
    {
      pucExtResistor[ucIdx].ucADC1Raw    = (uint8)CddMlcNxp_DiagRead[ucIdx].sReg.Ntc.u6NTC;
      pucExtResistor[ucIdx].eADC1RawQty  = ((CddMlcNxp_DiagRead[ucIdx].sReg.Ntc.u1NTCFAIL == 0u) && (CddMlcNxp_DiagRead[ucIdx].sReg.Ntc.u1CPFAIL == 0u)) ? SIG_VALID : SIG_INVALID;
      pucExtResistor[ucIdx].ucADC2Raw    = (uint8)CddMlcNxp_DiagRead[ucIdx].sReg.Bin.u3BIN;
      pucExtResistor[ucIdx].eADC2RawQty  = (CddMlcNxp_aboDevComError[ucIdx] == FALSE) ? SIG_VALID : SIG_INVALID;
    }
  }
}


//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_GetSwitchsFault
///
/// \descr
///
/// \param  pusSwitchFault
/// \param  ucDevCnt
/// \param  ucSwitchCnt
///
/// \return void
//-----------------------------------------------------------------------------
void CddMlcNxp_GetSwitchsFault(tsCddMlcSwitchFaultArray asSwitchFaultArray, uint8 ucDevCnt, uint8 ucSwitchCnt)
{
	if ((ucDevCnt <= CFG_MAX_NO_OF_MLC) && (ucSwitchCnt <= CDD_MLC_NXP_MAX_SWITCHS_PER_DEVICE))
	{
		for (uint8 ucDevIdx = 0; ucDevIdx < ucDevCnt; ucDevIdx++)
		{
			//Open Circuit - Short Circuit detection for every Segment. Nxp supports only 12 segments out of 16 (max by the generic driver)
			for (uint8 ucSwitchIdx = 0; ucSwitchIdx < ucSwitchCnt; ucSwitchIdx++)
			{
				if (ucSwitchIdx <= (CDD_MLC_NXP_XC1_LAST_SW - 1U))
				{
					asSwitchFaultArray[ucDevIdx][ucSwitchIdx].boOpenCircuit = (CddMlcNxp_DiagRead[ucDevIdx].sReg.ReadOc1.ucRaw  & (1U << ucSwitchIdx)) != 0U ? FLT_YES : FLT_NO;
					asSwitchFaultArray[ucDevIdx][ucSwitchIdx].boShortCircuit = (CddMlcNxp_DiagRead[ucDevIdx].sReg.ReadSc1.ucRaw  & (1U << ucSwitchIdx)) != 0U ? FLT_YES : FLT_NO;
				}
				else if (ucSwitchIdx <= CDD_MLC_NXP_XC2_LAST_SW - 1U)
				{
					asSwitchFaultArray[ucDevIdx][ucSwitchIdx].boOpenCircuit = (CddMlcNxp_DiagRead[ucDevIdx].sReg.ReadOc2.ucRaw  & (1U << (ucSwitchIdx - CDD_MLC_NXP_XC1_LAST_SW))) != 0U ? FLT_YES : FLT_NO;
					asSwitchFaultArray[ucDevIdx][ucSwitchIdx].boShortCircuit = (CddMlcNxp_DiagRead[ucDevIdx].sReg.ReadSc2.ucRaw  & (1U << (ucSwitchIdx - CDD_MLC_NXP_XC1_LAST_SW))) != 0U ? FLT_YES : FLT_NO;
				}
				else
				{
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_GetBusComError
///
/// \descr
///
/// \param  -
///
/// \return boolean
//-----------------------------------------------------------------------------
boolean CddMlcNxp_GetBusComError(void)
{
	return CddMlcNxp_boBusComError;
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_GetDeviceStatusFault
///
/// \descr
///
/// \param  pusDevStatusFault
/// \param  ucDevCnt
///
/// \return void
//-----------------------------------------------------------------------------
void CddMlcNxp_GetDeviceStatusFault(tsCddMlcDeviceStatusFault* pusDevStatusFault, uint8 ucDevCnt)
{
	if (ucDevCnt <= CFG_MAX_NO_OF_MLC)
	{
		for (uint8 ucIdx = 0U; ucIdx < ucDevCnt; ucIdx++)
		{
			pusDevStatusFault[ucIdx].boCommunicationError = CddMlcNxp_aboDevComError[ucIdx];
			pusDevStatusFault[ucIdx].boTemperatureWarning = (CddMlcNxp_DiagRead[ucIdx].sReg.Bin.u1OTW_2 == 1U) ? TRUE : FALSE;
			pusDevStatusFault[ucIdx].boReset = ((CddMlcNxp_SmState == CDD_MLC_NXP_SM_INIT) || (CddMlcNxp_SmState == CDD_MLC_NXP_SM_STOP)) ? TRUE : FALSE;
		}
	}
}

//-----------------------------------------------------------------------------
/// \brief CddNxp_RegWrite
///
/// \descr Trigger Register Write Command
///
/// \param  ucDevAdr
/// \param  ucRegAdr
/// \param  ucData
///
/// \return boolean
//-----------------------------------------------------------------------------
boolean CddMlcNxp_RegWriteRequest(uint8 ucDev, uint8 ucReg, uint8 ucData)
{
	boolean boRetVal = FALSE;
	if (ucDev < CFG_MAX_NO_OF_MLC)
	{
		//The driver is in active state 
		if ((CddMlcNxp_SmState != CDD_MLC_NXP_SM_STOP) && (CddMlcNxp_boStartupSequencePerformed == TRUE) && (CddMlcNxp_aboDevComError[ucDev] == FALSE))
		{
			CddMlcNxp_sWriteRegReq.ucDev = ucDev;
			CddMlcNxp_sWriteRegReq.ucReg = ucReg;
			CddMlcNxp_sWriteRegReq.ucVal = ucData;
			boRetVal = TRUE;
			CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_WRITE_REGISTER_REQUEST);
		}
	}
	return boRetVal;
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_RegReadRequest
///
/// \descr Trigger Register Read Command
///
/// \param  ucDevAdr
/// \param  ucRegAdr
///
/// \return boolean
//-----------------------------------------------------------------------------
boolean CddMlcNxp_RegReadRequest(uint8 ucDev, uint8 ucReg)
{
	boolean boRetVal = FALSE;
	if (ucDev < CFG_MAX_NO_OF_MLC)
	{
		if ((CddMlcNxp_SmState != CDD_MLC_NXP_SM_STOP) && (CddMlcNxp_boStartupSequencePerformed == TRUE) && (CddMlcNxp_aboDevComError[ucDev]) == FALSE)
		{
			boRetVal = TRUE;
			CddMlcNxp_sReadRegReq.ucDev = ucDev;
			CddMlcNxp_sReadRegReq.ucReg = ucReg;
			CddMlcNxp_SetSmState(CDD_MLC_NXP_SM_READ_REGISTER_REQUEST);
		}
		else
		{
			boRetVal = FALSE;
		}
	}

	CddMlcNxp_sReadRegReq.boPerformed = FALSE;

	return boRetVal;
}

//-----------------------------------------------------------------------------
/// \brief CddMlcNxp_GetRegRead
///
/// \descr
///
/// \param  ucVal
///
/// \return boolean
//-----------------------------------------------------------------------------
boolean CddMlcNxp_GetRegRead(uint8* ucVal)
{
	*ucVal = CddMlcNxp_sReadRegReq.ucVal;

	return CddMlcNxp_sReadRegReq.boPerformed;
}