eb001/tb/sw/src/halfLvdsMacSvr.c

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


#define DETECT_DEVICE_PKT_LEN			4
#define MAGIC_NUM						0xa53fd1a0U
#define DETECT_DEV_INTERVAL				((40)/CLINT_MTIME_TICK_PERIOD)


//-------------------------------------------------------------------
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);


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


	if (mode == WORKMODE_MASTER)
	{
		uint32_t seq = 0;

		while (1)
		{
			uint32_t tx_pkt_len;
			uint32_t rx_pkt_len = 0;
			uint32_t rx_start = 0;
			uint32_t status;
			uint32_t is_exit = 0;
			uint32_t intflag;
			uint32_t is_tx_crc;
			uint32_t is_rx_crc;
			uint32_t recv_valid;

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

			if (seq == 0)
			{
				is_tx_crc 	   = 0;
				is_rx_crc	   = 0;
				tx_pkt_len     = DETECT_DEVICE_PKT_LEN + 4;
				tx_data_ptr[0] = (DETECT_DEVICE_PKT_LEN << 20) | 1;
				tx_data_ptr[1] = MAGIC_NUM;
			}
			else if (seq == 1)
			{
				is_tx_crc  = 1;
				is_rx_crc  = 1;
				tx_pkt_len = 256 + 4;

				tx_data_ptr[0] = ((tx_pkt_len - 4) << 20) | 2;

				for (i = 4; i < (tx_pkt_len - 4 * is_tx_crc); i++)
	                MST_TX_BUF[i] = i;
			}
			else
			{
				is_tx_crc  = 1;
				is_rx_crc  = 1;
				tx_pkt_len = 5 * 4 + 4;

				//准备数据
				tx_data_ptr[0] = ((tx_pkt_len - 4) << 20) | 2;
				tx_data_ptr[1] = 0; //64bit time hi
				tx_data_ptr[2] = 0; //64bit time lo
				tx_data_ptr[3] = 0; //delta time
				tx_data_ptr[4] = 0; //ctr | dev_num
				//tx_data_ptr[5] = 0; //crc

			}

			//开始发送工作
			i_tx0_txLen(tx_pkt_len);
			
			uint32_t tx_index = 0;
			uint32_t rx_index = 0;
			uint32_t tx_len;

			tx_len = is_tx_crc? (tx_pkt_len - 4):tx_pkt_len;

			//i_tx0_clear_timer(0);

			for (i = 0; i < HLM_TX_FIFO_LEN; i++)
			{
				if ((tx_index * 4) < tx_len)
				{
					i_tx0_txFifo(tx_data_ptr[tx_index]);
					tx_index++;
				}
				else
				{
					if (is_tx_crc)
					{
						uint32_t crc;
						i_tx0_txCrc(crc);
						i_tx0_txFifo(crc);
						tx_index++;
					}
					break;
				}
			}

			while (!is_exit)
			{
				uint32_t tx_times;

				//i_tx1_softReset(1);
				i_hlm_status(status);
				i_hlm_read_intflag(intflag);
				i_hlm_clear_intflag(intflag);

				tx_times = HLM_TX_FIFO_LEN - HLM_TX0_FIFO_LEFT(status);

				for (i = 0; i < tx_times; i++)
				{
					if ((tx_index * 4) < tx_len)
					{
						i_tx0_txFifo(tx_data_ptr[tx_index]);
						tx_index++;
					}
					else
					{
						if (is_tx_crc && ((tx_index * 4) == tx_len))
						{
							uint32_t crc;
							i_tx0_txCrc(crc);
							i_tx0_txFifo(crc);
							tx_index++;
						}
						break;
					}
				}

				
				for (i = 0; i < HLM_RX1_FIFO_LEFT(status); i++)
				{
					if (rx_start)
					{
						if ((rx_pkt_len - 4) == (rx_index * 4))
						{
							uint32_t crc;
							i_rx1_rxCrc(crc);
							i_rx1_rxFifo(rx_data_ptr[rx_index]);

							if (is_rx_crc)
								while (crc != rx_data_ptr[rx_index]);
						}
						else
						{
							i_rx1_rxFifo(rx_data_ptr[rx_index]);
						}

						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 ((rx_start == 0) && (status & HLM_RX1_VALID))
				if (intflag & HLM_INT_RX1_START)
				{
					//exti_isr_flag[CDR_INT_RX1START] = 0;
					rx_start = 1;
					rx_index = 0;
				}

				if (intflag & HLM_INT_RX1_END)
				{
					is_exit = 1;
					i_rx1_softReset(1);
					i_tx0_softReset(1);
				}
			}

			if (seq == 0)
			{
				if ((rx_pkt_len == 8) && ((rx_data_ptr[0] & 0xff) == 0x1) && (rx_data_ptr[1] == MAGIC_NUM))
				{
					seq = 1;
				}
			}
			else if (seq == 1)
			{

			}
		}
		
	}
	else if (mode == WORKMODE_SLAVE)
	{
		HLM_slave_poll();
	}
	else
	{

	}
	return 0;
}

uint32_t HLM_slave_2streams_poll(uint32_t protocol, uint32_t data, uint32_t is_crc);
uint32_t HLM_slave_1stream_poll(uint32_t protocol, uint32_t data, uint32_t is_crc);

uint32_t HLM_slave_poll(void)
{
	uint32_t detect_work = 0;
	uint32_t downstream_work = 0;

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

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

	int i;
	
	//*rx0_rxTxPair = 1;
	i_rx0_txPair(1);
	i_rx0_limitTime(0);
	i_rx1_txPair(0);
	i_rx1_limitTime(0);

	//*rx0_rxTimerAim = 0; //240;
	//*rx1_rxTxPair = 0;
	//*rx1_rxTimerAim = 0;

	*plic_enable_0_31 = 0;
	
	stamp_time = 0; //read_mtimer();

	#ifdef __riscv_e
	sys_call(SYS_SLAVE_WORK);
	#else

	while (1)
	{
		if (is_terminal)
		{//是终节点
			//status = *HLM_status;
			i_hlm_status(hlm_status);
			i_hlm_read_intflag(intflag);

			//i_hlm_clear_intflag(intflag);

			//if ((!downstream_work) && (hlm_status & HLM_RX0_VALID))
			//	downstream_work = 1;

			if (intflag & HLM_INT_RX0_START)
			{
				downstream_work = 1;
				i_hlm_clear_intflag(HLM_INT_RX0_START);
			}
			
			if (downstream_work && (hlm_status & HLM_RX0_VALID))
			{
				uint32_t data;

				i_rx0_rxFifo(data);
				
				protocol = (data & 0xff);

				if ((protocol == 2) && (detect_result) && (detect_work == 0))
				{
					HLM_slave_2streams_poll(protocol, data, 0);
				}
				else
				{
					HLM_slave_1stream_poll(protocol, data, 0);
				}
			}

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

				//*tx0_txLen  = DETECT_DEVICE_PKT_TX_LEN;
				i_tx0_clear_timer(0);

				i_tx0_txLen(DETECT_DEVICE_PKT_LEN + 4);
				//*tx0_txFifo = (DETECT_DEVICE_PKT_LEN << 20) | 1;
				i_tx0_txFifo(((DETECT_DEVICE_PKT_LEN << 20) | 1));
				//*tx0_txFifo = detect_pkt;
				i_tx0_txFifo(detect_pkt);
			}

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

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

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

					detect_work = 0;
				}
				else
				{
					uint32_t t;
					i_tx0_read_timer(t);
					if (t >= 600)
					{
						i_rx1_softReset(1);
						i_tx0_softReset(1);

						detect_work = 0;
						detect_result = 0;
					}
				}
			}
			
			if ((detect_work == 0) && (downstream_work == 0))
			{
				cur_time = read_mtimer();
				//i_tx0_read_timer(cur_time);
				if ((cur_time - stamp_time) >= DETECT_DEV_INTERVAL)
                {
                    stamp_time = cur_time;
					detect_work = 1;
				}
			}
		}
		else
		{//不是终节点

		}
	}

	#endif
}


