lowerPower = pPowerInfo[lowerIndex].twicePwr48;
			upperPower = pPowerInfo[upperIndex].twicePwr48;
			break;

		case 13:
		case 14:
			lowerPower = pPowerInfo[lowerIndex].twicePwr54;
			upperPower = pPowerInfo[upperIndex].twicePwr54;
			break;
		}

		twicePower = (A_UINT16)(getInterpolatedValue(channel, lowerChannel, upperChannel, lowerPower,
						upperPower, 0));  


		if(twicePower > twiceMaxEdgePower) {
			twicePower = twiceMaxEdgePower;
		}

		if(pLibDev->libCfgParams.applyCtlLimit) {
			if((pLibDev->mode == MODE_11B) || (pLibDev->mode == MODE_11G) ) {
				ctlPower = getCtlPower(devNum, pLibDev->libCfgParams.ctlToApply, channel, MODE_11B, pLibDev->turbo);
			}

			if(ctlPower < twicePower) {
				pRatesPower[i] = (A_INT16)ctlPower;
//				printf("Applying ctl power (x2) of %d to pRatesPower[%d]\n", ctlPower, i);
			} else {
				pRatesPower[i] = twicePower;
			}
		}
		else {
			pRatesPower[i] = twicePower;
		}
	}
	
	return;
}


/**************************************************************************
* forcePCDACTable - Write the linear power - pcdac table to device registers
*
*
* RETURNS: 
*/
MANLIB_API void forcePCDACTable 
(
 A_UINT32		devNum,
 A_UINT16		*pPcdacs
)
{
	A_UINT16	regOffset;
	A_UINT16	i;
	A_UINT32	temp32;
  LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	
	regOffset = 0x9800 + (608 << 2) ;
	for(i = 0; i < 32; i++) {
		temp32 = 0xffff & ((pPcdacs[2*i + 1] << 8) | 0xff);
		temp32 = (temp32 << 16) | (0xffff & ((pPcdacs[2*i] << 8) | 0xff));
		if (pLibDev->devMap.remoteLib) {
			pciValues[i].offset = regOffset;
			pciValues[i].baseValue = temp32;
		}
		else {
		    REGW(devNum, regOffset, temp32);
		}
		//printf("Snoop: regOffset = %x, regValue = %x\n", regOffset, temp32);
		regOffset += 4;
	}
	if (pLibDev->devMap.remoteLib) {
			sendPciWrites(devNum, pciValues, 32);
	}

}


/**************************************************************************
* forcePDADCTable - Write the pdadc table and gain boundaries to device 
*                   registers 672-703
*
* RETURNS:  Nothing
*/
MANLIB_API void forcePDADCTable 
(
 A_UINT32		devNum,
 A_UINT16		*pPdadcs,
 A_UINT16		*pGainBoundaries
)
{
	A_UINT16	regOffset;
	A_UINT16	i;
	A_UINT32	temp32;
	
	regOffset = 0x9800 + (672 << 2) ;
	for(i = 0; i < 32; i++) {
		temp32 = ((pPdadcs[4*i + 0] & 0xFF) << 0)  | 
			     ((pPdadcs[4*i + 1] & 0xFF) << 8)  |
				 ((pPdadcs[4*i + 2] & 0xFF) << 16) |
				 ((pPdadcs[4*i + 3] & 0xFF) << 24) ;		
		REGW(devNum, regOffset, temp32);
		//printf("Snoop: regOffset = %x, regValue = %x\n", regOffset, temp32);
		regOffset += 4;
	}

	//cant use field names incase we are loading ear, these don't exist in non griffin
	//config files.
	temp32 = ((pGainBoundaries[0] & 0x3f) << 4)  |
			 ((pGainBoundaries[1] & 0x3f) << 10) |
			 ((pGainBoundaries[2] & 0x3f) << 16) |
			 ((pGainBoundaries[3] & 0x3f) << 22) ;
	REGW(devNum, 0xa26c, (REGR(devNum, 0xa26c) & 0xf)| temp32);

	//writeField(devNum, "bb_pd_gain_boundary_1", pGainBoundaries[0]);
	//writeField(devNum, "bb_pd_gain_boundary_2", pGainBoundaries[1]);
	//writeField(devNum, "bb_pd_gain_boundary_3", pGainBoundaries[2]);
	//writeField(devNum, "bb_pd_gain_boundary_4", pGainBoundaries[3]);
}



/**************************************************************************
* fbin2freq - Get channel value from binary representation held in eeprom
*
*
* RETURNS: the frequency in MHz
*/
A_UINT16 fbin2freq(A_UINT32 devNum, A_UINT16 fbin)
{
	A_UINT16 returnValue; 
    LIB_DEV_INFO	*pLibDev = gLibInfo.pLibDevArray[devNum];

	if((pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion <= 2)) {
		returnValue = (fbin>62) ? (A_UINT16)(5100 + 10*62 + 5*(fbin-62)) : (A_UINT16)(5100 + 10*fbin);
	}
	else {
		returnValue = (A_UINT16)(4800 + 5*fbin);
	}
	return returnValue;
} 

A_UINT16 fbin2freq_2p4(A_UINT32 devNum, A_UINT16 fbin)
{
	A_UINT16 returnValue; 
    LIB_DEV_INFO	*pLibDev = gLibInfo.pLibDevArray[devNum];

	if((pLibDev->p16kEepHeader->majorVersion == 3) && (pLibDev->p16kEepHeader->minorVersion <= 2)) {
		returnValue = (A_UINT16)(2400 + fbin);
	}
	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(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];
	A_UINT16 i;

	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;
	}
	if(pLibDev->pGen5CalData != NULL) {
		free(pLibDev->pGen5CalData);
		pLibDev->pGen5CalData = NULL;
	}
	for(i = 0; i < 3; i++) {
		if(pLibDev->pGen3RawData[i] != NULL) {
			free(pLibDev->pGen3RawData[i]);
			pLibDev->pGen3RawData[i] = NULL;
		}
		if(pLibDev->pGen5RawData[i] != NULL) {
			free(pLibDev->pGen5RawData[i]);
			pLibDev->pGen5RawData[i] = 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];
	EEPROM_DATA_STRUCT_GEN5  *pTempGen5CalData[3];

	// for dual 11a support, start reading eeprom_block1 from location 0x400
	if ((pLibDev->devMap.devIndex == 1) && (pLibDev->libCfgParams.eepStartLocation > 0)) {
		pLibDev->eepromStartLoc = pLibDev->libCfgParams.eepStartLocation;
	}

	//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->eepromStartLoc));
	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)))
	{
		// not really need to correct for  pLibDev->eepromStartLoc as dual 11a mode is 
		// only supported for eep_map = 1. done anyway.
		if(!readCalData_gen2(devNum, pLibDev->pCalibrationInfo)) {
			return (FALSE);