kscmds.c

ks8995m5口交换机启动eeprom配置源码

//		Command:
//
//		dp      Port          Dump port control and status registers.
//
//  Parameters:
//      int elem1   Port number
//      int elem2   NOPARAMETER
//      int elem3   NOPARAMETER
//  
//  Return Vlaue:
//      SUCCESS or PARMERROR
//
//--------------------------------------------------------------------------
int DumpPortCtlReg ( int elem1, int elem2, int elem3 )
{

	int iRegNdx, iNdx;

	if ( elem2 != NOPARAMETER || elem3 != NOPARAMETER )
		return PARMERROR;	

	// Check port range
	if ( elem1 < 1 || elem1 > 5 )
		return PARMERROR;

	iRegNdx = elem1 * 16;

	// Control Register
	for ( iNdx = 0; iNdx < 14; iNdx++ )
	{
		printf ( "\nPort %01d Control Register (0x%02x) = 0x%02x", elem1, iRegNdx + iNdx, ReadData ( (BYTE) (iRegNdx + iNdx) ) );	
	}

	// Status registers
	for ( ; iNdx < 16; iNdx++ )
	{
		printf ( "\nPort %01d Status Register (0x%02x) = 0x%02x", elem1, iRegNdx + iNdx, ReadData ( (BYTE) (iRegNdx +iNdx) ) );	
	}

	return SUCCESS;
}


//--------------------------------------------------------------------------
//  
//  void GetStaticMACBytes
//  
//  Description:
//      Read two MSB bytes from static MAC address table entries.
//
//  Parameters:
//      int iEntry      MAC address table entry number
//      BYTE *bByte7    Pointer to content of byte 7   
//      BYTE *bByte8    Pointer to content of byte 8
//  
//  Return Vlaue:
//      None
//
//--------------------------------------------------------------------------
void GetStaticMACBytes ( int iEntry, BYTE *bByte7, BYTE *bByte8 )
{
	WriteData ( INDIRECTCTL1, INDIRECTREAD | INDIRECTSMACTAB );
	WriteData ( INDIRECTCTL2, (BYTE) iEntry );

	*bByte8 = ReadData ( INDIRECTDATABASE + 1 );
	*bByte7 = ReadData ( INDIRECTDATABASE + 2 );

	return;
}

//--------------------------------------------------------------------------
//  
//  void GetStaticMACTableEntry
//  
//  Description:
//      Read Static MAC address table enty n and display to console.
//
//      Note: Read and Write the static MAC table entries are shifting one bit
//
//  Parameters:
//      int iEntry      MAC address table entry number
//  
//  Return Vlaue:
//      None
//
//--------------------------------------------------------------------------
void GetStaticMACTableEntry ( int iEntry )
{
#ifdef DOSBOX
#define FPORTBITMAPLEN		5  // Forwarding port bitmap length

	char sBitMap[5];	// Holds 5 binary digits for forwarding port bitmap
#endif

	union utag {
		BYTE data;	
		struct stag {
#ifdef LINUX
			unsigned filler : 3;
			unsigned Fid : 4;
			unsigned useFID :1;
#else
			unsigned useFID :1;
			unsigned Fid : 4;
			unsigned filler : 3;
#endif
		} field;

	} byte8;


	union {
		BYTE data;
		struct {
#ifdef LINUX
			unsigned filler : 1;
			unsigned override :1;
			unsigned valid : 1;
			unsigned forwardingports : 5;
#else
			unsigned forwardingports : 5;
			unsigned valid : 1;
			unsigned override :1;
			unsigned filler : 1;
#endif
		} field;
	} byte7;


	GetStaticMACBytes ( iEntry, &byte7.data, &byte8.data );

	printf ( "\nStatic MAC Table Entry (%0d) => FID = %0x Use FID = %01d Override Bit= %01d",
		iEntry,
		byte8.field.Fid,
		byte8.field.useFID,
		byte7.field.override);

#ifdef DOSBOX

	ConvertToBinaryDigits ( byte7.field.forwardingports, sBitMap, FPORTBITMAPLEN );

	printf ( "\nStatic MAC Table Entry (%d) => Valid Bit = %01d Forwarding ports = %05s",
		iEntry,
		byte7.field.valid,
		sBitMap);

#else
	printf ( "\nStatic MAC Table Entry (%d) => Valid Bit = %01d Forwarding ports = %05b",
		iEntry,
		byte7.field.valid,
		byte7.field.forwardingports);

#endif	

	printf ( "\nStatic MAC Table Entry (%d) => MAC Address %02x:%02x:%02x:%02x:%02x:%02x",
		iEntry,
		ReadData ( INDIRECTDATABASE + 3),
		ReadData ( INDIRECTDATABASE + 4),
		ReadData ( INDIRECTDATABASE + 5),
		ReadData ( INDIRECTDATABASE + 6),
		ReadData ( INDIRECTDATABASE + 7),
		ReadData ( INDIRECTDATABASE + 8) );


	return;
}

