eeprom.c

Atheros wifi driver source code

        
        fprintf(fd ,"               |              |              |              |\n");    
        fprintf(fd ,"               ");
        for (i = 0; i < 3; i++) {
            fprintf(fd ,"| pcdac min %02d ", pDataPerChannel[i].pcdacMin);
        }
        fprintf(fd ,"|\n");
        fprintf(fd ,"               ");
        for (i = 0; i < 3; i++) {
            fprintf(fd ,"| pcdac max %02d ", pDataPerChannel[i].pcdacMax);
        }
        fprintf(fd ,"|\n");
        fprintf(fd ,"               |==============|==============|==============|\n");

    }
}

static void
printExpnPower5112(FILE *fd, const HAL_EEPROM *ee, const EEPROM_POWER_EXPN_5112 *pExpnPower, u_int mode)
{
    u_int16_t        i, j=0, kk;
    u_int16_t        singleXpd = 0xDEAD;
    const char       *modeString[3] = {"11a", "11b", "11g"};
    const char	     *rule;

    if (pExpnPower->xpdMask != 0x9) {
        for (j = 0; j < NUM_XPD_PER_CHANNEL; j++) {
            if (pExpnPower->xpdMask == (1 << j)) {
                singleXpd = j;
                break;
            }
        }
    } 

    if (pExpnPower->xpdMask == 0x9) {
        fprintf(fd ,"======================5112 Power Calibration Information========================\n");

        fprintf(fd ,"| XPD_Gain_mask = 0x%02x              | Number of channels for mode %s: %2d      |\n",
            pExpnPower->xpdMask, modeString[mode], pExpnPower->numChannels);
        rule = "|======|========|========|========|========|========|========|========|========|";
    } else {
        fprintf(fd ,"=========5112 Power Calibration Information==========\n");
	fprintf(fd ,"| XPD_Gain_mask     0x%02x | Number of channels    %2d |\n",
            pExpnPower->xpdMask, pExpnPower->numChannels);
	fprintf(fd ,"| XPD_GAIN            %2d |                          |\n", j);
	rule = "|======|========|========|========|========|========|";
    }

    /* print the frequency values */
    fprintf(fd ,"%s\n", rule);
    fprintf(fd ,"| freq |  pwr1  |  pwr2  |  pwr3  |  pwr4  |");
    if (pExpnPower->xpdMask == 0x9) {
        fprintf(fd ," pwr1_x3| pwr2_x3| pwr3_x3| maxPow |\n");
        fprintf(fd ,"|      | [pcd]  | [pcd]  | [pcd]  | [pcd]  | [pcd]  | [pcd]  | [pcd]  |        |\n");
    } else {
        fprintf(fd ," maxPow |\n");
        fprintf(fd ,"|      | [pcd]  | [pcd]  | [pcd]  | [pcd]  |        |\n");
    }

    for (i = 0; i < pExpnPower->numChannels; i++) {
        fprintf(fd ,"%s\n", rule);
        fprintf(fd ,"| %4d |", pExpnPower->pChannels[i]);
        if (pExpnPower->xpdMask != 0x9) {
            j = singleXpd;
        } else {
            j = 0;
        }
        for (kk=0; kk < pExpnPower->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
            fprintf(fd ," %2d.%02d  |", (pExpnPower->pDataPerChannel[i].pDataPerXPD[j].pwr_t4[kk] / 4),
                (pExpnPower->pDataPerChannel[i].pDataPerXPD[j].pwr_t4[kk] % 4) * 25);
        }
        if (pExpnPower->xpdMask == 0x9) {
            for (kk=0; kk < pExpnPower->pDataPerChannel[i].pDataPerXPD[3].numPcdacs; kk++) {
                fprintf(fd ," %2d.%02d  |", pExpnPower->pDataPerChannel[i].pDataPerXPD[3].pwr_t4[kk] / 4,
                    (pExpnPower->pDataPerChannel[i].pDataPerXPD[3].pwr_t4[kk] % 4) * 25);
            }
        }
        fprintf(fd ," %2d.%02d  |\n", pExpnPower->pDataPerChannel[i].maxPower_t4 / 4,
            (pExpnPower->pDataPerChannel[i].maxPower_t4 % 4) * 25);
        fprintf(fd ,"|      |");        
        for (kk=0; kk<pExpnPower->pDataPerChannel[i].pDataPerXPD[j].numPcdacs; kk++) {
            fprintf(fd ,"  [%2d]  |", pExpnPower->pDataPerChannel[i].pDataPerXPD[j].pcdac[kk]);
        }
        if (pExpnPower->xpdMask == 0x9) {
            for (kk=0; kk<pExpnPower->pDataPerChannel[i].pDataPerXPD[3].numPcdacs; kk++) {
                fprintf(fd ,"  [%2d]  |", pExpnPower->pDataPerChannel[i].pDataPerXPD[3].pcdac[kk]);
            }
        }
        fprintf(fd ,"        |\n");     
    }
    fprintf(fd ,"%s\n", rule);
}

