rssi_power.c

Atheros AP Test with Agilent N4010A source code

#ifdef _WINDOWS
#include <windows.h>
#endif
#include <stdio.h>
#ifndef LINUX
#include <conio.h>
#endif
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdarg.h>
#include "wlantype.h"   /* typedefs for A_UINT16 etc.. */
#include "wlanproto.h"
#include "athreg.h"
#include "manlib.h"     /* The Manufacturing Library */
#include "MLIBif.h"     /* Manufacturing Library low level driver support functions */
#ifdef JUNGO
#include "mld.h"        /* Low level driver information */
#endif
#include "common_hw.h"        /* Low level driver information */

#include "manlibInst.h" /* The Manufacturing Library Instrument Library extension */
#include "mEeprom.h"    /* Definitions for the data structure */
#include "dynamic_optimizations.h"
#include "maui_cal.h"   /* Definitions for the Calibration Library */
#include "rssi_power.h" /* Definitions for the rssi to power cal */
#include "mathRoutines.h"
#include "test.h"
#include "parse.h"
#include "dk_cmds.h"

#ifdef LINUX
#include "linux_ansi.h"
#endif

#include "art_if.h"
#include "ar5212/mEEPROM_d.h"
#include "cal_gen3.h"
//++JC++
#include "ar2413/mEEPROM_g.h"
#include "cal_gen5.h"
//++JC++

//** the following added by ccshiang
#define __module_rssi_power__
#include "..\..\..\..\AgN4010WSODrv\AgN4010WSOAPI.h"
#include "..\..\..\..\ART.Common\AgiGlobalDefs.h"

#undef  DESC_ANT_A
#define DESC_ANT_A		((unsigned char) AgN4010.nAntennaX)

#undef  DESC_ANT_B
//** the above added by ccshiang

extern MLD_CONFIG configSetup;
extern ART_SOCK_INFO *artSockInfo;
//extern A_BOOL printLocalInfo;

// extern declarations for dut-golden sync
extern ART_SOCK_INFO *pArtPrimarySock;
extern ART_SOCK_INFO *pArtSecondarySock;
extern A_INT32 ackRecvPar1, ackRecvPar2, ackRecvPar3;
extern char ackRecvStr[1024];

extern GOLDEN_PARAMS  goldenParams ;

extern A_INT32 devPM, devSA, devATT;
extern A_UINT16 numRAWChannels; //will be computed prior to measurements.
extern A_UINT16 *RAW_CHAN_LIST ; // can accomodate 5000 - 6000 in steps of 5 MHz
extern A_UINT16 *RAW_PCDACS ;
extern A_UINT16 sizeOfRawPcdacs ;

extern dPCDACS_EEPROM RawDataset ; // raw power measurements
extern dPCDACS_EEPROM *pRawDataset  ; // raw power measurements
extern dPCDACS_EEPROM RawGainDataset ; // raw gainf measurements
extern dPCDACS_EEPROM *pRawGainDataset  ; // raw gainf measurements
extern dPCDACS_EEPROM CalDataset ; // calibration dataset
extern dPCDACS_EEPROM *pCalDataset ; // calibration dataset
extern dPCDACS_EEPROM FullDataset ; // full dataset
extern dPCDACS_EEPROM *pFullDataset  ; // full dataset

extern dPCDACS_EEPROM RawDataset_11g ; // raw power measurements for 11g
extern dPCDACS_EEPROM RawDataset_11b ; // raw power measurements for 11b
extern dPCDACS_EEPROM *pRawDataset_2p4[2]  ; // raw power measurements
extern dPCDACS_EEPROM RawGainDataset_11g ; // raw power measurements for 11b
extern dPCDACS_EEPROM RawGainDataset_11b ; // raw power measurements for 11b
extern dPCDACS_EEPROM *pRawGainDataset_2p4[2] ; // raw power measurements
extern dPCDACS_EEPROM CalDataset_11g ; // calibration dataset
extern dPCDACS_EEPROM CalDataset_11b ; // calibration dataset
extern dPCDACS_EEPROM *pCalDataset_2p4[2] ; // calibration dataset