uint32_t HLM_slave_1stream_poll(uint32_t protocol, uint32_t data, uint32_t is_crc)
{
	uint32_t hlm_status;
	uint32_t intflag;
	uint32_t i;

	uint32_t downstream_work = 1;
	uint32_t upstream_work = 0;

	uint32_t d_rx_index = 0;
	uint32_t d_rx_pkt_len;
	uint32_t u_rx_index = 0;
	uint32_t u_rx_pkt_len = 0;

	d_rx_pkt_len = (data >> 20) + 4;
	i_tx1_txLen(d_rx_pkt_len);
	i_tx1_txFifo(data);
	d_rx_index++;

	while (1)
	{
		i_hlm_status(hlm_status);
		i_hlm_read_intflag(intflag);
		i_hlm_clear_intflag(intflag);

		for (i = 0; i < HLM_RX0_FIFO_LEFT(hlm_status); i++)
		{
			uint32_t data;
			if (downstream_work)
			{//处理下行接收
				i_rx0_rxFifo(data);

				d_rx_index++;

				if (d_rx_pkt_len > (d_rx_index * 4))
				{
					i_tx1_txFifo(data);
				}
				else if (d_rx_pkt_len == (d_rx_index * 4))
				{
					i_tx1_txFifo(data);
				}
				else
				{
					downstream_work = 0;
					d_rx_index = 0;
					break;
				}
			}
			else
				break;
		}
		
		if (intflag & HLM_INT_TX1_END)
		{
			i_rx0_softReset(1);
			i_tx1_softReset(1);
			break;
		}
	}
}


