eeprom.c

Atheros AP Test with Agilent N4010A source code

		pDataPerChannel = pChannelInfo->pDataPerChannel11b;
		xpdGainMask = pChannelInfo->xpd_mask11b;
		break;

	default:
		printf("Illegal mode passed to printfChannelInfo_gen3\n");
		return;
	}

	//calculate the value of xpdgains
	for (jj = 0; jj < NUM_XPD_PER_CHANNEL; jj++) {
		if (((xpdGainMask >> jj) & 1) > 0) {
			xpdGainValues[numXpdGain++] = (A_UINT16) jj;			
		}
	}

	uiPrintf("\n");
	if(mode == MODE_11A) {
		uiPrintf("=========================Calibration Information============================\n");
		k_end = 10;
		i_end = 5;
	}
	else {
		uiPrintf("               ==========Calibration Information=============\n");
		k_end = 3;
		i_end = 3;
	}

	for (k = 0; k < k_end; k+=5) {
		if(mode != MODE_11A) {
			uiPrintf("               ");
		}
		for(i = k; i < (k + i_end); i++) {
			uiPrintf("|     %04d     ",
				pDataPerChannel[i].channelValue);
		}
		uiPrintf("|\n");
		
    	if(mode == MODE_11A) {
	    	uiPrintf("|==============|==============|==============|==============|==============|\n");
		}
		else {
    		uiPrintf("               |==============|==============|==============|\n");
			uiPrintf("               ");
		}
		for(i = k; i < (k + i_end); i++) {
			uiPrintf("|pcdac pwr(dBm)");
		}
		uiPrintf("|\n");

    	if(mode == MODE_11A) {
			uiPrintf("|              |              |              |              |              |\n");
			uiPrintf("| XPD_Gain %2d  |              |              |              |              |\n", 
				xpdGainMapping[xpdGainValues[0]]);	
		}
		else {
    		uiPrintf("               | XPD_Gain %2d  |              |              |\n",
				xpdGainMapping[xpdGainValues[0]]);	
    		uiPrintf("               |              |              |              |\n");
		}
		
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}
		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] = pDataPerChannel[i].pcd1_xg0;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].pwr1_xg0)/4));
		}
		uiPrintf("|\n");
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}
		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] += pDataPerChannel[i].pcd2_delta_xg0;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].pwr2_xg0)/4));
		}
		uiPrintf("|\n");
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}

		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] += pDataPerChannel[i].pcd3_delta_xg0;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].pwr3_xg0)/4));
		}

		uiPrintf("|\n");
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}

		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] += pDataPerChannel[i].pcd4_delta_xg0;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].pwr4_xg0)/4));
		}
		uiPrintf("|\n");
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}
		
		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] = 63;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].maxPower_t4)/4));
		}
		uiPrintf("|\n");
		
    	if(mode == MODE_11A) {
			uiPrintf("|              |              |              |              |              |\n");	
		}
		else {
    		uiPrintf("               |              |              |              |\n");	
		}

		if(numXpdGain > 1) {
    		if(mode == MODE_11A) {
				uiPrintf("| XPD_Gain %2d  |              |              |              |              |\n", 
					xpdGainMapping[xpdGainValues[1]]);	
			}
			else {
    			uiPrintf("               | XPD_Gain %2d  |              |              |\n",
					xpdGainMapping[xpdGainValues[1]]);	
			}
	    	if(mode != MODE_11A) {
				uiPrintf("               ");		
			}
			for(i = k; i < (k + i_end); i++) {
				uiPrintf("|  %02d  %6.2f  ", 20,	((float)(pDataPerChannel[i].pwr1_xg3)/4));
			}
			uiPrintf("|\n");
	    	if(mode != MODE_11A) {
				uiPrintf("               ");		
			}
			for(i = k; i < (k + i_end); i++) {
				uiPrintf("|  %02d  %6.2f  ", 35,	((float)(pDataPerChannel[i].pwr2_xg3)/4));
			}
			uiPrintf("|\n");
	    	if(mode != MODE_11A) {
				uiPrintf("               ");		
			}
			for(i = k; i < (k + i_end); i++) {
				uiPrintf("|  %02d  %6.2f  ", 63,	((float)(pDataPerChannel[i].pwr3_xg3)/4));
			}
			uiPrintf("|\n");
		}
		if(mode == MODE_11A) {
			uiPrintf("|==============|==============|==============|==============|==============|\n");
		} else {
			uiPrintf("               |==============|==============|==============|\n");
		}
	}

}

