addr_filter.c

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

							{
								if ((pass_port[ctr*2+1] != expected_num_pkts) || (pass_port[ports] == 0))
								{
									eprintf("\nDid not Receive expected number of packets on port %d\n", ctr*2+1);
									eprintf("Packets Received = %d\n",pass_port[ctr*2+1]);
									rxflag[ctr*2+1] = ERROR;
									flag = ERROR;
								}
								if (pass_port[ctr*2+1] == expected_num_pkts)
								{
									eprintf("Received %d packets on Port %d\n",pass_port[ctr*2+1],ctr*2+1);
								}
							}
						}
						
						break;
						
			   default:   eprintf("This is bad value for port number \n");
								return INVALID_PARAMETERS;
			}

		}
		eprintf("\n");

		if(dcache_status != 0)	// if dcache was originally ON
		{
			dcache_on();
		}

		if (loop == 0)
			loop = loop_count;
		test_passed=verify_filter(cflag);
	
		if (test_passed)
		{
			switch(test_param)
			{
			case 'u':
				eprintf("Unicast MAC filtering test...PASSED\n");
				break;
			case 'm':
				eprintf("Multicast MAC filtering test...PASSED\n");
				break;
			case 'b':
				eprintf("Broadcast MAC filtering test...PASSED\n");
				break;
			case '1':
				eprintf("RMON test for the following Registers ...PASSED\n");
				eprintf("RxOctetsTotalOK / OctetsTransmittedOK\n");
				eprintf("RxOctetsBAD / OctetsTransmittedBad\n");
				eprintf("RxUCPckts / TxUCPkts\n");
				eprintf("RxMCPckts / TxMCPkts\n");
				eprintf("RxBCPckts / TxBCPkts\n");
				eprintf("RxPkts64Octets / TxPkts64Octets\n");
				eprintf("RxPkts65to127Octets / TxPkts65to127Octets\n");
				eprintf("RxPkts128to255Octets / TxPkts128to255Octets\n");
				break;

			default:
				eprintf("Invalid parameters. \n");
				return INVALID_PARAMETERS;
			}

			Set_LED("MAFP");
			slowport_code[0] = SP_XSC;
			slowport_code[1] = SP_PASS;
			dump_slowport(slowport_code, 2, SP_NON_FATAL);
		} 
		else
		{
			if (mailbox_value == INIT_ERROR)
			{
				eprintf("The slave NPU did not succeed in loading the microcode to its microengines\n");
			}
			else if (mailbox_value == NOT_RECEIVED)
			{
				eprintf("There was no sign that the expected packet was received\n");
			}
			else if (mailbox_value == ERROR_PATTERN)
			{
				eprintf("mailbox = 0x%x\n",mailbox_value);
				eprintf("The packet received was not the same as the packet transmitted.\n");
			}
			else if (mailbox_value == INCORRECT_SIZE)
			{
				eprintf("mailbox = 0x%x\n",mailbox_value);
				eprintf("The packet received was not the same size as the packet transmitted.\n");
			}
				
			// prepare structure for dumping
			syslog.type = TYPE_ERROR;
			syslog.source_comp = MASTER_DIAG;	// Determine master/slave

			switch(test_param)
			{
			case 'u':
				eprintf("Unicast MAC filtering test...FAILED\n");
				break;
			case 'm':
				eprintf("Multicast MAC filtering test...FAILED\n");
				break;
			case 'b':
				eprintf("Broadcast MAC filtering test...FAILED\n");
				break;
			case '1':
				eprintf("RMON test for packet count Registers ...FAILED\n");
			}

			// write to syslog
			syslog_dump(&syslog, sizeof(SYSLOG_DATA));

			Set_LED("LswF");
			slowport_code[0] = SP_XSC;
			slowport_code[1] = SP_FAIL;
			dump_slowport(slowport_code, 2, SP_NON_FATAL);
			acL->Err = ERROR;
		}		

		Clear_All_ME();
		Msf_OutOfReset();

	}
	else
	{
		eprintf("\nThis test cannot be run directly on the Slave console\n");
		return DONE;	// To indicate that the slave does not do this.
	}
	return DONE;
}


