eeprom.c

atheros ar5001 5002 driver

 A_UINT32			mode
)
{
	A_UINT16 i, k;
	MDK_TRGT_POWER_INFO		*pPowerInfo;
	A_UINT16    numTrgtPwrPiers;

	uiPrintf("\n");
	if(mode == MODE_11A) {
		pPowerInfo = pPowerInfoAllModes->trgtPwr_11a;
		uiPrintf("============================Target Power Info===============================\n");
	
		for (k = 0; k < 8; k+=4) {
			uiPrintf("|     rate     ");
			for(i = k; i < k + 4; i++) {
				uiPrintf("|     %04d     ",
					pPowerInfo[i].testChannel);
			}
			uiPrintf("|\n");
			
			uiPrintf("|==============|==============|==============|==============|==============|\n");

			uiPrintf("|     6-24     ");
			for (i = k; i < k + 4; i++) {
				uiPrintf("|     %4.1f     ", (float)(pPowerInfo[i].twicePwr6_24)/2);
			}
			uiPrintf("|\n");

			uiPrintf("|      36      ");
			for (i = k; i < k + 4; i++) {
				uiPrintf("|     %4.1f     ", (float)(pPowerInfo[i].twicePwr36)/2);
			}
			uiPrintf("|\n");

			uiPrintf("|      48      ");
			for (i = k; i < k + 4; i++) {
				uiPrintf("|     %4.1f     ", (float)(pPowerInfo[i].twicePwr48)/2);
			}
			uiPrintf("|\n");

			uiPrintf("|      54      ");
			for (i = k; i < k + 4; i++) {
				uiPrintf("|     %4.1f     ", (float)(pPowerInfo[i].twicePwr54)/2);
			}

			uiPrintf("|\n");
			uiPrintf("|==============|==============|==============|==============|==============|\n");
		}
	}
	else {
		if(mode == MODE_11B) {
			pPowerInfo = pPowerInfoAllModes->trgtPwr_11b;
			numTrgtPwrPiers = pPowerInfoAllModes->numTargetPwr_11b;
		}
		else {
			pPowerInfo = pPowerInfoAllModes->trgtPwr_11g;
			numTrgtPwrPiers = pPowerInfoAllModes->numTargetPwr_11g;
		}
		if(numTrgtPwrPiers == 2){
			uiPrintf("=============Target Power Info================\n");
		} else {
			uiPrintf("====================Target Power Info========================\n");
		}

		uiPrintf("|     rate     ");
		for(i = 0; i < numTrgtPwrPiers; i++) {
			uiPrintf("|     %04d     ",
				pPowerInfo[i].testChannel);
		}
		uiPrintf("|\n");
		
		if(numTrgtPwrPiers == 2){
			uiPrintf("|==============|==============|==============|\n");
		} else {
			uiPrintf("|==============|==============|==============|==============|\n");

		}

		if(mode == MODE_11B) {
			uiPrintf("|      1       ");
		}
		else {
			uiPrintf("|     6-24     ");
		}

		for (i = 0; i < numTrgtPwrPiers; i++) {
			uiPrintf("|     %4.1f     ", (float)(pPowerInfo[i].twicePwr6_24)/2);
		}
		uiPrintf("|\n");

		if(mode == MODE_11B) {
			uiPrintf("|      2       ");
		}
		else {
			uiPrintf("|      36      ");
		}
		for (i = 0; i < numTrgtPwrPiers; i++) {
			uiPrintf("|     %4.1f     ", (float)(pPowerInfo[i].twicePwr36)/2);
		}
		uiPrintf("|\n");

		if(mode == MODE_11B) {
			uiPrintf("|      5.5     ");
		}
		else {
			uiPrintf("|      48      ");
		}
		for (i = 0; i < numTrgtPwrPiers; i++) {
			uiPrintf("|     %4.1f     ", (float)(pPowerInfo[i].twicePwr48)/2);
		}
		uiPrintf("|\n");

		if(mode == MODE_11B) {
			uiPrintf("|      11      ");
		}
		else {
			uiPrintf("|      54      ");
		}
		for (i = 0; i < numTrgtPwrPiers; i++) {
			uiPrintf("|     %4.1f     ", (float)(pPowerInfo[i].twicePwr54)/2);
		}

		uiPrintf("|\n");
		if(numTrgtPwrPiers == 2){
			uiPrintf("|==============|==============|==============|\n");
		} else {
			uiPrintf("|==============|==============|==============|==============|\n");

		}

	}
}

