maui_cal.c

Atheros AP Test with Agilent N4010A source code

#ifdef _WINDOWS
#include <windows.h>
#endif
#include <stdio.h>
#include <assert.h>
#include <time.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
#define __ARREGH__  // This is required to avoid including ar5210reg.h
#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"
#include "cmdTest.h"
#ifdef LINUX
#include "linux_ansi.h"
#include "unistd.h"
#endif

#include "art_if.h"
#undef __ARREGH__  // This is required to avoid including ar5210reg.h
#include "ar5212/mEEPROM_d.h"
#include "cal_gen3.h"
#include "ar5211/ar5211reg.h"  /* AR5001 register definitions */
//++JC++
#include "ar2413/mEEPROM_g.h"
#include "cal_gen5.h"
//++JC++
//** the following added by ccshiang
#define __ART_VERSION__		0x5311
#include <process.h>

#define __module_maui_cal__
#include "..\..\..\..\AgN4010WSODrv\AgN4010WSOAPI.h"
#include "..\..\..\..\ART.Common\AgiGlobalDefs.h"
#include "..\..\..\..\ART.Common\agi_RxThreading.h"

void dutTestEVM(A_UINT32 devNum,A_UINT32 mode);
void dutMaxTargetPowerMeasurement();
void dutTestAgnRxSEN(A_UINT32 devNum,A_UINT32 mode);
void dutTestAgnRxSENLevel(A_UINT32 devNum,A_UINT32 mode);

static const char demod_CCK[]	= "CCK";
static const char demod_OFDM[]	= "OFDM";

static const char fmt_RetestLoop[]				= "--- Retest Loop # %d ---";
static const char fmt_SpectralMask_iter_csv[]	= "%s.%dMHz.SpectralMask.%d.csv";
static const char fmt_SpectralMask_csv[]		= "%s.%dMHz.SpectralMask.csv";

static const char fmt_MASK_Adjust_to_Perfect_PowerRange_due_to_Overload[]
						= "--- ** %s_MASK ** Adjust to Perfect PowerRange due to Overload ---";
static const char fmt_MASK_Cannot_adjust_PowerRange_due_to_exceed_25dBm[]
						= "--- ** %s_MASK ** Cannot adjust PowerRange (= %g dBM) due to exceed 25dBm ---";
static const char fmt_MASK_Adjust_to_Perfect_PowerRange_due_to_mask_failure[]
						= "--- ** %s_MASK ** Adjust to Perfect PowerRange due to mask failure ---";
static const char fmt_MASK_Cannot_adjust_PowerRange_due_to_below_TargetPower[]
						= "--- ** %s_MASK ** Cannot adjust PowerRange (= %g dBm + loss %g dB) due to below TargetPower (= %g dBm) ---";

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

#undef  DESC_ANT_B
#define DESC_ANT_B		((unsigned char) (~USE_DESC_ANT - DESC_ANT_A))
//** the above added by ccshiang

#include "ear_externs.h"

extern void writeAr6000MacAddress(A_UINT32 devNum, A_UCHAR *pMacAddr_arr);

extern A_UINT32 subSystemID;
extern A_UCHAR DataRate[]; // declared in test.c
extern A_UCHAR calsetupFileName[];
extern char *machName;
extern A_BOOL usb_client;


//extern GAIN_OPTIMIZATION_LADDER gainLadder;
extern GAIN_OPTIMIZATION_LADDER *pCurrGainLadder;

//extern MLD_CONFIG configSetup;
extern ART_SOCK_INFO *artSockInfo;
extern CAL_SETUP CalSetup;
extern YIELD_LOG_STRUCT  yldStruct;
//extern A_BOOL printLocalInfo;

// extern declarations for dut-golden sync
extern ART_SOCK_INFO *pArtPrimarySock;
extern ART_SOCK_INFO *pArtSecondarySock;

extern  EEPROM_DATA_STRUCT_GEN5 *pCalDataset_gen5[] ; //++JC++
extern  EEPROM_DATA_STRUCT_GEN3 *pCalDataset_gen3[] ;
extern const A_CHAR  *DataRateStr[];
extern const A_CHAR  *DataRate_11b[];

 char ackRecvStr[1024];
 char ackSendStr[1024];
 A_INT32 ackSendPar1, ackSendPar2, ackSendPar3;
 A_INT32 ackRecvPar1, ackRecvPar2, ackRecvPar3;


