meeprom.c

atheros ar5001 5002 driver

	writeField(devNum, "rf_db", tempDB);

	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);

	writeField(devNum, "bb_tx_end_to_xpaa_off", pModeInfo->txEndToXPAOff);
	writeField(devNum, "bb_tx_frame_to_xpaa_on", pModeInfo->txFrameToXPAOn);

	writeField(devNum, "bb_pga_desired_size", pModeInfo->pgaDesiredSize);

	if((pLibDev->p16kEepHeader->majorVersion <= 3) ||
		((pLibDev->p16kEepHeader->majorVersion == 4) && (pLibDev->p16kEepHeader->eepMap == 0))) {
		writeField(devNum, "rf_xpd_gain", pModeInfo->xgain);
	}
	
	if(((pLibDev->swDevID & 0xff) <= 0x13) || ((pLibDev->swDevID & 0xff) == 0x15)) {
		writeField(devNum, "rf_plo_sel", pModeInfo->xpd);
		writeField(devNum, "rf_pwdxpd", !pModeInfo->xpd);
	}
	else {
		writeField(devNum, "rf_xpdsel", pModeInfo->xpd);
	}

	if ((pLibDev->swDevID & 0xff) >= 0x0012) 
	{
//		setAntennaTbl5211(devNum, pModeInfo->antennaControl);
		forceAntennaTbl5211(devNum, pModeInfo->antennaControl);
	}

	if(((pHeaderInfo->majorVersion == 3) && (pHeaderInfo->minorVersion >= 4)) 
			|| (pHeaderInfo->majorVersion == 4)){
		writeField(devNum, "rf_gain_I", pModeInfo->initialGainI);
	}

	if(pHeaderInfo->majorVersion == 4) {
		if(pLibDev->mode != MODE_11B) {
			//program the IQ cal values
			writeField(devNum, "bb_iqcorr_q_i_coff", pModeInfo->iqCalI);
			writeField(devNum, "bb_iqcorr_q_q_coff", pModeInfo->iqCalQ);
		}
		
		if(((pLibDev->swDevID & 0xff) == 0x14) || ((pLibDev->swDevID & 0xff) >= 0x16)) {
			writeField(devNum, "bb_do_iqcal", 1);
			writeField(devNum, "rf_Afixed_bias", pHeaderInfo->fixedBiasA);
			writeField(devNum, "rf_Bfixed_bias", pHeaderInfo->fixedBiasB);
		}

		if(pHeaderInfo->minorVersion >= 1) {
			writeField(devNum, "bb_rxtx_margin_2ghz", pModeInfo->rxtxMargin);
		}
	}

#if 0
	if((mode == MODE_11A)&&(pHeaderInfo->minorVersion >= 2)) {
		writeCornerCal(devNum, freq, pHeaderInfo);
	}
#endif
	return;
}

#if 0
void writeCornerCal
(
 A_UINT32 devNum, 
 A_UINT16 channel,
 MDK_EEP_HEADER_INFO	*pHeaderInfo
)
{
	A_UINT16  Lch, Rch, Nch, jj;

	iGetLowerUpperValues(channel, cornerFixChannels, NUM_CORNER_FIX_CHANNELS, &Lch, &Rch);

	Nch = (abs(channel - Lch) >= abs(Rch - channel)) ? Rch : Lch;
	
	for (jj = 0; jj < NUM_CORNER_FIX_CHANNELS; jj++)
	{
		if (cornerFixChannels[jj] == Nch)
			break;
	}

//	uiPrintf("SNOOP:  %d: nearest channel is %d(jj=%d) (Lch=%d, Rch=%d)\n", channel, Nch,jj,Lch, Rch);
	writeField(devNum, "rf_rfgainsel", pHeaderInfo->cornerCal[jj].gSel);	
	writeField(devNum, "rf_pwd_84", pHeaderInfo->cornerCal[jj].pd84);	
	writeField(devNum, "rf_pwd_90", pHeaderInfo->cornerCal[jj].pd90);	
	writeField(devNum, "bb_tx_clip", pHeaderInfo->cornerCal[jj].clip);	
}
#endif

