meeprom_d.c

atheros ar5001 5002 driver

	}

	mdk_GetLowerUppderIndex(channel, &(pRawDataset->pChannels[0]), pRawDataset->numChannels, &(chan_idx_L), &(chan_idx_R));

	kk = 0;
	for (ii=chan_idx_L; ii<=chan_idx_R; ii++) {
		pRawCh = &(pRawDataset->pDataPerChannel[ii]);
		if (xgain_list[1] == 0xDEAD) {
			jj = xgain_list[0];
			numPcd = pRawCh->pDataPerXPD[jj].numPcdacs;
			memcpy(&(pcdacs[0]), &(pRawCh->pDataPerXPD[jj].pcdac[0]), numPcd*sizeof(A_UINT16));
			memcpy(&(powers[0]), &(pRawCh->pDataPerXPD[jj].pwr_t4[0]), numPcd*sizeof(A_INT16));
			if (!mdk_getFullPwrTable(devNum, numPcd, &(pcdacs[0]), &(powers[0]), pRawCh->maxPower_t4, &(tmpPowerTable[0]))) {
				return(FALSE);
			} else {
				memcpy(&(powTableLXPD[kk][0]), &(tmpPowerTable[0]), 64*sizeof(A_INT16));
			}
		} else {
			jj = xgain_list[0];
			numPcd = pRawCh->pDataPerXPD[jj].numPcdacs;
			memcpy(&(pcdacs[0]), &(pRawCh->pDataPerXPD[jj].pcdac[0]), numPcd*sizeof(A_UINT16));
			memcpy(&(powers[0]), &(pRawCh->pDataPerXPD[jj].pwr_t4[0]), numPcd*sizeof(A_INT16));
			if (!mdk_getFullPwrTable(devNum, numPcd, &(pcdacs[0]), &(powers[0]), pRawCh->maxPower_t4, &(tmpPowerTable[0]))) {
				return(FALSE);
			} else {
				memcpy(&(powTableLXPD[kk][0]), &(tmpPowerTable[0]), 64*sizeof(A_INT16));
			}

			jj = xgain_list[1];
			numPcd = pRawCh->pDataPerXPD[jj].numPcdacs;
			memcpy(&(pcdacs[0]), &(pRawCh->pDataPerXPD[jj].pcdac[0]), numPcd*sizeof(A_UINT16));
			memcpy(&(powers[0]), &(pRawCh->pDataPerXPD[jj].pwr_t4[0]), numPcd*sizeof(A_INT16));
			if (!mdk_getFullPwrTable(devNum, numPcd, &(pcdacs[0]), &(powers[0]), pRawCh->maxPower_t4, &(tmpPowerTable[0]))) {
				return(FALSE);
			} else {
				memcpy(&(powTableHXPD[kk][0]), &(tmpPowerTable[0]), 64*sizeof(A_INT16));
			}
		}
			
		kk++;
	}
	
	chan_L = pRawDataset->pChannels[chan_idx_L];
	chan_R = pRawDataset->pChannels[chan_idx_R];
	kk = chan_idx_R - chan_idx_L;

	if (xgain_list[1] == 0xDEAD) {
		for (jj=0; jj<64; jj++) {
			pwr_table0[jj] = mdk_GetInterpolatedValue_Signed16(channel, chan_L, chan_R, powTableLXPD[0][jj], powTableLXPD[kk][jj]);			
		}
		Pmin = getPminAndPcdacTableFromPowerTable(&(pwr_table0[0]), pPCDACValues);
		*pPowerMin = (A_INT16) (Pmin / 2);
		*pPowerMid = (A_INT16) (pwr_table0[63] / 2);
		*pPowerMax = (A_INT16) (pwr_table0[63] / 2);
		pXpdGainValues[0] = xgain_list[0];
		pXpdGainValues[1] = pXpdGainValues[0];
	} else {
		for (jj=0; jj<64; jj++) {
			pwr_table0[jj] = mdk_GetInterpolatedValue_Signed16(channel, chan_L, chan_R, powTableLXPD[0][jj], powTableLXPD[kk][jj]);			
			pwr_table1[jj] = mdk_GetInterpolatedValue_Signed16(channel, chan_L, chan_R, powTableHXPD[0][jj], powTableHXPD[kk][jj]);			
		}
		if (numXpdGain == 2) {
	    	Pmin = getPminAndPcdacTableFromTwoPowerTables(&(pwr_table0[0]), &(pwr_table1[0]), pPCDACValues, &Pmid);
			*pPowerMin = (A_INT16) (Pmin / 2);
			*pPowerMid = (A_INT16) (Pmid / 2);
			*pPowerMax = (A_INT16) (pwr_table0[63] / 2);
			pXpdGainValues[0] = xgain_list[0];
			pXpdGainValues[1] = xgain_list[1];
		} else {
			if ( (minPwr_t4  <= pwr_table1[63]) && (maxPwr_t4  <= pwr_table1[63])) {
				Pmin = getPminAndPcdacTableFromPowerTable(&(pwr_table1[0]), pPCDACValues);
				pXpdGainValues[0] = xgain_list[1];
				pXpdGainValues[1] = pXpdGainValues[0];
				*pPowerMin = (A_INT16) (Pmin / 2);
				*pPowerMid = (A_INT16) (pwr_table1[63] / 2);
				*pPowerMax = (A_INT16) (pwr_table1[63] / 2);
			} else {
				Pmin = getPminAndPcdacTableFromPowerTable(&(pwr_table0[0]), pPCDACValues);
				pXpdGainValues[0] = xgain_list[0];
				pXpdGainValues[1] = xgain_list[0];
				*pPowerMin = (A_INT16) (Pmin/2);
				*pPowerMid = (A_INT16) (pwr_table0[63] / 2);
				*pPowerMax = (A_INT16) (pwr_table0[63] / 2);
			}
		}
	}

	devNum = 0;   //quiet compiler

    return(TRUE);
}
	