static void
printTargetPowerInfo(FILE *fd, const HAL_EEPROM *ee, u_int mode)
{
    u_int16_t i, k;
    const TRGT_POWER_INFO  *pPowerInfo;

    fprintf(fd ,"\n");
    if (mode == headerInfo11A) {
        pPowerInfo = ee->ee_trgtPwr_11a;
        fprintf(fd ,"============================Target Power Info===============================\n");
    
        for (k = 0; k < 8; k+=4) {
            fprintf(fd ,"|     rate     ");
            for (i = k; i < k + 4; i++) {
                fprintf(fd ,"|     %04d     ", pPowerInfo[i].testChannel);
            }
            fprintf(fd ,"|\n");
            
            fprintf(fd ,"|==============|==============|==============|==============|==============|\n");

            fprintf(fd ,"|     6-24     ");
            for (i = k; i < k + 4; i++) {
                fprintf(fd ,"|     %2d.%d     ", pPowerInfo[i].twicePwr6_24 / 2,
                    (pPowerInfo[i].twicePwr6_24 % 2) * 5);
            }
            fprintf(fd ,"|\n");

            fprintf(fd ,"|      36      ");
            for (i = k; i < k + 4; i++) {
                fprintf(fd ,"|     %2d.%d     ", pPowerInfo[i].twicePwr36 / 2,
                    (pPowerInfo[i].twicePwr36 % 2) * 5);
            }
            fprintf(fd ,"|\n");

            fprintf(fd ,"|      48      ");
            for (i = k; i < k + 4; i++) {
                fprintf(fd ,"|     %2d.%d     ", pPowerInfo[i].twicePwr48 / 2,
                    (pPowerInfo[i].twicePwr48 % 2) * 5);
            }
            fprintf(fd ,"|\n");

            fprintf(fd ,"|      54      ");
            for (i = k; i < k + 4; i++) {
                fprintf(fd ,"|     %2d.%d     ", pPowerInfo[i].twicePwr54 / 2,
                    (pPowerInfo[i].twicePwr54 % 2) * 5);
            }

            fprintf(fd ,"|\n");
            fprintf(fd ,"|==============|==============|==============|==============|==============|\n");
        }
    } else {
        if (mode == headerInfo11B) {
            pPowerInfo = ee->ee_trgtPwr_11b;
        } else {
            pPowerInfo = ee->ee_trgtPwr_11g;
        }
        fprintf(fd ,"=============Target Power Info================\n");

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

        if (mode == headerInfo11B) {
            fprintf(fd ,"|      1       ");
        } else {
            fprintf(fd ,"|     6-24     ");
        }

        for (i = 0; i < 2; i++) {
            fprintf(fd ,"|     %2d.%d     ", pPowerInfo[i].twicePwr6_24 / 2,
                (pPowerInfo[i].twicePwr6_24 % 2) * 5);
        }
        fprintf(fd ,"|\n");

        if (mode == headerInfo11B) {
            fprintf(fd ,"|      2       ");
        } else {
            fprintf(fd ,"|      36      ");
        }
        for (i = 0; i < 2; i++) {
            fprintf(fd ,"|     %2d.%d     ", pPowerInfo[i].twicePwr36 / 2,
                (pPowerInfo[i].twicePwr36 % 2) * 5);
        }
        fprintf(fd ,"|\n");

        if (mode == headerInfo11B) {
            fprintf(fd ,"|      5.5     ");
        } else {
            fprintf(fd ,"|      48      ");
        }
        for (i = 0; i < 2; i++) {
            fprintf(fd ,"|     %2d.%d     ", pPowerInfo[i].twicePwr48 / 2,
                (pPowerInfo[i].twicePwr48 % 2) * 5);
        }
        fprintf(fd ,"|\n");

        if (mode == headerInfo11B) {
            fprintf(fd ,"|      11      ");
        } else {
            fprintf(fd ,"|      54      ");
        }
        for (i = 0; i < 2; i++) {
            fprintf(fd ,"|     %2d.%d     ", pPowerInfo[i].twicePwr54 / 2,
                (pPowerInfo[i].twicePwr54 % 2) * 5);
        }

        fprintf(fd ,"|\n");
        fprintf(fd ,"|==============|==============|==============|\n");

    }
}

