/** ##########################################################################
**     Filename  :
**     Project   :
**     Module    :
**     Processor :
**     Version   :
**     Compiler  :
**     Date/Time :
**     Abstract  :
**     Contents  :
**     Note      :
**
**     (c) Copyright dmdz Co.,Ltd
**  --------------------------------------------------------------------------
**               R E V I S I O N   H I S T O R Y
**  --------------------------------------------------------------------------
**  Date       Ver   Author             Description

**  -20230602-  --V1.0--  --mingyea---  --修改--

** #########################################################################*/

/*---------------------------------------------------------------------------
- I N C L U D E   F I L E S
----------------------------------------------------------------------------*/
#include "common_types.h"
#include "Cpu.h"
#include "common_memory.h"
#include "Ls_Nm.h"
#if 0
#include "CanIf_Type.h"
#include "CanTrcv.h"
#include "CanIf.h"
#include "Com.h"
#include "wdog.h"
#include "Demm.h"
#include "can.h"
#include "Com.h"
#include "flexcan_hw_access.h"
#include "Demm.h"
#endif
#include "bl_can.h"
#include "bl_can_transceiver.h"
#include "bl_can_if.h"


#define CAN_LS_EN  //临时用


/*---------------------------------------------------------------------------
- D E F I N E S / M A C R O S
----------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------
- T Y P E   D E F I N I T I O N S
----------------------------------------------------------------------------*/
/*busoff*/
typedef struct
{
	u8 flag_busoff;
	nm_busoff_recovery_state_e state;  //主状态--未busoff，快恢复，慢恢复
	u16 timecount;
	u16 try_count;
}can_nm_busoff_s;

/**/
typedef struct
{
	can_nm_busoff_s busoff[CAN_ID_TOTAL];

	#ifdef LS_NM_DEBUG_EN
	u8 test_buf[15];
	#endif
}can_nm_s;

static can_nm_s g_ls_nm;

//static u8 g_nm_test1[10] ;

/*---------------------------------------------------------------------------
- S T A T I C   V A R I A B L E S
----------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
* G L O B A L   V A R I A B L E S
----------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------
- C O N S T A N T S
----------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------
- F U N C T I O N   P R O T O T Y P E
----------------------------------------------------------------------------*/
static void can_nm_phy_busoff_trig(u8 phy_id);
static void can_nm_busoff_recovery_task(u8 phy_id);
static void can_nm_busoff_recovery_successful(u8 phy_id);
static void can_nm_phy_busoff_pre_trig(u8 phy_id);
static void can_nm_busoff_recovery_op(u8 phy_id);



/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
static void can_nm_phy_busoff_pre_trig(u8 phy_id)
{
	//u8 i;
	if(phy_id == CAN_ID_0)
	{
		#ifdef CAN_ID_0_EN
		//for(i=0;i<CAN_ID_0_TX_MAILBOX_ID_MAX;i++)
		{
			//CAN_AbortTransmission(CAN0,CAN_TRANSMIT_SECONDARY);  //mingyea
			FL_CAN_DisableIT_TXOK(CAN);
		}
		#endif
	}
	else if(phy_id == CAN_ID_1)
	{
		#ifdef CAN_ID_1_EN
		//for(i=0;i<CAN_ID_1_TX_MAILBOX_ID_MAX;i++)
		{
			//CAN_AbortTransmission(CAN1,CAN_TRANSMIT_SECONDARY);
		}
		#endif
	}
	#ifdef LS_NM_DEBUG_EN
		g_ls_nm.test_buf[7]++;
	#endif
}

/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
static void can_nm_phy_busoff_trig(u8 phy_id)
{
	if(phy_id>=CAN_ID_TOTAL)
	{
		return;
	}
	g_ls_nm.busoff[phy_id].flag_busoff=1u;
}

/*---------------------------------------------------------------------------
|Prototype         :
|Called by         :
|Preconditions     : -
|Input parameters  : None
|Output parameters : None
|Return value      : None
|Description       : 在busoff时重试
----------------------------------------------------------------------------*/
static void can_nm_busoff_recovery_op(u8 phy_id)
{
	u8 l_logic_id;
	#ifdef CAN_LS_EN
	l_logic_id = can_drive_get_logic_id(phy_id);
	#else
	l_logic_id = CAN_ID_0;
	#endif
	//wdog_task();
	//__disable_irq();
	LS_NM_TEST_IO_ON();
	CanTrcv_Init();
	//can_de_init();
	//can_init();
	Can_Deinit();
	Can_Init();
	LS_NM_TEST_IO_OFF();
	//__enable_irq();
}


#if 0 //用来测试主动发
void can_nm_test_tx(void)
{
	bl_u8_t i;
	bl_u8_t l_buf[8u];

	for(i=0;i<8;i++)
	{
		l_buf[i] = 0x11u;
	}
	//for(i=8;i<ADPT_UDS_MAX_CAN_FRAME_SIZE;i++)
	{
		//l_buf[i] = CANTP_FRAME_PADDING_VALUE;
	}
	(void)Canif_Write(0u, 8, l_buf);  //ADPT_UDS_TX_HANDLE=0u
}
#endif