A_INT16 mdk_GetInterpolatedValue_Signed16(A_UINT16 target, A_UINT16 srcLeft, A_UINT16 srcRight, 
							 A_INT16 targetLeft, A_INT16 targetRight)
{
  A_INT16 returnValue;

  if (srcRight != srcLeft) {
		returnValue = (A_INT16)( ( (target - srcLeft)*targetRight + (srcRight - target)*targetLeft)/(srcRight - srcLeft));
  } 
  else {
		returnValue = targetLeft;
  }
  return (returnValue);
}


// returns indices surrounding the value in sorted integer lists. used for channel and pcdac lists
void mdk_GetLowerUppderIndex (
 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_UINT32	*pLowerValue,	//return the lower value
 A_UINT32	*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 = 0;
		*pUpperValue = 0;
		return;
	}
  
	//see if value is greater than last value in list
	//if so return last value
	if (target >= listEndValue) {
		*pLowerValue = listSize - 1;
		*pUpperValue = listSize - 1;
		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 = i;
			*pUpperValue = i;
			return;
		}

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

A_UINT16 fbin2freq_gen3(A_UINT32 fbin, A_UINT32 mode)
{
	A_UINT16 returnValue; 

	if(mode == MODE_11A) {
		returnValue = (A_UINT16)(4800 + 5*fbin);
	}
	else {
		returnValue = (A_UINT16)(2300 + fbin);
	}
	return returnValue;
}