// ******************************************************************************
// Function: void Slave_pl_SysLpbk_test(void)
//
// This function will be called by the PCI Doorbell Interrupt handler after the
// Master NPU initiates a PCI Doorbell Interrupt on the Slave NPU
// ******************************************************************************
void Slave_pl_SysLpbk_test(int param)
{
	UINT32 status, scratch_ring_addr, scratch_val, ctr=0, verbose;

	scratch_ring_addr = SCR_RING_INSTR_ADDR + (1 << 2);
	verbose = GET32(PCI_LOCAL_CSR_BASE + MAILBOX_3_OFF);

	Msf_OutOfReset();
	status = Msf_PLL();
	if (status == ERROR)
	{
		return;
	}

	// Load ME with microcode
	if (param != 1)
	{
		eprintf("Downloading SPHY code..\n");
		DownLoadUcode(PL_SYS_LOOPBACK_IN_RX_ME, sizeof(pl_sys_loopback_in_rx), (UINT32 *)pl_sys_loopback_in_rx);
		DownLoadUcode(PL_SYS_LOOPBACK_IN_TX_ME, sizeof(pl_sys_loopback_in_tx), (UINT32 *)pl_sys_loopback_in_tx);
	}
	else
	{
		eprintf("Downloading MPHY code\n");
		DownLoadUcode(PL_SYS_LOOPBACK_IN_RX_ME, sizeof(mphy_loopback_in_rx), (UINT32 *)mphy_loopback_in_rx);
		DownLoadUcode(PL_SYS_LOOPBACK_IN_TX_ME, sizeof(mphy_loopback_in_tx), (UINT32 *)mphy_loopback_in_tx);
	}

	hal_delay_us(1000000);

	do
	{
		if ((scratch_val = GET32(scratch_ring_addr)))
		{
			hal_delay_us(1);
			eprintf("Packets (total): %d\r", scratch_val);
			ctr = 0;
		}
		else
		{
			hal_delay_us(10);
			ctr++;
		}
	}
	while (ctr != 500000);

	eprintf("\n");

	Clear_All_ME();
	Msf_OutOfReset();
}