/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
static void can_nm_busoff_recovery_task(u8 phy_id)
{
	u8 l_logic_id = CAN_ID_NULL;
	//CAN_Type * const l_flexcanBasePtr[] = CAN_BASE_PTRS;
	#ifdef CAN_LS_EN
	l_logic_id = can_drive_get_logic_id(phy_id);
	#else
	l_logic_id = CAN_ID_0;
	#endif
	if((phy_id>=CAN_ID_TOTAL) || (l_logic_id==CAN_ID_NULL) )
	{
		return;
	}
	if(g_ls_nm.busoff[phy_id].state == NM_BUSOFF_RECOVERY_STATE_NULL)
	{
		g_ls_nm.busoff[phy_id].timecount=0u;
		g_ls_nm.busoff[phy_id].try_count=0u;
	}
	else
	{
		g_ls_nm.busoff[phy_id].timecount++;
		if(g_ls_nm.busoff[phy_id].timecount >=NM_MAIN_BUSOFF_FAST_H)
		{
			g_ls_nm.busoff[phy_id].timecount=0u;
			#ifdef LS_NM_DEBUG_EN
			g_ls_nm.test_buf[2]++;
			#endif
			//g_ls_nm.busoff.sub_state=1u;
			can_nm_busoff_recovery_op(phy_id);
		}
	}
}

/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
static void can_nm_busoff_recovery_successful(u8 phy_id)
{
	if(phy_id>=CAN_ID_TOTAL)
	{
		return;
	}
	if(g_ls_nm.busoff[phy_id].state != NM_BUSOFF_RECOVERY_STATE_NULL)
	{
		g_ls_nm.busoff[phy_id].timecount =0;
		g_ls_nm.busoff[phy_id].try_count =0;

		g_ls_nm.busoff[phy_id].state =NM_BUSOFF_RECOVERY_STATE_NULL;
		#ifdef LS_NM_DEBUG_EN
			g_ls_nm.test_buf[10]++;
		#endif
	}
}


/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
void ls_nm_Init(void)
{
	common_memory_clear((u8*)&g_ls_nm,sizeof(g_ls_nm));
	#ifdef CAN_LS_EN
	CanTrcv_Init();
	#endif
}



/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
void ls_nm_task(void)
{
	NM_CPU_SR_ALLOC();

	NM_ENTER_CRITICAL();

	//can_nm_test_tx();

	if(g_ls_nm.busoff[CAN_ID_0].flag_busoff == 1u)
	{
		g_ls_nm.busoff[CAN_ID_0].flag_busoff=0u;
		//
		if(g_ls_nm.busoff[CAN_ID_0].state == NM_BUSOFF_RECOVERY_STATE_NULL)
		{
			//g_ls_nm.busoff[CAN_ID_0].timecount=0u;
			g_ls_nm.busoff[CAN_ID_0].state = NM_BUSOFF_RECOVERY_STATE_QUICK;
		}
	}

	#ifdef CAN_ID_0_EN
	can_nm_busoff_recovery_task(CAN_ID_0);
	#endif

	NM_EXIT_CRITICAL();
}


/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
u8 CanNm_PhysErrorInd(u8 phy_id,nm_erro_source_e erro)
{
	u8 retValue;
	NM_CPU_SR_ALLOC();

	//g_nm_test1[1]++;
	if( erro == NM_DLL_BUS_OFF)
	{
		//g_nm_test1[2]++;
		NM_ENTER_CRITICAL();
		can_nm_phy_busoff_trig(phy_id);
		NM_EXIT_CRITICAL();

	}
	else if( erro == NM_DLL_ERROR_PASSIVE)
	{
		//g_nm_test1[3]++;
	}
	else if( erro == NM_DLL_ERROR_ACTIVE)
	{
		//g_nm_test1[4]++;
	}
	else if( erro == NM_DLL_BUS_OFF_PRE)
	{
		can_nm_phy_busoff_pre_trig(phy_id);
	}

	return retValue;

}



/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
u8 CanNm_is_busoff(void)
{
	u8 l_result = LS_NM_IS_NOT_BUSOFF;

	NM_CPU_SR_ALLOC();

	NM_ENTER_CRITICAL();
	#if 1
	if( g_ls_nm.busoff[CAN_ID_0].state == NM_BUSOFF_RECOVERY_STATE_NULL
			 )
	{
		l_result = LS_NM_IS_NOT_BUSOFF;
	}
	else
	{
		l_result = LS_NM_IS_BUSOFF;
	}
	#else
	if( (g_ls_nm.state == NM_MAIN_STATE_ACTIVE)   \
			 &&  (g_ls_nm.sub_state != NM_SUB_STATE_ACTIVE_BUSOFF)   \
			  &&  (g_ls_nm.busoff[CAN_ID_0].state == NM_BUSOFF_RECOVERY_STATE_NULL)
			  //&&  (g_ls_nm.busoff[CAN_ID_1].state == NM_BUSOFF_RECOVERY_STATE_NULL)
			 )
	{
		l_result = LS_NM_IS_NOT_BUSOFF;
	}
	else
	{
		l_result = LS_NM_IS_BUSOFF;
	}
	#endif

	NM_EXIT_CRITICAL();

	return l_result;

}




/*---------------------------------------------------------------------------
|Prototype			:
|Called by			:
|Preconditions		:
|Input parameters	:
|Output parameters	:
|Return value		:
|Description		:
----------------------------------------------------------------------------*/
void CanNm_TxConfirmation_com(PduIdType canNmPduId,u8 phy_id)
{
	NM_CPU_SR_ALLOC();
	(void)canNmPduId;

	{
		//g_nm_test1[8]++;
		NM_ENTER_CRITICAL();
		can_nm_busoff_recovery_successful(phy_id);
		NM_EXIT_CRITICAL();
	}

}