cal_gen5.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 <assert.h>
#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"
#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"
#include "test.h"
#include "parse.h"
#include "dk_cmds.h"
#include "dk_ver.h"

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

#include "art_if.h"

#include "ar2413/mEEPROM_g.h"
#include "ar5212/mEEPROM_d.h"
#include "cal_gen5.h"

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

extern long ticksTest;

char *toSeconds(unsigned long ticks);

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

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

extern  A_UINT32	devlibModeFor[3];
extern  A_UINT32	calModeFor[3];

extern  char		modeName[3][122]  ;
extern  A_INT32		devPM, devSA, devATT;
extern  A_BOOL		REWIND_TEST;
extern  char		ackRecvStr[1024];

extern A_UINT16		RAW_CHAN_LIST_2p4[2][3];

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 A_UINT16 rates[MAX_RATES] = {6,9,12,18,24,36,48,54};

 RAW_DATA_STRUCT_GEN5 RawDatasetGen5_11a ; // raw power measurements for 11a
 RAW_DATA_STRUCT_GEN5 RawDatasetGen5_11g ; // raw power measurements for 11g
 RAW_DATA_STRUCT_GEN5 RawDatasetGen5_11b ; // raw power measurements for 11b
 RAW_DATA_STRUCT_GEN5 *pRawDataset_gen5[3] = {&RawDatasetGen5_11g, &RawDatasetGen5_11b, &RawDatasetGen5_11a} ; // raw power measurements

 EEPROM_DATA_STRUCT_GEN5 CalDatasetGen5_11a ; // calibration dataset
 EEPROM_DATA_STRUCT_GEN5 CalDatasetGen5_11g ; // calibration dataset
 EEPROM_DATA_STRUCT_GEN5 CalDatasetGen5_11b ; // calibration dataset
 EEPROM_DATA_STRUCT_GEN5 *pCalDataset_gen5[3] = {&CalDatasetGen5_11g, &CalDatasetGen5_11b, &CalDatasetGen5_11a} ; // calibration dataset

 RAW_DATA_STRUCT_GEN5 RawGainDatasetGen5_11a ; // raw gainF measurements for 11a
 RAW_DATA_STRUCT_GEN5 RawGainDatasetGen5_11g ; // raw gainF measurements for 11g
 RAW_DATA_STRUCT_GEN5 RawGainDatasetGen5_11b ; // raw gainF measurements for 11b
 RAW_DATA_STRUCT_GEN5 *pRawGainDataset_gen5[3] = {&RawGainDatasetGen5_11g, &RawGainDatasetGen5_11b, &RawGainDatasetGen5_11a} ; // raw gainF measurements

char calPowerLogFile_gen5[3][122] = {"cal_AR2413_Power_11g.log", "cal_AR2413_Power_11b.log", "cal_AR2413_Power_11a.log"};

A_UINT16 dummpy_eep_map1_data[NUM_DUMMY_EEP_MAP1_LOCATIONS] = {
	0x4d31, //11b channel 2412 data
	0x7f54,
	0x3c93,
	0x1205,
	0x1931,
	0x492d, //11g channel 2442 data
	0x7f50,
	0x3c93,
	0x0e01,
	0x192d
};


void dutCalibration_gen5(A_UINT32 devNum, A_UINT32 mode)
{
	A_BOOL		read_from_file = CalSetup.readFromFile;
	char		*fileName = CalSetup.rawDataFilename;

	if (mode != MODE_11a) {
		read_from_file = CalSetup.readFromFile_2p4[mode];
		fileName       = CalSetup.rawDataFilename_2p4[mode];
	}

	// power datasets setup and measurement
	if (!setup_datasets_for_cal_gen5(devNum, mode)) {
		uiPrintf("Could not setup gen5 raw datasets for mode %d. Exiting...\n", mode);
		closeEnvironment();
		exit(0);
	}

	if (read_from_file)
	{
		uiPrintf("Reading from file not implemented yet for gen5. Exiting...\n", mode);
			closeEnvironment();
			exit(0);
		//++JC++ not implemented yet -- read_dataset_from_file_gen5(pRawDataset_gen3[mode], fileName);
	} else
	{
		if ((mode == MODE_11b) && (CalSetup.useOneCal)){
		//	uiPrintf("\n\nWARNING: USE_11g_CAL_FOR_11b not supported, performing 11b measurement\n\n");
			//copy_11g_cal_to_11b_gen5(pRawDataset_gen5[MODE_11g], pRawDataset_gen5[MODE_11b]);
		}
		else {

		getCalData(devNum, mode, CalSetup.customerDebug);
		}
		dump_raw_data_to_file_gen5(pRawDataset_gen5[mode], calPowerLogFile_gen5[mode]) ;
	}
	raw_to_eeprom_dataset_gen5(pRawDataset_gen5[mode], pCalDataset_gen5[mode]);
}

