#include <Copyright.h>
/********************************************************************************
* utils.c
*
* DESCRIPTION:
*       Collection of Utility functions
*
* DEPENDENCIES:   Platform.
*
* FILE REVISION NUMBER:
*
*******************************************************************************/
#include "msSample.h"

static GT_U16 hashMode = 0;
int testPrintEnable = 1;

void testPrint(char* format, ...)
{
	va_list argP;
	char dbgStr[1000] = "";

	if(testPrintEnable == 0)
		return;

	va_start(argP, format);

	vsprintf(dbgStr, format, argP);

	printf("%s",dbgStr);

	return;
}

int vtuEntryCmpFunc(void* buf, int a, int b)
{
    GT_VTU_ENTRY* vtuEntry = (GT_VTU_ENTRY*)buf;

	if ((vtuEntry+a)->vid > (vtuEntry+b)->vid)
		return 1;
	else if ((vtuEntry+a)->vid < (vtuEntry+b)->vid)
		return -1;
	else
		return 0;
}

int atuEntryCmpFunc(void* buf, int a, int b)
{
	GT_ATU_ENTRY *atuEntry = (GT_ATU_ENTRY *)buf;
	GT_U8* aChar,* bChar;
	int i;

	aChar = (GT_U8*)((atuEntry+a)->macAddr.arEther);
	bChar = (GT_U8*)((atuEntry+b)->macAddr.arEther);

	for (i=0; i<6; i++)
	{
		if(*aChar > *bChar)
			return 1;
		else if (*aChar < *bChar)
			return -1;
		aChar++;
		bChar++;
	}

	return 0;

}

/* insertion sort */
GT_STATUS gtSort(int list[], GT_CMP_FUNC cmpFunc, void* buf, GT_U32 len)
{
	GT_U32 index;
	int curValue, preValue;

	if (len <= 1)
		return GT_FAIL;

	preValue = list[0];

	for (index = 1; index < len; ++index)
	{
		curValue = list[index];
		if ((*cmpFunc)(buf, preValue, curValue) > 0)
		{
			/* out of order: list[index-1] > list[index] */
			GT_U32 index2;
			list[index] = preValue; /* move up the larger item first */

			/* find the insertion point for the smaller item */
			for (index2 = index - 1; index2 > 0;)
			{
				int temp_val = list[index2 - 1];
				if ((*cmpFunc)(buf, temp_val, curValue) > 0)
				{
					list[index2--] = temp_val;
					/* still out of order, move up 1 slot to make room */
				}
				else
					break;
			}
			list[index2] = curValue; /* insert the smaller item right here */
		}
		else
		{
			/* in order, advance to next element */
			preValue = curValue;
		}
	}
	return GT_OK;
}
 

GT_U16 hashFunction(char eaddr[])
{
	GT_U16 crc_reg;
	GT_U8 crc_in;
	int i,j;

	crc_reg=0;
	
	for(i=0; i<6; i++)
	{
		crc_in = eaddr[5-i];
		for(j=0; j<8; j++)
		{
			crc_reg = ((((crc_in & 1) ^ ((crc_reg>>15) & 1)) ^ 
						((crc_reg>>14) & 1)) << 15)				|	/* bit 15 */
						((crc_reg & 0x3FFC) << 1) 				|	/* bit 14:3 */
						((((crc_in & 1) ^ ((crc_reg>>15) & 1)) ^ 
						((crc_reg>>1) & 1)) << 2) 				|	/* bit 2 */
						((crc_reg & 1) << 1)					| 	/* bit 1 */
						((crc_in & 1) ^ ((crc_reg>>15) & 1));		/* bit 0 */

			crc_in >>= 1;
		}
	}

	return crc_reg;
}