static void
printRDEdges(FILE *fd, const HAL_EEPROM *ee,
	    const RD_EDGES_POWER *pRdEdgePwrInfo, const u_int16_t *pTestGroups,
            u_int mode, const u_int16_t maxNumCtl)
{
    u_int16_t version = ee->ee_version;
    u_int16_t    i=0, j;
    u_int16_t    ctlMode = 0;
    const static char *ctlType[4] = {
        "11a base mode ] ",
        "11b mode ]      ",
        "11g mode ]      ",
        "11a TURBO mode ]"
    };

    fprintf(fd ,"\n");
    fprintf(fd ,"=======================Test Group Band Edge Power========================\n");
    while ((pTestGroups[i] != 0) && (i < maxNumCtl)) {
        switch(pTestGroups[i] & 0x3) {
        case 0: 
        case 3:
            ctlMode = headerInfo11A;
            break;
        case 1: 
            ctlMode = headerInfo11B;
            break;
        case 2: 
            ctlMode = headerInfo11G;
            break;
        }
        if (mode != ctlMode) {
            i++;
            pRdEdgePwrInfo += NUM_EDGES;
            continue;
        }
        fprintf(fd ,"|                                                                       |\n");
        fprintf(fd ,"| CTL: 0x%02x   [ 0x%x %s", pTestGroups[i] & 0xff, pTestGroups[i], ctlType[pTestGroups[i] & 0x3]);
        
        fprintf(fd ,"                                   |\n");
        fprintf(fd ,"|=======|=======|=======|=======|=======|=======|=======|=======|=======|\n");

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

        fprintf(fd ,"|\n");
        fprintf(fd ,"|=======|=======|=======|=======|=======|=======|=======|=======|=======|\n");
        fprintf(fd ,"| power ");
        for (j = 0; j < NUM_EDGES; j++) {
            if (pRdEdgePwrInfo[j].rdEdge == 0) {
                fprintf(fd ,"|  --   ");
            } else {
                fprintf(fd ,"| %2d.%d  ", pRdEdgePwrInfo[j].twice_rdEdgePower / 2,
                    (pRdEdgePwrInfo[j].twice_rdEdgePower % 2) * 5);
            }
        }

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

            fprintf(fd ,"|\n");
        }
        fprintf(fd ,"=========================================================================\n");
        i++;
        pRdEdgePwrInfo += NUM_EDGES;
    }
}