extern char calPowerLogFile_2p4[2][122] ;

extern A_UINT16 numRAWChannels_2p4 ;
extern A_UINT16 RAW_CHAN_LIST_2p4[3] ; // Never change them. These values are NOT stored
														   // on EEPROM, but are hardcoded in the driver instead.
extern char modeName[3][122] ;


static A_UCHAR  bssID[6]     = {0x50, 0x55, 0x5A, 0x50, 0x00, 0x00};
static A_UCHAR  rxStation[6] = {0x10, 0x11, 0x12, 0x13, 0x00, 0x00};	// DUT
static A_UCHAR  txStation[6] = {0x20, 0x22, 0x24, 0x26, 0x00, 0x00};	// Golden
static A_UCHAR  NullID[6]    = {0x66, 0x66, 0x66, 0x66, 0x66, 0x66};
static A_UCHAR  pattern[2] = {0xaa, 0x55};

static FILE     *logGU;
static FILE     *refGU;
static FILE     *rawGU;
extern A_INT32 guDevPM, guDevAtt;

COEFF_DATA_STRUCT GoldenCoeffs;
COEFF_DATA_STRUCT *pGoldenCoeffs = &GoldenCoeffs;

void getCalData(A_UINT32 devNum, A_UINT32 mode, A_UINT32 debug)
{

	if (CalSetup.useFastCal)
	{
		getCalDataUsingGU(devNum, mode, GET_GU_PWR, debug) ;
	} else if (CalSetup.eeprom_map >= CAL_FORMAT_GEN5) {
//		measure_all_channels_gen5(devNum, CalSetup.customerDebug, mode) ;
		measure_all_channels_generalized_gen5(devNum, CalSetup.customerDebug, mode) ;
	} else if (CalSetup.eeprom_map == CAL_FORMAT_GEN3) {
		measure_all_channels_gen3(devNum, CalSetup.customerDebug, mode) ;
	} else
	{
		switch (mode) {
		case MODE_11a :
			measure_all_channels(devNum, CalSetup.customerDebug);
			break;
		case MODE_11b :
		case MODE_11g :
			measure_all_channels_2p4(devNum, CalSetup.customerDebug, mode) ;
			break ;
		default :
			uiPrintf("Illegal mode specified in getCalData : %d\n", mode);
			exit(0);
		}
	}
} // getCalData

