meeprom_d.c

Atheros AP Test with Agilent N4010A source code

		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. 0x2BE is the max possible end of CTL section.
	A_UINT32	maxPiers;
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];

	// read only upto the end of CTL section
	// 0x2BE is the max possible end of CTL section.
	// for 16k eeprom (0x2BE - 0x150) = 367. 
	eepromReadBlock(devNum, (start_offset + pLibDev->eepromStartLoc), 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);
		if(pCalDataset_gen3[MODE_11A]->xpd_mask == 0) {
			mError(devNum, EIO,"illegal xpd_mask mode 11a, must be non-zero (gen3)\n");
			return(0);
		}
		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);
		if(pCalDataset_gen3[MODE_11B]->xpd_mask == 0) {
			mError(devNum, EIO,"illegal xpd_mask (mode 11b), must be non-zero (gen3)\n");
			return(0);
		}
		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);
		if(pCalDataset_gen3[MODE_11G]->xpd_mask == 0) {
			mError(devNum, EIO,"illegal xpd_mask mode 11g, must be non-zero (gen3)\n");
			return(0);
		}
		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);
}

// expand the pcdac intercepts to generate full pcdacs-to-power table for pcdacs 1..63. 
//    capped with maxPower
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_UINT32 devNum, 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;
	if (isFalcon(devNum)) {
// since eirp_limited mode in falcon can't handle different Pmax values for 2 chains
// make it fixed 0-31.5 dBm
		currPower = 126;
		Pmin = 0;
//		currPower += 4*FALCON_BAND_EIRP_HEADROOM_IN_DB;
//		Pmin      += 4*FALCON_BAND_EIRP_HEADROOM_IN_DB;
	}

	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_UINT32 devNum, 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;
	if (isFalcon(devNum)) {
// since eirp_limited mode in falcon can't handle different Pmax values for 2 chains
// make it fixed 0-31.5 dBm
		currPower = 126;
		Pmin = 0;
//		currPower += 4*FALCON_BAND_EIRP_HEADROOM_IN_DB;
//		Pmin      += 4*FALCON_BAND_EIRP_HEADROOM_IN_DB;
	}
	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);
	}
}