cmdtest.c

Atheros AP Test with Agilent N4010A source code

	A_UINT32 num_tx_desc = 2;
	A_UINT32 tx_length = 100;
	A_UINT32 retry = 5;		// broadcast mode, disable retry
    A_UINT32 antenna = USE_DESC_ANT | DESC_ANT_A;
	A_UINT32 broadcast = 0;	// disable broadcast mode

	// for rx
	A_UINT32 num_rx_desc = 1000;
	A_UINT32 rx_length = sizeof(TEST_INFO_STRUCT);
	A_UINT32 enable_ppm = 0;

	// for rxDataBegin
	A_UINT32 start_timeout = 30000; //100;
	A_UINT32 complete_timeout = 10000;
	A_UINT32 stats_mode = 0; //ENABLE_STATS_SEND | ENABLE_STATS_RECEIVE;
	A_UINT32 compare = 0;
	A_UCHAR  pattern[] = {0xaa, 0x55};
	A_UINT32 channel = testSetup.sideChannel2G;
	A_UCHAR  buffer[500];
	A_UINT16 *mdkPacketType;

//	uiPrintf("\nWaiting for transmitter to ring the bell ...\n");

	if(configSetup.mode == MODE_11A){
		channel = testSetup.sideChannel5G;
	}


	art_setResetParams(devNum, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
			(A_BOOL)configSetup.eepromHeaderLoad, (A_UCHAR)configSetup.mode, configSetup.use_init);		
	while(!kbhit()) {
		art_resetDevice(devNum, goldenStation, bssID, channel, configSetup.turbo);
		art_mdkErrNo=0;
		art_setAntenna(devNum, configSetup.antenna);
		art_rxDataSetup(devNum, num_rx_desc, rx_length, enable_ppm);
		art_rxDataBegin(devNum, start_timeout, complete_timeout, stats_mode | LEAVE_DESC_STATUS, compare, pattern, 2);
//		Sleep(100);
		if (art_mdkErrNo==0) {
#ifdef _DEBUG
			uiPrintf("\nReceived wakeup by DUT, setting up for test\n");
#endif
			//extract the info from the packet
			art_rxGetData(devNum, 0, buffer, rx_length + MDK_PACKET_OVERHEAD);  
			memcpy(pTestInfo, buffer + MDK_PACKET_OVERHEAD, sizeof(TEST_INFO_STRUCT));
			//SNOOP
//			tempPtr = (A_UINT32 *)buffer;
//			for(i = 0; i < 16; i++, tempPtr++) {
//				uiPrintf("%x ", *tempPtr);
//			}
//			uiPrintf("\n");
			//end snoop
			mdkPacketType = (A_UINT16 *)(buffer + sizeof(WLAN_DATA_MAC_HEADER3));
			if(*mdkPacketType != MDK_NORMAL_PKT) {
				//this is not the correct packet, so go back to waiting
				uiPrintf("SNOOP: handshake is not normal packet\n");
				continue;
			}
			break;
		}
	}
	return;
}

void goldenCompleteWakeupCall
(
 A_UINT32 devNum
)
{
	// txDataSetup
	A_UINT32 rate_mask = RATE_6; //0xff; // all rates	
	A_UINT32 turbo = 0;
	A_UINT32 num_tx_desc = 15; //2;
	A_UINT32 tx_length = sizeof(TEST_INFO_STRUCT);
	A_UINT32 retry = 10;	
	A_UINT32 broadcast = 0;

	// rxDataSetup
	A_UINT32 num_rx_desc = 100;
	A_UINT32 rx_length = 100;
	A_UINT32 enable_ppm = 0;
	A_UINT32 compare = 0;

	// txrxDataBegin
	A_UINT32 start_timeout = 0;	// no wait time for transmit
	A_UINT32 complete_timeout = 5000;
	A_UINT32 stats_mode = 0; 
	A_UINT16 ii=0;
	A_UCHAR  pattern[] = {0xaa, 0x55};
	A_UINT32 channel = testSetup.sideChannel2G;

	if(configSetup.mode == MODE_11A){
		channel = testSetup.sideChannel5G;
	}

	art_resetDevice(devNum, goldenStation, bssID, channel, configSetup.turbo);

	while(!kbhit()) {
	    art_txDataSetup(devNum, rate_mask, dutStation, num_tx_desc, tx_length,
			pattern, 2, retry,configSetup.antenna, broadcast);
		art_txDataBegin(devNum, complete_timeout, 0);
		if(art_mdkErrNo==0) {
#ifdef _DEBUG
			uiPrintf("\nGolden Unit is ready to go!\n");
#endif
			break;
		}
	}
	while(kbhit())
		getch();	// clean up buffer

	//cleanup descriptor queues, to free up mem
	art_cleanupTxRxMemory(devNum, TX_CLEAN | RX_CLEAN);
	return;
}