short verify_filter(short cflag)
{
	UINT32 rxucpkts[4],rxmcpkts[4],rxbcpkts[4],dropped[4];
	UINT32 rxtotalOctets[4],rxBadoctets[4],rx64[4],rx65to127[4],rx128to255[4];
	UINT32 txucpkts[4],txmcpkts[4],txbcpkts[4];
	UINT32 txtotalOctets[4],txBadoctets[4],tx64[4],tx65to127[4],tx128to255[4];

	short test_passed = 1,iteration,port,port_ctr;
	short rxok=0,txok=0,res=0;


	if (ports == 4)
		if (!cflag)
			iteration = 4;
		else
			iteration = 2;
	else
		iteration = 1;

	spConfig();
    for(port=0; port<4;port++)
    {
		/* Reading Rx statistics */
		rxucpkts[port] = reg_read(((port*PORTSZ)+RX_UC_PKTS));  
		rxmcpkts[port] = reg_read(((port*PORTSZ)+RX_MC_PKTS));  
		rxbcpkts[port] = reg_read(((port*PORTSZ)+RX_BC_PKTS));  
		dropped[port] = reg_read(port+PORT0_RXFIFO_PKT_DROP);  
		rxtotalOctets[port] = reg_read(((port*PORTSZ)+RX_OCTETS_OK));  
		rxBadoctets[port] = reg_read(((port*PORTSZ)+RX_OCTETS_BAD));  
		rx64[port] = reg_read(((port*PORTSZ)+RX_PKTS_64));  
		rx65to127[port] = reg_read(((port*PORTSZ)+RX_PKTS_65_127));  
		rx128to255[port] = reg_read(((port*PORTSZ)+RX_PKTS_128_255));  
		/* Reading Tx statistics */
		txucpkts[port] = reg_read(((port*PORTSZ)+TX_UC_PKTS));  
		txmcpkts[port] = reg_read(((port*PORTSZ)+TX_MC_PKTS));  
		txbcpkts[port] = reg_read(((port*PORTSZ)+TX_BC_PKTS));  
		txtotalOctets[port] = reg_read(((port*PORTSZ)+TX_OCTETS_OK));  
		txBadoctets[port] = reg_read(((port*PORTSZ)+TX_OCTETS_BAD));  
		tx64[port] = reg_read(((port*PORTSZ)+TX_PKTS_64));  
		tx65to127[port] = reg_read(((port*PORTSZ)+TX_PKTS_65_127));  
		tx128to255[port] = reg_read(((port*PORTSZ)+TX_PKTS_128_255));  

	}
	spRestore();

	for(port_ctr=0; port_ctr<iteration;port_ctr++)
	{
		if ((!cflag) && (ports == 4))
			port = port_ctr;
		if ((cflag) && (ports == 4))
		{
			port = port_ctr*2;
			port = rxport[port];
		}
		if ((!cflag) && (ports != 4))
			port = ports;
		if ((cflag) && (ports != 4))
			port = rxport[ports];

		eprintf("PORT = %d\n",port);

		if ( (rxucpkts[port] == 0) ||
			 (rxmcpkts[port] == 0) ||
			 (rxbcpkts[port] == 0) )
		{
			test_passed = 0;
		}

		switch (test_param)
		{
		case 'u':
		
				eprintf("RX UC pkts = %d on port %d\n",rxucpkts[port],port);
				eprintf("RX MC pkts = %d on port %d\n",rxmcpkts[port],port);
				eprintf("RX BC pkts = %d on port %d\n",rxbcpkts[port],port);
				eprintf("Dropped UC pkts = %d on port %d\n",dropped[port],port);

				if ((ucCount[port] != 0) || 
					(mcCount[port] != (loop*MC_PKTS)) ||
					(bcCount[port] != (loop*BC_PKTS)) ||
					(dropped[port] != (loop *EXP_DROPPED_PKTS)))
				{
					eprintf("Unicast packet filtering test ERROR , Port %d\n",port);
					test_passed = 0;
				}
				else 
					res|= 1<<port_ctr;
				

		break;
		case 'm':
				eprintf("RX UC pkts = %d on port %d\n",rxucpkts[port],port);
				eprintf("RX MC pkts = %d on port %d\n",rxmcpkts[port],port);
				eprintf("RX BC pkts = %d on port %d\n",rxbcpkts[port],port);
				eprintf("Dropped MC pkts = %d on port %d\n",dropped[port],port);

				if ((ucCount[port] != (loop*UC_PKTS)) || 
					(mcCount[port] != 0) ||
					(bcCount[port] != (loop*BC_PKTS)) ||
					(dropped[port] != (loop *EXP_DROPPED_PKTS)))
				{
					eprintf("Multicast packet filtering test ERROR , Port %d\n",port);
					test_passed = 0;
				}				
				else
					res|= 1<<port_ctr;
				
				break;
		case 'b':
				eprintf("RX UC pkts = %d on port %d\n",rxucpkts[port],port);
				eprintf("RX MC pkts = %d on port %d\n",rxmcpkts[port],port);
				eprintf("RX BC pkts = %d on port %d\n",rxbcpkts[port],port);
				eprintf("Dropped BC pkts = %d on port %d\n",dropped[port],port);
	
				
				if ((ucCount[port] != (loop*UC_PKTS)) || 
					(mcCount[port] != (loop*MC_PKTS)) ||
					(bcCount[port] != 0) ||
					(dropped[port] != (loop *EXP_DROPPED_PKTS)))
				{
					eprintf("Broadcast packet filtering test ERROR , Port %d\n",port);
					test_passed = 0;
				}					
				else
					res|= 1<<port_ctr;
				
				break;
		case '1':

				test_passed = 0;
				rxok=0;
				txok=0;

				eprintf("\nRx stats for port %d\n",port);

				eprintf("RX UC pkts = \t\t%d on port %d\n",rxucpkts[port],port);
				eprintf("RX MC pkts = \t\t%d on port %d\n",rxmcpkts[port],port);
				eprintf("RX BC pkts = \t\t%d on port %d\n",rxbcpkts[port],port);
				eprintf("RX Total Octets = \t%d on port %d\n",rxtotalOctets[port],port);
				eprintf("RX BAD Octets = \t%d on port %d\n",rxBadoctets[port],port);
				eprintf("RX 64 byte pkts = \t%d on port %d\n",rx64[port],port);
				eprintf("RX 65-127 byte pkts = \t%d on port %d\n",rx65to127[port],port);
				eprintf("RX 128-255 pkts = \t%d on port %d\n",rx128to255[port],port);
								
				if (cflag)
					port=rxport[port];
				eprintf("\nTx stats for port %d\n",port);

				eprintf("TX UC pkts = \t\t%d on port %d\n",txucpkts[port],port);
				eprintf("TX MC pkts = \t\t%d on port %d\n",txmcpkts[port],port);
				eprintf("TX BC pkts = \t\t%d on port %d\n",txbcpkts[port],port);
				eprintf("TX Total Octets = \t%d on port %d\n",txtotalOctets[port],port);
				eprintf("TX BAD Octets = \t%d on port %d\n",txBadoctets[port],port);
				eprintf("TX 64 byte pkts = \t%d on port %d\n",tx64[port],port);
				eprintf("TX 65-127 byte pkts = \t%d on port %d\n",tx65to127[port],port);
				eprintf("TX 128-255 pkts = \t%d on port %d\n",tx128to255[port],port);

				if (cflag)
					port=rxport[port];

				if (rxucpkts[port] != (loop*UC_PKTS))
					eprintf("%s\n", ERR_STR(RXUCPKTS_ERR));
				else if (rxmcpkts[port] != (loop*MC_PKTS)) 
					eprintf("%s\n", ERR_STR(RXMCPKTS_ERR));
				else if (rxbcpkts[port] != (loop*BC_PKTS)) 
					eprintf("%s\n", ERR_STR(RXBCPKTS_ERR));
				else if (rxtotalOctets[port] != (loop*888)) 
					eprintf("%s\n", ERR_STR(RXOCTETSTOTALOK_ERR));
				else if (rxBadoctets[port] != (loop*0x0)) 
					eprintf("%s\n", ERR_STR(RXOCTETSTOTALBAD_ERR));
				else if (rx64[port] != (loop*0x3)) 
					eprintf("%s\n", ERR_STR(RXPKTS64OCTETS_ERR));
				else if (rx64[port] != (loop*0x3))
					eprintf("%s\n", ERR_STR(RXPKTS65TO127OCTETS_ERR));
				else if (rx65to127[port] != (loop*0x3) )
					eprintf("%s\n", ERR_STR(RXPKTS64OCTETS_ERR));
				else if (rx128to255[port] != (loop*0x3)) 
					eprintf("%s\n", ERR_STR(RXPKTS128TO255OCTETS_ERR));
				else
				{
					eprintf("Rx stats. are OK ! \n");
					rxok = 1;
				}

				if (cflag)
					port=rxport[port];

				if (txucpkts[port] != (loop*UC_PKTS)) 
					eprintf("%s\n", ERR_STR(TXUCPKTS_ERR));
				else if (txmcpkts[port] != (loop*MC_PKTS)) 
					eprintf("%s\n", ERR_STR(TXMCPKTS_ERR));
				else if (txbcpkts[port] != (loop*BC_PKTS)) 
					eprintf("%s\n", ERR_STR(TXBCPKTS_ERR));
				else if (txtotalOctets[port] != (loop*888)) 
					eprintf("%s\n", ERR_STR(OCTETSTRANSMITTEDOK_ERR));
				else if (txBadoctets[port] != (loop*0x0)) 
					eprintf("%s\n", ERR_STR(OCTETSTRANSMITTEDBAD_ERR));
				else if (tx64[port] != (loop*0x3)) 
					eprintf("%s\n", ERR_STR(TXPKTS64OCTETS_ERR));
				else if (tx64[port] != (loop*0x3)) 
					eprintf("%s\n", ERR_STR(TXPKTS65TO127OCTETS_ERR));
				else if (tx65to127[port] != (loop*0x3)) 
					eprintf("%s\n", ERR_STR(TXPKTS64OCTETS_ERR));
				else if (tx128to255[port] != (loop*0x3)) 
					eprintf("%s\n", ERR_STR(TXPKTS128TO255OCTETS_ERR));
				else
				{
					eprintf("Tx stats. are OK ! \n");
					txok = 1;
				}

				if (rxok && txok)
					res|= 1<<port_ctr;
				break;

		default: 
				eprintf("Illegal Test parameter\n");
				test_passed = 0;
				break;
		}

	}
	//eprintf("rxok = %x, txok= %x, ports = %x, res = %x\n",rxok,txok,ports,res);



	if ((res == 0xF) && (ports == 0x4) && (!cflag))
		test_passed = 1;
	else
		if ((res == 0x3) && (ports == 0x4) && cflag)
			test_passed = 1;
		else
			if ((res == 0x1) && (ports != 0x4))
				test_passed = 1;
			else
				test_passed = 0;


	return test_passed;
}


