meeprom.c

Atheros AP Test with Agilent N4010A source code

			|| (pHeaderInfo->majorVersion >= 4)){
		offset++;
		tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
		pHeaderInfo->info11a.falseDetectBackoff = (A_UINT16)((tempValue >> 6)  & 0x7f);
	}

	if(((pHeaderInfo->majorVersion == 3) && (pHeaderInfo->minorVersion >= 4)) 
			|| (pHeaderInfo->majorVersion >= 4)){
		pHeaderInfo->info11a.initialGainI = (A_UINT16)((tempValue >> 13) & 0x07);
		pHeaderInfo->info11a.xrTargetPower = (A_UINT16)(tempValue  & 0x3f);

		offset++;
		tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
		pHeaderInfo->info11a.initialGainI = (A_UINT16)(((tempValue & 0x07) << 3) | pHeaderInfo->info11a.initialGainI);
	}

	if(pHeaderInfo->majorVersion >= 4) {	
		pHeaderInfo->info11a.iqCalQ = (A_UINT16)((tempValue >> 3) & 0x1f);
		pHeaderInfo->info11a.iqCalI = (A_UINT16)((tempValue >> 8) & 0x3f);
		
		offset++;
		if(pHeaderInfo->minorVersion >= 1) {
			tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
			pHeaderInfo->info11a.rxtxMargin = (A_UINT16)(tempValue & 0x3f);
		}
	}

	//read the turbo params
	if(pHeaderInfo->majorVersion >= 5) {	
		pHeaderInfo->info11a.turbo.switchSettling = (A_UINT16)((tempValue >> 6) & 0x7f);
		pHeaderInfo->info11a.turbo.txrxAtten = (A_UINT16)((tempValue >> 13) & 0x7);

		offset++;
		tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
		pHeaderInfo->info11a.turbo.txrxAtten = (A_UINT16)(((tempValue & 0x07) << 3) | pHeaderInfo->info11a.turbo.txrxAtten);
		pHeaderInfo->info11a.turbo.rxtxMargin = (A_UINT16)((tempValue >> 3) & 0x3f);
		pHeaderInfo->info11a.turbo.adcDesiredSize = (A_INT8)((tempValue >> 9) & 0x7f);

		offset++;
		tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
		pHeaderInfo->info11a.turbo.adcDesiredSize = (A_INT8)(((tempValue & 0x01) << 7) | pHeaderInfo->info11a.turbo.adcDesiredSize);
		pHeaderInfo->info11a.turbo.pgaDesiredSize = (A_INT8)((tempValue >> 1) & 0xff);
	}

	//11b and g params
	//start by reading b
	pModeInfo = &(pHeaderInfo->info11b);
	offset = pOffsets->HDR_11B_COMMON;
	for (i = 0; i < 2; i++) {
		tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
		pModeInfo->switchSettling = (A_UINT16)((tempValue >> 8) & 0x7f);
		pModeInfo->txrxAtten = (A_UINT16)((tempValue >> 2) & 0x3f);
		pModeInfo->antennaControl[0] = (A_UINT16)((tempValue << 4) & 0x3f);

		tempValue = eepromRead(devNum, (offset + 1 + pLibDev->eepromStartLoc));
		pModeInfo->antennaControl[0] = (A_UINT16)(((tempValue >> 12) & 0x0f) | pModeInfo->antennaControl[0]);
		pModeInfo->antennaControl[1] = (A_UINT16)((tempValue >> 6) & 0x3f);
		pModeInfo->antennaControl[2] = (A_UINT16)(tempValue  & 0x3f);

		tempValue = eepromRead(devNum, (offset + 2 + pLibDev->eepromStartLoc));
		pModeInfo->antennaControl[3] = (A_UINT16)((tempValue >> 10)  & 0x3f);
		pModeInfo->antennaControl[4] = (A_UINT16)((tempValue >> 4)  & 0x3f);
		pModeInfo->antennaControl[5] = (A_UINT16)((tempValue << 2)  & 0x3f);

		tempValue = eepromRead(devNum, (offset + 3 + pLibDev->eepromStartLoc));
		pModeInfo->antennaControl[5] = (A_UINT16)(((tempValue >> 14)  & 0x03) | pModeInfo->antennaControl[5]);
		pModeInfo->antennaControl[6] = (A_UINT16)((tempValue >> 8)  & 0x3f);
		pModeInfo->antennaControl[7] = (A_UINT16)((tempValue >> 2)  & 0x3f);
		pModeInfo->antennaControl[8] = (A_UINT16)((tempValue << 4)  & 0x3f);

		tempValue = eepromRead(devNum, (offset + 4 + pLibDev->eepromStartLoc));
		pModeInfo->antennaControl[8] = (A_UINT16)(((tempValue >> 12)  & 0x0f) | pModeInfo->antennaControl[8]);
		pModeInfo->antennaControl[9] = (A_UINT16)((tempValue >> 6)  & 0x3f);
		pModeInfo->antennaControl[10] = (A_UINT16)(tempValue & 0x3f);

		tempValue = eepromRead(devNum, (offset + 5 + pLibDev->eepromStartLoc));
		pModeInfo->adcDesiredSize = (A_INT8)((tempValue >> 8)  & 0xff);
		pModeInfo->ob_1 = (A_UINT16)((tempValue >> 4)  & 0x07);
		pModeInfo->db_1 = (A_UINT16)(tempValue & 0x07);

		tempValue = eepromRead(devNum, (offset + 6 + pLibDev->eepromStartLoc));
		pModeInfo->txEndToXLNAOn = (A_UINT16)((tempValue >> 8)  & 0xff);
		pModeInfo->thresh62 = (A_UINT16)(tempValue  & 0xff);

		tempValue = eepromRead(devNum, (offset + 7 + pLibDev->eepromStartLoc));
		pModeInfo->txEndToXPAOff = (A_UINT16)((tempValue >> 8)  & 0xff);
		pModeInfo->txFrameToXPAOn = (A_UINT16)(tempValue  & 0xff);

		tempValue = eepromRead(devNum, (offset + 8 + pLibDev->eepromStartLoc));
		pModeInfo->pgaDesiredSize = (A_INT8)((tempValue >> 8)  & 0xff);
		pModeInfo->noisefloorThresh = (A_INT8)(tempValue  & 0xff);
		
		tempValue = eepromRead(devNum, (offset + 9 + pLibDev->eepromStartLoc));
		if((pHeaderInfo->majorVersion >= 4) && (i == 1)) {
			pHeaderInfo->fixedBiasB = (A_UINT16)((tempValue >> 13)  & 0x01); 
		}
		pModeInfo->xlnaGain = (A_UINT16)((tempValue >> 5)  & 0xff);
		pModeInfo->xgain = (A_UINT16)((tempValue >> 1)  & 0x0f);
		pModeInfo->xpd = (A_UINT8)(tempValue  & 0x01);

		if(((pHeaderInfo->majorVersion == 3) && (pHeaderInfo->minorVersion >= 3)) 
			|| (pHeaderInfo->majorVersion >= 4)){
			tempValue = eepromRead(devNum, (offset+10 + pLibDev->eepromStartLoc));
			pModeInfo->falseDetectBackoff = (A_UINT16)((tempValue >> 6)  & 0x7f);
		}

		//read the extra info for EEPROM version 3.4
		if(((pHeaderInfo->majorVersion == 3) && (pHeaderInfo->minorVersion >= 4)) 
			|| (pHeaderInfo->majorVersion >= 4)){
			pModeInfo->initialGainI = (A_UINT16)((tempValue >> 13) & 0x07);

			tempValue = eepromRead(devNum, (offset + 11 + pLibDev->eepromStartLoc));
			pModeInfo->initialGainI = (A_UINT16)(((tempValue & 0x07) << 3) | pModeInfo->initialGainI);
			pLibDev->p16kEepHeader->scaledOfdmCckDelta = (A_UINT16)((tempValue >> 3) & 0xff);

			if(((pHeaderInfo->majorVersion == 4) && (pHeaderInfo->minorVersion >= 6)) ||
				(pHeaderInfo->majorVersion >= 5)){
				pLibDev->p16kEepHeader->scaledCh14FilterCckDelta = (A_UINT16)((tempValue >> 11)  & 0x1f);
			}

			tempValue = eepromRead(devNum, (offset + 12 + pLibDev->eepromStartLoc));
			pModeInfo->calPier1 = (A_UINT16)(tempValue & 0xff);
			if(pModeInfo->calPier1 != 0xff) {
				pModeInfo->calPier1 = fbin2freq_2p4(devNum, pModeInfo->calPier1);
			}
			pModeInfo->calPier2 = (A_UINT16)((tempValue >> 8)  & 0xff);
			if(pModeInfo->calPier2 != 0xff) {
				pModeInfo->calPier2 = fbin2freq_2p4(devNum, pModeInfo->calPier2);
			}

			if(i == 1) {  //11g mode
 				tempValue = eepromRead(devNum, (offset + 13 + pLibDev->eepromStartLoc));
				pModeInfo->turbo.max2wPower = (A_UINT16)(tempValue & 0x7f);		
				pModeInfo->xrTargetPower = (A_UINT16)((tempValue >> 7)  & 0x3f);

			}
		}

		if(pHeaderInfo->majorVersion >= 4) {
			if(i == 0) {
				tempValue = eepromRead(devNum, (offset + 13 + pLibDev->eepromStartLoc));
				pModeInfo->calPier3 = (A_UINT16)(tempValue & 0xff);
				if(pModeInfo->calPier3 != 0xff) {
					pModeInfo->calPier3 = fbin2freq_2p4(devNum, pModeInfo->calPier3);
				}

				if( ((pHeaderInfo->majorVersion == 4) && (pHeaderInfo->minorVersion >= 1)) ||
					(pHeaderInfo->majorVersion >= 5)){
					pModeInfo->rxtxMargin = (A_UINT16)((tempValue >> 8) & 0x3f);
				}
			}

			if(i == 1) {  //11g mode
				tempValue = eepromRead(devNum, (offset + 14 + pLibDev->eepromStartLoc));
				pModeInfo->calPier3 = (A_UINT16)(tempValue & 0xff);
				if(pModeInfo->calPier3 != 0xff) {
					pModeInfo->calPier3 = fbin2freq_2p4(devNum, pModeInfo->calPier3);
				}
				
				if( ((pHeaderInfo->majorVersion == 4) && (pHeaderInfo->minorVersion >= 1)) ||
					(pHeaderInfo->majorVersion >= 5)){
					pModeInfo->rxtxMargin = (A_UINT16)((tempValue >> 8) & 0x3f);
				}

				tempValue = eepromRead(devNum, (offset + 15 + pLibDev->eepromStartLoc));
				pModeInfo->iqCalQ = (A_UINT16)(tempValue & 0x1f);
				pModeInfo->iqCalI = (A_UINT16)((tempValue >> 5)  & 0x3f);

				if( ((pHeaderInfo->majorVersion == 4) && (pHeaderInfo->minorVersion >= 2)) ||
					(pHeaderInfo->majorVersion >= 5)){
					tempValue = eepromRead(devNum, (offset + 16 + pLibDev->eepromStartLoc));				
					pHeaderInfo->ofdmCckGainDeltaX2 = (A_INT8)(tempValue & 0xFF);				
				}
			}
		}
		if(pHeaderInfo->majorVersion >= 5) {
			if(i == 1) {  //11g mode
				//read the turbo params
				pModeInfo->turbo.switchSettling = (A_UINT16)((tempValue >> 8) & 0x7f);
				pModeInfo->turbo.txrxAtten = (A_UINT16)((tempValue >> 15) & 0x1);

				tempValue = eepromRead(devNum, (offset + 17 + pLibDev->eepromStartLoc));				
				pModeInfo->turbo.txrxAtten = (A_UINT16)(((tempValue & 0x1f) << 1) | pModeInfo->turbo.txrxAtten);
				pModeInfo->turbo.rxtxMargin = (A_UINT16)((tempValue >> 5) & 0x3f);
				pModeInfo->turbo.adcDesiredSize = (A_INT8)((tempValue >> 10) & 0x1f);
				
				tempValue = eepromRead(devNum, (offset + 18 + pLibDev->eepromStartLoc));				
				pModeInfo->turbo.adcDesiredSize = (A_INT8)(((tempValue & 0x7) << 5) | pModeInfo->turbo.adcDesiredSize);
				pModeInfo->turbo.pgaDesiredSize = (A_INT8)((tempValue >> 3) & 0xff);
			}
		}

		//change params to read g stuff
		pModeInfo = &(pHeaderInfo->info11g);
		offset = pOffsets->HDR_11G_COMMON;
	}
	
	//read the test groups
	offset = pOffsets->HDR_CTL;
	for( i = 0; i < pHeaderInfo->numCtl; i+=2) {
		tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
		offset++;
		pHeaderInfo->testGroups[i] = (A_UINT16)((tempValue >> 8) & 0xff);
		pHeaderInfo->testGroups[i+1] = (A_UINT16)(tempValue & 0xff);
	}

	//read b and g ob/db, store in ob/db_4
	if(((pHeaderInfo->majorVersion == 3) && (pHeaderInfo->minorVersion >= 1)) 
			|| (pHeaderInfo->majorVersion >= 4)){
		tempValue = eepromRead(devNum, (pOffsets->HDR_11B_SPECIFIC + pLibDev->eepromStartLoc));
		pHeaderInfo->info11b.db_4 = (A_UINT16)((tempValue >> 3) & 0x7);
		pHeaderInfo->info11b.ob_4 = (A_UINT16)(tempValue & 0x7);
		tempValue = eepromRead(devNum, (pOffsets->HDR_11G_SPECIFIC + pLibDev->eepromStartLoc));
		pHeaderInfo->info11g.db_4 = (A_UINT16)((tempValue >> 3) & 0x7);
		pHeaderInfo->info11g.ob_4 = (A_UINT16)(tempValue & 0x7);
	}

	
	//read corner cal info