void printFailures
(
 A_UINT32 reasonFailMask
)
{
	if(reasonFailMask & MASK_LINKTEST_TX_PER_ANTA) {
		uiPrintf("   High PER(P) on antenna A. Error code %d\n", ERR_LINKTEST_TX_PER_ANTA);
	}
	if(reasonFailMask & MASK_LINKTEST_TX_PER_ANTB) {
		uiPrintf("   High PER(P) on antenna B. Error code %d\n", ERR_LINKTEST_TX_PER_ANTB);
	}
	if(reasonFailMask & MASK_LINKTEST_TX_PPM_ANTA) {
		uiPrintf("   PPM out of range(M) on antenna A. Error code %d\n", ERR_LINKTEST_TX_PPM_ANTA);
	}
	if(reasonFailMask & MASK_LINKTEST_TX_PPM_ANTB) {
		uiPrintf("   PPM out of range(M) on antenna B. Error code %d\n", ERR_LINKTEST_TX_PPM_ANTB);
	}
	if(reasonFailMask & MASK_LINKTEST_TX_RSSI_ANTA) {
		uiPrintf("   Low RSSI(R) on antenna A. Error code %d\n", ERR_LINKTEST_TX_RSSI_ANTA);
	}
	if(reasonFailMask & MASK_LINKTEST_TX_RSSI_ANTB) {
		uiPrintf("   Low RSSI(R) on antenna B. Error code %d\n", ERR_LINKTEST_TX_RSSI_ANTB);
	}
	if(reasonFailMask & MASK_LINKTEST_TX_CRC_ANTA) {
		uiPrintf("   Many CRC errors(C) on antenna A. Error code %d\n", ERR_LINKTEST_TX_CRC_ANTA);
	}
	if(reasonFailMask & MASK_LINKTEST_TX_CRC_ANTB) {
		uiPrintf("   Many CRC errors(C) on antenna B. Error code %d\n", ERR_LINKTEST_TX_CRC_ANTB);
	}
	if(reasonFailMask & MASK_LINKTEST_RX_PER_ANTA) {
		uiPrintf("   High PER(P) on antenna A. Error code %d\n", ERR_LINKTEST_RX_PER_ANTA);
	}
	if(reasonFailMask & MASK_LINKTEST_RX_PER_ANTB) {
		uiPrintf("   High PER(P) on antenna B. Error code %d\n", ERR_LINKTEST_RX_PER_ANTB);
	}
	if(reasonFailMask & MASK_LINKTEST_RX_PPM_ANTA) {
		uiPrintf("   PPM out of range(M) on antenna A. Error code %d\n", ERR_LINKTEST_RX_PPM_ANTA);
	}
	if(reasonFailMask & MASK_LINKTEST_RX_PPM_ANTB) {
		uiPrintf("   PPM out of range(M) on antenna B. Error code %d\n", ERR_LINKTEST_RX_PPM_ANTB);
	}
	if(reasonFailMask & MASK_LINKTEST_RX_RSSI_ANTA) {
		uiPrintf("   Low RSSI(R) on antenna A. Error code %d\n", ERR_LINKTEST_RX_RSSI_ANTA);
	}
	if(reasonFailMask & MASK_LINKTEST_RX_RSSI_ANTB) {
		uiPrintf("   Low RSSI(R) on antenna B. Error code %d\n", ERR_LINKTEST_RX_RSSI_ANTB);
	}
	if(reasonFailMask & MASK_LINKTEST_RX_CRC_ANTA) {
		uiPrintf("   Many CRC errors(C) on antenna A. Error code %d\n", ERR_LINKTEST_RX_CRC_ANTA);
	}
	if(reasonFailMask & MASK_LINKTEST_RX_CRC_ANTB) {
		uiPrintf("   Many CRC errors(C) on antenna B. Error code %d\n", ERR_LINKTEST_RX_CRC_ANTB);
	}
	if(reasonFailMask & MASK_THROUGHPUT_PER_ANTA) {
		uiPrintf("   High PER(P) on antenna A. Error code %d\n", ERR_THROUGHPUT_PER_ANTA);
	}
	if(reasonFailMask & MASK_THROUGHPUT_PER_ANTB) {
		uiPrintf("   High PER(P) on antenna B. Error code %d\n", ERR_THROUGHPUT_PER_ANTB);
	}
	if(reasonFailMask & MASK_THROUGHPUT_RSSI_ANTA) {
		uiPrintf("   Low RSSI(R) on antenna A. Error code %d\n", ERR_THROUGHPUT_RSSI_ANTA);
	}
	if(reasonFailMask & MASK_THROUGHPUT_RSSI_ANTB) {
		uiPrintf("   Low RSSI(R) on antenna B. Error code %d\n", ERR_THROUGHPUT_RSSI_ANTB);
	}
	if(reasonFailMask & MASK_THROUGHPUT_THRESH_ANTA) {
		uiPrintf("   Throughput too low(t) on antenna A. Error code %d\n", ERR_THROUGHPUT_THRESH_ANTA);
	}
	if(reasonFailMask & MASK_THROUGHPUT_THRESH_ANTB) {
		uiPrintf("   Throughput too low(t) on antenna B. Error code %d\n", ERR_THROUGHPUT_THRESH_ANTB);
	}
	if(reasonFailMask & MASK_COMMS_FAILURE) {
		uiPrintf("   Poor communications with golden unit. Error code %d\n", ERR_COMMS_FAIL);
	}
	if(reasonFailMask & MASK_EEPROM_BACKUP_FAIL) {
		uiPrintf("   Backup EEPROM failure. Error code %d\n", ERR_EEPROM_BACKUP);
	}
	if(reasonFailMask & MASK_EEPROM_RESTORE_FAIL) {
		uiPrintf("   Restore EEPROM failure. Error code %d\n", ERR_EEPROM_RESTORE);
	}
	if(reasonFailMask & MASK_EEPROM_COMP_VALUE_FAIL) {
		uiPrintf("   EEPROM single value compare failure. Error code %d\n", ERR_COMP_SINGLE_EEPROM_VAL);
	}
	return;
}

