sys_loopback_bd_3_eg_rx.uc

开发Inetl IXP2400平台所必须的硬件诊断和测试程序。该软件包支持的功能包括CPU基本功能检测

/* line_rate_bw_eg_rx.uc
 *
 *
 *
 * NOTE: THIS IS NOT A PERFORMANCE BENCHMARK!!!! IT IS JUST TO CHECK IF THE
 *       HARDWARE IS ABLE TO HANDLE DATA AT THE LINERATE THAT IS BEING
 *       PUMPED INTO THE SYSTEM
 *
 *---------------------------------------------------------------------------
 *                                                                      
 *                  I N T E L   P R O P R I E T A R Y                   
 *                                                                      
 *     COPYRIGHT (c)  2002 BY  INTEL  CORPORATION.  ALL RIGHTS          
 *     RESERVED.   NO  PART  OF THIS PROGRAM  OR  PUBLICATION  MAY      
 *     BE  REPRODUCED,   TRANSMITTED,   TRANSCRIBED,   STORED  IN  A    
 *     RETRIEVAL SYSTEM, OR TRANSLATED INTO ANY LANGUAGE OR COMPUTER    
 *     LANGUAGE IN ANY FORM OR BY ANY MEANS, ELECTRONIC, MECHANICAL,    
 *     MAGNETIC,  OPTICAL,  CHEMICAL, MANUAL, OR OTHERWISE,  WITHOUT    
 *     THE PRIOR WRITTEN PERMISSION OF :                                
 *                                                                      
 *                        INTEL  CORPORATION                            
 *                                                                     
 *                     2200 MISSION COLLEGE BLVD                        
 *                                                                      
 *               SANTA  CLARA,  CALIFORNIA  95052-8119                  
 *                                                                      
 *---------------------------------------------------------------------------
 *
 *
 *  system: IXDP2400
 *  subsystem: DIAG
 *  author: dalsraja, November 11, 2002
 *  revisions:
 * 
 * 
 * --------------------------------------------------------------------------
 */


#include "common_uc.h"
#include "sys_loopback_bd_3.h"

#define RX_TRANSFER_THREAD				&$TransferReg00
#define RX_SIGNAL						&rx_sig

#define NEXT_CTX_SIGNAL_NUM				EG_SAME_ME_SIG_NUM
#define NEXT_CTX_SIG_DATA				((1 << 7) | (NEXT_CTX_SIGNAL_NUM << 3))

#define LOOP_COUNT_ADDR					0x1604
#define BURST_COUNT_ADDR				0x1608
#define ME_TO_XSCALE_MSG_ADDR			0x160C
#define XSCALE_MSG_ADDR					0x1610

#define COUNT_RX_PKTS

.reg cur_me cur_ctx
.reg sram_channel_number t0 $sr0
.reg @total_rx @total_packet @total_rx_cnt
.reg @cur_loop @total_loop
.reg ring
.reg RxConfigData
.reg RBuf_Base Rbuf_Elem_Done Rx_Thd_Freelist
.reg null error elem bytecnt
.reg $sequence_count
.reg $ring_data $pkt_number
.reg @sramDescBase @dramPacketBase
.reg @expected_sequence_0 @expected_sequence_1 @expected_sequence_2 @expected_sequence_3
.reg $TransferReg00 $TransferReg01
.sig rx_sig
.sig next_ctx_sig
.sig msf_sig scratch_sig sram_sig dram_sig ring_sig scratch_rx

.xfer_order $TransferReg00 $TransferReg01

.addr next_ctx_sig EG_SAME_ME_SIG_NUM

.set $TransferReg00

.begin
	.reg temp_data
	local_csr_rd[ACTIVE_CTX_STS]
	immed[temp_data, 0]
	alu[cur_me, 0x1F, AND, temp_data, >>3]		// Extract the current ME number
	alu[cur_ctx, 0x7, AND, temp_data]			// Extract the current context number
.end

	immed[ring, (RING_0 << 2)]			// ring number in a register
	alu[sram_channel_number, --, B, CHAN_NUMBER, <<SRAM_CHANNEL_NUMBER_FIELD]
	alu[t0, sram_channel_number, OR, Q_NUMBER, <<SRAM_Q_ARRAY_NUMBER_FIELD]

	immed[RBuf_Base, RBUF_TBUF ]
	immed[Rbuf_Elem_Done, RBUF_ELEMENT_DONE]
	immed[Rx_Thd_Freelist, RX_THREAD_FREELIST_0]

.begin
	.reg RxThreadList temp_data me_data
	alu[me_data, 0x3, AND, cur_me]
	alu[temp_data, --, B, cur_me, >>4]
	alu[me_data, me_data, OR, temp_data, <<2]
	immed[RxThreadList, (RX_SIGNAL << 12)]
	alu[RxThreadList, RxThreadList, OR, me_data, <<7]
	alu[RxThreadList, RxThreadList, OR, cur_ctx, <<4]
	alu[RxConfigData, RxThreadList,  OR , RX_TRANSFER_THREAD]
	alu[RxConfigData, --,  B, RxConfigData, <<16]		// Shift 16 for msf[fast_wr...]
