tools/tools/ath/athprom/athprom.c

   1 /*-
   2  * Copyright (c) 2008 Sam Leffler, Errno Consulting
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  13  *    redistribution must be conditioned upon including a substantially
  14  *    similar Disclaimer requirement for further binary redistribution.
  15  *
  16  * NO WARRANTY
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  20  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  22  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  27  * THE POSSIBILITY OF SUCH DAMAGES.
  28  *
  29  * $FreeBSD$
  30  */
  31 #include "diag.h"
  32
  33 #include "ah.h"
  34 #include "ah_internal.h"
  35 #include "ah_eeprom_v1.h"
  36 #include "ah_eeprom_v3.h"
  37 #include "ah_eeprom_v14.h"
  38
  39 #define IS_VERS(op, v)          (eeprom.ee_version op (v))
  40
  41 #include <getopt.h>
  42 #include <errno.h>
  43 #include <err.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <ctype.h>
  47
  48 #ifndef DIR_TEMPLATE
  49 #define DIR_TEMPLATE    "/usr/local/libdata/athprom"
  50 #endif
  51
  52 struct  ath_diag atd;
  53 int     s;
  54 const char *progname;
  55 union {
  56         HAL_EEPROM legacy;              /* format v3.x ... v5.x */
  57         struct ar5416eeprom v14;        /* 11n format v14.x ... */
  58 } eep;
  59 #define eeprom  eep.legacy
  60 #define eepromN eep.v14
  61
  62 static void parseTemplate(FILE *ftemplate, FILE *fd);
  63 static uint16_t eeread(uint16_t);
  64 static void eewrite(uint16_t, uint16_t);
  65
  66 static void
  67 usage()
  68 {
  69         fprintf(stderr, "usage: %s [-i ifname] [-t pathname] [offset | offset=value]\n", progname);
  70         exit(-1);
  71 }
  72
  73 static FILE *
  74 opentemplate(const char *dir)
  75 {
  76         char filename[PATH_MAX];
  77         FILE *fd;
  78
  79         /* find the template using the eeprom version */
  80         snprintf(filename, sizeof(filename), "%s/eeprom-%d.%d",
  81             dir, eeprom.ee_version >> 12, eeprom.ee_version & 0xfff);
  82         fd = fopen(filename, "r");
  83         if (fd == NULL && errno == ENOENT) {
  84                 /* retry with just the major version */
  85                 snprintf(filename, sizeof(filename), "%s/eeprom-%d",
  86                     dir, eeprom.ee_version >> 12);
  87                 fd = fopen(filename, "r");
  88                 if (fd != NULL)         /* XXX verbose */
  89                         warnx("Using template file %s", filename);
  90         }
  91         return fd;
  92 }
  93
  94 int
  95 main(int argc, char *argv[])
  96 {
  97         FILE *fd = NULL;
  98         const char *ifname;
  99         int c;
 100
 101         s = socket(AF_INET, SOCK_DGRAM, 0);
 102         if (s < 0)
 103                 err(1, "socket");
 104         ifname = getenv("ATH");
 105         if (!ifname)
 106                 ifname = ATH_DEFAULT;
 107
 108         progname = argv[0];
 109         while ((c = getopt(argc, argv, "i:t:")) != -1)
 110                 switch (c) {
 111                 case 'i':
 112                         ifname = optarg;
 113                         break;
 114                 case 't':
 115                         fd = fopen(optarg, "r");
 116                         if (fd == NULL)
 117                                 err(-1, "Cannot open %s", optarg);
 118                         break;
 119                 default:
 120                         usage();
 121                         /*NOTREACHED*/
 122                 }
 123         argc -= optind;
 124         argv += optind;
 125
 126         strncpy(atd.ad_name, ifname, sizeof (atd.ad_name));
 127
 128         if (argc != 0) {
 129                 for (; argc > 0; argc--, argv++) {
 130                         uint16_t off, val, oval;
 131                         char line[256];
 132                         char *cp;
 133
 134                         cp = strchr(argv[0], '=');
 135                         if (cp != NULL)
 136                                 *cp = '\0';
 137                         off = (uint16_t) strtoul(argv[0], NULL, 0);
 138                         if (off == 0 && errno == EINVAL)
 139                                 errx(1, "%s: invalid eeprom offset %s",
 140                                         progname, argv[0]);
 141                         if (cp == NULL) {
 142                                 printf("%04x: %04x\n", off, eeread(off));
 143                         } else {
 144                                 val = (uint16_t) strtoul(cp+1, NULL, 0);
 145                                 if (val == 0 && errno == EINVAL)
 146                                 errx(1, "%s: invalid eeprom value %s",
 147                                         progname, cp+1);
 148                                 oval = eeread(off);
 149                                 printf("Write %04x: %04x = %04x? ",
 150                                         off, oval, val);
 151                                 fflush(stdout);
 152                                 if (fgets(line, sizeof(line), stdin) != NULL &&
 153                                     line[0] == 'y')
 154                                         eewrite(off, val);
 155                         }
 156                 }
 157         } else {
 158                 atd.ad_id = HAL_DIAG_EEPROM;
 159                 atd.ad_out_data = (caddr_t) &eep;
 160                 atd.ad_out_size = sizeof(eep);
 161                 if (ioctl(s, SIOCGATHDIAG, &atd) < 0)
 162                         err(1, "ioctl: %s", atd.ad_name);
 163                 if (fd == NULL) {
 164                         fd = opentemplate(DIR_TEMPLATE);
 165                         if (fd == NULL)
 166                                 fd = opentemplate(".");
 167                         if (fd == NULL)
 168                                 errx(-1, "Cannot locate template file for "
 169                                     "v%d.%d EEPROM", eeprom.ee_version >> 12,
 170                                     eeprom.ee_version & 0xfff);
 171                 }
 172                 parseTemplate(fd, stdout);
 173                 fclose(fd);
 174         }
 175         return 0;
 176 }
 177
 178 static u_int16_t
 179 eeread(u_int16_t off)
 180 {
 181         u_int16_t eedata;
 182
 183         atd.ad_id = HAL_DIAG_EEREAD | ATH_DIAG_IN | ATH_DIAG_DYN;
 184         atd.ad_in_size = sizeof(off);
 185         atd.ad_in_data = (caddr_t) &off;
 186         atd.ad_out_size = sizeof(eedata);
 187         atd.ad_out_data = (caddr_t) &eedata;
 188         if (ioctl(s, SIOCGATHDIAG, &atd) < 0)
 189                 err(1, "ioctl: %s", atd.ad_name);
 190         return eedata;
 191 }
 192
 193 static void
 194 eewrite(uint16_t off, uint16_t value)
 195 {
 196         HAL_DIAG_EEVAL eeval;
 197
 198         eeval.ee_off = off;
 199         eeval.ee_data = value;
 200
 201         atd.ad_id = HAL_DIAG_EEWRITE | ATH_DIAG_IN;
 202         atd.ad_in_size = sizeof(eeval);
 203         atd.ad_in_data = (caddr_t) &eeval;
 204         atd.ad_out_size = 0;
 205         atd.ad_out_data = NULL;
 206         if (ioctl(s, SIOCGATHDIAG, &atd) < 0)
 207                 err(1, "ioctl: %s", atd.ad_name);
 208 }
 209
 210 #define MAXID   128
 211 int     lineno;
 212 int     bol;
 213 int     curmode = -1;
 214 int     curchan;
 215 int     curpdgain;      /* raw pdgain index */
 216 int     curlpdgain;     /* logical pdgain index */
 217 int     curpcdac;
 218 int     curctl;
 219 int     numChannels;
 220 const RAW_DATA_STRUCT_2413 *pRaw;
 221 const TRGT_POWER_INFO *pPowerInfo;
 222 const DATA_PER_CHANNEL *pDataPerChannel;
 223 const EEPROM_POWER_EXPN_5112 *pExpnPower;
 224 int     singleXpd;
 225
 226 static int
 227 token(FILE *fd, char id[], int maxid, const char *what)
 228 {
 229         int c, i;
 230
 231         i = 0;
 232         for (;;) {
 233                 c = getc(fd);
 234                 if (c == EOF)
 235                         return EOF;
 236                 if (!isalnum(c) && c != '_') {
 237                         ungetc(c, fd);
 238                         break;
 239                 }
 240                 if (i == maxid-1) {
 241                         warnx("line %d, %s too long", lineno, what);
 242                         break;
 243                 }
 244                 id[i++] = c;
 245         }
 246         id[i] = '\0';
 247         if (i != 0)
 248                 bol = 0;
 249         return i;
 250 }
 251
 252 static int
 253 skipto(FILE *fd, const char *what)
 254 {
 255         char id[MAXID];
 256         int c;
 257
 258         for (;;) {
 259                 c = getc(fd);
 260                 if (c == EOF)
 261                         goto bad;
 262                 if (c == '.' && bol) {          /* .directive */
 263                         if (token(fd, id, MAXID, ".directive") == EOF)
 264                                 goto bad;
 265                         if (strcasecmp(id, what) == 0)
 266                                 break;
 267                         continue;
 268                 }
 269                 if (c == '\\') {                /* escape next character */
 270                         c = getc(fd);
 271                         if (c == EOF)
 272                                 goto bad;
 273                 }
 274                 bol = (c == '\n');
 275                 if (bol)
 276                         lineno++;
 277         }
 278         return 0;
 279 bad:
 280         warnx("EOF with no matching .%s", what);
 281         return EOF;
 282 }
 283
 284 static int
 285 skipws(FILE *fd)
 286 {
 287         int c, i;
 288
 289         i = 0;
 290         while ((c = getc(fd)) != EOF && isblank(c))
 291                 i++;
 292         if (c != EOF)
 293                 ungetc(c, fd);
 294         if (i != 0)
 295                 bol = 0;
 296         return 0;
 297 }
 298
 299 static void
 300 setmode(int mode)
 301 {
 302         EEPROM_POWER_EXPN_5112 *exp;
 303
 304         curmode = mode;
 305         curchan = -1;
 306         curctl = -1;
 307         curpdgain = -1;
 308         curlpdgain = -1;
 309         curpcdac = -1;
 310         switch (curmode) {
 311         case headerInfo11A:
 312                 pPowerInfo = eeprom.ee_trgtPwr_11a;
 313                 pDataPerChannel = eeprom.ee_dataPerChannel11a;
 314                 break;
 315         case headerInfo11B:
 316                 pPowerInfo = eeprom.ee_trgtPwr_11b;
 317                 pDataPerChannel = eeprom.ee_dataPerChannel11b;
 318                 break;
 319         case headerInfo11G:
 320                 pPowerInfo = eeprom.ee_trgtPwr_11g;
 321                 pDataPerChannel = eeprom.ee_dataPerChannel11g;
 322                 break;
 323         }
 324         if (IS_VERS(<, AR_EEPROM_VER4_0))               /* nothing to do */
 325                 return;
 326         if (IS_VERS(<, AR_EEPROM_VER5_0)) {
 327                 exp = &eeprom.ee_modePowerArray5112[curmode];
 328                 /* fetch indirect data*/
 329                 atd.ad_id = HAL_DIAG_EEPROM_EXP_11A+curmode;
 330                 atd.ad_out_size = roundup(
 331                         sizeof(u_int16_t) * exp->numChannels, sizeof(u_int32_t))
 332                     + sizeof(EXPN_DATA_PER_CHANNEL_5112) * exp->numChannels;
 333                 atd.ad_out_data = (caddr_t) malloc(atd.ad_out_size);
 334                 if (ioctl(s, SIOCGATHDIAG, &atd) < 0)
 335                         err(1, "ioctl: %s", atd.ad_name);
 336                 exp->pChannels = (void *) atd.ad_out_data;
 337                 exp->pDataPerChannel = (void *)((char *)atd.ad_out_data +
 338                    roundup(sizeof(u_int16_t) * exp->numChannels, sizeof(u_int32_t)));
 339                 pExpnPower = exp;
 340                 numChannels = pExpnPower->numChannels;
 341                 if (exp->xpdMask != 0x9) {
 342                         for (singleXpd = 0; singleXpd < NUM_XPD_PER_CHANNEL; singleXpd++)
 343                                 if (exp->xpdMask == (1<<singleXpd))
 344                                         break;
 345                 } else
 346                         singleXpd = 0;
 347         } else if (IS_VERS(<, AR_EEPROM_VER14_2)) {
 348                 pRaw = &eeprom.ee_rawDataset2413[curmode];
 349                 numChannels = pRaw->numChannels;
 350         }
 351 }
 352
 353 int
 354 nextctl(int start)
 355 {
 356         int i;
 357
 358         for (i = start; i < eeprom.ee_numCtls && eeprom.ee_ctl[i]; i++) {
 359                 switch (eeprom.ee_ctl[i] & 3) {
 360                 case 0: case 3:
 361                         if (curmode != headerInfo11A)
 362                                 continue;
 363                         break;
 364                 case 1:
 365                         if (curmode != headerInfo11B)
 366                                 continue;
 367                         break;
 368                 case 2:
 369                         if (curmode != headerInfo11G)
 370                                 continue;
 371                         break;
 372                 }
 373                 return i;
 374         }
 375         return -1;
 376 }
 377
 378 static void
 379 printAntennaControl(FILE *fd, int ant)
 380 {
 381         fprintf(fd, "0x%02X", eeprom.ee_antennaControl[ant][curmode]);
 382 }
 383
 384 static void
 385 printEdge(FILE *fd, int edge)
 386 {
 387         const RD_EDGES_POWER *pRdEdgePwrInfo =
 388             &eeprom.ee_rdEdgesPower[curctl*NUM_EDGES];
 389
 390         if (pRdEdgePwrInfo[edge].rdEdge == 0)
 391                 fprintf(fd, " -- ");
 392         else
 393                 fprintf(fd, "%04d", pRdEdgePwrInfo[edge].rdEdge);
 394 }
 395
 396 static void
 397 printEdgePower(FILE *fd, int edge)
 398 {
 399         const RD_EDGES_POWER *pRdEdgePwrInfo =
 400             &eeprom.ee_rdEdgesPower[curctl*NUM_EDGES];
 401
 402         if (pRdEdgePwrInfo[edge].rdEdge == 0)
 403                 fprintf(fd, " -- ");
 404         else
 405                 fprintf(fd, "%2d.%d",
 406                     pRdEdgePwrInfo[edge].twice_rdEdgePower / 2,
 407                     (pRdEdgePwrInfo[edge].twice_rdEdgePower % 2) * 5);
 408 }
 409
 410 static void
 411 printEdgeFlag(FILE *fd, int edge)
 412 {
 413         const RD_EDGES_POWER *pRdEdgePwrInfo =
 414             &eeprom.ee_rdEdgesPower[curctl*NUM_EDGES];
 415
 416         if (pRdEdgePwrInfo[edge].rdEdge == 0)
 417                 fprintf(fd, "--");
 418         else
 419                 fprintf(fd, " %1d", pRdEdgePwrInfo[edge].flag);
 420 }
 421
 422 static int16_t
 423 getMaxPowerV5(const RAW_DATA_PER_CHANNEL_2413 *data)
 424 {
 425         uint32_t i;
 426         uint16_t numVpd;
 427
 428         for (i = 0; i < MAX_NUM_PDGAINS_PER_CHANNEL; i++) {
 429                 numVpd = data->pDataPerPDGain[i].numVpd;
 430                 if (numVpd > 0)
 431                         return data->pDataPerPDGain[i].pwr_t4[numVpd-1];
 432         }
 433         return 0;
 434 }
 435
 436 static void
 437 printQuarterDbmPower(FILE *fd, int16_t power25dBm)
 438 {
 439         fprintf(fd, "%2d.%02d", power25dBm / 4, (power25dBm % 4) * 25);
 440 }
 441
 442 static void
 443 printHalfDbmPower(FILE *fd, int16_t power5dBm)
 444 {
 445         fprintf(fd, "%2d.%d", power5dBm / 2, (power5dBm % 2) * 5);
 446 }
 447
 448 static void
 449 printVpd(FILE *fd, int vpd)
 450 {
 451         fprintf(fd, "[%3d]", vpd);
 452 }
 453
 454 static void
 455 printPcdacValue(FILE *fd, int v)
 456 {
 457         fprintf(fd, "%2d.%02d", v / EEP_SCALE, v % EEP_SCALE);
 458 }
 459
 460 static void
 461 undef(const char *what)
 462 {
 463         warnx("%s undefined for version %d.%d format EEPROM", what,
 464             eeprom.ee_version >> 12, eeprom.ee_version & 0xfff);
 465 }
 466
 467 static int
 468 pdgain(int lpdgain)
 469 {
 470         uint32_t mask;
 471         int i, l = lpdgain;
 472
 473         if (IS_VERS(<, AR_EEPROM_VER5_0))
 474                 mask = pExpnPower->xpdMask;
 475         else
 476                 mask = pRaw->xpd_mask;
 477         for (i = 0; mask != 0; mask >>= 1, i++)
 478                 if ((mask & 1) && l-- == 0)
 479                         return i;
 480         warnx("can't find logical pdgain %d", lpdgain);
 481         return -1;
 482 }
 483
 484 #define COUNTRY_ERD_FLAG        0x8000
 485 #define WORLDWIDE_ROAMING_FLAG  0x4000
 486
 487 void
 488 eevar(FILE *fd, const char *var)
 489 {
 490 #define streq(a,b)      (strcasecmp(a,b) == 0)
 491 #define strneq(a,b,n)   (strncasecmp(a,b,n) == 0)
 492         if (streq(var, "mode")) {
 493                 fprintf(fd, "%s",
 494                     curmode == headerInfo11A ? "11a" :
 495                     curmode == headerInfo11B ? "11b" :
 496                     curmode == headerInfo11G ? "11g" : "???");
 497         } else if (streq(var, "version")) {
 498                 fprintf(fd, "%04x", eeprom.ee_version);
 499         } else if (streq(var, "V_major")) {
 500                 fprintf(fd, "%2d", eeprom.ee_version >> 12);
 501         } else if (streq(var, "V_minor")) {
 502                 fprintf(fd, "%2d", eeprom.ee_version & 0xfff);
 503         } else if (streq(var, "earStart")) {
 504                 fprintf(fd, "%03x", eeprom.ee_earStart);
 505         } else if (streq(var, "tpStart")) {
 506                 fprintf(fd, "%03x", eeprom.ee_targetPowersStart);
 507         } else if (streq(var, "eepMap")) {
 508                 fprintf(fd, "%3d", eeprom.ee_eepMap);
 509         } else if (streq(var, "exist32KHzCrystal")) {
 510                 fprintf(fd, "%3d", eeprom.ee_exist32kHzCrystal);
 511         } else if (streq(var, "eepMap2PowerCalStart")) {
 512                 fprintf(fd , "%3d", eeprom.ee_eepMap2PowerCalStart);
 513         } else if (streq(var, "Amode")) {
 514                 fprintf(fd , "%1d", eeprom.ee_Amode);
 515         } else if (streq(var, "Bmode")) {
 516                 fprintf(fd , "%1d", eeprom.ee_Bmode);
 517         } else if (streq(var, "Gmode")) {
 518                 fprintf(fd , "%1d", eeprom.ee_Gmode);
 519         } else if (streq(var, "regdomain")) {
 520                 if ((eeprom.ee_regdomain & COUNTRY_ERD_FLAG) == 0)
 521                         fprintf(fd, "%03X ", eeprom.ee_regdomain >> 15);
 522                 else
 523                         fprintf(fd, "%-3dC", eeprom.ee_regdomain & 0xfff);
 524         } else if (streq(var, "turbo2Disable")) {
 525                 fprintf(fd, "%1d", eeprom.ee_turbo2Disable);
 526         } else if (streq(var, "turbo5Disable")) {
 527                 fprintf(fd, "%1d", eeprom.ee_turbo5Disable);
 528         } else if (streq(var, "rfKill")) {
 529                 fprintf(fd, "%1d", eeprom.ee_rfKill);
 530         } else if (streq(var, "disableXr5")) {
 531                 fprintf(fd, "%1d", eeprom.ee_disableXr5);
 532         } else if (streq(var, "disableXr2")) {
 533                 fprintf(fd, "%1d", eeprom.ee_disableXr2);
 534         } else if (streq(var, "turbo2WMaxPower5")) {
 535                 fprintf(fd, "%2d", eeprom.ee_turbo2WMaxPower5);
 536         } else if (streq(var, "cckOfdmDelta")) {
 537                 fprintf(fd, "%2d", eeprom.ee_cckOfdmPwrDelta);
 538         } else if (streq(var, "gainI")) {
 539                 fprintf(fd, "%2d", eeprom.ee_gainI[curmode]);
 540         } else if (streq(var, "WWR")) {
 541                 fprintf(fd, "%1x",
 542                     (eeprom.ee_regdomain & WORLDWIDE_ROAMING_FLAG) != 0);
 543         } else if (streq(var, "falseDetectBackoff")) {
 544                 fprintf(fd, "0x%02x", eeprom.ee_falseDetectBackoff[curmode]);
 545         } else if (streq(var, "deviceType")) {
 546                 fprintf(fd, "%1x", eeprom.ee_deviceType);
 547         } else if (streq(var, "switchSettling")) {
 548                 if (IS_VERS(<, AR_EEPROM_VER14_2))
 549                         fprintf(fd, "0x%02x", eeprom.ee_switchSettling[curmode]);
 550                 else
 551                         fprintf(fd, "%3d", eepromN.modalHeader[curmode].switchSettling);
 552         } else if (streq(var, "adcDesiredSize")) {
 553                 if (IS_VERS(<, AR_EEPROM_VER14_2))
 554                         fprintf(fd, "%2d", eeprom.ee_adcDesiredSize[curmode]);
 555                 else
 556                         fprintf(fd, "%3d", eepromN.modalHeader[curmode].adcDesiredSize);
 557         } else if (streq(var, "xlnaGain")) {
 558                 fprintf(fd, "0x%02x", eeprom.ee_xlnaGain[curmode]);
 559         } else if (streq(var, "txEndToXLNAOn")) {
 560                 fprintf(fd, "0x%02x", eeprom.ee_txEndToXLNAOn[curmode]);
 561         } else if (streq(var, "thresh62")) {
 562                 if (IS_VERS(<, AR_EEPROM_VER14_2))
 563                         fprintf(fd, "0x%02x", eeprom.ee_thresh62[curmode]);
 564                 else
 565                         fprintf(fd, "%3d", eepromN.modalHeader[curmode].thresh62);
 566         } else if (streq(var, "txEndToRxOn")) {
 567                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].txEndToRxOn);
 568         } else if (streq(var, "txEndToXPAOff")) {
 569                 if (IS_VERS(<, AR_EEPROM_VER14_2))
 570                         fprintf(fd, "0x%02x", eeprom.ee_txEndToXPAOff[curmode]);
 571                 else
 572                         fprintf(fd, "%3d", eepromN.modalHeader[curmode].txEndToXpaOff);
 573         } else if (streq(var, "txFrameToXPAOn")) {
 574                 if (IS_VERS(<, AR_EEPROM_VER14_2))
 575                         fprintf(fd, "0x%02x", eeprom.ee_txFrameToXPAOn[curmode]);
 576                 else
 577                         fprintf(fd, "%3d", eepromN.modalHeader[curmode].txEndToRxOn);
 578         } else if (streq(var, "pgaDesiredSize")) {
 579                 if (IS_VERS(<, AR_EEPROM_VER14_2))
 580                         fprintf(fd, "%2d", eeprom.ee_pgaDesiredSize[curmode]);
 581                 else
 582                         fprintf(fd, "%3d", eepromN.modalHeader[curmode].pgaDesiredSize);
 583         } else if (streq(var, "noiseFloorThresh")) {
 584                 fprintf(fd, "%3d", eeprom.ee_noiseFloorThresh[curmode]);
 585         } else if (strneq(var, "noiseFloorThreshCh", 18)) {
 586                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].noiseFloorThreshCh[atoi(var+18)]);
 587         } else if (strneq(var, "xlnaGainCh", 10)) {
 588                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].xlnaGainCh[atoi(var+10)]);
 589         } else if (streq(var, "xgain")) {
 590                 fprintf(fd, "0x%02x", eeprom.ee_xgain[curmode]);
 591         } else if (streq(var, "xpd")) {
 592                 if (IS_VERS(<, AR_EEPROM_VER14_2))
 593                         fprintf(fd, "%1d", eeprom.ee_xpd[curmode]);
 594                 else
 595                         fprintf(fd, "%3d", eepromN.modalHeader[curmode].xpd);
 596         } else if (streq(var, "txrxAtten")) {
 597                 fprintf(fd, "0x%02x", eeprom.ee_txrxAtten[curmode]);
 598         } else if (streq(var, "capField")) {
 599                 fprintf(fd, "0x%04X", eeprom.ee_capField);
 600         } else if (streq(var, "txrxAttenTurbo")) {
 601                 fprintf(fd, "0x%02x",
 602                     eeprom.ee_txrxAtten[curmode != headerInfo11A]);
 603         } else if (streq(var, "switchSettlingTurbo")) {
 604                 fprintf(fd, "0x%02X",
 605                     eeprom.ee_switchSettlingTurbo[curmode != headerInfo11A]);
 606         } else if (streq(var, "adcDesiredSizeTurbo")) {
 607                 fprintf(fd, "%2d",
 608                     eeprom.ee_adcDesiredSizeTurbo[curmode != headerInfo11A]);
 609         } else if (streq(var, "pgaDesiredSizeTurbo")) {
 610                 fprintf(fd, "%2d",
 611                     eeprom.ee_pgaDesiredSizeTurbo[curmode != headerInfo11A]);
 612         } else if (streq(var, "rxtxMarginTurbo")) {
 613                 fprintf(fd, "0x%02x",
 614                     eeprom.ee_rxtxMarginTurbo[curmode != headerInfo11A]);
 615         } else if (strneq(var, "antennaControl", 14)) {
 616                 printAntennaControl(fd, atoi(var+14));
 617         } else if (strneq(var, "antCtrlChain", 12)) {
 618                 fprintf(fd, "0x%08X",
 619                     eepromN.modalHeader[curmode].antCtrlChain[atoi(var+12)]);
 620         } else if (strneq(var, "antGainCh", 9)) {
 621                 fprintf(fd, "%3d",
 622                     eepromN.modalHeader[curmode].antennaGainCh[atoi(var+9)]);
 623         } else if (strneq(var, "txRxAttenCh", 11)) {
 624                 fprintf(fd, "%3d",
 625                     eepromN.modalHeader[curmode].txRxAttenCh[atoi(var+11)]);
 626         } else if (strneq(var, "rxTxMarginCh", 12)) {
 627                 fprintf(fd, "%3d",
 628                     eepromN.modalHeader[curmode].rxTxMarginCh[atoi(var+12)]);
 629         } else if (streq(var, "xpdGain")) {
 630                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].xpdGain);
 631         } else if (strneq(var, "iqCalICh", 8)) {
 632                 fprintf(fd, "%3d",
 633                     eepromN.modalHeader[curmode].iqCalICh[atoi(var+8)]);
 634         } else if (strneq(var, "iqCalQCh", 8)) {
 635                 fprintf(fd, "%3d",
 636                     eepromN.modalHeader[curmode].iqCalQCh[atoi(var+8)]);
 637         } else if (streq(var, "pdGainOverlap")) {
 638                 printHalfDbmPower(fd, eepromN.modalHeader[curmode].pdGainOverlap);
 639         } else if (streq(var, "ob1")) {
 640                 fprintf(fd, "%1d", eeprom.ee_ob1);
 641         } else if (streq(var, "ob2")) {
 642                 fprintf(fd, "%1d", eeprom.ee_ob2);
 643         } else if (streq(var, "ob3")) {
 644                 fprintf(fd, "%1d", eeprom.ee_ob3);
 645         } else if (streq(var, "ob4")) {
 646                 fprintf(fd, "%1d", eeprom.ee_ob4);
 647         } else if (streq(var, "db1")) {
 648                 fprintf(fd, "%1d", eeprom.ee_db1);
 649         } else if (streq(var, "db2")) {
 650                 fprintf(fd, "%1d", eeprom.ee_db2);
 651         } else if (streq(var, "db3")) {
 652                 fprintf(fd, "%1d", eeprom.ee_db3);
 653         } else if (streq(var, "db4")) {
 654                 fprintf(fd, "%1d", eeprom.ee_db4);
 655         } else if (streq(var, "obFor24")) {
 656                 fprintf(fd, "%1d", eeprom.ee_obFor24);
 657         } else if (streq(var, "ob2GHz0")) {
 658                 fprintf(fd, "%1d", eeprom.ee_ob2GHz[0]);
 659         } else if (streq(var, "dbFor24")) {
 660                 fprintf(fd, "%1d", eeprom.ee_dbFor24);
 661         } else if (streq(var, "db2GHz0")) {
 662                 fprintf(fd, "%1d", eeprom.ee_db2GHz[0]);
 663         } else if (streq(var, "obFor24g")) {
 664                 fprintf(fd, "%1d", eeprom.ee_obFor24g);
 665         } else if (streq(var, "ob2GHz1")) {
 666                 fprintf(fd, "%1d", eeprom.ee_ob2GHz[1]);
 667         } else if (streq(var, "dbFor24g")) {
 668                 fprintf(fd, "%1d", eeprom.ee_dbFor24g);
 669         } else if (streq(var, "db2GHz1")) {
 670                 fprintf(fd, "%1d", eeprom.ee_db2GHz[1]);
 671         } else if (streq(var, "ob")) {
 672                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].ob);
 673         } else if (streq(var, "db")) {
 674                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].db);
 675         } else if (streq(var, "xpaBiasLvl")) {
 676                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].xpaBiasLvl);
 677         } else if (streq(var, "pwrDecreaseFor2Chain")) {
 678                 printHalfDbmPower(fd, eepromN.modalHeader[curmode].pwrDecreaseFor2Chain);
 679         } else if (streq(var, "pwrDecreaseFor3Chain")) {
 680                 printHalfDbmPower(fd, eepromN.modalHeader[curmode].pwrDecreaseFor3Chain);
 681         } else if (streq(var, "txFrameToDataStart")) {
 682                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].txFrameToDataStart);
 683         } else if (streq(var, "txFrameToPaOn")) {
 684                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].txFrameToPaOn);
 685         } else if (streq(var, "ht40PowerIncForPdadc")) {
 686                 fprintf(fd, "%3d", eepromN.modalHeader[curmode].ht40PowerIncForPdadc);
 687         } else if (streq(var, "checksum")) {
 688                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.checksum);
 689         } else if (streq(var, "length")) {
 690                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.length);
 691         } else if (streq(var, "regDmn0")) {
 692                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.regDmn[0]);
 693         } else if (streq(var, "regDmn1")) {
 694                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.regDmn[1]);
 695         } else if (streq(var, "txMask")) {
 696                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.txMask);
 697         } else if (streq(var, "rxMask")) {
 698                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.rxMask);
 699         } else if (streq(var, "rfSilent")) {
 700                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.rfSilent);
 701         } else if (streq(var, "btOptions")) {
 702                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.blueToothOptions);
 703         } else if (streq(var, "deviceCap")) {
 704                 fprintf(fd, "0x%04X", eepromN.baseEepHeader.deviceCap);
 705         } else if (strneq(var, "macaddr", 7)) {
 706                 fprintf(fd, "%02X",
 707                     eepromN.baseEepHeader.macAddr[atoi(var+7)]);
 708         } else if (streq(var, "opCapFlags")) {
 709                 fprintf(fd, "0x%02X", eepromN.baseEepHeader.opCapFlags);
 710         } else if (streq(var, "eepMisc")) {
 711                 fprintf(fd, "0x%02X", eepromN.baseEepHeader.eepMisc);
 712         } else if (strneq(var, "binBuildNumber", 14)) {
 713                 fprintf(fd, "%3d",
 714                     (eepromN.baseEepHeader.binBuildNumber >> (8*atoi(var+14)))
 715                     & 0xff);
 716         } else if (strneq(var, "custData", 8)) {
 717                 fprintf(fd, "%2.2X", eepromN.custData[atoi(var+8)]);
 718         } else if (streq(var, "xpd_mask")) {
 719                 if (IS_VERS(<, AR_EEPROM_VER5_0))
 720                         fprintf(fd, "0x%02x", pExpnPower->xpdMask);
 721                 else
 722                         fprintf(fd, "0x%02x", pRaw->xpd_mask);
 723         } else if (streq(var, "numChannels")) {
 724                 if (IS_VERS(<, AR_EEPROM_VER5_0))
 725                         fprintf(fd, "%2d", pExpnPower->numChannels);
 726                 else
 727                         fprintf(fd, "%2d", pRaw->numChannels);
 728         } else if (streq(var, "freq")) {
 729                 if (IS_VERS(<, AR_EEPROM_VER5_0))
 730                         fprintf(fd, "%4d", pExpnPower->pChannels[curchan]);
 731                 else
 732                         fprintf(fd, "%4d", pRaw->pChannels[curchan]);
 733         } else if (streq(var, "maxpow")) {
 734                 int16_t maxPower_t4;
 735                 if (IS_VERS(<, AR_EEPROM_VER5_0)) {
 736                         maxPower_t4 = pExpnPower->pDataPerChannel[curchan].maxPower_t4;
 737                 } else {
 738                         maxPower_t4 = pRaw->pDataPerChannel[curchan].maxPower_t4;
 739                         if (maxPower_t4 == 0)
 740                                 maxPower_t4 = getMaxPowerV5(&pRaw->pDataPerChannel[curchan]);
 741                 }
 742                 printQuarterDbmPower(fd, maxPower_t4);
 743         } else if (streq(var, "pd_gain")) {
 744                 fprintf(fd, "%4d", pRaw->pDataPerChannel[curchan].
 745                     pDataPerPDGain[curpdgain].pd_gain);
 746         } else if (strneq(var, "maxpwr", 6)) {
 747                 int vpd = atoi(var+6);
 748                 if (vpd < pRaw->pDataPerChannel[curchan].pDataPerPDGain[curpdgain].numVpd)
 749                         printQuarterDbmPower(fd, pRaw->pDataPerChannel[curchan].
 750                             pDataPerPDGain[curpdgain].pwr_t4[vpd]);
 751                 else
 752                         fprintf(fd, "     ");
 753         } else if (strneq(var, "pwr_t4_", 7)) {
 754                 printQuarterDbmPower(fd, pExpnPower->pDataPerChannel[curchan].
 755                     pDataPerXPD[singleXpd].pwr_t4[atoi(var+7)]);
 756         } else if (strneq(var, "Vpd", 3)) {
 757                 int vpd = atoi(var+3);
 758                 if (vpd < pRaw->pDataPerChannel[curchan].pDataPerPDGain[curpdgain].numVpd)
 759                         printVpd(fd, pRaw->pDataPerChannel[curchan].
 760                             pDataPerPDGain[curpdgain].Vpd[vpd]);
 761                 else
 762                         fprintf(fd, "     ");
 763         } else if (streq(var, "CTL")) {
 764                 fprintf(fd, "0x%2x", eeprom.ee_ctl[curctl] & 0xff);
 765         } else if (streq(var, "ctlType")) {
 766                 static const char *ctlType[16] = {
 767                     "11a base", "11b", "11g", "11a TURBO", "108g",
 768                     "2GHT20", "5GHT20", "2GHT40", "5GHT40",
 769                     "0x9", "0xa", "0xb", "0xc", "0xd", "0xe", "0xf",
 770                 };
 771                 fprintf(fd, "%8s", ctlType[eeprom.ee_ctl[curctl] & CTL_MODE_M]);
 772         } else if (streq(var, "ctlRD")) {
 773                 static const char *ctlRD[8] = {
 774                     "0x00", " FCC", "0x20", "ETSI",
 775                     " MKK", "0x50", "0x60", "0x70"
 776                 };
 777                 fprintf(fd, "%s", ctlRD[(eeprom.ee_ctl[curctl] >> 4) & 7]);
 778         } else if (strneq(var, "rdEdgePower", 11)) {
 779                 printEdgePower(fd, atoi(var+11));
 780         } else if (strneq(var, "rdEdgeFlag", 10)) {
 781                 printEdgeFlag(fd, atoi(var+10));
 782         } else if (strneq(var, "rdEdge", 6)) {
 783                 printEdge(fd, atoi(var+6));
 784         } else if (strneq(var, "testChannel", 11)) {
 785                 fprintf(fd, "%4d", pPowerInfo[atoi(var+11)].testChannel);
 786         } else if (strneq(var, "pwr6_24_", 8)) {
 787                 printHalfDbmPower(fd, pPowerInfo[atoi(var+8)].twicePwr6_24);
 788         } else if (strneq(var, "pwr36_", 6)) {
 789                 printHalfDbmPower(fd, pPowerInfo[atoi(var+6)].twicePwr36);
 790         } else if (strneq(var, "pwr48_", 6)) {
 791                 printHalfDbmPower(fd, pPowerInfo[atoi(var+6)].twicePwr48);
 792         } else if (strneq(var, "pwr54_", 6)) {
 793                 printHalfDbmPower(fd, pPowerInfo[atoi(var+6)].twicePwr54);
 794         } else if (strneq(var, "channelValue", 12)) {
 795                 fprintf(fd, "%4d", pDataPerChannel[atoi(var+12)].channelValue);
 796         } else if (strneq(var, "pcdacMin", 8)) {
 797                 fprintf(fd, "%02d", pDataPerChannel[atoi(var+8)].pcdacMin);
 798         } else if (strneq(var, "pcdacMax", 8)) {
 799                 fprintf(fd, "%02d", pDataPerChannel[atoi(var+8)].pcdacMax);
 800         } else if (strneq(var, "pcdac", 5)) {
 801                 if (IS_VERS(<, AR_EEPROM_VER4_0)) {
 802                         fprintf(fd, "%02d", pDataPerChannel[atoi(var+5)].
 803                             PcdacValues[curpcdac]);
 804                 } else if (IS_VERS(<, AR_EEPROM_VER5_0)) {
 805                         fprintf(fd, "%02d",
 806                             pExpnPower->pDataPerChannel[curchan].
 807                                 pDataPerXPD[singleXpd].pcdac[atoi(var+5)]);
 808                 } else
 809                         undef("pcdac");
 810         } else if (strneq(var, "pwrValue", 8)) {
 811                 printPcdacValue(fd,
 812                     pDataPerChannel[atoi(var+8)].PwrValues[curpcdac]);
 813         } else if (streq(var, "singleXpd")) {
 814                 fprintf(fd, "%2d", singleXpd);
 815         } else
 816                 warnx("line %u, unknown EEPROM variable \"%s\"", lineno, var);
 817 #undef strneq
 818 #undef streq
 819 }
 820
 821 static void
 822 ifmode(FILE *ftemplate, const char *mode)
 823 {
 824         if (strcasecmp(mode, "11a") == 0) {
 825                 if (IS_VERS(<, AR_EEPROM_VER14_2)) {
 826                         if (eeprom.ee_Amode)
 827                                 setmode(headerInfo11A);
 828                         else
 829                                 skipto(ftemplate, "endmode");
 830                         return;
 831                 }
 832                 if (IS_VERS(>=, AR_EEPROM_VER14_2)) {
 833                         if (eepromN.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11A)
 834                                 setmode(headerInfo11A);
 835                         else
 836                                 skipto(ftemplate, "endmode");
 837                         return;
 838                 }
 839         } else if (strcasecmp(mode, "11g") == 0) {
 840                 if (IS_VERS(<, AR_EEPROM_VER14_2)) {
 841                         if (eeprom.ee_Gmode)
 842                                 setmode(headerInfo11G);
 843                         else
 844                                 skipto(ftemplate, "endmode");
 845                         return;
 846                 }
 847                 if (IS_VERS(>=, AR_EEPROM_VER14_2)) {
 848                         if (eepromN.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11G)
 849                                 setmode(headerInfo11B);         /* NB: 2.4GHz */
 850                         else
 851                                 skipto(ftemplate, "endmode");
 852                         return;
 853                 }
 854         } else if (strcasecmp(mode, "11b") == 0) {
 855                 if (IS_VERS(<, AR_EEPROM_VER14_2)) {
 856                         if (eeprom.ee_Bmode)
 857                                 setmode(headerInfo11B);
 858                         else
 859                                 skipto(ftemplate, "endmode");
 860                         return;
 861                 }
 862         }
 863         warnx("line %d, unknown/unexpected mode \"%s\" ignored",
 864             lineno, mode);
 865         skipto(ftemplate, "endmode");
 866 }
 867
 868 static void
 869 parseTemplate(FILE *ftemplate, FILE *fd)
 870 {
 871         int c, i;
 872         char id[MAXID];
 873         long forchan, forpdgain, forctl, forpcdac;
 874
 875         lineno = 1;
 876         bol = 1;
 877         while ((c = getc(ftemplate)) != EOF) {
 878                 if (c == '#') {                 /* comment */
 879         skiptoeol:
 880                         while ((c = getc(ftemplate)) != EOF && c != '\n')
 881                                 ;
 882                         if (c == EOF)
 883                                 return;
 884                         lineno++;
 885                         bol = 1;
 886                         continue;
 887                 }
 888                 if (c == '.' && bol) {          /* .directive */
 889                         if (token(ftemplate, id, MAXID, ".directive") == EOF)
 890                                 return;
 891                         /* process directive */
 892                         if (strcasecmp(id, "ifmode") == 0) {
 893                                 skipws(ftemplate);
 894                                 if (token(ftemplate, id, MAXID, "id") == EOF)
 895                                         return;
 896                                 ifmode(ftemplate, id);
 897                         } else if (strcasecmp(id, "endmode") == 0) {
 898                                 /* XXX free malloc'd indirect data */
 899                                 curmode = -1;   /* NB: undefined */
 900                         } else if (strcasecmp(id, "forchan") == 0) {
 901                                 forchan = ftell(ftemplate) - sizeof("forchan");
 902                                 if (curchan == -1)
 903                                         curchan = 0;
 904                         } else if (strcasecmp(id, "endforchan") == 0) {
 905                                 if (++curchan < numChannels)
 906                                         fseek(ftemplate, forchan, SEEK_SET);
 907                                 else
 908                                         curchan = -1;
 909                         } else if (strcasecmp(id, "ifpdgain") == 0) {
 910                                 skipws(ftemplate);
 911                                 if (token(ftemplate, id, MAXID, "pdgain") == EOF)
 912                                         return;
 913                                 curlpdgain = strtoul(id, NULL, 0);
 914                                 if (curlpdgain >= pRaw->pDataPerChannel[curchan].numPdGains) {
 915                                         skipto(ftemplate, "endpdgain");
 916                                         curlpdgain = -1;
 917                                 } else
 918                                         curpdgain = pdgain(curlpdgain);
 919                         } else if (strcasecmp(id, "endpdgain") == 0) {
 920                                 curlpdgain = curpdgain = -1;
 921                         } else if (strcasecmp(id, "forpdgain") == 0) {
 922                                 forpdgain = ftell(ftemplate) - sizeof("forpdgain");
 923                                 if (curlpdgain == -1) {
 924                                         skipws(ftemplate);
 925                                         if (token(ftemplate, id, MAXID, "pdgain") == EOF)
 926                                                 return;
 927                                         curlpdgain = strtoul(id, NULL, 0);
 928                                         if (curlpdgain >= pRaw->pDataPerChannel[curchan].numPdGains) {
 929                                                 skipto(ftemplate, "endforpdgain");
 930                                                 curlpdgain = -1;
 931                                         } else
 932                                                 curpdgain = pdgain(curlpdgain);
 933                                 }
 934                         } else if (strcasecmp(id, "endforpdgain") == 0) {
 935                                 if (++curpdgain < pRaw->pDataPerChannel[curchan].numPdGains)
 936                                         fseek(ftemplate, forpdgain, SEEK_SET);
 937                                 else
 938                                         curpdgain = -1;
 939                         } else if (strcasecmp(id, "forpcdac") == 0) {
 940                                 forpcdac = ftell(ftemplate) - sizeof("forpcdac");
 941                                 if (curpcdac == -1)
 942                                         curpcdac = 0;
 943                         } else if (strcasecmp(id, "endforpcdac") == 0) {
 944                                 if (++curpcdac < pDataPerChannel[0].numPcdacValues)
 945                                         fseek(ftemplate, forpcdac, SEEK_SET);
 946                                 else
 947                                         curpcdac = -1;
 948                         } else if (strcasecmp(id, "forctl") == 0) {
 949                                 forctl = ftell(ftemplate) - sizeof("forchan");
 950                                 if (curctl == -1)
 951                                         curctl = nextctl(0);
 952                         } else if (strcasecmp(id, "endforctl") == 0) {
 953                                 curctl = nextctl(curctl+1);
 954                                 if (curctl != -1)
 955                                         fseek(ftemplate, forctl, SEEK_SET);
 956                         } else {
 957                                 warnx("line %d, unknown directive %s ignored",
 958                                     lineno, id);
 959                         }
 960                         goto skiptoeol;
 961                 }
 962                 if (c == '$') {                 /* $variable reference */
 963                         if (token(ftemplate, id, MAXID, "$var") == EOF)
 964                                 return;
 965                         /* XXX not valid if variable depends on curmode */
 966                         eevar(fd, id);
 967                         continue;
 968                 }
 969                 if (c == '\\') {                /* escape next character */
 970                         c = getc(ftemplate);
 971                         if (c == EOF)
 972                                 return;
 973                 }
 974                 fputc(c, fd);
 975                 bol = (c == '\n');
 976                 if (bol)
 977                         lineno++;
 978         }
 979 }