A_UINT16 readCtlInfo
(
 A_UINT32 devNum,
 A_UINT16 offset,
 MDK_RD_EDGES_POWER	*pRdEdgePwrInfo
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 tempValue;
	A_UINT16 sizeCtl = 0;
	A_UINT16 ii;

	if((pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion <= 2))
	{
		tempValue = eepromRead(devNum, offset++);
		pRdEdgePwrInfo[0].rdEdge = (A_UINT16)(( tempValue >> 9 ) & FREQ_MASK_16K);
		pRdEdgePwrInfo[1].rdEdge = (A_UINT16)(( tempValue >> 2 ) & FREQ_MASK_16K);
		pRdEdgePwrInfo[2].rdEdge = (A_UINT16)(( tempValue << 5 ) & FREQ_MASK_16K);

		tempValue = eepromRead(devNum, offset++);
		pRdEdgePwrInfo[2].rdEdge = (A_UINT16)((( tempValue >> 11 ) & 0x1f) | pRdEdgePwrInfo[2].rdEdge);
		pRdEdgePwrInfo[3].rdEdge = (A_UINT16)(( tempValue >> 4 ) & FREQ_MASK_16K);
		pRdEdgePwrInfo[4].rdEdge = (A_UINT16)(( tempValue << 3 ) & FREQ_MASK_16K);

		tempValue = eepromRead(devNum, offset++);
		pRdEdgePwrInfo[4].rdEdge = (A_UINT16)((( tempValue >> 13 ) & 0x7) | pRdEdgePwrInfo[4].rdEdge);
		pRdEdgePwrInfo[5].rdEdge = (A_UINT16)(( tempValue >> 6 ) & FREQ_MASK_16K);
		pRdEdgePwrInfo[6].rdEdge =  (A_UINT16)(( tempValue << 1 ) & FREQ_MASK_16K);

		tempValue = eepromRead(devNum, offset++);
		pRdEdgePwrInfo[6].rdEdge = (A_UINT16)((( tempValue >> 15 ) & 0x1) | pRdEdgePwrInfo[6].rdEdge);
		pRdEdgePwrInfo[7].rdEdge = (A_UINT16)(( tempValue >> 8 ) & FREQ_MASK_16K);

		pRdEdgePwrInfo[0].twice_rdEdgePower = (A_UINT16)(( tempValue >> 2 ) & POWER_MASK);
		pRdEdgePwrInfo[1].twice_rdEdgePower =  (A_UINT16)(( tempValue << 4 ) & POWER_MASK);
		
		tempValue = eepromRead(devNum, offset++);
		pRdEdgePwrInfo[1].twice_rdEdgePower = (A_UINT16)((( tempValue >> 12 ) & 0xf) | pRdEdgePwrInfo[1].twice_rdEdgePower);
		pRdEdgePwrInfo[2].twice_rdEdgePower = (A_UINT16)(( tempValue >> 6 ) & POWER_MASK);
		pRdEdgePwrInfo[3].twice_rdEdgePower = (A_UINT16)(tempValue & POWER_MASK);

		tempValue = eepromRead(devNum, offset++);
		pRdEdgePwrInfo[4].twice_rdEdgePower = (A_UINT16)(( tempValue >> 10 ) & POWER_MASK);
		pRdEdgePwrInfo[5].twice_rdEdgePower = (A_UINT16)(( tempValue >> 4 ) & POWER_MASK);
		pRdEdgePwrInfo[6].twice_rdEdgePower = (A_UINT16)(( tempValue << 2 ) & POWER_MASK);
		
		tempValue = eepromRead(devNum, offset++);
		pRdEdgePwrInfo[6].twice_rdEdgePower = (A_UINT16)((( tempValue >> 14 ) & 0x3) | pRdEdgePwrInfo[6].twice_rdEdgePower);
		pRdEdgePwrInfo[7].twice_rdEdgePower = (A_UINT16)(( tempValue >> 8 ) & POWER_MASK);
		sizeCtl = 7;
	}
	else
	{
		for (ii = 0; ii < NUM_16K_EDGES; ii+=2) { 
			tempValue = eepromRead(devNum, offset++);
			pRdEdgePwrInfo[ii].rdEdge = (A_UINT16)(( tempValue >> 8 ) & NEW_FREQ_MASK_16K);
			pRdEdgePwrInfo[ii+1].rdEdge = (A_UINT16)(( tempValue ) & NEW_FREQ_MASK_16K);
		}

		for (ii = 0; ii < NUM_16K_EDGES; ii+=2) { 
			tempValue = eepromRead(devNum, offset++);
			pRdEdgePwrInfo[ii+1].twice_rdEdgePower = (A_UINT16)(( tempValue ) & POWER_MASK);
			pRdEdgePwrInfo[ii+1].flag = (A_BOOL)((tempValue >> 6) & 0x01);
			pRdEdgePwrInfo[ii].twice_rdEdgePower = (A_UINT16)(( tempValue >> 8 ) & POWER_MASK);
			pRdEdgePwrInfo[ii].flag = (A_BOOL)((tempValue >> 14) & 0x01);
		}
		
		sizeCtl = 8;

	}
	return sizeCtl;
}


