#include "system_cfg.h"
#include "sysDef.h"
#include "tl2cdr.h"
#include "halfLvdsMacSvr.h"
#include "plic.h"

//-------------------------------------------------------------------
uint8_t MST_TX_BUF[TX_BUF_NUM * TX_BUF_MAX_LEN] __attribute__((aligned(32)));
uint8_t MST_RX_BUF[RX_BUF_NUM * RX_BUF_MAX_LEN] __attribute__((aligned(32)));


//-------------------------------------------------------------------
extern const uint8_t int_svr_code[];
uint32_t (*sys_call)(uint32_t no, ...);




static uint32_t HLM_slave_poll(void);

volatile uint32_t isr_flag[32] = {0};

uint32_t HLM_poll(uint32_t mode)
{
	sys_call = (void *)int_svr_code;
	//复位脉冲
	*tx0_softReset = 1;
	*tx1_softReset = 1;
	*rx0_softReset = 1;
	*rx1_softReset = 1;


	if (mode == WORKMODE_MASTER)
	{
		uint32_t tx_pkt_len = 1024;
		uint32_t rx_pkt_len = 0;
		uint32_t rx_start = 0;
		uint32_t status;

		uint32_t i;
		uint32_t *tx_data_ptr = (uint32_t *)MST_TX_BUF;
		uint32_t *rx_data_ptr = (uint32_t *)MST_RX_BUF;


		//准备数据
		for (i = 0; i < tx_pkt_len; i++)
			MST_TX_BUF[i] = i;

		
        //开始发送工作
        *tx0_txLen = tx_pkt_len + 4;
		*tx0_txFifo = (tx_pkt_len << 20) | 0;
		
		uint32_t tx_index = 0;
		uint32_t rx_index = 0;

		for (i = 0; i < HLM_TX_FIFO_LEN - 1; i++)
		{
			if ((tx_index * 4) < tx_pkt_len)
			{
				*tx0_txFifo = tx_data_ptr[tx_index];
				tx_index++;
			}
			else
				break;
		}

		while (1)
		{
			status = *HLM_status;

			for (i = 0; i < HLM_TX_FIFO_LEN - HLM_TX0_FIFO_LEFT(status); i++)
			{
				if ((tx_index * 4) < tx_pkt_len)
				{
					*tx0_txFifo = tx_data_ptr[tx_index];
					tx_index++;
				}
				else
					break;
			}

			for (i = 0; i < HLM_RX1_FIFO_LEFT(status); i++)
			{
				//if ((rx_start) && (status & HLM_RX1_VALID))
				if (rx_start)
				{
					rx_data_ptr[rx_index] = *rx1_rxFifo;
					if (rx_index == 0)
						rx_pkt_len = (rx_data_ptr[rx_index] >> 20) + 4;

					rx_index++;
					
					if (rx_pkt_len <= (rx_index * 4))
					{
						rx_start = 0;
						rx_index = 0;
						break;
					}
				}
			}

			if (isr_flag[CDR_INT_RX1START])
			{
				isr_flag[CDR_INT_RX1START] = 0;
				rx_start = 1;
				rx_index = 0;
			}
		}
	}
	else if (mode == WORKMODE_SLAVE)
	{
		HLM_slave_poll();
	}
	else
	{

	}
	return 0;
}

#define DETECT_DEVICE_PKT_LEN			4
#define DETECT_DEVICE_PKT_TX_LEN		(DETECT_DEVICE_PKT_LEN + 4)
#define MAGIC_NUM						0xa53fd1a0U
uint32_t HLM_slave_poll(void)
{
	uint32_t rx_index = 0;
	uint32_t tx_pkt_len;
	uint32_t rx_pkt_len = 0;
	
	uint32_t down_rx_start = 0;
	uint32_t detect_start = 0;

	uint32_t status;
	uint32_t is_terminal = 1;
	
	//填充检测下行设备的包
	uint32_t detect_pkt = MAGIC_NUM;

	int i;
	
	*rx0_rxTxPair = 1;
	*rx0_rxTimerAim = 0; //240;
	*rx1_rxTxPair = 0;
	*rx1_rxTimerAim = 0;
	*plic_enable_0_31 = 0;



	#ifdef __riscv_e
	sys_call(SYS_SLAVE_WORK);
	#else
	
	


	while (1)
	{
		if (is_terminal)
		{//是终节点
			status = *HLM_status;
			if ((!down_rx_start) && (status & HLM_RX0_VALID))
				down_rx_start = 1;

			for (i = 0; i < HLM_RX0_FIFO_LEFT(status); i++)
			{
				if (down_rx_start) // && (status & HLM_RX0_VALID))
				{//处理上行接收
					uint32_t data;
					data = *rx0_rxFifo;
					if (rx_index == 0)
					{
						rx_pkt_len = (data >> 20) + 4;
						*tx1_txLen = rx_pkt_len;
					}
		
					rx_index++;
					*tx1_txFifo = data;
					if (rx_pkt_len <= (rx_index * 4))
					{
						down_rx_start = 0;
						break;
					}
					if ((rx_index & 0x1f) == 10)
						detect_start = 1;
				}
				else
					break;
			}

			if (detect_start)
			{
				*tx0_txLen  = DETECT_DEVICE_PKT_TX_LEN;
				*tx0_txFifo = (DETECT_DEVICE_PKT_LEN << 20) | 1;
				*tx0_txFifo = detect_pkt;
				detect_start = 0;
			}

			if (status & HLM_RX1_VALID)
			{
				uint32_t data;
				uint32_t num;
				data = *rx1_rxFifo;
				num  = *rx1_rxFifo;
				if ((data & 0x1) && (num == MAGIC_NUM))
				{
					*rx1_softReset = 1;
					*tx0_softReset = 1;
				}
			}
		}
		else
		{//不是终节点

		}
	}

	#endif
}