meeprom.c

atheros ar5001 5002 driver

	else {
		returnValue = (A_UINT16)(2300 + fbin);
	}
	return returnValue;
}


/**************************************************************************
* allocateEepStructs - Allocate structs to hold eeprom contents
*
* Fills in pointers of the LIB_DEV_INFO struct
*
* RETURNS: TRUE if successfully allocated, false otherwise
*/
A_BOOL allocateEepStructs
(
 A_UINT32			devNum
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32	 i;

	//check to see if we already allocated thes stucts, if so, don't do again
	//if one ptrs is not null then so will the rest.
	if(pLibDev->pCalibrationInfo) {
		return(TRUE);
	}

	//allocate the struct to hold the pcdac/power info
	pLibDev->pCalibrationInfo = (MDK_PCDACS_ALL_MODES *)malloc(sizeof(MDK_PCDACS_ALL_MODES));
	if(NULL == pLibDev->pCalibrationInfo) {
		mError(devNum, ENOMEM, "Device Number %d:Device Number %d:Unable to allocate eeprom structure for pcdac/power info\n", devNum);
		return FALSE;
	}
	
	memset(pLibDev->pCalibrationInfo, 0, sizeof(MDK_PCDACS_ALL_MODES));

	pLibDev->pCalibrationInfo->numChannels_11a = NUM_11A_EEPROM_CHANNELS;
	pLibDev->pCalibrationInfo->numChannels_2_4 = NUM_2_4_EEPROM_CHANNELS;

	for(i = 0; i < NUM_11A_EEPROM_CHANNELS; i ++) {		
		pLibDev->pCalibrationInfo->DataPerChannel_11a[i].numPcdacValues = NUM_PCDAC_VALUES;	
	}

	//allocate the struct to hold the header info
	pLibDev->p16kEepHeader = (MDK_EEP_HEADER_INFO *)malloc(sizeof(MDK_EEP_HEADER_INFO));
	if(NULL ==pLibDev->p16kEepHeader) {
		mError(devNum, ENOMEM, "Device Number %d:Device Number %d:Unable to allocate eeprom structure for header info\n", devNum);
		freeEepStructs(devNum);
		return FALSE;
	}
	memset(pLibDev->p16kEepHeader, 0, sizeof(MDK_EEP_HEADER_INFO));

	//allocate the structure to hold target power info
	pLibDev->p16KTrgtPowerInfo = (MDK_TRGT_POWER_ALL_MODES *)malloc(sizeof(MDK_TRGT_POWER_ALL_MODES));
	if(NULL == pLibDev->p16KTrgtPowerInfo) {
		mError(devNum, ENOMEM, "Device Number %d:Device Number %d:Unable to allocate eeprom structure for target power info\n", devNum);
		freeEepStructs(devNum);
		return FALSE;
	}
	memset(pLibDev->p16KTrgtPowerInfo, 0, sizeof(MDK_TRGT_POWER_ALL_MODES));
	pLibDev->p16kEepHeader->scaledOfdmCckDelta = TENX_OFDM_CCK_DELTA_INIT;
	pLibDev->p16kEepHeader->scaledCh14FilterCckDelta = TENX_CH14_FILTER_CCK_DELTA_INIT;	
	pLibDev->p16kEepHeader->ofdmCckGainDeltaX2 = OFDM_CCK_GAIN_DELTA_INIT;

	//allocate structure for RD edges
	pLibDev->p16KRdEdgesPower = (MDK_RD_EDGES_POWER *)malloc(sizeof(MDK_RD_EDGES_POWER) * NUM_16K_EDGES * MAX_NUM_CTL);
	if(NULL == pLibDev->p16KRdEdgesPower) {
		mError(devNum, ENOMEM, "Device Number %d:Device Number %d:Unable to allocate eeprom structure for RD edges info\n", devNum);
		freeEepStructs(devNum);
		return FALSE;
	}
	memset(pLibDev->p16KRdEdgesPower, 0, sizeof(sizeof(MDK_RD_EDGES_POWER) * NUM_16K_EDGES * MAX_NUM_CTL));
	
	return TRUE;
}