void printRDEdges_16K
(
 MDK_RD_EDGES_POWER		*pRdEdgePwrInfo,
 A_UINT16			*pTestGroups,
 A_UINT32			mode,
 A_UINT16			maxNumCtl,
 A_UINT16			version
)
{
	A_UINT16	i=0, j;
	A_UINT16	ctlMode;
	char		ctlType[64];

	uiPrintf("\n");
	uiPrintf("=======================Test Group Band Edge Power========================\n");
	while ((pTestGroups[i] != 0) && (i < maxNumCtl)) {
		switch(pTestGroups[i] & 0x3) {
		case 0: 
			sprintf(ctlType, " [ 0x%x 11a base mode ] ", (pTestGroups[i]&0xfc));
			ctlMode = MODE_11A; break;
		case 3:
			sprintf(ctlType, " [ 0x%x 11a TURBO mode ]", (pTestGroups[i]&0xfc));
			ctlMode = MODE_11A; break;
		case 1: 
			sprintf(ctlType, " [ 0x%x 11b mode ]      ", (pTestGroups[i]&0xfc));
			ctlMode = MODE_11B; break;
		case 2: 
			sprintf(ctlType, " [ 0x%x 11g mode ]      ", (pTestGroups[i]&0xfc));
			ctlMode = MODE_11G; break;
		default: uiPrintf("Illegal mode mask in CTL (0x%x) number %d\n", pTestGroups[i], i); return;
		}
		if(mode != ctlMode) {
			i++;
			pRdEdgePwrInfo+=NUM_16K_EDGES;
			continue;
		}
		uiPrintf("|                                                                       |\n");
		uiPrintf("| CTL: 0x%02x  %s", pTestGroups[i] & 0xff, ctlType);
		
		uiPrintf("                                   |\n");
		uiPrintf("|=======|=======|=======|=======|=======|=======|=======|=======|=======|\n");

		uiPrintf("| edge  ");
		for(j = 0; j < NUM_16K_EDGES; j++) {
			if (pRdEdgePwrInfo[j].rdEdge == 0)
			{
				uiPrintf("|  --   ");
			} else
			{
				uiPrintf("| %04d  ", pRdEdgePwrInfo[j].rdEdge);
			}
		}

		uiPrintf("|\n");
		uiPrintf("|=======|=======|=======|=======|=======|=======|=======|=======|=======|\n");
		uiPrintf("| power ");
		for(j = 0; j < NUM_16K_EDGES; j++) {
			if (pRdEdgePwrInfo[j].rdEdge == 0)
			{
				uiPrintf("|  --   ");
			} else
			{
				uiPrintf("| %4.1f  ", (float)(pRdEdgePwrInfo[j].twice_rdEdgePower)/2);
			}
		}

		uiPrintf("|\n");
		if(version >= 3) {
			uiPrintf("|=======|=======|=======|=======|=======|=======|=======|=======|=======|\n");
			uiPrintf("| flag  ");
			for(j = 0; j < NUM_16K_EDGES; j++) {
				if (pRdEdgePwrInfo[j].rdEdge == 0)
				{
					uiPrintf("|  --   ");
				} else
				{
					uiPrintf("|   %1d   ", pRdEdgePwrInfo[j].flag);
				}
			}

			uiPrintf("|\n");
		}
		uiPrintf("=========================================================================\n");
		i++;
		pRdEdgePwrInfo+=NUM_16K_EDGES;
	}
}

