meeprom_g.c

Atheros AP Test with Agilent N4010A source code

	}

	ii = (A_UINT16) maxPiers; // to quiet compiler warnings
	return(1);
}



void eeprom_to_raw_dataset_gen5(A_UINT32 devNum, EEPROM_DATA_STRUCT_GEN5 *pCalDataset, RAW_DATA_STRUCT_GEN5 *pRawDataset) {

	A_UINT16	ii, jj, kk, ss;
	RAW_DATA_PER_PDGAIN_GEN5			*pRawXPD;
	EEPROM_DATA_PER_CHANNEL_GEN5	*pCalCh;	//ptr to array of info held per channel
	A_UINT16		xgain_list[MAX_NUM_PDGAINS_PER_CHANNEL];
	A_UINT16		xpd_mask;
	A_UINT32        numPdGainsUsed = 0;

	if (pRawDataset->xpd_mask != pCalDataset->xpd_mask) {
		mError(devNum, EIO,"xpd_mask values incompatible between raw and eeprom datasets\n");
		exit(0);
	}

	xgain_list[0] = 0xDEAD;
	xgain_list[1] = 0xDEAD;
	xgain_list[2] = 0xDEAD;
	xgain_list[3] = 0xDEAD;
 
	kk = 0;
	xpd_mask = pRawDataset->xpd_mask;

	for (jj = 0; jj < MAX_NUM_PDGAINS_PER_CHANNEL; jj++) {
		if (((xpd_mask >> (MAX_NUM_PDGAINS_PER_CHANNEL-jj-1)) & 1) > 0) {
			if (kk >= MAX_NUM_PDGAINS_PER_CHANNEL) {
				printf("A maximum of 4 pd_gains supported in eep_to_raw_data for gen5\n");
				exit(0);
			}
			xgain_list[kk++] = (A_UINT16) (MAX_NUM_PDGAINS_PER_CHANNEL-jj-1);			
		}
	}

	numPdGainsUsed = kk;

	pRawDataset->numChannels = pCalDataset->numChannels;
	for (ii = 0; ii < pRawDataset->numChannels; ii++) {
		pCalCh = &(pCalDataset->pDataPerChannel[ii]);
		pRawDataset->pDataPerChannel[ii].channelValue = pCalCh->channelValue;
//		pRawDataset->pDataPerChannel[ii].maxPower_t4  = pCalCh->maxPower_t4;
//		maxPower_t4 = pRawDataset->pDataPerChannel[ii].maxPower_t4;


		// numVpd has already been setup appropriately for the relevant pdGains

//printf("SNOOP: channel = %d\n", pCalCh->channelValue);
		for (jj = 0; jj<numPdGainsUsed; jj++) {
			ss = xgain_list[jj];  // use jj for calDataset and ss for rawDataset
			pRawXPD = &(pRawDataset->pDataPerChannel[ii].pDataPerPDGain[ss]);
			if (pRawXPD->numVpd < 1) {
				printf("ERROR : numVpd for ch[%d] = %d, pdgain = %d[%d] should not be 0 for xpd_mask = 0x%x\n", ii, 
					                  pCalCh->channelValue, ss, jj, xpd_mask);
				exit(0);
			}
				
			pRawXPD->pwr_t4[0] = (A_INT16)(4*pCalCh->pwr_I[jj]);
			pRawXPD->Vpd[0]    = pCalCh->Vpd_I[jj];
//printf("SNOOP: ss=%d, Vpd[0] = %d, pwr[0] = %d\n", ss, pRawXPD->Vpd[0], pRawXPD->pwr_t4[0]);
			for (kk = 1; kk < pRawXPD->numVpd; kk++) {
				pRawXPD->pwr_t4[kk] = (A_INT16)(pRawXPD->pwr_t4[kk-1] + 2*pCalCh->pwr_delta_t2[kk-1][jj]);
				pRawXPD->Vpd[kk] = (A_UINT16)(pRawXPD->Vpd[kk-1] + pCalCh->Vpd_delta[kk-1][jj]);
//printf("SNOOP: ss=%d, Vpd[%d] = %d, pwr[%d] = %d\n", ss, kk, pRawXPD->Vpd[kk], kk, pRawXPD->pwr_t4[kk]);
			} // loop over Vpds

		} // loop over pd_gains
	} // loop over channels
	devNum = 0;  //quiet warnings
}