void
printfChannelInfo_gen5
(
 EEPROM_FULL_DATA_STRUCT_GEN5 *pChannelInfo, 
 A_UINT32 mode
)
{
	EEPROM_DATA_PER_CHANNEL_GEN5	*pDataPerChannel;
	A_UINT16 channelCount, channelRowCnt, vpdCount;
	A_UINT16 pdadcValues[10];
	A_INT16  powerValues_t2[10];
	A_UINT16 xpdGainMask;
	A_UINT16 channelRowCnt_end, channelCount_end;
	A_UINT16 xpdGainValues[NUM_XPD_PER_CHANNEL];
	A_UINT16 numXpdGain = 0;
	A_UINT16 pdGainCount;

	if (!pChannelInfo) {
	   printf("printfChannelInfo_gen5::NULL channel info passed\n");
	   return;
	}

	switch(mode) {
	case MODE_11A:
		pDataPerChannel = pChannelInfo->pDataPerChannel11a;
		xpdGainMask = pChannelInfo->xpd_mask11a;
		break;

	case MODE_11G:
	case MODE_11O:
		pDataPerChannel = pChannelInfo->pDataPerChannel11g;
		xpdGainMask = pChannelInfo->xpd_mask11g;
		break;

	case MODE_11B:
		pDataPerChannel = pChannelInfo->pDataPerChannel11b;
		xpdGainMask = pChannelInfo->xpd_mask11b;
		break;

	default:
		printf("Illegal mode passed to printfChannelInfo_gen5\n");
		return;
	}

	//calculate the value of xpdgains
	for (pdGainCount = 0; pdGainCount < MAX_NUM_PDGAINS_PER_CHANNEL; pdGainCount++) {
		if (((xpdGainMask >> (MAX_NUM_PDGAINS_PER_CHANNEL-pdGainCount-1)) & 1) > 0) {
			if (numXpdGain >= MAX_NUM_PDGAINS_PER_CHANNEL) {
				printf("A maximum of 4 pd_gains supported in eep_to_raw_data for gen5\n");
				exit(0);
			}
			xpdGainValues[numXpdGain++] = (A_UINT16) (MAX_NUM_PDGAINS_PER_CHANNEL-pdGainCount-1);			
		}
	}


	uiPrintf("\n");
	if(mode == MODE_11A) {
		uiPrintf("=========================Calibration Information============================\n");
		channelRowCnt_end = 10;
		channelCount_end = 5;
	}
	else {
		uiPrintf("=========================Calibration Information=============\n");
		channelRowCnt_end = 4;
		channelCount_end = 4;
	}

	for (channelRowCnt = 0; channelRowCnt < channelRowCnt_end; channelRowCnt+=5) {
		if(mode != MODE_11A) {
//			uiPrintf("               ");
		}
		for(channelCount = channelRowCnt; channelCount < (channelRowCnt + channelCount_end); channelCount++) {
			uiPrintf("|     %04d     ",
				pDataPerChannel[channelCount].channelValue);
		}
		uiPrintf("|\n");
		
    	if(mode == MODE_11A) {
	    	uiPrintf("|==============|==============|==============|==============|==============|\n");
		}
		else {
    		uiPrintf("===============|==============|==============|==============|\n");
//			uiPrintf("               ");
		}
		for(channelCount = channelRowCnt; channelCount < (channelRowCnt + channelCount_end); channelCount++) {
			uiPrintf("|pdadc pwr(dBm)");
		}
		uiPrintf("|\n");

		for(pdGainCount = 0; pdGainCount < numXpdGain; pdGainCount++) {
			if(mode == MODE_11A) {
				uiPrintf("|              |              |              |              |              |\n");
				uiPrintf("| PD_Gain %2d   |              |              |              |              |\n", 
					xpdGainMapping_gen5[xpdGainValues[pdGainCount]]);	
			}
			else {
    			uiPrintf("| PD_Gain %2d   |              |              |              |\n",
					xpdGainMapping_gen5[xpdGainValues[pdGainCount]]);	
    			uiPrintf("|              |              |              |              |\n");
			}
			
    		if(mode != MODE_11A) {
	//			uiPrintf("               ");		
			}
			for(channelCount = channelRowCnt; channelCount < (channelRowCnt + channelCount_end); channelCount++) {
				pdadcValues[channelCount] = pDataPerChannel[channelCount].Vpd_I[pdGainCount];
				powerValues_t2[channelCount] = pDataPerChannel[channelCount].pwr_I[pdGainCount] * 2;
				uiPrintf("|  %03d %6.2f  ", pdadcValues[channelCount],	((float)(powerValues_t2[channelCount])/2));
			}
			uiPrintf("|\n");
    		if(mode != MODE_11A) {
//				uiPrintf("               ");		
			}
			for(vpdCount = 0; vpdCount < NUM_POINTS_OTHER_PDGAINS - 1; vpdCount++) {
				for(channelCount = channelRowCnt; channelCount < (channelRowCnt + channelCount_end); channelCount++) {
					pdadcValues[channelCount] += pDataPerChannel[channelCount].Vpd_delta[vpdCount][pdGainCount];
					powerValues_t2[channelCount] += pDataPerChannel[channelCount].pwr_delta_t2[vpdCount][pdGainCount];
					uiPrintf("|  %03d %6.2f  ", pdadcValues[channelCount],	((float)(powerValues_t2[channelCount])/2));
				}
				uiPrintf("|\n");
	   			if(mode != MODE_11A) {
//					uiPrintf("               ");		
				}
			}

			if(pdGainCount == numXpdGain - 1) {  //this is the last xpdgain, has an extra set
				for(channelCount = channelRowCnt; channelCount < (channelRowCnt + channelCount_end); channelCount++) {
					pdadcValues[channelCount] += pDataPerChannel[channelCount].Vpd_delta[vpdCount][pdGainCount];
					powerValues_t2[channelCount] += pDataPerChannel[channelCount].pwr_delta_t2[vpdCount][pdGainCount];
					uiPrintf("|  %03d %6.2f  ", pdadcValues[channelCount],	((float)(powerValues_t2[channelCount])/2));
				}

				uiPrintf("|\n");
	    		if(mode != MODE_11A) {
//					uiPrintf("               ");		
				}
			}

			
    		if(mode == MODE_11A) {
				uiPrintf("|              |              |              |              |              |\n");	
			}
			else {
    			uiPrintf("|              |              |              |              |\n");	
			}

		}

		if(mode == MODE_11A) {
			uiPrintf("|==============|==============|==============|==============|==============|\n");
		} else {
			uiPrintf("|==============|==============|==============|==============|\n");
		}
	}

}