void
printfChannelInfo_gen3
(
 EEPROM_FULL_DATA_STRUCT_GEN3 *pChannelInfo, 
 A_UINT32 mode
)
{
	EEPROM_DATA_PER_CHANNEL_GEN3	*pDataPerChannel;
	A_UINT16 i, k;
	A_UINT16 pcdacValues[10];
	A_UINT16 xpdGainMask;
	A_UINT16 k_end, i_end;
	A_UINT16 xpdGainValues[2];
	A_UINT16 numXpdGain = 0, jj;

	switch(mode) {
	case MODE_11A:
		pDataPerChannel = pChannelInfo->pDataPerChannel11a;
		xpdGainMask = pChannelInfo->xpd_mask11a;
		break;

	case MODE_11G:
	case MODE_11O:
		pDataPerChannel = pChannelInfo->pDataPerChannel11g;
		xpdGainMask = pChannelInfo->xpd_mask11g;
		break;

	case MODE_11B:
		pDataPerChannel = pChannelInfo->pDataPerChannel11b;
		xpdGainMask = pChannelInfo->xpd_mask11b;
		break;

	default:
		printf("Illegal mode passed to printfChannelInfo_gen3\n");
		return;
	}

	//calculate the value of xpdgains
	for (jj = 0; jj < NUM_XPD_PER_CHANNEL; jj++) {
		if (((xpdGainMask >> jj) & 1) > 0) {
			xpdGainValues[numXpdGain++] = (A_UINT16) jj;			
		}
	}

	uiPrintf("\n");
	if(mode == MODE_11A) {
		uiPrintf("=========================Calibration Information============================\n");
		k_end = 10;
		i_end = 5;
	}
	else {
		uiPrintf("               ==========Calibration Information=============\n");
		k_end = 3;
		i_end = 3;
	}

	for (k = 0; k < k_end; k+=5) {
		if(mode != MODE_11A) {
			uiPrintf("               ");
		}
		for(i = k; i < (k + i_end); i++) {
			uiPrintf("|     %04d     ",
				pDataPerChannel[i].channelValue);
		}
		uiPrintf("|\n");
		
    	if(mode == MODE_11A) {
	    	uiPrintf("|==============|==============|==============|==============|==============|\n");
		}
		else {
    		uiPrintf("               |==============|==============|==============|\n");
			uiPrintf("               ");
		}
		for(i = k; i < (k + i_end); i++) {
			uiPrintf("|pcdac pwr(dBm)");
		}
		uiPrintf("|\n");

    	if(mode == MODE_11A) {
			uiPrintf("|              |              |              |              |              |\n");
			uiPrintf("| XPD_Gain %2d  |              |              |              |              |\n", 
				xpdGainMapping[xpdGainValues[0]]);	
		}
		else {
    		uiPrintf("               | XPD_Gain %2d  |              |              |\n",
				xpdGainMapping[xpdGainValues[0]]);	
    		uiPrintf("               |              |              |              |\n");
		}
		
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}
		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] = pDataPerChannel[i].pcd1_xg0;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].pwr1_xg0)/4));
		}
		uiPrintf("|\n");
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}
		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] += pDataPerChannel[i].pcd2_delta_xg0;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].pwr2_xg0)/4));
		}
		uiPrintf("|\n");
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}

		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] += pDataPerChannel[i].pcd3_delta_xg0;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].pwr3_xg0)/4));
		}

		uiPrintf("|\n");
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}

		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] += pDataPerChannel[i].pcd4_delta_xg0;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].pwr4_xg0)/4));
		}
		uiPrintf("|\n");
    	if(mode != MODE_11A) {
			uiPrintf("               ");		
		}
		
		for(i = k; i < (k + i_end); i++) {
			pcdacValues[i] = 63;
			uiPrintf("|  %02d  %6.2f  ", pcdacValues[i],	((float)(pDataPerChannel[i].maxPower_t4)/4));
		}
		uiPrintf("|\n");
		
    	if(mode == MODE_11A) {
			uiPrintf("|              |              |              |              |              |\n");	
		}
		else {
    		uiPrintf("               |              |              |              |\n");	
		}

		if(numXpdGain > 1) {
    		if(mode == MODE_11A) {
				uiPrintf("| XPD_Gain %2d  |              |              |              |              |\n", 
					xpdGainMapping[xpdGainValues[1]]);	
			}
			else {
    			uiPrintf("               | XPD_Gain %2d  |              |              |\n",
					xpdGainMapping[xpdGainValues[1]]);	
			}
	    	if(mode != MODE_11A) {
				uiPrintf("               ");		
			}
			for(i = k; i < (k + i_end); i++) {
				uiPrintf("|  %02d  %6.2f  ", 20,	((float)(pDataPerChannel[i].pwr1_xg3)/4));
			}
			uiPrintf("|\n");
	    	if(mode != MODE_11A) {
				uiPrintf("               ");		
			}
			for(i = k; i < (k + i_end); i++) {
				uiPrintf("|  %02d  %6.2f  ", 35,	((float)(pDataPerChannel[i].pwr2_xg3)/4));
			}
			uiPrintf("|\n");
	    	if(mode != MODE_11A) {
				uiPrintf("               ");		
			}
			for(i = k; i < (k + i_end); i++) {
				uiPrintf("|  %02d  %6.2f  ", 63,	((float)(pDataPerChannel[i].pwr3_xg3)/4));
			}
			uiPrintf("|\n");
		}
		if(mode == MODE_11A) {
			uiPrintf("|==============|==============|==============|==============|==============|\n");
		} else {
			uiPrintf("               |==============|==============|==============|\n");
		}
	}

}