void copy_11g_cal_to_11b_gen5(RAW_DATA_STRUCT_GEN5 *pRawDataSrc, RAW_DATA_STRUCT_GEN5 *pRawDataDest) {

	A_UINT32 ii, jj, kk, idxL, idxR;
	RAW_DATA_PER_CHANNEL_GEN5	*pChDest;
	RAW_DATA_PER_CHANNEL_GEN5	*pChSrcL;
	RAW_DATA_PER_CHANNEL_GEN5	*pChSrcR;
	RAW_DATA_PER_PDGAIN_GEN5	*pXpdDest;
	RAW_DATA_PER_PDGAIN_GEN5	*pXpdSrcL;
	RAW_DATA_PER_PDGAIN_GEN5	*pXpdSrcR;
	A_UINT16    wordsForPdgains[] = {4,6,9,12}; // index is 1 less than numPdgains

	assert(pRawDataDest != NULL);
	assert(pRawDataSrc  != NULL);

	// map the 11g data to 2412, 2472, 2484 for 11b to give 2484 its
	// dedicated data.
	pRawDataDest->numChannels = 3;
	CalSetup.TrgtPwrStartAddr += wordsForPdgains[NUM_PDGAINS_PER_CHANNEL-1]*pRawDataDest->numChannels;
	CalSetup.numForcedPiers_2p4[MODE_11b] = pRawDataDest->numChannels;

	pRawDataDest->xpd_mask    = pRawDataSrc->xpd_mask;

	idxL = 0;
	idxR = 0;
	for (ii = 0; ii < pRawDataDest->numChannels ; ii++) {
		CalSetup.piersList_2p4[MODE_11b][ii] = RAW_CHAN_LIST_2p4[MODE_11b][ii];
		pRawDataDest->pChannels[ii] = RAW_CHAN_LIST_2p4[MODE_11b][ii];
		mdk_GetLowerUpperIndex(pRawDataDest->pChannels[ii], pRawDataSrc->pChannels, pRawDataSrc->numChannels, &(idxL), &(idxR));
		pChDest = &(pRawDataDest->pDataPerChannel[ii]);
		pChSrcL  = &(pRawDataSrc->pDataPerChannel[idxL]);
		pChSrcR  = &(pRawDataSrc->pDataPerChannel[idxR]);

		pChDest->channelValue = pRawDataDest->pChannels[ii];
		pChDest->numPdGains  = NUM_PDGAINS_PER_CHANNEL;
		pChDest->maxPower_t4  = mdk_GetInterpolatedValue_Signed16(
									pChDest->channelValue,
									pChSrcL->channelValue,
									pChSrcR->channelValue,
									pChSrcL->maxPower_t4,
									pChSrcR->maxPower_t4
								);
		pChDest->maxPower_t4  += (A_UINT16)(4*CalSetup.cck_ofdm_delta);

		if (pChDest->channelValue == 2484) {
			pChDest->maxPower_t4 -= (A_UINT16)(4*CalSetup.ch14_filter_cck_delta);
		}

		for (jj=0; jj<NUM_PDGAINS_PER_CHANNEL; jj++) {
			if ( ((1 << jj) & pRawDataDest->xpd_mask) == 0 ) {
				continue;
			}
			pXpdDest  = &(pChDest->pDataPerPDGain[jj]);
			pXpdSrcL  = &(pChSrcL->pDataPerPDGain[jj]);
			pXpdSrcR  = &(pChSrcR->pDataPerPDGain[jj]);
			// following quantities expected to remain the same for idxL and idxR
			assert(pXpdSrcL->numVpd == pXpdSrcR->numVpd);
			assert(pXpdSrcL->pd_gain  == pXpdSrcR->pd_gain);
			pXpdDest->numVpd = pXpdSrcL->numVpd;
			pXpdDest->pd_gain  = pXpdSrcL->pd_gain;

			for (kk = 0; kk < pXpdDest->numVpd; kk++) {
				pXpdDest->Vpd[kk] = getInterpolatedValue(	pChDest->channelValue,
											pChSrcL->channelValue,
											pChSrcR->channelValue,
											pXpdSrcL->Vpd[kk],
											pXpdSrcR->Vpd[kk],
											FALSE // don't scale_up
										);

				pXpdDest->pwr_t4[kk] = mdk_GetInterpolatedValue_Signed16(
											pChDest->channelValue,
											pChSrcL->channelValue,
											pChSrcR->channelValue,
											pXpdSrcL->pwr_t4[kk],
											pXpdSrcR->pwr_t4[kk]
										);

				pXpdDest->pwr_t4[kk] += (A_UINT16)(4*CalSetup.cck_ofdm_delta);

				if (pChDest->channelValue == 2484) {
					pXpdDest->pwr_t4[kk] -= (A_UINT16)(4*CalSetup.ch14_filter_cck_delta);
				}
			}
		}
	}
} // copy_11g_cal_to_11b_gen5