GT_U16 hashToBucket(GT_U16 hash, GT_U16 mode)
{
	GT_U16 bucket;

	switch (mode)
	{
		case 0:
			bucket = 
			(((hash >> 7) & 1) << 10) |		/* bit 10 */
			(((hash >> 11) & 1) << 9) |		/* bit 9 */
			(((hash >> 3 ) & 1) << 8) |		/* bit 8 */
			(((hash >> 14) & 1) << 7) |		/* bit 7 */
			(((hash >> 12) & 1) << 6) |		/* bit 6 */
			(((hash >> 10) & 1) << 5) |		/* bit 5 */
			(((hash >> 8 ) & 1) << 4) |		/* bit 4 */
			(((hash >> 6 ) & 1) << 3) |		/* bit 3 */
			(((hash >> 4 ) & 1) << 2) |		/* bit 2 */
			(((hash >> 2 ) & 1) << 1) |		/* bit 1 */
			(( hash >> 0 ) & 1); 			/* bit 0 */
			break;
		case 1:
			bucket = 
			(((hash >> 2) & 1) << 10) |		/* bit 10 */
			(((hash >> 12) & 1) << 9) |		/* bit 9 */
			(((hash >> 0 ) & 1) << 8) |		/* bit 8 */
			(((hash >> 10) & 1) << 7) |		/* bit 7 */
			(((hash >> 8 ) & 1) << 6) |		/* bit 6 */
			(((hash >> 7 ) & 1) << 5) |		/* bit 5 */
			(((hash >> 6 ) & 1) << 4) |		/* bit 4 */
			(((hash >> 5 ) & 1) << 3) |		/* bit 3 */
			(((hash >> 4 ) & 1) << 2) |		/* bit 2 */
			(((hash >> 3 ) & 1) << 1) |		/* bit 1 */
			(( hash >> 1 ) & 1); 			/* bit 0 */
			break;
		case 2:
			bucket = 
			(((hash >> 13) & 1) << 10)|		/* bit 10 */
			(((hash >> 15) & 1) << 9) |		/* bit 9 */
			(((hash >> 3 ) & 1) << 8) |		/* bit 8 */
			(((hash >> 14) & 1) << 7) |		/* bit 7 */
			(((hash >> 12) & 1) << 6) |		/* bit 6 */
			(((hash >> 11) & 1) << 5) |		/* bit 5 */
			(((hash >> 10) & 1) << 4) |		/* bit 4 */
			(((hash >> 9 ) & 1) << 3) |		/* bit 3 */
			(((hash >> 8 ) & 1) << 2) |		/* bit 2 */
			(((hash >> 7 ) & 1) << 1) |		/* bit 1 */
			(( hash >> 5 ) & 1); 			/* bit 0 */
			break;
		case 3:
			bucket = 
			(((hash >> 10) & 1) << 10)|		/* bit 10 */
			(((hash >> 8 ) & 1) << 9) |		/* bit 9 */
			(((hash >> 7 ) & 1) << 8) |		/* bit 8 */
			(((hash >> 13) & 1) << 7) |		/* bit 7 */
			(((hash >> 12) & 1) << 6) |		/* bit 6 */
			(((hash >> 10) & 1) << 5) |		/* bit 5 */
			(((hash >> 9 ) & 1) << 4) |		/* bit 4 */
			(((hash >> 6 ) & 1) << 3) |		/* bit 3 */
			(((hash >> 5 ) & 1) << 2) |		/* bit 2 */
			(((hash >> 3 ) & 1) << 1) |		/* bit 1 */
			(( hash >> 2 ) & 1); 			/* bit 0 */
			break;
		default:
			/* treat as case 0 */
			bucket = 
			(((hash >> 7) & 1) << 10) |		/* bit 10 */
			(((hash >> 11) & 1) << 9) |		/* bit 9 */
			(((hash >> 3 ) & 1) << 8) |		/* bit 8 */
			(((hash >> 14) & 1) << 7) |		/* bit 7 */
			(((hash >> 12) & 1) << 6) |		/* bit 6 */
			(((hash >> 10) & 1) << 5) |		/* bit 5 */
			(((hash >> 8 ) & 1) << 4) |		/* bit 4 */
			(((hash >> 6 ) & 1) << 3) |		/* bit 3 */
			(((hash >> 4 ) & 1) << 2) |		/* bit 2 */
			(((hash >> 2 ) & 1) << 1) |		/* bit 1 */
			(( hash >> 0 ) & 1); 			/* bit 0 */
			break;
	}
	return bucket;
}