A_BOOL initialize_datasets(A_UINT32 devNum, EEPROM_DATA_STRUCT_GEN3 *pCalDataset_gen3[], RAW_DATA_STRUCT_GEN3  *pRawDataset_gen3[]) {

	A_UINT32	words[400];
	A_UINT16	start_offset		= 0x150; // for 16k eeprom (0x2BE - 0x150) = 367
	A_UINT32	maxPiers;
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];

	eepromReadBlock(devNum, start_offset, 367, words);



	// setup datasets for mode_11a first
	start_offset = 0;

	if (pLibDev->p16kEepHeader->Amode) {
		maxPiers = NUM_11A_EEPROM_CHANNELS;
	
		pCalDataset_gen3[MODE_11A] = (EEPROM_DATA_STRUCT_GEN3 *)malloc(sizeof(EEPROM_DATA_STRUCT_GEN3));
		if(NULL == pCalDataset_gen3[MODE_11A]) {
			mError(devNum, ENOMEM, "unable to allocate 11a gen3 cal data struct\n");
			return(0);
		}
		if (!read_Cal_Dataset_From_EEPROM(devNum, pCalDataset_gen3[MODE_11A], start_offset, maxPiers,  &(words[0]), MODE_11A ) ) {
			mError(devNum, EIO,"unable to allocate cal dataset (gen3) for mode 11a\n");
			return(0);
		}
		pCalDataset_gen3[MODE_11A]->xpd_mask = pLibDev->p16kEepHeader->info11a.xgain;
		pRawDataset_gen3[MODE_11A] = (RAW_DATA_STRUCT_GEN3 *)malloc(sizeof(RAW_DATA_STRUCT_GEN3));
		if(NULL == pRawDataset_gen3[MODE_11A]) {
			mError(devNum, ENOMEM, "unable to allocate 11a gen3 raw data struct\n");
			return(0);
		}
		setup_raw_dataset_gen3(devNum, pRawDataset_gen3[MODE_11A], pCalDataset_gen3[MODE_11A]->numChannels, pCalDataset_gen3[MODE_11A]->pChannels);
		eeprom_to_raw_dataset_gen3(devNum, pCalDataset_gen3[MODE_11A], pRawDataset_gen3[MODE_11A]);


		// setup datasets for mode_11b next
		start_offset = (A_UINT16)(5 + pCalDataset_gen3[MODE_11A]->numChannels*5 );
	} else {
		pRawDataset_gen3[MODE_11A] = NULL;
		pCalDataset_gen3[MODE_11A] = NULL;
	}

	if (pLibDev->p16kEepHeader->Bmode) {
		maxPiers = NUM_2_4_EEPROM_CHANNELS;

		pCalDataset_gen3[MODE_11B] = (EEPROM_DATA_STRUCT_GEN3 *)malloc(sizeof(EEPROM_DATA_STRUCT_GEN3));
		if(NULL == pCalDataset_gen3[MODE_11B]) {
			mError(devNum, ENOMEM, "unable to allocate 11b gen3 cal data struct\n");
			return(0);
		}
		if (!read_Cal_Dataset_From_EEPROM(devNum, pCalDataset_gen3[MODE_11B], start_offset, maxPiers,  &(words[0]), MODE_11B ) ) {
			mError(devNum, EIO,"unable to allocate cal dataset (gen3) for mode 11b\n");
			return(0);
		}
		pCalDataset_gen3[MODE_11B]->xpd_mask = pLibDev->p16kEepHeader->info11b.xgain;
		pRawDataset_gen3[MODE_11B] = (RAW_DATA_STRUCT_GEN3 *)malloc(sizeof(RAW_DATA_STRUCT_GEN3));
		if(NULL == pRawDataset_gen3[MODE_11B]) {
			mError(devNum, ENOMEM, "unable to allocate 11b gen3 raw data struct\n");
			return(0);
		}
		setup_raw_dataset_gen3(devNum, pRawDataset_gen3[MODE_11B], pCalDataset_gen3[MODE_11B]->numChannels, pCalDataset_gen3[MODE_11B]->pChannels);
		eeprom_to_raw_dataset_gen3(devNum, pCalDataset_gen3[MODE_11B], pRawDataset_gen3[MODE_11B]);

		// setup datasets for mode_11g next
		start_offset = (A_UINT16) (start_offset + pCalDataset_gen3[MODE_11B]->numChannels*5);
	} else {
		pRawDataset_gen3[MODE_11B] = NULL;
		pCalDataset_gen3[MODE_11B] = NULL;
	}

	if (pLibDev->p16kEepHeader->Gmode) {
		maxPiers = NUM_2_4_EEPROM_CHANNELS;
		pCalDataset_gen3[MODE_11G] = (EEPROM_DATA_STRUCT_GEN3 *)malloc(sizeof(EEPROM_DATA_STRUCT_GEN3));
		if(NULL == pCalDataset_gen3[MODE_11G]) {
			mError(devNum, ENOMEM, "unable to allocate 11g gen3 cal data struct\n");
			return(0);
		}
		if (!read_Cal_Dataset_From_EEPROM(devNum, pCalDataset_gen3[MODE_11G], start_offset, maxPiers,  &(words[0]), MODE_11G ) ) {
			mError(devNum, EIO,"unable to allocate cal dataset (gen3) for mode 11g\n");
			return(0);
		}
		pCalDataset_gen3[MODE_11G]->xpd_mask = pLibDev->p16kEepHeader->info11g.xgain;
		pRawDataset_gen3[MODE_11G] = (RAW_DATA_STRUCT_GEN3 *)malloc(sizeof(RAW_DATA_STRUCT_GEN3));
		if(NULL == pRawDataset_gen3[MODE_11G]) {
			mError(devNum, ENOMEM, "unable to allocate 11g gen3 raw data struct\n");
			return(0);
		}
		setup_raw_dataset_gen3(devNum, pRawDataset_gen3[MODE_11G], pCalDataset_gen3[MODE_11G]->numChannels, pCalDataset_gen3[MODE_11G]->pChannels);
		eeprom_to_raw_dataset_gen3(devNum, pCalDataset_gen3[MODE_11G], pRawDataset_gen3[MODE_11G]);
	} else {
		pRawDataset_gen3[MODE_11G] = NULL;
		pCalDataset_gen3[MODE_11G] = NULL;
	}

	// REMEMBER TO FREE THE CAL DATASETS HERE

	return(1);
}

