cal_gen3.c

atheros ar5001 5002 driver

			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
		}
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[0] = (A_UINT16)(4*power + 0.5);				
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[0]  = lo_pcd;
		gain1 = read_gainf_twice(devNum) ;
		if (gain1 < 5) {  // possibly a bad reading
			gain1 = read_gainf_twice(devNum) ;
		}
		pwr1 = power;
		if (CalSetup.customerDebug) {
			uiPrintf(", %3.2f[%d]", power, lo_pcd);
		}

		lo_pcd = 25;
		art_ForceSinglePCDACTable(devNum, lo_pcd);
		Sleep(sleep_interval);
		power = pmMeasAvgPower(devPM, reset) + myAtten ;
		gain25 = read_gainf_twice(devNum) ;
		if (gain25 < 5) {  // possibly a bad reading
			gain25 = read_gainf_twice(devNum) ;
		}
		pwr25 = power;
		if (CalSetup.customerDebug) {
			uiPrintf(", %3.2f[%d]", power, lo_pcd);
		}

		// start search for highest linear power at pcdac for (maxPower - 3dB)
		lo_pcd = (A_UINT16)((((maxPower - 3) - pwr1)/(pwr25 - pwr1))*(25 - 1) + 1);
		if ((lo_pcd < 0) || (lo_pcd > 56)) {
			lo_pcd = 56;
		}
		art_ForceSinglePCDACTable(devNum, lo_pcd);
		Sleep(10);
		gainF = read_gainf_twice(devNum) ;
		intp_gain = (A_UINT16)(((lo_pcd - 1)/(25 - 1))*(gain25 - gain1) + gain1);

		dirxn = (gainF > (intp_gain + 5)) ? -1 : 1;

		prev_gain = gainF;
		if (dirxn < 0) {
			while ((abs(gainF - prev_gain) < 4) && (lo_pcd < 63)){
				lo_pcd -= dirxn ;
				prev_gain = gainF;
				if (CalSetup.customerDebug) printf("SNOOP: loop 1 dirxn-1 = %d : pcd=%d, prev_gF=%d", dirxn, lo_pcd, prev_gain);
				art_ForceSinglePCDACTable(devNum, lo_pcd);
				Sleep(10);				
				gainF = read_gainf_twice(devNum) ;
				if (CalSetup.customerDebug) printf(", gF=%d\n", gainF);
			}
					
			while ((abs(gainF - prev_gain) >= 4) && (lo_pcd < 63)){
				lo_pcd += dirxn ;
				prev_gain = gainF;
				if (CalSetup.customerDebug) printf("SNOOP: loop 2 dirxn-1 = %d : pcd=%d, prev_gF=%d", dirxn, lo_pcd, prev_gain);
				art_ForceSinglePCDACTable(devNum, lo_pcd);
				Sleep(10);
				gainF = read_gainf_twice(devNum) ;		
				if (CalSetup.customerDebug) printf(", gF=%d\n", gainF);
			}
		} else {  // dirxn > 0
			prev_gain = 107;
			while ((abs(gainF - prev_gain) >= 4) && (lo_pcd < 63)){
				lo_pcd -= dirxn ;
				prev_gain = gainF;
				if (CalSetup.customerDebug) printf("SNOOP: loop 1 dirxn1 = %d : pcd=%d, prev_gF=%d", dirxn, lo_pcd, prev_gain);
				art_ForceSinglePCDACTable(devNum, lo_pcd);
				Sleep(10);
				gainF = read_gainf_twice(devNum) ;	
				if (CalSetup.customerDebug) printf(", gF=%d\n", gainF);
			}
					
			while ((abs(gainF - prev_gain) < 4) && (lo_pcd < 63)) {
				lo_pcd += dirxn ;
				prev_gain = gainF;
				if (CalSetup.customerDebug) printf("SNOOP: loop 2 dirxn1 = %d : pcd=%d, prev_gF=%d", dirxn, lo_pcd, prev_gain);
				art_ForceSinglePCDACTable(devNum, lo_pcd);
				Sleep(10);
				gainF = read_gainf_twice(devNum) ;	
				if (CalSetup.customerDebug) printf(", gF=%d\n", gainF);
			}
			lo_pcd -= dirxn;
		}
		lo_pcd -= 1; // back off 1 into linear range

		if (lo_pcd > 63) {
			lo_pcd = 63;
		}
		art_ForceSinglePCDACTable(devNum, lo_pcd);
		Sleep(sleep_interval);
		power = pmMeasAvgPower(devPM, reset) + myAtten ;
		
		// highest linear power
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] = (A_UINT16)(4*power + 0.5);				
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2]  = lo_pcd;

		// if highest linear pcdac > 40, use pcdacs (25, 70% intrcpt[25,pcdMaxLin], pcdMaxLin, pcdMaxPwr) instead
		// of (1, 25, pcdMaxLin, pcdMaxPwr).


		if (CalSetup.customerDebug) printf("SNOOP: pcd2=%d, pwr2=%f\n", lo_pcd, power);
		if (lo_pcd > 40) {
			if (CalSetup.customerDebug) printf("SNOOP: lo_pcd is > 40 : %d\n", lo_pcd);
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[0] = (A_UINT16)(4*pwr25 + 0.5);				
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[0]  = 25;
			if (CalSetup.customerDebug) printf("SNOOP: pcd0=%d, pwr0=%f\n", 25, pwr25);
//			lo_pcd = (A_UINT16)(0.75*(lo_pcd-1) + 1);
//			if (lo_pcd > 32) {
//				lo_pcd = 32;
//			}
			lo_pcd = (A_UINT16)(0.7*(lo_pcd-25) + 25);
			if (lo_pcd > 56) {
				lo_pcd = 56;
			}
			art_ForceSinglePCDACTable(devNum, lo_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[1] = (A_UINT16)(4*power + 0.5);				
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[1]  = lo_pcd;
			if (CalSetup.customerDebug) printf("SNOOP: pcd1=%d, pwr1=%f\n", lo_pcd, power);
		} else {
			if (CalSetup.customerDebug) printf("SNOOP: lo_pcd is < 40 : %d\n", lo_pcd);
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[1] = (A_UINT16)(4*pwr25 + 0.5);				
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[1]  = 25;
			if (CalSetup.customerDebug) printf("SNOOP: pcd1=%d, pwr1=%f\n", 25, pwr25);
		}
		
		power = ((double)pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2])/4.0;

		// limit power[2] to maxPowerCap if highest linear power > maxPower
		if (power >= CalSetup.maxPowerCap[mode]) {
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] = pRawDataset_gen3[mode]->pDataPerChannel[ii].maxPower_t4;				
			pcd1 = pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[1];
			pcd2 = pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2];
			pwrL = (double) ((double)pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[1]/4.0);
			pwrH = power;
			pcd_interp = (A_INT16)( ( (CalSetup.maxPowerCap[mode] - pwrL)*pcd2 + (pwrH - CalSetup.maxPowerCap[mode])*pcd1)/(pwrH - pwrL));
			//uiPrintf("SNOOP: maxpwr2 : pcdI = %d, pcd1 = %d, pcd2 = %d, pwr1 = %3.1f, pwr2 = %3.1f, pwrT = %3.1f\n", pcd_interp, pcd1, pcd2, pwrL, pwrH, CalSetup.maxPowerCap[mode]);
			if ((pcd_interp >= pcd1) && (pcd_interp <= pcd2)) {
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2]  = pcd_interp;
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3]  = pcd_interp;
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] = pRawDataset_gen3[mode]->pDataPerChannel[ii].maxPower_t4;				
			} else {
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2]  = pcd2;
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] = (A_UINT16) (4*pwrH);
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3]  = pcd2;
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] = (A_UINT16) (4*pwrH);
			}
		} else {

			// search for min pcdac corresponding to maxPower

			lo_pcd = pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2];
			if (lo_pcd == 63) { // not hit saturation yet
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] = pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2];				
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3]  = pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2];
				if (CalSetup.customerDebug) printf("SNOOP: pcd3=%d, pwr3=%f\n", lo_pcd, (pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] - 0.5)/4);
				lo_pcd = 47;
				art_ForceSinglePCDACTable(devNum, lo_pcd);
				Sleep(sleep_interval);
				power = pmMeasAvgPower(devPM, reset) + myAtten ;
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] = (A_UINT16)(4*power + 0.5);				
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2]  = lo_pcd;
				if (CalSetup.customerDebug) printf("SNOOP: pcd2=%d, pwr2=%f\n", lo_pcd, (pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] - 0.5)/4);
			} else {
				art_ForceSinglePCDACTable(devNum, lo_pcd);
				Sleep(10);
				gainF = read_gainf_twice(devNum) ;
				prev_gain = 107;
				while (((gainF < 100) || (gainF == prev_gain))&& (lo_pcd < 63)){
					lo_pcd++;
					art_ForceSinglePCDACTable(devNum, lo_pcd);
					Sleep(10);
					prev_gain = gainF;
					gainF = read_gainf_twice(devNum) ;
					if (CalSetup.customerDebug) printf("SNOOP: gainF = %d, pcd = %d\n", gainF, lo_pcd);
				} 
				Sleep(sleep_interval);
				power = pmMeasAvgPower(devPM, reset) + myAtten ;
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] = (A_UINT16)(4*power + 0.5);				
				pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3]  = lo_pcd;
				if (CalSetup.customerDebug) printf("SNOOP: pcd3=%d, pwr3=%f\n", lo_pcd, power);
				
				// limit power[3] to maxPowerCap if highest power > maxPower
				if (power >= CalSetup.maxPowerCap[mode]) {
					pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] = pRawDataset_gen3[mode]->pDataPerChannel[ii].maxPower_t4;
					pcd1 = pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2];
					pcd2 = pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3];
					pwrL = (double) ((double)pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2]/4.0);
					pwrH = power;
					if (pwrH == pwrL) {
						pcd_interp = pcd2;
					} else {
						pcd_interp = (A_INT16)( ( (CalSetup.maxPowerCap[mode] - pwrL)*pcd2 + (pwrH - CalSetup.maxPowerCap[mode])*pcd1)/(pwrH - pwrL));
					}
					//uiPrintf("SNOOP: maxpwr3 : pcdI = %d, pcd1 = %d, pcd2 = %d, pwr1 = %3.1f, pwr2 = %3.1f, pwrT = %3.1f\n", pcd_interp, pcd1, pcd2, pwrL, pwrH, CalSetup.maxPowerCap[mode]);
					if ((pcd_interp >= pcd1) && (pcd_interp <= pcd2)) {
						pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3]  = pcd_interp;
					} else {
						pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3]  = pcd2;
						pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] = (A_UINT16) (4*pwrH);
					}
				}
			}
		}
			