static void
printChannelInfo2413(FILE *fd, const HAL_EEPROM *ee, const RAW_DATA_STRUCT_2413 *pRaw)
{
    u_int16_t            i, j, k = 0;
    const char *rule = "|========|======|========|========|========|========|========|";

    fprintf(fd ,"\n");

    fprintf(fd ,"=========2413 Power Calibration Information===================\n");
    fprintf(fd ,"| XPD_Gain_mask     0x%02x | Number of channels    %2d |        |\n",
            pRaw->xpd_mask, pRaw->numChannels);

    /* print the frequency values */
    fprintf(fd ,"%s\n", rule);
    fprintf(fd ,"|  freq  | pd   |  pwr1  |  pwr2  |  pwr3  |  pwr4  |  pwr5  |");
    fprintf(fd ,"\n");
    fprintf(fd ,"| maxpow | gain | [Vpd]  | [Vpd]  | [Vpd]  | [Vpd]  | [Vpd]  |\n");

    for (i = 0; i < pRaw->numChannels; i++) {
        fprintf(fd ,"%s\n", rule);
        fprintf(fd ,"|  %4d  |", pRaw->pChannels[i]);
        for (j=0; j < pRaw->pDataPerChannel[i].numPdGains; j++) {
	    if (j == 1)
		fprintf(fd ,"| %2d.%02d  |", pRaw->pDataPerChannel[i].maxPower_t4 / 4,
		    (pRaw->pDataPerChannel[i].maxPower_t4 % 4) * 25);
	    else if (j > 0)
		fprintf(fd ,"|         |");
	    fprintf(fd, " %4d |", pRaw->pDataPerChannel[i].pDataPerPDGain[j].pd_gain);
	    for (k=0; k < pRaw->pDataPerChannel[i].pDataPerPDGain[j].numVpd; k++)
		    fprintf(fd ," %2d.%02d  |", (pRaw->pDataPerChannel[i].pDataPerPDGain[j].pwr_t4[k] / 4),
			(pRaw->pDataPerChannel[i].pDataPerPDGain[j].pwr_t4[k] % 4) * 25);
	    for (; k<NUM_POINTS_LAST_PDGAIN; k++)
		    fprintf(fd ,"        |");
	    fprintf(fd, "\n");
            fprintf(fd ,"|        |      |");
	    for (k=0; k < pRaw->pDataPerChannel[i].pDataPerPDGain[j].numVpd; k++)
		    fprintf(fd ," [%3d]  |", pRaw->pDataPerChannel[i].pDataPerPDGain[j].Vpd[k]);
	    for (; k<NUM_POINTS_LAST_PDGAIN; k++)
		    fprintf(fd ,"        |");
	    fprintf(fd, "\n");
        }
    }
    fprintf(fd ,"%s\n", rule);
}

static void
printEepromStruct(FILE *fd, HAL_EEPROM *ee, u_int mode)
{
    switch(mode) {
    case headerInfo11A:
	if (!ee->ee_Amode)
	    return;
        break;
    case headerInfo11G:
	if (!ee->ee_Gmode)
	    return;
        break;
    case headerInfo11B:
	if (!ee->ee_Bmode)
	    return;
        break;
    }
    printHeaderInfo(fd, ee, mode);
    if (ee->ee_version >= AR_EEPROM_VER5_0) {
        printChannelInfo2413(fd, ee, &ee->ee_rawDataset2413[mode]);
    } else if (ee->ee_version >= AR_EEPROM_VER4_0) {
	EEPROM_POWER_EXPN_5112 *exp;

	exp = &ee->ee_modePowerArray5112[mode];
	atd.ad_id = HAL_DIAG_EEPROM_EXP_11A+mode;
	atd.ad_out_size = roundup(sizeof(u_int16_t) * exp->numChannels,
				sizeof(u_int32_t)) +
		      sizeof(EXPN_DATA_PER_CHANNEL_5112) * exp->numChannels;
	atd.ad_out_data = (caddr_t) malloc(atd.ad_out_size);
	if (ioctl(s, SIOCGATHDIAG, &atd) < 0)
		err(1, atd.ad_name);
	exp->pChannels = (void *) atd.ad_out_data;
	exp->pDataPerChannel = (void *)((char *)atd.ad_out_data +
		roundup(sizeof(u_int16_t) * exp->numChannels, sizeof(u_int32_t)));
        printExpnPower5112(fd, ee, exp, mode);
	free(atd.ad_out_data);
    } else {
        printChannelInfo(fd, ee, mode);
    }
    printTargetPowerInfo(fd, ee, mode);
    printRDEdges(fd, ee, ee->ee_rdEdgesPower, ee->ee_ctl, mode, ee->ee_numCtls);
}