//--------------------------------------------------------------------------
//  
//  int DumpStaticMACTable
//  
//  Description:
//		Command:
//
//		dstab      (n)          Dump complete static MAC address table. If n is
//                              specified, only display the entry that is specified.
//
//  Parameters:
//      int elem1   MAC address table entry number (optional)
//      int elem2   NOPARAMETER
//      int elem3   NOPARAMETER
//  
//  Return Vlaue:
//      SUCCESS or PARMERROR
//
//--------------------------------------------------------------------------
int DumpStaticMACTable ( int elem1, int elem2, int elem3 )
{

	int	iNdx;

	if ( elem2 != NOPARAMETER || elem3 != NOPARAMETER )
		return PARMERROR;

	if ( elem1 > SMACTABTOTAL )
		return PARMERROR;


	if ( elem1 == NOPARAMETER ) // Dump the whole table
	{
		for ( iNdx = 0; iNdx < SMACTABTOTAL; iNdx++ )
			GetStaticMACTableEntry ( iNdx );
		
	}
	else
		GetStaticMACTableEntry ( elem1 );

	return SUCCESS;
}


//--------------------------------------------------------------------------
//  
//  int DumpTOSReg
//  
//  Description:
//		Command:
//
//		dtos        Dump TOS Priority Control registers
//
//  Parameters:
//      int elem1   NOPARAMETER
//      int elem2   NOPARAMETER
//      int elem3   NOPARAMETER
//  
//  Return Vlaue:
//      SUCCESS or PARMERROR
//
//--------------------------------------------------------------------------
int DumpTOSReg ( int elem1, int elem2, int elem3 )
{
#define TOSREGBEGIN		96
#define TOSREGEND		103

	int iNdx;

	if ( elem1 != NOPARAMETER || elem2 != NOPARAMETER || elem3 != NOPARAMETER )
		return PARMERROR;	

	for ( iNdx = TOSREGBEGIN; iNdx <= TOSREGEND; iNdx++ )
		printf ( "\nTOS Priority Control Register (0x%02x) = 0x%02x", iNdx, ReadData ( (BYTE) iNdx ) );	

	return SUCCESS;
}

//--------------------------------------------------------------------------
//  
//  int GetVLANBytes
//  
//  Description:
//      Read three VLAN bytes accroding to entry number bEntry.
//
//  Parameters:
//      BYTE bEntry     Entry number
//      BYTE *bByte0    The first byte read
//      BYTE *bByte1    The second byte read
//      BYTE *bByte2    The thrid byte read
//  
//  Return Vlaue:
//      None
//
//--------------------------------------------------------------------------
void GetVLANBytes ( BYTE bEntry, BYTE *bByte0, BYTE *bByte1, BYTE *bByte2 )
{

	WriteData ( INDIRECTCTL1, INDIRECTREAD | INDIRECTVLANTAB );
	WriteData ( INDIRECTCTL2, bEntry );

	*bByte2 = ReadData ( INDIRECTDATABASE + 6 ) & 0x3f;
	*bByte1 = ReadData ( INDIRECTDATABASE + 7 );
	*bByte0 = ReadData ( INDIRECTDATABASE + 8 );

	return;
}

//--------------------------------------------------------------------------
//  
//  int GetVLANTableEntry
//  
//  Description:
//      Call GetVLANBytes() to get three VLAN bytes based on bEntry. Format the bytes and display them.
//      
//  Parameters:
//      BYTE bEntry     Entry number
//  
//  Return Vlaue:
//      None
//
//--------------------------------------------------------------------------
void GetVLANTableEntry ( BYTE bEntry )
{
#ifdef DOSBOX
#define MEMBERBITMAPLEN		5                   // Membership bitmap length

	char sBitMap[ MEMBERBITMAPLEN + 1];			// Holds 5 binary digits for forwarding port bitmap
#endif


	union utag {
		BYTE data[3];	
		struct stag {
			unsigned VID2 : 8;
#ifdef LINUX
			unsigned Fid : 4;
			unsigned VID1 : 4;

			unsigned filler : 2;
			unsigned Valid :1;
			unsigned Membership: 5;
#else
			unsigned VID1 : 4;
			unsigned Fid : 4;
			unsigned Membership: 5;
			unsigned Valid :1;
			unsigned filler : 2;
#endif
		} field;

	} vlantab;


	GetVLANBytes ( bEntry, &vlantab.data[0], &vlantab.data[1], &vlantab.data[2] );

#ifdef DOSBOX

	ConvertToBinaryDigits ( vlantab.field.Membership, sBitMap, MEMBERBITMAPLEN );

	printf ( "\nVLAN Table Entry (%02d) => VID = %03x FID = %0x Membership = %05s Valid bit = %01x",
		bEntry,
		( vlantab.field.VID1 << 8 ) | vlantab.field.VID2,
		vlantab.field.Fid,
		sBitMap,
		vlantab.field.Valid);

#else
	printf ( "\nVLAN Table Entry (%02d) => VID = %03x FID = %0x Membership = %05b Valid bit = %01x",
		bEntry,
		( vlantab.field.VID1 << 8 ) | vlantab.field.VID2,
		vlantab.field.Fid,
		vlantab.field.Membership,
		vlantab.field.Valid);
#endif
	return;

}

