| Current Path : /usr/src/tools/tools/ath/athprom/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //usr/src/tools/tools/ath/athprom/athprom.c |
/*-
* Copyright (c) 2008 Sam Leffler, Errno Consulting
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
* redistribution must be conditioned upon including a substantially
* similar Disclaimer requirement for further binary redistribution.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGES.
*
* $FreeBSD: release/9.1.0/tools/tools/ath/athprom/athprom.c 217680 2011-01-21 02:53:32Z adrian $
*/
#include "diag.h"
#include "ah.h"
#include "ah_internal.h"
#include "ah_eeprom_v1.h"
#include "ah_eeprom_v3.h"
#include "ah_eeprom_v14.h"
#define IS_VERS(op, v) (eeprom.ee_version op (v))
#include <getopt.h>
#include <errno.h>
#include <err.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#ifndef DIR_TEMPLATE
#define DIR_TEMPLATE "/usr/local/libdata/athprom"
#endif
struct ath_diag atd;
int s;
const char *progname;
union {
HAL_EEPROM legacy; /* format v3.x ... v5.x */
struct ar5416eeprom v14; /* 11n format v14.x ... */
} eep;
#define eeprom eep.legacy
#define eepromN eep.v14
static void parseTemplate(FILE *ftemplate, FILE *fd);
static uint16_t eeread(uint16_t);
static void eewrite(uint16_t, uint16_t);
static void
usage()
{
fprintf(stderr, "usage: %s [-i ifname] [-t pathname] [offset | offset=value]\n", progname);
exit(-1);
}
static FILE *
opentemplate(const char *dir)
{
char filename[PATH_MAX];
FILE *fd;
/* find the template using the eeprom version */
snprintf(filename, sizeof(filename), "%s/eeprom-%d.%d",
dir, eeprom.ee_version >> 12, eeprom.ee_version & 0xfff);
fd = fopen(filename, "r");
if (fd == NULL && errno == ENOENT) {
/* retry with just the major version */
snprintf(filename, sizeof(filename), "%s/eeprom-%d",
dir, eeprom.ee_version >> 12);
fd = fopen(filename, "r");
if (fd != NULL) /* XXX verbose */
warnx("Using template file %s", filename);
}
return fd;
}
int
main(int argc, char *argv[])
{
FILE *fd = NULL;
const char *ifname;
int c;
s = socket(AF_INET, SOCK_DGRAM, 0);
if (s < 0)
err(1, "socket");
ifname = getenv("ATH");
if (!ifname)
ifname = ATH_DEFAULT;
progname = argv[0];
while ((c = getopt(argc, argv, "i:t:")) != -1)
switch (c) {
case 'i':
ifname = optarg;
break;
case 't':
fd = fopen(optarg, "r");
if (fd == NULL)
err(-1, "Cannot open %s", optarg);
break;
default:
usage();
/*NOTREACHED*/
}
argc -= optind;
argv += optind;
strncpy(atd.ad_name, ifname, sizeof (atd.ad_name));
if (argc != 0) {
for (; argc > 0; argc--, argv++) {
uint16_t off, val, oval;
char line[256];
char *cp;
cp = strchr(argv[0], '=');
if (cp != NULL)
*cp = '\0';
off = (uint16_t) strtoul(argv[0], NULL, 0);
if (off == 0 && errno == EINVAL)
errx(1, "%s: invalid eeprom offset %s",
progname, argv[0]);
if (cp == NULL) {
printf("%04x: %04x\n", off, eeread(off));
} else {
val = (uint16_t) strtoul(cp+1, NULL, 0);
if (val == 0 && errno == EINVAL)
errx(1, "%s: invalid eeprom value %s",
progname, cp+1);
oval = eeread(off);
printf("Write %04x: %04x = %04x? ",
off, oval, val);
fflush(stdout);
if (fgets(line, sizeof(line), stdin) != NULL &&
line[0] == 'y')
eewrite(off, val);
}
}
} else {
atd.ad_id = HAL_DIAG_EEPROM;
atd.ad_out_data = (caddr_t) &eep;
atd.ad_out_size = sizeof(eep);
if (ioctl(s, SIOCGATHDIAG, &atd) < 0)
err(1, atd.ad_name);
if (fd == NULL) {
fd = opentemplate(DIR_TEMPLATE);
if (fd == NULL)
fd = opentemplate(".");
if (fd == NULL)
errx(-1, "Cannot locate template file for "
"v%d.%d EEPROM", eeprom.ee_version >> 12,
eeprom.ee_version & 0xfff);
}
parseTemplate(fd, stdout);
fclose(fd);
}
return 0;
}
static u_int16_t
eeread(u_int16_t off)
{
u_int16_t eedata;
atd.ad_id = HAL_DIAG_EEREAD | ATH_DIAG_IN | ATH_DIAG_DYN;
atd.ad_in_size = sizeof(off);
atd.ad_in_data = (caddr_t) &off;
atd.ad_out_size = sizeof(eedata);
atd.ad_out_data = (caddr_t) &eedata;
if (ioctl(s, SIOCGATHDIAG, &atd) < 0)
err(1, atd.ad_name);
return eedata;
}
static void
eewrite(uint16_t off, uint16_t value)
{
HAL_DIAG_EEVAL eeval;
eeval.ee_off = off;
eeval.ee_data = value;
atd.ad_id = HAL_DIAG_EEWRITE | ATH_DIAG_IN;
atd.ad_in_size = sizeof(eeval);
atd.ad_in_data = (caddr_t) &eeval;
atd.ad_out_size = 0;
atd.ad_out_data = NULL;
if (ioctl(s, SIOCGATHDIAG, &atd) < 0)
err(1, atd.ad_name);
}
#define MAXID 128
int lineno;
int bol;
int curmode = -1;
int curchan;
int curpdgain; /* raw pdgain index */
int curlpdgain; /* logical pdgain index */
int curpcdac;
int curctl;
int numChannels;
const RAW_DATA_STRUCT_2413 *pRaw;
const TRGT_POWER_INFO *pPowerInfo;
const DATA_PER_CHANNEL *pDataPerChannel;
const EEPROM_POWER_EXPN_5112 *pExpnPower;
int singleXpd;
static int
token(FILE *fd, char id[], int maxid, const char *what)
{
int c, i;
i = 0;
for (;;) {
c = getc(fd);
if (c == EOF)
return EOF;
if (!isalnum(c) && c != '_') {
ungetc(c, fd);
break;
}
if (i == maxid-1) {
warnx("line %d, %s too long", lineno, what);
break;
}
id[i++] = c;
}
id[i] = '\0';
if (i != 0)
bol = 0;
return i;
}
static int
skipto(FILE *fd, const char *what)
{
char id[MAXID];
int c;
for (;;) {
c = getc(fd);
if (c == EOF)
goto bad;
if (c == '.' && bol) { /* .directive */
if (token(fd, id, MAXID, ".directive") == EOF)
goto bad;
if (strcasecmp(id, what) == 0)
break;
continue;
}
if (c == '\\') { /* escape next character */
c = getc(fd);
if (c == EOF)
goto bad;
}
bol = (c == '\n');
if (bol)
lineno++;
}
return 0;
bad:
warnx("EOF with no matching .%s", what);
return EOF;
}
static int
skipws(FILE *fd)
{
int c, i;
i = 0;
while ((c = getc(fd)) != EOF && isblank(c))
i++;
if (c != EOF)
ungetc(c, fd);
if (i != 0)
bol = 0;
return 0;
}
static void
setmode(int mode)
{
EEPROM_POWER_EXPN_5112 *exp;
curmode = mode;
curchan = -1;
curctl = -1;
curpdgain = -1;
curlpdgain = -1;
curpcdac = -1;
switch (curmode) {
case headerInfo11A:
pPowerInfo = eeprom.ee_trgtPwr_11a;
pDataPerChannel = eeprom.ee_dataPerChannel11a;
break;
case headerInfo11B:
pPowerInfo = eeprom.ee_trgtPwr_11b;
pDataPerChannel = eeprom.ee_dataPerChannel11b;
break;
case headerInfo11G:
pPowerInfo = eeprom.ee_trgtPwr_11g;
pDataPerChannel = eeprom.ee_dataPerChannel11g;
break;
}
if (IS_VERS(<, AR_EEPROM_VER4_0)) /* nothing to do */
return;
if (IS_VERS(<, AR_EEPROM_VER5_0)) {
exp = &eeprom.ee_modePowerArray5112[curmode];
/* fetch indirect data*/
atd.ad_id = HAL_DIAG_EEPROM_EXP_11A+curmode;
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)));
pExpnPower = exp;
numChannels = pExpnPower->numChannels;
if (exp->xpdMask != 0x9) {
for (singleXpd = 0; singleXpd < NUM_XPD_PER_CHANNEL; singleXpd++)
if (exp->xpdMask == (1<<singleXpd))
break;
} else
singleXpd = 0;
} else if (IS_VERS(<, AR_EEPROM_VER14_2)) {
pRaw = &eeprom.ee_rawDataset2413[curmode];
numChannels = pRaw->numChannels;
}
}
int
nextctl(int start)
{
int i;
for (i = start; i < eeprom.ee_numCtls && eeprom.ee_ctl[i]; i++) {
switch (eeprom.ee_ctl[i] & 3) {
case 0: case 3:
if (curmode != headerInfo11A)
continue;
break;
case 1:
if (curmode != headerInfo11B)
continue;
break;
case 2:
if (curmode != headerInfo11G)
continue;
break;
}
return i;
}
return -1;
}
static void
printAntennaControl(FILE *fd, int ant)
{
fprintf(fd, "0x%02X", eeprom.ee_antennaControl[ant][curmode]);
}
static void
printEdge(FILE *fd, int edge)
{
const RD_EDGES_POWER *pRdEdgePwrInfo =
&eeprom.ee_rdEdgesPower[curctl*NUM_EDGES];
if (pRdEdgePwrInfo[edge].rdEdge == 0)
fprintf(fd, " -- ");
else
fprintf(fd, "%04d", pRdEdgePwrInfo[edge].rdEdge);
}
static void
printEdgePower(FILE *fd, int edge)
{
const RD_EDGES_POWER *pRdEdgePwrInfo =
&eeprom.ee_rdEdgesPower[curctl*NUM_EDGES];
if (pRdEdgePwrInfo[edge].rdEdge == 0)
fprintf(fd, " -- ");
else
fprintf(fd, "%2d.%d",
pRdEdgePwrInfo[edge].twice_rdEdgePower / 2,
(pRdEdgePwrInfo[edge].twice_rdEdgePower % 2) * 5);
}
static void
printEdgeFlag(FILE *fd, int edge)
{
const RD_EDGES_POWER *pRdEdgePwrInfo =
&eeprom.ee_rdEdgesPower[curctl*NUM_EDGES];
if (pRdEdgePwrInfo[edge].rdEdge == 0)
fprintf(fd, "--");
else
fprintf(fd, " %1d", pRdEdgePwrInfo[edge].flag);
}
static int16_t
getMaxPowerV5(const RAW_DATA_PER_CHANNEL_2413 *data)
{
uint32_t i;
uint16_t numVpd;
for (i = 0; i < MAX_NUM_PDGAINS_PER_CHANNEL; i++) {
numVpd = data->pDataPerPDGain[i].numVpd;
if (numVpd > 0)
return data->pDataPerPDGain[i].pwr_t4[numVpd-1];
}
return 0;
}
static void
printQuarterDbmPower(FILE *fd, int16_t power25dBm)
{
fprintf(fd, "%2d.%02d", power25dBm / 4, (power25dBm % 4) * 25);
}
static void
printHalfDbmPower(FILE *fd, int16_t power5dBm)
{
fprintf(fd, "%2d.%d", power5dBm / 2, (power5dBm % 2) * 5);
}
static void
printVpd(FILE *fd, int vpd)
{
fprintf(fd, "[%3d]", vpd);
}
static void
printPcdacValue(FILE *fd, int v)
{
fprintf(fd, "%2d.%02d", v / EEP_SCALE, v % EEP_SCALE);
}
static void
undef(const char *what)
{
warnx("%s undefined for version %d.%d format EEPROM", what,
eeprom.ee_version >> 12, eeprom.ee_version & 0xfff);
}
static int
pdgain(int lpdgain)
{
uint32_t mask;
int i, l = lpdgain;
if (IS_VERS(<, AR_EEPROM_VER5_0))
mask = pExpnPower->xpdMask;
else
mask = pRaw->xpd_mask;
for (i = 0; mask != 0; mask >>= 1, i++)
if ((mask & 1) && l-- == 0)
return i;
warnx("can't find logical pdgain %d", lpdgain);
return -1;
}
#define COUNTRY_ERD_FLAG 0x8000
#define WORLDWIDE_ROAMING_FLAG 0x4000
void
eevar(FILE *fd, const char *var)
{
#define streq(a,b) (strcasecmp(a,b) == 0)
#define strneq(a,b,n) (strncasecmp(a,b,n) == 0)
if (streq(var, "mode")) {
fprintf(fd, "%s",
curmode == headerInfo11A ? "11a" :
curmode == headerInfo11B ? "11b" :
curmode == headerInfo11G ? "11g" : "???");
} else if (streq(var, "version")) {
fprintf(fd, "%04x", eeprom.ee_version);
} else if (streq(var, "V_major")) {
fprintf(fd, "%2d", eeprom.ee_version >> 12);
} else if (streq(var, "V_minor")) {
fprintf(fd, "%2d", eeprom.ee_version & 0xfff);
} else if (streq(var, "earStart")) {
fprintf(fd, "%03x", eeprom.ee_earStart);
} else if (streq(var, "tpStart")) {
fprintf(fd, "%03x", eeprom.ee_targetPowersStart);
} else if (streq(var, "eepMap")) {
fprintf(fd, "%3d", eeprom.ee_eepMap);
} else if (streq(var, "exist32KHzCrystal")) {
fprintf(fd, "%3d", eeprom.ee_exist32kHzCrystal);
} else if (streq(var, "eepMap2PowerCalStart")) {
fprintf(fd , "%3d", eeprom.ee_eepMap2PowerCalStart);
} else if (streq(var, "Amode")) {
fprintf(fd , "%1d", eeprom.ee_Amode);
} else if (streq(var, "Bmode")) {
fprintf(fd , "%1d", eeprom.ee_Bmode);
} else if (streq(var, "Gmode")) {
fprintf(fd , "%1d", eeprom.ee_Gmode);
} else if (streq(var, "regdomain")) {
if ((eeprom.ee_regdomain & COUNTRY_ERD_FLAG) == 0)
fprintf(fd, "%03X ", eeprom.ee_regdomain >> 15);
else
fprintf(fd, "%-3dC", eeprom.ee_regdomain & 0xfff);
} else if (streq(var, "turbo2Disable")) {
fprintf(fd, "%1d", eeprom.ee_turbo2Disable);
} else if (streq(var, "turbo5Disable")) {
fprintf(fd, "%1d", eeprom.ee_turbo5Disable);
} else if (streq(var, "rfKill")) {
fprintf(fd, "%1d", eeprom.ee_rfKill);
} else if (streq(var, "disableXr5")) {
fprintf(fd, "%1d", eeprom.ee_disableXr5);
} else if (streq(var, "disableXr2")) {
fprintf(fd, "%1d", eeprom.ee_disableXr2);
} else if (streq(var, "turbo2WMaxPower5")) {
fprintf(fd, "%2d", eeprom.ee_turbo2WMaxPower5);
} else if (streq(var, "cckOfdmDelta")) {
fprintf(fd, "%2d", eeprom.ee_cckOfdmPwrDelta);
} else if (streq(var, "gainI")) {
fprintf(fd, "%2d", eeprom.ee_gainI[curmode]);
} else if (streq(var, "WWR")) {
fprintf(fd, "%1x",
(eeprom.ee_regdomain & WORLDWIDE_ROAMING_FLAG) != 0);
} else if (streq(var, "falseDetectBackoff")) {
fprintf(fd, "0x%02x", eeprom.ee_falseDetectBackoff[curmode]);
} else if (streq(var, "deviceType")) {
fprintf(fd, "%1x", eeprom.ee_deviceType);
} else if (streq(var, "switchSettling")) {
if (IS_VERS(<, AR_EEPROM_VER14_2))
fprintf(fd, "0x%02x", eeprom.ee_switchSettling[curmode]);
else
fprintf(fd, "%3d", eepromN.modalHeader[curmode].switchSettling);
} else if (streq(var, "adcDesiredSize")) {
if (IS_VERS(<, AR_EEPROM_VER14_2))
fprintf(fd, "%2d", eeprom.ee_adcDesiredSize[curmode]);
else
fprintf(fd, "%3d", eepromN.modalHeader[curmode].adcDesiredSize);
} else if (streq(var, "xlnaGain")) {
fprintf(fd, "0x%02x", eeprom.ee_xlnaGain[curmode]);
} else if (streq(var, "txEndToXLNAOn")) {
fprintf(fd, "0x%02x", eeprom.ee_txEndToXLNAOn[curmode]);
} else if (streq(var, "thresh62")) {
if (IS_VERS(<, AR_EEPROM_VER14_2))
fprintf(fd, "0x%02x", eeprom.ee_thresh62[curmode]);
else
fprintf(fd, "%3d", eepromN.modalHeader[curmode].thresh62);
} else if (streq(var, "txEndToRxOn")) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].txEndToRxOn);
} else if (streq(var, "txEndToXPAOff")) {
if (IS_VERS(<, AR_EEPROM_VER14_2))
fprintf(fd, "0x%02x", eeprom.ee_txEndToXPAOff[curmode]);
else
fprintf(fd, "%3d", eepromN.modalHeader[curmode].txEndToXpaOff);
} else if (streq(var, "txFrameToXPAOn")) {
if (IS_VERS(<, AR_EEPROM_VER14_2))
fprintf(fd, "0x%02x", eeprom.ee_txFrameToXPAOn[curmode]);
else
fprintf(fd, "%3d", eepromN.modalHeader[curmode].txEndToRxOn);
} else if (streq(var, "pgaDesiredSize")) {
if (IS_VERS(<, AR_EEPROM_VER14_2))
fprintf(fd, "%2d", eeprom.ee_pgaDesiredSize[curmode]);
else
fprintf(fd, "%3d", eepromN.modalHeader[curmode].pgaDesiredSize);
} else if (streq(var, "noiseFloorThresh")) {
fprintf(fd, "%3d", eeprom.ee_noiseFloorThresh[curmode]);
} else if (strneq(var, "noiseFloorThreshCh", 18)) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].noiseFloorThreshCh[atoi(var+18)]);
} else if (strneq(var, "xlnaGainCh", 10)) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].xlnaGainCh[atoi(var+10)]);
} else if (streq(var, "xgain")) {
fprintf(fd, "0x%02x", eeprom.ee_xgain[curmode]);
} else if (streq(var, "xpd")) {
if (IS_VERS(<, AR_EEPROM_VER14_2))
fprintf(fd, "%1d", eeprom.ee_xpd[curmode]);
else
fprintf(fd, "%3d", eepromN.modalHeader[curmode].xpd);
} else if (streq(var, "txrxAtten")) {
fprintf(fd, "0x%02x", eeprom.ee_txrxAtten[curmode]);
} else if (streq(var, "capField")) {
fprintf(fd, "0x%04X", eeprom.ee_capField);
} else if (streq(var, "txrxAttenTurbo")) {
fprintf(fd, "0x%02x",
eeprom.ee_txrxAtten[curmode != headerInfo11A]);
} else if (streq(var, "switchSettlingTurbo")) {
fprintf(fd, "0x%02X",
eeprom.ee_switchSettlingTurbo[curmode != headerInfo11A]);
} else if (streq(var, "adcDesiredSizeTurbo")) {
fprintf(fd, "%2d",
eeprom.ee_adcDesiredSizeTurbo[curmode != headerInfo11A]);
} else if (streq(var, "pgaDesiredSizeTurbo")) {
fprintf(fd, "%2d",
eeprom.ee_pgaDesiredSizeTurbo[curmode != headerInfo11A]);
} else if (streq(var, "rxtxMarginTurbo")) {
fprintf(fd, "0x%02x",
eeprom.ee_rxtxMarginTurbo[curmode != headerInfo11A]);
} else if (strneq(var, "antennaControl", 14)) {
printAntennaControl(fd, atoi(var+14));
} else if (strneq(var, "antCtrlChain", 12)) {
fprintf(fd, "0x%08X",
eepromN.modalHeader[curmode].antCtrlChain[atoi(var+12)]);
} else if (strneq(var, "antGainCh", 9)) {
fprintf(fd, "%3d",
eepromN.modalHeader[curmode].antennaGainCh[atoi(var+9)]);
} else if (strneq(var, "txRxAttenCh", 11)) {
fprintf(fd, "%3d",
eepromN.modalHeader[curmode].txRxAttenCh[atoi(var+11)]);
} else if (strneq(var, "rxTxMarginCh", 12)) {
fprintf(fd, "%3d",
eepromN.modalHeader[curmode].rxTxMarginCh[atoi(var+12)]);
} else if (streq(var, "xpdGain")) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].xpdGain);
} else if (strneq(var, "iqCalICh", 8)) {
fprintf(fd, "%3d",
eepromN.modalHeader[curmode].iqCalICh[atoi(var+8)]);
} else if (strneq(var, "iqCalQCh", 8)) {
fprintf(fd, "%3d",
eepromN.modalHeader[curmode].iqCalQCh[atoi(var+8)]);
} else if (streq(var, "pdGainOverlap")) {
printHalfDbmPower(fd, eepromN.modalHeader[curmode].pdGainOverlap);
} else if (streq(var, "ob1")) {
fprintf(fd, "%1d", eeprom.ee_ob1);
} else if (streq(var, "ob2")) {
fprintf(fd, "%1d", eeprom.ee_ob2);
} else if (streq(var, "ob3")) {
fprintf(fd, "%1d", eeprom.ee_ob3);
} else if (streq(var, "ob4")) {
fprintf(fd, "%1d", eeprom.ee_ob4);
} else if (streq(var, "db1")) {
fprintf(fd, "%1d", eeprom.ee_db1);
} else if (streq(var, "db2")) {
fprintf(fd, "%1d", eeprom.ee_db2);
} else if (streq(var, "db3")) {
fprintf(fd, "%1d", eeprom.ee_db3);
} else if (streq(var, "db4")) {
fprintf(fd, "%1d", eeprom.ee_db4);
} else if (streq(var, "obFor24")) {
fprintf(fd, "%1d", eeprom.ee_obFor24);
} else if (streq(var, "ob2GHz0")) {
fprintf(fd, "%1d", eeprom.ee_ob2GHz[0]);
} else if (streq(var, "dbFor24")) {
fprintf(fd, "%1d", eeprom.ee_dbFor24);
} else if (streq(var, "db2GHz0")) {
fprintf(fd, "%1d", eeprom.ee_db2GHz[0]);
} else if (streq(var, "obFor24g")) {
fprintf(fd, "%1d", eeprom.ee_obFor24g);
} else if (streq(var, "ob2GHz1")) {
fprintf(fd, "%1d", eeprom.ee_ob2GHz[1]);
} else if (streq(var, "dbFor24g")) {
fprintf(fd, "%1d", eeprom.ee_dbFor24g);
} else if (streq(var, "db2GHz1")) {
fprintf(fd, "%1d", eeprom.ee_db2GHz[1]);
} else if (streq(var, "ob")) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].ob);
} else if (streq(var, "db")) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].db);
} else if (streq(var, "xpaBiasLvl")) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].xpaBiasLvl);
} else if (streq(var, "pwrDecreaseFor2Chain")) {
printHalfDbmPower(fd, eepromN.modalHeader[curmode].pwrDecreaseFor2Chain);
} else if (streq(var, "pwrDecreaseFor3Chain")) {
printHalfDbmPower(fd, eepromN.modalHeader[curmode].pwrDecreaseFor3Chain);
} else if (streq(var, "txFrameToDataStart")) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].txFrameToDataStart);
} else if (streq(var, "txFrameToPaOn")) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].txFrameToPaOn);
} else if (streq(var, "ht40PowerIncForPdadc")) {
fprintf(fd, "%3d", eepromN.modalHeader[curmode].ht40PowerIncForPdadc);
} else if (streq(var, "checksum")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.checksum);
} else if (streq(var, "length")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.length);
} else if (streq(var, "regDmn0")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.regDmn[0]);
} else if (streq(var, "regDmn1")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.regDmn[1]);
} else if (streq(var, "txMask")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.txMask);
} else if (streq(var, "rxMask")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.rxMask);
} else if (streq(var, "rfSilent")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.rfSilent);
} else if (streq(var, "btOptions")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.blueToothOptions);
} else if (streq(var, "deviceCap")) {
fprintf(fd, "0x%04X", eepromN.baseEepHeader.deviceCap);
} else if (strneq(var, "macaddr", 7)) {
fprintf(fd, "%02X",
eepromN.baseEepHeader.macAddr[atoi(var+7)]);
} else if (streq(var, "opCapFlags")) {
fprintf(fd, "0x%02X", eepromN.baseEepHeader.opCapFlags);
} else if (streq(var, "eepMisc")) {
fprintf(fd, "0x%02X", eepromN.baseEepHeader.eepMisc);
} else if (strneq(var, "binBuildNumber", 14)) {
fprintf(fd, "%3d",
(eepromN.baseEepHeader.binBuildNumber >> (8*atoi(var+14)))
& 0xff);
} else if (strneq(var, "custData", 8)) {
fprintf(fd, "%2.2X", eepromN.custData[atoi(var+8)]);
} else if (streq(var, "xpd_mask")) {
if (IS_VERS(<, AR_EEPROM_VER5_0))
fprintf(fd, "0x%02x", pExpnPower->xpdMask);
else
fprintf(fd, "0x%02x", pRaw->xpd_mask);
} else if (streq(var, "numChannels")) {
if (IS_VERS(<, AR_EEPROM_VER5_0))
fprintf(fd, "%2d", pExpnPower->numChannels);
else
fprintf(fd, "%2d", pRaw->numChannels);
} else if (streq(var, "freq")) {
if (IS_VERS(<, AR_EEPROM_VER5_0))
fprintf(fd, "%4d", pExpnPower->pChannels[curchan]);
else
fprintf(fd, "%4d", pRaw->pChannels[curchan]);
} else if (streq(var, "maxpow")) {
int16_t maxPower_t4;
if (IS_VERS(<, AR_EEPROM_VER5_0)) {
maxPower_t4 = pExpnPower->pDataPerChannel[curchan].maxPower_t4;
} else {
maxPower_t4 = pRaw->pDataPerChannel[curchan].maxPower_t4;
if (maxPower_t4 == 0)
maxPower_t4 = getMaxPowerV5(&pRaw->pDataPerChannel[curchan]);
}
printQuarterDbmPower(fd, maxPower_t4);
} else if (streq(var, "pd_gain")) {
fprintf(fd, "%4d", pRaw->pDataPerChannel[curchan].
pDataPerPDGain[curpdgain].pd_gain);
} else if (strneq(var, "maxpwr", 6)) {
int vpd = atoi(var+6);
if (vpd < pRaw->pDataPerChannel[curchan].pDataPerPDGain[curpdgain].numVpd)
printQuarterDbmPower(fd, pRaw->pDataPerChannel[curchan].
pDataPerPDGain[curpdgain].pwr_t4[vpd]);
else
fprintf(fd, " ");
} else if (strneq(var, "pwr_t4_", 7)) {
printQuarterDbmPower(fd, pExpnPower->pDataPerChannel[curchan].
pDataPerXPD[singleXpd].pwr_t4[atoi(var+7)]);
} else if (strneq(var, "Vpd", 3)) {
int vpd = atoi(var+3);
if (vpd < pRaw->pDataPerChannel[curchan].pDataPerPDGain[curpdgain].numVpd)
printVpd(fd, pRaw->pDataPerChannel[curchan].
pDataPerPDGain[curpdgain].Vpd[vpd]);
else
fprintf(fd, " ");
} else if (streq(var, "CTL")) {
fprintf(fd, "0x%2x", eeprom.ee_ctl[curctl] & 0xff);
} else if (streq(var, "ctlType")) {
static const char *ctlType[16] = {
"11a base", "11b", "11g", "11a TURBO", "108g",
"2GHT20", "5GHT20", "2GHT40", "5GHT40",
"0x9", "0xa", "0xb", "0xc", "0xd", "0xe", "0xf",
};
fprintf(fd, "%8s", ctlType[eeprom.ee_ctl[curctl] & CTL_MODE_M]);
} else if (streq(var, "ctlRD")) {
static const char *ctlRD[8] = {
"0x00", " FCC", "0x20", "ETSI",
" MKK", "0x50", "0x60", "0x70"
};
fprintf(fd, "%s", ctlRD[(eeprom.ee_ctl[curctl] >> 4) & 7]);
} else if (strneq(var, "rdEdgePower", 11)) {
printEdgePower(fd, atoi(var+11));
} else if (strneq(var, "rdEdgeFlag", 10)) {
printEdgeFlag(fd, atoi(var+10));
} else if (strneq(var, "rdEdge", 6)) {
printEdge(fd, atoi(var+6));
} else if (strneq(var, "testChannel", 11)) {
fprintf(fd, "%4d", pPowerInfo[atoi(var+11)].testChannel);
} else if (strneq(var, "pwr6_24_", 8)) {
printHalfDbmPower(fd, pPowerInfo[atoi(var+8)].twicePwr6_24);
} else if (strneq(var, "pwr36_", 6)) {
printHalfDbmPower(fd, pPowerInfo[atoi(var+6)].twicePwr36);
} else if (strneq(var, "pwr48_", 6)) {
printHalfDbmPower(fd, pPowerInfo[atoi(var+6)].twicePwr48);
} else if (strneq(var, "pwr54_", 6)) {
printHalfDbmPower(fd, pPowerInfo[atoi(var+6)].twicePwr54);
} else if (strneq(var, "channelValue", 12)) {
fprintf(fd, "%4d", pDataPerChannel[atoi(var+12)].channelValue);
} else if (strneq(var, "pcdacMin", 8)) {
fprintf(fd, "%02d", pDataPerChannel[atoi(var+8)].pcdacMin);
} else if (strneq(var, "pcdacMax", 8)) {
fprintf(fd, "%02d", pDataPerChannel[atoi(var+8)].pcdacMax);
} else if (strneq(var, "pcdac", 5)) {
if (IS_VERS(<, AR_EEPROM_VER4_0)) {
fprintf(fd, "%02d", pDataPerChannel[atoi(var+5)].
PcdacValues[curpcdac]);
} else if (IS_VERS(<, AR_EEPROM_VER5_0)) {
fprintf(fd, "%02d",
pExpnPower->pDataPerChannel[curchan].
pDataPerXPD[singleXpd].pcdac[atoi(var+5)]);
} else
undef("pcdac");
} else if (strneq(var, "pwrValue", 8)) {
printPcdacValue(fd,
pDataPerChannel[atoi(var+8)].PwrValues[curpcdac]);
} else if (streq(var, "singleXpd")) {
fprintf(fd, "%2d", singleXpd);
} else
warnx("line %u, unknown EEPROM variable \"%s\"", lineno, var);
#undef strneq
#undef streq
}
static void
ifmode(FILE *ftemplate, const char *mode)
{
if (strcasecmp(mode, "11a") == 0) {
if (IS_VERS(<, AR_EEPROM_VER14_2)) {
if (eeprom.ee_Amode)
setmode(headerInfo11A);
else
skipto(ftemplate, "endmode");
return;
}
if (IS_VERS(>=, AR_EEPROM_VER14_2)) {
if (eepromN.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11A)
setmode(headerInfo11A);
else
skipto(ftemplate, "endmode");
return;
}
} else if (strcasecmp(mode, "11g") == 0) {
if (IS_VERS(<, AR_EEPROM_VER14_2)) {
if (eeprom.ee_Gmode)
setmode(headerInfo11G);
else
skipto(ftemplate, "endmode");
return;
}
if (IS_VERS(>=, AR_EEPROM_VER14_2)) {
if (eepromN.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11G)
setmode(headerInfo11B); /* NB: 2.4GHz */
else
skipto(ftemplate, "endmode");
return;
}
} else if (strcasecmp(mode, "11b") == 0) {
if (IS_VERS(<, AR_EEPROM_VER14_2)) {
if (eeprom.ee_Bmode)
setmode(headerInfo11B);
else
skipto(ftemplate, "endmode");
return;
}
}
warnx("line %d, unknown/unexpected mode \"%s\" ignored",
lineno, mode);
skipto(ftemplate, "endmode");
}
static void
parseTemplate(FILE *ftemplate, FILE *fd)
{
int c, i;
char id[MAXID];
long forchan, forpdgain, forctl, forpcdac;
lineno = 1;
bol = 1;
while ((c = getc(ftemplate)) != EOF) {
if (c == '#') { /* comment */
skiptoeol:
while ((c = getc(ftemplate)) != EOF && c != '\n')
;
if (c == EOF)
return;
lineno++;
bol = 1;
continue;
}
if (c == '.' && bol) { /* .directive */
if (token(ftemplate, id, MAXID, ".directive") == EOF)
return;
/* process directive */
if (strcasecmp(id, "ifmode") == 0) {
skipws(ftemplate);
if (token(ftemplate, id, MAXID, "id") == EOF)
return;
ifmode(ftemplate, id);
} else if (strcasecmp(id, "endmode") == 0) {
/* XXX free malloc'd indirect data */
curmode = -1; /* NB: undefined */
} else if (strcasecmp(id, "forchan") == 0) {
forchan = ftell(ftemplate) - sizeof("forchan");
if (curchan == -1)
curchan = 0;
} else if (strcasecmp(id, "endforchan") == 0) {
if (++curchan < numChannels)
fseek(ftemplate, forchan, SEEK_SET);
else
curchan = -1;
} else if (strcasecmp(id, "ifpdgain") == 0) {
skipws(ftemplate);
if (token(ftemplate, id, MAXID, "pdgain") == EOF)
return;
curlpdgain = strtoul(id, NULL, 0);
if (curlpdgain >= pRaw->pDataPerChannel[curchan].numPdGains) {
skipto(ftemplate, "endpdgain");
curlpdgain = -1;
} else
curpdgain = pdgain(curlpdgain);
} else if (strcasecmp(id, "endpdgain") == 0) {
curlpdgain = curpdgain = -1;
} else if (strcasecmp(id, "forpdgain") == 0) {
forpdgain = ftell(ftemplate) - sizeof("forpdgain");
if (curlpdgain == -1) {
skipws(ftemplate);
if (token(ftemplate, id, MAXID, "pdgain") == EOF)
return;
curlpdgain = strtoul(id, NULL, 0);
if (curlpdgain >= pRaw->pDataPerChannel[curchan].numPdGains) {
skipto(ftemplate, "endforpdgain");
curlpdgain = -1;
} else
curpdgain = pdgain(curlpdgain);
}
} else if (strcasecmp(id, "endforpdgain") == 0) {
if (++curpdgain < pRaw->pDataPerChannel[curchan].numPdGains)
fseek(ftemplate, forpdgain, SEEK_SET);
else
curpdgain = -1;
} else if (strcasecmp(id, "forpcdac") == 0) {
forpcdac = ftell(ftemplate) - sizeof("forpcdac");
if (curpcdac == -1)
curpcdac = 0;
} else if (strcasecmp(id, "endforpcdac") == 0) {
if (++curpcdac < pDataPerChannel[0].numPcdacValues)
fseek(ftemplate, forpcdac, SEEK_SET);
else
curpcdac = -1;
} else if (strcasecmp(id, "forctl") == 0) {
forctl = ftell(ftemplate) - sizeof("forchan");
if (curctl == -1)
curctl = nextctl(0);
} else if (strcasecmp(id, "endforctl") == 0) {
curctl = nextctl(curctl+1);
if (curctl != -1)
fseek(ftemplate, forctl, SEEK_SET);
} else {
warnx("line %d, unknown directive %s ignored",
lineno, id);
}
goto skiptoeol;
}
if (c == '$') { /* $variable reference */
if (token(ftemplate, id, MAXID, "$var") == EOF)
return;
/* XXX not valid if variable depends on curmode */
eevar(fd, id);
continue;
}
if (c == '\\') { /* escape next character */
c = getc(ftemplate);
if (c == EOF)
return;
}
fputc(c, fd);
bol = (c == '\n');
if (bol)
lineno++;
}
}