void printEepromStruct_16K
(
 A_UINT32	devNum,
 A_UINT32	mode
)
{
	void				*pTempPtr;
	MDK_EEP_HEADER_INFO		*pHeaderPtr;	//need to keep a copy of header pointer for later
	A_UINT16 testGroups[MAX_NUM_CTL];

	art_GetEepromStruct(devNum, EEP_HEADER_16K, &pTempPtr);
	pHeaderPtr = (MDK_EEP_HEADER_INFO *)pTempPtr; 
	printHeaderInfo_16K(pHeaderPtr, mode);
	//take a copy of the NUM_CTL test groups for later
	memcpy(testGroups, pHeaderPtr->testGroups, sizeof(A_UINT16) * pHeaderPtr->numCtl);
	uiPrintf("\nPress any key to continue\n");
	while(!kbhit());
	getch();

	if((pHeaderPtr->majorVersion ==3) ||
		((pHeaderPtr->majorVersion == 4) &&(pHeaderPtr->eepMap == 0))){
		art_GetEepromStruct(devNum, EEP_CHANNEL_INFO_16K, &pTempPtr);
		printChannelInfo_16K((MDK_PCDACS_ALL_MODES *)pTempPtr, mode);
	}
	else if(pHeaderPtr->majorVersion ==4) {
		art_GetEepromStruct(devNum, EEP_GEN3_CHANNEL_INFO, &pTempPtr);
		printfChannelInfo_gen3((EEPROM_FULL_DATA_STRUCT_GEN3 *)pTempPtr, mode);

	}
	else {
		uiPrintf("ERROR: EEPROM version number NOT supported for displaying channel info\n");
	}
	uiPrintf("\nPress any key to continue\n");
	while(!kbhit());
	getch();

	art_GetEepromStruct(devNum, EEP_TRGT_POWER_16K, &pTempPtr);
	printTargetPowerInfo_16K((MDK_TRGT_POWER_ALL_MODES *)pTempPtr, mode);
	uiPrintf("\nPress any key to continue\n");
	while(!kbhit());
	getch();

	art_GetEepromStruct(devNum, EEP_RD_POWER_16K, &pTempPtr);
	printRDEdges_16K((MDK_RD_EDGES_POWER *)pTempPtr, testGroups, mode, pHeaderPtr->numCtl, pHeaderPtr->minorVersion);
	uiPrintf("\nPress any key to continue\n");
	while(!kbhit());
	getch();
	return;
}