GT_U16 dbNumMap(GT_U32 bucket, GT_U32 dbNum)
{
	return (GT_U16)(bucket + dbNum);
}

GT_U16 runQDHash(GT_U8* eaddr, GT_U16 dbNum, int bSize, GT_U16* pHash, GT_U16* preBucket, GT_U16* posBucket)
{
	GT_U16 hash, bucket;

	hash = hashFunction(eaddr);
	if (pHash)
		*pHash = hash;
	bucket = hashToBucket(hash,hashMode);
	bucket &= (bSize-1);
	if (preBucket)
		*preBucket = bucket;
	bucket = dbNumMap(bucket,dbNum);
	if (posBucket)
		*posBucket = bucket;
	bucket &= (bSize-1);

	return bucket;
}

GT_U16 hashTest(unsigned int maxMacs, int maxDbNum, int bSize)
{
	char eaddr[6] = {0,0,0,0,0,0};
	char buckets[MAX_BUCKET_SIZE];
	GT_U32 i, dbNum;
	GT_U16 hash, bucket, tmpBucket;

	gtMemSet(buckets,0,MAX_BUCKET_SIZE);

	for(dbNum=0; dbNum<(GT_U32)maxDbNum; dbNum++)
	{
		MSG_PRINT(("DBNum %i:\n", dbNum));
		for(i=1; i<maxMacs; i++)
		{
			eaddr[2] = (char)((i >> 24) & 0xff);
			eaddr[3] = (char)((i >> 16) & 0xff);
			eaddr[4] = (char)((i >> 8) & 0xff);
			eaddr[5] = (char)(i & 0xff);
			tmpBucket=runQDHash((GT_U8*)eaddr, (GT_U16)dbNum, bSize, &hash, &bucket, NULL);
			buckets[tmpBucket]++;
			MSG_PRINT(("EADDR : %02x-%02x-%02x-%02x, ", eaddr[2],eaddr[3],eaddr[4],eaddr[5]));
			MSG_PRINT(("Hash : %03x, ", hash));
			MSG_PRINT(("bucket : %03x, ", bucket));
			MSG_PRINT(("bins : %02x\n", buckets[tmpBucket]-1));
		}

	}

	return 0;
}

GT_U16 hashFindEntriesInBucket(unsigned int maxMacs, int bucketNum, int bSize)
{
	char eaddr[6] = {0,0,0,0,0,0};
	char buckets[MAX_BUCKET_SIZE];
	GT_U32 i, dbNum;
	GT_U16 hash, bucket, tmpBucket;

	gtMemSet(buckets,0,MAX_BUCKET_SIZE);

	dbNum = 0;
	MSG_PRINT(("DBNum %i:\n", dbNum));
	for(i=1; i<maxMacs; i++)
	{
		eaddr[2] = (char)((i >> 24) & 0xff);
		eaddr[3] = (char)((i >> 16) & 0xff);
		eaddr[4] = (char)((i >> 8) & 0xff);
		eaddr[5] = (char)(i & 0xff);
		tmpBucket=runQDHash((GT_U8*)eaddr, (GT_U16)dbNum, bSize, &hash, &bucket, NULL);
		buckets[tmpBucket]++;
		if (tmpBucket != bucketNum)
			continue;
		MSG_PRINT(("EADDR : %02x-%02x-%02x-%02x, ", eaddr[2],eaddr[3],eaddr[4],eaddr[5]));
		MSG_PRINT(("Hash : %03x, ", hash));
		MSG_PRINT(("bucket : %03x, ", bucket));
		MSG_PRINT(("bins : %02x\n", buckets[tmpBucket]-1));
	}

	return 0;
}

