#include "system_cfg.h"
#include "sysDef.h"
#include "tl2cdr.h"
#include "halfLvdsMacSvr.h"
#include "plic.h"
#include "clint.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 exti_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 is_exit = 0;

		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 (!is_exit)
		{
			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;
						is_exit = 1;
						break;
					}
				}
			}

			if (exti_isr_flag[CDR_INT_RX1START])
			{
				exti_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
#define DETECT_DEV_INTERVAL				((200)/CLINT_MTIME_TICK_PERIOD)

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_work = 0;
	uint32_t detect_work = 0;

	uint32_t hlm_status;
	uint32_t is_terminal = 1;
	uint32_t detect_result = 0;

	uint64_t stamp_time;
	uint64_t cur_time;
	
	//填充检测下行设备的包
	uint32_t detect_pkt = MAGIC_NUM;

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


	stamp_time = read_mtimer();
	//set_mtimer(150);
	//enable_mtimer_int();
	

	#ifdef __riscv_e
	sys_call(SYS_SLAVE_WORK);
	#else

	while (1)
	{
		if (is_terminal)
		{//是终节点
			hlm_status = *HLM_status;
			if ((!down_rx_work) && (hlm_status & HLM_RX0_VALID))
			{
				down_rx_work = 1;
			}

			for (i = 0; i < HLM_RX0_FIFO_LEFT(hlm_status); i++)
			{
				uint32_t data;
				if (down_rx_work)
				{//处理上行接收
					
					data = *rx0_rxFifo;
					if (rx_index == 0)
					{
						rx_pkt_len = (data >> 20) + 4;
						*tx1_txLen = rx_pkt_len;
						//rx_pkt_len += 4; //最后是一个0,接收入队列，但不写入tx_fifo
					}
		
					rx_index++;
					
					if (rx_pkt_len >= (rx_index * 4))
					{
						*tx1_txFifo = data;
					}
					else
					{
						down_rx_work = 0;
						rx_index = 0;
						//*rx0_softReset = 1;
						break;
					}
				}
				else
					break;
			}

			if (down_rx_work == 0)
			{
				if ((detect_work == 1))
				{
					detect_work = 2;

					*tx0_txLen  = (DETECT_DEVICE_PKT_TX_LEN);
					*tx0_txFifo = ((DETECT_DEVICE_PKT_LEN << 20) | 1);
					*tx0_txFifo = detect_pkt;
				}

				if ((detect_work == 2) && (HLM_RX1_FIFO_LEFT(hlm_status) >= 2))
				{
					uint32_t data;
					uint32_t num;
					uint32_t dummy;

					data = *rx1_rxFifo;
					num  = *rx1_rxFifo;
					for (i = 0; i < HLM_RX1_FIFO_LEFT(hlm_status) - 2; i++)
						dummy = *rx1_rxFifo;

					*rx1_softReset = 1;
					*tx0_softReset = 1;
					
					if (((data & 0xff) == 0x1) && (num == MAGIC_NUM))
						detect_result = 1;

					detect_work = 3;
				}
				
				if (detect_work == 0)
				{
					cur_time = read_mtimer();
					if ((cur_time - stamp_time) >= DETECT_DEV_INTERVAL)
					{
						stamp_time = cur_time;
						detect_work = 1;
					}
				}

				if ((detect_work == 3))
				{
					detect_work = 0;
				}
			}
		}
		else
		{//不是终节点

		}
	}

	#endif
}