A_BOOL mdk_getFullPwrTable(A_UINT32 devNum, A_UINT16 numPcdacs, A_UINT16 *pcdacs, A_INT16 *power, A_INT16 maxPower, A_INT16 *retVals) {

	A_UINT16	ii;
	A_UINT16	idxL = 0;
	A_UINT16	idxR = 1;

	if (numPcdacs < 2) {
		mError(devNum, EINVAL, "at least 2 pcdac values needed in mdk_getFullPwrTable - [%d]\n", numPcdacs);
		return(FALSE);
	}

	for (ii=0; ii<64; ii++) {
		if ((ii>pcdacs[idxR]) && (idxR < (numPcdacs-1))) {
			idxL++;
			idxR++;
		}
		retVals[ii] = mdk_GetInterpolatedValue_Signed16(ii, pcdacs[idxL], pcdacs[idxR], power[idxL], power[idxR]);
		if (retVals[ii] >= maxPower) {
			while (ii<64) {
				retVals[ii++] = maxPower;
			}
		}
	}
	return(TRUE);
}


A_INT16 getPminAndPcdacTableFromPowerTable(A_INT16 *pwrTable_t4, A_UINT16 retVals[]) {
	A_INT16	ii, jj, jj_max;
	A_INT16		Pmin, currPower, Pmax;
	
	// if the spread is > 31.5dB, keep the upper 31.5dB range
	if ((pwrTable_t4[63] - pwrTable_t4[0]) > 126) {
		Pmin = (A_INT16) (pwrTable_t4[63] - 126);
	} else {
		Pmin = pwrTable_t4[0];
	}

/*
	if (Pmin >= 0) {
		Pmin = 0;
	}
*/

	Pmax = pwrTable_t4[63];
	jj_max = 63;
	// search for highest pcdac 0.25dB below maxPower
	while ((pwrTable_t4[jj_max] > (Pmax - 1) ) && (jj_max >= 0)){
		jj_max--;
	} 


	jj = jj_max;
	currPower = Pmax;
	for (ii=63; ii>=0; ii--) {
		while ((jj<64) && (jj>0) && (pwrTable_t4[jj] >= currPower)) {
			jj--;
		}
		if (jj == 0) {
			while (ii >= 0) {
				retVals[ii] = retVals[ii+1];
				ii--;
			}
			break;
		}
		retVals[ii] = jj;
		currPower -= 2;  // corresponds to a 0.5dB step
	}
	return(Pmin);
}