.end

	br=ctx[0, init_thread0_only#]
	.set_sig next_ctx_sig
	ctx_arb[next_ctx_sig]
	br[ReceiveNextPacket#]


init_thread0_only#:
	immed[@sramDescBase, (EG_SRAM_DESC_BASE & MASK_16BIT)]
	immed_w1[@sramDescBase, ((EG_SRAM_DESC_BASE >> 16) & MASK_16BIT)]

	immed[@dramPacketBase, (EG_DRAM_PCKT_BASE & MASK_16BIT)]
	immed_w1[@dramPacketBase, ((EG_DRAM_PCKT_BASE >> 16) & MASK_16BIT)]

	immed[@expected_sequence_0, 0]
	immed[@total_rx, 0]
	immed[@total_rx_cnt, 0]
	immed[@cur_loop, 0]

.begin
	.reg temp_scratch_addr $temp_scratch_data temp_data
	.sig scratch_sig
	immed[temp_scratch_addr, BURST_COUNT_ADDR]
	scratch[read, $temp_scratch_data, temp_scratch_addr, 0, 1], ctx_swap[scratch_sig]
	alu[temp_data, --, B, $temp_scratch_data]
	alu[@total_packet, --, B, temp_data]
.end

.begin
	.reg temp_scratch_addr $temp_scratch_data
	.sig scratch_sig
	immed[temp_scratch_addr, LOOP_COUNT_ADDR]
	scratch[read, $temp_scratch_data, temp_scratch_addr, 0, 1], ctx_swap[scratch_sig]
	alu[@total_loop, --, B, $temp_scratch_data]
.end


//****************************************************
// Configure RX/TX Control
//****************************************************
.begin
	.reg MsfAddress RxControlData $RxControlData
	immed[RxControlData, ((0<<9) | (EG_RX_ELEMENT_SIZE << 2))] // put control and data into diff freelist
	immed_w1[RxControlData, ((EG_RX_MODE << 6) | (EG_RX_WIDTH << 4) | (EG_RX_PHY << 3) | (0 << 1) | (1 << 0))]
	alu[$RxControlData, --, B, RxControlData]
	immed[MsfAddress, MSF_RX_CONTROL]
	msf[write, $RxControlData, MsfAddress, 0, 1], ctx_swap[msf_sig]
.end


//****************************************************
// Configure CSIX_TYPE_MAP
//****************************************************
.begin
	.reg MsfAddress $CsixTypeMapData
	alu[$CsixTypeMapData, --, B, MSF_CSIX_RBUF_DATA, <<BIT_SHF_UNICAST]
	immed[MsfAddress, CSIX_TYPE_MAP]
	msf[write, $CsixTypeMapData, MsfAddress, 0, 1], ctx_swap[msf_sig]
.end


//******************************************************
// Initialize RBUF Freelist to add elements to the list
//******************************************************
.begin
	.reg temp_reg RbufElemDoneData

	immed[temp_reg, 0]

init_RBUF#:
	alu[RbufElemDoneData, --, B, temp_reg, <<16]
	msf[fast_wr, --, RbufElemDoneData, RBUF_ELEMENT_DONE]
	alu[temp_reg, temp_reg, +, 1]
	alu[--, EG_RBUF_ELEM_COUNT, -, temp_reg]
	bne[init_RBUF#]
.end


//****************************************************
// Configure RX/TX Control
//****************************************************
.begin
	.reg MsfAddress RxControlData $RxControlData
	immed[MsfAddress, MSF_RX_CONTROL]
	msf[read, $RxControlData, MsfAddress, 0, 1], ctx_swap[msf_sig]
	alu[$RxControlData, $RxControlData, OR, EG_RX_ENABLE_MASK, <<28]
	msf[write, $RxControlData, MsfAddress, 0, 1], ctx_swap[msf_sig]
.end


//******************************************************
// Configure Rx_Thread_Freelist_Timeout0
//******************************************************
.begin
	.reg timeout_val
	immed[timeout_val, FREELIST_TIMEOUT_VAL]			// timeout value
	alu[timeout_val,--, B, timeout_val, <<16]			// Shift 16 for fast_wr
	msf[fast_wr, --, timeout_val, RX_THREAD_FREELIST_TIMEOUT_0]
.end


//**************************************************
// Configure Scratch Ring
//**************************************************
.begin
	.reg $scratch_base $scratch_head $scratch_tail temp_val
	.sig scratch_sig1 scratch_sig2 scratch_sig3

	alu[temp_val, --, B, RINGBASE_256_0, <<9]
	alu[$scratch_base, temp_val, OR, RINGSIZE_1024, <<30]	// Use ring size of 256 lw and base 0x0
	immed[$scratch_head,0]
	immed[$scratch_tail,0]

	cap[write,$scratch_base,SCRATCH_RING_BASE_0],sig_done[scratch_sig1]
	cap[write,$scratch_head,SCRATCH_RING_HEAD_0],sig_done[scratch_sig2]
	cap[write,$scratch_tail,SCRATCH_RING_TAIL_0],sig_done[scratch_sig3]
	ctx_arb[scratch_sig1, scratch_sig2, scratch_sig3]
.end


ReceiveNextPacket#:
	local_csr_wr[SAME_ME_SIGNAL, NEXT_CTX_SIG_DATA]
	msf[fast_wr, --, Rx_Thd_Freelist, RxConfigData] // add thread to freelist
	.set_sig rx_sig next_ctx_sig
	ctx_arb[rx_sig, next_ctx_sig]	


// RSW should be in xfer register
// Transfer RBUF data to sram_in transfer registers
//***************************************
// Extract RSW
//***************************************
RSW#:
	alu[null, 0x1, AND, $TransferReg00, >>9]		// Extract null
	bne[NULL#]										// If null=1, result=0

#ifdef COUNT_RX_PKTS
	alu[@total_rx_cnt, @total_rx_cnt, +, 1]
.begin
	.reg temp_scratch_addr

	alu[$pkt_number, --, B, @total_rx_cnt]
	immed[temp_scratch_addr, (SCRATCH_MSG_ADDR + PKTS_RX_OFFSET)]
	scratch[write, $pkt_number, temp_scratch_addr, 0, 1], sig_done[scratch_rx]
.end
#endif

//	alu[error, 0x1, AND, $TransferReg00, >>13]
	alu[elem, 0xFF, AND, $TransferReg00, >>24]		// RBUF element number

.begin
	.reg refcnt ind_ref_data

	local_csr_wr[SAME_ME_SIGNAL, NEXT_CTX_SIG_DATA]

.local RBufAddress
	alu[RBufAddress, RBuf_Base, OR, elem, <<EG_RBUF_ADDR_SHF]
	msf[read, $sequence_count, RBufAddress, 0, 1], sig_done[msf_sig]	// Extract prepend data and first 4 bytes
	alu[ind_ref_data, RBufAddress, +, PREPEND_LENGTH]	// Calc. RBuf address for packet data
.endlocal		// RBufAddress

	.set_sig next_ctx_sig
#ifdef COUNT_RX_PKTS
	ctx_arb[msf_sig, next_ctx_sig, scratch_rx]
#else
	ctx_arb[msf_sig, next_ctx_sig]
#endif
.end


.begin
	.reg temp_sequence
	alu[temp_sequence, --, B, $sequence_count, >>24]

	.if (temp_sequence == @expected_sequence_0)
		alu[@expected_sequence_0, @expected_sequence_0, +, 1]
		alu[@expected_sequence_0, @expected_sequence_0, AND, (EG_TBUF_ELEM_COUNT_PER_PORT - 1)]
	.else
		br[sequence_error#]
	.endif
.end


//**************************************************************
//  Free up Element by writing to RBUF_Element_Done
//**************************************************************
.begin
	.reg rbuf_elem_done_data
	alu[rbuf_elem_done_data, --, B, elem, <<16]
	msf[fast_wr, --, rbuf_elem_done_data, RBUF_ELEMENT_DONE]
.end

	alu[@total_rx, @total_rx, +, 1]

	.if (@total_rx == @total_packet)
		immed[@total_rx, 0]
//		.if (@total_loop > 0)
			alu[@cur_loop, @cur_loop, +, 1]

/*			.if (@cur_loop == @total_loop)
				.begin
					.reg $temp_scratch temp_scratch_addr

					immed[$temp_scratch, TEST_COMPLETE]
					immed[temp_scratch_addr, SCRATCH_MSG_ADDR]
					scratch[write, $temp_scratch, temp_scratch_addr, 0, 1], ctx_swap[scratch_sig]
				.end
			.endif
*///		.endif

			alu[$ring_data, --, B, @cur_loop]
check_ring_full#:
			br_inp_state[SCR_Ring0_Full, check_ring_full#]
			scratch[put, $ring_data, ring, 0, 1], ctx_swap[ring_sig]

	.endif


NULL#:
next_packet#:
	br[ReceiveNextPacket#]			// loop around and wait for next packet


sequence_error#:
.begin
	.reg $temp_scratch temp_scratch_addr

	immed[$temp_scratch, SEQUENCE_ERROR]
	immed[temp_scratch_addr, SCRATCH_MSG_ADDR]
	scratch[write, $temp_scratch, temp_scratch_addr, 0, 1], ctx_swap[scratch_sig]
	ctx_arb[kill]
.end