void get_packets_for_filter_test()
{
	pl_sys_lb_data64_0 = data64_0;
	pl_sys_lb_data64_1 = data64_1;
	pl_sys_lb_data64_2 = data64_2;
	pl_sys_lb_data64_3 = data64_3;

	pl_sys_lb_data96_0 = data96_0;
	pl_sys_lb_data96_1 = data96_1;
	pl_sys_lb_data96_2 = data96_2;
	pl_sys_lb_data96_3 = data96_3;

	pl_sys_lb_data138_0 = data138_0;
	pl_sys_lb_data138_1 = data138_1;
	pl_sys_lb_data138_2 = data138_2;
	pl_sys_lb_data138_3 = data138_3;

}



void clear_stat_regs()
{
	int port=0, offset=0x20; 

	eprintf("Clearing statistics registers\n");
	spConfig();

	/* Read all Rx stat regs */
    for(port=0; port<4;port++)
    {
		offset = 0x20;
		while(offset <= 0x39)
		{
			reg_read((port*0x80)+offset);
			offset++;
		}
	}

	/* Read all Tx stat regs */
	for(port=0; port<4;port++)
    {
		offset = 0x40;
		while(offset <= 0x58)
		{
			reg_read((port*0x80)+offset);
			offset++;
		}
	}

	/* Read all Rx FIFO regs */
	offset = 0x580;
	while(offset <= (0x580 + 0x3F))
	{
		reg_read((port*0x80)+offset);
		offset++;
	}

	/* Read all Tx FIFO regs */
	offset = 0x600;
	while(offset <= (0x600 + 0x3E))
	{
		reg_read((port*0x80)+offset);
		offset++;
	}

	spRestore();
}