#define HLM_Slave_2streams_down_poll(ds_work, index, pkt_len, intflag, status) \
	do {\
		if (status & HLM_RX0_VALID)\
		{\
			uint32_t data;\
			if (ds_work)\
			{/*处理下行接收*/ \
				i_rx0_rxFifo(data);\
				index++;\
				if (pkt_len > (index))\
				{\
					i_tx0_txFifo(data);\
				}\
				else if (pkt_len == (index))\
				{\
					i_tx0_txFifo(data);\
				}\
				else\
				{\
					ds_work = 0;\
					index = 0;\
				}\
			}\
		}\
	} while (0)

#define HLM_Slave_2streams_up_poll(us_work, index, pkt_len, intflag, status) \
	do {\ 	
		if (status & HLM_RX1_VALID)\
		{\
			uint32_t data;\
			if (us_work)\
			{/*处理上行接收*/\
				i_rx1_rxFifo(data);\
				if (index == 0)\
				{\
					pkt_len = (data >> 20) + 4;\
					i_tx1_txLen(pkt_len);\
					pkt_len = (pkt_len >> 2);\
				}\
				index++;\
				if (pkt_len > (index))\
				{\
					i_tx1_txFifo(data);\
				}\
				else if (pkt_len == (index))\
				{\
					i_tx1_txFifo(data);\
				}\
				else\
				{\
					us_work = 0;\
					index = 0;\
					/*is_work = 0;*/\
				}\
			}\
		}\
	} while (0)


uint32_t HLM_slave_2streams_poll(uint32_t protocol, uint32_t data, uint32_t is_crc)
{
	uint32_t hlm_status;
	uint32_t intflag;
	uint32_t i;

	uint32_t downstream_work = 1;
	uint32_t upstream_work = 0;

	uint32_t d_rx_index = 0;
	uint32_t d_rx_pkt_len = 0;
	uint32_t u_rx_index = 0;
	uint32_t u_rx_pkt_len = 0;
	//uint32_t is_work = 1;

	d_rx_pkt_len = (data >> 20) + 4;
	i_tx0_txLen(d_rx_pkt_len);
	i_tx0_txFifo(data);
	d_rx_pkt_len = (d_rx_pkt_len >> 2);
	d_rx_index++;

	while (1)
	{
		i_hlm_status(hlm_status);
		i_hlm_read_intflag(intflag);
		i_hlm_clear_intflag(intflag);

		HLM_Slave_2streams_down_poll(downstream_work,
			d_rx_index,
			d_rx_pkt_len,
			intflag,
		 	hlm_status);

		if (intflag & HLM_INT_RX1_START)
		{
			upstream_work = 1;
			intflag = 0;
			do {
				i_hlm_status(hlm_status);
				//i_hlm_read_intflag(intflag);
				//i_hlm_clear_intflag(intflag);

				HLM_Slave_2streams_down_poll(downstream_work,
					d_rx_index,
					d_rx_pkt_len,
					intflag,
					hlm_status);

				HLM_Slave_2streams_up_poll(upstream_work,
					u_rx_index,
					u_rx_pkt_len,
					intflag,
					hlm_status);
			} while ((upstream_work) || (downstream_work));
		}

		if (intflag & HLM_INT_TX1_END)
		{
			i_tx0_softReset(1);
			i_tx1_softReset(1);
			i_rx0_softReset(1);
			i_rx1_softReset(1);
			break;
		}
	}

	return 0;
}