/*
//		hi_pcd = (A_UINT16)(lo_pcd + (maxPower - power)*curr_intercept_estimate/10.0 - 5);		
		hi_pcd = 55;
//		if (hi_pcd > 63) hi_pcd = 63;
//		if (hi_pcd < 0) {
//			uiPrintf("The max transmit Power (%3.2f) is too close to power at pcdac = 1 (%3.2f) at ch = %d. Try again.\n", maxPower, power, channel);
//			REWIND_TEST = TRUE;
//			return;
//			hi_pcd = 45;
//		}
		art_ForceSinglePCDACTable(devNum, hi_pcd);
		Sleep(sleep_interval);
		power = pmMeasAvgPower(devPM, reset) + myAtten ;
		gainF = read_gainf_twice(devNum) ;
		if (CalSetup.customerDebug) {
			uiPrintf(", %3.2f[%d, %d]", power, hi_pcd, gainF);
		}
		tmpPower = power;
		tmpGainF = gainF;
		if (power < (maxPower - 1.5)) {
			hi_pcd += 5;
			art_ForceSinglePCDACTable(devNum, hi_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			gainF = read_gainf_twice(devNum) ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d, %d]", power, hi_pcd, gainF);
			}
			if ((gainF > 105) && (tmpGainF <= 105)) {
				gainF = tmpGainF;
				power = tmpPower;
				hi_pcd -= 5;
			}
		}
//		if (power > (maxPower - 0.5)) {
		while ((gainF > 99) && (hi_pcd > 32)){
			hi_pcd -= 4;
			art_ForceSinglePCDACTable(devNum, hi_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			gainF = read_gainf_twice(devNum) ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d, %d]", power, hi_pcd, gainF);
			}
		}
//		if ((power > (maxPower - 0.5)) || (power < (maxPower - 1.5))) {
//			art_ForceSinglePCDACTable(devNum, hi_pcd);
//			Sleep(sleep_interval);
//			power = pmMeasAvgPower(devPM, reset) + myAtten ;
//			uiPrintf(", %3.2f[%d]", power, hi_pcd);
//		}
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[3] = (A_UINT16)(4*power + 0.5);
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[3] = hi_pcd;
		
		hi_pcd = lo_pcd + (A_UINT16)((hi_pcd - lo_pcd)*0.9);
		art_ForceSinglePCDACTable(devNum, hi_pcd);
		Sleep(sleep_interval);
		power = pmMeasAvgPower(devPM, reset) + myAtten ;
		if (CalSetup.customerDebug) {
			uiPrintf(", %3.2f[%d]", power, hi_pcd);
		}
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] = (A_UINT16)(4*power + 0.5);
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2] = hi_pcd;
		
		hi_pcd = lo_pcd + (A_UINT16)((hi_pcd - lo_pcd)*0.7);
		if ((hi_pcd - lo_pcd) > 31) {
			hi_pcd = lo_pcd + 31; // because pcd_delta mask is only 5 bits
		}
		art_ForceSinglePCDACTable(devNum, hi_pcd);
		Sleep(sleep_interval);
		power = pmMeasAvgPower(devPM, reset) + myAtten ;
		if (CalSetup.customerDebug) {
			uiPrintf(", %3.2f[%d]", power, hi_pcd);
		}
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[1] = (A_UINT16)(4*power + 0.5);
		pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[1] = hi_pcd;
*/
//		if (CalSetup.cal_mult_xpd_gain_mask[mode] > 0) {
		if ( xgain_list[1] != xgain_list[0] ) {
			art_txContEnd(devNum);
			jj = xgain_list[1];
			if((swDeviceID & 0xff) >= 0x16) {
				art_writeField(devNum, "rf_pdgain_lo", jj);
				art_writeField(devNum, "rf_pdgain_hi", jj);
			} else {
				art_writeField(devNum, "rf_xpd_gain", jj);
			}
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].xpd_gain = (A_UINT16)jj;
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].numPcdacs = NUM_POINTS_XPD3;
			art_txContBegin(devNum, CONT_FRAMED_DATA, RANDOM_PATTERN, 
							rates[0], DESC_ANT_A | USE_DESC_ANT);

			lo_pcd = 20;
			art_ForceSinglePCDACTable(devNum, lo_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d]", power, lo_pcd);
			}
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[0] = (A_UINT16)(4*power + 0.5);				
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[0]  = lo_pcd;

			lo_pcd = 35;
			art_ForceSinglePCDACTable(devNum, lo_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d]", power, lo_pcd);
			}
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[1] = (A_UINT16)(4*power + 0.5);				
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[1]  = lo_pcd;

			lo_pcd = 63;
			art_ForceSinglePCDACTable(devNum, lo_pcd);
			Sleep(sleep_interval);
			power = pmMeasAvgPower(devPM, reset) + myAtten ;
			if (CalSetup.customerDebug) {
				uiPrintf(", %3.2f[%d]", power, lo_pcd);
			}
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pwr_t4[2] = (A_UINT16)(4*power + 0.5);				
			pRawDataset_gen3[mode]->pDataPerChannel[ii].pDataPerXPD[jj].pcdac[2]  = lo_pcd;
		}
		
		if (CalSetup.customerDebug) {
			uiPrintf("\n");
		}
		art_txContEnd(devNum);

	} // end channel loop

	art_writeField(devNum, "rf_mixvga_ovr", mixvga_ovr);
	art_writeField(devNum, "rf_mixgain_ovr", mixgain_ovr);
}