/**************************************************************************
* freeEepStructs - Free EEPROM structs from LIB_DEV_INFO
*
* Generic free function, has to check for allocation before free since
* not all structs may be allocated.
*
* RETURNS:
*/
void freeEepStructs
(
 A_UINT32			devNum
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];

	if(pLibDev->pCalibrationInfo != NULL) {
		free(pLibDev->pCalibrationInfo);
		pLibDev->pCalibrationInfo = NULL;
	}

	if(pLibDev->p16kEepHeader != NULL) {
		free(pLibDev->p16kEepHeader);
		pLibDev->p16kEepHeader = NULL;
	}

	if(pLibDev->p16KTrgtPowerInfo != NULL) {
		free(pLibDev->p16KTrgtPowerInfo);
		pLibDev->p16KTrgtPowerInfo = NULL;
	}
	
	if (pLibDev->p16KRdEdgesPower != NULL) {
		free(pLibDev->p16KRdEdgesPower);
		pLibDev->p16KRdEdgesPower = NULL;
	}

	if(pLibDev->pGen3CalData != NULL) {
		free(pLibDev->pGen3CalData);
		pLibDev->pGen3CalData = NULL;
	}
	return;
}


/**************************************************************************
* readEepromIntoDataset - Read eeprom contents into structs held by LIB_DEV_INFO 
*
* 
*
* RETURNS: TRUE of OK, FALSE otherwise
*/
A_BOOL readEepromIntoDataset
(
 A_UINT32			devNum
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32			tempValue;
	A_UINT16			i, j, jj;
	A_UINT16			offset = 0;
	MDK_RD_EDGES_POWER		*pRdEdgePwrInfo = pLibDev->p16KRdEdgesPower;
	MDK_TRGT_POWER_INFO	    *pPowerInfo = NULL;
	A_UINT16			numChannels = 0;
	A_UINT16			mode;
	A_UINT16			*pNumTrgtChannels = NULL;
	A_UINT16			sizeCtl;
	EEPROM_DATA_STRUCT_GEN3 *pTempGen3CalData[3];

	//verify the checksum
	if (!eepromVerifyChecksum(devNum)) {
		mError(devNum, EIO, "Device Number %d: eeprom checksum failed\n", devNum);
		return FALSE;
	}

	//get the version information
	tempValue = eepromRead(devNum, HDR_VERSION);
	pLibDev->p16kEepHeader->majorVersion = (A_UINT16)((tempValue >> 12) & 0x0f);
	pLibDev->p16kEepHeader->minorVersion = (A_UINT16)(tempValue & 0x0fff);

	
	if((pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion <= 2)) {
		pOffsets = &eep3_2;
		pLibDev->p16kEepHeader->numCtl = NUM_CTL_EEP3_2;
	}
	else if(((pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion >= 3)) ||
			(pLibDev->p16kEepHeader->majorVersion == 4) )
	{
		pOffsets = &eep3_3;	
		pLibDev->p16kEepHeader->numCtl = NUM_CTL_EEP3_3;
	}
	else {
		mError(devNum, EIO, "Device Number %d:Device Number %d:eeprom version not supported\n", devNum);
		return (FALSE);
	}

	if (!(( pLibDev->p16kEepHeader->majorVersion > 3) || 
		( pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion >= 2)))
	{
		for (jj=0; jj<NUM_INTERCEPTS; jj++)
		{
			intercepts[jj] = intercepts_pre3p2[jj] ;
		}
	}
	

	//the channel list for 2.4 is fixed, fill this in here
	for(i = 0; i < NUM_2_4_EEPROM_CHANNELS; i++) {
		pLibDev->pCalibrationInfo->Channels_11b[i] = channels_11b[i];
		if((pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion <= 2)) {
			pLibDev->pCalibrationInfo->Channels_11g[i] = channels_11b[i];
		}
		else {
			pLibDev->pCalibrationInfo->Channels_11g[i] = channels_11g[i];
		}
		pLibDev->pCalibrationInfo->DataPerChannel_11b[i].numPcdacValues = NUM_PCDAC_VALUES;	
		pLibDev->pCalibrationInfo->DataPerChannel_11g[i].numPcdacValues = NUM_PCDAC_VALUES;	
	}

	//read the header information here
	readHeaderInfo(devNum, pLibDev->p16kEepHeader);

	if((pLibDev->p16kEepHeader->majorVersion == 3) ||
		((pLibDev->p16kEepHeader->majorVersion == 4) && (pLibDev->p16kEepHeader->eepMap == 0)))
	{
		if(!readCalData_gen2(devNum, pLibDev->pCalibrationInfo)) {
			return (FALSE);
		}
	}
	else if((pLibDev->p16kEepHeader->majorVersion == 4) && (pLibDev->p16kEepHeader->eepMap)) {
		if(!initialize_datasets(devNum, pTempGen3CalData, pLibDev->pGen3RawData)) {
			return (FALSE);
		}

		//read eeprom data into contiguous struct
		if(pLibDev->pGen3CalData == NULL) {
			pLibDev->pGen3CalData = (EEPROM_FULL_DATA_STRUCT_GEN3 *)malloc(sizeof(EEPROM_FULL_DATA_STRUCT_GEN3));
			if(NULL == pLibDev->pGen3CalData) {
				mError(devNum, ENOMEM, "Device Number %d:Device Number %d:Unable to allocate memory for full gen3 eeprom struct\n", devNum);
				return (FALSE);
			}

		}

		//copy in the data
		memset(pLibDev->pGen3CalData, 0, sizeof(EEPROM_FULL_DATA_STRUCT_GEN3));
		copyGen3EepromStruct(pLibDev->pGen3CalData, pTempGen3CalData);
		
		//#######TO DO would free pTempGen3CalData here

	}


	//read the power per rate info for test channels
	for(mode = 0; mode <= MAX_MODE; mode++) {
		switch(mode) {
		case MODE_11A:
			offset = pOffsets->GROUP5_11A_TRGT_PWR;
			if(pLibDev->p16kEepHeader->majorVersion == 4) {
				offset = pLibDev->p16kEepHeader->trgtPowerStartLocation;
			}
			numChannels = NUM_TEST_FREQUENCIES;
			pPowerInfo = pLibDev->p16KTrgtPowerInfo->trgtPwr_11a;
			pNumTrgtChannels = &(pLibDev->p16KTrgtPowerInfo->numTargetPwr_11a);
			break;

		case MODE_11G:
		case MODE_11O:
			offset = pOffsets->GROUP7_11G_TRGT_PWR;
			if(pLibDev->p16kEepHeader->majorVersion == 4) {
				offset = (A_UINT16)(pLibDev->p16kEepHeader->trgtPowerStartLocation + 0x14);
			}
			numChannels = 3;
			pPowerInfo = pLibDev->p16KTrgtPowerInfo->trgtPwr_11g;
			pNumTrgtChannels = &(pLibDev->p16KTrgtPowerInfo->numTargetPwr_11g);
			break;
		
		case MODE_11B:
			offset = pOffsets->GROUP6_11B_TRGT_PWR;
			if(pLibDev->p16kEepHeader->majorVersion == 4) {
				offset = (A_UINT16)(pLibDev->p16kEepHeader->trgtPowerStartLocation + 0x10);
			}
			numChannels = 2;
			pPowerInfo = pLibDev->p16KTrgtPowerInfo->trgtPwr_11b;
			pNumTrgtChannels = &(pLibDev->p16KTrgtPowerInfo->numTargetPwr_11b);
			break;
		default:
			mError(devNum, EIO, "Device Number %d:Device Number %d:Bad mode in readEepromIntoDataset, internal software error, should not get here\n", devNum);
			return(FALSE);
		} //end switch

		*pNumTrgtChannels = 0;
		for(i = 0; i < numChannels; i++) {
			if(readTrgtPowers(devNum, offset, pPowerInfo, mode)) {
				(*pNumTrgtChannels)++;
			}
			pPowerInfo++;
			offset+=2;
		}

	}
	
	//read the CTL edge power limits
	
	i = 0;
	offset = pOffsets->GROUP8_CTL_INFO;
	if(pLibDev->p16kEepHeader->majorVersion == 4) {
		offset = (A_UINT16)(pLibDev->p16kEepHeader->trgtPowerStartLocation + 0x1a);
	}
	while ((pLibDev->p16kEepHeader->testGroups[i] != 0) && (i < pLibDev->p16kEepHeader->numCtl)) {
		sizeCtl = readCtlInfo(devNum, offset, pRdEdgePwrInfo);
		
		for(j = 0; j < NUM_16K_EDGES; j++ ) {
			if ((pRdEdgePwrInfo[j].rdEdge==0) && (pRdEdgePwrInfo[j].twice_rdEdgePower==0))
			{
				pRdEdgePwrInfo[j].rdEdge = 0; // if not all rdedges were specified for this CTL
			} else
			{
				if(((pLibDev->p16kEepHeader->testGroups[i] & 0x3) == 0) ||
					((pLibDev->p16kEepHeader->testGroups[i] & 0x3) == 0x3)  ){ //turbo mode
				
					pRdEdgePwrInfo[j].rdEdge = fbin2freq(devNum, pRdEdgePwrInfo[j].rdEdge);
				}
				else {
					pRdEdgePwrInfo[j].rdEdge = fbin2freq_2p4(devNum, pRdEdgePwrInfo[j].rdEdge);
				}
			}
		}
		i++;
		offset = (A_UINT16)(offset + sizeCtl);
		pRdEdgePwrInfo+=NUM_16K_EDGES;
	}
	  
	return TRUE;
}
// only searches for integer values in integer lists. used for channel and pcdac lists
void iGetLowerUpperValues 
(
 A_UINT16	value,			//value to search for
 A_UINT16	*pList,			//ptr to the list to search
 A_UINT16	listSize,		//number of entries in list
 A_UINT16	*pLowerValue,	//return the lower value
 A_UINT16	*pUpperValue	//return the upper value	
)
{
	A_UINT16	i;
	A_UINT16	listEndValue = *(pList + listSize - 1);
	A_UINT16	target = value ;

	//see if value is lower than the first value in the list
	//if so return first value
	if (target <= (*pList)) {
		*pLowerValue = *pList;
		*pUpperValue = *pList;
		return;
	}
  
	//see if value is greater than last value in list
	//if so return last value
	if (target >= listEndValue) {
		*pLowerValue = listEndValue;
		*pUpperValue = listEndValue;
		return;
	}

	//look for value being near or between 2 values in list
	for(i = 0; i < listSize; i++) {
		//if value is close to the current value of the list 
		//then target is not between values, it is one of the values
		if (pList[i] == target) {
			*pLowerValue = pList[i];
			*pUpperValue = pList[i];
			return;
		}

		//look for value being between current value and next value
		//if so return these 2 values
		if (target < pList[i + 1]) {
			*pLowerValue = pList[i];
			*pUpperValue = pList[i + 1];
			return;
		}
	}
} 