//--------------------------------------------------------------------------
//  
//  int DumpVLANReg
//  
//  Description:
//		Command:
//
//		dvtab      (n)          Dump complete VLAN table. If n is
//                              specified, only display the entry that is specified.
//
//  Parameters:
//      int elem1   VLAN table entry number (optional)
//      int elem2   NOPARAMETER
//      int elem3   NOPARAMETER
//  
//  Return Vlaue:
//      SUCCESS or PARMERROR
//
//--------------------------------------------------------------------------
int DumpVLANReg ( int elem1, int elem2, int elem3 )
{
	int iNdx;

	if ( elem2 != NOPARAMETER || elem3 != NOPARAMETER )
		return PARMERROR;

	if ( elem1 >= VLANENTRIES )
		return PARMERROR;


	if ( elem1 == NOPARAMETER )	// Dump complete VLAN table
	{
		for ( iNdx = 0; iNdx < VLANENTRIES; iNdx++ )
		{
			GetVLANTableEntry ( (BYTE) iNdx );
		}
	}
	else
		GetVLANTableEntry ( (BYTE) elem1 );

	return SUCCESS;
}


//--------------------------------------------------------------------------
//  
//  int ReadMIB
//  
//  Description:
//		Command:
//
//		rmib    Port    n   (s)     Read the specified MIB counter. Repeat every "s" seconds if
//                                  specified.
//                              
//
//  Parameters:
//      int elem1   Port number
//      int elem2   MIB number
//      int elem3   Number of seconds (optional)
//  
//  Return Vlaue:
//      SUCCESS or PARMERROR
//
//--------------------------------------------------------------------------
int ReadMIB ( int elem1, int elem2, int elem3 )
{
	
	unsigned long ulTemp;
	int ch =0;
	time_t  tStart, tEnd;

	if ( elem1 == NOPARAMETER || elem2 == NOPARAMETER )
		return PARMERROR;

	if ( elem1 < 1 || elem1 > 5 )
		return PARMERROR;

	giMIBOverflow = FALSE;

	ulMIB[elem1][elem2] = 0;

	ulTemp = GetMIBCounter ( (BYTE) elem1, (BYTE) elem2 );

	ulMIB[elem1][elem2] += ulTemp;

	printf ( "\nPort %01d MIB Counter %s (0x%02x) = %lu", elem1, MIBNames[ elem2 ], elem2, ulTemp );

	printf ("\n");
	
	if ( elem3 > 0 )
	{

#ifdef LINUX
        EnableLINUXkbhit ();
#endif 

		time (&tStart);

		tEnd = tStart; 

		while(ch != 'q') {
		
			if ( tEnd - tStart  >= elem3 )
			{
				
				ulTemp = GetMIBCounter ( (BYTE) elem1, (BYTE) elem2 );

				printf ( "\nPort %01d MIB Counter %s (0x%02x) = %lu", elem1, MIBNames[ elem2 ], elem2, ulTemp );

				ulMIB[elem1][elem2] += ulTemp;

				printf ( "\nTotal =  %lu", ulMIB[elem1][elem2]);
	
				printf ("\n");

				tStart = tEnd;
			}

			time (&tEnd);
			
			if(_kbhit()) {
				ch = _getch();
			}
		}

#ifdef LINUX
        DisableLINUXkbhit ();

#endif

	}


	if ( giMIBOverflow )
	{

		printf ( "\n!!!!!!!!!!!!!!!!!!!!!!!!");
		printf ( "\n!                      !");
		printf ( "\n! MIB Counter overflow !");
		printf ( "\n!                      !");
		printf ( "\n!!!!!!!!!!!!!!!!!!!!!!!!");

	}
	
	return SUCCESS;
}


//--------------------------------------------------------------------------
//  
//  int ReadNextReg
//  
//  Description:
//      Command:
//
//      rn      Read next register content. Global variable igRRegNdx points to
//              the current register.
//
//  Parameters:
//      int elem1       NOPARAMETER
//      int elem2       NOPARAMETER
//      int elem3       NOPARAMETER
//  
//  Return Vlaue:
//      SUCCESS or PARMERROR
//  
//--------------------------------------------------------------------------
int ReadNextReg ( int elem1, int elem2, int elem3 )
{
	if ( elem1 != NOPARAMETER || elem2 != NOPARAMETER || elem3 != NOPARAMETER )
		return PARMERROR;	

	igRRegNdx++;
	
	if ( igRRegNdx == REGISTERTOTAL )
		igRRegNdx = 0;