#if 0
	if(pHeaderInfo->minorVersion >= 2) {
		offset = pOffsets->HDR_11A_SPECIFIC;
		tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
		offset++;
		pHeaderInfo->cornerCal[0].gSel = (A_UINT16)(tempValue & 0x1);
		pHeaderInfo->cornerCal[0].pd84 = (A_UINT16)((tempValue >> 1) & 0x1);
		pHeaderInfo->cornerCal[0].pd90 = (A_UINT16)((tempValue >> 2) & 0x1);
		pHeaderInfo->cornerCal[0].clip = (A_UINT16)((tempValue >> 3) & 0x7);
		pHeaderInfo->cornerCal[1].gSel = (A_UINT16)((tempValue >> 6) & 0x1);
		pHeaderInfo->cornerCal[1].pd84 = (A_UINT16)((tempValue >> 7) & 0x1);
		pHeaderInfo->cornerCal[1].pd90 = (A_UINT16)((tempValue >> 8) & 0x1);
		pHeaderInfo->cornerCal[1].clip = (A_UINT16)((tempValue >> 9) & 0x7);
		pHeaderInfo->cornerCal[2].gSel = (A_UINT16)((tempValue >> 12) & 0x1);
		pHeaderInfo->cornerCal[2].pd84 = (A_UINT16)((tempValue >> 13) & 0x1);
		pHeaderInfo->cornerCal[2].pd90 = (A_UINT16)((tempValue >> 14) & 0x1);
		pHeaderInfo->cornerCal[2].clip = (A_UINT16)((tempValue >> 15) & 0x1);
		
		tempValue = eepromRead(devNum, (offset + pLibDev->eepromStartLoc));
		pHeaderInfo->cornerCal[2].clip = (A_UINT16)(((tempValue & 0x3) << 1) | pHeaderInfo->cornerCal[2].clip);
		pHeaderInfo->cornerCal[3].gSel = (A_UINT16)((tempValue >> 2) & 0x1);
		pHeaderInfo->cornerCal[3].pd84 = (A_UINT16)((tempValue >> 3) & 0x1);
		pHeaderInfo->cornerCal[3].pd90 = (A_UINT16)((tempValue >> 4) & 0x1);
		pHeaderInfo->cornerCal[3].clip = (A_UINT16)((tempValue >> 5) & 0x7);
	}