static A_UINT16 SideChannel = 5120; // channel used for sending handshake.
static A_UINT16 SideChannel_2p4 = 2312; // channel used for sending handshake.
A_UINT16 eepromType = EEPROM_SIZE_16K;

extern GOLDEN_PARAMS  goldenParams;

A_UINT32 devlibModeFor[3] = {MODE_11G, MODE_11B, MODE_11A};
A_UINT32 calModeFor[3] = {MODE_11a, MODE_11g, MODE_11b};


static A_UINT16 rates[MAX_RATES] = {6,9,12,18,24,36,48,54};

A_UINT32 VERIFY_DATA_PACKET_LEN   = 2352;

//** the following remaked by ccshiang
 /*
A_INT32 devPM, devSA, devATT, devDMM;
 */
//** the above remaked by ccshiang
 A_INT32 guDevPM, guDevAtt;

static A_UINT16 MKK_CHAN_LIST[] = {5170, 5190, 5210, 5230}; // channels used for OBW test
A_UINT16 numRAWChannels = 0; //will be computed prior to measurements.
A_UINT16 RAW_CHAN_LIST[201] ; // can accomodate 5000 - 6000 in steps of 5 MHz
A_UINT16 PCDACS_MASTER_LIST[] = {1,4, 7,10, 12,14,15,16,18,20, 22, 25, 28,32,37, 42, 48, 54, 60, 63};
//A_UINT16 PCDACS_MASTER_LIST[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,
//								 27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,
//								 55,56,57,58,59,60,61,62,63};
A_UINT16 *RAW_PCDACS;
A_UINT16 sizeOfRawPcdacs = (A_UINT16) sizeof(PCDACS_MASTER_LIST)/sizeof(A_UINT16);

static 	A_UINT32  devNumArr[3];

//** the following remarked by ccshiang
/***
static A_UCHAR  bssID[6]     = {0x50, 0x55, 0x5A, 0x50, 0x00, 0x00};
static A_UCHAR  rxStation[6] = {0x10, 0x11, 0x12, 0x13, 0x00, 0x00};	// DUT
***/
//** the above remarked by ccshiang
//** the following added by ccshiang
static A_UCHAR  bssID[6]     = {0x50, 0x55, 0x55, 0x55, 0x55, 0x05};
static A_UCHAR  rxStation[6] = {0x20, 0x22, 0x22, 0x22, 0x22, 0x02};	// DUT
//** the above added by ccshiang
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_UCHAR  verifyDataPattern[NUM_VERIFY_DATA_PATTERNS][LEN_VERIFY_DATA_PATTERNS]  = {
											{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA},
											{0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55},
											{0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66},
											{0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99},
											{0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80},
											{0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F}
										};



static A_UINT32 PER_TEST_RATE[] = {6, 36, 48, 54};
static A_UINT32 PER_MARGIN_TEST_RATE[] = {48, 54};
static A_UINT32 PER_RATEMASK = RATE_6|RATE_36|RATE_48|RATE_54;
static A_UINT32 PER_MARGIN_RATEMASK = RATE_48|RATE_54;
static A_UINT32 PER_RATE_COUNT = 4;
static A_UINT32 PER_MARGIN_RATE_COUNT = 2;
//static A_UINT32 PER_TEST_FRAME = 100;
static A_UINT32 PER_TEST_FRAME = 50;
static A_UINT32 PER_FRAME_LEN  = 1000;
static A_UINT32 NUM_11G_PPM_PKTS = 20;
//static A_UINT32 PER_GOOD_FRAME = 90;	// 90% of the frame send/receive

static A_UINT32 NUM_DATA_CHECK_FRAME = 4;

static A_UINT32 SEN_TEST_RATE[] = {48, 54};
static A_UINT32 SEN_RATEMASK = RATE_GROUP | RATE_48 | RATE_54;
static A_UINT32 SEN_RATE_COUNT = 2;
//static A_UINT32 SEN_TEST_FRAME = 100;  // use deprecated by CalSetup.numSensPackets[mode] starting w/ ART_2.5b18
static A_UINT32 SEN_FRAME_LEN  = 1000;
//static A_UINT32 SEN_GOOD_FRAME = 90;	// 90% of the frame send/receive