/**************************************************************************
* readHeaderInfo - Read eeprom header info
*
* RETURNS: 
*/
void  readHeaderInfo
(
 A_UINT32			devNum,
 MDK_EEP_HEADER_INFO	*pHeaderInfo		//ptr to header struct to fill
)
{
	A_UINT32		tempValue;
	A_UINT16		offset;
	A_UINT16        i;
	MODE_HEADER_INFO	*pModeInfo;
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];


	tempValue = eepromRead(devNum, pOffsets->HDR_COUNTRY_CODE);
	pHeaderInfo->countryRegCode = (A_UINT16)(tempValue);

	if(((pHeaderInfo->majorVersion == 3) && (pHeaderInfo->minorVersion >= 2)) 
			|| (pHeaderInfo->majorVersion == 4)){
		pHeaderInfo->countryRegCode = (A_UINT16)(pHeaderInfo->countryRegCode & 0xfff);
		pHeaderInfo->countryCodeFlag = (A_UINT16)((tempValue >> 15) & 0x01);

	if(((pHeaderInfo->majorVersion == 3) && (pHeaderInfo->minorVersion >= 3)) 
			|| (pHeaderInfo->majorVersion == 4)){
			pHeaderInfo->worldwideRoaming = (A_UINT16)((tempValue >> 14) & 0x01);
		}
	}
	else {
		pHeaderInfo->countryCodeFlag = 1;
	}