void displayHash(char* eaddr, GT_U16 dbNum, GT_U32 bSize)
{
	GT_U16 hash, posBucket, preBucket;

	posBucket=runQDHash(eaddr, dbNum, bSize, &hash, &preBucket, NULL);
	MSG_PRINT(("EADDR : %02x-%02x-%02x-%02x, ", eaddr[2],eaddr[3],eaddr[4],eaddr[5]));
	MSG_PRINT(("Hash : %03x, ", hash));
	MSG_PRINT(("bucket : %03x, ", preBucket));
	MSG_PRINT(("bucket(db) : %03x, ", posBucket));
	MSG_PRINT(("bSize : %03x\n", bSize));
}

GT_U16 hashWrap(int bSize, int entry)
{
	char eaddr[6] = {0,0,0,0,0,0};
	char buckets[MAX_BUCKET_SIZE];
	GT_U32 i, maxMacs;
	GT_U16 hash, bucket, tmpBucket, preBucket;
	int wrapping = 0;
	maxMacs =0xFFFFFFFF;
	gtMemSet(buckets,0,MAX_BUCKET_SIZE);

	MSG_PRINT(("Wrapped Entry :\n"));
	for(i=1; i<maxMacs; i++)
	{
		eaddr[2] = (char)((i >> 24) & 0xff);
		eaddr[3] = (char)((i >> 16) & 0xff);
		eaddr[4] = (char)((i >> 8) & 0xff);
		eaddr[5] = (char)(i & 0xff);
		tmpBucket = runQDHash(eaddr, 15, bSize, &hash, &preBucket, &bucket);
		buckets[tmpBucket]++;
		if(bucket != tmpBucket)
		{
			wrapping++;
			MSG_PRINT(("EADDR : %02x-%02x-%02x-%02x, ", eaddr[2],eaddr[3],eaddr[4],eaddr[5]));
			MSG_PRINT(("Hash : %03x, ", hash));
			MSG_PRINT(("bucket : %03x, ", preBucket));
			MSG_PRINT(("bucket(db) : %03x, ", tmpBucket));
			MSG_PRINT(("bins : %02x\n", buckets[tmpBucket]-1));
		}
		if (wrapping >= entry)
			break;
	}

	return wrapping;
}