A_BOOL readTrgtPowers
(
 A_UINT32 devNum,
 A_UINT16 offset,
 MDK_TRGT_POWER_INFO *pPowerInfo,
 A_UINT16 mode
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 tempValue;
	A_BOOL	 readPower=FALSE;

	if((pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion <= 2))
	{
		tempValue = eepromRead(devNum, offset);
		pPowerInfo->testChannel = (A_UINT16)(( tempValue >> 9 ) & FREQ_MASK_16K);	

		if(pPowerInfo->testChannel != 0) {
			//get the channel value and read rest of info
			if (mode == MODE_11A) {
				pPowerInfo->testChannel = fbin2freq(devNum, pPowerInfo->testChannel);
			}
			else {
				pPowerInfo->testChannel = fbin2freq_2p4(devNum, pPowerInfo->testChannel);
			}
			pPowerInfo->twicePwr6_24 = (A_INT16)(( tempValue >> 3 ) & POWER_MASK);
			pPowerInfo->twicePwr36 = (A_INT16)(( tempValue << 3  ) & POWER_MASK);

			tempValue = eepromRead(devNum, offset+1);
			pPowerInfo->twicePwr36 = 
				(A_UINT16)(( ( tempValue >> 13 ) & 0x7 ) | pPowerInfo->twicePwr36);
			pPowerInfo->twicePwr48 = (A_INT16)(( tempValue >> 7 ) & POWER_MASK);
			pPowerInfo->twicePwr54 = (A_INT16)(( tempValue >> 1 ) & POWER_MASK);
			readPower = TRUE;
		}
	}
	else {
		tempValue = eepromRead(devNum, offset);
		pPowerInfo->testChannel = (A_UINT16)(( tempValue >> 8 ) & NEW_FREQ_MASK_16K);	

		if(pPowerInfo->testChannel != 0) {
			//get the channel value and read rest of info
			if (mode == MODE_11A) {
				pPowerInfo->testChannel = fbin2freq(devNum, pPowerInfo->testChannel);
			}
			else {
				pPowerInfo->testChannel = fbin2freq_2p4(devNum, pPowerInfo->testChannel);
			}
			pPowerInfo->twicePwr6_24 = (A_INT16)(( tempValue >> 2 ) & POWER_MASK);
			pPowerInfo->twicePwr36 = (A_INT16)(( tempValue << 4  ) & POWER_MASK);

			tempValue = eepromRead(devNum, offset+1);
			pPowerInfo->twicePwr36 = 
				(A_UINT16)(( ( tempValue >> 12 ) & 0xf ) | pPowerInfo->twicePwr36);
			pPowerInfo->twicePwr48 = (A_INT16)(( tempValue >> 6 ) & POWER_MASK);
			pPowerInfo->twicePwr54 = (A_INT16)(tempValue & POWER_MASK);
			readPower = TRUE;
		}

	}
	return readPower;
}