void getCalDataUsingGU(A_UINT32 devNum, A_UINT32 mode, A_UINT32 opcode, A_UINT32 debug)
{

	A_UINT16 ch ;
	A_INT16 ii, jj;
	double pwrList[64];
	A_UCHAR  devlibMode ; // use setResetParams to communicate appropriate mode to devlib
	A_UINT32  time1;

	dPCDACS_EEPROM *pRawDatasetLocal;
	dPCDACS_EEPROM *pRawGainDatasetLocal;

	dDATA_PER_CHANNEL	*pRawChannelData;
	dDATA_PER_CHANNEL	*pGainfChannelData;

	switch (mode) {
	case MODE_11a:
		devlibMode = MODE_11A;
		break;
	case MODE_11g :
		devlibMode = MODE_11G;
		break;
	case MODE_11b :
		devlibMode = MODE_11B;
		break;
	default:
		uiPrintf("Unknown mode : %d \n", mode);
		exit(0);
		break;
	}


//	gpibONL(devATT, 0); // take att offline. relinquish for golden.
//	gpibONL(devPM, 0); // take att offline. relinquish for golden.
//	gpibRSC(0, 0);  // DUT to release system control (0);

	configSetup.eepromLoad = 0;
	art_setResetParams(devNum, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
					(A_BOOL)configSetup.eepromHeaderLoad, (A_UCHAR)devlibMode, configSetup.use_init);

	if (mode != MODE_11a)
	{
		pRawDatasetLocal = pRawDataset_2p4[mode] ;
		pRawGainDatasetLocal = pRawGainDataset_2p4[mode] ;
	} else
	{
		pRawDatasetLocal = pRawDataset ;
		pRawGainDatasetLocal = pRawGainDataset ;
	}

	uiPrintf("\nL%d, Collecting raw data for the adapter for mode %s\n",_module_line(),modeName[mode]);

	setupDutForPwrMeas(devNum, opcode, mode, debug);
	if (debug)
		uiPrintf("numChannels=%d for mode %s\n", pRawDatasetLocal->numChannels, modeName[mode]);

	time1 = milliTime();

	for (ii=0; ii<pRawDatasetLocal->numChannels; ii++)
	{
		ch = pRawDatasetLocal->pDataPerChannel[ii].channelValue;
		if (debug)
			uiPrintf("starting channel %d\n", ch);
		pRawChannelData = &(pRawDatasetLocal->pDataPerChannel[ii]) ;
		pGainfChannelData = &(pRawGainDatasetLocal->pDataPerChannel[ii]) ;

		if (mode == MODE_11a)
		{
//			setCornerFixBits(devNum, ch);
		}

		art_changeChannel(devNum, ch); // can't resetDevice else setupDutForPwrMeas gets erased.
		retrievePwrData(devNum, opcode, ch, mode, RAW_PCDACS, sizeOfRawPcdacs, &(pwrList[0]), debug);
		uiPrintf("ch: %d, time = %d\n", ch, (A_UINT16)(milliTime()-time1)/1000);

		for (jj=0; jj<sizeOfRawPcdacs; jj++)
		{
			pRawChannelData->pPwrValues[jj] = pwrList[jj] ;
			pGainfChannelData->pPwrValues[jj] = 0.0 ;
		}
	} // channels

} // getCalDataUsingGU


void setupDutForPwrMeas(A_UINT32 devNum, A_UINT32 opcode, A_UINT32 mode, A_UINT32 debug)
{
	A_UINT32	ch;
	A_UINT32	rddata, wrdata;
//	A_INT32		minccapwr;
	A_INT32		maxccapwr  = -80;
	A_UINT16	ii, allpcdacs[64], kk=0;

	ch = ((mode == MODE_11a) ? 5170 : 2412) ;

	// disable noise cal
	art_resetDevice(devNum, txStation, bssID, ch, 0);
// /*
	Sleep(50);

	rddata = art_regRead(devNum, (0x9800 + (24<<2)));
	wrdata = rddata & ~0x8002;
	art_regWrite(devNum, (0x9800 + (24<<2)), wrdata);

	// force noise floor
//    art_regWrite(devNum, 0x9800+(25<<2), ( (maxccapwr<0) ? (abs(maxccapwr*2) ^ 0x1ff)+1 : maxccapwr*2));

//	uiPrintf("forceval=%x\n",( (maxccapwr<0) ? (abs(maxccapwr*2) ^ 0x1ff)+1 : maxccapwr*2));
	rddata = art_regRead(devNum, 0x9800+(25<<2));
	wrdata = (rddata & ~(0x1ff)) | (( (maxccapwr<0) ? (abs(maxccapwr*2) ^ 0x1ff)+1 : maxccapwr*2));
	art_regWrite(devNum, 0x9800+(25<<2), wrdata);

//	uiPrintf("rddata = %x, wrdata = %x\n", rddata, wrdata);

	rddata = art_regRead(devNum, (0x9800 + (24<<2)));
	wrdata = rddata | 0x0002;
	art_regWrite(devNum, (0x9800 + (24<<2)), wrdata);
/*
	uiPrintf("forceval=%x\n",wrdata);

	rddata = 1;
	while ( rddata > 0)
	{
		rddata = ( art_regRead(devNum, (0x9800 + (24<<2))) & 0x2);
		//uiPrintf("(%d) rddata = %x\n", kk++, rddata);
	}

	rddata = art_regRead(devNum, (0x9800+(25<<2)));
	minccapwr = (rddata >> 19) & 0x1ff;
	if (minccapwr & 0x100) {
		minccapwr = -((minccapwr ^ 0x1ff) + 1);
	}
	uiPrintf( "Minimum CCA power was forced to %d dBm\n\n", minccapwr);
*/
	for(ii=0; ii<64; ii++)
		allpcdacs[ii] = ii;

	art_ForcePCDACTable(devNum, allpcdacs);

} // setupDutForPwrMeas