void printFailLetters
(
 A_UINT32 reasonFailMask
)
{
	
	if((reasonFailMask & MASK_LINKTEST_TX_RSSI_ANTA)||(reasonFailMask & MASK_LINKTEST_TX_RSSI_ANTB) ||
	   (reasonFailMask & MASK_LINKTEST_RX_RSSI_ANTA)||(reasonFailMask & MASK_LINKTEST_RX_RSSI_ANTB) ||
	   (reasonFailMask & MASK_THROUGHPUT_RSSI_ANTA)||(reasonFailMask & MASK_THROUGHPUT_RSSI_ANTB)) {
		uiPrintf("R");
	}
	if((reasonFailMask & MASK_LINKTEST_TX_CRC_ANTA)||(reasonFailMask & MASK_LINKTEST_TX_CRC_ANTB)||
		(reasonFailMask & MASK_LINKTEST_RX_CRC_ANTA)||(reasonFailMask & MASK_LINKTEST_RX_CRC_ANTB)) {
		uiPrintf("C");
	}
	if((reasonFailMask & MASK_LINKTEST_TX_PER_ANTA)||(reasonFailMask & MASK_LINKTEST_TX_PER_ANTB)||
		(reasonFailMask & MASK_LINKTEST_RX_PER_ANTA)||(reasonFailMask & MASK_LINKTEST_RX_PER_ANTB)||
		(reasonFailMask & MASK_THROUGHPUT_PER_ANTA)||(reasonFailMask & MASK_THROUGHPUT_PER_ANTB)) {
		uiPrintf("P");
	}
	if((reasonFailMask & MASK_LINKTEST_TX_PPM_ANTA)||(reasonFailMask & MASK_LINKTEST_TX_PPM_ANTB)||
		(reasonFailMask & MASK_LINKTEST_RX_PPM_ANTA)||(reasonFailMask & MASK_LINKTEST_RX_PPM_ANTB)) {
		uiPrintf("M");
	}
	if((reasonFailMask & MASK_THROUGHPUT_THRESH_ANTA)||(reasonFailMask & MASK_THROUGHPUT_THRESH_ANTA)) {
		uiPrintf("T");
	}
	return;
}