#endif
	return;
}

/**************************************************************************
* programHeaderInfo - Program device registers with eeprom header info
*
* RETURNS: 
*/
void  programHeaderInfo
(
 A_UINT32			devNum,
 MDK_EEP_HEADER_INFO	*pHeaderInfo,
 A_UINT16			freq,
 A_UCHAR			mode
)
{
	A_UINT32		tempOB=0;
	A_UINT32		tempDB=0;

	MODE_HEADER_INFO	*pModeInfo;
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	TURBO_HEADER_INFO   *pTurboInfo;

//	if(pLibDev->eepromHeaderApplied[mode]) {
//		return;
//	}
	
//printf("mode=%d\n", mode);
	switch(mode) {
	case MODE_11A:
		pModeInfo = &(pHeaderInfo->info11a);
		break;

	case MODE_11G:
	case MODE_11O:
		pModeInfo = &(pHeaderInfo->info11g);
		break;

	case MODE_11B:
		pModeInfo = &(pHeaderInfo->info11b);
		break;

	default:

		mError(devNum, EINVAL, "Device Number %d:Illegal mode passed to programHeaderInfo\n", devNum);
		return;
	} //end switch
	

/*
	   writeField(devNum, "bb_switch_settling", pModeInfo->switchSettling); 
	   writeField(devNum, "bb_txrxatten", pModeInfo->txrxAtten);

*/

	pTurboInfo = &(pModeInfo->turbo);
	if (pHeaderInfo->majorVersion >= 5){
	   writeField(devNum, "bb_switch_settling", 
		   pLibDev->turbo == TURBO_ENABLE ? pTurboInfo->switchSettling : pModeInfo->switchSettling); 
	   writeField(devNum, "bb_txrxatten", 
		   pLibDev->turbo == TURBO_ENABLE ? pTurboInfo->txrxAtten : pModeInfo->txrxAtten);
	   writeField(devNum, "bb_pga_desired_size", 
		   pLibDev->turbo == TURBO_ENABLE ? pTurboInfo->pgaDesiredSize : pModeInfo->pgaDesiredSize);
	   writeField(devNum, "bb_adc_desired_size", 
		   pLibDev->turbo == TURBO_ENABLE ? pTurboInfo->adcDesiredSize : pModeInfo->adcDesiredSize);
	}
	else {
	   writeField(devNum, "bb_switch_settling", pModeInfo->switchSettling); 
	   writeField(devNum, "bb_txrxatten", pModeInfo->txrxAtten);
	   writeField(devNum, "bb_pga_desired_size", pModeInfo->pgaDesiredSize);
	   writeField(devNum, "bb_adc_desired_size", pModeInfo->adcDesiredSize);
	}
	if(((pHeaderInfo->majorVersion == 4) && (pHeaderInfo->minorVersion >= 1)) ||
	  (pHeaderInfo->majorVersion >= 5)){

		if (pHeaderInfo->majorVersion >= 5){
		   writeField(devNum, "bb_rxtx_margin_2ghz", 
			   pLibDev->turbo == TURBO_ENABLE ? pTurboInfo->rxtxMargin : pModeInfo->rxtxMargin);
		}
		else {
		   writeField(devNum, "bb_rxtx_margin_2ghz", pModeInfo->rxtxMargin);
		}
	}


	if(((freq > 4000) && (freq < 5260)) || (mode != MODE_11A)) {
		tempOB = pModeInfo->ob_1;
		tempDB = pModeInfo->db_1;
	}
	else if ((freq >= 5260) && (freq < 5500)) {
		tempOB = pModeInfo->ob_2;
		tempDB = pModeInfo->db_2;
	}
	else if ((freq >= 5500) && (freq < 5725)) {
		tempOB = pModeInfo->ob_3;
		tempDB = pModeInfo->db_3;
	}
	else if (freq >= 5725) {
		tempOB = pModeInfo->ob_4;
		tempDB = pModeInfo->db_4;
	}

	writeField(devNum, "rf_ob", tempOB);
	writeField(devNum, "rf_db", tempDB);

	if (!isGriffin(pLibDev->swDevID)) { // exclude griffin
		if((mode != MODE_11A)&&
			((pHeaderInfo->majorVersion == 3) && (pHeaderInfo->minorVersion >= 1)) 
				|| (pHeaderInfo->majorVersion >= 4)){
			//write the b_ob and b_db which are held in ob/db_4
			writeField(devNum, "rf_b_ob", pModeInfo->ob_4);
			writeField(devNum, "rf_b_db", pModeInfo->db_4);
		}
		writeField(devNum, "bb_tx_end_to_xlna_on", pModeInfo->txEndToXLNAOn);
	}


	writeField(devNum, "bb_thresh62", pModeInfo->thresh62);

	if(pLibDev->mode == MODE_11A) {
		writeField(devNum, "bb_tx_end_to_xpaa_off", pModeInfo->txEndToXPAOff);
		writeField(devNum, "bb_tx_frame_to_xpaa_on", pModeInfo->txFrameToXPAOn);
	}
	else  {
		writeField(devNum, "bb_tx_end_to_xpab_off", pModeInfo->txEndToXPAOff);
		writeField(devNum, "bb_tx_frame_to_xpab_on", pMode