test.c

Atheros AP Test with Agilent N4010A source code

			}
			else {
				printf("|   d - Enable deep sleep|\n");
			}
		}
//take out for now        printf("|   x - Additional Tests                   |\n");
		printf("|   q - (Q)uit                             |\n");
		printf("============================================\n");

// TONY Always select 'M'
//        switch(toupper(getch())) {
	switch('M')
{
		case 'N':
				configSetup.use_init = !configSetup.use_init;
				art_setResetParams(devNum, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
						(A_BOOL)configSetup.eepromHeaderLoad, (A_UCHAR)configSetup.mode, configSetup.use_init);
				if (configSetup.use_init) {
					printf("Using Driver init code\n");
				}
				else {
					printf("Using MDK init code\n");
				}
				art_resetDevice(devNum, txStation, bssID, configSetup.channel, configSetup.turbo);
				break;

		case 'O':
			if (supportMultiModes(&supportedModes))
			 {
				//before changing mode, take a copy of the current frequency and rxGain for mode
				switch(configSetup.mode) {
				case MODE_11A:
					configSetup.channel5 = configSetup.channel;
					configSetup.rxGain5 = configSetup.rxGain;
					break;
				case MODE_11G:
				case MODE_11O:
					configSetup.channel2_4 = configSetup.channel;
					configSetup.rxGain2_4 = configSetup.rxGain;
					break;
				case MODE_11B:
					configSetup.channel2_4 = configSetup.channel;
					configSetup.rxGain2_4 = configSetup.rxGain;        //Not sure if will have another rxGain for b??
					break;
				}

				configSetup.mode = getNextMode(&supportedModes);
				if(configSetup.mode == MODE_11B) {
					configSetup.turbo = 0;
				}
				if((configSetup.mode != MODE_11G) && (configSetup.dataRateIndex > 7)) {
					configSetup.dataRateIndex = 0;
				}

				uiPrintf("\n");

				if ( isDragon_sd(swDeviceID)) {
					if(configSetup.mode == MODE_11A) {
					   configSetup.maxRxGain = RX_GAIN_MAX_AR6000;
					   configSetup.minRxGain = RX_GAIN_MIN_AR6000;
					}
					else {
					   configSetup.maxRxGain = RX_GAIN_MAX_AR6000_11g;
					   configSetup.minRxGain = RX_GAIN_MIN_AR6000_11g;
					}
				}
				else
				if ( ( (swDeviceID & 0xFF) == 0x14 ) || ( (swDeviceID & 0xFF) >= 0x16 ) ){
					configSetup.maxRxGain = RX_GAIN_MAX_AR5112;
					configSetup.minRxGain = RX_GAIN_MIN_AR5112;
				} else {
					if(configSetup.mode == MODE_11A) {
						configSetup.maxRxGain = RX_GAIN_MAX;
						configSetup.minRxGain = RX_GAIN_MIN;
					} else {
						configSetup.maxRxGain = RX_GAIN_MAX_11bg;
						configSetup.minRxGain = RX_GAIN_MIN_11bg;
					}
				}

				if (configSetup.rxGain > configSetup.maxRxGain) {
					configSetup.rxGain = configSetup.maxRxGain;
				}

				if (configSetup.rxGain < configSetup.minRxGain) {
					configSetup.rxGain = configSetup.minRxGain;
				}

				if(((swDeviceID == 0xa014)||(swDeviceID == 0xa016)||(swDeviceID == 0xa017))&&(!configSetup.userInstanceOverride)) {
					if(configSetup.mode != MODE_11A) {
						devNum = devNum_2g;
					}
					else {
						devNum = devNum_5g;
					}
				}
				setupMode();
				art_setResetParams(devNum, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
					(A_BOOL)configSetup.eepromHeaderLoad, (A_BOOL)configSetup.mode, configSetup.use_init);
				art_resetDevice(devNum, txStation, bssID, configSetup.channel, configSetup.turbo);
				if (configSetup.useTargetPower == TRUE) {
					configSetup.powerOutput = art_getMaxPowerForRate(devNum, (A_UINT16)configSetup.channel, DataRate[configSetup.dataRateIndex]);
				}
				updateConfigFromRegValues(devNum);

			}
			else {
				uiPrintf("Unknown command\n");
			}
			break;
 #ifndef __ATH_DJGPPDOS__
	   case 'E':
			if(configSetup.eepromLoad) {
				configSetup.eepromLoad = 0;
				//force the reload of eep file to override eeprom settings.
//                    processEepFile(devNum, configSetup.cfgTable.pCurrentElement->eepFilename, &configSetup.eepFileVersion);
			}
			else {
				if (eeprom_verify_checksum(devNum))
				{
				configSetup.validCalData  =  TRUE;
				configSetup.eepromLoad = 1;
				} else
				{
				configSetup.validCalData  =  FALSE;
				configSetup.eepromLoad    =  0;
				invalidEepromMessage(2000);
				}
			}
			if (configSetup.validCalData)
			{
				//revert back to defaults for config setup params
				configSetup.pcDac = USE_REG_FILE;
				configSetup.powerOutput = USE_REG_FILE;
				configSetup.rxGain = USE_REG_FILE;
				configSetup.powerControlMethod = NO_PWR_CTL;

				if (((swDeviceID & 0xff) >= 0x0014) && ((swDeviceID & 0xff) != 0x0015)) {
					//xpdgain gets set by devlib, don't want to apply here unless there
					//is an override.
					configSetup.applyXpdGain = (configSetup.eepromLoad == 1) ? 0 : 1;
				}
				//update the library with the new eepromload flag setting.
				art_setResetParams(devNum, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
					(A_BOOL)1, (A_BOOL)configSetup.mode, configSetup.use_init);
				art_rereadProm(devNum);
				art_resetDevice(devNum, txStation, bssID, configSetup.channel, configSetup.turbo);
				if(!configSetup.eepromLoad) {
					//force the reload of eep file to override eeprom settings.
					processEepFile(devNum, configSetup.cfgTable.pCurrentElement->eepFilename, &configSetup.eepFileVersion);
				}

				//Read register values read in from resetDevice
				updateConfigFromRegValues(devNum);
			}

			break;
#endif //__ATH_DJGPPDOS__
		case 'C':
			contMenu(devNum);
			break;
		case 'R':
			contRxMenu(devNum);
			break;
		case 'L':
			linkMenu(devNum);
			break;
		case 'T':
			throughputMenu(devNum);
			break;
		case 'P':
				if(sizeWarning)
				{
					uiPrintf("! Warning EEP EEPROM_SIZE and EEPROM Location size are Different \n");
					uiPrintf(" May Lead to illegal operation \n");
					uiPrintf(" Do you want to continue (Y/N)\n");
					while(!kbhit())    ;
						if(toupper(getch())=='Y') {
							EEPROM_Routine(devNum);
						}
						else
							break;
				}

			EEPROM_Routine(devNum);
			break;
		case 'U':
			utilityMenu(devNum);
			break;
		case 'I':
			noiseImmunityMenu(devNum);
			break;
		case 'G':
			if (configSetup.logging) {
				configSetup.logging = 0;

				//turn off logging
				uilogClose();
			}
			else {
				configSetup.logging = 1;

				if(configSetup.logFile[0] == '\0') {
					uiPrintf("\nPlease enter filename for logging: ");
					scanf("%s", configSetup.logFile);
				}
				#ifndef __ATH_DJGPPDOS__
				uilog(configSetup.logFile, 1);
				#endif
			}

			if(configSetup.logging) {
			}

			break;
#ifndef __ATH_DJGPPDOS__
		case 'S':
		if (!isDragon_sd(swDeviceID)) {

			art_teardownDevice(devNum);
			if ((devNum_2g != devNum_5g) &&(!configSetup.userInstanceOverride)) {
				if(devNum == devNum_2g) {
					art_teardownDevice(devNum_5g);
				} else {
					art_teardownDevice(devNum_2g);
				}

			}
			uiPrintf("Device has been stopped and may be removed\n");
			uiPrintf("Press Q to exit or any other key to setup a new device\n");
			if( toupper(getch()) == 'Q' ) {
				uiPrintf("closing environment\n");
				closeEnvironment();
				exit(0);
			}
			if (configSetup.remote)
			 {
					 uiPrintf("IP Address of the new AP: ");
					 scanf("%s",configSetup.machName);
			 }


			findEepFile();


			if(configSetup.userInstanceOverride) {
			  devNum = art_setupDevice(configSetup.instance);
			  if(devNum < 0) {
				  uiPrintf("main: Error attaching to the device - ending test\n");
				  closeEnvironment();
				  exit(0);
			  }
			  art_configureLibParams(devNum);
			  art_resetDevice(devNum, txStation, bssID, configSetup.channel, configSetup.turbo);
			  uiPrintf("Attached to the Device for instance = %d\n", configSetup.instance);

				//for now make the assumption that both a and g are supported
				devNum_5g = devNum;
				devNum_2g = devNum;
			}
			else {
				//enable the instances that are valid
				if(CalSetup.modeMaskForRadio[0] != 0) {
					devNumInst[1] = art_setupDevice(1);
					if(devNumInst[1] < 0) {
						uiPrintf("main: Error attaching to the device - ending test\n");
						closeEnvironment();
						exit(0);
			}
					art_configureLibParams(devNumInst[1]);
					art_resetDevice(devNumInst[1], txStation, bssID, configSetup.channel, configSetup.turbo);
					uiPrintf("Attached to the Device for instance = %d\n", 1);
			}

				if(CalSetup.modeMaskForRadio[1] != 0) {
					devNumInst[2] = art_setupDevice(2);
					if(devNumInst[2] < 0) {
						uiPrintf("main: Error attaching to the device - ending test\n");
						closeEnvironment();
						exit(0);
					}
					art_configureLibParams(devNumInst[2]);
					art_resetDevice(devNumInst[2], txStation, bssID, configSetup.channel, configSetup.turbo);
					uiPrintf("Attached to the Device for instance = %d\n", 2);
					}

				//Setup the 2g and 5g instances
				devNum_5g = devNumInst[CalSetup.instanceForMode[MODE_11a]];
				devNum_2g = devNumInst[CalSetup.instanceForMode[MODE_11g]];

				//check that we have legal devNums for both.  If not, point to a valid
				//devNum, manufacturing expects 2 devNums to be valid
				//if all board text files are setup correctly, should not use it.
				if((devNum_5g == INVALID_INSTANCE)&& (devNum_2g == INVALID_INSTANCE)) {
					uiPrintf("Unable to allocate a valid devNum, exiting\n");
						closeEnvironment();
						exit(0);
					}
				else if (devNum_5g == INVALID_INSTANCE) {
						devNum_5g = devNum_2g;
					}
				else if (devNum_2g == INVALID_INSTANCE) {
					devNum_2g = devNum_5g;
				}
			}

			//setup devnum correctly
			if(configSetup.mode == MODE_11A) {
				if(devNum_5g != INVALID_INSTANCE) {
					devNum = devNum_5g;
				}
				else {
					//assume 11g
					devNum = devNum_2g;
				}
			}
			else {
				if(devNum_2g != INVALID_INSTANCE) {
					devNum = devNum_2g;
				}
				else {
					//assume 11a
					devNum = devNum_5g;
				}
				}

			//extra safety check
			if(devNum == INVALID_INSTANCE) {
				uiPrintf("Unable to get allocate a valid devNum, exiting\n");
				closeEnvironment();
				exit(0);
			}


			//get the deviceID from the library and use the swDevID
			art_getDeviceInfo(devNum, &devStruct);
					swDeviceID = devStruct.swDevID;
					hwDeviceID = devStruct.hwDevID;

			if (!configSetup.userInstanceOverride) {

				if (CalSetup.Amode) {
					if (CalSetup.Gmode) {
						if ((CalSetup.instanceForMode[MODE_11a] != 1) && (CalSetup.instanceForMode[MODE_11g] != 1)) {
							configSetup.validInstance = 2;
						}
					} else {
						if (CalSetup.instanceForMode[MODE_11a] != 1) {
							configSetup.validInstance = 2;
						}
					}
				} else if (CalSetup.Gmode) {
					if (CalSetup.instanceForMode[MODE_11g] != 1) {
						configSetup.validInstance = 2;
					}
				}
			}


			configSetup.powerControlMethod = NO_PWR_CTL;
			art_resetDevice(devNum, txStation, bssID, configSetup.channel, configSetup.turbo);
			if (((swDeviceID & 0xff) == 0x14)||((swDeviceID & 0xff) >= 0x16)) {
				if ((swDeviceID & 0xFF) >= 0x16) {
					pCurrGainLadder = &(gainLadder_derby2);
				} else {
					pCurrGainLadder = &(gainLadder_derby1);
				}
			} else {
				pCurrGainLadder = &(gainLadder);
			}

			if (eeprom_verify_checksum(devNum))
			{
				configSetup.validCalData  =  TRUE;
				configSetup.eepromLoad    =  1;
				if (((swDeviceID & 0xff) >= 0x0014)&&((swDeviceID & 0xff) != 0x0015) ){
					//xpdgain gets set by devlib, don't want to apply here unless there
					//is an override.
					configSetup.applyXpdGain = 0;
				}
			} else
			{
				configSetup.validCalData  =  FALSE;
				configSetup.eepromLoad    =  0;
				invalidEepromMessage(2000);
				configSetup.applyXpdGain = 1;
			}

			art_setResetParams(devNum, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
				(A_BOOL)configSetup.eepromHeaderLoad, (A_UCHAR)configSetup.mode, configSetup.use_init);
	   #ifndef __ATH_DJGPPDOS__
			if(!setEepFile(devNum)) {
				art_teardownDevice(devNum);
				closeEnvironment();
				exit(0);
			}

			if(((swDeviceID == 0xa014)||(swDeviceID == 0xa016)||(swDeviceID == 0xa017))&&(!configSetup.userInstanceOverride)) {
				if(!setEepFile((devNum == devNum_5g) ? devNum_2g : devNum_5g)) {
					art_teardownDevice((devNum == devNum_5g) ? devNum_2g : devNum_5g);
					closeEnvironment();
					exit(0);
				}
			}
		#endif
			//test card/installation
			if(!initTest(devNum)) {
				uiPrintf("main: Error testing device - exiting\n");
				art_teardownDevice(devNum);
				closeEnvironment();
				exit(0);
			}

			//Read register values read in from resetDevice
			updateConfigFromRegValues(devNum);
			}
			break;
		case 'W':
			if(configSetup.logging) {
				printf("Enter comment below.  Put a period (.) on a seperate line to complete\n");
				while(commentBuffer[0] != '.') {