A_UINT32 printTestSummary
(
 A_UINT32 reasonFailMask
)
{
	A_UINT32 mask = 0x01;
	A_UINT32 nextErrorCode = ERR_LINKTEST_TX_PER_ANTA;
	A_UINT32 lastErrorCode = 0;

	uiPrintf("\n\n*************************************************\n");
	if(!reasonFailMask) {
		uiPrintf("\nDEVICE PASSED, return code 0");
	}
	else {
		uiPrintf("\nDEVICE FAILED with error code(s): ");
		while(reasonFailMask) {
			if(mask & reasonFailMask) {
				uiPrintf("%d ", nextErrorCode);
				lastErrorCode = nextErrorCode;
			}
			reasonFailMask = reasonFailMask & ~mask;
			mask = mask << 1;
			nextErrorCode++;
		}
	}
	uiPrintf("\n\n*************************************************\n");
	return(lastErrorCode);
}

A_BOOL testMacAddress
(
	WLAN_MACADDR *addressIn
)
{
	

	if((A_MACADDR_COMP(addressIn, &testSetup.minMacAddress) >= 0) &&
		(A_MACADDR_COMP(addressIn, &testSetup.maxMacAddress) <= 0)) {
		return TRUE;
	}
	return FALSE;
}

A_BOOL parseTestFile(void) 
{
    FILE *fStream;
    char lineBuf[222], *pLine;
	char delimiters[]   = " \t";

    uiPrintf("\nReading in Test Setup\n");
    if( (fStream = fopen( TESTSETUP_FILE, "r")) == NULL ) {
        uiPrintf("Failed to open %s - using Defaults\n", TESTSETUP_FILE);
        return 0;
    }

    while(fgets(lineBuf, 120, fStream) != NULL) {
        pLine = lineBuf;
        while(isspace(*pLine)) pLine++;
        if(*pLine == '#') {
            continue;
        }
		if(*pLine == '\0') {
			continue;
		}
		else if(strnicmp("NUM_ITERATIONS", pLine, strlen("NUM_ITERATIONS")) == 0) {
            pLine = strchr(pLine, '=');
            pLine++;
	        pLine = strtok( pLine, delimiters ); //get past any white space etc

            if(!sscanf(pLine, "%ld", &testSetup.numIterations)) {
                uiPrintf("Unable to read the NUM_ITERATIONS from %s\n", TESTSETUP_FILE);
				return 0;
            }
			
			//check to see if command line arg was specified, if so this overrides file
			if(configSetup.iterations) {
				testSetup.numIterations = configSetup.iterations;
			}
        }
		else if(strnicmp("NUM_PACKETS", pLine, strlen("NUM_PACKETS")) == 0) {
            pLine = strchr(pLine, '=');
            pLine++;
	        pLine = strtok( pLine, delimiters ); //get past any white space etc

            if(!sscanf(pLine, "%ld", &testSetup.numPackets)) {
                uiPrintf("Unable to read the NUM_PACKETS from %s\n", TESTSETUP_FILE);
				return 0;
            }
			
			//check for exeeding max
			if(testSetup.numPackets > MAX_NUM_PACKETS) {
                uiPrintf("NUM_PACKETS should be less than %d\n", MAX_NUM_PACKETS);
				return 0;
			}
			if ((thin_client) && (configSetup.cmdLineTestMask & RX_TEST_MASK) &&  (testSetup.numPackets > MAX_NUM_RX_PACKETS)) {
				uiPrintf("WARNING:Setting NUM_PACKETS to %d, for thin client cards\n", MAX_NUM_RX_PACKETS);
				testSetup.numPackets = MAX_NUM_RX_PACKETS;
			}
        }
		else if(strnicmp("PACKET_SIZE", pLine, strlen("PACKET_SIZE")) == 0) {
            pLine = strchr(pLine, '=');
            pLine++;
	        pLine = strtok( pLine, delimiters ); //get past any white space etc

            if(!sscanf(pLine, "%ld", &testSetup.packetSize)) {
                uiPrintf("Unable to read the PACKET_SIZE from %s\n", TESTSETUP_FILE);
				return 0;
            }
			
			//check for exeeding max
			if(testSetup.packetSize > MAX_PACKET_SIZE) {
                uiPrintf("PACKET_SIZE should be less than %d\n", MAX_PACKET_SIZE);
				return 0;
			}
        }
		else if(strnicmp("TP_PACKET_SIZE", pLine, strlen("TP_PACKET_SIZE")) == 0) {
            pLine = strchr(pLine, '=');
            pLine++;
	        pLine = strtok( pLine, delimiters ); //get past any white space etc

            if(!sscanf(pLine, "%ld", &testSetup.packetSizeTP)) {
                uiPrintf("Unable to read the TP_PACKET_SIZE from %s\n", TESTSETUP_FILE);
				return 0;
            }
			
			//check for exeeding max
//			if(testSetup.packetSizeTP > MAX_PACKET_SIZE) {
//                uiPrintf("TP_PACKET_SIZE should be less than %d\n", MAX_PACKET_SIZE);
//				return 0;
//			}
        }
		else if(strnicmp("TP_NUM_PACKETS", pLine, strlen("TP_NUM_PACKETS")) == 0) {
            pLine = strchr(pLine, '=');
            pLine++;
	        pLine = strtok( pLine, delimiters ); //get past any white space etc

            if(!sscanf(pLine, "%ld", &testSetup.numPacketsTP)) {
                uiPrintf("Unable to read the TP_NUM_PACKETS from %s\n", TESTSETUP_FILE);
				return 0;
            }
			
			//check for exeeding max
//			if(testSetup.numPacketsTP > MAX_NUM_PACKETS_TP) {
//                uiPrintf("TP_NUM_PACKETS should be less than %d\n", MAX_NUM_PACKETS_TP);
//				return 0;
//			}
        }
		else if(strnicmp("TP_CCK_NUM_PACKETS", pLine, strlen("TP_CCK_NUM_PACKETS")) == 0) {
            pLine = strchr(pLine, '=');
            pLine++;
	        pLine = strtok( pLine, delimiters ); //get past any white space etc

            if(!sscanf(pLine, "%ld", &testSetup.numPacketsTP_CCK)) {
                uiPrintf("Unable to read the TP_CCK_NUM_PACKETS from %s\n", TESTSETUP_FILE);
				return 0;
            }
			
			//check for exeeding max
//			if(testSetup.numPacketsTP > MAX_NUM_PACKETS_TP) {
//                uiPrintf("TP_NUM_PACKETS should be less than %d\n", MAX_NUM_PACKETS_TP);
//				return 0;
//			}
        }
		else if(strnicmp("TP_RATE_MASK", pLine, strlen("TP_RATE_MASK")) == 0) {
            pLine = strchr(pLine, '=');
            pLine++;
	        pLine = strtok( pLine, delimiters ); //get past any white space etc

            if(!sscanf(pLine, "%x", &testSetup.dataRateMaskTP)) {
                uiPrintf("Unable to r