//static A_INT32 PPM_MAX = 9;
//static A_INT32 PPM_MIN = -9;
static A_BOOL  TestFail;

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

 dPCDACS_EEPROM RawDataset_11g ; // raw power measurements for 11g
 dPCDACS_EEPROM RawDataset_11b ; // raw power measurements for 11b
 dPCDACS_EEPROM *pRawDataset_2p4[2] = {&RawDataset_11g, &RawDataset_11b} ; // raw power measurements

 dPCDACS_EEPROM CalDataset_11g ; // calibration dataset
 dPCDACS_EEPROM CalDataset_11b ; // calibration dataset
 dPCDACS_EEPROM *pCalDataset_2p4[2] = {&CalDataset_11g, &CalDataset_11b} ; // calibration dataset

 dPCDACS_EEPROM RawGainDataset_11g ; // raw power measurements for 11b
 dPCDACS_EEPROM RawGainDataset_11b ; // raw power measurements for 11b
 dPCDACS_EEPROM *pRawGainDataset_2p4[2] = {&RawGainDataset_11g, &RawGainDataset_11b} ; // raw power measurements

char calPowerLogFile_2p4[2][122] = {"cal_AR5211_Power_11g.log", "cal_AR5211_Power_11b.log"};
static char calGainfLogFile_2p4[2][122] = {"cal_AR5211_Gainf_11g.log", "cal_AR5211_Gainf_11b.log"};

extern A_UINT16 numRAWChannels_2p4;
//A_UINT16 RAW_CHAN_LIST_2p4[3] = {2412, 2447, 2484}; // Never change them. These values are NOT stored
														   // on EEPROM, but are hardcoded in the driver instead.
// Needed to change these channels starting eeprom version 3.3 to accomodate
// Korea channels for 11g. - PD 9/02.
A_UINT16 RAW_CHAN_LIST_2p4[2][3] = {{2312, 2412, 2484}, {2412, 2472, 2484}}; // {11g, 11b}


extern TARGETS_SET	  *pTargetsSet;
extern TARGETS_SET	  *pTargetsSet_2p4[];

extern TEST_SET	  *pTestSet[3] ;
extern  char modeName[3][122]  ;

static A_UINT32		reportTiming = 1;
static char			testname[50][32] ;
static A_INT32		testtime[50];
static A_UINT32		timestart, timestop, globalteststarttime;
static A_UINT32		testnum = 0;
static char			failTest[50]; // flag if curr test has a failure.

A_BOOL		REWIND_TEST = FALSE;
static A_BOOL		SETUP_PM_MODEL2_ONCE = FALSE;
static A_BOOL		DUT_SUPPORTS_MODE[3] = {FALSE, FALSE, FALSE}; // flags used by golden

extern A_BOOL printLocalInfo;

static A_UINT32	optGainLadderIndex[3];
static A_BOOL	NEED_GAIN_OPT_FOR_MODE[] = {FALSE, FALSE, FALSE};

static A_UINT32 loadEARState;
static A_UINT32 enableXRState;
static A_BOOL quarterChannelState;

extern const A_CHAR  *DataRateShortStr[];
extern const A_CHAR  *DataRateShortStr_11b[];

static void dutThroughputTest(A_UINT32 devNum, A_UINT32 mode, A_UINT32 turbo, A_UINT16 rate, A_UINT16 frameLen,
					   A_UINT32 numPackets);
static void goldenThroughputTest(A_UINT32 devNum, A_UINT32 mode, A_UINT32 turbo, A_UINT16 rate, A_UINT16 frameLen,
						  A_UINT32 numPackets);

#define NUM_THROUGHPUT_PACKETS		 500
#define NUM_THROUGHPUT_PACKETS_11B   100
#define THROUGHPUT_PACKET_SIZE		 1500
#define THROUGHPUT_TURBO_PACKET_SIZE 3992
//#define THROUGHPUT_TURBO_PACKET_SIZE 2992


static A_UINT32 TX_PER_STRESS_MARGIN = 0;

//A_UINT32 EEPROM_DATA[2][0x400] ;
A_UINT32 **EEPROM_DATA_BUFFER;

extern void programCompactEeprom(A_UINT32);