A_INT16 getPminAndPcdacTableFromTwoPowerTables(A_INT16 *pwrTableLXPD_t4, A_INT16 *pwrTableHXPD_t4, A_UINT16 retVals[], A_INT16 *Pmid) {
	A_INT16		ii, jj, jj_max;
	A_INT16		Pmin, currPower, Pmax;
	A_INT16		*pwrTable_t4;
	A_UINT16	msbFlag = 0x40;  // turns on the 7th bit of the pcdac
	
	// if the spread is > 31.5dB, keep the upper 31.5dB range
	if ((pwrTableLXPD_t4[63] - pwrTableHXPD_t4[0]) > 126) {
		Pmin = (A_INT16)(pwrTableLXPD_t4[63] - 126);		
	} else {
		Pmin = pwrTableHXPD_t4[0];
	}

/*
	if (Pmin >= 0) {
		Pmin = 0;
	}
*/
	Pmax = pwrTableLXPD_t4[63];
	jj_max = 63;
	// search for highest pcdac 0.25dB below maxPower
	while ((pwrTableLXPD_t4[jj_max] > (Pmax - 1) ) && (jj_max >= 0)){
		jj_max--;
	} 


	*Pmid = pwrTableHXPD_t4[63];
	jj = jj_max;
	ii = 63;
	currPower = Pmax;
	pwrTable_t4 = &(pwrTableLXPD_t4[0]);
	while(ii >= 0) {
		if ((currPower <= *Pmid) || ( (jj == 0) && (msbFlag == 0x40))){
			msbFlag = 0x00;
			pwrTable_t4 = &(pwrTableHXPD_t4[0]);
			jj = 63;
		}
		while ((jj>0) && (pwrTable_t4[jj] >= currPower)) {
			jj--;
		}
		if ((jj == 0) && (msbFlag == 0x00)) {
			while (ii >= 0) {
				retVals[ii] = retVals[ii+1];
				ii--;
			}
			break;
		}
		retVals[ii] = (A_UINT16)(jj | msbFlag);
		currPower -= 2;  // corresponds to a 0.5dB step
		ii--;
	}
	return(Pmin);
}


void
copyGen3EepromStruct
(
 EEPROM_FULL_DATA_STRUCT_GEN3 *pFullCalDataset_gen3,
 EEPROM_DATA_STRUCT_GEN3 *pCalDataset_gen3[]
)
{
	if (pCalDataset_gen3[MODE_11A] != NULL) {
		//copy the 11a structs
		pFullCalDataset_gen3->numChannels11a = pCalDataset_gen3[MODE_11A]->numChannels;
		pFullCalDataset_gen3->xpd_mask11a = pCalDataset_gen3[MODE_11A]->xpd_mask;
		memcpy(pFullCalDataset_gen3->pDataPerChannel11a, pCalDataset_gen3[MODE_11A]->pDataPerChannel, 
			sizeof(EEPROM_DATA_PER_CHANNEL_GEN3) * pCalDataset_gen3[MODE_11A]->numChannels);
	}

	if (pCalDataset_gen3[MODE_11B] != NULL) {
		//copy the 11b structs
		pFullCalDataset_gen3->numChannels11b = pCalDataset_gen3[MODE_11B]->numChannels;
		pFullCalDataset_gen3->xpd_mask11b = pCalDataset_gen3[MODE_11B]->xpd_mask;
		memcpy(pFullCalDataset_gen3->pDataPerChannel11b, pCalDataset_gen3[MODE_11B]->pDataPerChannel, 
			sizeof(EEPROM_DATA_PER_CHANNEL_GEN3) * pCalDataset_gen3[MODE_11B]->numChannels);
	}

	if (pCalDataset_gen3[MODE_11G] != NULL) {
		//copy the 11g structs
		pFullCalDataset_gen3->numChannels11g = pCalDataset_gen3[MODE_11G]->numChannels;
		pFullCalDataset_gen3->xpd_mask11g = pCalDataset_gen3[MODE_11G]->xpd_mask;
		memcpy(pFullCalDataset_gen3->pDataPerChannel11g, pCalDataset_gen3[MODE_11G]->pDataPerChannel, 
			sizeof(EEPROM_DATA_PER_CHANNEL_GEN3) * pCalDataset_gen3[MODE_11G]->numChannels);
	}
}