void readFreqPiers
(
 A_UINT32 devNum, 
 A_UINT16 *pChannels, 
 A_UINT16 numChannels
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT16	offset;
	A_UINT32	tempValue;
	A_UINT16	i;


	offset = pOffsets->GROUP1_11A_FREQ_PIERS;
	
	if((pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion <= 2))
	{
		tempValue = eepromRead(devNum, offset);
		pChannels[0] = (A_UINT16)(( tempValue >> 9 ) & FREQ_MASK_16K);
		pChannels[1] = (A_UINT16)(( tempValue >> 2 ) & FREQ_MASK_16K);
		pChannels[2] = (A_UINT16)(( tempValue << 5 ) & FREQ_MASK_16K);

		offset++;
		tempValue = eepromRead(devNum, offset);
		pChannels[2] = (A_UINT16)((( tempValue >> 11 ) & 0x1f) | pChannels[2]);
		pChannels[3] = (A_UINT16)(( tempValue >> 4 ) & FREQ_MASK_16K);
		pChannels[4] = (A_UINT16)(( tempValue << 3 ) & FREQ_MASK_16K);

		offset++;
		tempValue = eepromRead(devNum, offset);
		pChannels[4] = (A_UINT16)((( tempValue >> 13 ) & 0x7) | pChannels[4]);
		pChannels[5] = (A_UINT16)(( tempValue >> 6 ) & FREQ_MASK_16K);
		pChannels[6] =  (A_UINT16)(( tempValue << 1 ) & FREQ_MASK_16K);

		offset++;
		tempValue = eepromRead(devNum, offset);
		pChannels[6] = (A_UINT16)((( tempValue >> 15 ) & 0x1) | pChannels[6]);
		pChannels[7] = (A_UINT16)(( tempValue >> 8 ) & FREQ_MASK_16K);
		pChannels[8] =  (A_UINT16)(( tempValue >> 1 ) & FREQ_MASK_16K);
		pChannels[9] =  (A_UINT16)(( tempValue << 6 ) & FREQ_MASK_16K);
  
		offset++;
		tempValue = eepromRead(devNum, offset);
		pChannels[9] = (A_UINT16)((( tempValue >> 10 ) & 0x3f) | pChannels[9]);
	}
	else {
		for(i = 0; i < numChannels; i+=2) {
			tempValue = eepromRead(devNum, offset);
			pChannels[i] = (A_UINT16)((tempValue >> 8) & NEW_FREQ_MASK_16K);
			pChannels[i+1] = (A_UINT16)(tempValue & NEW_FREQ_MASK_16K);
			offset++;
		}
	}

	for(i = 0; i < numChannels; i++ ) {
		pChannels[i] = fbin2freq(devNum, pChannels[i]);
	}
}

/**************************************************************************
* eepromVerifyChecksum - Verify EEPROM checksum
*
* 
* RETURNS: TRUE if OK, FALSE otherwise 
*
*/
A_BOOL eepromVerifyChecksum
(
 A_UINT32	devNum
)
{
	A_UINT32	data = 0;
	A_UINT16	addr;
	A_UINT32	chksum = 0;

	data = eepromRead(devNum, 0xc0);
	for (addr=0xc0; addr < 0x400; addr++) {
		data = eepromRead(devNum,addr);
		chksum ^= (data & 0xffff);
	}

	chksum &= 0xffff;
	if (chksum != 0xffff) {
		return FALSE;
	}
	
	return TRUE;
}



/**************************************************************************
* eepromWriteBlock - Call correct eepromWrite function
*
* Write a block of eeprom starting from the startOffset with
* the eepromValue
*
*/
MANLIB_API void eepromWriteBlock
(
	A_UINT32 devNum, 
	A_UINT32 startOffset, 
	A_UINT32 length,
	A_UINT32 *eepromValue
)
{
   	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 i = pLibDev->ar5kInitIndex;
	A_UINT32 j;

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:eepromWriteBlock\n", devNum);
		return;
	}

	if (ar5kInitData[i].pMacAPI->eepromWrite == NULL) {
		return;
	}

//make AP eeprom block writing more efficient
#if defined(SPIRIT_AP) || defined(FREEDOM_AP)
{
	A_UINT8 *pVal;
	A_UINT16 *pTempBuffer;
	A_UINT16 *pTempPtr;

	//copy the data into 16bit data buffer
	pTempBuffer = (A_UINT16 *)malloc(length * sizeof(A_UINT16));
	pTempPtr = pTempBuffer;
	for(j = 0; j < length; j++) {
//#ifdef ENDIAN_SWAP
//		*eepromValue = btol_l(*eepromValue);
//#endif
		*pTempPtr = *eepromValue & 0xffff; 
		eepromValue++;
		pTempPtr++;
	}

	pVal = (A_UINT8 *)pTempBuffer;
// 16 bit addressing
//	q_uiPrintf("Write to eeprom @ %x : %x \n",eepromOffset,eepromValue); 
	startOffset = startOffset << 1;	
// write only the lower 2 bytes
	sysFlashConfigWrite(FLC_RADIOCFG, startOffset, pVal , length*sizeof(A_UINT16));
//	free(pTempBuffer);
	return;
}
#else
	for (j=0;j<length;j++) {
		ar5kInitData[i].pMacAPI->eepromWrite(devNum,(startOffset + j), *eepromValue);
		if (pLibDev->mdkErrno) return;
		eepromValue++;
	}
#endif
	return;
}

/**************************************************************************
* eepromReadBlock - call correct eepromR