void topCalibrationEntry(A_UINT32 *pdevNum_inst1, A_UINT32 *pdevNum_inst2)
{
	A_UINT32 devNum_inst1, devNum_inst2;
	SUB_DEV_INFO devStruct;

	devNum_inst1 = *pdevNum_inst1;
	devNum_inst2 = *pdevNum_inst2;

	loadEARState = configSetup.loadEar;
	enableXRState = configSetup.enableXR;
	quarterChannelState = configSetup.quarterChannel;

	// force loadEAR to 0 to capture values from new config file
	// loadEAR is restored just before the dutTest
	//also turn off eeprom loading
	//also want to force off enable_xr, re-enable on exit from cal
	configSetup.loadEar = 0;
	configSetup.eepromLoad = 0;
	configSetup.enableXR = 0;
	configSetup.quarterChannel = 0;

	art_setResetParams(devNum_inst1, configSetup.pCfgFile, (A_BOOL)configSetup.eepromLoad,
								(A_BOOL)1, MODE_11A, configSetup.use_init);
	art_configureLibParams(devNum_inst1);
	art_resetDevice(devNum_inst1, rxStation, bssID, 5220, 0);
	processEepFile(devNum_inst1, configSetup.cfgTable.pCurrentElement->eepFilename, &configSetup.eepFileVersion);

	art_getDeviceInfo(devNum_inst1, &devStruct);
	swDeviceID = devStruct.swDevID;
	if(isDragon_sd(swDeviceID))
	   art_writeField(devNum_inst1, "mc_eeprom_size_ovr", 3);

	if (devNum_inst1 != devNum_inst2)  {
		art_setResetParams(devNum_inst2, configSetup.pCfgFile, \
					(A_BOOL)configSetup.eepromLoad, \
						(A_BOOL)1, MODE_11A, configSetup.use_init);
		art_configureLibParams(devNum_inst2);
		art_resetDevice(devNum_inst2, rxStation, bssID, 2412, 0);
		processEepFile(devNum_inst2, configSetup.cfgTable.pCurrentElement->eepFilename, &configSetup.eepFileVersion);
		art_getDeviceInfo(devNum_inst2, &devStruct);
		swDeviceID = devStruct.swDevID;
		if(isDragon_sd(swDeviceID))
			art_writeField(devNum_inst2, "mc_eeprom_size_ovr", 3);

	}

	devNumArr[MODE_11a] = devNum_inst1;
	devNumArr[MODE_11g] = devNum_inst2;
	devNumArr[MODE_11b] = devNum_inst2;

	setup_raw_pcdacs();
	calibrationMenu() ;

	*pdevNum_inst1 = devNumArr[MODE_11a];
	*pdevNum_inst2 = devNumArr[MODE_11g];
	configSetup.loadEar = loadEARState;
	configSetup.enableXR = enableXRState;
	configSetup.quarterChannel = quarterChannelState;

	art_configureLibParams(devNum_inst1);
	art_configureLibParams(devNum_inst2);
}


void calibrationMenu()
{
	A_BOOL exitLoop  = FALSE;
	A_UINT32 channel = 5220;
	A_UINT32 devNum  = devNumArr[MODE_11a];
	A_UINT32 i=0,k=0;

	if (configSetup.validInstance == 2)
	{
		devNum = devNumArr[MODE_11g];
	}

	if ( !processEepFile(devNum, configSetup.cfgTable.pCurrentElement->eepFilename, &configSetup.eepFileVersion))
	{
		uiPrintf("Could Not Parse the .eep file %s for SubsystemID %x.\n", configSetup.cfgTable.pCurrentElement->eepFilename,
			configSetup.cfgTable.pCurrentElement->subsystemID);
		exit(0);
	}
	parseSetup(devNum);

	//userEepromSize = (CalSetup.eepromLength*1024)/16;

	/*if(userEepromSize == 0x400)
	{
		checkSumLength = eepromSize = 0x400;
	}
	else
				{
		eepromSize = userEepromSize;

		uiPrintf("SNOOP: IN IN Calibaration Menu EEPSIZE= 0x%x\n", eepromSize );
		uiPrintf("SNOOP: Ivalid check sum Length Before Calibration \n ");

	}*/

	EEPROM_DATA_BUFFER =(A_UINT32 **) malloc(sizeof(A_UINT32 *) * NUMEEPBLK);

	if(EEPROM_DATA_BUFFER != NULL)	{
		for (i = 0; i < 2; i++) {
			EEPROM_DATA_BUFFER[i]= (A_UINT32 *)malloc(sizeof(A_UINT32) * eepromSize);
			if(EEPROM_DATA_BUFFER[i] == NULL){
						printf(" Memory Not allocated in calibrationMenu() \n");
						exit(1);
				}
		}
 }
	else {
	 printf(" Memory Not allocated in calibrationMenu() \n");
   exit(1);
 }

	for(i=0;i<NUMEEPBLK;i++)
	{
		for(k =0;k< eepromSize;k++)
	{
			EEPROM_DATA_BUFFER[i][k]=0xffff;