/*
void measure_all_channels_gen5(A_UINT32 devNum, A_UINT32 debug, A_UINT32 mode) {

	A_UINT32	pd_gain, xgain_list[2]; // handle upto two pd_gains
	A_INT32		ii, jj, kk, ll;
	A_UINT16	channel;
	A_UINT16	pcdac, anchor_pcdac;
	A_UINT32    offset;
	A_UINT16	reset = 0;
	double		txPower;
	A_UCHAR		devlibMode ; // use setResetParams to communicate appropriate mode to devlib
	double		maxPower;
	double		myAtten;
	A_UINT16    sleep_interval = 150;
	A_UINT32 	rddata;
	A_INT16		power_pcdac_offset_t4, power_to_store_t4, anchor_power_t4;
	A_UINT16 	current_pcdac;
	A_UINT32 	initial_power[2], power_delta[2];
	A_INT32 	initial_pcdac[2];
	A_UINT16    wordsForPdgains[] = {4,6,9,12}; // index is 1 less than numPdgains
//** the following added by ccshiang
	double      saved_myAtten;

	configSetup.antenna = DESC_ANT_A | USE_DESC_ANT;
//** the above added by ccshiang

	switch (mode) {
	case MODE_11a :
		devlibMode = MODE_11A;
		pd_gain   = CalSetup.xgain;
		myAtten	   = CalSetup.attenDutPM;
		CalSetup.TrgtPwrStartAddr += 5; // upto 10 piers
//printf("SNOOP: meas_all_gen5 : calTgtPwrStart = 0x%x\n", CalSetup.TrgtPwrStartAddr);
		break;
	case MODE_11g :
		devlibMode = MODE_11G;
		pd_gain   = CalSetup.xgain_2p4[mode];
		myAtten	   = CalSetup.attenDutPM_2p4[mode];
		CalSetup.TrgtPwrStartAddr += 2; // upto 4 piers
		break;
	case MODE_11b :
		devlibMode = MODE_11B;
		pd_gain   = CalSetup.xgain_2p4[mode];
		myAtten	   = CalSetup.attenDutPM_2p4[mode];
		CalSetup.TrgtPwrStartAddr += 2; // upto 4 piers
		if (CalSetup.pmModel == NRP_Z11) {
			sleep_interval = 50;
		} else {
			sleep_interval = 250;
		}
		break;
	default:
		uiPrintf("Unknown mode supplied to measure_all_channels_gen5 : %d \n", mode);
		break;
	}
	CalSetup.TrgtPwrStartAddr += wordsForPdgains[NUM_PDGAINS_PER_CHANNEL-1]*pRawDataset_gen5[mode]->numChannels;
//** the following added by ccshiang
	saved_myAtten = myAtten;
//** the above added by ccshiang
//uiPrintf("SNOOP: meas_all_gen5 : calTgtPwrStart = 0x%x (mode=%d,wrdsperch=%d)\n", CalSetup.TrgtPwrStartAddr,mode,wordsForPdgains[NUM_PDGAINS_PER_CHANNEL-1]);
	configSetup.eepromLoad = 0;
	art_setResetParams(devNum, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
					(A_BOOL)configSetup.eepromHeaderLoad, (A_UCHAR)devlibMode, configSetup.use_init);


//** the following added by ccshiang
	ticksTest = GetTickCount();
	AgN4010_Log_LogIt("<<<*** %s -- Collecting raw data for the adapter ***>>>",modeName[mode]);

	agiDo_Cal_Setting();
//** the above added by ccshiang
	uiPrintf("\nL%d, Collecting raw data for the adapter for mode %s\n",_module_line(),modeName[mode]);

	for (ii=0; ii<pRawDataset_gen5[mode]->numChannels; ii++)
	{
		channel = pRawDataset_gen5[mode]->pDataPerChannel[ii].channelValue;

		if (ii == 0)
		{
			art_resetDevice(devNum, txStation, NullID, channel, 0);
		} else
		{
			art_resetDevice(devNum, txStation, NullID, channel, 0);
//			art_changeChannel(devNum, channel); // for efficiency
		}

		uiPrintf("ch: %d  --> ", channel);
//** the following added by ccshiang
		myAtten = saved_myAtten + agiGetCableLost(channel);
//** the above added by ccshiang

		//++JC++ For now only two pd_adc_gain supported -- if (CalSetup.cal_mult_xpd_gain_mask[mode] == 0) {
		if (1) {
				jj = 0;
				pRawDataset_gen5[mode]->xpd_mask = (1 << XPD_GAIN1_GEN5) | (1 << XPD_GAIN2_GEN5);
				xgain_list[0] = XPD_GAIN1_GEN5;
				xgain_list[1] = XPD_GAIN2_GEN5;
		} else {
			jj = 0;
			pRawDataset_gen5[mode]->xpd_mask = (A_UINT16) CalSetup.cal_mult_xpd_gain_mask[mode];
			pd_gain = CalSetup.cal_mult_xpd_gain_mask[mode];
			kk = 0;
			ll = 0;
			while (ll < 4) {
				if ((pd_gain & 0x1) == 1) {
					if (kk > 2) {
						uiPrintf("ERROR: A maximum of 2 pd_gains allowed to be specified in the rf_pd_gain parameter in the eep file.\n");
						exit(0);
					}