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