void dump_raw_data_to_file_gen3( RAW_DATA_STRUCT_GEN3 *pRawData, char *filename )
{
	A_UINT16		i, j, kk;
    FILE			*fStream;
//	A_UINT16		single_xpd = 0xDEAD;
	A_UINT16		xgain_list[2];
	A_UINT16		xpd_mask;

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

	for (j = 0; j < NUM_XPD_PER_CHANNEL; j++) {
		if (((xpd_mask >> j) & 1) > 0) {
			if (kk > 1) {
				uiPrintf("ERROR: A maximum of 2 xpd_gains supported in raw data\n");
				exit(0);
			}
			xgain_list[kk++] = (A_UINT16) j;			
		}
	}

	if (CalSetup.customerDebug)
		uiPrintf("\nWriting raw data to file %s\n", filename);
	
    if( (fStream = fopen( filename, "w")) == NULL ) {
        uiPrintf("Failed to open %s for writing - giving up\n", filename);
        return;
    }

	fprintf(fStream, "XPD_Gain_mask = 0x%x\n\n", pRawData->xpd_mask);

	//print the frequency values
	fprintf(fStream, "freq    pwr1    pwr2    pwr3    pwr4");
	if (xgain_list[1] != 0xDEAD) {
		fprintf(fStream, "   pwr1_x3  pwr2_x3   pwr3_x3\n");
		fprintf(fStream, "        [pcd]    [pcd]    [pcd]    [pcd]   [pcd]    [pcd]      [pcd]\n");
	} else {
		fprintf(fStream, "\n        [pcd]    [pcd]    [pcd]    [pcd]    \n");
	}

	for (i = 0; i < pRawData->numChannels; i++) {
		fprintf(fStream, "%d\t", pRawData->pChannels[i]);
		j = xgain_list[0];
		for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
			fprintf(fStream, "%3.2f    ", (double)(pRawData->pDataPerChannel[i].pDataPerXPD[j].pwr_t4[kk]/4.0));
		}
		if (xgain_list[1] != 0xDEAD) {
			j = xgain_list[1];
			for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
				fprintf(fStream, "%3.2f    ", (double)(pRawData->pDataPerChannel[i].pDataPerXPD[j].pwr_t4[kk]/4.0));
			}
		}
		fprintf(fStream, "%3.2f    ", (double)(pRawData->pDataPerChannel[i].maxPower_t4/4.0));
		fprintf(fStream,"\n\t");		
		for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
			fprintf(fStream, "[%2d]    ", pRawData->pDataPerChannel[i].pDataPerXPD[j].pcdac[kk]);
		}
		if (xgain_list[1] != 0xDEAD) {
			j = xgain_list[1];
			for (kk=0; kk<pRawData->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
				fprintf(fStream, "[%2d]    ", pRawData->pDataPerChannel[i].pDataPerXPD[j].pcdac[kk]);
			}
		}
		fprintf(fStream,"\n");		
	}
	
	fclose(fStream);
}

void raw_to_eeprom_dataset_gen3(RAW_DATA_STRUCT_GEN3 *pRawDataset, EEPROM_DATA_STRUCT_GEN3 *pCalDataset) {

	A_UINT16	ii, jj, kk;
	EEPROM_DATA_PER_CHANNEL_GEN3	*pCalCh;
	RAW_DATA_PER_CHANNEL_GEN3		*pRawCh;
	A_UINT16		xgain_list[2];
	A_UINT16		xpd_mask;

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

	kk = 0;