/*
A_BOOL get_xpd_gain_and_pcdacs_for_powers
(
 A_UINT32				devNum,                         // In
 A_UINT16				channel,                         // In       
 RAW_DATA_STRUCT_GEN5	*pRawDataset,					// In
 A_UINT32				numXpdGain,                      // In
 A_UINT32				xpdGainMask,                      // In     - desired xpd_gain
 A_INT16				*pPowerMin,                      // In/Out	(2 x power)
 A_INT16				*pPowerMax,                      // In/Out	(2 x power)
 A_INT16				*pPowerMid,                      // Out		(2 x power)
 A_UINT16				pXpdGainValues[],               // Out
 A_UINT16				pPCDACValues[]                  // Out 
)
{
	A_UINT32	ii, jj, kk;
	A_INT16		minPwr_t4, maxPwr_t4, Pmin, Pmid;

	A_UINT32	chan_idx_L, chan_idx_R;
	A_UINT16	chan_L, chan_R;
	
	A_INT16		pwr_table0[64];
	A_INT16		pwr_table1[64];
	RAW_DATA_PER_CHANNEL_GEN5	*pRawCh;	
	A_UINT16	pcdacs[10];
	A_INT16		powers[10];
	A_UINT16	numPcd;
	A_INT16		powTableLXPD[2][64];
	A_INT16		powTableHXPD[2][64];
	A_INT16		tmpPowerTable[64];
	A_UINT16		xgain_list[2];
	A_UINT16		xpd_mask;
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	
	if (pRawDataset == NULL) {
		mError(devNum, EINVAL,"NULL dataset pointer. This mode may not be supported.\n");
		return(FALSE);
	}
	
	if ((xpdGainMask & pRawDataset->xpd_mask) < 1) {
		mError(devNum, EINVAL,"desired xpdGainMask not supported by calibrated xpd_mask\n");
		return(FALSE);
	}

	maxPwr_t4 = (A_INT16)(2*(*pPowerMax));   // pwr_t2 -> pwr_t4
	minPwr_t4 = (A_INT16)(2*(*pPowerMin));	  // pwr_t2 -> pwr_t4



	xgain_list[0] = 0xDEAD;
	xgain_list[1] = 0xDEAD;
 
	kk = 0;
	xpd_mask = pRawDataset->xpd_mask;

	for (jj = 0; jj < MAX_NUM_PDGAINS_PER_CHANNEL; jj++) {
		if (((xpd_mask >> jj) & 1) > 0) {
			if (kk > 1) {
				printf("A maximum of 2 xpd_gains supported in eep_to_raw_data\n");
				exit(0);
			}
			xgain_list[kk++] = (A_UINT16) jj;			
		}
	}

	mdk_GetLowerUpperIndex(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;

	pLibDev->maxLinPwrx4 = mdk_GetInterpolatedValue_Signed16(channel, chan_L, chan_R, 
										pRawDataset->pDataPerChannel[chan_idx_L].pDataPerXPD[0].pwr_t4[2],
										pRawDataset->pDataPerChannel[chan_idx_R].pDataPerXPD[0].pwr_t4[2]);

	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_GetLowerUpperIndex_Signed16 (
 A_INT16	value,			//value to search for
 A_INT16	*pList,			//ptr to the list to search
 A_UINT16	listSize,		//number of entries in list
 A_UINT32	*pLowerValue,	//return the lower index
 A_UINT32	*pUpperValue	//return the upper index	
)
{
	A_UINT16	i;
	A_INT16	listEndValue = *(pList + listSize - 1);
	A_INT16	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_BOOL initialize_datasets_gen5(A_UINT32 devNum, EEPROM_DATA_STRUCT_GEN5 *pCalDataset_gen5[], RAW_DATA_STRUCT_GEN5  *pRawDataset_gen5[]) {

	A_UINT32	words[400];
	A_UINT16	start_offset		= 0x150; // for 16k eeprom (0x2BE - 0x150) = 367. 0x2BE is the max possible end of CTL section.
												//add 10 to ignore dummy data written for driver
	A_UINT32	maxPiers;
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT16    numEEPROMWordsPerChannel;
	A_UINT16    wordsForPdgains[] = {4,6,9,12}; // index is 1 less than numPdgains

//printf("SNOOP: initialize_datasets_gen5 : entered [%d, %d]\n", MODE_11B, MODE_11G);
	// read only upto the end of CTL section
	// 0x2BE is the max possible end of CTL section.
	// for 16k eeprom (0x2BE - 0x150) = 367. 
	start_offset = pLibDev->p16kEepHeader->calStartLocation;
	eepromReadBlock(devNum, (start_offset + pLibDev->eepromStartLoc), 367, words);


	// setup datasets for mode_11b first
	start_offset = 0;

	if (pLibDev->p16kEepHeader->Amode) {
		maxPiers = NUM_11A_EEPROM_CHANNELS;
		pCalDataset_gen5[MODE_11A] = (EEPROM_DATA_STRUCT_GEN5 *)malloc(sizeof(EEPROM_DATA_STRUCT_GEN5));
		if(NULL == pCalDataset_gen5[MODE_11A]) {
			mError(devNum, ENOMEM, "unable to allocate 11a gen5 cal data struct\n");
			return(0);
		}
		pCalDataset_gen5[MODE_11A]->xpd_mask = pLibDev->p16kEepHeader->info11a.xgain;
		if (!read_Cal_Dataset_From_EEPROM_gen5(devNum, pCalDataset_gen5[MODE_11A], start_offset, maxPiers,  &(words[0]), MODE_11A ) ) {
			mError(devNum, EIO,"unable to allocate cal dataset (gen5) for mode 11a\n");
			return(0);
		}		
		pRawDataset_gen5[MODE_11A] = (RAW_DATA_STRUCT_GEN5 *)malloc(sizeof(RAW_DATA_STRUCT_GEN5));
		if(NULL == pRawDataset_gen5[MODE_11A]) {
			mError(devNum, ENOMEM, "unable to allocate 11a gen5 raw data struct\n");
			return(0);
		}
		pRawDataset_gen5[MODE_11A]->xpd_mask = pLibDev->p16kEepHeader->info11a.xgain;
		setup_raw_dataset_gen5(devNum, pRawDataset_gen5[MODE_11A], pCalDataset_gen5[MODE_11A]->numChannels, pCalDataset_gen5[MODE_11A]->pChannels);
		eeprom_to_raw_dataset_gen5(devNum, pCalDataset_gen5[MODE_11A], pRawDataset_gen5[MODE_11A]);

		// setup datasets for mode_11b next
		numEEPROMWordsPerChannel = wordsForPdgains[pCalDataset_gen5[MODE_11A]->pDataPerChannel[0].numPdGains - 1];
	    start_offset = (A_UINT16) (start_offset + pCalDataset_gen5[MODE_11A]->numChannels*numEEPROMWordsPerChannel + 5);
	} else {
		pRawDataset_gen5[MODE_11A] = NULL;
		pCalDataset_gen5[MODE_11A] = NULL;
	}

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

		pCalDataset_gen5[MODE_11B] = (EEPROM_DATA_STRUCT_GEN5 *)malloc(sizeof(EEPROM_DATA_STRUCT_GEN5));
		if(NULL == pCalDataset_gen5[MODE_11B]) {
			mError(devNum, ENOMEM, "unable to allocate 11b gen5 cal data struct\n");
			return(0);
		}
		pCalDataset_gen5[MODE_11B]->xpd_mask = pLibDev->p16kEepHeader->info11b.xgain;
		if (!read_Cal_Dataset_From_EEPROM_gen5(devNum, pCalDataset_gen5[MODE_11B], start_offset, maxPiers,  &(words[0]), MODE_11B ) ) {
			mError(devNum, EIO,"unable to allocate cal dataset (gen5) for mode 11b\n");
			return(0);
		}
		pRawDataset_gen5[MODE_11B] = (RAW_DATA_STRUCT_GEN5 *)malloc(sizeof(RAW_DATA_STRUCT_GEN5));
		if(NULL == pRawDataset_gen5[MODE_11B]) {
			mError(devNum, ENOMEM, "unable to allocate 11b gen5 raw data struct\n");
			return(0);
		}
		
		pRawDataset_gen5[MODE_11B]->xpd_mask = pLibDev->p16kEepHeader->info11b.xgain;
		setup_raw_dataset_gen5(devNum, pRawDataset_gen5[MODE_11B], pCalDataset_gen5[MODE_11B]->numChannels, pCalDataset_gen5[MODE_11B]->pChannels);
		eeprom_to_raw_dataset_gen5(devNum, pCalDataset_gen5[MODE_11B], pRawDataset_gen5[MODE_11B]);

		// setup datasets for mode_11g next
		numEEPROMWordsPerChannel = wordsForPdgains[pCalDataset_gen5[MODE_11B]->pDataPerChannel[0].numPdGains - 1];
		start_offset = (A_UINT16) (start_offset + pCalDataset_gen5[MODE_11B]->numChannels*numEEPROMWordsPerChannel + 2);
	} else {
		pRawDataset_gen5[MODE_11B] = NULL;
		pCalDataset_gen5[MODE_11B] = NULL;
	}

	if (pLibDev->p16kEepHeader->Gmode) {
		maxPiers = NUM_2_4_EEPROM_CHANNELS_GEN5;
		pCalDataset_gen5[MODE_11G] = (EEPROM_DATA_STRUCT_GEN5 *)malloc(sizeof(EEPROM_DATA_STRUCT_GEN5));
		if(NULL == pCalDataset_gen5[MODE_11G]) {
			mError(devNum, ENOMEM, "unable to allocate 11g gen5 cal data struct\n");
			return(0);
		}
		pCalDataset_gen5[MODE_11G]->xpd_mask = pLibDev->p16kEepHeader->info11g.xgain;
		if (!read_Cal_Dataset_From_EEPROM_gen5(devNum, pCalDataset_gen5[MODE_11G], start_offset, maxPiers,  &(words[0]), MODE_11G ) ) {
			mError(devNum, EIO,"unable to allocate cal dataset (gen5) for mode 11g\n");
			return(0);
		}		
		pRawDataset_gen5[MODE_11G] = (RAW_DATA_STRUCT_GEN5 *)malloc(sizeof(RAW_DATA_STRUCT_GEN5));
		if(NULL == pRawDataset_gen5[MODE_11G]) {
			mError(devNum, ENOMEM, "unable to allocate 11g gen5 raw data struct\n");
			return(0);
		}
		pRawDataset_gen5[MODE_11G]->xpd_mask = pLibDev->p16kEepHeader->info11g.xgain;