void retrievePwrData(A_UINT32 devNum, A_UINT32 opcode, A_UINT32 channel, A_UINT32 mode,
						A_UINT16 *pcdacs, A_UINT32 numPcd, double *retVals,
						A_UINT32 debug)
{

	A_UINT32 ii, jj, numAvg;
	A_UCHAR  datapattern[1] = {0x00};
	A_UINT32 broadcast = 1;
	A_UINT32 complete_timeout = 1000;
	A_UINT32 statsMode = 0;
	A_UINT32 dataCh;
	A_UINT32 time1;

	numAvg = (opcode == CAL_PM_PWR) ? 1 : NUM_POWER_AVERAGES ;

	for (ii=0; ii<numAvg; ii++)
	{
		if (opcode != CAL_PM_PWR)
		{
			sendAck(devNum, "Prepare to begin receive for power meas at ", channel, ii, opcode, debug);
			waitForAck(debug);
		}

		for( jj=0; jj<numPcd; jj++)
		{
			art_forceSinglePowerTxMax(devNum, pcdacs[jj]);
			datapattern[0] = pcdacs[jj] & 0xff ;
//			art_txDataSetup(devNum, RATE_6, rxStation, NUM_POWER_PACKETS, LEN_POWER_PACKETS, datapattern, 1, 0,
//							(USE_DESC_ANT | DESC_ANT_A), broadcast);
//			if (opcode == CAL_PM_PWR)
			if (1) // handshake in all cases.
			{
				sendAck(devNum, "Prepare for RX at pcdac = ", channel, pcdacs[jj], opcode, debug);
				waitForAck(debug);
			}
			Sleep(1);
			//Sleep(1);
			time1 = milliTime();
			txContFrameBegin(devNum, LEN_POWER_PACKETS, IFS_IN_SLOTS, RANDOM_PATTERN, 6, (USE_DESC_ANT | DESC_ANT_A), 0, NUM_POWER_PACKETS, rxStation);
//			art_txDataBegin(devNum, complete_timeout, statsMode);
//			uiPrintf("txdatabegin time: %d\n", milliTime() - time1);
		} // for (0..numPcd)
	} // for 0..numAvg

	if (opcode == GET_GU_PWR)
	{
		sendAck(devNum, "Send Power List", numPcd, channel, numAvg, debug);
		waitForAck(debug);
		extractDoublesFromStr(ackRecvStr, retVals, numPcd, &(dataCh), debug);
		if (dataCh != channel)
		{
			uiPrintf("dataChannel (%d) is different from channel (%d)\n", dataCh, channel);
			exit(0);
		}
	}
} // retrievePwrData

void extractDoublesFromStr(char *srcStr, double *retVals, A_UINT32 size, A_UINT32 *par1, A_UINT32 debug)
{
	char		delimiters[] = " \t" ;
	char		*tmpstr, str1[1024];
	A_UINT32	ii=0;

	strcpy(str1, srcStr);

	tmpstr = strtok(str1, delimiters);
	if (!sscanf(tmpstr, "%d", par1))
		uiPrintf("Unable to read par1 from string: %s\n", tmpstr);

	tmpstr = strtok(NULL, delimiters);

	while((tmpstr != NULL) && (ii < size))
	{
		if (!sscanf(tmpstr, "%lf", &(retVals[ii]) ))
			uiPrintf("Unable to read value %d from string: %s\n", ii, tmpstr);
		tmpstr = strtok(NULL, delimiters);
		ii++;
	}

	if (ii != size)
	{
		uiPrintf("Unable to extract all %d values from string %s\n", size, srcStr);
		exit(0);
	}
} // extractDoublesFromStr

