cal_gen6.c

Atheros AP Test with Agilent N4010A source code

    ar6000EepromDump(devNum, (AR6K_EEPROM *)pTempPtr);
    return;
}

/**************************************************************
 * ar6000EepromDump
 *
 * Produce a formatted dump of the EEPROM structure
 */
void ar6000EepromDump(A_UINT32 devNum, AR6K_EEPROM *ar6kEep)
{
    A_UINT16          i, j, k;
    BASE_EEP_HEADER   *pBase;
    MODAL_EEP_HEADER  *pModal;
    CAL_TARGET_POWER  *pPowerInfo;
    CAL_DATA_PER_FREQ *pDataPerChannel;
    A_UINT8           noMoreSpurs;
    A_UINT8           *pChannel;
    A_UINT16          *pSpurData;
    A_UINT16          channelCount, channelRowCnt, vpdCount, rowEndsAtChan;
    A_UINT16          xpdGainMapping[] = {0, 1, 2, 4};
    A_UINT16          xpdGainValues[AR6000_NUM_PD_GAINS], numXpdGain = 0, xpdMask;
    A_UINT16          numPowers, ratePrint, numChannels, tempFreq;
    const static char *sRatePrint[2][4] = {
      {"     6-24     ", "      36      ", "      48      ", "      54      "},
      {"       1      ", "       2      ", "     5.5      ", "      11      "}
    };
    const static char *sTargetPowerMode[3] = {
      "11A OFDM", "11G CCK ", "11G OFDM"
    };
    const static char *sCtlType[5] = {
        "[ 11A base mode ]",
        "[ 11B base mode ]",
        "[ 11G base mode ]",
        "[ UNKNOWN       ]"
    };

    //assert(pEeprom);

    /* Print Header info */
    pBase = &(ar6kEep->baseEepHeader);
    uiPrintf("\n");
    uiPrintf(" =======================Header Information======================\n");
    uiPrintf(" |  Major Version           %2d  |  Minor Version           %2d  |\n",
             pBase->version >> 12, pBase->version & 0xFFF);
    uiPrintf(" |-------------------------------------------------------------|\n");
    uiPrintf(" |  Checksum           0x%04X   |  Regulatory Domain  0x%04X   |\n",
             pBase->checksum, pBase->regDmn);
    uiPrintf(" |  MacAddress: 0x%02X:%02X:%02X:%02X:%02X:%02X                            |\n",
             pBase->macAddr[0], pBase->macAddr[1], pBase->macAddr[2],
             pBase->macAddr[3], pBase->macAddr[4], pBase->macAddr[5]);
    uiPrintf(" |  OpFlags: 11A %d, 11G %d                                      |\n",
             (pBase->opFlags & AR6000_OPFLAGS_11A) || 0, (pBase->opFlags & AR6000_OPFLAGS_11G) || 0);

    uiPrintf(" |  Customer Data in hex                                       |\n");
    uiPrintf(" |= ");
    for (i = 0; i < 16; i++) {
        uiPrintf("%02X ", pBase->custData[i]);
    }
    uiPrintf("          =|\n |= ");
    for (i = 16; i < 30; i++) {
        uiPrintf("%02X ", pBase->custData[i]);
    }
    uiPrintf("          =|\n");

    /* Print Modal Header info */
    for (i = 0; i < 2; i++) {
        pModal = &(ar6kEep->modalHeader[i]);
        if (i == 0) {
            uiPrintf(" |======================11A Modal Header=======================|\n");
        } else {
            uiPrintf(" |======================11G Modal Header=======================|\n");
        }
        uiPrintf(" |  Ant Control 0   0x%08lX  |  Ant Control 1   0x%08lX  |\n",
                 pModal->antCtrl[0], pModal->antCtrl[1]);
        uiPrintf(" |  Antenna Control Idle   %3d  |  Antenna Gain           %3d  |\n",
                 pModal->antCtrl0, pModal->antennaGain);
        uiPrintf(" |  Switch Settling        %3d  |  TxRxAttenuation        %3d  |\n",
                 pModal->switchSettling, pModal->txRxAtten);
        uiPrintf(" |  RxTxMargin             %3d  |  adc desired size       %3d  |\n",
                 pModal->rxTxMargin, pModal->adcDesiredSize);
        uiPrintf(" |  pga desired size       %3d  |  tx end to xlna on      %3d  |\n",
                 pModal->pgaDesiredSize, pModal->txEndToXlnaOn);
        uiPrintf(" |  xlna gain              %3d  |  tx end to xpa off      %3d  |\n",
                 pModal->xlnaGain, pModal->txEndToXpaOff);
        uiPrintf(" |  tx frame to xpa on     %3d  |  thresh62               %3d  |\n",
                 pModal->txFrameToXpaOn, pModal->thresh62);
        uiPrintf(" |  noise floor threshold  %3d  |  Xpd Gain Mask 0x%X | Xpd %2d  |\n",
                 pModal->noiseFloorThresh, pModal->xpdGain, pModal->xpd);
        uiPrintf(" |  IQ Cal I               %3d  |  IQ Cal Q               %3d  |\n",
                 pModal->iqCalI, pModal->iqCalQ);
    }
    uiPrintf(" |=============================================================|\n");

    /* Print spur data 
    uiPrintf("=======================Spur Information======================\n");
    for (i = 0; i < 2; i++) {
        if (i == 0) {
            uiPrintf("| 11A Spurs in MHz                                          |\n");
        } else {
            uiPrintf("| 11G Spurs in MHz                                          |\n");
        }
        pSpurData = ar6kEep->spurChans[i];
        noMoreSpurs = 0;
        for (j = 0; j < AR6000_EEPROM_MODAL_SPURS; j++) {
            if ((pSpurData[j] == NO_SPUR) || noMoreSpurs) {
                noMoreSpurs = 1;
                uiPrintf("|  NO SPUR  ");
            } else {
                uiPrintf("|   %4d.%1d  ", SPUR_TO_KHZ(i, pSpurData[j])/1000,
                         (SPUR_TO_KHZ(i, pSpurData[j])/100) % 10);
            }
        }
        uiPrintf("|\n");
    } */
    uiPrintf("|===========================================================|\n");

    /* Print calibration info */
    for (i = 0; i < 2; i++) {
        if (i == 0) {
            pDataPerChannel = ar6kEep->calPierData11A;
            numChannels = AR6000_NUM_11A_CAL_PIERS;
            pChannel = ar6kEep->calFreqPier11A;
        } else {
            pDataPerChannel = ar6kEep->calPierData11G;
            numChannels = AR6000_NUM_11G_CAL_PIERS;
            pChannel = ar6kEep->calFreqPier11G;
        }
        xpdMask = ar6kEep->modalHeader[i].xpdGain;

        numXpdGain = 0;

        /* Calculate the value of xpdgains from the xpdGain Mask */
        for (j = 1; j <= AR6000_PD_GAINS_IN_MASK; j++) {
            if ((xpdMask >> (AR6000_PD_GAINS_IN_MASK - j)) & 1) {
                if (numXpdGain >= AR6000_NUM_PD_GAINS) {
                    assert(0);
                    break;
                }
                xpdGainValues[numXpdGain++] = AR6000_PD_GAINS_IN_MASK - j;
            }
        }
        
		uiPrintf("====================Power Calibration Information===========================\n");
	    for (channelRowCnt = 0; channelRowCnt < numChannels; channelRowCnt += 5) {
			A_UINT16 p = channelRowCnt+5;
             rowEndsAtChan = A_MIN( numChannels, p );
			//printf(">>>>>rowEndAtChan :%2u  %2u  %2u\n",rowEndsAtChan , numChannels , channelRowCnt+5);
			uiPrintf("============Power Calibration Information========== :%d\n",rowEndsAtChan );
	        for (channelCount = channelRowCnt; channelCount < rowEndsAtChan; channelCount++) {
                uiPrintf("|     %04d     ",  (i == 0) ?
                    fbin2freq(pChannel[channelCount]) : fbin2freq_2p4(pChannel[channelCount]));
            }
	        uiPrintf("|\n|==============|==============|==============|==============|==============|\n");
	
            for (channelCount = channelRowCnt; channelCount < rowEndsAtChan; channelCount++) {
                uiPrintf("|pdadc pwr(dBm)");
            }
            uiPrintf("|\n");

            uiPrintf("|              |              |              |              |              |\n");
            uiPrintf("| PD_Gain %2d   |              |              |              |              |\n",
                     xpdGainMapping[xpdGainValues[0]]);
			
		
            for (vpdCount = 0; vpdCount < 4; vpdCount++) {
                for (channelCount = channelRowCnt; channelCount < rowEndsAtChan; channelCount++) {
                    uiPrintf("|  %02d   %2d.%02d  ", pDataPerChannel[channelCount].vpdPdg0[vpdCount],
                             pDataPerChannel[channelCount].pwrPdg0[vpdCount] / 4,
                             (pDataPerChannel[channelCount].pwrPdg0[vpdCount] % 4) * 25);
                }
                uiPrintf("|\n");
            }
            uiPrintf("|              |              |              |              |              |\n");
            uiPrintf("|              |              |              |              |              |\n");
            uiPrintf("| PD_Gain %2d   |              |              |              |              |\n",
                     xpdGainMapping[xpdGainValues[1]]);
	
            for (vpdCount = 0; vpdCount < 5; vpdCount++) {
                for (channelCount = channelRowCnt; channelCount < rowEndsAtChan; channelCount++) {
                    uiPrintf("|  %02d   %2d.%02d  ", pDataPerChannel[channelCount].vpdPdg1[vpdCount],
                             pDataPerChannel[channelCount].pwrPdg1[vpdCount] / 4,
                             (pDataPerChannel[channelCount].pwrPdg1[vpdCount] % 4) * 25);
                }
                uiPrintf("|\n");
            }
	
            uiPrintf("|              |              |              |              |              |\n");
            uiPrintf("|==============|==============|==============|==============|==============|\n");
        }

        uiPrintf("|\n");
    }


    /* Print Target Powers */
    for (i = 0; i < 3; i++) {
        if (i == 0) {
            pPowerInfo = ar6kEep->calTargetPower11A;
            numPowers = AR6000_NUM_11A_TARGET_POWERS;
            ratePrint = 0;
        } else if (i == 1) {
            pPowerInfo = ar6kEep->calTargetPower11B;
            numPowers = AR6000_NUM_11B_TARGET_POWERS;
            ratePrint = 1;
        } else {
            pPowerInfo = ar6kEep->calTargetPower11G;
            numPowers = AR6000_NUM_11G_TARGET_POWERS;
            ratePrint = 0;
        }
        uiPrintf("============================Target Power Info===============================\n");
        for (j = 0; j < numPowers; j+=4) {
            uiPrintf("|   %s   ", sTargetPowerMode[i]);
            for (k = j; k < A_MIN(j + 4, numPowers); k++) {
                uiPrintf("|     %04d     ", (i == 0) ?
                    fbin2freq(pPowerInfo[k].bChannel) : fbin2freq_2p4(pPowerInfo[k].bChannel));
            }
            uiPrintf("|\n");
            uiPrintf("|==============|==============|==============|==============|==============|\n");

            uiPrintf("|%s", sRatePrint[ratePrint][0]);
            for (k = j; k < A_MIN(j + 4, numPowers); k++) {
                uiPrintf("|     %2d.%d     ", pPowerInfo[k].tPow6to24 / 2,
                         (pPowerInfo[k].tPow6to24 % 2) * 5);
            }
            uiPrintf("|\n");
            uiPrintf("|%s", sRatePrint[ratePrint][1]);
            for (k = j; k < A_MIN(j + 4, numPowers); k++) {
                uiPrintf("|     %2d.%d     ", pPowerInfo[k].tPow36 / 2,
                         (pPowerInfo[k].tPow36 % 2) * 5);
            }
            uiPrintf("|\n");

            uiPrintf("|%s", sRatePrint[ratePrint][2]);
            for (k = j; k < A_MIN(j + 4, numPowers); k++) {
                uiPrintf("|     %2d.%d     ", pPowerInfo[k].tPow48 / 2,
                         (pPowerInfo[k].tPow48 % 2) * 5);
            }
            uiPrintf("|\n");

            uiPrintf("|%s", sRatePrint[ratePrint][3]);
            for (k = j; k < A_MIN(j + 4, numPowers); k++) {
                uiPrintf("|     %2d.%d     ", pPowerInfo[k].tPow54 / 2,
                         (pPowerInfo[k].tPow54 % 2) * 5);
            }
            uiPrintf("|\n");
            uiPrintf("|==============|==============|==============|==============|==============|\n");
        }
    }
    uiPrintf("\n");

    /* Print Band Edge Powers */
    uiPrintf("=======================Test Group Band Edge Power========================\n");
    for (i = 0; (ar6kEep->ctlIndex[i] != 0) && (i < AR6000_NUM_CTLS); i++) {
        uiPrintf("|                                                                       |\n");
        uiPrintf("| CTL: 0x%02x %s                                           |\n",
                 ar6kEep->ctlIndex[i], sCtlType[ar6kEep->ctlIndex[i] & 0x3]);
        uiPrintf("|=======|=======|=======|=======|=======|=======|=======|=======|=======|\n");

        uiPrintf("| edge  ");
        for (j = 0; j < AR6000_NUM_BAND_EDGES; j++) {
            if (ar6kEep->ctlData[i].ctlEdges[j].bChannel == AR6000_BCHAN_UNUSED) {
                uiPrintf("|  --   ");
            } else {
                if(((ar6kEep->ctlIndex[i] & 0x7) == 0) ||
                    ((ar6kEep->ctlIndex[i] & 0x7) == 0x3)  ){ //turbo mode
                    tempFreq = fbin2freq(ar6kEep->ctlData[i].ctlEdges[j].bChannel);
                }
                else {
                    tempFreq = fbin2freq_2p4(ar6kEep->ctlData[i].ctlEdges[j].bChannel);
               }

               uiPrintf("| %04d  ", tempFreq);
            }
        }
        uiPrintf("|\n");
        uiPrintf("|=======|=======|=======|=======|=======|=======|=======|=======|=======|\n");

        uiPrintf("| power ");
        for (j = 0; j < AR6000_NUM_BAND_EDGES; j++) {
            if (ar6kEep->ctlData[i].ctlEdges[j].bChannel == AR6000_BCHAN_UNUSED) {
                uiPrintf("|  --   ");
            } else {
                uiPrintf("| %2d.%d  ", ar6kEep->ctlData[i].ctlEdges[j].tPower / 2,
                    (ar6kEep->ctlData[i].ctlEdges[j].tPower % 2) * 5);
            }
        }
        uiPrintf("|\n");
        uiPrintf("|=======|=======|=======|=======|=======|=======|=======|=======|=======|\n");

        uiPrintf("| flag  ");
        for (j = 0; j < AR6000_NUM_BAND_EDGES; j++) {
            if (ar6kEep->ctlData[i].ctlEdges[j].bChannel == AR6000_BCHAN_UNUSED) {
                uiPrintf("|  --   ");
            } else {
                uiPrintf("|   %1d   ", ar6kEep->ctlData[i].ctlEdges[j].flag);
            }
        }
        uiPrintf("|\n");
        uiPrintf("=========================================================================\n");
    }

}