void printEepromStruct_16K
(
 A_UINT32	devNum,
 A_UINT32	mode
)
{
	void				*pTempPtr;
	MDK_EEP_HEADER_INFO		*pHeaderPtr;	//need to keep a copy of header pointer for later
	A_UINT16 testGroups[MAX_NUM_CTL];
	A_UINT16 numCtl, minorRevision, majorRevision;

	if(isDragon_sd(swDeviceID)) {
//	if(1){
	    printAR6000Eeprom(devNum);
		return;	
	}
	
	art_GetEepromStruct(devNum, EEP_HEADER_16K, &pTempPtr);
	pHeaderPtr = (MDK_EEP_HEADER_INFO *)pTempPtr; 
	printHeaderInfo_16K(pHeaderPtr, mode);
	//take a copy of the NUM_CTL test groups for later
	memcpy(testGroups, pHeaderPtr->testGroups, sizeof(A_UINT16) * pHeaderPtr->numCtl);
	numCtl = pHeaderPtr->numCtl;
	minorRevision = pHeaderPtr->minorVersion;
	majorRevision = pHeaderPtr->majorVersion;

	uiPrintf("\nPress any key to continue\n");
	while(!kbhit());
	getch();

	if((majorRevision ==3) ||
		((majorRevision >= 4) && (pHeaderPtr->eepMap == 0))){
		art_GetEepromStruct(devNum, EEP_CHANNEL_INFO_16K, &pTempPtr);
		printChannelInfo_16K((MDK_PCDACS_ALL_MODES *)pTempPtr, mode);
	}
	else if((majorRevision >=4) && pHeaderPtr->eepMap==1) {
		art_GetEepromStruct(devNum, EEP_GEN3_CHANNEL_INFO, &pTempPtr);
		printfChannelInfo_gen3((EEPROM_FULL_DATA_STRUCT_GEN3 *)pTempPtr, mode);

	}
	else if(majorRevision ==5) {
		art_GetEepromStruct(devNum, EEP_GEN5_CHANNEL_INFO, &pTempPtr);
		printfChannelInfo_gen5((EEPROM_FULL_DATA_STRUCT_GEN5 *)pTempPtr, mode);

	}
	else {
		uiPrintf("ERROR: EEPROM version number NOT supported for displaying channel info\n");
	}
	uiPrintf("\nPress any key to continue\n");
	while(!kbhit());
	getch();

	art_GetEepromStruct(devNum, EEP_TRGT_POWER_16K, &pTempPtr);
	printTargetPowerInfo_16K((MDK_TRGT_POWER_ALL_MODES *)pTempPtr, mode);
	uiPrintf("\nPress any key to continue\n");
	while(!kbhit());
	getch();

	art_GetEepromStruct(devNum, EEP_RD_POWER_16K, &pTempPtr);
	printRDEdges_16K((MDK_RD_EDGES_POWER *)pTempPtr, testGroups, mode, numCtl, majorRevision, minorRevision);
	uiPrintf("\nPress any key to continue\n");
	while(!kbhit());
	getch();
	return;
}