void extractDoublesFromScientificStr(char *srcStr, double *retVals, A_UINT32 size, A_UINT32 *par1, A_UINT32 debug)
{
	char		delimiters[] = " \t" ;
	char		*tmpstr, str1[1024];
	A_UINT32	ii=0;

	strcpy(str1, srcStr);

	tmpstr = strtok(str1, delimiters);
	if (!sscanf(tmpstr, "%d", par1))
		uiPrintf("Unable to read par1 from string: %s\n", tmpstr);

	tmpstr = strtok(NULL, delimiters);

	if (debug) uiPrintf("\nSNOOP: %s\nExtracted vals: ", srcStr);

	while((tmpstr != NULL) && (ii < size))
	{
		if (!sscanf(tmpstr, "%le", &(retVals[ii]) ))
			uiPrintf("Unable to read value %d from string: %s\n", ii, tmpstr);
		//uiPrintf("%s->%le (%d), ", tmpstr, retVals[ii], ii);
		tmpstr = strtok(NULL, delimiters);
		ii++;
	}

	if (ii != size)
	{
		uiPrintf("Unable to extract all %d values from string %s\n", size, srcStr);
		exit(0);
	}
} // extractDoublesFromScientificStr

void extractFloatsFromStr(char *srcStr, float *retVals, A_UINT32 size, A_UINT32 *par1, A_UINT32 debug)
{
	char		delimiters[] = " \t" ;
	char		*tmpstr, str1[1024];
	A_UINT32	ii=0;

	strcpy(str1, srcStr);

	tmpstr = strtok(str1, delimiters);
	if (!sscanf(tmpstr, "%d", par1))
		uiPrintf("Unable to read par1 from string: %s\n", tmpstr);

	tmpstr = strtok(NULL, delimiters);

	while((tmpstr != NULL) && (ii < size))
	{
		if (!sscanf(tmpstr, "%f", &(retVals[ii]) ))
			uiPrintf("Unable to read value %d from string: %s\n", ii, tmpstr);
		tmpstr = strtok(NULL, delimiters);
		ii++;
	}

	if (ii != size)
	{
		uiPrintf("Unable to extract all %d values from string %s\n", size, srcStr);
		exit(0);
	}
} // extractFloatsFromStr

void extractIntsFromStr(char *srcStr, A_UINT32 *retVals, A_UINT32 size, A_UINT32 *par1, A_UINT32 debug)
{
	char		delimiters[] = " \t" ;
	char		*tmpstr, str1[1024];
	A_UINT32	ii=0;

	strcpy(str1, srcStr);

	tmpstr = strtok(str1, delimiters);
	if (!sscanf(tmpstr, "%d", par1))
		uiPrintf("Unable to read par1 from string: %s\n", tmpstr);

	tmpstr = strtok(NULL, delimiters);

	while((tmpstr != NULL) && (ii < size))
	{
		if (!sscanf(tmpstr, "%d", &(retVals[ii])))
			uiPrintf("Unable to read value %d from string: %s\n", ii, tmpstr);
		tmpstr = strtok(NULL, delimiters);
		ii++;
	}

	if (ii != size)
	{
		uiPrintf("Unable to extract all %d values from string %s\n", size, srcStr);
		exit(0);
	}
} // extractIntsFromStr




void setupGoldenForCal(A_UINT32 devNum, A_UINT32 debug)
{

	//11a calibration
	if(CalSetup.calPower && CalSetup.Amode) {
		sendCalDataFromGU(devNum, MODE_11a, GET_GU_PWR, debug);
	}

	// 11g calibration
	if(CalSetup.calPower && CalSetup.Gmode){
		sendCalDataFromGU(devNum, MODE_11g, GET_GU_PWR, debug);
   }

	// 11b calibration
	if(CalSetup.calPower && CalSetup.Bmode){
		sendCalDataFromGU(devNum, MODE_11b, GET_GU_PWR, debug);
	}
} // setupGoldenForCal