/*
	This routine will create ATU Entry List.
	Input
		entrySize - entry size for each dbNum
		dbNumSize - number of DBNums
		sameMacs  - how many same MAC addresses are in the ATU database.
				 	Each of the same addresses are beloging to different DBNum.
*/
GT_U16 createATUList(GT_QD_DEV *dev,TEST_ATU_ENTRY entry[], GT_U16 entrySize, GT_U16 dbNumSize, GT_U16 sameMacs, GT_U16 bSize)
{
	GT_U16 i;
	char* buckets;
	GT_U16 dynamicMacs = 0;
	GT_U16 bucket,dbNum,binSize;
	GT_BOOL	exPrio, fqPri;

	if(dbNumSize == 0)
		return entrySize+1;
	if(entrySize < sameMacs)
		return entrySize+1;

	buckets = (char*)malloc(MAX_BUCKET_SIZE);
	if(buckets == NULL)
	{
		printf("No more available memories\n");
		return -1;
	}
	gtMemSet(buckets,0,MAX_BUCKET_SIZE);

#ifndef TEST_DEBUG
	srand((unsigned)time(NULL));
#else
	srand((unsigned)1);
#endif

	binSize = 4;
	switch(dev->deviceId)
	{
		case GT_88E6131:
		case GT_88E6108:
			hashMode = 1;
			exPrio = GT_FALSE;
			fqPri = GT_FALSE;
			break;
		case GT_88E6031:
		case GT_88E6061:
			hashMode = 1;
			exPrio = GT_TRUE;
			fqPri = GT_FALSE;
			break;
		case GT_88E6035:
		case GT_88E6055:
		case GT_88E6065:
			hashMode = 1;
			exPrio = GT_TRUE;
			fqPri = GT_TRUE;
			break;
		default:
			exPrio = GT_FALSE;
			fqPri = GT_FALSE;
			hashMode = 0;
			break;
	}			

	for(i=0; i<entrySize; i++)
	{
		if(sameMacs)
		{
			memset(&entry[0].atuEntry[i],0,sizeof(GT_ATU_ENTRY));
			
			*(GT_U16*)entry[0].atuEntry[i].macAddr.arEther = (GT_U16)rand();
			*(GT_U16*)(entry[0].atuEntry[i].macAddr.arEther+2) = (GT_U16)(rand() & 0xFFFF);

			do 
			{
				GT_U16 tmpBucket[256];
				*(GT_U16*)(entry[0].atuEntry[i].macAddr.arEther+4) = (GT_U16)(rand() & 0xFFFF);

				for (dbNum=0; dbNum<dbNumSize; dbNum++)
				{
					/* In current implementation, each dbNum will located in different bucket. */

					tmpBucket[dbNum] = runQDHash(entry[0].atuEntry[i].macAddr.arEther, dbNum, bSize, NULL,NULL,NULL);
					if (buckets[tmpBucket[dbNum]] >= binSize)
					{
						/* if bucket is full, find another entry. */
						break;
					}
					else
					{
						continue;
					}
				}

				if (dbNum == dbNumSize)
				{
					/* we found a entry which meets our requirement. */
					entry[0].atuEntry[i].portVec = (GT_U32)(rand() & 0x3FF) % (1<<dev->numOfPorts);
					if(entry[0].atuEntry[i].portVec == 0)
						entry[0].atuEntry[i].portVec = 0x3;
					if(!exPrio)
					{
						entry[0].atuEntry[i].prio = (GT_U8)(rand() & 0x3);
					}
					else
					{
						entry[0].atuEntry[i].exPrio.macQPri = (GT_U8)(rand() & 0x3);
						if(fqPri)
						{
							entry[0].atuEntry[i].exPrio.macFPri = (GT_U8)(rand() & 0x7);
							entry[0].atuEntry[i].exPrio.useMacFPri = GT_TRUE;
						}
					}

					if(entry[0].atuEntry[i].macAddr.arEther[0] & 0x1)
					{
						entry[0].atuEntry[i].entryState.mcEntryState = GT_MC_STATIC;
					}
					else
					{
						entry[0].atuEntry[i].entryState.ucEntryState = GT_UC_DYNAMIC;
						dynamicMacs+=dbNumSize;
					}

					buckets[tmpBucket[0]]++;
					for (dbNum=1; dbNum<dbNumSize; dbNum++)
					{
						buckets[tmpBucket[dbNum]]++;
						memcpy(&entry[dbNum].atuEntry[i],&entry[0].atuEntry[i],sizeof(GT_ATU_ENTRY));
						entry[dbNum].atuEntry[i].DBNum = (GT_U8)dbNum;
					}
#ifdef TEST_DEBUG
					MSG_PRINT(("MAC : %02x-%02x-%02x-%02x-%02x-%02x, ",
									entry[dbNum].atuEntry[i].macAddr.arEther[0],
									entry[dbNum].atuEntry[i].macAddr.arEther[1],
									entry[dbNum].atuEntry[i].macAddr.arEther[2],
									entry[dbNum].atuEntry[i].macAddr.arEther[3],
									entry[dbNum].atuEntry[i].macAddr.arEther[4],
									entry[dbNum].atuEntry[i].macAddr.arEther[5] ));
					MSG_PRINT(("dbNum 0 ~ %x, bucket %03x ~ %03x\n", dbNumSize, tmpBucket[0], tmpBucket[dbNumSize-1]));
#endif
					break;	/* we are done with current dbNum. so exit the while loop */
				}
			} while (1);

			sameMacs--;
		}
		else
		{
			for(dbNum=0; dbNum<dbNumSize; dbNum++)
			{
				memset(&entry[dbNum].atuEntry[i],0,sizeof(GT_ATU_ENTRY));
			
				*(GT_U16*)entry[dbNum].atuEntry[i].macAddr.arEther = (GT_U16)rand();
				*(GT_U16*)(entry[dbNum].atuEntry[i].macAddr.arEther+2) = (GT_U16)(rand() & 0xFFFF);

				do 
				{
					*(GT_U16*)(entry[dbNum].atuEntry[i].macAddr.arEther+4) = (GT_U16)(rand() & 0xFFFF);

					bucket=runQDHash(entry[dbNum].atuEntry[i].macAddr.arEther, dbNum, bSize, NULL,NULL,NULL);
					if (buckets[bucket] >= binSize)
						continue;
					else
					{
#ifdef TEST_DEBUG
						MSG_PRINT(("MAC : %02x-%02x-%02x-%02x-%02x-%02x, ",
									entry[dbNum].atuEntry[i].macAddr.arEther[0],
									entry[dbNum].atuEntry[i].macAddr.arEther[1],
									entry[dbNum].atuEntry[i].macAddr.arEther[2],
									entry[dbNum].atuEntry[i].macAddr.arEther[3],
									entry[dbNum].atuEntry[i].macAddr.arEther[4],
									entry[dbNum].atuEntry[i].macAddr.arEther[5] ));
						MSG_PRINT(("dbNum : %04x, ", dbNum));
						MSG_PRINT(("bucket : %03x, bins : %02x\n", bucket,buckets[bucket]));
#endif
						buckets[bucket]++;
						break;
					}

				} while (1);

				entry[dbNum].atuEntry[i].portVec = (GT_U32)(rand() & 0x3FF) % (1<<dev->numOfPorts);
				if(entry[dbNum].atuEntry[i].portVec == 0)
					entry[dbNum].atuEntry[i].portVec = 0x3;
				if(!exPrio)
				{
					entry[dbNum].atuEntry[i].prio = (GT_U8)(rand() & 0x3);
				}
				else
				{
					entry[dbNum].atuEntry[i].exPrio.macQPri = (GT_U8)(rand() & 0x3);
					if(fqPri)
					{
						entry[dbNum].atuEntry[i].exPrio.macFPri = (GT_U8)(rand() & 0x7);
						entry[dbNum].atuEntry[i].exPrio.useMacFPri = GT_TRUE;
					}
				}
				entry[dbNum].atuEntry[i].DBNum = (GT_U8)dbNum;

				if(entry[dbNum].atuEntry[i].macAddr.arEther[0] & 0x1)
				{
					entry[dbNum].atuEntry[i].entryState.mcEntryState = GT_MC_STATIC;
				}
				else
				{
					entry[dbNum].atuEntry[i].entryState.ucEntryState = GT_UC_DYNAMIC;
					dynamicMacs++;
				}
			}
		}
	}

	free(buckets);

	return dynamicMacs;
}


GT_STATUS testFixedAtu(GT_QD_DEV *dev,GT_U8 dbNum,GT_U8 atuSize)
{
	GT_STATUS status;
	GT_ATU_ENTRY macEntry[16];
	int i;
	GT_U32 u32Data1;

	/* Set ATU Size will cause ATU reset and SW reset, so call before any other setup. */
	MSG_PRINT(("Setting ATU Size\n"));
	if((status = gfdbSetAtuSize(dev,atuSize)) != GT_OK)
	{
		MSG_PRINT(("gfdbSetAtuSize returned fail.\n"));
		return status;
	}

	/* Disable Aging */
	MSG_PRINT(("Disable Aging Timeout... \n"));
	if((status = gfdbSetAgingTimeout(dev,0)) != GT_OK)
	{
		MSG_PRINT(("gfdbSetAgingTimeout returned fail.\n"));
		return status;
	}

	/* Disable Learning */
	MSG_PRINT(("Disable Learning... \n"));
	if((status = gfdbLearnEnable(dev,GT_FALSE)) != GT_OK)
	{
		MSG_PRINT(("gfdbSetAtuSize returned fail.\n"));
		return status;
	}

	/* Flush all addresses from the ATU table. */
	MSG_PRINT(("Flush out all the entries in the ATU Table ... \n"));
	if((status = gfdbFlush(dev,GT_FLUSH_ALL)) != GT_OK)
	{
		MSG_PRINT(("gfdbFlush returned fail.\n"));
		return status;
	}

	/* Get Atu Dynamic Count, which should be 0, since we flush them all. */
	if((status = gfdbGetAtuDynamicCount(dev,&u32Data1)) != GT_OK)
	{
		MSG_PRINT(("gfdbGetAtuDynamicCount returned fail.\n"));
		return status;
	}

	MSG_PRINT(("Atu Dynamic Count : %d.\n", u32Data1));

	/* Now ATU table is clean. Play with our own MAC entries */	
	MSG_PRINT(("Setup Testing Table... \n"));

	gtMemSet(macEntry,0,sizeof(macEntry));

	/* bucket 0xee */
	*(GT_U16*)&macEntry[0].macAddr.arEther[4] = 0xd1b;
	macEntry[0].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[0].DBNum = dbNum;

	*(GT_U16*)&macEntry[1].macAddr.arEther[4] = 0xd1e;
	macEntry[1].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[1].DBNum = dbNum;

	*(GT_U16*)&macEntry[2].macAddr.arEther[4] = 0xddb;
	macEntry[2].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[2].DBNum = dbNum;

	*(GT_U16*)&macEntry[3].macAddr.arEther[4] = 0xdde;
	macEntry[3].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[3].DBNum = dbNum;

	/* bucket 0xef */
	*(GT_U16*)&macEntry[4].macAddr.arEther[4] = 0xd1a;
	macEntry[4].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[4].DBNum = dbNum;

	*(GT_U16*)&macEntry[5].macAddr.arEther[4] = 0xd1f;
	macEntry[5].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[5].DBNum = dbNum;

	*(GT_U16*)&macEntry[6].macAddr.arEther[4] = 0xdda;
	macEntry[6].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[6].DBNum = dbNum;

	*(GT_U16*)&macEntry[7].macAddr.arEther[4] = 0xddf;
	macEntry[7].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[7].DBNum = dbNum;

	/* bucket 0xf0 */
	*(GT_U16*)&macEntry[8].macAddr.arEther[4] = 0x440;
	macEntry[8].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[8].DBNum = dbNum;

	*(GT_U16*)&macEntry[9].macAddr.arEther[4] = 0x485;
	macEntry[9].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[9].DBNum = dbNum;

	*(GT_U16*)&macEntry[10].macAddr.arEther[4] = 0x1123;
	macEntry[10].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[10].DBNum = dbNum;

	*(GT_U16*)&macEntry[11].macAddr.arEther[4] = 0x1223;
	macEntry[11].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[11].DBNum = dbNum;

	/* bucket 0xf0 */
	*(GT_U16*)&macEntry[12].macAddr.arEther[4] = 0x441;
	macEntry[12].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[12].DBNum = dbNum;

	*(GT_U16*)&macEntry[13].macAddr.arEther[4] = 0x484;
	macEntry[13].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[13].DBNum = dbNum;

	*(GT_U16*)&macEntry[14].macAddr.arEther[4] = 0xb41;
	macEntry[14].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[14].DBNum = dbNum;

	*(GT_U16*)&macEntry[15].macAddr.arEther[4] = 0x444;
	macEntry[15].entryState.ucEntryState = GT_UC_DYNAMIC;
	macEntry[15].DBNum = dbNum;

	
	for(i=0; i<16; i++)
	{
		displayHash(macEntry[i].macAddr.arEther,dbNum,64<<atuSize);
		if((status = gfdbAddMacEntry(dev,&macEntry[i])) != GT_OK)
		{
			MSG_PRINT(("gfdbAddMacEntry returned fail.\n"));
			return status;
		}
	}

	testDisplayATUList(dev);
	return GT_OK;

}